ziko 1.4.0 → 1.5.0

package/src/math/functions/index.d.ts

@@ -1,140 +1,147 @@
-import type { Complex } from "../complex/index.js";
-import type { MapfunResult, Mappable } from "../utils/mapfun.js";
+export type * from './arithmetic/index.d.ts'
+export type * from './conversions/index.d.ts'
+export type * from './logic/index.d.ts'
+export type * from './utils/index.d.ts'
+export type * from './mapfun/index.d.ts'
+export type * from './ufunc/index.d.ts'
 
-/* -------------------- MapfunWrap -------------------- */
+// import type { Complex } from "../complex/index.js";
+// import type { MapfunResult, Mappable } from "../utils/mapfun.js";
 
-type MapfunWrap<F extends (x: any) => any, A extends Mappable[]> =
-    A["length"] extends 1
-        ? MapfunResult<F, A[0]>
-        : { [K in keyof A]: MapfunResult<F, A[K]> };
+// /* -------------------- MapfunWrap -------------------- */
 
+// type MapfunWrap<F extends (x: any) => any, A extends Mappable[]> =
+//     A["length"] extends 1
+//         ? MapfunResult<F, A[0]>
+//         : { [K in keyof A]: MapfunResult<F, A[K]> };
 
-/* -------------------- mapfun-based simple operators -------------------- */
 
-export declare function abs<A extends Mappable[]>(...x: A):
-    MapfunWrap<typeof Math.abs, A>;
+// /* -------------------- mapfun-based simple operators -------------------- */
 
-export declare function sqrt<A extends Mappable[]>(...x: A):
-    MapfunWrap<typeof Math.sqrt, A>;
+// export declare function abs<A extends Mappable[]>(...x: A):
+//     MapfunWrap<typeof Math.abs, A>;
 
-export declare function e<A extends Mappable[]>(...x: A):
-    MapfunWrap<typeof Math.exp, A>;
+// export declare function sqrt<A extends Mappable[]>(...x: A):
+//     MapfunWrap<typeof Math.sqrt, A>;
 
-export declare function ln<A extends Mappable[]>(...x: A):
-    MapfunWrap<typeof Math.log, A>;
+// export declare function e<A extends Mappable[]>(...x: A):
+//     MapfunWrap<typeof Math.exp, A>;
 
-/* ---- Fixed-based operators ---- */
+// export declare function ln<A extends Mappable[]>(...x: A):
+//     MapfunWrap<typeof Math.log, A>;
 
-export declare function cos<A extends Mappable[]>(...x: A):
-    MapfunWrap<typeof Math.cos, A>;
+// /* ---- Fixed-based operators ---- */
 
-export declare function sin<A extends Mappable[]>(...x: A):
-    MapfunWrap<Math.sin, A>;
+// export declare function cos<A extends Mappable[]>(...x: A):
+//     MapfunWrap<typeof Math.cos, A>;
 
-export declare function tan<A extends Mappable[]>(...x: A):
-    MapfunWrap<Math.tan, A>;
+// export declare function sin<A extends Mappable[]>(...x: A):
+//     MapfunWrap<Math.sin, A>;
 
-export declare function sec<A extends Mappable[]>(...x: A):
-    MapfunWrap<Math.sec, A>;
+// export declare function tan<A extends Mappable[]>(...x: A):
+//     MapfunWrap<Math.tan, A>;
 
-export declare function sinc<A extends Mappable[]>(...x: A):
-    MapfunWrap<Math.sinc, A>;
+// export declare function sec<A extends Mappable[]>(...x: A):
+//     MapfunWrap<Math.sec, A>;
 
-export declare function csc<A extends Mappable[]>(...x: A):
-    MapfunWrap<Math.csc, A>;
+// export declare function sinc<A extends Mappable[]>(...x: A):
+//     MapfunWrap<Math.sinc, A>;
 
-export declare function cot<A extends Mappable[]>(...x: A):
-    MapfunWrap<Math.cot, A>;
+// export declare function csc<A extends Mappable[]>(...x: A):
+//     MapfunWrap<Math.csc, A>;
 
-export declare function acos<A extends Mappable[]>(...x: A):
-    MapfunWrap<Math.acos, A>;
+// export declare function cot<A extends Mappable[]>(...x: A):
+//     MapfunWrap<Math.cot, A>;
 
-export declare function asin<A extends Mappable[]>(...x: A):
-    MapfunWrap<Math.asin, A>;
+// export declare function acos<A extends Mappable[]>(...x: A):
+//     MapfunWrap<Math.acos, A>;
 
