ziko 0.54.5 → 0.56.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ziko",
-  "version": "0.54.5",
+  "version": "0.56.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/--discret/index.js

@@ -0,0 +1,12 @@
+// import { powerSet , subSet } from "./Set/index.js";
+// import { Base } from "./Conversion/index.js";
+// import {
+//     Permutation,
+// } from "./Permutation/index.js"
+// import {
+//     Combinaison,
+//     combinaison,
+// } from "./Combinaison/index.js"
+
+// export{
+//     Base,Permutation,Combinaison,combinaison,powerSet,subSet}

package/src/math/complex/index.js

@@ -1,5 +1,4 @@
-// import {sum,prod,deg2rad} from "../utils/index.js";
-// Should avoid CD
+import { Random } from "../random/index.js";
 class Complex{
     constructor(a = 0, b = 0) {
         if(a instanceof Complex){
@@ -74,10 +73,23 @@ class Complex{
     get phi(){
         return Math.atan2(this.b , this.a);        
     }
-    static Zero() {
+    static zero() {
         return new Complex(0, 0);
     }
-    static Twiddle(N, K){
+    static fromPolar(z, phi) {
+        return new Complex(
+            +(z * cos(phi)).toFixed(13), 
+            +(z * sin(phi)).toFixed(13)
+        );
+    }
+    
+    static get random(){
+        return {
+            int : (a, b)=> new Complex(...Random.sample.int(2, a, b) ),
+            float : (a, b)=> new Complex(...Random.sample.float(2, a, b) ),
+        }
+    }
+    static twiddle(N, K){
         const phi = -2 * Math.PI * K / N;
         return new Complex(
             Math.cos(phi), 
@@ -150,12 +162,6 @@ class Complex{
         this.b = z * Math.sin(phi)  
         return this;
     }
-    static fromExpo(z, phi) {
-        return new Complex(
-            +(z * cos(phi)).toFixed(13), 
-            +(z * sin(phi)).toFixed(13)
-            );
-    }
     get expo() {
         return [this.z, this.phi];
     }
@@ -176,10 +182,10 @@ class Complex{
         return complex({z: this.z ** (1/n), phi: this.phi / n});
     }
     get sqrt(){
-        return this.nrth(2);
+        return this.nthr(2);
     }
     get cbrt(){
-        return this.nrth(3);
+        return this.nthr(3);
     }
     get log(){
         return complex(this.z, this.phi);

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

@@ -0,0 +1,61 @@
+export const base2base = (value, fromBase, toBase) => {
+    if (fromBase < 2 || fromBase > 36 || toBase < 2 || toBase > 36)
+        throw new TypeError('Base must be between 2 and 36');
+
+    const dec = parseInt(value, fromBase);
+    if (Number.isNaN(dec)) throw new TypeError('Invalid value for the given base');
+
+    return dec.toString(toBase);
+};
+
+export const bin2oct = (...x) => mapfun(
+    n => base2base(n, 2, 8),
+    ...x
+)
+export const bin2dec = (...x) => mapfun(
+    n => base2base(n, 2, 10),
+    ...x
+)
+export const bin2hex = (...x) => mapfun(
+    n => base2base(n, 2, 16),
+    ...x
+)
+
+export const oct2bin = (...x) => mapfun(
+    n => base2base(n, 8, 2),
+    ...x
+)
+export const oct2dec = (...x) => mapfun(
+    n => base2base(n, 8, 10),
+    ...x
+)
+export const oct2hex = (...x) => mapfun(
+    n => base2base(n, 8, 16),
+    ...x
+)
+
+export const dec2bin = (...x) => mapfun(
+    n => base2base(n, 10, 2),
+    ...x
+)
+export const dec2oct = (...x) => mapfun(
+    n => base2base(n, 10, 8),
+    ...x
+)
+export const dec2hex = (...x) => mapfun(
+    n => base2base(n, 10, 16),
+    ...x
+)
+
+export const hex2bin = (...x) => mapfun(
+    n => base2base(n, 16, 2),
+    ...x
+)
+export const hex2oct = (...x) => mapfun(
+    n => base2base(n, 16, 8),
+    ...x
+)
+export const hex2dec = (...x) => mapfun(
+    n => base2base(n, 16, 10),
+    ...x
+)

package/src/math/functions/index.js

@@ -1,5 +1,5 @@
 export * from './mapfun/index.js'
-export * from './nested/index.js'
+export * from './ufunc/index.js'
 export * from './arithmetic/index.js'
 export * from './utils/index.js'
 export * from './stats/index.js'

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

@@ -1,5 +1,5 @@
 import { mapfun } from "../mapfun/index.js";
-import { nthr, pow } from "../nested/index.js";
+import { nthr, pow } from "../fundamentals/index.js";
 
 export const zeros = n => new Array(n).fill(0);
 export const ones = n => new Array(n).fill(1);

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

@@ -3,6 +3,18 @@ import {add, mul} from '../arithmetic/index.js';
 export const min = (...x) => Math.min(...x);
 export const max = (...x) => Math.max(...x);
 
+export const binomial = (n, k) =>{
+  if(n !== Math.floor(n)) return TypeError('n must be an integer');
+  if(k !== Math.floor(k)) return TypeError('k must be an integer');
+  if (n < 0) return TypeError('n must be non-negative');
+  if (k < 0 || n < 0 || k > n) return 0;
+  if (k > n - k) k = n - k;
+    let c = 1, i;
+    for (i = 0; i < k; i++)
+        c = c * (n - i) / (i + 1);
+    return c;
+}
+
 export const mean = (...x) => x.reduce((a, b) => a + b) / x.length;
 
 export const variance = (...x) => {
@@ -16,7 +28,7 @@ export const std = (...x) => Math.sqrt(variance(...x));
 
 export const accum_sum = (...x) => {
   let result = [];
-  let total = 0, i; n = x.length;
+  let total = 0, i, n = x.length;
   for(i = 0; i < n ; i++){
     total = add(total, x[i])
     result.push(total);
@@ -26,7 +38,7 @@ export const accum_sum = (...x) => {
 
 export const accum_prod = (...x) => {
   let result = [];
-  let prod = 1, i; n = x.length;
+  let prod = 1, i, n = x.length;
   for(i = 0; i < n ; i++){
     prod = mul(prod, x[i])
     result.push(prod);

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

@@ -20,64 +20,6 @@ export const map = (x, a, b, c, d) => apply_fun(
     v => lerp(norm(v, a, b), c, d)
 );
 
-
-// export const norm = (x, min, max) => {
-//     if(x.isComplex?.()) return new x.constructor(
-//         norm(x.a, min, max),
-//         norm(x.b, min, max)
-//     )
-//     if(x.isMatrix?.()) return new x.constructor(
-//         x.rows, 
-//         x.cols, 
-//         norm(x.arr.flat(1), min, max)
-//     );
-//     if(x instanceof Array) return mapfun(n => norm(n, min, max), ...x);
-//     return min !== max ? (x - min) / (max - min) : 0;
-// }
-
-
-// export const lerp = (x, min, max) => {
-//     if(x.isComplex?.()) return new x.constructor(
-//         lerp(x.a, min, max),
-//         lerp(x.b, min, max)
-//     )
-//     if(x.isMatrix?.()) return new x.constructor(
-//         x.rows, 
-//         x.cols, 
-//         lerp(x.arr.flat(1), min, max)
-//     );
-//     if(x instanceof Array) return mapfun(n => lerp(n, min, max), ...x);
-//     return (max - min) * x + min;
-// }
-
-// export const map = (x, a, b, c, d) => {
-//     if(x.isComplex?.()) return new x.constructor(
-//         map(x.a, a, b, c, d),
-//         map(x.b, a, b, c, d)
-//     )
-//     if(x.isMatrix?.()) return new x.constructor(
-//         x.rows, 
-//         x.cols, 
-//         map(x.arr.flat(1), a, b, c, d)
-//     );
-//     if(x instanceof Array) return mapfun(n => map(n, a, b, c, d), ...x);
-//     return lerp(norm(x, a, b), c, d);
-// }
-
-// export const clamp = (x, min, max) => {
-//     if(x.isComplex?.()) return new x.constructor(
-//         clamp(x.a, min, max),
-//         clamp(x.b, min, max)
-//     )
-//     if(x.isMatrix?.()) return new x.constructor(
-//         x.rows, 
-//         x.cols, 
-//         clamp(x.arr.flat(1), min, max)
-//     );
-//     if(x instanceof Array) return mapfun(n => clamp(n, min, max), ...x);
-//     return Math.min(Math.max(x, min), max)
-// }
-
 export const hypot = (...x) => {
   const c0 = x.find(a => a.isComplex?.());
   if (c0) {

package/src/math/index.js

@@ -18,9 +18,9 @@ export * from "./const.js"
 export * from "./functions/index.js"
 export * from "./complex"
 export * from "./matrix"
-export * from "./discret"
+// export * from "./discret"
 export * from "./random"
 export * from "./utils"
-export * from "./statistics"
+// export * from "./statistics"
 // export default Math;
 

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

@@ -0,0 +1,30 @@
+export const matrix_constructor = (rows, cols, element) => {
+  if (rows.isMatrix?.()) {
+    arr = rows.arr;
+    rows = rows.rows;
+    cols = rows.cols;
+  } 
+  else {
+    let arr = [], i, j;
+    if (rows instanceof Array) {
+        arr = rows;
+        rows = arr.length;
+        cols = arr[0].length;
+    } 
+    else {
+      for (i = 0; i < rows; i++) {
+        arr.push([]);
+        arr[i].push(new Array(cols));
+        for (j = 0; j < cols; j++) {
+          arr[i][j] = element[i * cols + j];
+          if (element[i * cols + j] == undefined) arr[i][j] = 0;
+        }
+      }
+    }
+    return [
+        rows,
+        cols,
+        arr
+    ]
+  }
+};

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

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