@danielsimonjr/mathts-functions 0.64.2 → 0.65.0

package/dist/typed/special.d.ts

@@ -26,15 +26,15 @@ export declare function erfcScalar(x: f64): f64;
  * erfc(0) // 1
  * erfc(1) // ~0.1573
  */
-export declare const erfc: import("typed-function").TypedFunction;
+export declare const erfc: import("@danielsimonjr/mathts-core").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;
-export declare const lgamma: import("typed-function").TypedFunction;
+export declare const erfi: import("@danielsimonjr/mathts-core").TypedFunction;
+export declare const lgamma: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Beta function: B(a, b) = Gamma(a) * Gamma(b) / Gamma(a + b).
  *
@@ -45,7 +45,7 @@ export declare const lgamma: import("typed-function").TypedFunction;
  * @example
  * beta(2, 3) // 1/12 ~ 0.08333
  */
-export declare const beta: import("typed-function").TypedFunction;
+export declare const beta: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Regularized lower incomplete gamma function P(a, x) = gamma(a, x) / Gamma(a).
  *
@@ -56,7 +56,7 @@ export declare const beta: import("typed-function").TypedFunction;
  * @example
  * gammainc(1, 1) // 1 - 1/e ~ 0.6321
  */
-export declare const gammainc: import("typed-function").TypedFunction;
+export declare const gammainc: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Upper (complementary) regularized incomplete gamma: Q(a, x) = 1 - P(a, x).
  *
@@ -64,7 +64,7 @@ export declare const gammainc: import("typed-function").TypedFunction;
  * @param x - Lower limit, or Float64Array of limits
  * @returns Q(a, x)
  */
-export declare const gammaincp: import("typed-function").TypedFunction;
+export declare const gammaincp: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Regularized incomplete beta function I_x(a, b).
  *
@@ -73,7 +73,7 @@ export declare const gammaincp: import("typed-function").TypedFunction;
  * @param x - Upper limit in [0, 1], or Float64Array of limits
  * @returns I_x(a, b)
  */
-export declare const betainc: import("typed-function").TypedFunction;
+export declare const betainc: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Digamma function: psi(x) = d/dx ln(Gamma(x)).
  *
@@ -83,7 +83,7 @@ export declare const betainc: import("typed-function").TypedFunction;
  * @example
  * digamma(1) // -gamma ~ -0.5772
  */
-export declare const digamma: import("typed-function").TypedFunction;
+export declare const digamma: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Bessel function of the first kind, order 0: J0(x).
  *
@@ -94,7 +94,7 @@ export declare const digamma: import("typed-function").TypedFunction;
  * @param x - Input value, or Float64Array of values
  * @returns J0(x)
  */
-export declare const besselJ0: import("typed-function").TypedFunction;
+export declare const besselJ0: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Bessel function of the first kind, order 1: J1(x).
  *
@@ -104,7 +104,7 @@ export declare const besselJ0: import("typed-function").TypedFunction;
  * @param x - Input value, or Float64Array of values
  * @returns J1(x)
  */
-export declare const besselJ1: import("typed-function").TypedFunction;
+export declare const besselJ1: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Bessel function of the second kind, order 0: Y0(x).
  *
@@ -114,7 +114,7 @@ export declare const besselJ1: import("typed-function").TypedFunction;
  * @param x - Input value (must be positive), or Float64Array of values
  * @returns Y0(x)
  */
-export declare const besselY0: import("typed-function").TypedFunction;
+export declare const besselY0: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Bessel function of the second kind, order 1: Y1(x).
  *
@@ -124,7 +124,7 @@ export declare const besselY0: import("typed-function").TypedFunction;
  * @param x - Input value (must be positive), or Float64Array of values
  * @returns Y1(x)
  */
-export declare const besselY1: import("typed-function").TypedFunction;
+export declare const besselY1: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Bessel function of the first kind, general integer order n: J_n(x).
  *
@@ -135,7 +135,7 @@ export declare const besselY1: import("typed-function").TypedFunction;
  * @param x - Input value, or Float64Array of values
  * @returns J_n(x)
  */
-export declare const besselJ: import("typed-function").TypedFunction;
+export declare const besselJ: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Bessel function of the second kind, general integer order n: Y_n(x).
  *
@@ -146,7 +146,7 @@ export declare const besselJ: import("typed-function").TypedFunction;
  * @param x - Input value (must be positive), or Float64Array of values
  * @returns Y_n(x)
  */
-export declare const besselY: import("typed-function").TypedFunction;
+export declare const besselY: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Modified Bessel function of the first kind, I_n(x).
  *
