@danielsimonjr/mathts-functions 0.25.1 → 0.27.0

package/dist/index.js

@@ -36301,6 +36301,127 @@ var createSolveODE = /* @__PURE__ */ factory(
       }
       return true;
     }
+    function _rmsNorm(v) {
+      let s = 0;
+      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;
@@ -36313,12 +36434,21 @@ var createSolveODE = /* @__PURE__ */ factory(
       const t0 = tspan[0];
       const tf = tspan[1];
       const isForwards = tf > t0;
-      const steps = 1;
       const tol = options.tol ? options.tol : 1e-4;
       const minDelta = options.minDelta ? options.minDelta : 0.2;
       const maxDelta = options.maxDelta ? options.maxDelta : 5;
       const maxIter = options.maxIter ? options.maxIter : 1e4;
-      let h = options.firstStep ? isForwards ? options.firstStep : -options.firstStep : (tf - t0) / steps;
+      let h;
+      if (options.firstStep) {
+        h = isForwards ? options.firstStep : -options.firstStep;
+      } else {
+        const f0 = f(t0, y0);
+        const d0 = _rmsNorm(y0);
+        const d1 = _rmsNorm(Array.isArray(f0) ? f0 : [f0]);
+        const h0 = d0 < 1e-5 || d1 < 1e-5 ? 1e-6 : 0.01 * (d0 / d1);
+        const hMag = Math.min(h0, Math.abs(tf - t0));
+        h = isForwards ? hMag : -hMag;
+      }
       const maxStepVal = options.maxStep;
       const minStepVal = options.minStep;
       const deltaB = new Float64Array(numStages);
@@ -36468,10 +36598,31 @@ var createSolveODE = /* @__PURE__ */ factory(
           bignumber2(butcherTableau.b),
           bignumber2(butcherTableau.bp)
         ] : [butcherTableau.a, butcherTableau.c, butcherTableau.b, butcherTableau.bp];
-        let h = firstStep ? isForwards ? firstStep : unaryMinus2(firstStep) : divide2(subtract2(tf, t0), steps);
+        let h;
+        if (firstStep) {
+          h = isForwards ? firstStep : unaryMinus2(firstStep);
+        } else if (!hasBigNumbers && !tspan.some(isUnit) && y0.every((v) => typeof v === "number")) {
+          const f0 = f(t0, y0);
+          const f0arr = Array.isArray(f0) ? f0 : [f0];
+          const d0 = _rmsNorm(y0);
+          const d1 = _rmsNorm(f0arr);
+          const h0 = d0 < 1e-5 || d1 < 1e-5 ? 1e-6 : 0.01 * (d0 / d1);
+          const hMag = Math.min(h0, Math.abs(tf - t0));
+          h = isForwards ? hMag : -hMag;
+        } else {
+          h = divide2(subtract2(tf, t0), steps);
+        }
         const t = [t0];
         const y = [y0];
         const deltaB = subtract2(b, bp);
+        function stageCombo(coeffs, stages) {
+          const m = Math.min(coeffs.length, stages.length);
+          let acc = multiply2(coeffs[0], stages[0]);
+          for (let j = 1; j < m; j++) {
+            acc = add2(acc, multiply2(coeffs[j], stages[j]));
+          }
+          return acc;
+        }
         let n = 0;
         let iter = 0;
         const ongoing = _createOngoing(isForwards);
@@ -36481,14 +36632,14 @@ var createSolveODE = /* @__PURE__ */ factory(
           h = trimStep(t[n], tf, h);
           k.push(f(t[n], y[n]));
           for (let i = 1; i < c.length; ++i) {
-            k.push(f(add2(t[n], multiply2(c[i], h)), add2(y[n], multiply2(h, a[i], k))));
+            k.push(f(add2(t[n], multiply2(c[i], h)), add2(y[n], multiply2(h, stageCombo(a[i], k)))));
           }
-          const TE = max2(
-            abs2(map2(multiply2(deltaB, k), (X) => isUnit(X) ? X.value : X))
-          );
+          const errComb = stageCombo(deltaB, k);
+          const errArr = Array.isArray(errComb) ? errComb : [errComb];
+          const TE = max2(abs2(map2(errArr, (X) => isUnit(X) ? X.value : X)));
           if (TE < tol && tol / TE > 1 / 4) {
             t.push(add2(t[n], h));
-            y.push(add2(y[n], multiply2(h, b, k)));
+            y.push(add2(y[n], multiply2(h, stageCombo(b, k))));
             n++;
           }
           let delta = 0.84 * (tol / TE) ** (1 / 5);
@@ -36548,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,yDA8kB1B,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.25.1",
+  "version": "0.27.0",
   "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
   "author": "Daniel Simon Jr.",
   "license": "MIT",