@danielsimonjr/mathts-parallel 0.6.4 → 0.6.5

package/dist/ComputePool.d.ts

@@ -0,0 +1,548 @@
+/**
+ * MathTS Compute Pool
+ *
+ * High-level wrapper around @danielsimonjr/mathts-workerpool for parallel computation in MathTS.
+ * Provides automatic parallelization of matrix operations based on data size.
+ *
+ * @packageDocumentation
+ */
+import { MathWorkerPool, Transfer, type TaskOptions, type PoolStats } from '@danielsimonjr/mathts-workerpool';
+/**
+ * Recognised kernel / operation names.
+ *
+ * These are the string identifiers passed to `shouldParallelize(length, op)` so
+ * the per-op threshold map can be consulted before falling back to the global
+ * `thresholdElements`.  The list covers:
+ *   - Element-wise float ops dispatched through `ComputePool.unary/elementwise/scale`
+ *   - Reduction ops (`sum`, `mean`, `variance`, etc.)
+ *   - Linear-algebra ops (`matmul`, `matrixPower`, `characteristicPolynomial`)
+ *   - Signal-processing ops (`parallelFFT`, `parallelConv`, `spectrogram`, `fft2d`)
+ *   - Geometry ops (`distanceMatrix`)
+ *   - Special / distribution functions (`erfc`, `besselJ`, `normalCDF`)
+ *   - Additional ops exposed via the typed functions layer
+ */
+export type OpName = 'add' | 'subtract' | 'multiply' | 'divide' | 'pow' | 'scale' | 'abs' | 'negate' | 'sqrt' | 'square' | 'bitAnd' | 'bitOr' | 'bitXor' | 'bitNot' | 'leftShift' | 'rightArithShift' | 'rightLogShift' | 'exp' | 'log' | 'sin' | 'cos' | 'tan' | 'sign' | 'tensordot' | 'sum' | 'mean' | 'min' | 'max' | 'minMax' | 'variance' | 'std' | 'norm' | 'histogram' | 'dot' | 'prod' | 'distance' | 'parallelStatProd' | 'matmul' | 'outer' | 'matvec' | 'transpose' | 'matrixPower' | 'characteristicPolynomial' | 'parallelFFT' | 'parallelConv' | 'spectrogram' | 'fft2d' | 'distanceMatrix' | 'erfc' | 'besselJ' | 'normalCDF' | 'chiSquareTest' | 'kolmogorovSmirnovTest' | 'mannWhitneyTest' | 'shapiroWilkTest' | 'integrateChunk' | 'sampleChunk';
+/**
+ * Per-op threshold override.  The value is the minimum element count required
+ * before parallelizing the named operation.  Special string aliases:
+ *
+ *  - `'never'`  → `Number.MAX_SAFE_INTEGER` (never parallelize)
+ *  - `'always'` → `0`                       (always parallelize when pool is ready)
+ */
+export type OpThreshold = number | 'never' | 'always';
+/**
+ * Resolve an `OpThreshold` alias to its numeric equivalent.
+ * @internal
+ */
+export declare function resolveOpThreshold(t: OpThreshold): number;
+/**
+ * Configuration for ComputePool
+ * Extends the base WorkerPoolConfig with MathTS-specific options
+ */
+export interface ComputePoolConfig {
+    /** Enable parallel processing */
+    enabled: boolean;
+    /** Minimum number of workers to maintain */
+    minWorkers: number;
+    /** Maximum number of workers */
+    maxWorkers: number;
+    /**
+     * Global minimum element count before parallelizing.
+     * Acts as the fallback for ops not listed in `thresholdByOp`.
+     */
+    thresholdElements: number;
+    /**
+     * Per-operation parallelization thresholds.
+     *
+     * Values measured on a noisy CI container (2026-05-23) — re-run on target
+     * hardware to retune.  Source: tools/benchmark/parallel/run.ts
+     *
+     * Ops absent from this map fall back to `thresholdElements`.
+     */
+    thresholdByOp?: Partial<Record<OpName, OpThreshold>>;
+    /** Elements per chunk for parallel operations */
+    chunkSize: number;
+    /** Worker type: 'auto' | 'web' | 'thread' */
+    workerType: 'auto' | 'web' | 'thread';
+    /** Worker idle timeout in milliseconds */
+    workerIdleTimeout: number;
+    /** Default task timeout in milliseconds */
+    taskTimeout: number;
+}
+/**
+ * Default per-op thresholds derived from benchmark data (tools/benchmark/parallel/run.ts,
+ * 2026-05-23).  Values measured on a noisy CI container — re-run on target hardware to retune.
+ *
+ *  'never'  → Number.MAX_SAFE_INTEGER  (benchmark showed no reliable speedup)
+ *  'always' → 0                        (always parallelize when pool is ready)
+ *  number   → minimum element count before dispatching to workers
+ */
+/**
+ * Canonical, benchmark-tuned per-op parallelization thresholds. This is the
+ * single source of truth consulted by `ComputePool.shouldParallelize` — the
+ * authority the typed functions actually dispatch through. The coarser
+ * category-level {@link ThresholdDispatcher} derives its overlapping values
+ * (e.g. matmul) from here so the two cannot silently diverge.
+ */
+export declare const DEFAULT_THRESHOLD_BY_OP: Partial<Record<OpName, OpThreshold>>;
+/**
+ * Default ComputePool configuration
+ */
+export declare const DEFAULT_POOL_CONFIG: ComputePoolConfig;
+/**
+ * Result of a parallel operation
+ */
+export interface ParallelResult<T> {
+    /** The computed result */
+    result: T;
+    /** Time taken in milliseconds */
+    duration: number;
+    /** Number of chunks processed */
+    chunks: number;
+    /** Whether parallelization was used */
+    parallelized: boolean;
+}
+/**
+ * Pure-JS tensordot computation over a contiguous range of output elements
+ * `[outStart, outEnd)`.
+ *
+ * This is the shared inner kernel used by both the sequential fallback path in
+ * `ComputePool.tensordot` and the worker-dispatched `tensordotChunk` handler.
+ * By exporting it and registering it in the worker, we keep the algorithm in
+ * one place and avoid divergence.
+ *
+ * Contracts axis `axesA[i]` of `a` (shape `aShape`) with axis `axesB[i]` of
+ * `b` (shape `bShape`). The result layout is free-A axes first, then free-B
+ * axes (NumPy convention).
+ */
+export declare function tensordotChunkKernel(a: Float64Array, aShape: readonly number[], b: Float64Array, bShape: readonly number[], axesA: readonly number[], axesB: readonly number[], resultShape: readonly number[], outStart: number, outEnd: number): Float64Array;
+/**
+ * ComputePool for parallel MathTS operations
+ *
+ * Wraps the @danielsimonjr/mathts-workerpool MathWorkerPool with a MathTS-specific API.
+ *
+ * @example
+ * ```typescript
+ * import { ComputePool } from '@danielsimonjr/mathts-parallel';
+ *
+ * const pool = new ComputePool({ maxWorkers: 8 });
+ * await pool.initialize();
+ *
+ * // Parallel matrix multiplication
+ * const result = await pool.matmul(matrixA, aRows, aCols, matrixB, bCols);
+ *
+ * // Parallel element-wise operation
+ * const sum = await pool.elementwise(a, b, 'add');
+ *
+ * // Cleanup
+ * await pool.terminate();
+ * ```
+ */
+export declare class ComputePool {
+    private workerPool;
+    private config;
+    constructor(config?: Partial<ComputePoolConfig>);
+    /**
+     * Initialize the worker pool
+     */
+    initialize(): Promise<void>;
+    /**
+     * Check if pool is ready
+     */
+    isReady(): boolean;
+    /**
+     * Determine if operation should be parallelized.
+     *
+     * When `op` is supplied the per-op threshold map is consulted first;
+     * if the op is absent from the map the global `thresholdElements` fallback
+     * is used.  When `op` is omitted the global threshold is always used (for
+     * backward-compatibility with existing callers that don't know the op name).
+     */
+    shouldParallelize(elementCount: number, op?: OpName): boolean;
+    /**
+     * Wrap a sequentially-computed reduction result in the `ParallelResult`
+     * envelope. Used by the reduction methods below so that ops whose threshold
+     * says "don't parallelize at this size" (notably the memory-bound reductions
+     * pinned to `'never'`) compute inline instead of paying a worker round-trip —
+     * previously every reduction dispatched to the pool unconditionally, ignoring
+     * its threshold.
+     */
+    private seqResult;
+    /**
+     * Execute a method in the worker pool
+     */
+    exec<T>(method: string, params: unknown[], options?: TaskOptions): Promise<T>;
+    /**
+     * Get pool statistics
+     */
+    stats(): PoolStats;
+    /**
+     * Parallel sum of array elements
+     */
+    sum(data: Float64Array): Promise<ParallelResult<number>>;
+    /**
+     * Parallel product of array elements
+     */
+    prod(data: Float64Array): Promise<ParallelResult<number>>;
+    /**
+     * Parallel dot product
+     */
+    dot(a: Float64Array, b: Float64Array): Promise<ParallelResult<number>>;
+    /**
+     * Parallel element-wise operation
+     */
+    elementwise(a: Float64Array, b: Float64Array, op: 'add' | 'subtract' | 'multiply' | 'divide'): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Parallel scale operation
+     */
+    scale(data: Float64Array, scalar: number): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Parallel matrix multiplication
+     *
+     * @param a - First matrix as flat Float64Array (row-major)
+     * @param aRows - Number of rows in A
+     * @param aCols - Number of columns in A
+     * @param b - Second matrix as flat Float64Array (row-major)
+     * @param bCols - Number of columns in B
+     */
+    matmul(a: Float64Array, aRows: number, aCols: number, b: Float64Array, bCols: number): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Parallel matrix transpose
+     */
+    transpose(data: Float64Array, rows: number, cols: number): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Parallel map operation
+     */
+    map<T, R>(data: T[], fn: (item: T) => R): Promise<ParallelResult<R[]>>;
+    /**
+     * Parallel reduce operation
+     */
+    reduce<T, R>(data: T[], fn: (acc: R, item: T) => R, initial: R): Promise<ParallelResult<R>>;
+    /**
+     * Parallel filter operation
+     */
+    filter<T>(data: T[], predicate: (item: T) => boolean): Promise<ParallelResult<T[]>>;
+    /**
+     * Find min and max values in parallel
+     */
+    minMax(data: Float64Array): Promise<ParallelResult<{
+        min: number;
+        max: number;
+        minIdx: number;
+        maxIdx: number;
+    }>>;
+    /**
+     * Compute variance, mean, and standard deviation in parallel
+     */
+    variance(data: Float64Array): Promise<ParallelResult<{
+        mean: number;
+        variance: number;
+        std: number;
+    }>>;
+    /**
+     * Compute norm (Euclidean length) in parallel
+     */
+    norm(data: Float64Array): Promise<ParallelResult<number>>;
+    /**
+     * Compute Euclidean distance in parallel
+     */
+    distance(a: Float64Array, b: Float64Array): Promise<ParallelResult<number>>;
+    /**
+     * Compute histogram in parallel
+     */
+    histogram(data: Float64Array, bins: number, min?: number, max?: number): Promise<ParallelResult<number[]>>;
+    /**
+     * Apply unary function in parallel
+     */
+    unary(data: Float64Array, fn: 'abs' | 'sqrt' | 'exp' | 'log' | 'sin' | 'cos' | 'tan' | 'negate' | 'square'): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Apply a caller-supplied unary numeric function in parallel.
+     *
+     * @param data - Input values
+     * @param fnSource - Source of a self-contained `(x: number) => number`
+     *   expression. It must not reference free variables / closures, since it
+     *   is eval'd in an isolated worker context. Used to parallelize element-wise
+     *   math (special functions, distribution PDFs/CDFs).
+     */
+    applyKernel(data: Float64Array, fnSource: string): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Apply a caller-supplied binary numeric function in parallel.
+     *
+     * @param a - First operand array
+     * @param b - Second operand array (must match the length of `a`)
+     * @param fnSource - Source of a self-contained `(a: number, b: number) =>
+     *   number` expression (no free variables / closures).
+     */
+    applyKernel2(a: Float64Array, b: Float64Array, fnSource: string): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Fan-out Gauss-Legendre quadrature over `workerCount` sub-intervals.
+     *
+     * Partitions `[a, b]` into `workerCount` equal sub-domains and dispatches one
+     * `integrateChunk` worker task per sub-domain.  Each task evaluates the
+     * integrand (supplied as a stringified closure) with the given GL nodes and
+     * weights and returns its partial integral.  The partial sums are aggregated
+     * on the main thread.
+     *
+     * **Closure contract:** `fnSource` must be a self-contained `(x: number) =>
+     * number` expression — no free variables referencing outer scope, because it
+     * is eval'd inside an isolated worker context.  Call-site validation (via
+     * `validateClosureSource`) should have already rejected unsafe closures before
+     * reaching this method.
+     *
+     * @param fnSource    - Stringified integrand, e.g. `"(x) => Math.sin(x)"`
+     * @param a           - Lower integration bound
+     * @param b           - Upper integration bound
+     * @param workerCount - Number of sub-intervals / worker tasks
+     * @param nodes       - GL nodes on [-1, 1]
+     * @param weights     - Corresponding GL weights
+     * @returns Sum of partial integrals = approximate value of ∫ₐᵇ f(x) dx
+     */
+    integrateFanOut(fnSource: string, a: number, b: number, workerCount: number, nodes: number[], weights: number[]): Promise<number>;
+    /**
+     * Fan-out distribution batch sampling across `workerCount` workers.
+     *
+     * Partitions `n` samples into `workerCount` equal chunks (last chunk absorbs
+     * the remainder) and dispatches one `sampleChunk` task per chunk. Each chunk
+     * uses an independent seed derived from `baseSeed` via SplitMix64-style
+     * hashing:
+     *
+     *   `chunkSeed = (baseSeed ^ (chunkIdx * 0x9E3779B97F4A7C15)) >>> 0`
+     *
+     * This Fibonacci-hashing multiplier gives good avalanche: even baseSeed=0
+     * produces K distinct seeds, and adjacent chunk indices produce uncorrelated
+     * sequences. See the `sampleChunk` worker kernel for the full rationale.
+     *
+     * @param distName    - One of 'normal', 'gamma', 'beta', 'studentT', 'exponential'
+     * @param params      - Distribution parameters (order matches factory functions)
+     * @param n           - Total number of samples to generate
+     * @param baseSeed    - Base seed for reproducible output
+     * @param workerCount - Number of parallel worker tasks
+     * @returns Concatenated Float64Array of `n` samples
+     */
+    distributionSampleFanOut(distName: string, params: number[], n: number, baseSeed: number, workerCount: number): Promise<Float64Array>;
+    /**
+     * Compute a batch of independent radix-2 FFTs in parallel.
+     *
+     * `real` and `imag` each hold `frameCount` concatenated frames of
+     * `frameLength` samples (`frameLength` must be a power of two). Each frame
+     * is FFT'd independently and the frames are distributed across workers.
+     *
+     * Used to parallelize the embarrassingly-parallel FFT batches in
+     * `spectrogram` (one FFT per windowed frame) and `fft2d` (rows then columns).
+     *
+     * @param real - Concatenated real parts (`frameCount * frameLength` values)
+     * @param imag - Concatenated imaginary parts (same layout as `real`)
+     * @param frameCount - Number of independent frames
+     * @param frameLength - Samples per frame (power of two)
+     * @param inverse - Compute the inverse FFT when true
+     */
+    fftBatch(real: Float64Array, imag: Float64Array, frameCount: number, frameLength: number, inverse?: boolean): Promise<ParallelResult<{
+        real: Float64Array;
+        imag: Float64Array;
+    }>>;
+    /**
+     * Compute an all-pairs Euclidean distance matrix in parallel.
+     *
+     * @param points - Flattened `n * dim` coordinate array (row-major)
+     * @param n - Number of points
+     * @param dim - Coordinate dimension
+     * @returns Flat row-major `n * n` distance matrix
+     */
+    distanceMatrix(points: Float64Array, n: number, dim: number): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Parallel absolute value
+     */
+    abs(data: Float64Array): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Parallel square root
+     */
+    sqrt(data: Float64Array): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Parallel exponential
+     */
+    exp(data: Float64Array): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Parallel natural log
+     */
+    log(data: Float64Array): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Parallel sine
+     */
+    sin(data: Float64Array): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Parallel cosine
+     */
+    cos(data: Float64Array): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Parallel tangent
+     */
+    tan(data: Float64Array): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Parallel negation
+     */
+    negate(data: Float64Array): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Parallel square
+     */
+    square(data: Float64Array): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Parallel matrix-vector multiplication
+     */
+    matvec(matrix: Float64Array, rows: number, cols: number, vector: Float64Array): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Parallel outer product
+     */
+    outer(a: Float64Array, b: Float64Array): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Parallel find operation
+     */
+    find<T>(data: T[], predicate: (item: T) => boolean): Promise<ParallelResult<{
+        found: boolean;
+        value?: T;
+        index?: number;
+    }>>;
+    /**
+     * Parallel sort operation
+     */
+    sort<T>(data: T[], compare?: (a: T, b: T) => number): Promise<ParallelResult<T[]>>;
+    /**
+     * Parallel addition of two arrays
+     */
+    add(a: Float64Array, b: Float64Array): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Parallel subtraction of two arrays
+     */
+    subtract(a: Float64Array, b: Float64Array): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Parallel element-wise multiplication
+     */
+    multiply(a: Float64Array, b: Float64Array): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Parallel element-wise division
+     */
+    divide(a: Float64Array, b: Float64Array): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Parallel element-wise exponentiation.
+     *
+     * `out[i] = a[i] ** b[i]`
+     *
+     * Delegates to `applyKernel2` with the `Math.pow` kernel. The default
+     * per-op threshold for `pow` is `'never'` (overhead dominates); the
+     * sequential path is taken unless the caller overrides `thresholdByOp.pow`.
+     */
+    pow(a: Float64Array, b: Float64Array): Promise<ParallelResult<Float64Array>>;
+    /**
+     * Parallel element-wise sign function.
+     *
+     * `out[i] = Math.sign(data[i])`  →  -1 | 0 | 1, with NaN → NaN (IEEE 754).
+     *
+     * Delegates to `applyKernel` with the `Math.sign` kernel. The default
+     * per-op threshold for `sign` is `'never'` (overhead dominates); the
+     * sequential path is taken unless the caller overrides `thresholdByOp.sign`.
+     */
+    sign(data: Float64Array): Promise<ParallelResult<Float64Array>>;
+    /**
+     * General tensor contraction (tensordot) over specified axis pairs.
+     *
+     * Contracts axis `axesA[i]` of `a` with axis `axesB[i]` of `b` for each
+     * pair index `i`. The result shape is the non-contracted axes of `a` followed
+     * by the non-contracted axes of `b` (NumPy convention).
+     *
+     * Parallelization threshold: contracted-axis volume (product of contracted
+     * dimensions) >= 8 192. When parallelized, output elements are distributed
+     * in contiguous slices across workers via the `tensordotChunk` kernel.
+     *
+     * @param a      - Flat row-major Float64Array for tensor A
+     * @param aShape - Shape of tensor A
+     * @param b      - Flat row-major Float64Array for tensor B
+     * @param bShape - Shape of tensor B
+     * @param axesA  - Axes of A to contract (same length as axesB)
+     * @param axesB  - Axes of B to contract (same length as axesA)
+     * @returns `{ data: Float64Array; shape: number[] }` — flat result + result shape
+     */
+    tensordot(a: Float64Array, aShape: readonly number[], b: Float64Array, bShape: readonly number[], axesA: readonly number[], axesB: readonly number[]): Promise<ParallelResult<{
+        data: Float64Array;
+        shape: number[];
+    }>>;
+    /**
+     * Compute mean in parallel (uses variance internally)
+     */
+    mean(data: Float64Array): Promise<ParallelResult<number>>;
+    /**
+     * Compute standard deviation in parallel
+     */
+    std(data: Float64Array): Promise<ParallelResult<number>>;
+    /**
+     * Find minimum value in parallel
+     */
+    min(data: Float64Array): Promise<ParallelResult<number>>;
+    /**
+     * Find maximum value in parallel
+     */
+    max(data: Float64Array): Promise<ParallelResult<number>>;
+    /**
+     * Element-wise bitwise AND on two `Int32Array`s.
+     */
+    bitAnd(a: Int32Array, b: Int32Array): Promise<ParallelResult<Int32Array>>;
+    /**
+     * Element-wise bitwise OR on two `Int32Array`s.
+     */
+    bitOr(a: Int32Array, b: Int32Array): Promise<ParallelResult<Int32Array>>;
+    /**
+     * Element-wise bitwise XOR on two `Int32Array`s.
+     */
+    bitXor(a: Int32Array, b: Int32Array): Promise<ParallelResult<Int32Array>>;
+    /**
+     * Unary bitwise NOT on an `Int32Array`.
+     */
+    bitNot(a: Int32Array): Promise<ParallelResult<Int32Array>>;
+    /**
+     * Element-wise left shift. `b` may be a per-element `Int32Array` of
+     * shift counts or a single scalar `number` applied uniformly.
+     */
+    leftShift(a: Int32Array, b: Int32Array | number): Promise<ParallelResult<Int32Array>>;
+    /**
+     * Element-wise arithmetic (sign-preserving) right shift.
+     */
+    rightArithShift(a: Int32Array, b: Int32Array | number): Promise<ParallelResult<Int32Array>>;
+    /**
+     * Element-wise logical (zero-filling) right shift. Results are stored
+     * as `Int32Array`, so values ≥ 2^31 wrap into the negative range —
+     * matching `(x >>> n) | 0` JavaScript semantics.
+     */
+    rightLogShift(a: Int32Array, b: Int32Array | number): Promise<ParallelResult<Int32Array>>;
+    /**
+     * Terminate the worker pool
+     */
+    terminate(force?: boolean): Promise<void>;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<ComputePoolConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): ComputePoolConfig;
+    /**
+     * Maximum number of workers configured for this pool.
+     * Used by distribution sampling fan-out to determine chunk count.
+     */
+    get workerCount(): number;
+    /**
+     * Get the underlying MathWorkerPool for advanced operations
+     */
+    getWorkerPool(): MathWorkerPool;
+}
+/**
+ * Global compute pool instance
+ */
+export declare const computePool: ComputePool;
+/**
+ * Create a Transferable wrapper for zero-copy data transfer
+ */
+export { Transfer };
+/**
+ * Re-export types from @danielsimonjr/mathts-workerpool
+ */
+export type { TaskOptions, PoolStats };
+//# sourceMappingURL=ComputePool.d.ts.map

package/dist/ComputePool.d.ts.map

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