@@ -154,7 +154,7 @@ export declare const besselY: import("typed-function").TypedFunction;
  * @param x - Input value, or Float64Array of values
  * @returns I_n(x)
  */
-export declare const besselI: import("typed-function").TypedFunction;
+export declare const besselI: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Modified Bessel function of the second kind, K_n(x).
  *
@@ -162,7 +162,7 @@ export declare const besselI: import("typed-function").TypedFunction;
  * @param x - Input value (must be positive), or Float64Array of values
  * @returns K_n(x)
  */
-export declare const besselK: import("typed-function").TypedFunction;
+export declare const besselK: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Complete elliptic integral of the first kind K(m).
  *
@@ -182,7 +182,7 @@ export declare const besselK: import("typed-function").TypedFunction;
  * @param m - Parameter (0 <= m < 1), or Float64Array of parameters
  * @returns K(m)
  */
-export declare const ellipticK: import("typed-function").TypedFunction;
+export declare const ellipticK: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Elliptic integral of the second kind E(phi, m) or complete form E(m).
  *
@@ -203,7 +203,7 @@ export declare const ellipticK: import("typed-function").TypedFunction;
  * @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;
+export declare const ellipticE: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Chebyshev polynomial of the first kind T_n(x).
  *
@@ -211,7 +211,7 @@ export declare const ellipticE: import("typed-function").TypedFunction;
  * @param x - Input value, or Float64Array of values
  * @returns T_n(x)
  */
