ziko 0.0.18 → 0.0.20

package/src/math/discret/Conversion/index.js

@@ -1,86 +1,86 @@
-import { Complex } from "../../complex/index.js";
-import { Matrix } from "../../matrix/Matrix.js";
-const Base={
-    _mode:Number,
-    _map:function(func,number,toBase){
-        if (number instanceof Matrix)
-            return new Matrix(
-                number.rows,
-                number.cols,
-                number.arr.flat(1).map(n=>func(n,toBase))
-            );
-        else if (number instanceof Complex) return new Complex(func(number.a,toBase),func(number.b,toBase));
-        else if (number instanceof Array) return number.map((n) =>func(n,toBase));
-    },
-    dec2base(dec,base){
-        base<=10?this._mode=Number:this._mode=String
-        //this._mode=String
-        if (typeof dec === "number") return this._mode((dec >>> 0).toString(base));
-          return this._map(this.dec2base,dec,base)
-    },
-    dec2bin(dec){
-        return this.dec2base(dec,2);
-    },
-    dec2oct(dec){
-        return this.dec2base(dec,8);
-    },
-    dec2hex(dec){
-        return this.dec2base(dec,16);
-    },
-    bin2base(bin, base) {
-        return this.dec2base(this.bin2dec(bin),base)
-    },
-    bin2dec(bin){
-        return this._mode("0b"+bin);
-    },
-    bin2oct(bin){
-        return this.bin2base(bin,8);
-    },
-    bin2hex(bin){
-        return this.bin2base(bin,16);
-    },
-    oct2dec(oct){
-        return this._mode("0o"+oct);
-    },
-    oct2bin(oct){
-        return this.dec2bin(this.oct2dec(oct))
-    },
-    oct2hex(oct){
-        return this.dec2hex(this.oct2dec(oct))
-    },
-    oct2base(oct, base) {
-        return this.dec2base(this.oct2dec(oct),base)
-    },
-    hex2dec(hex){
-        return this._mode("0x"+hex);
-    },
-    hex2bin(hex){
-        return this.dec2bin(this.hex2dec(hex))
-    },
-    hex2oct(hex){
-        return this.dec2oct(this.hex2dec(hex))
-    },
-    hex2base(hex, base) {
-        return this.dec2base(this.hex2dec(hex),base)
-    },
-    IEEE32toDec(Bin){
-        let IEEE32=Bin.split(" ").join("").padEnd(32,"0");
-        let s=IEEE32[0];
-        let e=2**(+("0b"+IEEE32.slice(1,9))-127)
-        let m=IEEE32.slice(9,32).split("").map(n=>+n)
-        let M=m.map((n,i)=>n*(2**(-i-1))).reduce((a,b)=>a+b,0);
-        let dec=(-1)**s*(1+M)*e;
-        return dec
-    },
-    IEEE64toDec(Bin){
-        let IEEE64=Bin.split(" ").join("").padEnd(64,"0");
-        let s=IEEE64[0];
-        let e=2**(+("0b"+IEEE64.slice(1,12))-1023)
-        let m=IEEE64.slice(13,64).split("").map(n=>+n)
-        let M=m.map((n,i)=>n*(2**(-i-1))).reduce((a,b)=>a+b,0);
-        let dec=(-1)**s*(1+M)*e;
-        return dec;
-    }
-}
-
+import { Complex } from "../../complex/index.js";
+import { Matrix } from "../../matrix/Matrix.js";
+const Base={
+    _mode:Number,
+    _map:function(func,number,toBase){
+        if (number instanceof Matrix)
+            return new Matrix(
+                number.rows,
+                number.cols,
+                number.arr.flat(1).map(n=>func(n,toBase))
+            );
+        else if (number instanceof Complex) return new Complex(func(number.a,toBase),func(number.b,toBase));
+        else if (number instanceof Array) return number.map((n) =>func(n,toBase));
+    },
+    dec2base(dec,base){
+        base<=10?this._mode=Number:this._mode=String
+        //this._mode=String
+        if (typeof dec === "number") return this._mode((dec >>> 0).toString(base));
+          return this._map(this.dec2base,dec,base)
+    },
+    dec2bin(dec){
+        return this.dec2base(dec,2);
+    },
+    dec2oct(dec){
+        return this.dec2base(dec,8);
+    },
+    dec2hex(dec){
+        return this.dec2base(dec,16);
+    },
+    bin2base(bin, base) {
+        return this.dec2base(this.bin2dec(bin),base)
+    },
+    bin2dec(bin){
+        return this._mode("0b"+bin);
+    },
+    bin2oct(bin){
+        return this.bin2base(bin,8);
+    },
+    bin2hex(bin){
+        return this.bin2base(bin,16);
+    },
+    oct2dec(oct){
+        return this._mode("0o"+oct);
+    },
+    oct2bin(oct){
+        return this.dec2bin(this.oct2dec(oct))
+    },
+    oct2hex(oct){
+        return this.dec2hex(this.oct2dec(oct))
+    },
+    oct2base(oct, base) {
+        return this.dec2base(this.oct2dec(oct),base)
+    },
+    hex2dec(hex){
+        return this._mode("0x"+hex);
+    },
+    hex2bin(hex){
+        return this.dec2bin(this.hex2dec(hex))
+    },
+    hex2oct(hex){
+        return this.dec2oct(this.hex2dec(hex))
+    },
+    hex2base(hex, base) {
+        return this.dec2base(this.hex2dec(hex),base)
+    },
+    IEEE32toDec(Bin){
+        let IEEE32=Bin.split(" ").join("").padEnd(32,"0");
+        let s=IEEE32[0];
+        let e=2**(+("0b"+IEEE32.slice(1,9))-127)
+        let m=IEEE32.slice(9,32).split("").map(n=>+n)
+        let M=m.map((n,i)=>n*(2**(-i-1))).reduce((a,b)=>a+b,0);
+        let dec=(-1)**s*(1+M)*e;
+        return dec
+    },
+    IEEE64toDec(Bin){
+        let IEEE64=Bin.split(" ").join("").padEnd(64,"0");
+        let s=IEEE64[0];
+        let e=2**(+("0b"+IEEE64.slice(1,12))-1023)
+        let m=IEEE64.slice(13,64).split("").map(n=>+n)
+        let M=m.map((n,i)=>n*(2**(-i-1))).reduce((a,b)=>a+b,0);
+        let dec=(-1)**s*(1+M)*e;
+        return dec;
+    }
+}
+
 export{Base}

