physicskit 0.1.0__py3-none-any.whl

physicskit/classical/tests/test_lagrangian.py

@@ -0,0 +1,69 @@
+"""Tests for physicskit.classical.systems.lagrangian's concrete systems and,
+via them, the LagrangianSystem base class's own defaults that
+test_conservation.py's energy-conservation checks never reach: direct
+calls to ``acceleration()``/``derivatives()`` (every conservation test
+goes through ``integrate()``, which calls the underlying njit
+callbacks directly rather than through those convenience methods),
+``ElasticPendulum.positions()``, and the ``rk4``/unknown-method
+branches of ``LagrangianSystem.integrate()`` (every existing test uses
+the default ``implicit_midpoint``).
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from physicskit.classical.systems.lagrangian import BeadOnRotatingHoop, ElasticPendulum
+
+
+def test_bead_on_rotating_hoop_acceleration_matches_euler_lagrange_by_hand():
+    """theta'' = Omega^2 sin(theta) cos(theta) - (g/R) sin(theta), derived
+    by hand from the Lagrangian in the class docstring."""
+    system = BeadOnRotatingHoop(0.3, 0.1, R=1.5, omega=2.0, g=9.81)
+    theta, thetadot = system.q, system.qdot
+    accel = system.acceleration(theta, thetadot, 0.0)
+    expected = system.omega**2 * np.sin(theta) * np.cos(theta) - (system.g / system.R) * np.sin(theta)
+    np.testing.assert_allclose(accel, expected, rtol=1e-6)
+
+
+def test_bead_on_rotating_hoop_derivatives_matches_qdot_and_acceleration():
+    system = BeadOnRotatingHoop(0.3, 0.1, R=1.5, omega=2.0, g=9.81)
+    d = system.derivatives(0.0, system.state)
+    np.testing.assert_allclose(d[:1], system.qdot)
+    np.testing.assert_allclose(d[1:], system.acceleration(system.q, system.qdot, 0.0))
+
+
+def test_lagrangian_system_integrate_rk4_matches_implicit_midpoint_over_short_time():
+    """rk4 is not symplectic, but over a short-enough window both
+    integrators should agree closely -- the standard cross-check that
+    the rk4 branch (which uses the direct (q, qdot) acceleration form,
+    not the canonical Hamiltonian form implicit_midpoint uses) is wired
+    correctly."""
+    dt = 1e-4
+    result_rk4 = BeadOnRotatingHoop(0.3, 0.0, omega=3.0).integrate((0.0, 0.05), dt=dt, method="rk4")
+    result_im = BeadOnRotatingHoop(0.3, 0.0, omega=3.0).integrate((0.0, 0.05), dt=dt, method="implicit_midpoint")
+    assert np.max(np.abs(result_rk4.q - result_im.q)) < 1e-5
+
+
+def test_lagrangian_system_integrate_rejects_unknown_method():
+    system = BeadOnRotatingHoop(0.3, 0.0, omega=3.0)
+    with pytest.raises(ValueError):
+        system.integrate((0.0, 1.0), dt=0.1, method="bogus")
+
+
+def test_elastic_pendulum_positions_matches_polar_to_cartesian_by_hand():
+    system = ElasticPendulum([0.2, 0.3], [0.0, 0.0], L0=1.0)
+    x, y = system.positions()
+    s, theta = system.q
+    r = system.L0 + s
+    assert x == pytest.approx(r * np.sin(theta))
+    assert y == pytest.approx(-r * np.cos(theta))
+
+
+def test_elastic_pendulum_positions_defaults_to_current_state_but_accepts_override():
+    system = ElasticPendulum([0.2, 0.3], [0.0, 0.0], L0=1.0)
+    default = system.positions()
+    overridden = system.positions(np.array([0.0, 0.0]))
+    np.testing.assert_allclose(overridden, [0.0, -1.0])
+    assert not np.allclose(default, overridden)

physicskit/classical/tests/test_newtonian.py

@@ -0,0 +1,45 @@
+"""Tests for physicskit.classical.systems.newtonian helpers that
+test_conservation.py's energy-conservation checks never call directly:
+ProjectileMotion.range_and_max_height() (a standalone closed-form
+helper, not used by any trajectory check), and FoucaultPendulum's
+position/velocity convenience properties and precession_period()."""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from physicskit.classical.systems.newtonian import FoucaultPendulum, ProjectileMotion
+
+
+def test_range_and_max_height_matches_analytic_trajectory_peak_and_landing():
+    """Cross-check the closed-form range/max-height formula against the
+    same speed/angle's full analytic_trajectory(), by finding where that
+    trajectory peaks and lands."""
+    speed, angle_deg, g = 20.0, 30.0, 9.81
+    rng, max_height = ProjectileMotion.range_and_max_height(speed, angle_deg, g)
+
+    t = np.linspace(0.0, 5.0, 200_000)
+    x, y = ProjectileMotion.analytic_trajectory(speed, angle_deg, g, t)
+    assert max_height == pytest.approx(y.max(), abs=1e-3)
+    landing_idx = np.argmax(y[1:] < 0.0) + 1
+    assert rng == pytest.approx(x[landing_idx], rel=1e-3)
+
+
+def test_range_and_max_height_with_initial_height_raises_both():
+    rng_ground, height_ground = ProjectileMotion.range_and_max_height(15.0, 45.0, 9.81, height=0.0)
+    rng_elevated, height_elevated = ProjectileMotion.range_and_max_height(15.0, 45.0, 9.81, height=10.0)
+    assert rng_elevated > rng_ground
+    assert height_elevated == pytest.approx(height_ground + 10.0)
+
+
+def test_foucault_pendulum_position_and_velocity_properties_match_state():
+    system = FoucaultPendulum(q0=[1.0, 2.0], v0=[0.3, -0.4])
+    np.testing.assert_allclose(system.position, [1.0, 2.0])
+    np.testing.assert_allclose(system.velocity, [0.3, -0.4])
+
+
+def test_foucault_pendulum_precession_period_matches_sidereal_day_over_sin_latitude():
+    system = FoucaultPendulum(q0=[1.0, 0.0], v0=[0.0, 0.0], latitude_deg=48.85)
+    expected = (2.0 * np.pi / system.omega_earth) / np.sin(np.deg2rad(48.85))
+    assert system.precession_period() == pytest.approx(expected)

physicskit/classical/tests/test_rotations.py

@@ -0,0 +1,160 @@
+"""Targeted checks for physicskit.classical.systems.rotations beyond energy conservation
+(covered in test_conservation.py): the closed-form/harmonic-approximation
+precession and nutation frequencies for HeavySymmetricTop, validated
+against an FFT of an actual integrated trajectory.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from physicskit.classical.systems.rotations import (
+    EulersDisk,
+    EulerTop,
+    HeavySymmetricTop,
+    Rattleback,
+    eulers_disk_theta_analytic,
+    find_theta_equilibrium,
+    nutation_frequency,
+    precession_frequency,
+)
+
+
+def _measured_nutation_frequency(t: np.ndarray, theta_t: np.ndarray) -> float:
+    dt = t[1] - t[0]
+    spectrum = np.abs(np.fft.rfft(theta_t - theta_t.mean()))
+    freqs = np.fft.rfftfreq(len(theta_t), d=dt) * 2.0 * np.pi
+    peak_idx = np.argmax(spectrum[1:]) + 1
+    return float(freqs[peak_idx])
+
+
+def test_theta_equilibrium_is_a_true_minimum_of_effective_potential():
+    I1, I3, Mgl = 1.0, 0.5, 9.81
+    p_phi, p_psi = 8.78, 10.0
+    theta_eq = find_theta_equilibrium(p_phi, p_psi, I1, I3, Mgl)
+    assert 0.0 < theta_eq < np.pi
+
+    from physicskit.classical.systems.rotations import effective_potential_symmetric_top
+
+    v_at_eq = effective_potential_symmetric_top(theta_eq, p_phi, p_psi, I1, I3, Mgl)
+    for delta in (-0.05, 0.05):
+        assert effective_potential_symmetric_top(theta_eq + delta, p_phi, p_psi, I1, I3, Mgl) > v_at_eq
+
+
+def test_nutation_frequency_without_explicit_theta_eq_matches_passing_it_explicitly():
+    """theta_eq is optional and, if omitted, is located internally via
+    find_theta_equilibrium -- check that path gives the same answer as
+    passing the same equilibrium explicitly."""
+    I1, I3, Mgl = 1.0, 0.5, 9.81
+    p_phi, p_psi = 8.78, 10.0
+    theta_eq = find_theta_equilibrium(p_phi, p_psi, I1, I3, Mgl)
+    explicit = nutation_frequency(p_phi, p_psi, I1, I3, Mgl, theta_eq=theta_eq)
+    implicit = nutation_frequency(p_phi, p_psi, I1, I3, Mgl)
+    assert implicit == pytest.approx(explicit)
+
+
+def test_heavy_symmetric_top_precession_nutation_rate_matches_qdot():
+    top = HeavySymmetricTop([0.0, 0.5, 0.0], [0.2, -0.1, 0.3], I1=1.0, I3=0.5, M=1.0, l=1.0, g=9.81)
+    phidot, thetadot = top.precession_nutation_rate()
+    assert phidot == pytest.approx(top.qdot[0])
+    assert thetadot == pytest.approx(top.qdot[1])
+
+
+def test_euler_top_omega_and_quaternion_properties_match_state():
+    omega0 = [0.01, 1.0, 0.01]
+    quat0 = [1.0, 0.0, 0.0, 0.0]
+    top = EulerTop(omega0, I1=1.0, I2=2.0, I3=3.0, quat0=quat0)
+    np.testing.assert_allclose(top.omega, omega0)
+    np.testing.assert_allclose(top.quaternion, quat0)
+
+
+def test_eulers_disk_theta_and_phi_properties_match_state():
+    disk = EulersDisk(0.5, phi0=1.2, decay_rate=0.02, precession_const=1.0)
+    assert disk.theta == pytest.approx(0.5)
+    assert disk.phi == pytest.approx(1.2)
+
+
+@pytest.mark.slow
+def test_nutation_frequency_matches_fft_of_real_trajectory():
+    I1, I3, M, l, g = 1.0, 0.5, 1.0, 1.0, 9.81
+    top = HeavySymmetricTop([0.0, 0.5, 0.0], [0.0, 0.0, 20.0], I1=I1, I3=I3, M=M, l=l, g=g)
+    q0, qdot0 = top.q.copy(), top.qdot.copy()
+    p_phi, _, p_psi = top.momentum(q0, qdot0)
+
+    theta_eq = find_theta_equilibrium(p_phi, p_psi, I1, I3, M * g * l)
+    predicted = nutation_frequency(p_phi, p_psi, I1, I3, M * g * l, theta_eq=theta_eq)
+
+    result = top.integrate((0, 10.0), dt=2e-5, method="implicit_midpoint")
+    measured = _measured_nutation_frequency(result.t, result.q[:, 1])
+
+    assert abs(measured - predicted) / predicted < 0.02
+
+
+@pytest.mark.slow
+def test_precession_frequency_matches_mean_phi_rate():
+    I1, I3, M, l, g = 1.0, 0.5, 1.0, 1.0, 9.81
+    top = HeavySymmetricTop([0.0, 0.5, 0.0], [0.0, 0.0, 20.0], I1=I1, I3=I3, M=M, l=l, g=g)
+    q0, qdot0 = top.q.copy(), top.qdot.copy()
+    p_phi, _, p_psi = top.momentum(q0, qdot0)
+
+    theta_eq = find_theta_equilibrium(p_phi, p_psi, I1, I3, M * g * l)
+    predicted = precession_frequency(p_phi, p_psi, I1, theta_eq)
+
+    result = top.integrate((0, 10.0), dt=2e-5, method="implicit_midpoint")
+    measured = (result.q[-1, 0] - result.q[0, 0]) / (result.t[-1] - result.t[0])
+
+    assert abs(measured - predicted) / abs(predicted) < 0.02
+
+
+def test_eulers_disk_theta_matches_closed_form_solution():
+    """Well below the collapse time (where the regularizing theta_floor
+    never engages), the numerically integrated theta(t) should match the
+    closed-form solution `eulers_disk_theta_analytic`."""
+    theta0, decay_rate = 0.5, 0.02
+    t_collapse = theta0**2 / (2.0 * decay_rate)
+
+    disk = EulersDisk(theta0, decay_rate=decay_rate, precession_const=1.0, theta_floor=1e-4)
+    t_end = 0.5 * t_collapse
+    dt = 1e-3
+    result = disk.integrate((0.0, t_end), dt=dt, method="rk4")
+
+    predicted = eulers_disk_theta_analytic(result.t, theta0, decay_rate)
+    np.testing.assert_allclose(result.y[:, 0], predicted, atol=1e-3)
+
+
+def test_eulers_disk_precession_speeds_up_as_it_runs_down():
+    """The whole point of the model: phi advances faster and faster per
+    unit time as theta shrinks, since dphi/dt = precession_const/theta."""
+    disk = EulersDisk(0.5, decay_rate=0.02, precession_const=1.0, theta_floor=1e-4)
+    result = disk.integrate((0.0, 5.0), dt=1e-3, method="rk4")
+    phi_rate = np.diff(result.y[:, 1]) / np.diff(result.t)
+    # Later phi-rate (disk flatter, closer to collapse) must exceed the
+    # earlier phi-rate (disk still steep).
+    assert phi_rate[-1] > phi_rate[len(phi_rate) // 10]
+
+
+def test_rattleback_reverses_spin_direction():
+    """Starting spun up hard about n3 with only a tiny rocking
+    perturbation, the toy model should show n3 collapse through zero and
+    become substantially negative (a genuine reversal), not merely decay
+    toward zero and stay positive."""
+    system = Rattleback([0.01, 0.01, 3.0])
+    result = system.integrate((0.0, 20.0), dt=5e-3, method="rk4")
+    n3 = result.y[:, 2]
+    assert n3[0] > 2.0
+    assert np.min(n3) < -0.5  # a substantial excursion to negative spin
+
+
+def test_rattleback_energy_decays_overall():
+    """Despite the transient internal instability that drives the
+    reversal, the model is net dissipative (linear friction `mu` on all
+    three components): the quadratic 'energy' diagnostic averaged over the
+    first vs. last portion of a long run should show substantial decay."""
+    system = Rattleback([0.01, 0.01, 3.0])
+    result = system.integrate((0.0, 300.0), dt=5e-3, method="rk4")
+    energies = np.array([system.energy(y) for y in result.y])
+    n = len(energies)
+    early = np.mean(energies[: n // 20])
+    late = np.mean(energies[-n // 20 :])
+    assert late < 0.1 * early

physicskit/classical/tests/test_stepsize.py

@@ -0,0 +1,149 @@
+"""Tests for physicskit.classical.utils.stepsize.estimate_dt.
+
+The critical property this checks is not just "it finds a dt," but
+that the returned dt genuinely meets the tolerance at the *requested*
+step count, including for a chaotic system where a naive short probe
+can find a dt that looks fine briefly and then fails badly later.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from physicskit.classical.systems.lagrangian import DoublePendulum
+from physicskit.classical.systems.newtonian import KeplerSystem
+from physicskit.classical.utils.conservation import relative_energy_drift
+from physicskit.classical.utils.stepsize import estimate_dt
+
+
+class _FakeSystemNeverConvergesAtProbe:
+    """Deterministically fails the fast probe stage at every dt, however
+    small -- used to exercise estimate_dt's shrink-loop-exhausted error
+    path without relying on a real system happening to never converge."""
+
+    def energy(self):
+        return 1.0
+
+    def integrate(self, t_span, dt, method):
+        del t_span, dt, method
+        result = type("Result", (), {})()
+        result.energy = np.array([1.0, 11.0])
+        return result
+
+
+class _FakeSystemNeverConvergesAtTarget:
+    """Passes the fast probe at any dt, but fails verification at the
+    full target_steps at every dt -- used to exercise estimate_dt's
+    verification-stage error path (the case the module docstring
+    describes: a dt that looks fine briefly but fails over a longer
+    run) without depending on a real chaotic system's exact behavior."""
+
+    def __init__(self, probe_steps):
+        self.probe_steps = probe_steps
+
+    def energy(self):
+        return 1.0
+
+    def integrate(self, t_span, dt, method):
+        del method
+        n_steps = round((t_span[1] - t_span[0]) / dt)
+        result = type("Result", (), {})()
+        result.energy = np.array([1.0, 1.0]) if n_steps <= self.probe_steps else np.array([1.0, 11.0])
+        return result
+
+
+def test_estimate_dt_quasi_periodic_kepler():
+    tol = 1e-6
+    est = estimate_dt(
+        lambda: KeplerSystem.from_orbital_elements(a=1.0, e=0.5),
+        method="yoshida4",
+        tol=tol,
+        target_steps=20_000,
+        probe_steps=1000,
+        dt_initial=1e-2,
+    )
+    assert est.achieved_drift < tol
+
+    system = KeplerSystem.from_orbital_elements(a=1.0, e=0.5)
+    result = system.integrate((0.0, 20_000 * est.dt), dt=est.dt, method="yoshida4")
+    assert np.max(relative_energy_drift(result.energy)) < tol
+
+
+def test_estimate_dt_bracket_search_grows_dt_across_several_doublings():
+    """A deliberately tiny dt_initial forces the fast-probe bracket
+    search to succeed across several successive doublings before it
+    finally fails, rather than failing on the very first growth step."""
+    est = estimate_dt(
+        lambda: KeplerSystem.from_orbital_elements(a=1.0, e=0.5),
+        method="yoshida4",
+        tol=1e-6,
+        target_steps=2000,
+        probe_steps=1000,
+        dt_initial=1e-4,
+    )
+    assert est.achieved_drift < 1e-6
+    assert est.n_evaluations > 5  # several bracket/verification evaluations, not just one
+
+
+def test_estimate_dt_bracket_search_shrinks_dt_across_several_halvings():
+    """A deliberately oversized dt_initial forces the fast-probe bracket
+    search to fail across several successive halvings before it
+    finally succeeds, rather than succeeding on the very first shrink."""
+    est = estimate_dt(
+        lambda: KeplerSystem.from_orbital_elements(a=1.0, e=0.5),
+        method="yoshida4",
+        tol=1e-6,
+        target_steps=2000,
+        probe_steps=1000,
+        dt_initial=0.1024,
+    )
+    assert est.achieved_drift < 1e-6
+
+
+def test_estimate_dt_raises_when_probe_never_converges_within_max_iter():
+    with pytest.raises(RuntimeError, match="shrink steps"):
+        estimate_dt(
+            lambda: _FakeSystemNeverConvergesAtProbe(),
+            method="unused",
+            tol=1e-6,
+            target_steps=100,
+            probe_steps=10,
+            dt_initial=1.0,
+            max_iter=3,
+        )
+
+
+def test_estimate_dt_raises_when_target_verification_never_converges():
+    with pytest.raises(RuntimeError, match="verification shrink steps"):
+        estimate_dt(
+            lambda: _FakeSystemNeverConvergesAtTarget(probe_steps=10),
+            method="unused",
+            tol=1e-6,
+            target_steps=100,
+            probe_steps=10,
+            dt_initial=1.0,
+            max_iter=3,
+        )
+
+
+def test_estimate_dt_verification_catches_chaotic_underestimate():
+    """A short probe alone can find a dt for the (chaotic) double
+    pendulum that passes over a few hundred steps but fails once run
+    for the full target_steps; estimate_dt must not return such a dt --
+    its own verification stage has to catch and shrink it."""
+    tol = 1e-6
+    target_steps = 20_000
+    est = estimate_dt(
+        lambda: DoublePendulum([2.0, 1.0], [0.5, -0.3]),
+        method="implicit_midpoint",
+        tol=tol,
+        target_steps=target_steps,
+        probe_steps=500,
+        dt_initial=1e-3,
+    )
+    assert est.achieved_drift < tol
+
+    system = DoublePendulum([2.0, 1.0], [0.5, -0.3])
+    result = system.integrate((0.0, target_steps * est.dt), dt=est.dt, method="implicit_midpoint")
+    assert np.max(relative_energy_drift(result.energy)) < tol

physicskit/classical/tests/test_symbolic.py

@@ -0,0 +1,125 @@
+"""Direct unit tests for physicskit.classical.utils.symbolic.LagrangianEngine, in
+isolation from any physicskit.classical.systems class.
+
+These exist specifically because of a real bug found during
+development: a spurious sign flip in the Legendre-transform code
+produced a self-consistent but unphysical (negative-definite kinetic
+term) Hamiltonian for CoupledOscillators. It was NOT caught by that
+system's own energy-conservation test, because implicit_midpoint
+faithfully conserves whatever Hamiltonian it is handed, even a wrong
+one -- energy conservation alone cannot distinguish a correctly-derived
+Hamiltonian from a self-consistent but wrong one. The tests below check
+LagrangianEngine's output against independently-known-correct physics
+(closed-form accelerations, finite-difference Hamiltonian gradients),
+which does catch that class of bug.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import sympy as sp
+
+from physicskit.classical.utils.symbolic import LagrangianEngine
+
+
+def test_simple_harmonic_oscillator_acceleration_and_hamiltonian_signs():
+    """L = (m/2) qdot^2 - (k/2) q^2 must give qddot = -(k/m) q, p = m*qdot,
+    and H = p^2/(2m) + (k/2) q^2 with a POSITIVE kinetic term -- exactly
+    the sign the historical bug got backwards."""
+    m, k = 2.0, 3.0
+    q, qdot = sp.symbols("q qdot")
+    L = sp.Rational(1, 2) * m * qdot**2 - sp.Rational(1, 2) * k * q**2
+
+    engine = LagrangianEngine([q], [qdot], L)
+
+    q0, qdot0 = np.array([1.5]), np.array([0.7])
+    accel = engine.acceleration_njit(q0, qdot0, 0.0)
+    assert np.allclose(accel, [-(k / m) * q0[0]])
+
+    p0 = engine.momentum_njit(q0, qdot0)
+    assert np.allclose(p0, [m * qdot0[0]])
+
+    H = engine.hamiltonian_njit(q0, p0, 0.0)
+    expected_H = p0[0] ** 2 / (2 * m) + 0.5 * k * q0[0] ** 2
+    assert np.isclose(H, expected_H)
+
+    # The regression this guards against: a flipped Legendre transform
+    # sign gives H = -3*T + V instead of T + V, which for qdot != 0
+    # differs from the correct value by far more than float noise.
+    wrong_H = -3 * (0.5 * m * qdot0[0] ** 2) + 0.5 * k * q0[0] ** 2
+    assert not np.isclose(H, wrong_H)
+
+
+def test_canonical_gradient_matches_finite_difference_of_hamiltonian():
+    """For a non-trivial single pendulum, dH/dq and dH/dp from
+    canonical_deriv_njit must match a central finite difference of
+    hamiltonian_njit itself -- a general, formula-agnostic consistency
+    check that would have caught the historical sign bug regardless of
+    which specific system triggered it."""
+    m, l, g = 1.3, 0.8, 9.81
+    q, qdot = sp.symbols("q qdot")
+    L = sp.Rational(1, 2) * m * l**2 * qdot**2 - m * g * l * (1 - sp.cos(q))
+
+    engine = LagrangianEngine([q], [qdot], L)
+
+    q0, p0 = np.array([0.6]), np.array([0.9])
+    y0 = np.concatenate([q0, p0])
+    dy = engine.canonical_deriv_njit(0.0, y0)
+    dq_analytic, dp_analytic = dy[0], dy[1]
+
+    eps = 1e-6
+
+    def H(qa, pa):
+        return float(engine.hamiltonian_njit(np.array([qa]), np.array([pa]), 0.0))
+
+    dHdq_fd = (H(q0[0] + eps, p0[0]) - H(q0[0] - eps, p0[0])) / (2 * eps)
+    dHdp_fd = (H(q0[0], p0[0] + eps) - H(q0[0], p0[0] - eps)) / (2 * eps)
+
+    assert np.isclose(dq_analytic, dHdp_fd, atol=1e-6)
+    assert np.isclose(dp_analytic, -dHdq_fd, atol=1e-6)
+
+
+def test_two_dof_coupled_system_matches_finite_difference():
+    """Same finite-difference consistency check, but for a genuinely
+    coupled 2-DOF Lagrangian (unequal masses, linear coupling) -- the
+    structurally closest case to the CoupledOscillators bug."""
+    m1, m2, k = 1.7, 0.9, 2.5
+    q0s, q1s, w0s, w1s = sp.symbols("q0 q1 w0 w1")
+    L = sp.Rational(1, 2) * m1 * w0s**2 + sp.Rational(1, 2) * m2 * w1s**2 - sp.Rational(1, 2) * k * q0s**2 - sp.Rational(1, 2) * k * (q1s - q0s) ** 2
+    engine = LagrangianEngine([q0s, q1s], [w0s, w1s], L)
+
+    q0, p0 = np.array([0.3, -0.2]), np.array([0.5, 0.1])
+    y0 = np.concatenate([q0, p0])
+    dy = engine.canonical_deriv_njit(0.0, y0)
+    dq_analytic, dp_analytic = dy[:2], dy[2:]
+
+    eps = 1e-6
+
+    def H(qa, pa):
+        return float(engine.hamiltonian_njit(qa, pa, 0.0))
+
+    dHdq_fd = np.array([(H(q0 + eps * e, p0) - H(q0 - eps * e, p0)) / (2 * eps) for e in np.eye(2)])
+    dHdp_fd = np.array([(H(q0, p0 + eps * e) - H(q0, p0 - eps * e)) / (2 * eps) for e in np.eye(2)])
+
+    assert np.allclose(dq_analytic, dHdp_fd, atol=1e-6)
+    assert np.allclose(dp_analytic, -dHdq_fd, atol=1e-6)
+
+    # Momentum should be the classical p_i = m_i * qdot_i for this
+    # diagonal-mass-matrix system (a sign flip here would break it).
+    qdot0 = np.array([0.4, -0.1])
+    p_from_qdot = engine.momentum_njit(q0, qdot0)
+    assert np.allclose(p_from_qdot, [m1 * qdot0[0], m2 * qdot0[1]])
+
+
+def test_explicit_time_dependence():
+    """A driven oscillator L = (1/2)qdot^2 - (1/2)q^2 + q*sin(t) must
+    give the textbook forced equation qddot = -q + sin(t)."""
+    t = sp.symbols("t")
+    q, qdot = sp.symbols("q qdot")
+    L = sp.Rational(1, 2) * qdot**2 - sp.Rational(1, 2) * q**2 + q * sp.sin(t)
+
+    engine = LagrangianEngine([q], [qdot], L, t=t)
+
+    q0, qdot0, t0 = np.array([0.4]), np.array([-0.2]), 1.1
+    accel = engine.acceleration_njit(q0, qdot0, t0)
+    assert np.allclose(accel, [-q0[0] + np.sin(t0)])