ziko 1.3.0 → 1.5.0

package/src/math/functions/signal/index.d.ts

@@ -0,0 +1,146 @@
+import type { Complex }from '../../complex/index.d.ts'
+/**
+ * Creates an array filled with zeros.
+ *
+ * @param n Array length.
+ */
+export declare function zeros(
+    n: number
+): number[];
+
+/**
+ * Creates an array filled with ones.
+ *
+ * @param n Array length.
+ */
+export declare function ones(
+    n: number
+): number[];
+
+/**
+ * Creates an array filled with a given value.
+ *
+ * @param n Array length.
+ * @param num Fill value.
+ */
+export declare function nums<T>(
+    n: number,
+    num: T
+): T[];
+
+
+/**
+ * Creates a range of numbers.
+ *
+ * Supports ascending and descending ranges.
+ *
+ * @param a Start value.
+ * @param b End value.
+ * @param step Step size.
+ * @param include Include end value.
+ *
+ * @example
+ * arange(0, 5, 1)
+ * // [0,1,2,3,4]
+ */
+export declare function arange(
+    a: number,
+    b: number,
+    step: number,
+    include?: boolean
+): number[];
+
+export declare function arange(
+    a: number[],
+    b: number,
+    step: number,
+    include?: boolean
+): number[][];
+
+export declare function arange(
+    a: number,
+    b: number[],
+    step: number,
+    include?: boolean
+): number[][];
+
+export declare function arange(
+    a: number[],
+    b: number[],
+    step: number,
+    include?: boolean
+): number[][];
+
+
+/**
+ * Generates evenly spaced numbers over an interval.
+ *
+ * @param a Start value.
+ * @param b End value.
+ * @param n Number of samples.
+ * @param endpoint Include endpoint.
+ */
+export declare function linspace(
+    a: number,
+    b: number,
+    n?: number,
+    endpoint?: boolean
+): number[];
+
+export declare function linspace<T extends Complex>(
+    a: number | T,
+    b: number | T,
+    n?: number,
+    endpoint?: boolean
+): T[];
+
+export declare function linspace(
+    a: number[],
+    b: number | number[],
+    n?: number,
+    endpoint?: boolean
+): number[][];
+
+
+/**
+ * Generates numbers spaced evenly on a logarithmic scale.
+ *
+ * @param a Start exponent.
+ * @param b End exponent.
+ * @param n Number of samples.
+ * @param base Logarithm base.
+ * @param endpoint Include endpoint.
+ */
+export declare function logspace(
+    a: number,
+    b: number,
+    n?: number,
+    base?: number,
+    endpoint?: boolean
+): number[];
+
+
+/**
+ * Generates numbers spaced evenly on a geometric progression.
+ *
+ * @param a Start value.
+ * @param b End value.
+ * @param n Number of samples.
+ * @param endpoint Include endpoint.
+ * @param precision Decimal precision.
+ */
+export declare function geomspace(
+    a: number,
+    b: number,
+    n?: number,
+    endpoint?: boolean,
+    precision?: number
+): number[];
+
+export declare function geomspace<T extends Complex>(
+    a: T | number,
+    b: T | number,
+    n?: number,
+    endpoint?: boolean,
+    precision?: number
+): T[];

package/src/math/functions/stats/index.js

@@ -15,26 +15,26 @@ export const binomial = (n, k) =>{
     return c;
 }
 
