ziko 1.4.0 → 1.5.0

package/dist/ziko.cjs

@@ -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
@@ -56,122 +56,212 @@ const base2base = (value, fromBase, toBase) => {
     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){
@@ -246,9 +336,9 @@ class Random {
     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()),
@@ -889,6 +979,63 @@ const sig = (...x) => mapfun$1(
     ...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);
 
@@ -933,6 +1080,66 @@ const atan2 = (y, x, rad = true) => {
     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))
@@ -2891,7 +3098,14 @@ let UIElement$1 = class UIElement extends UIElementCore{
 
     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];
@@ -3573,6 +3787,22 @@ class UIFragment extends UIElement$1{
 
 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;
@@ -4989,6 +5219,7 @@ exports.EPSILON = EPSILON;
 exports.EventController = EventController;
 exports.FileBasedRouting = FileBasedRouting;
 exports.Flex = Flex;
+exports.For = For;
 exports.Fragment = Fragment;
 exports.HTMLWrapper = HTMLWrapper;
 exports.KeyListeners = KeyListeners;
@@ -5026,7 +5257,10 @@ exports.ZikoSPA = ZikoSPA;
 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;
@@ -5052,6 +5286,7 @@ exports.clamp = clamp;
 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;
@@ -5068,9 +5303,12 @@ exports.deg2rad = deg2rad;
 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;
@@ -5092,6 +5330,8 @@ exports.in_quad = in_quad;
 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;
@@ -5116,6 +5356,8 @@ exports.matrix4 = matrix4;
 exports.max = max;
 exports.mean = mean;
 exports.median = median;
+exports.midhinge = midhinge;
+exports.midrange = midrange;
 exports.min = min;
 exports.modulo = modulo;
 exports.mul = mul;
@@ -5123,6 +5365,7 @@ exports.nand = nand;
 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;
@@ -5137,12 +5380,20 @@ exports.out_quint = out_quint;
 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;
@@ -5150,6 +5401,7 @@ exports.sign = sign;
 exports.sin = sin$3;
 exports.sinh = sinh$1;
 exports.sleep = sleep;
+exports.sma = sma;
 exports.sqrt = sqrt$2;
 exports.std = std;
 exports.step = step;
@@ -5169,6 +5421,7 @@ exports.tick = tick;
 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;
@@ -5188,5 +5441,10 @@ exports.waitElm = waitElm;
 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;