ziko 0.0.17 → 0.0.19

package/src/math/statistics/Functions/index.js

@@ -1,100 +1,100 @@
-// Mixed calcul
-const sum=(...x)=>{
-    if(x.every(n=>typeof n==="number")){
-        let s = x[0];
-        for (let i = 1; i < x.length; i++) s += x[i];
-        return s;
-    }
-    const Y=[];
-    for(let i=0;i<x.length;i++){
-        if(x[i] instanceof Array)Y.push(sum(...x[i]));
-        else if(x[i] instanceof Object){
-            Y.push(sum(...Object.values(x[i])))
-        }
-    }
-    return Y.length===1?Y[0]:Y;
-}
-const prod=(...x)=>{
-    if(x.every(n=>typeof n==="number")){
-        let p = x[0];
-        for (let i = 1; i < x.length; i++) p *= x[i];
-        return p;
-    }
-    const Y=[];
-    for(let i=0;i<x.length;i++){
-        if(x[i] instanceof Array)Y.push(prod(...x[i]));
-        else if(x[i] instanceof Object){
-            Y.push(prod(...Object.values(x[i])))
-        }
-    }
-    return Y.length===1?Y[0]:Y;
-}
-const min=(...num)=>{
-    if(num.every(n=>typeof n==="number"))return Math.min(...num);
-    const Y=[];
-    for(let i=0;i<num.length;i++){
-        if(num[i] instanceof Array)Y.push(min(...num[i]));
-        else if(num[i] instanceof Object){
-            Y.push(
-                    Object.fromEntries(
-                        [Object.entries(num[i]).sort((a,b)=>a[1]-b[1])[0]]
-                    )
-                )
-        }
-    }
-    return Y.length===1?Y[0]:Y;
-}
-const max=(...num)=>{
-    if(num.every(n=>typeof n==="number"))return Math.max(...num);
-    const Y=[];
-    for(let i=0;i<num.length;i++){
-        if(num[i] instanceof Array)Y.push(min(...num[i]));
-        else if(num[i] instanceof Object){
-            Y.push(
-                    Object.fromEntries(
-                        [Object.entries(num[i]).sort((a,b)=>b[1]-a[1])[0]]
-                    )
-                )
-        }
-    }
-    return Y.length===1?Y[0]:Y;
-}
-const accum=(...num)=>{
-    if(num.every(n=>typeof n==="number")){
-        let acc = num.reduce((x, y) => [...x, x[x.length - 1] + y], [0]);
-        acc.shift();
-        return acc;
-    }
-    const Y=[];
-    for(let i=0;i<num.length;i++){
-        if(num[i] instanceof Array)Y.push(accum(...num[i]));
-        else if(num[i] instanceof Object){
-            Y.push(null
-                    // Object.fromEntries(
-                    //     [Object.entries(num[i]).sort((a,b)=>b[1]-a[1])[0]]
-                    // )
-                )
-        }
-    }
-    return Y.length===1?Y[0]:Y;
-}
-
-// sort
-
-export{
-    sum,
-    prod,
-    min,
-    max,
-    accum
-}
-
-//moy
-//med
-//variance
-//std
-//mode
-//acccum
-//min2max
-//max2min
+// Mixed calcul
+const sum=(...x)=>{
+    if(x.every(n=>typeof n==="number")){
+        let s = x[0];
+        for (let i = 1; i < x.length; i++) s += x[i];
+        return s;
+    }
+    const Y=[];
+    for(let i=0;i<x.length;i++){
+        if(x[i] instanceof Array)Y.push(sum(...x[i]));
+        else if(x[i] instanceof Object){
+            Y.push(sum(...Object.values(x[i])))
+        }
+    }
+    return Y.length===1?Y[0]:Y;
+}
+const prod=(...x)=>{
+    if(x.every(n=>typeof n==="number")){
+        let p = x[0];
+        for (let i = 1; i < x.length; i++) p *= x[i];
+        return p;
+    }
+    const Y=[];
+    for(let i=0;i<x.length;i++){
+        if(x[i] instanceof Array)Y.push(prod(...x[i]));
+        else if(x[i] instanceof Object){
+            Y.push(prod(...Object.values(x[i])))
+        }
+    }
+    return Y.length===1?Y[0]:Y;
+}
+const min=(...num)=>{
+    if(num.every(n=>typeof n==="number"))return Math.min(...num);
+    const Y=[];
+    for(let i=0;i<num.length;i++){
+        if(num[i] instanceof Array)Y.push(min(...num[i]));
+        else if(num[i] instanceof Object){
+            Y.push(
+                    Object.fromEntries(
+                        [Object.entries(num[i]).sort((a,b)=>a[1]-b[1])[0]]
+                    )
+                )
+        }
+    }
+    return Y.length===1?Y[0]:Y;
+}
+const max=(...num)=>{
+    if(num.every(n=>typeof n==="number"))return Math.max(...num);
+    const Y=[];
+    for(let i=0;i<num.length;i++){
+        if(num[i] instanceof Array)Y.push(min(...num[i]));
+        else if(num[i] instanceof Object){
+            Y.push(
+                    Object.fromEntries(
+                        [Object.entries(num[i]).sort((a,b)=>b[1]-a[1])[0]]
+                    )
+                )
+        }
+    }
+    return Y.length===1?Y[0]:Y;
+}
+const accum=(...num)=>{
+    if(num.every(n=>typeof n==="number")){
+        let acc = num.reduce((x, y) => [...x, x[x.length - 1] + y], [0]);
+        acc.shift();
+        return acc;
+    }
+    const Y=[];
+    for(let i=0;i<num.length;i++){
+        if(num[i] instanceof Array)Y.push(accum(...num[i]));
+        else if(num[i] instanceof Object){
+            Y.push(null
+                    // Object.fromEntries(
+                    //     [Object.entries(num[i]).sort((a,b)=>b[1]-a[1])[0]]
+                    // )
+                )
+        }
+    }
+    return Y.length===1?Y[0]:Y;
+}
+
+// sort
+
+export{
+    sum,
+    prod,
+    min,
+    max,
+    accum
+}
+
+//moy
+//med
+//variance
+//std
+//mode
+//acccum
+//min2max
+//max2min
 //percentile

