ziko 0.53.0 → 0.54.1

package/src/math/functions/{primitives → nested}/index.js

@@ -1,4 +1,5 @@
-import { mapfun } from '../../mapfun/index.js';
+import { mapfun } from '../mapfun/index.js';
+import { complex } from '../../complex/index.js'
 
 export const abs = (...x) => mapfun(
     x =>{
@@ -22,7 +23,7 @@ export const pow = (...x) => {
             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
@@ -32,7 +33,8 @@ export const pow = (...x) => {
 export const sqrt = (...x) => mapfun(
     x=>{
         if(x.isComplex?.()) 
-            return new x.constructor({z: x.z**(1/2), phi: x.phi/2})
+            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
@@ -42,16 +44,18 @@ export const cbrt = (...x) => mapfun(
     x=>{
         if(x.isComplex?.()) 
             return new x.constructor({z: x.z**(1/3), phi: x.phi/3})
-        return Math.sqrt(x);
+        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.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
@@ -59,11 +63,20 @@ export const nthr = (...x) => {
 }
 
 export const croot = (...x) =>{
-    const z = x.pop()
+    const c = x.pop()
+    if(!c.isComplex?.()) throw Error('croot expect Complex number as root')
     return mapfun(
         x => {
-            if(x.isComplex?.()) return null
-            return null
+            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
     )
@@ -75,7 +88,7 @@ export const exp = (...x) => mapfun(
             Math.exp(x.a) * Math.cos(x.b),
             Math.exp(x.a) * Math.sin(x.b)
         );
-        return Math.ln(x)
+        return Math.exp(x)
     }
     ,...x
 );
@@ -86,7 +99,7 @@ export const ln = (...x) => mapfun(
             Math.log(x.z),
             x.phi
         );
-        return Math.ln(x)
+        return Math.log(x)
     }
     ,...x
 );
@@ -268,33 +281,33 @@ export const acot = (...x) => mapfun(
 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)
+            Math.cosh(x.a) * Math.cos(x.b),
+            Math.sinh(x.a) * Math.sin(x.b)
         ); 
-        return cosh(x)
+        return Math.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)
+            Math.sinh(x.a) * Math.cos(x.b),
+            Math.cosh(x.a) * Math.sin(x.b)
         ); 
-        return sinh(x)
+        return Math.sinh(x)
     },
     ...x
 )
 export const tanh = (...x) => mapfun(
     x =>{
         if(x?.isComplex){
-            const D=cosh(2*a)+cos(2*b);
+            const D = Math.cosh(2*a) + Math.cos(2*b);
             return new x.constructor(
-                sinh(2*a)/D,
-                sin(2*b)/D
+                Math.sinh(2*a) / D,
+                Math.sin(2*b) / D
             )
         } 
-        return tanh(x)
+        return Math.tanh(x)
     },
     ...x
 )
@@ -349,7 +362,7 @@ export const sig = (...x) => mapfun(
         if(x?.isComplex){
 
         } 
-        return 1/(1+Math.e(-x))
+        return 1/(1+Math.exp(-x))
     },
     ...x
 )

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

