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

pynamicalsys/__version__.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '1.2.2'
-__version_tuple__ = version_tuple = (1, 2, 2)
+__version__ = version = '1.3.1'
+__version_tuple__ = version_tuple = (1, 3, 1)
+
+__commit_id__ = commit_id = None

pynamicalsys/common/recurrence_quantification_analysis.py

@@ -91,7 +91,7 @@ class RTEConfig:
             raise ValueError("metric must be 'supremum', 'euclidean' or 'manhattan'")
 
 
-@njit(cache=True)
+@njit
 def _recurrence_matrix(
     arr: NDArray[np.float64], threshold: float, metric_id: int
 ) -> NDArray[np.uint8]:

pynamicalsys/common/utils.py

@@ -21,7 +21,7 @@ from numpy.typing import NDArray
 from numba import njit
 
 
-@njit(cache=True)
+@njit
 def qr(M: NDArray[np.float64]) -> Tuple[NDArray[np.float64], NDArray[np.float64]]:
     """
     Perform numerically stable QR decomposition using modified Gram-Schmidt with reorthogonalization.
@@ -92,7 +92,7 @@ def qr(M: NDArray[np.float64]) -> Tuple[NDArray[np.float64], NDArray[np.float64]
     return Q, R
 
 
-@njit(cache=True)
+@njit
 def householder_qr(
     M: NDArray[np.float64],
 ) -> Tuple[NDArray[np.float64], NDArray[np.float64]]:
@@ -184,7 +184,7 @@ def householder_qr(
     return Q, R
 
 
-@njit(cache=True)
+@njit
 def finite_difference_jacobian(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],
@@ -257,7 +257,7 @@ def finite_difference_jacobian(
 
 
 @njit
-def wedge_product_norm(vectors: NDArray[np.float64]) -> float:
+def wedge_norm_2(vectors: NDArray[np.float64]) -> float:
     """
     Computes the norm of the wedge product of n m-dimensional vectors using the Gram determinant.
 
@@ -295,6 +295,25 @@ def wedge_product_norm(vectors: NDArray[np.float64]) -> float:
     return norm
 
 
+def wedge_norm(V: NDArray[np.float64]) -> float:
+    """
+    Computes the norm of the wedge product of k d-dimensional vectors using the Gram determinant.
+
+    Parameters:
+    vectors : NDArray[np.float64]
+        A (d, k) array where d is the dimension and k is the number of vectors.
+
+    Returns:
+    norm : float
+        The norm (magnitude) of the wedge product.
+    """
+    G = V.T @ V  # Gram matrix, shape (k, k)
+
+    det = np.linalg.det(G)
+
+    return 0 if det < 0 else np.sqrt(det)
+
+
 @njit
 def _coeff_mat(x: NDArray[np.float64], deg: int) -> NDArray[np.float64]:
     mat_ = np.zeros(shape=(x.shape[0], deg + 1))