package/src/math/statistics/index.js

@@ -1,16 +1,16 @@
-import {
-    sum,
-    prod,
-    min,
-    max,
-    accum
-} from "./Functions/index.js"
-const Stats={
-    sum,
-    prod,
-    min,
-    max,
-    accum,
-}
-export default Stats;
+import {
+    sum,
+    prod,
+    min,
+    max,
+    accum
+} from "./Functions/index.js"
+const Stats={
+    sum,
+    prod,
+    min,
+    max,
+    accum,
+}
+export default Stats;
 export * from "./Functions/index.js"

package/src/math/utils/arithmetic.js

@@ -1,139 +1,139 @@
-import { Complex,complex} from "../complex/index.js";
-import { Matrix  } from "../matrix/index.js";
-const _add=(a,b)=>{
-    if(typeof(a)==="number"){
-        if (typeof b == "number") return a + b;
-        else if (b instanceof Complex)return complex(a + b.a, b.b);
-        else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).add(b);
-        else if (b instanceof Array)return b.map(n=>add(n,a));                 
-    }
-    else if(a instanceof Complex||a instanceof Matrix){
-        if(b instanceof Array)return b.map(n=>a.clone.add(n));
-        return a.clone.add(b);
-    }
-    else if(a instanceof Array){
-        if(b instanceof Array){
-            if(a.length === b.length)return a.map((n,i)=>add(n,b[i]))
-        }
-        else {
-            return a.map(n=>add(n,b));
-        }
-    }
-}
-const _sub=(a,b)=>{
-    if(typeof(a)==="number"){
-        if (typeof b == "number") return a - b;
-        else if (b instanceof Complex)return complex(a - b.a, -b.b);
-        else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).sub(b);
-        else if (b instanceof Array)return b.map(n=>sub(n,a));                 
-    }
-    else if(a instanceof Complex||a instanceof Matrix){
-        if(b instanceof Array)return b.map(n=>a.clone.sub(n));
-        return a.clone.sub(b);
-    }
-    else if(a instanceof Array){
-        if(b instanceof Array){
-            if(b instanceof Array){
-                if(a.length === b.length)return a.map((n,i)=>sub(n,b[i]))
-            }
-        }
-        else {
-            return a.map(n=>sub(n,b));
-        }
-    }
-}
-const _mul=(a,b)=>{
-    if(typeof(a)==="number"){
-    if (typeof b == "number") return a * b;
-        else if (b instanceof Complex)return complex(a * b.a,a * b.b);
-        else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).mul(b);
-        else if (b instanceof Array)return b.map(n=>mul(a,n)); 
-    }
-    else if(a instanceof Complex||a instanceof Matrix){
-        if(b instanceof Array)return b.map(n=>a.clone.mul(n));
-        return a.clone.mul(b);
-    }
-    else if(a instanceof Array){
-        if(b instanceof Array){
-            if(b instanceof Array){
-                if(a.length === b.length)return a.map((n,i)=>mul(n,b[i]))
-            }
-        }
-        else {
-            return a.map(n=>mul(n,b));
-        }
-    }
-}
-const _div=(a,b)=>{
-    if(typeof(a)==="number"){
-    if (typeof b == "number") return a / b;
-        else if (b instanceof Complex)return complex(a / b.a,a / b.b);
-        else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).div(b);
-        else if (b instanceof Array)return b.map(n=>div(a,n));
-    }
-    else if(a instanceof Complex||a instanceof Matrix){
-        if(b instanceof Array)return b.map(n=>a.clone.div(n));
-        return a.clone.div(b);
-    }
-    else if(a instanceof Array){
-        if(b instanceof Array){
-            if(b instanceof Array){
-                if(a.length === b.length)return a.map((n,i)=>div(n,b[i]))
-            }
-        }
-        else {
-            return a.map(n=>div(n,b));
-        }
-    }
-}
-const _modulo=(a,b)=>{
-    if(typeof(a)==="number"){
-        if (typeof b == "number") return a % b;
-            else if (b instanceof Complex)return complex(a % b.a,a % b.b);
-            else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).modulo(b);
-            else if (b instanceof Array)return b.map(n=>div(a,n));
-        }
-        else if(a instanceof Complex||a instanceof Matrix){
-            if(b instanceof Array)return b.map(n=>a.clone.div(n));
-            return a.clone.div(b);
-        }
-        else if(a instanceof Array){
-            if(b instanceof Array){
-            }
-            else {
-                return a.map(n=>add(n,b));
-            }
-        }
-}
-const add=(a,...b)=>{
-    var res=a;
-    for(let i=0;i<b.length;i++)res=_add(res,b[i])
-    return res;
-}
-const sub=(a,...b)=>{
-    var res=a;
-    for(let i=0;i<b.length;i++)res=_sub(res,b[i])
-    return res;
-}
-const mul=(a,...b)=>{
-    var res=a;
-    for(let i=0;i<b.length;i++)res=_mul(res,b[i])
-    return res;
-}
-const div=(a,...b)=>{
-    var res=a;
-    for(let i=0;i<b.length;i++)res=_div(res,b[i])
-    return res;
-}
-const modulo=(a,...b)=>{
-    var res=a;
-    for(let i=0;i<b.length;i++)res=_modulo(res,b[i])
-    return res;
-}
-export{
-    add,
-    sub,
-    mul,
-    div,
-    modulo
+import { Complex,complex} from "../complex/index.js";
+import { Matrix  } from "../matrix/index.js";
+const _add=(a,b)=>{
+    if(typeof(a)==="number"){
+        if (typeof b == "number") return a + b;
+        else if (b instanceof Complex)return complex(a + b.a, b.b);
+        else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).add(b);
+        else if (b instanceof Array)return b.map(n=>add(n,a));                 
+    }
+    else if(a instanceof Complex||a instanceof Matrix){
+        if(b instanceof Array)return b.map(n=>a.clone.add(n));
+        return a.clone.add(b);
+    }
+    else if(a instanceof Array){
+        if(b instanceof Array){
+            if(a.length === b.length)return a.map((n,i)=>add(n,b[i]))
+        }
+        else {
+            return a.map(n=>add(n,b));
+        }
+    }
+}
+const _sub=(a,b)=>{
+    if(typeof(a)==="number"){
+        if (typeof b == "number") return a - b;
+        else if (b instanceof Complex)return complex(a - b.a, -b.b);
+        else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).sub(b);
+        else if (b instanceof Array)return b.map(n=>sub(n,a));                 
+    }
+    else if(a instanceof Complex||a instanceof Matrix){
+        if(b instanceof Array)return b.map(n=>a.clone.sub(n));
+        return a.clone.sub(b);
+    }
+    else if(a instanceof Array){
+        if(b instanceof Array){
+            if(b instanceof Array){
+                if(a.length === b.length)return a.map((n,i)=>sub(n,b[i]))
+            }
+        }
+        else {
+            return a.map(n=>sub(n,b));
+        }
+    }
+}
+const _mul=(a,b)=>{
+    if(typeof(a)==="number"){
+    if (typeof b == "number") return a * b;
+        else if (b instanceof Complex)return complex(a * b.a,a * b.b);
+        else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).mul(b);
+        else if (b instanceof Array)return b.map(n=>mul(a,n)); 
+    }
+    else if(a instanceof Complex||a instanceof Matrix){
+        if(b instanceof Array)return b.map(n=>a.clone.mul(n));
+        return a.clone.mul(b);
+    }
+    else if(a instanceof Array){
+        if(b instanceof Array){
+            if(b instanceof Array){
+                if(a.length === b.length)return a.map((n,i)=>mul(n,b[i]))
+            }
+        }
+        else {
+            return a.map(n=>mul(n,b));
+        }
+    }
+}
+const _div=(a,b)=>{
+    if(typeof(a)==="number"){
+    if (typeof b == "number") return a / b;
+        else if (b instanceof Complex)return complex(a / b.a,a / b.b);
+        else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).div(b);
+        else if (b instanceof Array)return b.map(n=>div(a,n));
+    }
+    else if(a instanceof Complex||a instanceof Matrix){
+        if(b instanceof Array)return b.map(n=>a.clone.div(n));
+        return a.clone.div(b);
+    }
+    else if(a instanceof Array){
+        if(b instanceof Array){
+            if(b instanceof Array){
+                if(a.length === b.length)return a.map((n,i)=>div(n,b[i]))
+            }
+        }
+        else {
+            return a.map(n=>div(n,b));
+        }
+    }
+}
+const _modulo=(a,b)=>{
+    if(typeof(a)==="number"){
+        if (typeof b == "number") return a % b;
+            else if (b instanceof Complex)return complex(a % b.a,a % b.b);
+            else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).modulo(b);
+            else if (b instanceof Array)return b.map(n=>div(a,n));
+        }
+        else if(a instanceof Complex||a instanceof Matrix){
+            if(b instanceof Array)return b.map(n=>a.clone.div(n));
+            return a.clone.div(b);
+        }
+        else if(a instanceof Array){
+            if(b instanceof Array){
+            }
+            else {
+                return a.map(n=>add(n,b));
+            }
+        }
+}
+const add=(a,...b)=>{
+    var res=a;
+    for(let i=0;i<b.length;i++)res=_add(res,b[i])
+    return res;
+}
+const sub=(a,...b)=>{
+    var res=a;
+    for(let i=0;i<b.length;i++)res=_sub(res,b[i])
+    return res;
+}
+const mul=(a,...b)=>{
+    var res=a;
+    for(let i=0;i<b.length;i++)res=_mul(res,b[i])
+    return res;
+}
+const div=(a,...b)=>{
+    var res=a;
+    for(let i=0;i<b.length;i++)res=_div(res,b[i])
+    return res;
+}
+const modulo=(a,...b)=>{
+    var res=a;
+    for(let i=0;i<b.length;i++)res=_modulo(res,b[i])
+    return res;
+}
+export{
+    add,
+    sub,
+    mul,
+    div,
+    modulo
 }

