@danielsimonjr/mathts-matrix 0.1.12 → 0.1.13

package/dist/wasm/wasm-manifest.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-matrix",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "Matrix operations for MathTS with WASM/WebGPU backend support",
   "author": "Daniel Simon Jr.",
   "license": "MIT",

package/dist/chunk-JRSQE7LB.js

@@ -1,607 +0,0 @@
-// 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((row) => [...row]);
-}
-function transpose(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(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 matMul(A, B) {
-  const m = A.length;
-  const p = A[0].length;
-  const n = B[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 * B[k][j];
-    }
-  }
-  return C;
-}
-function matAdd(A, B) {
-  const n = A.length;
-  return Array.from(
-    { length: n },
-    (_, i) => Array.from({ length: n }, (_2, j) => A[i][j] + B[i][j])
-  );
-}
-function matSub(A, B) {
-  const n = A.length;
-  return Array.from(
-    { length: n },
-    (_, i) => Array.from({ length: n }, (_2, j) => A[i][j] - B[i][j])
-  );
-}
-function matScale(A, c) {
-  return A.map((row) => row.map((v) => v * c));
-}
-function normInf(A) {
-  let mx = 0;
-  for (const row of A) for (const v of row) 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 scale = 0;
-    for (let i = m; i <= high; i++) {
-      scale += Math.abs(H[i * nn + (m - 1)]);
-    }
-    if (scale !== 0) {
-      let h = 0;
-      for (let i = high; i >= m; i--) {
-        ort[i] = H[i * nn + (m - 1)] / scale;
-        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] = scale * ort[m];
-      H[m * nn + (m - 1)] = scale * 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 norm = 0;
-  for (let i = 0; i < nn; i++) {
-    for (let j = Math.max(i - 1, 0); j < nn; j++) {
-      norm += 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 = norm;
-      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 (norm !== 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 * norm);
-            } 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 * norm * (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(matrix, options = {}) {
-  const { 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
-    };
-  }
-  return eigGeneral(A, computeVectors, 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 {
-  eye,
-  cloneMatrix,
-  transpose,
-  isSymmetric,
-  matMul,
-  matAdd,
-  matSub,
-  matScale,
-  normInf,
-  norm1,
-  householder,
-  applyHouseholderLeft,
-  applyHouseholderRight,
-  eig,
-  eigvals,
-  powerIteration
-};

package/dist/eig-PIFFHFJF.js

@@ -1,11 +0,0 @@
-import {
-  eig,
-  eigvals,
-  powerIteration
-} from "./chunk-JRSQE7LB.js";
-import "./chunk-4VMDO6W2.js";
-export {
-  eig,
-  eigvals,
-  powerIteration
-};