@danielsimonjr/mathts-functions 0.38.0 → 0.40.0

package/dist/index.js

@@ -3402,10 +3402,10 @@ async function fftGpuDispatchImpl(real, imag, inverse, options) {
     staging.unmap();
     const outRe = new Float64Array(n);
     const outIm = new Float64Array(n);
-    const scale3 = inverse ? 1 / n : 1;
+    const scale4 = inverse ? 1 / n : 1;
     for (let i = 0; i < n; i++) {
-      outRe[i] = packed[i * 2] * scale3;
-      outIm[i] = packed[i * 2 + 1] * scale3;
+      outRe[i] = packed[i * 2] * scale4;
+      outIm[i] = packed[i * 2 + 1] * scale4;
     }
     return { real: outRe, imag: outIm };
   } catch {
@@ -3636,9 +3636,9 @@ function applyWindowDispatch(samples, windowName) {
   const wasm = getWasm();
   if (wasm && isAsWasm(wasm)) {
     try {
-      const out = withAsF64(wasm, [samples], (mod2, [h]) => {
-        mod2["apply_window_f64"](h, wt);
-        return asReadReturnedF64(mod2, h);
+      const out = withAsF64(wasm, [samples], (mod3, [h]) => {
+        mod3["apply_window_f64"](h, wt);
+        return asReadReturnedF64(mod3, h);
       });
       if (out && out.length === samples.length) {
         samples.set(out);
@@ -3659,9 +3659,9 @@ function welchPSDDispatch(samples, frameLength, overlap, windowName) {
         const out = withAsF64(
           wasm,
           [samples],
-          (mod2, [h]) => asReadReturnedF64(
-            mod2,
-            mod2["welch_psd_f64"](
+          (mod3, [h]) => asReadReturnedF64(
+            mod3,
+            mod3["welch_psd_f64"](
               h,
               frameLength,
               overlap,
@@ -3685,9 +3685,9 @@ function bartlettPSDDispatch(samples, frameLength) {
         const out = withAsF64(
           wasm,
           [samples],
-          (mod2, [h]) => asReadReturnedF64(
-            mod2,
-            mod2["bartlett_psd_f64"](h, frameLength)
+          (mod3, [h]) => asReadReturnedF64(
+            mod3,
+            mod3["bartlett_psd_f64"](h, frameLength)
           )
         );
         if (out && out.length > 0) return out;
@@ -3706,7 +3706,7 @@ function goertzelDispatch(samples, targetFreq, sampleRate) {
         const r = withAsF64(
           wasm,
           [samples],
-          (mod2, [h]) => mod2["goertzel_f64"](
+          (mod3, [h]) => mod3["goertzel_f64"](
             h,
             targetFreq,
             sampleRate
@@ -3728,9 +3728,9 @@ function chirpZTransformDispatch(samples, m, phiStartRe, phiStartIm, phiStepRe,
         const interleaved = withAsF64(
           wasm,
           [samples],
-          (mod2, [h]) => asReadReturnedF64(
-            mod2,
-            mod2["chirp_z_transform_f64"](h, m, phiStartRe, phiStartIm, phiStepRe, phiStepIm)
+          (mod3, [h]) => asReadReturnedF64(
+            mod3,
+            mod3["chirp_z_transform_f64"](h, m, phiStartRe, phiStartIm, phiStepRe, phiStepIm)
           )
         );
         if (interleaved && interleaved.length === 2 * m) {
@@ -3749,6 +3749,139 @@ function chirpZTransformDispatch(samples, m, phiStartRe, phiStartIm, phiStepRe,
   return chirpZTransformJS(samples, m, phiStartRe, phiStartIm, phiStepRe, phiStepIm);
 }
 
+// src/signal/wavelet-filters.ts
+var DEC_LO_TABLE = {
+  haar: [0.7071067811865476, 0.7071067811865476],
+  db1: [0.7071067811865476, 0.7071067811865476],
+  db2: [-0.12940952255126037, 0.2241438680420134, 0.8365163037378079, 0.48296291314453416],
+  db3: [
+    0.03522629188570953,
+    -0.08544127388202666,
+    -0.13501102001025458,
+    0.45987750211849154,
+    0.8068915093110925,
+    0.33267055295008263
+  ],
+  db4: [
+    -0.010597401785069032,
+    0.0328830116668852,
+    0.030841381835560764,
+    -0.18703481171909309,
+    -0.027983769416859854,
+    0.6308807679298589,
+    0.7148465705529157,
+    0.2303778133088965
+  ],
+  sym2: [-0.12940952255092145, 0.22414386804185735, 0.836516303737469, 0.48296291314469025],
+  sym3: [
+    0.035226291882100656,
+    -0.08544127388224149,
+    -0.13501102001039084,
+    0.4598775021193313,
+    0.8068915093133388,
+    0.3326705529509569
+  ],
+  sym4: [
+    -0.07576571478927333,
+    -0.02963552764599851,
+    0.49761866763201545,
+    0.8037387518059161,
+    0.29785779560527736,
+    -0.09921954357684722,
+    -0.012603967262037833,
+    0.0322231006040427
+  ],
+  coif1: [
+    -0.015655728135791993,
+    -0.07273261951252645,
+    0.3848648468648578,
+    0.8525720202116004,
+    0.3378976624574818,
+    -0.07273261951252645
+  ],
+  coif2: [
+    -720549445520347e-18,
+    -0.0018232088709110323,
+    0.005611434819368834,
+    0.02368017194684777,
+    -0.05943441864643109,
+    -0.07648859907828076,
+    0.4170051844232391,
+    0.8127236354494135,
+    0.3861100668227629,
+    -0.0673725547237256,
+    -0.04146493678687178,
+    0.01638733646320364
+  ]
+};
+var SUPPORTED_WAVELETS = Object.keys(DEC_LO_TABLE);
+function getWaveletFilters(wavelet) {
+  const decLo = DEC_LO_TABLE[wavelet];
+  if (!decLo) {
+    throw new Error(
+      `unsupported wavelet "${wavelet}". Supported families: ${SUPPORTED_WAVELETS.join(", ")}`
+    );
+  }
+  const L = decLo.length;
+  const decHi = new Array(L);
+  for (let k = 0; k < L; k++) {
+    decHi[k] = (k % 2 === 0 ? -1 : 1) * decLo[L - 1 - k];
+  }
+  const recLo = decLo.slice().reverse();
+  const recHi = decHi.slice().reverse();
+  return { decLo, decHi, recLo, recHi };
+}
+function mod2(a, m) {
+  const r = a % m;
+  return r < 0 ? r + m : r;
+}
+function dwtPeriodization(x, wavelet) {
+  const n = x.length;
+  if (n < 2) throw new Error("signal must have at least 2 samples");
+  const { decLo, decHi } = getWaveletFilters(wavelet);
+  const L = decLo.length;
+  const offset = Math.floor(L / 2);
+  const half = Math.ceil(n / 2);
+  const approx = new Array(half);
+  const detail = new Array(half);
+  for (let i = 0; i < half; i++) {
+    let sa = 0;
+    let sd = 0;
+    for (let k = 0; k < L; k++) {
+      const idx = mod2(2 * i - k + offset, n);
+      const xi = x[idx];
+      sa += decLo[k] * xi;
+      sd += decHi[k] * xi;
+    }
+    approx[i] = sa;
+    detail[i] = sd;
+  }
+  return { approx, detail };
+}
+function idwtPeriodization(approx, detail, wavelet) {
+  if (approx.length !== detail.length) {
+    throw new Error("approx and detail must have equal length");
+  }
+  const { recLo, recHi } = getWaveletFilters(wavelet);
+  const half = approx.length;
+  const n = half * 2;
+  const L = recLo.length;
+  const shift = Math.floor(L / 2) - 1;
+  const x = new Array(n);
+  for (let m = 0; m < n; m++) {
+    let s = 0;
+    for (let k = 0; k < L; k++) {
+      const idx = mod2(m - k + shift, n);
+      if (idx % 2 === 0) {
+        const j = idx / 2;
+        s += recLo[k] * approx[j] + recHi[k] * detail[j];
+      }
+    }
+    x[m] = s;
+  }
+  return x;
+}
+
 // src/typed/signal.ts
 var WASM_THRESHOLD = 64;
 function isPowerOf22(n) {
@@ -4182,7 +4315,11 @@ function dwt(x, wavelet = "haar") {
     }
     return { approx, detail };
   } else {
-    throw new Error(`dwt: unsupported wavelet "${wavelet}"`);
+    try {
+      return dwtPeriodization(x, wavelet);
+    } catch (err) {
+      throw new Error(`dwt: ${err instanceof Error ? err.message : String(err)}`);
+    }
   }
 }
 async function fft2d(x) {
@@ -4737,9 +4874,9 @@ function runBinaryBitwiseWasm(op, a, b) {
   const n = a.length;
   const names = BINARY_OPS[op];
   try {
-    return withAsI32(wasm, [a, b, new Int32Array(n)], (mod2, [ha, hb, hr]) => {
-      mod2[names.as](ha, hb, hr);
-      return asReadReturnedI32(mod2, hr);
+    return withAsI32(wasm, [a, b, new Int32Array(n)], (mod3, [ha, hb, hr]) => {
+      mod3[names.as](ha, hb, hr);
+      return asReadReturnedI32(mod3, hr);
     });
   } catch {
     return null;
@@ -4751,9 +4888,9 @@ function runUnaryBitwiseWasm(op, a) {
   const n = a.length;
   const names = UNARY_OPS[op];
   try {
-    return withAsI32(wasm, [a, new Int32Array(n)], (mod2, [ha, hr]) => {
-      mod2[names.as](ha, hr);
-      return asReadReturnedI32(mod2, hr);
+    return withAsI32(wasm, [a, new Int32Array(n)], (mod3, [ha, hr]) => {
+      mod3[names.as](ha, hr);
+      return asReadReturnedI32(mod3, hr);
     });
   } catch {
     return null;
@@ -6479,7 +6616,7 @@ function besselOrderDispatch(order, xs, asName, js) {
         const out = withAsF64(
           wasm,
           [xs],
-          (mod2, [h]) => asReadReturnedF64(mod2, mod2[asName](order, h))
+          (mod3, [h]) => asReadReturnedF64(mod3, mod3[asName](order, h))
         );
         if (out) return out;
       } catch {
@@ -6741,7 +6878,7 @@ function multiArrayDispatch(name254, inputs, js) {
         const out = withAsF64(
           wasm,
           inputs,
-          (mod2, headers) => asReadReturnedF64(mod2, mod2[name254](...headers))
+          (mod3, headers) => asReadReturnedF64(mod3, mod3[name254](...headers))
         );
         if (out) return out;
       } catch {
@@ -6877,7 +7014,7 @@ function digammaScalar(x) {
   return result;
 }
 function besselK01(x) {
-  const EPS4 = 1e-16;
+  const EPS5 = 1e-16;
   const xi = 1 / x;
   const xi2 = 2 * xi;
   let rkmu;
@@ -6900,7 +7037,7 @@ function besselK01(x) {
       const del = c * ff;
       sum3 += del;
       sum1 += c * (p - i * ff);
-      if (Math.abs(del) < Math.abs(sum3) * EPS4) break;
+      if (Math.abs(del) < Math.abs(sum3) * EPS5) break;
     }
     rkmu = sum3;
     rk1 = sum1 * xi2;
@@ -6929,7 +7066,7 @@ function besselK01(x) {
       h += delh;
       const dels = q * delh;
       s += dels;
-      if (Math.abs(dels / s) < EPS4) break;
+      if (Math.abs(dels / s) < EPS5) break;
     }
     h = a1 * h;
     rkmu = Math.sqrt(Math.PI / (2 * x)) * Math.exp(-x) / s;
@@ -8266,26 +8403,26 @@ var betaPDF = mathTyped11("betaPDF", {
     return Promise.resolve(out);
   }
 });
-function gammaPDFScalar(x, shape, scale3) {
-  if (shape <= 0 || scale3 <= 0) return NaN;
+function gammaPDFScalar(x, shape, scale4) {
+  if (shape <= 0 || scale4 <= 0) return NaN;
   if (x <= 0) return 0;
   return Math.exp(
-    (shape - 1) * Math.log(x) - x / scale3 - _lgammaD(shape) - shape * Math.log(scale3)
+    (shape - 1) * Math.log(x) - x / scale4 - _lgammaD(shape) - shape * Math.log(scale4)
   );
 }
 var gammaPDF = mathTyped11("gammaPDF", {
-  "number, number, number": (x, shape, scale3) => gammaPDFScalar(x, shape, scale3),
-  "Float64Array, number, number": (x, shape, scale3) => {
+  "number, number, number": (x, shape, scale4) => gammaPDFScalar(x, shape, scale4),
+  "Float64Array, number, number": (x, shape, scale4) => {
     const out = new Float64Array(x.length);
     const lgShape = _lgammaD(shape);
-    const logScale = Math.log(scale3);
+    const logScale = Math.log(scale4);
     const logConstant = lgShape + shape * logScale;
     for (let i = 0; i < x.length; i++) {
       const xi = x[i];
       if (xi <= 0) {
         out[i] = 0;
       } else {
-        out[i] = Math.exp((shape - 1) * Math.log(xi) - xi / scale3 - logConstant);
+        out[i] = Math.exp((shape - 1) * Math.log(xi) - xi / scale4 - logConstant);
       }
     }
     return Promise.resolve(out);
@@ -8391,18 +8528,18 @@ import { computePool as computePool7 } from "@danielsimonjr/mathts-parallel";
 var GEOMETRY_WASM_THRESHOLD = 32;
 var HULL3D_WASM_THRESHOLD = 1024;
 function angle2D(v1, v2) {
-  const dot7 = v1[0] * v2[0] + v1[1] * v2[1];
+  const dot8 = 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, dot7 / (mag1 * mag2))));
+  return Math.acos(Math.max(-1, Math.min(1, dot8 / (mag1 * mag2))));
 }
 function angle3D(v1, v2) {
-  const dot7 = v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
+  const dot8 = 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, dot7 / (mag1 * mag2))));
+  return Math.acos(Math.max(-1, Math.min(1, dot8 / (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]];
@@ -8446,12 +8583,12 @@ function convexHull(points) {
   } else {
     sorted = points.slice().sort((a, b) => a[0] - b[0] || a[1] - b[1]);
   }
-  function cross2(o, a, b) {
+  function cross3(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 && cross2(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) {
+    while (lower.length >= 2 && cross3(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) {
       lower.pop();
     }
     lower.push(p);
@@ -8459,7 +8596,7 @@ function convexHull(points) {
   const upper = [];
   for (let i = sorted.length - 1; i >= 0; i--) {
     const p = sorted[i];
-    while (upper.length >= 2 && cross2(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
+    while (upper.length >= 2 && cross3(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
       upper.pop();
     }
     upper.push(p);
@@ -8507,15 +8644,15 @@ 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 dot7 = v.reduce((s, c, i) => s + c * n[i], 0);
-  return v.map((c, i) => c - 2 * dot7 * n[i]);
+  const dot8 = v.reduce((s, c, i) => s + c * n[i], 0);
+  return v.map((c, i) => c - 2 * dot8 * n[i]);
 }
 function projectVector(v, onto) {
-  const dot7 = v.reduce((s, c, i) => s + c * onto[i], 0);
+  const dot8 = 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 scale3 = dot7 / magSq;
-  return onto.map((c) => c * scale3);
+  const scale4 = dot8 / magSq;
+  return onto.map((c) => c * scale4);
 }
 function distance2D(a, b) {
   return Math.sqrt((b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2);
@@ -8590,10 +8727,10 @@ function centroid(vertices) {
   let cy = 0;
   for (let i = 0; i < n; i++) {
     const j = (i + 1) % n;
-    const cross2 = vertices[i][0] * vertices[j][1] - vertices[j][0] * vertices[i][1];
-    signedArea += cross2;
-    cx += (vertices[i][0] + vertices[j][0]) * cross2;
-    cy += (vertices[i][1] + vertices[j][1]) * cross2;
+    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;
   }
   signedArea /= 2;
   cx /= 6 * signedArea;
@@ -9162,7 +9299,7 @@ function polyMulDispatch(a, b) {
         const out = withAsF64(
           wasm,
           [a, b],
-          (mod2, [ha, hb]) => asReadReturnedF64(mod2, mod2["poly_mul_f64"](ha, hb))
+          (mod3, [ha, hb]) => asReadReturnedF64(mod3, mod3["poly_mul_f64"](ha, hb))
         );
         if (out) return out;
       } catch {
@@ -9181,9 +9318,9 @@ function polyDivModDispatch(num2, den) {
         const flat = withAsF64(
           wasm,
           [num2, den],
-          (mod2, [hn, hd]) => asReadReturnedF64(
-            mod2,
-            mod2["poly_div_mod_f64"](hn, hd)
+          (mod3, [hn, hd]) => asReadReturnedF64(
+            mod3,
+            mod3["poly_div_mod_f64"](hn, hd)
           )
         );
         if (flat) {
@@ -9284,7 +9421,7 @@ function resultantDispatch(p, q) {
         const r = withAsF64(
           wasm,
           [p, q],
-          (mod2, [hp, hq]) => mod2["poly_resultant_f64"](hp, hq)
+          (mod3, [hp, hq]) => mod3["poly_resultant_f64"](hp, hq)
         );
         if (r !== null) return r;
       } catch {
@@ -9302,7 +9439,7 @@ function discriminantDispatch(p) {
         const r = withAsF64(
           wasm,
           [p],
-          (mod2, [hp]) => mod2["poly_discriminant_f64"](hp)
+          (mod3, [hp]) => mod3["poly_discriminant_f64"](hp)
         );
         if (r !== null) return r;
       } catch {
@@ -9415,9 +9552,9 @@ function fitDispatch(xs, ys, degree2, asName, jsFallback) {
         const out = withAsF64(
           wasm,
           [xs, ys],
-          (mod2, [hx, hy]) => asReadReturnedF64(
-            mod2,
-            mod2[asName](hx, hy, degree2)
+          (mod3, [hx, hy]) => asReadReturnedF64(
+            mod3,
+            mod3[asName](hx, hy, degree2)
           )
         );
         if (out && out.length === degree2 + 1 && out.every((v) => Number.isFinite(v))) {
@@ -10948,9 +11085,9 @@ function tridiagSolveDispatch(diag2, lower, upper, rhs) {
         const result = withAsF64(
           wasm,
           [diag2, lower, upper, rhs],
-          (mod2, [hd, hl, hu, hr]) => asReadReturnedF64(
-            mod2,
-            mod2["tridiag_solve_f64"](
+          (mod3, [hd, hl, hu, hr]) => asReadReturnedF64(
+            mod3,
+            mod3["tridiag_solve_f64"](
               hd,
               hl,
               hu,
@@ -10989,9 +11126,9 @@ function dividedDifferenceDispatch(xs, ys) {
         const result = withAsF64(
           wasm,
           [xs, ys],
-          (mod2, [hx, hy]) => asReadReturnedF64(
-            mod2,
-            mod2["divided_difference_f64"](hx, hy)
+          (mod3, [hx, hy]) => asReadReturnedF64(
+            mod3,
+            mod3["divided_difference_f64"](hx, hy)
           )
         );
         if (result && result.length === n) return result;
@@ -11762,7 +11899,7 @@ var createSolveODE = /* @__PURE__ */ factory(
   dependencies,
   ({
     typed: typed3,
-    add: add3,
+    add: add4,
     subtract: subtract3,
     multiply: multiply2,
     divide: divide2,
@@ -11981,7 +12118,7 @@ var createSolveODE = /* @__PURE__ */ factory(
           const m = Math.min(coeffs.length, stages.length);
           let acc = multiply2(coeffs[0], stages[0]);
           for (let j = 1; j < m; j++) {
-            acc = add3(acc, multiply2(coeffs[j], stages[j]));
+            acc = add4(acc, multiply2(coeffs[j], stages[j]));
           }
           return acc;
         }
@@ -11994,14 +12131,14 @@ var createSolveODE = /* @__PURE__ */ factory(
           h = trimStep(t[n], tf, h);
           k.push(f(t[n], y[n]));
           for (let i = 1; i < c.length; ++i) {
-            k.push(f(add3(t[n], multiply2(c[i], h)), add3(y[n], multiply2(h, stageCombo(a[i], k)))));
+            k.push(f(add4(t[n], multiply2(c[i], h)), add4(y[n], multiply2(h, stageCombo(a[i], k)))));
           }
           const errComb = stageCombo(deltaB, k);
           const errArr = Array.isArray(errComb) ? errComb : [errComb];
           const TE = max2(abs2(map2(errArr, (X) => isUnit(X) ? X.value : X)));
           if (TE < tol && tol / TE > 1 / 4) {
-            t.push(add3(t[n], h));
-            y.push(add3(y[n], multiply2(h, stageCombo(b, k))));
+            t.push(add4(t[n], h));
+            y.push(add4(y[n], multiply2(h, stageCombo(b, k))));
             n++;
           }
           let delta = 0.84 * (tol / TE) ** (1 / 5);
@@ -12082,7 +12219,7 @@ var createSolveODE = /* @__PURE__ */ factory(
     function _createTrimStep(isForwards) {
       const outOfBounds = isForwards ? larger2 : smaller2;
       return function(t, tf, h) {
-        const next = add3(t, h);
+        const next = add4(t, h);
         return outOfBounds(next, tf) ? subtract3(tf, t) : h;
       };
     }
@@ -13371,8 +13508,8 @@ function quadprog(H, f, A, b) {
         let aNorm = 0;
         for (let j = 0; j < n; j++) aNorm += A[c][j] * A[c][j];
         if (aNorm > 1e-15) {
-          const scale3 = (ax - b[c]) / aNorm;
-          for (let j = 0; j < n; j++) xNew[j] -= scale3 * A[c][j];
+          const scale4 = (ax - b[c]) / aNorm;
+          for (let j = 0; j < n; j++) xNew[j] -= scale4 * A[c][j];
         }
       }
     }
@@ -14579,7 +14716,7 @@ function _betweennessOnce(adj, directed, normalise, seed) {
     for (let i = 0; i < n; i++) cb[i] *= scaleFactor;
   }
   if (normalise) {
-    const denom = directed ? (n - 1) * (n - 2) : (n - 1) * (n - 2) / 2;
+    const denom = (n - 1) * (n - 2);
     if (denom > 0) {
       for (let i = 0; i < n; i++) cb[i] /= denom;
     }
@@ -14613,7 +14750,7 @@ function _aggregateBetweenness(vectors, aggregation) {
 }
 async function betweennessCentrality(adj, opts) {
   const directed = opts?.directed ?? false;
-  const normalise = opts?.normalise ?? true;
+  const normalise = opts?.normalized ?? opts?.normalise ?? true;
   const restarts = opts?.restarts ?? 1;
   const baseSeed = opts?.restartSeed ?? 0;
   const aggregation = opts?.aggregation ?? "mean";
@@ -14672,9 +14809,9 @@ function _aggregateEigenvector(vectors, aggregation) {
   const count2 = vectors.length;
   const ref = vectors[0];
   const aligned = vectors.map((v) => {
-    let dot7 = 0;
-    for (let i = 0; i < n; i++) dot7 += v[i] * ref[i];
-    if (dot7 < 0) {
+    let dot8 = 0;
+    for (let i = 0; i < n; i++) dot8 += v[i] * ref[i];
+    if (dot8 < 0) {
       const flipped = new Float64Array(n);
       for (let i = 0; i < n; i++) flipped[i] = -v[i];
       return flipped;
@@ -15210,7 +15347,7 @@ function fDist(d1, d2) {
 }
 function gammaDist(shape, rate = 1) {
   if (shape <= 0 || rate <= 0) throw new Error("gammaDist: shape and rate must be positive");
-  const scale3 = 1 / rate;
+  const scale4 = 1 / rate;
   return {
     pdf: (x) => {
       if (x < 0) return 0;
@@ -15231,7 +15368,7 @@ function gammaDist(shape, rate = 1) {
       if (p <= 0) return 0;
       if (p >= 1) return Infinity;
       let lo = 0;
-      let hi = shape * scale3 * 20;
+      let hi = shape * scale4 * 20;
       while (_gammainc(shape, hi * rate) < p) hi *= 2;
       for (let i = 0; i < 100; i++) {
         const mid = (lo + hi) / 2;
@@ -15241,13 +15378,13 @@ function gammaDist(shape, rate = 1) {
       }
       return (lo + hi) / 2;
     },
-    mean: shape * scale3,
-    variance: shape * scale3 * scale3,
-    sample: () => _gammaRandom(shape) * scale3,
-    sampleN: (n, opts) => _sampleNDispatch("gamma", [shape, scale3], n, opts, (count2, rng) => {
+    mean: shape * scale4,
+    variance: shape * scale4 * scale4,
+    sample: () => _gammaRandom(shape) * scale4,
+    sampleN: (n, opts) => _sampleNDispatch("gamma", [shape, scale4], n, opts, (count2, rng) => {
       const out = new Float64Array(count2);
       for (let i = 0; i < count2; i++) {
-        out[i] = _gammaRandomRng(shape, rng) * scale3;
+        out[i] = _gammaRandomRng(shape, rng) * scale4;
       }
       return out;
     })
@@ -16638,9 +16775,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 dot7 = 0;
-      for (let j = 0; j < p; j++) dot7 += row2[j] * ev[j];
-      return dot7;
+      let dot8 = 0;
+      for (let j = 0; j < p; j++) dot8 += row2[j] * ev[j];
+      return dot8;
     });
   });
   return { components: eigenvectors, explained, scores };
@@ -17167,9 +17304,9 @@ function rowReduce(A, tol = 1e-10) {
     if (maxRow !== pivotRow) {
       [M[pivotRow], M[maxRow]] = [M[maxRow], M[pivotRow]];
     }
-    const scale3 = M[pivotRow][col];
+    const scale4 = M[pivotRow][col];
     for (let j = col; j < n; j++) {
-      M[pivotRow][j] /= scale3;
+      M[pivotRow][j] /= scale4;
     }
     for (let row2 = 0; row2 < m; row2++) {
       if (row2 === pivotRow) continue;
@@ -17255,30 +17392,30 @@ function hessenbergForm(A) {
     if (normV < 1e-30) continue;
     const beta2 = 2 / normV;
     for (let j = k; j < n; j++) {
-      let dot7 = 0;
+      let dot8 = 0;
       for (let i = 0; i < len; i++) {
-        dot7 += v[i] * H[k + 1 + i][j];
+        dot8 += v[i] * H[k + 1 + i][j];
       }
       for (let i = 0; i < len; i++) {
-        H[k + 1 + i][j] -= beta2 * v[i] * dot7;
+        H[k + 1 + i][j] -= beta2 * v[i] * dot8;
       }
     }
     for (let i = 0; i < n; i++) {
-      let dot7 = 0;
+      let dot8 = 0;
       for (let j = 0; j < len; j++) {
-        dot7 += H[i][k + 1 + j] * v[j];
+        dot8 += H[i][k + 1 + j] * v[j];
       }
       for (let j = 0; j < len; j++) {
-        H[i][k + 1 + j] -= beta2 * dot7 * v[j];
+        H[i][k + 1 + j] -= beta2 * dot8 * v[j];
       }
     }
     for (let i = 0; i < n; i++) {
-      let dot7 = 0;
+      let dot8 = 0;
       for (let j = 0; j < len; j++) {
-        dot7 += Q2[i][k + 1 + j] * v[j];
+        dot8 += Q2[i][k + 1 + j] * v[j];
       }
       for (let j = 0; j < len; j++) {
-        Q2[i][k + 1 + j] -= beta2 * dot7 * v[j];
+        Q2[i][k + 1 + j] -= beta2 * dot8 * v[j];
       }
     }
   }
@@ -17337,8 +17474,8 @@ function matrixInverse(A) {
     }
     if (maxVal < 1e-15) throw new Error("matrixPower: singular matrix cannot be inverted");
     if (maxRow !== col) [M[col], M[maxRow]] = [M[maxRow], M[col]];
-    const scale3 = M[col][col];
-    for (let j = 0; j < 2 * n; j++) M[col][j] /= scale3;
+    const scale4 = M[col][col];
+    for (let j = 0; j < 2 * n; j++) M[col][j] /= scale4;
     for (let row2 = 0; row2 < n; row2++) {
       if (row2 === col) continue;
       const factor2 = M[row2][col];
@@ -17412,10 +17549,10 @@ async function matLogScalingSquaring(A) {
       }
     }
   }
-  const scale3 = Math.pow(2, numSquares);
+  const scale4 = Math.pow(2, numSquares);
   for (let i = 0; i < n; i++) {
     for (let j = 0; j < n; j++) {
-      logM[i][j] *= scale3;
+      logM[i][j] *= scale4;
     }
   }
   return logM;
@@ -17678,9 +17815,9 @@ async function solveApprox(A, b, n) {
       }
     }
     if (maxRow !== col) [M[col], M[maxRow]] = [M[maxRow], M[col]];
-    const scale3 = M[col][col];
-    if (Math.abs(scale3) < 1e-30) continue;
-    for (let j = 0; j <= n; j++) M[col][j] /= scale3;
+    const scale4 = M[col][col];
+    if (Math.abs(scale4) < 1e-30) continue;
+    for (let j = 0; j <= n; j++) M[col][j] /= scale4;
     for (let row2 = 0; row2 < n; row2++) {
       if (row2 === col) continue;
       const factor2 = M[row2][col];
@@ -22491,41 +22628,41 @@ var createDot = /* @__PURE__ */ factory(
       const bdt = isMatrix(b) ? b._datatype || b.getDataType() : void 0;
       const aIsColumn = _size(a).length === 2;
       const bIsColumn = _size(b).length === 2;
-      let add3 = addScalar2;
+      let add4 = addScalar2;
       let mul = multiplyScalar2;
       if (adt && bdt && adt === bdt && typeof adt === "string" && adt !== "mixed") {
         const dt = adt;
-        add3 = typed3.find(addScalar2, [dt, dt]);
+        add4 = typed3.find(addScalar2, [dt, dt]);
         mul = typed3.find(multiplyScalar2, [dt, dt]);
       }
-      if (!aIsColumn && !bIsColumn && add3 === addScalar2 && mul === multiplyScalar2 && _isFlatNumbers(adata) && _isFlatNumbers(bdata)) {
+      if (!aIsColumn && !bIsColumn && add4 === addScalar2 && mul === multiplyScalar2 && _isFlatNumbers(adata) && _isFlatNumbers(bdata)) {
         return pairwiseDot2(adata, bdata);
       }
       if (!aIsColumn && !bIsColumn) {
         let c = mul(conj3(adata[0]), bdata[0]);
         for (let i = 1; i < N; i++) {
-          c = add3(c, mul(conj3(adata[i]), bdata[i]));
+          c = add4(c, mul(conj3(adata[i]), bdata[i]));
         }
         return c;
       }
       if (!aIsColumn && bIsColumn) {
         let c = mul(conj3(adata[0]), bdata[0][0]);
         for (let i = 1; i < N; i++) {
-          c = add3(c, mul(conj3(adata[i]), bdata[i][0]));
+          c = add4(c, mul(conj3(adata[i]), bdata[i][0]));
         }
         return c;
       }
       if (aIsColumn && !bIsColumn) {
         let c = mul(conj3(adata[0][0]), bdata[0]);
         for (let i = 1; i < N; i++) {
-          c = add3(c, mul(conj3(adata[i][0]), bdata[i]));
+          c = add4(c, mul(conj3(adata[i][0]), bdata[i]));
         }
         return c;
       }
       {
         let c = mul(conj3(adata[0][0]), bdata[0][0]);
         for (let i = 1; i < N; i++) {
-          c = add3(c, mul(conj3(adata[i][0]), bdata[i][0]));
+          c = add4(c, mul(conj3(adata[i][0]), bdata[i][0]));
         }
         return c;
       }
@@ -22537,7 +22674,7 @@ var createDot = /* @__PURE__ */ factory(
       const yindex = y._index;
       const yvalues = y._values;
       let c = 0;
-      const add3 = addScalar2;
+      const add4 = addScalar2;
       const mul = multiplyScalar2;
       let i = 0;
       let j = 0;
@@ -22553,7 +22690,7 @@ var createDot = /* @__PURE__ */ factory(
           continue;
         }
         if (I2 === J) {
-          c = add3(c, mul(xvalues[i], yvalues[j]));
+          c = add4(c, mul(xvalues[i], yvalues[j]));
           i++;
           j++;
         }
@@ -23645,7 +23782,7 @@ var dependencies95 = ["typed", "matrix", "add"];
 var createTrace = /* @__PURE__ */ factory(
   name95,
   dependencies95,
-  ({ typed: typed3, matrix: matrix2, add: add3 }) => {
+  ({ typed: typed3, matrix: matrix2, add: add4 }) => {
     return typed3("trace", {
       Array: function _arrayTrace(x) {
         return _denseTrace(matrix2(x));
@@ -23669,7 +23806,7 @@ var createTrace = /* @__PURE__ */ factory(
           if (rows === cols) {
             let sum3 = 0;
             for (let i = 0; i < rows; i++) {
-              sum3 = add3(sum3, data[i][i]);
+              sum3 = add4(sum3, data[i][i]);
             }
             return sum3;
           } else {
@@ -23696,7 +23833,7 @@ var createTrace = /* @__PURE__ */ factory(
             for (let k = k0; k < k1; k++) {
               const i = index[k];
               if (i === j) {
-                sum3 = add3(sum3, values[k]);
+                sum3 = add4(sum3, values[k]);
                 break;
               }
               if (i > j) {
@@ -24063,7 +24200,7 @@ var dependencies98 = ["add", "multiply", "transpose"];
 var createCsAmd = /* @__PURE__ */ factory(
   name98,
   dependencies98,
-  ({ add: add3, multiply: multiply2, transpose: transpose5 }) => {
+  ({ add: add4, multiply: multiply2, transpose: transpose5 }) => {
     function _tryWasmAmd(a, n) {
       const wasm = wasmLoader.getModule();
       if (!wasm || !a._ptr || !a._index) return null;
@@ -24359,7 +24496,7 @@ var createCsAmd = /* @__PURE__ */ factory(
     function _createTargetMatrix(order, a, m, n, dense) {
       const at = transpose5(a);
       if (order === 1 && n === m) {
-        return add3(a, at);
+        return add4(a, at);
       }
       if (order === 2) {
         const tindex = at._index;
@@ -24708,8 +24845,8 @@ var dependencies100 = ["add", "multiply", "transpose"];
 var createCsSqr = /* @__PURE__ */ factory(
   name100,
   dependencies100,
-  ({ add: add3, multiply: multiply2, transpose: transpose5 }) => {
-    const csAmd2 = createCsAmd({ add: add3, multiply: multiply2, transpose: transpose5 });
+  ({ add: add4, multiply: multiply2, transpose: transpose5 }) => {
+    const csAmd2 = createCsAmd({ add: add4, multiply: multiply2, transpose: transpose5 });
     const csCounts2 = createCsCounts({ transpose: transpose5 });
     return function csSqr2(order, a, qr2) {
       const aptr = a._ptr;
@@ -26715,7 +26852,7 @@ var createSubset = /* @__PURE__ */ factory(
     typed: typed3,
     matrix: matrix2,
     zeros: zeros4,
-    add: add3
+    add: add4
   }) => {
     const referTo = typed3.referTo;
     return typed3(name119, {
@@ -26774,7 +26911,7 @@ var createSubset = /* @__PURE__ */ factory(
       const indexSize = index.size();
       if (indexSize.every((d) => d > 0)) {
         try {
-          return add3(replacement, zeros4(indexSize));
+          return add4(replacement, zeros4(indexSize));
         } catch {
           return replacement;
         }
@@ -27447,7 +27584,7 @@ var dependencies127 = ["typed", "add", "multiply", "Complex", "number"];
 var createZpk2tf = /* @__PURE__ */ factory(
   name127,
   dependencies127,
-  ({ typed: typed3, add: add3, multiply: multiply2, Complex: Complex13, number: number2 }) => {
+  ({ typed: typed3, add: add4, multiply: multiply2, Complex: Complex13, number: number2 }) => {
     return typed3(name127, {
       "Array,Array,number": function(z, p, k) {
         return _zpk2tf(z, p, k);
@@ -27492,7 +27629,7 @@ var createZpk2tf = /* @__PURE__ */ factory(
         c[i] = Complex13(0, 0);
         for (let j = 0; j < a.length; j++) {
           if (i - j >= 0 && i - j < b.length) {
-            c[i] = add3(c[i], multiply2(a[j], b[i - j]));
+            c[i] = add4(c[i], multiply2(a[j], b[i - j]));
           }
         }
       }
@@ -27516,7 +27653,7 @@ var dependencies128 = ["typed", "add", "unaryPlus"];
 var createCumSum = /* @__PURE__ */ factory(
   name128,
   dependencies128,
-  ({ typed: typed3, add: add3, unaryPlus: unaryPlus2 }) => {
+  ({ typed: typed3, add: add4, unaryPlus: unaryPlus2 }) => {
     return typed3(name128, {
       // sum([a, b, c, d, ...])
       Array: _cumsum,
@@ -27557,7 +27694,7 @@ var createCumSum = /* @__PURE__ */ factory(
       }
       const sums = [unaryPlus2(array[0])];
       for (let i = 1; i < array.length; ++i) {
-        sums.push(add3(sums[i - 1], array[i]));
+        sums.push(add4(sums[i - 1], array[i]));
       }
       return sums;
     }
@@ -27615,7 +27752,7 @@ var dependencies129 = ["typed", "config", "add", "numeric", "parseNumberWithConf
 var createSum = /* @__PURE__ */ factory(
   name129,
   dependencies129,
-  ({ typed: typed3, config: config2, add: add3, numeric: numeric2, parseNumberWithConfig: parseNumberWithConfig2 }) => {
+  ({ typed: typed3, config: config2, add: add4, numeric: numeric2, parseNumberWithConfig: parseNumberWithConfig2 }) => {
     return typed3(name129, {
       // sum(string) - single string input
       string: function(x) {
@@ -27641,7 +27778,7 @@ var createSum = /* @__PURE__ */ factory(
       deepForEach2(array, function(value) {
         try {
           const converted = typeof value === "string" ? parseNumberWithConfig2(value) : value;
-          sum3 = sum3 === void 0 ? converted : add3(sum3, converted);
+          sum3 = sum3 === void 0 ? converted : add4(sum3, converted);
         } catch (err) {
           throw improveErrorMessage(err, "sum", value);
         }
@@ -27654,7 +27791,7 @@ var createSum = /* @__PURE__ */ factory(
     function _nsumDim(array, dim) {
       try {
         const dimValue = typeof dim === "number" ? dim : dim.valueOf();
-        const sum3 = reduce2(array, dimValue, add3);
+        const sum3 = reduce2(array, dimValue, add4);
         return sum3;
       } catch (err) {
         throw improveErrorMessage(err, "sum", void 0);
@@ -28446,7 +28583,7 @@ var createGcd = /* @__PURE__ */ factory(
     DenseMatrix: DenseMatrix6,
     concat: concat3
   }) => {
-    const mod2 = createMod({
+    const mod3 = createMod({
       typed: typed3,
       config: config2,
       round: round2,
@@ -28532,7 +28669,7 @@ var createGcd = /* @__PURE__ */ factory(
       }
       let r;
       while (b !== 0) {
-        r = mod2(a, b);
+        r = mod3(a, b);
         a = b;
         b = r;
       }
@@ -28544,7 +28681,7 @@ var createGcd = /* @__PURE__ */ factory(
       }
       const zero = new BigNumber9(0);
       while (!b.isZero()) {
-        const r = mod2(a, b);
+        const r = mod3(a, b);
         a = b;
         b = r;
       }
@@ -30315,8 +30452,8 @@ var createInvmod = /* @__PURE__ */ factory(
     xgcd: xgcd2,
     equal: equal2,
     smaller: smaller2,
-    mod: mod2,
-    add: add3,
+    mod: mod3,
+    add: add4,
     isInteger: isInteger3
   }) => {
     return typed3(name168, {
@@ -30326,14 +30463,14 @@ var createInvmod = /* @__PURE__ */ factory(
     function invmod2(a, b) {
       if (!isInteger3(a) || !isInteger3(b))
         throw new Error("Parameters in function invmod must be integer numbers");
-      a = mod2(a, b);
+      a = mod3(a, b);
       if (equal2(b, 0)) throw new Error("Divisor must be non zero");
       const res = xgcd2(a, b);
       const resVal = res.valueOf();
       const [gcd2, invValue] = resVal;
       if (!equal2(gcd2, 1)) return NaN;
-      let inv3 = mod2(invValue, b);
-      if (smaller2(inv3, 0)) inv3 = add3(inv3, b);
+      let inv3 = mod3(invValue, b);
+      if (smaller2(inv3, 0)) inv3 = add4(inv3, b);
       return inv3;
     }
   }
@@ -30590,11 +30727,11 @@ var createPinv = /* @__PURE__ */ factory(
     deepEqual: deepEqual3,
     equal: equal2,
     dotDivide: dotDivide2,
-    dot: dot7,
+    dot: dot8,
     ctranspose: ctranspose2,
     divideScalar: divideScalar2,
     multiply: multiply2,
-    add: add3,
+    add: add4,
     Complex: Complex13
   }) => {
     return typed3(name172, {
@@ -30606,7 +30743,7 @@ var createPinv = /* @__PURE__ */ factory(
             if (size2[0] === 1) {
               return inv3(x);
             } else {
-              return dotDivide2(ctranspose2(x), dot7(x, x));
+              return dotDivide2(ctranspose2(x), dot8(x, x));
             }
           case 2: {
             if (_isZeros(x)) return ctranspose2(x);
@@ -30676,7 +30813,7 @@ var createPinv = /* @__PURE__ */ factory(
           if (i2 === r) continue;
           val = M[i2][lead];
           for (let j = 0; j < cols; j++) {
-            M[i2][j] = add3(M[i2][j], multiply2(-1, multiply2(val, M[r][j])));
+            M[i2][j] = add4(M[i2][j], multiply2(-1, multiply2(val, M[r][j])));
           }
         }
         lead++;
@@ -30685,17 +30822,17 @@ 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(dot7(rref[j], rref[j]))));
-      const F = rref.filter((_, i) => !_isZero(dot7(rref[i], rref[i])));
+      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])));
       return { C, F };
     }
     function _isZero(x) {
-      return equal2(add3(x, Complex13(1, 1)), add3(0, Complex13(1, 1)));
+      return equal2(add4(x, Complex13(1, 1)), add4(0, Complex13(1, 1)));
     }
     function _isZeros(arr10) {
       return deepEqual3(
-        add3(arr10, Complex13(1, 1)),
-        add3(multiply2(arr10, 0), Complex13(1, 1))
+        add4(arr10, Complex13(1, 1)),
+        add4(multiply2(arr10, 0), Complex13(1, 1))
       );
     }
   }
@@ -30926,7 +31063,7 @@ var createRange = /* @__PURE__ */ factory(
     smallerEq: smallerEq2,
     larger: larger2,
     largerEq: largerEq2,
-    add: add3,
+    add: add4,
     isZero: isZero2,
     isPositive: isPositive2
   }) => {
@@ -31039,7 +31176,7 @@ var createRange = /* @__PURE__ */ factory(
       let x = start;
       while (ongoing(x, end)) {
         array.push(x);
-        x = add3(x, step);
+        x = add4(x, step);
       }
       return array;
     }
@@ -34712,7 +34849,7 @@ var dependencies211 = [
 var createSqrtm = /* @__PURE__ */ factory(
   name211,
   dependencies211,
-  ({ typed: typed3, abs: abs2, add: add3, multiply: multiply2, map: map2, sqrt: sqrt2, subtract: subtract3, inv: inv3, size: size2, max: max2, identity: identity2 }) => {
+  ({ typed: typed3, abs: abs2, add: add4, multiply: multiply2, map: map2, sqrt: sqrt2, subtract: subtract3, inv: inv3, size: size2, max: max2, identity: identity2 }) => {
     const _maxIterations = 1e3;
     const _tolerance = 1e-6;
     function _tryWasmSqrtm(A, n) {
@@ -34778,8 +34915,8 @@ var createSqrtm = /* @__PURE__ */ factory(
       let Z = identity2(size2(A));
       do {
         const Yk = Y;
-        Y = multiply2(0.5, add3(Yk, inv3(Z)));
-        Z = multiply2(0.5, add3(Z, inv3(Yk)));
+        Y = multiply2(0.5, add4(Yk, inv3(Z)));
+        Z = multiply2(0.5, add4(Z, inv3(Yk)));
         error = max2(abs2(subtract3(Y, Yk)));
         if (error > _tolerance && ++iterations > _maxIterations) {
           throw new Error("computing square root of matrix: iterative method could not converge");
@@ -35417,7 +35554,7 @@ var createSlu = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     abs: abs2,
-    add: add3,
+    add: add4,
     multiply: multiply2,
     transpose: transpose5,
     divideScalar: divideScalar2,
@@ -35426,7 +35563,7 @@ var createSlu = /* @__PURE__ */ factory(
     largerEq: largerEq2,
     SparseMatrix
   }) => {
-    const csSqr2 = createCsSqr({ add: add3, multiply: multiply2, transpose: transpose5 });
+    const csSqr2 = createCsSqr({ add: add4, multiply: multiply2, transpose: transpose5 });
     const csLu2 = createCsLu({
       abs: abs2,
       divideScalar: divideScalar2,
@@ -35731,7 +35868,7 @@ var createIntersect = /* @__PURE__ */ factory(
     typed: typed3,
     config: config2,
     abs: abs2,
-    add: add3,
+    add: add4,
     addScalar: addScalar2,
     matrix: matrix2,
     multiply: multiply2,
@@ -35871,7 +36008,7 @@ var createIntersect = /* @__PURE__ */ factory(
         ),
         det2
       );
-      return add3(multiply2(d1, t), o1);
+      return add4(multiply2(d1, t), o1);
     }
     function _tryWasmIntersect2d(p1a, p1b, p2a, p2b) {
       const wasm = wasmLoader.getModule();
@@ -35987,7 +36124,7 @@ var dependencies219 = ["typed", "add", "divide"];
 var createMean = /* @__PURE__ */ factory(
   name219,
   dependencies219,
-  ({ typed: typed3, add: add3, divide: divide2 }) => {
+  ({ typed: typed3, add: add4, divide: divide2 }) => {
     return typed3(name219, {
       // mean([a, b, c, d, ...])
       "Array | Matrix": _mean2,
@@ -36004,7 +36141,7 @@ var createMean = /* @__PURE__ */ factory(
     function _nmeanDim(array, dim) {
       try {
         const dimValue = typeof dim === "number" ? dim : dim.valueOf();
-        const sum3 = reduce2(array, dimValue, add3);
+        const sum3 = reduce2(array, dimValue, add4);
         const s = Array.isArray(array) ? arraySize(array) : array.size();
         return divide2(sum3, s[dimValue]);
       } catch (err) {
@@ -36032,7 +36169,7 @@ var createMean = /* @__PURE__ */ factory(
       let num2 = 0;
       deepForEach2(array, function(value) {
         try {
-          sum3 = sum3 === void 0 ? value : add3(sum3, value);
+          sum3 = sum3 === void 0 ? value : add4(sum3, value);
           num2++;
         } catch (err) {
           throw improveErrorMessage(err, "mean", value);
@@ -36052,7 +36189,7 @@ var dependencies220 = ["typed", "add", "divide", "compare", "partitionSelect"];
 var createMedian = /* @__PURE__ */ factory(
   name220,
   dependencies220,
-  ({ typed: typed3, add: add3, divide: divide2, compare: compare2, partitionSelect: partitionSelect2 }) => {
+  ({ typed: typed3, add: add4, divide: divide2, compare: compare2, partitionSelect: partitionSelect2 }) => {
     function _median2(array) {
       try {
         const flat = flatten2(array.valueOf());
@@ -36085,7 +36222,7 @@ var createMedian = /* @__PURE__ */ factory(
     });
     const middle2 = typed3({
       "number | BigNumber | Complex | Unit, number | BigNumber | Complex | Unit": function(left, right) {
-        return divide2(add3(left, right), 2);
+        return divide2(add4(left, right), 2);
       }
     });
     return typed3(name220, {
@@ -36124,7 +36261,7 @@ var createVariance = /* @__PURE__ */ factory(
   dependencies221,
   ({
     typed: typed3,
-    add: add3,
+    add: add4,
     subtract: subtract3,
     multiply: multiply2,
     divide: divide2,
@@ -36173,7 +36310,7 @@ var createVariance = /* @__PURE__ */ factory(
       let num2 = 0;
       deepForEach2(array, function(value) {
         try {
-          sum3 = sum3 === void 0 ? value : add3(sum3, value);
+          sum3 = sum3 === void 0 ? value : add4(sum3, value);
           num2++;
         } catch (err) {
           throw improveErrorMessage(err, "variance", value);
@@ -36184,7 +36321,7 @@ var createVariance = /* @__PURE__ */ factory(
       sum3 = void 0;
       deepForEach2(array, function(value) {
         const diff2 = subtract3(value, mean7);
-        sum3 = sum3 === void 0 ? multiply2(diff2, diff2) : add3(sum3, multiply2(diff2, diff2));
+        sum3 = sum3 === void 0 ? multiply2(diff2, diff2) : add4(sum3, multiply2(diff2, diff2));
       });
       if (mathIsNaN(sum3)) {
         return sum3;
@@ -36259,7 +36396,7 @@ var createQuantileSeq = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     bignumber: bignumber2,
-    add: add3,
+    add: add4,
     subtract: subtract3,
     divide: divide2,
     multiply: multiply2,
@@ -36307,7 +36444,7 @@ var createQuantileSeq = /* @__PURE__ */ factory(
             "N must be less than or equal to 2^32-1, as that is the maximum length of an Array"
           );
         }
-        const nPlusOne = add3(probOrN, 1);
+        const nPlusOne = add4(probOrN, 1);
         probArr = [];
         for (let i = 0; smaller2(i, probOrN); i++) {
           const prob = divide2(i + 1, nPlusOne);
@@ -36364,11 +36501,11 @@ var createQuantileSeq = /* @__PURE__ */ factory(
           return integerPart % 2 === 0 ? left : right;
         }
         case "midpoint":
-          return divide2(add3(left, right), 2);
+          return divide2(add4(left, right), 2);
         case "linear":
         default: {
           const fracPartConverted = isBigNumber(left) && isNumber(fracPart) ? bignumber2(fracPart) : fracPart;
-          return add3(
+          return add4(
             multiply2(left, subtract3(1, fracPartConverted)),
             multiply2(right, fracPartConverted)
           );
@@ -36462,7 +36599,7 @@ var dependencies224 = ["typed", "add", "divide", "multiply", "factorial", "isInt
 var createMultinomial = /* @__PURE__ */ factory(
   name224,
   dependencies224,
-  ({ typed: typed3, add: add3, divide: divide2, multiply: multiply2, factorial: factorial5, isInteger: isInteger3, isPositive: isPositive2 }) => {
+  ({ typed: typed3, add: add4, divide: divide2, multiply: multiply2, factorial: factorial5, isInteger: isInteger3, isPositive: isPositive2 }) => {
     return typed3(name224, {
       "Array | Matrix": function(a) {
         let sum3 = 0;
@@ -36471,7 +36608,7 @@ var createMultinomial = /* @__PURE__ */ factory(
           if (!isInteger3(ai) || !isPositive2(ai)) {
             throw new TypeError("Positive integer value expected in function multinomial");
           }
-          sum3 = add3(sum3, ai);
+          sum3 = add4(sum3, ai);
           denom = multiply2(denom, factorial5(ai));
         });
         return divide2(factorial5(sum3), denom);
@@ -36487,7 +36624,7 @@ var dependencies225 = ["typed", "add", "multiply", "Complex", "divide", "matrix"
 var createFreqz = /* @__PURE__ */ factory(
   name225,
   dependencies225,
-  ({ typed: typed3, add: add3, multiply: multiply2, Complex: Complex13, divide: divide2, matrix: matrix2 }) => {
+  ({ typed: typed3, add: add4, multiply: multiply2, Complex: Complex13, divide: divide2, matrix: matrix2 }) => {
     return typed3(name225, {
       "Array, Array": function(b, a) {
         const w = createBins(512);
@@ -36581,13 +36718,13 @@ var createFreqz = /* @__PURE__ */ factory(
         let sumNum = Complex13(0, 0);
         let sumDen = Complex13(0, 0);
         for (let j = 0; j < b.length; j++) {
-          sumNum = add3(
+          sumNum = add4(
             sumNum,
             multiply2(b[j], Complex13(Math.cos(-j * w[i]), Math.sin(-j * w[i])))
           );
         }
         for (let j = 0; j < a.length; j++) {
-          sumDen = add3(
+          sumDen = add4(
             sumDen,
             multiply2(a[j], Complex13(Math.cos(-j * w[i]), Math.sin(-j * w[i])))
           );
@@ -37404,7 +37541,7 @@ var createPolynomialRoot = /* @__PURE__ */ factory(
     typed: typed3,
     isZero: isZero2,
     equalScalar: equalScalar3,
-    add: add3,
+    add: add4,
     subtract: subtract3,
     multiply: multiply2,
     divide: divide2,
@@ -37446,15 +37583,15 @@ var createPolynomialRoot = /* @__PURE__ */ factory(
             const denom = unaryMinus2(multiply2(3, a));
             const D0_1 = multiply2(b, b);
             const D0_2 = multiply2(3, a, c);
-            const D1_1 = add3(multiply2(2, b, b, b), multiply2(27, a, a, d));
+            const D1_1 = add4(multiply2(2, b, b, b), multiply2(27, a, a, d));
             const D1_2 = multiply2(9, a, b, c);
             if (equalScalar3(D0_1, D0_2) && equalScalar3(D1_1, D1_2)) {
               return [divide2(b, denom)];
             }
             const Delta0 = subtract3(D0_1, D0_2);
             const Delta1 = subtract3(D1_1, D1_2);
-            const discriminant1 = add3(multiply2(18, a, b, c, d), multiply2(b, b, c, c));
-            const discriminant2 = add3(
+            const discriminant1 = add4(multiply2(18, a, b, c, d), multiply2(b, b, c, c));
+            const discriminant2 = add4(
               multiply2(4, b, b, b, d),
               multiply2(4, a, c, c, c),
               multiply2(27, a, a, d, d)
@@ -37462,7 +37599,7 @@ var createPolynomialRoot = /* @__PURE__ */ factory(
             if (equalScalar3(discriminant1, discriminant2)) {
               return [
                 divide2(
-                  subtract3(multiply2(4, a, b, c), add3(multiply2(9, a, a, d), multiply2(b, b, b))),
+                  subtract3(multiply2(4, a, b, c), add4(multiply2(9, a, a, d), multiply2(b, b, b))),
                   multiply2(a, Delta0)
                 ),
                 // simple root
@@ -37475,7 +37612,7 @@ var createPolynomialRoot = /* @__PURE__ */ factory(
               Ccubed = Delta1;
             } else {
               Ccubed = divide2(
-                add3(
+                add4(
                   Delta1,
                   sqrt2(subtract3(multiply2(Delta1, Delta1), multiply2(4, Delta0, Delta0, Delta0)))
                 ),
@@ -37483,7 +37620,7 @@ var createPolynomialRoot = /* @__PURE__ */ factory(
               );
             }
             const allRoots = true;
-            const rawRoots = cbrt3(Ccubed, allRoots).toArray().map((C) => divide2(add3(b, C, divide2(Delta0, C)), denom));
+            const rawRoots = cbrt3(Ccubed, allRoots).toArray().map((C) => divide2(add4(b, C, divide2(Delta0, C)), denom));
             return rawRoots.map((r) => {
               if (typeOf3(r) === "Complex" && equalScalar3(re3(r), re3(r) + im3(r))) {
                 return re3(r);
@@ -37539,7 +37676,7 @@ var createZeta = /* @__PURE__ */ factory(
     gamma: gamma2,
     sin: sin2,
     subtract: subtract3,
-    add: add3,
+    add: add4,
     Complex: Complex13,
     BigNumber: BigNumber9,
     pi
@@ -37607,20 +37744,20 @@ var createZeta = /* @__PURE__ */ factory(
     }
     function d(k, n) {
       let S = k;
-      for (let j = k; smallerEq2(j, n); j = add3(j, 1)) {
+      for (let j = k; smallerEq2(j, n); j = add4(j, 1)) {
         const factor2 = divide2(
-          multiply2(factorial5(add3(n, subtract3(j, 1))), pow2(4, j)),
+          multiply2(factorial5(add4(n, subtract3(j, 1))), pow2(4, j)),
           multiply2(factorial5(subtract3(n, j)), factorial5(multiply2(2, j)))
         );
-        S = add3(S, factor2);
+        S = add4(S, factor2);
       }
       return multiply2(n, S);
     }
     function f(s, n, createValue) {
       const c = divide2(1, multiply2(d(createValue(0), n), subtract3(1, pow2(2, subtract3(1, s)))));
       let S = createValue(0);
-      for (let k = createValue(1); smallerEq2(k, n); k = add3(k, 1)) {
-        S = add3(S, divide2(multiply2((-1) ** (k - 1), d(k, n)), pow2(k, s)));
+      for (let k = createValue(1); smallerEq2(k, n); k = add4(k, 1)) {
+        S = add4(S, divide2(multiply2((-1) ** (k - 1), d(k, n)), pow2(k, s)));
       }
       return multiply2(c, S);
     }
@@ -37686,7 +37823,7 @@ function createComplexEigs({
   larger: larger2,
   smaller: smaller2,
   matrixFromColumns: _matrixFromColumns,
-  dot: dot7
+  dot: dot8
 }) {
   function complexEigs(arr10, N, prec, type, findVectors = true) {
     if (!findVectors && type === "number" && N * N >= WASM_EIGS_THRESHOLD) {
@@ -38057,11 +38194,11 @@ function createComplexEigs({
       M[i] = Array(N).fill(0);
     }
     let I2 = 0;
-    for (const sub of arr10) {
-      const n = sub.length;
+    for (const sub2 of arr10) {
+      const n = sub2.length;
       for (let i = 0; i < n; i++) {
         for (let j = 0; j < n; j++) {
-          M[I2 + i][I2 + j] = sub[i][j];
+          M[I2 + i][I2 + j] = sub2[i][j];
         }
       }
       I2 += n;
@@ -38127,7 +38264,7 @@ function createComplexEigs({
       v = subtract3(
         v,
         multiply2(
-          divideScalar2(dot7(w, v), dot7(w, w)),
+          divideScalar2(dot8(w, v), dot8(w, w)),
           w
         )
       );
@@ -38135,7 +38272,7 @@ function createComplexEigs({
     return v;
   }
   function norm4(v) {
-    return abs2(sqrt2(dot7(v, v)));
+    return abs2(sqrt2(dot8(v, v)));
   }
   function normalize2(v, type) {
     const big = type === "BigNumber";
@@ -38169,7 +38306,7 @@ function createRealSymmetric({
   inv: inv3,
   bignumber: bignumber2,
   multiply: multiply2,
-  add: add3
+  add: add4
 }) {
   function bigGte(a, b) {
     if (typeof a === "number" && typeof b === "number") return a >= b;
@@ -38366,7 +38503,7 @@ function createRealSymmetric({
       subtract3(multiplyScalar2(c2, Hij[i][i]), csHij),
       multiplyScalar2(s2, Hij[j][j])
     );
-    const Ajj = add3(
+    const Ajj = add4(
       multiplyScalar2(s2, Hij[i][i]),
       csHij,
       multiplyScalar2(c2, Hij[j][j])
@@ -38538,7 +38675,7 @@ var createEigs = /* @__PURE__ */ factory(
     inv: inv3,
     bignumber: bignumber2,
     multiply: multiply2,
-    add: add3,
+    add: add4,
     larger: larger2,
     column: _column,
     flatten: flatten5,
@@ -38555,7 +38692,7 @@ var createEigs = /* @__PURE__ */ factory(
     re: re3,
     smaller: smaller2,
     matrixFromColumns: matrixFromColumns2,
-    dot: dot7
+    dot: dot8
   }) => {
     const doRealSymmetric = createRealSymmetric({
       config: config2,
@@ -38570,7 +38707,7 @@ var createEigs = /* @__PURE__ */ factory(
       bignumber: bignumber2,
       complex: complex3,
       multiply: multiply2,
-      add: add3
+      add: add4
     });
     const doComplexEigs = createComplexEigs({
       addScalar: addScalar2,
@@ -38594,7 +38731,7 @@ var createEigs = /* @__PURE__ */ factory(
       larger: larger2,
       smaller: smaller2,
       matrixFromColumns: matrixFromColumns2,
-      dot: dot7
+      dot: dot8
     });
     return typed3("eigs", {
       // The conversion to matrix in the first two implementations,
@@ -40596,7 +40733,7 @@ var createNorm = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     abs: abs2,
-    add: add3,
+    add: add4,
     pow: pow2,
     conj: conj3,
     sqrt: sqrt2,
@@ -40701,7 +40838,7 @@ var createNorm = /* @__PURE__ */ factory(
         if (!equalScalar3(p, 0)) {
           let n = 0;
           x.forEach(function(value) {
-            n = add3(pow2(abs2(value), p), n);
+            n = add4(pow2(abs2(value), p), n);
           }, true);
           return pow2(n, 1 / p);
         }
@@ -40712,7 +40849,7 @@ var createNorm = /* @__PURE__ */ factory(
     function _matrixNormFrobenius(x) {
       let fro = 0;
       x.forEach(function(value) {
-        fro = add3(fro, multiply2(value, conj3(value)));
+        fro = add4(fro, multiply2(value, conj3(value)));
       });
       return abs2(sqrt2(fro));
     }
@@ -40721,7 +40858,7 @@ var createNorm = /* @__PURE__ */ factory(
       let maxc = 0;
       x.forEach(function(value, index) {
         const j = index[1];
-        const cj = add3(c[j] || 0, abs2(value));
+        const cj = add4(c[j] || 0, abs2(value));
         if (larger2(cj, maxc)) {
           maxc = cj;
         }
@@ -40745,7 +40882,7 @@ var createNorm = /* @__PURE__ */ factory(
       let maxr = 0;
       x.forEach(function(value, index) {
         const i = index[0];
-        const ri = add3(r[i] || 0, abs2(value));
+        const ri = add4(r[i] || 0, abs2(value));
         if (larger2(ri, maxr)) {
           maxr = ri;
         }
@@ -41579,7 +41716,7 @@ var createSylvester = /* @__PURE__ */ factory(
     transpose: transpose5,
     index,
     subset: subset2,
-    add: add3,
+    add: add4,
     subtract: subtract3,
     identity: identity2,
     lusolve: lusolve2,
@@ -41627,7 +41764,7 @@ var createSylvester = /* @__PURE__ */ factory(
         if (k < n - 1 && abs2(subset2(G, index(k + 1, k))) > 1e-5) {
           let RHS = vc(subset2(D, index(all, [k])), subset2(D, index(all, [k + 1])));
           for (let j = 0; j < k; j++) {
-            RHS = add3(
+            RHS = add4(
               RHS,
               vc(multiply2(y[j], subset2(G, index(j, k))), multiply2(y[j], subset2(G, index(j, k + 1))))
             );
@@ -41636,7 +41773,7 @@ var createSylvester = /* @__PURE__ */ factory(
           const gmk = multiply2(identity2(m), multiply2(-1, subset2(G, index(k + 1, k))));
           const gkm = multiply2(identity2(m), multiply2(-1, subset2(G, index(k, k + 1))));
           const gmm = multiply2(identity2(m), multiply2(-1, subset2(G, index(k + 1, k + 1))));
-          const LHS = vc(hc(add3(F, gkk), gmk), hc(gkm, add3(F, gmm)));
+          const LHS = vc(hc(add4(F, gkk), gmk), hc(gkm, add4(F, gmm)));
           const yAux = lusolve2(LHS, RHS);
           y[k] = yAux.subset(index(range2(0, m), [0]));
           y[k + 1] = yAux.subset(index(range2(m, 2 * m), [0]));
@@ -41644,7 +41781,7 @@ var createSylvester = /* @__PURE__ */ factory(
         } else {
           let RHS = subset2(D, index(all, [k]));
           for (let j = 0; j < k; j++) {
-            RHS = add3(RHS, multiply2(y[j], subset2(G, index(j, k))));
+            RHS = add4(RHS, multiply2(y[j], subset2(G, index(j, k))));
           }
           const gkk = subset2(G, index(k, k));
           const LHS = subtract3(F, multiply2(gkk, identity2(m)));
@@ -43452,11 +43589,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 cross2 = (fpp - fpm - fmp + fmm) / (4 * h * h);
-        if (Math.abs(cross2) < 1e-12) continue;
+        const cross3 = (fpp - fpm - fmp + fmm) / (4 * h * h);
+        if (Math.abs(cross3) < 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(cross2)}*${xi}*${xj}`);
+        terms.push(`${formatCoeff(cross3)}*${xi}*${xj}`);
       }
     }
   }
@@ -43483,8 +43620,8 @@ function polyCoeffsDeg3(expr, varName) {
     const d2 = f[2] - 2 * f[1] + f[0];
     const d3 = f[3] - 3 * f[2] + 3 * f[1] - f[0];
     const d4 = f[4] - 4 * f[3] + 6 * f[2] - 4 * f[1] + f[0];
-    const scale3 = Math.max(1, ...f.map(Math.abs));
-    if (Math.abs(d4) > 1e-7 * scale3) return null;
+    const scale4 = Math.max(1, ...f.map(Math.abs));
+    if (Math.abs(d4) > 1e-7 * scale4) return null;
     const c3 = d3 / 6;
     const c2 = d2 / 2 - d3 / 2;
     const c1 = d1 - d2 / 2 + d3 / 3;
@@ -44817,20 +44954,20 @@ function stirlingS1(n, k) {
   }
   return s[n][k];
 }
-function modPowBig(base, exp2, mod2) {
-  let b = (base % mod2 + mod2) % mod2;
+function modPowBig(base, exp2, mod3) {
+  let b = (base % mod3 + mod3) % mod3;
   let e = exp2;
   let result = 1n;
   while (e > 0n) {
-    if (e & 1n) result = result * b % mod2;
-    b = b * b % mod2;
+    if (e & 1n) result = result * b % mod3;
+    b = b * b % mod3;
     e >>= 1n;
   }
   return result;
 }
-function modInverseBig(a, mod2) {
+function modInverseBig(a, mod3) {
   let oldR = a;
-  let r = mod2;
+  let r = mod3;
   let oldS = 1n;
   let s = 0n;
   while (r !== 0n) {
@@ -44838,7 +44975,7 @@ function modInverseBig(a, mod2) {
     [oldR, r] = [r, oldR - q * r];
     [oldS, s] = [s, oldS - q * s];
   }
-  return (oldS % mod2 + mod2) % mod2;
+  return (oldS % mod3 + mod3) % mod3;
 }
 function discreteLog(g, h, p) {
   if (!Number.isInteger(g) || !Number.isInteger(h) || !Number.isInteger(p) || p < 2) {
@@ -46484,12 +46621,12 @@ function eigsh(a, k = 1, opts) {
 }
 
 // src/numeric/structured-solvers.ts
-function thomasSolve(sub, diag2, sup, d) {
+function thomasSolve(sub2, diag2, sup, d) {
   const n = diag2.length;
   if (n === 0) return [];
-  if (sub.length !== n - 1 || sup.length !== n - 1 || d.length !== n) {
+  if (sub2.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=${sub.length}, sup=${sup.length}, d=${d.length}`
+      `thomasSolve: expected sub/sup of length ${n - 1} and d of length ${n}, got sub=${sub2.length}, sup=${sup.length}, d=${d.length}`
     );
   }
   const cp = new Array(n).fill(0);
@@ -46498,12 +46635,12 @@ function thomasSolve(sub, 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] - sub[i - 1] * cp[i - 1];
+    const m = diag2[i] - sub2[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] - sub[i - 1] * dp[i - 1]) / m;
+    dp[i] = (d[i] - sub2[i - 1] * dp[i - 1]) / m;
   }
   const x = new Array(n);
   x[n - 1] = dp[n - 1];
@@ -46716,6 +46853,12 @@ import { eig as eig3 } from "@danielsimonjr/mathts-matrix";
 function cSub(a, b) {
   return { re: a.re - b.re, im: a.im - b.im };
 }
+function cAdd(a, b) {
+  return { re: a.re + b.re, im: a.im + b.im };
+}
+function cScale(a, s) {
+  return { re: a.re * s, im: a.im * s };
+}
 function cMul(a, b) {
   return { re: a.re * b.re - a.im * b.im, im: a.re * b.im + a.im * b.re };
 }
@@ -46732,6 +46875,11 @@ function cZeros(n) {
     im: Array.from({ length: n }, () => new Array(n).fill(0))
   };
 }
+function cIdentity(n) {
+  const m = cZeros(n);
+  for (let i = 0; i < n; i++) m.re[i][i] = 1;
+  return m;
+}
 function cFromReal(A) {
   const n = A.length;
   return {
@@ -46798,7 +46946,81 @@ function isDiagonal(A, n) {
   }
   return true;
 }
-function funm(A, f) {
+function clusterEigenvalues(values, tol) {
+  const acc = [];
+  for (const v of values) {
+    let placed = false;
+    for (const c of acc) {
+      const rep = { re: c.sumRe / c.count, im: c.sumIm / c.count };
+      if (cAbs(cSub(v, rep)) < tol) {
+        c.sumRe += v.re;
+        c.sumIm += v.im;
+        c.count += 1;
+        placed = true;
+        break;
+      }
+    }
+    if (!placed) acc.push({ sumRe: v.re, sumIm: v.im, count: 1 });
+  }
+  return acc.map((c) => ({
+    value: { re: c.sumRe / c.count, im: c.sumIm / c.count },
+    count: c.count
+  }));
+}
+function factorialNum(k) {
+  let r = 1;
+  for (let i = 2; i <= k; i++) r *= i;
+  return r;
+}
+function numericalDerivative2(f, z, order) {
+  const at = (dx) => f({ re: z.re + dx, im: z.im });
+  switch (order) {
+    case 1: {
+      const h = 1e-6;
+      return cScale(cSub(at(h), at(-h)), 1 / (2 * h));
+    }
+    case 2: {
+      const h = 1e-4;
+      const t = cSub(cAdd(at(h), at(-h)), cScale(at(0), 2));
+      return cScale(t, 1 / (h * h));
+    }
+    case 3: {
+      const h = 1e-3;
+      const t = cSub(cAdd(at(2 * h), cScale(at(-h), 2)), cAdd(cScale(at(h), 2), at(-2 * h)));
+      return cScale(t, 1 / (2 * h * h * h));
+    }
+    case 4: {
+      const h = 0.01;
+      let t = at(2 * h);
+      t = cSub(t, cScale(at(h), 4));
+      t = cAdd(t, cScale(at(0), 6));
+      t = cSub(t, cScale(at(-h), 4));
+      t = cAdd(t, at(-2 * h));
+      return cScale(t, 1 / (h * h * h * h));
+    }
+    default:
+      throw new Error(
+        `funm: numerical derivatives of order ${order} are not supported (eigenvalue multiplicity ${order + 1} exceeds the finite-difference stencils); supply analytic derivatives via the fDerivs argument (fDerivs[k] = f^(k+1))`
+      );
+  }
+}
+function taylorCoeffs(f, fDerivs, z, maxOrder) {
+  const coeffs = [f(z)];
+  for (let L = 1; L <= maxOrder; L++) {
+    const deriv = fDerivs && fDerivs.length >= L ? fDerivs[L - 1](z) : numericalDerivative2(f, z, L);
+    coeffs.push(cScale(deriv, 1 / factorialNum(L)));
+  }
+  return coeffs;
+}
+function cIsFinite(M) {
+  for (let i = 0; i < M.re.length; i++) {
+    for (let j = 0; j < M.re.length; j++) {
+      if (!Number.isFinite(M.re[i][j]) || !Number.isFinite(M.im[i][j])) return false;
+    }
+  }
+  return true;
+}
+function funm(A, f, fDerivs) {
   const n = A.length;
   if (n === 0) return { re: [], im: [] };
   for (const row2 of A) {
@@ -46816,29 +47038,59 @@ function funm(A, f) {
   const { values } = eig3(A, { computeVectors: false });
   const maxAbs = values.reduce((m, v) => Math.max(m, cAbs(v)), 0);
   const tol = EIGENVALUE_DISTINCT_REL_TOL * Math.max(1, maxAbs);
-  for (let i = 0; i < n; i++) {
-    for (let j = i + 1; j < n; j++) {
-      if (cAbs(cSub(values[i], values[j])) < tol) {
-        throw new Error(
-          "funm: matrix has repeated (or numerically indistinguishable) eigenvalues and is not diagonal \u2014 defective/non-diagonalizable matrices are not supported (Schur-Parlett block recurrence not yet implemented)"
-        );
+  const clusters = clusterEigenvalues(values, tol);
+  if (clusters.length === n) {
+    const F2 = cZeros(n);
+    for (let i = 0; i < n; i++) {
+      const lambdaI = values[i];
+      let numerator = cFromReal(A);
+      let denom = { re: 1, im: 0 };
+      let first = true;
+      for (let j = 0; j < n; j++) {
+        if (j === i) continue;
+        const factor2 = cShiftedReal(A, values[j]);
+        numerator = first ? factor2 : cMatMul(numerator, factor2);
+        first = false;
+        denom = cMul(denom, cSub(lambdaI, values[j]));
       }
+      cAccumulate(F2, f(lambdaI), cMatScalarDiv(numerator, denom));
     }
+    return F2;
   }
-  const F = cZeros(n);
-  for (let i = 0; i < n; i++) {
-    const lambdaI = values[i];
-    let numerator = cFromReal(A);
-    let denom = { re: 1, im: 0 };
-    let first = true;
-    for (let j = 0; j < n; j++) {
-      if (j === i) continue;
-      const factor2 = cShiftedReal(A, values[j]);
-      numerator = first ? factor2 : cMatMul(numerator, factor2);
-      first = false;
-      denom = cMul(denom, cSub(lambdaI, values[j]));
+  const nodes = [];
+  const clusterIdx = [];
+  const taylor2 = clusters.map(
+    (c) => taylorCoeffs(f, fDerivs, c.value, c.count - 1)
+  );
+  clusters.forEach((c, ci) => {
+    for (let r = 0; r < c.count; r++) {
+      nodes.push(c.value);
+      clusterIdx.push(ci);
+    }
+  });
+  const dd = Array.from({ length: n }, () => new Array(n));
+  for (let i = 0; i < n; i++) dd[i][i] = taylor2[clusterIdx[i]][0];
+  for (let L = 1; L < n; L++) {
+    for (let i = 0; i + L < n; i++) {
+      const j = i + L;
+      if (clusterIdx[i] === clusterIdx[j]) {
+        dd[i][j] = taylor2[clusterIdx[i]][L];
+      } else {
+        dd[i][j] = cDiv(cSub(dd[i + 1][j], dd[i][j - 1]), cSub(nodes[j], nodes[i]));
+      }
     }
-    cAccumulate(F, f(lambdaI), cMatScalarDiv(numerator, denom));
+  }
+  const F = cZeros(n);
+  let P2 = cIdentity(n);
+  cAccumulate(F, dd[0][0], P2);
+  for (let k = 1; k < n; k++) {
+    P2 = cMatMul(P2, cShiftedReal(A, nodes[k - 1]));
+    cAccumulate(F, dd[0][k], P2);
+  }
+  if (!cIsFinite(F)) {
+    throw new Error(
+      "funm: result is non-finite \u2014 f (or one of its derivatives) is singular at a repeated eigenvalue (e.g. sqrt/log at 0), so the matrix function is undefined there"
+    );
   }
   return F;
 }
@@ -46854,11 +47106,17 @@ function complexSin(z) {
     im: Math.cos(z.re) * Math.sinh(z.im)
   };
 }
+function trigDerivs(base, n) {
+  return Array.from({ length: Math.max(0, n - 1) }, (_unused, k) => {
+    const shift = (k + 1) * Math.PI / 2;
+    return (z) => base({ re: z.re + shift, im: z.im });
+  });
+}
 function cosm(A) {
-  return funm(A, complexCos);
+  return funm(A, complexCos, trigDerivs(complexCos, A.length));
 }
 function sinm(A) {
-  return funm(A, complexSin);
+  return funm(A, complexSin, trigDerivs(complexSin, A.length));
 }
 
 // src/numeric/control-equations.ts
@@ -47579,15 +47837,15 @@ function ridge(X, y, alpha, opts) {
   return { coefficients, intercept };
 }
 function standardize(Xc, n, p) {
-  const scale3 = new Array(p);
+  const scale4 = new Array(p);
   for (let j = 0; j < p; j++) {
     let ss = 0;
     for (let i = 0; i < n; i++) ss += Xc[i][j] * Xc[i][j];
     const meanSq = ss / n;
-    scale3[j] = meanSq > 1e-15 ? Math.sqrt(meanSq) : 1;
+    scale4[j] = meanSq > 1e-15 ? Math.sqrt(meanSq) : 1;
   }
-  const Xs = Xc.map((row2) => row2.map((v, j) => v / scale3[j]));
-  return { Xs, scale: scale3 };
+  const Xs = Xc.map((row2) => row2.map((v, j) => v / scale4[j]));
+  return { Xs, scale: scale4 };
 }
 function coordinateDescent(Xs, yc, n, p, l1, l2, maxIter, tol) {
   const beta2 = new Array(p).fill(0);
@@ -47619,9 +47877,9 @@ function lasso(X, y, alpha, opts) {
   const maxIter = opts?.maxIter ?? 1e3;
   const tol = opts?.tol ?? 1e-7;
   const { Xc, yc, xMean, yMean } = center(X, y, n, p, useIntercept);
-  const { Xs, scale: scale3 } = standardize(Xc, n, p);
+  const { Xs, scale: scale4 } = standardize(Xc, n, p);
   const betaStd = coordinateDescent(Xs, yc, n, p, alpha, 0, maxIter, tol);
-  const coefficients = betaStd.map((b, j) => b / scale3[j]);
+  const coefficients = betaStd.map((b, j) => b / scale4[j]);
   const intercept = useIntercept ? yMean - dot4(xMean, coefficients) : 0;
   return { coefficients, intercept };
 }
@@ -47633,11 +47891,11 @@ function elasticNet(X, y, alpha, l1Ratio, opts) {
   const maxIter = opts?.maxIter ?? 1e3;
   const tol = opts?.tol ?? 1e-7;
   const { Xc, yc, xMean, yMean } = center(X, y, n, p, useIntercept);
-  const { Xs, scale: scale3 } = standardize(Xc, n, p);
+  const { Xs, scale: scale4 } = standardize(Xc, n, p);
   const l1 = alpha * l1Ratio;
   const l2 = alpha * (1 - l1Ratio);
   const betaStd = coordinateDescent(Xs, yc, n, p, l1, l2, maxIter, tol);
-  const coefficients = betaStd.map((b, j) => b / scale3[j]);
+  const coefficients = betaStd.map((b, j) => b / scale4[j]);
   const intercept = useIntercept ? yMean - dot4(xMean, coefficients) : 0;
   return { coefficients, intercept };
 }
@@ -47705,8 +47963,8 @@ function logisticRegression(X, y, opts) {
     let stepNorm = 0;
     for (const d of delta) stepNorm = Math.max(stepNorm, Math.abs(d));
     if (stepNorm > MAX_STEP_NORM) {
-      const scale3 = MAX_STEP_NORM / stepNorm;
-      delta = delta.map((d) => d * scale3);
+      const scale4 = MAX_STEP_NORM / stepNorm;
+      delta = delta.map((d) => d * scale4);
       stepNorm = MAX_STEP_NORM;
     }
     beta2 = beta2.map((b, j) => b + delta[j]);
@@ -47744,18 +48002,18 @@ function nelderMead(f, x0, opts = {}) {
     for (let i = 0; i < n; i++) for (let j = 0; j < n; j++) c[j] += pts[i][j] / n;
     return c;
   };
-  const add3 = (a, b, s) => a.map((v, i) => v + s * b[i]);
-  const sub = (a, b) => a.map((v, i) => v - b[i]);
+  const add4 = (a, b, s) => a.map((v, i) => v + s * b[i]);
+  const sub2 = (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 = add3(c, sub(c, simplex[n]), alpha);
+    const xr = add4(c, sub2(c, simplex[n]), alpha);
     const fr = f(xr);
     if (fr < fv[0]) {
-      const xe = add3(c, sub(c, simplex[n]), gamma2);
+      const xe = add4(c, sub2(c, simplex[n]), gamma2);
       const fe = f(xe);
       if (fe < fr) {
         simplex[n] = xe;
@@ -47768,14 +48026,14 @@ function nelderMead(f, x0, opts = {}) {
       simplex[n] = xr;
       fv[n] = fr;
     } else {
-      const xc = add3(c, sub(simplex[n], c), rho);
+      const xc = add4(c, sub2(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] = add3(simplex[0], sub(simplex[i], simplex[0]), sigma);
+          simplex[i] = add4(simplex[0], sub2(simplex[i], simplex[0]), sigma);
           fv[i] = f(simplex[i]);
         }
       }
@@ -48148,8 +48406,8 @@ function fitPoisson(data) {
   for (const k of data) logLikelihood += -lambda + k * Math.log(lambda) - logFactorial(k);
   return { params: { lambda }, logLikelihood };
 }
-function gammaLogPdf(x, shape, scale3) {
-  return (shape - 1) * Math.log(x) - x / scale3 - lgamma(shape) - shape * Math.log(scale3);
+function gammaLogPdf(x, shape, scale4) {
+  return (shape - 1) * Math.log(x) - x / scale4 - lgamma(shape) - shape * Math.log(scale4);
 }
 function fitGamma(data) {
   for (const x of data) {
@@ -48166,10 +48424,10 @@ function fitGamma(data) {
   const k0 = (3 - s + Math.sqrt((s - 3) * (s - 3) + 24 * s)) / (12 * s);
   const f = (k) => Math.log(k) - digamma(k) - s;
   const shape = secant(f, k0, k0 * 1.1, { tol: 1e-12, maxIter: 200 });
-  const scale3 = xbar / shape;
+  const scale4 = xbar / shape;
   let logLikelihood = 0;
-  for (const x of data) logLikelihood += gammaLogPdf(x, shape, scale3);
-  return { params: { shape, scale: scale3 }, logLikelihood };
+  for (const x of data) logLikelihood += gammaLogPdf(x, shape, scale4);
+  return { params: { shape, scale: scale4 }, logLikelihood };
 }
 function fitDistribution(name254, data) {
   if (data.length === 0) {
@@ -48658,17 +48916,17 @@ function filtfilt(b, a, x) {
   ).y.reverse();
   return back.slice(pad, pad + n);
 }
-var cAdd = (p, q) => p.add(q);
+var cAdd2 = (p, q) => p.add(q);
 var cSub2 = (p, q) => p.sub(q);
 var cMul2 = (p, q) => p.multiply(q);
 var cDiv2 = (p, q) => p.divide(q);
-var cScale = (p, s) => cMul2(p, new Complex11(s, 0));
+var cScale2 = (p, s) => cMul2(p, new Complex11(s, 0));
 function polyFromRoots(roots) {
   let c = [new Complex11(1, 0)];
   for (const r of roots) {
     const next = Array.from({ length: c.length + 1 }, () => new Complex11(0, 0));
     for (let i = 0; i < c.length; i++) {
-      next[i] = cAdd(next[i], c[i]);
+      next[i] = cAdd2(next[i], c[i]);
       next[i + 1] = cSub2(next[i + 1], cMul2(c[i], r));
     }
     c = next;
@@ -48683,8 +48941,8 @@ function relativeDegree(z, p) {
 function lp2lpZpk(z, p, k, wo) {
   const degree2 = relativeDegree(z, p);
   return {
-    z: z.map((zv) => cScale(zv, wo)),
-    p: p.map((pv) => cScale(pv, wo)),
+    z: z.map((zv) => cScale2(zv, wo)),
+    p: p.map((pv) => cScale2(pv, wo)),
     k: k * Math.pow(wo, degree2)
   };
 }
@@ -48703,8 +48961,8 @@ function lp2bpZpk(z, p, k, wo, bw) {
   const degree2 = relativeDegree(z, p);
   const wo2 = new Complex11(wo * wo, 0);
   const shift = (roots) => {
-    const lp = roots.map((r) => cScale(r, bw / 2));
-    const plus = lp.map((r) => cAdd(r, cSub2(cMul2(r, r), wo2).sqrt()));
+    const lp = roots.map((r) => cScale2(r, bw / 2));
+    const plus = lp.map((r) => cAdd2(r, cSub2(cMul2(r, r), wo2).sqrt()));
     const minus = lp.map((r) => cSub2(r, cSub2(cMul2(r, r), wo2).sqrt()));
     return plus.concat(minus);
   };
@@ -48718,7 +48976,7 @@ function lp2bsZpk(z, p, k, wo, bw) {
   const bw2 = new Complex11(bw / 2, 0);
   const shift = (roots) => {
     const hp = roots.map((r) => cDiv2(bw2, r));
-    const plus = hp.map((r) => cAdd(r, cSub2(cMul2(r, r), wo2).sqrt()));
+    const plus = hp.map((r) => cAdd2(r, cSub2(cMul2(r, r), wo2).sqrt()));
     const minus = hp.map((r) => cSub2(r, cSub2(cMul2(r, r), wo2).sqrt()));
     return plus.concat(minus);
   };
@@ -48734,7 +48992,7 @@ function lp2bsZpk(z, p, k, wo, bw) {
 function bilinearZpk(z, p, k, fs) {
   const degree2 = relativeDegree(z, p);
   const fs2 = new Complex11(2 * fs, 0);
-  const zZ = z.map((zv) => cDiv2(cAdd(fs2, zv), cSub2(fs2, zv)));
+  const zZ = z.map((zv) => cDiv2(cAdd2(fs2, zv), cSub2(fs2, zv)));
   for (let i = 0; i < degree2; i++) zZ.push(new Complex11(-1, 0));
   let prodZ = new Complex11(1, 0);
   for (const zv of z) prodZ = cMul2(prodZ, cSub2(fs2, zv));
@@ -48742,7 +49000,7 @@ function bilinearZpk(z, p, k, fs) {
   for (const pv of p) prodP = cMul2(prodP, cSub2(fs2, pv));
   return {
     z: zZ,
-    p: p.map((pv) => cDiv2(cAdd(fs2, pv), cSub2(fs2, pv))),
+    p: p.map((pv) => cDiv2(cAdd2(fs2, pv), cSub2(fs2, pv))),
     k: k * cDiv2(prodZ, prodP).re
   };
 }
@@ -49008,10 +49266,10 @@ function arcJacSn(w, m) {
   let wn = w;
   for (let i = 0; i < ks.length - 1; i++) {
     const knext = ks[i + 1];
-    const comp = complementComplex(cScale(wn, ks[i]));
-    wn = cDiv2(cScale(wn, 2), cMul2(new Complex12(1 + knext, 0), new Complex12(1, 0).add(comp)));
+    const comp = complementComplex(cScale2(wn, ks[i]));
+    wn = cDiv2(cScale2(wn, 2), cMul2(new Complex12(1 + knext, 0), new Complex12(1, 0).add(comp)));
   }
-  return cScale(cScale(wn.asin(), 2 / Math.PI), K);
+  return cScale2(cScale2(wn.asin(), 2 / Math.PI), K);
 }
 function arcJacSc1(w, m) {
   const z = arcJacSn(new Complex12(0, w), m);
@@ -49570,20 +49828,11 @@ function remez(numtaps, bands, desired) {
 
 // src/signal/wavelets.ts
 function idwt(approx, detail, wavelet = "haar") {
-  if (wavelet !== "haar" && wavelet !== "db1") {
-    throw new Error(`idwt: unsupported wavelet "${wavelet}"`);
-  }
-  if (approx.length !== detail.length) {
-    throw new Error("idwt: approx and detail must have equal length");
-  }
-  const half = approx.length;
-  const s = 1 / Math.SQRT2;
-  const x = new Array(half * 2);
-  for (let i = 0; i < half; i++) {
-    x[2 * i] = s * (approx[i] + detail[i]);
-    x[2 * i + 1] = s * (approx[i] - detail[i]);
+  try {
+    return idwtPeriodization(approx, detail, wavelet);
+  } catch (err) {
+    throw new Error(`idwt: ${err instanceof Error ? err.message : String(err)}`);
   }
-  return x;
 }
 function wavedec(x, wavelet = "haar", level = 1) {
   if (!Number.isInteger(level) || level < 1) {
@@ -49609,23 +49858,23 @@ function waverec(coeffs, wavelet = "haar") {
   }
   return approx;
 }
-function rickerWavelet(points, scale3) {
-  const amplitude = 2 / (Math.sqrt(3 * scale3) * Math.pow(Math.PI, 0.25));
+function rickerWavelet(points, scale4) {
+  const amplitude = 2 / (Math.sqrt(3 * 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) / scale3;
+    const t = (i - center3) / scale4;
     const t2 = t * t;
     out[i] = amplitude * (1 - t2) * Math.exp(-t2 / 2);
   }
   return out;
 }
-function morletWavelet(points, scale3) {
-  const norm4 = 1 / (Math.sqrt(scale3) * Math.pow(Math.PI, 0.25));
+function morletWavelet(points, scale4) {
+  const norm4 = 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) / scale3;
+    const t = (i - center3) / scale4;
     out[i] = norm4 * Math.cos(5 * t) * Math.exp(-(t * t) / 2);
   }
   return out;
@@ -49635,10 +49884,10 @@ function cwt(x, scales, wavelet = "ricker") {
     throw new Error(`cwt: unsupported wavelet "${wavelet}"`);
   }
   const n = x.length;
-  return scales.map((scale3) => {
-    if (scale3 <= 0) throw new Error("cwt: scales must be positive");
-    const points = Math.max(1, Math.min(Math.round(10 * scale3), n));
-    const psi = wavelet === "ricker" ? rickerWavelet(points, scale3) : morletWavelet(points, scale3);
+  return scales.map((scale4) => {
+    if (scale4 <= 0) throw new Error("cwt: scales must be positive");
+    const points = Math.max(1, Math.min(Math.round(10 * scale4), n));
+    const psi = wavelet === "ricker" ? rickerWavelet(points, scale4) : morletWavelet(points, scale4);
     return convDirect(x, psi, "same");
   });
 }
@@ -49756,10 +50005,10 @@ function crossPower(x, y, opts) {
       im3[k] += X.im * Y.re - X.re * Y.im;
     }
   }
-  const scale3 = 1 / (fs * winSum2 * nSeg);
+  const scale4 = 1 / (fs * winSum2 * nSeg);
   for (let k = 0; k < half; k++) {
-    re3[k] *= scale3;
-    im3[k] *= scale3;
+    re3[k] *= scale4;
+    im3[k] *= scale4;
   }
   const frequencies = Array.from({ length: half }, (_, k) => k * fs / nfft);
   return { frequencies, re: re3, im: im3 };
@@ -49946,6 +50195,27 @@ function quaternionToEuler(q) {
   const yaw = Math.atan2(2 * (w * z + x * y), 1 - 2 * (y * y + z * z));
   return [roll, pitch, yaw];
 }
+var QUAT_VECTOR_EPS = 1e-15;
+function quaternionLog(q) {
+  const [w, x, y, z] = q;
+  const vNorm = Math.sqrt(x * x + y * y + z * z);
+  if (vNorm < QUAT_VECTOR_EPS) return [0, 0, 0, 0];
+  const theta = Math.atan2(vNorm, w);
+  const s = theta / vNorm;
+  return [0, x * s, y * s, z * s];
+}
+function quaternionExp(q) {
+  const [w, x, y, z] = q;
+  const vNorm = Math.sqrt(x * x + y * y + z * z);
+  const ew = Math.exp(w);
+  if (vNorm < QUAT_VECTOR_EPS) return [ew, 0, 0, 0];
+  const s = ew * Math.sin(vNorm) / vNorm;
+  return [ew * Math.cos(vNorm), x * s, y * s, z * s];
+}
+function quaternionPow(q, t) {
+  const logQ = quaternionLog(q);
+  return quaternionExp(logQ.map((v) => v * t));
+}
 function boundingBox(points) {
   if (points.length === 0) throw new Error("boundingBox: requires at least one point");
   const dims = points[0].length;
@@ -50011,8 +50281,8 @@ function procrustes(A, B) {
   const M = matMul2(matTranspose(A0), B0);
   const { U, S, V } = svd3(M);
   const R = matMul2(V, matTranspose(U));
-  const scale3 = S.reduce((s, v) => s + v, 0);
-  const transformed = matMul2(B0, R).map((row2) => row2.map((v) => v * scale3));
+  const scale4 = S.reduce((s, v) => s + v, 0);
+  const transformed = matMul2(B0, R).map((row2) => row2.map((v) => v * scale4));
   let disparity = 0;
   for (let i = 0; i < A0.length; i++) {
     for (let j = 0; j < A0[i].length; j++) {
@@ -50020,7 +50290,7 @@ function procrustes(A, B) {
       disparity += diff2 * diff2;
     }
   }
-  return { R, scale: scale3, disparity };
+  return { R, scale: scale4, disparity };
 }
 function euclideanDist(a, b) {
   let sum3 = 0;
@@ -50069,6 +50339,89 @@ function setDisjoint(a, b) {
   return true;
 }
 
+// src/geometry/intersect3d.ts
+var EPS3 = 1e-12;
+function sub(a, b) {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function add3(a, b) {
+  return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+}
+function scale3(a, s) {
+  return [a[0] * s, a[1] * s, a[2] * s];
+}
+function dot7(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function cross2(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 rayTriangleIntersect(origin, dir, v0, v1, v2) {
+  const e1 = sub(v1, v0);
+  const e2 = sub(v2, v0);
+  const pvec = cross2(dir, e2);
+  const det2 = dot7(e1, pvec);
+  if (Math.abs(det2) < EPS3) return null;
+  const invDet = 1 / det2;
+  const tvec = sub(origin, v0);
+  const u = dot7(tvec, pvec) * invDet;
+  if (u < 0 || u > 1) return null;
+  const qvec = cross2(tvec, e1);
+  const v = dot7(dir, qvec) * invDet;
+  if (v < 0 || u + v > 1) return null;
+  const t = dot7(e2, qvec) * invDet;
+  if (t < 0) return null;
+  return { point: add3(origin, scale3(dir, t)), t };
+}
+function rayPlaneIntersect(origin, dir, planePoint, planeNormal) {
+  const denom = dot7(dir, planeNormal);
+  if (Math.abs(denom) < EPS3) return null;
+  const t = dot7(sub(planePoint, origin), planeNormal) / denom;
+  return { point: add3(origin, scale3(dir, t)), t };
+}
+function clamp01(x) {
+  return x < 0 ? 0 : x > 1 ? 1 : x;
+}
+function segmentSegmentClosest(p1, p2, q1, q2) {
+  const d1 = sub(p2, p1);
+  const d2 = sub(q2, q1);
+  const r = sub(p1, q1);
+  const a = dot7(d1, d1);
+  const e = dot7(d2, d2);
+  const f = dot7(d2, r);
+  let s;
+  let t;
+  if (a <= EPS3 && e <= EPS3) {
+    s = 0;
+    t = 0;
+  } else if (a <= EPS3) {
+    s = 0;
+    t = clamp01(f / e);
+  } else {
+    const c = dot7(d1, r);
+    if (e <= EPS3) {
+      t = 0;
+      s = clamp01(-c / a);
+    } else {
+      const b = dot7(d1, d2);
+      const denom = a * e - b * b;
+      s = denom !== 0 ? clamp01((b * f - c * e) / denom) : 0;
+      t = (b * s + f) / e;
+      if (t < 0) {
+        t = 0;
+        s = clamp01(-c / a);
+      } else if (t > 1) {
+        t = 1;
+        s = clamp01((b - c) / a);
+      }
+    }
+  }
+  const point1 = add3(p1, scale3(d1, s));
+  const point2 = add3(q1, scale3(d2, t));
+  const distance2 = Math.sqrt(dot7(sub(point1, point2), sub(point1, point2)));
+  return { point1, point2, distance: distance2 };
+}
+
 // src/stats/inference-extra2.ts
 var TWO_PI = 2 * Math.PI;
 function noncentralChi2CDF(x, df, nc) {
@@ -50128,22 +50481,22 @@ function noncentralTCDF(t, df, nc) {
 }
 function circularSums(angles, opts) {
   const { high = TWO_PI, low = 0 } = opts;
-  const scale3 = TWO_PI / (high - low);
+  const scale4 = TWO_PI / (high - low);
   let sinSum = 0;
   let cosSum = 0;
   for (const a of angles) {
-    const theta = (a - low) * scale3;
+    const theta = (a - low) * scale4;
     sinSum += Math.sin(theta);
     cosSum += Math.cos(theta);
   }
-  return { sinSum, cosSum, scale: scale3 };
+  return { sinSum, cosSum, scale: scale4 };
 }
 function circmean(angles, opts = {}) {
   const { low = 0 } = opts;
-  const { sinSum, cosSum, scale: scale3 } = circularSums(angles, opts);
+  const { sinSum, cosSum, scale: scale4 } = circularSums(angles, opts);
   let mean7 = Math.atan2(sinSum, cosSum);
   if (mean7 < 0) mean7 += TWO_PI;
-  return mean7 / scale3 + low;
+  return mean7 / scale4 + low;
 }
 function circvar(angles, opts = {}) {
   const n = angles.length;
@@ -50675,10 +51028,10 @@ function hungarian(cost) {
 }
 
 // src/numeric/interval.ts
-var EPS3 = Number.EPSILON;
+var EPS4 = Number.EPSILON;
 function outward(lo, hi) {
-  const loOut = lo - Math.abs(lo) * EPS3 - Number.MIN_VALUE;
-  const hiOut = hi + Math.abs(hi) * EPS3 + Number.MIN_VALUE;
+  const loOut = lo - Math.abs(lo) * EPS4 - Number.MIN_VALUE;
+  const hiOut = hi + Math.abs(hi) * EPS4 + Number.MIN_VALUE;
   return new Interval(loOut, hiOut);
 }
 var Interval = class {
@@ -50813,6 +51166,270 @@ var Interval = class {
 function interval(lo, hi) {
   return new Interval(lo, hi);
 }
+
+// src/graph/community-coloring.ts
+function _edgeExists(adj, i, j) {
+  const w = adj[i][j];
+  return Number.isFinite(w) && w !== 0;
+}
+function _undirectedEdgeExists(adj, i, j) {
+  return _edgeExists(adj, i, j) || _edgeExists(adj, j, i);
+}
+function graphColoring(adj) {
+  const n = adj.length;
+  const colors = new Array(n).fill(-1);
+  if (n === 0) return colors;
+  const degree2 = new Array(n).fill(0);
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < n; j++) {
+      if (i !== j && _undirectedEdgeExists(adj, i, j)) degree2[i]++;
+    }
+  }
+  const order = Array.from({ length: n }, (_, i) => i).sort(
+    (a, b) => degree2[b] - degree2[a] || a - b
+  );
+  for (const v of order) {
+    const usedByNeighbor = /* @__PURE__ */ new Set();
+    for (let u = 0; u < n; u++) {
+      if (u !== v && _undirectedEdgeExists(adj, v, u) && colors[u] !== -1) {
+        usedByNeighbor.add(colors[u]);
+      }
+    }
+    let c = 0;
+    while (usedByNeighbor.has(c)) c++;
+    colors[v] = c;
+  }
+  return colors;
+}
+function maxClique(adj) {
+  const n = adj.length;
+  if (n === 0) return [];
+  const hasEdge = (i, j) => i !== j && _undirectedEdgeExists(adj, i, j);
+  let best = [];
+  function bronKerbosch(R, P2, X) {
+    if (P2.size === 0 && X.size === 0) {
+      if (R.length > best.length) best = R.slice();
+      return;
+    }
+    let pivot = -1;
+    let pivotCount = -1;
+    for (const u of [...P2, ...X]) {
+      let cnt = 0;
+      for (const w of P2) if (hasEdge(u, w)) cnt++;
+      if (cnt > pivotCount) {
+        pivotCount = cnt;
+        pivot = u;
+      }
+    }
+    const candidates = pivot === -1 ? [...P2] : [...P2].filter((v) => !hasEdge(pivot, v));
+    for (const v of candidates) {
+      const newP = /* @__PURE__ */ new Set();
+      const newX = /* @__PURE__ */ new Set();
+      for (const w of P2) if (hasEdge(v, w)) newP.add(w);
+      for (const w of X) if (hasEdge(v, w)) newX.add(w);
+      bronKerbosch([...R, v], newP, newX);
+      P2.delete(v);
+      X.add(v);
+    }
+  }
+  const initialP = new Set(Array.from({ length: n }, (_, i) => i));
+  bronKerbosch([], initialP, /* @__PURE__ */ new Set());
+  return best.sort((a, b) => a - b);
+}
+function _louvainLocalMoving(W) {
+  const n = W.length;
+  const kDeg = new Array(n).fill(0);
+  for (let i = 0; i < n; i++) {
+    let s = 0;
+    for (let j = 0; j < n; j++) s += W[i][j];
+    kDeg[i] = s;
+  }
+  const m2 = kDeg.reduce((a, b) => a + b, 0);
+  const m = m2 / 2;
+  const community = Array.from({ length: n }, (_, i) => i);
+  const sigmaTot = kDeg.slice();
+  if (m === 0) return community;
+  let improved = true;
+  while (improved) {
+    improved = false;
+    for (let i = 0; i < n; i++) {
+      const ci = community[i];
+      sigmaTot[ci] -= kDeg[i];
+      const neighborWeight = /* @__PURE__ */ new Map();
+      for (let j = 0; j < n; j++) {
+        if (j === i) continue;
+        const w = W[i][j];
+        if (w > 0) {
+          const cj = community[j];
+          neighborWeight.set(cj, (neighborWeight.get(cj) ?? 0) + w);
+        }
+      }
+      const candidates = new Set(neighborWeight.keys());
+      candidates.add(ci);
+      const sortedCandidates = [...candidates].sort((a, b) => a - b);
+      let bestC = ci;
+      let bestGain = (neighborWeight.get(ci) ?? 0) / m - kDeg[i] * sigmaTot[ci] / (2 * m * m);
+      for (const c of sortedCandidates) {
+        if (c === ci) continue;
+        const gain = (neighborWeight.get(c) ?? 0) / m - kDeg[i] * sigmaTot[c] / (2 * m * m);
+        if (gain > bestGain + 1e-12) {
+          bestGain = gain;
+          bestC = c;
+        }
+      }
+      community[i] = bestC;
+      sigmaTot[bestC] += kDeg[i];
+      if (bestC !== ci) improved = true;
+    }
+  }
+  return community;
+}
+function _louvainAggregate(W, community) {
+  const distinct = [...new Set(community)].sort((a, b) => a - b);
+  const remap = new Map(distinct.map((c, idx) => [c, idx]));
+  const k = distinct.length;
+  const n = W.length;
+  const newW = Array.from({ length: k }, () => new Array(k).fill(0));
+  for (let i = 0; i < n; i++) {
+    const ci = remap.get(community[i]);
+    for (let j = 0; j < n; j++) {
+      const cj = remap.get(community[j]);
+      newW[ci][cj] += W[i][j];
+    }
+  }
+  return { newW, remap };
+}
+function louvainCommunities(adj) {
+  const n = adj.length;
+  if (n === 0) return [];
+  if (n === 1) return [[0]];
+  let curW = adj.map((row2) => row2.slice());
+  let membership = Array.from({ length: n }, (_, i) => i);
+  for (; ; ) {
+    const community = _louvainLocalMoving(curW);
+    const isIdentity = community.every((c, i) => c === i);
+    if (isIdentity) break;
+    const { newW, remap } = _louvainAggregate(curW, community);
+    membership = membership.map((c) => remap.get(community[c]));
+    curW = newW;
+    if (curW.length === 1) break;
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n; i++) {
+    const c = membership[i];
+    const group = groups.get(c);
+    if (group) group.push(i);
+    else groups.set(c, [i]);
+  }
+  return [...groups.entries()].sort((a, b) => a[0] - b[0]).map(([, group]) => group);
+}
+function _solveLinearSystem(A, b) {
+  const n = A.length;
+  const M = A.map((row2, i) => [...row2, b[i]]);
+  for (let col = 0; col < n; col++) {
+    let pivotRow = col;
+    let maxVal = Math.abs(M[col][col]);
+    for (let r = col + 1; r < n; r++) {
+      if (Math.abs(M[r][col]) > maxVal) {
+        maxVal = Math.abs(M[r][col]);
+        pivotRow = r;
+      }
+    }
+    if (maxVal < 1e-14) {
+      throw new Error(
+        "katzCentrality: singular system \u2014 reduce alpha (must be < 1/largest eigenvalue)"
+      );
+    }
+    if (pivotRow !== col) {
+      const tmp = M[col];
+      M[col] = M[pivotRow];
+      M[pivotRow] = tmp;
+    }
+    const pivotVal = M[col][col];
+    for (let j = col; j <= n; j++) M[col][j] /= pivotVal;
+    for (let r = 0; r < n; r++) {
+      if (r === col) continue;
+      const factor2 = M[r][col];
+      if (factor2 === 0) continue;
+      for (let j = col; j <= n; j++) M[r][j] -= factor2 * M[col][j];
+    }
+  }
+  return M.map((row2) => row2[n]);
+}
+function katzCentrality(adj, alpha, beta2 = 1) {
+  const n = adj.length;
+  if (n === 0) return [];
+  const M = Array.from(
+    { length: n },
+    (_, i) => Array.from({ length: n }, (_2, j) => (i === j ? 1 : 0) - alpha * adj[j][i])
+  );
+  const b = new Array(n).fill(beta2);
+  const x = _solveLinearSystem(M, b);
+  let sum3 = 0;
+  let sumSq = 0;
+  for (const xi of x) {
+    sum3 += xi;
+    sumSq += xi * xi;
+  }
+  const norm4 = Math.sign(sum3) * Math.sqrt(sumSq);
+  if (norm4 === 0) return x;
+  return x.map((xi) => xi / norm4);
+}
+function isIsomorphic(graphA, graphB) {
+  const n = graphA.length;
+  if (graphB.length !== n) return false;
+  if (n === 0) return true;
+  const degreeSequence = (adj) => {
+    const size2 = adj.length;
+    const seq = [];
+    for (let i = 0; i < size2; i++) {
+      let outDeg = 0;
+      let inDeg = 0;
+      for (let j = 0; j < size2; j++) {
+        if (_edgeExists(adj, i, j)) outDeg++;
+        if (_edgeExists(adj, j, i)) inDeg++;
+      }
+      seq.push(outDeg * (size2 + 1) + inDeg);
+    }
+    return seq.sort((a, b) => a - b);
+  };
+  const degA = degreeSequence(graphA);
+  const degB = degreeSequence(graphB);
+  for (let i = 0; i < n; i++) {
+    if (degA[i] !== degB[i]) return false;
+  }
+  const mapAtoB = new Array(n).fill(-1);
+  const usedB = new Array(n).fill(false);
+  const order = Array.from({ length: n }, (_, i) => i);
+  function backtrack(pos) {
+    if (pos === n) return true;
+    const a = order[pos];
+    for (let b = 0; b < n; b++) {
+      if (usedB[b]) continue;
+      let consistent = true;
+      for (let k = 0; k < pos; k++) {
+        const a2 = order[k];
+        const b2 = mapAtoB[a2];
+        if (_edgeExists(graphA, a, a2) !== _edgeExists(graphB, b, b2)) {
+          consistent = false;
+          break;
+        }
+        if (_edgeExists(graphA, a2, a) !== _edgeExists(graphB, b2, b)) {
+          consistent = false;
+          break;
+        }
+      }
+      if (!consistent) continue;
+      mapAtoB[a] = b;
+      usedB[b] = true;
+      if (backtrack(pos + 1)) return true;
+      usedB[b] = false;
+      mapAtoB[a] = -1;
+    }
+    return false;
+  }
+  return backtrack(0);
+}
 export {
   ARRAY_WORKER_THRESHOLD,
   CAS_BATCH_THRESHOLD,
@@ -51252,6 +51869,7 @@ export {
   gradientAt,
   gradientDescent,
   gradientSymbolic,
+  graphColoring,
   graphDistance,
   gravitationConstant,
   gravity,
@@ -51318,6 +51936,7 @@ export {
   isGpuChainSupported,
   isGpuEnabled3 as isGpuEnabled,
   isInteger2 as isInteger,
+  isIsomorphic,
   isNaN2 as isNaN,
   isNegative,
   isNumeric,
@@ -51335,6 +51954,7 @@ export {
   jordanForm,
   josephson,
   jsDivergence,
+  katzCentrality,
   kdTree,
   kdTreeKNN,
   kdTreeNearest,
@@ -51399,6 +52019,7 @@ export {
   logisticRegression,
   logsumexp,
   loschmidt,
+  louvainCommunities,
   lowRankApprox,
   lowpassFilter,
   lsolve,
@@ -51430,6 +52051,7 @@ export {
   matrixSqrtm,
   matvec,
   max,
+  maxClique,
   maxFlow,
   maxSelect,
   maximize,
@@ -51597,10 +52219,13 @@ export {
   quantileSeq,
   quantumOfCirculation,
   quaternionConjugate,
+  quaternionExp,
   quaternionFromAxisAngle,
   quaternionInverse,
+  quaternionLog,
   quaternionMultiply,
   quaternionNormalize,
+  quaternionPow,
   quaternionRotate,
   quaternionSlerp,
   quaternionToEuler,
@@ -51613,6 +52238,8 @@ export {
   rank,
   rankdata,
   rationalize,
+  rayPlaneIntersect,
+  rayTriangleIntersect,
   rayleighDist,
   rbfInterpolate,
   re,
@@ -51655,6 +52282,7 @@ export {
   sech,
   secondRadiation,
   seedProbabilityRng,
+  segmentSegmentClosest,
   sem,
   series,
   seriesCoefficient,