@danielsimonjr/mathts-parallel 0.6.4 → 0.6.6

package/dist/index.d.ts

@@ -1,1286 +1,18 @@
-import { TaskOptions, PoolStats, MathWorkerPool } from '@danielsimonjr/mathts-workerpool';
-export { ExecOptions, PoolOptions, PoolStats, Transfer } from '@danielsimonjr/mathts-workerpool';
-
 /**
- * MathTS Compute Pool
+ * @danielsimonjr/mathts-parallel
  *
- * High-level wrapper around @danielsimonjr/mathts-workerpool for parallel computation in MathTS.
- * Provides automatic parallelization of matrix operations based on data size.
+ * WebWorker parallelization for MathTS computations.
+ * Provides automatic parallelization based on data size thresholds.
  *
  * @packageDocumentation
  */
-
-/**
- * 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
- */
-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)
- */
-type OpThreshold = number | 'never' | 'always';
-/**
- * Resolve an `OpThreshold` alias to its numeric equivalent.
- * @internal
- */
-declare function resolveOpThreshold(t: OpThreshold): number;
-/**
- * Configuration for ComputePool
- * Extends the base WorkerPoolConfig with MathTS-specific options
- */
-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.
- */
-declare const DEFAULT_THRESHOLD_BY_OP: Partial<Record<OpName, OpThreshold>>;
-/**
- * Default ComputePool configuration
- */
-declare const DEFAULT_POOL_CONFIG: ComputePoolConfig;
-/**
- * Result of a parallel operation
- */
-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;
-}
-/**
- * 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();
- * ```
- */
-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
- */
-declare const computePool: ComputePool;
-
-/**
- * Parallel Matrix Multiplication
- *
- * High-performance parallel matrix multiplication with automatic chunking.
- * Distributes rows across workers for parallel computation.
- *
- * @packageDocumentation
- */
-
-/**
- * Options for parallel matrix multiplication
- */
-interface MatmulOptions {
-    /** Custom pool to use (defaults to global computePool) */
-    pool?: ComputePool;
-    /** Force parallel execution regardless of threshold */
-    forceParallel?: boolean;
-    /** Force sequential execution regardless of threshold */
-    forceSequential?: boolean;
-}
-/**
- * Parallel matrix multiplication (C = A × B)
- *
- * Multiplies two matrices using parallel workers. The computation
- * distributes rows of matrix A across available workers.
- *
- * @param a - First matrix as flat Float64Array (row-major order)
- * @param aRows - Number of rows in matrix A
- * @param aCols - Number of columns in matrix A (must equal bRows)
- * @param b - Second matrix as flat Float64Array (row-major order)
- * @param bCols - Number of columns in matrix B
- * @param options - Optional configuration
- * @returns Result matrix C (aRows × bCols) with parallel execution metadata
- *
- * @example
- * ```typescript
- * // 2x3 matrix * 3x2 matrix = 2x2 matrix
- * const A = new Float64Array([1, 2, 3, 4, 5, 6]);
- * const B = new Float64Array([7, 8, 9, 10, 11, 12]);
- *
- * const result = await parallelMatmul(A, 2, 3, B, 2);
- * console.log(result.result); // 2x2 result matrix
- * console.log(result.parallelized); // true if workers were used
- * ```
- */
-declare function parallelMatmul(a: Float64Array, aRows: number, aCols: number, b: Float64Array, bCols: number, options?: MatmulOptions): Promise<ParallelResult<Float64Array>>;
-/**
- * Parallel matrix-vector multiplication (y = A × x)
- *
- * Multiplies a matrix by a vector using parallel workers.
- *
- * @param matrix - Matrix as flat Float64Array (row-major order)
- * @param rows - Number of rows in the matrix
- * @param cols - Number of columns in the matrix (must equal vector length)
- * @param vector - Vector as Float64Array
- * @param options - Optional configuration
- * @returns Result vector with parallel execution metadata
- */
-declare function parallelMatvec(matrix: Float64Array, rows: number, cols: number, vector: Float64Array, options?: MatmulOptions): Promise<ParallelResult<Float64Array>>;
-/**
- * Parallel matrix transpose
- *
- * Transposes a matrix using parallel workers.
- *
- * @param data - Matrix as flat Float64Array (row-major order)
- * @param rows - Number of rows in the original matrix
- * @param cols - Number of columns in the original matrix
- * @param options - Optional configuration
- * @returns Transposed matrix (cols × rows) with parallel execution metadata
- */
-declare function parallelTranspose(data: Float64Array, rows: number, cols: number, options?: MatmulOptions): Promise<ParallelResult<Float64Array>>;
-/**
- * Parallel outer product (C = a ⊗ b)
- *
- * Computes the outer product of two vectors.
- *
- * @param a - First vector
- * @param b - Second vector
- * @param options - Optional configuration
- * @returns Outer product matrix (a.length × b.length)
- */
-declare function parallelOuter(a: Float64Array, b: Float64Array, options?: MatmulOptions): Promise<ParallelResult<Float64Array>>;
-/**
- * Parallel dot product (scalar = a · b)
- *
- * Computes the dot product of two vectors.
- *
- * @param a - First vector
- * @param b - Second vector (must have same length as a)
- * @param options - Optional configuration
- * @returns Dot product scalar
- */
-declare function parallelDot(a: Float64Array, b: Float64Array, options?: MatmulOptions): Promise<ParallelResult<number>>;
-
-/**
- * Parallel Element-wise Operations
- *
- * High-performance parallel element-wise operations on arrays.
- * Automatically chunks data for distribution across workers.
- *
- * @packageDocumentation
- */
-
-/**
- * Options for parallel element-wise operations
- */
-interface ElementwiseOptions {
-    /** Custom pool to use (defaults to global computePool) */
-    pool?: ComputePool;
-    /** Force parallel execution regardless of threshold */
-    forceParallel?: boolean;
-    /** Force sequential execution regardless of threshold */
-    forceSequential?: boolean;
-}
-/**
- * Parallel element-wise addition (c[i] = a[i] + b[i])
- */
-declare function parallelAdd(a: Float64Array, b: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
-/**
- * Parallel element-wise subtraction (c[i] = a[i] - b[i])
- */
-declare function parallelSubtract(a: Float64Array, b: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
-/**
- * Parallel element-wise multiplication (c[i] = a[i] * b[i])
- */
-declare function parallelMultiply(a: Float64Array, b: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
-/**
- * Parallel element-wise division (c[i] = a[i] / b[i])
- */
-declare function parallelDivide(a: Float64Array, b: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
-/**
- * Parallel scalar multiplication (b[i] = a[i] * scalar)
- */
-declare function parallelScale(data: Float64Array, scalar: number, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
-/**
- * Parallel absolute value (b[i] = |a[i]|)
- */
-declare function parallelAbs(data: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
-/**
- * Parallel negation (b[i] = -a[i])
- */
-declare function parallelNegate(data: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
-/**
- * Parallel square (b[i] = a[i]²)
- */
-declare function parallelSquare(data: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
-/**
- * Parallel square root (b[i] = √a[i])
- */
-declare function parallelSqrt(data: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
-/**
- * Parallel exponential (b[i] = e^a[i])
- */
-declare function parallelExp(data: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
-/**
- * Parallel natural logarithm (b[i] = ln(a[i]))
- */
-declare function parallelLog(data: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
-/**
- * Parallel sine (b[i] = sin(a[i]))
- */
-declare function parallelSin(data: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
-/**
- * Parallel cosine (b[i] = cos(a[i]))
- */
-declare function parallelCos(data: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
-/**
- * Parallel tangent (b[i] = tan(a[i]))
- */
-declare function parallelTan(data: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
-/**
- * Generic parallel element-wise operation
- */
-declare function parallelElementwise(a: Float64Array, b: Float64Array, op: 'add' | 'subtract' | 'multiply' | 'divide', options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
-/**
- * Generic parallel unary operation
- */
-declare function parallelUnary(data: Float64Array, fn: 'abs' | 'sqrt' | 'exp' | 'log' | 'sin' | 'cos' | 'tan' | 'negate' | 'square', options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
-
-/**
- * Parallel Reduction Operations
- *
- * High-performance parallel reduction operations (sum, min, max, etc.).
- * Uses parallel aggregation with sequential final reduction.
- *
- * @packageDocumentation
- */
-
-/**
- * Options for parallel reduction operations
- */
-interface ReduceOptions {
-    /** Custom pool to use (defaults to global computePool) */
-    pool?: ComputePool;
-    /** Force parallel execution regardless of threshold */
-    forceParallel?: boolean;
-    /** Force sequential execution regardless of threshold */
-    forceSequential?: boolean;
-}
-/**
- * Parallel sum reduction
- *
- * Computes the sum of all elements using parallel partial sums.
- *
- * @param data - Array to sum
- * @param options - Optional configuration
- * @returns Sum of all elements
- */
-declare function parallelSum(data: Float64Array, options?: ReduceOptions): Promise<ParallelResult<number>>;
-/**
- * Parallel mean computation
- *
- * @param data - Array to compute mean of
- * @param options - Optional configuration
- * @returns Mean value
- */
-declare function parallelMean(data: Float64Array, options?: ReduceOptions): Promise<ParallelResult<number>>;
-/**
- * Parallel minimum value
- *
- * @param data - Array to find minimum of
- * @param options - Optional configuration
- * @returns Minimum value
- */
-declare function parallelMin(data: Float64Array, options?: ReduceOptions): Promise<ParallelResult<number>>;
-/**
- * Parallel maximum value
- *
- * @param data - Array to find maximum of
- * @param options - Optional configuration
- * @returns Maximum value
- */
-declare function parallelMax(data: Float64Array, options?: ReduceOptions): Promise<ParallelResult<number>>;
-/**
- * Parallel min/max with indices
- *
- * @param data - Array to analyze
- * @param options - Optional configuration
- * @returns Object with min, max, minIdx, maxIdx
- */
-declare function parallelMinMax(data: Float64Array, options?: ReduceOptions): Promise<ParallelResult<{
-    min: number;
-    max: number;
-    minIdx: number;
-    maxIdx: number;
-}>>;
-/**
- * Parallel variance computation
- *
- * Uses Welford's algorithm for numerically stable variance calculation.
- *
- * @param data - Array to compute variance of
- * @param options - Optional configuration
- * @returns Object with mean, variance, and std (standard deviation)
- */
-declare function parallelVariance(data: Float64Array, options?: ReduceOptions): Promise<ParallelResult<{
-    mean: number;
-    variance: number;
-    std: number;
-}>>;
-/**
- * Parallel standard deviation
- *
- * @param data - Array to compute std of
- * @param options - Optional configuration
- * @returns Standard deviation
- */
-declare function parallelStd(data: Float64Array, options?: ReduceOptions): Promise<ParallelResult<number>>;
-/**
- * Parallel Euclidean norm (L2 norm)
- *
- * Computes √(Σx²) using parallel partial sums of squares.
- *
- * @param data - Vector to compute norm of
- * @param options - Optional configuration
- * @returns Euclidean norm
- */
-declare function parallelNorm(data: Float64Array, options?: ReduceOptions): Promise<ParallelResult<number>>;
-/**
- * Parallel Euclidean distance
- *
- * Computes the Euclidean distance between two vectors.
- *
- * @param a - First vector
- * @param b - Second vector
- * @param options - Optional configuration
- * @returns Euclidean distance
- */
-declare function parallelDistance(a: Float64Array, b: Float64Array, options?: ReduceOptions): Promise<ParallelResult<number>>;
-/**
- * Parallel histogram computation
- *
- * Bins data into histogram using parallel counting.
- *
- * @param data - Array to bin
- * @param bins - Number of bins
- * @param min - Minimum value (auto-detected if not provided)
- * @param max - Maximum value (auto-detected if not provided)
- * @param options - Optional configuration
- * @returns Array of bin counts
- */
-declare function parallelHistogram(data: Float64Array, bins: number, min?: number, max?: number, options?: ReduceOptions): Promise<ParallelResult<number[]>>;
-/**
- * Generic parallel reduce operation
- *
- * Reduces an array using a custom function. Note that for truly
- * associative operations, consider using specialized functions
- * (parallelSum, parallelMin, etc.) for better performance.
- *
- * @param data - Array to reduce
- * @param fn - Reduction function (acc, item) => newAcc
- * @param initial - Initial accumulator value
- * @param options - Optional configuration
- * @returns Reduced value
- */
-declare function parallelReduce<T, R>(data: T[], fn: (acc: R, item: T) => R, initial: R, options?: ReduceOptions): Promise<ParallelResult<R>>;
-
-/**
- * Parallel Map and Transform Operations
- *
- * High-performance parallel map, filter, find, and sort operations.
- * Automatically chunks data for distribution across workers.
- *
- * @packageDocumentation
- */
-
-/**
- * Options for parallel map operations
- */
-interface MapOptions {
-    /** Custom pool to use (defaults to global computePool) */
-    pool?: ComputePool;
-    /** Force parallel execution regardless of threshold */
-    forceParallel?: boolean;
-    /** Force sequential execution regardless of threshold */
-    forceSequential?: boolean;
-}
-/**
- * Parallel map operation
- *
- * Applies a function to each element in parallel.
- *
- * @param data - Array to map over
- * @param fn - Function to apply to each element
- * @param options - Optional configuration
- * @returns Mapped array
- *
- * @example
- * ```typescript
- * const data = [1, 2, 3, 4, 5];
- * const result = await parallelMap(data, x => x * x);
- * console.log(result.result); // [1, 4, 9, 16, 25]
- * ```
- */
-declare function parallelMap<T, R>(data: T[], fn: (item: T) => R, options?: MapOptions): Promise<ParallelResult<R[]>>;
-/**
- * Parallel filter operation
- *
- * Filters elements based on a predicate in parallel.
- *
- * @param data - Array to filter
- * @param predicate - Function that returns true for elements to keep
- * @param options - Optional configuration
- * @returns Filtered array
- *
- * @example
- * ```typescript
- * const data = [1, 2, 3, 4, 5, 6];
- * const result = await parallelFilter(data, x => x % 2 === 0);
- * console.log(result.result); // [2, 4, 6]
- * ```
- */
-declare function parallelFilter<T>(data: T[], predicate: (item: T) => boolean, options?: MapOptions): Promise<ParallelResult<T[]>>;
-/**
- * Parallel find operation
- *
- * Finds the first element matching a predicate.
- * Searches chunks in parallel for early termination.
- *
- * @param data - Array to search
- * @param predicate - Function that returns true for the target element
- * @param options - Optional configuration
- * @returns Object with found status, value, and index
- *
- * @example
- * ```typescript
- * const data = [1, 2, 3, 4, 5];
- * const result = await parallelFind(data, x => x > 3);
- * console.log(result.result); // { found: true, value: 4, index: 3 }
- * ```
- */
-declare function parallelFind<T>(data: T[], predicate: (item: T) => boolean, options?: MapOptions): Promise<ParallelResult<{
-    found: boolean;
-    value?: T;
-    index?: number;
-}>>;
-/**
- * Parallel sort operation
- *
- * Sorts an array using parallel merge sort.
- * Each chunk is sorted in parallel, then merged.
- *
- * @param data - Array to sort
- * @param compare - Optional comparison function (default: ascending)
- * @param options - Optional configuration
- * @returns Sorted array
- *
- * @example
- * ```typescript
- * const data = [3, 1, 4, 1, 5, 9, 2, 6];
- * const result = await parallelSort(data);
- * console.log(result.result); // [1, 1, 2, 3, 4, 5, 6, 9]
- * ```
- */
-declare function parallelSort<T>(data: T[], compare?: (a: T, b: T) => number, options?: MapOptions): Promise<ParallelResult<T[]>>;
-/**
- * Parallel forEach (for side effects)
- *
- * Note: This executes the function for side effects only.
- * The function is serialized to workers, so it cannot access
- * closures or external state.
- *
- * @param data - Array to iterate
- * @param fn - Function to apply to each element
- * @param options - Optional configuration
- */
-declare function parallelForEach<T>(data: T[], fn: (item: T) => void, options?: MapOptions): Promise<ParallelResult<void[]>>;
-/**
- * Parallel some operation
- *
- * Tests whether at least one element passes the predicate.
- *
- * @param data - Array to test
- * @param predicate - Test function
- * @param options - Optional configuration
- * @returns true if any element passes
- */
-declare function parallelSome<T>(data: T[], predicate: (item: T) => boolean, options?: MapOptions): Promise<ParallelResult<boolean>>;
-/**
- * Parallel every operation
- *
- * Tests whether all elements pass the predicate.
- *
- * @param data - Array to test
- * @param predicate - Test function
- * @param options - Optional configuration
- * @returns true if all elements pass
- */
-declare function parallelEvery<T>(data: T[], predicate: (item: T) => boolean, options?: MapOptions): Promise<ParallelResult<boolean>>;
-/**
- * Parallel count operation
- *
- * Counts elements matching a predicate.
- *
- * @param data - Array to count
- * @param predicate - Optional predicate (counts all if not provided)
- * @param options - Optional configuration
- * @returns Count of matching elements
- */
-declare function parallelCount<T>(data: T[], predicate?: (item: T) => boolean, options?: MapOptions): Promise<ParallelResult<number>>;
-
-/**
- * Chunking Strategies for Parallel Operations
- *
- * Provides utilities for dividing large arrays into chunks
- * for parallel processing across multiple workers.
- *
- * @packageDocumentation
- */
-/**
- * Result of a chunking operation
- */
-interface ChunkResult<T> {
-    /** The chunked data */
-    chunks: T[];
-    /** Metadata about each chunk */
-    chunkInfo: ChunkInfo[];
-    /** Total number of elements */
-    totalElements: number;
-    /** Number of workers/chunks */
-    numChunks: number;
-}
-/**
- * Information about a single chunk
- */
-interface ChunkInfo {
-    /** Start index in the original array */
-    startIndex: number;
-    /** End index (exclusive) in the original array */
-    endIndex: number;
-    /** Length of this chunk */
-    length: number;
-    /** Chunk index */
-    chunkIndex: number;
-}
-/**
- * Options for chunking operations
- */
-interface ChunkOptions {
-    /** Minimum elements per chunk (default: 1000) */
-    minChunkSize?: number;
-    /** Maximum number of chunks (default: number of CPUs) */
-    maxChunks?: number;
-    /** Target chunk size (default: auto-calculated) */
-    targetChunkSize?: number;
-    /** Whether to balance chunk sizes evenly (default: true) */
-    balanced?: boolean;
-}
-/**
- * Calculate optimal number of chunks for a given array size
- *
- * @param totalElements - Total number of elements
- * @param options - Chunking options
- * @returns Optimal number of chunks
- */
-declare function calculateOptimalChunks(totalElements: number, options?: ChunkOptions): number;
-/**
- * Chunk a Float64Array into multiple smaller arrays
- *
- * @param data - The array to chunk
- * @param options - Chunking options
- * @returns Chunked data with metadata
- */
-declare function chunkFloat64Array(data: Float64Array, options?: ChunkOptions): ChunkResult<Float64Array>;
-/**
- * Chunk a generic array into multiple smaller arrays
- *
- * @param data - The array to chunk
- * @param options - Chunking options
- * @returns Chunked data with metadata
- */
-declare function chunkArray<T>(data: T[], options?: ChunkOptions): ChunkResult<T[]>;
-/**
- * Merge chunked results back into a single array
- *
- * @param chunks - Array of chunk results
- * @returns Merged array
- */
-declare function mergeFloat64Chunks(chunks: Float64Array[]): Float64Array;
-/**
- * Merge generic array chunks
- *
- * @param chunks - Array of chunk results
- * @returns Merged array
- */
-declare function mergeArrayChunks<T>(chunks: T[][]): T[];
-/**
- * Determine if an array should be parallelized based on size
- *
- * @param elementCount - Number of elements
- * @param threshold - Minimum elements for parallelization (default: 10000)
- * @returns Whether parallelization is recommended
- */
-declare function shouldParallelize$1(elementCount: number, threshold?: number): boolean;
-/**
- * Create a range partitioner for parallel iteration
- *
- * @param start - Start of range (inclusive)
- * @param end - End of range (exclusive)
- * @param options - Chunking options
- * @returns Array of [start, end] pairs for each chunk
- */
-declare function partitionRange(start: number, end: number, options?: ChunkOptions): Array<[number, number]>;
-/**
- * Create a 2D partition for matrix operations
- *
- * @param rows - Number of rows
- * @param cols - Number of columns
- * @param options - Chunking options
- * @returns Array of [rowStart, rowEnd, colStart, colEnd] tuples
- */
-declare function partition2D(rows: number, cols: number, options?: ChunkOptions): Array<[number, number, number, number]>;
-
-/**
- * Parallel Bitwise Operations
- *
- * Element-wise bitwise operations on Int32Array buffers. Operations are
- * applied in a chunked fashion so the work pattern mirrors the other
- * parallel ops (`elementwise`, `scale`, etc.). The actual chunk kernel
- * runs in-process: the MathWorkerPool kernel registry in
- * `@danielsimonjr/mathts-workerpool` is keyed on `Float64Array` buffers,
- * so cross-thread bitwise dispatch is intentionally out of scope here.
- *
- * The chunking still matters: it bounds peak-allocation pressure for
- * very large arrays and keeps the call shape uniform with the rest of
- * the parallel API, so the typed-function `Int32Array, Int32Array`
- * signatures look identical to the `Float64Array, Float64Array` ones.
- *
- * Semantics follow JavaScript bitwise semantics on 32-bit signed
- * integers (two's complement). For shift counts JavaScript itself
- * masks to the low 5 bits — we preserve that behavior.
- *
- * @packageDocumentation
- */
-
-/**
- * The set of supported binary bitwise op codes.
- *
- * - `bitAnd`   : `a & b`
- * - `bitOr`    : `a | b`
- * - `bitXor`   : `a ^ b`
- * - `leftShift`       : `a << b`
- * - `rightArithShift` : `a >> b`  (sign-extending)
- * - `rightLogShift`   : `a >>> b` (zero-filling, returned as Int32 — values
- *   above 2^31 wrap into negative range, as in `(x >>> n) | 0`)
- */
-type BitwiseBinaryOp = 'bitAnd' | 'bitOr' | 'bitXor' | 'leftShift' | 'rightArithShift' | 'rightLogShift';
-/**
- * Bitwise AND on two equal-length `Int32Array`s.
- */
-declare function bitAnd(a: Int32Array, b: Int32Array, options?: ChunkOptions): Int32Array;
-/**
- * Bitwise OR on two equal-length `Int32Array`s.
- */
-declare function bitOr(a: Int32Array, b: Int32Array, options?: ChunkOptions): Int32Array;
-/**
- * Bitwise XOR on two equal-length `Int32Array`s.
- */
-declare function bitXor(a: Int32Array, b: Int32Array, options?: ChunkOptions): Int32Array;
-/**
- * Element-wise left shift: `a[i] << b[i]`.
- *
- * `b` may be either an `Int32Array` of per-element shift counts or a
- * single scalar `number` (applied uniformly). Shift counts are masked
- * to the low 5 bits by JavaScript itself — values ≥ 32 fold back into
- * `[0, 31]`.
- */
-declare function leftShift(a: Int32Array, b: Int32Array | number, options?: ChunkOptions): Int32Array;
-/**
- * Element-wise arithmetic (sign-preserving) right shift: `a[i] >> b[i]`.
- */
-declare function rightArithShift(a: Int32Array, b: Int32Array | number, options?: ChunkOptions): Int32Array;
-/**
- * Element-wise logical (zero-filling) right shift: `a[i] >>> b[i]`.
- *
- * Result is stored as `Int32Array`, so values ≥ 2^31 wrap into the
- * negative range — equivalent to `(x >>> n) | 0`.
- */
-declare function rightLogShift(a: Int32Array, b: Int32Array | number, options?: ChunkOptions): Int32Array;
-/**
- * Unary bitwise NOT: `~a[i]`. Returns a fresh `Int32Array`.
- */
-declare function bitNot(a: Int32Array, options?: ChunkOptions): Int32Array;
-
-/**
- * Threshold-based Dispatch Strategy
- *
- * Automatically decides whether to use parallel or sequential execution
- * based on data size, operation type, and system capabilities.
- *
- * @packageDocumentation
- */
-
-/**
- * Operation categories for threshold selection
- */
-type OperationCategory = 'matmul' | 'elementwise' | 'reduce' | 'map' | 'sort' | 'decomposition' | 'general';
-/**
- * Threshold configuration for different operation types
- */
-interface ThresholdConfig {
-    /** Minimum elements for parallel matmul */
-    matmul: number;
-    /** Minimum elements for parallel elementwise ops */
-    elementwise: number;
-    /** Minimum elements for parallel reductions */
-    reduce: number;
-    /** Minimum elements for parallel map */
-    map: number;
-    /** Minimum elements for parallel sort */
-    sort: number;
-    /** Minimum elements for parallel decomposition */
-    decomposition: number;
-    /** Default threshold for other operations */
-    general: number;
-}
-/**
- * Default category-level thresholds.
- *
- * NOTE: `ComputePool.shouldParallelize` (op-level, {@link DEFAULT_THRESHOLD_BY_OP})
- * is the authority the typed functions dispatch through. This category map is a
- * coarser helper; where a category overlaps a tuned op (matmul) its value is
- * derived from the canonical const so the two cannot diverge. The remaining
- * categories (no single ComputePool op equivalent — many are 'never') keep
- * heuristic defaults for compute-vs-memory-bound work.
- */
-declare const DEFAULT_THRESHOLDS: ThresholdConfig;
-/**
- * Execution mode returned by threshold dispatch
- */
-type ExecutionMode = 'parallel' | 'sequential';
-/**
- * Result of threshold dispatch decision
- */
-interface DispatchResult {
-    /** Recommended execution mode */
-    mode: ExecutionMode;
-    /** Reason for the decision */
-    reason: string;
-    /** Threshold used for comparison */
-    threshold: number;
-    /** Actual element count */
-    elementCount: number;
-}
-/**
- * Threshold-based Dispatch Manager
- *
- * Provides intelligent parallel vs sequential dispatch based on
- * operation type, data size, and system state.
- */
-declare class ThresholdDispatcher {
-    private thresholds;
-    private pool;
-    constructor(thresholds?: Partial<ThresholdConfig>, pool?: ComputePool);
-    /**
-     * Get threshold for a specific operation category
-     */
-    getThreshold(category: OperationCategory): number;
-    /**
-     * Update thresholds
-     */
-    setThresholds(thresholds: Partial<ThresholdConfig>): void;
-    /**
-     * Get current threshold configuration
-     */
-    getThresholds(): ThresholdConfig;
-    /**
-     * Determine execution mode based on operation and data size
-     */
-    dispatch(elementCount: number, category?: OperationCategory): DispatchResult;
-    /**
-     * Simple boolean check for parallel execution
-     */
-    shouldParallelize(elementCount: number, category?: OperationCategory): boolean;
-    /**
-     * Calculate optimal chunk count based on operation and data size
-     */
-    calculateChunks(elementCount: number, category?: OperationCategory): number;
-}
-/**
- * Global threshold dispatcher instance
- */
-declare const thresholdDispatcher: ThresholdDispatcher;
-/**
- * Convenience function to check if operation should be parallelized
- */
-declare function shouldParallelize(elementCount: number, category?: OperationCategory): boolean;
-/**
- * Convenience function to get dispatch decision
- */
-declare function dispatch(elementCount: number, category?: OperationCategory): DispatchResult;
-/**
- * Convenience function to calculate optimal chunk count
- */
-declare function calculateChunks(elementCount: number, category?: OperationCategory): number;
-
-export { type BitwiseBinaryOp, type ChunkInfo, type ChunkOptions, type ChunkResult, ComputePool, type ComputePoolConfig, DEFAULT_POOL_CONFIG, DEFAULT_THRESHOLDS, DEFAULT_THRESHOLD_BY_OP, type DispatchResult, type ElementwiseOptions, type ExecutionMode, type MapOptions, type MatmulOptions, type OpName, type OpThreshold, type OperationCategory, type ParallelResult, type ReduceOptions, type ThresholdConfig, ThresholdDispatcher, bitAnd, bitNot, bitOr, bitXor, calculateChunks, calculateOptimalChunks, chunkArray, chunkFloat64Array, computePool, dispatch, leftShift, mergeArrayChunks, mergeFloat64Chunks, parallelAbs, parallelAdd, parallelCos, parallelCount, parallelDistance, parallelDivide, parallelDot, parallelElementwise, parallelEvery, parallelExp, parallelFilter, parallelFind, parallelForEach, parallelHistogram, parallelLog, parallelMap, parallelMatmul, parallelMatvec, parallelMax, parallelMean, parallelMin, parallelMinMax, parallelMultiply, parallelNegate, parallelNorm, parallelOuter, parallelReduce, parallelScale, parallelSin, parallelSome, parallelSort, parallelSqrt, parallelSquare, parallelStd, parallelSubtract, parallelSum, parallelTan, parallelTranspose, parallelUnary, parallelVariance, partition2D, partitionRange, resolveOpThreshold, rightArithShift, rightLogShift, shouldParallelize$1 as shouldChunkParallelize, shouldParallelize, thresholdDispatcher };
+export { ComputePool, computePool, Transfer, DEFAULT_POOL_CONFIG, DEFAULT_THRESHOLD_BY_OP, resolveOpThreshold, } from './ComputePool.js';
+export type { ComputePoolConfig, ParallelResult, OpName, OpThreshold } from './ComputePool.js';
+export { parallelMatmul, parallelMatvec, parallelTranspose, parallelOuter, parallelDot, parallelAdd, parallelSubtract, parallelMultiply, parallelDivide, parallelScale, parallelAbs, parallelNegate, parallelSquare, parallelSqrt, parallelExp, parallelLog, parallelSin, parallelCos, parallelTan, parallelElementwise, parallelUnary, parallelSum, parallelMean, parallelMin, parallelMax, parallelMinMax, parallelVariance, parallelStd, parallelNorm, parallelDistance, parallelHistogram, parallelReduce, parallelMap, parallelFilter, parallelFind, parallelSort, parallelForEach, parallelSome, parallelEvery, parallelCount, } from './operations/index.js';
+export type { MatmulOptions, ElementwiseOptions, ReduceOptions, MapOptions, } from './operations/index.js';
+export { bitAnd, bitOr, bitXor, bitNot, leftShift, rightArithShift, rightLogShift, } from './ops/bitwise.js';
+export type { BitwiseBinaryOp } from './ops/bitwise.js';
+export { calculateOptimalChunks, chunkFloat64Array, chunkArray, mergeFloat64Chunks, mergeArrayChunks, shouldChunkParallelize, partitionRange, partition2D, ThresholdDispatcher, thresholdDispatcher, shouldParallelize, dispatch, calculateChunks, DEFAULT_THRESHOLDS, } from './strategies/index.js';
+export type { ChunkOptions, ChunkResult, ChunkInfo, ThresholdConfig, OperationCategory, ExecutionMode, DispatchResult, } from './strategies/index.js';
+export type { PoolOptions, ExecOptions, PoolStats } from '@danielsimonjr/mathts-workerpool';
+//# sourceMappingURL=index.d.ts.map