rename to add_piecewise_constraints

Author: FBumann

linopy/model.py

@@ -597,7 +597,7 @@ def add_sos_constraints(
 
         variable.attrs.update(sos_type=sos_type, sos_dim=sos_dim)
 
-    def add_piecewise_constraint(
+    def add_piecewise_constraints(
         self,
         expr: Variable | LinearExpression | dict[str, Variable | LinearExpression],
         breakpoints: DataArray,
@@ -675,15 +675,15 @@ def add_piecewise_constraint(
         >>> m = Model()
         >>> x = m.add_variables(name="x")
         >>> breakpoints = xr.DataArray([0, 10, 50, 100], dims=["bp"])
-        >>> m.add_piecewise_constraint(x, breakpoints, dim="bp")
+        >>> m.add_piecewise_constraints(x, breakpoints, dim="bp")
 
         Using an expression:
 
         >>> m = Model()
         >>> x = m.add_variables(name="x")
         >>> y = m.add_variables(name="y")
         >>> breakpoints = xr.DataArray([0, 10, 50, 100], dims=["bp"])
-        >>> m.add_piecewise_constraint(x + y, breakpoints, dim="bp")
+        >>> m.add_piecewise_constraints(x + y, breakpoints, dim="bp")
 
         Multiple linked variables (e.g., power-efficiency curve):
 
@@ -695,7 +695,7 @@ def add_piecewise_constraint(
         ...     [[0, 50, 100], [0.8, 0.95, 0.9]],
         ...     coords={"var": ["power", "efficiency"], "bp": [0, 1, 2]},
         ... )
-        >>> m.add_piecewise_constraint(
+        >>> m.add_piecewise_constraints(
         ...     {"power": power, "efficiency": efficiency},
         ...     breakpoints,
         ...     link_dim="var",

test/test_piecewise_constraints.py

@@ -23,7 +23,7 @@ def test_basic_single_variable(self) -> None:
             [0, 10, 50, 100], dims=["bp"], coords={"bp": [0, 1, 2, 3]}
         )
 
-        m.add_piecewise_constraint(x, breakpoints, dim="bp")
+        m.add_piecewise_constraints(x, breakpoints, dim="bp")
 
         # Check lambda variables were created
         assert f"pwl0{PWL_LAMBDA_SUFFIX}" in m.variables
@@ -50,7 +50,7 @@ def test_single_variable_with_coords(self) -> None:
             coords={"generator": generators, "bp": bp_coords},
         )
 
-        m.add_piecewise_constraint(x, breakpoints, dim="bp")
+        m.add_piecewise_constraints(x, breakpoints, dim="bp")
 
         # Lambda should have both generator and bp dimensions
         lambda_var = m.variables[f"pwl0{PWL_LAMBDA_SUFFIX}"]
@@ -73,7 +73,7 @@ def test_dict_of_variables(self) -> None:
             coords={"var": ["power", "efficiency"], "bp": [0, 1, 2]},
         )
 
-        m.add_piecewise_constraint(
+        m.add_piecewise_constraints(
             {"power": power, "efficiency": efficiency},
             breakpoints,
             link_dim="var",
@@ -100,7 +100,7 @@ def test_dict_with_coordinates(self) -> None:
             },
         )
 
-        m.add_piecewise_constraint(
+        m.add_piecewise_constraints(
             {"power": power, "efficiency": efficiency},
             breakpoints,
             link_dim="var",
@@ -130,7 +130,7 @@ def test_auto_detect_link_dim(self) -> None:
         )
 
         # Should auto-detect link_dim="var"
-        m.add_piecewise_constraint(
+        m.add_piecewise_constraints(
             {"power": power, "efficiency": efficiency},
             breakpoints,
             dim="bp",
@@ -152,7 +152,7 @@ def test_auto_detect_fails_with_no_match(self) -> None:
         )
 
         with pytest.raises(ValueError, match="Could not auto-detect link_dim"):
-            m.add_piecewise_constraint(
+            m.add_piecewise_constraints(
                 {"power": power, "efficiency": efficiency},
                 breakpoints,
                 dim="bp",
@@ -174,7 +174,7 @@ def test_nan_masking(self) -> None:
             coords={"bp": [0, 1, 2, 3]},
         )
 
-        m.add_piecewise_constraint(x, breakpoints, dim="bp")
+        m.add_piecewise_constraints(x, breakpoints, dim="bp")
 
         # Lambda for NaN breakpoint should be masked
         lambda_var = m.variables[f"pwl0{PWL_LAMBDA_SUFFIX}"]
@@ -200,7 +200,7 @@ def test_explicit_mask(self) -> None:
             coords={"generator": generators, "bp": [0, 1, 2]},
         )
 
-        m.add_piecewise_constraint(x, breakpoints, dim="bp", mask=mask)
+        m.add_piecewise_constraints(x, breakpoints, dim="bp", mask=mask)
 
         # Should still create variables and constraints
         assert f"pwl0{PWL_LAMBDA_SUFFIX}" in m.variables
@@ -214,7 +214,7 @@ def test_skip_nan_check(self) -> None:
         breakpoints = xr.DataArray([0, 10, 50], dims=["bp"], coords={"bp": [0, 1, 2]})
 
         # Should work with skip_nan_check=True
-        m.add_piecewise_constraint(x, breakpoints, dim="bp", skip_nan_check=True)
+        m.add_piecewise_constraints(x, breakpoints, dim="bp", skip_nan_check=True)
 
         # All lambda variables should be valid (no masking)
         lambda_var = m.variables[f"pwl0{PWL_LAMBDA_SUFFIX}"]
@@ -238,7 +238,7 @@ def test_multi_dimensional(self) -> None:
             coords={"generator": generators, "time": timesteps, "bp": [0, 1, 2, 3]},
         )
 
-        m.add_piecewise_constraint(x, breakpoints, dim="bp")
+        m.add_piecewise_constraints(x, breakpoints, dim="bp")
 
         # Lambda should have all dimensions
         lambda_var = m.variables[f"pwl0{PWL_LAMBDA_SUFFIX}"]
@@ -259,7 +259,7 @@ def test_invalid_vars_type(self) -> None:
         with pytest.raises(
             ValueError, match="must be a Variable, LinearExpression, or dict"
         ):
-            m.add_piecewise_constraint("invalid", breakpoints, dim="bp")  # type: ignore
+            m.add_piecewise_constraints("invalid", breakpoints, dim="bp")  # type: ignore
 
     def test_missing_dim(self) -> None:
         """Test error when breakpoints don't have the required dim."""
@@ -269,7 +269,7 @@ def test_missing_dim(self) -> None:
         breakpoints = xr.DataArray([0, 10, 50], dims=["wrong"])
 
         with pytest.raises(ValueError, match="must have dimension"):
-            m.add_piecewise_constraint(x, breakpoints, dim="bp")
+            m.add_piecewise_constraints(x, breakpoints, dim="bp")
 
     def test_non_numeric_dim(self) -> None:
         """Test error when dim coordinates are not numeric."""
@@ -283,7 +283,7 @@ def test_non_numeric_dim(self) -> None:
         )
 
         with pytest.raises(ValueError, match="numeric coordinates"):
-            m.add_piecewise_constraint(x, breakpoints, dim="bp")
+            m.add_piecewise_constraints(x, breakpoints, dim="bp")
 
     def test_expression_support(self) -> None:
         """Test that LinearExpression is supported as input."""
@@ -294,7 +294,7 @@ def test_expression_support(self) -> None:
         breakpoints = xr.DataArray([0, 10, 50], dims=["bp"], coords={"bp": [0, 1, 2]})
 
         # Should work with a LinearExpression
-        m.add_piecewise_constraint(x + y, breakpoints, dim="bp")
+        m.add_piecewise_constraints(x + y, breakpoints, dim="bp")
 
         # Check constraints were created
         assert f"pwl0{PWL_LINK_SUFFIX}" in m.constraints
@@ -308,7 +308,7 @@ def test_link_dim_not_in_breakpoints(self) -> None:
         breakpoints = xr.DataArray([0, 50, 100], dims=["bp"], coords={"bp": [0, 1, 2]})
 
         with pytest.raises(ValueError, match="not found in breakpoints dimensions"):
-            m.add_piecewise_constraint(
+            m.add_piecewise_constraints(
                 {"power": power, "efficiency": efficiency},
                 breakpoints,
                 link_dim="var",
@@ -328,7 +328,7 @@ def test_link_dim_coords_mismatch(self) -> None:
         )
 
         with pytest.raises(ValueError, match="don't match expression keys"):
-            m.add_piecewise_constraint(
+            m.add_piecewise_constraints(
                 {"power": power, "efficiency": efficiency},
                 breakpoints,
                 link_dim="var",
@@ -348,8 +348,8 @@ def test_auto_name_generation(self) -> None:
         bp1 = xr.DataArray([0, 10, 50], dims=["bp"], coords={"bp": [0, 1, 2]})
         bp2 = xr.DataArray([0, 20, 80], dims=["bp"], coords={"bp": [0, 1, 2]})
 
-        m.add_piecewise_constraint(x, bp1, dim="bp")
-        m.add_piecewise_constraint(y, bp2, dim="bp")
+        m.add_piecewise_constraints(x, bp1, dim="bp")
+        m.add_piecewise_constraints(y, bp2, dim="bp")
 
         assert f"pwl0{PWL_LAMBDA_SUFFIX}" in m.variables
         assert f"pwl1{PWL_LAMBDA_SUFFIX}" in m.variables
@@ -361,7 +361,7 @@ def test_custom_name(self) -> None:
 
         breakpoints = xr.DataArray([0, 10, 50], dims=["bp"], coords={"bp": [0, 1, 2]})
 
-        m.add_piecewise_constraint(x, breakpoints, dim="bp", name="my_pwl")
+        m.add_piecewise_constraints(x, breakpoints, dim="bp", name="my_pwl")
 
         assert f"my_pwl{PWL_LAMBDA_SUFFIX}" in m.variables
         assert f"my_pwl{PWL_CONVEX_SUFFIX}" in m.constraints
@@ -382,7 +382,7 @@ def test_piecewise_written_to_lp(self, tmp_path) -> None:
             coords={"bp": [0, 1, 2]},
         )
 
-        m.add_piecewise_constraint(x, breakpoints, dim="bp")
+        m.add_piecewise_constraints(x, breakpoints, dim="bp")
 
         # Add a simple objective to make it a valid LP
         m.add_objective(x)
@@ -418,7 +418,7 @@ def test_solve_single_variable(self) -> None:
             coords={"var": ["x", "cost"], "bp": [0, 1, 2]},
         )
 
-        m.add_piecewise_constraint(
+        m.add_piecewise_constraints(
             {"x": x, "cost": cost}, breakpoints, link_dim="var", dim="bp"
         )
 
@@ -453,7 +453,7 @@ def test_solve_efficiency_curve(self) -> None:
             coords={"var": ["power", "efficiency"], "bp": [0, 1, 2, 3, 4]},
         )
 
-        m.add_piecewise_constraint(
+        m.add_piecewise_constraints(
             {"power": power, "efficiency": efficiency},
             breakpoints,
             link_dim="var",
@@ -498,7 +498,7 @@ def test_solve_multi_generator(self) -> None:
             },
         )
 
-        m.add_piecewise_constraint(
+        m.add_piecewise_constraints(
             {"power": power, "cost": cost}, breakpoints, link_dim="var", dim="bp"
         )