pynamicalsys 1.0.1__py3-none-any.whl → 1.2.2__py3-none-any.whl

pynamicalsys/__init__.py

@@ -16,9 +16,16 @@
 # along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 from pynamicalsys.core.discrete_dynamical_systems import DiscreteDynamicalSystem
+from pynamicalsys.core.continuous_dynamical_systems import ContinuousDynamicalSystem
 from pynamicalsys.core.basin_metrics import BasinMetrics
 from pynamicalsys.core.plot_styler import PlotStyler
 from pynamicalsys.core.time_series_metrics import TimeSeriesMetrics
 from .__version__ import __version__
 
-__all__ = ["DiscreteDynamicalSystem", "PlotStyler", "TimeSeriesMetrics", "BasinMetrics"]
+__all__ = [
+    "DiscreteDynamicalSystem",
+    "ContinuousDynamicalSystem",
+    "PlotStyler",
+    "TimeSeriesMetrics",
+    "BasinMetrics",
+]

pynamicalsys/__version__.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.0.1'
-__version_tuple__ = version_tuple = (1, 0, 1)
+__version__ = version = '1.2.2'
+__version_tuple__ = version_tuple = (1, 2, 2)

pynamicalsys/continuous_time/chaotic_indicators.py

@@ -0,0 +1,347 @@
+# chaotic_indicators.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/>.
+
+from typing import Optional, Callable, Union, Tuple, Dict, List, Any, Sequence
+from numpy.typing import NDArray
+import numpy as np
+from numba import njit, prange
+
+from pynamicalsys.common.utils import qr
+from pynamicalsys.continuous_time.trajectory_analysis import evolve_system
+from pynamicalsys.continuous_time.numerical_integrators import rk4_step_wrapped
+
+
+@njit(cache=True)
+def lyapunov_exponents(
+    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,
+    log_base: float = np.e,
+    QR: Callable[
+        [NDArray[np.float64]], Tuple[NDArray[np.float64], NDArray[np.float64]]
+    ] = qr,
+) -> NDArray[np.float64]:
+
+    neq = len(u)  # Number of equations of the system
+    nt = neq + neq**2  # Total number of equations including 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)
+    v = uv[neq:].reshape(neq, neq)
+    v, _ = QR(v)
+    uv[neq:] = v.reshape(neq**2)
+
+    exponents = np.zeros(neq, dtype=np.float64)
+    history = []
+
+    while time < total_time:
+        if time + time_step > total_time:
+            time_step = total_time - time
+
+        uv_new, time_new, time_step_new, accept = integrator(
+            time,
+            uv,
+            parameters,
+            equations_of_motion,
+            jacobian=jacobian,
+            time_step=time_step,
+        )
+
+        if accept:
+            time = time_new
+            uv = uv_new.copy()
+            #  Reshape the deviation vectors into a neq x neq matrix
+            v = uv[neq:].reshape(neq, neq).copy()
+
+            # Perform the QR decomposition
+            v, R = QR(v)
+
+            # Accumulate the log
+            exponents += np.log(np.abs(np.diag(R))) / np.log(log_base)
+
+            if return_history:
+                result = [time]
+                for i in range(neq):
+                    result.append(
+                        exponents[i]
+                        / (time - (transient_time if transient_time is not None else 0))
+                    )
+                history.append(result)
+
+            # Reshape v back to uv
+            uv[neq:] = v.reshape(neq**2)
+
+        time_step = time_step_new
+
+    if return_history:
+        return history
+    else:
+        result = []
+        for i in range(neq):
+            result.append(
+                exponents[i]
+                / (time - (transient_time if transient_time is not None else 0))
+            )
+        return [result]
+
+
+@njit(cache=True)
+def SALI(
+    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,
+    threshold: float = 1e-16,
+) -> NDArray[np.float64]:
+
+    neq = len(u)  # Number of equations of the system
+    ndv = 2  # Number of deviation vectors
+    nt = neq + neq * ndv  # Total number of equations including 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,
+        )
+        time = transient_time
+    else:
+        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)
+    v = uv[neq:].reshape(neq, ndv)
+    v, _ = qr(v)
+    uv[neq:] = v.reshape(neq * ndv)
+
+    history = []
+
+    while time < total_time:
+        if time + time_step > total_time:
+            time_step = total_time - time
+
+        uv_new, time_new, time_step_new, accept = integrator(
+            time,
+            uv,
+            parameters,
+            equations_of_motion,
+            jacobian=jacobian,
+            time_step=time_step,
+            number_of_deviation_vectors=ndv,
+        )
+
+        if accept:
+            time = time_new
+            uv = uv_new.copy()
+
+            # Reshape the deviation vectors into a neq x ndv matrix
+            v = uv[neq:].reshape(neq, ndv)
+
+            # Normalize the deviation vectors
+            v[:, 0] /= np.linalg.norm(v[:, 0])
+            v[:, 1] /= np.linalg.norm(v[:, 1])
+
+            # Calculate the aligment indexes and SALI
+            PAI = np.linalg.norm(v[:, 0] + v[:, 1])
+            AAI = np.linalg.norm(v[:, 0] - v[:, 1])
+            sali = min(PAI, AAI)
+
+            if return_history:
+                result = [time, sali]
+                history.append(result)
+
+            # Early termination
+            if sali <= threshold:
+                break
+
+            # Reshape v back to uv
+            uv[neq:] = v.reshape(neq * ndv)
+
+        time_step = time_step_new
+
+    if return_history:
+        return history
+    else:
+        return [[time, sali]]
+
+
+# @njit(cache=True)
+def LDI(
+    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]
+    ],
+    number_deviation_vectors: int,
+    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,
+    threshold: float = 1e-16,
+) -> NDArray[np.float64]:
+
+    neq = len(u)  # Number of equations of the system
+    ndv = number_deviation_vectors  # Number of deviation vectors
+    nt = neq + neq * ndv  # Total number of equations including 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,
+        )
+        time = transient_time
+    else:
+        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)
+    v = uv[neq:].reshape(neq, ndv)
+    v, _ = qr(v)
+    uv[neq:] = v.reshape(neq * ndv)
+
+    history = []
+
+    while time < total_time:
+        if time + time_step > total_time:
+            time_step = total_time - time
+
+        uv_new, time_new, time_step_new, accept = integrator(
+            time,
+            uv,
+            parameters,
+            equations_of_motion,
+            jacobian=jacobian,
+            time_step=time_step,
+            number_of_deviation_vectors=ndv,
+        )
+
+        if accept:
+            time = time_new
+            uv = uv_new.copy()
+
+            # Reshape the deviation vectors into a neq x ndv matrix
+            v = uv[neq:].reshape(neq, ndv)
+
+            # Normalize the deviation vectors
+            for i in range(ndv):
+                v[:, i] /= np.linalg.norm(v[:, i])
+
+            # Calculate the singular values
+            S = np.linalg.svd(v, full_matrices=False, compute_uv=False)
+            ldi = np.prod(S)
+
+            if return_history:
+                result = [time, ldi]
+                history.append(result)
+
+            # Early termination
+            if ldi <= threshold:
+                break
+
+            # Reshape v back to uv
+            uv[neq:] = v.reshape(neq * ndv)
+
+        time_step = time_step_new
+
+    if return_history:
+        return history
+    else:
+        return [[time, ldi]]

