ziko 0.51.0 → 0.52.0

package/dist/ziko.js

@@ -2,7 +2,7 @@
 /*
   Project: ziko.js
   Author: Zakaria Elalaoui
-  Date : Wed Dec 03 2025 10:58:16 GMT+0100 (UTC+01:00)
+  Date : Fri Dec 05 2025 17:08: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
@@ -17,87 +17,318 @@
     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;
+    //     }
+    // })
+
+    const is_primitive = value => typeof value !== 'object' && typeof value !== 'function' || value === null;
 
-    // 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(is_primitive(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.isMatrix?.()) return new x.constructor(x.rows, x.cols, mapfun$1(x.arr.flat(1)))
+            else if(x instanceof Object){
+                return Object.fromEntries(
+                    Object.entries(x).map(
+                        n=>n=[n[0],mapfun$1(fun,n[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)
+        });
+       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;
             }
-            else if(x instanceof Object){
-                return Object.fromEntries(Object.entries(x).map(n=>n=[n[0],mapfun$1(fun,n[1])]))
+        }
+    };
+    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;
             }
-        });
-       return Y.length==1?Y[0]:Y; 
+        }
+    };
+    const e=(...x) => mapfun$1(Math.exp,...x);
+    const ln=(...x) => mapfun$1(Math.log,...x);
+    const cos$2=(...x) => mapfun$1(Fixed.cos,...x);
+    const sin$2=(...x) => mapfun$1(Fixed.sin,...x);
+    const tan=(...x) => mapfun$1(Fixed.tan,...x);
+    const sec=(...x) => mapfun$1(Fixed.sec,...x);
+    const sinc=(...x) => mapfun$1(Fixed.sinc,...x);
+    const csc=(...x) => mapfun$1(Fixed.csc,...x);
+    const cot=(...x) => mapfun$1(Fixed.cot,...x);
+    const acos$1=(...x) => mapfun$1(Fixed.acos,...x);
+    const asin=(...x) => mapfun$1(Fixed.asin,...x);
+    const atan=(...x) => mapfun$1(Fixed.atan,...x);
+    const acot=(...x) => mapfun$1(Fixed.acot,...x);
+    const cosh$1=(...x) => mapfun$1(Fixed.cosh,...x);
+    const sinh$1=(...x) => mapfun$1(Fixed.sinh,...x);
+    const tanh=(...x) => mapfun$1(Fixed.tanh,...x);
+    const coth=(...x) => mapfun$1(Fixed.coth,...x);
+    const acosh=(...x) => mapfun$1(Fixed.acosh,...x);
+    const asinh=(...x) => mapfun$1(Fixed.asinh,...x);
+    const atanh=(...x) => mapfun$1(Fixed.atanh,...x);
+    const ceil=(...x) => mapfun$1(Math.ceil,...x);
+    const floor=(...x) => mapfun$1(Math.floor,...x);
+    const round=(...x) => mapfun$1(Math.round,...x);
+    const atan2=(x,y,rad=true)=>{
+        if(typeof x === "number"){
+            if(typeof y === "number")return rad?Math.atan2(x,y):Math.atan2(x,y)*180/Math.PI;
+            else return mapfun$1(a=>atan2(x,a,rad),...y);
+        }
+        // else if(x.isComplex?.()){
+        //     if(typeof n === "number")return x.constructor.fromExpo(x.z**n,x.phi*n);
+        //     else return mapfun(a=>pow(x,a),...n);
+        // }
+        else if(x instanceof Array){
+            if(typeof y === "number") return mapfun$1(a=>atan2(a,y,rad),...x);
+            else if(y instanceof Array){
+                const Y=[];
+                for(let i=0;i<x.length;i++){
+                    Y.push(mapfun$1(a=>pow$1(x[i],a),...y));
+                }
+                return Y;
+            }
+        }
+    };
+    const fact=(...x)=>mapfun$1(n=> {
+            let i,
+            y = 1;
+            if (n == 0) y = 1;
+            else if (n > 0) for (i = 1; i <= n; i++) y *= i;
+            else y = NaN;
+            return y;
+        },...x);
+    const sign=(...x)=>mapfun$1(Math.sign,...x);
+
+    const sig=(...x)=>mapfun$1(n=>1/(1+e(-n)),...x);
+
+    const hypot=(...x)=>{
+        if(x.every(n=>typeof n === "number"))return Math.hypot(...x);
+        if(x.every(n=>n instanceof Array))return mapfun$1(
+            Math.hypot,
+            ...x
+        )
     };
 
     const _add=(a,b)=>{
         if(typeof(a)==="number"){
             if (typeof b == "number") return a + b;
-            else if (b instanceof Complex)return complex(a + b.a, b.b);
-            else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).add(b);
+            else if (b.isComplex?.())return new b.constructor(a + b.a, b.b);
+            else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).add(b);
             else if (b instanceof Array)return b.map(n=>add(n,a));                 
         }
-        else if(a instanceof Complex||a instanceof Matrix){
+        else if(a.isComplex?.()||a.isMatrix?.()){
             if(b instanceof Array)return b.map(n=>a.clone.add(n));
             return a.clone.add(b);
         }
@@ -113,11 +344,11 @@
     const _sub=(a,b)=>{
         if(typeof(a)==="number"){
             if (typeof b == "number") return a - b;
-            else if (b instanceof Complex)return complex(a - b.a, -b.b);
-            else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).sub(b);
+            else if (b.isComplex?.())return new b.constructor(a - b.a, -b.b);
+            else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).sub(b);
             else if (b instanceof Array)return b.map(n=>sub(n,a));                 
         }
-        else if(a instanceof Complex||a instanceof Matrix){
+        else if(a.isComplex?.()||a.isMatrix?.()){
             if(b instanceof Array)return b.map(n=>a.clone.sub(n));
             return a.clone.sub(b);
         }
@@ -135,11 +366,11 @@
     const _mul=(a,b)=>{
         if(typeof(a)==="number"){
         if (typeof b == "number") return a * b;
-            else if (b instanceof Complex)return complex(a * b.a,a * b.b);
-            else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).mul(b);
+            else if (b.isComplex?.())return new b.constructor(a * b.a,a * b.b);
+            else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).mul(b);
             else if (b instanceof Array)return b.map(n=>mul(a,n)); 
         }
-        else if(a instanceof Complex||a instanceof Matrix){
+        else if(a.isComplex?.()||a.isMatrix?.()){
             if(b instanceof Array)return b.map(n=>a.clone.mul(n));
             return a.clone.mul(b);
         }
@@ -157,11 +388,11 @@
     const _div=(a,b)=>{
         if(typeof(a)==="number"){
         if (typeof b == "number") return a / b;
-            else if (b instanceof Complex)return complex(a / b.a,a / b.b);
-            else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).div(b);
+            else if (b.isComplex?.())return new b.constructor(a / b.a,a / b.b);
+            else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).div(b);
             else if (b instanceof Array)return b.map(n=>div(a,n));
         }
-        else if(a instanceof Complex||a instanceof Matrix){
+        else if(a.isComplex?.()||a.isMatrix?.()){
             if(b instanceof Array)return b.map(n=>a.clone.div(n));
             return a.clone.div(b);
         }
@@ -179,11 +410,11 @@
     const _modulo=(a,b)=>{
         if(typeof(a)==="number"){
             if (typeof b == "number") return a % b;
-                else if (b instanceof Complex)return complex(a % b.a,a % b.b);
-                else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).modulo(b);
+                else if (b.isComplex?.())return new b.constructor(a % b.a,a % b.b);
+                else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).modulo(b);
                 else if (b instanceof Array)return b.map(n=>div(a,n));
             }
-            else if(a instanceof Complex||a instanceof Matrix){
+            else if(a.isComplex?.()||a.isMatrix?.()){
                 if(b instanceof Array)return b.map(n=>a.clone.div(n));
                 return a.clone.div(b);
             }
@@ -225,8 +456,8 @@
     const nums=(num,n)=>new Array(n).fill(num);
     const norm=(value, min, max)=>{
         if (typeof value === "number") return min !== max ? (value - min) / (max - min) : 0;
-        else if (value instanceof Matrix) return new Matrix(value.rows, value.cols, norm(value.arr.flat(1), min, max));
-        else if (value instanceof Complex) return new Complex(norm(value.a, min, max), norm(value.b, min, max));
+        else if (value.isMatrix?.()) return new value.constructor(value.rows, value.cols, norm(value.arr.flat(1), min, max));
+        else if (value.isComplex?.()) return new value.constructor(norm(value.a, min, max), norm(value.b, min, max));
         else if (value instanceof Array) {
             if (value.every((n) => typeof (n === "number"))) {
                 return value.map((n) => norm(n, min, max));
@@ -240,8 +471,8 @@
     };
     const lerp=(value, min, max)=>{
         if (typeof value === "number") return (max - min) * value + min;
-        else if (value instanceof Matrix) return new Matrix(value.rows, value.cols, lerp(value.arr.flat(1), min, max));
-        else if (value instanceof Complex) return new Complex(lerp(value.a, min, max), lerp(value.b, min, max));
+        else if (value.isMatrix?.()) return new value.constructor(value.rows, value.cols, lerp(value.arr.flat(1), min, max));
+        else if (value.isComplex?.()) return new value.constructor(lerp(value.a, min, max), lerp(value.b, min, max));
         else if (value instanceof Array) {
             if (value.every((n) => typeof (n === "number"))) {
                 return value.map((n) => lerp(n, min, max));
@@ -253,17 +484,17 @@
             }
         }
     };
-    const map$1=(value, a, b, c, d)=>{
-        if (typeof value === "number") return lerp(norm(value, a, b), c, d);
-        else if (value instanceof Matrix) return new Matrix(value.rows, value.cols, map$1(value.arr.flat(1), a, b, c, d));
-        else if (value instanceof Complex) return new Complex(map$1(value.a, b, c, d), map$1(value.b, a, b, c, d));
-        else if (value instanceof Array) {
-            if (value.every((n) => typeof (n === "number"))) {
-                return value.map((n) => map$1(n, a, b, c, d));
+    const map$1=(x, a, b, c, d)=>{
+        if (typeof x === "number") return lerp(norm(x, a, b), c, d);
+        else if (x.isMatrix?.()) return new x.constructor(x.rows, x.cols, map$1(x.arr.flat(1), a, b, c, d));
+        else if (x.isComplex?.()) return new x.constructor(map$1(x.a, b, c, d), map$1(x.b, a, b, c, d));
+        else if (x instanceof Array) {
+            if (x.every((n) => typeof (n === "number"))) {
+                return x.map((n) => map$1(n, a, b, c, d));
             } else {
-                let y = new Array(value.length);
-                for (let i = 0; i < value.length; i++) {
-                    y[i] = map$1(value[i], a, b, c, d);
+                let y = new Array(x.length);
+                for (let i = 0; i < x.length; i++) {
+                    y[i] = map$1(x[i], a, b, c, d);
                 }
             }
         }
@@ -271,8 +502,8 @@
     const clamp=(x, a , b)=>{
         const [min_value,max_value]=[min(a,b),max(a,b)];
         if (typeof x === "number") return min(max(x, min_value), max_value);
-        else if (x instanceof Matrix) return new Matrix(x.rows, x.cols, clamp(x.arr.flat(1), min_value, max_value));
-        else if (x instanceof Complex) return new Complex(clamp(x.a, min_value, max_value), clamp(x.b, min_value, max_value));
+        else if (x.isMatrix?.()) return new x.constructor(x.rows, x.cols, clamp(x.arr.flat(1), min_value, max_value));
+        else if (x.isComplex?.()) return new x.constructor(clamp(x.a, min_value, max_value), clamp(x.b, min_value, max_value));
         else if (x instanceof Array) {
             if (x.every((n) => typeof (n === "number"))) {
                 return x.map((n) => clamp(n, min_value, max_value));
@@ -307,14 +538,14 @@
             return Y
         }
 
-        if([a,b].some(n=>n instanceof Complex)){
-            const z1=complex(a);
-            const z2=complex(b);
+        if([a,b].some(n=>n.isComplex?.())){
+            const z1 = new n.constructor(a);
+            const z2 = new n.constructor(b);
             n=n||Math.abs(z1.a-z2.a)+1;
             const X=linspace(z1.a,z2.a,n,endpoint);
             const Y=linspace(z1.b,z2.b,n,endpoint);
             let Z=new Array(n).fill(null);
-            Z=Z.map((n,i)=>complex(X[i],Y[i]));
+            Z=Z.map((n,i)=> new n.constructor(X[i],Y[i]));
             return Z;
         }
     };
@@ -334,9 +565,9 @@
             return a<b?Y:Y.reverse()
         }
 
-        if([a,b].some(n=>n instanceof Complex)){
-            const z1=complex(a);
-            const z2=complex(b);
+        if([a,b].some(n=>n.isComplex?.())){
+            const z1 = new n.constructor(a);
+            const z2 = new n.constructor(b);
             n=n||Math.abs(z1.a-z2.a)+1;
             let base;
             endpoint ? base = sqrtn(z2.div(z1),n-1) : base = sqrtn(z2.div(z1),n) ;
@@ -363,109 +594,18 @@
      */
     const rad2deg = (...rad) => mapfun(x => x / Math.PI * 180, ...rad);
 