package/src/math/utils/checkers.js

@@ -1,29 +1,29 @@
-/** @module Math */
-/**
- * Checks if a value is within the specified range.
- * @function
- * @param {number} x - The value to check.
- * @param {number} a - The start of the range.
- * @param {number} b - The end of the range.
- * @returns {boolean} Returns true if the value is within the range [a, b], otherwise false.
- */
-const inRange = (x, a, b) => {
-    const [min, max] = [Math.min(a, b), Math.max(a, b)];
-    return x >= min && x <= max;
-}
-
-/**
- * Checks if two numbers are approximately equal within a given error margin.
- * @param {number} a - The first number.
- * @param {number} b - The second number.
- * @param {number} [Err=0.0001] - The maximum acceptable difference between the two numbers.
- * @returns {boolean} Returns true if the two numbers are approximately equal within the specified error margin, otherwise false.
- */
-const isApproximatlyEqual = (a, b, Err = 0.0001) => {
-    return Math.abs(a - b) <= Err;
-}
-
-export {
-    inRange,
-    isApproximatlyEqual
-}
+/** @module Math */
+/**
+ * Checks if a value is within the specified range.
+ * @function
+ * @param {number} x - The value to check.
+ * @param {number} a - The start of the range.
+ * @param {number} b - The end of the range.
+ * @returns {boolean} Returns true if the value is within the range [a, b], otherwise false.
+ */
+const inRange = (x, a, b) => {
+    const [min, max] = [Math.min(a, b), Math.max(a, b)];
+    return x >= min && x <= max;
+}
+
+/**
+ * Checks if two numbers are approximately equal within a given error margin.
+ * @param {number} a - The first number.
+ * @param {number} b - The second number.
+ * @param {number} [Err=0.0001] - The maximum acceptable difference between the two numbers.
+ * @returns {boolean} Returns true if the two numbers are approximately equal within the specified error margin, otherwise false.
+ */
+const isApproximatlyEqual = (a, b, Err = 0.0001) => {
+    return Math.abs(a - b) <= Err;
+}
+
+export {
+    inRange,
+    isApproximatlyEqual
+}

