@danielsimonjr/mathts-functions 0.2.3 → 0.2.5

package/dist/typed/special.d.ts

@@ -0,0 +1,469 @@
+/**
+ * Typed Special Functions
+ *
+ * Special mathematical functions using typed-function for runtime dispatch.
+ * Includes the error functions, beta/gamma functions, Bessel functions,
+ * elliptic integrals, orthogonal polynomials and integral functions.
+ *
+ * Each single-argument function has a `Float64Array` overload that evaluates
+ * the function across a whole array, parallelizing large inputs via the
+ * worker pool. Multi-argument functions take a `Float64Array` for their
+ * varying argument with the remaining parameters fixed.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Complementary error function: erfc(x) = 1 - erf(x).
+ *
+ * @param x - Input value, or Float64Array of values
+ * @returns 1 - erf(x)
+ *
+ * @example
+ * erfc(0) // 1
+ * erfc(1) // ~0.1573
+ */
+export declare const erfc: import("typed-function").TypedFunction;
+/**
+ * Imaginary error function: erfi(x) = -i * erf(ix).
+ *
+ * @param x - Input value, or Float64Array of values
+ * @returns erfi(x)
+ */
+export declare const erfi: import("typed-function").TypedFunction;
+/**
+ * Log-gamma function: lgamma(x) = log(|Γ(x)|).
+ *
+ * Poles at non-positive integers return +Infinity.
+ * Negative non-integer inputs use the reflection formula.
+ *
+ * Arrays of length ≥ WASM_SPECIAL_THRESHOLD (1024) are dispatched to the
+ * WASM kernel (Rust via lgamma_f64, Slice 5.8; or AS via lgamma_f64_as).
+ *
+ * Reference values:
+ *   lgamma(1)   = 0
+ *   lgamma(2)   = 0
+ *   lgamma(0.5) ≈ 0.5723649429247001 (ln(√π))
+ *   lgamma(10)  ≈ 12.801827480081469
+ *   lgamma(100) ≈ 359.13420536957544
+ *
+ * @param x - Input value, or Float64Array of values
+ * @returns log(|Γ(x)|)
+ */
+export declare const lgamma: import("typed-function").TypedFunction;
+/**
+ * Beta function: B(a, b) = Gamma(a) * Gamma(b) / Gamma(a + b).
+ *
+ * @param a - First parameter (positive), or Float64Array of values
+ * @param b - Second parameter (positive)
+ * @returns B(a, b)
+ *
+ * @example
+ * beta(2, 3) // 1/12 ~ 0.08333
+ */
+export declare const beta: import("typed-function").TypedFunction;
+/**
+ * Regularized lower incomplete gamma function P(a, x) = gamma(a, x) / Gamma(a).
+ *
+ * @param a - Shape parameter (positive)
+ * @param x - Integration upper limit, or Float64Array of limits
+ * @returns P(a, x)
+ *
+ * @example
+ * gammainc(1, 1) // 1 - 1/e ~ 0.6321
+ */
+export declare const gammainc: import("typed-function").TypedFunction;
+/**
+ * Upper (complementary) regularized incomplete gamma: Q(a, x) = 1 - P(a, x).
+ *
+ * @param a - Shape parameter (positive)
+ * @param x - Lower limit, or Float64Array of limits
+ * @returns Q(a, x)
+ */
+export declare const gammaincp: import("typed-function").TypedFunction;
+/**
+ * Regularized incomplete beta function I_x(a, b).
+ *
+ * @param a - First parameter (positive)
+ * @param b - Second parameter (positive)
+ * @param x - Upper limit in [0, 1], or Float64Array of limits
+ * @returns I_x(a, b)
+ */
+export declare const betainc: import("typed-function").TypedFunction;
+/**
+ * Digamma function: psi(x) = d/dx ln(Gamma(x)).
+ *
+ * @param x - Input value, or Float64Array of values
+ * @returns psi(x)
+ *
+ * @example
+ * digamma(1) // -gamma ~ -0.5772
+ */
+export declare const digamma: import("typed-function").TypedFunction;
+/**
+ * Bessel function of the first kind, order 0: J0(x).
+ *
+ * Arrays of length ≥ WASM_SPECIAL_THRESHOLD (1024) are dispatched to the
+ * WASM kernel (Rust via bessel_j0_f64, Slice 3.10c-1); smaller inputs and
+ * scalars use the inline JS approximation.
+ *
+ * @param x - Input value, or Float64Array of values
+ * @returns J0(x)
+ */
+export declare const besselJ0: import("typed-function").TypedFunction;
+/**
+ * Bessel function of the first kind, order 1: J1(x).
+ *
+ * Arrays of length ≥ WASM_SPECIAL_THRESHOLD (1024) are dispatched to the
+ * WASM kernel (Rust via bessel_j1_f64, Slice 3.10c-1).
+ *
+ * @param x - Input value, or Float64Array of values
+ * @returns J1(x)
+ */
+export declare const besselJ1: import("typed-function").TypedFunction;
+/**
+ * Bessel function of the second kind, order 0: Y0(x).
+ *
+ * Arrays of length ≥ WASM_SPECIAL_THRESHOLD (1024) are dispatched to the
+ * WASM kernel (Rust via bessel_y0_f64, Slice 3.10c-1).
+ *
+ * @param x - Input value (must be positive), or Float64Array of values
+ * @returns Y0(x)
+ */
+export declare const besselY0: import("typed-function").TypedFunction;
+/**
+ * Bessel function of the second kind, order 1: Y1(x).
+ *
+ * Arrays of length ≥ WASM_SPECIAL_THRESHOLD (1024) are dispatched to the
+ * WASM kernel (Rust via bessel_y1_f64, Slice 3.10c-1).
+ *
+ * @param x - Input value (must be positive), or Float64Array of values
+ * @returns Y1(x)
+ */
+export declare const besselY1: import("typed-function").TypedFunction;
+/**
+ * Bessel function of the first kind, general integer order n: J_n(x).
+ *
+ * Arrays of length ≥ WASM_SPECIAL_THRESHOLD (1024) are dispatched to the
+ * WASM kernel (Rust via bessel_j_f64, Slice 3.10c-1).
+ *
+ * @param n - Order (integer)
+ * @param x - Input value, or Float64Array of values
+ * @returns J_n(x)
+ */
+export declare const besselJ: import("typed-function").TypedFunction;
+/**
+ * Bessel function of the second kind, general integer order n: Y_n(x).
+ *
+ * Arrays of length ≥ WASM_SPECIAL_THRESHOLD (1024) are dispatched to the
+ * WASM kernel (Rust via bessel_y_f64, Slice 3.10c-1).
+ *
+ * @param n - Order (integer)
+ * @param x - Input value (must be positive), or Float64Array of values
+ * @returns Y_n(x)
+ */
+export declare const besselY: import("typed-function").TypedFunction;
+/**
+ * Modified Bessel function of the first kind, I_n(x).
+ *
+ * @param n - Order (integer)
+ * @param x - Input value, or Float64Array of values
+ * @returns I_n(x)
+ */
+export declare const besselI: import("typed-function").TypedFunction;
+/**
+ * Modified Bessel function of the second kind, K_n(x).
+ *
+ * @param n - Order (integer)
+ * @param x - Input value (must be positive), or Float64Array of values
+ * @returns K_n(x)
+ */
+export declare const besselK: import("typed-function").TypedFunction;
+/**
+ * Complete elliptic integral of the first kind K(m).
+ *
+ * Arrays of length ≥ WASM_SPECIAL_THRESHOLD (1024) are dispatched to the
+ * WASM kernel (Rust via elliptic_k_f64, Slice 5.3; or AS via elliptic_k_f64_as).
+ *
+ * Algorithm: AGM (arithmetic-geometric mean) — K = π / (2·agm(1, √(1−m))).
+ * Converges quadratically; ~10 iterations for full f64 precision.
+ *
+ * Domain: m ∈ [0, 1).  K(1) = +∞.  m < 0 or m > 1 → NaN.
+ *
+ * Reference values (DLMF §19.6):
+ *   K(0) = π/2 ≈ 1.5707963267948966
+ *   K(0.5) ≈ 1.8540746773013719
+ *   K(0.99) ≈ 3.6956373629898747
+ *
+ * @param m - Parameter (0 <= m < 1), or Float64Array of parameters
+ * @returns K(m)
+ */
+export declare const ellipticK: import("typed-function").TypedFunction;
+/**
+ * Elliptic integral of the second kind E(phi, m) or complete form E(m).
+ *
+ * With one number argument, returns the complete integral E(m).
+ * With a Float64Array, dispatches the complete integral E(m) across the array.
+ * Arrays of length ≥ WASM_SPECIAL_THRESHOLD (1024) use the WASM kernel
+ * (Rust via elliptic_e_f64, Slice 5.3; or AS via elliptic_e_f64_as).
+ *
+ * Algorithm: Carlson-Bulirsch AGM variant (complete form).
+ * Domain: m ∈ [0, 1].  E(0) = π/2, E(1) = 1.  m < 0 or m > 1 → NaN.
+ *
+ * Reference values (DLMF §19.6):
+ *   E(0) = π/2 ≈ 1.5707963267948966
+ *   E(0.5) ≈ 1.3506438810476755
+ *   E(1) = 1.0
+ *
+ * @param phi - Amplitude (radians), or Float64Array of m-values for complete form
+ * @param m - Parameter (0 <= m <= 1)
+ * @returns E(phi, m), or E(m) for the single-argument / array form
+ */
+export declare const ellipticE: import("typed-function").TypedFunction;
+/**
+ * Chebyshev polynomial of the first kind T_n(x).
+ *
+ * @param n - Degree
+ * @param x - Input value, or Float64Array of values
+ * @returns T_n(x)
+ */
+export declare const chebyshevT: import("typed-function").TypedFunction;
+/**
+ * Hermite polynomial H_n(x) (physicist's convention).
+ *
+ * @param n - Degree
+ * @param x - Input value, or Float64Array of values
+ * @returns H_n(x)
+ */
+export declare const hermiteH: import("typed-function").TypedFunction;
+/**
+ * Laguerre polynomial L_n(x).
+ *
+ * @param n - Degree
+ * @param x - Input value, or Float64Array of values
+ * @returns L_n(x)
+ */
+export declare const laguerreL: import("typed-function").TypedFunction;
+/**
+ * Legendre polynomial P_n(x).
+ *
+ * @param n - Degree
+ * @param x - Input value in [-1, 1], or Float64Array of values
+ * @returns P_n(x)
+ */
+export declare const legendreP: import("typed-function").TypedFunction;
+/**
+ * Lambert W function (principal branch W_0).
+ *
+ * @param x - Input value (>= -1/e), or Float64Array of values
+ * @returns W_0(x)
+ *
+ * @example
+ * lambertW(1) // ~0.5671 (omega constant)
+ */
+export declare const lambertW: import("typed-function").TypedFunction;
+/**
+ * Cosine integral Ci(x).
+ *
+ * @param x - Input value (positive), or Float64Array of values
+ * @returns Ci(x)
+ */
+export declare const cosIntegral: import("typed-function").TypedFunction;
+/**
+ * Sine integral Si(x).
+ *
+ * @param x - Input value, or Float64Array of values
+ * @returns Si(x)
+ */
+export declare const sinIntegral: import("typed-function").TypedFunction;
+/**
+ * Logarithmic integral li(x) = Ei(ln(x)).
+ *
+ * @param x - Input value (> 0, != 1), or Float64Array of values
+ * @returns li(x)
+ */
+export declare const logIntegral: import("typed-function").TypedFunction;
+/**
+ * Exponential integral Ei(x).
+ *
+ * @param x - Input value (x != 0), or Float64Array of values
+ * @returns Ei(x)
+ */
+export declare const expIntegralEi: import("typed-function").TypedFunction;
+/**
+ * Fresnel cosine integral C(x) = integral_0^x cos(pi*t^2/2) dt.
+ *
+ * @param x - Input value, or Float64Array of values
+ * @returns C(x)
+ */
+export declare const fresnelC: import("typed-function").TypedFunction;
+/**
+ * Fresnel sine integral S(x) = integral_0^x sin(pi*t^2/2) dt.
+ *
+ * @param x - Input value, or Float64Array of values
+ * @returns S(x)
+ */
+export declare const fresnelS: import("typed-function").TypedFunction;
+/**
+ * Airy function of the first kind Ai(x).
+ *
+ * Arrays of length ≥ WASM_SPECIAL_THRESHOLD (1024) are dispatched to the
+ * WASM kernel (Rust via airy_ai_f64, Slice 4.9; or AS via airy_ai_f64_as).
+ *
+ * Algorithm:
+ *   - |x| ≤ 4.5: power series (DLMF §9.2.2) — ~1e-10 relative error
+ *   - x > 4.5:   decaying asymptotic exp(−ζ)/... (DLMF §9.7.3) — ~1e-7
+ *   - x < −4.5:  oscillatory asymptotic sin/cos (DLMF §9.7.5) — ~1e-7
+ *
+ * Reference values (DLMF §9.2):
+ *   Ai(0) ≈ 0.355028053887817
+ *   Ai(1) ≈ 0.135292416312881
+ *   Ai(−1) ≈ 0.535560883292352
+ *
+ * @param x - Input value, or Float64Array of values
+ * @returns Ai(x)
+ */
+export declare const airyAi: import("typed-function").TypedFunction;
+/**
+ * Airy function of the second kind Bi(x).
+ *
+ * Arrays of length ≥ WASM_SPECIAL_THRESHOLD (1024) are dispatched to the
+ * WASM kernel (Rust via airy_bi_f64, Slice 4.9; or AS via airy_bi_f64_as).
+ *
+ * Reference values (DLMF §9.2):
+ *   Bi(0) ≈ 0.614926627446001
+ *   Bi(1) ≈ 1.207423594952871
+ *   Bi(−1) ≈ 0.103997389496945
+ *
+ * @param x - Input value, or Float64Array of values
+ * @returns Bi(x)
+ */
+export declare const airyBi: import("typed-function").TypedFunction;
+/**
+ * Carlson degenerate symmetric integral RC(x, y).
+ *
+ * RC(x, y) = ∫_0^∞ dt / ((t+x)^{1/2} (t+y))
+ *
+ * Identities: RC(0, 1) = π/2; RC(1, 1) = 1.
+ *
+ * Reference: DLMF §19.16.6; Numerical Recipes §6.11.
+ *
+ * @param x - First argument (≥ 0), or Float64Array of values
+ * @param y - Second argument (≠ 0), or Float64Array of values
+ */
+export declare const carlsonRC: import("typed-function").TypedFunction;
+/**
+ * Carlson symmetric integral RF(x, y, z).
+ *
+ * RF(x, y, z) = (1/2) ∫_0^∞ dt / (√(t+x)·√(t+y)·√(t+z))
+ *
+ * Symmetry: RF is symmetric in all three arguments.
+ * Identity: RF(0, 1, 2) ≈ 1.3110287771461...
+ *
+ * Reference: DLMF §19.16.1; Numerical Recipes §6.11.
+ */
+export declare const carlsonRF: import("typed-function").TypedFunction;
+/**
+ * Carlson symmetric integral RD(x, y, z).
+ *
+ * RD(x, y, z) = (3/2) ∫_0^∞ dt / (√(t+x)·√(t+y)·(t+z)^{3/2})
+ *
+ * Identity: RD(0, 2, 1) ≈ 1.7972103521033...
+ *
+ * Reference: DLMF §19.16.5; Numerical Recipes §6.11.
+ */
+export declare const carlsonRD: import("typed-function").TypedFunction;
+/**
+ * Carlson symmetric integral RJ(x, y, z, p).
+ *
+ * RJ(x, y, z, p) = (3/2) ∫_0^∞ dt / ((t+p)·√(t+x)·√(t+y)·√(t+z))
+ *
+ * Reference: DLMF §19.16.2; Numerical Recipes §6.11.
+ */
+export declare const carlsonRJ: import("typed-function").TypedFunction;
+/**
+ * Incomplete elliptic integral of the first kind F(φ, m).
+ *
+ * F(φ, m) = ∫_0^φ dθ / √(1 − m·sin²θ)
+ *
+ * Implemented via F(φ, m) = sin(φ)·RF(cos²φ, 1−m·sin²φ, 1) (DLMF §19.25.5).
+ *
+ * Special cases: F(0, m) = 0; F(π/2, m) = K(m).
+ *
+ * Reference values (DLMF §19.6): F(π/2, 0.5) = K(0.5) ≈ 1.8540746773013719.
+ *
+ * @param phi - Amplitude in [0, π/2]
+ * @param m - Parameter in [0, 1)
+ */
+export declare const ellipticF: import("typed-function").TypedFunction;
+/**
+ * Incomplete elliptic integral of the second kind E(φ, m) — Carlson form.
+ *
+ * E(φ, m) = ∫_0^φ √(1 − m·sin²θ) dθ
+ *
+ * Implemented via Carlson forms (DLMF §19.25.7):
+ *   E(φ, m) = sin(φ)·RF(c², 1−m·s², 1) − (m/3)·s³·RD(c², 1−m·s², 1)
+ *
+ * Special cases: E(0, m) = 0; E(π/2, m) = E(m) (complete second kind).
+ *
+ * Named `ellipticEIncomplete` to distinguish from the existing `ellipticE`
+ * export which handles both the complete form (1-arg) and the Simpson
+ * 2-arg form.
+ */
+export declare const ellipticEIncomplete: import("typed-function").TypedFunction;
+/**
+ * Incomplete elliptic integral of the third kind Π(n, φ, m).
+ *
+ * Π(n, φ, m) = ∫_0^φ dθ / ((1 − n·sin²θ)·√(1 − m·sin²θ))
+ *
+ * Implemented via Carlson forms (DLMF §19.25.9):
+ *   Π(n, φ, m) = sin(φ)·RF(c², 1−m·s², 1) + (n/3)·s³·RJ(c², 1−m·s², 1, 1−n·s²)
+ *
+ * Special cases: Π(n, 0, m) = 0; Π(n, π/2, m) = Π(n, m) (complete third kind).
+ *
+ * Reference: DLMF §19.6, Abramowitz & Stegun §17.7.
+ */
+export declare const ellipticPi: import("typed-function").TypedFunction;
+/**
+ * All typed special functions.
+ */
+export declare const typedSpecial: {
+    erfc: import("typed-function").TypedFunction;
+    lgamma: import("typed-function").TypedFunction;
+    beta: import("typed-function").TypedFunction;
+    gammainc: import("typed-function").TypedFunction;
+    digamma: import("typed-function").TypedFunction;
+    besselJ0: import("typed-function").TypedFunction;
+    besselJ1: import("typed-function").TypedFunction;
+    besselY0: import("typed-function").TypedFunction;
+    besselY1: import("typed-function").TypedFunction;
+    besselJ: import("typed-function").TypedFunction;
+    besselY: import("typed-function").TypedFunction;
+    besselI: import("typed-function").TypedFunction;
+    besselK: import("typed-function").TypedFunction;
+    betainc: import("typed-function").TypedFunction;
+    gammaincp: import("typed-function").TypedFunction;
+    ellipticK: import("typed-function").TypedFunction;
+    ellipticE: import("typed-function").TypedFunction;
+    chebyshevT: import("typed-function").TypedFunction;
+    hermiteH: import("typed-function").TypedFunction;
+    laguerreL: import("typed-function").TypedFunction;
+    legendreP: import("typed-function").TypedFunction;
+    lambertW: import("typed-function").TypedFunction;
+    erfi: import("typed-function").TypedFunction;
+    cosIntegral: import("typed-function").TypedFunction;
+    sinIntegral: import("typed-function").TypedFunction;
+    logIntegral: import("typed-function").TypedFunction;
+    expIntegralEi: import("typed-function").TypedFunction;
+    fresnelC: import("typed-function").TypedFunction;
+    fresnelS: import("typed-function").TypedFunction;
+    airyAi: import("typed-function").TypedFunction;
+    airyBi: import("typed-function").TypedFunction;
+    carlsonRC: import("typed-function").TypedFunction;
+    carlsonRF: import("typed-function").TypedFunction;
+    carlsonRD: import("typed-function").TypedFunction;
+    carlsonRJ: import("typed-function").TypedFunction;
+    ellipticF: import("typed-function").TypedFunction;
+    ellipticEIncomplete: import("typed-function").TypedFunction;
+    ellipticPi: import("typed-function").TypedFunction;
+};
+//# sourceMappingURL=special.d.ts.map

