numz 0.5.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numz",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "scientific computing with zikojs",
   "main": "index.js",
   "type": "module",
@@ -26,9 +26,9 @@
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-terser": "^1.0.0",
     "cross-env": "^10.1.0",
-    "rollup": "^4.62.5"
+    "rollup": "^4.63.0"
   },
   "dependencies": {
-    "ziko": "^1.8.0"
+    "ziko": "^1.10.0"
   }
 }

package/src/complex/helpers/constructor.js

@@ -0,0 +1,38 @@
+export const complex_constructor = (Complex, a, b) => {
+    let _a, _b;
+  if (a instanceof Complex) {
+    _a = a.a;
+    _b = a.b;
+  } 
+  else if (typeof a === "object") {
+    if ("a" in a && "b" in a) {
+      _a = a.a;
+      _b = a.b;
+    } 
+    else if ("a" in a && "z" in a) {
+      _a = a.a;
+      _b = Math.sqrt(a.z ** 2 - a.a ** 2);
+    } 
+    else if ("a" in a && "phi" in a) {
+      _a = a.a;
+      _b = a.a * Math.tan(a.phi);
+    } 
+    else if ("b" in a && "z" in a) {
+      _b = a.b;
+      _a = Math.sqrt(a.z ** 2 - a.b ** 2);
+    } 
+    else if ("b" in a && "phi" in a) {
+      _b = b;
+      _a = a.b / Math.tan(a.phi);
+    } 
+    else if ("z" in a && "phi" in a) {
+      _a = +a.z * Math.cos(a.phi).toFixed(15);
+      _b = +a.z * Math.sin(a.phi).toFixed(15);
+    }
+  } 
+  else if (typeof a === "number" && typeof b === "number") {
+    _a = +a.toFixed(32);
+    _b = +b.toFixed(32);
+  }
+  return [_a, _b]
+};

package/src/complex/helpers/index.js

@@ -0,0 +1 @@
+export * from './constructor.js'

package/src/complex/index.d.ts

