ziko 0.54.0 → 0.54.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ziko",
-  "version": "0.54.0",
+  "version": "0.54.2",
   "description": "A versatile JavaScript library offering a rich set of Hyperscript Based UI components, advanced mathematical utilities, interactivity ,animations, client side routing and more ...",
   "keywords": [
     "front-end",

package/src/data/converter/csv.js

@@ -1,4 +1,4 @@
-import { Matrix } from "../../math/matrix/matrix.js"
+import { Matrix } from "../../math/matrix/index.js"
 const csv2arr = (csv, delimiter = ",")=>csv.trim().trimEnd().split("\n").map(n=>n.split(delimiter));
 const csv2matrix = (csv, delimiter = ",")=>new Matrix(csv2arr(csv,delimiter));
 const csv2object = (csv, delimiter = ",") => {

package/src/math/complex/index.js

@@ -55,7 +55,16 @@ class Complex{
             : (str = `-${Math.abs(this.b)}*i`);
         return str;
     }
-      
+    toFixed(n){
+        this.a = + this.a.toFixed(n);
+        this.b = + this.b.toFixed(n);
+        return this; 
+    }  
+    toPrecision(n){
+        this.a = + this.a.toPrecision(n);
+        this.b = + this.b.toPrecision(n);
+        return this; 
+    }  
     clone() {
         return new Complex(this.a, this.b);
     }
@@ -68,6 +77,13 @@ class Complex{
     static Zero() {
         return new Complex(0, 0);
     }
+    static Twidlle(N, K){
+        const phi = -2 * Math.PI * K / N;
+        return new Complex(
+            Math.cos(phi), 
+            Math.sin(phi)
+        );
+    }
     get conj() {
         return new Complex(this.a, -this.b);
     }
@@ -98,22 +114,22 @@ class Complex{
         for (let i = 0; i < c.length; i++) {
             if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
             z *= c[i].z;
-            phi += c[i].z;
+            phi += c[i].phi;
         }
-        this.a = z*Math.cos(phi)
-        this.b = z*Math.sin(phi)  
-        return this;
+        this.a = z * Math.cos(phi)
+        this.b = z * Math.sin(phi)  
+        return this.toFixed(8);
     }
     div(...c){
         let {z, phi} = this;
         for (let i = 0; i < c.length; i++) {
             if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
             z /= c[i].z;
-            phi -= c[i].z;
+            phi -= c[i].phi;
         }
-        this.a = z*Math.cos(phi)
-        this.b = z*Math.sin(phi)  
-        return this;
+        this.a = z * Math.cos(phi)
+        this.b = z * Math.sin(phi)  
+        return this.toFixed(8);;
     }
     modulo(...c) {
         for (let i = 0; i < c.length; i++) {
@@ -123,6 +139,17 @@ class Complex{
         }
         return this;
     }
+    pow(...c){
+        let {z, phi} = this;
+        for (let i = 0; i < c.length; i++) {
+            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
+            z *= Math.exp(c[i].a * Math.log(z) - c[i].b * phi);
+            phi += c[i].b * Math.log(z) + c[i].a * phi;
+        }
+        this.a = z * Math.cos(phi)
+        this.b = z * Math.sin(phi)  
+        return this;
+    }
     static fromExpo(z, phi) {
         return new Complex(
             +(z * cos(phi)).toFixed(13), 

package/src/math/discret/Conversion/index.js

@@ -1,5 +1,5 @@
 import { Complex } from "../../complex/index.js";
-import { Matrix } from "../../matrix/matrix.js";
+import { Matrix } from "../../matrix/index.js";
 const Base={
     _mode:Number,
     _map:function(func,number,toBase){

package/src/math/discret/Logic/index.js

@@ -1,5 +1,5 @@
 import { Complex } from "../../complex/index.js";
-import { Matrix } from "../../matrix/matrix.js";
+import { Matrix } from "../../matrix/index.js";
 const Logic={
     _mode:Number,
     _map:function(func,a,b){

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

@@ -6,7 +6,7 @@ const _add = (x, y) =>{
         }
     }
     if(x.isComplex?.()){
-        if(typeof y === 'number' || y.isComplex?.()) return new x.clone().add(y);
+        if(typeof y === 'number' || y.isComplex?.()) return x.clone().add(y);
     }
 }
 
@@ -16,7 +16,7 @@ const _sub = (x, y) =>{
         if(y.isComplex?.()) return new y.constructor(x - y.a, y.b);
     }
     if(x.isComplex?.()){
-        if(typeof y === 'number' || y.isComplex?.()) return new x.clone().sub(y);
+        if(typeof y === 'number' || y.isComplex?.()) return x.clone().sub(y);
     }
 }
 
@@ -26,7 +26,7 @@ const _mul = (x, y) =>{
         if(y.isComplex?.()) return y.clone().mul(x);
     }
     if(x.isComplex?.()){
-        if(typeof y === 'number' || y.isComplex?.()) return new x.clone().mul(y);
+        if(typeof y === 'number' || y.isComplex?.()) return x.clone().mul(y);
     }
 }
 
@@ -36,7 +36,7 @@ const _div = (x, y) =>{
         if(y.isComplex?.()) return new y.constructor(x, 0).div(y)
     }
     if(x.isComplex?.()){
-        if(typeof y === 'number' || y.isComplex?.()) return new x.clone().mul(y);
+        if(typeof y === 'number' || y.isComplex?.()) return x.clone().mul(y);
     }
 }
 
@@ -46,7 +46,7 @@ const _modulo = (x, y) =>{
         if(y.isComplex?.()) return new y.constructor(x, 0).modulo(y)
     }
     if(x.isComplex?.()){
-        if(typeof y === 'number' || y.isComplex?.()) return new x.clone().modulo(y);
+        if(typeof y === 'number' || y.isComplex?.()) return x.clone().modulo(y);
     }
 }
 

package/src/math/functions/index.js

@@ -2,6 +2,7 @@ export * from './mapfun/index.js'
 export * from './nested/index.js'
 export * from './arithmetic/index.js'
 export * from './utils/index.js'
+export * from './stats/index.js'
 // export const atan2=(x,y,rad=true)=>{
 //     if(typeof x === "number"){
 //         if(typeof y === "number")return rad?Math.atan2(x,y):Math.atan2(x,y)*180/Math.PI;

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

@@ -17,3 +17,17 @@ export const mapfun=(fun,...X)=>{
     });
    return Y.length==1? Y[0]: Y; 
 }
+
+export const apply_fun = (x, fn) => {
+    if (x.isComplex?.()) return new x.constructor(
+        fn(x.a),
+        fn(x.b)
+    )
+    if (x.isMatrix?.()) return new x.constructor(
+        x.rows,
+        x.cols,
+        x.arr.flat(1).map(fn)
+    )
+    if (x instanceof Array) mapfun(fn, ...x)
+    return fn(x)
+}

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

@@ -1,8 +1,7 @@
 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);
+const PRECESION = 8
 
 export const abs = (...x) => mapfun(
     x =>{
@@ -37,8 +36,8 @@ 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);
+        if(x < 0) return complex(0, Math.sqrt(-x)).toFixed(PRECESION)
+        return + Math.sqrt(x).toFixed(PRECESION);
     },
     ...x
 );
