diff-grok 1.0.10 → 1.2.0

package/src/solver-tools/mrt-method.ts

@@ -5,14 +5,102 @@
    [2] https://doi.org/10.1016/S0898-1221(00)00175-9
 */
 
-import {ODEs, max, abs, SAFETY, PSHRNK, PSGROW, REDUCE_COEF, GROW_COEF,
-  ERR_CONTR, TINY, EPS, tDerivative, jacobian, ERROR_MSG} from './solver-defs';
+import {ODEs, max, min, abs, SAFETY, TINY, EPS, tDerivative, jacobian, ERROR_MSG} from './solver-defs';
 import {Callback} from './callbacks/callback-base';
 import {luDecomp, luSolve, solve1d2d} from './lin-alg-tools';
 
 // Quantities used in Rosenbrock method (see [1], [2] for more details)
 const D = 1.0 - Math.sqrt(2.0) / 2.0;
 const E32 = 6.0 + Math.sqrt(2.0);
+const TWO_D = 2.0 * D;
+const ONE_MINUS_2D = 1.0 - TWO_D;
+
+// Adaptive step size control bounds (see MRT.md, Section 6)
+const ALPHA_MAX = 5;
+const ALPHA_MIN = 0.2;
+
+/** Compute the initial step size using the Hairer-Norsett-Wanner algorithm.
+ *  @param t0    initial time
+ *  @param y0    initial state vector
+ *  @param f     right-hand side function
+ *  @param tol   scalar tolerance (plays the role of rtol)
+ *  @param dim   dimension of the system
+ *  @param p     order of the method (p = 2 for MRT)
+ *  @param tEnd  end of the integration interval (used to cap h0)
+ *  @returns     estimated initial step size
+ */
+function initialStepSize(
+  t0: number,
+  y0: Float64Array,
+  f: (t: number, y: Float64Array, out: Float64Array) => void,
+  tol: number,
+  dim: number,
+  p: number,
+  tEnd: number,
+): number {
+  const f0 = new Float64Array(dim);
+  const f1 = new Float64Array(dim);
+  const y1 = new Float64Array(dim);
+  const sc = new Float64Array(dim);
+
+  // Step 1: scale vector (sc[i] = |y0[i]| + TINY)
+  for (let i = 0; i < dim; ++i)
+    sc[i] = Math.abs(y0[i]) + TINY;
+
+  // Step 2: evaluate the right-hand side at the initial point
+  f(t0, y0, f0);
+
+  // Step 3: compute scaled norms d0 = ||y0/sc||, d1 = ||f0/sc||
+  let d0 = 0.0;
+  let d1 = 0.0;
+
+  for (let i = 0; i < dim; ++i) {
+    d0 = Math.max(d0, Math.abs(y0[i]) / sc[i]);
+    d1 = Math.max(d1, Math.abs(f0[i]) / sc[i]);
+  }
+
+  // Step 4: first guess
+  let h0: number;
+
+  if (d0 < 1e-5 || d1 < 1e-5)
+    h0 = 1e-6;
+  else
+    h0 = 0.01 * d0 / d1;
+
+  // Cap h0 to the integration interval
+  h0 = Math.min(h0, Math.abs(tEnd - t0));
+
+  // Step 5: explicit Euler probe to estimate the second derivative
+  for (let i = 0; i < dim; ++i)
+    y1[i] = y0[i] + h0 * f0[i];
+
+  f(t0 + h0, y1, f1);
+
+  let d2 = 0.0;
+
+  for (let i = 0; i < dim; ++i)
+    d2 = Math.max(d2, Math.abs(f1[i] - f0[i]) / sc[i]);
+
+  d2 /= h0;
+
+  // Step 6: refine using the method order
+  //   h1 = (tol / max(d1, d2))^(1/(p+1))
+  const maxD = Math.max(d1, d2);
+  let h1: number;
+
+  if (maxD <= 1e-15)
+    h1 = Math.max(1e-6, h0 * 1e-3);
+  else
+    h1 = Math.pow(tol / maxD, 1.0 / (p + 1));
+
+  // Step 7: final initial step size
+  h0 = Math.min(100.0 * h0, h1);
+
+  // Safety: clip to the integration interval
+  h0 = Math.min(h0, Math.abs(tEnd - t0));
+
+  return h0;
+}
 
 /** Solve initial value problem the modified Rosenbrock triple (MRT) method
  * @param odes initial value problem for ordinary differential equations
@@ -61,19 +149,22 @@ const E32 = 6.0 + Math.sqrt(2.0);
 export function mrt(odes: ODEs, callback?: Callback): Float64Array[] {
   /** right-hand side of the IVP solved */
   const f = odes.func;