package/src/math/discret/Logic/index.js

@@ -1,46 +1,46 @@
-import { Complex } from "../../complex/index.js";
-import { Matrix } from "../../matrix/Matrix.js";
-const Logic={
-    _mode:Number,
-    _map:function(func,a,b){
-        if (a instanceof Matrix)
-            return new Matrix(
-                a.rows,
-                a.cols,
-                a.arr.flat(1).map((n) => func(n, b))
-            );
-        else if (a instanceof Complex) return new Complex(func(a.a, b), func(a.b, b));
-        else if (a instanceof Array) return a.map((n) => func(n, b));      
-    },
-    not:function(input){
-        if(["number","boolean"].includes(typeof input)) return Logic._mode(!input);
-        else return this._map(this.not,input)
-    },
-    and:function(a, ...b){
-        if(["number","boolean"].includes(typeof a))return Logic._mode(b.reduce((n, m) => (n &= m), a));
-        else return this._map(this.and,a,b)
-    },
-    or:function(a, ...b) {
-        if(["number","boolean"].includes(typeof a)) return Logic._mode(b.reduce((n, m) => (n |= m), a));
-        else return this._map(this.or,a,b);
-    },
-    nand:function(a, ...b) {
-        return this.not(this.and(a, b));
-    },
-    nor:function(a, ...b) {
-        return this.not(this.or(a, b));
-    },
-    xor:function(a,...b){
-        let arr=[a,...b]
-        if(["number","boolean"].includes(typeof a))return this._mode(arr.reduce((length,cur)=>{
-            if(+cur===1)length+=1;
-            return length;
-        },0)===1);
-        else return this._map(this.xor,a,b);
-    },
-    xnor:function(a,...b){
-        return Logic.not(Logic.xor(a,b))
-    }
-    
-}
+import { Complex } from "../../complex/index.js";
+import { Matrix } from "../../matrix/Matrix.js";
+const Logic={
+    _mode:Number,
+    _map:function(func,a,b){
+        if (a instanceof Matrix)
+            return new Matrix(
+                a.rows,
+                a.cols,
+                a.arr.flat(1).map((n) => func(n, b))
+            );
+        else if (a instanceof Complex) return new Complex(func(a.a, b), func(a.b, b));
+        else if (a instanceof Array) return a.map((n) => func(n, b));      
+    },
+    not:function(input){
+        if(["number","boolean"].includes(typeof input)) return Logic._mode(!input);
+        else return this._map(this.not,input)
+    },
+    and:function(a, ...b){
+        if(["number","boolean"].includes(typeof a))return Logic._mode(b.reduce((n, m) => (n &= m), a));
+        else return this._map(this.and,a,b)
+    },
+    or:function(a, ...b) {
+        if(["number","boolean"].includes(typeof a)) return Logic._mode(b.reduce((n, m) => (n |= m), a));
+        else return this._map(this.or,a,b);
+    },
+    nand:function(a, ...b) {
+        return this.not(this.and(a, b));
+    },
+    nor:function(a, ...b) {
+        return this.not(this.or(a, b));
+    },
+    xor:function(a,...b){
+        let arr=[a,...b]
+        if(["number","boolean"].includes(typeof a))return this._mode(arr.reduce((length,cur)=>{
+            if(+cur===1)length+=1;
+            return length;
+        },0)===1);
+        else return this._map(this.xor,a,b);
+    },
+    xnor:function(a,...b){
+        return Logic.not(Logic.xor(a,b))
+    }
+    
+}
 export{Logic}

