@danielsimonjr/mathts-functions 0.32.0 → 0.34.0

package/dist/index.js

@@ -2021,16 +2021,16 @@ var xgcd = mathTyped2("xgcd", {
     return a < 0n ? [-a, -lastX, -lastY] : [a, lastX, lastY];
   }
 });
-function is2DArray(arr8) {
-  return Array.isArray(arr8[0]);
-}
-function vectorNorm(arr8, p = 2) {
-  if (p === Infinity) return Math.max(...arr8.map((x) => Math.abs(x)));
-  if (p === -Infinity) return Math.min(...arr8.map((x) => Math.abs(x)));
-  if (p === 0) return arr8.filter((x) => x !== 0).length;
-  if (p === 2) return norm2(arr8);
-  const terms = new Array(arr8.length);
-  for (let i = 0; i < arr8.length; i++) terms[i] = Math.pow(Math.abs(arr8[i]), p);
+function is2DArray(arr10) {
+  return Array.isArray(arr10[0]);
+}
+function vectorNorm(arr10, p = 2) {
+  if (p === Infinity) return Math.max(...arr10.map((x) => Math.abs(x)));
+  if (p === -Infinity) return Math.min(...arr10.map((x) => Math.abs(x)));
+  if (p === 0) return arr10.filter((x) => x !== 0).length;
+  if (p === 2) return norm2(arr10);
+  const terms = new Array(arr10.length);
+  for (let i = 0; i < arr10.length; i++) terms[i] = Math.pow(Math.abs(arr10[i]), p);
   return Math.pow(pairwiseSum(terms), 1 / p);
 }
 function matrixNorm(data, p = "fro") {
@@ -2071,9 +2071,9 @@ var norm = mathTyped2("norm", {
   Complex: (a) => a.abs(),
   BigNumber: (a) => a.abs(),
   // Array: a flat vector uses the vector 2-norm; a 2-D array is a matrix (Frobenius).
-  Array: (arr8) => is2DArray(arr8) ? matrixNorm(arr8) : vectorNorm(arr8),
-  "Array, number": (arr8, p) => is2DArray(arr8) ? matrixNorm(arr8, p) : vectorNorm(arr8, p),
-  "Array, string": (arr8, p) => matrixNorm(arr8, p),
+  Array: (arr10) => is2DArray(arr10) ? matrixNorm(arr10) : vectorNorm(arr10),
+  "Array, number": (arr10, p) => is2DArray(arr10) ? matrixNorm(arr10, p) : vectorNorm(arr10, p),
+  "Array, string": (arr10, p) => matrixNorm(arr10, p),
   // Matrix norms (mathjs parity): Frobenius / 1 / 2 / ∞.
   DenseMatrix: (m) => matrixNorm(matrixLike(m)),
   "DenseMatrix, number": (m, p) => matrixNorm(matrixLike(m), p),
@@ -2187,7 +2187,7 @@ var min = mathTyped2("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: (arr8) => Math.min(...arr8),
+  Array: (arr10) => Math.min(...arr10),
   number: (a) => a,
   "number, number": (a, b) => Math.min(a, b),
   "number, number, ...number": (a, b, rest) => Math.min(a, b, ...rest),
@@ -2206,7 +2206,7 @@ var max = mathTyped2("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: (arr8) => Math.max(...arr8),
+  Array: (arr10) => Math.max(...arr10),
   number: (a) => a,
   "number, number": (a, b) => Math.max(a, b),
   "number, number, ...number": (a, b, rest) => Math.max(a, b, ...rest),
@@ -2221,7 +2221,7 @@ var max = mathTyped2("max", {
   }
 });
 var fsum = mathTyped2("fsum", {
-  Array: (arr8) => neumaierSum(arr8),
+  Array: (arr10) => neumaierSum(arr10),
   Float64Array: (a) => neumaierSum(a)
 });
 var sum = mathTyped2("sum", {
@@ -2238,7 +2238,7 @@ var sum = mathTyped2("sum", {
   // all inherit it. Pairwise costs the same number of additions — the naive loop was simply worse.
   // For catastrophic cancellation (e.g. [1e16, 1, -1e16], which pairwise AND np.sum both
   // annihilate to 0) use `fsum`.
-  Array: (arr8) => pairwiseSum(arr8),
+  Array: (arr10) => pairwiseSum(arr10),
   // Float64Array: the pool's sequential branch is pairwise too (see ComputePool.sum), and its
   // parallel branch sums per-chunk then combines — blocked summation, which is pairwise-like.
   // Either way the O(n) drift is gone.
@@ -2248,9 +2248,9 @@ var sum = mathTyped2("sum", {
   }
 });
 var mean = mathTyped2("mean", {
-  Array: (arr8) => {
-    if (arr8.length === 0) return NaN;
-    return pairwiseSum(arr8) / arr8.length;
+  Array: (arr10) => {
+    if (arr10.length === 0) return NaN;
+    return pairwiseSum(arr10) / arr10.length;
   },
   // Parallel Float64Array mean
   Float64Array: async (a) => {
@@ -2270,12 +2270,12 @@ function varianceFromM2(m2, n, norm4) {
       return n > 1 ? m2 / (n - 1) : 0;
   }
 }
-function m2OfArray(arr8) {
-  return sumSquaredDeviations(arr8);
+function m2OfArray(arr10) {
+  return sumSquaredDeviations(arr10);
 }
 var variance = mathTyped2("variance", {
-  Array: (arr8) => varianceFromM2(m2OfArray(arr8), arr8.length, "unbiased"),
-  "Array, string": (arr8, norm4) => varianceFromM2(m2OfArray(arr8), arr8.length, norm4),
+  Array: (arr10) => varianceFromM2(m2OfArray(arr10), arr10.length, "unbiased"),
+  "Array, string": (arr10, norm4) => varianceFromM2(m2OfArray(arr10), arr10.length, norm4),
   // Parallel Float64Array variance. computePool returns POPULATION variance
   // (sum2/n); recover sum2 = pop·n and renormalize for the requested convention.
   Float64Array: async (a) => {
@@ -2288,8 +2288,8 @@ var variance = mathTyped2("variance", {
   }
 });
 var std = mathTyped2("std", {
-  Array: (arr8) => Math.sqrt(varianceFromM2(m2OfArray(arr8), arr8.length, "unbiased")),
-  "Array, string": (arr8, norm4) => Math.sqrt(varianceFromM2(m2OfArray(arr8), arr8.length, norm4)),
+  Array: (arr10) => Math.sqrt(varianceFromM2(m2OfArray(arr10), arr10.length, "unbiased")),
+  "Array, string": (arr10, norm4) => Math.sqrt(varianceFromM2(m2OfArray(arr10), arr10.length, norm4)),
   // Parallel Float64Array std — derive from the (renormalized) variance so the
   // convention matches the Array path and parallelStatStd.
   Float64Array: async (a) => {
@@ -2642,7 +2642,7 @@ var hypot = mathTyped3("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: (arr8) => Math.hypot(...arr8)
+  Array: (arr10) => Math.hypot(...arr10)
 });
 var typedTrigonometry = {
   // Basic
@@ -2673,8 +2673,8 @@ var typedTrigonometry = {
 // src/typed/statistics.ts
 import { mathTyped as mathTyped4, neumaierCumsum } from "@danielsimonjr/mathts-core";
 import { computePool as computePool3 } from "@danielsimonjr/mathts-parallel";
-function toFloat64Array(arr8) {
-  return new Float64Array(arr8);
+function toFloat64Array(arr10) {
+  return new Float64Array(arr10);
 }
 var parallelStatSum = mathTyped4("parallelStatSum", {
   // Float64Array - parallel execution
@@ -2683,8 +2683,8 @@ var parallelStatSum = mathTyped4("parallelStatSum", {
     return result.result;
   },
   // Number array
-  Array: async (arr8) => {
-    const data = toFloat64Array(arr8);
+  Array: async (arr10) => {
+    const data = toFloat64Array(arr10);
     const result = await computePool3.sum(data);
     return result.result;
   },
@@ -2700,9 +2700,9 @@ var parallelStatMean = mathTyped4("parallelStatMean", {
     return result.result;
   },
   // Number array - parallel execution
-  Array: async (arr8) => {
-    if (arr8.length === 0) return NaN;
-    const data = toFloat64Array(arr8);
+  Array: async (arr10) => {
+    if (arr10.length === 0) return NaN;
+    const data = toFloat64Array(arr10);
     const result = await computePool3.mean(data);
     return result.result;
   },
@@ -2737,15 +2737,15 @@ var parallelStatVariance = mathTyped4("parallelStatVariance", {
     }
   },
   // Number array
-  Array: async (arr8) => {
-    if (arr8.length === 0) return NaN;
-    const data = toFloat64Array(arr8);
+  Array: async (arr10) => {
+    if (arr10.length === 0) return NaN;
+    const data = toFloat64Array(arr10);
     return parallelStatVariance(data);
   },
   // Number array with normalization
-  "Array, string": async (arr8, normalization) => {
-    if (arr8.length === 0) return NaN;
-    const data = toFloat64Array(arr8);
+  "Array, string": async (arr10, normalization) => {
+    if (arr10.length === 0) return NaN;
+    const data = toFloat64Array(arr10);
     return parallelStatVariance(data, normalization);
   },
   // Variadic form
@@ -2772,15 +2772,15 @@ var parallelStatStd = mathTyped4("parallelStatStd", {
     return Math.sqrt(variance2);
   },
   // Number array
-  Array: async (arr8) => {
-    if (arr8.length === 0) return NaN;
-    const data = toFloat64Array(arr8);
+  Array: async (arr10) => {
+    if (arr10.length === 0) return NaN;
+    const data = toFloat64Array(arr10);
     return parallelStatStd(data);
   },
   // Number array with normalization
-  "Array, string": async (arr8, normalization) => {
-    if (arr8.length === 0) return NaN;
-    const data = toFloat64Array(arr8);
+  "Array, string": async (arr10, normalization) => {
+    if (arr10.length === 0) return NaN;
+    const data = toFloat64Array(arr10);
     return parallelStatStd(data, normalization);
   }
 });
@@ -2791,9 +2791,9 @@ var parallelStatMin = mathTyped4("parallelStatMin", {
     return result.result;
   },
   // Number array
-  Array: async (arr8) => {
-    if (arr8.length === 0) return Infinity;
-    const data = toFloat64Array(arr8);
+  Array: async (arr10) => {
+    if (arr10.length === 0) return Infinity;
+    const data = toFloat64Array(arr10);
     const result = await computePool3.min(data);
     return result.result;
   },
@@ -2811,9 +2811,9 @@ var parallelStatMax = mathTyped4("parallelStatMax", {
     return result.result;
   },
   // Number array
-  Array: async (arr8) => {
-    if (arr8.length === 0) return -Infinity;
-    const data = toFloat64Array(arr8);
+  Array: async (arr10) => {
+    if (arr10.length === 0) return -Infinity;
+    const data = toFloat64Array(arr10);
     const result = await computePool3.max(data);
     return result.result;
   },
@@ -2831,8 +2831,8 @@ var parallelStatMinMax = mathTyped4("parallelStatMinMax", {
     return result.result;
   },
   // Number array
-  Array: async (arr8) => {
-    const data = toFloat64Array(arr8);
+  Array: async (arr10) => {
+    const data = toFloat64Array(arr10);
     const result = await computePool3.minMax(data);
     return result.result;
   }
@@ -2852,25 +2852,25 @@ var parallelStatMedian = mathTyped4("parallelStatMedian", {
     return sorted[mid];
   },
   // Number array
-  Array: async (arr8) => {
-    if (arr8.length === 0) return NaN;
-    return parallelStatMedian(toFloat64Array(arr8));
+  Array: async (arr10) => {
+    if (arr10.length === 0) return NaN;
+    return parallelStatMedian(toFloat64Array(arr10));
   },
   // Variadic form
   "number, number": (a, b) => (a + b) / 2,
   "number, number, number": (a, b, c) => {
-    const arr8 = [a, b, c].sort((x, y) => x - y);
-    return arr8[1];
+    const arr10 = [a, b, c].sort((x, y) => x - y);
+    return arr10[1];
   }
 });
 var parallelStatMode = mathTyped4("parallelStatMode", {
   // Number array
-  Array: (arr8) => {
-    if (arr8.length === 0) return [];
+  Array: (arr10) => {
+    if (arr10.length === 0) return [];
     const counts = /* @__PURE__ */ new Map();
     let maxCount = 0;
-    for (let i = 0; i < arr8.length; i++) {
-      const val = arr8[i];
+    for (let i = 0; i < arr10.length; i++) {
+      const val = arr10[i];
       const count2 = (counts.get(val) || 0) + 1;
       counts.set(val, count2);
       if (count2 > maxCount) maxCount = count2;
@@ -2888,11 +2888,11 @@ var parallelStatMode = mathTyped4("parallelStatMode", {
 });
 var parallelStatProd = mathTyped4("parallelStatProd", {
   // Number array
-  Array: (arr8) => {
-    if (arr8.length === 0) return 1;
+  Array: (arr10) => {
+    if (arr10.length === 0) return 1;
     let prod2 = 1;
-    for (let i = 0; i < arr8.length; i++) {
-      prod2 *= arr8[i];
+    for (let i = 0; i < arr10.length; i++) {
+      prod2 *= arr10[i];
     }
     return prod2;
   },
@@ -2920,8 +2920,8 @@ var parallelStatNorm = mathTyped4("parallelStatNorm", {
     return result.result;
   },
   // Number array
-  Array: async (arr8) => {
-    const data = toFloat64Array(arr8);
+  Array: async (arr10) => {
+    const data = toFloat64Array(arr10);
     const result = await computePool3.norm(data);
     return result.result;
   },
@@ -2962,8 +2962,8 @@ var parallelStatNorm = mathTyped4("parallelStatNorm", {
     }
   },
   // Number array with p-norm
-  "Array, number": (arr8, p) => {
-    return parallelStatNorm(toFloat64Array(arr8), p);
+  "Array, number": (arr10, p) => {
+    return parallelStatNorm(toFloat64Array(arr10), p);
   }
 });
 var parallelStatDistance = mathTyped4("parallelStatDistance", {
@@ -3020,8 +3020,8 @@ var parallelStatMAD = mathTyped4("parallelStatMAD", {
     return mad2 / n;
   },
   // Number array
-  Array: async (arr8) => {
-    return parallelStatMAD(toFloat64Array(arr8));
+  Array: async (arr10) => {
+    return parallelStatMAD(toFloat64Array(arr10));
   }
 });
 var parallelStatCumsum = mathTyped4("parallelStatCumsum", {
@@ -3032,9 +3032,9 @@ var parallelStatCumsum = mathTyped4("parallelStatCumsum", {
     return result;
   },
   // Number array
-  Array: (arr8) => {
-    const result = new Array(arr8.length);
-    neumaierCumsum(arr8, result);
+  Array: (arr10) => {
+    const result = new Array(arr10.length);
+    neumaierCumsum(arr10, result);
     return result;
   }
 });
@@ -3056,8 +3056,8 @@ var parallelStatQuantile = mathTyped4("parallelStatQuantile", {
     return sorted[lower] * (1 - frac) + sorted[upper] * frac;
   },
   // Number array
-  "Array, number": (arr8, q) => {
-    return parallelStatQuantile(toFloat64Array(arr8), q);
+  "Array, number": (arr10, q) => {
+    return parallelStatQuantile(toFloat64Array(arr10), q);
   },
   // Multiple quantiles
   "Float64Array, Array": (data, quantiles) => {
@@ -3080,15 +3080,15 @@ var parallelStatHistogram = mathTyped4("parallelStatHistogram", {
     return result.result;
   },
   // Number array
-  "Array, number": async (arr8, bins) => {
-    return parallelStatHistogram(toFloat64Array(arr8), bins);
+  "Array, number": async (arr10, bins) => {
+    return parallelStatHistogram(toFloat64Array(arr10), bins);
   }
 });
-function quickSelect(arr8, k) {
-  if (k < 0 || k >= arr8.length) {
-    throw new RangeError(`k=${k} is out of range for array of length ${arr8.length}`);
+function quickSelect(arr10, k) {
+  if (k < 0 || k >= arr10.length) {
+    throw new RangeError(`k=${k} is out of range for array of length ${arr10.length}`);
   }
-  const a = arr8.slice();
+  const a = arr10.slice();
   return _quickSelect(a, 0, a.length - 1, k);
 }
 function _quickSelect(a, lo, hi, k) {
@@ -3131,32 +3131,32 @@ function _quickSelect(a, lo, hi, k) {
   }
   return a[lo];
 }
-function medianSelect(arr8) {
-  const n = arr8.length;
+function medianSelect(arr10) {
+  const n = arr10.length;
   if (n === 0) return NaN;
-  if (n === 1) return arr8[0];
+  if (n === 1) return arr10[0];
   const mid = Math.floor(n / 2);
   if (n % 2 === 1) {
-    return quickSelect(arr8, mid);
+    return quickSelect(arr10, mid);
   }
-  const a = arr8.slice();
+  const a = arr10.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(arr8, k) {
+function minSelect(arr10, k) {
   if (k <= 0) return [];
-  if (k >= arr8.length) return arr8.slice().sort((a2, b) => a2 - b);
-  const a = arr8.slice();
+  if (k >= arr10.length) return arr10.slice().sort((a2, b) => a2 - b);
+  const a = arr10.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(arr8, k) {
+function maxSelect(arr10, k) {
   if (k <= 0) return [];
-  if (k >= arr8.length) return arr8.slice().sort((a2, b) => b - a2);
-  const a = arr8.slice();
+  if (k >= arr10.length) return arr10.slice().sort((a2, b) => b - a2);
+  const a = arr10.slice();
   const pivot = a.length - k;
   _quickSelect(a, 0, a.length - 1, pivot);
   const result = a.slice(pivot);
@@ -5110,8 +5110,8 @@ var typedLogical = {
 
 // src/typed/complex.ts
 import { mathTyped as mathTyped8, BigNumber as BigNumber5 } from "@danielsimonjr/mathts-core";
-function deepMapArray(arr8, fn) {
-  return arr8.map(
+function deepMapArray(arr10, fn) {
+  return arr10.map(
     (item) => Array.isArray(item) ? deepMapArray(item, fn) : fn(item)
   );
 }
@@ -5161,9 +5161,9 @@ var typedComplex = {
 
 // src/typed/set.ts
 import { mathTyped as mathTyped9 } from "@danielsimonjr/mathts-core";
-function flattenArray(arr8) {
+function flattenArray(arr10) {
   const result = [];
-  const stack = [...arr8];
+  const stack = [...arr10];
   while (stack.length > 0) {
     const item = stack.shift();
     if (Array.isArray(item)) {
@@ -9894,11 +9894,11 @@ function discriminant(coeffs) {
   const sign3 = deg * (deg - 1) / 2 % 2 === 0 ? 1 : -1;
   return sign3 * res / an;
 }
-function differences(arr8, n = 1) {
+function differences(arr10, n = 1) {
   if (n < 0 || !Number.isInteger(n)) {
     throw new Error("Difference order must be a non-negative integer");
   }
-  let result = [...arr8];
+  let result = [...arr10];
   for (let k = 0; k < n; k++) {
     if (result.length <= 1) return [];
     const next = new Array(result.length - 1);
@@ -10167,11 +10167,11 @@ function fullSimplify(expr) {
   result = reduce(result);
   return result;
 }
-function element(arr8, index) {
-  if (index < 0 || index >= arr8.length) {
-    throw new Error("Index " + index + " out of bounds for array of length " + arr8.length);
+function element(arr10, index) {
+  if (index < 0 || index >= arr10.length) {
+    throw new Error("Index " + index + " out of bounds for array of length " + arr10.length);
   }
-  return arr8[index];
+  return arr10[index];
 }
 function eliminate(system, variable) {
   const symbols = /* @__PURE__ */ new Set();
@@ -11549,22 +11549,22 @@ var createSolveODE = /* @__PURE__ */ factory(
       const stageAlloc = wasmLoader.allocateFloat64ArrayEmpty(numStages * dim);
       try {
         let readVec2 = function(alloc) {
-          const arr8 = new Float64Array(wasm.memory.buffer, alloc.ptr, dim);
+          const arr10 = new Float64Array(wasm.memory.buffer, alloc.ptr, dim);
           const result = new Array(dim);
           for (let i = 0; i < dim; i++) {
-            result[i] = arr8[i];
+            result[i] = arr10[i];
           }
           return result;
         }, writeVec2 = function(alloc, data) {
-          const arr8 = new Float64Array(wasm.memory.buffer, alloc.ptr, dim);
+          const arr10 = new Float64Array(wasm.memory.buffer, alloc.ptr, dim);
           for (let i = 0; i < dim; i++) {
-            arr8[i] = data[i];
+            arr10[i] = data[i];
           }
         }, writeStage2 = function(stageIdx, data) {
           const offset = stageIdx * dim;
-          const arr8 = new Float64Array(wasm.memory.buffer, stageAlloc.ptr, numStages * dim);
+          const arr10 = new Float64Array(wasm.memory.buffer, stageAlloc.ptr, numStages * dim);
           for (let i = 0; i < dim; i++) {
-            arr8[offset + i] = data[i];
+            arr10[offset + i] = data[i];
           }
         }, trimStepNum2 = function(tn, tfn, hn) {
           const next = tn + hn;
@@ -12960,7 +12960,7 @@ function nullspace(A) {
 }
 function residue(p, q) {
   const poles = polyRoots(q);
-  function evalPoly(coeffs, x) {
+  function evalPoly2(coeffs, x) {
     let s = 0;
     for (let i = coeffs.length - 1; i >= 0; i--) {
       s = s * x + coeffs[i];
@@ -12974,7 +12974,7 @@ function residue(p, q) {
     }
     return s;
   }
-  const residues = poles.map((pole) => evalPoly(p, pole) / evalPolyDeriv(q, pole));
+  const residues = poles.map((pole) => evalPoly2(p, pole) / evalPolyDeriv(q, pole));
   return { residues, poles };
 }
 function polyRoots(coeffs) {
@@ -15509,12 +15509,12 @@ function _makeMulberry322(seed) {
     return z / 4294967296;
   };
 }
-function _shuffle(arr8, rng) {
-  for (let i = arr8.length - 1; i > 0; i--) {
+function _shuffle(arr10, rng) {
+  for (let i = arr10.length - 1; i > 0; i--) {
     const j = Math.floor(rng() * (i + 1));
-    const tmp = arr8[i];
-    arr8[i] = arr8[j];
-    arr8[j] = tmp;
+    const tmp = arr10[i];
+    arr10[i] = arr10[j];
+    arr10[j] = tmp;
   }
 }
 function _bootstrapSummary(stats) {
@@ -15528,16 +15528,16 @@ function _bootstrapSummary(stats) {
   const std2 = n > 1 ? Math.sqrt(sq / (n - 1)) : 0;
   return { bootstrapMean: mean7, bootstrapStd: std2 };
 }
-function _mean(arr8) {
+function _mean(arr10) {
   let sum3 = 0;
-  for (let i = 0; i < arr8.length; i++) sum3 += arr8[i];
-  return sum3 / arr8.length;
+  for (let i = 0; i < arr10.length; i++) sum3 += arr10[i];
+  return sum3 / arr10.length;
 }
-function _variance(arr8, ddof = 1) {
-  const m = _mean(arr8);
+function _variance(arr10, ddof = 1) {
+  const m = _mean(arr10);
   let sum3 = 0;
-  for (let i = 0; i < arr8.length; i++) sum3 += (arr8[i] - m) ** 2;
-  return sum3 / (arr8.length - ddof);
+  for (let i = 0; i < arr10.length; i++) sum3 += (arr10[i] - m) ** 2;
+  return sum3 / (arr10.length - ddof);
 }
 function _erf(x) {
   if (x === 0) return 0;
@@ -15928,9 +15928,9 @@ function _mwUCounts(n16, n26) {
     const row2 = [];
     for (let j = 0; j <= n26; j++) {
       const maxU = i * j;
-      const arr8 = new Float64Array(maxU + 1);
+      const arr10 = new Float64Array(maxU + 1);
       if (i === 0 || j === 0) {
-        arr8[0] = 1;
+        arr10[0] = 1;
       } else {
         const prevI = table[i - 1][j];
         const prevJ = row2[j - 1];
@@ -15939,10 +15939,10 @@ function _mwUCounts(n16, n26) {
           const uShift = u - j;
           if (uShift >= 0 && uShift < prevI.length) val += prevI[uShift];
           if (u < prevJ.length) val += prevJ[u];
-          arr8[u] = val;
+          arr10[u] = val;
         }
       }
-      row2.push(arr8);
+      row2.push(arr10);
     }
     table.push(row2);
   }
@@ -16359,8 +16359,8 @@ function kolmogorovSmirnov2Test(sample1, sample2, opts) {
   const en = Math.sqrt(n16 * n26 / (n16 + n26));
   return { statistic: d, pValue: _kstwobignSf(en * d) };
 }
-function _median(arr8) {
-  const s = arr8.slice().sort((a, b) => a - b);
+function _median(arr10) {
+  const s = arr10.slice().sort((a, b) => a - b);
   const n = s.length;
   const m = n >> 1;
   return n % 2 === 1 ? s[m] : (s[m - 1] + s[m]) / 2;
@@ -18150,19 +18150,19 @@ var randomInt = mathTyped16("randomInt", {
   }
 });
 var pickRandom = mathTyped16("pickRandom", {
-  Array: (arr8) => _pick(arr8, 1, void 0)[0],
-  "Array, number": (arr8, n) => _pick(arr8, n, void 0),
-  "Array, Array": (arr8, weights) => _pick(arr8, 1, weights)[0],
-  "Array, number, Array": (arr8, n, weights) => _pick(arr8, n, weights),
-  "Array, Array, number": (arr8, weights, n) => _pick(arr8, n, weights)
+  Array: (arr10) => _pick(arr10, 1, void 0)[0],
+  "Array, number": (arr10, n) => _pick(arr10, n, void 0),
+  "Array, Array": (arr10, weights) => _pick(arr10, 1, weights)[0],
+  "Array, number, Array": (arr10, n, weights) => _pick(arr10, n, weights),
+  "Array, Array, number": (arr10, weights, n) => _pick(arr10, n, weights)
 });
-function _pick(arr8, n, weights) {
-  if (arr8.length === 0) throw new RangeError("Cannot pick from an empty array");
+function _pick(arr10, n, weights) {
+  if (arr10.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 !== arr8.length) {
+    if (weights.length !== arr10.length) {
       throw new RangeError("weights must have the same length as the array");
     }
     let total = 0;
@@ -18176,20 +18176,20 @@ function _pick(arr8, n, weights) {
     const result2 = [];
     for (let i = 0; i < n; i++) {
       let r = _rng() * total;
-      for (let j = 0; j < arr8.length; j++) {
+      for (let j = 0; j < arr10.length; j++) {
         r -= weights[j];
         if (r < 0) {
-          result2.push(arr8[j]);
+          result2.push(arr10[j]);
           break;
         }
       }
-      if (result2.length < i + 1) result2.push(arr8[arr8.length - 1]);
+      if (result2.length < i + 1) result2.push(arr10[arr10.length - 1]);
     }
     return result2;
   }
   const result = [];
   for (let i = 0; i < n; i++) {
-    result.push(arr8[Math.floor(_rng() * arr8.length)]);
+    result.push(arr10[Math.floor(_rng() * arr10.length)]);
   }
   return result;
 }
@@ -18841,13 +18841,13 @@ function resize(array, size2, defaultValue) {
       );
     }
   });
-  let arr8 = array;
+  let arr10 = array;
   if (isNumber(array) || isBigNumber(array)) {
-    arr8 = [array];
+    arr10 = [array];
   }
   const _defaultValue = defaultValue !== void 0 ? defaultValue : 0;
-  _resize(arr8, size2, 0, _defaultValue);
-  return arr8;
+  _resize(arr10, size2, 0, _defaultValue);
+  return arr10;
 }
 function _resize(array, size2, dim, defaultValue) {
   let i;
@@ -18948,9 +18948,9 @@ function _reshape(array, sizes) {
 }
 function squeeze(array, size2) {
   const s = size2 || arraySize(array);
-  let arr8 = array;
-  while (Array.isArray(arr8) && arr8.length === 1) {
-    arr8 = arr8[0];
+  let arr10 = array;
+  while (Array.isArray(arr10) && arr10.length === 1) {
+    arr10 = arr10[0];
     s.shift();
   }
   let dims = s.length;
@@ -18958,19 +18958,19 @@ function squeeze(array, size2) {
     dims--;
   }
   if (dims < s.length) {
-    arr8 = _squeeze(arr8, dims, 0);
+    arr10 = _squeeze(arr10, dims, 0);
     s.length = dims;
   }
-  return arr8;
+  return arr10;
 }
 function _squeeze(array, dims, dim) {
   if (dim < dims) {
     const next = dim + 1;
-    const arr8 = array;
-    for (let i = 0, ii = arr8.length; i < ii; i++) {
-      arr8[i] = _squeeze(arr8[i], dims, next);
+    const arr10 = array;
+    for (let i = 0, ii = arr10.length; i < ii; i++) {
+      arr10[i] = _squeeze(arr10[i], dims, next);
     }
-    return arr8;
+    return arr10;
   } else {
     let result = array;
     while (Array.isArray(result)) {
@@ -18993,9 +18993,9 @@ function flatten2(array, isRectangular = false) {
     _flatten(array);
   }
   return flat;
-  function _flatten(arr8) {
-    for (let i = 0; i < arr8.length; i++) {
-      const item = arr8[i];
+  function _flatten(arr10) {
+    for (let i = 0; i < arr10.length; i++) {
+      const item = arr10[i];
       if (Array.isArray(item)) {
         _flatten(item);
       } else {
@@ -19003,14 +19003,14 @@ function flatten2(array, isRectangular = false) {
       }
     }
   }
-  function _flattenRectangular(arr8) {
-    if (Array.isArray(arr8[0])) {
-      for (let i = 0; i < arr8.length; i++) {
-        _flattenRectangular(arr8[i]);
+  function _flattenRectangular(arr10) {
+    if (Array.isArray(arr10[0])) {
+      for (let i = 0; i < arr10.length; i++) {
+        _flattenRectangular(arr10[i]);
       }
     } else {
-      for (let i = 0; i < arr8.length; i++) {
-        flat.push(arr8[i]);
+      for (let i = 0; i < arr10.length; i++) {
+        flat.push(arr10[i]);
       }
     }
   }
@@ -19506,12 +19506,12 @@ var dependencies6 = ["typed", "Complex"];
 var createExpm1 = /* @__PURE__ */ factory(
   name6,
   dependencies6,
-  ({ typed: typed3, Complex: Complex12 }) => {
+  ({ typed: typed3, Complex: Complex13 }) => {
     return typed3(name6, {
       number: expm1Number,
       Complex: function(x) {
         const r = Math.exp(x.re);
-        return new Complex12(r * Math.cos(x.im) - 1, r * Math.sin(x.im));
+        return new Complex13(r * Math.cos(x.im) - 1, r * Math.sin(x.im));
       },
       BigNumber: function(x) {
         return x.exp().minus(1);
@@ -19540,12 +19540,12 @@ var log16 = log10Number(16);
 var createLog10 = /* @__PURE__ */ factory(
   name7,
   dependencies7,
-  ({ typed: typed3, config: config2, Complex: Complex12 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex13 }) => {
     function complexLog(c) {
       return c.log().div(Math.LN10);
     }
     function complexLogNumber(x) {
-      return complexLog(new Complex12(x, 0));
+      return complexLog(new Complex13(x, 0));
     }
     return typed3(name7, {
       number: function(x) {
@@ -19577,9 +19577,9 @@ var dependencies8 = ["typed", "config", "Complex"];
 var createLog2 = /* @__PURE__ */ factory(
   name8,
   dependencies8,
-  ({ typed: typed3, config: config2, Complex: Complex12 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex13 }) => {
     function complexLog2Number(x) {
-      return _log2Complex(new Complex12(x, 0));
+      return _log2Complex(new Complex13(x, 0));
     }
     return typed3(name8, {
       number: function(x) {
@@ -19604,7 +19604,7 @@ var createLog2 = /* @__PURE__ */ factory(
     });
     function _log2Complex(x) {
       const newX = Math.sqrt(x.re * x.re + x.im * x.im);
-      return new Complex12(
+      return new Complex13(
         Math.log2 ? Math.log2(newX) : Math.log(newX) / Math.LN2,
         Math.atan2(x.im, x.re) / Math.LN2
       );
@@ -19645,11 +19645,11 @@ var dependencies10 = ["typed", "BigNumber", "complex", "Fraction"];
 var createSign = /* @__PURE__ */ factory(
   name10,
   dependencies10,
-  ({ typed: typed3, BigNumber: BigNumber9, complex: complex2, Fraction: Fraction5 }) => {
+  ({ typed: typed3, BigNumber: BigNumber9, complex: complex3, Fraction: Fraction5 }) => {
     return typed3(name10, {
       number: signNumber,
       Complex: function(x) {
-        return x.im === 0 ? complex2(signNumber(x.re)) : x.sign();
+        return x.im === 0 ? complex3(signNumber(x.re)) : x.sign();
       },
       BigNumber: function(x) {
         return new BigNumber9(x.cmp(0));
@@ -19680,7 +19680,7 @@ var dependencies11 = ["config", "typed", "Complex"];
 var createSqrt = /* @__PURE__ */ factory(
   name11,
   dependencies11,
-  ({ config: config2, typed: typed3, Complex: Complex12 }) => {
+  ({ config: config2, typed: typed3, Complex: Complex13 }) => {
     return typed3("sqrt", {
       number: _sqrtNumber,
       Complex: function(x) {
@@ -19703,7 +19703,7 @@ var createSqrt = /* @__PURE__ */ factory(
       } else if (x >= 0 || config2.predictable) {
         return Math.sqrt(x);
       } else {
-        return new Complex12(x, 0).sqrt();
+        return new Complex13(x, 0).sqrt();
       }
     }
   }
@@ -19990,24 +19990,24 @@ function decCoefficientToBinaryString(x) {
       str = str.slice(0, xe) + "." + str.slice(xe);
     }
   }
-  const arr8 = [0];
+  const arr10 = [0];
   for (let i = 0; i < str.length; ) {
-    let arrL = arr8.length;
+    let arrL = arr10.length;
     while (arrL--) {
-      arr8[arrL] *= 10;
+      arr10[arrL] *= 10;
     }
-    arr8[0] += parseInt(str.charAt(i++));
-    for (let j2 = 0; j2 < arr8.length; ++j2) {
-      if (arr8[j2] > 1) {
-        if (arr8[j2 + 1] === null || arr8[j2 + 1] === void 0) {
-          arr8[j2 + 1] = 0;
+    arr10[0] += parseInt(str.charAt(i++));
+    for (let j2 = 0; j2 < arr10.length; ++j2) {
+      if (arr10[j2] > 1) {
+        if (arr10[j2 + 1] === null || arr10[j2 + 1] === void 0) {
+          arr10[j2 + 1] = 0;
         }
-        arr8[j2 + 1] += arr8[j2] >> 1;
-        arr8[j2] &= 1;
+        arr10[j2 + 1] += arr10[j2] >> 1;
+        arr10[j2] &= 1;
       }
     }
   }
-  return arr8.reverse();
+  return arr10.reverse();
 }
 function bitXor2(x, y) {
   if (x.isFinite() && !x.isInteger() || y.isFinite() && !y.isInteger()) {
@@ -20507,8 +20507,8 @@ var createMap = /* @__PURE__ */ factory(
             if (index) index[depth] = i;
             result[i] = iterate(
               arrays2.map((array, arrayIndex) => {
-                const arr8 = array;
-                return offsets[arrayIndex] > depth ? array : arr8.length === 1 ? arr8[0] : arr8[i];
+                const arr10 = array;
+                return offsets[arrayIndex] > depth ? array : arr10.length === 1 ? arr10[0] : arr10[i];
               }),
               depth + 1
             );
@@ -20518,8 +20518,8 @@ var createMap = /* @__PURE__ */ factory(
             if (index) index[depth] = i;
             result[i] = callback(
               arrays2.map((a) => {
-                const arr8 = a;
-                return arr8.length === 1 ? arr8[0] : arr8[i];
+                const arr10 = a;
+                return arr10.length === 1 ? arr10[0] : arr10[i];
               }),
               index ? index.slice() : void 0
             );
@@ -20715,7 +20715,7 @@ var dependencies30 = ["Complex", "typed"];
 var createLgamma = /* @__PURE__ */ factory(
   name30,
   dependencies30,
-  ({ Complex: Complex12, typed: typed3 }) => {
+  ({ Complex: Complex13, typed: typed3 }) => {
     const SMALL_RE = 7;
     const SMALL_IM = 7;
     const coeffs = [
@@ -20729,15 +20729,15 @@ var createLgamma = /* @__PURE__ */ factory(
       0.08333333333333333
     ];
     return typed3(name30, {
-      Array: function(arr8) {
+      Array: function(arr10) {
         const wasm = wasmLoader.getModule();
-        if (wasm && arr8.length >= 100 && arr8.every((x) => typeof x === "number")) {
+        if (wasm && arr10.length >= 100 && arr10.every((x) => typeof x === "number")) {
           try {
-            const input = new Float64Array(arr8);
+            const input = new Float64Array(arr10);
             const inputAlloc = wasmLoader.allocateFloat64Array(input);
-            const resultAlloc = wasmLoader.allocateFloat64ArrayEmpty(arr8.length);
+            const resultAlloc = wasmLoader.allocateFloat64ArrayEmpty(arr10.length);
             try {
-              wasm.lgammaArray(inputAlloc.ptr, arr8.length, resultAlloc.ptr);
+              wasm.lgammaArray(inputAlloc.ptr, arr10.length, resultAlloc.ptr);
               return Array.from(resultAlloc.array);
             } finally {
               wasmLoader.free(inputAlloc.ptr);
@@ -20746,7 +20746,7 @@ var createLgamma = /* @__PURE__ */ factory(
           } catch {
           }
         }
-        return arr8.map((x) => lgammaNumber(x));
+        return arr10.map((x) => lgammaNumber(x));
       },
       number: lgammaNumber,
       Complex: lgammaComplex2,
@@ -20761,16 +20761,16 @@ var createLgamma = /* @__PURE__ */ factory(
       const LOGPI = 1.1447298858494002;
       const REFLECTION = 0.1;
       if (n.isNaN()) {
-        return new Complex12(NaN, NaN);
+        return new Complex13(NaN, NaN);
       } else if (n.im === 0) {
-        return new Complex12(lgammaNumber(n.re), 0);
+        return new Complex13(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 Complex12(1 - n.re, -n.im));
-        return new Complex12(LOGPI, tmp).sub(a).sub(b);
+        const b = lgammaComplex2(new Complex13(1 - n.re, -n.im));
+        return new Complex13(LOGPI, tmp).sub(a).sub(b);
       } else if (n.im >= 0) {
         return lgammaRecurrence(n);
       } else {
@@ -20779,7 +20779,7 @@ var createLgamma = /* @__PURE__ */ factory(
     }
     function lgammaStirling(z) {
       const leftPart = z.sub(0.5).mul(z.log()).sub(z).add(lnSqrt2PI);
-      const rz = new Complex12(1, 0).div(z);
+      const rz = new Complex13(1, 0).div(z);
       const rzz = rz.div(z);
       let a = coeffs[0];
       let b = coeffs[1];
@@ -20805,7 +20805,7 @@ var createLgamma = /* @__PURE__ */ factory(
         sb = nsb;
         z = z.add(1);
       }
-      return lgammaStirling(z).sub(shiftprod.log()).sub(new Complex12(0, signflips * 2 * Math.PI * 1));
+      return lgammaStirling(z).sub(shiftprod.log()).sub(new Complex13(0, signflips * 2 * Math.PI * 1));
     }
   }
 );
@@ -21243,13 +21243,13 @@ var dependencies37 = ["typed", "config", "Complex"];
 var createAcos = /* @__PURE__ */ factory(
   name37,
   dependencies37,
-  ({ typed: typed3, config: config2, Complex: Complex12 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex13 }) => {
     return typed3(name37, {
       number: function(x) {
         if (x >= -1 && x <= 1 || config2.predictable) {
           return Math.acos(x);
         } else {
-          return new Complex12(x, 0).acos();
+          return new Complex13(x, 0).acos();
         }
       },
       Complex: function(x) {
@@ -21268,16 +21268,16 @@ var dependencies38 = ["typed", "config", "Complex"];
 var createAcosh = /* @__PURE__ */ factory(
   name38,
   dependencies38,
-  ({ typed: typed3, config: config2, Complex: Complex12 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex13 }) => {
     return typed3(name38, {
       number: function(x) {
         if (x >= 1 || config2.predictable) {
           return acoshNumber(x);
         }
         if (x <= -1) {
-          return new Complex12(Math.log(Math.sqrt(x * x - 1) - x), Math.PI);
+          return new Complex13(Math.log(Math.sqrt(x * x - 1) - x), Math.PI);
         }
-        return new Complex12(x, 0).acosh();
+        return new Complex13(x, 0).acosh();
       },
       Complex: function(x) {
         return x.acosh();
@@ -21314,13 +21314,13 @@ var dependencies40 = ["typed", "config", "Complex", "BigNumber"];
 var createAcoth = /* @__PURE__ */ factory(
   name40,
   dependencies40,
-  ({ typed: typed3, config: config2, Complex: Complex12, BigNumber: BigNumber9 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex13, BigNumber: BigNumber9 }) => {
     return typed3(name40, {
       number: function(x) {
         if (x >= 1 || x <= -1 || config2.predictable) {
           return acothNumber(x);
         }
-        return new Complex12(x, 0).acoth();
+        return new Complex13(x, 0).acoth();
       },
       Complex: function(x) {
         return x.acoth();
@@ -21338,13 +21338,13 @@ var dependencies41 = ["typed", "config", "Complex", "BigNumber"];
 var createAcsc = /* @__PURE__ */ factory(
   name41,
   dependencies41,
-  ({ typed: typed3, config: config2, Complex: Complex12, BigNumber: BigNumber9 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex13, BigNumber: BigNumber9 }) => {
     return typed3(name41, {
       number: function(x) {
         if (x <= -1 || x >= 1 || config2.predictable) {
           return acscNumber(x);
         }
-        return new Complex12(x, 0).acsc();
+        return new Complex13(x, 0).acsc();
       },
       Complex: function(x) {
         return x.acsc();
@@ -21381,13 +21381,13 @@ var dependencies43 = ["typed", "config", "Complex", "BigNumber"];
 var createAsec = /* @__PURE__ */ factory(
   name43,
   dependencies43,
-  ({ typed: typed3, config: config2, Complex: Complex12, BigNumber: BigNumber9 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex13, BigNumber: BigNumber9 }) => {
     return typed3(name43, {
       number: function(x) {
         if (x <= -1 || x >= 1 || config2.predictable) {
           return asecNumber(x);
         }
-        return new Complex12(x, 0).asec();
+        return new Complex13(x, 0).asec();
       },
       Complex: function(x) {
         return x.asec();
@@ -21405,7 +21405,7 @@ var dependencies44 = ["typed", "config", "Complex", "BigNumber"];
 var createAsech = /* @__PURE__ */ factory(
   name44,
   dependencies44,
-  ({ typed: typed3, config: config2, Complex: Complex12, BigNumber: BigNumber9 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex13, BigNumber: BigNumber9 }) => {
     return typed3(name44, {
       number: function(x) {
         if (x <= 1 && x >= -1 || config2.predictable) {
@@ -21414,9 +21414,9 @@ var createAsech = /* @__PURE__ */ factory(
             return asechNumber(x);
           }
           const ret = Math.sqrt(xInv * xInv - 1);
-          return new Complex12(Math.log(ret - xInv), Math.PI);
+          return new Complex13(Math.log(ret - xInv), Math.PI);
         }
-        return new Complex12(x, 0).asech();
+        return new Complex13(x, 0).asech();
       },
       Complex: function(x) {
         return x.asech();
@@ -21434,13 +21434,13 @@ var dependencies45 = ["typed", "config", "Complex"];
 var createAsin = /* @__PURE__ */ factory(
   name45,
   dependencies45,
-  ({ typed: typed3, config: config2, Complex: Complex12 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex13 }) => {
     return typed3(name45, {
       number: function(x) {
         if (x >= -1 && x <= 1 || config2.predictable) {
           return Math.asin(x);
         } else {
-          return new Complex12(x, 0).asin();
+          return new Complex13(x, 0).asin();
         }
       },
       Complex: function(x) {
@@ -21499,13 +21499,13 @@ var dependencies48 = ["typed", "config", "Complex"];
 var createAtanh = /* @__PURE__ */ factory(
   name48,
   dependencies48,
-  ({ typed: typed3, config: config2, Complex: Complex12 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex13 }) => {
     return typed3(name48, {
       number: function(x) {
         if (x <= 1 && x >= -1 || config2.predictable) {
           return atanhNumber(x);
         }
-        return new Complex12(x, 0).atanh();
+        return new Complex13(x, 0).atanh();
       },
       Complex: function(x) {
         return x.atanh();
@@ -21783,8 +21783,8 @@ var createIsBounded = /* @__PURE__ */ factory(
       ),
       "Array | Matrix": typed3.referToSelf(
         (self) => (A) => {
-          const arr8 = Array.isArray(A) ? A : A.valueOf();
-          return arr8.every((entry) => self(entry));
+          const arr10 = Array.isArray(A) ? A : A.valueOf();
+          return arr10.every((entry) => self(entry));
         }
       )
     });
@@ -22120,9 +22120,9 @@ var createUnaryPlus = /* @__PURE__ */ factory(
 
 // src/matrix/dot.ts
 import { pairwiseDot as pairwiseDot2 } from "@danielsimonjr/mathts-core";
-function _isFlatNumbers(arr8) {
-  for (let i = 0; i < arr8.length; i++) {
-    if (typeof arr8[i] !== "number") return false;
+function _isFlatNumbers(arr10) {
+  for (let i = 0; i < arr10.length; i++) {
+    if (typeof arr10[i] !== "number") return false;
   }
   return true;
 }
@@ -22362,9 +22362,9 @@ function improveErrorMessage(err, fnName, value) {
 
 // src/statistics/prod.ts
 var WASM_PROD_THRESHOLD = 100;
-function isFlatNumberArray(arr8) {
-  for (let i = 0; i < arr8.length; i++) {
-    if (typeof arr8[i] !== "number") {
+function isFlatNumberArray(arr10) {
+  for (let i = 0; i < arr10.length; i++) {
+    if (typeof arr10[i] !== "number") {
       return false;
     }
   }
@@ -22882,19 +22882,19 @@ function createZerosAndOnes(name254, defaultValue, { typed: typed3, config: conf
       }
       return m;
     } else {
-      const arr8 = [];
+      const arr10 = [];
       if (size2.length > 0) {
-        return resize(arr8, size2, dflt);
+        return resize(arr10, size2, dflt);
       }
-      return arr8;
+      return arr10;
     }
   }
   function _normalize(size2) {
     let hasBigNumbers = false;
-    size2.forEach(function(value, index, arr8) {
+    size2.forEach(function(value, index, arr10) {
       if (isBigNumber(value)) {
         hasBigNumbers = true;
-        arr8[index] = value.toNumber();
+        arr10[index] = value.toNumber();
       }
     });
     return hasBigNumbers;
@@ -23021,9 +23021,9 @@ var createDiag = /* @__PURE__ */ factory(
 
 // src/matrix/kron.ts
 var WASM_KRON_THRESHOLD = 64;
-function isPlainNumber2D(arr8) {
-  for (let i = 0; i < arr8.length; i++) {
-    const row2 = arr8[i];
+function isPlainNumber2D(arr10) {
+  for (let i = 0; i < arr10.length; i++) {
+    const row2 = arr10[i];
     for (let j = 0; j < row2.length; j++) {
       if (typeof row2[j] !== "number") {
         return false;
@@ -23032,11 +23032,11 @@ function isPlainNumber2D(arr8) {
   }
   return true;
 }
-function flatten2D(arr8, rows, cols) {
+function flatten2D(arr10, 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] = arr8[i][j];
+      result[i * cols + j] = arr10[i][j];
     }
   }
   return result;
@@ -23178,15 +23178,15 @@ var createMatrixFromColumns = /* @__PURE__ */ factory(
   ({ typed: typed3, matrix: matrix2, flatten: flatten4, size: size2 }) => {
     return typed3(name92, {
       // Single variadic handler for arrays, matrices, and mixed types
-      "...": function(arr8) {
-        if (arr8.length === 0) {
+      "...": function(arr10) {
+        if (arr10.length === 0) {
           throw new TypeError("At least one column is needed to construct a matrix.");
         }
-        const allMatrix = arr8.every(
+        const allMatrix = arr10.every(
           (item) => typeof item.toArray === "function"
         );
-        const hasArray = arr8.some((item) => Array.isArray(item));
-        const arrays = arr8.map(
+        const hasArray = arr10.some((item) => Array.isArray(item));
+        const arrays = arr10.map(
           (item) => typeof item.toArray === "function" ? item.toArray() : item
         );
         const result = _createArray(arrays);
@@ -23197,15 +23197,15 @@ var createMatrixFromColumns = /* @__PURE__ */ factory(
       }
       // TODO implement this properly for SparseMatrix
     });
-    function _createArray(arr8) {
-      if (arr8.length === 0)
+    function _createArray(arr10) {
+      if (arr10.length === 0)
         throw new TypeError("At least one column is needed to construct a matrix.");
-      const N = checkVectorTypeAndReturnLength(arr8[0]);
+      const N = checkVectorTypeAndReturnLength(arr10[0]);
       const result = [];
       for (let i = 0; i < N; i++) {
         result[i] = [];
       }
-      for (const col of arr8) {
+      for (const col of arr10) {
         const colLength = checkVectorTypeAndReturnLength(col);
         if (colLength !== N) {
           throw new TypeError(
@@ -23247,15 +23247,15 @@ var createMatrixFromRows = /* @__PURE__ */ factory(
   ({ typed: typed3, matrix: matrix2, flatten: flatten4, size: size2 }) => {
     return typed3(name93, {
       // Single variadic handler for arrays, matrices, and mixed types
-      "...": function(arr8) {
-        if (arr8.length === 0) {
+      "...": function(arr10) {
+        if (arr10.length === 0) {
           throw new TypeError("At least one row is needed to construct a matrix.");
         }
-        const allMatrix = arr8.every(
+        const allMatrix = arr10.every(
           (item) => typeof item.toArray === "function"
         );
-        const hasArray = arr8.some((item) => Array.isArray(item));
-        const arrays = arr8.map(
+        const hasArray = arr10.some((item) => Array.isArray(item));
+        const arrays = arr10.map(
           (item) => typeof item.toArray === "function" ? item.toArray() : item
         );
         const result = _createArray(arrays);
@@ -23266,12 +23266,12 @@ var createMatrixFromRows = /* @__PURE__ */ factory(
       }
       // TODO implement this properly for SparseMatrix
     });
-    function _createArray(arr8) {
-      if (arr8.length === 0)
+    function _createArray(arr10) {
+      if (arr10.length === 0)
         throw new TypeError("At least one row is needed to construct a matrix.");
-      const N = checkVectorTypeAndReturnLength(arr8[0]);
+      const N = checkVectorTypeAndReturnLength(arr10[0]);
       const result = [];
-      for (const row2 of arr8) {
+      for (const row2 of arr10) {
         const rowLength = checkVectorTypeAndReturnLength(row2);
         if (rowLength !== N) {
           throw new TypeError(
@@ -25340,7 +25340,7 @@ var createCbrt = /* @__PURE__ */ factory(
     isNegative: isNegative2,
     unaryMinus: unaryMinus2,
     matrix: matrix2,
-    Complex: Complex12,
+    Complex: Complex13,
     BigNumber: BigNumber9,
     Fraction: Fraction5
   }) => {
@@ -25352,7 +25352,7 @@ var createCbrt = /* @__PURE__ */ factory(
       // through the complex cube-root path (all three roots when allRoots, the
       // principal Complex root otherwise) — matching mathjs `cbrt(8, true)`.
       "number, boolean": function(x, allRoots) {
-        return _cbrtComplex(new Complex12(x, 0), allRoots);
+        return _cbrtComplex(new Complex13(x, 0), allRoots);
       },
       Complex: _cbrtComplex,
       "Complex, boolean": _cbrtComplex,
@@ -25364,12 +25364,12 @@ var createCbrt = /* @__PURE__ */ factory(
     function _cbrtComplex(x, allRoots) {
       const arg3 = x.arg() / 3;
       const abs2 = x.abs();
-      const principal = new Complex12(cbrtNumber(abs2), 0).mul(new Complex12(0, arg3).exp());
+      const principal = new Complex13(cbrtNumber(abs2), 0).mul(new Complex13(0, arg3).exp());
       if (allRoots) {
         const all = [
           principal,
-          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())
+          new Complex13(cbrtNumber(abs2), 0).mul(new Complex13(0, arg3 + Math.PI * 2 / 3).exp()),
+          new Complex13(cbrtNumber(abs2), 0).mul(new Complex13(0, arg3 - Math.PI * 2 / 3).exp())
         ];
         return config2.matrix === "Array" ? all : matrix2(all);
       } else {
@@ -25418,27 +25418,27 @@ var createNthRoots = /* @__PURE__ */ factory(
     typed: typed3,
     config: _config,
     divideScalar: _divideScalar,
-    Complex: Complex12
+    Complex: Complex13
   }) => {
     const _calculateExactResult = [
       function realPos(val) {
-        return new Complex12(val, 0);
+        return new Complex13(val, 0);
       },
       function imagPos(val) {
-        return new Complex12(0, val);
+        return new Complex13(0, val);
       },
       function realNeg(val) {
-        return new Complex12(-val, 0);
+        return new Complex13(-val, 0);
       },
       function imagNeg(val) {
-        return new Complex12(0, -val);
+        return new Complex13(0, -val);
       }
     ];
     function _nthComplexRoots(a, root2) {
       if (root2 < 0) throw new Error("Root must be greater than zero");
       if (root2 === 0) throw new Error("Root must be non-zero");
       if (root2 % 1 !== 0) throw new Error("Root must be an integer");
-      if (a === 0 || a.abs() === 0) return [new Complex12(0, 0)];
+      if (a === 0 || a.abs() === 0) return [new Complex13(0, 0)];
       const aIsNumeric = typeof a === "number";
       let offset = NaN;
       if (aIsNumeric || a.re === 0 || a.im === 0) {
@@ -25460,7 +25460,7 @@ var createNthRoots = /* @__PURE__ */ factory(
           roots.push(_calculateExactResult[halfPiFactor % 4](r));
           continue;
         }
-        roots.push(new Complex12({ r, phi: (arg3 + 2 * Math.PI * k) / root2 }));
+        roots.push(new Complex13({ r, phi: (arg3 + 2 * Math.PI * k) / root2 }));
       }
       return roots;
     }
@@ -25847,12 +25847,12 @@ var nlg16 = Math.log(16);
 var createLog = /* @__PURE__ */ factory(
   name113,
   dependencies113,
-  ({ typed: typed3, typeOf: typeOf3, config: config2, divideScalar: divideScalar2, Complex: Complex12 }) => {
+  ({ typed: typed3, typeOf: typeOf3, config: config2, divideScalar: divideScalar2, Complex: Complex13 }) => {
     function complexLog(c) {
       return c.log();
     }
     function complexLogNumber(x) {
-      return complexLog(new Complex12(x, 0));
+      return complexLog(new Complex13(x, 0));
     }
     return typed3(name113, {
       number: function(x) {
@@ -26283,9 +26283,9 @@ var createResize = /* @__PURE__ */ factory(
         }
         return clone(scalar);
       } else {
-        let arr8 = !Array.isArray(x) ? [x] : x;
-        arr8 = clone(arr8);
-        const res = resize(arr8, sz, defaultValue);
+        let arr10 = !Array.isArray(x) ? [x] : x;
+        arr10 = clone(arr10);
+        const res = resize(arr10, sz, defaultValue);
         return asMatrix ? matrix2(res) : res;
       }
     }
@@ -27127,7 +27127,7 @@ var dependencies127 = ["typed", "add", "multiply", "Complex", "number"];
 var createZpk2tf = /* @__PURE__ */ factory(
   name127,
   dependencies127,
-  ({ typed: typed3, add: add2, multiply: multiply2, Complex: Complex12, number: number2 }) => {
+  ({ typed: typed3, add: add2, multiply: multiply2, Complex: Complex13, number: number2 }) => {
     return typed3(name127, {
       "Array,Array,number": function(z, p, k) {
         return _zpk2tf(z, p, k);
@@ -27149,17 +27149,17 @@ var createZpk2tf = /* @__PURE__ */ factory(
       if (p.some((el) => el.type === "BigNumber")) {
         p = p.map((el) => number2(el));
       }
-      let num2 = [Complex12(1, 0)];
-      let den = [Complex12(1, 0)];
+      let num2 = [Complex13(1, 0)];
+      let den = [Complex13(1, 0)];
       for (let i = 0; i < z.length; i++) {
         let zero = z[i];
-        if (typeof zero === "number") zero = Complex12(zero, 0);
-        num2 = _multiply2(num2, [Complex12(1, 0), Complex12(-zero.re, -zero.im)]);
+        if (typeof zero === "number") zero = Complex13(zero, 0);
+        num2 = _multiply2(num2, [Complex13(1, 0), Complex13(-zero.re, -zero.im)]);
       }
       for (let i = 0; i < p.length; i++) {
         let pole = p[i];
-        if (typeof pole === "number") pole = Complex12(pole, 0);
-        den = _multiply2(den, [Complex12(1, 0), Complex12(-pole.re, -pole.im)]);
+        if (typeof pole === "number") pole = Complex13(pole, 0);
+        den = _multiply2(den, [Complex13(1, 0), Complex13(-pole.re, -pole.im)]);
       }
       for (let i = 0; i < num2.length; i++) {
         num2[i] = multiply2(num2[i], k);
@@ -27169,7 +27169,7 @@ var createZpk2tf = /* @__PURE__ */ factory(
     function _multiply2(a, b) {
       const c = [];
       for (let i = 0; i < a.length + b.length - 1; i++) {
-        c[i] = Complex12(0, 0);
+        c[i] = Complex13(0, 0);
         for (let j = 0; j < a.length; j++) {
           if (i - j >= 0 && i - j < b.length) {
             c[i] = add2(c[i], multiply2(a[j], b[i - j]));
@@ -27183,9 +27183,9 @@ var createZpk2tf = /* @__PURE__ */ factory(
 
 // src/statistics/cumsum.ts
 import { neumaierCumsum as neumaierCumsum2 } from "@danielsimonjr/mathts-core";
-function isFlatNumberArray2(arr8) {
-  for (let i = 0; i < arr8.length; i++) {
-    if (typeof arr8[i] !== "number") {
+function isFlatNumberArray2(arr10) {
+  for (let i = 0; i < arr10.length; i++) {
+    if (typeof arr10[i] !== "number") {
       return false;
     }
   }
@@ -27282,9 +27282,9 @@ var createCumSum = /* @__PURE__ */ factory(
 
 // src/statistics/sum.ts
 import { pairwiseSum as pairwiseSum2 } from "@danielsimonjr/mathts-core";
-function isFlatNumberArray3(arr8) {
-  for (let i = 0; i < arr8.length; i++) {
-    if (typeof arr8[i] !== "number") {
+function isFlatNumberArray3(arr10) {
+  for (let i = 0; i < arr10.length; i++) {
+    if (typeof arr10[i] !== "number") {
       return false;
     }
   }
@@ -28385,13 +28385,13 @@ var dependencies143 = ["typed", "config", "divideScalar", "log", "Complex"];
 var createLog1p = /* @__PURE__ */ factory(
   name143,
   dependencies143,
-  ({ typed: typed3, config: config2, divideScalar: divideScalar2, log: log3, Complex: Complex12 }) => {
+  ({ typed: typed3, config: config2, divideScalar: divideScalar2, log: log3, Complex: Complex13 }) => {
     return typed3(name143, {
       number: function(x) {
         if (x >= -1 || config2.predictable) {
           return log1p2(x);
         } else {
-          return _log1pComplex(new Complex12(x, 0));
+          return _log1pComplex(new Complex13(x, 0));
         }
       },
       Complex: _log1pComplex,
@@ -28400,7 +28400,7 @@ var createLog1p = /* @__PURE__ */ factory(
         if (!y.isNegative() || config2.predictable) {
           return y.ln();
         } else {
-          return _log1pComplex(new Complex12(x.toNumber(), 0));
+          return _log1pComplex(new Complex13(x.toNumber(), 0));
         }
       },
       "Array | Matrix": typed3.referToSelf(
@@ -28414,7 +28414,7 @@ var createLog1p = /* @__PURE__ */ factory(
     });
     function _log1pComplex(x) {
       const xRe1p = x.re + 1;
-      return new Complex12(Math.log(Math.sqrt(xRe1p * xRe1p + x.im * x.im)), Math.atan2(x.im, xRe1p));
+      return new Complex13(Math.log(Math.sqrt(xRe1p * xRe1p + x.im * x.im)), Math.atan2(x.im, xRe1p));
     }
   }
 );
@@ -28566,7 +28566,7 @@ var createPow = /* @__PURE__ */ factory(
     inv: inv2,
     number: number2,
     fraction: fraction2,
-    Complex: Complex12
+    Complex: Complex13
   }) => {
     return typed3(name145, {
       "number, number": _pow,
@@ -28577,7 +28577,7 @@ var createPow = /* @__PURE__ */ factory(
         if (y.isInteger() || x.gte(0) || config2.predictable) {
           return x.pow(y);
         } else {
-          return new Complex12(x.toNumber(), 0).pow(y.toNumber(), 0);
+          return new Complex13(x.toNumber(), 0).pow(y.toNumber(), 0);
         }
       },
       "bigint, bigint": (x, y) => x ** y,
@@ -28626,7 +28626,7 @@ var createPow = /* @__PURE__ */ factory(
         if (isPowZeroAtInfinity(x, y)) {
           return 0;
         }
-        return new Complex12(x, 0).pow(y, 0);
+        return new Complex13(x, 0).pow(y, 0);
       }
     }
     function _powArray(x, y) {
@@ -29897,7 +29897,7 @@ var createFixNumber = /* @__PURE__ */ factory(
 var createFix = /* @__PURE__ */ factory(
   name167,
   dependencies167,
-  ({ typed: typed3, Complex: Complex12, matrix: matrix2, ceil: ceil2, floor: floor2, equalScalar: equalScalar3, zeros: zeros2, DenseMatrix: DenseMatrix6 }) => {
+  ({ typed: typed3, Complex: Complex13, matrix: matrix2, ceil: ceil2, floor: floor2, equalScalar: equalScalar3, zeros: zeros2, DenseMatrix: DenseMatrix6 }) => {
     const matAlgo12xSfs = createMatAlgo12xSfs({ typed: typed3, DenseMatrix: DenseMatrix6 });
     const matAlgo14xDs = createMatAlgo14xDs({ typed: typed3 });
     const fixNumber = createFixNumber({ typed: typed3, ceil: ceil2, floor: floor2 });
@@ -29905,20 +29905,20 @@ var createFix = /* @__PURE__ */ factory(
       number: fixNumber.signatures.number,
       "number, number | BigNumber": fixNumber.signatures["number,number"],
       Complex: function(x) {
-        return new Complex12(
+        return new Complex13(
           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 Complex12(
+        return new Complex13(
           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 Complex12(
+        return new Complex13(
           x.re > 0 ? floor2(x.re, n) : ceil2(x.re, n),
           x.im > 0 ? floor2(x.im, n) : ceil2(x.im, n)
         );
@@ -30138,9 +30138,9 @@ var createComposition = /* @__PURE__ */ factory(
 
 // src/matrix/partitionSelect.ts
 var WASM_PARTITION_SELECT_THRESHOLD = 100;
-function isFlatNumberArray4(arr8) {
-  for (let i = 0; i < arr8.length; i++) {
-    if (typeof arr8[i] !== "number") {
+function isFlatNumberArray4(arr10) {
+  for (let i = 0; i < arr10.length; i++) {
+    if (typeof arr10[i] !== "number") {
       return false;
     }
   }
@@ -30182,28 +30182,28 @@ var createPartitionSelect = /* @__PURE__ */ factory(
       }
       return quickSelect2(x, k, compare3);
     }
-    function quickSelect2(arr8, k, compare3) {
-      if (k >= arr8.length) {
+    function quickSelect2(arr10, k, compare3) {
+      if (k >= arr10.length) {
         throw new Error("k out of bounds");
       }
-      for (let i = 0; i < arr8.length; i++) {
-        if (isNumeric2(arr8[i]) && mathIsNaN(arr8[i])) {
-          return arr8[i];
+      for (let i = 0; i < arr10.length; i++) {
+        if (isNumeric2(arr10[i]) && mathIsNaN(arr10[i])) {
+          return arr10[i];
         }
       }
       const wasm = wasmLoader.getModule();
-      if (wasm && arr8.length >= WASM_PARTITION_SELECT_THRESHOLD && isFlatNumberArray4(arr8)) {
+      if (wasm && arr10.length >= WASM_PARTITION_SELECT_THRESHOLD && isFlatNumberArray4(arr10)) {
         const isAsc = compare3 === asc;
         const isDesc = compare3 === desc;
         if (isAsc || isDesc) {
           try {
-            const effectiveK = isDesc ? arr8.length - 1 - k : k;
-            const data = wasmLoader.allocateFloat64Array(arr8);
-            const work = wasmLoader.allocateFloat64ArrayEmpty(arr8.length);
+            const effectiveK = isDesc ? arr10.length - 1 - k : k;
+            const data = wasmLoader.allocateFloat64Array(arr10);
+            const work = wasmLoader.allocateFloat64ArrayEmpty(arr10.length);
             try {
-              const result = wasm.partitionSelect(data.ptr, arr8.length, effectiveK, work.ptr);
-              for (let i = 0; i < arr8.length; i++) {
-                arr8[i] = work.array[i];
+              const result = wasm.partitionSelect(data.ptr, arr10.length, effectiveK, work.ptr);
+              for (let i = 0; i < arr10.length; i++) {
+                arr10[i] = work.array[i];
               }
               return result;
             } finally {
@@ -30215,22 +30215,22 @@ var createPartitionSelect = /* @__PURE__ */ factory(
         }
       }
       let from = 0;
-      let to3 = arr8.length - 1;
+      let to3 = arr10.length - 1;
       while (from < to3) {
         let r = from;
         let w = to3;
-        const pivot = arr8[Math.floor(Math.random() * (to3 - from + 1)) + from];
+        const pivot = arr10[Math.floor(Math.random() * (to3 - from + 1)) + from];
         while (r < w) {
-          if (compare3(arr8[r], pivot) >= 0) {
-            const tmp = arr8[w];
-            arr8[w] = arr8[r];
-            arr8[r] = tmp;
+          if (compare3(arr10[r], pivot) >= 0) {
+            const tmp = arr10[w];
+            arr10[w] = arr10[r];
+            arr10[r] = tmp;
             --w;
           } else {
             ++r;
           }
         }
-        if (compare3(arr8[r], pivot) > 0) {
+        if (compare3(arr10[r], pivot) > 0) {
           --r;
         }
         if (k <= r) {
@@ -30239,7 +30239,7 @@ var createPartitionSelect = /* @__PURE__ */ factory(
           from = r + 1;
         }
       }
-      return arr8[k];
+      return arr10[k];
     }
   }
 );
@@ -30275,7 +30275,7 @@ var createPinv = /* @__PURE__ */ factory(
     divideScalar: divideScalar2,
     multiply: multiply2,
     add: add2,
-    Complex: Complex12
+    Complex: Complex13
   }) => {
     return typed3(name172, {
       "Array | Matrix": function(x) {
@@ -30370,12 +30370,12 @@ var createPinv = /* @__PURE__ */ factory(
       return { C, F };
     }
     function _isZero(x) {
-      return equal2(add2(x, Complex12(1, 1)), add2(0, Complex12(1, 1)));
+      return equal2(add2(x, Complex13(1, 1)), add2(0, Complex13(1, 1)));
     }
-    function _isZeros(arr8) {
+    function _isZeros(arr10) {
       return deepEqual3(
-        add2(arr8, Complex12(1, 1)),
-        add2(multiply2(arr8, 0), Complex12(1, 1))
+        add2(arr10, Complex13(1, 1)),
+        add2(multiply2(arr10, 0), Complex13(1, 1))
       );
     }
   }
@@ -30439,7 +30439,7 @@ var createQr = /* @__PURE__ */ factory(
     divideScalar: divideScalar2,
     multiplyScalar: multiplyScalar2,
     subtractScalar: subtractScalar2,
-    complex: complex2
+    complex: complex3
   }) => {
     const qrTyped = typed3(name173, {
       DenseMatrix: function(m) {
@@ -30563,7 +30563,7 @@ var createQr = /* @__PURE__ */ factory(
       const ret = _denseQRimpl(m);
       const Rdata = ret.R._data;
       if (m._data.length > 0) {
-        const zero = Rdata[0][0].type === "Complex" ? complex2(0) : 0;
+        const zero = Rdata[0][0].type === "Complex" ? complex3(0) : 0;
         for (let i = 0; i < Rdata.length; ++i) {
           for (let j = 0; j < i && j < (Rdata[0] || []).length; ++j) {
             Rdata[i][j] = zero;
@@ -30692,11 +30692,11 @@ var createRange = /* @__PURE__ */ factory(
         return _out(_range(start, end, step, includeEnd));
       }
     });
-    function _out(arr8) {
+    function _out(arr10) {
       if (config2.matrix === "Matrix") {
-        return matrix2 ? matrix2(arr8) : noMatrix();
+        return matrix2 ? matrix2(arr10) : noMatrix();
       }
-      return arr8;
+      return arr10;
     }
     function _strRange(str, includeEnd) {
       const r = _parse2(str);
@@ -30765,25 +30765,25 @@ var createGamma = /* @__PURE__ */ factory(
     multiplyScalar: _multiplyScalar,
     pow: _pow,
     BigNumber: BigNumber9,
-    Complex: Complex12
+    Complex: Complex13
   }) => {
     function gammaComplex(n) {
       if (n.im === 0) {
         return gammaNumber(n.re);
       }
       if (n.re < 0.5) {
-        const t2 = new Complex12(1 - n.re, -n.im);
-        const r = new Complex12(Math.PI * n.re, Math.PI * n.im);
+        const t2 = new Complex13(1 - n.re, -n.im);
+        const r = new Complex13(Math.PI * n.re, Math.PI * n.im);
         const gammaT = gammaComplex(t2);
-        return new Complex12(Math.PI).div(r.sin()).div(gammaT);
+        return new Complex13(Math.PI).div(r.sin()).div(gammaT);
       }
-      const z = new Complex12(n.re - 1, n.im);
-      let x = new Complex12(gammaP[0], 0);
+      const z = new Complex13(n.re - 1, n.im);
+      let x = new Complex13(gammaP[0], 0);
       for (let i = 1; i < gammaP.length; ++i) {
-        const gammaPval = new Complex12(gammaP[i], 0);
+        const gammaPval = new Complex13(gammaP[i], 0);
         x = x.add(gammaPval.div(z.add(i)));
       }
-      const t = new Complex12(z.re + gammaG + 0.5, z.im);
+      const t = new Complex13(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();
@@ -30993,9 +30993,9 @@ var createEqualText = /* @__PURE__ */ factory(
 
 // src/statistics/max.ts
 var WASM_MAX_THRESHOLD = 100;
-function isFlatNumberArray5(arr8) {
-  for (let i = 0; i < arr8.length; i++) {
-    if (typeof arr8[i] !== "number") {
+function isFlatNumberArray5(arr10) {
+  for (let i = 0; i < arr10.length; i++) {
+    if (typeof arr10[i] !== "number") {
       return false;
     }
   }
@@ -31072,9 +31072,9 @@ var createMax = /* @__PURE__ */ factory(
 
 // src/statistics/min.ts
 var WASM_MIN_THRESHOLD = 100;
-function isFlatNumberArray6(arr8) {
-  for (let i = 0; i < arr8.length; i++) {
-    if (typeof arr8[i] !== "number") {
+function isFlatNumberArray6(arr10) {
+  for (let i = 0; i < arr10.length; i++) {
+    if (typeof arr10[i] !== "number") {
       return false;
     }
   }
@@ -31159,8 +31159,8 @@ var createNullish = /* @__PURE__ */ factory(
     const matAlgo03xDSf = createMatAlgo03xDSf({ typed: typed3 });
     const matAlgo14xDs = createMatAlgo14xDs({ typed: typed3 });
     const matAlgo13xDD = createMatAlgo13xDD({ typed: typed3 });
-    const toMatrix = (arr8) => {
-      return matrix2(arr8);
+    const toMatrix = (arr10) => {
+      return matrix2(arr10);
     };
     return typed3(name180, {
       // Scalar and SparseMatrix-first short-circuit handlers
@@ -31472,11 +31472,11 @@ var createDistance = /* @__PURE__ */ factory(
           throw new TypeError("Invalid Arguments: Try again");
         }
       },
-      Array: function(arr8) {
-        if (!_pairwise(arr8)) {
+      Array: function(arr10) {
+        if (!_pairwise(arr10)) {
           throw new TypeError("Incorrect array format entered for pairwise distance calculation");
         }
-        return _distancePairwise(arr8);
+        return _distancePairwise(arr10);
       }
     });
     function _isNumber(a) {
@@ -31486,15 +31486,15 @@ var createDistance = /* @__PURE__ */ factory(
       if (!Array.isArray(a)) {
         a = _objectToArray(a);
       }
-      const arr8 = a;
-      return _isNumber(arr8[0]) && _isNumber(arr8[1]);
+      const arr10 = a;
+      return _isNumber(arr10[0]) && _isNumber(arr10[1]);
     }
     function _3d(a) {
       if (!Array.isArray(a)) {
         a = _objectToArray(a);
       }
-      const arr8 = a;
-      return _isNumber(arr8[0]) && _isNumber(arr8[1]) && _isNumber(arr8[2]);
+      const arr10 = a;
+      return _isNumber(arr10[0]) && _isNumber(arr10[1]) && _isNumber(arr10[2]);
     }
     function _containsOnlyNumbers(a) {
       if (!Array.isArray(a)) {
@@ -31506,8 +31506,8 @@ var createDistance = /* @__PURE__ */ factory(
       if (!Array.isArray(a)) {
         a = _objectToArray(a);
       }
-      const arr8 = a;
-      return _isNumber(arr8[0]) && _isNumber(arr8[1]) && _isNumber(arr8[2]) && _isNumber(arr8[3]) && _isNumber(arr8[4]) && _isNumber(arr8[5]);
+      const arr10 = a;
+      return _isNumber(arr10[0]) && _isNumber(arr10[1]) && _isNumber(arr10[2]) && _isNumber(arr10[3]) && _isNumber(arr10[4]) && _isNumber(arr10[5]);
     }
     function _objectToArray(o) {
       const keys = Object.keys(o);
@@ -31837,9 +31837,9 @@ var dependencies187 = ["typed", "factorial"];
 var createPermutations = /* @__PURE__ */ factory(
   name187,
   dependencies187,
-  ({ typed: typed3, factorial: factorial4 }) => {
+  ({ typed: typed3, factorial: factorial5 }) => {
     return typed3(name187, {
-      "number | BigNumber": factorial4,
+      "number | BigNumber": factorial5,
       "number, number": function(n, k) {
         if (!isInteger(n) || n < 0) {
           throw new TypeError("Positive integer value expected in function permutations");
@@ -32826,11 +32826,11 @@ var FAST_FFT_THRESHOLD = 64;
 function isPowerOf23(n) {
   return n > 0 && (n & n - 1) === 0;
 }
-function complexToInterleaved(arr8, _complex) {
-  const n = arr8.length;
+function complexToInterleaved(arr10, _complex) {
+  const n = arr10.length;
   const result = new Float64Array(n * 2);
   for (let i = 0; i < n; i++) {
-    const val = arr8[i];
+    const val = arr10[i];
     if (typeof val === "number") {
       result[i * 2] = val;
       result[i * 2 + 1] = 0;
@@ -32843,10 +32843,10 @@ function complexToInterleaved(arr8, _complex) {
   }
   return result;
 }
-function interleavedToComplex(data, n, complex2) {
+function interleavedToComplex(data, n, complex3) {
   const result = [];
   for (let i = 0; i < n; i++) {
-    result.push(complex2(data[i * 2], data[i * 2 + 1]));
+    result.push(complex3(data[i * 2], data[i * 2 + 1]));
   }
   return result;
 }
@@ -32884,7 +32884,7 @@ var createFft = /* @__PURE__ */ factory(
     pow: pow2,
     ceil: ceil2,
     log2: log23,
-    complex: complex2
+    complex: complex3
   }) => {
     return typed3(name196, {
       Array: _ndFft,
@@ -32892,40 +32892,40 @@ var createFft = /* @__PURE__ */ factory(
         return matrix2.create(_ndFft(matrix2.valueOf()), matrix2._datatype);
       }
     });
-    function _ndFft(arr8) {
-      const size2 = arraySize(arr8);
-      if (size2.length === 1) return _fft(arr8, size2[0]);
+    function _ndFft(arr10) {
+      const size2 = arraySize(arr10);
+      if (size2.length === 1) return _fft(arr10, size2[0]);
       return _1dFft(
-        arr8.map((slice) => _ndFft(slice)),
+        arr10.map((slice) => _ndFft(slice)),
         0
       );
     }
-    function _1dFft(arr8, dim) {
-      const size2 = arraySize(arr8);
+    function _1dFft(arr10, dim) {
+      const size2 = arraySize(arr10);
       if (dim !== 0) {
         const result = [];
         for (let i = 0; i < size2[0]; i++) {
-          result.push(_1dFft(arr8[i], dim - 1));
+          result.push(_1dFft(arr10[i], dim - 1));
         }
         return result;
       }
-      if (size2.length === 1) return _fft(arr8);
-      function _transpose(arr9) {
-        const size3 = arraySize(arr9);
+      if (size2.length === 1) return _fft(arr10);
+      function _transpose(arr11) {
+        const size3 = arraySize(arr11);
         const result = [];
         for (let j = 0; j < size3[1]; j++) {
           const row2 = [];
           for (let i = 0; i < size3[0]; i++) {
-            row2.push(arr9[i][j]);
+            row2.push(arr11[i][j]);
           }
           result.push(row2);
         }
         return result;
       }
-      return _transpose(_1dFft(_transpose(arr8), 1));
+      return _transpose(_1dFft(_transpose(arr10), 1));
     }
-    function _czt(arr8) {
-      const n = arr8.length;
+    function _czt(arr10) {
+      const n = arr10.length;
       const w = exp2(divideScalar2(multiplyScalar2(-1, multiplyScalar2(I2, tau2)), n));
       const chirp = [];
       for (let i = 1 - n; i < n; i++) {
@@ -32934,7 +32934,7 @@ var createFft = /* @__PURE__ */ factory(
       const N2 = pow2(2, ceil2(log23(n + n - 1)));
       const xp = [];
       for (let i = 0; i < n; i++) {
-        xp.push(multiplyScalar2(arr8[i], chirp[n - 1 + i]));
+        xp.push(multiplyScalar2(arr10[i], chirp[n - 1 + i]));
       }
       for (let i = 0; i < N2 - n; i++) {
         xp.push(0);
@@ -32959,11 +32959,11 @@ var createFft = /* @__PURE__ */ factory(
       }
       return ret;
     }
-    function _fft(arr8, len) {
-      const length = len ?? arr8.length;
-      if (length === 1) return [arr8[0]];
-      if (length === arr8.length && length >= FAST_FFT_THRESHOLD && isPowerOf23(length)) {
-        const interleaved = complexToInterleaved(arr8, complex2);
+    function _fft(arr10, len) {
+      const length = len ?? arr10.length;
+      if (length === 1) return [arr10[0]];
+      if (length === arr10.length && length >= FAST_FFT_THRESHOLD && isPowerOf23(length)) {
+        const interleaved = complexToInterleaved(arr10, complex3);
         if (interleaved) {
           const real = new Float64Array(length);
           const imag = new Float64Array(length);
@@ -32977,17 +32977,17 @@ var createFft = /* @__PURE__ */ factory(
             result[i * 2] = out.real[i];
             result[i * 2 + 1] = out.imag[i];
           }
-          return interleavedToComplex(result, length, complex2);
+          return interleavedToComplex(result, length, complex3);
         }
       }
       if (length % 2 === 0) {
         const ret = [
           ..._fft(
-            arr8.filter((_, i) => i % 2 === 0),
+            arr10.filter((_, i) => i % 2 === 0),
             length / 2
           ),
           ..._fft(
-            arr8.filter((_, i) => i % 2 === 1),
+            arr10.filter((_, i) => i % 2 === 1),
             length / 2
           )
         ];
@@ -33002,7 +33002,7 @@ var createFft = /* @__PURE__ */ factory(
         }
         return ret;
       } else {
-        return _czt(arr8);
+        return _czt(arr10);
       }
     }
   }
@@ -33273,11 +33273,11 @@ var FAST_IFFT_THRESHOLD = 64;
 function isPowerOf24(n) {
   return n > 0 && (n & n - 1) === 0;
 }
-function complexToInterleaved2(arr8, _complex) {
-  const n = arr8.length;
+function complexToInterleaved2(arr10, _complex) {
+  const n = arr10.length;
   const result = new Float64Array(n * 2);
   for (let i = 0; i < n; i++) {
-    const val = arr8[i];
+    const val = arr10[i];
     if (typeof val === "number") {
       result[i * 2] = val;
       result[i * 2 + 1] = 0;
@@ -33291,10 +33291,10 @@ function complexToInterleaved2(arr8, _complex) {
   }
   return result;
 }
-function interleavedToComplex2(data, n, complex2) {
+function interleavedToComplex2(data, n, complex3) {
   const result = [];
   for (let i = 0; i < n; i++) {
-    result.push(complex2(data[i * 2], data[i * 2 + 1]));
+    result.push(complex3(data[i * 2], data[i * 2 + 1]));
   }
   return result;
 }
@@ -33303,16 +33303,16 @@ var dependencies200 = ["typed", "fft", "dotDivide", "conj", "complex"];
 var createIfft = /* @__PURE__ */ factory(
   name200,
   dependencies200,
-  ({ typed: typed3, fft: fft2, dotDivide: dotDivide2, conj: conj3, complex: complex2 }) => {
+  ({ typed: typed3, fft: fft3, dotDivide: dotDivide2, conj: conj3, complex: complex3 }) => {
     return typed3(name200, {
-      "Array | Matrix": function(arr8) {
-        const size2 = isMatrix(arr8) ? arr8.size() : arraySize(arr8);
+      "Array | Matrix": function(arr10) {
+        const size2 = isMatrix(arr10) ? arr10.size() : arraySize(arr10);
         const totalSize = size2.reduce((acc, curr) => acc * curr, 1);
         if (size2.length === 1) {
           const length = size2[0];
           if (length >= FAST_IFFT_THRESHOLD && isPowerOf24(length)) {
-            const arrData = isMatrix(arr8) ? arr8.valueOf() : arr8;
-            const interleaved = complexToInterleaved2(arrData, complex2);
+            const arrData = isMatrix(arr10) ? arr10.valueOf() : arr10;
+            const interleaved = complexToInterleaved2(arrData, complex3);
             if (interleaved) {
               const real = new Float64Array(length);
               const imag = new Float64Array(length);
@@ -33326,15 +33326,15 @@ var createIfft = /* @__PURE__ */ factory(
                 packed[i * 2] = out.real[i];
                 packed[i * 2 + 1] = out.imag[i];
               }
-              const result = interleavedToComplex2(packed, length, complex2);
-              if (isMatrix(arr8)) {
-                return arr8.create(result);
+              const result = interleavedToComplex2(packed, length, complex3);
+              if (isMatrix(arr10)) {
+                return arr10.create(result);
               }
               return result;
             }
           }
         }
-        return dotDivide2(conj3(fft2(conj3(arr8))), totalSize);
+        return dotDivide2(conj3(fft3(conj3(arr10))), totalSize);
       }
     });
   }
@@ -34298,51 +34298,51 @@ var createDiff = /* @__PURE__ */ factory(
     number: number2
   }) => {
     return typed3(name210, {
-      "Array | Matrix": function(arr8) {
-        if (isMatrix(arr8)) {
-          return matrix2(_diff(arr8.toArray()));
+      "Array | Matrix": function(arr10) {
+        if (isMatrix(arr10)) {
+          return matrix2(_diff(arr10.toArray()));
         } else {
-          return _diff(arr8);
+          return _diff(arr10);
         }
       },
-      "Array | Matrix, number": function(arr8, dim) {
+      "Array | Matrix, number": function(arr10, dim) {
         if (!isInteger(dim)) throw new RangeError("Dimension must be a whole number");
-        if (isMatrix(arr8)) {
-          return matrix2(_recursive(arr8.toArray(), dim));
+        if (isMatrix(arr10)) {
+          return matrix2(_recursive(arr10.toArray(), dim));
         } else {
-          return _recursive(arr8, dim);
+          return _recursive(arr10, 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) => (arr8, dim) => selfAn(arr8, number2(dim))),
-      "Matrix, BigNumber": typed3.referTo("Matrix,number", (selfMn) => (arr8, dim) => selfMn(arr8, number2(dim)))
+      "Array, BigNumber": typed3.referTo("Array,number", (selfAn) => (arr10, dim) => selfAn(arr10, number2(dim))),
+      "Matrix, BigNumber": typed3.referTo("Matrix,number", (selfMn) => (arr10, dim) => selfMn(arr10, number2(dim)))
     });
-    function _recursive(arr8, dim) {
-      if (isMatrix(arr8)) {
-        arr8 = arr8.toArray();
+    function _recursive(arr10, dim) {
+      if (isMatrix(arr10)) {
+        arr10 = arr10.toArray();
       }
-      if (!Array.isArray(arr8)) {
+      if (!Array.isArray(arr10)) {
         throw RangeError("Array/Matrix does not have that many dimensions");
       }
       if (dim > 0) {
         const result = [];
-        arr8.forEach((element2) => {
+        arr10.forEach((element2) => {
           result.push(_recursive(element2, dim - 1));
         });
         return result;
       } else if (dim === 0) {
-        return _diff(arr8);
+        return _diff(arr10);
       } else {
         throw RangeError("Cannot have negative dimension");
       }
     }
-    function _diff(arr8) {
+    function _diff(arr10) {
       const result = [];
-      const size2 = arr8.length;
+      const size2 = arr10.length;
       for (let i = 1; i < size2; i++) {
-        result.push(_ElementDiff(arr8[i - 1], arr8[i]));
+        result.push(_ElementDiff(arr10[i - 1], arr10[i]));
       }
       return result;
     }
@@ -35428,21 +35428,21 @@ var createIntersect = /* @__PURE__ */ factory(
       "Array, Array, Array": _AAA,
       "Array, Array, Array, Array": _AAAA,
       "Matrix, Matrix, Matrix": function(x, y, plane) {
-        const arr8 = _AAA(
+        const arr10 = _AAA(
           x.valueOf(),
           y.valueOf(),
           plane.valueOf()
         );
-        return arr8 === null ? null : matrix2(arr8);
+        return arr10 === null ? null : matrix2(arr10);
       },
       "Matrix, Matrix, Matrix, Matrix": function(w, x, y, z) {
-        const arr8 = _AAAA(
+        const arr10 = _AAAA(
           w.valueOf(),
           x.valueOf(),
           y.valueOf(),
           z.valueOf()
         );
-        return arr8 === null ? null : matrix2(arr8);
+        return arr10 === null ? null : matrix2(arr10);
       }
     });
     function _AAA(x, y, plane) {
@@ -35508,13 +35508,13 @@ var createIntersect = /* @__PURE__ */ factory(
         throw new TypeError("Arrays with two or thee dimensional points expected");
       }
     }
-    function _coerceArr(arr8) {
-      if (arr8.length === 1 && Array.isArray(arr8[0])) return arr8[0];
-      if (arr8.length > 1 && Array.isArray(arr8[0])) {
-        if (arr8.every((el) => Array.isArray(el) && el.length === 1))
-          return flatten4(arr8);
+    function _coerceArr(arr10) {
+      if (arr10.length === 1 && Array.isArray(arr10[0])) return arr10[0];
+      if (arr10.length > 1 && Array.isArray(arr10[0])) {
+        if (arr10.every((el) => Array.isArray(el) && el.length === 1))
+          return flatten4(arr10);
       }
-      return arr8;
+      return arr10;
     }
     function _2d(x) {
       return x.length === 2 && isNumeric2(x[0]) && isNumeric2(x[1]);
@@ -35654,9 +35654,9 @@ var createIntersect = /* @__PURE__ */ factory(
 
 // src/statistics/mean.ts
 var WASM_MEAN_THRESHOLD = 100;
-function isFlatNumberArray7(arr8) {
-  for (let i = 0; i < arr8.length; i++) {
-    if (typeof arr8[i] !== "number") {
+function isFlatNumberArray7(arr10) {
+  for (let i = 0; i < arr10.length; i++) {
+    if (typeof arr10[i] !== "number") {
       return false;
     }
   }
@@ -35788,9 +35788,9 @@ var createMedian = /* @__PURE__ */ factory(
 
 // src/statistics/variance.ts
 import { sumSquaredDeviations as sumSquaredDeviations2 } from "@danielsimonjr/mathts-core";
-function isFlatNumberArray8(arr8) {
-  for (let i = 0; i < arr8.length; i++) {
-    if (typeof arr8[i] !== "number") {
+function isFlatNumberArray8(arr10) {
+  for (let i = 0; i < arr10.length; i++) {
+    if (typeof arr10[i] !== "number") {
       return false;
     }
   }
@@ -36105,7 +36105,7 @@ var dependencies224 = ["typed", "add", "divide", "multiply", "factorial", "isInt
 var createMultinomial = /* @__PURE__ */ factory(
   name224,
   dependencies224,
-  ({ typed: typed3, add: add2, divide: divide2, multiply: multiply2, factorial: factorial4, isInteger: isInteger3, isPositive: isPositive2 }) => {
+  ({ typed: typed3, add: add2, divide: divide2, multiply: multiply2, factorial: factorial5, isInteger: isInteger3, isPositive: isPositive2 }) => {
     return typed3(name224, {
       "Array | Matrix": function(a) {
         let sum3 = 0;
@@ -36115,9 +36115,9 @@ var createMultinomial = /* @__PURE__ */ factory(
             throw new TypeError("Positive integer value expected in function multinomial");
           }
           sum3 = add2(sum3, ai);
-          denom = multiply2(denom, factorial4(ai));
+          denom = multiply2(denom, factorial5(ai));
         });
-        return divide2(factorial4(sum3), denom);
+        return divide2(factorial5(sum3), denom);
       }
     });
   }
@@ -36130,7 +36130,7 @@ var dependencies225 = ["typed", "add", "multiply", "Complex", "divide", "matrix"
 var createFreqz = /* @__PURE__ */ factory(
   name225,
   dependencies225,
-  ({ typed: typed3, add: add2, multiply: multiply2, Complex: Complex12, divide: divide2, matrix: matrix2 }) => {
+  ({ typed: typed3, add: add2, multiply: multiply2, Complex: Complex13, divide: divide2, matrix: matrix2 }) => {
     return typed3(name225, {
       "Array, Array": function(b, a) {
         const w = createBins(512);
@@ -36199,7 +36199,7 @@ var createFreqz = /* @__PURE__ */ factory(
           );
           const h = [];
           for (let i = 0; i < w.length; i++) {
-            h.push(Complex12(hRealAlloc.array[i], hImagAlloc.array[i]));
+            h.push(Complex13(hRealAlloc.array[i], hImagAlloc.array[i]));
           }
           return { h, w };
         } finally {
@@ -36221,18 +36221,18 @@ var createFreqz = /* @__PURE__ */ factory(
       const num2 = [];
       const den = [];
       for (let i = 0; i < w.length; i++) {
-        let sumNum = Complex12(0, 0);
-        let sumDen = Complex12(0, 0);
+        let sumNum = Complex13(0, 0);
+        let sumDen = Complex13(0, 0);
         for (let j = 0; j < b.length; j++) {
           sumNum = add2(
             sumNum,
-            multiply2(b[j], Complex12(Math.cos(-j * w[i]), Math.sin(-j * w[i])))
+            multiply2(b[j], Complex13(Math.cos(-j * w[i]), Math.sin(-j * w[i])))
           );
         }
         for (let j = 0; j < a.length; j++) {
           sumDen = add2(
             sumDen,
-            multiply2(a[j], Complex12(Math.cos(-j * w[i]), Math.sin(-j * w[i])))
+            multiply2(a[j], Complex13(Math.cos(-j * w[i]), Math.sin(-j * w[i])))
           );
         }
         num2.push(sumNum);
@@ -37174,7 +37174,7 @@ var createZeta = /* @__PURE__ */ factory(
     multiply: multiply2,
     pow: pow2,
     divide: divide2,
-    factorial: factorial4,
+    factorial: factorial5,
     equal: equal2,
     smallerEq: smallerEq2,
     isBounded: isBounded2,
@@ -37183,7 +37183,7 @@ var createZeta = /* @__PURE__ */ factory(
     sin: sin2,
     subtract: subtract2,
     add: add2,
-    Complex: Complex12,
+    Complex: Complex13,
     BigNumber: BigNumber9,
     pi
   }) => {
@@ -37219,16 +37219,16 @@ var createZeta = /* @__PURE__ */ factory(
     }
     function zetaComplex(s) {
       if (s.re === 0 && s.im === 0) {
-        return new Complex12(-0.5);
+        return new Complex13(-0.5);
       }
       if (s.re === 1 && s.im === 0) {
-        return new Complex12(NaN, NaN);
+        return new Complex13(NaN, NaN);
       }
       if (s.re === Infinity && s.im === 0) {
-        return new Complex12(1);
+        return new Complex13(1);
       }
       if (s.im === Infinity || s.re === -Infinity) {
-        return new Complex12(NaN, NaN);
+        return new Complex13(NaN, NaN);
       }
       return zeta2(
         s,
@@ -37252,8 +37252,8 @@ var createZeta = /* @__PURE__ */ factory(
       let S = k;
       for (let j = k; smallerEq2(j, n); j = add2(j, 1)) {
         const factor2 = divide2(
-          multiply2(factorial4(add2(n, subtract2(j, 1))), pow2(4, j)),
-          multiply2(factorial4(subtract2(n, j)), factorial4(multiply2(2, j)))
+          multiply2(factorial5(add2(n, subtract2(j, 1))), pow2(4, j)),
+          multiply2(factorial5(subtract2(n, j)), factorial5(multiply2(2, j)))
         );
         S = add2(S, factor2);
       }
@@ -37325,18 +37325,18 @@ function createComplexEigs({
   usolve: usolve2,
   usolveAll: usolveAll2,
   equal: equal2,
-  complex: complex2,
+  complex: complex3,
   larger: larger2,
   smaller: smaller2,
   matrixFromColumns: _matrixFromColumns,
   dot: dot5
 }) {
-  function complexEigs(arr8, N, prec, type, findVectors = true) {
+  function complexEigs(arr10, N, prec, type, findVectors = true) {
     if (!findVectors && type === "number" && N * N >= WASM_EIGS_THRESHOLD) {
       const wasm = wasmLoader.getModule();
       if (wasm) {
         try {
-          const flat = flattenToFloat648(arr8, N, N);
+          const flat = flattenToFloat648(arr10, N, N);
           const matrixAlloc = wasmLoader.allocateFloat64Array(flat);
           const eigenvaluesRealAlloc = wasmLoader.allocateFloat64ArrayEmpty(N);
           const eigenvaluesImagAlloc = wasmLoader.allocateFloat64ArrayEmpty(N);
@@ -37360,7 +37360,7 @@ function createComplexEigs({
                 if (Math.abs(im3) < 1e-14) {
                   values2.push(re3);
                 } else {
-                  values2.push(complex2(re3, im3));
+                  values2.push(complex3(re3, im3));
                 }
               }
               values2.sort((a, b) => {
@@ -37380,20 +37380,20 @@ function createComplexEigs({
         }
       }
     }
-    const R = balance(arr8, N, prec, type, findVectors);
-    reduceToHessenberg(arr8, N, prec, type, findVectors, R);
-    const { values, C } = iterateUntilTriangular(arr8, N, prec, type, findVectors);
+    const R = balance(arr10, N, prec, type, findVectors);
+    reduceToHessenberg(arr10, N, prec, type, findVectors, R);
+    const { values, C } = iterateUntilTriangular(arr10, N, prec, type, findVectors);
     if (findVectors) {
-      const eigenvectors = findEigenvectors(arr8, N, C, R, values, prec, type);
+      const eigenvectors = findEigenvectors(arr10, N, C, R, values, prec, type);
       return { values, eigenvectors };
     }
     return { values };
   }
-  function balance(arr8, N, _prec, type, findVectors) {
+  function balance(arr10, N, _prec, type, findVectors) {
     const big = type === "BigNumber";
     const cplx = type === "Complex";
     const realzero = big ? bignumber2(0) : 0;
-    const one = big ? bignumber2(1) : cplx ? complex2(1) : 1;
+    const one = big ? bignumber2(1) : cplx ? complex3(1) : 1;
     const realone = big ? bignumber2(1) : 1;
     const radix = big ? bignumber2(10) : 2;
     const radixSq = multiplyScalar2(radix, radix);
@@ -37409,8 +37409,8 @@ function createComplexEigs({
         let rowNorm = realzero;
         for (let j = 0; j < N; j++) {
           if (i === j) continue;
-          colNorm = addScalar2(colNorm, abs2(arr8[j][i]));
-          rowNorm = addScalar2(rowNorm, abs2(arr8[i][j]));
+          colNorm = addScalar2(colNorm, abs2(arr10[j][i]));
+          rowNorm = addScalar2(rowNorm, abs2(arr10[i][j]));
         }
         if (!equal2(colNorm, 0) && !equal2(rowNorm, 0)) {
           let f = realone;
@@ -37436,8 +37436,8 @@ function createComplexEigs({
               if (i === j) {
                 continue;
               }
-              arr8[i][j] = multiplyScalar2(arr8[i][j], g);
-              arr8[j][i] = multiplyScalar2(arr8[j][i], f);
+              arr10[i][j] = multiplyScalar2(arr10[i][j], g);
+              arr10[j][i] = multiplyScalar2(arr10[j][i], f);
             }
             if (findVectors) {
               Rdiag[i] = multiplyScalar2(Rdiag[i], g);
@@ -37448,10 +37448,10 @@ function createComplexEigs({
     }
     return findVectors ? diag2(Rdiag) : null;
   }
-  function reduceToHessenberg(arr8, N, prec, type, findVectors, R) {
+  function reduceToHessenberg(arr10, N, prec, type, findVectors, R) {
     const big = type === "BigNumber";
     const cplx = type === "Complex";
-    const zero = big ? bignumber2(0) : cplx ? complex2(0) : 0;
+    const zero = big ? bignumber2(0) : cplx ? complex3(0) : 0;
     if (big) {
       prec = bignumber2(prec);
     }
@@ -37459,7 +37459,7 @@ function createComplexEigs({
       let maxIndex = 0;
       let max2 = zero;
       for (let j = i + 1; j < N; j++) {
-        const el = arr8[j][i];
+        const el = arr10[j][i];
         if (smaller2(abs2(max2), abs2(el))) {
           max2 = el;
           maxIndex = j;
@@ -37469,13 +37469,13 @@ function createComplexEigs({
         continue;
       }
       if (maxIndex !== i + 1) {
-        const tmp1 = arr8[maxIndex];
-        arr8[maxIndex] = arr8[i + 1];
-        arr8[i + 1] = tmp1;
+        const tmp1 = arr10[maxIndex];
+        arr10[maxIndex] = arr10[i + 1];
+        arr10[i + 1] = tmp1;
         for (let j = 0; j < N; j++) {
-          const tmp2 = arr8[j][maxIndex];
-          arr8[j][maxIndex] = arr8[j][i + 1];
-          arr8[j][i + 1] = tmp2;
+          const tmp2 = arr10[j][maxIndex];
+          arr10[j][maxIndex] = arr10[j][i + 1];
+          arr10[j][i + 1] = tmp2;
         }
         if (findVectors) {
           const tmp3 = R[maxIndex];
@@ -37484,15 +37484,15 @@ function createComplexEigs({
         }
       }
       for (let j = i + 2; j < N; j++) {
-        const n = divideScalar2(arr8[j][i], max2);
+        const n = divideScalar2(arr10[j][i], max2);
         if (n === 0) {
           continue;
         }
         for (let k = 0; k < N; k++) {
-          arr8[j][k] = subtract2(arr8[j][k], multiplyScalar2(n, arr8[i + 1][k]));
+          arr10[j][k] = subtract2(arr10[j][k], multiplyScalar2(n, arr10[i + 1][k]));
         }
         for (let k = 0; k < N; k++) {
-          arr8[k][i + 1] = addScalar2(arr8[k][i + 1], multiplyScalar2(n, arr8[k][j]));
+          arr10[k][i + 1] = addScalar2(arr10[k][i + 1], multiplyScalar2(n, arr10[k][j]));
         }
         if (findVectors) {
           for (let k = 0; k < N; k++) {
@@ -37505,11 +37505,11 @@ function createComplexEigs({
   function iterateUntilTriangular(A, N, prec, type, findVectors) {
     const big = type === "BigNumber";
     const cplx = type === "Complex";
-    const one = big ? bignumber2(1) : cplx ? complex2(1) : 1;
+    const one = big ? bignumber2(1) : cplx ? complex3(1) : 1;
     if (big) {
       prec = bignumber2(prec);
     }
-    let arr8 = clone(A);
+    let arr10 = clone(A);
     const lambdas = [];
     let n = N;
     const Sdiag = [];
@@ -37518,21 +37518,21 @@ function createComplexEigs({
     let lastConvergenceBefore = 0;
     while (lastConvergenceBefore <= 100) {
       lastConvergenceBefore += 1;
-      const k = arr8[n - 1][n - 1];
+      const k = arr10[n - 1][n - 1];
       for (let i = 0; i < n; i++) {
-        arr8[i][i] = subtract2(arr8[i][i], k);
+        arr10[i][i] = subtract2(arr10[i][i], k);
       }
-      const { Q: Q2, R } = qr2(arr8);
-      arr8 = multiply2(R, Q2);
+      const { Q: Q2, R } = qr2(arr10);
+      arr10 = multiply2(R, Q2);
       for (let i = 0; i < n; i++) {
-        arr8[i][i] = addScalar2(arr8[i][i], k);
+        arr10[i][i] = addScalar2(arr10[i][i], k);
       }
       if (findVectors) {
         Qpartial = multiply2(Qpartial, Q2);
       }
-      if (n === 1 || smaller2(abs2(arr8[n - 1][n - 2]), prec)) {
+      if (n === 1 || smaller2(abs2(arr10[n - 1][n - 2]), prec)) {
         lastConvergenceBefore = 0;
-        lambdas.push(arr8[n - 1][n - 1]);
+        lambdas.push(arr10[n - 1][n - 1]);
         if (findVectors) {
           Sdiag.unshift([[1]]);
           inflateMatrix(Qpartial, N);
@@ -37542,26 +37542,26 @@ function createComplexEigs({
           }
         }
         n -= 1;
-        arr8.pop();
+        arr10.pop();
         for (let i = 0; i < n; i++) {
-          arr8[i].pop();
+          arr10[i].pop();
         }
-      } else if (n === 2 || smaller2(abs2(arr8[n - 2][n - 3]), prec)) {
+      } else if (n === 2 || smaller2(abs2(arr10[n - 2][n - 3]), prec)) {
         lastConvergenceBefore = 0;
         const ll = eigenvalues2x2(
-          arr8[n - 2][n - 2],
-          arr8[n - 2][n - 1],
-          arr8[n - 1][n - 2],
-          arr8[n - 1][n - 1]
+          arr10[n - 2][n - 2],
+          arr10[n - 2][n - 1],
+          arr10[n - 1][n - 2],
+          arr10[n - 1][n - 1]
         );
         lambdas.push(...ll);
         if (findVectors) {
           Sdiag.unshift(
             jordanBase2x2(
-              arr8[n - 2][n - 2],
-              arr8[n - 2][n - 1],
-              arr8[n - 1][n - 2],
-              arr8[n - 1][n - 1],
+              arr10[n - 2][n - 2],
+              arr10[n - 2][n - 1],
+              arr10[n - 1][n - 2],
+              arr10[n - 1][n - 1],
               ll[0],
               ll[1],
               prec,
@@ -37575,11 +37575,11 @@ function createComplexEigs({
           }
         }
         n -= 2;
-        arr8.pop();
-        arr8.pop();
+        arr10.pop();
+        arr10.pop();
         for (let i = 0; i < n; i++) {
-          arr8[i].pop();
-          arr8[i].pop();
+          arr10[i].pop();
+          arr10[i].pop();
         }
       }
       if (n === 0) {
@@ -37603,8 +37603,8 @@ function createComplexEigs({
     const U = multiply2(multiply2(Cinv, A), C);
     const big = type === "BigNumber";
     const cplx = type === "Complex";
-    const zero = big ? bignumber2(0) : cplx ? complex2(0) : 0;
-    const one = big ? bignumber2(1) : cplx ? complex2(1) : 1;
+    const zero = big ? bignumber2(0) : cplx ? complex3(0) : 0;
+    const one = big ? bignumber2(1) : cplx ? complex3(1) : 1;
     const uniqueValues = [];
     const multiplicities = [];
     for (const lambda of values) {
@@ -37656,8 +37656,8 @@ function createComplexEigs({
   function jordanBase2x2(a, b, c, d, l1, l2, prec, type) {
     const big = type === "BigNumber";
     const cplx = type === "Complex";
-    const zero = big ? bignumber2(0) : cplx ? complex2(0) : 0;
-    const one = big ? bignumber2(1) : cplx ? complex2(1) : 1;
+    const zero = big ? bignumber2(0) : cplx ? complex3(0) : 0;
+    const one = big ? bignumber2(1) : cplx ? complex3(1) : 1;
     if (smaller2(abs2(c), prec)) {
       return [
         [one, zero],
@@ -37684,23 +37684,23 @@ function createComplexEigs({
       ];
     }
   }
-  function inflateMatrix(arr8, N) {
-    for (let i = 0; i < arr8.length; i++) {
-      arr8[i].push(...Array(N - arr8[i].length).fill(0));
+  function inflateMatrix(arr10, N) {
+    for (let i = 0; i < arr10.length; i++) {
+      arr10[i].push(...Array(N - arr10[i].length).fill(0));
     }
-    for (let i = arr8.length; i < N; i++) {
-      arr8.push(Array(N).fill(0));
-      arr8[i][i] = 1;
+    for (let i = arr10.length; i < N; i++) {
+      arr10.push(Array(N).fill(0));
+      arr10[i][i] = 1;
     }
-    return arr8;
+    return arr10;
   }
-  function blockDiag(arr8, N) {
+  function blockDiag(arr10, N) {
     const M = [];
     for (let i = 0; i < N; i++) {
       M[i] = Array(N).fill(0);
     }
     let I2 = 0;
-    for (const sub of arr8) {
+    for (const sub of arr10) {
       const n = sub.length;
       for (let i = 0; i < n; i++) {
         for (let j = 0; j < n; j++) {
@@ -37711,9 +37711,9 @@ function createComplexEigs({
     }
     return M;
   }
-  function indexOf(arr8, el, fn) {
-    for (let i = 0; i < arr8.length; i++) {
-      if (fn(arr8[i], el)) {
+  function indexOf(arr10, el, fn) {
+    for (let i = 0; i < arr10.length; i++) {
+      if (fn(arr10[i], el)) {
         return i;
       }
     }
@@ -37758,7 +37758,7 @@ function createComplexEigs({
       v = v.map((n) => bignumber2(n));
     }
     if (cplx) {
-      v = v.map((n) => complex2(n));
+      v = v.map((n) => complex3(n));
     }
     v = orthogonalComplement(v, orthog);
     return normalize2(v, type);
@@ -37783,7 +37783,7 @@ function createComplexEigs({
   function normalize2(v, type) {
     const big = type === "BigNumber";
     const cplx = type === "Complex";
-    const one = big ? bignumber2(1) : cplx ? complex2(1) : 1;
+    const one = big ? bignumber2(1) : cplx ? complex3(1) : 1;
     return multiply2(divideScalar2(one, norm4(v)), v);
   }
   return complexEigs;
@@ -37826,12 +37826,12 @@ function createRealSymmetric({
     if (typeof a === "number" && typeof b === "number") return a <= b;
     return a.lte(b);
   }
-  function main(arr8, _N, prec = config2.relTol, type, computeVectors) {
+  function main(arr10, _N, prec = config2.relTol, type, computeVectors) {
     if (type === "number") {
-      return diag2(arr8, prec, computeVectors);
+      return diag2(arr10, prec, computeVectors);
     }
     if (type === "BigNumber") {
-      return diagBig(arr8, prec, computeVectors);
+      return diagBig(arr10, prec, computeVectors);
     }
     throw TypeError("Unsupported data type: " + type);
   }
@@ -38186,7 +38186,7 @@ var createEigs = /* @__PURE__ */ factory(
     column: _column,
     flatten: flatten4,
     number: number2,
-    complex: complex2,
+    complex: complex3,
     sqrt: sqrt2,
     diag: diag2,
     size: size2,
@@ -38211,7 +38211,7 @@ var createEigs = /* @__PURE__ */ factory(
       multiplyScalar: multiplyScalar2,
       inv: inv2,
       bignumber: bignumber2,
-      complex: complex2,
+      complex: complex3,
       multiply: multiply2,
       add: add2
     });
@@ -38233,7 +38233,7 @@ var createEigs = /* @__PURE__ */ factory(
       usolve: usolve2,
       usolveAll: usolveAll2,
       equal: equal2,
-      complex: complex2,
+      complex: complex3,
       larger: larger2,
       smaller: smaller2,
       matrixFromColumns: matrixFromColumns2,
@@ -38293,18 +38293,18 @@ var createEigs = /* @__PURE__ */ factory(
       return result;
     }
     function computeValuesAndVectors(mat, prec, computeVectors) {
-      const arr8 = mat.toArray();
+      const arr10 = 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(arr8, N, prec)) {
-        coerceReal(arr8, N);
-        if (isSymmetric(arr8, N, prec)) {
-          const type2 = coerceTypes(mat, arr8, N);
+      if (isReal(arr10, N, prec)) {
+        coerceReal(arr10, N);
+        if (isSymmetric(arr10, N, prec)) {
+          const type2 = coerceTypes(mat, arr10, N);
           return doRealSymmetric(
-            arr8,
+            arr10,
             N,
             prec,
             type2,
@@ -38312,37 +38312,37 @@ var createEigs = /* @__PURE__ */ factory(
           );
         }
       }
-      const type = coerceTypes(mat, arr8, N);
-      return doComplexEigs(arr8, N, prec, type, computeVectors);
+      const type = coerceTypes(mat, arr10, N);
+      return doComplexEigs(arr10, N, prec, type, computeVectors);
     }
-    function isSymmetric(arr8, N, prec) {
+    function isSymmetric(arr10, N, prec) {
       for (let i = 0; i < N; i++) {
         for (let j = i; j < N; j++) {
-          if (larger2(bignumber2(abs2(subtract2(arr8[i][j], arr8[j][i]))), prec)) {
+          if (larger2(bignumber2(abs2(subtract2(arr10[i][j], arr10[j][i]))), prec)) {
             return false;
           }
         }
       }
       return true;
     }
-    function isReal(arr8, N, prec) {
+    function isReal(arr10, N, prec) {
       for (let i = 0; i < N; i++) {
         for (let j = 0; j < N; j++) {
-          if (larger2(bignumber2(abs2(im3(arr8[i][j]))), prec)) {
+          if (larger2(bignumber2(abs2(im3(arr10[i][j]))), prec)) {
             return false;
           }
         }
       }
       return true;
     }
-    function coerceReal(arr8, N) {
+    function coerceReal(arr10, N) {
       for (let i = 0; i < N; i++) {
         for (let j = 0; j < N; j++) {
-          arr8[i][j] = re3(arr8[i][j]);
+          arr10[i][j] = re3(arr10[i][j]);
         }
       }
     }
-    function coerceTypes(mat, arr8, N) {
+    function coerceTypes(mat, arr10, N) {
       const type = mat.datatype();
       if (type === "number" || type === "BigNumber" || type === "Complex") {
         return type;
@@ -38352,7 +38352,7 @@ var createEigs = /* @__PURE__ */ factory(
       let hasComplex = false;
       for (let i = 0; i < N; i++) {
         for (let j = 0; j < N; j++) {
-          const el = arr8[i][j];
+          const el = arr10[i][j];
           if (isNumber(el) || isFraction(el)) {
             hasNumber = true;
           } else if (isBigNumber(el)) {
@@ -38370,7 +38370,7 @@ var createEigs = /* @__PURE__ */ factory(
       if (hasComplex) {
         for (let i = 0; i < N; i++) {
           for (let j = 0; j < N; j++) {
-            arr8[i][j] = complex2(arr8[i][j]);
+            arr10[i][j] = complex3(arr10[i][j]);
           }
         }
         return "Complex";
@@ -38378,7 +38378,7 @@ var createEigs = /* @__PURE__ */ factory(
       if (hasBig) {
         for (let i = 0; i < N; i++) {
           for (let j = 0; j < N; j++) {
-            arr8[i][j] = bignumber2(arr8[i][j]);
+            arr10[i][j] = bignumber2(arr10[i][j]);
           }
         }
         return "BigNumber";
@@ -38386,7 +38386,7 @@ var createEigs = /* @__PURE__ */ factory(
       if (hasNumber) {
         for (let i = 0; i < N; i++) {
           for (let j = 0; j < N; j++) {
-            arr8[i][j] = number2(arr8[i][j]);
+            arr10[i][j] = number2(arr10[i][j]);
           }
         }
         return "number";
@@ -38604,9 +38604,9 @@ var createLusolve = /* @__PURE__ */ factory(
 
 // src/statistics/corr.ts
 import { pairwiseSum as pairwiseSum3, pairwiseDot as pairwiseDot3 } from "@danielsimonjr/mathts-core";
-function isPlainNumberArray(arr8) {
-  for (let i = 0; i < arr8.length; i++) {
-    if (typeof arr8[i] !== "number") {
+function isPlainNumberArray(arr10) {
+  for (let i = 0; i < arr10.length; i++) {
+    if (typeof arr10[i] !== "number") {
       return false;
     }
   }
@@ -38681,9 +38681,9 @@ var createCorr = /* @__PURE__ */ factory(
 
 // src/statistics/mad.ts
 var WASM_MAD_THRESHOLD = 500;
-function isPlainNumberArray2(arr8) {
-  for (let i = 0; i < arr8.length; i++) {
-    if (typeof arr8[i] !== "number") {
+function isPlainNumberArray2(arr10) {
+  for (let i = 0; i < arr10.length; i++) {
+    if (typeof arr10[i] !== "number") {
       return false;
     }
   }
@@ -40280,12 +40280,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 arr8 = x.toArray();
-      const n = arr8.length;
+      const arr10 = x.toArray();
+      const n = arr10.length;
       const data = new Float64Array(n);
       for (let i = 0; i < n; i++) {
-        if (typeof arr8[i] !== "number") return null;
-        data[i] = arr8[i];
+        if (typeof arr10[i] !== "number") return null;
+        data[i] = arr10[i];
       }
       const alloc = wasmLoader.allocateFloat64Array(data);
       try {
@@ -44400,6 +44400,262 @@ function help(search) {
   return new Help(doc);
 }
 
+// src/numbertheory/extra.ts
+function continuedFraction(x, maxTerms = 20) {
+  if (!Number.isFinite(x)) {
+    throw new Error("continuedFraction requires a finite number");
+  }
+  const terms = [];
+  let r = x;
+  for (let i = 0; i < maxTerms; i++) {
+    const a = Math.floor(r);
+    terms.push(a);
+    const frac = r - a;
+    if (frac < 1e-12) break;
+    r = 1 / frac;
+  }
+  return terms;
+}
+function binomialExact(n, k) {
+  if (k < 0 || k > n) return 0;
+  const kk = Math.min(k, n - k);
+  let result = 1;
+  for (let i = 0; i < kk; i++) {
+    result = result * (n - i) / (i + 1);
+  }
+  return Math.round(result);
+}
+function eulerNumbers(n) {
+  if (!Number.isInteger(n) || n < 0) {
+    throw new Error("eulerNumbers requires a non-negative integer");
+  }
+  const E = new Array(n + 1).fill(0);
+  E[0] = 1;
+  for (let m = 1; m <= n; m++) {
+    if (m % 2 === 1) {
+      E[m] = 0;
+      continue;
+    }
+    let sum3 = 0;
+    for (let k = 0; k < m / 2; k++) {
+      sum3 += binomialExact(m, 2 * k) * E[2 * k];
+    }
+    E[m] = -sum3;
+  }
+  return E;
+}
+function stirlingS1(n, k) {
+  if (!Number.isInteger(n) || !Number.isInteger(k) || n < 0 || k < 0) {
+    throw new Error("stirlingS1 requires non-negative integers");
+  }
+  if (k > n) return 0;
+  const s = Array.from({ length: n + 1 }, () => new Array(n + 1).fill(0));
+  s[0][0] = 1;
+  for (let i = 1; i <= n; i++) {
+    for (let j = 0; j <= i; j++) {
+      const prevDiag = j > 0 ? s[i - 1][j - 1] : 0;
+      const prevSame = s[i - 1][j];
+      s[i][j] = prevDiag - (i - 1) * prevSame;
+    }
+  }
+  return s[n][k];
+}
+function modPowBig(base, exp2, mod2) {
+  let b = (base % mod2 + mod2) % mod2;
+  let e = exp2;
+  let result = 1n;
+  while (e > 0n) {
+    if (e & 1n) result = result * b % mod2;
+    b = b * b % mod2;
+    e >>= 1n;
+  }
+  return result;
+}
+function modInverseBig(a, mod2) {
+  let oldR = a;
+  let r = mod2;
+  let oldS = 1n;
+  let s = 0n;
+  while (r !== 0n) {
+    const q = oldR / r;
+    [oldR, r] = [r, oldR - q * r];
+    [oldS, s] = [s, oldS - q * s];
+  }
+  return (oldS % mod2 + mod2) % mod2;
+}
+function discreteLog(g, h, p) {
+  if (!Number.isInteger(g) || !Number.isInteger(h) || !Number.isInteger(p) || p < 2) {
+    throw new Error("discreteLog requires integer g, h and a modulus p >= 2");
+  }
+  const P2 = BigInt(p);
+  const G = (BigInt(g) % P2 + P2) % P2;
+  const H = (BigInt(h) % P2 + P2) % P2;
+  const m = BigInt(Math.max(1, Math.ceil(Math.sqrt(p - 1))));
+  const table = /* @__PURE__ */ new Map();
+  let cur = 1n;
+  for (let j = 0n; j < m; j++) {
+    const key = cur.toString();
+    if (!table.has(key)) table.set(key, j);
+    cur = cur * G % P2;
+  }
+  const gm = modPowBig(G, m, P2);
+  const gInvM = modInverseBig(gm, P2);
+  let gamma2 = H;
+  for (let i = 0n; i < m; i++) {
+    const key = gamma2.toString();
+    const j = table.get(key);
+    if (j !== void 0) {
+      return Number(i * m + j);
+    }
+    gamma2 = gamma2 * gInvM % P2;
+  }
+  return -1;
+}
+function distinctPrimeFactors(nIn) {
+  let n = nIn;
+  const primes = [];
+  for (let d = 2; d * d <= n; d++) {
+    if (n % d === 0) {
+      primes.push(d);
+      while (n % d === 0) n /= d;
+    }
+  }
+  if (n > 1) primes.push(n);
+  return primes;
+}
+function primitiveRoot(p) {
+  if (!Number.isInteger(p) || p < 2) {
+    throw new Error("primitiveRoot requires an integer p >= 2");
+  }
+  if (p === 2) return 1;
+  const phi = p - 1;
+  const phiFactors = distinctPrimeFactors(phi);
+  const P2 = BigInt(p);
+  for (let g = 2; g < p; g++) {
+    let isRoot = true;
+    for (const q of phiFactors) {
+      if (modPowBig(BigInt(g), BigInt(phi / q), P2) === 1n) {
+        isRoot = false;
+        break;
+      }
+    }
+    if (isRoot) return g;
+  }
+  throw new Error("primitiveRoot: no primitive root found (p may not be prime)");
+}
+function gcdInt(aIn, bIn) {
+  let a = Math.abs(aIn);
+  let b = Math.abs(bIn);
+  while (b !== 0) {
+    [a, b] = [b, a % b];
+  }
+  return a;
+}
+function multiplicativeOrder(a, n) {
+  if (!Number.isInteger(a) || !Number.isInteger(n) || n < 1) {
+    throw new Error("multiplicativeOrder requires integers with modulus n >= 1");
+  }
+  const amod = (a % n + n) % n;
+  if (gcdInt(amod, n) !== 1) return -1;
+  if (n === 1) return 1;
+  let cur = amod;
+  let k = 1;
+  while (cur !== 1) {
+    cur = cur * amod % n;
+    k++;
+  }
+  return k;
+}
+function kroneckerTwo(a) {
+  if (a % 2 === 0) return 0;
+  const r = (a % 8 + 8) % 8;
+  return r === 1 || r === 7 ? 1 : -1;
+}
+function kroneckerSymbol(a, n) {
+  if (!Number.isInteger(a) || !Number.isInteger(n)) {
+    throw new Error("kroneckerSymbol requires integers");
+  }
+  if (n === 0) {
+    return Math.abs(a) === 1 ? 1 : 0;
+  }
+  let sign3 = 1;
+  let nn = n;
+  if (nn < 0) {
+    nn = -nn;
+    if (a < 0) sign3 = -1;
+  }
+  let v = 0;
+  while (nn % 2 === 0) {
+    nn /= 2;
+    v++;
+  }
+  if (v > 0) {
+    const k2 = kroneckerTwo(a);
+    if (k2 === 0) return 0;
+    sign3 *= Math.pow(k2, v);
+  }
+  if (nn === 1) return sign3;
+  let aa = (a % nn + nn) % nn;
+  let N = nn;
+  let jac = 1;
+  while (aa !== 0) {
+    while (aa % 2 === 0) {
+      aa /= 2;
+      if (N % 8 === 3 || N % 8 === 5) jac = -jac;
+    }
+    [aa, N] = [N, aa];
+    if (aa % 4 === 3 && N % 4 === 3) jac = -jac;
+    aa = aa % N;
+  }
+  return sign3 * (N === 1 ? jac : 0);
+}
+function combinationsGen(arr10, k) {
+  const n = arr10.length;
+  if (!Number.isInteger(k) || k < 0 || k > n) {
+    throw new Error("combinationsGen: k must be an integer in [0, arr.length]");
+  }
+  const result = [];
+  const combo = [];
+  function backtrack(start) {
+    if (combo.length === k) {
+      result.push(combo.slice());
+      return;
+    }
+    for (let i = start; i < n; i++) {
+      combo.push(arr10[i]);
+      backtrack(i + 1);
+      combo.pop();
+    }
+  }
+  backtrack(0);
+  return result;
+}
+function permutationsGen(arr10, k = arr10.length) {
+  const n = arr10.length;
+  if (!Number.isInteger(k) || k < 0 || k > n) {
+    throw new Error("permutationsGen: k must be an integer in [0, arr.length]");
+  }
+  const result = [];
+  const used = new Array(n).fill(false);
+  const perm = [];
+  function backtrack() {
+    if (perm.length === k) {
+      result.push(perm.slice());
+      return;
+    }
+    for (let i = 0; i < n; i++) {
+      if (used[i]) continue;
+      used[i] = true;
+      perm.push(arr10[i]);
+      backtrack();
+      perm.pop();
+      used[i] = false;
+    }
+  }
+  backtrack();
+  return result;
+}
+
 // src/grad-forward.ts
 import { Dual as Dual3 } from "@danielsimonjr/mathts-core";
 function derivativeAt(fn, x0) {
@@ -44587,9 +44843,9 @@ function kendallTau(x, y) {
     }
   }
   const n0 = n * (n - 1) / 2;
-  const tiePairs = (arr8) => {
+  const tiePairs = (arr10) => {
     const counts = /* @__PURE__ */ new Map();
-    for (const v of arr8) counts.set(v, (counts.get(v) ?? 0) + 1);
+    for (const v of arr10) counts.set(v, (counts.get(v) ?? 0) + 1);
     let s = 0;
     for (const c of counts.values()) s += c * (c - 1) / 2;
     return s;
@@ -46901,7 +47157,9 @@ function lfilterZi(b, a) {
   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");
+    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)))
@@ -46922,15 +47180,26 @@ function filtfilt(b, a, x) {
   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 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();
+  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);
+var cScale = (p, s) => cMul(p, new Complex11(s, 0));
 function polyFromRoots(roots) {
   let c = [new Complex11(1, 0)];
   for (const r of roots) {
@@ -46943,29 +47212,1167 @@ function polyFromRoots(roots) {
   }
   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 = [];
+function relativeDegree(z, p) {
+  const degree2 = p.length - z.length;
+  if (degree2 < 0) throw new Error("Improper transfer function: fewer poles than zeros");
+  return degree2;
+}
+function lp2lpZpk(z, p, k, wo) {
+  const degree2 = relativeDegree(z, p);
+  return {
+    z: z.map((zv) => cScale(zv, wo)),
+    p: p.map((pv) => cScale(pv, wo)),
+    k: k * Math.pow(wo, degree2)
+  };
+}
+function lp2hpZpk(z, p, k, wo) {
+  const degree2 = relativeDegree(z, p);
+  const woC = new Complex11(wo, 0);
+  const zHp = z.map((zv) => cDiv(woC, zv));
+  for (let i = 0; i < degree2; i++) zHp.push(new Complex11(0, 0));
+  let prodZ = new Complex11(1, 0);
+  for (const zv of z) prodZ = cMul(prodZ, zv.negate());
+  let prodP = new Complex11(1, 0);
+  for (const pv of p) prodP = cMul(prodP, pv.negate());
+  return { z: zHp, p: p.map((pv) => cDiv(woC, pv)), k: k * cDiv(prodZ, prodP).re };
+}
+function lp2bpZpk(z, p, k, wo, bw) {
+  const degree2 = relativeDegree(z, p);
+  const wo2 = new Complex11(wo * wo, 0);
+  const shift = (roots) => {
+    const lp = roots.map((r) => cScale(r, bw / 2));
+    const plus = lp.map((r) => cAdd(r, cSub(cMul(r, r), wo2).sqrt()));
+    const minus = lp.map((r) => cSub(r, cSub(cMul(r, r), wo2).sqrt()));
+    return plus.concat(minus);
+  };
+  const zBp = shift(z);
+  for (let i = 0; i < degree2; i++) zBp.push(new Complex11(0, 0));
+  return { z: zBp, p: shift(p), k: k * Math.pow(bw, degree2) };
+}
+function lp2bsZpk(z, p, k, wo, bw) {
+  const degree2 = relativeDegree(z, p);
+  const wo2 = new Complex11(wo * wo, 0);
+  const bw2 = new Complex11(bw / 2, 0);
+  const shift = (roots) => {
+    const hp = roots.map((r) => cDiv(bw2, r));
+    const plus = hp.map((r) => cAdd(r, cSub(cMul(r, r), wo2).sqrt()));
+    const minus = hp.map((r) => cSub(r, cSub(cMul(r, r), wo2).sqrt()));
+    return plus.concat(minus);
+  };
+  const zBs = shift(z);
+  for (let i = 0; i < degree2; i++) zBs.push(new Complex11(0, wo));
+  for (let i = 0; i < degree2; i++) zBs.push(new Complex11(0, -wo));
+  let prodZ = new Complex11(1, 0);
+  for (const zv of z) prodZ = cMul(prodZ, zv.negate());
+  let prodP = new Complex11(1, 0);
+  for (const pv of p) prodP = cMul(prodP, pv.negate());
+  return { z: zBs, p: shift(p), k: k * cDiv(prodZ, prodP).re };
+}
+function bilinearZpk(z, p, k, fs) {
+  const degree2 = relativeDegree(z, p);
+  const fs2 = new Complex11(2 * fs, 0);
+  const zZ = z.map((zv) => cDiv(cAdd(fs2, zv), cSub(fs2, zv)));
+  for (let i = 0; i < degree2; i++) zZ.push(new Complex11(-1, 0));
+  let prodZ = new Complex11(1, 0);
+  for (const zv of z) prodZ = cMul(prodZ, cSub(fs2, zv));
+  let prodP = new Complex11(1, 0);
+  for (const pv of p) prodP = cMul(prodP, cSub(fs2, pv));
+  return {
+    z: zZ,
+    p: p.map((pv) => cDiv(cAdd(fs2, pv), cSub(fs2, pv))),
+    k: k * cDiv(prodZ, prodP).re
+  };
+}
+function zpkToTf(z, p, k) {
+  return { b: polyFromRoots(z).map((v) => v * k), a: polyFromRoots(p) };
+}
+function validateWn(Wn, btype) {
+  const needsPair = btype === "bandpass" || btype === "bandstop";
+  const arr10 = Array.isArray(Wn) ? Wn.slice() : [Wn];
+  if (needsPair && arr10.length !== 2)
+    throw new Error(`${btype} filter design requires Wn = [low, high]`);
+  if (!needsPair && arr10.length !== 1)
+    throw new Error(`${btype} filter design requires a scalar Wn`);
+  for (const w of arr10) {
+    if (!(w > 0 && w < 1)) throw new Error("Wn must satisfy 0 < Wn < 1 (normalized to Nyquist)");
+  }
+  if (needsPair && !(arr10[0] < arr10[1])) throw new Error("Wn[0] must be less than Wn[1]");
+  return arr10;
+}
+function analogToDigital(proto, Wn, btype) {
+  const WnArr = validateWn(Wn, btype);
+  const fs = 2;
+  const warped = WnArr.map((w) => 2 * fs * Math.tan(Math.PI * w / fs));
+  let { z, p, k } = proto;
+  if (btype === "low") {
+    ({ z, p, k } = lp2lpZpk(z, p, k, warped[0]));
+  } else if (btype === "high") {
+    ({ z, p, k } = lp2hpZpk(z, p, k, warped[0]));
+  } else {
+    const bw = warped[1] - warped[0];
+    const wo = Math.sqrt(warped[0] * warped[1]);
+    ({ z, p, k } = btype === "bandpass" ? lp2bpZpk(z, p, k, wo, bw) : lp2bsZpk(z, p, k, wo, bw));
+  }
+  ({ z, p, k } = bilinearZpk(z, p, k, fs));
+  return zpkToTf(z, p, k);
+}
+function buttap(N) {
+  const p = [];
   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)));
+    p.push(new Complex11(-Math.cos(theta), -Math.sin(theta)));
+  }
+  return { z: [], p, k: 1 };
+}
+function butter(N, Wn, btype = "low") {
+  if (!Number.isInteger(N) || N < 1) throw new Error("butter: order N must be a positive integer");
+  return analogToDigital(buttap(N), Wn, btype);
+}
+
+// src/signal/fft-helpers.ts
+var callFft = fft;
+var callIfft = ifft;
+function toReIm(value) {
+  if (typeof value === "number") {
+    return { re: value, im: 0 };
+  }
+  const c = value;
+  return { re: c.re, im: c.im };
+}
+function rfft(x) {
+  const n = x.length;
+  const full = callFft(x);
+  const keep = Math.floor(n / 2) + 1;
+  const re3 = new Array(keep);
+  const im3 = new Array(keep);
+  for (let i = 0; i < keep; i++) {
+    const c = toReIm(full[i]);
+    re3[i] = c.re;
+    im3[i] = c.im;
+  }
+  return { re: re3, im: im3 };
+}
+function irfft(spec, n) {
+  const halfLen = Math.floor(n / 2) + 1;
+  const full = new Array(n);
+  for (let i = 0; i < halfLen; i++) {
+    full[i] = complex(spec.re[i], spec.im[i]);
+  }
+  for (let i = halfLen; i < n; i++) {
+    const mirror = toReIm(full[n - i]);
+    full[i] = complex(mirror.re, -mirror.im);
+  }
+  const result = callIfft(full);
+  return result.map((v) => toReIm(v).re);
+}
+function fftshift(x) {
+  const n = x.length;
+  const half = Math.floor(n / 2);
+  return [...x.slice(half), ...x.slice(0, half)];
+}
+function ifftshift(x) {
+  const n = x.length;
+  const half = Math.ceil(n / 2);
+  return [...x.slice(half), ...x.slice(0, half)];
+}
+function fftfreq(n, d = 1) {
+  const result = new Array(n);
+  const posCount = Math.ceil(n / 2);
+  const negCount = Math.floor(n / 2);
+  for (let k = 0; k < posCount; k++) {
+    result[k] = k / (n * d);
+  }
+  for (let k = 0; k < negCount; k++) {
+    result[posCount + k] = (k - negCount) / (n * d);
+  }
+  return result;
+}
+function rfftfreq(n, d = 1) {
+  const half = Math.floor(n / 2);
+  const result = new Array(half + 1);
+  for (let k = 0; k <= half; k++) {
+    result[k] = k / (n * d);
+  }
+  return result;
+}
+function fftn(x) {
+  const full = callFft(x);
+  const re3 = full.map((row2) => row2.map((v) => toReIm(v).re));
+  const im3 = full.map((row2) => row2.map((v) => toReIm(v).im));
+  return { re: re3, im: im3 };
+}
+
+// src/signal/iir-design.ts
+import { Complex as Complex12 } from "@danielsimonjr/mathts-core";
+
+// src/special/jacobi-elliptic.ts
+var MAX_AGM_ITERATIONS = 12;
+var AGM_TOLERANCE = 1e-16;
+function jacobiElliptic(u, m) {
+  if (m < 0 || m > 1) {
+    throw new Error("jacobiElliptic: m (=k^2) must be in [0, 1]");
+  }
+  if (m === 0) {
+    return { sn: Math.sin(u), cn: Math.cos(u), dn: 1 };
+  }
+  if (m === 1) {
+    const sn2 = Math.tanh(u);
+    const sech2 = 1 / Math.cosh(u);
+    return { sn: sn2, cn: sech2, dn: sech2 };
+  }
+  const a = [1];
+  const b = [Math.sqrt(1 - m)];
+  const c = [Math.sqrt(m)];
+  let n = 0;
+  while (n < MAX_AGM_ITERATIONS && Math.abs(c[n]) > AGM_TOLERANCE) {
+    a.push((a[n] + b[n]) / 2);
+    b.push(Math.sqrt(a[n] * b[n]));
+    c.push((a[n] - b[n]) / 2);
+    n++;
+  }
+  let phi = Math.pow(2, n) * a[n] * u;
+  for (let i = n; i >= 1; i--) {
+    phi = (phi + Math.asin(c[i] / a[i] * Math.sin(phi))) / 2;
+  }
+  const sn = Math.sin(phi);
+  const cn = Math.cos(phi);
+  const dn = Math.sqrt(1 - m * sn * sn);
+  return { sn, cn, dn };
+}
+function jacobiSN(u, m) {
+  return jacobiElliptic(u, m).sn;
+}
+function jacobiCN(u, m) {
+  return jacobiElliptic(u, m).cn;
+}
+function jacobiDN(u, m) {
+  return jacobiElliptic(u, m).dn;
+}
+
+// src/signal/iir-design.ts
+var arr8 = (x) => Array.isArray(x) ? x : Array.from(x);
+function cheb1ap(N, rp) {
+  const eps = Math.sqrt(Math.pow(10, 0.1 * rp) - 1);
+  const mu = 1 / N * Math.asinh(1 / eps);
+  const p = [];
+  for (let m = -N + 1; m < N; m += 2) {
+    const theta = Math.PI * m / (2 * N);
+    p.push(new Complex12(-Math.sinh(mu) * Math.cos(theta), -Math.cosh(mu) * Math.sin(theta)));
+  }
+  let prod2 = new Complex12(1, 0);
+  for (const pv of p) prod2 = cMul(prod2, pv.negate());
+  let k = prod2.re;
+  if (N % 2 === 0) k /= Math.sqrt(1 + eps * eps);
+  return { z: [], p, k };
+}
+function cheby1(N, rp, Wn, btype = "low") {
+  if (!Number.isInteger(N) || N < 1) throw new Error("cheby1: order N must be a positive integer");
+  if (!(rp > 0)) throw new Error("cheby1: rp (passband ripple, dB) must be positive");
+  return analogToDigital(cheb1ap(N, rp), Wn, btype);
+}
+function cheb2ap(N, rs) {
+  const de = 1 / Math.sqrt(Math.pow(10, 0.1 * rs) - 1);
+  const mu = Math.asinh(1 / de) / N;
+  const mVals = [];
+  if (N % 2) {
+    for (let m = -N + 1; m < 0; m += 2) mVals.push(m);
+    for (let m = 2; m < N; m += 2) mVals.push(m);
+  } else {
+    for (let m = -N + 1; m < N; m += 2) mVals.push(m);
+  }
+  const z = mVals.map((m) => new Complex12(0, 1 / Math.sin(m * Math.PI / (2 * N))));
+  const p = [];
+  for (let m = -N + 1; m < N; m += 2) {
+    const theta = Math.PI * m / (2 * N);
+    const s = new Complex12(Math.sinh(mu) * Math.cos(theta), Math.cosh(mu) * Math.sin(theta));
+    p.push(cDiv(new Complex12(1, 0), s).negate());
+  }
+  let prodP = new Complex12(1, 0);
+  for (const pv of p) prodP = cMul(prodP, pv.negate());
+  let prodZ = new Complex12(1, 0);
+  for (const zv of z) prodZ = cMul(prodZ, zv.negate());
+  const k = cDiv(prodP, prodZ).re;
+  return { z, p, k };
+}
+function cheby2(N, rs, Wn, btype = "low") {
+  if (!Number.isInteger(N) || N < 1) throw new Error("cheby2: order N must be a positive integer");
+  if (!(rs > 0)) throw new Error("cheby2: rs (stopband attenuation, dB) must be positive");
+  return analogToDigital(cheb2ap(N, rs), Wn, btype);
+}
+var ELLIPDEG_MMAX = 7;
+function ellipdeg(N, m1) {
+  const K1 = ellipticKScalar(m1);
+  const K1p = ellipticKScalar(1 - m1);
+  const q1 = Math.exp(-Math.PI * K1p / K1);
+  const q = Math.pow(q1, 1 / N);
+  let num2 = 0;
+  for (let i = 0; i <= ELLIPDEG_MMAX; i++) num2 += Math.pow(q, i * (i + 1));
+  let den = 1;
+  for (let i = 1; i <= ELLIPDEG_MMAX + 1; i++) den += 2 * Math.pow(q, i * i);
+  return 16 * q * Math.pow(num2 / den, 4);
+}
+function complementReal(kx) {
+  return Math.sqrt((1 - kx) * (1 + kx));
+}
+function complementComplex(kx) {
+  const one = new Complex12(1, 0);
+  return one.sub(kx).mul(one.add(kx)).sqrt();
+}
+var ARC_JAC_SN_MAX_ITER = 100;
+function arcJacSn(w, m) {
+  const k = Math.sqrt(m);
+  if (k > 1) throw new Error("arcJacSn: modulus out of range");
+  if (k === 1) return w.atanh();
+  const ks = [k];
+  let niter = 0;
+  while (ks[ks.length - 1] !== 0) {
+    const kCur = ks[ks.length - 1];
+    const kp = complementReal(kCur);
+    const next = (1 - kp) / (1 + kp);
+    ks.push(next);
+    niter++;
+    if (niter > ARC_JAC_SN_MAX_ITER)
+      throw new Error("arcJacSn: Landen transformation did not converge");
+    if (next < 1e-18) {
+      ks[ks.length - 1] = 0;
+      break;
+    }
+  }
+  let K = 1;
+  for (let i = 1; i < ks.length; i++) K *= 1 + ks[i];
+  K *= Math.PI / 2;
+  let wn = w;
+  for (let i = 0; i < ks.length - 1; i++) {
+    const knext = ks[i + 1];
+    const comp = complementComplex(cScale(wn, ks[i]));
+    wn = cDiv(cScale(wn, 2), cMul(new Complex12(1 + knext, 0), new Complex12(1, 0).add(comp)));
+  }
+  return cScale(cScale(wn.asin(), 2 / Math.PI), K);
+}
+function arcJacSc1(w, m) {
+  const z = arcJacSn(new Complex12(0, w), m);
+  if (Math.abs(z.re) > 1e-9)
+    throw new Error("ellip: elliptic filter design failed to converge (arcJacSc1)");
+  return z.im;
+}
+function ellipap(N, rp, rs) {
+  if (N === 1) {
+    const p = -Math.sqrt(1 / (Math.pow(10, 0.1 * rp) - 1));
+    return { z: [], p: [new Complex12(p, 0)], k: -p };
+  }
+  const epsSq = Math.pow(10, 0.1 * rp) - 1;
+  const eps = Math.sqrt(epsSq);
+  const ck1Sq = epsSq / (Math.pow(10, 0.1 * rs) - 1);
+  if (ck1Sq <= 0) throw new Error("ellip: cannot design a filter with the given rp/rs");
+  const val0 = ellipticKScalar(ck1Sq);
+  const m = ellipdeg(N, ck1Sq);
+  const capk = ellipticKScalar(m);
+  const j = [];
+  for (let v = 1 - N % 2; v < N; v += 2) j.push(v);
+  const EPSILON = 2e-16;
+  const s = [];
+  const c = [];
+  const d = [];
+  for (const jv of j) {
+    const u = jv * capk / N;
+    s.push(jacobiSN(u, m));
+    c.push(jacobiCN(u, m));
+    d.push(jacobiDN(u, m));
+  }
+  const zHalf = [];
+  for (let i = 0; i < j.length; i++) {
+    if (Math.abs(s[i]) > EPSILON) zHalf.push(new Complex12(0, 1 / (Math.sqrt(m) * s[i])));
+  }
+  const zFull = zHalf.concat(zHalf.map((zv) => new Complex12(zv.re, -zv.im)));
+  const rr = arcJacSc1(1 / eps, ck1Sq);
+  const v0 = capk * rr / (N * val0);
+  const sv = jacobiSN(v0, 1 - m);
+  const cv = jacobiCN(v0, 1 - m);
+  const dv = jacobiDN(v0, 1 - m);
+  const pHalf = [];
+  for (let i = 0; i < j.length; i++) {
+    const num2 = new Complex12(c[i] * d[i] * sv * cv, s[i] * dv).negate();
+    const den = 1 - Math.pow(d[i] * sv, 2);
+    pHalf.push(new Complex12(num2.re / den, num2.im / den));
+  }
+  let pFull;
+  if (N % 2) {
+    const sumP2 = pHalf.reduce((acc, pv) => acc + pv.re * pv.re + pv.im * pv.im, 0);
+    const thresh = EPSILON * Math.sqrt(sumP2);
+    const newp = pHalf.filter((pv) => Math.abs(pv.im) > thresh);
+    pFull = pHalf.concat(newp.map((pv) => new Complex12(pv.re, -pv.im)));
+  } else {
+    pFull = pHalf.concat(pHalf.map((pv) => new Complex12(pv.re, -pv.im)));
+  }
+  let prodP = new Complex12(1, 0);
+  for (const pv of pFull) prodP = cMul(prodP, pv.negate());
+  let prodZ = new Complex12(1, 0);
+  for (const zv of zFull) prodZ = cMul(prodZ, zv.negate());
+  let k = cDiv(prodP, prodZ).re;
+  if (N % 2 === 0) k /= Math.sqrt(1 + epsSq);
+  return { z: zFull, p: pFull, k };
+}
+function ellip(N, rp, rs, Wn, btype = "low") {
+  if (!Number.isInteger(N) || N < 1) throw new Error("ellip: order N must be a positive integer");
+  if (!(rp > 0)) throw new Error("ellip: rp (passband ripple, dB) must be positive");
+  if (!(rs > 0)) throw new Error("ellip: rs (stopband attenuation, dB) must be positive");
+  return analogToDigital(ellipap(N, rp, rs), Wn, btype);
+}
+function polyMul2(p, q) {
+  const res = new Array(p.length + q.length - 1).fill(0);
+  for (let i = 0; i < p.length; i++) for (let j = 0; j < q.length; j++) res[i + j] += p[i] * q[j];
+  return res;
+}
+function polyAdd2(p, q) {
+  const res = new Array(Math.max(p.length, q.length)).fill(0);
+  for (let i = 0; i < p.length; i++) res[i] += p[i];
+  for (let i = 0; i < q.length; i++) res[i] += q[i];
+  return res;
+}
+function polyPow2(p, n) {
+  let res = [1];
+  for (let i = 0; i < n; i++) res = polyMul2(res, p);
+  return res;
+}
+function trimLeadingZeros(coeffs) {
+  let i = 0;
+  while (i < coeffs.length - 1 && coeffs[i] === 0) i++;
+  return coeffs.slice(i);
+}
+function bilinear(bIn, aIn, fs) {
+  const bTrim = trimLeadingZeros(arr8(bIn));
+  const aTrim = trimLeadingZeros(arr8(aIn));
+  const Q2 = bTrim.length - 1;
+  const P2 = aTrim.length - 1;
+  const N = Math.max(P2, Q2);
+  const kappa = 2 * fs;
+  const zp1 = [1, 1];
+  const zm1 = [-kappa, kappa];
+  let numerator = [0];
+  for (let q = 0; q <= Q2; q++) {
+    const bq = bTrim[Q2 - q];
+    numerator = polyAdd2(
+      numerator,
+      polyMul2(polyPow2(zp1, N - q), polyPow2(zm1, q)).map((v) => v * bq)
+    );
+  }
+  let denominator = [0];
+  for (let p = 0; p <= P2; p++) {
+    const ap = aTrim[P2 - p];
+    denominator = polyAdd2(
+      denominator,
+      polyMul2(polyPow2(zp1, N - p), polyPow2(zm1, p)).map((v) => v * ap)
+    );
+  }
+  const bDesc = numerator.slice().reverse();
+  const aDesc = denominator.slice().reverse();
+  const a0 = aDesc[0];
+  return { b: bDesc.map((v) => v / a0), a: aDesc.map((v) => v / a0) };
+}
+function buttord(wp, ws, gpass, gstop) {
+  if (!(wp > 0 && wp < 1)) throw new Error("buttord: wp must satisfy 0 < wp < 1");
+  if (!(ws > 0 && ws < 1)) throw new Error("buttord: ws must satisfy 0 < ws < 1");
+  if (wp === ws) throw new Error("buttord: wp and ws must differ");
+  const isLow = wp < ws;
+  const passb = Math.tan(Math.PI * wp / 2);
+  const stopb = Math.tan(Math.PI * ws / 2);
+  const nat = isLow ? stopb / passb : passb / stopb;
+  const GSTOP = Math.pow(10, 0.1 * Math.abs(gstop));
+  const GPASS = Math.pow(10, 0.1 * Math.abs(gpass));
+  const N = Math.ceil(Math.log10((GSTOP - 1) / (GPASS - 1)) / (2 * Math.log10(nat)));
+  const W0 = Math.pow(GPASS - 1, -1 / (2 * N));
+  const WN = isLow ? W0 * passb : passb / W0;
+  return { N, Wn: Math.atan(WN) * 2 / Math.PI };
+}
+function toComplex(x) {
+  return x instanceof Complex12 ? x : new Complex12(x, 0);
+}
+function groupConjugatePairs(rootsIn) {
+  const roots = rootsIn.map(toComplex);
+  const n = roots.length;
+  const used = new Array(n).fill(false);
+  const groups = [];
+  const tol = 1e-6;
+  for (let i = 0; i < n; i++) {
+    if (used[i] || Math.abs(roots[i].im) <= tol) continue;
+    const mag = Math.max(1, Math.abs(roots[i].re), Math.abs(roots[i].im));
+    let match = -1;
+    for (let j = i + 1; j < n; j++) {
+      if (used[j]) continue;
+      if (Math.abs(roots[j].re - roots[i].re) < tol * mag && Math.abs(roots[j].im + roots[i].im) < tol * mag) {
+        match = j;
+        break;
+      }
+    }
+    if (match === -1)
+      throw new Error(
+        "zpk2sos: complex root has no matching conjugate (input must have real coefficients)"
+      );
+    used[i] = true;
+    used[match] = true;
+    groups.push([roots[i], roots[match]]);
+  }
+  const reals = [];
+  for (let i = 0; i < n; i++) if (!used[i]) reals.push(new Complex12(roots[i].re, 0));
+  for (let i = 0; i + 1 < reals.length; i += 2) groups.push([reals[i], reals[i + 1]]);
+  if (reals.length % 2 === 1) groups.push([reals[reals.length - 1]]);
+  return groups;
+}
+function quadraticFromRoots(roots) {
+  const poly = polyFromRoots(roots);
+  return poly.length === 2 ? [poly[0], poly[1], 0] : [poly[0], poly[1], poly[2]];
+}
+function zpk2sos(z, p, k) {
+  if (z.length > p.length)
+    throw new Error("zpk2sos: more zeros than poles (improper transfer function)");
+  const zPadded = z.slice();
+  while (zPadded.length < p.length) zPadded.push(0);
+  const zGroups = groupConjugatePairs(zPadded);
+  const pGroups = groupConjugatePairs(p);
+  if (zGroups.length !== pGroups.length)
+    throw new Error("zpk2sos: zero/pole group-count mismatch (roots must be conjugate-symmetric)");
+  const sos = [];
+  for (let i = 0; i < pGroups.length; i++) {
+    const [b0, b1, b2] = quadraticFromRoots(zGroups[i]);
+    const [a0, a1, a2] = quadraticFromRoots(pGroups[i]);
+    const gain = i === 0 ? k : 1;
+    sos.push([b0 * gain, b1 * gain, b2 * gain, a0, a1, a2]);
+  }
+  return sos;
+}
+function sosfilt(sos, x) {
+  let y = arr8(x);
+  for (const section of sos) {
+    if (section.length !== 6)
+      throw new Error("sosfilt: each section must have 6 coefficients [b0,b1,b2,a0,a1,a2]");
+    const [b0, b1, b2, a0, a1, a2] = section;
+    y = lfilter([b0, b1, b2], [a0, a1, a2], y);
+  }
+  return y;
+}
+
+// src/signal/fft.ts
+function complex2(re3, im3 = 0) {
+  return { re: re3, im: im3 };
+}
+function isPowerOf25(n) {
+  return n > 0 && (n & n - 1) === 0;
+}
+function nextPowerOf22(n) {
+  if (n <= 1) return 1;
+  return Math.pow(2, Math.ceil(Math.log2(n)));
+}
+function fftCore(data, inverse = false) {
+  const n = data.length;
+  if (!isPowerOf25(n)) {
+    throw new Error(`FFT length must be power of 2, got ${n}`);
+  }
+  if (n === 1) {
+    return [{ ...data[0] }];
+  }
+  const real = new Float64Array(n);
+  const imag = new Float64Array(n);
+  for (let i = 0; i < n; i++) {
+    real[i] = data[i].re;
+    imag[i] = data[i].im;
+  }
+  const out = fftCoreFloat64(real, imag, inverse);
+  const spectrum = new Array(n);
+  for (let i = 0; i < n; i++) {
+    spectrum[i] = { re: out.real[i], im: out.imag[i] };
+  }
+  return spectrum;
+}
+function fft2(signal) {
+  const originalLength = signal.length;
+  if (originalLength === 0) {
+    return {
+      spectrum: [],
+      originalLength: 0,
+      paddedLength: 0
+    };
+  }
+  let complexSignal;
+  if (signal instanceof Float64Array) {
+    complexSignal = Array.from(signal).map((x) => complex2(x, 0));
+  } else if (typeof signal[0] === "number") {
+    complexSignal = signal.map((x) => complex2(x, 0));
+  } else {
+    complexSignal = signal;
+  }
+  const paddedLength = nextPowerOf22(originalLength);
+  if (paddedLength > originalLength) {
+    const padding = new Array(paddedLength - originalLength).fill(complex2(0, 0));
+    complexSignal = [...complexSignal, ...padding];
+  }
+  const spectrum = fftCore(complexSignal, false);
+  return {
+    spectrum,
+    originalLength,
+    paddedLength
+  };
+}
+function ifft2(spectrum, originalLength) {
+  if (spectrum.length === 0) {
+    return [];
+  }
+  const paddedLength = nextPowerOf22(spectrum.length);
+  let paddedSpectrum = spectrum;
+  if (paddedLength > spectrum.length) {
+    const padding = new Array(paddedLength - spectrum.length).fill(complex2(0, 0));
+    paddedSpectrum = [...spectrum, ...padding];
+  }
+  const result = fftCore(paddedSpectrum, true);
+  if (originalLength !== void 0 && originalLength < result.length) {
+    return result.slice(0, originalLength);
+  }
+  return result;
+}
+function ifftReal(spectrum, originalLength) {
+  const complex3 = ifft2(spectrum, originalLength);
+  return complex3.map((c) => c.re);
+}
+
+// src/signal/conv.ts
+function convDirect(x, h, mode2 = "full") {
+  const xArr = Array.isArray(x) ? x : Array.from(x);
+  const hArr = Array.isArray(h) ? h : Array.from(h);
+  const n = xArr.length;
+  const m = hArr.length;
+  if (n === 0 || m === 0) {
+    return [];
+  }
+  const fullLength = n + m - 1;
+  const result = new Array(fullLength).fill(0);
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < m; j++) {
+      result[i + j] += xArr[i] * hArr[j];
+    }
+  }
+  switch (mode2) {
+    case "full":
+      return result;
+    case "same": {
+      const startSame = Math.floor((m - 1) / 2);
+      return result.slice(startSame, startSame + n);
+    }
+    case "valid": {
+      if (m > n) {
+        return [];
+      }
+      const startValid = m - 1;
+      const validLength = Math.max(0, n - m + 1);
+      return result.slice(startValid, startValid + validLength);
+    }
+    default:
+      return result;
   }
-  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/signal/fir-smoothing.ts
+var arr9 = (x) => Array.isArray(x) ? x : Array.from(x);
+function solveLinearSystem(Ain, bin2) {
+  const n = bin2.length;
+  const A = Ain.map((row2) => row2.slice());
+  const b = bin2.slice();
+  for (let col = 0; col < n; col++) {
+    let piv = col;
+    for (let r = col + 1; r < n; r++) if (Math.abs(A[r][col]) > Math.abs(A[piv][col])) piv = r;
+    if (piv !== col) {
+      [A[col], A[piv]] = [A[piv], A[col]];
+      [b[col], b[piv]] = [b[piv], b[col]];
+    }
+    const pivotVal = A[col][col];
+    if (Math.abs(pivotVal) < 1e-14) throw new Error("solveLinearSystem: singular matrix");
+    for (let r = col + 1; r < n; r++) {
+      const factor2 = A[r][col] / pivotVal;
+      if (factor2 === 0) continue;
+      for (let c = col; c < n; c++) A[r][c] -= factor2 * A[col][c];
+      b[r] -= factor2 * b[col];
+    }
+  }
+  const x = new Array(n).fill(0);
+  for (let row2 = n - 1; row2 >= 0; row2--) {
+    let sum3 = b[row2];
+    for (let c = row2 + 1; c < n; c++) sum3 -= A[row2][c] * x[c];
+    x[row2] = sum3 / A[row2][row2];
+  }
+  return x;
+}
+function firwinBandpass(numtaps, cutoffs) {
+  if (!Number.isInteger(numtaps) || numtaps < 2)
+    throw new Error("firwinBandpass: numtaps must be an integer >= 2");
+  const [f1, f2] = cutoffs;
+  if (!(f1 > 0 && f1 < f2 && f2 < 1))
+    throw new Error("firwinBandpass: require 0 < f1 < f2 < 1 (normalized to Nyquist)");
+  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] = (f2 * sinc(f2 * (n - M / 2)) - f1 * sinc(f1 * (n - M / 2))) * w;
+  }
+  return h;
+}
+function polyFitCoeffs(offsets, values, polyorder) {
+  const p = polyorder + 1;
+  const A = offsets.map((t) => Array.from({ length: p }, (_, k) => Math.pow(t, k)));
+  const AtA = Array.from(
+    { length: p },
+    (_, i) => Array.from({ length: p }, (_2, j) => A.reduce((s, row2) => s + row2[i] * row2[j], 0))
+  );
+  const Atb = Array.from(
+    { length: p },
+    (_, i) => A.reduce((s, row2, idx) => s + row2[i] * values[idx], 0)
+  );
+  return solveLinearSystem(AtA, Atb);
+}
+function evalPoly(c, t) {
+  let s = 0;
+  let tk = 1;
+  for (let k = 0; k < c.length; k++) {
+    s += c[k] * tk;
+    tk *= t;
+  }
+  return s;
+}
+function savgol(x, windowLength, polyorder) {
+  const xx = arr9(x);
+  const n = xx.length;
+  if (!Number.isInteger(windowLength) || windowLength < 1 || windowLength % 2 === 0)
+    throw new Error("savgol: windowLength must be a positive odd integer");
+  if (!Number.isInteger(polyorder) || polyorder < 0 || polyorder >= windowLength)
+    throw new Error("savgol: polyorder must satisfy 0 <= polyorder < windowLength");
+  if (windowLength > n) throw new Error("savgol: windowLength must not exceed the signal length");
+  const half = (windowLength - 1) / 2;
+  const offsets = Array.from({ length: windowLength }, (_, j) => j - half);
+  const out = new Array(n);
+  for (let i = half; i <= n - 1 - half; i++) {
+    const values = offsets.map((_, j) => xx[i - half + j]);
+    out[i] = polyFitCoeffs(offsets, values, polyorder)[0];
+  }
+  if (half > 0) {
+    const cLeft = polyFitCoeffs(offsets, xx.slice(0, windowLength), polyorder);
+    for (let i = 0; i < half; i++) out[i] = evalPoly(cLeft, i - half);
+    const cRight = polyFitCoeffs(offsets, xx.slice(n - windowLength, n), polyorder);
+    const rightCenter = n - 1 - half;
+    for (let i = n - half; i < n; i++) out[i] = evalPoly(cRight, i - rightCenter);
+  }
+  return out;
+}
+function deconvolve(signal, divisor) {
+  const s = arr9(signal);
+  const d = arr9(divisor);
+  const N = s.length;
+  const D = d.length;
+  if (D === 0) throw new Error("deconvolve: divisor must be non-empty");
+  if (d[0] === 0) throw new Error("deconvolve: divisor[0] (leading coefficient) must be nonzero");
+  if (D > N) return { quotient: [], remainder: s.slice() };
+  const remainder = s.slice();
+  const quotient = new Array(N - D + 1).fill(0);
+  for (let i = 0; i < quotient.length; i++) {
+    const c = remainder[i] / d[0];
+    quotient[i] = c;
+    for (let j = 0; j < D; j++) remainder[i + j] -= c * d[j];
+  }
+  return { quotient, remainder };
+}
+function wiener(x, mysize = 3) {
+  const xx = arr9(x);
+  const n = xx.length;
+  if (!Number.isInteger(mysize) || mysize < 1)
+    throw new Error("wiener: mysize must be a positive integer");
+  const kernel = new Array(mysize).fill(1 / mysize);
+  const lMean = convDirect(xx, kernel, "same");
+  const lMeanSq = convDirect(
+    xx.map((v) => v * v),
+    kernel,
+    "same"
+  );
+  const lVar = lMeanSq.map((v, i) => Math.max(0, v - lMean[i] * lMean[i]));
+  const noise = lVar.reduce((a, b) => a + b, 0) / n;
+  return xx.map((xi, i) => {
+    const v = lVar[i];
+    const denom = Math.max(v, noise);
+    if (denom === 0) return lMean[i];
+    return lMean[i] + Math.max(0, v - noise) / denom * (xi - lMean[i]);
+  });
+}
+function makeBasis(numtaps) {
+  const type1 = numtaps % 2 === 1;
+  const M = type1 ? (numtaps - 1) / 2 : numtaps / 2;
+  const nBasis = type1 ? M + 1 : M;
+  return {
+    type1,
+    M,
+    nBasis,
+    phi: (k, w) => type1 ? Math.cos(k * Math.PI * w) : Math.cos((k + 0.5) * Math.PI * w)
+  };
+}
+function coeffsToTaps(numtaps, basis, coeffs) {
+  const h = new Array(numtaps).fill(0);
+  const { M, type1 } = basis;
+  if (type1) {
+    h[M] = coeffs[0];
+    for (let k = 1; k <= M; k++) {
+      h[M - k] = coeffs[k] / 2;
+      h[M + k] = coeffs[k] / 2;
+    }
+  } else {
+    for (let k = 1; k <= M; k++) {
+      const v = coeffs[k - 1] / 2;
+      h[M - k] = v;
+      h[M - 1 + k] = v;
+    }
+  }
+  return h;
+}
+function validateBandsDesired(numtaps, bands, desired) {
+  if (!Number.isInteger(numtaps) || numtaps < 3)
+    throw new Error("firls/remez: numtaps must be an integer >= 3");
+  if (bands.length < 2 || bands.length % 2 !== 0)
+    throw new Error("firls/remez: bands must be a non-empty list of [lo, hi] pairs");
+  if (desired.length !== bands.length)
+    throw new Error("firls/remez: desired must have the same length as bands");
+  for (let i = 0; i < bands.length; i += 2) {
+    if (!(bands[i] >= 0 && bands[i] < bands[i + 1] && bands[i + 1] <= 1))
+      throw new Error("firls/remez: each band pair must satisfy 0 <= lo < hi <= 1");
+  }
+}
+function sampleBands(bands, desired, samplesPerBand = 400) {
+  const pts = [];
+  for (let band = 0; band < bands.length; band += 2) {
+    const w0 = bands[band];
+    const w1 = bands[band + 1];
+    const d0 = desired[band];
+    const d1 = desired[band + 1];
+    const dw = (w1 - w0) / samplesPerBand;
+    for (let s = 0; s <= samplesPerBand; s++) {
+      const w = w0 + s * dw;
+      const D = d0 + (d1 - d0) * (w - w0) / (w1 - w0);
+      const weight = s === 0 || s === samplesPerBand ? 0.5 * dw : dw;
+      pts.push({ w, D, dw: weight });
+    }
+  }
+  return pts;
+}
+function solveWeightedBasis(basis, pts, weights) {
+  const n = basis.nBasis;
+  const A = Array.from({ length: n }, () => new Array(n).fill(0));
+  const b = new Array(n).fill(0);
+  for (let i = 0; i < pts.length; i++) {
+    const { w, D, dw } = pts[i];
+    const wt = weights[i] * dw;
+    const phis = Array.from({ length: n }, (_, k) => basis.phi(k, w));
+    for (let a = 0; a < n; a++) {
+      b[a] += wt * phis[a] * D;
+      for (let c = 0; c < n; c++) A[a][c] += wt * phis[a] * phis[c];
+    }
+  }
+  return solveLinearSystem(A, b);
+}
+function evalBasis(basis, coeffs, w) {
+  let s = 0;
+  for (let k = 0; k < basis.nBasis; k++) s += coeffs[k] * basis.phi(k, w);
+  return s;
+}
+function firls(numtaps, bands, desired) {
+  validateBandsDesired(numtaps, bands, desired);
+  const basis = makeBasis(numtaps);
+  const pts = sampleBands(bands, desired);
+  const coeffs = solveWeightedBasis(
+    basis,
+    pts,
+    pts.map(() => 1)
+  );
+  return coeffsToTaps(numtaps, basis, coeffs);
+}
+function remez(numtaps, bands, desired) {
+  validateBandsDesired(numtaps, bands, desired);
+  const basis = makeBasis(numtaps);
+  const pts = sampleBands(bands, desired);
+  let weights = pts.map(() => 1);
+  let coeffs = solveWeightedBasis(basis, pts, weights);
+  const ITERATIONS = 15;
+  for (let iter = 1; iter < ITERATIONS; iter++) {
+    const errs = pts.map((pt) => Math.abs(evalBasis(basis, coeffs, pt.w) - pt.D));
+    const maxErr = Math.max(...errs, 1e-12);
+    const reweighted = weights.map((wgt, i) => wgt * Math.pow(errs[i] / maxErr + 1e-6, 0.5));
+    const meanW = reweighted.reduce((a, b) => a + b, 0) / reweighted.length;
+    weights = reweighted.map((wgt) => wgt / meanW);
+    coeffs = solveWeightedBasis(basis, pts, weights);
+  }
+  return coeffsToTaps(numtaps, basis, coeffs);
+}
+
+// src/signal/wavelets.ts
+function idwt(approx, detail, wavelet = "haar") {
+  if (wavelet !== "haar" && wavelet !== "db1") {
+    throw new Error(`idwt: unsupported wavelet "${wavelet}"`);
+  }
+  if (approx.length !== detail.length) {
+    throw new Error("idwt: approx and detail must have equal length");
+  }
+  const half = approx.length;
+  const s = 1 / Math.SQRT2;
+  const x = new Array(half * 2);
+  for (let i = 0; i < half; i++) {
+    x[2 * i] = s * (approx[i] + detail[i]);
+    x[2 * i + 1] = s * (approx[i] - detail[i]);
+  }
+  return x;
+}
+function wavedec(x, wavelet = "haar", level = 1) {
+  if (!Number.isInteger(level) || level < 1) {
+    throw new Error("wavedec: level must be an integer >= 1");
+  }
+  const coeffs = [];
+  let approx = x.slice();
+  for (let l = 0; l < level; l++) {
+    const { approx: a, detail: d } = dwt(approx, wavelet);
+    coeffs.unshift(d);
+    approx = a;
+  }
+  coeffs.unshift(approx);
+  return coeffs;
+}
+function waverec(coeffs, wavelet = "haar") {
+  if (coeffs.length < 2) {
+    throw new Error("waverec: coeffs must contain at least [cA, cD]");
+  }
+  let approx = coeffs[0].slice();
+  for (let i = 1; i < coeffs.length; i++) {
+    approx = idwt(approx, coeffs[i], wavelet);
+  }
+  return approx;
+}
+function rickerWavelet(points, scale) {
+  const amplitude = 2 / (Math.sqrt(3 * scale) * Math.pow(Math.PI, 0.25));
+  const out = new Array(points);
+  const center2 = (points - 1) / 2;
+  for (let i = 0; i < points; i++) {
+    const t = (i - center2) / scale;
+    const t2 = t * t;
+    out[i] = amplitude * (1 - t2) * Math.exp(-t2 / 2);
+  }
+  return out;
+}
+function morletWavelet(points, scale) {
+  const norm4 = 1 / (Math.sqrt(scale) * Math.pow(Math.PI, 0.25));
+  const out = new Array(points);
+  const center2 = (points - 1) / 2;
+  for (let i = 0; i < points; i++) {
+    const t = (i - center2) / scale;
+    out[i] = norm4 * Math.cos(5 * t) * Math.exp(-(t * t) / 2);
+  }
+  return out;
+}
+function cwt(x, scales, wavelet = "ricker") {
+  if (wavelet !== "ricker" && wavelet !== "morlet") {
+    throw new Error(`cwt: unsupported wavelet "${wavelet}"`);
+  }
+  const n = x.length;
+  return scales.map((scale) => {
+    if (scale <= 0) throw new Error("cwt: scales must be positive");
+    const points = Math.max(1, Math.min(Math.round(10 * scale), n));
+    const psi = wavelet === "ricker" ? rickerWavelet(points, scale) : morletWavelet(points, scale);
+    return convDirect(x, psi, "same");
+  });
+}
+
+// src/signal/spectral-peaks.ts
+function peakProminence(x, i) {
+  const n = x.length;
+  const peakHeight = x[i];
+  let leftMin = peakHeight;
+  let j = i;
+  while (j > 0) {
+    j--;
+    if (x[j] > peakHeight) break;
+    if (x[j] < leftMin) leftMin = x[j];
+  }
+  let rightMin = peakHeight;
+  let k = i;
+  while (k < n - 1) {
+    k++;
+    if (x[k] > peakHeight) break;
+    if (x[k] < rightMin) rightMin = x[k];
+  }
+  return peakHeight - Math.max(leftMin, rightMin);
+}
+function filterByDistance(x, peaks, distance2) {
+  const order = peaks.map((_, idx) => idx).sort((a, b) => x[peaks[b]] - x[peaks[a]]);
+  const keep = new Array(peaks.length).fill(true);
+  for (const idx of order) {
+    if (!keep[idx]) continue;
+    let j = idx - 1;
+    while (j >= 0 && peaks[idx] - peaks[j] < distance2) {
+      keep[j] = false;
+      j--;
+    }
+    let k = idx + 1;
+    while (k < peaks.length && peaks[k] - peaks[idx] < distance2) {
+      keep[k] = false;
+      k++;
+    }
+  }
+  return peaks.filter((_, idx) => keep[idx]);
+}
+function findPeaks(x, opts) {
+  let peaks = [];
+  for (let i = 1; i < x.length - 1; i++) {
+    if (x[i - 1] < x[i] && x[i] > x[i + 1]) peaks.push(i);
+  }
+  if (opts?.height !== void 0) {
+    const h = opts.height;
+    peaks = peaks.filter((i) => x[i] >= h);
+  }
+  if (opts?.prominence !== void 0) {
+    const p = opts.prominence;
+    peaks = peaks.filter((i) => peakProminence(x, i) >= p);
+  }
+  if (opts?.distance !== void 0 && peaks.length > 1) {
+    peaks = filterByDistance(x, peaks, opts.distance);
+  }
+  return peaks;
+}
+function interpolateCrossing(x, start, dir, refHeight) {
+  const n = x.length;
+  let j = start;
+  while (j + dir >= 0 && j + dir < n && x[j + dir] > refHeight) j += dir;
+  const j2 = j + dir;
+  if (j2 < 0 || j2 >= n) return j;
+  const v1 = x[j];
+  const v2 = x[j2];
+  if (v1 === v2) return j;
+  const frac = (v1 - refHeight) / (v1 - v2);
+  return j + dir * frac;
+}
+function peakWidths(x, peaks, relHeight = 0.5) {
+  return peaks.map((i) => {
+    const prom = peakProminence(x, i);
+    const refHeight = x[i] - relHeight * prom;
+    const left = interpolateCrossing(x, i, -1, refHeight);
+    const right = interpolateCrossing(x, i, 1, refHeight);
+    return right - left;
+  });
+}
+function segmentSpectra(sig, nperseg, noverlap, winType) {
+  const step = nperseg - noverlap;
+  if (step <= 0) throw new Error("csd/coherence: noverlap must be less than nperseg");
+  const win = windowFunction(nperseg, winType);
+  const winSum2 = win.reduce((s, w) => s + w * w, 0);
+  const segments = [];
+  for (let start = 0; start + nperseg <= sig.length; start += step) {
+    const seg = new Array(nperseg);
+    for (let i = 0; i < nperseg; i++) seg[i] = sig[start + i] * win[i];
+    segments.push(fft2(seg).spectrum);
+  }
+  if (segments.length === 0) {
+    throw new Error(`csd/coherence: signal length ${sig.length} shorter than nperseg ${nperseg}`);
+  }
+  return { segments, winSum2 };
+}
+function crossPower(x, y, opts) {
+  const nperseg = opts?.nperseg ?? Math.min(256, x.length, y.length);
+  const noverlap = opts?.noverlap ?? Math.floor(nperseg / 2);
+  const winType = opts?.window ?? "hann";
+  const fs = opts?.fs ?? 1;
+  const { segments: Xs, winSum2 } = segmentSpectra(x, nperseg, noverlap, winType);
+  const { segments: Ys } = segmentSpectra(y, nperseg, noverlap, winType);
+  const nSeg = Math.min(Xs.length, Ys.length);
+  const nfft = Xs[0].length;
+  const half = Math.floor(nfft / 2) + 1;
+  const re3 = new Array(half).fill(0);
+  const im3 = new Array(half).fill(0);
+  for (let s = 0; s < nSeg; s++) {
+    for (let k = 0; k < half; k++) {
+      const X = Xs[s][k];
+      const Y = Ys[s][k];
+      re3[k] += X.re * Y.re + X.im * Y.im;
+      im3[k] += X.im * Y.re - X.re * Y.im;
+    }
+  }
+  const scale = 1 / (fs * winSum2 * nSeg);
+  for (let k = 0; k < half; k++) {
+    re3[k] *= scale;
+    im3[k] *= scale;
+  }
+  const frequencies = Array.from({ length: half }, (_, k) => k * fs / nfft);
+  return { frequencies, re: re3, im: im3 };
+}
+function csd(x, y, opts) {
+  const { frequencies, re: re3, im: im3 } = crossPower(x, y, opts);
+  const power = re3.map((r, k) => Math.hypot(r, im3[k]));
+  return { frequencies, power };
+}
+function coherence(x, y, opts) {
+  const pxy = crossPower(x, y, opts);
+  const pxx = crossPower(x, x, opts);
+  const pyy = crossPower(y, y, opts);
+  const coh = pxy.re.map((r, k) => {
+    const num2 = r * r + pxy.im[k] * pxy.im[k];
+    const den = pxx.re[k] * pyy.re[k];
+    if (den <= 0) return 0;
+    return Math.min(1, num2 / den);
+  });
+  return { frequencies: pxy.frequencies, coherence: coh };
+}
+function stft(x, opts) {
+  const nperseg = opts?.nperseg ?? 256;
+  const noverlap = opts?.noverlap ?? Math.floor(nperseg / 2);
+  const winType = opts?.window ?? "hann";
+  const step = nperseg - noverlap;
+  if (step <= 0) throw new Error("stft: noverlap must be less than nperseg");
+  const win = windowFunction(nperseg, winType);
+  const re3 = [];
+  const im3 = [];
+  for (let start = 0; start + nperseg <= x.length; start += step) {
+    const seg = new Array(nperseg);
+    for (let i = 0; i < nperseg; i++) seg[i] = x[start + i] * win[i];
+    const spectrum = fft2(seg).spectrum;
+    re3.push(spectrum.map((c) => c.re));
+    im3.push(spectrum.map((c) => c.im));
+  }
+  return { re: re3, im: im3 };
+}
+function istft(S, opts) {
+  const nperseg = opts?.nperseg ?? 256;
+  const noverlap = opts?.noverlap ?? Math.floor(nperseg / 2);
+  const winType = opts?.window ?? "hann";
+  const step = nperseg - noverlap;
+  if (step <= 0) throw new Error("istft: noverlap must be less than nperseg");
+  const win = windowFunction(nperseg, winType);
+  const nFrames = S.re.length;
+  const outLength = nFrames > 0 ? (nFrames - 1) * step + nperseg : 0;
+  const output = new Array(outLength).fill(0);
+  const normalizer = new Array(outLength).fill(0);
+  for (let f = 0; f < nFrames; f++) {
+    const spectrum = S.re[f].map((r, i) => ({ re: r, im: S.im[f][i] }));
+    const frame = ifftReal(spectrum, nperseg);
+    const start = f * step;
+    for (let i = 0; i < nperseg; i++) {
+      output[start + i] += frame[i] * win[i];
+      normalizer[start + i] += win[i] * win[i];
+    }
+  }
+  for (let i = 0; i < outLength; i++) {
+    if (normalizer[i] > 1e-12) output[i] /= normalizer[i];
+  }
+  return output;
+}
+function decimate(x, q) {
+  if (!Number.isInteger(q) || q < 1) {
+    throw new Error("decimate: q must be a positive integer");
+  }
+  if (q === 1) return x.slice();
+  const order = 4;
+  const wn = Math.min(0.8 / q, 0.99);
+  const { b, a } = butter(order, wn);
+  const filtered = filtfilt(b, a, x);
+  const out = [];
+  for (let i = 0; i < filtered.length; i += q) out.push(filtered[i]);
+  return out;
 }
 
 // src/geometry-extra.ts
@@ -47170,6 +48577,146 @@ function cochranQ(data) {
   const pValue = 1 - chiSquaredCDF(Q2, dof);
   return { Q: Q2, pValue, dof };
 }
+
+// src/special/hypergeometric.ts
+var MAX_TERMS = 500;
+var RELTOL = 1e-16;
+function pFq(a, b, z) {
+  let sum3 = 1;
+  let term = 1;
+  for (let n = 0; n < MAX_TERMS; n++) {
+    let ratio = z / (n + 1);
+    for (const ai of a) ratio *= ai + n;
+    for (const bj of b) ratio /= bj + n;
+    term *= ratio;
+    sum3 += term;
+    if (Math.abs(term) < RELTOL * Math.abs(sum3)) break;
+  }
+  return sum3;
+}
+function hyp0f1(b, z) {
+  return pFq([], [b], z);
+}
+function hyp1f1(a, b, z) {
+  return pFq([a], [b], z);
+}
+function hyp2f1(a, b, c, z) {
+  if (Math.abs(z) >= 1) {
+    throw new Error("hyp2f1: |z| must be < 1 (analytic continuation not yet implemented)");
+  }
+  return pFq([a, b], [c], z);
+}
+
+// src/special/polygamma-orthopoly.ts
+var SHIFT_THRESHOLD = 12;
+var BERNOULLI_EVEN = [1 / 6, -1 / 30, 1 / 42, -1 / 30];
+function factorial4(n) {
+  let result = 1;
+  for (let i = 2; i <= n; i++) result *= i;
+  return result;
+}
+function polygamma(n, x) {
+  if (!Number.isInteger(n) || n < 0) {
+    throw new Error("polygamma: n must be a nonnegative integer");
+  }
+  if (n === 0) {
+    return digamma(x);
+  }
+  if (x <= 0 && Number.isInteger(x)) {
+    return NaN;
+  }
+  const sign3 = n % 2 === 1 ? 1 : -1;
+  const nFactorial = factorial4(n);
+  let recurrenceSum = 0;
+  let shifted = x;
+  while (shifted < SHIFT_THRESHOLD) {
+    recurrenceSum += 1 / Math.pow(shifted, n + 1);
+    shifted += 1;
+  }
+  let bracket = factorial4(n - 1) / Math.pow(shifted, n) + nFactorial / (2 * Math.pow(shifted, n + 1));
+  for (let j = 1; j <= BERNOULLI_EVEN.length; j++) {
+    const twoJ = 2 * j;
+    const term = BERNOULLI_EVEN[j - 1] * factorial4(twoJ + n - 1) / factorial4(twoJ) / Math.pow(shifted, twoJ + n);
+    bracket += term;
+  }
+  return sign3 * (nFactorial * recurrenceSum + bracket);
+}
+function trigamma(x) {
+  return polygamma(1, x);
+}
+function jacobiP(n, alpha, beta2, x) {
+  if (!Number.isInteger(n) || n < 0) {
+    throw new Error("jacobiP: n must be a nonnegative integer");
+  }
+  if (n === 0) return 1;
+  let pPrev = 1;
+  let pCurr = alpha + 1 + (alpha + beta2 + 2) * (x - 1) / 2;
+  if (n === 1) return pCurr;
+  for (let k = 2; k <= n; k++) {
+    const a1 = 2 * k * (k + alpha + beta2) * (2 * k + alpha + beta2 - 2);
+    const a2 = (2 * k + alpha + beta2 - 1) * ((2 * k + alpha + beta2) * (2 * k + alpha + beta2 - 2) * x + alpha * alpha - beta2 * beta2);
+    const a3 = 2 * (k + alpha - 1) * (k + beta2 - 1) * (2 * k + alpha + beta2);
+    const pNext = (a2 * pCurr - a3 * pPrev) / a1;
+    pPrev = pCurr;
+    pCurr = pNext;
+  }
+  return pCurr;
+}
+function gegenbauerC(n, alpha, x) {
+  if (!Number.isInteger(n) || n < 0) {
+    throw new Error("gegenbauerC: n must be a nonnegative integer");
+  }
+  if (n === 0) return 1;
+  let cPrev = 1;
+  let cCurr = 2 * alpha * x;
+  if (n === 1) return cCurr;
+  for (let k = 2; k <= n; k++) {
+    const cNext = (2 * x * (k + alpha - 1) * cCurr - (k + 2 * alpha - 2) * cPrev) / k;
+    cPrev = cCurr;
+    cCurr = cNext;
+  }
+  return cCurr;
+}
+
+// src/numeric/gauss-nodes.ts
+var NEWTON_MAX_ITERATIONS = 100;
+var NEWTON_TOLERANCE = 1e-15;
+function legendrePair(n, x) {
+  let pPrev = 1;
+  let pCurr = x;
+  if (n === 0) return [1, x];
+  for (let k = 2; k <= n; k++) {
+    const pNext = ((2 * k - 1) * x * pCurr - (k - 1) * pPrev) / k;
+    pPrev = pCurr;
+    pCurr = pNext;
+  }
+  return [pCurr, pPrev];
+}
+function rootsLegendre(n) {
+  if (!Number.isInteger(n) || n < 1) {
+    throw new Error("rootsLegendre: n must be a positive integer");
+  }
+  const nodes = [];
+  const weights = [];
+  for (let i = 0; i < n; i++) {
+    let x = Math.cos(Math.PI * (i + 0.75) / (n + 0.5));
+    let pn = 0;
+    let dpn = 0;
+    for (let iter = 0; iter < NEWTON_MAX_ITERATIONS; iter++) {
+      const [pCurr, pPrev] = legendrePair(n, x);
+      pn = pCurr;
+      dpn = n * (x * pCurr - pPrev) / (x * x - 1);
+      const dx = pn / dpn;
+      x -= dx;
+      if (Math.abs(dx) < NEWTON_TOLERANCE) break;
+    }
+    nodes.push(x);
+    weights.push(2 / ((1 - x * x) * dpn * dpn));
+  }
+  nodes.reverse();
+  weights.reverse();
+  return { nodes, weights };
+}
 export {
   ARRAY_WORKER_THRESHOLD,
   CAS_BATCH_THRESHOLD,
@@ -47243,6 +48790,7 @@ export {
   bfgs,
   bigint,
   bignumber,
+  bilinear,
   bin,
   binomialDist,
   binomialPMF,
@@ -47258,6 +48806,7 @@ export {
   bootstrapCI,
   bspline,
   butter,
+  buttord,
   cancel,
   carlsonRC,
   carlsonRD,
@@ -47277,6 +48826,8 @@ export {
   centroid,
   chain,
   characteristicPolynomial,
+  cheby1,
+  cheby2,
   chebyshevApprox,
   chebyshevDistance,
   chebyshevFit,
@@ -47299,9 +48850,11 @@ export {
   clone3 as clone,
   cochranQ,
   coefficientList,
+  coherence,
   collect,
   column,
   combinations,
+  combinationsGen,
   combinationsWithRep,
   combine,
   companion,
@@ -47319,6 +48872,7 @@ export {
   config,
   conj,
   connectedComponents,
+  continuedFraction,
   convexHull,
   convexHull3D,
   convolve,
@@ -47348,6 +48902,7 @@ export {
   csSymperm,
   csc,
   csch,
+  csd,
   cspline,
   ctranspose,
   cube,
@@ -47359,9 +48914,12 @@ export {
   cumtrapz,
   curl,
   curvefit,
+  cwt,
   dagostinoTest,
   dbscan,
   dct,
+  decimate,
+  deconvolve,
   deepEqual,
   degree,
   delaunayTriangulation,
@@ -47377,6 +48935,7 @@ export {
   digamma,
   directionalDerivative,
   disableGpu,
+  discreteLog,
   discreteUniformDist,
   discriminant,
   distance,
@@ -47410,6 +48969,7 @@ export {
   elementwiseChainGpuDispatch,
   elementwiseChainReduceGpuDispatch,
   eliminate,
+  ellip,
   ellipticE,
   ellipticEIncomplete,
   ellipticF,
@@ -47424,6 +48984,7 @@ export {
   erfc,
   erfcScalar,
   erfi,
+  eulerNumbers,
   eulerPhi,
   evaluate,
   eventDetection,
@@ -47514,13 +49075,19 @@ export {
   fft,
   fft2d,
   fftGpuDispatch,
+  fftfreq,
+  fftn,
+  fftshift,
   fibonacci,
   filter2 as filter,
   filtfilt,
+  findPeaks,
   findRoot,
   fineStructure,
+  firls,
   firstRadiation,
   firwin,
+  firwinBandpass,
   fisherExact,
   fitDistribution,
   fix,
@@ -47553,6 +49120,7 @@ export {
   gaussQuad,
   gaussianKDE,
   gcd,
+  gegenbauerC,
   generalizedEig,
   geometricPMF,
   getAssumptions,
@@ -47592,12 +49160,17 @@ export {
   histogram,
   hmean,
   hotellingT2,
+  hyp0f1,
+  hyp1f1,
+  hyp2f1,
   hypergeometricDist,
   hypot,
   idct,
   identity,
   idst,
+  idwt,
   ifft,
+  ifftshift,
   im,
   implicitDiff,
   indexFn as index,
@@ -47619,6 +49192,7 @@ export {
   inverseLaplaceTransform,
   invmod,
   iqr,
+  irfft,
   isBounded,
   isConnected,
   isFinite2 as isFinite,
@@ -47631,6 +49205,11 @@ export {
   isPositive,
   isPrime,
   isZero,
+  istft,
+  jacobiCN,
+  jacobiDN,
+  jacobiP,
+  jacobiSN,
   jacobiSymbol,
   jacobian,
   jarqueBera,
@@ -47650,6 +49229,7 @@ export {
   kolmogorovSmirnov2Test,
   kolmogorovSmirnovTest,
   kron,
+  kroneckerSymbol,
   kruskalWallis,
   kurtosis,
   lagrangeInterp,
@@ -47756,6 +49336,7 @@ export {
   multinomial,
   multipleComparison,
   multipleTest,
+  multiplicativeOrder,
   multiply,
   multiplyScalar,
   multivariateNormal,
@@ -47799,6 +49380,7 @@ export {
   or,
   orth,
   outer,
+  pFq,
   pacf,
   padeApproximant,
   pageRank,
@@ -47836,10 +49418,12 @@ export {
   partitions,
   pchip,
   pchipInterp,
+  peakWidths,
   pearsonr,
   periodogram,
   permutationTest,
   permutations,
+  permutationsGen,
   pickRandom,
   piecewise,
   pinv,
@@ -47856,6 +49440,7 @@ export {
   polyFit,
   polyadd,
   polyder,
+  polygamma,
   polygonArea,
   polygonPerimeter,
   polymul,
@@ -47871,6 +49456,7 @@ export {
   prime,
   primeFactors,
   primePi,
+  primitiveRoot,
   principalComponentAnalysis,
   print,
   prod,
@@ -47904,6 +49490,7 @@ export {
   reduce,
   reducedPlanckConstant,
   reflectVector,
+  remez,
   replacer,
   resample,
   resetGpuElementwise,
@@ -47914,12 +49501,15 @@ export {
   resolve,
   resultant,
   reviver,
+  rfft,
+  rfftfreq,
   ridge,
   rightArithShift,
   rightLogShift,
   risingFactorial,
   romberg,
   root,
+  rootsLegendre,
   rotate,
   rotateVector2D,
   rotateVector3D,
@@ -47929,6 +49519,7 @@ export {
   rowReduce,
   rydberg,
   sackurTetrode,
+  savgol,
   schur,
   sec,
   secant,
@@ -47977,6 +49568,7 @@ export {
   solveODESystem,
   solvePDE,
   sort,
+  sosfilt,
   sparse,
   spearman,
   spearmanr,
@@ -47990,7 +49582,9 @@ export {
   squeeze2 as squeeze,
   std,
   stefanBoltzmann,
+  stft,
   stiffODESolver,
+  stirlingS1,
   stirlingS2,
   string,
   stronglyConnectedComponents,
@@ -48040,6 +49634,7 @@ export {
   trigExpand,
   trigReduce,
   trigToExp,
+  trigamma,
   tril,
   trimmedMean,
   triu,
@@ -48078,10 +49673,13 @@ export {
   variation,
   vonMisesPDF,
   voronoiDiagram,
+  wavedec,
+  waverec,
   weakMixingAngle,
   weibullDist,
   welchPSD,
   wienDisplacement,
+  wiener,
   wilcoxon,
   windowFunction,
   xgcd,
@@ -48089,6 +49687,7 @@ export {
   zTransform,
   zeros,
   zeta,
+  zpk2sos,
   zpk2tf,
   zscore
 };