ziko 0.52.0 → 0.54.0

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

@@ -0,0 +1,371 @@
+import { mapfun } from '../mapfun/index.js';
+import { complex } from '../../complex/index.js'
+
+export const deg2rad = (...deg) => mapfun(x => x * Math.PI / 180, ...deg);
+export const rad2deg = (...rad) => mapfun(x => x / Math.PI * 180, ...rad);
+
+export const abs = (...x) => mapfun(
+    x =>{
+        if(x.isComplex?.()) return x.z;
+        return Math.abs(x)
+    },
+    ...x
+)
+
+export const pow = (...x) => {
+    const n = x.pop();
+    return mapfun(
+        x => {
+            if(x.isComplex?.()) {
+                if(n.isComplex?.()) return new x.constructor({
+                    z: Math.exp(n.a * Math.log(x.z) - n.b * x.phi),
+                    phi: n.b * Math.log(x.z) + n.a * x.phi
+                })
+                return new x.constructor({z: x.z ** n, phi: x.phi * n});
+            }
+            if(n.isComplex?.()) return new x.constructor({
+                    z: Math.exp(n.a * Math.log(x)),
+                    phi: n.b * Math.log(x)
+            })
+            return Math.pow(x, n)
+        },
+        ...x
+    )
+}
+
+export const sqrt = (...x) => mapfun(
+    x=>{
+        if(x.isComplex?.()) 
+            return new x.constructor({z: x.z**(1/2), phi: x.phi/2});
+        if(x < 0) return complex(0, Math.sqrt(-x)) 
+        return Math.sqrt(x);
+    },
+    ...x
+);
+
+export const cbrt = (...x) => mapfun(
+    x=>{
+        if(x.isComplex?.()) 
+            return new x.constructor({z: x.z**(1/3), phi: x.phi/3})
+        return Math.cbrt(x);
+    },
+    ...x
+);
+
+export const nthr = (...x) => {
+    const n = x.pop();
+    if(typeof n !== 'number') throw Error('nthr expects a real number n');
+    return mapfun(
+        x => {
+            if(x.isComplex?.()) return new x.constructor({z: x.z ** (1/n), phi: x.phi / n});
+            if(x<0) return n%2===2 ? complex(0, (-x)**(1/n)) : -1 * (-x)**(1/n)                
+            return x**(1/n)
+        },
+        ...x
+    )
+}
+
+export const croot = (...x) =>{
+    const c = x.pop()
+    if(!c.isComplex?.()) throw Error('croot expect Complex number as root')
+    return mapfun(
+        x => {
+            if(typeof x === 'number') x = new c.constructor(x, 0);
+            const {a : c_a, b : c_b} = c;
+            const {z, phi} = x;
+            const D = Math.hypot(c_a, c_b);
+            const A = Math.exp((Math.log(z)*c_a + phi*c_b)/D);
+            const B = (phi*c_a - Math.log(z)*c_b)/D
+            return new c.constructor(
+                A * Math.cos(B),
+                A * Math.sin(B)
+            )
+        },
+        ...x
+    )
+}
+
+export const exp = (...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.exp(x)
+    }
+    ,...x
+);
+
+export const ln = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.log(x.z),
+            x.phi
+        );
+        return Math.log(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 floor = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.floor(x.a),
+            Math.floor(x.b)
+        )
+        return Math.floor(x)
+    },
+    ...x
+)
+export const ceil = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.ceil(x.a),
+            Math.ceil(x.b)
+        )
+        return Math.ceil(x)
+    },
+    ...x
+)
+export const round = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.round(x.a),
+            Math.round(x.b)
+        )
+        return Math.round(x)
+    },
+    ...x
+)
+
+export const trunc = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.trunc(x.a),
+            Math.trunc(x.b)
+        )
+        return Math.trunc(x)
+    },
+    ...x
+)
+
+export const fract = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            x.a - Math.trunc(x.a),
+            x.b - Math.trunc(x.b)
+        )
+        return x - Math.trunc(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 D = Math.cos(2*x.a) + Math.cosh(2*x.b);
+            return new x.constructor(
+                Math.sin(2*x.a) / D,
+                Math.sinh(2*x.b) / D
+            );
+        } 
+        return Math.tan(x) 
+    },
+    ...x
+);
+
+export const sec = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) {
+
+        }
+        return 1 / Math.cos(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
+            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 acot = (...x) => mapfun(
+    x => {
+        if(x?.isComplex){
+            const { a, b } = x;
+            return new x.constructor(
+                Math.atan(2*a/(a**2+(b-1)*(b+1)))/2,
+                Math.log((a**2 + (b-1)**2)/(a**2 + (b+1)**2))/4   
+            )
+        }
+        return Math.PI/2 - Math.atan(x);
+    },
+    ...x
+);
+
+
+export const cosh = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex) return new x.constructor(
+            Math.cosh(x.a) * Math.cos(x.b),
+            Math.sinh(x.a) * Math.sin(x.b)
+        ); 
+        return Math.cosh(x)
+    },
+    ...x
+)
+export const sinh = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex) return new x.constructor(
+            Math.sinh(x.a) * Math.cos(x.b),
+            Math.cosh(x.a) * Math.sin(x.b)
+        ); 
+        return Math.sinh(x)
+    },
+    ...x
+)
+export const tanh = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            const D = Math.cosh(2*a) + Math.cos(2*b);
+            return new x.constructor(
+                Math.sinh(2*a) / D,
+                Math.sin(2*b) / D
+            )
+        } 
+        return Math.tanh(x)
+    },
+    ...x
+)
+
+export const coth = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            const {a, b} = x
+            const D = (Math.sinh(a)**2)*(Math.cos(b)**2) + (Math.cosh(a)**2)*(Math.sin(b)**2) 
+            return new x.constructor(
+                Math.cosh(a) * Math.sinh(a) / D,
+                - Math.sin(b) * Math.cos(b) / D
+            )
+        } 
+        return 1/Math.tanh(x)
+    },
+    ...x
+)
+
+export const acosh = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            return ln(x.clone().add(sqrt(x.clone().mul(x.clone()).sub(1))))
+        } 
+        return Math.acosh(x)
+    },
+    ...x
+)
+
+export const asinh = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            return ln(x.clone().add(sqrt(x.clone().mul(x.clone()).add(1))))
+        } 
+        return Math.asinh(x)
+    },
+    ...x
+)
+
+export const atanh = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+
+        } 
+        return Math.atanh(x)
+    },
+    ...x
+)
+
+export const sig = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+
+        } 
+        return 1/(1+Math.exp(-x))
+    },
+    ...x
+)

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
+
+//