@danielsimonjr/mathts-functions 0.2.3 → 0.2.4

package/dist/wasm/interpolation/wasm-bridge.d.ts

@@ -0,0 +1,95 @@
+/**
+ * WASM dispatch bridge for the tridiagonal-solve and divided-difference
+ * hot loops (Slices 3.10b and 5.5).
+ *
+ * Two kernels are exposed:
+ *   - `tridiag_solve_f64`      — O(n) Thomas algorithm for a tridiagonal system
+ *   - `divided_difference_f64` — O(n²) Newton divided-difference table
+ *
+ * Behavior:
+ *   - When `wasmLoader.getModule()` returns null (module not loaded or
+ *     load failed), the helper returns the JS fallback result without
+ *     throwing.
+ *   - When the loaded module exposes the Rust export, we marshal the
+ *     Float64Array operands into WASM-owned memory, run the kernel, and
+ *     return a JS-side copy of the result.
+ *   - When only the AS export is present (the AS binary is loaded), we
+ *     pass the Float64Array references directly via the `_as`-named
+ *     variant.
+ *   - Any thrown error is swallowed and the JS fallback runs — the
+ *     WASM tier is an optimisation, not a correctness requirement.
+ *
+ * Threshold:
+ *   The marshal cost (four memcpys in + one out) pays off when the O(n)
+ *   inner loop is large enough.  A knot-count of ≥ 1024 is the
+ *   empirically-chosen break-even point; see
+ *   `tools/benchmark/wasm/tridiag.bench.ts`.
+ */
+/**
+ * Knot-count threshold above which we attempt the WASM tridiag kernel.
+ * Gated on the length of `diag` (== number of unknowns).
+ */
+export declare const WASM_TRIDIAG_THRESHOLD = 1024;
+/**
+ * Knot-count threshold above which we attempt the WASM divided-difference
+ * kernel.  The O(n²) table is large enough to benefit from WASM at ≥ 256
+ * knots; below that, marshal overhead dominates.
+ */
+export declare const WASM_INTERP_THRESHOLD = 256;
+/**
+ * Pure-JS Thomas algorithm — used as the below-threshold / no-WASM fallback.
+ *
+ * Solves a tridiagonal system A·x = rhs in O(n).
+ *
+ * @param diag  - main diagonal,   length n
+ * @param lower - sub-diagonal,    length n-1
+ * @param upper - super-diagonal,  length n-1
+ * @param rhs   - right-hand side, length n
+ * @returns solution x, length n
+ */
+export declare function tridiagSolveJS(diag: Float64Array, lower: Float64Array, upper: Float64Array, rhs: Float64Array): Float64Array;
+/**
+ * Solve a tridiagonal system via WASM when `diag.length` is at or above
+ * the threshold, otherwise falls back to the inline JS Thomas algorithm.
+ *
+ * @param diag  - main diagonal,   length n
+ * @param lower - sub-diagonal,    length n-1
+ * @param upper - super-diagonal,  length n-1
+ * @param rhs   - right-hand side, length n
+ * @returns solution Float64Array of length n
+ */
+export declare function tridiagSolveDispatch(diag: Float64Array, lower: Float64Array, upper: Float64Array, rhs: Float64Array): Float64Array;
+/**
+ * Test-only hook — re-exported so tests can reset loader state
+ * without importing WasmLoader directly.
+ */
+export declare function resetTridiagWasm(): void;
+/**
+ * Pure-JS Newton divided-difference computation — used as the
+ * below-threshold / no-WASM fallback.
+ *
+ * Given n distinct nodes (xs, ys), returns a Float64Array of n Newton-form
+ * coefficients c_0 … c_{n-1} such that:
+ *
+ *   P(x) = c_0 + c_1·(x-x_0) + c_2·(x-x_0)(x-x_1) + …
+ *
+ * Throws `RangeError` when any two x-values are equal (degenerate input).
+ *
+ * @param xs - interpolation nodes (distinct)
+ * @param ys - function values at xs
+ * @returns Newton-form coefficient array of length n
+ */
+export declare function dividedDifferenceJS(xs: Float64Array, ys: Float64Array): Float64Array;
+/**
+ * Compute Newton divided-difference coefficients via WASM when
+ * `xs.length` is at or above WASM_INTERP_THRESHOLD, otherwise falls
+ * back to the inline JS implementation.
+ *
+ * @param xs - interpolation nodes (distinct), length n
+ * @param ys - function values at xs, length n
+ * @returns Newton-form coefficient Float64Array of length n
+ * @throws RangeError on duplicate x-values (JS path only; WASM path
+ *         falls back to JS on error return)
+ */
+export declare function dividedDifferenceDispatch(xs: Float64Array, ys: Float64Array): Float64Array;
+//# sourceMappingURL=wasm-bridge.d.ts.map

