physicskit 0.1.0__py3-none-any.whl

physicskit/integrators/adaptive.py

@@ -0,0 +1,199 @@
+"""Adaptive-step-size integration: embedded Dormand-Prince RK5(4).
+
+This is deliberately offered only for the non-symplectic RK4-style path
+(``rhs(state, t, params) -> ndarray``), not for the symplectic
+:func:`~physicskit.integrators.fixed_step.leapfrog_step` /
+:func:`~physicskit.integrators.fixed_step.yoshida4_step` family. Those
+integrators conserve energy over long integrations *because* they take a
+fixed step; naively varying ``dt`` from an embedded error estimate breaks
+that guarantee; a genuinely adaptive symplectic scheme needs a reversible
+step-size controller (see Hairer, Lubich & Wanner, *Geometric Numerical
+Integration*), which is a different algorithm, not a drop-in extension of
+this one. Use :func:`dopri5_integrate` for non-conservative, driven, or
+stiff-ish systems where accuracy control matters more than exact energy
+conservation; use the fixed-step symplectic integrators for long-time
+Hamiltonian evolution.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from numba import njit
+from numpy.typing import NDArray
+
+from physicskit.integrators.fixed_step import RHSFunc
+
+__all__ = ["dopri5_step", "dopri5_integrate"]
+
+# Dormand & Prince (1980) 5(4) coefficients (the classic "ode45" tableau).
+_C2, _C3, _C4, _C5 = 1.0 / 5.0, 3.0 / 10.0, 4.0 / 5.0, 8.0 / 9.0
+
+_A21 = 1.0 / 5.0
+_A31, _A32 = 3.0 / 40.0, 9.0 / 40.0
+_A41, _A42, _A43 = 44.0 / 45.0, -56.0 / 15.0, 32.0 / 9.0
+_A51, _A52, _A53, _A54 = 19372.0 / 6561.0, -25360.0 / 2187.0, 64448.0 / 6561.0, -212.0 / 729.0
+_A61, _A62, _A63, _A64, _A65 = 9017.0 / 3168.0, -355.0 / 33.0, 46732.0 / 5247.0, 49.0 / 176.0, -5103.0 / 18656.0
+
+# 5th-order solution weights (= 7th-stage row, i.e. this method is FSAL).
+_B1, _B3, _B4, _B5, _B6 = 35.0 / 384.0, 500.0 / 1113.0, 125.0 / 192.0, -2187.0 / 6784.0, 11.0 / 84.0
+# Embedded 4th-order weights, for the error estimate y5 - y4.
+_B1S, _B3S, _B4S, _B5S, _B6S, _B7S = (
+    5179.0 / 57600.0,
+    7571.0 / 16695.0,
+    393.0 / 640.0,
+    -92097.0 / 339200.0,
+    187.0 / 2100.0,
+    1.0 / 40.0,
+)
+_E1 = _B1 - _B1S
+_E3 = _B3 - _B3S
+_E4 = _B4 - _B4S
+_E5 = _B5 - _B5S
+_E6 = _B6 - _B6S
+_E7 = -_B7S
+
+
+@njit(cache=True)
+def dopri5_step(
+    rhs: RHSFunc,
+    state: NDArray[np.float64],
+    t: float,
+    dt: float,
+    params: NDArray[np.float64],
+) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+    """Single embedded Dormand-Prince RK5(4) step, with an error estimate.
+
+    Parameters
+    ----------
+    rhs : callable
+        Numba-jitted right-hand-side function ``rhs(state, t, params) ->
+        ndarray``.
+    state : ndarray of float, shape (dim,)
+        Current state vector.
+    t : float
+        Current time.
+    dt : float
+        Step size to attempt.
+    params : ndarray of float
+        Parameter vector passed through to `rhs`.
+
+    Returns
+    -------
+    state_new : ndarray of float, shape (dim,)
+        The 5th-order state estimate at ``t + dt``.
+    error : ndarray of float, shape (dim,)
+        Difference between the 5th- and embedded 4th-order estimates, for
+        step-size control (see :func:`dopri5_integrate`).
+    """
+    k1 = rhs(state, t, params)
+    k2 = rhs(state + dt * (_A21 * k1), t + _C2 * dt, params)
+    k3 = rhs(state + dt * (_A31 * k1 + _A32 * k2), t + _C3 * dt, params)
+    k4 = rhs(state + dt * (_A41 * k1 + _A42 * k2 + _A43 * k3), t + _C4 * dt, params)
+    k5 = rhs(state + dt * (_A51 * k1 + _A52 * k2 + _A53 * k3 + _A54 * k4), t + _C5 * dt, params)
+    k6 = rhs(state + dt * (_A61 * k1 + _A62 * k2 + _A63 * k3 + _A64 * k4 + _A65 * k5), t + dt, params)
+    state_new = state + dt * (_B1 * k1 + _B3 * k3 + _B4 * k4 + _B5 * k5 + _B6 * k6)
+    k7 = rhs(state_new, t + dt, params)  # FSAL: also the first stage of the next step
+    error = dt * (_E1 * k1 + _E3 * k3 + _E4 * k4 + _E5 * k5 + _E6 * k6 + _E7 * k7)
+    return state_new, error
+
+
+@njit(cache=True)
+def dopri5_integrate(
+    rhs: RHSFunc,
+    state0: NDArray[np.float64],
+    t0: float,
+    t_end: float,
+    dt0: float,
+    params: NDArray[np.float64],
+    rtol: float = 1e-6,
+    atol: float = 1e-9,
+    dt_min: float = 1e-12,
+    dt_max: float = 1e6,
+    safety: float = 0.9,
+    max_steps: int = 100_000,
+) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+    """Integrate forward from ``t0`` to ``t_end`` with adaptive step-size control.
+
+    Steps are accepted or rejected from the embedded RK5(4) error estimate
+    against an ``atol + rtol * |state|`` tolerance (the same convention as
+    :func:`scipy.integrate.solve_ivp`), with the step size adjusted after
+    every attempt. Only forward integration (``t_end > t0``, ``dt0 > 0``) is
+    supported.
+
+    Parameters
+    ----------
+    rhs : callable
+        Numba-jitted right-hand-side function ``rhs(state, t, params) ->
+        ndarray``.
+    state0 : ndarray of float, shape (dim,)
+        Initial state vector.
+    t0, t_end : float
+        Integration interval, with ``t_end > t0``.
+    dt0 : float
+        Initial step size to attempt.
+    params : ndarray of float
+        Parameter vector passed through to `rhs`.
+    rtol, atol : float
+        Relative and absolute error tolerances.
+    dt_min, dt_max : float
+        Step-size bounds; a step is accepted once ``dt`` shrinks to
+        `dt_min` regardless of its error estimate, to guarantee progress.
+    safety : float, default=0.9
+        Safety factor applied to the step-size update.
+    max_steps : int
+        Upper bound on the number of attempted steps (accepted or
+        rejected), to guarantee termination.
+
+    Returns
+    -------
+    times : ndarray of float, shape (n_accepted + 1,)
+        Times of the accepted steps, starting at `t0` and ending at
+        `t_end`.
+    states : ndarray of float, shape (n_accepted + 1, dim)
+        State at each accepted step.
+    """
+    dim = state0.shape[0]
+    cap = 1024
+    times = np.empty(cap)
+    states = np.empty((cap, dim))
+    times[0] = t0
+    states[0] = state0
+
+    t = t0
+    state = state0.copy()
+    dt = dt0
+    count = 0
+    for _ in range(max_steps):
+        if t >= t_end:
+            break
+        if t + dt > t_end:
+            dt = t_end - t
+
+        state_new, error = dopri5_step(rhs, state, t, dt, params)
+        scale = atol + rtol * np.maximum(np.abs(state), np.abs(state_new))
+        err_norm = np.sqrt(np.mean((error / scale) ** 2))
+
+        if err_norm <= 1.0 or dt <= dt_min:
+            t = t + dt
+            state = state_new
+            count += 1
+            if count >= cap:
+                new_cap = cap * 2
+                new_times = np.empty(new_cap)
+                new_states = np.empty((new_cap, dim))
+                new_times[:cap] = times
+                new_states[:cap] = states
+                times = new_times
+                states = new_states
+                cap = new_cap
+            times[count] = t
+            states[count] = state
+
+        if err_norm == 0.0:
+            factor = 5.0
+        else:
+            factor = safety * err_norm ** (-0.2)
+            factor = min(max(factor, 0.2), 5.0)
+        dt = min(max(dt * factor, dt_min), dt_max)
+
+    return times[: count + 1], states[: count + 1]

physicskit/integrators/fixed_step.py

@@ -0,0 +1,360 @@
+"""Numba-accelerated fixed-step time integrators, shared across subpackages.
+
+Right-hand-side functions passed to these integrators must be module-level
+``@njit`` functions with the signature ``rhs(state, t, params) -> ndarray``
+(for :func:`rk4_step` / :func:`rk4_integrate`) or ``force(pos, t, params) ->
+ndarray`` (for :func:`leapfrog_step` / :func:`leapfrog_integrate` /
+:func:`yoshida4_step` / :func:`yoshida4_integrate`). Keeping ``params`` as an
+explicit ``float64`` array (rather than closing over Python scalars) lets
+Numba compile these integrators once and reuse them, as first-class
+functions, across many differently-parameterized systems -- e.g. sweeping a
+grid of parameter values without recompiling per value.
+
+The two symplectic integrators (:func:`leapfrog_step`, 2nd order, and
+:func:`yoshida4_step`, 4th order) only apply to *separable* Hamiltonian
+systems of the form ``pos'' = force(pos, t)`` (the force may not depend on
+velocity); RK4 is required for non-separable systems (e.g. anything with a
+Coriolis-like velocity-dependent force).
+
+Callers that need a closure-based calling convention instead (a fixed
+``force_func(q, t)`` plus a per-instance ``mass_inv``, as used by
+:mod:`physicskit.classical.core.integrators` for momentum-parameterized
+Hamiltonian systems) are not a good fit for the ``params``-array convention
+here -- baking ``mass_inv`` into a per-step closure only pays off when the
+closure is built once per system instance, which conflicts with a runtime
+``params`` array meant to be swept without recompilation. That subpackage
+keeps its own small, independently-tested step implementations rather than
+adapting to this one.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+import numpy as np
+from numba import njit
+from numpy.typing import NDArray
+
+__all__ = [
+    "RHSFunc",
+    "rk4_step",
+    "rk4_integrate",
+    "leapfrog_step",
+    "leapfrog_integrate",
+    "velocity_verlet_step",
+    "velocity_verlet_integrate",
+    "yoshida4_step",
+    "yoshida4_integrate",
+]
+
+#: Signature shared by every right-hand-side / force function accepted by
+#: the integrators below: ``f(state, t, params) -> derivative``.
+RHSFunc = Callable[[NDArray[np.float64], float, NDArray[np.float64]], NDArray[np.float64]]
+
+
+@njit(cache=True)
+def rk4_step(
+    rhs: RHSFunc,
+    state: NDArray[np.float64],
+    t: float,
+    dt: float,
+    params: NDArray[np.float64],
+) -> NDArray[np.float64]:
+    """Single classical 4th-order Runge-Kutta step.
+
+    Parameters
+    ----------
+    rhs : callable
+        Numba-jitted right-hand-side function ``rhs(state, t, params) ->
+        ndarray``.
+    state : ndarray of float, shape (dim,)
+        Current state vector.
+    t : float
+        Current time.
+    dt : float
+        Step size.
+    params : ndarray of float
+        Parameter vector passed through to `rhs`.
+
+    Returns
+    -------
+    ndarray of float, shape (dim,)
+        The state advanced by one step of size `dt`.
+    """
+    k1 = rhs(state, t, params)
+    k2 = rhs(state + 0.5 * dt * k1, t + 0.5 * dt, params)
+    k3 = rhs(state + 0.5 * dt * k2, t + 0.5 * dt, params)
+    k4 = rhs(state + dt * k3, t + dt, params)
+    return state + (dt / 6.0) * (k1 + 2.0 * k2 + 2.0 * k3 + k4)
+
+
+@njit(cache=True)
+def rk4_integrate(
+    rhs: RHSFunc,
+    state0: NDArray[np.float64],
+    t0: float,
+    dt: float,
+    n_steps: int,
+    params: NDArray[np.float64],
+) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+    """Integrate ``n_steps`` of RK4 starting from ``state0``.
+
+    Parameters
+    ----------
+    rhs : callable
+        Numba-jitted right-hand-side function ``rhs(state, t, params) ->
+        ndarray``.
+    state0 : ndarray of float, shape (dim,)
+        Initial state vector.
+    t0 : float
+        Initial time.
+    dt : float
+        Step size.
+    n_steps : int
+        Number of integration steps.
+    params : ndarray of float
+        Parameter vector passed through to `rhs`.
+
+    Returns
+    -------
+    times : ndarray of float, shape (n_steps + 1,)
+        Time at each step, starting at `t0`.
+    states : ndarray of float, shape (n_steps + 1, dim)
+        State at each step, starting at `state0`.
+    """
+    dim = state0.shape[0]
+    states = np.empty((n_steps + 1, dim))
+    times = np.empty(n_steps + 1)
+    states[0] = state0
+    times[0] = t0
+    state = state0.copy()
+    t = t0
+    for i in range(n_steps):
+        state = rk4_step(rhs, state, t, dt, params)
+        t = t0 + (i + 1) * dt
+        states[i + 1] = state
+        times[i + 1] = t
+    return times, states
+
+
+@njit(cache=True)
+def leapfrog_step(
+    force: RHSFunc,
+    pos: NDArray[np.float64],
+    vel: NDArray[np.float64],
+    t: float,
+    dt: float,
+    params: NDArray[np.float64],
+) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+    """Single velocity-Verlet (symplectic) step for ``pos'' = force(pos, t)``.
+
+    Parameters
+    ----------
+    force : callable
+        Numba-jitted acceleration function ``force(pos, t, params) ->
+        ndarray``.
+    pos : ndarray of float, shape (dim,)
+        Current position vector.
+    vel : ndarray of float, shape (dim,)
+        Current velocity vector.
+    t : float
+        Current time.
+    dt : float
+        Step size.
+    params : ndarray of float
+        Parameter vector passed through to `force`.
+
+    Returns
+    -------
+    pos_new : ndarray of float, shape (dim,)
+        Position advanced by one step of size `dt`.
+    vel_new : ndarray of float, shape (dim,)
+        Velocity advanced by one step of size `dt`.
+    """
+    a0 = force(pos, t, params)
+    pos_new = pos + vel * dt + 0.5 * a0 * dt * dt
+    a1 = force(pos_new, t + dt, params)
+    vel_new = vel + 0.5 * (a0 + a1) * dt
+    return pos_new, vel_new
+
+
+@njit(cache=True)
+def leapfrog_integrate(
+    force: RHSFunc,
+    pos0: NDArray[np.float64],
+    vel0: NDArray[np.float64],
+    t0: float,
+    dt: float,
+    n_steps: int,
+    params: NDArray[np.float64],
+) -> tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]:
+    """Integrate ``n_steps`` of the symplectic leapfrog scheme.
+
+    Parameters
+    ----------
+    force : callable
+        Numba-jitted acceleration function ``force(pos, t, params) ->
+        ndarray``.
+    pos0 : ndarray of float, shape (dim,)
+        Initial position vector.
+    vel0 : ndarray of float, shape (dim,)
+        Initial velocity vector.
+    t0 : float
+        Initial time.
+    dt : float
+        Step size.
+    n_steps : int
+        Number of integration steps.
+    params : ndarray of float
+        Parameter vector passed through to `force`.
+
+    Returns
+    -------
+    times : ndarray of float, shape (n_steps + 1,)
+        Time at each step, starting at `t0`.
+    positions : ndarray of float, shape (n_steps + 1, dim)
+        Position at each step, starting at `pos0`.
+    velocities : ndarray of float, shape (n_steps + 1, dim)
+        Velocity at each step, starting at `vel0`.
+    """
+    dim = pos0.shape[0]
+    positions = np.empty((n_steps + 1, dim))
+    velocities = np.empty((n_steps + 1, dim))
+    times = np.empty(n_steps + 1)
+    positions[0] = pos0
+    velocities[0] = vel0
+    times[0] = t0
+    pos = pos0.copy()
+    vel = vel0.copy()
+    t = t0
+    for i in range(n_steps):
+        pos, vel = leapfrog_step(force, pos, vel, t, dt, params)
+        t = t0 + (i + 1) * dt
+        positions[i + 1] = pos
+        velocities[i + 1] = vel
+        times[i + 1] = t
+    return times, positions, velocities
+
+
+#: ``leapfrog_step``/``leapfrog_integrate`` under the name used by
+#: gravitational-dynamics and molecular-dynamics literature, where this same
+#: kick-drift-kick scheme is usually called "velocity Verlet".
+velocity_verlet_step = leapfrog_step
+velocity_verlet_integrate = leapfrog_integrate
+
+
+#: Yoshida (1990) 4th-order composition coefficients: the 4th-order step is
+#: three 2nd-order (leapfrog) sub-steps of sizes ``w1*dt``, ``w0*dt``,
+#: ``w1*dt`` (which sum to ``dt``, since ``2*w1 + w0 == 1``).
+_YOSHIDA_CBRT2 = 2.0 ** (1.0 / 3.0)
+_YOSHIDA_W0 = -_YOSHIDA_CBRT2 / (2.0 - _YOSHIDA_CBRT2)
+_YOSHIDA_W1 = 1.0 / (2.0 - _YOSHIDA_CBRT2)
+
+
+@njit(cache=True)
+def yoshida4_step(
+    force: RHSFunc,
+    pos: NDArray[np.float64],
+    vel: NDArray[np.float64],
+    t: float,
+    dt: float,
+    params: NDArray[np.float64],
+) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+    """Single 4th-order symplectic (Yoshida) step for ``pos'' = force(pos, t)``.
+
+    Composes three :func:`leapfrog_step` sub-steps with Yoshida's (1990)
+    coefficients to raise the (still symplectic) accuracy from 2nd to 4th
+    order, at roughly 3x the cost per step of plain leapfrog. Because it
+    remains symplectic, it -- like leapfrog -- conserves energy far better
+    than RK4 over long integrations, now with much smaller local truncation
+    error too.
+
+    Parameters
+    ----------
+    force : callable
+        Numba-jitted acceleration function ``force(pos, t, params) ->
+        ndarray``.
+    pos : ndarray of float, shape (dim,)
+        Current position vector.
+    vel : ndarray of float, shape (dim,)
+        Current velocity vector.
+    t : float
+        Current time.
+    dt : float
+        Step size.
+    params : ndarray of float
+        Parameter vector passed through to `force`.
+
+    Returns
+    -------
+    pos_new : ndarray of float, shape (dim,)
+        Position advanced by one step of size `dt`.
+    vel_new : ndarray of float, shape (dim,)
+        Velocity advanced by one step of size `dt`.
+    """
+    h1 = _YOSHIDA_W1 * dt
+    h0 = _YOSHIDA_W0 * dt
+    pos, vel = leapfrog_step(force, pos, vel, t, h1, params)
+    t = t + h1
+    pos, vel = leapfrog_step(force, pos, vel, t, h0, params)
+    t = t + h0
+    pos, vel = leapfrog_step(force, pos, vel, t, h1, params)
+    return pos, vel
+
+
+@njit(cache=True)
+def yoshida4_integrate(
+    force: RHSFunc,
+    pos0: NDArray[np.float64],
+    vel0: NDArray[np.float64],
+    t0: float,
+    dt: float,
+    n_steps: int,
+    params: NDArray[np.float64],
+) -> tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]:
+    """Integrate ``n_steps`` of the 4th-order symplectic Yoshida scheme.
+
+    Parameters
+    ----------
+    force : callable
+        Numba-jitted acceleration function ``force(pos, t, params) ->
+        ndarray``.
+    pos0 : ndarray of float, shape (dim,)
+        Initial position vector.
+    vel0 : ndarray of float, shape (dim,)
+        Initial velocity vector.
+    t0 : float
+        Initial time.
+    dt : float
+        Step size.
+    n_steps : int
+        Number of integration steps.
+    params : ndarray of float
+        Parameter vector passed through to `force`.
+
+    Returns
+    -------
+    times : ndarray of float, shape (n_steps + 1,)
+        Time at each step, starting at `t0`.
+    positions : ndarray of float, shape (n_steps + 1, dim)
+        Position at each step, starting at `pos0`.
+    velocities : ndarray of float, shape (n_steps + 1, dim)
+        Velocity at each step, starting at `vel0`.
+    """
+    dim = pos0.shape[0]
+    positions = np.empty((n_steps + 1, dim))
+    velocities = np.empty((n_steps + 1, dim))
+    times = np.empty(n_steps + 1)
+    positions[0] = pos0
+    velocities[0] = vel0
+    times[0] = t0
+    pos = pos0.copy()
+    vel = vel0.copy()
+    t = t0
+    for i in range(n_steps):
+        pos, vel = yoshida4_step(force, pos, vel, t, dt, params)
+        t = t0 + (i + 1) * dt
+        positions[i + 1] = pos
+        velocities[i + 1] = vel
+        times[i + 1] = t
+    return times, positions, velocities

