@danielsimonjr/mathts-functions 0.34.0 → 0.35.0

package/dist/index.js

@@ -3402,10 +3402,10 @@ async function fftGpuDispatchImpl(real, imag, inverse, options) {
     staging.unmap();
     const outRe = new Float64Array(n);
     const outIm = new Float64Array(n);
-    const scale = inverse ? 1 / n : 1;
+    const scale3 = inverse ? 1 / n : 1;
     for (let i = 0; i < n; i++) {
-      outRe[i] = packed[i * 2] * scale;
-      outIm[i] = packed[i * 2 + 1] * scale;
+      outRe[i] = packed[i * 2] * scale3;
+      outIm[i] = packed[i * 2 + 1] * scale3;
     }
     return { real: outRe, imag: outIm };
   } catch {
@@ -4290,9 +4290,9 @@ function hilbertTransform(x) {
       try {
         const paddedInput = new Array(N).fill(0);
         for (let i = 0; i < n; i++) paddedInput[i] = x[i];
-        const zeros2 = new Array(N).fill(0);
+        const zeros4 = new Array(N).fill(0);
         const inReAlloc = wasmLoader.allocateFloat64Array(paddedInput);
-        const inImAlloc = wasmLoader.allocateFloat64Array(zeros2);
+        const inImAlloc = wasmLoader.allocateFloat64Array(zeros4);
         const outReAlloc = wasmLoader.allocateFloat64ArrayEmpty(N);
         const outImAlloc = wasmLoader.allocateFloat64ArrayEmpty(N);
         try {
@@ -5511,8 +5511,8 @@ function modNumber(x, y) {
 }
 modNumber.signature = n2;
 function nthRootNumber(a, root2 = 2) {
-  const inv2 = root2 < 0;
-  if (inv2) {
+  const inv3 = root2 < 0;
+  if (inv3) {
     root2 = -root2;
   }
   if (root2 === 0) {
@@ -5522,14 +5522,14 @@ function nthRootNumber(a, root2 = 2) {
     throw new Error("Root must be odd when a is negative.");
   }
   if (a === 0) {
-    return inv2 ? Infinity : 0;
+    return inv3 ? Infinity : 0;
   }
   if (!isFinite(a)) {
-    return inv2 ? 0 : a;
+    return inv3 ? 0 : a;
   }
   let x = Math.pow(Math.abs(a), 1 / root2);
   x = a < 0 ? -x : x;
-  return inv2 ? 1 / x : x;
+  return inv3 ? 1 / x : x;
 }
 function signNumber(x) {
   return sign2(x);
@@ -8256,26 +8256,26 @@ var betaPDF = mathTyped11("betaPDF", {
     return Promise.resolve(out);
   }
 });
-function gammaPDFScalar(x, shape, scale) {
-  if (shape <= 0 || scale <= 0) return NaN;
+function gammaPDFScalar(x, shape, scale3) {
+  if (shape <= 0 || scale3 <= 0) return NaN;
   if (x <= 0) return 0;
   return Math.exp(
-    (shape - 1) * Math.log(x) - x / scale - _lgammaD(shape) - shape * Math.log(scale)
+    (shape - 1) * Math.log(x) - x / scale3 - _lgammaD(shape) - shape * Math.log(scale3)
   );
 }
 var gammaPDF = mathTyped11("gammaPDF", {
-  "number, number, number": (x, shape, scale) => gammaPDFScalar(x, shape, scale),
-  "Float64Array, number, number": (x, shape, scale) => {
+  "number, number, number": (x, shape, scale3) => gammaPDFScalar(x, shape, scale3),
+  "Float64Array, number, number": (x, shape, scale3) => {
     const out = new Float64Array(x.length);
     const lgShape = _lgammaD(shape);
-    const logScale = Math.log(scale);
+    const logScale = Math.log(scale3);
     const logConstant = lgShape + shape * logScale;
     for (let i = 0; i < x.length; i++) {
       const xi = x[i];
       if (xi <= 0) {
         out[i] = 0;
       } else {
-        out[i] = Math.exp((shape - 1) * Math.log(xi) - xi / scale - logConstant);
+        out[i] = Math.exp((shape - 1) * Math.log(xi) - xi / scale3 - logConstant);
       }
     }
     return Promise.resolve(out);
@@ -8381,18 +8381,18 @@ import { computePool as computePool7 } from "@danielsimonjr/mathts-parallel";
 var GEOMETRY_WASM_THRESHOLD = 32;
 var HULL3D_WASM_THRESHOLD = 1024;
 function angle2D(v1, v2) {
-  const dot5 = v1[0] * v2[0] + v1[1] * v2[1];
+  const dot7 = v1[0] * v2[0] + v1[1] * v2[1];
   const mag1 = Math.sqrt(v1[0] ** 2 + v1[1] ** 2);
   const mag2 = Math.sqrt(v2[0] ** 2 + v2[1] ** 2);
   if (mag1 === 0 || mag2 === 0) return NaN;
-  return Math.acos(Math.max(-1, Math.min(1, dot5 / (mag1 * mag2))));
+  return Math.acos(Math.max(-1, Math.min(1, dot7 / (mag1 * mag2))));
 }
 function angle3D(v1, v2) {
-  const dot5 = v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
+  const dot7 = v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
   const mag1 = Math.sqrt(v1[0] ** 2 + v1[1] ** 2 + v1[2] ** 2);
   const mag2 = Math.sqrt(v2[0] ** 2 + v2[1] ** 2 + v2[2] ** 2);
   if (mag1 === 0 || mag2 === 0) return NaN;
-  return Math.acos(Math.max(-1, Math.min(1, dot5 / (mag1 * mag2))));
+  return Math.acos(Math.max(-1, Math.min(1, dot7 / (mag1 * mag2))));
 }
 function cross3D(a, b) {
   return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
@@ -8497,15 +8497,15 @@ function reflectVector(v, normal) {
   const mag = Math.sqrt(normal.reduce((s, c) => s + c * c, 0));
   if (mag === 0) return v.slice();
   const n = normal.map((c) => c / mag);
-  const dot5 = v.reduce((s, c, i) => s + c * n[i], 0);
-  return v.map((c, i) => c - 2 * dot5 * n[i]);
+  const dot7 = v.reduce((s, c, i) => s + c * n[i], 0);
+  return v.map((c, i) => c - 2 * dot7 * n[i]);
 }
 function projectVector(v, onto) {
-  const dot5 = v.reduce((s, c, i) => s + c * onto[i], 0);
+  const dot7 = v.reduce((s, c, i) => s + c * onto[i], 0);
   const magSq = onto.reduce((s, c) => s + c * c, 0);
   if (magSq === 0) return onto.map(() => 0);
-  const scale = dot5 / magSq;
-  return onto.map((c) => c * scale);
+  const scale3 = dot7 / magSq;
+  return onto.map((c) => c * scale3);
 }
 function distance2D(a, b) {
   return Math.sqrt((b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2);
@@ -11487,8 +11487,8 @@ var createSolveODE = /* @__PURE__ */ factory(
   dependencies,
   ({
     typed: typed3,
-    add: add2,
-    subtract: subtract2,
+    add: add3,
+    subtract: subtract3,
     multiply: multiply2,
     divide: divide2,
     max: max2,
@@ -11697,16 +11697,16 @@ var createSolveODE = /* @__PURE__ */ factory(
           const hMag = Math.min(h0, Math.abs(tf - t0));
           h = isForwards ? hMag : -hMag;
         } else {
-          h = divide2(subtract2(tf, t0), steps);
+          h = divide2(subtract3(tf, t0), steps);
         }
         const t = [t0];
         const y = [y0];
-        const deltaB = subtract2(b, bp);
+        const deltaB = subtract3(b, bp);
         function stageCombo(coeffs, stages) {
           const m = Math.min(coeffs.length, stages.length);
           let acc = multiply2(coeffs[0], stages[0]);
           for (let j = 1; j < m; j++) {
-            acc = add2(acc, multiply2(coeffs[j], stages[j]));
+            acc = add3(acc, multiply2(coeffs[j], stages[j]));
           }
           return acc;
         }
@@ -11719,14 +11719,14 @@ var createSolveODE = /* @__PURE__ */ factory(
           h = trimStep(t[n], tf, h);
           k.push(f(t[n], y[n]));
           for (let i = 1; i < c.length; ++i) {
-            k.push(f(add2(t[n], multiply2(c[i], h)), add2(y[n], multiply2(h, stageCombo(a[i], k)))));
+            k.push(f(add3(t[n], multiply2(c[i], h)), add3(y[n], multiply2(h, stageCombo(a[i], k)))));
           }
           const errComb = stageCombo(deltaB, k);
           const errArr = Array.isArray(errComb) ? errComb : [errComb];
           const TE = max2(abs2(map2(errArr, (X) => isUnit(X) ? X.value : X)));
           if (TE < tol && tol / TE > 1 / 4) {
-            t.push(add2(t[n], h));
-            y.push(add2(y[n], multiply2(h, stageCombo(b, k))));
+            t.push(add3(t[n], h));
+            y.push(add3(y[n], multiply2(h, stageCombo(b, k))));
             n++;
           }
           let delta = 0.84 * (tol / TE) ** (1 / 5);
@@ -11807,8 +11807,8 @@ var createSolveODE = /* @__PURE__ */ factory(
     function _createTrimStep(isForwards) {
       const outOfBounds = isForwards ? larger2 : smaller2;
       return function(t, tf, h) {
-        const next = add2(t, h);
-        return outOfBounds(next, tf) ? subtract2(tf, t) : h;
+        const next = add3(t, h);
+        return outOfBounds(next, tf) ? subtract3(tf, t) : h;
       };
     }
     function isNumOrBig(x) {
@@ -13096,8 +13096,8 @@ function quadprog(H, f, A, b) {
         let aNorm = 0;
         for (let j = 0; j < n; j++) aNorm += A[c][j] * A[c][j];
         if (aNorm > 1e-15) {
-          const scale = (ax - b[c]) / aNorm;
-          for (let j = 0; j < n; j++) xNew[j] -= scale * A[c][j];
+          const scale3 = (ax - b[c]) / aNorm;
+          for (let j = 0; j < n; j++) xNew[j] -= scale3 * A[c][j];
         }
       }
     }
@@ -14397,9 +14397,9 @@ function _aggregateEigenvector(vectors, aggregation) {
   const count2 = vectors.length;
   const ref = vectors[0];
   const aligned = vectors.map((v) => {
-    let dot5 = 0;
-    for (let i = 0; i < n; i++) dot5 += v[i] * ref[i];
-    if (dot5 < 0) {
+    let dot7 = 0;
+    for (let i = 0; i < n; i++) dot7 += v[i] * ref[i];
+    if (dot7 < 0) {
       const flipped = new Float64Array(n);
       for (let i = 0; i < n; i++) flipped[i] = -v[i];
       return flipped;
@@ -14935,7 +14935,7 @@ function fDist(d1, d2) {
 }
 function gammaDist(shape, rate = 1) {
   if (shape <= 0 || rate <= 0) throw new Error("gammaDist: shape and rate must be positive");
-  const scale = 1 / rate;
+  const scale3 = 1 / rate;
   return {
     pdf: (x) => {
       if (x < 0) return 0;
@@ -14956,7 +14956,7 @@ function gammaDist(shape, rate = 1) {
       if (p <= 0) return 0;
       if (p >= 1) return Infinity;
       let lo = 0;
-      let hi = shape * scale * 20;
+      let hi = shape * scale3 * 20;
       while (_gammainc(shape, hi * rate) < p) hi *= 2;
       for (let i = 0; i < 100; i++) {
         const mid = (lo + hi) / 2;
@@ -14966,13 +14966,13 @@ function gammaDist(shape, rate = 1) {
       }
       return (lo + hi) / 2;
     },
-    mean: shape * scale,
-    variance: shape * scale * scale,
-    sample: () => _gammaRandom(shape) * scale,
-    sampleN: (n, opts) => _sampleNDispatch("gamma", [shape, scale], n, opts, (count2, rng) => {
+    mean: shape * scale3,
+    variance: shape * scale3 * scale3,
+    sample: () => _gammaRandom(shape) * scale3,
+    sampleN: (n, opts) => _sampleNDispatch("gamma", [shape, scale3], n, opts, (count2, rng) => {
       const out = new Float64Array(count2);
       for (let i = 0; i < count2; i++) {
-        out[i] = _gammaRandomRng(shape, rng) * scale;
+        out[i] = _gammaRandomRng(shape, rng) * scale3;
       }
       return out;
     })
@@ -16298,9 +16298,9 @@ function principalComponentAnalysis(data, k) {
   const explained = eigenvalues.map((ev) => totalVar > 0 ? Math.abs(ev) / totalVar : 0);
   const scores = centered.map((row2) => {
     return eigenvectors.map((ev) => {
-      let dot5 = 0;
-      for (let j = 0; j < p; j++) dot5 += row2[j] * ev[j];
-      return dot5;
+      let dot7 = 0;
+      for (let j = 0; j < p; j++) dot7 += row2[j] * ev[j];
+      return dot7;
     });
   });
   return { components: eigenvectors, explained, scores };
@@ -16702,9 +16702,9 @@ function mahalanobis(u, v, cov2) {
   if (u.length !== v.length || cov2.length !== u.length) {
     throw new Error("mahalanobis: u, v, and cov dimensions must match");
   }
-  const inv2 = _matInverse(cov2);
+  const inv3 = _matInverse(cov2);
   const d = u.map((ui, i) => ui - v[i]);
-  return Math.sqrt(_quadForm(d, inv2));
+  return Math.sqrt(_quadForm(d, inv3));
 }
 function hotellingT2(data, mu0) {
   const n = data.length;
@@ -16847,9 +16847,9 @@ function rowReduce(A, tol = 1e-10) {
     if (maxRow !== pivotRow) {
       [M[pivotRow], M[maxRow]] = [M[maxRow], M[pivotRow]];
     }
-    const scale = M[pivotRow][col];
+    const scale3 = M[pivotRow][col];
     for (let j = col; j < n; j++) {
-      M[pivotRow][j] /= scale;
+      M[pivotRow][j] /= scale3;
     }
     for (let row2 = 0; row2 < m; row2++) {
       if (row2 === pivotRow) continue;
@@ -16935,30 +16935,30 @@ function hessenbergForm(A) {
     if (normV < 1e-30) continue;
     const beta2 = 2 / normV;
     for (let j = k; j < n; j++) {
-      let dot5 = 0;
+      let dot7 = 0;
       for (let i = 0; i < len; i++) {
-        dot5 += v[i] * H[k + 1 + i][j];
+        dot7 += v[i] * H[k + 1 + i][j];
       }
       for (let i = 0; i < len; i++) {
-        H[k + 1 + i][j] -= beta2 * v[i] * dot5;
+        H[k + 1 + i][j] -= beta2 * v[i] * dot7;
       }
     }
     for (let i = 0; i < n; i++) {
-      let dot5 = 0;
+      let dot7 = 0;
       for (let j = 0; j < len; j++) {
-        dot5 += H[i][k + 1 + j] * v[j];
+        dot7 += H[i][k + 1 + j] * v[j];
       }
       for (let j = 0; j < len; j++) {
-        H[i][k + 1 + j] -= beta2 * dot5 * v[j];
+        H[i][k + 1 + j] -= beta2 * dot7 * v[j];
       }
     }
     for (let i = 0; i < n; i++) {
-      let dot5 = 0;
+      let dot7 = 0;
       for (let j = 0; j < len; j++) {
-        dot5 += Q2[i][k + 1 + j] * v[j];
+        dot7 += Q2[i][k + 1 + j] * v[j];
       }
       for (let j = 0; j < len; j++) {
-        Q2[i][k + 1 + j] -= beta2 * dot5 * v[j];
+        Q2[i][k + 1 + j] -= beta2 * dot7 * v[j];
       }
     }
   }
@@ -16978,9 +16978,9 @@ async function matrixPower(A, p) {
     return matPowBySquaring(A, p);
   }
   if (isInt && p < 0) {
-    const inv2 = matrixInverse(A);
-    if (p === -1) return inv2;
-    return matPowBySquaring(inv2, -p);
+    const inv3 = matrixInverse(A);
+    if (p === -1) return inv3;
+    return matPowBySquaring(inv3, -p);
   }
   return matPowFractional(A, p);
 }
@@ -17017,8 +17017,8 @@ function matrixInverse(A) {
     }
     if (maxVal < 1e-15) throw new Error("matrixPower: singular matrix cannot be inverted");
     if (maxRow !== col) [M[col], M[maxRow]] = [M[maxRow], M[col]];
-    const scale = M[col][col];
-    for (let j = 0; j < 2 * n; j++) M[col][j] /= scale;
+    const scale3 = M[col][col];
+    for (let j = 0; j < 2 * n; j++) M[col][j] /= scale3;
     for (let row2 = 0; row2 < n; row2++) {
       if (row2 === col) continue;
       const factor2 = M[row2][col];
@@ -17092,10 +17092,10 @@ async function matLogScalingSquaring(A) {
       }
     }
   }
-  const scale = Math.pow(2, numSquares);
+  const scale3 = Math.pow(2, numSquares);
   for (let i = 0; i < n; i++) {
     for (let j = 0; j < n; j++) {
-      logM[i][j] *= scale;
+      logM[i][j] *= scale3;
     }
   }
   return logM;
@@ -17358,9 +17358,9 @@ async function solveApprox(A, b, n) {
       }
     }
     if (maxRow !== col) [M[col], M[maxRow]] = [M[maxRow], M[col]];
-    const scale = M[col][col];
-    if (Math.abs(scale) < 1e-30) continue;
-    for (let j = 0; j <= n; j++) M[col][j] /= scale;
+    const scale3 = M[col][col];
+    if (Math.abs(scale3) < 1e-30) continue;
+    for (let j = 0; j <= n; j++) M[col][j] /= scale3;
     for (let row2 = 0; row2 < n; row2++) {
       if (row2 === col) continue;
       const factor2 = M[row2][col];
@@ -22171,41 +22171,41 @@ var createDot = /* @__PURE__ */ factory(
       const bdt = isMatrix(b) ? b._datatype || b.getDataType() : void 0;
       const aIsColumn = _size(a).length === 2;
       const bIsColumn = _size(b).length === 2;
-      let add2 = addScalar2;
+      let add3 = addScalar2;
       let mul = multiplyScalar2;
       if (adt && bdt && adt === bdt && typeof adt === "string" && adt !== "mixed") {
         const dt = adt;
-        add2 = typed3.find(addScalar2, [dt, dt]);
+        add3 = typed3.find(addScalar2, [dt, dt]);
         mul = typed3.find(multiplyScalar2, [dt, dt]);
       }
-      if (!aIsColumn && !bIsColumn && add2 === addScalar2 && mul === multiplyScalar2 && _isFlatNumbers(adata) && _isFlatNumbers(bdata)) {
+      if (!aIsColumn && !bIsColumn && add3 === addScalar2 && mul === multiplyScalar2 && _isFlatNumbers(adata) && _isFlatNumbers(bdata)) {
         return pairwiseDot2(adata, bdata);
       }
       if (!aIsColumn && !bIsColumn) {
         let c = mul(conj3(adata[0]), bdata[0]);
         for (let i = 1; i < N; i++) {
-          c = add2(c, mul(conj3(adata[i]), bdata[i]));
+          c = add3(c, mul(conj3(adata[i]), bdata[i]));
         }
         return c;
       }
       if (!aIsColumn && bIsColumn) {
         let c = mul(conj3(adata[0]), bdata[0][0]);
         for (let i = 1; i < N; i++) {
-          c = add2(c, mul(conj3(adata[i]), bdata[i][0]));
+          c = add3(c, mul(conj3(adata[i]), bdata[i][0]));
         }
         return c;
       }
       if (aIsColumn && !bIsColumn) {
         let c = mul(conj3(adata[0][0]), bdata[0]);
         for (let i = 1; i < N; i++) {
-          c = add2(c, mul(conj3(adata[i][0]), bdata[i]));
+          c = add3(c, mul(conj3(adata[i][0]), bdata[i]));
         }
         return c;
       }
       {
         let c = mul(conj3(adata[0][0]), bdata[0][0]);
         for (let i = 1; i < N; i++) {
-          c = add2(c, mul(conj3(adata[i][0]), bdata[i][0]));
+          c = add3(c, mul(conj3(adata[i][0]), bdata[i][0]));
         }
         return c;
       }
@@ -22217,7 +22217,7 @@ var createDot = /* @__PURE__ */ factory(
       const yindex = y._index;
       const yvalues = y._values;
       let c = 0;
-      const add2 = addScalar2;
+      const add3 = addScalar2;
       const mul = multiplyScalar2;
       let i = 0;
       let j = 0;
@@ -22233,7 +22233,7 @@ var createDot = /* @__PURE__ */ factory(
           continue;
         }
         if (I2 === J) {
-          c = add2(c, mul(xvalues[i], yvalues[j]));
+          c = add3(c, mul(xvalues[i], yvalues[j]));
           i++;
           j++;
         }
@@ -22750,10 +22750,10 @@ var dependencies85 = ["typed", "transpose", "conj"];
 var createCtranspose = /* @__PURE__ */ factory(
   name85,
   dependencies85,
-  ({ typed: typed3, transpose: transpose4, conj: conj3 }) => {
+  ({ typed: typed3, transpose: transpose5, conj: conj3 }) => {
     return typed3(name85, {
       any: function(x) {
-        return conj3(transpose4(x));
+        return conj3(transpose5(x));
       }
     });
   }
@@ -23325,7 +23325,7 @@ var dependencies95 = ["typed", "matrix", "add"];
 var createTrace = /* @__PURE__ */ factory(
   name95,
   dependencies95,
-  ({ typed: typed3, matrix: matrix2, add: add2 }) => {
+  ({ typed: typed3, matrix: matrix2, add: add3 }) => {
     return typed3("trace", {
       Array: function _arrayTrace(x) {
         return _denseTrace(matrix2(x));
@@ -23349,7 +23349,7 @@ var createTrace = /* @__PURE__ */ factory(
           if (rows === cols) {
             let sum3 = 0;
             for (let i = 0; i < rows; i++) {
-              sum3 = add2(sum3, data[i][i]);
+              sum3 = add3(sum3, data[i][i]);
             }
             return sum3;
           } else {
@@ -23376,7 +23376,7 @@ var createTrace = /* @__PURE__ */ factory(
             for (let k = k0; k < k1; k++) {
               const i = index[k];
               if (i === j) {
-                sum3 = add2(sum3, values[k]);
+                sum3 = add3(sum3, values[k]);
                 break;
               }
               if (i > j) {
@@ -23607,7 +23607,7 @@ function acceleratedInv(a, factoryInv2) {
     const Ld = L.toArray();
     const Ud = U.toArray();
     const n = a.length;
-    const inv2 = Array.from({ length: n }, () => new Array(n).fill(0));
+    const inv3 = Array.from({ length: n }, () => new Array(n).fill(0));
     for (let j = 0; j < n; j++) {
       const b = new Array(n).fill(0);
       for (let i = 0; i < n; i++) if (P2[i] === j) b[i] = 1;
@@ -23623,9 +23623,9 @@ function acceleratedInv(a, factoryInv2) {
         for (let k = i + 1; k < n; k++) s -= Ud[i][k] * x[k];
         x[i] = s / Ud[i][i];
       }
-      for (let i = 0; i < n; i++) inv2[i][j] = x[i];
+      for (let i = 0; i < n; i++) inv3[i][j] = x[i];
     }
-    return inv2;
+    return inv3;
   } catch {
     return factoryInv2(a);
   }
@@ -23743,7 +23743,7 @@ var dependencies98 = ["add", "multiply", "transpose"];
 var createCsAmd = /* @__PURE__ */ factory(
   name98,
   dependencies98,
-  ({ add: add2, multiply: multiply2, transpose: transpose4 }) => {
+  ({ add: add3, multiply: multiply2, transpose: transpose5 }) => {
     function _tryWasmAmd(a, n) {
       const wasm = wasmLoader.getModule();
       if (!wasm || !a._ptr || !a._index) return null;
@@ -24037,9 +24037,9 @@ var createCsAmd = /* @__PURE__ */ factory(
       return P2;
     };
     function _createTargetMatrix(order, a, m, n, dense) {
-      const at = transpose4(a);
+      const at = transpose5(a);
       if (order === 1 && n === m) {
-        return add2(a, at);
+        return add3(a, at);
       }
       if (order === 2) {
         const tindex = at._index;
@@ -24056,7 +24056,7 @@ var createCsAmd = /* @__PURE__ */ factory(
           }
         }
         tptr[m] = p2;
-        a = transpose4(at);
+        a = transpose5(at);
         return multiply2(at, a);
       }
       return multiply2(at, a);
@@ -24157,7 +24157,7 @@ var dependencies99 = ["transpose"];
 var createCsCounts = /* @__PURE__ */ factory(
   name99,
   dependencies99,
-  ({ transpose: transpose4 }) => {
+  ({ transpose: transpose5 }) => {
     function _tryWasmCounts(a, parent, post, n) {
       const wasm = wasmLoader.getModule();
       if (!wasm || n < WASM_COUNTS_THRESHOLD || !a._index || !a._ptr) return null;
@@ -24219,7 +24219,7 @@ var createCsCounts = /* @__PURE__ */ factory(
         w[k] = -1;
       }
       const colcount = [];
-      const at = transpose4(a);
+      const at = transpose5(a);
       const tindex = at._index;
       const tptr = at._ptr;
       for (k = 0; k < n; k++) {
@@ -24388,9 +24388,9 @@ var dependencies100 = ["add", "multiply", "transpose"];
 var createCsSqr = /* @__PURE__ */ factory(
   name100,
   dependencies100,
-  ({ add: add2, multiply: multiply2, transpose: transpose4 }) => {
-    const csAmd2 = createCsAmd({ add: add2, multiply: multiply2, transpose: transpose4 });
-    const csCounts2 = createCsCounts({ transpose: transpose4 });
+  ({ add: add3, multiply: multiply2, transpose: transpose5 }) => {
+    const csAmd2 = createCsAmd({ add: add3, multiply: multiply2, transpose: transpose5 });
+    const csCounts2 = createCsCounts({ transpose: transpose5 });
     return function csSqr2(order, a, qr2) {
       const aptr = a._ptr;
       const asize = a._size;
@@ -25647,7 +25647,7 @@ var dependencies111 = [
 var createRound = /* @__PURE__ */ factory(
   name111,
   dependencies111,
-  ({ typed: typed3, config: config2, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, BigNumber: BigNumber9, DenseMatrix: DenseMatrix6 }) => {
+  ({ typed: typed3, config: config2, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros4, BigNumber: BigNumber9, DenseMatrix: DenseMatrix6 }) => {
     const matAlgo11xS0s = createMatAlgo11xS0s({ typed: typed3, equalScalar: equalScalar3 });
     const matAlgo12xSfs = createMatAlgo12xSfs({ typed: typed3, DenseMatrix: DenseMatrix6 });
     const matAlgo14xDs = createMatAlgo14xDs({ typed: typed3 });
@@ -25767,7 +25767,7 @@ var createRound = /* @__PURE__ */ factory(
       "number | Complex | BigNumber | Fraction, SparseMatrix": typed3.referToSelf(
         (self) => (x, n) => {
           if (equalScalar3(x, 0)) {
-            return zeros2(n.size(), n.storage());
+            return zeros4(n.size(), n.storage());
           }
           return matAlgo12xSfs(n, x, self, true);
         }
@@ -25775,7 +25775,7 @@ var createRound = /* @__PURE__ */ factory(
       "number | Complex | BigNumber | Fraction, DenseMatrix": typed3.referToSelf(
         (self) => (x, n) => {
           if (equalScalar3(x, 0)) {
-            return zeros2(n.size(), n.storage());
+            return zeros4(n.size(), n.storage());
           }
           return matAlgo14xDs(n, x, self, true);
         }
@@ -26394,8 +26394,8 @@ var createSubset = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     matrix: matrix2,
-    zeros: zeros2,
-    add: add2
+    zeros: zeros4,
+    add: add3
   }) => {
     const referTo = typed3.referTo;
     return typed3(name119, {
@@ -26454,7 +26454,7 @@ var createSubset = /* @__PURE__ */ factory(
       const indexSize = index.size();
       if (indexSize.every((d) => d > 0)) {
         try {
-          return add2(replacement, zeros2(indexSize));
+          return add3(replacement, zeros4(indexSize));
         } catch {
           return replacement;
         }
@@ -27127,7 +27127,7 @@ var dependencies127 = ["typed", "add", "multiply", "Complex", "number"];
 var createZpk2tf = /* @__PURE__ */ factory(
   name127,
   dependencies127,
-  ({ typed: typed3, add: add2, multiply: multiply2, Complex: Complex13, number: number2 }) => {
+  ({ typed: typed3, add: add3, multiply: multiply2, Complex: Complex13, number: number2 }) => {
     return typed3(name127, {
       "Array,Array,number": function(z, p, k) {
         return _zpk2tf(z, p, k);
@@ -27172,7 +27172,7 @@ var createZpk2tf = /* @__PURE__ */ factory(
         c[i] = Complex13(0, 0);
         for (let j = 0; j < a.length; j++) {
           if (i - j >= 0 && i - j < b.length) {
-            c[i] = add2(c[i], multiply2(a[j], b[i - j]));
+            c[i] = add3(c[i], multiply2(a[j], b[i - j]));
           }
         }
       }
@@ -27196,7 +27196,7 @@ var dependencies128 = ["typed", "add", "unaryPlus"];
 var createCumSum = /* @__PURE__ */ factory(
   name128,
   dependencies128,
-  ({ typed: typed3, add: add2, unaryPlus: unaryPlus2 }) => {
+  ({ typed: typed3, add: add3, unaryPlus: unaryPlus2 }) => {
     return typed3(name128, {
       // sum([a, b, c, d, ...])
       Array: _cumsum,
@@ -27237,7 +27237,7 @@ var createCumSum = /* @__PURE__ */ factory(
       }
       const sums = [unaryPlus2(array[0])];
       for (let i = 1; i < array.length; ++i) {
-        sums.push(add2(sums[i - 1], array[i]));
+        sums.push(add3(sums[i - 1], array[i]));
       }
       return sums;
     }
@@ -27295,7 +27295,7 @@ var dependencies129 = ["typed", "config", "add", "numeric", "parseNumberWithConf
 var createSum = /* @__PURE__ */ factory(
   name129,
   dependencies129,
-  ({ typed: typed3, config: config2, add: add2, numeric: numeric2, parseNumberWithConfig: parseNumberWithConfig2 }) => {
+  ({ typed: typed3, config: config2, add: add3, numeric: numeric2, parseNumberWithConfig: parseNumberWithConfig2 }) => {
     return typed3(name129, {
       // sum(string) - single string input
       string: function(x) {
@@ -27321,7 +27321,7 @@ var createSum = /* @__PURE__ */ factory(
       deepForEach2(array, function(value) {
         try {
           const converted = typeof value === "string" ? parseNumberWithConfig2(value) : value;
-          sum3 = sum3 === void 0 ? converted : add2(sum3, converted);
+          sum3 = sum3 === void 0 ? converted : add3(sum3, converted);
         } catch (err) {
           throw improveErrorMessage(err, "sum", value);
         }
@@ -27334,7 +27334,7 @@ var createSum = /* @__PURE__ */ factory(
     function _nsumDim(array, dim) {
       try {
         const dimValue = typeof dim === "number" ? dim : dim.valueOf();
-        const sum3 = reduce2(array, dimValue, add2);
+        const sum3 = reduce2(array, dimValue, add3);
         return sum3;
       } catch (err) {
         throw improveErrorMessage(err, "sum", void 0);
@@ -27604,7 +27604,7 @@ var createFloorNumber = /* @__PURE__ */ factory(
 var createFloor = /* @__PURE__ */ factory(
   name134,
   dependencies134,
-  ({ typed: typed3, config: config2, round: round2, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, DenseMatrix: DenseMatrix6 }) => {
+  ({ typed: typed3, config: config2, round: round2, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros4, DenseMatrix: DenseMatrix6 }) => {
     const matAlgo11xS0s = createMatAlgo11xS0s({ typed: typed3, equalScalar: equalScalar3 });
     const matAlgo12xSfs = createMatAlgo12xSfs({ typed: typed3, DenseMatrix: DenseMatrix6 });
     const matAlgo14xDs = createMatAlgo14xDs({ typed: typed3 });
@@ -27692,7 +27692,7 @@ var createFloor = /* @__PURE__ */ factory(
       ),
       "number | Complex | Fraction | BigNumber, Matrix": typed3.referToSelf(
         (self) => (x, y) => {
-          if (equalScalar3(x, 0)) return zeros2(y.size(), y.storage());
+          if (equalScalar3(x, 0)) return zeros4(y.size(), y.storage());
           if (y.storage() === "dense") {
             return matAlgo14xDs(y, x, self, true);
           }
@@ -27817,14 +27817,14 @@ var dependencies136 = [
 var createMod = /* @__PURE__ */ factory(
   name136,
   dependencies136,
-  ({ typed: typed3, config: config2, round: round2, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, DenseMatrix: DenseMatrix6, concat: concat3 }) => {
+  ({ typed: typed3, config: config2, round: round2, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros4, DenseMatrix: DenseMatrix6, concat: concat3 }) => {
     const floor2 = createFloor({
       typed: typed3,
       config: config2,
       round: round2,
       matrix: matrix2,
       equalScalar: equalScalar3,
-      zeros: zeros2,
+      zeros: zeros4,
       DenseMatrix: DenseMatrix6
     });
     const matAlgo02xDS0 = createMatAlgo02xDS0({ typed: typed3, equalScalar: equalScalar3 });
@@ -28121,7 +28121,7 @@ var createGcd = /* @__PURE__ */ factory(
     config: config2,
     round: round2,
     equalScalar: equalScalar3,
-    zeros: zeros2,
+    zeros: zeros4,
     BigNumber: BigNumber9,
     DenseMatrix: DenseMatrix6,
     concat: concat3
@@ -28132,7 +28132,7 @@ var createGcd = /* @__PURE__ */ factory(
       round: round2,
       matrix: matrix2,
       equalScalar: equalScalar3,
-      zeros: zeros2,
+      zeros: zeros4,
       DenseMatrix: DenseMatrix6,
       concat: concat3
     });
@@ -28518,8 +28518,8 @@ var createNthRoot = /* @__PURE__ */ factory(
       const Big = BigNumber9.clone({ precision: precision + 2 });
       const zero = new BigNumber9(0);
       const one = new Big(1);
-      const inv2 = root2.isNegative();
-      if (inv2) {
+      const inv3 = root2.isNegative();
+      if (inv3) {
         root2 = root2.neg();
       }
       if (root2.isZero()) {
@@ -28529,14 +28529,14 @@ var createNthRoot = /* @__PURE__ */ factory(
         throw new Error("Root must be odd when a is negative.");
       }
       if (a.isZero()) {
-        return inv2 ? new Big(Infinity) : 0;
+        return inv3 ? new Big(Infinity) : 0;
       }
       if (!a.isFinite()) {
-        return inv2 ? zero : a;
+        return inv3 ? zero : a;
       }
       let x = a.abs().pow(one.div(root2));
       x = a.isNeg() ? x.neg() : x;
-      return new BigNumber9((inv2 ? one.div(x) : x).toPrecision(precision));
+      return new BigNumber9((inv3 ? one.div(x) : x).toPrecision(precision));
     }
   }
 );
@@ -28563,7 +28563,7 @@ var createPow = /* @__PURE__ */ factory(
     identity: identity2,
     multiply: multiply2,
     matrix: matrix2,
-    inv: inv2,
+    inv: inv3,
     number: number2,
     fraction: fraction2,
     Complex: Complex13
@@ -28642,7 +28642,7 @@ var createPow = /* @__PURE__ */ factory(
       }
       if (y < 0) {
         try {
-          return _powArray(inv2(x), -y);
+          return _powArray(inv3(x), -y);
         } catch (error) {
           if (error instanceof Error && error.message === "Cannot calculate inverse, determinant is zero") {
             throw new TypeError(
@@ -28705,7 +28705,7 @@ var createCeilNumber = /* @__PURE__ */ factory(
 var createCeil = /* @__PURE__ */ factory(
   name146,
   dependencies146,
-  ({ typed: typed3, config: config2, round: round2, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, DenseMatrix: DenseMatrix6 }) => {
+  ({ typed: typed3, config: config2, round: round2, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros4, DenseMatrix: DenseMatrix6 }) => {
     const matAlgo11xS0s = createMatAlgo11xS0s({ typed: typed3, equalScalar: equalScalar3 });
     const matAlgo12xSfs = createMatAlgo12xSfs({ typed: typed3, DenseMatrix: DenseMatrix6 });
     const matAlgo14xDs = createMatAlgo14xDs({ typed: typed3 });
@@ -28793,7 +28793,7 @@ var createCeil = /* @__PURE__ */ factory(
       ),
       "number | Complex | Fraction | BigNumber, Matrix": typed3.referToSelf(
         (self) => (x, y) => {
-          if (equalScalar3(x, 0)) return zeros2(y.size(), y.storage());
+          if (equalScalar3(x, 0)) return zeros4(y.size(), y.storage());
           if (y.storage() === "dense") {
             return matAlgo14xDs(y, x, self, true);
           }
@@ -29016,7 +29016,7 @@ var dependencies151 = ["typed", "matrix", "equalScalar", "zeros", "DenseMatrix",
 var createLeftShift = /* @__PURE__ */ factory(
   name151,
   dependencies151,
-  ({ typed: typed3, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, DenseMatrix: DenseMatrix6, concat: concat3 }) => {
+  ({ typed: typed3, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros4, DenseMatrix: DenseMatrix6, concat: concat3 }) => {
     const matAlgo01xDSid = createMatAlgo01xDSid({ typed: typed3 });
     const matAlgo02xDS0 = createMatAlgo02xDS0({ typed: typed3, equalScalar: equalScalar3 });
     const matAlgo08xS0Sid = createMatAlgo08xS0Sid({ typed: typed3, equalScalar: equalScalar3 });
@@ -29057,7 +29057,7 @@ var createLeftShift = /* @__PURE__ */ factory(
         "number | BigNumber, SparseMatrix": typed3.referToSelf(
           (self) => (x, y) => {
             if (equalScalar3(x, 0)) {
-              return zeros2(y.size(), y.storage());
+              return zeros4(y.size(), y.storage());
             }
             return matAlgo10xSids(y, x, self, true);
           }
@@ -29065,7 +29065,7 @@ var createLeftShift = /* @__PURE__ */ factory(
         "number | BigNumber, DenseMatrix": typed3.referToSelf(
           (self) => (x, y) => {
             if (equalScalar3(x, 0)) {
-              return zeros2(y.size(), y.storage());
+              return zeros4(y.size(), y.storage());
             }
             return matAlgo14xDs(y, x, self, true);
           }
@@ -29087,7 +29087,7 @@ var dependencies152 = ["typed", "matrix", "equalScalar", "zeros", "DenseMatrix",
 var createRightArithShift = /* @__PURE__ */ factory(
   name152,
   dependencies152,
-  ({ typed: typed3, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, DenseMatrix: DenseMatrix6, concat: concat3 }) => {
+  ({ typed: typed3, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros4, DenseMatrix: DenseMatrix6, concat: concat3 }) => {
     const matAlgo01xDSid = createMatAlgo01xDSid({ typed: typed3 });
     const matAlgo02xDS0 = createMatAlgo02xDS0({ typed: typed3, equalScalar: equalScalar3 });
     const matAlgo08xS0Sid = createMatAlgo08xS0Sid({ typed: typed3, equalScalar: equalScalar3 });
@@ -29128,7 +29128,7 @@ var createRightArithShift = /* @__PURE__ */ factory(
         "number | BigNumber, SparseMatrix": typed3.referToSelf(
           (self) => (x, y) => {
             if (equalScalar3(x, 0)) {
-              return zeros2(y.size(), y.storage());
+              return zeros4(y.size(), y.storage());
             }
             return matAlgo10xSids(y, x, self, true);
           }
@@ -29136,7 +29136,7 @@ var createRightArithShift = /* @__PURE__ */ factory(
         "number | BigNumber, DenseMatrix": typed3.referToSelf(
           (self) => (x, y) => {
             if (equalScalar3(x, 0)) {
-              return zeros2(y.size(), y.storage());
+              return zeros4(y.size(), y.storage());
             }
             return matAlgo14xDs(y, x, self, true);
           }
@@ -29158,7 +29158,7 @@ var dependencies153 = ["typed", "matrix", "equalScalar", "zeros", "DenseMatrix",
 var createRightLogShift = /* @__PURE__ */ factory(
   name153,
   dependencies153,
-  ({ typed: typed3, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, DenseMatrix: DenseMatrix6, concat: concat3 }) => {
+  ({ typed: typed3, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros4, DenseMatrix: DenseMatrix6, concat: concat3 }) => {
     const matAlgo01xDSid = createMatAlgo01xDSid({ typed: typed3 });
     const matAlgo02xDS0 = createMatAlgo02xDS0({ typed: typed3, equalScalar: equalScalar3 });
     const matAlgo08xS0Sid = createMatAlgo08xS0Sid({ typed: typed3, equalScalar: equalScalar3 });
@@ -29198,7 +29198,7 @@ var createRightLogShift = /* @__PURE__ */ factory(
         "number | BigNumber, SparseMatrix": typed3.referToSelf(
           (self) => (x, y) => {
             if (equalScalar3(x, 0)) {
-              return zeros2(y.size(), y.storage());
+              return zeros4(y.size(), y.storage());
             }
             return matAlgo10xSids(y, x, self, true);
           }
@@ -29206,7 +29206,7 @@ var createRightLogShift = /* @__PURE__ */ factory(
         "number | BigNumber, DenseMatrix": typed3.referToSelf(
           (self) => (x, y) => {
             if (equalScalar3(x, 0)) {
-              return zeros2(y.size(), y.storage());
+              return zeros4(y.size(), y.storage());
             }
             return matAlgo14xDs(y, x, self, true);
           }
@@ -29897,7 +29897,7 @@ var createFixNumber = /* @__PURE__ */ factory(
 var createFix = /* @__PURE__ */ factory(
   name167,
   dependencies167,
-  ({ typed: typed3, Complex: Complex13, matrix: matrix2, ceil: ceil2, floor: floor2, equalScalar: equalScalar3, zeros: zeros2, DenseMatrix: DenseMatrix6 }) => {
+  ({ typed: typed3, Complex: Complex13, matrix: matrix2, ceil: ceil2, floor: floor2, equalScalar: equalScalar3, zeros: zeros4, DenseMatrix: DenseMatrix6 }) => {
     const matAlgo12xSfs = createMatAlgo12xSfs({ typed: typed3, DenseMatrix: DenseMatrix6 });
     const matAlgo14xDs = createMatAlgo14xDs({ typed: typed3 });
     const fixNumber = createFixNumber({ typed: typed3, ceil: ceil2, floor: floor2 });
@@ -29972,7 +29972,7 @@ var createFix = /* @__PURE__ */ factory(
       ),
       "number | Complex | Fraction | BigNumber, Matrix": typed3.referToSelf(
         (self) => (x, y) => {
-          if (equalScalar3(x, 0)) return zeros2(y.size(), y.storage());
+          if (equalScalar3(x, 0)) return zeros4(y.size(), y.storage());
           if (y.storage() === "dense") {
             return matAlgo14xDs(y, x, self, true);
           }
@@ -29996,7 +29996,7 @@ var createInvmod = /* @__PURE__ */ factory(
     equal: equal2,
     smaller: smaller2,
     mod: mod2,
-    add: add2,
+    add: add3,
     isInteger: isInteger3
   }) => {
     return typed3(name168, {
@@ -30012,9 +30012,9 @@ var createInvmod = /* @__PURE__ */ factory(
       const resVal = res.valueOf();
       const [gcd2, invValue] = resVal;
       if (!equal2(gcd2, 1)) return NaN;
-      let inv2 = mod2(invValue, b);
-      if (smaller2(inv2, 0)) inv2 = add2(inv2, b);
-      return inv2;
+      let inv3 = mod2(invValue, b);
+      if (smaller2(inv3, 0)) inv3 = add3(inv3, b);
+      return inv3;
     }
   }
 );
@@ -30025,7 +30025,7 @@ var dependencies169 = ["typed", "matrix", "equalScalar", "zeros", "not", "concat
 var createAnd = /* @__PURE__ */ factory(
   name169,
   dependencies169,
-  ({ typed: typed3, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, not: not3, concat: concat3 }) => {
+  ({ typed: typed3, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros4, not: not3, concat: concat3 }) => {
     const matAlgo02xDS0 = createMatAlgo02xDS0({ typed: typed3, equalScalar: equalScalar3 });
     const matAlgo06xS0S0 = createMatAlgo06xS0S0({ typed: typed3, equalScalar: equalScalar3 });
     const matAlgo11xS0s = createMatAlgo11xS0s({ typed: typed3, equalScalar: equalScalar3 });
@@ -30052,7 +30052,7 @@ var createAnd = /* @__PURE__ */ factory(
         "SparseMatrix, any": typed3.referToSelf(
           (self) => (x, y) => {
             if (not3(y)) {
-              return zeros2(x.size(), x.storage());
+              return zeros4(x.size(), x.storage());
             }
             return matAlgo11xS0s(x, y, self, false);
           }
@@ -30060,7 +30060,7 @@ var createAnd = /* @__PURE__ */ factory(
         "DenseMatrix, any": typed3.referToSelf(
           (self) => (x, y) => {
             if (not3(y)) {
-              return zeros2(x.size(), x.storage());
+              return zeros4(x.size(), x.storage());
             }
             return matAlgo14xDs(x, y, self, false);
           }
@@ -30068,7 +30068,7 @@ var createAnd = /* @__PURE__ */ factory(
         "any, SparseMatrix": typed3.referToSelf(
           (self) => (x, y) => {
             if (not3(x)) {
-              return zeros2(y.size(), y.storage());
+              return zeros4(y.size(), y.storage());
             }
             return matAlgo11xS0s(y, x, self, true);
           }
@@ -30076,7 +30076,7 @@ var createAnd = /* @__PURE__ */ factory(
         "any, DenseMatrix": typed3.referToSelf(
           (self) => (x, y) => {
             if (not3(x)) {
-              return zeros2(y.size(), y.storage());
+              return zeros4(y.size(), y.storage());
             }
             return matAlgo14xDs(y, x, self, true);
           }
@@ -30266,15 +30266,15 @@ var createPinv = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     matrix: matrix2,
-    inv: inv2,
+    inv: inv3,
     deepEqual: deepEqual3,
     equal: equal2,
     dotDivide: dotDivide2,
-    dot: dot5,
+    dot: dot7,
     ctranspose: ctranspose2,
     divideScalar: divideScalar2,
     multiply: multiply2,
-    add: add2,
+    add: add3,
     Complex: Complex13
   }) => {
     return typed3(name172, {
@@ -30284,9 +30284,9 @@ var createPinv = /* @__PURE__ */ factory(
           case 1:
             if (_isZeros(x)) return ctranspose2(x);
             if (size2[0] === 1) {
-              return inv2(x);
+              return inv3(x);
             } else {
-              return dotDivide2(ctranspose2(x), dot5(x, x));
+              return dotDivide2(ctranspose2(x), dot7(x, x));
             }
           case 2: {
             if (_isZeros(x)) return ctranspose2(x);
@@ -30294,7 +30294,7 @@ var createPinv = /* @__PURE__ */ factory(
             const cols = size2[1];
             if (rows === cols) {
               try {
-                return inv2(x);
+                return inv3(x);
               } catch (err) {
                 if (err instanceof Error && err.message.match(/Cannot calculate inverse, determinant is zero/)) {
                 } else {
@@ -30325,8 +30325,8 @@ var createPinv = /* @__PURE__ */ factory(
     });
     function _pinv(mat, rows, cols) {
       const { C, F } = _rankFact(mat, rows, cols);
-      const Cpinv = multiply2(inv2(multiply2(ctranspose2(C), C)), ctranspose2(C));
-      const Fpinv = multiply2(ctranspose2(F), inv2(multiply2(F, ctranspose2(F))));
+      const Cpinv = multiply2(inv3(multiply2(ctranspose2(C), C)), ctranspose2(C));
+      const Fpinv = multiply2(ctranspose2(F), inv3(multiply2(F, ctranspose2(F))));
       return multiply2(Fpinv, Cpinv);
     }
     function _rref(mat, rows, cols) {
@@ -30356,7 +30356,7 @@ var createPinv = /* @__PURE__ */ factory(
           if (i2 === r) continue;
           val = M[i2][lead];
           for (let j = 0; j < cols; j++) {
-            M[i2][j] = add2(M[i2][j], multiply2(-1, multiply2(val, M[r][j])));
+            M[i2][j] = add3(M[i2][j], multiply2(-1, multiply2(val, M[r][j])));
           }
         }
         lead++;
@@ -30365,17 +30365,17 @@ var createPinv = /* @__PURE__ */ factory(
     }
     function _rankFact(mat, rows, cols) {
       const rref = _rref(mat, rows, cols);
-      const C = mat.map((row2) => row2.filter((_, j) => j < rows && !_isZero(dot5(rref[j], rref[j]))));
-      const F = rref.filter((_, i) => !_isZero(dot5(rref[i], rref[i])));
+      const C = mat.map((row2) => row2.filter((_, j) => j < rows && !_isZero(dot7(rref[j], rref[j]))));
+      const F = rref.filter((_, i) => !_isZero(dot7(rref[i], rref[i])));
       return { C, F };
     }
     function _isZero(x) {
-      return equal2(add2(x, Complex13(1, 1)), add2(0, Complex13(1, 1)));
+      return equal2(add3(x, Complex13(1, 1)), add3(0, Complex13(1, 1)));
     }
     function _isZeros(arr10) {
       return deepEqual3(
-        add2(arr10, Complex13(1, 1)),
-        add2(multiply2(arr10, 0), Complex13(1, 1))
+        add3(arr10, Complex13(1, 1)),
+        add3(multiply2(arr10, 0), Complex13(1, 1))
       );
     }
   }
@@ -30427,7 +30427,7 @@ var createQr = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     matrix: matrix2,
-    zeros: zeros2,
+    zeros: zeros4,
     identity: identity2,
     isZero: isZero2,
     equal: equal2,
@@ -30505,7 +30505,7 @@ var createQr = /* @__PURE__ */ factory(
       const R = m.clone();
       const Rdata = R._data;
       let i, j, k;
-      const w = zeros2([rows], "");
+      const w = zeros4([rows], "");
       for (k = 0; k < Math.min(cols, rows); ++k) {
         const pivot = Rdata[k][k];
         const sgn = unaryMinus2(equal2(pivot, 0) ? 1 : sign3(pivot));
@@ -30606,7 +30606,7 @@ var createRange = /* @__PURE__ */ factory(
     smallerEq: smallerEq2,
     larger: larger2,
     largerEq: largerEq2,
-    add: add2,
+    add: add3,
     isZero: isZero2,
     isPositive: isPositive2
   }) => {
@@ -30719,7 +30719,7 @@ var createRange = /* @__PURE__ */ factory(
       let x = start;
       while (ongoing(x, end)) {
         array.push(x);
-        x = add2(x, step);
+        x = add3(x, step);
       }
       return array;
     }
@@ -33204,7 +33204,7 @@ var dependencies199 = [
 var createDivide = /* @__PURE__ */ factory(
   name199,
   dependencies199,
-  ({ typed: typed3, matrix: matrix2, multiply: multiply2, equalScalar: equalScalar3, divideScalar: divideScalar2, inv: inv2, nodeOperations: nodeOperations2 }) => {
+  ({ typed: typed3, matrix: matrix2, multiply: multiply2, equalScalar: equalScalar3, divideScalar: divideScalar2, inv: inv3, nodeOperations: nodeOperations2 }) => {
     const matAlgo11xS0s = createMatAlgo11xS0s({ typed: typed3, equalScalar: equalScalar3 });
     const matAlgo14xDs = createMatAlgo14xDs({ typed: typed3 });
     return typed3(
@@ -33232,7 +33232,7 @@ var createDivide = /* @__PURE__ */ factory(
           // MATRIX SIGNATURES - Deal with matrices
           // =========================================================================
           "Array | Matrix, Array | Matrix": function(x, y) {
-            return multiply2(x, inv2(y));
+            return multiply2(x, inv3(y));
           },
           "DenseMatrix, any": function(x, y) {
             return matAlgo14xDs(
@@ -33259,7 +33259,7 @@ var createDivide = /* @__PURE__ */ factory(
             ).valueOf();
           },
           "any, Array | Matrix": function(x, y) {
-            return multiply2(x, inv2(y));
+            return multiply2(x, inv3(y));
           }
         },
         divideScalar2.signatures
@@ -34245,7 +34245,7 @@ var createCross = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     matrix: matrix2,
-    subtract: subtract2,
+    subtract: subtract3,
     multiply: multiply2
   }) => {
     return typed3(name209, {
@@ -34272,9 +34272,9 @@ var createCross = /* @__PURE__ */ factory(
         );
       }
       const product3 = [
-        subtract2(multiply2(x[1], y[2]), multiply2(x[2], y[1])),
-        subtract2(multiply2(x[2], y[0]), multiply2(x[0], y[2])),
-        subtract2(multiply2(x[0], y[1]), multiply2(x[1], y[0]))
+        subtract3(multiply2(x[1], y[2]), multiply2(x[2], y[1])),
+        subtract3(multiply2(x[2], y[0]), multiply2(x[0], y[2])),
+        subtract3(multiply2(x[0], y[1]), multiply2(x[1], y[0]))
       ];
       if (highestDimension > 1) {
         return [product3];
@@ -34294,7 +34294,7 @@ var createDiff = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     matrix: matrix2,
-    subtract: subtract2,
+    subtract: subtract3,
     number: number2
   }) => {
     return typed3(name210, {
@@ -34355,7 +34355,7 @@ var createDiff = /* @__PURE__ */ factory(
         return _ArrayDiff(obj1, obj2);
       }
       if (!obj1IsArray && !obj2IsArray) {
-        return subtract2(obj2, obj1);
+        return subtract3(obj2, obj1);
       }
       throw TypeError("Cannot calculate difference between 1 array and 1 non-array");
     }
@@ -34392,7 +34392,7 @@ var dependencies211 = [
 var createSqrtm = /* @__PURE__ */ factory(
   name211,
   dependencies211,
-  ({ typed: typed3, abs: abs2, add: add2, multiply: multiply2, map: map2, sqrt: sqrt2, subtract: subtract2, inv: inv2, size: size2, max: max2, identity: identity2 }) => {
+  ({ typed: typed3, abs: abs2, add: add3, multiply: multiply2, map: map2, sqrt: sqrt2, subtract: subtract3, inv: inv3, size: size2, max: max2, identity: identity2 }) => {
     const _maxIterations = 1e3;
     const _tolerance = 1e-6;
     function _tryWasmSqrtm(A, n) {
@@ -34458,9 +34458,9 @@ var createSqrtm = /* @__PURE__ */ factory(
       let Z = identity2(size2(A));
       do {
         const Yk = Y;
-        Y = multiply2(0.5, add2(Yk, inv2(Z)));
-        Z = multiply2(0.5, add2(Z, inv2(Yk)));
-        error = max2(abs2(subtract2(Y, Yk)));
+        Y = multiply2(0.5, add3(Yk, inv3(Z)));
+        Z = multiply2(0.5, add3(Z, inv3(Yk)));
+        error = max2(abs2(subtract3(Y, Yk)));
         if (error > _tolerance && ++iterations > _maxIterations) {
           throw new Error("computing square root of matrix: iterative method could not converge");
         }
@@ -34924,7 +34924,7 @@ var dependencies213 = ["divideScalar", "multiply", "subtract"];
 var createCsSpsolve = /* @__PURE__ */ factory(
   name213,
   dependencies213,
-  ({ divideScalar: divideScalar2, multiply: multiply2, subtract: subtract2 }) => {
+  ({ divideScalar: divideScalar2, multiply: multiply2, subtract: subtract3 }) => {
     return function csSpsolve2(g, b, k, xi, x, pinv2, lo) {
       const gvalues = g._values;
       const gindex = g._index;
@@ -34955,7 +34955,7 @@ var createCsSpsolve = /* @__PURE__ */ factory(
         q = lo ? p1 : p1 - 1;
         for (; p < q; p++) {
           const i = gindex[p];
-          x[i] = subtract2(x[i], multiply2(gvalues[p], x[j]));
+          x[i] = subtract3(x[i], multiply2(gvalues[p], x[j]));
         }
       }
       return top;
@@ -34977,8 +34977,8 @@ var dependencies214 = [
 var createCsLu = /* @__PURE__ */ factory(
   name214,
   dependencies214,
-  ({ abs: abs2, divideScalar: divideScalar2, multiply: multiply2, subtract: subtract2, larger: larger2, largerEq: largerEq2, SparseMatrix }) => {
-    const csSpsolve2 = createCsSpsolve({ divideScalar: divideScalar2, multiply: multiply2, subtract: subtract2 });
+  ({ abs: abs2, divideScalar: divideScalar2, multiply: multiply2, subtract: subtract3, larger: larger2, largerEq: largerEq2, SparseMatrix }) => {
+    const csSpsolve2 = createCsSpsolve({ divideScalar: divideScalar2, multiply: multiply2, subtract: subtract3 });
     return function csLu2(m, s, tol) {
       if (!m) {
         return null;
@@ -35097,21 +35097,21 @@ var createSlu = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     abs: abs2,
-    add: add2,
+    add: add3,
     multiply: multiply2,
-    transpose: transpose4,
+    transpose: transpose5,
     divideScalar: divideScalar2,
-    subtract: subtract2,
+    subtract: subtract3,
     larger: larger2,
     largerEq: largerEq2,
     SparseMatrix
   }) => {
-    const csSqr2 = createCsSqr({ add: add2, multiply: multiply2, transpose: transpose4 });
+    const csSqr2 = createCsSqr({ add: add3, multiply: multiply2, transpose: transpose5 });
     const csLu2 = createCsLu({
       abs: abs2,
       divideScalar: divideScalar2,
       multiply: multiply2,
-      subtract: subtract2,
+      subtract: subtract3,
       larger: larger2,
       largerEq: largerEq2,
       SparseMatrix
@@ -35197,7 +35197,7 @@ var createCsChol = /* @__PURE__ */ factory(
   ({
     divideScalar: divideScalar2,
     sqrt: sqrt2,
-    subtract: subtract2,
+    subtract: subtract3,
     multiply: multiply2,
     im: im3,
     re: re3,
@@ -35251,9 +35251,9 @@ var createCsChol = /* @__PURE__ */ factory(
           x[i] = 0;
           for (p = lptr[i] + 1; p < c[i]; p++) {
             const r = lindex[p];
-            x[r] = subtract2(x[r], multiply2(lvalues[p], lki));
+            x[r] = subtract3(x[r], multiply2(lvalues[p], lki));
           }
-          d = subtract2(d, multiply2(lki, conj3(lki)));
+          d = subtract3(d, multiply2(lki, conj3(lki)));
           p = c[i]++;
           lindex[p] = k;
           lvalues[p] = conj3(lki);
@@ -35411,13 +35411,13 @@ var createIntersect = /* @__PURE__ */ factory(
     typed: typed3,
     config: config2,
     abs: abs2,
-    add: add2,
+    add: add3,
     addScalar: addScalar2,
     matrix: matrix2,
     multiply: multiply2,
     multiplyScalar: multiplyScalar2,
     divideScalar: divideScalar2,
-    subtract: subtract2,
+    subtract: subtract3,
     smaller: smaller2,
     equalScalar: equalScalar3,
     flatten: flatten4,
@@ -35530,9 +35530,9 @@ var createIntersect = /* @__PURE__ */ factory(
       if (wasmResult !== void 0) return wasmResult;
       const o1 = p1a;
       const o2 = p2a;
-      const d1 = subtract2(o1, p1b);
-      const d2 = subtract2(o2, p2b);
-      const det2 = subtract2(
+      const d1 = subtract3(o1, p1b);
+      const d2 = subtract3(o2, p2b);
+      const det2 = subtract3(
         multiplyScalar2(d1[0], d2[1]),
         multiplyScalar2(d2[0], d1[1])
       );
@@ -35546,12 +35546,12 @@ var createIntersect = /* @__PURE__ */ factory(
       const d21o20 = multiplyScalar2(d2[1], o2[0]);
       const t = divideScalar2(
         addScalar2(
-          subtract2(subtract2(d20o11, d21o10), d20o21),
+          subtract3(subtract3(d20o11, d21o10), d20o21),
           d21o20
         ),
         det2
       );
-      return add2(multiply2(d1, t), o1);
+      return add3(multiply2(d1, t), o1);
     }
     function _tryWasmIntersect2d(p1a, p1b, p2a, p2b) {
       const wasm = wasmLoader.getModule();
@@ -35583,18 +35583,18 @@ var createIntersect = /* @__PURE__ */ factory(
     }
     function _intersect3dHelper(a, b, c, d, e, f, g, h, i, j, k, l) {
       const add1 = multiplyScalar2(
-        subtract2(a, b),
-        subtract2(c, d)
+        subtract3(a, b),
+        subtract3(c, d)
       );
       const add22 = multiplyScalar2(
-        subtract2(e, f),
-        subtract2(g, h)
+        subtract3(e, f),
+        subtract3(g, h)
       );
-      const add3 = multiplyScalar2(
-        subtract2(i, j),
-        subtract2(k, l)
+      const add32 = multiplyScalar2(
+        subtract3(i, j),
+        subtract3(k, l)
       );
-      return addScalar2(addScalar2(add1, add22), add3);
+      return addScalar2(addScalar2(add1, add22), add32);
     }
     function _intersect3d(x1, y1, z1, x2, y2, z2, x3, y3, z3, x4, y4, z4) {
       const d1343 = _intersect3dHelper(x1, x3, x4, x3, y1, y3, y4, y3, z1, z3, z4, z3);
@@ -35602,23 +35602,23 @@ var createIntersect = /* @__PURE__ */ factory(
       const d1321 = _intersect3dHelper(x1, x3, x2, x1, y1, y3, y2, y1, z1, z3, z2, z1);
       const d4343 = _intersect3dHelper(x4, x3, x4, x3, y4, y3, y4, y3, z4, z3, z4, z3);
       const d2121 = _intersect3dHelper(x2, x1, x2, x1, y2, y1, y2, y1, z2, z1, z2, z1);
-      const numerator = subtract2(
+      const numerator = subtract3(
         multiplyScalar2(d1343, d4321),
         multiplyScalar2(d1321, d4343)
       );
-      const denominator = subtract2(
+      const denominator = subtract3(
         multiplyScalar2(d2121, d4343),
         multiplyScalar2(d4321, d4321)
       );
       if (isZero2(denominator)) return null;
       const ta = divideScalar2(numerator, denominator);
       const tb = divideScalar2(addScalar2(d1343, multiplyScalar2(ta, d4321)), d4343);
-      const pax = addScalar2(x1, multiplyScalar2(ta, subtract2(x2, x1)));
-      const pay = addScalar2(y1, multiplyScalar2(ta, subtract2(y2, y1)));
-      const paz = addScalar2(z1, multiplyScalar2(ta, subtract2(z2, z1)));
-      const pbx = addScalar2(x3, multiplyScalar2(tb, subtract2(x4, x3)));
-      const pby = addScalar2(y3, multiplyScalar2(tb, subtract2(y4, y3)));
-      const pbz = addScalar2(z3, multiplyScalar2(tb, subtract2(z4, z3)));
+      const pax = addScalar2(x1, multiplyScalar2(ta, subtract3(x2, x1)));
+      const pay = addScalar2(y1, multiplyScalar2(ta, subtract3(y2, y1)));
+      const paz = addScalar2(z1, multiplyScalar2(ta, subtract3(z2, z1)));
+      const pbx = addScalar2(x3, multiplyScalar2(tb, subtract3(x4, x3)));
+      const pby = addScalar2(y3, multiplyScalar2(tb, subtract3(y4, y3)));
+      const pbz = addScalar2(z3, multiplyScalar2(tb, subtract3(z4, z3)));
       if (equalScalar3(pax, pbx) && equalScalar3(pay, pby) && equalScalar3(paz, pbz)) {
         return [pax, pay, paz];
       } else {
@@ -35632,21 +35632,21 @@ var createIntersect = /* @__PURE__ */ factory(
       const y2y = multiplyScalar2(y2, y);
       const z1z = multiplyScalar2(z1, z);
       const z2z = multiplyScalar2(z2, z);
-      const numerator = subtract2(
-        subtract2(subtract2(c, x1x), y1y),
+      const numerator = subtract3(
+        subtract3(subtract3(c, x1x), y1y),
         z1z
       );
-      const denominator = subtract2(
-        subtract2(
-          subtract2(addScalar2(addScalar2(x2x, y2y), z2z), x1x),
+      const denominator = subtract3(
+        subtract3(
+          subtract3(addScalar2(addScalar2(x2x, y2y), z2z), x1x),
           y1y
         ),
         z1z
       );
       const t = divideScalar2(numerator, denominator);
-      const px = addScalar2(x1, multiplyScalar2(t, subtract2(x2, x1)));
-      const py = addScalar2(y1, multiplyScalar2(t, subtract2(y2, y1)));
-      const pz = addScalar2(z1, multiplyScalar2(t, subtract2(z2, z1)));
+      const px = addScalar2(x1, multiplyScalar2(t, subtract3(x2, x1)));
+      const py = addScalar2(y1, multiplyScalar2(t, subtract3(y2, y1)));
+      const pz = addScalar2(z1, multiplyScalar2(t, subtract3(z2, z1)));
       return [px, py, pz];
     }
   }
@@ -35667,7 +35667,7 @@ var dependencies219 = ["typed", "add", "divide"];
 var createMean = /* @__PURE__ */ factory(
   name219,
   dependencies219,
-  ({ typed: typed3, add: add2, divide: divide2 }) => {
+  ({ typed: typed3, add: add3, divide: divide2 }) => {
     return typed3(name219, {
       // mean([a, b, c, d, ...])
       "Array | Matrix": _mean2,
@@ -35684,7 +35684,7 @@ var createMean = /* @__PURE__ */ factory(
     function _nmeanDim(array, dim) {
       try {
         const dimValue = typeof dim === "number" ? dim : dim.valueOf();
-        const sum3 = reduce2(array, dimValue, add2);
+        const sum3 = reduce2(array, dimValue, add3);
         const s = Array.isArray(array) ? arraySize(array) : array.size();
         return divide2(sum3, s[dimValue]);
       } catch (err) {
@@ -35712,7 +35712,7 @@ var createMean = /* @__PURE__ */ factory(
       let num2 = 0;
       deepForEach2(array, function(value) {
         try {
-          sum3 = sum3 === void 0 ? value : add2(sum3, value);
+          sum3 = sum3 === void 0 ? value : add3(sum3, value);
           num2++;
         } catch (err) {
           throw improveErrorMessage(err, "mean", value);
@@ -35732,7 +35732,7 @@ var dependencies220 = ["typed", "add", "divide", "compare", "partitionSelect"];
 var createMedian = /* @__PURE__ */ factory(
   name220,
   dependencies220,
-  ({ typed: typed3, add: add2, divide: divide2, compare: compare2, partitionSelect: partitionSelect2 }) => {
+  ({ typed: typed3, add: add3, divide: divide2, compare: compare2, partitionSelect: partitionSelect2 }) => {
     function _median2(array) {
       try {
         const flat = flatten2(array.valueOf());
@@ -35765,7 +35765,7 @@ var createMedian = /* @__PURE__ */ factory(
     });
     const middle2 = typed3({
       "number | BigNumber | Complex | Unit, number | BigNumber | Complex | Unit": function(left, right) {
-        return divide2(add2(left, right), 2);
+        return divide2(add3(left, right), 2);
       }
     });
     return typed3(name220, {
@@ -35804,8 +35804,8 @@ var createVariance = /* @__PURE__ */ factory(
   dependencies221,
   ({
     typed: typed3,
-    add: add2,
-    subtract: subtract2,
+    add: add3,
+    subtract: subtract3,
     multiply: multiply2,
     divide: divide2,
     mapSlices: mapSlices2,
@@ -35853,7 +35853,7 @@ var createVariance = /* @__PURE__ */ factory(
       let num2 = 0;
       deepForEach2(array, function(value) {
         try {
-          sum3 = sum3 === void 0 ? value : add2(sum3, value);
+          sum3 = sum3 === void 0 ? value : add3(sum3, value);
           num2++;
         } catch (err) {
           throw improveErrorMessage(err, "variance", value);
@@ -35863,8 +35863,8 @@ var createVariance = /* @__PURE__ */ factory(
       const mean7 = divide2(sum3, num2);
       sum3 = void 0;
       deepForEach2(array, function(value) {
-        const diff2 = subtract2(value, mean7);
-        sum3 = sum3 === void 0 ? multiply2(diff2, diff2) : add2(sum3, multiply2(diff2, diff2));
+        const diff2 = subtract3(value, mean7);
+        sum3 = sum3 === void 0 ? multiply2(diff2, diff2) : add3(sum3, multiply2(diff2, diff2));
       });
       if (mathIsNaN(sum3)) {
         return sum3;
@@ -35924,8 +35924,8 @@ var createQuantileSeq = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     bignumber: bignumber2,
-    add: add2,
-    subtract: subtract2,
+    add: add3,
+    subtract: subtract3,
     divide: divide2,
     multiply: multiply2,
     partitionSelect: partitionSelect2,
@@ -35967,7 +35967,7 @@ var createQuantileSeq = /* @__PURE__ */ factory(
             "N must be less than or equal to 2^32-1, as that is the maximum length of an Array"
           );
         }
-        const nPlusOne = add2(probOrN, 1);
+        const nPlusOne = add3(probOrN, 1);
         probArr = [];
         for (let i = 0; smaller2(i, probOrN); i++) {
           const prob = divide2(i + 1, nPlusOne);
@@ -36013,8 +36013,8 @@ var createQuantileSeq = /* @__PURE__ */ factory(
         }
       }
       const fracPartConverted = isBigNumber(left) && isNumber(fracPart) ? bignumber2(fracPart) : fracPart;
-      return add2(
-        multiply2(left, subtract2(1, fracPartConverted)),
+      return add3(
+        multiply2(left, subtract3(1, fracPartConverted)),
         multiply2(right, fracPartConverted)
       );
     }
@@ -36105,7 +36105,7 @@ var dependencies224 = ["typed", "add", "divide", "multiply", "factorial", "isInt
 var createMultinomial = /* @__PURE__ */ factory(
   name224,
   dependencies224,
-  ({ typed: typed3, add: add2, divide: divide2, multiply: multiply2, factorial: factorial5, isInteger: isInteger3, isPositive: isPositive2 }) => {
+  ({ typed: typed3, add: add3, divide: divide2, multiply: multiply2, factorial: factorial5, isInteger: isInteger3, isPositive: isPositive2 }) => {
     return typed3(name224, {
       "Array | Matrix": function(a) {
         let sum3 = 0;
@@ -36114,7 +36114,7 @@ var createMultinomial = /* @__PURE__ */ factory(
           if (!isInteger3(ai) || !isPositive2(ai)) {
             throw new TypeError("Positive integer value expected in function multinomial");
           }
-          sum3 = add2(sum3, ai);
+          sum3 = add3(sum3, ai);
           denom = multiply2(denom, factorial5(ai));
         });
         return divide2(factorial5(sum3), denom);
@@ -36130,7 +36130,7 @@ var dependencies225 = ["typed", "add", "multiply", "Complex", "divide", "matrix"
 var createFreqz = /* @__PURE__ */ factory(
   name225,
   dependencies225,
-  ({ typed: typed3, add: add2, multiply: multiply2, Complex: Complex13, divide: divide2, matrix: matrix2 }) => {
+  ({ typed: typed3, add: add3, multiply: multiply2, Complex: Complex13, divide: divide2, matrix: matrix2 }) => {
     return typed3(name225, {
       "Array, Array": function(b, a) {
         const w = createBins(512);
@@ -36224,13 +36224,13 @@ var createFreqz = /* @__PURE__ */ factory(
         let sumNum = Complex13(0, 0);
         let sumDen = Complex13(0, 0);
         for (let j = 0; j < b.length; j++) {
-          sumNum = add2(
+          sumNum = add3(
             sumNum,
             multiply2(b[j], Complex13(Math.cos(-j * w[i]), Math.sin(-j * w[i])))
           );
         }
         for (let j = 0; j < a.length; j++) {
-          sumDen = add2(
+          sumDen = add3(
             sumDen,
             multiply2(a[j], Complex13(Math.cos(-j * w[i]), Math.sin(-j * w[i])))
           );
@@ -37047,8 +37047,8 @@ var createPolynomialRoot = /* @__PURE__ */ factory(
     typed: typed3,
     isZero: isZero2,
     equalScalar: equalScalar3,
-    add: add2,
-    subtract: subtract2,
+    add: add3,
+    subtract: subtract3,
     multiply: multiply2,
     divide: divide2,
     sqrt: sqrt2,
@@ -37078,10 +37078,10 @@ var createPolynomialRoot = /* @__PURE__ */ factory(
             const d1 = multiply2(b, b);
             const d2 = multiply2(4, a, c);
             if (equalScalar3(d1, d2)) return [divide2(unaryMinus2(b), denom)];
-            const discriminant2 = sqrt2(subtract2(d1, d2));
+            const discriminant2 = sqrt2(subtract3(d1, d2));
             return [
-              divide2(subtract2(discriminant2, b), denom),
-              divide2(subtract2(unaryMinus2(discriminant2), b), denom)
+              divide2(subtract3(discriminant2, b), denom),
+              divide2(subtract3(unaryMinus2(discriminant2), b), denom)
             ];
           }
           case 4: {
@@ -37089,15 +37089,15 @@ var createPolynomialRoot = /* @__PURE__ */ factory(
             const denom = unaryMinus2(multiply2(3, a));
             const D0_1 = multiply2(b, b);
             const D0_2 = multiply2(3, a, c);
-            const D1_1 = add2(multiply2(2, b, b, b), multiply2(27, a, a, d));
+            const D1_1 = add3(multiply2(2, b, b, b), multiply2(27, a, a, d));
             const D1_2 = multiply2(9, a, b, c);
             if (equalScalar3(D0_1, D0_2) && equalScalar3(D1_1, D1_2)) {
               return [divide2(b, denom)];
             }
-            const Delta0 = subtract2(D0_1, D0_2);
-            const Delta1 = subtract2(D1_1, D1_2);
-            const discriminant1 = add2(multiply2(18, a, b, c, d), multiply2(b, b, c, c));
-            const discriminant2 = add2(
+            const Delta0 = subtract3(D0_1, D0_2);
+            const Delta1 = subtract3(D1_1, D1_2);
+            const discriminant1 = add3(multiply2(18, a, b, c, d), multiply2(b, b, c, c));
+            const discriminant2 = add3(
               multiply2(4, b, b, b, d),
               multiply2(4, a, c, c, c),
               multiply2(27, a, a, d, d)
@@ -37105,11 +37105,11 @@ var createPolynomialRoot = /* @__PURE__ */ factory(
             if (equalScalar3(discriminant1, discriminant2)) {
               return [
                 divide2(
-                  subtract2(multiply2(4, a, b, c), add2(multiply2(9, a, a, d), multiply2(b, b, b))),
+                  subtract3(multiply2(4, a, b, c), add3(multiply2(9, a, a, d), multiply2(b, b, b))),
                   multiply2(a, Delta0)
                 ),
                 // simple root
-                divide2(subtract2(multiply2(9, a, d), multiply2(b, c)), multiply2(2, Delta0))
+                divide2(subtract3(multiply2(9, a, d), multiply2(b, c)), multiply2(2, Delta0))
                 // double root
               ];
             }
@@ -37118,15 +37118,15 @@ var createPolynomialRoot = /* @__PURE__ */ factory(
               Ccubed = Delta1;
             } else {
               Ccubed = divide2(
-                add2(
+                add3(
                   Delta1,
-                  sqrt2(subtract2(multiply2(Delta1, Delta1), multiply2(4, Delta0, Delta0, Delta0)))
+                  sqrt2(subtract3(multiply2(Delta1, Delta1), multiply2(4, Delta0, Delta0, Delta0)))
                 ),
                 2
               );
             }
             const allRoots = true;
-            const rawRoots = cbrt3(Ccubed, allRoots).toArray().map((C) => divide2(add2(b, C, divide2(Delta0, C)), denom));
+            const rawRoots = cbrt3(Ccubed, allRoots).toArray().map((C) => divide2(add3(b, C, divide2(Delta0, C)), denom));
             return rawRoots.map((r) => {
               if (typeOf3(r) === "Complex" && equalScalar3(re3(r), re3(r) + im3(r))) {
                 return re3(r);
@@ -37181,8 +37181,8 @@ var createZeta = /* @__PURE__ */ factory(
     isNegative: isNegative2,
     gamma: gamma2,
     sin: sin2,
-    subtract: subtract2,
-    add: add2,
+    subtract: subtract3,
+    add: add3,
     Complex: Complex13,
     BigNumber: BigNumber9,
     pi
@@ -37242,28 +37242,28 @@ var createZeta = /* @__PURE__ */ factory(
       if (getRe(s) >= 0) {
         return f(s, createValue(n), createValue);
       } else {
-        let c = multiply2(pow2(2, s), pow2(createValue(pi), subtract2(s, 1)));
+        let c = multiply2(pow2(2, s), pow2(createValue(pi), subtract3(s, 1)));
         c = multiply2(c, sin2(multiply2(divide2(createValue(pi), 2), s)));
-        c = multiply2(c, gamma2(subtract2(1, s)));
-        return multiply2(c, zeta2(subtract2(1, s), createValue, determineDigits, getRe));
+        c = multiply2(c, gamma2(subtract3(1, s)));
+        return multiply2(c, zeta2(subtract3(1, s), createValue, determineDigits, getRe));
       }
     }
     function d(k, n) {
       let S = k;
-      for (let j = k; smallerEq2(j, n); j = add2(j, 1)) {
+      for (let j = k; smallerEq2(j, n); j = add3(j, 1)) {
         const factor2 = divide2(
-          multiply2(factorial5(add2(n, subtract2(j, 1))), pow2(4, j)),
-          multiply2(factorial5(subtract2(n, j)), factorial5(multiply2(2, j)))
+          multiply2(factorial5(add3(n, subtract3(j, 1))), pow2(4, j)),
+          multiply2(factorial5(subtract3(n, j)), factorial5(multiply2(2, j)))
         );
-        S = add2(S, factor2);
+        S = add3(S, factor2);
       }
       return multiply2(n, S);
     }
     function f(s, n, createValue) {
-      const c = divide2(1, multiply2(d(createValue(0), n), subtract2(1, pow2(2, subtract2(1, s)))));
+      const c = divide2(1, multiply2(d(createValue(0), n), subtract3(1, pow2(2, subtract3(1, s)))));
       let S = createValue(0);
-      for (let k = createValue(1); smallerEq2(k, n); k = add2(k, 1)) {
-        S = add2(S, divide2(multiply2((-1) ** (k - 1), d(k, n)), pow2(k, s)));
+      for (let k = createValue(1); smallerEq2(k, n); k = add3(k, 1)) {
+        S = add3(S, divide2(multiply2((-1) ** (k - 1), d(k, n)), pow2(k, s)));
       }
       return multiply2(c, S);
     }
@@ -37309,7 +37309,7 @@ function flattenToFloat648(matrix2, rows, cols) {
 }
 function createComplexEigs({
   addScalar: addScalar2,
-  subtract: subtract2,
+  subtract: subtract3,
   flatten: flatten4,
   multiply: multiply2,
   multiplyScalar: multiplyScalar2,
@@ -37320,7 +37320,7 @@ function createComplexEigs({
   diag: diag2,
   size: size2,
   reshape: reshape3,
-  inv: inv2,
+  inv: inv3,
   qr: qr2,
   usolve: usolve2,
   usolveAll: usolveAll2,
@@ -37329,7 +37329,7 @@ function createComplexEigs({
   larger: larger2,
   smaller: smaller2,
   matrixFromColumns: _matrixFromColumns,
-  dot: dot5
+  dot: dot7
 }) {
   function complexEigs(arr10, N, prec, type, findVectors = true) {
     if (!findVectors && type === "number" && N * N >= WASM_EIGS_THRESHOLD) {
@@ -37489,14 +37489,14 @@ function createComplexEigs({
           continue;
         }
         for (let k = 0; k < N; k++) {
-          arr10[j][k] = subtract2(arr10[j][k], multiplyScalar2(n, arr10[i + 1][k]));
+          arr10[j][k] = subtract3(arr10[j][k], multiplyScalar2(n, arr10[i + 1][k]));
         }
         for (let k = 0; k < N; k++) {
           arr10[k][i + 1] = addScalar2(arr10[k][i + 1], multiplyScalar2(n, arr10[k][j]));
         }
         if (findVectors) {
           for (let k = 0; k < N; k++) {
-            R[j][k] = subtract2(R[j][k], multiplyScalar2(n, R[i + 1][k]));
+            R[j][k] = subtract3(R[j][k], multiplyScalar2(n, R[i + 1][k]));
           }
         }
       }
@@ -37520,7 +37520,7 @@ function createComplexEigs({
       lastConvergenceBefore += 1;
       const k = arr10[n - 1][n - 1];
       for (let i = 0; i < n; i++) {
-        arr10[i][i] = subtract2(arr10[i][i], k);
+        arr10[i][i] = subtract3(arr10[i][i], k);
       }
       const { Q: Q2, R } = qr2(arr10);
       arr10 = multiply2(R, Q2);
@@ -37586,7 +37586,7 @@ function createComplexEigs({
         break;
       }
     }
-    lambdas.sort((a, b) => +subtract2(abs2(a), abs2(b)));
+    lambdas.sort((a, b) => +subtract3(abs2(a), abs2(b)));
     if (lastConvergenceBefore > 100) {
       const err = new Error(
         "The eigenvalues failed to converge. Only found these eigenvalues: " + lambdas.join(", ")
@@ -37599,7 +37599,7 @@ function createComplexEigs({
     return { values: lambdas, C };
   }
   function findEigenvectors(A, N, C, R, values, prec, type) {
-    const Cinv = inv2(C);
+    const Cinv = inv3(C);
     const U = multiply2(multiply2(Cinv, A), C);
     const big = type === "BigNumber";
     const cplx = type === "Complex";
@@ -37622,7 +37622,7 @@ function createComplexEigs({
     const E = diag2(Array(N).fill(one));
     for (let i = 0; i < len; i++) {
       const lambda = uniqueValues[i];
-      const S = subtract2(
+      const S = subtract3(
         U,
         multiply2(lambda, E)
       );
@@ -37635,7 +37635,7 @@ function createComplexEigs({
         }
         solutions.push(approxVec);
       }
-      const correction = multiply2(inv2(R), C);
+      const correction = multiply2(inv3(R), C);
       solutions = solutions.map(
         (v) => multiply2(correction, v)
       );
@@ -37645,13 +37645,13 @@ function createComplexEigs({
   }
   function eigenvalues2x2(a, b, c, d) {
     const trA = addScalar2(a, d);
-    const detA = subtract2(multiplyScalar2(a, d), multiplyScalar2(b, c));
+    const detA = subtract3(multiplyScalar2(a, d), multiplyScalar2(b, c));
     const x = multiplyScalar2(trA, 0.5);
     const y = multiplyScalar2(
-      sqrt2(subtract2(multiplyScalar2(trA, trA), multiplyScalar2(4, detA))),
+      sqrt2(subtract3(multiplyScalar2(trA, trA), multiplyScalar2(4, detA))),
       0.5
     );
-    return [addScalar2(x, y), subtract2(x, y)];
+    return [addScalar2(x, y), subtract3(x, y)];
   }
   function jordanBase2x2(a, b, c, d, l1, l2, prec, type) {
     const big = type === "BigNumber";
@@ -37664,14 +37664,14 @@ function createComplexEigs({
         [zero, one]
       ];
     }
-    if (larger2(abs2(subtract2(l1, l2)), prec)) {
+    if (larger2(abs2(subtract3(l1, l2)), prec)) {
       return [
-        [subtract2(l1, d), subtract2(l2, d)],
+        [subtract3(l1, d), subtract3(l2, d)],
         [c, c]
       ];
     }
-    const na = subtract2(a, l1);
-    const nd = subtract2(d, l1);
+    const na = subtract3(a, l1);
+    const nd = subtract3(d, l1);
     if (smaller2(abs2(b), prec) && smaller2(abs2(nd), prec)) {
       return [
         [na, one],
@@ -37767,10 +37767,10 @@ function createComplexEigs({
     const vectorShape = size2(v);
     for (let w of orthog) {
       w = reshape3(w, vectorShape);
-      v = subtract2(
+      v = subtract3(
         v,
         multiply2(
-          divideScalar2(dot5(w, v), dot5(w, w)),
+          divideScalar2(dot7(w, v), dot7(w, w)),
           w
         )
       );
@@ -37778,7 +37778,7 @@ function createComplexEigs({
     return v;
   }
   function norm4(v) {
-    return abs2(sqrt2(dot5(v, v)));
+    return abs2(sqrt2(dot7(v, v)));
   }
   function normalize2(v, type) {
     const big = type === "BigNumber";
@@ -37803,16 +37803,16 @@ function flattenToFloat649(matrix2, rows, cols) {
 function createRealSymmetric({
   config: config2,
   addScalar: addScalar2,
-  subtract: subtract2,
+  subtract: subtract3,
   abs: abs2,
   atan: atan3,
   cos: cos2,
   sin: sin2,
   multiplyScalar: multiplyScalar2,
-  inv: inv2,
+  inv: inv3,
   bignumber: bignumber2,
   multiply: multiply2,
-  add: add2
+  add: add3
 }) {
   function bigGte(a, b) {
     if (typeof a === "number" && typeof b === "number") return a >= b;
@@ -37954,13 +37954,13 @@ function createRealSymmetric({
     }
   }
   function getThetaBig(aii, ajj, aij) {
-    const denom = subtract2(ajj, aii);
+    const denom = subtract3(ajj, aii);
     if (bigLte(abs2(denom), bignumber2(config2.relTol))) {
       return bignumber2(-1).acos().div(4);
     } else {
       return multiplyScalar2(
         bignumber2(0.5),
-        atan3(multiply2(bignumber2(2), aij, inv2(denom)))
+        atan3(multiply2(bignumber2(2), aij, inv3(denom)))
       );
     }
   }
@@ -37987,7 +37987,7 @@ function createRealSymmetric({
     const Ski = Array(N).fill(bignumber2(0));
     const Skj = Array(N).fill(bignumber2(0));
     for (let k = 0; k < N; k++) {
-      Ski[k] = subtract2(multiplyScalar2(c, Sij[k][i]), multiplyScalar2(s, Sij[k][j]));
+      Ski[k] = subtract3(multiplyScalar2(c, Sij[k][i]), multiplyScalar2(s, Sij[k][j]));
       Skj[k] = addScalar2(multiplyScalar2(s, Sij[k][i]), multiplyScalar2(c, Sij[k][j]));
     }
     for (let k = 0; k < N; k++) {
@@ -38006,16 +38006,16 @@ function createRealSymmetric({
     const Akj = Array(N).fill(bignumber2(0));
     const csHij = multiply2(bignumber2(2), c, s, Hij[i][j]);
     const Aii = addScalar2(
-      subtract2(multiplyScalar2(c2, Hij[i][i]), csHij),
+      subtract3(multiplyScalar2(c2, Hij[i][i]), csHij),
       multiplyScalar2(s2, Hij[j][j])
     );
-    const Ajj = add2(
+    const Ajj = add3(
       multiplyScalar2(s2, Hij[i][i]),
       csHij,
       multiplyScalar2(c2, Hij[j][j])
     );
     for (let k = 0; k < N; k++) {
-      Aki[k] = subtract2(multiplyScalar2(c, Hij[i][k]), multiplyScalar2(s, Hij[j][k]));
+      Aki[k] = subtract3(multiplyScalar2(c, Hij[i][k]), multiplyScalar2(s, Hij[j][k]));
       Akj[k] = addScalar2(multiplyScalar2(s, Hij[i][k]), multiplyScalar2(c, Hij[j][k]));
     }
     Hij[i][i] = Aii;
@@ -38170,7 +38170,7 @@ var createEigs = /* @__PURE__ */ factory(
     typed: typed3,
     matrix: matrix2,
     addScalar: addScalar2,
-    subtract: subtract2,
+    subtract: subtract3,
     equal: equal2,
     abs: abs2,
     atan: atan3,
@@ -38178,10 +38178,10 @@ var createEigs = /* @__PURE__ */ factory(
     sin: sin2,
     multiplyScalar: multiplyScalar2,
     divideScalar: divideScalar2,
-    inv: inv2,
+    inv: inv3,
     bignumber: bignumber2,
     multiply: multiply2,
-    add: add2,
+    add: add3,
     larger: larger2,
     column: _column,
     flatten: flatten4,
@@ -38198,26 +38198,26 @@ var createEigs = /* @__PURE__ */ factory(
     re: re3,
     smaller: smaller2,
     matrixFromColumns: matrixFromColumns2,
-    dot: dot5
+    dot: dot7
   }) => {
     const doRealSymmetric = createRealSymmetric({
       config: config2,
       addScalar: addScalar2,
-      subtract: subtract2,
+      subtract: subtract3,
       abs: abs2,
       atan: atan3,
       cos: cos2,
       sin: sin2,
       multiplyScalar: multiplyScalar2,
-      inv: inv2,
+      inv: inv3,
       bignumber: bignumber2,
       complex: complex3,
       multiply: multiply2,
-      add: add2
+      add: add3
     });
     const doComplexEigs = createComplexEigs({
       addScalar: addScalar2,
-      subtract: subtract2,
+      subtract: subtract3,
       multiply: multiply2,
       multiplyScalar: multiplyScalar2,
       flatten: flatten4,
@@ -38229,7 +38229,7 @@ var createEigs = /* @__PURE__ */ factory(
       size: size2,
       reshape: reshape3,
       qr: qr2,
-      inv: inv2,
+      inv: inv3,
       usolve: usolve2,
       usolveAll: usolveAll2,
       equal: equal2,
@@ -38237,7 +38237,7 @@ var createEigs = /* @__PURE__ */ factory(
       larger: larger2,
       smaller: smaller2,
       matrixFromColumns: matrixFromColumns2,
-      dot: dot5
+      dot: dot7
     });
     return typed3("eigs", {
       // The conversion to matrix in the first two implementations,
@@ -38318,7 +38318,7 @@ var createEigs = /* @__PURE__ */ factory(
     function isSymmetric(arr10, N, prec) {
       for (let i = 0; i < N; i++) {
         for (let j = i; j < N; j++) {
-          if (larger2(bignumber2(abs2(subtract2(arr10[i][j], arr10[j][i]))), prec)) {
+          if (larger2(bignumber2(abs2(subtract3(arr10[i][j], arr10[j][i]))), prec)) {
             return false;
           }
         }
@@ -38617,7 +38617,7 @@ var dependencies239 = ["typed", "matrix", "sqrt", "sum", "subtract", "multiply",
 var createCorr = /* @__PURE__ */ factory(
   name239,
   dependencies239,
-  ({ typed: typed3, matrix: matrix2, sqrt: sqrt2, sum: sum3, subtract: subtract2, multiply: multiply2, divide: divide2 }) => {
+  ({ typed: typed3, matrix: matrix2, sqrt: sqrt2, sum: sum3, subtract: subtract3, multiply: multiply2, divide: divide2 }) => {
     return typed3(name239, {
       "Array, Array": function(A, B) {
         return _corr(A, B);
@@ -38669,8 +38669,8 @@ var createCorr = /* @__PURE__ */ factory(
       }
       const meanX = divide2(sum3(A), n);
       const meanY = divide2(sum3(B), n);
-      const dX = A.map((x) => subtract2(x, meanX));
-      const dY = B.map((y) => subtract2(y, meanY));
+      const dX = A.map((x) => subtract3(x, meanX));
+      const dY = B.map((y) => subtract3(y, meanY));
       const sxy = sum3(dX.map((dx, i) => multiply2(dx, dY[i])));
       const sxx = sum3(dX.map((dx) => multiply2(dx, dx)));
       const syy = sum3(dY.map((dy) => multiply2(dy, dy)));
@@ -38694,7 +38694,7 @@ var dependencies240 = ["typed", "abs", "map", "median", "subtract"];
 var createMad = /* @__PURE__ */ factory(
   name240,
   dependencies240,
-  ({ typed: typed3, abs: abs2, map: map2, median: median2, subtract: subtract2 }) => {
+  ({ typed: typed3, abs: abs2, map: map2, median: median2, subtract: subtract3 }) => {
     return typed3(name240, {
       // mad([a, b, c, d, ...])
       "Array | Matrix": _mad,
@@ -38725,7 +38725,7 @@ var createMad = /* @__PURE__ */ factory(
         const med = median2(flat);
         return median2(
           map2(flat, function(value) {
-            return abs2(subtract2(value, med));
+            return abs2(subtract3(value, med));
           })
         );
       } catch (err) {
@@ -40239,7 +40239,7 @@ var createNorm = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     abs: abs2,
-    add: add2,
+    add: add3,
     pow: pow2,
     conj: conj3,
     sqrt: sqrt2,
@@ -40344,7 +40344,7 @@ var createNorm = /* @__PURE__ */ factory(
         if (!equalScalar3(p, 0)) {
           let n = 0;
           x.forEach(function(value) {
-            n = add2(pow2(abs2(value), p), n);
+            n = add3(pow2(abs2(value), p), n);
           }, true);
           return pow2(n, 1 / p);
         }
@@ -40355,7 +40355,7 @@ var createNorm = /* @__PURE__ */ factory(
     function _matrixNormFrobenius(x) {
       let fro = 0;
       x.forEach(function(value) {
-        fro = add2(fro, multiply2(value, conj3(value)));
+        fro = add3(fro, multiply2(value, conj3(value)));
       });
       return abs2(sqrt2(fro));
     }
@@ -40364,7 +40364,7 @@ var createNorm = /* @__PURE__ */ factory(
       let maxc = 0;
       x.forEach(function(value, index) {
         const j = index[1];
-        const cj = add2(c[j] || 0, abs2(value));
+        const cj = add3(c[j] || 0, abs2(value));
         if (larger2(cj, maxc)) {
           maxc = cj;
         }
@@ -40388,7 +40388,7 @@ var createNorm = /* @__PURE__ */ factory(
       let maxr = 0;
       x.forEach(function(value, index) {
         const i = index[0];
-        const ri = add2(r[i] || 0, abs2(value));
+        const ri = add3(r[i] || 0, abs2(value));
         if (larger2(ri, maxr)) {
           maxr = ri;
         }
@@ -41219,11 +41219,11 @@ var createSylvester = /* @__PURE__ */ factory(
     multiply: multiply2,
     range: range2,
     concat: concat3,
-    transpose: transpose4,
+    transpose: transpose5,
     index,
     subset: subset2,
-    add: add2,
-    subtract: subtract2,
+    add: add3,
+    subtract: subtract3,
     identity: identity2,
     lusolve: lusolve2,
     abs: abs2
@@ -41261,7 +41261,7 @@ var createSylvester = /* @__PURE__ */ factory(
       const sB = schur2(multiply2(-1, B));
       const G = sB.T;
       const V = sB.U;
-      const D = multiply2(multiply2(transpose4(U), C), V);
+      const D = multiply2(multiply2(transpose5(U), C), V);
       const all = range2(0, m);
       const y = [];
       const hc = (a, b) => concat3(a, b, 1);
@@ -41270,7 +41270,7 @@ var createSylvester = /* @__PURE__ */ factory(
         if (k < n - 1 && abs2(subset2(G, index(k + 1, k))) > 1e-5) {
           let RHS = vc(subset2(D, index(all, [k])), subset2(D, index(all, [k + 1])));
           for (let j = 0; j < k; j++) {
-            RHS = add2(
+            RHS = add3(
               RHS,
               vc(multiply2(y[j], subset2(G, index(j, k))), multiply2(y[j], subset2(G, index(j, k + 1))))
             );
@@ -41279,7 +41279,7 @@ var createSylvester = /* @__PURE__ */ factory(
           const gmk = multiply2(identity2(m), multiply2(-1, subset2(G, index(k + 1, k))));
           const gkm = multiply2(identity2(m), multiply2(-1, subset2(G, index(k, k + 1))));
           const gmm = multiply2(identity2(m), multiply2(-1, subset2(G, index(k + 1, k + 1))));
-          const LHS = vc(hc(add2(F, gkk), gmk), hc(gkm, add2(F, gmm)));
+          const LHS = vc(hc(add3(F, gkk), gmk), hc(gkm, add3(F, gmm)));
           const yAux = lusolve2(LHS, RHS);
           y[k] = yAux.subset(index(range2(0, m), [0]));
           y[k + 1] = yAux.subset(index(range2(m, 2 * m), [0]));
@@ -41287,15 +41287,15 @@ var createSylvester = /* @__PURE__ */ factory(
         } else {
           let RHS = subset2(D, index(all, [k]));
           for (let j = 0; j < k; j++) {
-            RHS = add2(RHS, multiply2(y[j], subset2(G, index(j, k))));
+            RHS = add3(RHS, multiply2(y[j], subset2(G, index(j, k))));
           }
           const gkk = subset2(G, index(k, k));
-          const LHS = subtract2(F, multiply2(gkk, identity2(m)));
+          const LHS = subtract3(F, multiply2(gkk, identity2(m)));
           y[k] = lusolve2(LHS, RHS);
         }
       }
       const Y = matrix2(matrixFromColumns2(...y));
-      const X = multiply2(U, multiply2(Y, transpose4(V)));
+      const X = multiply2(U, multiply2(Y, transpose5(V)));
       return X;
     }
   }
@@ -41307,21 +41307,21 @@ var dependencies253 = ["typed", "matrix", "sylvester", "multiply", "transpose"];
 var createLyap = /* @__PURE__ */ factory(
   name253,
   dependencies253,
-  ({ typed: typed3, matrix: matrix2, sylvester: sylvester2, multiply: multiply2, transpose: transpose4 }) => {
+  ({ typed: typed3, matrix: matrix2, sylvester: sylvester2, multiply: multiply2, transpose: transpose5 }) => {
     return typed3(name253, {
       "Matrix, Matrix": function(A, Q2) {
-        return sylvester2(A, transpose4(A), multiply2(-1, Q2));
+        return sylvester2(A, transpose5(A), multiply2(-1, Q2));
       },
       "Array, Matrix": function(A, Q2) {
-        return sylvester2(matrix2(A), transpose4(matrix2(A)), multiply2(-1, Q2));
+        return sylvester2(matrix2(A), transpose5(matrix2(A)), multiply2(-1, Q2));
       },
       "Matrix, Array": function(A, Q2) {
-        return sylvester2(A, transpose4(A), matrix2(multiply2(-1, Q2)));
+        return sylvester2(A, transpose5(A), matrix2(multiply2(-1, Q2)));
       },
       "Array, Array": function(A, Q2) {
         return sylvester2(
           matrix2(A),
-          transpose4(matrix2(A)),
+          transpose5(matrix2(A)),
           matrix2(multiply2(-1, Q2))
         ).toArray();
       }
@@ -43126,8 +43126,8 @@ function polyCoeffsDeg3(expr, varName) {
     const d2 = f[2] - 2 * f[1] + f[0];
     const d3 = f[3] - 3 * f[2] + 3 * f[1] - f[0];
     const d4 = f[4] - 4 * f[3] + 6 * f[2] - 4 * f[1] + f[0];
-    const scale = Math.max(1, ...f.map(Math.abs));
-    if (Math.abs(d4) > 1e-7 * scale) return null;
+    const scale3 = Math.max(1, ...f.map(Math.abs));
+    if (Math.abs(d4) > 1e-7 * scale3) return null;
     const c3 = d3 / 6;
     const c2 = d2 / 2 - d3 / 2;
     const c1 = d1 - d2 / 2 + d3 / 3;
@@ -45377,10 +45377,10 @@ function laplacianMatrix(adjacency, opts = {}) {
   const n = adjacency.length;
   const deg = adjacency.map((row2) => row2.reduce((s, v) => s + v, 0));
   if (opts.normalized) {
-    const inv2 = deg.map((d) => d > 0 ? 1 / Math.sqrt(d) : 0);
+    const inv3 = deg.map((d) => d > 0 ? 1 / Math.sqrt(d) : 0);
     return Array.from(
       { length: n },
-      (_, i) => Array.from({ length: n }, (_2, j) => (i === j ? 1 : 0) - inv2[i] * adjacency[i][j] * inv2[j])
+      (_, i) => Array.from({ length: n }, (_2, j) => (i === j ? 1 : 0) - inv3[i] * adjacency[i][j] * inv3[j])
     );
   }
   return Array.from(
@@ -45613,6 +45613,1096 @@ function fsolve(F, x0, opts = {}) {
 }
 var root = fsolve;
 
+// src/numeric/krylov.ts
+function isDenseMatrix2(a) {
+  return Array.isArray(a);
+}
+function toMatvec(a) {
+  if (!isDenseMatrix2(a)) return a;
+  const rows = a;
+  return (x) => {
+    const n = rows.length;
+    const y = new Array(n).fill(0);
+    for (let i = 0; i < n; i++) {
+      const row2 = rows[i];
+      let sum3 = 0;
+      for (let j = 0; j < row2.length; j++) sum3 += row2[j] * x[j];
+      y[i] = sum3;
+    }
+    return y;
+  };
+}
+function dot2(a, b) {
+  let s = 0;
+  for (let i = 0; i < a.length; i++) s += a[i] * b[i];
+  return s;
+}
+function norm25(a) {
+  return Math.sqrt(dot2(a, a));
+}
+function axpy(alpha, x, y) {
+  const n = x.length;
+  const out = new Array(n);
+  for (let i = 0; i < n; i++) out[i] = alpha * x[i] + y[i];
+  return out;
+}
+function scale(alpha, x) {
+  return x.map((v) => alpha * v);
+}
+function subtract2(a, b) {
+  return a.map((v, i) => v - b[i]);
+}
+function add2(a, b) {
+  return a.map((v, i) => v + b[i]);
+}
+function zeros2(n) {
+  return new Array(n).fill(0);
+}
+function resolvePreconditioner(a, preconditioner) {
+  if (preconditioner === void 0) return (r) => r.slice();
+  if (typeof preconditioner === "function") return preconditioner;
+  if (!isDenseMatrix2(a)) {
+    throw new Error(
+      "krylov: 'jacobi' preconditioner requires a dense matrix (need the diagonal) \u2014 pass a custom preconditioner function when using a matvec operator"
+    );
+  }
+  const n = a.length;
+  const invDiag = new Array(n);
+  for (let i = 0; i < n; i++) {
+    const d = a[i][i];
+    if (d === 0) {
+      throw new Error(
+        `krylov: Jacobi preconditioner requires a nonzero diagonal (A[${i}][${i}] = 0)`
+      );
+    }
+    invDiag[i] = 1 / d;
+  }
+  return (r) => r.map((v, i) => v * invDiag[i]);
+}
+function defaultMaxIter(n) {
+  return Math.min(n * 10, 1e3);
+}
+function relativeResidualNorm(rNorm, bNorm) {
+  return bNorm > 0 ? rNorm / bNorm : rNorm;
+}
+function relativeResidual(matvec2, x, b, bNorm) {
+  return relativeResidualNorm(norm25(subtract2(b, matvec2(x))), bNorm);
+}
+function cg(a, b, opts) {
+  const n = b.length;
+  const matvec2 = toMatvec(a);
+  const applyM = resolvePreconditioner(a, opts?.preconditioner);
+  const tol = opts?.tol ?? 1e-10;
+  const maxIter = opts?.maxIter ?? defaultMaxIter(n);
+  const bNorm = norm25(b);
+  let x = opts?.x0 ? opts.x0.slice() : zeros2(n);
+  let r = subtract2(b, matvec2(x));
+  let z = applyM(r);
+  let p = z.slice();
+  let rzOld = dot2(r, z);
+  let residual = relativeResidualNorm(norm25(r), bNorm);
+  if (residual < tol) {
+    return { x, iterations: 0, converged: true, residual };
+  }
+  let iterations = 0;
+  for (let iter = 1; iter <= maxIter; iter++) {
+    iterations = iter;
+    const Ap = matvec2(p);
+    const pAp = dot2(p, Ap);
+    if (Math.abs(pAp) < 1e-300) break;
+    const alpha = rzOld / pAp;
+    x = axpy(alpha, p, x);
+    r = axpy(-alpha, Ap, r);
+    residual = relativeResidualNorm(norm25(r), bNorm);
+    if (residual < tol) {
+      return { x, iterations, converged: true, residual };
+    }
+    z = applyM(r);
+    const rzNew = dot2(r, z);
+    const beta2 = rzNew / rzOld;
+    p = add2(z, scale(beta2, p));
+    rzOld = rzNew;
+  }
+  return { x, iterations, converged: residual < tol, residual };
+}
+function minres(a, b, opts) {
+  const n = b.length;
+  const matvec2 = toMatvec(a);
+  const applyM = resolvePreconditioner(a, opts?.preconditioner);
+  const tol = opts?.tol ?? 1e-10;
+  const maxIter = opts?.maxIter ?? defaultMaxIter(n);
+  const bNorm = norm25(b);
+  const x0 = opts?.x0 ? opts.x0.slice() : zeros2(n);
+  const r0 = subtract2(b, matvec2(x0));
+  let residual = relativeResidualNorm(norm25(r0), bNorm);
+  if (residual < tol) {
+    return { x: x0, iterations: 0, converged: true, residual };
+  }
+  const z0 = applyM(r0);
+  const beta1 = Math.sqrt(dot2(r0, z0));
+  if (beta1 < 1e-300) {
+    return { x: x0, iterations: 0, converged: residual < tol, residual };
+  }
+  const V = [zeros2(n), scale(1 / beta1, r0)];
+  const Z = [zeros2(n), scale(1 / beta1, z0)];
+  const alphas = [];
+  const betas = [beta1];
+  let bestX = x0.slice();
+  let bestResidual = residual;
+  let iterations = 0;
+  for (let k = 1; k <= maxIter; k++) {
+    iterations = k;
+    const vK = V[k];
+    const zK = Z[k];
+    const vKm1 = V[k - 1];
+    const betaK = betas[k - 1];
+    let p = matvec2(zK);
+    p = subtract2(p, scale(betaK, vKm1));
+    const alphaK = dot2(p, zK);
+    alphas.push(alphaK);
+    p = subtract2(p, scale(alphaK, vK));
+    const zRaw = applyM(p);
+    const betaNext = Math.sqrt(Math.max(0, dot2(p, zRaw)));
+    const T = Array.from({ length: k + 1 }, () => new Array(k).fill(0));
+    for (let i = 0; i < k; i++) {
+      T[i][i] = alphas[i];
+      if (i + 1 < k) {
+        T[i + 1][i] = betas[i + 1];
+        T[i][i + 1] = betas[i + 1];
+      }
+    }
+    T[k][k - 1] = betaNext;
+    const rhs = new Array(k + 1).fill(0);
+    rhs[0] = beta1;
+    const y = solveLeastSquaresQR(T, rhs);
+    let xCandidate = x0.slice();
+    for (let i = 0; i < k; i++) {
+      xCandidate = axpy(y[i], Z[i + 1], xCandidate);
+    }
+    residual = relativeResidual(matvec2, xCandidate, b, bNorm);
+    if (residual < bestResidual) {
+      bestResidual = residual;
+      bestX = xCandidate;
+    }
+    if (residual < tol) {
+      return { x: xCandidate, iterations: k, converged: true, residual };
+    }
+    if (betaNext < 1e-300) break;
+    betas.push(betaNext);
+    V.push(scale(1 / betaNext, p));
+    Z.push(scale(1 / betaNext, zRaw));
+  }
+  return { x: bestX, iterations, converged: bestResidual < tol, residual: bestResidual };
+}
+function solveLeastSquaresQR(T, rhs) {
+  const m = T.length;
+  const n = T[0]?.length ?? 0;
+  const R = T.map((row2) => row2.slice());
+  const c = rhs.slice();
+  for (let k = 0; k < n; k++) {
+    let normX = 0;
+    for (let i = k; i < m; i++) normX += R[i][k] * R[i][k];
+    normX = Math.sqrt(normX);
+    if (normX < 1e-300) continue;
+    const alpha = R[k][k] >= 0 ? -normX : normX;
+    const v = new Array(m).fill(0);
+    v[k] = R[k][k] - alpha;
+    for (let i = k + 1; i < m; i++) v[i] = R[i][k];
+    let vNormSq = 0;
+    for (let i = k; i < m; i++) vNormSq += v[i] * v[i];
+    if (vNormSq < 1e-300) continue;
+    for (let j = k; j < n; j++) {
+      let dotVR = 0;
+      for (let i = k; i < m; i++) dotVR += v[i] * R[i][j];
+      const factor2 = 2 * dotVR / vNormSq;
+      for (let i = k; i < m; i++) R[i][j] -= factor2 * v[i];
+    }
+    let dotVC = 0;
+    for (let i = k; i < m; i++) dotVC += v[i] * c[i];
+    const factorC = 2 * dotVC / vNormSq;
+    for (let i = k; i < m; i++) c[i] -= factorC * v[i];
+  }
+  const y = new Array(n).fill(0);
+  for (let i = n - 1; i >= 0; i--) {
+    let sum3 = c[i];
+    for (let j = i + 1; j < n; j++) sum3 -= R[i][j] * y[j];
+    y[i] = Math.abs(R[i][i]) > 1e-300 ? sum3 / R[i][i] : 0;
+  }
+  return y;
+}
+function gmres(a, b, opts) {
+  const n = b.length;
+  const matvec2 = toMatvec(a);
+  const applyM = resolvePreconditioner(a, opts?.preconditioner);
+  const tol = opts?.tol ?? 1e-10;
+  const maxIter = opts?.maxIter ?? defaultMaxIter(n);
+  const restart = Math.max(1, Math.min(opts?.restart ?? 30, n));
+  const bNorm = norm25(b);
+  let x = opts?.x0 ? opts.x0.slice() : zeros2(n);
+  let totalIterations = 0;
+  let residual = relativeResidual(matvec2, x, b, bNorm);
+  if (residual < tol) {
+    return { x, iterations: 0, converged: true, residual };
+  }
+  while (totalIterations < maxIter) {
+    const r0 = applyM(subtract2(b, matvec2(x)));
+    const beta2 = norm25(r0);
+    if (beta2 < 1e-300) {
+      return { x, iterations: totalIterations, converged: residual < tol, residual };
+    }
+    const m = Math.min(restart, maxIter - totalIterations);
+    const V = [scale(1 / beta2, r0)];
+    const H = Array.from({ length: m + 1 }, () => new Array(m).fill(0));
+    const g = new Array(m + 1).fill(0);
+    g[0] = beta2;
+    const cs = new Array(m).fill(0);
+    const sn = new Array(m).fill(0);
+    let k = 0;
+    for (; k < m; k++) {
+      totalIterations++;
+      let w = applyM(matvec2(V[k]));
+      for (let i = 0; i <= k; i++) {
+        H[i][k] = dot2(w, V[i]);
+        w = axpy(-H[i][k], V[i], w);
+      }
+      H[k + 1][k] = norm25(w);
+      V.push(H[k + 1][k] > 1e-300 ? scale(1 / H[k + 1][k], w) : zeros2(n));
+      for (let i = 0; i < k; i++) {
+        const temp2 = cs[i] * H[i][k] + sn[i] * H[i + 1][k];
+        H[i + 1][k] = -sn[i] * H[i][k] + cs[i] * H[i + 1][k];
+        H[i][k] = temp2;
+      }
+      const denom = Math.sqrt(H[k][k] * H[k][k] + H[k + 1][k] * H[k + 1][k]);
+      if (denom < 1e-300) {
+        cs[k] = 1;
+        sn[k] = 0;
+      } else {
+        cs[k] = H[k][k] / denom;
+        sn[k] = H[k + 1][k] / denom;
+      }
+      H[k][k] = cs[k] * H[k][k] + sn[k] * H[k + 1][k];
+      H[k + 1][k] = 0;
+      const temp = cs[k] * g[k] + sn[k] * g[k + 1];
+      g[k + 1] = -sn[k] * g[k] + cs[k] * g[k + 1];
+      g[k] = temp;
+      residual = relativeResidualNorm(Math.abs(g[k + 1]), bNorm);
+      if (residual < tol) {
+        k++;
+        break;
+      }
+    }
+    const y = new Array(k).fill(0);
+    for (let i = k - 1; i >= 0; i--) {
+      let sum3 = g[i];
+      for (let j = i + 1; j < k; j++) sum3 -= H[i][j] * y[j];
+      y[i] = Math.abs(H[i][i]) > 1e-300 ? sum3 / H[i][i] : 0;
+    }
+    for (let i = 0; i < k; i++) {
+      x = axpy(y[i], V[i], x);
+    }
+    residual = relativeResidual(matvec2, x, b, bNorm);
+    if (residual < tol || k < m) {
+      return { x, iterations: totalIterations, converged: residual < tol, residual };
+    }
+  }
+  return { x, iterations: totalIterations, converged: residual < tol, residual };
+}
+function bicgstab(a, b, opts) {
+  const n = b.length;
+  const matvec2 = toMatvec(a);
+  const applyM = resolvePreconditioner(a, opts?.preconditioner);
+  const tol = opts?.tol ?? 1e-10;
+  const maxIter = opts?.maxIter ?? defaultMaxIter(n);
+  const bNorm = norm25(b);
+  let x = opts?.x0 ? opts.x0.slice() : zeros2(n);
+  let r = subtract2(b, matvec2(x));
+  const rHat0 = r.slice();
+  let residual = relativeResidualNorm(norm25(r), bNorm);
+  if (residual < tol) {
+    return { x, iterations: 0, converged: true, residual };
+  }
+  let rho = 1;
+  let alpha = 1;
+  let omega = 1;
+  let v = zeros2(n);
+  let p = zeros2(n);
+  let iterations = 0;
+  for (let iter = 1; iter <= maxIter; iter++) {
+    iterations = iter;
+    const rhoNew = dot2(rHat0, r);
+    if (Math.abs(rhoNew) < 1e-300) break;
+    if (iter === 1) {
+      p = r.slice();
+    } else {
+      const beta2 = rhoNew / rho * (alpha / omega);
+      p = add2(r, scale(beta2, subtract2(p, scale(omega, v))));
+    }
+    rho = rhoNew;
+    const pHat = applyM(p);
+    v = matvec2(pHat);
+    const rHatV = dot2(rHat0, v);
+    if (Math.abs(rHatV) < 1e-300) break;
+    alpha = rho / rHatV;
+    const s = axpy(-alpha, v, r);
+    const sNorm = relativeResidualNorm(norm25(s), bNorm);
+    if (sNorm < tol) {
+      x = axpy(alpha, pHat, x);
+      residual = sNorm;
+      return { x, iterations, converged: true, residual };
+    }
+    const sHat = applyM(s);
+    const t = matvec2(sHat);
+    const tt = dot2(t, t);
+    omega = tt > 1e-300 ? dot2(t, s) / tt : 0;
+    x = axpy(alpha, pHat, x);
+    x = axpy(omega, sHat, x);
+    r = axpy(-omega, t, s);
+    residual = relativeResidualNorm(norm25(r), bNorm);
+    if (residual < tol) {
+      return { x, iterations, converged: true, residual };
+    }
+    if (Math.abs(omega) < 1e-300) break;
+  }
+  return { x, iterations, converged: residual < tol, residual };
+}
+
+// src/numeric/eigsh.ts
+function isDenseMatrix3(a) {
+  return Array.isArray(a);
+}
+function toMatvecAndSize(a, nOpt) {
+  if (isDenseMatrix3(a)) {
+    const rows = a;
+    const n = rows.length;
+    if (n === 0 || rows.some((row2) => row2.length !== n)) {
+      throw new Error("eigsh: dense matrix input must be square and non-empty");
+    }
+    return {
+      n,
+      matvec: (x) => rows.map((row2) => row2.reduce((s, v, j) => s + v * x[j], 0))
+    };
+  }
+  if (nOpt === void 0) {
+    throw new Error(
+      "eigsh: a matvec operator requires opts.n (the matrix dimension) since it cannot be inferred from a function"
+    );
+  }
+  return { matvec: a, n: nOpt };
+}
+function dot3(a, b) {
+  let s = 0;
+  for (let i = 0; i < a.length; i++) s += a[i] * b[i];
+  return s;
+}
+function norm26(a) {
+  return Math.sqrt(dot3(a, a));
+}
+function axpy2(alpha, x, y) {
+  const out = new Array(x.length);
+  for (let i = 0; i < x.length; i++) out[i] = alpha * x[i] + y[i];
+  return out;
+}
+function scale2(alpha, x) {
+  return x.map((v) => alpha * v);
+}
+function startVector(n) {
+  const v = new Array(n);
+  for (let i = 0; i < n; i++) v[i] = Math.sin(i + 1);
+  const nrm = norm26(v);
+  return nrm > 1e-300 ? scale2(1 / nrm, v) : v.map((_, i) => i === 0 ? 1 : 0);
+}
+function lanczos(matvec2, n, m) {
+  const V = [startVector(n)];
+  const alphas = [];
+  const betas = [];
+  for (let j = 0; j < m; j++) {
+    const vj = V[j];
+    let w = matvec2(vj);
+    if (j > 0) w = axpy2(-betas[j - 1], V[j - 1], w);
+    const alpha = dot3(w, vj);
+    alphas.push(alpha);
+    w = axpy2(-alpha, vj, w);
+    for (let pass = 0; pass < 2; pass++) {
+      for (let i = 0; i <= j; i++) {
+        const c = dot3(w, V[i]);
+        w = axpy2(-c, V[i], w);
+      }
+    }
+    const beta2 = norm26(w);
+    if (j === m - 1 || beta2 < 1e-13) break;
+    betas.push(beta2);
+    V.push(scale2(1 / beta2, w));
+  }
+  return { V, alphas, betas };
+}
+function jacobiEigenSymmetric(input, tol) {
+  const n = input.length;
+  const a = input.map((row2) => row2.slice());
+  const v = Array.from(
+    { length: n },
+    (_, i) => Array.from({ length: n }, (_2, j) => i === j ? 1 : 0)
+  );
+  const maxSweeps = 100;
+  for (let sweep = 0; sweep < maxSweeps; sweep++) {
+    let offDiagSumSq = 0;
+    for (let p = 0; p < n; p++) {
+      for (let q = p + 1; q < n; q++) offDiagSumSq += a[p][q] * a[p][q];
+    }
+    if (offDiagSumSq < tol * tol) break;
+    for (let p = 0; p < n; p++) {
+      for (let q = p + 1; q < n; q++) {
+        const apq = a[p][q];
+        if (Math.abs(apq) < 1e-300) continue;
+        const theta = (a[q][q] - a[p][p]) / (2 * apq);
+        const sign3 = theta === 0 ? 1 : Math.sign(theta);
+        const t = sign3 / (Math.abs(theta) + Math.sqrt(theta * theta + 1));
+        const c = 1 / Math.sqrt(t * t + 1);
+        const s = t * c;
+        const app = a[p][p];
+        const aqq = a[q][q];
+        a[p][p] = c * c * app - 2 * s * c * apq + s * s * aqq;
+        a[q][q] = s * s * app + 2 * s * c * apq + c * c * aqq;
+        a[p][q] = 0;
+        a[q][p] = 0;
+        for (let i = 0; i < n; i++) {
+          if (i === p || i === q) continue;
+          const aip = a[i][p];
+          const aiq = a[i][q];
+          a[i][p] = c * aip - s * aiq;
+          a[p][i] = a[i][p];
+          a[i][q] = s * aip + c * aiq;
+          a[q][i] = a[i][q];
+        }
+        for (let i = 0; i < n; i++) {
+          const vip = v[i][p];
+          const viq = v[i][q];
+          v[i][p] = c * vip - s * viq;
+          v[i][q] = s * vip + c * viq;
+        }
+      }
+    }
+  }
+  const values = new Array(n);
+  for (let i = 0; i < n; i++) values[i] = a[i][i];
+  return { values, vectors: v };
+}
+function eigsh(a, k = 1, opts) {
+  const which = opts?.which ?? "LM";
+  const { matvec: matvec2, n } = toMatvecAndSize(a, opts?.n);
+  if (!Number.isInteger(k) || k < 1 || k > n) {
+    throw new Error(`eigsh: k must be an integer between 1 and n (n=${n}), got ${k}`);
+  }
+  const tol = opts?.tol ?? 1e-10;
+  const m = Math.min(opts?.maxIter ?? Math.max(2 * k + 20, 20), n);
+  const { V, alphas, betas } = lanczos(matvec2, n, m);
+  const size2 = alphas.length;
+  if (k > size2) {
+    throw new Error(
+      `eigsh: Lanczos basis collapsed to ${size2} vectors (invariant subspace) before ${k} eigenpairs could be extracted`
+    );
+  }
+  const T = Array.from({ length: size2 }, () => new Array(size2).fill(0));
+  for (let i = 0; i < size2; i++) {
+    T[i][i] = alphas[i];
+    if (i + 1 < size2) {
+      T[i][i + 1] = betas[i];
+      T[i + 1][i] = betas[i];
+    }
+  }
+  const { values, vectors } = jacobiEigenSymmetric(T, tol);
+  const order = values.map((value, index) => ({ value, index })).sort((a1, b1) => which === "LM" ? b1.value - a1.value : a1.value - b1.value);
+  const eigenvalues = order.slice(0, k).map((o) => o.value);
+  const eigenvectors = Array.from({ length: n }, () => new Array(k).fill(0));
+  for (let col = 0; col < k; col++) {
+    const ritzIndex = order[col].index;
+    let full = new Array(n).fill(0);
+    for (let i = 0; i < size2; i++) {
+      full = axpy2(vectors[i][ritzIndex], V[i], full);
+    }
+    const nrm = norm26(full);
+    if (nrm > 1e-300) full = scale2(1 / nrm, full);
+    for (let row2 = 0; row2 < n; row2++) eigenvectors[row2][col] = full[row2];
+  }
+  return { eigenvalues, eigenvectors };
+}
+
+// src/numeric/structured-solvers.ts
+function thomasSolve(sub, diag2, sup, d) {
+  const n = diag2.length;
+  if (n === 0) return [];
+  if (sub.length !== n - 1 || sup.length !== n - 1 || d.length !== n) {
+    throw new Error(
+      `thomasSolve: expected sub/sup of length ${n - 1} and d of length ${n}, got sub=${sub.length}, sup=${sup.length}, d=${d.length}`
+    );
+  }
+  const cp = new Array(n).fill(0);
+  const dp = new Array(n).fill(0);
+  if (diag2[0] === 0) throw new Error("thomasSolve: zero pivot at row 0 (no pivoting is performed)");
+  cp[0] = n > 1 ? sup[0] / diag2[0] : 0;
+  dp[0] = d[0] / diag2[0];
+  for (let i = 1; i < n; i++) {
+    const m = diag2[i] - sub[i - 1] * cp[i - 1];
+    if (m === 0) {
+      throw new Error(`thomasSolve: zero pivot at row ${i} (no pivoting is performed)`);
+    }
+    cp[i] = i < n - 1 ? sup[i] / m : 0;
+    dp[i] = (d[i] - sub[i - 1] * dp[i - 1]) / m;
+  }
+  const x = new Array(n);
+  x[n - 1] = dp[n - 1];
+  for (let i = n - 2; i >= 0; i--) {
+    x[i] = dp[i] - cp[i] * x[i + 1];
+  }
+  return x;
+}
+function solveBanded(l, u, A, b) {
+  const n = A.length;
+  if (b.length !== n) {
+    throw new Error(`solveBanded: A is ${n}x? but b has length ${b.length}`);
+  }
+  for (const row2 of A) {
+    if (row2.length !== n) throw new Error("solveBanded: A must be a square dense matrix");
+  }
+  const W = A.map((row2) => row2.slice());
+  const rhs = b.slice();
+  for (let k = 0; k < n - 1; k++) {
+    const pivot = W[k][k];
+    if (pivot === 0)
+      throw new Error(`solveBanded: zero pivot at row ${k} (no pivoting is performed)`);
+    const iMax = Math.min(n - 1, k + l);
+    const jMax = Math.min(n - 1, k + u);
+    for (let i = k + 1; i <= iMax; i++) {
+      const factor2 = W[i][k] / pivot;
+      if (factor2 === 0) continue;
+      for (let j = k; j <= jMax; j++) {
+        W[i][j] -= factor2 * W[k][j];
+      }
+      rhs[i] -= factor2 * rhs[k];
+    }
+  }
+  const x = new Array(n).fill(0);
+  for (let i = n - 1; i >= 0; i--) {
+    let sum3 = rhs[i];
+    const jMax = Math.min(n - 1, i + u);
+    for (let j = i + 1; j <= jMax; j++) {
+      sum3 -= W[i][j] * x[j];
+    }
+    if (W[i][i] === 0)
+      throw new Error(`solveBanded: zero pivot at row ${i} during back-substitution`);
+    x[i] = sum3 / W[i][i];
+  }
+  return x;
+}
+function toeplitzSolve(c, r, b) {
+  const n = b.length;
+  if (c.length !== n || r.length !== n) {
+    throw new Error(
+      `toeplitzSolve: expected c and r of length ${n}, got c=${c.length}, r=${r.length}`
+    );
+  }
+  if (Math.abs(c[0] - r[0]) > 1e-12 * (Math.abs(c[0]) + Math.abs(r[0]) + 1)) {
+    throw new Error(`toeplitzSolve: c[0] (${c[0]}) must equal r[0] (${r[0]})`);
+  }
+  const c0 = c[0];
+  if (c0 === 0) throw new Error("toeplitzSolve: zero diagonal (c[0] === 0)");
+  let x = [b[0] / c0];
+  if (n === 1) return x;
+  let f = [c[1] / c0];
+  let fs = [r[1] / c0];
+  for (let m = 1; m < n; m++) {
+    const v = new Array(m);
+    const u = new Array(m);
+    for (let j = 0; j < m; j++) {
+      v[j] = c[m - j];
+      u[j] = r[m - j];
+    }
+    const A = new Array(m);
+    const Astar = new Array(m);
+    for (let i = 0; i < m; i++) {
+      A[i] = fs[m - 1 - i];
+      Astar[i] = f[m - 1 - i];
+    }
+    let vDotA = 0;
+    let vDotX = 0;
+    for (let i = 0; i < m; i++) {
+      vDotA += v[i] * A[i];
+      vDotX += v[i] * x[i];
+    }
+    const delta = c0 - vDotA;
+    if (delta === 0) throw new Error(`toeplitzSolve: breakdown at order ${m + 1} (zero pivot)`);
+    const qx = (b[m] - vDotX) / delta;
+    const xNew = new Array(m + 1);
+    for (let i = 0; i < m; i++) xNew[i] = x[i] - qx * A[i];
+    xNew[m] = qx;
+    x = xNew;
+    if (m + 1 < n) {
+      let vDotF = 0;
+      let uDotFs = 0;
+      for (let i = 0; i < m; i++) {
+        vDotF += v[i] * f[i];
+        uDotFs += u[i] * fs[i];
+      }
+      const qf = (c[m + 1] - vDotF) / delta;
+      const qfs = (r[m + 1] - uDotFs) / delta;
+      const fNew = new Array(m + 1);
+      const fsNew = new Array(m + 1);
+      for (let i = 0; i < m; i++) {
+        fNew[i] = f[i] - qf * A[i];
+        fsNew[i] = fs[i] - qfs * Astar[i];
+      }
+      fNew[m] = qf;
+      fsNew[m] = qfs;
+      f = fNew;
+      fs = fsNew;
+    }
+  }
+  return x;
+}
+function ldl(A) {
+  const n = A.length;
+  for (const row2 of A) {
+    if (row2.length !== n) throw new Error("ldl: A must be a square matrix");
+  }
+  const W = A.map((row2) => row2.slice());
+  const L = Array.from({ length: n }, () => new Array(n).fill(0));
+  const D = Array.from({ length: n }, () => new Array(n).fill(0));
+  const perm = Array.from({ length: n }, (_, i) => i);
+  const swap = (a, b) => {
+    if (a === b) return;
+    [perm[a], perm[b]] = [perm[b], perm[a]];
+    [W[a], W[b]] = [W[b], W[a]];
+    for (let i = 0; i < n; i++) [W[i][a], W[i][b]] = [W[i][b], W[i][a]];
+    [L[a], L[b]] = [L[b], L[a]];
+  };
+  const alpha = (1 + Math.sqrt(17)) / 8;
+  let k = 0;
+  while (k < n) {
+    if (k === n - 1) {
+      L[k][k] = 1;
+      D[k][k] = W[k][k];
+      k += 1;
+      continue;
+    }
+    const w1 = Math.abs(W[k][k]);
+    let r = k + 1;
+    let lambda = Math.abs(W[k + 1][k]);
+    for (let i = k + 2; i < n; i++) {
+      const val = Math.abs(W[i][k]);
+      if (val > lambda) {
+        lambda = val;
+        r = i;
+      }
+    }
+    let use1x1 = true;
+    let swapWith = -1;
+    if (lambda !== 0 && w1 < alpha * lambda) {
+      let sigma = 0;
+      for (let i = k; i < n; i++) {
+        if (i !== r) sigma = Math.max(sigma, Math.abs(W[i][r]));
+      }
+      if (w1 * sigma < alpha * lambda * lambda) {
+        if (Math.abs(W[r][r]) >= alpha * sigma) {
+          swapWith = r;
+        } else {
+          use1x1 = false;
+          swapWith = r;
+        }
+      }
+    }
+    if (use1x1) {
+      if (swapWith >= 0) swap(k, swapWith);
+      const d = W[k][k];
+      L[k][k] = 1;
+      D[k][k] = d;
+      if (d === 0) throw new Error(`ldl: singular 1x1 pivot at step ${k}`);
+      for (let i = k + 1; i < n; i++) L[i][k] = W[i][k] / d;
+      for (let i = k + 1; i < n; i++) {
+        for (let j = k + 1; j < n; j++) {
+          W[i][j] -= L[i][k] * d * L[j][k];
+        }
+      }
+      k += 1;
+    } else {
+      swap(k + 1, swapWith);
+      const a = W[k][k];
+      const bVal = W[k][k + 1];
+      const cVal = W[k + 1][k];
+      const dd = W[k + 1][k + 1];
+      const det2 = a * dd - bVal * cVal;
+      if (det2 === 0) throw new Error(`ldl: singular 2x2 pivot at step ${k}`);
+      D[k][k] = a;
+      D[k][k + 1] = bVal;
+      D[k + 1][k] = cVal;
+      D[k + 1][k + 1] = dd;
+      L[k][k] = 1;
+      L[k + 1][k + 1] = 1;
+      for (let i = k + 2; i < n; i++) {
+        const wi0 = W[i][k];
+        const wi1 = W[i][k + 1];
+        L[i][k] = (wi0 * dd - wi1 * cVal) / det2;
+        L[i][k + 1] = (-wi0 * bVal + wi1 * a) / det2;
+      }
+      for (let i = k + 2; i < n; i++) {
+        for (let j = k + 2; j < n; j++) {
+          const upd = L[i][k] * (a * L[j][k] + bVal * L[j][k + 1]) + L[i][k + 1] * (cVal * L[j][k] + dd * L[j][k + 1]);
+          W[i][j] -= upd;
+        }
+      }
+      k += 2;
+    }
+  }
+  return { L, D, perm };
+}
+
+// src/numeric/matrix-functions.ts
+import { eig as eig3 } from "@danielsimonjr/mathts-matrix";
+function cSub(a, b) {
+  return { re: a.re - b.re, im: a.im - b.im };
+}
+function cMul(a, b) {
+  return { re: a.re * b.re - a.im * b.im, im: a.re * b.im + a.im * b.re };
+}
+function cDiv(a, b) {
+  const d = b.re * b.re + b.im * b.im;
+  return { re: (a.re * b.re + a.im * b.im) / d, im: (a.im * b.re - a.re * b.im) / d };
+}
+function cAbs(a) {
+  return Math.hypot(a.re, a.im);
+}
+function cZeros(n) {
+  return {
+    re: Array.from({ length: n }, () => new Array(n).fill(0)),
+    im: Array.from({ length: n }, () => new Array(n).fill(0))
+  };
+}
+function cFromReal(A) {
+  const n = A.length;
+  return {
+    re: A.map((row2) => row2.slice()),
+    im: Array.from({ length: n }, () => new Array(n).fill(0))
+  };
+}
+function cShiftedReal(A, lambda) {
+  const n = A.length;
+  const re3 = A.map((row2) => row2.slice());
+  const im3 = Array.from({ length: n }, () => new Array(n).fill(0));
+  for (let i = 0; i < n; i++) {
+    re3[i][i] -= lambda.re;
+    im3[i][i] -= lambda.im;
+  }
+  return { re: re3, im: im3 };
+}
+function cMatMul(X, Y) {
+  const n = X.re.length;
+  const out = cZeros(n);
+  for (let i = 0; i < n; i++) {
+    for (let k = 0; k < n; k++) {
+      const xr = X.re[i][k];
+      const xi = X.im[i][k];
+      if (xr === 0 && xi === 0) continue;
+      for (let j = 0; j < n; j++) {
+        const yr = Y.re[k][j];
+        const yi = Y.im[k][j];
+        out.re[i][j] += xr * yr - xi * yi;
+        out.im[i][j] += xr * yi + xi * yr;
+      }
+    }
+  }
+  return out;
+}
+function cMatScalarDiv(X, s) {
+  const n = X.re.length;
+  const out = cZeros(n);
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < n; j++) {
+      const q = cDiv({ re: X.re[i][j], im: X.im[i][j] }, s);
+      out.re[i][j] = q.re;
+      out.im[i][j] = q.im;
+    }
+  }
+  return out;
+}
+function cAccumulate(F, s, M) {
+  const n = F.re.length;
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < n; j++) {
+      const term = cMul(s, { re: M.re[i][j], im: M.im[i][j] });
+      F.re[i][j] += term.re;
+      F.im[i][j] += term.im;
+    }
+  }
+}
+var EIGENVALUE_DISTINCT_REL_TOL = 1e-8;
+function isDiagonal(A, n) {
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < n; j++) {
+      if (i !== j && A[i][j] !== 0) return false;
+    }
+  }
+  return true;
+}
+function funm(A, f) {
+  const n = A.length;
+  if (n === 0) return { re: [], im: [] };
+  for (const row2 of A) {
+    if (row2.length !== n) throw new Error(`funm: matrix must be square (got ${n}x${row2.length})`);
+  }
+  if (isDiagonal(A, n)) {
+    const out = cZeros(n);
+    for (let i = 0; i < n; i++) {
+      const fi = f({ re: A[i][i], im: 0 });
+      out.re[i][i] = fi.re;
+      out.im[i][i] = fi.im;
+    }
+    return out;
+  }
+  const { values } = eig3(A, { computeVectors: false });
+  const maxAbs = values.reduce((m, v) => Math.max(m, cAbs(v)), 0);
+  const tol = EIGENVALUE_DISTINCT_REL_TOL * Math.max(1, maxAbs);
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      if (cAbs(cSub(values[i], values[j])) < tol) {
+        throw new Error(
+          "funm: matrix has repeated (or numerically indistinguishable) eigenvalues and is not diagonal \u2014 defective/non-diagonalizable matrices are not supported (Schur-Parlett block recurrence not yet implemented)"
+        );
+      }
+    }
+  }
+  const F = cZeros(n);
+  for (let i = 0; i < n; i++) {
+    const lambdaI = values[i];
+    let numerator = cFromReal(A);
+    let denom = { re: 1, im: 0 };
+    let first = true;
+    for (let j = 0; j < n; j++) {
+      if (j === i) continue;
+      const factor2 = cShiftedReal(A, values[j]);
+      numerator = first ? factor2 : cMatMul(numerator, factor2);
+      first = false;
+      denom = cMul(denom, cSub(lambdaI, values[j]));
+    }
+    cAccumulate(F, f(lambdaI), cMatScalarDiv(numerator, denom));
+  }
+  return F;
+}
+function complexCos(z) {
+  return {
+    re: Math.cos(z.re) * Math.cosh(z.im),
+    im: -Math.sin(z.re) * Math.sinh(z.im)
+  };
+}
+function complexSin(z) {
+  return {
+    re: Math.sin(z.re) * Math.cosh(z.im),
+    im: Math.cos(z.re) * Math.sinh(z.im)
+  };
+}
+function cosm(A) {
+  return funm(A, complexCos);
+}
+function sinm(A) {
+  return funm(A, complexSin);
+}
+
+// src/numeric/control-equations.ts
+function assertSquare2(A, name254) {
+  const n = A.length;
+  if (n === 0) throw new Error(`${name254}: empty matrix`);
+  for (const row2 of A) {
+    if (row2.length !== n)
+      throw new Error(`${name254}: matrix must be square (got ${n}x${row2.length})`);
+  }
+  return n;
+}
+function zeros3(rows, cols) {
+  return Array.from({ length: rows }, () => new Array(cols).fill(0));
+}
+function eye2(n) {
+  const I2 = zeros3(n, n);
+  for (let i = 0; i < n; i++) I2[i][i] = 1;
+  return I2;
+}
+function transpose3(A) {
+  const n = A.length;
+  const m = A[0].length;
+  const T = zeros3(m, n);
+  for (let i = 0; i < n; i++) for (let j = 0; j < m; j++) T[j][i] = A[i][j];
+  return T;
+}
+function matmul2(A, B) {
+  const n = A.length;
+  const k = B.length;
+  const m = B[0].length;
+  const C = zeros3(n, m);
+  for (let i = 0; i < n; i++) {
+    for (let p = 0; p < k; p++) {
+      const a = A[i][p];
+      if (a === 0) continue;
+      for (let j = 0; j < m; j++) C[i][j] += a * B[p][j];
+    }
+  }
+  return C;
+}
+function matadd(A, B, s = 1) {
+  const n = A.length;
+  const m = A[0].length;
+  const C = zeros3(n, m);
+  for (let i = 0; i < n; i++) for (let j = 0; j < m; j++) C[i][j] = A[i][j] + s * B[i][j];
+  return C;
+}
+function matScale(A, s) {
+  return A.map((row2) => row2.map((v) => v * s));
+}
+function inv2(A) {
+  const n = A.length;
+  const Inv = zeros3(n, n);
+  for (let j = 0; j < n; j++) {
+    const e = new Array(n).fill(0);
+    e[j] = 1;
+    const col = linsolve(A, e);
+    for (let i = 0; i < n; i++) Inv[i][j] = col[i];
+  }
+  return Inv;
+}
+function norm1(A) {
+  const n = A.length;
+  const m = A[0].length;
+  let maxSum = 0;
+  for (let j = 0; j < m; j++) {
+    let s = 0;
+    for (let i = 0; i < n; i++) s += Math.abs(A[i][j]);
+    maxSum = Math.max(maxSum, s);
+  }
+  return maxSum;
+}
+function symmetrize(X) {
+  return matScale(matadd(X, transpose3(X)), 0.5);
+}
+function maxAbsDiff(A, B) {
+  const n = A.length;
+  const m = A[0].length;
+  let d = 0;
+  for (let i = 0; i < n; i++)
+    for (let j = 0; j < m; j++) d = Math.max(d, Math.abs(A[i][j] - B[i][j]));
+  return d;
+}
+function sylvesterOperator(M, N) {
+  const n = M.length;
+  const n26 = n * n;
+  const L = zeros3(n26, n26);
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < n; j++) {
+      const row2 = i * n + j;
+      for (let p = 0; p < n; p++) {
+        const mip = M[i][p];
+        if (mip === 0) continue;
+        for (let q = 0; q < n; q++) {
+          L[row2][p * n + q] = mip * N[q][j];
+        }
+      }
+    }
+  }
+  return L;
+}
+function vecRowMajor(Q2) {
+  const n = Q2.length;
+  const v = new Array(n * n);
+  for (let i = 0; i < n; i++) for (let j = 0; j < n; j++) v[i * n + j] = Q2[i][j];
+  return v;
+}
+function unvecRowMajor(v, n) {
+  const X = zeros3(n, n);
+  for (let i = 0; i < n; i++) for (let j = 0; j < n; j++) X[i][j] = v[i * n + j];
+  return X;
+}
+function dlyap(A, Q2) {
+  const n = assertSquare2(A, "dlyap");
+  assertSquare2(Q2, "dlyap");
+  if (Q2.length !== n) throw new Error("dlyap: A and Q must have the same size");
+  const L = sylvesterOperator(A, transpose3(A));
+  const n26 = n * n;
+  const M = zeros3(n26, n26);
+  for (let r = 0; r < n26; r++) {
+    for (let c = 0; c < n26; c++) {
+      M[r][c] = (r === c ? 1 : 0) - L[r][c];
+    }
+  }
+  const vecQ = vecRowMajor(Q2);
+  const vecX = linsolve(M, vecQ);
+  return symmetrize(unvecRowMajor(vecX, n));
+}
+var RICCATI_MAX_ITER = 100;
+var RICCATI_TOL = 1e-13;
+function care(A, B, Q2, R) {
+  const n = assertSquare2(A, "care");
+  assertSquare2(Q2, "care");
+  if (Q2.length !== n) throw new Error("care: A and Q must have the same size");
+  if (B.length !== n) throw new Error("care: B must have n rows (n = size of A)");
+  const m = B[0]?.length ?? 0;
+  assertSquare2(R, "care");
+  if (R.length !== m) throw new Error("care: R must be m x m (m = number of columns of B)");
+  const Rinv = inv2(R);
+  const G = matmul2(matmul2(B, Rinv), transpose3(B));
+  const At = transpose3(A);
+  const n26 = 2 * n;
+  let Z = zeros3(n26, n26);
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < n; j++) {
+      Z[i][j] = A[i][j];
+      Z[i][n + j] = -G[i][j];
+      Z[n + i][j] = -Q2[i][j];
+      Z[n + i][n + j] = -At[i][j];
+    }
+  }
+  for (let iter = 0; iter < RICCATI_MAX_ITER; iter++) {
+    const Zinv = inv2(Z);
+    const c = Math.sqrt(norm1(Zinv) / norm1(Z));
+    const Znew = matScale(matadd(matScale(Z, c), matScale(Zinv, 1 / c)), 0.5);
+    const diff2 = maxAbsDiff(Znew, Z);
+    Z = Znew;
+    if (diff2 < RICCATI_TOL) break;
+  }
+  const S = Z;
+  const P2 = matScale(matadd(eye2(n26), S, -1), 0.5);
+  const U1 = zeros3(n, n);
+  const U2 = zeros3(n, n);
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < n; j++) {
+      U1[i][j] = P2[i][j];
+      U2[i][j] = P2[n + i][j];
+    }
+  }
+  const X = matmul2(U2, inv2(U1));
+  return symmetrize(X);
+}
+function dare(A, B, Q2, R) {
+  const n = assertSquare2(A, "dare");
+  assertSquare2(Q2, "dare");
+  if (Q2.length !== n) throw new Error("dare: A and Q must have the same size");
+  if (B.length !== n) throw new Error("dare: B must have n rows (n = size of A)");
+  const m = B[0]?.length ?? 0;
+  assertSquare2(R, "dare");
+  if (R.length !== m) throw new Error("dare: R must be m x m (m = number of columns of B)");
+  const Rinv = inv2(R);
+  let Ak = A.map((row2) => row2.slice());
+  let Gk = matmul2(matmul2(B, Rinv), transpose3(B));
+  let Hk = Q2.map((row2) => row2.slice());
+  for (let iter = 0; iter < RICCATI_MAX_ITER; iter++) {
+    const I_GH_inv = inv2(matadd(eye2(n), matmul2(Gk, Hk)));
+    const AkT = transpose3(Ak);
+    const Ak_IGHinv = matmul2(Ak, I_GH_inv);
+    const Anew = matmul2(Ak_IGHinv, Ak);
+    const Gnew = matadd(Gk, matmul2(matmul2(Ak_IGHinv, Gk), AkT));
+    const Hnew = matadd(Hk, matmul2(matmul2(AkT, matmul2(Hk, I_GH_inv)), Ak));
+    const diff2 = maxAbsDiff(Hnew, Hk);
+    Ak = Anew;
+    Gk = Gnew;
+    Hk = Hnew;
+    if (diff2 < RICCATI_TOL) break;
+  }
+  return symmetrize(Hk);
+}
+
 // src/numeric/minimize-scalar.ts
 var GOLD = (3 - Math.sqrt(5)) / 2;
 var EPS2 = 2220446049250313e-31;
@@ -45755,7 +46845,7 @@ function acf(x, nlags) {
 }
 
 // src/ml/ols.ts
-function transpose3(m) {
+function transpose4(m) {
   const rows = m.length;
   const cols = m[0].length;
   const out = Array.from({ length: cols }, () => new Array(rows).fill(0));
@@ -45766,7 +46856,7 @@ function transpose3(m) {
   }
   return out;
 }
-function matmul2(a, b) {
+function matmul3(a, b) {
   const n = a.length;
   const k = b.length;
   const m = b[0].length;
@@ -45820,8 +46910,8 @@ function ols(X, y, opts) {
   const design = useIntercept ? X.map((row2) => [1, ...row2]) : X.map((row2) => [...row2]);
   const p = design[0].length;
   if (n <= p) throw new Error(`ols: need more observations (${n}) than parameters (${p})`);
-  const Xt = transpose3(design);
-  const XtX = matmul2(Xt, design);
+  const Xt = transpose4(design);
+  const XtX = matmul3(Xt, design);
   const Xty = matVec(Xt, y);
   const XtXinv = invert(XtX);
   const coefficients = matVec(XtXinv, Xty);
@@ -46019,7 +47109,7 @@ function center(X, y, n, p, useIntercept) {
   const yc = y.map((v) => v - yMean);
   return { Xc, yc, xMean, yMean };
 }
-function dot2(a, b) {
+function dot4(a, b) {
   let s = 0;
   for (let i = 0; i < a.length; i++) s += a[i] * b[i];
   return s;
@@ -46047,19 +47137,19 @@ function ridge(X, y, alpha, opts) {
     for (let i = 0; i < n; i++) Xty[j] += Xc[i][j] * yc[i];
   }
   const coefficients = linsolve(XtX, Xty);
-  const intercept = useIntercept ? yMean - dot2(xMean, coefficients) : 0;
+  const intercept = useIntercept ? yMean - dot4(xMean, coefficients) : 0;
   return { coefficients, intercept };
 }
 function standardize(Xc, n, p) {
-  const scale = new Array(p);
+  const scale3 = new Array(p);
   for (let j = 0; j < p; j++) {
     let ss = 0;
     for (let i = 0; i < n; i++) ss += Xc[i][j] * Xc[i][j];
     const meanSq = ss / n;
-    scale[j] = meanSq > 1e-15 ? Math.sqrt(meanSq) : 1;
+    scale3[j] = meanSq > 1e-15 ? Math.sqrt(meanSq) : 1;
   }
-  const Xs = Xc.map((row2) => row2.map((v, j) => v / scale[j]));
-  return { Xs, scale };
+  const Xs = Xc.map((row2) => row2.map((v, j) => v / scale3[j]));
+  return { Xs, scale: scale3 };
 }
 function coordinateDescent(Xs, yc, n, p, l1, l2, maxIter, tol) {
   const beta2 = new Array(p).fill(0);
@@ -46091,10 +47181,10 @@ function lasso(X, y, alpha, opts) {
   const maxIter = opts?.maxIter ?? 1e3;
   const tol = opts?.tol ?? 1e-7;
   const { Xc, yc, xMean, yMean } = center(X, y, n, p, useIntercept);
-  const { Xs, scale } = standardize(Xc, n, p);
+  const { Xs, scale: scale3 } = standardize(Xc, n, p);
   const betaStd = coordinateDescent(Xs, yc, n, p, alpha, 0, maxIter, tol);
-  const coefficients = betaStd.map((b, j) => b / scale[j]);
-  const intercept = useIntercept ? yMean - dot2(xMean, coefficients) : 0;
+  const coefficients = betaStd.map((b, j) => b / scale3[j]);
+  const intercept = useIntercept ? yMean - dot4(xMean, coefficients) : 0;
   return { coefficients, intercept };
 }
 function elasticNet(X, y, alpha, l1Ratio, opts) {
@@ -46105,12 +47195,12 @@ function elasticNet(X, y, alpha, l1Ratio, opts) {
   const maxIter = opts?.maxIter ?? 1e3;
   const tol = opts?.tol ?? 1e-7;
   const { Xc, yc, xMean, yMean } = center(X, y, n, p, useIntercept);
-  const { Xs, scale } = standardize(Xc, n, p);
+  const { Xs, scale: scale3 } = standardize(Xc, n, p);
   const l1 = alpha * l1Ratio;
   const l2 = alpha * (1 - l1Ratio);
   const betaStd = coordinateDescent(Xs, yc, n, p, l1, l2, maxIter, tol);
-  const coefficients = betaStd.map((b, j) => b / scale[j]);
-  const intercept = useIntercept ? yMean - dot2(xMean, coefficients) : 0;
+  const coefficients = betaStd.map((b, j) => b / scale3[j]);
+  const intercept = useIntercept ? yMean - dot4(xMean, coefficients) : 0;
   return { coefficients, intercept };
 }
 
@@ -46177,8 +47267,8 @@ function logisticRegression(X, y, opts) {
     let stepNorm = 0;
     for (const d of delta) stepNorm = Math.max(stepNorm, Math.abs(d));
     if (stepNorm > MAX_STEP_NORM) {
-      const scale = MAX_STEP_NORM / stepNorm;
-      delta = delta.map((d) => d * scale);
+      const scale3 = MAX_STEP_NORM / stepNorm;
+      delta = delta.map((d) => d * scale3);
       stepNorm = MAX_STEP_NORM;
     }
     beta2 = beta2.map((b, j) => b + delta[j]);
@@ -46216,7 +47306,7 @@ function nelderMead(f, x0, opts = {}) {
     for (let i = 0; i < n; i++) for (let j = 0; j < n; j++) c[j] += pts[i][j] / n;
     return c;
   };
-  const add2 = (a, b, s) => a.map((v, i) => v + s * b[i]);
+  const add3 = (a, b, s) => a.map((v, i) => v + s * b[i]);
   const sub = (a, b) => a.map((v, i) => v - b[i]);
   for (; iter < maxIter; iter++) {
     const order = fv.map((_, i) => i).sort((i, j) => fv[i] - fv[j]);
@@ -46224,10 +47314,10 @@ function nelderMead(f, x0, opts = {}) {
     fv = order.map((i) => fv[i]);
     if (Math.abs(fv[n] - fv[0]) <= tol * (Math.abs(fv[0]) + tol)) break;
     const c = centroid2(simplex.slice(0, n));
-    const xr = add2(c, sub(c, simplex[n]), alpha);
+    const xr = add3(c, sub(c, simplex[n]), alpha);
     const fr = f(xr);
     if (fr < fv[0]) {
-      const xe = add2(c, sub(c, simplex[n]), gamma2);
+      const xe = add3(c, sub(c, simplex[n]), gamma2);
       const fe = f(xe);
       if (fe < fr) {
         simplex[n] = xe;
@@ -46240,14 +47330,14 @@ function nelderMead(f, x0, opts = {}) {
       simplex[n] = xr;
       fv[n] = fr;
     } else {
-      const xc = add2(c, sub(simplex[n], c), rho);
+      const xc = add3(c, sub(simplex[n], c), rho);
       const fc = f(xc);
       if (fc < fv[n]) {
         simplex[n] = xc;
         fv[n] = fc;
       } else {
         for (let i = 1; i <= n; i++) {
-          simplex[i] = add2(simplex[0], sub(simplex[i], simplex[0]), sigma);
+          simplex[i] = add3(simplex[0], sub(simplex[i], simplex[0]), sigma);
           fv[i] = f(simplex[i]);
         }
       }
@@ -46291,7 +47381,7 @@ function levenbergMarquardt(residual, x0, opts = {}) {
   let x = Array.from(x0);
   let lambda = 1e-3;
   const h = 1e-7;
-  const norm25 = (v) => v.reduce((s, c) => s + c * c, 0);
+  const norm27 = (v) => v.reduce((s, c) => s + c * c, 0);
   const jacobian2 = (xc, r0) => {
     const m = r0.length;
     const J = Array.from({ length: m }, () => new Array(n).fill(0));
@@ -46304,7 +47394,7 @@ function levenbergMarquardt(residual, x0, opts = {}) {
     return J;
   };
   let r = residual(x);
-  let cost = norm25(r);
+  let cost = norm27(r);
   let iter = 0;
   for (; iter < maxIter; iter++) {
     const J = jacobian2(x, r);
@@ -46335,7 +47425,7 @@ function levenbergMarquardt(residual, x0, opts = {}) {
     }
     const xNew = x.map((v, i) => v + delta[i]);
     const rNew = residual(xNew);
-    const costNew = norm25(rNew);
+    const costNew = norm27(rNew);
     if (costNew < cost) {
       x = xNew;
       r = rNew;
@@ -46685,8 +47775,8 @@ function fitPoisson(data) {
   for (const k of data) logLikelihood += -lambda + k * Math.log(lambda) - logFactorial(k);
   return { params: { lambda }, logLikelihood };
 }
-function gammaLogPdf(x, shape, scale) {
-  return (shape - 1) * Math.log(x) - x / scale - lgamma(shape) - shape * Math.log(scale);
+function gammaLogPdf(x, shape, scale3) {
+  return (shape - 1) * Math.log(x) - x / scale3 - lgamma(shape) - shape * Math.log(scale3);
 }
 function fitGamma(data) {
   for (const x of data) {
@@ -46703,10 +47793,10 @@ function fitGamma(data) {
   const k0 = (3 - s + Math.sqrt((s - 3) * (s - 3) + 24 * s)) / (12 * s);
   const f = (k) => Math.log(k) - digamma(k) - s;
   const shape = secant(f, k0, k0 * 1.1, { tol: 1e-12, maxIter: 200 });
-  const scale = xbar / shape;
+  const scale3 = xbar / shape;
   let logLikelihood = 0;
-  for (const x of data) logLikelihood += gammaLogPdf(x, shape, scale);
-  return { params: { shape, scale }, logLikelihood };
+  for (const x of data) logLikelihood += gammaLogPdf(x, shape, scale3);
+  return { params: { shape, scale: scale3 }, logLikelihood };
 }
 function fitDistribution(name254, data) {
   if (data.length === 0) {
@@ -46754,7 +47844,7 @@ function clipToBounds(x, bounds) {
     return Math.min(hi, Math.max(lo, v));
   });
 }
-function dot3(a, b) {
+function dot5(a, b) {
   let s = 0;
   for (let i = 0; i < a.length; i++) s += a[i] * b[i];
   return s;
@@ -46786,9 +47876,9 @@ function bfgs(f, x0, opts = {}) {
   let converged = infNorm(g) < tol;
   while (!converged && iter < maxIter) {
     const d = matVec2(H, g).map((v) => -v);
-    const gd = dot3(g, d);
+    const gd = dot5(g, d);
     const dir = gd < 0 ? d : g.map((v) => -v);
-    const dirSlope = gd < 0 ? gd : -dot3(g, g);
+    const dirSlope = gd < 0 ? gd : -dot5(g, g);
     let alpha = 1;
     let xNew = clipToBounds(
       x.map((v, i) => v + alpha * dir[i]),
@@ -46808,11 +47898,11 @@ function bfgs(f, x0, opts = {}) {
     const gNew = gradOf(xNew);
     const s = xNew.map((v, i) => v - x[i]);
     const y = gNew.map((v, i) => v - g[i]);
-    const sy = dot3(s, y);
+    const sy = dot5(s, y);
     if (sy > 1e-12) {
       const rho = 1 / sy;
       const Hy = matVec2(H, y);
-      const yHy = dot3(y, Hy);
+      const yHy = dot5(y, Hy);
       const HNew = Array.from({ length: n }, () => new Array(n).fill(0));
       for (let i = 0; i < n; i++) {
         for (let j = 0; j < n; j++) {
@@ -47073,18 +48163,18 @@ function integrateNode(raw, x) {
       if (fn === "sqrt") return integrateNode(parse2(`(${us})^(0.5)`), x);
       const a = linearSlope(us, x);
       if (a === null) throw new NotIntegrable(`non-linear argument of ${fn}`);
-      const inv2 = a === 1 ? "" : ` / ${num(a)}`;
+      const inv3 = a === 1 ? "" : ` / ${num(a)}`;
       switch (fn) {
         case "sin":
-          return `-cos(${us})${inv2}`;
+          return `-cos(${us})${inv3}`;
         case "cos":
-          return `sin(${us})${inv2}`;
+          return `sin(${us})${inv3}`;
         case "exp":
-          return `exp(${us})${inv2}`;
+          return `exp(${us})${inv3}`;
         case "sinh":
-          return `cosh(${us})${inv2}`;
+          return `cosh(${us})${inv3}`;
         case "cosh":
-          return `sinh(${us})${inv2}`;
+          return `sinh(${us})${inv3}`;
         default:
           throw new NotIntegrable(`function ${fn}`);
       }
@@ -47196,17 +48286,17 @@ function filtfilt(b, a, x) {
   return back.slice(pad, pad + n);
 }
 var cAdd = (p, q) => p.add(q);
-var cSub = (p, q) => p.sub(q);
-var cMul = (p, q) => p.multiply(q);
-var cDiv = (p, q) => p.divide(q);
-var cScale = (p, s) => cMul(p, new Complex11(s, 0));
+var cSub2 = (p, q) => p.sub(q);
+var cMul2 = (p, q) => p.multiply(q);
+var cDiv2 = (p, q) => p.divide(q);
+var cScale = (p, s) => cMul2(p, new Complex11(s, 0));
 function polyFromRoots(roots) {
   let c = [new Complex11(1, 0)];
   for (const r of roots) {
     const next = Array.from({ length: c.length + 1 }, () => new Complex11(0, 0));
     for (let i = 0; i < c.length; i++) {
       next[i] = cAdd(next[i], c[i]);
-      next[i + 1] = cSub(next[i + 1], cMul(c[i], r));
+      next[i + 1] = cSub2(next[i + 1], cMul2(c[i], r));
     }
     c = next;
   }
@@ -47228,21 +48318,21 @@ function lp2lpZpk(z, p, k, wo) {
 function lp2hpZpk(z, p, k, wo) {
   const degree2 = relativeDegree(z, p);
   const woC = new Complex11(wo, 0);
-  const zHp = z.map((zv) => cDiv(woC, zv));
+  const zHp = z.map((zv) => cDiv2(woC, zv));
   for (let i = 0; i < degree2; i++) zHp.push(new Complex11(0, 0));
   let prodZ = new Complex11(1, 0);
-  for (const zv of z) prodZ = cMul(prodZ, zv.negate());
+  for (const zv of z) prodZ = cMul2(prodZ, zv.negate());
   let prodP = new Complex11(1, 0);
-  for (const pv of p) prodP = cMul(prodP, pv.negate());
-  return { z: zHp, p: p.map((pv) => cDiv(woC, pv)), k: k * cDiv(prodZ, prodP).re };
+  for (const pv of p) prodP = cMul2(prodP, pv.negate());
+  return { z: zHp, p: p.map((pv) => cDiv2(woC, pv)), k: k * cDiv2(prodZ, prodP).re };
 }
 function lp2bpZpk(z, p, k, wo, bw) {
   const degree2 = relativeDegree(z, p);
   const wo2 = new Complex11(wo * wo, 0);
   const shift = (roots) => {
     const lp = roots.map((r) => cScale(r, bw / 2));
-    const plus = lp.map((r) => cAdd(r, cSub(cMul(r, r), wo2).sqrt()));
-    const minus = lp.map((r) => cSub(r, cSub(cMul(r, r), wo2).sqrt()));
+    const plus = lp.map((r) => cAdd(r, cSub2(cMul2(r, r), wo2).sqrt()));
+    const minus = lp.map((r) => cSub2(r, cSub2(cMul2(r, r), wo2).sqrt()));
     return plus.concat(minus);
   };
   const zBp = shift(z);
@@ -47254,33 +48344,33 @@ function lp2bsZpk(z, p, k, wo, bw) {
   const wo2 = new Complex11(wo * wo, 0);
   const bw2 = new Complex11(bw / 2, 0);
   const shift = (roots) => {
-    const hp = roots.map((r) => cDiv(bw2, r));
-    const plus = hp.map((r) => cAdd(r, cSub(cMul(r, r), wo2).sqrt()));
-    const minus = hp.map((r) => cSub(r, cSub(cMul(r, r), wo2).sqrt()));
+    const hp = roots.map((r) => cDiv2(bw2, r));
+    const plus = hp.map((r) => cAdd(r, cSub2(cMul2(r, r), wo2).sqrt()));
+    const minus = hp.map((r) => cSub2(r, cSub2(cMul2(r, r), wo2).sqrt()));
     return plus.concat(minus);
   };
   const zBs = shift(z);
   for (let i = 0; i < degree2; i++) zBs.push(new Complex11(0, wo));
   for (let i = 0; i < degree2; i++) zBs.push(new Complex11(0, -wo));
   let prodZ = new Complex11(1, 0);
-  for (const zv of z) prodZ = cMul(prodZ, zv.negate());
+  for (const zv of z) prodZ = cMul2(prodZ, zv.negate());
   let prodP = new Complex11(1, 0);
-  for (const pv of p) prodP = cMul(prodP, pv.negate());
-  return { z: zBs, p: shift(p), k: k * cDiv(prodZ, prodP).re };
+  for (const pv of p) prodP = cMul2(prodP, pv.negate());
+  return { z: zBs, p: shift(p), k: k * cDiv2(prodZ, prodP).re };
 }
 function bilinearZpk(z, p, k, fs) {
   const degree2 = relativeDegree(z, p);
   const fs2 = new Complex11(2 * fs, 0);
-  const zZ = z.map((zv) => cDiv(cAdd(fs2, zv), cSub(fs2, zv)));
+  const zZ = z.map((zv) => cDiv2(cAdd(fs2, zv), cSub2(fs2, zv)));
   for (let i = 0; i < degree2; i++) zZ.push(new Complex11(-1, 0));
   let prodZ = new Complex11(1, 0);
-  for (const zv of z) prodZ = cMul(prodZ, cSub(fs2, zv));
+  for (const zv of z) prodZ = cMul2(prodZ, cSub2(fs2, zv));
   let prodP = new Complex11(1, 0);
-  for (const pv of p) prodP = cMul(prodP, cSub(fs2, pv));
+  for (const pv of p) prodP = cMul2(prodP, cSub2(fs2, pv));
   return {
     z: zZ,
-    p: p.map((pv) => cDiv(cAdd(fs2, pv), cSub(fs2, pv))),
-    k: k * cDiv(prodZ, prodP).re
+    p: p.map((pv) => cDiv2(cAdd(fs2, pv), cSub2(fs2, pv))),
+    k: k * cDiv2(prodZ, prodP).re
   };
 }
 function zpkToTf(z, p, k) {
@@ -47461,7 +48551,7 @@ function cheb1ap(N, rp) {
     p.push(new Complex12(-Math.sinh(mu) * Math.cos(theta), -Math.cosh(mu) * Math.sin(theta)));
   }
   let prod2 = new Complex12(1, 0);
-  for (const pv of p) prod2 = cMul(prod2, pv.negate());
+  for (const pv of p) prod2 = cMul2(prod2, pv.negate());
   let k = prod2.re;
   if (N % 2 === 0) k /= Math.sqrt(1 + eps * eps);
   return { z: [], p, k };
@@ -47486,13 +48576,13 @@ function cheb2ap(N, rs) {
   for (let m = -N + 1; m < N; m += 2) {
     const theta = Math.PI * m / (2 * N);
     const s = new Complex12(Math.sinh(mu) * Math.cos(theta), Math.cosh(mu) * Math.sin(theta));
-    p.push(cDiv(new Complex12(1, 0), s).negate());
+    p.push(cDiv2(new Complex12(1, 0), s).negate());
   }
   let prodP = new Complex12(1, 0);
-  for (const pv of p) prodP = cMul(prodP, pv.negate());
+  for (const pv of p) prodP = cMul2(prodP, pv.negate());
   let prodZ = new Complex12(1, 0);
-  for (const zv of z) prodZ = cMul(prodZ, zv.negate());
-  const k = cDiv(prodP, prodZ).re;
+  for (const zv of z) prodZ = cMul2(prodZ, zv.negate());
+  const k = cDiv2(prodP, prodZ).re;
   return { z, p, k };
 }
 function cheby2(N, rs, Wn, btype = "low") {
@@ -47546,7 +48636,7 @@ function arcJacSn(w, m) {
   for (let i = 0; i < ks.length - 1; i++) {
     const knext = ks[i + 1];
     const comp = complementComplex(cScale(wn, ks[i]));
-    wn = cDiv(cScale(wn, 2), cMul(new Complex12(1 + knext, 0), new Complex12(1, 0).add(comp)));
+    wn = cDiv2(cScale(wn, 2), cMul2(new Complex12(1 + knext, 0), new Complex12(1, 0).add(comp)));
   }
   return cScale(cScale(wn.asin(), 2 / Math.PI), K);
 }
@@ -47606,10 +48696,10 @@ function ellipap(N, rp, rs) {
     pFull = pHalf.concat(pHalf.map((pv) => new Complex12(pv.re, -pv.im)));
   }
   let prodP = new Complex12(1, 0);
-  for (const pv of pFull) prodP = cMul(prodP, pv.negate());
+  for (const pv of pFull) prodP = cMul2(prodP, pv.negate());
   let prodZ = new Complex12(1, 0);
-  for (const zv of zFull) prodZ = cMul(prodZ, zv.negate());
-  let k = cDiv(prodP, prodZ).re;
+  for (const zv of zFull) prodZ = cMul2(prodZ, zv.negate());
+  let k = cDiv2(prodP, prodZ).re;
   if (N % 2 === 0) k /= Math.sqrt(1 + epsSq);
   return { z: zFull, p: pFull, k };
 }
@@ -48146,23 +49236,23 @@ function waverec(coeffs, wavelet = "haar") {
   }
   return approx;
 }
-function rickerWavelet(points, scale) {
-  const amplitude = 2 / (Math.sqrt(3 * scale) * Math.pow(Math.PI, 0.25));
+function rickerWavelet(points, scale3) {
+  const amplitude = 2 / (Math.sqrt(3 * scale3) * Math.pow(Math.PI, 0.25));
   const out = new Array(points);
   const center2 = (points - 1) / 2;
   for (let i = 0; i < points; i++) {
-    const t = (i - center2) / scale;
+    const t = (i - center2) / scale3;
     const t2 = t * t;
     out[i] = amplitude * (1 - t2) * Math.exp(-t2 / 2);
   }
   return out;
 }
-function morletWavelet(points, scale) {
-  const norm4 = 1 / (Math.sqrt(scale) * Math.pow(Math.PI, 0.25));
+function morletWavelet(points, scale3) {
+  const norm4 = 1 / (Math.sqrt(scale3) * Math.pow(Math.PI, 0.25));
   const out = new Array(points);
   const center2 = (points - 1) / 2;
   for (let i = 0; i < points; i++) {
-    const t = (i - center2) / scale;
+    const t = (i - center2) / scale3;
     out[i] = norm4 * Math.cos(5 * t) * Math.exp(-(t * t) / 2);
   }
   return out;
@@ -48172,10 +49262,10 @@ function cwt(x, scales, wavelet = "ricker") {
     throw new Error(`cwt: unsupported wavelet "${wavelet}"`);
   }
   const n = x.length;
-  return scales.map((scale) => {
-    if (scale <= 0) throw new Error("cwt: scales must be positive");
-    const points = Math.max(1, Math.min(Math.round(10 * scale), n));
-    const psi = wavelet === "ricker" ? rickerWavelet(points, scale) : morletWavelet(points, scale);
+  return scales.map((scale3) => {
+    if (scale3 <= 0) throw new Error("cwt: scales must be positive");
+    const points = Math.max(1, Math.min(Math.round(10 * scale3), n));
+    const psi = wavelet === "ricker" ? rickerWavelet(points, scale3) : morletWavelet(points, scale3);
     return convDirect(x, psi, "same");
   });
 }
@@ -48293,10 +49383,10 @@ function crossPower(x, y, opts) {
       im3[k] += X.im * Y.re - X.re * Y.im;
     }
   }
-  const scale = 1 / (fs * winSum2 * nSeg);
+  const scale3 = 1 / (fs * winSum2 * nSeg);
   for (let k = 0; k < half; k++) {
-    re3[k] *= scale;
-    im3[k] *= scale;
+    re3[k] *= scale3;
+    im3[k] *= scale3;
   }
   const frequencies = Array.from({ length: half }, (_, k) => k * fs / nfft);
   return { frequencies, re: re3, im: im3 };
@@ -48386,15 +49476,15 @@ function haversine(lat1, lon1, lat2, lon2, radius = EARTH_RADIUS_KM) {
   const a = Math.sin(dPhi / 2) ** 2 + Math.cos(phi1) * Math.cos(phi2) * Math.sin(dLambda / 2) ** 2;
   return radius * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
 }
-var dot4 = (a, b) => a.reduce((s, v, i) => s + v * b[i], 0);
-var norm3 = (a) => Math.sqrt(dot4(a, a));
+var dot6 = (a, b) => a.reduce((s, v, i) => s + v * b[i], 0);
+var norm3 = (a) => Math.sqrt(dot6(a, a));
 function slerp(v0, v1, t) {
   const n0 = norm3(v0);
   const n16 = norm3(v1);
   if (n0 === 0 || n16 === 0) throw new Error("slerp: input vectors must be non-zero");
   const u0 = v0.map((v) => v / n0);
   const u1 = v1.map((v) => v / n16);
-  let cos2 = dot4(u0, u1);
+  let cos2 = dot6(u0, u1);
   cos2 = cos2 > 1 ? 1 : cos2 < -1 ? -1 : cos2;
   const omega = Math.acos(cos2);
   const mag = n0 + (n16 - n0) * t;
@@ -48501,22 +49591,22 @@ function noncentralTCDF(t, df, nc) {
 }
 function circularSums(angles, opts) {
   const { high = TWO_PI, low = 0 } = opts;
-  const scale = TWO_PI / (high - low);
+  const scale3 = TWO_PI / (high - low);
   let sinSum = 0;
   let cosSum = 0;
   for (const a of angles) {
-    const theta = (a - low) * scale;
+    const theta = (a - low) * scale3;
     sinSum += Math.sin(theta);
     cosSum += Math.cos(theta);
   }
-  return { sinSum, cosSum, scale };
+  return { sinSum, cosSum, scale: scale3 };
 }
 function circmean(angles, opts = {}) {
   const { low = 0 } = opts;
-  const { sinSum, cosSum, scale } = circularSums(angles, opts);
+  const { sinSum, cosSum, scale: scale3 } = circularSums(angles, opts);
   let mean7 = Math.atan2(sinSum, cosSum);
   if (mean7 < 0) mean7 += TWO_PI;
-  return mean7 / scale + low;
+  return mean7 / scale3 + low;
 }
 function circvar(angles, opts = {}) {
   const n = angles.length;
@@ -48788,6 +49878,7 @@ export {
   betweennessCentrality,
   bezierCurve,
   bfgs,
+  bicgstab,
   bigint,
   bignumber,
   bilinear,
@@ -48808,6 +49899,7 @@ export {
   butter,
   buttord,
   cancel,
+  care,
   carlsonRC,
   carlsonRD,
   carlsonRF,
@@ -48824,6 +49916,7 @@ export {
   cbrt,
   ceil,
   centroid,
+  cg,
   chain,
   characteristicPolynomial,
   cheby1,
@@ -48864,7 +49957,9 @@ export {
   compareUnits,
   compileExpr,
   complex,
+  complexCos,
   complexExpand,
+  complexSin,
   composition,
   concat2 as concat,
   cond,
@@ -48883,6 +49978,7 @@ export {
   cos,
   cosIntegral,
   cosh,
+  cosm,
   cot,
   coth,
   coulomb,
@@ -48916,6 +50012,7 @@ export {
   curvefit,
   cwt,
   dagostinoTest,
+  dare,
   dbscan,
   dct,
   decimate,
@@ -48949,6 +50046,7 @@ export {
   divideScalar,
   divisorSigma,
   divisors,
+  dlyap,
   dot,
   dot3D,
   dotDivide,
@@ -48961,6 +50059,7 @@ export {
   efimovFactor,
   eigenvectorCentrality,
   eigs,
+  eigsh,
   elasticNet,
   electricConstant,
   electronMass,
@@ -49106,6 +50205,7 @@ export {
   fsum,
   fullSimplify,
   functionExpand,
+  funm,
   fuseUnaryChain,
   fuseUnaryChainAsync,
   fuseUnaryChainReduceAsync,
@@ -49128,6 +50228,7 @@ export {
   getMatrixDataType,
   globalMinimize,
   gmean,
+  gmres,
   goertzel,
   gpuAdd,
   gpuMatmul,
@@ -49245,6 +50346,7 @@ export {
   largerEq,
   lasso,
   lcm,
+  ldl,
   leafCount,
   leastSquares,
   leftShift,
@@ -49323,6 +50425,7 @@ export {
   minimizeScalar,
   minimumSpanningTree,
   minkowskiDistance,
+  minres,
   mod,
   mode,
   moebiusMu,
@@ -49555,6 +50658,7 @@ export {
   sinIntegral,
   singularValues2 as singularValues,
   sinh,
+  sinm,
   size,
   skewness,
   slerp,
@@ -49564,6 +50668,7 @@ export {
   softmax,
   solve,
   solveBVP,
+  solveBanded,
   solveODE,
   solveODESystem,
   solvePDE,
@@ -49616,6 +50721,7 @@ export {
   terminatePool,
   terminateSignal,
   terminateStatistics,
+  thomasSolve,
   thomsonCrossSection,
   to,
   toBest,
@@ -49623,6 +50729,7 @@ export {
   toRadians,
   toRadicals,
   toeplitz,
+  toeplitzSolve,
   together,
   topologicalSort,
   trace2 as trace,