ziko 0.52.0 → 0.53.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ziko",
-  "version": "0.52.0",
+  "version": "0.53.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

@@ -69,7 +69,7 @@ class Complex{
         return str;
     }
       
-    get clone() {
+    clone() {
         return new Complex(this.a, this.b);
     }
     get z(){
@@ -146,19 +146,19 @@ class Complex{
         return [this.z, this.phi];
     }
     static add(c,...z) {
-        return c.clone.add(...z);
+        return c.clone().add(...z);
     }
     static sub(c,...z) {
-        return c.clone.sub(...z);
+        return c.clone().sub(...z);
     }
     static mul(c,...z) {
-        return c.clone.mul(...z);
+        return c.clone().mul(...z);
     }
     static div(c,...z) {
-        return c.clone.div(...z);
+        return c.clone().div(...z);
     }
     static pow(z,n){
-        return z.clone.pow(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)));

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

@@ -8,21 +8,68 @@ export const abs = (...x) => mapfun(
     ...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?.()){
-            const {z, phi} = x
-            return new x.constructor(
-                Math.sqrt(z) * Math.cos(phi/2),
-                Math.sqrt(z) * Math.sin(phi/2)
-            );
-        } 
+        if(x.isComplex?.()) 
+            return new x.constructor({z: x.z**(1/2), phi: x.phi/2})
         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.sqrt(x);
+    },
+    ...x
+);
 
-export const e = (...x) => mapfun(
+export const nthr = (...x) => {
+    const n = x.pop();
+    return mapfun(
+        x => {
+            if(x.isComplex?.()) return new x.constructor({z: x.z ** 1/n, phi: x.phi / n});
+            return x**(1/n)
+        },
+        ...x
+    )
+}
+
+export const croot = (...x) =>{
+    const z = x.pop()
+    return mapfun(
+        x => {
+            if(x.isComplex?.()) return null
+            return null
+        },
+        ...x
+    )
+}
+
+export const exp = (...x) => mapfun(
     x => {
         if(x.isComplex?.()) return new x.constructor(
             Math.exp(x.a) * Math.cos(x.b),
@@ -55,6 +102,60 @@ export const sign = (...x) => mapfun(
     }
     ,...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(
@@ -80,10 +181,10 @@ export const sin = (...x) => mapfun(
 export const tan = (...x) => mapfun(
     x =>{
         if(x?.isComplex){
-            const DEN = Math.cos(2*x.a) + Math.cosh(2*x.b);
+            const D = Math.cos(2*x.a) + Math.cosh(2*x.b);
             return new x.constructor(
-                Math.sin(2*x.a) / DEN,
-                Math.sinh(2*x.b) / DEN
+                Math.sin(2*x.a) / D,
+                Math.sinh(2*x.b) / D
             );
         } 
         return Math.tan(x) 
@@ -91,6 +192,16 @@ export const tan = (...x) => mapfun(
     ...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){
@@ -99,7 +210,6 @@ export const acos = (...x) => mapfun(
             const Rm = Math.hypot(a - 1, b);
             globalThis.Rp = Rp
             globalThis.Rm = Rm
-            console.log({a, b, Rp, Rm})
             return new x.constructor(
                 Math.acos((Rp - Rm) / 2),
                 -Math.acosh((Rp + Rm) / 2),
@@ -140,6 +250,20 @@ export const atan = (...x) => mapfun(
     ...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 =>{
@@ -164,13 +288,68 @@ export const sinh = (...x) => mapfun(
 export const tanh = (...x) => mapfun(
     x =>{
         if(x?.isComplex){
-            const DEN=cosh(2*a)+cos(2*b);
+            const D=cosh(2*a)+cos(2*b);
             return new x.constructor(
-                sinh(2*a)/DEN,
-                sin(2*b)/DEN
+                sinh(2*a)/D,
+                sin(2*b)/D
             )
         } 
         return 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.e(-x))
+    },
+    ...x
 )