initial support for conjunction constraints

Author: ctdunc

src/pyscipopt/scip.pxd

@@ -1512,6 +1512,22 @@ cdef extern from "scip/cons_disjunction.h":
                                             SCIP_CONS *cons,
                                             SCIP_CONS *addcons)
 
+cdef extern from "scip/cons_conjunction.h":
+    SCIP_RETCODE SCIPcreateConsConjunction(SCIP *scip,
+                                            SCIP_CONS **cons,
+                                            const char *name,
+                                            int nconss,
+                                            SCIP_CONS **conss,
+                                            SCIP_Bool enforce,
+                                            SCIP_Bool check,
+                                            SCIP_Bool local,
+                                            SCIP_Bool modifiable,
+                                            SCIP_Bool dynamic)
+
+    SCIP_RETCODE SCIPaddConsElemConjunction(SCIP *scip,
+                                            SCIP_CONS *cons,
+                                            SCIP_CONS *addcons)
+     
 cdef extern from "scip/cons_and.h":
     SCIP_RETCODE SCIPcreateConsAnd(SCIP* scip,
                                          SCIP_CONS** cons,

src/pyscipopt/scip.pxi

@@ -2489,6 +2489,118 @@ cdef class Model:
 
         return constraints
 
+    def addConsConjunction(self, conss, name = '', 
+        relaxcons = None, enforce=True, check =True, 
+        local=False, modifiable = False, dynamic = False):
+        """Add a conjunction constraint.
+
+        :param Iterable[Constraint] conss: An iterable of constraint objects to be included initially in the conjunction. Currently, these must be expressions.
+        :param name: the name of the conjunction constraint.
+        :param relaxcons: a conjunction constraint containing the linear relaxation of the conjunction constraint, or None. (Default value = None)
+        :param enforce: should the constraint be enforced during node processing? (Default value = True)
+        :param check: should the constraint be checked for feasibility? (Default value = True)
+        :param local: is the constraint only valid locally? (Default value = False)
+        :param modifiable: is the constraint modifiable (subject to column generation)? (Default value = False)
+        :param dynamic: is the constraint subject to aging? (Default value = False)
+        :return The added @ref scip#Constraint "Constraint" object.
+        """
+        def ensure_iterable(elem, length):
+            if isinstance(elem, Iterable):
+                return elem
+            else:
+                return list(repeat(elem, length))
+        assert isinstance(conss, Iterable), "Given constraint list is not iterable"
+
+        conss = list(conss)
+        n_conss = len(conss)
+
+        cdef SCIP_CONS* conj_cons
+
+        cdef SCIP_CONS* scip_cons
+
+        cdef SCIP_EXPR* scip_expr
+
+        PY_SCIP_CALL(SCIPcreateConsConjunction(
+            self._scip, &conj_cons, str_conversion(name), 0, &scip_cons,
+            enforce, check, local, modifiable, dynamic
+        ))
+
+
+        # TODO add constraints to disjunction
+        for i, cons in enumerate(conss):
+            pycons = self.createExprCons(cons, name=name, initial = True, # TODO is there ever a case these shouldn't be default?
+                                            enforce=enforce, check=check,
+                                            local=local, modifiable=modifiable, dynamic=dynamic
+                                            )
+            PY_SCIP_CALL(SCIPaddConsElemConjunction(self._scip,conj_cons, (<Constraint>pycons).scip_cons))
+            PY_SCIP_CALL(SCIPreleaseCons(self._scip, &(<Constraint>pycons).scip_cons))
+        PY_SCIP_CALL(SCIPaddCons(self._scip, conj_cons))
+        PyCons = Constraint.create(conj_cons)
+        PY_SCIP_CALL(SCIPreleaseCons(self._scip, &conj_cons))
+        return PyCons
+
+    def addConsElemConjunction(self, Constraint conj_cons, Constraint cons):
+        """Appends a constraint to a conjunction.
+        
+        :param Constraint conj_cons: the conjunction constraint to append to.
+        :param Constraint cons: the Constraint to append
+        :return The disjunction constraint with added @ref scip#Constraint object.
+        """
+        assert conj_cons.getConshdlrName() == "conjunction", "conj_cons is not conjunction but %s" % conj_cons.getConshdlrName()
+
+        PY_SCIP_CALL(SCIPaddConsElemConjunction(self._scip, (<Constraint>conj_cons).scip_cons, (<Constraint>cons).scip_cons))
+        PY_SCIP_CALL(SCIPreleaseCons(self._scip, &((<Constraint>cons).scip_cons)))
+        return conj_cons
+
+    def createConsConjunction(self, conss, name = '', 
+        relaxcons = None, enforce=True, check =True, 
+        local=False, modifiable = False, dynamic = False):
+        """Create a conjunction constraint without adding it to the problem.
+
+        :param Iterable[Constraint] conss: An iterable of constraint objects to be included initially in the conjunction. Currently, these must be expressions.
+        :param name: the name of the conjunction constraint.
+        :param relaxcons: a conjunction constraint containing the linear relaxation of the conjunction constraint, or None. (Default value = None)
+        :param enforce: should the constraint be enforced during node processing? (Default value = True)
+        :param check: should the constraint be checked for feasibility? (Default value = True)
+        :param local: is the constraint only valid locally? (Default value = False)
+        :param modifiable: is the constraint modifiable (subject to column generation)? (Default value = False)
+        :param dynamic: is the constraint subject to aging? (Default value = False)
+        :return The added @ref scip#Constraint "Constraint" object.
+        """
+        def ensure_iterable(elem, length):
+            if isinstance(elem, Iterable):
+                return elem
+            else:
+                return list(repeat(elem, length))
+        assert isinstance(conss, Iterable), "Given constraint list is not iterable"
+
+        conss = list(conss)
+        n_conss = len(conss)
+
+        cdef SCIP_CONS* conj_cons
+
+        cdef SCIP_CONS* scip_cons
+
+        cdef SCIP_EXPR* scip_expr
+
+        PY_SCIP_CALL(SCIPcreateConsConjunction(
+            self._scip, &conj_cons, str_conversion(name), 0, &scip_cons,
+            enforce, check, local, modifiable, dynamic
+        ))
+
+
+        # TODO add constraints to conujunction
+        for i, cons in enumerate(conss):
+            pycons = self.createExprCons(cons, name=name, initial = True, # TODO is there ever a case these shouldn't be default?
+                                            enforce=enforce, check=check,
+                                            local=local, modifiable=modifiable, dynamic=dynamic
+                                            )
+            PY_SCIP_CALL(SCIPaddConsElemConjunction(self._scip,conj_cons, (<Constraint>pycons).scip_cons))
+            PY_SCIP_CALL(SCIPreleaseCons(self._scip, &(<Constraint>pycons).scip_cons))
+
+        PyCons = Constraint.create(conj_cons)
+        return PyCons
+    
     def addConsDisjunction(self, conss, name = '', initial = True, 
         relaxcons = None, enforce=True, check =True, 
         local=False, modifiable = False, dynamic = False):
@@ -2533,22 +2645,72 @@ cdef class Model:
                                             enforce=enforce, check=check,
                                             local=local, modifiable=modifiable, dynamic=dynamic
                                             )