package/dist/typed/special.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"special.d.ts","sourceRoot":"","sources":["../../src/typed/special.ts"],"names":[],"mappings":"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"}

package/dist/typed/statistics.d.ts

@@ -0,0 +1,174 @@
+/**
+ * Typed Statistics Functions (Parallel-First)
+ *
+ * AssemblyScript-friendly TypeScript implementations with typed-function
+ * integration and workerpool parallel execution.
+ *
+ * Following the parallel-first philosophy per CLAUDE.md:
+ * - Use workers for ALL array transformations (Float64Array)
+ * - Use workers for ALL numerical computations that can be batched
+ * - Only fall back to sequential for trivial scalar operations
+ *
+ * @packageDocumentation
+ */
+/** 64-bit float (default for decimals) */
+type f64 = number;
+/** 32-bit signed integer */
+type i32 = number;
+/**
+ * Normalization type for variance computation
+ */
+export type NormalizationType = 'unbiased' | 'uncorrected' | 'biased';
+/**
+ * Parallel sum with typed-function dispatch
+ */
+export declare const parallelStatSum: import("typed-function").TypedFunction;
+/**
+ * Parallel mean with typed-function dispatch
+ */
+export declare const parallelStatMean: import("typed-function").TypedFunction;
+/**
+ * Parallel variance with typed-function dispatch
+ *
+ * Uses Welford's algorithm for numerical stability
+ */
+export declare const parallelStatVariance: import("typed-function").TypedFunction;
+/**
+ * Parallel standard deviation with typed-function dispatch
+ */
+export declare const parallelStatStd: import("typed-function").TypedFunction;
+/**
+ * Parallel minimum with typed-function dispatch
+ */
+export declare const parallelStatMin: import("typed-function").TypedFunction;
+/**
+ * Parallel maximum with typed-function dispatch
+ */
+export declare const parallelStatMax: import("typed-function").TypedFunction;
+/**
+ * Parallel minmax with typed-function dispatch
+ * Returns both min and max in a single pass
+ */
+export declare const parallelStatMinMax: import("typed-function").TypedFunction;
+/**
+ * Parallel median with typed-function dispatch
+ *
+ * Note: Median requires sorting which is O(n log n)
+ */
+export declare const parallelStatMedian: import("typed-function").TypedFunction;
+/**
+ * Parallel mode with typed-function dispatch
+ * Returns the most frequently occurring value(s)
+ */
+export declare const parallelStatMode: import("typed-function").TypedFunction;
+/**
+ * Parallel product with typed-function dispatch
+ */
+export declare const parallelStatProd: import("typed-function").TypedFunction;
+/**
+ * Parallel Euclidean norm (L2 norm) with typed-function dispatch
+ */
+export declare const parallelStatNorm: import("typed-function").TypedFunction;
+/**
+ * Parallel Euclidean distance with typed-function dispatch
+ */
+export declare const parallelStatDistance: import("typed-function").TypedFunction;
+/**
+ * Parallel Pearson correlation coefficient
+ */
+export declare const parallelStatCorr: import("typed-function").TypedFunction;
+/**
+ * Parallel Mean Absolute Deviation
+ */
+export declare const parallelStatMAD: import("typed-function").TypedFunction;
+/**
+ * Parallel cumulative sum
+ */
+export declare const parallelStatCumsum: import("typed-function").TypedFunction;
+/**
+ * Parallel quantile computation
+ */
+export declare const parallelStatQuantile: import("typed-function").TypedFunction;
+/**
+ * Compute the p-th percentile of a Float64Array.
+ *
+ * Identical to `parallelStatQuantile(data, p / 100)`.
+ * Uses WASM sort acceleration above WASM_SORT_THRESHOLD elements.
+ *
+ * @param data - Input data array.
+ * @param p    - Percentile in [0, 100].
+ */
+export declare function parallelStatPercentile(data: Float64Array, p: f64): f64;
+/**
+ * Parallel histogram computation
+ */
+export declare const parallelStatHistogram: import("typed-function").TypedFunction;
+/**
+ * Select the k-th smallest element from an array using Hoare's quickselect algorithm.
+ * Average O(n) time complexity.
+ *
+ * @param arr - Input array (not modified)
+ * @param k - Zero-based index of the desired order statistic
+ * @returns The k-th smallest element
+ */
+export declare function quickSelect(arr: number[], k: i32): f64;
+/**
+ * Find the median of an array in O(n) average time using quickselect.
+ *
+ * @param arr - Input array (not modified)
+ * @returns The median value
+ */
+export declare function medianSelect(arr: number[]): f64;
+/**
+ * Find the k smallest elements from an array.
+ *
+ * @param arr - Input array (not modified)
+ * @param k - Number of smallest elements to return
+ * @returns Array of k smallest elements, sorted ascending
+ */
+export declare function minSelect(arr: number[], k: i32): number[];
+/**
+ * Find the k largest elements from an array.
+ *
+ * @param arr - Input array (not modified)
+ * @param k - Number of largest elements to return
+ * @returns Array of k largest elements, sorted descending
+ */
+export declare function maxSelect(arr: number[], k: i32): number[];
+/**
+ * Primary export: typed statistics functions
+ */
+export declare const typedStatistics: {
+    sum: import("typed-function").TypedFunction;
+    mean: import("typed-function").TypedFunction;
+    variance: import("typed-function").TypedFunction;
+    std: import("typed-function").TypedFunction;
+    min: import("typed-function").TypedFunction;
+    max: import("typed-function").TypedFunction;
+    minMax: import("typed-function").TypedFunction;
+    median: import("typed-function").TypedFunction;
+    mode: import("typed-function").TypedFunction;
+    prod: import("typed-function").TypedFunction;
+    norm: import("typed-function").TypedFunction;
+    distance: import("typed-function").TypedFunction;
+    corr: import("typed-function").TypedFunction;
+    mad: import("typed-function").TypedFunction;
+    cumsum: import("typed-function").TypedFunction;
+    quantile: import("typed-function").TypedFunction;
+    percentile: typeof parallelStatPercentile;
+    histogram: import("typed-function").TypedFunction;
+    quickSelect: typeof quickSelect;
+    medianSelect: typeof medianSelect;
+    minSelect: typeof minSelect;
+    maxSelect: typeof maxSelect;
+};
+/**
+ * Initialize statistics processing pool
+ */
+export declare function initializeStatistics(): Promise<void>;
+/**
+ * Terminate statistics processing pool
+ */
+export declare function terminateStatistics(): Promise<void>;
+export {};
+//# sourceMappingURL=statistics.d.ts.map