@@ -46,8 +45,8 @@ export const sqrt = (...x) => mapfun(
 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);
+            return new x.constructor({z: x.z**(1/3), phi: x.phi/3}).toFixed(PRECESION)
+        return + Math.cbrt(x).toFixed(PRECESION);
     },
     ...x
 );
@@ -58,8 +57,10 @@ export const nthr = (...x) => {
     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)
+            if(x<0) return n %2 ===2 
+                ? complex(0, (-x)**(1/n)).toFixed(PRECESION)
+                : + (-1 * (-x)**(1/n)).toFixed(PRECESION)                
+            return + (x**(1/n)).toFixed(PRECESION)
         },
         ...x
     )
@@ -79,7 +80,7 @@ export const croot = (...x) =>{
             return new c.constructor(
                 A * Math.cos(B),
                 A * Math.sin(B)
-            )
+            ).toFixed(PRECESION)
         },
         ...x
     )
@@ -90,8 +91,8 @@ export const exp = (...x) => mapfun(
         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)
+        ).toFixed(PRECESION);
+        return + Math.exp(x).toFixed(PRECESION)
     }
     ,...x
 );
@@ -101,8 +102,8 @@ export const ln = (...x) => mapfun(
         if(x.isComplex?.()) return new x.constructor(
             Math.log(x.z),
             x.phi
-        );
-        return Math.log(x)
+        ).toFixed(PRECESION);
+        return + Math.log(x).toFixed(PRECESION)
     }
     ,...x
 );
@@ -177,8 +178,8 @@ export const cos = (...x) => mapfun(
         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)
+        ).toFixed(PRECESION);
+        return + Math.cos(x).toFixed(PRECESION)
     }
     ,...x
 );
@@ -188,8 +189,8 @@ export const sin = (...x) => mapfun(
         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)
