ziko 0.0.13 → 0.0.15

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,23 +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"
-
-
-const Discret={
-    Logic,
-    Base,
-    Permutation,
-    Combinaison,
-    combinaison,
-    powerSet,
-    subSet
-}
-export default Discret;
-export{Logic,Base,Permutation,Combinaison,powerSet,subSet}
+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}

package/src/math/functions/helper.js

@@ -0,0 +1,20 @@
+export const Fixed={
+    cos:x=>+Math.cos(x).toFixed(15),
+    sin:x=>+Math.sin(x).toFixed(15),
+    tan:x=>+Math.tan(x).toFixed(31),
+    sinc:x=>+Math.sin(Math.PI*x)/(Math.PI*x),
+    sec:x=>+1/Math.cos(x).toFixed(15),
+    csc:x=>+1/Math.sin(x).toFixed(15),
+    cot:x=>+1/Math.tan(x).toFixed(15),
+    acos:x=>+Math.acos(x).toFixed(15),
+    asin:x=>+Math.asin(x).toFixed(15),
+    atan:x=>+Math.atan(x).toFixed(15),
+    acot:x=>+Math.PI/2-Math.atan(x).toFixed(15),
+    cosh:x=>+Math.cosh(x).toFixed(15),
+    sinh:x=>+Math.sinh(x).toFixed(15),
+    tanh:x=>+Math.tanh(x).toFixed(15),
+    coth:n=>+(1/2*Math.log((1+n)/(1-n))).toFixed(15),
+    acosh:x=>+Math.acosh(x).toFixed(15),
+    asinh:x=>+Math.asinh(x).toFixed(15),
+    atanh:x=>+Math.atanh(x).toFixed(15),
+}

package/src/math/functions/index.js

