ziko 0.51.1 → 0.53.0

package/dist/ziko.cjs

@@ -2,7 +2,7 @@
 /*
   Project: ziko.js
   Author: Zakaria Elalaoui
-  Date : Wed Dec 03 2025 10:48:15 GMT+0100 (UTC+01:00)
+  Date : Fri Dec 05 2025 11:33:57 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
@@ -13,87 +13,340 @@
 const { PI: PI$2, E } = Math;
 const EPSILON=Number.EPSILON;
 
-const {PI: PI$1, cos: cos$3, sin: sin$3, tan: tan$1, acos: acos$2, asin: asin$1, atan: atan$1, cosh: cosh$2, sinh: sinh$2, tanh: tanh$1, acosh: acosh$1, asinh: asinh$1, atanh: atanh$1, log: log$1} = Math;
+const {PI: PI$1, cos: cos$3, sin: sin$3, tan: tan$1, atan: atan$1, cosh: cosh$2, sinh: sinh$2, tanh: tanh$1, acosh: acosh$1, asinh: asinh$1, atanh: atanh$1, log: log$1} = Math;
 let Fixed={
-    cos: cos$3,
-    sin: sin$3,
-    tan: tan$1,
+    cos : x=> {
+        if(x.isComplex?.()) return new x.constructor(
+            cos$3(x.a)*cosh$2(x.b),
+            -(sin$3(x.a)*sinh$2(x.b))
+        );
+        return cos$3(x)
+    },
+    sin : x=>{
+        if(x?.isComplex) return new x.constructor(
+            sin$3(x.a)*cosh$2(x.b),
+            cos$3(x.a)*sinh$2(x.b)
+        );
+        return sin$3(x)
+    },
+    tan : x=>{
+        if(x?.isComplex){
+            const DEN = cos$3(2*x.a)+cosh$2(2*x.b);
+            return new x.constructor(
+                sin$3(2*x.a)/DEN,
+                sinh$2(2*x.b)/DEN
+            );
+        } 
+        return tan$1(x) 
+    },
     sinc: x => sin$3(PI$1*x)/(PI$1*x),
     sec: x => 1/cos$3(x),
     csc: x => 1/sin$3(x),
     cot: x => 1/tan$1(x),
-    acos: acos$2,
-    asin: asin$1,
-    atan: atan$1,
+    acos: x=>{
+        if(x?.isComplex) return 
+        return sin$3(x)
+    },
+    asin: x=>{
+        if(x?.isComplex) return 
+        return sin$3(x)
+    },
+    atan: x=>{
+        if(x?.isComplex) return 
+        return sin$3(x)
+    },
     acot: x => PI$1/2-atan$1(x),
-    cosh: cosh$2,
-    sinh: sinh$2,
-    tanh: tanh$1,
+    cosh: x=>{
+        if(x?.isComplex) return new x.constructor(
+            cosh$2(x.a)*cos$3(x.b),
+            sinh$2(x.a)*sin$3(x.b)
+        ); 
+        return cosh$2(x)
+    },
+    sinh: x=>{
+        if(x?.isComplex) return new x.constructor(
+            sinh$2(x.a)*cos$3(x.b),
+            cosh$2(x.a)*sin$3(x.b)
+        ); 
+        return sinh$2(x)
+    },
+    tanh: x=>{
+        if(x?.isComplex){
+            const DEN=cosh$2(2*a)+cos$3(2*b);
+            return new x.constructor(
+                sinh$2(2*a)/DEN,
+                sin$3(2*b)/DEN
+            )
+        } 
+        return tanh$1(x)
+    },
     coth: n => (1/2*log$1((1+n)/(1-n))),
     acosh: acosh$1,
     asinh: asinh$1,
     atanh: atanh$1,
 };
 
-Fixed = new Proxy(Fixed, {
-    get(target, prop) {
-        if(prop in target){
-            return x => + target[prop](x).toFixed(15);
-        }
-        return undefined;
-    }
-});
+// Fixed = new Proxy(Fixed, {
+//     get(target, prop) {
+//         if(prop in target){
+//             return x => + target[prop](x).toFixed(15);
+//         }
+//         return undefined;
+//     }
+// })
 
-// To generalise
-
 const mapfun$1=(fun,...X)=>{
     const Y=X.map(x=>{
-        if(x===null) return fun(null);
-        if(["number","string","boolean","bigint","undefined"].includes(typeof x)) return fun(x);
+        if(
+            x===null||
+            ["number","string","boolean","bigint","undefined"].includes(typeof x)||
+            x?.__mapfun__
+        ) return fun(x)
         if(x instanceof Array) return x.map(n=>mapfun$1(fun,n));
         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){
-            const [a,b,z,phi]=[x.a,x.b,x.z,x.phi];
-            switch(fun){
-                case Math.log: return complex(ln(z),phi); // Done
-                case Math.exp: return complex(e(a)*cos$2(b),e(a)*sin$2(b)); // Done
-                case Math.abs: return z; // Done
-                case Math.sqrt: return complex(sqrt$2(z)*cos$2(phi/2),sqrt$2(z)*sin$2(phi/2)); // Done
-                case Fixed.cos: return complex(cos$2(a)*cosh$1(b),-(sin$2(a)*sinh$1(b)));
-                case Fixed.sin: return complex(sin$2(a)*cosh$1(b),cos$2(a)*sinh$1(b));
-                case Fixed.tan:{
-                    const DEN = cos$2(2*a)+cosh$1(2*b);
-                    return complex(sin$2(2*a)/DEN,sinh$1(2*b)/DEN);
-                }
-                case Fixed.cosh:return complex(cosh$1(a)*cos$2(b),sinh$1(a)*sin$2(b));
-                case Fixed.sinh:return complex(sinh$1(a)*cos$2(b),cosh$1(a)*sin$2(b));
-                case Fixed.tanh:{
-                    const DEN=cosh$1(2*a)+cos$2(2*b);
-                    return complex(sinh$1(2*a)/DEN,sin$2(2*b)/DEN)
-                }
-                default : return fun(x)
-            }
-        }
+        if(x.isMatrix?.()) return new x.constructor(x.rows, x.cols, mapfun$1(x.arr.flat(1)))
+        // if(x.isComplex?.()){
+        //     const [a,b,z,phi]=[x.a,x.b,x.z,x.phi];
+        //     switch(fun){
+        //         // Moved to Fixed to avoid Circular Dep
+        //         // case Math.log: return new x.constructor(ln(z),phi); // Done
+        //         // case Math.exp: return new x.constructor(e(a)*cos(b),e(a)*sin(b)); // Done
+        //         // case Math.abs: return z; // Done
+        //         // case Math.sqrt: return new x.constructor(sqrt(z)*cos(phi/2),sqrt(z)*sin(phi/2)); // Done
+        //         // case Fixed.cos: return new x.constructor(cos(a)*cosh(b),-(sin(a)*sinh(b)));
+        //         // case Fixed.sin: return new x.constructor(sin(a)*cosh(b),cos(a)*sinh(b));
+        //         // case Fixed.tan:{
+        //         //     const DEN = cos(2*a)+cosh(2*b);
+        //         //     return new x.constructor(sin(2*a)/DEN,sinh(2*b)/DEN);
+        //         // }
+        //         // case Fixed.cosh:return new x.constructor(cosh(a)*cos(b),sinh(a)*sin(b));
+        //         // case Fixed.sinh:return new x.constructor(sinh(a)*cos(b),cosh(a)*sin(b));
+        //         // case Fixed.tanh:{
+        //         //     const DEN=cosh(2*a)+cos(2*b);
+        //         //     return new x.constructor(sinh(2*a)/DEN,sin(2*b)/DEN)
+        //         // }
+        //         default : return fun(x)
+        //     }
+        // }
         else if(x instanceof Object){
             return Object.fromEntries(Object.entries(x).map(n=>n=[n[0],mapfun$1(fun,n[1])]))
+            // return fun(Object) || Object.fromEntries(Object.entries(x).map(n=>n=[n[0],mapfun(fun,n[1])]))
         }
     });
-   return Y.length==1?Y[0]:Y; 
+   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);
     }
@@ -109,11 +362,11 @@ const _add=(a,b)=>{
 const _sub=(a,b)=>{
     if(typeof(a)==="number"){
         if (typeof b == "number") return a - b;
-        else if (b instanceof Complex)return complex(a - b.a, -b.b);
-        else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).sub(b);
+        else if (b.isComplex?.())return new b.constructor(a - b.a, -b.b);
+        else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).sub(b);
         else if (b instanceof Array)return b.map(n=>sub(n,a));                 
     }
-    else if(a instanceof Complex||a instanceof Matrix){
+    else if(a.isComplex?.()||a.isMatrix?.()){
         if(b instanceof Array)return b.map(n=>a.clone.sub(n));
         return a.clone.sub(b);
     }
@@ -131,11 +384,11 @@ const _sub=(a,b)=>{
 const _mul=(a,b)=>{
     if(typeof(a)==="number"){
     if (typeof b == "number") return a * b;
-        else if (b instanceof Complex)return complex(a * b.a,a * b.b);
-        else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).mul(b);
+        else if (b.isComplex?.())return new b.constructor(a * b.a,a * b.b);
+        else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).mul(b);
         else if (b instanceof Array)return b.map(n=>mul(a,n)); 
     }
-    else if(a instanceof Complex||a instanceof Matrix){
+    else if(a.isComplex?.()||a.isMatrix?.()){
         if(b instanceof Array)return b.map(n=>a.clone.mul(n));
         return a.clone.mul(b);
     }
@@ -153,11 +406,11 @@ const _mul=(a,b)=>{
 const _div=(a,b)=>{
     if(typeof(a)==="number"){
     if (typeof b == "number") return a / b;
-        else if (b instanceof Complex)return complex(a / b.a,a / b.b);
-        else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).div(b);
+        else if (b.isComplex?.())return new b.constructor(a / b.a,a / b.b);
+        else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).div(b);
         else if (b instanceof Array)return b.map(n=>div(a,n));
     }
-    else if(a instanceof Complex||a instanceof Matrix){
+    else if(a.isComplex?.()||a.isMatrix?.()){
         if(b instanceof Array)return b.map(n=>a.clone.div(n));
         return a.clone.div(b);
     }
@@ -175,11 +428,11 @@ const _div=(a,b)=>{
 const _modulo=(a,b)=>{
     if(typeof(a)==="number"){
         if (typeof b == "number") return a % b;
-            else if (b instanceof Complex)return complex(a % b.a,a % b.b);
-            else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).modulo(b);
+            else if (b.isComplex?.())return new b.constructor(a % b.a,a % b.b);
+            else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).modulo(b);
             else if (b instanceof Array)return b.map(n=>div(a,n));
         }
-        else if(a instanceof Complex||a instanceof Matrix){
+        else if(a.isComplex?.()||a.isMatrix?.()){
             if(b instanceof Array)return b.map(n=>a.clone.div(n));
             return a.clone.div(b);
         }
@@ -221,8 +474,8 @@ const ones=(n)=>new Array(n).fill(1);
 const nums=(num,n)=>new Array(n).fill(num);
 const norm=(value, min, max)=>{
     if (typeof value === "number") return min !== max ? (value - min) / (max - min) : 0;
-    else if (value instanceof Matrix) return new Matrix(value.rows, value.cols, norm(value.arr.flat(1), min, max));
-    else if (value instanceof Complex) return new Complex(norm(value.a, min, max), norm(value.b, min, max));
+    else if (value.isMatrix?.()) return new value.constructor(value.rows, value.cols, norm(value.arr.flat(1), min, max));
+    else if (value.isComplex?.()) return new value.constructor(norm(value.a, min, max), norm(value.b, min, max));
     else if (value instanceof Array) {
         if (value.every((n) => typeof (n === "number"))) {
             return value.map((n) => norm(n, min, max));
@@ -236,8 +489,8 @@ const norm=(value, min, max)=>{
 };
 const lerp=(value, min, max)=>{
     if (typeof value === "number") return (max - min) * value + min;
-    else if (value instanceof Matrix) return new Matrix(value.rows, value.cols, lerp(value.arr.flat(1), min, max));
-    else if (value instanceof Complex) return new Complex(lerp(value.a, min, max), lerp(value.b, min, max));
+    else if (value.isMatrix?.()) return new value.constructor(value.rows, value.cols, lerp(value.arr.flat(1), min, max));
+    else if (value.isComplex?.()) return new value.constructor(lerp(value.a, min, max), lerp(value.b, min, max));
     else if (value instanceof Array) {
         if (value.every((n) => typeof (n === "number"))) {
             return value.map((n) => lerp(n, min, max));
@@ -249,17 +502,17 @@ const lerp=(value, min, max)=>{
         }
     }
 };
-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);
             }
         }
     }
@@ -267,8 +520,8 @@ const map$1=(value, a, b, c, d)=>{
 const clamp=(x, a , b)=>{
     const [min_value,max_value]=[min(a,b),max(a,b)];
     if (typeof x === "number") return min(max(x, min_value), max_value);
-    else if (x instanceof Matrix) return new Matrix(x.rows, x.cols, clamp(x.arr.flat(1), min_value, max_value));
-    else if (x instanceof Complex) return new Complex(clamp(x.a, min_value, max_value), clamp(x.b, min_value, max_value));
+    else if (x.isMatrix?.()) return new x.constructor(x.rows, x.cols, clamp(x.arr.flat(1), min_value, max_value));
+    else if (x.isComplex?.()) return new x.constructor(clamp(x.a, min_value, max_value), clamp(x.b, min_value, max_value));
     else if (x instanceof Array) {
         if (x.every((n) => typeof (n === "number"))) {
             return x.map((n) => clamp(n, min_value, max_value));
@@ -303,14 +556,14 @@ const linspace=(a,b,n=abs(b-a)+1,endpoint=true)=>{
         return Y
     }
 
-    if([a,b].some(n=>n instanceof Complex)){
-        const z1=complex(a);
-        const z2=complex(b);
+    if([a,b].some(n=>n.isComplex?.())){
+        const z1 = new n.constructor(a);
+        const z2 = new n.constructor(b);
         n=n||Math.abs(z1.a-z2.a)+1;
         const X=linspace(z1.a,z2.a,n,endpoint);
         const Y=linspace(z1.b,z2.b,n,endpoint);
         let Z=new Array(n).fill(null);
-        Z=Z.map((n,i)=>complex(X[i],Y[i]));
+        Z=Z.map((n,i)=> new n.constructor(X[i],Y[i]));
         return Z;
     }
 };
@@ -330,9 +583,9 @@ const geomspace=(a,b,n=abs(b-a)+1,endpoint=true)=>{
         return a<b?Y:Y.reverse()
     }
 
-    if([a,b].some(n=>n instanceof Complex)){
-        const z1=complex(a);
-        const z2=complex(b);
+    if([a,b].some(n=>n.isComplex?.())){
+        const z1 = new n.constructor(a);
+        const z2 = new n.constructor(b);
         n=n||Math.abs(z1.a-z2.a)+1;
         let base;
         endpoint ? base = sqrtn(z2.div(z1),n-1) : base = sqrtn(z2.div(z1),n) ;
@@ -359,109 +612,18 @@ const deg2rad = (...deg) => mapfun(x => x * Math.PI / 180, ...deg);
  */
 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;
 };
 
 /**
@@ -554,394 +716,194 @@ const Utils={
     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;
+    get __mapfun__(){
+        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))
-    }
-    
-};
-
-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()))
+    isComplex(){
+        return true
     }
-    static floats(n, a, b) {
-        return new Array(n).fill(0).map(() => this.float(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;
     }
-    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));
+    get expo() {
+        return [this.z, this.phi];
     }
-    static complexOct() {
-        return new Complex(...this.octs(2));
+    static add(c,...z) {
+        return c.clone.add(...z);
     }
-    static complexDec() {
-        return new Complex(...this.decs(10));
+    static sub(c,...z) {
+        return c.clone.sub(...z);
     }
-    static complexHex() {
-        return new Complex(...this.octs(2));
+    static mul(c,...z) {
+        return c.clone.mul(...z);
     }
-    static complexes(n, a = 0, b = 1) {
-        return new Array(n).fill(0).map(() => this.complex(a, b));
+    static div(c,...z) {
+        return c.clone.div(...z);
     }
-    static complexesInt(n, a = 0, b = 1) {
-        return new Array(n).fill(0).map(() => this.complexInt(a, b));
+    static pow(z,n){
+        return z.clone.pow(n);
     }
-    static complexesBin(n) {
-        return new Array(n).fill(0).map(() => this.complexBin());
+    static xpowZ(x){
+        return complex((x**this.a)*cos$2(this.b*ln(x)),(x**this.a)*sin$2(this.b*ln(x)));
     }
-    static complexesOct(n) {
-        return new Array(n).fill(0).map(() => this.complexOct());
+    sqrtn(n=2){
+        return complex(sqrtn(this.z,n)*cos$2(this.phi/n),sqrtn(this.z,n)*sin$2(this.phi/n));
     }
-    static complexesDec(n) {
-        return new Array(n).fill(0).map(() => this.complexDec());
+    get sqrt(){
+        return this.sqrtn(2);
     }
-    static complexesHex(n) {
-        return new Array(n).fill(0).map(() => this.complexHex());
+    get log(){
+        return complex(this.z,this.phi);
     }
-    static matrix(r,c,min,max){
-        return matrix(r,c,this.floats(r*c,min,max))
+    get cos(){
+        return complex(cos$2(this.a)*cosh$1(this.b),sin$2(this.a)*sinh$1(this.b))
     }
-    static matrixInt(r,c,min,max){
-        return matrix(r,c,this.ints(r*c,min,max))
+    get sin(){
+        return complex(sin$2(this.a)*cosh$1(this.b),cos$2(this.a)*sinh$1(this.b))
     }
-    static matrixBin(r,c){
-        return matrix(r,c,this.bins(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 matrixOct(r,c){
-        return matrix(r,c,this.octs(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)
     }
-    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))
-    }
-}
-
-const preload=(url)=>{
-    const xhr = new XMLHttpRequest();
-    xhr.open("GET", url, false); 
-    xhr.send();
-    if (xhr.status === 200) {
-      return xhr.responseText;
-    } else {
-      throw new Error(`Failed to fetch data from ${url}. Status: ${xhr.status}`);
+    return new Complex(a,b)
+};
+
+const preload=(url)=>{
+    const xhr = new XMLHttpRequest();
+    xhr.open("GET", url, false); 
+    xhr.send();
+    if (xhr.status === 200) {
+      return xhr.responseText;
+    } else {
+      throw new Error(`Failed to fetch data from ${url}. Status: ${xhr.status}`);
     }
 };
 
@@ -1086,6 +1048,35 @@ class UINode {
 
 // globalThis.node = (node) => new UINode(node);
 
+function parseQueryParams$1(queryString) {
+    const params = {};
+    queryString.replace(/[A-Z0-9]+?=([\w|:|\/\.]*)/gi, (match) => {
+        const [key, value] = match.split('=');
+        params[key] = value;
+    });
+    return params;
+}
+
+function defineParamsGetter$1(target ){
+    Object.defineProperties(target, {
+        'QueryParams': {
+            get: function() {
+                return parseQueryParams$1(globalThis.location.search.substring(1));
+            },
+            configurable: false,
+            enumerable: true 
+        },
+        'HashParams': {
+            get: function() {
+                const hash = globalThis.location.hash.substring(1);
+                return hash.split("#");
+            },
+            configurable: false,
+            enumerable: true 
+        }
+    });
+}
+
 class UIStore extends Array {
     constructor(...args) {
         super(...args); 
@@ -1119,202 +1110,6 @@ class UIStore extends Array {
 // create the singleton
 const __UI__ = new UIStore();
 
-// __init__global__()
-class UIElementCore extends UINode{
-  constructor(){
-    super();
-  }
-  init(element, name, type, render){
-    this.target = globalThis.__Ziko__.__Config__.default.target||globalThis?.document?.body;
-    if(typeof element === "string") {
-      switch(type){
-        case "html" : {
-          element = globalThis?.document?.createElement(element);
-          // console.log('1')
-        } break;
-        case "svg" : {
-          element = globalThis?.document?.createElementNS("http://www.w3.org/2000/svg", element); 
-          // console.log('2')
-        } break;
-        default : throw Error("Not supported")
-      }
-    }
-    else this.target = element?.parentElement;
-    Object.assign(this.cache, {
-      name,
-      isInteractive : false,
-      parent:null,
-      isBody:false,
-      isRoot:false,
-      isHidden: false,
-      isFrozzen:false,
-      legacyParent : null,
-      attributes: {},
-      filters: {},
-      temp:{}
-    });
-    this.events = {
-      ptr:null,
-      mouse:null,
-      wheel:null,
-      key:null,
-      drag:null,
-      drop:null,
-      click:null,
-      clipboard:null,
-      focus:null,
-      swipe:null,
-      custom:null,
-    };
-    this.observer={
-      resize:null,
-      intersection:null
-    };
-    if(element) Object.assign(this.cache,{element});
-    // useDefaultStyle && this.style({ 
-    //   position: "relative",
-    //   boxSizing:"border-box",
-    //   margin:0,
-    //   padding:0,
-    //   width : "auto",
-    //   height : "auto"
-    //  });
-    this.items = new UIStore();
-    globalThis.__Ziko__.__UI__[this.cache.name]?globalThis.__Ziko__.__UI__[this.cache.name]?.push(this):globalThis.__Ziko__.__UI__[this.cache.name]=[this];
-    element && render && this?.render?.();
-    globalThis.__Ziko__.__UI__.push(this);
-  }
-  get element(){
-    return this.cache.element;
-  }
-    [Symbol.iterator]() {
-    return this.items[Symbol.iterator]();
-  }
-  maintain() {
-    for (let i = 0; i < this.items.length; i++) {
-      Object.defineProperty(this, i, {
-        value: this.items[i],
-        writable: true,
-        configurable: true,
-        enumerable: false 
-        });
-    }
-  }
-  isInteractive(){
-    return this.cache.isInteractive;
-  }
-  isUIElement(){
-    return true;
-  }
-}
-
-function register_to_class(target, ...mixins){
-    mixins.forEach(n => _register_to_class_(target, n));
-}
-function _register_to_class_(target, mixin) {
-  const descriptors = Object.getOwnPropertyDescriptors(mixin);
-  for (const key of Reflect.ownKeys(descriptors)) {
-    const desc = descriptors[key];
-    if ('get' in desc || 'set' in desc || typeof desc.value !== 'function') {
-      Object.defineProperty(Object.getPrototypeOf(target), key, desc);
-    } else if (typeof desc.value === 'function') {
-      if (!Object.getPrototypeOf(target).hasOwnProperty(key)) {
-        Object.defineProperty(Object.getPrototypeOf(target), key, desc);
-      }
-    }
-  }
-}
-
-// export function mount(target = this.target) {
-//   if(this.isBody) return ;
-//   if(target?.isUIElement)target=target.element;
-//   this.target=target;
-//   this.target?.appendChild(this.element);
-//   return this;
-// }
-// export function unmount(){
-//   if(this.cache.parent)this.cache.parent.remove(this);
-//   else if(this.target?.children?.length && [...this.target?.children].includes(this.element)) this.target.removeChild(this.element);
-//   return this;
-// }
-
-// export function mountAfter(target = this.target, t = 1) {
-//   setTimeout(() => this.mount(), t);
-//   return this;
-// }
-// export function unmountAfter(t = 1) {
-//   setTimeout(() => this.unmount(), t);
-//   return this;
-// }
-
-function mount(target = this.target, delay = 0) {
-    if (delay > 0) {
-        setTimeout(() => this.mount(target, 0), delay);
-        return this;
-    }
-
-    if (this.isBody) return this;
-
-    if (target?.isUIElement) target = target.element;
-    this.target = target;
-
-    this.target?.appendChild(this.element);
-    return this;
-}
-
-function unmount(delay = 0) {
-    if (delay > 0) {
-        setTimeout(() => this.unmount(0), delay);
-        return this;
-    }
-
-    if (this.cache.parent) {
-        this.cache.parent.remove(this);
-    } else if (
-        this.target?.children?.length &&
-        [...this.target.children].includes(this.element)
-    ) {
-        this.target.removeChild(this.element);
-    }
-
-    return this;
-}
-
-var LifecycleMethods = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    mount: mount,
-    unmount: unmount
-});
-
-function parseQueryParams$1(queryString) {
-    const params = {};
-    queryString.replace(/[A-Z0-9]+?=([\w|:|\/\.]*)/gi, (match) => {
-        const [key, value] = match.split('=');
-        params[key] = value;
-    });
-    return params;
-}
-
-function defineParamsGetter$1(target ){
-    Object.defineProperties(target, {
-        'QueryParams': {
-            get: function() {
-                return parseQueryParams$1(globalThis.location.search.substring(1));
-            },
-            configurable: false,
-            enumerable: true 
-        },
-        'HashParams': {
-            get: function() {
-                const hash = globalThis.location.hash.substring(1);
-                return hash.split("#");
-            },
-            configurable: false,
-            enumerable: true 
-        }
-    });
-}
-
 const __Config__ = {
     default:{
         target:null,
@@ -1369,7 +1164,7 @@ class UseIPC {
         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.#uuid = "ziko-channel:" + (Math.random()*10e16);  // To Be Replaced by UUID
         this.#subscribers = new Set([this.#uuid]);
         this.#currentRooms = new Set(); 
         this.#channel.addEventListener("message", (e) => {
@@ -1568,19 +1363,186 @@ function __init__global__(){
     }
 }
 
-if(!globalThis.__Ziko__) __init__global__();
-
-function useState(initialValue) {
-    
-    const {store, index} = __Ziko__.__State__;
-    __Ziko__.__State__.register({
-            value : initialValue,
-            subscribers : new Set(),
-            paused : false
-    });
-
-    let current = store.get(index);
-
+__init__global__();
+class UIElementCore extends UINode{
+  constructor(){
+    super();
+  }
+  init(element, name, type, render){
+    this.target = globalThis.__Ziko__.__Config__.default.target||globalThis?.document?.body;
+    if(typeof element === "string") {
+      switch(type){
+        case "html" : {
+          element = globalThis?.document?.createElement(element);
+          // console.log('1')
+        } break;
+        case "svg" : {
+          element = globalThis?.document?.createElementNS("http://www.w3.org/2000/svg", element); 
+          // console.log('2')
+        } break;
+        default : throw Error("Not supported")
+      }
+    }
+    else this.target = element?.parentElement;
+    Object.assign(this.cache, {
+      name,
+      isInteractive : false,
+      parent:null,
+      isBody:false,
+      isRoot:false,
+      isHidden: false,
+      isFrozzen:false,
+      legacyParent : null,
+      attributes: {},
+      filters: {},
+      temp:{}
+    });
+    this.events = {
+      ptr:null,
+      mouse:null,
+      wheel:null,
+      key:null,
+      drag:null,
+      drop:null,
+      click:null,
+      clipboard:null,
+      focus:null,
+      swipe:null,
+      custom:null,
+    };
+    this.observer={
+      resize:null,
+      intersection:null
+    };
+    if(element) Object.assign(this.cache,{element});
+    // useDefaultStyle && this.style({ 
+    //   position: "relative",
+    //   boxSizing:"border-box",
+    //   margin:0,
+    //   padding:0,
+    //   width : "auto",
+    //   height : "auto"
+    //  });
+    this.items = new UIStore();
+    globalThis.__Ziko__.__UI__[this.cache.name]?globalThis.__Ziko__.__UI__[this.cache.name]?.push(this):globalThis.__Ziko__.__UI__[this.cache.name]=[this];
+    element && render && this?.render?.();
+    globalThis.__Ziko__.__UI__.push(this);
+  }
+  get element(){
+    return this.cache.element;
+  }
+    [Symbol.iterator]() {
+    return this.items[Symbol.iterator]();
+  }
+  maintain() {
+    for (let i = 0; i < this.items.length; i++) {
+      Object.defineProperty(this, i, {
+        value: this.items[i],
+        writable: true,
+        configurable: true,
+        enumerable: false 
+        });
+    }
+  }
+  isInteractive(){
+    return this.cache.isInteractive;
+  }
+  isUIElement(){
+    return true;
+  }
+}
+
+function register_to_class(target, ...mixins){
+    mixins.forEach(n => _register_to_class_(target, n));
+}
+function _register_to_class_(target, mixin) {
+  const descriptors = Object.getOwnPropertyDescriptors(mixin);
+  for (const key of Reflect.ownKeys(descriptors)) {
+    const desc = descriptors[key];
+    if ('get' in desc || 'set' in desc || typeof desc.value !== 'function') {
+      Object.defineProperty(Object.getPrototypeOf(target), key, desc);
+    } else if (typeof desc.value === 'function') {
+      if (!Object.getPrototypeOf(target).hasOwnProperty(key)) {
+        Object.defineProperty(Object.getPrototypeOf(target), key, desc);
+      }
+    }
+  }
+}
+
+// export function mount(target = this.target) {
+//   if(this.isBody) return ;
+//   if(target?.isUIElement)target=target.element;
+//   this.target=target;
+//   this.target?.appendChild(this.element);
+//   return this;
+// }
+// export function unmount(){
+//   if(this.cache.parent)this.cache.parent.remove(this);
+//   else if(this.target?.children?.length && [...this.target?.children].includes(this.element)) this.target.removeChild(this.element);
+//   return this;
+// }
+
+// export function mountAfter(target = this.target, t = 1) {
+//   setTimeout(() => this.mount(), t);
+//   return this;
+// }
+// export function unmountAfter(t = 1) {
+//   setTimeout(() => this.unmount(), t);
+//   return this;
+// }
+
+function mount(target = this.target, delay = 0) {
+    if (delay > 0) {
+        setTimeout(() => this.mount(target, 0), delay);
+        return this;
+    }
+
+    if (this.isBody) return this;
+
+    if (target?.isUIElement) target = target.element;
+    this.target = target;
+
+    this.target?.appendChild(this.element);
+    return this;
+}
+
+function unmount(delay = 0) {
+    if (delay > 0) {
+        setTimeout(() => this.unmount(0), delay);
+        return this;
+    }
+
+    if (this.cache.parent) {
+        this.cache.parent.remove(this);
+    } else if (
+        this.target?.children?.length &&
+        [...this.target.children].includes(this.element)
+    ) {
+        this.target.removeChild(this.element);
+    }
+
+    return this;
+}
+
+var LifecycleMethods = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    mount: mount,
+    unmount: unmount
+});
+
+if(!globalThis.__Ziko__) __init__global__();
+
+function useState(initialValue) {
+    
+    const {store, index} = __Ziko__.__State__;
+    __Ziko__.__State__.register({
+            value : initialValue,
+            subscribers : new Set(),
+            paused : false
+    });
+
+    let current = store.get(index);
+
     function getValue() {
         return {
             value: current.value,
@@ -2022,38 +1984,137 @@ function key_details_setter(){
     }
 }
 
-function ptr_details_setter(){
-    switch(this.currentEvent){
-        case "pointerdown" : {
-            this.dx = parseInt(this.event.offsetX);
-            this.dy = parseInt(this.event.offsetY);
+function ptr_details_setter() {
+    const rect = this.targetElement.getBoundingClientRect();
+    const e = this.event;
+    let x = (e.clientX - rect.left) | 0;
+    let y = (e.clientY - rect.top) | 0;
+
+    if(this.cache.useNormalisedCoordinates){
+        const w = this.targetElement.clientWidth;
+        const h = this.targetElement.clientHeight;
+        x = +((x / w) * 2 - 1).toFixed(8);
+        y = +((y / h) * -2 + 1).toFixed(8);
+    }
+    switch (this.currentEvent) {
+
+        case "pointerdown":
+            this.dx = x;
+            this.dy = y;
             this.isDown = true;
-        } break;
-        case "pointermove" : {
-            this.mx = parseInt(this.event.offsetX);
-            this.my = parseInt(this.event.offsetY);
+            break;
+
+        case "pointermove":
+            this.mx = x;
+            this.my = y;
             this.isMoving = true;
-        } break;
-        case "pointerup" : {
-            this.ux = parseInt(this.event.offsetX);
-            this.uy = parseInt(this.event.offsetY);
+            break;
+
+        case "pointerup":
+            this.ux = x;
+            this.uy = y;
             this.isDown = false;
-            console.log(this.target.width);
-            const delta_x=(this.ux-this.dx)/this.target.width;
-            const delta_y=(this.dy-this.uy)/this.target.height;
-            const HORIZONTAL_SWIPPE=(delta_x<0)?"left":(delta_x>0)?"right":"none";
-            const VERTICAL_SWIPPE=(delta_y<0)?"bottom":(delta_y>0)?"top":"none";
-            this.swippe={
-                h:HORIZONTAL_SWIPPE,
-                v:VERTICAL_SWIPPE,
-                delta_x,
-                delta_y
-            };
-        } break;
+            this.isMoving = false;
+            break;
+    }
+}
+
+function mouse_details_setter() {
+    const rect = this.targetElement.getBoundingClientRect();
+    const e = this.event;
+    let x = (e.clientX - rect.left) | 0;
+    let y = (e.clientY - rect.top) | 0;
+
+    if(this.cache.useNormalisedCoordinates){
+        const w = this.targetElement.clientWidth;
+        const h = this.targetElement.clientHeight;
+        x = +((x / w) * 2 - 1).toFixed(8);
+        y = +((y / h) * -2 + 1).toFixed(8);
+    }
+
+    switch (this.currentEvent) {
+
+        case "mousedown":
+            this.dx = x;
+            this.dy = y;
+            this.isDown = true;
+            break;
+
+        case "mousemove":
+            this.mx = x;
+            this.my = y;
+            this.isMoving = true;
+            break;
+
+        case "mouserup":
+            this.ux = x;
+            this.uy = y;
+            this.isDown = false;
+            this.isMoving = false;
+            break;
+    }
+}
+
+function touch_details_setter() {
+    const e = this.event;
+    const touch = e.touches?.[0] || e.changedTouches?.[0];
+
+    if (!touch) return; // should never happen but safe
+
+    const rect = this.targetElement.getBoundingClientRect();
+    let x = touch.clientX - rect.left;
+    let y = touch.clientY - rect.top;
+
+    if(this.cache.useNormalisedCoordinates){
+        const w = this.targetElement.clientWidth;
+        const h = this.targetElement.clientHeight;
+        x = +((x / w) * 2 - 1).toFixed(8);
+        y = +((y / h) * -2 + 1).toFixed(8);
+    }
+
+    switch (this.currentEvent) {
+        case "touchstart":
+            this.dx = x;
+            this.dy = y;
+            this.isDown = true;
+            break;
+
+        case "touchmove":
+            this.mx = x;
+            this.my = y;
+            this.isMoving = true;
+            break;
+
+        case "touchend":
+            this.ux = x;
+            this.uy = y;
+            this.isDown = false;
+            break;
+    }
+}
+
+class CoordinatesBasedEvent extends ZikoEvent{
+    constructor(signature, target = null, Events = [], details_setter, customizer){
+        super(signature, target, Events, details_setter, customizer);
+        Object.assign(this.cache,{
+            useNormalisedCoordinates : false
+        });
+        this.isDown = false;
+        this.isMoving = false;
+        this.dx = 0;
+        this.dy = 0;
+        this.mx = 0;
+        this.my = 0;
+        this.ux = 0;
+        this.uy = 0;
+    }
+    get isDragging(){
+        return this.isDown && this.isMoving
+    }
+    useNormalisedCoordinates(enable = true){
+        this.cache.useNormalisedCoordinates = enable;
+        return this;
     }
-    // if(this.currentEvent==="click") this.dx = 0
-    // else this.dx = 1
-    // console.log(this.currentEvent)
 }
 
 class ClickAwayEvent extends Event {
@@ -2284,25 +2345,25 @@ const bind_key_event = (target, customizer) => new ZikoEvent(
     key_details_setter, 
     customizer
 );
-const bind_mouse_event = (target, customizer) => new ZikoEvent(
+const bind_mouse_event = (target, customizer) => new CoordinatesBasedEvent(
     'mouse',
     target,
     EventsMap.Mouse,
-    null,
+    mouse_details_setter,
     customizer
 );
-const bind_pointer_event = (target, customizer) => new ZikoEvent(
+const bind_pointer_event = (target, customizer) => new CoordinatesBasedEvent(
     'ptr',
     target,
     EventsMap.Ptr, 
     ptr_details_setter, 
     customizer
 );
-const bind_touch_event = (target, customizer) => new ZikoEvent(
+const bind_touch_event = (target, customizer) => new CoordinatesBasedEvent(
     'touch',
     target,
     EventsMap.Touch,
-    null,
+    touch_details_setter,
     customizer
 );
 const bind_wheel_event = (target, customizer) => new ZikoEvent(
@@ -2465,6 +2526,14 @@ var StyleMethods = /*#__PURE__*/Object.freeze({
     style: style
 });
 
