@danielsimonjr/mathts-functions 0.49.0 → 0.51.0

package/dist/index.js

@@ -112,7 +112,7 @@ __export(typed_exports, {
   cond: () => cond,
   conj: () => conj,
   connectedComponents: () => connectedComponents,
-  convexHull: () => convexHull,
+  convexHull2D: () => convexHull2D,
   convexHull3D: () => convexHull3D,
   convolve: () => convolve,
   coordinateTransform: () => coordinateTransform,
@@ -2281,9 +2281,9 @@ var mean = mathTyped2("mean", {
     return result.result;
   }
 });
-function varianceFromM2(m2, n, norm4) {
+function varianceFromM2(m2, n, norm5) {
   if (n === 0) return NaN;
-  switch (norm4) {
+  switch (norm5) {
     case "biased":
       return m2 / (n + 1);
     case "uncorrected":
@@ -2298,31 +2298,31 @@ function m2OfArray(arr10) {
 }
 var variance = mathTyped2("variance", {
   Array: (arr10) => varianceFromM2(m2OfArray(arr10), arr10.length, "unbiased"),
-  "Array, string": (arr10, norm4) => varianceFromM2(m2OfArray(arr10), arr10.length, norm4),
+  "Array, string": (arr10, norm5) => varianceFromM2(m2OfArray(arr10), arr10.length, norm5),
   // Parallel Float64Array variance. computePool returns POPULATION variance
   // (sum2/n); recover sum2 = pop·n and renormalize for the requested convention.
   Float64Array: async (a) => {
     const result = await computePool.variance(a);
     return varianceFromM2(result.result.variance * a.length, a.length, "unbiased");
   },
-  "Float64Array, string": async (a, norm4) => {
+  "Float64Array, string": async (a, norm5) => {
     const result = await computePool.variance(a);
-    return varianceFromM2(result.result.variance * a.length, a.length, norm4);
+    return varianceFromM2(result.result.variance * a.length, a.length, norm5);
   }
 });
 var std = mathTyped2("std", {
   Array: (arr10) => Math.sqrt(varianceFromM2(m2OfArray(arr10), arr10.length, "unbiased")),
-  "Array, string": (arr10, norm4) => Math.sqrt(varianceFromM2(m2OfArray(arr10), arr10.length, norm4)),
+  "Array, string": (arr10, norm5) => Math.sqrt(varianceFromM2(m2OfArray(arr10), arr10.length, norm5)),
   // Parallel Float64Array std — derive from the (renormalized) variance so the
   // convention matches the Array path and parallelStatStd.
   Float64Array: async (a) => {
     const result = await computePool.variance(a);
     return Math.sqrt(varianceFromM2(result.result.variance * a.length, a.length, "unbiased"));
   },
-  "Float64Array, string": async (a, norm4) => {
+  "Float64Array, string": async (a, norm5) => {
     const result = await computePool.variance(a);
     return Math.sqrt(
-      varianceFromM2(result.result.variance * a.length, a.length, norm4)
+      varianceFromM2(result.result.variance * a.length, a.length, norm5)
     );
   }
 });
@@ -3589,8 +3589,8 @@ function welchPSDJS(samples, frameLength, overlap, windowType) {
     start += hop;
   }
   if (numFrames === 0) return new Float64Array(0);
-  const norm4 = numFrames * frameLength * winPower;
-  for (let k = 0; k < psdLen; k++) psd[k] /= norm4;
+  const norm5 = numFrames * frameLength * winPower;
+  for (let k = 0; k < psdLen; k++) psd[k] /= norm5;
   for (let k = 1; k < psdLen - 1; k++) psd[k] *= 2;
   return psd;
 }
@@ -8551,18 +8551,18 @@ import { computePool as computePool7 } from "@danielsimonjr/mathts-parallel";
 var GEOMETRY_WASM_THRESHOLD = 32;
 var HULL3D_WASM_THRESHOLD = 1024;
 function angle2D(v1, v2) {
-  const dot8 = v1[0] * v2[0] + v1[1] * v2[1];
+  const dot9 = 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, dot8 / (mag1 * mag2))));
+  return Math.acos(Math.max(-1, Math.min(1, dot9 / (mag1 * mag2))));
 }
 function angle3D(v1, v2) {
-  const dot8 = v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
+  const dot9 = 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, dot8 / (mag1 * mag2))));
+  return Math.acos(Math.max(-1, Math.min(1, dot9 / (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]];
@@ -8584,7 +8584,7 @@ function polygonArea(vertices) {
   }
   return Math.abs(area2) / 2;
 }
-function convexHull(points) {
+function convexHull2D(points) {
   const n = points.length;
   if (n <= 1) return points.slice();
   if (n === 2) return points.slice();
@@ -8606,12 +8606,12 @@ function convexHull(points) {
   } else {
     sorted = points.slice().sort((a, b) => a[0] - b[0] || a[1] - b[1]);
   }
-  function cross3(o, a, b) {
+  function cross4(o, a, b) {
     return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
   }
   const lower = [];
   for (const p of sorted) {
-    while (lower.length >= 2 && cross3(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) {
+    while (lower.length >= 2 && cross4(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) {
       lower.pop();
     }
     lower.push(p);
@@ -8619,7 +8619,7 @@ function convexHull(points) {
   const upper = [];
   for (let i = sorted.length - 1; i >= 0; i--) {
     const p = sorted[i];
-    while (upper.length >= 2 && cross3(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
+    while (upper.length >= 2 && cross4(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
       upper.pop();
     }
     upper.push(p);
@@ -8667,14 +8667,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 dot8 = v.reduce((s, c, i) => s + c * n[i], 0);
-  return v.map((c, i) => c - 2 * dot8 * n[i]);
+  const dot9 = v.reduce((s, c, i) => s + c * n[i], 0);
+  return v.map((c, i) => c - 2 * dot9 * n[i]);
 }
 function projectVector(v, onto) {
-  const dot8 = v.reduce((s, c, i) => s + c * onto[i], 0);
+  const dot9 = 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 scale4 = dot8 / magSq;
+  const scale4 = dot9 / magSq;
   return onto.map((c) => c * scale4);
 }
 function distance2D(a, b) {
@@ -8750,10 +8750,10 @@ function centroid(vertices) {
   let cy = 0;
   for (let i = 0; i < n; i++) {
     const j = (i + 1) % n;
-    const cross3 = vertices[i][0] * vertices[j][1] - vertices[j][0] * vertices[i][1];
-    signedArea += cross3;
-    cx += (vertices[i][0] + vertices[j][0]) * cross3;
-    cy += (vertices[i][1] + vertices[j][1]) * cross3;
+    const cross4 = vertices[i][0] * vertices[j][1] - vertices[j][0] * vertices[i][1];
+    signedArea += cross4;
+    cx += (vertices[i][0] + vertices[j][0]) * cross4;
+    cy += (vertices[i][1] + vertices[j][1]) * cross4;
   }
   signedArea /= 2;
   cx /= 6 * signedArea;
@@ -8840,37 +8840,6 @@ function minkowskiDistance(a, b, p) {
 function delaunayTriangulation(points) {
   const n = points.length;
   if (n < 3) return [];
-  if (n >= GEOMETRY_WASM_THRESHOLD) {
-    const wasm = wasmLoader.getModule();
-    if (wasm) {
-      try {
-        const flat = new Float64Array(n * 2);
-        for (let i = 0; i < n; i++) {
-          flat[i * 2] = points[i][0];
-          flat[i * 2 + 1] = points[i][1];
-        }
-        const ptsAlloc = wasmLoader.allocateFloat64Array(flat);
-        const maxTris = 2 * n;
-        const trisAlloc = wasmLoader.allocateInt32ArrayEmpty(maxTris * 3);
-        try {
-          const numTris = wasm.delaunay_wasm(ptsAlloc.ptr, n, trisAlloc.ptr);
-          const result = [];
-          for (let i = 0; i < numTris; i++) {
-            result.push([
-              trisAlloc.array[i * 3],
-              trisAlloc.array[i * 3 + 1],
-              trisAlloc.array[i * 3 + 2]
-            ]);
-          }
-          return result;
-        } finally {
-          wasmLoader.free(ptsAlloc.ptr);
-          wasmLoader.free(trisAlloc.ptr);
-        }
-      } catch {
-      }
-    }
-  }
   let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
   for (const p of points) {
     minX = Math.min(minX, p[0]);
@@ -12230,6 +12199,446 @@ function rodasSolve(f, tspan, y0raw, options = {}) {
   }
   return { t: tOut, y: yOut };
 }
+var _EPS = Number.EPSILON;
+function _rms(v) {
+  let s = 0;
+  for (let i = 0; i < v.length; i++) s += v[i] * v[i];
+  return Math.sqrt(s / v.length);
+}
+function _selectInitialStep(f, t0, y0, tf, maxStep, f0, dir, order, rtol, atol) {
+  const interval2 = Math.abs(tf - t0);
+  if (interval2 === 0) return 0;
+  const scale4 = y0.map((yi) => atol + Math.abs(yi) * rtol);
+  const d0 = _rms(y0.map((yi, i) => yi / scale4[i]));
+  const d1 = _rms(f0.map((fi, i) => fi / scale4[i]));
+  let h0 = d0 < 1e-5 || d1 < 1e-5 ? 1e-6 : 0.01 * (d0 / d1);
+  h0 = Math.min(h0, interval2);
+  const y1 = y0.map((yi, i) => yi + h0 * dir * f0[i]);
+  const f1 = _fArr(f, t0 + h0 * dir, y1);
+  const d2 = _rms(f1.map((v, i) => (v - f0[i]) / scale4[i])) / h0;
+  const h1 = d1 <= 1e-15 && d2 <= 1e-15 ? Math.max(1e-6, h0 * 1e-3) : Math.pow(0.01 / Math.max(d1, d2), 1 / (order + 1));
+  return Math.min(100 * h0, h1, interval2, maxStep);
+}
+function _newtonTol(rtol) {
+  return Math.max(10 * _EPS / rtol, Math.min(0.03, Math.sqrt(rtol)));
+}
+function _minStep(t) {
+  return 10 * _EPS * Math.max(1, Math.abs(t));
+}
+function _matMul(A, B) {
+  const m = A.length;
+  const p = B[0].length;
+  const q = B.length;
+  const out = Array.from({ length: m }, () => new Array(p).fill(0));
+  for (let i = 0; i < m; i++) {
+    for (let k = 0; k < q; k++) {
+      const aik = A[i][k];
+      if (aik === 0) continue;
+      for (let j = 0; j < p; j++) out[i][j] += aik * B[k][j];
+    }
+  }
+  return out;
+}
+var BDF_MAX_ORDER = 5;
+var BDF_NEWTON_MAXITER = 4;
+var BDF_MIN_FACTOR = 0.2;
+var BDF_MAX_FACTOR = 10;
+var BDF_KAPPA = [0, -0.185, -1 / 9, -0.0823, -0.0415, 0];
+var BDF_GAMMA = (() => {
+  const g = [0];
+  let acc = 0;
+  for (let i = 1; i <= BDF_MAX_ORDER; i++) {
+    acc += 1 / i;
+    g.push(acc);
+  }
+  return g;
+})();
+var BDF_ALPHA = BDF_KAPPA.map((k, i) => (1 - k) * BDF_GAMMA[i]);
+var BDF_ERROR_CONST = BDF_KAPPA.map((k, i) => k * BDF_GAMMA[i] + 1 / (i + 1));
+function _bdfComputeR(order, factor2) {
+  const M = Array.from(
+    { length: order + 1 },
+    () => new Array(order + 1).fill(0)
+  );
+  for (let j = 0; j <= order; j++) M[0][j] = 1;
+  for (let i = 1; i <= order; i++) {
+    for (let j = 1; j <= order; j++) M[i][j] = (i - 1 - factor2 * j) / i;
+  }
+  for (let j = 0; j <= order; j++) {
+    for (let i = 1; i <= order; i++) M[i][j] *= M[i - 1][j];
+  }
+  return M;
+}
+function _bdfChangeD(D, order, factor2) {
+  const R = _bdfComputeR(order, factor2);
+  const U = _bdfComputeR(order, 1);
+  const RU = _matMul(R, U);
+  const n = D[0].length;
+  const newTop = Array.from({ length: order + 1 }, () => new Array(n).fill(0));
+  for (let i = 0; i <= order; i++) {
+    for (let j = 0; j <= order; j++) {
+      const c = RU[j][i];
+      if (c === 0) continue;
+      const Dj = D[j];
+      const row2 = newTop[i];
+      for (let k = 0; k < n; k++) row2[k] += c * Dj[k];
+    }
+  }
+  for (let i = 0; i <= order; i++) D[i] = newTop[i];
+}
+function _bdfNewton(f, tNew, yPredict, c, psi, solveW, scale4, tol) {
+  const n = yPredict.length;
+  const d = new Array(n).fill(0);
+  const y = yPredict.slice();
+  let dyNormOld = null;
+  let converged = false;
+  let k = 0;
+  for (; k < BDF_NEWTON_MAXITER; k++) {
+    const fv = _fArr(f, tNew, y);
+    if (!fv.every((v) => Number.isFinite(v))) break;
+    const rhs = fv.map((v, i) => c * v - psi[i] - d[i]);
+    const dy = solveW(rhs);
+    const dyNorm = _rms(dy.map((v, i) => v / scale4[i]));
+    const rate = dyNormOld === null ? null : dyNorm / dyNormOld;
+    if (rate !== null && (rate >= 1 || Math.pow(rate, BDF_NEWTON_MAXITER - k) / (1 - rate) * dyNorm > tol)) {
+      break;
+    }
+    for (let i = 0; i < n; i++) {
+      y[i] += dy[i];
+      d[i] += dy[i];
+    }
+    if (dyNorm === 0 || rate !== null && rate / (1 - rate) * dyNorm < tol) {
+      converged = true;
+      k++;
+      break;
+    }
+    dyNormOld = dyNorm;
+  }
+  return { converged, nIter: k, y, d };
+}
+function bdfSolve(f, tspan, y0raw, options = {}) {
+  const t0 = tspan[0];
+  const tf = tspan[1];
+  if (!(typeof t0 === "number" && typeof tf === "number")) {
+    throw new Error('The "BDF" stiff method requires numeric tspan');
+  }
+  if (!y0raw.every((v) => typeof v === "number")) {
+    throw new Error('The "BDF" stiff method requires plain-number state (y0)');
+  }
+  const y0 = y0raw;
+  const n = y0.length;
+  const dir = tf >= t0 ? 1 : -1;
+  const rtol = options.tol ? options.tol : 1e-4;
+  const atol = rtol * 1e-3;
+  const maxIter = options.maxIter ? options.maxIter : 1e5;
+  const maxStep = options.maxStep ?? Infinity;
+  const newtonTol = _newtonTol(rtol);
+  let t = t0;
+  let y = y0.slice();
+  const f0 = _fArr(f, t, y);
+  let hAbs = options.firstStep ? Math.abs(options.firstStep) : _selectInitialStep(f, t0, y0, tf, maxStep, f0, dir, 1, rtol, atol);
+  const D = Array.from(
+    { length: BDF_MAX_ORDER + 3 },
+    () => new Array(n).fill(0)
+  );
+  D[0] = y.slice();
+  D[1] = f0.map((v) => v * hAbs * dir);
+  let order = 1;
+  let nEqualSteps = 0;
+  const tOut = [t];
+  const yOut = [y.slice()];
+  let iter = 0;
+  while ((dir > 0 ? t < tf : t > tf) && iter < maxIter) {
+    iter++;
+    const minStep = _minStep(t);
+    if (hAbs > maxStep) {
+      _bdfChangeD(D, order, maxStep / hAbs);
+      hAbs = maxStep;
+      nEqualSteps = 0;
+    } else if (hAbs < minStep) {
+      _bdfChangeD(D, order, minStep / hAbs);
+      hAbs = minStep;
+      nEqualSteps = 0;
+    }
+    const F0 = _fArr(f, t, y);
+    const J = _jacobianAt(f, t, y, F0, options);
+    let stepAccepted = false;
+    let yNew = y;
+    let dVec = new Array(n).fill(0);
+    let errorNorm = 0;
+    let nIter = 1;
+    let scale4 = new Array(n).fill(1);
+    while (!stepAccepted) {
+      if (hAbs < minStep) {
+        throw new Error("Required step size is less than spacing between numbers (BDF)");
+      }
+      let h = hAbs * dir;
+      let tNew = t + h;
+      if (dir * (tNew - tf) > 0) {
+        tNew = tf;
+        _bdfChangeD(D, order, Math.abs(tNew - t) / hAbs);
+        nEqualSteps = 0;
+      }
+      h = tNew - t;
+      hAbs = Math.abs(h);
+      const yPredict = new Array(n).fill(0);
+      for (let j = 0; j <= order; j++) for (let k = 0; k < n; k++) yPredict[k] += D[j][k];
+      scale4 = yPredict.map((v) => atol + rtol * Math.abs(v));
+      const psi = new Array(n).fill(0);
+      for (let k = 0; k < n; k++) {
+        let s = 0;
+        for (let j = 1; j <= order; j++) s += D[j][k] * BDF_GAMMA[j];
+        psi[k] = s / BDF_ALPHA[order];
+      }
+      const c = h / BDF_ALPHA[order];
+      const W = J.map((rowv, i) => rowv.map((v, j) => (i === j ? 1 : 0) - c * v));
+      const solveW = _factorSolver(W, n);
+      const res = _bdfNewton(f, tNew, yPredict, c, psi, solveW, scale4, newtonTol);
+      if (!res.converged) {
+        hAbs *= 0.5;
+        _bdfChangeD(D, order, 0.5);
+        nEqualSteps = 0;
+        continue;
+      }
+      nIter = res.nIter;
+      yNew = res.y;
+      dVec = res.d;
+      const safety2 = 0.9 * (2 * BDF_NEWTON_MAXITER + 1) / (2 * BDF_NEWTON_MAXITER + nIter);
+      scale4 = yNew.map((v) => atol + rtol * Math.abs(v));
+      errorNorm = _rms(dVec.map((v, i) => BDF_ERROR_CONST[order] * v / scale4[i]));
+      if (errorNorm > 1) {
+        const factor3 = Math.max(BDF_MIN_FACTOR, safety2 * Math.pow(errorNorm, -1 / (order + 1)));
+        hAbs *= factor3;
+        _bdfChangeD(D, order, factor3);
+        nEqualSteps = 0;
+      } else {
+        stepAccepted = true;
+      }
+      if (stepAccepted) {
+        t = tNew;
+        y = yNew;
+        tOut.push(t);
+        yOut.push(y.slice());
+      }
+    }
+    nEqualSteps++;
+    const safety = 0.9 * (2 * BDF_NEWTON_MAXITER + 1) / (2 * BDF_NEWTON_MAXITER + nIter);
+    for (let k = 0; k < n; k++) {
+      D[order + 2][k] = dVec[k] - D[order + 1][k];
+      D[order + 1][k] = dVec[k];
+    }
+    for (let i = order; i >= 0; i--) for (let k = 0; k < n; k++) D[i][k] += D[i + 1][k];
+    if (nEqualSteps < order + 1) continue;
+    const errM = order > 1 ? _rms(D[order].map((v, i) => BDF_ERROR_CONST[order - 1] * v / scale4[i])) : Infinity;
+    const errP = order < BDF_MAX_ORDER ? _rms(D[order + 2].map((v, i) => BDF_ERROR_CONST[order + 1] * v / scale4[i])) : Infinity;
+    const errNorms = [errM, errorNorm, errP];
+    const factors = errNorms.map((e, i) => Math.pow(e, -1 / (order + i)));
+    let best = 0;
+    for (let i = 1; i < 3; i++) if (factors[i] > factors[best]) best = i;
+    order += best - 1;
+    const factor2 = Math.min(BDF_MAX_FACTOR, safety * factors[best]);
+    hAbs *= factor2;
+    _bdfChangeD(D, order, factor2);
+    nEqualSteps = 0;
+  }
+  if (iter >= maxIter) {
+    throw new Error("Maximum number of iterations reached, try changing options");
+  }
+  return { t: tOut, y: yOut };
+}
+var RADAU_NEWTON_MAXITER = 6;
+var RADAU_MIN_FACTOR = 0.2;
+var RADAU_MAX_FACTOR = 10;
+var _S6 = Math.sqrt(6);
+var RADAU_A = [
+  [(88 - 7 * _S6) / 360, (296 - 169 * _S6) / 1800, (-2 + 3 * _S6) / 225],
+  [(296 + 169 * _S6) / 1800, (88 + 7 * _S6) / 360, (-2 - 3 * _S6) / 225],
+  [(16 - _S6) / 36, (16 + _S6) / 36, 1 / 9]
+];
+var RADAU_C = [(4 - _S6) / 10, (4 + _S6) / 10, 1];
+var RADAU_E = [(-13 - 7 * _S6) / 3, (-13 + 7 * _S6) / 3, -1 / 3];
+var RADAU_MU_REAL = 3 + Math.pow(3, 2 / 3) - Math.pow(3, 1 / 3);
+function _radauPredictFactor(hAbs, hAbsOld, errNorm, errNormOld) {
+  const mult = errNormOld === null || hAbsOld === null || errNorm === 0 ? 1 : hAbs / hAbsOld * Math.pow(errNormOld / errNorm, 0.25);
+  return Math.min(1, mult) * Math.pow(errNorm, -0.25);
+}
+function _radauNewton(f, t, y, h, J, scale4, tol) {
+  const n = y.length;
+  const Z = [
+    new Array(n).fill(0),
+    new Array(n).fill(0),
+    new Array(n).fill(0)
+  ];
+  const big = Array.from({ length: 3 * n }, () => new Array(3 * n).fill(0));
+  for (let i = 0; i < 3; i++) {
+    for (let k2 = 0; k2 < 3; k2++) {
+      const a = h * RADAU_A[i][k2];
+      for (let r = 0; r < n; r++) {
+        for (let col = 0; col < n; col++) {
+          big[i * n + r][k2 * n + col] = (i === k2 && r === col ? 1 : 0) - a * J[r][col];
+        }
+      }
+    }
+  }
+  const solveBig = _factorSolver(big, 3 * n);
+  let dWNormOld = null;
+  let rate = 0;
+  let converged = false;
+  let k = 0;
+  for (; k < RADAU_NEWTON_MAXITER; k++) {
+    const F = [
+      _fArr(
+        f,
+        t + RADAU_C[0] * h,
+        y.map((yi, r) => yi + Z[0][r])
+      ),
+      _fArr(
+        f,
+        t + RADAU_C[1] * h,
+        y.map((yi, r) => yi + Z[1][r])
+      ),
+      _fArr(
+        f,
+        t + RADAU_C[2] * h,
+        y.map((yi, r) => yi + Z[2][r])
+      )
+    ];
+    if (!F.every((row2) => row2.every((v) => Number.isFinite(v)))) break;
+    const rhs = new Array(3 * n).fill(0);
+    for (let i = 0; i < 3; i++) {
+      for (let r = 0; r < n; r++) {
+        let acc = Z[i][r];
+        for (let j = 0; j < 3; j++) acc -= h * RADAU_A[i][j] * F[j][r];
+        rhs[i * n + r] = -acc;
+      }
+    }
+    const dZ = solveBig(rhs);
+    let sq = 0;
+    for (let i = 0; i < 3; i++) for (let r = 0; r < n; r++) sq += (dZ[i * n + r] / scale4[r]) ** 2;
+    const dWNorm = Math.sqrt(sq / (3 * n));
+    if (dWNormOld !== null) rate = dWNorm / dWNormOld;
+    if (dWNormOld !== null && (rate >= 1 || Math.pow(rate, RADAU_NEWTON_MAXITER - k) / (1 - rate) * dWNorm > tol)) {
+      break;
+    }
+    for (let i = 0; i < 3; i++) for (let r = 0; r < n; r++) Z[i][r] += dZ[i * n + r];
+    if (dWNorm === 0 || dWNormOld !== null && rate / (1 - rate) * dWNorm < tol) {
+      converged = true;
+      k++;
+      break;
+    }
+    dWNormOld = dWNorm;
+  }
+  return { converged, nIter: k, Z, rate };
+}
+function radauSolve(f, tspan, y0raw, options = {}) {
+  const t0 = tspan[0];
+  const tf = tspan[1];
+  if (!(typeof t0 === "number" && typeof tf === "number")) {
+    throw new Error('The "Radau" stiff method requires numeric tspan');
+  }
+  if (!y0raw.every((v) => typeof v === "number")) {
+    throw new Error('The "Radau" stiff method requires plain-number state (y0)');
+  }
+  const y0 = y0raw;
+  const n = y0.length;
+  const dir = tf >= t0 ? 1 : -1;
+  const rtol = options.tol ? options.tol : 1e-4;
+  const atol = rtol * 1e-3;
+  const maxIter = options.maxIter ? options.maxIter : 1e5;
+  const maxStep = options.maxStep ?? Infinity;
+  const newtonTol = _newtonTol(rtol);
+  let t = t0;
+  let y = y0.slice();
+  let hAbs = options.firstStep ? Math.abs(options.firstStep) : _selectInitialStep(f, t0, y0, tf, maxStep, _fArr(f, t, y), dir, 3, rtol, atol);
+  let hAbsOld = null;
+  let errNormOld = null;
+  const tOut = [t];
+  const yOut = [y.slice()];
+  let iter = 0;
+  while ((dir > 0 ? t < tf : t > tf) && iter < maxIter) {
+    iter++;
+    const minStep = _minStep(t);
+    let hEntry;
+    if (hAbs > maxStep) {
+      hEntry = maxStep;
+      hAbs = maxStep;
+      hAbsOld = null;
+      errNormOld = null;
+    } else if (hAbs < minStep) {
+      hEntry = minStep;
+      hAbs = minStep;
+      hAbsOld = null;
+      errNormOld = null;
+    } else {
+      hEntry = hAbs;
+    }
+    const f0 = _fArr(f, t, y);
+    const J = _jacobianAt(f, t, y, f0, options);
+    let stepAccepted = false;
+    let rejected = false;
+    let yNew = y;
+    let errNorm = 0;
+    let nIter = 1;
+    let tNew = t;
+    while (!stepAccepted) {
+      if (hAbs < minStep) {
+        throw new Error("Required step size is less than spacing between numbers (Radau)");
+      }
+      let h = hAbs * dir;
+      tNew = t + h;
+      if (dir * (tNew - tf) > 0) tNew = tf;
+      h = tNew - t;
+      hAbs = Math.abs(h);
+      const scale4 = y.map((yi) => atol + Math.abs(yi) * rtol);
+      const res = _radauNewton(f, t, y, h, J, scale4, newtonTol);
+      if (!res.converged) {
+        hAbs *= 0.5;
+        continue;
+      }
+      nIter = res.nIter;
+      const Z = res.Z;
+      yNew = y.map((yi, r) => yi + Z[2][r]);
+      const ze = new Array(n).fill(0);
+      for (let r = 0; r < n; r++) {
+        ze[r] = f0[r] + (RADAU_E[0] * Z[0][r] + RADAU_E[1] * Z[1][r] + RADAU_E[2] * Z[2][r]) / h;
+      }
+      const Merr = J.map((rowv, i) => rowv.map((v, j) => (i === j ? RADAU_MU_REAL / h : 0) - v));
+      const solveErr = _factorSolver(Merr, n);
+      let error = solveErr(ze);
+      const escale = y.map((yi, r) => atol + Math.max(Math.abs(yi), Math.abs(yNew[r])) * rtol);
+      errNorm = _rms(error.map((v, r) => v / escale[r]));
+      const safety2 = 0.9 * (2 * RADAU_NEWTON_MAXITER + 1) / (2 * RADAU_NEWTON_MAXITER + nIter);
+      if (rejected && errNorm > 1) {
+        const yErr = y.map((yi, r) => yi + error[r]);
+        const fErr = _fArr(f, t, yErr);
+        error = solveErr(fErr.map((v, r) => v + ze[r] - f0[r]));
+        errNorm = _rms(error.map((v, r) => v / escale[r]));
+      }
+      if (errNorm > 1) {
+        const factor3 = _radauPredictFactor(hAbs, hAbsOld, errNorm, errNormOld);
+        hAbs *= Math.max(RADAU_MIN_FACTOR, safety2 * factor3);
+        rejected = true;
+      } else {
+        stepAccepted = true;
+      }
+    }
+    const safety = 0.9 * (2 * RADAU_NEWTON_MAXITER + 1) / (2 * RADAU_NEWTON_MAXITER + nIter);
+    let factor2 = _radauPredictFactor(hAbs, hAbsOld, errNorm, errNormOld);
+    factor2 = Math.min(RADAU_MAX_FACTOR, safety * factor2);
+    if (factor2 < 1.2) factor2 = 1;
+    hAbsOld = hEntry;
+    errNormOld = errNorm;
+    t = tNew;
+    y = yNew;
+    tOut.push(t);
+    yOut.push(y.slice());
+    hAbs *= factor2;
+  }
+  if (iter >= maxIter) {
+    throw new Error("Maximum number of iterations reached, try changing options");
+  }
+  return { t: tOut, y: yOut };
+}
 var createSolveODE = /* @__PURE__ */ factory(
   name,
   dependencies,
@@ -12536,7 +12945,9 @@ var createSolveODE = /* @__PURE__ */ factory(
         RK23: _rk23,
         RK45: _rk45,
         ROSENBROCK: rosenbrockSolve,
-        RODAS: rodasSolve
+        RODAS: rodasSolve,
+        BDF: bdfSolve,
+        RADAU: radauSolve
       };
       if (method.toUpperCase() in methods) {
         const methodOptions = { ...opt };
@@ -13446,9 +13857,84 @@ function powerfit(xs, ys) {
   const lna = (sy - b * sx) / n;
   return [Math.exp(lna), b];
 }
+var _DP_C = [0, 1 / 5, 3 / 10, 4 / 5, 8 / 9, 1, 1];
+var _DP_A = [
+  [],
+  [1 / 5],
+  [3 / 40, 9 / 40],
+  [44 / 45, -56 / 15, 32 / 9],
+  [19372 / 6561, -25360 / 2187, 64448 / 6561, -212 / 729],
+  [9017 / 3168, -355 / 33, 46732 / 5247, 49 / 176, -5103 / 18656],
+  [35 / 384, 0, 500 / 1113, 125 / 192, -2187 / 6784, 11 / 84]
+];
+var _DP_B = [35 / 384, 0, 500 / 1113, 125 / 192, -2187 / 6784, 11 / 84, 0];
+var _DP_BHAT = [5179 / 57600, 0, 7571 / 16695, 393 / 640, -92097 / 339200, 187 / 2100, 1 / 40];
+function _adaptiveRK45System(f, y0, tspan, tol, maxSteps) {
+  const n = y0.length;
+  const [t0, tf] = tspan;
+  const dir = tf >= t0 ? 1 : -1;
+  const rtol = tol;
+  const atol = tol * 1e-3;
+  const ts = [t0];
+  const ys = [y0.slice()];
+  let t = t0;
+  let y = y0.slice();
+  const f0 = f(t, y);
+  const rms = (v) => {
+    let s = 0;
+    for (let i = 0; i < v.length; i++) s += v[i] * v[i];
+    return Math.sqrt(s / v.length);
+  };
+  const d0 = rms(y);
+  const d1 = rms(f0);
+  let h = dir * Math.min(d0 < 1e-5 || d1 < 1e-5 ? 1e-6 : 0.01 * (d0 / d1), Math.abs(tf - t0));
+  let steps = 0;
+  while ((dir > 0 ? t < tf : t > tf) && steps < maxSteps) {
+    steps++;
+    if (Math.abs(h) > Math.abs(tf - t)) h = tf - t;
+    const k = [f(t, y)];
+    for (let s = 1; s < 7; s++) {
+      const ys_ = y.slice();
+      for (let j = 0; j < s; j++) {
+        const aij = _DP_A[s][j];
+        if (aij === 0) continue;
+        for (let i = 0; i < n; i++) ys_[i] += h * aij * k[j][i];
+      }
+      k.push(f(t + _DP_C[s] * h, ys_));
+    }
+    const yNew = y.slice();
+    let errNorm = 0;
+    for (let i = 0; i < n; i++) {
+      let sum5 = 0;
+      let errI = 0;
+      for (let s = 0; s < 7; s++) {
+        sum5 += _DP_B[s] * k[s][i];
+        errI += (_DP_B[s] - _DP_BHAT[s]) * k[s][i];
+      }
+      yNew[i] = y[i] + h * sum5;
+      const sc = atol + rtol * Math.max(Math.abs(y[i]), Math.abs(yNew[i]));
+      errNorm += (h * errI / sc) ** 2;
+    }
+    errNorm = Math.sqrt(errNorm / n);
+    if (errNorm <= 1 || Math.abs(h) <= 1e-14 * Math.abs(t)) {
+      t += h;
+      y = yNew;
+      ts.push(t);
+      ys.push(y.slice());
+    }
+    h *= Math.min(5, Math.max(0.2, 0.9 * Math.pow(errNorm || 1e-10, -1 / 5)));
+  }
+  if (steps >= maxSteps) {
+    throw new Error("Maximum number of steps reached in solveODESystem, try changing options");
+  }
+  return { t: ts, y: ys };
+}
 function solveODESystem(f, y0, tspan, opts) {
+  if (opts?.dt === void 0) {
+    return _adaptiveRK45System(f, y0, tspan, opts?.tol ?? 1e-6, opts?.maxSteps ?? 1e5);
+  }
   const n = y0.length;
-  const dt = opts?.dt ?? (tspan[1] - tspan[0]) / 200;
+  const dt = opts.dt;
   const nSteps = Math.ceil((tspan[1] - tspan[0]) / dt);
   const h = (tspan[1] - tspan[0]) / nSteps;
   const ts = [tspan[0]];
@@ -15157,11 +15643,11 @@ function _eigenvectorOnce(adj, maxIter, tol, seed) {
         if (adj[j][i] > 0) next[i] += adj[j][i] * x[j];
       }
     }
-    let norm4 = 0;
-    for (let i = 0; i < n; i++) norm4 += next[i] * next[i];
-    norm4 = Math.sqrt(norm4);
-    if (norm4 < 1e-15) break;
-    for (let i = 0; i < n; i++) next[i] /= norm4;
+    let norm5 = 0;
+    for (let i = 0; i < n; i++) norm5 += next[i] * next[i];
+    norm5 = Math.sqrt(norm5);
+    if (norm5 < 1e-15) break;
+    for (let i = 0; i < n; i++) next[i] /= norm5;
     let delta = 0;
     for (let i = 0; i < n; i++) delta = Math.max(delta, Math.abs(next[i] - x[i]));
     x = next;
@@ -15174,9 +15660,9 @@ function _aggregateEigenvector(vectors, aggregation) {
   const count2 = vectors.length;
   const ref = vectors[0];
   const aligned = vectors.map((v) => {
-    let dot8 = 0;
-    for (let i = 0; i < n; i++) dot8 += v[i] * ref[i];
-    if (dot8 < 0) {
+    let dot9 = 0;
+    for (let i = 0; i < n; i++) dot9 += v[i] * ref[i];
+    if (dot9 < 0) {
       const flipped = new Float64Array(n);
       for (let i = 0; i < n; i++) flipped[i] = -v[i];
       return flipped;
@@ -15188,11 +15674,11 @@ function _aggregateEigenvector(vectors, aggregation) {
     for (let i = 0; i < n; i++) mean7[i] += v[i];
   }
   for (let i = 0; i < n; i++) mean7[i] /= count2;
-  let norm4 = 0;
-  for (let i = 0; i < n; i++) norm4 += mean7[i] * mean7[i];
-  norm4 = Math.sqrt(norm4);
-  if (norm4 > 1e-15) {
-    for (let i = 0; i < n; i++) mean7[i] /= norm4;
+  let norm5 = 0;
+  for (let i = 0; i < n; i++) norm5 += mean7[i] * mean7[i];
+  norm5 = Math.sqrt(norm5);
+  if (norm5 > 1e-15) {
+    for (let i = 0; i < n; i++) mean7[i] /= norm5;
   }
   if (aggregation === "mean") {
     return { centrality: mean7 };
@@ -17103,11 +17589,11 @@ function principalComponentAnalysis(data, k) {
           Av[i] += A[i][j] * v[j];
         }
       }
-      let norm4 = 0;
-      for (let i = 0; i < p; i++) norm4 += Av[i] * Av[i];
-      norm4 = Math.sqrt(norm4);
-      if (norm4 === 0) break;
-      const vNew = Av.map((x) => x / norm4);
+      let norm5 = 0;
+      for (let i = 0; i < p; i++) norm5 += Av[i] * Av[i];
+      norm5 = Math.sqrt(norm5);
+      if (norm5 === 0) break;
+      const vNew = Av.map((x) => x / norm5);
       let diff2 = 0;
       for (let i = 0; i < p; i++) diff2 += (vNew[i] - v[i]) ** 2;
       v = vNew;
@@ -17132,9 +17618,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 dot8 = 0;
-      for (let j = 0; j < p; j++) dot8 += row2[j] * ev[j];
-      return dot8;
+      let dot9 = 0;
+      for (let j = 0; j < p; j++) dot9 += row2[j] * ev[j];
+      return dot9;
     });
   });
   return { components: eigenvectors, explained, scores };
@@ -17733,30 +18219,30 @@ function hessenbergForm(A) {
     if (normV < 1e-30) continue;
     const beta2 = 2 / normV;
     for (let j = k; j < n; j++) {
-      let dot8 = 0;
+      let dot9 = 0;
       for (let i = 0; i < len; i++) {
-        dot8 += v[i] * H[k + 1 + i][j];
+        dot9 += v[i] * H[k + 1 + i][j];
       }
       for (let i = 0; i < len; i++) {
-        H[k + 1 + i][j] -= beta2 * v[i] * dot8;
+        H[k + 1 + i][j] -= beta2 * v[i] * dot9;
       }
     }
     for (let i = 0; i < n; i++) {
-      let dot8 = 0;
+      let dot9 = 0;
       for (let j = 0; j < len; j++) {
-        dot8 += H[i][k + 1 + j] * v[j];
+        dot9 += H[i][k + 1 + j] * v[j];
       }
       for (let j = 0; j < len; j++) {
-        H[i][k + 1 + j] -= beta2 * dot8 * v[j];
+        H[i][k + 1 + j] -= beta2 * dot9 * v[j];
       }
     }
     for (let i = 0; i < n; i++) {
-      let dot8 = 0;
+      let dot9 = 0;
       for (let j = 0; j < len; j++) {
-        dot8 += Q2[i][k + 1 + j] * v[j];
+        dot9 += Q2[i][k + 1 + j] * v[j];
       }
       for (let j = 0; j < len; j++) {
-        Q2[i][k + 1 + j] -= beta2 * dot8 * v[j];
+        Q2[i][k + 1 + j] -= beta2 * dot9 * v[j];
       }
     }
   }
@@ -18125,11 +18611,11 @@ function findKernelVector(A, n, tol) {
       }
     }
   }
-  let norm4 = 0;
-  for (let i = 0; i < n; i++) norm4 += v[i] * v[i];
-  norm4 = Math.sqrt(norm4);
-  if (norm4 > 1e-15) {
-    for (let i = 0; i < n; i++) v[i] /= norm4;
+  let norm5 = 0;
+  for (let i = 0; i < n; i++) norm5 += v[i] * v[i];
+  norm5 = Math.sqrt(norm5);
+  if (norm5 > 1e-15) {
+    for (let i = 0; i < n; i++) v[i] /= norm5;
   }
   return v;
 }
@@ -18166,11 +18652,11 @@ async function solveApprox(A, b, n) {
     }
   }
   const x = M.map((row2) => row2[n]);
-  let norm4 = 0;
-  for (let i = 0; i < n; i++) norm4 += x[i] * x[i];
-  norm4 = Math.sqrt(norm4);
-  if (norm4 > 1e-15) {
-    for (let i = 0; i < n; i++) x[i] /= norm4;
+  let norm5 = 0;
+  for (let i = 0; i < n; i++) norm5 += x[i] * x[i];
+  norm5 = Math.sqrt(norm5);
+  if (norm5 > 1e-15) {
+    for (let i = 0; i < n; i++) x[i] /= norm5;
   }
   return x;
 }
@@ -30180,7 +30666,7 @@ var createPinv = /* @__PURE__ */ factory(
     deepEqual: deepEqual3,
     equal: equal2,
     dotDivide: dotDivide2,
-    dot: dot8,
+    dot: dot9,
     ctranspose: ctranspose2,
     divideScalar: divideScalar2,
     multiply: multiply2,
@@ -30196,7 +30682,7 @@ var createPinv = /* @__PURE__ */ factory(
             if (size2[0] === 1) {
               return inv3(x);
             } else {
-              return dotDivide2(ctranspose2(x), dot8(x, x));
+              return dotDivide2(ctranspose2(x), dot9(x, x));
             }
           case 2: {
             if (_isZeros(x)) return ctranspose2(x);
@@ -30275,8 +30761,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(dot8(rref[j], rref[j]))));
-      const F = rref.filter((_, i) => !_isZero(dot8(rref[i], rref[i])));
+      const C = mat.map((row2) => row2.filter((_, j) => j < rows && !_isZero(dot9(rref[j], rref[j]))));
+      const F = rref.filter((_, i) => !_isZero(dot9(rref[i], rref[i])));
       return { C, F };
     }
     function _isZero(x) {
@@ -37197,7 +37683,7 @@ function createComplexEigs({
   larger: larger2,
   smaller: smaller2,
   matrixFromColumns: _matrixFromColumns,
-  dot: dot8
+  dot: dot9
 }) {
   function complexEigs(arr10, N, prec, type, findVectors = true) {
     if (!findVectors && type === "number" && N * N >= WASM_EIGS_THRESHOLD) {
@@ -37568,11 +38054,11 @@ function createComplexEigs({
       M[i] = Array(N).fill(0);
     }
     let I2 = 0;
-    for (const sub2 of arr10) {
-      const n = sub2.length;
+    for (const sub3 of arr10) {
+      const n = sub3.length;
       for (let i = 0; i < n; i++) {
         for (let j = 0; j < n; j++) {
-          M[I2 + i][I2 + j] = sub2[i][j];
+          M[I2 + i][I2 + j] = sub3[i][j];
         }
       }
       I2 += n;
@@ -37598,7 +38084,7 @@ function createComplexEigs({
       } catch {
         continue;
       }
-      if (larger2(norm4(b), largeNum)) {
+      if (larger2(norm5(b), largeNum)) {
         break;
       }
     }
@@ -37608,13 +38094,13 @@ function createComplexEigs({
     i = 0;
     while (true) {
       const c = usolve2(A, b);
-      if (smaller2(norm4(orthogonalComplement(b, [c])), prec)) {
+      if (smaller2(norm5(orthogonalComplement(b, [c])), prec)) {
         break;
       }
       if (++i >= 10) {
         return null;
       }
-      b = normalize2(c, type);
+      b = normalize3(c, type);
     }
     return b;
   }
@@ -37629,7 +38115,7 @@ function createComplexEigs({
       v = v.map((n) => complex3(n));
     }
     v = orthogonalComplement(v, orthog);
-    return normalize2(v, type);
+    return normalize3(v, type);
   }
   function orthogonalComplement(v, orthog) {
     const vectorShape = size2(v);
@@ -37638,21 +38124,21 @@ function createComplexEigs({
       v = subtract3(
         v,
         multiply2(
-          divideScalar2(dot8(w, v), dot8(w, w)),
+          divideScalar2(dot9(w, v), dot9(w, w)),
           w
         )
       );
     }
     return v;
   }
-  function norm4(v) {
-    return abs2(sqrt2(dot8(v, v)));
+  function norm5(v) {
+    return abs2(sqrt2(dot9(v, v)));
   }
-  function normalize2(v, type) {
+  function normalize3(v, type) {
     const big = type === "BigNumber";
     const cplx = type === "Complex";
     const one = big ? bignumber2(1) : cplx ? complex3(1) : 1;
-    return multiply2(divideScalar2(one, norm4(v)), v);
+    return multiply2(divideScalar2(one, norm5(v)), v);
   }
   return complexEigs;
 }
@@ -38066,7 +38552,7 @@ var createEigs = /* @__PURE__ */ factory(
     re: re3,
     smaller: smaller2,
     matrixFromColumns: matrixFromColumns2,
-    dot: dot8
+    dot: dot9
   }) => {
     const doRealSymmetric = createRealSymmetric({
       config: config2,
@@ -38105,7 +38591,7 @@ var createEigs = /* @__PURE__ */ factory(
       larger: larger2,
       smaller: smaller2,
       matrixFromColumns: matrixFromColumns2,
-      dot: dot8
+      dot: dot9
     });
     return typed3("eigs", {
       // The conversion to matrix in the first two implementations,
@@ -40852,7 +41338,7 @@ var createRotationMatrix = /* @__PURE__ */ factory(
     multiplyScalar: multiplyScalar2,
     addScalar: addScalar2,
     unaryMinus: unaryMinus2,
-    norm: norm4,
+    norm: norm5,
     BigNumber: BigNumber9,
     matrix: matrix2,
     DenseMatrix: DenseMatrix7,
@@ -40926,7 +41412,7 @@ var createRotationMatrix = /* @__PURE__ */ factory(
       return data;
     }
     function _rotationMatrix3x3(theta, v, format4) {
-      const normV = norm4(v);
+      const normV = norm5(v);
       if (normV === 0) {
         throw new RangeError("Rotation around zero vector");
       }
@@ -42963,11 +43449,11 @@ function multivariateTaylor(expr, vars, x0, n = 1) {
         const fmp = evalWith(expr, s);
         s[vars[j]] = x0[j] - h;
         const fmm = evalWith(expr, s);
-        const cross3 = (fpp - fpm - fmp + fmm) / (4 * h * h);
-        if (Math.abs(cross3) < 1e-12) continue;
+        const cross4 = (fpp - fpm - fmp + fmm) / (4 * h * h);
+        if (Math.abs(cross4) < 1e-12) continue;
         const xi = x0[i] === 0 ? vars[i] : `(${vars[i]} - ${formatCoeff(x0[i])})`;
         const xj = x0[j] === 0 ? vars[j] : `(${vars[j]} - ${formatCoeff(x0[j])})`;
-        terms.push(`${formatCoeff(cross3)}*${xi}*${xj}`);
+        terms.push(`${formatCoeff(cross4)}*${xi}*${xj}`);
       }
     }
   }
@@ -45950,12 +46436,12 @@ function svds(A, k = 1, opts) {
 }
 
 // src/numeric/structured-solvers.ts
-function thomasSolve(sub2, diag2, sup, d) {
+function thomasSolve(sub3, diag2, sup, d) {
   const n = diag2.length;
   if (n === 0) return [];
-  if (sub2.length !== n - 1 || sup.length !== n - 1 || d.length !== n) {
+  if (sub3.length !== n - 1 || sup.length !== n - 1 || d.length !== n) {
     throw new Error(
-      `thomasSolve: expected sub/sup of length ${n - 1} and d of length ${n}, got sub=${sub2.length}, sup=${sup.length}, d=${d.length}`
+      `thomasSolve: expected sub/sup of length ${n - 1} and d of length ${n}, got sub=${sub3.length}, sup=${sup.length}, d=${d.length}`
     );
   }
   const cp = new Array(n).fill(0);
@@ -45964,12 +46450,12 @@ function thomasSolve(sub2, diag2, sup, d) {
   cp[0] = n > 1 ? sup[0] / diag2[0] : 0;
   dp[0] = d[0] / diag2[0];
   for (let i = 1; i < n; i++) {
-    const m = diag2[i] - sub2[i - 1] * cp[i - 1];
+    const m = diag2[i] - sub3[i - 1] * cp[i - 1];
     if (m === 0) {
       throw new Error(`thomasSolve: zero pivot at row ${i} (no pivoting is performed)`);
     }
     cp[i] = i < n - 1 ? sup[i] / m : 0;
-    dp[i] = (d[i] - sub2[i - 1] * dp[i - 1]) / m;
+    dp[i] = (d[i] - sub3[i - 1] * dp[i - 1]) / m;
   }
   const x = new Array(n);
   x[n - 1] = dp[n - 1];
@@ -47554,17 +48040,17 @@ function nelderMead(f, x0, opts = {}) {
     return c;
   };
   const add4 = (a, b, s) => a.map((v, i) => v + s * b[i]);
-  const sub2 = (a, b) => a.map((v, i) => v - b[i]);
+  const sub3 = (a, b) => a.map((v, i) => v - b[i]);
   for (; iter < maxIter; iter++) {
     const order = fv.map((_, i) => i).sort((i, j) => fv[i] - fv[j]);
     simplex = order.map((i) => simplex[i]);
     fv = order.map((i) => fv[i]);
     if (Math.abs(fv[n] - fv[0]) <= tol * (Math.abs(fv[0]) + tol)) break;
     const c = centroid2(simplex.slice(0, n));
-    const xr = add4(c, sub2(c, simplex[n]), alpha);
+    const xr = add4(c, sub3(c, simplex[n]), alpha);
     const fr = f(xr);
     if (fr < fv[0]) {
-      const xe = add4(c, sub2(c, simplex[n]), gamma2);
+      const xe = add4(c, sub3(c, simplex[n]), gamma2);
       const fe = f(xe);
       if (fe < fr) {
         simplex[n] = xe;
@@ -47577,14 +48063,14 @@ function nelderMead(f, x0, opts = {}) {
       simplex[n] = xr;
       fv[n] = fr;
     } else {
-      const xc = add4(c, sub2(simplex[n], c), rho);
+      const xc = add4(c, sub3(simplex[n], c), rho);
       const fc = f(xc);
       if (fc < fv[n]) {
         simplex[n] = xc;
         fv[n] = fc;
       } else {
         for (let i = 1; i <= n; i++) {
-          simplex[i] = add4(simplex[0], sub2(simplex[i], simplex[0]), sigma);
+          simplex[i] = add4(simplex[0], sub3(simplex[i], simplex[0]), sigma);
           fv[i] = f(simplex[i]);
         }
       }
@@ -50204,12 +50690,12 @@ function rickerWavelet(points, scale4) {
   return out;
 }
 function morletWavelet(points, scale4) {
-  const norm4 = 1 / (Math.sqrt(scale4) * Math.pow(Math.PI, 0.25));
+  const norm5 = 1 / (Math.sqrt(scale4) * Math.pow(Math.PI, 0.25));
   const out = new Array(points);
   const center3 = (points - 1) / 2;
   for (let i = 0; i < points; i++) {
     const t = (i - center3) / scale4;
-    out[i] = norm4 * Math.cos(5 * t) * Math.exp(-(t * t) / 2);
+    out[i] = norm5 * Math.cos(5 * t) * Math.exp(-(t * t) / 2);
   }
   return out;
 }
@@ -50756,6 +51242,264 @@ function segmentSegmentClosest(p1, p2, q1, q2) {
   return { point1, point2, distance: distance2 };
 }
 
+// src/geometry/hull.ts
+function hull2DIndices(points) {
+  const n = points.length;
+  const order = Array.from({ length: n }, (_, i) => i).sort(
+    (a, b) => points[a][0] - points[b][0] || points[a][1] - points[b][1]
+  );
+  const cross4 = (o, a, b) => (points[a][0] - points[o][0]) * (points[b][1] - points[o][1]) - (points[a][1] - points[o][1]) * (points[b][0] - points[o][0]);
+  const lower = [];
+  for (const i of order) {
+    while (lower.length >= 2 && cross4(lower[lower.length - 2], lower[lower.length - 1], i) <= 0) {
+      lower.pop();
+    }
+    lower.push(i);
+  }
+  const upper = [];
+  for (let k = order.length - 1; k >= 0; k--) {
+    const i = order[k];
+    while (upper.length >= 2 && cross4(upper[upper.length - 2], upper[upper.length - 1], i) <= 0) {
+      upper.pop();
+    }
+    upper.push(i);
+  }
+  lower.pop();
+  upper.pop();
+  return lower.concat(upper);
+}
+function convexHull2D2(points) {
+  const vertices = hull2DIndices(points);
+  const m = vertices.length;
+  const simplices = [];
+  let signedArea = 0;
+  let perimeter = 0;
+  for (let k = 0; k < m; k++) {
+    const i = vertices[k];
+    const j = vertices[(k + 1) % m];
+    simplices.push([i, j]);
+    const a = points[i];
+    const b = points[j];
+    signedArea += a[0] * b[1] - b[0] * a[1];
+    perimeter += Math.hypot(b[0] - a[0], b[1] - a[1]);
+  }
+  return { vertices, simplices, area: perimeter, volume: Math.abs(signedArea) / 2 };
+}
+function convexHull3DResult(points) {
+  const faces = convexHull3D(points);
+  const vertexSet = /* @__PURE__ */ new Set();
+  let volume6 = 0;
+  let surface = 0;
+  for (const [ia, ib, ic] of faces) {
+    vertexSet.add(ia);
+    vertexSet.add(ib);
+    vertexSet.add(ic);
+    const a = points[ia];
+    const b = points[ib];
+    const c = points[ic];
+    volume6 += a[0] * (b[1] * c[2] - b[2] * c[1]) - a[1] * (b[0] * c[2] - b[2] * c[0]) + a[2] * (b[0] * c[1] - b[1] * c[0]);
+    const ux = b[0] - a[0];
+    const uy = b[1] - a[1];
+    const uz = b[2] - a[2];
+    const vx = c[0] - a[0];
+    const vy = c[1] - a[1];
+    const vz = c[2] - a[2];
+    const cx = uy * vz - uz * vy;
+    const cy = uz * vx - ux * vz;
+    const cz = ux * vy - uy * vx;
+    surface += Math.hypot(cx, cy, cz) / 2;
+  }
+  return {
+    vertices: Array.from(vertexSet).sort((a, b) => a - b),
+    simplices: faces.map((f) => [...f]),
+    area: surface,
+    volume: Math.abs(volume6) / 6
+  };
+}
+function convexHull(points) {
+  if (!Array.isArray(points) || points.length === 0) {
+    throw new Error("convexHull: requires a non-empty array of points");
+  }
+  const dim = points[0].length;
+  if (dim === 2) {
+    if (points.length < 3) throw new Error("convexHull: 2-D hull requires at least 3 points");
+    return convexHull2D2(points);
+  }
+  if (dim === 3) {
+    if (points.length < 4) throw new Error("convexHull: 3-D hull requires at least 4 points");
+    return convexHull3DResult(points);
+  }
+  throw new Error(`convexHull: only 2-D and 3-D point sets are supported (got dimension ${dim})`);
+}
+
+// src/geometry/delaunay.ts
+function delaunay(points) {
+  if (!Array.isArray(points) || points.length < 3) {
+    throw new Error("delaunay: requires at least 3 points");
+  }
+  if (points[0].length !== 2) {
+    throw new Error("delaunay: only 2-D point sets are supported");
+  }
+  return { simplices: delaunayTriangulation(points).map((t) => [...t]) };
+}
+
+// src/geometry/voronoi.ts
+function circumcenter(a, b, c) {
+  const d = 2 * (a[0] * (b[1] - c[1]) + b[0] * (c[1] - a[1]) + c[0] * (a[1] - b[1]));
+  if (Math.abs(d) < 1e-15) return null;
+  const a2 = a[0] * a[0] + a[1] * a[1];
+  const b2 = b[0] * b[0] + b[1] * b[1];
+  const c2 = c[0] * c[0] + c[1] * c[1];
+  const ux = (a2 * (b[1] - c[1]) + b2 * (c[1] - a[1]) + c2 * (a[1] - b[1])) / d;
+  const uy = (a2 * (c[0] - b[0]) + b2 * (a[0] - c[0]) + c2 * (b[0] - a[0])) / d;
+  return [ux, uy];
+}
+function voronoi(points) {
+  const { simplices: tris } = delaunay(points);
+  const vertices = [];
+  const simplices = [];
+  const regions = Array.from({ length: points.length }, () => []);
+  for (const t of tris) {
+    const cc = circumcenter(points[t[0]], points[t[1]], points[t[2]]);
+    if (cc === null) continue;
+    const vIdx = vertices.length;
+    vertices.push(cc);
+    simplices.push([...t]);
+    for (const p of t) regions[p].push(vIdx);
+  }
+  return { vertices, simplices, regions };
+}
+
+// src/geometry/alpha-shape.ts
+function circumradius(a, b, c) {
+  const d = 2 * (a[0] * (b[1] - c[1]) + b[0] * (c[1] - a[1]) + c[0] * (a[1] - b[1]));
+  if (Math.abs(d) < 1e-15) return Infinity;
+  const a2 = a[0] * a[0] + a[1] * a[1];
+  const b2 = b[0] * b[0] + b[1] * b[1];
+  const c2 = c[0] * c[0] + c[1] * c[1];
+  const ux = (a2 * (b[1] - c[1]) + b2 * (c[1] - a[1]) + c2 * (a[1] - b[1])) / d;
+  const uy = (a2 * (c[0] - b[0]) + b2 * (a[0] - c[0]) + c2 * (b[0] - a[0])) / d;
+  return Math.hypot(a[0] - ux, a[1] - uy);
+}
+function alphaShape(points, alpha) {
+  if (!(alpha > 0)) throw new Error("alphaShape: alpha must be positive");
+  const { simplices: tris } = delaunay(points);
+  const threshold = 1 / alpha;
+  const triangles = [];
+  const edgeCount = /* @__PURE__ */ new Map();
+  for (const t of tris) {
+    if (circumradius(points[t[0]], points[t[1]], points[t[2]]) > threshold) continue;
+    triangles.push([...t]);
+    const es = [
+      [t[0], t[1]],
+      [t[1], t[2]],
+      [t[2], t[0]]
+    ];
+    for (const [u, v] of es) {
+      const key = `${Math.min(u, v)},${Math.max(u, v)}`;
+      edgeCount.set(key, (edgeCount.get(key) ?? 0) + 1);
+    }
+  }
+  const edges = [];
+  for (const [key, count2] of edgeCount) {
+    if (count2 === 1) {
+      const [lo, hi] = key.split(",").map(Number);
+      edges.push([lo, hi]);
+    }
+  }
+  return { triangles, edges };
+}
+
+// src/geometry/spherical-voronoi.ts
+function sub2(a, b) {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function cross3(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]];
+}
+function dot8(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function norm4(a) {
+  return Math.hypot(a[0], a[1], a[2]);
+}
+function normalize2(a) {
+  const n = norm4(a) || 1;
+  return [a[0] / n, a[1] / n, a[2] / n];
+}
+function geodesicAngle(u, v) {
+  return Math.atan2(norm4(cross3(u, v)), dot8(u, v));
+}
+function sphericalTriangleArea(a, b, c) {
+  const A = geodesicAngle(b, c);
+  const B = geodesicAngle(a, c);
+  const C = geodesicAngle(a, b);
+  const s = (A + B + C) / 2;
+  const t = Math.tan(s / 2) * Math.tan((s - A) / 2) * Math.tan((s - B) / 2) * Math.tan((s - C) / 2);
+  return 4 * Math.atan(Math.sqrt(Math.max(0, t)));
+}
+function sphericalVoronoi(points, radius = 1, center3 = [0, 0, 0]) {
+  if (!Array.isArray(points) || points.length < 4) {
+    throw new Error("sphericalVoronoi: requires at least 4 points");
+  }
+  if (points[0].length !== 3) {
+    throw new Error("sphericalVoronoi: only 3-D point sets are supported");
+  }
+  const gen = points.map((p) => normalize2(sub2(p, center3)));
+  const faces = convexHull3D(points);
+  const vertices = [];
+  const vertDir = [];
+  const incident = Array.from({ length: points.length }, () => []);
+  faces.forEach((f, fi) => {
+    const a = gen[f[0]];
+    const b = gen[f[1]];
+    const c = gen[f[2]];
+    let nrm = cross3(sub2(b, a), sub2(c, a));
+    if (dot8(nrm, a) < 0) nrm = [-nrm[0], -nrm[1], -nrm[2]];
+    const dir = normalize2(nrm);
+    vertDir.push(dir);
+    vertices.push([
+      center3[0] + radius * dir[0],
+      center3[1] + radius * dir[1],
+      center3[2] + radius * dir[2]
+    ]);
+    for (const p of f) incident[p].push(fi);
+  });
+  const regions = [];
+  const areas = [];
+  for (let g = 0; g < points.length; g++) {
+    const gdir = gen[g];
+    const facs = incident[g];
+    let ref = null;
+    const withAngle = facs.map((fi) => {
+      const d = vertDir[fi];
+      const tang = normalize2(
+        sub2(d, [gdir[0] * dot8(d, gdir), gdir[1] * dot8(d, gdir), gdir[2] * dot8(d, gdir)])
+      );
+      if (ref === null) {
+        ref = tang;
+        return { fi, ang: 0 };
+      }
+      const x = dot8(tang, ref);
+      const y = dot8(cross3(gdir, ref), tang);
+      let ang = Math.atan2(y, x);
+      if (ang < 0) ang += 2 * Math.PI;
+      return { fi, ang };
+    });
+    withAngle.sort((p, q) => p.ang - q.ang);
+    const ring = withAngle.map((w) => w.fi);
+    regions.push(ring);
+    let area2 = 0;
+    for (let k = 0; k < ring.length; k++) {
+      const v1 = vertDir[ring[k]];
+      const v2 = vertDir[ring[(k + 1) % ring.length]];
+      area2 += sphericalTriangleArea(gdir, v1, v2);
+    }
+    areas.push(area2 * radius * radius);
+  }
+  return { vertices, regions, areas };
+}
+
 // src/stats/inference-extra2.ts
 var TWO_PI = 2 * Math.PI;
 function noncentralChi2CDF(x, df, nc) {
@@ -51965,9 +52709,9 @@ function katzCentrality(adj, alpha, beta2 = 1) {
     sum3 += xi;
     sumSq += xi * xi;
   }
-  const norm4 = Math.sign(sum3) * Math.sqrt(sumSq);
-  if (norm4 === 0) return x;
-  return x.map((xi) => xi / norm4);
+  const norm5 = Math.sign(sum3) * Math.sqrt(sumSq);
+  if (norm5 === 0) return x;
+  return x.map((xi) => xi / norm5);
 }
 function isIsomorphic(graphA, graphB) {
   const n = graphA.length;
@@ -52522,6 +53266,7 @@ export {
   adjacencyMatrix,
   airyAi,
   airyBi,
+  alphaShape,
   and,
   andersonDarlingTest,
   angle2D,
@@ -52666,6 +53411,7 @@ export {
   connectedComponents,
   continuedFraction,
   convexHull,
+  convexHull2D,
   convexHull3D,
   convolve,
   coordinateTransform,
@@ -52717,6 +53463,7 @@ export {
   deconvolve,
   deepEqual,
   degree,
+  delaunay,
   delaunayTriangulation,
   derivative,
   derivativeAt,
@@ -53423,6 +54170,7 @@ export {
   spectralClustering,
   spectrogram,
   speedOfLight,
+  sphericalVoronoi,
   splitUnit,
   sqrt,
   sqrtm,
@@ -53526,6 +54274,7 @@ export {
   variance,
   variation,
   vonMisesPDF,
+  voronoi,
   voronoiDiagram,
   wavedec,
   waverec,