tsdynamics 2.2.2__tar.gz → 2.4.0__tar.gz

{tsdynamics-2.2.2 → tsdynamics-2.4.0}/.gitignore

@@ -175,3 +175,11 @@ src/tsdynamics/_version.py
 # Generated docs artifacts (figures render at build time, cache in .cache/)
 docs/assets/figures/systems/
 site/
+
+# Rust core crate build artifacts (Cargo.lock IS committed for reproducible
+# wheel builds — the crate ships a distributable artifact).
+crates/*/target/
+crates/*/dist/
+crates/*/.venv/
+
+crates/*/uv.lock

{tsdynamics-2.2.2 → tsdynamics-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tsdynamics
-Version: 2.2.2
+Version: 2.4.0
 Summary: Compiled ODE/DDE integration, discrete maps, and chaos analysis for dynamical systems.
 Project-URL: Source, https://github.com/El3ssar/TSDynamics
 Project-URL: Documentation, https://el3ssar.github.io/TSDynamics/

{tsdynamics-2.2.2 → tsdynamics-2.4.0}/src/tsdynamics/__init__.py

@@ -48,7 +48,7 @@ from .systems import continuous as _continuous
 from .systems import discrete as _discrete
 
 # Single source of truth for the package version; rewritten by python-semantic-release.
-__version__ = "2.2.2"
+__version__ = "2.4.0"
 
 # Re-export every system class at the top level so ``from tsdynamics import Lorenz``
 # works without users having to remember which submodule a system lives in.

tsdynamics-2.4.0/src/tsdynamics/backends/rustcore.py

@@ -0,0 +1,375 @@
+"""Experimental Rust-backed RHS evaluation and ensemble integration (``tsdynamics-core``).
+
+The same symbolic ``_equations`` that feed the DiffSL backend are lowered here
+to a flat *instruction tape* — single-static-assignment primitives over a
+register file — which the Rust crate evaluates with no Python callbacks and no
+runtime compiler.  That makes ensemble integration GIL-free and rayon-parallel
+(the basin/Monte-Carlo primitive), and is the foundation the future Rust SDE
+and DDE solvers build on.
+
+``tsdynamics`` itself stays pure-Python; this module is inert unless the
+optional accelerator is installed::
+
+    pip install tsdynamics-core    # or the [rustcore] extra
+
+Limitations (experimental): ODEs only; fixed-step explicit RK4 (no stiff
+support — use the ``jitcode``/``diffsol`` backends for stiff systems); the RHS
+must use functions the tape VM provides (the same set the DiffSL backend
+supports).  Unsupported constructs raise :class:`TapeCompileError`.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+
+__all__ = [
+    "TapeCompileError",
+    "available",
+    "compile_tape",
+    "ensemble_final",
+    "eval_rhs",
+    "integrate_dense",
+]
+
+# ---------------------------------------------------------------------------
+# Opcodes — MUST stay in sync with crates/tsdynamics-core/src/vm.rs
+# ---------------------------------------------------------------------------
+OP_CONST = 0
+OP_STATE = 1
+OP_PARAM = 2
+OP_TIME = 3
+OP_ADD = 10
+OP_SUB = 11
+OP_MUL = 12
+OP_DIV = 13
+OP_POW = 14  # regs[a] ** regs[b]
+OP_POWI = 15  # regs[a] ** b   (b is the integer exponent)
+OP_NEG = 20
+OP_RECIP = 21
+_FUNC_OPS = {
+    "sin": 30,
+    "cos": 31,
+    "tan": 32,
+    "exp": 33,
+    "log": 34,
+    "sqrt": 35,
+    "Abs": 36,
+    "sign": 37,
+    "sinh": 38,
+    "cosh": 39,
+    "tanh": 40,
+    "asin": 41,
+    "acos": 42,
+    "atan": 43,
+    "asinh": 44,
+    "acosh": 45,
+    "atanh": 46,
+}
+_OP_SQRT = 35
+
+
+class TapeCompileError(NotImplementedError):
+    """The system's RHS uses a construct the tape VM cannot express."""
+
+
+def available() -> bool:
+    """Whether the optional ``tsdynamics-core`` accelerator is installed."""
+    try:
+        import tsdynamics_core  # noqa: F401
+    except ImportError:
+        return False
+    return True
+
+
+# ---------------------------------------------------------------------------
+# Symbolic RHS  →  instruction tape
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class CompiledTape:
+    """A system RHS lowered to flat arrays for the Rust tape VM."""
+
+    ops: np.ndarray  # int32 (n_instr,)
+    a: np.ndarray  # int32
+    b: np.ndarray  # int32
+    imm: np.ndarray  # float64
+    outputs: np.ndarray  # int32 (dim,) — register holding each derivative
+    n_state: int
+    n_param: int
+    control_names: list[str]
+
+
+class _Emitter:
+    """Lower a sympy expression DAG to SSA instructions, sharing subexpressions."""
+
+    def __init__(self) -> None:
+        self.ops: list[int] = []
+        self.a: list[int] = []
+        self.b: list[int] = []
+        self.imm: list[float] = []
+        self._cache: dict[Any, int] = {}
+
+    def _push(self, op: int, a: int = 0, b: int = 0, imm: float = 0.0) -> int:
+        idx = len(self.ops)
+        self.ops.append(op)
+        self.a.append(a)
+        self.b.append(b)
+        self.imm.append(imm)
+        return idx
+
+    def emit(self, expr: Any) -> int:
+        cached = self._cache.get(expr)
+        if cached is not None:
+            return cached
+        idx = self._emit(expr)
+        self._cache[expr] = idx
+        return idx
+
+    def _emit(self, expr: Any) -> int:
+        import sympy
+
+        # Any symbol-free subexpression (numbers, pi, e, constant folds).
+        if not expr.free_symbols:
+            return self._push(OP_CONST, imm=float(expr))
+
+        if isinstance(expr, sympy.Symbol):
+            name = expr.name
+            if name == "t":
+                return self._push(OP_TIME)
+            if name.startswith("u"):
+                return self._push(OP_STATE, a=int(name[1:]))
+            if name.startswith("p"):
+                return self._push(OP_PARAM, a=int(name[1:]))
+            raise TapeCompileError(f"unexpected symbol {name!r} in RHS")
+
+        if isinstance(expr, sympy.Add):
+            args = expr.args
+            acc = self.emit(args[0])
+            for term in args[1:]:
+                acc = self._push(OP_ADD, a=acc, b=self.emit(term))
+            return acc
+
+        if isinstance(expr, sympy.Mul):
+            args = expr.args
+            acc = self.emit(args[0])
+            for fac in args[1:]:
+                acc = self._push(OP_MUL, a=acc, b=self.emit(fac))
+            return acc
+
+        if isinstance(expr, sympy.Pow):
+            return self._emit_pow(expr)
+
+        name = type(expr).__name__
+        op = _FUNC_OPS.get(name)
+        if op is not None:
+            if len(expr.args) != 1:
+                raise TapeCompileError(f"function {name!r} expects 1 argument")
+            return self._push(op, a=self.emit(expr.args[0]))
+
+        raise TapeCompileError(f"tape VM has no equivalent for {name!r}.")
+
+    def _emit_pow(self, expr: Any) -> int:
+        import sympy
+
+        base, exp = expr.base, expr.exp
+        base_reg = self.emit(base)
+        if isinstance(exp, sympy.Integer):
+            e = int(exp)
+            if e == -1:
+                return self._push(OP_RECIP, a=base_reg)
+            return self._push(OP_POWI, a=base_reg, b=e)
+        if exp == sympy.Rational(1, 2):
+            return self._push(_OP_SQRT, a=base_reg)
+        if exp == sympy.Rational(-1, 2):
+            sqrt_reg = self._push(_OP_SQRT, a=base_reg)
+            return self._push(OP_RECIP, a=sqrt_reg)
+        # general exponent: a constant non-integer power, or a symbolic exponent
+        return self._push(OP_POW, a=base_reg, b=self.emit(exp))
+
+
+def compile_tape(system: Any) -> CompiledTape:
+    """
+    Lower a :class:`~tsdynamics.base.ContinuousSystem`'s RHS to a tape.
+
+    Structural parameters are folded to constants; control parameters become
+    inputs in ``control_names`` order (the layout the solve-time params vector
+    must follow).
+    """
+    import symengine
+    from jitcode import t as t_sym
+    from jitcode import y
+
+    dim = system.dim
+    struct_vals = system._structural_vals()
+    control_names = list(system._control_params())
+    control_syms = {k: symengine.Symbol(f"p{i}") for i, k in enumerate(control_names)}
+
+    exprs = list(type(system)._equations(y, t_sym, **{**struct_vals, **control_syms}))
+    if len(exprs) != dim:
+        raise ValueError(f"_equations must return {dim} expressions, got {len(exprs)}")
+
+    subs = {y(i): symengine.Symbol(f"u{i}") for i in range(dim)}
+    subs[t_sym] = symengine.Symbol("t")
+
+    em = _Emitter()
+    outputs = [em.emit(symengine.sympify(e).subs(subs)._sympy_()) for e in exprs]
+
+    return CompiledTape(
+        ops=np.asarray(em.ops, dtype=np.int32),
+        a=np.asarray(em.a, dtype=np.int32),
+        b=np.asarray(em.b, dtype=np.int32),
+        imm=np.asarray(em.imm, dtype=np.float64),
+        outputs=np.asarray(outputs, dtype=np.int32),
+        n_state=dim,
+        n_param=len(control_names),
+        control_names=control_names,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Thin wrappers over the Rust kernels
+# ---------------------------------------------------------------------------
+
+
+def _require():
+    if not available():
+        raise ImportError(
+            "the Rust core is not installed: pip install tsdynamics-core (or the 'rustcore' extra)"
+        )
+    import tsdynamics_core
+
+    return tsdynamics_core
+
+
+def _params_vec(system: Any, tape: CompiledTape) -> np.ndarray:
+    return np.asarray([float(system.params[k]) for k in tape.control_names], dtype=np.float64)
+
+
+def _args(tape: CompiledTape):
+    return (tape.ops, tape.a, tape.b, tape.imm, tape.outputs, tape.n_state, tape.n_param)
+
+
+# Method names: fixed-step RK4, or the adaptive Dormand-Prince 5(4) kernel.
+# These are the only kernels the crate implements; an unknown name is rejected
+# (rather than silently downgraded) — there is no DOP853/LSODA kernel to reach.
+_FIXED_RK4 = {"RK4", "rk4"}
+_ADAPTIVE = {"RK45", "rk45", "dopri5", "DP45"}
+_METHODS = _FIXED_RK4 | _ADAPTIVE
+
+
+def _check_method(method: str) -> None:
+    if method not in _METHODS:
+        raise ValueError(
+            f"rustcore: unknown method {method!r}; supported: {sorted(_METHODS)} "
+            "(RK4 = fixed step, RK45/dopri5 = adaptive). For stiff systems use the "
+            "jitcode/diffsol backends."
+        )
+
+
+def _as_state(x: Any, dim: int, name: str) -> np.ndarray:
+    """Coerce to a contiguous float64 1-D vector of length ``dim`` (or raise)."""
+    a = np.ascontiguousarray(x, dtype=np.float64).ravel()
+    if a.size != dim:
+        raise ValueError(f"rustcore: {name} has length {a.size}, expected dim={dim}")
+    return a
+
+
+def eval_rhs(
+    system: Any, u: Any, t: float = 0.0, *, tape: CompiledTape | None = None
+) -> np.ndarray:
+    """Evaluate ``du/dt`` once in Rust — used to cross-check the tape."""
+    core = _require()
+    tape = tape or compile_tape(system)
+    u = _as_state(u, tape.n_state, "u")
+    return np.asarray(core.eval_rhs(*_args(tape), u, _params_vec(system, tape), float(t)))
+
+
+def integrate_dense(
+    system: Any,
+    ic: Any,
+    t_eval: Any,
+    *,
+    method: str = "RK45",
+    rtol: float = 1e-6,
+    atol: float = 1e-9,
+    h: float | None = None,
+    tape: CompiledTape | None = None,
+) -> np.ndarray:
+    """Integrate a trajectory and sample it at ``t_eval``.
+
+    ``method="RK45"`` (default) uses error-controlled adaptive Dormand-Prince
+    5(4) with Hermite dense output (``rtol``/``atol`` set the tolerance);
+    ``method="RK4"`` uses fixed-step RK4 with internal step ``h``.
+
+    Raises ``RuntimeError`` if the trajectory diverges or the step collapses
+    before reaching the final time (matching the jitcode/diffsol backends).
+    """
+    _check_method(method)
+    core = _require()
+    tape = tape or compile_tape(system)
+    t_eval = np.ascontiguousarray(t_eval, dtype=np.float64)
+    ic = _as_state(ic, tape.n_state, "ic")
+    p = _params_vec(system, tape)
+    if method in _FIXED_RK4:
+        if h is None:
+            h = float(np.min(np.diff(t_eval))) if t_eval.size > 1 else 1e-2
+        y = np.asarray(core.integrate_dense_py(*_args(tape), ic, p, t_eval, float(h)))
+    else:
+        y = np.asarray(
+            core.integrate_dense_rk45_py(*_args(tape), ic, p, t_eval, float(rtol), float(atol))
+        )
+    if not np.all(np.isfinite(y)):
+        raise RuntimeError(
+            f"{type(system).__name__}: rustcore integration diverged or the step "
+            "collapsed before reaching the final time."
+        )
+    return y
+
+
+def ensemble_final(
+    system: Any,
+    u0_batch: Any,
+    t0: float,
+    t1: float,
+    *,
+    method: str = "RK45",
+    rtol: float = 1e-6,
+    atol: float = 1e-9,
+    h: float = 1e-2,
+    tape: CompiledTape | None = None,
+) -> np.ndarray:
+    """Integrate a batch of initial conditions in parallel; return final states.
+
+    ``u0_batch`` is ``(n, dim)``; each row is integrated from ``t0`` to ``t1``
+    and its final state returned as a row of the ``(n, dim)`` result.
+    ``method`` selects the adaptive (``"RK45"``, default) or fixed-step
+    (``"RK4"``) kernel, as in :func:`integrate_dense`.
+
+    A trajectory that diverges (escapes to infinity) yields a row of ``NaN``
+    rather than aborting the batch — the basin/ensemble caller classifies those
+    initial conditions as escaped.
+    """
+    _check_method(method)
+    core = _require()
+    tape = tape or compile_tape(system)
+    u0_batch = np.ascontiguousarray(u0_batch, dtype=np.float64)
+    if u0_batch.ndim != 2 or u0_batch.shape[1] != tape.n_state:
+        raise ValueError(
+            f"rustcore: u0_batch must be (n, {tape.n_state}); got shape {u0_batch.shape}"
+        )
+    p = _params_vec(system, tape)
+    if method in _FIXED_RK4:
+        return np.asarray(
+            core.integrate_ensemble_final_py(
+                *_args(tape), u0_batch, p, float(t0), float(t1), float(h)
+            )
+        )
+    return np.asarray(
+        core.integrate_ensemble_final_rk45_py(
+            *_args(tape), u0_batch, p, float(t0), float(t1), float(rtol), float(atol)
+        )
+    )

tsdynamics-2.4.0/tests/test_rustcore.py

@@ -0,0 +1,220 @@
+"""
+Numeric validation of the ``tsdynamics-core`` Rust kernels.
+
+Skipped entirely unless the optional accelerator is installed.  These tests
+prove the tape VM reproduces the symbolic RHS, that the RK4 stepper matches a
+high-accuracy SciPy reference, and that the rayon ensemble runner is
+deterministic and race-free (parallel == serial, bit for bit).
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+import tsdynamics as ts
+from tsdynamics.backends import rustcore as rc
+from tsdynamics.base.ode_base import ContinuousSystem
+
+pytestmark = pytest.mark.skipif(
+    not rc.available(), reason="tsdynamics-core (Rust accelerator) is not installed"
+)
+
+_EVAL_SAMPLE = ["Lorenz", "Rossler", "Chen", "Thomas", "Halvorsen", "SprottA"]
+
+
+# Tiny user-defined systems for the robustness/regression tests below. They
+# register as non-builtin, so the builtin-only catalogue sweeps never see them.
+class _Blowup(ContinuousSystem):
+    """du/dt = u² — finite-time blow-up from u0 = 1 near t = 1."""
+
+    params: dict = {}
+    dim = 1
+
+    @staticmethod
+    def _equations(y, t):
+        return [y(0) ** 2]
+
+
+class _Twin(ContinuousSystem):
+    """Both components are the bare symbol u0 → the tape CSEs to n_reg = 1 < dim."""
+
+    params: dict = {}
+    dim = 2
+
+    @staticmethod
+    def _equations(y, t):
+        return [y(0), y(0)]
+
+
+@pytest.mark.parametrize("name", _EVAL_SAMPLE)
+def test_tape_eval_matches_symbolic_rhs(name: str) -> None:
+    """The Rust tape evaluates the exact same RHS as the symbolic core."""
+    sys = getattr(ts, name)()
+    tape = rc.compile_tape(sys)
+    f = sys._rhs_numeric()
+    rng = np.random.default_rng(abs(hash(name)) % (2**32))
+    for _ in range(8):
+        u = rng.standard_normal(sys.dim)
+        t = float(rng.uniform(0.0, 5.0))
+        got = rc.eval_rhs(sys, u, t, tape=tape)
+        ref = f(u, t)
+        np.testing.assert_allclose(got, ref, rtol=1e-9, atol=1e-9)
+
+
+@pytest.mark.parametrize(
+    ("name", "ic"),
+    [("Lorenz", [1.0, 1.0, 1.0]), ("Rossler", [0.1, 0.0, 0.0])],
+)
+def test_rk4_matches_scipy(name: str, ic: list[float]) -> None:
+    """Fixed-step RK4 agrees with a high-accuracy SciPy reference."""
+    from scipy.integrate import solve_ivp
+
+    sys = getattr(ts, name)()
+    t_eval = np.linspace(0.0, 8.0, 801)
+    y = rc.integrate_dense(sys, ic, t_eval, method="RK4", h=1e-3)
+    assert y.shape == (t_eval.size, sys.dim)
+    f = sys._rhs_numeric()
+    sol = solve_ivp(lambda t, u: f(u, t), (0.0, 8.0), ic, t_eval=t_eval, rtol=1e-11, atol=1e-13)
+    # Chaotic divergence over 8 t.u. is bounded for matched truncation; require
+    # tight early agreement and finiteness throughout.
+    assert np.all(np.isfinite(y))
+    early = t_eval <= 3.0
+    np.testing.assert_allclose(y[early], sol.y.T[early], atol=1e-4)
+
+
+@pytest.mark.parametrize(
+    ("name", "ic"),
+    [("Lorenz", [1.0, 1.0, 1.0]), ("Rossler", [1.0, 1.0, 1.0]), ("Thomas", [0.1, 0.0, 0.0])],
+)
+def test_rk45_matches_scipy(name: str, ic: list[float]) -> None:
+    """Adaptive Dormand-Prince agrees with SciPy's RK45 at the same tolerance."""
+    from scipy.integrate import solve_ivp
+
+    sys = getattr(ts, name)()
+    rtol, atol = 1e-8, 1e-10
+    t_eval = np.linspace(0.0, 5.0, 501)
+    y = rc.integrate_dense(sys, ic, t_eval, method="RK45", rtol=rtol, atol=atol)
+    assert y.shape == (t_eval.size, sys.dim)
+    assert np.all(np.isfinite(y))
+    f = sys._rhs_numeric()
+    ref = solve_ivp(
+        lambda t, u: f(u, t), (0.0, 5.0), ic, t_eval=t_eval, rtol=rtol, atol=atol, method="RK45"
+    ).y.T
+    # Two correct integrators on a chaotic flow diverge slowly; require tight
+    # agreement in the early window where Lyapunov amplification is small.
+    early = t_eval <= 2.0
+    np.testing.assert_allclose(y[early], ref[early], atol=1e-3)
+
+
+def test_rk45_converges_with_tolerance() -> None:
+    """Tightening the tolerance drives the error toward a high-accuracy reference."""
+    from scipy.integrate import solve_ivp
+
+    sys = ts.Lorenz()
+    ic = [1.0, 1.0, 1.0]
+    t_eval = np.linspace(0.0, 3.0, 301)
+    f = sys._rhs_numeric()
+    ref = solve_ivp(
+        lambda t, u: f(u, t), (0.0, 3.0), ic, t_eval=t_eval, rtol=1e-12, atol=1e-14, method="DOP853"
+    ).y.T
+    err_loose = np.max(np.abs(rc.integrate_dense(sys, ic, t_eval, rtol=1e-6, atol=1e-9) - ref))
+    err_tight = np.max(np.abs(rc.integrate_dense(sys, ic, t_eval, rtol=1e-10, atol=1e-12) - ref))
+    assert err_tight < err_loose
+    assert err_tight < 1e-4  # adaptive at rtol=1e-10 tracks the reference closely
+
+
+def test_adaptive_ensemble_deterministic_and_matches_serial() -> None:
+    """Adaptive ensemble == serial adaptive, bit for bit, and is reproducible."""
+    sys = ts.Lorenz()
+    rng = np.random.default_rng(3)
+    batch = rng.uniform(-12.0, 12.0, size=(400, 3))
+    fin = rc.ensemble_final(sys, batch, 0.0, 4.0, method="RK45", rtol=1e-8, atol=1e-10)
+    assert fin.shape == batch.shape and np.all(np.isfinite(fin))
+    np.testing.assert_array_equal(
+        fin, rc.ensemble_final(sys, batch, 0.0, 4.0, method="RK45", rtol=1e-8, atol=1e-10)
+    )
+    for i in (0, 200, 399):
+        serial = rc.integrate_dense(
+            sys, batch[i], np.array([0.0, 4.0]), method="RK45", rtol=1e-8, atol=1e-10
+        )[-1]
+        np.testing.assert_array_equal(fin[i], serial)
+
+
+def test_ensemble_is_deterministic_and_race_free() -> None:
+    """Fixed-step parallel ensemble == serial per-trajectory, bit for bit; all finite."""
+    sys = ts.Lorenz()
+    rng = np.random.default_rng(0)
+    batch = rng.uniform(-12.0, 12.0, size=(500, 3))
+    fin = rc.ensemble_final(sys, batch, 0.0, 4.0, method="RK4", h=2e-3)
+    assert fin.shape == batch.shape
+    assert np.all(np.isfinite(fin))
+    # Re-running must be identical (no nondeterministic reduction).
+    again = rc.ensemble_final(sys, batch, 0.0, 4.0, method="RK4", h=2e-3)
+    np.testing.assert_array_equal(fin, again)
+    # And it must equal the serial single-trajectory result for sampled rows.
+    for i in (0, 17, 250, 499):
+        serial = rc.integrate_dense(sys, batch[i], np.array([0.0, 4.0]), method="RK4", h=2e-3)[-1]
+        np.testing.assert_array_equal(fin[i], serial)
+
+
+# ---------------------------------------------------------------------------
+# Robustness / regression — failure modes an adversarial review surfaced.
+# Each must terminate (no infinite loop) and signal cleanly, not crash or lie.
+# ---------------------------------------------------------------------------
+
+
+def test_divergent_trajectory_raises_not_hangs() -> None:
+    """A blow-up must raise (not spin forever on a NaN error norm)."""
+    with pytest.raises(RuntimeError):
+        rc.integrate_dense(_Blowup(), [1.0], np.linspace(0.0, 5.0, 101), method="RK45")
+
+
+def test_ensemble_divergent_ics_yield_nan_rows() -> None:
+    """Diverging ICs become NaN rows; the batch finishes and finite ICs survive."""
+    batch = np.array([[0.1], [0.2], [5.0], [10.0]])
+    fin = rc.ensemble_final(_Blowup(), batch, 0.0, 3.0, method="RK45")
+    assert np.isfinite(fin[0, 0]) and np.isfinite(fin[1, 0])
+    assert np.isnan(fin[2, 0]) and np.isnan(fin[3, 0])
+
+
+def test_degenerate_tape_nreg_below_dim_does_not_panic() -> None:
+    """A tape with fewer registers than state components must integrate, not panic."""
+    y = rc.integrate_dense(_Twin(), [1.0, 1.0], np.linspace(0.0, 1.0, 11), method="RK45")
+    assert np.all(np.isfinite(y))
+    # Analytic: u0 = e^t, u1 = 1 + (e^t − 1) = e^t.
+    np.testing.assert_allclose(y[-1], [np.e, np.e], rtol=1e-4)
+
+
+def test_noncontiguous_inputs_are_accepted() -> None:
+    """Strided (non-C-contiguous) ic / t_eval must be coerced, not panic."""
+    lor = ts.Lorenz()
+    t_eval = np.linspace(0.0, 2.0, 41)[::2]  # strided view
+    ic = np.array([1.0, 1.0, 1.0, 9.0])[:3]  # strided-ish view
+    y = rc.integrate_dense(lor, ic, t_eval, method="RK45")
+    assert y.shape == (t_eval.size, 3) and np.all(np.isfinite(y))
+
+
+def test_unknown_method_raises() -> None:
+    with pytest.raises(ValueError, match="unknown method"):
+        rc.integrate_dense(ts.Lorenz(), [1.0, 1.0, 1.0], np.linspace(0, 1, 5), method="DOP853")
+
+
+def test_dimension_mismatch_raises() -> None:
+    lor = ts.Lorenz()
+    with pytest.raises(ValueError):
+        rc.integrate_dense(lor, [1.0, 1.0], np.linspace(0, 1, 5))
+    with pytest.raises(ValueError):
+        rc.ensemble_final(lor, np.zeros((5, 2)), 0.0, 1.0)
+
+
+@pytest.mark.parametrize("method", ["RK45", "RK4"])
+def test_empty_t_eval_returns_empty(method: str) -> None:
+    y = rc.integrate_dense(ts.Lorenz(), [1.0, 1.0, 1.0], np.array([]), method=method)
+    assert y.shape[0] == 0
+
+
+def test_version_is_exposed() -> None:
+    import tsdynamics_core
+
+    assert isinstance(tsdynamics_core._version(), str)

tsdynamics-2.4.0/tests/test_rustcore_translation.py

@@ -0,0 +1,49 @@
+"""
+Rust-core *tape compiler* coverage — runs without the ``tsdynamics-core`` extra.
+
+``compile_tape`` only needs SymEngine + the jitcode symbols, so this guards the
+symbolic→tape lowering for the whole ODE catalogue on every CI run, regardless
+of whether the Rust accelerator is installed.  The numeric cross-validation
+against the symbolic RHS (and the RK4/ensemble kernels) lives in
+``test_rustcore.py``, which needs the compiled crate and is skipped when absent.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from tsdynamics import registry
+from tsdynamics.backends.rustcore import TapeCompileError, compile_tape
+
+
+def test_every_ode_compiles_to_tape(ode_entry) -> None:
+    """Every built-in ODE must lower to a well-formed instruction tape."""
+    try:
+        tape = compile_tape(ode_entry.cls())
+    except TapeCompileError as exc:
+        raise AssertionError(f"{ode_entry.name}: no longer compiles to a tape — {exc}") from exc
+
+    n = tape.ops.size
+    # Parallel instruction arrays agree in length.
+    assert tape.a.size == n and tape.b.size == n and tape.imm.size == n
+    # One output register per state component.
+    assert tape.outputs.size == ode_entry.cls().dim == tape.n_state
+    # Every register reference points to an already-emitted instruction.
+    assert np.all(tape.outputs < n) and np.all(tape.outputs >= 0)
+    # control inputs = the non-structural params (structural ones are folded
+    # to constants in the tape, mirroring the DiffSL backend).
+    cls = ode_entry.cls
+    structural = getattr(cls, "_structural_params", frozenset())
+    expected = [k for k in cls().params if k not in structural]
+    assert list(tape.control_names) == expected
+
+
+def test_tape_coverage_is_total() -> None:
+    """The whole ODE catalogue lowers to a tape — the Rust-core coverage fact."""
+    failed = []
+    for e in registry.all_systems(family="ode"):
+        try:
+            compile_tape(e.cls())
+        except Exception as exc:  # noqa: BLE001 — record, don't abort
+            failed.append((e.name, str(exc).splitlines()[0][:60]))
+    assert not failed, f"{len(failed)} ODE systems no longer compile to a tape: {failed}"