+// import { 
+//   // useCustomEvent,
+//   // useSwipeEvent,
+//   // watchIntersection, 
+//   // watchSize,
+//   // watchAttr,
+//   // watchChildren
+// } from "../../--reactivity-deprecated/events/custom-event.js"
 let UIElement$1 = class UIElement extends UIElementCore{
   constructor({element, name ='', type='html', render = __Ziko__.__Config__.default.render}={}){
     super();
@@ -3211,274 +3280,454 @@ function trimKeys(obj) {
     }, 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;
-                }
-            }
+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];
         }
-        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");
+    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;
+        }
+        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];
+            }
+        }
     }
-    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;
+    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;
     }
-    get clone() {
-        return new Matrix(this.rows, this.cols, this.arr.flat(1));
+    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;   
     }
-    get size() {
-        return this.rows * this.cols;
-    } 
-    get shape() {
-        return [this.rows, this.cols];
+    this.#maintain();
     }
-    get reel() {
-        return new Matrix(this.cols, this.rows, this.arr.flat(1).reel);
+    isMatrix(){
+        return true
     }
-    get imag() {
-        return new Matrix(this.cols, this.rows, this.arr.flat(1).imag);
+    clone() {
+        return new Matrix(this.rows, this.cols, this.arr.flat(1));
     }
     [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;
+        for (let i = 0; i < this.arr.length; i++) {
+            Object.defineProperty(this, i, {
+                value: this.arr[i],
+                writable: true,
+                configurable: true,
+                enumerable: false 
+            });
         }
-        return (this.arr[row][col] = value);
     }
-    get isSquare() {
-        return this.rows / this.cols === 1;
+    get size() {
+        return this.rows * this.cols;
+    } 
+    get shape() {
+        return [this.rows, this.cols];
     }
-    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;
+    toString(){
+        return arr2str(this.arr);
     }
-    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;
+    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];
     }
-    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;
+    slice(r0=0, c0=0, r1=this.rows-1, c1=this.cols-1) {
+        let newRow = r1 - r0,
+            newCol = c1 - c0;
+        let newArr = new Array(newCol);
+        for (let i = 0; i < newRow; i++) {
+            newArr[i] = [];
+            for (let j = 0; j < newCol; j++) newArr[i][j] = this.arr[i + r0][j + c0];
+        }
+        return new Matrix(newRow, newCol, newArr.flat(1));
     }
-    get isOrtho() {
-        if (!this.isSquare) return false;
-        return this.isDiag && (this.det == 1 || this.det == -1);
+    static slice(m1,r0=0, c0=0, r1=this.rows-1, c1=this.cols-1) {
+        return m1.slice(r0, c0, r1, c1);
     }
-    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;
+    reshape(newRows, newCols) {
+        if(!(newRows * newCols === this.rows * this.cols)) throw Error('size not matched')
+        return new Matrix(newRows, newCols, this.arr.flat(1));
     }
     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++) {
+            for (let j = 0; j < this.arr.length; j++) 
                 transpose[i][j] = this.arr[j][i];
-            }
         }
         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;
