ziko 0.54.5 → 0.55.0

package/src/math/random/index.js

@@ -1,169 +1,125 @@
+import { base2base } from "../functions/conversions/index.js";
+import { accum_sum } from "../functions/stats/index.js";
 
-import { Utils } from "../utils/index.js";
-import{ Base } from "../discret/index.js"
-class Random {
-    static float(a = 1, b) {
-        return b ? Math.random() * (b - a) + a : a * Math.random();
-    }
-    static int(a, b) {
+export class Random {
+    static int(a, b){
         return Math.floor(this.float(a, b));
     }
-    static char(upperCase){
-        upperCase=upperCase??this.bool();
-        const Char=String.fromCharCode(this.int(97,120));
-        return upperCase?Char.toUpperCase():Char;
-    }
-    static bool(){
-        return [false,true][Math.floor(Math.random()*2)];
-    }
-    static string(length,upperCase){
-        return length instanceof Array?
-            new Array(this.int(...length)).fill(0).map(() => this.char(upperCase)).join(""):
-            new Array(length).fill(0).map(() => this.char(upperCase)).join("");
+    static float(a, b){
+        return b !== undefined
+            ? Math.random() * (b - a) + a
+            : Math.random() * a;
     }
-    static bin() {
+    static bin(){
         return this.int(2);
     }
-    static oct() {
-        return this.int(8);
-    }
-    static dec() {
+    static oct(){
         return this.int(8);
     }
-    static hex() {
-        return this.int(16);
-    }
-    static choice(choices = [1, 2, 3], p = new Array(choices.length).fill(1 / choices.length)) {
-        let newchoice = new Array(100);
-        p=Utils.accum(...p).map(n=>n*100)
-        newchoice.fill(choices[0], 0, p[0]);
-        for (let i = 1; i < choices.length; i++) newchoice.fill(choices[i], p[i - 1], p[i]);
-        return newchoice[this.int(newchoice.length - 1)];
-    }
-    static shuffleArr(arr){
-        return arr.sort(()=>0.5-Math.random())    
-    }
-    static floats(n, a, b) {
-        return new Array(n).fill(0).map(() => this.float(a, b));
-    }
-    static ints(n, a, b) {
-        return new Array(n).fill(0).map(() => this.int(a, b));
-    }
-    static bools(n){
-        return  new Array(n).fill(0).map(() => this.bool());
+    static dec(){
+        return this.int(10);
     }
-    static bins(n) {
-        return new Array(n).fill(0).map(() => this.int(2));
+    static hex(){
+        return base2base(this.int(16), 10, 16);
     }
-    static octs(n) {
-        return new Array(n).fill(0).map(() => this.int(8));
+    static char(upperCase = false){
+        const i = upperCase
+            ? this.int(65, 91)
+            : this.int(97, 123);
+        return String.fromCharCode(i);
     }
-    static decs(n) {
-        return new Array(n).fill(0).map(() => this.int(10));
-    }
-    static hexs(n) {
-        return new Array(n).fill(0).map(() => this.int(16));
-    }
-    static choices(n, choices, p) {
-        return new Array(n).fill(0).map(() => this.choice(choices, p));
-    }
-    static perm(...arr) {
-        // permutation
-        return arr.permS[this.int(arr.length)];
-    }
-    static color() {
-        return "#" + Base.dec2hex(this.float(16777216)).padStart(6,0);
-    }
-    static colors(n) {
-        return new Array(n).fill(null).map(()=>this.color());
+    static bool(){
+        return Boolean(this.int(2));
     }
+    static get color(){
+        return {
+            hex : () =>
+                `#${this.int(0xffffff).toString(16).padStart(6, '0')}`,
 
-    // Should be Moved to Matrix and Complex to avoid Circular dependencies
-    // static complex(a = [0,1], b = [0,1]) {
-    //     return a instanceof Array?
-    //     new Complex(
-    //         this.float(a[0], a[1]),
-    //         this.float(b[0], b[1])
-    //     ):
-    //     new Complex(
-    //         ...this.floats(2,a,b)
-    //     )
-        
-    // }
-    // static complexInt(a = [0,1], b = [0,1]) {
-    //     return new Complex(
-    //         this.int(a[0], a[1]),
-    //         this.int(b[0], b[1])
-    //         );
-    // }
-    // static complexBin() {
-    //     return new Complex(...this.bins(2));
-    // }
-    // static complexOct() {
-    //     return new Complex(...this.octs(2));
-    // }
-    // static complexDec() {
-    //     return new Complex(...this.decs(10));
-    // }
-    // static complexHex() {
-    //     return new Complex(...this.octs(2));
-    // }
-    // static complexes(n, a = 0, b = 1) {
-    //     return new Array(n).fill(0).map(() => this.complex(a, b));
-    // }
-    // static complexesInt(n, a = 0, b = 1) {
-    //     return new Array(n).fill(0).map(() => this.complexInt(a, b));
-    // }
-    // static complexesBin(n) {
-    //     return new Array(n).fill(0).map(() => this.complexBin());
-    // }
-    // static complexesOct(n) {
-    //     return new Array(n).fill(0).map(() => this.complexOct());
-    // }
-    // static complexesDec(n) {
-    //     return new Array(n).fill(0).map(() => this.complexDec());
-    // }
-    // static complexesHex(n) {
-    //     return new Array(n).fill(0).map(() => this.complexHex());
-    // }
-    // static matrix(r,c,min,max){
-    //     return matrix(r,c,this.floats(r*c,min,max))
-    // }
-    // static matrixInt(r,c,min,max){
-    //     return matrix(r,c,this.ints(r*c,min,max))
-    // }
-    // static matrixBin(r,c){
-    //     return matrix(r,c,this.bins(r*c))
-    // }
-    // static matrixOct(r,c){
-    //     return matrix(r,c,this.octs(r*c))
-    // }
-    // static matrixDec(r,c){
-    //     return matrix(r,c,this.decs(r*c))
-    // }
-    // static matrixHex(r,c){
-    //     return matrix(r,c,this.hex(r*c))
-    // }
-    // static matrixColor(r,c){
-    //     return matrix(r,c,this.colors(r*c))
-    // }
-    // static matrixComplex(r,c,a,b){
-    //     return matrix(r,c,this.complexes(r*c,a,b))
-    // }
-    // static matrixComplexInt(r,c,a,b){
-    //     return matrix(r,c,this.complexesInt(r*c,a,b))
-    // }
-    // static matrixComplexBin(r,c){
-    //     return matrix(r,c,this.complexesBin(r*c))
-    // }
-    // static matrixComplexOct(r,c){
-    //     return matrix(r,c,this.complexesBin(r*c))
-    // }
-    // static matrixComplexDec(r,c){
-    //     return matrix(r,c,this.complexesBin(r*c))
-    // }
-    // static matrixComplexHex(r,c){
-    //     return matrix(r,c,this.complexesBin(r*c))
-    // }
+            hexa : () => {
+                const [r,g,b,a] = Array.from(
+                    {length:4},
+                    () => this.int(0xff).toString(16).padStart(2,'0')
+                );
+                return `#${r}${g}${b}${a}`;
+            },
+            rgb : () => {
+                const [r,g,b] = Array.from({length:3}, () => this.int(0xff));
+                return `rgb(${r}, ${g}, ${b})`;
+            },
+            rgba : () => {
+                const [r,g,b] = Array.from({length:3}, () => this.int(0xff));
+                const a = Math.random().toFixed(2);
+                return `rgba(${r}, ${g}, ${b}, ${a})`;
+            },
+            hsl : () => {
+                const h = this.int(360);
+                const s = this.int(100);
+                const l = this.int(100);
+                return `hsl(${h}, ${s}%, ${l}%)`;
+            },
+            hsla : () => {
+                const h = this.int(360);
+                const s = this.int(100);
+                const l = this.int(100);
+                const a = Math.random().toFixed(2);
+                return `hsla(${h}, ${s}%, ${l}%, ${a})`;
+            },
+            gray : () => {
+                const g = this.int(0xff);
+                return `rgb(${g}, ${g}, ${g})`;
+            }
+        };
+    }
+    static get sample(){
+        const R = this;
+        return {
+            int   : (n,a,b) => Array.from({length:n}, () => R.int(a,b)),
+            float : (n,a,b) => Array.from({length:n}, () => R.float(a,b)),
+            char  : (n,upper=false) => Array.from({length:n}, () => R.char(upper)),
+            bool  : n => Array.from({length:n}, () => R.bool()),
+            bin   : n => Array.from({length:n}, () => R.bin()),
+            oct   : n => Array.from({length:n}, () => R.oct()),
+            dec   : n => Array.from({length:n}, () => R.dec()),
+            hex   : n => Array.from({length:n}, () => R.hex()),
+            get color(){
+                return {
+                    hex  : n => Array.from({length:n}, () => R.color.hex()),
+                    hexa : n => Array.from({length:n}, () => R.color.hexa()),
+                    rgb  : n => Array.from({length:n}, () => R.color.rgb()),
+                    rgba : n => Array.from({length:n}, () => R.color.rgba()),
+                    hsl  : n => Array.from({length:n}, () => R.color.hsl()),
+                    hsla : n => Array.from({length:n}, () => R.color.hsla()),
+                    gray : n => Array.from({length:n}, () => R.color.gray())
+                };
+            },
+            choice : (n, choices, p) =>
+                Array.from({length:n}, () => R.choice(choices, p))
+        };
+    }
+    static shuffle(arr){
+        return [...arr].sort(() => 0.5 - Math.random());
+    }
+    static choice(choices = [1,2,3], p = new Array(choices.length).fill(1 / choices.length)){
+        const acc = accum_sum(...p).map(v => v * 100);
+        const pool = new Array(100);
+        pool.fill(choices[0], 0, acc[0]);
+        for(let i=1;i<choices.length;i++)
+            pool.fill(choices[i], acc[i-1], acc[i]);
+        return pool[this.int(pool.length)];
+    }
 }
-export{Random}
+
+
+globalThis.Random = Random
+
+// // (upperCase) => upperCase ? : String.fromCharCode(rand_int(97,120))
+// class Random {
+//     static string(length,upperCase){
+//         return length instanceof Array?
+//             new Array(this.int(...length)).fill(0).map(() => this.char(upperCase)).join(""):
+//             new Array(length).fill(0).map(() => this.char(upperCase)).join("");
+//     }
+
+// }
+// export{Random}

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);
+// /** @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);
+// /**
+//  * 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
-}
+// export {
+//     deg2rad,
+//     rad2deg
+// }

package/src/math/utils/index.js

@@ -23,11 +23,11 @@ import {
 //     deg2rad,
 //     rad2deg
 // } from "./conversions.js"
-import{
-    sum,
-    prod,
-    accum
-} from "../statistics/index.js"
+// import{
+//     sum,
+//     prod,
+//     accum
+// } from "../statistics/index.js"
 import{
     inRange,
     isApproximatlyEqual
@@ -56,9 +56,9 @@ const Utils={
     logspace,
     geomspace,
 
-    sum,
-    prod,
-    accum,
+    // sum,
+    // prod,
+    // accum,
 
     cartesianProduct,
     ppcm,
@@ -76,8 +76,8 @@ export {
     zeros,
     ones,
     nums,
-    sum,
-    prod,
+    // sum,
+    // prod,
     // add,
     // mul,
     // sub,

package/types/math/complex/index.d.ts

@@ -35,17 +35,17 @@ export declare class Complex {
     mul(...z: (number | Complex)[]): this;
     div(...z: (number | Complex)[]): this;
     pow(n: number): this;
-    nrth(n?: number): Complex;
+    nthr(n?: number): Complex;
 
-    static Zero(): Complex;
-    static Twiddle(N : number, K : number): Complex;
-    static fromExpo(z: number, phi: number): Complex;
+    static zero(): Complex;
+    static twiddle(N : number, K : number): Complex;
+    static fromPolar(z: number, phi: number): Complex;
+    
     static add(c: Complex, ...z: (number | Complex)[]): Complex;
     static sub(c: Complex, ...z: (number | Complex)[]): Complex;
     static mul(c: Complex, ...z: (number | Complex)[]): Complex;
     static div(c: Complex, ...z: (number | Complex)[]): Complex;
     static pow(c: Complex, n: number): Complex;
-    static xpowZ(x: number): Complex;
 }
 
 export declare function complex(a: number, b?: number): Complex;

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

@@ -1,34 +0,0 @@
-class Combinaison {
-    static withDiscount(comboOptions, comboLength) {
-        if (comboLength === 1) {
-            return comboOptions.map((comboOption) => [comboOption]);
-        }
-        const combos = [];
-        comboOptions.forEach((currentOption, optionIndex) => {
-            const smallerCombos = this.withDiscount(comboOptions.slice(optionIndex), comboLength - 1);
-            smallerCombos.forEach((smallerCombo) => {
-                combos.push([currentOption].concat(smallerCombo));
-            });
-        });
-        return combos;
-    }
-    static withoutDiscount(comboOptions, comboLength) {
-        if (comboLength === 1) {
-            return comboOptions.map((comboOption) => [comboOption]);
-        }
-        const combos = [];
-        comboOptions.forEach((currentOption, optionIndex) => {
-            const smallerCombos = this.withoutDiscount(comboOptions.slice(optionIndex + 1), comboLength - 1);
-            smallerCombos.forEach((smallerCombo) => {
-                combos.push([currentOption].concat(smallerCombo));
-            });
-        });
-
-        return combos;
-    }
-}
-const combinaison=(comboOptions, comboLength, discount=false)=>Combinaison[discount?"withDiscount":"withoutDiscount"](comboOptions, comboLength)
-export{ 
-    Combinaison,
-    combinaison
- }

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

@@ -1,86 +0,0 @@
-import { Complex } from "../../complex/index.js";
-import { Matrix } from "../../matrix/index.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/Permutation/index.js

@@ -1,31 +0,0 @@
-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/index.js

@@ -1,12 +0,0 @@
-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/statistics/functions/index.js

@@ -1,100 +0,0 @@
-// 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 +0,0 @@
-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"