ziko 0.52.0 → 0.54.0

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

@@ -0,0 +1,21 @@
+export const min = (...x) => Math.min(...x);
+export const max = (...x) => Math.max(...x);
+
+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;

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

@@ -1,176 +0,0 @@
-import { mapfun } from '../../mapfun/index.js';
-
-export const abs = (...x) => mapfun(
-    x =>{
-        if(x.isComplex?.()) return x.z;
-        return Math.abs(x)
-    },
-    ...x
-)
-
-export const sqrt = (...x) => mapfun(
-    x=>{
-        if(x.isComplex?.()){
-            const {z, phi} = x
-            return new x.constructor(
-                Math.sqrt(z) * Math.cos(phi/2),
-                Math.sqrt(z) * Math.sin(phi/2)
-            );
-        } 
-        return Math.sqrt(x);
-    },
-    ...x
-)
-
-export const e = (...x) => mapfun(
-    x => {
-        if(x.isComplex?.()) return new x.constructor(
-            Math.exp(x.a) * Math.cos(x.b),
-            Math.exp(x.a) * Math.sin(x.b)
-        );
-        return Math.ln(x)
-    }
-    ,...x
-);
-
-export const ln = (...x) => mapfun(
-    x => {
-        if(x.isComplex?.()) return new x.constructor(
-            Math.log(x.z),
-            x.phi
-        );
-        return Math.ln(x)
-    }
-    ,...x
-);
-
-export const sign = (...x) => mapfun(
-    x => {
-        if(x.isComplex?.()){
-            const {z, phi} = x;
-            if(z===0) return new x.constructor(0, 0);
-            return new x.constructor({z:1, phi})
-        }
-        return Math.sign(x)
-    }
-    ,...x
-);
-export const cos = (...x) => mapfun(
-    x => {
-        if(x.isComplex?.()) return new x.constructor(
-            Math.cos(x.a) * Math.cosh(x.b),
-            -Math.sin(x.a) * Math.sinh(x.b)
-        );
-        return Math.cos(x)
-    }
-    ,...x
-);
-
-export const sin = (...x) => mapfun(
-    x =>{
-        if(x?.isComplex) return new x.constructor(
-            Math.sin(x.a) * Math.cosh(x.b),
-            Math.cos(x.a) * Math.sinh(x.b)
-        );
-        return Math.sin(x)
-    }
-    , ...x
-);
-
-export const tan = (...x) => mapfun(
-    x =>{
-        if(x?.isComplex){
-            const DEN = Math.cos(2*x.a) + Math.cosh(2*x.b);
-            return new x.constructor(
-                Math.sin(2*x.a) / DEN,
-                Math.sinh(2*x.b) / DEN
-            );
-        } 
-        return Math.tan(x) 
-    },
-    ...x
-);
-
-export const acos = (...x) => mapfun(
-    x =>{
-        if(x?.isComplex){
-            const { a, b } = x;
-            const Rp = Math.hypot(a + 1, b);
-            const Rm = Math.hypot(a - 1, b);
-            globalThis.Rp = Rp
-            globalThis.Rm = Rm
-            console.log({a, b, Rp, Rm})
-            return new x.constructor(
-                Math.acos((Rp - Rm) / 2),
-                -Math.acosh((Rp + Rm) / 2),
-            )
-        } 
-        return Math.acos(x) 
-    },
-    ...x
-);
-
-export const asin = (...x) => mapfun(
-    x => {
-        if(x?.isComplex){
-            const { a, b } = x;
-            const Rp = Math.hypot(a + 1, b);
-            const Rm = Math.hypot(a - 1, b);
-            return new x.constructor(
-                Math.asin((Rp - Rm) / 2), 
-                Math.acosh((Rp + Rm) / 2)
-            );
-        }
-        return Math.asin(x);
-    },
-    ...x
-);
-
-export const atan = (...x) => mapfun(
-    x => {
-        if(x?.isComplex){
-            const { a, b } = x;
-            return new x.constructor(
-                Math.atan((a*2/(1-a**2-b**2)))/2,
-                Math.log((a**2 + (1+b)**2)/(a**2 + (1-b)**2))/4
-            )
-        }
-        return Math.atan(x);
-    },
-    ...x
-);
-
-
-export const cosh = (...x) => mapfun(
-    x =>{
-        if(x?.isComplex) return new x.constructor(
-            cosh(x.a)*cos(x.b),
-            sinh(x.a)*sin(x.b)
-        ); 
-        return cosh(x)
-    },
-    ...x
-)
-export const sinh = (...x) => mapfun(
-    x =>{
-        if(x?.isComplex) return new x.constructor(
-            sinh(x.a)*cos(x.b),
-            cosh(x.a)*sin(x.b)
-        ); 
-        return sinh(x)
-    },
-    ...x
-)
-export const tanh = (...x) => mapfun(
-    x =>{
-        if(x?.isComplex){
-            const DEN=cosh(2*a)+cos(2*b);
-            return new x.constructor(
-                sinh(2*a)/DEN,
-                sin(2*b)/DEN
-            )
-        } 
-        return tanh(x)
-    },
-    ...x
-)