-    // Mixed calcul
-    const sum=(...x)=>{
-        if(x.every(n=>typeof n==="number")){
-            let s = x[0];
-            for (let i = 1; i < x.length; i++) s += x[i];
-            return s;
-        }
-        const Y=[];
-        for(let i=0;i<x.length;i++){
-            if(x[i] instanceof Array)Y.push(sum(...x[i]));
-            else if(x[i] instanceof Object){
-                Y.push(sum(...Object.values(x[i])));
-            }
-        }
-        return Y.length===1?Y[0]:Y;
-    };
-    const prod=(...x)=>{
-        if(x.every(n=>typeof n==="number")){
-            let p = x[0];
-            for (let i = 1; i < x.length; i++) p *= x[i];
-            return p;
-        }
-        const Y=[];
-        for(let i=0;i<x.length;i++){
-            if(x[i] instanceof Array)Y.push(prod(...x[i]));
-            else if(x[i] instanceof Object){
-                Y.push(prod(...Object.values(x[i])));
-            }
-        }
-        return Y.length===1?Y[0]:Y;
-    };
-    const min=(...num)=>{
-        if(num.every(n=>typeof n==="number"))return Math.min(...num);
-        const Y=[];
-        for(let i=0;i<num.length;i++){
-            if(num[i] instanceof Array)Y.push(min(...num[i]));
-            else if(num[i] instanceof Object){
-                Y.push(
-                        Object.fromEntries(
-                            [Object.entries(num[i]).sort((a,b)=>a[1]-b[1])[0]]
-                        )
-                    );
-            }
-        }
-        return Y.length===1?Y[0]:Y;
-    };
-    const max=(...num)=>{
-        if(num.every(n=>typeof n==="number"))return Math.max(...num);
-        const Y=[];
-        for(let i=0;i<num.length;i++){
-            if(num[i] instanceof Array)Y.push(min(...num[i]));
-            else if(num[i] instanceof Object){
-                Y.push(
-                        Object.fromEntries(
-                            [Object.entries(num[i]).sort((a,b)=>b[1]-a[1])[0]]
-                        )
-                    );
-            }
-        }
-        return Y.length===1?Y[0]:Y;
-    };
-    const accum=(...num)=>{
-        if(num.every(n=>typeof n==="number")){
-            let acc = num.reduce((x, y) => [...x, x[x.length - 1] + y], [0]);
-            acc.shift();
-            return acc;
-        }
-        const Y=[];
-        for(let i=0;i<num.length;i++){
-            if(num[i] instanceof Array)Y.push(accum(...num[i]));
-            else if(num[i] instanceof Object){
-                Y.push(null
-                        // Object.fromEntries(
-                        //     [Object.entries(num[i]).sort((a,b)=>b[1]-a[1])[0]]
-                        // )
-                    );
-            }
-        }
-        return Y.length===1?Y[0]:Y;
-    };
-
-    //moy
-    //med
-    //variance
-    //std
-    //mode
-    //acccum
-    //min2max
-    //max2min
-    //percentile
-
-    /** @module Math */
-    /**
-     * Checks if a value is within the specified range.
-     * @function
-     * @param {number} x - The value to check.
-     * @param {number} a - The start of the range.
-     * @param {number} b - The end of the range.
-     * @returns {boolean} Returns true if the value is within the range [a, b], otherwise false.
-     */
-    const inRange = (x, a, b) => {
-        const [min, max] = [Math.min(a, b), Math.max(a, b)];
-        return x >= min && x <= max;
+    /** @module Math */
+    /**
+     * Checks if a value is within the specified range.
+     * @function
+     * @param {number} x - The value to check.
+     * @param {number} a - The start of the range.
+     * @param {number} b - The end of the range.
+     * @returns {boolean} Returns true if the value is within the range [a, b], otherwise false.
+     */
+    const inRange = (x, a, b) => {
+        const [min, max] = [Math.min(a, b), Math.max(a, b)];
+        return x >= min && x <= max;
     };
 
     /**
@@ -558,385 +698,185 @@
         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).toFixed(15);
+                    this.b = +a.z*sin$2(a.phi).toFixed(15);
                 }
             }
-            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));
-        }
-        static complexOct() {
-            return new Complex(...this.octs(2));
-        }
-        static complexDec() {
-            return new Complex(...this.decs(10));
-        }
-        static complexHex() {
-            return new Complex(...this.octs(2));
-        }
-        static complexes(n, a = 0, b = 1) {
-            return new Array(n).fill(0).map(() => this.complex(a, b));
-        }
-        static complexesInt(n, a = 0, b = 1) {
-            return new Array(n).fill(0).map(() => this.complexInt(a, b));
-        }
-        static complexesBin(n) {
-            return new Array(n).fill(0).map(() => this.complexBin());
-        }
-        static complexesOct(n) {
-            return new Array(n).fill(0).map(() => this.complexOct());
-        }
-        static complexesDec(n) {
-            return new Array(n).fill(0).map(() => this.complexDec());
-        }
-        static complexesHex(n) {
-            return new Array(n).fill(0).map(() => this.complexHex());
+        get expo() {
+            return [this.z, this.phi];
         }
-        static matrix(r,c,min,max){
-            return matrix(r,c,this.floats(r*c,min,max))
+        static add(c,...z) {
+            return c.clone.add(...z);
         }
-        static matrixInt(r,c,min,max){
-            return matrix(r,c,this.ints(r*c,min,max))
+        static sub(c,...z) {
+            return c.clone.sub(...z);
         }
-        static matrixBin(r,c){
-            return matrix(r,c,this.bins(r*c))
+        static mul(c,...z) {
+            return c.clone.mul(...z);
         }
-        static matrixOct(r,c){
-            return matrix(r,c,this.octs(r*c))
+        static div(c,...z) {
+            return c.clone.div(...z);
         }
-        static matrixDec(r,c){
-            return matrix(r,c,this.decs(r*c))
+        static pow(z,n){
+            return z.clone.pow(n);
         }
-        static matrixHex(r,c){
-            return matrix(r,c,this.hex(r*c))
+        static xpowZ(x){
+            return complex((x**this.a)*cos$2(this.b*ln(x)),(x**this.a)*sin$2(this.b*ln(x)));
         }
-        static matrixColor(r,c){
-            return matrix(r,c,this.colors(r*c))
+        sqrtn(n=2){
+            return complex(sqrtn(this.z,n)*cos$2(this.phi/n),sqrtn(this.z,n)*sin$2(this.phi/n));
         }
-        static matrixComplex(r,c,a,b){
-            return matrix(r,c,this.complexes(r*c,a,b))
+        get sqrt(){
+            return this.sqrtn(2);
         }
-        static matrixComplexInt(r,c,a,b){
-            return matrix(r,c,this.complexesInt(r*c,a,b))
+        get log(){
+            return complex(this.z,this.phi);
         }
-        static matrixComplexBin(r,c){
-            return matrix(r,c,this.complexesBin(r*c))
+        get cos(){
+            return complex(cos$2(this.a)*cosh$1(this.b),sin$2(this.a)*sinh$1(this.b))
         }
-        static matrixComplexOct(r,c){
-            return matrix(r,c,this.complexesBin(r*c))
+        get sin(){
+            return complex(sin$2(this.a)*cosh$1(this.b),cos$2(this.a)*sinh$1(this.b))
         }
-        static matrixComplexDec(r,c){
-            return matrix(r,c,this.complexesBin(r*c))
+        get tan(){
+            const de=cos$2(this.a*2)+cosh$1(this.b*2);
+            return complex(sin$2(2*this.a)/de,sinh$1(2*this.b)/de);
         }
-        static matrixComplexHex(r,c){
-            return matrix(r,c,this.complexesBin(r*c))
+    }
+    const complex=(a,b)=>{
+        if((a instanceof Array||ArrayBuffer.isView(a)) && (b instanceof Array||ArrayBuffer.isView(a)))return a.map((n,i)=>complex(a[i],b[i]));
+        if(a.isMatrix?.() && b.isMatrix?.()){
+            if((a.shape[0]!==b.shape[0])||(a.shape[1]!==b.shape[1]))return Error(0)
+            const arr=a.arr.map((n,i)=>complex(a.arr[i],b.arr[i]));
+            return new a.constructor(a.rows,a.cols,...arr)
         }
-    }
+        return new Complex(a,b)
+    };
 
     const preload=(url)=>{
         const xhr = new XMLHttpRequest();
@@ -1090,8 +1030,37 @@
 
     // globalThis.node = (node) => new UINode(node);
 
-    class UIStore extends Array {
-        constructor(...args) {
+    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); 
         }
         clear(){
@@ -1123,202 +1092,6 @@
     // 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,
@@ -1373,7 +1146,7 @@
             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) => {
@@ -1572,36 +1345,203 @@
         }
     }
 
-    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,
-                isStateGetter: () => true,
-                _subscribe: (fn) => current.subscribers.add(fn),
-            };
-        }
-
-        function setValue(newValue) {
-            if (current.paused) return;
-            if (typeof newValue === "function") {
-                newValue = newValue(current.value);
-            }
-            if (newValue !== current.value) {
-                current.value = newValue;
-                current.subscribers.forEach(fn => fn(current.value));
-                __Ziko__.__State__.update(index, newValue);
+    __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,
+                isStateGetter: () => true,
+                _subscribe: (fn) => current.subscribers.add(fn),
+            };
+        }
+
+        function setValue(newValue) {
+            if (current.paused) return;
+            if (typeof newValue === "function") {
+                newValue = newValue(current.value);
+            }
+            if (newValue !== current.value) {
+                current.value = newValue;
+                current.subscribers.forEach(fn => fn(current.value));
+                __Ziko__.__State__.update(index, newValue);
             }
         }
 
@@ -2568,6 +2508,14 @@
         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();
@@ -3314,6 +3262,119 @@
         }, Array.isArray(obj) ? [] : {});
     }
 
+    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];
+            }
+        }
+        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 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;
+        }
+        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){
@@ -3322,9 +3383,7 @@
                 this.cols=rows.cols;
             }
             else {
-            let arr = [],
-                i,
-                j;
+            let arr = [], i, j;
             if (arguments[0] instanceof Array) {
                 rows = arguments[0].length;
                 cols = arguments[0][0].length;
@@ -3344,29 +3403,25 @@
             this.arr = arr;   
         }
         this.#maintain();
-            //Object.seal(this);
         }
-        toString(){
-            return arr2str(this.arr);
+        isMatrix(){
+            return true
         }
-        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];
+        clone() {
+            return new Matrix(this.rows, this.cols, this.arr.flat(1));
         }
-        reshape(newRows, newCols) {
-            let check = newRows * newCols === this.rows * this.cols;
-            if (check) return new Matrix(newRows, newCols, this.arr.flat(1));
-            else console.error("Err");
-        }
-        static eye(size) {
-            let result = new Matrix(size, size);
-            for (let i = 0; i < size; i++) for (let j = 0; j < size; j++) i === j ? (result.arr[i][j] = 1) : (result.arr[i][j] = 0);
-            return result;
+        [Symbol.iterator]() {
+          return this.arr[Symbol.iterator]();
         }
-        get clone() {
-            return new Matrix(this.rows, this.cols, this.arr.flat(1));
+        #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 size() {
             return this.rows * this.cols;
@@ -3374,214 +3429,287 @@
         get shape() {
             return [this.rows, this.cols];
         }
-        get reel() {
-            return new Matrix(this.cols, this.rows, this.arr.flat(1).reel);
-        }
-        get imag() {
-            return new Matrix(this.cols, this.rows, this.arr.flat(1).imag);
-        }
-        [Symbol.iterator]() {
-          return this.arr[Symbol.iterator]();
-        }
-        #maintain() {
-        for (let i = 0; i < this.arr.length; i++) {
-            Object.defineProperty(this, i, {
-            value: this.arr[i],
-            writable: true,
-            configurable: true,
-            enumerable: false 
-            });
-            }
+        toString(){
+            return arr2str(this.arr);
         }
-        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];
+        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];
         }
-        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;
+        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 (this.arr[row][col] = value);
-        }
-        get isSquare() {
-            return this.rows / this.cols === 1;
-        }
-        get isSym() {
-            if (!this.isSquare) return false;
-            const T = this.T;
-            const M = this.clone;
-            return Matrix.sub(M, T).max == 0 && Matrix.sub(M, T).min == 0;
-        }
-        get isAntiSym() {
-            if (!this.isSquare) return false;
-            const T = this.T;
-            const M = this.clone;
-            return Matrix.add(M, T).max == 0 && Matrix.add(M, T).min == 0;
-        }
-        get isDiag() {
-            if (!this.isSquare) return false;
-            const T = this.T;
-            const M = this.clone;
-            const MT = Matrix.mul(M, T);
-            const TM = Matrix.dot(T, M);
-            return Matrix.sub(MT, TM).max == 0 && Matrix.sub(MT, TM).min == 0;
+            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);
@@ -3621,72 +3749,11 @@
         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));
-        }
-        hstack(...matrices) {
-            const M=[this,...matrices].reduce((a,b)=>a.#hstack(b));
-            Object.assign(this,M);
-            return this;
-        }
-        static hstack(matrix,...matrices) {
-            return matrix.clone.hstack(...matrices);
-        }
-        #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));
-        }
-        vstack(...matrices) {
-            const M=[this,...matrices].reduce((a,b)=>a.#vstack(b));
-            Object.assign(this,M);
-            return this;
-        }
-        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);
-        }
+        // toBase(n) {
+        //     let newArr = this.arr.flat(1).toBase(n);
+        //     return new Matrix(this.rows, this.cols, newArr);
+        // }
+        
         splice(r0,c0,deleteCount,...items){
             
         }
@@ -3705,52 +3772,54 @@
         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]);
+                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 = [];
@@ -3759,9 +3828,9 @@
                 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])
                             );
                     }
                 }
@@ -3772,52 +3841,52 @@
             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) {
@@ -3832,53 +3901,15 @@
             }
             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})));
@@ -3910,68 +3941,7 @@
         }
     }
 
-    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}
     */
@@ -3980,292 +3950,383 @@
     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)));
