@danielsimonjr/mathts-parallel 0.6.4 → 0.6.5

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,OAAO,EACL,WAAW,EACX,WAAW,EACX,QAAQ,EACR,mBAAmB,EACnB,uBAAuB,EACvB,kBAAkB,GACnB,MAAM,kBAAkB,CAAC;AAE1B,YAAY,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAM/F,OAAO,EAEL,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,aAAa,EACb,WAAW,EAGX,WAAW,EACX,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,WAAW,EACX,cAAc,EACd,cAAc,EACd,YAAY,EACZ,WAAW,EACX,WAAW,EACX,WAAW,EACX,WAAW,EACX,WAAW,EACX,mBAAmB,EACnB,aAAa,EAGb,WAAW,EACX,YAAY,EACZ,WAAW,EACX,WAAW,EACX,cAAc,EACd,gBAAgB,EAChB,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,cAAc,EAGd,WAAW,EACX,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,aAAa,EACb,aAAa,GACd,MAAM,uBAAuB,CAAC;AAE/B,YAAY,EACV,aAAa,EACb,kBAAkB,EAClB,aAAa,EACb,UAAU,GACX,MAAM,uBAAuB,CAAC;AAM/B,OAAO,EACL,MAAM,EACN,KAAK,EACL,MAAM,EACN,MAAM,EACN,SAAS,EACT,eAAe,EACf,aAAa,GACd,MAAM,kBAAkB,CAAC;AAE1B,YAAY,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAMxD,OAAO,EAEL,sBAAsB,EACtB,iBAAiB,EACjB,UAAU,EACV,kBAAkB,EAClB,gBAAgB,EAChB,sBAAsB,EACtB,cAAc,EACd,WAAW,EAGX,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EACjB,QAAQ,EACR,eAAe,EACf,kBAAkB,GACnB,MAAM,uBAAuB,CAAC;AAE/B,YAAY,EACV,YAAY,EACZ,WAAW,EACX,SAAS,EACT,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,cAAc,GACf,MAAM,uBAAuB,CAAC;AAU/B,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC"}

package/dist/matrix.worker.d.ts

@@ -1,2 +1,13 @@
-
-export {  }
+/**
+ * Matrix Worker for parallel computation
+ * Handles matrix operations in a separate thread.
+ *
+ * Each task computes a contiguous slice of the output and returns it. The
+ * parent ({@link ParallelMatrix}) copies returned slices back into the result
+ * buffer. Returning the data (rather than relying on in-place mutation of a
+ * shared buffer) keeps the worker correct whether or not the caller is using
+ * SharedArrayBuffer — a structured-clone copy of a non-shared `resultData`
+ * would otherwise be discarded and the caller would observe all zeros.
+ */
+export {};
+//# sourceMappingURL=matrix.worker.d.ts.map

package/dist/matrix.worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrix.worker.d.ts","sourceRoot":"","sources":["../src/matrix.worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAmQH,OAAO,EAAE,CAAC"}

