pynamicalsys 1.3.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

pynamicalsys/core/continuous_dynamical_systems.py

@@ -16,18 +16,24 @@
 # along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 from numbers import Integral, Real
-from typing import Any, Callable, Dict, List, Optional, Sequence, Union
+from typing import Any, Callable, Dict, List, Optional, Sequence, Union, Tuple
+from IPython.display import Math
 
 import numpy as np
 from numpy.typing import NDArray
 
 from pynamicalsys.common.utils import householder_qr, qr
+
 from pynamicalsys.continuous_time.chaotic_indicators import (
     LDI,
     SALI,
     GALI,
     lyapunov_exponents,
+    maximum_lyapunov_exponent,
+    recurrence_time_entropy,
+    hurst_exponent_wrapped,
 )
+
 from pynamicalsys.continuous_time.models import (
     henon_heiles,
     henon_heiles_jacobian,
@@ -37,17 +43,30 @@ from pynamicalsys.continuous_time.models import (
     rossler_system_4D,
     rossler_system_4D_jacobian,
     rossler_system_jacobian,
+    duffing,
+    duffing_jacobian,
 )
+
 from pynamicalsys.continuous_time.numerical_integrators import (
     estimate_initial_step,
     rk4_step_wrapped,
     rk45_step_wrapped,
 )
+
 from pynamicalsys.continuous_time.trajectory_analysis import (
-    ensemble_trajectories,
     evolve_system,
+    generate_maxima_map,
     generate_trajectory,
+    ensemble_trajectories,
+    generate_poincare_section,
+    ensemble_poincare_section,
+    generate_stroboscopic_map,
+    ensemble_stroboscopic_map,
+    generate_maxima_map,
+    ensemble_maxima_map,
+    basin_of_attraction,
 )
+
 from pynamicalsys.continuous_time.validators import (
     validate_initial_conditions,
     validate_non_negative,
@@ -102,6 +121,15 @@ class ContinuousDynamicalSystem:
     __AVAILABLE_MODELS: Dict[str, Dict[str, Any]] = {
         "lorenz system": {
             "description": "3D Lorenz system",
+            "equation": Math(
+                r"""
+        \dot{x} = \sigma (y - x), \quad
+        \dot{y} = x (\rho - z) - y, \quad
+        \dot{z} = xy - \beta z
+        """
+            ),
+            "equation_readable": "x' = σ(y − x), y' = x(ρ − z) − y, z' = xy − βz",
+            "notes": "Classic Lorenz 1963 model of atmospheric convection. Exhibits chaotic dynamics for some parameter values.",
             "has_jacobian": True,
             "has_variational_equations": True,
             "equations_of_motion": lorenz_system,
@@ -111,7 +139,16 @@ class ContinuousDynamicalSystem:
             "parameters": ["sigma", "rho", "beta"],
         },
         "henon heiles": {
-            "description": "Two d.o.f. Hénon-Heiles system",
+            "description": "Two d.o.f. Hénon–Heiles system",
+            "equation": Math(
+                r"""
+        H = \frac{1}{2}(p_x^2 + p_y^2) + 
+            \frac{1}{2}(x^2 + y^2) + 
+            x^2 y - \frac{1}{3}y^3
+        """
+            ),
+            "equation_readable": "H = ½(pₓ² + pᵧ²) + ½(x² + y²) + x²y − y³/3",
+            "notes": "Hamiltonian system modeling stellar motion near a galactic center; classic example of a mixed chaotic/regular system.",
             "has_jacobian": True,
             "has_variational_equations": True,
             "equations_of_motion": henon_heiles,
@@ -122,6 +159,15 @@ class ContinuousDynamicalSystem:
         },
         "rossler system": {
             "description": "3D Rössler system",
+            "equation": Math(
+                r"""
+        \dot{x} = -y - z, \quad
+        \dot{y} = x + a y, \quad
+        \dot{z} = b + z(x - c)
+        """
+            ),
+            "equation_readable": "x' = −y − z, y' = x + a y, z' = b + z(x − c)",
+            "notes": "Continuous-time chaotic system proposed by Otto Rössler (1976).",
             "has_jacobian": True,
             "has_variational_equations": True,
             "equations_of_motion": rossler_system,
@@ -132,6 +178,16 @@ class ContinuousDynamicalSystem:
         },
         "4d rossler system": {
             "description": "4D Rössler system",
+            "equation": Math(
+                r"""
+        \dot{x} = -y - z, \quad
+        \dot{y} = x + a y + w, \quad
+        \dot{z} = b + z(x - c), \quad
+        \dot{w} = -d y
+        """
+            ),
+            "equation_readable": "x' = −y − z, y' = x + a y + w, z' = b + z(x − c), w' = −d y",
+            "notes": "A 4D generalization of the Rössler attractor with an added variable w.",
             "has_jacobian": True,
             "has_variational_equations": True,
             "equations_of_motion": rossler_system_4D,
@@ -140,6 +196,21 @@ class ContinuousDynamicalSystem:
             "number_of_parameters": 4,
             "parameters": ["a", "b", "c", "d"],
         },
+        "duffing": {
+            "description": "Duffing oscillator (nonlinear forced damped oscillator)",
+            "equation": Math(
+                r"\ddot{x} + \delta \dot{x} - \alpha x + \beta x^3 = \gamma \cos(\omega t)"
+            ),
+            "equation_readable": "x'' + δ x' − α x + β x³ = γ cos(ω t)",
+            "notes": "A nonlinear oscillator with a double-well potential, forced and damped; exhibits chaos under some parameters.",
+            "has_jacobian": True,
+            "has_variational_equations": True,
+            "equations_of_motion": duffing,
+            "jacobian": duffing_jacobian,
+            "dimension": 2,
+            "number_of_parameters": 5,
+            "parameters": ["delta", "alpha", "beta", "gamma", "omega"],
+        },
     }
 
     __AVAILABLE_INTEGRATORS: Dict[str, Dict[str, Any]] = {
@@ -325,7 +396,7 @@ class ContinuousDynamicalSystem:
 
     def evolve_system(
         self,
-        u: NDArray[np.float64],
+        u: Union[NDArray[np.float64], Sequence[float]],
         total_time: float,
         parameters: Union[None, Sequence[float], NDArray[np.float64]] = None,
     ) -> NDArray[np.float64]:
@@ -334,7 +405,7 @@ class ContinuousDynamicalSystem:
 
         Parameters
         ----------
-        u : NDArray[np.float64]
+        u : Union[NDArray[np.float64], Sequence[float]]
             Initial conditions of the system. Must match the system's dimension.
         total_time : float
             Total time over which to evolve the system.
@@ -392,7 +463,7 @@ class ContinuousDynamicalSystem:
 
     def trajectory(
         self,
-        u: NDArray[np.float64],
+        u: Union[NDArray[np.float64], Sequence[float]],
         total_time: float,
         parameters: Union[None, Sequence[float], NDArray[np.float64]] = None,
         transient_time: Optional[float] = None,
@@ -402,7 +473,7 @@ class ContinuousDynamicalSystem:
 
         Parameters
         ----------
-        u : NDArray[np.float64]
+        u : Union[NDArray[np.float64], Sequence[float]]
             Initial conditions of the system. Must match the system's dimension.
         total_time : float
             Total time over which to evolve the system (including transient).
@@ -432,7 +503,7 @@ class ContinuousDynamicalSystem:
         --------
         >>> from pynamicalsys import ContinuousDynamicalSystem as cds
         >>> ds = cds(model="lorenz system")
-        >>> u = [0.1, 0.1, 0.1]  # Initial condition
+        >>> u = [0.1, 0.1, 0.1]  # Initial condition
         >>> parameters = [10, 28, 8/3]
         >>> total_time = 700
         >>> transient_time = 500
@@ -480,9 +551,482 @@ class ContinuousDynamicalSystem:
                 integrator=self.__integrator_func,
             )
 
+    def poincare_section(
+        self,
+        u: Union[NDArray[np.float64], Sequence[float]],
+        num_intersections: int,
+        section_index: int,
+        section_value: float,
+        parameters: Union[None, Sequence[float], NDArray[np.float64]] = None,
+        transient_time: Optional[float] = None,
+        crossing: int = 1,
+    ) -> NDArray[np.float64]:
+        """
+        Compute the Poincaré section of the dynamical system for given initial conditions.
+
+        A Poincaré section records the points where a trajectory intersects a chosen hypersurface
+        in phase space (e.g. x = constant). This reduces a continuous flow to a lower-dimensional
+        map, making it easier to identify periodic orbits, quasi-periodic motion, or chaotic
+        structures.
+
+        Parameters
+        ----------
+        u : Union[NDArray[np.float64], Sequence[float]]
+            Initial conditions of the system. Must match the system's dimension.
+        num_intersections : int
+            Number of intersections to record in the Poincaré section.
+        section_index : int
+            Index of the coordinate to define the Poincaré section (0-based).
+        section_value : float
+            Value of the coordinate at which the section is defined.
+        parameters : Union[None, Sequence[float], NDArray[np.float64]], optional
+            Parameters of the system, by default None. Can be a scalar, a sequence of floats, or a numpy array.
+        transient_time : float, optional
+            Initial time to discard before recording the section.
+        crossing : int, default=1
+            Specifies the type of crossing to consider:
+            - 1 : positive crossing (from below to above section_value)
+            - -1 : negative crossing (from above to below section_value)
+            - 0 : all crossings
+
+        Returns
+        -------
+        result : NDArray[np.float64]
+            The Poincaré section points.
+
+            - For a single initial condition (u.ndim = 1), returns a 2D array of shape
+              (num_intersections, neq), where each row is a system state at a crossing.
+            - For multiple initial conditions (u.ndim = 2), returns a 3D array of shape
+              (num_ic, num_intersections, neq).
+
+        Raises
+        ------
+        ValueError
+            - If the initial condition dimension does not match the system dimension.
+            - If the number of parameters does not match the system.
+            - If section_index is larger than the system dimension.
+        TypeError
+            - If `section_value` is not a real number.
+            - If `num_intersections` or `transient_time` are not valid numbers.
+
+        Examples
+        --------
+        >>> from pynamicalsys import ContinuousDynamicalSystem as cds
+        >>> ds = cds(model="lorenz system")
+        >>> u = [0.1, 0.1, 0.1]  # Initial condition
+        >>> parameters = [10, 28, 8/3]
+        >>> num_intersections = 500
+        >>> section_index = 2
+        >>> section_value = 25.0
+        >>> ps = ds.poincare_section(u, num_intersections, section_index, section_value, parameters=parameters)
+        (500, 3)
+        >>> u = [[0.1, 0.1, 0.1],
+        ...      [0.2, 0.2, 0.2]]  # Two initial conditions
+        >>> ps_ensemble = ds.poincare_section(u, num_intersections, section_index, section_value, parameters=parameters)
+        (2, 500, 3)
+        """
+
+        u = validate_initial_conditions(u, self.__system_dimension)
+        u = u.copy()
+
+        parameters = validate_parameters(parameters, self.__number_of_parameters)
+
+        validate_non_negative(num_intersections, "num_intersections", Integral)
+
+        validate_non_negative(section_index, "section_index", Integral)
+        if section_index > self.__system_dimension:
+            raise ValueError("section_index must be smaller than the sustem_dimension")
+
+        if not isinstance(section_value, Real):
+            raise TypeError("section_value must be a valid real number")
+
+        if transient_time is not None:
+            validate_non_negative(transient_time, "transient_time", Real)
+
+        if not isinstance(crossing, Integral):
+            raise TypeError("crossing must be an integer number")
+        elif crossing not in [-1, 0, 1]:
+            raise ValueError(
+                "crossing must be -1 (downward crossings), 0 (all crossings), or 1 (upward crossing)"
+            )
+
+        time_step = self.__get_initial_time_step(u, parameters)
+
+        if u.ndim == 1:
+            return generate_poincare_section(
+                u,
+                parameters,
+                num_intersections,
+                self.__equations_of_motion,
+                transient_time,
+                time_step,
+                self.__atol,
+                self.__rtol,
+                self.__integrator_func,
+                section_index,
+                section_value,
+                crossing,
+            )
+        else:
+            return ensemble_poincare_section(
+                u,
+                parameters,
+                num_intersections,
+                self.__equations_of_motion,
+                transient_time,
+                time_step,
+                self.__atol,
+                self.__rtol,
+                self.__integrator_func,
+                section_index,
+                section_value,
+                crossing,
+            )
+
+    def stroboscopic_map(
+        self,
+        u: Union[NDArray[np.float64], Sequence[float]],
+        num_samples: int,
+        sampling_time: float,
+        parameters: Union[None, Sequence[float], NDArray[np.float64]] = None,
+        transient_time: Optional[float] = None,
+    ) -> NDArray[np.float64]:
+        """
+        Compute the stroboscopic map of the dynamical system for given initial conditions.
+
+        A stroboscopic map samples the state of a time-periodic or driven system at fixed time
+        intervals (typically one driving period). This converts the continuous-time dynamics
+        into a discrete-time sequence that highlights periodicity, phase locking, and
+        bifurcations.
+
+        Parameters
+        ----------
+        u : Union[NDArray[np.float64], Sequence[float]]
+            Initial conditions of the system. Must match the system's dimension.
+        num_samples : int
+            Number of samples to record in the stroboscopic map.
+        sampling_time : float
+            Time interval between consecutive samples.
+        parameters : Union[None, Sequence[float], NDArray[np.float64]], optional
+            Parameters of the system, by default None. Can be a scalar, a sequence of floats, or a numpy array.
+        transient_time : float, optional
+            Initial time to discard before recording the map.
+
+        Returns
+        -------
+        result : NDArray[np.float64]
+            The stroboscopic map points.
+
+            - For a single initial condition (u.ndim = 1), returns a 2D array of shape
+              (num_samples, neq + 1), where the first column is the time and the remaining
+              columns are the system coordinates at each sampled time.
+            - For multiple initial conditions (u.ndim = 2), returns a 3D array of shape
+              (num_ic, num_samples, neq + 1).
+
+        Raises
+        ------
+        ValueError
+            - If the initial condition dimension does not match the system dimension.
+            - If the number of parameters does not match the system.
+        TypeError
+            - If `num_samples` or `sampling_time` are not valid numbers.
+            - If `transient_time` is provided and is not a valid number.
+
+        Examples
+        --------
+        >>> from pynamicalsys import ContinuousDynamicalSystem as cds
+        >>> ds = cds(model="lorenz system")
+        >>> u = [0.1, 0.1, 0.1]  # Initial condition
+        >>> parameters = [10, 28, 8/3]
+        >>> num_samples = 500
+        >>> sampling_time = 0.1
+        >>> smap = ds.stroboscopic_map(u, num_samples, sampling_time, parameters=parameters)
+        (500, 4)
+        >>> u = [[0.1, 0.1, 0.1],
+        ...      [0.2, 0.2, 0.2]]  # Two initial conditions
+        >>> smap_ensemble = ds.stroboscopic_map(u, num_samples, sampling_time, parameters=parameters)
+        (2, 500, 4)
+        """
+
+        u = validate_initial_conditions(u, self.__system_dimension)
+        u = u.copy()
+
+        parameters = validate_parameters(parameters, self.__number_of_parameters)
+
+        validate_non_negative(num_samples, "num_samples", Integral)
+
+        validate_non_negative(sampling_time, "sampling_time", Real)
+
+        if transient_time is not None:
+            validate_non_negative(transient_time, "transient_time", Real)
+
+        time_step = self.__get_initial_time_step(u, parameters)
+
+        if u.ndim == 1:
+            return generate_stroboscopic_map(
+                u,
+                parameters,
+                num_samples,
+                sampling_time,
+                self.__equations_of_motion,
+                transient_time,
+                time_step,
+                self.__atol,
+                self.__rtol,
+                self.__integrator_func,
+            )
+        else:
+            return ensemble_stroboscopic_map(
+                u,
+                parameters,
+                num_samples,
+                sampling_time,
+                self.__equations_of_motion,
+                transient_time,
+                time_step,
+                self.__atol,
+                self.__rtol,
+                self.__integrator_func,
+            )
+
+    def maxima_map(
+        self,
+        u: Union[NDArray[np.float64], Sequence[float]],
+        num_points: int,
+        maxima_index: int,
+        parameters: Union[None, Sequence[float], NDArray[np.float64]] = None,
+        transient_time: Optional[float] = None,
+    ) -> NDArray[np.float64]:
+        """
+        Compute the maxima map of the dynamical system for given initial conditions.
+
+        A maxima map records the local maxima of a chosen system variable along the trajectory.
+        By plotting successive maxima, one obtains a discrete return map that reveals
+        oscillation amplitudes, period-doubling cascades, and other nonlinear behaviours.
+
+        Parameters
+        ----------
+        u : Union[NDArray[np.float64], Sequence[float]]
+            Initial conditions of the system. Must match the system's dimension.
+        num_points : int
+            Number of points to record in the maxima map.
+        maxima_index : int
+            Index of the variable whose maxima are to be recorded.
+        parameters : Union[None, Sequence[float], NDArray[np.float64]], optional
+            Parameters of the system, by default None. Can be a scalar, a sequence of floats, or a numpy array.
+        transient_time : float, optional
+            Initial time to discard before recording the map.
+
+        Returns
+        -------
+        result : NDArray[np.float64]
+            The maxima map points.
+
+            - For a single initial condition (u.ndim = 1), returns a 2D array of shape
+              (num_points, neq + 1), where the first column is the time and the remaining
+              columns are the system coordinates at each maxima point.
+            - For multiple initial conditions (u.ndim = 2), returns a 3D array of shape
+              (num_ic, num_points, neq + 1).
+
+        Raises
+        ------
+        ValueError
+            - If the initial condition dimension does not match the system dimension.
+            - If the number of parameters does not match the system.
+        TypeError
+            - If `num_points` or `maxima_index` are not valid numbers.
+            - If `transient_time` is provided and is not a valid number.
+
+        Examples
+        --------
+        >>> from pynamicalsys import ContinuousDynamicalSystem as cds
+        >>> ds = cds(model="lorenz system")
+        >>> u = [0.1, 0.1, 0.1]  # Initial condition
+        >>> parameters = [10, 28, 8/3]
+        >>> num_points = 500
+        >>> maxima_index = 0
+        >>> smap = ds.maxima_map(u, num_points, maxima_index, parameters=parameters)
+        >>> smap.shape
+        (500, 4)
+        >>> u = [[0.1, 0.1, 0.1],
+        ...      [0.2, 0.2, 0.2]]  # Two initial conditions
+        >>> smap_ensemble = ds.stroboscopic_map(u, num_samples, sampling_time, parameters=parameters)
+        >>> smap_ensemble.shape
+        (2, 500, 4)
+        """
+
+        u = validate_initial_conditions(u, self.__system_dimension)
+        u = u.copy()
+
+        parameters = validate_parameters(parameters, self.__number_of_parameters)
+
+        validate_non_negative(num_points, "num_samples", Integral)
+
+        validate_non_negative(maxima_index, "maxima_index", Integral)
+
+        if transient_time is not None:
+            validate_non_negative(transient_time, "transient_time", Real)
+
+        time_step = self.__get_initial_time_step(u, parameters)
+
+        if u.ndim == 1:
+            return generate_maxima_map(
+                u,
+                parameters,
+                num_points,
+                maxima_index,
+                self.__equations_of_motion,
+                transient_time,
+                time_step,
+                self.__atol,
+                self.__rtol,
+                self.__integrator_func,
+            )
+        else:
+            return ensemble_maxima_map(
+                u,
+                parameters,
+                num_points,
+                maxima_index,
+                self.__equations_of_motion,
+                transient_time,
+                time_step,
+                self.__atol,
+                self.__rtol,
+                self.__integrator_func,
+            )
+
+    def basin_of_attraction(
+        self,
+        u: Union[NDArray[np.float64], Sequence[float]],
+        num_intersections: int,
+        parameters: Union[None, Sequence[float], NDArray[np.float64]] = None,
+        transient_time: Optional[float] = None,
+        map_type: str = "SM",
+        section_index: Optional[int] = None,
+        section_value: Optional[float] = None,
+        crossing: Optional[int] = None,
+        sampling_time: Optional[float] = None,
+        eps: float = 0.05,
+        min_samples: int = 1,
+    ) -> NDArray[np.int32]:
+        """
+        Compute the basin of attraction for a dynamical system for a set of initial conditions.
+
+        Parameters
+        ----------
+        u : Union[NDArray[np.float64], Sequence[float]]
+            Initial conditions for the dynamical system.
+        num_intersections : int
+            Number of intersections (or samples) to use in constructing the map (stroboscopic or Poincaré).
+        parameters : Union[None, Sequence[float], NDArray[np.float64]], optional
+            System parameters. If None, defaults will be used. Default is None.
+        transient_time : float, optional
+            Transient time to discard before analyzing the trajectories. Default is None.
+        map_type : str, default "SM"
+            Type of map to compute:
+            - "SM" : stroboscopic map
+            - "PS" : Poincaré section
+        section_index : int, optional
+            Index of the coordinate used for the Poincaré section (required if map_type="PS").
+        section_value : float, optional
+            Value of the section plane (required if map_type="PS").
+        crossing : int, optional
+            Crossing direction for Poincaré section:
+            - -1 : downward crossings
+            - 0  : all crossings
+            - 1  : upward crossings
+            Required if map_type="PS".
+        sampling_time : float, optional
+            Sampling time for stroboscopic map (required if map_type="SM").
+        eps : float, default 0.05
+            The maximum distance between points to be considered in the same cluster (DBSCAN parameter).
+        min_samples : int, default 1
+            The minimum number of points to form a cluster (DBSCAN parameter).
+
+        Returns
+        -------
+        NDArray[np.int32]
+            Array of integer labels indicating which attractor each initial condition belongs to.
+            Label `-1` indicates points classified as noise (not part of any attractor).
+
+        Notes
+        -----
+        The basin of attraction is determined by first constructing either a stroboscopic map
+        or a Poincaré section from the trajectories. Then, the attractors are identified by
+        clustering the trajectory centroids using the DBSCAN algorithm from scikit-learn.
+
+        DBSCAN groups points that are close to each other in phase space, with `eps` defining
+        the neighborhood radius and `min_samples` specifying the minimum number of points to
+        form a cluster. Each cluster corresponds to a distinct attractor, and initial conditions
+        whose trajectories end up in the same cluster are considered to belong to the same basin
+        of attraction.
+        """
+        u = validate_initial_conditions(u, self.__system_dimension)
+        u = u.copy()
+
+        validate_non_negative(num_intersections, "num_intersections", Integral)
+
+        parameters = validate_parameters(parameters, self.__number_of_parameters)
+
+        if transient_time is not None:
+            validate_non_negative(transient_time, "transient_time", Real)
+
+        if not isinstance(map_type, str):
+            raise TypeError("map_type must a valid string")
+        if map_type not in ["SM", "PS"]:
+            raise ValueError(
+                "map_type must be either SM (stroboscopic map) or PS (Poicaré section)"
+            )
+
+        if section_index is not None:
+            validate_non_negative(section_index, "section_index", Integral)
+            if section_index > self.__system_dimension:
+                raise ValueError("section_index must be <= system_dimension")
+
+        if section_value is not None:
+            if not isinstance(section_value, Real):
+                raise TypeError("section_value must be a valid real number")
+
+        if crossing is not None:
+            if not isinstance(crossing, Integral):
+                raise TypeError("crossing must be an integer number")
+            elif crossing not in [-1, 0, 1]:
+                raise ValueError(
+                    "crossing must be -1 (downward crossings), 0 (all crossings), or 1 (upward crossing)"
+                )
+
+        if sampling_time is not None:
+            validate_non_negative(sampling_time, "sampling_time", Real)
+
+        validate_non_negative(eps, "eps", Real)
+
+        validate_non_negative(min_samples, "min_samples", Integral)
+
+        time_step = self.__get_initial_time_step(u, parameters)
+
+        return basin_of_attraction(
+            u,
+            parameters,
+            num_intersections,
+            self.__equations_of_motion,
+            transient_time,
+            time_step,
+            self.__atol,
+            self.__rtol,
+            self.__integrator_func,
+            map_type,
+            section_index,
+            section_value,
+            crossing,
+            sampling_time,
+            eps,
+            min_samples,
+        )
+
     def lyapunov(
         self,
-        u: NDArray[np.float64],
+        u: Union[NDArray[np.float64], Sequence[float]],
         total_time: float,
         parameters: Union[None, Sequence[float], NDArray[np.float64]] = None,
         transient_time: Optional[float] = None,
@@ -499,7 +1043,7 @@ class ContinuousDynamicalSystem:
 
         Parameters
         ----------
-        u : NDArray[np.float64]
+        u : Union[NDArray[np.float64], Sequence[float]]
             Initial conditions of the system. Must match the system's dimension.
         total_time : float
             Total time over which to evolve the system (including transient).
@@ -603,31 +1147,46 @@ class ContinuousDynamicalSystem:
         if log_base == 1:
             raise ValueError("The logarithm function is not defined with base 1")
 
-        result = lyapunov_exponents(
-            u,
-            parameters,
-            total_time,
-            self.__equations_of_motion,
-            self.__jacobian,
-            num_exponents,
-            transient_time=transient_time,
-            time_step=time_step,
-            atol=self.__atol,
-            rtol=self.__rtol,
-            integrator=self.__integrator_func,
-            return_history=return_history,
-            seed=seed,
-            log_base=log_base,
-            QR=qr_func,
-        )
+        if num_exponents == 1:
+            result = maximum_lyapunov_exponent(
+                u,
+                parameters,
+                total_time,
+                self.__equations_of_motion,
+                self.__jacobian,
+                transient_time,
+                time_step,
+                self.__atol,
+                self.__rtol,
+                self.__integrator_func,
+                return_history,
+                seed,
+            )
+        else:
+            result = lyapunov_exponents(
+                u,
+                parameters,
+                total_time,
+                self.__equations_of_motion,
+                self.__jacobian,
+                num_exponents,
+                transient_time=transient_time,
+                time_step=time_step,
+                atol=self.__atol,
+                rtol=self.__rtol,
+                integrator=self.__integrator_func,
+                return_history=return_history,
+                seed=seed,
+                QR=qr_func,
+            )
         if return_history:
-            return np.array(result)
+            return np.array(result) / np.log(log_base)
         else:
-            return np.array(result[0])
+            return np.array(result[0]) / np.log(log_base)
 
     def SALI(
         self,
-        u: NDArray[np.float64],
+        u: Union[NDArray[np.float64], Sequence[float]],
         total_time: float,
         parameters: Union[None, Sequence[float], NDArray[np.float64]] = None,
         transient_time: Optional[float] = None,
@@ -640,7 +1199,7 @@ class ContinuousDynamicalSystem:
 
         Parameters
         ----------
-        u : NDArray[np.float64]
+        u : Union[NDArray[np.float64], Sequence[float]]
             Initial conditions of the system. Must match the system's dimension.
         total_time : float
             Total time over which to evolve the system (including transient).
@@ -738,7 +1297,7 @@ class ContinuousDynamicalSystem:
 
     def LDI(
         self,
-        u: NDArray[np.float64],
+        u: Union[NDArray[np.float64], Sequence[float]],
         total_time: float,
         k: int,
         parameters: Union[None, Sequence[float], NDArray[np.float64]] = None,
@@ -752,7 +1311,7 @@ class ContinuousDynamicalSystem:
 
         Parameters
         ----------
-        u : NDArray[np.float64]
+        u : Union[NDArray[np.float64], Sequence[float]]
             Initial conditions of the system. Must match the system's dimension.
         total_time : float
             Total time over which to evolve the system (including transient).
@@ -853,7 +1412,7 @@ class ContinuousDynamicalSystem:
 
     def GALI(
         self,
-        u: NDArray[np.float64],
+        u: Union[NDArray[np.float64], Sequence[float]],
         total_time: float,
         k: int,
         parameters: Union[None, Sequence[float], NDArray[np.float64]] = None,
@@ -867,7 +1426,7 @@ class ContinuousDynamicalSystem:
 
         Parameters
         ----------
-        u : NDArray[np.float64]
+        u : Union[NDArray[np.float64], Sequence[float]]
             Initial conditions of the system. Must match the system's dimension.
         total_time : float
             Total time over which to evolve the system (including transient).
@@ -965,3 +1524,342 @@ class ContinuousDynamicalSystem:
             return np.array(result)
         else:
             return np.array(result[0])
+
+    def recurrence_time_entropy(
+        self,
+        u: Union[NDArray[np.float64], Sequence[float]],
+        num_intersections: int,
+        parameters: Union[None, Sequence[float], NDArray[np.float64]] = None,
+        transient_time: Optional[float] = None,
+        map_type: str = "SM",
+        section_index: Optional[int] = None,
+        section_value: Optional[float] = None,
+        crossing: Optional[int] = None,
+        sampling_time: Optional[float] = None,
+        maxima_index: Optional[float] = None,
+        **kwargs,
+    ) -> Union[float, Tuple[float, NDArray[np.float64]]]:
+        """Compute the Recurrence Time Entropy (RTE) for a dynamical system.
+
+        Parameters
+        ----------
+        u: Union[NDArray[np.float64], Sequence[float]]
+            Initial condition of shape(d,) where d is system dimension
+        num_intersections: int
+            Number of intersections to record in the Poincaré section or stroboscopic map.
+        parameters: Union[None, float, Sequence[np.float64], NDArray[np.float64]], optional
+            System parameters of shape(p,) passed to mapping function
+        transient_time : float, optional
+            Initial time to discard before recording the section.
+        map_type : str
+            Which map to use: stroboscopic map or Poincaré section, by default "SM"
+        section_index : Optional[int]
+            Index of the coordinate to define the Poincaré section (0-based). Only used when map_type="PS".
+        section_value : Optional[float]
+            Value of the coordinate at which the section is defined. Only used when map_type="PS".
+        crossing : Optional[int]
+            Specifies the type of crossing to consider:
+            - 1 : positive crossing (from below to above section_value)
+            - -1 : negative crossing (from above to below section_value)
+            - 0 : all crossings
+
+            Only used when map_type="PS".
+        sampling_time : float
+            Time interval between consecutive samples in the stroboscopic map. Only used when map_type="SM".
+        maxima_index : Optional[int]
+            Index of the coordinate whose maxima will be recorded. Only used when map_type="MM".
+        metric: {"supremum", "euclidean", "manhattan"}, default = "supremum"
+            Distance metric used for phase space reconstruction.
+        std_metric: {"supremum", "euclidean", "manhattan"}, default = "supremum"
+            Distance metric used for standard deviation calculation.
+        lmin: int, default = 1
+            Minimum line length to consider in recurrence quantification.
+        threshold: float, default = 0.1
+            Recurrence threshold(relative to data range).
+        threshold_std: bool, default = True
+            Whether to scale threshold by data standard deviation.
+        return_final_state: bool, default = False
+            Whether to return the final system state in results.
+        return_recmat: bool, default = False
+            Whether to return the recurrence matrix.
+        return_p: bool, default = False
+            Whether to return white vertical line length distribution.
+
+        Returns
+        -------
+        Union[float, Tuple[float, NDArray[np.float64]]]
+            - float: RTE value(base case)
+            - Tuple: (RTE, white_line_distribution) if return_distribution = True
+
+        Raises
+        ------
+        ValueError
+            - If `u` is not a 1D array matching the system dimension.
+            - If `parameters` is not `None` and does not match the expected number of parameters.
+            - If `parameters` is `None` but the system expects parameters.
+            - If `parameters` is a scalar or array-like but not 1D.
+            - If `transient_time` is negative.
+            - If `map_type` is not one of {"SM", "PS"}.
+            - If `map_type="PS"` but any of `section_index`, `section_value`, or `crossing` is `None`.
+            - If `section_index` is negative or ≥ system dimension.
+            - If `crossing` is not one of {-1, 0, 1}.
+            - If `map_type="SM"` but `sampling_time` is `None` or negative.
+        TypeError
+            - If `u` is not a scalar or array-like type.
+            - If `parameters` is not a scalar or array-like type.
+            - If `map_type` is not a string.
+            - If `section_value` is not a real number when `map_type="PS"`.
+            - If `crossing` is not an integer when `map_type="PS"`.
+            - If `sampling_time` is not a real number when `map_type="SM"`.
+
+        Notes
+        -----
+        - Higher RTE indicates more complex dynamics
+        - Set min_recurrence_time = 2 to ignore single-point recurrences
+        - Implementation follows [1]
+
+        References
+        ----------
+        [1] Sales et al., Chaos 33, 033140 (2023)
+
+        Examples
+        --------
+        >>>  # Basic usage
+        >>> rte = system.recurrence_time_entropy(u0, params, 5000)
+
+        >>>  # With distribution output
+        >>> rte, dist = system.recurrence_time_entropy(
+        ...     u0, params, 5000,
+        ...     return_distribution=True,
+        ...     recurrence_threshold=0.1
+        ...)
+        """
+        u = validate_initial_conditions(
+            u, self.__system_dimension, allow_ensemble=False
+        )
+        u = u.copy()
+
+        parameters = validate_parameters(parameters, self.__number_of_parameters)
+
+        validate_non_negative(transient_time, "transient_time", Real)
+
+        if not isinstance(map_type, str):
+            raise TypeError("map_type must be a string")
+
+        if map_type == "PS":
+            if section_index is None or section_value is None or crossing is None:
+                raise ValueError(
+                    'When using map_type="PS", you must inform section_index, section_value, and crossing'
+                )
+
+            validate_non_negative(section_index, "section_index", Integral)
+            if section_index >= self.__system_dimension:
+                raise ValueError("section_index must be in [0, system_dimension)")
+
+            if not isinstance(section_value, Real):
+                raise TypeError("section_value must be a valid real number")
+
+            if not isinstance(crossing, Integral):
+                raise TypeError("crossing must be a valid integer number")
+            elif crossing not in [-1, 0, 1]:
+                raise ValueError("crossing must be -1, 0, or 1")
+
+        elif map_type == "SM":
+
+            if sampling_time is not None:
+                validate_non_negative(sampling_time, "sampling_time", Real)
+            else:
+                raise ValueError(
+                    'When using map_type="SM" you must inform sampling_time'
+                )
+        elif map_type == "MM":
+            if maxima_index is not None:
+                validate_non_negative(maxima_index, "maxima_index", Integral)
+            else:
+                raise ValueError(
+                    'When using map_type="MM" you must inform maxima_index'
+                )
+        else:
+            raise ValueError(
+                "map_type must be SM (stroboscopic map), PS (Poincaré section), or MM (Maxima map)"
+            )
+
+        time_step = self.__get_initial_time_step(u, parameters)
+
+        return recurrence_time_entropy(
+            u,
+            parameters,
+            num_intersections,
+            transient_time,
+            self.__equations_of_motion,
+            time_step,
+            self.__atol,
+            self.__rtol,
+            self.__integrator_func,
+            map_type,
+            section_index,
+            section_value,
+            crossing,
+            sampling_time,
+            maxima_index,
+            **kwargs,
+        )
+
+    def hurst_exponent(
+        self,
+        u: Union[NDArray[np.float64], Sequence[float]],
+        num_intersections: int,
+        parameters: Union[None, Sequence[float], NDArray[np.float64]] = None,
+        transient_time: Optional[float] = None,
+        wmin: int = 2,
+        map_type: str = "SM",
+        section_index: Optional[int] = None,
+        section_value: Optional[float] = None,
+        crossing: Optional[int] = None,
+        sampling_time: Optional[float] = None,
+        maxima_index: Optional[float] = None,
+    ) -> Union[float, Tuple[float, NDArray[np.float64]]]:
+        """
+        Estimate the Hurst exponent for a system trajectory using the rescaled range (R/S) method.
+
+        Parameters
+        ----------
+        u : NDArray[np.float64]
+            Initial condition vector of shape (n,).
+        parameters : Union[None, float, Sequence[np.float64], NDArray[np.float64]], optional
+            Parameters passed to the mapping function.
+        total_time : int
+            Total number of iterations used to generate the trajectory.
+        transient_time : Optional[int], optional
+            Number of initial iterations to discard as transient. If `None`, no transient is removed. Default is `None`.
+        wmin : int, optional
+            Minimum window size for the rescaled range calculation. Default is 2.
+        map_type : str
+            Which map to use: stroboscopic map or Poincaré section, by default "SM"
+        section_index : Optional[int]
+            Index of the coordinate to define the Poincaré section (0-based). Only used when map_type="PS".
+        section_value : Optional[float]
+            Value of the coordinate at which the section is defined. Only used when map_type="PS".
+        crossing : Optional[int]
+            Specifies the type of crossing to consider:
+            - 1 : positive crossing (from below to above section_value)
+            - -1 : negative crossing (from above to below section_value)
+            - 0 : all crossings
+
+            Only used when map_type="PS".
+        sampling_time : float
+            Time interval between consecutive samples in the stroboscopic map. Only used when map_type="SM".
+        maxima_index : Optional[int]
+            Index of the coordinate whose maxima will be recorded. Only used when map_type="MM".
+
+        Returns
+        -------
+        NDArray[np.float64]
+            Estimated Hurst exponents for each dimension of the input vector `u`, of shape (n,).
+
+        Raises
+        ------
+        TypeError
+            - If `map_type` is not a string.
+            - If `section_value` is not a real number when `map_type="PS"`.
+            - If `crossing` is not an integer when `map_type="PS"`.
+            - If `sampling_time` is not a real number when `map_type="SM"`.
+            - If `maxima_index` is not an integer when `map_type="MM"`.
+        ValueError
+            - If `map_type` is not one of {"SM", "PS", "MM"}.
+            - If `map_type="PS"` and any of `section_index`, `section_value`, or `crossing` is `None`.
+            - If `section_index` is negative or ≥ system dimension when `map_type="PS"`.
+            - If `crossing` is not in {-1, 0, 1} when `map_type="PS"`.
+            - If `map_type="SM"` and `sampling_time` is `None` or negative.
+            - If `map_type="MM"` and `maxima_index` is `None` or negative.
+            - If `transient_time` is negative.
+            - If `wmin` is less than 2 or greater than or equal to `num_intersections // 2`.
+
+        Notes
+        -----
+        The Hurst exponent is a measure of the long-term memory of a time series:
+
+        - H = 0.5 indicates a random walk (no memory).
+        - H > 0.5 indicates persistent behavior (positive autocorrelation).
+        - H < 0.5 indicates anti-persistent behavior (negative autocorrelation).
+
+        This implementation computes the rescaled range (R/S) for various window sizes and
+        performs a linear regression in log-log space to estimate the exponent.
+
+        The function supports multivariate time series, estimating one Hurst exponent per dimension.
+        """
+        u = validate_initial_conditions(
+            u, self.__system_dimension, allow_ensemble=False
+        )
+        u = u.copy()
+
+        parameters = validate_parameters(parameters, self.__number_of_parameters)
+
+        validate_non_negative(transient_time, "transient_time", Real)
+
+        if not isinstance(map_type, str):
+            raise TypeError("map_type must be a string")
+
+        if map_type == "PS":
+            if section_index is None or section_value is None or crossing is None:
+                raise ValueError(
+                    'When using map_type="PS", you must inform section_index, section_value, and crossing'
+                )
+
+            validate_non_negative(section_index, "section_index", Integral)
+            if section_index >= self.__system_dimension:
+                raise ValueError("section_index must be in [0, system_dimension)")
+
+            if not isinstance(section_value, Real):
+                raise TypeError("section_value must be a valid real number")
+
+            if not isinstance(crossing, Integral):
+                raise TypeError("crossing must be a valid integer number")
+            elif crossing not in [-1, 0, 1]:
+                raise ValueError("crossing must be -1, 0, or 1")
+
+        elif map_type == "SM":
+
+            if sampling_time is not None:
+                validate_non_negative(sampling_time, "sampling_time", Real)
+            else:
+                raise ValueError(
+                    'When using map_type="SM" you must inform sampling_time'
+                )
+        elif map_type == "MM":
+            if maxima_index is not None:
+                validate_non_negative(maxima_index, "maxima_index", Integral)
+            else:
+                raise ValueError(
+                    'When using map_type="MM" you must inform maxima_index'
+                )
+        else:
+            raise ValueError(
+                "map_type must be SM (stroboscopic map), PS (Poincaré section), or MM (Maxima map)"
+            )
+
+        if wmin < 2 or wmin >= num_intersections // 2:
+            raise ValueError(
+                f"`wmin` must be an integer >= 2 and <= total_time / 2. Got {wmin}."
+            )
+
+        time_step = self.__get_initial_time_step(u, parameters)
+
+        return hurst_exponent_wrapped(
+            u,
+            parameters,
+            num_intersections,
+            self.__equations_of_motion,
+            time_step,
+            self.__atol,
+            self.__rtol,
+            self.__integrator_func,
+            map_type,
+            section_index,
+            section_value,
+            crossing,
+            sampling_time,
+            maxima_index,
+            wmin,
+            transient_time,
+        )