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

pynamicalsys/core/time_series_metrics.py

@@ -18,12 +18,18 @@
 import numpy as np
 from numpy.typing import NDArray
 
+from numbers import Integral, Real
+
 from pynamicalsys.common.recurrence_quantification_analysis import (
     recurrence_matrix,
     RTEConfig,
     white_vertline_distr,
 )
 
+from pynamicalsys.discrete_time.validators import validate_positive
+
+from pynamicalsys.common.time_series_metrics import hurst_exponent
+
 
 class TimeSeriesMetrics:
     def __init__(self, time_series: NDArray[np.float64]) -> None:
@@ -137,3 +143,62 @@ class TimeSeriesMetrics:
             result.append(P)
 
         return result[0] if len(result) == 1 else tuple(result)
+
+    def hurst_exponent(self, wmin: int = 2):
+        """
+        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 : NDArray[np.float64]
+            Parameters passed to the mapping function.
+        total_time : int
+            Total number of iterations used to generate the trajectory.
+        mapping : Callable[[NDArray[np.float64], NDArray[np.float64]], NDArray[np.float64]]
+            A function that defines the system dynamics, i.e., how `u` evolves over time given `parameters`.
+        wmin : int, optional
+            Minimum window size for the rescaled range calculation. Default is 2.
+        transient_time : Optional[int], optional
+            Number of initial iterations to discard as transient. If `None`, no transient is removed. Default is `None`.
+
+        Returns
+        -------
+        NDArray[np.float64]
+            Estimated Hurst exponents for each dimension of the input vector `u`, of shape (n,).
+
+        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.
+        """
+
+        sample_size = self.time_series.shape[0]
+
+        validate_positive(wmin, "wmin", Integral)
+
+        if wmin < 2 or wmin >= sample_size // 2:
+            raise ValueError(
+                f"`wmin` must be an integer >= 2 and <= len(time_series) / 2. Got {wmin}."
+            )
+
+        if self.time_series.ndim == 1:
+            time_series = self.time_series.reshape(sample_size, 1)
+        else:
+            time_series = self.time_series
+
+        result = hurst_exponent(time_series, wmin=wmin)
+
+        if self.time_series.ndim == 1:
+            return result[0]
+        else:
+            return result

pynamicalsys/discrete_time/dynamical_indicators.py

@@ -18,7 +18,7 @@
 from typing import Optional, Tuple, Union, Callable
 from numpy.typing import NDArray
 import numpy as np
