ziko 0.54.4 → 0.55.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ziko",
-  "version": "0.54.4",
+  "version": "0.55.0",
   "description": "A versatile JavaScript library offering a rich set of Hyperscript Based UI components, advanced mathematical utilities, interactivity ,animations, client side routing and more ...",
   "keywords": [
     "front-end",

package/src/math/--discret/index.js

@@ -0,0 +1,12 @@
+// import { powerSet , subSet } from "./Set/index.js";
+// import { Base } from "./Conversion/index.js";
+// import {
+//     Permutation,
+// } from "./Permutation/index.js"
+// import {
+//     Combinaison,
+//     combinaison,
+// } from "./Combinaison/index.js"
+
+// export{
+//     Base,Permutation,Combinaison,combinaison,powerSet,subSet}

package/src/math/complex/index.js

@@ -1,5 +1,4 @@
-// import {sum,prod,deg2rad} from "../utils/index.js";
-// Should avoid CD
+import { Random } from "../random/index.js";
 class Complex{
     constructor(a = 0, b = 0) {
         if(a instanceof Complex){
@@ -74,10 +73,23 @@ class Complex{
     get phi(){
         return Math.atan2(this.b , this.a);        
     }
-    static Zero() {
+    static zero() {
         return new Complex(0, 0);
     }
-    static Twiddle(N, K){
+    static fromPolar(z, phi) {
+        return new Complex(
+            +(z * cos(phi)).toFixed(13), 
+            +(z * sin(phi)).toFixed(13)
+        );
+    }
+    
+    static get random(){
+        return {
+            int : (a, b)=> new Complex(...Random.sample.int(2, a, b) ),
+            float : (a, b)=> new Complex(...Random.sample.float(2, a, b) ),
+        }
+    }
+    static twiddle(N, K){
         const phi = -2 * Math.PI * K / N;
         return new Complex(
             Math.cos(phi), 
@@ -150,12 +162,6 @@ class Complex{
         this.b = z * Math.sin(phi)  
         return this;
     }
-    static fromExpo(z, phi) {
-        return new Complex(
-            +(z * cos(phi)).toFixed(13), 
-            +(z * sin(phi)).toFixed(13)
-            );
-    }
     get expo() {
         return [this.z, this.phi];
     }
@@ -176,10 +182,10 @@ class Complex{
         return complex({z: this.z ** (1/n), phi: this.phi / n});
     }
     get sqrt(){
-        return this.nrth(2);
+        return this.nthr(2);
     }
     get cbrt(){
-        return this.nrth(3);
+        return this.nthr(3);
     }
     get log(){
         return complex(this.z, this.phi);

package/src/math/functions/conversions/index.js

@@ -0,0 +1,61 @@
+export const base2base = (value, fromBase, toBase) => {
+    if (fromBase < 2 || fromBase > 36 || toBase < 2 || toBase > 36)
+        throw new TypeError('Base must be between 2 and 36');
+
+    const dec = parseInt(value, fromBase);
+    if (Number.isNaN(dec)) throw new TypeError('Invalid value for the given base');
+
+    return dec.toString(toBase);
+};
+
+export const bin2oct = (...x) => mapfun(
+    n => base2base(n, 2, 8),
+    ...x
+)
+export const bin2dec = (...x) => mapfun(
+    n => base2base(n, 2, 10),
+    ...x
+)
+export const bin2hex = (...x) => mapfun(
+    n => base2base(n, 2, 16),
+    ...x
+)
+
+export const oct2bin = (...x) => mapfun(
+    n => base2base(n, 8, 2),
+    ...x
+)
+export const oct2dec = (...x) => mapfun(
+    n => base2base(n, 8, 10),
+    ...x
+)
+export const oct2hex = (...x) => mapfun(
+    n => base2base(n, 8, 16),
+    ...x
+)
+
+export const dec2bin = (...x) => mapfun(
+    n => base2base(n, 10, 2),
+    ...x
+)
+export const dec2oct = (...x) => mapfun(
+    n => base2base(n, 10, 8),
+    ...x
+)
+export const dec2hex = (...x) => mapfun(
+    n => base2base(n, 10, 16),
+    ...x
+)
+
+export const hex2bin = (...x) => mapfun(
+    n => base2base(n, 16, 2),
+    ...x
+)
+export const hex2oct = (...x) => mapfun(
+    n => base2base(n, 16, 8),
+    ...x
+)
+export const hex2dec = (...x) => mapfun(
+    n => base2base(n, 16, 10),
+    ...x
+)

package/src/math/functions/index.js

@@ -1,8 +1,9 @@
 export * from './mapfun/index.js'
-export * from './nested/index.js'
+export * from './ufunc/index.js'
 export * from './arithmetic/index.js'
 export * from './utils/index.js'
 export * from './stats/index.js'
+export * from './logic/index.js'
 // export 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;

package/src/math/functions/logic/index.js

@@ -0,0 +1,54 @@
+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
+};
+
+export const and = (...x) => {
+    const result = handle_complex_and_matrix(x, and);
+    if (result !== null) return result;
+    return x.reduce((n, m) => (n &= m), 1);
+};
+
+export const or = (...x) => {
+    const result = handle_complex_and_matrix(x, or);
+    if (result !== null) return result;
+    return x.reduce((n, m) => (n |= m), 0);
+};
+
+export const xor = (...x) => {
+    const result = handle_complex_and_matrix(x, xor);
+    if (result !== null) return result;
+    return x.reduce((n, m) => (n ^= m), 0);
+};
+
+export const nand = (...x) => not(and(...x));
+export const nor = (...x) => not(or(...x));
+export const xnor = (...x) => not(xor(...x));
+

package/src/math/functions/signal/index.js

@@ -1,5 +1,5 @@
 import { mapfun } from "../mapfun/index.js";
-import { nthr, pow } from "../nested/index.js";
+import { nthr, pow } from "../fundamentals/index.js";
 
 export const zeros = n => new Array(n).fill(0);
 export const ones = n => new Array(n).fill(1);

package/src/math/functions/stats/index.js

@@ -3,6 +3,18 @@ import {add, mul} from '../arithmetic/index.js';
 export const min = (...x) => Math.min(...x);
 export const max = (...x) => Math.max(...x);
 
+export 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;
+}
+
 export const mean = (...x) => x.reduce((a, b) => a + b) / x.length;
 
 export const variance = (...x) => {
@@ -16,7 +28,7 @@ export const std = (...x) => Math.sqrt(variance(...x));
 
 export const accum_sum = (...x) => {
   let result = [];
-  let total = 0, i; n = x.length;
+  let total = 0, i, n = x.length;
   for(i = 0; i < n ; i++){
     total = add(total, x[i])
     result.push(total);
@@ -26,7 +38,7 @@ export const accum_sum = (...x) => {
 
 export const accum_prod = (...x) => {
   let result = [];
-  let prod = 1, i; n = x.length;
+  let prod = 1, i, n = x.length;
   for(i = 0; i < n ; i++){
     prod = mul(prod, x[i])
     result.push(prod);

package/src/math/functions/utils/index.js

@@ -20,64 +20,6 @@ export const map = (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)
-// }
-
 export const hypot = (...x) => {
   const c0 = x.find(a => a.isComplex?.());
   if (c0) {

package/src/math/index.js

@@ -18,9 +18,9 @@ export * from "./const.js"
 export * from "./functions/index.js"
 export * from "./complex"
 export * from "./matrix"
-export * from "./discret"
+// export * from "./discret"
 export * from "./random"
 export * from "./utils"
-export * from "./statistics"
+// export * from "./statistics"
 // export default Math;
 

package/src/math/matrix/index.js

@@ -20,6 +20,7 @@ import {
     vstack
 } from "./helpers/index.js";
 import { mapfun } from '../functions/index.js';
+import { Random } from '../random/index.js';
 class Matrix{
     constructor(rows, cols, element = [] ) {
         if(rows instanceof Matrix){
@@ -93,13 +94,16 @@ class Matrix{
         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) {
+    slice(r0=0, c0=0, r1 = this.rows-1, c1 = this.cols-1) {
+        if(r1 < 0) r1 = this.rows + r1
+        if(c1 < 0 ) c1 = this.cols + c1
         let newRow = r1 - r0,
             newCol = c1 - c0;
         let newArr = new Array(newCol);
         for (let i = 0; i < newRow; i++) {
             newArr[i] = [];
-            for (let j = 0; j < newCol; j++) newArr[i][j] = this.arr[i + r0][j + c0];
+            for (let j = 0; j < newCol; j++) 
+                newArr[i][j] = this.arr[i + r0][j + c0];
         }
         return new Matrix(newRow, newCol, newArr.flat(1));
     }
@@ -125,6 +129,7 @@ class Matrix{
     get inv() {
         return matrix_inverse(this)
     }
+    // normalize names
     static eye(size) {
         let result = new Matrix(size, size);
         for (let i = 0; i < size; i++) 
@@ -149,6 +154,20 @@ class Matrix{
             for (let j = 0; j < cols; j++) result.arr[i][j] = number;
         return result;
     }
+    static get random(){
+        return {
+            int : (r, c, a, b)=> new Matrix(
+                r,
+                c,
+                Random.sample.int(r*c, a, b)
+            ),
+            float : (r, c, a,)=> new Matrix(
+                r,
+                c,
+                Random.sample.float(r*c, a, b)
+            ),
+        }
+    }
     hstack(...matrices) {
         const M=[this, ...matrices].reduce((a,b)=>hstack(a, b));
         Object.assign(this, M);
@@ -184,19 +203,31 @@ class Matrix{
         return matrix.clone().vqueue(...matrices);
     }
     shuffle(){
-        this.arr = this.arr.sort(()=>0.5-Math.random());
-        return this;
+        const arr = this.arr.flat(1).sort(() => 0.5-Math.random())
+        return new Matrix(
+            this.rows, 
+            this.cols,
+            arr
+        )
     }
     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);
-    // }
-
+    shuffleRows(){
+        this.arr = this.arr.sort(() => 0.5-Math.random());
+        return this;
+    }
+    static shuffleRows(M){
+        return M.clone().shuffleRows()
+    }
+    
+    shuffleCols(){
+        this.arr = this.clone().T.arr.sort(() => 0.5-Math.random());
+        return this.T
+    }
+    static shuffleCols(M){
+        return M.clone().shuffleCols()
+    }
     // Checkers
     get isSquare() {
         return this.rows === this.cols;
@@ -351,22 +382,6 @@ class Matrix{
                 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);
@@ -504,42 +519,44 @@ class Matrix{
     }
     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];
+        for (let i = 0; i < this.rows; i++) 
+            for (let j = 0; j < this.cols; j++) 
+                S += this.arr[i][j];
         return S;
     }
-    get hasComplex() {
+    hasComplex(){
         return this.arr.flat(Infinity).some((n) => n instanceof Complex);
     }
     get min() {
-        if (this.hasComplex) console.error("Complex numbers are not comparable");
+        if (this.hasComplex()) console.error("Complex numbers are not comparable");
         let minRow = [];
         for (let i = 0; i < this.rows; i++) minRow.push(min(...this.arr[i]));
         return min(...minRow);
     }
     get max() {
-        if (this.hasComplex) console.error("Complex numbers are not comparable");
+        if (this.hasComplex()) console.error("Complex numbers are not comparable");
         let maxRow = [];
         for (let i = 0; i < this.rows; i++) maxRow.push(max(...this.arr[i]));
         return max(...maxRow);
     }
     get minRows() {
-        if (this.hasComplex) console.error("Complex numbers are not comparable");
+        if (this.hasComplex()) console.error("Complex numbers are not comparable");
         let minRow = [];
         for (let i = 0; i < this.rows; i++) minRow.push(min(...this.arr[i]));
         return minRow;
     }
     get maxRows() {
-        if (this.hasComplex) console.error("Complex numbers are not comparable");
+        if (this.hasComplex()) console.error("Complex numbers are not comparable");
         let maxRow = [];
         for (let i = 0; i < this.rows; i++) maxRow.push(max(...this.arr[i]));
         return maxRow;
     }
     get minCols() {
-        if (this.hasComplex) console.error("Complex numbers are not comparable");
+        if (this.hasComplex()) console.error("Complex numbers are not comparable");
         return this.T.minRows;
     }
     get maxCols() {
-        if (this.hasComplex) console.error("Complex numbers are not comparable");
+        if (this.hasComplex()) console.error("Complex numbers are not comparable");
         return this.T.maxRows;
     }
     static fromVector(v) {