package/dist/wasm/interpolation/wasm-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-bridge.d.ts","sourceRoot":"","sources":["../../../src/wasm/interpolation/wasm-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH;;;GAGG;AACH,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAE3C;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAczC;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,YAAY,EAClB,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,YAAY,EACnB,GAAG,EAAE,YAAY,GAChB,YAAY,CA8Bd;AAwBD;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,YAAY,EAClB,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,YAAY,EACnB,GAAG,EAAE,YAAY,GAChB,YAAY,CAwDd;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,YAAY,EAAE,EAAE,EAAE,YAAY,GAAG,YAAY,CAepF;AAQD;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,YAAY,EAAE,EAAE,EAAE,YAAY,GAAG,YAAY,CA4C1F"}

package/dist/wasm/poly/wasm-bridge.d.ts

@@ -0,0 +1,99 @@
+/**
+ * WASM dispatch bridge for polynomial hot-loop kernels.
+ *
+ * Four kernels are exposed:
+ *   - `poly_mul_f64`         — O(n·m) coefficient convolution
+ *   - `poly_div_mod_f64`     — polynomial long division (returns concat [quot|rem])
+ *   - `poly_resultant_f64`   — Sylvester-matrix determinant (Slice 4.5)
+ *   - `poly_discriminant_f64` — discriminant via Res(p, p') (Slice 4.5)
+ *
+ * Behavior:
+ *   - When `wasmLoader.getModule()` returns null (module not loaded or
+ *     load failed), every helper here returns the JS fallback result
+ *     without throwing.
+ *   - When the loaded module exposes the matching Rust export, we
+ *     marshal the Float64Array operands into WASM-owned memory, run
+ *     the kernel, and return a JS-side copy of the result.
+ *   - When only the AS export is present (the AS binary is loaded),
+ *     we pass the Float64Array references directly via the `_as`-named
+ *     variant (see `WasmModule` interface entries).
+ *   - Any thrown error is swallowed and the JS fallback runs — the
+ *     WASM tier is an optimisation, not a correctness requirement.
+ *
+ * Threshold:
+ *   The marshal cost (two memcpys in + one out) pays off when the
+ *   O(n·m) inner loop is large enough. A polynomial length ≥ 256
+ *   coefficients is the empirically-chosen break-even point; see
+ *   `tools/benchmark/wasm/poly.bench.ts`.
+ */
+/**
+ * Coefficient-count threshold above which we attempt the WASM kernel.
+ * For `poly_mul_f64`, we gate on either operand reaching this length;
+ * for `poly_div_mod_f64`, we gate on `num.length`.
+ */
+export declare const WASM_POLY_THRESHOLD = 256;
+/**
+ * Multiply two polynomials `a` and `b` via WASM when either operand
+ * length exceeds the threshold, otherwise falls back to inline JS.
+ *
+ * Returns a `Float64Array` of length `a.length + b.length - 1`.
+ */
+export declare function polyMulDispatch(a: Float64Array, b: Float64Array): Float64Array;
+/**
+ * Divide polynomial `num` by `den` via WASM when `num.length` exceeds
+ * the threshold, otherwise falls back to inline JS.
+ *
+ * Returns `{ quotient: Float64Array, remainder: Float64Array }`.
+ */
+export declare function polyDivModDispatch(num: Float64Array, den: Float64Array): {
+    quotient: Float64Array;
+    remainder: Float64Array;
+};
+/**
+ * Compute the resultant of `p` and `q` via WASM when either polynomial
+ * length exceeds the threshold, otherwise falls back to inline JS.
+ */
+export declare function resultantDispatch(p: Float64Array, q: Float64Array): number;
+/**
+ * Compute the discriminant of `p` via WASM when the polynomial length
+ * exceeds the threshold, otherwise falls back to inline JS.
+ */
+export declare function discriminantDispatch(p: Float64Array): number;
+/**
+ * Sample-count threshold above which we attempt the WASM kernel for
+ * poly_fit / cheb_fit / legendre_fit.  Below this, the marshal cost
+ * (two memcpys in + one out) dominates; above it, the O(n·k²) QR
+ * factorisation pays off.
+ */
+export declare const WASM_POLY_FIT_THRESHOLD = 1024;
+/**
+ * Fit a polynomial via Vandermonde + QR using WASM when n ≥ threshold.
+ *
+ * Returns a `Float64Array` of length `degree + 1` with coefficients
+ * `[a0, a1, ..., a_degree]` (constant-first / power-ascending order).
+ *
+ * Throws when the system is rank-deficient (e.g. all xs equal).
+ */
+export declare function polyFitDispatch(xs: Float64Array, ys: Float64Array, degree: number): Float64Array;
+/**
+ * Fit a Chebyshev-series via Vandermonde + QR using WASM when n ≥ threshold.
+ *
+ * Returns a `Float64Array` of length `degree + 1` with Chebyshev coefficients.
+ *
+ * Throws when the system is rank-deficient.
+ */
+export declare function chebFitDispatch(xs: Float64Array, ys: Float64Array, degree: number): Float64Array;
+/**
+ * Fit a Legendre-series via Vandermonde + QR using WASM when n ≥ threshold.
+ *
+ * Returns a `Float64Array` of length `degree + 1` with Legendre coefficients.
+ *
+ * Throws when the system is rank-deficient.
+ */
+export declare function legendreFitDispatch(xs: Float64Array, ys: Float64Array, degree: number): Float64Array;
+/**
+ * Test-only hook — re-exported so tests can reset loader state
+ * without importing WasmLoader directly.
+ */
+export declare function resetPolyWasm(): void;
+//# sourceMappingURL=wasm-bridge.d.ts.map