-export declare function atan<A extends Mappable[]>(...x: A):
-    MapfunWrap<Math.atan, A>;
+// export declare function asin<A extends Mappable[]>(...x: A):
+//     MapfunWrap<Math.asin, A>;
 
-export declare function acot<A extends Mappable[]>(...x: A):
-    MapfunWrap<Math.acot, A>;
+// export declare function atan<A extends Mappable[]>(...x: A):
+//     MapfunWrap<Math.atan, A>;
 
-export declare function cosh<A extends Mappable[]>(...x: A):
-    MapfunWrap<Math.cosh, A>;
+// export declare function acot<A extends Mappable[]>(...x: A):
+//     MapfunWrap<Math.acot, A>;
 
-export declare function sinh<A extends Mappable[]>(...x: A):
-    MapfunWrap<Math.sinh, A>;
+// export declare function cosh<A extends Mappable[]>(...x: A):
+//     MapfunWrap<Math.cosh, A>;
 
-export declare function tanh<A extends Mappable[]>(...x: A):
-    MapfunWrap<Math.tanh, A>;
+// export declare function sinh<A extends Mappable[]>(...x: A):
+//     MapfunWrap<Math.sinh, A>;
 
-export declare function coth<A extends Mappable[]>(...x: A):
-    MapfunWrap<Math.coth, A>;
+// export declare function tanh<A extends Mappable[]>(...x: A):
+//     MapfunWrap<Math.tanh, A>;
 
-export declare function acosh<A extends Mappable[]>(...x: A):
-    MapfunWrap<Math.acosh, A>;
+// export declare function coth<A extends Mappable[]>(...x: A):
+//     MapfunWrap<Math.coth, A>;
 
-export declare function asinh<A extends Mappable[]>(...x: A):
-    MapfunWrap<Math.asinh, A>;
+// export declare function acosh<A extends Mappable[]>(...x: A):
+//     MapfunWrap<Math.acosh, A>;
 
-export declare function atanh<A extends Mappable[]>(...x: A):
-    MapfunWrap<Math.atanh, A>;
+// export declare function asinh<A extends Mappable[]>(...x: A):
+//     MapfunWrap<Math.asinh, A>;
 
-/* ---- Math wrappers ---- */
+// export declare function atanh<A extends Mappable[]>(...x: A):
+//     MapfunWrap<Math.atanh, A>;
 
-export declare function ceil<A extends Mappable[]>(...x: A):
-    MapfunWrap<typeof Math.ceil, A>;
+// /* ---- Math wrappers ---- */
 
-export declare function floor<A extends Mappable[]>(...x: A):
-    MapfunWrap<typeof Math.floor, A>;
+// export declare function ceil<A extends Mappable[]>(...x: A):
+//     MapfunWrap<typeof Math.ceil, A>;
 
-export declare function round<A extends Mappable[]>(...x: A):
-    MapfunWrap<typeof Math.round, A>;
+// export declare function floor<A extends Mappable[]>(...x: A):
+//     MapfunWrap<typeof Math.floor, A>;
 
-export declare function sign<A extends Mappable[]>(...x: A):
-    MapfunWrap<typeof Math.sign, A>;
+// export declare function round<A extends Mappable[]>(...x: A):
+//     MapfunWrap<typeof Math.round, A>;
 
-export declare function sig<A extends Mappable[]>(...x: A):
-    MapfunWrap<(n: number) => number, A>;
+// export declare function sign<A extends Mappable[]>(...x: A):
+//     MapfunWrap<typeof Math.sign, A>;
 
-export declare function fact<A extends Mappable[]>(...x: A):
-    MapfunWrap<(n: number) => number, A>;
+// export declare function sig<A extends Mappable[]>(...x: A):
+//     MapfunWrap<(n: number) => number, A>;
 
+// export declare function fact<A extends Mappable[]>(...x: A):
+//     MapfunWrap<(n: number) => number, A>;
 
-/* -------------------- pow -------------------- */
 
-export declare function pow(x: number, n: number): number;
-export declare function pow(x: number, n: Complex): Complex;
-export declare function pow(x: number, n: Mappable): any;
+// /* -------------------- pow -------------------- */
 
-export declare function pow(x: Complex, n: number): Complex;
-export declare function pow(x: Complex, n: Complex): Complex;
-export declare function pow(x: Complex, n: Mappable): any;
+// export declare function pow(x: number, n: number): number;
+// export declare function pow(x: number, n: Complex): Complex;
+// export declare function pow(x: number, n: Mappable): any;
 
