@danielsimonjr/mathts-functions 0.35.0 → 0.37.0

package/dist/index.js

@@ -9930,7 +9930,143 @@ function substitute(expr, vars) {
   }
   return result;
 }
+function isNearInt(c) {
+  return Math.abs(c - Math.round(c)) < 1e-7;
+}
+function polyToDense(p) {
+  let maxPow = 0;
+  for (const t of p) maxPow = Math.max(maxPow, t.powers[0] ?? 0);
+  const dense = new Array(maxPow + 1).fill(0);
+  for (const t of p) dense[t.powers[0]] += t.coeff;
+  return trimPoly(dense);
+}
+function denseToPoly(coeffs) {
+  return coeffs.map((coeff, i) => ({ coeff, powers: [i] })).filter((t) => Math.abs(t.coeff) > 1e-10);
+}
+function divisorsOf(n) {
+  const m = Math.abs(Math.round(n)) || 1;
+  const divs = [];
+  for (let i = 1; i <= m; i++) if (m % i === 0) divs.push(i);
+  return divs;
+}
+function ratReduce(r) {
+  let { n, d } = r;
+  if (d < 0) {
+    n = -n;
+    d = -d;
+  }
+  const g = gcdNum(Math.abs(n), Math.abs(d)) || 1;
+  return { n: n / g, d: d / g };
+}
+function ratPolyval(coeffs, r) {
+  let acc = { n: 0, d: 1 };
+  for (let i = coeffs.length - 1; i >= 0; i--) {
+    acc = ratReduce({
+      n: acc.n * r.n + coeffs[i] * acc.d * r.d,
+      d: acc.d * r.d
+    });
+  }
+  return acc;
+}
+function findRationalLinearFactors(poly) {
+  let cur = trimPoly(poly.map((c) => Math.round(c)));
+  const roots = [];
+  let repeated = false;
+  const hasRoot = (r) => roots.some((x) => x.n === r.n && x.d === r.d);
+  for (; ; ) {
+    const deg = cur.length - 1;
+    if (deg < 1) break;
+    if (cur[0] === 0) {
+      const r = { n: 0, d: 1 };
+      if (hasRoot(r)) repeated = true;
+      roots.push(r);
+      cur = trimPoly(cur.slice(1));
+      continue;
+    }
+    const ps = divisorsOf(cur[0]);
+    const qs = divisorsOf(cur[cur.length - 1]);
+    let found = null;
+    let quotient = null;
+    outer: for (const q of qs) {
+      for (const pAbs of ps) {
+        for (const sign3 of [1, -1]) {
+          const candidate = ratReduce({ n: sign3 * pAbs, d: q });
+          const divisor = trimPoly([-candidate.n, candidate.d]);
+          const rem = polynomialRemainder(cur, divisor);
+          if (rem.length === 1 && Math.abs(rem[0]) < 1e-6) {
+            found = candidate;
+            quotient = polynomialQuotient(cur, divisor).map((c) => Math.round(c * 1e6) / 1e6);
+            break outer;
+          }
+        }
+      }
+    }
+    if (!found || !quotient) break;
+    if (hasRoot(found)) repeated = true;
+    roots.push(found);
+    cur = trimPoly(quotient);
+  }
+  return { roots, remainder: cur, repeated };
+}
+function formatLinearFactor(r, varName) {
+  const base = r.d === 1 ? varName : `${r.d}*${varName}`;
+  if (r.n === 0) return `(${base})`;
+  return r.n > 0 ? `(${base} - ${r.n})` : `(${base} + ${-r.n})`;
+}
+function formatPartialTerm(a, root2, varName) {
+  const rootExpr = root2.d === 1 ? root2.n === 0 ? varName : root2.n > 0 ? `${varName} - ${root2.n}` : `${varName} + ${-root2.n}` : `${varName} - ${root2.n}/${root2.d}`;
+  const denomExpr = a.d === 1 ? `(${rootExpr})` : `(${a.d}*(${rootExpr}))`;
+  if (a.n === 1) return `1/${denomExpr}`;
+  if (a.n === -1) return `-1/${denomExpr}`;
+  return `${a.n}/${denomExpr}`;
+}
+function splitTopLevelSum(expr) {
+  const s = expr.replace(/\s+/g, "");
+  const terms = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (c === "(") depth++;
+    else if (c === ")") depth--;
+    else if (depth === 0 && (c === "+" || c === "-") && i > start) {
+      const prev = s[i - 1];
+      if (!/[*/^(+-]/.test(prev)) {
+        terms.push(s.slice(start, i));
+        start = i;
+      }
+    }
+  }
+  terms.push(s.slice(start));
+  return terms.filter((t) => t !== "");
+}
+function splitProductChain(term) {
+  const nums = [];
+  const dens = [];
+  let depth = 0;
+  let start = 0;
+  let op = "*";
+  for (let i = 0; i <= term.length; i++) {
+    const c = term[i];
+    if (c === "(") depth++;
+    else if (c === ")") depth--;
+    if (depth === 0 && (c === "*" || c === "/" || i === term.length)) {
+      const piece = term.slice(start, i).trim();
+      if (piece !== "") (op === "*" ? nums : dens).push(piece);
+      if (i < term.length) op = c;
+      start = i + 1;
+    }
+  }
+  return { nums, dens };
+}
 function expand(expr) {
+  const univariateVars = variables(expr);
+  if (univariateVars.length === 1) {
+    try {
+      return polyToString(polyFromExpression(expr, univariateVars), univariateVars);
+    } catch {
+    }
+  }
   let result = expr;
   result = result.replace(/\(([^()]+)\)\^2/g, "($1)*($1)");
   const splitTerms = (factor2) => factor2.replace(/\s*-\s*/g, " + -").split(/\s*\+\s*/).map((t) => t.trim()).filter((t) => t !== "");
@@ -9951,6 +10087,27 @@ function expand(expr) {
   return result;
 }
 function factor(expr) {
+  const univariateVars = variables(expr);
+  if (univariateVars.length === 1) {
+    try {
+      const v = univariateVars[0];
+      const dense = polyToDense(polyFromExpression(expr, [v]));
+      if (degree(dense) >= 2 && dense.every(isNearInt)) {
+        const intDense = dense.map((c) => Math.round(c));
+        const { roots, remainder } = findRationalLinearFactors(intDense);
+        if (roots.length > 0) {
+          const factors = roots.map((r) => formatLinearFactor(r, v));
+          if (degree(remainder) >= 1) {
+            factors.push(`(${polyToString(denseToPoly(remainder), [v])})`);
+          } else if (remainder[0] !== 1) {
+            factors.unshift(String(remainder[0]));
+          }
+          return factors.join("*");
+        }
+      }
+    } catch {
+    }
+  }
   const normalized = expr.replace(/\s*-\s*/g, " + -");
   const terms = normalized.split(/\s*\+\s*/).filter((t) => t.trim() !== "");
   if (terms.length < 2) return expr;
@@ -10027,6 +10184,49 @@ function collect(expr, variable) {
 function cancel(expr) {
   const sameMatch = expr.match(/^\s*\(([^()]+)\)\s*\/\s*\(\s*\1\s*\)\s*$/);
   if (sameMatch && sameMatch[1].trim().length > 0) return "1";
+  const univariateVars = variables(expr);
+  if (univariateVars.length === 1) {
+    try {
+      const v = univariateVars[0];
+      const cleaned = expr.replace(/\s+/g, "");
+      const topTerms = splitTopLevelSum(cleaned);
+      if (topTerms.length === 1) {
+        const { nums, dens } = splitProductChain(topTerms[0]);
+        if (dens.length > 0) {
+          const numStr = nums.length ? nums.join("*") : "1";
+          const denStr = dens.join("*");
+          const N = polyToDense(polyFromExpression(numStr, [v]));
+          const D = polyToDense(polyFromExpression(denStr, [v]));
+          if (N.every(isNearInt) && D.every(isNearInt)) {
+            const Nint = N.map((c) => Math.round(c));
+            const Dint = D.map((c) => Math.round(c));
+            const g = polynomialGCD(Nint, Dint);
+            if (degree(g) >= 1) {
+              let Nq = polynomialQuotient(Nint, g).map((c) => Math.round(c * 1e6) / 1e6);
+              let Dq = polynomialQuotient(Dint, g).map((c) => Math.round(c * 1e6) / 1e6);
+              let contentGcd = 0;
+              for (const c of [...Nq, ...Dq]) contentGcd = gcdNum(contentGcd, Math.round(c));
+              if (contentGcd > 1) {
+                Nq = Nq.map((c) => c / contentGcd);
+                Dq = Dq.map((c) => c / contentGcd);
+              }
+              if (Dq[Dq.length - 1] < 0) {
+                Nq = Nq.map((c) => -c);
+                Dq = Dq.map((c) => -c);
+              }
+              if (degree(Dq) === 0) {
+                const c = Dq[0];
+                if (c !== 1) Nq = Nq.map((x) => x / c);
+                return polyToString(denseToPoly(Nq), [v]);
+              }
+              return `(${polyToString(denseToPoly(Nq), [v])})/(${polyToString(denseToPoly(Dq), [v])})`;
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
   const fracMatch = expr.match(/^\s*(-?\d+)\s*\/\s*(-?\d+)\s*$/);
   if (fracMatch) {
     const num2 = parseInt(fracMatch[1], 10);
@@ -10053,6 +10253,25 @@ function cancel(expr) {
   return expr;
 }
 function together(expr) {
+  const univariateVars = variables(expr);
+  if (univariateVars.length === 1) {
+    try {
+      const v = univariateVars[0];
+      const terms = splitTopLevelSum(expr).map(splitProductChain);
+      const denParts = terms.flatMap((t) => t.dens);
+      if (denParts.length > 0) {
+        const denominatorStr = denParts.map((d) => `(${d})`).join("*");
+        const numeratorExpr = terms.map((t, i) => {
+          const otherDens = terms.flatMap((t2, j) => j === i ? [] : t2.dens);
+          const parts = [...t.nums, ...otherDens].map((p) => `(${p})`);
+          return parts.length ? parts.join("*") : "1";
+        }).join(" + ");
+        const numeratorStr = polyToString(polyFromExpression(numeratorExpr, [v]), [v]);
+        return `(${numeratorStr})/(${denominatorStr})`;
+      }
+    } catch {
+    }
+  }
   const match = expr.match(/^\s*(-?\d+)\s*\/\s*(-?\d+)\s*\+\s*(-?\d+)\s*\/\s*(-?\d+)\s*$/);
   if (match) {
     const a = parseInt(match[1], 10);
@@ -10067,6 +10286,52 @@ function together(expr) {
   return expr;
 }
 function apart(expr) {
+  const univariateVars = variables(expr);
+  if (univariateVars.length === 1) {
+    try {
+      const v = univariateVars[0];
+      const topTerms = splitTopLevelSum(expr);
+      if (topTerms.length === 1) {
+        const { nums, dens } = splitProductChain(topTerms[0]);
+        if (dens.length > 0) {
+          const numStr = nums.length ? nums.join("*") : "1";
+          const denStr = dens.join("*");
+          const N = polyToDense(polyFromExpression(numStr, [v]));
+          const D = polyToDense(polyFromExpression(denStr, [v]));
+          if (degree(D) >= 1 && N.every(isNearInt) && D.every(isNearInt)) {
+            let Nint = N.map((c) => Math.round(c));
+            const Dint = D.map((c) => Math.round(c));
+            let quotientPrefix = "";
+            if (degree(Nint) >= degree(Dint)) {
+              const q = polynomialQuotient(Nint, Dint);
+              const r = polynomialRemainder(Nint, Dint);
+              if (degree(r) === 0 && r[0] === 0) {
+                return polyToString(denseToPoly(q), [v]);
+              }
+              quotientPrefix = `${polyToString(denseToPoly(q), [v])} + `;
+              Nint = r.map((c) => Math.round(c));
+            }
+            const { roots, remainder, repeated } = findRationalLinearFactors(Dint);
+            if (!repeated && degree(remainder) === 0 && roots.length === degree(Dint)) {
+              const Dprime = polyder(Dint);
+              const termStrs = roots.map((root2) => {
+                const nAtRoot = ratPolyval(Nint, root2);
+                const dAtRoot = ratPolyval(Dprime, root2);
+                if (dAtRoot.n === 0) throw new Error("apart: derivative vanished at root");
+                const a = ratReduce({
+                  n: nAtRoot.n * dAtRoot.d,
+                  d: nAtRoot.d * dAtRoot.n
+                });
+                return formatPartialTerm(a, root2, v);
+              });
+              return (quotientPrefix + termStrs.join(" + ")).replace(/\+ -/g, "- ");
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
   const match = expr.match(/^\s*(-?\d+)\s*\/\s*(-?\d+)\s*$/);
   if (match) {
     const num2 = parseInt(match[1], 10);
@@ -12731,15 +12996,15 @@ function solveODESystem(f, y0, tspan, opts) {
 function stiffODESolver(f, y0, tspan) {
   return rosenbrockSolve((t, y) => f(t, y), tspan, y0, { tol: 1e-7 });
 }
-function solveBVP(f, bc, mesh) {
-  const n = 2;
+function solveBVP(f, bc, mesh, y0Guess = [0, 0]) {
+  const n = y0Guess.length;
   const tspan = [mesh[0], mesh[mesh.length - 1]];
   function shoot(guess) {
     const sol = solveODESystem(f, guess, tspan, { dt: (tspan[1] - tspan[0]) / 50 });
     const yf = sol.y[sol.y.length - 1];
     return bc(guess, yf);
   }
-  const s = new Array(n).fill(0);
+  const s = y0Guess.slice();
   const delta = 1e-7;
   for (let iter = 0; iter < 50; iter++) {
     const r = shoot(s);
@@ -15496,6 +15761,71 @@ var logisticPDF = (x, mu = 0, s = 1) => {
 var logisticCDF = (x, mu = 0, s = 1) => 1 / (1 + Math.exp(-(x - mu) / s));
 var logisticQuantile = (p, mu = 0, s = 1) => mu + s * Math.log(p / (1 - p));
 
+// src/stats/inference-extra.ts
+function chi2Contingency(table, opts = {}) {
+  const rows = table.length;
+  if (rows < 2) throw new Error("chi2Contingency: table needs at least 2 rows");
+  const cols = table[0].length;
+  if (cols < 2) throw new Error("chi2Contingency: table needs at least 2 columns");
+  for (const row2 of table) {
+    if (row2.length !== cols) throw new Error("chi2Contingency: table must be rectangular");
+  }
+  const rowTotals = new Array(rows).fill(0);
+  const colTotals = new Array(cols).fill(0);
+  let total = 0;
+  for (let i = 0; i < rows; i++) {
+    for (let j = 0; j < cols; j++) {
+      const v = table[i][j];
+      rowTotals[i] += v;
+      colTotals[j] += v;
+      total += v;
+    }
+  }
+  if (total <= 0) throw new Error("chi2Contingency: table sum must be positive");
+  const expected = Array.from({ length: rows }, () => new Array(cols).fill(0));
+  const applyCorrection = rows === 2 && cols === 2 && opts.correction !== false;
+  let chi2 = 0;
+  for (let i = 0; i < rows; i++) {
+    for (let j = 0; j < cols; j++) {
+      const e = rowTotals[i] * colTotals[j] / total;
+      expected[i][j] = e;
+      if (e <= 0) continue;
+      const o = table[i][j];
+      const diff2 = applyCorrection ? Math.max(0, Math.abs(o - e) - 0.5) : o - e;
+      chi2 += diff2 * diff2 / e;
+    }
+  }
+  const dof = (rows - 1) * (cols - 1);
+  const pValue = 1 - chiSquaredCDF(chi2, dof);
+  const cramersV = Math.sqrt(chi2 / (total * Math.min(rows - 1, cols - 1)));
+  return { chi2, pValue, dof, expected, cramersV };
+}
+function multipleTest(pValues, method) {
+  const n = pValues.length;
+  if (n === 0) return [];
+  if (method === "bonferroni") {
+    return pValues.map((p) => Math.min(1, p * n));
+  }
+  const order = pValues.map((_, i) => i).sort((a, b) => pValues[a] - pValues[b]);
+  const adjusted = new Array(n);
+  if (method === "holm") {
+    let running2 = 0;
+    for (let rank2 = 0; rank2 < n; rank2++) {
+      const idx = order[rank2];
+      running2 = Math.max(running2, (n - rank2) * pValues[idx]);
+      adjusted[idx] = Math.min(1, running2);
+    }
+    return adjusted;
+  }
+  let running = 1;
+  for (let rank2 = n - 1; rank2 >= 0; rank2--) {
+    const idx = order[rank2];
+    running = Math.min(running, n / (rank2 + 1) * pValues[idx]);
+    adjusted[idx] = Math.min(1, running);
+  }
+  return adjusted;
+}
+
 // src/typed/hypothesis.ts
 var HYPOTHESIS_THRESHOLD = 4096;
 function _makeMulberry322(seed) {
@@ -16365,7 +16695,7 @@ function _median(arr10) {
   const m = n >> 1;
   return n % 2 === 1 ? s[m] : (s[m - 1] + s[m]) / 2;
 }
-function leveneTest(groups, center2 = "median") {
+function leveneTest(groups, center3 = "median") {
   const k = groups.length;
   if (k < 2) throw new Error("leveneTest: need at least 2 groups");
   let N = 0;
@@ -16374,7 +16704,7 @@ function leveneTest(groups, center2 = "median") {
     N += g.length;
   }
   const z = groups.map((g) => {
-    const c = center2 === "median" ? _median(g) : _mean(g);
+    const c = center3 === "median" ? _median(g) : _mean(g);
     return g.map((x) => Math.abs(x - c));
   });
   const allZ = [];
@@ -16596,27 +16926,7 @@ function anova2(data) {
   };
 }
 function multipleComparison(pValues, method = "bh") {
-  const m = pValues.length;
-  if (m === 0) return [];
-  if (method === "bonferroni") return pValues.map((p) => Math.min(p * m, 1));
-  const order = pValues.map((_, i) => i).sort((i, j) => pValues[i] - pValues[j]);
-  const out = new Array(m);
-  if (method === "holm") {
-    let running = 0;
-    for (let rank2 = 0; rank2 < m; rank2++) {
-      const idx = order[rank2];
-      running = Math.max(running, (m - rank2) * pValues[idx]);
-      out[idx] = Math.min(running, 1);
-    }
-  } else {
-    let prev = 1;
-    for (let rank2 = m - 1; rank2 >= 0; rank2--) {
-      const idx = order[rank2];
-      prev = Math.min(prev, pValues[idx] * m / (rank2 + 1));
-      out[idx] = Math.min(prev, 1);
-    }
-  }
-  return out;
+  return multipleTest(pValues, method);
 }
 function meanCI(data, confidence = 0.95) {
   const n = data.length;
@@ -23175,7 +23485,7 @@ var dependencies92 = ["typed", "matrix", "flatten", "size"];
 var createMatrixFromColumns = /* @__PURE__ */ factory(
   name92,
   dependencies92,
-  ({ typed: typed3, matrix: matrix2, flatten: flatten4, size: size2 }) => {
+  ({ typed: typed3, matrix: matrix2, flatten: flatten5, size: size2 }) => {
     return typed3(name92, {
       // Single variadic handler for arrays, matrices, and mixed types
       "...": function(arr10) {
@@ -23212,7 +23522,7 @@ var createMatrixFromColumns = /* @__PURE__ */ factory(
             "The vectors had different length: " + (N | 0) + " \u2260 " + (colLength | 0)
           );
         }
-        const f = flatten4(col);
+        const f = flatten5(col);
         for (let i = 0; i < N; i++) {
           result[i].push(f[i]);
         }
@@ -23244,7 +23554,7 @@ var dependencies93 = ["typed", "matrix", "flatten", "size"];
 var createMatrixFromRows = /* @__PURE__ */ factory(
   name93,
   dependencies93,
-  ({ typed: typed3, matrix: matrix2, flatten: flatten4, size: size2 }) => {
+  ({ typed: typed3, matrix: matrix2, flatten: flatten5, size: size2 }) => {
     return typed3(name93, {
       // Single variadic handler for arrays, matrices, and mixed types
       "...": function(arr10) {
@@ -23278,7 +23588,7 @@ var createMatrixFromRows = /* @__PURE__ */ factory(
             "The vectors had different length: " + (N | 0) + " \u2260 " + (rowLength | 0)
           );
         }
-        result.push(flatten4(row2));
+        result.push(flatten5(row2));
       }
       return result;
     }
@@ -32299,13 +32609,13 @@ var createUtil = /* @__PURE__ */ factory(
       }
       return merged;
     }
-    function flatten4(node, context = defaultContext) {
+    function flatten5(node, context = defaultContext) {
       if (!node.args || node.args.length === 0) {
         return;
       }
       node.args = allChildren(node, context);
       for (let i = 0; i < node.args.length; i++) {
-        flatten4(node.args[i], context);
+        flatten5(node.args[i], context);
       }
     }
     function allChildren(node, context) {
@@ -32385,7 +32695,7 @@ var createUtil = /* @__PURE__ */ factory(
       isCommutative,
       isAssociative,
       mergeContext,
-      flatten: flatten4,
+      flatten: flatten5,
       allChildren,
       unflattenr,
       unflattenl,
@@ -35420,7 +35730,7 @@ var createIntersect = /* @__PURE__ */ factory(
     subtract: subtract3,
     smaller: smaller2,
     equalScalar: equalScalar3,
-    flatten: flatten4,
+    flatten: flatten5,
     isZero: isZero2,
     isNumeric: isNumeric2
   }) => {
@@ -35512,7 +35822,7 @@ var createIntersect = /* @__PURE__ */ factory(
       if (arr10.length === 1 && Array.isArray(arr10[0])) return arr10[0];
       if (arr10.length > 1 && Array.isArray(arr10[0])) {
         if (arr10.every((el) => Array.isArray(el) && el.length === 1))
-          return flatten4(arr10);
+          return flatten5(arr10);
       }
       return arr10;
     }
@@ -37310,7 +37620,7 @@ function flattenToFloat648(matrix2, rows, cols) {
 function createComplexEigs({
   addScalar: addScalar2,
   subtract: subtract3,
-  flatten: flatten4,
+  flatten: flatten5,
   multiply: multiply2,
   multiplyScalar: multiplyScalar2,
   divideScalar: divideScalar2,
@@ -37639,7 +37949,7 @@ function createComplexEigs({
       solutions = solutions.map(
         (v) => multiply2(correction, v)
       );
-      vectors.push(...solutions.map((v) => ({ value: lambda, vector: flatten4(v) })));
+      vectors.push(...solutions.map((v) => ({ value: lambda, vector: flatten5(v) })));
     }
     return vectors;
   }
@@ -38184,7 +38494,7 @@ var createEigs = /* @__PURE__ */ factory(
     add: add3,
     larger: larger2,
     column: _column,
-    flatten: flatten4,
+    flatten: flatten5,
     number: number2,
     complex: complex3,
     sqrt: sqrt2,
@@ -38220,7 +38530,7 @@ var createEigs = /* @__PURE__ */ factory(
       subtract: subtract3,
       multiply: multiply2,
       multiplyScalar: multiplyScalar2,
-      flatten: flatten4,
+      flatten: flatten5,
       divideScalar: divideScalar2,
       sqrt: sqrt2,
       abs: abs2,
@@ -38868,7 +39178,7 @@ var createSimplify = /* @__PURE__ */ factory(
       isCommutative,
       isAssociative,
       mergeContext,
-      flatten: flatten4,
+      flatten: flatten5,
       unflattenr,
       unflattenl,
       createMakeNodeFunction,
@@ -39180,7 +39490,7 @@ var createSimplify = /* @__PURE__ */ factory(
         );
         const expandsym = _getExpandPlaceholderSymbol();
         const expandedL = makeNode([newRule.l, expandsym]);
-        flatten4(expandedL, context);
+        flatten5(expandedL, context);
         unflattenr(expandedL, context);
         newRule.expanded = {
           l: expandedL,
@@ -39267,7 +39577,7 @@ var createSimplify = /* @__PURE__ */ factory(
             if (debug)
               rulestr = builtRules[i].name;
           } else {
-            flatten4(res, options.context);
+            flatten5(res, options.context);
             res = applyRule(res, builtRules[i], options.context);
             if (debug) {
               rulestr = `${builtRules[i].l.toString()} -> ${builtRules[i].r.toString()}`;
@@ -45474,7 +45784,7 @@ function hessian(f, x, h = 1e-4) {
 }
 
 // src/index.ts
-import { svd as svd3 } from "@danielsimonjr/mathts-matrix";
+import { svd as svd4 } from "@danielsimonjr/mathts-matrix";
 
 // src/linalg-svd-extra.ts
 import { svd as svd2 } from "@danielsimonjr/mathts-matrix";
@@ -46776,6 +47086,87 @@ function minimizeScalar(f, opts) {
   return { x, fval: fx };
 }
 
+// src/numeric/interpn.ts
+function flattenND(values, shape) {
+  const total = shape.reduce((a, b) => a * b, 1);
+  const flat = new Float64Array(total);
+  let pos = 0;
+  function walk(v, depth) {
+    if (depth === shape.length) {
+      if (typeof v !== "number") {
+        throw new Error(
+          `interpn: values is nested deeper than grids.length (${shape.length} dimensions)`
+        );
+      }
+      flat[pos++] = v;
+      return;
+    }
+    if (!Array.isArray(v) || v.length !== shape[depth]) {
+      const gotLen = Array.isArray(v) ? v.length : "scalar";
+      throw new Error(
+        `interpn: values shape mismatch at dimension ${depth} (expected length ${shape[depth]}, got ${gotLen})`
+      );
+    }
+    for (const item of v) walk(item, depth + 1);
+  }
+  walk(values, 0);
+  return flat;
+}
+function locateOnAxis(grid, x) {
+  const n = grid.length;
+  if (x < grid[0] || x > grid[n - 1]) {
+    throw new Error(`interpn: query value ${x} is out of bounds [${grid[0]}, ${grid[n - 1]}]`);
+  }
+  if (n === 1) return { i: 0, t: 0 };
+  let lo = 0;
+  let hi = n - 1;
+  while (hi - lo > 1) {
+    const mid = lo + hi >> 1;
+    if (grid[mid] <= x) lo = mid;
+    else hi = mid;
+  }
+  const denom = grid[lo + 1] - grid[lo];
+  const t = denom === 0 ? 0 : (x - grid[lo]) / denom;
+  return { i: lo, t };
+}
+function interpn(grids, values, query) {
+  if (grids.length === 0) throw new Error("interpn: at least one grid axis is required");
+  for (const grid of grids) {
+    if (grid.length < 2) throw new Error("interpn: each grid axis needs at least 2 points");
+    for (let i = 1; i < grid.length; i++) {
+      if (!(grid[i] > grid[i - 1])) {
+        throw new Error("interpn: each grid axis must be strictly increasing");
+      }
+    }
+  }
+  const dims = grids.length;
+  const shape = grids.map((g) => g.length);
+  const flat = flattenND(values, shape);
+  const strides = new Array(dims);
+  strides[dims - 1] = 1;
+  for (let d = dims - 2; d >= 0; d--) strides[d] = strides[d + 1] * shape[d + 1];
+  const numCorners = 1 << dims;
+  return query.map((q) => {
+    if (q.length !== dims) {
+      throw new Error(`interpn: query point has ${q.length} coordinates, expected ${dims}`);
+    }
+    const locs = grids.map((g, d) => locateOnAxis(g, q[d]));
+    let result = 0;
+    for (let corner = 0; corner < numCorners; corner++) {
+      let weight = 1;
+      let flatIndex = 0;
+      for (let d = 0; d < dims; d++) {
+        const bit = corner >> d & 1;
+        const { i, t } = locs[d];
+        weight *= bit ? t : 1 - t;
+        flatIndex += (i + bit) * strides[d];
+      }
+      if (weight !== 0) result += weight * flat[flatIndex];
+    }
+    return result;
+  });
+}
+
 // src/timeseries-extra.ts
 var arr4 = (x) => Array.isArray(x) ? x : Array.from(x);
 var mean4 = (x) => mean(x);
@@ -47661,71 +48052,6 @@ function gaussianKDE(samples, opts = {}) {
   return { evaluate: evaluate3, bandwidth };
 }
 
-// src/stats/inference-extra.ts
-function chi2Contingency(table, opts = {}) {
-  const rows = table.length;
-  if (rows < 2) throw new Error("chi2Contingency: table needs at least 2 rows");
-  const cols = table[0].length;
-  if (cols < 2) throw new Error("chi2Contingency: table needs at least 2 columns");
-  for (const row2 of table) {
-    if (row2.length !== cols) throw new Error("chi2Contingency: table must be rectangular");
-  }
-  const rowTotals = new Array(rows).fill(0);
-  const colTotals = new Array(cols).fill(0);
-  let total = 0;
-  for (let i = 0; i < rows; i++) {
-    for (let j = 0; j < cols; j++) {
-      const v = table[i][j];
-      rowTotals[i] += v;
-      colTotals[j] += v;
-      total += v;
-    }
-  }
-  if (total <= 0) throw new Error("chi2Contingency: table sum must be positive");
-  const expected = Array.from({ length: rows }, () => new Array(cols).fill(0));
-  const applyCorrection = rows === 2 && cols === 2 && opts.correction !== false;
-  let chi2 = 0;
-  for (let i = 0; i < rows; i++) {
-    for (let j = 0; j < cols; j++) {
-      const e = rowTotals[i] * colTotals[j] / total;
-      expected[i][j] = e;
-      if (e <= 0) continue;
-      const o = table[i][j];
-      const diff2 = applyCorrection ? Math.max(0, Math.abs(o - e) - 0.5) : o - e;
-      chi2 += diff2 * diff2 / e;
-    }
-  }
-  const dof = (rows - 1) * (cols - 1);
-  const pValue = 1 - chiSquaredCDF(chi2, dof);
-  const cramersV = Math.sqrt(chi2 / (total * Math.min(rows - 1, cols - 1)));
-  return { chi2, pValue, dof, expected, cramersV };
-}
-function multipleTest(pValues, method) {
-  const n = pValues.length;
-  if (n === 0) return [];
-  if (method === "bonferroni") {
-    return pValues.map((p) => Math.min(1, p * n));
-  }
-  const order = pValues.map((_, i) => i).sort((a, b) => pValues[a] - pValues[b]);
-  const adjusted = new Array(n);
-  if (method === "holm") {
-    let running2 = 0;
-    for (let rank2 = 0; rank2 < n; rank2++) {
-      const idx = order[rank2];
-      running2 = Math.max(running2, (n - rank2) * pValues[idx]);
-      adjusted[idx] = Math.min(1, running2);
-    }
-    return adjusted;
-  }
-  let running = 1;
-  for (let rank2 = n - 1; rank2 >= 0; rank2--) {
-    const idx = order[rank2];
-    running = Math.min(running, n / (rank2 + 1) * pValues[idx]);
-    adjusted[idx] = Math.min(1, running);
-  }
-  return adjusted;
-}
-
 // src/stats/fit-distribution.ts
 var LOG_2PI = Math.log(2 * Math.PI);
 function meanOf(data) {
@@ -49239,9 +49565,9 @@ function waverec(coeffs, wavelet = "haar") {
 function rickerWavelet(points, scale3) {
   const amplitude = 2 / (Math.sqrt(3 * scale3) * Math.pow(Math.PI, 0.25));
   const out = new Array(points);
-  const center2 = (points - 1) / 2;
+  const center3 = (points - 1) / 2;
   for (let i = 0; i < points; i++) {
-    const t = (i - center2) / scale3;
+    const t = (i - center3) / scale3;
     const t2 = t * t;
     out[i] = amplitude * (1 - t2) * Math.exp(-t2 / 2);
   }
@@ -49250,9 +49576,9 @@ function rickerWavelet(points, scale3) {
 function morletWavelet(points, scale3) {
   const norm4 = 1 / (Math.sqrt(scale3) * Math.pow(Math.PI, 0.25));
   const out = new Array(points);
-  const center2 = (points - 1) / 2;
+  const center3 = (points - 1) / 2;
   for (let i = 0; i < points; i++) {
-    const t = (i - center2) / scale3;
+    const t = (i - center3) / scale3;
     out[i] = norm4 * Math.cos(5 * t) * Math.exp(-(t * t) / 2);
   }
   return out;
@@ -49532,6 +49858,170 @@ function quaternionToRotationMatrix(q) {
   ];
 }
 
+// src/geometry/geometry-extra.ts
+import { svd as svd3 } from "@danielsimonjr/mathts-matrix";
+function dot42(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
+}
+function quaternionInverse(q) {
+  const magSq = dot42(q, q);
+  if (magSq === 0) throw new Error("quaternionInverse: zero-magnitude quaternion");
+  return quaternionConjugate(q).map((v) => v / magSq);
+}
+function quaternionSlerp(q1, q2, t) {
+  const a = q1;
+  let b = q2;
+  let d = dot42(a, b);
+  if (d < 0) {
+    d = -d;
+    b = b.map((v) => -v);
+  }
+  const DOT_THRESHOLD = 0.9995;
+  if (d > DOT_THRESHOLD) {
+    const lerp = a.map((v, i) => v + t * (b[i] - v));
+    const m = Math.sqrt(dot42(lerp, lerp)) || 1;
+    return lerp.map((v) => v / m);
+  }
+  const clamped = d > 1 ? 1 : d < -1 ? -1 : d;
+  const theta0 = Math.acos(clamped);
+  const theta = theta0 * t;
+  const sinTheta0 = Math.sin(theta0);
+  const sinTheta = Math.sin(theta);
+  const s0 = Math.cos(theta) - d * sinTheta / sinTheta0;
+  const s1 = sinTheta / sinTheta0;
+  return a.map((v, i) => s0 * v + s1 * b[i]);
+}
+function quaternionToEuler(q) {
+  const [w, x, y, z] = q;
+  const roll = Math.atan2(2 * (w * x + y * z), 1 - 2 * (x * x + y * y));
+  const sinp = 2 * (w * y - z * x);
+  const pitch = Math.asin(sinp > 1 ? 1 : sinp < -1 ? -1 : sinp);
+  const yaw = Math.atan2(2 * (w * z + x * y), 1 - 2 * (y * y + z * z));
+  return [roll, pitch, yaw];
+}
+function boundingBox(points) {
+  if (points.length === 0) throw new Error("boundingBox: requires at least one point");
+  const dims = points[0].length;
+  const min2 = points[0].slice();
+  const max2 = points[0].slice();
+  for (let i = 1; i < points.length; i++) {
+    const p = points[i];
+    for (let d = 0; d < dims; d++) {
+      if (p[d] < min2[d]) min2[d] = p[d];
+      if (p[d] > max2[d]) max2[d] = p[d];
+    }
+  }
+  return { min: min2, max: max2 };
+}
+function columnMean(A) {
+  const n = A.length;
+  const d = A[0]?.length ?? 0;
+  const mean7 = new Array(d).fill(0);
+  for (const row2 of A) {
+    for (let j = 0; j < d; j++) mean7[j] += row2[j] / n;
+  }
+  return mean7;
+}
+function center2(A, mean7) {
+  return A.map((row2) => row2.map((v, j) => v - mean7[j]));
+}
+function frobeniusNorm(A) {
+  let sum3 = 0;
+  for (const row2 of A) for (const v of row2) sum3 += v * v;
+  return Math.sqrt(sum3);
+}
+function matTranspose(A) {
+  const rows = A.length;
+  const cols = A[0]?.length ?? 0;
+  const T = Array.from({ length: cols }, () => new Array(rows).fill(0));
+  for (let i = 0; i < rows; i++) for (let j = 0; j < cols; j++) T[j][i] = A[i][j];
+  return T;
+}
+function matMul2(A, B) {
+  const rows = A.length;
+  const inner = B.length;
+  const cols = B[0]?.length ?? 0;
+  const C = Array.from({ length: rows }, () => new Array(cols).fill(0));
+  for (let i = 0; i < rows; i++) {
+    for (let k = 0; k < inner; k++) {
+      const a = A[i][k];
+      if (a === 0) continue;
+      for (let j = 0; j < cols; j++) C[i][j] += a * B[k][j];
+    }
+  }
+  return C;
+}
+function procrustes(A, B) {
+  if (A.length !== B.length || A.length === 0) {
+    throw new Error("procrustes: A and B must have the same non-zero number of rows");
+  }
+  const A0raw = center2(A, columnMean(A));
+  const B0raw = center2(B, columnMean(B));
+  const nA = frobeniusNorm(A0raw) || 1;
+  const nB = frobeniusNorm(B0raw) || 1;
+  const A0 = A0raw.map((row2) => row2.map((v) => v / nA));
+  const B0 = B0raw.map((row2) => row2.map((v) => v / nB));
+  const M = matMul2(matTranspose(A0), B0);
+  const { U, S, V } = svd3(M);
+  const R = matMul2(V, matTranspose(U));
+  const scale3 = S.reduce((s, v) => s + v, 0);
+  const transformed = matMul2(B0, R).map((row2) => row2.map((v) => v * scale3));
+  let disparity = 0;
+  for (let i = 0; i < A0.length; i++) {
+    for (let j = 0; j < A0[i].length; j++) {
+      const diff2 = A0[i][j] - transformed[i][j];
+      disparity += diff2 * diff2;
+    }
+  }
+  return { R, scale: scale3, disparity };
+}
+function euclideanDist(a, b) {
+  let sum3 = 0;
+  for (let i = 0; i < a.length; i++) {
+    const d = a[i] - b[i];
+    sum3 += d * d;
+  }
+  return Math.sqrt(sum3);
+}
+function kdTreeKNN(points, query, k) {
+  const ranked = points.map((p, i) => ({ i, d: euclideanDist(p, query) }));
+  ranked.sort((a, b) => a.d - b.d);
+  return ranked.slice(0, Math.max(0, Math.min(k, ranked.length))).map((e) => e.i);
+}
+function kdTreeRadius(points, query, r) {
+  const result = [];
+  for (let i = 0; i < points.length; i++) {
+    if (euclideanDist(points[i], query) <= r) result.push(i);
+  }
+  return result;
+}
+function flatten4(arr10) {
+  const result = [];
+  const stack = [...arr10];
+  while (stack.length > 0) {
+    const item = stack.shift();
+    if (Array.isArray(item)) {
+      stack.unshift(...item);
+    } else {
+      result.push(item);
+    }
+  }
+  return result;
+}
+function setIsSuperset(a, b) {
+  return setIsSubset(b, a);
+}
+function setEqual(a, b) {
+  return setIsSubset(a, b) && setIsSubset(b, a);
+}
+function setDisjoint(a, b) {
+  const flatA = flatten4(a);
+  for (const elem of flatA) {
+    if (setMultiplicity(elem, b) > 0) return false;
+  }
+  return true;
+}
+
 // src/stats/inference-extra2.ts
 var TWO_PI = 2 * Math.PI;
 function noncentralChi2CDF(x, df, nc) {
@@ -49807,6 +50297,475 @@ function rootsLegendre(n) {
   weights.reverse();
   return { nodes, weights };
 }
+
+// src/graph/traversal-centrality.ts
+function bfs(adj, start) {
+  const n = adj.length;
+  if (start < 0 || start >= n) {
+    throw new Error("bfs: start out of bounds");
+  }
+  const visited = new Array(n).fill(false);
+  const order = [];
+  const queue = [start];
+  visited[start] = true;
+  while (queue.length > 0) {
+    const u = queue.shift();
+    order.push(u);
+    for (let v = 0; v < n; v++) {
+      if (!visited[v] && Number.isFinite(adj[u][v]) && adj[u][v] !== 0) {
+        visited[v] = true;
+        queue.push(v);
+      }
+    }
+  }
+  return order;
+}
+function dfs(adj, start) {
+  const n = adj.length;
+  if (start < 0 || start >= n) {
+    throw new Error("dfs: start out of bounds");
+  }
+  const visited = new Array(n).fill(false);
+  const order = [];
+  function visit(u) {
+    visited[u] = true;
+    order.push(u);
+    for (let v = 0; v < n; v++) {
+      if (!visited[v] && Number.isFinite(adj[u][v]) && adj[u][v] !== 0) {
+        visit(v);
+      }
+    }
+  }
+  visit(start);
+  return order;
+}
+function _hasWeightedEdge(w) {
+  return Number.isFinite(w) && w !== 0;
+}
+function floydWarshall(adj) {
+  const n = adj.length;
+  const dist = Array.from({ length: n }, () => new Array(n).fill(Infinity));
+  for (let i = 0; i < n; i++) {
+    dist[i][i] = 0;
+    for (let j = 0; j < n; j++) {
+      if (i !== j && _hasWeightedEdge(adj[i][j])) {
+        dist[i][j] = adj[i][j];
+      }
+    }
+  }
+  for (let k = 0; k < n; k++) {
+    for (let i = 0; i < n; i++) {
+      if (dist[i][k] === Infinity) continue;
+      for (let j = 0; j < n; j++) {
+        const throughK = dist[i][k] + dist[k][j];
+        if (throughK < dist[i][j]) {
+          dist[i][j] = throughK;
+        }
+      }
+    }
+  }
+  return dist;
+}
+function bellmanFord(adj, source) {
+  const n = adj.length;
+  if (source < 0 || source >= n) {
+    throw new Error("bellmanFord: source out of bounds");
+  }
+  const dist = new Array(n).fill(Infinity);
+  dist[source] = 0;
+  const edges = [];
+  for (let u = 0; u < n; u++) {
+    for (let v = 0; v < n; v++) {
+      if (u !== v && _hasWeightedEdge(adj[u][v])) {
+        edges.push([u, v, adj[u][v]]);
+      }
+    }
+  }
+  for (let i = 0; i < n - 1; i++) {
+    let changed = false;
+    for (const [u, v, w] of edges) {
+      if (dist[u] !== Infinity && dist[u] + w < dist[v]) {
+        dist[v] = dist[u] + w;
+        changed = true;
+      }
+    }
+    if (!changed) break;
+  }
+  let hasNegativeCycle = false;
+  for (const [u, v, w] of edges) {
+    if (dist[u] !== Infinity && dist[u] + w < dist[v]) {
+      hasNegativeCycle = true;
+      break;
+    }
+  }
+  return { dist, hasNegativeCycle };
+}
+function closenessCentrality(adj) {
+  const n = adj.length;
+  const dist = floydWarshall(adj);
+  const result = new Array(n).fill(0);
+  for (let u = 0; u < n; u++) {
+    let sum3 = 0;
+    let reachable = 0;
+    for (let v = 0; v < n; v++) {
+      if (v === u) continue;
+      if (dist[v][u] < Infinity) {
+        sum3 += dist[v][u];
+        reachable++;
+      }
+    }
+    if (reachable === 0 || sum3 === 0) {
+      result[u] = 0;
+      continue;
+    }
+    const r = reachable + 1;
+    result[u] = (r - 1 === n - 1 ? 1 : (r - 1) / (n - 1)) * ((r - 1) / sum3);
+  }
+  return result;
+}
+function harmonicCentrality(adj) {
+  const n = adj.length;
+  const dist = floydWarshall(adj);
+  const result = new Array(n).fill(0);
+  for (let u = 0; u < n; u++) {
+    let sum3 = 0;
+    for (let v = 0; v < n; v++) {
+      if (v === u) continue;
+      if (dist[v][u] > 0 && dist[v][u] < Infinity) {
+        sum3 += 1 / dist[v][u];
+      }
+    }
+    result[u] = sum3;
+  }
+  return result;
+}
+
+// src/graph/optimization.ts
+function _bfsResidual(residual, source, sink) {
+  const n = residual.length;
+  const parent = new Array(n).fill(-1);
+  const visited = new Array(n).fill(false);
+  visited[source] = true;
+  const queue = [source];
+  while (queue.length > 0) {
+    const u = queue.shift();
+    if (u === sink) return parent;
+    for (let v = 0; v < n; v++) {
+      if (!visited[v] && residual[u][v] > 0) {
+        visited[v] = true;
+        parent[v] = u;
+        queue.push(v);
+      }
+    }
+  }
+  return visited[sink] ? parent : null;
+}
+function maxFlow(capacity, source, sink) {
+  const n = capacity.length;
+  if (source < 0 || source >= n || sink < 0 || sink >= n) {
+    throw new Error("maxFlow: source or sink out of bounds");
+  }
+  const residual = capacity.map((row2) => row2.slice());
+  const flow = Array.from({ length: n }, () => new Array(n).fill(0));
+  let total = 0;
+  if (source === sink) {
+    return { maxFlow: 0, flow };
+  }
+  for (; ; ) {
+    const parent = _bfsResidual(residual, source, sink);
+    if (parent === null) break;
+    let pathFlow = Infinity;
+    for (let v = sink; v !== source; v = parent[v]) {
+      const u = parent[v];
+      pathFlow = Math.min(pathFlow, residual[u][v]);
+    }
+    for (let v = sink; v !== source; v = parent[v]) {
+      const u = parent[v];
+      residual[u][v] -= pathFlow;
+      residual[v][u] += pathFlow;
+      flow[u][v] += pathFlow;
+      flow[v][u] -= pathFlow;
+    }
+    total += pathFlow;
+  }
+  return { maxFlow: total, flow };
+}
+function minCut(capacity, source, sink) {
+  const n = capacity.length;
+  if (source < 0 || source >= n || sink < 0 || sink >= n) {
+    throw new Error("minCut: source or sink out of bounds");
+  }
+  const { maxFlow: value, flow } = maxFlow(capacity, source, sink);
+  const residual = Array.from(
+    { length: n },
+    (_, i) => capacity[i].map((c, j) => c - flow[i][j])
+  );
+  const visited = new Array(n).fill(false);
+  visited[source] = true;
+  const queue = [source];
+  while (queue.length > 0) {
+    const u = queue.shift();
+    for (let v = 0; v < n; v++) {
+      if (!visited[v] && residual[u][v] > 0) {
+        visited[v] = true;
+        queue.push(v);
+      }
+    }
+  }
+  const s = [];
+  const t = [];
+  for (let i = 0; i < n; i++) {
+    (visited[i] ? s : t).push(i);
+  }
+  return { value, partition: [s, t] };
+}
+function astar(adj, start, goal, heuristic) {
+  const n = adj.length;
+  if (start < 0 || start >= n || goal < 0 || goal >= n) {
+    throw new Error("astar: start or goal out of bounds");
+  }
+  if (start === goal) {
+    return { path: [start], cost: 0 };
+  }
+  const gScore = new Array(n).fill(Infinity);
+  gScore[start] = 0;
+  const cameFrom = new Array(n).fill(-1);
+  const closed = new Array(n).fill(false);
+  const open = [{ node: start, fScore: heuristic(start) }];
+  while (open.length > 0) {
+    let bestIdx = 0;
+    for (let i = 1; i < open.length; i++) {
+      if (open[i].fScore < open[bestIdx].fScore) bestIdx = i;
+    }
+    const { node: u } = open[bestIdx];
+    open.splice(bestIdx, 1);
+    if (closed[u]) continue;
+    closed[u] = true;
+    if (u === goal) break;
+    for (let v = 0; v < n; v++) {
+      if (closed[v] || !Number.isFinite(adj[u][v]) || adj[u][v] === 0) continue;
+      const tentative = gScore[u] + adj[u][v];
+      if (tentative < gScore[v]) {
+        gScore[v] = tentative;
+        cameFrom[v] = u;
+        open.push({ node: v, fScore: tentative + heuristic(v) });
+      }
+    }
+  }
+  if (gScore[goal] === Infinity) {
+    return { path: [], cost: Infinity };
+  }
+  const path = [];
+  for (let v = goal; v !== -1; v = cameFrom[v]) {
+    path.unshift(v);
+    if (v === start) break;
+  }
+  return { path, cost: gScore[goal] };
+}
+function hungarian(cost) {
+  const n = cost.length;
+  if (n === 0) {
+    return { assignment: [], cost: 0 };
+  }
+  for (const row2 of cost) {
+    if (row2.length !== n) {
+      throw new Error("hungarian: cost matrix must be square");
+    }
+  }
+  const INF = Infinity;
+  const u = new Array(n + 1).fill(0);
+  const v = new Array(n + 1).fill(0);
+  const a = new Array(n + 1).fill(0);
+  const p = new Array(n + 1).fill(0);
+  for (let i = 1; i <= n; i++) {
+    a[0] = i;
+    let j0 = 0;
+    const minv = new Array(n + 1).fill(INF);
+    const used = new Array(n + 1).fill(false);
+    do {
+      used[j0] = true;
+      const i0 = a[j0];
+      let delta = INF;
+      let j1 = -1;
+      for (let j = 1; j <= n; j++) {
+        if (used[j]) continue;
+        const cur = cost[i0 - 1][j - 1] - u[i0] - v[j];
+        if (cur < minv[j]) {
+          minv[j] = cur;
+          p[j] = j0;
+        }
+        if (minv[j] < delta) {
+          delta = minv[j];
+          j1 = j;
+        }
+      }
+      for (let j = 0; j <= n; j++) {
+        if (used[j]) {
+          u[a[j]] += delta;
+          v[j] -= delta;
+        } else {
+          minv[j] -= delta;
+        }
+      }
+      j0 = j1;
+    } while (a[j0] !== 0);
+    while (j0 !== 0) {
+      const j1 = p[j0];
+      a[j0] = a[j1];
+      j0 = j1;
+    }
+  }
+  const assignment = new Array(n).fill(-1);
+  let totalCost = 0;
+  for (let j = 1; j <= n; j++) {
+    const i = a[j];
+    if (i > 0) {
+      assignment[i - 1] = j - 1;
+      totalCost += cost[i - 1][j - 1];
+    }
+  }
+  return { assignment, cost: totalCost };
+}
+
+// src/numeric/interval.ts
+var EPS3 = Number.EPSILON;
+function outward(lo, hi) {
+  const loOut = lo - Math.abs(lo) * EPS3 - Number.MIN_VALUE;
+  const hiOut = hi + Math.abs(hi) * EPS3 + Number.MIN_VALUE;
+  return new Interval(loOut, hiOut);
+}
+var Interval = class {
+  lo;
+  hi;
+  constructor(lo, hi) {
+    if (lo > hi) {
+      throw new Error(`Interval: lo (${lo}) must be <= hi (${hi})`);
+    }
+    this.lo = lo;
+    this.hi = hi;
+  }
+  /** `[this.lo + b.lo, this.hi + b.hi]`, outward-rounded. */
+  add(b) {
+    return outward(this.lo + b.lo, this.hi + b.hi);
+  }
+  /** `[this.lo - b.hi, this.hi - b.lo]`, outward-rounded. */
+  sub(b) {
+    return outward(this.lo - b.hi, this.hi - b.lo);
+  }
+  /**
+   * Interval product: the min/max of all four endpoint products
+   * (`lo*lo, lo*hi, hi*lo, hi*hi`), outward-rounded. Correct for any
+   * combination of signs.
+   */
+  mul(b) {
+    const p1 = this.lo * b.lo;
+    const p2 = this.lo * b.hi;
+    const p3 = this.hi * b.lo;
+    const p4 = this.hi * b.hi;
+    return outward(Math.min(p1, p2, p3, p4), Math.max(p1, p2, p3, p4));
+  }
+  /**
+   * Interval quotient. Throws if `b` contains 0 (division would be
+   * unbounded). Otherwise the min/max of the four endpoint quotients,
+   * outward-rounded.
+   */
+  div(b) {
+    if (b.contains(0)) {
+      throw new Error("Interval.div: divisor interval contains zero");
+    }
+    const q1 = this.lo / b.lo;
+    const q2 = this.lo / b.hi;
+    const q3 = this.hi / b.lo;
+    const q4 = this.hi / b.hi;
+    return outward(Math.min(q1, q2, q3, q4), Math.max(q1, q2, q3, q4));
+  }
+  /** `[-this.hi, -this.lo]`, outward-rounded. */
+  neg() {
+    return outward(-this.hi, -this.lo);
+  }
+  /** `hi - lo`. */
+  width() {
+    return this.hi - this.lo;
+  }
+  /** `(lo + hi) / 2`. */
+  mid() {
+    return (this.lo + this.hi) / 2;
+  }
+  /** Whether the closed interval `[lo, hi]` contains the real number `x`. */
+  contains(x) {
+    return x >= this.lo && x <= this.hi;
+  }
+  /**
+   * Square root, monotonic-increasing over `[0, +Infinity)`. Throws if the
+   * interval contains negative values (real square root is undefined there).
+   */
+  sqrt() {
+    if (this.lo < 0) {
+      throw new Error("Interval.sqrt: interval contains negative values");
+    }
+    return outward(Math.sqrt(this.lo), Math.sqrt(this.hi));
+  }
+  /** Exponential, monotonic-increasing over all reals. */
+  exp() {
+    return outward(Math.exp(this.lo), Math.exp(this.hi));
+  }
+  /**
+   * Natural log, monotonic-increasing over `(0, +Infinity)`. Throws if the
+   * interval is not strictly positive.
+   */
+  log() {
+    if (this.lo <= 0) {
+      throw new Error("Interval.log: interval must be strictly positive");
+    }
+    return outward(Math.log(this.lo), Math.log(this.hi));
+  }
+  /**
+   * Integer power `x^n`, monotonic-aware:
+   * - `n` odd: `x^n` is monotonic-increasing over all reals, so the result is
+   *   `[lo^n, hi^n]`.
+   * - `n` even, interval entirely non-negative: monotonic-increasing, so
+   *   `[lo^n, hi^n]`.
+   * - `n` even, interval entirely non-positive: monotonic-decreasing (in
+   *   magnitude, toward zero), so `[hi^n, lo^n]`.
+   * - `n` even, interval spans zero: the minimum is `0` (attained at `x=0`)
+   *   and the maximum is `max(|lo|, |hi|)^n`.
+   * - `n` negative: computed as the reciprocal of `pow(-n)`; throws if that
+   *   positive-power interval contains zero (division by zero).
+   * - `n = 0`: `[1, 1]` for every interval.
+   *
+   * Throws if `n` is not an integer.
+   */
+  pow(n) {
+    if (!Number.isInteger(n)) {
+      throw new Error("Interval.pow: exponent must be an integer");
+    }
+    if (n === 0) {
+      return outward(1, 1);
+    }
+    if (n < 0) {
+      const positivePow = this.pow(-n);
+      if (positivePow.contains(0)) {
+        throw new Error("Interval.pow: cannot invert an interval containing zero");
+      }
+      return outward(1 / positivePow.hi, 1 / positivePow.lo);
+    }
+    const isOdd = n % 2 !== 0;
+    if (isOdd) {
+      return outward(this.lo ** n, this.hi ** n);
+    }
+    if (this.lo >= 0) {
+      return outward(this.lo ** n, this.hi ** n);
+    }
+    if (this.hi <= 0) {
+      return outward(this.hi ** n, this.lo ** n);
+    }
+    const maxAbs = Math.max(Math.abs(this.lo), Math.abs(this.hi));
+    return outward(0, maxAbs ** n);
+  }
+};
+function interval(lo, hi) {
+  return new Interval(lo, hi);
+}
 export {
   ARRAY_WORKER_THRESHOLD,
   CAS_BATCH_THRESHOLD,
@@ -49818,6 +50777,7 @@ export {
   GPU_ELEMENTWISE_OPS,
   GPU_MIN_ELEMENTS2 as GPU_MIN_ELEMENTS,
   GPU_REDUCE_OPS,
+  Interval,
   WASM_INTERP_THRESHOLD,
   abs,
   acf,
@@ -49848,6 +50808,7 @@ export {
   asin,
   asinh,
   assume,
+  astar,
   asymptotic,
   atan,
   atan2,
@@ -49859,6 +50820,7 @@ export {
   bartlettPSD,
   bartlettTest,
   bellNumbers,
+  bellmanFord,
   bernoulli,
   bernoulliPMF,
   besselI,
@@ -49878,6 +50840,7 @@ export {
   betweennessCentrality,
   bezierCurve,
   bfgs,
+  bfs,
   bicgstab,
   bigint,
   bignumber,
@@ -49895,6 +50858,7 @@ export {
   boltzmann,
   boolean,
   bootstrapCI,
+  boundingBox,
   bspline,
   butter,
   buttord,
@@ -49941,6 +50905,7 @@ export {
   classicalElectronRadius,
   clearAssumptions,
   clone3 as clone,
+  closenessCentrality,
   cochranQ,
   coefficientList,
   coherence,
@@ -50026,6 +50991,7 @@ export {
   det,
   detrend,
   deuteronMass,
+  dfs,
   diag,
   diff,
   differences,
@@ -50192,6 +51158,7 @@ export {
   fix,
   flatten3 as flatten,
   floor,
+  floydWarshall,
   forEach,
   format4 as format,
   fourier,
@@ -50246,6 +51213,7 @@ export {
   groupDelay,
   gumbelDist,
   halley,
+  harmonicCentrality,
   harmonicNumber,
   hartreeEnergy,
   hasNumericValue,
@@ -50261,6 +51229,7 @@ export {
   histogram,
   hmean,
   hotellingT2,
+  hungarian,
   hyp0f1,
   hyp1f1,
   hyp2f1,
@@ -50281,10 +51250,12 @@ export {
   initializeStatistics,
   integerDigits,
   integrate,
+  interpn,
   interpolate,
   intersect,
   intersectLines2D,
   intersectSegments2D,
+  interval,
   inv,
   invFourier,
   invGaussDist,
@@ -50318,7 +51289,9 @@ export {
   josephson,
   jsDivergence,
   kdTree,
+  kdTreeKNN,
   kdTreeNearest,
+  kdTreeRadius,
   kendallTau,
   kendallTauTest,
   kendalltau,
@@ -50410,6 +51383,7 @@ export {
   matrixSqrtm,
   matvec,
   max,
+  maxFlow,
   maxSelect,
   maximize,
   mcnemar,
@@ -50419,6 +51393,7 @@ export {
   median,
   medianSelect,
   min,
+  minCut,
   minSelect,
   minimalPolynomial,
   minimize,
@@ -50562,6 +51537,7 @@ export {
   primitiveRoot,
   principalComponentAnalysis,
   print,
+  procrustes,
   prod,
   projectVector,
   proportionCI,
@@ -50575,9 +51551,12 @@ export {
   quantumOfCirculation,
   quaternionConjugate,
   quaternionFromAxisAngle,
+  quaternionInverse,
   quaternionMultiply,
   quaternionNormalize,
   quaternionRotate,
+  quaternionSlerp,
+  quaternionToEuler,
   quaternionToRotationMatrix,
   quickSelect,
   qz,
@@ -50634,9 +51613,12 @@ export {
   seriesCoefficient,
   setCartesian,
   setDifference,
+  setDisjoint,
   setDistinct,
+  setEqual,
   setIntersect,
   setIsSubset,
+  setIsSuperset,
   setMultiplicity,
   setPowerset,
   setSize,
@@ -50707,7 +51689,7 @@ export {
   subtractScalar,
   sum,
   summation,
-  svd3 as svd,
+  svd4 as svd,
   sylvester,
   symbolicEqual,
   symbolicIntegral,