Rename methods and only keep old one for benchmarking

Author: FBumann

dev-scripts/benchmark_printing.py

@@ -36,7 +36,7 @@
 import xarray as xr
 
 from linopy import Model
-from linopy.common import get_label_position
+from linopy.common import _get_label_position_linear
 
 
 def build_model(n_var_arrays: int, n_con_arrays: int, vars_per_array: int = 10) -> Model:
@@ -108,10 +108,10 @@ def use_original_implementation():
 
     # Replace with original O(n) implementation
     def original_var_get_label_position(self, values):
-        return get_label_position(self, values)
+        return _get_label_position_linear(self, values)
 
     def original_con_get_label_position(self, values):
-        return get_label_position(self, values)
+        return _get_label_position_linear(self, values)
 
     # Original print_single_variable using .sel()
     def original_print_single_variable(model, label):
@@ -121,7 +121,7 @@ def original_print_single_variable(model, label):
             return "None"
 
         variables = model.variables
-        name, coord = get_label_position(variables, label)
+        name, coord = _get_label_position_linear(variables, label)
 
         # Original: use .sel() which is slower
         lower = variables[name].lower.sel(coord).item()

linopy/common.py

@@ -855,7 +855,7 @@ def find_single_with_index(
         return name, coord, index
 
 
-def get_label_position(
+def _get_label_position_linear(
     obj: Any, values: int | np.ndarray
 ) -> (
     tuple[str, dict]
@@ -867,7 +867,7 @@ def get_label_position(
     Get tuple of name and coordinate for variable labels.
 
     This is the original O(n) implementation that scans through all items.
-    For better performance with many items, use LabelPositionIndex.
+    Used only for testing/benchmarking comparisons.
     """
 
     def find_single(value: int) -> tuple[str, dict] | tuple[None, None]:
@@ -903,7 +903,7 @@ def find_single(value: int) -> tuple[str, dict] | tuple[None, None]:
         raise ValueError("Array's with more than two dimensions is not supported")
 
 
-def get_label_position_optimized(
+def get_label_position(
     obj: Any,
     values: int | np.ndarray,
     index: LabelPositionIndex | None = None,
@@ -914,14 +914,14 @@ def get_label_position_optimized(
     | list[list[tuple[str, dict] | tuple[None, None]]]
 ):
     """
-    Get tuple of name and coordinate for variable labels using binary search.
+    Get tuple of name and coordinate for variable labels.
 
-    This is an optimized O(log n) implementation using a pre-built index.
+    Uses O(log n) binary search with a cached index for fast lookups.
 
     Parameters
     ----------
     obj : Any
-        Container object with items() method.
+        Container object with items() method (Variables or Constraints).
     values : int or np.ndarray
         Label value(s) to look up.
     index : LabelPositionIndex, optional

linopy/constraints.py

@@ -39,7 +39,7 @@
     format_string_as_variable_name,
     generate_indices_for_printout,
     get_dims_with_index_levels,
-    get_label_position_optimized,
+    get_label_position,
     group_terms_polars,
     has_optimized_model,
     infer_schema_polars,
@@ -998,7 +998,7 @@ def get_label_position(
         """
         if self._label_position_index is None:
             self._label_position_index = LabelPositionIndex(self)
-        return get_label_position_optimized(self, values, self._label_position_index)
+        return get_label_position(self, values, self._label_position_index)
 
     def print_labels(
         self, values: Sequence[int], display_max_terms: int | None = None

linopy/variables.py

@@ -40,7 +40,7 @@
     format_string_as_variable_name,
     generate_indices_for_printout,
     get_dims_with_index_levels,
-    get_label_position_optimized,
+    get_label_position,
     has_optimized_model,
     is_constant,
     iterate_slices,
@@ -1439,7 +1439,7 @@ def get_label_position(self, values: int | ndarray) -> Any:
         """
         if self._label_position_index is None:
             self._label_position_index = LabelPositionIndex(self)
-        return get_label_position_optimized(self, values, self._label_position_index)
+        return get_label_position(self, values, self._label_position_index)
 
     def get_label_position_with_index(
         self, label: int

test/test_label_position.py

@@ -13,7 +13,7 @@
 from linopy import Model
 from linopy.common import (
     LabelPositionIndex,
-    get_label_position,
+    _get_label_position_linear,
 )
 
 
@@ -189,15 +189,15 @@ def test_matches_original_implementation(self, model):
         labels = rng.integers(0, max_label, size=50)
 
         for label in labels:
-            original = get_label_position(model.variables, int(label))
+            original = _get_label_position_linear(model.variables, int(label))
             optimized = model.variables.get_label_position(int(label))
             assert original == optimized, f"Mismatch for label {label}"
 
     def test_matches_original_batch(self, model):
         """Test that batch lookup matches original."""
         labels = np.arange(min(20, model._xCounter))
 
-        original = get_label_position(model.variables, labels)
+        original = _get_label_position_linear(model.variables, labels)
         optimized = model.variables.get_label_position(labels)
 
         assert original == optimized
@@ -330,14 +330,14 @@ def test_large_model_correctness(self, large_model):
         # Test variables
         max_var = large_model._xCounter
         for label in rng.integers(0, max_var, size=100):
-            original = get_label_position(large_model.variables, int(label))
+            original = _get_label_position_linear(large_model.variables, int(label))
             optimized = large_model.variables.get_label_position(int(label))
             assert original == optimized
 
         # Test constraints
         max_con = large_model._cCounter
         for label in rng.integers(0, max_con, size=100):
-            original = get_label_position(large_model.constraints, int(label))
+            original = _get_label_position_linear(large_model.constraints, int(label))
             optimized = large_model.constraints.get_label_position(int(label))
             assert original == optimized