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

pynamicalsys/discrete_time/dynamical_indicators.py

@@ -29,10 +29,10 @@ from pynamicalsys.discrete_time.trajectory_analysis import (
     iterate_mapping,
     generate_trajectory,
 )
-from pynamicalsys.common.utils import qr, householder_qr, fit_poly
+from pynamicalsys.common.utils import qr, householder_qr, fit_poly, wedge_norm
 
 
-@njit(cache=True)
+@njit
 def lyapunov_1D(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],
@@ -41,8 +41,9 @@ def lyapunov_1D(
     derivative_mapping: Callable[
         [NDArray[np.float64], NDArray[np.float64], Callable], NDArray[np.float64]
     ],
+    num_exponents: int,  # Added just to match signature
+    sample_times: Union[NDArray[np.int32], NDArray[np.int64]],
     return_history: bool = False,
-    sample_times: Optional[NDArray[np.int32]] = None,
     transient_time: Optional[int] = None,
     log_base: float = np.e,
 ) -> Union[NDArray[np.float64], float]:
@@ -64,10 +65,10 @@ def lyapunov_1D(
         Function defining the system's evolution: `u_next = mapping(u, parameters)`.
     derivative_mapping : Callable[[NDArray, NDArray, Callable], NDArray]
         Function returning the derivative of `mapping` (Jacobian for 1D systems).
+    sample_times: Union[NDArray[np.int32], NDArray[np.int64]],
+        Specific time steps to record the exponent (if `return_history=True`).
     return_history : bool, optional
         If True, returns the Lyapunov exponent estimate at each step (default: False).
-    sample_times : Optional[NDArray[np.int32]], optional
-        Specific time steps to record the exponent (if `return_history=True`).
     transient_time : Optional[int], optional
         Number of initial iterations to discard as transient (default: None).
     log_base : float, optional
@@ -96,33 +97,30 @@ def lyapunov_1D(
         sample_size = total_time
 
     # Initialize history tracking
-    exponent = 0.0
     if return_history:
-        if sample_times is not None:
-            if sample_times.max() > sample_size:
-                raise ValueError("sample_times must be ≤ total_time")
-            history = np.zeros(len(sample_times))
-            count = 0
-        else:
-            history = np.zeros(sample_size)
+        if sample_times.max() > sample_size:
+            raise ValueError("sample_times must be ≤ total_time - transient_time")
+        history = np.zeros(len(sample_times))
 
-    # Main computation loop
-    for i in range(1, sample_size + 1):
-        u = mapping(u, parameters)
-        du = derivative_mapping(u, parameters, mapping)
-        exponent += np.log(np.abs(du[0, 0])) / np.log(log_base)
+    sample_idx = 0
+    exponent = 0.0
+    prev_i = 0
+    for st in sample_times:
+        steps = st - prev_i
+        for _ in range(steps):
+            u = mapping(u, parameters)
+            du = derivative_mapping(u, parameters, mapping)
+            exponent += np.log(np.abs(du[0, 0])) / np.log(log_base)
 
         if return_history:
-            if sample_times is None:
-                history[i - 1] = exponent / i
-            elif i in sample_times:
-                history[count] = exponent / i
-                count += 1
+            history[sample_idx] = exponent / st
+            sample_idx += 1
+        prev_i = st
 
     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],
@@ -131,8 +129,9 @@ def lyapunov_er(
     jacobian: Callable[
         [NDArray[np.float64], NDArray[np.float64], Callable], NDArray[np.float64]
     ],
+    num_exponents: int,  # Added just to match signature
+    sample_times: Union[NDArray[np.int32], NDArray[np.int64]],
     return_history: bool = False,
-    sample_times: Optional[NDArray[np.int32]] = None,
     transient_time: Optional[int] = None,
     log_base: float = np.e,
 ) -> Tuple[NDArray[np.float64], NDArray[np.float64]]:
@@ -154,10 +153,10 @@ def lyapunov_er(
         System evolution function: `u_next = mapping(u, parameters)`.
     jacobian : Callable[[NDArray, NDArray, Callable], NDArray]
         Function returning the Jacobian matrix (shape: `(2, 2)`).
+    sample_times: Union[NDArray[np.int32], NDArray[np.int64]],
+        Specific time steps to record exponents (if `return_history=True`).
     return_history : bool, optional
         If True, returns exponent convergence history (default: False).
-    sample_times : Optional[NDArray[np.int32]], optional
-        Specific time steps to record exponents (if `return_history=True`).
     transient_time : Optional[int], optional
         Number of initial iterations to discard as transient (default: None).
     log_base : float, optional
@@ -202,44 +201,41 @@ def lyapunov_er(
 
     # Initialize history tracking
     if return_history:
-        if sample_times is not None:
-            if sample_times.max() > sample_size:
-                raise ValueError("sample_times must be ≤ total_time")
-            history = np.zeros((len(sample_times), neq))
-            count = 0
-        else:
-            history = np.zeros((sample_size, neq))
+        if sample_times.max() > sample_size:
+            raise ValueError("sample_times must be ≤ total_time - transient_time")
+        history = np.zeros((len(sample_times), neq))
 
+    sample_idx = 0
     eigvals = np.zeros(neq)
-    # Main computation loop
-    for i in range(1, sample_size + 1):
-        u_contig = mapping(u_contig, parameters)
-        J = jacobian(u_contig, parameters, mapping)
-
-        # Compute new rotation angle
-        cb0, sb0 = np.cos(beta0), np.sin(beta0)
-        beta = np.arctan2(-J[1, 0] * cb0 + J[1, 1] * sb0, J[0, 0] * cb0 - J[0, 1] * sb0)
-
-        # Transformation matrix elements
-        cb, sb = np.cos(beta), np.sin(beta)
-        eigvals[0] = (J[0, 0] * cb - J[1, 0] * sb) * cb0 - (
-            J[0, 1] * cb - J[1, 1] * sb
-        ) * sb0
-        eigvals[1] = (J[0, 0] * sb + J[1, 0] * cb) * sb0 + (
-            J[0, 1] * sb + J[1, 1] * cb
-        ) * cb0
-
-        exponents += np.log(np.abs(eigvals)) / np.log(log_base)
-
-        # Record history if requested
-        if return_history:
-            if sample_times is None:
-                history[i - 1] = exponents / i
-            elif i in sample_times:
-                history[count] = exponents / i
-                count += 1
+    log_base_inv = 1.0 / np.log(log_base)
+    prev_i = 0
+    for st in sample_times:
+        steps = st - prev_i
+        for _ in range(steps):
+            u_contig = mapping(u_contig, parameters)
+            J = jacobian(u_contig, parameters, mapping)
 
-        beta0 = beta  # Update angle for next iteration
+            cb0, sb0 = np.cos(beta0), np.sin(beta0)
+            beta = np.arctan2(
+                -J[1, 0] * cb0 + J[1, 1] * sb0, J[0, 0] * cb0 - J[0, 1] * sb0
+            )
+
+            cb, sb = np.cos(beta), np.sin(beta)
+            eigvals[0] = (J[0, 0] * cb - J[1, 0] * sb) * cb0 - (
+                J[0, 1] * cb - J[1, 1] * sb
+            ) * sb0
+            eigvals[1] = (J[0, 0] * sb + J[1, 0] * cb) * sb0 + (
+                J[0, 1] * sb + J[1, 1] * cb
+            ) * cb0
+
+            exponents += np.log(np.abs(eigvals)) * log_base_inv
+
+            beta0 = beta
+
+        if return_history:
+            history[sample_idx] = exponents / st
+            sample_idx += 1
+        prev_i = st
 
     # Format output
     if return_history:
@@ -250,7 +246,128 @@ def lyapunov_er(
         return aux_exponents, u_contig
 
 
-@njit(cache=True)
+@njit
+def maximum_lyapunov_er(
+    u: NDArray[np.float64],
+    parameters: NDArray[np.float64],
+    total_time: int,
+    mapping: Callable[[NDArray[np.float64], NDArray[np.float64]], NDArray[np.float64]],
+    jacobian: Callable[
+        [NDArray[np.float64], NDArray[np.float64], Callable], NDArray[np.float64]
+    ],
+    num_exponents: int,  # Added just to match signature
+    sample_times: Union[NDArray[np.int32], NDArray[np.int64]],
+    return_history: bool = False,
+    transient_time: Optional[int] = None,
+    log_base: float = np.e,
+) -> Tuple[NDArray[np.float64], NDArray[np.float64]]:
+    """
+    Compute the maximum Lyapunov exponent using the Eckmann-Ruelle (ER) method for 2D systems.
+
+    This method tracks the evolution of perturbations via continuous QR decomposition
+    using rotational angles, providing numerically stable exponent estimates.
+
+    Parameters
+    ----------
+    u : NDArray[np.float64]
+        Initial state vector (shape: `(2,)` for 2D systems).
+    parameters : NDArray[np.float64]
+        System parameters passed to `mapping` and `jacobian`.
+    total_time : int
+        Total number of iterations (time steps) to compute.
+    mapping : Callable[[NDArray, NDArray], NDArray]
+        System evolution function: `u_next = mapping(u, parameters)`.
+    jacobian : Callable[[NDArray, NDArray, Callable], NDArray]
+        Function returning the Jacobian matrix (shape: `(2, 2)`).
+    sample_times: Union[NDArray[np.int32], NDArray[np.int64]],
+        Specific time steps to record exponents (if `return_history=True`).
+    return_history : bool, optional
+        If True, returns exponent convergence history (default: False).
+    transient_time : Optional[int], optional
+        Number of initial iterations to discard as transient (default: None).
+    log_base : float, optional
+        Logarithm base for exponent calculation (default: e).
+
+    Returns
+    -------
+    Tuple[NDArray[np.float64], NDArray[np.float64]]
+        - If `return_history=True`:
+            - `history`: Array of exponent estimates (shape: `(sample_size, 2)` or `(len(sample_times), 2)`)
+            - `final_state`: System state at termination (shape: `(2,)`)
+        - If `return_history=False`:
+            - `exponents`: Final Lyapunov exponents (shape: `(2, 1)`)
+            - `final_state`: System state at termination (shape: `(2,)`)
+
+    Notes
+    -----
+    - **Method**: Uses rotation angles for continuous QR decomposition [1].
+    - **Stability**: More robust than Gram-Schmidt for 2D systems.
+    - **Limitation**: Designed specifically for 2D maps (`neq=2`).
+    - **Numerics**: Exponents are averaged as:
+        λ_i = (1/N) Σ log|T_ii|, where T is the transformation matrix.
+
+    References
+    ----------
+    [1] J. Eckmann & D. Ruelle, "Ergodic theory of chaos and strange attractors",
+        Rev. Mod. Phys. 57, 617 (1985).
+    """
+
+    neq = len(u)
+    exponent = 0.0
+    beta0 = 0.0  # Initial rotation angle
+    u_contig = np.ascontiguousarray(u)
+
+    # Handle transient time
+    if transient_time is not None:
+        sample_size = total_time - transient_time
+        for _ in range(transient_time):
+            u_contig = mapping(u_contig, parameters)
+    else:
+        sample_size = total_time
+
+    # Initialize history tracking
+    if return_history:
+        if sample_times.max() > sample_size:
+            raise ValueError("sample_times must be ≤ total_time - transient_time")
+        history = np.zeros(len(sample_times))
+
+    sample_idx = 0
+    eigval = 0.0
+    log_base_inv = 1.0 / np.log(log_base)
+    prev_i = 0
+    for st in sample_times:
+        steps = st - prev_i
+        for _ in range(steps):
+            u_contig = mapping(u_contig, parameters)
+            J = jacobian(u_contig, parameters, mapping)
+
+            cb0, sb0 = np.cos(beta0), np.sin(beta0)
+            beta = np.arctan2(
+                -J[1, 0] * cb0 + J[1, 1] * sb0, J[0, 0] * cb0 - J[0, 1] * sb0
+            )
+
+            cb, sb = np.cos(beta), np.sin(beta)
+            eigval = (J[0, 0] * cb - J[1, 0] * sb) * cb0 - (
+                J[0, 1] * cb - J[1, 1] * sb
+            ) * sb0
+
+            exponent += np.log(np.abs(eigval)) * log_base_inv
+
+            beta0 = beta
+
+        if return_history:
+            history[sample_idx] = exponent / st
+            sample_idx += 1
+        prev_i = st
+
+    # Format output
+    if return_history:
+        return history, u_contig
+    else:
+        return np.array([exponent / sample_size]), u_contig
+
+
+@njit
 def lyapunov_qr(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],
@@ -259,13 +376,15 @@ def lyapunov_qr(
     jacobian: Callable[
         [NDArray[np.float64], NDArray[np.float64], Callable], NDArray[np.float64]
     ],
+    num_exponents: int,
+    sample_times: Union[NDArray[np.int32], NDArray[np.int64]],
     QR: Callable[
         [NDArray[np.float64]], Tuple[NDArray[np.float64], NDArray[np.float64]]
     ] = qr,
     return_history: bool = False,
-    sample_times: Optional[NDArray[np.int32]] = None,
     transient_time: Optional[int] = None,
     log_base: float = np.e,
+    seed: int = 13,
 ) -> Tuple[NDArray[np.float64], NDArray[np.float64]]:
     """
     Compute Lyapunov exponents using QR decomposition (Gram-Schmidt) for N-dimensional systems.
@@ -320,11 +439,11 @@ def lyapunov_qr(
         Physica D 16D, 285-317 (1985).
     """
 
+    np.random.seed(seed)
     neq = len(u)
-    v = np.ascontiguousarray(np.random.rand(neq, neq))
-    v = np.ascontiguousarray(np.eye(neq))
+    v = np.ascontiguousarray(np.random.rand(neq, num_exponents))
     v, _ = qr(v)  # Initialize orthonormal vectors
-    exponents = np.zeros(neq)
+    exponents = np.zeros(num_exponents)
     u_contig = np.ascontiguousarray(u.copy())
 
     # Handle transient time
@@ -337,38 +456,34 @@ def lyapunov_qr(
 
     # Initialize history tracking
     if return_history:
-        if sample_times is not None:
-            if sample_times.max() > sample_size:
-                raise ValueError("sample_times must be ≤ total_time")
-            history = np.zeros((len(sample_times), neq))
-            count = 0
-        else:
-            history = np.zeros((sample_size, neq))
-
-    # Main computation loop
-    for j in range(1, sample_size + 1):
-        u_contig = mapping(u_contig, parameters)
-        J = np.ascontiguousarray(jacobian(u_contig, parameters, mapping))
-
-        # Evolve and orthogonalize vectors
-        for i in range(neq):
-            v[:, i] = np.ascontiguousarray(J) @ np.ascontiguousarray(v[:, i])
-        v, R = QR(v)
-        exponents += np.log(np.abs(np.diag(R))) / np.log(log_base)
+        if sample_times.max() > sample_size:
+            raise ValueError("sample_times must be ≤ total_time - transient_time")
+        history = np.zeros((len(sample_times), num_exponents))
+
+    sample_idx = 0
+    log_base_inv = 1.0 / np.log(log_base)
+    prev_i = 0
+    for st in sample_times:
+        steps = st - prev_i
+        for _ in range(steps):
+            u_contig = mapping(u_contig, parameters)
+            J = np.ascontiguousarray(jacobian(u_contig, parameters, mapping))
+            # Evolve and orthogonalize vectors
+            for i in range(num_exponents):
+                v[:, i] = np.ascontiguousarray(J) @ np.ascontiguousarray(v[:, i])
+            v, R = QR(v)
+            exponents += np.log(np.abs(np.diag(R))) * log_base_inv
 
-        # Record history if requested
         if return_history:
-            if sample_times is None:
-                history[j - 1] = exponents / j
-            elif j in sample_times:
-                history[count] = exponents / j
-                count += 1
+            history[sample_idx] = exponents / st
+            sample_idx += 1
+        prev_i = st
 
     # Format output
     if return_history:
         return history, u_contig
     else:
-        aux_exponents = np.zeros((neq, 1))
+        aux_exponents = np.zeros((num_exponents, 1))
         aux_exponents[:, 0] = exponents / sample_size
         return aux_exponents, u_contig
 
@@ -382,6 +497,7 @@ def finite_time_lyapunov(
     jacobian: Callable[
         [NDArray[np.float64], NDArray[np.float64], Callable], NDArray[np.float64]
     ],
+    num_exponents: int,
     method: str = "QR",
     transient_time: Optional[int] = None,
     log_base: float = np.e,
@@ -451,18 +567,43 @@ def finite_time_lyapunov(
 
     neq = len(u)
     num_windows = sample_size // finite_time
-    exponents = np.zeros((num_windows, neq))
+    exponents = np.zeros((num_windows, num_exponents))
     phase_space_points = np.zeros((num_windows, neq))
-
+    sample_times = np.arange(finite_time)
     # Compute exponents for each window
     for i in range(num_windows):
-        if method == "ER":
+        if num_exponents == 1 and method == "ER":
+            window_exponents, u_new = maximum_lyapunov_er(
+                u,
+                parameters,
+                finite_time,
+                mapping,
+                jacobian,
+                num_exponents,
+                sample_times,
+                log_base=log_base,
+            )
+        elif num_exponents > 1 and method == "ER":
             window_exponents, u_new = lyapunov_er(
-                u, parameters, finite_time, mapping, jacobian, log_base=log_base
+                u,
+                parameters,
+                finite_time,
+                mapping,
+                jacobian,
+                num_exponents,
+                sample_times,
+                log_base=log_base,
             )
         elif method == "QR":
             window_exponents, u_new = lyapunov_qr(
-                u, parameters, finite_time, mapping, jacobian, log_base=log_base
+                u,
+                parameters,
+                finite_time,
+                mapping,
+                jacobian,
+                num_exponents,
+                sample_times,
+                log_base=log_base,
             )
         elif method == "QR_HH":
             window_exponents, u_new = lyapunov_qr(
@@ -471,6 +612,8 @@ def finite_time_lyapunov(
                 finite_time,
                 mapping,
                 jacobian,
+                num_exponents,
+                sample_times,
                 QR=householder_qr,
                 log_base=log_base,
             )
@@ -558,7 +701,7 @@ def dig(
     return -np.log10(abs(WB0 - WB1))
 
 
-@njit(cache=True)
+@njit
 def SALI(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],
@@ -567,8 +710,8 @@ def SALI(
     jacobian: Callable[
         [NDArray[np.float64], NDArray[np.float64], Callable], NDArray[np.float64]
     ],
+    sample_times: Union[NDArray[np.int32], NDArray[np.int64]],
     return_history: bool = False,
-    sample_times: Optional[NDArray[np.int32]] = None,
     tol: float = 1e-16,
     transient_time: Optional[int] = None,
     seed: int = 13,
@@ -591,10 +734,10 @@ def SALI(
         Function representing the system's time evolution: `u_next = mapping(u, parameters)`.
     jacobian : Callable[[NDArray, NDArray, Callable], NDArray]
         Function computing the Jacobian matrix of `mapping` at state `u`.
+    sample_times: Union[NDArray[np.int32], NDArray[np.int64]],
+        Specific time steps at which to record SALI (if `return_history=True`). Must be sorted.
     return_history : bool, optional
         If True, return SALI values at each time step (or `sample_times`). Default: False.
-    sample_times : Optional[NDArray[np.int32]], optional
-        Specific time steps at which to record SALI (if `return_history=True`). Must be sorted.
     tol : float, optional
         Tolerance for early stopping if SALI < `tol` (default: 1e-16).
     transient_time : Optional[int], optional
@@ -618,7 +761,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
@@ -639,48 +782,158 @@ def SALI(
 
     # Initialize history tracking
     if return_history:
-        if sample_times is not None:
-            if sample_times.max() > sample_size:
-                raise ValueError("Maximum sample time must be ≤ total_time.")
-            history = np.zeros(len(sample_times))
-            count = 0
-        else:
-            history = np.zeros(sample_size)
-
-    # Main evolution loop
-    for j in range(sample_size):
-        u = mapping(u, parameters)
-        J = np.ascontiguousarray(jacobian(u, parameters, mapping))
+        if sample_times.max() > sample_size:
+            raise ValueError("sample_times must be ≤ total_time - transient_time")
+        history = np.zeros(len(sample_times))
+
+    sample_idx = 0
+    prev_i = 0
+    for st in sample_times:
+        steps = st - prev_i
+        for _ in range(steps):
+            u = mapping(u, parameters)
+            J = np.ascontiguousarray(jacobian(u, parameters, mapping))
 
-        # Update deviation vectors
-        for i in range(2):
-            v[:, i] = np.ascontiguousarray(J) @ np.ascontiguousarray(v[:, i])
-            v[:, i] /= np.linalg.norm(v[:, i])
+            for i in range(2):
+                v[:, i] = np.ascontiguousarray(J) @ np.ascontiguousarray(v[:, i])
+                v[:, i] /= np.linalg.norm(v[:, i])
 
-        # Compute SALI
-        PAI = np.linalg.norm(v[:, 0] + v[:, 1])
-        AAI = np.linalg.norm(v[:, 0] - v[:, 1])
-        sali_val = min(PAI, AAI)
+            # Compute SALI
+            PAI = np.linalg.norm(v[:, 0] + v[:, 1])
+            AAI = np.linalg.norm(v[:, 0] - v[:, 1])
+            sali_val = min(PAI, AAI)
 
-        # Record history if requested
         if return_history:
-            if sample_times is None:
-                history[j] = sali_val
-            elif (j + 1) in sample_times:
-                history[count] = sali_val
-                count += 1
+            history[sample_idx] = sali_val
+            sample_idx += 1
+        prev_i = st
 
-        # Early termination
         if sali_val < tol:
             break
 
     return history if return_history else np.array([sali_val])
 
 
-# @njit(cache=True)
+def LDI_k(
+    u: NDArray[np.float64],
+    parameters: NDArray[np.float64],
+    total_time: int,
+    mapping: Callable[[NDArray[np.float64], NDArray[np.float64]], NDArray[np.float64]],
+    jacobian: Callable[
+        [NDArray[np.float64], NDArray[np.float64], Callable], NDArray[np.float64]
+    ],
+    k: int,
+    sample_times: Union[NDArray[np.int32], NDArray[np.int64]],
+    return_history: bool = False,
+    tol: float = 1e-16,
+    transient_time: Optional[int] = None,
+    seed: int = 13,
+) -> Union[NDArray[np.float64], Tuple[NDArray[np.float64], NDArray[np.float64]]]:
+    """
+    Compute the linear dependence index (LDI) for a dynamical system.
 
+    LDI is a measure of chaos in dynamical systems, calculated using the evolution
+    of `k` initially orthonormal deviation vectors under the system's Jacobian.
 
-def LDI_k(
+    Parameters
+    ----------
+    u : NDArray[np.float64]
+        Initial state vector of the system (shape: `(neq,)`).
+    parameters : NDArray[np.float64]
+        System parameters (shape: arbitrary, passed to `mapping` and `jacobian`).
+    total_time : int
+        Total number of iterations (time steps) to simulate.
+    mapping : Callable[[NDArray, NDArray], NDArray]
+        Function representing the system's time evolution (maps state `u` to next state).
+    jacobian : Callable[[NDArray, NDArray, Callable], NDArray]
+        Function computing the Jacobian matrix of `mapping` at state `u`.
+    k : int
+        Number of deviation vectors to track.
+    sample_times: Union[NDArray[np.int32], NDArray[np.int64]],
+        Specific time steps at which to record LDI (if `return_history=True`).
+    return_history : bool, optional
+        If True, return GALI values at each time step (or `sample_times`). Default: False.
+    tol : float, optional
+        Tolerance for early stopping if GALI drops below this value (default: 1e-16).
+    transient_time : Optional[int], optional
+        Number of initial iterations to discard as transient (default: None).
+    seed : int, optional
+        Random seed for reproducibility (default 13)
+
+    Returns
+    -------
+    Union[NDArray[np.float64], Tuple[NDArray[np.float64], NDArray[np.float64]]]
+        - If `return_history=False`: Final LDI value (shape: `(1,)`).
+        - If `return_history=True`: Array of LDI values at each sampled time.
+
+    Raises
+    ------
+    ValueError
+        If `sample_times` contains values exceeding `total_time`.
+
+    Notes
+    -----
+    - Early termination occurs if LDI < `tol` (indicating chaotic behavior).
+    """
+
+    np.random.seed(seed)  # For reproducibility
+
+    neq = len(u)
+
+    # Generate random orthonormal deviation vectors
+    v = np.ascontiguousarray(np.random.rand(neq, k))
+    v, _ = qr(v)
+
+    if transient_time is not None:
+        # Discard transient time
+        sample_size = total_time - transient_time
+        for i in range(transient_time):
+            u = mapping(u, parameters)
+    else:
+        sample_size = total_time
+
+    # Initialize history tracking
+    if return_history:
+        if sample_times.max() > sample_size:
+            raise ValueError("sample_times must be ≤ total_time - transient_time")
+        history = np.zeros(len(sample_times))
+
+    sample_idx = 0
+    prev_j = 0
+    for st in sample_times:
+        steps = st - prev_j
+        for _ in range(steps):
+            u = mapping(u, parameters)
+            J = np.ascontiguousarray(jacobian(u, parameters, mapping))
+
+            # Update deviation vectors
+            for i in range(k):
+                v[:, i] = np.ascontiguousarray(J) @ np.ascontiguousarray(v[:, i])
+                v[:, i] = v[:, i] / np.linalg.norm(v[:, i])
+
+            # Compute LDI
+            S = np.linalg.svd(v, full_matrices=False, compute_uv=False)
+            # ldi = np.prod(S)  # LDI is the product of the singular values
+            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.
+
+        if return_history:
+            history[sample_idx] = ldi
+            sample_idx += 1
+        prev_j = st
+
+        if ldi < tol:
+            break
+
+    if return_history:
+        return history
+    else:
+        return np.array([ldi])
+
+
+def GALI_k(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],
     total_time: int,
@@ -688,15 +941,15 @@ def LDI_k(
     jacobian: Callable[
         [NDArray[np.float64], NDArray[np.float64], Callable], NDArray[np.float64]
     ],
-    k: int = 2,
+    k: int,
+    sample_times: Union[NDArray[np.int32], NDArray[np.int64]],
     return_history: bool = False,
-    sample_times: Optional[NDArray[np.int32]] = None,
     tol: float = 1e-16,
     transient_time: Optional[int] = None,
     seed: int = 13,
 ) -> Union[NDArray[np.float64], Tuple[NDArray[np.float64], NDArray[np.float64]]]:
     """
-    Compute the Generalized Alignment Index (GALI) for a dynamical system.
+    Compute the Generalized Aligment Index (GALI) for a dynamical system.
 
     GALI is a measure of chaos in dynamical systems, calculated using the evolution
     of `k` initially orthonormal deviation vectors under the system's Jacobian.
@@ -713,12 +966,12 @@ def LDI_k(
         Function representing the system's time evolution (maps state `u` to next state).
     jacobian : Callable[[NDArray, NDArray, Callable], NDArray]
         Function computing the Jacobian matrix of `mapping` at state `u`.
-    k : int, optional
-        Number of deviation vectors to track (default: 2).
+    k : int
+        Number of deviation vectors to track.
+    sample_times: Union[NDArray[np.int32], NDArray[np.int64]],
+        Specific time steps at which to record LDI (if `return_history=True`).
     return_history : bool, optional
         If True, return GALI values at each time step (or `sample_times`). Default: False.
-    sample_times : Optional[NDArray[np.int32]], optional
-        Specific time steps at which to record GALI (if `return_history=True`).
     tol : float, optional
         Tolerance for early stopping if GALI drops below this value (default: 1e-16).
     transient_time : Optional[int], optional
@@ -739,9 +992,7 @@ def LDI_k(
 
     Notes
     -----
-    - The function uses QR decomposition to maintain orthonormality of deviation vectors.
     - Early termination occurs if GALI < `tol` (indicating chaotic behavior).
-    - For performance, the function is optimized with `@njit(cache=True)`.
     """
 
     np.random.seed(seed)  # For reproducibility
@@ -760,39 +1011,32 @@ def LDI_k(
     else:
         sample_size = total_time
 
+    # Initialize history tracking
     if return_history:
-        if sample_times is not None:
-            if sample_times.max() > sample_size:
-                raise ValueError(
-                    "Maximum sample time should be smaller than the total time."
-                )
-            count = 0
-            history = np.zeros(len(sample_times))
-        else:
-            history = np.zeros(sample_size)
-
-    for j in range(sample_size):
-        # Update the state
-        u = mapping(u, parameters)
-
-        # Compute the Jacobian
-        J = np.ascontiguousarray(jacobian(u, parameters, mapping))
+        if sample_times.max() > sample_size:
+            raise ValueError("sample_times must be ≤ total_time - transient_time")
+        history = np.zeros(len(sample_times))
+
+    sample_idx = 0
+    prev_j = 0
+    for st in sample_times:
+        steps = st - prev_j
+        for _ in range(steps):
+            u = mapping(u, parameters)
+            J = np.ascontiguousarray(jacobian(u, parameters, mapping))
 
-        # Update deviation vectors
-        for i in range(k):
-            v[:, i] = np.ascontiguousarray(J) @ np.ascontiguousarray(v[:, i])
-            v[:, i] = v[:, i] / np.linalg.norm(v[:, i])
+            # Update deviation vectors
+            for i in range(k):
+                v[:, i] = np.ascontiguousarray(J) @ np.ascontiguousarray(v[:, i])
+                v[:, i] = v[:, i] / np.linalg.norm(v[:, i])
 
-        # Compute GALI
-        S = np.linalg.svd(v, full_matrices=False, compute_uv=False)
-        gali = np.prod(S)  # GALI is the product of the singular values
+            # Compute GALI
+            gali = wedge_norm(v)
 
         if return_history:
-            if sample_times is None:
-                history[j] = gali
-            elif (j + 1) in sample_times:
-                history[count] = gali
-                count += 1
+            history[sample_idx] = gali
+            sample_idx += 1
+        prev_j = st
 
         if gali < tol:
             break
@@ -803,7 +1047,7 @@ def LDI_k(
         return np.array([gali])
 
 
-@njit(cache=True)
+@njit
 def hurst_exponent(
     u: NDArray[np.float64],
     parameters: NDArray[np.float64],
@@ -980,13 +1224,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],