tsdynamics 5.2.4__tar.gz → 5.2.6__tar.gz

tsdynamics-5.2.6/PKG-INFO

@@ -0,0 +1,221 @@
+Metadata-Version: 2.4
+Name: tsdynamics
+Version: 5.2.6
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Typing :: Typed
+Requires-Dist: numpy>=2.0,<3.0
+Requires-Dist: scipy>=1.14,<2.0
+Requires-Dist: symengine>=0.13,<1.0
+Requires-Dist: sympy>=1.13,<2.0
+Requires-Dist: plotly>=6,<7 ; extra == 'interactive'
+Requires-Dist: lzcomplexity>=0.9 ; extra == 'lz'
+Requires-Dist: matplotlib>=3.9,<5 ; extra == 'plot'
+Requires-Dist: matplotlib>=3.9,<5 ; extra == 'viz'
+Provides-Extra: interactive
+Provides-Extra: lz
+Provides-Extra: plot
+Provides-Extra: viz
+License-File: LICENSE
+Summary: Zero-warmup Rust-engine ODE/DDE/SDE integration, discrete maps, and chaos analysis for dynamical systems.
+Keywords: dynamical systems,ODE,DDE,chaos,Lyapunov exponents,nonlinear dynamics,bifurcation,attractors,reservoir computing
+Author-email: Daniel Estevez <kemossabee@gmail.com>
+License-Expression: MIT
+Requires-Python: >=3.12, <4.0
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Changelog, https://github.com/El3ssar/TSDynamics/releases
+Project-URL: Documentation, https://el3ssar.github.io/TSDynamics/
+Project-URL: Issues, https://github.com/El3ssar/TSDynamics/issues
+Project-URL: Source, https://github.com/El3ssar/TSDynamics
+
+# TSDynamics
+
+[![Python](https://img.shields.io/pypi/pyversions/tsdynamics)](https://pypi.org/project/tsdynamics/)
+[![CI](https://github.com/El3ssar/TSDynamics/actions/workflows/ci.yml/badge.svg)](https://github.com/El3ssar/TSDynamics/actions/workflows/ci.yml)
+[![Release](https://github.com/El3ssar/TSDynamics/actions/workflows/release.yml/badge.svg)](https://github.com/El3ssar/TSDynamics/actions/workflows/release.yml)
+[![Docs](https://github.com/El3ssar/TSDynamics/actions/workflows/docs.yml/badge.svg)](https://el3ssar.github.io/TSDynamics/)
+[![PyPI](https://img.shields.io/pypi/v/tsdynamics)](https://pypi.org/project/tsdynamics/)
+[![codecov](https://codecov.io/gh/El3ssar/TSDynamics/graph/badge.svg)](https://codecov.io/gh/El3ssar/TSDynamics)
+
+**Dynamical systems in Python: 151 built-in systems, a native Rust integration
+engine, and a chaos-analysis toolkit — with the simplest system-definition
+contract anywhere.**
+
+You write the math (one symbolic method); TSDynamics lowers it to a native Rust
+engine and handles integration, Lyapunov spectra, bifurcation diagrams, Poincaré
+sections, attractors & basins — and even the documentation page for your system.
+
+<p align="center">
+  <img src="docs/assets/readme/lorenz_spin.gif" width="440" alt="A spinning Lorenz attractor"><br>
+  <em>A built-in Lorenz attractor — integrated, spun, and saved to a GIF (code below).</em>
+</p>
+
+```python
+import tsdynamics as ts
+
+lor = ts.Lorenz()
+traj = lor.integrate(final_time=100.0, dt=0.01)
+traj["x"]                              # named component access
+lor.lyapunov_spectrum()                # → [0.91, ~0, -14.57]
+ts.kaplan_yorke_dimension(_)           # → ~2.06
+```
+
+📖 **Documentation: <https://el3ssar.github.io/TSDynamics/>**
+
+---
+
+## Define your own system
+
+```python
+import tsdynamics as ts
+
+class Rossler(ts.ContinuousSystem):
+    params = {"a": 0.2, "b": 0.2, "c": 5.7}
+    dim = 3
+    variables = ("x", "y", "z")            # optional niceties
+
+    @staticmethod
+    def _equations(y, t, *, a, b, c):
+        x, yv, z = y(0), y(1), y(2)
+        return (-yv - z, x + a * yv, b + z * (x - c))
+```
+
+That's the whole contract. The class auto-registers: every analysis tool works
+on it, the test-suite sweeps it, and the docs build renders its equations
+(LaTeX, straight from the symbolics) and its attractor — zero extra steps. Delay
+systems use `y(0, t - tau)`; maps implement `_step`/`_jacobian` (signature order
+validated at import); SDEs add a `_diffusion` term.
+
+## From equations to figures
+
+Every system produces a `Trajectory`, and every `Trajectory` knows how to plot
+itself (`to_plot_spec` auto-detects the right kind from the data). The plot is a
+backend-neutral *spec* you tweak fluently, then `render` or `save` to matplotlib,
+plotly (interactive), or a three.js / JSON export.
+
+**Bifurcation diagram of the logistic map**, with the period-doubling onsets
+marked — `orbit_diagram` is one call, and `.bifurcation_points()` finds the
+cascade ($r_1 = 3$, $r_2 = 1 + \sqrt6 \approx 3.449$, …):
+
+```python
+import numpy as np, tsdynamics as ts
+from tsdynamics.viz import Annotation
+
+orbit = ts.orbit_diagram(ts.Logistic(), "r", np.linspace(2.8, 4.0, 2000))
+pts = orbit.bifurcation_points()
+
+spec = orbit.to_plot_spec().relabel(x="r", y="x*", title="Logistic bifurcation")
+spec.style(color="k", s=0.2, alpha=0.5)                  # tiny semi-transparent dots
+spec.annotations = [
+    Annotation("vline", x=pts[i], text=lbl, style={"color": "red", "linestyle": "--"})
+    for i, lbl in [(0, " r₁"), (1, " r₂"), (3, " r₄")]
+]
+spec.save("bifurcation.png", size=(1600, 700))
+```
+
+![Logistic bifurcation diagram](docs/assets/readme/logistic_bifurcation.png)
+
+**A PDE, too** — the Kuramoto–Sivashinsky equation is a built-in spatially
+extended system; its space–time field is auto-detected and drawn as a heatmap:
+
+```python
+ks = ts.KuramotoSivashinsky(N=128, L=22.0)
+traj = ks.integrate(final_time=200.0, dt=0.25)
+traj.to_plot_spec().save("ks.png")        # 128-mode space–time field
+```
+
+
+
+<p align="center">
+  <img src="docs/assets/readme/ks_spacetime.png" alt="Kuramoto–Sivashinsky space–time field">
+</p>
+
+
+The spinning attractor at the top is the same `to_plot_spec`, animated:
+
+```python
+traj = ts.Lorenz().integrate(final_time=100.0, dt=0.01)
+spec = traj.to_plot_spec()
+spec.style(axes=False).trail(None).camera(spin=0.4)      # full curve, no axes, rotate
+spec.animate(fps=30, duration=10, loop=True)
+spec.save("lorenz.gif")
+```
+
+## A taste of the analysis layer
+
+```python
+import numpy as np, tsdynamics as ts
+
+# Poincaré section of the Rössler attractor (root-refined crossings)
+section = ts.poincare_section(ts.Rossler(), plane=("y", 0.0, "up"), n=500)
+
+# Fixed points of the Hénon map, with stability
+ts.fixed_points(ts.Henon())
+# [FixedPoint([-1.1314 -0.3394], unstable), FixedPoint([0.6314 0.1894], unstable)]
+
+# Maximal Lyapunov exponent — no Jacobian needed
+ts.max_lyapunov(ts.Lorenz(ic=[1, 1, 1]), dt=0.05)        # ≈ 0.9
+```
+
+Plus: **attractors & basins** of any flow or map, correlation/Rényi **fractal
+dimensions**, **permutation/sample/dispersion entropy**, **RQA** (recurrence
+quantification), **surrogate** hypothesis tests, **delay embedding** (Takens,
+optimal τ, Cao/FNN), GALI & the 0–1 chaos test, and Lyapunov exponents **from a
+bare time series** (Kantz/Rosenstein).
+
+## Highlights
+
+- **Three families, one interface**
+
+  - **ODEs**
+
+  - **DDEs**
+  - **SDEs**
+  - **Discrete Maps**
+
+- **151 built-in systems** with literature parameters.
+
+- **Native engine**: equations lower to a Rust engine (an SSA-tape
+  interpreter, with a Cranelift JIT alongside) in-process; parameters are runtime
+  values, so changing them is free and there is no compile step or cache.
+
+- **Composition** — a `PoincareMap` of a flow *is* a discrete map, so
+  `orbit_diagram(PoincareMap(Rossler(), ("y", 0.0)), "c", values)` draws the
+  bifurcation diagram of a *flow* in one line.
+
+- **Backend-neutral plotting** — one `PlotSpec` IR renders to matplotlib, plotly
+  (interactive + animated HTML), three.js, or JSON, with a fluent styling/theming
+  vocabulary.
+
+## Install
+
+```bash
+pip install tsdynamics            # or: uv add tsdynamics
+```
+
+A prebuilt `abi3` wheel (manylinux / musllinux / macOS / Windows) bundles the
+native Rust engine. No Rust toolchain and no C compiler needed to install or
+run. Optional plotting extra: `tsdynamics[plot,interactive]` (matplotlib, plotly).
+
+## Development
+
+```bash
+git clone https://github.com/El3ssar/TSDynamics && cd TSDynamics
+uv sync --group dev --group docs
+uv run pytest -m "not slow" --no-cov     # fast tier
+uv run pytest --no-cov                   # full local suite
+TSD_DOCS_FIGURES=0 uv run mkdocs serve   # docs preview
+```
+
+Releases are automated: conventional-commit PR titles drive
+[semantic-release](https://python-semantic-release.readthedocs.io/) on merge see [CONTRIBUTING](https://el3ssar.github.io/TSDynamics/project/contributing/).
+
+## License
+
+MIT © Daniel Estevez
+

tsdynamics-5.2.6/README.md

@@ -0,0 +1,185 @@
+# TSDynamics
+
+[![Python](https://img.shields.io/pypi/pyversions/tsdynamics)](https://pypi.org/project/tsdynamics/)
+[![CI](https://github.com/El3ssar/TSDynamics/actions/workflows/ci.yml/badge.svg)](https://github.com/El3ssar/TSDynamics/actions/workflows/ci.yml)
+[![Release](https://github.com/El3ssar/TSDynamics/actions/workflows/release.yml/badge.svg)](https://github.com/El3ssar/TSDynamics/actions/workflows/release.yml)
+[![Docs](https://github.com/El3ssar/TSDynamics/actions/workflows/docs.yml/badge.svg)](https://el3ssar.github.io/TSDynamics/)
+[![PyPI](https://img.shields.io/pypi/v/tsdynamics)](https://pypi.org/project/tsdynamics/)
+[![codecov](https://codecov.io/gh/El3ssar/TSDynamics/graph/badge.svg)](https://codecov.io/gh/El3ssar/TSDynamics)
+
+**Dynamical systems in Python: 151 built-in systems, a native Rust integration
+engine, and a chaos-analysis toolkit — with the simplest system-definition
+contract anywhere.**
+
+You write the math (one symbolic method); TSDynamics lowers it to a native Rust
+engine and handles integration, Lyapunov spectra, bifurcation diagrams, Poincaré
+sections, attractors & basins — and even the documentation page for your system.
+
+<p align="center">
+  <img src="docs/assets/readme/lorenz_spin.gif" width="440" alt="A spinning Lorenz attractor"><br>
+  <em>A built-in Lorenz attractor — integrated, spun, and saved to a GIF (code below).</em>
+</p>
+
+```python
+import tsdynamics as ts
+
+lor = ts.Lorenz()
+traj = lor.integrate(final_time=100.0, dt=0.01)
+traj["x"]                              # named component access
+lor.lyapunov_spectrum()                # → [0.91, ~0, -14.57]
+ts.kaplan_yorke_dimension(_)           # → ~2.06
+```
+
+📖 **Documentation: <https://el3ssar.github.io/TSDynamics/>**
+
+---
+
+## Define your own system
+
+```python
+import tsdynamics as ts
+
+class Rossler(ts.ContinuousSystem):
+    params = {"a": 0.2, "b": 0.2, "c": 5.7}
+    dim = 3
+    variables = ("x", "y", "z")            # optional niceties
+
+    @staticmethod
+    def _equations(y, t, *, a, b, c):
+        x, yv, z = y(0), y(1), y(2)
+        return (-yv - z, x + a * yv, b + z * (x - c))
+```
+
+That's the whole contract. The class auto-registers: every analysis tool works
+on it, the test-suite sweeps it, and the docs build renders its equations
+(LaTeX, straight from the symbolics) and its attractor — zero extra steps. Delay
+systems use `y(0, t - tau)`; maps implement `_step`/`_jacobian` (signature order
+validated at import); SDEs add a `_diffusion` term.
+
+## From equations to figures
+
+Every system produces a `Trajectory`, and every `Trajectory` knows how to plot
+itself (`to_plot_spec` auto-detects the right kind from the data). The plot is a
+backend-neutral *spec* you tweak fluently, then `render` or `save` to matplotlib,
+plotly (interactive), or a three.js / JSON export.
+
+**Bifurcation diagram of the logistic map**, with the period-doubling onsets
+marked — `orbit_diagram` is one call, and `.bifurcation_points()` finds the
+cascade ($r_1 = 3$, $r_2 = 1 + \sqrt6 \approx 3.449$, …):
+
+```python
+import numpy as np, tsdynamics as ts
+from tsdynamics.viz import Annotation
+
+orbit = ts.orbit_diagram(ts.Logistic(), "r", np.linspace(2.8, 4.0, 2000))
+pts = orbit.bifurcation_points()
+
+spec = orbit.to_plot_spec().relabel(x="r", y="x*", title="Logistic bifurcation")
+spec.style(color="k", s=0.2, alpha=0.5)                  # tiny semi-transparent dots
+spec.annotations = [
+    Annotation("vline", x=pts[i], text=lbl, style={"color": "red", "linestyle": "--"})
+    for i, lbl in [(0, " r₁"), (1, " r₂"), (3, " r₄")]
+]
+spec.save("bifurcation.png", size=(1600, 700))
+```
+
+![Logistic bifurcation diagram](docs/assets/readme/logistic_bifurcation.png)
+
+**A PDE, too** — the Kuramoto–Sivashinsky equation is a built-in spatially
+extended system; its space–time field is auto-detected and drawn as a heatmap:
+
+```python
+ks = ts.KuramotoSivashinsky(N=128, L=22.0)
+traj = ks.integrate(final_time=200.0, dt=0.25)
+traj.to_plot_spec().save("ks.png")        # 128-mode space–time field
+```
+
+
+
+<p align="center">
+  <img src="docs/assets/readme/ks_spacetime.png" alt="Kuramoto–Sivashinsky space–time field">
+</p>
+
+
+The spinning attractor at the top is the same `to_plot_spec`, animated:
+
+```python
+traj = ts.Lorenz().integrate(final_time=100.0, dt=0.01)
+spec = traj.to_plot_spec()
+spec.style(axes=False).trail(None).camera(spin=0.4)      # full curve, no axes, rotate
+spec.animate(fps=30, duration=10, loop=True)
+spec.save("lorenz.gif")
+```
+
+## A taste of the analysis layer
+
+```python
+import numpy as np, tsdynamics as ts
+
+# Poincaré section of the Rössler attractor (root-refined crossings)
+section = ts.poincare_section(ts.Rossler(), plane=("y", 0.0, "up"), n=500)
+
+# Fixed points of the Hénon map, with stability
+ts.fixed_points(ts.Henon())
+# [FixedPoint([-1.1314 -0.3394], unstable), FixedPoint([0.6314 0.1894], unstable)]
+
+# Maximal Lyapunov exponent — no Jacobian needed
+ts.max_lyapunov(ts.Lorenz(ic=[1, 1, 1]), dt=0.05)        # ≈ 0.9
+```
+
+Plus: **attractors & basins** of any flow or map, correlation/Rényi **fractal
+dimensions**, **permutation/sample/dispersion entropy**, **RQA** (recurrence
+quantification), **surrogate** hypothesis tests, **delay embedding** (Takens,
+optimal τ, Cao/FNN), GALI & the 0–1 chaos test, and Lyapunov exponents **from a
+bare time series** (Kantz/Rosenstein).
+
+## Highlights
+
+- **Three families, one interface**
+
+  - **ODEs**
+
+  - **DDEs**
+  - **SDEs**
+  - **Discrete Maps**
+
+- **151 built-in systems** with literature parameters.
+
+- **Native engine**: equations lower to a Rust engine (an SSA-tape
+  interpreter, with a Cranelift JIT alongside) in-process; parameters are runtime
+  values, so changing them is free and there is no compile step or cache.
+
+- **Composition** — a `PoincareMap` of a flow *is* a discrete map, so
+  `orbit_diagram(PoincareMap(Rossler(), ("y", 0.0)), "c", values)` draws the
+  bifurcation diagram of a *flow* in one line.
+
+- **Backend-neutral plotting** — one `PlotSpec` IR renders to matplotlib, plotly
+  (interactive + animated HTML), three.js, or JSON, with a fluent styling/theming
+  vocabulary.
+
+## Install
+
+```bash
+pip install tsdynamics            # or: uv add tsdynamics
+```
+
+A prebuilt `abi3` wheel (manylinux / musllinux / macOS / Windows) bundles the
+native Rust engine. No Rust toolchain and no C compiler needed to install or
+run. Optional plotting extra: `tsdynamics[plot,interactive]` (matplotlib, plotly).
+
+## Development
+
+```bash
+git clone https://github.com/El3ssar/TSDynamics && cd TSDynamics
+uv sync --group dev --group docs
+uv run pytest -m "not slow" --no-cov     # fast tier
+uv run pytest --no-cov                   # full local suite
+TSD_DOCS_FIGURES=0 uv run mkdocs serve   # docs preview
+```
+
+Releases are automated: conventional-commit PR titles drive
+[semantic-release](https://python-semantic-release.readthedocs.io/) on merge see [CONTRIBUTING](https://el3ssar.github.io/TSDynamics/project/contributing/).
+
+## License
+
+MIT © Daniel Estevez

tsdynamics-5.2.6/crates/tsdyn-core/src/bridge/lyapunov.rs

@@ -0,0 +1,162 @@
+//! ODE Lyapunov-spectrum entry point (stream `perf/ode-lyapunov-engine`).
+//!
+//! Thin bridge over the engine's [`tsdyn_engine::lyapunov`] kernel: build the
+//! evaluator (interpreter or JIT) over the **extended** variational tape + resolve
+//! the solver here (the cranelift edge lives in this crate, not the engine), then
+//! run the whole burn-in + averaging Benettin loop in one call. The per-`dt`
+//! integration is byte-for-byte the released `TangentSystem` ODE numerics, so
+//! `interp == jit` and the spectrum matches the Python path to floating-point
+//! tolerance.
+//!
+//! Shared plumbing (evaluator/solver builders, the `EngineError` enum) lives in
+//! [`super::marshal`]; the renormalisation loop and the QR live in
+//! [`tsdyn_engine::lyapunov`].
+
+use tsdyn_engine::lyapunov::{lyapunov_spectrum_ode, LyapunovError, LyapunovOutcome};
+use tsdyn_ir::Tape;
+use tsdyn_solvers::Solver;
+
+use super::marshal::{
+    build_evaluator, build_solver, require_jacobian_if_needed, resolve_solver, EngineError,
+};
+
+/// Map a [`LyapunovError`] (a kernel-side shape / divergence failure) to the
+/// bridge's [`EngineError`] so the binding routes it to the matching Python
+/// exception (`ValueError` / `RuntimeError`).
+fn to_engine_err(e: LyapunovError) -> EngineError {
+    match e {
+        LyapunovError::BadShape(m) => EngineError::BadShape(m),
+        LyapunovError::Diverged(m) => EngineError::Diverged(m),
+    }
+}
+
+/// Run the burn-in + averaging Benettin Lyapunov-spectrum loop over an
+/// **extended variational** ODE tape.
+///
+/// The `tape` is the `dim*(k+1)`-wide extended variational system (base RHS ⊕ the
+/// `k` tangent-vector RHS blocks) built by the Python
+/// `tsdynamics.derived._variational.build_variational_tape`. `method` resolves
+/// through the solver registry; an implicit kernel needs a Jacobian-carrying tape
+/// (the extended tape carries one — rejected up front exactly as the integrate
+/// path does, for the defence-in-depth message). `dt` is the renormalisation
+/// interval, `burn_in` / `final_time` the two window lengths. `p` is the live
+/// control-parameter vector. Returns the spectrum plus the final extended state.
+#[allow(clippy::too_many_arguments)]
+pub fn lyapunov_spectrum_ode_bridge(
+    tape: Tape,
+    p: &[f64],
+    method: &str,
+    rtol: f64,
+    atol: f64,
+    dim: usize,
+    k: usize,
+    z0: &[f64],
+    t0: f64,
+    dt: f64,
+    burn_in: f64,
+    final_time: f64,
+    jit: bool,
+) -> Result<LyapunovOutcome, EngineError> {
+    // The extended tape is `n_state == ev.dim()` (a plain ODE-shaped tape over the
+    // stacked state), validated by the kernel against `dim*(k+1)`. Resolve the
+    // method + the Jacobian guard exactly like the integrate / basin paths.
+    let name = resolve_solver(method)?;
+    require_jacobian_if_needed(&tape, name)?;
+    let ev = build_evaluator(tape, jit)?;
+    // A fresh kernel per `dt` chunk (mirrors `OdeStepper::advance` / the basin
+    // march); the name is a registry name, so `build_solver` always succeeds.
+    let factory = move || -> Box<dyn Solver> { build_solver(name, rtol, atol) };
+    lyapunov_spectrum_ode(&*ev, factory, p, dim, k, z0, t0, dt, burn_in, final_time)
+        .map_err(to_engine_err)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tsdyn_ir::TapeBuilder;
+
+    /// Extended variational tape of `dx = a x, dy = b y` with `k` tangents (the
+    /// Jacobian is the constant `diag(a, b)`). Spectrum is `[max(a,b), min(a,b)]`.
+    fn linear_extended(a: f64, b: f64, k: usize) -> Tape {
+        let dim = 2;
+        let mut bld = TapeBuilder::new();
+        let x = bld.state(0);
+        let y = bld.state(1);
+        let ac = bld.constant(a);
+        let bc = bld.constant(b);
+        let dx = bld.mul(ac, x);
+        let dy = bld.mul(bc, y);
+        let mut outs = vec![dx, dy];
+        for i in 0..k {
+            let base = dim + i * dim;
+            let w0 = bld.state(base);
+            let w1 = bld.state(base + 1);
+            let dw0 = bld.mul(ac, w0);
+            let dw1 = bld.mul(bc, w1);
+            outs.push(dw0);
+            outs.push(dw1);
+        }
+        let n = dim * (k + 1);
+        bld.finish(&outs, &[], n, 0).unwrap()
+    }
+
+    #[test]
+    fn bridge_spectrum_matches_analytic_and_interp_equals_jit() {
+        let (a, b, k) = (0.5, -2.0, 2);
+        let z0 = vec![1.0, 1.0, 1.0, 0.0, 0.0, 1.0];
+        let run = |jit| {
+            lyapunov_spectrum_ode_bridge(
+                linear_extended(a, b, k),
+                &[],
+                "rk45",
+                1e-9,
+                1e-11,
+                2,
+                k,
+                &z0,
+                0.0,
+                0.1,
+                5.0,
+                50.0,
+                jit,
+            )
+            .unwrap()
+        };
+        let interp = run(false);
+        let jit = run(true);
+        // interp == jit bit-for-bit (both drive the same &dyn Evaluator).
+        assert_eq!(interp.spectrum.len(), jit.spectrum.len());
+        for (i, (x, y)) in interp.spectrum.iter().zip(jit.spectrum.iter()).enumerate() {
+            assert_eq!(
+                x.to_bits(),
+                y.to_bits(),
+                "exponent {i}: jit {y} != interp {x}"
+            );
+        }
+        // and matches the analytic spectrum.
+        assert!((interp.spectrum[0] - 0.5).abs() < 1e-4);
+        assert!((interp.spectrum[1] - (-2.0)).abs() < 1e-4);
+    }
+
+    #[test]
+    fn bridge_rejects_unknown_method() {
+        let z0 = vec![1.0, 1.0, 1.0, 0.0, 0.0, 1.0];
+        let err = lyapunov_spectrum_ode_bridge(
+            linear_extended(0.5, -2.0, 2),
+            &[],
+            "no-such",
+            1e-6,
+            1e-9,
+            2,
+            2,
+            &z0,
+            0.0,
+            0.1,
+            1.0,
+            1.0,
+            false,
+        )
+        .unwrap_err();
+        assert!(matches!(err, EngineError::UnknownMethod(_)), "got {err:?}");
+    }
+}

{tsdynamics-5.2.4 → tsdynamics-5.2.6}/crates/tsdyn-core/src/bridge/map.rs

@@ -5,7 +5,10 @@
 //! iteration loop, shape contract and divergence behaviour are unchanged. Shared
 //! plumbing lives in [`super::marshal`].
 
-use tsdyn_engine::{iterate_dense, iterate_ensemble_final as engine_iterate_ensemble};
+use tsdyn_engine::{
+    iterate_dense, iterate_ensemble_final as engine_iterate_ensemble, map_orbit_sweep, SweepError,
+    SweepOutcome,
+};
 use tsdyn_ir::Tape;
 
 use super::marshal::{build_evaluator, map_diverge_msg, EngineError};
@@ -126,3 +129,88 @@ pub fn map_ensemble_final(
     let result = engine_iterate_ensemble(&*ev, ics, &[], steps);
     Ok(result.states)
 }
+
+/// Map a [`SweepError`] (a kernel-side shape failure) to the bridge's
+/// [`EngineError`] so the binding routes it to the same Python `ValueError` the
+/// other entry points use.
+fn sweep_to_engine_err(e: SweepError) -> EngineError {
+    match e {
+        SweepError::BadShape(m) => EngineError::BadShape(m),
+    }
+}
+
+/// Run the whole map orbit-diagram parameter sweep in one call (stream
+/// `perf/param-sweep-kernel`).
+///
+/// Unlike [`iterate_map`], the tape here keeps the **swept** parameter as its
+/// single runtime `Param` input (`n_param == 1`) — the Python wiring lowers the
+/// map once with the other parameters folded in, so a 1000-value sweep is one FFI
+/// call instead of ~1000 `iterate_map` round-trips. For each value the kernel sets
+/// `p[sweep_index] = value`, runs `transient + n` iterations (carrying the final
+/// state across values when `carry_state`), and records the last `n` asymptotic
+/// states' selected `components`.
+///
+/// Returns `(points, status)`: `points` is the flat row-major
+/// `(n_values * n, n_components)` recorded buffer, and `status[k]` is `0` for a
+/// value that ran finitely / `1` for a value that diverged (whose block is zero —
+/// the binding drops it to an empty set and warns, mirroring the per-value path).
+/// The per-iterate numerics are byte-for-byte the [`iterate_map`] path (a `Param`
+/// leaf reads the same `f64` a folded `Const` would).
+///
+/// `jit` selects the evaluator (Cranelift native code vs the interpreter); both
+/// are bit-for-bit identical on `eval`, so the swept diagram is numerically
+/// identical either way.
+#[allow(clippy::too_many_arguments)]
+pub fn map_param_sweep(
+    tape: Tape,
+    base_params: &[f64],
+    sweep_index: usize,
+    values: &[f64],
+    ic: &[f64],
+    components: &[usize],
+    transient: usize,
+    n_record: usize,
+    carry_state: bool,
+    jit: bool,
+) -> Result<(Vec<f64>, Vec<i64>), EngineError> {
+    // The sweep tape's next-state dimension equals its state dimension, and it
+    // carries exactly the swept parameter as a runtime input. Reject a tape whose
+    // shape disagrees (reachable only via a hand-built tape) so a mismatch is a
+    // clean error rather than a release-mode out-of-bounds inside the eval loop.
+    let dim = tape.dim();
+    if tape.n_state() != dim {
+        return Err(EngineError::BadShape(format!(
+            "map sweep expects n_state == dim (state and next-state share a \
+             dimension); got n_state = {} != dim = {dim}",
+            tape.n_state()
+        )));
+    }
+    if tape.n_param() != base_params.len() {
+        return Err(EngineError::BadShape(format!(
+            "map sweep base-parameter vector has length {}, but the tape declares \
+             n_param = {}",
+            base_params.len(),
+            tape.n_param()
+        )));
+    }
+    let ev = build_evaluator(tape, jit)?;
+    let SweepOutcome { points, status, .. } = map_orbit_sweep(
+        &*ev,
+        base_params,
+        sweep_index,
+        values,
+        ic,
+        components,
+        transient,
+        n_record,
+        carry_state,
+    )
+    .map_err(sweep_to_engine_err)?;
+    // Flatten the per-value fate to a plain i64 code (0 = ok, 1 = diverged) the
+    // FFI returns alongside the points buffer.
+    let status: Vec<i64> = status
+        .into_iter()
+        .map(|s| if s.is_ok() { 0 } else { 1 })
+        .collect();
+    Ok((points, status))
+}