@danielsimonjr/mathts-functions 0.31.0 → 0.33.0

package/dist/index.js

@@ -2021,16 +2021,16 @@ var xgcd = mathTyped2("xgcd", {
     return a < 0n ? [-a, -lastX, -lastY] : [a, lastX, lastY];
   }
 });
-function is2DArray(arr7) {
-  return Array.isArray(arr7[0]);
-}
-function vectorNorm(arr7, p = 2) {
-  if (p === Infinity) return Math.max(...arr7.map((x) => Math.abs(x)));
-  if (p === -Infinity) return Math.min(...arr7.map((x) => Math.abs(x)));
-  if (p === 0) return arr7.filter((x) => x !== 0).length;
-  if (p === 2) return norm2(arr7);
-  const terms = new Array(arr7.length);
-  for (let i = 0; i < arr7.length; i++) terms[i] = Math.pow(Math.abs(arr7[i]), p);
+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);
   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: (arr7) => is2DArray(arr7) ? matrixNorm(arr7) : vectorNorm(arr7),
-  "Array, number": (arr7, p) => is2DArray(arr7) ? matrixNorm(arr7, p) : vectorNorm(arr7, p),
-  "Array, string": (arr7, p) => matrixNorm(arr7, p),
+  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),
   // 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: (arr7) => Math.min(...arr7),
+  Array: (arr8) => Math.min(...arr8),
   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: (arr7) => Math.max(...arr7),
+  Array: (arr8) => Math.max(...arr8),
   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: (arr7) => neumaierSum(arr7),
+  Array: (arr8) => neumaierSum(arr8),
   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: (arr7) => pairwiseSum(arr7),
+  Array: (arr8) => pairwiseSum(arr8),
   // 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: (arr7) => {
