ziko 0.56.0 → 0.56.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ziko",
-  "version": "0.56.0",
+  "version": "0.56.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/helpers/constructor.js

@@ -0,0 +1,38 @@
+export const complex_constructor = (Complex, a, b) => {
+    let _a, _b;
+  if (a instanceof Complex) {
+    _a = a.a;
+    _b = a.b;
+  } 
+  else if (typeof a === "object") {
+    if ("a" in a && "b" in a) {
+      _a = a.a;
+      _b = a.b;
+    } 
+    else if ("a" in a && "z" in a) {
+      _a = a.a;
+      _b = Math.sqrt(a.z ** 2 - a.a ** 2);
+    } 
+    else if ("a" in a && "phi" in a) {
+      _a = a.a;
+      _b = a.a * Math.tan(a.phi);
+    } 
+    else if ("b" in a && "z" in a) {
+      _b = a.b;
+      _a = Math.sqrt(a.z ** 2 - a.b ** 2);
+    } 
+    else if ("b" in a && "phi" in a) {
+      _b = b;
+      _a = a.b / Math.tan(a.phi);
+    } 
+    else if ("z" in a && "phi" in a) {
+      _a = +a.z * Math.cos(a.phi).toFixed(15);
+      _b = +a.z * Math.sin(a.phi).toFixed(15);
+    }
+  } 
+  else if (typeof a === "number" && typeof b === "number") {
+    _a = +a.toFixed(32);
+    _b = +b.toFixed(32);
+  }
+  return [_a, _b]
+};

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

@@ -0,0 +1 @@
+export * from './constructor.js'

package/src/math/complex/index.js

@@ -1,40 +1,11 @@
 import { Random } from "../random/index.js";
