ziko 0.51.0 → 0.51.1

package/dist/ziko.js

@@ -2,7 +2,7 @@
 /*
   Project: ziko.js
   Author: Zakaria Elalaoui
-  Date : Wed Dec 03 2025 10:58:16 GMT+0100 (UTC+01:00)
+  Date : Thu Dec 04 2025 12:08:41 GMT+0100 (UTC+01:00)
   Git-Repo : https://github.com/zakarialaoui10/ziko.js
   Git-Wiki : https://github.com/zakarialaoui10/ziko.js/wiki
   Released under MIT License
@@ -49,7 +49,6 @@
     });
 
     // To generalise
-
     const mapfun$1=(fun,...X)=>{
         const Y=X.map(x=>{
             if(x===null) return fun(null);
@@ -58,10 +57,9 @@
             if(ArrayBuffer.isView(x)) return x.map(n=>fun(n));
             if(x instanceof Set) return new Set(mapfun$1(fun,...[...x]));
             if(x instanceof Map) return new Map([...x].map(n=>[n[0],mapfun$1(fun,n[1])]));
-            if(x instanceof Matrix){
-                return new Matrix(x.rows,x.cols, mapfun$1(x.arr.flat(1)))
-            }
-            if(x instanceof Complex){
+            if(x.isMatrix?.()) return new x.constructor(x.rows, x.cols, mapfun$1(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
@@ -90,14 +88,215 @@
        return Y.length==1?Y[0]:Y; 
     };
 
+    // Mixed calcul
+    const sum=(...x)=>{
+        if(x.every(n=>typeof n==="number")){
+            let s = x[0];
+            for (let i = 1; i < x.length; i++) s += x[i];
+            return s;
+        }
+        const Y=[];
+        for(let i=0;i<x.length;i++){
+            if(x[i] instanceof Array)Y.push(sum(...x[i]));
+            else if(x[i] instanceof Object){
+                Y.push(sum(...Object.values(x[i])));
+            }
+        }
+        return Y.length===1?Y[0]:Y;
+    };
+    const prod=(...x)=>{
+        if(x.every(n=>typeof n==="number")){
+            let p = x[0];
+            for (let i = 1; i < x.length; i++) p *= x[i];
+            return p;
+        }
+        const Y=[];
+        for(let i=0;i<x.length;i++){
+            if(x[i] instanceof Array)Y.push(prod(...x[i]));
+            else if(x[i] instanceof Object){
+                Y.push(prod(...Object.values(x[i])));
+            }
+        }
+        return Y.length===1?Y[0]:Y;
+    };
+    const min=(...num)=>{
+        if(num.every(n=>typeof n==="number"))return Math.min(...num);
+        const Y=[];
+        for(let i=0;i<num.length;i++){
+            if(num[i] instanceof Array)Y.push(min(...num[i]));
+            else if(num[i] instanceof Object){
+                Y.push(
+                        Object.fromEntries(
+                            [Object.entries(num[i]).sort((a,b)=>a[1]-b[1])[0]]
+                        )
+                    );
+            }
+        }
+        return Y.length===1?Y[0]:Y;
+    };
+    const max=(...num)=>{
+        if(num.every(n=>typeof n==="number"))return Math.max(...num);
+        const Y=[];
+        for(let i=0;i<num.length;i++){
+            if(num[i] instanceof Array)Y.push(min(...num[i]));
+            else if(num[i] instanceof Object){
+                Y.push(
+                        Object.fromEntries(
+                            [Object.entries(num[i]).sort((a,b)=>b[1]-a[1])[0]]
+                        )
+                    );
+            }
+        }
+        return Y.length===1?Y[0]:Y;
+    };
+    const accum=(...num)=>{
+        if(num.every(n=>typeof n==="number")){
+            let acc = num.reduce((x, y) => [...x, x[x.length - 1] + y], [0]);
+            acc.shift();
+            return acc;
+        }
+        const Y=[];
+        for(let i=0;i<num.length;i++){
+            if(num[i] instanceof Array)Y.push(accum(...num[i]));
+            else if(num[i] instanceof Object){
+                Y.push(null
+                        // Object.fromEntries(
+                        //     [Object.entries(num[i]).sort((a,b)=>b[1]-a[1])[0]]
+                        // )
+                    );
+            }
+        }
+        return Y.length===1?Y[0]:Y;
+    };
+
+    //moy
+    //med
+    //variance
+    //std
+    //mode
+    //acccum
+    //min2max
+    //max2min
+    //percentile
+
+    const abs=(...x)=>mapfun$1(Math.abs,...x);
+    const sqrt$2=(...x)=>mapfun$1(Math.sqrt,...x);
+    const pow$1=(x,n)=>{
+        if(typeof x === "number"){
+            if(typeof n === "number")return Math.pow(x,n);
+            else if(n?.isComplex?.())return n.constructor.fromExpo(x**n.a,n.b*ln(x))
+            else return mapfun$1(a=>pow$1(x,a),...n);
+        }
+        else if(x.isComplex?.()){
+            if(typeof n === "number")return x.constructor.fromExpo(x.z**n,x.phi*n);
+            else if(n.isComplex?.())return x.constructor.fromExpo(
+                x.z**n.a*e(-x.phi*n.b),
+                ln(x.z)*n.b+n.a*x.phi
+            )
+            else return mapfun$1(a=>pow$1(x,a),...n);
+        }
+        else if(x instanceof Array){
+            if(typeof n === "number") return mapfun$1(a=>pow$1(a,n),...x);
+            else if(n instanceof Array){
+                const Y=[];
+                for(let i=0;i<x.length;i++){
+                    Y.push(mapfun$1(a=>pow$1(x[i],a),...n));
+                }
+                return Y;
+            }
+        }
+    };
+    const sqrtn=(x,n)=>{
+        if(typeof x === "number"){
+            if(typeof n === "number")return Math.pow(x,1/n);
+            else return mapfun$1(a=>sqrtn(x,a),...n);
+        }
+        else if(x.isComplex?.()){
+            if(typeof n === "number")return x.constructor.fromExpo(sqrtn(x.z,n),x.phi/n);
+            else return mapfun$1(a=>sqrtn(x,a),...n);
+        }
+        else if(x instanceof Array){
+            if(typeof n === "number") return mapfun$1(a=>sqrtn(a,n),...x);
+            else if(n instanceof Array){
+                const Y=[];
+                for(let i=0;i<x.length;i++){
+                    Y.push(mapfun$1(a=>sqrtn(x[i],a),...n));
+                }
+                return Y;
+            }
+        }
+    };
+    const e=(...x) => mapfun$1(Math.exp,...x);
+    const ln=(...x) => mapfun$1(Math.log,...x);
+    const cos$2=(...x) => mapfun$1(Fixed.cos,...x);
+    const sin$2=(...x) => mapfun$1(Fixed.sin,...x);
+    const tan=(...x) => mapfun$1(Fixed.tan,...x);
+    const sec=(...x) => mapfun$1(Fixed.sec,...x);
+    const sinc=(...x) => mapfun$1(Fixed.sinc,...x);
+    const csc=(...x) => mapfun$1(Fixed.csc,...x);
+    const cot=(...x) => mapfun$1(Fixed.cot,...x);
+    const acos$1=(...x) => mapfun$1(Fixed.acos,...x);
+    const asin=(...x) => mapfun$1(Fixed.asin,...x);
+    const atan=(...x) => mapfun$1(Fixed.atan,...x);
+    const acot=(...x) => mapfun$1(Fixed.acot,...x);
+    const cosh$1=(...x) => mapfun$1(Fixed.cosh,...x);
+    const sinh$1=(...x) => mapfun$1(Fixed.sinh,...x);
+    const tanh=(...x) => mapfun$1(Fixed.tanh,...x);
+    const coth=(...x) => mapfun$1(Fixed.coth,...x);
+    const acosh=(...x) => mapfun$1(Fixed.acosh,...x);
+    const asinh=(...x) => mapfun$1(Fixed.asinh,...x);
+    const atanh=(...x) => mapfun$1(Fixed.atanh,...x);
+    const ceil=(...x) => mapfun$1(Math.ceil,...x);
+    const floor=(...x) => mapfun$1(Math.floor,...x);
+    const round=(...x) => mapfun$1(Math.round,...x);
+    const atan2=(x,y,rad=true)=>{
+        if(typeof x === "number"){
+            if(typeof y === "number")return rad?Math.atan2(x,y):Math.atan2(x,y)*180/Math.PI;
+            else return mapfun$1(a=>atan2(x,a,rad),...y);
+        }
+        // else if(x.isComplex?.()){
+        //     if(typeof n === "number")return x.constructor.fromExpo(x.z**n,x.phi*n);
+        //     else return mapfun(a=>pow(x,a),...n);
+        // }
+        else if(x instanceof Array){
+            if(typeof y === "number") return mapfun$1(a=>atan2(a,y,rad),...x);
+            else if(y instanceof Array){
+                const Y=[];
+                for(let i=0;i<x.length;i++){
+                    Y.push(mapfun$1(a=>pow$1(x[i],a),...y));
+                }
+                return Y;
+            }
+        }
+    };
+    const fact=(...x)=>mapfun$1(n=> {
+            let i,
+            y = 1;
+            if (n == 0) y = 1;
+            else if (n > 0) for (i = 1; i <= n; i++) y *= i;
+            else y = NaN;
+            return y;
+        },...x);
+    const sign=(...x)=>mapfun$1(Math.sign,...x);
+
+    const sig=(...x)=>mapfun$1(n=>1/(1+e(-n)),...x);
+
+    const hypot=(...x)=>{
+        if(x.every(n=>typeof n === "number"))return Math.hypot(...x);
+        if(x.every(n=>n instanceof Array))return mapfun$1(
+            Math.hypot,
+            ...x
+        )
+    };
+
     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);
         }
@@ -113,11 +312,11 @@
     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);
         }
@@ -135,11 +334,11 @@
     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);
         }
@@ -157,11 +356,11 @@
     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);
         }
@@ -179,11 +378,11 @@
     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);
             }
@@ -225,8 +424,8 @@
     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));
@@ -240,8 +439,8 @@
     };
     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));
@@ -253,17 +452,17 @@
             }
         }
     };
-    const map$1=(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$1(value.arr.flat(1), a, b, c, d));
-        else if (value instanceof Complex) return new Complex(map$1(value.a, b, c, d), map$1(value.b, a, b, c, d));
-        else if (value instanceof Array) {
-            if (value.every((n) => typeof (n === "number"))) {
-                return value.map((n) => map$1(n, a, b, c, d));
+    const map$1=(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$1(x.arr.flat(1), a, b, c, d));
+        else if (x.isComplex?.()) return new x.constructor(map$1(x.a, b, c, d), map$1(x.b, a, b, c, d));
+        else if (x instanceof Array) {
+            if (x.every((n) => typeof (n === "number"))) {
+                return x.map((n) => map$1(n, a, b, c, d));
             } else {
-                let y = new Array(value.length);
-                for (let i = 0; i < value.length; i++) {
-                    y[i] = map$1(value[i], a, b, c, d);
+                let y = new Array(x.length);
+                for (let i = 0; i < x.length; i++) {
+                    y[i] = map$1(x[i], a, b, c, d);
                 }
             }
         }
@@ -271,8 +470,8 @@
     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));
@@ -307,14 +506,14 @@
             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;
         }
     };
@@ -334,9 +533,9 @@
             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) ;
@@ -363,109 +562,18 @@
      */
     const rad2deg = (...rad) => mapfun(x => x / Math.PI * 180, ...rad);
 
