ziko 0.51.0 → 0.52.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ziko",
-  "version": "0.51.0",
+  "version": "0.52.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/data/converter/csv.js

@@ -1,4 +1,4 @@
-import { Matrix } from "../../math/matrix/Matrix.js"
+import { Matrix } from "../../math/matrix/matrix.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/{__helpers__ → helpers}/register/index.js

@@ -1,5 +1,5 @@
 import { register_to_class } from "./register-to-class.js";
-import { register_to_instance } from "./register-to-instance"; // Not Overridable
+import { register_to_instance } from "./register-to-instance.js"; // Not Overridable
 export const register = (target, ...mixins) => {
   console.log(target)
   // return register_to_class(target, ...mixins)

package/src/hooks/use-ipc.js

@@ -1,5 +1,3 @@
-import { Random } from "../math/random/index.js";
-
 class UseIPC {
     #channel;
     #eventData;
@@ -11,7 +9,7 @@ class UseIPC {
         this.#channel = new BroadcastChannel(name);
         this.#eventData = new Map();
         this.#handlers = new Map(); // Map<event, Array<{fn, rooms}>>
-        this.#uuid = "ziko-channel:" + Random.string(10);
+        this.#uuid = "ziko-channel:" + (Math.random()*10e16);  // To Be Replaced by UUID
         this.#subscribers = new Set([this.#uuid]);
         this.#currentRooms = new Set(); 
         this.#channel.addEventListener("message", (e) => {

package/src/math/adapted/index.js

@@ -0,0 +1,7 @@
+export const adapted_cos = x =>{
+    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)
+}

package/src/math/complex/index.js

@@ -12,7 +12,6 @@ import{
     sqrt,
     ln
   }from "../functions/index.js"
-import { Matrix } from "../matrix/index.js";
 import {sum,prod,deg2rad} from "../utils/index.js";
 class Complex{
     constructor(a = 0, b = 0) {
@@ -42,8 +41,8 @@ class Complex{
                 this.a=a.b/tan(a.phi);
             }
             else if(("z" in a && "phi" in a)){
-                this.a=a.z*cos(a.phi);
-                this.a=a.z*sin(a.phi);
+                this.a = +a.z*cos(a.phi).toFixed(15);
+                this.b = +a.z*sin(a.phi).toFixed(15);
             }
         }
         else if(typeof(a)==="number"&&typeof(b)==="number"){
@@ -51,6 +50,9 @@ class Complex{
             this.b = +b.toFixed(32);
         }
     }
+    get __mapfun__(){
+        return true
+    }
     isComplex(){
         return true
     }
@@ -183,10 +185,10 @@ class Complex{
 }
 const complex=(a,b)=>{
     if((a instanceof Array||ArrayBuffer.isView(a)) && (b instanceof Array||ArrayBuffer.isView(a)))return a.map((n,i)=>complex(a[i],b[i]));
-    if(a instanceof Matrix && b instanceof Matrix){
+    if(a.isMatrix?.() && b.isMatrix?.()){
         if((a.shape[0]!==b.shape[0])||(a.shape[1]!==b.shape[1]))return Error(0)
         const arr=a.arr.map((n,i)=>complex(a.arr[i],b.arr[i]))
-        return new Matrix(a.rows,a.cols,...arr)
+        return new a.constructor(a.rows,a.cols,...arr)
     }
     return new Complex(a,b)
 }

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/matrix.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/matrix.js";
 const Logic={
     _mode:Number,
     _map:function(func,a,b){

package/src/math/functions/helper.js

@@ -1,30 +1,81 @@
 const {PI, cos, sin, tan, acos, asin, atan, cosh, sinh, tanh, acosh, asinh, atanh, log} = Math
 export let Fixed={
-    cos,
-    sin,
-    tan,
+    cos : x=> {
+        if(x.isComplex?.()) return new x.constructor(
+            cos(x.a)*cosh(x.b),
+            -(sin(x.a)*sinh(x.b))
+        );
+        return cos(x)
+    },
+    sin : x=>{
+        if(x?.isComplex) return new x.constructor(
+            sin(x.a)*cosh(x.b),
+            cos(x.a)*sinh(x.b)
+        );
+        return sin(x)
+    },
+    tan : x=>{
+        if(x?.isComplex){
+            const DEN = cos(2*x.a)+cosh(2*x.b);
+            return new x.constructor(
+                sin(2*x.a)/DEN,
+                sinh(2*x.b)/DEN
+            );
+        } 
+        return tan(x) 
+    },
     sinc: x => sin(PI*x)/(PI*x),
     sec: x => 1/cos(x),
     csc: x => 1/sin(x),
     cot: x => 1/tan(x),
-    acos,
-    asin,
-    atan,
+    acos: x=>{
+        if(x?.isComplex) return 
+        return sin(x)
+    },
+    asin: x=>{
+        if(x?.isComplex) return 
+        return sin(x)
+    },
+    atan: x=>{
+        if(x?.isComplex) return 
+        return sin(x)
+    },
     acot: x => PI/2-atan(x),
-    cosh,
-    sinh,
-    tanh,
+    cosh: x=>{
+        if(x?.isComplex) return new x.constructor(
+            cosh(x.a)*cos(x.b),
+            sinh(x.a)*sin(x.b)
+        ); 
+        return cosh(x)
+    },
+    sinh: x=>{
+        if(x?.isComplex) return new x.constructor(
+            sinh(x.a)*cos(x.b),
+            cosh(x.a)*sin(x.b)
+        ); 
+        return sinh(x)
+    },
+    tanh: x=>{
+        if(x?.isComplex){
+            const DEN=cosh(2*a)+cos(2*b);
+            return new x.constructor(
+                sinh(2*a)/DEN,
+                sin(2*b)/DEN
+            )
+        } 
+        return tanh(x)
+    },
     coth: n => (1/2*log((1+n)/(1-n))),
     acosh,
     asinh,
     atanh,
 }
 
-Fixed = new Proxy(Fixed, {
-    get(target, prop) {
-        if(prop in target){
-            return x => + target[prop](x).toFixed(15);
-        }
-        return undefined;
-    }
-})
+// Fixed = new Proxy(Fixed, {
+//     get(target, prop) {
+//         if(prop in target){
+//             return x => + target[prop](x).toFixed(15);
+//         }
+//         return undefined;
+//     }
+// })

package/src/math/functions/index.js

@@ -1,22 +1,22 @@
 import { Fixed } from "./helper.js";
-import { Complex } from "../complex/index.js";
-import { mapfun } from "../utils/mapfun.js";
+import { mapfun } from "../mapfun/index.js";
 import { 
     min,
     max 
-}from "../statistics/index.js";
+}
+from "../statistics/index.js";
 
 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 instanceof Complex)return Complex.fromExpo(x**n.a,n.b*ln(x))
+        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 instanceof Complex){
-        if(typeof n === "number")return Complex.fromExpo(x.z**n,x.phi*n);
-        else if(n instanceof Complex)return Complex.fromExpo(
+    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
         )
@@ -38,8 +38,8 @@ const sqrtn=(x,n)=>{
         if(typeof n === "number")return Math.pow(x,1/n);
         else return mapfun(a=>sqrtn(x,a),...n);
     }
-    else if(x instanceof Complex){
-        if(typeof n === "number")return Complex.fromExpo(sqrtn(x.z,n),x.phi/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){
@@ -81,8 +81,8 @@ const atan2=(x,y,rad=true)=>{
         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 instanceof Complex){
-    //     if(typeof n === "number")return Complex.fromExpo(x.z**n,x.phi*n);
+    // 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){

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

@@ -0,0 +1,176 @@
+import { mapfun } from '../../mapfun/index.js';
+
+export const abs = (...x) => mapfun(
+    x =>{
+        if(x.isComplex?.()) return x.z;
+        return Math.abs(x)
+    },
+    ...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)
+            );
+        } 
+        return Math.sqrt(x);
+    },
+    ...x
+)
+
+export const e = (...x) => mapfun(
+    x => {
+        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.ln(x)
+    }
+    ,...x
+);
+
+export const ln = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.log(x.z),
+            x.phi
+        );
+        return Math.ln(x)
+    }
+    ,...x
+);
+
+export const sign = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()){
+            const {z, phi} = x;
+            if(z===0) return new x.constructor(0, 0);
+            return new x.constructor({z:1, phi})
+        }
+        return Math.sign(x)
+    }
+    ,...x
+);
+export const cos = (...x) => mapfun(
+    x => {
+        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)
+    }
+    ,...x
+);
+
+export const sin = (...x) => mapfun(
+    x =>{
+        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)
+    }
+    , ...x
+);
+
+export const tan = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            const DEN = 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
+            );
+        } 
+        return Math.tan(x) 
+    },
+    ...x
+);
+
+export const acos = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            const { a, b } = x;
+            const Rp = Math.hypot(a + 1, b);
+            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),
+            )
+        } 
+        return Math.acos(x) 
+    },
+    ...x
+);
+
+export const asin = (...x) => mapfun(
+    x => {
+        if(x?.isComplex){
+            const { a, b } = x;
+            const Rp = Math.hypot(a + 1, b);
+            const Rm = Math.hypot(a - 1, b);
+            return new x.constructor(
+                Math.asin((Rp - Rm) / 2), 
+                Math.acosh((Rp + Rm) / 2)
+            );
+        }
+        return Math.asin(x);
+    },
+    ...x
+);
+
+export const atan = (...x) => mapfun(
+    x => {
+        if(x?.isComplex){
+            const { a, b } = x;
+            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
+            )
+        }
+        return Math.atan(x);
+    },
+    ...x
+);
+
+
+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)
+        ); 
+        return 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)
+        ); 
+        return sinh(x)
+    },
+    ...x
+)
+export const tanh = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            const DEN=cosh(2*a)+cos(2*b);
+            return new x.constructor(
+                sinh(2*a)/DEN,
+                sin(2*b)/DEN
+            )
+        } 
+        return tanh(x)
+    },
+    ...x
+)