-export declare function pow(x: Mappable[], n: number): any[];
-export declare function pow(x: Mappable[], n: Mappable[]): any[];
+// export declare function pow(x: Complex, n: number): Complex;
+// export declare function pow(x: Complex, n: Complex): Complex;
+// export declare function pow(x: Complex, n: Mappable): any;
 
+// export declare function pow(x: Mappable[], n: number): any[];
+// export declare function pow(x: Mappable[], n: Mappable[]): any[];
 
-/* -------------------- sqrtn -------------------- */
 
-export declare function sqrtn(x: number, n: number): number;
-export declare function sqrtn(x: number, n: Mappable): any;
+// /* -------------------- sqrtn -------------------- */
 
-export declare function sqrtn(x: Complex, n: number): Complex;
-export declare function sqrtn(x: Complex, n: Mappable): any;
+// export declare function sqrtn(x: number, n: number): number;
+// export declare function sqrtn(x: number, n: Mappable): any;
 
-export declare function sqrtn(x: Mappable[], n: number): any[];
-export declare function sqrtn(x: Mappable[], n: Mappable[]): any[];
+// export declare function sqrtn(x: Complex, n: number): Complex;
+// export declare function sqrtn(x: Complex, n: Mappable): any;
 
+// export declare function sqrtn(x: Mappable[], n: number): any[];
+// export declare function sqrtn(x: Mappable[], n: Mappable[]): any[];
 
-/* -------------------- atan2 -------------------- */
 
-export declare function atan2(x: number, y: number, rad?: boolean): number;
-export declare function atan2(x: number, y: Mappable, rad?: boolean): any;
-export declare function atan2(x: Mappable, y: number, rad?: boolean): any;
-export declare function atan2(x: Mappable[], y: Mappable[], rad?: boolean): any[];
+// /* -------------------- atan2 -------------------- */
 
+// export declare function atan2(x: number, y: number, rad?: boolean): number;
+// export declare function atan2(x: number, y: Mappable, rad?: boolean): any;
+// export declare function atan2(x: Mappable, y: number, rad?: boolean): any;
+// export declare function atan2(x: Mappable[], y: Mappable[], rad?: boolean): any[];
 
-/* -------------------- hypot -------------------- */
 
-export declare function hypot(...x: number[]): number;
-export declare function hypot(...x: Mappable[]): any;
+// /* -------------------- hypot -------------------- */
+
+// export declare function hypot(...x: number[]): number;
+// export declare function hypot(...x: Mappable[]): any;

package/src/math/functions/logic/index.d.ts

@@ -1,11 +1,53 @@
 import type { Complex } from "../../complex/index.d.ts";
-// import type { Matrix } from "../../matrix/index.d.ts";
 import { Matrix } from '../../../../src/math/matrix/index.js'
 
-export declare const not: (x: 0 | 1 | Complex | Matrix) => 0 | 1 | Complex | Matrix;
-export declare const and: (...x: (0 | 1 | Complex | Matrix)[]) => 0 | 1 | Complex | Matrix;
-export declare const or: (...x: (0 | 1 | Complex | Matrix)[]) => 0 | 1 | Complex | Matrix;
-export declare const xor: (...x: (0 | 1 | Complex | Matrix)[]) => 0 | 1 | Complex | Matrix;
-export declare const nand: (...x: (0 | 1 | Complex | Matrix)[]) => 0 | 1 | Complex | Matrix;
-export declare const nor: (...x: (0 | 1 | Complex | Matrix)[]) => 0 | 1 | Complex | Matrix;
-export declare const xnor: (...x: (0 | 1 | Complex | Matrix)[]) => 0 | 1 | Complex | Matrix;
+export type LogicValue = 0 | 1 | Complex | Matrix;
+
+/**
+ * Logical NOT operation.
+ */
+export declare const not: (
+    x: LogicValue
+) => LogicValue;
+
+/**
+ * Logical AND operation.
+ */
+export declare const and: (
+    ...x: LogicValue[]
+) => LogicValue;
+
+/**
+ * Logical OR operation.
+ */
+export declare const or: (
+    ...x: LogicValue[]
+) => LogicValue;
+
+/**
+ * Logical XOR operation.
+ */
+export declare const xor: (
+    ...x: LogicValue[]
+) => LogicValue;
+
+/**
+ * Logical NAND operation.
+ */
+export declare const nand: (
+    ...x: LogicValue[]
+) => LogicValue;
+
+/**
+ * Logical NOR operation.
+ */
+export declare const nor: (
+    ...x: LogicValue[]
+) => LogicValue;
+
+/**
+ * Logical XNOR operation.
+ */
+export declare const xnor: (
+    ...x: LogicValue[]
+) => LogicValue;

