nrl-tracker 1.6.0__py3-none-any.whl → 1.7.1__py3-none-any.whl

pytcl/magnetism/wmm.py

@@ -13,7 +13,7 @@ References
 """
 
 from functools import lru_cache
-from typing import NamedTuple, Optional, Tuple
+from typing import Any, NamedTuple, Optional, Tuple
 
 import numpy as np
 from numpy.typing import NDArray
@@ -482,7 +482,7 @@ def _magnetic_field_spherical_cached(
 
 
 # Registry to hold coefficient sets by id
-_coefficient_registry: dict = {}
+_coefficient_registry: dict[str, Any] = {}
 
 
 def _register_coefficients(coeffs: "MagneticCoefficients") -> int:
@@ -579,7 +579,7 @@ def _compute_magnetic_field_spherical_impl(
 # =============================================================================
 
 
-def get_magnetic_cache_info() -> dict:
+def get_magnetic_cache_info() -> dict[str, Any]:
     """
     Get information about the magnetic field computation cache.
 
@@ -630,7 +630,7 @@ def clear_magnetic_cache() -> None:
 
 def configure_magnetic_cache(
     maxsize: Optional[int] = None,
-    precision: Optional[dict] = None,
+    precision: Optional[dict[str, Any]] = None,
 ) -> None:
     """
     Configure the magnetic field computation cache.

pytcl/mathematical_functions/combinatorics/combinatorics.py

@@ -7,7 +7,7 @@ related operations commonly used in assignment problems and data association.
 
 import itertools
 from functools import lru_cache
-from typing import Iterator, List, Optional, Tuple
+from typing import Any, Iterator, List, Optional, Tuple
 
 from numpy.typing import ArrayLike
 
@@ -108,7 +108,7 @@ def n_permute_k(n: int, k: int) -> int:
 def permutations(
     items: ArrayLike,
     k: Optional[int] = None,
-) -> Iterator[Tuple]:
+) -> Iterator[tuple[Any, ...]]:
     """
     Generate all k-permutations of items.
 
@@ -136,7 +136,7 @@ def permutations(
 def combinations(
     items: ArrayLike,
     k: int,
-) -> Iterator[Tuple]:
+) -> Iterator[tuple[Any, ...]]:
     """
     Generate all k-combinations of items.
 
@@ -164,7 +164,7 @@ def combinations(
 def combinations_with_replacement(
     items: ArrayLike,
     k: int,
-) -> Iterator[Tuple]:
+) -> Iterator[tuple[Any, ...]]:
     """
     Generate all k-combinations with replacement.
 
@@ -263,7 +263,7 @@ def permutation_unrank(rank: int, n: int) -> List[int]:
     return perm
 
 
-def next_permutation(perm: ArrayLike) -> Optional[List]:
+def next_permutation(perm: ArrayLike) -> Optional[List[Any]]:
     """
     Generate the next permutation in lexicographic order.
 

pytcl/mathematical_functions/geometry/geometry.py

@@ -5,7 +5,7 @@ This module provides geometric functions for points, lines, planes,
 polygons, and related operations used in tracking applications.
 """
 