package/src/math/mapfun/index.js

@@ -0,0 +1,19 @@
+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)
+        if(x instanceof Array) return x.map(n=>mapfun(fun,n));
+        if(ArrayBuffer.isView(x)) return x.map(n=>fun(n));
+        if(x instanceof Set) return new Set(mapfun(fun,...[...x]));
+        if(x instanceof Map) return new Map([...x].map(n=>[n[0],mapfun(fun,n[1])]));
+        if(x.isMatrix?.()) return new x.constructor(x.rows, x.cols, mapfun(x.arr.flat(1)))
+        else if(x instanceof Object){
+            return Object.fromEntries(
+                Object.entries(x).map(
+                    n=>n=[n[0],mapfun(fun,n[1])]
+                )
+            )
+        }
+    });
+   return Y.length==1? Y[0]: Y; 
+}

package/src/math/matrix/helpers/det.js

@@ -0,0 +1,36 @@
+import { add, sub, mul } from "../../utils/index.js";
+import { pow } from "../../functions/index.js";
+export function matrix_det(M) {
+    if (!M.isSquare) return new Error("is not square matrix");
+    if (M.rows == 1) return M.arr[0][0];
+    function determinat(M) {
+        if (M.length == 2) {
+            if (M.flat(1).some((n) => n?.isMatrix?.())) {
+                console.warn("Tensors are not completely supported yet ...");
+                return;
+            }
+            return sub(mul(M[0][0],M[1][1]),mul(M[0][1],M[1][0]))
+        }
+        var answer = 0;
+        for (var i = 0; i < M.length; i++) {
+            //console.log(M[0][i]);
+            /*answer = answer.add(
+                pow(-1, i)
+                    .mul(M[0][i])
+                    .mul(determinat(deleteRowAndColumn(M, i)))
+            );*/
+            //const to_be_added=add(mul(pow(-1, i),mul(M[0][i],determinat(deleteRowAndColumn(M, i)))));
+            const to_be_added=add(mul(pow(-1, i),mul(M[0][i],determinat(deleteRowAndColumn(M, i)))));
+            answer=add(answer,to_be_added)
+        }
+        return answer;
+    }
+    return determinat(M.arr);
+}
+function deleteRowAndColumn(M, index) {
+    var temp = [];
+    for (let i = 0; i < M.length; i++) temp.push(M[i].slice(0));
+    temp.splice(0, 1);
+    for (let i = 0; i < temp.length; i++) temp[i].splice(index, 1);
+    return temp;
+}

