nrl-tracker 0.21.5__py3-none-any.whl → 0.22.1__py3-none-any.whl

pytcl/magnetism/emm.py

@@ -531,8 +531,7 @@ def _high_res_field_spherical(
                     factor = np.sqrt((n - m) * (n + m + 1))
                     if m + 1 <= n:
                         dP[n, m] = (
-                            n * cos_theta / sin_theta * P[n, m]
-                            - factor * P[n, m + 1] / sin_theta
+                            n * cos_theta / sin_theta * P[n, m] - factor * P[n, m + 1] / sin_theta
                             if m + 1 <= n_max_eval
                             else n * cos_theta / sin_theta * P[n, m]
                         )
@@ -559,13 +558,7 @@ def _high_res_field_spherical(
             B_theta += -r_power * dP[n, m] * (gnm * cos_m_lon + hnm * sin_m_lon)
 
             if abs(sin_theta) > 1e-10:
-                B_phi += (
-                    r_power
-                    * m
-                    * P[n, m]
-                    / sin_theta
-                    * (gnm * sin_m_lon - hnm * cos_m_lon)
-                )
+                B_phi += r_power * m * P[n, m] / sin_theta * (gnm * sin_m_lon - hnm * cos_m_lon)
 
     return B_r, B_theta, B_phi
 
@@ -624,9 +617,7 @@ def emm(
     r = a + h
 
     # Compute field in spherical coordinates
-    B_r, B_theta, B_phi = _high_res_field_spherical(
-        lat_gc, lon, r, year, coefficients, n_max
-    )
+    B_r, B_theta, B_phi = _high_res_field_spherical(lat_gc, lon, r, year, coefficients, n_max)
 
     # Convert to geodetic coordinates
     X = -B_theta  # North

pytcl/magnetism/wmm.py

@@ -468,8 +468,7 @@ def magnetic_field_spherical(
                     factor = np.sqrt((n - m) * (n + m + 1))
                     if m + 1 <= n:
                         dP[n, m] = (
-                            n * cos_theta / sin_theta * P[n, m]
-                            - factor * P[n, m + 1] / sin_theta
+                            n * cos_theta / sin_theta * P[n, m] - factor * P[n, m + 1] / sin_theta
                             if m + 1 <= n_max
                             else n * cos_theta / sin_theta * P[n, m]
                         )
@@ -499,13 +498,7 @@ def magnetic_field_spherical(
             B_theta += -r_power * dP[n, m] * (gnm * cos_m_lon + hnm * sin_m_lon)
 
             if abs(sin_theta) > 1e-10:
-                B_phi += (
-                    r_power
-                    * m
-                    * P[n, m]
-                    / sin_theta
-                    * (gnm * sin_m_lon - hnm * cos_m_lon)
-                )
+                B_phi += r_power * m * P[n, m] / sin_theta * (gnm * sin_m_lon - hnm * cos_m_lon)
 
     return B_r, B_theta, B_phi
 

pytcl/mathematical_functions/basic_matrix/decompositions.py

@@ -160,9 +160,7 @@ def tria_sqrt(
     if B is not None:
         B = np.asarray(B, dtype=np.float64)
         if A.shape[0] != B.shape[0]:
-            raise ValueError(
-                f"A and B must have same number of rows: {A.shape[0]} vs {B.shape[0]}"
-            )
+            raise ValueError(f"A and B must have same number of rows: {A.shape[0]} vs {B.shape[0]}")
         combined = np.hstack([A, B])
     else:
         combined = A

pytcl/mathematical_functions/combinatorics/combinatorics.py

@@ -378,9 +378,7 @@ def partitions(n: int, k: Optional[int] = None) -> Iterator[Tuple[int, ...]]:
     [(4,), (3, 1), (2, 2), (2, 1, 1), (1, 1, 1, 1)]
     """
 
-    def gen_partitions(
-        n: int, max_val: int, prefix: Tuple[int, ...]
-    ) -> Iterator[Tuple[int, ...]]:
+    def gen_partitions(n: int, max_val: int, prefix: Tuple[int, ...]) -> Iterator[Tuple[int, ...]]:
         if n == 0:
             yield prefix
             return

pytcl/mathematical_functions/geometry/geometry.py

@@ -191,12 +191,8 @@ def polygon_centroid(vertices: ArrayLike) -> NDArray[np.floating]:
 
     # Centroid
     factor = 1.0 / (3.0 * a)
-    cx = factor * np.sum(
-        (x + np.roll(x, -1)) * (x * np.roll(y, -1) - np.roll(x, -1) * y)
-    )
-    cy = factor * np.sum(
-        (y + np.roll(y, -1)) * (x * np.roll(y, -1) - np.roll(x, -1) * y)
-    )
+    cx = factor * np.sum((x + np.roll(x, -1)) * (x * np.roll(y, -1) - np.roll(x, -1) * y))
+    cy = factor * np.sum((y + np.roll(y, -1)) * (x * np.roll(y, -1) - np.roll(x, -1) * y))
 
     return np.array([cx, cy], dtype=np.float64)
 
@@ -551,14 +547,10 @@ def minimum_bounding_circle(
                 return circle_from_two_points(p1, p3)
 
         ux = (
-            (ax**2 + ay**2) * (by - cy)
-            + (bx**2 + by**2) * (cy - ay)
-            + (cx**2 + cy**2) * (ay - by)
+            (ax**2 + ay**2) * (by - cy) + (bx**2 + by**2) * (cy - ay) + (cx**2 + cy**2) * (ay - by)
         ) / d
         uy = (
-            (ax**2 + ay**2) * (cx - bx)
-            + (bx**2 + by**2) * (ax - cx)
-            + (cx**2 + cy**2) * (bx - ax)
+            (ax**2 + ay**2) * (cx - bx) + (bx**2 + by**2) * (ax - cx) + (cx**2 + cy**2) * (bx - ax)
         ) / d
 
         center = np.array([ux, uy])

pytcl/mathematical_functions/interpolation/__init__.py

@@ -8,8 +8,8 @@ This module provides:
 - Spherical interpolation
 """
 
-from pytcl.mathematical_functions.interpolation.interpolation import (  # noqa: E501
-    akima,
+from pytcl.mathematical_functions.interpolation.interpolation import akima  # noqa: E501
+from pytcl.mathematical_functions.interpolation.interpolation import (
     barycentric,
     cubic_spline,
     interp1d,

pytcl/mathematical_functions/interpolation/interpolation.py

@@ -371,9 +371,7 @@ def rbf_interpolate(
     points = np.asarray(points, dtype=np.float64)
     values = np.asarray(values, dtype=np.float64)
 
-    return interpolate.RBFInterpolator(
-        points, values, kernel=kernel, smoothing=smoothing
-    )
+    return interpolate.RBFInterpolator(points, values, kernel=kernel, smoothing=smoothing)
 
 
 def barycentric(

pytcl/mathematical_functions/signal_processing/detection.py

@@ -410,8 +410,7 @@ 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
@@ -460,8 +459,7 @@ 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]
@@ -512,8 +510,7 @@ 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,13 +606,9 @@ 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,8 +590,7 @@ 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
 
@@ -638,8 +637,7 @@ 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/__init__.py

@@ -40,8 +40,8 @@ from pytcl.mathematical_functions.special_functions.debye import (
     debye_entropy,
     debye_heat_capacity,
 )
-from pytcl.mathematical_functions.special_functions.elliptic import (  # noqa: E501
-    ellipe,
+from pytcl.mathematical_functions.special_functions.elliptic import ellipe  # noqa: E501
+from pytcl.mathematical_functions.special_functions.elliptic import (
     ellipeinc,
     ellipk,
     ellipkinc,

pytcl/mathematical_functions/special_functions/elliptic.py

@@ -243,9 +243,7 @@ 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,9 +421,7 @@ 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,9 +108,7 @@ 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,9 +43,7 @@ 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
 
@@ -104,9 +102,7 @@ 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:
@@ -167,9 +163,7 @@ 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]:
@@ -239,9 +233,7 @@ 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:
@@ -279,9 +271,7 @@ 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:
@@ -347,9 +337,7 @@ 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:
@@ -387,9 +375,7 @@ 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:
@@ -436,9 +422,7 @@ 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:
@@ -485,9 +469,7 @@ 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:
@@ -528,9 +510,7 @@ 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:
@@ -573,9 +553,7 @@ 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:
@@ -628,9 +606,7 @@ 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,9 +364,7 @@ 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,12 +503,8 @@ 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
@@ -592,9 +588,7 @@ 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,9 +526,7 @@ 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)
 
@@ -579,9 +577,7 @@ 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]
@@ -617,9 +613,7 @@ 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)
@@ -653,9 +647,7 @@ 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)
@@ -709,9 +701,7 @@ 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)
 
@@ -817,9 +807,7 @@ 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/__init__.py

@@ -11,8 +11,10 @@ needed in tracking applications, including:
 - Rhumb line navigation
 """
 
-from pytcl.navigation.geodesy import (  # Ellipsoids; Coordinate conversions; Geodetic problems
-    GRS80,
+from pytcl.navigation.geodesy import (
+    GRS80,  # Ellipsoids; Coordinate conversions; Geodetic problems
+)
+from pytcl.navigation.geodesy import (
     SPHERE,
     WGS84,
     Ellipsoid,
@@ -26,8 +28,8 @@ from pytcl.navigation.geodesy import (  # Ellipsoids; Coordinate conversions; Ge
     inverse_geodetic,
     ned_to_ecef,
 )
-from pytcl.navigation.great_circle import (  # Great circle navigation
-    EARTH_RADIUS,
+from pytcl.navigation.great_circle import EARTH_RADIUS  # Great circle navigation
+from pytcl.navigation.great_circle import (
     CrossTrackResult,
     GreatCircleResult,
     IntersectionResult,
@@ -45,8 +47,10 @@ from pytcl.navigation.great_circle import (  # Great circle navigation
     great_circle_waypoint,
     great_circle_waypoints,
 )
-from pytcl.navigation.ins import (  # Constants; State representation; Gravity and Earth rate
-    A_EARTH,
+from pytcl.navigation.ins import (
+    A_EARTH,  # Constants; State representation; Gravity and Earth rate
+)
+from pytcl.navigation.ins import (
     B_EARTH,
     E2_EARTH,
     F_EARTH,
@@ -73,8 +77,8 @@ from pytcl.navigation.ins import (  # Constants; State representation; Gravity a
     update_attitude_ned,
     update_quaternion,
 )
-from pytcl.navigation.ins_gnss import (  # INS/GNSS integration
-    GPS_L1_FREQ,
+from pytcl.navigation.ins_gnss import GPS_L1_FREQ  # INS/GNSS integration
+from pytcl.navigation.ins_gnss import (
     GPS_L1_WAVELENGTH,
     SPEED_OF_LIGHT,
     GNSSMeasurement,
@@ -99,8 +103,8 @@ from pytcl.navigation.ins_gnss import (  # INS/GNSS integration
     tight_coupled_update,
     velocity_measurement_matrix,
 )
-from pytcl.navigation.rhumb import (  # Rhumb line navigation
-    RhumbDirectResult,
+from pytcl.navigation.rhumb import RhumbDirectResult  # Rhumb line navigation
+from pytcl.navigation.rhumb import (
     RhumbIntersectionResult,
     RhumbResult,
     compare_great_circle_rhumb,

pytcl/navigation/geodesy.py

@@ -356,9 +356,7 @@ 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(
@@ -436,11 +434,7 @@ 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)
                 )
             )
         )
@@ -458,27 +452,20 @@ 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)
 
@@ -565,10 +552,7 @@ 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:
@@ -588,11 +572,7 @@ 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)
             )
         )
     )
@@ -601,9 +581,7 @@ 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)