@@ -0,0 +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(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 }
+    );
+
+    /**
+     * 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;
+
+    /**
+     * 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;
+
+    /**
+     * Complex tangent.
+     */
+    readonly tan: Complex;
+
+    /**
+     * Returns zero complex.
+     */
+    static zero(): 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;
+    };
+}
+
+
+/**
+ * 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/complex/index.js

@@ -0,0 +1,193 @@
+import { Random } from "../random/index.js";
+import { complex_constructor } from "./helpers/index.js";
+class Complex{
+    constructor(a = 0, b = 0) {
+        [
+            this.a,
+            this.b
+        ] = complex_constructor(Complex, a, b)
+    }
+    get __mapfun__(){
+        return true
+    }
+    isComplex(){
+        return true
+    }
+    toString(){
+        let str = "";
+        if (this.a !== 0)
+          this.b >= 0
+            ? (str = `${this.a}+${this.b}*i`)
+            : (str = `${this.a}-${Math.abs(this.b)}*i`);
+        else
+          this.b >= 0
+            ? (str = `${this.b}*i`)
+            : (str = `-${Math.abs(this.b)}*i`);
+        return str;
+    }
+    serialize() {
+        return JSON.stringify({
+            type : 'complex',
+            data : this
+        });
+    }
+    static deserialize(json){
+        if(typeof json === 'string') json = JSON.parse(json);
+        let {data, type} = json;
+        return (type === 'complex' && ('a' in data) && ('b' in data))
+            ? new Complex(data.a, data.b)
+            : TypeError('Not a valid complex')
+    } 
+    toFixed(n){
+        this.a = + this.a.toFixed(n);
+        this.b = + this.b.toFixed(n);
+        return this; 
+    }  
+    toPrecision(n){
+        this.a = + this.a.toPrecision(n);
+        this.b = + this.b.toPrecision(n);
+        return this; 
+    }  
+    clone() {
+        return new Complex(this.a, this.b);
+    }
+    get z(){
+        return Math.hypot(this.a,this.b);    
+    }
+    get phi(){
+        return Math.atan2(this.b , this.a);        
+    }
+    static zero() {
+        return new Complex(0, 0);
+    }
+    static fromPolar(z, phi) {
+        return new Complex(
+            +(z * cos(phi)).toFixed(13), 
+            +(z * sin(phi)).toFixed(13)
+        );
+    }
+    
+    static get random(){
+        return {
+            int : (a, b)=> new Complex(...Random.sample.int(2, a, b) ),
+            float : (a, b)=> new Complex(...Random.sample.float(2, a, b) ),
+        }
+    }
+    static twiddle(K, N){
+        const phi = -2 * Math.PI * K / N;
+        return new Complex(
+            Math.cos(phi), 
+            Math.sin(phi)
+        );
+    }
+    get conj() {
+        return new Complex(this.a, -this.b);
+    }
+    get inv() {
+        return new Complex(
+            this.a / Math.hypot(this.a, this.b),
+            -this.b / Math.hypot(this.a, this.b)
+        );
+    }
+    add(...c) {
+        for (let i = 0; i < c.length; i++) {
+            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
+            this.a += c[i].a;
+            this.b += c[i].b;
+        }
+        return this;
+    }
+    sub(...c) {
+        for (let i = 0; i < c.length; i++) {
+            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
+            this.a -= c[i].a;
+            this.b -= c[i].b;
+        }
+        return this;
+    }
+    mul(...c){
+        let {z, phi} = this;
+        for (let i = 0; i < c.length; i++) {
+            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
+            z *= c[i].z;
+            phi += c[i].phi;
+        }
+        this.a = z * Math.cos(phi)
+        this.b = z * Math.sin(phi)  
+        return this.toFixed(8);
+    }
+    div(...c){
+        let {z, phi} = this;
+        for (let i = 0; i < c.length; i++) {
+            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
+            z /= c[i].z;
+            phi -= c[i].phi;
+        }
+        this.a = z * Math.cos(phi)
+        this.b = z * Math.sin(phi)  
+        return this.toFixed(8);;
+    }
+    modulo(...c) {
+        for (let i = 0; i < c.length; i++) {
+            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
+            this.a %= c[i].a;
+            this.b %= c[i].b;
+        }
+        return this;
+    }
+    pow(...c){
+        let {z, phi} = this;
+        for (let i = 0; i < c.length; i++) {
+            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
+            z *= Math.exp(c[i].a * Math.log(z) - c[i].b * phi);
+            phi += c[i].b * Math.log(z) + c[i].a * phi;
+        }
+        this.a = z * Math.cos(phi)
+        this.b = z * Math.sin(phi)  
+        return this;
+    }
+    get expo() {
+        return [this.z, this.phi];
+    }
+    nthr(n=2){
+        return complex({z: this.z ** (1/n), phi: this.phi / n});
+    }
+    get sqrt(){
+        return this.nthr(2);
+    }
+    get cbrt(){
+        return this.nthr(3);
+    }
+    get log(){
+        return complex(this.z, this.phi);
+    }
+    get cos(){
+        return complex(
+            Math.cos(this.a) * Math.cosh(this.b),
+            Math.sin(this.a) * Math.sinh(this.b)
+        )
+    }
+    get sin(){
+        return complex(
+            Math.sin(this.a) * Math.cosh(this.b),
+            Math.cos(this.a) * Math.sinh(this.b)
+        )
+    }
+    get tan(){
+        const D=cos(this.a*2)+cosh(this.b*2);
+        return complex(
+            Math.sin(2 * this.a) / D,
+            Math.sinh(2 * this.b) / D
+        );
+    }
+}
+const complex=(a,b)=>{
+    if((a instanceof Array||ArrayBuffer.isView(a)) && (b instanceof Array||ArrayBuffer.isView(a)))return a.map((n,i)=>complex(a[i],b[i]));
+    if(a.isMatrix?.() && b.isMatrix?.()){
+        if((a.shape[0]!==b.shape[0])||(a.shape[1]!==b.shape[1]))return Error(0)
+        const arr=a.arr.map((n,i)=>complex(a.arr[i],b.arr[i]))
+        return new a.constructor(a.rows,a.cols,...arr)
+    }
+    return new Complex(a,b)
+}
+export{complex,Complex}

package/src/index.js

@@ -1,6 +1,6 @@
 export * from './ufunc/index.js'
+export * from './random/index.js'
+export * from './complex/index.js'
 export * from './calculus/index.js'
 export * from './signal/index.js'
 export * from './stats/index.js'
-
-

package/src/random/index.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Utility class for generating random values.
+ */
+export declare class Random {
+
+    /**
+     * Generates a random integer.
+     * @param a Minimum value (inclusive).
+     * @param b Maximum value (exclusive).
+     */
+    static int(a: number, b?: number): number;
+
+    /**
+     * Generates a random floating-point number.
+     * @param a Minimum value.
+     * @param b Maximum value.
+     */
+    static float(a: number, b?: number): number;
+
+    /**
+     * Generates a random binary value.
+     */
+    static bin(): 0 | 1;
+
+    /**
+     * Generates a random octal digit.
+     */
+    static oct(): number;
+
+    /**
+     * Generates a random decimal digit.
+     */
+    static dec(): number;
+
+    /**
+     * Generates a random hexadecimal digit.
+     */
+    static hex(): string;
+
+    /**
+     * Generates a random alphabetic character.
+     * @param upperCase Generate uppercase character when true.
+     */
+    static char(upperCase?: boolean): string;
+
+    /**
+     * Generates a random boolean value.
+     */
+    static bool(): boolean;
+
+    /**
+     * Random color generators.
+     */
+    static readonly color: {
+        /** Generates a random HEX color. */
+        hex(): string;
+
+        /** Generates a random HEXA color with alpha channel. */
+        hexa(): string;
+
+        /** Generates a random RGB color. */
+        rgb(): string;
+
+        /** Generates a random RGBA color. */
+        rgba(): string;
+
+        /** Generates a random HSL color. */
+        hsl(): string;
+
+        /** Generates a random HSLA color with alpha channel. */
+        hsla(): string;
+
+        /** Generates a random grayscale RGB color. */
+        gray(): string;
+    };
+
+    /**
+     * Generates arrays of random values.
+     */
+    static readonly sample: {
+
+        /**
+         * Generates an array of random integers.
+         */
+        int(n: number, a: number, b?: number): number[];
+
+        /**
+         * Generates an array of random floats.
+         */
+        float(n: number, a: number, b?: number): number[];
+
+        /**
+         * Generates an array of random characters.
+         */
+        char(n: number, upper?: boolean): string[];
+
+        /**
+         * Generates an array of random booleans.
+         */
+        bool(n: number): boolean[];
+
+        /**
+         * Generates an array of random binary values.
+         */
+        bin(n: number): (0 | 1)[];
+
+        /**
+         * Generates an array of random octal digits.
+         */
+        oct(n: number): number[];
+
+        /**
+         * Generates an array of random decimal digits.
+         */
+        dec(n: number): number[];
+
+        /**
+         * Generates an array of random hexadecimal digits.
+         */
+        hex(n: number): string[];
+
+        /**
+         * Generates arrays of random colors.
+         */
+        readonly color: {
+            hex(n: number): string[];
+            hexa(n: number): string[];
+            rgb(n: number): string[];
+            rgba(n: number): string[];
+            hsl(n: number): string[];
+            hsla(n: number): string[];
+            gray(n: number): string[];
+        };
+
+        /**
+         * Generates an array of random choices from a list.
+         * @param n Number of generated values.
+         * @param choices Available values.
+         * @param p Probability distribution for each value.
+         */
+        choice<T>(
+            n: number,
+            choices: T[],
+            p?: number[]
+        ): T[];
+    };
+
+    /**
+     * Returns a shuffled copy of an array.
+     */
+    static shuffle<T>(arr: T[]): T[];
+
+    /**
+     * Randomly selects a value from a list.
+     * @param choices Available values.
+     * @param p Probability distribution for each value.
+     */
+    static choice<T>(
+        choices?: T[],
+        p?: number[]
+    ): T;
+}