-export declare const chebyshevT: import("typed-function").TypedFunction;
+export declare const chebyshevT: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Hermite polynomial H_n(x) (physicist's convention).
  *
@@ -219,7 +219,7 @@ export declare const chebyshevT: import("typed-function").TypedFunction;
  * @param x - Input value, or Float64Array of values
  * @returns H_n(x)
  */
-export declare const hermiteH: import("typed-function").TypedFunction;
+export declare const hermiteH: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Laguerre polynomial L_n(x).
  *
@@ -227,7 +227,7 @@ export declare const hermiteH: import("typed-function").TypedFunction;
  * @param x - Input value, or Float64Array of values
  * @returns L_n(x)
  */
-export declare const laguerreL: import("typed-function").TypedFunction;
+export declare const laguerreL: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Legendre polynomial P_n(x).
  *
@@ -235,7 +235,7 @@ export declare const laguerreL: import("typed-function").TypedFunction;
  * @param x - Input value in [-1, 1], or Float64Array of values
  * @returns P_n(x)
  */
-export declare const legendreP: import("typed-function").TypedFunction;
+export declare const legendreP: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Lambert W function.
  *
@@ -248,49 +248,49 @@ export declare const legendreP: import("typed-function").TypedFunction;
  * lambertW(1) // ~0.5671 (omega constant)
  * lambertW(-0.3, -1) // ~-1.7813 (lower branch)
  */
-export declare const lambertW: import("typed-function").TypedFunction;
+export declare const lambertW: import("@danielsimonjr/mathts-core").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;
+export declare const cosIntegral: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Sine integral Si(x).
  *
  * @param x - Input value, or Float64Array of values
  * @returns Si(x)
  */
-export declare const sinIntegral: import("typed-function").TypedFunction;
+export declare const sinIntegral: import("@danielsimonjr/mathts-core").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;
+export declare const logIntegral: import("@danielsimonjr/mathts-core").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;
+export declare const expIntegralEi: import("@danielsimonjr/mathts-core").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;
+export declare const fresnelC: import("@danielsimonjr/mathts-core").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;
+export declare const fresnelS: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Airy function of the first kind Ai(x).
  *
@@ -310,7 +310,7 @@ export declare const fresnelS: import("typed-function").TypedFunction;
  * @param x - Input value, or Float64Array of values
  * @returns Ai(x)
  */
-export declare const airyAi: import("typed-function").TypedFunction;
+export declare const airyAi: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Airy function of the second kind Bi(x).
  *
@@ -325,7 +325,7 @@ export declare const airyAi: import("typed-function").TypedFunction;
  * @param x - Input value, or Float64Array of values
  * @returns Bi(x)
  */
-export declare const airyBi: import("typed-function").TypedFunction;
+export declare const airyBi: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Carlson degenerate symmetric integral RC(x, y).
  *
@@ -338,7 +338,7 @@ export declare const airyBi: import("typed-function").TypedFunction;
  * @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;
+export declare const carlsonRC: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Carlson symmetric integral RF(x, y, z).
  *
@@ -349,7 +349,7 @@ export declare const carlsonRC: import("typed-function").TypedFunction;
  *
  * Reference: DLMF §19.16.1; Numerical Recipes §6.11.
  */
-export declare const carlsonRF: import("typed-function").TypedFunction;
+export declare const carlsonRF: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Carlson symmetric integral RD(x, y, z).
  *
@@ -359,7 +359,7 @@ export declare const carlsonRF: import("typed-function").TypedFunction;
  *
  * Reference: DLMF §19.16.5; Numerical Recipes §6.11.
  */
-export declare const carlsonRD: import("typed-function").TypedFunction;
+export declare const carlsonRD: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Carlson symmetric integral RJ(x, y, z, p).
  *
@@ -367,7 +367,7 @@ export declare const carlsonRD: import("typed-function").TypedFunction;
  *
  * Reference: DLMF §19.16.2; Numerical Recipes §6.11.
  */
-export declare const carlsonRJ: import("typed-function").TypedFunction;
+export declare const carlsonRJ: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Incomplete elliptic integral of the first kind F(φ, m).
  *
@@ -382,7 +382,7 @@ export declare const carlsonRJ: import("typed-function").TypedFunction;
  * @param phi - Amplitude in [0, π/2]
  * @param m - Parameter in [0, 1)
  */
-export declare const ellipticF: import("typed-function").TypedFunction;
+export declare const ellipticF: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Incomplete elliptic integral of the second kind E(φ, m) — Carlson form.
  *
@@ -397,7 +397,7 @@ export declare const ellipticF: import("typed-function").TypedFunction;
  * export which handles both the complete form (1-arg) and the Simpson
  * 2-arg form.
  */
-export declare const ellipticEIncomplete: import("typed-function").TypedFunction;
+export declare const ellipticEIncomplete: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Incomplete elliptic integral of the third kind Π(n, φ, m).
  *
@@ -410,49 +410,49 @@ export declare const ellipticEIncomplete: import("typed-function").TypedFunction
  *
  * Reference: DLMF §19.6, Abramowitz & Stegun §17.7.
  */
-export declare const ellipticPi: import("typed-function").TypedFunction;
+export declare const ellipticPi: import("@danielsimonjr/mathts-core").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;
+    erfc: import("@danielsimonjr/mathts-core").TypedFunction;
+    lgamma: import("@danielsimonjr/mathts-core").TypedFunction;
+    beta: import("@danielsimonjr/mathts-core").TypedFunction;
+    gammainc: import("@danielsimonjr/mathts-core").TypedFunction;
+    digamma: import("@danielsimonjr/mathts-core").TypedFunction;
+    besselJ0: import("@danielsimonjr/mathts-core").TypedFunction;
+    besselJ1: import("@danielsimonjr/mathts-core").TypedFunction;
+    besselY0: import("@danielsimonjr/mathts-core").TypedFunction;
+    besselY1: import("@danielsimonjr/mathts-core").TypedFunction;
+    besselJ: import("@danielsimonjr/mathts-core").TypedFunction;
+    besselY: import("@danielsimonjr/mathts-core").TypedFunction;
+    besselI: import("@danielsimonjr/mathts-core").TypedFunction;
+    besselK: import("@danielsimonjr/mathts-core").TypedFunction;
+    betainc: import("@danielsimonjr/mathts-core").TypedFunction;
+    gammaincp: import("@danielsimonjr/mathts-core").TypedFunction;
+    ellipticK: import("@danielsimonjr/mathts-core").TypedFunction;
+    ellipticE: import("@danielsimonjr/mathts-core").TypedFunction;
+    chebyshevT: import("@danielsimonjr/mathts-core").TypedFunction;
+    hermiteH: import("@danielsimonjr/mathts-core").TypedFunction;
+    laguerreL: import("@danielsimonjr/mathts-core").TypedFunction;
+    legendreP: import("@danielsimonjr/mathts-core").TypedFunction;
+    lambertW: import("@danielsimonjr/mathts-core").TypedFunction;
+    erfi: import("@danielsimonjr/mathts-core").TypedFunction;
+    cosIntegral: import("@danielsimonjr/mathts-core").TypedFunction;
+    sinIntegral: import("@danielsimonjr/mathts-core").TypedFunction;
+    logIntegral: import("@danielsimonjr/mathts-core").TypedFunction;
+    expIntegralEi: import("@danielsimonjr/mathts-core").TypedFunction;
+    fresnelC: import("@danielsimonjr/mathts-core").TypedFunction;
+    fresnelS: import("@danielsimonjr/mathts-core").TypedFunction;
+    airyAi: import("@danielsimonjr/mathts-core").TypedFunction;
+    airyBi: import("@danielsimonjr/mathts-core").TypedFunction;
+    carlsonRC: import("@danielsimonjr/mathts-core").TypedFunction;
+    carlsonRF: import("@danielsimonjr/mathts-core").TypedFunction;
+    carlsonRD: import("@danielsimonjr/mathts-core").TypedFunction;
+    carlsonRJ: import("@danielsimonjr/mathts-core").TypedFunction;
+    ellipticF: import("@danielsimonjr/mathts-core").TypedFunction;
+    ellipticEIncomplete: import("@danielsimonjr/mathts-core").TypedFunction;
+    ellipticPi: import("@danielsimonjr/mathts-core").TypedFunction;
 };
 export {};
 //# sourceMappingURL=special.d.ts.map

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

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

