@danielsimonjr/mathts-matrix 0.1.8 → 0.1.10

package/dist/wasm/wasm-manifest.json

@@ -1,3 +1,3 @@
 {
-  "mathts-as.wasm": "sha384-5Riad6qN9+B0bHxTlj6fvOwiOYBDx8byKGX6Ojv7RAyrLl6RkKq6CPlpX+oY4QCE"
+  "mathts-as.wasm": "sha384-IyFXb07px2TSL5Si1ZWfdJsjfHUPnsChMrlIyKqxfjkREfaF+4DHtBcuBkpqOhhx"
 }

package/package.json

@@ -1,61 +1,61 @@
-{
-  "name": "@danielsimonjr/mathts-matrix",
-  "version": "0.1.8",
-  "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 && node scripts/copy-wasm.mjs",
-    "copy:wasm": "node scripts/copy-wasm.mjs",
-    "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 && node scripts/copy-wasm.mjs"
-  },
-  "dependencies": {
-    "@danielsimonjr/mathts-core": "^0.1.4",
-    "@danielsimonjr/mathts-parallel": "^0.2.2"
-  },
-  "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.10",
+  "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 && node scripts/copy-wasm.mjs",
+    "copy:wasm": "node scripts/copy-wasm.mjs",
+    "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 && node scripts/copy-wasm.mjs"
+  },
+  "dependencies": {
+    "@danielsimonjr/mathts-core": "^0.1.4",
+    "@danielsimonjr/mathts-parallel": "^0.3.0"
+  },
+  "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"
+  ]
+}

package/dist/chunk-VCPLE6ED.js