-            PY_SCIP_CALL(SCIPaddConsElemDisjunction(self._scip,disj_cons, (<Constraint>pycons).scip_cons))
+            PY_SCIP_CALL(SCIPaddConsElemDisjunction(self._scip, disj_cons, (<Constraint>pycons).scip_cons))
             PY_SCIP_CALL(SCIPreleaseCons(self._scip, &(<Constraint>pycons).scip_cons))
         PY_SCIP_CALL(SCIPaddCons(self._scip, disj_cons))
         PyCons = Constraint.create(disj_cons)
         PY_SCIP_CALL(SCIPreleaseCons(self._scip, &disj_cons))
         return PyCons
+    
+    def createConsDisjunction(self, conss, name = '', initial = True, 
+        relaxcons = None, enforce=True, check =True, 
+        local=False, modifiable = False, dynamic = False):
+        """Add a disjunction constraint.
+
+        :param Iterable[Constraint] conss: An iterable of constraint objects to be included initially in the disjunction. Currently, these must be expressions.
+        :param name: the name of the disjunction constraint.
+        :param initial: should the LP relaxation of disjunction constraint be in the initial LP? (Default value = True)
+        :param relaxcons: a conjunction constraint containing the linear relaxation of the disjunction constraint, or None. (Default value = None)
+        :param enforce: should the constraint be enforced during node processing? (Default value = True)
+        :param check: should the constraint be checked for feasibility? (Default value = True)
+        :param local: is the constraint only valid locally? (Default value = False)
+        :param modifiable: is the constraint modifiable (subject to column generation)? (Default value = False)
+        :param dynamic: is the constraint subject to aging? (Default value = False)
+        :return The added @ref scip#Constraint "Constraint" object.
+        """
+        def ensure_iterable(elem, length):
+            if isinstance(elem, Iterable):
+                return elem
+            else:
+                return list(repeat(elem, length))
+        assert isinstance(conss, Iterable), "Given constraint list is not iterable"
+
+        conss = list(conss)
+        n_conss = len(conss)
+
+        cdef SCIP_CONS* disj_cons
+
+        cdef SCIP_CONS* scip_cons
+
+        cdef SCIP_EXPR* scip_expr
+
+        PY_SCIP_CALL(SCIPcreateConsDisjunction(
+            self._scip, &disj_cons, str_conversion(name), 0, &scip_cons, NULL, 
+            initial, enforce, check, local, modifiable, dynamic
+        ))
+
 
