diff-grok 1.0.10 → 1.2.0

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

@@ -0,0 +1,505 @@
+import {
+  Cvode, cvodeCreate, cvodeInit, cvode, cvodeSStolerances, cvodeSVtolerances,
+  cvodeSetLinearSolver, cvodeGetDky,
+  CV_BDF, CV_NORMAL,
+  CV_SUCCESS, CV_ROOT_RETURN, CV_TOO_MUCH_WORK,
+} from '../solver-tools/cvode';
+import type {OdeFunction, CvodeSolveResult, CvodeRhsFn} from '../solver-tools/cvode';
+import {ODEs} from '../../index';
+import {corrProbs} from '../examples/corr-probs';
+
+// ─── Robertson chemical kinetics (original test) ────────────────────────────
+
+function robertsonRhs(t: number, y: Float64Array, ydot: Float64Array): void {
+  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]);
+}
+
+/** Low-level RHS for Robertson (returns int). */
+function robertsonRhsLowLevel(t: number, y: Float64Array, ydot: Float64Array, _userData: any): number {
+  robertsonRhs(t, y, ydot);
+  return 0;
+}
+
+const robertsonExpected = [
+  {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]},
+];
+
+// Robertson solver tolerances for CVODE.
+const ROBERTSON_SOLVER_RTOL = 1e-8;
+const ROBERTSON_SOLVER_ATOL = new Float64Array([1e-10, 1e-14, 1e-10]);
+
+// Number of Robertson output points to check with strict relative tolerance.
+// At very late times (t>=4e8) the solution components become extremely small
+// (y1~1e-5, y2~1e-10) and accumulated integration error over many orders of
+// magnitude of time makes pure relative error checks impractical. We check
+// the first 9 points (up to t=4e7) with strict tolerance and use qualitative
+// checks for the remaining points.
+const ROBERTSON_STRICT_POINTS = 9;
+const ROBERTSON_CHECK_TOL = 5e-3;
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function relError(computed: number, reference: number): number {
+  if (reference === 0) return Math.abs(computed);
+  return Math.abs((computed - reference) / reference);
+}
+
+/**
+ * Solves an ODE with the Cvode class and checks against exact solution at the final time.
+ * Uses combined absolute + relative tolerance: |computed - exact| < checkTol * |exact| + checkAbsTol.
+ */
+function solveAndCheck(
+  ode: ODEs,
+  exactSolution: (t: number) => Float64Array,
+  lmm: 'adams' | 'bdf',
+  checkTol: number = 1e-3,
+  checkAbsTol: number = 1e-6,
+) {
+  const neq = ode.initial.length;
+  const tol = ode.tolerance;
+
+  const solver = new Cvode(ode.func, neq, ode.arg.start, Float64Array.from(ode.initial), {
+    lmm,
+    rtol: tol,
+    atol: tol,
+  });
+
+  let t = ode.arg.start;
+  const step = ode.arg.step;
+  const finish = ode.arg.finish;
+  let result: CvodeSolveResult;
+
+  let tout = t + step;
+  while (tout <= finish + step / 2) {
+    result = solver.solve(tout);
+    expect(result.flag).toBe(CV_SUCCESS);
+    t = result.t;
+    tout += step;
+  }
+
+  // Check final solution against exact
+  const exact = exactSolution(t);
+  const y = result!.y;
+  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);
+  }
+}
+
+/**
+ * Dense output helper: solve an ODE to evenly spaced output points, then use getDky
+ * to verify the interpolation matches the exact solution.
+ */
+function denseExactCheck(
+  ode: ODEs,
+  exactSolution: (t: number) => Float64Array,
+  lmm: 'adams' | 'bdf',
+  checkTol: number = 1e-3,
+  checkAbsTol: number = 1e-6,
+) {
+  const neq = ode.initial.length;
+  const tol = ode.tolerance;
+
+  const solver = new Cvode(ode.func, neq, ode.arg.start, Float64Array.from(ode.initial), {
+    lmm,
+    rtol: tol,
+    atol: tol,
+  });
+
+  const start = ode.arg.start;
+  const finish = ode.arg.finish;
+  const nOutputPts = 100;
+  let nChecked = 0;
+
+  for (let i = 1; i <= nOutputPts; i++) {
+    const tout = start + (finish - start) * i / nOutputPts;
+    const result = solver.solve(tout);
+    expect(result.flag).toBe(CV_SUCCESS);
+
+    // getDky at the output time should match the solve result
+    const dky = solver.getDky(result.t, 0);
+    const exact = exactSolution(result.t);
+
+    for (let j = 0; j < neq; j++) {
+      // Dense output should match the direct solve result
+      expect(Math.abs(dky[j] - result.y[j])).toBeLessThan(1e-12);
+
+      // Dense output should match the exact solution
+      const absErr = Math.abs(dky[j] - exact[j]);
+      const allowed = checkTol * Math.abs(exact[j]) + checkAbsTol;
+      expect(absErr).toBeLessThan(allowed);
+    }
+    nChecked++;
+  }
+
+  // Ensure we actually checked points
+  expect(nChecked).toBe(nOutputPts);
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+const nonStiffProbs = corrProbs.filter((p) => p.odes.name.startsWith('non-stiff'));
+const stiffProbs = corrProbs.filter((p) => p.odes.name.startsWith('stiff'));
+
+describe('CVODE LIB', () => {
+  it('should solve Robertson chemical kinetics with Cvode class', () => {
+    const neq = 3;
+    const solver = new Cvode(robertsonRhs, neq, 0.0, Float64Array.from([1.0, 0.0, 0.0]), {
+      lmm: 'bdf',
+      rtol: ROBERTSON_SOLVER_RTOL,
+      atol: ROBERTSON_SOLVER_ATOL,
+    });
+
+    let tout = 0.4;
+    for (let iout = 0; iout < 12; iout++) {
+      const result = solver.solve(tout);
+      expect(result.flag).toBe(CV_SUCCESS);
+
+      const exp = robertsonExpected[iout];
+      if (iout < ROBERTSON_STRICT_POINTS) {
+        for (let j = 0; j < 3; j++) {
+          const err = relError(result.y[j], exp.y[j]);
+          expect(err).toBeLessThanOrEqual(ROBERTSON_CHECK_TOL);
+        }
+      } else {
+        const sum = result.y[0] + result.y[1] + result.y[2];
+        expect(Math.abs(sum - 1.0)).toBeLessThan(1e-4);
+        expect(result.y[2]).toBeGreaterThan(0.999);
+      }
+
+      tout *= 10.0;
+    }
+  });
+
+  it('should solve Robertson chemical kinetics with the low-level API', () => {
+    const neq = 3;
+    const y0 = Float64Array.from([1.0, 0.0, 0.0]);
+
+    const mem = cvodeCreate(CV_BDF);
+    cvodeInit(mem, robertsonRhsLowLevel, 0.0, y0);
+    cvodeSVtolerances(mem, ROBERTSON_SOLVER_RTOL, ROBERTSON_SOLVER_ATOL);
+    cvodeSetLinearSolver(mem);
+
+    const yout = new Float64Array(neq);
+    let tout = 0.4;
+
+    for (let iout = 0; iout < 12; iout++) {
+      const {flag, t} = cvode(mem, tout, yout, CV_NORMAL);
+      expect(flag).toBe(CV_SUCCESS);
+
+      const exp = robertsonExpected[iout];
+      if (iout < ROBERTSON_STRICT_POINTS) {
+        for (let j = 0; j < 3; j++) {
+          const err = relError(yout[j], exp.y[j]);
+          expect(err).toBeLessThanOrEqual(ROBERTSON_CHECK_TOL);
+        }
+      } else {
+        const sum = yout[0] + yout[1] + yout[2];
+        expect(Math.abs(sum - 1.0)).toBeLessThan(1e-4);
+        expect(yout[2]).toBeGreaterThan(0.999);
+      }
+
+      tout *= 10.0;
+    }
+  });
+
+  describe('non-stiff problems (Adams)', () => {
+    nonStiffProbs.forEach(({odes, exact}) => {
+      it(`should solve ${odes.name} problem`, () => {
+        solveAndCheck(odes, exact, 'adams');
+      });
+    });
+  });
+
+  describe('stiff problems (BDF)', () => {
+    stiffProbs.forEach(({odes, exact}) => {
+      it(`should solve ${odes.name} problem`, () => {
+        solveAndCheck(odes, exact, 'bdf');
+      });
+    });
+  });
+
+  // ─── Rootfinding ─────────────────────────────────────────────────────────
+
+  describe('rootfinding', () => {
+    it('should detect roots in Robertson system', () => {
+      const neq = 3;
+
+      // Root functions: g1 = y1 - 1e-4, g2 = y3 - 0.01
+      const rootFn = (t: number, y: Float64Array, gout: Float64Array): void => {
+        gout[0] = y[0] - 1e-4;
+        gout[1] = y[2] - 0.01;
+      };
+
+      const solver = new Cvode(robertsonRhs, neq, 0.0, Float64Array.from([1.0, 0.0, 0.0]), {
+        lmm: 'bdf',
+        rtol: ROBERTSON_SOLVER_RTOL,
+        atol: ROBERTSON_SOLVER_ATOL,
+        rootFn,
+        nRootFns: 2,
+      });
+
+      const rootTimes: number[] = [];
+      const rootIndices: Int32Array[] = [];
+
+      // Advance through the problem, collecting root returns
+      let tout = 0.4;
+      const tEnd = 4e10;
+
+      while (tout <= tEnd) {
+        const result = solver.solve(tout);
+
+        if (result.flag === CV_ROOT_RETURN) {
+          rootTimes.push(result.t);
+          rootIndices.push(result.rootsFound!);
+          // Continue from the root time; do not advance tout yet
+          continue;
+        }
+
+        expect(result.flag).toBe(CV_SUCCESS);
+        tout *= 10.0;
+      }
+
+      // Expect at least 2 roots: y3 reaches 0.01 first, then y1 drops to 1e-4
+      expect(rootTimes.length).toBeGreaterThanOrEqual(2);
+
+      // First root: y3 = 0.01, near t ~ 2.6391e-1
+      const tRoot1 = rootTimes[0];
+      expect(relError(tRoot1, 2.6391e-1)).toBeLessThan(2e-2);
+      // rootsFound should indicate root function index 1 (g2)
+      expect(rootIndices[0][1]).not.toBe(0);
+
+      // Second root: y1 = 1e-4, near t ~ 2.0790e+7
+      const tRoot2 = rootTimes[1];
+      expect(relError(tRoot2, 2.0790e7)).toBeLessThan(2e-2);
+      // rootsFound should indicate root function index 0 (g1)
+      expect(rootIndices[1][0]).not.toBe(0);
+    });
+  });
+
+  // ─── Dense output tests ─────────────────────────────────────────────────
+
+  describe('dense output (getDky)', () => {
+    it('consistency: getDky at output points should match solve results (Robertson)', () => {
+      const neq = 3;
+      const solver = new Cvode(robertsonRhs, neq, 0.0, Float64Array.from([1.0, 0.0, 0.0]), {
+        lmm: 'bdf',
+        rtol: ROBERTSON_SOLVER_RTOL,
+        atol: ROBERTSON_SOLVER_ATOL,
+      });
+
+      let tout = 0.4;
+      for (let iout = 0; iout < 12; iout++) {
+        const result = solver.solve(tout);
+        expect(result.flag).toBe(CV_SUCCESS);
+
+        // getDky at the output time should match the solve result
+        const dky = solver.getDky(result.t, 0);
+        for (let j = 0; j < neq; j++)
+          expect(Math.abs(dky[j] - result.y[j])).toBeLessThan(1e-12);
+
+
+        tout *= 10.0;
+      }
+    });
+
+    it('monotonicity: getDky at successive output points should produce finite values', () => {
+      const neq = 3;
+      const solver = new Cvode(robertsonRhs, neq, 0.0, Float64Array.from([1.0, 0.0, 0.0]), {
+        lmm: 'bdf',
+        rtol: ROBERTSON_SOLVER_RTOL,
+        atol: ROBERTSON_SOLVER_ATOL,
+      });
+
+      // Solve to 1000 uniformly spaced points across [0.01, 1.0]
+      const n = 1000;
+      const tMin = 0.01;
+      const tMax = 1.0;
+      let prevT = 0.0;
+
+      for (let i = 0; i < n; i++) {
+        const tout = tMin + (tMax - tMin) * i / (n - 1);
+        const result = solver.solve(tout);
+        expect(result.flag).toBe(CV_SUCCESS);
+
+        // Time should advance monotonically
+        expect(result.t).toBeGreaterThan(prevT);
+        prevT = result.t;
+
+        // getDky at the output point should return finite values
+        const dky = solver.getDky(result.t, 0);
+        for (let j = 0; j < neq; j++)
+          expect(Number.isFinite(dky[j])).toBe(true);
+      }
+    });
+
+    it('boundary: getDky at endpoints of the current step interval', () => {
+      const neq = 3;
+      const solver = new Cvode(robertsonRhs, neq, 0.0, Float64Array.from([1.0, 0.0, 0.0]), {
+        lmm: 'bdf',
+        rtol: ROBERTSON_SOLVER_RTOL,
+        atol: ROBERTSON_SOLVER_ATOL,
+      });
+
+      // Advance to a point to establish state
+      const result = solver.solve(0.4);
+      expect(result.flag).toBe(CV_SUCCESS);
+
+      // getDky at the last output time should succeed
+      const dkyEnd = solver.getDky(result.t, 0);
+      for (let j = 0; j < neq; j++)
+        expect(Number.isFinite(dkyEnd[j])).toBe(true);
+
+
+      // Query derivative (k=1) - first derivative at output time
+      const dkyDeriv = solver.getDky(result.t, 1);
+      for (let j = 0; j < neq; j++)
+        expect(Number.isFinite(dkyDeriv[j])).toBe(true);
+    });
+
+    corrProbs.forEach(({odes, exact}) => {
+      const lmm = odes.name.startsWith('stiff') ? 'bdf' as const : 'adams' as const;
+      it(`dense output on ${odes.name} problem should match exact solution`, () => {
+        denseExactCheck(odes, exact, lmm);
+      });
+    });
+  });
+
+  // ─── Error handling ─────────────────────────────────────────────────────
+
+  describe('error handling', () => {
+    it('should return error for negative tolerances (low-level API)', () => {
+      const mem = cvodeCreate(CV_BDF);
+      cvodeInit(mem, robertsonRhsLowLevel, 0.0, Float64Array.from([1.0, 0.0, 0.0]));
+
+      const flag = cvodeSStolerances(mem, -1e-4, 1e-6);
+      expect(flag).toBeLessThan(0);
+    });
+
+    it('should return CV_TOO_MUCH_WORK with maxSteps: 1', () => {
+      const neq = 3;
+      const solver = new Cvode(robertsonRhs, neq, 0.0, Float64Array.from([1.0, 0.0, 0.0]), {
+        lmm: 'bdf',
+        rtol: ROBERTSON_SOLVER_RTOL,
+        atol: ROBERTSON_SOLVER_ATOL,
+        maxSteps: 1,
+      });
+
+      const result = solver.solve(4e10);
+      expect(result.flag).toBe(CV_TOO_MUCH_WORK);
+    });
+
+    it('should return error flag when RHS function fails', () => {
+      const failingRhs: OdeFunction = (_t, _y, ydot) => {
+        ydot[0] = NaN;
+      };
+
+      const solver = new Cvode(failingRhs, 1, 0.0, Float64Array.from([1.0]), {
+        lmm: 'bdf',
+        rtol: 1e-4,
+        atol: 1e-6,
+      });
+
+      const result = solver.solve(1.0);
+      expect(result.flag).toBeLessThan(0);
+    });
+  });
+
+  // ─── Cvode class features ──────────────────────────────────────────────
+
+  describe('Cvode class features', () => {
+    it('getStats should return valid integrator statistics', () => {
+      const neq = 3;
+      const solver = new Cvode(robertsonRhs, neq, 0.0, Float64Array.from([1.0, 0.0, 0.0]), {
+        lmm: 'bdf',
+        rtol: ROBERTSON_SOLVER_RTOL,
+        atol: ROBERTSON_SOLVER_ATOL,
+      });
+
+      // Solve to first output point
+      solver.solve(0.4);
+
+      const stats = solver.getStats();
+      expect(stats.nSteps).toBeGreaterThan(0);
+      expect(stats.nRhsEvals).toBeGreaterThan(0);
+      expect(stats.nLinSolvSetups).toBeGreaterThanOrEqual(0);
+      expect(stats.nErrTestFails).toBeGreaterThanOrEqual(0);
+      expect(stats.nNonlinSolvIters).toBeGreaterThan(0);
+      expect(stats.nNonlinSolvConvFails).toBeGreaterThanOrEqual(0);
+      expect(stats.nJacEvals).toBeGreaterThanOrEqual(0);
+      expect(stats.lastOrder).toBeGreaterThanOrEqual(1);
+      expect(stats.lastStep).toBeGreaterThan(0);
+      expect(stats.currentTime).toBeGreaterThan(0);
+    });
+
+    it('reInit should allow solving with new initial conditions', () => {
+      const neq = 3;
+      const solver = new Cvode(robertsonRhs, neq, 0.0, Float64Array.from([1.0, 0.0, 0.0]), {
+        lmm: 'bdf',
+        rtol: ROBERTSON_SOLVER_RTOL,
+        atol: ROBERTSON_SOLVER_ATOL,
+      });
+
+      // Solve to first output point
+      const result1 = solver.solve(0.4);
+      expect(result1.flag).toBe(CV_SUCCESS);
+      const y1 = new Float64Array(result1.y);
+
+      // Re-initialize with the same initial conditions and solve again
+      solver.reInit(0.0, Float64Array.from([1.0, 0.0, 0.0]));
+      const result2 = solver.solve(0.4);
+      expect(result2.flag).toBe(CV_SUCCESS);
+
+      // Results should match closely
+      for (let j = 0; j < neq; j++) {
+        const err = relError(result2.y[j], y1[j]);
+        expect(err).toBeLessThanOrEqual(1e-6);
+      }
+    });
+
+    it('reInit with different initial conditions should produce different results', () => {
+      const neq = 1;
+      const simpleRhs: OdeFunction = (_t, y, ydot) => {
+        ydot[0] = -y[0]; // y' = -y, solution: y(t) = y0 * exp(-t)
+      };
+
+      const solver = new Cvode(simpleRhs, neq, 0.0, Float64Array.from([1.0]), {
+        lmm: 'adams',
+        rtol: 1e-10,
+        atol: 1e-12,
+      });
+
+      // Solve with y0 = 1
+      const result1 = solver.solve(1.0);
+      expect(result1.flag).toBe(CV_SUCCESS);
+      const y1 = result1.y[0]; // should be ~ exp(-1) ~ 0.3679
+
+      // Re-initialize with y0 = 2
+      solver.reInit(0.0, Float64Array.from([2.0]));
+      const result2 = solver.solve(1.0);
+      expect(result2.flag).toBe(CV_SUCCESS);
+      const y2 = result2.y[0]; // should be ~ 2*exp(-1) ~ 0.7358
+
+      // y2 should be approximately 2 * y1
+      expect(relError(y2, 2 * y1)).toBeLessThan(1e-6);
+
+      // Check against exact solutions
+      expect(relError(y1, Math.exp(-1))).toBeLessThan(1e-6);
+      expect(relError(y2, 2 * Math.exp(-1))).toBeLessThan(1e-6);
+    });
+  });
+});

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

@@ -0,0 +1,103 @@
+import { Cvode } from '../solver-tools/cvode';
+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';
+/** Solves a benchmark problem using CVODE, checks accuracy against the reference point. */
+function solveBenchmarkAndCheck(ode, referencePoint, relTol, absTol, opts) {
+    var _a;
+    const neq = ode.initial.length;
+    const tol = ode.tolerance;
+    // Build CvodeOptions
+    const cvodeOpts = { lmm: 'bdf' };
+    // Handle tolerances
+    if ((opts === null || opts === void 0 ? void 0 : opts.rtol) && (opts === null || opts === void 0 ? void 0 : opts.atol)) {
+        cvodeOpts.rtol = opts.rtol[0];
+        cvodeOpts.atol = opts.atol;
+    }
+    else if (opts === null || opts === void 0 ? void 0 : opts.rtol)
+        cvodeOpts.rtol = opts.rtol[0];
+    else if (opts === null || opts === void 0 ? void 0 : opts.atol)
+        cvodeOpts.atol = opts.atol;
+    else {
+        cvodeOpts.rtol = tol;
+        cvodeOpts.atol = tol;
+    }
+    if (opts === null || opts === void 0 ? void 0 : opts.mxstep)
+        cvodeOpts.maxSteps = opts.mxstep;
+    if (opts === null || opts === void 0 ? void 0 : opts.hmax)
+        cvodeOpts.maxStep = opts.hmax;
+    const y0 = Float64Array.from(ode.initial);
+    const solver = new Cvode(ode.func, neq, ode.arg.start, y0, cvodeOpts);
+    // 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(opts.warmupTout);
+        expect(result.flag).toBeGreaterThanOrEqual(0);
+    }
+    const t = (_a = opts === null || opts === void 0 ? void 0 : opts.warmupTout) !== null && _a !== void 0 ? _a : ode.arg.start;
+    let tout = t + ode.arg.step;
+    const finish = ode.arg.finish;
+    let lastResult;
+    while (tout <= finish + ode.arg.step / 2) {
+        lastResult = solver.solve(tout);
+        if (lastResult.flag < 0)
+            throw new Error(`${ode.name}: solver failed at t=${lastResult.t} with flag=${lastResult.flag}`);
+        tout += ode.arg.step;
+    }
+    // Check final solution against reference point
+    const y = lastResult.y;
+    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 of magnitude).
+// Known limitation: CVODE BDF with dense direct solver hits convergence failures
+// on this extreme problem. LSODA handles it via automatic stiff/non-stiff switching.
+// TODO: revisit when band/iterative solvers or preconditioners are added.
+describe('E5', () => {
+    it.skip('should solve correctly (known limitation: CV_CONV_FAILURE)', () => {
+        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=cvode-lib-performance.test.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cvode-lib-performance.test.js","sourceRoot":"","sources":["cvode-lib-performance.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,EAAiC,MAAM,uBAAuB,CAAC;AAE5E,OAAO,EAAC,SAAS,EAAE,uBAAuB,EAAC,MAAM,uBAAuB,CAAC;AACzE,OAAO,EAAC,KAAK,EAAE,mBAAmB,EAAC,MAAM,mBAAmB,CAAC;AAC7D,OAAO,EAAC,KAAK,EAAE,mBAAmB,EAAC,MAAM,mBAAmB,CAAC;AAC7D,OAAO,EAAC,KAAK,EAAE,mBAAmB,EAAC,MAAM,mBAAmB,CAAC;AAC7D,OAAO,EAAC,EAAE,EAAE,gBAAgB,EAAC,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAC,SAAS,EAAE,uBAAuB,EAAC,MAAM,uBAAuB,CAAC;AAazE,2FAA2F;AAC3F,SAAS,sBAAsB,CAC7B,GAAS,EAAE,cAA4B,EAAE,MAAc,EAAE,MAAc,EAAE,IAAiB;;IAE1F,MAAM,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC;IAC/B,MAAM,GAAG,GAAG,GAAG,CAAC,SAAS,CAAC;IAE1B,qBAAqB;IACrB,MAAM,SAAS,GAAiB,EAAC,GAAG,EAAE,KAAK,EAAC,CAAC;IAE7C,oBAAoB;IACpB,IAAI,CAAA,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,IAAI,MAAI,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,IAAI,CAAA,EAAE,CAAC;QAC7B,SAAS,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC9B,SAAS,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;IAC7B,CAAC;SAAM,IAAI,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,IAAI;QACnB,SAAS,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;SAC3B,IAAI,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,IAAI;QACjB,SAAS,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;SACxB,CAAC;QACJ,SAAS,CAAC,IAAI,GAAG,GAAG,CAAC;QACrB,SAAS,CAAC,IAAI,GAAG,GAAG,CAAC;IACvB,CAAC;IAED,IAAI,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,MAAM;QAAE,SAAS,CAAC,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC;IACnD,IAAI,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,IAAI;QAAE,SAAS,CAAC,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC;IAE9C,MAAM,EAAE,GAAG,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAC1C,MAAM,MAAM,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,EAAE,SAAS,CAAC,CAAC;IAEtE,wEAAwE;IACxE,IAAI,CAAA,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,UAAU,MAAK,SAAS,EAAE,CAAC;QACnC,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAC7C,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC;IAChD,CAAC;IAED,MAAM,CAAC,GAAG,MAAA,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,UAAU,mCAAI,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC;IAC5C,IAAI,IAAI,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC;IAC5B,MAAM,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC;IAC9B,IAAI,UAA4B,CAAC;IAEjC,OAAO,IAAI,IAAI,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;QACzC,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAChC,IAAI,UAAU,CAAC,IAAI,GAAG,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,GAAG,GAAG,CAAC,IAAI,wBAAwB,UAAU,CAAC,CAAC,cAAc,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC;QAClG,IAAI,IAAI,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC;IACvB,CAAC;IAED,+CAA+C;IAC/C,MAAM,CAAC,GAAG,UAAW,CAAC,CAAC,CAAC;IACxB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;QAC7B,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;QAClD,MAAM,OAAO,GAAG,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;QAC9D,MAAM,CAAC,MAAM,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;IACvC,CAAC;AACH,CAAC;AAED,+EAA+E;AAE/E,+EAA+E;AAC/E,QAAQ,CAAC,WAAW,EAAE,GAAG,EAAE;IACzB,EAAE,CAAC,wBAAwB,EAAE,GAAG,EAAE;QAChC,sBAAsB,CAAC,SAAS,EAAE,uBAAuB,EAAE,IAAI,EAAE,IAAI,EAAE;YACrE,MAAM,EAAE,KAAK;YACb,IAAI,EAAE,IAAI,YAAY,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;YAC3C,IAAI,EAAE,IAAI,YAAY,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;SAC3C,CAAC,CAAC;IACL,CAAC,EAAE,KAAK,CAAC,CAAC;AACZ,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,OAAO,EAAE,GAAG,EAAE;IACrB,EAAE,CAAC,wBAAwB,EAAE,GAAG,EAAE;QAChC,sBAAsB,CAAC,KAAK,EAAE,mBAAmB,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;IAClE,CAAC,EAAE,KAAK,CAAC,CAAC;AACZ,CAAC,CAAC,CAAC;AAEH,+DAA+D;AAC/D,QAAQ,CAAC,aAAa,EAAE,GAAG,EAAE;IAC3B,EAAE,CAAC,wBAAwB,EAAE,GAAG,EAAE;QAChC,sBAAsB,CAAC,KAAK,EAAE,mBAAmB,EAAE,IAAI,EAAE,IAAI,EAAE;YAC7D,MAAM,EAAE,KAAK;SACd,CAAC,CAAC;IACL,CAAC,EAAE,KAAK,CAAC,CAAC;AACZ,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,OAAO,EAAE,GAAG,EAAE;IACrB,EAAE,CAAC,wBAAwB,EAAE,GAAG,EAAE;QAChC,sBAAsB,CAAC,KAAK,EAAE,mBAAmB,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;IACjE,CAAC,EAAE,KAAK,CAAC,CAAC;AACZ,CAAC,CAAC,CAAC;AAEH,oEAAoE;AACpE,iFAAiF;AACjF,qFAAqF;AACrF,0EAA0E;AAC1E,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE;IAClB,EAAE,CAAC,IAAI,CAAC,4DAA4D,EAAE,GAAG,EAAE;QACzE,sBAAsB,CAAC,EAAE,EAAE,gBAAgB,EAAE,CAAC,EAAE,IAAI,EAAE;YACpD,MAAM,EAAE,KAAK;YACb,UAAU,EAAE,IAAI;SACjB,CAAC,CAAC;IACL,CAAC,EAAE,KAAK,CAAC,CAAC;AACZ,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,WAAW,EAAE,GAAG,EAAE;IACzB,EAAE,CAAC,wBAAwB,EAAE,GAAG,EAAE;QAChC,sBAAsB,CAAC,SAAS,EAAE,uBAAuB,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;IAC1E,CAAC,EAAE,KAAK,CAAC,CAAC;AACZ,CAAC,CAAC,CAAC"}