+            subSets.push(subSet);
         }
-        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;
+        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;
         }
-        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;
+    };
+
+    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))
         }
-        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;
+        
+    };
+
+    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;
         }
-        div(...z) {
-            for (let i = 0; i < z.length; i++) {
-                if (typeof z[i] === "number") z[i] = new Complex(z[i], 0);
+        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));
+                }
             }
-            let Z=+(this.z/prod(...z.map(n=>n.z))).toFixed(15);
-            let phi=+(this.phi-sum(...z.map(n=>n.phi))).toFixed(15);
-            this.a=+(Z*cos$2(phi).toFixed(15)).toFixed(15);
-            this.b=+(Z*sin$2(phi).toFixed(15)).toFixed(15);
-            return this;
+            return permutations;
         }
-        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);
+    }
+
+    class Combinaison {
+        static withDiscount(comboOptions, comboLength) {
+            if (comboLength === 1) {
+                return comboOptions.map((comboOption) => [comboOption]);
             }
-            return this;
+            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 fromExpo(z, phi) {
-            return new Complex(
-                +(z * cos$2(phi)).toFixed(13), 
-                +(z * sin$2(phi)).toFixed(13)
-                );
+        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 expo() {
-            return [this.z, this.phi];
+    }
+    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 add(c,...z) {
-            return c.clone.add(...z);
+        static int(a, b) {
+            return Math.floor(this.float(a, b));
         }
-        static sub(c,...z) {
-            return c.clone.sub(...z);
+        static char(upperCase){
+            upperCase=upperCase??this.bool();
+            const Char=String.fromCharCode(this.int(97,120));
+            return upperCase?Char.toUpperCase():Char;
         }
-        static mul(c,...z) {
-            return c.clone.mul(...z);
+        static bool(){
+            return [false,true][Math.floor(Math.random()*2)];
         }
-        static div(c,...z) {
-            return c.clone.div(...z);
+        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 pow(z,n){
-            return z.clone.pow(n);
+        static bin() {
+            return this.int(2);
         }
-        static xpowZ(x){
-            return complex((x**this.a)*cos$2(this.b*ln(x)),(x**this.a)*sin$2(this.b*ln(x)));
+        static oct() {
+            return this.int(8);
         }
-        sqrtn(n=2){
-            return complex(sqrtn(this.z,n)*cos$2(this.phi/n),sqrtn(this.z,n)*sin$2(this.phi/n));
+        static dec() {
+            return this.int(8);
         }
-        get sqrt(){
-            return this.sqrtn(2);
+        static hex() {
+            return this.int(16);
         }
-        get log(){
-            return complex(this.z,this.phi);
+        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)];
         }
-        get cos(){
-            return complex(cos$2(this.a)*cosh$1(this.b),sin$2(this.a)*sinh$1(this.b))
+        static shuffleArr(arr){
+            return arr.sort(()=>0.5-Math.random())    
         }
-        get sin(){
-            return complex(sin$2(this.a)*cosh$1(this.b),cos$2(this.a)*sinh$1(this.b))
+        static floats(n, a, b) {
+            return new Array(n).fill(0).map(() => this.float(a, b));
         }
-        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 ints(n, a, b) {
+            return new Array(n).fill(0).map(() => this.int(a, b));
         }
-    }
-    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 bools(n){
+            return  new Array(n).fill(0).map(() => this.bool());
         }
-        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 bins(n) {
+            return new Array(n).fill(0).map(() => this.int(2));
         }
-        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 octs(n) {
+            return new Array(n).fill(0).map(() => 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 decs(n) {
+            return new Array(n).fill(0).map(() => this.int(10));
         }
-    };
-    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 hexs(n) {
+            return new Array(n).fill(0).map(() => this.int(16));
         }
-        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 choices(n, choices, p) {
+            return new Array(n).fill(0).map(() => this.choice(choices, p));
         }
-        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 perm(...arr) {
+            // permutation
+            return arr.permS[this.int(arr.length)];
         }
-    };
-    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 color() {
+            return "#" + Base.dec2hex(this.float(16777216)).padStart(6,0);
         }
-        // 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 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;