-                }
-                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;
-        }
-        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;
-        }
-        return determinat(this.arr);
+        return matrix_det(this)
     }
     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));
+        return matrix_inverse(this)
+    }
+    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;
     }
     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;
+        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;
+        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;
+        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;
+    hstack(...matrices) {
+        const M=[this, ...matrices].reduce((a,b)=>hstack(a, b));
+        Object.assign(this, M);
+        this.#maintain();
+        return this;
+    }
+    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);
+    // }
+
+    // Checkers
+    get isSquare() {
+        return this.rows === this.cols;
+    }
+    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;
+            }
+        }
+        return true;
+    }
+    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;
+            }
+        }
+        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;
+    }
+    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];
                 }
-                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))
+                MM[i][j] = sum;
+            }
+        }
+        // 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;
             }
         }
+        return true;
     }
-    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;
+
+    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;
+            }
+        }
+        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;
+    }
+    
+    // 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) {
-        return Utils.map(this, Imin, Imax, Fmin, Fmax);
+        this.arr = map$1(this.arr, Imin, Imax, Fmin, Fmax);
+        return this;
     }
     lerp(min, max) {
-        return Utils.lerp(this, min, max);
+        this.arr = lerp(this.arr, min, max);
+        return this;
     }
     norm(min, max) {
-        return Utils.norm(this, min, max);
+        this.arr = norm(this.arr, min, max);
+        return this;
     }
     clamp(min, max) {
-        return Utils.clamp(this, min, max);
+        this.arr = clamp(this.arr, min, max);
+        return this;
     }
