tsdynamics 6.0.2__tar.gz → 6.0.4__tar.gz

{tsdynamics-6.0.2 → tsdynamics-6.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tsdynamics
-Version: 6.0.2
+Version: 6.0.4
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: Operating System :: OS Independent

{tsdynamics-6.0.2 → tsdynamics-6.0.4}/crates/tsdyn-core/src/bridge/lyapunov.rs

@@ -12,7 +12,7 @@
 //! [`super::marshal`]; the renormalisation loop and the QR live in
 //! [`tsdyn_engine::lyapunov`].
 
-use tsdyn_engine::lyapunov::{lyapunov_spectrum_ode, LyapunovError, LyapunovOutcome};
+use tsdyn_engine::lyapunov::{lyapunov_spectrum_ode_guarded, LyapunovError, LyapunovOutcome};
 use tsdyn_ir::Tape;
 use tsdyn_solvers::Solver;
 
@@ -59,6 +59,7 @@ pub fn lyapunov_spectrum_ode_bridge(
     burn_in: f64,
     final_time: f64,
     jit: bool,
+    escape_limit: f64,
 ) -> 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
@@ -71,8 +72,20 @@ pub fn lyapunov_spectrum_ode_bridge(
     // march); the name is a registry name and the tolerances are validated, so
     // `build_solver` always succeeds.
     let factory = move || -> Box<dyn Solver> { build_solver(name, tol) };
-    lyapunov_spectrum_ode(&*ev, factory, p, dim, k, z0, t0, dt, burn_in, final_time)
-        .map_err(to_engine_err)
+    lyapunov_spectrum_ode_guarded(
+        &*ev,
+        factory,
+        p,
+        dim,
+        k,
+        z0,
+        t0,
+        dt,
+        burn_in,
+        final_time,
+        escape_limit,
+    )
+    .map_err(to_engine_err)
 }
 
 #[cfg(test)]
@@ -124,6 +137,7 @@ mod tests {
                 5.0,
                 50.0,
                 jit,
+                f64::INFINITY,
             )
             .unwrap()
         };
@@ -160,6 +174,7 @@ mod tests {
             1.0,
             1.0,
             false,
+            f64::INFINITY,
         )
         .unwrap_err();
         assert!(matches!(err, EngineError::UnknownMethod(_)), "got {err:?}");
@@ -186,6 +201,7 @@ mod tests {
                 1.0,
                 1.0,
                 false,
+                f64::INFINITY,
             )
             .unwrap_err();
             assert!(

{tsdynamics-6.0.2 → tsdynamics-6.0.4}/crates/tsdyn-core/src/bridge/map_lyapunov.rs

@@ -37,10 +37,10 @@ fn to_engine_err(e: MapLyapunovError) -> EngineError {
 /// Run the discrete-map QR tangent-map Lyapunov spectrum over a **map** tape.
 ///
 /// Builds the evaluator over `tape` (which must carry its step Jacobian), seeds the
-/// deviation frame to the leading `k` identity columns, iterates `steps` map steps
+/// deviation frame to a deterministic mixed orthonormal frame, iterates `steps` map steps
 /// propagating the frame through `J(x_n)` (pre-image convention) with a QR
 /// reorthonormalisation every `reortho_interval` steps, and returns the `k`
-/// time-averaged exponents (largest first) plus the completed-interval count. The
+/// time-averaged exponents in QR order plus the completed-interval count. The
 /// map tape folds its parameters in, so `p` is empty. `jit` selects the Cranelift
 /// evaluator (numerically identical to the interpreter).
 #[allow(clippy::too_many_arguments)]

{tsdynamics-6.0.2 → tsdynamics-6.0.4}/crates/tsdyn-core/src/bridge/marshal.rs

@@ -544,6 +544,12 @@ pub(super) fn validate_grid(t_eval: &[f64]) -> Result<(), EngineError> {
                 w[0]
             )));
         }
