nrl-tracker 0.22.2__py3-none-any.whl → 0.22.4__py3-none-any.whl

pytcl/mathematical_functions/signal_processing/detection.py

@@ -410,7 +410,8 @@ def _cfar_2d_ca_kernel(
             for ri in range(row_min, row_max):
                 for ci in range(col_min, col_max):
                     if not (
-                        guard_row_min <= ri < guard_row_max and guard_col_min <= ci < guard_col_max
+                        guard_row_min <= ri < guard_row_max
+                        and guard_col_min <= ci < guard_col_max
                     ):
                         ref_sum += image[ri, ci]
                         n_cells += 1
@@ -459,7 +460,8 @@ def _cfar_2d_go_kernel(
             for ri in range(row_min, row_max):
                 for ci in range(col_min, col_max):
                     if not (
-                        guard_row_min <= ri < guard_row_max and guard_col_min <= ci < guard_col_max
+                        guard_row_min <= ri < guard_row_max
+                        and guard_col_min <= ci < guard_col_max
                     ):
                         if ri < i:
                             top_sum += image[ri, ci]
@@ -510,7 +512,8 @@ def _cfar_2d_so_kernel(
             for ri in range(row_min, row_max):
                 for ci in range(col_min, col_max):
                     if not (
-                        guard_row_min <= ri < guard_row_max and guard_col_min <= ci < guard_col_max
+                        guard_row_min <= ri < guard_row_max
+                        and guard_col_min <= ci < guard_col_max
                     ):
                         if ri < i:
                             top_sum += image[ri, ci]

pytcl/mathematical_functions/signal_processing/filters.py

@@ -606,9 +606,13 @@ def filtfilt(
 
     if isinstance(coeffs, FilterCoefficients):
         if coeffs.sos is not None:
-            return scipy_signal.sosfiltfilt(coeffs.sos, x, padtype=padtype, padlen=padlen)
+            return scipy_signal.sosfiltfilt(
+                coeffs.sos, x, padtype=padtype, padlen=padlen
+            )
         else:
-            return scipy_signal.filtfilt(coeffs.b, coeffs.a, x, padtype=padtype, padlen=padlen)
+            return scipy_signal.filtfilt(
+                coeffs.b, coeffs.a, x, padtype=padtype, padlen=padlen
+            )
     elif isinstance(coeffs, tuple) and len(coeffs) == 2:
         b, a = coeffs
         return scipy_signal.filtfilt(b, a, x, padtype=padtype, padlen=padlen)

pytcl/mathematical_functions/signal_processing/matched_filter.py

@@ -590,7 +590,8 @@ def _ambiguity_function_kernel(
                     for k in range(n_signal - delay_samples):
                         s1 = signal[k]
                         s2_conj = (
-                            shifted[delay_samples + k].real - 1j * shifted[delay_samples + k].imag
+                            shifted[delay_samples + k].real
+                            - 1j * shifted[delay_samples + k].imag
                         )
                         result += s1 * s2_conj
 
@@ -637,7 +638,8 @@ def _cross_ambiguity_kernel(
                     for k in range(n_signal - delay_samples):
                         s1 = signal1[k]
                         s2_conj = (
-                            shifted[delay_samples + k].real - 1j * shifted[delay_samples + k].imag
+                            shifted[delay_samples + k].real
+                            - 1j * shifted[delay_samples + k].imag
                         )
                         result += s1 * s2_conj
 

pytcl/mathematical_functions/special_functions/elliptic.py

@@ -243,7 +243,9 @@ def elliprg(x: ArrayLike, y: ArrayLike, z: ArrayLike) -> NDArray[np.floating]:
     return np.asarray(sp.elliprg(x, y, z), dtype=np.float64)
 
 
-def elliprj(x: ArrayLike, y: ArrayLike, z: ArrayLike, p: ArrayLike) -> NDArray[np.floating]:
+def elliprj(
+    x: ArrayLike, y: ArrayLike, z: ArrayLike, p: ArrayLike
+) -> NDArray[np.floating]:
     """
     Carlson symmetric elliptic integral R_J.
 

pytcl/mathematical_functions/special_functions/gamma_functions.py

@@ -421,7 +421,9 @@ def comb(
     --------
     scipy.special.comb : Combinations.
     """
-    return np.asarray(sp.comb(n, k, exact=exact, repetition=repetition), dtype=np.float64)
+    return np.asarray(
+        sp.comb(n, k, exact=exact, repetition=repetition), dtype=np.float64
+    )
 
 
 def perm(n: ArrayLike, k: ArrayLike, exact: bool = False) -> NDArray:

pytcl/mathematical_functions/special_functions/lambert_w.py

@@ -108,7 +108,9 @@ def lambert_w_real(
             raise ValueError(f"For branch 0, x must be >= -1/e ≈ {branch_point:.6f}")
     elif branch == -1:
         if np.any((x < branch_point) | (x >= 0)):
-            raise ValueError(f"For branch -1, x must be in [-1/e, 0) ≈ [{branch_point:.6f}, 0)")
+            raise ValueError(
+                f"For branch -1, x must be in [-1/e, 0) ≈ [{branch_point:.6f}, 0)"
+            )
     else:
         raise ValueError(f"branch must be 0 or -1, got {branch}")
 

pytcl/mathematical_functions/statistics/distributions.py

@@ -43,7 +43,9 @@ class Distribution(ABC):
         pass
 
     @abstractmethod
-    def sample(self, size: Optional[Union[int, Tuple[int, ...]]] = None) -> NDArray[np.floating]:
+    def sample(
+        self, size: Optional[Union[int, Tuple[int, ...]]] = None
+    ) -> NDArray[np.floating]:
         """Generate random samples."""
         pass
 
@@ -102,7 +104,9 @@ class Gaussian(Distribution):
     def ppf(self, q: ArrayLike) -> NDArray[np.floating]:
         return np.asarray(self._dist.ppf(q), dtype=np.float64)
 
-    def sample(self, size: Optional[Union[int, Tuple[int, ...]]] = None) -> NDArray[np.floating]:
+    def sample(
+        self, size: Optional[Union[int, Tuple[int, ...]]] = None
+    ) -> NDArray[np.floating]:
         return np.asarray(self._dist.rvs(size=size), dtype=np.float64)
 
     def mean(self) -> float:
@@ -163,7 +167,9 @@ class MultivariateGaussian(Distribution):
     def ppf(self, q: ArrayLike) -> NDArray[np.floating]:
         raise NotImplementedError("PPF not available for multivariate normal")
 
-    def sample(self, size: Optional[Union[int, Tuple[int, ...]]] = None) -> NDArray[np.floating]:
+    def sample(
+        self, size: Optional[Union[int, Tuple[int, ...]]] = None
+    ) -> NDArray[np.floating]:
         return np.asarray(self._dist.rvs(size=size), dtype=np.float64)
 
     def mean(self) -> NDArray[np.floating]:
@@ -233,7 +239,9 @@ class Uniform(Distribution):
     def ppf(self, q: ArrayLike) -> NDArray[np.floating]:
         return np.asarray(self._dist.ppf(q), dtype=np.float64)
 
-    def sample(self, size: Optional[Union[int, Tuple[int, ...]]] = None) -> NDArray[np.floating]:
+    def sample(
+        self, size: Optional[Union[int, Tuple[int, ...]]] = None
+    ) -> NDArray[np.floating]:
         return np.asarray(self._dist.rvs(size=size), dtype=np.float64)
 
     def mean(self) -> float:
@@ -271,7 +279,9 @@ class Exponential(Distribution):
     def ppf(self, q: ArrayLike) -> NDArray[np.floating]:
         return np.asarray(self._dist.ppf(q), dtype=np.float64)
 
-    def sample(self, size: Optional[Union[int, Tuple[int, ...]]] = None) -> NDArray[np.floating]:
+    def sample(
+        self, size: Optional[Union[int, Tuple[int, ...]]] = None
+    ) -> NDArray[np.floating]:
         return np.asarray(self._dist.rvs(size=size), dtype=np.float64)
 
     def mean(self) -> float:
@@ -337,7 +347,9 @@ class Gamma(Distribution):
     def ppf(self, q: ArrayLike) -> NDArray[np.floating]:
         return np.asarray(self._dist.ppf(q), dtype=np.float64)
 
-    def sample(self, size: Optional[Union[int, Tuple[int, ...]]] = None) -> NDArray[np.floating]:
+    def sample(
+        self, size: Optional[Union[int, Tuple[int, ...]]] = None
+    ) -> NDArray[np.floating]:
         return np.asarray(self._dist.rvs(size=size), dtype=np.float64)
 
     def mean(self) -> float:
@@ -375,7 +387,9 @@ class ChiSquared(Distribution):
     def ppf(self, q: ArrayLike) -> NDArray[np.floating]:
         return np.asarray(self._dist.ppf(q), dtype=np.float64)
 
-    def sample(self, size: Optional[Union[int, Tuple[int, ...]]] = None) -> NDArray[np.floating]:
+    def sample(
+        self, size: Optional[Union[int, Tuple[int, ...]]] = None
+    ) -> NDArray[np.floating]:
         return np.asarray(self._dist.rvs(size=size), dtype=np.float64)
 
     def mean(self) -> float:
@@ -422,7 +436,9 @@ class StudentT(Distribution):
     def ppf(self, q: ArrayLike) -> NDArray[np.floating]:
         return np.asarray(self._dist.ppf(q), dtype=np.float64)
 
-    def sample(self, size: Optional[Union[int, Tuple[int, ...]]] = None) -> NDArray[np.floating]:
+    def sample(
+        self, size: Optional[Union[int, Tuple[int, ...]]] = None
+    ) -> NDArray[np.floating]:
         return np.asarray(self._dist.rvs(size=size), dtype=np.float64)
 
     def mean(self) -> float:
@@ -469,7 +485,9 @@ class Beta(Distribution):
     def ppf(self, q: ArrayLike) -> NDArray[np.floating]:
         return np.asarray(self._dist.ppf(q), dtype=np.float64)
 
-    def sample(self, size: Optional[Union[int, Tuple[int, ...]]] = None) -> NDArray[np.floating]:
+    def sample(
+        self, size: Optional[Union[int, Tuple[int, ...]]] = None
+    ) -> NDArray[np.floating]:
         return np.asarray(self._dist.rvs(size=size), dtype=np.float64)
 
     def mean(self) -> float:
@@ -510,7 +528,9 @@ class Poisson(Distribution):
     def ppf(self, q: ArrayLike) -> NDArray[np.floating]:
         return np.asarray(self._dist.ppf(q), dtype=np.float64)
 
-    def sample(self, size: Optional[Union[int, Tuple[int, ...]]] = None) -> NDArray[np.floating]:
+    def sample(
+        self, size: Optional[Union[int, Tuple[int, ...]]] = None
+    ) -> NDArray[np.floating]:
         return np.asarray(self._dist.rvs(size=size), dtype=np.float64)
 
     def mean(self) -> float:
@@ -553,7 +573,9 @@ class VonMises(Distribution):
     def ppf(self, q: ArrayLike) -> NDArray[np.floating]:
         return np.asarray(self._dist.ppf(q), dtype=np.float64)
 
-    def sample(self, size: Optional[Union[int, Tuple[int, ...]]] = None) -> NDArray[np.floating]:
+    def sample(
+        self, size: Optional[Union[int, Tuple[int, ...]]] = None
+    ) -> NDArray[np.floating]:
         return np.asarray(self._dist.rvs(size=size), dtype=np.float64)
 
     def mean(self) -> float:
@@ -606,7 +628,9 @@ class Wishart(Distribution):
     def ppf(self, q: ArrayLike) -> NDArray[np.floating]:
         raise NotImplementedError("PPF not available for Wishart distribution")
 
-    def sample(self, size: Optional[Union[int, Tuple[int, ...]]] = None) -> NDArray[np.floating]:
+    def sample(
+        self, size: Optional[Union[int, Tuple[int, ...]]] = None
+    ) -> NDArray[np.floating]:
         return np.asarray(self._dist.rvs(size=size), dtype=np.float64)
 
     def mean(self) -> NDArray[np.floating]:

pytcl/mathematical_functions/statistics/estimators.py

@@ -364,7 +364,9 @@ def kurtosis(
     """
     from scipy.stats import kurtosis as scipy_kurtosis
 
-    return np.asarray(scipy_kurtosis(x, axis=axis, fisher=fisher, bias=bias), dtype=np.float64)
+    return np.asarray(
+        scipy_kurtosis(x, axis=axis, fisher=fisher, bias=bias), dtype=np.float64
+    )
 
 
 def moment(

pytcl/mathematical_functions/transforms/stft.py

@@ -503,8 +503,12 @@ def reassigned_spectrogram(
     win_d = np.gradient(win)
 
     # STFT with modified windows
-    result_t = stft(x, fs=fs, window=win_t, nperseg=nperseg, noverlap=noverlap, nfft=nfft)
-    result_d = stft(x, fs=fs, window=win_d, nperseg=nperseg, noverlap=noverlap, nfft=nfft)
+    result_t = stft(
+        x, fs=fs, window=win_t, nperseg=nperseg, noverlap=noverlap, nfft=nfft
+    )
+    result_d = stft(
+        x, fs=fs, window=win_d, nperseg=nperseg, noverlap=noverlap, nfft=nfft
+    )
 
     # Compute reassigned coordinates
     Zxx = result1.Zxx
@@ -588,7 +592,9 @@ def mel_spectrogram(
         noverlap = nperseg // 4
 
     # Compute linear spectrogram
-    spec_result = spectrogram(x, fs=fs, window=window, nperseg=nperseg, noverlap=noverlap)
+    spec_result = spectrogram(
+        x, fs=fs, window=window, nperseg=nperseg, noverlap=noverlap
+    )
 
     # Create mel filterbank
     mel_fb = _mel_filterbank(

pytcl/mathematical_functions/transforms/wavelets.py

@@ -526,7 +526,9 @@ def dwt(
     - 'biorN.M': Biorthogonal wavelets
     """
     if not PYWT_AVAILABLE:
-        raise ImportError("pywavelets is required for DWT. Install with: pip install pywavelets")
+        raise ImportError(
+            "pywavelets is required for DWT. Install with: pip install pywavelets"
+        )
 
     signal = np.asarray(signal, dtype=np.float64)
 
@@ -577,7 +579,9 @@ def idwt(
     True
     """
     if not PYWT_AVAILABLE:
-        raise ImportError("pywavelets is required for IDWT. Install with: pip install pywavelets")
+        raise ImportError(
+            "pywavelets is required for IDWT. Install with: pip install pywavelets"
+        )
 
     # Reconstruct coeffs list in pywt format
     # [cA_n, cD_n, cD_n-1, ..., cD_1]
@@ -613,7 +617,9 @@ def dwt_single_level(
         Detail coefficients.
     """
     if not PYWT_AVAILABLE:
-        raise ImportError("pywavelets is required for DWT. Install with: pip install pywavelets")
+        raise ImportError(
+            "pywavelets is required for DWT. Install with: pip install pywavelets"
+        )
 
     signal = np.asarray(signal, dtype=np.float64)
     cA, cD = pywt.dwt(signal, wavelet, mode=mode)
@@ -647,7 +653,9 @@ def idwt_single_level(
         Reconstructed signal.
     """
     if not PYWT_AVAILABLE:
-        raise ImportError("pywavelets is required for IDWT. Install with: pip install pywavelets")
+        raise ImportError(
+            "pywavelets is required for IDWT. Install with: pip install pywavelets"
+        )
 
     cA = np.asarray(cA, dtype=np.float64)
     cD = np.asarray(cD, dtype=np.float64)
@@ -701,7 +709,9 @@ def wpt(
     True
     """
     if not PYWT_AVAILABLE:
-        raise ImportError("pywavelets is required for WPT. Install with: pip install pywavelets")
+        raise ImportError(
+            "pywavelets is required for WPT. Install with: pip install pywavelets"
+        )
 
     signal = np.asarray(signal, dtype=np.float64)
 
@@ -807,7 +817,9 @@ def threshold_coefficients(
         Thresholded coefficients.
     """
     if not PYWT_AVAILABLE:
-        raise ImportError("pywavelets is required. Install with: pip install pywavelets")
+        raise ImportError(
+            "pywavelets is required. Install with: pip install pywavelets"
+        )
 
     # Estimate noise from finest detail coefficients
     if value is None:

pytcl/navigation/geodesy.py

@@ -356,7 +356,9 @@ def ned_to_ecef(
     x, y, z : ndarray
         ECEF coordinates in meters.
     """
-    return enu_to_ecef(east, north, -np.asarray(down), lat_ref, lon_ref, alt_ref, ellipsoid)
+    return enu_to_ecef(
+        east, north, -np.asarray(down), lat_ref, lon_ref, alt_ref, ellipsoid
+    )
 
 
 def direct_geodetic(
@@ -434,7 +436,11 @@ def direct_geodetic(
                 / 4
                 * (
                     cos_sigma * (-1 + 2 * cos_2sigma_m**2)
-                    - B / 6 * cos_2sigma_m * (-3 + 4 * sin_sigma**2) * (-3 + 4 * cos_2sigma_m**2)
+                    - B
+                    / 6
+                    * cos_2sigma_m
+                    * (-3 + 4 * sin_sigma**2)
+                    * (-3 + 4 * cos_2sigma_m**2)
                 )
             )
         )
@@ -452,20 +458,27 @@ def direct_geodetic(
     lat2 = np.arctan2(
         sin_U2,
         (1 - f)
-        * np.sqrt(sin_alpha**2 + (sin_U1 * sin_sigma - cos_U1 * cos_sigma * cos_alpha1) ** 2),
+        * np.sqrt(
+            sin_alpha**2 + (sin_U1 * sin_sigma - cos_U1 * cos_sigma * cos_alpha1) ** 2
+        ),
     )
 
-    lam = np.arctan2(sin_sigma * sin_alpha1, cos_U1 * cos_sigma - sin_U1 * sin_sigma * cos_alpha1)
+    lam = np.arctan2(
+        sin_sigma * sin_alpha1, cos_U1 * cos_sigma - sin_U1 * sin_sigma * cos_alpha1
+    )
 
     C = f / 16 * cos2_alpha * (4 + f * (4 - 3 * cos2_alpha))
     L = lam - (1 - C) * f * sin_alpha * (
-        sigma + C * sin_sigma * (cos_2sigma_m + C * cos_sigma * (-1 + 2 * cos_2sigma_m**2))
+        sigma
+        + C * sin_sigma * (cos_2sigma_m + C * cos_sigma * (-1 + 2 * cos_2sigma_m**2))
     )
 
     lon2 = lon1 + L
 
     # Back azimuth
-    azimuth2 = np.arctan2(sin_alpha, -sin_U1 * sin_sigma + cos_U1 * cos_sigma * cos_alpha1)
+    azimuth2 = np.arctan2(
+        sin_alpha, -sin_U1 * sin_sigma + cos_U1 * cos_sigma * cos_alpha1
+    )
 
     return float(lat2), float(lon2), float(azimuth2)
 
@@ -552,7 +565,10 @@ def inverse_geodetic(
         C = f / 16 * cos2_alpha * (4 + f * (4 - 3 * cos2_alpha))
 
         lam_new = L + (1 - C) * f * sin_alpha * (
-            sigma + C * sin_sigma * (cos_2sigma_m + C * cos_sigma * (-1 + 2 * cos_2sigma_m**2))
+            sigma
+            + C
+            * sin_sigma
+            * (cos_2sigma_m + C * cos_sigma * (-1 + 2 * cos_2sigma_m**2))
         )
 
         if abs(lam_new - lam) < 1e-12:
@@ -572,7 +588,11 @@ def inverse_geodetic(
             / 4
             * (
                 cos_sigma * (-1 + 2 * cos_2sigma_m**2)
-                - B / 6 * cos_2sigma_m * (-3 + 4 * sin_sigma**2) * (-3 + 4 * cos_2sigma_m**2)
+                - B
+                / 6
+                * cos_2sigma_m
+                * (-3 + 4 * sin_sigma**2)
+                * (-3 + 4 * cos_2sigma_m**2)
             )
         )
     )
@@ -581,7 +601,9 @@ def inverse_geodetic(
 
     # Azimuths
     azimuth1 = np.arctan2(cos_U2 * sin_lam, cos_U1 * sin_U2 - sin_U1 * cos_U2 * cos_lam)
-    azimuth2 = np.arctan2(cos_U1 * sin_lam, -sin_U1 * cos_U2 + cos_U1 * sin_U2 * cos_lam)
+    azimuth2 = np.arctan2(
+        cos_U1 * sin_lam, -sin_U1 * cos_U2 + cos_U1 * sin_U2 * cos_lam
+    )
 
     return float(distance), float(azimuth1), float(azimuth2)
 

pytcl/navigation/great_circle.py

@@ -344,7 +344,9 @@ def great_circle_direct(
     """
     d = distance / radius  # Angular distance
 
-    lat2 = np.arcsin(np.sin(lat1) * np.cos(d) + np.cos(lat1) * np.sin(d) * np.cos(azimuth))
+    lat2 = np.arcsin(
+        np.sin(lat1) * np.cos(d) + np.cos(lat1) * np.sin(d) * np.cos(azimuth)
+    )
 
     lon2 = lon1 + np.arctan2(
         np.sin(azimuth) * np.sin(d) * np.cos(lat1),
@@ -406,7 +408,9 @@ def cross_track_distance(
     # Along-track distance
     dat = np.arccos(np.cos(d13) / np.cos(dxt))
 
-    return CrossTrackResult(cross_track=float(dxt * radius), along_track=float(dat * radius))
+    return CrossTrackResult(
+        cross_track=float(dxt * radius), along_track=float(dat * radius)
+    )
 
 
 def great_circle_intersect(
@@ -448,7 +452,9 @@ def great_circle_intersect(
 
     # Convert to Cartesian unit vectors
     def to_cartesian(lat, lon):
-        return np.array([np.cos(lat) * np.cos(lon), np.cos(lat) * np.sin(lon), np.sin(lat)])
+        return np.array(
+            [np.cos(lat) * np.cos(lon), np.cos(lat) * np.sin(lon), np.sin(lat)]
+        )
 
     # Normal vectors to the great circles
     p1 = to_cartesian(lat1, lon1)
@@ -502,7 +508,9 @@ def great_circle_intersect(
     lat_i2 = -lat_i1
     lon_i2 = ((lon_i1 + np.pi) % (2 * np.pi)) - np.pi
 
-    return IntersectionResult(float(lat_i1), float(lon_i1), float(lat_i2), float(lon_i2), True)
+    return IntersectionResult(
+        float(lat_i1), float(lon_i1), float(lat_i2), float(lon_i2), True
+    )
 
 
 def great_circle_path_intersect(

pytcl/navigation/ins.py

@@ -244,7 +244,11 @@ def normal_gravity(lat: float, alt: float = 0.0) -> float:
 
     # Free-air correction (first-order)
     g = g0 * (
-        1 - 2 * alt / A_EARTH * (1 + F_EARTH + (OMEGA_EARTH**2 * A_EARTH**2 * B_EARTH) / GM_EARTH)
+        1
+        - 2
+        * alt
+        / A_EARTH
+        * (1 + F_EARTH + (OMEGA_EARTH**2 * A_EARTH**2 * B_EARTH) / GM_EARTH)
     )
 
     return g
@@ -568,7 +572,9 @@ def update_quaternion(
 
     if angle < 1e-10:
         # Small angle approximation
-        delta_q = np.array([1.0, 0.5 * delta_theta[0], 0.5 * delta_theta[1], 0.5 * delta_theta[2]])
+        delta_q = np.array(
+            [1.0, 0.5 * delta_theta[0], 0.5 * delta_theta[1], 0.5 * delta_theta[2]]
+        )
     else:
         # Exact quaternion for rotation
         axis = delta_theta / angle

pytcl/navigation/ins_gnss.py

@@ -512,7 +512,9 @@ def loose_coupled_predict(
     dt = imu.dt
 
     # Propagate INS mechanization
-    ins_new = mechanize_ins_ned(state.ins_state, imu, accel_prev=accel_prev, gyro_prev=gyro_prev)
+    ins_new = mechanize_ins_ned(
+        state.ins_state, imu, accel_prev=accel_prev, gyro_prev=gyro_prev
+    )
 
     # Get error state transition matrix (continuous-time)
     F_cont = ins_error_state_matrix(state.ins_state)
@@ -574,7 +576,9 @@ def loose_coupled_update_position(
     if gnss.position_cov is not None:
         R = gnss.position_cov
     else:
-        R = np.diag([10.0**2, 10.0**2, 15.0**2])  # Default: 10m horizontal, 15m vertical
+        R = np.diag(
+            [10.0**2, 10.0**2, 15.0**2]
+        )  # Default: 10m horizontal, 15m vertical
 
     # Innovation: measured position - INS predicted position
     z = gnss.position - state.ins_state.position
@@ -691,8 +695,16 @@ def loose_coupled_update(
         # Full position + velocity update
         H = position_velocity_measurement_matrix()
 
-        R_pos = gnss.position_cov if gnss.position_cov is not None else np.diag([10.0**2] * 3)
-        R_vel = gnss.velocity_cov if gnss.velocity_cov is not None else np.diag([0.1**2] * 3)
+        R_pos = (
+            gnss.position_cov
+            if gnss.position_cov is not None
+            else np.diag([10.0**2] * 3)
+        )
+        R_vel = (
+            gnss.velocity_cov
+            if gnss.velocity_cov is not None
+            else np.diag([0.1**2] * 3)
+        )
         R = np.block([[R_pos, np.zeros((3, 3))], [np.zeros((3, 3)), R_vel]])
 
         z = np.concatenate(
@@ -834,7 +846,9 @@ def tight_coupled_measurement_matrix(
         los, _ = compute_line_of_sight(user_ecef, sat.position)
 
         # LOS components in ECEF
-        los_x, los_y, los_z = -los  # Negative because increase in user pos decreases range
+        los_x, los_y, los_z = (
+            -los
+        )  # Negative because increase in user pos decreases range
 
         # Transform LOS to geodetic derivatives
         # d(range)/d(lat), d(range)/d(lon), d(range)/d(alt)
@@ -844,7 +858,9 @@ def tight_coupled_measurement_matrix(
             + los_z * (cos_lat * N * (1 - ellipsoid.e2))
         )
         H[i, 1] = los_x * (-cos_lat * sin_lon * N) + los_y * (cos_lat * cos_lon * N)
-        H[i, 2] = los_x * cos_lat * cos_lon + los_y * cos_lat * sin_lon + los_z * sin_lat
+        H[i, 2] = (
+            los_x * cos_lat * cos_lon + los_y * cos_lat * sin_lon + los_z * sin_lat
+        )
 
         # Clock bias (state 15)
         H[i, 15] = 1.0
@@ -975,7 +991,9 @@ def _apply_error_correction(
 
     # Apply small angle rotation to quaternion
     q = ins_state.quaternion
-    delta_q = np.array([1.0, 0.5 * phi[0], 0.5 * phi[1], 0.5 * phi[2]], dtype=np.float64)
+    delta_q = np.array(
+        [1.0, 0.5 * phi[0], 0.5 * phi[1], 0.5 * phi[2]], dtype=np.float64
+    )
     delta_q = delta_q / np.linalg.norm(delta_q)
 
     # Quaternion multiplication (body frame correction)

pytcl/navigation/rhumb.py

@@ -100,7 +100,9 @@ def _isometric_latitude(lat: float, e2: float = 0.0) -> float:
         )
 
 
-def _inverse_isometric_latitude(psi: float, e2: float = 0.0, max_iter: int = 20) -> float:
+def _inverse_isometric_latitude(
+    psi: float, e2: float = 0.0, max_iter: int = 20
+) -> float:
     """
     Compute geodetic latitude from isometric latitude.
 
@@ -129,7 +131,10 @@ def _inverse_isometric_latitude(psi: float, e2: float = 0.0, max_iter: int = 20)
         for _ in range(max_iter):
             sin_lat = np.sin(lat)
             lat_new = (
-                2 * np.arctan(((1 + e * sin_lat) / (1 - e * sin_lat)) ** (e / 2) * np.exp(psi))
+                2
+                * np.arctan(
+                    ((1 + e * sin_lat) / (1 - e * sin_lat)) ** (e / 2) * np.exp(psi)
+                )
                 - np.pi / 2
             )
             if abs(lat_new - lat) < 1e-12:
@@ -422,7 +427,9 @@ def indirect_rhumb(
     if abs(dlon) > np.pi:
         dlon = dlon - np.sign(dlon) * 2 * np.pi
 
-    dpsi = _isometric_latitude(lat2, ellipsoid.e2) - _isometric_latitude(lat1, ellipsoid.e2)
+    dpsi = _isometric_latitude(lat2, ellipsoid.e2) - _isometric_latitude(
+        lat1, ellipsoid.e2
+    )
     bearing = np.arctan2(dlon, dpsi) % (2 * np.pi)
 
     return RhumbResult(distance, bearing)

pytcl/performance_evaluation/track_metrics.py

@@ -158,7 +158,9 @@ def ospa(
     loc_component = (localization_sum / n) ** (1.0 / p) if localization_sum > 0 else 0.0
     card_component = (cardinality_penalty / n) ** (1.0 / p) if n > m else 0.0
 
-    return OSPAResult(ospa=ospa_val, localization=loc_component, cardinality=card_component)
+    return OSPAResult(
+        ospa=ospa_val, localization=loc_component, cardinality=card_component
+    )
 
 
 def ospa_over_time(

pytcl/plotting/coordinates.py

@@ -181,13 +181,19 @@ def plot_euler_angles(
 
     # Create rotation matrices for each axis
     def rotx(a):
-        return np.array([[1, 0, 0], [0, np.cos(a), -np.sin(a)], [0, np.sin(a), np.cos(a)]])
+        return np.array(
+            [[1, 0, 0], [0, np.cos(a), -np.sin(a)], [0, np.sin(a), np.cos(a)]]
+        )
 
     def roty(a):
-        return np.array([[np.cos(a), 0, np.sin(a)], [0, 1, 0], [-np.sin(a), 0, np.cos(a)]])
+        return np.array(
+            [[np.cos(a), 0, np.sin(a)], [0, 1, 0], [-np.sin(a), 0, np.cos(a)]]
+        )
 
     def rotz(a):
-        return np.array([[np.cos(a), -np.sin(a), 0], [np.sin(a), np.cos(a), 0], [0, 0, 1]])
+        return np.array(
+            [[np.cos(a), -np.sin(a), 0], [np.sin(a), np.cos(a), 0], [0, 0, 1]]
+        )
 
     rot_funcs = {"X": rotx, "Y": roty, "Z": rotz}
 
@@ -241,7 +247,11 @@ def plot_euler_angles(
     for i in range(4):
         scene_name = f"scene{i + 1}" if i > 0 else "scene"
         fig.update_layout(
-            **{scene_name: dict(aspectmode="cube", camera=dict(eye=dict(x=1.5, y=1.5, z=1.5)))}
+            **{
+                scene_name: dict(
+                    aspectmode="cube", camera=dict(eye=dict(x=1.5, y=1.5, z=1.5))
+                )
+            }
         )
 
     return fig
@@ -368,7 +378,9 @@ def plot_quaternion_interpolation(
                         method="animate",
                         args=[
                             [None],
-                            dict(frame=dict(duration=0, redraw=False), mode="immediate"),
+                            dict(
+                                frame=dict(duration=0, redraw=False), mode="immediate"
+                            ),
                         ],
                     ),
                 ],