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

pytcl/dynamic_estimation/rbpf.py

@@ -23,7 +23,7 @@ References:
   (IEEE SPM, 2004)
 """
 
-from typing import Callable, NamedTuple
+from typing import Any, Callable, NamedTuple
 
 import numpy as np
 from numpy.typing import NDArray
@@ -46,9 +46,9 @@ class RBPFParticle(NamedTuple):
         Particle weight (typically normalized to sum to 1)
     """
 
-    y: NDArray
-    x: NDArray
-    P: NDArray
+    y: NDArray[Any]
+    x: NDArray[Any]
+    P: NDArray[Any]
     w: float
 
 
@@ -96,9 +96,9 @@ class RBPFFilter:
 
     def initialize(
         self,
-        y0: NDArray,
-        x0: NDArray,
-        P0: NDArray,
+        y0: NDArray[Any],
+        x0: NDArray[Any],
+        P0: NDArray[Any],
         num_particles: int = 100,
     ) -> None:
         """Initialize particles.
@@ -132,12 +132,12 @@ class RBPFFilter:
 
     def predict(
         self,
-        g: Callable[[NDArray], NDArray],
-        G: NDArray,
-        Qy: NDArray,
-        f: Callable[[NDArray, NDArray], NDArray],
-        F: NDArray,
-        Qx: NDArray,
+        g: Callable[[NDArray[Any]], NDArray[Any]],
+        G: NDArray[Any],
+        Qy: NDArray[Any],
+        f: Callable[[NDArray[Any], NDArray[Any]], NDArray[Any]],
+        F: NDArray[Any],
+        Qx: NDArray[Any],
     ) -> None:
         """Predict step: propagate particles and linear states.
 
@@ -167,7 +167,7 @@ class RBPFFilter:
             )
 
             # Create wrapper for linear dynamics with current y_pred
-            def f_wrapper(x):
+            def f_wrapper(x: NDArray[Any]) -> NDArray[Any]:
                 return f(x, y_pred)
 
             # Predict linear component using EKF
@@ -185,10 +185,10 @@ class RBPFFilter:
 
     def update(
         self,
-        z: NDArray,
-        h: Callable[[NDArray, NDArray], NDArray],
-        H: NDArray,
-        R: NDArray,
+        z: NDArray[Any],
+        h: Callable[[NDArray[Any], NDArray[Any]], NDArray[Any]],
+        H: NDArray[Any],
+        R: NDArray[Any],
     ) -> None:
         """Update step: adapt particle weights based on measurement.
 
@@ -208,7 +208,7 @@ class RBPFFilter:
 
         for i, particle in enumerate(self.particles):
             # Create wrapper for measurement function with current y
-            def h_wrapper(x):
+            def h_wrapper(x: NDArray[Any]) -> NDArray[Any]:
                 return h(x, particle.y)
 
             # Update linear component (Kalman update)
@@ -248,7 +248,7 @@ class RBPFFilter:
         # Merge if too many particles
         self._merge_particles()
 
-    def estimate(self) -> tuple[NDArray, NDArray]:
+    def estimate(self) -> tuple[NDArray[Any], NDArray[Any], NDArray[Any]]:
         """Estimate state as weighted mean and covariance.
 
         Returns
@@ -417,13 +417,12 @@ class RBPFFilter:
         w_sum = sum(p.w for p in self.particles)
         if w_sum > 0:
             self.particles = [
-                RBPFParticle(y=p.y, x=p.x, P=p.P, w=p.w / w_sum)
-                for p in self.particles
+                RBPFParticle(y=p.y, x=p.x, P=p.P, w=p.w / w_sum) for p in self.particles
             ]
 
     @staticmethod
     def _kl_divergence(
-        P1: NDArray, P2: NDArray, x1: NDArray, x2: NDArray
+        P1: NDArray[Any], P2: NDArray[Any], x1: NDArray[Any], x2: NDArray[Any]
     ) -> float:
         """Compute KL divergence between two Gaussians.
 
@@ -472,12 +471,12 @@ class RBPFFilter:
 
 def rbpf_predict(
     particles: list[RBPFParticle],
-    g: Callable[[NDArray], NDArray],
-    G: NDArray,
-    Qy: NDArray,
-    f: Callable[[NDArray, NDArray], NDArray],
-    F: NDArray,
-    Qx: NDArray,
+    g: Callable[[NDArray[Any]], NDArray[Any]],
+    G: NDArray[Any],
+    Qy: NDArray[Any],
+    f: Callable[[NDArray[Any], NDArray[Any]], NDArray[Any]],
+    F: NDArray[Any],
+    Qx: NDArray[Any],
 ) -> list[RBPFParticle]:
     """Predict step for RBPF particles.
 
