ziko 0.51.0 → 0.51.1

package/dist/ziko.mjs

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