@@ -0,0 +1,104 @@
+import { mapfun } from "../mapfun/index.js";
+import { nthr, pow } from "../nested/index.js";
+
+export const zeros = n => new Array(n).fill(0);
+export const ones = n => new Array(n).fill(1);
+export const nums = (n, num) => new Array(n).fill(num);
+
+
+export const arange = (a, b, step, include = false) => {  
+    if(a instanceof Array && typeof b === 'number') return mapfun(x => arange(x, b, step, include), ...a);
+    if(b instanceof Array && typeof a === 'number') return mapfun(x => arange(a, x, step, include), ...b);
+    if(a instanceof Array && b instanceof Array){
+        if(a.length !== b.length) return TypeError('');
+        let res = new Array(a.length).fill(null)
+        return res.map((_, i) => arange(a[i], b[i], step, include))
+    }
+    if(typeof a === 'number' && typeof b === 'number'){
+        const values = [];
+         let i;
+        if(a<b){
+            for (i = a; include ? i<=b : i<b ; i += step) 
+                values.push((i * 10) / 10);
+        }
+        else{
+            for(i = a; include ? i>=b: i>b ; i -= step) 
+                values.push((i * 10) / 10);
+        }
+        return values
+    }
+}
+
+export const linspace = (a, b, n = Math.abs(b-a) + 1, endpoint = true) =>{
+    if(Math.floor(n) !== n) return TypeError('');
+    let c = [a, b].find(n => n.isComplex?.())
+    if(c){
+        let z1 = new c.constructor(a);
+        let z2 = new c.constructor(b)
+        if (!n) n = Math.abs(z1.a - z2.a) + 1;
+        const X = linspace(z1.a, z2.a, n, endpoint);
+        const Y = linspace(z1.a, z2.a, n, endpoint);
+        let Z = new Array(n).fill(null);
+        Z = Z.map((_, i) => new z1.constructor(X[i], Y[i]));
+        return Z;
+    }
+    if(a instanceof Array && typeof b === 'number') return mapfun(x => linspace(x, b, step, include), ...a);
+    if(b instanceof Array && typeof a === 'number') return mapfun(x => linspace(a, x, step, include), ...b);
+    if(a instanceof Array && b instanceof Array){
+        if(a.length !== b.length) return TypeError('');
+        let res = new Array(a.length).fill(null)
+        return res.map((_, i) => linspace(a[i], b[i], step, include))
+    }
+    if(typeof a === 'number' && typeof b === 'number'){
+        const [max, min] = [a, b].sort((a, b) => b-a);
+        let Y = [], step, i;
+        endpoint ? step = (max - min) / (n - 1) : step = (max - min) / n;
+        if(a < b)
+            for(i = 0; i < n; i++)
+                Y.push(+(min + step * i).toFixed(8))
+        else
+            for(i = 0; i < n; i++)
+                Y.push(+(max - step * i).toFixed(8))
+        return Y
+    }
+}
+
+export const logspace = (a, b, n = Math.abs(b-a) + 1, base = Math.E, endpoint = true) => {
+    const ls = linspace(a, b, n, endpoint);
+    return mapfun(x => pow(base, x), ...ls)
+}
+
+export const geomspace = (a, b, n = Math.abs(b-a) + 1, endpoint = true, precison = 8) =>{
+    if(Math.floor(n) !== n) return TypeError('n must be and integer');
+    let c = [a, b].find(n => n.isComplex?.())
+    if(c){
+        let z1 = new c.constructor(a);
+        let z2 = new c.constructor(b);
+        if (!n) n = Math.abs(z1.a - z2.a) + 1;
+        const ratio = nthr(z2.clone().div(z1.clone()), n-1);
+        let i;
+        const Y = [];
+        for(i = 0; i < n; i++){
+            Y[i] = z1.clone().mul(pow(ratio.clone(), i))
+        }
+
+        return Y.map(n => n.toFixed(precison))
+    }
+    if(a instanceof Array && typeof b === 'number') return mapfun(x => geomspace(x, b, n, endpoint, precison), ...a);
+    if(b instanceof Array && typeof a === 'number') return mapfun(x => geomspace(a, x, n, endpoint, precison), ...b);
+    if(a instanceof Array && b instanceof Array){
+        if(a.length !== b.length) return TypeError('');
+        let res = new Array(a.length).fill(null)
+        return res.map((_, i) => geomspace(a[i], b[i], n, endpoint, precison))
+    }
+    if(typeof a === 'number' && typeof b === 'number'){
+        const [max, min]= [a, b].sort((a, b) => b-a);
+        let base = endpoint ? nthr(max/min, n-1) : nthr(max/min, n);
+        const Y = [min];
+        let i;
+        for(i = 1; i < n; i++)
+            Y.push(Y[i-1] * base )
+        const Fixed = Y.map(n => + n.toFixed(precison))
+        return a < b ? Fixed : Fixed.reverse()
+    }
+}

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

@@ -0,0 +1,49 @@
+import {add, mul} from '../arithmetic/index.js';
+
+export const min = (...x) => Math.min(...x);
+export const max = (...x) => Math.max(...x);
+
+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;
+};
+
+export 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); 

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