package/dist/wasm/poly/wasm-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-bridge.d.ts","sourceRoot":"","sources":["../../../src/wasm/poly/wasm-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAIH;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,MAAM,CAAC;AA8EvC;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,GAAG,YAAY,CAsC9E;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,YAAY,EACjB,GAAG,EAAE,YAAY,GAChB;IAAE,QAAQ,EAAE,YAAY,CAAC;IAAC,SAAS,EAAE,YAAY,CAAA;CAAE,CAgErD;AAuGD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,GAAG,MAAM,CAiC1E;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,YAAY,GAAG,MAAM,CA+B5D;AAMD;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAoM5C;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,YAAY,EAAE,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY,CAEhG;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,YAAY,EAAE,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY,CAEhG;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,YAAY,EAChB,EAAE,EAAE,YAAY,EAChB,MAAM,EAAE,MAAM,GACb,YAAY,CASd;AAED;;;GAGG;AACH,wBAAgB,aAAa,IAAI,IAAI,CAEpC"}

package/dist/wasm/signal/wasm-bridge.d.ts

@@ -0,0 +1,61 @@
+/**
+ * WASM dispatch bridge for spectral signal kernels — Slice 5.6.
+ *
+ * Kernels covered:
+ *   - `apply_window_f64`       — in-place window multiplication
+ *   - `welch_psd_f64`          — Welch's overlapped-segment-averaging PSD
+ *   - `bartlett_psd_f64`       — Bartlett's non-overlapped segment-averaging PSD
+ *   - `goertzel_f64`           — Goertzel single-bin DFT (returns |X[k]|²)
+ *   - `chirp_z_transform_f64`  — Bluestein chirp-Z transform
+ *
+ * Dispatch order (for arrays ≥ WASM_SIGNAL_THRESHOLD = 4096 samples):
+ *   1. Probe Rust export (pointer-style ABI).
+ *   2. If absent, probe AS export (`*_as` suffix, typed-array ABI).
+ *   3. Fall back to pure-JS implementation.
+ *
+ * Window-type encoding:
+ *   0 = Hann, 1 = Hamming, 2 = Blackman, 3 = Rectangular (no-op)
+ *
+ * Any thrown error is swallowed and the JS fallback runs — the WASM tier
+ * is an optimisation, not a correctness requirement.
+ */
+/** Minimum sample count for WASM acceleration. */
+export declare const WASM_SIGNAL_THRESHOLD = 4096;
+/** JS fallback: apply a window to `samples` in-place. */
+export declare function applyWindowJS(samples: Float64Array, windowType: number): void;
+/** JS fallback: Goertzel algorithm, returns |X[k]|² at `targetFreq`. */
+export declare function goertzelJS(samples: Float64Array, targetFreq: number, sampleRate: number): number;
+/** JS fallback: Welch's PSD. */
+export declare function welchPSDJS(samples: Float64Array, frameLength: number, overlap: number, windowType: number): Float64Array;
+/** JS fallback: Bartlett's PSD (Welch with rectangular window, overlap=0). */
+export declare function bartlettPSDJS(samples: Float64Array, frameLength: number): Float64Array;
+/** JS fallback: Chirp-Z Transform (Bluestein). */
+export declare function chirpZTransformJS(samples: Float64Array, m: number, phiStartRe: number, phiStartIm: number, phiStepRe: number, phiStepIm: number): {
+    re: Float64Array;
+    im: Float64Array;
+};
+/**
+ * Apply a window function to `samples` in-place.
+ * Always runs (no threshold — small arrays benefit too).
+ */
+export declare function applyWindowDispatch(samples: Float64Array, windowName: string): void;
+/**
+ * Welch's PSD with WASM acceleration above threshold.
+ */
+export declare function welchPSDDispatch(samples: Float64Array, frameLength: number, overlap: number, windowName: string): Float64Array;
+/**
+ * Bartlett's PSD with WASM acceleration above threshold.
+ */
+export declare function bartlettPSDDispatch(samples: Float64Array, frameLength: number): Float64Array;
+/**
+ * Goertzel single-bin DFT with WASM acceleration above threshold.
+ */
+export declare function goertzelDispatch(samples: Float64Array, targetFreq: number, sampleRate: number): number;
+/**
+ * Chirp-Z Transform with WASM acceleration above threshold.
+ */
+export declare function chirpZTransformDispatch(samples: Float64Array, m: number, phiStartRe: number, phiStartIm: number, phiStepRe: number, phiStepIm: number): {
+    re: Float64Array;
+    im: Float64Array;
+};
+//# sourceMappingURL=wasm-bridge.d.ts.map

