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

pynamicalsys/__init__.py

@@ -17,6 +17,7 @@
 
 from pynamicalsys.core.discrete_dynamical_systems import DiscreteDynamicalSystem
 from pynamicalsys.core.continuous_dynamical_systems import ContinuousDynamicalSystem
+from pynamicalsys.core.hamiltonian_systems import HamiltonianSystem
 from pynamicalsys.core.basin_metrics import BasinMetrics
 from pynamicalsys.core.plot_styler import PlotStyler
 from pynamicalsys.core.time_series_metrics import TimeSeriesMetrics
@@ -25,6 +26,7 @@ from .__version__ import __version__
 __all__ = [
     "DiscreteDynamicalSystem",
     "ContinuousDynamicalSystem",
+    "HamiltonianSystem",
     "PlotStyler",
     "TimeSeriesMetrics",
     "BasinMetrics",

pynamicalsys/__version__.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.3.1'
-__version_tuple__ = version_tuple = (1, 3, 1)
+__version__ = version = '1.4.0'
+__version_tuple__ = version_tuple = (1, 4, 0)
 
 __commit_id__ = commit_id = None

pynamicalsys/common/time_series_metrics.py

@@ -0,0 +1,85 @@
+from typing import Optional, Tuple, Union, Callable
+from numpy.typing import NDArray
+import numpy as np
+from numba import njit, prange
+
+from pynamicalsys.common.utils import fit_poly
+
+
+@njit(parallel=True)
+def hurst_exponent(
+    time_series: NDArray[np.float64],
+    wmin: int = 2,
+) -> NDArray[np.float64]:
+
+    time_series = time_series.copy()
+
+    sample_size, neq = time_series.shape
+
+    H = np.zeros(neq)
+
+    ells = np.arange(wmin, sample_size // 2)
+    log_ells = np.log(ells)
+    RS = np.empty((ells.shape[0], neq))
+
+    for j in prange(neq):
+        series = time_series[:, j]
+
+        # Precompute cumulative sums and cumulative sums of squares
+        cum_sum = np.zeros(sample_size)
+        cum_sum_sq = np.zeros(sample_size)
+        cum_sum[0] = series[0]
+        cum_sum_sq[0] = series[0] ** 2
+        for t in range(1, sample_size):
+            cum_sum[t] = cum_sum[t - 1] + series[t]
+            cum_sum_sq[t] = cum_sum_sq[t - 1] + series[t] ** 2
+
+        for i, ell in enumerate(ells):
+            num_blocks = sample_size // ell
+            R_over_S = np.zeros(num_blocks)
+
+            for block in range(num_blocks):
+                start = block * ell
+                end = start + ell
+
+                # Mean using cumulative sums
+                block_sum = cum_sum[end - 1] - (cum_sum[start - 1] if start > 0 else 0)
+                block_mean = block_sum / ell
+
+                # Variance using cumulative sums of squares
+                block_sum_sq = cum_sum_sq[end - 1] - (
+                    cum_sum_sq[start - 1] if start > 0 else 0
+                )
+                var = block_sum_sq / ell - block_mean**2
+                S = np.sqrt(var) if var > 0 else 0
+
+                # Cumulative sum of mean-adjusted series for range
+                max_Z = 0.0
+                min_Z = 0.0
+                cumsum = 0.0
+                for k in range(start, end):
+                    cumsum += series[k] - block_mean
+                    if cumsum > max_Z:
+                        max_Z = cumsum
+                    if cumsum < min_Z:
+                        min_Z = cumsum
+                R = max_Z - min_Z
+
+                R_over_S[block] = R / S if S > 0 else 0.0
+
+            positive_mask = R_over_S > 0
+            RS[i, j] = (
+                np.mean(R_over_S[positive_mask]) if np.any(positive_mask) else 0.0
+            )
+
+        # Linear regression in log-log space
+        positive_inds = np.where(RS[:, j] > 0)[0]
+        if positive_inds.size == 0:
+            H[j] = 0.0
+        else:
+            x_fit = log_ells[positive_inds]
+            y_fit = np.log(RS[positive_inds, j])
+            fitting = fit_poly(x_fit, y_fit, 1)
+            H[j] = fitting[0]
+
+    return H

pynamicalsys/continuous_time/chaotic_indicators.py

@@ -15,17 +15,33 @@
 # You should have received a copy of the GNU General Public License
 # along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-from typing import Optional, Callable, Union, Tuple, Dict, List, Any, Sequence
+from typing import Optional, Callable, Tuple
 from numpy.typing import NDArray
 import numpy as np
 from numba import njit
 
-from pynamicalsys.common.utils import qr, wedge_norm
-from pynamicalsys.continuous_time.trajectory_analysis import step, evolve_system
+from pynamicalsys.common.utils import qr, wedge_norm, fit_poly
+
+from pynamicalsys.continuous_time.trajectory_analysis import (
+    generate_maxima_map,
+    step,
+    evolve_system,
+    generate_poincare_section,
+    generate_stroboscopic_map,
+)
+
 from pynamicalsys.continuous_time.numerical_integrators import rk4_step_wrapped
 
+from pynamicalsys.common.recurrence_quantification_analysis import (
+    RTEConfig,
+    recurrence_matrix,
+    white_vertline_distr,
+)
+
+from pynamicalsys.common.time_series_metrics import hurst_exponent
 
-# @njit
+
+@njit
 def lyapunov_exponents(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],
@@ -44,7 +60,6 @@ def lyapunov_exponents(
     integrator=rk4_step_wrapped,
     return_history: bool = False,
     seed: int = 13,
-    log_base: float = np.e,
     QR: Callable[
         [NDArray[np.float64]], Tuple[NDArray[np.float64], NDArray[np.float64]]
     ] = qr,
@@ -110,7 +125,7 @@ def lyapunov_exponents(
         # Perform the QR decomposition
         v, R = QR(v)
         # Accumulate the log
-        exponents += np.log(np.abs(np.diag(R))) / np.log(log_base)
+        exponents += np.log(np.abs(np.diag(R)))
 
         if return_history:
             result = [time]
@@ -136,6 +151,102 @@ def lyapunov_exponents(
         return [result]
 
 
+@njit
+def maximum_lyapunov_exponent(
+    u: NDArray[np.float64],
+    parameters: NDArray[np.float64],
+    total_time: float,
+    equations_of_motion: Callable[
+        [np.float64, NDArray[np.float64], NDArray[np.float64]], NDArray[np.float64]
+    ],
+    jacobian: Callable[
+        [np.float64, NDArray[np.float64], NDArray[np.float64]], NDArray[np.float64]
+    ],
+    transient_time: Optional[float] = None,
+    time_step: float = 0.01,
+    atol: float = 1e-6,
+    rtol: float = 1e-3,
+    integrator=rk4_step_wrapped,
+    return_history: bool = False,
+    seed: int = 13,
+) -> NDArray[np.float64]:
+
+    neq = len(u)  # Number of equations of the system
+    nt = neq + neq  # system + variational equations
+
+    u = u.copy()
+
+    # Handle transient time
+    if transient_time is not None:
+        u = evolve_system(
+            u,
+            parameters,
+            transient_time,
+            equations_of_motion,
+            time_step=time_step,
+            atol=atol,
+            rtol=rtol,
+            integrator=integrator,
+        )
+        sample_time = total_time - transient_time
+        time = transient_time
+    else:
+        sample_time = total_time
+        time = 0
+
+    # State + deviation vectors
+    uv = np.zeros(nt)
+    uv[:neq] = u.copy()
+
+    # Randomly define the deviation vectors and orthonormalize them
+    np.random.seed(seed)
+    uv[neq:] = -1 + 2 * np.random.rand(nt - neq)
+    norm = np.linalg.norm(uv[neq:])
+    uv[neq:] /= norm
+
+    exponent = 0.0
+    history = []
+
+    while time < total_time:
+        if time + time_step > total_time:
+            time_step = total_time - time
+
+        uv, time, time_step = step(
+            time,
+            uv,
+            parameters,
+            equations_of_motion,
+            jacobian=jacobian,
+            time_step=time_step,
+            atol=atol,
+            rtol=rtol,
+            integrator=integrator,
+            number_of_deviation_vectors=1,
+        )
+
+        norm = np.linalg.norm(uv[neq:])
+
+        exponent += np.log(np.abs(norm))
+
+        uv[neq:] /= norm
+
+        if return_history:
+            result = [time]
+            result.append(
+                exponent
+                / (time - (transient_time if transient_time is not None else 0))
+            )
+            history.append(result)
+
+    if return_history:
+        return history
+    else:
+        result = [
+            exponent / (time - (transient_time if transient_time is not None else 0))
+        ]
+        return [result]
+
+
 @njit
 def SALI(
     u: NDArray[np.float64],
@@ -238,7 +349,6 @@ def SALI(
         return [[time, sali]]
 
 
-# @njit
 def LDI(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],
@@ -441,3 +551,191 @@ def GALI(
         return history
     else:
         return [[time, gali]]
+
+
+def recurrence_time_entropy(
+    u,
+    parameters,
+    num_points,
+    transient_time,
+    equations_of_motion,
+    time_step,
+    atol,
+    rtol,
+    integrator,
+    map_type,
+    section_index,
+    section_value,
+    crossing,
+    sampling_time,
+    maxima_index,
+    **kwargs,
+):
+
+    # Configuration handling
+    config = RTEConfig(**kwargs)
+
+    # Metric setup
+    metric_map = {"supremum": np.inf, "euclidean": 2, "manhattan": 1}
+
+    try:
+        ord = metric_map[config.std_metric.lower()]
+    except KeyError:
+        raise ValueError(
+            f"Invalid std_metric: {config.std_metric}. Must be {list(metric_map.keys())}"
+        )
+
+    # Generate the Poincaré section or stroboscopic map
+    if map_type == "PS":
+        points = generate_poincare_section(
+            u,
+            parameters,
+            num_points,
+            equations_of_motion,
+            transient_time,
+            time_step,
+            atol,
+            rtol,
+            integrator,
+            section_index,
+            section_value,
+            crossing,
+        )
+        data = points[:, 1:]  # Remove time
+        data = np.delete(data, section_index, axis=1)
+    elif map_type == "SM":
+        points = generate_stroboscopic_map(
+            u,
+            parameters,
+            num_points,
+            sampling_time,
+            equations_of_motion,
+            transient_time,
+            time_step,
+            atol,
+            rtol,
+            integrator,
+        )
+
+        data = points[:, 1:]  # Remove time
+    else:
+        points = generate_maxima_map(
+            u,
+            parameters,
+            num_points,
+            maxima_index,
+            equations_of_motion,
+            transient_time,
+            time_step,
+            atol,
+            rtol,
+            integrator,
+        )
+
+        data = points[:, 1:]  # Remove time
+
+    # Threshold calculation
+    if config.threshold_std:
+        std = np.std(data, axis=0)
+        eps = config.threshold * np.linalg.norm(std, ord=ord)
+        if eps <= 0:
+            eps = 0.1
+    else:
+        eps = config.threshold
+
+    # Recurrence matrix calculation
+    recmat = recurrence_matrix(data, float(eps), metric=config.metric)
+
+    # White line distribution
+    P = white_vertline_distr(recmat)[config.lmin :]
+    P = P[P > 0]  # Remove zeros
+    P /= P.sum()  # Normalize
+
+    # Entropy calculation
+    rte = -np.sum(P * np.log(P))
+
+    # Prepare output
+    result = [rte]
+    if config.return_final_state:
+        result.append(points[-1])
+    if config.return_recmat:
+        result.append(recmat)
+    if config.return_p:
+        result.append(P)
+
+    return result[0] if len(result) == 1 else tuple(result)
+
+
+def hurst_exponent_wrapped(
+    u: NDArray[np.float64],
+    parameters: NDArray[np.float64],
+    num_points: int,
+    equations_of_motion: Callable,
+    time_step: float,
+    atol: float,
+    rtol: float,
+    integrator: Callable,
+    map_type: str,
+    section_index: int,
+    section_value: float,
+    crossing: int,
+    sampling_time: float,
+    maxima_index: int,
+    wmin: int = 2,
+    transient_time: Optional[int] = None,
+) -> NDArray[np.float64]:
+
+    u = u.copy()
+    neq = len(u)
+    H = np.zeros(neq)
+
+    # Generate the Poincaré section or stroboscopic map
+    if map_type == "PS":
+        points = generate_poincare_section(
+            u,
+            parameters,
+            num_points,
+            equations_of_motion,
+            transient_time,
+            time_step,
+            atol,
+            rtol,
+            integrator,
+            section_index,
+            section_value,
+            crossing,
+        )
+        data = points[:, 1:]  # Remove time
+        data = np.delete(data, section_index, axis=1)
+    elif map_type == "SM":
+        points = generate_stroboscopic_map(
+            u,
+            parameters,
+            num_points,
+            sampling_time,
+            equations_of_motion,
+            transient_time,
+            time_step,
+            atol,
+            rtol,
+            integrator,
+        )
+
+        data = points[:, 1:]  # Remove time
+    else:
+        points = generate_maxima_map(
+            u,
+            parameters,
+            num_points,
+            maxima_index,
+            equations_of_motion,
+            transient_time,
+            time_step,
+            atol,
+            rtol,
+            integrator,
+        )
+
+        data = points[:, 1:]  # Remove time
+
+    return hurst_exponent(data, wmin=wmin)

pynamicalsys/continuous_time/models.py

@@ -196,6 +196,31 @@ def rossler_system_4D_jacobian(
     return J
 
 
+@njit
+def duffing(time, u, parameters):
+    delta, alpha, beta, gamma, omega = parameters
+    dudt = np.zeros_like(u)
+    dudt[0] = u[1]
+    dudt[1] = (
+        -delta * u[1] + alpha * u[0] - beta * u[0] ** 3 + gamma * np.cos(omega * time)
+    )
+
+    return dudt
+
+
+@njit
+def duffing_jacobian(time, u, parameters):
+    delta, alpha, beta, gamma, omega = parameters
+    neq = len(u)
+    J = np.zeros((neq, neq), dtype=np.float64)
+
+    J[0, 0] = 0
+    J[0, 1] = 1
+    J[1, 0] = alpha - 3 * beta * u[0] ** 2
+    J[1, 1] = -delta
+    return J
+
+
 @njit
 def variational_equations(
     time: float,