nrl-tracker 0.22.1__tar.gz → 0.22.2__tar.gz

{nrl_tracker-0.22.1/nrl_tracker.egg-info → nrl_tracker-0.22.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nrl-tracker
-Version: 0.22.1
+Version: 0.22.2
 Summary: Python port of the U.S. Naval Research Laboratory's Tracker Component Library for target tracking algorithms
 Author: Original: David F. Crouse, Naval Research Laboratory
 Maintainer: Python Port Contributors

{nrl_tracker-0.22.1 → nrl_tracker-0.22.2/nrl_tracker.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nrl-tracker
-Version: 0.22.1
+Version: 0.22.2
 Summary: Python port of the U.S. Naval Research Laboratory's Tracker Component Library for target tracking algorithms
 Author: Original: David F. Crouse, Naval Research Laboratory
 Maintainer: Python Port Contributors

{nrl_tracker-0.22.1 → nrl_tracker-0.22.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nrl-tracker"
-version = "0.22.1"
+version = "0.22.2"
 description = "Python port of the U.S. Naval Research Laboratory's Tracker Component Library for target tracking algorithms"
 readme = "README.md"
 authors = [

{nrl_tracker-0.22.1 → nrl_tracker-0.22.2}/pytcl/__init__.py

@@ -20,7 +20,7 @@ References
        no. 5, pp. 18-27, May 2017.
 """
 
-__version__ = "0.22.1"
+__version__ = "0.22.2"
 __author__ = "Python Port Contributors"
 __original_author__ = "David F. Crouse, Naval Research Laboratory"
 

{nrl_tracker-0.22.1 → nrl_tracker-0.22.2}/tests/conftest.py

@@ -82,9 +82,7 @@ class NumpyTestCase:
 
     def assert_shape(self, arr, expected_shape):
         """Assert array has expected shape."""
-        assert (
-            arr.shape == expected_shape
-        ), f"Expected shape {expected_shape}, got {arr.shape}"
+        assert arr.shape == expected_shape, f"Expected shape {expected_shape}, got {arr.shape}"
 
     def assert_symmetric(self, arr, rtol=1e-10):
         """Assert matrix is symmetric."""

{nrl_tracker-0.22.1 → nrl_tracker-0.22.2}/tests/test_astronomical.py

@@ -150,9 +150,7 @@ class TestOrbitalElementConversions:
 
     def test_roundtrip_elements_state(self):
         """Test elements -> state -> elements roundtrip."""
-        elements_orig = OrbitalElements(
-            a=8000, e=0.2, i=0.5, raan=0.3, omega=0.8, nu=1.0
-        )
+        elements_orig = OrbitalElements(a=8000, e=0.2, i=0.5, raan=0.3, omega=0.8, nu=1.0)
         state = orbital_elements_to_state(elements_orig)
         elements_back = state_to_orbital_elements(state)
 

{nrl_tracker-0.22.1 → nrl_tracker-0.22.2}/tests/test_coordinate_systems.py

@@ -403,9 +403,7 @@ class TestSlerp:
 
         # Should be 45 deg rotation about z
         expected_angle = angle / 2
-        expected = np.array(
-            [np.cos(expected_angle / 2), 0, 0, np.sin(expected_angle / 2)]
-        )
+        expected = np.array([np.cos(expected_angle / 2), 0, 0, np.sin(expected_angle / 2)])
         np.testing.assert_allclose(result, expected, atol=1e-10)
 
 

{nrl_tracker-0.22.1 → nrl_tracker-0.22.2}/tests/test_coverage_boost.py

@@ -438,9 +438,7 @@ class TestCoordinatedTurnProcessNoise:
         T = 0.1
         sigma_a = 1.0
         sigma_omega = 0.01
-        Q = q_coord_turn_2d(
-            T, sigma_a, sigma_omega, state_type="position_velocity_omega"
-        )
+        Q = q_coord_turn_2d(T, sigma_a, sigma_omega, state_type="position_velocity_omega")
         assert Q.shape == (5, 5)
         np.testing.assert_allclose(Q, Q.T)
 

{nrl_tracker-0.22.1 → nrl_tracker-0.22.2}/tests/test_coverage_boost_2.py

@@ -121,9 +121,7 @@ class TestParticleFilters:
         def likelihood_func(z, x):
             return gaussian_likelihood(z, x, R)
 
-        new_weights, log_lik = bootstrap_pf_update(
-            particles, weights, z, likelihood_func
-        )
+        new_weights, log_lik = bootstrap_pf_update(particles, weights, z, likelihood_func)
 
         assert new_weights.shape == weights.shape
         assert np.isclose(np.sum(new_weights), 1.0)
@@ -327,9 +325,7 @@ class TestParticleFilters:
 
         mean = particle_mean(particles, weights)
 
-        expected = (
-            0.5 * np.array([0, 0]) + 0.3 * np.array([1, 1]) + 0.2 * np.array([2, 2])
-        )
+        expected = 0.5 * np.array([0, 0]) + 0.3 * np.array([1, 1]) + 0.2 * np.array([2, 2])
         assert np.allclose(mean, expected)
 
     def test_particle_covariance(self):
@@ -995,9 +991,7 @@ class TestNavigationCoverage:
         tdoa12 = 0.0
         tdoa13 = 0.0
 
-        result1, result2 = great_circle_tdoa_loc(
-            lat1, lon1, lat2, lon2, lat3, lon3, tdoa12, tdoa13
-        )
+        result1, result2 = great_circle_tdoa_loc(lat1, lon1, lat2, lon2, lat3, lon3, tdoa12, tdoa13)
 
         # Should return at least one solution
         assert result1 is not None or result2 is not None

{nrl_tracker-0.22.1 → nrl_tracker-0.22.2}/tests/test_egm.py

@@ -98,9 +98,7 @@ class TestClenshawSumOrderDerivative:
         cos_theta = 0.5
         sin_theta = np.sqrt(1 - cos_theta**2)
 
-        result = clenshaw_sum_order_derivative(
-            0, cos_theta, sin_theta, coef.C, coef.S, 10
-        )
+        result = clenshaw_sum_order_derivative(0, cos_theta, sin_theta, coef.C, coef.S, 10)
 
         assert isinstance(result, tuple)
         assert len(result) == 4
@@ -142,12 +140,8 @@ class TestClenshawPotential:
         lat = np.radians(30)
         lon = 0
 
-        V_close = clenshaw_potential(
-            lat, lon, coef.R, coef.C, coef.S, coef.R, coef.GM, 10
-        )
-        V_far = clenshaw_potential(
-            lat, lon, coef.R * 1.1, coef.C, coef.S, coef.R, coef.GM, 10
-        )
+        V_close = clenshaw_potential(lat, lon, coef.R, coef.C, coef.S, coef.R, coef.GM, 10)
+        V_far = clenshaw_potential(lat, lon, coef.R * 1.1, coef.C, coef.S, coef.R, coef.GM, 10)
 
         # Potential magnitude should decrease with distance
         assert abs(V_far) < abs(V_close)
@@ -158,12 +152,8 @@ class TestClenshawPotential:
         lon = 0
         r = coef.R
 
-        V_north = clenshaw_potential(
-            np.radians(45), lon, r, coef.C, coef.S, coef.R, coef.GM, 10
-        )
-        V_south = clenshaw_potential(
-            np.radians(-45), lon, r, coef.C, coef.S, coef.R, coef.GM, 10
-        )
+        V_north = clenshaw_potential(np.radians(45), lon, r, coef.C, coef.S, coef.R, coef.GM, 10)
+        V_south = clenshaw_potential(np.radians(-45), lon, r, coef.C, coef.S, coef.R, coef.GM, 10)
 
         # For Earth's gravity field (with small asymmetries), should be close
         # The potential is dominated by the central term, so relative difference is small
@@ -195,9 +185,7 @@ class TestClenshawGravity:
         lon = np.radians(0)
         r = coef.R
 
-        g_r, g_lat, g_lon = clenshaw_gravity(
-            lat, lon, r, coef.C, coef.S, coef.R, coef.GM, 10
-        )
+        g_r, g_lat, g_lon = clenshaw_gravity(lat, lon, r, coef.C, coef.S, coef.R, coef.GM, 10)
 
         # Full gravity includes the central term GM/r^2 which is about 9.8 m/s^2
         # The sign depends on convention - we compute -dV/dr
@@ -257,9 +245,7 @@ class TestAssociatedLegendreScaled:
             for m in range(n + 1):
                 # exp is indexed by degree only (1D array)
                 P_reconstructed = P_scaled[n, m] * (10.0 ** exp[n])
-                assert_allclose(
-                    P_reconstructed, P_unscaled[n, m], rtol=1e-8, atol=1e-12
-                )
+                assert_allclose(P_reconstructed, P_unscaled[n, m], rtol=1e-8, atol=1e-12)
 
     def test_no_overflow_high_degree(self):
         """High degree computation doesn't overflow."""
@@ -320,9 +306,7 @@ class TestGeoidHeight:
         # Test several locations
         for lat in [0, 45, -45, 90]:
             for lon in [0, 90, -90, 180]:
-                N = geoid_height(
-                    np.radians(lat), np.radians(lon), coefficients=coef, n_max=36
-                )
+                N = geoid_height(np.radians(lat), np.radians(lon), coefficients=coef, n_max=36)
                 assert not np.isnan(N)
                 assert not np.isinf(N)
 
@@ -348,9 +332,7 @@ class TestGeoidHeights:
         lon = np.radians(-75)
 
         N_single = geoid_height(lat, lon, coefficients=coef, n_max=10)
-        N_batch = geoid_heights(
-            np.array([lat]), np.array([lon]), coefficients=coef, n_max=10
-        )
+        N_batch = geoid_heights(np.array([lat]), np.array([lon]), coefficients=coef, n_max=10)
 
         assert_allclose(N_batch[0], N_single)
 
@@ -380,9 +362,7 @@ class TestGravityDisturbance:
             np.radians(30), np.radians(60), h=0.0, coefficients=coef, n_max=10
         )
 
-        expected_mag = np.sqrt(
-            result.delta_g_r**2 + result.delta_g_lat**2 + result.delta_g_lon**2
-        )
+        expected_mag = np.sqrt(result.delta_g_r**2 + result.delta_g_lat**2 + result.delta_g_lon**2)
         assert_allclose(result.magnitude, expected_mag)
 
     def test_disturbance_decreases_with_altitude(self):
@@ -392,9 +372,7 @@ class TestGravityDisturbance:
         lon = np.radians(0)
 
         result_0 = gravity_disturbance(lat, lon, h=0.0, coefficients=coef, n_max=20)
-        result_10km = gravity_disturbance(
-            lat, lon, h=10000.0, coefficients=coef, n_max=20
-        )
+        result_10km = gravity_disturbance(lat, lon, h=10000.0, coefficients=coef, n_max=20)
 
         # Disturbance magnitude should decrease with altitude
         assert result_10km.magnitude < result_0.magnitude
@@ -407,9 +385,7 @@ class TestGravityAnomaly:
         """gravity_anomaly returns a float."""
         coef = create_test_coefficients(n_max=10)
 
-        anom = gravity_anomaly(
-            np.radians(45), np.radians(-75), h=0.0, coefficients=coef, n_max=10
-        )
+        anom = gravity_anomaly(np.radians(45), np.radians(-75), h=0.0, coefficients=coef, n_max=10)
 
         assert isinstance(anom, float)
         assert not np.isnan(anom)
@@ -418,9 +394,7 @@ class TestGravityAnomaly:
         """Gravity anomaly computation produces finite values."""
         coef = create_test_coefficients(n_max=36)
 
-        anom = gravity_anomaly(
-            np.radians(45), np.radians(0), h=0.0, coefficients=coef, n_max=36
-        )
+        anom = gravity_anomaly(np.radians(45), np.radians(0), h=0.0, coefficients=coef, n_max=36)
 
         # Note: With test coefficients (including full J2), values are large
         # because J2 represents the equatorial bulge which is part of the
@@ -449,9 +423,7 @@ class TestDeflectionOfVertical:
         """Deflection values are finite."""
         coef = create_test_coefficients(n_max=36)
 
-        xi, eta = deflection_of_vertical(
-            np.radians(45), np.radians(0), coefficients=coef, n_max=36
-        )
+        xi, eta = deflection_of_vertical(np.radians(45), np.radians(0), coefficients=coef, n_max=36)
 
         # Note: Test coefficients include full J2, so deflections are larger
         # than real-world values which are typically < 60 arcseconds.
@@ -521,16 +493,12 @@ class TestClenshawVsNaive:
         r = coef.R
 
         # Compute potential using Clenshaw
-        V_clenshaw = clenshaw_potential(
-            lat, lon, r, coef.C, coef.S, coef.R, coef.GM, 10
-        )
+        V_clenshaw = clenshaw_potential(lat, lon, r, coef.C, coef.S, coef.R, coef.GM, 10)
 
         # Compute using naive spherical harmonic sum
         # spherical_harmonic_sum takes (lat, lon, r, C, S, R, GM, n_max)
         # and returns (V, dV_r, dV_lat)
-        V_naive, _, _ = spherical_harmonic_sum(
-            lat, lon, r, coef.C, coef.S, coef.R, coef.GM, 10
-        )
+        V_naive, _, _ = spherical_harmonic_sum(lat, lon, r, coef.C, coef.S, coef.R, coef.GM, 10)
 
         # Should match to reasonable precision
         # (Clenshaw and naive may have different numerical properties)
@@ -578,12 +546,8 @@ class TestEdgeCases:
         """Negative longitude works correctly."""
         coef = create_test_coefficients(n_max=20)
 
-        N_pos = geoid_height(
-            np.radians(45), np.radians(90), coefficients=coef, n_max=20
-        )
-        N_neg = geoid_height(
-            np.radians(45), np.radians(-270), coefficients=coef, n_max=20
-        )
+        N_pos = geoid_height(np.radians(45), np.radians(90), coefficients=coef, n_max=20)
+        N_neg = geoid_height(np.radians(45), np.radians(-270), coefficients=coef, n_max=20)
 
         # 90° and -270° are the same longitude
         assert_allclose(N_pos, N_neg, rtol=1e-10)

{nrl_tracker-0.22.1 → nrl_tracker-0.22.2}/tests/test_emm.py

@@ -130,41 +130,31 @@ class TestEMMFunction:
 
     def test_total_intensity_reasonable(self, test_coefficients):
         """Total field intensity should be in expected range."""
-        result = emm(
-            np.radians(45), np.radians(0), 0, 2020.0, coefficients=test_coefficients
-        )
+        result = emm(np.radians(45), np.radians(0), 0, 2020.0, coefficients=test_coefficients)
         # Field intensity typically 25,000-65,000 nT at mid-latitudes
         # but can exceed this at high latitudes, allow up to 100,000 nT
         assert 20000 < result.F < 100000
 
     def test_horizontal_intensity_formula(self, test_coefficients):
         """H = sqrt(X^2 + Y^2)."""
-        result = emm(
-            np.radians(40), np.radians(-75), 0, 2020.0, coefficients=test_coefficients
-        )
+        result = emm(np.radians(40), np.radians(-75), 0, 2020.0, coefficients=test_coefficients)
         H_calc = np.sqrt(result.X**2 + result.Y**2)
         assert_allclose(result.H, H_calc, rtol=1e-10)
 
     def test_total_intensity_formula(self, test_coefficients):
         """F = sqrt(H^2 + Z^2)."""
-        result = emm(
-            np.radians(40), np.radians(-75), 0, 2020.0, coefficients=test_coefficients
-        )
+        result = emm(np.radians(40), np.radians(-75), 0, 2020.0, coefficients=test_coefficients)
         F_calc = np.sqrt(result.H**2 + result.Z**2)
         assert_allclose(result.F, F_calc, rtol=1e-10)
 
     def test_declination_range(self, test_coefficients):
         """Declination should be within -180 to 180 degrees."""
-        result = emm(
-            np.radians(45), np.radians(-75), 0, 2020.0, coefficients=test_coefficients
-        )
+        result = emm(np.radians(45), np.radians(-75), 0, 2020.0, coefficients=test_coefficients)
         assert -np.pi <= result.D <= np.pi
 
     def test_inclination_range(self, test_coefficients):
         """Inclination should be within -90 to 90 degrees."""
-        result = emm(
-            np.radians(45), np.radians(-75), 0, 2020.0, coefficients=test_coefficients
-        )
+        result = emm(np.radians(45), np.radians(-75), 0, 2020.0, coefficients=test_coefficients)
         assert -np.pi / 2 <= result.I <= np.pi / 2
 
 
@@ -229,9 +219,7 @@ class TestWMMHR:
 
     def test_wmmhr_returns_result(self, test_coefficients):
         """WMMHR returns MagneticResult."""
-        result = wmmhr(
-            np.radians(45), np.radians(-75), 0, 2025.0, coefficients=test_coefficients
-        )
+        result = wmmhr(np.radians(45), np.radians(-75), 0, 2025.0, coefficients=test_coefficients)
         assert hasattr(result, "F")
         assert hasattr(result, "D")
         assert hasattr(result, "I")
@@ -271,9 +259,7 @@ class TestConvenienceFunctions:
 
     def test_emm_declination(self, test_coefficients):
         """emm_declination returns correct value."""
-        result = emm(
-            np.radians(40), np.radians(-105), 0, 2020.0, coefficients=test_coefficients
-        )
+        result = emm(np.radians(40), np.radians(-105), 0, 2020.0, coefficients=test_coefficients)
         D = emm_declination(
             np.radians(40), np.radians(-105), 0, 2020.0, coefficients=test_coefficients
         )
@@ -281,9 +267,7 @@ class TestConvenienceFunctions:
 
     def test_emm_inclination(self, test_coefficients):
         """emm_inclination returns correct value."""
-        result = emm(
-            np.radians(40), np.radians(-105), 0, 2020.0, coefficients=test_coefficients
-        )
+        result = emm(np.radians(40), np.radians(-105), 0, 2020.0, coefficients=test_coefficients)
         incl = emm_inclination(
             np.radians(40), np.radians(-105), 0, 2020.0, coefficients=test_coefficients
         )
@@ -291,9 +275,7 @@ class TestConvenienceFunctions:
 
     def test_emm_intensity(self, test_coefficients):
         """emm_intensity returns correct value."""
-        result = emm(
-            np.radians(40), np.radians(-105), 0, 2020.0, coefficients=test_coefficients
-        )
+        result = emm(np.radians(40), np.radians(-105), 0, 2020.0, coefficients=test_coefficients)
         F = emm_intensity(
             np.radians(40), np.radians(-105), 0, 2020.0, coefficients=test_coefficients
         )
@@ -331,12 +313,8 @@ class TestSecularVariation:
 
     def test_field_changes_with_time(self, test_coefficients):
         """Field should change slightly between years."""
-        result_2020 = emm(
-            np.radians(45), np.radians(0), 0, 2020.0, coefficients=test_coefficients
-        )
-        result_2022 = emm(
-            np.radians(45), np.radians(0), 0, 2022.0, coefficients=test_coefficients
-        )
+        result_2020 = emm(np.radians(45), np.radians(0), 0, 2020.0, coefficients=test_coefficients)
+        result_2022 = emm(np.radians(45), np.radians(0), 0, 2022.0, coefficients=test_coefficients)
         # Small but non-zero change expected
         # Secular variation is ~50-100 nT/year at mid-latitudes
         assert result_2020.F != result_2022.F
@@ -411,9 +389,7 @@ class TestHighDegreeEvaluation:
     def test_higher_degree_coefficients(self):
         """Test with higher degree coefficients (n_max=50)."""
         coef = create_emm_test_coefficients(n_max=50)
-        result = emm(
-            np.radians(40), np.radians(-105), 0, 2020.0, coefficients=coef, n_max=50
-        )
+        result = emm(np.radians(40), np.radians(-105), 0, 2020.0, coefficients=coef, n_max=50)
         assert not np.isnan(result.F)
         assert result.F > 0
 
@@ -422,12 +398,8 @@ class TestHighDegreeEvaluation:
         coef = create_emm_test_coefficients(n_max=50)
 
         # Evaluate at different n_max values
-        result_12 = emm(
-            np.radians(40), np.radians(-105), 0, 2020.0, coefficients=coef, n_max=12
-        )
-        result_50 = emm(
-            np.radians(40), np.radians(-105), 0, 2020.0, coefficients=coef, n_max=50
-        )
+        result_12 = emm(np.radians(40), np.radians(-105), 0, 2020.0, coefficients=coef, n_max=12)
+        result_50 = emm(np.radians(40), np.radians(-105), 0, 2020.0, coefficients=coef, n_max=50)
 
         # Both should be valid
         assert result_12.F > 0