+        if !(w[1] - w[0]).is_finite() {
+            return Err(EngineError::InvalidParameter(format!(
+                "t_eval gap {i} is not finite: {} - {} exceeds float64 range",
+                w[1], w[0]
+            )));
+        }
     }
     Ok(())
 }

{tsdynamics-6.0.2 → tsdynamics-6.0.4}/crates/tsdyn-core/src/bridge/mod.rs

@@ -730,6 +730,23 @@ mod tests {
         );
     }
 
+    #[test]
+    fn integrate_dense_rejects_overflowing_finite_grid_gap() {
+        let err = integrate_dense(
+            decay_tape(),
+            &[1.0],
+            &[2.0],
+            &[-f64::MAX, f64::MAX],
+            "rk45",
+            1e-6,
+            1e-9,
+            false,
+        )
+        .unwrap_err();
+        assert!(matches!(err, EngineError::InvalidParameter(_)), "{err:?}");
+        assert!(err.to_string().contains("gap"));
+    }
+
     #[test]
     fn ensemble_rejects_non_finite_times() {
         let err = ensemble_final(

{tsdynamics-6.0.2 → tsdynamics-6.0.4}/crates/tsdyn-core/src/lib.rs

@@ -1245,7 +1245,7 @@ use bridge::lyapunov_spectrum_ode_bridge;
 /// window. Returns `(spectrum, final_state, last_growths)` — the `k` exponents,
 /// the final extended state, and the last per-step log-stretch contributions. A
 /// divergence raises (it must not become a plausible-looking spectrum).
-#[pyfunction]
+#[pyfunction(signature = (ops, a, b, imm, outputs, jac_outputs, n_state, n_param, p, method, rtol, atol, dim, k, z0, t0, dt, burn_in, final_time, jit, escape_limit=None))]
 #[allow(clippy::too_many_arguments, clippy::type_complexity)]
 fn lyapunov_spectrum_ode<'py>(
     py: Python<'py>,
@@ -1269,6 +1269,7 @@ fn lyapunov_spectrum_ode<'py>(
     burn_in: f64,
     final_time: f64,
     jit: bool,
+    escape_limit: Option<f64>,
 ) -> PyResult<(
     Bound<'py, PyArray1<f64>>,
     Bound<'py, PyArray1<f64>>,
@@ -1292,6 +1293,7 @@ fn lyapunov_spectrum_ode<'py>(
             burn_in,
             final_time,
             jit,
+            escape_limit.unwrap_or(f64::INFINITY),
         )
     })
     .map_err(to_py_err)?;

{tsdynamics-6.0.2 → tsdynamics-6.0.4}/crates/tsdyn-engine/src/lib.rs

@@ -62,6 +62,8 @@ pub mod alloc;
 pub mod interrupt;
 pub mod pool;
 
+mod tangent_frame;
+
 #[cfg(test)]
 mod testkit;
 

{tsdynamics-6.0.2 → tsdynamics-6.0.4}/crates/tsdyn-engine/src/lyapunov.rs

