@danielsimonjr/mathts-matrix 0.1.13 → 0.1.14

package/dist/index.js

@@ -6544,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,
@@ -6615,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) {
@@ -7111,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) {
@@ -7217,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) {
@@ -7225,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]);
@@ -7238,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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-matrix",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "Matrix operations for MathTS with WASM/WebGPU backend support",
   "author": "Daniel Simon Jr.",
   "license": "MIT",
@@ -32,7 +32,7 @@
     "build:prod": "tsup src/index.ts --format esm --dts --clean --minify --treeshake && node scripts/copy-wasm.mjs"
   },
   "dependencies": {
-    "@danielsimonjr/mathts-core": "^0.3.0",
+    "@danielsimonjr/mathts-core": "^0.4.0",
     "@danielsimonjr/mathts-parallel": "^0.3.0"
   },
   "devDependencies": {