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

pytcl/mathematical_functions/signal_processing/detection.py

@@ -24,11 +24,14 @@ References
        Systems, 19(4), 608-621.
 """
 
-from typing import NamedTuple, Optional
+from typing import NamedTuple
+from typing import Optional
 
 import numpy as np
-from numba import njit, prange
-from numpy.typing import ArrayLike, NDArray
+from numba import njit
+from numba import prange
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
 # =============================================================================
 # Result Types
@@ -410,8 +413,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 +462,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 +513,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

@@ -24,10 +24,13 @@ References
        Wiley-Interscience.
 """
 
-from typing import NamedTuple, Optional, Union
+from typing import NamedTuple
+from typing import Optional
+from typing import Union
 
 import numpy as np
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 from scipy import signal as scipy_signal
 
 # =============================================================================
@@ -606,13 +609,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

@@ -21,11 +21,14 @@ References
        IRE Transactions on Information Theory, 6(3), 311-329.
 """
 
-from typing import NamedTuple, Optional
+from typing import NamedTuple
+from typing import Optional
 
 import numpy as np
-from numba import njit, prange
-from numpy.typing import ArrayLike, NDArray
+from numba import njit
+from numba import prange
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 from scipy import fft as scipy_fft
 from scipy import signal as scipy_signal
 
@@ -590,8 +593,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 +640,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

@@ -13,98 +13,96 @@ physics, signal processing, and statistical applications:
 - Debye functions (thermodynamics)
 """
 
-from pytcl.mathematical_functions.special_functions.bessel import (
-    airy,
-    bessel_deriv,
-    bessel_ratio,
-    bessel_zeros,
-    besselh,
-    besseli,
-    besselj,
-    besselk,
-    bessely,
-    kelvin,
-    spherical_in,
-    spherical_jn,
-    spherical_kn,
-    spherical_yn,
-    struve_h,
-    struve_l,
-)
-from pytcl.mathematical_functions.special_functions.debye import (
-    debye,
-    debye_1,
-    debye_2,
-    debye_3,
-    debye_4,
-    debye_entropy,
-    debye_heat_capacity,
-)
-from pytcl.mathematical_functions.special_functions.elliptic import (  # noqa: E501
-    ellipe,
-    ellipeinc,
-    ellipk,
-    ellipkinc,
-    ellipkm1,
-    elliprc,
-    elliprd,
-    elliprf,
-    elliprg,
-    elliprj,
-)
+from pytcl.mathematical_functions.special_functions.bessel import airy
+from pytcl.mathematical_functions.special_functions.bessel import bessel_deriv
+from pytcl.mathematical_functions.special_functions.bessel import bessel_ratio
+from pytcl.mathematical_functions.special_functions.bessel import bessel_zeros
+from pytcl.mathematical_functions.special_functions.bessel import besselh
+from pytcl.mathematical_functions.special_functions.bessel import besseli
+from pytcl.mathematical_functions.special_functions.bessel import besselj
+from pytcl.mathematical_functions.special_functions.bessel import besselk
+from pytcl.mathematical_functions.special_functions.bessel import bessely
+from pytcl.mathematical_functions.special_functions.bessel import kelvin
+from pytcl.mathematical_functions.special_functions.bessel import spherical_in
+from pytcl.mathematical_functions.special_functions.bessel import spherical_jn
+from pytcl.mathematical_functions.special_functions.bessel import spherical_kn
+from pytcl.mathematical_functions.special_functions.bessel import spherical_yn
+from pytcl.mathematical_functions.special_functions.bessel import struve_h
+from pytcl.mathematical_functions.special_functions.bessel import struve_l
+from pytcl.mathematical_functions.special_functions.debye import debye
+from pytcl.mathematical_functions.special_functions.debye import debye_1
+from pytcl.mathematical_functions.special_functions.debye import debye_2
+from pytcl.mathematical_functions.special_functions.debye import debye_3
+from pytcl.mathematical_functions.special_functions.debye import debye_4
+from pytcl.mathematical_functions.special_functions.debye import debye_entropy
+from pytcl.mathematical_functions.special_functions.debye import debye_heat_capacity
+from pytcl.mathematical_functions.special_functions.elliptic import ellipe  # noqa: E501
+from pytcl.mathematical_functions.special_functions.elliptic import ellipeinc
+from pytcl.mathematical_functions.special_functions.elliptic import ellipk
+from pytcl.mathematical_functions.special_functions.elliptic import ellipkinc
+from pytcl.mathematical_functions.special_functions.elliptic import ellipkm1
+from pytcl.mathematical_functions.special_functions.elliptic import elliprc
+from pytcl.mathematical_functions.special_functions.elliptic import elliprd
+from pytcl.mathematical_functions.special_functions.elliptic import elliprf
+from pytcl.mathematical_functions.special_functions.elliptic import elliprg
+from pytcl.mathematical_functions.special_functions.elliptic import elliprj
 from pytcl.mathematical_functions.special_functions.error_functions import (  # noqa: E501
     dawsn,
-    erf,
-    erfc,
-    erfcinv,
-    erfcx,
-    erfi,
-    erfinv,
-    fresnel,
-    voigt_profile,
-    wofz,
 )