+import { complex_constructor } from "./helpers/index.js";
 class Complex{
     constructor(a = 0, b = 0) {
-        if(a instanceof Complex){
-            this.a=a.a;
-            this.b=a.b;
-        }
-        else if(typeof(a)==="object"){
-            if(("a" in a && "b" in a)){
-                this.a = a.a;
-                this.b = a.b;
-            }
-            else if(("a" in a && "z" in a)){
-                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 * Math.tan(a.phi);
-            }
-            else if(("b" in a && "z" in a)){
-                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 / Math.tan(a.phi);
-            }
-            else if(("z" in a && "phi" in a)){
-                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);
-        }
+        [
+            this.a,
+            this.b
+        ] = complex_constructor(Complex, a, b)
     }
     get __mapfun__(){
         return true
@@ -54,6 +25,19 @@ class Complex{
             : (str = `-${Math.abs(this.b)}*i`);
         return str;
     }
+    serialize() {
+        return JSON.stringify({
+            type : 'complex',
+            data : this
+        });
+    }
+    static deserialize(json){
+        if(typeof json === 'string') json = JSON.parse(json);
+        let {data, type} = json;
+        return (type === 'complex' && ('a' in data) && ('b' in data))
+            ? new Complex(data.a, data.b)
+            : TypeError('Not a valid complex')
+    } 
     toFixed(n){
         this.a = + this.a.toFixed(n);
         this.b = + this.b.toFixed(n);
@@ -165,19 +149,6 @@ class Complex{
     get expo() {
         return [this.z, this.phi];
     }
-    static add(c,...z) {
-        return c.clone().add(...z);
-    }
-    static sub(c,...z) {
-        return c.clone().sub(...z);
-    }
-    static mul(c,...z) {
-        return c.clone().mul(...z);
-    }
-    static div(c,...z) {
-        return c.clone().div(...z);
-    }
-
     nthr(n=2){
         return complex({z: this.z ** (1/n), phi: this.phi / n});
     }

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

@@ -1,82 +1,56 @@
-const _add = (x, y) =>{
+const arithmetic_helper=(op, x, y)=>{
     if(typeof x === 'number'){
-        if(typeof y === 'number') return x + y;
-        if(y.isComplex?.()) {
-            return y.clone().add(x);
+        if(typeof y === 'number'){
+            switch(op){
+                case 'add' : return x + y;
+                case 'sub' : return x - y;
+                case 'mul' : return x * y;
+                case 'div' : return x / y;
+                case 'modulo' : return x % y;
+            }
+        }
+        if(y?.isComplex?.()) x = new y.constructor(x, 0);
+        if(y?.isMatrix?.()) x = y.constructor.nums(y.rows, y.cols, x);
+        return x[op](y)
+    }
+    if(x?.isComplex?.()){
+        if(typeof y === 'number' || y?.isComplex?.()) return x.clone()[op](y);
+        if(y?.isMatrix?.()){
+            x = y.constructor.nums(y.rows, y.cols, x);
+            return x.clone()[op](y)
         }
     }
-    if(x.isComplex?.()){
-        if(typeof y === 'number' || y.isComplex?.()) return 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 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 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 x.clone().modulo(y);
-    }
+    if(x?.isMatrix?.()){
+        return x.clone()[op](y)
+    }    
 }
-
 export const add=(a,...b)=>{
     let res = a;
     for(let i=0; i<b.length; i++)
-        res = _add(res, b[i])
+        res = arithmetic_helper('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])
+        res = arithmetic_helper('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])
+        res = arithmetic_helper('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])
+        res = arithmetic_helper('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])
+        res = arithmetic_helper('modulo', res, b[i])
     return res;
 }

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

@@ -1,5 +1,5 @@
-export const matrix_constructor = (rows, cols, element) => {
-  if (rows.isMatrix?.()) {
+export const matrix_constructor = (Matrix, rows, cols, element) => {
+  if (rows instanceof Matrix) {
     arr = rows.arr;
     rows = rows.rows;
     cols = rows.cols;

package/src/math/matrix/index.js

@@ -28,7 +28,7 @@ class Matrix{
             this.rows, 
             this.cols, 
             this.arr
-        ] = matrix_constructor(rows, cols, element);
+        ] = matrix_constructor(Matrix, rows, cols, element);
         this.#maintain();
     }
     isMatrix(){
@@ -88,9 +88,6 @@ class Matrix{
         }
         return new Matrix(newRow, newCol, newArr.flat(1));
     }
-    static slice(m1,r0=0, c0=0, r1=this.rows-1, c1=this.cols-1) {
-        return m1.slice(r0, c0, r1, c1);
-    }
     reshape(newRows, newCols) {
         if(!(newRows * newCols === this.rows * this.cols)) throw Error('size not matched')
         return new Matrix(newRows, newCols, this.arr.flat(1));
@@ -155,35 +152,34 @@ class Matrix{
         this.#maintain();
         return this;
     }
-    static hstack(matrix,...matrices) {
-        return matrix.clone().hstack(...matrices);
-    }
     vstack(...matrices){
         const M=[this, ...matrices].reduce((a,b)=>vstack(a, b));
         Object.assign(this, M);
         this.#maintain();
         return this;
     }
-    static vstack(matrix,...matrices) {
-        return matrix.clone().vstack(...matrices);
-    }
     hqueue(...matrices){
         const M=[this, ...matrices].reverse().reduce((a,b)=>hstack(a, b));
         Object.assign(this, M)
         return this;
     }
-    static hqueue(matrix,...matrices) {
-        return matrix.clone().hqueue(...matrices);
-    }
     vqueue(...matrices){
         const M=[this,...matrices].reverse().reduce((a, b)=>vstack(a, b));
         Object.assign(this, M)
         return this;
     }
-    static vqueue(matrix,...matrices) {
-        return matrix.clone().vqueue(...matrices);
+    forEach(fn){
+        this.arr.flat(1).forEach(fn);
+        return this;
+    }
+    forEachRow(fn){
+        this.arr.forEach(fn);
+        return this;
+    }
+    forEachCol(fn){
+        this.clone().T.forEachRow(fn);
+        return this
     }
-
     apply(fn){
         const arr = this.arr.flat(1).map(fn)
         return new Matrix(
@@ -192,22 +188,13 @@ class Matrix{
             arr
         )
     }
-    static apply(M, fn){
-        return M.clone().apply(fn)
-    }
     applyRows(fn = ()=>{}){
         this.arr = this.arr.map(fn)
         return this;
     }
-    static applyRows(M, fn){
-        return M.clone().applyRows(fn)
-    }
     applyCols(fn){
         return this.clone().T.applyRows(fn).T;
     }
-    static applyCols(M, fn){
-        return M.clone().applyCols(fn);
-    }
     sort(fn = ()=>{}){
         const arr = this.arr.flat(1).sort(fn)
         return new Matrix(
@@ -216,66 +203,38 @@ class Matrix{
             arr
         )  
     }
-    static sort(M, fn){
-        return M.clone().sort(fn)
-    }
     shuffle(){
         return this.sort(() => 0.5-Math.random())
     }
-    static shuffle(M){
-        return M.clone().shuffle()
-    }
     sortRows(fn = ()=>{}){
         this.arr = this.arr.map(row => row.sort(fn))
         return this;
     }
-    static sortRows(M, fn){
-        return M.clone().sortRows(fn)
-    }
     shuffleRows(){
         return this.sortRows(() => 0.5-Math.random())
     }
-    static shuffleRows(M){
-        return M.clone().shuffleRows()
-    }
     sortCols(fn){
         return this.clone().T.sortRows(fn).T;
     }
-    static sortCols(M, fn){
-        return M.clone().sortCols(fn);
-    }
     shuffleCols(){
         return this.sortCols(() => 0.5-Math.random())
     }
-    static shuffleCols(M){
-        return M.clone().shuffleCols()
-    }
-
     reduce(fn, initialValue){
         const value = initialValue 
             ? this.arr.flat(1).reduce(fn, initialValue) 
             : this.arr.flat(1).reduce(fn);
         return new Matrix([[value]])
     }
-    static reduce(M, fn, initialValue){
-        return M.clone().reduce(fn, initialValue)
-    }
     reduceRows(fn, initialValue){
         const values = initialValue 
             ? this.arr.map(row => row.reduce(fn, initialValue)) 
             : this.arr.map(row => row.reduce(fn)) 
         return new Matrix(1, this.cols, values)
     }
-    static reduceRows(M, fn, initialValue){
-        return M.clone().reduceRows(fn, initialValue)
-    }
     reduceCols(fn, initialValue){
         return this.T.reduceRows(fn, initialValue).T
 
     }
-    static reduceCols(M, fn, initialValue){
-        return M.clone().reduceCols(fn, initialValue)
-    }
     filterRows(fn){
         const mask = this.arr.map(n => n.some(m => fn(m)));
         const arr = [];
@@ -284,16 +243,10 @@ class Matrix{
             if(mask[i]) arr.push(this.arr[i])
         return new Matrix(arr)
     }
-    static filterCols(M, fn){
-        return M.clone().filterRows(fn)
-    }
     filterCols(fn){
         const arr = this.T.filterRows(fn);
         return new Matrix(arr).T
     }
-    static filterCols(M, fn){
-        return M.clone().filterCols(fn);
-    }
     every(fn){
         return this.arr.flat(1).every(fn)
     }
@@ -395,7 +348,6 @@ class Matrix{
         }
         return true;
     }
-
     map(Imin, Imax, Fmin, Fmax) {
         this.arr = map(this.arr, Imin, Imax, Fmin, Fmax)
         return this;
@@ -412,18 +364,6 @@ class Matrix{
         this.arr = clamp(this.arr, min, max)
         return this;
     }
-    static map(M, Imin, Imax, Fmin, Fmax) {
-        return M.clone().map(Imin, Imax, Fmin, Fmax)
-    }
-    static lerp(M, min, max) {
-        return M.clone().lerp(min, max)
-    }
-    static norm(M, min, max) {
-        return M.clone().norm(min, max)
-    }
-    static clamp(M, min, max) {
-        return M.clone().clamp(min, max)
-    }
     toPrecision(p) {
         for (let i = 0; i < this.cols; i++) 
             for (let j = 0; j < this.rows; j++) 
@@ -456,15 +396,9 @@ class Matrix{
     getCols(ci, cf = ci + 1) {
         return this.slice(0, ci, this.rows, cf);
     }
-    static getRows(m, ri, rf = ri + 1) {
-        return m.slice(ri, 0, rf, m.cols);
-    }
-    static getCols(m, ci, cf = ci + 1) {
-        return m.slice(0, ci, m.rows, cf);
-    }
     #arithmetic(fn, ...matr){
         for (let k = 0; k < matr.length; k++) {
-            if (typeof matr[k] == "number"||matr[k] instanceof Complex) matr[k] = Matrix.nums(this.rows, this.cols, matr[k]);
+            if (typeof matr[k] == "number" || matr[k]?.isComplex?.()) matr[k] = Matrix.nums(this.rows, this.cols, matr[k]);
             for (let i = 0; i < this.rows; i++) 
                 for (var j = 0; j < this.cols; j++) 
                     this.arr[i][j] = fn(this.arr[i][j], matr[k].arr[i][j]);
@@ -474,33 +408,18 @@ class Matrix{
     add(...matr) {
         return this.#arithmetic(add, ...matr)
     }
-    static add(m1, ...m2) {
-        return m1.clone().add(...m2);
-    }
     sub(...matr) {
         return this.#arithmetic(sub, ...matr)
     }
-    static sub(m1, ...m2) {
-        return m1.clone().sub(...m2);
-    }
     mul(...matr) {
         return this.#arithmetic(mul, ...matr)
     }
-    static mul(m1, ...m2) {
-        return m1.clone().mul(...m2);
-    }
     div(...matr) {
         return this.#arithmetic(div, ...matr)
     }
-    static div(m1, ...m2) {
-        return m1.clone().div(...m2);
-    }
     modulo(...matr) {
         return this.#arithmetic(modulo, ...matr)
     }
-    static modulo(m1, ...m2) {
-        return m1.clone().modulo(...m2);
-    }
     dot(matrix) {
         var res = [];
         for (var i = 0; i < this.arr.length; i++) {
@@ -517,23 +436,24 @@ class Matrix{
         }
         return new Matrix(this.arr.length, matrix.arr[0].length, res.flat(1));
     }
-    static dot(matrix1, matrix2) {
-        return matrix1.dot(matrix2);
-    }
     pow(n) {
         let a = this.clone(),
             p = this.clone();
         for (let i = 0; i < n - 1; i++) p = p.dot(a);
         return p;
     }
-    static pow(m, n) {
-        return m.clone().pow(n);
-    }
-    get somme() {
+    sum(){
         let S = 0;
         for (let i = 0; i < this.rows; i++) 
             for (let j = 0; j < this.cols; j++) 
-                S += this.arr[i][j];
+                S = add(S, this.arr[i][j]);
+        return S;
+    }
+    prod(){
+        let S = 1;
+        for (let i = 0; i < this.rows; i++) 
+            for (let j = 0; j < this.cols; j++) 
+                S = mul(S, this.arr[i][j]);
         return S;
     }
     hasComplex(){
@@ -578,53 +498,62 @@ class Matrix{
     static fromVector(v) {
         return new Matrix(v.length, 1, v);
     }
-    get toArray() {
-        let arr = [];
-        for (let i = 0; i < this.rows; i++) {
-            for (let j = 0; j < this.cols; j++) {
-                arr.push(this.arr[i][j]);
+    serialize() {
+        const arr = mapfun(x => x.serialize?.() || x, ...this.arr)
+        return JSON.stringify({
+            type : 'matrix',
+            data : {
+                rows : this.rows,
+                cols : this.cols,
+                arr,
             }
-        }
-        return arr;
-    }
-    get serialize() {
-        return JSON.stringify(this);
-    }
-    static deserialize(data) {
-        if (typeof data == "string") data = JSON.parse(data);
-        let matrix = new Matrix(data.rows, data.cols);
-        matrix.arr = data.arr;
-        return matrix;
-    }
-    sortTable(n=0,{type="num",order="asc"}={}) {
-        var obj=this.T.arr.map(n=>n.map((n,i)=>Object.assign({},{x:n,y:i})));
-        var newObj=this.T.arr.map(n=>n.map((n,i)=>Object.assign({},{x:n,y:i})));
-        if(type==="num"){
-            if(order==="asc")obj[n].sort((a,b)=>a.x-b.x);
-            else if(order==="desc")obj[n].sort((a,b)=>b.x-a.x);
-            else if(order==="toggle"){
-               // console.log(obj[n][0])
-                //console.log(obj[n][1])
-                if(obj[n][0].x>obj[n][1].x)obj[n].sort((a,b)=>b.x-a.x);
-                else obj[n].sort((a,b)=>a.x-b.x);
+        });
+    }
+    static deserialize(json) {
+        if (typeof json == "string") json = JSON.parse(json);
+        const {type, data} = json;
+        if(type !== 'matrix') return TypeError('Not a valid Matrix')
+        let {arr} = data;
+        arr = mapfun(x => {
+            if(typeof x === 'string') {
+                const x_obj = JSON.parse(x);
+                const {type} = x_obj
+                if(type === 'complex') return Complex.deserialize(x_obj)
             }
-        }
-        else if(type==="alpha"){
-            if(order==="asc")obj[n].sort((a,b)=>(""+a.x).localeCompare(""+b.x));
-            else if(order==="desc")obj[n].sort((a,b)=>(""+b.x).localeCompare(""+a.x));            
-        }
-        //var order=obj[n].map(n=>n.y);
-        order=obj[n].map(n=>n.y);
-        for(let i=0;i<obj.length;i++){
-            if(i!==n)obj[i].map((n,j)=>n.y=order[j]);
-        }
-        for(let i=0;i<obj.length;i++){
-            if(i!==n)newObj[i].map((n,j)=>n.x=obj[i][order[j]].x)
-        }
-        newObj[n]=obj[n];
-        var newArr=newObj.map(n=>n.map(m=>m.x));
-        return new Matrix(newArr).T;
+            return x
+        }, ...arr)
+        return new Matrix(arr)
     }
+    // To Be Moved to Table or GridView
+    // sortTable(n=0,{type="num",order="asc"}={}) {
+    //     var obj=this.T.arr.map(n=>n.map((n,i)=>Object.assign({},{x:n,y:i})));
+    //     var newObj=this.T.arr.map(n=>n.map((n,i)=>Object.assign({},{x:n,y:i})));
+    //     if(type==="num"){
+    //         if(order==="asc")obj[n].sort((a,b)=>a.x-b.x);
+    //         else if(order==="desc")obj[n].sort((a,b)=>b.x-a.x);
+    //         else if(order==="toggle"){
+    //            // console.log(obj[n][0])
+    //             //console.log(obj[n][1])
+    //             if(obj[n][0].x>obj[n][1].x)obj[n].sort((a,b)=>b.x-a.x);
+    //             else obj[n].sort((a,b)=>a.x-b.x);
+    //         }
+    //     }
+    //     else if(type==="alpha"){
+    //         if(order==="asc")obj[n].sort((a,b)=>(""+a.x).localeCompare(""+b.x));
+    //         else if(order==="desc")obj[n].sort((a,b)=>(""+b.x).localeCompare(""+a.x));            
+    //     }
+    //     //var order=obj[n].map(n=>n.y);
+    //     order=obj[n].map(n=>n.y);
+    //     for(let i=0;i<obj.length;i++){
+    //         if(i!==n)obj[i].map((n,j)=>n.y=order[j]);
+    //     }
+    //     for(let i=0;i<obj.length;i++){
+    //         if(i!==n)newObj[i].map((n,j)=>n.x=obj[i][order[j]].x)
+    //     }
+    //     newObj[n]=obj[n];
+    //     var newArr=newObj.map(n=>n.map(m=>m.x));
+    //     return new Matrix(newArr).T;
+    // }
 }