nrl-tracker 1.7.0__py3-none-any.whl → 1.7.3__py3-none-any.whl

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.
 

pytcl/mathematical_functions/transforms/stft.py

@@ -22,7 +22,7 @@ References
        Speech, and Signal Processing, 32(2), 236-243.
 """
 
-from typing import NamedTuple, Optional, Union
+from typing import Any, NamedTuple, Optional, Union
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -77,7 +77,7 @@ class Spectrogram(NamedTuple):
 
 
 def get_window(
-    window: Union[str, tuple, ArrayLike],
+    window: Union[str, tuple[str, Any], ArrayLike],
     length: int,
     fftbins: bool = True,
 ) -> NDArray[np.floating]:
@@ -174,7 +174,7 @@ def window_bandwidth(
 def stft(
     x: ArrayLike,
     fs: float = 1.0,
-    window: Union[str, tuple, ArrayLike] = "hann",
+    window: Union[str, tuple[str, Any], ArrayLike] = "hann",
     nperseg: int = 256,
     noverlap: Optional[int] = None,
     nfft: Optional[int] = None,
@@ -264,13 +264,13 @@ def stft(
 def istft(
     Zxx: ArrayLike,
     fs: float = 1.0,
-    window: Union[str, tuple, ArrayLike] = "hann",
+    window: Union[str, tuple[str, Any], ArrayLike] = "hann",
     nperseg: Optional[int] = None,
     noverlap: Optional[int] = None,
     nfft: Optional[int] = None,
     input_onesided: bool = True,
     boundary: bool = True,
-) -> tuple:
+) -> tuple[NDArray[np.floating], NDArray[np.floating]]:
     """
     Compute the inverse Short-Time Fourier Transform.
 