package/dist/wasm/signal/wasm-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-bridge.d.ts","sourceRoot":"","sources":["../../../src/wasm/signal/wasm-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAQH,kDAAkD;AAClD,eAAO,MAAM,qBAAqB,OAAO,CAAC;AAmC1C,yDAAyD;AACzD,wBAAgB,aAAa,CAAC,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAuB7E;AAED,wEAAwE;AACxE,wBAAgB,UAAU,CAAC,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAchG;AA2DD,gCAAgC;AAChC,wBAAgB,UAAU,CACxB,OAAO,EAAE,YAAY,EACrB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GACjB,YAAY,CA2Cd;AAED,8EAA8E;AAC9E,wBAAgB,aAAa,CAAC,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,GAAG,YAAY,CAEtF;AAED,kDAAkD;AAClD,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,YAAY,EACrB,CAAC,EAAE,MAAM,EACT,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB;IAAE,EAAE,EAAE,YAAY,CAAC;IAAC,EAAE,EAAE,YAAY,CAAA;CAAE,CAiExC;AAMD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CA+BnF;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,YAAY,EACrB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GACjB,YAAY,CAoDd;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,GAAG,YAAY,CA4C5F;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,YAAY,EACrB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,MAAM,CAqCR;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,YAAY,EACrB,CAAC,EAAE,MAAM,EACT,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB;IAAE,EAAE,EAAE,YAAY,CAAC;IAAC,EAAE,EAAE,YAAY,CAAA;CAAE,CA+ExC"}

package/dist/wasm/sort/wasm-bridge.d.ts

