numz 0.6.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numz",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "scientific computing with zikojs",
   "main": "index.js",
   "type": "module",

package/src/index.js

@@ -1,6 +1,6 @@
 export * from './ufunc/index.js'
+export * from './random/index.js'
+export * from './complex/index.js'
 export * from './calculus/index.js'
 export * from './signal/index.js'
 export * from './stats/index.js'
-export * from './complex/index.js'
-

package/src/random/index.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Utility class for generating random values.
+ */
+export declare class Random {
+
+    /**
+     * Generates a random integer.
+     * @param a Minimum value (inclusive).
+     * @param b Maximum value (exclusive).
+     */
+    static int(a: number, b?: number): number;
+
+    /**
+     * Generates a random floating-point number.
+     * @param a Minimum value.
+     * @param b Maximum value.
+     */
+    static float(a: number, b?: number): number;
+
+    /**
+     * Generates a random binary value.
+     */
+    static bin(): 0 | 1;
+
+    /**
+     * Generates a random octal digit.
+     */
+    static oct(): number;
+
+    /**
+     * Generates a random decimal digit.
+     */
+    static dec(): number;
+
+    /**
+     * Generates a random hexadecimal digit.
+     */
+    static hex(): string;
+
+    /**
+     * Generates a random alphabetic character.
+     * @param upperCase Generate uppercase character when true.
+     */
+    static char(upperCase?: boolean): string;
+
+    /**
+     * Generates a random boolean value.
+     */
+    static bool(): boolean;
+
+    /**
+     * Random color generators.
+     */
+    static readonly color: {
+        /** Generates a random HEX color. */
+        hex(): string;
+
+        /** Generates a random HEXA color with alpha channel. */
+        hexa(): string;
+
+        /** Generates a random RGB color. */
+        rgb(): string;
+
+        /** Generates a random RGBA color. */
+        rgba(): string;
+
+        /** Generates a random HSL color. */
+        hsl(): string;
+
+        /** Generates a random HSLA color with alpha channel. */
+        hsla(): string;
+
+        /** Generates a random grayscale RGB color. */
+        gray(): string;
+    };
+
+    /**
+     * Generates arrays of random values.
+     */
+    static readonly sample: {
+
+        /**
+         * Generates an array of random integers.
+         */
+        int(n: number, a: number, b?: number): number[];
+
+        /**
+         * Generates an array of random floats.
+         */
+        float(n: number, a: number, b?: number): number[];
+
+        /**
+         * Generates an array of random characters.
+         */
+        char(n: number, upper?: boolean): string[];
+
+        /**
+         * Generates an array of random booleans.
+         */
+        bool(n: number): boolean[];
+
+        /**
+         * Generates an array of random binary values.
+         */
+        bin(n: number): (0 | 1)[];
+
+        /**
+         * Generates an array of random octal digits.
+         */
+        oct(n: number): number[];
+
+        /**
+         * Generates an array of random decimal digits.
+         */
+        dec(n: number): number[];
+
+        /**
+         * Generates an array of random hexadecimal digits.
+         */
+        hex(n: number): string[];
+
+        /**
+         * Generates arrays of random colors.
+         */
+        readonly color: {
+            hex(n: number): string[];
+            hexa(n: number): string[];
+            rgb(n: number): string[];
+            rgba(n: number): string[];
+            hsl(n: number): string[];
+            hsla(n: number): string[];
+            gray(n: number): string[];
+        };
+
+        /**
+         * Generates an array of random choices from a list.
+         * @param n Number of generated values.
+         * @param choices Available values.
+         * @param p Probability distribution for each value.
+         */
+        choice<T>(
+            n: number,
+            choices: T[],
+            p?: number[]
+        ): T[];
+    };
+
+    /**
+     * Returns a shuffled copy of an array.
+     */
+    static shuffle<T>(arr: T[]): T[];
+
+    /**
+     * Randomly selects a value from a list.
+     * @param choices Available values.
+     * @param p Probability distribution for each value.
+     */
+    static choice<T>(
+        choices?: T[],
+        p?: number[]
+    ): T;
+}

package/src/random/index.js

@@ -0,0 +1,111 @@
+// import { base2base } from "../../../dep/--from-ziko/functions/conversions/index.js";
+import { accum_sum } from "../stats";
+
+export class Random {
+    static int(a, b){
+        return Math.floor(this.float(a, b));
+    }
+    static float(a, b){
+        return b !== undefined
+            ? Math.random() * (b - a) + a
+            : Math.random() * a;
+    }
+    static bin(){
+        return this.int(2);
+    }
+    static oct(){
+        return this.int(8);
+    }
+    static dec(){
+        return this.int(10);
+    }
+    // static hex(){
+    //     return base2base(this.int(16), 10, 16);
+    // }
+    static char(upperCase = false){
+        const i = upperCase
+            ? this.int(65, 91)
+            : this.int(97, 123);
+        return String.fromCharCode(i);
+    }
+    static bool(){
+        return Boolean(this.int(2));
+    }
+    static get color(){
+        return {
+            hex : () =>
+                `#${this.int(0xffffff).toString(16).padStart(6, '0')}`,
+
+            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)];
+    // }
+}