ziko 0.53.0 → 0.54.1

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

@@ -0,0 +1,75 @@
+// Mean
+export const mean = (...x) => x.reduce((a, b) => a + b) / x.length;
+export const geo_mean = (...x) => (x.reduce((a, b) => a * b)) ** (1/x.length);
+// Quadratic Mean
+export const rms = (...x) => {
+    const n = x.length;
+    return (Math.hypot(...x)/n)**(1/n)
+}
+
+export 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;
+}
+
+export const harmonic_mean = (...x) => {
+  let s = 0, i = 0;
+  for(i=0; i<x.length; i++) 
+    s += 1/x[i]
+  return x.length / s;
+}
+
+export 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);
+}
+
+export const trimmed_mean = (X, k) =>{
+  let a = [...X].sort((a,b)=>a-b).slice(k, X.length - k);
+  return mean(...a);
+}
+
+export 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);
+}
+
+export const midrange = (x) =>{
+  let min = Math.min(...x);
+  let max = Math.max(...x);
+  return (min + max) / 2;
+}
+
+export 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;
+}
+
+
+export 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);
+}
+
+
+export 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;
+}

package/src/math/stats/index.js

@@ -0,0 +1,14 @@
+export * from './percentile/index.js';
+export * from './average/index.js';
+export * from './variability/index.js'
+export * from './rolling/index.js'
+export * from './accum/index.js'
+
+
+// mean
+// variance
+// std
+// percentil 
+// accum
+
+//

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

@@ -0,0 +1,18 @@
+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 q1 = X => percentile(X, 25); 
+export const median = X => percentile(X, 50); 
+export const q3 = X => percentile(X, 75); 
+
+// Interquartile Range
+export const iqr = X => q3(X) - q1(X)

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

@@ -0,0 +1,34 @@
+// Simple Moving Average
+export 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
+export 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
+export 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;
+}

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

@@ -0,0 +1,37 @@
+// Population Variance
+import { mean } from "../average/index.js";
+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 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);
+};
+export const sample_std = (...x) => Math.sqrt(sample_variance(...x));
+
+export 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;
+};
+export const weighted_std = (X, weights) => Math.sqrt(weighted_variance(X, weights));
+
+export const rolling_variance = (X, windowSize) => {
+  if (windowSize < 1 || X.length < windowSize) return [];
+  let result = [];
+  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;
+};
+export const rolling_std = (X, windowSize) => Math.sqrt(rolling_variance(X, windowSize));

package/src/math/utils/arithmetic.js

@@ -43,7 +43,7 @@ const _sub=(a,b)=>{
 const _mul=(a,b)=>{
     if(typeof(a)==="number"){
     if (typeof b == "number") return a * b;
-        else if (b.isComplex?.())return new b.constructor(a * b.a,a * b.b);
+        else if (b.isComplex?.())return new b.constructor(a * b.a, a * b.b);
         else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).mul(b);
         else if (b instanceof Array)return b.map(n=>mul(a,n)); 
     }

package/src/math/utils/index.js

@@ -1,28 +1,28 @@
-import { mapfun } from "../mapfun/index.js";
-import { 
-    add,
-    sub,
-    mul,
-    div,
-    modulo
- } from "./arithmetic.js";
+// import { mapfun } from "../mapfun/index.js";
+// import { 
+//     add,
+//     sub,
+//     mul,
+//     div,
+//     modulo
+//  } from "./arithmetic.js";
 import {
     zeros,
     ones,
     nums,
-    norm,
-    lerp,
-    map,
-    clamp,
+    // norm,
+    // lerp,
+    // map,
+    // clamp,
     arange,
     linspace,
     logspace,
     geomspace
 } from "../signal/functions.js"
-import {
-    deg2rad,
-    rad2deg
-} from "./conversions.js"
+// import {
+//     deg2rad,
+//     rad2deg
+// } from "./conversions.js"
 import{
     sum,
     prod,
@@ -38,19 +38,19 @@ import{
     pgcd
 } from "./discret.js"
 const Utils={
-    add,
-    sub,
-    mul,
-    div,
-    modulo,
+    // add,
+    // sub,
+    // mul,
+    // div,
+    // modulo,
 
     zeros,
     ones,
     nums,
-    norm,
-    lerp,
-    map,
-    clamp,
+    // norm,
+    // lerp,
+    // map,
+    // clamp,
     arange,
     linspace,
     logspace,
@@ -64,35 +64,35 @@ const Utils={
     ppcm,
     pgcd,
 
-    deg2rad,
-    rad2deg,
+    // deg2rad,
+    // rad2deg,
 
     inRange,
     isApproximatlyEqual
 }
 export {
-    mapfun,
+    // mapfun,
     Utils,
     zeros,
     ones,
     nums,
     sum,
     prod,
-    add,
-    mul,
-    sub,
-    div,
-    modulo,
-    rad2deg,
-    deg2rad,
+    // add,
+    // mul,
+    // sub,
+    // div,
+    // modulo,
+    // rad2deg,
+    // deg2rad,
     arange,
     linspace,
     logspace,
     geomspace,
-    norm,
-    lerp,
-    map,
-    clamp,
+    // norm,
+    // lerp,
+    // map,
+    // clamp,
     pgcd,
     ppcm,
     isApproximatlyEqual,

package/src/time/animation/index.js

@@ -1,5 +1,5 @@
 import { linear } from "../ease/index.js";
-import { map } from "../../math/utils/index.js";
+import { map } from "../../math/functions/utils/index.js";
 
 class TimeAnimation {
   constructor(callback, { ease = linear, step = 50, t0 = 0, start = true, duration = 3000 } = {}) {

package/types/math/complex/index.d.ts

@@ -23,6 +23,7 @@ export declare class Complex {
     readonly conj: Complex;
     readonly inv: Complex;
     readonly sqrt: Complex;
+    readonly cbrt: Complex;
     readonly log: Complex;
     readonly cos: Complex;
     readonly sin: Complex;
@@ -34,7 +35,7 @@ export declare class Complex {
     mul(...z: (number | Complex)[]): this;
     div(...z: (number | Complex)[]): this;
     pow(n: number): this;
-    sqrtn(n?: number): Complex;
+    nrth(n?: number): Complex;
 
     static Zero(): Complex;
     static fromExpo(z: number, phi: number): Complex;