+from pytcl.mathematical_functions.special_functions.error_functions import erf
+from pytcl.mathematical_functions.special_functions.error_functions import erfc
+from pytcl.mathematical_functions.special_functions.error_functions import erfcinv
+from pytcl.mathematical_functions.special_functions.error_functions import erfcx
+from pytcl.mathematical_functions.special_functions.error_functions import erfi
+from pytcl.mathematical_functions.special_functions.error_functions import erfinv
+from pytcl.mathematical_functions.special_functions.error_functions import fresnel
+from pytcl.mathematical_functions.special_functions.error_functions import voigt_profile
+from pytcl.mathematical_functions.special_functions.error_functions import wofz
 from pytcl.mathematical_functions.special_functions.gamma_functions import (  # noqa: E501
     beta,
-    betainc,
-    betaincinv,
-    betaln,
-    comb,
-    digamma,
-    factorial,
-    factorial2,
-    gamma,
-    gammainc,
-    gammaincc,
-    gammaincinv,
-    gammaln,
-    perm,
-    polygamma,
 )
+from pytcl.mathematical_functions.special_functions.gamma_functions import betainc
+from pytcl.mathematical_functions.special_functions.gamma_functions import betaincinv
+from pytcl.mathematical_functions.special_functions.gamma_functions import betaln
+from pytcl.mathematical_functions.special_functions.gamma_functions import comb
+from pytcl.mathematical_functions.special_functions.gamma_functions import digamma
+from pytcl.mathematical_functions.special_functions.gamma_functions import factorial
+from pytcl.mathematical_functions.special_functions.gamma_functions import factorial2
+from pytcl.mathematical_functions.special_functions.gamma_functions import gamma
+from pytcl.mathematical_functions.special_functions.gamma_functions import gammainc
+from pytcl.mathematical_functions.special_functions.gamma_functions import gammaincc
+from pytcl.mathematical_functions.special_functions.gamma_functions import gammaincinv
+from pytcl.mathematical_functions.special_functions.gamma_functions import gammaln
+from pytcl.mathematical_functions.special_functions.gamma_functions import perm
+from pytcl.mathematical_functions.special_functions.gamma_functions import polygamma
 from pytcl.mathematical_functions.special_functions.hypergeometric import (
     falling_factorial,
+)
+from pytcl.mathematical_functions.special_functions.hypergeometric import (
     generalized_hypergeometric,
-    hyp0f1,
-    hyp1f1,
+)
+from pytcl.mathematical_functions.special_functions.hypergeometric import hyp0f1
+from pytcl.mathematical_functions.special_functions.hypergeometric import hyp1f1
+from pytcl.mathematical_functions.special_functions.hypergeometric import (
     hyp1f1_regularized,
-    hyp2f1,
-    hyperu,
-    pochhammer,
 )
