@danielsimonjr/mathts-matrix 0.1.13 → 0.2.0

package/dist/index.d.ts

@@ -1125,7 +1125,7 @@ declare function getCachedFeatures(): WasmFeatures | null;
  * WASM Matrix Backend (AssemblyScript)
  *
  * Implements MatrixBackend using the AssemblyScript-compiled WebAssembly
- * module (`lib/wasm/mathts-as.wasm`, ~42 KB). Falls back to JSBackend when
+ * module (`dist/wasm/mathts-as.wasm`, ~65 KB). Falls back to JSBackend when
  * the WASM module is unavailable or for small matrices.
  *
  * ABI:
@@ -1178,7 +1178,7 @@ declare function getCachedFeatures(): WasmFeatures | null;
 interface WASMBackendConfig {
     /** Minimum elements to use WASM (default: 100) */
     minElements?: number;
-    /** Path to WASM file (defaults to the AS artifact, `lib/wasm/mathts-as.wasm`) */
+    /** Path to WASM file (defaults to the packaged AS artifact, `dist/wasm/mathts-as.wasm`) */
     wasmPath?: string;
     /** Enable SIMD code paths if the AS module exposes them (currently a no-op
      * — AS export surface does not include `simd*` ops; kept for API stability). */
@@ -1203,11 +1203,7 @@ declare class WASMBackend implements MatrixBackend {
     initialize(): Promise<void>;
     private doInitialize;
     /**
-     * Resolve the path to the AssemblyScript artifact (`lib/wasm/mathts-as.wasm`).
-     *
-     * On Windows, `URL.pathname` returns "/C:/foo/bar.wasm" which fs.readFile
-     * interprets as drive-relative ("C:\C:\foo\..."). `fileURLToPath` does the
-     * platform-correct conversion.
+     * Resolve the path to the AssemblyScript artifact (`dist/wasm/mathts-as.wasm`).
      */
     private resolveAsWasmPath;
     /**
@@ -2478,18 +2474,17 @@ interface SVDOptions {
     maxIterations?: number;
     /** Convergence tolerance */
     tolerance?: number;
-    /** Whether to compute full U and V matrices */
+    /**
+     * Complete the thin factor to a square orthonormal basis (U → m×m for tall
+     * inputs, V → n×n for wide ones), numpy `full_matrices=True` style, so the
+     * rectangular-Σ reconstruction `A = U·Σ·Vᵀ` holds. Default `false` = thin
+     * factors (the library's long-standing behavior; the option was previously
+     * accepted but ignored — B-4).
+     */
     fullMatrices?: boolean;
     /** Threshold for rank determination */
     rankTolerance?: number;
 }
-/**
- * Compute SVD of a matrix
- *
- * @param matrix - Input matrix (m x n)
- * @param options - Computation options
- * @returns SVD decomposition
- */
 declare function svd(matrix: number[][] | Float64Array, options?: SVDOptions): SVDResult;
 /**
  * Compute only singular values (faster than full SVD)

package/dist/index.js

@@ -2481,22 +2481,17 @@ var WASMBackend = class {
     }
   }
   /**
-   * Resolve the path to the AssemblyScript artifact (`lib/wasm/mathts-as.wasm`).
-   *
-   * On Windows, `URL.pathname` returns "/C:/foo/bar.wasm" which fs.readFile
-   * interprets as drive-relative ("C:\C:\foo\..."). `fileURLToPath` does the
-   * platform-correct conversion.
+   * Resolve the path to the AssemblyScript artifact (`dist/wasm/mathts-as.wasm`).
    */
   async resolveAsWasmPath() {
     const isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
+    const { resolvePackagedWasm, defaultWasmLocation } = await import("./resolve-VJX3YTS6.js");
     if (isNode) {
-      const { resolvePackagedWasm } = await import("./resolve-JRHDDNVQ.js");
       const found = await resolvePackagedWasm(import.meta.url, "mathts-as.wasm");
       if (found) return found;
-      const { fileURLToPath } = await import("url");
-      return fileURLToPath(new URL(`../../../lib/wasm/mathts-as.wasm`, import.meta.url));
+      return defaultWasmLocation(import.meta.url, "mathts-as.wasm");
     }
-    return new URL(`../../../lib/wasm/mathts-as.wasm`, import.meta.url).href;
+    return defaultWasmLocation(import.meta.url, "mathts-as.wasm", { browser: true });
   }
   /**
    * Compile + instantiate the AssemblyScript WASM artifact. Each
@@ -5483,27 +5478,22 @@ var WasmLoader = class _WasmLoader {
    * (`mathts-as.wasm`); the legacy second toolchain was removed in the
    * WASM-backend migration (complete 2026-06-26).
    *
-   * The path is resolved relative to this source file's location so it is
-   * CWD-independent.  This file lives at:
-   *   <repo-root>/matrix/src/backends/WasmLoader.ts
-   * so the repo root is three directories up, and the artifact is at
-   *   <repo-root>/lib/wasm/mathts-as.wasm
-   *
-   * Both branches use `new URL(relative, import.meta.url)` to resolve a
-   * file: URL. In Node we convert via `fileURLToPath` (which correctly
-   * strips the leading slash on Windows so the drive letter is not
-   * doubled); in the browser we keep the full `.href` for fetch().
+   * Resolution is package-relative and CWD-independent: the packaged artifact
+   * (`dist/wasm/`) is preferred via `resolvePackagedWasm`; when absent, the
+   * canonical expected location is returned so the missing-binary warning is
+   * actionable (see `defaultWasmLocation` in wasm/resolve.ts — B-3).
    */
   async getDefaultWasmPath() {
     const wasmFile = "mathts-as.wasm";
     if (this.isNode) {
-      const { resolvePackagedWasm } = await import("./resolve-JRHDDNVQ.js");
+      const { resolvePackagedWasm } = await import("./resolve-VJX3YTS6.js");
       const found = await resolvePackagedWasm(import.meta.url, wasmFile);
       if (found) return found;
-      const { fileURLToPath } = await import("url");
-      return fileURLToPath(new URL(`../../../lib/wasm/${wasmFile}`, import.meta.url));
+      const { defaultWasmLocation: defaultWasmLocation2 } = await import("./resolve-VJX3YTS6.js");
+      return defaultWasmLocation2(import.meta.url, wasmFile);
     }
-    return new URL(`../../../lib/wasm/${wasmFile}`, import.meta.url).href;
+    const { defaultWasmLocation } = await import("./resolve-VJX3YTS6.js");
+    return defaultWasmLocation(import.meta.url, wasmFile, { browser: true });
   }
   async loadNodeWasm(path, totalStart) {
     const fs = await import("fs");
@@ -6544,11 +6534,110 @@ 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 completeOrthonormalBasis(cols, m) {
+  const k = cols[0]?.length ?? 0;
+  const basis = Array.from({ length: k }, (_, j) => cols.map((row2) => row2[j]));
+  for (let cand = 0; cand < m && basis.length < m; cand++) {
+    const v = Array.from({ length: m }, (_, i) => i === cand ? 1 : 0);
+    for (let pass = 0; pass < 2; pass++) {
+      for (const b of basis) {
+        let dot = 0;
+        for (let i = 0; i < m; i++) dot += v[i] * b[i];
+        for (let i = 0; i < m; i++) v[i] -= dot * b[i];
+      }
+    }
+    let norm4 = 0;
+    for (let i = 0; i < m; i++) norm4 += v[i] * v[i];
+    norm4 = Math.sqrt(norm4);
+    if (norm4 > 0.1) {
+      basis.push(v.map((x) => x / norm4));
+    }
+  }
+  return Array.from({ length: m }, (_, i) => basis.map((b) => b[i]));
+}
 function svd(matrix2, options = {}) {
   const {
     maxIterations = DEFAULT_MAX_ITERATIONS,
     tolerance = DEFAULT_TOLERANCE,
-    fullMatrices: _fullMatrices = true,
+    fullMatrices = false,
     rankTolerance = 1e-10
   } = options;
   let A;
@@ -6615,19 +6704,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) {
@@ -6639,12 +6738,12 @@ function svd(matrix2, options = {}) {
     return {
       U: sortedV,
       S: sortedS,
-      V: sortedU,
+      V: fullMatrices && sortedU.length > (sortedU[0]?.length ?? 0) ? completeOrthonormalBasis(sortedU, sortedU.length) : sortedU,
       rank
     };
   }
   return {
-    U: sortedU,
+    U: fullMatrices && sortedU.length > (sortedU[0]?.length ?? 0) ? completeOrthonormalBasis(sortedU, sortedU.length) : sortedU,
     S: sortedS,
     V: sortedV,
     rank
@@ -7111,8 +7210,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 +7315,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 +7374,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 +7390,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/dist/{resolve-JRHDDNVQ.js → resolve-VJX3YTS6.js}

@@ -19,6 +19,25 @@ async function resolvePackagedWasm(metaUrl, wasmFile) {
   }
   return null;
 }
+async function defaultWasmLocation(metaUrl, wasmFile, opts) {
+  if (opts?.browser) {
+    return new URL(`./wasm/${wasmFile}`, metaUrl).href;
+  }
+  const { fileURLToPath } = await import("url");
+  const { dirname, join } = await import("path");
+  const { existsSync } = await import("fs");
+  let dir = dirname(fileURLToPath(metaUrl));
+  for (let depth = 0; depth < 8; depth++) {
+    if (existsSync(join(dir, "package.json"))) {
+      return join(dir, "dist", "wasm", wasmFile);
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return join(dirname(fileURLToPath(metaUrl)), "wasm", wasmFile);
+}
 export {
+  defaultWasmLocation,
   resolvePackagedWasm
 };

package/dist/wasm/wasm-manifest.json

@@ -1,3 +1,3 @@
 {
-  "mathts-as.wasm": "sha384-eSck1dw9Rtu8oUAQ/0GMpC1L4bhAPNVS72581QGAyd1xDlRvonQT/XA2RZjpxghB"
+  "mathts-as.wasm": "sha384-q4RGhtVhsLmeCfG5lYpL70f51laygEpfcKGuxKWFnoC9iSXZPXMUEYE9V8W8gYZu"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-matrix",
-  "version": "0.1.13",
+  "version": "0.2.0",
   "description": "Matrix operations for MathTS with WASM/WebGPU backend support",
   "author": "Daniel Simon Jr.",
   "license": "MIT",
@@ -32,8 +32,8 @@
     "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-parallel": "^0.3.0"
+    "@danielsimonjr/mathts-core": "^0.5.0",
+    "@danielsimonjr/mathts-parallel": "^0.3.2"
   },
   "devDependencies": {
     "@types/node": "^25.5.2",