@@ -0,0 +1,43 @@
+/**
+ * WASM dispatch bridge for sort kernels — Slice 5.7a.
+ *
+ * Kernels covered:
+ *   - `sort_f64`    — in-place ascending sort (NaN-last, returns same array).
+ *   - `argsort_f64` — return Int32Array of permutation indices (NaN-last).
+ *   - `rank_f64`    — return Int32Array of ranks (0-indexed, NaN-last).
+ *
+ * Dispatch order (for arrays ≥ WASM_SORT_THRESHOLD = 16 384 elements):
+ *   1. Probe Rust export (`sort_f64` / `argsort_f64` / `rank_f64`).
+ *   2. If absent, probe AS export (same name, typed-array ABI).
+ *   3. Fall back to pure-JS implementation.
+ *
+ * Any thrown error is swallowed and the JS fallback runs — WASM is an
+ * optimisation, not a correctness requirement.
+ */
+/** Minimum element count for WASM acceleration. */
+export declare const WASM_SORT_THRESHOLD = 16384;
+/** JS fallback: sort Float64Array in-place (NaN-last). Returns same array. */
+export declare function sortF64JS(data: Float64Array): Float64Array;
+/** JS fallback: return argsort permutation (NaN-last). */
+export declare function argsortF64JS(data: Float64Array): Int32Array;
+/** JS fallback: return rank array (NaN-last). */
+export declare function rankF64JS(data: Float64Array): Int32Array;
+/**
+ * Sort `data` in place (ascending, NaN-last).
+ * Returns the same array for convenience.
+ * Uses WASM above {@link WASM_SORT_THRESHOLD}.
+ */
+export declare function sortF64Dispatch(data: Float64Array): Float64Array;
+/**
+ * Return the argsort permutation for `data` (NaN-last).
+ * After the call, `data[result[0]] ≤ data[result[1]] ≤ …`
+ * Uses WASM above {@link WASM_SORT_THRESHOLD}.
+ */
+export declare function argsortF64Dispatch(data: Float64Array): Int32Array;
+/**
+ * Return the rank array for `data` (0-indexed, NaN-last).
+ * `result[i]` = position of `data[i]` in the sorted array.
+ * Uses WASM above {@link WASM_SORT_THRESHOLD}.
+ */
+export declare function rankF64Dispatch(data: Float64Array): Int32Array;
+//# sourceMappingURL=wasm-bridge.d.ts.map

package/dist/wasm/sort/wasm-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-bridge.d.ts","sourceRoot":"","sources":["../../../src/wasm/sort/wasm-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAQH,mDAAmD;AACnD,eAAO,MAAM,mBAAmB,QAAQ,CAAC;AA6BzC,8EAA8E;AAC9E,wBAAgB,SAAS,CAAC,IAAI,EAAE,YAAY,GAAG,YAAY,CAO1D;AAED,0DAA0D;AAC1D,wBAAgB,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG,UAAU,CAS3D;AAED,iDAAiD;AACjD,wBAAgB,SAAS,CAAC,IAAI,EAAE,YAAY,GAAG,UAAU,CAMxD;AAMD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,YAAY,GAAG,YAAY,CAqChE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,YAAY,GAAG,UAAU,CAyCjE;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,YAAY,GAAG,UAAU,CAyC9D"}

package/dist/wasm/special/wasm-bridge.d.ts