@@ -188,7 +188,7 @@ pub struct LyapunovOutcome {
 /// - `dim` — the **base** system dimension.
 /// - `k` — the number of tangent vectors (`1 ≤ k ≤ dim`).
 /// - `z0` — the initial extended state (length `dim*(k+1)`): base IC ⊕ the seed
-///   tangent frame (`I[:, :k]` column-major), exactly the Python `embed_extended`.
+///   tangent frame (column-major), exactly the Python `embed_extended`.
 /// - `t0` — the start time.
 /// - `dt` — the renormalisation interval (the Python `dt`).
 /// - `burn_in` — discard this much time before accumulating (`max(0, burn_in)`).
@@ -213,6 +213,44 @@ pub fn lyapunov_spectrum_ode<F>(
     burn_in: f64,
     final_time: f64,
 ) -> Result<LyapunovOutcome, LyapunovError>
+where
+    F: Fn() -> Box<dyn Solver>,
+{
+    lyapunov_spectrum_ode_guarded(
+        ev,
+        solver_factory,
+        p,
+        dim,
+        k,
+        z0,
+        t0,
+        dt,
+        burn_in,
+        final_time,
+        f64::INFINITY,
+    )
+}
+
+/// The Benettin loop with a caller-supplied base-orbit escape limit.
+///
+/// Only the first `dim` state components are checked: a growing tangent vector
+/// is not an escaping base orbit. Python derives this limit from its shared
+/// scale-and-growth policy; the unguarded Rust entry point remains available
+/// for callers measuring non-attractor finite-time growth.
+#[allow(clippy::too_many_arguments)]
+pub fn lyapunov_spectrum_ode_guarded<F>(
+    ev: &dyn Evaluator,
+    solver_factory: F,
+    p: &[f64],
+    dim: usize,
+    k: usize,
+    z0: &[f64],
+    t0: f64,
+    dt: f64,
+    burn_in: f64,
+    final_time: f64,
+    escape_limit: f64,
+) -> Result<LyapunovOutcome, LyapunovError>
 where
     F: Fn() -> Box<dyn Solver>,
 {
@@ -257,6 +295,11 @@ where
             "final_time must be finite and positive, got {final_time}"
         )));
     }
+    if escape_limit.is_nan() || escape_limit <= 0.0 {
+        return Err(LyapunovError::BadShape(
+            "escape_limit must be positive (or infinite)".to_string(),
+        ));
+    }
 
     let mut z = z0.to_vec();
     let mut t = t0;