+from pytcl.mathematical_functions.special_functions.hypergeometric import hyp2f1
+from pytcl.mathematical_functions.special_functions.hypergeometric import hyperu
+from pytcl.mathematical_functions.special_functions.hypergeometric import pochhammer
+from pytcl.mathematical_functions.special_functions.lambert_w import lambert_w
+from pytcl.mathematical_functions.special_functions.lambert_w import lambert_w_real
+from pytcl.mathematical_functions.special_functions.lambert_w import omega_constant
 from pytcl.mathematical_functions.special_functions.lambert_w import (
-    lambert_w,
-    lambert_w_real,
-    omega_constant,
     solve_exponential_equation,
-    time_delay_equation,
-    wright_omega,
 )
+from pytcl.mathematical_functions.special_functions.lambert_w import time_delay_equation
+from pytcl.mathematical_functions.special_functions.lambert_w import wright_omega
+from pytcl.mathematical_functions.special_functions.marcum_q import log_marcum_q
+from pytcl.mathematical_functions.special_functions.marcum_q import marcum_q
+from pytcl.mathematical_functions.special_functions.marcum_q import marcum_q1
+from pytcl.mathematical_functions.special_functions.marcum_q import marcum_q_inv
+from pytcl.mathematical_functions.special_functions.marcum_q import nuttall_q
 from pytcl.mathematical_functions.special_functions.marcum_q import (
-    log_marcum_q,
-    marcum_q,
-    marcum_q1,
-    marcum_q_inv,
-    nuttall_q,
     swerling_detection_probability,
 )
 

pytcl/mathematical_functions/special_functions/bessel.py

