63 lines
2.0 KiB
TypeScript
63 lines
2.0 KiB
TypeScript
import {
|
|
joinTypes, typeOfDependency, Dependency,
|
|
} from '../core/Dispatcher.js'
|
|
import type {
|
|
OneOp, ZeroOp, NanOp, ReOp, ZeroType, OneType, NaNType, Depends
|
|
} from '../interfaces/type.js'
|
|
|
|
export type Complex<T> = { re: T; im: T; }
|
|
|
|
export const Complex_type = {
|
|
test: <T>(dep: { testT: (z: unknown) => z is T }) =>
|
|
(z: unknown): z is Complex<T> =>
|
|
typeof z === 'object' && z != null && 're' in z && 'im' in z
|
|
&& dep.testT(z['re']) && dep.testT(z['im']),
|
|
infer: (dep: typeOfDependency) =>
|
|
(z: Complex<unknown>) => joinTypes(dep.typeOf(z.re), dep.typeOf(z.im)),
|
|
from: {
|
|
T: <T>(dep: Dependency<'zero', [T]>) => (t: T) =>
|
|
({ re: t, im: dep.zero(t) }),
|
|
Complex: <U, T>(dep: { convert: (from: U) => T }) =>
|
|
(z: Complex<U>) => ({ re: dep.convert(z.re), im: dep.convert(z.im) })
|
|
}
|
|
}
|
|
|
|
declare module "../interfaces/type" {
|
|
interface AssociatedTypes<T> {
|
|
Complex: T extends Complex<infer R> ? {
|
|
type: Complex<R>
|
|
zero: Complex<ZeroType<R>>
|
|
one: Complex<OneType<R> | ZeroType<R>>
|
|
nan: Complex<NaNType<R>>
|
|
real: RealType<R>
|
|
} : never
|
|
}
|
|
}
|
|
|
|
export type ComplexOp<T> = {op?: 'complex', (a: T, b?: T): Complex<T>}
|
|
|
|
export const complex =
|
|
<T>(dep: Depends<ZeroOp<T>>): ComplexOp<T | ZeroType<T>> =>
|
|
(a, b) => ({re: a, im: b || dep.zero(a)})
|
|
|
|
export const zero =
|
|
<T>(dep: Depends<ZeroOp<T>> & Depends<ComplexOp<ZeroType<T>>>):
|
|
ZeroOp<Complex<T>> =>
|
|
z => dep.complex(dep.zero(z.re), dep.zero(z.im))
|
|
|
|
export const one =
|
|
<T>(dep: Depends<OneOp<T>>
|
|
& Depends<ZeroOp<T>>
|
|
& Depends<ComplexOp<ZeroType<T>|OneType<T>>>):
|
|
OneOp<Complex<T>> =>
|
|
z => dep.complex(dep.one(z.re), dep.zero(z.im))
|
|
|
|
export const nan =
|
|
<T>(dep: Depends<NanOp<T>> & Depends<ComplexOp<NaNType<T>>>):
|
|
NanOp<Complex<T>> =>
|
|
z => dep.complex(dep.nan(z.re), dep.nan(z.im))
|
|
|
|
export const re =
|
|
<T>(dep: Depends<ReOp<T>>): ReOp<Complex<T>> =>
|
|
z => dep.re(z.re)
|