-    static map(matrix, Imin, Imax, Fmin, Fmax) {
-        return Utils.map(matrix, Imin, Imax, Fmin, Fmax);
+    static map(M, Imin, Imax, Fmin, Fmax) {
+        return M.clone().map(Imin, Imax, Fmin, Fmax)
     }
-    static lerp(matrix, min, max) {
-        return Utils.lerp(matrix, min, max);
+    static lerp(M, min, max) {
+        return M.clone().lerp(min, max)
     }
-    static norm(matrix, min, max) {
-        return Utils.norm(matrix, min, max);
+    static norm(M, min, max) {
+        return M.clone().norm(min, max)
     }
-    static clamp(m, min, max) {
-        return Utils.clamp(matrix, min, max);
+    static clamp(M, min, max) {
+        return M.clone().clamp(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);
+        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 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);
@@ -3518,136 +3767,77 @@ class Matrix{
     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);
-    }
-    #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));
+    // toBase(n) {
+    //     let newArr = this.arr.flat(1).toBase(n);
+    //     return new Matrix(this.rows, this.cols, newArr);
+    // }
+    
+    splice(r0,c0,deleteCount,...items){
+        
     }
-    hstack(...matrices) {
-        const M=[this,...matrices].reduce((a,b)=>a.#hstack(b));
-        Object.assign(this,M);
-        return this;
+    getRows(ri, rf = ri + 1) {
+        return this.slice(ri, 0, rf, this.cols);
     }
-    static hstack(matrix,...matrices) {
-        return matrix.clone.hstack(...matrices);
+    getCols(ci, cf = ci + 1) {
+        return this.slice(0, ci, this.rows, cf);
     }
-    #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));
+    static getRows(m, ri, rf = ri + 1) {
+        return m.slice(ri, 0, rf, m.cols);
     }
-    vstack(...matrices) {
-        const M=[this,...matrices].reduce((a,b)=>a.#vstack(b));
-        Object.assign(this,M);
-        return this;
+    static getCols(m, ci, cf = ci + 1) {
+        return m.slice(0, ci, m.rows, cf);
     }
-    static vstack(matrix,...matrices) {
-        return matrix.clone.vstack(...matrices);
-    }
-    hqueue(...matrices){
-        const M=[this,...matrices].reverse().reduce((a,b)=>a.#hstack(b));
-        Object.assign(this,M);
-        return this;
-    }
-    vqueue(...matrices){
-        const M=[this,...matrices].reverse().reduce((a,b)=>a.#vstack(b));
-        Object.assign(this,M);
-        return this;
-    }
-    static hqueue(matrix,...matrices) {
-        return matrix.clone.hqueue(...matrices);
-    }
-    static vqueue(matrix,...matrices) {
-        return matrix.clone.vqueue(...matrices);
-    }
-    slice(r0=0, c0=0, r1=this.rows-1, c1=this.cols-1) {
-        let newRow = r1 - r0,
-            newCol = c1 - c0;
-        let newArr = new Array(newCol);
-        for (let i = 0; i < newRow; i++) {
-            newArr[i] = [];
-            for (let j = 0; j < newCol; j++) newArr[i][j] = this.arr[i + r0][j + c0];
-        }
-        return new Matrix(newRow, newCol, newArr.flat(1));
-    }
-    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));
+    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]);
+        }
+        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]);
+            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));
     }
     static add(m1, ...m2) {
-        return m1.clone.add(...m2);
+        return m1.clone().add(...m2);
     }
     static sub(m1, ...m2) {
-        return m1.clone.sub(...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]);
+            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]);
         }
         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]);