+        ).toFixed(PRECESION);
+        return + Math.sin(x).toFixed(PRECESION)
     }
     , ...x
 );
@@ -201,9 +202,9 @@ export const tan = (...x) => mapfun(
             return new x.constructor(
                 Math.sin(2*x.a) / D,
                 Math.sinh(2*x.b) / D
-            );
+            ).toFixed(PRECESION);
         } 
-        return Math.tan(x) 
+        return + Math.tan(x).toFixed(PRECESION)
     },
     ...x
 );
@@ -213,7 +214,7 @@ export const sec = (...x) => mapfun(
         if(x.isComplex?.()) {
 
         }
-        return 1 / Math.cos(x)
+        return + (1 / Math.cos(x)).toFixed(PRECESION)
     }
     ,...x
 );
@@ -229,9 +230,9 @@ export const acos = (...x) => mapfun(
             return new x.constructor(
                 Math.acos((Rp - Rm) / 2),
                 -Math.acosh((Rp + Rm) / 2),
-            )
+            ).toFixed(PRECESION)
         } 
-        return Math.acos(x) 
+        return + Math.acos(x).toFixed(PRECESION) 
     },
     ...x
 );
@@ -245,9 +246,9 @@ export const asin = (...x) => mapfun(
             return new x.constructor(
                 Math.asin((Rp - Rm) / 2), 
                 Math.acosh((Rp + Rm) / 2)
-            );
+            ).toFixed(PRECESION);
         }
-        return Math.asin(x);
+        return + Math.asin(x).toFixed(PRECESION);
     },
     ...x
 );
@@ -259,9 +260,9 @@ export const atan = (...x) => mapfun(
             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
-            )
+            ).toFixed(PRECESION)
         }
-        return Math.atan(x);
+        return + Math.atan(x).toFixed(PRECESION);
     },
     ...x
 );
@@ -273,9 +274,9 @@ export const acot = (...x) => mapfun(
             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   
-            )
+            ).toFixed(PRECESION)
         }
-        return Math.PI/2 - Math.atan(x);
+        return + (Math.PI/2 - Math.atan(x)).toFixed(PRECESION);
     },
     ...x
 );
@@ -286,8 +287,8 @@ export const cosh = (...x) => mapfun(
         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)
+        ).toFixed(PRECESION); 
+        return + Math.cosh(x).toFixed(PRECESION)
     },
     ...x
 )
@@ -296,8 +297,8 @@ export const sinh = (...x) => mapfun(
         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)
+        ).toFixed(PRECESION); 
+        return + Math.sinh(x).toFixed(PRECESION)
     },
     ...x
 )
@@ -308,9 +309,9 @@ export const tanh = (...x) => mapfun(
             return new x.constructor(
                 Math.sinh(2*a) / D,
                 Math.sin(2*b) / D
-            )
+            ).toFixed(PRECESION)
         } 
-        return Math.tanh(x)
+        return + Math.tanh(x).toFixed(PRECESION)
     },
     ...x
 )
@@ -323,9 +324,9 @@ export const coth = (...x) => mapfun(
             return new x.constructor(
                 Math.cosh(a) * Math.sinh(a) / D,
                 - Math.sin(b) * Math.cos(b) / D
-            )
+            ).toFixed(PRECESION)
         } 
-        return 1/Math.tanh(x)
+        return + (1 / Math.tanh(x)).toFixed(PRECESION)
     },
     ...x
 )
@@ -335,7 +336,7 @@ export const acosh = (...x) => mapfun(
         if(x?.isComplex){
             return ln(x.clone().add(sqrt(x.clone().mul(x.clone()).sub(1))))
         } 
-        return Math.acosh(x)
+        return + Math.acosh(x).toFixed(PRECESION)
     },
     ...x
 )
@@ -345,7 +346,7 @@ export const asinh = (...x) => mapfun(
         if(x?.isComplex){
             return ln(x.clone().add(sqrt(x.clone().mul(x.clone()).add(1))))
         } 
-        return Math.asinh(x)
+        return + Math.asinh(x).toFixed(PRECESION)
     },
     ...x
 )
@@ -355,7 +356,7 @@ export const atanh = (...x) => mapfun(
         if(x?.isComplex){
 
         } 
-        return Math.atanh(x)
+        return + Math.atanh(x).toFixed(PRECESION)
     },
     ...x
 )
@@ -365,7 +366,7 @@ export const sig = (...x) => mapfun(
         if(x?.isComplex){
 
         } 
-        return 1/(1+Math.exp(-x))
+        return + 1/(1 + Math.exp(-x)).toFixed(PRECESION)
     },
     ...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);