@@ -508,12 +507,10 @@ def rbpf_predict(
     for particle in particles:
         # Predict nonlinear component
         y_pred = g(particle.y)
-        y_pred = y_pred + np.random.multivariate_normal(
-            np.zeros(y_pred.shape[0]), Qy
-        )
+        y_pred = y_pred + np.random.multivariate_normal(np.zeros(y_pred.shape[0]), Qy)
 
         # Create wrapper for linear dynamics with current y_pred
-        def f_wrapper(x):
+        def f_wrapper(x: NDArray[Any]) -> NDArray[Any]:
             return f(x, y_pred)
 
         # Predict linear component
@@ -532,10 +529,10 @@ def rbpf_predict(
 
 def rbpf_update(
     particles: list[RBPFParticle],
-    z: NDArray,
-    h: Callable[[NDArray, NDArray], NDArray],
-    H: NDArray,
-    R: NDArray,
+    z: NDArray[Any],
+    h: Callable[[NDArray[Any], NDArray[Any]], NDArray[Any]],
+    H: NDArray[Any],
+    R: NDArray[Any],
 ) -> list[RBPFParticle]:
     """Update step for RBPF particles.
 
@@ -562,7 +559,7 @@ def rbpf_update(
 
     for i, particle in enumerate(particles):
         # Create wrapper for measurement function with current y
-        def h_wrapper(x):
+        def h_wrapper(x: NDArray[Any]) -> NDArray[Any]:
             return h(x, particle.y)
 
         # Update linear component
@@ -588,6 +585,5 @@ def rbpf_update(
 
     # Update with new weights
     return [
-        RBPFParticle(y=p.y, x=p.x, P=p.P, w=w)
-        for p, w in zip(new_particles, weights)
+        RBPFParticle(y=p.y, x=p.x, P=p.P, w=w) for p, w in zip(new_particles, weights)
     ]

pytcl/gravity/spherical_harmonics.py

@@ -13,7 +13,7 @@ References
 
 import logging
 from functools import lru_cache
-from typing import Optional, Tuple
+from typing import Any, Optional, Tuple
 
 import numpy as np
 from numpy.typing import NDArray
@@ -37,7 +37,7 @@ def _associated_legendre_cached(
     m_max: int,
     x_quantized: float,
     normalized: bool,
-) -> tuple:
+) -> tuple[tuple[np.ndarray[Any, Any], ...], ...]:
     """Cached Legendre polynomial computation (internal).
 
     Returns tuple of tuples for hashability.
@@ -543,7 +543,7 @@ def clear_legendre_cache() -> None:
     _logger.debug("Legendre polynomial cache cleared")
 
 
-def get_legendre_cache_info():
+def get_legendre_cache_info() -> Any:
     """Get cache statistics for Legendre polynomials.
 
     Returns

pytcl/gravity/tides.py

@@ -77,9 +77,9 @@ class OceanTideLoading(NamedTuple):
         Names of tidal constituents.
     """
 
-    amplitude: NDArray
-    phase: NDArray
-    constituents: Tuple[str, ...]
+    amplitude: NDArray[np.floating]
+    phase: NDArray[np.floating]
+    constituents: tuple[str, ...]
 
 
 # Love and Shida numbers for degree 2 (IERS 2010)
@@ -593,9 +593,9 @@ def solid_earth_tide_gravity(
 
 def ocean_tide_loading_displacement(
     mjd: float,
-    amplitude: NDArray,
-    phase: NDArray,
-    constituents: Tuple[str, ...] = ("M2", "S2", "N2", "K2", "K1", "O1", "P1", "Q1"),
+    amplitude: NDArray[np.floating],
+    phase: NDArray[np.floating],
+    constituents: tuple[str, ...] = ("M2", "S2", "N2", "K2", "K1", "O1", "P1", "Q1"),
 ) -> TidalDisplacement:
     """
     Compute ocean tide loading displacement.

pytcl/logging_config.py

@@ -26,7 +26,7 @@ import functools
 import logging
 import time
 from contextlib import contextmanager
-from typing import Any, Callable, Optional, TypeVar
+from typing import Any, Callable, Generator, Optional, TypeVar
 
 # Type variable for decorated functions
 F = TypeVar("F", bound=Callable[..., Any])
@@ -201,7 +201,7 @@ def TimingContext(
     logger: Optional[logging.Logger] = None,
     name: str = "operation",
     level: int = logging.DEBUG,
-):
+) -> Generator[None, None, None]:
     """
     Context manager for timing code blocks.
 
@@ -268,7 +268,7 @@ class PerformanceTracker:
         self.max_ms = 0.0
 
     @contextmanager
-    def track(self):
+    def track(self) -> Generator[None, None, None]:
         """Track a single operation."""
         start = time.perf_counter()
         try:

pytcl/magnetism/emm.py

@@ -24,7 +24,7 @@ References
 import os
 from functools import lru_cache
 from pathlib import Path
-from typing import Dict, NamedTuple, Optional, Tuple
+from typing import Any, NamedTuple, Optional, Tuple
 
 import numpy as np
 from numpy.typing import NDArray
@@ -32,7 +32,7 @@ from numpy.typing import NDArray
 from .wmm import MagneticResult
 
 # Model parameters
-EMM_PARAMETERS: Dict[str, Dict] = {
+EMM_PARAMETERS: dict[str, dict[str, Any]] = {
     "EMM2017": {
         "n_max": 790,
         "epoch": 2017.0,
@@ -119,7 +119,14 @@ def _ensure_data_dir() -> Path:
 def parse_emm_file(
     filepath: Path,
     n_max: Optional[int] = None,
-) -> Tuple[NDArray, NDArray, NDArray, NDArray, float, int]:
+) -> tuple[
+    NDArray[np.floating],
+    NDArray[np.floating],
+    NDArray[np.floating],
+    NDArray[np.floating],
+    float,
+    int,
+]:
     """Parse an EMM/WMMHR coefficient file.
 
     The file format is similar to WMM but with more coefficients:

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,