+            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 new Matrix(this.rows, this.cols, this.arr.flat(1));
     }
     static div(m1, ...m2) {
-        return m1.clone.div(...m2);
+        return m1.clone().div(...m2);
     }
     static mul(m1, ...m2) {
-        return m1.clone.mul(...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]);
+            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 modulo(m1, ...m2) {
-        return m1.clone.modulo(...m2);
+        return m1.clone().modulo(...m2);
     }
     dot(matrix) {
         var res = [];
@@ -3656,9 +3846,9 @@ class Matrix{
             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] = add(
                         res[i][j],
-                        Utils.mul(this.arr[i][k],matrix.arr[k][j])
+                        mul(this.arr[i][k],matrix.arr[k][j])
                         );
                 }
             }
@@ -3669,52 +3859,52 @@ class Matrix{
         return matrix1.dot(matrix2);
     }
     pow(n) {
-        let a = this.clone,
-            p = this.clone;
+        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);
+        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() {
+    get hasComplex() {
         return this.arr.flat(Infinity).some((n) => n instanceof Complex);
     }
     get min() {
-        if (this.DoesItContainComplexNumbers) console.error("Complex numbers are not comparable");
+        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 max() {
-        if (this.DoesItContainComplexNumbers) console.error("Complex numbers are not comparable");
+        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 minRows() {
-        if (this.DoesItContainComplexNumbers) console.error("Complex numbers are not comparable");
+        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 maxRows() {
-        if (this.DoesItContainComplexNumbers) console.error("Complex numbers are not comparable");
+        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;
     }
     get minCols() {
-        if (this.DoesItContainComplexNumbers) console.error("Complex numbers are not comparable");
+        if (this.hasComplex) console.error("Complex numbers are not comparable");
         return this.T.minRows;
     }
     get maxCols() {
-        if (this.DoesItContainComplexNumbers) console.error("Complex numbers are not comparable");
+        if (this.hasComplex) console.error("Complex numbers are not comparable");
         return this.T.maxRows;
     }
     static fromVector(v) {
@@ -3729,53 +3919,15 @@ class Matrix{
         }
         return arr;
     }
-    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) + " ]");
-    }
-    get table() {
-        console.table(this.arr);
-    }
     get serialize() {
         return JSON.stringify(this);
     }
     static deserialize(data) {
-        if (typeof data == "string") {
-            data = JSON.parse(data);
-        }
+        if (typeof data == "string") data = JSON.parse(data);
         let matrix = new Matrix(data.rows, data.cols);
         matrix.arr = data.arr;
         return matrix;
     }
-
-    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;
-    }
     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})));
