nrl-tracker 1.10.0__tar.gz → 1.11.0__tar.gz

{nrl_tracker-1.10.0 → nrl_tracker-1.11.0}/CONTRIBUTING.md

@@ -222,35 +222,29 @@ When porting a function from the original MATLAB library:
 
 ## Current Development Status
 
-**Version:** v1.10.0
+**Version:** v1.11.0
 **MATLAB Parity:** 100% ✅
-**Test Suite:** 2,133 tests passing
+**Test Suite:** 2,894 tests passing
 **Code Coverage:** 76% (target 80%+ in v2.0.0)
 **Quality:** 100% compliance (black, isort, flake8, mypy --strict)
 **GPU Acceleration:** CuPy (NVIDIA) + MLX (Apple Silicon)
+**Performance Optimization:** Numba JIT, lru_cache, sparse matrix support
 
-## v2.0.0 Roadmap - 8 Phases Over 18 Months
+## v2.0.0 Roadmap Progress
 
-### Phase 1: Network Flow Performance (NEXT)
-**Focus:** Replace Bellman-Ford O(VE²) with network simplex O(VE log V)
-- **Impact:** 50-100x faster network flow computations
-- **Location:** `pytcl/assignment/network_flow.py`
-- **Tests:** Will re-enable 13 currently skipped tests
-- **Estimated:** 2-3 weeks
+### Completed Phases
+- **Phase 1** ✅: Network flow performance (50-100x faster)
+- **Phase 2** ✅: API standardization (exceptions, spatial indexes, optional deps)
+- **Phase 5** ✅: GPU acceleration (CuPy + MLX, 5-15x speedup)
+- **Phase 6** ✅: Test expansion (+761 tests, 2,894 total)
+- **Phase 7** ✅: Performance optimization (Numba JIT, lru_cache, sparse matrices)
 
-### Phases 2-5: Algorithm Optimization
-- Phase 2: Kalman filter performance
-- Phase 3: Tracking algorithm improvements
-- Phase 4: Signal processing optimization
-- Phase 5: Advanced estimation methods
+### In Progress
+- **Phase 3**: Documentation expansion
+- **Phase 4**: Jupyter notebooks
 
-### Phase 6: Test Expansion
-- **Goal:** +50 new tests, target 80%+ coverage
-- **Focus:** Edge cases, numerical stability, batch operations
-
-### Phases 7-8: Documentation & Final Polish
-- Phase 7: Documentation updates and examples
-- Phase 8: Performance tuning and optimization
+### Remaining
+- **Phase 8**: Release preparation (alpha → beta → RC → v2.0.0)
 
 ## Priority Areas for Contributors
 