package/dist/typed/statistics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statistics.d.ts","sourceRoot":"","sources":["../../src/typed/statistics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAUH,0CAA0C;AAC1C,KAAK,GAAG,GAAG,MAAM,CAAC;AAElB,4BAA4B;AAC5B,KAAK,GAAG,GAAG,MAAM,CAAC;AAMlB;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,aAAa,GAAG,QAAQ,CAAC;AA0CtE;;GAEG;AACH,eAAO,MAAM,eAAe,wCAoB1B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,gBAAgB,wCAqB3B,CAAC;AAMH;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,wCA2D/B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,eAAe,wCAgC1B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,eAAe,wCAuB1B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,eAAe,wCAuB1B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB,wCAe7B,CAAC;AAMH;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,wCAgC7B,CAAC;AAMH;;;GAGG;AACH,eAAO,MAAM,gBAAgB,wCA2B3B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,gBAAgB,wCA8B3B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,gBAAgB,wCA4D3B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,oBAAoB,wCAiB/B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,gBAAgB,wCAgC3B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,eAAe,wCAsB1B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,kBAAkB,wCAsB7B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,oBAAoB,wCAgC/B,CAAC;AAMH;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,YAAY,EAAE,CAAC,EAAE,GAAG,GAAG,GAAG,CAGtE;AAMD;;GAEG;AACH,eAAO,MAAM,qBAAqB,wCAsBhC,CAAC;AAMH;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,GAAG,GAAG,GAAG,CAMtD;AA8CD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,GAAG,CAc/C;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,CAWzD;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,CAWzD;AAMD;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;CAuB3B,CAAC;AAEF;;GAEG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,IAAI,CAAC,CAE1D;AAED;;GAEG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CAEzD"}