@@ -3807,68 +3959,7 @@ class Matrix{
     }
 }
 
-function InverseMatrixe(M) {
-    if (M.length !== M[0].length) {
-        return;
-    }
-    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;
-            }
-            C[i][j] = M[i][j];
-        }
-    }
-    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;
-            }
-        }
-        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 I;
-}
+
 /**
 * @returns {Matrix}
 */
@@ -3877,292 +3968,383 @@ 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));
-            }
-            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);
+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]);
             }
         }
-        else if(typeof(a)==="number"&&typeof(b)==="number"){
-            this.a = +a.toFixed(32);
-            this.b = +b.toFixed(32);
-        }
-    }
-    isComplex(){
-        return true
-    }
-    toString(){
-        let str = "";
-        if (this.a !== 0)
-          this.b >= 0
-            ? (str = `${this.a}+${this.b}*i`)
-            : (str = `${this.a}-${Math.abs(this.b)}*i`);
-        else
-          this.b >= 0
-            ? (str = `${this.b}*i`)
-            : (str = `-${Math.abs(this.b)}*i`);
-        return str;
-    }
-      
-    get clone() {
-        return new Complex(this.a, this.b);
-    }
-    get z(){
-        return hypot(this.a,this.b);    
-    }
-    get phi(){
-        return atan2(this.b , this.a);        
-    }
-    static Zero() {
-        return new Complex(0, 0);
-    }
-    get conj() {
-        return new Complex(this.a, -this.b);
-    }
-    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)));
-    }
-    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;
-    }
-    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;
-    }
-    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;
-    }
-    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;
-    }
-    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;
+        subSets.push(subSet);
     }
