@danielsimonjr/mathts-parallel 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,993 @@
+import { TaskOptions, PoolStats as PoolStats$1, MathWorkerPool } from '@danielsimonjr/mathts-workerpool';
+export { Transfer } from '@danielsimonjr/mathts-workerpool';
+
+/**
+ * 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
+ */
+
+/**
+ * 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;
+    /** Minimum elements before parallelizing */
+    thresholdElements: number;
+    /** 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 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
+     */
+    shouldParallelize(elementCount: number): boolean;
+    /**
+     * Execute a method in the worker pool
+     */
+    exec<T>(method: string, params: unknown[], options?: TaskOptions): Promise<T>;
+    /**
+     * Get pool statistics
+     */
+    stats(): PoolStats$1;
+    /**
+     * Parallel sum of array elements
+     */
+    sum(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>>;
+    /**
+     * 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>>;
+    /**
+     * 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>>;
+    /**
+     * Terminate the worker pool
+     */
+    terminate(force?: boolean): Promise<void>;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<ComputePoolConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): ComputePoolConfig;
+    /**
+     * 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]>;
+
+/**
+ * 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 thresholds optimized for typical hardware
+ *
+ * These thresholds account for worker creation overhead vs computation benefit.
+ * Smaller thresholds for compute-intensive operations (matmul, decomposition).
+ * Larger thresholds for memory-bound operations (elementwise, reduce).
+ */
+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;
+
+/**
+ * @danielsimonjr/mathts-parallel
+ *
+ * WebWorker parallelization for MathTS computations.
+ * Provides automatic parallelization based on data size thresholds.
+ *
+ * @packageDocumentation
+ */
+
+interface PoolOptions {
+    minWorkers?: number | 'max';
+    maxWorkers?: number;
+    workerType?: 'auto' | 'web' | 'thread';
+    workerTerminateTimeout?: number;
+}
+interface ExecOptions {
+    on?: (payload: unknown) => void;
+    transfer?: unknown[];
+    timeout?: number;
+}
+interface PoolStats {
+    totalWorkers: number;
+    busyWorkers: number;
+    idleWorkers: number;
+    pendingTasks: number;
+    activeTasks: number;
+}
+
+export { type ChunkInfo, type ChunkOptions, type ChunkResult, ComputePool, type ComputePoolConfig, DEFAULT_POOL_CONFIG, DEFAULT_THRESHOLDS, type DispatchResult, type ElementwiseOptions, type ExecOptions, type ExecutionMode, type MapOptions, type MatmulOptions, type OperationCategory, type ParallelResult, type PoolOptions, type PoolStats, type ReduceOptions, type ThresholdConfig, ThresholdDispatcher, calculateChunks, calculateOptimalChunks, chunkArray, chunkFloat64Array, computePool, dispatch, 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, shouldParallelize$1 as shouldChunkParallelize, shouldParallelize, thresholdDispatcher };