nrl-tracker 1.5.0__tar.gz → 1.7.0__tar.gz

{nrl_tracker-1.5.0/nrl_tracker.egg-info → nrl_tracker-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nrl-tracker
-Version: 1.5.0
+Version: 1.7.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
@@ -63,15 +63,16 @@ Requires-Dist: nrl-tracker[astronomy,dev,geodesy,optimization,signal,visualizati
 
 # Tracker Component Library (Python)
 
-[![PyPI version](https://img.shields.io/badge/pypi-v1.5.0-blue.svg)](https://pypi.org/project/nrl-tracker/)
+[![PyPI version](https://img.shields.io/badge/pypi-v1.7.0-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-1850%20passing-success.svg)](https://github.com/nedonatelli/TCL)
+[![Tests](https://img.shields.io/badge/tests-1988%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)
 
 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.
 
-**840+ functions** | **148 modules** | **1,850 tests** | **15+ algorithm categories**
+**1,070+ functions** | **153 modules** | **1,988 tests** | **100% MATLAB parity**
 
 ## Overview
 
@@ -79,12 +80,15 @@ The Tracker Component Library provides building blocks for developing target tra
 
 - **Coordinate Systems**: Conversions between Cartesian, spherical, geodetic, and other coordinate systems
 - **Dynamic Models**: State transition matrices for constant velocity, coordinated turn, and other motion models
-- **Estimation Algorithms**: Kalman filters (EKF, UKF, etc.), particle filters, and batch estimation
-- **Assignment Algorithms**: Hungarian algorithm, auction algorithms, and multi-dimensional assignment
+- **Estimation Algorithms**: Kalman filters (EKF, UKF, CKF, H-infinity), particle filters, smoothers, and batch estimation
+- **Assignment Algorithms**: Hungarian algorithm, auction algorithms, 3D/ND assignment, k-best assignments
+- **Data Association**: Global Nearest Neighbor, JPDA, MHT for multi-target tracking
 - **Mathematical Functions**: Special functions, statistics, numerical integration, and more
-- **Astronomical Code**: Ephemeris calculations, time systems, celestial mechanics
-- **Navigation**: Geodetic calculations, INS algorithms, GNSS utilities
-- **Geophysical Models**: Gravity, magnetism, atmosphere, and terrain models
+- **Astronomical Code**: SGP4/SDP4 propagation, TLE parsing, special orbits (parabolic/hyperbolic), ephemerides, relativistic corrections
+- **Reference Frames**: GCRF, ITRF, TEME, TOD, MOD with full transformation chains
+- **Navigation**: Geodetic calculations, INS mechanization, GNSS utilities, INS/GNSS integration
+- **Geophysical Models**: Gravity (WGS84, EGM96/2008), magnetism (WMM, IGRF), atmosphere, tides, terrain
+- **Signal Processing**: Digital filters, matched filtering, CFAR detection, transforms (FFT, STFT, wavelets)
 
 ## Installation
 

{nrl_tracker-1.5.0 → nrl_tracker-1.7.0}/README.md

@@ -1,14 +1,15 @@
 # Tracker Component Library (Python)
 
-[![PyPI version](https://img.shields.io/badge/pypi-v1.5.0-blue.svg)](https://pypi.org/project/nrl-tracker/)
+[![PyPI version](https://img.shields.io/badge/pypi-v1.7.0-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-1850%20passing-success.svg)](https://github.com/nedonatelli/TCL)
+[![Tests](https://img.shields.io/badge/tests-1988%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)
 
 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.
 
-**840+ functions** | **148 modules** | **1,850 tests** | **15+ algorithm categories**
+**1,070+ functions** | **153 modules** | **1,988 tests** | **100% MATLAB parity**
 
 ## Overview
 
@@ -16,12 +17,15 @@ The Tracker Component Library provides building blocks for developing target tra
 
 - **Coordinate Systems**: Conversions between Cartesian, spherical, geodetic, and other coordinate systems
 - **Dynamic Models**: State transition matrices for constant velocity, coordinated turn, and other motion models
-- **Estimation Algorithms**: Kalman filters (EKF, UKF, etc.), particle filters, and batch estimation
-- **Assignment Algorithms**: Hungarian algorithm, auction algorithms, and multi-dimensional assignment
+- **Estimation Algorithms**: Kalman filters (EKF, UKF, CKF, H-infinity), particle filters, smoothers, and batch estimation
+- **Assignment Algorithms**: Hungarian algorithm, auction algorithms, 3D/ND assignment, k-best assignments
+- **Data Association**: Global Nearest Neighbor, JPDA, MHT for multi-target tracking
 - **Mathematical Functions**: Special functions, statistics, numerical integration, and more
-- **Astronomical Code**: Ephemeris calculations, time systems, celestial mechanics
-- **Navigation**: Geodetic calculations, INS algorithms, GNSS utilities
-- **Geophysical Models**: Gravity, magnetism, atmosphere, and terrain models
+- **Astronomical Code**: SGP4/SDP4 propagation, TLE parsing, special orbits (parabolic/hyperbolic), ephemerides, relativistic corrections
+- **Reference Frames**: GCRF, ITRF, TEME, TOD, MOD with full transformation chains
+- **Navigation**: Geodetic calculations, INS mechanization, GNSS utilities, INS/GNSS integration
+- **Geophysical Models**: Gravity (WGS84, EGM96/2008), magnetism (WMM, IGRF), atmosphere, tides, terrain
+- **Signal Processing**: Digital filters, matched filtering, CFAR detection, transforms (FFT, STFT, wavelets)
 
 ## Installation
 

{nrl_tracker-1.5.0 → nrl_tracker-1.7.0/nrl_tracker.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nrl-tracker
-Version: 1.5.0
+Version: 1.7.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
@@ -63,15 +63,16 @@ Requires-Dist: nrl-tracker[astronomy,dev,geodesy,optimization,signal,visualizati
 
 # Tracker Component Library (Python)
 
-[![PyPI version](https://img.shields.io/badge/pypi-v1.5.0-blue.svg)](https://pypi.org/project/nrl-tracker/)
+[![PyPI version](https://img.shields.io/badge/pypi-v1.7.0-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-1850%20passing-success.svg)](https://github.com/nedonatelli/TCL)
+[![Tests](https://img.shields.io/badge/tests-1988%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)
 
 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.
 
-**840+ functions** | **148 modules** | **1,850 tests** | **15+ algorithm categories**
+**1,070+ functions** | **153 modules** | **1,988 tests** | **100% MATLAB parity**
 
 ## Overview
 
@@ -79,12 +80,15 @@ The Tracker Component Library provides building blocks for developing target tra
 
 - **Coordinate Systems**: Conversions between Cartesian, spherical, geodetic, and other coordinate systems
 - **Dynamic Models**: State transition matrices for constant velocity, coordinated turn, and other motion models
-- **Estimation Algorithms**: Kalman filters (EKF, UKF, etc.), particle filters, and batch estimation
-- **Assignment Algorithms**: Hungarian algorithm, auction algorithms, and multi-dimensional assignment
+- **Estimation Algorithms**: Kalman filters (EKF, UKF, CKF, H-infinity), particle filters, smoothers, and batch estimation
+- **Assignment Algorithms**: Hungarian algorithm, auction algorithms, 3D/ND assignment, k-best assignments
+- **Data Association**: Global Nearest Neighbor, JPDA, MHT for multi-target tracking
 - **Mathematical Functions**: Special functions, statistics, numerical integration, and more
-- **Astronomical Code**: Ephemeris calculations, time systems, celestial mechanics
-- **Navigation**: Geodetic calculations, INS algorithms, GNSS utilities
-- **Geophysical Models**: Gravity, magnetism, atmosphere, and terrain models
+- **Astronomical Code**: SGP4/SDP4 propagation, TLE parsing, special orbits (parabolic/hyperbolic), ephemerides, relativistic corrections
+- **Reference Frames**: GCRF, ITRF, TEME, TOD, MOD with full transformation chains
+- **Navigation**: Geodetic calculations, INS mechanization, GNSS utilities, INS/GNSS integration
+- **Geophysical Models**: Gravity (WGS84, EGM96/2008), magnetism (WMM, IGRF), atmosphere, tides, terrain
+- **Signal Processing**: Digital filters, matched filtering, CFAR detection, transforms (FFT, STFT, wavelets)
 
 ## Installation
 

{nrl_tracker-1.5.0 → nrl_tracker-1.7.0}/nrl_tracker.egg-info/SOURCES.txt

@@ -14,6 +14,8 @@ pytcl/assignment_algorithms/__init__.py
 pytcl/assignment_algorithms/data_association.py
 pytcl/assignment_algorithms/gating.py
 pytcl/assignment_algorithms/jpda.py
+pytcl/assignment_algorithms/nd_assignment.py
+pytcl/assignment_algorithms/network_flow.py
 pytcl/assignment_algorithms/three_dimensional/__init__.py
 pytcl/assignment_algorithms/three_dimensional/assignment.py
 pytcl/assignment_algorithms/two_dimensional/__init__.py
@@ -25,10 +27,14 @@ pytcl/astronomical/lambert.py
 pytcl/astronomical/orbital_mechanics.py
 pytcl/astronomical/reference_frames.py
 pytcl/astronomical/relativity.py
+pytcl/astronomical/sgp4.py
+pytcl/astronomical/special_orbits.py
 pytcl/astronomical/time_systems.py
+pytcl/astronomical/tle.py
 pytcl/atmosphere/__init__.py
 pytcl/atmosphere/ionosphere.py
 pytcl/atmosphere/models.py
+pytcl/atmosphere/nrlmsise00.py
 pytcl/clustering/__init__.py
 pytcl/clustering/dbscan.py
 pytcl/clustering/gaussian_mixture.py
@@ -58,12 +64,16 @@ pytcl/core/array_utils.py
 pytcl/core/constants.py
 pytcl/core/validation.py
 pytcl/dynamic_estimation/__init__.py
+pytcl/dynamic_estimation/gaussian_sum_filter.py
 pytcl/dynamic_estimation/imm.py
 pytcl/dynamic_estimation/information_filter.py
+pytcl/dynamic_estimation/rbpf.py
 pytcl/dynamic_estimation/smoothers.py
 pytcl/dynamic_estimation/batch_estimation/__init__.py
 pytcl/dynamic_estimation/kalman/__init__.py
+pytcl/dynamic_estimation/kalman/constrained.py
 pytcl/dynamic_estimation/kalman/extended.py
+pytcl/dynamic_estimation/kalman/h_infinity.py
 pytcl/dynamic_estimation/kalman/linear.py
 pytcl/dynamic_estimation/kalman/square_root.py
 pytcl/dynamic_estimation/kalman/sr_ukf.py
@@ -164,6 +174,7 @@ tests/test_additional_trees.py
 tests/test_assignment_algorithms.py
 tests/test_astronomical.py
 tests/test_clustering.py
+tests/test_constrained_ekf.py
 tests/test_coordinate_systems.py
 tests/test_coverage_boost.py
 tests/test_coverage_boost_2.py
@@ -172,29 +183,38 @@ tests/test_egm.py
 tests/test_emm.py
 tests/test_ephemerides.py
 tests/test_gaussian_mixtures.py
+tests/test_gaussian_sum_filter.py
 tests/test_geophysical.py
 tests/test_great_circle.py
+tests/test_h_infinity.py
 tests/test_ins.py
 tests/test_ins_gnss.py
 tests/test_kalman_filters.py
 tests/test_mathematical_functions.py
 tests/test_maximum_likelihood.py
 tests/test_mht.py
+tests/test_nd_assignment.py
+tests/test_network_flow.py
+tests/test_nrlmsise00.py
 tests/test_performance_evaluation.py
 tests/test_phase6_specialized.py
 tests/test_plotting.py
 tests/test_projections.py
+tests/test_rbpf.py
 tests/test_relativity.py
 tests/test_rhumb.py
+tests/test_sgp4.py
 tests/test_signal_processing.py
 tests/test_smoothers.py
 tests/test_spatial_containers_parametrized.py
 tests/test_spatial_structures.py
 tests/test_special_functions_phase12.py
+tests/test_special_orbits.py
 tests/test_static_estimation.py
 tests/test_terrain.py
 tests/test_terrain_loaders.py
 tests/test_tides.py
+tests/test_tod_mod.py
 tests/test_trackers.py
 tests/test_tracking_containers.py
 tests/test_transforms.py

{nrl_tracker-1.5.0 → nrl_tracker-1.7.0}/pyproject.toml

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

{nrl_tracker-1.5.0 → nrl_tracker-1.7.0}/pytcl/__init__.py

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

{nrl_tracker-1.5.0 → nrl_tracker-1.7.0}/pytcl/assignment_algorithms/__init__.py

@@ -51,6 +51,21 @@ from pytcl.assignment_algorithms.two_dimensional import (
     murty,
     ranked_assignments,
 )
+from pytcl.assignment_algorithms.nd_assignment import (
+    AssignmentNDResult,
+    auction_assignment_nd,
+    detect_dimension_conflicts,
+    greedy_assignment_nd,
+    relaxation_assignment_nd,
+    validate_cost_tensor,
+)
+from pytcl.assignment_algorithms.network_flow import (
+    FlowStatus,
+    MinCostFlowResult,
+    assignment_to_flow_network,
+    min_cost_assignment_via_flow,
+    min_cost_flow_successive_shortest_paths,
+)
 
 __all__ = [
     # 2D Assignment
@@ -91,4 +106,17 @@ __all__ = [
     "jpda_update",
     "jpda_probabilities",
     "compute_likelihood_matrix",
+    # N-Dimensional Assignment (4D+)
+    "AssignmentNDResult",
+    "validate_cost_tensor",
+    "greedy_assignment_nd",
+    "relaxation_assignment_nd",
+    "auction_assignment_nd",
+    "detect_dimension_conflicts",
+    # Network Flow-Based Assignment
+    "FlowStatus",
+    "MinCostFlowResult",
+    "assignment_to_flow_network",
+    "min_cost_flow_successive_shortest_paths",
+    "min_cost_assignment_via_flow",
 ]

nrl_tracker-1.7.0/pytcl/assignment_algorithms/nd_assignment.py

@@ -0,0 +1,378 @@
+"""
+N-dimensional assignment algorithms (4D and higher).
+
+This module extends the 3D assignment solver to arbitrary dimensions,
+enabling more complex assignment scenarios such as:
+- 4D: Measurements × Tracks × Hypotheses × Sensors
+- 5D+: Additional dimensions for time frames, maneuver classes, etc.
+
+The module provides a unified interface for solving high-dimensional
+assignment problems using generalized relaxation methods.
+
+References
+----------
+.. [1] Poore, A. B., "Multidimensional Assignment Problem and Data
+       Association," IEEE Transactions on Aerospace and Electronic Systems,
+       2013.
+.. [2] Cramer, R. D., et al., "The Emerging Role of Chemical Similarity in
+       Drug Discovery," Perspectives in Drug Discovery and Design, 2003.
+"""
+
+from typing import NamedTuple, Optional, Tuple
+
+import numpy as np
+from numpy.typing import NDArray
+
+
+class AssignmentNDResult(NamedTuple):
+    """Result of an N-dimensional assignment problem.
+
+    Attributes
+    ----------
+    assignments : ndarray
+        Array of shape (n_assignments, n_dimensions) containing assigned
+        index tuples. Each row is an n-tuple of indices.
+    cost : float
+        Total assignment cost.
+    converged : bool
+        Whether the algorithm converged (for iterative methods).
+    n_iterations : int
+        Number of iterations used (for iterative methods).
+    gap : float
+        Optimality gap (upper_bound - lower_bound) for relaxation methods.
+    """
+
+    assignments: NDArray[np.intp]
+    cost: float
+    converged: bool
+    n_iterations: int
+    gap: float
+
+
+def validate_cost_tensor(cost_tensor: NDArray[np.float64]) -> Tuple[int, ...]:
+    """
+    Validate cost tensor and return dimensions.
+
+    Parameters
+    ----------
+    cost_tensor : ndarray
+        Cost tensor of arbitrary dimension.
+
+    Returns
+    -------
+    dims : tuple
+        Dimensions of the cost tensor.
+
+    Raises
+    ------
+    ValueError
+        If tensor has fewer than 2 dimensions.
+    """
+    if cost_tensor.ndim < 2:
+        raise ValueError(
+            f"Cost tensor must have at least 2 dimensions, got {cost_tensor.ndim}"
+        )
+
+    return cost_tensor.shape
+
+
+def greedy_assignment_nd(
+    cost_tensor: NDArray[np.float64],
+    max_assignments: Optional[int] = None,
+) -> AssignmentNDResult:
+    """
+    Greedy solver for N-dimensional assignment.
+
+    Selects minimum-cost tuples in order until no more valid assignments
+    exist (no dimension index is repeated).
+
+    Parameters
+    ----------
+    cost_tensor : ndarray
+        Cost tensor of shape (n1, n2, ..., nk).
+    max_assignments : int, optional
+        Maximum number of assignments to find (default: min(dimensions)).
+
+    Returns
+    -------
+    AssignmentNDResult
+        Assignments, total cost, and algorithm info.
+
+    Notes
+    -----
+    Greedy assignment is fast O(n log n) but not optimal. Used as
+    heuristic or starting solution for optimization methods.
+    """
+    dims = cost_tensor.shape
+    n_dims = len(dims)
+
+    if max_assignments is None:
+        max_assignments = min(dims)
+
+    # Flatten tensor with index mapping
+    flat_costs = cost_tensor.ravel()
+    sorted_indices = np.argsort(flat_costs)
+
+    assignments: list[tuple[int, ...]] = []
+    used_indices: list[set[int]] = [set() for _ in range(n_dims)]
+
+    for flat_idx in sorted_indices:
+        if len(assignments) >= max_assignments:
+            break
+
+        # Convert flat index to multi-dimensional index
+        multi_idx = np.unravel_index(flat_idx, dims)
+
+        # Check if any dimension index is already used
+        conflict = False
+        for d, idx in enumerate(multi_idx):
+            if idx in used_indices[d]:
+                conflict = True
+                break
+
+        if not conflict:
+            assignments.append(multi_idx)
+            for d, idx in enumerate(multi_idx):
+                used_indices[d].add(idx)
+
+    assignments_array = np.array(assignments, dtype=np.intp)
+    if assignments_array.size > 0:
+        total_cost = float(np.sum(cost_tensor[tuple(assignments_array.T)]))
+    else:
+        total_cost = 0.0
+
+    return AssignmentNDResult(
+        assignments=assignments_array,
+        cost=total_cost,
+        converged=True,
+        n_iterations=1,
+        gap=0.0,  # Greedy doesn't compute lower bound
+    )
+
+
+def relaxation_assignment_nd(
+    cost_tensor: NDArray[np.float64],
+    max_iterations: int = 100,
+    tolerance: float = 1e-6,
+    verbose: bool = False,
+) -> AssignmentNDResult:
+    """
+    Lagrangian relaxation solver for N-dimensional assignment.
+
+    Uses iterative subgradient optimization on Lagrange multipliers
+    to tighten the lower bound and find good solutions.
+
+    Parameters
+    ----------
+    cost_tensor : ndarray
+        Cost tensor of shape (n1, n2, ..., nk).
+    max_iterations : int, optional
+        Maximum iterations (default 100).
+    tolerance : float, optional
+        Convergence tolerance for gap (default 1e-6).
+    verbose : bool, optional
+        Print iteration info (default False).
+
+    Returns
+    -------
+    AssignmentNDResult
+        Assignments, total cost, convergence info, and optimality gap.
+
+    Notes
+    -----
+    The relaxation approach:
+    1. Maintain Lagrange multipliers for each dimension
+    2. Solve relaxed problem (select best entries per tuple)
+    3. Update multipliers based on constraint violations
+    4. Iterate until convergence or gap tolerance met
+
+    This guarantees a lower bound on optimal cost and often finds
+    near-optimal or optimal solutions.
+    """
+    dims = cost_tensor.shape
+    n_dims = len(dims)
+
+    # Initialize Lagrange multipliers (one per dimension per index)
+    lambdas = [np.zeros(dim) for dim in dims]
+
+    best_cost = np.inf
+    best_assignments = None
+    lower_bound = -np.inf
+
+    for iteration in range(max_iterations):
+        # Compute relaxed costs: original - Lagrange penalty
+        relaxed_cost = cost_tensor.copy()
+        for d in range(n_dims):
+            # Reshape lambda[d] to broadcast correctly
+            shape = [1] * n_dims
+            shape[d] = dims[d]
+            relaxed_cost = relaxed_cost - lambdas[d].reshape(shape)
+
+        # Solve relaxed problem: greedy on relaxed costs
+        result_relaxed = greedy_assignment_nd(relaxed_cost)
+
+        # Compute lower bound from relaxed solution
+        lower_bound = (
+            result_relaxed.cost
+            + sum(np.sum(lambdas[d]) for d in range(n_dims))
+        )
+
+        # Extract solution from relaxed problem
+        if len(result_relaxed.assignments) > 0:
+            actual_cost = float(np.sum(cost_tensor[tuple(result_relaxed.assignments.T)]))
+
+            if actual_cost < best_cost:
+                best_cost = actual_cost
+                best_assignments = result_relaxed.assignments
+
+        # Compute constraint violations and update multipliers
+        violations = [np.zeros(dim) for dim in dims]
+
+        for assignment in result_relaxed.assignments:
+            for d, idx in enumerate(assignment):
+                violations[d][idx] += 1
+
+        # Subgradient descent on multipliers
+        step_size = 1.0 / (iteration + 1)
+        for d in range(n_dims):
+            lambdas[d] -= step_size * (violations[d] - 1.0)
+
+        # Compute gap
+        gap = best_cost - lower_bound if best_cost != np.inf else np.inf
+
+        if verbose:
+            print(
+                f"Iter {iteration+1}: LB={lower_bound:.4f}, UB={best_cost:.4f}, "
+                f"Gap={gap:.6f}"
+            )
+
+        if gap < tolerance:
+            if verbose:
+                print(f"Converged at iteration {iteration+1}")
+            break
+
+    if best_assignments is None:
+        best_assignments = np.empty((0, n_dims), dtype=np.intp)
+        best_cost = 0.0
+
+    gap = best_cost - lower_bound if best_cost != np.inf else np.inf
+
+    return AssignmentNDResult(
+        assignments=best_assignments,
+        cost=best_cost,
+        converged=gap < tolerance,
+        n_iterations=iteration + 1,
+        gap=gap,
+    )
+
+
+def auction_assignment_nd(
+    cost_tensor: NDArray[np.float64],
+    max_iterations: int = 100,
+    epsilon: float = 0.01,
+    verbose: bool = False,
+) -> AssignmentNDResult:
+    """
+    Auction algorithm for N-dimensional assignment.
+
+    Inspired by the classical auction algorithm for 2D assignment,
+    adapted to higher dimensions. Objects bid for assignments based
+    on relative costs.
+
+    Parameters
+    ----------
+    cost_tensor : ndarray
+        Cost tensor of shape (n1, n2, ..., nk).
+    max_iterations : int, optional
+        Maximum iterations (default 100).
+    epsilon : float, optional
+        Bid increment (default 0.01). Larger epsilon → fewer iterations,
+        worse solution; smaller epsilon → more iterations, better solution.
+    verbose : bool, optional
+        Print iteration info (default False).
+
+    Returns
+    -------
+    AssignmentNDResult
+        Assignments, total cost, convergence info, gap estimate.
+
+    Notes
+    -----
+    The algorithm maintains a "price" for each index and allows bidding
+    (price adjustment) to maximize value. Converges to epsilon-optimal
+    solution in finite iterations.
+    """
+    dims = cost_tensor.shape
+    n_dims = len(dims)
+
+    # Initialize prices (one per dimension per index)
+    prices = [np.zeros(dim) for dim in dims]
+
+    for iteration in range(max_iterations):
+        # Compute profit: cost - price penalty
+        profit = cost_tensor.copy()
+        for d in range(n_dims):
+            shape = [1] * n_dims
+            shape[d] = dims[d]
+            profit = profit - prices[d].reshape(shape)
+
+        # Find best assignment at current prices (greedy)
+        result = greedy_assignment_nd(profit)
+
+        if len(result.assignments) == 0:
+            break
+
+        # Update prices: increase price for "in-demand" indices
+        demands = [np.zeros(dim) for dim in dims]
+        for assignment in result.assignments:
+            for d, idx in enumerate(assignment):
+                demands[d][idx] += 1
+
+        for d in range(n_dims):
+            prices[d] += epsilon * (demands[d] - 1.0)
+
+        if verbose and (iteration + 1) % 10 == 0:
+            actual_cost = float(np.sum(cost_tensor[tuple(result.assignments.T)]))
+            print(f"Iter {iteration+1}: Cost={actual_cost:.4f}")
+
+    # Final solution
+    result = greedy_assignment_nd(cost_tensor)
+
+    return AssignmentNDResult(
+        assignments=result.assignments,
+        cost=result.cost,
+        converged=True,
+        n_iterations=iteration + 1,
+        gap=0.0,  # Auction algorithm doesn't track gap formally
+    )
+
+
+def detect_dimension_conflicts(
+    assignments: NDArray[np.intp],
+    dims: Tuple[int, ...],
+) -> bool:
+    """
+    Check if assignments violate dimension uniqueness.
+
+    For valid assignment, each index should appear at most once per dimension.
+
+    Parameters
+    ----------
+    assignments : ndarray
+        Array of shape (n_assignments, n_dimensions) with assignments.
+    dims : tuple
+        Dimensions of the cost tensor.
+
+    Returns
+    -------
+    has_conflicts : bool
+        True if any index appears more than once in any dimension.
+    """
+    n_dims = len(dims)
+
+    for d in range(n_dims):
+        indices_in_dim = assignments[:, d]
+        if len(indices_in_dim) != len(np.unique(indices_in_dim)):
+            return True
+
+    return False