+        # TODO add constraints to disjunction
+        for i, cons in enumerate(conss):
+            pycons = self.createExprCons(cons, name=name, initial = initial,
+                                            enforce=enforce, check=check,
+                                            local=local, modifiable=modifiable, dynamic=dynamic
+                                            )
+            PY_SCIP_CALL(SCIPaddConsElemDisjunction(self._scip, disj_cons, (<Constraint>pycons).scip_cons))
+            PY_SCIP_CALL(SCIPreleaseCons(self._scip, &(<Constraint>pycons).scip_cons))
+        PyCons = Constraint.create(disj_cons)
+        return PyCons
     def addConsElemDisjunction(self, Constraint disj_cons, Constraint cons):
-        PY_SCIP_CALL(SCIPaddConsElemDisjunction(self._scip, (<Constraint>disj_cons).scip_cons, (<Constraint>cons).scip_cons))
-        PY_SCIP_CALL(SCIPreleaseCons(self._scip, &((<Constraint>cons).scip_cons)))
         """Appends a constraint to a disjunction.
-        
+
         :param Constraint disj_cons: the disjunction constraint to append to.
         :param Constraint cons: the Constraint to append
         :return The disjunction constraint with added @ref scip#Constraint object.
         """
+        assert disj_cons.getConshdlrName() == "disjunction", "disj_cons is not disjunction but %s" % disj_cons.getConshdlrName()
+        PY_SCIP_CALL(SCIPaddConsElemDisjunction(self._scip, (<Constraint>disj_cons).scip_cons, (<Constraint>cons).scip_cons))
+        PY_SCIP_CALL(SCIPreleaseCons(self._scip, &((<Constraint>cons).scip_cons)))
+
         return disj_cons
 
 

tests/test_cons.py

@@ -192,6 +192,26 @@ def test_addConsDisjunction_expr_init():
     assert m.isEQ(m.getVal(o), 6)
 
 
+def test_addConsElemConjunction():
+    m = Model()
+    x = m.addVar(vtype="c", lb=-10, ub=2)
+    y = m.addVar(vtype="c", lb=-10, ub=5)
+    o = m.addVar(vtype="c")
+
+    m.addCons(o <= (x + y))
+    conj_cons = m.addConsConjunction([])
+    print(conj_cons.getConshdlrName())
+    c1 = m.createExprCons(x <= 1)
+    c3 = m.createExprCons(y <= 0)
+    m.addConsElemConjunction(conj_cons, c1)
+    m.addConsElemConjunction(conj_cons, c3)
+    m.setObjective(o, "maximize")
+    m.optimize()
+    assert m.isEQ(m.getVal(x), 1)
+    assert m.isEQ(m.getVal(y), 0)
+    assert m.isEQ(m.getVal(o), 1)
+
+
 @pytest.mark.skip(reason="TODO: test getValsLinear()")
 def test_getValsLinear():
     assert True
@@ -200,3 +220,7 @@ def test_getValsLinear():
 @pytest.mark.skip(reason="TODO: test getRowLinear()")
 def test_getRowLinear():
     assert True
+
+
+if __name__ == "__main__":
+    test_addConsElemConjunction()