@danielsimonjr/mathts-matrix 0.1.12 → 0.1.14

package/dist/index.js

@@ -1,21 +1,3 @@
-import {
-  applyHouseholderLeft,
-  applyHouseholderRight,
-  cloneMatrix,
-  eig,
-  eigvals,
-  eye,
-  householder,
-  isSymmetric,
-  matAdd,
-  matMul,
-  matScale,
-  matSub,
-  norm1,
-  normInf,
-  powerIteration,
-  transpose
-} from "./chunk-JRSQE7LB.js";
 import {
   __esm,
   __export,
@@ -196,7 +178,7 @@ function scale(a, scalar) {
   for (let i = 0; i < ad.length; i++) result[i] = ad[i] * scalar;
   return result;
 }
-function transpose2(a) {
+function transpose(a) {
   const ad = flat(a);
   const rows = a.rows;
   const cols = a.cols;
@@ -1301,7 +1283,7 @@ var init_DenseMatrix = __esm({
        * Matrix transpose
        */
       transpose() {
-        return new _DenseMatrix(this.cols, this.rows, transpose2(this));
+        return new _DenseMatrix(this.cols, this.rows, transpose(this));
       }
       /**
        * Negate all elements
@@ -2485,7 +2467,7 @@ var WASMBackend = class {
     try {
       const path = this.config.wasmPath || await this.resolveAsWasmPath();
       const loaded = await this.loadAsModule(path);
-      if (typeof loaded.__new !== "function" || typeof loaded.matrix_multiply !== "function") {
+      if (typeof loaded.__new !== "function" || typeof loaded.matrix_multiply_simd_ptr !== "function") {
         console.warn(
           "WASMBackend: loaded module is not the AssemblyScript artifact; falling back to JS. Pass an explicit wasmPath (the AS binary, mathts-as.wasm)."
         );
@@ -2559,7 +2541,15 @@ var WASMBackend = class {
     }
     return instance.exports;
   }
-  shouldUseWasm(elementCount) {
+  /**
+   * WASM is only worth its copy/alloc overhead for compute-dense ops. The 2026-07-01
+   * backend audit (`tools/benchmarks/backend-audit`) measured element-wise / transpose
+   * ops 4–6× SLOWER on WASM than JS (memory-bound; the SIMD matmul kernel is the only
+   * clear win, 9–12×). So WASM is reserved for `opKind: 'matmul'`; everything else stays
+   * on JS via each method's existing `jsBackend` fallback.
+   */
+  shouldUseWasm(elementCount, opKind = "elementwise") {
+    if (opKind !== "matmul") return false;
     return this.wasmModule !== null && elementCount >= this.config.minElements;
   }
   getFeatures() {
@@ -2568,137 +2558,49 @@ var WASMBackend = class {
   // =========================================================================
   // Element-wise Operations
   // =========================================================================
+  // Element-wise ops run on JS. The AS element-wise kernels (matrix_add/sub/mul/div/scale/neg,
+  // array_abs) were measured 4–6× SLOWER than JS (memory-bound + copy/alloc overhead —
+  // tools/benchmarks/backend-audit) and retired via `shouldUseWasm` (returns false for
+  // non-matmul). These delegate to `jsBackend`; the dead WASM branches were removed 2026-07-02.
   add(a, b) {
-    const elementCount = a.rows * a.cols;
-    if (!this.shouldUseWasm(elementCount)) return jsBackend.add(a, b);
-    const mod = this.wasmModule;
-    const aAlloc = writeAsFloat64Array(this.allocCache, mod, a.toFloat64Array());
-    const bAlloc = writeAsFloat64Array(this.allocCache, mod, b.toFloat64Array());
-    const rAlloc = allocAsFloat64Array(this.allocCache, mod, elementCount);
-    try {
-      mod.matrix_add(aAlloc.headerPtr, bAlloc.headerPtr, rAlloc.headerPtr);
-      const result = readAsFloat64Array(mod, rAlloc);
-      return DenseMatrix.fromFlat(a.rows, a.cols, Array.from(result));
-    } finally {
-      this.allocCache.release(aAlloc);
-      this.allocCache.release(bAlloc);
-      this.allocCache.release(rAlloc);
-    }
+    return jsBackend.add(a, b);
   }
   subtract(a, b) {
-    const elementCount = a.rows * a.cols;
-    if (!this.shouldUseWasm(elementCount)) return jsBackend.subtract(a, b);
-    const mod = this.wasmModule;
-    const aAlloc = writeAsFloat64Array(this.allocCache, mod, a.toFloat64Array());
-    const bAlloc = writeAsFloat64Array(this.allocCache, mod, b.toFloat64Array());
-    const rAlloc = allocAsFloat64Array(this.allocCache, mod, elementCount);
-    try {
-      mod.matrix_sub(aAlloc.headerPtr, bAlloc.headerPtr, rAlloc.headerPtr);
-      const result = readAsFloat64Array(mod, rAlloc);
-      return DenseMatrix.fromFlat(a.rows, a.cols, Array.from(result));
-    } finally {
-      this.allocCache.release(aAlloc);
-      this.allocCache.release(bAlloc);
-      this.allocCache.release(rAlloc);
-    }
+    return jsBackend.subtract(a, b);
   }
   multiplyElementwise(a, b) {
-    const elementCount = a.rows * a.cols;
-    if (!this.shouldUseWasm(elementCount)) return jsBackend.multiplyElementwise(a, b);
-    const mod = this.wasmModule;
-    const aAlloc = writeAsFloat64Array(this.allocCache, mod, a.toFloat64Array());
-    const bAlloc = writeAsFloat64Array(this.allocCache, mod, b.toFloat64Array());
-    const rAlloc = allocAsFloat64Array(this.allocCache, mod, elementCount);
-    try {
-      mod.matrix_mul_elementwise(aAlloc.headerPtr, bAlloc.headerPtr, rAlloc.headerPtr);
-      const result = readAsFloat64Array(mod, rAlloc);
-      return DenseMatrix.fromFlat(a.rows, a.cols, Array.from(result));
-    } finally {
-      this.allocCache.release(aAlloc);
-      this.allocCache.release(bAlloc);
-      this.allocCache.release(rAlloc);
-    }
+    return jsBackend.multiplyElementwise(a, b);
   }
   divideElementwise(a, b) {
-    const elementCount = a.rows * a.cols;
-    if (!this.shouldUseWasm(elementCount)) return jsBackend.divideElementwise(a, b);
-    const mod = this.wasmModule;
-    const aAlloc = writeAsFloat64Array(this.allocCache, mod, a.toFloat64Array());
-    const bAlloc = writeAsFloat64Array(this.allocCache, mod, b.toFloat64Array());
-    const rAlloc = allocAsFloat64Array(this.allocCache, mod, elementCount);
-    try {
-      mod.matrix_div_elementwise(aAlloc.headerPtr, bAlloc.headerPtr, rAlloc.headerPtr);
-      const result = readAsFloat64Array(mod, rAlloc);
-      return DenseMatrix.fromFlat(a.rows, a.cols, Array.from(result));
-    } finally {
-      this.allocCache.release(aAlloc);
-      this.allocCache.release(bAlloc);
-      this.allocCache.release(rAlloc);
-    }
+    return jsBackend.divideElementwise(a, b);
   }
   scale(a, scalar) {
-    const elementCount = a.rows * a.cols;
-    if (!this.shouldUseWasm(elementCount)) return jsBackend.scale(a, scalar);
-    const mod = this.wasmModule;
-    const aAlloc = writeAsFloat64Array(this.allocCache, mod, a.toFloat64Array());
-    const rAlloc = allocAsFloat64Array(this.allocCache, mod, elementCount);
-    try {
-      mod.matrix_scale(aAlloc.headerPtr, scalar, rAlloc.headerPtr);
-      const result = readAsFloat64Array(mod, rAlloc);
-      return DenseMatrix.fromFlat(a.rows, a.cols, Array.from(result));
-    } finally {
-      this.allocCache.release(aAlloc);
-      this.allocCache.release(rAlloc);
-    }
+    return jsBackend.scale(a, scalar);
   }
   abs(a) {
-    const elementCount = a.rows * a.cols;
-    if (!this.shouldUseWasm(elementCount)) return jsBackend.abs(a);
-    const mod = this.wasmModule;
-    const aAlloc = writeAsFloat64Array(this.allocCache, mod, a.toFloat64Array());
-    const rAlloc = allocAsFloat64Array(this.allocCache, mod, elementCount);
-    try {
-      mod.array_abs(aAlloc.headerPtr, rAlloc.headerPtr);
-      const result = readAsFloat64Array(mod, rAlloc);
-      return DenseMatrix.fromFlat(a.rows, a.cols, Array.from(result));
-    } finally {
-      this.allocCache.release(aAlloc);
-      this.allocCache.release(rAlloc);
-    }
+    return jsBackend.abs(a);
   }
   negate(a) {
-    const elementCount = a.rows * a.cols;
-    if (!this.shouldUseWasm(elementCount)) return jsBackend.negate(a);
-    const mod = this.wasmModule;
-    const aAlloc = writeAsFloat64Array(this.allocCache, mod, a.toFloat64Array());
-    const rAlloc = allocAsFloat64Array(this.allocCache, mod, elementCount);
-    try {
-      mod.matrix_neg(aAlloc.headerPtr, rAlloc.headerPtr);
-      const result = readAsFloat64Array(mod, rAlloc);
-      return DenseMatrix.fromFlat(a.rows, a.cols, Array.from(result));
-    } finally {
-      this.allocCache.release(aAlloc);
-      this.allocCache.release(rAlloc);
-    }
+    return jsBackend.negate(a);
   }
   // =========================================================================
   // Matrix Operations
   // =========================================================================
   multiply(a, b) {
     const elementCount = a.rows * a.cols + b.rows * b.cols;
-    if (!this.shouldUseWasm(elementCount)) return jsBackend.multiply(a, b);
+    if (!this.shouldUseWasm(elementCount, "matmul")) return jsBackend.multiply(a, b);
     const mod = this.wasmModule;
     const aAlloc = writeAsFloat64Array(this.allocCache, mod, a.toFloat64Array());
     const bAlloc = writeAsFloat64Array(this.allocCache, mod, b.toFloat64Array());
     const rAlloc = allocAsFloat64Array(this.allocCache, mod, a.rows * b.cols);
     try {
-      mod.matrix_multiply(
-        aAlloc.headerPtr,
+      mod.matrix_multiply_simd_ptr(
+        aAlloc.bufferPtr,
         a.rows,
         a.cols,
-        bAlloc.headerPtr,
+        bAlloc.bufferPtr,
         b.cols,
-        rAlloc.headerPtr
+        rAlloc.bufferPtr
       );
       const result = readAsFloat64Array(mod, rAlloc);
       return DenseMatrix.fromFlat(a.rows, b.cols, Array.from(result));
@@ -2708,61 +2610,24 @@ var WASMBackend = class {
       this.allocCache.release(rAlloc);
     }
   }
+  // transpose is memory-bound (like element-wise) — retired from WASM, runs on JS.
   transpose(a) {
-    const elementCount = a.rows * a.cols;
-    if (!this.shouldUseWasm(elementCount)) return jsBackend.transpose(a);
-    const mod = this.wasmModule;
-    const aAlloc = writeAsFloat64Array(this.allocCache, mod, a.toFloat64Array());
-    const rAlloc = allocAsFloat64Array(this.allocCache, mod, elementCount);
-    try {
-      mod.matrix_transpose(aAlloc.headerPtr, a.rows, a.cols, rAlloc.headerPtr);
-      const result = readAsFloat64Array(mod, rAlloc);
-      return DenseMatrix.fromFlat(a.cols, a.rows, Array.from(result));
-    } finally {
-      this.allocCache.release(aAlloc);
-      this.allocCache.release(rAlloc);
-    }
+    return jsBackend.transpose(a);
   }
   // =========================================================================
-  // Reduction Operations
+  // Reduction Operations — memory-bound (single pass), retired from WASM → JS.
   // =========================================================================
   sum(a) {
-    const elementCount = a.rows * a.cols;
-    if (!this.shouldUseWasm(elementCount)) return jsBackend.sum(a);
-    const mod = this.wasmModule;
-    const aAlloc = writeAsFloat64Array(this.allocCache, mod, a.toFloat64Array());
-    try {
-      return mod.matrix_sum(aAlloc.headerPtr);
-    } finally {
-      this.allocCache.release(aAlloc);
-    }
+    return jsBackend.sum(a);
   }
   sumAxis(a, axis) {
     return jsBackend.sumAxis(a, axis);
   }
   norm(a) {
-    const elementCount = a.rows * a.cols;
-    if (!this.shouldUseWasm(elementCount)) return jsBackend.norm(a);
-    const mod = this.wasmModule;
-    const aAlloc = writeAsFloat64Array(this.allocCache, mod, a.toFloat64Array());
-    try {
-      return mod.matrix_norm_frobenius(aAlloc.headerPtr);
-    } finally {
-      this.allocCache.release(aAlloc);
-    }
+    return jsBackend.norm(a);
   }
   dot(a, b) {
-    const elementCount = a.rows * a.cols;
-    if (!this.shouldUseWasm(elementCount)) return jsBackend.dot(a, b);
-    const mod = this.wasmModule;
-    const aAlloc = writeAsFloat64Array(this.allocCache, mod, a.toFloat64Array());
-    const bAlloc = writeAsFloat64Array(this.allocCache, mod, b.toFloat64Array());
-    try {
-      return mod.array_dot(aAlloc.headerPtr, bAlloc.headerPtr);
-    } finally {
-      this.allocCache.release(aAlloc);
-      this.allocCache.release(bAlloc);
-    }
+    return jsBackend.dot(a, b);
   }
   // =========================================================================
   // LU / QR / Cholesky / Inverse / Determinant
@@ -5070,8 +4935,13 @@ backendRegistry.register(wasmBackend);
 var DEFAULT_EXTENDED_HINTS = {
   ...DEFAULT_BACKEND_HINTS,
   operationThresholds: {
-    multiply: { wasm: 500, gpu: 5e4 },
+    // matmul: the SIMD-WASM kernel wins from ~256 elems (16²), solidly 1.3–2.2× (measured,
+    // tools/benchmarks/matmul-threshold.mjs); below that copy/alloc overhead dominates (8²
+    // loses, 12² marginal). Dropped 500→256 to stop forcing 16²–22² matmuls onto JS.
+    multiply: { wasm: 256, gpu: 5e4 },
     decomposition: { wasm: 100, gpu: 1e4 },
+    // transpose WASM is retired (memory-bound, lost 4–6×) — WASMBackend.transpose always uses
+    // JS regardless of this gate; kept high so the manager doesn't even select the WASM backend.
     transpose: { wasm: 2e3, gpu: 2e5 }
   },
   autoSIMD: true,
@@ -5760,7 +5630,7 @@ var WasmLoader = class _WasmLoader {
   }
   /**
    * Decode a managed Float64Array RETURNED by an AssemblyScript export
-   * (e.g. `matrix_svd`, `matrix_eig_symmetric`) into a fresh JS copy.
+   * (e.g. the `matrix_lu_decompose` / `matrix_qr_decompose` outputs) into a fresh JS copy.
    *
    * AS exports that return a `Float64Array` hand back the typed-array
    * *header* pointer. The header is a 12-byte block laid out as
@@ -5972,6 +5842,590 @@ var WasmLoader = class _WasmLoader {
 };
 var wasmLoader = WasmLoader.getInstance();
 
+// src/operations/common.ts
+function eye(n) {
+  return Array.from(
+    { length: n },
+    (_, i) => Array.from({ length: n }, (_2, j) => i === j ? 1 : 0)
+  );
+}
+function cloneMatrix(A) {
+  return A.map((row2) => [...row2]);
+}
+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]));
+}
+function isSymmetric(matrix2, tolerance = 1e-10) {
+  const n = matrix2.length;
+  if (n === 0) return true;
+  if (matrix2[0].length !== n) return false;
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      if (Math.abs(matrix2[i][j] - matrix2[j][i]) > tolerance) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function matMul(A, B2) {
+  const m = A.length;
+  const p = A[0].length;
+  const n = B2[0].length;
+  const C = Array.from({ length: m }, () => new Array(n).fill(0));
+  for (let i = 0; i < m; i++) {
+    for (let k = 0; k < p; k++) {
+      const aik = A[i][k];
+      if (aik === 0) continue;
+      for (let j = 0; j < n; j++) C[i][j] += aik * B2[k][j];
+    }
+  }
+  return C;
+}
+function matAdd(A, B2) {
+  const n = A.length;
+  return Array.from(
+    { length: n },
+    (_, i) => Array.from({ length: n }, (_2, j) => A[i][j] + B2[i][j])
+  );
+}
+function matSub(A, B2) {
+  const n = A.length;
+  return Array.from(
+    { length: n },
+    (_, i) => Array.from({ length: n }, (_2, j) => A[i][j] - B2[i][j])
+  );
+}
+function matScale(A, c) {
+  return A.map((row2) => row2.map((v) => v * c));
+}
+function normInf(A) {
+  let mx = 0;
+  for (const row2 of A) for (const v of row2) if (Math.abs(v) > mx) mx = Math.abs(v);
+  return mx;
+}
+function norm1(A) {
+  const m = A.length;
+  const n = A[0].length;
+  let maxColSum = 0;
+  for (let j = 0; j < n; j++) {
+    let colSum = 0;
+    for (let i = 0; i < m; i++) colSum += Math.abs(A[i][j]);
+    if (colSum > maxColSum) maxColSum = colSum;
+  }
+  return maxColSum;
+}
+function householder(x, degenerateBeta = -2) {
+  const n = x.length;
+  let sigma = 0;
+  for (let i = 1; i < n; i++) {
+    sigma += x[i] * x[i];
+  }
+  const v = [...x];
+  v[0] = 1;
+  if (sigma === 0 && x[0] >= 0) {
+    return { v, beta: 0 };
+  } else if (sigma === 0 && x[0] < 0) {
+    return { v, beta: degenerateBeta };
+  } else {
+    const mu = Math.sqrt(x[0] * x[0] + sigma);
+    if (x[0] <= 0) {
+      v[0] = x[0] - mu;
+    } else {
+      v[0] = -sigma / (x[0] + mu);
+    }
+    const beta = 2 * v[0] * v[0] / (sigma + v[0] * v[0]);
+    const v0 = v[0];
+    for (let i = 0; i < n; i++) {
+      v[i] /= v0;
+    }
+    return { v, beta };
+  }
+}
+function applyHouseholderLeft(A, v, beta, startRow, startCol) {
+  const n = A[0].length;
+  const len = v.length;
+  for (let j = startCol; j < n; j++) {
+    let dot = 0;
+    for (let i = 0; i < len; i++) {
+      dot += v[i] * A[startRow + i][j];
+    }
+    dot *= beta;
+    for (let i = 0; i < len; i++) {
+      A[startRow + i][j] -= dot * v[i];
+    }
+  }
+}
+function applyHouseholderRight(A, v, beta, startRow, startCol) {
+  const m = A.length;
+  const len = v.length;
+  for (let i = startRow; i < m; i++) {
+    let dot = 0;
+    for (let j = 0; j < len; j++) {
+      dot += A[i][startCol + j] * v[j];
+    }
+    dot *= beta;
+    for (let j = 0; j < len; j++) {
+      A[i][startCol + j] -= dot * v[j];
+    }
+  }
+}
+
+// src/operations/eig.ts
+var EIG_GEN_EPS = 2220446049250313e-31;
+function cdiv(xr, xi, yr, yi) {
+  let rr;
+  let d;
+  if (Math.abs(yr) > Math.abs(yi)) {
+    rr = yi / yr;
+    d = yr + rr * yi;
+    return { r: (xr + rr * xi) / d, i: (xi - rr * xr) / d };
+  } else {
+    rr = yr / yi;
+    d = yi + rr * yr;
+    return { r: (rr * xr + xi) / d, i: (rr * xi - xr) / d };
+  }
+}
+function orthesGeneral(H, V, ort, nn) {
+  const low = 0;
+  const high = nn - 1;
+  for (let m = low + 1; m <= high - 1; m++) {
+    let scale2 = 0;
+    for (let i = m; i <= high; i++) {
+      scale2 += Math.abs(H[i * nn + (m - 1)]);
+    }
+    if (scale2 !== 0) {
+      let h = 0;
+      for (let i = high; i >= m; i--) {
+        ort[i] = H[i * nn + (m - 1)] / scale2;
+        h += ort[i] * ort[i];
+      }
+      let g = Math.sqrt(h);
+      if (ort[m] > 0) g = -g;
+      h = h - ort[m] * g;
+      ort[m] = ort[m] - g;
+      for (let j = m; j < nn; j++) {
+        let f = 0;
+        for (let i = high; i >= m; i--) f += ort[i] * H[i * nn + j];
+        f = f / h;
+        for (let i = m; i <= high; i++) H[i * nn + j] -= f * ort[i];
+      }
+      for (let i = 0; i <= high; i++) {
+        let f = 0;
+        for (let j = high; j >= m; j--) f += ort[j] * H[i * nn + j];
+        f = f / h;
+        for (let j = m; j <= high; j++) H[i * nn + j] -= f * ort[j];
+      }
+      ort[m] = scale2 * ort[m];
+      H[m * nn + (m - 1)] = scale2 * g;
+    }
+  }
+  for (let m = high - 1; m >= low + 1; m--) {
+    if (H[m * nn + (m - 1)] !== 0) {
+      for (let i = m + 1; i <= high; i++) ort[i] = H[i * nn + (m - 1)];
+      for (let j = m; j <= high; j++) {
+        let g = 0;
+        for (let i = m; i <= high; i++) g += ort[i] * V[i * nn + j];
+        g = g / ort[m] / H[m * nn + (m - 1)];
+        for (let i = m; i <= high; i++) V[i * nn + j] += g * ort[i];
+      }
+    }
+  }
+}
+function eigGeneral(A, computeVectors, symmetric) {
+  const nn = A.length;
+  const eps = EIG_GEN_EPS;
+  const H = new Float64Array(nn * nn);
+  for (let i = 0; i < nn; i++) {
+    for (let j = 0; j < nn; j++) H[i * nn + j] = A[i][j];
+  }
+  const V = new Float64Array(nn * nn);
+  for (let i = 0; i < nn; i++) V[i * nn + i] = 1;
+  const d = new Float64Array(nn);
+  const e = new Float64Array(nn);
+  const ort = new Float64Array(nn);
+  orthesGeneral(H, V, ort, nn);
+  const low = 0;
+  const high = nn - 1;
+  let exshift = 0;
+  let p = 0;
+  let q = 0;
+  let r = 0;
+  let s = 0;
+  let z = 0;
+  let t;
+  let w;
+  let x;
+  let y;
+  let norm4 = 0;
+  for (let i = 0; i < nn; i++) {
+    for (let j = Math.max(i - 1, 0); j < nn; j++) {
+      norm4 += Math.abs(H[i * nn + j]);
+    }
+  }
+  let nIdx = nn - 1;
+  let iter = 0;
+  while (nIdx >= low) {
+    let l = nIdx;
+    while (l > low) {
+      s = Math.abs(H[(l - 1) * nn + (l - 1)]) + Math.abs(H[l * nn + l]);
+      if (s === 0) s = norm4;
+      if (Math.abs(H[l * nn + (l - 1)]) < eps * s) break;
+      l--;
+    }
+    if (l === nIdx) {
+      H[nIdx * nn + nIdx] = H[nIdx * nn + nIdx] + exshift;
+      d[nIdx] = H[nIdx * nn + nIdx];
+      e[nIdx] = 0;
+      nIdx--;
+      iter = 0;
+    } else if (l === nIdx - 1) {
+      w = H[nIdx * nn + (nIdx - 1)] * H[(nIdx - 1) * nn + nIdx];
+      p = (H[(nIdx - 1) * nn + (nIdx - 1)] - H[nIdx * nn + nIdx]) / 2;
+      q = p * p + w;
+      z = Math.sqrt(Math.abs(q));
+      H[nIdx * nn + nIdx] = H[nIdx * nn + nIdx] + exshift;
+      H[(nIdx - 1) * nn + (nIdx - 1)] = H[(nIdx - 1) * nn + (nIdx - 1)] + exshift;
+      x = H[nIdx * nn + nIdx];
+      if (q >= 0) {
+        z = p >= 0 ? p + z : p - z;
+        d[nIdx - 1] = x + z;
+        d[nIdx] = d[nIdx - 1];
+        if (z !== 0) d[nIdx] = x - w / z;
+        e[nIdx - 1] = 0;
+        e[nIdx] = 0;
+        x = H[nIdx * nn + (nIdx - 1)];
+        s = Math.abs(x) + Math.abs(z);
+        p = x / s;
+        q = z / s;
+        r = Math.sqrt(p * p + q * q);
+        p = p / r;
+        q = q / r;
+        for (let j = nIdx - 1; j < nn; j++) {
+          z = H[(nIdx - 1) * nn + j];
+          H[(nIdx - 1) * nn + j] = q * z + p * H[nIdx * nn + j];
+          H[nIdx * nn + j] = q * H[nIdx * nn + j] - p * z;
+        }
+        for (let i = 0; i <= nIdx; i++) {
+          z = H[i * nn + (nIdx - 1)];
+          H[i * nn + (nIdx - 1)] = q * z + p * H[i * nn + nIdx];
+          H[i * nn + nIdx] = q * H[i * nn + nIdx] - p * z;
+        }
+        for (let i = low; i <= high; i++) {
+          z = V[i * nn + (nIdx - 1)];
+          V[i * nn + (nIdx - 1)] = q * z + p * V[i * nn + nIdx];
+          V[i * nn + nIdx] = q * V[i * nn + nIdx] - p * z;
+        }
+      } else {
+        d[nIdx - 1] = x + p;
+        d[nIdx] = x + p;
+        e[nIdx - 1] = z;
+        e[nIdx] = -z;
+      }
+      nIdx = nIdx - 2;
+      iter = 0;
+    } else {
+      x = H[nIdx * nn + nIdx];
+      y = 0;
+      w = 0;
+      if (l < nIdx) {
+        y = H[(nIdx - 1) * nn + (nIdx - 1)];
+        w = H[nIdx * nn + (nIdx - 1)] * H[(nIdx - 1) * nn + nIdx];
+      }
+      if (iter === 10) {
+        exshift += x;
+        for (let i = low; i <= nIdx; i++) H[i * nn + i] -= x;
+        s = Math.abs(H[nIdx * nn + (nIdx - 1)]) + Math.abs(H[(nIdx - 1) * nn + (nIdx - 2)]);
+        x = y = 0.75 * s;
+        w = -0.4375 * s * s;
+      }
+      if (iter === 30) {
+        s = (y - x) / 2;
+        s = s * s + w;
+        if (s > 0) {
+          s = Math.sqrt(s);
+          if (y < x) s = -s;
+          s = x - w / ((y - x) / 2 + s);
+          for (let i = low; i <= nIdx; i++) H[i * nn + i] -= s;
+          exshift += s;
+          x = y = w = 0.964;
+        }
+      }
+      iter = iter + 1;
+      let m = nIdx - 2;
+      while (m >= l) {
+        z = H[m * nn + m];
+        r = x - z;
+        s = y - z;
+        p = (r * s - w) / H[(m + 1) * nn + m] + H[m * nn + (m + 1)];
+        q = H[(m + 1) * nn + (m + 1)] - z - r - s;
+        r = H[(m + 2) * nn + (m + 1)];
+        s = Math.abs(p) + Math.abs(q) + Math.abs(r);
+        p = p / s;
+        q = q / s;
+        r = r / s;
+        if (m === l) break;
+        if (Math.abs(H[m * nn + (m - 1)]) * (Math.abs(q) + Math.abs(r)) < eps * (Math.abs(p) * (Math.abs(H[(m - 1) * nn + (m - 1)]) + Math.abs(z) + Math.abs(H[(m + 1) * nn + (m + 1)])))) {
+          break;
+        }
+        m--;
+      }
+      for (let i = m + 2; i <= nIdx; i++) {
+        H[i * nn + (i - 2)] = 0;
+        if (i > m + 2) H[i * nn + (i - 3)] = 0;
+      }
+      for (let k = m; k <= nIdx - 1; k++) {
+        const notlast = k !== nIdx - 1;
+        if (k !== m) {
+          p = H[k * nn + (k - 1)];
+          q = H[(k + 1) * nn + (k - 1)];
+          r = notlast ? H[(k + 2) * nn + (k - 1)] : 0;
+          x = Math.abs(p) + Math.abs(q) + Math.abs(r);
+          if (x !== 0) {
+            p = p / x;
+            q = q / x;
+            r = r / x;
+          }
+        }
+        if (x === 0) break;
+        s = Math.sqrt(p * p + q * q + r * r);
+        if (p < 0) s = -s;
+        if (s !== 0) {
+          if (k !== m) {
+            H[k * nn + (k - 1)] = -s * x;
+          } else if (l !== m) {
+            H[k * nn + (k - 1)] = -H[k * nn + (k - 1)];
+          }
+          p = p + s;
+          x = p / s;
+          y = q / s;
+          z = r / s;
+          q = q / p;
+          r = r / p;
+          for (let j = k; j < nn; j++) {
+            p = H[k * nn + j] + q * H[(k + 1) * nn + j];
+            if (notlast) {
+              p = p + r * H[(k + 2) * nn + j];
+              H[(k + 2) * nn + j] = H[(k + 2) * nn + j] - p * z;
+            }
+            H[k * nn + j] = H[k * nn + j] - p * x;
+            H[(k + 1) * nn + j] = H[(k + 1) * nn + j] - p * y;
+          }
+          const colEnd = Math.min(nIdx, k + 3);
+          for (let i = 0; i <= colEnd; i++) {
+            p = x * H[i * nn + k] + y * H[i * nn + (k + 1)];
+            if (notlast) {
+              p = p + z * H[i * nn + (k + 2)];
+              H[i * nn + (k + 2)] = H[i * nn + (k + 2)] - p * r;
+            }
+            H[i * nn + k] = H[i * nn + k] - p;
+            H[i * nn + (k + 1)] = H[i * nn + (k + 1)] - p * q;
+          }
+          for (let i = low; i <= high; i++) {
+            p = x * V[i * nn + k] + y * V[i * nn + (k + 1)];
+            if (notlast) {
+              p = p + z * V[i * nn + (k + 2)];
+              V[i * nn + (k + 2)] = V[i * nn + (k + 2)] - p * r;
+            }
+            V[i * nn + k] = V[i * nn + k] - p;
+            V[i * nn + (k + 1)] = V[i * nn + (k + 1)] - p * q;
+          }
+        }
+      }
+    }
+  }
+  if (norm4 !== 0) {
+    for (nIdx = nn - 1; nIdx >= 0; nIdx--) {
+      p = d[nIdx];
+      q = e[nIdx];
+      if (q === 0) {
+        let l = nIdx;
+        H[nIdx * nn + nIdx] = 1;
+        for (let i = nIdx - 1; i >= 0; i--) {
+          w = H[i * nn + i] - p;
+          r = 0;
+          for (let j = l; j <= nIdx; j++) r += H[i * nn + j] * H[j * nn + nIdx];
+          if (e[i] < 0) {
+            z = w;
+            s = r;
+          } else {
+            l = i;
+            if (e[i] === 0) {
+              H[i * nn + nIdx] = w !== 0 ? -r / w : -r / (eps * norm4);
+            } else {
+              x = H[i * nn + (i + 1)];
+              y = H[(i + 1) * nn + i];
+              q = (d[i] - p) * (d[i] - p) + e[i] * e[i];
+              t = (x * s - z * r) / q;
+              H[i * nn + nIdx] = t;
+              if (Math.abs(x) > Math.abs(z)) {
+                H[(i + 1) * nn + nIdx] = (-r - w * t) / x;
+              } else {
+                H[(i + 1) * nn + nIdx] = (-s - y * t) / z;
+              }
+            }
+            t = Math.abs(H[i * nn + nIdx]);
+            if (eps * t * t > 1) {
+              for (let j = i; j <= nIdx; j++) H[j * nn + nIdx] = H[j * nn + nIdx] / t;
+            }
+          }
+        }
+      } else if (q < 0) {
+        let l = nIdx - 1;
+        if (Math.abs(H[nIdx * nn + (nIdx - 1)]) > Math.abs(H[(nIdx - 1) * nn + nIdx])) {
+          H[(nIdx - 1) * nn + (nIdx - 1)] = q / H[nIdx * nn + (nIdx - 1)];
+          H[(nIdx - 1) * nn + nIdx] = -(H[nIdx * nn + nIdx] - p) / H[nIdx * nn + (nIdx - 1)];
+        } else {
+          const cd = cdiv(0, -H[(nIdx - 1) * nn + nIdx], H[(nIdx - 1) * nn + (nIdx - 1)] - p, q);
+          H[(nIdx - 1) * nn + (nIdx - 1)] = cd.r;
+          H[(nIdx - 1) * nn + nIdx] = cd.i;
+        }
+        H[nIdx * nn + (nIdx - 1)] = 0;
+        H[nIdx * nn + nIdx] = 1;
+        for (let i = nIdx - 2; i >= 0; i--) {
+          let ra = 0;
+          let sa = 0;
+          for (let j = l; j <= nIdx; j++) {
+            ra += H[i * nn + j] * H[j * nn + (nIdx - 1)];
+            sa += H[i * nn + j] * H[j * nn + nIdx];
+          }
+          w = H[i * nn + i] - p;
+          if (e[i] < 0) {
+            z = w;
+            r = ra;
+            s = sa;
+          } else {
+            l = i;
+            if (e[i] === 0) {
+              const cd = cdiv(-ra, -sa, w, q);
+              H[i * nn + (nIdx - 1)] = cd.r;
+              H[i * nn + nIdx] = cd.i;
+            } else {
+              x = H[i * nn + (i + 1)];
+              y = H[(i + 1) * nn + i];
+              let vr = (d[i] - p) * (d[i] - p) + e[i] * e[i] - q * q;
+              const vi = (d[i] - p) * 2 * q;
+              if (vr === 0 && vi === 0) {
+                vr = eps * norm4 * (Math.abs(w) + Math.abs(q) + Math.abs(x) + Math.abs(y) + Math.abs(z));
+              }
+              const cd = cdiv(x * r - z * ra + q * sa, x * s - z * sa - q * ra, vr, vi);
+              H[i * nn + (nIdx - 1)] = cd.r;
+              H[i * nn + nIdx] = cd.i;
+              if (Math.abs(x) > Math.abs(z) + Math.abs(q)) {
+                H[(i + 1) * nn + (nIdx - 1)] = (-ra - w * H[i * nn + (nIdx - 1)] + q * H[i * nn + nIdx]) / x;
+                H[(i + 1) * nn + nIdx] = (-sa - w * H[i * nn + nIdx] - q * H[i * nn + (nIdx - 1)]) / x;
+              } else {
+                const cd2 = cdiv(-r - y * H[i * nn + (nIdx - 1)], -s - y * H[i * nn + nIdx], z, q);
+                H[(i + 1) * nn + (nIdx - 1)] = cd2.r;
+                H[(i + 1) * nn + nIdx] = cd2.i;
+              }
+            }
+            t = Math.max(Math.abs(H[i * nn + (nIdx - 1)]), Math.abs(H[i * nn + nIdx]));
+            if (eps * t * t > 1) {
+              for (let j = i; j <= nIdx; j++) {
+                H[j * nn + (nIdx - 1)] = H[j * nn + (nIdx - 1)] / t;
+                H[j * nn + nIdx] = H[j * nn + nIdx] / t;
+              }
+            }
+          }
+        }
+      }
+    }
+    for (let j = nn - 1; j >= low; j--) {
+      for (let i = low; i <= high; i++) {
+        z = 0;
+        const kEnd = Math.min(j, high);
+        for (let k = low; k <= kEnd; k++) z += V[i * nn + k] * H[k * nn + j];
+        V[i * nn + j] = z;
+      }
+    }
+  }
+  const values = [];
+  for (let j = 0; j < nn; j++) values.push({ re: d[j], im: e[j] });
+  let vectors;
+  if (computeVectors) {
+    vectors = [];
+    for (let j = 0; j < nn; j++) {
+      const vec = new Array(nn).fill(0);
+      if (e[j] === 0) {
+        let colNorm = 0;
+        for (let i = 0; i < nn; i++) colNorm += V[i * nn + j] * V[i * nn + j];
+        colNorm = Math.sqrt(colNorm);
+        if (colNorm > 1e-300) {
+          for (let i = 0; i < nn; i++) vec[i] = V[i * nn + j] / colNorm;
+        } else {
+          for (let i = 0; i < nn; i++) vec[i] = V[i * nn + j];
+        }
+      }
+      vectors.push(vec);
+    }
+  } else {
+    vectors = eye(nn);
+  }
+  return { values, vectors, isSymmetric: symmetric };
+}
+function eig(matrix2, options = {}) {
+  const { computeVectors = true } = options;
+  let A;
+  if (matrix2 instanceof Float64Array) {
+    const n2 = Math.sqrt(matrix2.length);
+    if (n2 !== Math.floor(n2)) {
+      throw new Error("Float64Array length must be a perfect square");
+    }
+    A = Array.from({ length: n2 }, (_, i) => Array.from({ length: n2 }, (_2, j) => matrix2[i * n2 + j]));
+  } else {
+    A = matrix2;
+  }
+  const n = A.length;
+  if (n === 0) {
+    return { values: [], vectors: [], isSymmetric: true };
+  }
+  for (let i = 0; i < n; i++) {
+    if (A[i].length !== n) {
+      throw new Error("Matrix must be square");
+    }
+  }
+  const symmetric = isSymmetric(A);
+  if (n === 1) {
+    return {
+      values: [{ re: A[0][0], im: 0 }],
+      vectors: [[1]],
+      isSymmetric: symmetric
+    };
+  }
+  return eigGeneral(A, computeVectors, symmetric);
+}
+function eigvals(matrix2, options) {
+  return eig(matrix2, { ...options, computeVectors: false }).values;
+}
+function powerIteration(matrix2, options = {}) {
+  const { maxIterations = 1e3, tolerance = 1e-12 } = options;
+  const n = matrix2.length;
+  let v = Array.from({ length: n }, () => Math.random() - 0.5);
+  let norm4 = Math.sqrt(v.reduce((sum3, x) => sum3 + x * x, 0));
+  v = v.map((x) => x / norm4);
+  let eigenvalue = 0;
+  let prevEigenvalue = 0;
+  for (let iter = 0; iter < maxIterations; iter++) {
+    const w = new Array(n).fill(0);
+    for (let i = 0; i < n; i++) {
+      for (let j = 0; j < n; j++) {
+        w[i] += matrix2[i][j] * v[j];
+      }
+    }
+    eigenvalue = v.reduce((sum3, vi, i) => sum3 + vi * w[i], 0);
+    norm4 = Math.sqrt(w.reduce((sum3, x) => sum3 + x * x, 0));
+    v = w.map((x) => x / norm4);
+    if (Math.abs(eigenvalue - prevEigenvalue) < tolerance * Math.abs(eigenvalue)) {
+      break;
+    }
+    prevEigenvalue = eigenvalue;
+  }
+  return { value: eigenvalue, vector: v };
+}
+
 // src/operations/svd.ts
 var DEFAULT_MAX_ITERATIONS = 1e3;
 var DEFAULT_TOLERANCE = 1e-12;
@@ -6090,6 +6544,84 @@ function handleZero(d, e, _U, V, zeroIdx, isDiagonal, _tolerance) {
     }
   }
 }
+function jacobiSVD(A) {
+  const m = A.length;
+  const n = A[0].length;
+  const W = A.map((row2) => row2.slice());
+  const V = eye(n);
+  const EPS = 1e-15;
+  const MAX_SWEEPS = 60;
+  for (let sweep = 0; sweep < MAX_SWEEPS; sweep++) {
+    let rotated = false;
+    for (let p = 0; p < n - 1; p++) {
+      for (let q = p + 1; q < n; q++) {
+        let alpha = 0;
+        let beta = 0;
+        let gamma = 0;
+        for (let i = 0; i < m; i++) {
+          alpha += W[i][p] * W[i][p];
+          gamma += W[i][q] * W[i][q];
+          beta += W[i][p] * W[i][q];
+        }
+        if (Math.abs(beta) <= EPS * Math.sqrt(alpha * gamma) || alpha === 0 && gamma === 0) {
+          continue;
+        }
+        rotated = true;
+        const zeta = (gamma - alpha) / (2 * beta);
+        const sign = zeta >= 0 ? 1 : -1;
+        const t = sign / (Math.abs(zeta) + Math.sqrt(1 + zeta * zeta));
+        const c = 1 / Math.sqrt(1 + t * t);
+        const s = c * t;
+        for (let i = 0; i < m; i++) {
+          const wip = W[i][p];
+          const wiq = W[i][q];
+          W[i][p] = c * wip - s * wiq;
+          W[i][q] = s * wip + c * wiq;
+        }
+        for (let i = 0; i < n; i++) {
+          const vip = V[i][p];
+          const viq = V[i][q];
+          V[i][p] = c * vip - s * viq;
+          V[i][q] = s * vip + c * viq;
+        }
+      }
+    }
+    if (!rotated) break;
+  }
+  const d = new Array(n).fill(0);
+  const U = Array.from({ length: m }, () => new Array(n).fill(0));
+  for (let j = 0; j < n; j++) {
+    let norm4 = 0;
+    for (let i = 0; i < m; i++) norm4 += W[i][j] * W[i][j];
+    norm4 = Math.sqrt(norm4);
+    d[j] = norm4;
+    if (norm4 > 1e-300) {
+      for (let i = 0; i < m; i++) U[i][j] = W[i][j] / norm4;
+    }
+  }
+  for (let j = 0; j < n; j++) {
+    if (d[j] > 1e-300) continue;
+    const col = new Array(m).fill(0);
+    for (let seed = 0; seed < m; seed++) {
+      col.fill(0);
+      col[seed] = 1;
+      for (let c = 0; c < n; c++) {
+        if (c === j) continue;
+        let dot = 0;
+        for (let i = 0; i < m; i++) dot += col[i] * U[i][c];
+        for (let i = 0; i < m; i++) col[i] -= dot * U[i][c];
+      }
+      let nrm = 0;
+      for (let i = 0; i < m; i++) nrm += col[i] * col[i];
+      nrm = Math.sqrt(nrm);
+      if (nrm > 1e-8) {
+        for (let i = 0; i < m; i++) U[i][j] = col[i] / nrm;
+        break;
+      }
+    }
+  }
+  return { d, U, V };
+}
 function svd(matrix2, options = {}) {
   const {
     maxIterations = DEFAULT_MAX_ITERATIONS,
@@ -6161,19 +6693,29 @@ function svd(matrix2, options = {}) {
     }
     svdStep(d, e, U, V, start, end);
   }
-  for (let i = 0; i < d.length; i++) {
-    if (d[i] < 0) {
-      d[i] = -d[i];
-      for (let j = 0; j < V.length; j++) {
-        V[j][i] = -V[j][i];
-      }
-    }
-  }
-  const indices = Array.from({ length: d.length }, (_, i) => i);
-  indices.sort((a, b) => d[b] - d[a]);
-  const sortedS = indices.map((i) => d[i]);
-  const sortedU = U.map((row2) => indices.map((i) => row2[i]));
-  const sortedV = V.map((row2) => indices.map((i) => row2[i]));
+  let dFinal = d;
+  let uFinal = U;
+  let vFinal = V;
+  const maxAbsD = d.reduce((mx, x) => Math.max(mx, Math.abs(x)), 0);
+  if (maxAbsD > 0 && d.some((x) => Math.abs(x) <= rankTolerance * maxAbsD)) {
+    const jac = jacobiSVD(A);
+    dFinal = jac.d;
+    uFinal = jac.U;
+    vFinal = jac.V;
+  }
+  for (let i = 0; i < dFinal.length; i++) {
+    if (dFinal[i] < 0) {
+      dFinal[i] = -dFinal[i];
+      for (let j = 0; j < vFinal.length; j++) {
+        vFinal[j][i] = -vFinal[j][i];
+      }
+    }
+  }
+  const indices = Array.from({ length: dFinal.length }, (_, i) => i);
+  indices.sort((a, b) => dFinal[b] - dFinal[a]);
+  const sortedS = indices.map((i) => dFinal[i]);
+  const sortedU = uFinal.map((row2) => indices.map((i) => row2[i]));
+  const sortedV = vFinal.map((row2) => indices.map((i) => row2[i]));
   const maxS = sortedS[0] || 0;
   let rank = 0;
   for (const s of sortedS) {
@@ -6263,17 +6805,6 @@ function normFro(matrix2) {
 }
 
 // src/operations/eig-wasm.ts
-var WASM_EIG_THRESHOLD = 8;
-function flattenMatrix(matrix2) {
-  const n = matrix2.length;
-  const flat2 = new Float64Array(n * n);
-  for (let i = 0; i < n; i++) {
-    for (let j = 0; j < n; j++) {
-      flat2[i * n + j] = matrix2[i][j];
-    }
-  }
-  return flat2;
-}
 async function eigWasm(matrix2, options) {
   const n = matrix2.length;
   if (n === 0) {
@@ -6284,113 +6815,14 @@ async function eigWasm(matrix2, options) {
       throw new Error("Matrix must be square");
     }
   }
-  let module = wasmLoader.getModule();
-  if (!module) {
-    try {
-      module = await wasmLoader.load();
-    } catch {
-      module = null;
-    }
-  }
-  const symmetric = isSymmetric(matrix2);
-  const useSymWasm = !!module && n >= WASM_EIG_THRESHOLD && symmetric && typeof module.matrix_eig_symmetric === "function";
-  const useGenWasm = !!module && n >= WASM_EIG_THRESHOLD && !symmetric && typeof module.matrix_eig_general === "function";
-  if (!useSymWasm && !useGenWasm) {
-    return eig(matrix2, options);
-  }
-  const computeVectors = options?.computeVectors ?? true;
-  const identityVectors = () => Array.from({ length: n }, (_, i) => {
-    const row2 = new Array(n).fill(0);
-    row2[i] = 1;
-    return row2;
-  });
-  const flatMatrix = flattenMatrix(matrix2);
-  const matrixAlloc = wasmLoader.allocateFloat64Array(Array.from(flatMatrix));
-  try {
-    if (useSymWasm) {
-      const packedPtr2 = module.matrix_eig_symmetric(matrixAlloc.ptr, n);
-      const packed2 = wasmLoader.readReturnedFloat64Array(packedPtr2);
-      if (packed2.length < n + n * n) {
-        return eig(matrix2, options);
-      }
-      const values2 = [];
-      for (let j = 0; j < n; j++) {
-        values2.push({ re: packed2[j], im: 0 });
-      }
-      let vectors2;
-      if (computeVectors) {
-        vectors2 = [];
-        for (let j = 0; j < n; j++) {
-          const vec = [];
-          for (let i = 0; i < n; i++) {
-            vec.push(packed2[n + i * n + j]);
-          }
-          vectors2.push(vec);
-        }
-      } else {
-        vectors2 = identityVectors();
-      }
-      return { values: values2, vectors: vectors2, isSymmetric: true };
-    }
-    const packedPtr = module.matrix_eig_general(matrixAlloc.ptr, n);
-    const packed = wasmLoader.readReturnedFloat64Array(packedPtr);
-    if (packed.length < 2 * n + n * n) {
-      return eig(matrix2, options);
-    }
-    const values = [];
-    for (let j = 0; j < n; j++) {
-      values.push({ re: packed[j], im: packed[n + j] });
-    }
-    let vectors;
-    if (computeVectors) {
-      vectors = [];
-      for (let j = 0; j < n; j++) {
-        const vec = [];
-        for (let i = 0; i < n; i++) {
-          vec.push(packed[2 * n + i * n + j]);
-        }
-        vectors.push(vec);
-      }
-    } else {
-      vectors = identityVectors();
-    }
-    return { values, vectors, isSymmetric: false };
-  } catch {
-    return eig(matrix2, options);
-  } finally {
-    wasmLoader.free(matrixAlloc.ptr);
-  }
+  return eig(matrix2, options);
 }
 async function eigvalsWasm(matrix2, options) {
-  const result = await eigWasm(matrix2, { ...options, computeVectors: false });
-  return result.values;
+  return eigvals(matrix2, options);
 }
 async function spectralRadiusWasm(matrix2, options) {
-  const n = matrix2.length;
-  let module = wasmLoader.getModule();
-  if (!module) {
-    try {
-      module = await wasmLoader.load();
-    } catch {
-      module = null;
-    }
-  }
-  if (!module || n < WASM_EIG_THRESHOLD || typeof module.matrix_spectral_radius !== "function") {
-    const { powerIteration: powerIteration2 } = await import("./eig-PIFFHFJF.js");
-    const result = powerIteration2(matrix2, options);
-    return Math.abs(result.value);
-  }
-  const flatMatrix = flattenMatrix(matrix2);
-  const matrixAlloc = wasmLoader.allocateFloat64Array(Array.from(flatMatrix));
-  try {
-    return module.matrix_spectral_radius(matrixAlloc.ptr, n);
-  } catch {
-    const { powerIteration: powerIteration2 } = await import("./eig-PIFFHFJF.js");
-    const result = powerIteration2(matrix2, options);
-    return Math.abs(result.value);
-  } finally {
-    wasmLoader.free(matrixAlloc.ptr);
-  }
+  const result = powerIteration(matrix2, options);
+  return Math.abs(result.value);
 }
 
 // src/operations/svd-wasm.ts
@@ -6418,46 +6850,7 @@ async function svdWasm(matrix2, options) {
   }
   const k = Math.min(m, n);
   const rankTolerance = options?.rankTolerance ?? 1e-10;
-  let module = wasmLoader.getModule();
-  if (!module) {
-    try {
-      module = await wasmLoader.load();
-    } catch {
-      module = null;
-    }
-  }
-  if (!module || typeof module.matrix_svd !== "function") {
-    return toThin(svd(matrix2, options), k, rankTolerance);
-  }
-  const flat2 = new Float64Array(m * n);
-  for (let i = 0; i < m; i++) {
-    for (let j = 0; j < n; j++) flat2[i * n + j] = matrix2[i][j];
-  }
-  const aAlloc = wasmLoader.allocateFloat64Array(flat2);
-  try {
-    const packedPtr = module.matrix_svd(aAlloc.ptr, m, n);
-    const packed = wasmLoader.readReturnedFloat64Array(packedPtr);
-    if (packed.length < m * k + k + n * k) {
-      return toThin(svd(matrix2, options), k, rankTolerance);
-    }
-    const uFlat = packed.subarray(0, m * k);
-    const sFlat = packed.subarray(m * k, m * k + k);
-    const vFlat = packed.subarray(m * k + k, m * k + k + n * k);
-    const U = [];
-    for (let i = 0; i < m; i++) {
-      U.push(Array.from(uFlat.subarray(i * k, i * k + k)));
-    }
-    const V = [];
-    for (let i = 0; i < n; i++) {
-      V.push(Array.from(vFlat.subarray(i * k, i * k + k)));
-    }
-    const S = Array.from(sFlat);
-    return { U, S, V, rank: estimateRank(S, rankTolerance) };
-  } catch {
-    return toThin(svd(matrix2, options), k, rankTolerance);
-  } finally {
-    wasmLoader.free(aAlloc.ptr);
-  }
+  return toThin(svd(matrix2, options), k, rankTolerance);
 }
 
 // src/operations/pinv.ts
@@ -6806,8 +7199,7 @@ function hessenbergReduce(A) {
       applyHouseholderRight(Q, v, beta, 0, k + 1);
     }
   }
-  for (let i = 0; i < n; i++)
-    for (let j = 0; j < i - 1; j++) H[i][j] = 0;
+  for (let i = 0; i < n; i++) for (let j = 0; j < i - 1; j++) H[i][j] = 0;
   return { H, Q };
 }
 function givensParams(a, b) {
@@ -6912,6 +7304,57 @@ function qrStepDouble(H, Q, start, end) {
   applyGivensRight(H, gc, gs, end - 1, end, 0);
   applyGivensRight(Q, gc, gs, end - 1, end, 0);
 }
+function qrStepSingleShift(H, Q, start, end, shift) {
+  let x = H[start][start] - shift;
+  let y = H[start + 1][start];
+  for (let k = start; k < end; k++) {
+    const { c: gc, s: gs } = givensParams(x, y);
+    applyGivensLeft(H, gc, gs, k, k + 1, Math.max(0, k - 1));
+    applyGivensRight(H, gc, gs, k, k + 1, 0);
+    applyGivensRight(Q, gc, gs, k, k + 1, 0);
+    if (k < end - 1) {
+      x = H[k + 1][k];
+      y = H[k + 2][k];
+    }
+  }
+}
+function exceptionalShift(H, start, end) {
+  const sub1 = Math.abs(H[end][end - 1]);
+  const sub2 = end - 1 > start ? Math.abs(H[end - 1][end - 2]) : 0;
+  return H[end][end] + 0.75 * (sub1 + sub2);
+}
+function standardize2x2Block(H, Q, p) {
+  const q = p + 1;
+  const a = H[p][p];
+  const b = H[p][q];
+  const c = H[q][p];
+  const d = H[q][q];
+  if (c === 0) return;
+  const half = (a - d) / 2;
+  const disc = half * half + b * c;
+  if (disc < 0) return;
+  const z = Math.sqrt(disc);
+  const lambda = (a + d) / 2 + (half >= 0 ? z : -z);
+  const r0 = Math.hypot(a - lambda, b);
+  const r1 = Math.hypot(c, d - lambda);
+  let u0;
+  let u1;
+  if (r0 >= r1) {
+    u0 = b;
+    u1 = lambda - a;
+  } else {
+    u0 = lambda - d;
+    u1 = c;
+  }
+  const norm4 = Math.hypot(u0, u1);
+  if (norm4 === 0) return;
+  const cs = u0 / norm4;
+  const sn = -u1 / norm4;
+  applyGivensLeft(H, cs, sn, p, q, 0);
+  applyGivensRight(H, cs, sn, p, q, 0);
+  applyGivensRight(Q, cs, sn, p, q, 0);
+  H[q][p] = 0;
+}
 function schurRaw(A, maxIterations, tolerance) {
   const n = A.length;
   if (n === 1) {
@@ -6920,7 +7363,10 @@ function schurRaw(A, maxIterations, tolerance) {
   const { H, Q } = hessenbergReduce(A);
   let end = n - 1;
   let iter = 0;
+  let iterSinceDeflation = 0;
+  const EXCEPTIONAL_EVERY = 10;
   while (end > 0 && iter < maxIterations) {
+    const endBefore = end;
     let start = end;
     while (start > 0) {
       const scale2 = Math.abs(H[start - 1][start - 1]) + Math.abs(H[start][start]);
@@ -6933,14 +7379,16 @@ function schurRaw(A, maxIterations, tolerance) {
     if (start === end) {
       end--;
     } else if (start === end - 1) {
+      standardize2x2Block(H, Q, start);
       end -= 2;
+    } else if (iterSinceDeflation > 0 && iterSinceDeflation % EXCEPTIONAL_EVERY === 0) {
+      qrStepSingleShift(H, Q, start, end, exceptionalShift(H, start, end));
+    } else if (end - start >= 2) {
+      qrStepDouble(H, Q, start, end);
     } else {
-      if (end - start >= 2) {
-        qrStepDouble(H, Q, start, end);
-      } else {
-        qrStepSingle(H, Q, start, end);
-      }
+      qrStepSingle(H, Q, start, end);
     }
+    iterSinceDeflation = end < endBefore ? 0 : iterSinceDeflation + 1;
     iter++;
   }
   return { H, Q };
@@ -7155,7 +7603,7 @@ function logmSchur(A, tol) {
     const scale2 = Math.pow(2, numSqrt);
     logT = logT.map((row2) => row2.map((v) => v * scale2));
   }
-  const Qt = transpose(Q);
+  const Qt = transpose2(Q);
   return matMul(matMul(Q, logT), Qt);
 }
 function validateEigenvalues(A) {
@@ -7189,7 +7637,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(
@@ -7314,9 +7762,9 @@ function sqrtmSymmetric(A) {
   }
   const Ynewton = sqrtmNewton(Asym);
   if (Ynewton !== null) return Ynewton;
-  const Qraw = transpose(vectors);
+  const Qraw = transpose2(vectors);
   const Q = gramSchmidt(Qraw);
-  const Qt = transpose(Q);
+  const Qt = transpose2(Q);
   const Dsqrt = eye(n);
   for (let i = 0; i < n; i++) Dsqrt[i][i] = Math.sqrt(Math.max(values[i].re, 0));
   return matMul(matMul(Q, Dsqrt), Qt);
@@ -7362,7 +7810,7 @@ function sqrtmGeneral(A) {
   const Ynewton = sqrtmNewton(A);
   if (Ynewton !== null) return Ynewton;
   const V = vectors;
-  const Q = transpose(V);
+  const Q = transpose2(V);
   const Qinv = matInv2(Q);
   if (Qinv === null) {
     throw new Error(
@@ -7490,7 +7938,7 @@ function sqrtmSchur(A) {
   const { H: T, Q } = schurInternal(A);
   const U = sqrtmQuasiTriangular(T);
   if (U === null) return null;
-  const Qt = transpose(Q);
+  const Qt = transpose2(Q);
   return matMul(matMul(Q, U), Qt);
 }
 function matrixSqrtm(A, opts) {