package/src/random/index.js

@@ -0,0 +1,111 @@
+// import { base2base } from "../../../dep/--from-ziko/functions/conversions/index.js";
+import { accum_sum } from "../stats";
+
+export class Random {
+    static int(a, b){
+        return Math.floor(this.float(a, b));
+    }
+    static float(a, b){
+        return b !== undefined
+            ? Math.random() * (b - a) + a
+            : Math.random() * a;
+    }
+    static bin(){
+        return this.int(2);
+    }
+    static oct(){
+        return this.int(8);
+    }
+    static dec(){
+        return this.int(10);
+    }
+    // static hex(){
+    //     return base2base(this.int(16), 10, 16);
+    // }
+    static char(upperCase = false){
+        const i = upperCase
+            ? this.int(65, 91)
+            : this.int(97, 123);
+        return String.fromCharCode(i);
+    }
+    static bool(){
+        return Boolean(this.int(2));
+    }
+    static get color(){
+        return {
+            hex : () =>
+                `#${this.int(0xffffff).toString(16).padStart(6, '0')}`,
+
+            hexa : () => {
+                const [r,g,b,a] = Array.from(
+                    {length:4},
+                    () => this.int(0xff).toString(16).padStart(2,'0')
+                );
+                return `#${r}${g}${b}${a}`;
+            },
+            rgb : () => {
+                const [r,g,b] = Array.from({length:3}, () => this.int(0xff));
+                return `rgb(${r}, ${g}, ${b})`;
+            },
+            rgba : () => {
+                const [r,g,b] = Array.from({length:3}, () => this.int(0xff));
+                const a = Math.random().toFixed(2);
+                return `rgba(${r}, ${g}, ${b}, ${a})`;
+            },
+            hsl : () => {
+                const h = this.int(360);
+                const s = this.int(100);
+                const l = this.int(100);
+                return `hsl(${h}, ${s}%, ${l}%)`;
+            },
+            hsla : () => {
+                const h = this.int(360);
+                const s = this.int(100);
+                const l = this.int(100);
+                const a = Math.random().toFixed(2);
+                return `hsla(${h}, ${s}%, ${l}%, ${a})`;
+            },
+            gray : () => {
+                const g = this.int(0xff);
+                return `rgb(${g}, ${g}, ${g})`;
+            }
+        };
+    }
+    static get sample(){
+        const R = this;
+        return {
+            int   : (n, a, b) => Array.from({length:n}, () => R.int(a, b)),
+            float : (n, a, b) => Array.from({length:n}, () => R.float(a, b)),
+            char  : (n, upper=false) => Array.from({length:n}, () => R.char(upper)),
+            bool  : n => Array.from({length:n}, () => R.bool()),
+            bin   : n => Array.from({length:n}, () => R.bin()),
+            oct   : n => Array.from({length:n}, () => R.oct()),
+            dec   : n => Array.from({length:n}, () => R.dec()),
+            hex   : n => Array.from({length:n}, () => R.hex()),
+            get color(){
+                return {
+                    hex  : n => Array.from({length:n}, () => R.color.hex()),
+                    hexa : n => Array.from({length:n}, () => R.color.hexa()),
+                    rgb  : n => Array.from({length:n}, () => R.color.rgb()),
+                    rgba : n => Array.from({length:n}, () => R.color.rgba()),
+                    hsl  : n => Array.from({length:n}, () => R.color.hsl()),
+                    hsla : n => Array.from({length:n}, () => R.color.hsla()),
+                    gray : n => Array.from({length:n}, () => R.color.gray())
+                };
+            },
+            choice : (n, choices, p) =>
+                Array.from({length:n}, () => R.choice(choices, p))
+        };
+    }
+    static shuffle(arr){
+        return [...arr].sort(() => 0.5 - Math.random());
+    }
+    // static choice(choices = [1,2,3], p = new Array(choices.length).fill(1 / choices.length)){
+    //     const acc = accum_sum(...p).map(v => v * 100);
+    //     const pool = new Array(100);
+    //     pool.fill(choices[0], 0, acc[0]);
+    //     for(let i=1;i<choices.length;i++)
+    //         pool.fill(choices[i], acc[i-1], acc[i]);
+    //     return pool[this.int(pool.length)];
+    // }
+}