@danielsimonjr/mathts-functions 0.52.0 → 0.54.0

package/dist/index.js

@@ -439,8 +439,10 @@ __export(typed_exports, {
   smaller: () => smaller,
   smallerEq: () => smallerEq,
   solveBVP: () => solveBVP,
+  solveDAE: () => solveDAE,
   solveODESystem: () => solveODESystem,
   solvePDE: () => solvePDE,
+  solveParabolicPDE: () => solveParabolicPDE,
   spectrogram: () => spectrogram,
   sqrt: () => sqrt,
   square: () => square,
@@ -13106,6 +13108,405 @@ function quad(f, a, b, opts) {
   return panel(a, b, 0);
 }
 
+// src/numeric/solveParabolicPDE.ts
+function asSpaceFn(c, dflt) {
+  if (c === void 0) return () => dflt;
+  return typeof c === "function" ? c : () => c;
+}
+function asTimeFn(g) {
+  return typeof g === "function" ? g : () => g;
+}
+function solveParabolicPDE(options) {
+  const { x0, x1, T, nx, u0, bcLeft, bcRight } = options;
+  if (!(nx >= 3) || !Number.isInteger(nx)) {
+    throw new Error("solveParabolicPDE: nx must be an integer \u2265 3");
+  }
+  if (!(x1 > x0)) {
+    throw new Error("solveParabolicPDE: require x1 > x0");
+  }
+  if (!(T > 0)) {
+    throw new Error("solveParabolicPDE: require T > 0");
+  }
+  const h = (x1 - x0) / (nx - 1);
+  const D = asSpaceFn(options.diffusion, 0);
+  const c = asSpaceFn(options.advection, 0);
+  const f = options.source ?? (() => 0);
+  const gL = asTimeFn(bcLeft.value);
+  const gR = asTimeFn(bcRight.value);
+  const x = new Array(nx);
+  for (let i = 0; i < nx; i++) x[i] = x0 + i * h;
+  const leftDirichlet = bcLeft.type === "dirichlet";
+  const rightDirichlet = bcRight.type === "dirichlet";
+  const freeIdx = [];
+  if (!leftDirichlet) freeIdx.push(0);
+  for (let i = 1; i < nx - 1; i++) freeIdx.push(i);
+  if (!rightDirichlet) freeIdx.push(nx - 1);
+  const m = freeIdx.length;
+  const reconstruct = (t, U) => {
+    const full = new Array(nx);
+    if (leftDirichlet) full[0] = gL(t);
+    if (rightDirichlet) full[nx - 1] = gR(t);
+    for (let s = 0; s < m; s++) full[freeIdx[s]] = U[s];
+    return full;
+  };
+  const rhs = (t, U) => {
+    const full = reconstruct(t, U);
+    const out = new Array(m);
+    for (let s = 0; s < m; s++) {
+      const i = freeIdx[s];
+      const xi = x[i];
+      let uxx;
+      let ux;
+      if (i === 0) {
+        const g = gL(t);
+        uxx = (2 * full[1] - 2 * full[0] - 2 * h * g) / (h * h);
+        ux = g;
+      } else if (i === nx - 1) {
+        const g = gR(t);
+        uxx = (2 * full[nx - 2] - 2 * full[nx - 1] + 2 * h * g) / (h * h);
+        ux = g;
+      } else {
+        uxx = (full[i - 1] - 2 * full[i] + full[i + 1]) / (h * h);
+        ux = (full[i + 1] - full[i - 1]) / (2 * h);
+      }
+      out[s] = D(xi) * uxx + c(xi) * ux + f(xi, t, full[i]);
+    }
+    return out;
+  };
+  const y0 = freeIdx.map((i) => u0(x[i]));
+  const bdfOptions = {};
+  if (options.tol !== void 0) bdfOptions.tol = options.tol;
+  else bdfOptions.tol = 1e-6;
+  if (options.maxStep !== void 0) bdfOptions.maxStep = options.maxStep;
+  const sol = bdfSolve(rhs, [0, T], y0, bdfOptions);
+  const stepT = sol.t;
+  const stepY = sol.y;
+  const requested = options.times;
+  if (requested === void 0) {
+    return { x, t: stepT.slice(), u: stepT.map((tk, k) => reconstruct(tk, stepY[k])) };
+  }
+  const u = requested.map((tq) => {
+    const U = interpState(stepT, stepY, tq);
+    return reconstruct(tq, U);
+  });
+  return { x, t: requested.slice(), u };
+}
+function interpState(stepT, stepY, tq) {
+  const n = stepT.length;
+  if (tq <= stepT[0]) return stepY[0].slice();
+  if (tq >= stepT[n - 1]) return stepY[n - 1].slice();
+  let lo = 0;
+  let hi = n - 1;
+  while (hi - lo > 1) {
+    const mid = lo + hi >> 1;
+    if (stepT[mid] <= tq) lo = mid;
+    else hi = mid;
+  }
+  const t0 = stepT[lo];
+  const t1 = stepT[lo + 1];
+  const w = t1 === t0 ? 0 : (tq - t0) / (t1 - t0);
+  const y0 = stepY[lo];
+  const y1 = stepY[lo + 1];
+  return y0.map((v, i) => v + w * (y1[i] - v));
+}
+
+// src/numeric/solveDAE.ts
+function _arr(v) {
+  return Array.isArray(v) ? v.slice() : [v];
+}
+function _evalArr(fn, t, y, z) {
+  const r = fn(t, y, z);
+  return Array.isArray(r) ? r : [r];
+}
+function _wrms(v, scale4) {
+  let s = 0;
+  for (let i = 0; i < v.length; i++) {
+    const q = v[i] / scale4[i];
+    s += q * q;
+  }
+  return Math.sqrt(s / v.length);
+}
+function _bdfCoeffs(nodes) {
+  const m = nodes.length;
+  const x0 = nodes[0];
+  const c = new Array(m).fill(0);
+  let diag2 = 0;
+  for (let p = 1; p < m; p++) diag2 += 1 / (x0 - nodes[p]);
+  c[0] = diag2;
+  for (let j = 1; j < m; j++) {
+    let val = 1 / (nodes[j] - x0);
+    for (let p = 0; p < m; p++) {
+      if (p === 0 || p === j) continue;
+      val *= (x0 - nodes[p]) / (nodes[j] - nodes[p]);
+    }
+    c[j] = val;
+  }
+  return c;
+}
+function _polyExtrap(times, vals, tnew) {
+  const p = times.length;
+  const n = vals[0].length;
+  const out = new Array(n).fill(0);
+  for (let i = 0; i < p; i++) {
+    let li = 1;
+    for (let m = 0; m < p; m++) {
+      if (m === i) continue;
+      li *= (tnew - times[m]) / (times[i] - times[m]);
+    }
+    for (let d = 0; d < n; d++) out[d] += li * vals[i][d];
+  }
+  return out;
+}
+function _denseSolve(A, b) {
+  const n = b.length;
+  const M = A.map((r) => r.slice());
+  const x = b.slice();
+  for (let k = 0; k < n; k++) {
+    let piv = k;
+    for (let i = k + 1; i < n; i++) if (Math.abs(M[i][k]) > Math.abs(M[piv][k])) piv = i;
+    if (Math.abs(M[piv][k]) < 1e-300) return new Array(n).fill(NaN);
+    [M[k], M[piv]] = [M[piv], M[k]];
+    [x[k], x[piv]] = [x[piv], x[k]];
+    const akk = M[k][k];
+    for (let i = k + 1; i < n; i++) {
+      const factor2 = M[i][k] / akk;
+      for (let j = k; j < n; j++) M[i][j] -= factor2 * M[k][j];
+      x[i] -= factor2 * x[k];
+    }
+  }
+  for (let i = n - 1; i >= 0; i--) {
+    let s = x[i];
+    for (let j = i + 1; j < n; j++) s -= M[i][j] * x[j];
+    x[i] = s / M[i][i];
+  }
+  return x;
+}
+function _solveAlgebraic(g, t, y, zGuess, tol) {
+  const na = zGuess.length;
+  const z = zGuess.slice();
+  for (let iter = 0; iter < 50; iter++) {
+    const g0 = _evalArr(g, t, y, z);
+    if (g0.length !== na) {
+      throw new Error(
+        `solveDAE: the constraint g must return ${na} value(s) (matching z0); got ${g0.length}`
+      );
+    }
+    const J = Array.from({ length: na }, () => new Array(na));
+    for (let j = 0; j < na; j++) {
+      const eps = Math.max(1e-8, 1e-7 * Math.abs(z[j]));
+      const zp = z.slice();
+      zp[j] += eps;
+      const gp = _evalArr(g, t, y, zp);
+      for (let i = 0; i < na; i++) J[i][j] = (gp[i] - g0[i]) / eps;
+    }
+    const dz = _denseSolve(
+      J,
+      g0.map((v) => -v)
+    );
+    if (!dz.every((v) => Number.isFinite(v))) return null;
+    let znorm = 0;
+    let dnorm = 0;
+    for (let i = 0; i < na; i++) {
+      z[i] += dz[i];
+      znorm += z[i] * z[i];
+      dnorm += dz[i] * dz[i];
+    }
+    if (Math.sqrt(dnorm) <= tol * (1 + Math.sqrt(znorm))) {
+      const gCheck = _evalArr(g, t, y, z);
+      const res = Math.sqrt(gCheck.reduce((a, v) => a + v * v, 0));
+      return res < 1e-6 ? z : null;
+    }
+  }
+  return null;
+}
+function solveDAE(f, g, tspan, y0, z0, options = {}) {
+  const t0 = tspan[0];
+  const tf = tspan[1];
+  if (!(typeof t0 === "number" && typeof tf === "number")) {
+    throw new Error("solveDAE: tspan must be [t0, T] numbers");
+  }
+  if (!(tf > t0)) {
+    throw new Error("solveDAE: require T > t0 (forward integration)");
+  }
+  const yScalar = !Array.isArray(y0);
+  const zScalar = z0 === void 0 || !Array.isArray(z0);
+  const y0v = _arr(y0);
+  const z0v = z0 === void 0 ? [0] : _arr(z0);
+  const nd = y0v.length;
+  const na = z0v.length;
+  const n = nd + na;
+  const rtol = options.tol ?? 1e-6;
+  const atol = options.atol ?? rtol * 1e-3;
+  const maxOrder = options.maxOrder ?? 2;
+  const maxIter = options.maxIter ?? 1e5;
+  const maxStep = options.maxStep ?? Infinity;
+  const minStepOpt = options.minStep ?? 0;
+  const EPS5 = Number.EPSILON;
+  const newtonTol = options.newtonTol ?? Math.max(10 * EPS5 / rtol, Math.min(0.03, Math.sqrt(rtol)));
+  const span = tf - t0;
+  const yOf = (w2) => w2.slice(0, nd);
+  const zOf = (w2) => w2.slice(nd);
+  const z0consistent = _solveAlgebraic(g, t0, y0v, z0v, newtonTol);
+  if (z0consistent === null) {
+    throw new Error(
+      "solveDAE: could not solve g(t0, y0, z0) = 0 for a consistent z0 \u2014 \u2202g/\u2202z appears singular. The DAE is not semi-explicit index-1 (index-1 requires \u2202g/\u2202z nonsingular)."
+    );
+  }
+  let t = t0;
+  let w = [...y0v, ...z0consistent];
+  const histT = [t];
+  const histW = [w.slice()];
+  const tOut = [t];
+  const yOut = [yOf(w)];
+  const zOut = [zOf(w)];
+  let h;
+  if (options.firstStep !== void 0) {
+    h = Math.abs(options.firstStep);
+  } else {
+    const f0 = _evalArr(f, t0, y0v, z0consistent);
+    const nrm = (v) => Math.sqrt(v.reduce((a, x) => a + x * x, 0) / Math.max(1, v.length));
+    const d0 = nrm(y0v);
+    const d1 = nrm(f0);
+    h = Math.min(d0 < 1e-5 || d1 < 1e-5 ? 1e-3 : 0.01 * (d0 / d1), span);
+  }
+  h = Math.min(h, maxStep);
+  function makeResidual(tNew, c0, histSum) {
+    return (wc) => {
+      const y = yOf(wc);
+      const z = zOf(wc);
+      const fv = _evalArr(f, tNew, y, z);
+      const gv = _evalArr(g, tNew, y, z);
+      if (fv.length !== nd) {
+        throw new Error(`solveDAE: f must return ${nd} value(s) (matching y0); got ${fv.length}`);
+      }
+      if (gv.length !== na) {
+        throw new Error(`solveDAE: g must return ${na} value(s) (matching z0); got ${gv.length}`);
+      }
+      const R = new Array(n);
+      for (let i = 0; i < nd; i++) R[i] = c0 * wc[i] + histSum[i] - fv[i];
+      for (let i = 0; i < na; i++) R[nd + i] = gv[i];
+      return R;
+    };
+  }
+  function newtonMatrix(tNew, wc, c0, residual, R0) {
+    if (options.jacobian) {
+      const { fy, fz, gy, gz } = options.jacobian(tNew, yOf(wc), zOf(wc));
+      const J2 = Array.from({ length: n }, () => new Array(n).fill(0));
+      for (let i = 0; i < nd; i++) {
+        for (let j = 0; j < nd; j++) J2[i][j] = (i === j ? c0 : 0) - fy[i][j];
+        for (let j = 0; j < na; j++) J2[i][nd + j] = -fz[i][j];
+      }
+      for (let i = 0; i < na; i++) {
+        for (let j = 0; j < nd; j++) J2[nd + i][j] = gy[i][j];
+        for (let j = 0; j < na; j++) J2[nd + i][nd + j] = gz[i][j];
+      }
+      return J2;
+    }
+    const J = Array.from({ length: n }, () => new Array(n));
+    for (let col = 0; col < n; col++) {
+      const eps = Math.max(1e-8, 1e-7 * Math.abs(wc[col]));
+      const wp = wc.slice();
+      wp[col] += eps;
+      const Rp = residual(wp);
+      for (let row2 = 0; row2 < n; row2++) J[row2][col] = (Rp[row2] - R0[row2]) / eps;
+    }
+    return J;
+  }
+  let iter = 0;
+  while (t < tf && iter < maxIter) {
+    iter++;
+    if (t + h > tf) h = tf - t;
+    const minStep = Math.max(minStepOpt, 1e-13 * Math.max(1, Math.abs(t)));
+    const order = Math.max(1, Math.min(maxOrder, histT.length - 1));
+    let accepted = false;
+    let wNew = w;
+    let acceptedTime = t;
+    while (!accepted) {
+      if (h < minStep) {
+        throw new Error(
+          "solveDAE: required step size fell below the minimum \u2014 the Newton iteration is not converging. The system may be higher-index (\u2202g/\u2202z singular) or the tolerance too tight."
+        );
+      }
+      const tNew = t + h;
+      const nodes = [tNew];
+      for (let j = 0; j < order; j++) nodes.push(histT[j]);
+      const coeffs = _bdfCoeffs(nodes);
+      const c0 = coeffs[0];
+      const histSum = new Array(nd).fill(0);
+      for (let j = 1; j <= order; j++) {
+        const cj = coeffs[j];
+        const wj = histW[j - 1];
+        for (let i = 0; i < nd; i++) histSum[i] += cj * wj[i];
+      }
+      const residual = makeResidual(tNew, c0, histSum);
+      let wPred;
+      if (histT.length >= order + 1) {
+        wPred = _polyExtrap(histT.slice(0, order + 1), histW.slice(0, order + 1), tNew);
+      } else {
+        wPred = w.slice();
+        const fn = _evalArr(f, histT[0], yOf(w), zOf(w));
+        for (let i = 0; i < nd; i++) wPred[i] = w[i] + h * fn[i];
+      }
+      const wc = wPred.slice();
+      let converged = false;
+      const scale4 = new Array(n);
+      for (let it = 0; it < 12; it++) {
+        const R0 = residual(wc);
+        const J = newtonMatrix(tNew, wc, c0, residual, R0);
+        const solve2 = _factorSolver(J, n);
+        const dw = solve2(R0.map((v) => -v));
+        if (!dw.every((v) => Number.isFinite(v))) break;
+        for (let i = 0; i < n; i++) {
+          wc[i] += dw[i];
+          scale4[i] = atol + rtol * Math.abs(wc[i]);
+        }
+        if (_wrms(dw, scale4) <= newtonTol) {
+          converged = true;
+          break;
+        }
+      }
+      if (!converged) {
+        h *= 0.5;
+        continue;
+      }
+      for (let i = 0; i < n; i++) scale4[i] = atol + rtol * Math.abs(wc[i]);
+      const errNorm = _wrms(
+        wc.map((v, i) => v - wPred[i]),
+        scale4
+      );
+      if (errNorm <= 1 || h <= minStep) {
+        wNew = wc;
+        acceptedTime = tNew;
+        accepted = true;
+      }
+      const factor2 = errNorm === 0 ? 4 : 0.9 * Math.pow(errNorm, -1 / (order + 1));
+      h *= Math.min(4, Math.max(0.2, factor2));
+      if (h > maxStep) h = maxStep;
+    }
+    w = wNew;
+    t = acceptedTime;
+    histT.unshift(t);
+    histW.unshift(w.slice());
+    if (histT.length > maxOrder + 2) {
+      histT.pop();
+      histW.pop();
+    }
+    tOut.push(t);
+    yOut.push(yOf(w));
+    zOut.push(zOf(w));
+  }
+  if (iter >= maxIter) {
+    throw new Error(
+      "solveDAE: maximum number of steps reached \u2014 try loosening tol or raising maxIter"
+    );
+  }
+  return {
+    t: tOut,
+    y: yScalar ? yOut.map((v) => v[0]) : yOut,
+    z: zScalar ? zOut.map((v) => v[0]) : zOut
+  };
+}
+
 // src/typed/numeric.ts
 var NUMERIC_WASM_THRESHOLD = 16;
 function findRoot(f, a, b, opts) {
@@ -54239,9 +54640,11 @@ export {
   solve,
   solveBVP,
   solveBanded,
+  solveDAE,
   solveODE,
   solveODESystem,
   solvePDE,
+  solveParabolicPDE,
   sort,
   sosfilt,
   sparse,

package/dist/numeric/solveDAE.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Semi-explicit index-1 differential-algebraic equation (DAE) solver via BDF.
+ *
+ * Solves the semi-explicit index-1 system
+ *
+ *     y' = f(t, y, z)      (differential variables y)
+ *     0  = g(t, y, z)      (algebraic constraint z)
+ *
+ * on `t ∈ [t0, T]`. "Index-1" means the algebraic Jacobian block `∂g/∂z` is
+ * **nonsingular**, so the constraint `g = 0` locally determines `z` from
+ * `(t, y)`; this is exactly the condition that makes the coupled per-step
+ * Newton system solvable.
+ *
+ * ## Method — variable-step, variable-order (1–2) BDF with a combined Newton step
+ *
+ * The differential derivative is discretised with a Backward Differentiation
+ * Formula (the same BDF family that backs {@link bdfSolve}): on the last `k`
+ * accepted times plus the new time `t_{n+1}`, the interpolating polynomial's
+ * derivative at `t_{n+1}` is `Σ_j c_j·w_{n+1-j}` (variable-step coefficients
+ * `c_j` from the Lagrange-basis derivative, so BDF1/BDF2 work on a non-uniform
+ * grid). Each step then solves the **combined** nonlinear system for the new
+ * `w_{n+1} = (y_{n+1}, z_{n+1})`
+ *
+ *     differential rows:  c_0·y_{n+1} + (history) − f(t_{n+1}, y_{n+1}, z_{n+1}) = 0
+ *     algebraic rows:     g(t_{n+1}, y_{n+1}, z_{n+1}) = 0
+ *
+ * by Newton's method. The Newton (iteration) matrix is the block
+ *
+ *     ⎡ c_0·I − ∂f/∂y     − ∂f/∂z ⎤
+ *     ⎣    ∂g/∂y            ∂g/∂z  ⎦
+ *
+ * (finite-differenced from the residual by default, or built from analytic
+ * blocks supplied via `options.jacobian`) and is LU-solved through the shared
+ * matrix-package factorisation ({@link _factorSolver}). The index-1 condition
+ * (`∂g/∂z` nonsingular) is exactly what makes this matrix nonsingular, so a
+ * **higher-index** input is detected as a singular Jacobian and reported
+ * (it is not silently integrated to garbage).
+ *
+ * Adaptive step size uses a predictor/corrector local-error estimate (the
+ * corrector minus a lower-order extrapolation predictor), scaled by the usual
+ * `atol + rtol·|w|` weights.
+ *
+ * ## Consistent initial values
+ *
+ * The initial algebraic value `z0` is treated as a **guess**: the solver runs
+ * Newton on `g(t0, y0, z0) = 0` to land on the constraint manifold before the
+ * first step (so a slightly-off or omitted `z0` is corrected rather than
+ * silently propagated). If that Newton fails / `∂g/∂z` is singular at `t0`,
+ * the problem is not index-1 and an error is thrown.
+ *
+ * Plain-number state only (the Jacobian and linear solves are numeric).
+ *
+ * @packageDocumentation
+ */
+/** Differential forcing `y' = f(t, y, z)`. Returns the `y'` vector (a scalar is accepted for 1-D y). */
+export type DAEDifferential = (t: number, y: number[], z: number[]) => number[] | number;
+/** Algebraic constraint `0 = g(t, y, z)`. Returns the residual vector (a scalar is accepted for 1-D z). */
+export type DAEConstraint = (t: number, y: number[], z: number[]) => number[] | number;
+/**
+ * Analytic Jacobian blocks of the DAE at `(t, y, z)`, supplied via
+ * {@link SolveDAEOptions.jacobian} in place of the default finite differences.
+ * Each block is a matrix in the usual `[row][col]` convention:
+ * `fy[i][j] = ∂fᵢ/∂yⱼ`, `fz[i][j] = ∂fᵢ/∂zⱼ`, `gy`, `gz` likewise.
+ */
+export interface DAEJacobianBlocks {
+    fy: number[][];
+    fz: number[][];
+    gy: number[][];
+    gz: number[][];
+}
+/** Options for {@link solveDAE}. */
+export interface SolveDAEOptions {
+    /** Relative tolerance for the local-error step control (default `1e-6`). */
+    tol?: number;
+    /** Absolute tolerance (default `tol · 1e-3`). */
+    atol?: number;
+    /** Initial step size (default: chosen from `‖f‖`). */
+    firstStep?: number;
+    /** Minimum step size (a hard floor; the solver throws if it must go below it). */
+    minStep?: number;
+    /** Maximum step size (default: no cap). */
+    maxStep?: number;
+    /** Maximum number of accepted steps (default `1e5`). */
+    maxIter?: number;
+    /** Maximum BDF order, 1 or 2 (default `2`). */
+    maxOrder?: 1 | 2;
+    /** Newton convergence tolerance on the scaled increment (default derived from `tol`). */
+    newtonTol?: number;
+    /**
+     * Analytic Jacobian blocks `(t, y, z) => { fy, fz, gy, gz }`. When given they
+     * replace the default finite-difference Newton matrix (faster + more accurate).
+     */
+    jacobian?: (t: number, y: number[], z: number[]) => DAEJacobianBlocks;
+}
+/**
+ * Solution returned by {@link solveDAE}.
+ *
+ * `y`/`z` are `number[][]` (one state vector per time) when the corresponding
+ * initial value was an array, and unwrapped to `number[]` when it was a scalar.
+ */
+export interface DAESolution {
+    /** Accepted output times, `t[0] = t0`, last entry `= T`. */
+    t: number[];
+    /** Differential state at each time. */
+    y: number[][] | number[];
+    /** Algebraic state at each time. */
+    z: number[][] | number[];
+}
+/**
+ * Solve the semi-explicit index-1 DAE `y' = f(t, y, z)`, `0 = g(t, y, z)` on
+ * `[tspan[0], tspan[1]]` with a variable-step BDF(1–2) integrator and a coupled
+ * Newton solve for `(y, z)` at each step.
+ *
+ * @param f      Differential forcing `f(t, y, z) → y'`.
+ * @param g      Algebraic constraint `g(t, y, z) → 0`.
+ * @param tspan  `[t0, T]` (forward integration; `T > t0`).
+ * @param y0     Initial differential state (scalar or vector).
+ * @param z0     Initial algebraic guess (scalar or vector). Refined to satisfy
+ *               `g(t0, y0, z0) = 0` before the first step. Defaults to `[0]`.
+ * @param options See {@link SolveDAEOptions}.
+ * @returns `{ t, y, z }` — `y`/`z` are unwrapped to `number[]` when the matching
+ *          initial value was a scalar, else `number[][]`.
+ *
+ * @example
+ * // RC circuit: C·V' = i, i·R = Vs − V  (semi-explicit, index-1)
+ * // with C=R=Vs=1, V(0)=0 → V = 1 − e^{−t}, i = e^{−t}
+ * const sol = solveDAE(
+ *   (t, y, z) => [z[0]],                 // V' = i
+ *   (t, y, z) => [z[0] - (1 - y[0])],    // i − (Vs − V) = 0
+ *   [0, 3], 0, 1,
+ * );
+ */
+export declare function solveDAE(f: DAEDifferential, g: DAEConstraint, tspan: [number, number] | number[], y0: number | number[], z0?: number | number[], options?: SolveDAEOptions): DAESolution;
+//# sourceMappingURL=solveDAE.d.ts.map

package/dist/numeric/solveDAE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solveDAE.d.ts","sourceRoot":"","sources":["../../src/numeric/solveDAE.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAIH,wGAAwG;AACxG,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,GAAG,MAAM,CAAC;AAEzF,2GAA2G;AAC3G,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,GAAG,MAAM,CAAC;AAEvF;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC;IACf,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC;IACf,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC;IACf,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC;CAChB;AAED,oCAAoC;AACpC,MAAM,WAAW,eAAe;IAC9B,4EAA4E;IAC5E,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kFAAkF;IAClF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2CAA2C;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,wDAAwD;IACxD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IACjB,yFAAyF;IACzF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,iBAAiB,CAAC;CACvE;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,4DAA4D;IAC5D,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,uCAAuC;IACvC,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,CAAC;IACzB,oCAAoC;IACpC,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,CAAC;CAC1B;AAiJD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,eAAe,EAClB,CAAC,EAAE,aAAa,EAChB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,EAAE,EAClC,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,EACrB,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,EACtB,OAAO,GAAE,eAAoB,GAC5B,WAAW,CAwPb"}

package/dist/numeric/solveODE.d.ts

@@ -54,6 +54,23 @@ interface ODEOptions {
  * Forcing function type for ODE
  */
 type ForcingFunction = (t: MathNumericType, y: MathNumericType | MathArray) => MathNumericType | MathArray;
+/**
+ * Return a solver for `A·x = b` reused across the 3–6 right-hand sides a single stiff step solves
+ * against the same iteration matrix (W for Rosenbrock, E for RODAS).
+ *
+ * Small systems (n < {@link LU_ROUTE_THRESHOLD}) use the allocation-light inline elimination.
+ * Large systems factor `A` **once** with the matrix `lu()` primitive (per
+ * project-two-decomposition-layers-prefer-matrix) and solve each RHS with `luSolve` — one O(n³)
+ * factorisation instead of the old inline's re-factorisation per RHS.
+ *
+ * Numerics are unchanged on the small path (identical inline code) and, on the large path, the
+ * matrix `lu()` uses the same partial-pivoting strategy and elimination arithmetic, so results
+ * match to rounding (well within the solver's `tol`). The one edge case — a singular iteration
+ * matrix — made the inline solve emit NaN/Inf (division by zero), which fails the embedded error
+ * test and rejects the step (h is then reduced); the matrix `lu()` throws "singular" instead, so
+ * we catch it and return a NaN vector to preserve that step-rejection behaviour.
+ */
+export declare function _factorSolver(A: number[][], n: number): (b: number[]) => number[];
 /**
  * Rosenbrock stiff ODE solver — the linearly-implicit ode23s method (Shampine & Reichelt),
  * L-stable, with an embedded error estimate for adaptive stepping. Unlike the explicit RK23/RK45

package/dist/numeric/solveODE.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"solveODE.d.ts","sourceRoot":"","sources":["../../src/numeric/solveODE.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"solveODE.d.ts","sourceRoot":"","sources":["../../src/numeric/solveODE.ts"],"names":[],"mappings":"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"}

package/dist/numeric/solveParabolicPDE.d.ts

@@ -0,0 +1,100 @@
+/**
+ * General 1-D parabolic PDE solver via the method of lines (MOL).
+ *
+ * Solves
+ *
+ *     u_t = D(x)·u_xx + c(x)·u_x + f(x, t, u)
+ *
+ * on `x ∈ [x0, x1]`, `t ∈ [0, T]`, with initial condition `u(x,0) = u0(x)` and
+ * Dirichlet or Neumann boundary conditions at each end.
+ *
+ * The spatial domain is discretised on a uniform grid of `nx` points (spacing
+ * `h`). The second derivative uses the standard central second difference
+ * `u_xx ≈ (u_{i-1} − 2u_i + u_{i+1})/h²` and the first derivative the central
+ * difference `u_x ≈ (u_{i+1} − u_{i-1})/(2h)` — both second-order accurate, so
+ * the scheme converges as `O(h²)` in space. This semi-discretisation turns the
+ * PDE into a **stiff** ODE system `U'(t) = RHS(t, U)` in the nodal values (the
+ * diffusion term gives the Jacobian eigenvalues ≈ −D/h², very stiff for fine
+ * grids), which is integrated with the variable-order BDF stiff solver
+ * ({@link bdfSolve}) — implicit, so there is no explicit-Euler CFL step cap.
+ *
+ * This is a NEW public entry point; the legacy explicit-Euler heat-only
+ * {@link solvePDE} is intentionally left unchanged.
+ *
+ * @packageDocumentation
+ */
+/** A spatially-varying coefficient `D(x)` / `c(x)`; a plain number means constant. */
+export type SpaceCoefficient = number | ((x: number) => number);
+/** A time-varying boundary datum `g(t)`; a plain number means constant in time. */
+export type BoundaryDatum = number | ((t: number) => number);
+/**
+ * Boundary condition at one end of the domain.
+ * - `dirichlet`: prescribes the value `u = g(t)`.
+ * - `neumann`: prescribes the spatial derivative `u_x = g(t)` (a second-order
+ *   ghost-node closure is used so overall `O(h²)` accuracy is preserved).
+ */
+export interface ParabolicBC {
+    type: 'dirichlet' | 'neumann';
+    value: BoundaryDatum;
+}
+/** Reaction / source term `f(x, t, u)`. */
+export type ParabolicSource = (x: number, t: number, u: number) => number;
+/** Options for {@link solveParabolicPDE}. */
+export interface SolveParabolicPDEOptions {
+    /** Diffusion coefficient `D(x)` (constant if a number). Must be > 0 for a well-posed problem. */
+    diffusion: SpaceCoefficient;
+    /** Advection coefficient `c(x)` in `c(x)·u_x` (default 0 — pure diffusion/reaction). */
+    advection?: SpaceCoefficient;
+    /** Reaction/source `f(x, t, u)` (default 0). */
+    source?: ParabolicSource;
+    /** Left domain endpoint. */
+    x0: number;
+    /** Right domain endpoint (`x1 > x0`). */
+    x1: number;
+    /** Final integration time (`T > 0`). */
+    T: number;
+    /** Number of grid points including both boundaries (`nx ≥ 3`). Spacing `h = (x1−x0)/(nx−1)`. */
+    nx: number;
+    /** Initial condition `u0(x)`. */
+    u0: (x: number) => number;
+    /** Left (`x = x0`) boundary condition. */
+    bcLeft: ParabolicBC;
+    /** Right (`x = x1`) boundary condition. */
+    bcRight: ParabolicBC;
+    /** Relative tolerance for the BDF integrator (default 1e-6). */
+    tol?: number;
+    /** Maximum BDF step size (default: no cap). */
+    maxStep?: number;
+    /**
+     * Explicit output times at which to report the solution (each in `[0, T]`).
+     * When omitted the solver's own accepted time steps are returned (the last is
+     * exactly `T`). When given, the free-node states are linearly interpolated
+     * between accepted steps and the boundary nodes evaluated exactly at each time.
+     */
+    times?: number[];
+}
+/** Solution returned by {@link solveParabolicPDE}. */
+export interface ParabolicPDESolution {
+    /** The `nx` spatial grid points. */
+    x: number[];
+    /** The output times (length `nt`). */
+    t: number[];
+    /** Solution values `u[timeIndex][spaceIndex]`, full grid including boundary nodes. */
+    u: number[][];
+}
+/**
+ * Solve the general 1-D parabolic PDE `u_t = D(x)·u_xx + c(x)·u_x + f(x, t, u)`
+ * by the method of lines onto the BDF stiff ODE solver.
+ *
+ * @example
+ * // Heat equation u_t = u_xx, u(x,0)=sin(πx), Dirichlet 0 → u = e^{−π²t} sin(πx)
+ * const sol = solveParabolicPDE({
+ *   diffusion: 1, x0: 0, x1: 1, T: 0.1, nx: 81,
+ *   u0: (x) => Math.sin(Math.PI * x),
+ *   bcLeft: { type: 'dirichlet', value: 0 },
+ *   bcRight: { type: 'dirichlet', value: 0 },
+ * });
+ * // sol.u[sol.t.length - 1] ≈ e^{−π²·0.1} sin(πx)
+ */
+export declare function solveParabolicPDE(options: SolveParabolicPDEOptions): ParabolicPDESolution;
+//# sourceMappingURL=solveParabolicPDE.d.ts.map

package/dist/numeric/solveParabolicPDE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solveParabolicPDE.d.ts","sourceRoot":"","sources":["../../src/numeric/solveParabolicPDE.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,sFAAsF;AACtF,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,CAAC,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;AAEhE,mFAAmF;AACnF,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,CAAC,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;AAE7D;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,WAAW,GAAG,SAAS,CAAC;IAC9B,KAAK,EAAE,aAAa,CAAC;CACtB;AAED,2CAA2C;AAC3C,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;AAE1E,6CAA6C;AAC7C,MAAM,WAAW,wBAAwB;IACvC,iGAAiG;IACjG,SAAS,EAAE,gBAAgB,CAAC;IAC5B,wFAAwF;IACxF,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,gDAAgD;IAChD,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,4BAA4B;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,yCAAyC;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,wCAAwC;IACxC,CAAC,EAAE,MAAM,CAAC;IACV,gGAAgG;IAChG,EAAE,EAAE,MAAM,CAAC;IACX,iCAAiC;IACjC,EAAE,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAC1B,0CAA0C;IAC1C,MAAM,EAAE,WAAW,CAAC;IACpB,2CAA2C;IAC3C,OAAO,EAAE,WAAW,CAAC;IACrB,gEAAgE;IAChE,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,+CAA+C;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,sDAAsD;AACtD,MAAM,WAAW,oBAAoB;IACnC,oCAAoC;IACpC,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,sCAAsC;IACtC,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,sFAAsF;IACtF,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;CACf;AAaD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,GAAG,oBAAoB,CA8FzF"}

package/dist/typed/numeric.d.ts

@@ -10,6 +10,8 @@
  *
  * @packageDocumentation
  */
+export { solveParabolicPDE, type SolveParabolicPDEOptions, type ParabolicPDESolution, type ParabolicBC, type SpaceCoefficient, type BoundaryDatum, type ParabolicSource, } from '../numeric/solveParabolicPDE.js';
+export { solveDAE, type SolveDAEOptions, type DAESolution, type DAEDifferential, type DAEConstraint, type DAEJacobianBlocks, } from '../numeric/solveDAE.js';
 type f64 = number;
 type i32 = number;
 /**
@@ -435,5 +437,4 @@ export declare function solvePDE(pde: {
     x: number[];
     u: number[];
 };
-export {};
 //# sourceMappingURL=numeric.d.ts.map

package/dist/typed/numeric.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"numeric.d.ts","sourceRoot":"","sources":["../../src/typed/numeric.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"numeric.d.ts","sourceRoot":"","sources":["../../src/typed/numeric.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-functions",
-  "version": "0.52.0",
+  "version": "0.54.0",
   "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
   "author": "Daniel Simon Jr.",
   "license": "MIT",