package/dist/typed/statistics.d.ts

@@ -22,73 +22,73 @@ export type NormalizationType = 'unbiased' | 'uncorrected' | 'biased';
 /**
  * Parallel sum with typed-function dispatch
  */
-export declare const parallelStatSum: import("typed-function").TypedFunction;
+export declare const parallelStatSum: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Parallel mean with typed-function dispatch
  */
-export declare const parallelStatMean: import("typed-function").TypedFunction;
+export declare const parallelStatMean: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Parallel variance with typed-function dispatch
  *
  * Uses Welford's algorithm for numerical stability
  */
-export declare const parallelStatVariance: import("typed-function").TypedFunction;
+export declare const parallelStatVariance: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Parallel standard deviation with typed-function dispatch
  */
-export declare const parallelStatStd: import("typed-function").TypedFunction;
+export declare const parallelStatStd: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Parallel minimum with typed-function dispatch
  */
-export declare const parallelStatMin: import("typed-function").TypedFunction;
+export declare const parallelStatMin: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Parallel maximum with typed-function dispatch
  */
-export declare const parallelStatMax: import("typed-function").TypedFunction;
+export declare const parallelStatMax: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Parallel minmax with typed-function dispatch
  * Returns both min and max in a single pass
  */
-export declare const parallelStatMinMax: import("typed-function").TypedFunction;
+export declare const parallelStatMinMax: import("@danielsimonjr/mathts-core").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;
+export declare const parallelStatMedian: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Parallel mode with typed-function dispatch
  * Returns the most frequently occurring value(s)
  */
-export declare const parallelStatMode: import("typed-function").TypedFunction;
+export declare const parallelStatMode: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Parallel product with typed-function dispatch
  */
-export declare const parallelStatProd: import("typed-function").TypedFunction;
+export declare const parallelStatProd: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Parallel Euclidean norm (L2 norm) with typed-function dispatch
  */
-export declare const parallelStatNorm: import("typed-function").TypedFunction;
+export declare const parallelStatNorm: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Parallel Euclidean distance with typed-function dispatch
  */
-export declare const parallelStatDistance: import("typed-function").TypedFunction;
+export declare const parallelStatDistance: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Parallel Pearson correlation coefficient
  */
-export declare const parallelStatCorr: import("typed-function").TypedFunction;
+export declare const parallelStatCorr: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Parallel Mean Absolute Deviation
  */
-export declare const parallelStatMAD: import("typed-function").TypedFunction;
+export declare const parallelStatMAD: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Parallel cumulative sum
  */
-export declare const parallelStatCumsum: import("typed-function").TypedFunction;
+export declare const parallelStatCumsum: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Parallel quantile computation
  */
-export declare const parallelStatQuantile: import("typed-function").TypedFunction;
+export declare const parallelStatQuantile: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Compute the p-th percentile of a Float64Array.
  *
@@ -102,7 +102,7 @@ export declare function parallelStatPercentile(data: Float64Array, p: f64): f64;
 /**
  * Parallel histogram computation
  */
-export declare const parallelStatHistogram: import("typed-function").TypedFunction;
+export declare const parallelStatHistogram: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Select the k-th smallest element from an array using Hoare's quickselect algorithm.
  * Average O(n) time complexity.
@@ -139,24 +139,24 @@ 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;
+    sum: import("@danielsimonjr/mathts-core").TypedFunction;
+    mean: import("@danielsimonjr/mathts-core").TypedFunction;
+    variance: import("@danielsimonjr/mathts-core").TypedFunction;
+    std: import("@danielsimonjr/mathts-core").TypedFunction;
+    min: import("@danielsimonjr/mathts-core").TypedFunction;
+    max: import("@danielsimonjr/mathts-core").TypedFunction;
+    minMax: import("@danielsimonjr/mathts-core").TypedFunction;
+    median: import("@danielsimonjr/mathts-core").TypedFunction;
+    mode: import("@danielsimonjr/mathts-core").TypedFunction;
+    prod: import("@danielsimonjr/mathts-core").TypedFunction;
+    norm: import("@danielsimonjr/mathts-core").TypedFunction;
+    distance: import("@danielsimonjr/mathts-core").TypedFunction;
+    corr: import("@danielsimonjr/mathts-core").TypedFunction;
+    mad: import("@danielsimonjr/mathts-core").TypedFunction;
+    cumsum: import("@danielsimonjr/mathts-core").TypedFunction;
+    quantile: import("@danielsimonjr/mathts-core").TypedFunction;
     percentile: typeof parallelStatPercentile;