package/dist/operations/elementwise.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Parallel Element-wise Operations
+ *
+ * High-performance parallel element-wise operations on arrays.
+ * Automatically chunks data for distribution across workers.
+ *
+ * @packageDocumentation
+ */
+import { ComputePool } from '../ComputePool.js';
+import type { ParallelResult } from '../ComputePool.js';
+/**
+ * Options for parallel element-wise operations
+ */
+export 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])
+ */
+export declare function parallelAdd(a: Float64Array, b: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
+/**
+ * Parallel element-wise subtraction (c[i] = a[i] - b[i])
+ */
+export declare function parallelSubtract(a: Float64Array, b: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
+/**
+ * Parallel element-wise multiplication (c[i] = a[i] * b[i])
+ */
+export declare function parallelMultiply(a: Float64Array, b: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
+/**
+ * Parallel element-wise division (c[i] = a[i] / b[i])
+ */
+export declare function parallelDivide(a: Float64Array, b: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
+/**
+ * Parallel scalar multiplication (b[i] = a[i] * scalar)
+ */
+export declare function parallelScale(data: Float64Array, scalar: number, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
+/**
+ * Parallel absolute value (b[i] = |a[i]|)
+ */
+export declare function parallelAbs(data: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
+/**
+ * Parallel negation (b[i] = -a[i])
+ */
+export declare function parallelNegate(data: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
+/**
+ * Parallel square (b[i] = a[i]²)
+ */
+export declare function parallelSquare(data: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
+/**
+ * Parallel square root (b[i] = √a[i])
+ */
+export declare function parallelSqrt(data: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
+/**
+ * Parallel exponential (b[i] = e^a[i])
+ */
+export declare function parallelExp(data: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
+/**
+ * Parallel natural logarithm (b[i] = ln(a[i]))
+ */
+export declare function parallelLog(data: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
+/**
+ * Parallel sine (b[i] = sin(a[i]))
+ */
+export declare function parallelSin(data: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
+/**
+ * Parallel cosine (b[i] = cos(a[i]))
+ */
+export declare function parallelCos(data: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
+/**
+ * Parallel tangent (b[i] = tan(a[i]))
+ */
+export declare function parallelTan(data: Float64Array, options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
+/**
+ * Generic parallel element-wise operation
+ */
+export declare function parallelElementwise(a: Float64Array, b: Float64Array, op: 'add' | 'subtract' | 'multiply' | 'divide', options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
+/**
+ * Generic parallel unary operation
+ */
+export declare function parallelUnary(data: Float64Array, fn: 'abs' | 'sqrt' | 'exp' | 'log' | 'sin' | 'cos' | 'tan' | 'negate' | 'square', options?: ElementwiseOptions): Promise<ParallelResult<Float64Array>>;
+//# sourceMappingURL=elementwise.d.ts.map

package/dist/operations/elementwise.d.ts.map

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

package/dist/operations/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Parallel Operations
+ *
+ * High-level parallel operations for matrix and array computations.
+ *
+ * @packageDocumentation
+ */
+export { parallelMatmul, parallelMatvec, parallelTranspose, parallelOuter, parallelDot, type MatmulOptions, } from './matmul.js';
+export { parallelAdd, parallelSubtract, parallelMultiply, parallelDivide, parallelScale, parallelAbs, parallelNegate, parallelSquare, parallelSqrt, parallelExp, parallelLog, parallelSin, parallelCos, parallelTan, parallelElementwise, parallelUnary, type ElementwiseOptions, } from './elementwise.js';
+export { parallelSum, parallelMean, parallelMin, parallelMax, parallelMinMax, parallelVariance, parallelStd, parallelNorm, parallelDistance, parallelHistogram, parallelReduce, type ReduceOptions, } from './reduce.js';
+export { parallelMap, parallelFilter, parallelFind, parallelSort, parallelForEach, parallelSome, parallelEvery, parallelCount, type MapOptions, } from './map.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/operations/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EACL,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,aAAa,EACb,WAAW,EACX,KAAK,aAAa,GACnB,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,WAAW,EACX,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,WAAW,EACX,cAAc,EACd,cAAc,EACd,YAAY,EACZ,WAAW,EACX,WAAW,EACX,WAAW,EACX,WAAW,EACX,WAAW,EACX,mBAAmB,EACnB,aAAa,EACb,KAAK,kBAAkB,GACxB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,WAAW,EACX,YAAY,EACZ,WAAW,EACX,WAAW,EACX,cAAc,EACd,gBAAgB,EAChB,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,cAAc,EACd,KAAK,aAAa,GACnB,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,WAAW,EACX,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,aAAa,EACb,aAAa,EACb,KAAK,UAAU,GAChB,MAAM,UAAU,CAAC"}

package/dist/operations/map.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Parallel Map and Transform Operations
+ *
+ * High-performance parallel map, filter, find, and sort operations.
+ * Automatically chunks data for distribution across workers.
+ *
+ * @packageDocumentation
+ */
+import { ComputePool } from '../ComputePool.js';
+import type { ParallelResult } from '../ComputePool.js';
+/**
+ * Options for parallel map operations
+ */
+export 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]
+ * ```
+ */
+export 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]
+ * ```
+ */
+export 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 }
+ * ```
+ */
+export 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]
+ * ```
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export declare function parallelCount<T>(data: T[], predicate?: (item: T) => boolean, options?: MapOptions): Promise<ParallelResult<number>>;
+//# sourceMappingURL=map.d.ts.map

package/dist/operations/map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/operations/map.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAe,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,0DAA0D;IAC1D,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,uDAAuD;IACvD,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,yDAAyD;IACzD,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,WAAW,CAAC,CAAC,EAAE,CAAC,EACpC,IAAI,EAAE,CAAC,EAAE,EACT,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,EAClB,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAG9B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,cAAc,CAAC,CAAC,EACpC,IAAI,EAAE,CAAC,EAAE,EACT,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,EAC/B,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAG9B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAClC,IAAI,EAAE,CAAC,EAAE,EACT,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,EAC/B,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAGxE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAClC,IAAI,EAAE,CAAC,EAAE,EACT,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,EAChC,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAG9B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CAAC,CAAC,EACrC,IAAI,EAAE,CAAC,EAAE,EACT,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,EACrB,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC,CAAC,CAUjC;AAED;;;;;;;;;GASG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAClC,IAAI,EAAE,CAAC,EAAE,EACT,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,EAC/B,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAOlC;AAED;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACnC,IAAI,EAAE,CAAC,EAAE,EACT,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,EAC/B,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAQlC;AAED;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACnC,IAAI,EAAE,CAAC,EAAE,EACT,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,EAChC,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAkBjC"}

package/dist/operations/matmul.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Parallel Matrix Multiplication
+ *
+ * High-performance parallel matrix multiplication with automatic chunking.
+ * Distributes rows across workers for parallel computation.
+ *
+ * @packageDocumentation
+ */
+import { ComputePool } from '../ComputePool.js';
+import type { ParallelResult } from '../ComputePool.js';
+/**
+ * Options for parallel matrix multiplication
+ */
+export 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
+ * ```
+ */
+export 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
+ */
+export 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
+ */
+export 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)
+ */
+export 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
+ */
+export declare function parallelDot(a: Float64Array, b: Float64Array, options?: MatmulOptions): Promise<ParallelResult<number>>;
+//# sourceMappingURL=matmul.d.ts.map

package/dist/operations/matmul.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matmul.d.ts","sourceRoot":"","sources":["../../src/operations/matmul.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAe,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,0DAA0D;IAC1D,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,uDAAuD;IACvD,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,yDAAyD;IACzD,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,cAAc,CAClC,CAAC,EAAE,YAAY,EACf,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,CAAC,EAAE,YAAY,EACf,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC,CAGvC;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,YAAY,EACpB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,YAAY,EACpB,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC,CAGvC;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,YAAY,EAClB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC,CAGvC;AAED;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CACjC,CAAC,EAAE,YAAY,EACf,CAAC,EAAE,YAAY,EACf,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC,CAGvC;AAED;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAC/B,CAAC,EAAE,YAAY,EACf,CAAC,EAAE,YAAY,EACf,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAGjC"}

package/dist/operations/reduce.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Parallel Reduction Operations
+ *
+ * High-performance parallel reduction operations (sum, min, max, etc.).
+ * Uses parallel aggregation with sequential final reduction.
+ *
+ * @packageDocumentation
+ */
+import { ComputePool } from '../ComputePool.js';
+import type { ParallelResult } from '../ComputePool.js';
+/**
+ * Options for parallel reduction operations
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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)
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export declare function parallelReduce<T, R>(data: T[], fn: (acc: R, item: T) => R, initial: R, options?: ReduceOptions): Promise<ParallelResult<R>>;
+//# sourceMappingURL=reduce.d.ts.map

package/dist/operations/reduce.d.ts.map

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

package/dist/ops/bitwise.d.ts

@@ -0,0 +1,71 @@
+/**
+ * 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
+ */
+import { type ChunkOptions } from '../strategies/chunk.js';
+/**
+ * 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`)
+ */
+export type BitwiseBinaryOp = 'bitAnd' | 'bitOr' | 'bitXor' | 'leftShift' | 'rightArithShift' | 'rightLogShift';
+/**
+ * Bitwise AND on two equal-length `Int32Array`s.
+ */
+export declare function bitAnd(a: Int32Array, b: Int32Array, options?: ChunkOptions): Int32Array;
+/**
+ * Bitwise OR on two equal-length `Int32Array`s.
+ */
+export declare function bitOr(a: Int32Array, b: Int32Array, options?: ChunkOptions): Int32Array;
+/**
+ * Bitwise XOR on two equal-length `Int32Array`s.
+ */
+export 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]`.
+ */
+export declare function leftShift(a: Int32Array, b: Int32Array | number, options?: ChunkOptions): Int32Array;
+/**
+ * Element-wise arithmetic (sign-preserving) right shift: `a[i] >> b[i]`.
+ */
+export 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`.
+ */
+export declare function rightLogShift(a: Int32Array, b: Int32Array | number, options?: ChunkOptions): Int32Array;
+/**
+ * Unary bitwise NOT: `~a[i]`. Returns a fresh `Int32Array`.
+ */
+export declare function bitNot(a: Int32Array, options?: ChunkOptions): Int32Array;
+//# sourceMappingURL=bitwise.d.ts.map

package/dist/ops/bitwise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitwise.d.ts","sourceRoot":"","sources":["../../src/ops/bitwise.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAA0B,KAAK,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEnF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,eAAe,GACvB,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,WAAW,GACX,iBAAiB,GACjB,eAAe,CAAC;AAwEpB;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,UAAU,CAEvF;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,UAAU,CAEtF;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,UAAU,CAEvF;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACvB,CAAC,EAAE,UAAU,EACb,CAAC,EAAE,UAAU,GAAG,MAAM,EACtB,OAAO,CAAC,EAAE,YAAY,GACrB,UAAU,CAGZ;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,CAAC,EAAE,UAAU,EACb,CAAC,EAAE,UAAU,GAAG,MAAM,EACtB,OAAO,CAAC,EAAE,YAAY,GACrB,UAAU,CAGZ;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,CAAC,EAAE,UAAU,EACb,CAAC,EAAE,UAAU,GAAG,MAAM,EACtB,OAAO,CAAC,EAAE,YAAY,GACrB,UAAU,CAGZ;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,UAAU,EAAE,OAAO,GAAE,YAAiB,GAAG,UAAU,CAiB5E"}