@danielsimonjr/mathts-functions 0.6.0 → 0.8.0

package/dist/index.js

@@ -1030,13 +1030,13 @@ var norm = mathTyped("norm", {
   number: (a) => Math.abs(a),
   Complex: (a) => a.abs(),
   BigNumber: (a) => a.abs(),
-  Array: (arr6) => Math.sqrt(arr6.reduce((sum3, x) => sum3 + x * x, 0)),
-  "Array, number": (arr6, p) => {
-    if (p === Infinity) return Math.max(...arr6.map(Math.abs));
-    if (p === -Infinity) return Math.min(...arr6.map(Math.abs));
-    if (p === 0) return arr6.filter((x) => x !== 0).length;
+  Array: (arr7) => Math.sqrt(arr7.reduce((sum3, x) => sum3 + x * x, 0)),
+  "Array, number": (arr7, p) => {
+    if (p === Infinity) return Math.max(...arr7.map(Math.abs));
+    if (p === -Infinity) return Math.min(...arr7.map(Math.abs));
+    if (p === 0) return arr7.filter((x) => x !== 0).length;
     return Math.pow(
-      arr6.reduce((sum3, x) => sum3 + Math.pow(Math.abs(x), p), 0),
+      arr7.reduce((sum3, x) => sum3 + Math.pow(Math.abs(x), p), 0),
       1 / p
     );
   },
@@ -1148,7 +1148,7 @@ var min = mathTyped("min", {
   "bigint, bigint": (a, b) => a < b ? a : b,
   "Fraction, Fraction": (a, b) => a.compare(b) < 0 ? a : b,
   "BigNumber, BigNumber": (a, b) => a.compare(b) < 0 ? a : b,
-  Array: (arr6) => Math.min(...arr6),
+  Array: (arr7) => Math.min(...arr7),
   number: (a) => a,
   "number, number": (a, b) => Math.min(a, b),
   "number, number, ...number": (a, b, rest) => Math.min(a, b, ...rest),
@@ -1162,7 +1162,7 @@ var max = mathTyped("max", {
   "bigint, bigint": (a, b) => a > b ? a : b,
   "Fraction, Fraction": (a, b) => a.compare(b) > 0 ? a : b,
   "BigNumber, BigNumber": (a, b) => a.compare(b) > 0 ? a : b,
-  Array: (arr6) => Math.max(...arr6),
+  Array: (arr7) => Math.max(...arr7),
   number: (a) => a,
   "number, number": (a, b) => Math.max(a, b),
   "number, number, ...number": (a, b, rest) => Math.max(a, b, ...rest),
@@ -1173,10 +1173,10 @@ var max = mathTyped("max", {
   }
 });
 var sum = mathTyped("sum", {
-  Array: (arr6) => {
+  Array: (arr7) => {
     let total = 0;
-    for (let i = 0; i < arr6.length; i++) {
-      total += arr6[i];
+    for (let i = 0; i < arr7.length; i++) {
+      total += arr7[i];
     }
     return total;
   },
@@ -1187,13 +1187,13 @@ var sum = mathTyped("sum", {
   }
 });
 var mean = mathTyped("mean", {
-  Array: (arr6) => {
-    if (arr6.length === 0) return NaN;
+  Array: (arr7) => {
+    if (arr7.length === 0) return NaN;
     let total = 0;
-    for (let i = 0; i < arr6.length; i++) {
-      total += arr6[i];
+    for (let i = 0; i < arr7.length; i++) {
+      total += arr7[i];
     }
-    return total / arr6.length;
+    return total / arr7.length;
   },
   // Parallel Float64Array mean
   Float64Array: async (a) => {
@@ -1213,20 +1213,20 @@ function varianceFromM2(m2, n, norm4) {
       return n > 1 ? m2 / (n - 1) : 0;
   }
 }
-function m2OfArray(arr6) {
+function m2OfArray(arr7) {
   let m = 0;
   let m2 = 0;
-  for (let i = 0; i < arr6.length; i++) {
-    const delta = arr6[i] - m;
+  for (let i = 0; i < arr7.length; i++) {
+    const delta = arr7[i] - m;
     m += delta / (i + 1);
-    const delta2 = arr6[i] - m;
+    const delta2 = arr7[i] - m;
     m2 += delta * delta2;
   }
   return m2;
 }
 var variance = mathTyped("variance", {
-  Array: (arr6) => varianceFromM2(m2OfArray(arr6), arr6.length, "unbiased"),
-  "Array, string": (arr6, norm4) => varianceFromM2(m2OfArray(arr6), arr6.length, norm4),
+  Array: (arr7) => varianceFromM2(m2OfArray(arr7), arr7.length, "unbiased"),
+  "Array, string": (arr7, norm4) => varianceFromM2(m2OfArray(arr7), arr7.length, norm4),
   // Parallel Float64Array variance. computePool returns POPULATION variance
   // (sum2/n); recover sum2 = pop·n and renormalize for the requested convention.
   Float64Array: async (a) => {
@@ -1239,8 +1239,8 @@ var variance = mathTyped("variance", {
   }
 });
 var std = mathTyped("std", {
-  Array: (arr6) => Math.sqrt(varianceFromM2(m2OfArray(arr6), arr6.length, "unbiased")),
-  "Array, string": (arr6, norm4) => Math.sqrt(varianceFromM2(m2OfArray(arr6), arr6.length, norm4)),
+  Array: (arr7) => Math.sqrt(varianceFromM2(m2OfArray(arr7), arr7.length, "unbiased")),
+  "Array, string": (arr7, norm4) => Math.sqrt(varianceFromM2(m2OfArray(arr7), arr7.length, norm4)),
   // Parallel Float64Array std — derive from the (renormalized) variance so the
   // convention matches the Array path and parallelStatStd.
   Float64Array: async (a) => {
@@ -1597,7 +1597,7 @@ var hypot = mathTyped2("hypot", {
   number: (a) => Math.abs(a),
   "number, number": (a, b) => Math.hypot(a, b),
   "number, number, ...number": (a, b, rest) => Math.hypot(a, b, ...rest),
-  Array: (arr6) => Math.hypot(...arr6)
+  Array: (arr7) => Math.hypot(...arr7)
 });
 var typedTrigonometry = {
   // Basic
@@ -1628,8 +1628,8 @@ var typedTrigonometry = {
 // src/typed/statistics.ts
 import { mathTyped as mathTyped3 } from "@danielsimonjr/mathts-core";
 import { computePool as computePool3 } from "@danielsimonjr/mathts-parallel";
-function toFloat64Array(arr6) {
-  return new Float64Array(arr6);
+function toFloat64Array(arr7) {
+  return new Float64Array(arr7);
 }
 var parallelStatSum = mathTyped3("parallelStatSum", {
   // Float64Array - parallel execution
@@ -1638,8 +1638,8 @@ var parallelStatSum = mathTyped3("parallelStatSum", {
     return result.result;
   },
   // Number array
-  Array: async (arr6) => {
-    const data = toFloat64Array(arr6);
+  Array: async (arr7) => {
+    const data = toFloat64Array(arr7);
     const result = await computePool3.sum(data);
     return result.result;
   },
@@ -1655,9 +1655,9 @@ var parallelStatMean = mathTyped3("parallelStatMean", {
     return result.result;
   },
   // Number array - parallel execution
-  Array: async (arr6) => {
-    if (arr6.length === 0) return NaN;
-    const data = toFloat64Array(arr6);
+  Array: async (arr7) => {
+    if (arr7.length === 0) return NaN;
+    const data = toFloat64Array(arr7);
     const result = await computePool3.mean(data);
     return result.result;
   },
@@ -1692,25 +1692,25 @@ var parallelStatVariance = mathTyped3("parallelStatVariance", {
     }
   },
   // Number array
-  Array: async (arr6) => {
-    if (arr6.length === 0) return NaN;
-    const data = toFloat64Array(arr6);
+  Array: async (arr7) => {
+    if (arr7.length === 0) return NaN;
+    const data = toFloat64Array(arr7);
     return parallelStatVariance(data);
   },
   // Number array with normalization
-  "Array, string": async (arr6, normalization) => {
-    if (arr6.length === 0) return NaN;
-    const data = toFloat64Array(arr6);
+  "Array, string": async (arr7, normalization) => {
+    if (arr7.length === 0) return NaN;
+    const data = toFloat64Array(arr7);
     return parallelStatVariance(data, normalization);
   },
   // Variadic form
   "number, number": (a, b) => {
-    const mean5 = (a + b) / 2;
-    return ((a - mean5) ** 2 + (b - mean5) ** 2) / 1;
+    const mean6 = (a + b) / 2;
+    return ((a - mean6) ** 2 + (b - mean6) ** 2) / 1;
   },
   "number, number, number": (a, b, c) => {
-    const mean5 = (a + b + c) / 3;
-    return ((a - mean5) ** 2 + (b - mean5) ** 2 + (c - mean5) ** 2) / 2;
+    const mean6 = (a + b + c) / 3;
+    return ((a - mean6) ** 2 + (b - mean6) ** 2 + (c - mean6) ** 2) / 2;
   }
 });
 var parallelStatStd = mathTyped3("parallelStatStd", {
@@ -1727,15 +1727,15 @@ var parallelStatStd = mathTyped3("parallelStatStd", {
     return Math.sqrt(variance2);
   },
   // Number array
-  Array: async (arr6) => {
-    if (arr6.length === 0) return NaN;
-    const data = toFloat64Array(arr6);
+  Array: async (arr7) => {
+    if (arr7.length === 0) return NaN;
+    const data = toFloat64Array(arr7);
     return parallelStatStd(data);
   },
   // Number array with normalization
-  "Array, string": async (arr6, normalization) => {
-    if (arr6.length === 0) return NaN;
-    const data = toFloat64Array(arr6);
+  "Array, string": async (arr7, normalization) => {
+    if (arr7.length === 0) return NaN;
+    const data = toFloat64Array(arr7);
     return parallelStatStd(data, normalization);
   }
 });
@@ -1746,9 +1746,9 @@ var parallelStatMin = mathTyped3("parallelStatMin", {
     return result.result;
   },
   // Number array
-  Array: async (arr6) => {
-    if (arr6.length === 0) return Infinity;
-    const data = toFloat64Array(arr6);
+  Array: async (arr7) => {
+    if (arr7.length === 0) return Infinity;
+    const data = toFloat64Array(arr7);
     const result = await computePool3.min(data);
     return result.result;
   },
@@ -1766,9 +1766,9 @@ var parallelStatMax = mathTyped3("parallelStatMax", {
     return result.result;
   },
   // Number array
-  Array: async (arr6) => {
-    if (arr6.length === 0) return -Infinity;
-    const data = toFloat64Array(arr6);
+  Array: async (arr7) => {
+    if (arr7.length === 0) return -Infinity;
+    const data = toFloat64Array(arr7);
     const result = await computePool3.max(data);
     return result.result;
   },
@@ -1786,8 +1786,8 @@ var parallelStatMinMax = mathTyped3("parallelStatMinMax", {
     return result.result;
   },
   // Number array
-  Array: async (arr6) => {
-    const data = toFloat64Array(arr6);
+  Array: async (arr7) => {
+    const data = toFloat64Array(arr7);
     const result = await computePool3.minMax(data);
     return result.result;
   }
@@ -1807,25 +1807,25 @@ var parallelStatMedian = mathTyped3("parallelStatMedian", {
     return sorted[mid];
   },
   // Number array
-  Array: async (arr6) => {
-    if (arr6.length === 0) return NaN;
-    return parallelStatMedian(toFloat64Array(arr6));
+  Array: async (arr7) => {
+    if (arr7.length === 0) return NaN;
+    return parallelStatMedian(toFloat64Array(arr7));
   },
   // Variadic form
   "number, number": (a, b) => (a + b) / 2,
   "number, number, number": (a, b, c) => {
-    const arr6 = [a, b, c].sort((x, y) => x - y);
-    return arr6[1];
+    const arr7 = [a, b, c].sort((x, y) => x - y);
+    return arr7[1];
   }
 });
 var parallelStatMode = mathTyped3("parallelStatMode", {
   // Number array
-  Array: (arr6) => {
-    if (arr6.length === 0) return [];
+  Array: (arr7) => {
+    if (arr7.length === 0) return [];
     const counts = /* @__PURE__ */ new Map();
     let maxCount = 0;
-    for (let i = 0; i < arr6.length; i++) {
-      const val = arr6[i];
+    for (let i = 0; i < arr7.length; i++) {
+      const val = arr7[i];
       const count2 = (counts.get(val) || 0) + 1;
       counts.set(val, count2);
       if (count2 > maxCount) maxCount = count2;
@@ -1843,11 +1843,11 @@ var parallelStatMode = mathTyped3("parallelStatMode", {
 });
 var parallelStatProd = mathTyped3("parallelStatProd", {
   // Number array
-  Array: (arr6) => {
-    if (arr6.length === 0) return 1;
+  Array: (arr7) => {
+    if (arr7.length === 0) return 1;
     let prod2 = 1;
-    for (let i = 0; i < arr6.length; i++) {
-      prod2 *= arr6[i];
+    for (let i = 0; i < arr7.length; i++) {
+      prod2 *= arr7[i];
     }
     return prod2;
   },
@@ -1875,8 +1875,8 @@ var parallelStatNorm = mathTyped3("parallelStatNorm", {
     return result.result;
   },
   // Number array
-  Array: async (arr6) => {
-    const data = toFloat64Array(arr6);
+  Array: async (arr7) => {
+    const data = toFloat64Array(arr7);
     const result = await computePool3.norm(data);
     return result.result;
   },
@@ -1917,8 +1917,8 @@ var parallelStatNorm = mathTyped3("parallelStatNorm", {
     }
   },
   // Number array with p-norm
-  "Array, number": (arr6, p) => {
-    return parallelStatNorm(toFloat64Array(arr6), p);
+  "Array, number": (arr7, p) => {
+    return parallelStatNorm(toFloat64Array(arr7), p);
   }
 });
 var parallelStatDistance = mathTyped3("parallelStatDistance", {
@@ -1967,16 +1967,16 @@ var parallelStatMAD = mathTyped3("parallelStatMAD", {
     const n = data.length;
     if (n === 0) return NaN;
     const result = await computePool3.mean(data);
-    const mean5 = result.result;
+    const mean6 = result.result;
     let mad2 = 0;
     for (let i = 0; i < n; i++) {
-      mad2 += Math.abs(data[i] - mean5);
+      mad2 += Math.abs(data[i] - mean6);
     }
     return mad2 / n;
   },
   // Number array
-  Array: async (arr6) => {
-    return parallelStatMAD(toFloat64Array(arr6));
+  Array: async (arr7) => {
+    return parallelStatMAD(toFloat64Array(arr7));
   }
 });
 var parallelStatCumsum = mathTyped3("parallelStatCumsum", {
@@ -1991,11 +1991,11 @@ var parallelStatCumsum = mathTyped3("parallelStatCumsum", {
     return result;
   },
   // Number array
-  Array: (arr6) => {
+  Array: (arr7) => {
     const result = [];
     let sum3 = 0;
-    for (let i = 0; i < arr6.length; i++) {
-      sum3 += arr6[i];
+    for (let i = 0; i < arr7.length; i++) {
+      sum3 += arr7[i];
       result.push(sum3);
     }
     return result;
@@ -2019,8 +2019,8 @@ var parallelStatQuantile = mathTyped3("parallelStatQuantile", {
     return sorted[lower] * (1 - frac) + sorted[upper] * frac;
   },
   // Number array
-  "Array, number": (arr6, q) => {
-    return parallelStatQuantile(toFloat64Array(arr6), q);
+  "Array, number": (arr7, q) => {
+    return parallelStatQuantile(toFloat64Array(arr7), q);
   },
   // Multiple quantiles
   "Float64Array, Array": (data, quantiles) => {
@@ -2043,15 +2043,15 @@ var parallelStatHistogram = mathTyped3("parallelStatHistogram", {
     return result.result;
   },
   // Number array
-  "Array, number": async (arr6, bins) => {
-    return parallelStatHistogram(toFloat64Array(arr6), bins);
+  "Array, number": async (arr7, bins) => {
+    return parallelStatHistogram(toFloat64Array(arr7), bins);
   }
 });
-function quickSelect(arr6, k) {
-  if (k < 0 || k >= arr6.length) {
-    throw new RangeError(`k=${k} is out of range for array of length ${arr6.length}`);
+function quickSelect(arr7, k) {
+  if (k < 0 || k >= arr7.length) {
+    throw new RangeError(`k=${k} is out of range for array of length ${arr7.length}`);
   }
-  const a = arr6.slice();
+  const a = arr7.slice();
   return _quickSelect(a, 0, a.length - 1, k);
 }
 function _quickSelect(a, lo, hi, k) {
@@ -2094,32 +2094,32 @@ function _quickSelect(a, lo, hi, k) {
   }
   return a[lo];
 }
-function medianSelect(arr6) {
-  const n = arr6.length;
+function medianSelect(arr7) {
+  const n = arr7.length;
   if (n === 0) return NaN;
-  if (n === 1) return arr6[0];
+  if (n === 1) return arr7[0];
   const mid = Math.floor(n / 2);
   if (n % 2 === 1) {
-    return quickSelect(arr6, mid);
+    return quickSelect(arr7, mid);
   }
-  const a = arr6.slice();
+  const a = arr7.slice();
   const lower = _quickSelect(a, 0, a.length - 1, mid - 1);
   const upper = _quickSelect(a, 0, a.length - 1, mid);
   return (lower + upper) / 2;
 }
-function minSelect(arr6, k) {
+function minSelect(arr7, k) {
   if (k <= 0) return [];
-  if (k >= arr6.length) return arr6.slice().sort((a2, b) => a2 - b);
-  const a = arr6.slice();
+  if (k >= arr7.length) return arr7.slice().sort((a2, b) => a2 - b);
+  const a = arr7.slice();
   _quickSelect(a, 0, a.length - 1, k - 1);
   const result = a.slice(0, k);
   result.sort((x, y) => x - y);
   return result;
 }
-function maxSelect(arr6, k) {
+function maxSelect(arr7, k) {
   if (k <= 0) return [];
-  if (k >= arr6.length) return arr6.slice().sort((a2, b) => b - a2);
-  const a = arr6.slice();
+  if (k >= arr7.length) return arr7.slice().sort((a2, b) => b - a2);
+  const a = arr7.slice();
   const pivot = a.length - k;
   _quickSelect(a, 0, a.length - 1, pivot);
   const result = a.slice(pivot);
@@ -3889,8 +3889,8 @@ var typedLogical = {
 
 // src/typed/complex.ts
 import { mathTyped as mathTyped7, BigNumber as BigNumber5 } from "@danielsimonjr/mathts-core";
-function deepMapArray(arr6, fn) {
-  return arr6.map(
+function deepMapArray(arr7, fn) {
+  return arr7.map(
     (item) => Array.isArray(item) ? deepMapArray(item, fn) : fn(item)
   );
 }
@@ -3940,9 +3940,9 @@ var typedComplex = {
 
 // src/typed/set.ts
 import { mathTyped as mathTyped8 } from "@danielsimonjr/mathts-core";
-function flattenArray(arr6) {
+function flattenArray(arr7) {
   const result = [];
-  const stack = [...arr6];
+  const stack = [...arr7];
   while (stack.length > 0) {
     const item = stack.shift();
     if (Array.isArray(item)) {
@@ -4602,11 +4602,11 @@ function roundDigits(split, precision) {
   return rounded;
 }
 function zeros(length) {
-  const arr6 = [];
+  const arr7 = [];
   for (let i = 0; i < length; i++) {
-    arr6.push(0);
+    arr7.push(0);
   }
-  return arr6;
+  return arr7;
 }
 function nearlyEqual(a, b, relTol = 1e-8, absTol = 0) {
   if (relTol <= 0) {
@@ -5629,17 +5629,17 @@ function betaincScalar(a, b, x) {
   d = 1 / d;
   f = d;
   for (let m = 1; m <= 200; m++) {
-    let num = m * (b - m) * x / ((a + 2 * m - 1) * (a + 2 * m));
-    d = 1 + num * d;
+    let num2 = m * (b - m) * x / ((a + 2 * m - 1) * (a + 2 * m));
+    d = 1 + num2 * d;
     if (Math.abs(d) < 1e-30) d = 1e-30;
-    c = 1 + num / c;
+    c = 1 + num2 / c;
     if (Math.abs(c) < 1e-30) c = 1e-30;
     d = 1 / d;
     f *= d * c;
-    num = -(a + m) * (a + b + m) * x / ((a + 2 * m) * (a + 2 * m + 1));
-    d = 1 + num * d;
+    num2 = -(a + m) * (a + b + m) * x / ((a + 2 * m) * (a + 2 * m + 1));
+    d = 1 + num2 * d;
     if (Math.abs(d) < 1e-30) d = 1e-30;
-    c = 1 + num / c;
+    c = 1 + num2 / c;
     if (Math.abs(c) < 1e-30) c = 1e-30;
     d = 1 / d;
     const delta = d * c;
@@ -7920,20 +7920,20 @@ function polyMulJS(a, b) {
   }
   return out;
 }
-function polyDivModJS(num, den) {
+function polyDivModJS(num2, den) {
   if (den.length === 0) throw new Error("Division by zero polynomial");
-  if (num.length < den.length) {
+  if (num2.length < den.length) {
     return {
       quotient: new Float64Array([0]),
-      remainder: new Float64Array(num)
+      remainder: new Float64Array(num2)
     };
   }
-  const qLen = num.length - den.length + 1;
-  const work = new Float64Array(num);
+  const qLen = num2.length - den.length + 1;
+  const work = new Float64Array(num2);
   const quotient = new Float64Array(qLen);
   const bn = den[den.length - 1];
   for (let ii = 0; ii < qLen; ii++) {
-    const i = num.length - 1 - ii;
+    const i = num2.length - 1 - ii;
     quotient[i - den.length + 1] = work[i] / bn;
     for (let j = 0; j < den.length; j++) {
       work[i - den.length + 1 + j] -= quotient[i - den.length + 1] * den[j];
@@ -7963,23 +7963,23 @@ function polyMulDispatch(a, b) {
   }
   return polyMulJS(a, b);
 }
-function polyDivModDispatch(num, den) {
+function polyDivModDispatch(num2, den) {
   if (den.length === 0) throw new Error("Division by zero polynomial");
-  const bigEnough = num.length >= WASM_POLY_THRESHOLD;
+  const bigEnough = num2.length >= WASM_POLY_THRESHOLD;
   if (bigEnough) {
     const wasm = getWasm();
     if (wasm && isAsWasm(wasm)) {
       try {
         const flat = withAsF64(
           wasm,
-          [num, den],
+          [num2, den],
           (mod2, [hn, hd]) => asReadReturnedF64(
             mod2,
             mod2["poly_div_mod_f64"](hn, hd)
           )
         );
         if (flat) {
-          const actualQLen = num.length >= den.length ? num.length - den.length + 1 : 0;
+          const actualQLen = num2.length >= den.length ? num2.length - den.length + 1 : 0;
           const actualRLen = flat.length - actualQLen;
           return {
             quotient: actualQLen > 0 ? flat.slice(0, actualQLen) : new Float64Array([0]),
@@ -7990,7 +7990,7 @@ function polyDivModDispatch(num, den) {
       }
     }
   }
-  return polyDivModJS(num, den);
+  return polyDivModJS(num2, den);
 }
 function resultantJS(p, q) {
   let pm = p.length - 1;
@@ -8443,11 +8443,11 @@ function discriminant(coeffs) {
   const sign3 = deg * (deg - 1) / 2 % 2 === 0 ? 1 : -1;
   return sign3 * res / an;
 }
-function differences(arr6, n = 1) {
+function differences(arr7, n = 1) {
   if (n < 0 || !Number.isInteger(n)) {
     throw new Error("Difference order must be a non-negative integer");
   }
-  let result = [...arr6];
+  let result = [...arr7];
   for (let k = 0; k < n; k++) {
     if (result.length <= 1) return [];
     const next = new Array(result.length - 1);
@@ -8577,11 +8577,11 @@ function cancel(expr) {
   if (sameMatch && sameMatch[1].trim().length > 0) return "1";
   const fracMatch = expr.match(/^\s*(-?\d+)\s*\/\s*(-?\d+)\s*$/);
   if (fracMatch) {
-    const num = parseInt(fracMatch[1], 10);
+    const num2 = parseInt(fracMatch[1], 10);
     const den = parseInt(fracMatch[2], 10);
     if (den === 0) throw new Error("cancel: division by zero");
-    const g = gcdNum(Math.abs(num), Math.abs(den));
-    const rn = num / g;
+    const g = gcdNum(Math.abs(num2), Math.abs(den));
+    const rn = num2 / g;
     const rd = den / g;
     if (rd === 1) return String(rn);
     if (rd < 0) return -rn + "/" + -rd;
@@ -8607,20 +8607,20 @@ function together(expr) {
     const b = parseInt(match[2], 10);
     const c = parseInt(match[3], 10);
     const d = parseInt(match[4], 10);
-    const num = a * d + c * b;
+    const num2 = a * d + c * b;
     const den = b * d;
-    const g = gcdNum(Math.abs(num), Math.abs(den));
-    return num / g + "/" + den / g;
+    const g = gcdNum(Math.abs(num2), Math.abs(den));
+    return num2 / g + "/" + den / g;
   }
   return expr;
 }
 function apart(expr) {
   const match = expr.match(/^\s*(-?\d+)\s*\/\s*(-?\d+)\s*$/);
   if (match) {
-    const num = parseInt(match[1], 10);
+    const num2 = parseInt(match[1], 10);
     const den = parseInt(match[2], 10);
-    const whole = Math.trunc(num / den);
-    const remainder = num - whole * den;
+    const whole = Math.trunc(num2 / den);
+    const remainder = num2 - whole * den;
     if (remainder === 0) return String(whole);
     return whole + " + " + remainder + "/" + den;
   }
@@ -8715,11 +8715,11 @@ function fullSimplify(expr) {
   result = reduce(result);
   return result;
 }
-function element(arr6, index) {
-  if (index < 0 || index >= arr6.length) {
-    throw new Error("Index " + index + " out of bounds for array of length " + arr6.length);
+function element(arr7, index) {
+  if (index < 0 || index >= arr7.length) {
+    throw new Error("Index " + index + " out of bounds for array of length " + arr7.length);
   }
-  return arr6[index];
+  return arr7[index];
 }
 function eliminate(system, variable) {
   const withVar = [];
@@ -10869,15 +10869,15 @@ function padeApproximant(coeffs, m, n) {
       b = new Array(n).fill(0);
     }
     const den = [1, ...b];
-    const num = [];
+    const num2 = [];
     for (let i = 0; i <= m; i++) {
       let s = c[i];
       for (let j = 1; j <= Math.min(i, n); j++) {
         s += b[j - 1] * (i - j >= 0 ? c[i - j] : 0);
       }
-      num.push(s);
+      num2.push(s);
     }
-    return { num, den };
+    return { num: num2, den };
   }
   return { num: c.slice(0, m + 1), den: [1] };
 }
@@ -11685,26 +11685,26 @@ function _splitSeed(baseSeed, k) {
 function _aggregateRanks(vectors, aggregation) {
   const n = vectors[0].length;
   const count2 = vectors.length;
-  const mean5 = new Float64Array(n);
+  const mean6 = new Float64Array(n);
   for (const v of vectors) {
-    for (let i = 0; i < n; i++) mean5[i] += v[i];
+    for (let i = 0; i < n; i++) mean6[i] += v[i];
   }
-  for (let i = 0; i < n; i++) mean5[i] /= count2;
+  for (let i = 0; i < n; i++) mean6[i] /= count2;
   if (aggregation === "mean") {
-    return { ranks: mean5 };
+    return { ranks: mean6 };
   }
   const std2 = new Float64Array(n);
   for (const v of vectors) {
     for (let i = 0; i < n; i++) {
-      const d = v[i] - mean5[i];
+      const d = v[i] - mean6[i];
       std2[i] += d * d;
     }
   }
   for (let i = 0; i < n; i++) std2[i] = Math.sqrt(std2[i] / count2);
   return {
-    ranks: mean5,
+    ranks: mean6,
     ranksPerRestart: vectors,
-    restartStats: { mean: mean5, std: std2 }
+    restartStats: { mean: mean6, std: std2 }
   };
 }
 function _pageRankOnce(adj, d, maxIter, tol, seed) {
@@ -11837,26 +11837,26 @@ function _betweennessOnce(adj, directed, normalise, seed) {
 function _aggregateBetweenness(vectors, aggregation) {
   const n = vectors[0].length;
   const count2 = vectors.length;
-  const mean5 = new Float64Array(n);
+  const mean6 = new Float64Array(n);
   for (const v of vectors) {
-    for (let i = 0; i < n; i++) mean5[i] += v[i];
+    for (let i = 0; i < n; i++) mean6[i] += v[i];
   }
-  for (let i = 0; i < n; i++) mean5[i] /= count2;
+  for (let i = 0; i < n; i++) mean6[i] /= count2;
   if (aggregation === "mean") {
-    return { centrality: mean5 };
+    return { centrality: mean6 };
   }
   const std2 = new Float64Array(n);
   for (const v of vectors) {
     for (let i = 0; i < n; i++) {
-      const d = v[i] - mean5[i];
+      const d = v[i] - mean6[i];
       std2[i] += d * d;
     }
   }
   for (let i = 0; i < n; i++) std2[i] = Math.sqrt(std2[i] / count2);
   return {
-    centrality: mean5,
+    centrality: mean6,
     centralityPerRestart: vectors,
-    restartStats: { mean: mean5, std: std2 }
+    restartStats: { mean: mean6, std: std2 }
   };
 }
 async function betweennessCentrality(adj, opts) {
@@ -11929,32 +11929,32 @@ function _aggregateEigenvector(vectors, aggregation) {
     }
     return v;
   });
-  const mean5 = new Float64Array(n);
+  const mean6 = new Float64Array(n);
   for (const v of aligned) {
-    for (let i = 0; i < n; i++) mean5[i] += v[i];
+    for (let i = 0; i < n; i++) mean6[i] += v[i];
   }
-  for (let i = 0; i < n; i++) mean5[i] /= count2;
+  for (let i = 0; i < n; i++) mean6[i] /= count2;
   let norm4 = 0;
-  for (let i = 0; i < n; i++) norm4 += mean5[i] * mean5[i];
+  for (let i = 0; i < n; i++) norm4 += mean6[i] * mean6[i];
   norm4 = Math.sqrt(norm4);
   if (norm4 > 1e-15) {
-    for (let i = 0; i < n; i++) mean5[i] /= norm4;
+    for (let i = 0; i < n; i++) mean6[i] /= norm4;
   }
   if (aggregation === "mean") {
-    return { centrality: mean5 };
+    return { centrality: mean6 };
   }
   const std2 = new Float64Array(n);
   for (const v of aligned) {
     for (let i = 0; i < n; i++) {
-      const d = v[i] - mean5[i];
+      const d = v[i] - mean6[i];
       std2[i] += d * d;
     }
   }
   for (let i = 0; i < n; i++) std2[i] = Math.sqrt(std2[i] / count2);
   return {
-    centrality: mean5,
+    centrality: mean6,
     centralityPerRestart: aligned,
-    restartStats: { mean: mean5, std: std2 }
+    restartStats: { mean: mean6, std: std2 }
   };
 }
 async function eigenvectorCentrality(adj, opts) {
@@ -12420,9 +12420,9 @@ function fDist(d1, d2) {
         if (d1 === 2) return 1;
         return 0;
       }
-      const num = Math.pow(d1 * x, d1) * Math.pow(d2, d2);
+      const num2 = Math.pow(d1 * x, d1) * Math.pow(d2, d2);
       const den = Math.pow(d1 * x + d2, d1 + d2);
-      return Math.sqrt(num / den) / (x * Math.exp(_lgamma2(d1 / 2) + _lgamma2(d2 / 2) - _lgamma2((d1 + d2) / 2)));
+      return Math.sqrt(num2 / den) / (x * Math.exp(_lgamma2(d1 / 2) + _lgamma2(d2 / 2) - _lgamma2((d1 + d2) / 2)));
     },
     cdf: (x) => {
       if (x <= 0) return 0;
@@ -12709,12 +12709,12 @@ function _makeMulberry322(seed) {
     return z / 4294967296;
   };
 }
-function _shuffle(arr6, rng) {
-  for (let i = arr6.length - 1; i > 0; i--) {
+function _shuffle(arr7, rng) {
+  for (let i = arr7.length - 1; i > 0; i--) {
     const j = Math.floor(rng() * (i + 1));
-    const tmp = arr6[i];
-    arr6[i] = arr6[j];
-    arr6[j] = tmp;
+    const tmp = arr7[i];
+    arr7[i] = arr7[j];
+    arr7[j] = tmp;
   }
 }
 function _bootstrapSummary(stats) {
@@ -12722,22 +12722,22 @@ function _bootstrapSummary(stats) {
   if (n === 0) return { bootstrapMean: NaN, bootstrapStd: NaN };
   let sum3 = 0;
   for (let i = 0; i < n; i++) sum3 += stats[i];
-  const mean5 = sum3 / n;
+  const mean6 = sum3 / n;
   let sq = 0;
-  for (let i = 0; i < n; i++) sq += (stats[i] - mean5) ** 2;
+  for (let i = 0; i < n; i++) sq += (stats[i] - mean6) ** 2;
   const std2 = n > 1 ? Math.sqrt(sq / (n - 1)) : 0;
-  return { bootstrapMean: mean5, bootstrapStd: std2 };
+  return { bootstrapMean: mean6, bootstrapStd: std2 };
 }
-function _mean(arr6) {
+function _mean(arr7) {
   let sum3 = 0;
-  for (let i = 0; i < arr6.length; i++) sum3 += arr6[i];
-  return sum3 / arr6.length;
+  for (let i = 0; i < arr7.length; i++) sum3 += arr7[i];
+  return sum3 / arr7.length;
 }
-function _variance(arr6, ddof = 1) {
-  const m = _mean(arr6);
+function _variance(arr7, ddof = 1) {
+  const m = _mean(arr7);
   let sum3 = 0;
-  for (let i = 0; i < arr6.length; i++) sum3 += (arr6[i] - m) ** 2;
-  return sum3 / (arr6.length - ddof);
+  for (let i = 0; i < arr7.length; i++) sum3 += (arr7[i] - m) ** 2;
+  return sum3 / (arr7.length - ddof);
 }
 function _erf(x) {
   if (x === 0) return 0;
@@ -12870,9 +12870,9 @@ function studentTTest(sample1, sample2) {
   const v2 = _variance(sample2);
   const se = Math.sqrt(v1 / n16 + v2 / n26);
   const t = (m1 - m2) / se;
-  const num = (v1 / n16 + v2 / n26) ** 2;
+  const num2 = (v1 / n16 + v2 / n26) ** 2;
   const den = (v1 / n16) ** 2 / (n16 - 1) + (v2 / n26) ** 2 / (n26 - 1);
-  const df = num / den;
+  const df = num2 / den;
   return { statistic: t, pValue: _tPValue(t, df), degreesOfFreedom: df };
 }
 async function chiSquareTest(observed, expected, opts) {
@@ -14833,19 +14833,19 @@ var randomInt = mathTyped15("randomInt", {
   }
 });
 var pickRandom = mathTyped15("pickRandom", {
-  Array: (arr6) => _pick(arr6, 1, void 0)[0],
-  "Array, number": (arr6, n) => _pick(arr6, n, void 0),
-  "Array, Array": (arr6, weights) => _pick(arr6, 1, weights)[0],
-  "Array, number, Array": (arr6, n, weights) => _pick(arr6, n, weights),
-  "Array, Array, number": (arr6, weights, n) => _pick(arr6, n, weights)
+  Array: (arr7) => _pick(arr7, 1, void 0)[0],
+  "Array, number": (arr7, n) => _pick(arr7, n, void 0),
+  "Array, Array": (arr7, weights) => _pick(arr7, 1, weights)[0],
+  "Array, number, Array": (arr7, n, weights) => _pick(arr7, n, weights),
+  "Array, Array, number": (arr7, weights, n) => _pick(arr7, n, weights)
 });
-function _pick(arr6, n, weights) {
-  if (arr6.length === 0) throw new RangeError("Cannot pick from an empty array");
+function _pick(arr7, n, weights) {
+  if (arr7.length === 0) throw new RangeError("Cannot pick from an empty array");
   if (!Number.isInteger(n) || n < 1) {
     throw new RangeError("number of picks must be a positive integer");
   }
   if (weights !== void 0) {
-    if (weights.length !== arr6.length) {
+    if (weights.length !== arr7.length) {
       throw new RangeError("weights must have the same length as the array");
     }
     let total = 0;
@@ -14859,20 +14859,20 @@ function _pick(arr6, n, weights) {
     const result2 = [];
     for (let i = 0; i < n; i++) {
       let r = _rng() * total;
-      for (let j = 0; j < arr6.length; j++) {
+      for (let j = 0; j < arr7.length; j++) {
         r -= weights[j];
         if (r < 0) {
-          result2.push(arr6[j]);
+          result2.push(arr7[j]);
           break;
         }
       }
-      if (result2.length < i + 1) result2.push(arr6[arr6.length - 1]);
+      if (result2.length < i + 1) result2.push(arr7[arr7.length - 1]);
     }
     return result2;
   }
   const result = [];
   for (let i = 0; i < n; i++) {
-    result.push(arr6[Math.floor(_rng() * arr6.length)]);
+    result.push(arr7[Math.floor(_rng() * arr7.length)]);
   }
   return result;
 }
@@ -16376,13 +16376,13 @@ function resize(array, size2, defaultValue) {
       );
     }
   });
-  let arr6 = array;
+  let arr7 = array;
   if (isNumber(array) || isBigNumber(array)) {
-    arr6 = [array];
+    arr7 = [array];
   }
   const _defaultValue = defaultValue !== void 0 ? defaultValue : 0;
-  _resize(arr6, size2, 0, _defaultValue);
-  return arr6;
+  _resize(arr7, size2, 0, _defaultValue);
+  return arr7;
 }
 function _resize(array, size2, dim, defaultValue) {
   let i;
@@ -16483,9 +16483,9 @@ function _reshape(array, sizes) {
 }
 function squeeze(array, size2) {
   const s = size2 || arraySize(array);
-  let arr6 = array;
-  while (Array.isArray(arr6) && arr6.length === 1) {
-    arr6 = arr6[0];
+  let arr7 = array;
+  while (Array.isArray(arr7) && arr7.length === 1) {
+    arr7 = arr7[0];
     s.shift();
   }
   let dims = s.length;
@@ -16493,19 +16493,19 @@ function squeeze(array, size2) {
     dims--;
   }
   if (dims < s.length) {
-    arr6 = _squeeze(arr6, dims, 0);
+    arr7 = _squeeze(arr7, dims, 0);
     s.length = dims;
   }
-  return arr6;
+  return arr7;
 }
 function _squeeze(array, dims, dim) {
   if (dim < dims) {
     const next = dim + 1;
-    const arr6 = array;
-    for (let i = 0, ii = arr6.length; i < ii; i++) {
-      arr6[i] = _squeeze(arr6[i], dims, next);
+    const arr7 = array;
+    for (let i = 0, ii = arr7.length; i < ii; i++) {
+      arr7[i] = _squeeze(arr7[i], dims, next);
     }
-    return arr6;
+    return arr7;
   } else {
     let result = array;
     while (Array.isArray(result)) {
@@ -16528,9 +16528,9 @@ function flatten2(array, isRectangular = false) {
     _flatten(array);
   }
   return flat;
-  function _flatten(arr6) {
-    for (let i = 0; i < arr6.length; i++) {
-      const item = arr6[i];
+  function _flatten(arr7) {
+    for (let i = 0; i < arr7.length; i++) {
+      const item = arr7[i];
       if (Array.isArray(item)) {
         _flatten(item);
       } else {
@@ -16538,14 +16538,14 @@ function flatten2(array, isRectangular = false) {
       }
     }
   }
-  function _flattenRectangular(arr6) {
-    if (Array.isArray(arr6[0])) {
-      for (let i = 0; i < arr6.length; i++) {
-        _flattenRectangular(arr6[i]);
+  function _flattenRectangular(arr7) {
+    if (Array.isArray(arr7[0])) {
+      for (let i = 0; i < arr7.length; i++) {
+        _flattenRectangular(arr7[i]);
       }
     } else {
-      for (let i = 0; i < arr6.length; i++) {
-        flat.push(arr6[i]);
+      for (let i = 0; i < arr7.length; i++) {
+        flat.push(arr7[i]);
       }
     }
   }
@@ -17041,12 +17041,12 @@ var dependencies5 = ["typed", "Complex"];
 var createExpm1 = /* @__PURE__ */ factory(
   name5,
   dependencies5,
-  ({ typed: typed3, Complex: Complex11 }) => {
+  ({ typed: typed3, Complex: Complex12 }) => {
     return typed3(name5, {
       number: expm1Number,
       Complex: function(x) {
         const r = Math.exp(x.re);
-        return new Complex11(r * Math.cos(x.im) - 1, r * Math.sin(x.im));
+        return new Complex12(r * Math.cos(x.im) - 1, r * Math.sin(x.im));
       },
       BigNumber: function(x) {
         return x.exp().minus(1);
@@ -17075,12 +17075,12 @@ var log16 = log10Number(16);
 var createLog10 = /* @__PURE__ */ factory(
   name6,
   dependencies6,
-  ({ typed: typed3, config, Complex: Complex11 }) => {
+  ({ typed: typed3, config, Complex: Complex12 }) => {
     function complexLog(c) {
       return c.log().div(Math.LN10);
     }
     function complexLogNumber(x) {
-      return complexLog(new Complex11(x, 0));
+      return complexLog(new Complex12(x, 0));
     }
     return typed3(name6, {
       number: function(x) {
@@ -17112,9 +17112,9 @@ var dependencies7 = ["typed", "config", "Complex"];
 var createLog2 = /* @__PURE__ */ factory(
   name7,
   dependencies7,
-  ({ typed: typed3, config, Complex: Complex11 }) => {
+  ({ typed: typed3, config, Complex: Complex12 }) => {
     function complexLog2Number(x) {
-      return _log2Complex(new Complex11(x, 0));
+      return _log2Complex(new Complex12(x, 0));
     }
     return typed3(name7, {
       number: function(x) {
@@ -17139,7 +17139,7 @@ var createLog2 = /* @__PURE__ */ factory(
     });
     function _log2Complex(x) {
       const newX = Math.sqrt(x.re * x.re + x.im * x.im);
-      return new Complex11(
+      return new Complex12(
         Math.log2 ? Math.log2(newX) : Math.log(newX) / Math.LN2,
         Math.atan2(x.im, x.re) / Math.LN2
       );
@@ -17215,7 +17215,7 @@ var dependencies10 = ["config", "typed", "Complex"];
 var createSqrt = /* @__PURE__ */ factory(
   name10,
   dependencies10,
-  ({ config, typed: typed3, Complex: Complex11 }) => {
+  ({ config, typed: typed3, Complex: Complex12 }) => {
     return typed3("sqrt", {
       number: _sqrtNumber,
       Complex: function(x) {
@@ -17238,7 +17238,7 @@ var createSqrt = /* @__PURE__ */ factory(
       } else if (x >= 0 || config.predictable) {
         return Math.sqrt(x);
       } else {
-        return new Complex11(x, 0).sqrt();
+        return new Complex12(x, 0).sqrt();
       }
     }
   }
@@ -17525,24 +17525,24 @@ function decCoefficientToBinaryString(x) {
       str = str.slice(0, xe) + "." + str.slice(xe);
     }
   }
-  const arr6 = [0];
+  const arr7 = [0];
   for (let i = 0; i < str.length; ) {
-    let arrL = arr6.length;
+    let arrL = arr7.length;
     while (arrL--) {
-      arr6[arrL] *= 10;
+      arr7[arrL] *= 10;
     }
-    arr6[0] += parseInt(str.charAt(i++));
-    for (let j2 = 0; j2 < arr6.length; ++j2) {
-      if (arr6[j2] > 1) {
-        if (arr6[j2 + 1] === null || arr6[j2 + 1] === void 0) {
-          arr6[j2 + 1] = 0;
+    arr7[0] += parseInt(str.charAt(i++));
+    for (let j2 = 0; j2 < arr7.length; ++j2) {
+      if (arr7[j2] > 1) {
+        if (arr7[j2 + 1] === null || arr7[j2 + 1] === void 0) {
+          arr7[j2 + 1] = 0;
         }
-        arr6[j2 + 1] += arr6[j2] >> 1;
-        arr6[j2] &= 1;
+        arr7[j2 + 1] += arr7[j2] >> 1;
+        arr7[j2] &= 1;
       }
     }
   }
-  return arr6.reverse();
+  return arr7.reverse();
 }
 function bitXor2(x, y) {
   if (x.isFinite() && !x.isInteger() || y.isFinite() && !y.isInteger()) {
@@ -18042,8 +18042,8 @@ var createMap = /* @__PURE__ */ factory(
             if (index) index[depth] = i;
             result[i] = iterate(
               arrays2.map((array, arrayIndex) => {
-                const arr6 = array;
-                return offsets[arrayIndex] > depth ? array : arr6.length === 1 ? arr6[0] : arr6[i];
+                const arr7 = array;
+                return offsets[arrayIndex] > depth ? array : arr7.length === 1 ? arr7[0] : arr7[i];
               }),
               depth + 1
             );
@@ -18053,8 +18053,8 @@ var createMap = /* @__PURE__ */ factory(
             if (index) index[depth] = i;
             result[i] = callback(
               arrays2.map((a) => {
-                const arr6 = a;
-                return arr6.length === 1 ? arr6[0] : arr6[i];
+                const arr7 = a;
+                return arr7.length === 1 ? arr7[0] : arr7[i];
               }),
               index ? index.slice() : void 0
             );
@@ -18250,7 +18250,7 @@ var dependencies29 = ["Complex", "typed"];
 var createLgamma = /* @__PURE__ */ factory(
   name29,
   dependencies29,
-  ({ Complex: Complex11, typed: typed3 }) => {
+  ({ Complex: Complex12, typed: typed3 }) => {
     const SMALL_RE = 7;
     const SMALL_IM = 7;
     const coeffs = [
@@ -18264,15 +18264,15 @@ var createLgamma = /* @__PURE__ */ factory(
       0.08333333333333333
     ];
     return typed3(name29, {
-      Array: function(arr6) {
+      Array: function(arr7) {
         const wasm = wasmLoader.getModule();
-        if (wasm && arr6.length >= 100 && arr6.every((x) => typeof x === "number")) {
+        if (wasm && arr7.length >= 100 && arr7.every((x) => typeof x === "number")) {
           try {
-            const input = new Float64Array(arr6);
+            const input = new Float64Array(arr7);
             const inputAlloc = wasmLoader.allocateFloat64Array(input);
-            const resultAlloc = wasmLoader.allocateFloat64ArrayEmpty(arr6.length);
+            const resultAlloc = wasmLoader.allocateFloat64ArrayEmpty(arr7.length);
             try {
-              wasm.lgammaArray(inputAlloc.ptr, arr6.length, resultAlloc.ptr);
+              wasm.lgammaArray(inputAlloc.ptr, arr7.length, resultAlloc.ptr);
               return Array.from(resultAlloc.array);
             } finally {
               wasmLoader.free(inputAlloc.ptr);
@@ -18281,7 +18281,7 @@ var createLgamma = /* @__PURE__ */ factory(
           } catch {
           }
         }
-        return arr6.map((x) => lgammaNumber(x));
+        return arr7.map((x) => lgammaNumber(x));
       },
       number: lgammaNumber,
       Complex: lgammaComplex2,
@@ -18296,16 +18296,16 @@ var createLgamma = /* @__PURE__ */ factory(
       const LOGPI = 1.1447298858494002;
       const REFLECTION = 0.1;
       if (n.isNaN()) {
-        return new Complex11(NaN, NaN);
+        return new Complex12(NaN, NaN);
       } else if (n.im === 0) {
-        return new Complex11(lgammaNumber(n.re), 0);
+        return new Complex12(lgammaNumber(n.re), 0);
       } else if (n.re >= SMALL_RE || Math.abs(n.im) >= SMALL_IM) {
         return lgammaStirling(n);
       } else if (n.re <= REFLECTION) {
         const tmp = copysign(TWOPI, n.im) * Math.floor(0.5 * n.re + 0.25);
         const a = n.mul(Math.PI).sin().log();
-        const b = lgammaComplex2(new Complex11(1 - n.re, -n.im));
-        return new Complex11(LOGPI, tmp).sub(a).sub(b);
+        const b = lgammaComplex2(new Complex12(1 - n.re, -n.im));
+        return new Complex12(LOGPI, tmp).sub(a).sub(b);
       } else if (n.im >= 0) {
         return lgammaRecurrence(n);
       } else {
@@ -18314,7 +18314,7 @@ var createLgamma = /* @__PURE__ */ factory(
     }
     function lgammaStirling(z) {
       const leftPart = z.sub(0.5).mul(z.log()).sub(z).add(lnSqrt2PI);
-      const rz = new Complex11(1, 0).div(z);
+      const rz = new Complex12(1, 0).div(z);
       const rzz = rz.div(z);
       let a = coeffs[0];
       let b = coeffs[1];
@@ -18340,7 +18340,7 @@ var createLgamma = /* @__PURE__ */ factory(
         sb = nsb;
         z = z.add(1);
       }
-      return lgammaStirling(z).sub(shiftprod.log()).sub(new Complex11(0, signflips * 2 * Math.PI * 1));
+      return lgammaStirling(z).sub(shiftprod.log()).sub(new Complex12(0, signflips * 2 * Math.PI * 1));
     }
   }
 );
@@ -18784,13 +18784,13 @@ var dependencies36 = ["typed", "config", "Complex"];
 var createAcos = /* @__PURE__ */ factory(
   name36,
   dependencies36,
-  ({ typed: typed3, config, Complex: Complex11 }) => {
+  ({ typed: typed3, config, Complex: Complex12 }) => {
     return typed3(name36, {
       number: function(x) {
         if (x >= -1 && x <= 1 || config.predictable) {
           return Math.acos(x);
         } else {
-          return new Complex11(x, 0).acos();
+          return new Complex12(x, 0).acos();
         }
       },
       Complex: function(x) {
@@ -18809,16 +18809,16 @@ var dependencies37 = ["typed", "config", "Complex"];
 var createAcosh = /* @__PURE__ */ factory(
   name37,
   dependencies37,
-  ({ typed: typed3, config, Complex: Complex11 }) => {
+  ({ typed: typed3, config, Complex: Complex12 }) => {
     return typed3(name37, {
       number: function(x) {
         if (x >= 1 || config.predictable) {
           return acoshNumber(x);
         }
         if (x <= -1) {
-          return new Complex11(Math.log(Math.sqrt(x * x - 1) - x), Math.PI);
+          return new Complex12(Math.log(Math.sqrt(x * x - 1) - x), Math.PI);
         }
-        return new Complex11(x, 0).acosh();
+        return new Complex12(x, 0).acosh();
       },
       Complex: function(x) {
         return x.acosh();
@@ -18855,13 +18855,13 @@ var dependencies39 = ["typed", "config", "Complex", "BigNumber"];
 var createAcoth = /* @__PURE__ */ factory(
   name39,
   dependencies39,
-  ({ typed: typed3, config, Complex: Complex11, BigNumber: BigNumber9 }) => {
+  ({ typed: typed3, config, Complex: Complex12, BigNumber: BigNumber9 }) => {
     return typed3(name39, {
       number: function(x) {
         if (x >= 1 || x <= -1 || config.predictable) {
           return acothNumber(x);
         }
-        return new Complex11(x, 0).acoth();
+        return new Complex12(x, 0).acoth();
       },
       Complex: function(x) {
         return x.acoth();
@@ -18879,13 +18879,13 @@ var dependencies40 = ["typed", "config", "Complex", "BigNumber"];
 var createAcsc = /* @__PURE__ */ factory(
   name40,
   dependencies40,
-  ({ typed: typed3, config, Complex: Complex11, BigNumber: BigNumber9 }) => {
+  ({ typed: typed3, config, Complex: Complex12, BigNumber: BigNumber9 }) => {
     return typed3(name40, {
       number: function(x) {
         if (x <= -1 || x >= 1 || config.predictable) {
           return acscNumber(x);
         }
-        return new Complex11(x, 0).acsc();
+        return new Complex12(x, 0).acsc();
       },
       Complex: function(x) {
         return x.acsc();
@@ -18922,13 +18922,13 @@ var dependencies42 = ["typed", "config", "Complex", "BigNumber"];
 var createAsec = /* @__PURE__ */ factory(
   name42,
   dependencies42,
-  ({ typed: typed3, config, Complex: Complex11, BigNumber: BigNumber9 }) => {
+  ({ typed: typed3, config, Complex: Complex12, BigNumber: BigNumber9 }) => {
     return typed3(name42, {
       number: function(x) {
         if (x <= -1 || x >= 1 || config.predictable) {
           return asecNumber(x);
         }
-        return new Complex11(x, 0).asec();
+        return new Complex12(x, 0).asec();
       },
       Complex: function(x) {
         return x.asec();
@@ -18946,7 +18946,7 @@ var dependencies43 = ["typed", "config", "Complex", "BigNumber"];
 var createAsech = /* @__PURE__ */ factory(
   name43,
   dependencies43,
-  ({ typed: typed3, config, Complex: Complex11, BigNumber: BigNumber9 }) => {
+  ({ typed: typed3, config, Complex: Complex12, BigNumber: BigNumber9 }) => {
     return typed3(name43, {
       number: function(x) {
         if (x <= 1 && x >= -1 || config.predictable) {
@@ -18955,9 +18955,9 @@ var createAsech = /* @__PURE__ */ factory(
             return asechNumber(x);
           }
           const ret = Math.sqrt(xInv * xInv - 1);
-          return new Complex11(Math.log(ret - xInv), Math.PI);
+          return new Complex12(Math.log(ret - xInv), Math.PI);
         }
-        return new Complex11(x, 0).asech();
+        return new Complex12(x, 0).asech();
       },
       Complex: function(x) {
         return x.asech();
@@ -18975,13 +18975,13 @@ var dependencies44 = ["typed", "config", "Complex"];
 var createAsin = /* @__PURE__ */ factory(
   name44,
   dependencies44,
-  ({ typed: typed3, config, Complex: Complex11 }) => {
+  ({ typed: typed3, config, Complex: Complex12 }) => {
     return typed3(name44, {
       number: function(x) {
         if (x >= -1 && x <= 1 || config.predictable) {
           return Math.asin(x);
         } else {
-          return new Complex11(x, 0).asin();
+          return new Complex12(x, 0).asin();
         }
       },
       Complex: function(x) {
@@ -19040,13 +19040,13 @@ var dependencies47 = ["typed", "config", "Complex"];
 var createAtanh = /* @__PURE__ */ factory(
   name47,
   dependencies47,
-  ({ typed: typed3, config, Complex: Complex11 }) => {
+  ({ typed: typed3, config, Complex: Complex12 }) => {
     return typed3(name47, {
       number: function(x) {
         if (x <= 1 && x >= -1 || config.predictable) {
           return atanhNumber(x);
         }
-        return new Complex11(x, 0).atanh();
+        return new Complex12(x, 0).atanh();
       },
       Complex: function(x) {
         return x.atanh();
@@ -19324,8 +19324,8 @@ var createIsBounded = /* @__PURE__ */ factory(
       ),
       "Array | Matrix": typed3.referToSelf(
         (self) => (A) => {
-          const arr6 = Array.isArray(A) ? A : A.valueOf();
-          return arr6.every((entry) => self(entry));
+          const arr7 = Array.isArray(A) ? A : A.valueOf();
+          return arr7.every((entry) => self(entry));
         }
       )
     });
@@ -19850,8 +19850,8 @@ var createMode = /* @__PURE__ */ factory(
     });
     function _mode(values) {
       const flat = flatten2(values.valueOf());
-      const num = flat.length;
-      if (num === 0) {
+      const num2 = flat.length;
+      if (num2 === 0) {
         throw new Error("Cannot calculate mode of an empty array");
       }
       const count2 = {};
@@ -19897,9 +19897,9 @@ function improveErrorMessage(err, fnName, value) {
 
 // src/statistics/prod.ts
 var WASM_PROD_THRESHOLD = 100;
-function isFlatNumberArray(arr6) {
-  for (let i = 0; i < arr6.length; i++) {
-    if (typeof arr6[i] !== "number") {
+function isFlatNumberArray(arr7) {
+  for (let i = 0; i < arr7.length; i++) {
+    if (typeof arr7[i] !== "number") {
       return false;
     }
   }
@@ -20094,11 +20094,11 @@ var createParseNumberWithConfig = /* @__PURE__ */ factory(
           return bignumber2(str);
         case "bigint":
           if (str.includes(".") || str.includes("e") || str.includes("E")) {
-            const num = Number(str);
-            if (isNaN(num)) {
+            const num2 = Number(str);
+            if (isNaN(num2)) {
               throw new SyntaxError(`String "${str}" is not a valid number`);
             }
-            return num;
+            return num2;
           }
           try {
             return BigInt(str);
@@ -20114,11 +20114,11 @@ var createParseNumberWithConfig = /* @__PURE__ */ factory(
         }
         case "number":
         default: {
-          const num = Number(str);
-          if (isNaN(num)) {
+          const num2 = Number(str);
+          if (isNaN(num2)) {
             throw new SyntaxError(`String "${str}" is not a valid number`);
           }
-          return num;
+          return num2;
         }
       }
     }
@@ -20417,19 +20417,19 @@ function createZerosAndOnes(name256, defaultValue, { typed: typed3, config, matr
       }
       return m;
     } else {
-      const arr6 = [];
+      const arr7 = [];
       if (size2.length > 0) {
-        return resize(arr6, size2, dflt);
+        return resize(arr7, size2, dflt);
       }
-      return arr6;
+      return arr7;
     }
   }
   function _normalize(size2) {
     let hasBigNumbers = false;
-    size2.forEach(function(value, index, arr6) {
+    size2.forEach(function(value, index, arr7) {
       if (isBigNumber(value)) {
         hasBigNumbers = true;
-        arr6[index] = value.toNumber();
+        arr7[index] = value.toNumber();
       }
     });
     return hasBigNumbers;
@@ -20556,9 +20556,9 @@ var createDiag = /* @__PURE__ */ factory(
 
 // src/matrix/kron.ts
 var WASM_KRON_THRESHOLD = 64;
-function isPlainNumber2D(arr6) {
-  for (let i = 0; i < arr6.length; i++) {
-    const row2 = arr6[i];
+function isPlainNumber2D(arr7) {
+  for (let i = 0; i < arr7.length; i++) {
+    const row2 = arr7[i];
     for (let j = 0; j < row2.length; j++) {
       if (typeof row2[j] !== "number") {
         return false;
@@ -20567,11 +20567,11 @@ function isPlainNumber2D(arr6) {
   }
   return true;
 }
-function flatten2D(arr6, rows, cols) {
+function flatten2D(arr7, rows, cols) {
   const result = new Float64Array(rows * cols);
   for (let i = 0; i < rows; i++) {
     for (let j = 0; j < cols; j++) {
-      result[i * cols + j] = arr6[i][j];
+      result[i * cols + j] = arr7[i][j];
     }
   }
   return result;
@@ -20713,15 +20713,15 @@ var createMatrixFromColumns = /* @__PURE__ */ factory(
   ({ typed: typed3, matrix: matrix2, flatten: flatten4, size: size2 }) => {
     return typed3(name91, {
       // Single variadic handler for arrays, matrices, and mixed types
-      "...": function(arr6) {
-        if (arr6.length === 0) {
+      "...": function(arr7) {
+        if (arr7.length === 0) {
           throw new TypeError("At least one column is needed to construct a matrix.");
         }
-        const allMatrix = arr6.every(
+        const allMatrix = arr7.every(
           (item) => typeof item.toArray === "function"
         );
-        const hasArray = arr6.some((item) => Array.isArray(item));
-        const arrays = arr6.map(
+        const hasArray = arr7.some((item) => Array.isArray(item));
+        const arrays = arr7.map(
           (item) => typeof item.toArray === "function" ? item.toArray() : item
         );
         const result = _createArray(arrays);
@@ -20732,15 +20732,15 @@ var createMatrixFromColumns = /* @__PURE__ */ factory(
       }
       // TODO implement this properly for SparseMatrix
     });
-    function _createArray(arr6) {
-      if (arr6.length === 0)
+    function _createArray(arr7) {
+      if (arr7.length === 0)
         throw new TypeError("At least one column is needed to construct a matrix.");
-      const N = checkVectorTypeAndReturnLength(arr6[0]);
+      const N = checkVectorTypeAndReturnLength(arr7[0]);
       const result = [];
       for (let i = 0; i < N; i++) {
         result[i] = [];
       }
-      for (const col of arr6) {
+      for (const col of arr7) {
         const colLength = checkVectorTypeAndReturnLength(col);
         if (colLength !== N) {
           throw new TypeError(
@@ -20782,15 +20782,15 @@ var createMatrixFromRows = /* @__PURE__ */ factory(
   ({ typed: typed3, matrix: matrix2, flatten: flatten4, size: size2 }) => {
     return typed3(name92, {
       // Single variadic handler for arrays, matrices, and mixed types
-      "...": function(arr6) {
-        if (arr6.length === 0) {
+      "...": function(arr7) {
+        if (arr7.length === 0) {
           throw new TypeError("At least one row is needed to construct a matrix.");
         }
-        const allMatrix = arr6.every(
+        const allMatrix = arr7.every(
           (item) => typeof item.toArray === "function"
         );
-        const hasArray = arr6.some((item) => Array.isArray(item));
-        const arrays = arr6.map(
+        const hasArray = arr7.some((item) => Array.isArray(item));
+        const arrays = arr7.map(
           (item) => typeof item.toArray === "function" ? item.toArray() : item
         );
         const result = _createArray(arrays);
@@ -20801,12 +20801,12 @@ var createMatrixFromRows = /* @__PURE__ */ factory(
       }
       // TODO implement this properly for SparseMatrix
     });
-    function _createArray(arr6) {
-      if (arr6.length === 0)
+    function _createArray(arr7) {
+      if (arr7.length === 0)
         throw new TypeError("At least one row is needed to construct a matrix.");
-      const N = checkVectorTypeAndReturnLength(arr6[0]);
+      const N = checkVectorTypeAndReturnLength(arr7[0]);
       const result = [];
-      for (const row2 of arr6) {
+      for (const row2 of arr7) {
         const rowLength = checkVectorTypeAndReturnLength(row2);
         if (rowLength !== N) {
           throw new TypeError(
@@ -22875,7 +22875,7 @@ var createCbrt = /* @__PURE__ */ factory(
     isNegative: isNegative2,
     unaryMinus: unaryMinus2,
     matrix: matrix2,
-    Complex: Complex11,
+    Complex: Complex12,
     BigNumber: BigNumber9,
     Fraction: Fraction5
   }) => {
@@ -22893,12 +22893,12 @@ var createCbrt = /* @__PURE__ */ factory(
     function _cbrtComplex(x, allRoots) {
       const arg3 = x.arg() / 3;
       const abs2 = x.abs();
-      const principal = new Complex11(cbrtNumber(abs2), 0).mul(new Complex11(0, arg3).exp());
+      const principal = new Complex12(cbrtNumber(abs2), 0).mul(new Complex12(0, arg3).exp());
       if (allRoots) {
         const all = [
           principal,
-          new Complex11(cbrtNumber(abs2), 0).mul(new Complex11(0, arg3 + Math.PI * 2 / 3).exp()),
-          new Complex11(cbrtNumber(abs2), 0).mul(new Complex11(0, arg3 - Math.PI * 2 / 3).exp())
+          new Complex12(cbrtNumber(abs2), 0).mul(new Complex12(0, arg3 + Math.PI * 2 / 3).exp()),
+          new Complex12(cbrtNumber(abs2), 0).mul(new Complex12(0, arg3 - Math.PI * 2 / 3).exp())
         ];
         return config.matrix === "Array" ? all : matrix2(all);
       } else {
@@ -22947,27 +22947,27 @@ var createNthRoots = /* @__PURE__ */ factory(
     typed: typed3,
     config: _config,
     divideScalar: _divideScalar,
-    Complex: Complex11
+    Complex: Complex12
   }) => {
     const _calculateExactResult = [
       function realPos(val) {
-        return new Complex11(val, 0);
+        return new Complex12(val, 0);
       },
       function imagPos(val) {
-        return new Complex11(0, val);
+        return new Complex12(0, val);
       },
       function realNeg(val) {
-        return new Complex11(-val, 0);
+        return new Complex12(-val, 0);
       },
       function imagNeg(val) {
-        return new Complex11(0, -val);
+        return new Complex12(0, -val);
       }
     ];
     function _nthComplexRoots(a, root) {
       if (root < 0) throw new Error("Root must be greater than zero");
       if (root === 0) throw new Error("Root must be non-zero");
       if (root % 1 !== 0) throw new Error("Root must be an integer");
-      if (a === 0 || a.abs() === 0) return [new Complex11(0, 0)];
+      if (a === 0 || a.abs() === 0) return [new Complex12(0, 0)];
       const aIsNumeric = typeof a === "number";
       let offset = NaN;
       if (aIsNumeric || a.re === 0 || a.im === 0) {
@@ -22989,7 +22989,7 @@ var createNthRoots = /* @__PURE__ */ factory(
           roots.push(_calculateExactResult[halfPiFactor % 4](r));
           continue;
         }
-        roots.push(new Complex11({ r, phi: (arg3 + 2 * Math.PI * k) / root }));
+        roots.push(new Complex12({ r, phi: (arg3 + 2 * Math.PI * k) / root }));
       }
       return roots;
     }
@@ -23376,12 +23376,12 @@ var nlg16 = Math.log(16);
 var createLog = /* @__PURE__ */ factory(
   name112,
   dependencies112,
-  ({ typed: typed3, typeOf: typeOf3, config, divideScalar: divideScalar2, Complex: Complex11 }) => {
+  ({ typed: typed3, typeOf: typeOf3, config, divideScalar: divideScalar2, Complex: Complex12 }) => {
     function complexLog(c) {
       return c.log();
     }
     function complexLogNumber(x) {
-      return complexLog(new Complex11(x, 0));
+      return complexLog(new Complex12(x, 0));
     }
     return typed3(name112, {
       number: function(x) {
@@ -23579,9 +23579,9 @@ var createInv = /* @__PURE__ */ factory(
               if (isMatrix(x)) {
                 const matX = x;
                 const storage = matX.storage();
-                return matrix2(_inv2(matX.valueOf(), rows, cols), storage);
+                return matrix2(_inv4(matX.valueOf(), rows, cols), storage);
               } else {
-                return _inv2(x, rows, cols);
+                return _inv4(x, rows, cols);
               }
             } else {
               throw new RangeError("Matrix must be square (size: " + format3(size2, {}) + ")");
@@ -23597,7 +23597,7 @@ var createInv = /* @__PURE__ */ factory(
         return divideScalar2(1, x);
       }
     });
-    function _inv2(mat, rows, cols) {
+    function _inv4(mat, rows, cols) {
       let r, s, f, value, temp;
       const wasm = wasmLoader.getModule();
       if (wasm && rows >= 3 && rows * rows >= WASM_INV_THRESHOLD && isPlainNumberMatrix5(mat)) {
@@ -23812,9 +23812,9 @@ var createResize = /* @__PURE__ */ factory(
         }
         return clone(scalar);
       } else {
-        let arr6 = !Array.isArray(x) ? [x] : x;
-        arr6 = clone(arr6);
-        const res = resize(arr6, sz, defaultValue);
+        let arr7 = !Array.isArray(x) ? [x] : x;
+        arr7 = clone(arr7);
+        const res = resize(arr7, sz, defaultValue);
         return asMatrix ? matrix2(res) : res;
       }
     }
@@ -24656,7 +24656,7 @@ var dependencies126 = ["typed", "add", "multiply", "Complex", "number"];
 var createZpk2tf = /* @__PURE__ */ factory(
   name126,
   dependencies126,
-  ({ typed: typed3, add: add2, multiply: multiply2, Complex: Complex11, number: number2 }) => {
+  ({ typed: typed3, add: add2, multiply: multiply2, Complex: Complex12, number: number2 }) => {
     return typed3(name126, {
       "Array,Array,number": function(z, p, k) {
         return _zpk2tf(z, p, k);
@@ -24678,27 +24678,27 @@ var createZpk2tf = /* @__PURE__ */ factory(
       if (p.some((el) => el.type === "BigNumber")) {
         p = p.map((el) => number2(el));
       }
-      let num = [Complex11(1, 0)];
-      let den = [Complex11(1, 0)];
+      let num2 = [Complex12(1, 0)];
+      let den = [Complex12(1, 0)];
       for (let i = 0; i < z.length; i++) {
         let zero = z[i];
-        if (typeof zero === "number") zero = Complex11(zero, 0);
-        num = _multiply2(num, [Complex11(1, 0), Complex11(-zero.re, -zero.im)]);
+        if (typeof zero === "number") zero = Complex12(zero, 0);
+        num2 = _multiply2(num2, [Complex12(1, 0), Complex12(-zero.re, -zero.im)]);
       }
       for (let i = 0; i < p.length; i++) {
         let pole = p[i];
-        if (typeof pole === "number") pole = Complex11(pole, 0);
-        den = _multiply2(den, [Complex11(1, 0), Complex11(-pole.re, -pole.im)]);
+        if (typeof pole === "number") pole = Complex12(pole, 0);
+        den = _multiply2(den, [Complex12(1, 0), Complex12(-pole.re, -pole.im)]);
       }
-      for (let i = 0; i < num.length; i++) {
-        num[i] = multiply2(num[i], k);
+      for (let i = 0; i < num2.length; i++) {
+        num2[i] = multiply2(num2[i], k);
       }
-      return [num, den];
+      return [num2, den];
     }
     function _multiply2(a, b) {
       const c = [];
       for (let i = 0; i < a.length + b.length - 1; i++) {
-        c[i] = Complex11(0, 0);
+        c[i] = Complex12(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]));
@@ -24712,9 +24712,9 @@ var createZpk2tf = /* @__PURE__ */ factory(
 
 // src/statistics/cumsum.ts
 var WASM_CUMSUM_THRESHOLD = 100;
-function isFlatNumberArray2(arr6) {
-  for (let i = 0; i < arr6.length; i++) {
-    if (typeof arr6[i] !== "number") {
+function isFlatNumberArray2(arr7) {
+  for (let i = 0; i < arr7.length; i++) {
+    if (typeof arr7[i] !== "number") {
       return false;
     }
   }
@@ -24825,9 +24825,9 @@ var createCumSum = /* @__PURE__ */ factory(
 
 // src/statistics/sum.ts
 var WASM_SUM_THRESHOLD = 100;
-function isFlatNumberArray3(arr6) {
-  for (let i = 0; i < arr6.length; i++) {
-    if (typeof arr6[i] !== "number") {
+function isFlatNumberArray3(arr7) {
+  for (let i = 0; i < arr7.length; i++) {
+    if (typeof arr7[i] !== "number") {
       return false;
     }
   }
@@ -25941,13 +25941,13 @@ var dependencies142 = ["typed", "config", "divideScalar", "log", "Complex"];
 var createLog1p = /* @__PURE__ */ factory(
   name142,
   dependencies142,
-  ({ typed: typed3, config, divideScalar: divideScalar2, log: log3, Complex: Complex11 }) => {
+  ({ typed: typed3, config, divideScalar: divideScalar2, log: log3, Complex: Complex12 }) => {
     return typed3(name142, {
       number: function(x) {
         if (x >= -1 || config.predictable) {
           return log1p2(x);
         } else {
-          return _log1pComplex(new Complex11(x, 0));
+          return _log1pComplex(new Complex12(x, 0));
         }
       },
       Complex: _log1pComplex,
@@ -25956,7 +25956,7 @@ var createLog1p = /* @__PURE__ */ factory(
         if (!y.isNegative() || config.predictable) {
           return y.ln();
         } else {
-          return _log1pComplex(new Complex11(x.toNumber(), 0));
+          return _log1pComplex(new Complex12(x.toNumber(), 0));
         }
       },
       "Array | Matrix": typed3.referToSelf(
@@ -25970,7 +25970,7 @@ var createLog1p = /* @__PURE__ */ factory(
     });
     function _log1pComplex(x) {
       const xRe1p = x.re + 1;
-      return new Complex11(Math.log(Math.sqrt(xRe1p * xRe1p + x.im * x.im)), Math.atan2(x.im, xRe1p));
+      return new Complex12(Math.log(Math.sqrt(xRe1p * xRe1p + x.im * x.im)), Math.atan2(x.im, xRe1p));
     }
   }
 );
@@ -26122,7 +26122,7 @@ var createPow = /* @__PURE__ */ factory(
     inv: inv2,
     number: number2,
     fraction: fraction2,
-    Complex: Complex11
+    Complex: Complex12
   }) => {
     return typed3(name144, {
       "number, number": _pow,
@@ -26133,7 +26133,7 @@ var createPow = /* @__PURE__ */ factory(
         if (y.isInteger() || x.gte(0) || config.predictable) {
           return x.pow(y);
         } else {
-          return new Complex11(x.toNumber(), 0).pow(y.toNumber(), 0);
+          return new Complex12(x.toNumber(), 0).pow(y.toNumber(), 0);
         }
       },
       "bigint, bigint": (x, y) => x ** y,
@@ -26182,7 +26182,7 @@ var createPow = /* @__PURE__ */ factory(
         if (isPowZeroAtInfinity(x, y)) {
           return 0;
         }
-        return new Complex11(x, 0).pow(y, 0);
+        return new Complex12(x, 0).pow(y, 0);
       }
     }
     function _powArray(x, y) {
@@ -27587,7 +27587,7 @@ var createFixNumber = /* @__PURE__ */ factory(
 var createFix = /* @__PURE__ */ factory(
   name167,
   dependencies167,
-  ({ typed: typed3, Complex: Complex11, matrix: matrix2, ceil: ceil2, floor: floor2, equalScalar: equalScalar3, zeros: zeros3, DenseMatrix: DenseMatrix6 }) => {
+  ({ typed: typed3, Complex: Complex12, matrix: matrix2, ceil: ceil2, floor: floor2, equalScalar: equalScalar3, zeros: zeros3, DenseMatrix: DenseMatrix6 }) => {
     const matAlgo12xSfs = createMatAlgo12xSfs({ typed: typed3, DenseMatrix: DenseMatrix6 });
     const matAlgo14xDs = createMatAlgo14xDs({ typed: typed3 });
     const fixNumber = createFixNumber({ typed: typed3, ceil: ceil2, floor: floor2 });
@@ -27595,20 +27595,20 @@ var createFix = /* @__PURE__ */ factory(
       number: fixNumber.signatures.number,
       "number, number | BigNumber": fixNumber.signatures["number,number"],
       Complex: function(x) {
-        return new Complex11(
+        return new Complex12(
           x.re > 0 ? Math.floor(x.re) : Math.ceil(x.re),
           x.im > 0 ? Math.floor(x.im) : Math.ceil(x.im)
         );
       },
       "Complex, number": function(x, n) {
-        return new Complex11(
+        return new Complex12(
           x.re > 0 ? floor2(x.re, n) : ceil2(x.re, n),
           x.im > 0 ? floor2(x.im, n) : ceil2(x.im, n)
         );
       },
       "Complex, BigNumber": function(x, bn) {
         const n = bn.toNumber();
-        return new Complex11(
+        return new Complex12(
           x.re > 0 ? floor2(x.re, n) : ceil2(x.re, n),
           x.im > 0 ? floor2(x.im, n) : ceil2(x.im, n)
         );
@@ -27839,9 +27839,9 @@ var createComposition = /* @__PURE__ */ factory(
 
 // src/matrix/partitionSelect.ts
 var WASM_PARTITION_SELECT_THRESHOLD = 100;
-function isFlatNumberArray4(arr6) {
-  for (let i = 0; i < arr6.length; i++) {
-    if (typeof arr6[i] !== "number") {
+function isFlatNumberArray4(arr7) {
+  for (let i = 0; i < arr7.length; i++) {
+    if (typeof arr7[i] !== "number") {
       return false;
     }
   }
@@ -27883,28 +27883,28 @@ var createPartitionSelect = /* @__PURE__ */ factory(
       }
       return quickSelect2(x, k, compare3);
     }
-    function quickSelect2(arr6, k, compare3) {
-      if (k >= arr6.length) {
+    function quickSelect2(arr7, k, compare3) {
+      if (k >= arr7.length) {
         throw new Error("k out of bounds");
       }
-      for (let i = 0; i < arr6.length; i++) {
-        if (isNumeric2(arr6[i]) && mathIsNaN(arr6[i])) {
-          return arr6[i];
+      for (let i = 0; i < arr7.length; i++) {
+        if (isNumeric2(arr7[i]) && mathIsNaN(arr7[i])) {
+          return arr7[i];
         }
       }
       const wasm = wasmLoader.getModule();
-      if (wasm && arr6.length >= WASM_PARTITION_SELECT_THRESHOLD && isFlatNumberArray4(arr6)) {
+      if (wasm && arr7.length >= WASM_PARTITION_SELECT_THRESHOLD && isFlatNumberArray4(arr7)) {
         const isAsc = compare3 === asc;
         const isDesc = compare3 === desc;
         if (isAsc || isDesc) {
           try {
-            const effectiveK = isDesc ? arr6.length - 1 - k : k;
-            const data = wasmLoader.allocateFloat64Array(arr6);
-            const work = wasmLoader.allocateFloat64ArrayEmpty(arr6.length);
+            const effectiveK = isDesc ? arr7.length - 1 - k : k;
+            const data = wasmLoader.allocateFloat64Array(arr7);
+            const work = wasmLoader.allocateFloat64ArrayEmpty(arr7.length);
             try {
-              const result = wasm.partitionSelect(data.ptr, arr6.length, effectiveK, work.ptr);
-              for (let i = 0; i < arr6.length; i++) {
-                arr6[i] = work.array[i];
+              const result = wasm.partitionSelect(data.ptr, arr7.length, effectiveK, work.ptr);
+              for (let i = 0; i < arr7.length; i++) {
+                arr7[i] = work.array[i];
               }
               return result;
             } finally {
@@ -27916,22 +27916,22 @@ var createPartitionSelect = /* @__PURE__ */ factory(
         }
       }
       let from = 0;
-      let to3 = arr6.length - 1;
+      let to3 = arr7.length - 1;
       while (from < to3) {
         let r = from;
         let w = to3;
-        const pivot = arr6[Math.floor(Math.random() * (to3 - from + 1)) + from];
+        const pivot = arr7[Math.floor(Math.random() * (to3 - from + 1)) + from];
         while (r < w) {
-          if (compare3(arr6[r], pivot) >= 0) {
-            const tmp = arr6[w];
-            arr6[w] = arr6[r];
-            arr6[r] = tmp;
+          if (compare3(arr7[r], pivot) >= 0) {
+            const tmp = arr7[w];
+            arr7[w] = arr7[r];
+            arr7[r] = tmp;
             --w;
           } else {
             ++r;
           }
         }
-        if (compare3(arr6[r], pivot) > 0) {
+        if (compare3(arr7[r], pivot) > 0) {
           --r;
         }
         if (k <= r) {
@@ -27940,7 +27940,7 @@ var createPartitionSelect = /* @__PURE__ */ factory(
           from = r + 1;
         }
       }
-      return arr6[k];
+      return arr7[k];
     }
   }
 );
@@ -27976,7 +27976,7 @@ var createPinv = /* @__PURE__ */ factory(
     divideScalar: divideScalar2,
     multiply: multiply2,
     add: add2,
-    Complex: Complex11
+    Complex: Complex12
   }) => {
     return typed3(name172, {
       "Array | Matrix": function(x) {
@@ -28071,12 +28071,12 @@ var createPinv = /* @__PURE__ */ factory(
       return { C, F };
     }
     function _isZero(x) {
-      return equal2(add2(x, Complex11(1, 1)), add2(0, Complex11(1, 1)));
+      return equal2(add2(x, Complex12(1, 1)), add2(0, Complex12(1, 1)));
     }
-    function _isZeros(arr6) {
+    function _isZeros(arr7) {
       return deepEqual3(
-        add2(arr6, Complex11(1, 1)),
-        add2(multiply2(arr6, 0), Complex11(1, 1))
+        add2(arr7, Complex12(1, 1)),
+        add2(multiply2(arr7, 0), Complex12(1, 1))
       );
     }
   }
@@ -28393,11 +28393,11 @@ var createRange = /* @__PURE__ */ factory(
         return _out(_range(start, end, step, includeEnd));
       }
     });
-    function _out(arr6) {
+    function _out(arr7) {
       if (config.matrix === "Matrix") {
-        return matrix2 ? matrix2(arr6) : noMatrix();
+        return matrix2 ? matrix2(arr7) : noMatrix();
       }
-      return arr6;
+      return arr7;
     }
     function _strRange(str, includeEnd) {
       const r = _parse2(str);
@@ -28429,8 +28429,8 @@ var createRange = /* @__PURE__ */ factory(
       const nums = args.map(function(arg3) {
         return Number(arg3);
       });
-      const invalid = nums.some(function(num) {
-        return isNaN(num);
+      const invalid = nums.some(function(num2) {
+        return isNaN(num2);
       });
       if (invalid) {
         return null;
@@ -28467,25 +28467,25 @@ var createGamma = /* @__PURE__ */ factory(
     multiplyScalar: _multiplyScalar,
     pow: _pow,
     BigNumber: BigNumber9,
-    Complex: Complex11
+    Complex: Complex12
   }) => {
     function gammaComplex(n) {
       if (n.im === 0) {
         return gammaNumber(n.re);
       }
       if (n.re < 0.5) {
-        const t2 = new Complex11(1 - n.re, -n.im);
-        const r = new Complex11(Math.PI * n.re, Math.PI * n.im);
+        const t2 = new Complex12(1 - n.re, -n.im);
+        const r = new Complex12(Math.PI * n.re, Math.PI * n.im);
         const gammaT = gammaComplex(t2);
-        return new Complex11(Math.PI).div(r.sin()).div(gammaT);
+        return new Complex12(Math.PI).div(r.sin()).div(gammaT);
       }
-      const z = new Complex11(n.re - 1, n.im);
-      let x = new Complex11(gammaP[0], 0);
+      const z = new Complex12(n.re - 1, n.im);
+      let x = new Complex12(gammaP[0], 0);
       for (let i = 1; i < gammaP.length; ++i) {
-        const gammaPval = new Complex11(gammaP[i], 0);
+        const gammaPval = new Complex12(gammaP[i], 0);
         x = x.add(gammaPval.div(z.add(i)));
       }
-      const t = new Complex11(z.re + gammaG + 0.5, z.im);
+      const t = new Complex12(z.re + gammaG + 0.5, z.im);
       const twoPiSqrt = Math.sqrt(2 * Math.PI);
       const tpow = t.pow(z.add(0.5));
       const expt = t.neg().exp();
@@ -28704,9 +28704,9 @@ var createEqualText = /* @__PURE__ */ factory(
 
 // src/statistics/max.ts
 var WASM_MAX_THRESHOLD = 100;
-function isFlatNumberArray5(arr6) {
-  for (let i = 0; i < arr6.length; i++) {
-    if (typeof arr6[i] !== "number") {
+function isFlatNumberArray5(arr7) {
+  for (let i = 0; i < arr7.length; i++) {
+    if (typeof arr7[i] !== "number") {
       return false;
     }
   }
@@ -28783,9 +28783,9 @@ var createMax = /* @__PURE__ */ factory(
 
 // src/statistics/min.ts
 var WASM_MIN_THRESHOLD = 100;
-function isFlatNumberArray6(arr6) {
-  for (let i = 0; i < arr6.length; i++) {
-    if (typeof arr6[i] !== "number") {
+function isFlatNumberArray6(arr7) {
+  for (let i = 0; i < arr7.length; i++) {
+    if (typeof arr7[i] !== "number") {
       return false;
     }
   }
@@ -28870,8 +28870,8 @@ var createNullish = /* @__PURE__ */ factory(
     const matAlgo03xDSf = createMatAlgo03xDSf({ typed: typed3 });
     const matAlgo14xDs = createMatAlgo14xDs({ typed: typed3 });
     const matAlgo13xDD = createMatAlgo13xDD({ typed: typed3 });
-    const toMatrix = (arr6) => {
-      return matrix2(arr6);
+    const toMatrix = (arr7) => {
+      return matrix2(arr7);
     };
     return typed3(name180, {
       // Scalar and SparseMatrix-first short-circuit handlers
@@ -29183,11 +29183,11 @@ var createDistance = /* @__PURE__ */ factory(
           throw new TypeError("Invalid Arguments: Try again");
         }
       },
-      Array: function(arr6) {
-        if (!_pairwise(arr6)) {
+      Array: function(arr7) {
+        if (!_pairwise(arr7)) {
           throw new TypeError("Incorrect array format entered for pairwise distance calculation");
         }
-        return _distancePairwise(arr6);
+        return _distancePairwise(arr7);
       }
     });
     function _isNumber(a) {
@@ -29197,15 +29197,15 @@ var createDistance = /* @__PURE__ */ factory(
       if (!Array.isArray(a)) {
         a = _objectToArray(a);
       }
-      const arr6 = a;
-      return _isNumber(arr6[0]) && _isNumber(arr6[1]);
+      const arr7 = a;
+      return _isNumber(arr7[0]) && _isNumber(arr7[1]);
     }
     function _3d(a) {
       if (!Array.isArray(a)) {
         a = _objectToArray(a);
       }
-      const arr6 = a;
-      return _isNumber(arr6[0]) && _isNumber(arr6[1]) && _isNumber(arr6[2]);
+      const arr7 = a;
+      return _isNumber(arr7[0]) && _isNumber(arr7[1]) && _isNumber(arr7[2]);
     }
     function _containsOnlyNumbers(a) {
       if (!Array.isArray(a)) {
@@ -29217,8 +29217,8 @@ var createDistance = /* @__PURE__ */ factory(
       if (!Array.isArray(a)) {
         a = _objectToArray(a);
       }
-      const arr6 = a;
-      return _isNumber(arr6[0]) && _isNumber(arr6[1]) && _isNumber(arr6[2]) && _isNumber(arr6[3]) && _isNumber(arr6[4]) && _isNumber(arr6[5]);
+      const arr7 = a;
+      return _isNumber(arr7[0]) && _isNumber(arr7[1]) && _isNumber(arr7[2]) && _isNumber(arr7[3]) && _isNumber(arr7[4]) && _isNumber(arr7[5]);
     }
     function _objectToArray(o) {
       const keys = Object.keys(o);
@@ -29245,9 +29245,9 @@ var createDistance = /* @__PURE__ */ factory(
       return true;
     }
     function _distancePointLine2D(x, y, a, b, c) {
-      const num = abs2(addScalar2(addScalar2(multiplyScalar2(a, x), multiplyScalar2(b, y)), c));
+      const num2 = abs2(addScalar2(addScalar2(multiplyScalar2(a, x), multiplyScalar2(b, y)), c));
       const den = sqrt2(addScalar2(multiplyScalar2(a, a), multiplyScalar2(b, b)));
-      return divideScalar2(num, den);
+      return divideScalar2(num2, den);
     }
     function _distancePointLine3D(x, y, z, x0, y0, z0, a, b, c) {
       const numComponents = [
@@ -29264,7 +29264,7 @@ var createDistance = /* @__PURE__ */ factory(
           multiplyScalar2(subtractScalar2(y0, y), a)
         )
       ];
-      const num = sqrt2(
+      const num2 = sqrt2(
         addScalar2(
           addScalar2(
             multiplyScalar2(numComponents[0], numComponents[0]),
@@ -29276,7 +29276,7 @@ var createDistance = /* @__PURE__ */ factory(
       const den = sqrt2(
         addScalar2(addScalar2(multiplyScalar2(a, a), multiplyScalar2(b, b)), multiplyScalar2(c, c))
       );
-      return divideScalar2(num, den);
+      return divideScalar2(num2, den);
     }
     function _euclideanDistance(x, y) {
       const vectorSize = x.length;
@@ -29846,7 +29846,7 @@ var createResolve = /* @__PURE__ */ factory(
   dependencies192,
   ({
     typed: typed3,
-    parse: parse2,
+    parse: parse3,
     ConstantNode,
     FunctionNode,
     OperatorNode,
@@ -29869,7 +29869,7 @@ var createResolve = /* @__PURE__ */ factory(
           nextWithin.add(symbolNode.name);
           return _resolve(value, scope, nextWithin);
         } else if (typeof value === "number") {
-          return parse2(String(value));
+          return parse3(String(value));
         } else if (value !== void 0) {
           return new ConstantNode(value);
         } else {
@@ -30137,7 +30137,7 @@ var createSimplifyConstant = /* @__PURE__ */ factory(
     config,
     mathWithTransform,
     matrix: matrix2,
-    parse: parse2,
+    parse: parse3,
     isBounded: isBounded2,
     fraction: fraction2,
     bignumber: bignumber2,
@@ -30156,9 +30156,9 @@ var createSimplifyConstant = /* @__PURE__ */ factory(
       SymbolNode
     });
     const simplifyConstant2 = typed3("simplifyConstant", {
-      string: (expr) => _ensureNode(foldFraction(parse2(expr), {})),
+      string: (expr) => _ensureNode(foldFraction(parse3(expr), {})),
       "string, Object": function(expr, options) {
-        return _ensureNode(foldFraction(parse2(expr), options));
+        return _ensureNode(foldFraction(parse3(expr), options));
       },
       Node: (node) => _ensureNode(foldFraction(node, {})),
       "Node, Object": function(expr, options) {
@@ -30539,11 +30539,11 @@ var WASM_FFT_THRESHOLD = 64;
 function isPowerOf22(n) {
   return n > 0 && (n & n - 1) === 0;
 }
-function complexToInterleaved(arr6, _complex) {
-  const n = arr6.length;
+function complexToInterleaved(arr7, _complex) {
+  const n = arr7.length;
   const result = new Float64Array(n * 2);
   for (let i = 0; i < n; i++) {
-    const val = arr6[i];
+    const val = arr7[i];
     if (typeof val === "number") {
       result[i * 2] = val;
       result[i * 2 + 1] = 0;
@@ -30605,40 +30605,40 @@ var createFft = /* @__PURE__ */ factory(
         return matrix2.create(_ndFft(matrix2.valueOf()), matrix2._datatype);
       }
     });
-    function _ndFft(arr6) {
-      const size2 = arraySize(arr6);
-      if (size2.length === 1) return _fft(arr6, size2[0]);
+    function _ndFft(arr7) {
+      const size2 = arraySize(arr7);
+      if (size2.length === 1) return _fft(arr7, size2[0]);
       return _1dFft(
-        arr6.map((slice) => _ndFft(slice)),
+        arr7.map((slice) => _ndFft(slice)),
         0
       );
     }
-    function _1dFft(arr6, dim) {
-      const size2 = arraySize(arr6);
+    function _1dFft(arr7, dim) {
+      const size2 = arraySize(arr7);
       if (dim !== 0) {
         const result = [];
         for (let i = 0; i < size2[0]; i++) {
-          result.push(_1dFft(arr6[i], dim - 1));
+          result.push(_1dFft(arr7[i], dim - 1));
         }
         return result;
       }
-      if (size2.length === 1) return _fft(arr6);
-      function _transpose(arr7) {
-        const size3 = arraySize(arr7);
+      if (size2.length === 1) return _fft(arr7);
+      function _transpose(arr8) {
+        const size3 = arraySize(arr8);
         const result = [];
         for (let j = 0; j < size3[1]; j++) {
           const row2 = [];
           for (let i = 0; i < size3[0]; i++) {
-            row2.push(arr7[i][j]);
+            row2.push(arr8[i][j]);
           }
           result.push(row2);
         }
         return result;
       }
-      return _transpose(_1dFft(_transpose(arr6), 1));
+      return _transpose(_1dFft(_transpose(arr7), 1));
     }
-    function _czt(arr6) {
-      const n = arr6.length;
+    function _czt(arr7) {
+      const n = arr7.length;
       const w = exp2(divideScalar2(multiplyScalar2(-1, multiplyScalar2(I2, tau2)), n));
       const chirp = [];
       for (let i = 1 - n; i < n; i++) {
@@ -30647,7 +30647,7 @@ var createFft = /* @__PURE__ */ factory(
       const N2 = pow2(2, ceil2(log24(n + n - 1)));
       const xp = [];
       for (let i = 0; i < n; i++) {
-        xp.push(multiplyScalar2(arr6[i], chirp[n - 1 + i]));
+        xp.push(multiplyScalar2(arr7[i], chirp[n - 1 + i]));
       }
       for (let i = 0; i < N2 - n; i++) {
         xp.push(0);
@@ -30672,12 +30672,12 @@ var createFft = /* @__PURE__ */ factory(
       }
       return ret;
     }
-    function _fft(arr6, len) {
-      const length = len ?? arr6.length;
-      if (length === 1) return [arr6[0]];
+    function _fft(arr7, len) {
+      const length = len ?? arr7.length;
+      if (length === 1) return [arr7[0]];
       const wasm = wasmLoader.getModule();
       if (wasm && length >= WASM_FFT_THRESHOLD && isPowerOf22(length) && len === void 0) {
-        const interleaved = complexToInterleaved(arr6, complex2);
+        const interleaved = complexToInterleaved(arr7, complex2);
         if (interleaved) {
           try {
             const dataAlloc = wasmLoader.allocateFloat64Array(interleaved);
@@ -30694,11 +30694,11 @@ var createFft = /* @__PURE__ */ factory(
       if (length % 2 === 0) {
         const ret = [
           ..._fft(
-            arr6.filter((_, i) => i % 2 === 0),
+            arr7.filter((_, i) => i % 2 === 0),
             length / 2
           ),
           ..._fft(
-            arr6.filter((_, i) => i % 2 === 1),
+            arr7.filter((_, i) => i % 2 === 1),
             length / 2
           )
         ];
@@ -30713,7 +30713,7 @@ var createFft = /* @__PURE__ */ factory(
         }
         return ret;
       } else {
-        return _czt(arr6);
+        return _czt(arr7);
       }
     }
   }
@@ -30984,11 +30984,11 @@ var WASM_IFFT_THRESHOLD = 64;
 function isPowerOf23(n) {
   return n > 0 && (n & n - 1) === 0;
 }
-function complexToInterleaved2(arr6, _complex) {
-  const n = arr6.length;
+function complexToInterleaved2(arr7, _complex) {
+  const n = arr7.length;
   const result = new Float64Array(n * 2);
   for (let i = 0; i < n; i++) {
-    const val = arr6[i];
+    const val = arr7[i];
     if (typeof val === "number") {
       result[i * 2] = val;
       result[i * 2 + 1] = 0;
@@ -31016,14 +31016,14 @@ var createIfft = /* @__PURE__ */ factory(
   dependencies200,
   ({ typed: typed3, fft: fft2, dotDivide: dotDivide2, conj: conj3, complex: complex2 }) => {
     return typed3(name200, {
-      "Array | Matrix": function(arr6) {
-        const size2 = isMatrix(arr6) ? arr6.size() : arraySize(arr6);
+      "Array | Matrix": function(arr7) {
+        const size2 = isMatrix(arr7) ? arr7.size() : arraySize(arr7);
         const totalSize = size2.reduce((acc, curr) => acc * curr, 1);
         if (size2.length === 1) {
           const length = size2[0];
           const wasm = wasmLoader.getModule();
           if (wasm && length >= WASM_IFFT_THRESHOLD && isPowerOf23(length)) {
-            const arrData = isMatrix(arr6) ? arr6.valueOf() : arr6;
+            const arrData = isMatrix(arr7) ? arr7.valueOf() : arr7;
             const interleaved = complexToInterleaved2(arrData, complex2);
             if (interleaved) {
               try {
@@ -31031,8 +31031,8 @@ var createIfft = /* @__PURE__ */ factory(
                 try {
                   wasm.fft(dataAlloc.ptr, length, 1);
                   const result = interleavedToComplex2(dataAlloc.array, length, complex2);
-                  if (isMatrix(arr6)) {
-                    return arr6.create(result);
+                  if (isMatrix(arr7)) {
+                    return arr7.create(result);
                   }
                   return result;
                 } finally {
@@ -31043,7 +31043,7 @@ var createIfft = /* @__PURE__ */ factory(
             }
           }
         }
-        return dotDivide2(conj3(fft2(conj3(arr6))), totalSize);
+        return dotDivide2(conj3(fft2(conj3(arr7))), totalSize);
       }
     });
   }
@@ -31569,7 +31569,7 @@ var createUnitClass = /* @__PURE__ */ factory(
     isNumeric: isNumeric2,
     format: format6,
     number: number2,
-    Complex: Complex11,
+    Complex: Complex12,
     BigNumber: BigNumber9,
     Fraction: Fraction5
   }) => {
@@ -33683,7 +33683,7 @@ var createUnitClass = /* @__PURE__ */ factory(
         name: "VAR",
         base: BASE_UNITS.POWER,
         prefixes: PREFIXES.SHORT,
-        value: Complex11.I,
+        value: Complex12.I,
         offset: 0
       },
       VA: {
@@ -34943,51 +34943,51 @@ var createDiff = /* @__PURE__ */ factory(
     number: number2
   }) => {
     return typed3(name211, {
-      "Array | Matrix": function(arr6) {
-        if (isMatrix(arr6)) {
-          return matrix2(_diff(arr6.toArray()));
+      "Array | Matrix": function(arr7) {
+        if (isMatrix(arr7)) {
+          return matrix2(_diff(arr7.toArray()));
         } else {
-          return _diff(arr6);
+          return _diff(arr7);
         }
       },
-      "Array | Matrix, number": function(arr6, dim) {
+      "Array | Matrix, number": function(arr7, dim) {
         if (!isInteger(dim)) throw new RangeError("Dimension must be a whole number");
-        if (isMatrix(arr6)) {
-          return matrix2(_recursive(arr6.toArray(), dim));
+        if (isMatrix(arr7)) {
+          return matrix2(_recursive(arr7.toArray(), dim));
         } else {
-          return _recursive(arr6, dim);
+          return _recursive(arr7, dim);
         }
       },
       // typed-function's runtime `referTo` is single-call variadic
       // (`referTo(...signatures, callback)`); the imported TypedFunction interface
       // models it curried, so narrow to the real contract via `unknown`.
-      "Array, BigNumber": typed3.referTo("Array,number", (selfAn) => (arr6, dim) => selfAn(arr6, number2(dim))),
-      "Matrix, BigNumber": typed3.referTo("Matrix,number", (selfMn) => (arr6, dim) => selfMn(arr6, number2(dim)))
+      "Array, BigNumber": typed3.referTo("Array,number", (selfAn) => (arr7, dim) => selfAn(arr7, number2(dim))),
+      "Matrix, BigNumber": typed3.referTo("Matrix,number", (selfMn) => (arr7, dim) => selfMn(arr7, number2(dim)))
     });
-    function _recursive(arr6, dim) {
-      if (isMatrix(arr6)) {
-        arr6 = arr6.toArray();
+    function _recursive(arr7, dim) {
+      if (isMatrix(arr7)) {
+        arr7 = arr7.toArray();
       }
-      if (!Array.isArray(arr6)) {
+      if (!Array.isArray(arr7)) {
         throw RangeError("Array/Matrix does not have that many dimensions");
       }
       if (dim > 0) {
         const result = [];
-        arr6.forEach((element2) => {
+        arr7.forEach((element2) => {
           result.push(_recursive(element2, dim - 1));
         });
         return result;
       } else if (dim === 0) {
-        return _diff(arr6);
+        return _diff(arr7);
       } else {
         throw RangeError("Cannot have negative dimension");
       }
     }
-    function _diff(arr6) {
+    function _diff(arr7) {
       const result = [];
-      const size2 = arr6.length;
+      const size2 = arr7.length;
       for (let i = 1; i < size2; i++) {
-        result.push(_ElementDiff(arr6[i - 1], arr6[i]));
+        result.push(_ElementDiff(arr7[i - 1], arr7[i]));
       }
       return result;
     }
@@ -36073,21 +36073,21 @@ var createIntersect = /* @__PURE__ */ factory(
       "Array, Array, Array": _AAA,
       "Array, Array, Array, Array": _AAAA,
       "Matrix, Matrix, Matrix": function(x, y, plane) {
-        const arr6 = _AAA(
+        const arr7 = _AAA(
           x.valueOf(),
           y.valueOf(),
           plane.valueOf()
         );
-        return arr6 === null ? null : matrix2(arr6);
+        return arr7 === null ? null : matrix2(arr7);
       },
       "Matrix, Matrix, Matrix, Matrix": function(w, x, y, z) {
-        const arr6 = _AAAA(
+        const arr7 = _AAAA(
           w.valueOf(),
           x.valueOf(),
           y.valueOf(),
           z.valueOf()
         );
-        return arr6 === null ? null : matrix2(arr6);
+        return arr7 === null ? null : matrix2(arr7);
       }
     });
     function _AAA(x, y, plane) {
@@ -36153,13 +36153,13 @@ var createIntersect = /* @__PURE__ */ factory(
         throw new TypeError("Arrays with two or thee dimensional points expected");
       }
     }
-    function _coerceArr(arr6) {
-      if (arr6.length === 1 && Array.isArray(arr6[0])) return arr6[0];
-      if (arr6.length > 1 && Array.isArray(arr6[0])) {
-        if (arr6.every((el) => Array.isArray(el) && el.length === 1))
-          return flatten4(arr6);
+    function _coerceArr(arr7) {
+      if (arr7.length === 1 && Array.isArray(arr7[0])) return arr7[0];
+      if (arr7.length > 1 && Array.isArray(arr7[0])) {
+        if (arr7.every((el) => Array.isArray(el) && el.length === 1))
+          return flatten4(arr7);
       }
-      return arr6;
+      return arr7;
     }
     function _2d(x) {
       return x.length === 2 && isNumeric2(x[0]) && isNumeric2(x[1]);
@@ -36299,9 +36299,9 @@ var createIntersect = /* @__PURE__ */ factory(
 
 // src/statistics/mean.ts
 var WASM_MEAN_THRESHOLD = 100;
-function isFlatNumberArray7(arr6) {
-  for (let i = 0; i < arr6.length; i++) {
-    if (typeof arr6[i] !== "number") {
+function isFlatNumberArray7(arr7) {
+  for (let i = 0; i < arr7.length; i++) {
+    if (typeof arr7[i] !== "number") {
       return false;
     }
   }
@@ -36354,19 +36354,19 @@ var createMean = /* @__PURE__ */ factory(
         }
       }
       let sum3;
-      let num = 0;
+      let num2 = 0;
       deepForEach2(array, function(value) {
         try {
           sum3 = sum3 === void 0 ? value : add2(sum3, value);
-          num++;
+          num2++;
         } catch (err) {
           throw improveErrorMessage(err, "mean", value);
         }
       });
-      if (num === 0) {
+      if (num2 === 0) {
         throw new Error("Cannot calculate the mean of an empty array");
       }
-      return divide2(sum3, num);
+      return divide2(sum3, num2);
     }
   }
 );
@@ -36381,12 +36381,12 @@ var createMedian = /* @__PURE__ */ factory(
     function _median(array) {
       try {
         const flat = flatten2(array.valueOf());
-        const num = flat.length;
-        if (num === 0) {
+        const num2 = flat.length;
+        if (num2 === 0) {
           throw new Error("Cannot calculate median of an empty array");
         }
-        if (num % 2 === 0) {
-          const mid = num / 2 - 1;
+        if (num2 % 2 === 0) {
+          const mid = num2 / 2 - 1;
           const right = partitionSelect2(flat, mid + 1);
           let left = flat[mid];
           for (let i = 0; i < mid; ++i) {
@@ -36396,7 +36396,7 @@ var createMedian = /* @__PURE__ */ factory(
           }
           return middle2(left, right);
         } else {
-          const m = partitionSelect2(flat, (num - 1) / 2);
+          const m = partitionSelect2(flat, (num2 - 1) / 2);
           return middle(m);
         }
       } catch (err) {
@@ -36433,9 +36433,9 @@ var createMedian = /* @__PURE__ */ factory(
 
 // src/statistics/variance.ts
 var WASM_VARIANCE_THRESHOLD = 100;
-function isFlatNumberArray8(arr6) {
-  for (let i = 0; i < arr6.length; i++) {
-    if (typeof arr6[i] !== "number") {
+function isFlatNumberArray8(arr7) {
+  for (let i = 0; i < arr7.length; i++) {
+    if (typeof arr7[i] !== "number") {
       return false;
     }
   }
@@ -36496,20 +36496,20 @@ var createVariance = /* @__PURE__ */ factory(
         }
       }
       let sum3;
-      let num = 0;
+      let num2 = 0;
       deepForEach2(array, function(value) {
         try {
           sum3 = sum3 === void 0 ? value : add2(sum3, value);
-          num++;
+          num2++;
         } catch (err) {
           throw improveErrorMessage(err, "variance", value);
         }
       });
-      if (num === 0) throw new Error("Cannot calculate variance of an empty array");
-      const mean5 = divide2(sum3, num);
+      if (num2 === 0) throw new Error("Cannot calculate variance of an empty array");
+      const mean6 = divide2(sum3, num2);
       sum3 = void 0;
       deepForEach2(array, function(value) {
-        const diff2 = subtract2(value, mean5);
+        const diff2 = subtract2(value, mean6);
         sum3 = sum3 === void 0 ? multiply2(diff2, diff2) : add2(sum3, multiply2(diff2, diff2));
       });
       if (mathIsNaN(sum3)) {
@@ -36517,12 +36517,12 @@ var createVariance = /* @__PURE__ */ factory(
       }
       switch (normalization) {
         case "uncorrected":
-          return divide2(sum3, num);
+          return divide2(sum3, num2);
         case "biased":
-          return divide2(sum3, num + 1);
+          return divide2(sum3, num2 + 1);
         case "unbiased": {
           const zero = isBigNumber(sum3) ? sum3.mul(0) : 0;
-          return num === 1 ? zero : divide2(sum3, num - 1);
+          return num2 === 1 ? zero : divide2(sum3, num2 - 1);
         }
         default:
           throw new Error(
@@ -36776,7 +36776,7 @@ var dependencies226 = ["typed", "add", "multiply", "Complex", "divide", "matrix"
 var createFreqz = /* @__PURE__ */ factory(
   name226,
   dependencies226,
-  ({ typed: typed3, add: add2, multiply: multiply2, Complex: Complex11, divide: divide2, matrix: matrix2 }) => {
+  ({ typed: typed3, add: add2, multiply: multiply2, Complex: Complex12, divide: divide2, matrix: matrix2 }) => {
     return typed3(name226, {
       "Array, Array": function(b, a) {
         const w = createBins(512);
@@ -36845,7 +36845,7 @@ var createFreqz = /* @__PURE__ */ factory(
           );
           const h = [];
           for (let i = 0; i < w.length; i++) {
-            h.push(Complex11(hRealAlloc.array[i], hImagAlloc.array[i]));
+            h.push(Complex12(hRealAlloc.array[i], hImagAlloc.array[i]));
           }
           return { h, w };
         } finally {
@@ -36864,29 +36864,29 @@ var createFreqz = /* @__PURE__ */ factory(
       if (wasmResult !== null) {
         return wasmResult;
       }
-      const num = [];
+      const num2 = [];
       const den = [];
       for (let i = 0; i < w.length; i++) {
-        let sumNum = Complex11(0, 0);
-        let sumDen = Complex11(0, 0);
+        let sumNum = Complex12(0, 0);
+        let sumDen = Complex12(0, 0);
         for (let j = 0; j < b.length; j++) {
           sumNum = add2(
             sumNum,
-            multiply2(b[j], Complex11(Math.cos(-j * w[i]), Math.sin(-j * w[i])))
+            multiply2(b[j], Complex12(Math.cos(-j * w[i]), Math.sin(-j * w[i])))
           );
         }
         for (let j = 0; j < a.length; j++) {
           sumDen = add2(
             sumDen,
-            multiply2(a[j], Complex11(Math.cos(-j * w[i]), Math.sin(-j * w[i])))
+            multiply2(a[j], Complex12(Math.cos(-j * w[i]), Math.sin(-j * w[i])))
           );
         }
-        num.push(sumNum);
+        num2.push(sumNum);
         den.push(sumDen);
       }
       const h = [];
-      for (let i = 0; i < num.length; i++) {
-        h.push(divide2(num[i], den[i]));
+      for (let i = 0; i < num2.length; i++) {
+        h.push(divide2(num2[i], den[i]));
       }
       return { h, w };
     }
@@ -37868,22 +37868,22 @@ var createSolveODE = /* @__PURE__ */ factory(
       const stageAlloc = wasmLoader.allocateFloat64ArrayEmpty(numStages * dim);
       try {
         let readVec2 = function(alloc) {
-          const arr6 = new Float64Array(wasm.memory.buffer, alloc.ptr, dim);
+          const arr7 = new Float64Array(wasm.memory.buffer, alloc.ptr, dim);
           const result = new Array(dim);
           for (let i = 0; i < dim; i++) {
-            result[i] = arr6[i];
+            result[i] = arr7[i];
           }
           return result;
         }, writeVec2 = function(alloc, data) {
-          const arr6 = new Float64Array(wasm.memory.buffer, alloc.ptr, dim);
+          const arr7 = new Float64Array(wasm.memory.buffer, alloc.ptr, dim);
           for (let i = 0; i < dim; i++) {
-            arr6[i] = data[i];
+            arr7[i] = data[i];
           }
         }, writeStage2 = function(stageIdx, data) {
           const offset = stageIdx * dim;
-          const arr6 = new Float64Array(wasm.memory.buffer, stageAlloc.ptr, numStages * dim);
+          const arr7 = new Float64Array(wasm.memory.buffer, stageAlloc.ptr, numStages * dim);
           for (let i = 0; i < dim; i++) {
-            arr6[offset + i] = data[i];
+            arr7[offset + i] = data[i];
           }
         }, trimStepNum2 = function(tn, tfn, hn) {
           const next = tn + hn;
@@ -38179,7 +38179,7 @@ var createZeta = /* @__PURE__ */ factory(
     sin: sin2,
     subtract: subtract2,
     add: add2,
-    Complex: Complex11,
+    Complex: Complex12,
     BigNumber: BigNumber9,
     pi
   }) => {
@@ -38215,16 +38215,16 @@ var createZeta = /* @__PURE__ */ factory(
     }
     function zetaComplex(s) {
       if (s.re === 0 && s.im === 0) {
-        return new Complex11(-0.5);
+        return new Complex12(-0.5);
       }
       if (s.re === 1) {
-        return new Complex11(NaN, NaN);
+        return new Complex12(NaN, NaN);
       }
       if (s.re === Infinity && s.im === 0) {
-        return new Complex11(1);
+        return new Complex12(1);
       }
       if (s.im === Infinity || s.re === -Infinity) {
-        return new Complex11(NaN, NaN);
+        return new Complex12(NaN, NaN);
       }
       return zeta2(
         s,
@@ -38327,12 +38327,12 @@ function createComplexEigs({
   matrixFromColumns: _matrixFromColumns,
   dot: dot3
 }) {
-  function complexEigs(arr6, N, prec, type, findVectors = true) {
+  function complexEigs(arr7, N, prec, type, findVectors = true) {
     if (!findVectors && type === "number" && N * N >= WASM_EIGS_THRESHOLD) {
       const wasm = wasmLoader.getModule();
       if (wasm) {
         try {
-          const flat = flattenToFloat648(arr6, N, N);
+          const flat = flattenToFloat648(arr7, N, N);
           const matrixAlloc = wasmLoader.allocateFloat64Array(flat);
           const eigenvaluesRealAlloc = wasmLoader.allocateFloat64ArrayEmpty(N);
           const eigenvaluesImagAlloc = wasmLoader.allocateFloat64ArrayEmpty(N);
@@ -38376,16 +38376,16 @@ function createComplexEigs({
         }
       }
     }
-    const R = balance(arr6, N, prec, type, findVectors);
-    reduceToHessenberg(arr6, N, prec, type, findVectors, R);
-    const { values, C } = iterateUntilTriangular(arr6, N, prec, type, findVectors);
+    const R = balance(arr7, N, prec, type, findVectors);
+    reduceToHessenberg(arr7, N, prec, type, findVectors, R);
+    const { values, C } = iterateUntilTriangular(arr7, N, prec, type, findVectors);
     if (findVectors) {
-      const eigenvectors = findEigenvectors(arr6, N, C, R, values, prec, type);
+      const eigenvectors = findEigenvectors(arr7, N, C, R, values, prec, type);
       return { values, eigenvectors };
     }
     return { values };
   }
-  function balance(arr6, N, _prec, type, findVectors) {
+  function balance(arr7, N, _prec, type, findVectors) {
     const big = type === "BigNumber";
     const cplx = type === "Complex";
     const realzero = big ? bignumber2(0) : 0;
@@ -38405,8 +38405,8 @@ function createComplexEigs({
         let rowNorm = realzero;
         for (let j = 0; j < N; j++) {
           if (i === j) continue;
-          colNorm = addScalar2(colNorm, abs2(arr6[j][i]));
-          rowNorm = addScalar2(rowNorm, abs2(arr6[i][j]));
+          colNorm = addScalar2(colNorm, abs2(arr7[j][i]));
+          rowNorm = addScalar2(rowNorm, abs2(arr7[i][j]));
         }
         if (!equal2(colNorm, 0) && !equal2(rowNorm, 0)) {
           let f = realone;
@@ -38432,8 +38432,8 @@ function createComplexEigs({
               if (i === j) {
                 continue;
               }
-              arr6[i][j] = multiplyScalar2(arr6[i][j], g);
-              arr6[j][i] = multiplyScalar2(arr6[j][i], f);
+              arr7[i][j] = multiplyScalar2(arr7[i][j], g);
+              arr7[j][i] = multiplyScalar2(arr7[j][i], f);
             }
             if (findVectors) {
               Rdiag[i] = multiplyScalar2(Rdiag[i], g);
@@ -38444,7 +38444,7 @@ function createComplexEigs({
     }
     return findVectors ? diag2(Rdiag) : null;
   }
-  function reduceToHessenberg(arr6, N, prec, type, findVectors, R) {
+  function reduceToHessenberg(arr7, N, prec, type, findVectors, R) {
     const big = type === "BigNumber";
     const cplx = type === "Complex";
     const zero = big ? bignumber2(0) : cplx ? complex2(0) : 0;
@@ -38455,7 +38455,7 @@ function createComplexEigs({
       let maxIndex = 0;
       let max2 = zero;
       for (let j = i + 1; j < N; j++) {
-        const el = arr6[j][i];
+        const el = arr7[j][i];
         if (smaller2(abs2(max2), abs2(el))) {
           max2 = el;
           maxIndex = j;
@@ -38465,13 +38465,13 @@ function createComplexEigs({
         continue;
       }
       if (maxIndex !== i + 1) {
-        const tmp1 = arr6[maxIndex];
-        arr6[maxIndex] = arr6[i + 1];
-        arr6[i + 1] = tmp1;
+        const tmp1 = arr7[maxIndex];
+        arr7[maxIndex] = arr7[i + 1];
+        arr7[i + 1] = tmp1;
         for (let j = 0; j < N; j++) {
-          const tmp2 = arr6[j][maxIndex];
-          arr6[j][maxIndex] = arr6[j][i + 1];
-          arr6[j][i + 1] = tmp2;
+          const tmp2 = arr7[j][maxIndex];
+          arr7[j][maxIndex] = arr7[j][i + 1];
+          arr7[j][i + 1] = tmp2;
         }
         if (findVectors) {
           const tmp3 = R[maxIndex];
@@ -38480,15 +38480,15 @@ function createComplexEigs({
         }
       }
       for (let j = i + 2; j < N; j++) {
-        const n = divideScalar2(arr6[j][i], max2);
+        const n = divideScalar2(arr7[j][i], max2);
         if (n === 0) {
           continue;
         }
         for (let k = 0; k < N; k++) {
-          arr6[j][k] = subtract2(arr6[j][k], multiplyScalar2(n, arr6[i + 1][k]));
+          arr7[j][k] = subtract2(arr7[j][k], multiplyScalar2(n, arr7[i + 1][k]));
         }
         for (let k = 0; k < N; k++) {
-          arr6[k][i + 1] = addScalar2(arr6[k][i + 1], multiplyScalar2(n, arr6[k][j]));
+          arr7[k][i + 1] = addScalar2(arr7[k][i + 1], multiplyScalar2(n, arr7[k][j]));
         }
         if (findVectors) {
           for (let k = 0; k < N; k++) {
@@ -38505,7 +38505,7 @@ function createComplexEigs({
     if (big) {
       prec = bignumber2(prec);
     }
-    let arr6 = clone(A);
+    let arr7 = clone(A);
     const lambdas = [];
     let n = N;
     const Sdiag = [];
@@ -38514,21 +38514,21 @@ function createComplexEigs({
     let lastConvergenceBefore = 0;
     while (lastConvergenceBefore <= 100) {
       lastConvergenceBefore += 1;
-      const k = arr6[n - 1][n - 1];
+      const k = arr7[n - 1][n - 1];
       for (let i = 0; i < n; i++) {
-        arr6[i][i] = subtract2(arr6[i][i], k);
+        arr7[i][i] = subtract2(arr7[i][i], k);
       }
-      const { Q: Q2, R } = qr2(arr6);
-      arr6 = multiply2(R, Q2);
+      const { Q: Q2, R } = qr2(arr7);
+      arr7 = multiply2(R, Q2);
       for (let i = 0; i < n; i++) {
-        arr6[i][i] = addScalar2(arr6[i][i], k);
+        arr7[i][i] = addScalar2(arr7[i][i], k);
       }
       if (findVectors) {
         Qpartial = multiply2(Qpartial, Q2);
       }
-      if (n === 1 || smaller2(abs2(arr6[n - 1][n - 2]), prec)) {
+      if (n === 1 || smaller2(abs2(arr7[n - 1][n - 2]), prec)) {
         lastConvergenceBefore = 0;
-        lambdas.push(arr6[n - 1][n - 1]);
+        lambdas.push(arr7[n - 1][n - 1]);
         if (findVectors) {
           Sdiag.unshift([[1]]);
           inflateMatrix(Qpartial, N);
@@ -38538,26 +38538,26 @@ function createComplexEigs({
           }
         }
         n -= 1;
-        arr6.pop();
+        arr7.pop();
         for (let i = 0; i < n; i++) {
-          arr6[i].pop();
+          arr7[i].pop();
         }
-      } else if (n === 2 || smaller2(abs2(arr6[n - 2][n - 3]), prec)) {
+      } else if (n === 2 || smaller2(abs2(arr7[n - 2][n - 3]), prec)) {
         lastConvergenceBefore = 0;
         const ll = eigenvalues2x2(
-          arr6[n - 2][n - 2],
-          arr6[n - 2][n - 1],
-          arr6[n - 1][n - 2],
-          arr6[n - 1][n - 1]
+          arr7[n - 2][n - 2],
+          arr7[n - 2][n - 1],
+          arr7[n - 1][n - 2],
+          arr7[n - 1][n - 1]
         );
         lambdas.push(...ll);
         if (findVectors) {
           Sdiag.unshift(
             jordanBase2x2(
-              arr6[n - 2][n - 2],
-              arr6[n - 2][n - 1],
-              arr6[n - 1][n - 2],
-              arr6[n - 1][n - 1],
+              arr7[n - 2][n - 2],
+              arr7[n - 2][n - 1],
+              arr7[n - 1][n - 2],
+              arr7[n - 1][n - 1],
               ll[0],
               ll[1],
               prec,
@@ -38571,11 +38571,11 @@ function createComplexEigs({
           }
         }
         n -= 2;
-        arr6.pop();
-        arr6.pop();
+        arr7.pop();
+        arr7.pop();
         for (let i = 0; i < n; i++) {
-          arr6[i].pop();
-          arr6[i].pop();
+          arr7[i].pop();
+          arr7[i].pop();
         }
       }
       if (n === 0) {
@@ -38680,23 +38680,23 @@ function createComplexEigs({
       ];
     }
   }
-  function inflateMatrix(arr6, N) {
-    for (let i = 0; i < arr6.length; i++) {
-      arr6[i].push(...Array(N - arr6[i].length).fill(0));
+  function inflateMatrix(arr7, N) {
+    for (let i = 0; i < arr7.length; i++) {
+      arr7[i].push(...Array(N - arr7[i].length).fill(0));
     }
-    for (let i = arr6.length; i < N; i++) {
-      arr6.push(Array(N).fill(0));
-      arr6[i][i] = 1;
+    for (let i = arr7.length; i < N; i++) {
+      arr7.push(Array(N).fill(0));
+      arr7[i][i] = 1;
     }
-    return arr6;
+    return arr7;
   }
-  function blockDiag(arr6, N) {
+  function blockDiag(arr7, N) {
     const M = [];
     for (let i = 0; i < N; i++) {
       M[i] = Array(N).fill(0);
     }
     let I2 = 0;
-    for (const sub of arr6) {
+    for (const sub of arr7) {
       const n = sub.length;
       for (let i = 0; i < n; i++) {
         for (let j = 0; j < n; j++) {
@@ -38707,9 +38707,9 @@ function createComplexEigs({
     }
     return M;
   }
-  function indexOf(arr6, el, fn) {
-    for (let i = 0; i < arr6.length; i++) {
-      if (fn(arr6[i], el)) {
+  function indexOf(arr7, el, fn) {
+    for (let i = 0; i < arr7.length; i++) {
+      if (fn(arr7[i], el)) {
         return i;
       }
     }
@@ -38822,12 +38822,12 @@ function createRealSymmetric({
     if (typeof a === "number" && typeof b === "number") return a <= b;
     return a.lte(b);
   }
-  function main(arr6, _N, prec = config.relTol, type, computeVectors) {
+  function main(arr7, _N, prec = config.relTol, type, computeVectors) {
     if (type === "number") {
-      return diag2(arr6, prec, computeVectors);
+      return diag2(arr7, prec, computeVectors);
     }
     if (type === "BigNumber") {
-      return diagBig(arr6, prec, computeVectors);
+      return diagBig(arr7, prec, computeVectors);
     }
     throw TypeError("Unsupported data type: " + type);
   }
@@ -39289,18 +39289,18 @@ var createEigs = /* @__PURE__ */ factory(
       return result;
     }
     function computeValuesAndVectors(mat, prec, computeVectors) {
-      const arr6 = mat.toArray();
+      const arr7 = mat.toArray();
       const asize = mat.size();
       if (asize.length !== 2 || asize[0] !== asize[1]) {
         throw new RangeError(`Matrix must be square (size: ${format3(asize, {})})`);
       }
       const N = asize[0];
-      if (isReal(arr6, N, prec)) {
-        coerceReal(arr6, N);
-        if (isSymmetric(arr6, N, prec)) {
-          const type2 = coerceTypes(mat, arr6, N);
+      if (isReal(arr7, N, prec)) {
+        coerceReal(arr7, N);
+        if (isSymmetric(arr7, N, prec)) {
+          const type2 = coerceTypes(mat, arr7, N);
           return doRealSymmetric(
-            arr6,
+            arr7,
             N,
             prec,
             type2,
@@ -39308,37 +39308,37 @@ var createEigs = /* @__PURE__ */ factory(
           );
         }
       }
-      const type = coerceTypes(mat, arr6, N);
-      return doComplexEigs(arr6, N, prec, type, computeVectors);
+      const type = coerceTypes(mat, arr7, N);
+      return doComplexEigs(arr7, N, prec, type, computeVectors);
     }
-    function isSymmetric(arr6, N, prec) {
+    function isSymmetric(arr7, N, prec) {
       for (let i = 0; i < N; i++) {
         for (let j = i; j < N; j++) {
-          if (larger2(bignumber2(abs2(subtract2(arr6[i][j], arr6[j][i]))), prec)) {
+          if (larger2(bignumber2(abs2(subtract2(arr7[i][j], arr7[j][i]))), prec)) {
             return false;
           }
         }
       }
       return true;
     }
-    function isReal(arr6, N, prec) {
+    function isReal(arr7, N, prec) {
       for (let i = 0; i < N; i++) {
         for (let j = 0; j < N; j++) {
-          if (larger2(bignumber2(abs2(im3(arr6[i][j]))), prec)) {
+          if (larger2(bignumber2(abs2(im3(arr7[i][j]))), prec)) {
             return false;
           }
         }
       }
       return true;
     }
-    function coerceReal(arr6, N) {
+    function coerceReal(arr7, N) {
       for (let i = 0; i < N; i++) {
         for (let j = 0; j < N; j++) {
-          arr6[i][j] = re3(arr6[i][j]);
+          arr7[i][j] = re3(arr7[i][j]);
         }
       }
     }
-    function coerceTypes(mat, arr6, N) {
+    function coerceTypes(mat, arr7, N) {
       const type = mat.datatype();
       if (type === "number" || type === "BigNumber" || type === "Complex") {
         return type;
@@ -39348,7 +39348,7 @@ var createEigs = /* @__PURE__ */ factory(
       let hasComplex = false;
       for (let i = 0; i < N; i++) {
         for (let j = 0; j < N; j++) {
-          const el = arr6[i][j];
+          const el = arr7[i][j];
           if (isNumber(el) || isFraction(el)) {
             hasNumber = true;
           } else if (isBigNumber(el)) {
@@ -39366,7 +39366,7 @@ var createEigs = /* @__PURE__ */ factory(
       if (hasComplex) {
         for (let i = 0; i < N; i++) {
           for (let j = 0; j < N; j++) {
-            arr6[i][j] = complex2(arr6[i][j]);
+            arr7[i][j] = complex2(arr7[i][j]);
           }
         }
         return "Complex";
@@ -39374,7 +39374,7 @@ var createEigs = /* @__PURE__ */ factory(
       if (hasBig) {
         for (let i = 0; i < N; i++) {
           for (let j = 0; j < N; j++) {
-            arr6[i][j] = bignumber2(arr6[i][j]);
+            arr7[i][j] = bignumber2(arr7[i][j]);
           }
         }
         return "BigNumber";
@@ -39382,7 +39382,7 @@ var createEigs = /* @__PURE__ */ factory(
       if (hasNumber) {
         for (let i = 0; i < N; i++) {
           for (let j = 0; j < N; j++) {
-            arr6[i][j] = number2(arr6[i][j]);
+            arr7[i][j] = number2(arr7[i][j]);
           }
         }
         return "number";
@@ -39600,9 +39600,9 @@ var createLusolve = /* @__PURE__ */ factory(
 
 // src/statistics/corr.ts
 var WASM_CORR_THRESHOLD = 200;
-function isPlainNumberArray(arr6) {
-  for (let i = 0; i < arr6.length; i++) {
-    if (typeof arr6[i] !== "number") {
+function isPlainNumberArray(arr7) {
+  for (let i = 0; i < arr7.length; i++) {
+    if (typeof arr7[i] !== "number") {
       return false;
     }
   }
@@ -39697,9 +39697,9 @@ var createCorr = /* @__PURE__ */ factory(
 
 // src/statistics/mad.ts
 var WASM_MAD_THRESHOLD = 500;
-function isPlainNumberArray2(arr6) {
-  for (let i = 0; i < arr6.length; i++) {
-    if (typeof arr6[i] !== "number") {
+function isPlainNumberArray2(arr7) {
+  for (let i = 0; i < arr7.length; i++) {
+    if (typeof arr7[i] !== "number") {
       return false;
     }
   }
@@ -39757,9 +39757,9 @@ var createMad = /* @__PURE__ */ factory(
 
 // src/statistics/std.ts
 var WASM_STD_THRESHOLD = 100;
-function isFlatNumberArray9(arr6) {
-  for (let i = 0; i < arr6.length; i++) {
-    if (typeof arr6[i] !== "number") {
+function isFlatNumberArray9(arr7) {
+  for (let i = 0; i < arr7.length; i++) {
+    if (typeof arr7[i] !== "number") {
       return false;
     }
   }
@@ -39892,7 +39892,7 @@ var createSimplify = /* @__PURE__ */ factory(
   dependencies245,
   ({
     typed: typed3,
-    parse: parse2,
+    parse: parse3,
     equal: equal2,
     resolve: resolve2,
     simplifyConstant: simplifyConstant2,
@@ -40202,8 +40202,8 @@ var createSimplify = /* @__PURE__ */ factory(
         newRule.l = ruleObject.l;
         newRule.r = ruleObject.r;
       }
-      newRule.l = removeParens(parse2(newRule.l));
-      newRule.r = removeParens(parse2(newRule.r));
+      newRule.l = removeParens(parse3(newRule.l));
+      newRule.r = removeParens(parse3(newRule.r));
       if ("imposeContext" in ruleObject && ruleObject.imposeContext) {
         newRule.imposeContext = ruleObject.imposeContext;
       }
@@ -40214,7 +40214,7 @@ var createSimplify = /* @__PURE__ */ factory(
         newRule.assuming = ruleObject.assuming;
       }
       if (ruleObject.evaluate) {
-        newRule.evaluate = parse2(ruleObject.evaluate);
+        newRule.evaluate = parse3(ruleObject.evaluate);
       }
       if (isAssociative(newRule.l, context)) {
         const nonCommutative = !isCommutative(newRule.l, context);
@@ -40699,7 +40699,7 @@ var createDerivative = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     config,
-    parse: parse2,
+    parse: parse3,
     simplify: simplify2,
     equal: equal2,
     isZero: isZero2,
@@ -40726,7 +40726,7 @@ var createDerivative = /* @__PURE__ */ factory(
       return options.simplify ? simplify2(res) : res;
     }
     function parseIdentifier(string2) {
-      const symbol = parse2(string2);
+      const symbol = parse3(string2);
       if (!symbol.isSymbolNode) {
         throw new TypeError(
           `Invalid variable. Cannot parse ${JSON.stringify(string2)} into a variable in function derivative`
@@ -40757,14 +40757,14 @@ var createDerivative = /* @__PURE__ */ factory(
     const _derivTex = typed3("_derivTex", {
       "Node, SymbolNode": function(expr, x) {
         if (isConstantNode(expr) && typeOf(expr.value) === "string") {
-          return _derivTex(parse2(expr.value).toString(), x.toString(), 1);
+          return _derivTex(parse3(expr.value).toString(), x.toString(), 1);
         } else {
           return _derivTex(expr.toTex(), x.toString(), 1);
         }
       },
       "Node, ConstantNode": function(expr, x) {
         if (typeOf(x.value) === "string") {
-          return _derivTex(expr, parse2(x.value));
+          return _derivTex(expr, parse3(x.value));
         } else {
           throw new Error("The second parameter to 'derivative' is a non-string constant");
         }
@@ -40789,40 +40789,40 @@ var createDerivative = /* @__PURE__ */ factory(
       "function, SymbolNode, string": function(_isConst2, node, varName) {
         return node.name !== varName;
       },
-      "function, ParenthesisNode, string": function(isConst, node, varName) {
-        return isConst(node.content, varName);
+      "function, ParenthesisNode, string": function(isConst2, node, varName) {
+        return isConst2(node.content, varName);
       },
-      "function, FunctionAssignmentNode, string": function(isConst, node, varName) {
+      "function, FunctionAssignmentNode, string": function(isConst2, node, varName) {
         if (!node.params.includes(varName)) {
           return true;
         }
-        return isConst(node.expr, varName);
+        return isConst2(node.expr, varName);
       },
-      "function, FunctionNode | OperatorNode, string": function(isConst, node, varName) {
-        return node.args.every((arg3) => isConst(arg3, varName));
+      "function, FunctionNode | OperatorNode, string": function(isConst2, node, varName) {
+        return node.args.every((arg3) => isConst2(arg3, varName));
       }
     });
     const _derivative = typed3("_derivative", {
       "ConstantNode, function": function() {
         return createConstantNode2(0);
       },
-      "SymbolNode, function": function(node, isConst) {
-        if (isConst(node)) {
+      "SymbolNode, function": function(node, isConst2) {
+        if (isConst2(node)) {
           return createConstantNode2(0);
         }
         return createConstantNode2(1);
       },
-      "ParenthesisNode, function": function(node, isConst) {
-        return new ParenthesisNode(_derivative(node.content, isConst));
+      "ParenthesisNode, function": function(node, isConst2) {
+        return new ParenthesisNode(_derivative(node.content, isConst2));
       },
-      "FunctionAssignmentNode, function": function(node, isConst) {
-        if (isConst(node)) {
+      "FunctionAssignmentNode, function": function(node, isConst2) {
+        if (isConst2(node)) {
           return createConstantNode2(0);
         }
-        return _derivative(node.expr, isConst);
+        return _derivative(node.expr, isConst2);
       },
-      "FunctionNode, function": function(node, isConst) {
-        if (isConst(node)) {
+      "FunctionNode, function": function(node, isConst2) {
+        if (isConst2(node)) {
           return createConstantNode2(0);
         }
         const arg0 = node.args[0];
@@ -40851,7 +40851,7 @@ var createDerivative = /* @__PURE__ */ factory(
               ]);
             } else if (node.args.length === 2) {
               arg1 = new OperatorNode("/", "divide", [createConstantNode2(1), node.args[1]]);
-              return _derivative(new OperatorNode("^", "pow", [arg0, arg1]), isConst);
+              return _derivative(new OperatorNode("^", "pow", [arg0, arg1]), isConst2);
             }
             break;
           case "log10":
@@ -40862,7 +40862,7 @@ var createDerivative = /* @__PURE__ */ factory(
             if (!arg1 && node.args.length === 1) {
               funcDerivative = arg0.clone();
               div = true;
-            } else if (node.args.length === 1 && arg1 || node.args.length === 2 && isConst(node.args[1])) {
+            } else if (node.args.length === 1 && arg1 || node.args.length === 2 && isConst2(node.args[1])) {
               funcDerivative = new OperatorNode("*", "multiply", [
                 arg0.clone(),
                 new FunctionNode("log", [arg1 || node.args[1]])
@@ -40874,13 +40874,13 @@ var createDerivative = /* @__PURE__ */ factory(
                   new FunctionNode("log", [arg0]),
                   new FunctionNode("log", [node.args[1]])
                 ]),
-                isConst
+                isConst2
               );
             }
             break;
           case "pow":
             if (node.args.length === 2) {
-              return _derivative(new OperatorNode("^", "pow", [arg0, node.args[1]]), isConst);
+              return _derivative(new OperatorNode("^", "pow", [arg0, node.args[1]]), isConst2);
             }
             break;
           case "exp":
@@ -41093,14 +41093,14 @@ var createDerivative = /* @__PURE__ */ factory(
           op = "*";
           func = "multiply";
         }
-        let chainDerivative = _derivative(arg0, isConst);
+        let chainDerivative = _derivative(arg0, isConst2);
         if (negative) {
           chainDerivative = new OperatorNode("-", "unaryMinus", [chainDerivative]);
         }
         return new OperatorNode(op, func, [chainDerivative, funcDerivative]);
       },
-      "OperatorNode, function": function(node, isConst) {
-        if (isConst(node)) {
+      "OperatorNode, function": function(node, isConst2) {
+        if (isConst2(node)) {
           return createConstantNode2(0);
         }
         if (node.op === "+") {
@@ -41108,33 +41108,33 @@ var createDerivative = /* @__PURE__ */ factory(
             node.op,
             node.fn,
             node.args.map(function(arg3) {
-              return _derivative(arg3, isConst);
+              return _derivative(arg3, isConst2);
             })
           );
         }
         if (node.op === "-") {
           if (node.isUnary()) {
             return new OperatorNode(node.op, node.fn, [
-              _derivative(node.args[0], isConst)
+              _derivative(node.args[0], isConst2)
             ]);
           }
           if (node.isBinary()) {
             return new OperatorNode(node.op, node.fn, [
-              _derivative(node.args[0], isConst),
-              _derivative(node.args[1], isConst)
+              _derivative(node.args[0], isConst2),
+              _derivative(node.args[1], isConst2)
             ]);
           }
         }
         if (node.op === "*") {
           const constantTerms = node.args.filter(function(arg3) {
-            return isConst(arg3);
+            return isConst2(arg3);
           });
           if (constantTerms.length > 0) {
             const nonConstantTerms = node.args.filter(function(arg3) {
-              return !isConst(arg3);
+              return !isConst2(arg3);
             });
             const nonConstantNode = nonConstantTerms.length === 1 ? nonConstantTerms[0] : new OperatorNode("*", "multiply", nonConstantTerms);
-            const newArgs = constantTerms.concat(_derivative(nonConstantNode, isConst));
+            const newArgs = constantTerms.concat(_derivative(nonConstantNode, isConst2));
             return new OperatorNode("*", "multiply", newArgs);
           }
           return new OperatorNode(
@@ -41145,7 +41145,7 @@ var createDerivative = /* @__PURE__ */ factory(
                 "*",
                 "multiply",
                 node.args.map(function(argInner) {
-                  return argInner === argOuter ? _derivative(argInner, isConst) : argInner.clone();
+                  return argInner === argOuter ? _derivative(argInner, isConst2) : argInner.clone();
                 })
               );
             })
@@ -41154,22 +41154,22 @@ var createDerivative = /* @__PURE__ */ factory(
         if (node.op === "/" && node.isBinary()) {
           const arg0 = node.args[0];
           const arg1 = node.args[1];
-          if (isConst(arg1)) {
-            return new OperatorNode("/", "divide", [_derivative(arg0, isConst), arg1]);
+          if (isConst2(arg1)) {
+            return new OperatorNode("/", "divide", [_derivative(arg0, isConst2), arg1]);
           }
-          if (isConst(arg0)) {
+          if (isConst2(arg0)) {
             return new OperatorNode("*", "multiply", [
               new OperatorNode("-", "unaryMinus", [arg0]),
               new OperatorNode("/", "divide", [
-                _derivative(arg1, isConst),
+                _derivative(arg1, isConst2),
                 new OperatorNode("^", "pow", [arg1.clone(), createConstantNode2(2)])
               ])
             ]);
           }
           return new OperatorNode("/", "divide", [
             new OperatorNode("-", "subtract", [
-              new OperatorNode("*", "multiply", [_derivative(arg0, isConst), arg1.clone()]),
-              new OperatorNode("*", "multiply", [arg0.clone(), _derivative(arg1, isConst)])
+              new OperatorNode("*", "multiply", [_derivative(arg0, isConst2), arg1.clone()]),
+              new OperatorNode("*", "multiply", [arg0.clone(), _derivative(arg1, isConst2)])
             ]),
             new OperatorNode("^", "pow", [arg1.clone(), createConstantNode2(2)])
           ]);
@@ -41177,7 +41177,7 @@ var createDerivative = /* @__PURE__ */ factory(
         if (node.op === "^" && node.isBinary()) {
           const arg0 = node.args[0];
           const arg1 = node.args[1];
-          if (isConst(arg0)) {
+          if (isConst2(arg0)) {
             if (isConstantNode(arg0) && (isZero2(arg0.value) || equal2(arg0.value, 1))) {
               return createConstantNode2(0);
             }
@@ -41185,17 +41185,17 @@ var createDerivative = /* @__PURE__ */ factory(
               node,
               new OperatorNode("*", "multiply", [
                 new FunctionNode("log", [arg0.clone()]),
-                _derivative(arg1.clone(), isConst)
+                _derivative(arg1.clone(), isConst2)
               ])
             ]);
           }
-          if (isConst(arg1)) {
+          if (isConst2(arg1)) {
             if (isConstantNode(arg1)) {
               if (isZero2(arg1.value)) {
                 return createConstantNode2(0);
               }
               if (equal2(arg1.value, 1)) {
-                return _derivative(arg0, isConst);
+                return _derivative(arg0, isConst2);
               }
             }
             const powMinusOne = new OperatorNode("^", "pow", [
@@ -41204,18 +41204,18 @@ var createDerivative = /* @__PURE__ */ factory(
             ]);
             return new OperatorNode("*", "multiply", [
               arg1.clone(),
-              new OperatorNode("*", "multiply", [_derivative(arg0, isConst), powMinusOne])
+              new OperatorNode("*", "multiply", [_derivative(arg0, isConst2), powMinusOne])
             ]);
           }
           return new OperatorNode("*", "multiply", [
             new OperatorNode("^", "pow", [arg0.clone(), arg1.clone()]),
             new OperatorNode("+", "add", [
               new OperatorNode("*", "multiply", [
-                _derivative(arg0, isConst),
+                _derivative(arg0, isConst2),
                 new OperatorNode("/", "divide", [arg1.clone(), arg0.clone()])
               ]),
               new OperatorNode("*", "multiply", [
-                _derivative(arg1, isConst),
+                _derivative(arg1, isConst2),
                 new FunctionNode("log", [arg0.clone()])
               ])
             ])
@@ -41298,12 +41298,12 @@ var createNorm = /* @__PURE__ */ factory(
       if (size2.length !== 1 || size2[0] < WASM_NORM_THRESHOLD) return null;
       const wasm = wasmLoader.getModule();
       if (!wasm) return null;
-      const arr6 = x.toArray();
-      const n = arr6.length;
+      const arr7 = x.toArray();
+      const n = arr7.length;
       const data = new Float64Array(n);
       for (let i = 0; i < n; i++) {
-        if (typeof arr6[i] !== "number") return null;
-        data[i] = arr6[i];
+        if (typeof arr7[i] !== "number") return null;
+        data[i] = arr7[i];
       }
       const alloc = wasmLoader.allocateFloat64Array(data);
       try {
@@ -43675,13 +43675,13 @@ var inverseLaplaceTable = [
   {
     pattern: /^([\d.]+)\/\(__VAR__\^2 \+ ([\d.]+)\)$/,
     transform: (m, _s, t) => {
-      const num = parseFloat(m[1]);
+      const num2 = parseFloat(m[1]);
       const den = parseFloat(m[2]);
       const w = Math.sqrt(den);
-      if (Math.abs(num - w) < 1e-10) {
+      if (Math.abs(num2 - w) < 1e-10) {
         return `sin(${formatCoeff(w)}*${t})`;
       }
-      return `${formatCoeff(num / w)}*sin(${formatCoeff(w)}*${t})`;
+      return `${formatCoeff(num2 / w)}*sin(${formatCoeff(w)}*${t})`;
     }
   }
 ];
@@ -44129,10 +44129,10 @@ function minimalPolynomial(expr, varName) {
   const alpha = evaluate(expr);
   if (!isFinite(alpha)) return null;
   for (let den = 1; den <= 100; den++) {
-    const num = Math.round(alpha * den);
-    if (Math.abs(alpha - num / den) < 1e-12) {
-      if (den === 1) return `${varName} - ${num}`;
-      return `${den}*${varName} - ${num}`;
+    const num2 = Math.round(alpha * den);
+    if (Math.abs(alpha - num2 / den) < 1e-12) {
+      if (den === 1) return `${varName} - ${num2}`;
+      return `${den}*${varName} - ${num2}`;
     }
   }
   const powers = [1, alpha, alpha * alpha, alpha * alpha * alpha, alpha ** 4];
@@ -44473,10 +44473,10 @@ function iltNiceNumber(val) {
   const rounded = Math.round(val);
   if (Math.abs(val - rounded) < 1e-8) return String(rounded);
   for (let den = 2; den <= 12; den++) {
-    const num = Math.round(val * den);
-    if (Math.abs(val - num / den) < 1e-8) {
-      const g = iltGcd(Math.abs(num), den);
-      const n = num / g;
+    const num2 = Math.round(val * den);
+    if (Math.abs(val - num2 / den) < 1e-8) {
+      const g = iltGcd(Math.abs(num2), den);
+      const n = num2 / g;
       const d = den / g;
       return d === 1 ? String(n) : n + "/" + d;
     }
@@ -45154,11 +45154,13 @@ function rankdata(x) {
 function gmean(x) {
   const a = arr(x);
   if (a.length === 0) return NaN;
+  if (a.some((v) => v <= 0)) throw new Error("gmean: all entries must be > 0");
   return Math.exp(mean2(a.map(Math.log)));
 }
 function hmean(x) {
   const a = arr(x);
   if (a.length === 0) return NaN;
+  if (a.some((v) => v <= 0)) throw new Error("hmean: all entries must be > 0");
   return a.length / sum2(a.map((v) => 1 / v));
 }
 function moment(x, k, central = true) {
@@ -45173,9 +45175,11 @@ function skewness(x, opts = {}) {
   const a = arr(x);
   const n = a.length;
   const m2 = centralMoment(a, 2);
+  if (m2 === 0) throw new Error("skewness: variance is zero (constant input); skewness undefined");
   const m3 = centralMoment(a, 3);
   const g1 = m3 / Math.pow(m2, 1.5);
-  if (opts.bias === false && n > 2) {
+  if (opts.bias === false) {
+    if (n <= 2) return NaN;
     return Math.sqrt(n * (n - 1)) / (n - 2) * g1;
   }
   return g1;
@@ -45184,9 +45188,11 @@ function kurtosis(x, opts = {}) {
   const a = arr(x);
   const n = a.length;
   const m2 = centralMoment(a, 2);
+  if (m2 === 0) throw new Error("kurtosis: variance is zero (constant input); kurtosis undefined");
   const m4 = centralMoment(a, 4);
   let g2 = m4 / (m2 * m2);
-  if (opts.bias === false && n > 3) {
+  if (opts.bias === false) {
+    if (n <= 3) return NaN;
     g2 = (n - 1) / ((n - 2) * (n - 3)) * ((n + 1) * g2 - 3 * (n - 1)) + 3;
   }
   return opts.fisher === false ? g2 : g2 - 3;
@@ -45202,8 +45208,10 @@ function sem(x) {
 }
 function zscore(x) {
   const a = arr(x);
+  if (a.length === 0) return [];
   const m = mean2(a);
   const s = stdPop(a);
+  if (s === 0) throw new Error("zscore: standard deviation is zero (constant input)");
   return a.map((v) => (v - m) / s);
 }
 function cov(x, y, ddof = 1) {
@@ -45211,6 +45219,8 @@ function cov(x, y, ddof = 1) {
     const a = arr(x);
     const b = arr(y);
     if (a.length !== b.length) throw new Error(`cov: length mismatch ${a.length} vs ${b.length}`);
+    if (a.length <= ddof)
+      throw new Error(`cov: need more than ddof=${ddof} observations (got n=${a.length})`);
     const ma = mean2(a);
     const mb = mean2(b);
     let acc = 0;
@@ -45219,7 +45229,9 @@ function cov(x, y, ddof = 1) {
   }
   const M = x.map((r) => Array.from(r));
   const nObs = M.length;
-  const nVar = nObs > 0 ? M[0].length : 0;
+  if (nObs <= ddof)
+    throw new Error(`cov: need more than ddof=${ddof} observations (got n=${nObs})`);
+  const nVar = M[0].length;
   const cols = Array.from({ length: nVar }, (_, j) => M.map((r) => r[j]));
   const means = cols.map(mean2);
   const out = Array.from({ length: nVar }, () => new Array(nVar).fill(0));
@@ -45246,6 +45258,11 @@ function corrcoef(matrix2) {
 
 // src/numeric-extra.ts
 var toArr = (x) => Array.isArray(x) ? x : Array.from(x);
+var maxOf = (a) => {
+  let m = -Infinity;
+  for (let i = 0; i < a.length; i++) if (a[i] > m) m = a[i];
+  return m;
+};
 function clamp(x, lo, hi) {
   const c = (v) => v < lo ? lo : v > hi ? hi : v;
   return Array.isArray(x) ? x.map(c) : c(x);
@@ -45257,7 +45274,7 @@ function sigmoid(x) {
 function logsumexp(x) {
   const a = toArr(x);
   if (a.length === 0) return -Infinity;
-  const m = max(a);
+  const m = maxOf(a);
   if (!Number.isFinite(m)) return m;
   let acc = 0;
   for (let i = 0; i < a.length; i++) acc += Math.exp(a[i] - m);
@@ -45266,7 +45283,7 @@ function logsumexp(x) {
 function softmax(x) {
   const a = toArr(x);
   if (a.length === 0) return [];
-  const m = max(a);
+  const m = maxOf(a);
   const e = a.map((v) => Math.exp(v - m));
   const z = sum(e);
   return e.map((v) => v / z);
@@ -45304,7 +45321,17 @@ function cummin(x) {
 function cumtrapz(y, x) {
   const a = toArr(y);
   const out = new Array(a.length).fill(0);
-  const dxAt = typeof x === "number" ? (_i) => x : x !== void 0 ? /* @__PURE__ */ ((xs) => (i) => xs[i + 1] - xs[i])(toArr(x)) : (_i) => 1;
+  let dxAt;
+  if (typeof x === "number") {
+    dxAt = () => x;
+  } else if (x !== void 0) {
+    const xs = toArr(x);
+    if (xs.length < a.length)
+      throw new Error(`cumtrapz: abscissa x (length ${xs.length}) is shorter than y (length ${a.length})`);
+    dxAt = (i) => xs[i + 1] - xs[i];
+  } else {
+    dxAt = () => 1;
+  }
   let acc = 0;
   for (let i = 1; i < a.length; i++) {
     acc += (a[i] + a[i - 1]) / 2 * dxAt(i - 1);
@@ -45341,8 +45368,17 @@ var logisticQuantile = (p, mu = 0, s = 1) => mu + s * Math.log(p / (1 - p));
 // src/hypothesis-extra.ts
 var arr2 = (x) => Array.isArray(x) ? x : Array.from(x);
 var sampleVar = (x) => variance(x);
+var mean3 = (x) => mean(x);
 var normalCDF2 = (z) => normalCDF(z);
+var normalPDF2 = (z) => normalPDF(z);
 var lgamma3 = (n) => lgamma(n);
+function simpson2(f, a, b, n = 512) {
+  const m = n % 2 === 0 ? n : n + 1;
+  const h = (b - a) / m;
+  let s = f(a) + f(b);
+  for (let i = 1; i < m; i++) s += (i % 2 === 0 ? 2 : 4) * f(a + i * h);
+  return s * h / 3;
+}
 function tieTerm(values) {
   const sorted = [...values].sort((a, b) => a - b);
   let term = 0;
@@ -45358,9 +45394,13 @@ function tieTerm(values) {
 function fTest(x, y) {
   const a = arr2(x);
   const b = arr2(y);
+  if (a.length < 2 || b.length < 2)
+    throw new Error("fTest: each sample needs at least 2 observations");
   const df1 = a.length - 1;
   const df2 = b.length - 1;
-  const statistic = sampleVar(a) / sampleVar(b);
+  const vb = sampleVar(b);
+  if (vb === 0) throw new Error("fTest: denominator sample has zero variance");
+  const statistic = sampleVar(a) / vb;
   const lower = fCDF(statistic, df1, df2);
   const pValue = 2 * Math.min(lower, 1 - lower);
   return { statistic, pValue, df1, df2 };
@@ -45368,6 +45408,7 @@ function fTest(x, y) {
 function jarqueBera(x) {
   const a = arr2(x);
   const n = a.length;
+  if (n < 2) throw new Error("jarqueBera: need at least 2 observations");
   const s = skewness(a);
   const k = kurtosis(a);
   const statistic = n / 6 * (s * s + k * k / 4);
@@ -45376,6 +45417,7 @@ function jarqueBera(x) {
 }
 function kruskalWallis(...groups) {
   const arrs = groups.map(arr2).filter((g) => g.length > 0);
+  if (arrs.length < 2) throw new Error("kruskalWallis: need at least 2 non-empty groups");
   const pooled = arrs.flat();
   const N = pooled.length;
   const ranks = rankdata(pooled);
@@ -45395,9 +45437,13 @@ function kruskalWallis(...groups) {
 }
 function wilcoxon(x, y) {
   const a = arr2(x);
-  const diffs = (y !== void 0 ? arr2(y) : null) ? a.map((v, i) => v - arr2(y)[i]) : a;
+  const yy = y !== void 0 ? arr2(y) : void 0;
+  if (yy !== void 0 && yy.length !== a.length)
+    throw new Error(`wilcoxon: paired samples must have equal length (${a.length} vs ${yy.length})`);
+  const diffs = yy !== void 0 ? a.map((v, i) => v - yy[i]) : a;
   const d = diffs.filter((v) => v !== 0);
   const n = d.length;
+  if (n === 0) throw new Error("wilcoxon: all differences are zero (test undefined)");
   const ranks = rankdata(d.map(Math.abs));
   let wPlus = 0;
   let wMinus = 0;
@@ -45434,12 +45480,110 @@ function fisherExact(table) {
   const oddsRatio = b * c === 0 ? Infinity : a * d / (b * c);
   return { oddsRatio, pValue: Math.min(1, p) };
 }
+function rangeProb(w, k) {
+  if (w <= 0) return 0;
+  const integrand = (z) => k * normalPDF2(z) * Math.pow(normalCDF2(z) - normalCDF2(z - w), k - 1);
+  return Math.min(1, Math.max(0, simpson2(integrand, -8.5, 8.5, 240)));
+}
+function studentizedRangeCDF(q, k, df) {
+  if (!(k >= 2)) throw new Error("studentizedRangeCDF: k (number of groups) must be >= 2");
+  if (q <= 0) return 0;
+  if (!Number.isFinite(df)) return rangeProb(q, k);
+  if (!(df > 0)) throw new Error("studentizedRangeCDF: df must be > 0");
+  const nu = df;
+  const logc = nu / 2 * Math.log(nu) - (nu / 2 - 1) * Math.log(2) - lgamma3(nu / 2);
+  const fU = (u) => Math.exp(logc + (nu - 1) * Math.log(u) - nu * u * u / 2);
+  let umax = 1 + 12 / Math.sqrt(nu);
+  for (let iter = 0; iter < 20 && simpson2(fU, 1e-5, umax, 120) < 1 - 1e-6; iter++) umax *= 1.5;
+  return Math.min(1, Math.max(0, simpson2((u) => fU(u) * rangeProb(q * u, k), 1e-5, umax, 120)));
+}
+function studentizedRangeQuantile(p, k, df) {
+  if (!(p > 0 && p < 1)) throw new Error("studentizedRangeQuantile: p must be in (0, 1)");
+  let lo = 0;
+  let hi = 1;
+  for (let iter = 0; studentizedRangeCDF(hi, k, df) < p; iter++) {
+    if (iter >= 60)
+      throw new Error(`studentizedRangeQuantile: failed to bracket p=${p} (CDF plateaued below p)`);
+    hi *= 2;
+  }
+  for (let i = 0; i < 45; i++) {
+    const mid = (lo + hi) / 2;
+    if (studentizedRangeCDF(mid, k, df) < p) lo = mid;
+    else hi = mid;
+  }
+  return (lo + hi) / 2;
+}
+function tukeyHSD(groups, alpha = 0.05) {
+  const gs = groups.map(arr2);
+  const k = gs.length;
+  if (k < 2) throw new Error("tukeyHSD: need at least 2 groups");
+  const means = gs.map(mean3);
+  const N = gs.reduce((s, g) => s + g.length, 0);
+  const dfErr = N - k;
+  if (dfErr <= 0)
+    throw new Error("tukeyHSD: residual df must be > 0 (groups must hold more observations than groups)");
+  const sse = gs.reduce((s, g) => s + sampleVar(g) * (g.length - 1), 0);
+  const mse = sse / dfErr;
+  const qCrit = studentizedRangeQuantile(1 - alpha, k, dfErr);
+  const out = [];
+  for (let i = 0; i < k; i++) {
+    for (let j = i + 1; j < k; j++) {
+      const diff2 = means[i] - means[j];
+      const se = Math.sqrt(mse / 2 * (1 / gs[i].length + 1 / gs[j].length));
+      const q = Math.abs(diff2) / se;
+      out.push({
+        groups: [i, j],
+        meanDifference: diff2,
+        qStatistic: q,
+        pValue: 1 - studentizedRangeCDF(q, k, dfErr),
+        reject: q > qCrit
+      });
+    }
+  }
+  return out;
+}
 
 // src/linalg-extra.ts
 import { DenseMatrix as DenseMatrix5, lu as lu2 } from "@danielsimonjr/mathts-matrix";
 var _inv = inv;
 var _eigs = eigs;
 var _multiply = multiply;
+var _qr = qr;
+var transposeArr = (A) => A[0].map((_, j) => A.map((r) => r[j]));
+var identityArr = (n) => Array.from({ length: n }, (_, i) => Array.from({ length: n }, (_2, j) => i === j ? 1 : 0));
+function realSchur(M) {
+  const n = M.length;
+  let A = M.map((r) => r.slice());
+  let U = identityArr(n);
+  let m = n;
+  for (let iter = 0; iter < 8e3 && m > 1; iter++) {
+    if (Math.abs(A[m - 1][m - 2]) < 1e-14 * (Math.abs(A[m - 2][m - 2]) + Math.abs(A[m - 1][m - 1]))) {
+      A[m - 1][m - 2] = 0;
+      m--;
+      continue;
+    }
+    const a = A[m - 2][m - 2];
+    const b = A[m - 2][m - 1];
+    const c = A[m - 1][m - 2];
+    const d = A[m - 1][m - 1];
+    const delta = (a - d) / 2;
+    const disc = delta * delta + b * c;
+    const denom = Math.abs(delta) + Math.sqrt(Math.abs(disc));
+    const s = disc >= 0 && denom > 1e-300 ? d - (Math.sign(delta) || 1) * (b * c) / denom : d;
+    const As = A.map((r, i) => r.map((v, j) => v - (i === j ? s : 0)));
+    const { Q: Q2, R } = _qr(As);
+    A = _multiply(R, Q2).map((r, i) => r.map((v, j) => v + (i === j ? s : 0)));
+    U = _multiply(U, Q2);
+  }
+  for (let i = 2; i < n; i++) {
+    for (let j = 0; j < i - 1; j++) {
+      if (Math.abs(A[i][j]) > 1e-8 * (1 + Math.abs(A[i][i]) + Math.abs(A[j][j]))) {
+        throw new Error("realSchur: QR iteration failed to converge to (quasi-)triangular form");
+      }
+    }
+  }
+  return { U, S: A };
+}
 var arr3 = (x) => Array.isArray(x) ? x : Array.from(x);
 function generalizedEig(A, B) {
   const Binv = _inv(B);
@@ -45481,6 +45625,7 @@ function companion(coeffs) {
   const a = arr3(coeffs);
   const n = a.length - 1;
   if (n < 1) throw new Error("companion: need at least 2 coefficients");
+  if (a[0] === 0) throw new Error("companion: leading coefficient must be nonzero");
   const C = Array.from({ length: n }, () => new Array(n).fill(0));
   for (let j = 0; j < n; j++) C[0][j] = -a[j + 1] / a[0];
   for (let i = 1; i < n; i++) C[i][i - 1] = 1;
@@ -45525,6 +45670,16 @@ function logdet(A) {
   }
   return { sign: sign3, value };
 }
+function qz(A, B) {
+  const Aa = A;
+  const Bb = B;
+  const M = _multiply(_inv(Bb), Aa);
+  const { U: Z } = realSchur(M);
+  const { Q: Q2, R } = _qr(_multiply(Bb, Z));
+  const Qt = transposeArr(Q2);
+  const AA = _multiply(_multiply(Qt, Aa), Z);
+  return { AA, BB: R, Q: Q2, Z };
+}
 
 // src/calculus-extra.ts
 function gradient(y, x) {
@@ -45578,7 +45733,7 @@ function hessian(f, x, h = 1e-4) {
 
 // src/timeseries-extra.ts
 var arr4 = (x) => Array.isArray(x) ? x : Array.from(x);
-var mean3 = (x) => mean(x);
+var mean4 = (x) => mean(x);
 function movingAverage(x, w) {
   const a = arr4(x);
   if (w <= 0 || w > a.length) throw new Error(`movingAverage: window ${w} out of range`);
@@ -45594,6 +45749,7 @@ function movingAverage(x, w) {
 function ewma(x, alpha) {
   const a = arr4(x);
   if (alpha <= 0 || alpha > 1) throw new Error("ewma: alpha must be in (0, 1]");
+  if (a.length === 0) throw new Error("ewma: input series is empty");
   const out = new Array(a.length);
   let prev = a[0];
   out[0] = prev;
@@ -45607,12 +45763,13 @@ function detrend(x, type = "linear") {
   const a = arr4(x);
   const n = a.length;
   if (type === "constant") {
-    const m = mean3(a);
+    const m = mean4(a);
     return a.map((v) => v - m);
   }
+  if (n < 2) return a.map(() => 0);
   const t = Array.from({ length: n }, (_, i) => i);
-  const mt = mean3(t);
-  const my = mean3(a);
+  const mt = mean4(t);
+  const my = mean4(a);
   let sxy = 0;
   let sxx = 0;
   for (let i = 0; i < n; i++) {
@@ -45626,10 +45783,13 @@ function detrend(x, type = "linear") {
 function acf(x, nlags) {
   const a = arr4(x);
   const n = a.length;
-  const m = mean3(a);
+  if (nlags < 0 || nlags >= n)
+    throw new Error(`acf: nlags ${nlags} out of range for series length ${n}`);
+  const m = mean4(a);
   const dev = a.map((v) => v - m);
   let c0 = 0;
   for (let i = 0; i < n; i++) c0 += dev[i] * dev[i];
+  if (c0 === 0) throw new Error("acf: series has zero variance");
   const out = new Array(nlags + 1);
   for (let k = 0; k <= nlags; k++) {
     let ck = 0;
@@ -45641,14 +45801,16 @@ function acf(x, nlags) {
 
 // src/regression-extra.ts
 var arr5 = (x) => Array.isArray(x) ? x : Array.from(x);
-var mean4 = (x) => mean(x);
+var mean5 = (x) => mean(x);
 function linearRegression(x, y) {
   const a = arr5(x);
   const b = arr5(y);
   const n = a.length;
   if (b.length !== n) throw new Error(`linearRegression: length mismatch ${n} vs ${b.length}`);
-  const mx = mean4(a);
-  const my = mean4(b);
+  if (n < 3)
+    throw new Error("linearRegression: need at least 3 points for a slope significance test");
+  const mx = mean5(a);
+  const my = mean5(b);
   let sxx = 0;
   let syy = 0;
   let sxy = 0;
@@ -45659,6 +45821,7 @@ function linearRegression(x, y) {
     syy += dy * dy;
     sxy += dx * dy;
   }
+  if (sxx === 0) throw new Error("linearRegression: predictor x has zero variance");
   const slope = sxy / sxx;
   const intercept = my - slope * mx;
   const rValue = sxy / Math.sqrt(sxx * syy);
@@ -45669,6 +45832,484 @@ function linearRegression(x, y) {
   return { slope, intercept, rValue, rSquared: rValue * rValue, pValue, stdErr };
 }
 
+// src/optimization-extra.ts
+var _inv2 = inv;
+function nelderMead(f, x0, opts = {}) {
+  const { maxIter = 2e3, tol = 1e-8, step = 0.05 } = opts;
+  const n = x0.length;
+  const alpha = 1;
+  const gamma2 = 2;
+  const rho = 0.5;
+  const sigma = 0.5;
+  let simplex = [Array.from(x0)];
+  for (let i = 0; i < n; i++) {
+    const p = Array.from(x0);
+    p[i] += p[i] !== 0 ? step * p[i] : step;
+    simplex.push(p);
+  }
+  let fv = simplex.map(f);
+  let iter = 0;
+  const centroid2 = (pts) => {
+    const c = new Array(n).fill(0);
+    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 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]);
+    simplex = order.map((i) => simplex[i]);
+    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 fr = f(xr);
+    if (fr < fv[0]) {
+      const xe = add2(c, sub(c, simplex[n]), gamma2);
+      const fe = f(xe);
+      if (fe < fr) {
+        simplex[n] = xe;
+        fv[n] = fe;
+      } else {
+        simplex[n] = xr;
+        fv[n] = fr;
+      }
+    } else if (fr < fv[n - 1]) {
+      simplex[n] = xr;
+      fv[n] = fr;
+    } else {
+      const xc = add2(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);
+          fv[i] = f(simplex[i]);
+        }
+      }
+    }
+  }
+  const best = fv.map((_, i) => i).sort((i, j) => fv[i] - fv[j])[0];
+  return { x: simplex[best], fx: fv[best], iterations: iter, converged: iter < maxIter };
+}
+function gradientDescent(f, x0, opts = {}) {
+  const { rate = 0.1, maxIter = 1e4, tol = 1e-8 } = opts;
+  const n = x0.length;
+  const numGrad = (x2) => {
+    const h = 1e-6;
+    const g = new Array(n);
+    for (let i = 0; i < n; i++) {
+      const xp = x2.slice();
+      const xm = x2.slice();
+      xp[i] += h;
+      xm[i] -= h;
+      g[i] = (f(xp) - f(xm)) / (2 * h);
+    }
+    return g;
+  };
+  const grad = opts.grad ?? numGrad;
+  let x = Array.from(x0);
+  let iter = 0;
+  for (; iter < maxIter; iter++) {
+    const g = grad(x);
+    const gnorm = Math.hypot(...g);
+    if (gnorm <= tol) break;
+    let t = rate;
+    const fx = f(x);
+    while (t > 1e-15 && f(x.map((v, i) => v - t * g[i])) > fx - 0.5 * t * gnorm * gnorm) t *= 0.5;
+    x = x.map((v, i) => v - t * g[i]);
+  }
+  return { x, fx: f(x), iterations: iter, converged: iter < maxIter };
+}
+function levenbergMarquardt(residual, x0, opts = {}) {
+  const { maxIter = 200, tol = 1e-10 } = opts;
+  const n = x0.length;
+  let x = Array.from(x0);
+  let lambda = 1e-3;
+  const h = 1e-7;
+  const norm22 = (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));
+    for (let j = 0; j < n; j++) {
+      const xp = xc.slice();
+      xp[j] += h;
+      const rp = residual(xp);
+      for (let i = 0; i < m; i++) J[i][j] = (rp[i] - r0[i]) / h;
+    }
+    return J;
+  };
+  let r = residual(x);
+  let cost = norm22(r);
+  let iter = 0;
+  for (; iter < maxIter; iter++) {
+    const J = jacobian2(x, r);
+    const m = r.length;
+    const JtJ = Array.from({ length: n }, () => new Array(n).fill(0));
+    const Jtr = new Array(n).fill(0);
+    for (let a = 0; a < n; a++) {
+      for (let b = 0; b < n; b++) {
+        let s = 0;
+        for (let i = 0; i < m; i++) s += J[i][a] * J[i][b];
+        JtJ[a][b] = s;
+      }
+      let sr = 0;
+      for (let i = 0; i < m; i++) sr += J[i][a] * r[i];
+      Jtr[a] = sr;
+    }
+    const A = JtJ.map((row2, a) => row2.map((v, b) => v + (a === b ? lambda * JtJ[a][a] : 0)));
+    let delta;
+    try {
+      const Ainv = _inv2(A);
+      delta = Ainv.map((row2) => row2.reduce((s, v, k) => s - v * Jtr[k], 0));
+    } catch (e) {
+      if (e instanceof Error && /determinant is zero|singular|zero pivot/i.test(e.message)) {
+        lambda *= 10;
+        continue;
+      }
+      throw e;
+    }
+    const xNew = x.map((v, i) => v + delta[i]);
+    const rNew = residual(xNew);
+    const costNew = norm22(rNew);
+    if (costNew < cost) {
+      x = xNew;
+      r = rNew;
+      if (Math.abs(cost - costNew) <= tol * cost) {
+        cost = costNew;
+        break;
+      }
+      cost = costNew;
+      lambda = Math.max(lambda / 3, 1e-12);
+    } else {
+      lambda *= 3;
+    }
+  }
+  return { x, residualNorm: Math.sqrt(cost), iterations: iter, converged: iter < maxIter };
+}
+
+// src/clustering-extra.ts
+var _eigs2 = eigs;
+var dist2 = (a, b) => a.reduce((s, v, i) => s + (v - b[i]) * (v - b[i]), 0);
+function kmeans(data, k, opts = {}) {
+  const { maxIter = 100 } = opts;
+  const n = data.length;
+  if (n === 0) throw new Error("kmeans: data is empty");
+  if (!Number.isInteger(k) || k < 1) throw new Error("kmeans: k must be a positive integer");
+  const d = data[0].length;
+  if (k > n) throw new Error("kmeans: k exceeds number of points");
+  const mean6 = new Array(d).fill(0);
+  for (const p of data) for (let j = 0; j < d; j++) mean6[j] += p[j] / n;
+  let first = 0;
+  for (let i = 1; i < n; i++) if (dist2(data[i], mean6) < dist2(data[first], mean6)) first = i;
+  const centroids = [data[first].slice()];
+  while (centroids.length < k) {
+    let best = -1;
+    let bestD = -1;
+    for (let i = 0; i < n; i++) {
+      const dmin = Math.min(...centroids.map((c) => dist2(data[i], c)));
+      if (dmin > bestD) {
+        bestD = dmin;
+        best = i;
+      }
+    }
+    centroids.push(data[best].slice());
+  }
+  const labels = new Array(n).fill(0);
+  let iterations = 0;
+  let converged = false;
+  for (let iter = 0; iter < maxIter; iter++) {
+    iterations = iter + 1;
+    let changed = false;
+    for (let i = 0; i < n; i++) {
+      let best = 0;
+      let bestD = Infinity;
+      for (let c = 0; c < k; c++) {
+        const dd = dist2(data[i], centroids[c]);
+        if (dd < bestD) {
+          bestD = dd;
+          best = c;
+        }
+      }
+      if (labels[i] !== best) {
+        labels[i] = best;
+        changed = true;
+      }
+    }
+    for (let c = 0; c < k; c++) {
+      const members = data.filter((_, i) => labels[i] === c);
+      if (members.length === 0) continue;
+      for (let j = 0; j < d; j++)
+        centroids[c][j] = members.reduce((s, p) => s + p[j], 0) / members.length;
+    }
+    if (!changed) {
+      converged = true;
+      break;
+    }
+  }
+  const inertia = data.reduce((s, p, i) => s + dist2(p, centroids[labels[i]]), 0);
+  return { labels, centroids, inertia, iterations, converged };
+}
+function spectralClustering(adjacency, k, opts = {}) {
+  const L = laplacianMatrix(adjacency, { normalized: true });
+  const { eigenvectors } = _eigs2(L);
+  const n = adjacency.length;
+  const embed = Array.from(
+    { length: n },
+    (_, i) => eigenvectors.slice(0, k).map((e) => e.vector[i])
+  );
+  return kmeans(embed, k, opts).labels;
+}
+
+// src/cas-integration.ts
+var parse2 = parse;
+var evaluate2 = evaluate;
+var NotIntegrable = class extends Error {
+};
+function evalConst(s) {
+  let v;
+  try {
+    v = evaluate2(s);
+  } catch {
+    throw new NotIntegrable(`non-numeric constant ${s}`);
+  }
+  if (!Number.isFinite(v)) throw new NotIntegrable(`non-finite constant ${s}`);
+  return v;
+}
+var unwrap = (n) => n.type === "ParenthesisNode" && n.content ? unwrap(n.content) : n;
+function isConst(n, x) {
+  const node = unwrap(n);
+  if (node.type === "SymbolNode") return node.name !== x;
+  if (node.type === "ConstantNode") return true;
+  return [...node.args ?? [], ...node.content ? [node.content] : []].every((a) => isConst(a, x));
+}
+function num(v) {
+  return Number.isInteger(v) ? String(v) : String(Number(v.toPrecision(15)));
+}
+function linearSlope(u, x) {
+  try {
+    const a1 = evaluate2(u, { [x]: 1 }) - evaluate2(u, { [x]: 0 });
+    const a2 = evaluate2(u, { [x]: 5 }) - evaluate2(u, { [x]: 4 });
+    if (Math.abs(a1 - a2) < 1e-9 && Math.abs(a1) > 1e-12) return a1;
+    return null;
+  } catch (e) {
+    if (e instanceof Error && /undefined symbol/i.test(e.message)) return null;
+    throw e;
+  }
+}
+function integrateNode(raw, x) {
+  const node = unwrap(raw);
+  if (isConst(node, x)) return `${node.toString()} * ${x}`;
+  switch (node.type) {
+    case "SymbolNode":
+      return `${x}^2 / 2`;
+    // node is x
+    case "OperatorNode": {
+      const args = (node.args ?? []).map(unwrap);
+      if (node.op === "+") return args.map((a) => integrateNode(a, x)).join(" + ");
+      if (node.op === "-" && args.length === 2)
+        return `${integrateNode(args[0], x)} - (${integrateNode(args[1], x)})`;
+      if (node.op === "-" && args.length === 1) return `-(${integrateNode(args[0], x)})`;
+      if (node.op === "*") {
+        const consts = args.filter((a) => isConst(a, x));
+        const varying = args.filter((a) => !isConst(a, x));
+        if (varying.length === 1) {
+          const c = consts.map((a) => `(${a.toString()})`).join(" * ");
+          const inner = integrateNode(varying[0], x);
+          return c ? `${c} * (${inner})` : inner;
+        }
+        throw new NotIntegrable("product of x-dependent factors");
+      }
+      if (node.op === "/") {
+        if (isConst(args[1], x)) return `(${integrateNode(args[0], x)}) / (${args[1].toString()})`;
+        if (isConst(args[0], x)) {
+          const a = linearSlope(args[1].toString(), x);
+          if (a !== null) {
+            const k = evalConst(args[0].toString()) / a;
+            return `${num(k)} * log(abs(${args[1].toString()}))`;
+          }
+        }
+        throw new NotIntegrable("general quotient");
+      }
+      if (node.op === "^") {
+        const base = args[0];
+        const exp2 = args[1];
+        if (!isConst(exp2, x)) throw new NotIntegrable("variable exponent");
+        const n = evalConst(exp2.toString());
+        const a = linearSlope(base.toString(), x);
+        if (a === null) throw new NotIntegrable("non-linear base");
+        const b = `(${base.toString()})`;
+        if (n === -1) return `${num(1 / a)} * log(abs(${b}))`;
+        const denom = a * (n + 1);
+        return denom === 1 ? `${b}^${num(n + 1)}` : `${b}^${num(n + 1)} / ${num(denom)}`;
+      }
+      throw new NotIntegrable(`operator ${node.op}`);
+    }
+    case "FunctionNode": {
+      const fn = node.fn?.name ?? node.name ?? "";
+      const u = (node.args ?? [])[0];
+      if (!u) throw new NotIntegrable(fn);
+      const us = u.toString();
+      if (fn === "log" || fn === "ln") {
+        if (us === x) return `${x} * log(${x}) - ${x}`;
+        throw new NotIntegrable("ln of non-trivial argument");
+      }
+      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)}`;
+      switch (fn) {
+        case "sin":
+          return `-cos(${us})${inv2}`;
+        case "cos":
+          return `sin(${us})${inv2}`;
+        case "exp":
+          return `exp(${us})${inv2}`;
+        case "sinh":
+          return `cosh(${us})${inv2}`;
+        case "cosh":
+          return `sinh(${us})${inv2}`;
+        default:
+          throw new NotIntegrable(`function ${fn}`);
+      }
+    }
+    default:
+      throw new NotIntegrable(node.type);
+  }
+}
+function symbolicIntegral(expr, variable = "x") {
+  try {
+    return integrateNode(parse2(expr), variable);
+  } catch (e) {
+    if (e instanceof NotIntegrable) return `integral(${expr}, ${variable})`;
+    throw e;
+  }
+}
+
+// src/signal-filter-extra.ts
+import { Complex as Complex11 } from "@danielsimonjr/mathts-core";
+var _inv3 = inv;
+var arr6 = (x) => Array.isArray(x) ? x : Array.from(x);
+var sinc = (x) => x === 0 ? 1 : Math.sin(Math.PI * x) / (Math.PI * x);
+function firwin(numtaps, cutoff) {
+  if (!Number.isInteger(numtaps) || numtaps < 2)
+    throw new Error("firwin: numtaps must be an integer >= 2");
+  const M = numtaps - 1;
+  const h = new Array(numtaps);
+  for (let n = 0; n <= M; n++) {
+    const w = 0.54 - 0.46 * Math.cos(2 * Math.PI * n / M);
+    h[n] = cutoff * sinc(cutoff * (n - M / 2)) * w;
+  }
+  const s = h.reduce((a, b) => a + b, 0);
+  if (Math.abs(s) < 1e-12)
+    throw new Error("firwin: degenerate design \u2014 taps sum to ~0 (cutoff at/near 0)");
+  return h.map((v) => v / s);
+}
+function padCoeffs(b, a) {
+  const n = Math.max(a.length, b.length);
+  const a0 = a[0];
+  const bn = Array.from({ length: n }, (_, i) => (i < b.length ? b[i] : 0) / a0);
+  const an = Array.from({ length: n }, (_, i) => (i < a.length ? a[i] : 0) / a0);
+  return { b: bn, a: an, n };
+}
+function lfilterState(b, a, x, zi) {
+  const { b: bb, a: aa, n } = padCoeffs(b, a);
+  const z = zi ? zi.slice() : new Array(Math.max(n - 1, 0)).fill(0);
+  const y = new Array(x.length);
+  for (let m = 0; m < x.length; m++) {
+    const xm = x[m];
+    const ym = bb[0] * xm + (z.length ? z[0] : 0);
+    for (let i = 0; i < n - 2; i++) z[i] = bb[i + 1] * xm + z[i + 1] - aa[i + 1] * ym;
+    if (n >= 2) z[n - 2] = bb[n - 1] * xm - aa[n - 1] * ym;
+    y[m] = ym;
+  }
+  return { y, zf: z };
+}
+function lfilter(b, a, x) {
+  return lfilterState(arr6(b), arr6(a), arr6(x)).y;
+}
+function lfilterZi(b, a) {
+  const { b: bb, a: aa, n } = padCoeffs(arr6(b), arr6(a));
+  if (n < 2) return [];
+  const C = companion(aa);
+  const M = Array.from(
+    { length: n - 1 },
+    (_, i) => Array.from({ length: n - 1 }, (_2, j) => (i === j ? 1 : 0) - C[j][i])
+  );
+  const B = Array.from({ length: n - 1 }, (_, i) => bb[i + 1] - aa[i + 1] * bb[0]);
+  let Minv;
+  try {
+    Minv = _inv3(M);
+  } catch {
+    throw new Error("lfilterZi: filter has a pole at z=1 (singular I \u2212 A\u1D40); steady-state zi is undefined");
+  }
+  const zi = Minv.map((row2) => row2.reduce((s, v, k) => s + v * B[k], 0));
+  if (zi.some((v) => !Number.isFinite(v)))
+    throw new Error("lfilterZi: non-finite steady state (unstable or marginally-stable filter)");
+  return zi;
+}
+function filtfilt(b, a, x) {
+  const bb = arr6(b);
+  const aa = arr6(a);
+  const xx = arr6(x);
+  const n = xx.length;
+  const ntaps = Math.max(aa.length, bb.length);
+  const pad = 3 * ntaps;
+  if (pad >= n) throw new Error(`filtfilt: signal length ${n} must exceed padlen ${pad}`);
+  const left = [];
+  for (let k = pad; k >= 1; k--) left.push(2 * xx[0] - xx[k]);
+  const right = [];
+  for (let k = 1; k <= pad; k++) right.push(2 * xx[n - 1] - xx[n - 1 - k]);
+  const ext = [...left, ...xx, ...right];
+  const zi = lfilterZi(bb, aa);
+  const fwd = lfilterState(bb, aa, ext, zi.map((v) => v * ext[0])).y;
+  const rev = fwd.slice().reverse();
+  const back = lfilterState(bb, aa, rev, zi.map((v) => v * rev[0])).y.reverse();
+  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);
+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));
+    }
+    c = next;
+  }
+  return c.map((z) => z.re);
+}
+function butter(N, Wn) {
+  if (!Number.isInteger(N) || N < 1) throw new Error("butter: order N must be a positive integer");
+  if (!(Wn > 0 && Wn < 1))
+    throw new Error("butter: Wn must satisfy 0 < Wn < 1 (normalized to Nyquist)");
+  const ap = [];
+  for (let k = 0; k < N; k++) {
+    const m = -N + 1 + 2 * k;
+    const theta = Math.PI * m / (2 * N);
+    ap.push(new Complex11(-Math.cos(theta), -Math.sin(theta)));
+  }
+  const fs = 2;
+  const warped = 2 * fs * Math.tan(Math.PI * Wn / fs);
+  const pLp = ap.map((p) => cMul(p, new Complex11(warped, 0)));
+  const kLp = Math.pow(warped, N);
+  const fs2 = new Complex11(2 * fs, 0);
+  const pd = pLp.map((p) => cDiv(cAdd(fs2, p), cSub(fs2, p)));
+  const zd = Array.from({ length: N }, () => new Complex11(-1, 0));
+  let denom = new Complex11(1, 0);
+  for (const p of pLp) denom = cMul(denom, cSub(fs2, p));
+  const kd = kLp / denom.re;
+  const b = polyFromRoots(zd).map((v) => v * kd);
+  const a = polyFromRoots(pd);
+  return { b, a };
+}
+
 // src/geometry-extra.ts
 var toRad = (deg) => toRadians(deg);
 var EARTH_RADIUS_KM = 6371.0088;
@@ -45685,6 +46326,7 @@ var norm3 = (a) => Math.sqrt(dot2(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 = dot2(u0, u1);
@@ -45692,6 +46334,8 @@ function slerp(v0, v1, t) {
   const omega = Math.acos(cos2);
   const mag = n0 + (n16 - n0) * t;
   if (omega < 1e-9) return u0.map((v, i) => (v + (u1[i] - v) * t) * mag);
+  if (Math.PI - omega < 1e-9)
+    throw new Error("slerp: antipodal directions have no unique interpolation path");
   const s = Math.sin(omega);
   const a = Math.sin((1 - t) * omega) / s;
   const b = Math.sin(t * omega) / s;
@@ -45712,6 +46356,7 @@ function quaternionConjugate(q) {
 }
 function quaternionNormalize(q) {
   const m = norm3(q);
+  if (m === 0) throw new Error("quaternionNormalize: zero-magnitude quaternion");
   return q.map((v) => v / m);
 }
 function quaternionFromAxisAngle(axis, angle) {
@@ -45808,6 +46453,7 @@ export {
   boltzmann,
   boolean,
   bspline,
+  butter,
   cancel,
   carlsonRC,
   carlsonRD,
@@ -46049,9 +46695,11 @@ export {
   fft2d,
   fibonacci,
   filter2 as filter,
+  filtfilt,
   findRoot,
   fineStructure,
   firstRadiation,
+  firwin,
   fisherExact,
   fix,
   flatten3 as flatten,
@@ -46091,6 +46739,7 @@ export {
   gpuTranspose,
   gradient,
   gradientAt,
+  gradientDescent,
   gradientSymbolic,
   graphDistance,
   gravitationConstant,
@@ -46156,6 +46805,7 @@ export {
   kdTreeNearest,
   kldivergence,
   klitzing,
+  kmeans,
   kolmogorovSmirnovTest,
   kron,
   kruskalWallis,
@@ -46177,6 +46827,9 @@ export {
   leftShift,
   legendreFit,
   legendreP,
+  levenbergMarquardt,
+  lfilter,
+  lfilterZi,
   lgamma,
   limit,
   linearInterp,
@@ -46253,6 +46906,7 @@ export {
   multiplyScalar,
   multivariateTaylor,
   nearestNeighbor,
+  nelderMead,
   neutronMass,
   newtonInterp,
   nextPrime,
@@ -46365,6 +47019,7 @@ export {
   quaternionRotate,
   quaternionToRotationMatrix,
   quickSelect,
+  qz,
   random,
   randomInt,
   range,
@@ -46445,6 +47100,7 @@ export {
   solvePDE,
   sort,
   sparse,
+  spectralClustering,
   spectrogram,
   speedOfLight,
   splitUnit,
@@ -46462,6 +47118,8 @@ export {
   studentTPDF,
   studentTQuantile,
   studentTTest,
+  studentizedRangeCDF,
+  studentizedRangeQuantile,
   subfactorial,
   subset,
   substitute,
@@ -46471,6 +47129,7 @@ export {
   summation,
   sylvester,
   symbolicEqual,
+  symbolicIntegral,
   symbolicPartialDerivative,
   symbolicProduct,
   tDist,
@@ -46500,6 +47159,7 @@ export {
   trigToExp,
   tril,
   triu,
+  tukeyHSD,
   typeOf2 as typeOf,
   typedAlgebra,
   typedArithmetic,