numz 0.5.0 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numz",
-  "version": "0.5.0",
+  "version": "0.6.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

@@ -2,5 +2,5 @@ export * from './ufunc/index.js'
 export * from './calculus/index.js'
 export * from './signal/index.js'
 export * from './stats/index.js'
-
+export * from './complex/index.js'