-    if (arr7.length === 0) return NaN;
-    return pairwiseSum(arr7) / arr7.length;
+  Array: (arr8) => {
+    if (arr8.length === 0) return NaN;
+    return pairwiseSum(arr8) / arr8.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(arr7) {
-  return sumSquaredDeviations(arr7);
+function m2OfArray(arr8) {
+  return sumSquaredDeviations(arr8);
 }
 var variance = mathTyped2("variance", {
-  Array: (arr7) => varianceFromM2(m2OfArray(arr7), arr7.length, "unbiased"),
-  "Array, string": (arr7, norm4) => varianceFromM2(m2OfArray(arr7), arr7.length, norm4),
+  Array: (arr8) => varianceFromM2(m2OfArray(arr8), arr8.length, "unbiased"),
+  "Array, string": (arr8, norm4) => varianceFromM2(m2OfArray(arr8), arr8.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: (arr7) => Math.sqrt(varianceFromM2(m2OfArray(arr7), arr7.length, "unbiased")),
-  "Array, string": (arr7, norm4) => Math.sqrt(varianceFromM2(m2OfArray(arr7), arr7.length, norm4)),
+  Array: (arr8) => Math.sqrt(varianceFromM2(m2OfArray(arr8), arr8.length, "unbiased")),
+  "Array, string": (arr8, norm4) => Math.sqrt(varianceFromM2(m2OfArray(arr8), arr8.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: (arr7) => Math.hypot(...arr7)
+  Array: (arr8) => Math.hypot(...arr8)
 });
 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(arr7) {
-  return new Float64Array(arr7);
+function toFloat64Array(arr8) {
+  return new Float64Array(arr8);
 }
 var parallelStatSum = mathTyped4("parallelStatSum", {
   // Float64Array - parallel execution
@@ -2683,8 +2683,8 @@ var parallelStatSum = mathTyped4("parallelStatSum", {
     return result.result;
   },
   // Number array
-  Array: async (arr7) => {
-    const data = toFloat64Array(arr7);
+  Array: async (arr8) => {
+    const data = toFloat64Array(arr8);
     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 (arr7) => {
-    if (arr7.length === 0) return NaN;
-    const data = toFloat64Array(arr7);
+  Array: async (arr8) => {
+    if (arr8.length === 0) return NaN;
+    const data = toFloat64Array(arr8);
     const result = await computePool3.mean(data);
     return result.result;
   },
@@ -2737,15 +2737,15 @@ var parallelStatVariance = mathTyped4("parallelStatVariance", {
     }
   },
   // Number array
-  Array: async (arr7) => {
-    if (arr7.length === 0) return NaN;
-    const data = toFloat64Array(arr7);
+  Array: async (arr8) => {
+    if (arr8.length === 0) return NaN;
+    const data = toFloat64Array(arr8);
     return parallelStatVariance(data);
   },
   // Number array with normalization
-  "Array, string": async (arr7, normalization) => {
-    if (arr7.length === 0) return NaN;
-    const data = toFloat64Array(arr7);
+  "Array, string": async (arr8, normalization) => {
+    if (arr8.length === 0) return NaN;
+    const data = toFloat64Array(arr8);
     return parallelStatVariance(data, normalization);
   },
   // Variadic form
@@ -2772,15 +2772,15 @@ var parallelStatStd = mathTyped4("parallelStatStd", {
     return Math.sqrt(variance2);
   },
   // Number array
-  Array: async (arr7) => {
-    if (arr7.length === 0) return NaN;
-    const data = toFloat64Array(arr7);
+  Array: async (arr8) => {
+    if (arr8.length === 0) return NaN;
+    const data = toFloat64Array(arr8);
     return parallelStatStd(data);
   },
   // Number array with normalization
-  "Array, string": async (arr7, normalization) => {
-    if (arr7.length === 0) return NaN;
-    const data = toFloat64Array(arr7);
+  "Array, string": async (arr8, normalization) => {
+    if (arr8.length === 0) return NaN;
+    const data = toFloat64Array(arr8);
     return parallelStatStd(data, normalization);
   }
 });
@@ -2791,9 +2791,9 @@ var parallelStatMin = mathTyped4("parallelStatMin", {
     return result.result;
   },
   // Number array
-  Array: async (arr7) => {
-    if (arr7.length === 0) return Infinity;
-    const data = toFloat64Array(arr7);
+  Array: async (arr8) => {
+    if (arr8.length === 0) return Infinity;
+    const data = toFloat64Array(arr8);
     const result = await computePool3.min(data);
     return result.result;
   },
@@ -2811,9 +2811,9 @@ var parallelStatMax = mathTyped4("parallelStatMax", {
     return result.result;
   },
   // Number array
-  Array: async (arr7) => {
-    if (arr7.length === 0) return -Infinity;
-    const data = toFloat64Array(arr7);
+  Array: async (arr8) => {
+    if (arr8.length === 0) return -Infinity;
+    const data = toFloat64Array(arr8);
     const result = await computePool3.max(data);
     return result.result;
   },
@@ -2831,8 +2831,8 @@ var parallelStatMinMax = mathTyped4("parallelStatMinMax", {
     return result.result;
   },
   // Number array
-  Array: async (arr7) => {
-    const data = toFloat64Array(arr7);
+  Array: async (arr8) => {
+    const data = toFloat64Array(arr8);
     const result = await computePool3.minMax(data);
     return result.result;
   }
@@ -2852,25 +2852,25 @@ var parallelStatMedian = mathTyped4("parallelStatMedian", {
     return sorted[mid];
   },
   // Number array
-  Array: async (arr7) => {
-    if (arr7.length === 0) return NaN;
-    return parallelStatMedian(toFloat64Array(arr7));
+  Array: async (arr8) => {
+    if (arr8.length === 0) return NaN;
+    return parallelStatMedian(toFloat64Array(arr8));
   },
   // Variadic form
   "number, number": (a, b) => (a + b) / 2,
   "number, number, number": (a, b, c) => {
-    const arr7 = [a, b, c].sort((x, y) => x - y);
-    return arr7[1];
+    const arr8 = [a, b, c].sort((x, y) => x - y);
+    return arr8[1];
   }
 });
 var parallelStatMode = mathTyped4("parallelStatMode", {
   // Number array
-  Array: (arr7) => {
-    if (arr7.length === 0) return [];
+  Array: (arr8) => {
+    if (arr8.length === 0) return [];
     const counts = /* @__PURE__ */ new Map();
     let maxCount = 0;
-    for (let i = 0; i < arr7.length; i++) {
-      const val = arr7[i];
+    for (let i = 0; i < arr8.length; i++) {
+      const val = arr8[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: (arr7) => {
-    if (arr7.length === 0) return 1;
+  Array: (arr8) => {
+    if (arr8.length === 0) return 1;
     let prod2 = 1;
-    for (let i = 0; i < arr7.length; i++) {
-      prod2 *= arr7[i];
+    for (let i = 0; i < arr8.length; i++) {
+      prod2 *= arr8[i];
     }
     return prod2;
   },
@@ -2920,8 +2920,8 @@ var parallelStatNorm = mathTyped4("parallelStatNorm", {
     return result.result;
   },
   // Number array
-  Array: async (arr7) => {
-    const data = toFloat64Array(arr7);
+  Array: async (arr8) => {
+    const data = toFloat64Array(arr8);
     const result = await computePool3.norm(data);
     return result.result;
   },
@@ -2962,8 +2962,8 @@ var parallelStatNorm = mathTyped4("parallelStatNorm", {
     }
   },
   // Number array with p-norm
-  "Array, number": (arr7, p) => {
-    return parallelStatNorm(toFloat64Array(arr7), p);
+  "Array, number": (arr8, p) => {
+    return parallelStatNorm(toFloat64Array(arr8), p);
   }
 });
 var parallelStatDistance = mathTyped4("parallelStatDistance", {
@@ -3020,8 +3020,8 @@ var parallelStatMAD = mathTyped4("parallelStatMAD", {
     return mad2 / n;
   },
   // Number array
-  Array: async (arr7) => {
-    return parallelStatMAD(toFloat64Array(arr7));
+  Array: async (arr8) => {
+    return parallelStatMAD(toFloat64Array(arr8));
   }
 });
 var parallelStatCumsum = mathTyped4("parallelStatCumsum", {
@@ -3032,9 +3032,9 @@ var parallelStatCumsum = mathTyped4("parallelStatCumsum", {
     return result;
   },
   // Number array
-  Array: (arr7) => {
-    const result = new Array(arr7.length);
-    neumaierCumsum(arr7, result);
+  Array: (arr8) => {
+    const result = new Array(arr8.length);
+    neumaierCumsum(arr8, result);
     return result;
   }
 });
@@ -3056,8 +3056,8 @@ var parallelStatQuantile = mathTyped4("parallelStatQuantile", {
     return sorted[lower] * (1 - frac) + sorted[upper] * frac;
   },
   // Number array
-  "Array, number": (arr7, q) => {
-    return parallelStatQuantile(toFloat64Array(arr7), q);
+  "Array, number": (arr8, q) => {
+    return parallelStatQuantile(toFloat64Array(arr8), q);
   },
   // Multiple quantiles
   "Float64Array, Array": (data, quantiles) => {
@@ -3080,15 +3080,15 @@ var parallelStatHistogram = mathTyped4("parallelStatHistogram", {
     return result.result;
   },
   // Number array
-  "Array, number": async (arr7, bins) => {
-    return parallelStatHistogram(toFloat64Array(arr7), bins);
+  "Array, number": async (arr8, bins) => {
+    return parallelStatHistogram(toFloat64Array(arr8), bins);
   }
 });
-function quickSelect(arr7, k) {
-  if (k < 0 || k >= arr7.length) {
-    throw new RangeError(`k=${k} is out of range for array of length ${arr7.length}`);
+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}`);
   }
-  const a = arr7.slice();
+  const a = arr8.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(arr7) {
-  const n = arr7.length;
+function medianSelect(arr8) {
+  const n = arr8.length;
   if (n === 0) return NaN;
-  if (n === 1) return arr7[0];
+  if (n === 1) return arr8[0];
   const mid = Math.floor(n / 2);
   if (n % 2 === 1) {
-    return quickSelect(arr7, mid);
+    return quickSelect(arr8, mid);
   }
-  const a = arr7.slice();
+  const a = arr8.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(arr7, k) {
+function minSelect(arr8, k) {
   if (k <= 0) return [];
-  if (k >= arr7.length) return arr7.slice().sort((a2, b) => a2 - b);
-  const a = arr7.slice();
+  if (k >= arr8.length) return arr8.slice().sort((a2, b) => a2 - b);
+  const a = arr8.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(arr7, k) {
+function maxSelect(arr8, k) {
   if (k <= 0) return [];
-  if (k >= arr7.length) return arr7.slice().sort((a2, b) => b - a2);
-  const a = arr7.slice();
+  if (k >= arr8.length) return arr8.slice().sort((a2, b) => b - a2);
+  const a = arr8.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(arr7, fn) {
-  return arr7.map(
+function deepMapArray(arr8, fn) {
+  return arr8.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(arr7) {
+function flattenArray(arr8) {
   const result = [];
-  const stack = [...arr7];
+  const stack = [...arr8];
   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(arr7, n = 1) {
+function differences(arr8, n = 1) {
   if (n < 0 || !Number.isInteger(n)) {
     throw new Error("Difference order must be a non-negative integer");
   }
-  let result = [...arr7];
+  let result = [...arr8];
   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(arr7, index) {
-  if (index < 0 || index >= arr7.length) {
-    throw new Error("Index " + index + " out of bounds for array of length " + arr7.length);
+function element(arr8, index) {
+  if (index < 0 || index >= arr8.length) {
+    throw new Error("Index " + index + " out of bounds for array of length " + arr8.length);
   }
-  return arr7[index];
+  return arr8[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 arr7 = new Float64Array(wasm.memory.buffer, alloc.ptr, dim);
+          const arr8 = new Float64Array(wasm.memory.buffer, alloc.ptr, dim);
           const result = new Array(dim);
           for (let i = 0; i < dim; i++) {
-            result[i] = arr7[i];
+            result[i] = arr8[i];
           }
           return result;
         }, writeVec2 = function(alloc, data) {
-          const arr7 = new Float64Array(wasm.memory.buffer, alloc.ptr, dim);
+          const arr8 = new Float64Array(wasm.memory.buffer, alloc.ptr, dim);
           for (let i = 0; i < dim; i++) {
-            arr7[i] = data[i];
+            arr8[i] = data[i];
           }
         }, writeStage2 = function(stageIdx, data) {
           const offset = stageIdx * dim;
-          const arr7 = new Float64Array(wasm.memory.buffer, stageAlloc.ptr, numStages * dim);
+          const arr8 = new Float64Array(wasm.memory.buffer, stageAlloc.ptr, numStages * dim);
           for (let i = 0; i < dim; i++) {
-            arr7[offset + i] = data[i];
+            arr8[offset + i] = data[i];
           }
         }, trimStepNum2 = function(tn, tfn, hn) {
           const next = tn + hn;
@@ -15509,12 +15509,12 @@ function _makeMulberry322(seed) {
     return z / 4294967296;
   };
 }
-function _shuffle(arr7, rng) {
-  for (let i = arr7.length - 1; i > 0; i--) {
+function _shuffle(arr8, rng) {
+  for (let i = arr8.length - 1; i > 0; i--) {
     const j = Math.floor(rng() * (i + 1));
-    const tmp = arr7[i];
-    arr7[i] = arr7[j];
-    arr7[j] = tmp;
+    const tmp = arr8[i];
+    arr8[i] = arr8[j];
+    arr8[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(arr7) {
+function _mean(arr8) {
   let sum3 = 0;
-  for (let i = 0; i < arr7.length; i++) sum3 += arr7[i];
-  return sum3 / arr7.length;
+  for (let i = 0; i < arr8.length; i++) sum3 += arr8[i];
+  return sum3 / arr8.length;
 }
-function _variance(arr7, ddof = 1) {
-  const m = _mean(arr7);
+function _variance(arr8, ddof = 1) {
+  const m = _mean(arr8);
   let sum3 = 0;
-  for (let i = 0; i < arr7.length; i++) sum3 += (arr7[i] - m) ** 2;
-  return sum3 / (arr7.length - ddof);
+  for (let i = 0; i < arr8.length; i++) sum3 += (arr8[i] - m) ** 2;
+  return sum3 / (arr8.length - ddof);
 }
 function _erf(x) {
   if (x === 0) return 0;
@@ -15651,6 +15651,13 @@ function _chiSquaredPValue(x, df) {
 function _fPValue(f, d1, d2) {
   return 1 - _betainc2(d1 * f / (d1 * f + d2), d1 / 2, d2 / 2);
 }
+function _binomCoeff(n, k) {
+  if (k < 0 || k > n) return 0;
+  const kk = Math.min(k, n - k);
+  let r = 1;
+  for (let i = 0; i < kk; i++) r = r * (n - i) / (i + 1);
+  return r;
+}
 function studentTTest(sample1, sample2) {
   if (sample1.length < 2) throw new Error("studentTTest: sample1 must have at least 2 elements");
   if (sample2 === void 0 || sample2 === null) {
@@ -15915,6 +15922,40 @@ async function kolmogorovSmirnovTest(sample, cdfFn, opts) {
     bootstrapStd
   };
 }
+function _mwUCounts(n16, n26) {
+  const table = [];
+  for (let i = 0; i <= n16; i++) {
+    const row2 = [];
+    for (let j = 0; j <= n26; j++) {
+      const maxU = i * j;
+      const arr8 = new Float64Array(maxU + 1);
+      if (i === 0 || j === 0) {
+        arr8[0] = 1;
+      } else {
+        const prevI = table[i - 1][j];
+        const prevJ = row2[j - 1];
+        for (let u = 0; u <= maxU; u++) {
+          let val = 0;
+          const uShift = u - j;
+          if (uShift >= 0 && uShift < prevI.length) val += prevI[uShift];
+          if (u < prevJ.length) val += prevJ[u];
+          arr8[u] = val;
+        }
+      }
+      row2.push(arr8);
+    }
+    table.push(row2);
+  }
+  return table[n16][n26];
+}
+function _mwExactPValue(n16, n26, U) {
+  const counts = _mwUCounts(n16, n26);
+  let total = 0;
+  for (let k = 0; k < counts.length; k++) total += counts[k];
+  let cumLe = 0;
+  for (let k = 0; k <= U; k++) cumLe += counts[k];
+  return Math.min(1, 2 * (cumLe / total));
+}
 async function mannWhitneyTest(sample1, sample2, opts) {
   if (sample1.length < 1 || sample2.length < 1) {
     throw new Error("mannWhitneyTest: both samples must be non-empty");
@@ -15938,10 +15979,12 @@ async function mannWhitneyTest(sample1, sample2, opts) {
     combined.sort((a, b) => a.value - b.value);
   }
   const ranksArr = new Float64Array(nTotal);
+  let hasTies = false;
   let i = 0;
   while (i < nTotal) {
     let j = i;
     while (j < nTotal && combined[j].value === combined[i].value) j++;
+    if (j - i > 1) hasTies = true;
     const avgRank = (i + 1 + j) / 2;
     for (let k = i; k < j; k++) ranksArr[k] = avgRank;
     i = j;
@@ -15961,11 +16004,16 @@ async function mannWhitneyTest(sample1, sample2, opts) {
   const U1 = R1 - n16 * (n16 + 1) / 2;
   const U2 = n16 * n26 - U1;
   const U = Math.min(U1, U2);
-  const mu = n16 * n26 / 2;
-  const sigma = Math.sqrt(n16 * n26 * (n16 + n26 + 1) / 12);
-  const z = sigma === 0 ? 0 : (U - mu) / sigma;
-  const pValue = 2 * _normalCDF(z);
-  const baseResult = { uStatistic: U, pValue: Math.min(1, pValue) };
+  let pValue;
+  if (n16 * n26 <= 400 && !hasTies) {
+    pValue = _mwExactPValue(n16, n26, U);
+  } else {
+    const mu = n16 * n26 / 2;
+    const sigma = Math.sqrt(n16 * n26 * (n16 + n26 + 1) / 12);
+    const z = sigma === 0 ? 0 : (U - mu) / sigma;
+    pValue = Math.min(1, 2 * _normalCDF(z));
+  }
+  const baseResult = { uStatistic: U, pValue };
   const B = opts?.bootstrap ?? 0;
   if (B <= 0) return baseResult;
   const combinedPool = new Float64Array(nTotal);
@@ -16267,7 +16315,26 @@ function _kstwobignSf(x) {
   }
   return Math.max(0, Math.min(1, sum3));
 }
-function kolmogorovSmirnov2Test(sample1, sample2) {
+function _ks2ExactPValue(n16, n26, D) {
+  const eps = 1e-9;
+  const dp = Array.from({ length: n16 + 1 }, () => new Float64Array(n26 + 1));
+  dp[0][0] = 1;
+  for (let i = 0; i <= n16; i++) {
+    for (let j = 0; j <= n26; j++) {
+      if (i === 0 && j === 0) continue;
+      const dev = Math.abs(i / n16 - j / n26);
+      if (dev >= D - eps) continue;
+      let v = 0;
+      if (i > 0) v += dp[i - 1][j];
+      if (j > 0) v += dp[i][j - 1];
+      dp[i][j] = v;
+    }
+  }
+  const total = _binomCoeff(n16 + n26, n16);
+  const inside = dp[n16][n26];
+  return Math.max(0, Math.min(1, 1 - inside / total));
+}
+function kolmogorovSmirnov2Test(sample1, sample2, opts) {
   const n16 = sample1.length;
   const n26 = sample2.length;
   if (n16 < 1 || n26 < 1) {
@@ -16284,11 +16351,16 @@ function kolmogorovSmirnov2Test(sample1, sample2) {
     while (j < n26 && b[j] <= x) j++;
     d = Math.max(d, Math.abs(i / n16 - j / n26));
   }
+  const method = opts?.method;
+  const useExact = method === "exact" || method === "auto" && n16 * n26 <= 1e4;
+  if (useExact) {
+    return { statistic: d, pValue: _ks2ExactPValue(n16, n26, d) };
+  }
   const en = Math.sqrt(n16 * n26 / (n16 + n26));
   return { statistic: d, pValue: _kstwobignSf(en * d) };
 }
-function _median(arr7) {
-  const s = arr7.slice().sort((a, b) => a - b);
+function _median(arr8) {
+  const s = arr8.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;
@@ -18078,19 +18150,19 @@ var randomInt = mathTyped16("randomInt", {
   }
 });
 var pickRandom = mathTyped16("pickRandom", {
-  Array: (arr7) => _pick(arr7, 1, void 0)[0],
-  "Array, number": (arr7, n) => _pick(arr7, n, void 0),
-  "Array, Array": (arr7, weights) => _pick(arr7, 1, weights)[0],
-  "Array, number, Array": (arr7, n, weights) => _pick(arr7, n, weights),
-  "Array, Array, number": (arr7, weights, n) => _pick(arr7, n, weights)
+  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)
 });
-function _pick(arr7, n, weights) {
-  if (arr7.length === 0) throw new RangeError("Cannot pick from an empty array");
+function _pick(arr8, n, weights) {
+  if (arr8.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 !== arr7.length) {
+    if (weights.length !== arr8.length) {
       throw new RangeError("weights must have the same length as the array");
     }
     let total = 0;
@@ -18104,20 +18176,20 @@ function _pick(arr7, n, weights) {
     const result2 = [];
     for (let i = 0; i < n; i++) {
       let r = _rng() * total;
-      for (let j = 0; j < arr7.length; j++) {
+      for (let j = 0; j < arr8.length; j++) {
         r -= weights[j];
         if (r < 0) {
-          result2.push(arr7[j]);
+          result2.push(arr8[j]);
           break;
         }
       }
-      if (result2.length < i + 1) result2.push(arr7[arr7.length - 1]);
+      if (result2.length < i + 1) result2.push(arr8[arr8.length - 1]);
     }
     return result2;
   }
   const result = [];
   for (let i = 0; i < n; i++) {
-    result.push(arr7[Math.floor(_rng() * arr7.length)]);
+    result.push(arr8[Math.floor(_rng() * arr8.length)]);
   }
   return result;
 }
@@ -18769,13 +18841,13 @@ function resize(array, size2, defaultValue) {
       );
     }
   });
-  let arr7 = array;
+  let arr8 = array;
   if (isNumber(array) || isBigNumber(array)) {
-    arr7 = [array];
+    arr8 = [array];
   }
   const _defaultValue = defaultValue !== void 0 ? defaultValue : 0;
-  _resize(arr7, size2, 0, _defaultValue);
-  return arr7;
+  _resize(arr8, size2, 0, _defaultValue);
+  return arr8;
 }
 function _resize(array, size2, dim, defaultValue) {
   let i;
@@ -18876,9 +18948,9 @@ function _reshape(array, sizes) {
 }
 function squeeze(array, size2) {
   const s = size2 || arraySize(array);
-  let arr7 = array;
-  while (Array.isArray(arr7) && arr7.length === 1) {
-    arr7 = arr7[0];
+  let arr8 = array;
+  while (Array.isArray(arr8) && arr8.length === 1) {
+    arr8 = arr8[0];
     s.shift();
   }
   let dims = s.length;
@@ -18886,19 +18958,19 @@ function squeeze(array, size2) {
     dims--;
   }
   if (dims < s.length) {
-    arr7 = _squeeze(arr7, dims, 0);
+    arr8 = _squeeze(arr8, dims, 0);
     s.length = dims;
   }
-  return arr7;
+  return arr8;
 }
 function _squeeze(array, dims, dim) {
   if (dim < dims) {
     const next = dim + 1;
-    const arr7 = array;
-    for (let i = 0, ii = arr7.length; i < ii; i++) {
-      arr7[i] = _squeeze(arr7[i], dims, next);
+    const arr8 = array;
+    for (let i = 0, ii = arr8.length; i < ii; i++) {
+      arr8[i] = _squeeze(arr8[i], dims, next);
     }
-    return arr7;
+    return arr8;
   } else {
     let result = array;
     while (Array.isArray(result)) {
@@ -18921,9 +18993,9 @@ function flatten2(array, isRectangular = false) {
     _flatten(array);
   }
   return flat;
-  function _flatten(arr7) {
-    for (let i = 0; i < arr7.length; i++) {
-      const item = arr7[i];
+  function _flatten(arr8) {
+    for (let i = 0; i < arr8.length; i++) {
+      const item = arr8[i];
       if (Array.isArray(item)) {
         _flatten(item);
       } else {
@@ -18931,14 +19003,14 @@ function flatten2(array, isRectangular = false) {
       }
     }
   }
-  function _flattenRectangular(arr7) {
-    if (Array.isArray(arr7[0])) {
-      for (let i = 0; i < arr7.length; i++) {
-        _flattenRectangular(arr7[i]);
+  function _flattenRectangular(arr8) {
+    if (Array.isArray(arr8[0])) {
+      for (let i = 0; i < arr8.length; i++) {
+        _flattenRectangular(arr8[i]);
       }
     } else {
-      for (let i = 0; i < arr7.length; i++) {
-        flat.push(arr7[i]);
+      for (let i = 0; i < arr8.length; i++) {
+        flat.push(arr8[i]);
       }
     }
   }
@@ -19918,24 +19990,24 @@ function decCoefficientToBinaryString(x) {
       str = str.slice(0, xe) + "." + str.slice(xe);
     }
   }
-  const arr7 = [0];
+  const arr8 = [0];
   for (let i = 0; i < str.length; ) {
-    let arrL = arr7.length;
+    let arrL = arr8.length;
     while (arrL--) {
-      arr7[arrL] *= 10;
+      arr8[arrL] *= 10;
     }
-    arr7[0] += parseInt(str.charAt(i++));
-    for (let j2 = 0; j2 < arr7.length; ++j2) {
-      if (arr7[j2] > 1) {
-        if (arr7[j2 + 1] === null || arr7[j2 + 1] === void 0) {
-          arr7[j2 + 1] = 0;
+    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;
         }
-        arr7[j2 + 1] += arr7[j2] >> 1;
-        arr7[j2] &= 1;
+        arr8[j2 + 1] += arr8[j2] >> 1;
+        arr8[j2] &= 1;
       }
     }
   }
-  return arr7.reverse();
+  return arr8.reverse();
 }
 function bitXor2(x, y) {
   if (x.isFinite() && !x.isInteger() || y.isFinite() && !y.isInteger()) {
@@ -20435,8 +20507,8 @@ var createMap = /* @__PURE__ */ factory(
             if (index) index[depth] = i;
             result[i] = iterate(
               arrays2.map((array, arrayIndex) => {
-                const arr7 = array;
-                return offsets[arrayIndex] > depth ? array : arr7.length === 1 ? arr7[0] : arr7[i];
+                const arr8 = array;
+                return offsets[arrayIndex] > depth ? array : arr8.length === 1 ? arr8[0] : arr8[i];
               }),
               depth + 1
             );
@@ -20446,8 +20518,8 @@ var createMap = /* @__PURE__ */ factory(
             if (index) index[depth] = i;
             result[i] = callback(
               arrays2.map((a) => {
-                const arr7 = a;
-                return arr7.length === 1 ? arr7[0] : arr7[i];
+                const arr8 = a;
+                return arr8.length === 1 ? arr8[0] : arr8[i];
               }),
               index ? index.slice() : void 0
             );
@@ -20657,15 +20729,15 @@ var createLgamma = /* @__PURE__ */ factory(
       0.08333333333333333
     ];
     return typed3(name30, {
-      Array: function(arr7) {
+      Array: function(arr8) {
         const wasm = wasmLoader.getModule();
-        if (wasm && arr7.length >= 100 && arr7.every((x) => typeof x === "number")) {
+        if (wasm && arr8.length >= 100 && arr8.every((x) => typeof x === "number")) {
           try {
-            const input = new Float64Array(arr7);
+            const input = new Float64Array(arr8);
             const inputAlloc = wasmLoader.allocateFloat64Array(input);
-            const resultAlloc = wasmLoader.allocateFloat64ArrayEmpty(arr7.length);
+            const resultAlloc = wasmLoader.allocateFloat64ArrayEmpty(arr8.length);
             try {
-              wasm.lgammaArray(inputAlloc.ptr, arr7.length, resultAlloc.ptr);
+              wasm.lgammaArray(inputAlloc.ptr, arr8.length, resultAlloc.ptr);
               return Array.from(resultAlloc.array);
             } finally {
               wasmLoader.free(inputAlloc.ptr);
@@ -20674,7 +20746,7 @@ var createLgamma = /* @__PURE__ */ factory(
           } catch {
           }
         }
-        return arr7.map((x) => lgammaNumber(x));
+        return arr8.map((x) => lgammaNumber(x));
       },
       number: lgammaNumber,
       Complex: lgammaComplex2,
@@ -21711,8 +21783,8 @@ var createIsBounded = /* @__PURE__ */ factory(
       ),
       "Array | Matrix": typed3.referToSelf(
         (self) => (A) => {
-          const arr7 = Array.isArray(A) ? A : A.valueOf();
-          return arr7.every((entry) => self(entry));
+          const arr8 = Array.isArray(A) ? A : A.valueOf();
+          return arr8.every((entry) => self(entry));
         }
       )
     });
@@ -22048,9 +22120,9 @@ var createUnaryPlus = /* @__PURE__ */ factory(
 
 // src/matrix/dot.ts
 import { pairwiseDot as pairwiseDot2 } from "@danielsimonjr/mathts-core";
-function _isFlatNumbers(arr7) {
-  for (let i = 0; i < arr7.length; i++) {
-    if (typeof arr7[i] !== "number") return false;
+function _isFlatNumbers(arr8) {
+  for (let i = 0; i < arr8.length; i++) {
+    if (typeof arr8[i] !== "number") return false;
   }
   return true;
 }
@@ -22290,9 +22362,9 @@ function improveErrorMessage(err, fnName, value) {
 
 // src/statistics/prod.ts
 var WASM_PROD_THRESHOLD = 100;
-function isFlatNumberArray(arr7) {
-  for (let i = 0; i < arr7.length; i++) {
-    if (typeof arr7[i] !== "number") {
+function isFlatNumberArray(arr8) {
+  for (let i = 0; i < arr8.length; i++) {
+    if (typeof arr8[i] !== "number") {
       return false;
     }
   }
@@ -22810,19 +22882,19 @@ function createZerosAndOnes(name254, defaultValue, { typed: typed3, config: conf
       }
       return m;
     } else {
-      const arr7 = [];
+      const arr8 = [];
       if (size2.length > 0) {
-        return resize(arr7, size2, dflt);
+        return resize(arr8, size2, dflt);
       }
-      return arr7;
+      return arr8;
     }
   }
   function _normalize(size2) {
     let hasBigNumbers = false;
-    size2.forEach(function(value, index, arr7) {
+    size2.forEach(function(value, index, arr8) {
       if (isBigNumber(value)) {
         hasBigNumbers = true;
-        arr7[index] = value.toNumber();
+        arr8[index] = value.toNumber();
       }
     });
     return hasBigNumbers;
@@ -22949,9 +23021,9 @@ var createDiag = /* @__PURE__ */ factory(
 
 // src/matrix/kron.ts
 var WASM_KRON_THRESHOLD = 64;
-function isPlainNumber2D(arr7) {
-  for (let i = 0; i < arr7.length; i++) {
-    const row2 = arr7[i];
+function isPlainNumber2D(arr8) {
+  for (let i = 0; i < arr8.length; i++) {
+    const row2 = arr8[i];
     for (let j = 0; j < row2.length; j++) {
       if (typeof row2[j] !== "number") {
         return false;
@@ -22960,11 +23032,11 @@ function isPlainNumber2D(arr7) {
   }
   return true;
 }
-function flatten2D(arr7, rows, cols) {
+function flatten2D(arr8, 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] = arr7[i][j];
+      result[i * cols + j] = arr8[i][j];
     }
   }
   return result;
@@ -23106,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(arr7) {
-        if (arr7.length === 0) {
+      "...": function(arr8) {
+        if (arr8.length === 0) {
           throw new TypeError("At least one column is needed to construct a matrix.");
         }
-        const allMatrix = arr7.every(
+        const allMatrix = arr8.every(
           (item) => typeof item.toArray === "function"
         );
-        const hasArray = arr7.some((item) => Array.isArray(item));
-        const arrays = arr7.map(
+        const hasArray = arr8.some((item) => Array.isArray(item));
+        const arrays = arr8.map(
           (item) => typeof item.toArray === "function" ? item.toArray() : item
         );
         const result = _createArray(arrays);
@@ -23125,15 +23197,15 @@ var createMatrixFromColumns = /* @__PURE__ */ factory(
       }
       // TODO implement this properly for SparseMatrix
     });
-    function _createArray(arr7) {
-      if (arr7.length === 0)
+    function _createArray(arr8) {
+      if (arr8.length === 0)
         throw new TypeError("At least one column is needed to construct a matrix.");
-      const N = checkVectorTypeAndReturnLength(arr7[0]);
+      const N = checkVectorTypeAndReturnLength(arr8[0]);
       const result = [];
       for (let i = 0; i < N; i++) {
         result[i] = [];
       }
-      for (const col of arr7) {
+      for (const col of arr8) {
         const colLength = checkVectorTypeAndReturnLength(col);
         if (colLength !== N) {
           throw new TypeError(
@@ -23175,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(arr7) {
-        if (arr7.length === 0) {
+      "...": function(arr8) {
+        if (arr8.length === 0) {
           throw new TypeError("At least one row is needed to construct a matrix.");
         }
-        const allMatrix = arr7.every(
+        const allMatrix = arr8.every(
           (item) => typeof item.toArray === "function"
         );
-        const hasArray = arr7.some((item) => Array.isArray(item));
-        const arrays = arr7.map(
+        const hasArray = arr8.some((item) => Array.isArray(item));
+        const arrays = arr8.map(
           (item) => typeof item.toArray === "function" ? item.toArray() : item
         );
         const result = _createArray(arrays);
@@ -23194,12 +23266,12 @@ var createMatrixFromRows = /* @__PURE__ */ factory(
       }
       // TODO implement this properly for SparseMatrix
     });
-    function _createArray(arr7) {
-      if (arr7.length === 0)
+    function _createArray(arr8) {
+      if (arr8.length === 0)
         throw new TypeError("At least one row is needed to construct a matrix.");
-      const N = checkVectorTypeAndReturnLength(arr7[0]);
+      const N = checkVectorTypeAndReturnLength(arr8[0]);
       const result = [];
-      for (const row2 of arr7) {
+      for (const row2 of arr8) {
         const rowLength = checkVectorTypeAndReturnLength(row2);
         if (rowLength !== N) {
           throw new TypeError(
@@ -26211,9 +26283,9 @@ var createResize = /* @__PURE__ */ factory(
         }
         return clone(scalar);
       } else {
-        let arr7 = !Array.isArray(x) ? [x] : x;
-        arr7 = clone(arr7);
-        const res = resize(arr7, sz, defaultValue);
+        let arr8 = !Array.isArray(x) ? [x] : x;
+        arr8 = clone(arr8);
+        const res = resize(arr8, sz, defaultValue);
         return asMatrix ? matrix2(res) : res;
       }
     }
@@ -27111,9 +27183,9 @@ var createZpk2tf = /* @__PURE__ */ factory(
 
 // src/statistics/cumsum.ts
 import { neumaierCumsum as neumaierCumsum2 } from "@danielsimonjr/mathts-core";
-function isFlatNumberArray2(arr7) {
-  for (let i = 0; i < arr7.length; i++) {
-    if (typeof arr7[i] !== "number") {
+function isFlatNumberArray2(arr8) {
+  for (let i = 0; i < arr8.length; i++) {
+    if (typeof arr8[i] !== "number") {
       return false;
     }
   }
@@ -27210,9 +27282,9 @@ var createCumSum = /* @__PURE__ */ factory(
 
 // src/statistics/sum.ts
 import { pairwiseSum as pairwiseSum2 } from "@danielsimonjr/mathts-core";
-function isFlatNumberArray3(arr7) {
-  for (let i = 0; i < arr7.length; i++) {
-    if (typeof arr7[i] !== "number") {
+function isFlatNumberArray3(arr8) {
+  for (let i = 0; i < arr8.length; i++) {
+    if (typeof arr8[i] !== "number") {
       return false;
     }
   }
@@ -30066,9 +30138,9 @@ var createComposition = /* @__PURE__ */ factory(
 
 // src/matrix/partitionSelect.ts
 var WASM_PARTITION_SELECT_THRESHOLD = 100;
-function isFlatNumberArray4(arr7) {
-  for (let i = 0; i < arr7.length; i++) {
-    if (typeof arr7[i] !== "number") {
+function isFlatNumberArray4(arr8) {
+  for (let i = 0; i < arr8.length; i++) {
+    if (typeof arr8[i] !== "number") {
       return false;
     }
   }
@@ -30110,28 +30182,28 @@ var createPartitionSelect = /* @__PURE__ */ factory(
       }
       return quickSelect2(x, k, compare3);
     }
-    function quickSelect2(arr7, k, compare3) {
-      if (k >= arr7.length) {
+    function quickSelect2(arr8, k, compare3) {
+      if (k >= arr8.length) {
         throw new Error("k out of bounds");
       }
-      for (let i = 0; i < arr7.length; i++) {
-        if (isNumeric2(arr7[i]) && mathIsNaN(arr7[i])) {
-          return arr7[i];
+      for (let i = 0; i < arr8.length; i++) {
+        if (isNumeric2(arr8[i]) && mathIsNaN(arr8[i])) {
+          return arr8[i];
         }
       }
       const wasm = wasmLoader.getModule();
-      if (wasm && arr7.length >= WASM_PARTITION_SELECT_THRESHOLD && isFlatNumberArray4(arr7)) {
+      if (wasm && arr8.length >= WASM_PARTITION_SELECT_THRESHOLD && isFlatNumberArray4(arr8)) {
         const isAsc = compare3 === asc;
         const isDesc = compare3 === desc;
         if (isAsc || isDesc) {
           try {
-            const effectiveK = isDesc ? arr7.length - 1 - k : k;
-            const data = wasmLoader.allocateFloat64Array(arr7);
-            const work = wasmLoader.allocateFloat64ArrayEmpty(arr7.length);
+            const effectiveK = isDesc ? arr8.length - 1 - k : k;
+            const data = wasmLoader.allocateFloat64Array(arr8);
+            const work = wasmLoader.allocateFloat64ArrayEmpty(arr8.length);
             try {
-              const result = wasm.partitionSelect(data.ptr, arr7.length, effectiveK, work.ptr);
-              for (let i = 0; i < arr7.length; i++) {
-                arr7[i] = work.array[i];
+              const result = wasm.partitionSelect(data.ptr, arr8.length, effectiveK, work.ptr);
+              for (let i = 0; i < arr8.length; i++) {
+                arr8[i] = work.array[i];
               }
               return result;
             } finally {
@@ -30143,22 +30215,22 @@ var createPartitionSelect = /* @__PURE__ */ factory(
         }
       }
       let from = 0;
-      let to3 = arr7.length - 1;
+      let to3 = arr8.length - 1;
       while (from < to3) {
         let r = from;
         let w = to3;
-        const pivot = arr7[Math.floor(Math.random() * (to3 - from + 1)) + from];
+        const pivot = arr8[Math.floor(Math.random() * (to3 - from + 1)) + from];
         while (r < w) {
-          if (compare3(arr7[r], pivot) >= 0) {
-            const tmp = arr7[w];
-            arr7[w] = arr7[r];
-            arr7[r] = tmp;
+          if (compare3(arr8[r], pivot) >= 0) {
+            const tmp = arr8[w];
+            arr8[w] = arr8[r];
+            arr8[r] = tmp;
             --w;
           } else {
             ++r;
           }
         }
-        if (compare3(arr7[r], pivot) > 0) {
+        if (compare3(arr8[r], pivot) > 0) {
           --r;
         }
         if (k <= r) {
@@ -30167,7 +30239,7 @@ var createPartitionSelect = /* @__PURE__ */ factory(
           from = r + 1;
         }
       }
-      return arr7[k];
+      return arr8[k];
     }
   }
 );
@@ -30300,10 +30372,10 @@ var createPinv = /* @__PURE__ */ factory(
     function _isZero(x) {
       return equal2(add2(x, Complex12(1, 1)), add2(0, Complex12(1, 1)));
     }
-    function _isZeros(arr7) {
+    function _isZeros(arr8) {
       return deepEqual3(
-        add2(arr7, Complex12(1, 1)),
-        add2(multiply2(arr7, 0), Complex12(1, 1))
+        add2(arr8, Complex12(1, 1)),
+        add2(multiply2(arr8, 0), Complex12(1, 1))
       );
     }
   }
@@ -30620,11 +30692,11 @@ var createRange = /* @__PURE__ */ factory(
         return _out(_range(start, end, step, includeEnd));
       }
     });
-    function _out(arr7) {
+    function _out(arr8) {
       if (config2.matrix === "Matrix") {
-        return matrix2 ? matrix2(arr7) : noMatrix();
+        return matrix2 ? matrix2(arr8) : noMatrix();
       }
-      return arr7;
+      return arr8;
     }
     function _strRange(str, includeEnd) {
       const r = _parse2(str);
@@ -30921,9 +30993,9 @@ var createEqualText = /* @__PURE__ */ factory(
 
 // src/statistics/max.ts
 var WASM_MAX_THRESHOLD = 100;
-function isFlatNumberArray5(arr7) {
-  for (let i = 0; i < arr7.length; i++) {
-    if (typeof arr7[i] !== "number") {
+function isFlatNumberArray5(arr8) {
+  for (let i = 0; i < arr8.length; i++) {
+    if (typeof arr8[i] !== "number") {
       return false;
     }
   }
@@ -31000,9 +31072,9 @@ var createMax = /* @__PURE__ */ factory(
 
 // src/statistics/min.ts
 var WASM_MIN_THRESHOLD = 100;
-function isFlatNumberArray6(arr7) {
-  for (let i = 0; i < arr7.length; i++) {
-    if (typeof arr7[i] !== "number") {
+function isFlatNumberArray6(arr8) {
+  for (let i = 0; i < arr8.length; i++) {
+    if (typeof arr8[i] !== "number") {
       return false;
     }
   }
@@ -31087,8 +31159,8 @@ var createNullish = /* @__PURE__ */ factory(
     const matAlgo03xDSf = createMatAlgo03xDSf({ typed: typed3 });
     const matAlgo14xDs = createMatAlgo14xDs({ typed: typed3 });
     const matAlgo13xDD = createMatAlgo13xDD({ typed: typed3 });
-    const toMatrix = (arr7) => {
-      return matrix2(arr7);
+    const toMatrix = (arr8) => {
+      return matrix2(arr8);
     };
     return typed3(name180, {
       // Scalar and SparseMatrix-first short-circuit handlers
@@ -31400,11 +31472,11 @@ var createDistance = /* @__PURE__ */ factory(
           throw new TypeError("Invalid Arguments: Try again");
         }
       },
-      Array: function(arr7) {
-        if (!_pairwise(arr7)) {
+      Array: function(arr8) {
+        if (!_pairwise(arr8)) {
           throw new TypeError("Incorrect array format entered for pairwise distance calculation");
         }
-        return _distancePairwise(arr7);
+        return _distancePairwise(arr8);
       }
     });
     function _isNumber(a) {
@@ -31414,15 +31486,15 @@ var createDistance = /* @__PURE__ */ factory(
       if (!Array.isArray(a)) {
         a = _objectToArray(a);
       }
-      const arr7 = a;
-      return _isNumber(arr7[0]) && _isNumber(arr7[1]);
+      const arr8 = a;
+      return _isNumber(arr8[0]) && _isNumber(arr8[1]);
     }
     function _3d(a) {
       if (!Array.isArray(a)) {
         a = _objectToArray(a);
       }
-      const arr7 = a;
-      return _isNumber(arr7[0]) && _isNumber(arr7[1]) && _isNumber(arr7[2]);
+      const arr8 = a;
+      return _isNumber(arr8[0]) && _isNumber(arr8[1]) && _isNumber(arr8[2]);
     }
     function _containsOnlyNumbers(a) {
       if (!Array.isArray(a)) {
@@ -31434,8 +31506,8 @@ var createDistance = /* @__PURE__ */ factory(
       if (!Array.isArray(a)) {
         a = _objectToArray(a);
       }
-      const arr7 = a;
-      return _isNumber(arr7[0]) && _isNumber(arr7[1]) && _isNumber(arr7[2]) && _isNumber(arr7[3]) && _isNumber(arr7[4]) && _isNumber(arr7[5]);
+      const arr8 = a;
+      return _isNumber(arr8[0]) && _isNumber(arr8[1]) && _isNumber(arr8[2]) && _isNumber(arr8[3]) && _isNumber(arr8[4]) && _isNumber(arr8[5]);
     }
     function _objectToArray(o) {
       const keys = Object.keys(o);
@@ -31765,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");
@@ -32754,11 +32826,11 @@ var FAST_FFT_THRESHOLD = 64;
 function isPowerOf23(n) {
   return n > 0 && (n & n - 1) === 0;
 }
-function complexToInterleaved(arr7, _complex) {
-  const n = arr7.length;
+function complexToInterleaved(arr8, _complex) {
+  const n = arr8.length;
   const result = new Float64Array(n * 2);
   for (let i = 0; i < n; i++) {
-    const val = arr7[i];
+    const val = arr8[i];
     if (typeof val === "number") {
       result[i * 2] = val;
       result[i * 2 + 1] = 0;
@@ -32820,40 +32892,40 @@ var createFft = /* @__PURE__ */ factory(
         return matrix2.create(_ndFft(matrix2.valueOf()), matrix2._datatype);
       }
     });
-    function _ndFft(arr7) {
-      const size2 = arraySize(arr7);
-      if (size2.length === 1) return _fft(arr7, size2[0]);
+    function _ndFft(arr8) {
+      const size2 = arraySize(arr8);
+      if (size2.length === 1) return _fft(arr8, size2[0]);
       return _1dFft(
-        arr7.map((slice) => _ndFft(slice)),
+        arr8.map((slice) => _ndFft(slice)),
         0
       );
     }
-    function _1dFft(arr7, dim) {
-      const size2 = arraySize(arr7);
+    function _1dFft(arr8, dim) {
+      const size2 = arraySize(arr8);
       if (dim !== 0) {
         const result = [];
         for (let i = 0; i < size2[0]; i++) {
-          result.push(_1dFft(arr7[i], dim - 1));
+          result.push(_1dFft(arr8[i], dim - 1));
         }
         return result;
       }
-      if (size2.length === 1) return _fft(arr7);
-      function _transpose(arr8) {
-        const size3 = arraySize(arr8);
+      if (size2.length === 1) return _fft(arr8);
+      function _transpose(arr9) {
+        const size3 = arraySize(arr9);
         const result = [];
         for (let j = 0; j < size3[1]; j++) {
           const row2 = [];
           for (let i = 0; i < size3[0]; i++) {
-            row2.push(arr8[i][j]);
+            row2.push(arr9[i][j]);
           }
           result.push(row2);
         }
         return result;
       }
-      return _transpose(_1dFft(_transpose(arr7), 1));
+      return _transpose(_1dFft(_transpose(arr8), 1));
     }
-    function _czt(arr7) {
-      const n = arr7.length;
+    function _czt(arr8) {
+      const n = arr8.length;
       const w = exp2(divideScalar2(multiplyScalar2(-1, multiplyScalar2(I2, tau2)), n));
       const chirp = [];
       for (let i = 1 - n; i < n; i++) {
@@ -32862,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(arr7[i], chirp[n - 1 + i]));
+        xp.push(multiplyScalar2(arr8[i], chirp[n - 1 + i]));
       }
       for (let i = 0; i < N2 - n; i++) {
         xp.push(0);
@@ -32887,11 +32959,11 @@ var createFft = /* @__PURE__ */ factory(
       }
       return ret;
     }
-    function _fft(arr7, len) {
-      const length = len ?? arr7.length;
-      if (length === 1) return [arr7[0]];
-      if (length === arr7.length && length >= FAST_FFT_THRESHOLD && isPowerOf23(length)) {
-        const interleaved = complexToInterleaved(arr7, complex2);
+    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);
         if (interleaved) {
           const real = new Float64Array(length);
           const imag = new Float64Array(length);
@@ -32911,11 +32983,11 @@ var createFft = /* @__PURE__ */ factory(
       if (length % 2 === 0) {
         const ret = [
           ..._fft(
-            arr7.filter((_, i) => i % 2 === 0),
+            arr8.filter((_, i) => i % 2 === 0),
             length / 2
           ),
           ..._fft(
-            arr7.filter((_, i) => i % 2 === 1),
+            arr8.filter((_, i) => i % 2 === 1),
             length / 2
           )
         ];
@@ -32930,7 +33002,7 @@ var createFft = /* @__PURE__ */ factory(
         }
         return ret;
       } else {
-        return _czt(arr7);
+        return _czt(arr8);
       }
     }
   }
@@ -33201,11 +33273,11 @@ var FAST_IFFT_THRESHOLD = 64;
 function isPowerOf24(n) {
   return n > 0 && (n & n - 1) === 0;
 }
-function complexToInterleaved2(arr7, _complex) {
-  const n = arr7.length;
+function complexToInterleaved2(arr8, _complex) {
+  const n = arr8.length;
   const result = new Float64Array(n * 2);
   for (let i = 0; i < n; i++) {
-    const val = arr7[i];
+    const val = arr8[i];
     if (typeof val === "number") {
       result[i * 2] = val;
       result[i * 2 + 1] = 0;
@@ -33233,13 +33305,13 @@ var createIfft = /* @__PURE__ */ factory(
   dependencies200,
   ({ typed: typed3, fft: fft2, dotDivide: dotDivide2, conj: conj3, complex: complex2 }) => {
     return typed3(name200, {
-      "Array | Matrix": function(arr7) {
-        const size2 = isMatrix(arr7) ? arr7.size() : arraySize(arr7);
+      "Array | Matrix": function(arr8) {
+        const size2 = isMatrix(arr8) ? arr8.size() : arraySize(arr8);
         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(arr7) ? arr7.valueOf() : arr7;
+            const arrData = isMatrix(arr8) ? arr8.valueOf() : arr8;
             const interleaved = complexToInterleaved2(arrData, complex2);
             if (interleaved) {
               const real = new Float64Array(length);
@@ -33255,14 +33327,14 @@ var createIfft = /* @__PURE__ */ factory(
                 packed[i * 2 + 1] = out.imag[i];
               }
               const result = interleavedToComplex2(packed, length, complex2);
-              if (isMatrix(arr7)) {
-                return arr7.create(result);
+              if (isMatrix(arr8)) {
+                return arr8.create(result);
               }
               return result;
             }
           }
         }
-        return dotDivide2(conj3(fft2(conj3(arr7))), totalSize);
+        return dotDivide2(conj3(fft2(conj3(arr8))), totalSize);
       }
     });
   }
@@ -34226,51 +34298,51 @@ var createDiff = /* @__PURE__ */ factory(
     number: number2
   }) => {
     return typed3(name210, {
-      "Array | Matrix": function(arr7) {
-        if (isMatrix(arr7)) {
-          return matrix2(_diff(arr7.toArray()));
+      "Array | Matrix": function(arr8) {
+        if (isMatrix(arr8)) {
+          return matrix2(_diff(arr8.toArray()));
         } else {
-          return _diff(arr7);
+          return _diff(arr8);
         }
       },
-      "Array | Matrix, number": function(arr7, dim) {
+      "Array | Matrix, number": function(arr8, dim) {
         if (!isInteger(dim)) throw new RangeError("Dimension must be a whole number");
-        if (isMatrix(arr7)) {
-          return matrix2(_recursive(arr7.toArray(), dim));
+        if (isMatrix(arr8)) {
+          return matrix2(_recursive(arr8.toArray(), dim));
         } else {
-          return _recursive(arr7, dim);
+          return _recursive(arr8, 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) => (arr7, dim) => selfAn(arr7, number2(dim))),
-      "Matrix, BigNumber": typed3.referTo("Matrix,number", (selfMn) => (arr7, dim) => selfMn(arr7, number2(dim)))
+      "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)))
     });
-    function _recursive(arr7, dim) {
-      if (isMatrix(arr7)) {
-        arr7 = arr7.toArray();
+    function _recursive(arr8, dim) {
+      if (isMatrix(arr8)) {
+        arr8 = arr8.toArray();
       }
-      if (!Array.isArray(arr7)) {
+      if (!Array.isArray(arr8)) {
         throw RangeError("Array/Matrix does not have that many dimensions");
       }
       if (dim > 0) {
         const result = [];
-        arr7.forEach((element2) => {
+        arr8.forEach((element2) => {
           result.push(_recursive(element2, dim - 1));
         });
         return result;
       } else if (dim === 0) {
-        return _diff(arr7);
+        return _diff(arr8);
       } else {
         throw RangeError("Cannot have negative dimension");
       }
     }
-    function _diff(arr7) {
+    function _diff(arr8) {
       const result = [];
-      const size2 = arr7.length;
+      const size2 = arr8.length;
       for (let i = 1; i < size2; i++) {
-        result.push(_ElementDiff(arr7[i - 1], arr7[i]));
+        result.push(_ElementDiff(arr8[i - 1], arr8[i]));
       }
       return result;
     }
@@ -35356,21 +35428,21 @@ var createIntersect = /* @__PURE__ */ factory(
       "Array, Array, Array": _AAA,
       "Array, Array, Array, Array": _AAAA,
       "Matrix, Matrix, Matrix": function(x, y, plane) {
-        const arr7 = _AAA(
+        const arr8 = _AAA(
           x.valueOf(),
           y.valueOf(),
           plane.valueOf()
         );
-        return arr7 === null ? null : matrix2(arr7);
+        return arr8 === null ? null : matrix2(arr8);
       },
       "Matrix, Matrix, Matrix, Matrix": function(w, x, y, z) {
-        const arr7 = _AAAA(
+        const arr8 = _AAAA(
           w.valueOf(),
           x.valueOf(),
           y.valueOf(),
           z.valueOf()
         );
-        return arr7 === null ? null : matrix2(arr7);
+        return arr8 === null ? null : matrix2(arr8);
       }
     });
     function _AAA(x, y, plane) {
@@ -35436,13 +35508,13 @@ var createIntersect = /* @__PURE__ */ factory(
         throw new TypeError("Arrays with two or thee dimensional points expected");
       }
     }
-    function _coerceArr(arr7) {
-      if (arr7.length === 1 && Array.isArray(arr7[0])) return arr7[0];
-      if (arr7.length > 1 && Array.isArray(arr7[0])) {
-        if (arr7.every((el) => Array.isArray(el) && el.length === 1))
-          return flatten4(arr7);
+    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);
       }
-      return arr7;
+      return arr8;
     }
     function _2d(x) {
       return x.length === 2 && isNumeric2(x[0]) && isNumeric2(x[1]);
@@ -35582,9 +35654,9 @@ var createIntersect = /* @__PURE__ */ factory(
 
 // src/statistics/mean.ts
 var WASM_MEAN_THRESHOLD = 100;
-function isFlatNumberArray7(arr7) {
-  for (let i = 0; i < arr7.length; i++) {
-    if (typeof arr7[i] !== "number") {
+function isFlatNumberArray7(arr8) {
+  for (let i = 0; i < arr8.length; i++) {
+    if (typeof arr8[i] !== "number") {
       return false;
     }
   }
@@ -35716,9 +35788,9 @@ var createMedian = /* @__PURE__ */ factory(
 
 // src/statistics/variance.ts
 import { sumSquaredDeviations as sumSquaredDeviations2 } from "@danielsimonjr/mathts-core";
-function isFlatNumberArray8(arr7) {
-  for (let i = 0; i < arr7.length; i++) {
-    if (typeof arr7[i] !== "number") {
+function isFlatNumberArray8(arr8) {
+  for (let i = 0; i < arr8.length; i++) {
+    if (typeof arr8[i] !== "number") {
       return false;
     }
   }
@@ -36033,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;
@@ -36043,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);
       }
     });
   }
@@ -37102,7 +37174,7 @@ var createZeta = /* @__PURE__ */ factory(
     multiply: multiply2,
     pow: pow2,
     divide: divide2,
-    factorial: factorial4,
+    factorial: factorial5,
     equal: equal2,
     smallerEq: smallerEq2,
     isBounded: isBounded2,
@@ -37180,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);
       }
@@ -37259,12 +37331,12 @@ function createComplexEigs({
   matrixFromColumns: _matrixFromColumns,
   dot: dot5
 }) {
-  function complexEigs(arr7, N, prec, type, findVectors = true) {
+  function complexEigs(arr8, N, prec, type, findVectors = true) {
     if (!findVectors && type === "number" && N * N >= WASM_EIGS_THRESHOLD) {
       const wasm = wasmLoader.getModule();
       if (wasm) {
         try {
-          const flat = flattenToFloat648(arr7, N, N);
+          const flat = flattenToFloat648(arr8, N, N);
           const matrixAlloc = wasmLoader.allocateFloat64Array(flat);
           const eigenvaluesRealAlloc = wasmLoader.allocateFloat64ArrayEmpty(N);
           const eigenvaluesImagAlloc = wasmLoader.allocateFloat64ArrayEmpty(N);
@@ -37308,16 +37380,16 @@ function createComplexEigs({
         }
       }
     }
-    const R = balance(arr7, N, prec, type, findVectors);
-    reduceToHessenberg(arr7, N, prec, type, findVectors, R);
-    const { values, C } = iterateUntilTriangular(arr7, N, prec, type, findVectors);
+    const R = balance(arr8, N, prec, type, findVectors);
+    reduceToHessenberg(arr8, N, prec, type, findVectors, R);
+    const { values, C } = iterateUntilTriangular(arr8, N, prec, type, findVectors);
     if (findVectors) {
-      const eigenvectors = findEigenvectors(arr7, N, C, R, values, prec, type);
+      const eigenvectors = findEigenvectors(arr8, N, C, R, values, prec, type);
       return { values, eigenvectors };
     }
     return { values };
   }
-  function balance(arr7, N, _prec, type, findVectors) {
+  function balance(arr8, N, _prec, type, findVectors) {
     const big = type === "BigNumber";
     const cplx = type === "Complex";
     const realzero = big ? bignumber2(0) : 0;
@@ -37337,8 +37409,8 @@ function createComplexEigs({
         let rowNorm = realzero;
         for (let j = 0; j < N; j++) {
           if (i === j) continue;
-          colNorm = addScalar2(colNorm, abs2(arr7[j][i]));
-          rowNorm = addScalar2(rowNorm, abs2(arr7[i][j]));
+          colNorm = addScalar2(colNorm, abs2(arr8[j][i]));
+          rowNorm = addScalar2(rowNorm, abs2(arr8[i][j]));
         }
         if (!equal2(colNorm, 0) && !equal2(rowNorm, 0)) {
           let f = realone;
@@ -37364,8 +37436,8 @@ function createComplexEigs({
               if (i === j) {
                 continue;
               }
-              arr7[i][j] = multiplyScalar2(arr7[i][j], g);
-              arr7[j][i] = multiplyScalar2(arr7[j][i], f);
+              arr8[i][j] = multiplyScalar2(arr8[i][j], g);
+              arr8[j][i] = multiplyScalar2(arr8[j][i], f);
             }
             if (findVectors) {
               Rdiag[i] = multiplyScalar2(Rdiag[i], g);
@@ -37376,7 +37448,7 @@ function createComplexEigs({
     }
     return findVectors ? diag2(Rdiag) : null;
   }
-  function reduceToHessenberg(arr7, N, prec, type, findVectors, R) {
+  function reduceToHessenberg(arr8, N, prec, type, findVectors, R) {
     const big = type === "BigNumber";
     const cplx = type === "Complex";
     const zero = big ? bignumber2(0) : cplx ? complex2(0) : 0;
@@ -37387,7 +37459,7 @@ function createComplexEigs({
       let maxIndex = 0;
       let max2 = zero;
       for (let j = i + 1; j < N; j++) {
-        const el = arr7[j][i];
+        const el = arr8[j][i];
         if (smaller2(abs2(max2), abs2(el))) {
           max2 = el;
           maxIndex = j;
@@ -37397,13 +37469,13 @@ function createComplexEigs({
         continue;
       }
       if (maxIndex !== i + 1) {
-        const tmp1 = arr7[maxIndex];
-        arr7[maxIndex] = arr7[i + 1];
-        arr7[i + 1] = tmp1;
+        const tmp1 = arr8[maxIndex];
+        arr8[maxIndex] = arr8[i + 1];
+        arr8[i + 1] = tmp1;
         for (let j = 0; j < N; j++) {
-          const tmp2 = arr7[j][maxIndex];
-          arr7[j][maxIndex] = arr7[j][i + 1];
-          arr7[j][i + 1] = tmp2;
+          const tmp2 = arr8[j][maxIndex];
+          arr8[j][maxIndex] = arr8[j][i + 1];
+          arr8[j][i + 1] = tmp2;
         }
         if (findVectors) {
           const tmp3 = R[maxIndex];
@@ -37412,15 +37484,15 @@ function createComplexEigs({
         }
       }
       for (let j = i + 2; j < N; j++) {
-        const n = divideScalar2(arr7[j][i], max2);
+        const n = divideScalar2(arr8[j][i], max2);
         if (n === 0) {
           continue;
         }
         for (let k = 0; k < N; k++) {
-          arr7[j][k] = subtract2(arr7[j][k], multiplyScalar2(n, arr7[i + 1][k]));
+          arr8[j][k] = subtract2(arr8[j][k], multiplyScalar2(n, arr8[i + 1][k]));
         }
         for (let k = 0; k < N; k++) {
-          arr7[k][i + 1] = addScalar2(arr7[k][i + 1], multiplyScalar2(n, arr7[k][j]));
+          arr8[k][i + 1] = addScalar2(arr8[k][i + 1], multiplyScalar2(n, arr8[k][j]));
         }
         if (findVectors) {
           for (let k = 0; k < N; k++) {
@@ -37437,7 +37509,7 @@ function createComplexEigs({
     if (big) {
       prec = bignumber2(prec);
     }
-    let arr7 = clone(A);
+    let arr8 = clone(A);
     const lambdas = [];
     let n = N;
     const Sdiag = [];
@@ -37446,21 +37518,21 @@ function createComplexEigs({
     let lastConvergenceBefore = 0;
     while (lastConvergenceBefore <= 100) {
       lastConvergenceBefore += 1;
-      const k = arr7[n - 1][n - 1];
+      const k = arr8[n - 1][n - 1];
       for (let i = 0; i < n; i++) {
-        arr7[i][i] = subtract2(arr7[i][i], k);
+        arr8[i][i] = subtract2(arr8[i][i], k);
       }
-      const { Q: Q2, R } = qr2(arr7);
-      arr7 = multiply2(R, Q2);
+      const { Q: Q2, R } = qr2(arr8);
+      arr8 = multiply2(R, Q2);
       for (let i = 0; i < n; i++) {
-        arr7[i][i] = addScalar2(arr7[i][i], k);
+        arr8[i][i] = addScalar2(arr8[i][i], k);
       }
       if (findVectors) {
         Qpartial = multiply2(Qpartial, Q2);
       }
-      if (n === 1 || smaller2(abs2(arr7[n - 1][n - 2]), prec)) {
+      if (n === 1 || smaller2(abs2(arr8[n - 1][n - 2]), prec)) {
         lastConvergenceBefore = 0;
-        lambdas.push(arr7[n - 1][n - 1]);
+        lambdas.push(arr8[n - 1][n - 1]);
         if (findVectors) {
           Sdiag.unshift([[1]]);
           inflateMatrix(Qpartial, N);
@@ -37470,26 +37542,26 @@ function createComplexEigs({
           }
         }
         n -= 1;
-        arr7.pop();
+        arr8.pop();
         for (let i = 0; i < n; i++) {
-          arr7[i].pop();
+          arr8[i].pop();
         }
-      } else if (n === 2 || smaller2(abs2(arr7[n - 2][n - 3]), prec)) {
+      } else if (n === 2 || smaller2(abs2(arr8[n - 2][n - 3]), prec)) {
         lastConvergenceBefore = 0;
         const ll = eigenvalues2x2(
-          arr7[n - 2][n - 2],
-          arr7[n - 2][n - 1],
-          arr7[n - 1][n - 2],
-          arr7[n - 1][n - 1]
+          arr8[n - 2][n - 2],
+          arr8[n - 2][n - 1],
+          arr8[n - 1][n - 2],
+          arr8[n - 1][n - 1]
         );
         lambdas.push(...ll);
         if (findVectors) {
           Sdiag.unshift(
             jordanBase2x2(
-              arr7[n - 2][n - 2],
-              arr7[n - 2][n - 1],
-              arr7[n - 1][n - 2],
-              arr7[n - 1][n - 1],
+              arr8[n - 2][n - 2],
+              arr8[n - 2][n - 1],
+              arr8[n - 1][n - 2],
+              arr8[n - 1][n - 1],
               ll[0],
               ll[1],
               prec,
@@ -37503,11 +37575,11 @@ function createComplexEigs({
           }
         }
         n -= 2;
-        arr7.pop();
-        arr7.pop();
+        arr8.pop();
+        arr8.pop();
         for (let i = 0; i < n; i++) {
-          arr7[i].pop();
-          arr7[i].pop();
+          arr8[i].pop();
+          arr8[i].pop();
         }
       }
       if (n === 0) {
@@ -37612,23 +37684,23 @@ function createComplexEigs({
       ];
     }
   }
-  function inflateMatrix(arr7, N) {
-    for (let i = 0; i < arr7.length; i++) {
-      arr7[i].push(...Array(N - arr7[i].length).fill(0));
+  function inflateMatrix(arr8, N) {
+    for (let i = 0; i < arr8.length; i++) {
+      arr8[i].push(...Array(N - arr8[i].length).fill(0));
     }
-    for (let i = arr7.length; i < N; i++) {
-      arr7.push(Array(N).fill(0));
-      arr7[i][i] = 1;
+    for (let i = arr8.length; i < N; i++) {
+      arr8.push(Array(N).fill(0));
+      arr8[i][i] = 1;
     }
-    return arr7;
+    return arr8;
   }
-  function blockDiag(arr7, N) {
+  function blockDiag(arr8, N) {
     const M = [];
     for (let i = 0; i < N; i++) {
       M[i] = Array(N).fill(0);
     }
     let I2 = 0;
-    for (const sub of arr7) {
+    for (const sub of arr8) {
       const n = sub.length;
       for (let i = 0; i < n; i++) {
         for (let j = 0; j < n; j++) {
@@ -37639,9 +37711,9 @@ function createComplexEigs({
     }
     return M;
   }
-  function indexOf(arr7, el, fn) {
-    for (let i = 0; i < arr7.length; i++) {
-      if (fn(arr7[i], el)) {
+  function indexOf(arr8, el, fn) {
+    for (let i = 0; i < arr8.length; i++) {
+      if (fn(arr8[i], el)) {
         return i;
       }
     }
@@ -37754,12 +37826,12 @@ function createRealSymmetric({
     if (typeof a === "number" && typeof b === "number") return a <= b;
     return a.lte(b);
   }
-  function main(arr7, _N, prec = config2.relTol, type, computeVectors) {
+  function main(arr8, _N, prec = config2.relTol, type, computeVectors) {
     if (type === "number") {
-      return diag2(arr7, prec, computeVectors);
+      return diag2(arr8, prec, computeVectors);
     }
     if (type === "BigNumber") {
-      return diagBig(arr7, prec, computeVectors);
+      return diagBig(arr8, prec, computeVectors);
     }
     throw TypeError("Unsupported data type: " + type);
   }
@@ -38221,18 +38293,18 @@ var createEigs = /* @__PURE__ */ factory(
       return result;
     }
     function computeValuesAndVectors(mat, prec, computeVectors) {
-      const arr7 = mat.toArray();
+      const arr8 = 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(arr7, N, prec)) {
-        coerceReal(arr7, N);
-        if (isSymmetric(arr7, N, prec)) {
-          const type2 = coerceTypes(mat, arr7, N);
+      if (isReal(arr8, N, prec)) {
+        coerceReal(arr8, N);
+        if (isSymmetric(arr8, N, prec)) {
+          const type2 = coerceTypes(mat, arr8, N);
           return doRealSymmetric(
-            arr7,
+            arr8,
             N,
             prec,
             type2,
@@ -38240,37 +38312,37 @@ var createEigs = /* @__PURE__ */ factory(
           );
         }
       }
-      const type = coerceTypes(mat, arr7, N);
-      return doComplexEigs(arr7, N, prec, type, computeVectors);
+      const type = coerceTypes(mat, arr8, N);
+      return doComplexEigs(arr8, N, prec, type, computeVectors);
     }
-    function isSymmetric(arr7, N, prec) {
+    function isSymmetric(arr8, N, prec) {
       for (let i = 0; i < N; i++) {
         for (let j = i; j < N; j++) {
-          if (larger2(bignumber2(abs2(subtract2(arr7[i][j], arr7[j][i]))), prec)) {
+          if (larger2(bignumber2(abs2(subtract2(arr8[i][j], arr8[j][i]))), prec)) {
             return false;
           }
         }
       }
       return true;
     }
-    function isReal(arr7, N, prec) {
+    function isReal(arr8, N, prec) {
       for (let i = 0; i < N; i++) {
         for (let j = 0; j < N; j++) {
-          if (larger2(bignumber2(abs2(im3(arr7[i][j]))), prec)) {
+          if (larger2(bignumber2(abs2(im3(arr8[i][j]))), prec)) {
             return false;
           }
         }
       }
       return true;
     }
-    function coerceReal(arr7, N) {
+    function coerceReal(arr8, N) {
       for (let i = 0; i < N; i++) {
         for (let j = 0; j < N; j++) {
-          arr7[i][j] = re3(arr7[i][j]);
+          arr8[i][j] = re3(arr8[i][j]);
         }
       }
     }
-    function coerceTypes(mat, arr7, N) {
+    function coerceTypes(mat, arr8, N) {
       const type = mat.datatype();
       if (type === "number" || type === "BigNumber" || type === "Complex") {
         return type;
@@ -38280,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 = arr7[i][j];
+          const el = arr8[i][j];
           if (isNumber(el) || isFraction(el)) {
             hasNumber = true;
           } else if (isBigNumber(el)) {
@@ -38298,7 +38370,7 @@ var createEigs = /* @__PURE__ */ factory(
       if (hasComplex) {
         for (let i = 0; i < N; i++) {
           for (let j = 0; j < N; j++) {
-            arr7[i][j] = complex2(arr7[i][j]);
+            arr8[i][j] = complex2(arr8[i][j]);
           }
         }
         return "Complex";
@@ -38306,7 +38378,7 @@ var createEigs = /* @__PURE__ */ factory(
       if (hasBig) {
         for (let i = 0; i < N; i++) {
           for (let j = 0; j < N; j++) {
-            arr7[i][j] = bignumber2(arr7[i][j]);
+            arr8[i][j] = bignumber2(arr8[i][j]);
           }
         }
         return "BigNumber";
@@ -38314,7 +38386,7 @@ var createEigs = /* @__PURE__ */ factory(
       if (hasNumber) {
         for (let i = 0; i < N; i++) {
           for (let j = 0; j < N; j++) {
-            arr7[i][j] = number2(arr7[i][j]);
+            arr8[i][j] = number2(arr8[i][j]);
           }
         }
         return "number";
@@ -38532,9 +38604,9 @@ var createLusolve = /* @__PURE__ */ factory(
 
 // src/statistics/corr.ts
 import { pairwiseSum as pairwiseSum3, pairwiseDot as pairwiseDot3 } from "@danielsimonjr/mathts-core";
-function isPlainNumberArray(arr7) {
-  for (let i = 0; i < arr7.length; i++) {
-    if (typeof arr7[i] !== "number") {
+function isPlainNumberArray(arr8) {
+  for (let i = 0; i < arr8.length; i++) {
+    if (typeof arr8[i] !== "number") {
       return false;
     }
   }
@@ -38609,9 +38681,9 @@ var createCorr = /* @__PURE__ */ factory(
 
 // src/statistics/mad.ts
 var WASM_MAD_THRESHOLD = 500;
-function isPlainNumberArray2(arr7) {
-  for (let i = 0; i < arr7.length; i++) {
-    if (typeof arr7[i] !== "number") {
+function isPlainNumberArray2(arr8) {
+  for (let i = 0; i < arr8.length; i++) {
+    if (typeof arr8[i] !== "number") {
       return false;
     }
   }
@@ -40208,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 arr7 = x.toArray();
-      const n = arr7.length;
+      const arr8 = x.toArray();
+      const n = arr8.length;
       const data = new Float64Array(n);
       for (let i = 0; i < n; i++) {
-        if (typeof arr7[i] !== "number") return null;
-        data[i] = arr7[i];
+        if (typeof arr8[i] !== "number") return null;
+        data[i] = arr8[i];
       }
       const alloc = wasmLoader.allocateFloat64Array(data);
       try {
@@ -44328,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(arr8, k) {
+  const n = arr8.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(arr8[i]);
+      backtrack(i + 1);
+      combo.pop();
+    }
+  }
+  backtrack(0);
+  return result;
+}
+function permutationsGen(arr8, k = arr8.length) {
+  const n = arr8.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(arr8[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) {
@@ -44515,9 +44843,9 @@ function kendallTau(x, y) {
     }
   }
   const n0 = n * (n - 1) / 2;
-  const tiePairs = (arr7) => {
+  const tiePairs = (arr8) => {
     const counts = /* @__PURE__ */ new Map();
-    for (const v of arr7) counts.set(v, (counts.get(v) ?? 0) + 1);
+    for (const v of arr8) counts.set(v, (counts.get(v) ?? 0) + 1);
     let s = 0;
     for (const c of counts.values()) s += c * (c - 1) / 2;
     return s;
@@ -44604,6 +44932,10 @@ function kendalltau(x, y) {
   const z = 3 * tau2 * Math.sqrt(n * (n - 1)) / Math.sqrt(2 * (2 * n + 5));
   return { coefficient: tau2, pValue: 2 * (1 - normalCDF(Math.abs(z))) };
 }
+function kendallTauTest(x, y) {
+  const { coefficient, pValue } = kendalltau(x, y);
+  return { tau: coefficient, pValue };
+}
 function ptp(x) {
   const a = Array.from(x);
   if (a.length === 0) return NaN;
@@ -45422,39 +45754,6 @@ function acf(x, nlags) {
   return out;
 }
 
-// src/regression-extra.ts
-var arr5 = (x) => Array.isArray(x) ? x : Array.from(x);
-var mean5 = (x) => mean(x);
-function linearRegression(x, y) {
-  const a = arr5(x);
-  const b = arr5(y);
-  const n = a.length;
-  if (b.length !== n) throw new Error(`linearRegression: length mismatch ${n} vs ${b.length}`);
-  if (n < 3)
-    throw new Error("linearRegression: need at least 3 points for a slope significance test");
-  const mx = mean5(a);
-  const my = mean5(b);
-  let sxx = 0;
-  let syy = 0;
-  let sxy = 0;
-  for (let i = 0; i < n; i++) {
-    const dx = a[i] - mx;
-    const dy = b[i] - my;
-    sxx += dx * dx;
-    syy += dy * dy;
-    sxy += dx * dy;
-  }
-  if (sxx === 0) throw new Error("linearRegression: predictor x has zero variance");
-  const slope = sxy / sxx;
-  const intercept = my - slope * mx;
-  const rValue = sxy / Math.sqrt(sxx * syy);
-  const df = n - 2;
-  const stdErr = Math.sqrt((syy - slope * sxy) / df / sxx);
-  const t = slope / stdErr;
-  const pValue = 2 * (1 - studentTCDF(Math.abs(t), df));
-  return { slope, intercept, rValue, rSquared: rValue * rValue, pValue, stdErr };
-}
-
 // src/ml/ols.ts
 function transpose3(m) {
   const rows = m.length;
@@ -45542,6 +45841,155 @@ function ols(X, y, opts) {
   return { coefficients, stderr, tValues, pValues, r2, adjR2, fStat, residuals };
 }
 
+// src/stats/timeseries.ts
+var arr5 = (x) => Array.isArray(x) ? x : Array.from(x);
+function pacf(x, nlags) {
+  const r = acf(x, nlags);
+  const out = new Array(nlags + 1);
+  out[0] = 1;
+  if (nlags === 0) return out;
+  let phiPrev = [];
+  for (let k = 1; k <= nlags; k++) {
+    if (k === 1) {
+      const phi11 = r[1];
+      out[1] = phi11;
+      phiPrev = [phi11];
+      continue;
+    }
+    let num2 = r[k];
+    let den = 1;
+    for (let j = 1; j <= k - 1; j++) {
+      num2 -= phiPrev[j - 1] * r[k - j];
+      den -= phiPrev[j - 1] * r[j];
+    }
+    const phikk = den === 0 ? 0 : num2 / den;
+    const phiCurr = new Array(k);
+    for (let j = 1; j <= k - 1; j++) {
+      phiCurr[j - 1] = phiPrev[j - 1] - phikk * phiPrev[k - 1 - j];
+    }
+    phiCurr[k - 1] = phikk;
+    out[k] = phikk;
+    phiPrev = phiCurr;
+  }
+  return out;
+}
+function ljungBox(x, lags) {
+  const n = x.length;
+  if (lags < 1 || lags >= n)
+    throw new Error(`ljungBox: lags ${lags} out of range for series length ${n}`);
+  const r = acf(x, lags);
+  let sum3 = 0;
+  for (let k = 1; k <= lags; k++) sum3 += r[k] * r[k] / (n - k);
+  const statistic = n * (n + 2) * sum3;
+  const pValue = 1 - chiSquaredCDF(statistic, lags);
+  return { statistic, pValue };
+}
+function durbinWatson(residuals) {
+  const e = arr5(residuals);
+  const n = e.length;
+  if (n < 2) throw new Error("durbinWatson: need at least 2 residuals");
+  let num2 = 0;
+  for (let t = 1; t < n; t++) num2 += (e[t] - e[t - 1]) * (e[t] - e[t - 1]);
+  let den = 0;
+  for (let t = 0; t < n; t++) den += e[t] * e[t];
+  if (den === 0) throw new Error("durbinWatson: residuals have zero variance");
+  return num2 / den;
+}
+var MACKINNON_C = {
+  1: { betaInf: -3.4336, beta1: -5.999, beta2: -29.25 },
+  5: { betaInf: -2.8621, beta1: -2.738, beta2: -8.36 },
+  10: { betaInf: -2.5671, beta1: -1.438, beta2: -4.48 }
+};
+function adfCriticalValue(pct, n) {
+  const { betaInf, beta1, beta2 } = MACKINNON_C[pct];
+  return betaInf + beta1 / n + beta2 / (n * n);
+}
+function adfPValue(statistic, n) {
+  const cv1 = adfCriticalValue(1, n);
+  const cv5 = adfCriticalValue(5, n);
+  const cv10 = adfCriticalValue(10, n);
+  const clamp2 = (p) => Math.min(1, Math.max(0, p));
+  if (statistic <= cv1) {
+    const slope2 = (0.05 - 0.01) / (cv5 - cv1);
+    return clamp2(0.01 + slope2 * (statistic - cv1));
+  }
+  if (statistic <= cv5) {
+    const slope2 = (0.05 - 0.01) / (cv5 - cv1);
+    return clamp2(0.01 + slope2 * (statistic - cv1));
+  }
+  if (statistic <= cv10) {
+    const slope2 = (0.1 - 0.05) / (cv10 - cv5);
+    return clamp2(0.05 + slope2 * (statistic - cv5));
+  }
+  const slope = (0.1 - 0.05) / (cv10 - cv5);
+  return clamp2(0.1 + slope * (statistic - cv10));
+}
+function adfuller(x, maxlag) {
+  const a = arr5(x);
+  const n = a.length;
+  if (n < 4) throw new Error(`adfuller: series too short (length ${n})`);
+  const d = new Array(n - 1);
+  for (let i = 0; i < n - 1; i++) d[i] = a[i + 1] - a[i];
+  let lag = maxlag ?? Math.floor(12 * Math.pow(n / 100, 0.25));
+  lag = Math.max(0, Math.min(lag, n - 4));
+  for (; lag >= 0; lag--) {
+    const rows = n - lag - 1;
+    const params = lag + 2;
+    if (rows <= params) continue;
+    const X = [];
+    const y = [];
+    for (let i = lag; i <= n - 2; i++) {
+      const row2 = [a[i]];
+      for (let j = 1; j <= lag; j++) row2.push(d[i - j]);
+      X.push(row2);
+      y.push(d[i]);
+    }
+    try {
+      const result = ols(X, y);
+      const statistic = result.coefficients[1] / result.stderr[1];
+      if (!Number.isFinite(statistic)) continue;
+      const pValue = adfPValue(statistic, n);
+      return { statistic, pValue, usedLag: lag };
+    } catch {
+      continue;
+    }
+  }
+  throw new Error(`adfuller: could not construct a well-posed regression for series length ${n}`);
+}
+
+// src/regression-extra.ts
+var arr6 = (x) => Array.isArray(x) ? x : Array.from(x);
+var mean5 = (x) => mean(x);
+function linearRegression(x, y) {
+  const a = arr6(x);
+  const b = arr6(y);
+  const n = a.length;
+  if (b.length !== n) throw new Error(`linearRegression: length mismatch ${n} vs ${b.length}`);
+  if (n < 3)
+    throw new Error("linearRegression: need at least 3 points for a slope significance test");
+  const mx = mean5(a);
+  const my = mean5(b);
+  let sxx = 0;
+  let syy = 0;
+  let sxy = 0;
+  for (let i = 0; i < n; i++) {
+    const dx = a[i] - mx;
+    const dy = b[i] - my;
+    sxx += dx * dx;
+    syy += dy * dy;
+    sxy += dx * dy;
+  }
+  if (sxx === 0) throw new Error("linearRegression: predictor x has zero variance");
+  const slope = sxy / sxx;
+  const intercept = my - slope * mx;
+  const rValue = sxy / Math.sqrt(sxx * syy);
+  const df = n - 2;
+  const stdErr = Math.sqrt((syy - slope * sxy) / df / sxx);
+  const t = slope / stdErr;
+  const pValue = 2 * (1 - studentTCDF(Math.abs(t), df));
+  return { slope, intercept, rValue, rSquared: rValue * rValue, pValue, stdErr };
+}
+
 // src/ml/regularized-regression.ts
 function validate(X, y, name254) {
   const n = X.length;
@@ -46188,6 +46636,100 @@ function multipleTest(pValues, method) {
   return adjusted;
 }
 
+// src/stats/fit-distribution.ts
+var LOG_2PI = Math.log(2 * Math.PI);
+function meanOf(data) {
+  return mean(data);
+}
+function popStd(data) {
+  return std(data, "uncorrected");
+}
+function normalLogPdf(x, mu, sigma) {
+  const z = (x - mu) / sigma;
+  return -0.5 * z * z - Math.log(sigma) - 0.5 * LOG_2PI;
+}
+function fitNormal(data) {
+  const mu = meanOf(data);
+  const sigma = popStd(data);
+  let logLikelihood = 0;
+  for (const x of data) logLikelihood += normalLogPdf(x, mu, sigma);
+  return { params: { mean: mu, std: sigma }, logLikelihood };
+}
+function fitExponential(data) {
+  const lambda = 1 / meanOf(data);
+  let logLikelihood = 0;
+  for (const x of data) logLikelihood += Math.log(lambda) - lambda * x;
+  return { params: { lambda }, logLikelihood };
+}
+function fitLognormal(data) {
+  for (const x of data) {
+    if (!(x > 0)) {
+      throw new Error("fitDistribution: lognormal requires all data > 0");
+    }
+  }
+  const logData = data.map((x) => Math.log(x));
+  const mu = meanOf(logData);
+  const sigma = popStd(logData);
+  let logLikelihood = 0;
+  for (const x of data) {
+    logLikelihood += normalLogPdf(Math.log(x), mu, sigma) - Math.log(x);
+  }
+  return { params: { mu, sigma }, logLikelihood };
+}
+function logFactorial(k) {
+  return lgamma(k + 1);
+}
+function fitPoisson(data) {
+  const lambda = meanOf(data);
+  let logLikelihood = 0;
+  for (const k of data) logLikelihood += -lambda + k * Math.log(lambda) - logFactorial(k);
+  return { params: { lambda }, logLikelihood };
+}
+function gammaLogPdf(x, shape, scale) {
+  return (shape - 1) * Math.log(x) - x / scale - lgamma(shape) - shape * Math.log(scale);
+}
+function fitGamma(data) {
+  for (const x of data) {
+    if (!(x > 0)) {
+      throw new Error("fitDistribution: gamma requires all data > 0");
+    }
+  }
+  const xbar = meanOf(data);
+  const meanLog = meanOf(data.map((x) => Math.log(x)));
+  const s = Math.log(xbar) - meanLog;
+  if (!(s > 0)) {
+    throw new Error("fitDistribution: gamma requires data with positive spread (s <= 0)");
+  }
+  const k0 = (3 - s + Math.sqrt((s - 3) * (s - 3) + 24 * s)) / (12 * s);
+  const f = (k) => Math.log(k) - digamma(k) - s;
+  const shape = secant(f, k0, k0 * 1.1, { tol: 1e-12, maxIter: 200 });
+  const scale = xbar / shape;
+  let logLikelihood = 0;
+  for (const x of data) logLikelihood += gammaLogPdf(x, shape, scale);
+  return { params: { shape, scale }, logLikelihood };
+}
+function fitDistribution(name254, data) {
+  if (data.length === 0) {
+    throw new Error("fitDistribution: data must be non-empty");
+  }
+  switch (name254) {
+    case "normal":
+      return fitNormal(data);
+    case "exponential":
+      return fitExponential(data);
+    case "lognormal":
+      return fitLognormal(data);
+    case "poisson":
+      return fitPoisson(data);
+    case "gamma":
+      return fitGamma(data);
+    default: {
+      const _exhaustive = name254;
+      throw new Error(`fitDistribution: unknown distribution '${_exhaustive}'`);
+    }
+  }
+}
+
 // src/numeric/bfgs.ts
 var CBRT_EPS = Math.cbrt(2220446049250313e-31);
 function numericGradient(f, x) {
@@ -46563,7 +47105,7 @@ function symbolicIntegral(expr, variable = "x") {
 // src/signal-filter-extra.ts
 import { Complex as Complex11 } from "@danielsimonjr/mathts-core";
 var _inv3 = inv;
-var arr6 = (x) => Array.isArray(x) ? x : Array.from(x);
+var arr7 = (x) => Array.isArray(x) ? x : Array.from(x);
 var sinc = (x) => x === 0 ? 1 : Math.sin(Math.PI * x) / (Math.PI * x);
 function firwin(numtaps, cutoff) {
   if (!Number.isInteger(numtaps) || numtaps < 2)
@@ -46600,10 +47142,10 @@ function lfilterState(b, a, x, zi) {
   return { y, zf: z };
 }
 function lfilter(b, a, x) {
-  return lfilterState(arr6(b), arr6(a), arr6(x)).y;
+  return lfilterState(arr7(b), arr7(a), arr7(x)).y;
 }
 function lfilterZi(b, a) {
-  const { b: bb, a: aa, n } = padCoeffs(arr6(b), arr6(a));
+  const { b: bb, a: aa, n } = padCoeffs(arr7(b), arr7(a));
   if (n < 2) return [];
   const C = companion(aa);
   const M = Array.from(
@@ -46623,9 +47165,9 @@ function lfilterZi(b, a) {
   return zi;
 }
 function filtfilt(b, a, x) {
-  const bb = arr6(b);
-  const aa = arr6(a);
-  const xx = arr6(x);
+  const bb = arr7(b);
+  const aa = arr7(a);
+  const xx = arr7(x);
   const n = xx.length;
   const ntaps = Math.max(aa.length, bb.length);
   const pad = 3 * ntaps;
@@ -46748,6 +47290,326 @@ function quaternionToRotationMatrix(q) {
     [2 * (x * z - y * w), 2 * (y * z + x * w), 1 - 2 * (x * x + y * y)]
   ];
 }
+
+// src/stats/inference-extra2.ts
+var TWO_PI = 2 * Math.PI;
+function noncentralChi2CDF(x, df, nc) {
+  if (df <= 0) throw new Error("noncentralChi2CDF: df must be positive");
+  if (nc < 0) throw new Error("noncentralChi2CDF: nc must be non-negative");
+  if (x <= 0) return 0;
+  const halfNc = nc / 2;
+  let sum3 = 0;
+  let poissonCum = 0;
+  let logWeight = -halfNc;
+  for (let j = 0; j < 2e3; j++) {
+    const weight = Math.exp(logWeight);
+    sum3 += weight * chiSquaredCDF(x, df + 2 * j);
+    poissonCum += weight;
+    if (j > halfNc && 1 - poissonCum < 1e-12) break;
+    logWeight += Math.log(halfNc) - Math.log(j + 1);
+  }
+  return sum3;
+}
+function noncentralFCDF(x, dfn, dfd, nc) {
+  if (dfn <= 0 || dfd <= 0) throw new Error("noncentralFCDF: dfn and dfd must be positive");
+  if (nc < 0) throw new Error("noncentralFCDF: nc must be non-negative");
+  if (x <= 0) return 0;
+  const halfNc = nc / 2;
+  let sum3 = 0;
+  let poissonCum = 0;
+  let logWeight = -halfNc;
+  for (let j = 0; j < 2e3; j++) {
+    const weight = Math.exp(logWeight);
+    const dfnj = dfn + 2 * j;
+    sum3 += weight * fCDF(x * dfn / dfnj, dfnj, dfd);
+    poissonCum += weight;
+    if (j > halfNc && 1 - poissonCum < 1e-12) break;
+    logWeight += Math.log(halfNc) - Math.log(j + 1);
+  }
+  return sum3;
+}
+function noncentralTCDF(t, df, nc) {
+  if (df <= 0) throw new Error("noncentralTCDF: df must be positive");
+  const chi2 = chiSquaredDist(df);
+  const std2 = normalDist();
+  const upper = df + 40 * Math.sqrt(2 * Math.max(df, 1)) + 100;
+  const panels = 2e4;
+  const a = 1e-10;
+  const h = (upper - a) / panels;
+  const integrand = (v) => {
+    if (v <= 0) return 0;
+    const z = t * Math.sqrt(v / df) - nc;
+    return std2.cdf(z) * chi2.pdf(v);
+  };
+  let sum3 = integrand(a) + integrand(upper);
+  for (let i = 1; i < panels; i++) {
+    const v = a + i * h;
+    sum3 += (i % 2 === 0 ? 2 : 4) * integrand(v);
+  }
+  return h / 3 * sum3;
+}
+function circularSums(angles, opts) {
+  const { high = TWO_PI, low = 0 } = opts;
+  const scale = TWO_PI / (high - low);
+  let sinSum = 0;
+  let cosSum = 0;
+  for (const a of angles) {
+    const theta = (a - low) * scale;
+    sinSum += Math.sin(theta);
+    cosSum += Math.cos(theta);
+  }
+  return { sinSum, cosSum, scale };
+}
+function circmean(angles, opts = {}) {
+  const { low = 0 } = opts;
+  const { sinSum, cosSum, scale } = circularSums(angles, opts);
+  let mean7 = Math.atan2(sinSum, cosSum);
+  if (mean7 < 0) mean7 += TWO_PI;
+  return mean7 / scale + low;
+}
+function circvar(angles, opts = {}) {
+  const n = angles.length;
+  if (n === 0) throw new Error("circvar: angles must be non-empty");
+  const { sinSum, cosSum } = circularSums(angles, opts);
+  const R = Math.hypot(cosSum, sinSum) / n;
+  return 1 - R;
+}
+function circstd(angles, opts = {}) {
+  const n = angles.length;
+  if (n === 0) throw new Error("circstd: angles must be non-empty");
+  const { sinSum, cosSum } = circularSums(angles, opts);
+  const R = Math.hypot(cosSum, sinSum) / n;
+  return Math.sqrt(-2 * Math.log(R));
+}
+function vonMisesPDF(theta, mu, kappa) {
+  if (kappa < 0) throw new Error("vonMisesPDF: kappa must be non-negative");
+  return Math.exp(kappa * Math.cos(theta - mu)) / (TWO_PI * besselIScalar(0, kappa));
+}
+function mcnemar(table, opts = {}) {
+  if (table.length !== 2 || table[0].length !== 2 || table[1].length !== 2) {
+    throw new Error("mcnemar: table must be 2x2");
+  }
+  const b = table[0][1];
+  const c = table[1][0];
+  const correction = opts.correction !== false;
+  const denom = b + c;
+  const diff2 = Math.max(0, Math.abs(b - c) - (correction ? 1 : 0));
+  const chi2 = denom > 0 ? diff2 * diff2 / denom : 0;
+  const pValue = 1 - chiSquaredCDF(chi2, 1);
+  return { chi2, pValue };
+}
+function cochranQ(data) {
+  const n = data.length;
+  if (n === 0) throw new Error("cochranQ: data must have at least one row");
+  const k = data[0].length;
+  if (k < 2) throw new Error("cochranQ: need at least 2 treatments (columns)");
+  const colSums = new Array(k).fill(0);
+  const rowSums = new Array(n).fill(0);
+  let N = 0;
+  for (let i = 0; i < n; i++) {
+    if (data[i].length !== k) throw new Error("cochranQ: data must be rectangular");
+    let rowSum = 0;
+    for (let j = 0; j < k; j++) {
+      colSums[j] += data[i][j];
+      rowSum += data[i][j];
+    }
+    rowSums[i] = rowSum;
+    N += rowSum;
+  }
+  let sumC2 = 0;
+  for (let j = 0; j < k; j++) sumC2 += colSums[j] * colSums[j];
+  let sumR2 = 0;
+  for (let i = 0; i < n; i++) sumR2 += rowSums[i] * rowSums[i];
+  const dof = k - 1;
+  const denominator = k * N - sumR2;
+  const Q2 = denominator !== 0 ? dof * (k * sumC2 - N * N) / denominator : 0;
+  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/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/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,
@@ -46770,6 +47632,7 @@ export {
   acsch,
   add,
   addScalar,
+  adfuller,
   adjacencyMatrix,
   airyAi,
   airyBi,
@@ -46866,15 +47729,20 @@ export {
   chineseRemainder,
   chirpZTransform,
   cholesky,
+  circmean,
+  circstd,
   circulant,
+  circvar,
   clamp,
   classicalElectronRadius,
   clearAssumptions,
   clone3 as clone,
+  cochranQ,
   coefficientList,
   collect,
   column,
   combinations,
+  combinationsGen,
   combinationsWithRep,
   combine,
   companion,
@@ -46892,6 +47760,7 @@ export {
   config,
   conj,
   connectedComponents,
+  continuedFraction,
   convexHull,
   convexHull3D,
   convolve,
@@ -46950,6 +47819,7 @@ export {
   digamma,
   directionalDerivative,
   disableGpu,
+  discreteLog,
   discreteUniformDist,
   discriminant,
   distance,
@@ -46970,6 +47840,7 @@ export {
   dotPow,
   doubleFactorial,
   dst,
+  durbinWatson,
   dwt,
   efimovFactor,
   eigenvectorCentrality,
@@ -46996,6 +47867,7 @@ export {
   erfc,
   erfcScalar,
   erfi,
+  eulerNumbers,
   eulerPhi,
   evaluate,
   eventDetection,
@@ -47094,6 +47966,7 @@ export {
   firstRadiation,
   firwin,
   fisherExact,
+  fitDistribution,
   fix,
   flatten3 as flatten,
   floor,
@@ -47124,6 +47997,7 @@ export {
   gaussQuad,
   gaussianKDE,
   gcd,
+  gegenbauerC,
   generalizedEig,
   geometricPMF,
   getAssumptions,
@@ -47163,6 +48037,9 @@ export {
   histogram,
   hmean,
   hotellingT2,
+  hyp0f1,
+  hyp1f1,
+  hyp2f1,
   hypergeometricDist,
   hypot,
   idct,
@@ -47202,6 +48079,10 @@ export {
   isPositive,
   isPrime,
   isZero,
+  jacobiCN,
+  jacobiDN,
+  jacobiP,
+  jacobiSN,
   jacobiSymbol,
   jacobian,
   jarqueBera,
@@ -47211,6 +48092,7 @@ export {
   kdTree,
   kdTreeNearest,
   kendallTau,
+  kendallTauTest,
   kendalltau,
   kldivergence,
   klitzing,
@@ -47220,6 +48102,7 @@ export {
   kolmogorovSmirnov2Test,
   kolmogorovSmirnovTest,
   kron,
+  kroneckerSymbol,
   kruskalWallis,
   kurtosis,
   lagrangeInterp,
@@ -47251,6 +48134,7 @@ export {
   linprog,
   linregress,
   linsolve,
+  ljungBox,
   loess,
   log,
   log10,
@@ -47299,6 +48183,7 @@ export {
   max,
   maxSelect,
   maximize,
+  mcnemar,
   mean,
   meanCI,
   medfilt,
@@ -47324,6 +48209,7 @@ export {
   multinomial,
   multipleComparison,
   multipleTest,
+  multiplicativeOrder,
   multiply,
   multiplyScalar,
   multivariateNormal,
@@ -47338,7 +48224,10 @@ export {
   nintegrate,
   nnls,
   nodeOperations,
+  noncentralChi2CDF,
   noncentralChi2PDF,
+  noncentralFCDF,
+  noncentralTCDF,
   norm,
   norm22 as norm2,
   normFro,
@@ -47364,6 +48253,8 @@ export {
   or,
   orth,
   outer,
+  pFq,
+  pacf,
   padeApproximant,
   pageRank,
   parallelAutoCorr,
@@ -47404,6 +48295,7 @@ export {
   periodogram,
   permutationTest,
   permutations,
+  permutationsGen,
   pickRandom,
   piecewise,
   pinv,
@@ -47420,6 +48312,7 @@ export {
   polyFit,
   polyadd,
   polyder,
+  polygamma,
   polygonArea,
   polygonPerimeter,
   polymul,
@@ -47435,6 +48328,7 @@ export {
   prime,
   primeFactors,
   primePi,
+  primitiveRoot,
   principalComponentAnalysis,
   print,
   prod,
@@ -47484,6 +48378,7 @@ export {
   risingFactorial,
   romberg,
   root,
+  rootsLegendre,
   rotate,
   rotateVector2D,
   rotateVector3D,
@@ -47555,6 +48450,7 @@ export {
   std,
   stefanBoltzmann,
   stiffODESolver,
+  stirlingS1,
   stirlingS2,
   string,
   stronglyConnectedComponents,
@@ -47604,6 +48500,7 @@ export {
   trigExpand,
   trigReduce,
   trigToExp,
+  trigamma,
   tril,
   trimmedMean,
   triu,
@@ -47640,6 +48537,7 @@ export {
   variables,
   variance,
   variation,
+  vonMisesPDF,
   voronoiDiagram,
   weakMixingAngle,
   weibullDist,