-from numba import njit
+from numba import njit, prange
 
 from pynamicalsys.common.recurrence_quantification_analysis import (
     RTEConfig,
@@ -31,8 +31,10 @@ from pynamicalsys.discrete_time.trajectory_analysis import (
 )
 from pynamicalsys.common.utils import qr, householder_qr, fit_poly, wedge_norm
 
+from pynamicalsys.common.time_series_metrics import hurst_exponent
 
-@njit(cache=True)
+
+@njit
 def lyapunov_1D(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],
@@ -120,7 +122,7 @@ def lyapunov_1D(
     return history if return_history else np.array([exponent / sample_size])
 
 
-@njit(cache=True)
+@njit
 def lyapunov_er(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],
@@ -246,7 +248,7 @@ def lyapunov_er(
         return aux_exponents, u_contig
 
 
-@njit(cache=True)
+@njit
 def maximum_lyapunov_er(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],
@@ -367,7 +369,7 @@ def maximum_lyapunov_er(
         return np.array([exponent / sample_size]), u_contig
 
 
-@njit(cache=True)
+@njit
 def lyapunov_qr(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],
@@ -701,7 +703,7 @@ def dig(
     return -np.log10(abs(WB0 - WB1))
 
 
-@njit(cache=True)
+@njit
 def SALI(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],
@@ -761,7 +763,7 @@ def SALI(
     - Uses QR decomposition to initialize orthonormal deviation vectors.
     - Computes both Parallel (PAI) and Antiparallel (AAI) Alignment Indices.
     - Early termination occurs if SALI < `tol` (indicating chaotic behavior).
-    - Optimized with `@njit(cache=True)` for performance.
+    - Optimized with `@njit` for performance.
     """
 
     np.random.seed(seed)  # For reproducibility
@@ -1047,8 +1049,7 @@ def GALI_k(
         return np.array([gali])
 
 
-@njit(cache=True)
-def hurst_exponent(
+def hurst_exponent_wrapped(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],
     total_time: int,
@@ -1057,105 +1058,15 @@ def hurst_exponent(
     transient_time: Optional[int] = None,
     return_last: bool = False,
 ) -> 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 : NDArray[np.float64]
-        Parameters passed to the mapping function.
-    total_time : int
-        Total number of iterations used to generate the trajectory.
-    mapping : Callable[[NDArray[np.float64], NDArray[np.float64]], NDArray[np.float64]]
-        A function that defines the system dynamics, i.e., how `u` evolves over time given `parameters`.
-    wmin : int, optional
-        Minimum window size for the rescaled range calculation. Default is 2.
-    transient_time : Optional[int], optional
-        Number of initial iterations to discard as transient. If `None`, no transient is removed. Default is `None`.
-
-    Returns
-    -------
-    NDArray[np.float64]
-        Estimated Hurst exponents for each dimension of the input vector `u`, of shape (n,).
-
-    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 = u.copy()
     neq = len(u)
     H = np.zeros(neq)
 
-    # Handle transient time
-    if transient_time is not None:
-        sample_size = total_time - transient_time
-        for i in range(transient_time):
-            u = mapping(u, parameters)
-    else:
-        sample_size = total_time
-
     time_series = generate_trajectory(
         u, parameters, total_time, mapping, transient_time=transient_time
     )
 
-    ells = np.arange(wmin, sample_size // 2)
-    RS = np.empty((ells.shape[0], neq))
-    for j in range(neq):
-
-        for i, ell in enumerate(ells):
-            num_blocks = sample_size // ell
-            R_over_S = np.empty(num_blocks)
-
-            for block in range(num_blocks):
-                start = block * ell
-                end = start + ell
-                block_series = time_series[start:end, j]
-
-                # Mean adjustment
-                mean_adjusted_series = block_series - np.mean(block_series)
-
-                # Cumulative sum
-                Z = np.cumsum(mean_adjusted_series)
-
-                # Range (R)
-                R = np.max(Z) - np.min(Z)
-
-                # Standard deviation (S)
-                S = np.std(block_series)
-
-                # Avoid division by zero
-                if S > 0:
-                    R_over_S[block] = R / S
-                else:
-                    R_over_S[block] = 0
-
-            if np.all(R_over_S == 0):
-                RS[i, j] == 0
-            else:
-                RS[i, j] = np.mean(R_over_S[R_over_S > 0])
-
-        if np.all(RS[:, j] == 0):
-            H[j] = 0
-        else:
-            # Log-log plot and linear regression to estimate the Hurst exponent
-            inds = np.where(RS[:, j] > 0)[0]
-            x_fit = np.log(ells[inds])
-            y_fit = np.log(RS[inds, j])
-            fitting = fit_poly(x_fit, y_fit, 1)
-
-            H[j] = fitting[0]
+    H = hurst_exponent(time_series, wmin=wmin)
 
     if return_last:
         result = np.zeros(2 * neq)
@@ -1224,13 +1135,13 @@ def finite_time_hurst_exponent(
         return H_values
 
 
-@njit(cache=True)
+@njit
 def lyapunov_vectors():
     # ! To be implemented...
     pass
 
 
-@njit(cache=True)
+@njit
 def lagrangian_descriptors(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],

pynamicalsys/discrete_time/models.py

@@ -408,7 +408,7 @@ def logistic_map_jacobian(
 # ! ------------------ !
 
 
-@njit(cache=True)
+@njit
 def rulkov_map(
     u: NDArray[np.float64], parameters: Union[NDArray[np.float64], Sequence[float]]
 ) -> NDArray[np.float64]:
@@ -419,7 +419,7 @@ def rulkov_map(
     return np.array([x_new, y_new])
 
 
-@njit(cache=True)
+@njit
 def rulkov_map_jacobian(
     u: NDArray[np.float64],
     parameters: Union[NDArray[np.float64], Sequence[float]],

pynamicalsys/discrete_time/trajectory_analysis.py

@@ -22,7 +22,7 @@ from numba import njit, prange
 from numpy.typing import NDArray
 
 
-@njit(cache=True)
+@njit
 def iterate_mapping(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],
@@ -78,7 +78,7 @@ def iterate_mapping(
     return u
 
 
-@njit(cache=True)
+@njit
 def generate_trajectory(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],
@@ -331,7 +331,7 @@ def bifurcation_diagram(
         return param_values, results
 
 
-@njit(cache=True)
+@njit
 def period_counter(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],
@@ -415,7 +415,7 @@ def period_counter(
     return -1
 
 
-@njit(cache=True)
+@njit
 def rotation_number(
     u: Union[NDArray[np.float64], Sequence[float], float],
     parameters: Union[NDArray[np.float64], Sequence[float], float],
@@ -438,7 +438,7 @@ def rotation_number(
     return rn
 
 
-@njit(cache=True)
+@njit
 def escape_basin_and_time_entering(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],
@@ -515,7 +515,7 @@ def escape_basin_and_time_entering(
     return -1, max_time
 
 
-@njit(cache=True)
+@njit
 def escape_time_exiting(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],
@@ -584,7 +584,7 @@ def escape_time_exiting(
     return -1, max_time  # No escape
 
 
-@njit(cache=True)
+@njit
 def survival_probability(
     escape_times: NDArray[np.int32],
     max_time: np.int32,
@@ -659,7 +659,7 @@ def survival_probability(
     return t_values, survival_probs
 
 
-@njit(cache=True)
+@njit
 def is_periodic(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],
@@ -811,7 +811,7 @@ def scan_phase_space(
     return result
 
 
-@njit(cache=True)
+@njit
 def scan_symmetry_line(
     points: NDArray[np.float64],
     parameters: NDArray[np.float64],
@@ -1095,7 +1095,7 @@ def find_periodic_orbit(
     return periodic_orbit
 
 
-@njit(cache=True)
+@njit
 def eigenvalues_and_eigenvectors(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],

pynamicalsys/discrete_time/transport.py

@@ -390,7 +390,7 @@ def mean_squared_displacement(
     return output
 
 
-@njit(cache=True)
+@njit
 def recurrence_times(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],

pynamicalsys/hamiltonian_systems/__init__.py

@@ -0,0 +1,16 @@
+# # __init__.py
+
+# # Copyright (C) 2025 Matheus Rolim Sales
+# #
+# # This program is free software: you can redistribute it and/or modify
+# # it under the terms of the GNU General Public License as published by
+# # the Free Software Foundation, either version 3 of the License, or
+# # (at your option) any later version.
+# #
+# # This program is distributed in the hope that it will be useful,
+# # but WITHOUT ANY WARRANTY; without even the implied warranty of
+# # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# # GNU General Public License for more details.
+# #
+# # You should have received a copy of the GNU General Public License
+# # along with this program. If not, see <https://www.gnu.org/licenses/>.