@@ -1,182 +1,162 @@
-import { Complex } from "../complex/index.js";
-import { mapfun } from "../utils/mapfun.js";
-import { 
-    min,
-    max 
-}from "../statistics/index.js";
-import { 
-    gamma,
-    bessel,
-    beta 
-} from "../calculus/index.js";
-export const Fixed={
-    cos:x=>+Math.cos(x).toFixed(15),
-    sin:x=>+Math.sin(x).toFixed(15),
-    tan:x=>+Math.tan(x).toFixed(31),
-    sinc:x=>+Math.sin(Math.PI*x)/(Math.PI*x),
-    sec:x=>+1/Math.cos(x).toFixed(15),
-    csc:x=>+1/Math.sin(x).toFixed(15),
-    cot:x=>+1/Math.tan(x).toFixed(15),
-    acos:x=>+Math.acos(x).toFixed(15),
-    asin:x=>+Math.asin(x).toFixed(15),
-    atan:x=>+Math.atan(x).toFixed(15),
-    acot:x=>+Math.PI/2-Math.atan(x).toFixed(15),
-    cosh:x=>+Math.cosh(x).toFixed(15),
-    sinh:x=>+Math.sinh(x).toFixed(15),
-    tanh:x=>+Math.tanh(x).toFixed(15),
-    coth:n=>+(1/2*Math.log((1+n)/(1-n))).toFixed(15),
-    acosh:x=>+Math.acosh(x).toFixed(15),
-    asinh:x=>+Math.asinh(x).toFixed(15),
-    atanh:x=>+Math.atanh(x).toFixed(15),
-
-
-}
-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 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(
-            x.z**n.a*e(-x.phi*n.b),
-            ln(x.z)*n.b+n.a*x.phi
-        )
-        else return mapfun(a=>pow(x,a),...n);
-    }
-    else if(x instanceof Array){
-        if(typeof n === "number") return mapfun(a=>pow(a,n),...x);
-        else if(n instanceof Array){
-            const Y=[];
-            for(let i=0;i<x.length;i++){
-                Y.push(mapfun(a=>pow(x[i],a),...n))
-            }
-            return Y;
-        }
-    }
-}
-const sqrtn=(x,n)=>{
-    if(typeof x === "number"){
-        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 return mapfun(a=>sqrtn(x,a),...n);
-    }
-    else if(x instanceof Array){
-        if(typeof n === "number") return mapfun(a=>sqrtn(a,n),...x);
-        else if(n instanceof Array){
-            const Y=[];
-            for(let i=0;i<x.length;i++){
-                Y.push(mapfun(a=>sqrtn(x[i],a),...n))
-            }
-            return Y;
-        }
-    }
-}
-const e=(...x)=>mapfun(Math.exp,...x);
-const ln=(...x)=>mapfun(Math.log,...x);
-const cos=(...x)=>mapfun(Fixed.cos,...x);
-const sin=(...x)=>mapfun(Fixed.sin,...x);
-const tan=(...x)=>mapfun(Fixed.tan,...x);
-const sec=(...x)=>mapfun(Fixed.sec,...x);
-const sinc=(...x)=>mapfun(Fixed.sinc,...x)
-const csc=(...x)=>mapfun(Fixed.csc,...x);
-const cot=(...x)=>mapfun(Fixed.cot,...x);
-const acos=(...x)=>mapfun(Fixed.acos,...x);
-const asin=(...x)=>mapfun(Fixed.asin,...x);
-const atan=(...x)=>mapfun(Fixed.atan,...x);
-const acot=(...x)=>mapfun(Fixed.acot,...x);
-const cosh=(...x)=>mapfun(Fixed.cosh,...x);
-const sinh=(...x)=>mapfun(Fixed.sinh,...x);
-const tanh=(...x)=>mapfun(Fixed.tanh,...x);
-const coth=(...x)=>mapfun(Fixed.coth,...x);
-const acosh=(...x)=>mapfun(Fixed.acosh,...x);
-const asinh=(...x)=>mapfun(Fixed.asinh,...x);
-const atanh=(...x)=>mapfun(Fixed.atanh,...x);
-const ceil=(...x)=>mapfun(Math.ceil,...x);
-const floor=(...x)=>mapfun(Math.floor,...x);
-const round=(...x)=>mapfun(Math.round,...x);
-const atan2=(x,y,rad=true)=>{
-    if(typeof x === "number"){
-        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 return mapfun(a=>pow(x,a),...n);
-    // }
-    else if(x instanceof Array){
-        if(typeof y === "number") return mapfun(a=>atan2(a,y,rad),...x);
-        else if(y instanceof Array){
-            const Y=[];
-            for(let i=0;i<x.length;i++){
-                Y.push(mapfun(a=>pow(x[i],a,rad),...y))
-            }
-            return Y;
-        }
-    }
-}
-const fact=(...x)=>mapfun(n=> {
-        let i,
-        y = 1;
-        if (n == 0) y = 1;
-        else if (n > 0) for (i = 1; i <= n; i++) y *= i;
-        else y = NaN;
-        return y;
-    },...x);
-const sign=(...x)=>mapfun(Math.sign,...x);
-
-const sig=(...x)=>mapfun(n=>1/(1+e(-n)),...x);
-
-const hypot=(...x)=>{
-    if(x.every(n=>typeof n === "number"))return Math.hypot(...x);
-    if(x.every(n=>n instanceof Array))return mapfun(
-        Math.hypot,
-        ...x
-    )
-}
-
-export{
-    cos,
-    sin,
-    tan,
-    sinc,
-    cot,
-    sec,
-    csc,
-    abs,
-    sqrt,
-    pow,
-    sqrtn,
-    e,
-    ln,
-    acos,
-    asin,
-    atan,
-    acot,
-    cosh,
-    sinh,
-    tanh,
-    coth,
-    acosh,
-    asinh,
-    atanh,
-    min,
-    max,
-    sign,
-    floor,
-    ceil,
-    round,
-    fact,
-    hypot,
-    sig,
-    atan2,
-    gamma,
-    bessel,
-    beta
+import { Fixed } from "./helper.js";
+import { Complex } from "../complex/index.js";
+import { mapfun } from "../utils/mapfun.js";
+import { 
+    min,
+    max 
+}from "../statistics/index.js";
+import { 
+    gamma,
+    bessel,
+    beta 
+} from "../calculus/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 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(
+            x.z**n.a*e(-x.phi*n.b),
+            ln(x.z)*n.b+n.a*x.phi
+        )
+        else return mapfun(a=>pow(x,a),...n);
+    }
+    else if(x instanceof Array){
+        if(typeof n === "number") return mapfun(a=>pow(a,n),...x);
+        else if(n instanceof Array){
+            const Y=[];
+            for(let i=0;i<x.length;i++){
+                Y.push(mapfun(a=>pow(x[i],a),...n))
+            }
+            return Y;
+        }
+    }
+}
+const sqrtn=(x,n)=>{
+    if(typeof x === "number"){
+        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 return mapfun(a=>sqrtn(x,a),...n);
+    }
+    else if(x instanceof Array){
+        if(typeof n === "number") return mapfun(a=>sqrtn(a,n),...x);
+        else if(n instanceof Array){
+            const Y=[];
+            for(let i=0;i<x.length;i++){
+                Y.push(mapfun(a=>sqrtn(x[i],a),...n))
+            }
+            return Y;
+        }
+    }
+}
+const e=(...x)=>mapfun(Math.exp,...x);
+const ln=(...x)=>mapfun(Math.log,...x);
+const cos=(...x)=>mapfun(Fixed.cos,...x);
+const sin=(...x)=>mapfun(Fixed.sin,...x);
+const tan=(...x)=>mapfun(Fixed.tan,...x);
+const sec=(...x)=>mapfun(Fixed.sec,...x);
+const sinc=(...x)=>mapfun(Fixed.sinc,...x)
+const csc=(...x)=>mapfun(Fixed.csc,...x);
+const cot=(...x)=>mapfun(Fixed.cot,...x);
+const acos=(...x)=>mapfun(Fixed.acos,...x);
+const asin=(...x)=>mapfun(Fixed.asin,...x);
+const atan=(...x)=>mapfun(Fixed.atan,...x);
+const acot=(...x)=>mapfun(Fixed.acot,...x);
+const cosh=(...x)=>mapfun(Fixed.cosh,...x);
+const sinh=(...x)=>mapfun(Fixed.sinh,...x);
+const tanh=(...x)=>mapfun(Fixed.tanh,...x);
+const coth=(...x)=>mapfun(Fixed.coth,...x);
+const acosh=(...x)=>mapfun(Fixed.acosh,...x);
+const asinh=(...x)=>mapfun(Fixed.asinh,...x);
+const atanh=(...x)=>mapfun(Fixed.atanh,...x);
+const ceil=(...x)=>mapfun(Math.ceil,...x);
+const floor=(...x)=>mapfun(Math.floor,...x);
+const round=(...x)=>mapfun(Math.round,...x);
+const atan2=(x,y,rad=true)=>{
+    if(typeof x === "number"){
+        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 return mapfun(a=>pow(x,a),...n);
+    // }
+    else if(x instanceof Array){
+        if(typeof y === "number") return mapfun(a=>atan2(a,y,rad),...x);
+        else if(y instanceof Array){
+            const Y=[];
+            for(let i=0;i<x.length;i++){
+                Y.push(mapfun(a=>pow(x[i],a,rad),...y))
+            }
+            return Y;
+        }
+    }
+}
+const fact=(...x)=>mapfun(n=> {
+        let i,
+        y = 1;
+        if (n == 0) y = 1;
+        else if (n > 0) for (i = 1; i <= n; i++) y *= i;
+        else y = NaN;
+        return y;
+    },...x);
+const sign=(...x)=>mapfun(Math.sign,...x);
+
+const sig=(...x)=>mapfun(n=>1/(1+e(-n)),...x);
+
+const hypot=(...x)=>{
+    if(x.every(n=>typeof n === "number"))return Math.hypot(...x);
+    if(x.every(n=>n instanceof Array))return mapfun(
+        Math.hypot,
+        ...x
+    )
+}
+
+export{
+    cos,
+    sin,
+    tan,
+    sinc,
+    cot,
+    sec,
+    csc,
+    abs,
+    sqrt,
+    pow,
+    sqrtn,
+    e,
+    ln,
+    acos,
+    asin,
+    atan,
+    acot,
+    cosh,
+    sinh,
+    tanh,
+    coth,
+    acosh,
+    asinh,
+    atanh,
+    min,
+    max,
+    sign,
+    floor,
+    ceil,
+    round,
+    fact,
+    hypot,
+    sig,
+    atan2,
+    gamma,
+    bessel,
+    beta
   };