ziko 0.54.5 → 0.56.0

package/dist/ziko.cjs

@@ -2,7 +2,7 @@
 /*
   Project: ziko.js
   Author: Zakaria Elalaoui
-  Date : Fri Dec 12 2025 14:53:26 GMT+0100 (UTC+01:00)
+  Date : Sat Dec 13 2025 00:46:54 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
@@ -127,7 +127,7 @@ class Complex{
     static Zero() {
         return new Complex(0, 0);
     }
-    static Twidlle(N, K){
+    static Twiddle(N, K){
         const phi = -2 * Math.PI * K / N;
         return new Complex(
             Math.cos(phi), 
@@ -730,64 +730,6 @@ const map$1 = (x, a, b, c, d) => apply_fun(
     v => lerp(norm(v, a, b), c, d)
 );
 
-
-// export const norm = (x, min, max) => {
-//     if(x.isComplex?.()) return new x.constructor(
-//         norm(x.a, min, max),
-//         norm(x.b, min, max)
-//     )
-//     if(x.isMatrix?.()) return new x.constructor(
-//         x.rows, 
-//         x.cols, 
-//         norm(x.arr.flat(1), min, max)
-//     );
-//     if(x instanceof Array) return mapfun(n => norm(n, min, max), ...x);
-//     return min !== max ? (x - min) / (max - min) : 0;
-// }
-
-
-// export const lerp = (x, min, max) => {
-//     if(x.isComplex?.()) return new x.constructor(
-//         lerp(x.a, min, max),
-//         lerp(x.b, min, max)
-//     )
-//     if(x.isMatrix?.()) return new x.constructor(
-//         x.rows, 
-//         x.cols, 
-//         lerp(x.arr.flat(1), min, max)
-//     );
-//     if(x instanceof Array) return mapfun(n => lerp(n, min, max), ...x);
-//     return (max - min) * x + min;
-// }
-
-// export const map = (x, a, b, c, d) => {
-//     if(x.isComplex?.()) return new x.constructor(
-//         map(x.a, a, b, c, d),
-//         map(x.b, a, b, c, d)
-//     )
-//     if(x.isMatrix?.()) return new x.constructor(
-//         x.rows, 
-//         x.cols, 
-//         map(x.arr.flat(1), a, b, c, d)
-//     );
-//     if(x instanceof Array) return mapfun(n => map(n, a, b, c, d), ...x);
-//     return lerp(norm(x, a, b), c, d);
-// }
-
-// export const clamp = (x, min, max) => {
-//     if(x.isComplex?.()) return new x.constructor(
-//         clamp(x.a, min, max),
-//         clamp(x.b, min, max)
-//     )
-//     if(x.isMatrix?.()) return new x.constructor(
-//         x.rows, 
-//         x.cols, 
-//         clamp(x.arr.flat(1), min, max)
-//     );
-//     if(x instanceof Array) return mapfun(n => clamp(n, min, max), ...x);
-//     return Math.min(Math.max(x, min), max)
-// }
-
 const hypot = (...x) => {
   const c0 = x.find(a => a.isComplex?.());
   if (c0) {
@@ -815,6 +757,18 @@ const atan2 = (y, x, rad = true) => {
 const min$1 = (...x) => Math.min(...x);
 const max$1 = (...x) => Math.max(...x);
 
+const binomial = (n, k) =>{
+  if(n !== Math.floor(n)) return TypeError('n must be an integer');
+  if(k !== Math.floor(k)) return TypeError('k must be an integer');
+  if (n < 0) return TypeError('n must be non-negative');
+  if (k < 0 || n < 0 || k > n) return 0;
+  if (k > n - k) k = n - k;
+    let c = 1, i;
+    for (i = 0; i < k; i++)
+        c = c * (n - i) / (i + 1);
+    return c;
+};
+
 const mean = (...x) => x.reduce((a, b) => a + b) / x.length;
 
 const variance = (...x) => {
@@ -860,6 +814,60 @@ const percentile = (X, p) => {
 
 const median = X => percentile(X, 50);
 
+const not = x => {
+    if(x.isComplex?.()) return new x.constructor(not(x.a), not(x.b))
+    if(x.isMatrix?.()) return new x.constructor(x.rows, x.cols, x.arr.flat(1).map(not))
+    return + !x;
+};
+const handle_complex_and_matrix = (x, operation) => {
+    if (x.every(n => n.isComplex?.())) {
+        const Re = x.map(n => n.a);
+        const Im = x.map(n => n.b);
+        return new x[0].constructor(
+            operation(...Re),
+            operation(...Im)
+        );
+    }
+
+    if (x.every(n => n.isMatrix?.())) {
+        if (!x.every(mat => mat.rows === x[0].rows && mat.cols === x[0].cols)) {
+            return TypeError('All matrices must have the same shape');
+        }
+
+        const { rows, cols } = x[0];
+        const Y = Array.from({ length: rows }, (_, i) =>
+            Array.from({ length: cols }, (_, j) =>
+                operation(...x.map(mat => mat.arr[i][j]))
+            )
+        );
+        return new x[0].constructor(Y);
+    }
+
+    return null;  // Return null if no Complex or Matrix found
+};
+
+const and = (...x) => {
+    const result = handle_complex_and_matrix(x, and);
+    if (result !== null) return result;
+    return x.reduce((n, m) => (n &= m), 1);
+};
+
+const or = (...x) => {
+    const result = handle_complex_and_matrix(x, or);
+    if (result !== null) return result;
+    return x.reduce((n, m) => (n |= m), 0);
+};
+
+const xor = (...x) => {
+    const result = handle_complex_and_matrix(x, xor);
+    if (result !== null) return result;
+    return x.reduce((n, m) => (n ^= m), 0);
+};
+
+const nand = (...x) => not(and(...x));
+const nor = (...x) => not(or(...x));
+const xnor = (...x) => not(xor(...x));
+
 const preload=(url)=>{
     const xhr = new XMLHttpRequest();
     xhr.open("GET", url, false); 
@@ -3940,20 +3948,230 @@ 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 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);
+class Random{
+    static int(a, b){
+        return Math.floor(this.float(a, b));
     }
-    return subSets;
-};
+    static float(a, b){
+        return b ? Math.random() * (b - a) + a : a * Math.random();
+    }
+    static bin
+    static oct 
+    static hex
+    static char
+    static bool 
+    static string 
+
+    static sample
+    static shuffle
+
+}
+// import { Utils } from "../utils/index.js";
+// // import{ Base } from "../--discret/index.js"
+
+// export const rand_float = (a, b) => b ? Math.random() * (b - a) + a : a * Math.random();
+// export const rand_int = (a, b) => Math.floor(rand_float(a, b));
+// export const rand_char = (upperCase) =>{
+//     const i = upperCase ? rand_int(65,90) : rand_int(97,120);
+//     return String.fromCharCode(i);
+// }
+// export const rand_bool = () => Boolean(rand_int(1));
+// export const rand_bin = () => rand_int(1);
+// export const rand_oct = () => rand_int(7);
+
+// export const rand_hex_color = () => `#${rand_int(0xffffff).toString(16).padStart(6, '0')}`
+
+// export const rand_hexa_color = () => {
+//     const r = rand_int(0xff).toString(16).padStart(2, '0');
+//     const g = rand_int(0xff).toString(16).padStart(2, '0');
+//     const b = rand_int(0xff).toString(16).padStart(2, '0');
+//     const a = rand_int(0xff).toString(16).padStart(2, '0');
+//     return `#${r}${g}${b}${a}`;
+// };
+
+// export const rand_rgb = () => {
+//     const r = rand_int(255);
+//     const g = rand_int(255);
+//     const b = rand_int(255);
+//     return `rgb(${r}, ${g}, ${b})`;
+// };
+
+// export const rand_rgba = () => {
+//     const r = rand_int(255);
+//     const g = rand_int(255);
+//     const b = rand_int(255);
+//     const a = +(Math.random()).toFixed(2);
+//     return `rgba(${r}, ${g}, ${b}, ${a})`;
+// };
+
+
+// // (upperCase) => upperCase ? : String.fromCharCode(rand_int(97,120))
+// 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(10);
+//     }
+//     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))
+//     // }
+// }
+// export{Random}
 
 const zeros=(n)=>new Array(n).fill(0);
 const ones=(n)=>new Array(n).fill(1);
@@ -4226,369 +4444,6 @@ const Utils={
     isApproximatlyEqual
 };
 
-// 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))
-    // }
-}
-
 const { PI, sqrt: sqrt$1, cos: cos$2, sin: sin$2, acos, pow } = Math;
 
 const linear = t => t;
@@ -5746,19 +5601,15 @@ if(globalThis?.document){
 }
 
 exports.App = App;
-exports.Base = Base;
 exports.Clock = Clock;
-exports.Combinaison = Combinaison;
 exports.Complex = Complex;
 exports.E = E;
 exports.EPSILON = EPSILON;
 exports.FileBasedRouting = FileBasedRouting;
 exports.Flex = Flex;
 exports.HTMLWrapper = HTMLWrapper;
-exports.Logic = Logic$1;
 exports.Matrix = Matrix;
 exports.PI = PI$1;
-exports.Permutation = Permutation;
 exports.Random = Random;
 exports.SPA = SPA;
 exports.SVGWrapper = SVGWrapper;
@@ -5786,13 +5637,13 @@ exports.ZikoUIFlex = ZikoUIFlex;
 exports.ZikoUISuspense = ZikoUISuspense;
 exports.ZikoUIText = ZikoUIText;
 exports.abs = abs;
-exports.accum = accum;
 exports.accum_prod = accum_prod;
 exports.accum_sum = accum_sum;
 exports.acos = acos$1;
 exports.acosh = acosh;
 exports.acot = acot;
 exports.add = add;
+exports.and = and;
 exports.animation = animation;
 exports.apply_fun = apply_fun;
 exports.arange = arange;
@@ -5815,12 +5666,12 @@ exports.bind_swipe_event = bind_swipe_event;
 exports.bind_touch_event = bind_touch_event;
 exports.bind_view_event = bind_view_event;
 exports.bind_wheel_event = bind_wheel_event;
+exports.binomial = binomial;
 exports.cartesianProduct = cartesianProduct;
 exports.cbrt = cbrt;
 exports.ceil = ceil;
 exports.clamp = clamp;
 exports.clock = clock;
-exports.combinaison = combinaison;
 exports.complex = complex;
 exports.cos = cos$3;
 exports.cosh = cosh$2;
@@ -5894,11 +5745,14 @@ exports.median = median;
 exports.min = min$1;
 exports.modulo = modulo;
 exports.mul = mul;
+exports.nand = nand;
+exports.nor = nor;
 exports.norm = norm;
 exports.nthr = nthr;
 exports.nums = nums;
 exports.obj2str = obj2str;
 exports.ones = ones;
+exports.or = or;
 exports.out_back = out_back;
 exports.out_bounce = out_bounce;
 exports.out_circ = out_circ;
@@ -5912,7 +5766,6 @@ exports.out_sin = out_sin;
 exports.percentile = percentile;
 exports.pgcd = pgcd;
 exports.pow = pow$1;
-exports.powerSet = powerSet;
 exports.ppcm = ppcm;
 exports.preload = preload;
 exports.prod = prod;
@@ -5929,7 +5782,6 @@ exports.std = std;
 exports.step = step;
 exports.step_fps = step_fps;
 exports.sub = sub;
-exports.subSet = subSet;
 exports.sum = sum;
 exports.svg2ascii = svg2ascii;
 exports.svg2img = svg2img;
@@ -5961,4 +5813,6 @@ exports.variance = variance;
 exports.wait = wait;
 exports.waitForUIElm = waitForUIElm;
 exports.waitForUIElmSync = waitForUIElmSync;
+exports.xnor = xnor;
+exports.xor = xor;
 exports.zeros = zeros;