Merge branch 'master' into ExprLike

Author: Zeroto521

CHANGELOG.md

@@ -22,6 +22,7 @@
 - `Expr` and `GenExpr` support NumPy binary functions (`np.add`, `np.subtract`, `np.multiply`, `np.divide`, `np.true_divide`, `np.power`, `np.less_equal`, `np.greater_equal`, `np.equal`)
 - Added `getBase()` and `setBase()` methods to `LP` class for getting/setting basis status
 - Added `getMemUsed()`, `getMemTotal()`, and `getMemExternEstim()` methods
+- Added `addMatrixConsDisjunction()` for elementwise disjunctions over matrix constraint expressions (`MatrixExprCons`/`ExprCons`) (#1084)
 - Added `isReoptEnabled()` and raising error if not enabled upon calling `reoptSolve()`
 - SOS1/SOS2 constraints are now realease after addition similar to the other constraint types
 ### Fixed

src/pyscipopt/scip.pxi

@@ -6643,6 +6643,123 @@ cdef class Model:
         PY_SCIP_CALL(SCIPreleaseCons(self._scip, &(<Constraint>cons).scip_cons))
         return disj_cons
 
+    def addMatrixConsDisjunction(self, conss: Iterable,
+        name: Union[str, np.ndarray] = '', initial: Union[bool, np.ndarray] = True,
+        relaxcons=None, enforce: Union[bool, np.ndarray] = True,
+        check: Union[bool, np.ndarray] = True, local: Union[bool, np.ndarray] = False,
+        modifiable: Union[bool, np.ndarray] = False,
+        dynamic: Union[bool, np.ndarray] = False):
+        """
+        Add an elementwise disjunction of matrix constraint expressions.
+
+        Given an iterable of ``MatrixExprCons`` with a common shape, creates one
+        disjunction per index: for each position ``idx``, the resulting
+        disjunction enforces that at least one of ``conss[k][idx]`` holds.
+        ``ExprCons`` entries are broadcast to every position. If every entry in
+        ``conss`` is a plain ``ExprCons``, the call is forwarded to
+        :meth:`addConsDisjunction` and returns a single ``Constraint``.
+
+        Note: this method accepts constraint *expressions* (e.g., ``A @ x <= b``),
+        not ``MatrixConstraint``/``Constraint`` objects returned by
+        :meth:`addMatrixCons`/:meth:`addCons`.
+
+        Parameters
+        ----------
+        conss : iterable of MatrixExprCons or ExprCons
+            Constraint expressions to combine elementwise into disjunctions. All
+            ``MatrixExprCons`` entries must share the same shape.
+        name : str or np.ndarray, optional
+            Name of the disjunction constraints. (Default value = "")
+        initial : bool or np.ndarray, optional
+            Should the LP relaxation be in the initial LP? (Default value = True)
+        relaxcons : None, optional
+            NOT YET SUPPORTED. (Default value = None)
+        enforce : bool or np.ndarray, optional
+            Should the constraint be enforced during node processing? (Default value = True)
+        check : bool or np.ndarray, optional
+            Should the constraint be checked for feasibility? (Default value = True)
+        local : bool or np.ndarray, optional
+            Is the constraint only valid locally? (Default value = False)
+        modifiable : bool or np.ndarray, optional
+            Is the constraint modifiable (subject to column generation)? (Default value = False)
+        dynamic : bool or np.ndarray, optional
+            Is the constraint subject to aging? (Default value = False)
+
+        Returns
+        -------
+        MatrixConstraint or Constraint
+            A ``MatrixConstraint`` of the common shape when any entry of
+            ``conss`` is a ``MatrixExprCons``; otherwise a single
+            ``Constraint`` from the scalar fallback.
+        """
+        if not isinstance(conss, Iterable):
+            raise TypeError(f"given constraint list is not iterable, but got {type(conss).__name__}")
+        conss = list(conss)
+
+        for cons in conss:
+            if not isinstance(cons, (ExprCons, MatrixExprCons)):
+                raise TypeError(
+                    "element of conss is not MatrixExprCons nor ExprCons but %s"
+                    % cons.__class__.__name__
+                )
+
+        if all(isinstance(cons, ExprCons) for cons in conss):
+            return self.addConsDisjunction(
+                conss, name=name, initial=initial, relaxcons=relaxcons,
+                enforce=enforce, check=check, local=local,
+                modifiable=modifiable, dynamic=dynamic,
+            )
+
+        shape = None
+        for cons in conss:
+            if isinstance(cons, MatrixExprCons):
+                if shape is None:
+                    shape = cons.shape
+                elif cons.shape != shape:
+                    raise ValueError(
+                        "All MatrixExprCons in conss must have the same shape, "
+                        "got %s and %s" % (shape, cons.shape)
+                    )
+
+        for arr in (name, initial, enforce, check, local, modifiable, dynamic):
+            if isinstance(arr, np.ndarray):
+                assert arr.shape == shape
+
+        if isinstance(name, str):
+            matrix_names = np.full(shape, name, dtype=object)
+            if name != "":
+                for idx in np.ndindex(shape):
+                    matrix_names[idx] = f"{name}_{'_'.join(map(str, idx))}"
+        else:
+            matrix_names = name
+
+        matrix_initial = initial if isinstance(initial, np.ndarray) else np.full(shape, initial, dtype=bool)
+        matrix_enforce = enforce if isinstance(enforce, np.ndarray) else np.full(shape, enforce, dtype=bool)
+        matrix_check = check if isinstance(check, np.ndarray) else np.full(shape, check, dtype=bool)
+        matrix_local = local if isinstance(local, np.ndarray) else np.full(shape, local, dtype=bool)
+        matrix_modifiable = modifiable if isinstance(modifiable, np.ndarray) else np.full(shape, modifiable, dtype=bool)
+        matrix_dynamic = dynamic if isinstance(dynamic, np.ndarray) else np.full(shape, dynamic, dtype=bool)
+
+        matrix_cons = np.empty(shape, dtype=object)
+        for idx in np.ndindex(shape):
+            elem_conss = [
+                cons[idx] if isinstance(cons, MatrixExprCons) else cons
+                for cons in conss
+            ]
+            matrix_cons[idx] = self.addConsDisjunction(
+                elem_conss,
+                name=matrix_names[idx],
+                initial=matrix_initial[idx],
+                relaxcons=relaxcons,
+                enforce=matrix_enforce[idx],
+                check=matrix_check[idx],
+                local=matrix_local[idx],
+                modifiable=matrix_modifiable[idx],
+                dynamic=matrix_dynamic[idx],
+            )
+
+        return matrix_cons.view(MatrixConstraint)
+
     def getConsNVars(self, Constraint constraint):
         """
         Gets number of variables in a constraint.

src/pyscipopt/scip.pyi

@@ -816,6 +816,18 @@ class Model:
         removable: Incomplete = ...,
         stickingatnode: Incomplete = ...,
     ) -> Incomplete: ...
+    def addMatrixConsDisjunction(
+        self,
+        conss: Incomplete,
+        name: Incomplete = ...,
+        initial: Incomplete = ...,
+        relaxcons: Incomplete = ...,
+        enforce: Incomplete = ...,
+        check: Incomplete = ...,
+        local: Incomplete = ...,
+        modifiable: Incomplete = ...,
+        dynamic: Incomplete = ...,
+    ) -> Incomplete: ...
     def addMatrixConsIndicator(
         self,
         cons: Incomplete,

tests/test_matrix_variable.py

@@ -549,6 +549,45 @@ def test_matrix_cons_indicator():
     assert m.getVal(z) == 1
 
 
+def test_matrix_cons_disjunction():
+    m = Model()
+    x = m.addMatrixVar((2, 1), vtype="C", lb=-10, ub=2)
+    y = m.addMatrixVar((2, 1), vtype="C", lb=-10, ub=5)
+
+    # shape mismatch between MatrixExprCons entries
+    b = m.addMatrixVar((3, 1), vtype="C")
+    with pytest.raises(Exception):
+        m.addMatrixConsDisjunction([x <= 1, b <= 1])
+
+    # require MatrixExprCons or ExprCons in the list
+    with pytest.raises(TypeError):
+        m.addMatrixConsDisjunction([x])
+
+    # MatrixExprCons -> elementwise MatrixConstraint
+    o = m.addMatrixVar((2, 1), vtype="C")
+    m.addMatrixCons(o <= x + y)
+    cons = m.addMatrixConsDisjunction([x <= 1, x <= 0, y <= 0])
+    assert isinstance(cons, MatrixConstraint)
+    assert cons.shape == (2, 1)
+
+    m.setObjective(o.sum(), "maximize")
+    m.optimize()
+    for i in range(2):
+        # each row picks the (x<=1) option: x=1, y=5, o=6
+        assert m.isEQ(m.getVal(o[i, 0]), 6)
+
+    # ExprCons-only fallback returns a scalar Constraint
+    m2 = Model()
+    p = m2.addVar(vtype="C", lb=-10, ub=2)
+    q = m2.addVar(vtype="C", lb=-10, ub=5)
+    o2 = m2.addVar(vtype="C")
+    m2.addCons(o2 <= p + q)
+    m2.addMatrixConsDisjunction([p <= 1, p <= 0, q <= 0])
+    m2.setObjective(o2, "maximize")
+    m2.optimize()
+    assert m2.isEQ(m2.getVal(o2), 6)
+
+
 def test_matrix_compare_with_expr():
     m = Model()
     var = m.addVar(vtype="B", ub=0)