@danielsimonjr/mathts-functions 0.53.0 → 0.55.0

package/dist/index.js

@@ -439,6 +439,8 @@ __export(typed_exports, {
   smaller: () => smaller,
   smallerEq: () => smallerEq,
   solveBVP: () => solveBVP,
+  solveDAE: () => solveDAE,
+  solveDDE: () => solveDDE,
   solveODESystem: () => solveODESystem,
   solvePDE: () => solvePDE,
   solveParabolicPDE: () => solveParabolicPDE,
@@ -13209,6 +13211,469 @@ function interpState(stepT, stepY, tq) {
   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/numeric/solveDDE.ts
+function _arr2(v) {
+  return Array.isArray(v) ? v.slice() : [v];
+}
+function _hermite2(ta, tb, ya, yb, fa, fb, t) {
+  const h = tb - ta;
+  const theta = h === 0 ? 0 : (t - ta) / h;
+  const th2 = theta * theta;
+  const th3 = th2 * theta;
+  const h00 = 2 * th3 - 3 * th2 + 1;
+  const h10 = th3 - 2 * th2 + theta;
+  const h01 = -2 * th3 + 3 * th2;
+  const h11 = th3 - th2;
+  return ya.map((_, i) => h00 * ya[i] + h10 * h * fa[i] + h01 * yb[i] + h11 * h * fb[i]);
+}
+function _wrms2(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);
+}
+var _BS23_B = [2 / 9, 1 / 3, 4 / 9, 0];
+var _BS23_BP = [7 / 24, 1 / 4, 1 / 3, 1 / 8];
+var _BS23_DB = _BS23_B.map((b, i) => b - _BS23_BP[i]);
+function solveDDE(f, tspan, history, delays, options = {}) {
+  const t0 = tspan[0];
+  const tf = tspan[1];
+  if (!(typeof t0 === "number" && typeof tf === "number")) {
+    throw new Error("solveDDE: tspan must be [t0, T] numbers");
+  }
+  if (!(tf > t0)) {
+    throw new Error("solveDDE: require T > t0 (forward integration)");
+  }
+  if (!Array.isArray(delays) || delays.length === 0) {
+    throw new Error("solveDDE: at least one delay \u03C4 must be given");
+  }
+  if (!delays.every((d) => typeof d === "number" && d > 0)) {
+    throw new Error("solveDDE: every delay \u03C4 must be a positive number");
+  }
+  const histFn = typeof history === "function" ? (s) => _arr2(history(s)) : () => _arr2(history);
+  const y0raw = typeof history === "function" ? history(t0) : history;
+  const yScalar = !Array.isArray(y0raw);
+  const y0 = _arr2(y0raw);
+  const n = y0.length;
+  const minTau = Math.min(...delays);
+  const rtol = options.tol ?? 1e-6;
+  const atol = options.atol ?? rtol * 1e-3;
+  const maxIter = options.maxIter ?? 1e5;
+  const maxStep = options.maxStep ?? Infinity;
+  const minStepOpt = options.minStep ?? 0;
+  const Ts = [t0];
+  const Ys = [y0.slice()];
+  const Fs = [];
+  function _locate(s) {
+    let lo = 0;
+    let hi = Ts.length - 1;
+    if (s <= Ts[0]) return 0;
+    if (s >= Ts[hi]) return hi - 1;
+    while (hi - lo > 1) {
+      const mid = lo + hi >> 1;
+      if (Ts[mid] <= s) lo = mid;
+      else hi = mid;
+    }
+    return lo;
+  }
+  function delayedState(s) {
+    if (s <= t0) return histFn(s);
+    const i = _locate(s);
+    return _hermite2(Ts[i], Ts[i + 1], Ys[i], Ys[i + 1], Fs[i], Fs[i + 1], s);
+  }
+  function fEval(t2, y2) {
+    const yd = delays.map((tau2) => delayedState(t2 - tau2));
+    const r = f(t2, y2, yd);
+    const out = Array.isArray(r) ? r : [r];
+    if (out.length !== n) {
+      throw new Error(
+        `solveDDE: f must return ${n} value(s) (matching the state); got ${out.length}`
+      );
+    }
+    return out;
+  }
+  function nextBreakpoint(t2) {
+    let best = Infinity;
+    for (const tau2 of delays) {
+      let m = Math.floor((t2 - t0) / tau2) + 1;
+      let cand = t0 + m * tau2;
+      while (cand <= t2 + 1e-12 * Math.max(1, Math.abs(t2))) {
+        m += 1;
+        cand = t0 + m * tau2;
+      }
+      if (cand < best) best = cand;
+    }
+    return best;
+  }
+  Fs[0] = fEval(t0, y0);
+  const rms = (v) => Math.sqrt(v.reduce((a, x) => a + x * x, 0) / Math.max(1, v.length));
+  let h;
+  if (options.firstStep !== void 0) {
+    h = Math.abs(options.firstStep);
+  } else {
+    const d0 = rms(y0);
+    const d1 = rms(Fs[0]);
+    h = d0 < 1e-5 || d1 < 1e-5 ? 1e-6 : 0.01 * (d0 / d1);
+  }
+  h = Math.min(h, minTau, maxStep, tf - t0);
+  let t = t0;
+  let y = y0.slice();
+  let f0 = Fs[0];
+  let iter = 0;
+  while (t < tf && iter < maxIter) {
+    iter += 1;
+    const nb = nextBreakpoint(t);
+    let hmax = Math.min(minTau, maxStep, tf - t);
+    if (nb < tf) hmax = Math.min(hmax, nb - t);
+    if (h > hmax) h = hmax;
+    const minStep = Math.max(minStepOpt, 1e-13 * Math.max(1, Math.abs(t)));
+    if (h < minStep) h = Math.min(minStep, hmax);
+    const k1 = f0;
+    const k2 = fEval(
+      t + 0.5 * h,
+      y.map((yi, i) => yi + 0.5 * h * k1[i])
+    );
+    const k3 = fEval(
+      t + 0.75 * h,
+      y.map((yi, i) => yi + 0.75 * h * k2[i])
+    );
+    const yNew = y.map(
+      (yi, i) => yi + h * (_BS23_B[0] * k1[i] + _BS23_B[1] * k2[i] + _BS23_B[2] * k3[i])
+    );
+    const k4 = fEval(t + h, yNew);
+    const scale4 = y.map((yi, i) => atol + rtol * Math.max(Math.abs(yi), Math.abs(yNew[i])));
+    const err = yNew.map(
+      (_, i) => h * (_BS23_DB[0] * k1[i] + _BS23_DB[1] * k2[i] + _BS23_DB[2] * k3[i] + _BS23_DB[3] * k4[i])
+    );
+    const errNorm = _wrms2(err, scale4);
+    if (errNorm <= 1 || h <= minStep) {
+      t += h;
+      y = yNew;
+      f0 = k4;
+      Ts.push(t);
+      Ys.push(y.slice());
+      Fs.push(f0);
+    }
+    const factor2 = errNorm === 0 ? 5 : 0.9 * Math.pow(errNorm, -1 / 3);
+    h *= Math.min(5, Math.max(0.2, factor2));
+  }
+  if (iter >= maxIter) {
+    throw new Error(
+      "solveDDE: maximum number of steps reached \u2014 try loosening tol or raising maxIter"
+    );
+  }
+  const yInterp = (tq) => {
+    const s = tq <= t0 ? t0 : tq >= t ? t : tq;
+    const i = _locate(s);
+    const val = _hermite2(Ts[i], Ts[i + 1], Ys[i], Ys[i + 1], Fs[i], Fs[i + 1], s);
+    return yScalar ? val[0] : val;
+  };
+  return {
+    t: Ts,
+    y: yScalar ? Ys.map((v) => v[0]) : Ys,
+    yInterp
+  };
+}
+
 // src/typed/numeric.ts
 var NUMERIC_WASM_THRESHOLD = 16;
 function findRoot(f, a, b, opts) {
@@ -54342,6 +54807,8 @@ export {
   solve,
   solveBVP,
   solveBanded,
+  solveDAE,
+  solveDDE,
   solveODE,
   solveODESystem,
   solvePDE,

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/solveDDE.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Constant-delay delay differential equation (DDE) solver via the method of steps.
+ *
+ * Solves
+ *
+ *     y'(t) = f(t, y(t), [y(t−τ₁), y(t−τ₂), …])      on t ∈ [t0, T]
+ *
+ * with a **history function** `φ(t)` giving `y(t)` for `t ≤ t0` (the initial state
+ * is `y(t0) = φ(t0)`). The `τ_k` are fixed positive **constant delays**.
+ *
+ * ## Method — method of steps + continuous extension (Bellen–Zennaro)
+ *
+ * The system is integrated with the adaptive **BS23** (Bogacki–Shampine 3(2))
+ * embedded Runge–Kutta pair — the same explicit pair MATLAB's `dde23` uses. At each
+ * RK stage the delayed argument `y(t − τ_k)` is obtained from
+ *
+ *  - the **history function** `φ` when `t − τ_k ≤ t0`, or
+ *  - a **cubic-Hermite dense-output interpolant** of the already-computed solution
+ *    otherwise (a C¹, O(h⁴) continuous extension built from the stored per-step
+ *    `(t, y, y')` data — consistent with BS23's order).
+ *
+ * ### The step cap (standard MOS constraint)
+ *
+ * Each step is **capped at `h ≤ min(τ)`**. With that cap every delayed argument
+ * `t_stage − τ_k` lies in `[t0, t_n]` (already-accepted history), so the delayed
+ * value is always available and the method stays fully **explicit** — no implicit
+ * coupling of the current step to itself. Adaptive error control still chooses `h`
+ * freely within that cap.
+ *
+ * ### Discontinuity propagation
+ *
+ * `y'` is generically discontinuous at `t0` (the history need not satisfy the DDE),
+ * and that low-order discontinuity propagates to `t0 + τ_k`, `t0 + 2τ_k`, …. The
+ * integrator **lands exactly on each `t0 + m·τ_k` breakpoint** (the step is trimmed
+ * so it never *crosses* one), so no dense-output interval straddles a derivative
+ * jump and the smoothing order increases past each breakpoint as it should.
+ *
+ * Plain-number state only (the interpolation and error norms are numeric).
+ *
+ * @packageDocumentation
+ */
+/**
+ * Forcing function `y'(t) = f(t, y, yDelayed)`.
+ * - `y` is the current state (`number[]`; a length-1 array for a scalar DDE).
+ * - `yDelayed[k]` is `y(t − τ_k)` in the same shape as `y`, one entry per delay.
+ * Returns the derivative vector (a bare number is accepted for a scalar DDE).
+ */
+export type DDEForcing = (t: number, y: number[], yDelayed: number[][]) => number[] | number;
+/**
+ * History `φ(t)` giving `y(t)` for `t ≤ t0`. Either a function `(t) => state`
+ * (state as `number[]` or scalar `number`), or a constant (`number` / `number[]`)
+ * used for all `t ≤ t0`. The initial state is `φ(t0)`.
+ */
+export type DDEHistory = ((t: number) => number[] | number) | number | number[];
+/** Options for {@link solveDDE} (mirrors the `solveODE` option shape). */
+export interface SolveDDEOptions {
+    /** Relative tolerance for the adaptive local-error control (default `1e-6`). */
+    tol?: number;
+    /** Absolute tolerance (default `tol · 1e-3`). */
+    atol?: number;
+    /** Initial step size (default: Hairer heuristic, capped to `min(τ)`). */
+    firstStep?: number;
+    /** Minimum step size (a hard floor; below it a step is force-accepted). */
+    minStep?: number;
+    /** Maximum step size (further capped by `min(τ)` and the next breakpoint). */
+    maxStep?: number;
+    /** Maximum number of accepted steps (default `1e5`). */
+    maxIter?: number;
+}
+/**
+ * Solution returned by {@link solveDDE}.
+ *
+ * `y` is `number[][]` (one state vector per accepted time) when the history/initial
+ * state is a vector, and unwrapped to `number[]` when it is a scalar.
+ */
+export interface DDESolution {
+    /** Accepted output times, `t[0] = t0`, last entry `= T`. */
+    t: number[];
+    /** State at each accepted time (`number[]` for a scalar DDE, else `number[][]`). */
+    y: number[][] | number[];
+    /**
+     * Dense-output evaluator: the cubic-Hermite continuous extension `y(t)` for any
+     * `t ∈ [t0, T]` (clamped to that range). Returns the state in the same shape as
+     * `y` (scalar for a scalar DDE). C¹ and O(h⁴) between accepted steps.
+     */
+    yInterp: (t: number) => number[] | number;
+}
+/**
+ * Solve the constant-delay DDE `y'(t) = f(t, y(t), [y(t−τ₁), …])` on `[tspan[0],
+ * tspan[1]]` with a history `φ` and delays `τ_k`, by the method of steps (adaptive
+ * BS23 + cubic-Hermite continuous extension, step capped at `min(τ)`).
+ *
+ * @param f        Forcing `f(t, y, yDelayed) → y'`. `yDelayed[k] = y(t − τ_k)`.
+ * @param tspan    `[t0, T]` (forward integration; `T > t0`).
+ * @param history  `φ(t)` for `t ≤ t0` — a function or a constant. `y(t0) = φ(t0)`.
+ * @param delays   Positive constant delays `τ_k` (at least one).
+ * @param options  See {@link SolveDDEOptions}.
+ * @returns `{ t, y, yInterp }` — `y` unwrapped to `number[]` for a scalar DDE.
+ *
+ * @example
+ * // y'(t) = −y(t−1), history φ ≡ 1 on t ≤ 0. Method-of-steps solution:
+ * //   [0,1]: 1 − t,  [1,2]: t²/2 − 2t + 3/2, …
+ * const sol = solveDDE((t, y, yd) => [-yd[0][0]], [0, 3], 1, [1]);
+ * sol.yInterp(2.5); // dense output at t = 2.5
+ */
+export declare function solveDDE(f: DDEForcing, tspan: [number, number] | number[], history: DDEHistory, delays: number[], options?: SolveDDEOptions): DDESolution;
+//# sourceMappingURL=solveDDE.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"solveDDE.d.ts","sourceRoot":"","sources":["../../src/numeric/solveDDE.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,KAAK,MAAM,EAAE,GAAG,MAAM,CAAC;AAE7F;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EAAE,GAAG,MAAM,CAAC,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC;AAEhF,0EAA0E;AAC1E,MAAM,WAAW,eAAe;IAC9B,gFAAgF;IAChF,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,8EAA8E;IAC9E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,wDAAwD;IACxD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,4DAA4D;IAC5D,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,oFAAoF;IACpF,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,CAAC;IACzB;;;;OAIG;IACH,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EAAE,GAAG,MAAM,CAAC;CAC3C;AAgDD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,UAAU,EACb,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,EAAE,EAClC,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,MAAM,EAAE,EAChB,OAAO,GAAE,eAAoB,GAC5B,WAAW,CA8Kb"}

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/typed/numeric.d.ts

@@ -11,6 +11,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';
+export { solveDDE, type SolveDDEOptions, type DDESolution, type DDEForcing, type DDEHistory, } from '../numeric/solveDDE.js';
 type f64 = number;
 type i32 = number;
 /**

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":"AAAA;;;;;;;;;;;GAWG;AAQH,OAAO,EACL,iBAAiB,EACjB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,eAAe,GACrB,MAAM,iCAAiC,CAAC;AAGzC,OAAO,EACL,QAAQ,EACR,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,iBAAiB,GACvB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EACL,QAAQ,EACR,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,UAAU,GAChB,MAAM,wBAAwB,CAAC;AAMhC,KAAK,GAAG,GAAG,MAAM,CAAC;AAClB,KAAK,GAAG,GAAG,MAAM,CAAC;AASlB;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,yDAAyD;IACzD,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,uCAAuC;IACvC,OAAO,CAAC,EAAE,GAAG,CAAC;CACf;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,eAAe,GAAG,GAAG,CAwExF;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAyC7D;AAMD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,wCAAwC;IACxC,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,wCAAwC;IACxC,OAAO,CAAC,EAAE,GAAG,CAAC;IACd,8CAA8C;IAC9C,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,GAAG,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,eAAe,GAAG,MAAM,EAAE,CA+FhG;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,GAAG,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,eAAe,GAAG,MAAM,EAAE,CAEhG;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,GAAG,EACvB,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAC1B,IAAI,CAAC,EAAE,eAAe,GAAG;IAAE,KAAK,CAAC,EAAE,GAAG,CAAA;CAAE,GACvC,MAAM,EAAE,CAsBV;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CA+CjE;AAMD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CACxB,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,EAClB,CAAC,EAAE,GAAG,EACN,CAAC,EAAE,GAAG,EACN,IAAI,CAAC,EAAE;IAAE,GAAG,CAAC,EAAE,GAAG,CAAC;IAAC,QAAQ,CAAC,EAAE,GAAG,CAAA;CAAE,GACnC,GAAG,CAEL;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAE,GAAS,GAAG,GAAG,CAQ9E;AAMD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,EAAE,EAAE,MAAM,EAAE,EACZ,EAAE,EAAE,MAAM,EAAE,EACZ,MAAM,GAAE,QAAQ,GAAG,UAAU,GAAG,QAAmB,GAClD,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,CA6EjB;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,CAEnE;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,GAAG,GAAG,GAAG,CA+C7D;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,aAAa,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,CA2CvE;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,aAAa,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,CA2ChF;AAED;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,SAAS,GAAE,GAAS,GAAG,GAAG,CA2DnF;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,EAAE,EAAE,EAClB,MAAM,EAAE,MAAM,EAAE,EAChB,EAAE,EAAE,MAAM,EAAE,EACZ,EAAE,EAAE,MAAM,EAAE,GACX,MAAM,EAAE,EAAE,CA8FZ;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EAAE,EAAE,EAClB,MAAM,EAAE,MAAM,EAAE,EAChB,EAAE,EAAE,MAAM,EAAE,EAAE,EACd,MAAM,GAAE,UAAU,GAAG,cAAc,GAAG,WAAwB,GAC7D,MAAM,EAAE,CAoGV;AAMD;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,GAAG,EACpC,EAAE,EAAE,MAAM,EAAE,EACZ,EAAE,EAAE,MAAM,EAAE,EACZ,EAAE,EAAE,MAAM,EAAE,GACX,MAAM,EAAE,CA+EV;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAiB7D;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAgB7D;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAkB/D;AAMD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;CACf;AAuGD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,EACpC,EAAE,EAAE,MAAM,EAAE,EACZ,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EACjB,IAAI,CAAC,EAAE;IAAE,GAAG,CAAC,EAAE,GAAG,CAAC;IAAC,QAAQ,CAAC,EAAE,GAAG,CAAC;IAAC,EAAE,CAAC,EAAE,GAAG,CAAA;CAAE,GAC7C,WAAW,CAuEb;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,EACpC,EAAE,EAAE,MAAM,EAAE,EACZ,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,GAChB,WAAW,CAYb;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,EACpC,EAAE,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,EAC5C,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,GAAE,MAAM,EAAW,GACzB,WAAW,CA8Cb;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,EACpC,EAAE,EAAE,MAAM,EAAE,EACZ,EAAE,EAAE,GAAG,EACP,CAAC,EAAE,GAAG,EACN,GAAG,GAAE,GAAU,GACd;IAAE,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,CAAC,EAAE,GAAG,CAAC;IAAC,CAAC,EAAE,GAAG,CAAA;CAAE,CAgDjC;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,EACpC,EAAE,EAAE,MAAM,EAAE,EACZ,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EACjB,KAAK,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,GAAG,GAClC,WAAW,GAAG;IAAE,SAAS,CAAC,EAAE,GAAG,CAAA;CAAE,CA6EnC;AAMD;;;;;;GAMG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,GAAG,GAAE,GAAW,GAAG,GAAG,CAiDzD;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,EAAE,CAqDnD;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAwBzF;AAwDD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAE,GAAQ,GAAG,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,CAiChG;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EAAE,EAChB,CAAC,EAAE,GAAG,EACN,CAAC,EAAE,GAAG,GACL;IAAE,GAAG,EAAE,MAAM,EAAE,CAAC;IAAC,GAAG,EAAE,MAAM,EAAE,CAAA;CAAE,CA2ClC;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAuCzF;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,mGAAmG;IACnG,MAAM,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,MAAM,GAAG,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC;CAC/D;AAED,qDAAqD;AACrD,MAAM,WAAW,aAAa;IAC5B,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,SAAS,GAAG,YAAY,GAAG,WAAW,CAAC;CAChD;AA6bD;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,IAAI,CAAC;AACxF,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,cAAc,GAAG,aAAa,CAAC;AAY1E;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CACtB,GAAG,EAAE;IAAE,KAAK,EAAE,GAAG,CAAA;CAAE,EACnB,MAAM,EAAE;IAAE,CAAC,EAAE,GAAG,CAAC;IAAC,EAAE,EAAE,GAAG,CAAC;IAAC,EAAE,EAAE,GAAG,CAAC;IAAC,CAAC,EAAE,GAAG,CAAA;CAAE,EAC5C,EAAE,EAAE;IAAE,IAAI,EAAE,GAAG,CAAC;IAAC,KAAK,EAAE,GAAG,CAAC;IAAC,OAAO,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,CAAA;CAAE,GACtD;IAAE,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CA+B9B"}

package/package.json

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