-
   // operating variables
   const t0 = odes.arg.start;
   const t1 = odes.arg.finish;
-  let h = odes.arg.step;
-  const hDataframe = h;
+  const hDataframe = odes.arg.step;
   const tolerance = odes.tolerance;
 
-  /** number of solution dataframe rows */
-  const rowCount = Math.trunc((t1 - t0) / h) + 1;
-
   /** dimension of the problem */
   const dim = odes.initial.length;
+
+  // compute the initial step size automatically
+  let h = initialStepSize(t0, new Float64Array(odes.initial), f, tolerance, dim, 2, t1);
+
+  //console.log(`MRT, the problem "${odes.name}", grid step: ${hDataframe}, initial step size: ${h}.`);
+
+  /** number of solution dataframe rows */
+  const rowCount = Math.trunc((t1 - t0) / hDataframe) + 1;
   const dimSquared = dim * dim;
 
   /** independent variable values */
@@ -93,7 +184,6 @@ export function mrt(odes: ODEs, callback?: Callback): Float64Array[] {
   let flag = true;
   let index = 1;
   let errmax = 0;
-  let hTemp = 0;
   let tNew = 0;
 
   // 0 BUFFERS & TEMP STRUCTURES
@@ -241,18 +331,16 @@ export function mrt(odes: ODEs, callback?: Callback): Float64Array[] {
         errmax = max(errmax, abs(yErr[i] / yScale[i]));
       errmax /= tolerance;
 
-      // processing the error obtained
+      // adaptive step size control (see MRT.md, Section 6)
       if (errmax > 1) {
-        hTemp = SAFETY * h * errmax**PSHRNK;
-        h = max(hTemp, REDUCE_COEF * h);
+        // step rejected: reduce step size, but not below ALPHA_MIN factor
+        h = h * max(ALPHA_MIN, SAFETY * errmax ** (-1 / 3));
         tNew = t + h;
         if (tNew == t)
           throw new Error(ERROR_MSG.MRT_FAILS);
       } else {
-        if (errmax > ERR_CONTR)
-          hNext = SAFETY * h * errmax**PSGROW;
-        else
-          hNext = GROW_COEF * h;
+        // step accepted: grow step size, but not above ALPHA_MAX factor
+        hNext = h * min(ALPHA_MAX, SAFETY * errmax ** (-1 / 3));
         t = t + h;
 
         for (let i = 0; i < dim; ++i)
@@ -262,15 +350,17 @@ export function mrt(odes: ODEs, callback?: Callback): Float64Array[] {
       }
     } // while (true)
 
-    // compute lineraly interpolated results and store them in dataframe
+    // compute dense output using Shampine-Reichelt continuous extension
+    const hStep = t - tPrev;
     while (timeDataframe < t) {
-      const cLeft = (t - timeDataframe) / (t - tPrev);
-      const cRight = 1.0 - cLeft;
+      const s = (timeDataframe - tPrev) / hStep;
+      const b1 = s * (1.0 - s) / ONE_MINUS_2D;
+      const b2 = s * (s - TWO_D) / ONE_MINUS_2D;
 
       tArr[index] = timeDataframe;
 
       for (let j = 0; j < dim; ++j)
-        yArrs[j][index] = cRight * y[j] + cLeft * yPrev[j];
+        yArrs[j][index] = yPrev[j] + hStep * (b1 * k1[j] + b2 * k2[j]);
 
       timeDataframe += hDataframe;
       ++index;
@@ -294,7 +384,7 @@ export function mrt(odes: ODEs, callback?: Callback): Float64Array[] {
     yArrs[i][rowCount - 1] = y[i];
 
   // 4. prepare output
-  const solution = Array<Float64Array>(dim);
+  const solution = Array<Float64Array>(dim + 1);
 
   // independent variable
   solution[0] = tArr;

package/src/solver-tools/rk3-method.js

@@ -0,0 +1,210 @@
+/* The Bogacki-Shampine 3(2) method (RK3).
+
+   An explicit adaptive Runge-Kutta method of order 3 with an embedded
+   2nd-order error estimate for step size control. Uses the FSAL (First
+   Same As Last) property for efficiency.
+
+   Reference:
+   [1] P. Bogacki and L.F. Shampine, "A 3(2) pair of Runge-Kutta formulas",
+       Applied Mathematics Letters, 2(4):321-325, 1989.
+*/
+import { max, abs, SAFETY, REDUCE_COEF, GROW_COEF, ERR_CONTR, TINY, ERROR_MSG } from './solver-defs';
+// Step size control exponents for a 3rd-order method
+const PSHRNK = -1.0 / 3.0; // -1/p = -1/3
+const PSGROW = -0.25; // -1/(p+1) = -1/4
+// Bogacki-Shampine 3(2) Butcher tableau coefficients
+// Nodes (c_i)
+const C2 = 1.0 / 2.0;
+const C3 = 3.0 / 4.0;
+// C4 = 1 (FSAL)
+// Matrix coefficients (a_ij)
+const A21 = 1.0 / 2.0;
+const A32 = 3.0 / 4.0;
+// A4i = Bi (FSAL property: 4th-stage coefficients equal the 3rd-order weights)
+// 3rd-order weights (b_i) — used to advance the solution
+const B1 = 2.0 / 9.0;
+const B2 = 1.0 / 3.0;
+const B3 = 4.0 / 9.0;
+// B4 = 0
+// Error coefficients: (b_i - bHat_i), where bHat are the 2nd-order weights
+const E1 = -5.0 / 72.0;
+const E2 = 1.0 / 12.0;
+const E3 = 1.0 / 9.0;
+const E4 = -1.0 / 8.0;
+/** Solve initial value problem using the Bogacki-Shampine 3(2) method
+ * @param odes initial value problem for ordinary differential equations
+ * @param callback computations control callback
+ * @returns solution of the problem
+ * @example
+ * // Example. Solve the following initial value problem using the RK3 method:
+ * //   dx/dt = x + y - t
+ * //   dy/dt = x * y + t
+ * //   x(0) = 1
+ * //   y(0) = -1
+ * // on [0, 2] with the step 0.01.
+ * import { ODEs, rk3 } from 'diff-grok';
+ *
+ * const task: ODEs = {
+ *   name: 'Example', // name of your model
+ *   arg: {
+ *       name: 't',  // name of the argument
+ *       start: 0,   // initial value of the argument
+ *       finish: 2,  // final value of the argument
+ *       step: 0.01, // solution grid step
+ *   },
+ *   initial: [1, -1], // initial values
+ *   func: (t: number, y: Float64Array, output: Float64Array) => { // right-hand side of the system
+ *     output[0] = y[0] + y[1] - t; // 1-st equation
+ *     output[1] = y[0] * y[1] + t; // 2-nd equation
+ *   },
+ *   tolerance: 1e-7, // tolerance
+ *   solutionColNames: ['x', 'y'], // names of solution functions
+ * };
+ *
+ * try {
+ *   // Solve the problem using the RK3 method
+ *   const solution = rk3(task);
+ *
+ *   // Print a table with the results
+ *   console.log(task.arg.name, task.solutionColNames[0], task.solutionColNames[1]);
+ *   const length = solution[0].length;
+ *   for (let i = 0; i < length; ++i)
+ *     console.log(solution[0][i], solution[1][i], solution[2][i]);
+ * } catch (err) {
+ *   console.log('Solver failed: ', err instanceof Error ? err.message : 'Unknown problem!');
+ * }
+*/
+export function rk3(odes, callback) {
+    const f = odes.func;
+    // operating variables
+    const t0 = odes.arg.start;
+    const t1 = odes.arg.finish;
+    let h = odes.arg.step;
+    const hDataframe = h;
+    const hMax = hDataframe * 10;
+    const tolerance = odes.tolerance;
+    const rowCount = Math.trunc((t1 - t0) / h) + 1;
+    const dim = odes.initial.length;
+    // result arrays
+    const tArr = new Float64Array(rowCount);
+    const yArrs = Array(dim);
+    for (let i = 0; i < dim; ++i)
+        yArrs[i] = new Float64Array(rowCount);
+    // method routine
+    let timeDataframe = t0 + hDataframe;
+    let t = t0;
+    let tPrev = t0;
+    let hNext = 0.0;
+    let flag = true;
+    let index = 1;
+    let errmax = 0;
+    let hTemp = 0;
+    let tNew = 0;
+    // buffers
+    const y = new Float64Array(odes.initial);
+    const yPrev = new Float64Array(odes.initial);
+    const dydt = new Float64Array(dim);
+    const yScale = new Float64Array(dim);
+    const yTemp = new Float64Array(dim);
+    const yErr = new Float64Array(dim);
+    const k1 = new Float64Array(dim);
+    const k2 = new Float64Array(dim);
+    const k3 = new Float64Array(dim);
+    const k4 = new Float64Array(dim);
+    // 1. SOLUTION AT THE POINT t0
+    tArr[0] = t0;
+    for (let i = 0; i < dim; ++i)
+        yArrs[i][0] = y[i];
+    // 2. COMPUTE NUMERICAL SOLUTION FOR THE POINTS FROM THE INTERVAL (t0, t1)
+    while (flag) {
+        // compute derivative
+        f(t, y, dydt);
+        // check whether to go on computations
+        if (callback)
+            callback.onIterationStart();
+        // compute scale vector
+        for (let i = 0; i < dim; ++i)
+            yScale[i] = abs(y[i]) + h * abs(dydt[i]) + TINY;
+        // check end point
+        if (t + h > t1) {
+            h = t1 - t;
+            flag = false;
+        }
+        // adaptive step loop
+        while (true) {
+            // Stage 1: k1 = f(t, y)
+            f(t, y, k1);
+            // Stage 2: k2 = f(t + C2*h, y + h*A21*k1)
+            for (let i = 0; i < dim; ++i)
+                yTemp[i] = y[i] + h * A21 * k1[i];
+            f(t + C2 * h, yTemp, k2);
+            // Stage 3: k3 = f(t + C3*h, y + h*A32*k2)
+            for (let i = 0; i < dim; ++i)
+                yTemp[i] = y[i] + h * A32 * k2[i];
+            f(t + C3 * h, yTemp, k3);
+            // 3rd-order solution
+            for (let i = 0; i < dim; ++i)
+                yTemp[i] = y[i] + h * (B1 * k1[i] + B2 * k2[i] + B3 * k3[i]);
+            // Stage 4: k4 = f(t + h, yTemp) — needed for error estimate (FSAL)
+            f(t + h, yTemp, k4);
+            // Error estimate: difference between 3rd and 2nd order solutions
+            for (let i = 0; i < dim; ++i)
+                yErr[i] = h * (E1 * k1[i] + E2 * k2[i] + E3 * k3[i] + E4 * k4[i]);
+            // estimating error
+            errmax = 0;
+            for (let i = 0; i < dim; ++i)
+                errmax = max(errmax, abs(yErr[i] / yScale[i]));
+            errmax /= tolerance;
+            // processing the error obtained
+            if (errmax > 1) {
+                hTemp = SAFETY * h * Math.pow(errmax, PSHRNK);
+                h = max(hTemp, REDUCE_COEF * h);
+                tNew = t + h;
+                if (tNew == t)
+                    throw new Error(ERROR_MSG.RK3_FAILS);
+            }
+            else {
+                if (errmax > ERR_CONTR)
+                    hNext = SAFETY * h * Math.pow(errmax, PSGROW);
+                else
+                    hNext = GROW_COEF * h;
+                if (hNext > hMax)
+                    hNext = hMax;
+                t = t + h;
+                for (let i = 0; i < dim; ++i)
+                    y[i] = yTemp[i];
+                break;
+            }
+        } // while (true)
+        // compute linearly interpolated results and store them in dataframe
+        while (timeDataframe < t) {
+            const cLeft = (t - timeDataframe) / (t - tPrev);
+            const cRight = 1.0 - cLeft;
+            tArr[index] = timeDataframe;
+            for (let j = 0; j < dim; ++j)
+                yArrs[j][index] = cRight * y[j] + cLeft * yPrev[j];
+            timeDataframe += hDataframe;
+            ++index;
+        }
+        h = hNext;
+        tPrev = t;
+        for (let i = 0; i < dim; ++i)
+            yPrev[i] = y[i];
+    } // while (flag)
+    // perform final callback actions
+    if (callback)
+        callback.onComputationsCompleted();
+    // 3. solution at the point t1
+    tArr[rowCount - 1] = t1;
+    for (let i = 0; i < dim; ++i)
+        yArrs[i][rowCount - 1] = y[i];
+    // 4. prepare output
+    const solution = Array(dim + 1);
+    // independent variable
+    solution[0] = tArr;
+    // functions
+    for (let i = 0; i < dim; ++i)
+        solution[i + 1] = yArrs[i];
+    return solution;
+} // rk3
+//# sourceMappingURL=rk3-method.js.map

package/src/solver-tools/rk3-method.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rk3-method.js","sourceRoot":"","sources":["rk3-method.ts"],"names":[],"mappings":"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"}

package/src/solver-tools/rk3-method.ts

@@ -0,0 +1,257 @@
+/* The Bogacki-Shampine 3(2) method (RK3).
+
+   An explicit adaptive Runge-Kutta method of order 3 with an embedded
+   2nd-order error estimate for step size control. Uses the FSAL (First
+   Same As Last) property for efficiency.
+
+   Reference:
+   [1] P. Bogacki and L.F. Shampine, "A 3(2) pair of Runge-Kutta formulas",
+       Applied Mathematics Letters, 2(4):321-325, 1989.
+*/
+
+import {ODEs, max, abs, SAFETY, REDUCE_COEF, GROW_COEF,
+  ERR_CONTR, TINY, ERROR_MSG} from './solver-defs';
+import {Callback} from './callbacks/callback-base';
+
+// Step size control exponents for a 3rd-order method
+const PSHRNK = -1.0 / 3.0; // -1/p = -1/3
+const PSGROW = -0.25; // -1/(p+1) = -1/4
+
+// Bogacki-Shampine 3(2) Butcher tableau coefficients
+
+// Nodes (c_i)
+const C2 = 1.0 / 2.0;
+const C3 = 3.0 / 4.0;
+// C4 = 1 (FSAL)
+
+// Matrix coefficients (a_ij)
+const A21 = 1.0 / 2.0;
+
+const A32 = 3.0 / 4.0;
+
+// A4i = Bi (FSAL property: 4th-stage coefficients equal the 3rd-order weights)
+
+// 3rd-order weights (b_i) — used to advance the solution
+const B1 = 2.0 / 9.0;
+const B2 = 1.0 / 3.0;
+const B3 = 4.0 / 9.0;
+// B4 = 0
+
+// Error coefficients: (b_i - bHat_i), where bHat are the 2nd-order weights
+const E1 = -5.0 / 72.0;
+const E2 = 1.0 / 12.0;
+const E3 = 1.0 / 9.0;
+const E4 = -1.0 / 8.0;
+
+/** Solve initial value problem using the Bogacki-Shampine 3(2) method
+ * @param odes initial value problem for ordinary differential equations
+ * @param callback computations control callback
+ * @returns solution of the problem
+ * @example
+ * // Example. Solve the following initial value problem using the RK3 method:
+ * //   dx/dt = x + y - t
+ * //   dy/dt = x * y + t
+ * //   x(0) = 1
+ * //   y(0) = -1
+ * // on [0, 2] with the step 0.01.
+ * import { ODEs, rk3 } from 'diff-grok';
+ *
+ * const task: ODEs = {
+ *   name: 'Example', // name of your model
+ *   arg: {
+ *       name: 't',  // name of the argument
+ *       start: 0,   // initial value of the argument
+ *       finish: 2,  // final value of the argument
+ *       step: 0.01, // solution grid step
+ *   },
+ *   initial: [1, -1], // initial values
+ *   func: (t: number, y: Float64Array, output: Float64Array) => { // right-hand side of the system
+ *     output[0] = y[0] + y[1] - t; // 1-st equation
+ *     output[1] = y[0] * y[1] + t; // 2-nd equation
+ *   },
+ *   tolerance: 1e-7, // tolerance
+ *   solutionColNames: ['x', 'y'], // names of solution functions
+ * };
+ *
+ * try {
+ *   // Solve the problem using the RK3 method
+ *   const solution = rk3(task);
+ *
+ *   // Print a table with the results
+ *   console.log(task.arg.name, task.solutionColNames[0], task.solutionColNames[1]);
+ *   const length = solution[0].length;
+ *   for (let i = 0; i < length; ++i)
+ *     console.log(solution[0][i], solution[1][i], solution[2][i]);
+ * } catch (err) {
+ *   console.log('Solver failed: ', err instanceof Error ? err.message : 'Unknown problem!');
+ * }
+*/
+export function rk3(odes: ODEs, callback?: Callback): Float64Array[] {
+  const f = odes.func;
+
+  // operating variables
+  const t0 = odes.arg.start;
+  const t1 = odes.arg.finish;
+  let h = odes.arg.step;
+  const hDataframe = h;
+  const hMax = hDataframe * 10;
+  const tolerance = odes.tolerance;
+
+  const rowCount = Math.trunc((t1 - t0) / h) + 1;
+  const dim = odes.initial.length;
+
+  // result arrays
+  const tArr = new Float64Array(rowCount);
+  const yArrs = Array<Float64Array>(dim);
+
+  for (let i = 0; i < dim; ++i)
+    yArrs[i] = new Float64Array(rowCount);
+
+  // method routine
+  let timeDataframe = t0 + hDataframe;
+  let t = t0;
+  let tPrev = t0;
+  let hNext = 0.0;
+  let flag = true;
+  let index = 1;
+  let errmax = 0;
+  let hTemp = 0;
+  let tNew = 0;
+
+  // buffers
+  const y = new Float64Array(odes.initial);
+  const yPrev = new Float64Array(odes.initial);
+  const dydt = new Float64Array(dim);
+  const yScale = new Float64Array(dim);
+  const yTemp = new Float64Array(dim);
+  const yErr = new Float64Array(dim);
+
+  const k1 = new Float64Array(dim);
+  const k2 = new Float64Array(dim);
+  const k3 = new Float64Array(dim);
+  const k4 = new Float64Array(dim);
+
+  // 1. SOLUTION AT THE POINT t0
+  tArr[0] = t0;
+  for (let i = 0; i < dim; ++i)
+    yArrs[i][0] = y[i];
+
+  // 2. COMPUTE NUMERICAL SOLUTION FOR THE POINTS FROM THE INTERVAL (t0, t1)
+  while (flag) {
+    // compute derivative
+    f(t, y, dydt);
+
+    // check whether to go on computations
+    if (callback)
+      callback.onIterationStart();
+
+    // compute scale vector
+    for (let i = 0; i < dim; ++i)
+      yScale[i] = abs(y[i]) + h * abs(dydt[i]) + TINY;
+
+    // check end point
+    if (t + h > t1) {
+      h = t1 - t;
+      flag = false;
+    }
+
+    // adaptive step loop
+    while (true) {
+      // Stage 1: k1 = f(t, y)
+      f(t, y, k1);
+
+      // Stage 2: k2 = f(t + C2*h, y + h*A21*k1)
+      for (let i = 0; i < dim; ++i)
+        yTemp[i] = y[i] + h * A21 * k1[i];
+      f(t + C2 * h, yTemp, k2);
+
+      // Stage 3: k3 = f(t + C3*h, y + h*A32*k2)
+      for (let i = 0; i < dim; ++i)
+        yTemp[i] = y[i] + h * A32 * k2[i];
+      f(t + C3 * h, yTemp, k3);
+
+      // 3rd-order solution
+      for (let i = 0; i < dim; ++i)
+        yTemp[i] = y[i] + h * (B1 * k1[i] + B2 * k2[i] + B3 * k3[i]);
+
+      // Stage 4: k4 = f(t + h, yTemp) — needed for error estimate (FSAL)
+      f(t + h, yTemp, k4);
+
+      // Error estimate: difference between 3rd and 2nd order solutions
+      for (let i = 0; i < dim; ++i)
+        yErr[i] = h * (E1 * k1[i] + E2 * k2[i] + E3 * k3[i] + E4 * k4[i]);
+
+      // estimating error
+      errmax = 0;
+      for (let i = 0; i < dim; ++i)
+        errmax = max(errmax, abs(yErr[i] / yScale[i]));
+      errmax /= tolerance;
+
+      // processing the error obtained
+      if (errmax > 1) {
+        hTemp = SAFETY * h * errmax**PSHRNK;
+        h = max(hTemp, REDUCE_COEF * h);
+        tNew = t + h;
+        if (tNew == t)
+          throw new Error(ERROR_MSG.RK3_FAILS);
+      } else {
+        if (errmax > ERR_CONTR)
+          hNext = SAFETY * h * errmax**PSGROW;
+        else
+          hNext = GROW_COEF * h;
+
+        if (hNext > hMax)
+          hNext = hMax;
+
+        t = t + h;
+
+        for (let i = 0; i < dim; ++i)
+          y[i] = yTemp[i];
+
+        break;
+      }
+    } // while (true)
+
+    // compute linearly interpolated results and store them in dataframe
+    while (timeDataframe < t) {
+      const cLeft = (t - timeDataframe) / (t - tPrev);
+      const cRight = 1.0 - cLeft;
+
+      tArr[index] = timeDataframe;
+
+      for (let j = 0; j < dim; ++j)
+        yArrs[j][index] = cRight * y[j] + cLeft * yPrev[j];
+
+      timeDataframe += hDataframe;
+      ++index;
+    }
+
+    h = hNext;
+    tPrev = t;
+
+    for (let i = 0; i < dim; ++i)
+      yPrev[i] = y[i];
+  } // while (flag)
+
+  // perform final callback actions
+  if (callback)
+    callback.onComputationsCompleted();
+
+  // 3. solution at the point t1
+  tArr[rowCount - 1] = t1;
+
+  for (let i = 0; i < dim; ++i)
+    yArrs[i][rowCount - 1] = y[i];
+
+  // 4. prepare output
+  const solution = Array<Float64Array>(dim + 1);
+
+  // independent variable
+  solution[0] = tArr;
+
+  // functions
+  for (let i = 0; i < dim; ++i)
+    solution[i + 1] = yArrs[i];
+
+  return solution;
+} // rk3