@@ -322,23 +341,3 @@ def fit_poly(
     p = _fit_x(a, y)
     # Reverse order so p[0] is coefficient of highest order
     return p[::-1]
-
-
-if __name__ == "__main__":
-
-    v = np.random.rand(2, 2)
-    w = v.copy()
-
-    q, r = qr(v)
-    print("Q:\n", q)
-    print("R:\n", r)
-    print("QR Product:\n", np.dot(q, r))
-    print("Original Matrix:\n", v)
-
-    print()
-
-    q, r = householder_qr(v)
-    print("Q:\n", q)
-    print("R:\n", r)
-    print("QR Product:\n", np.dot(q, r))
-    print("Original Matrix:\n", v)

pynamicalsys/continuous_time/chaotic_indicators.py

@@ -18,14 +18,14 @@
 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 numba import njit
 
-from pynamicalsys.common.utils import qr
-from pynamicalsys.continuous_time.trajectory_analysis import evolve_system
+from pynamicalsys.common.utils import qr, wedge_norm
+from pynamicalsys.continuous_time.trajectory_analysis import step, evolve_system
 from pynamicalsys.continuous_time.numerical_integrators import rk4_step_wrapped
 
 
-@njit(cache=True)
+# @njit
 def lyapunov_exponents(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],
@@ -36,6 +36,7 @@ def lyapunov_exponents(
     jacobian: Callable[
         [np.float64, NDArray[np.float64], NDArray[np.float64]], NDArray[np.float64]
     ],
+    num_exponents: int,
     transient_time: Optional[float] = None,
     time_step: float = 0.01,
     atol: float = 1e-6,
@@ -50,7 +51,7 @@ def lyapunov_exponents(
 ) -> NDArray[np.float64]:
 
     neq = len(u)  # Number of equations of the system
-    nt = neq + neq**2  # Total number of equations including variational equations
+    nt = neq + neq * num_exponents  # system + variational equations
 
     u = u.copy()
 
@@ -79,57 +80,55 @@ def lyapunov_exponents(
     # 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 = uv[neq:].reshape(neq, num_exponents)
     v, _ = QR(v)
-    uv[neq:] = v.reshape(neq**2)
+    uv[neq:] = v.reshape(neq * num_exponents)
 
-    exponents = np.zeros(neq, dtype=np.float64)
+    exponents = np.zeros(num_exponents, 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(
+        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=num_exponents,
         )
 
-        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()
+        #  Reshape the deviation vectors into a neq x neq matrix
+        v = uv[neq:].reshape(neq, num_exponents).copy()
 
-            # Perform the QR decomposition
-            v, R = QR(v)
+        # Perform the QR decomposition
+        v, R = QR(v)
+        # Accumulate the log
+        exponents += np.log(np.abs(np.diag(R))) / np.log(log_base)
 
-            # Accumulate the log
-            exponents += np.log(np.abs(np.diag(R))) / np.log(log_base)
+        if return_history:
+            result = [time]
+            for i in range(num_exponents):
+                result.append(
+                    exponents[i]
+                    / (time - (transient_time if transient_time is not None else 0))
+                )
+            history.append(result)
 
-            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
+        # Reshape v back to uv
+        uv[neq:] = v.reshape(neq * num_exponents)
 
     if return_history:
         return history
     else:
         result = []
-        for i in range(neq):
+        for i in range(num_exponents):
             result.append(
                 exponents[i]
                 / (time - (transient_time if transient_time is not None else 0))
@@ -137,7 +136,7 @@ def lyapunov_exponents(
         return [result]
 
 
-@njit(cache=True)
+@njit
 def SALI(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],
@@ -197,44 +196,41 @@ def SALI(
         if time + time_step > total_time:
             time_step = total_time - time
 
-        uv_new, time_new, time_step_new, accept = integrator(
+        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=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)
+        # 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])
+        # 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)
+        # 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)
+        if return_history:
+            result = [time, sali]
+            history.append(result)
 
-            # Early termination
-            if sali <= threshold:
-                break
+        # Early termination
+        if sali <= threshold:
+            break
 
-            # Reshape v back to uv
-            uv[neq:] = v.reshape(neq * ndv)
-
-        time_step = time_step_new
+        # Reshape v back to uv
+        uv[neq:] = v.reshape(neq * ndv)
 
     if return_history:
         return history
@@ -242,7 +238,7 @@ def SALI(
         return [[time, sali]]
 
 
-# @njit(cache=True)
+# @njit
 def LDI(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],
@@ -303,45 +299,145 @@ def LDI(
         if time + time_step > total_time:
             time_step = total_time - time
 
-        uv_new, time_new, time_step_new, accept = integrator(
+        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=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.exp(np.sum(np.log(S)))  # LDI is the product of all singular values
+        # Instead of computing prod(S) directly, which could lead to underflows
+        # or overflows, we compute the sum_{i=1}^k log(S_i) and then take the
+        # exponential of this sum.
 
-            # Reshape the deviation vectors into a neq x ndv matrix
-            v = uv[neq:].reshape(neq, ndv)
+        if return_history:
+            result = [time, ldi]
+            history.append(result)
 
-            # Normalize the deviation vectors
-            for i in range(ndv):
-                v[:, i] /= np.linalg.norm(v[:, i])
+        # Early termination
+        if ldi <= threshold:
+            break
 
-            # Calculate the singular values
-            S = np.linalg.svd(v, full_matrices=False, compute_uv=False)
-            ldi = np.prod(S)
+        # Reshape v back to uv
+        uv[neq:] = v.reshape(neq * ndv)
+
+    if return_history:
+        return history
+    else:
+        return [[time, ldi]]
 
-            if return_history:
-                result = [time, ldi]
-                history.append(result)
 
-            # Early termination
-            if ldi <= threshold:
-                break
+def GALI(
+    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]:
 
-            # Reshape v back to uv
-            uv[neq:] = v.reshape(neq * ndv)
+    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
 
-        time_step = time_step_new
+    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, 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=ndv,
+        )
+
+        # 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 GALI
+        gali = wedge_norm(v)
+
+        if return_history:
+            result = [time, gali]
+            history.append(result)
+
+        # Early termination
+        if gali <= threshold:
+            break
+
+        # Reshape v back to uv
+        uv[neq:] = v.reshape(neq * ndv)
 
     if return_history:
         return history
     else:
-        return [[time, ldi]]
+        return [[time, gali]]

pynamicalsys/continuous_time/numerical_integrators.py

@@ -23,7 +23,7 @@ from numba import njit, prange
 from pynamicalsys.continuous_time.models import variational_equations
 
 
-@njit(cache=True)
+@njit
 def rk4_step(
     t: float,
     u: NDArray[np.float64],
@@ -43,7 +43,7 @@ def rk4_step(
     return u_next
 
 
-@njit(cache=True)
+@njit
 def variational_rk4_step(
     t: float,
     u: NDArray[np.float64],
@@ -115,7 +115,7 @@ RK45_B4 = np.array(
 )
 
 
-@njit(cache=True)
+@njit
 def rk45_step(t, u, parameters, equations_of_motion, time_step, atol=1e-6, rtol=1e-3):
     """Single adaptive step of RK45 (Dormand-Prince).
 
@@ -163,7 +163,7 @@ def rk45_step(t, u, parameters, equations_of_motion, time_step, atol=1e-6, rtol=
     return u5, t + time_step, time_step_new, accept
 
 
-@njit(cache=True)
+@njit
 def variational_rk45_step(
     t,
     u,
@@ -227,7 +227,7 @@ def variational_rk45_step(
     return u5, t + time_step, time_step_new, accept
 
 
-@njit(cache=True)
+@njit
 def rk4_step_wrapped(
     t: float,
     u: NDArray[np.float64],
@@ -237,7 +237,7 @@ def rk4_step_wrapped(
     ],
     jacobian=None,
     time_step: float = 0.01,
-    number_of_deviation_vectors=None,
+    number_of_deviation_vectors: Optional[int] = None,
     atol: float = 1e-6,  # unused, just to match signature
     rtol: float = 1e-3,  # unused, just to match signature
 ) -> tuple[NDArray[np.float64], float, float, bool]:
@@ -265,7 +265,7 @@ def rk4_step_wrapped(
     return u_next, t_next, h_next, accept
 
 
-@njit(cache=True)
+@njit
 def rk45_step_wrapped(
     t: float,
     u: NDArray[np.float64],
@@ -302,7 +302,7 @@ def rk45_step_wrapped(
         )
 
 
-@njit(cache=True)
+@njit
 def estimate_initial_step(
     t0: float,
     u0: np.ndarray,