ziko 0.53.0 → 0.54.0

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

@@ -0,0 +1,65 @@
+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)
+    );
+    return min !== max ? (value - 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)
+    );
+    return (max - min) * value + min;
+}
+
+export const map = (x, min, max) => {
+    if(x.isComplex?.()) return new x.constructor(
+        map(x.a, min, max),
+        map(x.b, min, max)
+    )
+    if(x.isMatrix?.()) return new x.constructor(
+        x.rows, 
+        x.cols, 
+        map(x.arr.flat(1), min, max)
+    );
+    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)
+    );
+    return Math.min(Math.max(c, min), max)
+}
+
+export const hypot = (...x) => {
+  const c0 = x.find(a => a.isComplex?.());
+  if (c0) {
+    const W = x.map(n => n.isComplex?.() ? n : new c0.constructor(n, 0));
+    return Math.hypot(...W.map(c => c.z));
+  }
+  return Math.hypot(...x);
+};
+
+
+export const atan2 = (x, y, rad = true) =>{
+
+}

package/src/math/matrix/helpers/det.js

@@ -1,4 +1,4 @@
-import { add, sub, mul } from "../../utils/index.js";
+import { add, sub, mul } from "../../functions/arithmetic/index.js";
 import { pow } from "../../functions/index.js";
 export function matrix_det(M) {
     if (!M.isSquare) return new Error("is not square matrix");

package/src/math/matrix/matrix.js

@@ -1,22 +1,17 @@
-import{
-    min,
-    max,
-  } from "../functions/index.js"
-import { 
-    Utils,
+import {
     add,
     sub, 
     mul, 
-    div, 
-    modulo,
+    div,
+    modulo
+} from '../functions/arithmetic/index.js'
+import {
     map,
-    lerp,
-    norm,
-    clamp
-
-} from "../utils/index.js";
+    lerp, 
+    clamp, 
+    norm 
+} from '../functions/utils/index.js'
 import { Complex } from "../complex/index.js";
-// import { Random } from "../random/index.js"
 import { arr2str } from "../../data/index.js";
 import { 
     matrix_inverse,

package/src/math/signal/functions.js

@@ -1,70 +1,10 @@
-import { abs , pow , sqrtn , max , min} from "../functions/index.js";
-import { mul } from "../utils/index.js";
+import { abs , pow , nthr } from "../functions/index.js";
+import { mul } from "../functions/arithmetic/index.js";
 import { E } from "../const.js";
 const zeros=(n)=>new Array(n).fill(0);
 const ones=(n)=>new Array(n).fill(1);
 const nums=(num,n)=>new Array(n).fill(num);
-const norm=(value, min, max)=>{
-    if (typeof value === "number") return min !== max ? (value - min) / (max - min) : 0;
-    else if (value.isMatrix?.()) return new value.constructor(value.rows, value.cols, norm(value.arr.flat(1), min, max));
-    else if (value.isComplex?.()) return new value.constructor(norm(value.a, min, max), norm(value.b, min, max));
-    else if (value instanceof Array) {
-        if (value.every((n) => typeof (n === "number"))) {
-            return value.map((n) => norm(n, min, max));
-        } else {
-            let y = new Array(value.length);
-            for (let i = 0; i < value.length; i++) {
-                y[i] = norm(value[i]);
-            }
-        }
-    }
-}
-const lerp=(value, min, max)=>{
-    if (typeof value === "number") return (max - min) * value + min;
-    else if (value.isMatrix?.()) return new value.constructor(value.rows, value.cols, lerp(value.arr.flat(1), min, max));
-    else if (value.isComplex?.()) return new value.constructor(lerp(value.a, min, max), lerp(value.b, min, max));
-    else if (value instanceof Array) {
-        if (value.every((n) => typeof (n === "number"))) {
-            return value.map((n) => lerp(n, min, max));
-        } else {
-            let y = new Array(value.length);
-            for (let i = 0; i < value.length; i++) {
-                y[i] = lerp(value[i]);
-            }
-        }
-    }
-}
-const map=(x, a, b, c, d)=>{
-    if (typeof x === "number") return lerp(norm(x, a, b), c, d);
-    else if (x.isMatrix?.()) return new x.constructor(x.rows, x.cols, map(x.arr.flat(1), a, b, c, d));
-    else if (x.isComplex?.()) return new x.constructor(map(x.a, b, c, d), map(x.b, a, b, c, d));
-    else if (x instanceof Array) {
-        if (x.every((n) => typeof (n === "number"))) {
-            return x.map((n) => map(n, a, b, c, d));
-        } else {
-            let y = new Array(x.length);
-            for (let i = 0; i < x.length; i++) {
-                y[i] = map(x[i], a, b, c, d);
-            }
-        }
-    }
-}
-const clamp=(x, a , b)=>{
-    const [min_value,max_value]=[min(a,b),max(a,b)]
-    if (typeof x === "number") return min(max(x, min_value), max_value);
-    else if (x.isMatrix?.()) return new x.constructor(x.rows, x.cols, clamp(x.arr.flat(1), min_value, max_value));
-    else if (x.isComplex?.()) return new x.constructor(clamp(x.a, min_value, max_value), clamp(x.b, min_value, max_value));
-    else if (x instanceof Array) {
-        if (x.every((n) => typeof (n === "number"))) {
-            return x.map((n) => clamp(n, min_value, max_value));
-        } else {
-            let y = new Array(x.length);
-            for (let i = 0; i < x.length; i++) {
-                y[i] = clamp(x[i], min_value, max_value);
-            }
-        }
-    }
-}
+
 const arange=(a, b, step , include = false)=>{
     let tab = [];
     if(a<b){
@@ -107,7 +47,7 @@ const geomspace=(a,b,n=abs(b-a)+1,endpoint=true)=>{
     if([a,b].every(n=>typeof n==="number")){
         const [max,min]=[a,b].sort((a,b)=>b-a);
         let base;
-        endpoint ? base = sqrtn(max/min,n-1) : base = sqrtn(max/min,n) ;
+        endpoint ? base = nthr(max/min,n-1) : base = nthr(max/min,n) ;
         const Y = [min];
         for (let i = 1; i < n; i++) {
             Y.push(Y[i-1]*base)
@@ -120,7 +60,7 @@ const geomspace=(a,b,n=abs(b-a)+1,endpoint=true)=>{
         const z2 = new n.constructor(b)
         n=n||Math.abs(z1.a-z2.a)+1;
         let base;
-        endpoint ? base = sqrtn(z2.div(z1),n-1) : base = sqrtn(z2.div(z1),n) ;
+        endpoint ? base = nthr(z2.div(z1),n-1) : base = nthr(z2.div(z1),n) ;
         const Y = [z1];
         for (let i = 1; i < n; i++) {
             Y.push(mul(Y[i-1],base))
@@ -132,10 +72,10 @@ export {
     zeros,
     ones,
     nums,
-    norm,
-    lerp,
-    map,
-    clamp,
+    // norm,
+    // lerp,
+    // map,
+    // clamp,
     arange,
     linspace,
     logspace,

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

@@ -0,0 +1,39 @@
+export const accum_sum = (arr) => {
+  let result = [];
+  let total = 0;
+  for (let x of arr) {
+    total += x;
+    result.push(total);
+  }
+  return result;
+};
+
+export const accum_product = (arr) => {
+  let result = [];
+  let prod = 1;
+  for (let x of arr) {
+    prod *= x;
+    result.push(prod);
+  }
+  return result;
+};
+
+export const accum_max = (arr) => {
+  let result = [];
+  let m = -Infinity;
+  for (let x of arr) {
+    m = Math.max(m, x);
+    result.push(m);
+  }
+  return result;
+};
+
+export const accum_min = (arr) => {
+  let result = [];
+  let m = Infinity;
+  for (let x of arr) {
+    m = Math.min(m, x);
+    result.push(m);
+  }
+  return result;
+};

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,17 @@
+export * from './position/index.js';
+export * from './average/index.js';
+export * from './variability/index.js'
+export * from './rolling/index.js'
+export * from './accum/index.js'
+
+
+    // min
+// max
+
+// mean
+// variance
+// std
+// percentil 
+// accum
+
+//

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;