package/src/math/discret/Permutation/index.js

@@ -1,31 +1,31 @@
-class Permutation {
-    static withDiscount(arr, l = arr.length) {
-        if (l === 1) return arr.map((n) => [n]);
-        const permutations = [];
-        let smallerPermutations;
-        smallerPermutations = this.withDiscount(arr, l - 1);
-        arr.forEach((currentOption) => {
-            smallerPermutations.forEach((smallerPermutation) => {
-                permutations.push([currentOption].concat(smallerPermutation));
-            });
-        });
-        return permutations;
-    }
-    static withoutDiscount(arr) {
-        const l = arr.length;
-        if (l === 1) return arr.map((n) => [n]);
-        const permutations = [];
-        const smallerPermutations = this.withoutDiscount(arr.slice(1));
-        const firstOption = arr[0];
-        for (let i = 0; i < smallerPermutations.length; i++) {
-            const smallerPermutation = smallerPermutations[i];
-            for (let j = 0; j <= smallerPermutation.length; j++) {
-                const permutationPrefix = smallerPermutation.slice(0, j);
-                const permutationSuffix = smallerPermutation.slice(j);
-                permutations.push(permutationPrefix.concat([firstOption], permutationSuffix));
-            }
-        }
-        return permutations;
-    }
-}
+class Permutation {
+    static withDiscount(arr, l = arr.length) {
+        if (l === 1) return arr.map((n) => [n]);
+        const permutations = [];
+        let smallerPermutations;
+        smallerPermutations = this.withDiscount(arr, l - 1);
+        arr.forEach((currentOption) => {
+            smallerPermutations.forEach((smallerPermutation) => {
+                permutations.push([currentOption].concat(smallerPermutation));
+            });
+        });
+        return permutations;
+    }
+    static withoutDiscount(arr) {
+        const l = arr.length;
+        if (l === 1) return arr.map((n) => [n]);
+        const permutations = [];
+        const smallerPermutations = this.withoutDiscount(arr.slice(1));
+        const firstOption = arr[0];
+        for (let i = 0; i < smallerPermutations.length; i++) {
+            const smallerPermutation = smallerPermutations[i];
+            for (let j = 0; j <= smallerPermutation.length; j++) {
+                const permutationPrefix = smallerPermutation.slice(0, j);
+                const permutationSuffix = smallerPermutation.slice(j);
+                permutations.push(permutationPrefix.concat([firstOption], permutationSuffix));
+            }
+        }
+        return permutations;
+    }
+}
 export { Permutation }

package/src/math/discret/Set/index.js

@@ -1,2 +1,2 @@
-export * from "./power-set.js";
+export * from "./power-set.js";
 export * from "./sub-set.js";

package/src/math/discret/Set/power-set.js

@@ -1,15 +1,15 @@
-const powerSet=originalSet=>{
-    const subSets = [];
-    const NUMBER_OF_COMBINATIONS = 2 ** originalSet.length;
-    for (let i = 0; i < NUMBER_OF_COMBINATIONS; i += 1) {
-        const subSet = [];
-        for (let j = 0; j < originalSet.length; j += 1) {
-            if (i & (1 << j)) {
-                subSet.push(originalSet[j]);
-            }
-        }
-        subSets.push(subSet);
-    }
-    return subSets;
-}
+const powerSet=originalSet=>{
+    const subSets = [];
+    const NUMBER_OF_COMBINATIONS = 2 ** originalSet.length;
+    for (let i = 0; i < NUMBER_OF_COMBINATIONS; i += 1) {
+        const subSet = [];
+        for (let j = 0; j < originalSet.length; j += 1) {
+            if (i & (1 << j)) {
+                subSet.push(originalSet[j]);
+            }
+        }
+        subSets.push(subSet);
+    }
+    return subSets;
+}
 export{powerSet}

package/src/math/discret/Set/sub-set.js

@@ -1,10 +1,10 @@
-import { arange } from "../../utils/index.js";
-
-// const subSet = (...arr) => {
-//     let list = arange(0, 2 ** arr.length, 1);
-//     let bin = list.map((n) => n.toString(2).padStart(arr.length, '0')).map((n) => n.split("").map((n) => +n));
-//     let sub = bin.map((n) => n.map((m, i) => (m === 1 ? arr[i] : null))).map((n) => n.filter((x) => x !== null));
-//     return sub;
-// };
-const subSet = null
-export { subSet };
+import { arange } from "../../utils/index.js";
+
+// const subSet = (...arr) => {
+//     let list = arange(0, 2 ** arr.length, 1);
+//     let bin = list.map((n) => n.toString(2).padStart(arr.length, '0')).map((n) => n.split("").map((n) => +n));
+//     let sub = bin.map((n) => n.map((m, i) => (m === 1 ? arr[i] : null))).map((n) => n.filter((x) => x !== null));
+//     return sub;
+// };
+const subSet = null
+export { subSet };

package/src/math/discret/index.js

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