@danielsimonjr/mathts-functions 0.39.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 {
@@ -7014,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;
@@ -7037,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;
@@ -7066,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;
@@ -8403,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);
@@ -8528,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]];
@@ -8583,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);
@@ -8596,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);
@@ -8644,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);
@@ -8727,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;
@@ -11899,7 +11899,7 @@ var createSolveODE = /* @__PURE__ */ factory(
   dependencies,
   ({
     typed: typed3,
-    add: add3,
+    add: add4,
     subtract: subtract3,
     multiply: multiply2,
     divide: divide2,
@@ -12118,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;
         }
@@ -12131,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);
@@ -12219,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;
       };
     }
@@ -13508,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];
         }
       }
     }
@@ -14716,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;
     }
@@ -14750,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";
@@ -14809,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;
@@ -15347,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;
@@ -15368,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;
@@ -15378,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;
     })
@@ -16775,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 };
@@ -17304,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;
@@ -17392,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];
       }
     }
   }
@@ -17474,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];
@@ -17549,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;
@@ -17815,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];
@@ -22628,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;
       }
@@ -22674,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;
@@ -22690,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++;
         }
@@ -23782,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));
@@ -23806,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 {
@@ -23833,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) {
@@ -24200,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;
@@ -24496,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;
@@ -24845,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;
@@ -26852,7 +26852,7 @@ var createSubset = /* @__PURE__ */ factory(
     typed: typed3,
     matrix: matrix2,
     zeros: zeros4,
-    add: add3
+    add: add4
   }) => {
     const referTo = typed3.referTo;
     return typed3(name119, {
@@ -26911,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;
         }
@@ -27584,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);
@@ -27629,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]));
           }
         }
       }
@@ -27653,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,
@@ -27694,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;
     }
@@ -27752,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) {
@@ -27778,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);
         }
@@ -27791,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);
@@ -30453,7 +30453,7 @@ var createInvmod = /* @__PURE__ */ factory(
     equal: equal2,
     smaller: smaller2,
     mod: mod3,
-    add: add3,
+    add: add4,
     isInteger: isInteger3
   }) => {
     return typed3(name168, {
@@ -30470,7 +30470,7 @@ var createInvmod = /* @__PURE__ */ factory(
       const [gcd2, invValue] = resVal;
       if (!equal2(gcd2, 1)) return NaN;
       let inv3 = mod3(invValue, b);
-      if (smaller2(inv3, 0)) inv3 = add3(inv3, b);
+      if (smaller2(inv3, 0)) inv3 = add4(inv3, b);
       return inv3;
     }
   }
@@ -30727,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, {
@@ -30743,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);
@@ -30813,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++;
@@ -30822,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))
       );
     }
   }
@@ -31063,7 +31063,7 @@ var createRange = /* @__PURE__ */ factory(
     smallerEq: smallerEq2,
     larger: larger2,
     largerEq: largerEq2,
-    add: add3,
+    add: add4,
     isZero: isZero2,
     isPositive: isPositive2
   }) => {
@@ -31176,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;
     }
@@ -34849,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) {
@@ -34915,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");
@@ -35554,7 +35554,7 @@ var createSlu = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     abs: abs2,
-    add: add3,
+    add: add4,
     multiply: multiply2,
     transpose: transpose5,
     divideScalar: divideScalar2,
@@ -35563,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,
@@ -35868,7 +35868,7 @@ var createIntersect = /* @__PURE__ */ factory(
     typed: typed3,
     config: config2,
     abs: abs2,
-    add: add3,
+    add: add4,
     addScalar: addScalar2,
     matrix: matrix2,
     multiply: multiply2,
@@ -36008,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();
@@ -36124,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,
@@ -36141,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) {
@@ -36169,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);
@@ -36189,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());
@@ -36222,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, {
@@ -36261,7 +36261,7 @@ var createVariance = /* @__PURE__ */ factory(
   dependencies221,
   ({
     typed: typed3,
-    add: add3,
+    add: add4,
     subtract: subtract3,
     multiply: multiply2,
     divide: divide2,
@@ -36310,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);
@@ -36321,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;
@@ -36396,7 +36396,7 @@ var createQuantileSeq = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     bignumber: bignumber2,
-    add: add3,
+    add: add4,
     subtract: subtract3,
     divide: divide2,
     multiply: multiply2,
@@ -36444,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);
@@ -36501,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)
           );
@@ -36599,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;
@@ -36608,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);
@@ -36624,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);
@@ -36718,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])))
           );
@@ -37541,7 +37541,7 @@ var createPolynomialRoot = /* @__PURE__ */ factory(
     typed: typed3,
     isZero: isZero2,
     equalScalar: equalScalar3,
-    add: add3,
+    add: add4,
     subtract: subtract3,
     multiply: multiply2,
     divide: divide2,
@@ -37583,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)
@@ -37599,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
@@ -37612,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)))
                 ),