-    // Mixed calcul
-    const sum=(...x)=>{
-        if(x.every(n=>typeof n==="number")){
-            let s = x[0];
-            for (let i = 1; i < x.length; i++) s += x[i];
-            return s;
-        }
-        const Y=[];
-        for(let i=0;i<x.length;i++){
-            if(x[i] instanceof Array)Y.push(sum(...x[i]));
-            else if(x[i] instanceof Object){
-                Y.push(sum(...Object.values(x[i])));
-            }
-        }
-        return Y.length===1?Y[0]:Y;
-    };
-    const prod=(...x)=>{
-        if(x.every(n=>typeof n==="number")){
-            let p = x[0];
-            for (let i = 1; i < x.length; i++) p *= x[i];
-            return p;
-        }
-        const Y=[];
-        for(let i=0;i<x.length;i++){
-            if(x[i] instanceof Array)Y.push(prod(...x[i]));
-            else if(x[i] instanceof Object){
-                Y.push(prod(...Object.values(x[i])));
-            }
-        }
-        return Y.length===1?Y[0]:Y;
-    };
-    const min=(...num)=>{
-        if(num.every(n=>typeof n==="number"))return Math.min(...num);
-        const Y=[];
-        for(let i=0;i<num.length;i++){
-            if(num[i] instanceof Array)Y.push(min(...num[i]));
-            else if(num[i] instanceof Object){
-                Y.push(
-                        Object.fromEntries(
-                            [Object.entries(num[i]).sort((a,b)=>a[1]-b[1])[0]]
-                        )
-                    );
-            }
-        }
-        return Y.length===1?Y[0]:Y;
-    };
-    const max=(...num)=>{
-        if(num.every(n=>typeof n==="number"))return Math.max(...num);
-        const Y=[];
-        for(let i=0;i<num.length;i++){
-            if(num[i] instanceof Array)Y.push(min(...num[i]));
-            else if(num[i] instanceof Object){
-                Y.push(
-                        Object.fromEntries(
-                            [Object.entries(num[i]).sort((a,b)=>b[1]-a[1])[0]]
-                        )
-                    );
-            }
-        }
-        return Y.length===1?Y[0]:Y;
-    };
-    const accum=(...num)=>{
-        if(num.every(n=>typeof n==="number")){
-            let acc = num.reduce((x, y) => [...x, x[x.length - 1] + y], [0]);
-            acc.shift();
-            return acc;
-        }
-        const Y=[];
-        for(let i=0;i<num.length;i++){
-            if(num[i] instanceof Array)Y.push(accum(...num[i]));
-            else if(num[i] instanceof Object){
-                Y.push(null
-                        // Object.fromEntries(
-                        //     [Object.entries(num[i]).sort((a,b)=>b[1]-a[1])[0]]
-                        // )
-                    );
-            }
-        }
-        return Y.length===1?Y[0]:Y;
-    };
-
-    //moy
-    //med
-    //variance
-    //std
-    //mode
-    //acccum
-    //min2max
-    //max2min
-    //percentile
-
-    /** @module Math */
-    /**
-     * Checks if a value is within the specified range.
-     * @function
-     * @param {number} x - The value to check.
-     * @param {number} a - The start of the range.
-     * @param {number} b - The end of the range.
-     * @returns {boolean} Returns true if the value is within the range [a, b], otherwise false.
-     */
-    const inRange = (x, a, b) => {
-        const [min, max] = [Math.min(a, b), Math.max(a, b)];
-        return x >= min && x <= max;
+    /** @module Math */
+    /**
+     * Checks if a value is within the specified range.
+     * @function
+     * @param {number} x - The value to check.
+     * @param {number} a - The start of the range.
+     * @param {number} b - The end of the range.
+     * @returns {boolean} Returns true if the value is within the range [a, b], otherwise false.
+     */
+    const inRange = (x, a, b) => {
+        const [min, max] = [Math.min(a, b), Math.max(a, b)];
+        return x >= min && x <= max;
     };
 
     /**
@@ -558,385 +666,182 @@
         isApproximatlyEqual
     };
 
-    const powerSet=originalSet=>{
-        const subSets = [];
-        const NUMBER_OF_COMBINATIONS = 2 ** originalSet.length;
-        for (let i = 0; i < NUMBER_OF_COMBINATIONS; i += 1) {
-            const subSet = [];
-            for (let j = 0; j < originalSet.length; j += 1) {
-                if (i & (1 << j)) {
-                    subSet.push(originalSet[j]);
+    class Complex{
+        constructor(a = 0, b = 0) {
+            if(a instanceof Complex){
+                this.a=a.a;
+                this.b=a.b;
+            }
+            else if(typeof(a)==="object"){
+                if(("a" in a && "b" in a)){
+                    this.a=a.a;
+                    this.b=a.b;
+                }
+                else if(("a" in a && "z" in a)){
+                    this.a=a.a;
+                    this.b=sqrt$2((a.z**2)-(a.a**2));
+                }
+                else if(("a" in a && "phi" in a)){
+                    this.a=a.a;
+                    this.b=a.a*tan(a.phi);
+                }
+                else if(("b" in a && "z" in a)){
+                    this.b=a.b;
+                    this.a=sqrt$2((a.z**2)-(a.b**2));
+                }
+                else if(("b" in a && "phi" in a)){
+                    this.b=b;
+                    this.a=a.b/tan(a.phi);
+                }
+                else if(("z" in a && "phi" in a)){
+                    this.a=a.z*cos$2(a.phi);
+                    this.a=a.z*sin$2(a.phi);
                 }
             }
-            subSets.push(subSet);
+            else if(typeof(a)==="number"&&typeof(b)==="number"){
+                this.a = +a.toFixed(32);
+                this.b = +b.toFixed(32);
+            }
         }
-        return subSets;
-    };
-
-    // const subSet = (...arr) => {
-    //     let list = arange(0, 2 ** arr.length, 1);
-    //     let bin = list.map((n) => n.toString(2).padStart(arr.length, '0')).map((n) => n.split("").map((n) => +n));
-    //     let sub = bin.map((n) => n.map((m, i) => (m === 1 ? arr[i] : null))).map((n) => n.filter((x) => x !== null));
-    //     return sub;
-    // };
-    const subSet = null;
-
-    const Base={
-        _mode:Number,
-        _map:function(func,number,toBase){
-            if (number instanceof Matrix)
-                return new Matrix(
-                    number.rows,
-                    number.cols,
-                    number.arr.flat(1).map(n=>func(n,toBase))
-                );
-            else if (number instanceof Complex) return new Complex(func(number.a,toBase),func(number.b,toBase));
-            else if (number instanceof Array) return number.map((n) =>func(n,toBase));
-        },
-        dec2base(dec,base){
-            base<=10?this._mode=Number:this._mode=String;
-            //this._mode=String
-            if (typeof dec === "number") return this._mode((dec >>> 0).toString(base));
-              return this._map(this.dec2base,dec,base)
-        },
-        dec2bin(dec){
-            return this.dec2base(dec,2);
-        },
-        dec2oct(dec){
-            return this.dec2base(dec,8);
-        },
-        dec2hex(dec){
-            return this.dec2base(dec,16);
-        },
-        bin2base(bin, base) {
-            return this.dec2base(this.bin2dec(bin),base)
-        },
-        bin2dec(bin){
-            return this._mode("0b"+bin);
-        },
-        bin2oct(bin){
-            return this.bin2base(bin,8);
-        },
-        bin2hex(bin){
-            return this.bin2base(bin,16);
-        },
-        oct2dec(oct){
-            return this._mode("0o"+oct);
-        },
-        oct2bin(oct){
-            return this.dec2bin(this.oct2dec(oct))
-        },
-        oct2hex(oct){
-            return this.dec2hex(this.oct2dec(oct))
-        },
-        oct2base(oct, base) {
-            return this.dec2base(this.oct2dec(oct),base)
-        },
-        hex2dec(hex){
-            return this._mode("0x"+hex);
-        },
-        hex2bin(hex){
-            return this.dec2bin(this.hex2dec(hex))
-        },
-        hex2oct(hex){
-            return this.dec2oct(this.hex2dec(hex))
-        },
-        hex2base(hex, base) {
-            return this.dec2base(this.hex2dec(hex),base)
-        },
-        IEEE32toDec(Bin){
-            let IEEE32=Bin.split(" ").join("").padEnd(32,"0");
-            let s=IEEE32[0];
-            let e=2**(+("0b"+IEEE32.slice(1,9))-127);
-            let m=IEEE32.slice(9,32).split("").map(n=>+n);
-            let M=m.map((n,i)=>n*(2**(-i-1))).reduce((a,b)=>a+b,0);
-            let dec=(-1)**s*(1+M)*e;
-            return dec
-        },
-        IEEE64toDec(Bin){
-            let IEEE64=Bin.split(" ").join("").padEnd(64,"0");
-            let s=IEEE64[0];
-            let e=2**(+("0b"+IEEE64.slice(1,12))-1023);
-            let m=IEEE64.slice(13,64).split("").map(n=>+n);
-            let M=m.map((n,i)=>n*(2**(-i-1))).reduce((a,b)=>a+b,0);
-            let dec=(-1)**s*(1+M)*e;
-            return dec;
+        isComplex(){
+            return true
         }
-    };
-
-    const Logic$1={
-        _mode:Number,
-        _map:function(func,a,b){
-            if (a instanceof Matrix)
-                return new Matrix(
-                    a.rows,
-                    a.cols,
-                    a.arr.flat(1).map((n) => func(n, b))
-                );
-            else if (a instanceof Complex) return new Complex(func(a.a, b), func(a.b, b));
-            else if (a instanceof Array) return a.map((n) => func(n, b));      
-        },
-        not:function(input){
-            if(["number","boolean"].includes(typeof input)) return Logic$1._mode(!input);
-            else return this._map(this.not,input)
-        },
-        and:function(a, ...b){
-            if(["number","boolean"].includes(typeof a))return Logic$1._mode(b.reduce((n, m) => (n &= m), a));
-            else return this._map(this.and,a,b)
-        },
-        or:function(a, ...b) {
-            if(["number","boolean"].includes(typeof a)) return Logic$1._mode(b.reduce((n, m) => (n |= m), a));
-            else return this._map(this.or,a,b);
-        },
-        nand:function(a, ...b) {
-            return this.not(this.and(a, b));
-        },
-        nor:function(a, ...b) {
-            return this.not(this.or(a, b));
-        },
-        xor:function(a,...b){
-            let arr=[a,...b];
-            if(["number","boolean"].includes(typeof a))return this._mode(arr.reduce((length,cur)=>{
-                if(+cur===1)length+=1;
-                return length;
-            },0)===1);
-            else return this._map(this.xor,a,b);
-        },
-        xnor:function(a,...b){
-            return Logic$1.not(Logic$1.xor(a,b))
+        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;
         }
-        
-    };
-
-    class Permutation {
-        static withDiscount(arr, l = arr.length) {
-            if (l === 1) return arr.map((n) => [n]);
-            const permutations = [];
-            let smallerPermutations;
-            smallerPermutations = this.withDiscount(arr, l - 1);
-            arr.forEach((currentOption) => {
-                smallerPermutations.forEach((smallerPermutation) => {
-                    permutations.push([currentOption].concat(smallerPermutation));
-                });
-            });
-            return permutations;
-        }
-        static withoutDiscount(arr) {
-            const l = arr.length;
-            if (l === 1) return arr.map((n) => [n]);
-            const permutations = [];
-            const smallerPermutations = this.withoutDiscount(arr.slice(1));
-            const firstOption = arr[0];
-            for (let i = 0; i < smallerPermutations.length; i++) {
-                const smallerPermutation = smallerPermutations[i];
-                for (let j = 0; j <= smallerPermutation.length; j++) {
-                    const permutationPrefix = smallerPermutation.slice(0, j);
-                    const permutationSuffix = smallerPermutation.slice(j);
-                    permutations.push(permutationPrefix.concat([firstOption], permutationSuffix));
-                }
-            }
-            return permutations;
-        }
-    }
-
-    class Combinaison {
-        static withDiscount(comboOptions, comboLength) {
-            if (comboLength === 1) {
-                return comboOptions.map((comboOption) => [comboOption]);
-            }
-            const combos = [];
-            comboOptions.forEach((currentOption, optionIndex) => {
-                const smallerCombos = this.withDiscount(comboOptions.slice(optionIndex), comboLength - 1);
-                smallerCombos.forEach((smallerCombo) => {
-                    combos.push([currentOption].concat(smallerCombo));
-                });
-            });
-            return combos;
-        }
-        static withoutDiscount(comboOptions, comboLength) {
-            if (comboLength === 1) {
-                return comboOptions.map((comboOption) => [comboOption]);
-            }
-            const combos = [];
-            comboOptions.forEach((currentOption, optionIndex) => {
-                const smallerCombos = this.withoutDiscount(comboOptions.slice(optionIndex + 1), comboLength - 1);
-                smallerCombos.forEach((smallerCombo) => {
-                    combos.push([currentOption].concat(smallerCombo));
-                });
-            });
-
-            return combos;
-        }
-    }
-    const combinaison=(comboOptions, comboLength, discount=false)=>Combinaison[discount?"withDiscount":"withoutDiscount"](comboOptions, comboLength);
-
-    class Random {
-        static float(a = 1, b) {
-            return b ? Math.random() * (b - a) + a : a * Math.random();
-        }
-        static int(a, b) {
-            return Math.floor(this.float(a, b));
-        }
-        static char(upperCase){
-            upperCase=upperCase??this.bool();
-            const Char=String.fromCharCode(this.int(97,120));
-            return upperCase?Char.toUpperCase():Char;
-        }
-        static bool(){
-            return [false,true][Math.floor(Math.random()*2)];
-        }
-        static string(length,upperCase){
-            return length instanceof Array?
-                new Array(this.int(...length)).fill(0).map(() => this.char(upperCase)).join(""):
-                new Array(length).fill(0).map(() => this.char(upperCase)).join("");
-        }
-        static bin() {
-            return this.int(2);
-        }
-        static oct() {
-            return this.int(8);
-        }
-        static dec() {
-            return this.int(8);
-        }
-        static hex() {
-            return this.int(16);
-        }
-        static choice(choices = [1, 2, 3], p = new Array(choices.length).fill(1 / choices.length)) {
-            let newchoice = new Array(100);
-            p=Utils.accum(...p).map(n=>n*100);
-            newchoice.fill(choices[0], 0, p[0]);
-            for (let i = 1; i < choices.length; i++) newchoice.fill(choices[i], p[i - 1], p[i]);
-            return newchoice[this.int(newchoice.length - 1)];
-        }
-        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));
-        }
-        static ints(n, a, b) {
-            return new Array(n).fill(0).map(() => this.int(a, b));
+          
+        get clone() {
+            return new Complex(this.a, this.b);
         }
-        static bools(n){
-            return  new Array(n).fill(0).map(() => this.bool());
+        get z(){
+            return hypot(this.a,this.b);    
         }
-        static bins(n) {
-            return new Array(n).fill(0).map(() => this.int(2));
+        get phi(){
+            return atan2(this.b , this.a);        
         }
-        static octs(n) {
-            return new Array(n).fill(0).map(() => this.int(8));
+        static Zero() {
+            return new Complex(0, 0);
         }
-        static decs(n) {
-            return new Array(n).fill(0).map(() => this.int(10));
+        get conj() {
+            return new Complex(this.a, -this.b);
         }
-        static hexs(n) {
-            return new Array(n).fill(0).map(() => this.int(16));
+        get inv() {
+            return new Complex(this.a / (pow$1(this.a, 2) + pow$1(this.b, 2)), -this.b / (pow$1(this.a, 2) + pow$1(this.b, 2)));
         }
-        static choices(n, choices, p) {
-            return new Array(n).fill(0).map(() => this.choice(choices, p));
+        add(...z) {
+            for (let i = 0; i < z.length; i++) {
+                if (typeof z[i] === "number") z[i] = new Complex(z[i], 0);
+            }
+            let re = z.map((n) => n.a);
+            let im = z.map((n) => n.b);
+            this.a+=+sum(...re).toFixed(15);
+            this.b+=+sum(...im).toFixed(15);
+            return this;
         }
-        static perm(...arr) {
-            // permutation
-            return arr.permS[this.int(arr.length)];
+        sub(...z) {
+            for (let i = 0; i < z.length; i++) {
+                if (typeof z[i] === "number") z[i] = new Complex(z[i], 0);
+            }
+            let re = z.map((n) => n.a);
+            let im = z.map((n) => n.b);
+            this.a-=+sum(...re).toFixed(15);
+            this.b-=+sum(...im).toFixed(15);
+            return this;
         }
-        static color() {
-            return "#" + Base.dec2hex(this.float(16777216)).padStart(6,0);
+        mul(...z){
+            for (let i = 0; i < z.length; i++) {
+                if (typeof z[i] === "number") z[i] = new Complex(z[i], 0);
+            }
+            let Z=+prod(this.z,...z.map(n=>n.z)).toFixed(15);
+            let phi=+sum(this.phi,...z.map(n=>n.phi)).toFixed(15);
+            this.a=+(Z*cos$2(phi).toFixed(15)).toFixed(14);
+            this.b=+(Z*sin$2(phi).toFixed(15)).toFixed(14);    
+            return this;
         }
-        static colors(n) {
-            return new Array(n).fill(null).map(()=>this.color());
+        div(...z) {
+            for (let i = 0; i < z.length; i++) {
+                if (typeof z[i] === "number") z[i] = new Complex(z[i], 0);
+            }
+            let Z=+(this.z/prod(...z.map(n=>n.z))).toFixed(15);
+            let phi=+(this.phi-sum(...z.map(n=>n.phi))).toFixed(15);
+            this.a=+(Z*cos$2(phi).toFixed(15)).toFixed(15);
+            this.b=+(Z*sin$2(phi).toFixed(15)).toFixed(15);
+            return this;
         }
-        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)
-            )
-            
+        pow(n) {
+            if (floor(n) === n && n > 0) {
+                let z=+(this.z**n).toFixed(15);
+                let phi=+(this.phi*n).toFixed(15);
+                this.a=+(z*cos$2(phi).toFixed(15)).toFixed(15);
+                this.b=+(z*sin$2(phi).toFixed(15)).toFixed(15);
+            }
+            return this;
         }
-        static complexInt(a = [0,1], b = [0,1]) {
+        static fromExpo(z, phi) {
             return new Complex(
-                this.int(a[0], a[1]),
-                this.int(b[0], b[1])
+                +(z * cos$2(phi)).toFixed(13), 
+                +(z * sin$2(phi)).toFixed(13)
                 );
         }
-        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());
+        get expo() {
+            return [this.z, this.phi];
         }
-        static matrix(r,c,min,max){
-            return matrix(r,c,this.floats(r*c,min,max))
+        static add(c,...z) {
+            return c.clone.add(...z);
         }
-        static matrixInt(r,c,min,max){
-            return matrix(r,c,this.ints(r*c,min,max))
+        static sub(c,...z) {
+            return c.clone.sub(...z);
         }
-        static matrixBin(r,c){
-            return matrix(r,c,this.bins(r*c))
+        static mul(c,...z) {
+            return c.clone.mul(...z);
         }
-        static matrixOct(r,c){
-            return matrix(r,c,this.octs(r*c))
+        static div(c,...z) {
+            return c.clone.div(...z);
         }
-        static matrixDec(r,c){
-            return matrix(r,c,this.decs(r*c))
+        static pow(z,n){
+            return z.clone.pow(n);
         }
-        static matrixHex(r,c){
-            return matrix(r,c,this.hex(r*c))
+        static xpowZ(x){
+            return complex((x**this.a)*cos$2(this.b*ln(x)),(x**this.a)*sin$2(this.b*ln(x)));
         }
-        static matrixColor(r,c){
-            return matrix(r,c,this.colors(r*c))
+        sqrtn(n=2){
+            return complex(sqrtn(this.z,n)*cos$2(this.phi/n),sqrtn(this.z,n)*sin$2(this.phi/n));
         }
-        static matrixComplex(r,c,a,b){
-            return matrix(r,c,this.complexes(r*c,a,b))
+        get sqrt(){
+            return this.sqrtn(2);
         }
-        static matrixComplexInt(r,c,a,b){
-            return matrix(r,c,this.complexesInt(r*c,a,b))
+        get log(){
+            return complex(this.z,this.phi);
         }
-        static matrixComplexBin(r,c){
-            return matrix(r,c,this.complexesBin(r*c))
+        get cos(){
+            return complex(cos$2(this.a)*cosh$1(this.b),sin$2(this.a)*sinh$1(this.b))
         }
-        static matrixComplexOct(r,c){
-            return matrix(r,c,this.complexesBin(r*c))
+        get sin(){
+            return complex(sin$2(this.a)*cosh$1(this.b),cos$2(this.a)*sinh$1(this.b))
         }
-        static matrixComplexDec(r,c){
-            return matrix(r,c,this.complexesBin(r*c))
+        get tan(){
+            const de=cos$2(this.a*2)+cosh$1(this.b*2);
+            return complex(sin$2(2*this.a)/de,sinh$1(2*this.b)/de);
         }
-        static matrixComplexHex(r,c){
-            return matrix(r,c,this.complexesBin(r*c))
+    }
+    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)
+    };
 
     const preload=(url)=>{
         const xhr = new XMLHttpRequest();
@@ -1362,29 +1267,407 @@
         }
     };
 
-    class UseIPC {
-        #channel;
-        #eventData;
-        #handlers;
-        #uuid;
-        #subscribers;
-        #currentRooms;
-        constructor(name = "") {
-            this.#channel = new BroadcastChannel(name);
-            this.#eventData = new Map();
-            this.#handlers = new Map(); // Map<event, Array<{fn, rooms}>>
-            this.#uuid = "ziko-channel:" + Random.string(10);
-            this.#subscribers = new Set([this.#uuid]);
-            this.#currentRooms = new Set(); 
-            this.#channel.addEventListener("message", (e) => {
-                const { last_sent_event, userId, eventData, rooms } = e.data;
-                if (userId === this.#uuid) return; // ignore own messages
-                // broadcast if no rooms, else check intersection
-                if (rooms && rooms.length && !rooms.some(r => this.#currentRooms.has(r))) return;
-                this.#subscribers.add(userId);
-                this.#eventData = new Map(eventData);
-                const handlersList = this.#handlers.get(last_sent_event);
-                if (!handlersList) return;
+    const powerSet=originalSet=>{
+        const subSets = [];
+        const NUMBER_OF_COMBINATIONS = 2 ** originalSet.length;
+        for (let i = 0; i < NUMBER_OF_COMBINATIONS; i += 1) {
+            const subSet = [];
+            for (let j = 0; j < originalSet.length; j += 1) {
+                if (i & (1 << j)) {
+                    subSet.push(originalSet[j]);
+                }
+            }
+            subSets.push(subSet);
+        }
+        return subSets;
+    };
+
+    // const subSet = (...arr) => {
+    //     let list = arange(0, 2 ** arr.length, 1);
+    //     let bin = list.map((n) => n.toString(2).padStart(arr.length, '0')).map((n) => n.split("").map((n) => +n));
+    //     let sub = bin.map((n) => n.map((m, i) => (m === 1 ? arr[i] : null))).map((n) => n.filter((x) => x !== null));
+    //     return sub;
+    // };
+    const subSet = null;
+
+    const Base={
+        _mode:Number,
+        _map:function(func,number,toBase){
+            if (number instanceof Matrix)
+                return new Matrix(
+                    number.rows,
+                    number.cols,
+                    number.arr.flat(1).map(n=>func(n,toBase))
+                );
+            else if (number instanceof Complex) return new Complex(func(number.a,toBase),func(number.b,toBase));
+            else if (number instanceof Array) return number.map((n) =>func(n,toBase));
+        },
+        dec2base(dec,base){
+            base<=10?this._mode=Number:this._mode=String;
+            //this._mode=String
+            if (typeof dec === "number") return this._mode((dec >>> 0).toString(base));
+              return this._map(this.dec2base,dec,base)
+        },
+        dec2bin(dec){
+            return this.dec2base(dec,2);
+        },
+        dec2oct(dec){
+            return this.dec2base(dec,8);
+        },
+        dec2hex(dec){
+            return this.dec2base(dec,16);
+        },
+        bin2base(bin, base) {
+            return this.dec2base(this.bin2dec(bin),base)
+        },
+        bin2dec(bin){
+            return this._mode("0b"+bin);
+        },
+        bin2oct(bin){
+            return this.bin2base(bin,8);
+        },
+        bin2hex(bin){
+            return this.bin2base(bin,16);
+        },
+        oct2dec(oct){
+            return this._mode("0o"+oct);
+        },
+        oct2bin(oct){
+            return this.dec2bin(this.oct2dec(oct))
+        },
+        oct2hex(oct){
+            return this.dec2hex(this.oct2dec(oct))
+        },
+        oct2base(oct, base) {
+            return this.dec2base(this.oct2dec(oct),base)
+        },
+        hex2dec(hex){
+            return this._mode("0x"+hex);
+        },
+        hex2bin(hex){
+            return this.dec2bin(this.hex2dec(hex))
+        },
+        hex2oct(hex){
+            return this.dec2oct(this.hex2dec(hex))
+        },
+        hex2base(hex, base) {
+            return this.dec2base(this.hex2dec(hex),base)
+        },
+        IEEE32toDec(Bin){
+            let IEEE32=Bin.split(" ").join("").padEnd(32,"0");
+            let s=IEEE32[0];
+            let e=2**(+("0b"+IEEE32.slice(1,9))-127);
+            let m=IEEE32.slice(9,32).split("").map(n=>+n);
+            let M=m.map((n,i)=>n*(2**(-i-1))).reduce((a,b)=>a+b,0);
+            let dec=(-1)**s*(1+M)*e;
+            return dec
+        },
+        IEEE64toDec(Bin){
+            let IEEE64=Bin.split(" ").join("").padEnd(64,"0");
+            let s=IEEE64[0];
+            let e=2**(+("0b"+IEEE64.slice(1,12))-1023);
+            let m=IEEE64.slice(13,64).split("").map(n=>+n);
+            let M=m.map((n,i)=>n*(2**(-i-1))).reduce((a,b)=>a+b,0);
+            let dec=(-1)**s*(1+M)*e;
+            return dec;
+        }
+    };
+
+    const Logic$1={
+        _mode:Number,
+        _map:function(func,a,b){
+            if (a instanceof Matrix)
+                return new Matrix(
+                    a.rows,
+                    a.cols,
+                    a.arr.flat(1).map((n) => func(n, b))
+                );
+            else if (a instanceof Complex) return new Complex(func(a.a, b), func(a.b, b));
+            else if (a instanceof Array) return a.map((n) => func(n, b));      
+        },
+        not:function(input){
+            if(["number","boolean"].includes(typeof input)) return Logic$1._mode(!input);
+            else return this._map(this.not,input)
+        },
+        and:function(a, ...b){
+            if(["number","boolean"].includes(typeof a))return Logic$1._mode(b.reduce((n, m) => (n &= m), a));
+            else return this._map(this.and,a,b)
+        },
+        or:function(a, ...b) {
+            if(["number","boolean"].includes(typeof a)) return Logic$1._mode(b.reduce((n, m) => (n |= m), a));
+            else return this._map(this.or,a,b);
+        },
+        nand:function(a, ...b) {
+            return this.not(this.and(a, b));
+        },
+        nor:function(a, ...b) {
+            return this.not(this.or(a, b));
+        },
+        xor:function(a,...b){
+            let arr=[a,...b];
+            if(["number","boolean"].includes(typeof a))return this._mode(arr.reduce((length,cur)=>{
+                if(+cur===1)length+=1;
+                return length;
+            },0)===1);
+            else return this._map(this.xor,a,b);
+        },
+        xnor:function(a,...b){
+            return Logic$1.not(Logic$1.xor(a,b))
+        }
+        
+    };
+
+    class Permutation {
+        static withDiscount(arr, l = arr.length) {
+            if (l === 1) return arr.map((n) => [n]);
+            const permutations = [];
+            let smallerPermutations;
+            smallerPermutations = this.withDiscount(arr, l - 1);
+            arr.forEach((currentOption) => {
+                smallerPermutations.forEach((smallerPermutation) => {
+                    permutations.push([currentOption].concat(smallerPermutation));
+                });
+            });
+            return permutations;
+        }
+        static withoutDiscount(arr) {
+            const l = arr.length;
+            if (l === 1) return arr.map((n) => [n]);
+            const permutations = [];
+            const smallerPermutations = this.withoutDiscount(arr.slice(1));
+            const firstOption = arr[0];
+            for (let i = 0; i < smallerPermutations.length; i++) {
+                const smallerPermutation = smallerPermutations[i];
+                for (let j = 0; j <= smallerPermutation.length; j++) {
+                    const permutationPrefix = smallerPermutation.slice(0, j);
+                    const permutationSuffix = smallerPermutation.slice(j);
+                    permutations.push(permutationPrefix.concat([firstOption], permutationSuffix));
+                }
+            }
+            return permutations;
+        }
+    }
+
+    class Combinaison {
+        static withDiscount(comboOptions, comboLength) {
+            if (comboLength === 1) {
+                return comboOptions.map((comboOption) => [comboOption]);
+            }
+            const combos = [];
+            comboOptions.forEach((currentOption, optionIndex) => {
+                const smallerCombos = this.withDiscount(comboOptions.slice(optionIndex), comboLength - 1);
+                smallerCombos.forEach((smallerCombo) => {
+                    combos.push([currentOption].concat(smallerCombo));
+                });
+            });
+            return combos;
+        }
+        static withoutDiscount(comboOptions, comboLength) {
+            if (comboLength === 1) {
+                return comboOptions.map((comboOption) => [comboOption]);
+            }
+            const combos = [];
+            comboOptions.forEach((currentOption, optionIndex) => {
+                const smallerCombos = this.withoutDiscount(comboOptions.slice(optionIndex + 1), comboLength - 1);
+                smallerCombos.forEach((smallerCombo) => {
+                    combos.push([currentOption].concat(smallerCombo));
+                });
+            });
+
+            return combos;
+        }
+    }
+    const combinaison=(comboOptions, comboLength, discount=false)=>Combinaison[discount?"withDiscount":"withoutDiscount"](comboOptions, comboLength);
+
+    class Random {
+        static float(a = 1, b) {
+            return b ? Math.random() * (b - a) + a : a * Math.random();
+        }
+        static int(a, b) {
+            return Math.floor(this.float(a, b));
+        }
+        static char(upperCase){
+            upperCase=upperCase??this.bool();
+            const Char=String.fromCharCode(this.int(97,120));
+            return upperCase?Char.toUpperCase():Char;
+        }
+        static bool(){
+            return [false,true][Math.floor(Math.random()*2)];
+        }
+        static string(length,upperCase){
+            return length instanceof Array?
+                new Array(this.int(...length)).fill(0).map(() => this.char(upperCase)).join(""):
+                new Array(length).fill(0).map(() => this.char(upperCase)).join("");
+        }
+        static bin() {
+            return this.int(2);
+        }
+        static oct() {
+            return this.int(8);
+        }
+        static dec() {
+            return this.int(8);
+        }
+        static hex() {
+            return this.int(16);
+        }
+        static choice(choices = [1, 2, 3], p = new Array(choices.length).fill(1 / choices.length)) {
+            let newchoice = new Array(100);
+            p=Utils.accum(...p).map(n=>n*100);
+            newchoice.fill(choices[0], 0, p[0]);
+            for (let i = 1; i < choices.length; i++) newchoice.fill(choices[i], p[i - 1], p[i]);
+            return newchoice[this.int(newchoice.length - 1)];
+        }
+        static shuffleArr(arr){
+            return arr.sort(()=>0.5-Math.random())    
+        }
+        static floats(n, a, b) {
+            return new Array(n).fill(0).map(() => this.float(a, b));
+        }
+        static ints(n, a, b) {
+            return new Array(n).fill(0).map(() => this.int(a, b));
+        }
+        static bools(n){
+            return  new Array(n).fill(0).map(() => this.bool());
+        }
+        static bins(n) {
+            return new Array(n).fill(0).map(() => this.int(2));
+        }
+        static octs(n) {
+            return new Array(n).fill(0).map(() => this.int(8));
+        }
+        static decs(n) {
+            return new Array(n).fill(0).map(() => this.int(10));
+        }
+        static hexs(n) {
+            return new Array(n).fill(0).map(() => this.int(16));
+        }
+        static choices(n, choices, p) {
+            return new Array(n).fill(0).map(() => this.choice(choices, p));
+        }
+        static perm(...arr) {
+            // permutation
+            return arr.permS[this.int(arr.length)];
+        }
+        static color() {
+            return "#" + Base.dec2hex(this.float(16777216)).padStart(6,0);
+        }
+        static colors(n) {
+            return new Array(n).fill(null).map(()=>this.color());
+        }
+
+        // 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))
+        // }
+    }
+
+    class UseIPC {
+        #channel;
+        #eventData;
+        #handlers;
+        #uuid;
+        #subscribers;
+        #currentRooms;
+        constructor(name = "") {
+            this.#channel = new BroadcastChannel(name);
+            this.#eventData = new Map();
+            this.#handlers = new Map(); // Map<event, Array<{fn, rooms}>>
+            this.#uuid = "ziko-channel:" + Random.string(10);
+            this.#subscribers = new Set([this.#uuid]);
+            this.#currentRooms = new Set(); 
+            this.#channel.addEventListener("message", (e) => {
+                const { last_sent_event, userId, eventData, rooms } = e.data;
+                if (userId === this.#uuid) return; // ignore own messages
+                // broadcast if no rooms, else check intersection
+                if (rooms && rooms.length && !rooms.some(r => this.#currentRooms.has(r))) return;
+                this.#subscribers.add(userId);
+                this.#eventData = new Map(eventData);
+                const handlersList = this.#handlers.get(last_sent_event);
+                if (!handlersList) return;
                 handlersList.forEach(({ fn, rooms: handlerRooms }) => {
                     // trigger if listener has no room filter, or intersects subscriber rooms
                     if (!handlerRooms || handlerRooms.length === 0 ||
@@ -3314,365 +3597,183 @@
         }, Array.isArray(obj) ? [] : {});
     }
 
-    class Matrix{
-        constructor(rows, cols, element = [] ) {
-            if(rows instanceof Matrix){
-                this.arr=rows.arr;
-                this.rows=rows.rows;
-                this.cols=rows.cols;
-            }
-            else {
-            let arr = [],
-                i,
-                j;
-            if (arguments[0] instanceof Array) {
-                rows = arguments[0].length;
-                cols = arguments[0][0].length;
-                arr = arguments[0];
-            } else {
-                for (i = 0; i < rows; i++) {
-                    arr.push([]);
-                    arr[i].push(new Array(cols));
-                    for (j = 0; j < cols; j++) {
-                        arr[i][j] = element[i * cols + j];
-                        if (element[i * cols + j] == undefined) arr[i][j] = 0;
-                    }
-                }
-            }
-            this.rows = rows;
-            this.cols = cols;
-            this.arr = arr;   
-        }
-        this.#maintain();
-            //Object.seal(this);
-        }
-        toString(){
-            return arr2str(this.arr);
-        }
-        at(i=0,j=undefined){
-            if(i<0)i=this.rows+i;
-            if(j==undefined) return this.arr[i];
-            if(j<0)j=this.cols+j;
-            return this.arr[i][j];
-        }
-        reshape(newRows, newCols) {
-            let check = newRows * newCols === this.rows * this.cols;
-            if (check) return new Matrix(newRows, newCols, this.arr.flat(1));
-            else console.error("Err");
-        }
-        static eye(size) {
-            let result = new Matrix(size, size);
-            for (let i = 0; i < size; i++) for (let j = 0; j < size; j++) i === j ? (result.arr[i][j] = 1) : (result.arr[i][j] = 0);
-            return result;
-        }
-        get clone() {
-            return new Matrix(this.rows, this.cols, this.arr.flat(1));
-        }
-        get size() {
-            return this.rows * this.cols;
-        } 
-        get shape() {
-            return [this.rows, this.cols];
-        }
-        get reel() {
-            return new Matrix(this.cols, this.rows, this.arr.flat(1).reel);
-        }
-        get imag() {
-            return new Matrix(this.cols, this.rows, this.arr.flat(1).imag);
-        }
-        [Symbol.iterator]() {
-          return this.arr[Symbol.iterator]();
-        }
-        #maintain() {
-        for (let i = 0; i < this.arr.length; i++) {
-            Object.defineProperty(this, i, {
-            value: this.arr[i],
-            writable: true,
-            configurable: true,
-            enumerable: false 
-            });
-            }
-        }
-        get(row = 0, col = 0) {
-            if (col == -1) return this.arr[row];
-            else if (row == -1) return this.arr.map((n) => n[col]);
-            else return this.arr[row][col];
-        }
-        set(row = 0, col = 0, value) {
-            if (col == -1) return (this.arr[row] = value);
-            else if (row == -1) {
-                for (let i = 0; i < this.cols; i++) {
-                    this.arr[i][col] = value[i] || 0;
-                }
-                return this.arr;
-            }
-            return (this.arr[row][col] = value);
-        }
-        get isSquare() {
-            return this.rows / this.cols === 1;
-        }
-        get isSym() {
-            if (!this.isSquare) return false;
-            const T = this.T;
-            const M = this.clone;
-            return Matrix.sub(M, T).max == 0 && Matrix.sub(M, T).min == 0;
-        }
-        get isAntiSym() {
-            if (!this.isSquare) return false;
-            const T = this.T;
-            const M = this.clone;
-            return Matrix.add(M, T).max == 0 && Matrix.add(M, T).min == 0;
-        }
-        get isDiag() {
-            if (!this.isSquare) return false;
-            const T = this.T;
-            const M = this.clone;
-            const MT = Matrix.mul(M, T);
-            const TM = Matrix.dot(T, M);
-            return Matrix.sub(MT, TM).max == 0 && Matrix.sub(MT, TM).min == 0;
-        }
-        get isOrtho() {
-            if (!this.isSquare) return false;
-            return this.isDiag && (this.det == 1 || this.det == -1);
-        }
-        get isIdemp() {
-            if (!this.isSquare) return false;
-            const M = this.clone;
-            const MM = Matrix.dot(M, M);
-            return Matrix.sub(MM, M).max == 0 && Matrix.sub(MM, M).min == 0;
-        }
-        get T() {
-            let transpose = [];
-            for (let i = 0; i < this.arr[0].length; i++) {
-                transpose[i] = [];
-                for (let j = 0; j < this.arr.length; j++) {
-                    transpose[i][j] = this.arr[j][i];
-                }
+    function matrix_inverse(M) {
+        if(M.row !== M.cols) throw Error('is not a square matrix"')
+        if (M.det === 0) throw Error("determinant should not equal 0");
+        const { arr } = M;
+        if (arr.length !== arr[0].length) return;
+        var i = 0, ii = 0, j = 0, dim = arr.length, e = 0;
+        var I = [], C = [];
+        for (i = 0; i < dim; i += 1) {
+            I[I.length] = [];
+            C[C.length] = [];
+            for (j = 0; j < dim; j += 1) {
+                if (i == j) I[i][j] = 1;
+                else I[i][j] = 0;
+                C[i][j] = arr[i][j];
             }
-            return new Matrix(this.cols, this.rows, transpose.flat(1));
         }
-        get det() {
-            if (!this.isSquare) return new Error("is not square matrix");
-            if (this.rows == 1) return this.arr[0][0];
-            function determinat(M) {
-                if (M.length == 2) {
-                    if (M.flat(1).some((n) => n instanceof Matrix)) {
-                        console.warn("Tensors are not completely supported yet ...");
-                        return;
+        for (i = 0; i < dim; i += 1) {
+            e = C[i][i];
+            if (e == 0) {
+                for (ii = i + 1; ii < dim; ii += 1) {
+                    if (C[ii][i] != 0) {
+                        for (j = 0; j < dim; j++) {
+                            e = C[i][j];
+                            C[i][j] = C[ii][j];
+                            C[ii][j] = e;
+                            e = I[i][j];
+                            I[i][j] = I[ii][j];
+                            I[ii][j] = e;
+                        }
+                        break;
                     }
-                    return Utils.sub(Utils.mul(M[0][0],M[1][1]),Utils.mul(M[0][1],M[1][0]))
                 }
-                var answer = 0;
-                for (var i = 0; i < M.length; i++) {
-                    //console.log(M[0][i]);
-                    /*answer = answer.add(
-                        pow(-1, i)
-                            .mul(M[0][i])
-                            .mul(determinat(deleteRowAndColumn(M, i)))
-                    );*/
-                    //const to_be_added=Utils.add(Utils.mul(pow(-1, i),Utils.mul(M[0][i],determinat(deleteRowAndColumn(M, i)))));
-                    const to_be_added=Utils.add(Utils.mul(pow$1(-1, i),Utils.mul(M[0][i],determinat(deleteRowAndColumn(M, i)))));
-                    answer=Utils.add(answer,to_be_added);
-                }
-                return answer;
+                e = C[i][i];
+                if (e == 0) return;
             }
