ziko 0.51.0 → 0.51.1

package/src/math/random/index.js

@@ -1,8 +1,6 @@
 
-import{Complex}from"../complex/index.js"
 import { Utils } from "../utils/index.js";
-import{Base}from"../discret/index.js"
-import { matrix } from "../matrix/index.js";
+import{ Base } from "../discret/index.js"
 class Random {
     static float(a = 1, b) {
         return b ? Math.random() * (b - a) + a : a * Math.random();
@@ -45,10 +43,6 @@ class Random {
     static shuffleArr(arr){
         return arr.sort(()=>0.5-Math.random())    
     }
-    static shuffleMatrix(M){
-            const {rows,cols,arr}=M;
-            return matrix(rows,cols,arr.flat().sort(()=>0.5-Math.random()))
-    }
     static floats(n, a, b) {
         return new Array(n).fill(0).map(() => this.float(a, b));
     }
@@ -83,91 +77,93 @@ class Random {
     static colors(n) {
         return new Array(n).fill(null).map(()=>this.color());
     }
-    static complex(a = [0,1], b = [0,1]) {
-        return a instanceof Array?
-        new Complex(
-            this.float(a[0], a[1]),
-            this.float(b[0], b[1])
-        ):
-        new Complex(
-            ...this.floats(2,a,b)
-        )
+
+    // Should be Moved to Matrix and Complex to avoid Circular dependencies
+    // static complex(a = [0,1], b = [0,1]) {
+    //     return a instanceof Array?
+    //     new Complex(
+    //         this.float(a[0], a[1]),
+    //         this.float(b[0], b[1])
+    //     ):
+    //     new Complex(
+    //         ...this.floats(2,a,b)
+    //     )
         
-    }
-    static complexInt(a = [0,1], b = [0,1]) {
-        return new Complex(
-            this.int(a[0], a[1]),
-            this.int(b[0], b[1])
-            );
-    }
-    static complexBin() {
-        return new Complex(...this.bins(2));
-    }
-    static complexOct() {
-        return new Complex(...this.octs(2));
-    }
-    static complexDec() {
-        return new Complex(...this.decs(10));
-    }
-    static complexHex() {
-        return new Complex(...this.octs(2));
-    }
-    static complexes(n, a = 0, b = 1) {
-        return new Array(n).fill(0).map(() => this.complex(a, b));
-    }
-    static complexesInt(n, a = 0, b = 1) {
-        return new Array(n).fill(0).map(() => this.complexInt(a, b));
-    }
-    static complexesBin(n) {
-        return new Array(n).fill(0).map(() => this.complexBin());
-    }
-    static complexesOct(n) {
-        return new Array(n).fill(0).map(() => this.complexOct());
-    }
-    static complexesDec(n) {
-        return new Array(n).fill(0).map(() => this.complexDec());
-    }
-    static complexesHex(n) {
-        return new Array(n).fill(0).map(() => this.complexHex());
-    }
-    static matrix(r,c,min,max){
-        return matrix(r,c,this.floats(r*c,min,max))
-    }
-    static matrixInt(r,c,min,max){
-        return matrix(r,c,this.ints(r*c,min,max))
-    }
-    static matrixBin(r,c){
-        return matrix(r,c,this.bins(r*c))
-    }
-    static matrixOct(r,c){
-        return matrix(r,c,this.octs(r*c))
-    }
-    static matrixDec(r,c){
-        return matrix(r,c,this.decs(r*c))
-    }
-    static matrixHex(r,c){
-        return matrix(r,c,this.hex(r*c))
-    }
-    static matrixColor(r,c){
-        return matrix(r,c,this.colors(r*c))
-    }
-    static matrixComplex(r,c,a,b){
-        return matrix(r,c,this.complexes(r*c,a,b))
-    }
-    static matrixComplexInt(r,c,a,b){
-        return matrix(r,c,this.complexesInt(r*c,a,b))
-    }
-    static matrixComplexBin(r,c){
-        return matrix(r,c,this.complexesBin(r*c))
-    }
-    static matrixComplexOct(r,c){
-        return matrix(r,c,this.complexesBin(r*c))
-    }
-    static matrixComplexDec(r,c){
-        return matrix(r,c,this.complexesBin(r*c))
-    }
-    static matrixComplexHex(r,c){
-        return matrix(r,c,this.complexesBin(r*c))
-    }
+    // }
+    // static complexInt(a = [0,1], b = [0,1]) {
+    //     return new Complex(
+    //         this.int(a[0], a[1]),
+    //         this.int(b[0], b[1])
+    //         );
+    // }
+    // static complexBin() {
+    //     return new Complex(...this.bins(2));
+    // }
+    // static complexOct() {
+    //     return new Complex(...this.octs(2));
+    // }
+    // static complexDec() {
+    //     return new Complex(...this.decs(10));
+    // }
+    // static complexHex() {
+    //     return new Complex(...this.octs(2));
+    // }
+    // static complexes(n, a = 0, b = 1) {
+    //     return new Array(n).fill(0).map(() => this.complex(a, b));
+    // }
+    // static complexesInt(n, a = 0, b = 1) {
+    //     return new Array(n).fill(0).map(() => this.complexInt(a, b));
+    // }
+    // static complexesBin(n) {
+    //     return new Array(n).fill(0).map(() => this.complexBin());
+    // }
+    // static complexesOct(n) {
+    //     return new Array(n).fill(0).map(() => this.complexOct());
+    // }
+    // static complexesDec(n) {
+    //     return new Array(n).fill(0).map(() => this.complexDec());
+    // }
+    // static complexesHex(n) {
+    //     return new Array(n).fill(0).map(() => this.complexHex());
+    // }
+    // static matrix(r,c,min,max){
+    //     return matrix(r,c,this.floats(r*c,min,max))
+    // }
+    // static matrixInt(r,c,min,max){
+    //     return matrix(r,c,this.ints(r*c,min,max))
+    // }
+    // static matrixBin(r,c){
+    //     return matrix(r,c,this.bins(r*c))
+    // }
+    // static matrixOct(r,c){
+    //     return matrix(r,c,this.octs(r*c))
+    // }
+    // static matrixDec(r,c){
+    //     return matrix(r,c,this.decs(r*c))
+    // }
+    // static matrixHex(r,c){
+    //     return matrix(r,c,this.hex(r*c))
+    // }
+    // static matrixColor(r,c){
+    //     return matrix(r,c,this.colors(r*c))
+    // }
+    // static matrixComplex(r,c,a,b){
+    //     return matrix(r,c,this.complexes(r*c,a,b))
+    // }
+    // static matrixComplexInt(r,c,a,b){
+    //     return matrix(r,c,this.complexesInt(r*c,a,b))
+    // }
+    // static matrixComplexBin(r,c){
+    //     return matrix(r,c,this.complexesBin(r*c))
+    // }
+    // static matrixComplexOct(r,c){
+    //     return matrix(r,c,this.complexesBin(r*c))
+    // }
+    // static matrixComplexDec(r,c){
+    //     return matrix(r,c,this.complexesBin(r*c))
+    // }
+    // static matrixComplexHex(r,c){
+    //     return matrix(r,c,this.complexesBin(r*c))
+    // }
 }
 export{Random}

package/src/math/signal/functions.js

@@ -1,15 +1,13 @@
-import { Complex , complex } from "../complex/index.js";
 import { abs , pow , sqrtn , max , min} from "../functions/index.js";
 import { mul } from "../utils/index.js";
 import { E } from "../const.js";
-import { Matrix  } from "../matrix/Matrix.js";
 const zeros=(n)=>new Array(n).fill(0);
 const ones=(n)=>new Array(n).fill(1);
 const nums=(num,n)=>new Array(n).fill(num);
 const norm=(value, min, max)=>{
     if (typeof value === "number") return min !== max ? (value - min) / (max - min) : 0;
-    else if (value instanceof Matrix) return new Matrix(value.rows, value.cols, norm(value.arr.flat(1), min, max));
-    else if (value instanceof Complex) return new Complex(norm(value.a, min, max), norm(value.b, min, max));
+    else if (value.isMatrix?.()) return new value.constructor(value.rows, value.cols, norm(value.arr.flat(1), min, max));
+    else if (value.isComplex?.()) return new value.constructor(norm(value.a, min, max), norm(value.b, min, max));
     else if (value instanceof Array) {
         if (value.every((n) => typeof (n === "number"))) {
             return value.map((n) => norm(n, min, max));
@@ -23,8 +21,8 @@ const norm=(value, min, max)=>{
 }
 const lerp=(value, min, max)=>{
     if (typeof value === "number") return (max - min) * value + min;
-    else if (value instanceof Matrix) return new Matrix(value.rows, value.cols, lerp(value.arr.flat(1), min, max));
-    else if (value instanceof Complex) return new Complex(lerp(value.a, min, max), lerp(value.b, min, max));
+    else if (value.isMatrix?.()) return new value.constructor(value.rows, value.cols, lerp(value.arr.flat(1), min, max));
+    else if (value.isComplex?.()) return new value.constructor(lerp(value.a, min, max), lerp(value.b, min, max));
     else if (value instanceof Array) {
         if (value.every((n) => typeof (n === "number"))) {
             return value.map((n) => lerp(n, min, max));
@@ -36,17 +34,17 @@ const lerp=(value, min, max)=>{
         }
     }
 }
-const map=(value, a, b, c, d)=>{
-    if (typeof value === "number") return lerp(norm(value, a, b), c, d);
-    else if (value instanceof Matrix) return new Matrix(value.rows, value.cols, map(value.arr.flat(1), a, b, c, d));
-    else if (value instanceof Complex) return new Complex(map(value.a, b, c, d), map(value.b, a, b, c, d));
-    else if (value instanceof Array) {
-        if (value.every((n) => typeof (n === "number"))) {
-            return value.map((n) => map(n, a, b, c, d));
+const map=(x, a, b, c, d)=>{
+    if (typeof x === "number") return lerp(norm(x, a, b), c, d);
+    else if (x.isMatrix?.()) return new x.constructor(x.rows, x.cols, map(x.arr.flat(1), a, b, c, d));
+    else if (x.isComplex?.()) return new x.constructor(map(x.a, b, c, d), map(x.b, a, b, c, d));
+    else if (x instanceof Array) {
+        if (x.every((n) => typeof (n === "number"))) {
+            return x.map((n) => map(n, a, b, c, d));
         } else {
-            let y = new Array(value.length);
-            for (let i = 0; i < value.length; i++) {
-                y[i] = map(value[i], a, b, c, d);
+            let y = new Array(x.length);
+            for (let i = 0; i < x.length; i++) {
+                y[i] = map(x[i], a, b, c, d);
             }
         }
     }
@@ -54,8 +52,8 @@ const map=(value, a, b, c, d)=>{
 const clamp=(x, a , b)=>{
     const [min_value,max_value]=[min(a,b),max(a,b)]
     if (typeof x === "number") return min(max(x, min_value), max_value);
-    else if (x instanceof Matrix) return new Matrix(x.rows, x.cols, clamp(x.arr.flat(1), min_value, max_value));
-    else if (x instanceof Complex) return new Complex(clamp(x.a, min_value, max_value), clamp(x.b, min_value, max_value));
+    else if (x.isMatrix?.()) return new x.constructor(x.rows, x.cols, clamp(x.arr.flat(1), min_value, max_value));
+    else if (x.isComplex?.()) return new x.constructor(clamp(x.a, min_value, max_value), clamp(x.b, min_value, max_value));
     else if (x instanceof Array) {
         if (x.every((n) => typeof (n === "number"))) {
             return x.map((n) => clamp(n, min_value, max_value));
@@ -90,14 +88,14 @@ const linspace=(a,b,n=abs(b-a)+1,endpoint=true)=>{
         return Y
     }
 
-    if([a,b].some(n=>n instanceof Complex)){
-        const z1=complex(a)
-        const z2=complex(b)
+    if([a,b].some(n=>n.isComplex?.())){
+        const z1 = new n.constructor(a)
+        const z2 = new n.constructor(b)
         n=n||Math.abs(z1.a-z2.a)+1;
         const X=linspace(z1.a,z2.a,n,endpoint);
         const Y=linspace(z1.b,z2.b,n,endpoint);
         let Z=new Array(n).fill(null);
-        Z=Z.map((n,i)=>complex(X[i],Y[i]));
+        Z=Z.map((n,i)=> new n.constructor(X[i],Y[i]));
         return Z;
     }
 }
@@ -117,9 +115,9 @@ const geomspace=(a,b,n=abs(b-a)+1,endpoint=true)=>{
         return a<b?Y:Y.reverse()
     }
 
-    if([a,b].some(n=>n instanceof Complex)){
-        const z1=complex(a)
-        const z2=complex(b)
+    if([a,b].some(n=>n.isComplex?.())){
+        const z1 = new n.constructor(a)
+        const z2 = new n.constructor(b)
         n=n||Math.abs(z1.a-z2.a)+1;
         let base;
         endpoint ? base = sqrtn(z2.div(z1),n-1) : base = sqrtn(z2.div(z1),n) ;

package/src/math/utils/arithmetic.js

@@ -1,13 +1,11 @@
-import { Complex,complex} from "../complex/index.js";
-import { Matrix  } from "../matrix/index.js";
 const _add=(a,b)=>{
     if(typeof(a)==="number"){
         if (typeof b == "number") return a + b;
-        else if (b instanceof Complex)return complex(a + b.a, b.b);
-        else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).add(b);
+        else if (b.isComplex?.())return new b.constructor(a + b.a, b.b);
+        else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).add(b);
         else if (b instanceof Array)return b.map(n=>add(n,a));                 
     }
-    else if(a instanceof Complex||a instanceof Matrix){
+    else if(a.isComplex?.()||a.isMatrix?.()){
         if(b instanceof Array)return b.map(n=>a.clone.add(n));
         return a.clone.add(b);
     }
@@ -23,11 +21,11 @@ const _add=(a,b)=>{
 const _sub=(a,b)=>{
     if(typeof(a)==="number"){
         if (typeof b == "number") return a - b;
-        else if (b instanceof Complex)return complex(a - b.a, -b.b);
-        else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).sub(b);
+        else if (b.isComplex?.())return new b.constructor(a - b.a, -b.b);
+        else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).sub(b);
         else if (b instanceof Array)return b.map(n=>sub(n,a));                 
     }
-    else if(a instanceof Complex||a instanceof Matrix){
+    else if(a.isComplex?.()||a.isMatrix?.()){
         if(b instanceof Array)return b.map(n=>a.clone.sub(n));
         return a.clone.sub(b);
     }
@@ -45,11 +43,11 @@ const _sub=(a,b)=>{
 const _mul=(a,b)=>{
     if(typeof(a)==="number"){
     if (typeof b == "number") return a * b;
-        else if (b instanceof Complex)return complex(a * b.a,a * b.b);
-        else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).mul(b);
+        else if (b.isComplex?.())return new b.constructor(a * b.a,a * b.b);
+        else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).mul(b);
         else if (b instanceof Array)return b.map(n=>mul(a,n)); 
     }
-    else if(a instanceof Complex||a instanceof Matrix){
+    else if(a.isComplex?.()||a.isMatrix?.()){
         if(b instanceof Array)return b.map(n=>a.clone.mul(n));
         return a.clone.mul(b);
     }
@@ -67,11 +65,11 @@ const _mul=(a,b)=>{
 const _div=(a,b)=>{
     if(typeof(a)==="number"){
     if (typeof b == "number") return a / b;
-        else if (b instanceof Complex)return complex(a / b.a,a / b.b);
-        else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).div(b);
+        else if (b.isComplex?.())return new b.constructor(a / b.a,a / b.b);
+        else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).div(b);
         else if (b instanceof Array)return b.map(n=>div(a,n));
     }
-    else if(a instanceof Complex||a instanceof Matrix){
+    else if(a.isComplex?.()||a.isMatrix?.()){
         if(b instanceof Array)return b.map(n=>a.clone.div(n));
         return a.clone.div(b);
     }
@@ -89,11 +87,11 @@ const _div=(a,b)=>{
 const _modulo=(a,b)=>{
     if(typeof(a)==="number"){
         if (typeof b == "number") return a % b;
-            else if (b instanceof Complex)return complex(a % b.a,a % b.b);
-            else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).modulo(b);
+            else if (b.isComplex?.())return new b.constructor(a % b.a,a % b.b);
+            else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).modulo(b);
             else if (b instanceof Array)return b.map(n=>div(a,n));
         }
-        else if(a instanceof Complex||a instanceof Matrix){
+        else if(a.isComplex?.()||a.isMatrix?.()){
             if(b instanceof Array)return b.map(n=>a.clone.div(n));
             return a.clone.div(b);
         }

package/src/math/utils/mapfun.js

@@ -1,9 +1,6 @@
-import { Matrix } from "../matrix/index.js";
-import { Complex , complex } from "../complex/index.js";
 import {ln,e,cos,sin,sqrt,cosh,sinh} from "../functions/index.js";
 import { Fixed } from "../functions/helper.js";
 // To generalise
-
 const mapfun=(fun,...X)=>{
     const Y=X.map(x=>{
         if(x===null) return fun(null);
@@ -12,10 +9,9 @@ const mapfun=(fun,...X)=>{
         if(ArrayBuffer.isView(x)) return x.map(n=>fun(n));
         if(x instanceof Set) return new Set(mapfun(fun,...[...x]));
         if(x instanceof Map) return new Map([...x].map(n=>[n[0],mapfun(fun,n[1])]));
-        if(x instanceof Matrix){
-            return new Matrix(x.rows,x.cols, mapfun(x.arr.flat(1)))
-        }
-        if(x instanceof Complex){
+        if(x.isMatrix?.()) return new x.constructor(x.rows, x.cols, mapfun(x.arr.flat(1)))
+        if(x.isComplex?.()){
+            const complex = (...args) => new x.constructor(...args) 
             const [a,b,z,phi]=[x.a,x.b,x.z,x.phi];
             switch(fun){
                 case Math.log: return complex(ln(z),phi); // Done