ziko 0.53.0 → 0.54.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ziko",
-  "version": "0.53.0",
+  "version": "0.54.1",
   "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__(){
@@ -68,15 +55,24 @@ 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);
     }
     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,55 +81,66 @@ 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)));
+        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;
+        }
+        return this;
     }
-    add(...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;
     }
-    sub(...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].phi;
         }
-        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);
+        this.a = z * Math.cos(phi)
+        this.b = z * Math.sin(phi)  
         return this;
     }
-    mul(...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].phi;
         }
-        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);
+    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;
         }
-        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);
         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);
+    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) {
@@ -157,30 +164,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 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,42 @@
-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 * 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;
+//         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)
@@ -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)
+}