ziko 0.51.0 → 0.51.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ziko",
-  "version": "0.51.0",
+  "version": "0.51.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/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/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) {
@@ -183,10 +182,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/index.js

@@ -1,5 +1,4 @@
 import { Fixed } from "./helper.js";
-import { Complex } from "../complex/index.js";
 import { mapfun } from "../utils/mapfun.js";
 import { 
     min,
@@ -11,12 +10,12 @@ 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 +37,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 +80,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/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"