ziko 1.4.0 → 1.5.0

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

@@ -1,54 +1,231 @@
+import type { Matrix } from "../matrix/index.js";
+
+/**
+ * Represents a complex number.
+ *
+ * A complex number is represented as:
+ * a + bi
+ */
 export declare class Complex {
     a: number;
     b: number;
 
     constructor(a?: number, b?: number);
     constructor(c: Complex);
-    constructor(a: 
-        { a: number; b: number } | 
-        { a: number; z: number } | 
-        { a: number; phi: number } | 
-        { b: number; z: number } | 
-        { b: number; phi: number } | 
-        { z: number; phi: number }
+    constructor(value:
+        | { a: number; b: number }
+        | { a: number; z: number }
+        | { a: number; phi: number }
+        | { b: number; z: number }
+        | { b: number; phi: number }
+        | { z: number; phi: number }
     );
-    constructor();
 
+    /**
+     * Used by mapfun to identify complex values.
+     */
+    readonly __mapfun__: boolean;
+
+    /**
+     * Checks whether this value is a Complex instance.
+     */
     isComplex(): true;
+
+    /**
+     * Converts the complex number to a string.
+     */
     toString(): string;
-    readonly __mapfun__ : boolean
-    readonly clone: Complex;
+
+    /**
+     * Serializes the complex number.
+     */
+    serialize(): string;
+
+    /**
+     * Deserializes a serialized complex number.
+     */
+    static deserialize(json: string | object): Complex | TypeError;
+
+    /**
+     * Rounds real and imaginary parts.
+     *
+     * @param n Number of decimal digits.
+     */
+    toFixed(n: number): this;
+
+    /**
+     * Formats real and imaginary parts with precision.
+     *
+     * @param n Number of significant digits.
+     */
+    toPrecision(n: number): this;
+
+    /**
+     * Creates a copy of this complex number.
+     */
+    clone(): Complex;
+
+    /**
+     * Magnitude of the complex number.
+     */
     readonly z: number;
+
+    /**
+     * Phase angle in radians.
+     */
     readonly phi: number;
+
+    /**
+     * Complex conjugate.
+     */
     readonly conj: Complex;
+
+    /**
+     * Multiplicative inverse.
+     */
     readonly inv: Complex;
+
+    /**
+     * Exponential representation [magnitude, phase].
+     */
+    readonly expo: [number, number];
+
+    /**
+     * Adds complex numbers.
+     */
+    add(...c: (number | Complex)[]): this;
+
+    /**
+     * Subtracts complex numbers.
+     */
+    sub(...c: (number | Complex)[]): this;
+
+    /**
+     * Multiplies complex numbers.
+     */
+    mul(...c: (number | Complex)[]): this;
+
+    /**
+     * Divides complex numbers.
+     */
+    div(...c: (number | Complex)[]): this;
+
+    /**
+     * Computes modulo.
+     */
+    modulo(...c: (number | Complex)[]): this;
+
+    /**
+     * Raises the complex number to a power.
+     */
+    pow(...c: (number | Complex)[]): this;
+
+    /**
+     * Calculates the nth root.
+     */
+    nthr(n?: number): Complex;
+
+    /**
+     * Square root.
+     */
     readonly sqrt: Complex;
+
+    /**
+     * Cube root.
+     */
     readonly cbrt: Complex;
+
+    /**
+     * Complex logarithm.
+     */
     readonly log: Complex;
+
+    /**
+     * Complex cosine.
+     */
     readonly cos: Complex;
+
+    /**
+     * Complex sine.
+     */
     readonly sin: Complex;
-    readonly tan: Complex;
-    expo: [number, number];
 
-    add(...z: (number | Complex)[]): this;
-    sub(...z: (number | Complex)[]): this;
-    mul(...z: (number | Complex)[]): this;
-    div(...z: (number | Complex)[]): this;
-    pow(n: number): this;
-    nthr(n?: number): Complex;
+    /**
+     * Complex tangent.
+     */
+    readonly tan: Complex;
 
+    /**
+     * Returns zero complex.
+     */
     static zero(): Complex;
-    static twiddle(K : number, N : number): Complex;
-    static fromPolar(z: number, phi: number): Complex;
-    
-    static add(c: Complex, ...z: (number | Complex)[]): Complex;
-    static sub(c: Complex, ...z: (number | Complex)[]): Complex;
-    static mul(c: Complex, ...z: (number | Complex)[]): Complex;
-    static div(c: Complex, ...z: (number | Complex)[]): Complex;
-    static pow(c: Complex, n: number): Complex;
+
+    /**
+     * Creates a complex number from polar coordinates.
+     *
+     * @param z Magnitude.
+     * @param phi Angle in radians.
+     */
+    static fromPolar(
+        z: number,
+        phi: number
+    ): Complex;
+
+    /**
+     * Creates FFT twiddle factor.
+     */
+    static twiddle(
+        K: number,
+        N: number
+    ): Complex;
+
+    /**
+     * Generates random complex numbers.
+     */
+    static readonly random: {
+        int(
+            a?: number,
+            b?: number
+        ): Complex;
+
+        float(
+            a?: number,
+            b?: number
+        ): Complex;
+    };
 }
 
-export declare function complex(a: number, b?: number): Complex;
-export declare function complex(a: Complex): Complex;
-export declare function complex(a: object): Complex;
-export declare function complex(): Complex;
+
+/**
+ * Creates a complex number.
+ */
+export declare function complex(
+    a?: number,
+    b?: number
+): Complex;
+
+export declare function complex(
+    a: Complex
+): Complex;
+
+export declare function complex(
+    a: object
+): Complex;
+
+
+/**
+ * Creates arrays of complex numbers from two arrays.
+ */
+export declare function complex(
+    a: number[] | ArrayLike<number>,
+    b: number[] | ArrayLike<number>
+): Complex[];
+
+
+/**
+ * Creates a complex matrix by combining two matrices.
+ */
+export declare function complex(
+    a: Matrix,
+    b: Matrix
+): Matrix;

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

@@ -0,0 +1,95 @@
+/**
+ * Arithmetic operation compatible with numbers,
+ * complex numbers, and matrix-like objects.
+ */
+export type ArithmeticValue = number | ComplexLike | MatrixLike;
+
+/**
+ * Minimal interface for complex number objects.
+ */
+export interface ComplexLike {
+    isComplex(): boolean;
+
+    clone(): this;
+
+    add(value: number | ComplexLike): this;
+    sub(value: number | ComplexLike): this;
+    mul(value: number | ComplexLike): this;
+    div(value: number | ComplexLike): this;
+    modulo(value: number | ComplexLike): this;
+}
+
+/**
+ * Minimal interface for matrix objects.
+ */
+export interface MatrixLike {
+    rows: number;
+    cols: number;
+
+    isMatrix(): boolean;
+
+    clone(): this;
+
+    add(value: ArithmeticValue): this;
+    sub(value: ArithmeticValue): this;
+    mul(value: ArithmeticValue): this;
+    div(value: ArithmeticValue): this;
+    modulo(value: ArithmeticValue): this;
+}
+
+/**
+ * Adds values together.
+ *
+ * Supports numbers, complex numbers, and matrices.
+ *
+ * @example
+ * add(1, 2, 3) // 6
+ */
+export declare function add<T extends ArithmeticValue>(
+    a: T,
+    ...b: ArithmeticValue[]
+): T;
+
+/**
+ * Subtracts values sequentially.
+ *
+ * @example
+ * sub(10, 2, 3) // 5
+ */
+export declare function sub<T extends ArithmeticValue>(
+    a: T,
+    ...b: ArithmeticValue[]
+): T;
+
+/**
+ * Multiplies values sequentially.
+ *
+ * @example
+ * mul(2, 3, 4) // 24
+ */
+export declare function mul<T extends ArithmeticValue>(
+    a: T,
+    ...b: ArithmeticValue[]
+): T;
+
+/**
+ * Divides values sequentially.
+ *
+ * @example
+ * div(20, 2, 5) // 2
+ */
+export declare function div<T extends ArithmeticValue>(
+    a: T,
+    ...b: ArithmeticValue[]
+): T;
+
+/**
+ * Calculates modulo sequentially.
+ *
+ * @example
+ * modulo(20, 6) // 2
+ */
+export declare function modulo<T extends ArithmeticValue>(
+    a: T,
+    ...b: ArithmeticValue[]
+): T;

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

@@ -0,0 +1,101 @@
+/**
+ * Converts a value from one numerical base to another.
+ *
+ * Supported bases are between 2 and 36.
+ *
+ * @param value Value to convert.
+ * @param fromBase Source base.
+ * @param toBase Target base.
+ *
+ * @example
+ * base2base("1010", 2, 10) // "10"
+ */
+export declare function base2base(
+    value: string | number,
+    fromBase: number,
+    toBase: number
+): string;
+
+/**
+ * Converts binary values to octal.
+ */
+export declare function bin2oct(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts binary values to decimal.
+ */
+export declare function bin2dec(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts binary values to hexadecimal.
+ */
+export declare function bin2hex(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts octal values to binary.
+ */
+export declare function oct2bin(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts octal values to decimal.
+ */
+export declare function oct2dec(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts octal values to hexadecimal.
+ */
+export declare function oct2hex(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts decimal values to binary.
+ */
+export declare function dec2bin(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts decimal values to octal.
+ */
+export declare function dec2oct(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts decimal values to hexadecimal.
+ */
+export declare function dec2hex(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts hexadecimal values to binary.
+ */
+export declare function hex2bin(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts hexadecimal values to octal.
+ */
+export declare function hex2oct(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts hexadecimal values to decimal.
+ */
+export declare function hex2dec(
+    ...x: (string | number)[]
+): string[];