pynamicalsys 1.3.1__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,6 +31,8 @@ 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
 def lyapunov_1D(
@@ -1047,8 +1049,7 @@ def GALI_k(
         return np.array([gali])
 
 
-@njit
-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)

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/>.