@@ -1,473 +0,0 @@
-// src/operations/eig.ts
-var DEFAULT_MAX_ITERATIONS = 1e3;
-var DEFAULT_TOLERANCE = 1e-12;
-function isSymmetric(matrix, tolerance = 1e-10) {
-  const n = matrix.length;
-  if (n === 0) return true;
-  if (matrix[0].length !== n) return false;
-  for (let i = 0; i < n; i++) {
-    for (let j = i + 1; j < n; j++) {
-      if (Math.abs(matrix[i][j] - matrix[j][i]) > tolerance) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-function eye(n) {
-  const I = Array.from({ length: n }, () => new Array(n).fill(0));
-  for (let i = 0; i < n; i++) {
-    I[i][i] = 1;
-  }
-  return I;
-}
-function cloneMatrix(A) {
-  return A.map((row) => [...row]);
-}
-function householder(x) {
-  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: -2 };
-  } 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];
-    }
-  }
-}
-function hessenberg(A) {
-  const n = A.length;
-  const H = cloneMatrix(A);
-  const Q = eye(n);
-  for (let k = 0; k < n - 2; k++) {
-    const x = [];
-    for (let i = k + 1; i < n; i++) {
-      x.push(H[i][k]);
-    }
-    const { v, beta } = householder(x);
-    if (beta !== 0) {
-      applyHouseholderLeft(H, v, beta, k + 1, k);
-      applyHouseholderRight(H, v, beta, 0, k + 1);
-      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;
-    }
-  }
-  return { H, Q };
-}
-function givens(a, b) {
-  if (b === 0) {
-    return { c: 1, s: 0 };
-  } else if (Math.abs(b) > Math.abs(a)) {
-    const t = -a / b;
-    const s = 1 / Math.sqrt(1 + t * t);
-    return { c: s * t, s };
-  } else {
-    const t = -b / a;
-    const c = 1 / Math.sqrt(1 + t * t);
-    return { c, s: c * t };
-  }
-}
-function applyGivensLeft(A, c, s, i, k, startCol) {
-  const n = A[0].length;
-  for (let j = startCol; j < n; j++) {
-    const temp = c * A[i][j] - s * A[k][j];
-    A[k][j] = s * A[i][j] + c * A[k][j];
-    A[i][j] = temp;
-  }
-}
-function applyGivensRight(A, c, s, i, k, startRow) {
-  const m = A.length;
-  for (let j = startRow; j < m; j++) {
-    const temp = c * A[j][i] - s * A[j][k];
-    A[j][k] = s * A[j][i] + c * A[j][k];
-    A[j][i] = temp;
-  }
-}
-function qrStep(H, Q, start, end) {
-  const n = end - start + 1;
-  if (n < 2) return;
-  const a = H[end - 1][end - 1];
-  const b = H[end - 1][end];
-  const c = H[end][end - 1];
-  const d = H[end][end];
-  const trace = a + d;
-  const det = a * d - b * c;
-  const disc = trace * trace - 4 * det;
-  let shift;
-  if (disc >= 0) {
-    const sqrtDisc = Math.sqrt(disc);
-    const e1 = (trace + sqrtDisc) / 2;
-    const e2 = (trace - sqrtDisc) / 2;
-    shift = Math.abs(e1 - d) < Math.abs(e2 - d) ? e1 : e2;
-  } else {
-    shift = d;
-  }
-  let x = H[start][start] - shift;
-  let y = H[start + 1][start];
-  for (let k = start; k < end; k++) {
-    const { c: c2, s } = givens(x, y);
-    applyGivensLeft(H, c2, s, k, k + 1, Math.max(0, k - 1));
-    applyGivensRight(H, c2, s, k, k + 1, 0);
-    applyGivensRight(Q, c2, s, k, k + 1, 0);
-    if (k < end - 1) {
-      x = H[k + 1][k];
-      y = H[k + 2][k];
-    }
-  }
-}
-function doubleShiftQR(H, Q, start, end) {
-  const n = H.length;
-  const a = H[end - 1][end - 1];
-  const b = H[end - 1][end];
-  const c = H[end][end - 1];
-  const d = H[end][end];
-  const s = a + d;
-  const t = a * d - b * c;
-  let x = H[start][start] * H[start][start] + H[start][start + 1] * H[start + 1][start] - s * H[start][start] + t;
-  let y = H[start + 1][start] * (H[start][start] + H[start + 1][start + 1] - s);
-  let z = H[start + 1][start] * H[start + 2][start + 1];
-  for (let k = start; k <= end - 2; k++) {
-    const { v, beta } = householder([x, y, z]);
-    const q = Math.max(start, k - 1);
-    for (let j = q; j < n; j++) {
-      let dot = v[0] * H[k][j] + v[1] * H[k + 1][j] + v[2] * H[k + 2][j];
-      dot *= beta;
-      H[k][j] -= dot * v[0];
-      H[k + 1][j] -= dot * v[1];
-      H[k + 2][j] -= dot * v[2];
-    }
-    const r = Math.min(k + 4, end + 1);
-    for (let i = 0; i < r; i++) {
-      let dot = v[0] * H[i][k] + v[1] * H[i][k + 1] + v[2] * H[i][k + 2];
-      dot *= beta;
-      H[i][k] -= dot * v[0];
-      H[i][k + 1] -= dot * v[1];
-      H[i][k + 2] -= dot * v[2];
-    }
-    for (let i = 0; i < n; i++) {
-      let dot = v[0] * Q[i][k] + v[1] * Q[i][k + 1] + v[2] * Q[i][k + 2];
-      dot *= beta;
-      Q[i][k] -= dot * v[0];
-      Q[i][k + 1] -= dot * v[1];
-      Q[i][k + 2] -= dot * v[2];
-    }
-    x = H[k + 1][k];
-    y = H[k + 2][k];
-    if (k < end - 2) {
-      z = H[k + 3][k];
-    }
-  }
-  const { c: cFinal, s: sFinal } = givens(x, y);
-  applyGivensLeft(H, cFinal, sFinal, end - 1, end, end - 2);
-  applyGivensRight(H, cFinal, sFinal, end - 1, end, 0);
-  applyGivensRight(Q, cFinal, sFinal, end - 1, end, 0);
-}
-function extractEigenvalues(H, tolerance) {
-  const n = H.length;
-  const eigenvalues = [];
-  let i = 0;
-  while (i < n) {
-    if (i === n - 1 || Math.abs(H[i + 1][i]) <= tolerance) {
-      eigenvalues.push({ re: H[i][i], im: 0 });
-      i++;
-    } else {
-      const a = H[i][i];
-      const b = H[i][i + 1];
-      const c = H[i + 1][i];
-      const d = H[i + 1][i + 1];
-      const trace = a + d;
-      const det = a * d - b * c;
-      const disc = trace * trace - 4 * det;
-      if (disc >= 0) {
-        const sqrtDisc = Math.sqrt(disc);
-        eigenvalues.push({ re: (trace + sqrtDisc) / 2, im: 0 });
-        eigenvalues.push({ re: (trace - sqrtDisc) / 2, im: 0 });
-      } else {
-        const realPart = trace / 2;
-        const imagPart = Math.sqrt(-disc) / 2;
-        eigenvalues.push({ re: realPart, im: imagPart });
-        eigenvalues.push({ re: realPart, im: -imagPart });
-      }
-      i += 2;
-    }
-  }
-  return eigenvalues;
-}
-function inverseIteration(A, eigenvalue, tolerance, maxIterations) {
-  const n = A.length;
-  if (eigenvalue.im !== 0) {
-    return new Array(n).fill(0);
-  }
-  const lambda = eigenvalue.re;
-  const shifted = cloneMatrix(A);
-  for (let i = 0; i < n; i++) {
-    shifted[i][i] -= lambda;
-  }
-  for (let i = 0; i < n; i++) {
-    shifted[i][i] += tolerance * 1e3;
-  }
-  const LU = cloneMatrix(shifted);
-  const perm = Array.from({ length: n }, (_, i) => i);
-  for (let k = 0; k < n; k++) {
-    let maxVal = Math.abs(LU[k][k]);
-    let maxIdx = k;
-    for (let i = k + 1; i < n; i++) {
-      if (Math.abs(LU[i][k]) > maxVal) {
-        maxVal = Math.abs(LU[i][k]);
-        maxIdx = i;
-      }
-    }
-    if (maxIdx !== k) {
-      [LU[k], LU[maxIdx]] = [LU[maxIdx], LU[k]];
-      [perm[k], perm[maxIdx]] = [perm[maxIdx], perm[k]];
-    }
-    if (Math.abs(LU[k][k]) < tolerance) {
-      LU[k][k] = tolerance;
-    }
-    for (let i = k + 1; i < n; i++) {
-      LU[i][k] /= LU[k][k];
-      for (let j = k + 1; j < n; j++) {
-        LU[i][j] -= LU[i][k] * LU[k][j];
-      }
-    }
-  }
-  const v = new Array(n).fill(1);
-  let prevNorm = 0;
-  for (let iter = 0; iter < maxIterations; iter++) {
-    const y = new Array(n).fill(0);
-    const b = new Array(n);
-    for (let i = 0; i < n; i++) {
-      b[i] = v[perm[i]];
-    }
-    for (let i = 0; i < n; i++) {
-      y[i] = b[i];
-      for (let j = 0; j < i; j++) {
-        y[i] -= LU[i][j] * y[j];
-      }
-    }
-    const x = new Array(n).fill(0);
-    for (let i = n - 1; i >= 0; i--) {
-      x[i] = y[i];
-      for (let j = i + 1; j < n; j++) {
-        x[i] -= LU[i][j] * x[j];
-      }
-      x[i] /= LU[i][i];
-    }
-    let norm = 0;
-    for (let i = 0; i < n; i++) {
-      norm += x[i] * x[i];
-    }
-    norm = Math.sqrt(norm);
-    if (norm < tolerance) {
-      return x;
-    }
-    for (let i = 0; i < n; i++) {
-      v[i] = x[i] / norm;
-    }
-    if (Math.abs(norm - prevNorm) < tolerance * norm) {
-      break;
-    }
-    prevNorm = norm;
-  }
-  return v;
-}
-function eig(matrix, options = {}) {
-  const {
-    maxIterations = DEFAULT_MAX_ITERATIONS,
-    tolerance = DEFAULT_TOLERANCE,
-    computeVectors = true
-  } = options;
-  let A;
-  if (matrix instanceof Float64Array) {
-    const n2 = Math.sqrt(matrix.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) => matrix[i * n2 + j]));
-  } else {
-    A = matrix;
-  }
-  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
-    };
-  }
-  if (n === 2) {
-    const a = A[0][0], b = A[0][1], c = A[1][0], d = A[1][1];
-    const trace = a + d;
-    const det = a * d - b * c;
-    const disc = trace * trace - 4 * det;
-    let values2;
-    let vectors2;
-    if (disc >= 0) {
-      const sqrtDisc = Math.sqrt(disc);
-      const e1 = (trace + sqrtDisc) / 2;
-      const e2 = (trace - sqrtDisc) / 2;
-      values2 = [
-        { re: e1, im: 0 },
-        { re: e2, im: 0 }
-      ];
-      if (computeVectors) {
-        vectors2 = [];
-        for (const e of [e1, e2]) {
-          if (Math.abs(b) > tolerance) {
-            const v = [b, e - a];
-            const norm = Math.sqrt(v[0] * v[0] + v[1] * v[1]);
-            vectors2.push([v[0] / norm, v[1] / norm]);
-          } else if (Math.abs(c) > tolerance) {
-            const v = [e - d, c];
-            const norm = Math.sqrt(v[0] * v[0] + v[1] * v[1]);
-            vectors2.push([v[0] / norm, v[1] / norm]);
-          } else {
-            vectors2.push(e === a ? [1, 0] : [0, 1]);
-          }
-        }
-      } else {
-        vectors2 = eye(2);
-      }
-    } else {
-      const realPart = trace / 2;
-      const imagPart = Math.sqrt(-disc) / 2;
-      values2 = [
-        { re: realPart, im: imagPart },
-        { re: realPart, im: -imagPart }
-      ];
-      vectors2 = eye(2);
-    }
-    return { values: values2, vectors: vectors2, isSymmetric: symmetric };
-  }
-  const { H, Q } = hessenberg(A);
-  let end = n - 1;
-  let iter = 0;
-  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) {
-        H[start][start - 1] = 0;
-        break;
-      }
-      start--;
-    }
-    if (start === end) {
-      end--;
-    } else if (start === end - 1) {
-      end -= 2;
-    } else {
-      if (iter % 30 === 29) {
-        qrStep(H, Q, start, end);
-      } else if (symmetric) {
-        qrStep(H, Q, start, end);
-      } else {
-        doubleShiftQR(H, Q, start, end);
-      }
-    }
-    iter++;
-  }
-  const values = extractEigenvalues(H, tolerance);
-  let vectors;
-  if (computeVectors) {
-    vectors = [];
-    for (const eigenvalue of values) {
-      const v = inverseIteration(A, eigenvalue, tolerance, 100);
-      vectors.push(v);
-    }
-  } else {
-    vectors = eye(n);
-  }
-  return { values, vectors, isSymmetric: symmetric };
-}
-function eigvals(matrix, options) {
-  return eig(matrix, { ...options, computeVectors: false }).values;
-}
-function powerIteration(matrix, options = {}) {
-  const { maxIterations = 1e3, tolerance = 1e-12 } = options;
-  const n = matrix.length;
-  let v = Array.from({ length: n }, () => Math.random() - 0.5);
-  let norm = Math.sqrt(v.reduce((sum, x) => sum + x * x, 0));
-  v = v.map((x) => x / norm);
-  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] += matrix[i][j] * v[j];
-      }
-    }
-    eigenvalue = v.reduce((sum, vi, i) => sum + vi * w[i], 0);
-    norm = Math.sqrt(w.reduce((sum, x) => sum + x * x, 0));
-    v = w.map((x) => x / norm);
-    if (Math.abs(eigenvalue - prevEigenvalue) < tolerance * Math.abs(eigenvalue)) {
-      break;
-    }
-    prevEigenvalue = eigenvalue;
-  }
-  return { value: eigenvalue, vector: v };
-}
-
-export {
-  eig,
-  eigvals,
-  powerIteration
-};