-    histogram: import("typed-function").TypedFunction;
+    histogram: import("@danielsimonjr/mathts-core").TypedFunction;
     quickSelect: typeof quickSelect;
     medianSelect: typeof medianSelect;
     minSelect: typeof minSelect;

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

@@ -1 +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;AAiBtE;;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,wCAc7B,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"}
+{"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;AAiBtE;;GAEG;AACH,eAAO,MAAM,eAAe,oDAoB1B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,gBAAgB,oDAqB3B,CAAC;AAMH;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,oDA2D/B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,eAAe,oDAgC1B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,eAAe,oDAuB1B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,eAAe,oDAuB1B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB,oDAe7B,CAAC;AAMH;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,oDAgC7B,CAAC;AAMH;;;GAGG;AACH,eAAO,MAAM,gBAAgB,oDA2B3B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,gBAAgB,oDA8B3B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,gBAAgB,oDA4D3B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,oBAAoB,oDAiB/B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,gBAAgB,oDAgC3B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,eAAe,oDAsB1B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,kBAAkB,oDAc7B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,oBAAoB,oDAgC/B,CAAC;AAMH;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,YAAY,EAAE,CAAC,EAAE,GAAG,GAAG,GAAG,CAGtE;AAMD;;GAEG;AACH,eAAO,MAAM,qBAAqB,oDAsBhC,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"}

package/dist/typed/string.d.ts

@@ -35,7 +35,7 @@
  * bin(0)     // '0b0'
  * ```
  */
-export declare const bin: import("typed-function").TypedFunction;
+export declare const bin: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Format a number as hexadecimal.
  *
@@ -50,7 +50,7 @@ export declare const bin: import("typed-function").TypedFunction;
  * hex(0)     // '0x0'
  * ```
  */
-export declare const hex: import("typed-function").TypedFunction;
+export declare const hex: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Format a number as octal.
  *
@@ -65,7 +65,7 @@ export declare const hex: import("typed-function").TypedFunction;
  * oct(0)     // '0o0'
  * ```
  */
-export declare const oct: import("typed-function").TypedFunction;
+export declare const oct: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Format a value of any type into a string.
  *
@@ -85,7 +85,7 @@ export declare const oct: import("typed-function").TypedFunction;
  * format(NaN)                                 // 'NaN'
  * ```
  */
-export declare const format: import("typed-function").TypedFunction;
+export declare const format: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Interpolate values into a string template.
  *
@@ -100,15 +100,15 @@ export declare const format: import("typed-function").TypedFunction;
  * print('pi ≈ $pi', { pi: Math.PI }, 4)              // 'pi ≈ 3.142'
  * ```
  */
-export declare const print: import("typed-function").TypedFunction;
+export declare const print: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * All typed string-formatting functions.
  */
 export declare const typedString: {
-    bin: import("typed-function").TypedFunction;
-    hex: import("typed-function").TypedFunction;
-    oct: import("typed-function").TypedFunction;
-    format: import("typed-function").TypedFunction;
-    print: import("typed-function").TypedFunction;
+    bin: import("@danielsimonjr/mathts-core").TypedFunction;
+    hex: import("@danielsimonjr/mathts-core").TypedFunction;
+    oct: import("@danielsimonjr/mathts-core").TypedFunction;
+    format: import("@danielsimonjr/mathts-core").TypedFunction;
+    print: import("@danielsimonjr/mathts-core").TypedFunction;
 };
 //# sourceMappingURL=string.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../src/typed/string.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAkGH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,GAAG,wCAQd,CAAC;AAMH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,GAAG,wCAQd,CAAC;AAMH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,GAAG,wCAQd,CAAC;AAMH;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,wCAyCjB,CAAC;AAMH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,KAAK,wCAShB,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;CAMvB,CAAC"}
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../src/typed/string.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAkGH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,GAAG,oDAQd,CAAC;AAMH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,GAAG,oDAQd,CAAC;AAMH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,GAAG,oDAQd,CAAC;AAMH;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,oDAyCjB,CAAC;AAMH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,KAAK,oDAShB,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;CAMvB,CAAC"}