@@ -277,6 +320,7 @@ where
     while t < t_burn - EPS {
         let h = dt.min(t_burn - t);
         advance_chunk(ev, &solver_factory, &mut z, t, h, p, &mut poll).map_err(classify)?;
+        check_base_orbit(&z[..dim], t + h, escape_limit)?;
         if !renorm_step(&mut z, dim, k, &mut last_growths)? {
             return Err(LyapunovError::Diverged(
                 "extended variational state went non-finite during burn-in".to_string(),
@@ -291,6 +335,7 @@ where
     while t < t_end - EPS {
         let h = dt.min(t_end - t);
         advance_chunk(ev, &solver_factory, &mut z, t, h, p, &mut poll).map_err(classify)?;
+        check_base_orbit(&z[..dim], t + h, escape_limit)?;
         if !renorm_step(&mut z, dim, k, &mut last_growths)? {
             return Err(LyapunovError::Diverged(
                 "extended variational state went non-finite during the averaging window"
@@ -317,6 +362,20 @@ where
     })
 }
 
+fn check_base_orbit(state: &[f64], t: f64, limit: f64) -> Result<(), LyapunovError> {
+    let peak = state
+        .iter()
+        .fold(0.0_f64, |peak, value| peak.max(value.abs()));
+    if peak >= limit {
+        return Err(LyapunovError::Diverged(format!(
+            "Lyapunov base orbit escaped at t={t:.6}: state magnitude {peak:.6e} \
+             reached the scale-and-growth limit {limit:.6e}. Use an initial condition \
+             on a bounded orbit before estimating attractor exponents."
+        )));
+    }
+    Ok(())
+}
+
 /// Unpack the tangent block of the extended state `z`, QR-reorthonormalise it in
 /// place, and re-embed the orthonormal frame — the per-chunk renormalisation.
 ///
@@ -460,6 +519,62 @@ mod tests {
         assert!((out.spectrum[0] - 0.5).abs() < 1e-4, "{}", out.spectrum[0]);
     }
 
+    #[test]
+    fn guarded_spectrum_refuses_base_escape_but_not_growing_tangents() {
+        let ev = VmEval::new(linear_extended(200.0, -2.0, 1));
+        let bounded = lyapunov_spectrum_ode_guarded(
+            &ev,
+            rk45_factory,
+            &[],
+            2,
+            1,
+            &[0.0, 0.0, 1.0, 0.0],
+            0.0,
+            0.1,
+            0.0,
+            0.2,
+            10.0,
+        )
+        .unwrap();
+        assert!((bounded.spectrum[0] - 200.0).abs() < 1e-4);
+        let err = lyapunov_spectrum_ode_guarded(
+            &ev,
+            rk45_factory,
+            &[],
+            2,
+            1,
+            &[1.0, 0.0, 1.0, 0.0],
+            0.0,
+            0.1,
+            0.0,
+            0.2,
+            10.0,
+        )
+        .unwrap_err();
+        assert!(matches!(err, LyapunovError::Diverged(_)));
+        assert!(err.to_string().contains("base orbit escaped at t="));
+    }
+
+    #[test]
+    fn guarded_spectrum_accepts_large_units_with_a_relative_limit() {
+        let ev = VmEval::new(linear_extended(0.0, 0.0, 1));
+        let out = lyapunov_spectrum_ode_guarded(
+            &ev,
+            rk45_factory,
+            &[],
+            2,
+            1,
+            &[1e12, -1e12, 1.0, 0.0],
+            0.0,
+            0.1,
+            0.0,
+            1.0,
+            1e15,
+        )
+        .unwrap();
+        assert_eq!(out.spectrum, vec![0.0]);
+    }
+
     #[test]
     fn rejects_bad_k_and_shapes() {
         let ev = VmEval::new(linear_extended(0.5, -2.0, 2));

{tsdynamics-6.0.2 → tsdynamics-6.0.4}/crates/tsdyn-engine/src/map_lyapunov.rs

@@ -92,7 +92,7 @@ impl std::error::Error for MapLyapunovError {}
 /// The accumulated spectrum a [`map_lyapunov`] run returns.
 #[derive(Clone, Debug, PartialEq)]
 pub struct MapLyapunovOutcome {
-    /// The `k` Lyapunov exponents, largest first (QR order) — the time-averaged
+    /// The `k` Lyapunov estimates in QR order — the time-averaged
     /// `log|R_ii|`.
     pub exponents: Vec<f64>,
     /// The number of reorthonormalisation intervals completed (the `_elapsed` the
@@ -215,12 +215,9 @@ pub fn map_lyapunov(
     // Live state and the next-state buffer (a map's RHS writes the next state).
     let mut x = ic[..dim].to_vec();
     let mut x_next = vec![0.0; dim];
-    // The deviation frame, column-major dim × k, seeded to the leading k columns of
-    // the identity (matching the released `np.eye(dim)[:, :k]`).
-    let mut w = vec![0.0; dim * k];
-    for j in 0..k {
-        w[j * dim + j] = 1.0;
-    }
+    // A mixed frame avoids getting stuck in a coordinate-aligned contracting
+    // subspace. The Python reference uses the identical fixed stream and QR.
+    let mut w = crate::tangent_frame::initial_frame(dim, k);
     // The propagated frame W' = J · W (column-major dim × k), a scratch buffer.
     let mut w_prop = vec![0.0; dim * k];
     let mut jac = vec![0.0; dim * dim];

tsdynamics-6.0.4/crates/tsdyn-engine/src/tangent_frame.rs

@@ -0,0 +1,82 @@
+//! Deterministic, mixed initial tangent frames (mirrored in Python tangent.py).
+
+use crate::rng::SplitMix64;
+
+/// Column-major orthonormal frame with no privileged coordinate direction.
+///
+/// Identity columns can remain forever inside a contracting invariant subspace,
+/// missing a maximal exponent in another component. A fixed, local SplitMix64
+/// stream supplies a generic dense frame without changing global RNG state or
+/// introducing run-to-run variation. Two-pass modified Gram--Schmidt controls
+/// orthogonality even when many directions are requested.
+pub(crate) fn initial_frame(dim: usize, k: usize) -> Vec<f64> {
+    let mut rng = SplitMix64::new(0x5441_4e47_454e_5453);
+    let mut w = vec![0.0; dim * k];
+    for j in 0..k {
+        for d in 0..dim {
+            w[j * dim + d] = 2.0 * rng.next_f64() - 1.0;
+        }
+        let mut norm = orthogonalise(&mut w, dim, j);
+        if norm <= f64::EPSILON {
+            // A numerically dependent draw: choose the coordinate least covered
+            // by the existing columns, then project it into their complement.
+            let mut best = 0;
+            let mut least = f64::INFINITY;
+            for d in 0..dim {
+                let used: f64 = (0..j).map(|i| w[i * dim + d].powi(2)).sum();
+                if used < least {
+                    least = used;
+                    best = d;
+                }
+            }
+            w[j * dim..(j + 1) * dim].fill(0.0);
+            w[j * dim + best] = 1.0;
+            norm = orthogonalise(&mut w, dim, j);
+        }
+        for d in 0..dim {
+            w[j * dim + d] /= norm;
+        }
+    }
+    w
+}
+
+fn orthogonalise(w: &mut [f64], dim: usize, j: usize) -> f64 {
+    for _ in 0..2 {
+        for i in 0..j {
+            let mut dot = 0.0;
+            for d in 0..dim {
+                dot += w[i * dim + d] * w[j * dim + d];
+            }
+            for d in 0..dim {
+                w[j * dim + d] -= dot * w[i * dim + d];
+            }
+        }
+    }
+    let mut norm2 = 0.0;
+    for d in 0..dim {
+        norm2 += w[j * dim + d] * w[j * dim + d];
+    }
+    norm2.sqrt()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn mixed_frame_is_reproducible_and_orthonormal() {
+        for dim in [1, 2, 3, 10, 64] {
+            let w = initial_frame(dim, dim);
+            assert_eq!(w, initial_frame(dim, dim));
+            assert_eq!(&w[..dim], initial_frame(dim, 1).as_slice());
+            for i in 0..dim {
+                for j in 0..dim {
+                    let dot: f64 = (0..dim).map(|d| w[i * dim + d] * w[j * dim + d]).sum();
+                    let expected = if i == j { 1.0 } else { 0.0 };
+                    assert!((dot - expected).abs() < 1e-13);
+                }
+            }
+            assert!(w[..dim].iter().all(|value| *value != 0.0));
+        }
+    }
+}

{tsdynamics-6.0.2 → tsdynamics-6.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "tsdynamics"
-version = "6.0.2"
+version = "6.0.4"
 description = "Rust-backed ODE/DDE/SDE integration, discrete maps, and chaos analysis for dynamical systems."
 readme = "README.md"
 requires-python = ">=3.12,<4.0"

{tsdynamics-6.0.2 → tsdynamics-6.0.4}/src/tsdynamics/__init__.py

@@ -190,7 +190,7 @@ from .families import (
 )
 
 # Single source of truth for the package version; rewritten by python-semantic-release.
-__version__ = "6.0.2"
+__version__ = "6.0.4"
 
 #: The curated top level.  **Sorted, one name per line** — the same mechanical
 #: policy every public package in this library follows, because a list grouped by

{tsdynamics-6.0.2 → tsdynamics-6.0.4}/src/tsdynamics/_engine/run.py

@@ -1182,6 +1182,7 @@ def lyapunov_spectrum_ode(
     rtol: float,
     atol: float,
     jit: bool,
+    escape_limit: float = float("inf"),
 ) -> dict[str, Any]:
     """Run the whole ODE Benettin Lyapunov-spectrum loop in the Rust engine.
 
@@ -1226,6 +1227,9 @@ def lyapunov_spectrum_ode(
         Adaptive-kernel tolerances.
     jit : bool
         Select the Cranelift evaluator.
+    escape_limit : float, optional
+        Upper bound on base-state magnitude, derived by the caller from its
+        scale-and-growth escape policy. Tangent components are not checked.
 
     Returns
     -------
@@ -1256,6 +1260,7 @@ def lyapunov_spectrum_ode(
         float(burn_in),
         float(final_time),
         bool(jit),
+        float(escape_limit),
     )
     return {
         "spectrum": np.asarray(spectrum, dtype=np.float64),

{tsdynamics-6.0.2 → tsdynamics-6.0.4}/src/tsdynamics/_engine/run_methods.py

@@ -142,7 +142,9 @@ def _resolve_method_and_prepare(
     ``rebuild_extra`` carries entry-point-specific build kwargs (``integrate``
     passes ``ic=``; ``ensemble`` seeds each trajectory later, so it passes none).
 
-    Returns the canonical method name and the (possibly rebuilt) problem.
+    Returns the implementation kernel name and the (possibly rebuilt) problem.
+    A plugin's selectable name can differ from its ``SolverSpec.kernel``;
+    the compiled engine dispatches the implementation, not that Python name.
     """
     from .run import _as_problem
 
@@ -157,7 +159,7 @@ def _resolve_method_and_prepare(
         problem = _as_problem(
             system_or_problem, with_jacobian=True, **rebuild_extra, **build_kwargs
         )
-    return resolution.name, problem
+    return resolution.kernel, problem
 
 
 def __dir__() -> list[str]:

{tsdynamics-6.0.2 → tsdynamics-6.0.4}/src/tsdynamics/_solvers/__init__.py

@@ -1,9 +1,9 @@
-"""The Python solver registry — the discovery half of the pluggable engine (D4).
+"""Solver metadata, capability checks, and installed solver discovery.
 
 .. note::
     **Advanced / internal.**  Reachable as :mod:`tsdynamics._solvers` to inspect or
     extend the available integrators, but most users only ever pass a solver by
-    name (``integrate(method="rk45")``) rather than importing this package.
+    name (``system.run(10.0, solver="rk45")``) rather than importing this package.
 
 This package is the Python-side mirror of the Rust link-time solver registry in
 the ``tsdyn-solvers`` crate.  It holds a ``name -> SolverSpec`` table of solver
@@ -16,12 +16,10 @@ auto-populates it from two sources at import time:
 2. **out-of-tree plugins** declared under the ``tsdynamics._solvers`` entry-point
    group (see :mod:`tsdynamics.plugins`).
 
-Stream **F2** owns this *mechanism* only.  It ships no built-in solvers — those
-arrive with the Rust kernels (streams E3/E4/E-SDE) and the selection layer
-(``method=`` resolution + auto-stiffness) is stream **C-SOLV**, which builds on
-top of this registry.  A :class:`SolverSpec` therefore carries no Python
-implementation; its :attr:`SolverSpec.kernel` names the Rust kernel to dispatch
-to once the engine bindings (stream E7) land.
+A :class:`SolverSpec` carries metadata rather than an implementation. Its
+:attr:`SolverSpec.kernel` names the executable kernel selected by the engine.
+An installed plugin may expose an existing kernel under a new name; adding an
+algorithm requires implementing and rebuilding the compiled engine as well.
 """
 
 from __future__ import annotations
@@ -44,7 +42,7 @@ _VALID_KINDS = frozenset({"explicit", "implicit"})
 class SolverCaps:
     """A solver's capabilities — the Python mirror of ``tsdyn_solvers::Caps``.
 
-    Drives ``method=`` resolution and the auto-stiffness layer (stream C-SOLV).
+    Drives solver resolution and the auto-stiffness layer.
     The four flags are how the selection layer reasons about a kernel without
     running it: ``kind`` is the auto-stiffness axis (:func:`~select.select`
     returns an ``"implicit"`` kernel only on a stiff RHS), ``needs_jacobian``

{tsdynamics-6.0.2 → tsdynamics-6.0.4}/src/tsdynamics/_solvers/select.py

@@ -187,7 +187,8 @@ class Resolution:
     Attributes
     ----------
     name : str
-        The canonical kernel name (the resolved ``method=`` the engine receives).
+        The registered solver name. Plugins can select an implementation with a
+        different name through :attr:`kernel`.
     spec : SolverSpec
         The registered spec for :attr:`name`.
     family : str or None

{tsdynamics-6.0.2 → tsdynamics-6.0.4}/src/tsdynamics/_utils/escape.py

@@ -111,17 +111,25 @@ def detect_unbounded(y: np.ndarray) -> Unbounded | None:
     )
 
 
-def escaped(peak: float | None) -> bool:
-    """Whether a recorded state magnitude is past :data:`ESCAPE_SCALE`.
+def escaped(peak: float | None, *, start: float | None = None) -> bool:
+    """Whether recorded orbit magnitudes satisfy the shared escape policy.
 
-    The one-number form, for a caller that holds only the landed state (a
-    Lyapunov estimator) rather than the whole orbit.  ``None`` — nothing was
-    recorded — is *not* an escape: a family that cannot answer says nothing.
+    With a recorded starting scale, both :data:`ESCAPE_SCALE` and
+    :data:`ESCAPE_GROWTH` must be reached. The legacy one-number form retains
+    its absolute-scale check when no starting scale was recorded. ``None`` for
+    the peak means there is no evidence of escape.
     """
     if peak is None:
         return False
     value = float(peak)
-    return not np.isfinite(value) or value >= ESCAPE_SCALE
+    if not np.isfinite(value):
+        return True
+    if start is None:
+        return value >= ESCAPE_SCALE
+    initial = float(start)
+    return not np.isfinite(initial) or (
+        value >= ESCAPE_SCALE and value / max(initial, 1.0) >= ESCAPE_GROWTH
+    )
 
 
 def __dir__() -> list[str]:

{tsdynamics-6.0.2 → tsdynamics-6.0.4}/src/tsdynamics/analysis/__init__.py

@@ -15,6 +15,7 @@ from __future__ import annotations
 from typing import Any as _Any
 
 from .. import registry as _registry
+from ..families import ContinuousSystem as _ContinuousSystem
 from ..plugins import ANALYSES_GROUP, register_entry_points
 from . import _discovery
 
@@ -145,7 +146,14 @@ globals()["basins"] = _basins_fn
 # picture) had no door at all.
 for _name, _subjects, _area, _keywords in PLANAR_ANALYSES:
     register(
-        getattr(planar, _name), subjects=_subjects, area=_area, keywords=_keywords, replace=True
+        getattr(planar, _name),
+        subjects=_subjects,
+        area=_area,
+        keywords=_keywords,
+        families=("ode",) if "flow" in _subjects else None,
+        system_types=(_ContinuousSystem,) if "flow" in _subjects else None,
+        min_dim=2 if "flow" in _subjects else None,
+        replace=True,
     )
 del _name, _subjects, _area, _keywords
 
@@ -215,6 +223,8 @@ def find(what: _Any = None, /) -> AnalysisList:
     ``what`` is a **string** (free-text search over the name, area, keywords and
     summary), or a **subject** — a system, a :class:`~tsdynamics.data.Trajectory`,
     an array, a result, or any of their classes — or omitted, for all of them.
+    System instances are filtered by the registered family, state dimension and
+    concrete autonomy restrictions. A class query cannot check parameter values.
     Returns a plain ``list`` of the analysis *functions*, whose repr is the
     grouped table.
 
@@ -224,7 +234,7 @@ def find(what: _Any = None, /) -> AnalysisList:
     >>> sorted(f.__name__ for f in ts.analysis.find("multistability"))[:3]
     ['attractors', 'basin_fractions', 'basins']
     >>> len(ts.analysis.find(ts.systems.Henon()))    # a map has no vector field
-    13
+    11
     >>> len(ts.analysis.find(ts.systems.Lorenz()))
     20
     """
@@ -246,7 +256,12 @@ def find(what: _Any = None, /) -> AnalysisList:
             f"    ts.analysis.find(traj)        # a subject\n"
             f"    ts.analysis.find()            # everything"
         )
-    hits = [e for e in entries if set(tokens) & set(e.metadata.get("subjects", ()))]
+    hits = [
+        e
+        for e in entries
+        if set(tokens) & set(e.metadata.get("subjects", ()))
+        and _discovery.supports_subject(e, what)
+    ]
     subject = what.__name__ if isinstance(what, type) else type(what).__name__
     return AnalysisList(hits, f"{len(hits)} analyses take a {subject}")