ziko 0.54.0 → 0.54.1

package/dist/ziko.js

@@ -2,7 +2,7 @@
 /*
   Project: ziko.js
   Author: Zakaria Elalaoui
-  Date : Sun Dec 07 2025 00:00:39 GMT+0100 (UTC+01:00)
+  Date : Wed Dec 10 2025 13:44:02 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
@@ -36,6 +36,20 @@
            }
        });
       return Y.length==1? Y[0]: Y; 
+   };
+
+   const apply_fun = (x, fn) => {
+       if (x.isComplex?.()) return new x.constructor(
+           fn(x.a),
+           fn(x.b)
+       )
+       if (x.isMatrix?.()) return new x.constructor(
+           x.rows,
+           x.cols,
+           x.arr.flat(1).map(fn)
+       )
+       if (x instanceof Array) mapfun(fn, ...x);
+       return fn(x)
    };
 
    // import {sum,prod,deg2rad} from "../utils/index.js";
@@ -95,7 +109,16 @@
                : (str = `-${Math.abs(this.b)}*i`);
            return str;
        }
-         
+       toFixed(n){
+           this.a = + this.a.toFixed(n);
+           this.b = + this.b.toFixed(n);
+           return this; 
+       }  
+       toPrecision(n){
+           this.a = + this.a.toPrecision(n);
+           this.b = + this.b.toPrecision(n);
+           return this; 
+       }  
        clone() {
            return new Complex(this.a, this.b);
        }
@@ -138,10 +161,10 @@
            for (let i = 0; i < c.length; i++) {
                if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
                z *= c[i].z;
-               phi += c[i].z;
+               phi += c[i].phi;
            }
-           this.a = z*Math.cos(phi);
-           this.b = z*Math.sin(phi);  
+           this.a = z * Math.cos(phi);
+           this.b = z * Math.sin(phi);  
            return this;
        }
        div(...c){
@@ -149,7 +172,7 @@
            for (let i = 0; i < c.length; i++) {
                if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
                z /= c[i].z;
-               phi -= c[i].z;
+               phi -= c[i].phi;
            }
            this.a = z*Math.cos(phi);
            this.b = z*Math.sin(phi);  
@@ -163,6 +186,17 @@
            }
            return this;
        }
+       pow(...c){
+           let {z, phi} = this;
+           for (let i = 0; i < c.length; i++) {
+               if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
+               z *= Math.exp(c[i].a * Math.log(z) - c[i].b * phi);
+               phi += c[i].b * Math.log(z) + c[i].a * phi;
+           }
+           this.a = z * Math.cos(phi);
+           this.b = z * Math.sin(phi);  
+           return this;
+       }
        static fromExpo(z, phi) {
            return new Complex(
                +(z * cos(phi)).toFixed(13), 
@@ -227,9 +261,6 @@
        return new Complex(a,b)
    };
 
-   const deg2rad = (...deg) => mapfun(x => x * Math.PI / 180, ...deg);
-   const rad2deg = (...rad) => mapfun(x => x / Math.PI * 180, ...rad);
-
    const abs = (...x) => mapfun(
        x =>{
            if(x.isComplex?.()) return x.z;
@@ -618,7 +649,7 @@
            if(y.isComplex?.()) return y.clone().mul(x);
        }
        if(x.isComplex?.()){
-           if(typeof y === 'number' || y.isComplex?.()) return new x.clone().mul(y);
+           if(typeof y === 'number' || y.isComplex?.()) return x.clone().mul(y);
        }
    };
 
@@ -673,57 +704,83 @@
        return res;
    };
 
-   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)
-       );
-       return min !== max ? (value - min) / (max - min) : 0;
-   };
+   const deg2rad = (...deg) => mapfun(x => x * Math.PI / 180, ...deg);
+   const rad2deg = (...rad) => mapfun(x => x / Math.PI * 180, ...rad);
 
-   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)
-       );
-       return (max - min) * value + min;
-   };
+   const norm = (x, min, max) => apply_fun(
+       x, 
+       v => min !== max ? (v - min) / (max - min) : 0
+   );
+   const lerp = (x, min, max) => apply_fun(
+       x, 
+       v => (max - min) * v + min
+   );
+   const clamp = (x, min, max) => apply_fun(
+       x, 
+       v => Math.min(Math.max(v, min), max)
+   );
+   const map$1 = (x, a, b, c, d) => apply_fun(
+       x, 
+       v => lerp(norm(v, a, b), c, d)
+   );
 
-   const map$1 = (x, min, max) => {
-       if(x.isComplex?.()) return new x.constructor(
-           map$1(x.a),
-           map$1(x.b)
-       )
-       if(x.isMatrix?.()) return new x.constructor(
-           x.rows, 
-           x.cols, 
-           map$1(x.arr.flat(1))
-       );
-       return lerp(norm(x, a, b), c, d);
-   };
 
-   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)
-       );
-       return Math.min(Math.max(c, min), max)
-   };
+   // 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?.());
@@ -735,10 +792,68 @@
    };
 
 
-   const atan2 = (x, y, rad = true) =>{
+   const atan2 = (y, x, rad = true) => {
+       if (y instanceof Array && !(x instanceof Array))
+           return mapfun(n => atan2(n, x, rad), ...y);
+
+       if (x instanceof Array && !(y instanceof Array))
+           return mapfun(n => atan2(y, n, rad), ...x);
 
+       if (y instanceof Array && x instanceof Array)
+           return y.map((v, i) => atan2(v, x[i], rad));
+
+       const phi = Math.atan2(y, x);
+       return rad ? phi : phi * 180 / Math.PI;
    };
 
+   const min$1 = (...x) => Math.min(...x);
+   const max$1 = (...x) => Math.max(...x);
+
+   const mean = (...x) => x.reduce((a, b) => a + b) / x.length;
+
+   const variance = (...x) => {
+     const n = x.length;
+     if (n === 0) return NaN;
+     const x_mean = mean(...x);
+     return x.reduce((sum, xi) => sum + (xi - x_mean) ** 2, 0) / n;
+   };
+
+   const std = (...x) => Math.sqrt(variance(...x));
+
+   const accum_sum = (...x) => {
+     let result = [];
+     let total = 0, i; n = x.length;
+     for(i = 0; i < n ; i++){
+       total = add(total, x[i]);
+       result.push(total);
+     }
+     return result;
+   };
+
+   const accum_prod = (...x) => {
+     let result = [];
+     let prod = 1, i; n = x.length;
+     for(i = 0; i < n ; i++){
+       prod = mul(prod, x[i]);
+       result.push(prod);
+     }
+     return result;
+   };
+
+   const percentile = (X, p) => {
+     if (X.length === 0) 
+       return NaN;
+     let a = [...X].sort((x, y) => x - y);
+     let index = (p / 100) * (a.length - 1);
+     let i = Math.floor(index);
+     let f = index - i;
+     if (i === a.length - 1) 
+       return a[i]; 
+     return a[i] * (1 - f) + a[i + 1] * f;
+   };
+
+   const median = X => percentile(X, 50);
+
    const preload=(url)=>{
        const xhr = new XMLHttpRequest();
        xhr.open("GET", url, false); 
@@ -3526,7 +3641,7 @@
        //     return result;
        // }
        map(Imin, Imax, Fmin, Fmax) {
-           this.arr = map$1(this.arr);
+           this.arr = map$1(this.arr, Imin, Imax, Fmin, Fmax);
            return this;
        }
        lerp(min, max) {
@@ -3925,36 +4040,36 @@
        }
        return Y.length===1?Y[0]:Y;
    };
-   const min$1=(...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$1(...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$1=(...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$1(...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 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]);
@@ -4608,7 +4723,7 @@
        this.t += this.state.step;
        this.i++;
 
-       this.tx = map$1(this.t, 0, this.state.duration);
+       this.tx = map$1(this.t, 0, this.state.duration, 0, 1);
        this.ty = this.state.ease(this.tx);
 
        this.callback(this);
@@ -5658,11 +5773,14 @@
    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.animation = animation;
+   exports.apply_fun = apply_fun;
    exports.arange = arange;
    exports.arc = arc;
    exports.arr2str = arr2str;
@@ -5757,6 +5875,8 @@
    exports.matrix3 = matrix3;
    exports.matrix4 = matrix4;
    exports.max = max$1;
+   exports.mean = mean;
+   exports.median = median;
    exports.min = min$1;
    exports.modulo = modulo;
    exports.mul = mul;
@@ -5775,6 +5895,7 @@
    exports.out_quart = out_quart;
    exports.out_quint = out_quint;
    exports.out_sin = out_sin;
+   exports.percentile = percentile;
    exports.pgcd = pgcd;
    exports.pow = pow$1;
    exports.powerSet = powerSet;
@@ -5790,6 +5911,7 @@
    exports.sinh = sinh$1;
    exports.sleep = sleep;
    exports.sqrt = sqrt$2;
+   exports.std = std;
    exports.step = step;
    exports.step_fps = step_fps;
    exports.sub = sub;
@@ -5821,6 +5943,7 @@
    exports.useState = useState;
    exports.useThread = useThread;
    exports.useTitle = useTitle;
+   exports.variance = variance;
    exports.wait = wait;
    exports.waitForUIElm = waitForUIElm;
    exports.waitForUIElmSync = waitForUIElmSync;