feat: Add semi-continous variables as an option (#593)

* Add semi-continous variables as an option

* Run the pre-commit

* Fix mypy issues

* Add release notes note

* Fabian feedback

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Missing to_culpdx

---------

Co-authored-by: Fabian Hofmann <fab.hof@gmx.de>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: 3 people

doc/release_notes.rst

@@ -17,6 +17,7 @@ Upcoming Version
 * Add ``active`` parameter to ``piecewise()`` for gating piecewise linear functions with a binary variable (e.g. unit commitment). Supported for incremental, SOS2, and disjunctive methods.
 * Add the `sphinx-copybutton` to the documentation
 * Add SOS1 and SOS2 reformulations for solvers not supporting them.
+* Add semi-continous variables for solvers that support them
 * Improve handling of CPLEX solver quality attributes to ensure metrics such are extracted correctly when available.
 * Fix Xpress IIS label mapping for masked constraints and add a regression test for matching infeasible coordinates.
 * Enable quadratic problems with SCIP on windows.

linopy/io.py

@@ -234,7 +234,11 @@ def bounds_to_file(
     """
     Write out variables of a model to a lp file.
     """
-    names = list(m.variables.continuous) + list(m.variables.integers)
+    names = (
+        list(m.variables.continuous)
+        + list(m.variables.integers)
+        + list(m.variables.semi_continuous)
+    )
     if not len(list(names)):
         return
 
@@ -304,6 +308,44 @@ def binaries_to_file(
             _format_and_write(df, columns, f)
 
 
+def semi_continuous_to_file(
+    m: Model,
+    f: BufferedWriter,
+    progress: bool = False,
+    slice_size: int = 2_000_000,
+    explicit_coordinate_names: bool = False,
+) -> None:
+    """
+    Write out semi-continuous variables of a model to a lp file.
+    """
+    names = m.variables.semi_continuous
+    if not len(list(names)):
+        return
+
+    print_variable, _ = get_printers(
+        m, explicit_coordinate_names=explicit_coordinate_names
+    )
+
+    f.write(b"\n\nsemi-continuous\n\n")
+    if progress:
+        names = tqdm(
+            list(names),
+            desc="Writing semi-continuous variables.",
+            colour=TQDM_COLOR,
+        )
+
+    for name in names:
+        var = m.variables[name]
+        for var_slice in var.iterate_slices(slice_size):
+            df = var_slice.to_polars()
+
+            columns = [
+                *print_variable(pl.col("labels")),
+            ]
+
+            _format_and_write(df, columns, f)
+
+
 def integers_to_file(
     m: Model,
     f: BufferedWriter,
@@ -509,6 +551,13 @@ def to_lp_file(
             slice_size=slice_size,
             explicit_coordinate_names=explicit_coordinate_names,
         )
+        semi_continuous_to_file(
+            m,
+            f=f,
+            progress=progress,
+            slice_size=slice_size,
+            explicit_coordinate_names=explicit_coordinate_names,
+        )
         sos_to_file(
             m,
             f=f,
@@ -594,6 +643,12 @@ def to_mosek(
     if m.variables.sos:
         raise NotImplementedError("SOS constraints are not supported by MOSEK.")
 
+    if m.variables.semi_continuous:
+        raise NotImplementedError(
+            "Semi-continuous variables are not supported by MOSEK. "
+            "Use a solver that supports them (gurobi, cplex, highs)."
+        )
+
     import mosek
 
     print_variable, print_constraint = get_printers_scalar(
@@ -720,7 +775,11 @@ def to_gurobipy(
 
     names = np.vectorize(print_variable)(M.vlabels).astype(object)
     kwargs = {}
-    if len(m.binaries.labels) + len(m.integers.labels):
+    if (
+        len(m.binaries.labels)
+        + len(m.integers.labels)
+        + len(list(m.variables.semi_continuous))
+    ):
         kwargs["vtype"] = M.vtypes
     x = model.addMVar(M.vlabels.shape, M.lb, M.ub, name=list(names), **kwargs)
 
@@ -793,11 +852,17 @@ def to_highspy(m: Model, explicit_coordinate_names: bool = False) -> Highs:
     M = m.matrices
     h = highspy.Highs()
     h.addVars(len(M.vlabels), M.lb, M.ub)
-    if len(m.binaries) + len(m.integers):
+    if len(m.binaries) + len(m.integers) + len(list(m.variables.semi_continuous)):
         vtypes = M.vtypes
-        labels = np.arange(len(vtypes))[(vtypes == "B") | (vtypes == "I")]
-        n = len(labels)
-        h.changeColsIntegrality(n, labels, ones_like(labels))
+        # Map linopy vtypes to HiGHS integrality values:
+        # 0 = continuous, 1 = integer, 2 = semi-continuous
+        integrality_map = {"C": 0, "B": 1, "I": 1, "S": 2}
+        int_mask = (vtypes == "B") | (vtypes == "I") | (vtypes == "S")
+        labels = np.arange(len(vtypes))[int_mask]
+        integrality = np.array(
+            [integrality_map[v] for v in vtypes[int_mask]], dtype=np.int32
+        )
+        h.changeColsIntegrality(len(labels), labels, integrality)
         if len(m.binaries):
             labels = np.arange(len(vtypes))[vtypes == "B"]
             n = len(labels)
@@ -856,6 +921,12 @@ def to_cupdlpx(m: Model, explicit_coordinate_names: bool = False) -> cupdlpxMode
     -------
     model : cupdlpx.Model
     """
+    if m.variables.semi_continuous:
+        raise NotImplementedError(
+            "Semi-continuous variables are not supported by cuPDLPx. "
+            "Use a solver that supports them (gurobi, cplex, highs)."
+        )
+
     import cupdlpx
 
     if explicit_coordinate_names:

linopy/matrices.py

@@ -83,6 +83,8 @@ def vtypes(self) -> ndarray:
                 val = "B"
             elif name in m.integers:
                 val = "I"
+            elif name in m.semi_continuous:
+                val = "S"
             else:
                 val = "C"
             specs.append(pd.Series(val, index=m.variables[name].flat.labels))

linopy/model.py

@@ -500,6 +500,7 @@ def add_variables(
         mask: DataArray | ndarray | Series | None = None,
         binary: bool = False,
         integer: bool = False,
+        semi_continuous: bool = False,
         **kwargs: Any,
     ) -> Variable:
         """
@@ -538,6 +539,11 @@ def add_variables(
         integer : bool
             Whether the new variable is a integer variable which are used for
             Mixed-Integer problems.
+        semi_continuous : bool
+            Whether the new variable is a semi-continuous variable. A
+            semi-continuous variable can take the value 0 or any value
+            between its lower and upper bounds. Requires a positive lower
+            bound.
         **kwargs :
             Additional keyword arguments are passed to the DataArray creation.
 
@@ -580,15 +586,23 @@ def add_variables(
         if name in self.variables:
             raise ValueError(f"Variable '{name}' already assigned to model")
 
-        if binary and integer:
-            raise ValueError("Variable cannot be both binary and integer.")
+        if sum([binary, integer, semi_continuous]) > 1:
+            raise ValueError(
+                "Variable can only be one of binary, integer, or semi-continuous."
+            )
 
         if binary:
             if (lower != -inf) or (upper != inf):
                 raise ValueError("Binary variables cannot have lower or upper bounds.")
             else:
                 lower, upper = 0, 1
 
+        if semi_continuous:
+            if not np.isscalar(lower) or float(lower) <= 0:  # type: ignore[arg-type]
+                raise ValueError(
+                    "Semi-continuous variables require a positive scalar lower bound."
+                )
+
         data = Dataset(
             {
                 "lower": as_dataarray(lower, coords, **kwargs),
@@ -626,7 +640,11 @@ def add_variables(
             data.labels.values = np.where(mask.values, data.labels.values, -1)
 
         data = data.assign_attrs(
-            label_range=(start, end), name=name, binary=binary, integer=integer
+            label_range=(start, end),
+            name=name,
+            binary=binary,
+            integer=integer,
+            semi_continuous=semi_continuous,
         )
 
         if self.chunk:
@@ -1018,6 +1036,13 @@ def integers(self) -> Variables:
         """
         return self.variables.integers
 
+    @property
+    def semi_continuous(self) -> Variables:
+        """
+        Get all semi-continuous variables.
+        """
+        return self.variables.semi_continuous
+
     @property
     def is_linear(self) -> bool:
         return self.objective.is_linear
@@ -1028,9 +1053,11 @@ def is_quadratic(self) -> bool:
 
     @property
     def type(self) -> str:
-        if (len(self.binaries) or len(self.integers)) and len(self.continuous):
+        if (
+            len(self.binaries) or len(self.integers) or len(self.semi_continuous)
+        ) and len(self.continuous):
             variable_type = "MI"
-        elif len(self.binaries) or len(self.integers):
+        elif len(self.binaries) or len(self.integers) or len(self.semi_continuous):
             variable_type = "I"
         else:
             variable_type = ""
@@ -1469,6 +1496,15 @@ def solve(
                     "Use reformulate_sos=True or 'auto', or a solver that supports SOS (gurobi, cplex)."
                 )
 
+        if self.variables.semi_continuous:
+            if not solver_supports(
+                solver_name, SolverFeature.SEMI_CONTINUOUS_VARIABLES
+            ):
+                raise ValueError(
+                    f"Solver {solver_name} does not support semi-continuous variables. "
+                    "Use a solver that supports them (gurobi, cplex, highs)."
+                )
+
         try:
             solver_class = getattr(solvers, f"{solvers.SolverName(solver_name).name}")
             # initialize the solver as object of solver subclass <solver_class>

linopy/solver_capabilities.py

@@ -49,6 +49,9 @@ class SolverFeature(Enum):
     # Special constraint types
     SOS_CONSTRAINTS = auto()  # Special Ordered Sets (SOS1/SOS2) constraints
 
+    # Special variable types
+    SEMI_CONTINUOUS_VARIABLES = auto()  # Semi-continuous variable support
+
     # Solver-specific
     SOLVER_ATTRIBUTE_ACCESS = auto()  # Direct access to solver variable attributes
 
@@ -85,6 +88,7 @@ def supports(self, feature: SolverFeature) -> bool:
                 SolverFeature.SOLUTION_FILE_NOT_NEEDED,
                 SolverFeature.IIS_COMPUTATION,
                 SolverFeature.SOS_CONSTRAINTS,
+                SolverFeature.SEMI_CONTINUOUS_VARIABLES,
                 SolverFeature.SOLVER_ATTRIBUTE_ACCESS,
             }
         ),
@@ -100,6 +104,7 @@ def supports(self, feature: SolverFeature) -> bool:
                 SolverFeature.LP_FILE_NAMES,
                 SolverFeature.READ_MODEL_FROM_FILE,
                 SolverFeature.SOLUTION_FILE_NOT_NEEDED,
+                SolverFeature.SEMI_CONTINUOUS_VARIABLES,
             }
         ),
     ),
@@ -133,6 +138,7 @@ def supports(self, feature: SolverFeature) -> bool:
                 SolverFeature.LP_FILE_NAMES,
                 SolverFeature.READ_MODEL_FROM_FILE,
                 SolverFeature.SOS_CONSTRAINTS,
+                SolverFeature.SEMI_CONTINUOUS_VARIABLES,
             }
         ),
     ),

linopy/variables.py

@@ -1386,6 +1386,8 @@ def __repr__(self) -> str:
                 sos_dim := ds.attrs.get(SOS_DIM_ATTR)
             ):
                 coords += f" - sos{sos_type} on {sos_dim}"
+            if ds.attrs.get("semi_continuous", False):
+                coords += " - semi-continuous"
             r += f" * {name}{coords}\n"
         if not len(list(self)):
             r += "<empty>\n"
@@ -1525,7 +1527,23 @@ def continuous(self) -> Variables:
             {
                 name: self.data[name]
                 for name in self
-                if not self[name].attrs["integer"] and not self[name].attrs["binary"]
+                if not self[name].attrs["integer"]
+                and not self[name].attrs["binary"]
+                and not self[name].attrs.get("semi_continuous", False)
+            },
+            self.model,
+        )
+
+    @property
+    def semi_continuous(self) -> Variables:
+        """
+        Get all semi-continuous variables.
+        """
+        return self.__class__(
+            {
+                name: self.data[name]
+                for name in self
+                if self[name].attrs.get("semi_continuous", False)
             },
             self.model,
         )