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

pytcl/static_estimation/maximum_likelihood.py

@@ -12,7 +12,7 @@ References
        Wiley, 2001.
 """
 
-from typing import Callable, NamedTuple, Optional
+from typing import Any, Callable, NamedTuple, Optional
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -75,10 +75,10 @@ class CRBResult(NamedTuple):
 
 
 def fisher_information_numerical(
-    log_likelihood: Callable[[NDArray], float],
+    log_likelihood: Callable[[np.ndarray[Any, Any]], float],
     theta: ArrayLike,
     h: float = 1e-5,
-) -> NDArray[np.floating]:
+) -> np.ndarray[Any, Any]:
     """
     Compute Fisher information matrix numerically.
 
@@ -189,11 +189,13 @@ def fisher_information_gaussian(
 
 
 def fisher_information_exponential_family(
-    sufficient_stats: Callable[[NDArray, NDArray], NDArray],
+    sufficient_stats: Callable[
+        [np.ndarray[Any, Any], np.ndarray[Any, Any]], np.ndarray[Any, Any]
+    ],
     theta: ArrayLike,
     data: ArrayLike,
     h: float = 1e-5,
-) -> NDArray[np.floating]:
+) -> np.ndarray[Any, Any]:
     """
     Fisher information for exponential family distributions.
 
@@ -232,10 +234,10 @@ def fisher_information_exponential_family(
 
 
 def observed_fisher_information(
-    log_likelihood: Callable[[NDArray], float],
+    log_likelihood: Callable[[np.ndarray[Any, Any]], float],
     theta: ArrayLike,
     h: float = 1e-5,
-) -> NDArray[np.floating]:
+) -> np.ndarray[Any, Any]:
     """
     Compute observed Fisher information (negative Hessian).
 
