numbl 0.4.19 → 0.4.21

package/dist-lib/lib.js

@@ -372,6 +372,9 @@ var RuntimeSparseMatrix = class extends Refcounted {
   jc;
   pr;
   pi;
+  /** Lazily computed by triangularInfo(); valid because sparse matrices are
+   *  never mutated in place (indexed assignment builds a new matrix). */
+  _triInfo = void 0;
   constructor(m, n, ir, jc, pr, pi2) {
     super();
     this.m = m;
@@ -1171,6 +1174,7 @@ function formatClassInstance(v) {
   const lines = [`  ${v.className} with properties:
 `];
   for (const [key, val] of v.fields) {
+    if (key.startsWith("_")) continue;
     lines.push(`    ${key}: ${displayValue(val)}`);
   }
   return lines.join("\n");
@@ -1484,6 +1488,8 @@ var PIVOT_T = 1;
 var PIVOT_B = 2;
 var DIRECT_F = 0;
 var DIRECT_B = 1;
+var SORT_INC = 0;
+var SORT_DEC = 1;
 var VECT_Q = 0;
 var VECT_P = 1;
 
@@ -18090,6 +18096,1357 @@ function eigComplexTs(dataRe, dataIm, n, computeVL, computeVR) {
   return result;
 }
 
+// src/ts-lapack/src/SRC/dlanst.ts
+var NORM_MAX5 = 0;
+var NORM_ONE2 = 1;
+var NORM_INF2 = 2;
+var NORM_FRO2 = 3;
+function dlanst(norm2, n, d, dOff, e, eOff) {
+  let anorm = 0;
+  if (n <= 0) {
+    anorm = 0;
+  } else if (norm2 === NORM_MAX5) {
+    anorm = Math.abs(d[dOff + (n - 1)]);
+    for (let i = 1; i <= n - 1; i++) {
+      let sum2 = Math.abs(d[dOff + (i - 1)]);
+      if (anorm < sum2 || Number.isNaN(sum2)) anorm = sum2;
+      sum2 = Math.abs(e[eOff + (i - 1)]);
+      if (anorm < sum2 || Number.isNaN(sum2)) anorm = sum2;
+    }
+  } else if (norm2 === NORM_ONE2 || norm2 === NORM_INF2) {
+    if (n === 1) {
+      anorm = Math.abs(d[dOff]);
+    } else {
+      anorm = Math.abs(d[dOff]) + Math.abs(e[eOff]);
+      let sum2 = Math.abs(e[eOff + (n - 2)]) + Math.abs(d[dOff + (n - 1)]);
+      if (anorm < sum2 || Number.isNaN(sum2)) anorm = sum2;
+      for (let i = 2; i <= n - 1; i++) {
+        sum2 = Math.abs(d[dOff + (i - 1)]) + Math.abs(e[eOff + (i - 1)]) + Math.abs(e[eOff + (i - 2)]);
+        if (anorm < sum2 || Number.isNaN(sum2)) anorm = sum2;
+      }
+    }
+  } else if (norm2 === NORM_FRO2) {
+    const scale = { val: 0 };
+    const sum2 = { val: 1 };
+    if (n > 1) {
+      dlassq(n - 1, e, eOff, 1, scale, sum2);
+      sum2.val = 2 * sum2.val;
+    }
+    dlassq(n, d, dOff, 1, scale, sum2);
+    anorm = scale.val * Math.sqrt(sum2.val);
+  }
+  return anorm;
+}
+
+// src/ts-lapack/src/SRC/dlae2.ts
+function dlae2(a, b, c) {
+  const ONE10 = 1;
+  const TWO = 2;
+  const HALF = 0.5;
+  const sm = a + c;
+  const df = a - c;
+  const adf = Math.abs(df);
+  const tb = b + b;
+  const ab = Math.abs(tb);
+  let acmx, acmn;
+  if (Math.abs(a) > Math.abs(c)) {
+    acmx = a;
+    acmn = c;
+  } else {
+    acmx = c;
+    acmn = a;
+  }
+  let rt;
+  if (adf > ab) {
+    rt = adf * Math.sqrt(ONE10 + (ab / adf) ** 2);
+  } else if (adf < ab) {
+    rt = ab * Math.sqrt(ONE10 + (adf / ab) ** 2);
+  } else {
+    rt = ab * Math.sqrt(TWO);
+  }
+  let rt1, rt2;
+  if (sm < 0) {
+    rt1 = HALF * (sm - rt);
+    rt2 = acmx / rt1 * acmn - b / rt1 * b;
+  } else if (sm > 0) {
+    rt1 = HALF * (sm + rt);
+    rt2 = acmx / rt1 * acmn - b / rt1 * b;
+  } else {
+    rt1 = HALF * rt;
+    rt2 = -HALF * rt;
+  }
+  return { rt1, rt2 };
+}
+
+// src/ts-lapack/src/SRC/dlaev2.ts
+function dlaev2(a, b, c) {
+  const ONE10 = 1;
+  const TWO = 2;
+  const HALF = 0.5;
+  const sm = a + c;
+  const df = a - c;
+  const adf = Math.abs(df);
+  const tb = b + b;
+  const ab = Math.abs(tb);
+  let acmx, acmn;
+  if (Math.abs(a) > Math.abs(c)) {
+    acmx = a;
+    acmn = c;
+  } else {
+    acmx = c;
+    acmn = a;
+  }
+  let rt;
+  if (adf > ab) {
+    rt = adf * Math.sqrt(ONE10 + (ab / adf) ** 2);
+  } else if (adf < ab) {
+    rt = ab * Math.sqrt(ONE10 + (adf / ab) ** 2);
+  } else {
+    rt = ab * Math.sqrt(TWO);
+  }
+  let rt1, rt2, sgn1;
+  if (sm < 0) {
+    rt1 = HALF * (sm - rt);
+    sgn1 = -1;
+    rt2 = acmx / rt1 * acmn - b / rt1 * b;
+  } else if (sm > 0) {
+    rt1 = HALF * (sm + rt);
+    sgn1 = 1;
+    rt2 = acmx / rt1 * acmn - b / rt1 * b;
+  } else {
+    rt1 = HALF * rt;
+    rt2 = -HALF * rt;
+    sgn1 = 1;
+  }
+  let cs, sgn2;
+  if (df >= 0) {
+    cs = df + rt;
+    sgn2 = 1;
+  } else {
+    cs = df - rt;
+    sgn2 = -1;
+  }
+  let cs1, sn1;
+  const acs = Math.abs(cs);
+  if (acs > ab) {
+    const ct = -tb / cs;
+    sn1 = ONE10 / Math.sqrt(ONE10 + ct * ct);
+    cs1 = ct * sn1;
+  } else {
+    if (ab === 0) {
+      cs1 = ONE10;
+      sn1 = 0;
+    } else {
+      const tn = -cs / tb;
+      cs1 = ONE10 / Math.sqrt(ONE10 + tn * tn);
+      sn1 = tn * cs1;
+    }
+  }
+  if (sgn1 === sgn2) {
+    const tn = cs1;
+    cs1 = -sn1;
+    sn1 = tn;
+  }
+  return { rt1, rt2, cs1, sn1 };
+}
+
+// src/ts-lapack/src/SRC/dlasrt.ts
+function dlasrt(id, n, d, dOff) {
+  const SELECT = 20;
+  let info = 0;
+  let dir = -1;
+  if (id === SORT_DEC) {
+    dir = 0;
+  } else if (id === SORT_INC) {
+    dir = 1;
+  }
+  if (dir === -1) {
+    info = -1;
+  } else if (n < 0) {
+    info = -2;
+  }
+  if (info !== 0) {
+    return info;
+  }
+  if (n <= 1) {
+    return 0;
+  }
+  const stack1 = new Int32Array(33);
+  const stack2 = new Int32Array(33);
+  let stkpnt = 1;
+  stack1[1] = 1;
+  stack2[1] = n;
+  while (stkpnt > 0) {
+    const start = stack1[stkpnt];
+    const endd = stack2[stkpnt];
+    stkpnt--;
+    if (endd - start <= SELECT && endd - start > 0) {
+      if (dir === 0) {
+        for (let i = start + 1; i <= endd; i++) {
+          for (let j = i; j >= start + 1; j--) {
+            if (d[dOff + (j - 1)] > d[dOff + (j - 2)]) {
+              const dmnmx = d[dOff + (j - 1)];
+              d[dOff + (j - 1)] = d[dOff + (j - 2)];
+              d[dOff + (j - 2)] = dmnmx;
+            } else {
+              break;
+            }
+          }
+        }
+      } else {
+        for (let i = start + 1; i <= endd; i++) {
+          for (let j = i; j >= start + 1; j--) {
+            if (d[dOff + (j - 1)] < d[dOff + (j - 2)]) {
+              const dmnmx = d[dOff + (j - 1)];
+              d[dOff + (j - 1)] = d[dOff + (j - 2)];
+              d[dOff + (j - 2)] = dmnmx;
+            } else {
+              break;
+            }
+          }
+        }
+      }
+    } else if (endd - start > SELECT) {
+      const d1 = d[dOff + (start - 1)];
+      const d2 = d[dOff + (endd - 1)];
+      const ii = Math.trunc((start + endd) / 2);
+      const d3 = d[dOff + (ii - 1)];
+      let dmnmx;
+      if (d1 < d2) {
+        if (d3 < d1) {
+          dmnmx = d1;
+        } else if (d3 < d2) {
+          dmnmx = d3;
+        } else {
+          dmnmx = d2;
+        }
+      } else {
+        if (d3 < d2) {
+          dmnmx = d2;
+        } else if (d3 < d1) {
+          dmnmx = d3;
+        } else {
+          dmnmx = d1;
+        }
+      }
+      let i;
+      let j;
+      if (dir === 0) {
+        i = start - 1;
+        j = endd + 1;
+        while (true) {
+          do {
+            j--;
+          } while (d[dOff + (j - 1)] < dmnmx);
+          do {
+            i++;
+          } while (d[dOff + (i - 1)] > dmnmx);
+          if (i < j) {
+            const tmp = d[dOff + (i - 1)];
+            d[dOff + (i - 1)] = d[dOff + (j - 1)];
+            d[dOff + (j - 1)] = tmp;
+          } else {
+            break;
+          }
+        }
+        if (j - start > endd - j - 1) {
+          stkpnt++;
+          stack1[stkpnt] = start;
+          stack2[stkpnt] = j;
+          stkpnt++;
+          stack1[stkpnt] = j + 1;
+          stack2[stkpnt] = endd;
+        } else {
+          stkpnt++;
+          stack1[stkpnt] = j + 1;
+          stack2[stkpnt] = endd;
+          stkpnt++;
+          stack1[stkpnt] = start;
+          stack2[stkpnt] = j;
+        }
+      } else {
+        i = start - 1;
+        j = endd + 1;
+        while (true) {
+          do {
+            j--;
+          } while (d[dOff + (j - 1)] > dmnmx);
+          do {
+            i++;
+          } while (d[dOff + (i - 1)] < dmnmx);
+          if (i < j) {
+            const tmp = d[dOff + (i - 1)];
+            d[dOff + (i - 1)] = d[dOff + (j - 1)];
+            d[dOff + (j - 1)] = tmp;
+          } else {
+            break;
+          }
+        }
+        if (j - start > endd - j - 1) {
+          stkpnt++;
+          stack1[stkpnt] = start;
+          stack2[stkpnt] = j;
+          stkpnt++;
+          stack1[stkpnt] = j + 1;
+          stack2[stkpnt] = endd;
+        } else {
+          stkpnt++;
+          stack1[stkpnt] = j + 1;
+          stack2[stkpnt] = endd;
+          stkpnt++;
+          stack1[stkpnt] = start;
+          stack2[stkpnt] = j;
+        }
+      }
+    }
+  }
+  return 0;
+}
+
+// src/ts-lapack/src/SRC/dsteqr.ts
+var COMPZ_N = 0;
+var COMPZ_V = 1;
+var COMPZ_I = 2;
+var NORM_MAX6 = 0;
+var TYPE_G3 = 0;
+var UPLO_FULL2 = -1;
+function fsign6(a, b) {
+  return b >= 0 ? Math.abs(a) : -Math.abs(a);
+}
+function dsteqr(compz, n, d, dOff, e, eOff, z, zOff, ldz, work, workOff) {
+  const ZERO9 = 0;
+  const ONE10 = 1;
+  const TWO = 2;
+  const THREE = 3;
+  const MAXIT = 30;
+  let info = 0;
+  if (compz !== COMPZ_N && compz !== COMPZ_V && compz !== COMPZ_I) {
+    info = -1;
+  } else if (n < 0) {
+    info = -2;
+  } else if (ldz < 1 || compz > 0 && ldz < Math.max(1, n)) {
+    info = -6;
+  }
+  if (info !== 0) {
+    xerbla("DSTEQR", -info);
+    return info;
+  }
+  if (n === 0) return 0;
+  if (n === 1) {
+    if (compz === COMPZ_I) z[zOff] = ONE10;
+    return 0;
+  }
+  const D = (i) => dOff + (i - 1);
+  const E = (i) => eOff + (i - 1);
+  const Zc = (j) => zOff + (j - 1) * ldz;
+  const W = (i) => workOff + (i - 1);
+  const eps2 = dlamch(MACH_EPS);
+  const eps22 = eps2 * eps2;
+  const safmin = dlamch(MACH_SFMIN);
+  const safmax = ONE10 / safmin;
+  const ssfmax = Math.sqrt(safmax) / THREE;
+  const ssfmin = Math.sqrt(safmin) / eps22;
+  if (compz === COMPZ_I) dlaset(UPLO_FULL2, n, n, ZERO9, ONE10, z, zOff, ldz);
+  const nmaxit = n * MAXIT;
+  let jtot = 0;
+  let l1 = 1;
+  const nm1 = n - 1;
+  let ordered = false;
+  outer: for (; ; ) {
+    if (l1 > n) {
+      ordered = true;
+      break outer;
+    }
+    if (l1 > 1) e[E(l1 - 1)] = ZERO9;
+    let m = n;
+    if (l1 <= nm1) {
+      let split = false;
+      for (m = l1; m <= nm1; m++) {
+        const tst = Math.abs(e[E(m)]);
+        if (tst === ZERO9) {
+          split = true;
+          break;
+        }
+        if (tst <= Math.sqrt(Math.abs(d[D(m)])) * Math.sqrt(Math.abs(d[D(m + 1)])) * eps2) {
+          e[E(m)] = ZERO9;
+          split = true;
+          break;
+        }
+      }
+      if (!split) m = n;
+    }
+    let l = l1;
+    const lsv = l;
+    let lend = m;
+    const lendsv = lend;
+    l1 = m + 1;
+    if (lend === l) continue outer;
+    const anorm = dlanst(NORM_MAX6, lend - l + 1, d, D(l), e, E(l));
+    let iscale = 0;
+    if (anorm === ZERO9) continue outer;
+    if (anorm > ssfmax) {
+      iscale = 1;
+      dlascl(TYPE_G3, 0, 0, anorm, ssfmax, lend - l + 1, 1, d, D(l), n);
+      dlascl(TYPE_G3, 0, 0, anorm, ssfmax, lend - l, 1, e, E(l), n);
+    } else if (anorm < ssfmin) {
+      iscale = 2;
+      dlascl(TYPE_G3, 0, 0, anorm, ssfmin, lend - l + 1, 1, d, D(l), n);
+      dlascl(TYPE_G3, 0, 0, anorm, ssfmin, lend - l, 1, e, E(l), n);
+    }
+    if (Math.abs(d[D(lend)]) < Math.abs(d[D(l)])) {
+      lend = lsv;
+      l = lendsv;
+    }
+    if (lend > l) {
+      ql: for (; ; ) {
+        if (l !== lend) {
+          let found = false;
+          for (m = l; m <= lend - 1; m++) {
+            const tst = Math.abs(e[E(m)]) ** 2;
+            if (tst <= eps22 * Math.abs(d[D(m)]) * Math.abs(d[D(m + 1)]) + safmin) {
+              found = true;
+              break;
+            }
+          }
+          if (!found) m = lend;
+        } else {
+          m = lend;
+        }
+        if (m < lend) e[E(m)] = ZERO9;
+        let p2 = d[D(l)];
+        if (m === l) {
+          d[D(l)] = p2;
+          l = l + 1;
+          if (l <= lend) continue ql;
+          break ql;
+        }
+        if (m === l + 1) {
+          if (compz > 0) {
+            const r2 = dlaev2(d[D(l)], e[E(l)], d[D(l + 1)]);
+            work[W(l)] = r2.cs1;
+            work[W(n - 1 + l)] = r2.sn1;
+            dlasr(
+              RIGHT,
+              PIVOT_V,
+              DIRECT_B,
+              n,
+              2,
+              work,
+              W(l),
+              work,
+              W(n - 1 + l),
+              z,
+              Zc(l),
+              ldz
+            );
+            d[D(l)] = r2.rt1;
+            d[D(l + 1)] = r2.rt2;
+          } else {
+            const r2 = dlae2(d[D(l)], e[E(l)], d[D(l + 1)]);
+            d[D(l)] = r2.rt1;
+            d[D(l + 1)] = r2.rt2;
+          }
+          e[E(l)] = ZERO9;
+          l = l + 2;
+          if (l <= lend) continue ql;
+          break ql;
+        }
+        if (jtot === nmaxit) break ql;
+        jtot = jtot + 1;
+        let g = (d[D(l + 1)] - p2) / (TWO * e[E(l)]);
+        let r = dlapy2(g, ONE10);
+        g = d[D(m)] - p2 + e[E(l)] / (g + fsign6(r, g));
+        let s = ONE10;
+        let c = ONE10;
+        p2 = ZERO9;
+        for (let i = m - 1; i >= l; i--) {
+          const f = s * e[E(i)];
+          const b = c * e[E(i)];
+          const rot = dlartg(g, f);
+          c = rot.cs;
+          s = rot.sn;
+          r = rot.r;
+          if (i !== m - 1) e[E(i + 1)] = r;
+          g = d[D(i + 1)] - p2;
+          r = (d[D(i)] - g) * s + TWO * c * b;
+          p2 = s * r;
+          d[D(i + 1)] = g + p2;
+          g = c * r - b;
+          if (compz > 0) {
+            work[W(i)] = c;
+            work[W(n - 1 + i)] = -s;
+          }
+        }
+        if (compz > 0) {
+          const mm = m - l + 1;
+          dlasr(
+            RIGHT,
+            PIVOT_V,
+            DIRECT_B,
+            n,
+            mm,
+            work,
+            W(l),
+            work,
+            W(n - 1 + l),
+            z,
+            Zc(l),
+            ldz
+          );
+        }
+        d[D(l)] = d[D(l)] - p2;
+        e[E(l)] = g;
+        continue ql;
+      }
+    } else {
+      qr: for (; ; ) {
+        if (l !== lend) {
+          let found = false;
+          for (m = l; m >= lend + 1; m--) {
+            const tst = Math.abs(e[E(m - 1)]) ** 2;
+            if (tst <= eps22 * Math.abs(d[D(m)]) * Math.abs(d[D(m - 1)]) + safmin) {
+              found = true;
+              break;
+            }
+          }
+          if (!found) m = lend;
+        } else {
+          m = lend;
+        }
+        if (m > lend) e[E(m - 1)] = ZERO9;
+        let p2 = d[D(l)];
+        if (m === l) {
+          d[D(l)] = p2;
+          l = l - 1;
+          if (l >= lend) continue qr;
+          break qr;
+        }
+        if (m === l - 1) {
+          if (compz > 0) {
+            const r2 = dlaev2(d[D(l - 1)], e[E(l - 1)], d[D(l)]);
+            work[W(m)] = r2.cs1;
+            work[W(n - 1 + m)] = r2.sn1;
+            dlasr(
+              RIGHT,
+              PIVOT_V,
+              DIRECT_F,
+              n,
+              2,
+              work,
+              W(m),
+              work,
+              W(n - 1 + m),
+              z,
+              Zc(l - 1),
+              ldz
+            );
+            d[D(l - 1)] = r2.rt1;
+            d[D(l)] = r2.rt2;
+          } else {
+            const r2 = dlae2(d[D(l - 1)], e[E(l - 1)], d[D(l)]);
+            d[D(l - 1)] = r2.rt1;
+            d[D(l)] = r2.rt2;
+          }
+          e[E(l - 1)] = ZERO9;
+          l = l - 2;
+          if (l >= lend) continue qr;
+          break qr;
+        }
+        if (jtot === nmaxit) break qr;
+        jtot = jtot + 1;
+        let g = (d[D(l - 1)] - p2) / (TWO * e[E(l - 1)]);
+        let r = dlapy2(g, ONE10);
+        g = d[D(m)] - p2 + e[E(l - 1)] / (g + fsign6(r, g));
+        let s = ONE10;
+        let c = ONE10;
+        p2 = ZERO9;
+        for (let i = m; i <= l - 1; i++) {
+          const f = s * e[E(i)];
+          const b = c * e[E(i)];
+          const rot = dlartg(g, f);
+          c = rot.cs;
+          s = rot.sn;
+          r = rot.r;
+          if (i !== m) e[E(i - 1)] = r;
+          g = d[D(i)] - p2;
+          r = (d[D(i + 1)] - g) * s + TWO * c * b;
+          p2 = s * r;
+          d[D(i)] = g + p2;
+          g = c * r - b;
+          if (compz > 0) {
+            work[W(i)] = c;
+            work[W(n - 1 + i)] = s;
+          }
+        }
+        if (compz > 0) {
+          const mm = l - m + 1;
+          dlasr(
+            RIGHT,
+            PIVOT_V,
+            DIRECT_F,
+            n,
+            mm,
+            work,
+            W(m),
+            work,
+            W(n - 1 + m),
+            z,
+            Zc(m),
+            ldz
+          );
+        }
+        d[D(l)] = d[D(l)] - p2;
+        e[E(l - 1)] = g;
+        continue qr;
+      }
+    }
+    if (iscale === 1) {
+      dlascl(TYPE_G3, 0, 0, ssfmax, anorm, lendsv - lsv + 1, 1, d, D(lsv), n);
+      dlascl(TYPE_G3, 0, 0, ssfmax, anorm, lendsv - lsv, 1, e, E(lsv), n);
+    } else if (iscale === 2) {
+      dlascl(TYPE_G3, 0, 0, ssfmin, anorm, lendsv - lsv + 1, 1, d, D(lsv), n);
+      dlascl(TYPE_G3, 0, 0, ssfmin, anorm, lendsv - lsv, 1, e, E(lsv), n);
+    }
+    if (jtot < nmaxit) continue outer;
+    for (let i = 1; i <= n - 1; i++) {
+      if (e[E(i)] !== ZERO9) info = info + 1;
+    }
+    break outer;
+  }
+  if (!ordered) return info;
+  if (compz === COMPZ_N) {
+    const sortInfo = dlasrt(SORT_INC, n, d, dOff);
+    if (sortInfo !== 0) return sortInfo;
+  } else {
+    for (let ii = 2; ii <= n; ii++) {
+      const i = ii - 1;
+      let k = i;
+      let p2 = d[D(i)];
+      for (let j = ii; j <= n; j++) {
+        if (d[D(j)] < p2) {
+          k = j;
+          p2 = d[D(j)];
+        }
+      }
+      if (k !== i) {
+        d[D(k)] = d[D(i)];
+        d[D(i)] = p2;
+        dswap(n, z, Zc(i), 1, z, Zc(k), 1);
+      }
+    }
+  }
+  return info;
+}
+
+// src/numbl-core/native/ts-lapack-eig-hermitian.ts
+var EPS2 = 2220446049250313e-31;
+var SAFMIN2 = 22250738585072014e-324;
+function dlapy3(x, y, z) {
+  const w = Math.max(Math.abs(x), Math.abs(y), Math.abs(z));
+  if (w === 0 || !Number.isFinite(w))
+    return Math.abs(x) + Math.abs(y) + Math.abs(z);
+  return w * Math.sqrt((x / w) ** 2 + (y / w) ** 2 + (z / w) ** 2);
+}
+function fsign7(mag2, s) {
+  return s >= 0 ? Math.abs(mag2) : -Math.abs(mag2);
+}
+function cdiv2(ar, ai, br, bi) {
+  if (Math.abs(br) >= Math.abs(bi)) {
+    const r2 = bi / br;
+    const t2 = br + bi * r2;
+    return [(ar + ai * r2) / t2, (ai - ar * r2) / t2];
+  }
+  const r = br / bi;
+  const t = br * r + bi;
+  return [(ar * r + ai) / t, (ai * r - ar) / t];
+}
+function dznrm2(n, re, im, off, incx) {
+  let scale = 0;
+  let ssq = 1;
+  for (let i = 0, k = off; i < n; i++, k += incx) {
+    for (const v of [re[k], im[k]]) {
+      if (v !== 0) {
+        const a = Math.abs(v);
+        if (scale < a) {
+          ssq = 1 + ssq * (scale / a) ** 2;
+          scale = a;
+        } else {
+          ssq += (a / scale) ** 2;
+        }
+      }
+    }
+  }
+  return scale * Math.sqrt(ssq);
+}
+function zlarfg2(n, re, im, off, incx) {
+  if (n <= 0) return { tauRe: 0, tauIm: 0 };
+  let xnorm = dznrm2(n - 1, re, im, off + incx, incx);
+  let alphr = re[off];
+  let alphi = im[off];
+  if (xnorm === 0 && alphi === 0) {
+    return { tauRe: 0, tauIm: 0 };
+  }
+  let beta = -fsign7(dlapy3(alphr, alphi, xnorm), alphr);
+  const safmin = SAFMIN2 / EPS2;
+  const rsafmn = 1 / safmin;
+  let knt = 0;
+  if (Math.abs(beta) < safmin) {
+    do {
+      knt++;
+      for (let i = 1, k = off + incx; i < n; i++, k += incx) {
+        re[k] *= rsafmn;
+        im[k] *= rsafmn;
+      }
+      beta *= rsafmn;
+      alphi *= rsafmn;
+      alphr *= rsafmn;
+    } while (Math.abs(beta) < safmin && knt < 20);
+    xnorm = dznrm2(n - 1, re, im, off + incx, incx);
+    beta = -fsign7(dlapy3(alphr, alphi, xnorm), alphr);
+  }
+  const tauRe = (beta - alphr) / beta;
+  const tauIm = -alphi / beta;
+  const [sr, si] = cdiv2(1, 0, alphr - beta, alphi);
+  for (let i = 1, k = off + incx; i < n; i++, k += incx) {
+    const xr = re[k];
+    const xi = im[k];
+    re[k] = xr * sr - xi * si;
+    im[k] = xr * si + xi * sr;
+  }
+  for (let j = 1; j <= knt; j++) beta *= safmin;
+  re[off] = beta;
+  im[off] = 0;
+  return { tauRe, tauIm };
+}
+function zhemvLower(n, alphaRe, alphaIm, aRe, aIm, aOff, lda, xRe, xIm, xOff, yRe, yIm, yOff) {
+  for (let i = 0; i < n; i++) {
+    yRe[yOff + i] = 0;
+    yIm[yOff + i] = 0;
+  }
+  for (let j = 0; j < n; j++) {
+    const xjr = xRe[xOff + j];
+    const xji = xIm[xOff + j];
+    const t1r = alphaRe * xjr - alphaIm * xji;
+    const t1i = alphaRe * xji + alphaIm * xjr;
+    let t2r = 0;
+    let t2i = 0;
+    const col = aOff + j * lda;
+    yRe[yOff + j] += t1r * aRe[col + j];
+    yIm[yOff + j] += t1i * aRe[col + j];
+    for (let i = j + 1; i < n; i++) {
+      const ar = aRe[col + i];
+      const ai = aIm[col + i];
+      yRe[yOff + i] += t1r * ar - t1i * ai;
+      yIm[yOff + i] += t1r * ai + t1i * ar;
+      const xir = xRe[xOff + i];
+      const xii = xIm[xOff + i];
+      t2r += ar * xir + ai * xii;
+      t2i += ar * xii - ai * xir;
+    }
+    yRe[yOff + j] += alphaRe * t2r - alphaIm * t2i;
+    yIm[yOff + j] += alphaRe * t2i + alphaIm * t2r;
+  }
+}
+function zher2LowerMinus(n, xRe, xIm, xOff, yRe, yIm, yOff, aRe, aIm, aOff, lda) {
+  for (let j = 0; j < n; j++) {
+    const xjr = xRe[xOff + j];
+    const xji = xIm[xOff + j];
+    const yjr = yRe[yOff + j];
+    const yji = yIm[yOff + j];
+    const col = aOff + j * lda;
+    if (xjr !== 0 || xji !== 0 || yjr !== 0 || yji !== 0) {
+      const t1r = -yjr;
+      const t1i = yji;
+      const t2r = -xjr;
+      const t2i = xji;
+      aRe[col + j] = aRe[col + j] + (xjr * t1r - xji * t1i) + (yjr * t2r - yji * t2i);
+      aIm[col + j] = 0;
+      for (let i = j + 1; i < n; i++) {
+        const xir = xRe[xOff + i];
+        const xii = xIm[xOff + i];
+        const yir = yRe[yOff + i];
+        const yii = yIm[yOff + i];
+        aRe[col + i] += xir * t1r - xii * t1i + (yir * t2r - yii * t2i);
+        aIm[col + i] += xir * t1i + xii * t1r + (yir * t2i + yii * t2r);
+      }
+    } else {
+      aIm[col + j] = 0;
+    }
+  }
+}
+function zhetd2Lower(n, aRe, aIm, lda, d, e, tauRe, tauIm) {
+  const wRe = allocFloat64Array(Math.max(1, n));
+  const wIm = allocFloat64Array(Math.max(1, n));
+  for (let i = 1; i <= n - 1; i++) {
+    const off = i + (i - 1) * lda;
+    const t = zlarfg2(n - i, aRe, aIm, off, 1);
+    e[i - 1] = aRe[off];
+    const taur = t.tauRe;
+    const taui = t.tauIm;
+    if (taur !== 0 || taui !== 0) {
+      aRe[off] = 1;
+      aIm[off] = 0;
+      const m = n - i;
+      const a11 = i + i * lda;
+      zhemvLower(m, taur, taui, aRe, aIm, a11, lda, aRe, aIm, off, wRe, wIm, 0);
+      let dr = 0;
+      let di = 0;
+      for (let k = 0; k < m; k++) {
+        const vr = aRe[off + k];
+        const vi = aIm[off + k];
+        dr += wRe[k] * vr + wIm[k] * vi;
+        di += wRe[k] * vi - wIm[k] * vr;
+      }
+      const ar = -0.5 * (taur * dr - taui * di);
+      const ai = -0.5 * (taur * di + taui * dr);
+      for (let k = 0; k < m; k++) {
+        const vr = aRe[off + k];
+        const vi = aIm[off + k];
+        wRe[k] += ar * vr - ai * vi;
+        wIm[k] += ar * vi + ai * vr;
+      }
+      zher2LowerMinus(m, aRe, aIm, off, wRe, wIm, 0, aRe, aIm, a11, lda);
+    } else {
+      const a11 = i + i * lda;
+      aIm[a11] = 0;
+    }
+    aRe[off] = e[i - 1];
+    aIm[off] = 0;
+    d[i - 1] = aRe[i - 1 + (i - 1) * lda];
+    tauRe[i - 1] = taur;
+    tauIm[i - 1] = taui;
+  }
+  d[n - 1] = aRe[n - 1 + (n - 1) * lda];
+}
+function zungtrLower(n, aRe, aIm, lda, tauRe, tauIm) {
+  for (let j = n; j >= 2; j--) {
+    aRe[(j - 1) * lda] = 0;
+    aIm[(j - 1) * lda] = 0;
+    for (let i = j + 1; i <= n; i++) {
+      aRe[i - 1 + (j - 1) * lda] = aRe[i - 1 + (j - 2) * lda];
+      aIm[i - 1 + (j - 1) * lda] = aIm[i - 1 + (j - 2) * lda];
+    }
+  }
+  aRe[0] = 1;
+  aIm[0] = 0;
+  for (let i = 2; i <= n; i++) {
+    aRe[i - 1] = 0;
+    aIm[i - 1] = 0;
+  }
+  if (n <= 1) return;
+  const m = n - 1;
+  const base = 1 + lda;
+  const workRe = allocFloat64Array(Math.max(1, m));
+  const workIm = allocFloat64Array(Math.max(1, m));
+  for (let i = m; i >= 1; i--) {
+    const vOff = base + (i - 1) + (i - 1) * lda;
+    const tr = tauRe[i - 1];
+    const ti = tauIm[i - 1];
+    if (i < m) {
+      aRe[vOff] = 1;
+      aIm[vOff] = 0;
+      const rows = m - i + 1;
+      const cols = m - i;
+      const cOff = base + (i - 1) + i * lda;
+      for (let j = 0; j < cols; j++) {
+        let sr = 0;
+        let si = 0;
+        for (let k = 0; k < rows; k++) {
+          const cr = aRe[cOff + k + j * lda];
+          const ci = aIm[cOff + k + j * lda];
+          const vr = aRe[vOff + k];
+          const vi = aIm[vOff + k];
+          sr += cr * vr + ci * vi;
+          si += cr * vi - ci * vr;
+        }
+        workRe[j] = sr;
+        workIm[j] = si;
+      }
+      for (let j = 0; j < cols; j++) {
+        const wr = workRe[j];
+        const wi = -workIm[j];
+        const fr = -(tr * wr - ti * wi);
+        const fi = -(tr * wi + ti * wr);
+        for (let k = 0; k < rows; k++) {
+          const vr = aRe[vOff + k];
+          const vi = aIm[vOff + k];
+          aRe[cOff + k + j * lda] += fr * vr - fi * vi;
+          aIm[cOff + k + j * lda] += fr * vi + fi * vr;
+        }
+      }
+    }
+    if (i < m) {
+      for (let k = 1; k <= m - i; k++) {
+        const vr = aRe[vOff + k];
+        const vi = aIm[vOff + k];
+        aRe[vOff + k] = -(tr * vr - ti * vi);
+        aIm[vOff + k] = -(tr * vi + ti * vr);
+      }
+    }
+    aRe[vOff] = 1 - tr;
+    aIm[vOff] = -ti;
+    for (let k = 1; k <= i - 1; k++) {
+      aRe[base + (k - 1) + (i - 1) * lda] = 0;
+      aIm[base + (k - 1) + (i - 1) * lda] = 0;
+    }
+  }
+}
+function eigHermTs(dataRe, dataIm, n, computeV) {
+  const w = allocFloat64Array(n);
+  if (n === 0)
+    return { w, VRe: allocFloat64Array(0), VIm: allocFloat64Array(0) };
+  if (n === 1) {
+    w[0] = dataRe[0];
+    if (!computeV) return { w };
+    const VRe2 = allocFloat64Array(1);
+    VRe2[0] = 1;
+    return { w, VRe: VRe2, VIm: allocFloat64Array(1) };
+  }
+  const aRe = allocFloat64Array(dataRe);
+  const aIm = allocFloat64Array(dataIm);
+  const e = allocFloat64Array(Math.max(1, n - 1));
+  const tauRe = allocFloat64Array(Math.max(1, n - 1));
+  const tauIm = allocFloat64Array(Math.max(1, n - 1));
+  zhetd2Lower(n, aRe, aIm, n, w, e, tauRe, tauIm);
+  if (!computeV) {
+    const work2 = allocFloat64Array(Math.max(1, 2 * n - 2));
+    const dummy = allocFloat64Array(1);
+    dsteqr(COMPZ_N, n, w, 0, e, 0, dummy, 0, 1, work2, 0);
+    return { w };
+  }
+  zungtrLower(n, aRe, aIm, n, tauRe, tauIm);
+  const S = allocFloat64Array(n * n);
+  const work = allocFloat64Array(Math.max(1, 2 * n - 2));
+  dsteqr(COMPZ_I, n, w, 0, e, 0, S, 0, n, work, 0);
+  const VRe = allocFloat64Array(n * n);
+  const VIm = allocFloat64Array(n * n);
+  for (let j = 0; j < n; j++) {
+    for (let k = 0; k < n; k++) {
+      const s = S[k + j * n];
+      if (s === 0) continue;
+      for (let i = 0; i < n; i++) {
+        VRe[i + j * n] += aRe[i + k * n] * s;
+        VIm[i + j * n] += aIm[i + k * n] * s;
+      }
+    }
+  }
+  return { w, VRe, VIm };
+}
+
+// src/ts-lapack/src/SRC/dlansy.ts
+var NORM_MAX7 = 0;
+var NORM_ONE3 = 1;
+var NORM_INF3 = 2;
+var NORM_FRO3 = 3;
+function dlansy(norm2, uplo, n, a, aOff, lda, work, workOff) {
+  let value = 0;
+  if (n === 0) {
+    value = 0;
+  } else if (norm2 === NORM_MAX7) {
+    value = 0;
+    if (uplo === UPPER) {
+      for (let j = 1; j <= n; j++) {
+        for (let i = 1; i <= j; i++) {
+          const sum2 = Math.abs(a[aOff + (i - 1) + (j - 1) * lda]);
+          if (value < sum2 || Number.isNaN(sum2)) value = sum2;
+        }
+      }
+    } else {
+      for (let j = 1; j <= n; j++) {
+        for (let i = j; i <= n; i++) {
+          const sum2 = Math.abs(a[aOff + (i - 1) + (j - 1) * lda]);
+          if (value < sum2 || Number.isNaN(sum2)) value = sum2;
+        }
+      }
+    }
+  } else if (norm2 === NORM_ONE3 || norm2 === NORM_INF3) {
+    value = 0;
+    if (uplo === UPPER) {
+      for (let j = 1; j <= n; j++) {
+        let sum2 = 0;
+        for (let i = 1; i <= j - 1; i++) {
+          const absa = Math.abs(a[aOff + (i - 1) + (j - 1) * lda]);
+          sum2 += absa;
+          work[workOff + (i - 1)] += absa;
+        }
+        work[workOff + (j - 1)] = sum2 + Math.abs(a[aOff + (j - 1) + (j - 1) * lda]);
+      }
+      for (let i = 1; i <= n; i++) {
+        const sum2 = work[workOff + (i - 1)];
+        if (value < sum2 || Number.isNaN(sum2)) value = sum2;
+      }
+    } else {
+      for (let i = 1; i <= n; i++) work[workOff + (i - 1)] = 0;
+      for (let j = 1; j <= n; j++) {
+        let sum2 = work[workOff + (j - 1)] + Math.abs(a[aOff + (j - 1) + (j - 1) * lda]);
+        for (let i = j + 1; i <= n; i++) {
+          const absa = Math.abs(a[aOff + (i - 1) + (j - 1) * lda]);
+          sum2 += absa;
+          work[workOff + (i - 1)] += absa;
+        }
+        if (value < sum2 || Number.isNaN(sum2)) value = sum2;
+      }
+    }
+  } else if (norm2 === NORM_FRO3) {
+    const scale = { val: 0 };
+    const sum2 = { val: 1 };
+    if (uplo === UPPER) {
+      for (let j = 2; j <= n; j++) {
+        dlassq(j - 1, a, aOff + (j - 1) * lda, 1, scale, sum2);
+      }
+    } else {
+      for (let j = 1; j <= n - 1; j++) {
+        dlassq(n - j, a, aOff + j + (j - 1) * lda, 1, scale, sum2);
+      }
+    }
+    sum2.val = 2 * sum2.val;
+    dlassq(n, a, aOff, lda + 1, scale, sum2);
+    value = scale.val * Math.sqrt(sum2.val);
+  }
+  return value;
+}
+
+// src/ts-lapack/src/BLAS/dsymv.ts
+function dsymv(uplo, n, alpha, a, aOff, lda, x, xOff, incx, beta, y, yOff, incy) {
+  const ZERO9 = 0;
+  const ONE10 = 1;
+  let info = 0;
+  if (uplo !== UPPER && uplo !== LOWER) {
+    info = 1;
+  } else if (n < 0) {
+    info = 2;
+  } else if (lda < Math.max(1, n)) {
+    info = 5;
+  } else if (incx === 0) {
+    info = 7;
+  } else if (incy === 0) {
+    info = 10;
+  }
+  if (info !== 0) {
+    xerbla("DSYMV ", info);
+    return;
+  }
+  if (n === 0 || alpha === ZERO9 && beta === ONE10) return;
+  const kx = incx > 0 ? 0 : -(n - 1) * incx;
+  const ky = incy > 0 ? 0 : -(n - 1) * incy;
+  if (beta !== ONE10) {
+    let iy = ky;
+    if (beta === ZERO9) {
+      for (let i = 0; i < n; i++) {
+        y[yOff + iy] = ZERO9;
+        iy += incy;
+      }
+    } else {
+      for (let i = 0; i < n; i++) {
+        y[yOff + iy] *= beta;
+        iy += incy;
+      }
+    }
+  }
+  if (alpha === ZERO9) return;
+  if (uplo === UPPER) {
+    let jx = kx;
+    let jy = ky;
+    for (let j = 1; j <= n; j++) {
+      const temp1 = alpha * x[xOff + jx];
+      let temp2 = ZERO9;
+      const aCol = aOff + (j - 1) * lda;
+      let ix = kx;
+      let iy = ky;
+      for (let i = 1; i <= j - 1; i++) {
+        const aij = a[aCol + (i - 1)];
+        y[yOff + iy] += temp1 * aij;
+        temp2 += aij * x[xOff + ix];
+        ix += incx;
+        iy += incy;
+      }
+      y[yOff + jy] += temp1 * a[aCol + (j - 1)] + alpha * temp2;
+      jx += incx;
+      jy += incy;
+    }
+  } else {
+    let jx = kx;
+    let jy = ky;
+    for (let j = 1; j <= n; j++) {
+      const temp1 = alpha * x[xOff + jx];
+      let temp2 = ZERO9;
+      const aCol = aOff + (j - 1) * lda;
+      y[yOff + jy] += temp1 * a[aCol + (j - 1)];
+      let ix = jx;
+      let iy = jy;
+      for (let i = j + 1; i <= n; i++) {
+        ix += incx;
+        iy += incy;
+        const aij = a[aCol + (i - 1)];
+        y[yOff + iy] += temp1 * aij;
+        temp2 += aij * x[xOff + ix];
+      }
+      y[yOff + jy] += alpha * temp2;
+      jx += incx;
+      jy += incy;
+    }
+  }
+}
+
+// src/ts-lapack/src/BLAS/dsyr2.ts
+function dsyr2(uplo, n, alpha, x, xOff, incx, y, yOff, incy, a, aOff, lda) {
+  const ZERO9 = 0;
+  let info = 0;
+  if (uplo !== UPPER && uplo !== LOWER) {
+    info = 1;
+  } else if (n < 0) {
+    info = 2;
+  } else if (incx === 0) {
+    info = 5;
+  } else if (incy === 0) {
+    info = 7;
+  } else if (lda < Math.max(1, n)) {
+    info = 9;
+  }
+  if (info !== 0) {
+    xerbla("DSYR2 ", info);
+    return;
+  }
+  if (n === 0 || alpha === ZERO9) return;
+  const kx = incx > 0 ? 0 : -(n - 1) * incx;
+  const ky = incy > 0 ? 0 : -(n - 1) * incy;
+  let jx = kx;
+  let jy = ky;
+  if (uplo === UPPER) {
+    for (let j = 1; j <= n; j++) {
+      const xj = x[xOff + jx];
+      const yj = y[yOff + jy];
+      if (xj !== ZERO9 || yj !== ZERO9) {
+        const temp1 = alpha * yj;
+        const temp2 = alpha * xj;
+        const aCol = aOff + (j - 1) * lda;
+        let ix = kx;
+        let iy = ky;
+        for (let i = 1; i <= j; i++) {
+          a[aCol + (i - 1)] += x[xOff + ix] * temp1 + y[yOff + iy] * temp2;
+          ix += incx;
+          iy += incy;
+        }
+      }
+      jx += incx;
+      jy += incy;
+    }
+  } else {
+    for (let j = 1; j <= n; j++) {
+      const xj = x[xOff + jx];
+      const yj = y[yOff + jy];
+      if (xj !== ZERO9 || yj !== ZERO9) {
+        const temp1 = alpha * yj;
+        const temp2 = alpha * xj;
+        const aCol = aOff + (j - 1) * lda;
+        let ix = jx;
+        let iy = jy;
+        for (let i = j; i <= n; i++) {
+          a[aCol + (i - 1)] += x[xOff + ix] * temp1 + y[yOff + iy] * temp2;
+          ix += incx;
+          iy += incy;
+        }
+      }
+      jx += incx;
+      jy += incy;
+    }
+  }
+}
+
+// src/ts-lapack/src/SRC/dsytd2.ts
+function dsytd2(uplo, n, a, aOff, lda, d, dOff, e, eOff, tau, tauOff) {
+  const ONE10 = 1;
+  const ZERO9 = 0;
+  const HALF = 0.5;
+  let info = 0;
+  const upper = uplo === UPPER;
+  if (!upper && uplo !== LOWER) {
+    info = -1;
+  } else if (n < 0) {
+    info = -2;
+  } else if (lda < Math.max(1, n)) {
+    info = -4;
+  }
+  if (info !== 0) {
+    xerbla("DSYTD2", -info);
+    return info;
+  }
+  if (n <= 0) return 0;
+  const A = (i, j) => aOff + (i - 1) + (j - 1) * lda;
+  if (upper) {
+    for (let i = n - 1; i >= 1; i--) {
+      const r = dlarfg(i, a[A(i, i + 1)], a, A(1, i + 1), 1);
+      a[A(i, i + 1)] = r.alpha;
+      const taui = r.tau;
+      e[eOff + (i - 1)] = a[A(i, i + 1)];
+      if (taui !== ZERO9) {
+        a[A(i, i + 1)] = ONE10;
+        dsymv(
+          uplo,
+          i,
+          taui,
+          a,
+          aOff,
+          lda,
+          a,
+          A(1, i + 1),
+          1,
+          ZERO9,
+          tau,
+          tauOff,
+          1
+        );
+        const alpha = -HALF * taui * ddot(i, tau, tauOff, 1, a, A(1, i + 1), 1);
+        daxpy(i, alpha, a, A(1, i + 1), 1, tau, tauOff, 1);
+        dsyr2(uplo, i, -ONE10, a, A(1, i + 1), 1, tau, tauOff, 1, a, aOff, lda);
+        a[A(i, i + 1)] = e[eOff + (i - 1)];
+      }
+      d[dOff + i] = a[A(i + 1, i + 1)];
+      tau[tauOff + (i - 1)] = taui;
+    }
+    d[dOff] = a[A(1, 1)];
+  } else {
+    for (let i = 1; i <= n - 1; i++) {
+      const r = dlarfg(n - i, a[A(i + 1, i)], a, A(Math.min(i + 2, n), i), 1);
+      a[A(i + 1, i)] = r.alpha;
+      const taui = r.tau;
+      e[eOff + (i - 1)] = a[A(i + 1, i)];
+      if (taui !== ZERO9) {
+        a[A(i + 1, i)] = ONE10;
+        dsymv(
+          uplo,
+          n - i,
+          taui,
+          a,
+          A(i + 1, i + 1),
+          lda,
+          a,
+          A(i + 1, i),
+          1,
+          ZERO9,
+          tau,
+          tauOff + (i - 1),
+          1
+        );
+        const alpha = -HALF * taui * ddot(n - i, tau, tauOff + (i - 1), 1, a, A(i + 1, i), 1);
+        daxpy(n - i, alpha, a, A(i + 1, i), 1, tau, tauOff + (i - 1), 1);
+        dsyr2(
+          uplo,
+          n - i,
+          -ONE10,
+          a,
+          A(i + 1, i),
+          1,
+          tau,
+          tauOff + (i - 1),
+          1,
+          a,
+          A(i + 1, i + 1),
+          lda
+        );
+        a[A(i + 1, i)] = e[eOff + (i - 1)];
+      }
+      d[dOff + (i - 1)] = a[A(i, i)];
+      tau[tauOff + (i - 1)] = taui;
+    }
+    d[dOff + (n - 1)] = a[A(n, n)];
+  }
+  return 0;
+}
+
+// src/ts-lapack/src/SRC/dorgtr.ts
+function dorgtr(uplo, n, a, aOff, lda, tau, tauOff) {
+  const ONE10 = 1;
+  const ZERO9 = 0;
+  let info = 0;
+  if (uplo !== LOWER) {
+    info = -1;
+  } else if (n < 0) {
+    info = -2;
+  } else if (lda < Math.max(1, n)) {
+    info = -4;
+  }
+  if (info !== 0) {
+    xerbla("DORGTR", -info);
+    return info;
+  }
+  if (n === 0) return 0;
+  const A = (i, j) => aOff + (i - 1) + (j - 1) * lda;
+  for (let j = n; j >= 2; j--) {
+    a[A(1, j)] = ZERO9;
+    for (let i = j + 1; i <= n; i++) {
+      a[A(i, j)] = a[A(i, j - 1)];
+    }
+  }
+  a[A(1, 1)] = ONE10;
+  for (let i = 2; i <= n; i++) {
+    a[A(i, 1)] = ZERO9;
+  }
+  if (n > 1) {
+    info = dorgqr(n - 1, n - 1, n - 1, a, A(2, 2), lda, tau, tauOff);
+  }
+  return info;
+}
+
+// src/ts-lapack/src/SRC/dsyev.ts
+var NORM_MAX8 = 0;
+var TYPE_L2 = 1;
+function dsyev(wantz, uplo, n, a, aOff, lda, w, wOff) {
+  const ONE10 = 1;
+  const ZERO9 = 0;
+  let info = 0;
+  if (uplo !== LOWER) {
+    info = -2;
+  } else if (n < 0) {
+    info = -3;
+  } else if (lda < Math.max(1, n)) {
+    info = -5;
+  }
+  if (info !== 0) {
+    xerbla("DSYEV ", -info);
+    return info;
+  }
+  if (n === 0) return 0;
+  if (n === 1) {
+    w[wOff] = a[aOff];
+    if (wantz) a[aOff] = ONE10;
+    return 0;
+  }
+  const safmin = dlamch(MACH_SFMIN);
+  const eps2 = dlamch(MACH_PREC);
+  const smlnum = safmin / eps2;
+  const bignum = ONE10 / smlnum;
+  const rmin = Math.sqrt(smlnum);
+  const rmax = Math.sqrt(bignum);
+  const work = allocFloat64Array(Math.max(1, 3 * n));
+  const anrm = dlansy(NORM_MAX8, uplo, n, a, aOff, lda, work, 0);
+  let iscale = 0;
+  let sigma = ONE10;
+  if (anrm > ZERO9 && anrm < rmin) {
+    iscale = 1;
+    sigma = rmin / anrm;
+  } else if (anrm > rmax) {
+    iscale = 1;
+    sigma = rmax / anrm;
+  }
+  if (iscale === 1) dlascl(TYPE_L2, 0, 0, ONE10, sigma, n, n, a, aOff, lda);
+  const e = allocFloat64Array(Math.max(1, n - 1));
+  const tau = allocFloat64Array(Math.max(1, n - 1));
+  dsytd2(uplo, n, a, aOff, lda, w, wOff, e, 0, tau, 0);
+  if (!wantz) {
+    info = dsteqr(COMPZ_N, n, w, wOff, e, 0, a, aOff, lda, work, 0);
+  } else {
+    const iinfo = dorgtr(uplo, n, a, aOff, lda, tau, 0);
+    if (iinfo !== 0) return iinfo;
+    info = dsteqr(COMPZ_V, n, w, wOff, e, 0, a, aOff, lda, work, 0);
+  }
+  if (iscale === 1) {
+    const imax = info === 0 ? n : info - 1;
+    dscal(imax, ONE10 / sigma, w, wOff, 1);
+  }
+  return info;
+}
+
 // src/numbl-core/native/ts-lapack-bridge.ts
 function inv(data, n) {
   const a = allocFloat64Array(data);
@@ -18263,6 +19620,20 @@ function linsolve(A, m, n, B, nrhs) {
     return x;
   }
 }
+function eigSym(data, n, computeV) {
+  const a = allocFloat64Array(data);
+  const w = allocFloat64Array(n);
+  const info = dsyev(computeV, LOWER, n, a, 0, n, w, 0);
+  if (info !== 0) {
+    throw new Error(
+      info < 0 ? "eig: illegal argument passed to dsyev" : "QR algorithm failed to converge in dsyev"
+    );
+  }
+  return computeV ? { w, V: a } : { w };
+}
+function eigHerm(dataRe, dataIm, n, computeV) {
+  return eigHermTs(dataRe, dataIm, n, computeV);
+}
 function eig(data, n, computeVL, computeVR, balance) {
   const a = allocFloat64Array(data);
   const wr = allocFloat64Array(n);
@@ -19001,7 +20372,9 @@ var _bridge2 = {
   linsolve,
   linsolveComplex,
   eig,
+  eigSym,
   eigComplex: eigComplexTs,
+  eigHerm,
   lu,
   svd,
   chol,
@@ -21461,6 +22834,21 @@ function mMulSparse(a, b) {
     const m = a.m;
     const hasImag = isComplexSparse(a) || b.imag !== void 0;
     const result = allocFloat64Array(m * bCols);
+    if (!hasImag) {
+      const ir = a.ir, jc = a.jc, pr = a.pr, bd = b.data;
+      for (let col = 0; col < bCols; col++) {
+        const boff = col * bRows;
+        const roff = col * m;
+        for (let k = 0; k < a.n; k++) {
+          const bk = bd[boff + k];
+          if (bk === 0) continue;
+          const end = jc[k + 1];
+          for (let ka = jc[k]; ka < end; ka++)
+            result[roff + ir[ka]] += pr[ka] * bk;
+        }
+      }
+      return RTV.tensor(result, [m, bCols]);
+    }
     const resultImag = hasImag ? allocFloat64Array(m * bCols) : void 0;
     for (let col = 0; col < bCols; col++) {
       for (let k = 0; k < a.n; k++) {
@@ -22580,6 +23968,707 @@ function sprintfFormat(fmt, args) {
   return result;
 }
 
+// src/numbl-core/helpers/warn.ts
+var sink = (msg) => console.warn("Warning: " + msg);
+function setWarningSink(fn) {
+  sink = fn;
+}
+function emitWarning(msg) {
+  sink(msg);
+}
+
+// src/numbl-core/helpers/sparse-direct.ts
+var SINGULAR_WARNING = "Matrix is singular to working precision.";
+function denseToSparse(t) {
+  const m = t.shape[0] ?? 1;
+  const n = t.shape.length >= 2 ? t.shape[1] : 1;
+  const irList = [];
+  const prList = [];
+  const piList = t.imag ? [] : void 0;
+  const jc = new Int32Array(n + 1);
+  for (let c = 0; c < n; c++) {
+    jc[c] = irList.length;
+    for (let r = 0; r < m; r++) {
+      const idx = c * m + r;
+      const re = t.data[idx];
+      const im = t.imag ? t.imag[idx] : 0;
+      if (re !== 0 || im !== 0) {
+        irList.push(r);
+        prList.push(re);
+        if (piList) piList.push(im);
+      }
+    }
+  }
+  jc[n] = irList.length;
+  return RTV.sparseMatrix(
+    m,
+    n,
+    new Int32Array(irList),
+    jc,
+    allocFloat64Array(prList),
+    piList ? allocFloat64Array(piList) : void 0
+  );
+}
+function denseDataToSparse(data, m, n) {
+  return denseToSparse(RTV.tensor(data, [m, n]));
+}
+function fromUnsortedColumns(m, n, ir, jc, pr) {
+  return sparseTranspose(sparseTranspose(RTV.sparseMatrix(m, n, ir, jc, pr)));
+}
+function permutationMatrix(p2) {
+  const n = p2.length;
+  const ir = new Int32Array(n);
+  const jc = new Int32Array(n + 1);
+  const pr = allocFloat64Array(n);
+  for (let k = 0; k < n; k++) jc[p2[k] + 1]++;
+  for (let c = 0; c < n; c++) jc[c + 1] += jc[c];
+  for (let k = 0; k < n; k++) {
+    ir[jc[p2[k]]] = k;
+    pr[jc[p2[k]]] = 1;
+  }
+  return RTV.sparseMatrix(n, n, ir, jc, pr);
+}
+function permVectorTensor(p2) {
+  const d = allocFloat64Array(p2.length);
+  for (let i = 0; i < p2.length; i++) d[i] = p2[i] + 1;
+  return RTV.tensor(d, [1, p2.length]);
+}
+function invertPerm(p2) {
+  const inv2 = new Int32Array(p2.length);
+  for (let i = 0; i < p2.length; i++) inv2[p2[i]] = i;
+  return inv2;
+}
+function sparsePermute(A, p2, q) {
+  const pinv = invertPerm(p2);
+  const nnz = A.jc[A.n];
+  const ir = new Int32Array(nnz);
+  const jc = new Int32Array(A.n + 1);
+  const pr = allocFloat64Array(nnz);
+  let pos = 0;
+  for (let k = 0; k < A.n; k++) {
+    jc[k] = pos;
+    const j = q[k];
+    for (let t = A.jc[j]; t < A.jc[j + 1]; t++) {
+      ir[pos] = pinv[A.ir[t]];
+      pr[pos] = A.pr[t];
+      pos++;
+    }
+  }
+  jc[A.n] = pos;
+  return fromUnsortedColumns(A.m, A.n, ir, jc, pr);
+}
+function sparseKron(A, B) {
+  const m = A.m, n = A.n, p2 = B.m, q = B.n;
+  const nnz = A.jc[n] * B.jc[q];
+  const ir = new Int32Array(nnz);
+  const jc = new Int32Array(n * q + 1);
+  const pr = allocFloat64Array(nnz);
+  const cplx = A.pi !== void 0 || B.pi !== void 0;
+  const pi2 = cplx ? allocFloat64Array(nnz) : void 0;
+  let pos = 0;
+  for (let ja = 0; ja < n; ja++) {
+    for (let jb = 0; jb < q; jb++) {
+      jc[ja * q + jb] = pos;
+      for (let ka = A.jc[ja]; ka < A.jc[ja + 1]; ka++) {
+        const rowBase = A.ir[ka] * p2;
+        const aRe = A.pr[ka];
+        const aIm = A.pi ? A.pi[ka] : 0;
+        for (let kb = B.jc[jb]; kb < B.jc[jb + 1]; kb++) {
+          ir[pos] = rowBase + B.ir[kb];
+          const bRe = B.pr[kb];
+          const bIm = B.pi ? B.pi[kb] : 0;
+          pr[pos] = aRe * bRe - aIm * bIm;
+          if (pi2) pi2[pos] = aRe * bIm + aIm * bRe;
+          pos++;
+        }
+      }
+    }
+  }
+  jc[n * q] = pos;
+  return RTV.sparseMatrix(m * p2, n * q, ir, jc, pr, pi2);
+}
+function triangularInfo(S) {
+  if (S._triInfo) return S._triInfo;
+  const n = S.n;
+  const ir = S.ir, jc = S.jc, pr = S.pr, pi2 = S.pi;
+  const diagPos = new Int32Array(n).fill(-1);
+  const diag2 = allocFloat64Array(n);
+  let upper = true;
+  let lower = true;
+  for (let j = 0; j < n; j++) {
+    const end = jc[j + 1];
+    for (let k = jc[j]; k < end; k++) {
+      const i = ir[k];
+      if (i === j) {
+        diagPos[j] = k;
+        diag2[j] = pr[k];
+        continue;
+      }
+      if (pr[k] === 0 && (!pi2 || pi2[k] === 0)) continue;
+      if (i > j) upper = false;
+      else lower = false;
+    }
+  }
+  const info = { upper, lower, diagPos, diag: diag2 };
+  S._triInfo = info;
+  return info;
+}
+function sparseIsUpper(S) {
+  return triangularInfo(S).upper;
+}
+function sparseIsLower(S) {
+  return triangularInfo(S).lower;
+}
+function sparseIsSymmetric(S) {
+  if (S.m !== S.n || S.pi) return false;
+  const T = sparseTranspose(S);
+  const nnz = S.jc[S.n];
+  if (T.jc[T.n] !== nnz) return false;
+  for (let j = 0; j <= S.n; j++) if (S.jc[j] !== T.jc[j]) return false;
+  for (let k = 0; k < nnz; k++)
+    if (S.ir[k] !== T.ir[k] || S.pr[k] !== T.pr[k]) return false;
+  return true;
+}
+function sparseAt(S, i, j) {
+  let lo = S.jc[j], hi = S.jc[j + 1] - 1;
+  while (lo <= hi) {
+    const mid = lo + hi >> 1;
+    const r = S.ir[mid];
+    if (r === i) return S.pr[mid];
+    if (r < i) lo = mid + 1;
+    else hi = mid - 1;
+  }
+  return 0;
+}
+function allDiagPositive(S) {
+  for (let j = 0; j < S.n; j++) if (!(sparseAt(S, j, j) > 0)) return false;
+  return true;
+}
+function sparseSolveUpper(R, B, nrhs) {
+  const n = R.n;
+  const { diagPos, diag: diag2 } = triangularInfo(R);
+  const ir = R.ir, jc = R.jc, pr = R.pr;
+  const x = allocFloat64Array(B);
+  let singular = false;
+  for (let j = 0; j < n; j++) if (diag2[j] === 0) singular = true;
+  for (let c = 0; c < nrhs; c++) {
+    const off = c * n;
+    for (let j = n - 1; j >= 0; j--) {
+      const xj = x[off + j] / diag2[j];
+      x[off + j] = xj;
+      if (xj === 0) continue;
+      const dp = diagPos[j];
+      const end = dp >= 0 ? dp : jc[j + 1];
+      for (let k = jc[j]; k < end; k++) x[off + ir[k]] -= pr[k] * xj;
+    }
+  }
+  return { x, singular };
+}
+function sparseSolveLower(L, B, nrhs) {
+  const n = L.n;
+  const { diagPos, diag: diag2 } = triangularInfo(L);
+  const ir = L.ir, jc = L.jc, pr = L.pr;
+  const x = allocFloat64Array(B);
+  let singular = false;
+  for (let j = 0; j < n; j++) if (diag2[j] === 0) singular = true;
+  for (let c = 0; c < nrhs; c++) {
+    const off = c * n;
+    for (let j = 0; j < n; j++) {
+      const xj = x[off + j] / diag2[j];
+      x[off + j] = xj;
+      if (xj === 0) continue;
+      const dp = diagPos[j];
+      const end = jc[j + 1];
+      for (let k = dp >= 0 ? dp + 1 : jc[j]; k < end; k++)
+        x[off + ir[k]] -= pr[k] * xj;
+    }
+  }
+  return { x, singular };
+}
+function permuteRows(X, n, nrhs, p2) {
+  const Y = allocFloat64Array(X.length);
+  for (let c = 0; c < nrhs; c++) {
+    const off = c * n;
+    for (let k = 0; k < n; k++) Y[off + k] = X[off + p2[k]];
+  }
+  return Y;
+}
+function unpermuteRows(X, n, nrhs, p2) {
+  const Y = allocFloat64Array(X.length);
+  for (let c = 0; c < nrhs; c++) {
+    const off = c * n;
+    for (let k = 0; k < n; k++) Y[off + p2[k]] = X[off + k];
+  }
+  return Y;
+}
+function eliminationTree(A) {
+  const n = A.n;
+  const parent = new Int32Array(n).fill(-1);
+  const ancestor = new Int32Array(n).fill(-1);
+  for (let k = 0; k < n; k++) {
+    for (let p2 = A.jc[k]; p2 < A.jc[k + 1]; p2++) {
+      let i = A.ir[p2];
+      while (i !== -1 && i < k) {
+        const inext = ancestor[i];
+        ancestor[i] = k;
+        if (inext === -1) parent[i] = k;
+        i = inext;
+      }
+    }
+  }
+  return parent;
+}
+function etreeReach(A, k, parent, s, mark) {
+  const n = A.n;
+  let top = n;
+  mark[k] = k;
+  for (let p2 = A.jc[k]; p2 < A.jc[k + 1]; p2++) {
+    let i = A.ir[p2];
+    if (i > k) continue;
+    let len = 0;
+    for (; mark[i] !== k; i = parent[i]) {
+      s[len++] = i;
+      mark[i] = k;
+    }
+    while (len > 0) s[--top] = s[--len];
+  }
+  return top;
+}
+function sparseChol(A) {
+  const n = A.n;
+  if (A.m !== n) throw new RuntimeError("chol: Matrix must be square.");
+  const parent = eliminationTree(A);
+  const s = new Int32Array(n);
+  const mark = new Int32Array(n).fill(-1);
+  const colCount = new Int32Array(n);
+  for (let k = 0; k < n; k++) {
+    const top = etreeReach(A, k, parent, s, mark);
+    for (let t = top; t < n; t++) colCount[s[t]]++;
+    colCount[k]++;
+  }
+  const Lp = new Int32Array(n + 1);
+  for (let j = 0; j < n; j++) Lp[j + 1] = Lp[j] + colCount[j];
+  const nnzL = Lp[n];
+  const Li = new Int32Array(nnzL);
+  const Lx = allocFloat64Array(nnzL);
+  const c = new Int32Array(n);
+  for (let j = 0; j < n; j++) c[j] = Lp[j];
+  const x = allocFloat64Array(n);
+  mark.fill(-1);
+  for (let k = 0; k < n; k++) {
+    const top = etreeReach(A, k, parent, s, mark);
+    x[k] = 0;
+    for (let p2 = A.jc[k]; p2 < A.jc[k + 1]; p2++) {
+      if (A.ir[p2] <= k) x[A.ir[p2]] = A.pr[p2];
+    }
+    let d = x[k];
+    x[k] = 0;
+    for (let t = top; t < n; t++) {
+      const i = s[t];
+      const lki = x[i] / Lx[Lp[i]];
+      x[i] = 0;
+      for (let p2 = Lp[i] + 1; p2 < c[i]; p2++) x[Li[p2]] -= Lx[p2] * lki;
+      d -= lki * lki;
+      const pos2 = c[i]++;
+      Li[pos2] = k;
+      Lx[pos2] = lki;
+    }
+    if (!(d > 0)) {
+      for (let i = k + 1; i < n; i++) {
+        const top2 = etreeReach(A, i, parent, s, mark);
+        for (let p2 = A.jc[i]; p2 < A.jc[i + 1]; p2++)
+          if (A.ir[p2] < k) x[A.ir[p2]] = A.pr[p2];
+        for (let t = top2; t < n; t++) {
+          const j = s[t];
+          if (j >= k) {
+            x[j] = 0;
+            continue;
+          }
+          const lij = x[j] / Lx[Lp[j]];
+          x[j] = 0;
+          for (let p2 = Lp[j] + 1; p2 < c[j]; p2++) x[Li[p2]] -= Lx[p2] * lij;
+          const pos2 = c[j]++;
+          Li[pos2] = i;
+          Lx[pos2] = lij;
+        }
+      }
+      return { L: leadingColumns(n, k, Lp, Li, Lx, c), ok: false, p: k + 1 };
+    }
+    const pos = c[k]++;
+    Li[pos] = k;
+    Lx[pos] = Math.sqrt(d);
+  }
+  return { L: RTV.sparseMatrix(n, n, Li, Lp, Lx), ok: true, p: 0 };
+}
+function leadingColumns(n, k, Lp, Li, Lx, c) {
+  let nnz = 0;
+  for (let j = 0; j < k; j++) nnz += c[j] - Lp[j];
+  const ir = new Int32Array(nnz);
+  const pr = allocFloat64Array(nnz);
+  const jc = new Int32Array(k + 1);
+  let pos = 0;
+  for (let j = 0; j < k; j++) {
+    jc[j] = pos;
+    for (let p2 = Lp[j]; p2 < c[j]; p2++) {
+      ir[pos] = Li[p2];
+      pr[pos] = Lx[p2];
+      pos++;
+    }
+  }
+  jc[k] = pos;
+  return RTV.sparseMatrix(n, k, ir, jc, pr);
+}
+function sparseLu(A, q, tol) {
+  const m = A.m, n = A.n;
+  const kmin = Math.min(m, n);
+  const Lp = [0];
+  const Li = [];
+  const Lx = [];
+  const Up = [0];
+  const Ui = [];
+  const Ux = [];
+  const pinv = new Int32Array(m).fill(-1);
+  const x = allocFloat64Array(m);
+  const xi = new Int32Array(m);
+  const stack = new Int32Array(m);
+  const pstack = new Int32Array(m);
+  const mark = new Int32Array(m).fill(-1);
+  let singular = false;
+  for (let k = 0; k < n; k++) {
+    const col = q ? q[k] : k;
+    let top = m;
+    for (let t = A.jc[col]; t < A.jc[col + 1]; t++) {
+      const i0 = A.ir[t];
+      if (mark[i0] === k) continue;
+      let head = 0;
+      stack[0] = i0;
+      mark[i0] = k;
+      pstack[i0] = pinv[i0] >= 0 ? Lp[pinv[i0]] : -1;
+      while (head >= 0) {
+        const j = stack[head];
+        const J = pinv[j];
+        let descended = false;
+        if (J >= 0) {
+          const end = Lp[J + 1];
+          let p3 = pstack[j];
+          for (; p3 < end; p3++) {
+            const i = Li[p3];
+            if (mark[i] !== k) {
+              mark[i] = k;
+              pstack[j] = p3 + 1;
+              stack[++head] = i;
+              pstack[i] = pinv[i] >= 0 ? Lp[pinv[i]] : -1;
+              descended = true;
+              break;
+            }
+          }
+          if (descended) continue;
+        }
+        head--;
+        xi[--top] = j;
+      }
+    }
+    for (let t = A.jc[col]; t < A.jc[col + 1]; t++) x[A.ir[t]] = A.pr[t];
+    for (let t = top; t < m; t++) {
+      const j = xi[t];
+      const J = pinv[j];
+      if (J < 0) continue;
+      const xj = x[j];
+      if (xj === 0) continue;
+      for (let p3 = Lp[J] + 1; p3 < Lp[J + 1]; p3++) x[Li[p3]] -= Lx[p3] * xj;
+    }
+    let ipiv = -1;
+    let amax = -1;
+    for (let t = top; t < m; t++) {
+      const i = xi[t];
+      if (pinv[i] >= 0) {
+        Ui.push(pinv[i]);
+        Ux.push(x[i]);
+      } else {
+        const a = Math.abs(x[i]);
+        if (a > amax) {
+          amax = a;
+          ipiv = i;
+        }
+      }
+    }
+    if (k < kmin) {
+      if (ipiv < 0 || amax === 0) {
+        singular = true;
+        if (ipiv < 0) {
+          for (let i = 0; i < m; i++)
+            if (pinv[i] < 0) {
+              ipiv = i;
+              break;
+            }
+        }
+      } else if (col < m && pinv[col] < 0 && Math.abs(x[col]) >= tol * amax && x[col] !== 0) {
+        ipiv = col;
+      }
+      const pivot = x[ipiv];
+      if (!Number.isFinite(pivot)) singular = true;
+      pinv[ipiv] = k;
+      Ui.push(k);
+      Ux.push(pivot);
+      Li.push(ipiv);
+      Lx.push(1);
+      if (pivot !== 0 && Number.isFinite(pivot)) {
+        for (let t = top; t < m; t++) {
+          const i = xi[t];
+          if (pinv[i] >= 0) continue;
+          const v = x[i] / pivot;
+          if (v !== 0) {
+            Li.push(i);
+            Lx.push(v);
+          }
+        }
+      }
+      Lp.push(Li.length);
+    }
+    Up.push(Ui.length);
+    for (let t = top; t < m; t++) x[xi[t]] = 0;
+  }
+  let next = kmin;
+  for (let i = 0; i < m; i++) if (pinv[i] < 0) pinv[i] = next++;
+  const LiArr = new Int32Array(Li.length);
+  for (let p3 = 0; p3 < Li.length; p3++) LiArr[p3] = pinv[Li[p3]];
+  const L = fromUnsortedColumns(
+    m,
+    kmin,
+    LiArr,
+    new Int32Array(Lp),
+    allocFloat64Array(Lx)
+  );
+  const U = fromUnsortedColumns(
+    kmin,
+    n,
+    new Int32Array(Ui),
+    new Int32Array(Up),
+    allocFloat64Array(Ux)
+  );
+  const p2 = invertPerm(pinv);
+  const qOut = q ? Int32Array.from(q) : identityPerm(n);
+  return { L, U, p: p2, q: qOut, singular };
+}
+function identityPerm(n) {
+  const p2 = new Int32Array(n);
+  for (let i = 0; i < n; i++) p2[i] = i;
+  return p2;
+}
+function symmetricAdjacency(A) {
+  const n = Math.max(A.m, A.n);
+  const adj = new Array(n);
+  for (let i = 0; i < n; i++) adj[i] = /* @__PURE__ */ new Set();
+  for (let j = 0; j < A.n; j++)
+    for (let k = A.jc[j]; k < A.jc[j + 1]; k++) {
+      const i = A.ir[k];
+      if (i === j) continue;
+      adj[i].add(j);
+      adj[j].add(i);
+    }
+  return adj;
+}
+function minimumDegreeOrdering(A) {
+  const adj = symmetricAdjacency(A);
+  const n = adj.length;
+  const perm = new Int32Array(n);
+  if (n === 0) return perm;
+  const head = new Int32Array(n + 1).fill(-1);
+  const next = new Int32Array(n).fill(-1);
+  const prev = new Int32Array(n).fill(-1);
+  const deg = new Int32Array(n);
+  const insert = (v) => {
+    const d = deg[v];
+    next[v] = head[d];
+    prev[v] = -1;
+    if (head[d] >= 0) prev[head[d]] = v;
+    head[d] = v;
+  };
+  const remove = (v) => {
+    const d = deg[v];
+    if (prev[v] >= 0) next[prev[v]] = next[v];
+    else head[d] = next[v];
+    if (next[v] >= 0) prev[next[v]] = prev[v];
+  };
+  for (let v = 0; v < n; v++) {
+    deg[v] = adj[v].size;
+    insert(v);
+  }
+  let mind = 0;
+  for (let step = 0; step < n; step++) {
+    while (head[mind] < 0) mind++;
+    const v = head[mind];
+    remove(v);
+    perm[step] = v;
+    const nbrs = Array.from(adj[v]);
+    for (const u of nbrs) adj[u].delete(v);
+    for (let a = 0; a < nbrs.length; a++) {
+      const u = nbrs[a];
+      const su = adj[u];
+      for (let b = a + 1; b < nbrs.length; b++) {
+        const w = nbrs[b];
+        if (!su.has(w)) {
+          su.add(w);
+          adj[w].add(u);
+        }
+      }
+    }
+    for (const u of nbrs) {
+      remove(u);
+      deg[u] = adj[u].size;
+      insert(u);
+      if (deg[u] < mind) mind = deg[u];
+    }
+    adj[v].clear();
+  }
+  return perm;
+}
+function reverseCuthillMcKee(A) {
+  const adj = symmetricAdjacency(A);
+  const n = adj.length;
+  const nb = adj.map(
+    (s) => Array.from(s).sort((a, b) => adj[a].size - adj[b].size || a - b)
+  );
+  const visited = new Uint8Array(n);
+  const order = [];
+  const bfsLevels = (start) => {
+    const seen = new Uint8Array(n);
+    let frontier = [start];
+    seen[start] = 1;
+    let levels = 0;
+    let last = start;
+    while (frontier.length > 0) {
+      const nextF = [];
+      for (const u of frontier)
+        for (const w of nb[u])
+          if (!seen[w]) {
+            seen[w] = 1;
+            nextF.push(w);
+          }
+      if (nextF.length === 0) {
+        last = frontier.reduce((a, b) => adj[b].size < adj[a].size ? b : a);
+        break;
+      }
+      frontier = nextF;
+      levels++;
+    }
+    return { last, levels };
+  };
+  for (let s0 = 0; s0 < n; s0++) {
+    if (visited[s0]) continue;
+    let start = s0;
+    let info = bfsLevels(start);
+    for (let iter = 0; iter < 4; iter++) {
+      const cand = bfsLevels(info.last);
+      if (cand.levels > info.levels) {
+        start = info.last;
+        info = cand;
+      } else {
+        start = info.last;
+        break;
+      }
+    }
+    const queue = [start];
+    visited[start] = 1;
+    let qh = 0;
+    while (qh < queue.length) {
+      const u = queue[qh++];
+      order.push(u);
+      for (const w of nb[u])
+        if (!visited[w]) {
+          visited[w] = 1;
+          queue.push(w);
+        }
+    }
+  }
+  const perm = new Int32Array(n);
+  for (let i = 0; i < n; i++) perm[i] = order[n - 1 - i];
+  return perm;
+}
+function ataPattern(A) {
+  const At = sparseTranspose(A);
+  const n = A.n;
+  const marker = new Int32Array(n).fill(-1);
+  const ir = [];
+  const jc = new Int32Array(n + 1);
+  for (let j = 0; j < n; j++) {
+    jc[j] = ir.length;
+    for (let k = A.jc[j]; k < A.jc[j + 1]; k++) {
+      const row = A.ir[k];
+      for (let t = At.jc[row]; t < At.jc[row + 1]; t++) {
+        const i = At.ir[t];
+        if (marker[i] !== j) {
+          marker[i] = j;
+          ir.push(i);
+        }
+      }
+    }
+  }
+  jc[n] = ir.length;
+  const pr = allocFloat64Array(ir.length).fill(1);
+  return fromUnsortedColumns(n, n, new Int32Array(ir), jc, pr);
+}
+function columnOrdering(A) {
+  return minimumDegreeOrdering(ataPattern(A));
+}
+var DENSE_FRACTION = 0.5;
+function sparseSolve(A, B, nrhs) {
+  const n = A.n;
+  if (A.m !== n || A.pi) return null;
+  if (n === 0) return allocFloat64Array(0);
+  const nnz = A.jc[n];
+  if (nnz > DENSE_FRACTION * n * n && n > 8) return null;
+  if (sparseIsUpper(A)) {
+    const r = sparseSolveUpper(A, B, nrhs);
+    if (r.singular) emitWarning(SINGULAR_WARNING);
+    return r.x;
+  }
+  if (sparseIsLower(A)) {
+    const r = sparseSolveLower(A, B, nrhs);
+    if (r.singular) emitWarning(SINGULAR_WARNING);
+    return r.x;
+  }
+  const perm = reverseCuthillMcKee(A);
+  if (sparseIsSymmetric(A) && allDiagPositive(A)) {
+    const Ap = sparsePermute(A, perm, perm);
+    const ch = sparseChol(Ap);
+    if (ch.ok) {
+      const Lt = sparseTranspose(ch.L);
+      const bp = permuteRows(B, n, nrhs, perm);
+      const y = sparseSolveLower(ch.L, bp, nrhs).x;
+      const z = sparseSolveUpper(Lt, y, nrhs).x;
+      return unpermuteRows(z, n, nrhs, perm);
+    }
+  }
+  const lu2 = sparseLu(A, perm, 1);
+  return luSolve(lu2, B, nrhs);
+}
+function luSolve(lu2, B, nrhs) {
+  const n = lu2.U.n;
+  const pb = permuteRows(B, n, nrhs, lu2.p);
+  const y = sparseSolveLower(lu2.L, pb, nrhs);
+  const z = sparseSolveUpper(lu2.U, y.x, nrhs);
+  if (lu2.singular || z.singular) emitWarning(SINGULAR_WARNING);
+  return unpermuteRows(z.x, n, nrhs, lu2.q);
+}
+function luSolveTransposed(lu2, B, nrhs) {
+  const n = lu2.U.n;
+  const qb = permuteRows(B, n, nrhs, lu2.q);
+  const y = sparseSolveLower(sparseTranspose(lu2.U), qb, nrhs);
+  const z = sparseSolveUpper(sparseTranspose(lu2.L), y.x, nrhs);
+  if (lu2.singular || y.singular) emitWarning(SINGULAR_WARNING);
+  return unpermuteRows(z.x, n, nrhs, lu2.p);
+}
+function sparseInverse(A) {
+  const n = A.n;
+  if (A.m !== n) throw new RuntimeError("inv: matrix must be square");
+  const I = allocFloat64Array(n * n);
+  for (let i = 0; i < n; i++) I[i + i * n] = 1;
+  const X = sparseSolve(A, I, n);
+  if (X === null) throw new RuntimeError("inv: unsupported sparse matrix");
+  return denseDataToSparse(X, n, n);
+}
+
 // src/numbl-core/helpers/arithmetic.ts
 function toComplex(v) {
   if (isRuntimeComplexNumber(v)) return { re: v.re, im: v.im };
@@ -23170,6 +25259,12 @@ function mElemMul(a, b) {
 }
 function mDiv(a, b) {
   if (isRuntimeSparseMatrix(a) || isRuntimeSparseMatrix(b)) {
+    if (isRuntimeSparseMatrix(a) && (isRuntimeNumber(b) || isRuntimeLogical(b) || isRuntimeComplexNumber(b) || isRuntimeTensor(b) && b.data.length === 1))
+      return mElemDivSparse(a, b);
+    if (isRuntimeSparseMatrix(b) && !(b.m === 1 && b.n === 1)) {
+      const result = mLeftDiv(mConjugateTranspose(b), mConjugateTranspose(a));
+      return mConjugateTranspose(result);
+    }
     return mDiv(densify(a), densify(b));
   }
   if (isRuntimeTensor(a) && a.data.length === 1) a = unwrap1x1(a);
@@ -23225,8 +25320,50 @@ function mElemDiv(a, b) {
   }
   return binaryOp(a, b, (x, y) => x / y, BIN_OP_DIV);
 }
+function sparseLeftDiv(A, b) {
+  if (A.pi) return null;
+  if (A.m === 1 && A.n === 1) return null;
+  let B;
+  let rows, nrhs;
+  const bSparse = isRuntimeSparseMatrix(b);
+  if (isRuntimeSparseMatrix(b)) {
+    if (b.pi) return null;
+    const d = sparseToDense(b);
+    B = d.data;
+    rows = b.m;
+    nrhs = b.n;
+  } else if (isRuntimeTensor(b)) {
+    if (b.imag) return null;
+    [rows, nrhs] = tensorSize2D(b);
+    B = b.data;
+  } else if (isRuntimeNumber(b) || isRuntimeLogical(b)) {
+    B = allocFloat64Array([toNumber(b)]);
+    rows = 1;
+    nrhs = 1;
+  } else {
+    return null;
+  }
+  if (rows !== A.m)
+    throw new RuntimeError(
+      `mldivide (\\): A is ${A.m}\xD7${A.n} but B has ${rows} rows`
+    );
+  if (A.m !== A.n) {
+    emitWarning(
+      "mldivide: sparse least-squares uses a dense factorization; the sparse matrix is converted to full."
+    );
+    return null;
+  }
+  const X = sparseSolve(A, B, nrhs);
+  if (X === null) return null;
+  if (bSparse) return denseDataToSparse(X, A.n, nrhs);
+  return unwrap1x1(RTV.tensor(X, [A.n, nrhs]));
+}
 function mLeftDiv(a, b) {
-  if (isRuntimeSparseMatrix(a)) return mLeftDiv(densify(a), b);
+  if (isRuntimeSparseMatrix(a)) {
+    const r = sparseLeftDiv(a, b);
+    if (r !== null) return r;
+    return mLeftDiv(densify(a), densify(b));
+  }
   if (isRuntimeSparseMatrix(b)) return mLeftDiv(a, densify(b));
   if (isRuntimeTensor(a) && a.data.length === 1) a = unwrap1x1(a);
   if (isRuntimeTensor(b) && b.data.length === 1) b = unwrap1x1(b);
@@ -32626,7 +34763,11 @@ function binop(op, a, b) {
         result = mElemDiv(mb, ma);
         break;
       }
-      const tensorA = isRuntimeSparseMatrix(ma) ? sparseToDense(ma) : ma;
+      if (isRuntimeSparseMatrix(ma)) {
+        result = mLeftDiv(ma, mb);
+        break;
+      }
+      const tensorA = ma;
       const tensorB = isRuntimeNumber(mb) ? RTV.tensor(allocFloat64Array([mb]), [1, 1]) : isRuntimeSparseMatrix(mb) ? sparseToDense(mb) : mb;
       if (!isRuntimeTensor(tensorA) || !isRuntimeTensor(tensorB))
         throw new RuntimeError(
@@ -40039,6 +42180,24 @@ defineBuiltin({
 });
 
 // src/numbl-core/interpreter/builtins/linear-algebra.ts
+var SPARSE_TYPE = { kind: "sparse_matrix", isComplex: false };
+function toSparseOperand(v, name) {
+  if (isRuntimeSparseMatrix(v)) return v;
+  if (isRuntimeNumber(v) || typeof v === "boolean")
+    return denseToSparse(RTV.tensor(allocFloat64Array([Number(v)]), [1, 1]));
+  if (isRuntimeTensor(v)) return denseToSparse(v);
+  throw new RuntimeError(`${name}: arguments must be numeric`);
+}
+function speyeSparse(n) {
+  const ir = new Int32Array(n);
+  const jc = new Int32Array(n + 1);
+  const pr = allocFloat64Array(n).fill(1);
+  for (let i = 0; i < n; i++) {
+    ir[i] = i;
+    jc[i + 1] = i + 1;
+  }
+  return RTV.sparseMatrix(n, n, ir, jc, pr);
+}
 function isNumericJitType(t) {
   return t.kind === "number" || t.kind === "boolean" || t.kind === "complex_or_number" || t.kind === "tensor" || t.kind === "sparse_matrix";
 }
@@ -40079,12 +42238,53 @@ function normApply(args) {
   const v = args[0];
   if (isRuntimeNumber(v)) return RTV.num(Math.abs(v));
   if (isRuntimeComplexNumber(v)) return RTV.num(Math.hypot(v.re, v.im));
-  if (isRuntimeSparseMatrix(v))
+  if (isRuntimeSparseMatrix(v)) {
+    const fast = sparseNormFast(v, args[1]);
+    if (fast !== null) return RTV.num(fast);
     return normApply([sparseToDense(v), ...args.slice(1)]);
+  }
   if (!isRuntimeTensor(v))
     throw new RuntimeError("norm: argument must be numeric");
   return normImplTensor(v, args);
 }
+function sparseNormFast(S, p2) {
+  if (S.m === 1 || S.n === 1) return null;
+  let kind = null;
+  if (p2 === void 0) return null;
+  if (isRuntimeNumber(p2)) {
+    if (p2 === 1) kind = "one";
+    else if (p2 === Infinity) kind = "inf";
+  } else if (isRuntimeChar(p2) || isRuntimeString(p2)) {
+    const s = parseStringArgLower(p2);
+    if (s === "fro") kind = "fro";
+    else if (s === "inf") kind = "inf";
+  }
+  if (kind === null) return null;
+  const mag2 = (k) => S.pi ? Math.hypot(S.pr[k], S.pi[k]) : Math.abs(S.pr[k]);
+  const nnz = S.jc[S.n];
+  if (kind === "fro") {
+    let sum2 = 0;
+    for (let k = 0; k < nnz; k++) {
+      const a = mag2(k);
+      sum2 += a * a;
+    }
+    return Math.sqrt(sum2);
+  }
+  if (kind === "one") {
+    let best2 = 0;
+    for (let j = 0; j < S.n; j++) {
+      let sum2 = 0;
+      for (let k = S.jc[j]; k < S.jc[j + 1]; k++) sum2 += mag2(k);
+      if (sum2 > best2) best2 = sum2;
+    }
+    return best2;
+  }
+  const rowSums = allocFloat64Array(S.m);
+  for (let k = 0; k < nnz; k++) rowSums[S.ir[k]] += mag2(k);
+  let best = 0;
+  for (let i = 0; i < S.m; i++) if (rowSums[i] > best) best = rowSums[i];
+  return best;
+}
 function scaledEuclid(magnitudes, count) {
   let scale = 0;
   let ssq = 1;
@@ -40709,11 +42909,18 @@ defineBuiltin({
         if (a.kind === "complex_or_number") return [COMPLEX_OR_NUM];
         if (a.kind === "tensor")
           return [{ kind: "tensor", isComplex: a.isComplex }];
+        if (a.kind === "sparse_matrix")
+          return [{ kind: "sparse_matrix", isComplex: a.isComplex }];
         return null;
       },
-      apply: (args) => {
+      apply: function invApply(args) {
         if (args.length < 1) throw new RuntimeError("inv requires 1 argument");
         const A = args[0];
+        if (isRuntimeSparseMatrix(A)) {
+          if (!A.pi) return sparseInverse(A);
+          const dense = invApply([sparseToDense(A)]);
+          return isRuntimeTensor(dense) ? denseToSparse(dense) : dense;
+        }
         if (isRuntimeComplexNumber(A)) {
           const { re, im } = A;
           if (re === 0 && im === 0)
@@ -41066,6 +43273,67 @@ registerIBuiltin({
     return { outputTypes: outs, apply: (args, n) => bandwidthApply(args, n) };
   }
 });
+function isTriangularValue(A, upper) {
+  if (isRuntimeNumber(A) || isRuntimeComplexNumber(A)) return true;
+  if (isRuntimeSparseMatrix(A))
+    return upper ? sparseIsUpper(A) : sparseIsLower(A);
+  if (isRuntimeTensor(A)) {
+    if (A.shape.length > 2) return false;
+    const [m, n] = tensorSize2D(A);
+    for (let j = 0; j < n; j++)
+      for (let i = 0; i < m; i++) {
+        if (upper ? i <= j : i >= j) continue;
+        const idx = colMajorIndex(i, j, m);
+        if (A.data[idx] !== 0 || A.imag && A.imag[idx] !== 0) return false;
+      }
+    return true;
+  }
+  throw new RuntimeError("istriu: argument must be a numeric matrix");
+}
+for (const [name, upper] of [
+  ["istriu", true],
+  ["istril", false]
+]) {
+  registerIBuiltin({
+    name,
+    help: {
+      signatures: [`tf = ${name}(A)`],
+      description: `True if A is ${upper ? "upper" : "lower"} triangular (all entries ${upper ? "below" : "above"} the main diagonal are zero). Works for dense and sparse matrices.`
+    },
+    resolve: (argTypes, nargout) => {
+      if (nargout > 1 || argTypes.length !== 1) return null;
+      if (!isNumericJitType(argTypes[0])) return null;
+      return {
+        outputTypes: [{ kind: "boolean" }],
+        apply: (args) => RTV.logical(isTriangularValue(args[0], upper))
+      };
+    }
+  });
+}
+registerIBuiltin({
+  name: "isbanded",
+  help: {
+    signatures: ["tf = isbanded(A, lower, upper)"],
+    description: "True if A has lower bandwidth at most `lower` and upper bandwidth at most `upper`. Works for dense and sparse matrices."
+  },
+  resolve: (argTypes, nargout) => {
+    if (nargout > 1 || argTypes.length !== 3) return null;
+    if (!isNumericJitType(argTypes[0])) return null;
+    return {
+      outputTypes: [{ kind: "boolean" }],
+      apply: (args) => {
+        const lo = toNumber(args[1]);
+        const up = toNumber(args[2]);
+        if (lo < 0 || up < 0 || !Number.isInteger(lo) || !Number.isInteger(up))
+          throw new RuntimeError(
+            "isbanded: bandwidths must be nonnegative integers"
+          );
+        const [l, u] = computeBandwidth(args[0]);
+        return RTV.logical(l <= lo && u <= up);
+      }
+    };
+  }
+});
 function computeATA(A_data, m, n) {
   const result = allocFloat64Array(n * n);
   for (let j = 0; j < n; j++)
@@ -41434,19 +43702,59 @@ function qrPivotApply(A, m, n, k, econ) {
 registerIBuiltin({
   name: "lu",
   resolve: (argTypes, nargout) => {
-    if (nargout < 0 || nargout > 3) return null;
-    if (argTypes.length < 1 || argTypes.length > 2) return null;
+    if (nargout < 0 || nargout > 4) return null;
+    if (argTypes.length < 1 || argTypes.length > 3) return null;
     if (!isNumericJitType(argTypes[0])) return null;
-    const t = tensorType();
+    const sparse = argTypes[0].kind === "sparse_matrix";
+    if (!sparse && (nargout > 3 || argTypes.length > 2)) return null;
+    const t = sparse ? SPARSE_TYPE : tensorType();
     const wrapped = (args, n) => withScratch(() => luApply(args, n));
     if (nargout <= 1) return { outputTypes: [t], apply: wrapped };
     if (nargout === 2) return { outputTypes: [t, t], apply: wrapped };
-    return { outputTypes: [t, t, t], apply: wrapped };
+    if (nargout === 3) return { outputTypes: [t, t, t], apply: wrapped };
+    return { outputTypes: [t, t, t, t], apply: wrapped };
   }
 });
+function sparseLuApply(S, args, nargout) {
+  let outputForm = "matrix";
+  let tol = nargout >= 4 ? 0.1 : 1;
+  for (const opt of args.slice(1)) {
+    if (isRuntimeNumber(opt)) {
+      if (!(opt >= 0 && opt <= 1))
+        throw new RuntimeError("lu: pivot threshold must be in [0, 1]");
+      tol = opt;
+    } else {
+      const form = parseLuOutputForm(opt);
+      if (form === null)
+        throw new RuntimeError("lu: outputForm must be 'matrix' or 'vector'");
+      outputForm = form;
+    }
+  }
+  const q = nargout >= 4 ? columnOrdering(S) : null;
+  const res = sparseLu(S, q, tol);
+  const { L, U, p: p2 } = res;
+  if (nargout <= 1) {
+    return mSub(mAdd(L, U), speyeSparse(Math.min(S.m, S.n)));
+  }
+  if (nargout === 2) {
+    const Lperm = sparsePermute(L, invertPerm(p2), identityPerm(L.n));
+    return [Lperm, U];
+  }
+  const permOut = (perm) => outputForm === "vector" ? permVectorTensor(perm) : permutationMatrix(perm);
+  if (nargout === 3) return [L, U, permOut(p2)];
+  const Q = outputForm === "vector" ? permVectorTensor(res.q) : sparseTranspose(permutationMatrix(res.q));
+  return [L, U, permOut(p2), Q];
+}
 function luApply(args, nargout) {
   if (args.length < 1)
     throw new RuntimeError("lu requires at least 1 argument");
+  if (isRuntimeSparseMatrix(args[0]) && !args[0].pi)
+    return sparseLuApply(args[0], args, nargout);
+  if (isRuntimeSparseMatrix(args[0])) {
+    const dense = luApply([sparseToDense(args[0]), ...args.slice(1)], nargout);
+    const toSp = (v) => isRuntimeTensor(v) ? denseToSparse(v) : v;
+    return Array.isArray(dense) ? dense.map(toSp) : toSp(dense);
+  }
   const outputForm = args.length >= 2 ? parseLuOutputForm(args[1]) : "matrix";
   if (outputForm === null)
     throw new RuntimeError("lu: outputForm must be 'matrix' or 'vector'");
@@ -41565,7 +43873,7 @@ function ipivToPermVector(ipiv, m) {
 registerIBuiltin({
   name: "eig",
   resolve: (argTypes, nargout) => {
-    if (nargout < 0 || nargout > 3 || argTypes.length < 1 || argTypes.length > 3)
+    if (nargout < 0 || nargout > 3 || argTypes.length < 1 || argTypes.length > 4)
       return null;
     if (!isNumericJitType(argTypes[0])) return null;
     const c = tensorType(true);
@@ -41580,7 +43888,9 @@ function eigApply(args, nargout) {
   if (args.length < 1)
     throw new RuntimeError("eig requires at least 1 argument");
   const A = args[0];
-  const { balance, outputForm } = parseEigOptionsRuntime(args);
+  const { B, balance, outputForm, algorithm } = parseEigOptionsRuntime(args);
+  if (B !== void 0)
+    return eigGeneralizedApply(A, B, nargout, outputForm, algorithm);
   if (isRuntimeNumber(A)) {
     const val = A;
     if (nargout <= 1) return RTV.num(val);
@@ -41597,6 +43907,10 @@ function eigApply(args, nargout) {
   const [m, n] = tensorSize2D(A);
   if (m !== n) throw new RuntimeError("eig: input must be a square matrix");
   const computeVL = nargout >= 3, computeVR = nargout >= 2;
+  if (isExactlyHermitian(A, n)) {
+    const symResult = eigSymmetricApply(A, n, nargout, outputForm);
+    if (symResult) return symResult;
+  }
   if (A.imag) {
     const bridge2 = getEffectiveBridge("eigComplex", "eigComplex");
     if (!bridge2.eigComplex)
@@ -41632,19 +43946,369 @@ function eigApply(args, nargout) {
   const Wout = computeVL && VL ? buildEigenvectorMatrix(VL, wi, n, hasComplex) : RTV.tensor(allocFloat64Array(n * n), [n, n]);
   return [Vout, Dout, Wout];
 }
+function isExactlyHermitian(A, n) {
+  const re = A.data;
+  const im = A.imag;
+  for (let j = 0; j < n; j++) {
+    if (im && im[j + j * n] !== 0) return false;
+    const dj = re[j + j * n];
+    if (Number.isNaN(dj)) return false;
+    for (let i = j + 1; i < n; i++) {
+      if (re[i + j * n] !== re[j + i * n]) return false;
+      if (im && im[i + j * n] !== -im[j + i * n]) return false;
+    }
+  }
+  return true;
+}
+function eigSymmetricApply(A, n, nargout, outputForm) {
+  const computeV = nargout >= 2;
+  let w;
+  let VRe;
+  let VIm;
+  if (A.imag) {
+    const bridge = getEffectiveBridge("eigHerm", "eigHerm");
+    if (!bridge.eigHerm) return null;
+    const r = bridge.eigHerm(toF64(A.data), toF64(A.imag), n, computeV);
+    if (!r) return null;
+    w = r.w;
+    VRe = r.VRe;
+    VIm = r.VIm;
+  } else {
+    const bridge = getEffectiveBridge("eigSym", "eigSym");
+    if (!bridge.eigSym) return null;
+    const r = bridge.eigSym(toF64(A.data), n, computeV);
+    if (!r) return null;
+    w = r.w;
+    VRe = r.V;
+  }
+  if (nargout <= 1) return RTV.tensor(w, [n, 1]);
+  const makeV = () => VRe ? maybeComplexTensor(
+    allocFloat64Array(VRe),
+    [n, n],
+    VIm ? allocFloat64Array(VIm) : void 0
+  ) : RTV.tensor(allocFloat64Array(n * n), [n, n]);
+  const Vout = makeV();
+  const Dout = outputForm === "vector" ? RTV.tensor(allocFloat64Array(w), [n, 1]) : buildDiagMatrix(w, void 0, n);
+  if (nargout === 2) return [Vout, Dout];
+  return [Vout, Dout, makeV()];
+}
 function parseEigOptionsRuntime(args) {
-  let balance = true, outputForm = "matrix";
-  for (let i = 1; i < args.length; i++) {
+  let balance = true, outputForm = "matrix", algorithm = "auto";
+  let B;
+  let first = 1;
+  if (args.length >= 2 && !isStringLikeArg(args[1])) {
+    B = args[1];
+    first = 2;
+  }
+  for (let i = first; i < args.length; i++) {
     const arg = args[i];
-    if (isRuntimeString(arg) || isRuntimeChar(arg)) {
-      const val = parseStringArgLower(arg);
-      if (val === "nobalance") balance = false;
-      else if (val === "balance") balance = true;
-      else if (val === "vector") outputForm = "vector";
-      else if (val === "matrix") outputForm = "matrix";
+    if (!isStringLikeArg(arg))
+      throw new RuntimeError(
+        "eig: option arguments must be character vectors or strings"
+      );
+    const val = parseStringArgLower(arg);
+    if (val === "nobalance") balance = false;
+    else if (val === "balance") balance = true;
+    else if (val === "vector") outputForm = "vector";
+    else if (val === "matrix") outputForm = "matrix";
+    else if (val === "chol" || val === "qz") algorithm = val;
+    else throw new RuntimeError(`eig: unknown option '${val}'`);
+  }
+  if (algorithm !== "auto" && B === void 0)
+    throw new RuntimeError(
+      `eig: the '${algorithm}' algorithm applies only to eig(A, B)`
+    );
+  return { B, balance, outputForm, algorithm };
+}
+function isStringLikeArg(arg) {
+  return isRuntimeString(arg) || isRuntimeChar(arg);
+}
+function toSplitSquare(v, name) {
+  if (isRuntimeNumber(v))
+    return { M: { re: allocFloat64Array([v]), im: null }, n: 1 };
+  if (isRuntimeComplexNumber(v))
+    return {
+      M: { re: allocFloat64Array([v.re]), im: allocFloat64Array([v.im]) },
+      n: 1
+    };
+  let t = v;
+  if (isRuntimeSparseMatrix(t))
+    t = sparseToDense(
+      t
+    );
+  if (!isRuntimeTensor(t))
+    throw new RuntimeError(`eig: ${name} must be a numeric matrix`);
+  const [rows, cols] = tensorSize2D(t);
+  if (rows !== cols)
+    throw new RuntimeError(`eig: ${name} must be a square matrix`);
+  return {
+    M: { re: toF64(t.data), im: t.imag ? toF64(t.imag) : null },
+    n: rows
+  };
+}
+function splitIsHermitian(M, n) {
+  for (let j = 0; j < n; j++) {
+    if (M.im && M.im[j + j * n] !== 0) return false;
+    if (Number.isNaN(M.re[j + j * n])) return false;
+    for (let i = j + 1; i < n; i++) {
+      if (M.re[i + j * n] !== M.re[j + i * n]) return false;
+      if (M.im && M.im[i + j * n] !== -M.im[j + i * n]) return false;
+    }
+  }
+  return true;
+}
+function eigGeneralizedApply(Aval, Bval, nargout, outputForm, algorithm) {
+  const { M: A, n } = toSplitSquare(Aval, "A");
+  const { M: B, n: nB } = toSplitSquare(Bval, "B");
+  if (n !== nB) throw new RuntimeError("eig: A and B must be the same size");
+  if (algorithm !== "qz" && splitIsHermitian(A, n) && splitIsHermitian(B, n)) {
+    const R = choleskyFactor(B, n);
+    if (R) return eigSymmetricDefinite(A, R, n, nargout, outputForm);
+    if (algorithm === "chol")
+      throw new RuntimeError(
+        "eig: the 'chol' algorithm requires B to be symmetric positive definite"
+      );
+  }
+  return eigGeneralizedQz(A, B, n, nargout, outputForm);
+}
+function choleskyFactor(B, n) {
+  if (B.im) {
+    const bridge2 = getEffectiveBridge("cholComplex", "cholComplex");
+    if (!bridge2.cholComplex) return null;
+    const r2 = bridge2.cholComplex(B.re, B.im, n, true);
+    if (!r2 || r2.info !== 0) return null;
+    return { re: r2.RRe, im: r2.RIm };
+  }
+  const bridge = getEffectiveBridge("chol", "chol");
+  if (!bridge.chol) return null;
+  const r = bridge.chol(B.re, n, true);
+  if (!r || r.info !== 0) return null;
+  return { re: r.R, im: null };
+}
+function eigSymmetricDefinite(A, R, n, nargout, outputForm) {
+  const complex = !!(A.im || R.im);
+  const Y = solveLeftConjTransposeUpper(R, A, n, complex);
+  const C = solveRightUpper(Y, R, n, complex);
+  symmetrizeInPlace(C, n);
+  const computeV = nargout >= 2;
+  let w;
+  let SRe;
+  let SIm;
+  if (complex) {
+    const bridge = getEffectiveBridge("eigHerm", "eigHerm");
+    if (!bridge.eigHerm)
+      throw new RuntimeError("eig: Hermitian eig bridge not available");
+    const r = bridge.eigHerm(
+      C.re,
+      C.im ?? allocFloat64Array(n * n),
+      n,
+      computeV
+    );
+    w = r.w;
+    SRe = r.VRe;
+    SIm = r.VIm;
+  } else {
+    const bridge = getEffectiveBridge("eigSym", "eigSym");
+    if (!bridge.eigSym)
+      throw new RuntimeError("eig: symmetric eig bridge not available");
+    const r = bridge.eigSym(C.re, n, computeV);
+    w = r.w;
+    SRe = r.V;
+  }
+  if (nargout <= 1) return RTV.tensor(w, [n, 1]);
+  const S = {
+    re: SRe ?? allocFloat64Array(n * n),
+    im: SIm ?? null
+  };
+  const V = SRe ? solveUpper(R, S, n, complex) : S;
+  const makeV = () => maybeComplexTensor(
+    allocFloat64Array(V.re),
+    [n, n],
+    V.im ? allocFloat64Array(V.im) : void 0
+  );
+  const Vout = makeV();
+  const Dout = outputForm === "vector" ? RTV.tensor(allocFloat64Array(w), [n, 1]) : buildDiagMatrix(w, void 0, n);
+  if (nargout === 2) return [Vout, Dout];
+  return [Vout, Dout, makeV()];
+}
+function symmetrizeInPlace(M, n) {
+  for (let j = 0; j < n; j++) {
+    if (M.im) M.im[j + j * n] = 0;
+    for (let i = j + 1; i < n; i++) {
+      const a = (M.re[i + j * n] + M.re[j + i * n]) / 2;
+      M.re[i + j * n] = a;
+      M.re[j + i * n] = a;
+      if (M.im) {
+        const b = (M.im[i + j * n] - M.im[j + i * n]) / 2;
+        M.im[i + j * n] = b;
+        M.im[j + i * n] = -b;
+      }
+    }
+  }
+}
+function solveLeftConjTransposeUpper(R, Bm, n, complex) {
+  const X = {
+    re: allocFloat64Array(n * n),
+    im: complex ? allocFloat64Array(n * n) : null
+  };
+  for (let c = 0; c < n; c++) {
+    for (let i = 0; i < n; i++) {
+      let sr = Bm.re[i + c * n];
+      let si = Bm.im ? Bm.im[i + c * n] : 0;
+      for (let k = 0; k < i; k++) {
+        const lr = R.re[k + i * n];
+        const li = R.im ? -R.im[k + i * n] : 0;
+        const xr = X.re[k + c * n];
+        const xi = X.im ? X.im[k + c * n] : 0;
+        sr -= lr * xr - li * xi;
+        si -= lr * xi + li * xr;
+      }
+      const dr = R.re[i + i * n];
+      const di = R.im ? -R.im[i + i * n] : 0;
+      const [qr2, qi] = complexDivide2(sr, si, dr, di);
+      X.re[i + c * n] = qr2;
+      if (X.im) X.im[i + c * n] = qi;
+    }
+  }
+  return X;
+}
+function solveRightUpper(Y, R, n, complex) {
+  const C = {
+    re: allocFloat64Array(n * n),
+    im: complex ? allocFloat64Array(n * n) : null
+  };
+  for (let j = 0; j < n; j++) {
+    for (let i = 0; i < n; i++) {
+      let sr = Y.re[i + j * n];
+      let si = Y.im ? Y.im[i + j * n] : 0;
+      for (let k = 0; k < j; k++) {
+        const cr = C.re[i + k * n];
+        const ci = C.im ? C.im[i + k * n] : 0;
+        const rr = R.re[k + j * n];
+        const ri = R.im ? R.im[k + j * n] : 0;
+        sr -= cr * rr - ci * ri;
+        si -= cr * ri + ci * rr;
+      }
+      const dr = R.re[j + j * n];
+      const di = R.im ? R.im[j + j * n] : 0;
+      const [qr2, qi] = complexDivide2(sr, si, dr, di);
+      C.re[i + j * n] = qr2;
+      if (C.im) C.im[i + j * n] = qi;
+    }
+  }
+  return C;
+}
+function solveUpper(R, S, n, complex) {
+  const V = {
+    re: allocFloat64Array(n * n),
+    im: complex ? allocFloat64Array(n * n) : null
+  };
+  for (let c = 0; c < n; c++) {
+    for (let i = n - 1; i >= 0; i--) {
+      let sr = S.re[i + c * n];
+      let si = S.im ? S.im[i + c * n] : 0;
+      for (let k = i + 1; k < n; k++) {
+        const rr = R.re[i + k * n];
+        const ri = R.im ? R.im[i + k * n] : 0;
+        const vr = V.re[k + c * n];
+        const vi = V.im ? V.im[k + c * n] : 0;
+        sr -= rr * vr - ri * vi;
+        si -= rr * vi + ri * vr;
+      }
+      const dr = R.re[i + i * n];
+      const di = R.im ? R.im[i + i * n] : 0;
+      const [qr2, qi] = complexDivide2(sr, si, dr, di);
+      V.re[i + c * n] = qr2;
+      if (V.im) V.im[i + c * n] = qi;
+    }
+  }
+  return V;
+}
+function complexDivide2(ar, ai, br, bi) {
+  if (bi === 0) return [ar / br, ai / br];
+  if (Math.abs(br) >= Math.abs(bi)) {
+    const r2 = bi / br;
+    const t2 = br + bi * r2;
+    return [(ar + ai * r2) / t2, (ai - ar * r2) / t2];
+  }
+  const r = br / bi;
+  const t = br * r + bi;
+  return [(ar * r + ai) / t, (ai * r - ar) / t];
+}
+function eigGeneralizedQz(A, B, n, nargout, outputForm) {
+  const computeEigvecs = nargout >= 2;
+  const wr = allocFloat64Array(n);
+  const wi = allocFloat64Array(n);
+  let V = null;
+  let W = null;
+  if (A.im || B.im) {
+    const bridge = getEffectiveBridge("qzComplex", "qzComplex");
+    if (!bridge.qzComplex) throw generalizedUnsupported();
+    const r = bridge.qzComplex(
+      A.re,
+      A.im ?? allocFloat64Array(n * n),
+      B.re,
+      B.im ?? allocFloat64Array(n * n),
+      n,
+      computeEigvecs
+    );
+    if (!r) throw new RuntimeError("eig: complex QZ failed");
+    for (let i = 0; i < n; i++) {
+      const [qr2, qi] = complexDivide2(
+        r.alphaRe[i],
+        r.alphaIm[i],
+        r.betaRe[i],
+        r.betaIm[i]
+      );
+      wr[i] = qr2;
+      wi[i] = qi;
+    }
+    if (computeEigvecs) {
+      if (!r.VRe || !r.VIm || !r.WRe || !r.WIm)
+        throw new RuntimeError(
+          "eig: failed to compute generalized eigenvectors"
+        );
+      V = maybeComplexTensor(
+        allocFloat64Array(r.VRe),
+        [n, n],
+        allocFloat64Array(r.VIm)
+      );
+      W = maybeComplexTensor(
+        allocFloat64Array(r.WRe),
+        [n, n],
+        allocFloat64Array(r.WIm)
+      );
+    }
+  } else {
+    const bridge = getEffectiveBridge("qz", "qz");
+    if (!bridge.qz) throw generalizedUnsupported();
+    const r = bridge.qz(A.re, B.re, n, computeEigvecs);
+    if (!r) throw new RuntimeError("eig: real QZ failed");
+    let hasComplex = false;
+    for (let i = 0; i < n; i++) {
+      const beta = r.beta[i];
+      wr[i] = r.alphar[i] / beta;
+      wi[i] = r.alphai[i] === 0 && beta === 0 ? 0 : r.alphai[i] / beta;
+      if (r.alphai[i] !== 0) hasComplex = true;
+    }
+    if (computeEigvecs) {
+      if (!r.V || !r.W)
+        throw new RuntimeError(
+          "eig: failed to compute generalized eigenvectors"
+        );
+      V = buildEigenvectorMatrix(r.V, r.alphai, n, hasComplex);
+      W = buildEigenvectorMatrix(r.W, r.alphai, n, hasComplex);
     }
   }
-  return { balance, outputForm };
+  if (nargout <= 1) return maybeComplexTensor(wr, [n, 1], wi);
+  const Dout = outputForm === "vector" ? maybeComplexTensor(wr, [n, 1], wi) : buildDiagMatrix(wr, wi, n);
+  if (nargout === 2) return [V, Dout];
+  return [V, Dout, W];
+}
+function generalizedUnsupported() {
+  return new RuntimeError(
+    "eig: the generalized eigenvalue problem eig(A, B) with a non symmetric-definite pencil requires the native LAPACK addon"
+  );
 }
 registerIBuiltin({
   name: "chol",
@@ -41652,13 +44316,31 @@ registerIBuiltin({
     if (nargout < 0 || nargout > 3 || argTypes.length < 1 || argTypes.length > 3)
       return null;
     if (!isNumericJitType(argTypes[0])) return null;
-    const t = tensorType();
+    const t = argTypes[0].kind === "sparse_matrix" ? SPARSE_TYPE : tensorType();
     const wrapped = (args, n) => withScratch(() => cholApply(args, n));
     if (nargout <= 1) return { outputTypes: [t], apply: wrapped };
     if (nargout === 2) return { outputTypes: [t, NUM], apply: wrapped };
     return { outputTypes: [t, NUM, t], apply: wrapped };
   }
 });
+function sparseCholApply(S, upper, outputForm, nargout) {
+  if (S.m !== S.n) throw new RuntimeError("chol: Matrix must be square.");
+  const n = S.n;
+  const perm = nargout >= 3 ? minimumDegreeOrdering(S) : identityPerm(n);
+  const A = nargout >= 3 ? sparsePermute(S, perm, perm) : S;
+  const res = sparseChol(A);
+  const R = upper ? sparseTranspose(res.L) : res.L;
+  const permOut = () => outputForm === "vector" ? permVectorTensor(perm) : permutationMatrix(invertPerm(perm));
+  if (!res.ok) {
+    if (nargout < 2)
+      throw new RuntimeError("chol: Matrix must be positive definite.");
+    if (nargout >= 3) return [R, RTV.num(res.p), permOut()];
+    return [R, RTV.num(res.p)];
+  }
+  if (nargout >= 3) return [R, RTV.num(0), permOut()];
+  if (nargout === 2) return [R, RTV.num(0)];
+  return R;
+}
 function cholApply(args, nargout) {
   if (args.length < 1)
     throw new RuntimeError("chol requires at least 1 argument");
@@ -41666,10 +44348,9 @@ function cholApply(args, nargout) {
   const inputIsSparse = isRuntimeSparseMatrix(A);
   if (nargout >= 3 && !inputIsSparse)
     throw new RuntimeError("Third output only available for sparse matrices.");
-  if (inputIsSparse)
-    A = sparseToDense(
-      A
-    );
+  const sparseInput = isRuntimeSparseMatrix(A) && !A.pi ? A : null;
+  if (inputIsSparse && !sparseInput)
+    A = sparseToDense(A);
   let triangle = "upper";
   let outputForm = "matrix";
   if (args.length === 2) {
@@ -41688,6 +44369,8 @@ function cholApply(args, nargout) {
     outputForm = form;
   }
   const upper = triangle === "upper";
+  if (sparseInput)
+    return sparseCholApply(sparseInput, upper, outputForm, nargout);
   if (isRuntimeNumber(A)) {
     const val = A;
     if (val <= 0) {
@@ -42105,15 +44788,28 @@ defineBuiltin({
         if (nargout > 1 || argTypes.length !== 2) return null;
         if (!isNumericJitType(argTypes[0]) || !isNumericJitType(argTypes[1]))
           return null;
+        if (argTypes.some((t) => t.kind === "sparse_matrix"))
+          return [
+            {
+              kind: "sparse_matrix",
+              isComplex: argTypes.some(
+                (t) => t.kind === "sparse_matrix" && t.isComplex
+              )
+            }
+          ];
         return [tensorType()];
       },
       apply: (args) => {
         if (args.length !== 2)
           throw new RuntimeError("kron requires 2 arguments");
+        if (isRuntimeSparseMatrix(args[0]) || isRuntimeSparseMatrix(args[1]))
+          return sparseKron(
+            toSparseOperand(args[0], "kron"),
+            toSparseOperand(args[1], "kron")
+          );
         const coerce = (v) => {
           if (isRuntimeNumber(v))
             return RTV.tensor(allocFloat64Array([v]), [1, 1]);
-          if (isRuntimeSparseMatrix(v)) return sparseToDense(v);
           if (isRuntimeTensor(v)) return v;
           throw new RuntimeError("kron: arguments must be numeric");
         };
@@ -49876,6 +52572,585 @@ registerIBuiltin({
   }
 });
 
+// src/numbl-core/interpreter/builtins/sparse-solvers.ts
+function toSparseArg(v, name) {
+  if (isRuntimeSparseMatrix(v)) return v;
+  if (isRuntimeTensor(v)) return denseToSparse(v);
+  if (isRuntimeNumber(v))
+    return denseToSparse(RTV.tensor(allocFloat64Array([v]), [1, 1]));
+  if (isRuntimeLogical(v))
+    return denseToSparse(RTV.tensor(allocFloat64Array([v ? 1 : 0]), [1, 1]));
+  throw new RuntimeError(`${name}: argument must be a numeric matrix`);
+}
+var ROW_VECTOR = { kind: "tensor", isComplex: false };
+registerIBuiltin({
+  name: "symrcm",
+  help: {
+    signatures: ["p = symrcm(A)"],
+    description: "Reverse Cuthill-McKee ordering of the pattern of A + A'. A(p,p) tends to have a smaller bandwidth than A."
+  },
+  resolve: (argTypes, nargout) => {
+    if (argTypes.length !== 1 || nargout > 1) return null;
+    return {
+      outputTypes: [ROW_VECTOR],
+      apply: (args) => permVectorTensor(reverseCuthillMcKee(toSparseArg(args[0], "symrcm")))
+    };
+  }
+});
+registerIBuiltin({
+  name: "amd",
+  help: {
+    signatures: ["p = amd(A)"],
+    description: "Minimum degree ordering of the pattern of A + A'. chol(A(p,p)) tends to be sparser than chol(A). numbl uses an exact minimum degree ordering, so p can differ from MATLAB's approximate minimum degree permutation."
+  },
+  resolve: (argTypes, nargout) => {
+    if (argTypes.length < 1 || argTypes.length > 2 || nargout > 1) return null;
+    return {
+      outputTypes: [ROW_VECTOR],
+      apply: (args) => permVectorTensor(minimumDegreeOrdering(toSparseArg(args[0], "amd")))
+    };
+  }
+});
+registerIBuiltin({
+  name: "colamd",
+  help: {
+    signatures: ["p = colamd(A)"],
+    description: "Column ordering for LU: minimum degree ordering of the pattern of A'*A. lu(A(:,p)) tends to produce sparser factors than lu(A)."
+  },
+  resolve: (argTypes, nargout) => {
+    if (argTypes.length < 1 || argTypes.length > 2 || nargout > 1) return null;
+    return {
+      outputTypes: [ROW_VECTOR],
+      apply: (args) => permVectorTensor(columnOrdering(toSparseArg(args[0], "colamd")))
+    };
+  }
+});
+function sampleDistinct(total, k) {
+  if (k >= total) {
+    const all2 = new Int32Array(total);
+    for (let i = 0; i < total; i++) all2[i] = i;
+    return all2;
+  }
+  let picked;
+  if (k > total / 3) {
+    const idx = new Int32Array(total);
+    for (let i = 0; i < total; i++) idx[i] = i;
+    for (let i = 0; i < k; i++) {
+      const j = i + Math.floor(rngRandom() * (total - i));
+      const t = idx[i];
+      idx[i] = idx[j];
+      idx[j] = t;
+    }
+    picked = idx.slice(0, k);
+  } else {
+    const set = /* @__PURE__ */ new Set();
+    while (set.size < k) set.add(Math.floor(rngRandom() * total));
+    picked = Int32Array.from(set);
+  }
+  return picked.sort();
+}
+function sparseFromLinearIndices(m, n, idx, gen) {
+  const nnz = idx.length;
+  const ir = new Int32Array(nnz);
+  const jc = new Int32Array(n + 1);
+  const pr = allocFloat64Array(nnz);
+  for (let k = 0; k < nnz; k++) {
+    const col = Math.floor(idx[k] / m);
+    ir[k] = idx[k] - col * m;
+    jc[col + 1]++;
+    pr[k] = gen();
+  }
+  for (let c = 0; c < n; c++) jc[c + 1] += jc[c];
+  return RTV.sparseMatrix(m, n, ir, jc, pr);
+}
+function registerSprand(name, gen) {
+  registerIBuiltin({
+    name,
+    help: {
+      signatures: [`R = ${name}(m, n, density)`, `R = ${name}(S)`],
+      description: `Random m-by-n sparse matrix with approximately density*m*n ` + (name === "sprand" ? "uniformly" : "normally") + ` distributed nonzeros, or a matrix with the pattern of S and random values.`
+    },
+    resolve: (argTypes, nargout) => {
+      if (nargout > 1) return null;
+      if (argTypes.length !== 1 && argTypes.length < 3) return null;
+      return {
+        outputTypes: [{ kind: "sparse_matrix", isComplex: false }],
+        apply: (args) => {
+          if (args.length === 1) {
+            const S = toSparseArg(args[0], name);
+            const pr = allocFloat64Array(S.pr.length);
+            for (let k2 = 0; k2 < pr.length; k2++) pr[k2] = gen();
+            return RTV.sparseMatrix(
+              S.m,
+              S.n,
+              new Int32Array(S.ir),
+              new Int32Array(S.jc),
+              pr
+            );
+          }
+          if (args.length > 3)
+            throw new RuntimeError(
+              `${name}: the reciprocal-condition form ${name}(m, n, density, rc) is not supported`
+            );
+          const m = Math.round(toNumber(args[0]));
+          const n = Math.round(toNumber(args[1]));
+          const density = toNumber(args[2]);
+          if (!(density >= 0 && density <= 1))
+            throw new RuntimeError(`${name}: density must be in [0, 1]`);
+          const total = m * n;
+          const k = Math.min(total, Math.round(density * total));
+          return sparseFromLinearIndices(m, n, sampleDistinct(total, k), gen);
+        }
+      };
+    }
+  });
+}
+registerSprand("sprand", rngRandom);
+registerSprand("sprandn", boxMullerRandom);
+registerIBuiltin({
+  name: "sprandsym",
+  help: {
+    signatures: ["R = sprandsym(n, density)", "R = sprandsym(S)"],
+    description: "Symmetric random n-by-n sparse matrix with approximately density*n*n normally distributed nonzeros, or a symmetric matrix with the pattern of the lower triangle of S."
+  },
+  resolve: (argTypes, nargout) => {
+    if (nargout > 1 || argTypes.length < 1 || argTypes.length > 2) return null;
+    return {
+      outputTypes: [{ kind: "sparse_matrix", isComplex: false }],
+      apply: (args) => {
+        let n;
+        let lowerIdx;
+        if (args.length === 1) {
+          const S = toSparseArg(args[0], "sprandsym");
+          if (S.m !== S.n)
+            throw new RuntimeError("sprandsym: S must be square");
+          n = S.n;
+          const idx = [];
+          for (let j = 0; j < n; j++)
+            for (let k = S.jc[j]; k < S.jc[j + 1]; k++)
+              if (S.ir[k] >= j) idx.push(j * n + S.ir[k]);
+          lowerIdx = Int32Array.from(idx);
+        } else {
+          n = Math.round(toNumber(args[0]));
+          const density = toNumber(args[1]);
+          if (!(density >= 0 && density <= 1))
+            throw new RuntimeError("sprandsym: density must be in [0, 1]");
+          const tri = n * (n + 1) / 2;
+          const k = Math.min(tri, Math.round(density * n * n / 2));
+          const triIdx = sampleDistinct(tri, k);
+          const lin = [];
+          for (let t = 0; t < triIdx.length; t++) {
+            let r = triIdx[t];
+            let col = 0;
+            while (r >= n - col) {
+              r -= n - col;
+              col++;
+            }
+            lin.push(col * n + col + r);
+          }
+          lowerIdx = Int32Array.from(lin).sort();
+        }
+        const lower = sparseFromLinearIndices(n, n, lowerIdx, boxMullerRandom);
+        const Lt = sparseTranspose(lower);
+        const dense = sparseToDense(lower).data;
+        const denseT = sparseToDense(Lt).data;
+        for (let i = 0; i < dense.length; i++) dense[i] += denseT[i];
+        for (let i = 0; i < n; i++) dense[i + i * n] /= 2;
+        return denseDataToSparse(dense, n, n);
+      }
+    };
+  }
+});
+var DEC_CLASS = "decomposition";
+function isDecomposition(v) {
+  return isRuntimeClassInstance(v) && v.className === DEC_CLASS;
+}
+function permFromField(d, name) {
+  const t = d.fields.get(name);
+  if (t === void 0 || !isRuntimeTensor(t))
+    throw new RuntimeError("decomposition: corrupt");
+  const p2 = new Int32Array(t.data.length);
+  for (let i = 0; i < p2.length; i++) p2[i] = t.data[i] - 1;
+  return p2;
+}
+function sparseField(d, name) {
+  const v = d.fields.get(name);
+  if (v === void 0 || !isRuntimeSparseMatrix(v))
+    throw new RuntimeError("decomposition: corrupt");
+  return v;
+}
+function charField(d, name) {
+  const v = d.fields.get(name);
+  if (v === void 0) throw new RuntimeError("decomposition: corrupt");
+  return parseStringArgLower(v);
+}
+function diagRatio(S) {
+  let lo = Infinity;
+  let hi = 0;
+  for (let j = 0; j < S.n; j++) {
+    let d = 0;
+    for (let k = S.jc[j]; k < S.jc[j + 1]; k++)
+      if (S.ir[k] === j) {
+        d = Math.abs(S.pr[k]);
+        break;
+      }
+    if (d < lo) lo = d;
+    if (d > hi) hi = d;
+  }
+  if (S.n === 0) return 1;
+  return hi === 0 ? 0 : lo / hi;
+}
+function denseLuFactors(data, n) {
+  const bridge = getEffectiveBridge("lu", "lu");
+  if (!bridge?.lu) throw new RuntimeError("decomposition: LU unavailable");
+  const { LU, ipiv } = bridge.lu(toF64(data), n, n);
+  const perm = new Int32Array(n);
+  for (let i = 0; i < n; i++) perm[i] = i;
+  for (let i = 0; i < ipiv.length; i++) {
+    const j = ipiv[i] - 1;
+    if (j !== i) {
+      const t = perm[i];
+      perm[i] = perm[j];
+      perm[j] = t;
+    }
+  }
+  const L = allocFloat64Array(n * n);
+  const U = allocFloat64Array(n * n);
+  let singular = false;
+  for (let j = 0; j < n; j++) {
+    L[j + j * n] = 1;
+    for (let i = j + 1; i < n; i++) L[i + j * n] = LU[i + j * n];
+    for (let i = 0; i <= j; i++) U[i + j * n] = LU[i + j * n];
+    if (U[j + j * n] === 0) singular = true;
+  }
+  return {
+    L: denseDataToSparse(L, n, n),
+    U: denseDataToSparse(U, n, n),
+    p: perm,
+    q: identityPerm(n),
+    singular
+  };
+}
+function denseCholLower(data, n) {
+  const bridge = getEffectiveBridge("chol", "chol");
+  if (!bridge?.chol) throw new RuntimeError("decomposition: chol unavailable");
+  const { R, info } = bridge.chol(toF64(data), n, false);
+  if (info > 0) return null;
+  return denseDataToSparse(R, n, n);
+}
+function denseIsTriangular(data, n, upper) {
+  for (let j = 0; j < n; j++)
+    for (let i = 0; i < n; i++) {
+      if (upper ? i <= j : i >= j) continue;
+      if (data[i + j * n] !== 0) return false;
+    }
+  return true;
+}
+registerIBuiltin({
+  name: "decomposition",
+  help: {
+    signatures: [
+      "dA = decomposition(A)",
+      "dA = decomposition(A, type)",
+      "dA = decomposition(A, 'triangular', 'upper' | 'lower')",
+      "x = dA \\ b",
+      "x = b / dA"
+    ],
+    description: "Factor a square matrix once and reuse the factors: dA \\ b and b / dA solve with the stored factorization. type is 'auto' (default), 'chol', 'lu', or 'triangular'; other MATLAB types fall back to LU. Sparse matrices use the sparse Cholesky / LU with a fill-reducing ordering. Properties: MatrixSize, Type, Datatype, IsReal, IsConjugateTransposed, ScaleFactor, CheckCondition."
+  },
+  resolve: (argTypes, nargout) => {
+    if (argTypes.length < 1 || nargout > 1) return null;
+    return {
+      outputTypes: [{ kind: "unknown" }],
+      apply: (args) => buildDecomposition(args)
+    };
+  }
+});
+function buildDecomposition(args) {
+  const A = args[0];
+  let type = "auto";
+  let triangle = null;
+  let checkCondition = true;
+  let luTol = 1;
+  let i = 1;
+  const isStr = (v) => isRuntimeChar(v) || isRuntimeString(v);
+  while (i < args.length) {
+    const a = args[i];
+    if (!isStr(a))
+      throw new RuntimeError("decomposition: options must be strings");
+    const s = parseStringArgLower(a);
+    if (s === "upper" || s === "lower") {
+      triangle = s;
+      i++;
+      continue;
+    }
+    if (s === "checkcondition" || s === "ranktolerance" || s === "banddensity" || s === "ldlpivottolerance" || s === "lupivottolerance") {
+      if (i + 1 >= args.length)
+        throw new RuntimeError(`decomposition: missing value for '${s}'`);
+      const v = args[i + 1];
+      if (s === "checkcondition") checkCondition = toNumber(v) !== 0;
+      if (s === "lupivottolerance") luTol = toNumber(v);
+      i += 2;
+      continue;
+    }
+    if (i === 1) {
+      type = s;
+      i++;
+      continue;
+    }
+    throw new RuntimeError(`decomposition: unknown option '${s}'`);
+  }
+  const known = [
+    "auto",
+    "chol",
+    "lu",
+    "triangular",
+    "ldl",
+    "qr",
+    "banded",
+    "diagonal",
+    "permutedtriangular",
+    "hessenberg",
+    "cod"
+  ];
+  if (!known.includes(type))
+    throw new RuntimeError(
+      `decomposition: unknown decomposition type '${type}'`
+    );
+  let S = null;
+  let dense = null;
+  let n;
+  if (isRuntimeSparseMatrix(A)) {
+    if (A.pi)
+      throw new RuntimeError(
+        "decomposition: complex matrices are not supported"
+      );
+    if (A.m !== A.n)
+      throw new RuntimeError(
+        "decomposition: only square matrices are supported"
+      );
+    S = A;
+    n = A.n;
+  } else if (isRuntimeTensor(A) || isRuntimeNumber(A)) {
+    const t = isRuntimeNumber(A) ? RTV.tensor(allocFloat64Array([A]), [1, 1]) : A;
+    if (t.imag)
+      throw new RuntimeError(
+        "decomposition: complex matrices are not supported"
+      );
+    const [m, nn] = tensorSize2D(t);
+    if (m !== nn)
+      throw new RuntimeError(
+        "decomposition: only square matrices are supported"
+      );
+    n = nn;
+    dense = t.data;
+  } else {
+    throw new RuntimeError("decomposition: A must be a numeric matrix");
+  }
+  const fields = /* @__PURE__ */ new Map();
+  const setCommon = (typeName, rc) => {
+    fields.set("MatrixSize", RTV.tensor(allocFloat64Array([n, n]), [1, 2]));
+    fields.set("Type", RTV.char(typeName));
+    fields.set("Datatype", RTV.char("double"));
+    fields.set("IsReal", RTV.logical(true));
+    fields.set("IsConjugateTransposed", RTV.logical(false));
+    fields.set("ScaleFactor", RTV.num(1));
+    fields.set("CheckCondition", RTV.logical(checkCondition));
+    fields.set("_rcond", RTV.num(rc));
+  };
+  const storeTriangular = (T, upper) => {
+    fields.set("_kind", RTV.char("triangular"));
+    fields.set("_T", T);
+    fields.set("_upper", RTV.logical(upper));
+    setCommon("triangular", diagRatio(T));
+  };
+  const storeChol = (L, p2) => {
+    fields.set("_kind", RTV.char("chol"));
+    fields.set("_L", L);
+    fields.set("_Lt", sparseTranspose(L));
+    fields.set("_p", permVectorTensor(p2));
+    setCommon("chol", diagRatio(L) ** 2);
+  };
+  const storeLu = (lu3) => {
+    fields.set("_kind", RTV.char("lu"));
+    fields.set("_L", lu3.L);
+    fields.set("_U", lu3.U);
+    fields.set("_p", permVectorTensor(lu3.p));
+    fields.set("_q", permVectorTensor(lu3.q));
+    setCommon(type === "auto" || type === "lu" ? "lu" : type, diagRatio(lu3.U));
+  };
+  const upperOk = S ? sparseIsUpper(S) : denseIsTriangular(dense, n, true);
+  const lowerOk = S ? sparseIsLower(S) : denseIsTriangular(dense, n, false);
+  if (type === "triangular" || type === "auto" && (upperOk || lowerOk)) {
+    let upper;
+    if (triangle) upper = triangle === "upper";
+    else if (upperOk) upper = true;
+    else if (lowerOk) upper = false;
+    else throw new RuntimeError("decomposition: matrix is not triangular");
+    const T = S ?? denseDataToSparse(dense, n, n);
+    storeTriangular(T, upper);
+    return new RuntimeClassInstance(DEC_CLASS, fields, false);
+  }
+  const symmetric = S !== null && sparseIsSymmetric(S);
+  if (type === "chol" || type === "auto" && symmetric) {
+    if (S) {
+      const perm = minimumDegreeOrdering(S);
+      const res = sparseChol(sparsePermute(S, perm, perm));
+      if (res.ok) {
+        storeChol(res.L, perm);
+        return new RuntimeClassInstance(DEC_CLASS, fields, false);
+      }
+    } else {
+      const L = denseCholLower(dense, n);
+      if (L) {
+        storeChol(L, identityPerm(n));
+        return new RuntimeClassInstance(DEC_CLASS, fields, false);
+      }
+    }
+    if (type === "chol")
+      throw new RuntimeError(
+        "Cholesky decomposition requires the input matrix to be positive definite."
+      );
+  }
+  const lu2 = S ? sparseLu(S, columnOrdering(S), luTol) : denseLuFactors(dense, n);
+  if (lu2.singular) emitWarning(SINGULAR_WARNING);
+  storeLu(lu2);
+  return new RuntimeClassInstance(DEC_CLASS, fields, false);
+}
+function decompositionRcond(d) {
+  const rc = d.fields.get("_rcond");
+  return typeof rc === "number" ? rc : 1;
+}
+registerIBuiltin({
+  name: "isIllConditioned",
+  help: {
+    signatures: ["tf = isIllConditioned(dA)"],
+    description: "True if the matrix stored in a decomposition object is ill conditioned (reciprocal condition estimate below eps)."
+  },
+  resolve: (argTypes, nargout) => {
+    if (argTypes.length !== 1 || nargout > 1) return null;
+    return {
+      outputTypes: [{ kind: "boolean" }],
+      apply: (args) => {
+        if (!isDecomposition(args[0]))
+          throw new RuntimeError(
+            "isIllConditioned: argument must be a decomposition object"
+          );
+        return RTV.logical(decompositionRcond(args[0]) < Number.EPSILON);
+      }
+    };
+  }
+});
+function decompositionSolve(d, B, n, nrhs, transposed) {
+  if (d.fields.get("CheckCondition") === true) {
+    const rc = decompositionRcond(d);
+    if (rc < Number.EPSILON)
+      emitWarning(
+        `Matrix is close to singular or badly scaled. Results may be inaccurate. RCOND =  ${rc.toExponential(6)}.`
+      );
+  }
+  const kind = charField(d, "_kind");
+  if (kind === "triangular") {
+    let T = sparseField(d, "_T");
+    let upper = d.fields.get("_upper") === true;
+    if (transposed) {
+      T = sparseTranspose(T);
+      upper = !upper;
+    }
+    const r = upper ? sparseSolveUpper(T, B, nrhs) : sparseSolveLower(T, B, nrhs);
+    if (r.singular) emitWarning(SINGULAR_WARNING);
+    return r.x;
+  }
+  if (kind === "chol") {
+    const L = sparseField(d, "_L");
+    const p2 = permFromField(d, "_p");
+    const bp = allocFloat64Array(B.length);
+    for (let c = 0; c < nrhs; c++)
+      for (let k = 0; k < n; k++) bp[c * n + k] = B[c * n + p2[k]];
+    const y = sparseSolveLower(L, bp, nrhs).x;
+    const z = sparseSolveUpper(sparseField(d, "_Lt"), y, nrhs).x;
+    const x = allocFloat64Array(B.length);
+    for (let c = 0; c < nrhs; c++)
+      for (let k = 0; k < n; k++) x[c * n + p2[k]] = z[c * n + k];
+    return x;
+  }
+  const lu2 = {
+    L: sparseField(d, "_L"),
+    U: sparseField(d, "_U"),
+    p: permFromField(d, "_p"),
+    q: permFromField(d, "_q"),
+    singular: false
+  };
+  return transposed ? luSolveTransposed(lu2, B, nrhs) : luSolve(lu2, B, nrhs);
+}
+function rhsData(v) {
+  if (isRuntimeSparseMatrix(v)) {
+    if (v.pi)
+      throw new RuntimeError(
+        "decomposition: complex operands are not supported"
+      );
+    return { data: sparseToDense(v).data, m: v.m, n: v.n };
+  }
+  if (isRuntimeTensor(v)) {
+    if (v.imag)
+      throw new RuntimeError(
+        "decomposition: complex operands are not supported"
+      );
+    const [m, n] = tensorSize2D(v);
+    return { data: v.data, m, n };
+  }
+  if (isRuntimeNumber(v) || isRuntimeLogical(v))
+    return { data: allocFloat64Array([toNumber(v)]), m: 1, n: 1 };
+  throw new RuntimeError("decomposition: operand must be numeric");
+}
+function tryDecompositionDivide(name, a, b) {
+  if (name === "mldivide") {
+    if (!isDecomposition(a)) {
+      if (isDecomposition(b))
+        throw new RuntimeError(
+          "decomposition: a decomposition object can only be the left operand of \\"
+        );
+      return void 0;
+    }
+    const n2 = toNumber(permSize(a));
+    const rhs2 = rhsData(b);
+    if (rhs2.m !== n2)
+      throw new RuntimeError(
+        `mldivide (\\): A is ${n2}\xD7${n2} but B has ${rhs2.m} rows`
+      );
+    const x2 = decompositionSolve(a, rhs2.data, n2, rhs2.n, false);
+    return RTV.tensor(x2, [n2, rhs2.n]);
+  }
+  if (!isDecomposition(b)) {
+    if (isDecomposition(a))
+      throw new RuntimeError(
+        "decomposition: a decomposition object can only be the right operand of /"
+      );
+    return void 0;
+  }
+  const n = toNumber(permSize(b));
+  const rhs = rhsData(a);
+  if (rhs.n !== n)
+    throw new RuntimeError(
+      `mrdivide (/): A is ${n}\xD7${n} but B has ${rhs.n} columns`
+    );
+  const nrhs = rhs.m;
+  const Bt = allocFloat64Array(n * nrhs);
+  for (let c = 0; c < nrhs; c++)
+    for (let k = 0; k < n; k++) Bt[c * n + k] = rhs.data[c + k * nrhs];
+  const xt = decompositionSolve(b, Bt, n, nrhs, true);
+  const x = allocFloat64Array(n * nrhs);
+  for (let c = 0; c < nrhs; c++)
+    for (let k = 0; k < n; k++) x[c + k * nrhs] = xt[c * n + k];
+  return RTV.tensor(x, [nrhs, n]);
+}
+function permSize(d) {
+  const ms = d.fields.get("MatrixSize");
+  if (ms === void 0 || !isRuntimeTensor(ms))
+    throw new RuntimeError("decomposition: corrupt");
+  return ms.data[0];
+}
+
 // src/numbl-core/interpreter/builtins/graph.ts
 function isGraph(v) {
   return isRuntimeClassInstance(v) && v.className === "graph";
@@ -51660,6 +54935,10 @@ for (const [name, op] of opMap) {
         apply: (args) => {
           const dt = tryDatetimeDurationBinop(name, args[0], args[1]);
           if (dt !== void 0) return dt;
+          if (name === "mldivide" || name === "mrdivide") {
+            const dec = tryDecompositionDivide(name, args[0], args[1]);
+            if (dec !== void 0) return dec;
+          }
           return op(args[0], args[1]);
         }
       };
@@ -53524,7 +56803,7 @@ var H = {
   },
   inv: {
     signatures: ["B = inv(A)"],
-    description: "Matrix inverse."
+    description: "Matrix inverse. A sparse A gives a sparse B (computed by sparse LU); prefer A \\ b for solving systems."
   },
   expm: {
     signatures: ["Y = expm(X)"],
@@ -53535,8 +56814,15 @@ var H = {
     description: "Sum of diagonal elements."
   },
   eig: {
-    signatures: ["E = eig(A)", "[V, D] = eig(A)", "[V, D, W] = eig(A)"],
-    description: "Eigenvalues and eigenvectors of square matrix. With three outputs, W contains left eigenvectors."
+    signatures: [
+      "E = eig(A)",
+      "[V, D] = eig(A)",
+      "[V, D, W] = eig(A)",
+      "E = eig(A, B)",
+      "[V, D] = eig(A, B)",
+      "eig(A, ..., 'vector' | 'matrix' | 'nobalance' | 'chol' | 'qz')"
+    ],
+    description: "Eigenvalues and eigenvectors of a square matrix. With three outputs, W contains left eigenvectors. Symmetric (Hermitian) input gives real eigenvalues in ascending order and an orthonormal eigenvector basis. eig(A, B) solves the generalized problem A*v = lambda*B*v; for a symmetric-definite pencil V is normalized so that V'*B*V = I."
   },
   eigs: {
     signatures: [
@@ -53559,8 +56845,15 @@ var H = {
     description: "Singular value decomposition."
   },
   lu: {
-    signatures: ["Y = lu(A)", "[L, U] = lu(A)", "[L, U, P] = lu(A)"],
-    description: "LU factorization. With 2 outputs, L includes the permutation. With 3, P is a permutation matrix."
+    signatures: [
+      "Y = lu(A)",
+      "[L, U] = lu(A)",
+      "[L, U, P] = lu(A)",
+      "[L, U, P] = lu(A, 'vector')",
+      "[L, U, P, Q] = lu(S)",
+      "[L, U, P, Q] = lu(S, thresh)"
+    ],
+    description: "LU factorization. With 2 outputs, L includes the permutation. With 3, P is a permutation matrix (or a row vector with 'vector'). Sparse S returns sparse factors from a left-looking LU with threshold partial pivoting; with 4 outputs, Q is a fill-reducing column permutation and P*S*Q = L*U."
   },
   qr: {
     signatures: [
@@ -53572,8 +56865,14 @@ var H = {
     description: "QR factorization. With 3 outputs, E is a column permutation matrix (or vector in economy mode)."
   },
   chol: {
-    signatures: ["R = chol(A)", "[R, P] = chol(A)"],
-    description: "Cholesky factorization. A must be symmetric positive definite. With 2 outputs, P is 0 on success."
+    signatures: [
+      "R = chol(A)",
+      "L = chol(A, 'lower')",
+      "[R, p] = chol(A)",
+      "[R, p, P] = chol(S)",
+      "[R, p, q] = chol(S, 'vector')"
+    ],
+    description: "Cholesky factorization with R'*R = A, reading only the upper triangle. A must be symmetric positive definite; with 2 outputs, p is 0 on success and otherwise the failing column (no error). Sparse S returns a sparse factor; with 3 outputs, P is a fill-reducing permutation with R'*R = P'*S*P."
   },
   rank: {
     signatures: ["K = rank(A)", "K = rank(A, TOL)"],
@@ -53601,7 +56900,7 @@ var H = {
   },
   kron: {
     signatures: ["K = kron(A, B)"],
-    description: "Kronecker tensor product."
+    description: "Kronecker tensor product. If either operand is sparse, K is sparse with nnz(A)*nnz(B) entries."
   },
   linsolve: {
     signatures: ["X = linsolve(A, B)"],
@@ -62560,6 +65859,7 @@ var Runtime = class _Runtime {
     if (options.cancelSAB) {
       this.cancelFlag = new Int32Array(options.cancelSAB);
     }
+    setWarningSink((msg) => this.output("Warning: " + msg + "\n"));
     this.initBuiltins();
   }
   outputLines = [];
@@ -65210,9 +68510,9 @@ function analyzeLoop(stmt) {
   };
 }
 function collectReadsFromSiblings(stmts, startIdx, out) {
-  const sink = /* @__PURE__ */ new Set();
+  const sink2 = /* @__PURE__ */ new Set();
   for (let i = startIdx; i < stmts.length; i++) {
-    walkStmt2(stmts[i], sink, out);
+    walkStmt2(stmts[i], sink2, out);
   }
 }
 function walkStmts(stmts, assigned, referenced) {
@@ -70091,14 +73391,6 @@ end
     name: "+matlab/+internal/+math/blkdiag.m",
     source: "function B = blkdiag(varargin)\n    B = builtin('blkdiag', varargin{:});\nend\n"
   },
-  {
-    name: "decomposition.m",
-    source: "classdef decomposition\n    properties\n        A\n        checkCondition\n        isIllCond\n    end\n    methods\n        function obj = decomposition(A, varargin)\n            obj.A = A;\n            obj.checkCondition = true;\n            for i = 1:2:length(varargin)\n                if strcmpi(varargin{i}, 'CheckCondition')\n                    obj.checkCondition = varargin{i+1};\n                end\n            end\n            if obj.checkCondition\n                obj.isIllCond = (rcond(A) < eps);\n            else\n                obj.isIllCond = false;\n            end\n        end\n        function x = mldivide(obj, b)\n            x = obj.A \\ b;\n        end\n    end\nend\n"
-  },
-  {
-    name: "isIllConditioned.m",
-    source: "function result = isIllConditioned(dA)\n    result = dA.isIllCond;\nend\n"
-  },
   {
     name: "uihtml.m",
     source: "classdef uihtml < handle\n    %UIHTML Create an HTML UI component (numbl subset).\n    %   H = UIHTML('HTMLSource', HTML) renders the self-contained HTML string\n    %   HTML in the figure pane. An optional leading parent argument (e.g. a\n    %   figure) is accepted and ignored. Supported name-value options:\n    %   HTMLSource, Data, Position.\n    %\n    %   H = UIHTML('HTMLSource', HTML, 'Data', X) also sends X into the page.\n    %   Mirroring MATLAB, X is encoded with jsonencode, parsed in the page with\n    %   JSON.parse, and set on the JavaScript `htmlComponent.Data` object,\n    %   firing any \"DataChanged\" listener registered in the page's\n    %   `function setup(htmlComponent)`. To update the data after construction,\n    %   set H.Data and call show(H) (numbl re-renders the component):\n    %\n    %       h = uihtml('HTMLSource', html, 'Data', struct('n', 1));\n    %       h.Data = struct('n', 2);\n    %       show(h);\n    %\n    %   numbl currently supports HTMLSource given as an HTML markup string (a\n    %   single self-contained document). HTML file paths and supporting files\n    %   are not yet supported.\n    %\n    %   The reverse channel (page -> MATLAB) is supported for the IDE:\n    %   HTMLEventReceivedFcn fires when JS calls\n    %   htmlComponent.sendEventToMATLAB(name,data); inside the callback use\n    %   sendEventToHTMLSource(src,name,data) to send back to the page.\n    %   DataChangedFcn fires when JS sets htmlComponent.Data. Register callbacks\n    %   at construction (name-value) since numbl renders at construction.\n    properties\n        HTMLSource = ''\n        Data = []\n        Position = [100 100 100 100]\n        HTMLEventReceivedFcn = []\n        DataChangedFcn = []\n    end\n    methods\n        function obj = uihtml(varargin)\n            args = varargin;\n            % Ignore an optional leading parent argument (anything that is not\n            % a name-value name string).\n            if numel(args) >= 1 && ~(ischar(args{1}) || isstring(args{1}))\n                args = args(2:end);\n            end\n            for i = 1:2:numel(args) - 1\n                name = args{i};\n                val = args{i + 1};\n                if strcmpi(name, 'HTMLSource')\n                    obj.HTMLSource = val;\n                elseif strcmpi(name, 'Data')\n                    obj.Data = val;\n                elseif strcmpi(name, 'Position')\n                    obj.Position = val;\n                elseif strcmpi(name, 'HTMLEventReceivedFcn')\n                    obj.HTMLEventReceivedFcn = val;\n                elseif strcmpi(name, 'DataChangedFcn')\n                    obj.DataChangedFcn = val;\n                end\n            end\n            render(obj);\n        end\n\n        function show(obj)\n            render(obj);\n        end\n\n        function render(obj)\n            if isempty(obj.HTMLSource)\n                return;\n            end\n            if isempty(obj.Data)\n                id = drawuihtml(obj.HTMLSource);\n            else\n                id = drawuihtml(obj.HTMLSource, jsonencode(obj.Data));\n            end\n            if ~isempty(obj.HTMLEventReceivedFcn)\n                registeruihtmlcallback(id, 'HTMLEventReceived', ...\n                                       obj.HTMLEventReceivedFcn);\n            end\n            if ~isempty(obj.DataChangedFcn)\n                registeruihtmlcallback(id, 'DataChanged', obj.DataChangedFcn);\n            end\n        end\n    end\nend\n"
@@ -79316,7 +82608,7 @@ function cCos(z) {
     im: -Math.sin(z.re) * Math.sinh(z.im)
   };
 }
-function cdiv2(a, b) {
+function cdiv3(a, b) {
   if (Math.abs(b.re) >= Math.abs(b.im)) {
     const r2 = b.im / b.re;
     const den2 = b.re + r2 * b.im;
@@ -79327,7 +82619,7 @@ function cdiv2(a, b) {
   return { re: (a.re * r + a.im) / den, im: (a.im * r - a.re) / den };
 }
 function cTan(z) {
-  return cdiv2(cSin(z), cCos(z));
+  return cdiv3(cSin(z), cCos(z));
 }
 function cSinh(z) {
   return {
@@ -79349,7 +82641,7 @@ function cAtan(z) {
   const iz = { re: -z.im, im: z.re };
   const num = { re: 1 - iz.re, im: -iz.im };
   const den = { re: 1 + iz.re, im: iz.im };
-  const q = cdiv2(num, den);
+  const q = cdiv3(num, den);
   const l = cLog(q);
   return { re: -l.im / 2, im: l.re / 2 };
 }