-    static fromExpo(z, phi) {
-        return new Complex(
-            +(z * cos$2(phi)).toFixed(13), 
-            +(z * sin$2(phi)).toFixed(13)
+    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;
     }
-    get expo() {
-        return [this.z, this.phi];
-    }
-    static add(c,...z) {
-        return c.clone.add(...z);
-    }
-    static sub(c,...z) {
-        return c.clone.sub(...z);
-    }
-    static mul(c,...z) {
-        return c.clone.mul(...z);
+};
+
+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))
     }
-    static div(c,...z) {
-        return c.clone.div(...z);
+    
+};
+
+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 pow(z,n){
-        return z.clone.pow(n);
+    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;
     }
-    static xpowZ(x){
-        return complex((x**this.a)*cos$2(this.b*ln(x)),(x**this.a)*sin$2(this.b*ln(x)));
+}
+
+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;
     }
-    sqrtn(n=2){
-        return complex(sqrtn(this.z,n)*cos$2(this.phi/n),sqrtn(this.z,n)*sin$2(this.phi/n));
+    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;
     }
-    get sqrt(){
-        return this.sqrtn(2);
+}
+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();
     }
-    get log(){
-        return complex(this.z,this.phi);
+    static int(a, b) {
+        return Math.floor(this.float(a, b));
     }
-    get cos(){
-        return complex(cos$2(this.a)*cosh$1(this.b),sin$2(this.a)*sinh$1(this.b))
+    static char(upperCase){
+        upperCase=upperCase??this.bool();
+        const Char=String.fromCharCode(this.int(97,120));
+        return upperCase?Char.toUpperCase():Char;
     }
-    get sin(){
-        return complex(sin$2(this.a)*cosh$1(this.b),cos$2(this.a)*sinh$1(this.b))
+    static bool(){
+        return [false,true][Math.floor(Math.random()*2)];
     }
-    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 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("");
     }
-}
-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)
+    static bin() {
+        return this.int(2);
     }
-    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);
+    static oct() {
+        return this.int(8);
     }
-    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 dec() {
+        return this.int(8);
     }
-    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;
-        }
+    static hex() {
+        return this.int(16);
     }
-};
-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);
+    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)];
     }
-    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 shuffleArr(arr){
+        return arr.sort(()=>0.5-Math.random())    
     }
-    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;
-        }
+    static floats(n, a, b) {
+        return new Array(n).fill(0).map(() => this.float(a, b));
     }
-};
-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);
+    static ints(n, a, b) {
+        return new Array(n).fill(0).map(() => this.int(a, b));
     }
-    // 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;
-        }
+    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());
     }
-};
-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
-    )
-};
+    // 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))
+    // }
+}
 
 const { PI, sqrt: sqrt$1, cos: cos$1, sin: sin$1, acos, pow } = Math;