@danielsimonjr/mathts-parallel 0.1.1

package/dist/index.js

@@ -0,0 +1,953 @@
+// src/ComputePool.ts
+import {
+  MathWorkerPool,
+  Transfer
+} from "@danielsimonjr/mathts-workerpool";
+var DEFAULT_POOL_CONFIG = {
+  enabled: true,
+  minWorkers: 1,
+  maxWorkers: typeof navigator !== "undefined" ? navigator.hardwareConcurrency || 4 : 4,
+  thresholdElements: 5e4,
+  chunkSize: 1e4,
+  workerType: "auto",
+  workerIdleTimeout: 6e4,
+  taskTimeout: 3e5
+  // 5 minutes
+};
+function toParallelResult(result) {
+  return {
+    result: result.result,
+    duration: result.duration,
+    chunks: result.chunks,
+    parallelized: result.parallelized
+  };
+}
+function toWorkerConfig(config) {
+  return {
+    enabled: config.enabled,
+    minWorkers: config.minWorkers,
+    maxWorkers: config.maxWorkers,
+    parallelThreshold: config.thresholdElements,
+    chunkSize: config.chunkSize,
+    workerType: config.workerType,
+    idleTimeout: config.workerIdleTimeout,
+    taskTimeout: config.taskTimeout
+  };
+}
+var ComputePool = class {
+  workerPool;
+  config;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_POOL_CONFIG, ...config };
+    this.workerPool = new MathWorkerPool(toWorkerConfig(this.config));
+  }
+  /**
+   * Initialize the worker pool
+   */
+  async initialize() {
+    await this.workerPool.initialize();
+  }
+  /**
+   * Check if pool is ready
+   */
+  isReady() {
+    return this.workerPool.isReady();
+  }
+  /**
+   * Determine if operation should be parallelized
+   */
+  shouldParallelize(elementCount) {
+    return this.workerPool.shouldParallelize(elementCount);
+  }
+  /**
+   * Execute a method in the worker pool
+   */
+  async exec(method, params, options) {
+    return this.workerPool.exec(method, params, options);
+  }
+  /**
+   * Get pool statistics
+   */
+  stats() {
+    return this.workerPool.stats();
+  }
+  /**
+   * Parallel sum of array elements
+   */
+  async sum(data) {
+    const result = await this.workerPool.sum(data);
+    return toParallelResult(result);
+  }
+  /**
+   * Parallel dot product
+   */
+  async dot(a, b) {
+    const result = await this.workerPool.dot(a, b);
+    return toParallelResult(result);
+  }
+  /**
+   * Parallel element-wise operation
+   */
+  async elementwise(a, b, op) {
+    const result = await this.workerPool.elementwise(a, b, op);
+    return toParallelResult(result);
+  }
+  /**
+   * Parallel scale operation
+   */
+  async scale(data, scalar) {
+    const result = await this.workerPool.scale(data, scalar);
+    return toParallelResult(result);
+  }
+  /**
+   * 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
+   */
+  async matmul(a, aRows, aCols, b, bCols) {
+    const result = await this.workerPool.matmul(a, aRows, aCols, b, bCols);
+    return toParallelResult(result);
+  }
+  /**
+   * Parallel matrix transpose
+   */
+  async transpose(data, rows, cols) {
+    const result = await this.workerPool.transpose(data, rows, cols);
+    return toParallelResult(result);
+  }
+  /**
+   * Parallel map operation
+   */
+  async map(data, fn) {
+    const result = await this.workerPool.map(data, fn);
+    return toParallelResult(result);
+  }
+  /**
+   * Parallel reduce operation
+   */
+  async reduce(data, fn, initial) {
+    const result = await this.workerPool.reduce(data, fn, initial);
+    return toParallelResult(result);
+  }
+  /**
+   * Parallel filter operation
+   */
+  async filter(data, predicate) {
+    const result = await this.workerPool.filter(data, predicate);
+    return toParallelResult(result);
+  }
+  // =========================================================================
+  // Statistical Operations
+  // =========================================================================
+  /**
+   * Find min and max values in parallel
+   */
+  async minMax(data) {
+    const result = await this.workerPool.minMax(data);
+    return toParallelResult(result);
+  }
+  /**
+   * Compute variance, mean, and standard deviation in parallel
+   */
+  async variance(data) {
+    const result = await this.workerPool.variance(data);
+    return toParallelResult(result);
+  }
+  /**
+   * Compute norm (Euclidean length) in parallel
+   */
+  async norm(data) {
+    const result = await this.workerPool.norm(data);
+    return toParallelResult(result);
+  }
+  /**
+   * Compute Euclidean distance in parallel
+   */
+  async distance(a, b) {
+    const result = await this.workerPool.distance(a, b);
+    return toParallelResult(result);
+  }
+  /**
+   * Compute histogram in parallel
+   */
+  async histogram(data, bins, min, max) {
+    const result = await this.workerPool.histogram(data, bins, min, max);
+    return toParallelResult(result);
+  }
+  // =========================================================================
+  // Unary Operations
+  // =========================================================================
+  /**
+   * Apply unary function in parallel
+   */
+  async unary(data, fn) {
+    const result = await this.workerPool.unary(data, fn);
+    return toParallelResult(result);
+  }
+  /**
+   * Parallel absolute value
+   */
+  async abs(data) {
+    return this.unary(data, "abs");
+  }
+  /**
+   * Parallel square root
+   */
+  async sqrt(data) {
+    return this.unary(data, "sqrt");
+  }
+  /**
+   * Parallel exponential
+   */
+  async exp(data) {
+    return this.unary(data, "exp");
+  }
+  /**
+   * Parallel natural log
+   */
+  async log(data) {
+    return this.unary(data, "log");
+  }
+  /**
+   * Parallel sine
+   */
+  async sin(data) {
+    return this.unary(data, "sin");
+  }
+  /**
+   * Parallel cosine
+   */
+  async cos(data) {
+    return this.unary(data, "cos");
+  }
+  /**
+   * Parallel tangent
+   */
+  async tan(data) {
+    return this.unary(data, "tan");
+  }
+  /**
+   * Parallel negation
+   */
+  async negate(data) {
+    return this.unary(data, "negate");
+  }
+  /**
+   * Parallel square
+   */
+  async square(data) {
+    return this.unary(data, "square");
+  }
+  // =========================================================================
+  // Additional Matrix Operations
+  // =========================================================================
+  /**
+   * Parallel matrix-vector multiplication
+   */
+  async matvec(matrix, rows, cols, vector) {
+    const result = await this.workerPool.matvec(matrix, rows, cols, vector);
+    return toParallelResult(result);
+  }
+  /**
+   * Parallel outer product
+   */
+  async outer(a, b) {
+    const result = await this.workerPool.outer(a, b);
+    return toParallelResult(result);
+  }
+  // =========================================================================
+  // Search and Sort Operations
+  // =========================================================================
+  /**
+   * Parallel find operation
+   */
+  async find(data, predicate) {
+    const result = await this.workerPool.find(data, predicate);
+    return toParallelResult(result);
+  }
+  /**
+   * Parallel sort operation
+   */
+  async sort(data, compare) {
+    const result = await this.workerPool.sort(data, compare);
+    return toParallelResult(result);
+  }
+  // =========================================================================
+  // Convenience Methods
+  // =========================================================================
+  /**
+   * Parallel addition of two arrays
+   */
+  async add(a, b) {
+    return this.elementwise(a, b, "add");
+  }
+  /**
+   * Parallel subtraction of two arrays
+   */
+  async subtract(a, b) {
+    return this.elementwise(a, b, "subtract");
+  }
+  /**
+   * Parallel element-wise multiplication
+   */
+  async multiply(a, b) {
+    return this.elementwise(a, b, "multiply");
+  }
+  /**
+   * Parallel element-wise division
+   */
+  async divide(a, b) {
+    return this.elementwise(a, b, "divide");
+  }
+  /**
+   * Compute mean in parallel (uses variance internally)
+   */
+  async mean(data) {
+    const result = await this.variance(data);
+    return {
+      ...result,
+      result: result.result.mean
+    };
+  }
+  /**
+   * Compute standard deviation in parallel
+   */
+  async std(data) {
+    const result = await this.variance(data);
+    return {
+      ...result,
+      result: result.result.std
+    };
+  }
+  /**
+   * Find minimum value in parallel
+   */
+  async min(data) {
+    const result = await this.minMax(data);
+    return {
+      ...result,
+      result: result.result.min
+    };
+  }
+  /**
+   * Find maximum value in parallel
+   */
+  async max(data) {
+    const result = await this.minMax(data);
+    return {
+      ...result,
+      result: result.result.max
+    };
+  }
+  /**
+   * Terminate the worker pool
+   */
+  async terminate(force = false) {
+    await this.workerPool.terminate(force);
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+    this.workerPool.updateConfig(toWorkerConfig(this.config));
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Get the underlying MathWorkerPool for advanced operations
+   */
+  getWorkerPool() {
+    return this.workerPool;
+  }
+};
+var computePool = new ComputePool();
+
+// src/operations/matmul.ts
+async function parallelMatmul(a, aRows, aCols, b, bCols, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.matmul(a, aRows, aCols, b, bCols);
+}
+async function parallelMatvec(matrix, rows, cols, vector, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.matvec(matrix, rows, cols, vector);
+}
+async function parallelTranspose(data, rows, cols, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.transpose(data, rows, cols);
+}
+async function parallelOuter(a, b, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.outer(a, b);
+}
+async function parallelDot(a, b, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.dot(a, b);
+}
+
+// src/operations/elementwise.ts
+async function parallelAdd(a, b, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.add(a, b);
+}
+async function parallelSubtract(a, b, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.subtract(a, b);
+}
+async function parallelMultiply(a, b, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.multiply(a, b);
+}
+async function parallelDivide(a, b, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.divide(a, b);
+}
+async function parallelScale(data, scalar, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.scale(data, scalar);
+}
+async function parallelAbs(data, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.abs(data);
+}
+async function parallelNegate(data, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.negate(data);
+}
+async function parallelSquare(data, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.square(data);
+}
+async function parallelSqrt(data, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.sqrt(data);
+}
+async function parallelExp(data, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.exp(data);
+}
+async function parallelLog(data, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.log(data);
+}
+async function parallelSin(data, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.sin(data);
+}
+async function parallelCos(data, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.cos(data);
+}
+async function parallelTan(data, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.tan(data);
+}
+async function parallelElementwise(a, b, op, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.elementwise(a, b, op);
+}
+async function parallelUnary(data, fn, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.unary(data, fn);
+}
+
+// src/operations/reduce.ts
+async function parallelSum(data, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.sum(data);
+}
+async function parallelMean(data, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.mean(data);
+}
+async function parallelMin(data, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.min(data);
+}
+async function parallelMax(data, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.max(data);
+}
+async function parallelMinMax(data, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.minMax(data);
+}
+async function parallelVariance(data, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.variance(data);
+}
+async function parallelStd(data, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.std(data);
+}
+async function parallelNorm(data, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.norm(data);
+}
+async function parallelDistance(a, b, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.distance(a, b);
+}
+async function parallelHistogram(data, bins, min, max, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.histogram(data, bins, min, max);
+}
+async function parallelReduce(data, fn, initial, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.reduce(data, fn, initial);
+}
+
+// src/operations/map.ts
+async function parallelMap(data, fn, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.map(data, fn);
+}
+async function parallelFilter(data, predicate, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.filter(data, predicate);
+}
+async function parallelFind(data, predicate, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.find(data, predicate);
+}
+async function parallelSort(data, compare, options = {}) {
+  const pool = options.pool ?? computePool;
+  return pool.sort(data, compare);
+}
+async function parallelForEach(data, fn, options = {}) {
+  const pool = options.pool ?? computePool;
+  const result = await pool.map(data, (item) => {
+    fn(item);
+    return void 0;
+  });
+  return {
+    ...result,
+    result: result.result
+  };
+}
+async function parallelSome(data, predicate, options = {}) {
+  const pool = options.pool ?? computePool;
+  const findResult = await pool.find(data, predicate);
+  return {
+    ...findResult,
+    result: findResult.result.found
+  };
+}
+async function parallelEvery(data, predicate, options = {}) {
+  const pool = options.pool ?? computePool;
+  const findResult = await pool.find(data, (item) => !predicate(item));
+  return {
+    ...findResult,
+    result: !findResult.result.found
+  };
+}
+async function parallelCount(data, predicate, options = {}) {
+  const pool = options.pool ?? computePool;
+  if (!predicate) {
+    return {
+      result: data.length,
+      duration: 0,
+      chunks: 1,
+      parallelized: false
+    };
+  }
+  const filterResult = await pool.filter(data, predicate);
+  return {
+    ...filterResult,
+    result: filterResult.result.length
+  };
+}
+
+// src/strategies/chunk.ts
+var DEFAULT_CHUNK_OPTIONS = {
+  minChunkSize: 1e3,
+  maxChunks: typeof navigator !== "undefined" ? navigator.hardwareConcurrency || 4 : 4,
+  targetChunkSize: 0,
+  // 0 = auto
+  balanced: true
+};
+function calculateOptimalChunks(totalElements, options = {}) {
+  const { minChunkSize, maxChunks, targetChunkSize } = {
+    ...DEFAULT_CHUNK_OPTIONS,
+    ...options
+  };
+  if (totalElements === 0) return 0;
+  if (targetChunkSize > 0) {
+    return Math.min(maxChunks, Math.ceil(totalElements / targetChunkSize));
+  }
+  const maxPossibleChunks = Math.floor(totalElements / minChunkSize);
+  return Math.max(1, Math.min(maxChunks, maxPossibleChunks));
+}
+function chunkFloat64Array(data, options = {}) {
+  const { minChunkSize, balanced } = { ...DEFAULT_CHUNK_OPTIONS, ...options };
+  const totalElements = data.length;
+  if (totalElements === 0) {
+    return {
+      chunks: [],
+      chunkInfo: [],
+      totalElements: 0,
+      numChunks: 0
+    };
+  }
+  const numChunks = calculateOptimalChunks(totalElements, options);
+  if (numChunks <= 1) {
+    return {
+      chunks: [data],
+      chunkInfo: [
+        {
+          startIndex: 0,
+          endIndex: totalElements,
+          length: totalElements,
+          chunkIndex: 0
+        }
+      ],
+      totalElements,
+      numChunks: 1
+    };
+  }
+  const chunks = [];
+  const chunkInfo = [];
+  if (balanced) {
+    const baseChunkSize = Math.floor(totalElements / numChunks);
+    const remainder = totalElements % numChunks;
+    let currentIndex = 0;
+    for (let i = 0; i < numChunks; i++) {
+      const thisChunkSize = baseChunkSize + (i < remainder ? 1 : 0);
+      const endIndex = currentIndex + thisChunkSize;
+      chunks.push(data.subarray(currentIndex, endIndex));
+      chunkInfo.push({
+        startIndex: currentIndex,
+        endIndex,
+        length: thisChunkSize,
+        chunkIndex: i
+      });
+      currentIndex = endIndex;
+    }
+  } else {
+    const chunkSize = Math.max(minChunkSize, Math.ceil(totalElements / numChunks));
+    let currentIndex = 0;
+    let chunkIndex = 0;
+    while (currentIndex < totalElements) {
+      const endIndex = Math.min(currentIndex + chunkSize, totalElements);
+      const thisChunkSize = endIndex - currentIndex;
+      chunks.push(data.subarray(currentIndex, endIndex));
+      chunkInfo.push({
+        startIndex: currentIndex,
+        endIndex,
+        length: thisChunkSize,
+        chunkIndex
+      });
+      currentIndex = endIndex;
+      chunkIndex++;
+    }
+  }
+  return {
+    chunks,
+    chunkInfo,
+    totalElements,
+    numChunks: chunks.length
+  };
+}
+function chunkArray(data, options = {}) {
+  const { balanced } = { ...DEFAULT_CHUNK_OPTIONS, ...options };
+  const totalElements = data.length;
+  if (totalElements === 0) {
+    return {
+      chunks: [],
+      chunkInfo: [],
+      totalElements: 0,
+      numChunks: 0
+    };
+  }
+  const numChunks = calculateOptimalChunks(totalElements, options);
+  if (numChunks <= 1) {
+    return {
+      chunks: [data],
+      chunkInfo: [
+        {
+          startIndex: 0,
+          endIndex: totalElements,
+          length: totalElements,
+          chunkIndex: 0
+        }
+      ],
+      totalElements,
+      numChunks: 1
+    };
+  }
+  const chunks = [];
+  const chunkInfo = [];
+  if (balanced) {
+    const baseChunkSize = Math.floor(totalElements / numChunks);
+    const remainder = totalElements % numChunks;
+    let currentIndex = 0;
+    for (let i = 0; i < numChunks; i++) {
+      const thisChunkSize = baseChunkSize + (i < remainder ? 1 : 0);
+      const endIndex = currentIndex + thisChunkSize;
+      chunks.push(data.slice(currentIndex, endIndex));
+      chunkInfo.push({
+        startIndex: currentIndex,
+        endIndex,
+        length: thisChunkSize,
+        chunkIndex: i
+      });
+      currentIndex = endIndex;
+    }
+  } else {
+    const chunkSize = Math.ceil(totalElements / numChunks);
+    let currentIndex = 0;
+    let chunkIndex = 0;
+    while (currentIndex < totalElements) {
+      const endIndex = Math.min(currentIndex + chunkSize, totalElements);
+      const thisChunkSize = endIndex - currentIndex;
+      chunks.push(data.slice(currentIndex, endIndex));
+      chunkInfo.push({
+        startIndex: currentIndex,
+        endIndex,
+        length: thisChunkSize,
+        chunkIndex
+      });
+      currentIndex = endIndex;
+      chunkIndex++;
+    }
+  }
+  return {
+    chunks,
+    chunkInfo,
+    totalElements,
+    numChunks: chunks.length
+  };
+}
+function mergeFloat64Chunks(chunks) {
+  if (chunks.length === 0) return new Float64Array(0);
+  if (chunks.length === 1) return chunks[0];
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const result = new Float64Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+function mergeArrayChunks(chunks) {
+  if (chunks.length === 0) return [];
+  if (chunks.length === 1) return chunks[0];
+  return chunks.flat();
+}
+function shouldParallelize(elementCount, threshold = 1e4) {
+  return elementCount >= threshold;
+}
+function partitionRange(start, end, options = {}) {
+  const totalElements = end - start;
+  const numChunks = calculateOptimalChunks(totalElements, options);
+  if (numChunks <= 1) {
+    return [[start, end]];
+  }
+  const partitions = [];
+  const baseChunkSize = Math.floor(totalElements / numChunks);
+  const remainder = totalElements % numChunks;
+  let currentIndex = start;
+  for (let i = 0; i < numChunks; i++) {
+    const thisChunkSize = baseChunkSize + (i < remainder ? 1 : 0);
+    const endIndex = currentIndex + thisChunkSize;
+    partitions.push([currentIndex, endIndex]);
+    currentIndex = endIndex;
+  }
+  return partitions;
+}
+function partition2D(rows, cols, options = {}) {
+  const rowPartitions = partitionRange(0, rows, options);
+  return rowPartitions.map(([rowStart, rowEnd]) => [rowStart, rowEnd, 0, cols]);
+}
+
+// src/strategies/threshold.ts
+var DEFAULT_THRESHOLDS = {
+  matmul: 1e4,
+  // ~100x100 matrix
+  elementwise: 5e4,
+  // ~50K elements
+  reduce: 1e5,
+  // ~100K elements
+  map: 1e4,
+  // ~10K elements
+  sort: 5e3,
+  // ~5K elements
+  decomposition: 2500,
+  // ~50x50 matrix
+  general: 5e4
+  // Default ~50K
+};
+var ThresholdDispatcher = class {
+  thresholds;
+  pool;
+  constructor(thresholds = {}, pool) {
+    this.thresholds = { ...DEFAULT_THRESHOLDS, ...thresholds };
+    this.pool = pool ?? computePool;
+  }
+  /**
+   * Get threshold for a specific operation category
+   */
+  getThreshold(category) {
+    return this.thresholds[category];
+  }
+  /**
+   * Update thresholds
+   */
+  setThresholds(thresholds) {
+    this.thresholds = { ...this.thresholds, ...thresholds };
+  }
+  /**
+   * Get current threshold configuration
+   */
+  getThresholds() {
+    return { ...this.thresholds };
+  }
+  /**
+   * Determine execution mode based on operation and data size
+   */
+  dispatch(elementCount, category = "general") {
+    const threshold = this.thresholds[category];
+    const poolReady = this.pool.isReady();
+    if (!poolReady) {
+      return {
+        mode: "sequential",
+        reason: "Worker pool not initialized",
+        threshold,
+        elementCount
+      };
+    }
+    const config = this.pool.getConfig();
+    if (!config.enabled) {
+      return {
+        mode: "sequential",
+        reason: "Parallel processing disabled",
+        threshold,
+        elementCount
+      };
+    }
+    if (elementCount < threshold) {
+      return {
+        mode: "sequential",
+        reason: `Element count (${elementCount}) below threshold (${threshold})`,
+        threshold,
+        elementCount
+      };
+    }
+    return {
+      mode: "parallel",
+      reason: `Element count (${elementCount}) exceeds threshold (${threshold})`,
+      threshold,
+      elementCount
+    };
+  }
+  /**
+   * Simple boolean check for parallel execution
+   */
+  shouldParallelize(elementCount, category = "general") {
+    return this.dispatch(elementCount, category).mode === "parallel";
+  }
+  /**
+   * Calculate optimal chunk count based on operation and data size
+   */
+  calculateChunks(elementCount, category = "general") {
+    const dispatch2 = this.dispatch(elementCount, category);
+    if (dispatch2.mode === "sequential") {
+      return 1;
+    }
+    const stats = this.pool.stats();
+    const workerCount = Math.max(1, stats.totalWorkers);
+    switch (category) {
+      case "matmul":
+      case "decomposition":
+        return workerCount;
+      case "elementwise":
+      case "map":
+        return Math.min(workerCount * 2, Math.ceil(elementCount / 1e4));
+      case "reduce":
+        return Math.min(workerCount, Math.ceil(elementCount / 5e4));
+      case "sort":
+        return Math.min(workerCount, 8);
+      default:
+        return workerCount;
+    }
+  }
+};
+var thresholdDispatcher = new ThresholdDispatcher();
+function shouldParallelize2(elementCount, category = "general") {
+  return thresholdDispatcher.shouldParallelize(elementCount, category);
+}
+function dispatch(elementCount, category = "general") {
+  return thresholdDispatcher.dispatch(elementCount, category);
+}
+function calculateChunks(elementCount, category = "general") {
+  return thresholdDispatcher.calculateChunks(elementCount, category);
+}
+export {
+  ComputePool,
+  DEFAULT_POOL_CONFIG,
+  DEFAULT_THRESHOLDS,
+  ThresholdDispatcher,
+  Transfer,
+  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 as shouldChunkParallelize,
+  shouldParallelize2 as shouldParallelize,
+  thresholdDispatcher
+};