package/src/math/matrix/helpers/index.js

@@ -0,0 +1,3 @@
+export * from './inverse.js'
+export * from './det.js'
+export * from './stack.js'

package/src/math/matrix/helpers/inverse.js

@@ -0,0 +1,52 @@
+export function matrix_inverse(M) {
+    if(M.row !== M.cols) throw Error('is not a square matrix"')
+    if (M.det === 0) throw Error("determinant should not equal 0");
+    const { arr } = M
+    if (arr.length !== arr[0].length) return;
+    var i = 0, ii = 0, j = 0, dim = arr.length, e = 0;
+    var I = [], C = [];
+    for (i = 0; i < dim; i += 1) {
+        I[I.length] = [];
+        C[C.length] = [];
+        for (j = 0; j < dim; j += 1) {
+            if (i == j) I[i][j] = 1;
+            else I[i][j] = 0;
+            C[i][j] = arr[i][j];
+        }
+    }
+    for (i = 0; i < dim; i += 1) {
+        e = C[i][i];
+        if (e == 0) {
+            for (ii = i + 1; ii < dim; ii += 1) {
+                if (C[ii][i] != 0) {
+                    for (j = 0; j < dim; j++) {
+                        e = C[i][j];
+                        C[i][j] = C[ii][j];
+                        C[ii][j] = e;
+                        e = I[i][j];
+                        I[i][j] = I[ii][j];
+                        I[ii][j] = e;
+                    }
+                    break;
+                }
+            }
+            e = C[i][i];
+            if (e == 0) return;
+        }
+        for (j = 0; j < dim; j++) {
+            C[i][j] = C[i][j] / e;
+            I[i][j] = I[i][j] / e;
+        }
+        for (ii = 0; ii < dim; ii++) {
+            if (ii == i) {
+                continue;
+            }
+            e = C[ii][i];
+            for (j = 0; j < dim; j++) {
+                C[ii][j] -= e * C[i][j];
+                I[ii][j] -= e * I[i][j];
+            }
+        }
+    }
+    return new M.constructor(I);
+}

