ziko 0.53.0 → 0.54.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ziko",
-  "version": "0.53.0",
+  "version": "0.54.0",
   "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/math/complex/index.js

@@ -1,18 +1,5 @@
-import{
-    cos,
-    sin,
-    tan,
-    pow,
-    floor,
-    hypot,
-    cosh,
-    sinh,
-    sqrtn,
-    atan2,
-    sqrt,
-    ln
-  }from "../functions/index.js"
-import {sum,prod,deg2rad} from "../utils/index.js";
+// import {sum,prod,deg2rad} from "../utils/index.js";
+// Should avoid CD
 class Complex{
     constructor(a = 0, b = 0) {
         if(a instanceof Complex){
@@ -21,33 +8,33 @@ class Complex{
         }
         else if(typeof(a)==="object"){
             if(("a" in a && "b" in a)){
-                this.a=a.a;
-                this.b=a.b;
+                this.a = a.a;
+                this.b = a.b;
             }
             else if(("a" in a && "z" in a)){
-                this.a=a.a;
-                this.b=sqrt((a.z**2)-(a.a**2));
+                this.a = a.a;
+                this.b = Math.sqrt((a.z**2)-(a.a**2));
             }
             else if(("a" in a && "phi" in a)){
-                this.a=a.a;
-                this.b=a.a*tan(a.phi);
+                this.a = a.a;
+                this.b = a.a * Math.tan(a.phi);
             }
             else if(("b" in a && "z" in a)){
-                this.b=a.b;
-                this.a=sqrt((a.z**2)-(a.b**2));
+                this.b = a.b;
+                this.a = Math.sqrt((a.z**2)-(a.b**2));
             }
             else if(("b" in a && "phi" in a)){
-                this.b=b;
-                this.a=a.b/tan(a.phi);
+                this.b = b;
+                this.a = a.b / Math.tan(a.phi);
             }
             else if(("z" in a && "phi" in a)){
-                this.a = +a.z*cos(a.phi).toFixed(15);
-                this.b = +a.z*sin(a.phi).toFixed(15);
+                this.a = + a.z * Math.cos(a.phi).toFixed(15);
+                this.b = + a.z * Math.sin(a.phi).toFixed(15);
             }
         }
-        else if(typeof(a)==="number"&&typeof(b)==="number"){
-            this.a = +a.toFixed(32);
-            this.b = +b.toFixed(32);
+        else if(typeof(a)==="number" && typeof(b)==="number"){
+            this.a = + a.toFixed(32);
+            this.b = + b.toFixed(32);
         }
     }
     get __mapfun__(){
@@ -73,10 +60,10 @@ class Complex{
         return new Complex(this.a, this.b);
     }
     get z(){
-        return hypot(this.a,this.b);    
+        return Math.hypot(this.a,this.b);    
     }
     get phi(){
-        return atan2(this.b , this.a);        
+        return Math.atan2(this.b , this.a);        
     }
     static Zero() {
         return new Complex(0, 0);
@@ -85,54 +72,54 @@ class Complex{
         return new Complex(this.a, -this.b);
     }
     get inv() {
-        return new Complex(this.a / (pow(this.a, 2) + pow(this.b, 2)), -this.b / (pow(this.a, 2) + pow(this.b, 2)));
-    }
-    add(...z) {
-        for (let i = 0; i < z.length; i++) {
-            if (typeof z[i] === "number") z[i] = new Complex(z[i], 0);
+        return new Complex(
+            this.a / Math.hypot(this.a, this.b),
+            -this.b / Math.hypot(this.a, this.b)
+        );
+    }
+    add(...c) {
+        for (let i = 0; i < c.length; i++) {
+            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
+            this.a += c[i].a;
+            this.b += c[i].b;
         }
-        let re = z.map((n) => n.a);
-        let im = z.map((n) => n.b);
-        this.a+=+sum(...re).toFixed(15);
-        this.b+=+sum(...im).toFixed(15);
         return this;
     }
-    sub(...z) {
-        for (let i = 0; i < z.length; i++) {
-            if (typeof z[i] === "number") z[i] = new Complex(z[i], 0);
+    sub(...c) {
+        for (let i = 0; i < c.length; i++) {
+            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
+            this.a -= c[i].a;
+            this.b -= c[i].b;
         }
-        let re = z.map((n) => n.a);
-        let im = z.map((n) => n.b);
-        this.a-=+sum(...re).toFixed(15);
-        this.b-=+sum(...im).toFixed(15);
         return this;
     }
-    mul(...z){
-        for (let i = 0; i < z.length; i++) {
-            if (typeof z[i] === "number") z[i] = new Complex(z[i], 0);
+    mul(...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;
         }
-        let Z=+prod(this.z,...z.map(n=>n.z)).toFixed(15);
-        let phi=+sum(this.phi,...z.map(n=>n.phi)).toFixed(15);
-        this.a=+(Z*cos(phi).toFixed(15)).toFixed(14);
-        this.b=+(Z*sin(phi).toFixed(15)).toFixed(14);    
+        this.a = z*Math.cos(phi)
+        this.b = z*Math.sin(phi)  
         return this;
     }
-    div(...z) {
-        for (let i = 0; i < z.length; i++) {
-            if (typeof z[i] === "number") z[i] = new Complex(z[i], 0);
+    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;
         }
-        let Z=+(this.z/prod(...z.map(n=>n.z))).toFixed(15);
-        let phi=+(this.phi-sum(...z.map(n=>n.phi))).toFixed(15);
-        this.a=+(Z*cos(phi).toFixed(15)).toFixed(15);
-        this.b=+(Z*sin(phi).toFixed(15)).toFixed(15);
+        this.a = z*Math.cos(phi)
+        this.b = z*Math.sin(phi)  
         return this;
     }
-    pow(n) {
-        if (floor(n) === n && n > 0) {
-            let z=+(this.z**n).toFixed(15);
-            let phi=+(this.phi*n).toFixed(15);
-            this.a=+(z*cos(phi).toFixed(15)).toFixed(15);
-            this.b=+(z*sin(phi).toFixed(15)).toFixed(15);
+    modulo(...c) {
+        for (let i = 0; i < c.length; i++) {
+            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
+            this.a %= c[i].a;
+            this.b %= c[i].b;
         }
         return this;
     }
@@ -157,30 +144,37 @@ class Complex{
     static div(c,...z) {
         return c.clone().div(...z);
     }
-    static pow(z,n){
-        return z.clone().pow(n);
-    }
-    static xpowZ(x){
-        return complex((x**this.a)*cos(this.b*ln(x)),(x**this.a)*sin(this.b*ln(x)));
-    }
-    sqrtn(n=2){
-        return complex(sqrtn(this.z,n)*cos(this.phi/n),sqrtn(this.z,n)*sin(this.phi/n));
+
+    nthr(n=2){
+        return complex({z: this.z ** (1/n), phi: this.phi / n});
     }
     get sqrt(){
-        return this.sqrtn(2);
+        return this.nrth(2);
+    }
+    get cbrt(){
+        return this.nrth(3);
     }
     get log(){
-        return complex(this.z,this.phi);
+        return complex(this.z, this.phi);
     }
     get cos(){
-        return complex(cos(this.a)*cosh(this.b),sin(this.a)*sinh(this.b))
+        return complex(
+            Math.cos(this.a) * Math.cosh(this.b),
+            Math.sin(this.a) * Math.sinh(this.b)
+        )
     }
     get sin(){
-        return complex(sin(this.a)*cosh(this.b),cos(this.a)*sinh(this.b))
+        return complex(
+            Math.sin(this.a) * Math.cosh(this.b),
+            Math.cos(this.a) * Math.sinh(this.b)
+        )
     }
     get tan(){
-        const de=cos(this.a*2)+cosh(this.b*2);
-        return complex(sin(2*this.a)/de,sinh(2*this.b)/de);
+        const D=cos(this.a*2)+cosh(this.b*2);
+        return complex(
+            Math.sin(2 * this.a) / D,
+            Math.sinh(2 * this.b) / D
+        );
     }
 }
 const complex=(a,b)=>{

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

@@ -0,0 +1,82 @@
+const _add = (x, y) =>{
+    if(typeof x === 'number'){
+        if(typeof y === 'number') return x + y;
+        if(y.isComplex?.()) {
+            return y.clone().add(x);
+        }
+    }
+    if(x.isComplex?.()){
+        if(typeof y === 'number' || y.isComplex?.()) return new x.clone().add(y);
+    }
+}
+
+const _sub = (x, y) =>{
+    if(typeof x === 'number'){
+        if(typeof y === 'number') return 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);
+    }
+}
+
+const _mul = (x, y) =>{
+    if(typeof x === 'number'){
+        if(typeof y === 'number') return 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);
+    }
+}
+
+const _div = (x, y) =>{
+    if(typeof x === 'number'){
+        if(typeof y === 'number') return 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);
+    }
+}
+
+const _modulo = (x, y) =>{
+    if(typeof x === 'number'){
+        if(typeof y === 'number') return 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);
+    }
+}
+
+export const add=(a,...b)=>{
+    let res = a;
+    for(let i=0; i<b.length; i++)
+        res = _add(res, b[i])
+    return res;
+}
+export const sub=(a,...b)=>{
+    let res = a;
+    for(let i=0; i<b.length; i++)
+        res = _sub(res, b[i])
+    return res;
+}
+export const mul=(a,...b)=>{
+    let res = a;
+    for(let i=0; i<b.length; i++)
+        res = _mul(res, b[i])
+    return res;
+}
+export const div=(a,...b)=>{
+    let res = a;
+    for(let i=0; i<b.length; i++)
+        res = _div(res, b[i])
+    return res;
+}
+export const modulo=(a,...b)=>{
+    let res = a;
+    for(let i=0; i<b.length; i++)
+        res = _modulo(res, b[i])
+    return res;
+}

package/src/math/functions/index.js

@@ -1,155 +1,41 @@
-import { Fixed } from "./helper.js";
-import { mapfun } from "../mapfun/index.js";
-import { 
-    min,
-    max 
-}
-from "../statistics/index.js";
+export * from './mapfun/index.js'
+export * from './nested/index.js'
+export * from './arithmetic/index.js'
+export * from './utils/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;
+//         else return mapfun(a=>atan2(x,a,rad),...y);
+//     }
+//     // else if(x.isComplex?.()){
+//     //     if(typeof n === "number")return x.constructor.fromExpo(x.z**n,x.phi*n);
+//     //     else return mapfun(a=>pow(x,a),...n);
+//     // }
+//     else if(x instanceof Array){
+//         if(typeof y === "number") return mapfun(a=>atan2(a,y,rad),...x);
+//         else if(y instanceof Array){
+//             const Y=[];
+//             for(let i=0;i<x.length;i++){
+//                 Y.push(mapfun(a=>pow(x[i],a,rad),...y))
+//             }
+//             return Y;
+//         }
+//     }
+// }
+// export const fact=(...x)=>mapfun(n=> {
+//         let i,
+//         y = 1;
+//         if (n == 0) y = 1;
+//         else if (n > 0) for (i = 1; i <= n; i++) y *= i;
+//         else y = NaN;
+//         return y;
+//     },...x);
 
-const abs=(...x)=>mapfun(Math.abs,...x);
-const sqrt=(...x)=>mapfun(Math.sqrt,...x);
-const pow=(x,n)=>{
-    if(typeof x === "number"){
-        if(typeof n === "number")return Math.pow(x,n);
-        else if(n?.isComplex?.())return n.constructor.fromExpo(x**n.a,n.b*ln(x))
-        else return mapfun(a=>pow(x,a),...n);
-    }
-    else if(x.isComplex?.()){
-        if(typeof n === "number")return x.constructor.fromExpo(x.z**n,x.phi*n);
-        else if(n.isComplex?.())return x.constructor.fromExpo(
-            x.z**n.a*e(-x.phi*n.b),
-            ln(x.z)*n.b+n.a*x.phi
-        )
-        else return mapfun(a=>pow(x,a),...n);
-    }
-    else if(x instanceof Array){
-        if(typeof n === "number") return mapfun(a=>pow(a,n),...x);
-        else if(n instanceof Array){
-            const Y=[];
-            for(let i=0;i<x.length;i++){
-                Y.push(mapfun(a=>pow(x[i],a),...n))
-            }
-            return Y;
-        }
-    }
-}
-const sqrtn=(x,n)=>{
-    if(typeof x === "number"){
-        if(typeof n === "number")return Math.pow(x,1/n);
-        else return mapfun(a=>sqrtn(x,a),...n);
-    }
-    else if(x.isComplex?.()){
-        if(typeof n === "number")return x.constructor.fromExpo(sqrtn(x.z,n),x.phi/n);
-        else return mapfun(a=>sqrtn(x,a),...n);
-    }
-    else if(x instanceof Array){
-        if(typeof n === "number") return mapfun(a=>sqrtn(a,n),...x);
-        else if(n instanceof Array){
-            const Y=[];
-            for(let i=0;i<x.length;i++){
-                Y.push(mapfun(a=>sqrtn(x[i],a),...n))
-            }
-            return Y;
-        }
-    }
-}
-const e=(...x) => mapfun(Math.exp,...x);
-const ln=(...x) => mapfun(Math.log,...x);
-const cos=(...x) => mapfun(Fixed.cos,...x);
-const sin=(...x) => mapfun(Fixed.sin,...x);
-const tan=(...x) => mapfun(Fixed.tan,...x);
-const sec=(...x) => mapfun(Fixed.sec,...x);
-const sinc=(...x) => mapfun(Fixed.sinc,...x)
-const csc=(...x) => mapfun(Fixed.csc,...x);
-const cot=(...x) => mapfun(Fixed.cot,...x);
-const acos=(...x) => mapfun(Fixed.acos,...x);
-const asin=(...x) => mapfun(Fixed.asin,...x);
-const atan=(...x) => mapfun(Fixed.atan,...x);
-const acot=(...x) => mapfun(Fixed.acot,...x);
-const cosh=(...x) => mapfun(Fixed.cosh,...x);
-const sinh=(...x) => mapfun(Fixed.sinh,...x);
-const tanh=(...x) => mapfun(Fixed.tanh,...x);
-const coth=(...x) => mapfun(Fixed.coth,...x);
-const acosh=(...x) => mapfun(Fixed.acosh,...x);
-const asinh=(...x) => mapfun(Fixed.asinh,...x);
-const atanh=(...x) => mapfun(Fixed.atanh,...x);
-const ceil=(...x) => mapfun(Math.ceil,...x);
-const floor=(...x) => mapfun(Math.floor,...x);
-const round=(...x) => mapfun(Math.round,...x);
-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;
-        else return mapfun(a=>atan2(x,a,rad),...y);
-    }
-    // else if(x.isComplex?.()){
-    //     if(typeof n === "number")return x.constructor.fromExpo(x.z**n,x.phi*n);
-    //     else return mapfun(a=>pow(x,a),...n);
-    // }
-    else if(x instanceof Array){
-        if(typeof y === "number") return mapfun(a=>atan2(a,y,rad),...x);
-        else if(y instanceof Array){
-            const Y=[];
-            for(let i=0;i<x.length;i++){
-                Y.push(mapfun(a=>pow(x[i],a,rad),...y))
-            }
-            return Y;
-        }
-    }
-}
-const fact=(...x)=>mapfun(n=> {
-        let i,
-        y = 1;
-        if (n == 0) y = 1;
-        else if (n > 0) for (i = 1; i <= n; i++) y *= i;
-        else y = NaN;
-        return y;
-    },...x);
-const sign=(...x)=>mapfun(Math.sign,...x);
+// export const hypot=(...x)=>{
+//     if(x.every(n=>typeof n === "number"))return Math.hypot(...x);
+//     if(x.every(n=>n instanceof Array))return mapfun(
+//         Math.hypot,
+//         ...x
+//     )
+// }
 
-const sig=(...x)=>mapfun(n=>1/(1+e(-n)),...x);
-
-const hypot=(...x)=>{
-    if(x.every(n=>typeof n === "number"))return Math.hypot(...x);
-    if(x.every(n=>n instanceof Array))return mapfun(
-        Math.hypot,
-        ...x
-    )
-}
-
-export{
-    cos,
-    sin,
-    tan,
-    sinc,
-    cot,
-    sec,
-    csc,
-    abs,
-    sqrt,
-    pow,
-    sqrtn,
-    e,
-    ln,
-    acos,
-    asin,
-    atan,
-    acot,
-    cosh,
-    sinh,
-    tanh,
-    coth,
-    acosh,
-    asinh,
-    atanh,
-    min,
-    max,
-    sign,
-    floor,
-    ceil,
-    round,
-    fact,
-    hypot,
-    sig,
-    atan2
-  };
-  

package/src/math/{mapfun → functions/mapfun}/index.js

@@ -1,4 +1,4 @@
-import { is_primitive } from "../../helpers/checkers/index.js";
+import { is_primitive } from "../../../helpers/checkers/index.js";
 export const mapfun=(fun,...X)=>{
     const Y=X.map(x=>{
         if(is_primitive(x) || x?.__mapfun__) return fun(x)

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

@@ -1,4 +1,8 @@
-import { mapfun } from '../../mapfun/index.js';
+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 =>{
@@ -22,7 +26,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 +36,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 +47,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 +66,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 +91,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 +102,7 @@ export const ln = (...x) => mapfun(
             Math.log(x.z),
             x.phi
         );
-        return Math.ln(x)
+        return Math.log(x)
     }
     ,...x
 );
@@ -268,33 +284,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 +365,7 @@ export const sig = (...x) => mapfun(
         if(x?.isComplex){
 
         } 
-        return 1/(1+Math.e(-x))
+        return 1/(1+Math.exp(-x))
     },
     ...x
 )