pynamicalsys/continuous_time/models.py

@@ -0,0 +1,240 @@
+# models.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/>.
+
+from typing import Callable, Optional
+
+import numpy as np
+from numba import njit
+from numpy.typing import NDArray
+
+
+@njit
+def lorenz_system(
+    time: float, u: NDArray[np.float64], parameters: NDArray[np.float64]
+) -> NDArray[np.float64]:
+    sigma, rho, beta = parameters
+    dudt = np.zeros_like(u)
+    dudt[0] = sigma * (u[1] - u[0])
+    dudt[1] = u[0] * (rho - u[2]) - u[1]
+    dudt[2] = u[0] * u[1] - beta * u[2]
+
+    return dudt
+
+
+@njit
+def lorenz_jacobian(
+    time: float, u: NDArray[np.float64], parameters: NDArray[np.float64]
+) -> NDArray[np.float64]:
+
+    sigma, rho, beta = parameters
+
+    J = np.empty((3, 3), dtype=np.float64)
+    J[0, 0] = -sigma
+    J[0, 1] = sigma
+    J[0, 2] = 0.0
+
+    J[1, 0] = rho - u[2]
+    J[1, 1] = -1.0
+    J[1, 2] = -u[0]
+
+    J[2, 0] = u[1]
+    J[2, 1] = u[0]
+    J[2, 2] = -beta
+
+    return J
+
+
+@njit
+def henon_heiles(
+    time: float, u: NDArray[np.float64], parameters: NDArray[np.float64]
+) -> NDArray[np.float64]:
+
+    dudt = np.zeros_like(u)
+
+    dudt[0] = u[2]  # dx / dt = px
+    dudt[1] = u[3]  # dy / dt = py
+    dudt[2] = -u[0] - 2 * u[0] * u[1]  # d(px) / dt = - x - 2xy
+    dudt[3] = -u[1] - u[0] ** 2 + u[1] ** 2  # d(py) / dt = - y - x^2 + y^2
+
+    return dudt
+
+
+@njit
+def henon_heiles_jacobian(
+    time: float, u: NDArray[np.float64], parameters: NDArray[np.float64]
+) -> NDArray[np.float64]:
+
+    neq = len(u)
+    J = np.zeros((neq, neq), dtype=np.float64)
+
+    J[0, 0] = 0
+    J[0, 1] = 0
+    J[0, 2] = 1
+    J[0, 3] = 0
+
+    J[1, 0] = 0
+    J[1, 1] = 0
+    J[1, 2] = 0
+    J[1, 3] = 1
+
+    J[2, 0] = -1 - 2 * u[1]
+    J[2, 1] = -2 * u[0]
+    J[2, 2] = 0
+    J[2, 3] = 0
+
+    J[3, 0] = -2 * u[0]
+    J[3, 1] = -1 + 2 * u[1]
+    J[3, 2] = 0
+    J[3, 3] = 0
+
+    return J
+
+
+@njit
+def rossler_system(
+    time: float, u: NDArray[np.float64], parameters: NDArray[np.float64]
+) -> NDArray[np.float64]:
+
+    a, b, c = parameters
+
+    dudt = np.zeros_like(u)
+
+    dudt[0] = -u[1] - u[2]
+    dudt[1] = u[0] + a * u[1]
+    dudt[2] = b + u[2] * (u[0] - c)
+
+    return dudt
+
+
+@njit
+def rossler_system_jacobian(
+    time: float, u: NDArray[np.float64], parameters: NDArray[np.float64]
+) -> NDArray[np.float64]:
+
+    a, b, c = parameters
+
+    neq = len(u)
+    J = np.zeros((neq, neq), dtype=np.float64)
+
+    J[0, 0] = 0
+    J[0, 1] = -1
+    J[0, 2] = -1
+
+    J[1, 0] = 1
+    J[1, 1] = a
+    J[1, 2] = 0
+
+    J[2, 0] = u[2]
+    J[2, 1] = 0
+    J[2, 2] = u[0] - c
+
+    return J
+
+
+@njit
+def rossler_system_4D(
+    time: float, u: NDArray[np.float64], parameters: NDArray[np.float64]
+) -> NDArray[np.float64]:
+
+    a, b, c, d = parameters
+    x, y, z, w = u
+    dudt = np.zeros_like(u)
+
+    dudt[0] = -(y + z)
+    dudt[1] = x + a * y + w
+    dudt[2] = b + x * z
+    dudt[3] = -c * z + d * w
+
+    return dudt
+
+
+@njit
+def rossler_system_4D_jacobian(
+    time: float, u: NDArray[np.float64], parameters: NDArray[np.float64]
+) -> NDArray[np.float64]:
+
+    a, b, c, d = parameters
+    x, y, z, w = u
+
+    neq = len(u)
+    J = np.zeros((neq, neq), dtype=np.float64)
+
+    J[0, 0] = 0
+    J[0, 1] = -1
+    J[0, 2] = -1
+    J[0, 3] = 0
+
+    J[1, 0] = 1
+    J[1, 1] = a
+    J[1, 2] = 0
+    J[1, 3] = 1
+
+    J[2, 0] = z
+    J[2, 1] = 0
+    J[2, 2] = x
+    J[2, 3] = 0
+
+    J[3, 0] = 0
+    J[3, 1] = 0
+    J[3, 2] = -c
+    J[3, 3] = d
+
+    return J
+
+
+@njit
+def variational_equations(
+    time: float,
+    state: NDArray[np.float64],
+    parameters: NDArray[np.float64],
+    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]
+    ],
+    number_of_deviation_vectors: Optional[int] = None,
+) -> NDArray[np.float64]:
+
+    state = state.copy()
+    nt = len(state)  # Total number of equations
+
+    if number_of_deviation_vectors is not None:
+        ndv = number_of_deviation_vectors
+        neq = round(nt / (1 + ndv))  # Number of system's equation
+    else:
+        neq = round((-1 + np.sqrt(1 + 4 * nt)) / 2)
+        ndv = neq
+
+    # Split the state into state variables, u, and deviation matrix, v
+    u = state[:neq].copy()  # State vector
+    v = state[neq:].reshape(neq, ndv).copy()  # Deviation matrix
+    # Compute the Jacobian matrix
+    J = jacobian(time, u, parameters)
+
+    # Compute system's dynamics
+    dudt = equations_of_motion(time, u, parameters)
+
+    # Variational equation: dvdt = J * v
+    dvdt = J @ v
+
+    # Combine into a single output vector of length nt = neq + neq * ndv
+    dstatedt = np.zeros(nt, dtype=np.float64)
+    dstatedt[:neq] = dudt
+    dstatedt[neq:] = dvdt.reshape(neq * ndv)
+
+    return dstatedt