@@ -9,7 +9,8 @@ from typing import Union
 
 import numpy as np
 import scipy.special as sp
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
 
 def besselj(

pytcl/mathematical_functions/special_functions/debye.py

@@ -7,7 +7,8 @@ thermodynamic properties of solids (heat capacity, entropy).
 
 import numpy as np
 import scipy.integrate as integrate
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
 
 def debye(
@@ -77,7 +78,8 @@ def debye(
             result[i] = 1.0 - n * xi / (2 * (n + 1))
         elif xi > 100:
             # Large x asymptotic
-            from scipy.special import factorial, zeta
+            from scipy.special import factorial
+            from scipy.special import zeta
 
             result[i] = factorial(n) * zeta(n + 1) * n / (xi**n)
         else:

pytcl/mathematical_functions/special_functions/elliptic.py

@@ -7,7 +7,8 @@ applications including orbits, pendulums, and electromagnetic calculations.
 
 import numpy as np
 import scipy.special as sp
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
 
 def ellipk(m: ArrayLike) -> NDArray[np.floating]:
@@ -243,9 +244,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/error_functions.py

@@ -7,7 +7,8 @@ in probability theory and statistical analysis.
 
 import numpy as np
 import scipy.special as sp
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
 
 def erf(x: ArrayLike) -> NDArray[np.floating]:

pytcl/mathematical_functions/special_functions/gamma_functions.py

@@ -7,7 +7,8 @@ functions used in statistics and probability calculations.
 
 import numpy as np
 import scipy.special as sp
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
 
 def gamma(x: ArrayLike) -> NDArray[np.floating]:
@@ -421,9 +422,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/hypergeometric.py

@@ -7,7 +7,8 @@ mathematical physics, probability theory, and special function evaluation.
 
 import numpy as np
 import scipy.special as sp
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
 
 def hyp0f1(

pytcl/mathematical_functions/special_functions/lambert_w.py

@@ -7,7 +7,8 @@ delay differential equations, combinatorics, and physics.
 
 import numpy as np
 import scipy.special as sp
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
 
 def lambert_w(
@@ -108,9 +109,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/special_functions/marcum_q.py

@@ -7,7 +7,8 @@ analyzing detection probabilities and signal statistics.
 
 import numpy as np
 import scipy.special as sp
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
 
 def marcum_q(

pytcl/mathematical_functions/statistics/__init__.py

@@ -8,37 +8,33 @@ This module provides:
 - Filter consistency metrics (NEES, NIS)
 """
 
-from pytcl.mathematical_functions.statistics.distributions import (
-    Beta,
-    ChiSquared,
-    Distribution,
-    Exponential,
-    Gamma,
-    Gaussian,
-    MultivariateGaussian,
-    Poisson,
-    StudentT,
-    Uniform,
-    VonMises,
-    Wishart,
-)
-from pytcl.mathematical_functions.statistics.estimators import (
-    iqr,
-    kurtosis,
-    mad,
-    median,
-    moment,
-    nees,
-    nis,
-    sample_corr,
-    sample_cov,
-    sample_mean,
-    sample_var,
-    skewness,
-    weighted_cov,
-    weighted_mean,
-    weighted_var,
-)
+from pytcl.mathematical_functions.statistics.distributions import Beta
+from pytcl.mathematical_functions.statistics.distributions import ChiSquared
+from pytcl.mathematical_functions.statistics.distributions import Distribution
+from pytcl.mathematical_functions.statistics.distributions import Exponential
+from pytcl.mathematical_functions.statistics.distributions import Gamma
+from pytcl.mathematical_functions.statistics.distributions import Gaussian
+from pytcl.mathematical_functions.statistics.distributions import MultivariateGaussian
+from pytcl.mathematical_functions.statistics.distributions import Poisson
+from pytcl.mathematical_functions.statistics.distributions import StudentT
+from pytcl.mathematical_functions.statistics.distributions import Uniform
+from pytcl.mathematical_functions.statistics.distributions import VonMises
+from pytcl.mathematical_functions.statistics.distributions import Wishart
+from pytcl.mathematical_functions.statistics.estimators import iqr
+from pytcl.mathematical_functions.statistics.estimators import kurtosis
+from pytcl.mathematical_functions.statistics.estimators import mad
+from pytcl.mathematical_functions.statistics.estimators import median
+from pytcl.mathematical_functions.statistics.estimators import moment
+from pytcl.mathematical_functions.statistics.estimators import nees
+from pytcl.mathematical_functions.statistics.estimators import nis
+from pytcl.mathematical_functions.statistics.estimators import sample_corr
+from pytcl.mathematical_functions.statistics.estimators import sample_cov
+from pytcl.mathematical_functions.statistics.estimators import sample_mean
+from pytcl.mathematical_functions.statistics.estimators import sample_var
+from pytcl.mathematical_functions.statistics.estimators import skewness
+from pytcl.mathematical_functions.statistics.estimators import weighted_cov
+from pytcl.mathematical_functions.statistics.estimators import weighted_mean
+from pytcl.mathematical_functions.statistics.estimators import weighted_var
 
 __all__ = [
     # Distributions

pytcl/mathematical_functions/statistics/distributions.py

@@ -6,12 +6,16 @@ for PDF, CDF, sampling, and moment calculations. These wrap scipy.stats
 distributions with additional functionality useful for tracking applications.
 """
 
-from abc import ABC, abstractmethod
-from typing import Optional, Tuple, Union
+from abc import ABC
+from abc import abstractmethod
+from typing import Optional
+from typing import Tuple
+from typing import Union
 
 import numpy as np
 import scipy.stats as stats
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
 
 class Distribution(ABC):
@@ -43,9 +47,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 +106,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 +167,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 +237,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 +275,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 +341,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 +379,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 +426,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 +473,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 +514,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 +557,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:
@@ -583,7 +565,8 @@ class VonMises(Distribution):
 
     def var(self) -> float:
         # Circular variance: 1 - I_1(kappa)/I_0(kappa)
-        from scipy.special import i0, i1
+        from scipy.special import i0
+        from scipy.special import i1
 
         return 1 - i1(self._kappa) / i0(self._kappa)
 
@@ -628,9 +611,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

@@ -8,7 +8,8 @@ robust estimators, and related quantities used in tracking applications.
 from typing import Optional
 
 import numpy as np
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
 
 def weighted_mean(
@@ -364,9 +365,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(