-export const mean = (...x) => x.reduce((a, b) => a + b) / x.length;
-
-export const variance = (...x) => {
-  const n = x.length;
-  if (n === 0) return NaN;
-  const x_mean = mean(...x);
-  return x.reduce((sum, xi) => sum + (xi - x_mean) ** 2, 0) / n;
-};
-
-export const std = (...x) => Math.sqrt(variance(...x));
-
-export const accum_sum = (...x) => {
-  let result = [];
-  let total = 0, i, n = x.length;
-  for(i = 0; i < n ; i++){
-    total = add(total, x[i])
-    result.push(total);
-  }
-  return result;
-};
+// export const mean = (...x) => x.reduce((a, b) => a + b) / x.length;
+
+// export const variance = (...x) => {
+//   const n = x.length;
+//   if (n === 0) return NaN;
+//   const x_mean = mean(...x);
+//   return x.reduce((sum, xi) => sum + (xi - x_mean) ** 2, 0) / n;
+// };
+
+// export const std = (...x) => Math.sqrt(variance(...x));
+
+// export const accum_sum = (...x) => {
+//   let result = [];
+//   let total = 0, i, n = x.length;
+//   for(i = 0; i < n ; i++){
+//     total = add(total, x[i])
+//     result.push(total);
+//   }
+//   return result;
+// };
 
 export const accum_prod = (...x) => {
   let result = [];
@@ -46,16 +46,16 @@ export const accum_prod = (...x) => {
   return result;
 };
 
-export const percentile = (X, p) => {
-  if (X.length === 0) 
-    return NaN;
-  let a = [...X].sort((x, y) => x - y);
-  let index = (p / 100) * (a.length - 1);
-  let i = Math.floor(index);
-  let f = index - i;
-  if (i === a.length - 1) 
-    return a[i]; 
-  return a[i] * (1 - f) + a[i + 1] * f;
-}
-
-export const median = X => percentile(X, 50); 
+// export const percentile = (X, p) => {
+//   if (X.length === 0) 
+//     return NaN;
+//   let a = [...X].sort((x, y) => x - y);
+//   let index = (p / 100) * (a.length - 1);
+//   let i = Math.floor(index);
+//   let f = index - i;
+//   if (i === a.length - 1) 
+//     return a[i]; 
+//   return a[i] * (1 - f) + a[i + 1] * f;
+// }
+
+// export const median = X => percentile(X, 50); 

package/src/math/functions/ufunc/index.d.ts

@@ -0,0 +1,96 @@
+import { mapfun, MapFunResult } from '../mapfun/index.d.ts';
+import { complex } from '../../complex/index.d.ts';
+
+// --- Standard Unary / Multi-Argument Math Functions ---
+
+export function abs<T>(x: T): MapFunResult<T, any>;
+export function abs<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function sqrt<T>(x: T): MapFunResult<T, any>;
+export function sqrt<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function cbrt<T>(x: T): MapFunResult<T, any>;
+export function cbrt<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function exp<T>(x: T): MapFunResult<T, any>;
+export function exp<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function ln<T>(x: T): MapFunResult<T, any>;
+export function ln<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function sign<T>(x: T): MapFunResult<T, any>;
+export function sign<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function floor<T>(x: T): MapFunResult<T, any>;
+export function floor<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function ceil<T>(x: T): MapFunResult<T, any>;
+export function ceil<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function round<T>(x: T): MapFunResult<T, any>;
+export function round<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function trunc<T>(x: T): MapFunResult<T, any>;
+export function trunc<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function fract<T>(x: T): MapFunResult<T, any>;
+export function fract<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function cos<T>(x: T): MapFunResult<T, any>;
+export function cos<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function sin<T>(x: T): MapFunResult<T, any>;
+export function sin<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function tan<T>(x: T): MapFunResult<T, any>;
+export function tan<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function sec<T>(x: T): MapFunResult<T, any>;
+export function sec<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function acos<T>(x: T): MapFunResult<T, any>;
+export function acos<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function asin<T>(x: T): MapFunResult<T, any>;
+export function asin<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function atan<T>(x: T): MapFunResult<T, any>;
+export function atan<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function acot<T>(x: T): MapFunResult<T, any>;
+export function acot<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function cosh<T>(x: T): MapFunResult<T, any>;
+export function cosh<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function sinh<T>(x: T): MapFunResult<T, any>;
+export function sinh<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function tanh<T>(x: T): MapFunResult<T, any>;
+export function tanh<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function coth<T>(x: T): MapFunResult<T, any>;
+export function coth<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function acosh<T>(x: T): MapFunResult<T, any>;
+export function acosh<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function asinh<T>(x: T): MapFunResult<T, any>;
+export function asinh<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function atanh<T>(x: T): MapFunResult<T, any>;
+export function atanh<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function sig<T>(x: T): MapFunResult<T, any>;
+export function sig<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+// --- Functions that pop parameters from the end (pow, nthr, croot) ---
+
+export function pow<T, N>(base: T, n: N): MapFunResult<T, any>;
+export function pow<T extends any[], N>(...args: [...T, N]): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function nthr<T, N extends number>(base: T, n: N): MapFunResult<T, any>;
+export function nthr<T extends any[], N extends number>(...args: [...T, N]): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function croot<T, C>(base: T, root: C): MapFunResult<T, any>;
+export function croot<T extends any[], C>(...args: [...T, C]): { [K in keyof T]: MapFunResult<T[K], any> };

package/src/math/functions/utils/index.d.ts

@@ -1 +1,118 @@
-export type * from './mapfun'
+import { Mappable } from "../mapfun/index.d.ts";
+/**
+ * Converts degrees to radians.
+ *
+ * Accepts multiple values and recursively maps through
+ * supported structures.
+ *
+ * @example
+ * deg2rad(180) // 3.14159...
+ */
+export declare function deg2rad(
+    ...deg: Mappable<number>[]
+): Mappable<number>;
+
+/**
+ * Converts radians to degrees.
+ *
+ * Accepts multiple values and recursively maps through
+ * supported structures.
+ *
+ * @example
+ * rad2deg(Math.PI) // 180
+ */
+export declare function rad2deg(
+    ...rad: Mappable<number>[]
+): Mappable<number>;
+
+/**
+ * Normalizes a value from a range to the interval [0, 1].
+ *
+ * Supports numbers, arrays, typed arrays, objects,
+ * complex values and matrices.
+ *
+ * @param x Input value.
+ * @param min Minimum range value.
+ * @param max Maximum range value.
+ */
+export declare function norm(
+    x: Mappable<number>,
+    min: number,
+    max: number
+): Mappable<number>;
+
+/**
+ * Performs linear interpolation.
+ *
+ * Maps a normalized value to a given range.
+ *
+ * @param x Input normalized value.
+ * @param min Start value.
+ * @param max End value.
+ */
+export declare function lerp(
+    x: Mappable<number>,
+    min: number,
+    max: number
+): Mappable<number>;
+
+/**
+ * Restricts values to a given interval.
+ *
+ * @param x Input value.
+ * @param min Lower bound.
+ * @param max Upper bound.
+ */
+export declare function clamp(
+    x: Mappable<number>,
+    min: number,
+    max: number
+): Mappable<number>;
+
+/**
+ * Maps a value from one range to another.
+ *
+ * @param x Input value.
+ * @param a Source minimum.
+ * @param b Source maximum.
+ * @param c Target minimum.
+ * @param d Target maximum.
+ */
+export declare function map(
+    x: Mappable<number>,
+    a: number,
+    b: number,
+    c: number,
+    d: number
+): Mappable<number>;
+
+/**
+ * Calculates the Euclidean norm (hypotenuse).
+ *
+ * Supports numbers and complex-like values.
+ *
+ * @example
+ * hypot(3, 4) // 5
+ */
+export declare function hypot(
+    ...x: (number | ComplexLike)[]
+): number;
+
+/**
+ * Calculates the angle between the positive x-axis and a point.
+ *
+ * Supports scalar values and array inputs.
+ *
+ * @param y Y coordinate(s).
+ * @param x X coordinate(s).
+ * @param rad Return radians when true, degrees otherwise.
+ *
+ * @example
+ * atan2(1, 1) // 0.785...
+ * atan2(1, 1, false) // 45
+ */
+export declare function atan2(
+    y: Mappable<number>,
+    x: Mappable<number>,
+    rad?: boolean
+): Mappable<number>;

package/src/math/index.d.ts

@@ -0,0 +1,4 @@
+export type * from './random/index.d.ts';
+export type * from './complex/index.d.ts';
+export type * from './stats/index.d.ts'
+export type * from './functions/index.d.ts'

package/src/math/index.js

@@ -1,23 +1,8 @@
-// import * as __Const__ from "./const.js"
-// import * as __Functions__ from "./functions/index.js"
-// import * as __Random__ from "./random"
-// import * as __Complex__ from "./complex"
-// import * as __Matrix__ from "./matrix"
-// import * as __Discrect__ from "./discret"
-// import * as __Utils__ from "./utils"
-// const Math = {
-//     ...__Const__,
-//     ...__Functions__,
-//     ...__Complex__,
-//     ...__Matrix__,
-//     ...__Random__,
-//     ...__Utils__,
-//     ...__Discrect__,
-// }
 export * from "./const.js"
 export * from "./functions/index.js"
 export * from "./complex/index.js"
 export * from "./matrix/index.js"
+export * from './stats/index.js'
 // export * from "./discret"
 export * from "./random/index.js"
 // export * from "./utils/index.js"  // To Check

package/src/math/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/math/random/index.js

@@ -1,5 +1,5 @@
 import { base2base } from "../functions/conversions/index.js";
-import { accum_sum } from "../functions/stats/index.js";
+import { accum_sum } from "../stats/index.js";
 
 export class Random {
     static int(a, b){
@@ -74,9 +74,9 @@ export class Random {
     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)),
+            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()),

package/src/math/stats/accum/index.d.ts

@@ -0,0 +1,43 @@
+ /**
+  * Calculates the cumulative sum of an array.
+  *
+  * Each element in the returned array represents the sum of all
+  * previous elements up to the current index.
+  *
+  * @example
+  * accum_sum([1, 2, 3]) // [1, 3, 6]
+  */
+export declare function accum_sum(arr: number[]): number[];
+
+/**
+ * Calculates the cumulative product of an array.
+ *
+ * Each element in the returned array represents the product of all
+ * previous elements up to the current index.
+ *
+ * @example
+ * accum_product([2, 3, 4]) // [2, 6, 24]
+ */
+export declare function accum_product(arr: number[]): number[];
+
+/**
+ * Calculates the cumulative maximum values of an array.
+ *
+ * Each element in the returned array represents the maximum value
+ * encountered from the beginning of the array.
+ *
+ * @example
+ * accum_max([3, 1, 5, 2]) // [3, 3, 5, 5]
+ */
+export declare function accum_max(arr: number[]): number[];
+
+/**
+ * Calculates the cumulative minimum values of an array.
+ *
+ * Each element in the returned array represents the minimum value
+ * encountered from the beginning of the array.
+ *
+ * @example
+ * accum_min([3, 1, 5, 2]) // [3, 1, 1, 1]
+ */
+export declare function accum_min(arr: number[]): number[];