-from typing import Optional, Tuple
+from typing import Any, Optional, Tuple
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -527,12 +527,12 @@ def minimum_bounding_circle(
     """
     points = np.asarray(points, dtype=np.float64)
 
-    def circle_from_two_points(p1, p2):
+    def circle_from_two_points(p1: Any, p2: Any) -> tuple[Any, Any]:
         center = (p1 + p2) / 2
         radius = np.linalg.norm(p1 - center)
         return center, radius
 
-    def circle_from_three_points(p1, p2, p3):
+    def circle_from_three_points(p1: Any, p2: Any, p3: Any) -> tuple[Any, Any]:
         ax, ay = p1
         bx, by = p2
         cx, cy = p3
@@ -565,10 +565,10 @@ def minimum_bounding_circle(
         radius = np.linalg.norm(p1 - center)
         return center, radius
 
-    def is_inside(c, r, p):
+    def is_inside(c: Any, r: Any, p: Any) -> Any:
         return np.linalg.norm(p - c) <= r + 1e-10
 
-    def welzl(P, R):
+    def welzl(P: Any, R: Any) -> tuple[Any, Any]:
         if len(P) == 0 or len(R) == 3:
             if len(R) == 0:
                 return np.array([0.0, 0.0]), 0.0

pytcl/mathematical_functions/numerical_integration/quadrature.py

@@ -5,7 +5,7 @@ This module provides Gaussian quadrature rules and numerical integration
 functions commonly used in state estimation and filtering.
 """
 
-from typing import Callable, Literal, Optional, Tuple
+from typing import Any, Callable, Literal, Optional, Tuple
 
 import numpy as np
 import scipy.integrate as integrate
@@ -158,7 +158,7 @@ def quad(
     f: Callable[[float], float],
     a: float,
     b: float,
-    **kwargs,
+    **kwargs: Any,
 ) -> Tuple[float, float]:
     """
     Adaptive quadrature integration.
@@ -203,7 +203,7 @@ def dblquad(
     b: float,
     gfun: Callable[[float], float],
     hfun: Callable[[float], float],
-    **kwargs,
+    **kwargs: Any,
 ) -> Tuple[float, float]:
     """
     Double integration.
@@ -248,7 +248,7 @@ def tplquad(
     hfun: Callable[[float], float],
     qfun: Callable[[float, float], float],
     rfun: Callable[[float, float], float],
-    **kwargs,
+    **kwargs: Any,
 ) -> Tuple[float, float]:
     """
     Triple integration.
@@ -290,11 +290,11 @@ def tplquad(
 
 
 def fixed_quad(
-    f: Callable[[NDArray], NDArray],
+    f: Callable[[np.ndarray[Any, Any]], np.ndarray[Any, Any]],
     a: float,
     b: float,
     n: int = 5,
-) -> Tuple[float, None]:
+) -> tuple[float, None]:
     """
     Fixed-order Gaussian quadrature.
 

pytcl/mathematical_functions/signal_processing/detection.py

@@ -24,7 +24,7 @@ References
        Systems, 19(4), 608-621.
 """
 
-from typing import NamedTuple, Optional
+from typing import Any, NamedTuple, Optional
 
 import numpy as np
 from numba import njit, prange
@@ -214,12 +214,12 @@ def detection_probability(
 
 @njit(cache=True, fastmath=True)
 def _cfar_ca_kernel(
-    signal: np.ndarray,
+    signal: np.ndarray[Any, Any],
     guard_cells: int,
     ref_cells: int,
     alpha: float,
-    noise_estimate: np.ndarray,
-    threshold: np.ndarray,
+    noise_estimate: np.ndarray[Any, Any],
+    threshold: np.ndarray[Any, Any],
 ) -> None:
     """JIT-compiled CA-CFAR kernel."""
     n = len(signal)
@@ -252,12 +252,12 @@ def _cfar_ca_kernel(
 
 @njit(cache=True, fastmath=True)
 def _cfar_go_kernel(
-    signal: np.ndarray,
+    signal: np.ndarray[Any, Any],
     guard_cells: int,
     ref_cells: int,
     alpha: float,
-    noise_estimate: np.ndarray,
-    threshold: np.ndarray,
+    noise_estimate: np.ndarray[Any, Any],
+    threshold: np.ndarray[Any, Any],
 ) -> None:
     """JIT-compiled GO-CFAR kernel."""
     n = len(signal)
@@ -290,12 +290,12 @@ def _cfar_go_kernel(
 
 @njit(cache=True, fastmath=True)
 def _cfar_so_kernel(
-    signal: np.ndarray,
+    signal: np.ndarray[Any, Any],
     guard_cells: int,
     ref_cells: int,
     alpha: float,
-    noise_estimate: np.ndarray,
-    threshold: np.ndarray,
+    noise_estimate: np.ndarray[Any, Any],
+    threshold: np.ndarray[Any, Any],
 ) -> None:
     """JIT-compiled SO-CFAR kernel."""
     n = len(signal)
@@ -331,13 +331,13 @@ def _cfar_so_kernel(
 
 @njit(cache=True, fastmath=True)
 def _cfar_os_kernel(
-    signal: np.ndarray,
+    signal: np.ndarray[Any, Any],
     guard_cells: int,
     ref_cells: int,
     k: int,
     alpha: float,
-    noise_estimate: np.ndarray,
-    threshold: np.ndarray,
+    noise_estimate: np.ndarray[Any, Any],
+    threshold: np.ndarray[Any, Any],
 ) -> None:
     """JIT-compiled OS-CFAR kernel."""
     n = len(signal)
@@ -378,14 +378,14 @@ def _cfar_os_kernel(
 
 @njit(cache=True, fastmath=True, parallel=True)
 def _cfar_2d_ca_kernel(
-    image: np.ndarray,
+    image: np.ndarray[Any, Any],
     guard_rows: int,
     guard_cols: int,
     ref_rows: int,
     ref_cols: int,
     alpha: float,
-    noise_estimate: np.ndarray,
-    threshold: np.ndarray,
+    noise_estimate: np.ndarray[Any, Any],
+    threshold: np.ndarray[Any, Any],
 ) -> None:
     """JIT-compiled 2D CA-CFAR kernel with parallel execution."""
     n_rows, n_cols = image.shape
@@ -426,14 +426,14 @@ def _cfar_2d_ca_kernel(
 
 @njit(cache=True, fastmath=True, parallel=True)
 def _cfar_2d_go_kernel(
-    image: np.ndarray,
+    image: np.ndarray[Any, Any],
     guard_rows: int,
     guard_cols: int,
     ref_rows: int,
     ref_cols: int,
     alpha: float,
-    noise_estimate: np.ndarray,
-    threshold: np.ndarray,
+    noise_estimate: np.ndarray[Any, Any],
+    threshold: np.ndarray[Any, Any],
 ) -> None:
     """JIT-compiled 2D GO-CFAR kernel with parallel execution."""
     n_rows, n_cols = image.shape
@@ -478,14 +478,14 @@ def _cfar_2d_go_kernel(
 
 @njit(cache=True, fastmath=True, parallel=True)
 def _cfar_2d_so_kernel(
-    image: np.ndarray,
+    image: np.ndarray[Any, Any],
     guard_rows: int,
     guard_cols: int,
     ref_rows: int,
     ref_cols: int,
     alpha: float,
-    noise_estimate: np.ndarray,
-    threshold: np.ndarray,
+    noise_estimate: np.ndarray[Any, Any],
+    threshold: np.ndarray[Any, Any],
 ) -> None:
     """JIT-compiled 2D SO-CFAR kernel with parallel execution."""
     n_rows, n_cols = image.shape
@@ -830,8 +830,8 @@ def cfar_os(
 
 def cfar_2d(
     image: ArrayLike,
-    guard_cells: tuple,
-    ref_cells: tuple,
+    guard_cells: tuple[int, int],
+    ref_cells: tuple[int, int],
     pfa: float = 1e-6,
     method: str = "ca",
     alpha: Optional[float] = None,

pytcl/mathematical_functions/signal_processing/filters.py

@@ -24,7 +24,7 @@ References
        Wiley-Interscience.
 """
 
-from typing import NamedTuple, Optional, Union
+from typing import Any, NamedTuple, Optional, Union
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -80,7 +80,7 @@ class FrequencyResponse(NamedTuple):
 
 def butter_design(
     order: int,
-    cutoff: Union[float, tuple],
+    cutoff: Union[float, tuple[float, ...]],
     fs: float,
     btype: str = "low",
     output: str = "sos",
@@ -141,7 +141,7 @@ def butter_design(
 def cheby1_design(
     order: int,
     ripple: float,
-    cutoff: Union[float, tuple],
+    cutoff: Union[float, tuple[float, ...]],
     fs: float,
     btype: str = "low",
     output: str = "sos",
@@ -198,7 +198,7 @@ def cheby1_design(
 def cheby2_design(
     order: int,
     attenuation: float,
-    cutoff: Union[float, tuple],
+    cutoff: Union[float, tuple[float, ...]],
     fs: float,
     btype: str = "low",
     output: str = "sos",
@@ -255,7 +255,7 @@ def ellip_design(
     order: int,
     passband_ripple: float,
     stopband_attenuation: float,
-    cutoff: Union[float, tuple],
+    cutoff: Union[float, tuple[float, ...]],
     fs: float,
     btype: str = "low",
     output: str = "sos",
@@ -317,7 +317,7 @@ def ellip_design(
 
 def bessel_design(
     order: int,
-    cutoff: Union[float, tuple],
+    cutoff: Union[float, tuple[float, ...]],
     fs: float,
     btype: str = "low",
     norm: str = "phase",
@@ -383,7 +383,7 @@ def bessel_design(
 
 def fir_design(
     numtaps: int,
-    cutoff: Union[float, tuple],
+    cutoff: Union[float, tuple[float, ...]],
     fs: float,
     window: str = "hamming",
     pass_zero: Union[bool, str] = True,
@@ -499,10 +499,10 @@ def fir_design_remez(
 
 
 def apply_filter(
-    coeffs: Union[FilterCoefficients, tuple, NDArray],
+    coeffs: Union[FilterCoefficients, tuple[Any, ...], NDArray[Any]],
     x: ArrayLike,
     zi: Optional[ArrayLike] = None,
-) -> Union[NDArray[np.floating], tuple]:
+) -> Union[NDArray[np.floating], tuple[NDArray[np.floating], Any]]:
     """
     Apply a digital filter to a signal.
 
@@ -559,7 +559,7 @@ def apply_filter(
 
 
 def filtfilt(
-    coeffs: Union[FilterCoefficients, tuple, NDArray],
+    coeffs: Union[FilterCoefficients, tuple[Any, ...], NDArray[Any]],
     x: ArrayLike,
     padtype: str = "odd",
     padlen: Optional[int] = None,
@@ -627,7 +627,7 @@ def filtfilt(
 
 
 def frequency_response(
-    coeffs: Union[FilterCoefficients, tuple, NDArray],
+    coeffs: Union[FilterCoefficients, tuple[Any, ...], NDArray[Any]],
     fs: float,
     n_points: int = 512,
     whole: bool = False,
@@ -684,10 +684,10 @@ def frequency_response(
 
 
 def group_delay(
-    coeffs: Union[FilterCoefficients, tuple, NDArray],
+    coeffs: Union[FilterCoefficients, tuple[Any, ...], NDArray[Any]],
     fs: float,
     n_points: int = 512,
-) -> tuple:
+) -> tuple[NDArray[np.floating], NDArray[np.floating]]:
     """
     Compute the group delay of a digital filter.
 
@@ -793,7 +793,7 @@ def filter_order(
     return int(order)
 
 
-def sos_to_zpk(sos: ArrayLike) -> tuple:
+def sos_to_zpk(sos: ArrayLike) -> tuple[NDArray[Any], NDArray[Any], Any]:
     """
     Convert second-order sections to zeros, poles, gain.
 

pytcl/mathematical_functions/signal_processing/matched_filter.py

@@ -21,7 +21,7 @@ References
        IRE Transactions on Information Theory, 6(3), 311-329.
 """
 
-from typing import NamedTuple, Optional
+from typing import Any, NamedTuple, Optional
 
 import numpy as np
 from numba import njit, prange
@@ -553,11 +553,11 @@ def generate_nlfm_chirp(
 
 @njit(cache=True, fastmath=True, parallel=True)
 def _ambiguity_function_kernel(
-    signal: np.ndarray,
-    delays: np.ndarray,
-    dopplers: np.ndarray,
+    signal: np.ndarray[Any, Any],
+    delays: np.ndarray[Any, Any],
+    dopplers: np.ndarray[Any, Any],
     fs: float,
-    af: np.ndarray,
+    af: np.ndarray[Any, Any],
 ) -> None:
     """JIT-compiled kernel for ambiguity function computation."""
     n_signal = len(signal)
@@ -600,12 +600,12 @@ def _ambiguity_function_kernel(
 
 @njit(cache=True, fastmath=True, parallel=True)
 def _cross_ambiguity_kernel(
-    signal1: np.ndarray,
-    signal2: np.ndarray,
-    delays: np.ndarray,
-    dopplers: np.ndarray,
+    signal1: np.ndarray[Any, Any],
+    signal2: np.ndarray[Any, Any],
+    delays: np.ndarray[Any, Any],
+    dopplers: np.ndarray[Any, Any],
     fs: float,
-    caf: np.ndarray,
+    caf: np.ndarray[Any, Any],
 ) -> None:
     """JIT-compiled kernel for cross-ambiguity function computation."""
     n_signal = len(signal1)
@@ -653,7 +653,7 @@ def ambiguity_function(
     max_doppler: Optional[float] = None,
     n_delay: int = 256,
     n_doppler: int = 256,
-) -> tuple:
+) -> tuple[NDArray[np.floating], NDArray[np.floating], NDArray[np.complexfloating]]:
     """
     Compute the ambiguity function of a signal.
 
@@ -722,7 +722,7 @@ def cross_ambiguity(
     max_doppler: Optional[float] = None,
     n_delay: int = 256,
     n_doppler: int = 256,
-) -> tuple:
+) -> tuple[NDArray[np.floating], NDArray[np.floating], NDArray[np.complexfloating]]:
     """
     Compute the cross-ambiguity function between two signals.
 

pytcl/mathematical_functions/special_functions/bessel.py

@@ -5,7 +5,7 @@ This module provides Bessel functions commonly used in signal processing,
 antenna theory, and scattering problems in tracking applications.
 """
 
-from typing import Union
+from typing import Any, Union
 
 import numpy as np
 import scipy.special as sp
@@ -315,7 +315,14 @@ def spherical_kn(
     return np.asarray(sp.spherical_kn(n, x, derivative=derivative), dtype=np.float64)
 
 
-def airy(x: ArrayLike) -> tuple:
+def airy(
+    x: ArrayLike,
+) -> tuple[
+    np.ndarray[Any, Any],
+    np.ndarray[Any, Any],
+    np.ndarray[Any, Any],
+    np.ndarray[Any, Any],
+]:
     """
     Airy functions and their derivatives.
 
@@ -554,7 +561,12 @@ def bessel_zeros(
 
 def kelvin(
     x: ArrayLike,
-) -> tuple:
+) -> tuple[
+    np.ndarray[Any, Any],
+    np.ndarray[Any, Any],
+    np.ndarray[Any, Any],
+    np.ndarray[Any, Any],
+]:
     """
     Kelvin functions ber, bei, ker, kei.
 

pytcl/mathematical_functions/special_functions/debye.py

@@ -11,6 +11,8 @@ core, providing ~10-50x speedup for batch computations compared to
 scipy.integrate.quad.
 """
 
+from typing import Any
+
 import numpy as np
 from numba import njit, prange
 from numpy.typing import ArrayLike, NDArray
@@ -90,7 +92,9 @@ def _debye_small_x(x: float, n: int) -> float:
 
 
 @njit(cache=True, fastmath=True, parallel=True)
-def _debye_batch(n: int, x_arr: np.ndarray, zeta_n_plus_1: float) -> np.ndarray:
+def _debye_batch(
+    n: int, x_arr: np.ndarray[Any, Any], zeta_n_plus_1: float
+) -> np.ndarray[Any, Any]:
     """
     Batch computation of Debye function for array input.
 

pytcl/mathematical_functions/special_functions/error_functions.py

@@ -5,6 +5,8 @@ This module provides error functions and their variants, commonly used
 in probability theory and statistical analysis.
 """
 
+from typing import Any
+
 import numpy as np
 import scipy.special as sp
 from numpy.typing import ArrayLike, NDArray
@@ -216,7 +218,7 @@ def dawsn(x: ArrayLike) -> NDArray[np.floating]:
     return np.asarray(sp.dawsn(x), dtype=np.float64)
 
 
-def fresnel(x: ArrayLike) -> tuple:
+def fresnel(x: ArrayLike) -> tuple[np.ndarray[Any, Any], np.ndarray[Any, Any]]:
     """
     Fresnel integrals.
 

pytcl/mathematical_functions/special_functions/gamma_functions.py

@@ -318,7 +318,7 @@ def betaincinv(a: ArrayLike, b: ArrayLike, y: ArrayLike) -> NDArray[np.floating]
     return np.asarray(sp.betaincinv(a, b, y), dtype=np.float64)
 
 
-def factorial(n: ArrayLike, exact: bool = False) -> NDArray:
+def factorial(n: ArrayLike, exact: bool = False) -> NDArray[np.floating]:
     """
     Factorial function.
 
@@ -351,7 +351,7 @@ def factorial(n: ArrayLike, exact: bool = False) -> NDArray:
     return np.asarray(sp.factorial(n, exact=exact), dtype=np.float64)
 
 
-def factorial2(n: ArrayLike, exact: bool = False) -> NDArray:
+def factorial2(n: ArrayLike, exact: bool = False) -> NDArray[np.floating]:
     """
     Double factorial.
 
@@ -388,7 +388,7 @@ def comb(
     k: ArrayLike,
     exact: bool = False,
     repetition: bool = False,
-) -> NDArray:
+) -> NDArray[np.floating]:
     """
     Binomial coefficient (combinations).
 
@@ -426,7 +426,7 @@ def comb(
     )
 
 
-def perm(n: ArrayLike, k: ArrayLike, exact: bool = False) -> NDArray:
+def perm(n: ArrayLike, k: ArrayLike, exact: bool = False) -> NDArray[np.floating]:
     """
     Permutation coefficient.
 

pytcl/mathematical_functions/special_functions/hypergeometric.py

@@ -11,6 +11,8 @@ the series summation loop, providing significant speedup for the general
 case (p > 2 or q > 1).
 """
 
+from typing import Any
+
 import numpy as np
 import scipy.special as sp
 from numba import njit
@@ -19,12 +21,12 @@ from numpy.typing import ArrayLike, NDArray
 
 @njit(cache=True, fastmath=True)
 def _hypergeometric_series(
-    a: np.ndarray,
-    b: np.ndarray,
-    z: np.ndarray,
+    a: np.ndarray[Any, Any],
+    b: np.ndarray[Any, Any],
+    z: np.ndarray[Any, Any],
     max_terms: int,
     tol: float,
-) -> np.ndarray:
+) -> np.ndarray[Any, Any]:
     """
     Numba-optimized series summation for generalized hypergeometric function.
 

pytcl/mathematical_functions/transforms/fourier.py

@@ -247,8 +247,8 @@ def irfft(
 
 def fft2(
     x: ArrayLike,
-    s: Optional[tuple] = None,
-    axes: tuple = (-2, -1),
+    s: Optional[tuple[int, ...]] = None,
+    axes: tuple[int, ...] = (-2, -1),
     norm: Optional[str] = None,
 ) -> NDArray[np.complexfloating]:
     """
@@ -284,8 +284,8 @@ def fft2(
 
 def ifft2(
     X: ArrayLike,
-    s: Optional[tuple] = None,
-    axes: tuple = (-2, -1),
+    s: Optional[tuple[int, ...]] = None,
+    axes: tuple[int, ...] = (-2, -1),
     norm: Optional[str] = None,
 ) -> NDArray[np.complexfloating]:
     """
@@ -313,8 +313,8 @@ def ifft2(
 
 def fftshift(
     x: ArrayLike,
-    axes: Optional[Union[int, tuple]] = None,
-) -> NDArray:
+    axes: Optional[Union[int, tuple[int, ...]]] = None,
+) -> NDArray[np.floating]:
     """
     Shift the zero-frequency component to the center of the spectrum.
 
@@ -345,8 +345,8 @@ def fftshift(
 
 def ifftshift(
     x: ArrayLike,
-    axes: Optional[Union[int, tuple]] = None,
-) -> NDArray:
+    axes: Optional[Union[int, tuple[int, ...]]] = None,
+) -> NDArray[np.floating]:
     """
     Inverse of fftshift. Shift zero-frequency back to beginning.