nrl-tracker 1.11.1__py3-none-any.whl → 1.12.0__py3-none-any.whl

{nrl_tracker-1.11.1.dist-info → nrl_tracker-1.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nrl-tracker
-Version: 1.11.1
+Version: 1.12.0
 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
@@ -71,17 +71,17 @@ Requires-Dist: plotly>=5.15.0; extra == "visualization"
 
 # Tracker Component Library (Python)
 
-[![PyPI version](https://img.shields.io/badge/pypi-v1.11.0-blue.svg)](https://pypi.org/project/nrl-tracker/)
+[![PyPI version](https://img.shields.io/badge/pypi-v1.11.1-blue.svg)](https://pypi.org/project/nrl-tracker/)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 [![License: Public Domain](https://img.shields.io/badge/License-Public%20Domain-brightgreen.svg)](https://en.wikipedia.org/wiki/Public_domain)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
-[![Tests](https://img.shields.io/badge/tests-2894%20passing-success.svg)](https://github.com/nedonatelli/TCL)
+[![Tests](https://img.shields.io/badge/tests-3280%20passing-success.svg)](https://github.com/nedonatelli/TCL)
 [![MATLAB Parity](https://img.shields.io/badge/MATLAB%20Parity-100%25-brightgreen.svg)](docs/gap_analysis.rst)
 [![Type Checking](https://img.shields.io/badge/mypy--strict-passing-brightgreen.svg)](mypy.ini)
 
 A Python port of the [U.S. Naval Research Laboratory's Tracker Component Library](https://github.com/USNavalResearchLaboratory/TrackerComponentLibrary), a comprehensive collection of algorithms for target tracking, estimation, coordinate systems, and related mathematical functions.
 
-**1,070+ functions** | **153 modules** | **2,894 tests** | **100% MATLAB parity**
+**1,070+ functions** | **153 modules** | **3,280 tests** | **100% MATLAB parity**
 
 ## Overview
 

{nrl_tracker-1.11.1.dist-info → nrl_tracker-1.12.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pytcl/__init__.py,sha256=HmAtN7X6Ng4OxkKX7kayquTrnQkn_ILi6kP_X0Vtu1M,2032
+pytcl/__init__.py,sha256=d_xdJJ89h0N88qtQ41ZNqKLNj4tEoOjYoA7HQu55syk,2032
 pytcl/logging_config.py,sha256=UJaYufQgNuIjpsOMTPo3ewz1XCHPk8a08jTHyP7uoI4,8956
 pytcl/assignment_algorithms/__init__.py,sha256=kUWhmyLhZcs5GiUQA5_v7KA3qETGsvqV6wU8r7paO-k,2976
 pytcl/assignment_algorithms/data_association.py,sha256=tsRxWJZk9aAPmE99BKXGouEpFfZrjPjb4HXvgxFUHhU,11405
@@ -6,7 +6,7 @@ pytcl/assignment_algorithms/dijkstra_min_cost.py,sha256=z-Wk1HXRNKieBsRFqR8_UB8Q
 pytcl/assignment_algorithms/gating.py,sha256=JaRaFcFqjfdsTbbTP6k_GY2zemDSR02l5yInWHpb05Y,11439
 pytcl/assignment_algorithms/jpda.py,sha256=rOY_v1vesL6EJySwD0kRDTfe7wHoDFLITg_lJLM-bX4,21731
 pytcl/assignment_algorithms/nd_assignment.py,sha256=bcSNm3xSEjAg8gFb_TLQovpsLjNwvI5OOlh2y8XG4M0,24571
-pytcl/assignment_algorithms/network_flow.py,sha256=pPD63Z0-HOBv5XIqKUedt1KzTkcs0KG41DNojFZocDI,14459
+pytcl/assignment_algorithms/network_flow.py,sha256=-9tQY-kBrjsTHqv23rBD0-iebVvtAsK_a605Qn0_9SM,18619
 pytcl/assignment_algorithms/network_simplex.py,sha256=Qi10PsIYcTc6MZ-9GPl6ivaLaGA9F5-B7ltBbmasRNM,5566
 pytcl/assignment_algorithms/three_dimensional/__init__.py,sha256=1Q40OUlUQoo7YKEucwdrSNo3D4A0Zibvkr8z4TpueBg,526
 pytcl/assignment_algorithms/three_dimensional/assignment.py,sha256=OGcjg3Yr1tYriWYBJ5k6jiRMpOHDISK8FJDY0nTQxxw,19244
@@ -21,7 +21,7 @@ pytcl/astronomical/reference_frames.py,sha256=MBqprzBpEvdq3ngRL-_pp-Vnj7AqbuXhjU
 pytcl/astronomical/relativity.py,sha256=vSay4am_ElkiGRwuu_4rwo5C10eN8hm86jy43xmaEt4,15933
 pytcl/astronomical/sgp4.py,sha256=iNZrqMRUzR-LFeZiluzlNmkwxeYbIyF2F1cygyeEZVE,21546
 pytcl/astronomical/special_orbits.py,sha256=N54c_wAD7XKk_diDOw2QjUSkmYECMyWQDq2P6EeEBEI,12745
-pytcl/astronomical/time_systems.py,sha256=Jg0Zaq60hc4Ts1aQtb5bK4KSZhz-uQse8gYC89Y0-TA,15243
+pytcl/astronomical/time_systems.py,sha256=1r1DDRrMlX4eAe1d3quffIaTqIvaozmynza76aSfmrE,15615
 pytcl/astronomical/tle.py,sha256=t3e2-0f3Wiz77q-pC2jfpohkrDfoYOEHacpNgWMNLAk,14638
 pytcl/atmosphere/__init__.py,sha256=Joa6PBEfKun0Moii6BOzyVYG8AOFyvucKdVuY62ArQc,1685
 pytcl/atmosphere/ionosphere.py,sha256=tt_Qu1IvqZxah2P_QaWxpwroSgtDNU-6RrqtxMRZScY,16092
@@ -34,7 +34,7 @@ pytcl/clustering/hierarchical.py,sha256=MDBIcJtZHYruSsM_seAR9bNWKB63EDh1nIf6qAn4
 pytcl/clustering/kmeans.py,sha256=_r08KVvqHL1UnYE4rHBAJ1OKA97q-PWl2OOsTi6kKqk,10963
 pytcl/containers/__init__.py,sha256=i-o_KDjhbPWc9yAlgN1R5igmyWK3CVKIB-V7Qnr-fLg,2746
 pytcl/containers/base.py,sha256=oKD8vAH09qAEOG3uhtoTgJ9UU_hQhl6keSIlGEVucrs,7762
-pytcl/containers/cluster_set.py,sha256=uhfOIpXlYoI1U75TWcLMHjezVavnIZhVEGQHKCDmKo4,22774
+pytcl/containers/cluster_set.py,sha256=_VYQa3uCf66LJWtF3LA2lCjyVsuJtfUFD3wKH9vHknk,23995
 pytcl/containers/covertree.py,sha256=oA09TAZYdxJbfkOUxAmXxqDn-l2XoQeUsnupjTF0Vo0,13245
 pytcl/containers/kd_tree.py,sha256=01CsFsSmiKb0PGjdQ3z1apmvqjT2T8t-1bLwXzyJu3c,18016
 pytcl/containers/measurement_set.py,sha256=87AbdoZIUspn1yJsiMpyQ5LoEVcerUnXefXGGPtFTJg,12654
@@ -43,7 +43,7 @@ pytcl/containers/track_list.py,sha256=6q9Qgcwm-8H_JqtOCsMssF27av4XaSkhfDl-MWb1AB
 pytcl/containers/vptree.py,sha256=-7znAilGCNpN7SN8TxVhNFIOyP-s9oJa9Vp4FJWehcg,8720
 pytcl/coordinate_systems/__init__.py,sha256=jwYhu_-9AvOeP9WLG9PYtyDwfe0GjxNZ9-xCqiLymW4,3909
 pytcl/coordinate_systems/conversions/__init__.py,sha256=PkNevB78vBw0BkalydJBbQO91AyiMJxKRrgJNt4HsYc,1100
-pytcl/coordinate_systems/conversions/geodetic.py,sha256=CarrTBW9rTC-CZ4E4YGxA8QjlpauuXJ2ZScnzc4QvK8,25001
+pytcl/coordinate_systems/conversions/geodetic.py,sha256=v8ymPT5wUt8zGDPlttbbTkNHJMxKbBUfvgNserugwlU,27373
 pytcl/coordinate_systems/conversions/spherical.py,sha256=GwuS1k0aUQ3AG1zZJouioMjxSIuEPRZMk-arvUCTh2k,11563
 pytcl/coordinate_systems/jacobians/__init__.py,sha256=CRGB8GzvGT_sr4Ynm51S7gSX8grqt1pO1Pq1MWmHPTs,890
 pytcl/coordinate_systems/jacobians/jacobians.py,sha256=IkEwyseGM1LeI2-cQEqzGD-lCplK-PVCHup7Bh3QPl4,12947
@@ -52,7 +52,7 @@ pytcl/coordinate_systems/projections/projections.py,sha256=y_kwcu_zp0HHiKR-wp3v3
 pytcl/coordinate_systems/rotations/__init__.py,sha256=nqAz4iJd2hEOX_r7Tz4cE524sShyxdbtcQ5m56RrDLg,1047
 pytcl/coordinate_systems/rotations/rotations.py,sha256=-VheczqsqF-qHF46HVKYTe0oS76MTmqyXQV3EO2JAJs,22258
 pytcl/core/__init__.py,sha256=Rm02KyEP5jCgcaS6N6F-Bs2nLgW-EO1cjCD0NqAg664,3236
-pytcl/core/array_utils.py,sha256=SsgEiAoRCWxAVKq1aa5-nPdOi-2AB6XNObu0IaGClUk,13983
+pytcl/core/array_utils.py,sha256=XkOzJD_65clohicbXV_uvDXtxo9_oupVMQfk_D8T4ds,15288
 pytcl/core/constants.py,sha256=cwkCjzCU7zG2ZsFcbqwslN632v7Lw50L85s-5q892mo,9988
 pytcl/core/exceptions.py,sha256=6ImMiwL86BdmTt-Rc8fXLXxKUGQ-PcQQyxIvKKzw-n0,24324
 pytcl/core/maturity.py,sha256=Sut19NfH1-6f3Qd2QSC6OAqvDcVHJDwf5-F_-oEAMJA,11596
@@ -91,12 +91,12 @@ pytcl/dynamic_models/process_noise/coordinated_turn.py,sha256=0PciDXtXHjgQdaYf7q
 pytcl/dynamic_models/process_noise/polynomial.py,sha256=w5ZW5Ouw6QpVtev_mnuCmZoj6_O6ovb2L_ENKDhHYIc,7742
 pytcl/dynamic_models/process_noise/singer.py,sha256=ozAdzH4s0wGlBaxajdyZvSnK8_CumgsUZDKeMW-TxDs,5735
 pytcl/gpu/__init__.py,sha256=aESvpn4Sa48xrQ4SIPb0j8uBt9bgiVHK_BgCXRLNY3o,4278
-pytcl/gpu/ekf.py,sha256=KPaojhYrti9F74C71_Pgc22HKDJeBSUkyrA7Iis9-L4,12575
-pytcl/gpu/kalman.py,sha256=8swMqLsnXjdl9-0vOg6wEqxtVHQRHcV4bXjHL8RwUmk,16417
-pytcl/gpu/matrix_utils.py,sha256=x2SBjN6f21YUeOOKThBtmIPyBnAXhTCvWteTxJZlSs0,12601
-pytcl/gpu/particle_filter.py,sha256=gqPt2ROFCkP-maFIlC8n7Td-ZNDZAN-42Ahen6TOfz8,17259
-pytcl/gpu/ukf.py,sha256=83tclGEAs4LWxocvUHSk7JIoUHozQnqusxM1qk_iedk,13273
-pytcl/gpu/utils.py,sha256=cedaW4evKeGCykFXI2QL_Ns8dU1yjL42MmYXf2gfGsw,14812
+pytcl/gpu/ekf.py,sha256=Eveyy_pJ5AXMRPUIFL5p-kmJUGMPAmwuN9r4k5x_rlM,14212
+pytcl/gpu/kalman.py,sha256=7DsEjSnMksymE4IT4m1H27-7gaB5zhHzAHdbfp_ZpCk,16939
+pytcl/gpu/matrix_utils.py,sha256=HwUGj6TKgt7jFUI5vR95y4evW4ZgMdHCt8G9Dlxx0RY,13878
+pytcl/gpu/particle_filter.py,sha256=frLpeDQY81gNKTvxTYqRH0w7VKEmw42IaazYQE5T-yk,18149
+pytcl/gpu/ukf.py,sha256=SZ-JdA2bDzqSQwqhoYwQJKwGuaZbEWxa6sbSHPYkmJo,14268
+pytcl/gpu/utils.py,sha256=jeOZW_L1hzPFgUlwtWSCYQnl0sUzMCJiH5ekyHV4P4A,15242
 pytcl/gravity/__init__.py,sha256=5xNdQSrrkt7-1-JPOYqR38CqvNJ7qKlPyMK36DGm6-I,3693
 pytcl/gravity/clenshaw.py,sha256=zhEtIxUY6Uj8EMv7ucO3JMBqauA5shFKbUW0HO2hUfI,17240
 pytcl/gravity/egm.py,sha256=LAeNbaQ7eZakk0ciwLec0_8q41MrBFouVLpDsETis6o,19683
@@ -105,46 +105,46 @@ pytcl/gravity/spherical_harmonics.py,sha256=SbCIlfNuJBwQ1nIJKo0DzgeEfW7RD_QnyKI0
 pytcl/gravity/tides.py,sha256=NjsiXSiI7f-0qGr7G7YJVpIOVGzDxagz2S2vf_aRq68,28681
 pytcl/magnetism/__init__.py,sha256=pBASOzCPHNnYqUH_XDEblhGtjz50vY9uW2KS25A0zQQ,2701
 pytcl/magnetism/emm.py,sha256=iIdxSL0uGGIf8nfA-c_SmHvg9_J7HwRA2-qbQIUW6IE,22380
-pytcl/magnetism/igrf.py,sha256=3g0PsH8IdbwQQS28OR5XWD-g-QxvfUva7jOkKToxndQ,13384
-pytcl/magnetism/wmm.py,sha256=7YsxnBmxeH5WnTTZ3VE91gr55Qq-OvVmBRAMbqlhGVg,23479
+pytcl/magnetism/igrf.py,sha256=XsbhEwthNSb4i9keqqrSO9h_m62WD5AMAwg2eGpgaPc,15585
+pytcl/magnetism/wmm.py,sha256=DYUUNrigWNOR6BETHO7FmD69amDpzP4s4aV9jg0fkiQ,25160
 pytcl/mathematical_functions/__init__.py,sha256=zeJ1ffRRl83k2NHn3HTn-fgtFoWNPq6LCALc3xRo4Do,3767
 pytcl/mathematical_functions/basic_matrix/__init__.py,sha256=kZv3kMAEHBdVxhbyMxTyM0s-4XJP1tK6po82UsIE4tc,1318
-pytcl/mathematical_functions/basic_matrix/decompositions.py,sha256=PWJsFDiXM2T78RHdxBJZPFnl8kFbNZQpHrbpw0mhE00,12268
-pytcl/mathematical_functions/basic_matrix/special_matrices.py,sha256=kOozwP2CHAj4qyO7Z9ct6GwDMkmHkk1bQa0e9G98FgA,13499
+pytcl/mathematical_functions/basic_matrix/decompositions.py,sha256=yvmQt_1UAvG1O2fOg0lzXSDcJiYYFu2yDyloz8Gz8uM,12425
+pytcl/mathematical_functions/basic_matrix/special_matrices.py,sha256=jD20KOJHF7P8xT5mtID1aniLUY84Dz701GwDbRrXKug,14545
 pytcl/mathematical_functions/combinatorics/__init__.py,sha256=byuHI0WkxOkQF8egrfjEr-awB2visWDXlGMnDux5IBg,1043
 pytcl/mathematical_functions/combinatorics/combinatorics.py,sha256=LzVxY3E5_pnpVl9XlcRdQjWhSSY8Fa1JUVYA6J25fro,12354
 pytcl/mathematical_functions/continuous_optimization/__init__.py,sha256=lck60eeCUOsRpEzPHBY3kiLKwNz_fhmYoUGP3lTmTwk,55
 pytcl/mathematical_functions/geometry/__init__.py,sha256=DhCmux9-6zxYRzlhQ9du18kvUL-leiiZwdd3Cmb5WX0,1092
-pytcl/mathematical_functions/geometry/geometry.py,sha256=iLKqTlLEGm8IScEDHEWOBQz5xfj-fflzIOzZaJ8fPtE,16522
+pytcl/mathematical_functions/geometry/geometry.py,sha256=mjbGAIp3F-YsVoUdVhoPQOD4bTnZrdniwVZJ2-Kja8U,17710
 pytcl/mathematical_functions/interpolation/__init__.py,sha256=lK4Rs0Ds_fzf9q0n6id5epdN0U8V7yD87dS-w1hvN8I,741
-pytcl/mathematical_functions/interpolation/interpolation.py,sha256=2cXMDgWBjWDGHnK1K_lawFlJL8oPl5AQGf9MNgsESfo,12610
+pytcl/mathematical_functions/interpolation/interpolation.py,sha256=E_CAexA4m-xOincCvslvPVqaw8FSRk55IAqd2CBbdak,15649
 pytcl/mathematical_functions/numerical_integration/__init__.py,sha256=iXiHzyV_KIhCv7tXErXlN1_fUEACN6yN3CYDHRA7esw,974
 pytcl/mathematical_functions/numerical_integration/quadrature.py,sha256=F5y8UQltTiAyIj_lGuuRYnSf465Rm_DNHMeq-E8bj-8,17732
 pytcl/mathematical_functions/polynomials/__init__.py,sha256=WJWZcoQhnvy5f59-kncMTgD9mCtgwfDgULvDYYHS5ys,43
 pytcl/mathematical_functions/signal_processing/__init__.py,sha256=_SzzBVtxmSvP8FKeogRdNmFo8FOVDDoexVOqd-lE7do,2325
-pytcl/mathematical_functions/signal_processing/detection.py,sha256=vLToMHdPkhom6ouo1oN0QqBYjEGv7SQENqTD0DOv1XY,30934
-pytcl/mathematical_functions/signal_processing/filters.py,sha256=xiB8VSFqTFkBCAom0yIWw7pK3Zjm6l-VZ_DAtwJMxFA,23676
-pytcl/mathematical_functions/signal_processing/matched_filter.py,sha256=El7XcUbunmXA7s-btXX_R4fgNx8d6QNa86GJETg4zAQ,23134
+pytcl/mathematical_functions/signal_processing/detection.py,sha256=Gphym92pFx3NSradLcFiBZwGSEAedBh5bOncrq0huGA,32252
+pytcl/mathematical_functions/signal_processing/filters.py,sha256=UhNnILWzpbJeiSait0xcnl48HEmNC5j47LWEogXMgr0,25233
+pytcl/mathematical_functions/signal_processing/matched_filter.py,sha256=63htJUvSVFnVOwwFBtHtWEMp5puEXD7HWnsKlZrLQ4E,24511
 pytcl/mathematical_functions/special_functions/__init__.py,sha256=AJBCKj32daQxdahUQckW0bWowzOoapxni2eZnVXERdg,3859
 pytcl/mathematical_functions/special_functions/bessel.py,sha256=kRRPafQMXmooBglEteccjb6Hct1LLq3Oze4JfLQ-AmY,15459
 pytcl/mathematical_functions/special_functions/debye.py,sha256=eH7Y5qq5j-AMKKx7y8uMS_l_pb6z9_3SG6Igvnc1Fdg,9626
 pytcl/mathematical_functions/special_functions/elliptic.py,sha256=mF3hVrErlK376pw-QZDoq_R6y8gnJAZAK5Kmuq8_0n4,8131
 pytcl/mathematical_functions/special_functions/error_functions.py,sha256=6i5HqQfYdcz0UNhLnHpoMCnWzzZypjckSHTC5ISrcHA,6990
 pytcl/mathematical_functions/special_functions/gamma_functions.py,sha256=riTiy1cqYFtJrzscw0vgTkCaPBCPDGN8Ge6qWAD1zBg,11086
-pytcl/mathematical_functions/special_functions/hypergeometric.py,sha256=mCBf5NPl0mOkwvIwAUp-sbXshin5HyGsdqEeGbYt3wQ,11428
+pytcl/mathematical_functions/special_functions/hypergeometric.py,sha256=_iyWm0yLVDTzNxgWogru5-LtVMUQ2FXJRZAcmj-o7eQ,12061
 pytcl/mathematical_functions/special_functions/lambert_w.py,sha256=flLSf_7IY5sRXzd2aGgyXfJTRCjekgtvguBV3MhB9GE,6943
 pytcl/mathematical_functions/special_functions/marcum_q.py,sha256=ASQ2vVfhmx4iEvtZTyiQ60-Hy8Qxl_4XgJzYufayJaQ,9910
 pytcl/mathematical_functions/statistics/__init__.py,sha256=dfypStgmnFmOrnWcm-3CEvLinONHraFgx9O66_37bqw,1278
 pytcl/mathematical_functions/statistics/distributions.py,sha256=icfFIIKCEFzkpFHuYGWL197nm8wvS7UPJlr9kd_uEgw,19373
-pytcl/mathematical_functions/statistics/estimators.py,sha256=TLnYXSwk5MzBakZrzDBupbOB3ONmJI7q1-oB2xuSVQM,10831
+pytcl/mathematical_functions/statistics/estimators.py,sha256=egaHcbeI1812MuDZEimrh6efas-zXSuNjWM-pcpnyfE,12036
 pytcl/mathematical_functions/transforms/__init__.py,sha256=SPXSKHjqR6B_8pvgtbtOnEiCpU-u0JF2s7hAlhb0BbI,2343
 pytcl/mathematical_functions/transforms/fourier.py,sha256=yD1CcH7sdPlrOmBgL7JoMiPNgN8ee7bTwvblgRRf7l4,20823
 pytcl/mathematical_functions/transforms/stft.py,sha256=olDzNH02Nta5GoeEdsdX1tTVKODr6OxLEYt_h3ZtMgA,18878
-pytcl/mathematical_functions/transforms/wavelets.py,sha256=lR71JX5vX_OXl1g9H89OGiimM_oqfU-WfGYJF3uD2z8,21887
+pytcl/mathematical_functions/transforms/wavelets.py,sha256=uHFh0wM10wSbP9Gs3P0WR3Vwz-Pue-g6Rr6H2OhJV68,22866
 pytcl/misc/__init__.py,sha256=SCHf_lQVfdl2gwUluHBiIloTF8HRH8EkgYfbNr7zOug,33
 pytcl/navigation/__init__.py,sha256=k1_x_FnnPrIzGeNu7zejPtPubIhweBgCfwqlZJEMw0I,6042
 pytcl/navigation/geodesy.py,sha256=NH4Txv_VtUdBk6LkQqnSnPfRnG4WnoGF7zGwB-mIbJA,23140
-pytcl/navigation/great_circle.py,sha256=K7CLS8k1P4uN9jpq4Nzc6jk_bSmo-ppb3vyUJbwYjVg,25503
+pytcl/navigation/great_circle.py,sha256=9OJKvFP6KwiqaMrgGA6DVOTOFKTeZwiqWlCejyZpwvQ,26741
 pytcl/navigation/ins.py,sha256=OIi8_RjrgEYl0MFpJEFMjIlpgX8DYGTEhdLEvqG-ABU,31151
 pytcl/navigation/ins_gnss.py,sha256=euKF5JGgwmVBsw3jBf7_wa2z1BpZeVbSNmBuwzhGS6c,30157
 pytcl/navigation/rhumb.py,sha256=lEr3LJqowT-WsdSA4E-V7BFmaqxoI7OpJa05pl_-uGg,20562
@@ -172,8 +172,8 @@ pytcl/trackers/mht.py,sha256=osEOXMaCeTt1eVn_E08dLRhEvBroVmf8b81zO5Zp1lU,20720
 pytcl/trackers/multi_target.py,sha256=RDITa0xnbgtVYAMj5XXp4lljo5lZ2zAAc02KZlOjxbQ,10526
 pytcl/trackers/single_target.py,sha256=Yy3FwaNTArMWcaod-0HVeiioNV4xLWxNDn_7ZPVqQYs,6562
 pytcl/transponders/__init__.py,sha256=5fL4u3lKCYgPLo5uFeuZbtRZkJPABntuKYGUvVgMMEI,41
-nrl_tracker-1.11.1.dist-info/LICENSE,sha256=rB5G4WppIIUzMOYr2N6uyYlNJ00hRJqE5tie6BMvYuE,1612
-nrl_tracker-1.11.1.dist-info/METADATA,sha256=Rk3gTB07fj8sHOEj6eEnVo-3Dfvv7I29KO4WDmdJmdo,14038
-nrl_tracker-1.11.1.dist-info/WHEEL,sha256=pL8R0wFFS65tNSRnaOVrsw9EOkOqxLrlUPenUYnJKNo,91
-nrl_tracker-1.11.1.dist-info/top_level.txt,sha256=17megxcrTPBWwPZTh6jTkwTKxX7No-ZqRpyvElnnO-s,6
-nrl_tracker-1.11.1.dist-info/RECORD,,
+nrl_tracker-1.12.0.dist-info/LICENSE,sha256=rB5G4WppIIUzMOYr2N6uyYlNJ00hRJqE5tie6BMvYuE,1612
+nrl_tracker-1.12.0.dist-info/METADATA,sha256=R5r43JY6yLPCD0lrxbyffCMBJm8g_KEHSojmTbeKR7k,14038
+nrl_tracker-1.12.0.dist-info/WHEEL,sha256=pL8R0wFFS65tNSRnaOVrsw9EOkOqxLrlUPenUYnJKNo,91
+nrl_tracker-1.12.0.dist-info/top_level.txt,sha256=17megxcrTPBWwPZTh6jTkwTKxX7No-ZqRpyvElnnO-s,6
+nrl_tracker-1.12.0.dist-info/RECORD,,

pytcl/__init__.py

@@ -6,7 +6,7 @@ systems, dynamic models, estimation algorithms, and mathematical functions.
 
 This is a Python port of the U.S. Naval Research Laboratory's Tracker Component
 Library originally written in MATLAB.
-**Current Version:** 1.11.1 (January 5, 2026)
+**Current Version:** 1.12.0 (January 5, 2026)
 **Status:** Production-ready, 2,894 tests passing, 76% line coverage
 Examples
 --------
@@ -21,7 +21,7 @@ References
        no. 5, pp. 18-27, May 2017.
 """
 
-__version__ = "1.11.1"
+__version__ = "1.12.0"
 __author__ = "Python Port Contributors"
 __original_author__ = "David F. Crouse, Naval Research Laboratory"
 

pytcl/assignment_algorithms/network_flow.py

@@ -179,13 +179,19 @@ def min_cost_flow_successive_shortest_paths(
     max_iterations: int = 1000,
 ) -> MinCostFlowResult:
     """
-    Solve min-cost flow using successive shortest paths.
+    Solve min-cost flow using successive shortest paths with cost scaling.
 
     Algorithm:
-    1. While there is excess supply:
-       - Find shortest path from a supply node to a demand node
-       - Push maximum feasible flow along path
-       - Update supplies and residual capacities
+    1. Initialize potentials using Bellman-Ford
+    2. While there is excess supply:
+       - Find shortest path using reduced costs (Dijkstra with potentials)
+       - Push unit flow along path
+       - Update node potentials
+       - Recompute shortest paths to maintain optimality
+
+    This is the standard min-cost flow algorithm that guarantees optimality
+    and convergence. It uses Dijkstra's algorithm with potentials, which
+    maintains the dual feasibility (reduced cost property).
 
     Parameters
     ----------
@@ -217,100 +223,163 @@ def min_cost_flow_successive_shortest_paths(
 
     Notes
     -----
-    This is a simplified implementation using Bellman-Ford for shortest
-    paths. Production code would use more efficient implementations.
+    This implementation uses successive shortest paths with potentials.
+    The algorithm is guaranteed to find the optimal solution for any
+    feasible min-cost flow problem.
+
+    For rectangular assignment problems (m < n or m > n), all m units
+    of flow must be satisfied. The algorithm ensures this by finding
+    augmenting paths until all supply is routed.
     """
     n_nodes = len(supplies)
     n_edges = len(edges)
 
-    # Build adjacency lists for residual graph
-    graph: list[list[tuple[int, int, float]]] = [[] for _ in range(n_nodes)]
+    # Initialize flow and residual capacity
     flow = np.zeros(n_edges)
     residual_capacity = np.array([e.capacity for e in edges])
 
+    # Initialize node potentials using Bellman-Ford from a dummy source
+    # This ensures all potentials are finite and maintains dual feasibility
+    potential = np.zeros(n_nodes)
+
+    # Build adjacency list representation
+    # Each entry: (to_node, edge_idx, is_reverse, cost)
+    graph: list[list[tuple[int, int, int, float]]] = [[] for _ in range(n_nodes)]
+
     for edge_idx, edge in enumerate(edges):
-        graph[edge.from_node].append((edge.to_node, edge_idx, edge.cost))
-        # Add reverse edge with negative cost
-        graph[edge.to_node].append((edge.from_node, edge_idx, -edge.cost))
+        # Forward edge
+        graph[edge.from_node].append((edge.to_node, edge_idx, 0, edge.cost))
+        # Reverse edge (for flow cancellation)
+        graph[edge.to_node].append((edge.from_node, edge_idx, 1, -edge.cost))
 
     current_supplies = supplies.copy()
     iteration = 0
 
+    # Main algorithm loop
     while iteration < max_iterations:
-        # Find a node with excess supply
-        excess_node = None
+        # Find excess and deficit nodes
+        excess_node = -1
+        deficit_node = -1
+
         for node in range(n_nodes):
             if current_supplies[node] > 1e-10:
                 excess_node = node
                 break
 
-        if excess_node is None:
-            break
+        if excess_node < 0:
+            break  # No more excess nodes
 
-        # Find a node with deficit
-        deficit_node = None
         for node in range(n_nodes):
             if current_supplies[node] < -1e-10:
                 deficit_node = node
                 break
 
-        if deficit_node is None:
-            break
+        if deficit_node < 0:
+            break  # No deficit nodes
 
-        # Find shortest path using Bellman-Ford relaxation
+        # Find shortest path using Dijkstra with potentials
+        # Reduced cost: c_reduced(u,v) = c(u,v) + π(u) - π(v)
         dist = np.full(n_nodes, np.inf)
         dist[excess_node] = 0.0
         parent = np.full(n_nodes, -1, dtype=int)
         parent_edge = np.full(n_nodes, -1, dtype=int)
+        parent_reverse = np.full(n_nodes, 0, dtype=int)
+        visited = np.zeros(n_nodes, dtype=bool)
+
+        # Dijkstra's algorithm
+        for _ in range(n_nodes):
+            # Find unvisited node with minimum distance
+            u = -1
+            min_dist = np.inf
+            for node in range(n_nodes):
+                if not visited[node] and dist[node] < min_dist:
+                    u = node
+                    min_dist = dist[node]
+
+            if u < 0 or dist[u] == np.inf:
+                break
+
+            visited[u] = True
 
-        for _ in range(n_nodes - 1):
-            for u in range(n_nodes):
-                if dist[u] == np.inf:
-                    continue
-                for v, edge_idx, cost in graph[u]:
-                    if residual_capacity[edge_idx] > 1e-10:
-                        new_dist = dist[u] + cost
-                        if new_dist < dist[v]:
-                            dist[v] = new_dist
-                            parent[v] = u
-                            parent_edge[v] = edge_idx
-
-        if dist[deficit_node] == np.inf:
+            # Relax edges from u
+            for v, eidx, is_rev, cost in graph[u]:
+                if residual_capacity[eidx] > 1e-10:
+                    # Compute reduced cost
+                    reduced_cost = cost + potential[u] - potential[v]
+                    new_dist = dist[u] + reduced_cost
+
+                    if new_dist < dist[v] - 1e-10:
+                        dist[v] = new_dist
+                        parent[v] = u
+                        parent_edge[v] = eidx
+                        parent_reverse[v] = is_rev
+
+        if dist[deficit_node] >= np.inf:
             # No path found
             break
 
-        # Extract path and find bottleneck capacity
+        # Update potentials to maintain dual feasibility
+        for node in range(n_nodes):
+            if dist[node] < np.inf:
+                potential[node] += dist[node]
+
+        # Extract path by backtracking
         path_edges = []
+        path_reverse_flags = []
         node = deficit_node
-        while parent[node] != -1:
+        path_length = 0
+        visited_set = set()
+
+        while parent[node] >= 0:
+            if path_length >= n_nodes:
+                break  # Safety check
+            if node in visited_set:
+                break  # Cycle detected
+
+            visited_set.add(node)
             path_edges.append(parent_edge[node])
+            path_reverse_flags.append(parent_reverse[node])
             node = parent[node]
+            path_length += 1
+
+        if not path_edges:
+            iteration += 1
+            continue
 
         path_edges.reverse()
+        path_reverse_flags.reverse()
 
-        # Find minimum capacity along path
+        # Find bottleneck capacity
         min_flow = min(residual_capacity[e] for e in path_edges)
         min_flow = min(
-            min_flow, current_supplies[excess_node], -current_supplies[deficit_node]
+            min_flow,
+            current_supplies[excess_node],
+            -current_supplies[deficit_node],
         )
 
         # Push flow along path
-        total_cost = 0.0
-        for edge_idx in path_edges:
-            flow[edge_idx] += min_flow
-            residual_capacity[edge_idx] -= min_flow
-            total_cost += min_flow * edges[edge_idx].cost
+        for edge_idx, is_reverse in zip(path_edges, path_reverse_flags):
+            if is_reverse == 0:
+                # Forward edge: increase flow
+                flow[edge_idx] += min_flow
+                residual_capacity[edge_idx] -= min_flow
+            else:
+                # Reverse edge: decrease flow (cancel)
+                flow[edge_idx] -= min_flow
+                residual_capacity[edge_idx] += min_flow
 
         current_supplies[excess_node] -= min_flow
         current_supplies[deficit_node] += min_flow
 
         iteration += 1
 
-    # Compute total cost
-    total_cost = float(np.sum(flow[i] * edges[i].cost for i in range(n_edges)))
+    # Compute total cost: include all flows (including negative which cancel)
+    total_cost = 0.0
+    for i, edge in enumerate(edges):
+        total_cost += flow[i] * edge.cost
 
     # Determine status
-    if np.allclose(current_supplies, 0):
+    if np.allclose(current_supplies, 0, atol=1e-6):
         status = FlowStatus.OPTIMAL
     elif iteration >= max_iterations:
         status = FlowStatus.TIMEOUT
@@ -409,6 +478,14 @@ def assignment_from_flow_solution(
     """
     Extract assignment from flow network solution.
 
+    A valid flow solution for assignment should have:
+    - Exactly 1 unit of flow from each worker to some task
+    - Exactly 1 unit of flow to each task from some worker
+    - No negative flows on worker->task edges (those are cancellations)
+
+    This function extracts the actual assignment by identifying which
+    worker->task edges carry the net positive flow.
+
     Parameters
     ----------
     flow : ndarray
@@ -427,24 +504,59 @@ def assignment_from_flow_solution(
     """
     m, n = cost_matrix_shape
     assignment = []
+    cost = 0.0
+
+    # Build source node (node 0) and sink node (node m+n+1) indices
+    source = 0
+    sink = m + n + 1
+
+    # For a valid assignment solution:
+    # - Count flow out of source to each worker
+    # - Count flow into sink from each task
+    worker_outflow = np.zeros(m)
+    task_inflow = np.zeros(n)
+
+    # Collect all worker->task edges and their flows
+    worker_task_edges = []
 
     for edge_idx, edge in enumerate(edges):
-        # Worker-to-task edges: from_node in [1, m], to_node in [m+1, m+n]
-        if 1 <= edge.from_node <= m and m + 1 <= edge.to_node <= m + n:
-            if flow[edge_idx] > 0.5:  # Flow > 0 (allowing for numerical tolerance)
-                worker_idx = edge.from_node - 1
-                task_idx = edge.to_node - m - 1
-                assignment.append([worker_idx, task_idx])
+        # Worker edges: from source (0) to worker nodes (1..m)
+        if edge.from_node == source and 1 <= edge.to_node <= m:
+            worker_id = edge.to_node - 1
+            worker_outflow[worker_id] += flow[edge_idx]
 
-    assignment = np.array(assignment, dtype=np.intp)
-    cost = 0.0
-    if len(assignment) > 0:
-        cost = float(
-            np.sum(
-                flow[edge_idx] * edges[edge_idx].cost for edge_idx in range(len(edges))
-            )
-        )
+        # Task edges: from task nodes (m+1..m+n) to sink
+        if m + 1 <= edge.from_node <= m + n and edge.to_node == sink:
+            task_id = edge.from_node - (m + 1)
+            task_inflow[task_id] += flow[edge_idx]
 
+        # Worker-to-task edges
+        if 1 <= edge.from_node <= m and m + 1 <= edge.to_node <= m + n:
+            worker_id = edge.from_node - 1
+            task_id = edge.to_node - (m + 1)
+            if flow[edge_idx] > 0.5:  # Positive flow means this edge is used
+                worker_task_edges.append(
+                    {
+                        "worker": worker_id,
+                        "task": task_id,
+                        "flow": flow[edge_idx],
+                        "cost": edge.cost,
+                        "edge_idx": edge_idx,
+                    }
+                )
+
+    # For assignment problems, each worker should have exactly 1 outgoing flow
+    # and each task should have exactly 1 incoming flow
+    # Extract the assignment from worker->task edges with positive flow
+    for edge_info in worker_task_edges:
+        assignment.append([edge_info["worker"], edge_info["task"]])
+        cost += edge_info["flow"] * edge_info["cost"]
+
+    assignment = (
+        np.array(assignment, dtype=np.intp)
+        if assignment
+        else np.empty((0, 2), dtype=np.intp)
+    )
     return assignment, cost
 
 

pytcl/astronomical/time_systems.py

@@ -269,6 +269,13 @@ def mjd_to_jd(mjd: float) -> float:
     float
         Julian Date.
 
+    Examples
+    --------
+    >>> mjd = 44239.0  # 1980-01-01
+    >>> jd = mjd_to_jd(mjd)
+    >>> jd
+    2444239.5
+
     Notes
     -----
     MJD = JD - 2400000.5
@@ -289,6 +296,13 @@ def jd_to_mjd(jd: float) -> float:
     -------
     float
         Modified Julian Date.
+
+    Examples
+    --------
+    >>> jd = 2444239.5  # 1980-01-01
+    >>> mjd = jd_to_mjd(jd)
+    >>> mjd
+    44239.0
     """
     return jd - MJD_OFFSET
 
@@ -328,6 +342,13 @@ def jd_to_unix(jd: float) -> float:
     -------
     float
         Unix timestamp.
+
+    Examples
+    --------
+    >>> jd = 2440587.5  # 1970-01-01 00:00:00 UTC
+    >>> unix_to_jd = jd_to_unix(jd)
+    >>> unix_to_jd
+    0.0
     """
     return (jd - JD_UNIX_EPOCH) * 86400.0
 

pytcl/containers/cluster_set.py

@@ -94,6 +94,23 @@ def compute_cluster_centroid(
     -------
     centroid : ndarray
         Centroid position [x, y].
+
+    Examples
+    --------
+    >>> from pytcl.trackers.multi_target import Track
+    >>> import numpy as np
+    >>> # Create sample tracks with [x, vx, y, vy] state vectors
+    >>> track1 = Track(state=np.array([0.0, 1.0, 0.0, 1.0]))
+    >>> track2 = Track(state=np.array([2.0, 1.0, 2.0, 1.0]))
+    >>> track3 = Track(state=np.array([4.0, 1.0, 4.0, 1.0]))
+    >>> tracks = [track1, track2, track3]
+    >>> centroid = compute_cluster_centroid(tracks)
+    >>> centroid
+    array([2., 2.])
+
+    See Also
+    --------
+    compute_cluster_covariance : Compute covariance of track positions.
     """
     track_list = list(tracks)
     if len(track_list) == 0:
@@ -122,6 +139,25 @@ def compute_cluster_covariance(
     -------
     covariance : ndarray
         Position covariance matrix (2x2).
+
+    Examples
+    --------
+    >>> from pytcl.trackers.multi_target import Track
+    >>> import numpy as np
+    >>> # Create collinear tracks (high variance along x-axis)
+    >>> track1 = Track(state=np.array([0.0, 1.0, 0.0, 0.0]))
+    >>> track2 = Track(state=np.array([1.0, 1.0, 0.0, 0.0]))
+    >>> track3 = Track(state=np.array([2.0, 1.0, 0.0, 0.0]))
+    >>> tracks = [track1, track2, track3]
+    >>> cov = compute_cluster_covariance(tracks)
+    >>> cov.shape
+    (2, 2)
+    >>> cov[0, 0] > cov[1, 1]  # More spread in x than y
+    True
+
+    See Also
+    --------
+    compute_cluster_centroid : Compute centroid of track positions.
     """
     track_list = list(tracks)
     if len(track_list) < 2: