@danielsimonjr/mathts-matrix 0.1.3 → 0.1.4

package/dist/{chunk-PNKVD2UK.js → chunk-4VMDO6W2.js}

@@ -2,8 +2,13 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)

package/dist/{eig-D5URIBNL.js → eig-A5GJGSJJ.js}

@@ -3,7 +3,7 @@ import {
   eigvals,
   powerIteration
 } from "./chunk-VCPLE6ED.js";
-import "./chunk-PNKVD2UK.js";
+import "./chunk-4VMDO6W2.js";
 export {
   eig,
   eigvals,

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-import * as _danielsimonjr_mathts_parallel from '@danielsimonjr/mathts-parallel';
 import { ComputePool, ComputePoolConfig } from '@danielsimonjr/mathts-parallel';
 import * as typed_function from 'typed-function';
 
@@ -855,6 +854,96 @@ declare class JSBackend implements MatrixBackend {
  */
 declare const jsBackend: JSBackend;
 
+/**
+ * Stub type declarations for workerpool.
+ * The actual workerpool package ships raw .ts sources without pre-built .d.ts files.
+ * This stub prevents TypeScript from diving into the raw source during type-checking.
+ */
+declare module 'workerpool' {
+  export interface ExecOptions<T = unknown> {
+    on?: (payload: unknown) => void;
+    transfer?: Transferable[];
+    metadata?: T;
+  }
+
+  export interface PoolStats {
+    totalWorkers: number;
+    busyWorkers: number;
+    idleWorkers: number;
+    pendingTasks: number;
+    activeTasks: number;
+  }
+
+  export interface PoolOptions {
+    minWorkers?: number | 'max';
+    maxWorkers?: number;
+    maxQueueSize?: number;
+    workerType?: 'auto' | 'web' | 'process' | 'thread';
+    queueStrategy?: 'fifo' | 'lifo';
+    script?: string;
+    workerTerminateTimeout?: number;
+    forkArgs?: string[];
+    forkOpts?: Record<string, unknown>;
+    workerOpts?: Record<string, unknown>;
+    workerThreadOpts?: Record<string, unknown>;
+    emitStdStreams?: boolean;
+    onCreateWorker?: (arg: Record<string, unknown>) => Record<string, unknown> | void;
+    onTerminateWorker?: (arg: Record<string, unknown>) => void;
+    debugPortStart?: number;
+  }
+
+  export interface WorkerpoolPromise<T, E = unknown> extends Promise<T> {
+    readonly resolved: boolean;
+    readonly rejected: boolean;
+    readonly pending: boolean;
+    cancel(): this;
+    timeout(delay: number): this;
+  }
+
+  export type WorkerProxy<T extends Record<string, (...args: unknown[]) => unknown>> = {
+    [K in keyof T]: (...args: Parameters<T[K]>) => WorkerpoolPromise<ReturnType<T[K]>>;
+  };
+
+  export class Pool {
+    constructor(script?: string | PoolOptions, options?: PoolOptions);
+    exec<T>(
+      method: string | ((...args: unknown[]) => T),
+      params?: unknown[],
+      options?: ExecOptions
+    ): WorkerpoolPromise<T>;
+    proxy<T extends Record<string, (...args: unknown[]) => unknown>>(): Promise<WorkerProxy<T>>;
+    stats(): PoolStats;
+    terminate(force?: boolean, timeout?: number): Promise<void>;
+  }
+
+  export interface TransferDescriptor<T = unknown> {
+    message: T;
+    transfer: Transferable[];
+  }
+
+  export class Transfer<T = unknown> {
+    message: T;
+    transfer: Transferable[];
+    constructor(message: T, transfer: Transferable[]);
+  }
+
+  export class CancellationError extends Error {}
+  export class TimeoutError extends Error {}
+  export class TerminateError extends Error {}
+
+  export function pool(script?: string | PoolOptions, options?: PoolOptions): Pool;
+
+  export function worker(
+    methods?: Record<string, (...args: unknown[]) => unknown>,
+    options?: {
+      onTerminate?: (code: number | undefined) => void | PromiseLike<void>;
+      abortListenerTimeout?: number;
+    }
+  ): void;
+
+  export function workerEmit(payload: unknown): void;
+}
+
 /**
  * Configuration for ParallelBackend
  */
@@ -961,7 +1050,7 @@ declare class ParallelBackend {
     /**
      * Get pool statistics
      */
-    getStats(): _danielsimonjr_mathts_parallel.PoolStats;
+    getStats(): undefined;
     private checkDimensionsMatch;
     private checkMultiplyDimensions;
 }

package/dist/index.js

@@ -7,7 +7,7 @@ import {
   __esm,
   __export,
   __toCommonJS
-} from "./chunk-PNKVD2UK.js";
+} from "./chunk-4VMDO6W2.js";
 
 // src/types/Matrix.ts
 function isMatrix(value) {
@@ -127,6 +127,130 @@ var init_Matrix = __esm({
   }
 });
 
+// src/types/dense/arithmetic.ts
+function add(a, b) {
+  const result = new Float64Array(a.rows * a.cols);
+  for (let i = 0; i < a.rows; i++) {
+    for (let j = 0; j < a.cols; j++) {
+      result[i * a.cols + j] = a.get(i, j) + b.get(i, j);
+    }
+  }
+  return result;
+}
+function subtract(a, b) {
+  const result = new Float64Array(a.rows * a.cols);
+  for (let i = 0; i < a.rows; i++) {
+    for (let j = 0; j < a.cols; j++) {
+      result[i * a.cols + j] = a.get(i, j) - b.get(i, j);
+    }
+  }
+  return result;
+}
+function multiplyElementwise(a, b) {
+  const result = new Float64Array(a.rows * a.cols);
+  for (let i = 0; i < a.rows; i++) {
+    for (let j = 0; j < a.cols; j++) {
+      result[i * a.cols + j] = a.get(i, j) * b.get(i, j);
+    }
+  }
+  return result;
+}
+function multiply(a, b) {
+  const result = new Float64Array(a.rows * b.cols);
+  for (let i = 0; i < a.rows; i++) {
+    for (let j = 0; j < b.cols; j++) {
+      let sum3 = 0;
+      for (let k = 0; k < a.cols; k++) {
+        sum3 += a.get(i, k) * b.get(k, j);
+      }
+      result[i * b.cols + j] = sum3;
+    }
+  }
+  return result;
+}
+function scale(a, scalar) {
+  const result = new Float64Array(a.rows * a.cols);
+  for (let i = 0; i < a.rows; i++) {
+    for (let j = 0; j < a.cols; j++) {
+      result[i * a.cols + j] = a.get(i, j) * scalar;
+    }
+  }
+  return result;
+}
+function transpose(a) {
+  const result = new Float64Array(a.cols * a.rows);
+  for (let i = 0; i < a.rows; i++) {
+    for (let j = 0; j < a.cols; j++) {
+      result[j * a.rows + i] = a.get(i, j);
+    }
+  }
+  return result;
+}
+var init_arithmetic = __esm({
+  "src/types/dense/arithmetic.ts"() {
+    "use strict";
+  }
+});
+
+// src/types/dense/reduction.ts
+function sum(a) {
+  let total = 0;
+  for (let i = 0; i < a.rows; i++) {
+    for (let j = 0; j < a.cols; j++) {
+      total += a.get(i, j);
+    }
+  }
+  return total;
+}
+function mean(a) {
+  return sum(a) / a.length;
+}
+function min(a) {
+  let minVal = Infinity;
+  for (let i = 0; i < a.rows; i++) {
+    for (let j = 0; j < a.cols; j++) {
+      const val = a.get(i, j);
+      if (val < minVal) minVal = val;
+    }
+  }
+  return minVal;
+}
+function max(a) {
+  let maxVal = -Infinity;
+  for (let i = 0; i < a.rows; i++) {
+    for (let j = 0; j < a.cols; j++) {
+      const val = a.get(i, j);
+      if (val > maxVal) maxVal = val;
+    }
+  }
+  return maxVal;
+}
+function norm(a) {
+  let sumSquared = 0;
+  for (let i = 0; i < a.rows; i++) {
+    for (let j = 0; j < a.cols; j++) {
+      const val = a.get(i, j);
+      sumSquared += val * val;
+    }
+  }
+  return Math.sqrt(sumSquared);
+}
+function trace(a) {
+  if (!a.isSquare) {
+    throw new Error("Trace is only defined for square matrices");
+  }
+  let traceSum = 0;
+  for (let i = 0; i < a.rows; i++) {
+    traceSum += a.get(i, i);
+  }
+  return traceSum;
+}
+var init_reduction = __esm({
+  "src/types/dense/reduction.ts"() {
+    "use strict";
+  }
+});
+
 // src/types/SparseMatrix.ts
 var SparseMatrix_exports = {};
 __export(SparseMatrix_exports, {
@@ -547,9 +671,9 @@ var init_SparseMatrix = __esm({
               entries.push({ row: i, col: otherCol, value: other._data[otherIdx] });
               otherIdx++;
             } else {
-              const sum2 = this._data[thisIdx] + other._data[otherIdx];
-              if (sum2 !== 0) {
-                entries.push({ row: i, col: thisCol, value: sum2 });
+              const sum3 = this._data[thisIdx] + other._data[otherIdx];
+              if (sum3 !== 0) {
+                entries.push({ row: i, col: thisCol, value: sum3 });
               }
               thisIdx++;
               otherIdx++;
@@ -602,13 +726,13 @@ var init_SparseMatrix = __esm({
           const rowStart = this._rowPointers[i];
           const rowEnd = this._rowPointers[i + 1];
           for (let j = 0; j < other.cols; j++) {
-            let sum2 = 0;
+            let sum3 = 0;
             for (let k = rowStart; k < rowEnd; k++) {
               const col = this._colIndices[k];
-              sum2 += this._data[k] * other.get(col, j);
+              sum3 += this._data[k] * other.get(col, j);
             }
-            if (sum2 !== 0) {
-              entries.push({ row: i, col: j, value: sum2 });
+            if (sum3 !== 0) {
+              entries.push({ row: i, col: j, value: sum3 });
             }
           }
         }
@@ -707,11 +831,11 @@ var init_SparseMatrix = __esm({
         if (!this.isSquare) {
           throw new Error("Trace is only defined for square matrices");
         }
-        let sum2 = 0;
+        let sum3 = 0;
         for (let i = 0; i < this.rows; i++) {
-          sum2 += this.get(i, i);
+          sum3 += this.get(i, i);
         }
-        return sum2;
+        return sum3;
       }
       // =========================================================================
       // Conversion Methods
@@ -857,6 +981,8 @@ var init_DenseMatrix = __esm({
   "src/types/DenseMatrix.ts"() {
     "use strict";
     init_Matrix();
+    init_arithmetic();
+    init_reduction();
     DenseMatrix = class _DenseMatrix extends Matrix {
       type = "DenseMatrix";
       rows;
@@ -1121,80 +1247,40 @@ var init_DenseMatrix = __esm({
        */
       add(other) {
         this.checkDimensionsMatch(other);
-        const result = new Float64Array(this.rows * this.cols);
-        for (let i = 0; i < this.rows; i++) {
-          for (let j = 0; j < this.cols; j++) {
-            result[i * this.cols + j] = this.get(i, j) + other.get(i, j);
-          }
-        }
-        return new _DenseMatrix(this.rows, this.cols, result);
+        return new _DenseMatrix(this.rows, this.cols, add(this, other));
       }
       /**
        * Matrix subtraction
        */
       subtract(other) {
         this.checkDimensionsMatch(other);
-        const result = new Float64Array(this.rows * this.cols);
-        for (let i = 0; i < this.rows; i++) {
-          for (let j = 0; j < this.cols; j++) {
-            result[i * this.cols + j] = this.get(i, j) - other.get(i, j);
-          }
-        }
-        return new _DenseMatrix(this.rows, this.cols, result);
+        return new _DenseMatrix(this.rows, this.cols, subtract(this, other));
       }
       /**
        * Element-wise multiplication (Hadamard product)
        */
       multiplyElementwise(other) {
         this.checkDimensionsMatch(other);
-        const result = new Float64Array(this.rows * this.cols);
-        for (let i = 0; i < this.rows; i++) {
-          for (let j = 0; j < this.cols; j++) {
-            result[i * this.cols + j] = this.get(i, j) * other.get(i, j);
-          }
-        }
-        return new _DenseMatrix(this.rows, this.cols, result);
+        return new _DenseMatrix(this.rows, this.cols, multiplyElementwise(this, other));
       }
       /**
        * Matrix multiplication
        */
       multiply(other) {
         this.checkMultiplyDimensions(other);
-        const result = new Float64Array(this.rows * other.cols);
-        for (let i = 0; i < this.rows; i++) {
-          for (let j = 0; j < other.cols; j++) {
-            let sum2 = 0;
-            for (let k = 0; k < this.cols; k++) {
-              sum2 += this.get(i, k) * other.get(k, j);
-            }
-            result[i * other.cols + j] = sum2;
-          }
-        }
-        return new _DenseMatrix(this.rows, other.cols, result);
+        return new _DenseMatrix(this.rows, other.cols, multiply(this, other));
       }
       /**
        * Scalar multiplication
        */
       scale(scalar) {
-        const result = new Float64Array(this.rows * this.cols);
-        for (let i = 0; i < this.rows; i++) {
-          for (let j = 0; j < this.cols; j++) {
-            result[i * this.cols + j] = this.get(i, j) * scalar;
-          }
-        }
-        return new _DenseMatrix(this.rows, this.cols, result);
+        return new _DenseMatrix(this.rows, this.cols, scale(this, scalar));
       }
       /**
        * Matrix transpose
        */
       transpose() {
-        const result = new Float64Array(this.cols * this.rows);
-        for (let i = 0; i < this.rows; i++) {
-          for (let j = 0; j < this.cols; j++) {
-            result[j * this.rows + i] = this.get(i, j);
-          }
-        }
-        return new _DenseMatrix(this.cols, this.rows, result);
+        return new _DenseMatrix(this.cols, this.rows, transpose(this));
       }
       /**
        * Negate all elements
@@ -1209,71 +1295,37 @@ var init_DenseMatrix = __esm({
        * Sum of all elements
        */
       sum() {
-        let total = 0;
-        for (let i = 0; i < this.rows; i++) {
-          for (let j = 0; j < this.cols; j++) {
-            total += this.get(i, j);
-          }
-        }
-        return total;
+        return sum(this);
       }
       /**
        * Mean of all elements
        */
       mean() {
-        return this.sum() / this.length;
+        return mean(this);
       }
       /**
        * Minimum element
        */
       min() {
-        let minVal = Infinity;
-        for (let i = 0; i < this.rows; i++) {
-          for (let j = 0; j < this.cols; j++) {
-            const val = this.get(i, j);
-            if (val < minVal) minVal = val;
-          }
-        }
-        return minVal;
+        return min(this);
       }
       /**
        * Maximum element
        */
       max() {
-        let maxVal = -Infinity;
-        for (let i = 0; i < this.rows; i++) {
-          for (let j = 0; j < this.cols; j++) {
-            const val = this.get(i, j);
-            if (val > maxVal) maxVal = val;
-          }
-        }
-        return maxVal;
+        return max(this);
       }
       /**
        * Frobenius norm (sqrt of sum of squared elements)
        */
       norm() {
-        let sum2 = 0;
-        for (let i = 0; i < this.rows; i++) {
-          for (let j = 0; j < this.cols; j++) {
-            const val = this.get(i, j);
-            sum2 += val * val;
-          }
-        }
-        return Math.sqrt(sum2);
+        return norm(this);
       }
       /**
        * Trace (sum of diagonal elements)
        */
       trace() {
-        if (!this.isSquare) {
-          throw new Error("Trace is only defined for square matrices");
-        }
-        let sum2 = 0;
-        for (let i = 0; i < this.rows; i++) {
-          sum2 += this.get(i, i);
-        }
-        return sum2;
+        return trace(this);
       }
       // =========================================================================
       // Conversion Methods
@@ -1693,13 +1745,13 @@ var JSBackend = class {
     if (a.length !== b.length) {
       throw new Error(`Vector lengths must match: ${a.length} vs ${b.length}`);
     }
-    let sum2 = 0;
+    let sum3 = 0;
     const aValues = Array.from(a.values());
     const bValues = Array.from(b.values());
     for (let i = 0; i < aValues.length; i++) {
-      sum2 += aValues[i] * bValues[i];
+      sum3 += aValues[i] * bValues[i];
     }
-    return sum2;
+    return sum3;
   }
   // =========================================================================
   // Utility Methods
@@ -1929,13 +1981,13 @@ var ParallelBackend = class {
     }
     const elementCount = a.length;
     if (!this.shouldParallelize(elementCount) || !this.isReady()) {
-      let sum2 = 0;
+      let sum3 = 0;
       const aValues = Array.from(a.values());
       const bValues = Array.from(b.values());
       for (let i = 0; i < aValues.length; i++) {
-        sum2 += aValues[i] * bValues[i];
+        sum3 += aValues[i] * bValues[i];
       }
-      return sum2;
+      return sum3;
     }
     const aData = a.toFloat64Array();
     const bData = b.toFloat64Array();
@@ -2459,7 +2511,7 @@ var WASMBackend = class {
       Date
     };
     const isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
-    const { loadWasmManifest, verifyWasmIntegrity } = await import("./integrity-P3NYUEMQ.js");
+    const { loadWasmManifest, verifyWasmIntegrity } = await import("./integrity-X3CLNVGW.js");
     let instance;
     if (isNode) {
       const fs = await import("fs");
@@ -2823,15 +2875,15 @@ var WASMBackend = class {
     }
     const minDim = Math.min(m, n);
     for (let k = 0; k < minDim; k++) {
-      let norm3 = 0;
+      let norm4 = 0;
       for (let i = k; i < m; i++) {
         const val = r[i * n + k];
-        norm3 += val * val;
+        norm4 += val * val;
       }
-      norm3 = Math.sqrt(norm3);
-      if (norm3 < 1e-14) continue;
+      norm4 = Math.sqrt(norm4);
+      if (norm4 < 1e-14) continue;
       const sign = r[k * n + k] >= 0 ? 1 : -1;
-      const u1 = r[k * n + k] + sign * norm3;
+      const u1 = r[k * n + k] + sign * norm4;
       const v = new Float64Array(m - k);
       v[0] = 1;
       for (let i = 1; i < m - k; i++) v[i] = r[(k + i) * n + k] / u1;
@@ -2899,14 +2951,14 @@ var WASMBackend = class {
     for (let col = 0; col < n; col++) {
       for (let i = 0; i < n; i++) b[i] = i === col ? 1 : 0;
       for (let i = 0; i < n; i++) {
-        let sum2 = b[perm[i]];
-        for (let j = 0; j < i; j++) sum2 -= luData[i * n + j] * x[j];
-        x[i] = sum2;
+        let sum3 = b[perm[i]];
+        for (let j = 0; j < i; j++) sum3 -= luData[i * n + j] * x[j];
+        x[i] = sum3;
       }
       for (let i = n - 1; i >= 0; i--) {
-        let sum2 = x[i];
-        for (let j = i + 1; j < n; j++) sum2 -= luData[i * n + j] * x[j];
-        x[i] = sum2 / luData[i * n + i];
+        let sum3 = x[i];
+        for (let j = i + 1; j < n; j++) sum3 -= luData[i * n + j] * x[j];
+        x[i] = sum3 / luData[i * n + i];
       }
       for (let i = 0; i < n; i++) result[i * n + col] = x[i];
     }
@@ -2982,17 +3034,17 @@ var WASMBackend = class {
     const l = new Float64Array(n * n);
     for (let i = 0; i < n; i++) {
       for (let j = 0; j <= i; j++) {
-        let sum2 = aData[i * n + j];
+        let sum3 = aData[i * n + j];
         for (let k = 0; k < j; k++) {
-          sum2 -= l[i * n + k] * l[j * n + k];
+          sum3 -= l[i * n + k] * l[j * n + k];
         }
         if (i === j) {
-          if (sum2 <= 0) {
+          if (sum3 <= 0) {
             return { l: DenseMatrix.zeros(n, n), positiveDefinite: false };
           }
-          l[i * n + j] = Math.sqrt(sum2);
+          l[i * n + j] = Math.sqrt(sum3);
         } else {
-          l[i * n + j] = sum2 / l[j * n + j];
+          l[i * n + j] = sum3 / l[j * n + j];
         }
       }
     }
@@ -5005,7 +5057,7 @@ var RustWasmLoader = class _RustWasmLoader {
     try {
       const path = wasmPath || await this.findWasmPath();
       const isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
-      const { loadWasmManifest, verifyWasmIntegrity } = await import("./integrity-P3NYUEMQ.js");
+      const { loadWasmManifest, verifyWasmIntegrity } = await import("./integrity-X3CLNVGW.js");
       let binarySize = 0;
       if (isNode) {
         const loadStart = performance.now();
@@ -6151,7 +6203,7 @@ var WasmLoader = class _WasmLoader {
     if (this.compiledModule) return;
     const path = wasmPath || await this.getDefaultWasmPath();
     const startTime = performance.now();
-    const { loadWasmManifest, verifyWasmIntegrity } = await import("./integrity-P3NYUEMQ.js");
+    const { loadWasmManifest, verifyWasmIntegrity } = await import("./integrity-X3CLNVGW.js");
     if (this.isNode) {
       const fs = await import("fs");
       const { promisify } = await import("util");
@@ -6229,7 +6281,7 @@ var WasmLoader = class _WasmLoader {
     const fs = await import("fs");
     const { promisify } = await import("util");
     const readFile = promisify(fs.readFile);
-    const { verifyWasmIntegrity } = await import("./integrity-P3NYUEMQ.js");
+    const { verifyWasmIntegrity } = await import("./integrity-X3CLNVGW.js");
     const readStart = performance.now();
     const buffer = await readFile(path);
     const readEnd = performance.now();
@@ -6250,7 +6302,7 @@ var WasmLoader = class _WasmLoader {
     return instance.exports;
   }
   async loadBrowserWasm(path, totalStart) {
-    const { loadWasmManifest, verifyWasmIntegrity } = await import("./integrity-P3NYUEMQ.js");
+    const { loadWasmManifest, verifyWasmIntegrity } = await import("./integrity-X3CLNVGW.js");
     const manifest = await loadWasmManifest(path);
     if (!manifest && typeof WebAssembly.instantiateStreaming === "function") {
       const instStart2 = performance.now();
@@ -6595,9 +6647,9 @@ var WasmLoader = class _WasmLoader {
    */
   getPoolStats() {
     const f64InUse = this.float64Pool.filter((e) => e.inUse).length;
-    const f64Bytes = this.float64Pool.reduce((sum2, e) => sum2 + e.size, 0);
+    const f64Bytes = this.float64Pool.reduce((sum3, e) => sum3 + e.size, 0);
     const i32InUse = this.int32Pool.filter((e) => e.inUse).length;
-    const i32Bytes = this.int32Pool.reduce((sum2, e) => sum2 + e.size, 0);
+    const i32Bytes = this.int32Pool.reduce((sum3, e) => sum3 + e.size, 0);
     return {
       float64: {
         total: this.float64Pool.length,
@@ -6771,11 +6823,11 @@ function svdStep(d, e, U, V, start, end) {
   const a = dm1 * dm1 + (end > start + 1 ? e[end - 2] * e[end - 2] : 0);
   const b = dm1 * em1;
   const c = dn * dn + em1 * em1;
-  const trace2 = a + c;
+  const trace3 = a + c;
   const det = a * c - b * b;
-  const disc = Math.sqrt(Math.max(0, trace2 * trace2 / 4 - det));
-  const e1 = trace2 / 2 + disc;
-  const e2 = trace2 / 2 - disc;
+  const disc = Math.sqrt(Math.max(0, trace3 * trace3 / 4 - det));
+  const e1 = trace3 / 2 + disc;
+  const e2 = trace3 / 2 - disc;
   const shift = Math.abs(e1 - c) < Math.abs(e2 - c) ? e1 : e2;
   let f = d[start] * d[start] - shift;
   let g = d[start] * e[start];
@@ -6942,11 +6994,11 @@ function pinv(matrix2, options) {
   const result = Array.from({ length: n }, () => new Array(m).fill(0));
   for (let i = 0; i < n; i++) {
     for (let j = 0; j < m; j++) {
-      let sum2 = 0;
+      let sum3 = 0;
       for (let l = 0; l < k; l++) {
-        sum2 += V[i][l] * Sinv[l] * U[j][l];
+        sum3 += V[i][l] * Sinv[l] * U[j][l];
       }
-      result[i][j] = sum2;
+      result[i][j] = sum3;
     }
   }
   return result;
@@ -6959,11 +7011,11 @@ function lowRankApprox(matrix2, r, options) {
   const result = Array.from({ length: m }, () => new Array(n).fill(0));
   for (let i = 0; i < m; i++) {
     for (let j = 0; j < n; j++) {
-      let sum2 = 0;
+      let sum3 = 0;
       for (let l = 0; l < k; l++) {
-        sum2 += U[i][l] * S[l] * V[j][l];
+        sum3 += U[i][l] * S[l] * V[j][l];
       }
-      result[i][j] = sum2;
+      result[i][j] = sum3;
     }
   }
   return result;
@@ -6980,13 +7032,13 @@ function norm2(matrix2, options) {
   return S[0] || 0;
 }
 function normFro(matrix2) {
-  let sum2 = 0;
+  let sum3 = 0;
   for (const row2 of matrix2) {
     for (const val of row2) {
-      sum2 += val * val;
+      sum3 += val * val;
     }
   }
-  return Math.sqrt(sum2);
+  return Math.sqrt(sum3);
 }
 
 // src/operations/eig-wasm.ts
@@ -7100,7 +7152,7 @@ async function spectralRadiusWasm(matrix2, options) {
   const n = matrix2.length;
   const wasmModule = wasmLoader.getModule();
   if (!wasmModule || n < WASM_EIG_THRESHOLD) {
-    const { powerIteration: powerIteration2 } = await import("./eig-D5URIBNL.js");
+    const { powerIteration: powerIteration2 } = await import("./eig-A5GJGSJJ.js");
     const result = powerIteration2(matrix2, options);
     return Math.abs(result.value);
   }
@@ -7119,7 +7171,7 @@ async function spectralRadiusWasm(matrix2, options) {
     );
     return radius;
   } catch {
-    const { powerIteration: powerIteration2 } = await import("./eig-D5URIBNL.js");
+    const { powerIteration: powerIteration2 } = await import("./eig-A5GJGSJJ.js");
     const result = powerIteration2(matrix2, options);
     return Math.abs(result.value);
   } finally {
@@ -7209,11 +7261,11 @@ function pinv2(A, opts) {
   const pinvData = new Float64Array(n * m);
   for (let i = 0; i < n; i++) {
     for (let j = 0; j < m; j++) {
-      let sum2 = 0;
+      let sum3 = 0;
       for (let l = 0; l < k; l++) {
-        sum2 += V[i][l] * Sinv[l] * U[j][l];
+        sum3 += V[i][l] * Sinv[l] * U[j][l];
       }
-      pinvData[i * m + j] = sum2;
+      pinvData[i * m + j] = sum3;
     }
   }
   return new DenseMatrix(n, m, pinvData);
@@ -7260,11 +7312,11 @@ function qr(A, opts) {
       R[q * n + j] += dot;
       for (let i = 0; i < m; i++) Qcm[i + j * m] -= dot * Qcm[i + q * m];
     }
-    let norm3 = 0;
-    for (let i = 0; i < m; i++) norm3 += Qcm[i + j * m] * Qcm[i + j * m];
-    norm3 = Math.sqrt(norm3);
-    R[j * n + j] = norm3;
-    if (norm3 < 1e-14) {
+    let norm4 = 0;
+    for (let i = 0; i < m; i++) norm4 += Qcm[i + j * m] * Qcm[i + j * m];
+    norm4 = Math.sqrt(norm4);
+    R[j * n + j] = norm4;
+    if (norm4 < 1e-14) {
       for (let trial = 0; trial < m; trial++) {
         for (let i = 0; i < m; i++) Qcm[i + j * m] = i === trial ? 1 : 0;
         for (let pass = 0; pass < 2; pass++) {
@@ -7283,7 +7335,7 @@ function qr(A, opts) {
         }
       }
     } else {
-      for (let i = 0; i < m; i++) Qcm[i + j * m] /= norm3;
+      for (let i = 0; i < m; i++) Qcm[i + j * m] /= norm4;
     }
     for (let c = j + 1; c < n; c++) {
       let dot = 0;
@@ -7302,11 +7354,11 @@ function qr(A, opts) {
           for (let i = 0; i < m; i++) Qcm[i + nextCol * m] -= dot * Qcm[i + q * m];
         }
       }
-      let norm3 = 0;
-      for (let i = 0; i < m; i++) norm3 += Qcm[i + nextCol * m] * Qcm[i + nextCol * m];
-      norm3 = Math.sqrt(norm3);
-      if (norm3 > 1e-12) {
-        for (let i = 0; i < m; i++) Qcm[i + nextCol * m] /= norm3;
+      let norm4 = 0;
+      for (let i = 0; i < m; i++) norm4 += Qcm[i + nextCol * m] * Qcm[i + nextCol * m];
+      norm4 = Math.sqrt(norm4);
+      if (norm4 > 1e-12) {
+        for (let i = 0; i < m; i++) Qcm[i + nextCol * m] /= norm4;
         nextCol++;
       }
     }
@@ -7395,21 +7447,21 @@ function cholesky(A) {
   const lData = new Float64Array(n * n);
   for (let i = 0; i < n; i++) {
     for (let j = 0; j <= i; j++) {
-      let sum2 = src[i * n + j];
+      let sum3 = src[i * n + j];
       for (let k = 0; k < j; k++) {
-        sum2 -= lData[i * n + k] * lData[j * n + k];
+        sum3 -= lData[i * n + k] * lData[j * n + k];
       }
       if (i === j) {
-        if (sum2 <= 0) {
+        if (sum3 <= 0) {
           throw new Error("cholesky: matrix is not positive definite");
         }
-        lData[i * n + j] = Math.sqrt(sum2);
+        lData[i * n + j] = Math.sqrt(sum3);
       } else {
         const ljj = lData[j * n + j];
         if (ljj === 0) {
           throw new Error("cholesky: matrix is not positive definite");
         }
-        lData[i * n + j] = sum2 / ljj;
+        lData[i * n + j] = sum3 / ljj;
       }
     }
   }
@@ -7668,14 +7720,14 @@ function qrStepSingle(H, Q, start, end) {
   const b = H[end - 1][end];
   const c = H[end][end - 1];
   const d = H[end][end];
-  const trace2 = a + d;
+  const trace3 = a + d;
   const det = a * d - b * c;
-  const disc = trace2 * trace2 - 4 * det;
+  const disc = trace3 * trace3 - 4 * det;
   let shift;
   if (disc >= 0) {
     const sqrtDisc = Math.sqrt(disc);
-    const e1 = (trace2 + sqrtDisc) / 2;
-    const e2 = (trace2 - sqrtDisc) / 2;
+    const e1 = (trace3 + sqrtDisc) / 2;
+    const e2 = (trace3 - sqrtDisc) / 2;
     shift = Math.abs(e1 - d) < Math.abs(e2 - d) ? e1 : e2;
   } else {
     shift = d;
@@ -7749,8 +7801,8 @@ function schurRaw(A, maxIterations, tolerance) {
   while (end > 0 && iter < maxIterations) {
     let start = end;
     while (start > 0) {
-      const scale = Math.abs(H[start - 1][start - 1]) + Math.abs(H[start][start]);
-      if (Math.abs(H[start][start - 1]) <= tolerance * scale) {
+      const scale2 = Math.abs(H[start - 1][start - 1]) + Math.abs(H[start][start]);
+      if (Math.abs(H[start][start - 1]) <= tolerance * scale2) {
         H[start][start - 1] = 0;
         break;
       }
@@ -7822,7 +7874,7 @@ function matMul2(A, B2) {
     }
   return C;
 }
-function transpose(A) {
+function transpose2(A) {
   const m = A.length;
   const n = A[0].length;
   return Array.from({ length: n }, (_, j) => Array.from({ length: m }, (_2, i) => A[i][j]));
@@ -7983,10 +8035,10 @@ function sqrtUpperTriangular(T) {
   }
   for (let j = 1; j < n; j++) {
     for (let i = j - 1; i >= 0; i--) {
-      let sum2 = 0;
-      for (let k = i + 1; k < j; k++) sum2 += U[i][k] * U[k][j];
+      let sum3 = 0;
+      for (let k = i + 1; k < j; k++) sum3 += U[i][k] * U[k][j];
       const denom = U[i][i] + U[j][j];
-      U[i][j] = Math.abs(denom) < 1e-14 ? 0 : (T[i][j] - sum2) / denom;
+      U[i][j] = Math.abs(denom) < 1e-14 ? 0 : (T[i][j] - sum3) / denom;
     }
   }
   return U;
@@ -8038,8 +8090,8 @@ function logmSchur(A, tol) {
   if (norm12(MminI) >= tol) return null;
   let logT = logPade(MminI);
   if (numSqrt > 0) {
-    const scale = Math.pow(2, numSqrt);
-    logT = logT.map((row2) => row2.map((v) => v * scale));
+    const scale2 = Math.pow(2, numSqrt);
+    logT = logT.map((row2) => row2.map((v) => v * scale2));
   }
   const Qt = transposeArr(Q);
   return matMulArr(matMulArr(Q, logT), Qt);
@@ -8075,7 +8127,7 @@ function logmEig(A) {
     }
   }
   const V = vectors;
-  const Q = transpose(V);
+  const Q = transpose2(V);
   const Qinv = matInv(Q);
   if (Qinv === null) {
     throw new Error(
@@ -8147,7 +8199,7 @@ function matMul3(A, B2) {
     }
   return C;
 }
-function transpose2(A) {
+function transpose3(A) {
   const m = A.length;
   const n = A[0].length;
   return Array.from({ length: n }, (_, j) => Array.from({ length: m }, (_2, i) => A[i][j]));
@@ -8200,13 +8252,13 @@ function gramSchmidt(A) {
       for (let i = 0; i < m; i++) dot += Q[i][k] * v[i];
       for (let i = 0; i < m; i++) v[i] -= dot * Q[i][k];
     }
-    let norm3 = 0;
-    for (let i = 0; i < m; i++) norm3 += v[i] * v[i];
-    norm3 = Math.sqrt(norm3);
-    if (norm3 < 1e-14) {
+    let norm4 = 0;
+    for (let i = 0; i < m; i++) norm4 += v[i] * v[i];
+    norm4 = Math.sqrt(norm4);
+    if (norm4 < 1e-14) {
       for (let i = 0; i < m; i++) Q[i][j] = i === j ? 1 : 0;
     } else {
-      for (let i = 0; i < m; i++) Q[i][j] = v[i] / norm3;
+      for (let i = 0; i < m; i++) Q[i][j] = v[i] / norm4;
     }
   }
   return Q;
@@ -8224,9 +8276,9 @@ function sqrtmSymmetric(A) {
   }
   const Ynewton = sqrtmNewton(Asym);
   if (Ynewton !== null) return Ynewton;
-  const Qraw = transpose2(vectors);
+  const Qraw = transpose3(vectors);
   const Q = gramSchmidt(Qraw);
-  const Qt = transpose2(Q);
+  const Qt = transpose3(Q);
   const Dsqrt = eye5(n);
   for (let i = 0; i < n; i++) Dsqrt[i][i] = Math.sqrt(Math.max(values[i].re, 0));
   return matMul3(matMul3(Q, Dsqrt), Qt);
@@ -8272,7 +8324,7 @@ function sqrtmGeneral(A) {
   const Ynewton = sqrtmNewton(A);
   if (Ynewton !== null) return Ynewton;
   const V = vectors;
-  const Q = transpose2(V);
+  const Q = transpose3(V);
   const Qinv = matInv2(Q);
   if (Qinv === null) {
     throw new Error(
@@ -8341,9 +8393,9 @@ function sqrtmQuasiTriangular(T) {
         const sk = blockSize[bk];
         for (let ii = 0; ii < si; ii++) {
           for (let jj = 0; jj < sj; jj++) {
-            let sum2 = 0;
-            for (let kk = 0; kk < sk; kk++) sum2 += U[ri + ii][rk + kk] * U[rk + kk][rj + jj];
-            RHS[ii][jj] -= sum2;
+            let sum3 = 0;
+            for (let kk = 0; kk < sk; kk++) sum3 += U[ri + ii][rk + kk] * U[rk + kk][rj + jj];
+            RHS[ii][jj] -= sum3;
           }
         }
       }
@@ -8479,7 +8531,7 @@ var diag = mathTyped("diag", {
 var random = mathTyped("random", {
   "number, number": (rows, cols) => DenseMatrix.random(rows, cols)
 });
-var add = mathTyped("add", {
+var add2 = mathTyped("add", {
   // Matrix + Matrix
   "DenseMatrix, DenseMatrix": (a, b) => a.add(b),
   // Matrix + scalar
@@ -8489,7 +8541,7 @@ var add = mathTyped("add", {
   // Fallback for number + number (delegates to core)
   "number, number": (a, b) => a + b
 });
-var subtract = mathTyped("subtract", {
+var subtract2 = mathTyped("subtract", {
   // Matrix - Matrix
   "DenseMatrix, DenseMatrix": (a, b) => a.subtract(b),
   // Matrix - scalar
@@ -8499,7 +8551,7 @@ var subtract = mathTyped("subtract", {
   // Fallback for number - number
   "number, number": (a, b) => a - b
 });
-var multiply = mathTyped("multiply", {
+var multiply2 = mathTyped("multiply", {
   // Matrix * Matrix (matmul)
   "DenseMatrix, DenseMatrix": (a, b) => a.multiply(b),
   // Matrix * scalar (scale)
@@ -8525,32 +8577,32 @@ var unaryMinus = mathTyped("unaryMinus", {
   DenseMatrix: (a) => a.negate(),
   number: (a) => -a
 });
-var transpose3 = mathTyped("transpose", {
+var transpose4 = mathTyped("transpose", {
   DenseMatrix: (a) => a.transpose()
 });
-var sum = mathTyped("sum", {
+var sum2 = mathTyped("sum", {
   DenseMatrix: (a) => a.sum(),
   Array: (arr) => arr.reduce((acc, v) => acc + v, 0)
 });
-var mean = mathTyped("mean", {
+var mean2 = mathTyped("mean", {
   DenseMatrix: (a) => a.mean(),
   Array: (arr) => arr.reduce((acc, v) => acc + v, 0) / arr.length
 });
-var min = mathTyped("min", {
+var min2 = mathTyped("min", {
   DenseMatrix: (a) => a.min(),
   Array: (arr) => Math.min(...arr),
   "number, number": (a, b) => Math.min(a, b)
 });
-var max = mathTyped("max", {
+var max2 = mathTyped("max", {
   DenseMatrix: (a) => a.max(),
   Array: (arr) => Math.max(...arr),
   "number, number": (a, b) => Math.max(a, b)
 });
-var norm = mathTyped("norm", {
+var norm3 = mathTyped("norm", {
   DenseMatrix: (a) => a.norm(),
   Array: (arr) => Math.sqrt(arr.reduce((acc, v) => acc + v * v, 0))
 });
-var trace = mathTyped("trace", {
+var trace2 = mathTyped("trace", {
   DenseMatrix: (a) => a.trace()
 });
 var abs = mathTyped("abs", {
@@ -8608,20 +8660,20 @@ var typedMatrixOperations = {
   diag,
   random,
   // Arithmetic
-  add,
-  subtract,
-  multiply,
+  add: add2,
+  subtract: subtract2,
+  multiply: multiply2,
   dotMultiply,
   divide,
   unaryMinus,
-  transpose: transpose3,
+  transpose: transpose4,
   // Reductions
-  sum,
-  mean,
-  min,
-  max,
-  norm,
-  trace,
+  sum: sum2,
+  mean: mean2,
+  min: min2,
+  max: max2,
+  norm: norm3,
+  trace: trace2,
   // Element-wise
   abs,
   sqrt,
@@ -8666,8 +8718,8 @@ async function pNorm(data) {
 async function pDistance(a, b) {
   return computePool2.distance(a, b);
 }
-async function pHistogram(data, bins, min2, max2) {
-  return computePool2.histogram(data, bins, min2, max2);
+async function pHistogram(data, bins, min3, max3) {
+  return computePool2.histogram(data, bins, min3, max3);
 }
 async function pAbs(data) {
   return computePool2.abs(data);
@@ -8918,11 +8970,11 @@ var parallelMatrixSum = mathTyped2("parallelMatrixSum", {
     return result.result;
   },
   Array: (arr) => {
-    let sum2 = 0;
+    let sum3 = 0;
     for (let i = 0; i < arr.length; i++) {
-      sum2 += arr[i];
+      sum3 += arr[i];
     }
-    return sum2;
+    return sum3;
   }
 });
 var parallelMatrixMean = mathTyped2("parallelMatrixMean", {
@@ -8937,11 +8989,11 @@ var parallelMatrixMean = mathTyped2("parallelMatrixMean", {
   },
   Array: (arr) => {
     if (arr.length === 0) return NaN;
-    let sum2 = 0;
+    let sum3 = 0;
     for (let i = 0; i < arr.length; i++) {
-      sum2 += arr[i];
+      sum3 += arr[i];
     }
-    return sum2 / arr.length;
+    return sum3 / arr.length;
   }
 });
 var parallelMatrixMin = mathTyped2("parallelMatrixMin", {
@@ -9017,11 +9069,11 @@ var parallelMatrixNorm = mathTyped2("parallelMatrixNorm", {
     return result.result;
   },
   Array: (arr) => {
-    let sum2 = 0;
+    let sum3 = 0;
     for (let i = 0; i < arr.length; i++) {
-      sum2 += arr[i] * arr[i];
+      sum3 += arr[i] * arr[i];
     }
-    return Math.sqrt(sum2);
+    return Math.sqrt(sum3);
   }
 });
 var parallelMatrixDot = mathTyped2("parallelMatrixDot", {
@@ -9036,12 +9088,12 @@ var parallelMatrixDot = mathTyped2("parallelMatrixDot", {
     return result.result;
   },
   "Array, Array": (a, b) => {
-    let sum2 = 0;
+    let sum3 = 0;
     const n = Math.min(a.length, b.length);
     for (let i = 0; i < n; i++) {
-      sum2 += a[i] * b[i];
+      sum3 += a[i] * b[i];
     }
-    return sum2;
+    return sum3;
   }
 });
 var parallelMatrixTrace = mathTyped2("parallelMatrixTrace", {
@@ -9222,8 +9274,8 @@ var parallelMatrixHistogram = mathTyped2("parallelMatrixHistogram", {
     const result = await pHistogram(a, bins);
     return result.result;
   },
-  "Float64Array, number, number, number": async (a, bins, min2, max2) => {
-    const result = await pHistogram(a, bins, min2, max2);
+  "Float64Array, number, number, number": async (a, bins, min3, max3) => {
+    const result = await pHistogram(a, bins, min3, max3);
     return result.result;
   }
 });
@@ -9302,7 +9354,7 @@ export {
   SyncManager,
   WASMBackend,
   abs,
-  add,
+  add2 as add,
   backendManager,
   backendRegistry,
   cholesky,
@@ -9354,11 +9406,11 @@ export {
   pinv2 as matrixPinv,
   matrixSchur,
   matrixSqrtm,
-  max,
-  mean,
-  min,
-  multiply,
-  norm,
+  max2 as max,
+  mean2 as mean,
+  min2 as min,
+  multiply2 as multiply,
+  norm3 as norm,
   norm2,
   normFro,
   ones,
@@ -9417,13 +9469,13 @@ export {
   sqrt,
   square,
   subset,
-  subtract,
-  sum,
+  subtract2 as subtract,
+  sum2 as sum,
   svd,
   svdWasm,
   terminateParallelMatrix,
-  trace,
-  transpose3 as transpose,
+  trace2 as trace,
+  transpose4 as transpose,
   typedMatrixOperations,
   unaryMinus,
   wasmBackend,

package/dist/{integrity-P3NYUEMQ.js → integrity-X3CLNVGW.js}

@@ -1,4 +1,4 @@
-import "./chunk-PNKVD2UK.js";
+import "./chunk-4VMDO6W2.js";
 
 // src/backends/wasm/integrity.ts
 var ALGO = "sha384";

package/package.json

@@ -1,60 +1,60 @@
-{
-  "name": "@danielsimonjr/mathts-matrix",
-  "version": "0.1.3",
-  "description": "Matrix operations for MathTS with WASM/WebGPU backend support",
-  "author": "Daniel Simon Jr.",
-  "license": "MIT",
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean",
-    "dev": "tsup src/index.ts --format esm --dts --watch",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint src --ext .ts",
-    "lint:fix": "eslint src --ext .ts --fix",
-    "clean": "rm -rf dist",
-    "build:prod": "tsup src/index.ts --format esm --dts --clean --minify --treeshake"
-  },
-  "dependencies": {
-    "@danielsimonjr/mathts-core": "*",
-    "@danielsimonjr/mathts-parallel": "*"
-  },
-  "devDependencies": {
-    "@types/node": "^25.5.2",
-    "@webgpu/types": "^0.1.67",
-    "tsup": "^8.0.0",
-    "typescript": "^5.3.0",
-    "vitest": "^4.1.5"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/danielsimonjr/mathts",
-    "directory": "matrix"
-  },
-  "keywords": [
-    "math",
-    "matrix",
-    "linear-algebra",
-    "typescript",
-    "wasm",
-    "webgpu"
-  ]
-}
+{
+  "name": "@danielsimonjr/mathts-matrix",
+  "version": "0.1.4",
+  "description": "Matrix operations for MathTS with WASM/WebGPU backend support",
+  "author": "Daniel Simon Jr.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "clean": "rm -rf dist",
+    "build:prod": "tsup src/index.ts --format esm --dts --clean --minify --treeshake"
+  },
+  "dependencies": {
+    "@danielsimonjr/mathts-core": "0.1.3",
+    "@danielsimonjr/mathts-parallel": "0.2.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "@webgpu/types": "^0.1.67",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^4.1.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/danielsimonjr/mathts",
+    "directory": "matrix"
+  },
+  "keywords": [
+    "math",
+    "matrix",
+    "linear-algebra",
+    "typescript",
+    "wasm",
+    "webgpu"
+  ]
+}