@danielsimonjr/mathts-functions 0.2.2 → 0.2.4

package/dist/typed/index.d.ts

@@ -0,0 +1,299 @@
+/**
+ * Typed Functions Index (Parallel-First)
+ *
+ * Re-exports all typed functions that use polymorphic dispatch
+ * via @danielsimonjr/mathts-core's mathTyped system with parallel-first execution
+ * through @danielsimonjr/mathts-parallel's ComputePool.
+ *
+ * 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
+ */
+export * from './arithmetic.js';
+export { typedArithmetic } from './arithmetic.js';
+export * from './trigonometry.js';
+export { typedTrigonometry } from './trigonometry.js';
+export * from './statistics.js';
+export { typedStatistics } from './statistics.js';
+export * from './signal.js';
+export { typedSignal } from './signal.js';
+export * from './bitwise.js';
+export { typedBitwise } from './bitwise.js';
+export * from './logical.js';
+export { typedLogical } from './logical.js';
+export * from './complex.js';
+export { typedComplex } from './complex.js';
+export * from './set.js';
+export { typedSet } from './set.js';
+export * from './special.js';
+export { typedSpecial } from './special.js';
+export * from './distributions.js';
+export { typedDistributions } from './distributions.js';
+export * from './geometry.js';
+export * from './algebra.js';
+export { typedAlgebra } from './algebra.js';
+export * from './integration.js';
+export * from './interpolation.js';
+export * from './numeric.js';
+export * from './combinatorics.js';
+export * from './graph.js';
+export * from './dist-objects.js';
+export * from './hypothesis.js';
+export * from './matrix-ops.js';
+export { cond } from './matrix-ops.js';
+export * from './gpu.js';
+export * from './relational.js';
+export { typedRelational } from './relational.js';
+export * from './string.js';
+export { typedString } from './string.js';
+export * from './probability.js';
+export { typedProbability } from './probability.js';
+export * from './unit.js';
+export { typedUnit } from './unit.js';
+/**
+ * All typed functions combined (parallel-first)
+ *
+ * This includes all arithmetic, trigonometric, statistics, signal
+ * processing, special, probability distribution, combinatorics,
+ * graph theory, distribution objects, hypothesis test, and algebra functions.
+ */
+export declare const typedFunctions: {
+    to: import("typed-function").TypedFunction;
+    toBest: import("typed-function").TypedFunction;
+    polyval: typeof import("./algebra.js").polyval;
+    polyadd: typeof import("./algebra.js").polyadd;
+    polymul: typeof import("./algebra.js").polymul;
+    polyder: typeof import("./algebra.js").polyder;
+    polynomialGCD: typeof import("./algebra.js").polynomialGCD;
+    polynomialLCM: typeof import("./algebra.js").polynomialLCM;
+    polynomialQuotient: typeof import("./algebra.js").polynomialQuotient;
+    polynomialRemainder: typeof import("./algebra.js").polynomialRemainder;
+    degree: typeof import("./algebra.js").degree;
+    coefficientList: typeof import("./algebra.js").coefficientList;
+    discriminant: typeof import("./algebra.js").discriminant;
+    differences: typeof import("./algebra.js").differences;
+    expand: typeof import("./algebra.js").expand;
+    factor: typeof import("./algebra.js").factor;
+    collect: typeof import("./algebra.js").collect;
+    substitute: typeof import("./algebra.js").substitute;
+    variables: typeof import("./algebra.js").variables;
+    cancel: typeof import("./algebra.js").cancel;
+    together: typeof import("./algebra.js").together;
+    apart: typeof import("./algebra.js").apart;
+    trigExpand: typeof import("./algebra.js").trigExpand;
+    trigReduce: typeof import("./algebra.js").trigReduce;
+    trigToExp: typeof import("./algebra.js").trigToExp;
+    expToTrig: typeof import("./algebra.js").expToTrig;
+    tangentLine: typeof import("./algebra.js").tangentLine;
+    reduce: typeof import("./algebra.js").reduce;
+    combine: typeof import("./algebra.js").combine;
+    complexExpand: typeof import("./algebra.js").complexExpand;
+    normalForm: typeof import("./algebra.js").normalForm;
+    powerExpand: typeof import("./algebra.js").powerExpand;
+    fullSimplify: typeof import("./algebra.js").fullSimplify;
+    element: typeof import("./algebra.js").element;
+    eliminate: typeof import("./algebra.js").eliminate;
+    symbolicPartialDerivative: typeof import("./algebra.js").symbolicPartialDerivative;
+    functionExpand: typeof import("./algebra.js").functionExpand;
+    resultant: typeof import("./algebra.js").resultant;
+    normalPDF: import("typed-function").TypedFunction;
+    normalCDF: import("typed-function").TypedFunction;
+    exponentialPDF: import("typed-function").TypedFunction;
+    exponentialCDF: import("typed-function").TypedFunction;
+    poissonPMF: import("typed-function").TypedFunction;
+    binomialPMF: import("typed-function").TypedFunction;
+    geometricPMF: import("typed-function").TypedFunction;
+    bernoulliPMF: import("typed-function").TypedFunction;
+    entropy: import("typed-function").TypedFunction;
+    jsDivergence: import("typed-function").TypedFunction;
+    betaPDF: import("typed-function").TypedFunction;
+    gammaPDF: import("typed-function").TypedFunction;
+    studentTPDF: import("typed-function").TypedFunction;
+    noncentralChi2PDF: import("typed-function").TypedFunction;
+    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;
+    fibonacci: import("typed-function").TypedFunction;
+    lucas: import("typed-function").TypedFunction;
+    doubleFactorial: import("typed-function").TypedFunction;
+    risingFactorial: import("typed-function").TypedFunction;
+    fallingFactorial: import("typed-function").TypedFunction;
+    subfactorial: import("typed-function").TypedFunction;
+    prime: import("typed-function").TypedFunction;
+    nextPrime: import("typed-function").TypedFunction;
+    primePi: import("typed-function").TypedFunction;
+    primeFactors: import("typed-function").TypedFunction;
+    divisors: import("typed-function").TypedFunction;
+    eulerPhi: import("typed-function").TypedFunction;
+    divisorSigma: import("typed-function").TypedFunction;
+    carmichaelLambda: import("typed-function").TypedFunction;
+    moebiusMu: import("typed-function").TypedFunction;
+    jacobiSymbol: import("typed-function").TypedFunction;
+    chineseRemainder: import("typed-function").TypedFunction;
+    lucasL: import("typed-function").TypedFunction;
+    partitions: import("typed-function").TypedFunction;
+    harmonicNumber: import("typed-function").TypedFunction;
+    integerDigits: import("typed-function").TypedFunction;
+    fft: import("typed-function").TypedFunction;
+    ifft: import("typed-function").TypedFunction;
+    fftMagnitude: import("typed-function").TypedFunction;
+    fftPower: import("typed-function").TypedFunction;
+    conv: import("typed-function").TypedFunction;
+    xcorr: import("typed-function").TypedFunction;
+    autocorr: import("typed-function").TypedFunction;
+    crossCorrelation: typeof import("./signal.js").crossCorrelation;
+    autoCorrelation: typeof import("./signal.js").autoCorrelation;
+    groupDelay: typeof import("./signal.js").groupDelay;
+    unwrapPhase: typeof import("./signal.js").unwrapPhase;
+    dct: typeof import("./signal.js").dct;
+    idct: typeof import("./signal.js").idct;
+    dst: typeof import("./signal.js").dst;
+    idst: typeof import("./signal.js").idst;
+    dwt: typeof import("./signal.js").dwt;
+    fft2d: typeof import("./signal.js").fft2d;
+    fourier: typeof import("./signal.js").fourier;
+    invFourier: typeof import("./signal.js").invFourier;
+    hilbertTransform: typeof import("./signal.js").hilbertTransform;
+    spectrogram: typeof import("./signal.js").spectrogram;
+    periodogram: typeof import("./signal.js").periodogram;
+    lowpassFilter: typeof import("./signal.js").lowpassFilter;
+    highpassFilter: typeof import("./signal.js").highpassFilter;
+    bandpassFilter: typeof import("./signal.js").bandpassFilter;
+    resample: typeof import("./signal.js").resample;
+    medfilt: typeof import("./signal.js").medfilt;
+    windowFunction: typeof import("./signal.js").windowFunction;
+    convolve: typeof import("./signal.js").convolve;
+    correlate: typeof import("./signal.js").correlate;
+    welchPSD: typeof import("./signal.js").welchPSD;
+    bartlettPSD: typeof import("./signal.js").bartlettPSD;
+    multiTaperPSD: typeof import("./signal.js").multiTaperPSD;
+    goertzel: typeof import("./signal.js").goertzel;
+    chirpZTransform: typeof import("./signal.js").chirpZTransform;
+    applyWindow: typeof import("../wasm/signal/wasm-bridge.js").applyWindowDispatch;
+    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 import("./statistics.js").parallelStatPercentile;
+    histogram: import("typed-function").TypedFunction;
+    quickSelect: typeof import("./statistics.js").quickSelect;
+    medianSelect: typeof import("./statistics.js").medianSelect;
+    minSelect: typeof import("./statistics.js").minSelect;
+    maxSelect: typeof import("./statistics.js").maxSelect;
+    sin: import("typed-function").TypedFunction;
+    cos: import("typed-function").TypedFunction;
+    tan: import("typed-function").TypedFunction;
+    csc: import("typed-function").TypedFunction;
+    sec: import("typed-function").TypedFunction;
+    cot: import("typed-function").TypedFunction;
+    asin: import("typed-function").TypedFunction;
+    acos: import("typed-function").TypedFunction;
+    atan: import("typed-function").TypedFunction;
+    atan2: import("typed-function").TypedFunction;
+    acsc: import("typed-function").TypedFunction;
+    asec: import("typed-function").TypedFunction;
+    acot: import("typed-function").TypedFunction;
+    asinh: import("typed-function").TypedFunction;
+    acosh: import("typed-function").TypedFunction;
+    atanh: import("typed-function").TypedFunction;
+    toRadians: import("typed-function").TypedFunction;
+    toDegrees: import("typed-function").TypedFunction;
+    hypot: import("typed-function").TypedFunction;
+    add: import("typed-function").TypedFunction;
+    subtract: import("typed-function").TypedFunction;
+    multiply: import("typed-function").TypedFunction;
+    divide: import("typed-function").TypedFunction;
+    unaryMinus: import("typed-function").TypedFunction;
+    unaryPlus: import("typed-function").TypedFunction;
+    abs: import("typed-function").TypedFunction;
+    sign: import("typed-function").TypedFunction;
+    pow: import("typed-function").TypedFunction;
+    sqrt: import("typed-function").TypedFunction;
+    square: import("typed-function").TypedFunction;
+    cube: import("typed-function").TypedFunction;
+    cbrt: import("typed-function").TypedFunction;
+    nthRoot: import("typed-function").TypedFunction;
+    exp: import("typed-function").TypedFunction;
+    log: import("typed-function").TypedFunction;
+    log10: import("typed-function").TypedFunction;
+    log2: import("typed-function").TypedFunction;
+    log1p: import("typed-function").TypedFunction;
+    expm1: import("typed-function").TypedFunction;
+    round: import("typed-function").TypedFunction;
+    floor: import("typed-function").TypedFunction;
+    ceil: import("typed-function").TypedFunction;
+    fix: import("typed-function").TypedFunction;
+    mod: import("typed-function").TypedFunction;
+    gcd: import("typed-function").TypedFunction;
+    lcm: import("typed-function").TypedFunction;
+    xgcd: import("typed-function").TypedFunction;
+    sinh: import("typed-function").TypedFunction;
+    cosh: import("typed-function").TypedFunction;
+    tanh: import("typed-function").TypedFunction;
+    equal: import("typed-function").TypedFunction;
+    smaller: import("typed-function").TypedFunction;
+    larger: import("typed-function").TypedFunction;
+    smallerEq: import("typed-function").TypedFunction;
+    largerEq: import("typed-function").TypedFunction;
+    compare: import("typed-function").TypedFunction;
+    dot: import("typed-function").TypedFunction;
+    matmul: typeof import("./arithmetic.js").matmul;
+    transpose: typeof import("./arithmetic.js").transpose;
+    matvec: typeof import("./arithmetic.js").matvec;
+    outer: typeof import("./arithmetic.js").outer;
+    initializePool: typeof import("./arithmetic.js").initializePool;
+    terminatePool: typeof import("./arithmetic.js").terminatePool;
+    shouldParallelize: typeof import("./arithmetic.js").shouldParallelize;
+    getComputePool: typeof import("./arithmetic.js").getComputePool;
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/typed/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAOH,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGlD,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAGtD,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGlD,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG1C,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAK5C,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGpC,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,cAAc,oBAAoB,CAAC;AACnC,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAGxD,cAAc,eAAe,CAAC;AAG9B,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,cAAc,kBAAkB,CAAC;AAGjC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,cAAc,CAAC;AAG7B,cAAc,oBAAoB,CAAC;AAGnC,cAAc,YAAY,CAAC;AAG3B,cAAc,mBAAmB,CAAC;AAGlC,cAAc,iBAAiB,CAAC;AAWhC,cAAc,iBAAiB,CAAC;AAGhC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAGvC,cAAc,UAAU,CAAC;AAIzB,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGlD,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI1C,cAAc,kBAAkB,CAAC;AACjC,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAGpD,cAAc,WAAW,CAAC;AAC1B,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAsCtC;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8B1B,CAAC"}

package/dist/typed/integration.d.ts

@@ -0,0 +1,219 @@
+/**
+ * Numerical Integration Functions
+ *
+ * Provides numerical integration (quadrature) methods:
+ * - trapz: Trapezoidal rule
+ * - simpson: Simpson's 1/3 rule
+ * - gaussQuad: Gauss-Legendre quadrature (composite form for n ≥ 64 sub-intervals)
+ * - romberg: Romberg integration (adaptive Richardson extrapolation)
+ *
+ * Worker-dispatch strategy (Slice 3.8):
+ * - gaussQuad / romberg: function evaluation stays on the main thread; the
+ *   weighted dot-product reduction (values × weights) is offloaded via
+ *   `computePool.dot` when sub-interval count ≥ GAUSS_WORKER_THRESHOLD.
+ * - trapz / simpson accepting a Float64Array of pre-computed values: the
+ *   summation is offloaded via `computePool.sum` when length ≥
+ *   ARRAY_WORKER_THRESHOLD.
+ *
+ * Worker-dispatch strategy (Slice 5.10) — sub-interval fan-out:
+ * - gaussQuad / romberg accept an optional `workerCount` option (default 1).
+ *   When `workerCount > 1` and `totalPoints ≥ GAUSS_WORKER_THRESHOLD`, the
+ *   integration domain is partitioned into `workerCount` equal sub-domains and
+ *   one `integrateChunk` worker task is dispatched per sub-domain.  Each task
+ *   stringifies the integrand closure and evaluates it inside the worker.
+ *
+ * **Closure-stringification contract:**
+ * Only closures that are self-contained (no free variables referencing
+ * outer scope) survive worker dispatch.  The heuristic in
+ * `validateClosureSource` tokenizes the function source and rejects any
+ * identifier that is not:
+ *   - the declared parameter name(s),
+ *   - a `Math` property access (`Math.*`),
+ *   - a standard numeric literal keyword (`Infinity`, `NaN`), or
+ *   - a keyword / punctuation.
+ * Arrow functions (`x => x*x`, `(x) => x*x`) and classic function expressions
+ * (`function(x){ return x*x; }`) both stringify cleanly.
+ * Async closures are rejected unconditionally.
+ *
+ * These use plain exports (not mathTyped) because they accept function
+ * arguments, which typed-function does not handle well.
+ *
+ * @packageDocumentation
+ */
+/** Minimum sub-interval count before gaussQuad / romberg offload the reduction. */
+export declare const GAUSS_WORKER_THRESHOLD = 64;
+/** Minimum array length before trapzF64 / simpsonF64 offload the summation. */
+export declare const ARRAY_WORKER_THRESHOLD = 65536;
+/**
+ * Validate that a stringified function closure is safe to dispatch to a worker.
+ *
+ * The heuristic:
+ * 1. Rejects async closures outright (they cannot be reconstructed portably).
+ * 2. Extracts the parameter name(s) from the function source.
+ * 3. Tokenizes the body by extracting all bare identifiers (word characters
+ *    not preceded or followed by a dot — i.e. not `Math.sin` method parts).
+ * 4. Rejects any identifier that is not the parameter name, not in the
+ *    ALLOWED_GLOBALS set, and not a numeric literal.
+ *
+ * @param fnSource - Result of `f.toString()`
+ * @throws {Error} When the closure references outer-scope identifiers or is async
+ */
+export declare function validateClosureSource(fnSource: string): void;
+/**
+ * Numerical integration using the trapezoidal rule over a number array.
+ *
+ * @param y - Array of function values
+ * @param x - Optional array of x-coordinates (defaults to uniform spacing h=1)
+ * @returns Approximate integral
+ *
+ * @example
+ * trapz([1, 2, 3], [0, 1, 2]) // => 4
+ * trapz([0, 1, 0])             // => 1 (uniform spacing)
+ */
+export declare function trapz(y: number[], x?: number[]): number;
+/**
+ * Numerical integration using the trapezoidal rule over a Float64Array.
+ *
+ * For arrays with length ≥ ARRAY_WORKER_THRESHOLD the trapezoidal terms are
+ * computed element-wise on the main thread and the final summation is
+ * offloaded to the compute pool via `computePool.sum`.
+ *
+ * @param y  - Float64Array of function values (uniform spacing h=1 unless dx provided)
+ * @param dx - Optional uniform step size (default 1)
+ * @returns Promise resolving to the approximate integral
+ *
+ * @example
+ * await trapzF64(new Float64Array([0, 1, 0])) // => 1
+ */
+export declare function trapzF64(y: Float64Array, dx?: number): Promise<number>;
+/**
+ * Numerical integration using Simpson's 1/3 rule (function form).
+ *
+ * @param f - Function to integrate
+ * @param a - Lower bound
+ * @param b - Upper bound
+ * @param n - Number of subintervals (must be even, default 100)
+ * @returns Approximate integral
+ *
+ * @example
+ * simpson(x => x ** 2, 0, 1) // => ~0.3333
+ */
+export declare function simpson(f: (x: number) => number, a: number, b: number, n?: number): number;
+/**
+ * Numerical integration using Simpson's 1/3 rule over a pre-computed
+ * Float64Array of uniformly-spaced function values.
+ *
+ * For arrays with length ≥ ARRAY_WORKER_THRESHOLD the weighted terms are
+ * computed on the main thread and the summation is offloaded to the pool.
+ *
+ * @param y  - Float64Array of function values at uniform spacing
+ * @param dx - Uniform step size (default 1)
+ * @returns Promise resolving to the approximate integral
+ */
+export declare function simpsonF64(y: Float64Array, dx?: number): Promise<number>;
+/**
+ * Options for `gaussQuad` fan-out mode (Slice 5.10).
+ */
+export interface GaussQuadOptions {
+    /**
+     * Number of sub-domain worker tasks to spawn when `n ≥ GAUSS_WORKER_THRESHOLD`.
+     *
+     * - `1` (default): behaves exactly as Slice 3.8 — no sub-interval fan-out.
+     * - `> 1`: the domain `[a, b]` is partitioned into `workerCount` equal
+     *   sub-domains.  One `integrateChunk` worker task is dispatched per
+     *   sub-domain.  The closure `f` is stringified via `f.toString()` and
+     *   reconstructed inside each worker with `new Function`.
+     *
+     * **Closure constraint:** The integrand must be a self-contained expression
+     * (no references to outer-scope variables).  Use `Math.*` methods and
+     * arithmetic only.  Async closures are rejected.  See `validateClosureSource`.
+     *
+     * **Fall-back:** when `workerCount > 1` but `totalPoints < GAUSS_WORKER_THRESHOLD`
+     * or the pool is not ready, the function falls back to single-thread evaluation
+     * (worker overhead would dominate at small sizes).
+     */
+    workerCount?: number;
+}
+/**
+ * Numerical integration using Gauss-Legendre quadrature.
+ *
+ * When `n` is in [2, 5] the legacy single-interval mode is used (backward
+ * compatible): `n` is the number of GL quadrature points applied to [a, b].
+ *
+ * When `n` ≥ 64 the domain is split into `n` equal sub-intervals, each
+ * integrated with a fixed-order GL rule (default order 5).  Function
+ * evaluation stays on the main thread; the weighted dot-product reduction is
+ * offloaded to the compute pool when the pool is ready.
+ *
+ * **Sub-interval fan-out (Slice 5.10):** Pass `{ workerCount: k }` to
+ * partition the integration domain into `k` equal sub-domains and dispatch
+ * one worker task per sub-domain.  Requires `totalPoints ≥ GAUSS_WORKER_THRESHOLD`
+ * and the compute pool to be ready; otherwise falls back to single-thread.
+ * The integrand `f` must satisfy the closure-stringification contract — see
+ * `validateClosureSource` and the module-level JSDoc.
+ *
+ * @param f       - Function to integrate
+ * @param a       - Lower bound
+ * @param b       - Upper bound
+ * @param n       - Number of quadrature points (2–5) OR number of sub-intervals (≥ 6)
+ * @param order   - GL order to use per sub-interval when n ≥ 6 (default 5)
+ * @param options - Optional fan-out options `{ workerCount }`
+ * @returns Approximate integral (or Promise when n ≥ GAUSS_WORKER_THRESHOLD and pool is ready)
+ *
+ * @example
+ * gaussQuad(x => x ** 2, 0, 1, 3)                        // => ~0.3333  (3-point GL, single interval)
+ * await gaussQuad(Math.sin, 0, Math.PI, 64)               // => ~2.0     (composite, 64 sub-intervals)
+ * await gaussQuad(Math.sin, 0, Math.PI, 64, 5, { workerCount: 4 }) // => ~2.0 (fan-out, 4 workers)
+ */
+export declare function gaussQuad(f: (x: number) => number, a: number, b: number, n?: number, order?: number, options?: GaussQuadOptions): number | Promise<number>;
+/**
+ * Options for `romberg` fan-out mode (Slice 5.10).
+ */
+export interface RombergOptions {
+    /**
+     * Number of sub-domain worker tasks to spawn for the initial trapezoidal
+     * estimate when the evaluation count crosses `GAUSS_WORKER_THRESHOLD`.
+     *
+     * - `1` (default): behaves exactly as Slice 3.8 — no sub-interval fan-out.
+     * - `> 1`: the domain `[a, b]` is partitioned into `workerCount` equal
+     *   sub-domains for the initial estimate.  Each sub-domain is integrated
+     *   with a 5-point GL rule inside a worker.
+     *
+     * **Closure constraint:** Same as `GaussQuadOptions.workerCount` — see
+     * `validateClosureSource` for details.
+     *
+     * **Fall-back:** when `workerCount > 1` but the point count is below
+     * `GAUSS_WORKER_THRESHOLD` or the pool is not ready, the standard sequential
+     * path is used.
+     */
+    workerCount?: number;
+}
+/**
+ * Romberg integration using Richardson extrapolation on the trapezoidal rule.
+ *
+ * Adaptively refines the estimate until the desired tolerance is reached
+ * or the maximum number of iterations (20) is exceeded.
+ *
+ * When the intermediate trapezoidal sum at level `n` involves ≥
+ * GAUSS_WORKER_THRESHOLD new function evaluations the partial sum is
+ * offloaded to the compute pool.  Because each level n evaluates 2^(n-1)
+ * *new* points, the pool is engaged once n ≥ log2(GAUSS_WORKER_THRESHOLD),
+ * i.e. from level 7 onward (128 new points per level).
+ *
+ * **Sub-interval fan-out (Slice 5.10):** Pass `{ workerCount: k }` to fan out
+ * the initial trapezoidal sub-domain evaluations to `k` workers.  The closure
+ * `f` must satisfy the stringification contract — see `validateClosureSource`.
+ *
+ * @param f       - Function to integrate
+ * @param a       - Lower bound
+ * @param b       - Upper bound
+ * @param tol     - Desired absolute tolerance (default 1e-12)
+ * @param options - Optional fan-out options `{ workerCount }`
+ * @returns Promise resolving to the approximate integral
+ *
+ * @example
+ * await romberg(Math.sin, 0, Math.PI)                          // => ~2.0
+ * await romberg(Math.sin, 0, Math.PI, 1e-12, { workerCount: 4 }) // fan-out, 4 workers
+ */
+export declare function romberg(f: (x: number) => number, a: number, b: number, tol?: number, options?: RombergOptions): Promise<number>;
+//# sourceMappingURL=integration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"integration.d.ts","sourceRoot":"","sources":["../../src/typed/integration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAQH,mFAAmF;AACnF,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC,+EAA+E;AAC/E,eAAO,MAAM,sBAAsB,QAAS,CAAC;AAwG7C;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAuC5D;AA2BD;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAqBvD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,YAAY,EAAE,EAAE,SAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAwBvE;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,GAAE,MAAY,GAAG,MAAM,CAa/F;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,UAAU,CAAC,CAAC,EAAE,YAAY,EAAE,EAAE,SAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAwBzE;AAuBD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;;;;;;;;;;;;OAgBG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,SAAS,CACvB,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EACxB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,GAAE,MAAU,EACb,KAAK,GAAE,MAAU,EACjB,OAAO,GAAE,gBAAqB,GAC7B,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAmE1B;AAMD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;;;;;;;;;;;OAeG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,OAAO,CAC3B,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EACxB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,GAAG,GAAE,MAAc,EACnB,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,MAAM,CAAC,CA0EjB"}