package/src/math/utils/conversions.js

@@ -1,19 +1,19 @@
-/** @module Math */
-/**
- * Converts degrees to radians.
- * @param {...number} deg - Degrees to convert.
- * @returns {number|number[]} Returns an array of radians corresponding to the input degrees.
- */
-const deg2rad = (...deg) => mapfun(x => x * Math.PI / 180, ...deg);
-
-/**
- * Converts radians to degrees.
- * @param {...number} rad - Radians to convert.
- * @returns {number|number[]} Returns an array of degrees corresponding to the input radians.
- */
-const rad2deg = (...rad) => mapfun(x => x / Math.PI * 180, ...rad);
-
-export {
-    deg2rad,
-    rad2deg
-}
+/** @module Math */
+/**
+ * Converts degrees to radians.
+ * @param {...number} deg - Degrees to convert.
+ * @returns {number|number[]} Returns an array of radians corresponding to the input degrees.
+ */
+const deg2rad = (...deg) => mapfun(x => x * Math.PI / 180, ...deg);
+
+/**
+ * Converts radians to degrees.
+ * @param {...number} rad - Radians to convert.
+ * @returns {number|number[]} Returns an array of degrees corresponding to the input radians.
+ */
+const rad2deg = (...rad) => mapfun(x => x / Math.PI * 180, ...rad);
+
+export {
+    deg2rad,
+    rad2deg
+}