@danielsimonjr/mathts-functions 0.26.0 → 0.27.0

package/dist/index.js

@@ -36306,6 +36306,122 @@ var createSolveODE = /* @__PURE__ */ factory(
       for (let i = 0; i < v.length; i++) s += v[i] * v[i];
       return Math.sqrt(s / v.length);
     }
+    function _luSolve(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;
+        [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 _fArr(f, t, y) {
+      const r = f(t, y);
+      return Array.isArray(r) ? r : [r];
+    }
+    function _fdJacobian(f, t, y, f0) {
+      const n = y.length;
+      const J = Array.from({ length: n }, () => new Array(n));
+      for (let j = 0; j < n; j++) {
+        const eps = Math.max(1e-8, 1e-7 * Math.abs(y[j]));
+        const yj = y.slice();
+        yj[j] += eps;
+        const fj = _fArr(f, t, yj);
+        for (let i = 0; i < n; i++) J[i][j] = (fj[i] - f0[i]) / eps;
+      }
+      return J;
+    }
+    function _rosenbrock(f, tspan, y0raw, options) {
+      const t0 = tspan[0];
+      const tf = tspan[1];
+      if (!(typeof t0 === "number" && typeof tf === "number")) {
+        throw new Error('The "Rosenbrock" stiff method requires numeric tspan');
+      }
+      if (!y0raw.every((v) => typeof v === "number")) {
+        throw new Error('The "Rosenbrock" stiff method requires plain-number state (y0)');
+      }
+      const y0 = y0raw;
+      const n = y0.length;
+      const dir = tf >= t0 ? 1 : -1;
+      const gamma2 = 1 / (2 + Math.SQRT2);
+      const c32 = 6 + Math.SQRT2;
+      const rtol = options.tol ? options.tol : 1e-4;
+      const atol = rtol * 1e-3;
+      const maxIter = options.maxIter ? options.maxIter : 1e5;
+      const span = Math.abs(tf - t0);
+      let t = t0;
+      let y = y0.slice();
+      let h;
+      if (options.firstStep) {
+        h = dir * Math.abs(options.firstStep);
+      } else {
+        const f0 = f(t, y);
+        const d0 = _rmsNorm(y);
+        const d1 = _rmsNorm(Array.isArray(f0) ? f0 : [f0]);
+        h = dir * Math.min(d0 < 1e-5 || d1 < 1e-5 ? 1e-6 : 0.01 * (d0 / d1), span);
+      }
+      const tOut = [t];
+      const yOut = [y.slice()];
+      let iter = 0;
+      const identityMinus = (J, hg) => J.map((row2, i) => row2.map((v, j) => (i === j ? 1 : 0) - hg * v));
+      while ((dir > 0 ? t < tf : t > tf) && iter < maxIter) {
+        if (Math.abs(h) > Math.abs(tf - t)) h = tf - t;
+        const F0 = _fArr(f, t, y);
+        const J = _fdJacobian(f, t, y, F0);
+        const W = identityMinus(J, h * gamma2);
+        const k1 = _luSolve(W, F0);
+        const y1 = y.map((yi, i) => yi + 0.5 * h * k1[i]);
+        const F1 = _fArr(f, t + 0.5 * h, y1);
+        const dk = _luSolve(
+          W,
+          F1.map((v, i) => v - k1[i])
+        );
+        const k2 = k1.map((v, i) => v + dk[i]);
+        const yNew = y.map((yi, i) => yi + h * k2[i]);
+        const F2 = _fArr(f, t + h, yNew);
+        const k3 = _luSolve(
+          W,
+          F2.map((v, i) => v - c32 * (k2[i] - F1[i]) - 2 * (k1[i] - F0[i]))
+        );
+        let errNorm = 0;
+        for (let i = 0; i < n; i++) {
+          const err = h / 6 * (k1[i] - 2 * k2[i] + k3[i]);
+          const sc = atol + rtol * Math.max(Math.abs(y[i]), Math.abs(yNew[i]));
+          errNorm += (err / sc) ** 2;
+        }
+        errNorm = Math.sqrt(errNorm / n);
+        if (errNorm <= 1 || Math.abs(h) <= 1e-14 * Math.abs(t)) {
+          t += h;
+          y = yNew;
+          tOut.push(t);
+          yOut.push(y.slice());
+        }
+        h *= Math.min(4, Math.max(0.25, 0.9 * Math.pow(errNorm || 1e-10, -1 / 3)));
+        const maxStepR = options.maxStep;
+        const minStepR = options.minStep;
+        if (maxStepR && Math.abs(h) > maxStepR) h = dir * maxStepR;
+        else if (minStepR && Math.abs(h) < minStepR) h = dir * minStepR;
+        iter++;
+      }
+      if (iter >= maxIter) {
+        throw new Error("Maximum number of iterations reached, try changing options");
+      }
+      return { t: tOut, y: yOut };
+    }
     function _rkWasmLoop(f, tspan, y0, options, butcherTableau) {
       const wasm = wasmLoader.getModule();
       if (!wasm) return null;
@@ -36583,7 +36699,8 @@ var createSolveODE = /* @__PURE__ */ factory(
       const method = opt.method ? opt.method : "RK45";
       const methods = {
         RK23: _rk23,
-        RK45: _rk45
+        RK45: _rk45,
+        ROSENBROCK: _rosenbrock
       };
       if (method.toUpperCase() in methods) {
         const methodOptions = { ...opt };

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

@@ -1 +1 @@
-{"version":3,"file":"solveODE.d.ts","sourceRoot":"","sources":["../../src/numeric/solveODE.ts"],"names":[],"mappings":"AAmEA,eAAO,MAAM,cAAc,yDA8nB1B,CAAC"}
+{"version":3,"file":"solveODE.d.ts","sourceRoot":"","sources":["../../src/numeric/solveODE.ts"],"names":[],"mappings":"AAmEA,eAAO,MAAM,cAAc,yDAkyB1B,CAAC"}

package/package.json

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