@@ -302,13 +296,14 @@ pytest --collect-only -q | tail -1
 pytest --cov=pytcl --cov-report=term
 ```
 
-Current metrics (v1.10.0):
+Current metrics (v1.11.0):
 - **Functions:** 1,070+
 - **Modules:** 150+
-- **Tests:** 2,133 (all passing)
+- **Tests:** 2,894 (all passing)
 - **Coverage:** 76%
 - **MATLAB Parity:** 100%
 - **GPU Backends:** 2 (CuPy + MLX)
+- **Performance:** Numba JIT + lru_cache optimizations
 
 ### 3. Sync Examples
 

{nrl_tracker-1.10.0/nrl_tracker.egg-info → nrl_tracker-1.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nrl-tracker
-Version: 1.10.0
+Version: 1.11.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: nrl-tracker[astronomy,dev,geodesy,optimization,signal,visualizati
 
 # Tracker Component Library (Python)
 
-[![PyPI version](https://img.shields.io/badge/pypi-v1.10.0-blue.svg)](https://pypi.org/project/nrl-tracker/)
+[![PyPI version](https://img.shields.io/badge/pypi-v1.11.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-2133%20passing-success.svg)](https://github.com/nedonatelli/TCL)
+[![Tests](https://img.shields.io/badge/tests-2894%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,133 tests** | **100% MATLAB parity**
+**1,070+ functions** | **153 modules** | **2,894 tests** | **100% MATLAB parity**
 
 ## Overview
 

{nrl_tracker-1.10.0 → nrl_tracker-1.11.0}/README.md

@@ -1,16 +1,16 @@
 # Tracker Component Library (Python)
 
-[![PyPI version](https://img.shields.io/badge/pypi-v1.10.0-blue.svg)](https://pypi.org/project/nrl-tracker/)
+[![PyPI version](https://img.shields.io/badge/pypi-v1.11.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-2133%20passing-success.svg)](https://github.com/nedonatelli/TCL)
+[![Tests](https://img.shields.io/badge/tests-2894%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,133 tests** | **100% MATLAB parity**
+**1,070+ functions** | **153 modules** | **2,894 tests** | **100% MATLAB parity**
 
 ## Overview
 

{nrl_tracker-1.10.0 → nrl_tracker-1.11.0/nrl_tracker.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nrl-tracker
-Version: 1.10.0
+Version: 1.11.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: nrl-tracker[astronomy,dev,geodesy,optimization,signal,visualizati
 
 # Tracker Component Library (Python)
 
-[![PyPI version](https://img.shields.io/badge/pypi-v1.10.0-blue.svg)](https://pypi.org/project/nrl-tracker/)
+[![PyPI version](https://img.shields.io/badge/pypi-v1.11.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-2133%20passing-success.svg)](https://github.com/nedonatelli/TCL)
+[![Tests](https://img.shields.io/badge/tests-2894%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,133 tests** | **100% MATLAB parity**
+**1,070+ functions** | **153 modules** | **2,894 tests** | **100% MATLAB parity**
 
 ## Overview
 

{nrl_tracker-1.10.0 → nrl_tracker-1.11.0}/nrl_tracker.egg-info/SOURCES.txt

@@ -187,27 +187,38 @@ tests/conftest.py
 tests/test_additional_trees.py
 tests/test_assignment_algorithms.py
 tests/test_astronomical.py
+tests/test_cfar_detection.py
 tests/test_clustering.py
+tests/test_combinatorics.py
 tests/test_constrained_ekf.py
 tests/test_coordinate_systems.py
 tests/test_coverage_boost.py
 tests/test_coverage_boost_2.py
+tests/test_debye.py
 tests/test_dynamic_models.py
 tests/test_egm.py
+tests/test_elliptic.py
 tests/test_emm.py
 tests/test_ephemerides.py
+tests/test_error_functions.py
 tests/test_exceptions.py
+tests/test_gamma_functions.py
 tests/test_gaussian_mixtures.py
 tests/test_gaussian_sum_filter.py
+tests/test_geometry.py
 tests/test_geophysical.py
 tests/test_gpu.py
 tests/test_gpu_utils.py
 tests/test_great_circle.py
 tests/test_h_infinity.py
+tests/test_hypergeometric.py
 tests/test_ins.py
 tests/test_ins_gnss.py
+tests/test_ionosphere.py
 tests/test_jpda.py
 tests/test_kalman_filters.py
+tests/test_marcum_q.py
+tests/test_matched_filter.py
 tests/test_mathematical_functions.py
 tests/test_maximum_likelihood.py
 tests/test_mht.py
@@ -219,9 +230,11 @@ tests/test_performance_evaluation.py
 tests/test_phase6_specialized.py
 tests/test_plotting.py
 tests/test_projections.py
+tests/test_quadrature.py
 tests/test_rbpf.py
 tests/test_relativity.py
 tests/test_rhumb.py
+tests/test_rotations.py
 tests/test_sgp4.py
 tests/test_signal_processing.py
 tests/test_smoothers.py
@@ -229,6 +242,7 @@ tests/test_spatial_containers_parametrized.py
 tests/test_spatial_structures.py
 tests/test_special_functions.py
 tests/test_special_orbits.py
+tests/test_square_root_filters.py
 tests/test_static_estimation.py
 tests/test_terrain.py
 tests/test_terrain_loaders.py
@@ -238,4 +252,5 @@ tests/test_trackers.py
 tests/test_tracking_containers.py
 tests/test_transforms.py
 tests/test_validation.py
+tests/test_wavelets.py
 tests/unit/test_core.py

{nrl_tracker-1.10.0 → nrl_tracker-1.11.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nrl-tracker"
-version = "1.10.0"
+version = "1.11.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.10.0 → nrl_tracker-1.11.0}/pytcl/__init__.py

@@ -6,8 +6,8 @@ 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.10.0 (January 4, 2026)
-**Status:** Production-ready, 2,133 tests passing, 76% line coverage
+**Current Version:** 1.11.0 (January 5, 2026)
+**Status:** Production-ready, 2,894 tests passing, 76% line coverage
 Examples
 --------
 >>> import pytcl as pytcl
@@ -21,7 +21,7 @@ References
        no. 5, pp. 18-27, May 2017.
 """
 
-__version__ = "1.10.0"
+__version__ = "1.11.0"
 __author__ = "Python Port Contributors"
 __original_author__ = "David F. Crouse, Naval Research Laboratory"
 

{nrl_tracker-1.10.0 → nrl_tracker-1.11.0}/pytcl/assignment_algorithms/nd_assignment.py

@@ -9,6 +9,11 @@ enabling more complex assignment scenarios such as:
 The module provides a unified interface for solving high-dimensional
 assignment problems using generalized relaxation methods.
 
+Performance Notes
+-----------------
+For sparse cost tensors (mostly invalid assignments), use SparseCostTensor
+to reduce memory usage by up to 50% and improve performance on large problems.
+
 References
 ----------
 .. [1] Poore, A. B., "Multidimensional Assignment Problem and Data
@@ -18,7 +23,7 @@ References
        Drug Discovery," Perspectives in Drug Discovery and Design, 2003.
 """
 
-from typing import NamedTuple, Optional, Tuple
+from typing import List, NamedTuple, Optional, Tuple, Union
 
 import numpy as np
 from numpy.typing import NDArray
@@ -442,3 +447,356 @@ def detect_dimension_conflicts(
             return True
 
     return False
+
+
+class SparseCostTensor:
+    """
+    Sparse representation of N-dimensional cost tensor.
+
+    For assignment problems where most entries represent invalid
+    assignments (infinite cost), storing only valid entries reduces
+    memory by 50% or more and speeds up greedy algorithms.
+
+    Attributes
+    ----------
+    dims : tuple
+        Shape of the full tensor (n1, n2, ..., nk).
+    indices : ndarray
+        Array of shape (n_valid, n_dims) with valid entry indices.
+    costs : ndarray
+        Array of shape (n_valid,) with costs for valid entries.
+    default_cost : float
+        Cost for entries not explicitly stored (default: inf).
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> # Create sparse tensor for 10x10x10 problem with 50 valid entries
+    >>> dims = (10, 10, 10)
+    >>> valid_indices = np.random.randint(0, 10, size=(50, 3))
+    >>> valid_costs = np.random.rand(50)
+    >>> sparse = SparseCostTensor(dims, valid_indices, valid_costs)
+    >>> sparse.n_valid
+    50
+    >>> sparse.sparsity  # Fraction of valid entries
+    0.05
+
+    >>> # Convert from dense tensor with inf for invalid
+    >>> dense = np.full((5, 5, 5), np.inf)
+    >>> dense[0, 0, 0] = 1.0
+    >>> dense[1, 1, 1] = 2.0
+    >>> sparse = SparseCostTensor.from_dense(dense)
+    >>> sparse.n_valid
+    2
+    """
+
+    def __init__(
+        self,
+        dims: Tuple[int, ...],
+        indices: NDArray[np.intp],
+        costs: NDArray[np.float64],
+        default_cost: float = np.inf,
+    ):
+        """
+        Initialize sparse cost tensor.
+
+        Parameters
+        ----------
+        dims : tuple
+            Shape of the full tensor.
+        indices : ndarray
+            Valid entry indices, shape (n_valid, n_dims).
+        costs : ndarray
+            Costs for valid entries, shape (n_valid,).
+        default_cost : float
+            Cost for invalid (unstored) entries.
+        """
+        self.dims = dims
+        self.indices = np.asarray(indices, dtype=np.intp)
+        self.costs = np.asarray(costs, dtype=np.float64)
+        self.default_cost = default_cost
+
+        # Build lookup for O(1) cost retrieval
+        self._cost_map: dict[Tuple[int, ...], float] = {}
+        for i in range(len(self.costs)):
+            key = tuple(self.indices[i])
+            self._cost_map[key] = self.costs[i]
+
+    @property
+    def n_dims(self) -> int:
+        """Number of dimensions."""
+        return len(self.dims)
+
+    @property
+    def n_valid(self) -> int:
+        """Number of valid (finite cost) entries."""
+        return len(self.costs)
+
+    @property
+    def sparsity(self) -> float:
+        """Fraction of tensor that is valid (0 to 1)."""
+        total_size = int(np.prod(self.dims))
+        return self.n_valid / total_size if total_size > 0 else 0.0
+
+    @property
+    def memory_savings(self) -> float:
+        """Estimated memory savings vs dense representation (0 to 1)."""
+        dense_size = np.prod(self.dims) * 8  # 8 bytes per float64
+        sparse_size = self.n_valid * (8 + self.n_dims * 8)  # cost + indices
+        return max(0, 1 - sparse_size / dense_size) if dense_size > 0 else 0.0
+
+    def get_cost(self, index: Tuple[int, ...]) -> float:
+        """Get cost for a specific index tuple."""
+        return self._cost_map.get(index, self.default_cost)
+
+    def to_dense(self) -> NDArray[np.float64]:
+        """
+        Convert to dense tensor representation.
+
+        Returns
+        -------
+        dense : ndarray
+            Full tensor with default_cost for unstored entries.
+
+        Notes
+        -----
+        May use significant memory for large tensors.
+        """
+        dense = np.full(self.dims, self.default_cost, dtype=np.float64)
+        for i in range(len(self.costs)):
+            dense[tuple(self.indices[i])] = self.costs[i]
+        return dense
+
+    @classmethod
+    def from_dense(
+        cls,
+        dense: NDArray[np.float64],
+        threshold: float = 1e10,
+    ) -> "SparseCostTensor":
+        """
+        Create sparse tensor from dense array.
+
+        Parameters
+        ----------
+        dense : ndarray
+            Dense cost tensor.
+        threshold : float
+            Entries above this value are considered invalid.
+            Default 1e10 (catches np.inf and large values).
+
+        Returns
+        -------
+        SparseCostTensor
+            Sparse representation.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> dense = np.array([[[1, np.inf], [np.inf, 2]],
+        ...                   [[np.inf, 3], [4, np.inf]]])
+        >>> sparse = SparseCostTensor.from_dense(dense)
+        >>> sparse.n_valid
+        4
+        """
+        valid_mask = dense < threshold
+        indices = np.array(np.where(valid_mask)).T
+        costs = dense[valid_mask]
+        return cls(dense.shape, indices, costs, default_cost=np.inf)
+
+
+def greedy_assignment_nd_sparse(
+    sparse_cost: SparseCostTensor,
+    max_assignments: Optional[int] = None,
+) -> AssignmentNDResult:
+    """
+    Greedy solver for sparse N-dimensional assignment.
+
+    Selects minimum-cost tuples from valid entries only, which is much
+    faster than dense greedy when sparsity < 0.5.
+
+    Parameters
+    ----------
+    sparse_cost : SparseCostTensor
+        Sparse cost tensor with valid entries only.
+    max_assignments : int, optional
+        Maximum number of assignments (default: min(dimensions)).
+
+    Returns
+    -------
+    AssignmentNDResult
+        Assignments, total cost, and algorithm info.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> # Create sparse problem
+    >>> dims = (10, 10, 10)
+    >>> # Only 20 valid assignments out of 1000
+    >>> indices = np.array([[i, i, i] for i in range(10)] +
+    ...                    [[i, (i+1)%10, (i+2)%10] for i in range(10)])
+    >>> costs = np.random.rand(20)
+    >>> sparse = SparseCostTensor(dims, indices, costs)
+    >>> result = greedy_assignment_nd_sparse(sparse)
+    >>> result.converged
+    True
+
+    Notes
+    -----
+    Time complexity is O(n_valid * log(n_valid)) vs O(total_size * log(total_size))
+    for dense greedy. For a 10x10x10 tensor with 50 valid entries, this is
+    50*log(50) vs 1000*log(1000), about 20x faster.
+    """
+    dims = sparse_cost.dims
+    n_dims = sparse_cost.n_dims
+
+    if max_assignments is None:
+        max_assignments = min(dims)
+
+    # Sort valid entries by cost
+    sorted_indices = np.argsort(sparse_cost.costs)
+
+    assignments: List[Tuple[int, ...]] = []
+    used_indices: List[set[int]] = [set() for _ in range(n_dims)]
+    total_cost = 0.0
+
+    for sorted_idx in sorted_indices:
+        if len(assignments) >= max_assignments:
+            break
+
+        multi_idx = tuple(sparse_cost.indices[sorted_idx])
+
+        # 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)
+            total_cost += sparse_cost.costs[sorted_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:
+        assignments_array = np.empty((0, n_dims), dtype=np.intp)
+
+    return AssignmentNDResult(
+        assignments=assignments_array,
+        cost=total_cost,
+        converged=True,
+        n_iterations=1,
+        gap=0.0,
+    )
+
+
+def assignment_nd(
+    cost: Union[NDArray[np.float64], SparseCostTensor],
+    method: str = "auto",
+    max_assignments: Optional[int] = None,
+    max_iterations: int = 100,
+    tolerance: float = 1e-6,
+    epsilon: float = 0.01,
+    verbose: bool = False,
+) -> AssignmentNDResult:
+    """
+    Unified interface for N-dimensional assignment.
+
+    Automatically selects between dense and sparse algorithms based on
+    input type and sparsity.
+
+    Parameters
+    ----------
+    cost : ndarray or SparseCostTensor
+        Cost tensor (dense) or sparse cost representation.
+    method : str
+        Algorithm to use: 'auto', 'greedy', 'relaxation', 'auction'.
+        'auto' selects greedy for sparse, relaxation for dense.
+    max_assignments : int, optional
+        Maximum number of assignments for greedy methods.
+    max_iterations : int
+        Maximum iterations for iterative methods.
+    tolerance : float
+        Convergence tolerance for relaxation.
+    epsilon : float
+        Price increment for auction algorithm.
+    verbose : bool
+        Print progress information.
+
+    Returns
+    -------
+    AssignmentNDResult
+        Assignment solution.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> # Dense usage
+    >>> cost = np.random.rand(4, 4, 4)
+    >>> result = assignment_nd(cost, method='greedy')
+    >>> result.converged
+    True
+
+    >>> # Sparse usage (more efficient for large sparse problems)
+    >>> dense = np.full((20, 20, 20), np.inf)
+    >>> for i in range(20):
+    ...     dense[i, i, i] = np.random.rand()
+    >>> sparse = SparseCostTensor.from_dense(dense)
+    >>> result = assignment_nd(sparse, method='auto')
+    >>> result.converged
+    True
+
+    See Also
+    --------
+    greedy_assignment_nd : Dense greedy algorithm.
+    greedy_assignment_nd_sparse : Sparse greedy algorithm.
+    relaxation_assignment_nd : Lagrangian relaxation.
+    auction_assignment_nd : Auction algorithm.
+    """
+    if isinstance(cost, SparseCostTensor):
+        # Sparse input - use sparse algorithm
+        if method in ("auto", "greedy"):
+            return greedy_assignment_nd_sparse(cost, max_assignments)
+        else:
+            # Convert to dense for other methods
+            dense = cost.to_dense()
+            if method == "relaxation":
+                return relaxation_assignment_nd(
+                    dense, max_iterations, tolerance, verbose
+                )
+            elif method == "auction":
+                return auction_assignment_nd(
+                    dense, max_iterations, epsilon=epsilon, verbose=verbose
+                )
+            else:
+                raise ValueError(f"Unknown method: {method}")
+    else:
+        # Dense input
+        cost = np.asarray(cost, dtype=np.float64)
+        if method == "auto":
+            # Use relaxation for better solutions on dense
+            return relaxation_assignment_nd(cost, max_iterations, tolerance, verbose)
+        elif method == "greedy":
+            return greedy_assignment_nd(cost, max_assignments)
+        elif method == "relaxation":
+            return relaxation_assignment_nd(cost, max_iterations, tolerance, verbose)
+        elif method == "auction":
+            return auction_assignment_nd(
+                cost, max_iterations, epsilon=epsilon, verbose=verbose
+            )
+        else:
+            raise ValueError(f"Unknown method: {method}")
+
+
+__all__ = [
+    "AssignmentNDResult",
+    "SparseCostTensor",
+    "validate_cost_tensor",
+    "greedy_assignment_nd",
+    "greedy_assignment_nd_sparse",
+    "relaxation_assignment_nd",
+    "auction_assignment_nd",
+    "detect_dimension_conflicts",
+    "assignment_nd",
+]