@danielsimonjr/mathts-matrix 0.1.8 → 0.1.10

package/dist/chunk-HT4ZF3LN.js

@@ -0,0 +1,886 @@
+// 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 DEFAULT_MAX_ITERATIONS = 1e3;
+var DEFAULT_TOLERANCE = 1e-12;
+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 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;
+}
+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 {
+    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 (!symmetric) {
+    return eigGeneral(A, computeVectors, 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 {
+      qrStep(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 {
+  eye,
+  cloneMatrix,
+  transpose,
+  isSymmetric,
+  matMul,
+  matAdd,
+  matSub,
+  matScale,
+  normInf,
+  norm1,
+  householder,
+  applyHouseholderLeft,
+  applyHouseholderRight,
+  eig,
+  eigvals,
+  powerIteration
+};