package/src/math/matrix/helpers/stack.js

@@ -0,0 +1,24 @@
+export function hstack(M1, M2){
+    M1 = M1.clone()
+    M2 = M2.clone()
+    if (M1.rows !== M2.rows) return;
+    let newArr = M1.arr;
+    for (let i = 0; i < M1.rows; i++) 
+        for (let j = M1.cols; j < M1.cols + M2.cols; j++) 
+            newArr[i][j] = M2.arr[i][j - M1.cols];
+    M1.cols += M2.cols;
+    return new M1.constructor(M1.rows, M1.cols, newArr.flat(1));
+}
+
+export function vstack(M1, M2){
+    M1 = M1.clone()
+    M2 = M2.clone()
+    if (M1.cols !== M2.cols) return;
+    let newArr = M1.arr;
+    for (let i = M1.rows; i < M1.rows + M2.rows; i++) {
+        newArr[i] = [];
+        for (let j = 0; j < M1.cols; j++) newArr[i][j] = M2.arr[i - M1.rows][j];
+    }
+    M1.rows += M2.rows;
+    return new M1.constructor(M1.rows, M1.cols, newArr.flat(1));
+}

package/src/math/matrix/index.js

@@ -1 +1 @@
-export * from "./Matrix.js"
+export * from "./matrix.js"