@@ -37620,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);
@@ -37676,7 +37676,7 @@ var createZeta = /* @__PURE__ */ factory(
     gamma: gamma2,
     sin: sin2,
     subtract: subtract3,
-    add: add3,
+    add: add4,
     Complex: Complex13,
     BigNumber: BigNumber9,
     pi
@@ -37744,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);
     }
@@ -37823,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) {
@@ -38194,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;
@@ -38264,7 +38264,7 @@ function createComplexEigs({
       v = subtract3(
         v,
         multiply2(
-          divideScalar2(dot7(w, v), dot7(w, w)),
+          divideScalar2(dot8(w, v), dot8(w, w)),
           w
         )
       );
@@ -38272,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";
@@ -38306,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;
@@ -38503,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])
@@ -38675,7 +38675,7 @@ var createEigs = /* @__PURE__ */ factory(
     inv: inv3,
     bignumber: bignumber2,
     multiply: multiply2,
-    add: add3,
+    add: add4,
     larger: larger2,
     column: _column,
     flatten: flatten5,
@@ -38692,7 +38692,7 @@ var createEigs = /* @__PURE__ */ factory(
     re: re3,
     smaller: smaller2,
     matrixFromColumns: matrixFromColumns2,
-    dot: dot7
+    dot: dot8
   }) => {
     const doRealSymmetric = createRealSymmetric({
       config: config2,
@@ -38707,7 +38707,7 @@ var createEigs = /* @__PURE__ */ factory(
       bignumber: bignumber2,
       complex: complex3,
       multiply: multiply2,
-      add: add3
+      add: add4
     });
     const doComplexEigs = createComplexEigs({
       addScalar: addScalar2,
@@ -38731,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,
@@ -40733,7 +40733,7 @@ var createNorm = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     abs: abs2,
-    add: add3,
+    add: add4,
     pow: pow2,
     conj: conj3,
     sqrt: sqrt2,
@@ -40838,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);
         }
@@ -40849,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));
     }
@@ -40858,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;
         }
@@ -40882,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;
         }
@@ -41716,7 +41716,7 @@ var createSylvester = /* @__PURE__ */ factory(
     transpose: transpose5,
     index,
     subset: subset2,
-    add: add3,
+    add: add4,
     subtract: subtract3,
     identity: identity2,
     lusolve: lusolve2,
@@ -41764,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))))
             );
@@ -41773,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]));
@@ -41781,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)));
@@ -43589,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}`);
       }
     }
   }
@@ -43620,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;
@@ -46621,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);
@@ -46635,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];
@@ -47837,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);
@@ -47877,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 };
 }
@@ -47891,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 };
 }
@@ -47963,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]);
@@ -48002,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;
@@ -48026,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]);
         }
       }
@@ -48406,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) {
@@ -48424,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) {
@@ -49858,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;
@@ -49884,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");
   });
 }
@@ -50005,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 };
@@ -50195,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;
@@ -50260,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++) {
@@ -50269,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;
@@ -50318,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) {
@@ -50377,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;
@@ -50924,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 {
@@ -51062,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,
@@ -51501,6 +51869,7 @@ export {
   gradientAt,
   gradientDescent,
   gradientSymbolic,
+  graphColoring,
   graphDistance,
   gravitationConstant,
   gravity,
@@ -51567,6 +51936,7 @@ export {
   isGpuChainSupported,
   isGpuEnabled3 as isGpuEnabled,
   isInteger2 as isInteger,
+  isIsomorphic,
   isNaN2 as isNaN,
   isNegative,
   isNumeric,
@@ -51584,6 +51954,7 @@ export {
   jordanForm,
   josephson,
   jsDivergence,
+  katzCentrality,
   kdTree,
   kdTreeKNN,
   kdTreeNearest,
@@ -51648,6 +52019,7 @@ export {
   logisticRegression,
   logsumexp,
   loschmidt,
+  louvainCommunities,
   lowRankApprox,
   lowpassFilter,
   lsolve,
@@ -51679,6 +52051,7 @@ export {
   matrixSqrtm,
   matvec,
   max,
+  maxClique,
   maxFlow,
   maxSelect,
   maximize,
@@ -51846,10 +52219,13 @@ export {
   quantileSeq,
   quantumOfCirculation,
   quaternionConjugate,
+  quaternionExp,
   quaternionFromAxisAngle,
   quaternionInverse,
+  quaternionLog,
   quaternionMultiply,
   quaternionNormalize,
+  quaternionPow,
   quaternionRotate,
   quaternionSlerp,
   quaternionToEuler,
@@ -51862,6 +52238,8 @@ export {
   rank,
   rankdata,
   rationalize,
+  rayPlaneIntersect,
+  rayTriangleIntersect,
   rayleighDist,
   rbfInterpolate,
   re,
@@ -51904,6 +52282,7 @@ export {
   sech,
   secondRadiation,
   seedProbabilityRng,
+  segmentSegmentClosest,
   sem,
   series,
   seriesCoefficient,