@danielsimonjr/mathts-functions 0.62.0 → 0.64.0

package/dist/index.js

@@ -4366,7 +4366,7 @@ function dwt(x, wavelet = "haar") {
     try {
       return dwtPeriodization(x, wavelet);
     } catch (err) {
-      throw new Error(`dwt: ${err instanceof Error ? err.message : String(err)}`);
+      throw new Error(`dwt: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
     }
   }
 }
@@ -6548,7 +6548,7 @@ function betaincScalar(a, b, x) {
   }
   const lnBeta = _lgamma(a) + _lgamma(b) - _lgamma(a + b);
   const front = Math.exp(Math.log(x) * a + Math.log(1 - x) * b - lnBeta) / a;
-  let f = 1;
+  let f;
   let c = 1;
   let d = 1 - (a + b) * x / (a + 1);
   if (Math.abs(d) < 1e-30) d = 1e-30;
@@ -6806,9 +6806,9 @@ function _carlsonRJ(x, y, z, p) {
     const sy = Math.sqrt(yy);
     const sz = Math.sqrt(zz);
     const lam = sx * sy + sy * sz + sz * sx;
-    const alpha = pp * (sx + sy + sz) + sx * sy * sz;
-    const beta2 = pp * (pp + lam) * (pp + lam);
-    sum3 += fac * _carlsonRC(alpha * alpha, beta2);
+    const alpha2 = pp * (sx + sy + sz) + sx * sy * sz;
+    const beta3 = pp * (pp + lam) * (pp + lam);
+    sum3 += fac * _carlsonRC(alpha2 * alpha2, beta3);
     fac /= 4;
     xx = (xx + lam) / 4;
     yy = (yy + lam) / 4;
@@ -8420,19 +8420,19 @@ var jsDivergence = mathTyped11("jsDivergence", {
     return jsd;
   }
 });
-function betaPDFScalar(x, alpha, beta_) {
-  if (alpha <= 0 || beta_ <= 0) return NaN;
+function betaPDFScalar(x, alpha2, beta_) {
+  if (alpha2 <= 0 || beta_ <= 0) return NaN;
   if (x <= 0 || x >= 1) return 0;
-  const logB = _lgammaD(alpha) + _lgammaD(beta_) - _lgammaD(alpha + beta_);
-  return Math.exp((alpha - 1) * Math.log(x) + (beta_ - 1) * Math.log(1 - x) - logB);
+  const logB = _lgammaD(alpha2) + _lgammaD(beta_) - _lgammaD(alpha2 + beta_);
+  return Math.exp((alpha2 - 1) * Math.log(x) + (beta_ - 1) * Math.log(1 - x) - logB);
 }
 var betaPDF = mathTyped11("betaPDF", {
-  "number, number, number": (x, alpha, beta_) => betaPDFScalar(x, alpha, beta_),
-  "Float64Array, number, number": (x, alpha, beta_) => {
+  "number, number, number": (x, alpha2, beta_) => betaPDFScalar(x, alpha2, beta_),
+  "Float64Array, number, number": (x, alpha2, beta_) => {
     const out = new Float64Array(x.length);
-    const lgAlpha = _lgammaD(alpha);
+    const lgAlpha = _lgammaD(alpha2);
     const lgBeta = _lgammaD(beta_);
-    const lgAlphaBeta = _lgammaD(alpha + beta_);
+    const lgAlphaBeta = _lgammaD(alpha2 + beta_);
     const logB = lgAlpha + lgBeta - lgAlphaBeta;
     if (x.length >= WASM_SPECIAL_THRESHOLD) {
       for (let i = 0; i < x.length; i++) {
@@ -8440,13 +8440,13 @@ var betaPDF = mathTyped11("betaPDF", {
         if (xi <= 0 || xi >= 1) {
           out[i] = 0;
         } else {
-          out[i] = Math.exp((alpha - 1) * Math.log(xi) + (beta_ - 1) * Math.log(1 - xi) - logB);
+          out[i] = Math.exp((alpha2 - 1) * Math.log(xi) + (beta_ - 1) * Math.log(1 - xi) - logB);
         }
       }
       return Promise.resolve(out);
     }
     for (let i = 0; i < x.length; i++) {
-      out[i] = betaPDFScalar(x[i], alpha, beta_);
+      out[i] = betaPDFScalar(x[i], alpha2, beta_);
     }
     return Promise.resolve(out);
   }
@@ -9609,13 +9609,23 @@ function normalize(p) {
     if (existing) existing.coeff += t.coeff;
     else byKey.set(key2, { coeff: t.coeff, powers: [...t.powers] });
   }
-  return [...byKey.values()].filter((t) => Math.abs(t.coeff) > EPS).sort((a, b) => cmpPowers(b.powers, a.powers));
+  const out = [];
+  for (const t of byKey.values()) {
+    if (Math.abs(t.coeff) > EPS) {
+      out.push(t);
+    }
+  }
+  return out.sort((a, b) => cmpPowers(b.powers, a.powers));
 }
 function polyAdd(a, b) {
   return normalize([...a, ...b]);
 }
 function polyNeg(a) {
-  return a.map((t) => ({ coeff: -t.coeff, powers: [...t.powers] }));
+  const out = [];
+  for (let i = 0; i < a.length; i++) {
+    out.push({ coeff: -a[i].coeff, powers: [...a[i].powers] });
+  }
+  return out;
 }
 function polySub(a, b) {
   return polyAdd(a, polyNeg(b));
@@ -9624,9 +9634,13 @@ function polyMul(a, b) {
   const out = [];
   for (const ta of a) {
     for (const tb of b) {
+      const powers = new Array(ta.powers.length);
+      for (let i = 0; i < ta.powers.length; i++) {
+        powers[i] = ta.powers[i] + tb.powers[i];
+      }
       out.push({
         coeff: ta.coeff * tb.coeff,
-        powers: ta.powers.map((p, i) => p + tb.powers[i])
+        powers
       });
     }
   }
@@ -9639,12 +9653,24 @@ function polyPow(a, n, nVars) {
 }
 function polyFromExpression(expr, vars) {
   const nVars = vars.length;
-  const varIndex = new Map(vars.map((v, i) => [v, i]));
+  const varIndex = /* @__PURE__ */ new Map();
+  for (let i = 0; i < vars.length; i++) {
+    varIndex.set(vars[i], i);
+  }
   let pos = 0;
   const constPoly = (v) => normalize([{ coeff: v, powers: new Array(nVars).fill(0) }]);
   function constOf(p) {
     if (p.length === 0) return 0;
-    if (p.length === 1 && p[0].powers.every((x) => x === 0)) return p[0].coeff;
+    if (p.length === 1) {
+      let isConst2 = true;
+      for (let i = 0; i < p[0].powers.length; i++) {
+        if (p[0].powers[i] !== 0) {
+          isConst2 = false;
+          break;
+        }
+      }
+      if (isConst2) return p[0].coeff;
+    }
     return null;
   }
   const skipWs = () => {
@@ -9727,7 +9753,11 @@ function polyFromExpression(expr, vars) {
         if (denom === null || Math.abs(denom) <= EPS) {
           return fail("division only by a nonzero numeric constant");
         }
-        p = normalize(p.map((t) => ({ coeff: t.coeff / denom, powers: t.powers })));
+        const nextP = [];
+        for (let i = 0; i < p.length; i++) {
+          nextP.push({ coeff: p[i].coeff / denom, powers: p[i].powers });
+        }
+        p = normalize(nextP);
       } else {
         break;
       }
@@ -9806,10 +9836,14 @@ function polyReduce(p, G) {
     const lt = work[0];
     const g = index.find(lt.powers);
     if (g) {
+      const powers = new Array(lt.powers.length);
+      for (let i = 0; i < lt.powers.length; i++) {
+        powers[i] = lt.powers[i] - g[0].powers[i];
+      }
       const factor2 = [
         {
           coeff: lt.coeff / g[0].coeff,
-          powers: lt.powers.map((x, i) => x - g[0].powers[i])
+          powers
         }
       ];
       work = polySub(work, polyMul(factor2, g));
@@ -9821,21 +9855,42 @@ function polyReduce(p, G) {
   return normalize(rem);
 }
 function lcmPowers(a, b) {
-  return a.map((x, i) => Math.max(x, b[i]));
+  const len = a.length;
+  const out = new Array(len);
+  for (let i = 0; i < len; i++) {
+    out[i] = Math.max(a[i], b[i]);
+  }
+  return out;
 }
 function sPoly(f, g) {
   const l = lcmPowers(f[0].powers, g[0].powers);
-  const mf = [{ coeff: 1 / f[0].coeff, powers: l.map((x, i) => x - f[0].powers[i]) }];
-  const mg = [{ coeff: 1 / g[0].coeff, powers: l.map((x, i) => x - g[0].powers[i]) }];
+  const mfPowers = new Array(l.length);
+  const mgPowers = new Array(l.length);
+  for (let i = 0; i < l.length; i++) {
+    mfPowers[i] = l[i] - f[0].powers[i];
+    mgPowers[i] = l[i] - g[0].powers[i];
+  }
+  const mf = [{ coeff: 1 / f[0].coeff, powers: mfPowers }];
+  const mg = [{ coeff: 1 / g[0].coeff, powers: mgPowers }];
   return polySub(polyMul(mf, f), polyMul(mg, g));
 }
 function monic(p) {
   if (p.length === 0) return p;
   const c = p[0].coeff;
-  return p.map((t) => ({ coeff: t.coeff / c, powers: [...t.powers] }));
+  const out = [];
+  for (let i = 0; i < p.length; i++) {
+    out.push({ coeff: p[i].coeff / c, powers: [...p[i].powers] });
+  }
+  return out;
 }
 function buchberger(input) {
-  let G = input.map(normalize).filter((p) => p.length > 0).map(monic);
+  let G = [];
+  for (let i = 0; i < input.length; i++) {
+    const p = normalize(input[i]);
+    if (p.length > 0) {
+      G.push(monic(p));
+    }
+  }
   if (G.length === 0) return [];
   const pairs = [];
   for (let i = 0; i < G.length; i++) {
@@ -9857,19 +9912,31 @@ function buchberger(input) {
       for (let t = 0; t < k; t++) pairs.push([t, k]);
     }
   }
-  G = G.filter(
-    (g, i) => !G.some(
-      (h, j) => j !== i && h.length > 0 && divides(h[0].powers, g[0].powers) && (cmpPowers(h[0].powers, g[0].powers) !== 0 || j < i)
-    )
-  );
-  G = G.map(
-    (g, i) => monic(
-      polyReduce(
-        g,
-        G.filter((_, j) => j !== i)
-      )
-    )
-  ).filter((g) => g.length > 0);
+  const minimalG = [];
+  for (let i = 0; i < G.length; i++) {
+    const g = G[i];
+    let isDivisible = false;
+    for (let j = 0; j < G.length; j++) {
+      if (i === j) continue;
+      const h = G[j];
+      if (h.length > 0 && divides(h[0].powers, g[0].powers) && (cmpPowers(h[0].powers, g[0].powers) !== 0 || j < i)) {
+        isDivisible = true;
+        break;
+      }
+    }
+    if (!isDivisible) minimalG.push(g);
+  }
+  G = minimalG;
+  const reducedG = [];
+  for (let i = 0; i < G.length; i++) {
+    const others = [];
+    for (let j = 0; j < G.length; j++) {
+      if (i !== j) others.push(G[j]);
+    }
+    const reduced = monic(polyReduce(G[i], others));
+    if (reduced.length > 0) reducedG.push(reduced);
+  }
+  G = reducedG;
   G.sort((a, b) => cmpPowers(b[0].powers, a[0].powers));
   return G;
 }
@@ -9879,10 +9946,18 @@ function polyToString(p, vars) {
     const r = Math.round(c);
     return Math.abs(c - r) < 1e-9 ? String(r) : String(Number(c.toPrecision(12)));
   };
-  const terms = [...p].reverse().map((t) => {
-    const varPart = t.powers.map((e, i) => e === 0 ? "" : e === 1 ? vars[i] : `${vars[i]}^${e}`).filter(Boolean).join("*");
-    return varPart ? `${fmt(t.coeff)}*${varPart}` : fmt(t.coeff);
-  });
+  const terms = [];
+  for (let i = p.length - 1; i >= 0; i--) {
+    const t = p[i];
+    const parts = [];
+    for (let j = 0; j < t.powers.length; j++) {
+      const e = t.powers[j];
+      if (e === 1) parts.push(vars[j]);
+      else if (e > 1) parts.push(`${vars[j]}^${e}`);
+    }
+    const varPart = parts.join("*");
+    terms.push(varPart ? `${fmt(t.coeff)}*${varPart}` : fmt(t.coeff));
+  }
   return terms.join(" + ").replace(/\+ -/g, "- ");
 }
 
@@ -12574,7 +12649,7 @@ function linearInterp(xs, ys, x) {
   if (xs.length !== ys.length || xs.length < 2) {
     throw new Error("linearInterp requires at least 2 data points with matching lengths");
   }
-  let i = 0;
+  let i;
   if (x <= xs[0]) {
     i = 0;
   } else if (x >= xs[xs.length - 1]) {
@@ -12761,7 +12836,7 @@ function pchipInterp(xs, ys, x) {
       delta[n - 3]
     );
   }
-  let i = 0;
+  let i;
   if (x <= xs[0]) {
     i = 0;
   } else if (x >= xs[n - 1]) {
@@ -13738,7 +13813,7 @@ function bdfSolve(f, tspan, y0raw, options = {}) {
     const F0 = _fArr(f, t, y);
     const J = _jacobianAt(f, t, y, F0, options);
     let stepAccepted = false;
-    let yNew = y;
+    let yNew;
     let dVec = new Array(n).fill(0);
     let errorNorm = 0;
     let nIter = 1;
@@ -15142,7 +15217,7 @@ function minimize(f, x0, opts) {
   const maxIter = opts?.maxIter ?? 1e3;
   const step = opts?.step ?? 0.1;
   const n = x0.length;
-  const alpha = 1;
+  const alpha2 = 1;
   const gamma2 = 2;
   const rho = 0.5;
   const sigma = 0.5;
@@ -15174,7 +15249,7 @@ function minimize(f, x0, opts) {
       }
     }
     for (let j = 0; j < n; j++) centroid2[j] /= n;
-    const xr = centroid2.map((c, j) => c + alpha * (c - simplex[n][j]));
+    const xr = centroid2.map((c, j) => c + alpha2 * (c - simplex[n][j]));
     const fr = f(xr);
     if (fr < fValues[n - 1] && fr >= fValues[0]) {
       simplex[n] = xr;
@@ -15307,9 +15382,9 @@ function interpolate(xs, ys, method = "linear") {
       const n = xs.length - 1;
       const h = [];
       for (let i = 0; i < n; i++) h[i] = xs[i + 1] - xs[i];
-      const alpha = [0];
+      const alpha2 = [0];
       for (let i = 1; i < n; i++) {
-        alpha[i] = 3 / h[i] * (ys[i + 1] - ys[i]) - 3 / h[i - 1] * (ys[i] - ys[i - 1]);
+        alpha2[i] = 3 / h[i] * (ys[i + 1] - ys[i]) - 3 / h[i - 1] * (ys[i] - ys[i - 1]);
       }
       const l = [1];
       const mu = [0];
@@ -15317,7 +15392,7 @@ function interpolate(xs, ys, method = "linear") {
       for (let i = 1; i < n; i++) {
         l[i] = 2 * (xs[i + 1] - xs[i - 1]) - h[i - 1] * mu[i - 1];
         mu[i] = h[i] / l[i];
-        z[i] = (alpha[i] - h[i - 1] * z[i - 1]) / l[i];
+        z[i] = (alpha2[i] - h[i - 1] * z[i - 1]) / l[i];
       }
       const c = new Array(n + 1).fill(0);
       const bArr = new Array(n);
@@ -15333,7 +15408,6 @@ function interpolate(xs, ys, method = "linear") {
         if (x <= xs[0]) j = 0;
         else if (x >= xs[n]) j = n - 1;
         else {
-          j = 0;
           for (j = 0; j < n; j++) {
             if (x >= xs[j] && x <= xs[j + 1]) break;
           }
@@ -15345,7 +15419,7 @@ function interpolate(xs, ys, method = "linear") {
     case "linear":
     default:
       return (x) => {
-        let i = 0;
+        let i;
         if (x <= xs[0]) i = 0;
         else if (x >= xs[xs.length - 1]) i = xs.length - 2;
         else {
@@ -15385,7 +15459,7 @@ function pchip(xs, ys, x) {
     m[0] = delta[0];
     m[n - 1] = delta[n - 2];
   }
-  let idx = 0;
+  let idx;
   if (x <= xs[0]) idx = 0;
   else if (x >= xs[n - 1]) idx = n - 2;
   else {
@@ -15462,9 +15536,9 @@ function bspline(controlPoints, degree3, t) {
   for (let r = 1; r <= p; r++) {
     for (let j = p; j >= r; j--) {
       const idx = k - p + j;
-      const alpha = (tClamped - knots[idx]) / (knots[idx + p - r + 1] - knots[idx]);
+      const alpha2 = (tClamped - knots[idx]) / (knots[idx + p - r + 1] - knots[idx]);
       for (let dd = 0; dd < dim; dd++) {
-        d[j][dd] = (1 - alpha) * d[j - 1][dd] + alpha * d[j][dd];
+        d[j][dd] = (1 - alpha2) * d[j - 1][dd] + alpha2 * d[j][dd];
       }
     }
   }
@@ -16662,11 +16736,11 @@ function linprog(c, arg22, arg3) {
   return linprogTwoPhase(c, arg22);
 }
 function solvePDE(pde, domain, bc) {
-  const { alpha } = pde;
+  const { alpha: alpha2 } = pde;
   const { L, nx, nt, T } = domain;
   const dx = L / (nx - 1);
   const dt = T / nt;
-  const r = alpha * dt / (dx * dx);
+  const r = alpha2 * dt / (dx * dx);
   if (r > 0.5) {
   }
   const x = [];
@@ -17511,6 +17585,8 @@ function _betweennessOnce(adj, directed, normalise, seed) {
     if (denom > 0) {
       for (let i = 0; i < n; i++) cb[i] /= denom;
     }
+  } else if (!directed) {
+    for (let i = 0; i < n; i++) cb[i] /= 2;
   }
   return cb;
 }
@@ -17674,11 +17750,11 @@ function normalSampleRng(rng) {
   const u2 = rng();
   return Math.sqrt(-2 * Math.log(u1 < 1e-300 ? 1e-300 : u1)) * Math.cos(2 * Math.PI * u2);
 }
-function gammaSampleRng(alpha, rng) {
-  if (alpha < 1) {
-    return gammaSampleRng(alpha + 1, rng) * Math.pow(rng(), 1 / alpha);
+function gammaSampleRng(alpha2, rng) {
+  if (alpha2 < 1) {
+    return gammaSampleRng(alpha2 + 1, rng) * Math.pow(rng(), 1 / alpha2);
   }
-  const d = alpha - 1 / 3;
+  const d = alpha2 - 1 / 3;
   const c = 1 / Math.sqrt(9 * d);
   for (; ; ) {
     let x;
@@ -17894,28 +17970,28 @@ function normalDist(mu = 0, sigma = 1) {
     })
   };
 }
-function betaDist(alpha, beta_) {
-  if (alpha <= 0 || beta_ <= 0) throw new Error("betaDist: alpha and beta must be positive");
-  const B = _gamma(alpha) * _gamma(beta_) / _gamma(alpha + beta_);
+function betaDist(alpha2, beta_) {
+  if (alpha2 <= 0 || beta_ <= 0) throw new Error("betaDist: alpha and beta must be positive");
+  const B = _gamma(alpha2) * _gamma(beta_) / _gamma(alpha2 + beta_);
   return {
     pdf: (x) => {
       if (x < 0 || x > 1) return 0;
-      if (x === 0 && alpha < 1) return Infinity;
+      if (x === 0 && alpha2 < 1) return Infinity;
       if (x === 1 && beta_ < 1) return Infinity;
-      return Math.pow(x, alpha - 1) * Math.pow(1 - x, beta_ - 1) / B;
+      return Math.pow(x, alpha2 - 1) * Math.pow(1 - x, beta_ - 1) / B;
     },
     cdf: (x) => {
       if (x <= 0) return 0;
       if (x >= 1) return 1;
-      return _betainc(x, alpha, beta_);
+      return _betainc(x, alpha2, beta_);
     },
     quantile: (p) => {
       if (p <= 0) return 0;
       if (p >= 1) return 1;
-      let x = alpha / (alpha + beta_);
+      let x = alpha2 / (alpha2 + beta_);
       for (let i = 0; i < 100; i++) {
-        const fx = _betainc(x, alpha, beta_) - p;
-        const dx = Math.pow(x, alpha - 1) * Math.pow(1 - x, beta_ - 1) / B;
+        const fx = _betainc(x, alpha2, beta_) - p;
+        const dx = Math.pow(x, alpha2 - 1) * Math.pow(1 - x, beta_ - 1) / B;
         if (dx === 0) break;
         const step = fx / dx;
         x = Math.max(1e-15, Math.min(1 - 1e-15, x - step));
@@ -17923,17 +17999,17 @@ function betaDist(alpha, beta_) {
       }
       return x;
     },
-    mean: alpha / (alpha + beta_),
-    variance: alpha * beta_ / ((alpha + beta_) ** 2 * (alpha + beta_ + 1)),
+    mean: alpha2 / (alpha2 + beta_),
+    variance: alpha2 * beta_ / ((alpha2 + beta_) ** 2 * (alpha2 + beta_ + 1)),
     sample: () => {
-      const ga = _gammaRandom(alpha);
+      const ga = _gammaRandom(alpha2);
       const gb = _gammaRandom(beta_);
       return ga / (ga + gb);
     },
-    sampleN: (n, opts) => _sampleNDispatch("beta", [alpha, beta_], n, opts, (count2, rng) => {
+    sampleN: (n, opts) => _sampleNDispatch("beta", [alpha2, beta_], n, opts, (count2, rng) => {
       const out = new Float64Array(count2);
       for (let i = 0; i < count2; i++) {
-        const ga = _gammaRandomRng(alpha, rng);
+        const ga = _gammaRandomRng(alpha2, rng);
         const gb = _gammaRandomRng(beta_, rng);
         out[i] = ga / (ga + gb);
       }
@@ -17941,14 +18017,14 @@ function betaDist(alpha, beta_) {
     })
   };
 }
-function _gammaRandom(alpha) {
-  return gammaSampleRng(alpha, Math.random);
+function _gammaRandom(alpha2) {
+  return gammaSampleRng(alpha2, Math.random);
 }
 function _normalRandom() {
   return normalSampleRng(Math.random);
 }
-function _gammaRandomRng(alpha, rng) {
-  return gammaSampleRng(alpha, rng);
+function _gammaRandomRng(alpha2, rng) {
+  return gammaSampleRng(alpha2, rng);
 }
 function binomialDist(n, p) {
   if (!Number.isInteger(n) || n < 0)
@@ -18098,7 +18174,7 @@ function fDist(d1, d2) {
     quantile: (p) => {
       if (p <= 0) return 0;
       if (p >= 1) return Infinity;
-      let x = d1 > 2 ? d2 * (d1 - 2) / (d1 * (d2 + 2)) : 1;
+      let x;
       let lo = 0;
       let hi = 1e3;
       for (let i = 0; i < 100; i++) {
@@ -18563,18 +18639,18 @@ function discreteUniformDist(lo, hi) {
     })
   };
 }
-function gumbelDist(mu, beta2) {
-  if (beta2 <= 0) throw new Error("gumbelDist: scale beta must be positive");
-  const quantile = (p) => p <= 0 ? -Infinity : p >= 1 ? Infinity : mu - beta2 * Math.log(-Math.log(p));
+function gumbelDist(mu, beta3) {
+  if (beta3 <= 0) throw new Error("gumbelDist: scale beta must be positive");
+  const quantile = (p) => p <= 0 ? -Infinity : p >= 1 ? Infinity : mu - beta3 * Math.log(-Math.log(p));
   return {
     pdf: (x) => {
-      const z = (x - mu) / beta2;
-      return 1 / beta2 * Math.exp(-(z + Math.exp(-z)));
+      const z = (x - mu) / beta3;
+      return 1 / beta3 * Math.exp(-(z + Math.exp(-z)));
     },
-    cdf: (x) => Math.exp(-Math.exp(-(x - mu) / beta2)),
+    cdf: (x) => Math.exp(-Math.exp(-(x - mu) / beta3)),
     quantile,
-    mean: mu + beta2 * EULER_GAMMA,
-    variance: Math.PI * Math.PI / 6 * beta2 * beta2,
+    mean: mu + beta3 * EULER_GAMMA,
+    variance: Math.PI * Math.PI / 6 * beta3 * beta3,
     sample: () => _contSample(quantile, Math.random),
     sampleN: (n, opts) => _sampleNDispatch(null, [], n, opts, (count2, rng) => {
       const out = new Float64Array(count2);
@@ -19766,12 +19842,12 @@ function dagostinoTest(data) {
   if (n < 8) throw new Error("dagostinoTest: need at least 8 observations");
   const { skew, kurtPearson } = _skewKurt(data);
   const y = skew * Math.sqrt((n + 1) * (n + 3) / (6 * (n - 2)));
-  const beta2 = 3 * (n * n + 27 * n - 70) * (n + 1) * (n + 3) / ((n - 2) * (n + 5) * (n + 7) * (n + 9));
-  const w2 = -1 + Math.sqrt(2 * (beta2 - 1));
+  const beta22 = 3 * (n * n + 27 * n - 70) * (n + 1) * (n + 3) / ((n - 2) * (n + 5) * (n + 7) * (n + 9));
+  const w2 = -1 + Math.sqrt(2 * (beta22 - 1));
   const delta = 1 / Math.sqrt(0.5 * Math.log(w2));
-  const alpha = Math.sqrt(2 / (w2 - 1));
+  const alpha2 = Math.sqrt(2 / (w2 - 1));
   const yy = y === 0 ? 1 : y;
-  const z1 = delta * Math.log(yy / alpha + Math.sqrt(yy / alpha * (yy / alpha) + 1));
+  const z1 = delta * Math.log(yy / alpha2 + Math.sqrt(yy / alpha2 * (yy / alpha2) + 1));
   const E = 3 * (n - 1) / (n + 1);
   const varb2 = 24 * n * (n - 2) * (n - 3) / ((n + 1) * (n + 1) * (n + 3) * (n + 5));
   const xx = (kurtPearson - E) / Math.sqrt(varb2);
@@ -20157,14 +20233,14 @@ function hessenbergForm(A) {
     let normV = 0;
     for (let i = 0; i < len; i++) normV += v[i] * v[i];
     if (normV < 1e-30) continue;
-    const beta2 = 2 / normV;
+    const beta3 = 2 / normV;
     for (let j = k; j < n; j++) {
       let dot9 = 0;
       for (let i = 0; i < len; i++) {
         dot9 += v[i] * H[k + 1 + i][j];
       }
       for (let i = 0; i < len; i++) {
-        H[k + 1 + i][j] -= beta2 * v[i] * dot9;
+        H[k + 1 + i][j] -= beta3 * v[i] * dot9;
       }
     }
     for (let i = 0; i < n; i++) {
@@ -20173,7 +20249,7 @@ function hessenbergForm(A) {
         dot9 += H[i][k + 1 + j] * v[j];
       }
       for (let j = 0; j < len; j++) {
-        H[i][k + 1 + j] -= beta2 * dot9 * v[j];
+        H[i][k + 1 + j] -= beta3 * dot9 * v[j];
       }
     }
     for (let i = 0; i < n; i++) {
@@ -20182,7 +20258,7 @@ function hessenbergForm(A) {
         dot9 += Q2[i][k + 1 + j] * v[j];
       }
       for (let j = 0; j < len; j++) {
-        Q2[i][k + 1 + j] -= beta2 * dot9 * v[j];
+        Q2[i][k + 1 + j] -= beta3 * dot9 * v[j];
       }
     }
   }
@@ -21649,6 +21725,7 @@ __export(factories_exports, {
   solveODE: () => solveODE,
   sort: () => sort,
   sparse: () => sparse,
+  spectralRadiance: () => spectralRadiance,
   speedOfLight: () => speedOfLight,
   splitUnit: () => splitUnit,
   sqrtm: () => sqrtm,
@@ -22381,6 +22458,36 @@ function rightArithShiftBigNumber(x, y) {
   }
   return x.div(new BigNumber9(2).pow(y)).floor();
 }
+function rightLogShiftBigNumber(x, y) {
+  if (x.isFinite() && !x.isInteger() || y.isFinite() && !y.isInteger()) {
+    throw new Error("Integers expected in function rightLogShift");
+  }
+  const BigNumber9 = x.constructor;
+  if (x.isNaN() || y.isNaN() || y.isNegative() && !y.isZero()) {
+    return new BigNumber9(NaN);
+  }
+  if (x.isZero() || y.isZero()) {
+    return x;
+  }
+  if (!y.isFinite()) {
+    if (x.isNegative() || !x.isFinite()) {
+      return new BigNumber9(NaN);
+    }
+    return new BigNumber9(0);
+  }
+  let val = x;
+  if (val.isNegative()) {
+    const MASK = new BigNumber9(4294967296);
+    val = val.mod(MASK);
+    if (val.isNegative()) {
+      val = val.plus(MASK);
+    }
+  }
+  if (y.lt(55)) {
+    return val.div(Math.pow(2, y.toNumber()) + "").floor();
+  }
+  return val.div(new BigNumber9(2).pow(y)).floor();
+}
 
 // src/bitwise/bitNot.ts
 var name15 = "bitNot";
@@ -24293,7 +24400,7 @@ var createIsPrime = /* @__PURE__ */ factory(
           d = d.div(2);
           r += 1;
         }
-        let bases = null;
+        let bases;
         if (n.toBigInt() < 3317044064679887385961981n) {
           bases = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41].filter((x) => x < n.toNumber());
         } else {
@@ -25534,17 +25641,79 @@ var createMatrixFromColumns = /* @__PURE__ */ factory(
           (item) => typeof item.toArray === "function"
         );
         const hasArray = arr10.some((item) => Array.isArray(item));
+        const isSparse = allMatrix && !hasArray && arr10.some(
+          (item) => typeof item.storage === "function" && item.storage() === "sparse"
+        );
+        if (isSparse) {
+          return _createSparseMatrixFromColumns(arr10);
+        }
         const arrays = arr10.map(
           (item) => typeof item.toArray === "function" ? item.toArray() : item
         );
         const result = _createArray(arrays);
         if (allMatrix && !hasArray) {
-          return matrix2(result);
+          return matrix2(result, "dense");
         }
         return result;
       }
-      // TODO implement this properly for SparseMatrix
     });
+    function _createSparseMatrixFromColumns(arr10) {
+      const M = arr10.length;
+      const N2 = checkVectorTypeAndReturnLength(arr10[0]);
+      const entries = [];
+      for (let j = 0; j < M; j++) {
+        const colVec = arr10[j];
+        const colLength = checkVectorTypeAndReturnLength(colVec);
+        if (colLength !== N2) {
+          throw new TypeError(
+            "The vectors had different length: " + (N2 | 0) + " \u2260 " + (colLength | 0)
+          );
+        }
+        if (typeof colVec.forEach === "function") {
+          const s = size2(colVec);
+          const is1D = s.length === 1;
+          const isCol = s.length === 2 && s[1] === 1;
+          colVec.forEach((val, idx) => {
+            let row2;
+            if (is1D) {
+              row2 = idx[0];
+            } else if (isCol) {
+              row2 = idx[0];
+            } else {
+              row2 = idx[1];
+            }
+            if (val !== 0) {
+              entries.push({ row: row2, col: j, value: val });
+            }
+          });
+        } else {
+          const f = flatten5(colVec);
+          for (let i = 0; i < N2; i++) {
+            if (f[i] !== 0) {
+              entries.push({ row: i, col: j, value: f[i] });
+            }
+          }
+        }
+      }
+      entries.sort((a, b) => {
+        if (a.col !== b.col) return a.col - b.col;
+        return a.row - b.row;
+      });
+      const values = [];
+      const index = [];
+      const ptr = new Array(M + 1).fill(0);
+      for (let i = 0; i < entries.length; i++) {
+        ptr[entries[i].col + 1]++;
+      }
+      for (let j = 1; j <= M; j++) {
+        ptr[j] += ptr[j - 1];
+      }
+      for (let i = 0; i < entries.length; i++) {
+        values.push(entries[i].value);
+        index.push(entries[i].row);
+      }
+      return matrix2({ values, index, ptr, size: [N2, M] }, "sparse");
+    }
     function _createArray(arr10) {
       if (arr10.length === 0)
         throw new TypeError("At least one column is needed to construct a matrix.");
@@ -25603,17 +25772,79 @@ var createMatrixFromRows = /* @__PURE__ */ factory(
           (item) => typeof item.toArray === "function"
         );
         const hasArray = arr10.some((item) => Array.isArray(item));
+        const isSparse = allMatrix && !hasArray && arr10.some(
+          (item) => typeof item.storage === "function" && item.storage() === "sparse"
+        );
+        if (isSparse) {
+          return _createSparseMatrixFromRows(arr10);
+        }
         const arrays = arr10.map(
           (item) => typeof item.toArray === "function" ? item.toArray() : item
         );
         const result = _createArray(arrays);
         if (allMatrix && !hasArray) {
-          return matrix2(result);
+          return matrix2(result, "dense");
         }
         return result;
       }
-      // TODO implement this properly for SparseMatrix
     });
+    function _createSparseMatrixFromRows(arr10) {
+      const N2 = arr10.length;
+      const M = checkVectorTypeAndReturnLength(arr10[0]);
+      const entries = [];
+      for (let i = 0; i < N2; i++) {
+        const rowVec = arr10[i];
+        const rowLength = checkVectorTypeAndReturnLength(rowVec);
+        if (rowLength !== M) {
+          throw new TypeError(
+            "The vectors had different length: " + (M | 0) + " \u2260 " + (rowLength | 0)
+          );
+        }
+        if (typeof rowVec.forEach === "function") {
+          const s = size2(rowVec);
+          const is1D = s.length === 1;
+          const isCol = s.length === 2 && s[1] === 1;
+          rowVec.forEach((val, idx) => {
+            let col;
+            if (is1D) {
+              col = idx[0];
+            } else if (isCol) {
+              col = idx[0];
+            } else {
+              col = idx[1];
+            }
+            if (val !== 0) {
+              entries.push({ row: i, col, value: val });
+            }
+          });
+        } else {
+          const f = flatten5(rowVec);
+          for (let j = 0; j < M; j++) {
+            if (f[j] !== 0) {
+              entries.push({ row: i, col: j, value: f[j] });
+            }
+          }
+        }
+      }
+      entries.sort((a, b) => {
+        if (a.col !== b.col) return a.col - b.col;
+        return a.row - b.row;
+      });
+      const values = [];
+      const index = [];
+      const ptr = new Array(M + 1).fill(0);
+      for (let i = 0; i < entries.length; i++) {
+        ptr[entries[i].col + 1]++;
+      }
+      for (let j = 1; j <= M; j++) {
+        ptr[j] += ptr[j - 1];
+      }
+      for (let i = 0; i < entries.length; i++) {
+        values.push(entries[i].value);
+        index.push(entries[i].row);
+      }
+      return matrix2({ values, index, ptr, size: [N2, M] }, "sparse");
+    }
     function _createArray(arr10) {
       if (arr10.length === 0)
         throw new TypeError("At least one row is needed to construct a matrix.");
@@ -26476,7 +26707,7 @@ var createCsAmd = /* @__PURE__ */ factory(
 // src/algebra/sparse/csLeaf.ts
 function csLeaf(i, j, w, first, maxfirst, prevleaf, ancestor) {
   let s, sparent;
-  let jleaf = 0;
+  let jleaf;
   let q;
   if (i <= j || w[first + j] <= w[maxfirst + i]) {
     return -1;
@@ -27828,6 +28059,10 @@ var createMatAlgo11xS0s = /* @__PURE__ */ factory(
   name108,
   dependencies108,
   ({ typed: typed3, equalScalar: equalScalar3 }) => {
+    let _dtCache;
+    let _cbCache;
+    let _eqCache;
+    let _cfCache;
     return function matAlgo11xS0s(s, b, callback, inverse) {
       const avalues = s._values;
       const aindex = s._index;
@@ -27845,10 +28080,19 @@ var createMatAlgo11xS0s = /* @__PURE__ */ factory(
       let cf = callback;
       if (typeof adt === "string") {
         dt = adt;
-        eq = typed3.find(equalScalar3, [dt, dt]);
+        if (dt === _dtCache && callback === _cbCache) {
+          eq = _eqCache;
+          cf = _cfCache;
+        } else {
+          eq = typed3.find(equalScalar3, [dt, dt]) || equalScalar3;
+          cf = typed3.find(callback, [dt, dt]) || callback;
+          _dtCache = dt;
+          _cbCache = callback;
+          _eqCache = eq;
+          _cfCache = cf;
+        }
         zero = typed3.convert(0, dt);
         b = typed3.convert(b, dt);
-        cf = typed3.find(callback, [dt, dt]);
       }
       const cvalues = [];
       const cindex = [];
@@ -28318,45 +28562,52 @@ var createConcat = /* @__PURE__ */ factory(
   dependencies115,
   ({ typed: typed3, matrix: matrix2, isInteger: isInteger3 }) => {
     return typed3(name115, {
-      // TODO: change signature to '...Array | Matrix, dim?' when supported
       "...Array | Matrix | number | BigNumber": function(args) {
-        let i;
         const len = args.length;
+        if (len === 0) {
+          throw new SyntaxError("At least one matrix expected");
+        }
+        const lastArg = args[len - 1];
+        const hasDim = isNumber(lastArg) || isBigNumber(lastArg);
+        const dimIndex = hasDim ? len - 1 : len;
         let dim = -1;
-        let prevDim;
+        if (hasDim) {
+          dim = lastArg.valueOf();
+          if (!isInteger3(dim)) {
+            throw new TypeError("Integer number expected for dimension");
+          }
+        }
         let asMatrix = false;
+        let prevDim = -1;
         const matrices = [];
-        for (i = 0; i < len; i++) {
+        for (let i = 0; i < dimIndex; i++) {
           const arg3 = args[i];
+          if (isNumber(arg3) || isBigNumber(arg3)) {
+            throw new Error("Dimension must be specified as last argument");
+          }
           if (isMatrix(arg3)) {
             asMatrix = true;
           }
-          if (isNumber(arg3) || isBigNumber(arg3)) {
-            if (i !== len - 1) {
-              throw new Error("Dimension must be specified as last argument");
-            }
-            prevDim = dim;
-            dim = arg3.valueOf();
-            if (!isInteger3(dim)) {
-              throw new TypeError("Integer number expected for dimension");
-            }
-            if (dim < 0 || i > 0 && dim > prevDim) {
-              throw new DimensionError(dim, dim < 0 ? 0 : prevDim, dim < 0 ? "<" : ">");
-            }
-          } else {
-            const m = clone(arg3).valueOf();
-            const size2 = arraySize(m);
-            matrices[i] = m;
-            prevDim = dim;
-            dim = size2.length - 1;
-            if (i > 0 && dim !== prevDim) {
-              throw new DimensionError(prevDim + 1, dim + 1);
-            }
+          const m = clone(arg3).valueOf();
+          const size2 = arraySize(m);
+          matrices.push(m);
+          const currentDim = size2.length - 1;
+          if (i === 0) {
+            prevDim = currentDim;
+          } else if (currentDim !== prevDim) {
+            throw new DimensionError(prevDim + 1, currentDim + 1);
           }
         }
         if (matrices.length === 0) {
           throw new SyntaxError("At least one matrix expected");
         }
+        if (hasDim) {
+          if (dim < 0 || dim > prevDim) {
+            throw new DimensionError(dim, dim < 0 ? 0 : prevDim, dim < 0 ? "<" : ">");
+          }
+        } else {
+          dim = prevDim;
+        }
         let res = matrices.shift();
         while (matrices.length) {
           res = concat(res, matrices.shift(), dim);
@@ -29055,6 +29306,7 @@ var createMatAlgo03xDSf = /* @__PURE__ */ factory(
   name121,
   dependencies121,
   ({ typed: typed3 }) => {
+    const signaturesCache = /* @__PURE__ */ new WeakMap();
     return function matAlgo03xDSf(denseMatrix, sparseMatrix, callback, inverse) {
       const adata = denseMatrix._data;
       const asize = denseMatrix._size;
@@ -29083,7 +29335,17 @@ var createMatAlgo03xDSf = /* @__PURE__ */ factory(
       if (typeof adt === "string" && adt === bdt && adt !== "mixed") {
         dt = adt;
         zero = typed3.convert(0, dt);
-        cf = typed3.find(callback, [dt, dt]);
+        let callbacksForDt = signaturesCache.get(callback);
+        if (!callbacksForDt) {
+          callbacksForDt = /* @__PURE__ */ new Map();
+          signaturesCache.set(callback, callbacksForDt);
+        }
+        let cachedCf = callbacksForDt.get(dt);
+        if (!cachedCf) {
+          cachedCf = typed3.find(callback, [dt, dt]);
+          callbacksForDt.set(dt, cachedCf);
+        }
+        cf = cachedCf;
       }
       const cdata = [];
       for (let z = 0; z < rows; z++) {
@@ -31042,7 +31304,8 @@ var createPow = /* @__PURE__ */ factory(
         } catch (error) {
           if (error instanceof Error && error.message === "Cannot calculate inverse, determinant is zero") {
             throw new TypeError(
-              "For A^b, when A is not invertible, b must be a positive integer (value is " + y + ")"
+              "For A^b, when A is not invertible, b must be a positive integer (value is " + y + ")",
+              { cause: error }
             );
           }
           throw error;
@@ -31574,7 +31837,7 @@ var createRightLogShift = /* @__PURE__ */ factory(
       name153,
       {
         "number, number": rightLogShiftNumber,
-        // 'BigNumber, BigNumber': ..., // TODO: implement BigNumber support for rightLogShift
+        "BigNumber, BigNumber": rightLogShiftBigNumber,
         "SparseMatrix, number | BigNumber": typed3.referToSelf(
           (self) => (x, y) => {
             if (equalScalar3(y, 0)) {
@@ -32910,14 +33173,14 @@ var createQr = /* @__PURE__ */ factory(
         for (i = k; i < rows; i++) {
           alphaSquared = addScalar2(alphaSquared, multiplyScalar2(Rdata[i][k], conj3(Rdata[i][k])));
         }
-        const alpha = multiplyScalar2(sgn, sqrt2(alphaSquared));
-        if (!isZero4(alpha)) {
-          const u1 = subtractScalar2(pivot, alpha);
+        const alpha2 = multiplyScalar2(sgn, sqrt2(alphaSquared));
+        if (!isZero4(alpha2)) {
+          const u1 = subtractScalar2(pivot, alpha2);
           w[k] = 1;
           for (i = k + 1; i < rows; i++) {
             w[i] = divideScalar2(Rdata[i][k], u1);
           }
-          const tau2 = unaryMinus2(conj3(divideScalar2(u1, alpha)));
+          const tau2 = unaryMinus2(conj3(divideScalar2(u1, alpha2)));
           let s;
           for (j = k; j < cols; j++) {
             s = 0;
@@ -34263,8 +34526,16 @@ var createPermutations = /* @__PURE__ */ factory(
           result = result.times(i);
         }
         return result;
-      }
-      // TODO: implement support for collection in permutations
+      },
+      "Array | Matrix": typed3.referToSelf(
+        (self) => (n) => deepMap(n, self)
+      ),
+      "Array | Matrix, number | BigNumber": typed3.referToSelf(
+        (self) => (n, k) => deepMap(n, (n_val) => self(n_val, k))
+      ),
+      "number | BigNumber, Array | Matrix": typed3.referToSelf(
+        (self) => (n, k) => deepMap(k, (k_val) => self(n, k_val))
+      )
     });
   }
 );
@@ -35493,7 +35764,16 @@ var createSubtract = /* @__PURE__ */ factory(
         // =========================================================================
         // EXISTING SIGNATURES - Keep after Node signatures
         // =========================================================================
-        "any, any": subtractScalar2
+        "any, any": subtractScalar2,
+        "any, any, ...any": typed3.referToSelf(
+          (self) => (x, y, ...rest) => {
+            let res = self(x, y);
+            for (let i = 0; i < rest.length; i++) {
+              res = self(res, rest[i]);
+            }
+            return res;
+          }
+        )
       },
       matrixAlgorithmSuite({
         elop: subtractScalar2,
@@ -37311,12 +37591,10 @@ var createCsLu = /* @__PURE__ */ factory(
       const size2 = m._size;
       const n = size2[1];
       let q;
-      let lnz = 100;
-      let unz = 100;
+      let lnz;
+      let unz;
       if (s) {
         q = s.q;
-        lnz = s.lnz || lnz;
-        unz = s.unz || unz;
       }
       const lvalues = [];
       const lindex = [];
@@ -37718,7 +37996,6 @@ var dependencies218 = [
   "abs",
   "add",
   "addScalar",
-  "matrix",
   "multiply",
   "multiplyScalar",
   "divideScalar",
@@ -37738,7 +38015,6 @@ var createIntersect = /* @__PURE__ */ factory(
     abs: abs2,
     add: add5,
     addScalar: addScalar2,
-    matrix: matrix2,
     multiply: multiply2,
     multiplyScalar: multiplyScalar2,
     divideScalar: divideScalar2,
@@ -37758,7 +38034,7 @@ var createIntersect = /* @__PURE__ */ factory(
           y.valueOf(),
           plane.valueOf()
         );
-        return arr10 === null ? null : matrix2(arr10);
+        return arr10 === null ? null : x.create(arr10, x.datatype());
       },
       "Matrix, Matrix, Matrix, Matrix": function(w, x, y, z) {
         const arr10 = _AAAA(
@@ -37767,7 +38043,7 @@ var createIntersect = /* @__PURE__ */ factory(
           y.valueOf(),
           z.valueOf()
         );
-        return arr10 === null ? null : matrix2(arr10);
+        return arr10 === null ? null : w.create(arr10, w.datatype());
       }
     });
     function _AAA(x, y, plane) {
@@ -38856,7 +39132,7 @@ var createSetPowerset = /* @__PURE__ */ factory(
       return result;
     }
     function _sort(array) {
-      let temp = [];
+      let temp;
       for (let i = array.length - 1; i > 0; i--) {
         for (let j = 0; j < i; j++) {
           if (array[j].length > array[j + 1].length) {
@@ -41105,7 +41381,7 @@ var createMad = /* @__PURE__ */ factory(
         );
       } catch (err) {
         if (err instanceof TypeError && err.message.includes("median")) {
-          throw new TypeError(err.message.replace("median", "mad"));
+          throw new TypeError(err.message.replace("median", "mad"), { cause: err });
         } else {
           throw improveErrorMessage(err, "mad", void 0);
         }
@@ -41149,7 +41425,7 @@ var createStd = /* @__PURE__ */ factory(
         }
       } catch (err) {
         if (err instanceof TypeError && err.message.includes(" variance")) {
-          throw new TypeError(err.message.replace(" variance", " std"));
+          throw new TypeError(err.message.replace(" variance", " std"), { cause: err });
         } else {
           throw err;
         }
@@ -42067,19 +42343,30 @@ var createDerivative = /* @__PURE__ */ factory(
     SymbolNode
   }) => {
     function plainDerivative(expr, variable, options = { simplify: true }) {
-      const cache = /* @__PURE__ */ new Map();
+      const order = options.order !== void 0 ? options.order : 1;
+      if (!Number.isInteger(order) || order < 0) {
+        throw new TypeError('Option "order" must be a non-negative integer');
+      }
       const variableName = variable.name;
-      function isConstCached(node) {
-        const cached = cache.get(node);
-        if (cached !== void 0) {
-          return cached;
+      let res = expr;
+      for (let i = 0; i < order; i++) {
+        let isConstCached2 = function(node) {
+          const cached = cache.get(node);
+          if (cached !== void 0) {
+            return cached;
+          }
+          const r = _isConst(isConstCached2, node, variableName);
+          cache.set(node, r);
+          return r;
+        };
+        var isConstCached = isConstCached2;
+        const cache = /* @__PURE__ */ new Map();
+        res = _derivative(res, isConstCached2);
+        if (options.simplify !== false && i < order - 1) {
+          res = simplify2(res);
         }
-        const res2 = _isConst(isConstCached, node, variableName);
-        cache.set(node, res2);
-        return res2;
       }
-      const res = _derivative(expr, isConstCached);
-      return options.simplify ? simplify2(res) : res;
+      return options.simplify !== false ? simplify2(res) : res;
     }
     function parseIdentifier(string2) {
       const symbol = parse3(string2);
@@ -42095,16 +42382,6 @@ var createDerivative = /* @__PURE__ */ factory(
       "Node, SymbolNode, Object": plainDerivative,
       "Node, string": (node, symbol) => plainDerivative(node, parseIdentifier(symbol)),
       "Node, string, Object": (node, symbol, options) => plainDerivative(node, parseIdentifier(symbol), options)
-      /* TODO: implement and test syntax with order of derivatives -> implement as an option {order: number}
-      'Node, SymbolNode, ConstantNode': function (expr, variable, {order}) {
-        let res = expr
-        for (let i = 0; i < order; i++) {
-          <create caching isConst>
-          res = _derivative(res, isConst)
-        }
-        return res
-      }
-      */
     });
     derivative3._simplify = true;
     derivative3.toTex = function(deriv) {
@@ -42113,7 +42390,11 @@ var createDerivative = /* @__PURE__ */ factory(
     const _derivTex = typed3("_derivTex", {
       "Node, SymbolNode": function(expr, x) {
         if (isConstantNode(expr) && typeOf(expr.value) === "string") {
-          return _derivTex(parse3(expr.value).toString(), x.toString(), 1);
+          return _derivTex(
+            parse3(expr.value).toString(),
+            x.toString(),
+            1
+          );
         } else {
           return _derivTex(expr.toTex(), x.toString(), 1);
         }
@@ -42169,7 +42450,9 @@ var createDerivative = /* @__PURE__ */ factory(
         return createConstantNode2(1);
       },
       "ParenthesisNode, function": function(node, isConst2) {
-        return new ParenthesisNode(_derivative(node.content, isConst2));
+        return new ParenthesisNode(
+          _derivative(node.content, isConst2)
+        );
       },
       "FunctionAssignmentNode, function": function(node, isConst2) {
         if (isConst2(node)) {
@@ -43784,7 +44067,7 @@ var createNuclearMagneton = /* @__PURE__ */ unitFactory(
 var createKlitzing = /* @__PURE__ */ unitFactory("klitzing", "25812.807459304513", "ohm");
 var createJosephson = /* @__PURE__ */ unitFactory(
   "josephson",
-  "4.835978484169836e14 Hz V",
+  "4.835978484169836e14",
   "Hz V^-1"
 );
 var createBohrRadius = /* @__PURE__ */ unitFactory("bohrRadius", "5.29177210544e-11", "m");
@@ -43854,6 +44137,11 @@ var createFirstRadiation = /* @__PURE__ */ unitFactory(
   "3.7417718521927573e-16",
   "W m^2"
 );
+var createSpectralRadiance = /* @__PURE__ */ unitFactory(
+  "spectralRadiance",
+  "1.1910429723971881e-16",
+  "W m^2 sr^-1"
+);
 var createLoschmidt = /* @__PURE__ */ unitFactory(
   "loschmidt",
   "2.686780111798444e25",
@@ -44704,6 +44992,9 @@ var stefanBoltzmann = createStefanBoltzmann(
 var firstRadiation = createFirstRadiation(
   factoryScope
 );
+var spectralRadiance = createSpectralRadiance(
+  factoryScope
+);
 var secondRadiation = createSecondRadiation(
   factoryScope
 );
@@ -45731,16 +46022,16 @@ function groebnerBasis(polys, vars) {
   return basis.map((b) => polyToString(b, vars));
 }
 function minimalPolynomial(expr, varName) {
-  const alpha = evaluate(expr);
-  if (!isFinite(alpha)) return null;
+  const alpha2 = evaluate(expr);
+  if (!isFinite(alpha2)) return null;
   for (let den = 1; den <= 100; den++) {
-    const num2 = Math.round(alpha * den);
-    if (Math.abs(alpha - num2 / den) < 1e-12) {
+    const num2 = Math.round(alpha2 * den);
+    if (Math.abs(alpha2 - num2 / den) < 1e-12) {
       if (den === 1) return `${varName} - ${num2}`;
       return `${den}*${varName} - ${num2}`;
     }
   }
-  const powers = [1, alpha, alpha * alpha, alpha * alpha * alpha, alpha ** 4];
+  const powers = [1, alpha2, alpha2 * alpha2, alpha2 * alpha2 * alpha2, alpha2 ** 4];
   for (let deg = 2; deg <= 6; deg++) {
     const maxCoeff = 20;
     const found = findIntegerRelation(powers.slice(0, deg + 1), maxCoeff);
@@ -46259,7 +46550,7 @@ function iltSimplifyNode(node) {
   return node;
 }
 function _inverseLaplaceNode(node, sVar, tVar) {
-  let simplified = node;
+  let simplified;
   try {
     simplified = iltSimplifyNode(node);
   } catch {
@@ -47317,7 +47608,7 @@ function studentizedRangeQuantile(p, k, df) {
   }
   return (lo + hi) / 2;
 }
-function tukeyHSD(groups, alpha = 0.05) {
+function tukeyHSD(groups, alpha2 = 0.05) {
   const gs = groups.map(arr2);
   const k = gs.length;
   if (k < 2) throw new Error("tukeyHSD: need at least 2 groups");
@@ -47328,7 +47619,7 @@ function tukeyHSD(groups, alpha = 0.05) {
     throw new Error("tukeyHSD: residual df must be > 0 (groups must hold more observations than groups)");
   const sse = gs.reduce((s, g) => s + sampleVar(g) * (g.length - 1), 0);
   const mse = sse / dfErr;
-  const qCrit = studentizedRangeQuantile(1 - alpha, k, dfErr);
+  const qCrit = studentizedRangeQuantile(1 - alpha2, k, dfErr);
   const out = [];
   for (let i = 0; i < k; i++) {
     for (let j = i + 1; j < k; j++) {
@@ -47619,7 +47910,7 @@ function fsolve(F, x0, opts = {}) {
       delta = linsolve(J, rhs);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      throw new Error(`fsolve: singular Jacobian at iteration ${iter} (${msg})`);
+      throw new Error(`fsolve: singular Jacobian at iteration ${iter} (${msg})`, { cause: err });
     }
     const residualNorm2 = norm24(Fx);
     let xNext = x.map((xi, i) => xi + delta[i]);
@@ -47672,14 +47963,14 @@ function dot2(a, b) {
 function norm25(a) {
   return Math.sqrt(dot2(a, a));
 }
-function axpy(alpha, x, y) {
+function axpy(alpha2, x, y) {
   const n = x.length;
   const out = new Array(n);
-  for (let i = 0; i < n; i++) out[i] = alpha * x[i] + y[i];
+  for (let i = 0; i < n; i++) out[i] = alpha2 * x[i] + y[i];
   return out;
 }
-function scale(alpha, x) {
-  return x.map((v) => alpha * v);
+function scale(alpha2, x) {
+  return x.map((v) => alpha2 * v);
 }
 function subtract2(a, b) {
   return a.map((v, i) => v - b[i]);
@@ -47843,17 +48134,17 @@ function cg(a, b, opts) {
     const Ap = matvec2(p);
     const pAp = dot2(p, Ap);
     if (Math.abs(pAp) < 1e-300) break;
-    const alpha = rzOld / pAp;
-    x = axpy(alpha, p, x);
-    r = axpy(-alpha, Ap, r);
+    const alpha2 = rzOld / pAp;
+    x = axpy(alpha2, p, x);
+    r = axpy(-alpha2, Ap, r);
     residual = relativeResidualNorm(norm25(r), bNorm);
     if (residual < tol) {
       return { x, iterations, converged: true, residual };
     }
     z = applyM(r);
     const rzNew = dot2(r, z);
-    const beta2 = rzNew / rzOld;
-    p = add3(z, scale(beta2, p));
+    const beta3 = rzNew / rzOld;
+    p = add3(z, scale(beta3, p));
     rzOld = rzNew;
   }
   return { x, iterations, converged: residual < tol, residual };
@@ -47874,7 +48165,7 @@ function minres(a, b, opts) {
     return { x, iterations: 0, converged: residual0 < tol, residual: residual0 };
   }
   let oldb = 0;
-  let beta2 = beta1;
+  let beta3 = beta1;
   let dbar = 0;
   let epsln = 0;
   let phibar = beta1;
@@ -47886,31 +48177,31 @@ function minres(a, b, opts) {
   let iterations = 0;
   for (let iter = 1; iter <= maxIter; iter++) {
     iterations = iter;
-    const v = scale(1 / beta2, y);
+    const v = scale(1 / beta3, y);
     y = matvec2(v);
-    if (iter >= 2) y = axpy(-beta2 / oldb, r1, y);
+    if (iter >= 2) y = axpy(-beta3 / oldb, r1, y);
     const alfa = dot2(v, y);
-    y = axpy(-alfa / beta2, r2, y);
+    y = axpy(-alfa / beta3, r2, y);
     r1 = r2;
     r2 = y;
     y = applyM(r2);
-    oldb = beta2;
-    beta2 = Math.sqrt(Math.max(0, dot2(r2, y)));
+    oldb = beta3;
+    beta3 = Math.sqrt(Math.max(0, dot2(r2, y)));
     const oldeps = epsln;
     const delta = cs * dbar + sn * alfa;
     const gbar = sn * dbar - cs * alfa;
-    epsln = sn * beta2;
-    dbar = -cs * beta2;
-    const gamma2 = Math.max(Math.sqrt(gbar * gbar + beta2 * beta2), 1e-300);
+    epsln = sn * beta3;
+    dbar = -cs * beta3;
+    const gamma2 = Math.max(Math.sqrt(gbar * gbar + beta3 * beta3), 1e-300);
     cs = gbar / gamma2;
-    sn = beta2 / gamma2;
+    sn = beta3 / gamma2;
     const phi = cs * phibar;
     phibar = sn * phibar;
     const w1 = w2;
     w2 = w;
     w = scale(1 / gamma2, subtract2(subtract2(v, scale(oldeps, w1)), scale(delta, w2)));
     for (let i = 0; i < n; i++) x[i] += phi * w[i];
-    if (phibar / beta1 < tol || beta2 < 1e-300) break;
+    if (phibar / beta1 < tol || beta3 < 1e-300) break;
   }
   const residual = relativeResidual(matvec2, x, b, bNorm);
   return { x, iterations, converged: residual < tol, residual };
@@ -47931,15 +48222,15 @@ function gmres(a, b, opts) {
   }
   while (totalIterations < maxIter) {
     const r0 = applyM(subtract2(b, matvec2(x)));
-    const beta2 = norm25(r0);
-    if (beta2 < 1e-300) {
+    const beta3 = norm25(r0);
+    if (beta3 < 1e-300) {
       return { x, iterations: totalIterations, converged: residual < tol, residual };
     }
     const m = Math.min(restart, maxIter - totalIterations);
-    const V = [scale(1 / beta2, r0)];
+    const V = [scale(1 / beta3, r0)];
     const H = Array.from({ length: m + 1 }, () => new Array(m).fill(0));
     const g = new Array(m + 1).fill(0);
-    g[0] = beta2;
+    g[0] = beta3;
     const cs = new Array(m).fill(0);
     const sn = new Array(m).fill(0);
     let k = 0;
@@ -48007,7 +48298,7 @@ function bicgstab(a, b, opts) {
     return { x, iterations: 0, converged: true, residual };
   }
   let rho = 1;
-  let alpha = 1;
+  let alpha2 = 1;
   let omega = 1;
   let v = zeros2(n);
   let p = zeros2(n);
@@ -48019,19 +48310,19 @@ function bicgstab(a, b, opts) {
     if (iter === 1) {
       p = r.slice();
     } else {
-      const beta2 = rhoNew / rho * (alpha / omega);
-      p = add3(r, scale(beta2, subtract2(p, scale(omega, v))));
+      const beta3 = rhoNew / rho * (alpha2 / omega);
+      p = add3(r, scale(beta3, subtract2(p, scale(omega, v))));
     }
     rho = rhoNew;
     const pHat = applyM(p);
     v = matvec2(pHat);
     const rHatV = dot2(rHat0, v);
     if (Math.abs(rHatV) < 1e-300) break;
-    alpha = rho / rHatV;
-    const s = axpy(-alpha, v, r);
+    alpha2 = rho / rHatV;
+    const s = axpy(-alpha2, v, r);
     const sNorm = relativeResidualNorm(norm25(s), bNorm);
     if (sNorm < tol) {
-      x = axpy(alpha, pHat, x);
+      x = axpy(alpha2, pHat, x);
       residual = sNorm;
       return { x, iterations, converged: true, residual };
     }
@@ -48039,7 +48330,7 @@ function bicgstab(a, b, opts) {
     const t = matvec2(sHat);
     const tt = dot2(t, t);
     omega = tt > 1e-300 ? dot2(t, s) / tt : 0;
-    x = axpy(alpha, pHat, x);
+    x = axpy(alpha2, pHat, x);
     x = axpy(omega, sHat, x);
     r = axpy(-omega, t, s);
     residual = relativeResidualNorm(norm25(r), bNorm);
@@ -48082,13 +48373,13 @@ function dot3(a, b) {
 function norm26(a) {
   return Math.sqrt(dot3(a, a));
 }
-function axpy2(alpha, x, y) {
+function axpy2(alpha2, x, y) {
   const out = new Array(x.length);
-  for (let i = 0; i < x.length; i++) out[i] = alpha * x[i] + y[i];
+  for (let i = 0; i < x.length; i++) out[i] = alpha2 * x[i] + y[i];
   return out;
 }
-function scale2(alpha, x) {
-  return x.map((v) => alpha * v);
+function scale2(alpha2, x) {
+  return x.map((v) => alpha2 * v);
 }
 function startVector(n) {
   const v = new Array(n);
@@ -48104,19 +48395,19 @@ function lanczos(matvec2, n, m) {
     const vj = V[j];
     let w = matvec2(vj);
     if (j > 0) w = axpy2(-betas[j - 1], V[j - 1], w);
-    const alpha = dot3(w, vj);
-    alphas.push(alpha);
-    w = axpy2(-alpha, vj, w);
+    const alpha2 = dot3(w, vj);
+    alphas.push(alpha2);
+    w = axpy2(-alpha2, vj, w);
     for (let pass = 0; pass < 2; pass++) {
       for (let i = 0; i <= j; i++) {
         const c = dot3(w, V[i]);
         w = axpy2(-c, V[i], w);
       }
     }
-    const beta2 = norm26(w);
-    if (j === m - 1 || beta2 < 1e-13) break;
-    betas.push(beta2);
-    V.push(scale2(1 / beta2, w));
+    const beta3 = norm26(w);
+    if (j === m - 1 || beta3 < 1e-13) break;
+    betas.push(beta3);
+    V.push(scale2(1 / beta3, w));
   }
   return { V, alphas, betas };
 }
@@ -48420,7 +48711,7 @@ function ldl(A) {
     for (let i = 0; i < n; i++) [W[i][a], W[i][b]] = [W[i][b], W[i][a]];
     [L[a], L[b]] = [L[b], L[a]];
   };
-  const alpha = (1 + Math.sqrt(17)) / 8;
+  const alpha2 = (1 + Math.sqrt(17)) / 8;
   let k = 0;
   while (k < n) {
     if (k === n - 1) {
@@ -48441,13 +48732,13 @@ function ldl(A) {
     }
     let use1x1 = true;
     let swapWith = -1;
-    if (lambda !== 0 && w1 < alpha * lambda) {
+    if (lambda !== 0 && w1 < alpha2 * lambda) {
       let sigma = 0;
       for (let i = k; i < n; i++) {
         if (i !== r) sigma = Math.max(sigma, Math.abs(W[i][r]));
       }
-      if (w1 * sigma < alpha * lambda * lambda) {
-        if (Math.abs(W[r][r]) >= alpha * sigma) {
+      if (w1 * sigma < alpha2 * lambda * lambda) {
+        if (Math.abs(W[r][r]) >= alpha2 * sigma) {
           swapWith = r;
         } else {
           use1x1 = false;
@@ -49361,15 +49652,15 @@ function movingAverage(x, w) {
   }
   return out;
 }
-function ewma(x, alpha) {
+function ewma(x, alpha2) {
   const a = arr4(x);
-  if (alpha <= 0 || alpha > 1) throw new Error("ewma: alpha must be in (0, 1]");
+  if (alpha2 <= 0 || alpha2 > 1) throw new Error("ewma: alpha must be in (0, 1]");
   if (a.length === 0) throw new Error("ewma: input series is empty");
   const out = new Array(a.length);
   let prev = a[0];
   out[0] = prev;
   for (let i = 1; i < a.length; i++) {
-    prev = alpha * a[i] + (1 - alpha) * prev;
+    prev = alpha2 * a[i] + (1 - alpha2) * prev;
     out[i] = prev;
   }
   return out;
@@ -49561,8 +49852,8 @@ var MACKINNON_C = {
   10: { betaInf: -2.5671, beta1: -1.438, beta2: -4.48 }
 };
 function adfCriticalValue(pct, n) {
-  const { betaInf, beta1, beta2 } = MACKINNON_C[pct];
-  return betaInf + beta1 / n + beta2 / (n * n);
+  const { betaInf, beta1, beta2: beta22 } = MACKINNON_C[pct];
+  return betaInf + beta1 / n + beta22 / (n * n);
 }
 function adfPValue(statistic, n) {
   const cv1 = adfCriticalValue(1, n);
@@ -49689,9 +49980,9 @@ function softThreshold(a, lambda) {
   if (a < -lambda) return a + lambda;
   return 0;
 }
-function ridge(X, y, alpha, opts) {
+function ridge(X, y, alpha2, opts) {
   const { n, p } = validate2(X, y, "ridge");
-  if (alpha < 0) throw new Error("ridge: alpha must be non-negative");
+  if (alpha2 < 0) throw new Error("ridge: alpha must be non-negative");
   const useIntercept = opts?.intercept !== false;
   const { Xc, yc, xMean, yMean } = center(X, y, n, p, useIntercept);
   const XtX = Array.from({ length: p }, () => new Array(p).fill(0));
@@ -49703,7 +49994,7 @@ function ridge(X, y, alpha, opts) {
       XtX[j][k] = s;
       XtX[k][j] = s;
     }
-    XtX[j][j] += alpha;
+    XtX[j][j] += alpha2;
     for (let i = 0; i < n; i++) Xty[j] += Xc[i][j] * yc[i];
   }
   const coefficients = linsolve(XtX, Xty);
@@ -49722,52 +50013,52 @@ function standardize(Xc, n, p) {
   return { Xs, scale: scale4 };
 }
 function coordinateDescent(Xs, yc, n, p, l1, l2, maxIter, tol) {
-  const beta2 = new Array(p).fill(0);
+  const beta3 = new Array(p).fill(0);
   const z = new Array(p).fill(n);
   const residual = [...yc];
   for (let iter = 0; iter < maxIter; iter++) {
     let maxChange = 0;
     for (let j = 0; j < p; j++) {
       const col = Xs.map((row2) => row2[j]);
-      const oldBeta = beta2[j];
+      const oldBeta = beta3[j];
       let rho = 0;
       for (let i = 0; i < n; i++) rho += col[i] * (residual[i] + col[i] * oldBeta);
       const newBeta = softThreshold(rho, l1) / (z[j] + l2);
       if (newBeta !== oldBeta) {
         const delta = newBeta - oldBeta;
         for (let i = 0; i < n; i++) residual[i] -= col[i] * delta;
-        beta2[j] = newBeta;
+        beta3[j] = newBeta;
         maxChange = Math.max(maxChange, Math.abs(delta));
       }
     }
     if (maxChange < tol) break;
   }
-  return beta2;
+  return beta3;
 }
-function lasso(X, y, alpha, opts) {
+function lasso(X, y, alpha2, opts) {
   const { n, p } = validate2(X, y, "lasso");
-  if (alpha < 0) throw new Error("lasso: alpha must be non-negative");
+  if (alpha2 < 0) throw new Error("lasso: alpha must be non-negative");
   const useIntercept = opts?.intercept !== false;
   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: scale4 } = standardize(Xc, n, p);
-  const betaStd = coordinateDescent(Xs, yc, n, p, alpha, 0, maxIter, tol);
+  const betaStd = coordinateDescent(Xs, yc, n, p, alpha2, 0, maxIter, tol);
   const coefficients = betaStd.map((b, j) => b / scale4[j]);
   const intercept = useIntercept ? yMean - dot4(xMean, coefficients) : 0;
   return { coefficients, intercept };
 }
-function elasticNet(X, y, alpha, l1Ratio, opts) {
+function elasticNet(X, y, alpha2, l1Ratio, opts) {
   const { n, p } = validate2(X, y, "elasticNet");
-  if (alpha < 0) throw new Error("elasticNet: alpha must be non-negative");
+  if (alpha2 < 0) throw new Error("elasticNet: alpha must be non-negative");
   if (l1Ratio < 0 || l1Ratio > 1) throw new Error("elasticNet: l1Ratio must be in [0, 1]");
   const useIntercept = opts?.intercept !== false;
   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: scale4 } = standardize(Xc, n, p);
-  const l1 = alpha * l1Ratio;
-  const l2 = alpha * (1 - l1Ratio);
+  const l1 = alpha2 * l1Ratio;
+  const l2 = alpha2 * (1 - l1Ratio);
   const betaStd = coordinateDescent(Xs, yc, n, p, l1, l2, maxIter, tol);
   const coefficients = betaStd.map((b, j) => b / scale4[j]);
   const intercept = useIntercept ? yMean - dot4(xMean, coefficients) : 0;
@@ -49801,9 +50092,9 @@ function logisticRegression(X, y, opts) {
   const design = (rows) => useIntercept ? rows.map((row2) => [1, ...row2]) : rows.map((row2) => [...row2]);
   const D = design(X);
   const p = D[0].length;
-  let beta2 = new Array(p).fill(0);
+  let beta3 = new Array(p).fill(0);
   for (let iter = 0; iter < maxIter; iter++) {
-    const eta = D.map((row2) => row2.reduce((s, v, j) => s + v * beta2[j], 0));
+    const eta = D.map((row2) => row2.reduce((s, v, j) => s + v * beta3[j], 0));
     const probs = eta.map(sigmoid2);
     const weights = probs.map((pi) => Math.max(pi * (1 - pi), 1e-9));
     const XtWX = Array.from({ length: p }, () => new Array(p).fill(0));
@@ -49841,14 +50132,14 @@ function logisticRegression(X, y, opts) {
       delta = delta.map((d) => d * scale4);
       stepNorm = MAX_STEP_NORM;
     }
-    beta2 = beta2.map((b, j) => b + delta[j]);
+    beta3 = beta3.map((b, j) => b + delta[j]);
     if (stepNorm < tol) break;
   }
-  const intercept = useIntercept ? beta2[0] : 0;
-  const coefficients = useIntercept ? beta2.slice(1) : beta2.slice();
+  const intercept = useIntercept ? beta3[0] : 0;
+  const coefficients = useIntercept ? beta3.slice(1) : beta3.slice();
   const predictProba = (x) => {
     const Dx = design(x);
-    return Dx.map((row2) => sigmoid2(row2.reduce((s, v, j) => s + v * beta2[j], 0)));
+    return Dx.map((row2) => sigmoid2(row2.reduce((s, v, j) => s + v * beta3[j], 0)));
   };
   const predict = (x) => predictProba(x).map((pi) => pi >= 0.5 ? 1 : 0);
   return { coefficients, intercept, predictProba, predict };
@@ -49859,7 +50150,7 @@ var _inv2 = inv;
 function nelderMead(f, x0, opts = {}) {
   const { maxIter = 2e3, tol = 1e-8, step = 0.05 } = opts;
   const n = x0.length;
-  const alpha = 1;
+  const alpha2 = 1;
   const gamma2 = 2;
   const rho = 0.5;
   const sigma = 0.5;
@@ -49884,7 +50175,7 @@ function nelderMead(f, x0, opts = {}) {
     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 = add5(c, sub4(c, simplex[n]), alpha);
+    const xr = add5(c, sub4(c, simplex[n]), alpha2);
     const fr = f(xr);
     if (fr < fv[0]) {
       const xe = add5(c, sub4(c, simplex[n]), gamma2);
@@ -50384,17 +50675,17 @@ function bfgs(f, x0, opts = {}) {
     const gd = dot5(g, d);
     const dir = gd < 0 ? d : g.map((v) => -v);
     const dirSlope = gd < 0 ? gd : -dot5(g, g);
-    let alpha = 1;
+    let alpha2 = 1;
     let xNew = clipToBounds(
-      x.map((v, i) => v + alpha * dir[i]),
+      x.map((v, i) => v + alpha2 * dir[i]),
       bounds
     );
     let fNew = f(xNew);
     let halvings = 0;
-    while (fNew > fx + c1 * alpha * dirSlope && halvings < 50) {
-      alpha *= 0.5;
+    while (fNew > fx + c1 * alpha2 * dirSlope && halvings < 50) {
+      alpha2 *= 0.5;
       xNew = clipToBounds(
-        x.map((v, i) => v + alpha * dir[i]),
+        x.map((v, i) => v + alpha2 * dir[i]),
         bounds
       );
       fNew = f(xNew);
@@ -50493,15 +50784,15 @@ function nnls(A, b, opts = {}) {
     let innerIter = 0;
     while (Array.from(passive).some((j) => z[j] <= tol) && innerIter < maxIter) {
       innerIter++;
-      let alpha = Infinity;
+      let alpha2 = Infinity;
       for (const j of passive) {
         if (z[j] <= tol) {
           const denom = x[j] - z[j];
-          if (denom > 0) alpha = Math.min(alpha, x[j] / denom);
+          if (denom > 0) alpha2 = Math.min(alpha2, x[j] / denom);
         }
       }
-      if (!isFinite(alpha)) alpha = 0;
-      for (let j = 0; j < n; j++) x[j] = x[j] + alpha * (z[j] - x[j]);
+      if (!isFinite(alpha2)) alpha2 = 0;
+      for (let j = 0; j < n; j++) x[j] = x[j] + alpha2 * (z[j] - x[j]);
       for (const j of Array.from(passive)) {
         if (Math.abs(x[j]) < tol) passive.delete(j);
       }
@@ -50549,18 +50840,18 @@ function lsqBounded(A, b, lower, upper, opts = {}) {
     pgNorm = Math.sqrt(pgNorm);
     if (pgNorm < tol) break;
     const fx = objective(x);
-    let alpha = 1;
+    let alpha2 = 1;
     let xNext = clip(
-      x.map((xi, i) => xi - alpha * g[i]),
+      x.map((xi, i) => xi - alpha2 * g[i]),
       lower,
       upper
     );
     let fNext = objective(xNext);
     let backtrack = 0;
     while (fNext > fx && backtrack < 50) {
-      alpha /= 2;
+      alpha2 /= 2;
       xNext = clip(
-        x.map((xi, i) => xi - alpha * g[i]),
+        x.map((xi, i) => xi - alpha2 * g[i]),
         lower,
         upper
       );
@@ -50572,7 +50863,10 @@ function lsqBounded(A, b, lower, upper, opts = {}) {
   return { x, residual: residualNorm(A, x, b) };
 }
 
-// src/cas/rational-integrate.ts
+// src/cas/layer3.ts
+import { eig as eig4 } from "@danielsimonjr/mathts-matrix";
+
+// src/cas/rat.ts
 function ratNormalize(num2, den) {
   if (den === 0n) {
     throw new Error("Rat: zero denominator");
@@ -50608,6 +50902,378 @@ function ratFromBigint(n) {
   return { num: n, den: 1n };
 }
 var RAT_ZERO = { num: 0n, den: 1n };
+
+// src/cas/layer3.ts
+function ratEq(a, b) {
+  return a.num === b.num && a.den === b.den;
+}
+function joinTerms(parts) {
+  if (parts.length === 0) return "0";
+  return parts.join(" + ").replace(/\+ -/g, "- ");
+}
+function renderCoeffTimes(r, rest) {
+  const neg2 = r.num < 0n;
+  const absNum = neg2 ? -r.num : r.num;
+  const sign3 = neg2 ? "-" : "";
+  if (absNum === r.den) return `${sign3}${rest}`;
+  const denPart = r.den === 1n ? "" : `/${r.den}`;
+  return `${sign3}${absNum}${denPart}*${rest}`;
+}
+function renderPoly(p, v) {
+  const t = trim(p);
+  if (t.length === 0) return "0";
+  const parts = [];
+  for (let i = t.length - 1; i >= 0; i -= 1) {
+    const c = t[i];
+    if (c === 0n) continue;
+    const sign3 = c < 0n ? "-" : parts.length === 0 ? "" : "+";
+    const abs2 = c < 0n ? -c : c;
+    let term;
+    if (i === 0) term = `${abs2}`;
+    else if (i === 1) term = abs2 === 1n ? v : `${abs2}*${v}`;
+    else term = abs2 === 1n ? `${v}^${i}` : `${abs2}*${v}^${i}`;
+    parts.push(parts.length === 0 && sign3 === "" ? term : `${sign3} ${term}`);
+  }
+  return parts.join(" ").replace(/^\+ /, "");
+}
+function detZ(matrix2) {
+  const n = matrix2.length;
+  if (n === 0) return 1n;
+  const a = matrix2.map((row2) => row2.slice());
+  let sign3 = 1n;
+  let prev = 1n;
+  for (let k = 0; k < n; k += 1) {
+    let pivot = k;
+    while (pivot < n && a[pivot][k] === 0n) pivot += 1;
+    if (pivot === n) return 0n;
+    if (pivot !== k) {
+      [a[k], a[pivot]] = [a[pivot], a[k]];
+      sign3 = -sign3;
+    }
+    if (k === n - 1) break;
+    for (let i = k + 1; i < n; i += 1) {
+      for (let j = k + 1; j < n; j += 1) {
+        a[i][j] = (a[i][j] * a[k][k] - a[i][k] * a[k][j]) / prev;
+      }
+    }
+    prev = a[k][k];
+  }
+  return sign3 * a[n - 1][n - 1];
+}
+function resultantZ(a, b) {
+  const ta = trim(a);
+  const tb = trim(b);
+  const m = ta.length - 1;
+  const n = tb.length - 1;
+  if (m < 0 || n < 0) return 0n;
+  if (m === 0 && n === 0) return 1n;
+  if (m === 0) return ta[0] ** BigInt(n);
+  if (n === 0) return tb[0] ** BigInt(m);
+  const dim = m + n;
+  const s = Array.from({ length: dim }, () => Array(dim).fill(0n));
+  for (let i = 0; i < n; i += 1) {
+    for (let j = 0; j <= m; j += 1) s[i][i + j] = ta[m - j];
+  }
+  for (let i = 0; i < m; i += 1) {
+    for (let j = 0; j <= n; j += 1) s[n + i][i + j] = tb[n - j];
+  }
+  return detZ(s);
+}
+function rothsteinResultant(A, B) {
+  const Bp = derivative(B);
+  const n = Math.max(degree(B), 0) + Math.max(degree(Bp), 0) + 2;
+  const samples = [];
+  for (let k = 0; k <= n; k += 1) {
+    const p = sub(A, scalarMul(Bp, BigInt(k)));
+    samples.push(resultantZ(p, B));
+  }
+  return interpolateAtIntegers(samples);
+}
+function interpolateAtIntegers(values) {
+  const n = values.length - 1;
+  const size2 = n + 1;
+  const matrix2 = [];
+  const rhs = [];
+  for (let k = 0; k < size2; k += 1) {
+    const row2 = [];
+    let pk = 1n;
+    for (let j = 0; j < size2; j += 1) {
+      row2.push(ratFromBigint(pk));
+      pk *= BigInt(k);
+    }
+    matrix2.push(row2);
+    rhs.push(ratFromBigint(values[k]));
+  }
+  const coeffs = solveLinearSystemRat(matrix2, rhs);
+  return trim(
+    coeffs.map((r) => {
+      if (r.den !== 1n) {
+        throw new Error("rothsteinResultant: non-integer interpolated coefficient");
+      }
+      return r.num;
+    })
+  );
+}
+function solveLinearSystemRat(matrix2, rhs) {
+  const n = rhs.length;
+  const a = matrix2.map((row2, i) => [...row2, rhs[i]]);
+  for (let col = 0; col < n; col += 1) {
+    let pivot = col;
+    while (pivot < n && a[pivot][col].num === 0n) pivot += 1;
+    if (pivot === n) throw new Error("singular Rat system");
+    if (pivot !== col) [a[col], a[pivot]] = [a[pivot], a[col]];
+    const pv = a[col][col];
+    for (let j = col; j <= n; j += 1) a[col][j] = ratDiv(a[col][j], pv);
+    for (let i = 0; i < n; i += 1) {
+      if (i === col) continue;
+      const f = a[i][col];
+      if (f.num === 0n) continue;
+      for (let j = col; j <= n; j += 1) a[i][j] = ratSub(a[i][j], ratMul(f, a[col][j]));
+    }
+  }
+  return a.map((row2) => row2[n]);
+}
+function intToRatPoly(p) {
+  return trim(p).map(ratFromBigint);
+}
+function ratPolyToInt(p) {
+  if (p.length === 0) return { poly: [], den: 1n };
+  let lcm2 = 1n;
+  const gcd2 = (a, b) => {
+    let x = a < 0n ? -a : a;
+    let y = b < 0n ? -b : b;
+    while (y !== 0n) {
+      const t = x % y;
+      x = y;
+      y = t;
+    }
+    return x;
+  };
+  for (const r of p) {
+    const g = gcd2(lcm2, r.den);
+    lcm2 = lcm2 / g * r.den;
+  }
+  return { poly: trim(p.map((r) => r.num * lcm2 / r.den)), den: lcm2 };
+}
+function rpAdd(a, b) {
+  const n = Math.max(a.length, b.length);
+  const out = [];
+  for (let i = 0; i < n; i += 1) {
+    out.push(ratAdd(a[i] ?? RAT_ZERO, b[i] ?? RAT_ZERO));
+  }
+  let m = out.length;
+  while (m > 0 && out[m - 1].num === 0n) m -= 1;
+  return out.slice(0, m);
+}
+function rpScale(p, s) {
+  if (s.num === 0n) return [];
+  return p.map((c) => ratMul(c, s));
+}
+function rpMul(a, b) {
+  if (a.length === 0 || b.length === 0) return [];
+  const out = Array.from({ length: a.length + b.length - 1 }, () => RAT_ZERO);
+  for (let i = 0; i < a.length; i += 1) {
+    if (a[i].num === 0n) continue;
+    for (let j = 0; j < b.length; j += 1) {
+      out[i + j] = ratAdd(out[i + j], ratMul(a[i], b[j]));
+    }
+  }
+  let m = out.length;
+  while (m > 0 && out[m - 1].num === 0n) m -= 1;
+  return out.slice(0, m);
+}
+function rpDerivative(p) {
+  if (p.length <= 1) return [];
+  const out = [];
+  for (let i = 1; i < p.length; i += 1) {
+    out.push(ratMul(p[i], ratFromBigint(BigInt(i))));
+  }
+  return out;
+}
+function hermiteReduce(R, Q2, v) {
+  const Q1 = polyGcdZ(Q2, derivative(Q2));
+  if (degree(Q1) <= 0) {
+    return { rational: "0", squareFreeNumer: trim(R), squareFreeDenom: trim(Q2) };
+  }
+  const Q22 = exactDivide(Q2, Q1);
+  if (Q22 === null) {
+    throw new Error("hermiteReduce: Q1 does not divide Q");
+  }
+  const Q1p = derivative(Q1);
+  const Wnum = mul(Q22, Q1p);
+  const Wdiv = exactDivide(Wnum, Q1);
+  let W;
+  if (Wdiv !== null) {
+    W = intToRatPoly(Wdiv);
+  } else {
+    W = ratPolyExactQuotient(intToRatPoly(Wnum), intToRatPoly(Q1));
+  }
+  const d1 = degree(Q1);
+  const d2 = degree(Q22);
+  const nP = Math.max(d1, 0);
+  const nS = Math.max(d2, 0);
+  const n = nP + nS;
+  const q2 = intToRatPoly(Q22);
+  const q1 = intToRatPoly(Q1);
+  const r = intToRatPoly(R);
+  const matrix2 = Array.from({ length: n }, () => Array(n).fill(RAT_ZERO));
+  const rhs = Array.from({ length: n }, () => RAT_ZERO);
+  for (let i = 0; i < r.length && i < n; i += 1) rhs[i] = r[i];
+  for (let k = 0; k < nP; k += 1) {
+    const Pk = Array.from({ length: k + 1 }, () => RAT_ZERO);
+    Pk[k] = { num: 1n, den: 1n };
+    const Pp = rpDerivative(Pk);
+    const term = rpAdd(rpMul(q2, Pp), rpScale(rpMul(W, Pk), ratFromBigint(-1n)));
+    for (let i = 0; i < term.length && i < n; i += 1) matrix2[i][k] = term[i];
+  }
+  for (let k = 0; k < nS; k += 1) {
+    const Sk = Array.from({ length: k + 1 }, () => RAT_ZERO);
+    Sk[k] = { num: 1n, den: 1n };
+    const term = rpMul(q1, Sk);
+    for (let i = 0; i < term.length && i < n; i += 1) matrix2[i][nP + k] = term[i];
+  }
+  const sol = solveLinearSystemRat(matrix2, rhs);
+  const P2 = sol.slice(0, nP);
+  const S = sol.slice(nP);
+  const Pint = ratPolyToInt(P2);
+  const Sint = ratPolyToInt(S);
+  const q1Scaled = Pint.den === 1n ? Q1 : scalarMul(Q1, Pint.den);
+  const rational = degree(Pint.poly) < 0 ? "0" : `(${renderPoly(Pint.poly, v)})/(${renderPoly(q1Scaled, v)})`;
+  const q2Scaled = Sint.den === 1n ? Q22 : scalarMul(Q22, Sint.den);
+  return { rational, squareFreeNumer: Sint.poly, squareFreeDenom: trim(q2Scaled) };
+}
+function ratPolyExactQuotient(a, b) {
+  const db = b.length - 1;
+  if (db < 0) throw new Error("ratPolyExactQuotient: zero divisor");
+  const lb = b[db];
+  let rem = a.slice();
+  const q = [];
+  while (rem.length - 1 >= db) {
+    const coeff = ratDiv(rem[rem.length - 1], lb);
+    const shift = rem.length - 1 - db;
+    while (q.length <= shift) q.push(RAT_ZERO);
+    q[shift] = coeff;
+    for (let i = 0; i <= db; i += 1) {
+      rem[shift + i] = ratSub(rem[shift + i] ?? RAT_ZERO, ratMul(coeff, b[i]));
+    }
+    let m = rem.length;
+    while (m > 0 && rem[m - 1].num === 0n) m -= 1;
+    rem = rem.slice(0, m);
+  }
+  if (rem.some((c) => c.num !== 0n)) {
+    throw new Error("ratPolyExactQuotient: nonzero remainder");
+  }
+  return q;
+}
+function evalPolyC(p, re3, im3) {
+  let r = 0;
+  let i = 0;
+  for (let k = p.length - 1; k >= 0; k -= 1) {
+    const c = Number(p[k]);
+    const nr = r * re3 - i * im3 + c;
+    const ni = r * im3 + i * re3;
+    r = nr;
+    i = ni;
+  }
+  return { re: r, im: i };
+}
+function companionRoots(B) {
+  const t = trim(B);
+  const n = t.length - 1;
+  if (n <= 0) return [];
+  const lead = Number(t[n]);
+  if (n === 1) {
+    return [{ re: -Number(t[0]) / lead, im: 0 }];
+  }
+  const m = Array.from({ length: n }, () => Array(n).fill(0));
+  for (let i = 1; i < n; i += 1) m[i][i - 1] = 1;
+  for (let j = 0; j < n; j += 1) m[0][j] = -Number(t[n - 1 - j]) / lead;
+  for (let i = 0; i < n; i += 1) m[i].fill(0);
+  for (let i = 0; i < n - 1; i += 1) m[i][i + 1] = 1;
+  for (let j = 0; j < n; j += 1) m[n - 1][j] = -Number(t[j]) / lead;
+  const { values } = eig4(m, { computeVectors: false });
+  return values;
+}
+function residueIntegral(A, B, v) {
+  const roots = companionRoots(B);
+  const Bp = derivative(B);
+  const used = new Array(roots.length).fill(false);
+  const parts = [];
+  const eps = 1e-10;
+  for (let i = 0; i < roots.length; i += 1) {
+    if (used[i]) continue;
+    const r = roots[i];
+    const Ar = evalPolyC(A, r.re, r.im);
+    const Bpr = evalPolyC(Bp, r.re, r.im);
+    const den = Bpr.re * Bpr.re + Bpr.im * Bpr.im;
+    if (den < 1e-30) continue;
+    const resRe = (Ar.re * Bpr.re + Ar.im * Bpr.im) / den;
+    const resIm = (Ar.im * Bpr.re - Ar.re * Bpr.im) / den;
+    if (Math.abs(r.im) < eps) {
+      used[i] = true;
+      if (Math.abs(resRe) < eps) continue;
+      const rootStr = Math.abs(r.re) < eps ? v : `${v} - (${r.re})`;
+      parts.push(`(${resRe})*log(abs(${rootStr}))`);
+      continue;
+    }
+    let j = -1;
+    for (let k = i + 1; k < roots.length; k += 1) {
+      if (!used[k] && Math.abs(roots[k].re - r.re) < 1e-8 && Math.abs(roots[k].im + r.im) < 1e-8) {
+        j = k;
+        break;
+      }
+    }
+    used[i] = true;
+    if (j >= 0) used[j] = true;
+    const a = r.re;
+    const b = r.im;
+    const quad2 = `(${v} - (${a}))^2 + (${b})^2`;
+    if (Math.abs(resRe) > eps) {
+      parts.push(`(${resRe})*log(${quad2})`);
+    }
+    if (Math.abs(resIm) > eps) {
+      parts.push(`(${-2 * resIm})*atan2(${-b}, ${v} - (${a}))`);
+    }
+  }
+  return joinTerms(parts);
+}
+function rothsteinTrager(A, B, v) {
+  try {
+    const R = rothsteinResultant(A, B);
+    if (degree(R) < 0) return "0";
+    const { factors } = factorUnivariateZ(R);
+    const allLinear = factors.every((f) => trim(f.poly).length - 1 === 1);
+    if (allLinear) {
+      const Bp = derivative(B);
+      const parts = [];
+      for (const { poly } of factors) {
+        const q = trim(poly);
+        if (q.length !== 2) continue;
+        const c = ratDiv(ratFromBigint(-q[0]), ratFromBigint(q[1]));
+        if (ratEq(c, RAT_ZERO)) continue;
+        const scaled = sub(scalarMul(A, c.den), scalarMul(Bp, c.num));
+        const g = polyGcdZ(scaled, B);
+        if (degree(g) < 1) continue;
+        parts.push(renderCoeffTimes(c, `log(${renderPoly(g, v)})`));
+      }
+      return joinTerms(parts);
+    }
+  } catch {
+  }
+  return residueIntegral(A, B, v);
+}
+function integrateLayer3(R, Q2, v) {
+  const { rational, squareFreeNumer, squareFreeDenom } = hermiteReduce(R, Q2, v);
+  const parts = [];
+  if (rational !== "0") parts.push(rational);
+  if (degree(squareFreeDenom) >= 1 && degree(squareFreeNumer) >= 0) {
+    const sf = rothsteinTrager(squareFreeNumer, squareFreeDenom, v);
+    if (sf !== "0") parts.push(sf);
+  }
+  return joinTerms(parts);
+}
+
+// src/cas/rational-integrate.ts
 function surdFromRat(r) {
   return { a: r, b: RAT_ZERO };
 }
@@ -50829,7 +51495,7 @@ function shiftedColumn(poly, shift, size2) {
   }
   return col;
 }
-function solveLinearSystemRat(matrix2, rhs) {
+function solveLinearSystemRat2(matrix2, rhs) {
   const n = rhs.length;
   const rows = matrix2.map((row2, r) => [...row2, rhs[r]]);
   for (let col = 0; col < n; col += 1) {
@@ -50906,7 +51572,7 @@ function partialFractions(remainder, factors) {
     rows.push(columns.map((col) => col[r]));
   }
   const rhs = new Array(n).fill(RAT_ZERO).map((_, idx2) => ratFromBigint(idx2 < trimmedRemainder.length ? trimmedRemainder[idx2] : 0n));
-  const solution = n === 0 ? [] : solveLinearSystemRat(rows, rhs);
+  const solution = n === 0 ? [] : solveLinearSystemRat2(rows, rhs);
   const terms = [];
   let idx = 0;
   for (let fi = 0; fi < factors.length; fi += 1) {
@@ -50928,7 +51594,7 @@ function ratNeg(r) {
 function ratToStr(r) {
   return r.den === 1n ? `${r.num}` : `${r.num}/${r.den}`;
 }
-function renderCoeffTimes(r, rest) {
+function renderCoeffTimes2(r, rest) {
   const neg2 = r.num < 0n;
   const absNum = neg2 ? -r.num : r.num;
   const sign3 = neg2 ? "-" : "";
@@ -50962,7 +51628,7 @@ function renderTwoXPlusB(b, v) {
   }
   return s;
 }
-function joinTerms(parts) {
+function joinTerms2(parts) {
   if (parts.length === 0) {
     return "0";
   }
@@ -50978,10 +51644,10 @@ function integrateLinearTerm(factor2, k, numer, v) {
   }
   const xMinus = renderXMinus(a, v);
   if (k === 1) {
-    return renderCoeffTimes(A, `log(abs(${xMinus}))`);
+    return renderCoeffTimes2(A, `log(abs(${xMinus}))`);
   }
   const coeff = ratNeg(ratDiv(A, ratFromBigint(BigInt(k - 1))));
-  return renderCoeffTimes(coeff, `(${xMinus})^(${-(k - 1)})`);
+  return renderCoeffTimes2(coeff, `(${xMinus})^(${-(k - 1)})`);
 }
 function integrateInverseQuadraticPower(k, b, c) {
   if (k === 1) {
@@ -51013,10 +51679,10 @@ function integrateQuadraticTerm(factor2, k, numer, v) {
   if (D.num !== 0n) {
     const half = ratDiv(D, ratFromBigint(2n));
     if (k === 1) {
-      parts.push(renderCoeffTimes(half, `log(${qCore})`));
+      parts.push(renderCoeffTimes2(half, `log(${qCore})`));
     } else {
       const coeff = ratNeg(ratDiv(half, ratFromBigint(BigInt(k - 1))));
-      parts.push(renderCoeffTimes(coeff, `(${qCore})^(${-(k - 1)})`));
+      parts.push(renderCoeffTimes2(coeff, `(${qCore})^(${-(k - 1)})`));
     }
   }
   if (K.num !== 0n) {
@@ -51026,15 +51692,15 @@ function integrateQuadraticTerm(factor2, k, numer, v) {
       if (coeff.num === 0n) {
         continue;
       }
-      parts.push(renderCoeffTimes(coeff, `(${twoXb})/(${qCore})^(${t.power})`));
+      parts.push(renderCoeffTimes2(coeff, `(${twoXb})/(${qCore})^(${t.power})`));
     }
     const atanCoeff = ratMul(ratMul(K, ik.atanCoeff), ratFromBigint(2n));
     if (atanCoeff.num !== 0n) {
       const d2s = ratToStr(d2);
-      parts.push(renderCoeffTimes(atanCoeff, `atan((${twoXb})/sqrt(${d2s}))/sqrt(${d2s})`));
+      parts.push(renderCoeffTimes2(atanCoeff, `atan((${twoXb})/sqrt(${d2s}))/sqrt(${d2s})`));
     }
   }
-  return joinTerms(parts);
+  return joinTerms2(parts);
 }
 function integrateQuadraticPosTerm(factor2, numer, v) {
   const c = factor2[0];
@@ -51064,7 +51730,7 @@ function integrateQuadraticPosTerm(factor2, numer, v) {
   };
   emit(A, r1);
   emit(B, r2);
-  return joinTerms(parts);
+  return joinTerms2(parts);
 }
 function integratePFTerm(term, v) {
   const factor2 = trim(term.factor);
@@ -51092,7 +51758,13 @@ function integrateRationalFunction(expr, v) {
     }
     const factors = factorDenominator(rf.denom);
     if (factors === null) {
-      return null;
+      const { quotient: quotient2, remainder: remainder2 } = polynomialPart(rf);
+      const parts2 = [];
+      const polyPart2 = integratePolynomial(quotient2, v);
+      if (polyPart2 !== "0") parts2.push(polyPart2);
+      const l3 = integrateLayer3(remainder2, rf.denom, v);
+      if (l3 !== "0") parts2.push(l3);
+      return joinTerms2(parts2);
     }
     const { quotient, remainder } = polynomialPart(rf);
     const terms = partialFractions(remainder, factors);
@@ -51118,8 +51790,11 @@ function integrateRationalFunction(expr, v) {
         parts.push(s);
       }
     }
-    return joinTerms(parts);
-  } catch {
+    return joinTerms2(parts);
+  } catch (err) {
+    if (typeof process !== "undefined" && process.env.MATHTS_DEBUG_L3) {
+      console.error("integrateRationalFunction declined:", err);
+    }
     return null;
   }
 }
@@ -51193,6 +51868,18 @@ function integrateNode(raw, x) {
             const k = evalConst(args[0].toString()) / a;
             return `${num(k)} * log(abs(${args[1].toString()}))`;
           }
+          const den = unwrap(args[1]);
+          if (den.type === "OperatorNode" && den.op === "*") {
+            const df = (den.args ?? []).map(unwrap);
+            const hasX = df.some((f) => f.type === "SymbolNode" && f.name === x);
+            const logF = df.find(
+              (f) => f.type === "FunctionNode" && (f.fn?.name === "log" || f.fn?.name === "ln") && unwrap((f.args ?? [])[0] ?? f).type === "SymbolNode" && unwrap((f.args ?? [])[0] ?? f).name === x
+            );
+            if (hasX && logF && df.length === 2) {
+              const k = evalConst(args[0].toString());
+              return k === 1 ? `log(log(${x}))` : `${num(k)} * log(log(${x}))`;
+            }
+          }
         }
         throw new NotIntegrable("general quotient");
       }
@@ -52046,7 +52733,7 @@ function fminbound(f, x1, x2) {
   let x = xf;
   let fx = f(x);
   let num2 = 1;
-  let fu = Infinity;
+  let fu;
   let ffulc = fx;
   let fnfc = fx;
   let xm = 0.5 * (a + b);
@@ -52306,7 +52993,7 @@ function wate(freq, fx, wtx, lband, jtype) {
   if (fx[lband] >= 1e-4) return wtx[lband] / freq;
   return wtx[lband];
 }
-function remezCore(des, grid, edge, wt, ngrid, nbands, iext, alpha, nfcns, itrmax) {
+function remezCore(des, grid, edge, wt, ngrid, nbands, iext, alpha2, nfcns, itrmax) {
   const size2 = ngrid + 2 * nfcns + 8;
   const a = new Array(size2).fill(0);
   const p = new Array(size2).fill(0);
@@ -52630,7 +53317,7 @@ function remezCore(des, grid, edge, wt, ngrid, nbands, iext, alpha, nfcns, itrma
       xt = (xt - bb) / aa;
       ft = Math.acos(xt) / TWOPI;
     }
-    let assigned = false;
+    let assigned;
     for (; ; ) {
       const xe = x[l];
       if (xt > xe) {
@@ -52661,14 +53348,14 @@ function remezCore(des, grid, edge, wt, ngrid, nbands, iext, alpha, nfcns, itrma
     if (nm1 >= 1) {
       for (let k = 1; k <= nm1; k++) dtemp += a[k + 1] * Math.cos(dnum * k);
     }
-    alpha[j] = 2 * dtemp + a[1];
+    alpha2[j] = 2 * dtemp + a[1];
   }
-  for (j = 2; j <= nfcns; j++) alpha[j] *= 2 / cn;
-  alpha[1] /= cn;
+  for (j = 2; j <= nfcns; j++) alpha2[j] *= 2 / cn;
+  alpha2[1] /= cn;
   if (kkk !== 1) {
-    p[1] = 2 * alpha[nfcns] * bb + alpha[nm1];
-    p[2] = 2 * aa * alpha[nfcns];
-    q[1] = alpha[nfcns - 2] - alpha[nfcns];
+    p[1] = 2 * alpha2[nfcns] * bb + alpha2[nm1];
+    p[2] = 2 * aa * alpha2[nfcns];
+    q[1] = alpha2[nfcns - 2] - alpha2[nfcns];
     for (j = 2; j <= nm1; j++) {
       if (j >= nm1) {
         aa *= 0.5;
@@ -52686,14 +53373,14 @@ function remezCore(des, grid, edge, wt, ngrid, nbands, iext, alpha, nfcns, itrma
       for (let k = 3; k <= jp1; k++) p[k] += aa * a[k - 1];
       if (j !== nm1) {
         for (let k = 1; k <= j; k++) q[k] = -a[k];
-        q[1] += alpha[nfcns - 1 - j];
+        q[1] += alpha2[nfcns - 1 - j];
       }
     }
-    for (j = 1; j <= nfcns; j++) alpha[j] = p[j];
+    for (j = 1; j <= nfcns; j++) alpha2[j] = p[j];
   }
   if (nfcns <= 3) {
-    alpha[nfcns + 1] = 0;
-    alpha[nfcns + 2] = 0;
+    alpha2[nfcns + 1] = 0;
+    alpha2[nfcns + 2] = 0;
   }
   return { status: 0, dev, niter };
 }
@@ -52727,7 +53414,7 @@ function remezExchange(numtaps, bands, desired, weight, type = "bandpass", maxit
   const des = new Array(wrksize + 2).fill(0);
   const grid = new Array(wrksize + 2).fill(0);
   const wt = new Array(wrksize + 2).fill(0);
-  const alpha = new Array(dimsize + 3).fill(0);
+  const alpha2 = new Array(dimsize + 3).fill(0);
   const iext = new Array(dimsize + 3).fill(0);
   let delf = gridDensity * nfcns;
   delf = 0.5 / delf;
@@ -52784,31 +53471,31 @@ function remezExchange(numtaps, bands, desired, weight, type = "bandpass", maxit
   const temp = (ngrid - 1) / nfcns;
   for (j = 1; j <= nfcns; j++) iext[j] = Math.floor((j - 1) * temp) + 1;
   iext[nfcns + 1] = ngrid;
-  const res = remezCore(des, grid, edge, wt, ngrid, numbands, iext, alpha, nfcns, maxiter);
+  const res = remezCore(des, grid, edge, wt, ngrid, numbands, iext, alpha2, nfcns, maxiter);
   if (res.status < 0) throw new Error("remez: Remez exchange failed to converge");
   const h = new Array(numtaps + 1).fill(0);
   const nz = nfcns + 1;
   const nm1 = nfcns - 1;
   if (neg2 <= 0) {
     if (nodd !== 0) {
-      for (j = 1; j <= nm1; j++) h[j] = 0.5 * alpha[nz - j];
-      h[nfcns] = alpha[1];
+      for (j = 1; j <= nm1; j++) h[j] = 0.5 * alpha2[nz - j];
+      h[nfcns] = alpha2[1];
     } else {
-      h[1] = 0.25 * alpha[nfcns];
-      for (j = 2; j <= nm1; j++) h[j] = 0.25 * (alpha[nz - j] + alpha[nfcns + 2 - j]);
-      h[nfcns] = 0.5 * alpha[1] + 0.25 * alpha[2];
+      h[1] = 0.25 * alpha2[nfcns];
+      for (j = 2; j <= nm1; j++) h[j] = 0.25 * (alpha2[nz - j] + alpha2[nfcns + 2 - j]);
+      h[nfcns] = 0.5 * alpha2[1] + 0.25 * alpha2[2];
     }
   } else {
     if (nodd !== 0) {
-      h[1] = 0.25 * alpha[nfcns];
-      h[2] = 0.25 * alpha[nm1];
-      for (j = 3; j <= nm1; j++) h[j] = 0.25 * (alpha[nz - j] - alpha[nfcns + 3 - j]);
-      h[nfcns] = 0.5 * alpha[1] - 0.25 * alpha[3];
+      h[1] = 0.25 * alpha2[nfcns];
+      h[2] = 0.25 * alpha2[nm1];
+      for (j = 3; j <= nm1; j++) h[j] = 0.25 * (alpha2[nz - j] - alpha2[nfcns + 3 - j]);
+      h[nfcns] = 0.5 * alpha2[1] - 0.25 * alpha2[3];
       h[nz] = 0;
     } else {
-      h[1] = 0.25 * alpha[nfcns];
-      for (j = 2; j <= nm1; j++) h[j] = 0.25 * (alpha[nz - j] - alpha[nfcns + 2 - j]);
-      h[nfcns] = 0.5 * alpha[1] - 0.25 * alpha[2];
+      h[1] = 0.25 * alpha2[nfcns];
+      for (j = 2; j <= nm1; j++) h[j] = 0.25 * (alpha2[nz - j] - alpha2[nfcns + 2 - j]);
+      h[nfcns] = 0.5 * alpha2[1] - 0.25 * alpha2[2];
     }
   }
   for (j = 1; j <= nfcns; j++) {
@@ -53040,7 +53727,7 @@ function idwt(approx, detail, wavelet = "haar") {
   try {
     return idwtPeriodization(approx, detail, wavelet);
   } catch (err) {
-    throw new Error(`idwt: ${err instanceof Error ? err.message : String(err)}`);
+    throw new Error(`idwt: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
   }
 }
 function wavedec(x, wavelet = "haar", level = 1) {
@@ -53770,10 +54457,10 @@ function circumradius(a, b, c) {
   const uy = (a2 * (c[0] - b[0]) + b2 * (a[0] - c[0]) + c2 * (b[0] - a[0])) / d;
   return Math.hypot(a[0] - ux, a[1] - uy);
 }
-function alphaShape(points, alpha) {
-  if (!(alpha > 0)) throw new Error("alphaShape: alpha must be positive");
+function alphaShape(points, alpha2) {
+  if (!(alpha2 > 0)) throw new Error("alphaShape: alpha must be positive");
   const { simplices: tris } = delaunay(points);
-  const threshold = 1 / alpha;
+  const threshold = 1 / alpha2;
   const triangles = [];
   const edgeCount = /* @__PURE__ */ new Map();
   for (const t of tris) {
@@ -54262,34 +54949,34 @@ function polygamma(n, x) {
 function trigamma(x) {
   return polygamma(1, x);
 }
-function jacobiP(n, alpha, beta2, x) {
+function jacobiP(n, alpha2, beta3, x) {
   if (!Number.isInteger(n) || n < 0) {
     throw new Error("jacobiP: n must be a nonnegative integer");
   }
   if (n === 0) return 1;
   let pPrev = 1;
-  let pCurr = alpha + 1 + (alpha + beta2 + 2) * (x - 1) / 2;
+  let pCurr = alpha2 + 1 + (alpha2 + beta3 + 2) * (x - 1) / 2;
   if (n === 1) return pCurr;
   for (let k = 2; k <= n; k++) {
-    const a1 = 2 * k * (k + alpha + beta2) * (2 * k + alpha + beta2 - 2);
-    const a2 = (2 * k + alpha + beta2 - 1) * ((2 * k + alpha + beta2) * (2 * k + alpha + beta2 - 2) * x + alpha * alpha - beta2 * beta2);
-    const a3 = 2 * (k + alpha - 1) * (k + beta2 - 1) * (2 * k + alpha + beta2);
+    const a1 = 2 * k * (k + alpha2 + beta3) * (2 * k + alpha2 + beta3 - 2);
+    const a2 = (2 * k + alpha2 + beta3 - 1) * ((2 * k + alpha2 + beta3) * (2 * k + alpha2 + beta3 - 2) * x + alpha2 * alpha2 - beta3 * beta3);
+    const a3 = 2 * (k + alpha2 - 1) * (k + beta3 - 1) * (2 * k + alpha2 + beta3);
     const pNext = (a2 * pCurr - a3 * pPrev) / a1;
     pPrev = pCurr;
     pCurr = pNext;
   }
   return pCurr;
 }
-function gegenbauerC(n, alpha, x) {
+function gegenbauerC(n, alpha2, x) {
   if (!Number.isInteger(n) || n < 0) {
     throw new Error("gegenbauerC: n must be a nonnegative integer");
   }
   if (n === 0) return 1;
   let cPrev = 1;
-  let cCurr = 2 * alpha * x;
+  let cCurr = 2 * alpha2 * x;
   if (n === 1) return cCurr;
   for (let k = 2; k <= n; k++) {
-    const cNext = (2 * x * (k + alpha - 1) * cCurr - (k + 2 * alpha - 2) * cPrev) / k;
+    const cNext = (2 * x * (k + alpha2 - 1) * cCurr - (k + 2 * alpha2 - 2) * cPrev) / k;
     cPrev = cCurr;
     cCurr = cNext;
   }
@@ -54318,7 +55005,7 @@ function rootsLegendre(n) {
   const weights = [];
   for (let i = 0; i < n; i++) {
     let x = Math.cos(Math.PI * (i + 0.75) / (n + 0.5));
-    let pn = 0;
+    let pn;
     let dpn = 0;
     for (let iter = 0; iter < NEWTON_MAX_ITERATIONS; iter++) {
       const [pCurr, pPrev] = legendrePair(n, x);
@@ -54675,7 +55362,7 @@ function coulombFG(L, eta, rho) {
 }
 
 // src/special/mathieu.ts
-import { eig as eig4 } from "@danielsimonjr/mathts-matrix";
+import { eig as eig5 } from "@danielsimonjr/mathts-matrix";
 var N = 50;
 function harmonicsFor(cls) {
   const h = new Int32Array(N);
@@ -54714,7 +55401,7 @@ function solveClass(cls, q) {
   const cached = modeCache.get(key2);
   if (cached) return cached;
   const harmonics = harmonicsFor(cls);
-  const { values, vectors } = eig4(buildMatrix(cls, q));
+  const { values, vectors } = eig5(buildMatrix(cls, q));
   const order = values.map((_, i) => i).sort((i, j) => values[i].re - values[j].re);
   const modes = order.map((idx, m) => {
     const g = vectors[idx];
@@ -54774,6 +55461,184 @@ function mathieuSe(n, q, x) {
   return evalSeries(solveClass(cls, q)[m], x, Math.sin);
 }
 
+// src/special/spheroidal.ts
+import { eig as eig6 } from "@danielsimonjr/mathts-matrix";
+var KMAX = 48;
+function checkMN(m, n, name254) {
+  if (!Number.isInteger(m) || m < 0) {
+    throw new Error(`${name254}: m must be a nonnegative integer`);
+  }
+  if (!Number.isInteger(n) || n < m) {
+    throw new Error(`${name254}: n must be an integer \u2265 m`);
+  }
+}
+function ferrersP(n, m, x) {
+  if (m < 0 || n < m) return 0;
+  const s = Math.max(0, 1 - x * x);
+  const somx2 = Math.sqrt(s);
+  let pmm = 1;
+  if (m > 0) {
+    let fact = 1;
+    for (let i = 1; i <= m; i += 1) {
+      pmm *= -fact * somx2;
+      fact += 2;
+    }
+  }
+  if (n === m) return pmm;
+  let pmmp1 = x * (2 * m + 1) * pmm;
+  if (n === m + 1) return pmmp1;
+  let pnn = pmmp1;
+  for (let nn = m + 2; nn <= n; nn += 1) {
+    pnn = ((2 * nn - 1) * x * pmmp1 - (nn + m - 1) * pmm) / (nn - m);
+    pmm = pmmp1;
+    pmmp1 = pnn;
+  }
+  return pnn;
+}
+function alpha(m, r, c2) {
+  const ell = m + r;
+  if (ell === 0 && m === 0) {
+    return c2 / 3;
+  }
+  const den = (2 * ell - 1) * (2 * ell + 3);
+  const extra = den === 0 ? 0 : c2 * (2 * ell * (ell + 1) - 2 * m * m - 1) / den;
+  return ell * (ell + 1) + extra;
+}
+function beta2(m, r, c2) {
+  const ell = m + r;
+  const den = (2 * ell + 3) * (2 * ell + 5);
+  if (den === 0) return 0;
+  return c2 * (ell + m + 1) * (ell + m + 2) / den;
+}
+function gammaCoeff(m, r, c2) {
+  const ell = m + r;
+  const den = (2 * ell - 3) * (2 * ell - 1);
+  if (den === 0) return 0;
+  return c2 * (ell - m) * (ell - m - 1) / den;
+}
+function solveParity(m, r0, c) {
+  const c2 = c * c;
+  const rs = [];
+  for (let r = r0; r < KMAX; r += 2) rs.push(r);
+  const N2 = rs.length;
+  const diag2 = new Float64Array(N2);
+  const off = new Float64Array(N2 - 1);
+  for (let i = 0; i < N2; i += 1) {
+    diag2[i] = alpha(m, rs[i], c2);
+    if (i < N2 - 1) {
+      const b = beta2(m, rs[i], c2);
+      const g = gammaCoeff(m, rs[i + 1], c2);
+      off[i] = Math.sign(b) * Math.sqrt(Math.abs(b * g));
+    }
+  }
+  const mat = Array.from({ length: N2 }, () => Array(N2).fill(0));
+  for (let i = 0; i < N2; i += 1) {
+    mat[i][i] = diag2[i];
+    if (i < N2 - 1) {
+      mat[i][i + 1] = off[i];
+      mat[i + 1][i] = off[i];
+    }
+  }
+  const { values, vectors } = eig6(mat);
+  const order = values.map((v, i) => ({ lam: v.re, i })).sort((a, b) => a.lam - b.lam);
+  return order.map(({ lam, i }) => {
+    const coeffs = new Float64Array(N2);
+    let nrm = 0;
+    for (let k = 0; k < N2; k += 1) {
+      coeffs[k] = vectors[k][i];
+      nrm += coeffs[k] * coeffs[k];
+    }
+    const s = Math.sqrt(nrm) || 1;
+    const sign3 = coeffs[0] < 0 ? -1 : 1;
+    for (let k = 0; k < N2; k += 1) coeffs[k] = sign3 * coeffs[k] / s;
+    return { lambda: lam, coeffs, r0 };
+  });
+}
+function modeFor(m, n, c) {
+  const N2 = n - m;
+  const r0 = N2 % 2;
+  const idx = Math.floor(N2 / 2);
+  const modes = solveParity(m, r0, c);
+  if (idx >= modes.length) {
+    throw new Error(`spheroidal: expansion too short for n=${n}, m=${m}`);
+  }
+  return modes[idx];
+}
+function spheroidalLambda(m, n, c) {
+  checkMN(m, n, "spheroidalLambda");
+  if (c === 0) return n * (n + 1);
+  return modeFor(m, n, c).lambda;
+}
+var spheroidalCharacteristic = spheroidalLambda;
+function spheroidalAngular(m, n, c, eta) {
+  checkMN(m, n, "spheroidalAngular");
+  if (!Number.isFinite(eta) || eta < -1 || eta > 1) {
+    throw new Error("spheroidalAngular: eta must lie in [-1, 1]");
+  }
+  if (c === 0) return ferrersP(n, m, eta);
+  const mode2 = modeFor(m, n, c);
+  let s = 0;
+  for (let i = 0; i < mode2.coeffs.length; i += 1) {
+    const r = mode2.r0 + 2 * i;
+    s += mode2.coeffs[i] * ferrersP(m + r, m, eta);
+  }
+  const ref = m === 0 ? 0 : 0.5;
+  const pref = ferrersP(n, m, ref);
+  let sref = 0;
+  for (let i = 0; i < mode2.coeffs.length; i += 1) {
+    const r = mode2.r0 + 2 * i;
+    sref += mode2.coeffs[i] * ferrersP(m + r, m, ref);
+  }
+  if (Math.abs(sref) < 1e-18 || Math.abs(pref) < 1e-18) return s;
+  return s * (pref / sref);
+}
+function spheroidalRadial(m, n, c, xi) {
+  checkMN(m, n, "spheroidalRadial");
+  if (!Number.isFinite(xi) || xi < 1) {
+    throw new Error("spheroidalRadial: xi must be \u2265 1");
+  }
+  return spheroidalAngularContinued(m, n, c, xi);
+}
+function ferrersPContinued(n, m, x) {
+  const somx2 = x * x >= 1 ? Math.sqrt(x * x - 1) : Math.sqrt(1 - x * x);
+  let pmm = 1;
+  if (m > 0) {
+    let fact = 1;
+    for (let i = 1; i <= m; i += 1) {
+      pmm *= fact * somx2;
+      fact += 2;
+    }
+  }
+  if (n === m) return pmm;
+  let pmmp1 = x * (2 * m + 1) * pmm;
+  if (n === m + 1) return pmmp1;
+  let pnn = pmmp1;
+  for (let nn = m + 2; nn <= n; nn += 1) {
+    pnn = ((2 * nn - 1) * x * pmmp1 - (nn + m - 1) * pmm) / (nn - m);
+    pmm = pmmp1;
+    pmmp1 = pnn;
+  }
+  return pnn;
+}
+function spheroidalAngularContinued(m, n, c, x) {
+  if (c === 0) return ferrersPContinued(n, m, x);
+  const mode2 = modeFor(m, n, c);
+  let s = 0;
+  for (let i = 0; i < mode2.coeffs.length; i += 1) {
+    const r = mode2.r0 + 2 * i;
+    s += mode2.coeffs[i] * ferrersPContinued(m + r, m, x);
+  }
+  const ref = 1.2;
+  const pref = ferrersPContinued(n, m, ref);
+  let sref = 0;
+  for (let i = 0; i < mode2.coeffs.length; i += 1) {
+    const r = mode2.r0 + 2 * i;
+    sref += mode2.coeffs[i] * ferrersPContinued(m + r, m, ref);
+  }
+  if (Math.abs(sref) < 1e-18 || Math.abs(pref) < 1e-18) return s;
+  return s * (pref / sref);
+}
+
 // src/graph/traversal-centrality.ts
 function bfs(adj, start) {
   const n = adj.length;
@@ -54997,7 +55862,10 @@ function minCut(capacity, source, sink) {
 }
 function astar(adj, start, goal, heuristic) {
   const n = adj.length;
-  if (start < 0 || start >= n || goal < 0 || goal >= n) {
+  if (!Array.isArray(adj) || !Number.isInteger(n) || n < 0) {
+    throw new Error("astar: adjacency must be a square number[][]");
+  }
+  if (!Number.isInteger(start) || !Number.isInteger(goal) || start < 0 || start >= n || goal < 0 || goal >= n) {
     throw new Error("astar: start or goal out of bounds");
   }
   if (start === goal) {
@@ -55032,7 +55900,8 @@ function astar(adj, start, goal, heuristic) {
     return { path: [], cost: Infinity };
   }
   const path = [];
-  for (let v = goal; v !== -1; v = cameFrom[v]) {
+  for (let v = goal, guard = 0; v !== -1 && guard <= n; v = cameFrom[v], guard += 1) {
+    if (!Number.isInteger(v) || v < 0 || v >= n) break;
     path.unshift(v);
     if (v === start) break;
   }
@@ -55432,14 +56301,14 @@ function _solveLinearSystem(A, b) {
   }
   return M.map((row2) => row2[n]);
 }
-function katzCentrality(adj, alpha, beta2 = 1) {
+function katzCentrality(adj, alpha2, beta3 = 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])
+    (_, i) => Array.from({ length: n }, (_2, j) => (i === j ? 1 : 0) - alpha2 * adj[j][i])
   );
-  const b = new Array(n).fill(beta2);
+  const b = new Array(n).fill(beta3);
   const x = _solveLinearSystem(M, b);
   let sum3 = 0;
   let sumSq = 0;
@@ -55571,7 +56440,7 @@ function glm(X, y, opts) {
   const tol = opts.tol ?? 1e-10;
   const maxIter = opts.maxIter ?? 100;
   let eta = family.mustart(y).map((mu2) => linkFns.linkFn(mu2));
-  let beta2 = new Array(p).fill(0);
+  let beta3 = new Array(p).fill(0);
   let iterations = 0;
   for (let iter = 0; iter < maxIter; iter++) {
     iterations = iter + 1;
@@ -55608,7 +56477,7 @@ function glm(X, y, opts) {
     const newEta = design.map((row2) => row2.reduce((s, v, j) => s + v * newBeta[j], 0));
     let maxDiff = 0;
     for (let i = 0; i < n; i++) maxDiff = Math.max(maxDiff, Math.abs(newEta[i] - eta[i]));
-    beta2 = newBeta;
+    beta3 = newBeta;
     eta = newEta;
     if (maxDiff < tol) break;
   }
@@ -55616,9 +56485,9 @@ function glm(X, y, opts) {
   const deviance = y.reduce((sum3, yi, i) => sum3 + family.deviance(yi, mu[i]), 0);
   const predict = (x) => {
     const Dx = useIntercept ? x.map((row2) => [1, ...row2]) : x.map((row2) => [...row2]);
-    return Dx.map((row2) => linkFns.linkInv(row2.reduce((s, v, j) => s + v * beta2[j], 0)));
+    return Dx.map((row2) => linkFns.linkInv(row2.reduce((s, v, j) => s + v * beta3[j], 0)));
   };
-  return { coefficients: beta2, fittedValues: mu, deviance, iterations, predict };
+  return { coefficients: beta3, fittedValues: mu, deviance, iterations, predict };
 }
 
 // src/stats/mvn.ts
@@ -55683,22 +56552,22 @@ function mvnSample(mean7, cov2, n, opts) {
 }
 
 // src/stats/power-analysis.ts
-function powerAt(effectSize, nobs, alpha, alt) {
+function powerAt(effectSize, nobs, alpha2, alt) {
   const df = 2 * (nobs - 1);
   const nc = effectSize * Math.sqrt(nobs / 2);
   if (alt === "larger") {
-    const tCrit2 = studentTQuantile(1 - alpha, df);
+    const tCrit2 = studentTQuantile(1 - alpha2, df);
     return 1 - noncentralTCDF(tCrit2, df, nc);
   }
   if (alt === "smaller") {
-    const tCrit2 = studentTQuantile(alpha, df);
+    const tCrit2 = studentTQuantile(alpha2, df);
     return noncentralTCDF(tCrit2, df, nc);
   }
-  const tCrit = studentTQuantile(1 - alpha / 2, df);
+  const tCrit = studentTQuantile(1 - alpha2 / 2, df);
   return 1 - noncentralTCDF(tCrit, df, nc) + noncentralTCDF(-tCrit, df, nc);
 }
-function tTestPower(effectSize, nobsOrPower, alpha, opts = {}) {
-  if (!(alpha > 0 && alpha < 1)) throw new Error("tTestPower: alpha must be in (0, 1)");
+function tTestPower(effectSize, nobsOrPower, alpha2, opts = {}) {
+  if (!(alpha2 > 0 && alpha2 < 1)) throw new Error("tTestPower: alpha must be in (0, 1)");
   const alt = opts.alternative ?? "two-sided";
   if (opts.solveFor === "nobs") {
     const targetPower = nobsOrPower;
@@ -55708,19 +56577,19 @@ function tTestPower(effectSize, nobsOrPower, alpha, opts = {}) {
     if (effectSize === 0) throw new Error("tTestPower: cannot solve for nobs when effectSize is 0");
     let lo = 2 + 1e-9;
     let hi = 1e7;
-    if (powerAt(effectSize, hi, alpha, alt) < targetPower) {
+    if (powerAt(effectSize, hi, alpha2, alt) < targetPower) {
       throw new Error("tTestPower: target power unreachable even at nobs = 1e7");
     }
     for (let it = 0; it < 200; it++) {
       const mid = (lo + hi) / 2;
-      if (powerAt(effectSize, mid, alpha, alt) < targetPower) lo = mid;
+      if (powerAt(effectSize, mid, alpha2, alt) < targetPower) lo = mid;
       else hi = mid;
     }
     return (lo + hi) / 2;
   }
   const nobs = nobsOrPower;
   if (!(nobs > 1)) throw new Error("tTestPower: nobs must be greater than 1");
-  return powerAt(effectSize, nobs, alpha, alt);
+  return powerAt(effectSize, nobs, alpha2, alt);
 }
 
 // src/stats/gaussian-process.ts
@@ -55856,29 +56725,29 @@ function gaussianProcessRegression(X, y, options = {}) {
 var gpRegression = gaussianProcessRegression;
 
 // src/stats/multivariate-sampling.ts
-function validateAlpha(alpha, fn) {
-  if (!Array.isArray(alpha) || alpha.length < 2) {
+function validateAlpha(alpha2, fn) {
+  if (!Array.isArray(alpha2) || alpha2.length < 2) {
     throw new Error(`${fn}: alpha must be an array of at least 2 concentration parameters`);
   }
-  for (const a of alpha) {
+  for (const a of alpha2) {
     if (!(a > 0) || !Number.isFinite(a)) {
       throw new Error(`${fn}: all concentration parameters must be positive and finite`);
     }
   }
 }
-function dirichletSample(alpha, n = 1, opts) {
-  validateAlpha(alpha, "dirichletSample");
+function dirichletSample(alpha2, n = 1, opts) {
+  validateAlpha(alpha2, "dirichletSample");
   if (!Number.isInteger(n) || n < 1) {
     throw new Error("dirichletSample: n must be a positive integer");
   }
-  const k = alpha.length;
+  const k = alpha2.length;
   const rng = createRng(opts?.seed ?? null);
   const samples = new Array(n);
   for (let s = 0; s < n; s++) {
     const g = new Array(k);
     let total = 0;
     for (let i = 0; i < k; i++) {
-      const gi = gammaSampleRng(alpha[i], rng);
+      const gi = gammaSampleRng(alpha2[i], rng);
       g[i] = gi;
       total += gi;
     }
@@ -55888,10 +56757,10 @@ function dirichletSample(alpha, n = 1, opts) {
   }
   return samples;
 }
-function dirichletPdf(x, alpha) {
-  validateAlpha(alpha, "dirichletPdf");
-  if (x.length !== alpha.length) {
-    throw new Error(`dirichletPdf: x length ${x.length} must match alpha length ${alpha.length}`);
+function dirichletPdf(x, alpha2) {
+  validateAlpha(alpha2, "dirichletPdf");
+  if (x.length !== alpha2.length) {
+    throw new Error(`dirichletPdf: x length ${x.length} must match alpha length ${alpha2.length}`);
   }
   let sum3 = 0;
   for (const xi of x) {
@@ -55905,7 +56774,7 @@ function dirichletPdf(x, alpha) {
   }
   let a0 = 0;
   let logB = 0;
-  for (const a of alpha) {
+  for (const a of alpha2) {
     logB += lgammaNumber(a);
     a0 += a;
   }
@@ -55913,7 +56782,7 @@ function dirichletPdf(x, alpha) {
   let logpdf = -logB;
   for (let i = 0; i < x.length; i++) {
     const xi = x[i];
-    const p = alpha[i] - 1;
+    const p = alpha2[i] - 1;
     if (p !== 0) {
       logpdf += p * Math.log(xi);
     }
@@ -56359,6 +57228,7 @@ export {
   fallingFactorial,
   faraday,
   fermiCoupling,
+  ferrersP,
   fft,
   fft2d,
   fftGpuDispatch,
@@ -56916,9 +57786,14 @@ export {
   spearman,
   spearmanr,
   spectralClustering,
+  spectralRadiance,
   spectrogram,
   speedOfLight,
   sphericalVoronoi,
+  spheroidalAngular,
+  spheroidalCharacteristic,
+  spheroidalLambda,
+  spheroidalRadial,
   splitUnit,
   sqrt,
   sqrtm,