package/src/math/functions/logic/index.js

@@ -1,4 +1,4 @@
-const not = x => {
+export const not = x => {
     if(x.isComplex?.()) return new x.constructor(not(x.a), not(x.b))
     if(x.isMatrix?.()) return new x.constructor(x.rows, x.cols, x.arr.flat(1).map(not))
     return + !x;

package/src/math/functions/mapfun/index.d.ts

@@ -1,87 +1,53 @@
-import { Complex } from "../../../src/math/Complex/index.js";
-import { Matrix } from "../../../src/math/matrix/index.js";
+type TypedArray =
+  | Int8Array
+  | Uint8Array
+  | Uint8ClampedArray
+  | Int16Array
+  | Uint16Array
+  | Int32Array
+  | Uint32Array
+  | Float32Array
+  | Float64Array
+  | BigInt64Array
+  | BigUint64Array;
 
 /**
- * Objects that behave like primitives for mapfun,
- * meaning fun(x) is applied directly without recursion.
+ * Custom mapped type that recursively applies leaf transformation `R`
+ * while strictly maintaining structure (tuples, arrays, sets, maps, objects).
  */
-export interface MapfunPrimitiveLike {
-    __mapfun__?: boolean;
-}
-
-export type PrimitiveLike =
-    | number
-    | boolean
-    | string
-    | bigint
-    | undefined
-    | null
-    | { readonly __mapfun__: boolean };
-
-export type Mappable =
-    | number
-    | string
-    | boolean
-    | bigint
-    | undefined
-    | null
-    | Matrix
-    | MapfunPrimitiveLike
-    | any[]
-    | Set<any>
-    | Map<any, any>
-    | object;
-
-/**
- * mapfun transform rules
- */
-export type MapfunResult<F extends (x: any) => any, T> =
-    // Objects with __mapfun__ → treat as primitive (call fun(x))
-    // T extends MapfunPrimitiveLike
-    //     ? ReturnType<F> :
-
-    // Matrix → always return Matrix (your JS logic rebuilds a new Matrix)
-    
-    T extends PrimitiveLike 
-        ? ReturnType<F> :
-    // T extends Complex
-    //     ? T :
-    T extends Matrix
-        ? T :
-
-    // Array → deep-map
+export type MapFunResult<T, R> =
+  // 1. Primitive types or explicit mapfun override tag
+  T extends number | string | boolean | bigint | symbol | null | undefined | { __mapfun__?: any }
+    ? R
+    : // 2. Preserve Tuple length and element order precisely
+    T extends [infer Head, ...infer Tail]
+    ? [MapFunResult<Head, R>, ...MapFunResult<Tail, R>]
+    : // 3. Standard homogeneous Arrays
     T extends Array<infer U>
-        ? Array<MapfunResult<F, U>> :
-
-    // Set → deep-map
+    ? Array<MapFunResult<U, R>>
+    : // 4. TypedArray views
+    T extends TypedArray
+    ? T
+    : // 5. Sets
     T extends Set<infer U>
-        ? Set<MapfunResult<F, U>> :
-
-    // Map → deep-map values
+    ? Set<MapFunResult<U, R>>
+    : // 6. Maps
     T extends Map<infer K, infer V>
-        ? Map<K, MapfunResult<F, V>> :
-
-    // Other objects → recursively map fields
+    ? Map<K, MapFunResult<V, R>>
+    : // 7. Matrix objects
+    T extends { isMatrix: () => boolean }
+    ? T
+    : // 8. Plain Objects (preserve property keys)
     T extends object
-        ? { [K in keyof T]: MapfunResult<F, T[K]> } :
-
-    // Primitive
-    ReturnType<F>;
-
-/**
- * If only one argument → return mapped value
- * If multiple → return tuple of mapped values
- */
-type UnwrapSingle<T extends unknown[]> =
-    T extends [infer U] ? U : { [K in keyof T]: T[K] };
-
-/**
- * mapfun main declaration
- */
-export declare function mapfun<
-    F extends (x: any) => any,
-    A extends Mappable[]
->(
-    fun: F,
-    ...values: A
-): UnwrapSingle<{ [K in keyof A]: MapfunResult<F, A[K]> }>;
+    ? { [K in keyof T]: MapFunResult<T[K], R> }
+    : R;
+
+export function mapfun<T, R>(
+  fun: (value: any) => R,
+  x: T
+): MapFunResult<T, R>;
+
+export function mapfun<T extends any[], R>(
+  fun: (value: any) => R,
+  ...X: T
+): { [K in keyof T]: MapFunResult<T[K], R> };

package/src/math/functions/mapfun/index.d.ts.txt

@@ -0,0 +1,162 @@
+// import { Complex } from "../../../src/math/Complex/index.js";
+// import { Matrix } from "../../../src/math/matrix/index.js";
+
+// /**
+//  * Objects that behave like primitives for mapfun,
+//  * meaning fun(x) is applied directly without recursion.
+//  */
+// export interface MapfunPrimitiveLike {
+//     __mapfun__?: boolean;
+// }
+
+// export type PrimitiveLike =
+//     | number
+//     | boolean
+//     | string
+//     | bigint
+//     | undefined
+//     | null
+//     | { readonly __mapfun__: boolean };
+
+// export type Mappable =
+//     | number
+//     | string
+//     | boolean
+//     | bigint
+//     | undefined
+//     | null
+//     | Matrix
+//     | MapfunPrimitiveLike
+//     | any[]
+//     | Set<any>
+//     | Map<any, any>
+//     | object;
+
+// /**
+//  * mapfun transform rules
+//  */
+// export type MapfunResult<F extends (x: any) => any, T> =
+//     // Objects with __mapfun__ → treat as primitive (call fun(x))
+//     // T extends MapfunPrimitiveLike
+//     //     ? ReturnType<F> :
+
+//     // Matrix → always return Matrix (your JS logic rebuilds a new Matrix)
+    
+//     T extends PrimitiveLike 
+//         ? ReturnType<F> :
+//     // T extends Complex
+//     //     ? T :
+//     T extends Matrix
+//         ? T :
+
+//     // Array → deep-map
+//     T extends Array<infer U>
+//         ? Array<MapfunResult<F, U>> :
+
+//     // Set → deep-map
+//     T extends Set<infer U>
+//         ? Set<MapfunResult<F, U>> :
+
+//     // Map → deep-map values
+//     T extends Map<infer K, infer V>
+//         ? Map<K, MapfunResult<F, V>> :
+
+//     // Other objects → recursively map fields
+//     T extends object
+//         ? { [K in keyof T]: MapfunResult<F, T[K]> } :
+
+//     // Primitive
+//     ReturnType<F>;
+
+// /**
+//  * If only one argument → return mapped value
+//  * If multiple → return tuple of mapped values
+//  */
+// type UnwrapSingle<T extends unknown[]> =
+//     T extends [infer U] ? U : { [K in keyof T]: T[K] };
+
+// /**
+//  * mapfun main declaration
+//  */
+// export declare function mapfun<
+//     F extends (x: any) => any,
+//     A extends Mappable[]
+// >(
+//     fun: F,
+//     ...values: A
+// ): UnwrapSingle<{ [K in keyof A]: MapfunResult<F, A[K]> }>;
+
+
+export type Primitive =
+    string |
+    number |
+    boolean |
+    bigint |
+    symbol |
+    null |
+    undefined;
+
+export interface MapfunCompatible<T = any> {
+    __mapfun__?: boolean;
+}
+
+export interface ComplexLike {
+    isComplex(): boolean;
+}
+
+export interface MatrixLike {
+    rows: number;
+    cols: number;
+
+    isMatrix(): boolean;
+}
+
+export type Mappable<T = any> =
+    | T
+    | Primitive
+    | Mappable<T>[]
+    | ArrayLike<T>
+    | Set<Mappable<T>>
+    | Map<any, Mappable<T>>
+    | MapfunCompatible<T>
+    | ComplexLike
+    | MatrixLike
+    | Record<string, Mappable<T>>;
+
+
+/**
+ * Applies a function recursively to values inside
+ * arrays, typed arrays, sets, maps, objects,
+ * complex values and matrices.
+ *
+ * @param fun Transformation function.
+ * @param X Values to transform.
+ *
+ * @example
+ * mapfun(x => x * 2, [1,2,3])
+ * // [2,4,6]
+ */
+export declare function mapfun<T, R>(
+    fun: (value: T) => R,
+    x: Mappable<T>
+): R;
+
+export declare function mapfun<T, R>(
+    fun: (value: T) => R,
+    x: Mappable<T>,
+    ...X: Mappable<T>[]
+): R[];
+
+
+/**
+ * Applies a function to supported mathematical structures.
+ *
+ * Handles Complex and Matrix instances specially.
+ *
+ * @param x Input value.
+ * @param fn Transformation function.
+ */
+export declare function apply_fun<T, R>(
+    x: Mappable<T>,
+    fn: (value: T) => R
+): Mappable<R>;