physicskit/integrators/tests/test_integrators.py

@@ -0,0 +1,101 @@
+"""Tests for physicskit.integrators itself.
+
+physicskit.chaos.tests.test_integrators already exercises rk4/leapfrog/
+yoshida4 correctness (via physicskit.chaos.core.integrators, which now
+re-exports these same functions) -- it is not repeated here. This file
+covers only what's specific to this package: that it's usable on its own
+(without going through chaos), the velocity_verlet aliasing, and the new
+adaptive Dormand-Prince integrator.
+"""
+
+import numpy as np
+import pytest
+from numba import njit
+
+from physicskit.integrators import (
+    dopri5_integrate,
+    leapfrog_step,
+    rk4_integrate,
+    velocity_verlet_step,
+)
+
+
+@njit
+def _harmonic_force(pos, t, params):
+    omega = params[0]
+    return -(omega**2) * pos
+
+
+@njit
+def _harmonic_rhs(state, t, params):
+    omega = params[0]
+    out = np.empty(2)
+    out[0] = state[1]
+    out[1] = -(omega**2) * state[0]
+    return out
+
+
+def _harmonic_energy(pos, vel, omega):
+    return 0.5 * vel**2 + 0.5 * omega**2 * pos**2
+
+
+def test_velocity_verlet_is_an_alias_for_leapfrog():
+    """The two names refer to the same kick-drift-kick scheme -- 'leapfrog'
+    in the celestial-mechanics literature, 'velocity Verlet' in molecular
+    dynamics -- so they must be the identical function object, not merely
+    numerically equivalent copies."""
+    assert velocity_verlet_step is leapfrog_step
+
+
+@pytest.mark.slow
+def test_dopri5_matches_analytic_harmonic_oscillator():
+    omega = 2.0
+    params = np.array([omega])
+    state0 = np.array([1.0, 0.0])
+    t_end = 10.0
+
+    ts, ys = dopri5_integrate(_harmonic_rhs, state0, 0.0, t_end, 0.01, params, rtol=1e-10, atol=1e-12)
+
+    assert ts[0] == 0.0
+    assert ts[-1] == t_end
+    expected = np.cos(omega * ts)
+    np.testing.assert_allclose(ys[:, 0], expected, atol=1e-6)
+
+
+def test_dopri5_energy_drift_shrinks_with_tolerance():
+    omega = 2.0
+    params = np.array([omega])
+    state0 = np.array([1.0, 0.0])
+    t_end = 20.0
+
+    drifts = []
+    for rtol in (1e-4, 1e-9):
+        _, ys = dopri5_integrate(_harmonic_rhs, state0, 0.0, t_end, 0.01, params, rtol=rtol, atol=rtol * 1e-3)
+        energy = _harmonic_energy(ys[:, 0], ys[:, 1], omega)
+        drifts.append(np.max(np.abs(energy - energy[0]) / energy[0]))
+
+    assert drifts[1] < drifts[0]
+
+
+def test_dopri5_takes_fewer_steps_for_looser_tolerance():
+    omega = 2.0
+    params = np.array([omega])
+    state0 = np.array([1.0, 0.0])
+    t_end = 20.0
+
+    ts_tight, _ = dopri5_integrate(_harmonic_rhs, state0, 0.0, t_end, 0.01, params, rtol=1e-10, atol=1e-12)
+    ts_loose, _ = dopri5_integrate(_harmonic_rhs, state0, 0.0, t_end, 0.01, params, rtol=1e-3, atol=1e-6)
+
+    assert len(ts_loose) < len(ts_tight)
+
+
+def test_dopri5_agrees_with_fixed_step_rk4_at_tight_tolerance():
+    omega = 2.0
+    params = np.array([omega])
+    state0 = np.array([1.0, 0.0])
+    t_end = 5.0
+
+    ts, ys = dopri5_integrate(_harmonic_rhs, state0, 0.0, t_end, 0.01, params, rtol=1e-10, atol=1e-12)
+    _, ys_rk4 = rk4_integrate(_harmonic_rhs, state0, 0.0, 1e-4, 50000, params)
+
+    np.testing.assert_allclose(ys[-1], ys_rk4[-1], atol=1e-6)