feat: Add generic operation square and numeric unequal (#4)

Co-authored-by: Jos de Jong <wjosdejong@gmail.com>
Co-authored-by: Glen Whitney <glen@studioinfinity.org>
Reviewed-on: #4
This commit is contained in:
Glen Whitney 2022-12-22 16:12:36 +00:00
parent fbec410c42
commit 8c06c8f36e
6 changed files with 84 additions and 11 deletions

View File

@ -30,6 +30,19 @@ export interface ComplexReturn<Params> {
: Params extends BBinary<infer B> ? Complex<B> // binary case
: never
// alternatively if it seems better; each definition is simpler, but at
// the cost of having two keys here:
// complex_unary: Params extends [infer R] ? Complex<R> : never
// complex_binary: Params extends BBinary<infer R> ? Complex<R> : never
// There is actually a subtlety here that complex_unary really only works
// on real types that include their own zero value, so it should really be
// complex_unary: Params extends [infer R]
// ? ImpReturns<'zero', [R]> extends R ? Complex<R> : never
// : never
// and that might actually simplify some of the typings of other operations,
// but we'll leave such fine tuning til later, if we adopt this scheme
zero: Params extends [infer Z] // unary
? Z extends Complex<infer T> // of a Complex parameter
? ImpReturns<'zero', T> extends T ? Z : never // that has its real 0

View File

@ -1,2 +1,3 @@
export * from './numbers/all.js'
export * from './Complex/all.js'
export * from './generic/all.js'

10
src/generic/all.ts Normal file
View File

@ -0,0 +1,10 @@
import { ForType } from '../core/Dispatcher.js'
import { GenericReturn } from './type.js'
import * as generic from './arithmetic.js'
export { generic }
declare module "../core/Dispatcher" {
interface ReturnTypes<Params>
extends ForType<'generic', GenericReturn<Params>> { }
}

39
src/generic/arithmetic.ts Normal file
View File

@ -0,0 +1,39 @@
import {Dependency, ImpType, ImpReturns} from "../core/Dispatcher";
declare module "./type" {
interface GenericReturn<Params> {
// Jos: not sure how to define this or why it is needed
// square: Signature<Params, [T], T>
// square: ConservativeUnary<Params, T>
// square: Params extends [infer R]
// ? R extends number ? UnderlyingReal<R> : never
// : never
// The type of `square` in this interface, instantiated with the type
// Params of a parameter list, needs to be the return type of the
// operation `square` on those parameters. In other words, `square` gives
// a type transformer from the tuple type of its parameters to its return
// type.
// That's how Dispatcher knows what the return type will be in
// `Dependency<'square', [bigint]>`, for example: it instantiates
// GenericReturn with Params equal to [bigint] and then grabs the
// type of the `square` property. Hence we write:
square: Params extends [infer T] // square only takes 1 arbitrary parameter
? ImpReturns<'multiply', [T, T]> // and returns whatever multiply does
: never; // otherwise if not a single argument, this implementation
// doesn't handle it
// If square had more than one implementation in this collection, we could
// either add more conditional clauses to the above type transformer
// as I did in Complex/type.ts for `complex`, or we could have two
// different keys that both start with `square_` and Dispatcher will
// check both (as I have now done in comments in Complex/type.ts and
// verified that also works).
}
}
export const square =
<T>(dep: Dependency<'multiply', [T, T]>):
ImpType<'square', [T]> =>
z => dep.multiply(z, z)

3
src/generic/type.ts Normal file
View File

@ -0,0 +1,3 @@
export interface GenericReturn<Params> {
}

View File

@ -1,27 +1,34 @@
import {configDependency} from '../core/Config.js'
import {Signature, ImpType} from '../core/Dispatcher.js'
import {Signature, ImpType, Dependency} from '../core/Dispatcher.js'
const DBL_EPSILON = Number.EPSILON || 2.2204460492503130808472633361816E-16
declare module "./type" {
interface NumbersReturn<Params> {
equal: Signature<Params, [number, number], boolean>
unequal: Signature<Params, [number, number], boolean>
}
}
export const equal =
(dep: configDependency): ImpType<'equal', [number, number]> =>
(x, y) => {
const eps = dep.config.epsilon
if (eps === null || eps === undefined) return x === y
if (x === y) return true
if (isNaN(x) || isNaN(y)) return false
(x, y) => {
const eps = dep.config.epsilon
if (eps === null || eps === undefined) return x === y
if (x === y) return true
if (isNaN(x) || isNaN(y)) return false
if (isFinite(x) && isFinite(y)) {
const diff = Math.abs(x - y)
if (diff < DBL_EPSILON) return true
return diff <= Math.max(Math.abs(x), Math.abs(y)) * eps
if (isFinite(x) && isFinite(y)) {
const diff = Math.abs(x - y)
if (diff < DBL_EPSILON) return true
return diff <= Math.max(Math.abs(x), Math.abs(y)) * eps
}
return false
}
return false
export const unequal = (dep: Dependency<'equal', [number, number]>):
ImpType<'unequal', [number, number]> =>
(x, y) => {
return !dep.equal(x, y)
}