@@ -409,10 +411,10 @@ def efficiency(
 
 
 def mle_newton_raphson(
-    log_likelihood: Callable[[NDArray], float],
-    score: Callable[[NDArray], NDArray],
+    log_likelihood: Callable[[np.ndarray[Any, Any]], float],
+    score: Callable[[np.ndarray[Any, Any]], np.ndarray[Any, Any]],
     theta_init: ArrayLike,
-    hessian: Optional[Callable[[NDArray], NDArray]] = None,
+    hessian: Optional[Callable[[np.ndarray[Any, Any]], np.ndarray[Any, Any]]] = None,
     max_iter: int = 100,
     tol: float = 1e-8,
     h: float = 1e-5,
@@ -460,7 +462,7 @@ def mle_newton_raphson(
 
     converged = False
 
-    def numerical_hessian(t: NDArray) -> NDArray:
+    def numerical_hessian(t: np.ndarray[Any, Any]) -> np.ndarray[Any, Any]:
         H = np.zeros((n_params, n_params))
         for i in range(n_params):
             for j in range(i, n_params):
@@ -532,9 +534,9 @@ def mle_newton_raphson(
 
 
 def mle_scoring(
-    log_likelihood: Callable[[NDArray], float],
-    score: Callable[[NDArray], NDArray],
-    fisher_info: Callable[[NDArray], NDArray],
+    log_likelihood: Callable[[np.ndarray[Any, Any]], float],
+    score: Callable[[np.ndarray[Any, Any]], np.ndarray[Any, Any]],
+    fisher_info: Callable[[np.ndarray[Any, Any]], np.ndarray[Any, Any]],
     theta_init: ArrayLike,
     max_iter: int = 100,
     tol: float = 1e-8,

pytcl/static_estimation/robust.py

@@ -12,7 +12,7 @@ References
        Cartography," Communications of the ACM, 1981.
 """
 
-from typing import Callable, NamedTuple, Optional
+from typing import Any, Callable, NamedTuple, Optional
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -313,8 +313,8 @@ def tau_scale(
 def irls(
     A: ArrayLike,
     b: ArrayLike,
-    weight_func: Callable[[NDArray], NDArray] = huber_weight,
-    scale_func: Callable[[NDArray], float] = mad,
+    weight_func: Callable[[np.ndarray[Any, Any]], np.ndarray[Any, Any]] = huber_weight,
+    scale_func: Callable[[np.ndarray[Any, Any]], float] = mad,
     max_iter: int = 50,
     tol: float = 1e-6,
 ) -> RobustResult:
@@ -455,7 +455,7 @@ def huber_regression(
     Gaussian errors and resistance to outliers.
     """
 
-    def weight_func(r: NDArray) -> NDArray:
+    def weight_func(r: np.ndarray[Any, Any]) -> np.ndarray[Any, Any]:
         return huber_weight(r, c)
 
     return irls(A, b, weight_func=weight_func, max_iter=max_iter, tol=tol)
@@ -504,7 +504,7 @@ def tukey_regression(
     Huber for gross outliers.
     """
 
-    def weight_func(r: NDArray) -> NDArray:
+    def weight_func(r: np.ndarray[Any, Any]) -> np.ndarray[Any, Any]:
         return tukey_weight(r, c)
 
     return irls(A, b, weight_func=weight_func, max_iter=max_iter, tol=tol)

pytcl/terrain/loaders.py

@@ -21,7 +21,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
 
 import numpy as np
 from numpy.typing import NDArray
@@ -31,7 +31,7 @@ from .dem import DEMGrid
 # Model parameters
 _GEBCO_BASE_URL = "https://www.gebco.net/data-products/gridded-bathymetry-data"
 
-GEBCO_PARAMETERS: Dict[str, Dict] = {
+GEBCO_PARAMETERS: dict[str, dict[str, Any]] = {
     "GEBCO2024": {
         "resolution_arcsec": 15.0,
         "n_lat": 43200,
@@ -58,7 +58,7 @@ GEBCO_PARAMETERS: Dict[str, Dict] = {
     },
 }
 
-EARTH2014_PARAMETERS: Dict[str, Dict] = {
+EARTH2014_PARAMETERS: dict[str, dict[str, Any]] = {
     "SUR": {
         "description": "Physical surface (topography, ice surface, 0 over oceans)",
         "file_pattern": "Earth2014.SUR2014.1min.geod.bin",
@@ -275,7 +275,7 @@ def parse_gebco_netcdf(
     lat_max: Optional[float] = None,
     lon_min: Optional[float] = None,
     lon_max: Optional[float] = None,
-) -> Tuple[NDArray, float, float, float, float]:
+) -> tuple[NDArray[np.floating], float, float, float, float]:
     """Parse GEBCO NetCDF file and extract region.
 
     Parameters
@@ -369,7 +369,7 @@ def parse_earth2014_binary(
     lat_max: Optional[float] = None,
     lon_min: Optional[float] = None,
     lon_max: Optional[float] = None,
-) -> Tuple[NDArray, float, float, float, float]:
+) -> tuple[NDArray[np.floating], float, float, float, float]:
     """Parse Earth2014 binary file and extract region.
 
     Earth2014 files are stored as int16 big-endian binary data,

pytcl/trackers/hypothesis.py

@@ -155,7 +155,7 @@ def generate_joint_associations(
         track_idx: int,
         current: Dict[int, int],
         used_meas: Set[int],
-    ):
+    ) -> None:
         """Recursively enumerate associations."""
         if track_idx == n_tracks:
             associations.append(current.copy())

pytcl/trackers/mht.py

@@ -15,7 +15,7 @@ References
        IEEE Trans. Automatic Control, 1979.
 """
 
-from typing import Callable, Dict, List, NamedTuple, Optional, Set
+from typing import Callable, Dict, List, NamedTuple, Optional
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -322,8 +322,8 @@ class MHTTracker:
     def _predict_tracks(
         self,
         tracks: Dict[int, MHTTrack],
-        F: NDArray,
-        Q: NDArray,
+        F: NDArray[np.floating],
+        Q: NDArray[np.floating],
     ) -> Dict[int, MHTTrack]:
         """Predict all tracks forward in time."""
         predicted = {}
@@ -352,8 +352,8 @@ class MHTTracker:
     def _compute_gating_and_likelihoods(
         self,
         tracks: Dict[int, MHTTrack],
-        Z: NDArray,
-    ) -> tuple[Set[tuple], Dict[tuple, float]]:
+        Z: NDArray[np.floating],
+    ) -> tuple[set[tuple[int, int]], dict[tuple[int, int], float]]:
         """Compute gating matrix and likelihood values."""
         gated = set()
         likelihood_matrix = {}
@@ -387,8 +387,8 @@ class MHTTracker:
         self,
         association: Dict[int, int],
         tracks: Dict[int, MHTTrack],
-        Z: NDArray,
-        likelihood_matrix: Dict[tuple, float],
+        Z: NDArray[np.floating],
+        likelihood_matrix: dict[tuple[int, int], float],
     ) -> float:
         """Compute likelihood of a joint association."""
         likelihood = 1.0
@@ -417,7 +417,7 @@ class MHTTracker:
     def _update_track(
         self,
         track: MHTTrack,
-        measurement: NDArray,
+        measurement: NDArray[np.floating],
         meas_idx: int,
     ) -> MHTTrack:
         """Update a track with a measurement."""
@@ -502,7 +502,7 @@ class MHTTracker:
 
     def _initiate_track(
         self,
-        measurement: NDArray,
+        measurement: NDArray[np.floating],
         meas_idx: int,
     ) -> MHTTrack:
         """Initiate a new track from a measurement."""

pytcl/trackers/multi_target.py

@@ -225,7 +225,7 @@ class MultiTargetTracker:
                 track.covariance = F @ track.covariance @ F.T + Q
                 track.time = self._time
 
-    def _associate(self, Z: NDArray[np.float64]) -> dict:
+    def _associate(self, Z: NDArray[np.float64]) -> dict[int, int]:
         """
         Associate measurements to tracks using GNN.