diff-grok 1.0.10 → 1.1.0

package/src/tests/lsoda-lib-correctness.test.ts

@@ -0,0 +1,283 @@
+import {Lsoda} from '../solver-tools/lsoda';
+import {ODEs} from '../../index';
+import {corrProbs} from '../examples/corr-probs';
+
+// ─── Robertson chemical kinetics (original test) ────────────────────────────
+
+function fex(t: number, y: Float64Array, ydot: Float64Array): number {
+  ydot[0] = 1.0e4 * y[1] * y[2] - 0.04 * y[0];
+  ydot[2] = 3.0e7 * y[1] * y[1];
+  ydot[1] = -(ydot[0] + ydot[2]);
+  return 0;
+}
+
+const expected = [
+  {t: 4.0000e-01, y: [9.851712e-01, 3.386380e-05, 1.479493e-02]},
+  {t: 4.0000e+00, y: [9.055333e-01, 2.240655e-05, 9.444430e-02]},
+  {t: 4.0000e+01, y: [7.158403e-01, 9.186334e-06, 2.841505e-01]},
+  {t: 4.0000e+02, y: [4.505250e-01, 3.222964e-06, 5.494717e-01]},
+  {t: 4.0000e+03, y: [1.831976e-01, 8.941773e-07, 8.168015e-01]},
+  {t: 4.0000e+04, y: [3.898729e-02, 1.621940e-07, 9.610125e-01]},
+  {t: 4.0000e+05, y: [4.936362e-03, 1.984221e-08, 9.950636e-01]},
+  {t: 4.0000e+06, y: [5.161833e-04, 2.065787e-09, 9.994838e-01]},
+  {t: 4.0000e+07, y: [5.179804e-05, 2.072027e-10, 9.999482e-01]},
+  {t: 4.0000e+08, y: [5.283675e-06, 2.113481e-11, 9.999947e-01]},
+  {t: 4.0000e+09, y: [4.658667e-07, 1.863468e-12, 9.999995e-01]},
+  {t: 4.0000e+10, y: [1.431100e-08, 5.724404e-14, 1.000000e+00]},
+];
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function relError(computed: number, reference: number): number {
+  if (reference === 0) return Math.abs(computed);
+  return Math.abs((computed - reference) / reference);
+}
+
+/** Wraps an ODEs func into an OdeFunction compatible with Lsoda (returns 0). */
+function wrapFunc(ode: ODEs): (t: number, y: Float64Array, ydot: Float64Array) => number {
+  return (t, y, ydot) => {
+    ode.func(t, y, ydot);
+    return 0;
+  };
+}
+
+/**
+ * Solves an ODE problem and checks against the exact solution at the final time point.
+ * Uses combined absolute + relative tolerance: |computed - exact| < checkTol * |exact| + checkAbsTol.
+ */
+function solveAndCheck(
+  ode: ODEs,
+  exactSolution: (t: number) => Float64Array,
+  checkTol: number = 1e-3,
+  checkAbsTol: number = 1e-6,
+) {
+  const neq = ode.initial.length;
+  const tol = ode.tolerance;
+  const rtol = new Float64Array(neq).fill(tol);
+  const atol = new Float64Array(neq).fill(tol);
+
+  const solver = new Lsoda(wrapFunc(ode), neq, {rtol, atol, itask: 1});
+
+  let y: ArrayLike<number> = [...ode.initial];
+  let t = ode.arg.start;
+  const step = ode.arg.step;
+  const finish = ode.arg.finish;
+
+  let tout = t + step;
+  while (tout <= finish + step / 2) {
+    const result = solver.solve(y, t, tout);
+    y = result.y;
+    t = result.t;
+
+    expect(solver.state).toBeGreaterThan(0);
+    tout += step;
+  }
+
+  // Check final solution against exact using combined abs + rel tolerance
+  const exact = exactSolution(t);
+  for (let j = 0; j < neq; j++) {
+    const absErr = Math.abs(y[j] - exact[j]);
+    const allowed = checkTol * Math.abs(exact[j]) + checkAbsTol;
+    expect(absErr).toBeLessThan(allowed);
+  }
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+const nonStiffProbs = corrProbs.filter((p) => p.odes.name.startsWith('non-stiff'));
+const stiffProbs = corrProbs.filter((p) => p.odes.name.startsWith('stiff'));
+
+describe('LSODA LIB', () => {
+  it('should solve Robertson chemical kinetics with expected accuracy', () => {
+    const neq = 3;
+    const rtol = new Float64Array([1.0e-4, 1.0e-4, 1.0e-4]);
+    const atol = new Float64Array([1.0e-6, 1.0e-10, 1.0e-6]);
+
+    const solver = new Lsoda(fex, neq, {
+      rtol,
+      atol,
+      itask: 1,
+    });
+
+    let y: ArrayLike<number> = [1.0, 0.0, 0.0];
+    let t = 0.0;
+    let tout = 0.4;
+
+    for (let iout = 0; iout < 12; iout++) {
+      const result = solver.solve(y, t, tout);
+      y = result.y;
+      t = result.t;
+
+      expect(solver.state).toBeGreaterThan(0);
+
+      const exp = expected[iout];
+      for (let j = 0; j < 3; j++) {
+        const err = relError(y[j], exp.y[j]);
+        expect(err).toBeLessThanOrEqual(5e-3);
+      }
+
+      tout *= 10.0;
+    }
+  });
+
+  describe('non-stiff problems', () => {
+    nonStiffProbs.forEach(({odes, exact}) => {
+      it(`should solve ${odes.name} problem`, () => {
+        solveAndCheck(odes, exact);
+      });
+    });
+  });
+
+  describe('stiff problems', () => {
+    stiffProbs.forEach(({odes, exact}) => {
+      it(`should solve ${odes.name} problem`, () => {
+        solveAndCheck(odes, exact);
+      });
+    });
+  });
+
+  // ─── Dense output tests ───────────────────────────────────────────────────
+
+  describe('dense output', () => {
+    // Helper: run Robertson to completion with dense output enabled
+    function solveRobertsonDense() {
+      const neq = 3;
+      const rtol = new Float64Array([1.0e-4, 1.0e-4, 1.0e-4]);
+      const atol = new Float64Array([1.0e-6, 1.0e-10, 1.0e-6]);
+
+      const solver = new Lsoda(fex, neq, {rtol, atol, itask: 1, dense: true});
+
+      let y: ArrayLike<number> = [1.0, 0.0, 0.0];
+      let t = 0.0;
+      let tout = 0.4;
+
+      for (let iout = 0; iout < 12; iout++) {
+        const result = solver.solve(y, t, tout);
+        y = result.y;
+        t = result.t;
+        tout *= 10.0;
+      }
+
+      return solver.getDenseOutput();
+    }
+
+    it('consistency: dense output should match direct solver results (Robertson)', () => {
+      const dense = solveRobertsonDense();
+
+      // Query dense output at the same tout points used in the reference test
+      const tPoints = Float64Array.from(expected.map((e) => e.t));
+      const results = dense.solveAtTimes(tPoints);
+
+      for (let i = 0; i < expected.length; i++) {
+        for (let j = 0; j < 3; j++) {
+          const err = relError(results[j][i], expected[i].y[j]);
+          expect(err).toBeLessThanOrEqual(5e-3);
+        }
+      }
+    });
+
+    it('monotonicity: uniform query should have increasing t and finite y', () => {
+      const dense = solveRobertsonDense();
+
+      // Query at 1000 uniform points across the full range
+      const tMin = dense.tMin;
+      const tMax = dense.tMax;
+      const n = 1000;
+      const tArray = new Float64Array(n);
+      for (let i = 0; i < n; i++)
+        tArray[i] = tMin + (tMax - tMin) * i / (n - 1);
+
+      const results = dense.solveAtTimes(tArray);
+      expect(results.length).toBe(3);
+      for (let j = 0; j < 3; j++)
+        expect(results[j].length).toBe(n);
+
+      for (let i = 1; i < n; i++)
+        expect(tArray[i]).toBeGreaterThan(tArray[i - 1]);
+
+      for (let i = 0; i < n; i++) {
+        for (let j = 0; j < 3; j++)
+          expect(Number.isFinite(results[j][i])).toBe(true);
+      }
+    });
+
+    it('boundary: query at tMin and tMax should succeed', () => {
+      const dense = solveRobertsonDense();
+
+      const yMin = dense.evaluateAt(dense.tMin);
+      const yMax = dense.evaluateAt(dense.tMax);
+
+      expect(yMin.length).toBe(3);
+      expect(yMax.length).toBe(3);
+      for (let j = 0; j < 3; j++) {
+        expect(Number.isFinite(yMin[j])).toBe(true);
+        expect(Number.isFinite(yMax[j])).toBe(true);
+      }
+    });
+
+    it('solveOnGrid: should return correct grid dimensions and quality', () => {
+      const dense = solveRobertsonDense();
+
+      const {t, y} = dense.solveOnGrid(0, 4e10, 1e9);
+
+      expect(t.length).toBe(41);
+      expect(y.length).toBe(3);
+      for (let j = 0; j < 3; j++)
+        expect(y[j].length).toBe(41);
+      expect(t[0]).toBeCloseTo(0, 10);
+      expect(t[t.length - 1]).toBeCloseTo(4e10, 0);
+
+      // Check solution quality at a sampled point (t=4e10)
+      const refLast = expected[expected.length - 1].y;
+      for (let j = 0; j < 3; j++) {
+        const err = relError(y[j][t.length - 1], refLast[j]);
+        expect(err).toBeLessThanOrEqual(5e-3);
+      }
+    });
+
+    function denseExactCheck(
+      ode: ODEs,
+      exactSolution: (t: number) => Float64Array,
+      checkTol: number = 1e-3,
+      checkAbsTol: number = 1e-6,
+    ) {
+      const neq = ode.initial.length;
+      const tol = ode.tolerance;
+      const rtol = new Float64Array(neq).fill(tol);
+      const atol = new Float64Array(neq).fill(tol);
+
+      const solver = new Lsoda(wrapFunc(ode), neq, {rtol, atol, itask: 1, dense: true});
+
+      let y: ArrayLike<number> = [...ode.initial];
+      let t = ode.arg.start;
+      const finish = ode.arg.finish;
+      const result = solver.solve(y, t, finish);
+      y = result.y;
+      t = result.t;
+
+      const dense = solver.getDenseOutput();
+
+      // Query at 100 points and compare against exact solution
+      const nPts = 100;
+      const tArr = new Float64Array(nPts + 1);
+      for (let i = 0; i <= nPts; i++)
+        tArr[i] = ode.arg.start + (finish - ode.arg.start) * i / nPts;
+
+      const results = dense.solveAtTimes(tArr);
+      for (let i = 0; i < tArr.length; i++) {
+        const exact = exactSolution(tArr[i]);
+        for (let j = 0; j < neq; j++) {
+          const absErr = Math.abs(results[j][i] - exact[j]);
+          const allowed = checkTol * Math.abs(exact[j]) + checkAbsTol;
+          expect(absErr).toBeLessThan(allowed);
+        }
+      }
+    }
+
+    corrProbs.forEach(({odes, exact}) => {
+      it(`dense output on ${odes.name} problem should match exact solution`, () => {
+        denseExactCheck(odes, exact);
+      });
+    });
+  });
+});

package/src/tests/lsoda-lib-performance.test.js

@@ -0,0 +1,95 @@
+import { Lsoda } from '../solver-tools/lsoda';
+import { robertson, robertsonReferencePoint } from '../examples/robertson';
+import { hires, hiresReferencePoint } from '../examples/hires';
+import { vdpol, vdpolReferencePoint } from '../examples/vdpol';
+import { orego, oregoReferencePoint } from '../examples/orego';
+import { e5, e5ReferencePoint } from '../examples/e5';
+import { pollution, pollutionReferencePoint } from '../examples/pollution';
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+/** Wraps an ODEs func into an OdeFunction compatible with Lsoda (returns 0). */
+function wrapFunc(ode) {
+    return (t, y, ydot) => {
+        ode.func(t, y, ydot);
+        return 0;
+    };
+}
+/** Solves a benchmark problem, checks accuracy against the reference point, and verifies solver health. */
+function solveBenchmarkAndCheck(ode, referencePoint, relTol, absTol, opts) {
+    var _a, _b;
+    const neq = ode.initial.length;
+    const tol = ode.tolerance;
+    const rtol = (_a = opts === null || opts === void 0 ? void 0 : opts.rtol) !== null && _a !== void 0 ? _a : new Float64Array(neq).fill(tol);
+    const atol = (_b = opts === null || opts === void 0 ? void 0 : opts.atol) !== null && _b !== void 0 ? _b : new Float64Array(neq).fill(tol);
+    const solver = new Lsoda(wrapFunc(ode), neq, Object.assign(Object.assign({ rtol, atol, itask: 1 }, ((opts === null || opts === void 0 ? void 0 : opts.mxstep) ? { mxstep: opts.mxstep } : {})), ((opts === null || opts === void 0 ? void 0 : opts.hmax) ? { hmax: opts.hmax } : {})));
+    let y = [...ode.initial];
+    let t = ode.arg.start;
+    const step = ode.arg.step;
+    const finish = ode.arg.finish;
+    // Warmup phase: bootstrap very stiff problems with a small initial tout
+    if ((opts === null || opts === void 0 ? void 0 : opts.warmupTout) !== undefined) {
+        const result = solver.solve(y, t, opts.warmupTout);
+        y = result.y;
+        t = result.t;
+        expect(solver.state).toBeGreaterThan(0);
+    }
+    let tout = t + step;
+    while (tout <= finish + step / 2) {
+        const result = solver.solve(y, t, tout);
+        y = result.y;
+        t = result.t;
+        if (solver.state <= 0)
+            throw new Error(`${ode.name}: solver failed at t=${t} with state=${solver.state}, error: ${solver.error}`);
+        tout += step;
+    }
+    // Check final solution against reference point
+    for (let j = 0; j < neq; j++) {
+        const absErr = Math.abs(y[j] - referencePoint[j]);
+        const allowed = relTol * Math.abs(referencePoint[j]) + absTol;
+        expect(absErr).toBeLessThan(allowed);
+    }
+}
+// ─── Performance tests ──────────────────────────────────────────────────────
+// Robertson: components span many orders of magnitude; use component-wise atol
+describe('Robertson', () => {
+    it('should solve correctly', () => {
+        solveBenchmarkAndCheck(robertson, robertsonReferencePoint, 1e-2, 1e-7, {
+            mxstep: 50000,
+            atol: new Float64Array([1e-8, 1e-14, 1e-8]),
+            rtol: new Float64Array([1e-7, 1e-7, 1e-7]),
+        });
+    }, 60000);
+});
+describe('HIRES', () => {
+    it('should solve correctly', () => {
+        solveBenchmarkAndCheck(hires, hiresReferencePoint, 1e-3, 1e-12);
+    }, 60000);
+});
+// Van der Pol (mu=1000): very stiff, needs many internal steps
+describe('van der Pol', () => {
+    it('should solve correctly', () => {
+        solveBenchmarkAndCheck(vdpol, vdpolReferencePoint, 1e-3, 1e-6, {
+            mxstep: 50000,
+        });
+    }, 60000);
+});
+describe('OREGO', () => {
+    it('should solve correctly', () => {
+        solveBenchmarkAndCheck(orego, oregoReferencePoint, 1e-2, 1e-6);
+    }, 60000);
+});
+// E5: extremely stiff (rate constants span 20 orders), needs warmup and many steps.
+// Reference values are near-zero (y1~1e-290, y2~1e-22), so absTol must be generous.
+describe('E5', () => {
+    it('should solve correctly', () => {
+        solveBenchmarkAndCheck(e5, e5ReferencePoint, 1, 1e-6, {
+            mxstep: 50000,
+            warmupTout: 1e-5,
+        });
+    }, 60000);
+});
+describe('Pollution', () => {
+    it('should solve correctly', () => {
+        solveBenchmarkAndCheck(pollution, pollutionReferencePoint, 1e-2, 1e-10);
+    }, 60000);
+});
+//# sourceMappingURL=lsoda-lib-performance.test.js.map

package/src/tests/lsoda-lib-performance.test.js.map

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

package/src/tests/lsoda-lib-performance.test.ts

@@ -0,0 +1,126 @@
+import {Lsoda} from '../solver-tools/lsoda';
+import {ODEs} from '../../index';
+import {robertson, robertsonReferencePoint} from '../examples/robertson';
+import {hires, hiresReferencePoint} from '../examples/hires';
+import {vdpol, vdpolReferencePoint} from '../examples/vdpol';
+import {orego, oregoReferencePoint} from '../examples/orego';
+import {e5, e5ReferencePoint} from '../examples/e5';
+import {pollution, pollutionReferencePoint} from '../examples/pollution';
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+/** Wraps an ODEs func into an OdeFunction compatible with Lsoda (returns 0). */
+function wrapFunc(ode: ODEs): (t: number, y: Float64Array, ydot: Float64Array) => number {
+  return (t, y, ydot) => {
+    ode.func(t, y, ydot);
+    return 0;
+  };
+}
+
+interface SolverOpts {
+  mxstep?: number;
+  hmax?: number;
+  rtol?: Float64Array;
+  atol?: Float64Array;
+  /** Small initial tout to bootstrap very stiff problems before the main loop. */
+  warmupTout?: number;
+}
+
+/** Solves a benchmark problem, checks accuracy against the reference point, and verifies solver health. */
+function solveBenchmarkAndCheck(
+  ode: ODEs, referencePoint: Float64Array, relTol: number, absTol: number, opts?: SolverOpts,
+): void {
+  const neq = ode.initial.length;
+  const tol = ode.tolerance;
+  const rtol = opts?.rtol ?? new Float64Array(neq).fill(tol);
+  const atol = opts?.atol ?? new Float64Array(neq).fill(tol);
+
+  const solver = new Lsoda(wrapFunc(ode), neq, {
+    rtol, atol, itask: 1,
+    ...(opts?.mxstep ? {mxstep: opts.mxstep} : {}),
+    ...(opts?.hmax ? {hmax: opts.hmax} : {}),
+  });
+
+  let y: ArrayLike<number> = [...ode.initial];
+  let t = ode.arg.start;
+  const step = ode.arg.step;
+  const finish = ode.arg.finish;
+
+  // Warmup phase: bootstrap very stiff problems with a small initial tout
+  if (opts?.warmupTout !== undefined) {
+    const result = solver.solve(y, t, opts.warmupTout);
+    y = result.y;
+    t = result.t;
+    expect(solver.state).toBeGreaterThan(0);
+  }
+
+  let tout = t + step;
+  while (tout <= finish + step / 2) {
+    const result = solver.solve(y, t, tout);
+    y = result.y;
+    t = result.t;
+
+    if (solver.state <= 0)
+      throw new Error(`${ode.name}: solver failed at t=${t} with state=${solver.state}, error: ${solver.error}`);
+
+    tout += step;
+  }
+
+  // Check final solution against reference point
+  for (let j = 0; j < neq; j++) {
+    const absErr = Math.abs(y[j] - referencePoint[j]);
+    const allowed = relTol * Math.abs(referencePoint[j]) + absTol;
+    expect(absErr).toBeLessThan(allowed);
+  }
+}
+
+// ─── Performance tests ──────────────────────────────────────────────────────
+
+// Robertson: components span many orders of magnitude; use component-wise atol
+describe('Robertson', () => {
+  it('should solve correctly', () => {
+    solveBenchmarkAndCheck(robertson, robertsonReferencePoint, 1e-2, 1e-7, {
+      mxstep: 50000,
+      atol: new Float64Array([1e-8, 1e-14, 1e-8]),
+      rtol: new Float64Array([1e-7, 1e-7, 1e-7]),
+    });
+  }, 60000);
+});
+
+describe('HIRES', () => {
+  it('should solve correctly', () => {
+    solveBenchmarkAndCheck(hires, hiresReferencePoint, 1e-3, 1e-12);
+  }, 60000);
+});
+
+// Van der Pol (mu=1000): very stiff, needs many internal steps
+describe('van der Pol', () => {
+  it('should solve correctly', () => {
+    solveBenchmarkAndCheck(vdpol, vdpolReferencePoint, 1e-3, 1e-6, {
+      mxstep: 50000,
+    });
+  }, 60000);
+});
+
+describe('OREGO', () => {
+  it('should solve correctly', () => {
+    solveBenchmarkAndCheck(orego, oregoReferencePoint, 1e-2, 1e-6);
+  }, 60000);
+});
+
+// E5: extremely stiff (rate constants span 20 orders), needs warmup and many steps.
+// Reference values are near-zero (y1~1e-290, y2~1e-22), so absTol must be generous.
+describe('E5', () => {
+  it('should solve correctly', () => {
+    solveBenchmarkAndCheck(e5, e5ReferencePoint, 1, 1e-6, {
+      mxstep: 50000,
+      warmupTout: 1e-5,
+    });
+  }, 60000);
+});
+
+describe('Pollution', () => {
+  it('should solve correctly', () => {
+    solveBenchmarkAndCheck(pollution, pollutionReferencePoint, 1e-2, 1e-10);
+  }, 60000);
+});

package/src/tests/performance.test.js

@@ -1,13 +1,15 @@
 // Performance tests
 import { perfProbs } from '../../index';
-import { methods, TIMEOUT_MS } from './test-defs';
-methods.forEach((method, name) => {
-    perfProbs.forEach((odes) => {
-        test(`Performance: method - ${name}, problem - ${odes.name}`, () => {
-            const start = performance.now();
-            method(odes);
-            const elapsed = performance.now() - start;
-            expect(elapsed).toBeLessThan(TIMEOUT_MS);
+import { implicitMethods, TIMEOUT_MS } from './test-defs';
+implicitMethods.forEach((method, name) => {
+    describe(`${name}`, () => {
+        perfProbs.forEach((odes) => {
+            test(`${odes.name}`, () => {
+                const start = performance.now();
+                method(odes);
+                const elapsed = performance.now() - start;
+                expect(elapsed).toBeLessThan(TIMEOUT_MS);
+            });
         });
     });
 });

package/src/tests/performance.test.js.map

@@ -1 +1 @@
-{"version":3,"file":"performance.test.js","sourceRoot":"","sources":["performance.test.ts"],"names":[],"mappings":"AAAA,oBAAoB;AAEpB,OAAO,EAAC,SAAS,EAAC,MAAM,aAAa,CAAC;AACtC,OAAO,EAAC,OAAO,EAAE,UAAU,EAAC,MAAM,aAAa,CAAC;AAEhD,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE;IAC/B,SAAS,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;QACzB,IAAI,CAAC,yBAAyB,IAAI,eAAe,IAAI,CAAC,IAAI,EAAE,EAAE,GAAG,EAAE;YACjE,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;YAChC,MAAM,CAAC,IAAI,CAAC,CAAC;YACb,MAAM,OAAO,GAAG,WAAW,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC;YAC1C,MAAM,CAAC,OAAO,CAAC,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}
+{"version":3,"file":"performance.test.js","sourceRoot":"","sources":["performance.test.ts"],"names":[],"mappings":"AAAA,oBAAoB;AAEpB,OAAO,EAAC,SAAS,EAAC,MAAM,aAAa,CAAC;AACtC,OAAO,EAAC,eAAe,EAAE,UAAU,EAAC,MAAM,aAAa,CAAC;AAExD,eAAe,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE;IACvC,QAAQ,CAAC,GAAG,IAAI,EAAE,EAAE,GAAG,EAAE;QACvB,SAAS,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;YACzB,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,EAAE,EAAE,GAAG,EAAE;gBACxB,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;gBAChC,MAAM,CAAC,IAAI,CAAC,CAAC;gBACb,MAAM,OAAO,GAAG,WAAW,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC;gBAC1C,MAAM,CAAC,OAAO,CAAC,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;YAC3C,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/src/tests/performance.test.ts

@@ -1,15 +1,17 @@
 // Performance tests
 
 import {perfProbs} from '../../index';
-import {methods, TIMEOUT_MS} from './test-defs';
+import {implicitMethods, TIMEOUT_MS} from './test-defs';
 
-methods.forEach((method, name) => {
-  perfProbs.forEach((odes) => {
-    test(`Performance: method - ${name}, problem - ${odes.name}`, () => {
-      const start = performance.now();
-      method(odes);
-      const elapsed = performance.now() - start;
-      expect(elapsed).toBeLessThan(TIMEOUT_MS);
+implicitMethods.forEach((method, name) => {
+  describe(`${name}`, () => {
+    perfProbs.forEach((odes) => {
+      test(`${odes.name}`, () => {
+        const start = performance.now();
+        method(odes);
+        const elapsed = performance.now() - start;
+        expect(elapsed).toBeLessThan(TIMEOUT_MS);
+      });
     });
   });
 });

package/src/tests/test-defs.js

@@ -1,9 +1,22 @@
 /* eslint-disable max-len */
-import { mrt, ros3prw, ros34prw } from '../../index';
+import { mrt, ros3prw, ros34prw, rk4, ab5, ab4, rkdp, rk3, lsoda } from '../../index';
 export const methods = new Map([
     ['MRT', mrt],
     ['ROS3PRw', ros3prw],
     ['ROS34PRw', ros34prw],
+    ['RK4', rk4],
+    ['AB5', ab5],
+    ['AB4', ab4],
+    ['RKDP', rkdp],
+    ['RK3', rk3],
+    ['LSODA', lsoda],
+]);
+/** Implicit methods suitable for stiff performance benchmarks */
+export const implicitMethods = new Map([
+    ['MRT', mrt],
+    ['ROS3PRw', ros3prw],
+    ['ROS34PRw', ros34prw],
+    ['LSODA', lsoda],
 ]);
 export const MAX_MAD = 0.1;
 export const TIMEOUT_MS = 10000;

package/src/tests/test-defs.js.map

@@ -1 +1 @@
-{"version":3,"file":"test-defs.js","sourceRoot":"","sources":["test-defs.ts"],"names":[],"mappings":"AAAA,4BAA4B;AAC5B,OAAO,EAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAC,MAAM,aAAa,CAAC;AAEnD,MAAM,CAAC,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC;IAC7B,CAAC,KAAK,EAAE,GAAG,CAAC;IACZ,CAAC,SAAS,EAAE,OAAO,CAAC;IACpB,CAAC,UAAU,EAAE,QAAQ,CAAC;CACvB,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,OAAO,GAAG,GAAG,CAAC;AAC3B,MAAM,CAAC,MAAM,UAAU,GAAG,KAAK,CAAC;AAEhC,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uGAkCmF,CAAC;AAExG,MAAM,kBAAkB,GAAG;IACzB,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,EAAE;IACP,EAAE,EAAE,CAAC;IACL,EAAE,EAAE,CAAC;IACL,EAAE,EAAE,CAAC;IACL,EAAE,EAAE,CAAC;IACL,EAAE,EAAE,CAAC;IACL,OAAO,EAAE,EAAE;IACX,OAAO,EAAE,GAAG;CACb,CAAC;AAEF,MAAM,mBAAmB,GAAG,CAAC,CAAC;AAE9B,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuCJ,CAAC;AAElB,MAAM,mBAAmB,GAAG;IAC1B,MAAM,EAAE,EAAE;IACV,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,EAAE;IACP,EAAE,EAAE,CAAC;IACL,KAAK,EAAE,CAAC;IACR,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC;IACP,GAAG,EAAE,GAAG;IACR,IAAI,EAAE,KAAK;IACX,EAAE,EAAE,IAAI;IACR,EAAE,EAAE,GAAG;IACP,EAAE,EAAE,IAAI;IACR,CAAC,EAAE,KAAK;IACR,EAAE,EAAE,IAAI;IACR,IAAI,EAAE,IAAI;IACV,GAAG,EAAE,KAAK;IACV,IAAI,EAAE,KAAK;CACZ,CAAC;AAEF,MAAM,oBAAoB,GAAG,CAAC,CAAC;AAE/B,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiDR,CAAC;AAElB,MAAM,uBAAuB,GAAG;IAC9B,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,EAAE;IACP,EAAE,EAAE,CAAC;IACL,CAAC,EAAE,CAAC;IACJ,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,CAAC;IACJ,CAAC,EAAE,CAAC;IACJ,OAAO,EAAE,GAAG;IACZ,GAAG,EAAE,KAAK;IACV,KAAK,EAAE,IAAI;IACX,IAAI,EAAE,KAAK;IACX,KAAK,EAAE,IAAI;IACX,MAAM,EAAE,KAAK;IACb,KAAK,EAAE,KAAK;IACZ,GAAG,EAAE,OAAO;IACZ,EAAE,EAAE,OAAO;IACX,EAAE,EAAE,OAAO;IACX,GAAG,EAAE,MAAM;IACX,GAAG,EAAE,EAAE;CACR,CAAC;AAEF,MAAM,wBAAwB,GAAG,CAAC,CAAC;AAQnC,MAAM,CAAC,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAsB;IACnD,CAAC,OAAO,EAAE,EAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,kBAAkB,EAAE,YAAY,EAAE,mBAAmB,EAAC,CAAC;IAC9F,CAAC,QAAQ,EAAE,EAAC,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,mBAAmB,EAAE,YAAY,EAAE,oBAAoB,EAAC,CAAC;IAClG,CAAC,YAAY,EAAE,EAAC,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,uBAAuB,EAAE,YAAY,EAAE,wBAAwB,EAAC,CAAC;CACnH,CAAC,CAAC"}
+{"version":3,"file":"test-defs.js","sourceRoot":"","sources":["test-defs.ts"],"names":[],"mappings":"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"}

package/src/tests/test-defs.ts

@@ -1,10 +1,24 @@
 /* eslint-disable max-len */
-import {mrt, ros3prw, ros34prw} from '../../index';
+import {mrt, ros3prw, ros34prw, rk4, ab5, ab4, rkdp, rk3, lsoda} from '../../index';
 
 export const methods = new Map([
   ['MRT', mrt],
   ['ROS3PRw', ros3prw],
   ['ROS34PRw', ros34prw],
+  ['RK4', rk4],
+  ['AB5', ab5],
+  ['AB4', ab4],
+  ['RKDP', rkdp],
+  ['RK3', rk3],
+  ['LSODA', lsoda],
+]);
+
+/** Implicit methods suitable for stiff performance benchmarks */
+export const implicitMethods = new Map([
+  ['MRT', mrt],
+  ['ROS3PRw', ros3prw],
+  ['ROS34PRw', ros34prw],
+  ['LSODA', lsoda],
 ]);
 
 export const MAX_MAD = 0.1;

package/src/worker-tools/solving.js

@@ -1,5 +1,5 @@
 // Tools for solving IVPs in web-workers
-import { mrt, ros3prw, ros34prw, getCallback } from '../solver-tools';
+import { mrt, ros3prw, ros34prw, getCallback, rk4, ab5, ab4, rkdp, rk3, lsoda } from '../solver-tools';
 import { getFunc } from './scripting';
 const ARG_INIT = 0;
 const ARG_FINAL = 1;
@@ -12,6 +12,18 @@ function getMethod(name) {
             return mrt;
         case 'ros3prw':
             return ros3prw;
+        case 'rk4':
+            return rk4;
+        case 'ab5':
+            return ab5;
+        case 'ab4':
+            return ab4;
+        case 'rkdp':
+            return rkdp;
+        case 'rk3':
+            return rk3;
+        case 'lsoda':
+            return lsoda;
         default:
             return ros34prw;
     }

package/src/worker-tools/solving.js.map

@@ -1 +1 @@
-{"version":3,"file":"solving.js","sourceRoot":"","sources":["solving.ts"],"names":[],"mappings":"AAAA,wCAAwC;AAExC,OAAO,EAAe,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAQ,WAAW,EAAC,MAAM,iBAAiB,CAAC;AAExF,OAAO,EAAgB,OAAO,EAAC,MAAM,aAAa,CAAC;AAEnD,MAAM,QAAQ,GAAG,CAAC,CAAC;AACnB,MAAM,SAAS,GAAG,CAAC,CAAC;AACpB,MAAM,QAAQ,GAAG,CAAC,CAAC;AACnB,MAAM,aAAa,GAAG,CAAC,CAAC;AAExB,oCAAoC;AACpC,SAAS,SAAS,CAAC,IAAwB;IACzC,QAAQ,IAAI,EAAE,CAAC;QACf,KAAK,KAAK;YACR,OAAO,GAAG,CAAC;QAEb,KAAK,SAAS;YACZ,OAAO,OAAO,CAAC;QAEjB;YACE,OAAO,QAAQ,CAAC;IAClB,CAAC;AACH,CAAC;AAED,gDAAgD;AAChD,SAAS,WAAW,CAAC,GAAkB,EAAE,MAAoB;IAC3D,MAAM,QAAQ,GAAG,aAAa,GAAG,GAAG,CAAC,SAAS,GAAG,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC;IAEvE,IAAI,QAAQ,GAAG,MAAM,CAAC,MAAM;QAC1B,MAAM,IAAI,KAAK,CAAC,qCAAqC,QAAQ,cAAc,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;AAChG,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,QAAQ,CAAC,GAAkB,EAAE,MAAoB;IAC/D,WAAW,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IACzB,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,GAAG,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC;IAElE,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC,CAAC;IACjE,MAAM,IAAI,GAAG,IAAI,QAAQ,CAAC,QAAQ,CAAS,CAAC;IAE5C,MAAM,IAAI,GAAS;QACjB,IAAI,EAAE,EAAE;QACR,GAAG,EAAE;YACH,IAAI,EAAE,EAAE;YACR,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC;YACvB,MAAM,EAAE,MAAM,CAAC,SAAS,CAAC;YACzB,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC;SACvB;QACD,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,QAAQ,GAAG,CAAC,EAAE,mBAAmB,CAAC;QACxD,IAAI,EAAE,IAAI;QACV,SAAS,EAAE,GAAG,CAAC,SAAS;QACxB,gBAAgB,EAAE,EAAE;KACrB,CAAC;IAEF,MAAM,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IAChD,MAAM,QAAQ,GAAG,WAAW,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAE7C,OAAO,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;AAChC,CAAC"}
+{"version":3,"file":"solving.js","sourceRoot":"","sources":["solving.ts"],"names":[],"mappings":"AAAA,wCAAwC;AAExC,OAAO,EAAe,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAQ,WAAW,EAC7D,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAC,MAAM,iBAAiB,CAAC;AAE1D,OAAO,EAAgB,OAAO,EAAC,MAAM,aAAa,CAAC;AAEnD,MAAM,QAAQ,GAAG,CAAC,CAAC;AACnB,MAAM,SAAS,GAAG,CAAC,CAAC;AACpB,MAAM,QAAQ,GAAG,CAAC,CAAC;AACnB,MAAM,aAAa,GAAG,CAAC,CAAC;AAExB,oCAAoC;AACpC,SAAS,SAAS,CAAC,IAAwB;IACzC,QAAQ,IAAI,EAAE,CAAC;QACf,KAAK,KAAK;YACR,OAAO,GAAG,CAAC;QAEb,KAAK,SAAS;YACZ,OAAO,OAAO,CAAC;QAEjB,KAAK,KAAK;YACR,OAAO,GAAG,CAAC;QAEb,KAAK,KAAK;YACR,OAAO,GAAG,CAAC;QAEb,KAAK,KAAK;YACR,OAAO,GAAG,CAAC;QAEb,KAAK,MAAM;YACT,OAAO,IAAI,CAAC;QAEd,KAAK,KAAK;YACR,OAAO,GAAG,CAAC;QAEb,KAAK,OAAO;YACV,OAAO,KAAK,CAAC;QAEf;YACE,OAAO,QAAQ,CAAC;IAClB,CAAC;AACH,CAAC;AAED,gDAAgD;AAChD,SAAS,WAAW,CAAC,GAAkB,EAAE,MAAoB;IAC3D,MAAM,QAAQ,GAAG,aAAa,GAAG,GAAG,CAAC,SAAS,GAAG,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC;IAEvE,IAAI,QAAQ,GAAG,MAAM,CAAC,MAAM;QAC1B,MAAM,IAAI,KAAK,CAAC,qCAAqC,QAAQ,cAAc,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;AAChG,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,QAAQ,CAAC,GAAkB,EAAE,MAAoB;IAC/D,WAAW,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IACzB,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,GAAG,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC;IAElE,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC,CAAC;IACjE,MAAM,IAAI,GAAG,IAAI,QAAQ,CAAC,QAAQ,CAAS,CAAC;IAE5C,MAAM,IAAI,GAAS;QACjB,IAAI,EAAE,EAAE;QACR,GAAG,EAAE;YACH,IAAI,EAAE,EAAE;YACR,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC;YACvB,MAAM,EAAE,MAAM,CAAC,SAAS,CAAC;YACzB,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC;SACvB;QACD,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,QAAQ,GAAG,CAAC,EAAE,mBAAmB,CAAC;QACxD,IAAI,EAAE,IAAI;QACV,SAAS,EAAE,GAAG,CAAC,SAAS;QACxB,gBAAgB,EAAE,EAAE;KACrB,CAAC;IAEF,MAAM,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IAChD,MAAM,QAAQ,GAAG,WAAW,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAE7C,OAAO,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;AAChC,CAAC"}