@danielsimonjr/mathts-functions 0.28.0 → 0.30.0

package/dist/index.js

@@ -5510,15 +5510,15 @@ function modNumber(x, y) {
   return y === 0 ? x : x - y * Math.floor(x / y);
 }
 modNumber.signature = n2;
-function nthRootNumber(a, root = 2) {
-  const inv2 = root < 0;
+function nthRootNumber(a, root2 = 2) {
+  const inv2 = root2 < 0;
   if (inv2) {
-    root = -root;
+    root2 = -root2;
   }
-  if (root === 0) {
+  if (root2 === 0) {
     throw new Error("Root must be non-zero");
   }
-  if (a < 0 && Math.abs(root) % 2 !== 1) {
+  if (a < 0 && Math.abs(root2) % 2 !== 1) {
     throw new Error("Root must be odd when a is negative.");
   }
   if (a === 0) {
@@ -5527,7 +5527,7 @@ function nthRootNumber(a, root = 2) {
   if (!isFinite(a)) {
     return inv2 ? 0 : a;
   }
-  let x = Math.pow(Math.abs(a), 1 / root);
+  let x = Math.pow(Math.abs(a), 1 / root2);
   x = a < 0 ? -x : x;
   return inv2 ? 1 / x : x;
 }
@@ -8381,18 +8381,18 @@ import { computePool as computePool7 } from "@danielsimonjr/mathts-parallel";
 var GEOMETRY_WASM_THRESHOLD = 32;
 var HULL3D_WASM_THRESHOLD = 1024;
 function angle2D(v1, v2) {
-  const dot3 = v1[0] * v2[0] + v1[1] * v2[1];
+  const dot4 = v1[0] * v2[0] + v1[1] * v2[1];
   const mag1 = Math.sqrt(v1[0] ** 2 + v1[1] ** 2);
   const mag2 = Math.sqrt(v2[0] ** 2 + v2[1] ** 2);
   if (mag1 === 0 || mag2 === 0) return NaN;
-  return Math.acos(Math.max(-1, Math.min(1, dot3 / (mag1 * mag2))));
+  return Math.acos(Math.max(-1, Math.min(1, dot4 / (mag1 * mag2))));
 }
 function angle3D(v1, v2) {
-  const dot3 = v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
+  const dot4 = v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
   const mag1 = Math.sqrt(v1[0] ** 2 + v1[1] ** 2 + v1[2] ** 2);
   const mag2 = Math.sqrt(v2[0] ** 2 + v2[1] ** 2 + v2[2] ** 2);
   if (mag1 === 0 || mag2 === 0) return NaN;
-  return Math.acos(Math.max(-1, Math.min(1, dot3 / (mag1 * mag2))));
+  return Math.acos(Math.max(-1, Math.min(1, dot4 / (mag1 * mag2))));
 }
 function cross3D(a, b) {
   return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
@@ -8497,14 +8497,14 @@ function reflectVector(v, normal) {
   const mag = Math.sqrt(normal.reduce((s, c) => s + c * c, 0));
   if (mag === 0) return v.slice();
   const n = normal.map((c) => c / mag);
-  const dot3 = v.reduce((s, c, i) => s + c * n[i], 0);
-  return v.map((c, i) => c - 2 * dot3 * n[i]);
+  const dot4 = v.reduce((s, c, i) => s + c * n[i], 0);
+  return v.map((c, i) => c - 2 * dot4 * n[i]);
 }
 function projectVector(v, onto) {
-  const dot3 = v.reduce((s, c, i) => s + c * onto[i], 0);
+  const dot4 = v.reduce((s, c, i) => s + c * onto[i], 0);
   const magSq = onto.reduce((s, c) => s + c * c, 0);
   if (magSq === 0) return onto.map(() => 0);
-  const scale = dot3 / magSq;
+  const scale = dot4 / magSq;
   return onto.map((c) => c * scale);
 }
 function distance2D(a, b) {
@@ -8852,9 +8852,9 @@ function kdTree(points) {
   }
   return build(indexed, 0);
 }
-function kdTreeNearest(root, target) {
-  if (!root) return null;
-  let best = { point: root.point, index: root.index, distance: distanceNDSq(root.point, target) };
+function kdTreeNearest(root2, target) {
+  if (!root2) return null;
+  let best = { point: root2.point, index: root2.index, distance: distanceNDSq(root2.point, target) };
   function search(node) {
     if (!node) return;
     const d = distanceNDSq(node.point, target);
@@ -8869,7 +8869,7 @@ function kdTreeNearest(root, target) {
       search(second);
     }
   }
-  search(root);
+  search(root2);
   best.distance = Math.sqrt(best.distance);
   return best;
 }
@@ -8921,8 +8921,8 @@ function nearestNeighbor(points, query) {
       }
     }
   }
-  const root = kdTree(points);
-  return kdTreeNearest(root, query);
+  const root2 = kdTree(points);
+  return kdTreeNearest(root2, query);
 }
 function convexHull3D(points) {
   const n = points.length;
@@ -11843,6 +11843,81 @@ var createSolveODE = /* @__PURE__ */ factory(
   }
 );
 
+// src/numeric/adaptive-quad.ts
+var XGK = [
+  0.991455371120813,
+  0.949107912342759,
+  0.864864423359769,
+  0.741531185599394,
+  0.586087235467691,
+  0.405845151377397,
+  0.207784955007898,
+  0
+];
+var WGK = [
+  0.022935322010529,
+  0.063092092629979,
+  0.10479001032225,
+  0.140653259715525,
+  0.169004726639267,
+  0.190350578064785,
+  0.204432940075298,
+  0.209482141084728
+];
+var WG = [0.12948496616887, 0.27970539148928, 0.38183005050512, 0.41795918367347];
+var KRONROD_NODES = [];
+var KRONROD_WEIGHTS = [];
+var GAUSS_WEIGHTS = [];
+for (let i = 0; i < 7; i++) {
+  KRONROD_NODES.push(-XGK[i]);
+  KRONROD_WEIGHTS.push(WGK[i]);
+  GAUSS_WEIGHTS.push(0);
+}
+KRONROD_NODES.push(0);
+KRONROD_WEIGHTS.push(WGK[7]);
+GAUSS_WEIGHTS.push(0);
+for (let i = 6; i >= 0; i--) {
+  KRONROD_NODES.push(XGK[i]);
+  KRONROD_WEIGHTS.push(WGK[i]);
+  GAUSS_WEIGHTS.push(0);
+}
+GAUSS_WEIGHTS[1] = WG[0];
+GAUSS_WEIGHTS[3] = WG[1];
+GAUSS_WEIGHTS[5] = WG[2];
+GAUSS_WEIGHTS[7] = WG[3];
+GAUSS_WEIGHTS[9] = WG[2];
+GAUSS_WEIGHTS[11] = WG[1];
+GAUSS_WEIGHTS[13] = WG[0];
+function gaussKronrod15(f, a, b) {
+  const halfWidth = (b - a) / 2;
+  const mid = (a + b) / 2;
+  let k = 0;
+  let g = 0;
+  for (let i = 0; i < 15; i++) {
+    const fx = f(halfWidth * KRONROD_NODES[i] + mid);
+    k += KRONROD_WEIGHTS[i] * fx;
+    g += GAUSS_WEIGHTS[i] * fx;
+  }
+  return { k: halfWidth * k, g: halfWidth * g };
+}
+var ABS_FLOOR = 1e-14;
+function quad(f, a, b, opts) {
+  const tol = opts?.tol ?? 1e-10;
+  const maxDepth = opts?.maxDepth ?? 50;
+  function panel(a2, b2, depth) {
+    const { k, g } = gaussKronrod15(f, a2, b2);
+    const panelError = Math.abs(k - g);
+    if (depth >= maxDepth || panelError <= Math.max(tol * Math.abs(k), ABS_FLOOR)) {
+      return { value: k, error: panelError };
+    }
+    const mid = (a2 + b2) / 2;
+    const left = panel(a2, mid, depth + 1);
+    const right = panel(mid, b2, depth + 1);
+    return { value: left.value + right.value, error: left.error + right.error };
+  }
+  return panel(a, b, 0);
+}
+
 // src/typed/numeric.ts
 var NUMERIC_WASM_THRESHOLD = 16;
 function findRoot(f, a, b, opts) {
@@ -12072,37 +12147,7 @@ function leastSquares(A, b) {
   return linsolve(AtA, Atb);
 }
 function nintegrate(f, a, b, opts) {
-  const tol = opts?.tol ?? 1e-10;
-  const maxDepth = opts?.maxDepth ?? 30;
-  function adaptiveQuad(a2, b2, depth) {
-    const mid = (a2 + b2) / 2;
-    const whole = gaussLegendre5(f, a2, b2);
-    const left = gaussLegendre5(f, a2, mid);
-    const right = gaussLegendre5(f, mid, b2);
-    const refined = left + right;
-    if (depth >= maxDepth || Math.abs(refined - whole) < 15 * tol) {
-      return refined + (refined - whole) / 15;
-    }
-    return adaptiveQuad(a2, mid, depth + 1) + adaptiveQuad(mid, b2, depth + 1);
-  }
-  return adaptiveQuad(a, b, 0);
-}
-function gaussLegendre5(f, a, b) {
-  const nodes = [-0.906179845938664, -0.5384693101056831, 0, 0.5384693101056831, 0.906179845938664];
-  const weights = [
-    0.2369268850561891,
-    0.4786286704993665,
-    0.5688888888888889,
-    0.4786286704993665,
-    0.2369268850561891
-  ];
-  const hw = (b - a) / 2;
-  const mid = (a + b) / 2;
-  let sum3 = 0;
-  for (let i = 0; i < 5; i++) {
-    sum3 += weights[i] * f(hw * nodes[i] + mid);
-  }
-  return hw * sum3;
+  return quad(f, a, b, opts).value;
 }
 function simpsons(f, a, b, n = 100) {
   if (n % 2 !== 0) n += 1;
@@ -13063,7 +13108,7 @@ function quadprog(H, f, A, b) {
   }
   return x;
 }
-function linprog(c, A, b) {
+function linprogOnePhaseLegacy(c, A, b) {
   const m = A.length;
   const n = c.length;
   const tableau = [];
@@ -13134,6 +13179,285 @@ function linprog(c, A, b) {
   }
   return x;
 }
+var LINPROG_TOL = 1e-9;
+function linprogSolveTwoPhase(costWork, Aeq, beq, hasSlack, slackCol) {
+  const m = Aeq.length;
+  const nw = costWork.length;
+  if (m === 0) {
+    for (let j = 0; j < nw; j++) {
+      if (costWork[j] < -LINPROG_TOL) return { xWork: [], status: "unbounded" };
+    }
+    return { xWork: new Array(nw).fill(0), status: "optimal" };
+  }
+  const rows = [];
+  const rhs = [];
+  const flipped = [];
+  for (let i2 = 0; i2 < m; i2++) {
+    let row2 = [...Aeq[i2]];
+    let b = beq[i2];
+    let f = false;
+    if (b < 0) {
+      row2 = row2.map((v) => -v);
+      b = -b;
+      f = true;
+    }
+    rows.push(row2);
+    rhs.push(b);
+    flipped.push(f);
+  }
+  const basis = new Array(m).fill(-1);
+  const artificialCols = [];
+  let nextCol = nw;
+  for (let i2 = 0; i2 < m; i2++) {
+    if (hasSlack[i2] && !flipped[i2]) {
+      basis[i2] = slackCol[i2];
+    } else {
+      const col = nextCol++;
+      artificialCols.push(col);
+      basis[i2] = col;
+    }
+  }
+  const totalCols = nextCol;
+  const isArtificial = new Array(totalCols).fill(false);
+  for (const col of artificialCols) isArtificial[col] = true;
+  const width = totalCols + 1;
+  const tableau = [];
+  for (let i2 = 0; i2 < m; i2++) {
+    const row2 = new Array(width).fill(0);
+    for (let j = 0; j < nw; j++) row2[j] = rows[i2][j];
+    if (isArtificial[basis[i2]]) row2[basis[i2]] = 1;
+    row2[totalCols] = rhs[i2];
+    tableau.push(row2);
+  }
+  const pivot = (pr, pc, objRow) => {
+    const pivotVal = tableau[pr][pc];
+    for (let j = 0; j < width; j++) tableau[pr][j] /= pivotVal;
+    for (let i2 = 0; i2 < tableau.length; i2++) {
+      if (i2 === pr) continue;
+      const factor3 = tableau[i2][pc];
+      if (factor3 === 0) continue;
+      for (let j = 0; j < width; j++) tableau[i2][j] -= factor3 * tableau[pr][j];
+    }
+    const factor2 = objRow[pc];
+    if (factor2 !== 0) {
+      for (let j = 0; j < width; j++) objRow[j] -= factor2 * tableau[pr][j];
+    }
+  };
+  const buildObjRow = (costFull) => {
+    const row2 = new Array(width).fill(0);
+    for (let j = 0; j < totalCols; j++) row2[j] = costFull[j];
+    for (let i2 = 0; i2 < tableau.length; i2++) {
+      const cb = costFull[basis[i2]];
+      if (cb === 0) continue;
+      for (let j = 0; j < width; j++) row2[j] -= cb * tableau[i2][j];
+    }
+    return row2;
+  };
+  const runSimplex = (objRow, excluded, maxIter = 2e3) => {
+    for (let iter = 0; iter < maxIter; iter++) {
+      let pivotCol = -1;
+      let minVal = -LINPROG_TOL;
+      for (let j = 0; j < totalCols; j++) {
+        if (excluded[j]) continue;
+        if (objRow[j] < minVal) {
+          minVal = objRow[j];
+          pivotCol = j;
+        }
+      }
+      if (pivotCol === -1) return "optimal";
+      let pivotRow = -1;
+      let minRatio = Infinity;
+      for (let i2 = 0; i2 < tableau.length; i2++) {
+        if (tableau[i2][pivotCol] > LINPROG_TOL) {
+          const ratio = tableau[i2][totalCols] / tableau[i2][pivotCol];
+          if (ratio < minRatio - 1e-12) {
+            minRatio = ratio;
+            pivotRow = i2;
+          }
+        }
+      }
+      if (pivotRow === -1) return "unbounded";
+      basis[pivotRow] = pivotCol;
+      pivot(pivotRow, pivotCol, objRow);
+    }
+    return "optimal";
+  };
+  const noExclusions = new Array(totalCols).fill(false);
+  const cost1 = new Array(totalCols).fill(0);
+  for (const col of artificialCols) cost1[col] = 1;
+  const objRow1 = buildObjRow(cost1);
+  const phase1Status = runSimplex(objRow1, noExclusions);
+  if (phase1Status === "unbounded") return { xWork: [], status: "infeasible" };
+  let phase1Obj = 0;
+  for (let i2 = 0; i2 < tableau.length; i2++) phase1Obj += cost1[basis[i2]] * tableau[i2][totalCols];
+  if (phase1Obj > 1e-7) return { xWork: [], status: "infeasible" };
+  let i = 0;
+  while (i < tableau.length) {
+    if (!isArtificial[basis[i]]) {
+      i++;
+      continue;
+    }
+    let pc = -1;
+    for (let j = 0; j < nw; j++) {
+      if (Math.abs(tableau[i][j]) > 1e-8) {
+        pc = j;
+        break;
+      }
+    }
+    if (pc === -1) {
+      tableau.splice(i, 1);
+      basis.splice(i, 1);
+      continue;
+    }
+    basis[i] = pc;
+    pivot(i, pc, new Array(width).fill(0));
+    i++;
+  }
+  const costFull2 = new Array(totalCols).fill(0);
+  for (let j = 0; j < nw; j++) costFull2[j] = costWork[j];
+  const objRow2 = buildObjRow(costFull2);
+  const excludeArtificial = isArtificial.slice();
+  const phase2Status = runSimplex(objRow2, excludeArtificial);
+  if (phase2Status === "unbounded") return { xWork: [], status: "unbounded" };
+  const xWork = new Array(nw).fill(0);
+  for (let r = 0; r < tableau.length; r++) {
+    if (basis[r] < nw) xWork[basis[r]] = Math.max(0, tableau[r][totalCols]);
+  }
+  return { xWork, status: "optimal" };
+}
+function linprogTwoPhase(c, opts) {
+  const n = c.length;
+  const boundsResolved = [];
+  for (let j = 0; j < n; j++) {
+    const b = opts.bounds?.[j];
+    boundsResolved.push(b ? [b[0], b[1]] : [0, null]);
+  }
+  let col = 0;
+  const expansions = [];
+  for (let j = 0; j < n; j++) {
+    const low = boundsResolved[j][0];
+    if (low === null) {
+      const colPos = col++;
+      const colNeg = col++;
+      expansions.push({ kind: "split", colPos, colNeg });
+    } else {
+      const c0 = col++;
+      expansions.push({ kind: "shift", col: c0, shift: low });
+    }
+  }
+  const nx = col;
+  const expandRow = (row2) => {
+    const out = new Array(nx).fill(0);
+    for (let j = 0; j < n; j++) {
+      const coeff = row2[j] ?? 0;
+      if (coeff === 0) continue;
+      const e = expansions[j];
+      if (e.kind === "shift") out[e.col] += coeff;
+      else {
+        out[e.colPos] += coeff;
+        out[e.colNeg] -= coeff;
+      }
+    }
+    return out;
+  };
+  const shiftedRhs = (row2, rhsVal) => {
+    let r = rhsVal;
+    for (let j = 0; j < n; j++) {
+      const e = expansions[j];
+      if (e.kind === "shift" && e.shift !== 0) r -= (row2[j] ?? 0) * e.shift;
+    }
+    return r;
+  };
+  let constant = 0;
+  const cWork = new Array(nx).fill(0);
+  for (let j = 0; j < n; j++) {
+    const e = expansions[j];
+    if (e.kind === "shift") {
+      cWork[e.col] = c[j];
+      constant += c[j] * e.shift;
+    } else {
+      cWork[e.colPos] = c[j];
+      cWork[e.colNeg] = -c[j];
+    }
+  }
+  const ubRows = [];
+  const ubRhs = [];
+  const A_ub = opts.A_ub ?? [];
+  const b_ub = opts.b_ub ?? [];
+  for (let i = 0; i < A_ub.length; i++) {
+    ubRows.push(expandRow(A_ub[i]));
+    ubRhs.push(shiftedRhs(A_ub[i], b_ub[i]));
+  }
+  for (let j = 0; j < n; j++) {
+    const high = boundsResolved[j][1];
+    if (high === null) continue;
+    const e = expansions[j];
+    const row2 = new Array(nx).fill(0);
+    let rhsVal;
+    if (e.kind === "shift") {
+      row2[e.col] = 1;
+      rhsVal = high - e.shift;
+    } else {
+      row2[e.colPos] = 1;
+      row2[e.colNeg] = -1;
+      rhsVal = high;
+    }
+    ubRows.push(row2);
+    ubRhs.push(rhsVal);
+  }
+  const A_eq = opts.A_eq ?? [];
+  const b_eq = opts.b_eq ?? [];
+  const eqRows = [];
+  const eqRhs = [];
+  for (let i = 0; i < A_eq.length; i++) {
+    eqRows.push(expandRow(A_eq[i]));
+    eqRhs.push(shiftedRhs(A_eq[i], b_eq[i]));
+  }
+  const mUb = ubRows.length;
+  const mEq = eqRows.length;
+  const nw = nx + mUb;
+  const Aeq = [];
+  const beq = [];
+  const hasSlack = [];
+  const slackCol = [];
+  for (let i = 0; i < mUb; i++) {
+    const row2 = new Array(nw).fill(0);
+    for (let j = 0; j < nx; j++) row2[j] = ubRows[i][j];
+    row2[nx + i] = 1;
+    Aeq.push(row2);
+    beq.push(ubRhs[i]);
+    hasSlack.push(true);
+    slackCol.push(nx + i);
+  }
+  for (let i = 0; i < mEq; i++) {
+    const row2 = new Array(nw).fill(0);
+    for (let j = 0; j < nx; j++) row2[j] = eqRows[i][j];
+    Aeq.push(row2);
+    beq.push(eqRhs[i]);
+    hasSlack.push(false);
+    slackCol.push(-1);
+  }
+  const costWorkFull = new Array(nw).fill(0);
+  for (let j = 0; j < nx; j++) costWorkFull[j] = cWork[j];
+  const raw = linprogSolveTwoPhase(costWorkFull, Aeq, beq, hasSlack, slackCol);
+  if (raw.status !== "optimal") {
+    return { x: new Array(n).fill(NaN), fun: NaN, success: false, status: raw.status };
+  }
+  const x = new Array(n).fill(0);
+  for (let j = 0; j < n; j++) {
+    const e = expansions[j];
+    x[j] = e.kind === "shift" ? raw.xWork[e.col] + e.shift : raw.xWork[e.colPos] - raw.xWork[e.colNeg];
+  }
+  let fun = constant;
+  for (let j = 0; j < nx; j++) fun += cWork[j] * raw.xWork[j];
+  return { x, fun, success: true, status: "optimal" };
+}
+function linprog(c, arg22, arg3) {
+  if (Array.isArray(arg22)) {
+    return linprogOnePhaseLegacy(c, arg22, arg3);
+  }
+  return linprogTwoPhase(c, arg22);
+}
 function solvePDE(pde, domain, bc) {
   const { alpha } = pde;
   const { L, nx, nt, T } = domain;
@@ -14073,9 +14397,9 @@ function _aggregateEigenvector(vectors, aggregation) {
   const count2 = vectors.length;
   const ref = vectors[0];
   const aligned = vectors.map((v) => {
-    let dot3 = 0;
-    for (let i = 0; i < n; i++) dot3 += v[i] * ref[i];
-    if (dot3 < 0) {
+    let dot4 = 0;
+    for (let i = 0; i < n; i++) dot4 += v[i] * ref[i];
+    if (dot4 < 0) {
       const flipped = new Float64Array(n);
       for (let i = 0; i < n; i++) flipped[i] = -v[i];
       return flipped;
@@ -15137,9 +15461,9 @@ function multivariateNormal(mean6, cov2) {
         for (let j = 0; j < i; j++) s -= L[i][j] * z[j];
         z[i] = s / L[i][i];
       }
-      let quad = 0;
-      for (let i = 0; i < k; i++) quad += z[i] * z[i];
-      return Math.exp(-0.5 * (k * Math.log(2 * Math.PI) + logDet + quad));
+      let quad2 = 0;
+      for (let i = 0; i < k; i++) quad2 += z[i] * z[i];
+      return Math.exp(-0.5 * (k * Math.log(2 * Math.PI) + logDet + quad2));
     }
   };
 }
@@ -15926,9 +16250,9 @@ function principalComponentAnalysis(data, k) {
   const explained = eigenvalues.map((ev) => totalVar > 0 ? Math.abs(ev) / totalVar : 0);
   const scores = centered.map((row2) => {
     return eigenvectors.map((ev) => {
-      let dot3 = 0;
-      for (let j = 0; j < p; j++) dot3 += row2[j] * ev[j];
-      return dot3;
+      let dot4 = 0;
+      for (let j = 0; j < p; j++) dot4 += row2[j] * ev[j];
+      return dot4;
     });
   });
   return { components: eigenvectors, explained, scores };
@@ -16539,30 +16863,30 @@ function hessenbergForm(A) {
     if (normV < 1e-30) continue;
     const beta2 = 2 / normV;
     for (let j = k; j < n; j++) {
-      let dot3 = 0;
+      let dot4 = 0;
       for (let i = 0; i < len; i++) {
-        dot3 += v[i] * H[k + 1 + i][j];
+        dot4 += v[i] * H[k + 1 + i][j];
       }
       for (let i = 0; i < len; i++) {
-        H[k + 1 + i][j] -= beta2 * v[i] * dot3;
+        H[k + 1 + i][j] -= beta2 * v[i] * dot4;
       }
     }
     for (let i = 0; i < n; i++) {
-      let dot3 = 0;
+      let dot4 = 0;
       for (let j = 0; j < len; j++) {
-        dot3 += H[i][k + 1 + j] * v[j];
+        dot4 += H[i][k + 1 + j] * v[j];
       }
       for (let j = 0; j < len; j++) {
-        H[i][k + 1 + j] -= beta2 * dot3 * v[j];
+        H[i][k + 1 + j] -= beta2 * dot4 * v[j];
       }
     }
     for (let i = 0; i < n; i++) {
-      let dot3 = 0;
+      let dot4 = 0;
       for (let j = 0; j < len; j++) {
-        dot3 += Q2[i][k + 1 + j] * v[j];
+        dot4 += Q2[i][k + 1 + j] * v[j];
       }
       for (let j = 0; j < len; j++) {
-        Q2[i][k + 1 + j] -= beta2 * dot3 * v[j];
+        Q2[i][k + 1 + j] -= beta2 * dot4 * v[j];
       }
     }
   }
@@ -25038,10 +25362,10 @@ var createNthRoots = /* @__PURE__ */ factory(
         return new Complex12(0, -val);
       }
     ];
-    function _nthComplexRoots(a, root) {
-      if (root < 0) throw new Error("Root must be greater than zero");
-      if (root === 0) throw new Error("Root must be non-zero");
-      if (root % 1 !== 0) throw new Error("Root must be an integer");
+    function _nthComplexRoots(a, root2) {
+      if (root2 < 0) throw new Error("Root must be greater than zero");
+      if (root2 === 0) throw new Error("Root must be non-zero");
+      if (root2 % 1 !== 0) throw new Error("Root must be an integer");
       if (a === 0 || a.abs() === 0) return [new Complex12(0, 0)];
       const aIsNumeric = typeof a === "number";
       let offset = NaN;
@@ -25057,14 +25381,14 @@ var createNthRoots = /* @__PURE__ */ factory(
       const arg3 = a.arg();
       const abs2 = a.abs();
       const roots = [];
-      const r = Math.pow(abs2, 1 / root);
-      for (let k = 0; k < root; k++) {
-        const halfPiFactor = (offset + 4 * k) / root;
+      const r = Math.pow(abs2, 1 / root2);
+      for (let k = 0; k < root2; k++) {
+        const halfPiFactor = (offset + 4 * k) / root2;
         if (halfPiFactor === Math.round(halfPiFactor)) {
           roots.push(_calculateExactResult[halfPiFactor % 4](r));
           continue;
         }
-        roots.push(new Complex12({ r, phi: (arg3 + 2 * Math.PI * k) / root }));
+        roots.push(new Complex12({ r, phi: (arg3 + 2 * Math.PI * k) / root2 }));
       }
       return roots;
     }
@@ -28117,19 +28441,19 @@ var createNthRoot = /* @__PURE__ */ factory(
         sS: false
       })
     );
-    function _bigNthRoot(a, root) {
+    function _bigNthRoot(a, root2) {
       const precision = BigNumber9.precision;
       const Big = BigNumber9.clone({ precision: precision + 2 });
       const zero = new BigNumber9(0);
       const one = new Big(1);
-      const inv2 = root.isNegative();
+      const inv2 = root2.isNegative();
       if (inv2) {
-        root = root.neg();
+        root2 = root2.neg();
       }
-      if (root.isZero()) {
+      if (root2.isZero()) {
         throw new Error("Root must be non-zero");
       }
-      if (a.isNegative() && !root.abs().mod(2).equals(1)) {
+      if (a.isNegative() && !root2.abs().mod(2).equals(1)) {
         throw new Error("Root must be odd when a is negative.");
       }
       if (a.isZero()) {
@@ -28138,7 +28462,7 @@ var createNthRoot = /* @__PURE__ */ factory(
       if (!a.isFinite()) {
         return inv2 ? zero : a;
       }
-      let x = a.abs().pow(one.div(root));
+      let x = a.abs().pow(one.div(root2));
       x = a.isNeg() ? x.neg() : x;
       return new BigNumber9((inv2 ? one.div(x) : x).toPrecision(precision));
     }
@@ -29874,7 +30198,7 @@ var createPinv = /* @__PURE__ */ factory(
     deepEqual: deepEqual3,
     equal: equal2,
     dotDivide: dotDivide2,
-    dot: dot3,
+    dot: dot4,
     ctranspose: ctranspose2,
     divideScalar: divideScalar2,
     multiply: multiply2,
@@ -29890,7 +30214,7 @@ var createPinv = /* @__PURE__ */ factory(
             if (size2[0] === 1) {
               return inv2(x);
             } else {
-              return dotDivide2(ctranspose2(x), dot3(x, x));
+              return dotDivide2(ctranspose2(x), dot4(x, x));
             }
           case 2: {
             if (_isZeros(x)) return ctranspose2(x);
@@ -29969,8 +30293,8 @@ var createPinv = /* @__PURE__ */ factory(
     }
     function _rankFact(mat, rows, cols) {
       const rref = _rref(mat, rows, cols);
-      const C = mat.map((row2) => row2.filter((_, j) => j < rows && !_isZero(dot3(rref[j], rref[j]))));
-      const F = rref.filter((_, i) => !_isZero(dot3(rref[i], rref[i])));
+      const C = mat.map((row2) => row2.filter((_, j) => j < rows && !_isZero(dot4(rref[j], rref[j]))));
+      const F = rref.filter((_, i) => !_isZero(dot4(rref[i], rref[i])));
       return { C, F };
     }
     function _isZero(x) {
@@ -36933,7 +37257,7 @@ function createComplexEigs({
   larger: larger2,
   smaller: smaller2,
   matrixFromColumns: _matrixFromColumns,
-  dot: dot3
+  dot: dot4
 }) {
   function complexEigs(arr7, N, prec, type, findVectors = true) {
     if (!findVectors && type === "number" && N * N >= WASM_EIGS_THRESHOLD) {
@@ -37374,7 +37698,7 @@ function createComplexEigs({
       v = subtract2(
         v,
         multiply2(
-          divideScalar2(dot3(w, v), dot3(w, w)),
+          divideScalar2(dot4(w, v), dot4(w, w)),
           w
         )
       );
@@ -37382,7 +37706,7 @@ function createComplexEigs({
     return v;
   }
   function norm4(v) {
-    return abs2(sqrt2(dot3(v, v)));
+    return abs2(sqrt2(dot4(v, v)));
   }
   function normalize2(v, type) {
     const big = type === "BigNumber";
@@ -37802,7 +38126,7 @@ var createEigs = /* @__PURE__ */ factory(
     re: re3,
     smaller: smaller2,
     matrixFromColumns: matrixFromColumns2,
-    dot: dot3
+    dot: dot4
   }) => {
     const doRealSymmetric = createRealSymmetric({
       config: config2,
@@ -37841,7 +38165,7 @@ var createEigs = /* @__PURE__ */ factory(
       larger: larger2,
       smaller: smaller2,
       matrixFromColumns: matrixFromColumns2,
-      dot: dot3
+      dot: dot4
     });
     return typed3("eigs", {
       // The conversion to matrix in the first two implementations,
@@ -42149,6 +42473,31 @@ function reviver(_key, value) {
 // src/typed/cas.ts
 import { computePool as computePool12 } from "@danielsimonjr/mathts-parallel";
 import { Complex as Complex10 } from "@danielsimonjr/mathts-core";
+
+// src/numeric/numeric-jacobian.ts
+function numericJacobian(f, x0, opts = {}) {
+  const n = x0.length;
+  const base = Array.from(x0);
+  const f0 = f(base);
+  const m = f0.length;
+  const cbrtEps = Math.cbrt(222e-18);
+  const J = Array.from({ length: m }, () => new Array(n).fill(0));
+  for (let j = 0; j < n; j++) {
+    const h = opts.h ?? Math.max(1, Math.abs(base[j])) * cbrtEps;
+    const xPlus = base.slice();
+    xPlus[j] += h;
+    const fPlus = f(xPlus);
+    const xMinus = base.slice();
+    xMinus[j] -= h;
+    const fMinus = f(xMinus);
+    for (let i = 0; i < m; i++) {
+      J[i][j] = (fPlus[i] - fMinus[i]) / (2 * h);
+    }
+  }
+  return J;
+}
+
+// src/typed/cas.ts
 function _evalNumeric(exprStr) {
   let pos = 0;
   const s = exprStr.replace(/\s+/g, "");
@@ -42409,6 +42758,9 @@ function gradientSymbolic(expr, vars, scope) {
   return vars.map((v) => partialDerivative(expr, v, scope));
 }
 function jacobian(exprs, vars, scope) {
+  if (typeof exprs === "function") {
+    return numericJacobian(exprs, vars);
+  }
   return exprs.map((expr) => vars.map((v) => partialDerivative(expr, v, scope)));
 }
 function laplacian(expr, vars, scope) {
@@ -43149,8 +43501,8 @@ function toRadicals(expr) {
   const a_lin = f1 - f0;
   if (Math.abs(a_lin * 2 + b_lin - f2) < 1e-8 && Math.abs(-a_lin + b_lin - fm1) < 1e-8) {
     if (Math.abs(a_lin) < 1e-12) return [];
-    const root = -b_lin / a_lin;
-    return [formatCoeff(root)];
+    const root2 = -b_lin / a_lin;
+    return [formatCoeff(root2)];
   }
   const c = f0;
   const a_plus_b = f1 - c;
@@ -44789,6 +45141,219 @@ function hessian(f, x, h = 1e-4) {
   return H;
 }
 
+// src/index.ts
+import { svd as svd3 } from "@danielsimonjr/mathts-matrix";
+
+// src/linalg-svd-extra.ts
+import { svd as svd2 } from "@danielsimonjr/mathts-matrix";
+function orth(A, opts = {}) {
+  const { U, S } = svd2(A);
+  const m = A.length;
+  const n = A[0]?.length ?? 0;
+  const s0 = S[0] ?? 0;
+  const tol = opts.tol ?? Math.max(m, n) * s0 * 222e-18;
+  const rank2 = S.filter((s) => s > tol).length;
+  return U.map((row2) => row2.slice(0, rank2));
+}
+
+// src/numeric/open-root-finders.ts
+var EPS_CBRT = Math.cbrt(2220446049250313e-31);
+function centralDiff1(f, x) {
+  const h = Math.max(1, Math.abs(x)) * EPS_CBRT;
+  return (f(x + h) - f(x - h)) / (2 * h);
+}
+function centralDiff2(f, x) {
+  const h = Math.max(1, Math.abs(x)) * EPS_CBRT;
+  return (f(x + h) - 2 * f(x) + f(x - h)) / (h * h);
+}
+function newton(f, x0, opts) {
+  const fprime = opts?.fprime;
+  const tol = opts?.tol ?? 1e-12;
+  const maxIter = opts?.maxIter ?? 100;
+  let x = x0;
+  for (let iter = 0; iter < maxIter; iter++) {
+    const fx = f(x);
+    if (Math.abs(fx) < tol) return x;
+    const dfx = fprime ? fprime(x) : centralDiff1(f, x);
+    if (Math.abs(dfx) < 1e-300) {
+      throw new Error("newton: derivative near zero \u2014 cannot continue");
+    }
+    const dx = fx / dfx;
+    const xNext = x - dx;
+    if (Math.abs(dx) < tol) return xNext;
+    x = xNext;
+  }
+  throw new Error(`newton: failed to converge within ${maxIter} iterations`);
+}
+function secant(f, x0, x1, opts) {
+  const tol = opts?.tol ?? 1e-12;
+  const maxIter = opts?.maxIter ?? 100;
+  let xPrev = x0;
+  let x = x1;
+  let fPrev = f(xPrev);
+  for (let iter = 0; iter < maxIter; iter++) {
+    const fx = f(x);
+    if (Math.abs(fx) < tol) return x;
+    const denom = fx - fPrev;
+    if (Math.abs(denom) < 1e-300) {
+      throw new Error("secant: f(x_k) - f(x_{k-1}) near zero \u2014 cannot continue");
+    }
+    const dx = fx * (x - xPrev) / denom;
+    const xNext = x - dx;
+    if (Math.abs(dx) < tol) return xNext;
+    xPrev = x;
+    fPrev = fx;
+    x = xNext;
+  }
+  throw new Error(`secant: failed to converge within ${maxIter} iterations`);
+}
+function halley(f, x0, opts) {
+  const fprime = opts?.fprime;
+  const fprime2 = opts?.fprime2;
+  const tol = opts?.tol ?? 1e-12;
+  const maxIter = opts?.maxIter ?? 100;
+  let x = x0;
+  for (let iter = 0; iter < maxIter; iter++) {
+    const fx = f(x);
+    if (Math.abs(fx) < tol) return x;
+    const dfx = fprime ? fprime(x) : centralDiff1(f, x);
+    const d2fx = fprime2 ? fprime2(x) : centralDiff2(f, x);
+    const denom = 2 * dfx * dfx - fx * d2fx;
+    if (Math.abs(denom) < 1e-300) {
+      throw new Error("halley: denominator near zero \u2014 cannot continue");
+    }
+    const dx = 2 * fx * dfx / denom;
+    const xNext = x - dx;
+    if (Math.abs(dx) < tol) return xNext;
+    x = xNext;
+  }
+  throw new Error(`halley: failed to converge within ${maxIter} iterations`);
+}
+
+// src/numeric/fsolve.ts
+function maxNorm(v) {
+  let m = 0;
+  for (const vi of v) m = Math.max(m, Math.abs(vi));
+  return m;
+}
+function norm24(v) {
+  let s = 0;
+  for (const vi of v) s += vi * vi;
+  return Math.sqrt(s);
+}
+function fsolve(F, x0, opts = {}) {
+  const tol = opts.tol ?? 1e-10;
+  const maxIter = opts.maxIter ?? 100;
+  let x = Array.from(x0);
+  let Fx = F(x);
+  for (let iter = 0; iter < maxIter; iter++) {
+    if (maxNorm(Fx) < tol) return x;
+    const J = numericJacobian(F, x);
+    const rhs = Fx.map((v) => -v);
+    let delta;
+    try {
+      delta = linsolve(J, rhs);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(`fsolve: singular Jacobian at iteration ${iter} (${msg})`);
+    }
+    const residualNorm2 = norm24(Fx);
+    let xNext = x.map((xi, i) => xi + delta[i]);
+    let FxNext = F(xNext);
+    if (norm24(FxNext) >= residualNorm2) {
+      let trialLambda = 1;
+      for (let halving = 0; halving < 20; halving++) {
+        trialLambda /= 2;
+        const xTrial = x.map((xi, i) => xi + trialLambda * delta[i]);
+        const FxTrial = F(xTrial);
+        if (norm24(FxTrial) < residualNorm2) {
+          xNext = xTrial;
+          FxNext = FxTrial;
+          break;
+        }
+      }
+    }
+    x = xNext;
+    Fx = FxNext;
+  }
+  if (maxNorm(Fx) < tol) return x;
+  throw new Error(`fsolve: failed to converge within ${maxIter} iterations`);
+}
+var root = fsolve;
+
+// src/numeric/minimize-scalar.ts
+var GOLD = (3 - Math.sqrt(5)) / 2;
+var EPS2 = 2220446049250313e-31;
+function minimizeScalar(f, opts) {
+  const [a0, b0] = opts?.bracket ?? [-10, 10];
+  const tol = opts?.tol ?? 1e-8;
+  const maxIter = opts?.maxIter ?? 100;
+  let a = Math.min(a0, b0);
+  let b = Math.max(a0, b0);
+  let x = a + GOLD * (b - a);
+  let w = x;
+  let v = x;
+  let fx = f(x);
+  let fw = fx;
+  let fv = fx;
+  let e = 0;
+  let d = 0;
+  for (let iter = 0; iter < maxIter; iter++) {
+    const xm = 0.5 * (a + b);
+    const tol1 = tol * Math.abs(x) + EPS2;
+    const tol2 = 2 * tol1;
+    if (Math.abs(x - xm) <= tol2 - 0.5 * (b - a)) break;
+    let useGolden = true;
+    if (Math.abs(e) > tol1) {
+      const r = (x - w) * (fx - fv);
+      let q = (x - v) * (fx - fw);
+      let p = (x - v) * q - (x - w) * r;
+      q = 2 * (q - r);
+      if (q > 0) p = -p;
+      q = Math.abs(q);
+      const eTemp = e;
+      e = d;
+      if (Math.abs(p) < Math.abs(0.5 * q * eTemp) && p > q * (a - x) && p < q * (b - x)) {
+        d = p / q;
+        const u2 = x + d;
+        if (u2 - a < tol2 || b - u2 < tol2) {
+          d = xm - x >= 0 ? tol1 : -tol1;
+        }
+        useGolden = false;
+      }
+    }
+    if (useGolden) {
+      e = x >= xm ? a - x : b - x;
+      d = GOLD * e;
+    }
+    const u = Math.abs(d) >= tol1 ? x + d : x + (d >= 0 ? tol1 : -tol1);
+    const fu = f(u);
+    if (fu <= fx) {
+      if (u >= x) a = x;
+      else b = x;
+      v = w;
+      fv = fw;
+      w = x;
+      fw = fx;
+      x = u;
+      fx = fu;
+    } else {
+      if (u < x) a = u;
+      else b = u;
+      if (fu <= fw || w === x) {
+        v = w;
+        fv = fw;
+        w = u;
+        fw = fu;
+      } else if (fu <= fv || v === x || v === w) {
+        v = u;
+        fv = fu;
+      }
+    }
+  }
+  return { x, fval: fx };
+}
+
 // src/timeseries-extra.ts
 var arr4 = (x) => Array.isArray(x) ? x : Array.from(x);
 var mean4 = (x) => mean(x);
@@ -44987,7 +45552,7 @@ function levenbergMarquardt(residual, x0, opts = {}) {
   let x = Array.from(x0);
   let lambda = 1e-3;
   const h = 1e-7;
-  const norm24 = (v) => v.reduce((s, c) => s + c * c, 0);
+  const norm25 = (v) => v.reduce((s, c) => s + c * c, 0);
   const jacobian2 = (xc, r0) => {
     const m = r0.length;
     const J = Array.from({ length: m }, () => new Array(n).fill(0));
@@ -45000,7 +45565,7 @@ function levenbergMarquardt(residual, x0, opts = {}) {
     return J;
   };
   let r = residual(x);
-  let cost = norm24(r);
+  let cost = norm25(r);
   let iter = 0;
   for (; iter < maxIter; iter++) {
     const J = jacobian2(x, r);
@@ -45031,7 +45596,7 @@ function levenbergMarquardt(residual, x0, opts = {}) {
     }
     const xNew = x.map((v, i) => v + delta[i]);
     const rNew = residual(xNew);
-    const costNew = norm24(rNew);
+    const costNew = norm25(rNew);
     if (costNew < cost) {
       x = xNew;
       r = rNew;
@@ -45127,6 +45692,253 @@ function spectralClustering(adjacency, k, opts = {}) {
   return kmeans(embed, k, opts).labels;
 }
 
+// src/numeric/bfgs.ts
+var CBRT_EPS = Math.cbrt(2220446049250313e-31);
+function numericGradient(f, x) {
+  const n = x.length;
+  const g = new Array(n);
+  for (let i = 0; i < n; i++) {
+    const h = Math.max(1, Math.abs(x[i])) * CBRT_EPS;
+    const xp = x.slice();
+    const xm = x.slice();
+    xp[i] += h;
+    xm[i] -= h;
+    g[i] = (f(xp) - f(xm)) / (2 * h);
+  }
+  return g;
+}
+function clipToBounds(x, bounds) {
+  if (!bounds) return x;
+  return x.map((v, i) => {
+    const b = bounds[i];
+    if (!b) return v;
+    const [lo, hi] = b;
+    return Math.min(hi, Math.max(lo, v));
+  });
+}
+function dot2(a, b) {
+  let s = 0;
+  for (let i = 0; i < a.length; i++) s += a[i] * b[i];
+  return s;
+}
+function matVec(H, v) {
+  const n = v.length;
+  const out = new Array(n);
+  for (let i = 0; i < n; i++) {
+    let s = 0;
+    for (let j = 0; j < n; j++) s += H[i][j] * v[j];
+    out[i] = s;
+  }
+  return out;
+}
+function bfgs(f, x0, opts = {}) {
+  const { grad, bounds, tol = 1e-8, maxIter = 500 } = opts;
+  const gradOf = grad ?? ((x2) => numericGradient(f, x2));
+  const n = x0.length;
+  const c1 = 1e-4;
+  let x = clipToBounds(x0.slice(), bounds);
+  let fx = f(x);
+  let g = gradOf(x);
+  let H = Array.from(
+    { length: n },
+    (_, i) => Array.from({ length: n }, (_2, j) => i === j ? 1 : 0)
+  );
+  const infNorm = (v) => v.reduce((m, c) => Math.max(m, Math.abs(c)), 0);
+  let iter = 0;
+  let converged = infNorm(g) < tol;
+  while (!converged && iter < maxIter) {
+    const d = matVec(H, g).map((v) => -v);
+    const gd = dot2(g, d);
+    const dir = gd < 0 ? d : g.map((v) => -v);
+    const dirSlope = gd < 0 ? gd : -dot2(g, g);
+    let alpha = 1;
+    let xNew = clipToBounds(
+      x.map((v, i) => v + alpha * dir[i]),
+      bounds
+    );
+    let fNew = f(xNew);
+    let halvings = 0;
+    while (fNew > fx + c1 * alpha * dirSlope && halvings < 50) {
+      alpha *= 0.5;
+      xNew = clipToBounds(
+        x.map((v, i) => v + alpha * dir[i]),
+        bounds
+      );
+      fNew = f(xNew);
+      halvings++;
+    }
+    const gNew = gradOf(xNew);
+    const s = xNew.map((v, i) => v - x[i]);
+    const y = gNew.map((v, i) => v - g[i]);
+    const sy = dot2(s, y);
+    if (sy > 1e-12) {
+      const rho = 1 / sy;
+      const Hy = matVec(H, y);
+      const yHy = dot2(y, Hy);
+      const HNew = Array.from({ length: n }, () => new Array(n).fill(0));
+      for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+          HNew[i][j] = H[i][j] - rho * (s[i] * Hy[j] + Hy[i] * s[j]) + rho * rho * yHy * s[i] * s[j] + rho * s[i] * s[j];
+        }
+      }
+      H = HNew;
+    }
+    x = xNew;
+    fx = fNew;
+    g = gNew;
+    iter++;
+    converged = infNorm(g) < tol;
+  }
+  return { x, fval: fx, iterations: iter, converged };
+}
+
+// src/numeric/nnls.ts
+function matVec2(A, x) {
+  const m = A.length;
+  const result = new Array(m);
+  for (let i = 0; i < m; i++) {
+    const row2 = A[i];
+    let s = 0;
+    for (let j = 0; j < row2.length; j++) s += row2[j] * x[j];
+    result[i] = s;
+  }
+  return result;
+}
+function residualNorm(A, x, b) {
+  const Ax = matVec2(A, x);
+  let s = 0;
+  for (let i = 0; i < b.length; i++) {
+    const d = Ax[i] - b[i];
+    s += d * d;
+  }
+  return Math.sqrt(s);
+}
+function nnls(A, b, opts = {}) {
+  const m = A.length;
+  const n = A[0]?.length ?? 0;
+  const tol = opts.tol ?? 1e-10;
+  const maxIter = opts.maxIter ?? 3 * n;
+  let x = new Array(n).fill(0);
+  const passive = /* @__PURE__ */ new Set();
+  const gradient2 = (xv) => {
+    const Ax = matVec2(A, xv);
+    const w = new Array(n).fill(0);
+    for (let j = 0; j < n; j++) {
+      let s = 0;
+      for (let i = 0; i < m; i++) s += A[i][j] * (b[i] - Ax[i]);
+      w[j] = s;
+    }
+    return w;
+  };
+  const solvePassive = (P2) => {
+    const z = new Array(n).fill(0);
+    if (P2.length === 0) return z;
+    const Asub = A.map((row2) => P2.map((j) => row2[j]));
+    let zp;
+    try {
+      zp = leastSquares(Asub, b);
+    } catch {
+      return x.slice();
+    }
+    for (let k = 0; k < P2.length; k++) z[P2[k]] = zp[k];
+    return z;
+  };
+  let outerIter = 0;
+  while (outerIter < maxIter) {
+    const w = gradient2(x);
+    let maxW = -Infinity;
+    let maxJ = -1;
+    for (let j = 0; j < n; j++) {
+      if (!passive.has(j) && w[j] > maxW) {
+        maxW = w[j];
+        maxJ = j;
+      }
+    }
+    if (maxJ === -1 || maxW <= tol) break;
+    passive.add(maxJ);
+    let z = solvePassive(Array.from(passive));
+    let innerIter = 0;
+    while (Array.from(passive).some((j) => z[j] <= tol) && innerIter < maxIter) {
+      innerIter++;
+      let alpha = Infinity;
+      for (const j of passive) {
+        if (z[j] <= tol) {
+          const denom = x[j] - z[j];
+          if (denom > 0) alpha = Math.min(alpha, x[j] / denom);
+        }
+      }
+      if (!isFinite(alpha)) alpha = 0;
+      for (let j = 0; j < n; j++) x[j] = x[j] + alpha * (z[j] - x[j]);
+      for (const j of Array.from(passive)) {
+        if (Math.abs(x[j]) < tol) passive.delete(j);
+      }
+      z = solvePassive(Array.from(passive));
+    }
+    x = z;
+    outerIter++;
+  }
+  return { x, residual: residualNorm(A, x, b) };
+}
+function clip(v, lower, upper) {
+  return v.map((vi, i) => Math.min(Math.max(vi, lower[i]), upper[i]));
+}
+function lsqBounded(A, b, lower, upper, opts = {}) {
+  const m = A.length;
+  const n = A[0]?.length ?? 0;
+  const tol = opts.tol ?? 1e-10;
+  const maxIter = opts.maxIter ?? Math.max(200, 20 * n);
+  let x = clip(new Array(n).fill(0), lower, upper);
+  const gradient2 = (xv) => {
+    const Ax = matVec2(A, xv);
+    const r = new Array(m);
+    for (let i = 0; i < m; i++) r[i] = Ax[i] - b[i];
+    const g = new Array(n).fill(0);
+    for (let j = 0; j < n; j++) {
+      let s = 0;
+      for (let i = 0; i < m; i++) s += A[i][j] * r[i];
+      g[j] = s;
+    }
+    return g;
+  };
+  const objective = (xv) => {
+    const r = residualNorm(A, xv, b);
+    return 0.5 * r * r;
+  };
+  for (let iter = 0; iter < maxIter; iter++) {
+    const g = gradient2(x);
+    const projFull = clip(
+      x.map((xi, i) => xi - g[i]),
+      lower,
+      upper
+    );
+    let pgNorm = 0;
+    for (let i = 0; i < n; i++) pgNorm += (x[i] - projFull[i]) ** 2;
+    pgNorm = Math.sqrt(pgNorm);
+    if (pgNorm < tol) break;
+    const fx = objective(x);
+    let alpha = 1;
+    let xNext = clip(
+      x.map((xi, i) => xi - alpha * g[i]),
+      lower,
+      upper
+    );
+    let fNext = objective(xNext);
+    let backtrack = 0;
+    while (fNext > fx && backtrack < 50) {
+      alpha /= 2;
+      xNext = clip(
+        x.map((xi, i) => xi - alpha * g[i]),
+        lower,
+        upper
+      );
+      fNext = objective(xNext);
+      backtrack++;
+    }
+    x = xNext;
+  }
+  return { x, residual: residualNorm(A, x, b) };
+}
+
 // src/cas-integration.ts
 var parse2 = parse;
 var evaluate2 = evaluate;
@@ -45385,15 +46197,15 @@ function haversine(lat1, lon1, lat2, lon2, radius = EARTH_RADIUS_KM) {
   const a = Math.sin(dPhi / 2) ** 2 + Math.cos(phi1) * Math.cos(phi2) * Math.sin(dLambda / 2) ** 2;
   return radius * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
 }
-var dot2 = (a, b) => a.reduce((s, v, i) => s + v * b[i], 0);
-var norm3 = (a) => Math.sqrt(dot2(a, a));
+var dot3 = (a, b) => a.reduce((s, v, i) => s + v * b[i], 0);
+var norm3 = (a) => Math.sqrt(dot3(a, a));
 function slerp(v0, v1, t) {
   const n0 = norm3(v0);
   const n16 = norm3(v1);
   if (n0 === 0 || n16 === 0) throw new Error("slerp: input vectors must be non-zero");
   const u0 = v0.map((v) => v / n0);
   const u1 = v1.map((v) => v / n16);
-  let cos2 = dot2(u0, u1);
+  let cos2 = dot3(u0, u1);
   cos2 = cos2 > 1 ? 1 : cos2 < -1 ? -1 : cos2;
   const omega = Math.acos(cos2);
   const mag = n0 + (n16 - n0) * t;
@@ -45509,6 +46321,7 @@ export {
   betainc,
   betweennessCentrality,
   bezierCurve,
+  bfgs,
   bigint,
   bignumber,
   bin,
@@ -45794,6 +46607,7 @@ export {
   fresnelC,
   fresnelS,
   friedmanTest,
+  fsolve,
   fsum,
   fullSimplify,
   functionExpand,
@@ -45833,6 +46647,7 @@ export {
   groebnerBasis,
   groupDelay,
   gumbelDist,
+  halley,
   harmonicNumber,
   hartreeEnergy,
   hasNumericValue,
@@ -45951,6 +46766,7 @@ export {
   lowpassFilter,
   lsolve,
   lsolveAll,
+  lsqBounded,
   lucas,
   lucasL,
   lup,
@@ -45988,6 +46804,7 @@ export {
   minSelect,
   minimalPolynomial,
   minimize,
+  minimizeScalar,
   minimumSpanningTree,
   minkowskiDistance,
   mod,
@@ -46010,9 +46827,11 @@ export {
   negativeBinomialDist,
   nelderMead,
   neutronMass,
+  newton,
   newtonInterp,
   nextPrime,
   nintegrate,
+  nnls,
   nodeOperations,
   noncentralChi2PDF,
   norm,
@@ -46031,11 +46850,13 @@ export {
   nullspace,
   number,
   numeric,
+  numericJacobian,
   oct,
   odeAdaptiveStep,
   odeGeneral,
   ones,
   or,
+  orth,
   outer,
   padeApproximant,
   pageRank,
@@ -46117,6 +46938,7 @@ export {
   protonMass,
   ptp,
   qr,
+  quad,
   quadprog,
   quantileSeq,
   quantumOfCirculation,
@@ -46154,6 +46976,7 @@ export {
   rightLogShift,
   risingFactorial,
   romberg,
+  root,
   rotate,
   rotateVector2D,
   rotateVector3D,
@@ -46165,6 +46988,7 @@ export {
   sackurTetrode,
   schur,
   sec,
+  secant,
   sech,
   secondRadiation,
   seedProbabilityRng,
@@ -46241,6 +47065,7 @@ export {
   subtractScalar,
   sum,
   summation,
+  svd3 as svd,
   sylvester,
   symbolicEqual,
   symbolicIntegral,