tsdynamics 3.1.2__tar.gz → 3.1.4__tar.gz

{tsdynamics-3.1.2 → tsdynamics-3.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tsdynamics
-Version: 3.1.2
+Version: 3.1.4
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: Operating System :: OS Independent
@@ -124,7 +124,7 @@ od = ts.orbit_diagram(ts.Logistic(), "r", np.linspace(2.5, 4.0, 600))
 x, y = od.flat()
 
 # Poincaré section of the Rössler attractor (root-refined crossings)
-section = ts.poincare_section(ts.Rossler(), plane=(1, 0.0), steps=500)
+section = ts.poincare_section(ts.Rossler(), plane=(1, 0.0), n=500)
 
 # Fixed points of the Hénon map, with stability
 ts.fixed_points(ts.Henon())

{tsdynamics-3.1.2 → tsdynamics-3.1.4}/README.md

@@ -93,7 +93,7 @@ od = ts.orbit_diagram(ts.Logistic(), "r", np.linspace(2.5, 4.0, 600))
 x, y = od.flat()
 
 # Poincaré section of the Rössler attractor (root-refined crossings)
-section = ts.poincare_section(ts.Rossler(), plane=(1, 0.0), steps=500)
+section = ts.poincare_section(ts.Rossler(), plane=(1, 0.0), n=500)
 
 # Fixed points of the Hénon map, with stability
 ts.fixed_points(ts.Henon())

{tsdynamics-3.1.2 → tsdynamics-3.1.4}/crates/tsdyn-engine/src/sde.rs

@@ -27,12 +27,15 @@
 //! # Fixed step, sub-stepping to the grid
 //!
 //! These schemes are fixed-step: the step size *is* `dt`, and `dt` sets the noise
-//! scale `√dt`. Output at a requested time that is not on the `dt` lattice is
-//! produced by a shorter final sub-step whose increment is drawn `~ N(0, h)` for
-//! that `h` — a valid Euler–Maruyama/Milstein step on a non-uniform partition
+//! scale `√dt`. Output at a requested time that is genuinely off the `dt` lattice
+//! is produced by a shorter final sub-step whose increment is drawn `~ N(0, h)`
+//! for that `h` — a valid Euler–Maruyama/Milstein step on a non-uniform partition
 //! (Brownian increments over sub-intervals are independent and sum correctly), so
-//! the discretization stays consistent. As with the ODE driver, a non-finite
-//! state is reported, never returned as plausible data ([`SdeError`]).
+//! the discretization stays consistent. A nominally `dt`-wide segment whose width
+//! only *appears* to exceed `dt` by floating-point roundoff is absorbed into one
+//! canonical `dt` step (a tolerant landing, [`LANDING_REL_TOL`]) rather than
+//! spawning a spurious sub-ULP sliver. As with the ODE driver, a non-finite state
+//! is reported, never returned as plausible data ([`SdeError`]).
 
 use rayon::prelude::*;
 use tsdyn_ir::Evaluator;
@@ -42,6 +45,20 @@ use tsdyn_solvers::{SolverState, StepOutcome};
 use crate::integrate::DEFAULT_MAX_STEPS;
 use crate::rng::{fill_wiener, seed_for, SplitMix64};
 
+/// Relative tolerance for the fixed-step *landing* decision (mirror of
+/// `_LANDING_REL_TOL` in `src/tsdynamics/families/stochastic.py` — keep the two
+/// in lock-step so the engine and the pure-Python reference draw their Wiener
+/// streams in identical order).
+///
+/// Output grids are uniform in `dt`, but floating-point roundoff makes a
+/// nominally `dt`-wide segment compute a `remaining = t_end - t` that is `dt`
+/// plus a few ULP. The naive `dt >= remaining` test then takes a full `dt` step
+/// and a **spurious sub-ULP sliver step** — drawing an extra Wiener increment
+/// (desyncing the noise stream) and adding a meaningless `N(0, ~ULP)` kick.
+/// Absorbing that roundoff into a single canonical `dt` step makes the
+/// discretisation exactly "one `N(0, dt)` increment per step".
+const LANDING_REL_TOL: f64 = 1e-9;
+
 /// Knobs for the fixed-step SDE loop.
 ///
 /// Build with [`SdeConfig::new`] (the step `dt` plus the default step cap) and
@@ -111,10 +128,13 @@ impl std::error::Error for SdeError {}
 /// Advance `st` from its current time to `t_end` with fixed step `cfg.dt`,
 /// drawing one diagonal Wiener increment per step from `rng` into `dw`.
 ///
-/// A landing step (when `dt` would reach/pass `t_end`) is shortened to the
-/// remaining span and its increment drawn `~ N(0, h)` for that `h`; the time is
-/// then pinned exactly to `t_end` so grid points never drift. `dw` is a caller-
-/// owned scratch of length `dim`, reused across steps.
+/// The landing (final) step of the span reuses the canonical `cfg.dt` when
+/// `remaining` is within [`LANDING_REL_TOL`] of it (so a uniform-`dt` grid takes
+/// exactly one `N(0, dt)` increment per segment and never a spurious sub-ULP
+/// sliver), and only a genuinely shorter span draws its increment `~ N(0, h)`
+/// for that smaller `h`; the time is then pinned exactly to `t_end` so grid
+/// points never drift. `dw` is a caller-owned scratch of length `dim`, reused
+/// across steps.
 #[allow(clippy::too_many_arguments)] // drift + diffusion + the state/rng/dw/time/cfg the loop threads.
 fn sde_advance_to(
     drift: &dyn Evaluator,
@@ -139,8 +159,21 @@ fn sde_advance_to(
             return Err(SdeError::StepLimit { t: st.t, steps });
         }
         let remaining = t_end - st.t;
-        let landing = cfg.dt >= remaining;
-        let h = if landing { remaining } else { cfg.dt };
+        // Tolerant landing: absorb a roundoff-scale overshoot so a uniform-dt grid
+        // takes exactly one canonical dt step per segment (no spurious sub-ULP
+        // sliver step). Only a genuinely shorter final span uses `remaining`. See
+        // LANDING_REL_TOL; the Python reference mirrors this predicate so the two
+        // draw their Wiener streams in identical order.
+        let landing = remaining <= cfg.dt * (1.0 + LANDING_REL_TOL);
+        let h = if landing {
+            if remaining >= cfg.dt * (1.0 - LANDING_REL_TOL) {
+                cfg.dt
+            } else {
+                remaining
+            }
+        } else {
+            cfg.dt
+        };
         steps += 1;
 
         fill_wiener(rng, h, dw);
@@ -900,6 +933,63 @@ mod tests {
         assert!(out.iter().all(|x| x.is_finite()));
     }
 
+    #[test]
+    fn tolerant_landing_kills_the_spurious_substep_on_a_roundoff_grid() {
+        // FIX-SDE-WIENER regression. A uniform grid t_eval[k] = k·dt built the way
+        // NumPy's arange does (k as f64 * dt) makes many segments compute a width a
+        // few ULP above dt. The old `dt >= remaining` landing then took a full dt
+        // step *plus a spurious sub-ULP sliver* — an extra Wiener draw that desynced
+        // the stream. With the tolerant landing the grid takes exactly one clean dt
+        // step per segment, so marching the grid and marching the whole span in one
+        // shot draw the identical N increments and reach the SAME final state
+        // bit-for-bit (GBM is autonomous, so the pinned-vs-accumulated time is moot).
+        let drift = gbm_drift(0.12);
+        let diffusion = gbm_diffusion(0.3);
+        let dt = 0.02;
+        let n = 50usize;
+        let cfg = SdeConfig::new(dt);
+        let t_eval: Vec<f64> = (0..=n).map(|k| k as f64 * dt).collect();
+        // At least one segment must actually overshoot dt, else the test is vacuous.
+        let overshoot = (1..=n).filter(|&k| t_eval[k] - t_eval[k - 1] > dt).count();
+        assert!(overshoot > 0, "grid did not provoke the roundoff overshoot");
+
+        let mut kernel_g = EulerMaruyama::new();
+        let mut rng_g = SplitMix64::new(20240614);
+        let grid = sde_integrate_grid(
+            &drift,
+            &diffusion,
+            &mut kernel_g,
+            &mut rng_g,
+            &[1.0],
+            &[],
+            &t_eval,
+            &cfg,
+        )
+        .unwrap();
+        let grid_final = grid[grid.len() - 1];
+
+        let mut kernel_f = EulerMaruyama::new();
+        let mut rng_f = SplitMix64::new(20240614);
+        let one_shot = sde_integrate_final(
+            &drift,
+            &diffusion,
+            &mut kernel_f,
+            &mut rng_f,
+            &[1.0],
+            &[],
+            0.0,
+            t_eval[n],
+            &cfg,
+        )
+        .unwrap();
+
+        assert_eq!(
+            grid_final.to_bits(),
+            one_shot[0].to_bits(),
+            "grid march != one-shot march — a spurious sliver desynced the noise stream"
+        );
+    }
+
     #[test]
     fn divergence_is_reported_not_silently_returned() {
         // f(x) = x², g = 0 ⇒ deterministic finite-time blow-up past t = 1 from

{tsdynamics-3.1.2 → tsdynamics-3.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "tsdynamics"
-version = "3.1.2"
+version = "3.1.4"
 description = "Zero-warmup Rust-engine ODE/DDE/SDE integration, discrete maps, and chaos analysis for dynamical systems."
 readme = "README.md"
 requires-python = ">=3.12,<4.0"
@@ -88,7 +88,6 @@ module-name = "tsdynamics._rust"
 python-source = "src"
 manifest-path = "crates/tsdyn-core/Cargo.toml"
 features = ["extension-module"]
-exclude = ["src/tsdynamics/_native/**"]
 
 # ── Release automation — python-semantic-release ───────────────────────────────
 # Version bumps are computed from conventional commit messages on main:
@@ -128,7 +127,7 @@ ignore = [
   "B008",    # do not perform function calls in default args
   # ── Math-notation conventions (intentional) ─────────────────────────────
   "N803",    # argument name should be lowercase — Y, N, L are standard math notation
-  "N805",    # first argument should be 'self' — false positive on @staticmethod/@staticjit
+  "N805",    # first argument should be 'self' — false positive on @staticmethod
   "N806",    # variable in function should be lowercase — X, Y, N, L are math convention
   # ── Module/package docstrings (optional for math-system collections) ────
   "D100",    # missing docstring in public module
@@ -179,9 +178,9 @@ ignore_missing_imports = true
 # catalogue only — `override` (system-specific signatures), `no-untyped-def` (the
 # math kernels themselves) and `no-untyped-call` (calls between those untyped
 # kernels and their nested helpers). Every other check (and the entire core
-# library) stays strict. `staticjit` is aliased to `staticmethod` for the type
-# checker (see `utils/general.py`), which clears the spurious self-binding errors
-# so this list need not grow.
+# library) stays strict. Map kernels are plain `@staticmethod`, so the type
+# checker reads their first parameter as state (not `self`) and this list need
+# not grow.
 [[tool.mypy.overrides]]
 module = ["tsdynamics.systems.*"]
 disable_error_code = ["override", "no-untyped-def", "no-untyped-call"]
@@ -203,9 +202,13 @@ markers   = [
   "slow: marks tests that run long simulations or compile the engine extension (deselect with: pytest -m 'not slow')",
   "full: exhaustive sweeps over every built-in system; deselected by default, run nightly (select with: pytest -m full)",
   "engine: requires the compiled tsdynamics._rust extension; auto-applied to modules that import it and selected by the engine CI job with -m engine (stream I-XVAL)",
+  "doctest: the executable-documentation gate — docstring doctests + doc-page python fences (stream DOCS-DOCTEST-GATE); curated-fast by default, broad sweep under -m full",
 ]
 filterwarnings = [
   "error",
   "ignore:.*License classifiers have been superseded.*:UserWarning",
   "ignore:.*divide by zero encountered in divide.*:RuntimeWarning",
+  # DiscreteMap.iterate warns when an off-basin random IC diverges and it retries
+  # — expected, benign resilience; do not let it trip the `error` filter.
+  "ignore:.*Retrying from a new random initial condition.*:RuntimeWarning",
 ]

{tsdynamics-3.1.2 → tsdynamics-3.1.4}/src/tsdynamics/__init__.py

@@ -21,8 +21,7 @@ so the top-level namespace stays focused on the base classes, the derived-system
 wrappers, the analysis functions, and the submodules.  For backwards
 compatibility ``tsdynamics.Lorenz`` (and ``from tsdynamics import Lorenz``) still
 resolve lazily.  See :mod:`tsdynamics.registry` for programmatic access.  Internal
-helpers (``ParamSet``, ``SystemBase``, ``staticjit``) live under
-``tsdynamics.families`` / ``tsdynamics.utils``.
+helpers (``ParamSet``, ``SystemBase``) live under ``tsdynamics.families``.
 
 Curated top level (stream WS-NAMESPACE)
 ---------------------------------------
@@ -105,15 +104,24 @@ from .analysis import (
 from .analysis import (
     FixedPoint as FixedPoint,
 )
+from .analysis import (
+    FixedPointSet as FixedPointSet,
+)
 from .analysis import (
     GALIResult as GALIResult,
 )
 from .analysis import (
     LyapunovFromData as LyapunovFromData,
 )
+from .analysis import (
+    LyapunovSpectrum as LyapunovSpectrum,
+)
 from .analysis import (
     OrbitDiagram as OrbitDiagram,
 )
+from .analysis import (
+    OrbitSet as OrbitSet,
+)
 from .analysis import (
     PeriodicOrbit as PeriodicOrbit,
 )
@@ -354,7 +362,7 @@ bifurcation_diagram = orbit_diagram  #: discoverable spelling of :func:`orbit_di
 basins = basins_of_attraction  #: short alias of :func:`basins_of_attraction`
 
 # Single source of truth for the package version; rewritten by python-semantic-release.
-__version__ = "3.1.2"
+__version__ = "3.1.4"
 
 # Built-in system classes are NOT bound into this namespace — that would bury the
 # submodules (``analysis``, ``data``, ``systems``, …) under ~149 model names in

tsdynamics-3.1.4/src/tsdynamics/analysis/_tangent.py

@@ -0,0 +1,155 @@
+r"""
+Shared tangent-dynamics primitives for the analysis subpackages.
+
+The fixed-point/periodic-orbit (**A-FP**) and chaos-indicator (**A-CHAOS**)
+streams each need the same self-contained tangent-dynamics building blocks: a
+``(step, jac)`` pair for a :class:`~tsdynamics.families.DiscreteMap` (compiled
+``_step`` / ``_jacobian``), a ``(rhs, jac)`` pair for a
+:class:`~tsdynamics.families.ContinuousSystem` (SymEngine-lambdified numeric RHS
+/ Jacobian), and the classic / augmented (state ⊕ fundamental matrix) RK4 steps.
+
+These were previously copy-pasted into both ``fixedpoints/_common.py`` and
+``chaos/_common.py`` (drifting independently); they live here once.  Each
+subpackage re-exports them under its existing names so callers are unchanged.
+All primitives stay engine-free (no tape lowering), so the detectors keep
+running in the fast tier.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, cast
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from tsdynamics.families import ContinuousSystem, DiscreteMap
+    from tsdynamics.families.base import ParamSet
+
+# ── state coercion ────────────────────────────────────────────────────────────
+
+
+def to_native(x: np.ndarray, dim: int) -> float | np.ndarray:
+    """Present the state to a compiled ``_step``/``_jacobian`` in its native form.
+
+    One-dimensional maps are written for a scalar argument (``x = X``);
+    higher-dimensional maps unpack an array (``x, y = X[0], X[1]``).
+    """
+    a = np.asarray(x, dtype=float).ravel()
+    return float(a[0]) if dim == 1 else a
+
+
+# ── tangent dynamics: maps ───────────────────────────────────────────────────
+
+
+def map_fns(
+    system: DiscreteMap,
+) -> tuple[Callable[[np.ndarray], np.ndarray], Callable[[np.ndarray], np.ndarray]]:
+    """Return ``(step, jac)`` callables for a discrete map.
+
+    ``step(x) -> ndarray (dim,)`` advances one iteration; ``jac(x) -> ndarray
+    (dim, dim)`` is the Jacobian at ``x``.  Both wrap the class's compiled
+    ``_step`` / ``_jacobian`` (the convention
+    :class:`~tsdynamics.derived.TangentSystem` uses).  A map without an analytic
+    ``_jacobian`` falls back to a forward finite difference of ``_step``.
+    """
+    cls = type(system)
+    dim = int(cast("int", system.dim))  # dim resolved at construction
+    # ``_step`` / ``_jacobian`` accept the native scalar-or-array form from
+    # ``to_native`` (1-D maps take a float); treat them as untyped callables.
+    step_raw: Callable[..., Any] = cls._step
+    jac_raw: Callable[..., Any] | None = getattr(cls, "_jacobian", None)
+    params = tuple(cast("ParamSet", system.params).as_tuple())
+
+    def step(x: np.ndarray) -> np.ndarray:
+        return np.asarray(step_raw(to_native(x, dim), *params), dtype=float).ravel()
+
+    if jac_raw is not None:
+
+        def jac(x: np.ndarray) -> np.ndarray:
+            j = np.asarray(jac_raw(to_native(x, dim), *params), dtype=float)
+            return np.atleast_2d(j).reshape(dim, dim)
+
+    else:
+
+        def jac(x: np.ndarray) -> np.ndarray:
+            return finite_diff_jac(step, x, dim)
+
+    return step, jac
+
+
+def finite_diff_jac(
+    step: Callable[[np.ndarray], np.ndarray], x: np.ndarray, dim: int, eps: float = 1e-7
+) -> np.ndarray:
+    """Forward finite-difference Jacobian of a map step (fallback only)."""
+    x = np.asarray(x, dtype=float).ravel()
+    base = step(x)
+    out = np.empty((dim, dim))
+    for j in range(dim):
+        xp = x.copy()
+        h = eps * (1.0 + abs(xp[j]))
+        xp[j] += h
+        out[:, j] = (step(xp) - base) / h
+    return out
+
+
+# ── tangent dynamics: flows ──────────────────────────────────────────────────
+
+
+def flow_fns(
+    system: ContinuousSystem,
+) -> tuple[Callable[..., np.ndarray], Callable[..., np.ndarray]]:
+    """Return ``(rhs, jac)`` for a flow: ``rhs(u, t)`` and ``jac(u, t)``.
+
+    Both come from the SymEngine-lambdified numeric forms
+    (:meth:`ContinuousSystem._rhs_numeric` / :meth:`ContinuousSystem.jacobian`),
+    so the shooting/monodromy/variational integrator is self-contained (no
+    engine tape lowering) and runs in the fast tier.  Parameters are captured at
+    call time.
+    """
+    rhs = system._rhs_numeric()
+
+    def jac(u: np.ndarray, t: float = 0.0) -> np.ndarray:
+        return np.asarray(system.jacobian(u, t), dtype=float)
+
+    return rhs, jac
+
+
+def rk4_state(rhs: Callable[..., np.ndarray], x: np.ndarray, t: float, h: float) -> np.ndarray:
+    """One classic RK4 step of ``dx/dt = rhs(x, t)`` (state only)."""
+    k1 = rhs(x, t)
+    k2 = rhs(x + 0.5 * h * k1, t + 0.5 * h)
+    k3 = rhs(x + 0.5 * h * k2, t + 0.5 * h)
+    k4 = rhs(x + h * k3, t + h)
+    return cast("np.ndarray", x + (h / 6.0) * (k1 + 2.0 * k2 + 2.0 * k3 + k4))
+
+
+def rk4_variational(
+    rhs: Callable[..., np.ndarray],
+    jac: Callable[..., np.ndarray],
+    x: np.ndarray,
+    m: np.ndarray,
+    t: float,
+    h: float,
+) -> tuple[np.ndarray, np.ndarray]:
+    r"""One RK4 step of the augmented system ``dx/dt = f``, ``dM/dt = J(x) M``.
+
+    ``M`` holds the tangent vectors as columns (shape ``(dim, ncol)``); started
+    at the identity it accumulates the monodromy matrix.  The same
+    fundamental-matrix flow drives the shooting monodromy, GALI and expansion
+    entropy.
+    """
+    k1x = rhs(x, t)
+    k1m = jac(x, t) @ m
+    x2, m2, t2 = x + 0.5 * h * k1x, m + 0.5 * h * k1m, t + 0.5 * h
+    k2x = rhs(x2, t2)
+    k2m = jac(x2, t2) @ m2
+    x3, m3 = x + 0.5 * h * k2x, m + 0.5 * h * k2m
+    k3x = rhs(x3, t2)
+    k3m = jac(x3, t2) @ m3
+    x4, m4, t4 = x + h * k3x, m + h * k3m, t + h
+    k4x = rhs(x4, t4)
+    k4m = jac(x4, t4) @ m4
+    x_new = x + (h / 6.0) * (k1x + 2.0 * k2x + 2.0 * k3x + k4x)
+    m_new = m + (h / 6.0) * (k1m + 2.0 * k2m + 2.0 * k3m + k4m)
+    return x_new, m_new

{tsdynamics-3.1.2 → tsdynamics-3.1.4}/src/tsdynamics/analysis/basins/_common.py

@@ -102,7 +102,9 @@ class _CellGrid:
 # ---------------------------------------------------------------------------
 
 
-def _recurrence_grid(region: Box | Ball | Grid, resolution: int | tuple[int, ...]) -> _CellGrid:
+def _recurrence_grid(
+    region: Box | Ball | Grid, resolution: int | tuple[int, ...] = 100
+) -> _CellGrid:
     """
     Build the recurrence :class:`_CellGrid` covering ``region``.
 
@@ -113,9 +115,9 @@ def _recurrence_grid(region: Box | Ball | Grid, resolution: int | tuple[int, ...
     Parameters
     ----------
     region : Box, Ball, or Grid
-    resolution : int or tuple of int
+    resolution : int or tuple of int, default 100
         Cells per axis for a Box/Ball region (ignored for a Grid, which carries
-        its own ``counts``).
+        its own ``counts`` — so the default is never consulted for a Grid).
     """
     if isinstance(region, Grid):
         return _CellGrid.from_grid(region)

{tsdynamics-3.1.2 → tsdynamics-3.1.4}/src/tsdynamics/analysis/basins/attractors.py

@@ -228,8 +228,9 @@ class _AttractorMapper:
         """Advance one step; ``None`` if the trajectory blew up (raised / non-finite)."""
         try:
             state = np.asarray(self.system.step(self._step_arg), dtype=float).reshape(-1)
-        except (RuntimeError, FloatingPointError, OverflowError, ArithmeticError):
+        except (RuntimeError, ArithmeticError):
             # maps raise on divergence; flows may overflow — both mean "gone".
+            # (ArithmeticError covers FloatingPointError and OverflowError.)
             return None
         return state if np.all(np.isfinite(state)) else None
 
@@ -445,8 +446,7 @@ def find_attractors(
     G. Datseris and A. Wagemakers, "Effortless estimation of basins of
     attraction", *Chaos* **32**, 023104 (2022).
     """
-    if getattr(system, "is_discrete", False) is False and _looks_unsupported(system):
-        raise TypeError("find_attractors supports maps and flows, not delay/stochastic systems.")
+    _reject_unsupported(system, "find_attractors")
 
     grid = _recurrence_grid(region, resolution)
     mapper = _AttractorMapper(system, grid, dt=dt, max_steps=max_steps, **fsm)
@@ -478,6 +478,18 @@ def _looks_unsupported(system: Any) -> bool:
     return hasattr(system, "_drift") or hasattr(system, "history") or hasattr(system, "_delays")
 
 
+def _reject_unsupported(system: Any, fn_name: str) -> None:
+    """Raise a uniform ``TypeError`` for delay / stochastic systems.
+
+    Shared by the basin entry points (``find_attractors``,
+    ``basins_of_attraction``, ``basin_fractions``, ``continuation``) so an
+    unsupported system fails early with one clear message instead of opaquely
+    inside the step loop.
+    """
+    if getattr(system, "is_discrete", False) is False and _looks_unsupported(system):
+        raise TypeError(f"{fn_name} supports maps and flows, not delay/stochastic systems.")
+
+
 def __dir__() -> list[str]:
     """Expose only the curated public API (``__all__``) to ``dir()`` / autocomplete."""
     return sorted(__all__)

{tsdynamics-3.1.2 → tsdynamics-3.1.4}/src/tsdynamics/analysis/basins/basins.py

@@ -31,7 +31,13 @@ import numpy as np
 from ...data import Ball, Box, Grid, grid_points, sampler
 from .._result import AnalysisResult
 from ._common import _apply_merge, _recurrence_grid
-from .attractors import DIVERGED, AttractorSet, _AttractorMapper, resolve_merge_tol
+from .attractors import (
+    DIVERGED,
+    AttractorSet,
+    _AttractorMapper,
+    _reject_unsupported,
+    resolve_merge_tol,
+)
 
 __all__ = [
     "BasinFractions",
@@ -265,8 +271,10 @@ def basins_of_attraction(
     G. Datseris and A. Wagemakers, "Effortless estimation of basins of
     attraction", *Chaos* **32**, 023104 (2022).
     """
+    _reject_unsupported(system, "basins_of_attraction")
     if recurrence is None:
-        cellgrid = _recurrence_grid(region, region.counts)
+        # region is a Grid → keeps its own counts (resolution arg is ignored).
+        cellgrid = _recurrence_grid(region)
     else:
         cellgrid = _recurrence_grid(recurrence, recurrence_resolution)
     mapper = _AttractorMapper(system, cellgrid, dt=dt, max_steps=max_steps, **fsm)
@@ -287,7 +295,7 @@ def basins_of_attraction(
         labels=labels,
         grid=region,
         attractors=attractors,
-        meta=AnalysisResult.build_meta(system, analysis="basins_of_attraction"),
+        meta=AnalysisResult.build_meta(system, analysis="basins_of_attraction", seed=seed),
     )
 
 
@@ -345,6 +353,7 @@ def basin_fractions(
     P. J. Menck, J. Heitzig, N. Marwan and J. Kurths, "How basin stability
     complements the linear-stability paradigm", *Nature Physics* **9**, 89 (2013).
     """
+    _reject_unsupported(system, "basin_fractions")
     cellgrid = _recurrence_grid(region, resolution)
     mapper = _AttractorMapper(system, cellgrid, dt=dt, max_steps=max_steps, **fsm)
     draw = sampler(region, seed=seed)

{tsdynamics-3.1.2 → tsdynamics-3.1.4}/src/tsdynamics/analysis/basins/continuation.py

@@ -22,7 +22,7 @@ import numpy as np
 
 from ...data import Ball, Box, Grid, set_distance
 from .._result import AnalysisResult, CollectionResult
-from .attractors import Attractor
+from .attractors import Attractor, _reject_unsupported
 from .basins import basin_fractions
 
 if TYPE_CHECKING:
@@ -145,6 +145,7 @@ def continuation(
     G. Datseris, K. L. Rossi and A. Wagemakers, "Framework for global stability
     analysis of dynamical systems", *Chaos* **33**, 073151 (2023).
     """
+    _reject_unsupported(system, "continuation")
     values = np.asarray(values, dtype=float)
     fractions: dict[int, list[float]] = {}
     per_value: list[dict[int, Attractor]] = []
@@ -247,9 +248,10 @@ def tipping_points(result: ContinuationResult, *, threshold: float = 0.0) -> Col
 
     Returns
     -------
-    list of dict
-        Each event is ``{"value", "attractor", "kind", "before", "after"}`` with
-        ``kind`` in ``{"appear", "disappear"}``, sorted by parameter value.
+    CollectionResult
+        Behaves as a ``list of dict``; each event is
+        ``{"value", "attractor", "kind", "before", "after"}`` with ``kind`` in
+        ``{"appear", "disappear"}``, sorted by parameter value.
     """
     events: list[dict[str, Any]] = []
     vals = result.values