ziko 1.4.0 → 1.5.0

package/dist/ziko.js

@@ -2,7 +2,7 @@
 /*
   Project: ziko.js
   Author: Zakaria Elalaoui
-  Date : Thu Jul 30 2026 20:50:03 GMT+0100 (UTC+01:00)
+  Date : Fri Jul 31 2026 10:36:31 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
@@ -60,122 +60,212 @@
        return dec.toString(toBase);
    };
 
-   const arithmetic_helper=(op, x, y)=>{
-       if(typeof x === 'number'){
-           if(typeof y === 'number'){
-               switch(op){
-                   case 'add' : return x + y;
-                   case 'sub' : return x - y;
-                   case 'mul' : return x * y;
-                   case 'div' : return x / y;
-                   case 'modulo' : return x % y;
-               }
-           }
-           if(y?.isComplex?.()) x = new y.constructor(x, 0);
-           if(y?.isMatrix?.()) x = y.constructor.nums(y.rows, y.cols, x);
-           return x[op](y)
-       }
-       if(x?.isComplex?.()){
-           if(typeof y === 'number' || y?.isComplex?.()) return x.clone()[op](y);
-           if(y?.isMatrix?.()){
-               x = y.constructor.nums(y.rows, y.cols, x);
-               return x.clone()[op](y)
-           }
-       }
-       if(x?.isMatrix?.()){
-           return x.clone()[op](y)
-       }    
+   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 add=(a,...b)=>{
-       let res = a;
-       for(let i=0; i<b.length; i++)
-           res = arithmetic_helper('add', res, b[i]);
-       return res;
+
+   const q1 = X => percentile(X, 25); 
+   const median = X => percentile(X, 50); 
+   const q3 = X => percentile(X, 75); 
+
+   // Interquartile Range
+   const iqr = X => q3(X) - q1(X);
+
+   // Mean
+   const mean = (...x) => x.reduce((a, b) => a + b) / x.length;
+   const geo_mean = (...x) => (x.reduce((a, b) => a * b)) ** (1/x.length);
+   // Quadratic Mean
+   const rms = (...x) => {
+       const n = x.length;
+       return (Math.hypot(...x)/n)**(1/n)
    };
-   const sub=(a,...b)=>{
-       let res = a;
-       for(let i=0; i<b.length; i++)
-           res = arithmetic_helper('sub', res, b[i]);
-       return res;
+
+   const weighted_mean=(values, weights)=>{
+     let sum = 0, sw = 0;
+     for (let i = 0; i < values.length; i++) {
+       sum += values[i] * weights[i];
+       sw += weights[i];
+     }
+     return sum / sw;
    };
-   const mul=(a,...b)=>{
-       let res = a;
-       for(let i=0; i<b.length; i++)
-           res = arithmetic_helper('mul', res, b[i]);
-       return res;
+
+   const harmonic_mean = (...x) => {
+     let s = 0, i = 0;
+     for(i=0; i<x.length; i++) 
+       s += 1/x[i];
+     return x.length / s;
    };
-   const div=(a,...b)=>{
-       let res = a;
-       for(let i=0; i<b.length; i++)
-           res = arithmetic_helper('div', res, b[i]);
-       return res;
+
+   const power_mean = (X, p) =>{
+     let s = 0, i = 0, l = X.length;
+     for(i=0; i < l; i++) 
+       s+= X[i]**p;
+     return (s / l) ** (1 / p);
    };
-   const modulo=(a,...b)=>{
-       let res = a;
-       for(let i=0; i<b.length; i++)
-           res = arithmetic_helper('modulo', res, b[i]);
-       return res;
-   };
-
-   const min = (...x) => Math.min(...x);
-   const max = (...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 trimmed_mean = (X, k) =>{
+     let a = [...X].sort((a,b)=>a-b).slice(k, X.length - k);
+     return mean(...a);
+   };
+
+   const winsorized_mean = (X, k) =>{
+     let a = [...X].sort((a,b)=>a-b);
+     let low = a[k], high = a[a.length - k - 1];
+     a = a.map(x => Math.max(low, Math.min(high, x)));
+     return mean(a);
+   };
+
+   const midrange = (x) =>{
+     let min = Math.min(...x);
+     let max = Math.max(...x);
+     return (min + max) / 2;
+   };
+
+   const midhinge = (...x) =>{
+     let a = x.sort((a,b)=>a-b);
+     let q1 = a[Math.floor((a.length - 1) * 0.25)];
+     let q3 = a[Math.floor((a.length - 1) * 0.75)];
+     return (q1 + q3) / 2;
    };
 
-   const mean = (...x) => x.reduce((a, b) => a + b) / x.length;
 
+   const interquartile_mean = (...x) =>{
+     let a = x.sort((a,b)=>a-b);
+     let q1 = a[Math.floor((a.length - 1) * 0.25)];
+     let q3 = a[Math.floor((a.length - 1) * 0.75)];
+     let m = a.filter(x => x >= q1 && x <= q3);
+     return mean(m);
+   };
+
+
+   const contraharmonic_mean = (...x) =>{
+     let num = 0, den = 0, i, l = x.length;
+     for(i = 0; i < l; i++){
+       num += x[i]**2;
+       den += x[i];
+     }
+     return num / den;
+   };
+
+   // Population Variance
    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) => {
+   const sample_variance = (...x) => {
+     const n = x.length;
+     if (n < 2) return NaN;
+     const x_mean = mean(...x);
+     return x.reduce((sum, xi) => sum + (xi - x_mean) ** 2, 0) / (n - 1);
+   };
+   const sample_std = (...x) => Math.sqrt(sample_variance(...x));
+
+   const weighted_variance = (X, weights) => {
+     const n = X.length;
+     if (n === 0 || weights.length !== n) return NaN;
+     const sw = weights.reduce((sum, w) => sum + w, 0);
+     const mean = X.reduce((sum, x, i) => sum + x * weights[i], 0) / sw;
+     return X.reduce((sum, x, i) => sum + weights[i] * (x - mean) ** 2, 0) / sw;
+   };
+   const weighted_std = (X, weights) => Math.sqrt(weighted_variance(X, weights));
+
+   const rolling_variance = (X, windowSize) => {
+     if (windowSize < 1 || X.length < windowSize) return [];
      let result = [];
-     let total = 0, i, n = x.length;
-     for(i = 0; i < n ; i++){
-       total = add(total, x[i]);
+     for (let i = 0; i <= X.length - windowSize; i++) {
+       const w = X.slice(i, i + windowSize);
+       result.push(sample_variance(w)); // usually sample variance for rolling
+     }
+     return result;
+   };
+   const rolling_std = (X, windowSize) => Math.sqrt(rolling_variance(X, windowSize));
+
+   // Simple Moving Average
+   const sma = (X, w) =>{
+     let r = [];
+     for (let i = 0; i <= X.length - w; i++) {
+       let s = 0;
+       for (let j = 0; j < w; j++) s += X[i + j];
+       r.push(s / w);
+     }
+     return r;
+   };
+
+   // exponential Moving Average
+   const ema = (X, alpha) =>{
+     let r = [], prev = X[0];
+     r.push(prev);
+     for (let i = 1; i < X.length; i++) {
+       prev = alpha * X[i] + (1 - alpha) * prev;
+       r.push(prev);
+     }
+     return r;
+   };
+
+   // weightedMovingAverage
+   const wma = (X, weights) =>{
+     let k = weights.length;
+     let sw = weights.reduce((a,b)=>a+b, 0);
+     let r = [];
+     for (let i = 0; i <= X.length - k; i++) {
+       let s = 0;
+       for (let j = 0; j < k; j++) s += X[i+j] * weights[j];
+       r.push(s / sw);
+     }
+     return r;
+   };
+
+   const accum_sum = (arr) => {
+     let result = [];
+     let total = 0;
+     for (let x of arr) {
+       total += x;
        result.push(total);
      }
      return result;
    };
 
-   const accum_prod = (...x) => {
+   const accum_product = (arr) => {
      let result = [];
-     let prod = 1, i, n = x.length;
-     for(i = 0; i < n ; i++){
-       prod = mul(prod, x[i]);
+     let prod = 1;
+     for (let x of arr) {
+       prod *= x;
        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 accum_max = (arr) => {
+     let result = [];
+     let m = -Infinity;
+     for (let x of arr) {
+       m = Math.max(m, x);
+       result.push(m);
+     }
+     return result;
    };
 
-   const median = X => percentile(X, 50);
+   const accum_min = (arr) => {
+     let result = [];
+     let m = Infinity;
+     for (let x of arr) {
+       m = Math.min(m, x);
+       result.push(m);
+     }
+     return result;
+   };
 
    class Random {
        static int(a, b){
@@ -250,9 +340,9 @@
        static get sample(){
            const R = this;
            return {
-               int   : (n,a,b) => Array.from({length:n}, () => R.int(a,b)),
-               float : (n,a,b) => Array.from({length:n}, () => R.float(a,b)),
-               char  : (n,upper=false) => Array.from({length:n}, () => R.char(upper)),
+               int   : (n, a, b) => Array.from({length:n}, () => R.int(a, b)),
+               float : (n, a, b) => Array.from({length:n}, () => R.float(a, b)),
+               char  : (n, upper=false) => Array.from({length:n}, () => R.char(upper)),
                bool  : n => Array.from({length:n}, () => R.bool()),
                bin   : n => Array.from({length:n}, () => R.bin()),
                oct   : n => Array.from({length:n}, () => R.oct()),
@@ -893,6 +983,63 @@
        ...x
    );
 
+   const arithmetic_helper=(op, x, y)=>{
+       if(typeof x === 'number'){
+           if(typeof y === 'number'){
+               switch(op){
+                   case 'add' : return x + y;
+                   case 'sub' : return x - y;
+                   case 'mul' : return x * y;
+                   case 'div' : return x / y;
+                   case 'modulo' : return x % y;
+               }
+           }
+           if(y?.isComplex?.()) x = new y.constructor(x, 0);
+           if(y?.isMatrix?.()) x = y.constructor.nums(y.rows, y.cols, x);
+           return x[op](y)
+       }
+       if(x?.isComplex?.()){
+           if(typeof y === 'number' || y?.isComplex?.()) return x.clone()[op](y);
+           if(y?.isMatrix?.()){
+               x = y.constructor.nums(y.rows, y.cols, x);
+               return x.clone()[op](y)
+           }
+       }
+       if(x?.isMatrix?.()){
+           return x.clone()[op](y)
+       }    
+   };
+   const add=(a,...b)=>{
+       let res = a;
+       for(let i=0; i<b.length; i++)
+           res = arithmetic_helper('add', res, b[i]);
+       return res;
+   };
+   const sub=(a,...b)=>{
+       let res = a;
+       for(let i=0; i<b.length; i++)
+           res = arithmetic_helper('sub', res, b[i]);
+       return res;
+   };
+   const mul=(a,...b)=>{
+       let res = a;
+       for(let i=0; i<b.length; i++)
+           res = arithmetic_helper('mul', res, b[i]);
+       return res;
+   };
+   const div=(a,...b)=>{
+       let res = a;
+       for(let i=0; i<b.length; i++)
+           res = arithmetic_helper('div', res, b[i]);
+       return res;
+   };
+   const modulo=(a,...b)=>{
+       let res = a;
+       for(let i=0; i<b.length; i++)
+           res = arithmetic_helper('modulo', res, b[i]);
+       return res;
+   };
+
    const deg2rad = (...deg) => mapfun$1(x => x * Math.PI / 180, ...deg);
    const rad2deg = (...rad) => mapfun$1(x => x / Math.PI * 180, ...rad);
 
@@ -937,6 +1084,66 @@
        return rad ? phi : phi * 180 / Math.PI;
    };
 
+   const min = (...x) => Math.min(...x);
+   const max = (...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;
+   };
+
+   // export const mean = (...x) => x.reduce((a, b) => a + b) / x.length;
+
+   // export 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;
+   // };
+
+   // export const std = (...x) => Math.sqrt(variance(...x));
+
+   // export 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;
+   };
+
+   // export 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;
+   // }
+
+   // export 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))
@@ -2895,7 +3102,14 @@
 
        if(element)this.init(element, name, type, render);
      }
-     on(event_name, callback, {details_setter, category = 'global', isCustom = false,preventDefault = false} = {}){
+     on(event_name, callback, {details_setter, category = 'global', isCustom = false, preventDefault = false} = {}){
+       if(event_name instanceof Array) event_name.forEach(
+         event => this.on(
+           event, 
+           callback, 
+           {details_setter, category, isCustom, preventDefault}
+         )
+       );
        if(category && !this.exp.events.hasOwnProperty(category)) this.exp.events[category] = new EventController(this, category);
        isCustom && this.exp.events[category].cache.customEvents.add(event_name);
        const EVENT = this.exp.events[category];
@@ -3577,6 +3791,22 @@
 
    const Fragment = (...items) => new UIFragment(...items);
 
+   class UIFor extends UIFragment{
+       constructor({each, fallback, mapFn = () => {}} = {}){
+           super();
+           this.config = {
+               each,
+               fallback,
+               mapFn
+           };
+           this.append(
+               ...this.config.each.map((n,i) => this.config.mapFn(n, i))
+           );
+       }
+   }
+
+   const For = ({each, fallback, mapFn} = {}) => new UIFor({each, fallback, mapFn});
+
    const { PI, sqrt: sqrt$1, cos: cos$2, sin: sin$2, acos, pow } = Math;
 
    const linear = t => t;
@@ -4993,6 +5223,7 @@
    exports.EventController = EventController;
    exports.FileBasedRouting = FileBasedRouting;
    exports.Flex = Flex;
+   exports.For = For;
    exports.Fragment = Fragment;
    exports.HTMLWrapper = HTMLWrapper;
    exports.KeyListeners = KeyListeners;
@@ -5030,7 +5261,10 @@
    exports.ZikoUISuspense = ZikoUISuspense;
    exports.ZikoUIText = ZikoUIText;
    exports.abs = abs;
+   exports.accum_max = accum_max;
+   exports.accum_min = accum_min;
    exports.accum_prod = accum_prod;
+   exports.accum_product = accum_product;
    exports.accum_sum = accum_sum;
    exports.acos = acos$1;
    exports.acosh = acosh;
@@ -5056,6 +5290,7 @@
    exports.clock = clock;
    exports.cloneUI = cloneUI;
    exports.complex = complex;
+   exports.contraharmonic_mean = contraharmonic_mean;
    exports.cos = cos$3;
    exports.cosh = cosh$2;
    exports.coth = coth;
@@ -5072,9 +5307,12 @@
    exports.discret = discret;
    exports.div = div;
    exports.elastic = elastic;
+   exports.ema = ema;
    exports.exp = exp$1;
    exports.floor = floor;
    exports.fract = fract;
+   exports.geo_mean = geo_mean;
+   exports.harmonic_mean = harmonic_mean;
    exports.hypot = hypot;
    exports.in_back = in_back;
    exports.in_bounce = in_bounce;
@@ -5096,6 +5334,8 @@
    exports.in_quart = in_quart;
    exports.in_quint = in_quint;
    exports.in_sin = in_sin;
+   exports.interquartile_mean = interquartile_mean;
+   exports.iqr = iqr;
    exports.isPrimitive = isPrimitive;
    exports.isStateGetter = isStateGetter;
    exports.json2arr = json2arr;
@@ -5120,6 +5360,8 @@
    exports.max = max;
    exports.mean = mean;
    exports.median = median;
+   exports.midhinge = midhinge;
+   exports.midrange = midrange;
    exports.min = min;
    exports.modulo = modulo;
    exports.mul = mul;
@@ -5127,6 +5369,7 @@
    exports.nor = nor;
    exports.norm = norm;
    exports.normalize_css_value = normalize_css_value;
+   exports.not = not;
    exports.nthr = nthr;
    exports.or = or;
    exports.out_back = out_back;
@@ -5141,12 +5384,20 @@
    exports.out_sin = out_sin;
    exports.percentile = percentile;
    exports.pow = pow$1;
+   exports.power_mean = power_mean;
+   exports.q1 = q1;
+   exports.q3 = q3;
    exports.rad2deg = rad2deg;
    exports.register_click_away_event = register_click_away_event;
    exports.register_swipe_event = register_swipe_event;
    exports.register_view_event = register_view_event;
    exports.remove_class = remove_class;
+   exports.rms = rms;
+   exports.rolling_std = rolling_std;
+   exports.rolling_variance = rolling_variance;
    exports.round = round;
+   exports.sample_std = sample_std;
+   exports.sample_variance = sample_variance;
    exports.script = script;
    exports.sec = sec;
    exports.sig = sig;
@@ -5154,6 +5405,7 @@
    exports.sin = sin$3;
    exports.sinh = sinh$1;
    exports.sleep = sleep;
+   exports.sma = sma;
    exports.sqrt = sqrt$2;
    exports.std = std;
    exports.step = step;
@@ -5173,6 +5425,7 @@
    exports.timeTaken = timeTaken;
    exports.time_memory_Taken = time_memory_Taken;
    exports.timeout = timeout;
+   exports.trimmed_mean = trimmed_mean;
    exports.trunc = trunc;
    exports.useDerived = useDerived;
    exports.useEventEmitter = useEventEmitter;
@@ -5192,6 +5445,11 @@
    exports.waitForUIElm = waitForUIElm;
    exports.waitForUIElmSync = waitForUIElmSync;
    exports.watchQueryParams = watchQueryParams;
+   exports.weighted_mean = weighted_mean;
+   exports.weighted_std = weighted_std;
+   exports.weighted_variance = weighted_variance;
+   exports.winsorized_mean = winsorized_mean;
+   exports.wma = wma;
    exports.xnor = xnor;
    exports.xor = xor;