@@ -0,0 +1,133 @@
+/**
+ * WASM dispatch bridge for Bessel J/Y and Airy Ai/Bi array kernels.
+ *
+ * Kernels exposed (Bessel — Slice 3.10c-1; Airy — Slice 4.9):
+ *   - `bessel_j0_f64` — J0(x) applied element-wise over a Float64Array
+ *   - `bessel_j1_f64` — J1(x) applied element-wise
+ *   - `bessel_j_f64`  — J_n(x) applied element-wise (fixed integer order n)
+ *   - `bessel_y0_f64` — Y0(x) applied element-wise
+ *   - `bessel_y1_f64` — Y1(x) applied element-wise
+ *   - `bessel_y_f64`  — Y_n(x) applied element-wise (fixed integer order n)
+ *   - `airy_ai_f64`   — Ai(x) applied element-wise
+ *   - `airy_bi_f64`   — Bi(x) applied element-wise
+ *
+ * Dispatch order (for arrays ≥ WASM_SPECIAL_THRESHOLD = 1024 elements):
+ *   1. Probe Rust export (pointer-style ABI).
+ *   2. If absent, probe AS export (`*_as` suffix, typed-array ABI).
+ *   3. Fall back to pure-JS implementation.
+ *
+ * AS parity (Slice 4.9): `assembly/src/special.ts` implements all 8 kernels
+ *   with the same algorithms.  The `_as`-suffix probes below pick them up
+ *   automatically when the AS WASM binary is loaded
+ *   (MATHJS_WASM_BACKEND=assemblyscript).
+ *
+ * Any thrown error is swallowed and the JS fallback runs — the WASM tier
+ * is an optimisation, not a correctness requirement.
+ *
+ * Threshold:
+ *   The pointer-marshal overhead (2 memcpys in + 1 out) pays off for arrays
+ *   of ≥ 1024 elements.  Verified empirically; see
+ *   `tools/benchmark/wasm/special.bench.ts`.
+ */
+/**
+ * Element-count threshold above which we attempt the WASM Bessel kernels.
+ */
+export declare const WASM_SPECIAL_THRESHOLD = 1024;
+/** JS fallback: J0(x) for all x. */
+export declare function besselJ0JS(xs: Float64Array): Float64Array;
+/** JS fallback: J1(x) for all x. */
+export declare function besselJ1JS(xs: Float64Array): Float64Array;
+/** JS fallback: J_n(x) for all x. */
+export declare function besselJnJS(n: number, xs: Float64Array): Float64Array;
+/** JS fallback: Y0(x) for all x (NaN for x ≤ 0). */
+export declare function besselY0JS(xs: Float64Array): Float64Array;
+/** JS fallback: Y1(x) for all x (NaN for x ≤ 0). */
+export declare function besselY1JS(xs: Float64Array): Float64Array;
+/** JS fallback: Y_n(x) for all x (NaN for x ≤ 0). */
+export declare function besselYnJS(n: number, xs: Float64Array): Float64Array;
+/** JS fallback: Ai(x) for all x. */
+export declare function airyAiJS(xs: Float64Array): Float64Array;
+/** JS fallback: Bi(x) for all x. */
+export declare function airyBiJS(xs: Float64Array): Float64Array;
+/** Dispatch J0 over an array — Rust WASM above threshold, then AS, then JS. */
+export declare function besselJ0Dispatch(xs: Float64Array): Float64Array;
+/** Dispatch J1 over an array — Rust WASM above threshold, then AS, then JS. */
+export declare function besselJ1Dispatch(xs: Float64Array): Float64Array;
+/** Dispatch J_order over an array — Rust WASM, then AS, then JS. */
+export declare function besselJDispatch(order: number, xs: Float64Array): Float64Array;
+/** Dispatch Y0 over an array — Rust WASM, then AS, then JS. */
+export declare function besselY0Dispatch(xs: Float64Array): Float64Array;
+/** Dispatch Y1 over an array — Rust WASM, then AS, then JS. */
+export declare function besselY1Dispatch(xs: Float64Array): Float64Array;
+/** Dispatch Y_order over an array — Rust WASM, then AS, then JS. */
+export declare function besselYDispatch(order: number, xs: Float64Array): Float64Array;
+/** Dispatch Ai(x) over an array — WASM above threshold, JS below. */
+export declare function airyAiDispatch(xs: Float64Array): Float64Array;
+/** Dispatch Bi(x) over an array — WASM above threshold, JS below. */
+export declare function airyBiDispatch(xs: Float64Array): Float64Array;
+/** JS fallback: lgamma(x) applied element-wise. */
+export declare function lgammaJS(xs: Float64Array): Float64Array;
+/**
+ * Dispatch lgamma over an array — Rust WASM above threshold, then AS, then JS.
+ *
+ * For arrays ≥ WASM_SPECIAL_THRESHOLD (1024):
+ *   1. Probe Rust `lgamma_f64` (pointer-style).
+ *   2. If absent, probe AS `lgamma_f64` (typed-array style, suffix `_as`).
+ *   3. Fall back to pure-JS `lgammaJS`.
+ */
+export declare function lgammaDispatch(xs: Float64Array): Float64Array;
+export declare function carlsonRCJS(xs: Float64Array, ys: Float64Array): Float64Array;
+export declare function carlsonRFJS(xs: Float64Array, ys: Float64Array, zs: Float64Array): Float64Array;
+export declare function carlsonRDJS(xs: Float64Array, ys: Float64Array, zs: Float64Array): Float64Array;
+export declare function carlsonRJJS(xs: Float64Array, ys: Float64Array, zs: Float64Array, ps: Float64Array): Float64Array;
+export declare function ellipticFIncompleteJS(phis: Float64Array, ms: Float64Array): Float64Array;
+export declare function ellipticEIncompleteJS(phis: Float64Array, ms: Float64Array): Float64Array;
+export declare function ellipticPiIncompleteJS(ns: Float64Array, phis: Float64Array, ms: Float64Array): Float64Array;
+export declare function carlsonRCScalar(x: number, y: number): number;
+export declare function carlsonRFScalar(x: number, y: number, z: number): number;
+export declare function carlsonRDScalar(x: number, y: number, z: number): number;
+export declare function carlsonRJScalar(x: number, y: number, z: number, p: number): number;
+export declare function ellipticFIncompleteScalar(phi: number, m: number): number;
+export declare function ellipticEIncompleteScalar(phi: number, m: number): number;
+export declare function ellipticPiIncompleteScalar(n: number, phi: number, m: number): number;
+/** Dispatch RC(x, y) element-wise — Rust WASM ≥ threshold, AS fallback, JS fallback. */
+export declare function carlsonRCDispatch(xs: Float64Array, ys: Float64Array): Float64Array;
+/** Dispatch RF(x, y, z) element-wise. */
+export declare function carlsonRFDispatch(xs: Float64Array, ys: Float64Array, zs: Float64Array): Float64Array;
+/** Dispatch RD(x, y, z) element-wise. */
+export declare function carlsonRDDispatch(xs: Float64Array, ys: Float64Array, zs: Float64Array): Float64Array;
+/** Dispatch RJ(x, y, z, p) element-wise. */
+export declare function carlsonRJDispatch(xs: Float64Array, ys: Float64Array, zs: Float64Array, ps: Float64Array): Float64Array;
+/** Dispatch F(φ, m) element-wise. */
+export declare function ellipticFIncompleteDispatch(phis: Float64Array, ms: Float64Array): Float64Array;
+/** Dispatch E(φ, m) (incomplete) element-wise. */
+export declare function ellipticEIncompleteDispatch(phis: Float64Array, ms: Float64Array): Float64Array;
+/** Dispatch Π(n, φ, m) element-wise. */
+export declare function ellipticPiIncompleteDispatch(ns: Float64Array, phis: Float64Array, ms: Float64Array): Float64Array;
+export declare function resetCarlsonWasm(): void;
+/**
+ * Test-only hook — re-exported so tests can reset loader state
+ * without importing WasmLoader directly.
+ */
+export declare function resetBesselWasm(): void;
+/**
+ * Test-only alias for Airy reset (uses same singleton).
+ */
+export declare function resetAiryWasm(): void;
+/**
+ * Test-only alias for Elliptic reset (uses same singleton).
+ */
+export declare function resetEllipticWasm(): void;
+/**
+ * Test-only alias for lgamma reset (uses same singleton).
+ */
+export declare function resetLgammaWasm(): void;
+/** JS fallback: K(m) applied element-wise. */
+export declare function ellipticKJS(ms: Float64Array): Float64Array;
+/** JS fallback: E(m) applied element-wise. */
+export declare function ellipticEJS(ms: Float64Array): Float64Array;
+/** Dispatch K(m) over an array — Rust WASM above threshold, then AS, then JS. */
+export declare function ellipticKDispatch(ms: Float64Array): Float64Array;
+/** Dispatch E(m) over an array — Rust WASM above threshold, then AS, then JS. */
+export declare function ellipticEDispatch(ms: Float64Array): Float64Array;
+//# sourceMappingURL=wasm-bridge.d.ts.map

package/dist/wasm/special/wasm-bridge.d.ts.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-functions",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
   "author": "Daniel Simon Jr.",
   "license": "MIT",
@@ -19,7 +19,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsup src/index.ts --format esm --clean",
+    "build": "tsup src/index.ts --format esm --clean && tsc -p tsconfig.dts.json",
     "dev": "tsup src/index.ts --format esm --dts --watch",
     "test": "vitest run",
     "test:watch": "vitest",