@@ -0,0 +1,105 @@
+import { mapfun, apply_fun } from "../mapfun/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 norm = (x, min, max) => apply_fun(
+    x, 
+    v => min !== max ? (v - min) / (max - min) : 0
+);
+export const lerp = (x, min, max) => apply_fun(
+    x, 
+    v => (max - min) * v + min
+);
+export const clamp = (x, min, max) => apply_fun(
+    x, 
+    v => Math.min(Math.max(v, min), max)
+);
+export const map = (x, a, b, c, d) => apply_fun(
+    x, 
+    v => lerp(norm(v, a, b), c, d)
+);
+
+
+// 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)
+//     );
+//     if(x instanceof Array) return mapfun(n => norm(n, min, max), ...x);
+//     return min !== max ? (x - 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)
+//     );
+//     if(x instanceof Array) return mapfun(n => lerp(n, min, max), ...x);
+//     return (max - min) * x + min;
+// }
+
+// export const map = (x, a, b, c, d) => {
+//     if(x.isComplex?.()) return new x.constructor(
+//         map(x.a, a, b, c, d),
+//         map(x.b, a, b, c, d)
+//     )
+//     if(x.isMatrix?.()) return new x.constructor(
+//         x.rows, 
+//         x.cols, 
+//         map(x.arr.flat(1), a, b, c, d)
+//     );
+//     if(x instanceof Array) return mapfun(n => map(n, a, b, c, d), ...x);
+//     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)
+//     );
+//     if(x instanceof Array) return mapfun(n => clamp(n, min, max), ...x);
+//     return Math.min(Math.max(x, 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 = (y, x, rad = true) => {
+    if (y instanceof Array && !(x instanceof Array))
+        return mapfun(n => atan2(n, x, rad), ...y);
+
+    if (x instanceof Array && !(y instanceof Array))
+        return mapfun(n => atan2(y, n, rad), ...x);
+
+    if (y instanceof Array && x instanceof Array)
+        return y.map((v, i) => atan2(v, x[i], rad));
+
+    const phi = Math.atan2(y, x);
+    return rad ? phi : phi * 180 / Math.PI;
+}
+
+

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/statistics/functions/index.js

@@ -29,36 +29,36 @@ const prod=(...x)=>{
     }
     return Y.length===1?Y[0]:Y;
 }
-const min=(...num)=>{
-    if(num.every(n=>typeof n==="number"))return Math.min(...num);
-    const Y=[];
-    for(let i=0;i<num.length;i++){
-        if(num[i] instanceof Array)Y.push(min(...num[i]));
-        else if(num[i] instanceof Object){
-            Y.push(
-                    Object.fromEntries(
-                        [Object.entries(num[i]).sort((a,b)=>a[1]-b[1])[0]]
-                    )
-                )
-        }
-    }
-    return Y.length===1?Y[0]:Y;
-}
-const max=(...num)=>{
-    if(num.every(n=>typeof n==="number"))return Math.max(...num);
-    const Y=[];
-    for(let i=0;i<num.length;i++){
-        if(num[i] instanceof Array)Y.push(min(...num[i]));
-        else if(num[i] instanceof Object){
-            Y.push(
-                    Object.fromEntries(
-                        [Object.entries(num[i]).sort((a,b)=>b[1]-a[1])[0]]
-                    )
-                )
-        }
-    }
-    return Y.length===1?Y[0]:Y;
-}
+// const min=(...num)=>{
+//     if(num.every(n=>typeof n==="number"))return Math.min(...num);
+//     const Y=[];
+//     for(let i=0;i<num.length;i++){
+//         if(num[i] instanceof Array)Y.push(min(...num[i]));
+//         else if(num[i] instanceof Object){
+//             Y.push(
+//                     Object.fromEntries(
+//                         [Object.entries(num[i]).sort((a,b)=>a[1]-b[1])[0]]
+//                     )
+//                 )
+//         }
+//     }
+//     return Y.length===1?Y[0]:Y;
+// }
+// const max=(...num)=>{
+//     if(num.every(n=>typeof n==="number"))return Math.max(...num);
+//     const Y=[];
+//     for(let i=0;i<num.length;i++){
+//         if(num[i] instanceof Array)Y.push(min(...num[i]));
+//         else if(num[i] instanceof Object){
+//             Y.push(
+//                     Object.fromEntries(
+//                         [Object.entries(num[i]).sort((a,b)=>b[1]-a[1])[0]]
+//                     )
+//                 )
+//         }
+//     }
+//     return Y.length===1?Y[0]:Y;
+// }
 const accum=(...num)=>{
     if(num.every(n=>typeof n==="number")){
         let acc = num.reduce((x, y) => [...x, x[x.length - 1] + y], [0]);
@@ -84,8 +84,8 @@ const accum=(...num)=>{
 export{
     sum,
     prod,
-    min,
-    max,
+    // min,
+    // max,
     accum
 }
 

package/src/math/statistics/index.js

@@ -1,15 +1,15 @@
 import {
     sum,
     prod,
-    min,
-    max,
+    // min,
+    // max,
     accum
 } from "./functions/index.js"
 const Stats={
     sum,
     prod,
-    min,
-    max,
+    // min,
+    // max,
     accum,
 }
 export default Stats;

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;
+};