@@ -351,7 +351,7 @@ def istft(
 def spectrogram(
     x: ArrayLike,
     fs: float = 1.0,
-    window: Union[str, tuple, ArrayLike] = "hann",
+    window: Union[str, tuple[str, Any], ArrayLike] = "hann",
     nperseg: int = 256,
     noverlap: Optional[int] = None,
     nfft: Optional[int] = None,
@@ -436,11 +436,11 @@ def spectrogram(
 def reassigned_spectrogram(
     x: ArrayLike,
     fs: float = 1.0,
-    window: Union[str, tuple, ArrayLike] = "hann",
+    window: Union[str, tuple[str, Any], ArrayLike] = "hann",
     nperseg: int = 256,
     noverlap: Optional[int] = None,
     nfft: Optional[int] = None,
-) -> tuple:
+) -> tuple[NDArray[np.floating], NDArray[np.floating], NDArray[np.floating]]:
     """
     Compute reassigned spectrogram for improved time-frequency resolution.
 
@@ -538,7 +538,7 @@ def mel_spectrogram(
     window: str = "hann",
     nperseg: int = 2048,
     noverlap: Optional[int] = None,
-) -> tuple:
+) -> tuple[NDArray[np.floating], NDArray[np.floating], NDArray[np.floating]]:
     """
     Compute mel-scaled spectrogram.
 
@@ -611,15 +611,15 @@ def mel_spectrogram(
     # Mel frequency centers
     mel_freqs = _mel_frequencies(n_mels, fmin, fmax)
 
-    return mel_freqs, spec_result.times, mel_spec
+    return (mel_freqs, spec_result.times, mel_spec)
 
 
-def _hz_to_mel(hz: Union[float, ArrayLike]) -> Union[float, NDArray]:
+def _hz_to_mel(hz: Union[float, ArrayLike]) -> Union[float, NDArray[np.floating]]:
     """Convert frequency in Hz to mel scale."""
     return 2595.0 * np.log10(1.0 + np.asarray(hz) / 700.0)
 
 
-def _mel_to_hz(mel: Union[float, ArrayLike]) -> Union[float, NDArray]:
+def _mel_to_hz(mel: Union[float, ArrayLike]) -> Union[float, NDArray[np.floating]]:
     """Convert mel scale to frequency in Hz."""
     return 700.0 * (10.0 ** (np.asarray(mel) / 2595.0) - 1.0)
 

pytcl/mathematical_functions/transforms/wavelets.py

@@ -20,7 +20,7 @@ References
 .. [2] Daubechies, I. (1992). Ten Lectures on Wavelets. SIAM.
 """
 
-from typing import Callable, List, NamedTuple, Optional, Union
+from typing import Any, Callable, List, NamedTuple, Optional, Union
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -262,7 +262,7 @@ def gaussian_wavelet(
 def cwt(
     signal: ArrayLike,
     scales: ArrayLike,
-    wavelet: Union[str, Callable[[int], NDArray]] = "morlet",
+    wavelet: Union[str, Callable[[int], NDArray[np.floating]]] = "morlet",
     fs: float = 1.0,
     method: str = "fft",
 ) -> CWTResult:
@@ -312,16 +312,16 @@ def cwt(
     n = len(signal)
 
     # Determine wavelet function
-    def _morlet_default(M: int) -> NDArray:
+    def _morlet_default(M: int) -> NDArray[np.floating]:
         return morlet_wavelet(M, w=5.0)
 
-    def _ricker_default(M: int) -> NDArray:
+    def _ricker_default(M: int) -> NDArray[np.floating]:
         return ricker_wavelet(M, a=1.0)
 
-    def _gaussian1_default(M: int) -> NDArray:
+    def _gaussian1_default(M: int) -> NDArray[np.floating]:
         return gaussian_wavelet(M, order=1)
 
-    def _gaussian2_default(M: int) -> NDArray:
+    def _gaussian2_default(M: int) -> NDArray[np.floating]:
         return gaussian_wavelet(M, order=2)
 
     if callable(wavelet):
@@ -596,7 +596,7 @@ def dwt_single_level(
     signal: ArrayLike,
     wavelet: str = "db4",
     mode: str = "symmetric",
-) -> tuple:
+) -> tuple[NDArray[np.floating], NDArray[np.floating]]:
     """
     Compute single-level DWT decomposition.
 
@@ -673,7 +673,7 @@ def wpt(
     wavelet: str = "db4",
     level: Optional[int] = None,
     mode: str = "symmetric",
-) -> dict:
+) -> dict[str, NDArray[np.floating]]:
     """
     Compute the Wavelet Packet Transform.
 
@@ -748,7 +748,7 @@ def available_wavelets() -> List[str]:
     return pywt.wavelist()
 
 
-def wavelet_info(wavelet: str) -> dict:
+def wavelet_info(wavelet: str) -> dict[str, Any]:
     """
     Get information about a wavelet.
 

pytcl/navigation/geodesy.py

@@ -10,7 +10,7 @@ This module provides geodetic utilities including:
 
 import logging
 from functools import lru_cache
-from typing import NamedTuple, Tuple
+from typing import Any, NamedTuple, Tuple
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -715,12 +715,12 @@ def clear_geodesy_cache() -> None:
     _logger.debug("Geodesy caches cleared")
 
 
-def get_geodesy_cache_info() -> dict:
+def get_geodesy_cache_info() -> dict[str, Any]:
     """Get cache statistics for geodesy computations.
 
     Returns
     -------
-    dict
+    dict[str, Any]
         Dictionary with cache statistics for inverse and direct geodetic caches.
     """
     return {

pytcl/navigation/great_circle.py

@@ -12,7 +12,7 @@ computing the shortest path on a sphere, including:
 
 import logging
 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
@@ -505,7 +505,7 @@ def great_circle_intersect(
     """
 
     # Convert to Cartesian unit vectors
-    def to_cartesian(lat, lon):
+    def to_cartesian(lat: Any, lon: Any) -> NDArray[np.float64]:
         return np.array(
             [np.cos(lat) * np.cos(lon), np.cos(lat) * np.sin(lon), np.sin(lat)]
         )
@@ -661,7 +661,7 @@ def great_circle_tdoa_loc(
     delta_d12 = delta_r12 / radius
     delta_d13 = delta_r13 / radius
 
-    def objective(lat, lon):
+    def objective(lat: Any, lon: Any) -> Any:
         """Objective function: difference between computed and observed TDOAs."""
         d1 = great_circle_distance(lat, lon, lat1, lon1, radius=1.0)
         d2 = great_circle_distance(lat, lon, lat2, lon2, radius=1.0)
@@ -836,12 +836,12 @@ def clear_great_circle_cache() -> None:
     _logger.debug("Great circle caches cleared")
 
 
-def get_cache_info() -> dict:
+def get_cache_info() -> dict[str, Any]:
     """Get cache statistics for great circle computations.
 
     Returns
     -------
-    dict
+    dict[str, Any]
         Dictionary with cache statistics for distance and azimuth caches.
     """
     return {

pytcl/plotting/coordinates.py

@@ -5,10 +5,10 @@ This module provides functions for visualizing coordinate systems,
 rotations, and transformations in 2D and 3D.
 """
 
-from typing import List, Optional, Tuple
+from typing import Any, List, Optional, Tuple
 
 import numpy as np
-from numpy.typing import ArrayLike
+from numpy.typing import ArrayLike, NDArray
 
 try:
     import plotly.graph_objects as go
@@ -180,17 +180,17 @@ def plot_euler_angles(
     angles = np.asarray(angles)
 
     # Create rotation matrices for each axis
-    def rotx(a):
+    def rotx(a: Any) -> NDArray[np.float64]:
         return np.array(
             [[1, 0, 0], [0, np.cos(a), -np.sin(a)], [0, np.sin(a), np.cos(a)]]
         )
 
-    def roty(a):
+    def roty(a: Any) -> NDArray[np.float64]:
         return np.array(
             [[np.cos(a), 0, np.sin(a)], [0, 1, 0], [-np.sin(a), 0, np.cos(a)]]
         )
 
-    def rotz(a):
+    def rotz(a: Any) -> NDArray[np.float64]:
         return np.array(
             [[np.cos(a), -np.sin(a), 0], [np.sin(a), np.cos(a), 0], [0, 0, 1]]
         )
@@ -293,7 +293,7 @@ def plot_quaternion_interpolation(
     q_end = q_end / np.linalg.norm(q_end)
 
     # SLERP interpolation
-    def quat_slerp(q1, q2, t):
+    def quat_slerp(q1: Any, q2: Any, t: Any) -> NDArray[np.float64]:
         dot = np.dot(q1, q2)
         if dot < 0:
             q2 = -q2
@@ -303,7 +303,7 @@ def plot_quaternion_interpolation(
         theta = np.arccos(dot)
         return (np.sin((1 - t) * theta) * q1 + np.sin(t * theta) * q2) / np.sin(theta)
 
-    def quat_to_rotmat(q):
+    def quat_to_rotmat(q: Any) -> NDArray[np.float64]:
         w, x, y, z = q
         return np.array(
             [

pytcl/plotting/tracks.py

@@ -196,7 +196,7 @@ def plot_tracking_result(
     covariances: Optional[List[ArrayLike]] = None,
     x_idx: int = 0,
     y_idx: int = 2,
-    cov_xy_idx: tuple = (0, 2),
+    cov_xy_idx: tuple[int, int] = (0, 2),
     ellipse_interval: int = 5,
     n_std: float = 2.0,
     title: str = "Tracking Result",
@@ -596,7 +596,7 @@ def create_animated_tracking(
     covariances: Optional[List[ArrayLike]] = None,
     x_idx: int = 0,
     y_idx: int = 2,
-    cov_xy_idx: tuple = (0, 2),
+    cov_xy_idx: tuple[int, int] = (0, 2),
     n_std: float = 2.0,
     frame_duration: int = 100,
     title: str = "Animated Tracking",