-            function deleteRowAndColumn(M, index) {
-                var temp = [];
-                for (let i = 0; i < M.length; i++) temp.push(M[i].slice(0));
-                temp.splice(0, 1);
-                for (let i = 0; i < temp.length; i++) temp[i].splice(index, 1);
-                return temp;
+            for (j = 0; j < dim; j++) {
+                C[i][j] = C[i][j] / e;
+                I[i][j] = I[i][j] / e;
             }
-            return determinat(this.arr);
-        }
-        get inv() {
-            if (!this.isSquare) return new Error("is not square matrix");
-            if (this.det === 0) return "determinat = 0 !!!";
-            let A = InverseMatrixe(this.arr);
-            return new Matrix(this.rows, this.cols, A.flat(1));
-        }
-        static zeros(rows, cols) {
-            let result = new Matrix(rows, cols);
-            for (let i = 0; i < rows; i++) for (var j = 0; j < cols; j++) result.arr[i][j] = 0;
-            return result;
-        }
-        static ones(rows, cols) {
-            let result = new Matrix(rows, cols);
-            for (let i = 0; i < rows; i++) for (let j = 0; j < cols; j++) result.arr[i][j] = 1;
-            return result;
-        }
-        static nums(rows, cols, number) {
-            let result = new Matrix(rows, cols);
-            for (let i = 0; i < rows; i++) for (let j = 0; j < cols; j++) result.arr[i][j] = number;
-            return result;
-        }
-        static get rand(){
-            return {
-                int:(rows, cols, a, b)=>{
-                    let result = new Matrix(rows, cols);
-                    for (let i = 0; i < rows; i++) for (let j = 0; j < cols; j++) result.arr[i][j] = Random.randInt(a, b);
-                    return result;
-                },
-                bin:(rows,cols)=>{
-                    let result = new Matrix(rows, cols);
-                    for (let i = 0; i < rows; i++) {
-                        for (let j = 0; j < cols; j++) result.arr[i][j] = Random.randBin;
-                    }
-                    return result;       
-                },
-                hex:(rows,cols)=>{
-                    let result = new Matrix(rows, cols);
-                    for (let i = 0; i < rows; i++) {
-                        for (let j = 0; j < cols; j++) result.arr[i][j] = Random.randHex;
-                    }
-                    return result;       
-                },
-                choices:(rows, cols, choices, p)=>{
-                    let result = new Matrix(rows, cols);
-                    for (let i = 0; i < rows; i++) for (let j = 0; j < cols; j++) result.arr[i][j] = Random.choice(choices, p);
-                    return result
-                },
-                permutation:(rows,cols,arr)=>{
-                    //return new Matrix(rows, cols, Random.permutation(...arr))
+            for (ii = 0; ii < dim; ii++) {
+                if (ii == i) {
+                    continue;
                 }
-            }
-        }
-        static rands(rows, cols, a = 1, b) {
-            let result = new Matrix(rows, cols);
-            for (let i = 0; i < rows; i++) for (let j = 0; j < cols; j++) result.arr[i][j] = Random.rand(a, b);
-            return result;
-        }
-        map(Imin, Imax, Fmin, Fmax) {
-            return Utils.map(this, Imin, Imax, Fmin, Fmax);
-        }
-        lerp(min, max) {
-            return Utils.lerp(this, min, max);
-        }
-        norm(min, max) {
-            return Utils.norm(this, min, max);
-        }
-        clamp(min, max) {
-            return Utils.clamp(this, min, max);
-        }
-        static map(matrix, Imin, Imax, Fmin, Fmax) {
-            return Utils.map(matrix, Imin, Imax, Fmin, Fmax);
-        }
-        static lerp(matrix, min, max) {
-            return Utils.lerp(matrix, min, max);
-        }
-        static norm(matrix, min, max) {
-            return Utils.norm(matrix, min, max);
-        }
-        static clamp(m, min, max) {
-            return Utils.clamp(matrix, min, max);
-        }
-        toPrecision(p) {
-            for (let i = 0; i < this.cols; i++) for (let j = 0; j < this.rows; j++) this.arr[i][j] = +this.arr[i][j].toPrecision(p);
-            return this;
-        }
-        get toBin() {
-            let newArr = this.arr.flat(1).toBin;
-            return new Matrix(this.rows, this.cols, newArr);
-        }
-        get toOct() {
-            let newArr = this.arr.flat(1).toOct;
-            return new Matrix(this.rows, this.cols, newArr);
-        }
-        get toHex() {
-            let newArr = this.arr.flat(1).toHex;
-            return new Matrix(this.rows, this.cols, newArr);
-        }
-        /*get isOdd() {
-            let newArr = this.arr.flat(1).isOdd;
-            return new Matrix(this.rows, this.cols, newArr);
-        }*/
-        max2min() {
-            let newArr = this.arr.flat(1).max2min;
-            return new Matrix(this.rows, this.cols, newArr);
-        }
-        min2max() {
-            let newArr = this.arr.flat(1).min2max;
-            return new Matrix(this.rows, this.cols, newArr);
-        }
-        sortRows(calback=undefined){
-            let newArr=this.arr.map(n=>n.sort(calback)).flat(1);
-            return new Matrix(this.rows, this.cols, newArr);           
-        }
-        sortCols(calback=undefined){
-            let m=this.T;
-            let newArr=m.arr.map(n=>n.sort(calback)).flat(1);
-            return new Matrix(this.rows, this.cols, newArr).T;           
-        }
-        filterByRows(item){
-            var truth=this.arr.map(n=>n.map(m=>+(""+m).includes(item)));
-            var mask=truth.map(n=>!!Logic.or(...n));
-            var filtredArray=this.arr.filter((n,i)=>mask[i]===true);
-            if(filtredArray.length===0)filtredArray.push([]);
-            console.log(filtredArray);
-            return new Matrix(filtredArray)
-        }
-        filterByCols(item){
-            return new Matrix(this.T.arr.filter(n=>n.includes(item)))
-        }
-        sortAll(calback=undefined){
-            let newArr=this.arr.flat(1).sort(calback);
-            return new Matrix(this.rows, this.cols, newArr);         
-        }
-        count(n) {
-            return this.arr.flat(1).count(n);
-        }
-        toBase(n) {
-            let newArr = this.arr.flat(1).toBase(n);
-            return new Matrix(this.rows, this.cols, newArr);
+                e = C[ii][i];
+                for (j = 0; j < dim; j++) {
+                    C[ii][j] -= e * C[i][j];
+                    I[ii][j] -= e * I[i][j];
+                }
+            }
         }
-        #hstack(matrix){
-            if (this.rows !== matrix.rows) return;
-            let newArr = this.arr;
-            for (let i = 0; i < this.rows; i++) for (let j = this.cols; j < this.cols + matrix.cols; j++) newArr[i][j] = matrix.arr[i][j - this.cols];
-            this.cols += matrix.cols;
-            return new Matrix(this.rows, this.cols, newArr.flat(1));
+        return new M.constructor(I);
+    }
+
+    function matrix_det(M) {
+        if (!M.isSquare) return new Error("is not square matrix");
+        if (M.rows == 1) return M.arr[0][0];
+        function determinat(M) {
+            if (M.length == 2) {
+                if (M.flat(1).some((n) => n?.isMatrix?.())) {
+                    console.warn("Tensors are not completely supported yet ...");
+                    return;
+                }
+                return sub(mul(M[0][0],M[1][1]),mul(M[0][1],M[1][0]))
+            }
+            var answer = 0;
+            for (var i = 0; i < M.length; i++) {
+                //console.log(M[0][i]);
+                /*answer = answer.add(
+                    pow(-1, i)
+                        .mul(M[0][i])
+                        .mul(determinat(deleteRowAndColumn(M, i)))
+                );*/
+                //const to_be_added=add(mul(pow(-1, i),mul(M[0][i],determinat(deleteRowAndColumn(M, i)))));
+                const to_be_added=add(mul(pow$1(-1, i),mul(M[0][i],determinat(deleteRowAndColumn(M, i)))));
+                answer=add(answer,to_be_added);
+            }
+            return answer;
         }
-        hstack(...matrices) {
-            const M=[this,...matrices].reduce((a,b)=>a.#hstack(b));
-            Object.assign(this,M);
-            return this;
+        return determinat(M.arr);
+    }
+    function deleteRowAndColumn(M, index) {
+        var temp = [];
+        for (let i = 0; i < M.length; i++) temp.push(M[i].slice(0));
+        temp.splice(0, 1);
+        for (let i = 0; i < temp.length; i++) temp[i].splice(index, 1);
+        return temp;
+    }
+
+    function hstack(M1, M2){
+        M1 = M1.clone();
+        M2 = M2.clone();
+        if (M1.rows !== M2.rows) return;
+        let newArr = M1.arr;
+        for (let i = 0; i < M1.rows; i++) 
+            for (let j = M1.cols; j < M1.cols + M2.cols; j++) 
+                newArr[i][j] = M2.arr[i][j - M1.cols];
+        M1.cols += M2.cols;
+        return new M1.constructor(M1.rows, M1.cols, newArr.flat(1));
+    }
+
+    function vstack(M1, M2){
+        M1 = M1.clone();
+        M2 = M2.clone();
+        if (M1.cols !== M2.cols) return;
+        let newArr = M1.arr;
+        for (let i = M1.rows; i < M1.rows + M2.rows; i++) {
+            newArr[i] = [];
+            for (let j = 0; j < M1.cols; j++) newArr[i][j] = M2.arr[i - M1.rows][j];
+        }
+        M1.rows += M2.rows;
+        return new M1.constructor(M1.rows, M1.cols, newArr.flat(1));
+    }
+
+    class Matrix{
+        constructor(rows, cols, element = [] ) {
+            if(rows instanceof Matrix){
+                this.arr=rows.arr;
+                this.rows=rows.rows;
+                this.cols=rows.cols;
+            }
+            else {
+            let arr = [], i, j;
+            if (arguments[0] instanceof Array) {
+                rows = arguments[0].length;
+                cols = arguments[0][0].length;
+                arr = arguments[0];
+            } else {
+                for (i = 0; i < rows; i++) {
+                    arr.push([]);
+                    arr[i].push(new Array(cols));
+                    for (j = 0; j < cols; j++) {
+                        arr[i][j] = element[i * cols + j];
+                        if (element[i * cols + j] == undefined) arr[i][j] = 0;
+                    }
+                }
+            }
+            this.rows = rows;
+            this.cols = cols;
+            this.arr = arr;   
         }
-        static hstack(matrix,...matrices) {
-            return matrix.clone.hstack(...matrices);
+        this.#maintain();
         }
-        #vstack(matrix) {
-            if (this.cols !== matrix.cols) return;
-            let newArr = this.arr;
-            for (let i = this.rows; i < this.rows + matrix.rows; i++) {
-                newArr[i] = [];
-                for (let j = 0; j < this.cols; j++) newArr[i][j] = matrix.arr[i - this.rows][j];
-            }
-            this.rows += matrix.rows;
-            return new Matrix(this.rows, this.cols, newArr.flat(1));
+        isMatrix(){
+            return true
         }
-        vstack(...matrices) {
-            const M=[this,...matrices].reduce((a,b)=>a.#vstack(b));
-            Object.assign(this,M);
-            return this;
+        clone() {
+            return new Matrix(this.rows, this.cols, this.arr.flat(1));
         }
-        static vstack(matrix,...matrices) {
-            return matrix.clone.vstack(...matrices);
+        [Symbol.iterator]() {
+          return this.arr[Symbol.iterator]();
         }
-        hqueue(...matrices){
-            const M=[this,...matrices].reverse().reduce((a,b)=>a.#hstack(b));
-            Object.assign(this,M);
-            return this;
+        #maintain() {
+            for (let i = 0; i < this.arr.length; i++) {
+                Object.defineProperty(this, i, {
+                    value: this.arr[i],
+                    writable: true,
+                    configurable: true,
+                    enumerable: false 
+                });
+            }
         }
-        vqueue(...matrices){
-            const M=[this,...matrices].reverse().reduce((a,b)=>a.#vstack(b));
-            Object.assign(this,M);
-            return this;
+        get size() {
+            return this.rows * this.cols;
+        } 
+        get shape() {
+            return [this.rows, this.cols];
         }
-        static hqueue(matrix,...matrices) {
-            return matrix.clone.hqueue(...matrices);
+        toString(){
+            return arr2str(this.arr);
         }
-        static vqueue(matrix,...matrices) {
-            return matrix.clone.vqueue(...matrices);
+        at(i = 0, j = undefined) {
+            if (i < 0) i += this.rows;
+            if (i < 0 || i >= this.rows) throw new Error('Row index out of bounds');
+            if (j === undefined) return this.arr[i];
+            if (j < 0) j += this.cols;
+            if (j < 0 || j >= this.cols) throw new Error('Column index out of bounds');
+            return this.arr[i][j];
         }
         slice(r0=0, c0=0, r1=this.rows-1, c1=this.cols-1) {
             let newRow = r1 - r0,
@@ -3687,585 +3788,502 @@
         static slice(m1,r0=0, c0=0, r1=this.rows-1, c1=this.cols-1) {
             return m1.slice(r0, c0, r1, c1);
         }
-        splice(r0,c0,deleteCount,...items){
-            
-        }
-        getRows(ri, rf = ri + 1) {
-            return this.slice(ri, 0, rf, this.cols);
-        }
-        getCols(ci, cf = ci + 1) {
-            return this.slice(0, ci, this.rows, cf);
-        }
-        static getRows(m, ri, rf = ri + 1) {
-            return m.slice(ri, 0, rf, m.cols);
-        }
-        static getCols(m, ci, cf = ci + 1) {
-            return m.slice(0, ci, m.rows, cf);
-        }
-        add(...matr) {
-            for (let k = 0; k < matr.length; k++) {
-                if (typeof matr[k] == "number"||matr[k] instanceof Complex) matr[k] = Matrix.nums(this.rows, this.cols, matr[k]);
-                for (let i = 0; i < this.rows; i++) for (var j = 0; j < this.cols; j++) this.arr[i][j] = Utils.add(this.arr[i][j],matr[k].arr[i][j]);
-            }
-            return new Matrix(this.rows, this.cols, this.arr.flat(1));
-        }
-        sub(...matr) {
-            for (let k = 0; k < matr.length; k++) {
-                if (typeof matr[k] == "number") matr[k] = Matrix.nums(this.rows, this.cols, matr[k]);
-                for (let i = 0; i < this.rows; i++) for (var j = 0; j < this.cols; j++) this.arr[i][j] = Utils.sub(this.arr[i][j],matr[k].arr[i][j]);
-            }
-            return new Matrix(this.rows, this.cols, this.arr.flat(1));
-        }
-        static add(m1, ...m2) {
-            return m1.clone.add(...m2);
-        }
-        static sub(m1, ...m2) {
-            return m1.clone.sub(...m2);
-        }
-        mul(...matr) {
-            for (let k = 0; k < matr.length; k++) {
-                if (typeof matr[k] == "number") matr[k] = Matrix.nums(this.rows, this.cols, matr[k]);
-                for (var i = 0; i < this.rows; i++) for (var j = 0; j < this.cols; j++) this.arr[i][j] = Utils.mul(this.arr[i][j],matr[k].arr[i][j]);
-            }
-            return new Matrix(this.rows, this.cols, this.arr.flat(1));
-        }
-        div(...matr) {
-            for (let k = 0; k < matr.length; k++) {
-                if (typeof matr[k] == "number") matr[k] = Matrix.nums(this.rows, this.cols, matr[k]);
-                for (let i = 0; i < this.rows; i++) for (var j = 0; j < this.cols; j++) this.arr[i][j] = Utils.div(this.arr[i][j],matr[k].arr[i][j]);
-            }
-            return new Matrix(this.rows, this.cols, this.arr.flat(1));
-        }
-        static div(m1, ...m2) {
-            return m1.clone.div(...m2);
-        }
-        static mul(m1, ...m2) {
-            return m1.clone.mul(...m2);
-        }
-        modulo(...matr) {
-            for (let k = 0; k < matr.length; k++) {
-                if (typeof matr[k] == "number") matr[k] = Matrix.nums(this.rows, this.cols, matr[k]);
-                for (let i = 0; i < this.rows; i++) for (var j = 0; j < this.cols; j++)this.arr[i][j]=Utils.modulo(this.arr[i][j],matr[k].arr[i][j]);
-            }
-            return new Matrix(this.rows, this.cols, this.arr.flat(1));
-        }
-        static modulo(m1, ...m2) {
-            return m1.clone.modulo(...m2);
+        reshape(newRows, newCols) {
+            if(!(newRows * newCols === this.rows * this.cols)) throw Error('size not matched')
+            return new Matrix(newRows, newCols, this.arr.flat(1));
         }
-        dot(matrix) {
-            var res = [];
-            for (var i = 0; i < this.arr.length; i++) {
-                res[i] = [];
-                for (var j = 0; j < matrix.arr[0].length; j++) {
-                    res[i][j] = 0;
-                    for (var k = 0; k < this.arr[0].length; k++) {
-                        res[i][j] = Utils.add(
-                            res[i][j],
-                            Utils.mul(this.arr[i][k],matrix.arr[k][j])
-                            );
-                    }
-                }
+        get T() {
+            let transpose = [];
+            for (let i = 0; i < this.arr[0].length; i++) {
+                transpose[i] = [];
+                for (let j = 0; j < this.arr.length; j++) 
+                    transpose[i][j] = this.arr[j][i];
             }
-            return new Matrix(this.arr.length, matrix.arr[0].length, res.flat(1));
-        }
-        static dot(matrix1, matrix2) {
-            return matrix1.dot(matrix2);
-        }
-        pow(n) {
-            let a = this.clone,
-                p = this.clone;
-            for (let i = 0; i < n - 1; i++) p = p.dot(a);
-            return p;
-        }
-        static pow(m, n) {
-            return m.clone.pow(n);
-        }
-        get somme() {
-            let S = 0;
-            for (let i = 0; i < this.rows; i++) for (let j = 0; j < this.cols; j++) S += this.arr[i][j];
-            return S;
-        }
-        get DoesItContainComplexNumbers() {
-            return this.arr.flat(Infinity).some((n) => n instanceof Complex);
-        }
-        get min() {
-            if (this.DoesItContainComplexNumbers) console.error("Complex numbers are not comparable");
-            let minRow = [];
-            for (let i = 0; i < this.rows; i++) minRow.push(min(...this.arr[i]));
-            return min(...minRow);
-        }
-        get max() {
-            if (this.DoesItContainComplexNumbers) console.error("Complex numbers are not comparable");
-            let maxRow = [];
-            for (let i = 0; i < this.rows; i++) maxRow.push(max(...this.arr[i]));
-            return max(...maxRow);
-        }
-        get minRows() {
-            if (this.DoesItContainComplexNumbers) console.error("Complex numbers are not comparable");
-            let minRow = [];
-            for (let i = 0; i < this.rows; i++) minRow.push(min(...this.arr[i]));
-            return minRow;
-        }
-        get maxRows() {
-            if (this.DoesItContainComplexNumbers) console.error("Complex numbers are not comparable");
-            let maxRow = [];
-            for (let i = 0; i < this.rows; i++) maxRow.push(max(...this.arr[i]));
-            return maxRow;
-        }
-        get minCols() {
-            if (this.DoesItContainComplexNumbers) console.error("Complex numbers are not comparable");
-            return this.T.minRows;
-        }
-        get maxCols() {
-            if (this.DoesItContainComplexNumbers) console.error("Complex numbers are not comparable");
-            return this.T.maxRows;
+            return new Matrix(this.cols, this.rows, transpose.flat(1));
         }
-        static fromVector(v) {
-            return new Matrix(v.length, 1, v);
+        get det() {
+            return matrix_det(this)
         }
-        get toArray() {
-            let arr = [];
-            for (let i = 0; i < this.rows; i++) {
-                for (let j = 0; j < this.cols; j++) {
-                    arr.push(this.arr[i][j]);
-                }
-            }
-            return arr;
+        get inv() {
+            return matrix_inverse(this)
         }
-        get print() {
-            //"pretty print" the matrix
-            let fstring = "[";
-            for (let i = 0; i < this.arr.length; i++) {
-                fstring += (i != 0 ? " " : "") + ` [${this.arr[i].map((n) => " " + n.toString() + " ")}],\n`;
-            }
-            console.log(fstring.substring(0, fstring.length - 2) + " ]");
-            document.write(fstring.substring(0, fstring.length - 2) + " ]");
+        static eye(size) {
+            let result = new Matrix(size, size);
+            for (let i = 0; i < size; i++) 
+                for (let j = 0; j < size; j++) i === j ? (result.arr[i][j] = 1) : (result.arr[i][j] = 0);
+            return result;
         }
-        get table() {
-            console.table(this.arr);
+        static zeros(rows, cols) {
+            let result = new Matrix(rows, cols);
+            for (let i = 0; i < rows; i++) 
+                for (var j = 0; j < cols; j++) result.arr[i][j] = 0;
+            return result;
         }
-        get serialize() {
-            return JSON.stringify(this);
+        static ones(rows, cols) {
+            let result = new Matrix(rows, cols);
+            for (let i = 0; i < rows; i++) 
+                for (let j = 0; j < cols; j++) result.arr[i][j] = 1;
+            return result;
         }
-        static deserialize(data) {
-            if (typeof data == "string") {
-                data = JSON.parse(data);
-            }
-            let matrix = new Matrix(data.rows, data.cols);
-            matrix.arr = data.arr;
-            return matrix;
+        static nums(rows, cols, number) {
+            let result = new Matrix(rows, cols);
+            for (let i = 0; i < rows; i++) 
+                for (let j = 0; j < cols; j++) result.arr[i][j] = number;
+            return result;
         }
-
-        toTable() {
-            var table = new DocumentFragment();
-            var Tr = new Array(this.rows).fill(null).map(() => document?.createElement("tr"));
-            var Td = this.arr.map((n) => n.map(() => document?.createElement("td")));
-            for (let i = 0; i < Td.length; i++) {
-                for (let j = 0; j < Td[0].length; j++) {
-                    Td[i][j].innerHTML = this.arr[i][j];
-                    Tr[i].appendChild(Td[i][j]);
-                }
-            }
-            Tr.map((n) => table.appendChild(n));
-            return table;
-        }
-        toGrid(element, style = {}) {
-            let a = Grid();
-            a.append(
-                ...this.map(element)
-                    .arr.flat(1)
-                    .map((n) => n.style(style))
-            );
-            a.Columns(this.cols);
-            return a;
+        hstack(...matrices) {
+            const M=[this, ...matrices].reduce((a,b)=>hstack(a, b));
+            Object.assign(this, M);
+            this.#maintain();
+            return this;
         }
-        sortTable(n=0,{type="num",order="asc"}={}) {
-            var obj=this.T.arr.map(n=>n.map((n,i)=>Object.assign({},{x:n,y:i})));
-            var newObj=this.T.arr.map(n=>n.map((n,i)=>Object.assign({},{x:n,y:i})));
-            if(type==="num"){
-                if(order==="asc")obj[n].sort((a,b)=>a.x-b.x);
-                else if(order==="desc")obj[n].sort((a,b)=>b.x-a.x);
-                else if(order==="toggle"){
-                   // console.log(obj[n][0])
-                    //console.log(obj[n][1])
-                    if(obj[n][0].x>obj[n][1].x)obj[n].sort((a,b)=>b.x-a.x);
-                    else obj[n].sort((a,b)=>a.x-b.x);
-                }
-            }
-            else if(type==="alpha"){
-                if(order==="asc")obj[n].sort((a,b)=>(""+a.x).localeCompare(""+b.x));
-                else if(order==="desc")obj[n].sort((a,b)=>(""+b.x).localeCompare(""+a.x));            
-            }
-            //var order=obj[n].map(n=>n.y);
-            order=obj[n].map(n=>n.y);
-            for(let i=0;i<obj.length;i++){
-                if(i!==n)obj[i].map((n,j)=>n.y=order[j]);
-            }
-            for(let i=0;i<obj.length;i++){
-                if(i!==n)newObj[i].map((n,j)=>n.x=obj[i][order[j]].x);
-            }
-            newObj[n]=obj[n];
-            var newArr=newObj.map(n=>n.map(m=>m.x));
-            return new Matrix(newArr).T;
+        static hstack(matrix,...matrices) {
+            return matrix.clone().hstack(...matrices);
         }
-    }
+        vstack(...matrices){
+            const M=[this, ...matrices].reduce((a,b)=>vstack(a, b));
+            Object.assign(this, M);
+            this.#maintain();
+            return this;
+        }
+        static vstack(matrix,...matrices) {
+            return matrix.clone().vstack(...matrices);
+        }
+        hqueue(...matrices){
+            const M=[this, ...matrices].reverse().reduce((a,b)=>hstack(a, b));
+            Object.assign(this, M);
+            return this;
+        }
+        static hqueue(matrix,...matrices) {
+            return matrix.clone().hqueue(...matrices);
+        }
+        vqueue(...matrices){
+            const M=[this,...matrices].reverse().reduce((a, b)=>vstack(a, b));
+            Object.assign(this, M);
+            return this;
+        }
+        static vqueue(matrix,...matrices) {
+            return matrix.clone().vqueue(...matrices);
+        }
+        shuffle(){
+            this.arr = this.arr.sort(()=>0.5-Math.random());
+            return this;
+        }
+        static shuffle(M){
+            return M.clone().shuffle()
+        }
+        // get reel() {
+        //     return new Matrix(this.cols, this.rows, this.arr.flat(1).reel);
+        // }
+        // get imag() {
+        //     return new Matrix(this.cols, this.rows, this.arr.flat(1).imag);
+        // }
 
-    function InverseMatrixe(M) {
-        if (M.length !== M[0].length) {
-            return;
+        // Checkers
+        get isSquare() {
+            return this.rows === this.cols;
         }
-        var i = 0,
-            ii = 0,
-            j = 0,
-            dim = M.length,
-            e = 0;
-            //t = 0;
-        var I = [],
-            C = [];
-        for (i = 0; i < dim; i += 1) {
-            I[I.length] = [];
-            C[C.length] = [];
-            for (j = 0; j < dim; j += 1) {
-                if (i == j) {
-                    I[i][j] = 1;
-                } else {
-                    I[i][j] = 0;
+        get isSym() {
+            if (!this.isSquare) return false;
+            for (let i = 0; i < this.rows; i++) {
+                for (let j = i + 1; j < this.cols; j++) {
+                    if (this.arr[i][j] !== this.arr[j][i]) return false;
                 }
-                C[i][j] = M[i][j];
             }
+            return true;
         }
-        for (i = 0; i < dim; i += 1) {
-            e = C[i][i];
-            if (e == 0) {
-                for (ii = i + 1; ii < dim; ii += 1) {
-                    if (C[ii][i] != 0) {
-                        for (j = 0; j < dim; j++) {
-                            e = C[i][j];
-                            C[i][j] = C[ii][j];
-                            C[ii][j] = e;
-                            e = I[i][j];
-                            I[i][j] = I[ii][j];
-                            I[ii][j] = e;
-                        }
-                        break;
-                    }
-                }
-                e = C[i][i];
-                if (e == 0) {
-                    return;
+        get isAntiSym() {
+            if (!this.isSquare) return false;
+            const n = this.rows;
+            for (let i = 0; i < n; i++) {
+                if (this.arr[i][i] !== 0) return false;
+                for (let j = i + 1; j < n; j++) {
+                    if (this.arr[i][j] !== -this.arr[j][i]) return false;
                 }
             }
-            for (j = 0; j < dim; j++) {
-                C[i][j] = C[i][j] / e;
-                I[i][j] = I[i][j] / e;
-            }
-            for (ii = 0; ii < dim; ii++) {
-                if (ii == i) {
-                    continue;
-                }
-                e = C[ii][i];
-                for (j = 0; j < dim; j++) {
-                    C[ii][j] -= e * C[i][j];
-                    I[ii][j] -= e * I[i][j];
+            return true;
+        }
+        get isDiag() {
+            if (!this.isSquare) return false;
+            const n = this.rows;
+            for (let i = 0; i < n; i++) {
+                for (let j = i + 1; j < n; j++) {
+                    if (this.arr[i][j] !== 0 || this.arr[j][i] !== 0) return false;
                 }
             }
+            return true;
         }
-        return I;
-    }
-    /**
-    * @returns {Matrix}
-    */
-    const matrix=(r, c, element)=>new Matrix(r, c, element);
-    const matrix2=(...element)=>new Matrix(2, 2, element);
-    const matrix3=(...element)=>new Matrix(3, 3, element);
-    const matrix4=(...element)=>new Matrix(4, 4, element);
-
-    class Complex{
-        constructor(a = 0, b = 0) {
-            if(a instanceof Complex){
-                this.a=a.a;
-                this.b=a.b;
-            }
-            else if(typeof(a)==="object"){
-                if(("a" in a && "b" in a)){
-                    this.a=a.a;
-                    this.b=a.b;
-                }
-                else if(("a" in a && "z" in a)){
-                    this.a=a.a;
-                    this.b=sqrt$2((a.z**2)-(a.a**2));
-                }
-                else if(("a" in a && "phi" in a)){
-                    this.a=a.a;
-                    this.b=a.a*tan(a.phi);
-                }
-                else if(("b" in a && "z" in a)){
-                    this.b=a.b;
-                    this.a=sqrt$2((a.z**2)-(a.b**2));
+        get isOrtho() {
+            if (!this.isSquare) return false;
+            return this.isDiag && (this.det == 1 || this.det == -1);
+        }
+        get isIdemp() {
+            if (!this.isSquare) return false;
+            const n = this.rows;
+            const A = this.arr;
+            // Compute A * A
+            const MM = [];
+            for (let i = 0; i < n; i++) {
+                MM[i] = [];
+                for (let j = 0; j < n; j++) {
+                    let sum = 0;
+                    for (let k = 0; k < n; k++) {
+                        sum += A[i][k] * A[k][j];
+                    }
+                    MM[i][j] = sum;
                 }
-                else if(("b" in a && "phi" in a)){
-                    this.b=b;
-                    this.a=a.b/tan(a.phi);
+            }
+            // Check if A * A == A
+            for (let i = 0; i < n; i++) {
+                for (let j = 0; j < n; j++) {
+                    if (MM[i][j] !== A[i][j]) return false;
                 }
-                else if(("z" in a && "phi" in a)){
-                    this.a=a.z*cos$2(a.phi);
-                    this.a=a.z*sin$2(a.phi);
+            }
+            return true;
+        }
+
+        get isUpperTri() {
+            if (!this.isSquare) return false;
+            const n = this.rows;
+            for (let i = 1; i < n; i++) {
+                for (let j = 0; j < i; j++) {
+                    if (this.arr[i][j] !== 0) return false;
                 }
             }
-            else if(typeof(a)==="number"&&typeof(b)==="number"){
-                this.a = +a.toFixed(32);
-                this.b = +b.toFixed(32);
+            return true;
+        }
+        get isLowerTri() {
+            if (!this.isSquare) return false;
+            const n = this.rows;
+            for (let i = 0; i < n - 1; i++) {
+                for (let j = i + 1; j < n; j++) {
+                    if (this.arr[i][j] !== 0) return false;
+                }
             }
+            return true;
         }
-        isComplex(){
-            return true
+        
+        // static get rand(){
+        //     return {
+        //         int:(rows, cols, a, b)=>{
+        //             let result = new Matrix(rows, cols);
+        //             for (let i = 0; i < rows; i++) for (let j = 0; j < cols; j++) result.arr[i][j] = Random.randInt(a, b);
+        //             return result;
+        //         },
+        //         bin:(rows,cols)=>{
+        //             let result = new Matrix(rows, cols);
+        //             for (let i = 0; i < rows; i++) {
+        //                 for (let j = 0; j < cols; j++) result.arr[i][j] = Random.randBin;
+        //             }
+        //             return result;       
+        //         },
+        //         hex:(rows,cols)=>{
+        //             let result = new Matrix(rows, cols);
+        //             for (let i = 0; i < rows; i++) {
+        //                 for (let j = 0; j < cols; j++) result.arr[i][j] = Random.randHex;
+        //             }
+        //             return result;       
+        //         },
+        //         choices:(rows, cols, choices, p)=>{
+        //             let result = new Matrix(rows, cols);
+        //             for (let i = 0; i < rows; i++) for (let j = 0; j < cols; j++) result.arr[i][j] = Random.choice(choices, p);
+        //             return result
+        //         },
+        //         permutation:(rows,cols,arr)=>{
+        //             //return new Matrix(rows, cols, Random.permutation(...arr))
+        //         }
+        //     }
+        // }
+        // static rands(rows, cols, a = 1, b) {
+        //     let result = new Matrix(rows, cols);
+        //     for (let i = 0; i < rows; i++) for (let j = 0; j < cols; j++) result.arr[i][j] = Random.rand(a, b);
+        //     return result;
+        // }
+        map(Imin, Imax, Fmin, Fmax) {
+            this.arr = map$1(this.arr, Imin, Imax, Fmin, Fmax);
+            return this;
         }
-        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;
+        lerp(min, max) {
+            this.arr = lerp(this.arr, min, max);
+            return this;
         }
-          
-        get clone() {
-            return new Complex(this.a, this.b);
+        norm(min, max) {
+            this.arr = norm(this.arr, min, max);
+            return this;
         }
-        get z(){
-            return hypot(this.a,this.b);    
+        clamp(min, max) {
+            this.arr = clamp(this.arr, min, max);
+            return this;
         }
-        get phi(){
-            return atan2(this.b , this.a);        
+        static map(M, Imin, Imax, Fmin, Fmax) {
+            return M.clone().map(Imin, Imax, Fmin, Fmax)
         }
-        static Zero() {
-            return new Complex(0, 0);
+        static lerp(M, min, max) {
+            return M.clone().lerp(min, max)
         }
-        get conj() {
-            return new Complex(this.a, -this.b);
+        static norm(M, min, max) {
+            return M.clone().norm(min, max)
         }
-        get inv() {
-            return new Complex(this.a / (pow$1(this.a, 2) + pow$1(this.b, 2)), -this.b / (pow$1(this.a, 2) + pow$1(this.b, 2)));
+        static clamp(M, min, max) {
+            return M.clone().clamp(min, max)
         }
-        add(...z) {
-            for (let i = 0; i < z.length; i++) {
-                if (typeof z[i] === "number") z[i] = new Complex(z[i], 0);
-            }
-            let re = z.map((n) => n.a);
-            let im = z.map((n) => n.b);
-            this.a+=+sum(...re).toFixed(15);
-            this.b+=+sum(...im).toFixed(15);
+        toPrecision(p) {
+            for (let i = 0; i < this.cols; i++) 
+                for (let j = 0; j < this.rows; j++) 
+                    this.arr[i][j] = +this.arr[i][j].toPrecision(p);
             return this;
         }
-        sub(...z) {
-            for (let i = 0; i < z.length; i++) {
-                if (typeof z[i] === "number") z[i] = new Complex(z[i], 0);
-            }
-            let re = z.map((n) => n.a);
-            let im = z.map((n) => n.b);
-            this.a-=+sum(...re).toFixed(15);
-            this.b-=+sum(...im).toFixed(15);
-            return this;
+        // get toBin() {
+        //     let newArr = this.arr.flat(1).toBin;
+        //     return new Matrix(this.rows, this.cols, newArr);
+        // }
+        // get toOct() {
+        //     let newArr = this.arr.flat(1).toOct;
+        //     return new Matrix(this.rows, this.cols, newArr);
+        // }
+        // get toHex() {
+        //     let newArr = this.arr.flat(1).toHex;
+        //     return new Matrix(this.rows, this.cols, newArr);
+        // }
+        /*get isOdd() {
+            let newArr = this.arr.flat(1).isOdd;
+            return new Matrix(this.rows, this.cols, newArr);
+        }*/
+        max2min() {
+            let newArr = this.arr.flat(1).max2min;
+            return new Matrix(this.rows, this.cols, newArr);
         }
-        mul(...z){
-            for (let i = 0; i < z.length; i++) {
-                if (typeof z[i] === "number") z[i] = new Complex(z[i], 0);
+        min2max() {
+            let newArr = this.arr.flat(1).min2max;
+            return new Matrix(this.rows, this.cols, newArr);
+        }
+        sortRows(calback=undefined){
+            let newArr=this.arr.map(n=>n.sort(calback)).flat(1);
+            return new Matrix(this.rows, this.cols, newArr);           
+        }
+        sortCols(calback=undefined){
+            let m=this.T;
+            let newArr=m.arr.map(n=>n.sort(calback)).flat(1);
+            return new Matrix(this.rows, this.cols, newArr).T;           
+        }
+        filterByRows(item){
+            var truth=this.arr.map(n=>n.map(m=>+(""+m).includes(item)));
+            var mask=truth.map(n=>!!Logic.or(...n));
+            var filtredArray=this.arr.filter((n,i)=>mask[i]===true);
+            if(filtredArray.length===0)filtredArray.push([]);
+            console.log(filtredArray);
+            return new Matrix(filtredArray)
+        }
+        filterByCols(item){
+            return new Matrix(this.T.arr.filter(n=>n.includes(item)))
+        }
+        sortAll(calback=undefined){
+            let newArr=this.arr.flat(1).sort(calback);
+            return new Matrix(this.rows, this.cols, newArr);         
+        }
+        count(n) {
+            return this.arr.flat(1).count(n);
+        }
+        // toBase(n) {
+        //     let newArr = this.arr.flat(1).toBase(n);
+        //     return new Matrix(this.rows, this.cols, newArr);
+        // }
+        
+        splice(r0,c0,deleteCount,...items){
+            
+        }
+        getRows(ri, rf = ri + 1) {
+            return this.slice(ri, 0, rf, this.cols);
+        }
+        getCols(ci, cf = ci + 1) {
+            return this.slice(0, ci, this.rows, cf);
+        }
+        static getRows(m, ri, rf = ri + 1) {
+            return m.slice(ri, 0, rf, m.cols);
+        }
+        static getCols(m, ci, cf = ci + 1) {
+            return m.slice(0, ci, m.rows, cf);
+        }
+        add(...matr) {
+            for (let k = 0; k < matr.length; k++) {
+                if (typeof matr[k] == "number"||matr[k] instanceof Complex) matr[k] = Matrix.nums(this.rows, this.cols, matr[k]);
+                for (let i = 0; i < this.rows; i++) for (var j = 0; j < this.cols; j++) this.arr[i][j] = add(this.arr[i][j],matr[k].arr[i][j]);
             }
-            let Z=+prod(this.z,...z.map(n=>n.z)).toFixed(15);
-            let phi=+sum(this.phi,...z.map(n=>n.phi)).toFixed(15);
-            this.a=+(Z*cos$2(phi).toFixed(15)).toFixed(14);
-            this.b=+(Z*sin$2(phi).toFixed(15)).toFixed(14);    
-            return this;
+            return new Matrix(this.rows, this.cols, this.arr.flat(1));
+        }
+        sub(...matr) {
+            for (let k = 0; k < matr.length; k++) {
+                if (typeof matr[k] == "number") matr[k] = Matrix.nums(this.rows, this.cols, matr[k]);
+                for (let i = 0; i < this.rows; i++) for (var j = 0; j < this.cols; j++) this.arr[i][j] = sub(this.arr[i][j],matr[k].arr[i][j]);
+            }
+            return new Matrix(this.rows, this.cols, this.arr.flat(1));
         }
-        div(...z) {
-            for (let i = 0; i < z.length; i++) {
-                if (typeof z[i] === "number") z[i] = new Complex(z[i], 0);
+        static add(m1, ...m2) {
+            return m1.clone().add(...m2);
+        }
+        static sub(m1, ...m2) {
+            return m1.clone().sub(...m2);
+        }
+        mul(...matr) {
+            for (let k = 0; k < matr.length; k++) {
+                if (typeof matr[k] == "number") matr[k] = Matrix.nums(this.rows, this.cols, matr[k]);
+                for (var i = 0; i < this.rows; i++) for (var j = 0; j < this.cols; j++) this.arr[i][j] = mul(this.arr[i][j],matr[k].arr[i][j]);
             }
-            let Z=+(this.z/prod(...z.map(n=>n.z))).toFixed(15);
-            let phi=+(this.phi-sum(...z.map(n=>n.phi))).toFixed(15);
-            this.a=+(Z*cos$2(phi).toFixed(15)).toFixed(15);
-            this.b=+(Z*sin$2(phi).toFixed(15)).toFixed(15);
-            return this;
+            return new Matrix(this.rows, this.cols, this.arr.flat(1));
         }
-        pow(n) {
-            if (floor(n) === n && n > 0) {
-                let z=+(this.z**n).toFixed(15);
-                let phi=+(this.phi*n).toFixed(15);
-                this.a=+(z*cos$2(phi).toFixed(15)).toFixed(15);
-                this.b=+(z*sin$2(phi).toFixed(15)).toFixed(15);
+        div(...matr) {
+            for (let k = 0; k < matr.length; k++) {
+                if (typeof matr[k] == "number") matr[k] = Matrix.nums(this.rows, this.cols, matr[k]);
+                for (let i = 0; i < this.rows; i++) for (var j = 0; j < this.cols; j++) this.arr[i][j] = div(this.arr[i][j],matr[k].arr[i][j]);
             }
-            return this;
+            return new Matrix(this.rows, this.cols, this.arr.flat(1));
         }
-        static fromExpo(z, phi) {
-            return new Complex(
-                +(z * cos$2(phi)).toFixed(13), 
-                +(z * sin$2(phi)).toFixed(13)
-                );
+        static div(m1, ...m2) {
+            return m1.clone().div(...m2);
         }
-        get expo() {
-            return [this.z, this.phi];
+        static mul(m1, ...m2) {
+            return m1.clone().mul(...m2);
         }
-        static add(c,...z) {
-            return c.clone.add(...z);
+        modulo(...matr) {
+            for (let k = 0; k < matr.length; k++) {
+                if (typeof matr[k] == "number") matr[k] = Matrix.nums(this.rows, this.cols, matr[k]);
+                for (let i = 0; i < this.rows; i++) 
+                    for (var j = 0; j < this.cols; j++)
+                        this.arr[i][j]=modulo(this.arr[i][j],matr[k].arr[i][j]);
+            }
+            return new Matrix(this.rows, this.cols, this.arr.flat(1));
         }
-        static sub(c,...z) {
-            return c.clone.sub(...z);
+        static modulo(m1, ...m2) {
+            return m1.clone().modulo(...m2);
         }
-        static mul(c,...z) {
-            return c.clone.mul(...z);
+        dot(matrix) {
+            var res = [];
+            for (var i = 0; i < this.arr.length; i++) {
+                res[i] = [];
+                for (var j = 0; j < matrix.arr[0].length; j++) {
+                    res[i][j] = 0;
+                    for (var k = 0; k < this.arr[0].length; k++) {
+                        res[i][j] = add(
+                            res[i][j],
+                            mul(this.arr[i][k],matrix.arr[k][j])
+                            );
+                    }
+                }
+            }
+            return new Matrix(this.arr.length, matrix.arr[0].length, res.flat(1));
         }
-        static div(c,...z) {
-            return c.clone.div(...z);
+        static dot(matrix1, matrix2) {
+            return matrix1.dot(matrix2);
         }
-        static pow(z,n){
-            return z.clone.pow(n);
+        pow(n) {
+            let a = this.clone(),
+                p = this.clone();
+            for (let i = 0; i < n - 1; i++) p = p.dot(a);
+            return p;
         }
-        static xpowZ(x){
-            return complex((x**this.a)*cos$2(this.b*ln(x)),(x**this.a)*sin$2(this.b*ln(x)));
+        static pow(m, n) {
+            return m.clone().pow(n);
         }
-        sqrtn(n=2){
-            return complex(sqrtn(this.z,n)*cos$2(this.phi/n),sqrtn(this.z,n)*sin$2(this.phi/n));
+        get somme() {
+            let S = 0;
+            for (let i = 0; i < this.rows; i++) for (let j = 0; j < this.cols; j++) S += this.arr[i][j];
+            return S;
         }
-        get sqrt(){
-            return this.sqrtn(2);
+        get hasComplex() {
+            return this.arr.flat(Infinity).some((n) => n instanceof Complex);
         }
-        get log(){
-            return complex(this.z,this.phi);
+        get min() {
+            if (this.hasComplex) console.error("Complex numbers are not comparable");
+            let minRow = [];
+            for (let i = 0; i < this.rows; i++) minRow.push(min(...this.arr[i]));
+            return min(...minRow);
         }
-        get cos(){
-            return complex(cos$2(this.a)*cosh$1(this.b),sin$2(this.a)*sinh$1(this.b))
+        get max() {
+            if (this.hasComplex) console.error("Complex numbers are not comparable");
+            let maxRow = [];
+            for (let i = 0; i < this.rows; i++) maxRow.push(max(...this.arr[i]));
+            return max(...maxRow);
         }
-        get sin(){
-            return complex(sin$2(this.a)*cosh$1(this.b),cos$2(this.a)*sinh$1(this.b))
+        get minRows() {
+            if (this.hasComplex) console.error("Complex numbers are not comparable");
+            let minRow = [];
+            for (let i = 0; i < this.rows; i++) minRow.push(min(...this.arr[i]));
+            return minRow;
         }
-        get tan(){
-            const de=cos$2(this.a*2)+cosh$1(this.b*2);
-            return complex(sin$2(2*this.a)/de,sinh$1(2*this.b)/de);
+        get maxRows() {
+            if (this.hasComplex) console.error("Complex numbers are not comparable");
+            let maxRow = [];
+            for (let i = 0; i < this.rows; i++) maxRow.push(max(...this.arr[i]));
+            return maxRow;
         }
-    }
-    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 instanceof Matrix && b instanceof Matrix){
-            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 Matrix(a.rows,a.cols,...arr)
+        get minCols() {
+            if (this.hasComplex) console.error("Complex numbers are not comparable");
+            return this.T.minRows;
         }
-        return new Complex(a,b)
-    };
-
-    const abs=(...x)=>mapfun$1(Math.abs,...x);
-    const sqrt$2=(...x)=>mapfun$1(Math.sqrt,...x);
-    const pow$1=(x,n)=>{
-        if(typeof x === "number"){
-            if(typeof n === "number")return Math.pow(x,n);
-            else if(n instanceof Complex)return Complex.fromExpo(x**n.a,n.b*ln(x))
-            else return mapfun$1(a=>pow$1(x,a),...n);
+        get maxCols() {
+            if (this.hasComplex) console.error("Complex numbers are not comparable");
+            return this.T.maxRows;
         }
-        else if(x instanceof Complex){
-            if(typeof n === "number")return Complex.fromExpo(x.z**n,x.phi*n);
-            else if(n instanceof Complex)return Complex.fromExpo(
-                x.z**n.a*e(-x.phi*n.b),
-                ln(x.z)*n.b+n.a*x.phi
-            )
-            else return mapfun$1(a=>pow$1(x,a),...n);
+        static fromVector(v) {
+            return new Matrix(v.length, 1, v);
         }
-        else if(x instanceof Array){
-            if(typeof n === "number") return mapfun$1(a=>pow$1(a,n),...x);
-            else if(n instanceof Array){
-                const Y=[];
-                for(let i=0;i<x.length;i++){
-                    Y.push(mapfun$1(a=>pow$1(x[i],a),...n));
+        get toArray() {
+            let arr = [];
+            for (let i = 0; i < this.rows; i++) {
+                for (let j = 0; j < this.cols; j++) {
+                    arr.push(this.arr[i][j]);
                 }
-                return Y;
             }
+            return arr;
         }
-    };
-    const sqrtn=(x,n)=>{
-        if(typeof x === "number"){
-            if(typeof n === "number")return Math.pow(x,1/n);
-            else return mapfun$1(a=>sqrtn(x,a),...n);
+        get serialize() {
+            return JSON.stringify(this);
         }
-        else if(x instanceof Complex){
-            if(typeof n === "number")return Complex.fromExpo(sqrtn(x.z,n),x.phi/n);
-            else return mapfun$1(a=>sqrtn(x,a),...n);
+        static deserialize(data) {
+            if (typeof data == "string") data = JSON.parse(data);
+            let matrix = new Matrix(data.rows, data.cols);
+            matrix.arr = data.arr;
+            return matrix;
         }
-        else if(x instanceof Array){
-            if(typeof n === "number") return mapfun$1(a=>sqrtn(a,n),...x);
-            else if(n instanceof Array){
-                const Y=[];
-                for(let i=0;i<x.length;i++){
-                    Y.push(mapfun$1(a=>sqrtn(x[i],a),...n));
+        sortTable(n=0,{type="num",order="asc"}={}) {
+            var obj=this.T.arr.map(n=>n.map((n,i)=>Object.assign({},{x:n,y:i})));
+            var newObj=this.T.arr.map(n=>n.map((n,i)=>Object.assign({},{x:n,y:i})));
+            if(type==="num"){
+                if(order==="asc")obj[n].sort((a,b)=>a.x-b.x);
+                else if(order==="desc")obj[n].sort((a,b)=>b.x-a.x);
+                else if(order==="toggle"){
+                   // console.log(obj[n][0])
+                    //console.log(obj[n][1])
+                    if(obj[n][0].x>obj[n][1].x)obj[n].sort((a,b)=>b.x-a.x);
+                    else obj[n].sort((a,b)=>a.x-b.x);
                 }
-                return Y;
             }
-        }
-    };
-    const e=(...x) => mapfun$1(Math.exp,...x);
-    const ln=(...x) => mapfun$1(Math.log,...x);
-    const cos$2=(...x) => mapfun$1(Fixed.cos,...x);
-    const sin$2=(...x) => mapfun$1(Fixed.sin,...x);
-    const tan=(...x) => mapfun$1(Fixed.tan,...x);
-    const sec=(...x) => mapfun$1(Fixed.sec,...x);
-    const sinc=(...x) => mapfun$1(Fixed.sinc,...x);
-    const csc=(...x) => mapfun$1(Fixed.csc,...x);
-    const cot=(...x) => mapfun$1(Fixed.cot,...x);
-    const acos$1=(...x) => mapfun$1(Fixed.acos,...x);
-    const asin=(...x) => mapfun$1(Fixed.asin,...x);
-    const atan=(...x) => mapfun$1(Fixed.atan,...x);
-    const acot=(...x) => mapfun$1(Fixed.acot,...x);
-    const cosh$1=(...x) => mapfun$1(Fixed.cosh,...x);
-    const sinh$1=(...x) => mapfun$1(Fixed.sinh,...x);
-    const tanh=(...x) => mapfun$1(Fixed.tanh,...x);
-    const coth=(...x) => mapfun$1(Fixed.coth,...x);
-    const acosh=(...x) => mapfun$1(Fixed.acosh,...x);
-    const asinh=(...x) => mapfun$1(Fixed.asinh,...x);
-    const atanh=(...x) => mapfun$1(Fixed.atanh,...x);
-    const ceil=(...x) => mapfun$1(Math.ceil,...x);
-    const floor=(...x) => mapfun$1(Math.floor,...x);
-    const round=(...x) => mapfun$1(Math.round,...x);
-    const atan2=(x,y,rad=true)=>{
-        if(typeof x === "number"){
-            if(typeof y === "number")return rad?Math.atan2(x,y):Math.atan2(x,y)*180/Math.PI;
-            else return mapfun$1(a=>atan2(x,a,rad),...y);
-        }
-        // else if(x instanceof Complex){
-        //     if(typeof n === "number")return Complex.fromExpo(x.z**n,x.phi*n);
-        //     else return mapfun(a=>pow(x,a),...n);
-        // }
-        else if(x instanceof Array){
-            if(typeof y === "number") return mapfun$1(a=>atan2(a,y,rad),...x);
-            else if(y instanceof Array){
-                const Y=[];
-                for(let i=0;i<x.length;i++){
-                    Y.push(mapfun$1(a=>pow$1(x[i],a),...y));
-                }
-                return Y;
+            else if(type==="alpha"){
+                if(order==="asc")obj[n].sort((a,b)=>(""+a.x).localeCompare(""+b.x));
+                else if(order==="desc")obj[n].sort((a,b)=>(""+b.x).localeCompare(""+a.x));            
+            }
+            //var order=obj[n].map(n=>n.y);
+            order=obj[n].map(n=>n.y);
+            for(let i=0;i<obj.length;i++){
+                if(i!==n)obj[i].map((n,j)=>n.y=order[j]);
             }
+            for(let i=0;i<obj.length;i++){
+                if(i!==n)newObj[i].map((n,j)=>n.x=obj[i][order[j]].x);
+            }
+            newObj[n]=obj[n];
+            var newArr=newObj.map(n=>n.map(m=>m.x));
+            return new Matrix(newArr).T;
         }
-    };
-    const fact=(...x)=>mapfun$1(n=> {
-            let i,
-            y = 1;
-            if (n == 0) y = 1;
-            else if (n > 0) for (i = 1; i <= n; i++) y *= i;
-            else y = NaN;
-            return y;
-        },...x);
-    const sign=(...x)=>mapfun$1(Math.sign,...x);
+    }
 
-    const sig=(...x)=>mapfun$1(n=>1/(1+e(-n)),...x);
 
-    const hypot=(...x)=>{
-        if(x.every(n=>typeof n === "number"))return Math.hypot(...x);
-        if(x.every(n=>n instanceof Array))return mapfun$1(
-            Math.hypot,
-            ...x
-        )
-    };
+    /**
+    * @returns {Matrix}
+    */
+    const matrix=(r, c, element)=>new Matrix(r, c, element);
+    const matrix2=(...element)=>new Matrix(2, 2, element);
+    const matrix3=(...element)=>new Matrix(3, 3, element);
+    const matrix4=(...element)=>new Matrix(4, 4, element);
 
     const { PI, sqrt: sqrt$1, cos: cos$1, sin: sin$1, acos, pow } = Math;