Merge remote-tracking branch 'upstream/master' into model-annotations-1

Author: jonathanberthias

CHANGELOG.md

@@ -2,9 +2,11 @@
 
 ## Unreleased
 ### Added
+- Added `addConsCumulative()` for SCIP cumulative constraints (#1222)
 - Added type annotations to most methods on the `Model` class
 ### Fixed
 ### Changed
+- Move magic methods (`__radd__`, `__sub__`, `__rsub__`, `__rmul__`, `__richcmp__`, `__neg__`, and `__rtruediv__`) to `ExprLike` base class (#1204)
 - Speed up `Expr.__add__` and `Expr.__iadd__` via the C-level API
 ### Removed
 

src/pyscipopt/expr.pxi

@@ -257,6 +257,27 @@ cdef class ExprLike:
 
         return NotImplemented
 
+    def __radd__(self, other, /):
+        return self + other
+
+    def __sub__(self, other, /):
+        return self + (-other)
+
+    def __rsub__(self, other, /):
+        return (-self) + other
+
+    def __rmul__(self, other, /):
+        return self * other
+
+    def __rtruediv__(self, other, /) -> GenExpr:
+        return buildGenExprObj(other) / self
+
+    def __richcmp__(self, other, int op):
+        return _expr_richcmp(self, other, op)
+
+    def __neg__(self, /) -> Union[Expr, GenExpr]:
+        return self * -1.0
+
     def __abs__(self) -> GenExpr:
         return UnaryExpr(Operator.fabs, buildGenExprObj(self))
 
@@ -358,11 +379,10 @@ cdef class Expr(ExprLike):
             return 1.0 / other * self
         return buildGenExprObj(self) / other
 
-    def __rtruediv__(self, other):
-        ''' other / self '''
+    def __rtruediv__(self, other, /) -> GenExpr:
         if not _is_expr_compatible(other):
             return NotImplemented
-        return buildGenExprObj(other) / self
+        return super().__rtruediv__(other)
 
     def __pow__(self, other, modulo):
         if float(other).is_integer() and other >= 0:
@@ -387,25 +407,6 @@ cdef class Expr(ExprLike):
             raise ValueError("Base of a**x must be positive, as expression is reformulated to scip.exp(x * scip.log(a)); got %g" % base)
         return (self * Constant(base).log()).exp()
 
-    def __neg__(self):
-        return Expr({v:-c for v,c in self.terms.items()})
-
-    def __sub__(self, other):
-        return self + (-other)
-
-    def __radd__(self, other):
-        return self.__add__(other)
-
-    def __rmul__(self, other):
-        return self.__mul__(other)
-
-    def __rsub__(self, other):
-        return -1.0 * self + other
-
-    def __richcmp__(self, other, int op):
-        '''turn it into a constraint'''
-        return _expr_richcmp(self, other, op)
-
     def normalize(self):
         '''remove terms with coefficient of 0'''
         self.terms =  {t:c for (t,c) in self.terms.items() if c != 0.0}
@@ -464,7 +465,6 @@ cdef class ExprCons:
         if not self._rhs is None:
             self._rhs -= c
 
-
     def __richcmp__(self, other, op):
         '''turn it into a constraint'''
         if not _is_number(other):
@@ -690,30 +690,10 @@ cdef class GenExpr(ExprLike):
             raise ZeroDivisionError("cannot divide by 0")
         return self * divisor**(-1)
 
-    def __rtruediv__(self, other):
-        ''' other / self '''
+    def __rtruediv__(self, other, /) -> GenExpr:
         if not _is_genexpr_compatible(other):
             return NotImplemented
-        return buildGenExprObj(other) / self
-
-    def __neg__(self):
-        return -1.0 * self
-
-    def __sub__(self, other):
-        return self + (-other)
-
-    def __radd__(self, other):
-        return self.__add__(other)
-
-    def __rmul__(self, other):
-        return self.__mul__(other)
-
-    def __rsub__(self, other):
-        return -1.0 * self + other
-
-    def __richcmp__(self, other, int op):
-        '''turn it into a constraint'''
-        return _expr_richcmp(self, other, op)
+        return super().__rtruediv__(other)
 
     def degree(self):
         '''Note: none of these expressions should be polynomial'''

src/pyscipopt/scip.pxd

@@ -1636,6 +1636,26 @@ cdef extern from "scip/cons_knapsack.h":
     int SCIPgetNVarsKnapsack(SCIP* scip, SCIP_CONS* cons)
     SCIP_Longint* SCIPgetWeightsKnapsack(SCIP* scip, SCIP_CONS* cons)
 
+cdef extern from "scip/cons_cumulative.h":
+    SCIP_RETCODE SCIPcreateConsCumulative(SCIP* scip,
+                                          SCIP_CONS** cons,
+                                          const char* name,
+                                          int nvars,
+                                          SCIP_VAR** vars,
+                                          int* durations,
+                                          int* demands,
+                                          int capacity,
+                                          SCIP_Bool initial,
+                                          SCIP_Bool separate,
+                                          SCIP_Bool enforce,
+                                          SCIP_Bool check,
+                                          SCIP_Bool propagate,
+                                          SCIP_Bool local,
+                                          SCIP_Bool modifiable,
+                                          SCIP_Bool dynamic,
+                                          SCIP_Bool removable,
+                                          SCIP_Bool stickingatnode)
+
 cdef extern from "scip/cons_nonlinear.h":
     SCIP_EXPR* SCIPgetExprNonlinear(SCIP_CONS* cons)
     SCIP_RETCODE SCIPcreateConsNonlinear(SCIP* scip,

src/pyscipopt/scip.pxi

@@ -2385,6 +2385,19 @@ cdef class Constraint:
         constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(self.scip_cons))).decode('UTF-8')
         return constype == 'knapsack'
 
+    def isCumulative(self):
+        """
+        Returns True if constraint is a cumulative constraint.
+        Cumulative is typically used in scheduling applications.
+
+        Returns
+        -------
+        bool
+
+        """
+        constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(self.scip_cons))).decode('UTF-8')
+        return constype == 'cumulative'
+
     def isLinearType(self):
         """
         Returns True if constraint can be represented as a linear constraint.
@@ -7206,6 +7219,96 @@ cdef class Model:
 
         return pyCons
 
+    def addConsCumulative(self, vars, durations, demands, capacity, name="",
+                initial=True, separate=True, enforce=True, check=True,
+                modifiable=False, propagate=True, local=False, dynamic=False,
+                removable=False, stickingatnode=False):
+        """
+        Add a cumulative constraint.
+
+        A cumulative constraint models resource-constrained scheduling: given jobs
+        with start times, durations, and demands on a shared resource of fixed
+        capacity, it ensures that at every time point t the total demand of all
+        jobs active at t does not exceed the capacity. Job j is active at t if
+        start[j] <= t < start[j] + duration[j].
+
+        The start times are given as integer variables in `vars`. The `durations`,
+        `demands`, and `capacity` arguments must be fixed integers. End times are
+        implicit (start + duration); post separate constraints if explicit end
+        variables are needed.
+
+        If you simply want the jobs to not overlap, set all durations to '1'.
+
+        Parameters
+        ----------
+        vars : list of Variable
+            list of integer variables corresponding to job start times
+        durations : list of int
+            list of durations, one for each job
+        demands : list of int
+            list of demands, one for each job
+        capacity : int
+            available cumulative capacity at any time point
+        name : str, optional
+            name of the constraint (Default value = "")
+        initial : bool, optional
+            should the LP relaxation of constraint be in the initial LP? (Default value = True)
+        separate : bool, optional
+            should the constraint be separated during LP processing? (Default value = True)
+        enforce : bool, optional
+            should the constraint be enforced during node processing? (Default value = True)
+        check : bool, optional
+            should the constraint be checked for feasibility? (Default value = True)
+        propagate : bool, optional
+            should the constraint be propagated during node processing? (Default value = True)
+        local : bool, optional
+            is the constraint only valid locally? (Default value = False)
+        dynamic : bool, optional
+            is the constraint subject to aging? (Default value = False)
+        removable : bool, optional
+            should the relaxation be removed from the LP due to aging or cleanup? (Default value = False)
+        stickingatnode : bool, optional
+            should the constraint always be kept at the node where it was added,
+            even if it may be moved to a more global node? (Default value = False)
+
+        Returns
+        -------
+        Constraint
+            The newly created cumulative constraint
+        """
+
+        cdef int nvars = len(vars)
+        cdef int i
+        cdef int* durations_array = <int*> malloc(nvars * sizeof(int))
+        cdef int* demands_array = <int*> malloc(nvars * sizeof(int))
+        cdef SCIP_CONS* scip_cons
+        cdef _VarArray wrapper
+
+        assert nvars == len(durations) == len(demands), "Number of variables, durations, and demands must be the same."
+
+        if name == '':
+            name = 'c'+str(SCIPgetNConss(self._scip)+1)
+
+        wrapper = _VarArray(vars)
+        for i in range(nvars):
+            durations_array[i] = <int>durations[i]
+            demands_array[i] = <int>demands[i]
+
+        PY_SCIP_CALL(SCIPcreateConsCumulative(
+            self._scip, &scip_cons, str_conversion(name), nvars, wrapper.ptr, durations_array,
+            demands_array, capacity, initial, separate, enforce, check, propagate, local, modifiable,
+            dynamic, removable, stickingatnode))
+
+        free(durations_array)
+        free(demands_array)
+
+        PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons))
+
+        pyCons = self._getOrCreateCons(scip_cons)
+        PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons))
+
+        return pyCons
+
     def addConsSOS1(self, vars, weights=None, name="",
                 initial=True, separate=True, enforce=True, check=True,
                 propagate=True, local=False, dynamic=False,

src/pyscipopt/scip.pyi

@@ -245,6 +245,7 @@ class Constraint:
     def getConshdlrName(self) -> Incomplete: ...
     def isActive(self) -> Incomplete: ...
     def isChecked(self) -> Incomplete: ...
+    def isCumulative(self) -> Incomplete: ...
     def isDynamic(self) -> Incomplete: ...
     def isEnforced(self) -> Incomplete: ...
     def isInitial(self) -> Incomplete: ...
@@ -333,6 +334,12 @@ class ExprLike:
         *args: Incomplete,
         **kwargs: Incomplete,
     ) -> Incomplete: ...
+    def __radd__(self, other: object, /) -> Incomplete: ...
+    def __sub__(self, other: object, /) -> Incomplete: ...
+    def __rsub__(self, other: object, /) -> Incomplete: ...
+    def __rmul__(self, other: object, /) -> Incomplete: ...
+    def __rtruediv__(self, other: object, /) -> GenExpr: ...
+    def __neg__(self, /) -> Union[Expr, GenExpr]: ...
     def __abs__(self) -> GenExpr: ...
     def exp(self) -> GenExpr: ...
     def log(self) -> GenExpr: ...
@@ -346,7 +353,6 @@ class Expr(ExprLike):
     def __init__(self, terms: Incomplete = ...) -> None: ...
     def degree(self) -> Incomplete: ...
     def normalize(self) -> Incomplete: ...
-    def __abs__(self) -> GenExpr: ...
     def __add__(self, other: Incomplete, /) -> Incomplete: ...
     def __eq__(self, other: object, /) -> bool: ...
     def __ge__(self, other: object, /) -> bool: ...
@@ -358,14 +364,8 @@ class Expr(ExprLike):
     def __lt__(self, other: object, /) -> bool: ...
     def __mul__(self, other: Incomplete, /) -> Incomplete: ...
     def __ne__(self, other: object, /) -> bool: ...
-    def __neg__(self) -> Incomplete: ...
     def __pow__(self, other: Incomplete, modulo: Incomplete = ..., /) -> Incomplete: ...
-    def __radd__(self, other: Incomplete, /) -> Incomplete: ...
-    def __rmul__(self, other: Incomplete, /) -> Incomplete: ...
     def __rpow__(self, other: Incomplete, /) -> Incomplete: ...
-    def __rsub__(self, other: Incomplete, /) -> Incomplete: ...
-    def __rtruediv__(self, other: Incomplete, /) -> Incomplete: ...
-    def __sub__(self, other: Incomplete, /) -> Incomplete: ...
     def __truediv__(self, other: Incomplete, /) -> Incomplete: ...
 
 @disjoint_base
@@ -392,7 +392,6 @@ class GenExpr(ExprLike):
     def __init__(self) -> None: ...
     def degree(self) -> Incomplete: ...
     def getOp(self) -> Incomplete: ...
-    def __abs__(self) -> GenExpr: ...
     def __add__(self, other: Incomplete, /) -> Incomplete: ...
     def __eq__(self, other: object, /) -> bool: ...
     def __ge__(self, other: object, /) -> bool: ...
@@ -401,14 +400,8 @@ class GenExpr(ExprLike):
     def __lt__(self, other: object, /) -> bool: ...
     def __mul__(self, other: Incomplete, /) -> Incomplete: ...
     def __ne__(self, other: object, /) -> bool: ...
-    def __neg__(self) -> Incomplete: ...
     def __pow__(self, other: Incomplete, modulo: Incomplete = ..., /) -> Incomplete: ...
-    def __radd__(self, other: Incomplete, /) -> Incomplete: ...
-    def __rmul__(self, other: Incomplete, /) -> Incomplete: ...
     def __rpow__(self, other: Incomplete, /) -> Incomplete: ...
-    def __rsub__(self, other: Incomplete, /) -> Incomplete: ...
-    def __rtruediv__(self, other: Incomplete, /) -> Incomplete: ...
-    def __sub__(self, other: Incomplete, /) -> Incomplete: ...
     def __truediv__(self, other: Incomplete, /) -> Incomplete: ...
 
 @disjoint_base
@@ -643,6 +636,24 @@ class Model:
         stickingatnode: bool = False,
     ) -> Constraint: ...
     def addConsCoeff(self, cons: Constraint, var: Variable, coeff: float) -> None: ...
+    def addConsCumulative(
+        self,
+        vars: Sequence[Variable],
+        durations: Sequence[int],
+        demands: Sequence[int],
+        capacity: int,
+        name: str = "",
+        initial: bool = True,
+        separate: bool = True,
+        enforce: bool = True,
+        check: bool = True,
+        modifiable: bool = False,
+        propagate: bool = True,
+        local: bool = False,
+        dynamic: bool = False,
+        removable: bool = False,
+        stickingatnode: bool = False,
+    ) -> Constraint: ...
     def addConsDisjunction(
         self,
         conss: Iterable[Incomplete],

tests/test_cons.py

@@ -351,6 +351,39 @@ def test_cons_knapsack():
     assert m.getDualsolKnapsack(knapsack_cons) == 0
     assert m.getDualfarkasKnapsack(knapsack_cons) == 0
 
+def test_cons_cumulative():
+    """Three jobs on a resource with capacity 3 must not overlap in demand.
+
+    Job 1: duration 3, demand 2
+    Job 2: duration 2, demand 3
+    Job 3: duration 2, demand 1
+
+    Jobs 2 and 3 cannot run together (demand 3+1 > 3). Minimizing the sum of
+    start times yields start1=0, start2=3, start3=0.
+    """
+    m = Model()
+    start1 = m.addVar("start1", vtype="I", lb=0, ub=10, obj=1)
+    start2 = m.addVar("start2", vtype="I", lb=0, ub=10, obj=1)
+    start3 = m.addVar("start3", vtype="I", lb=0, ub=10, obj=1)
+    durations = [3, 2, 2]
+    demands = [2, 3, 1]
+    capacity = 3
+
+    cumulative_cons = m.addConsCumulative([start1, start2, start3], durations, demands, capacity)
+    assert cumulative_cons.getConshdlrName() == "cumulative"
+    assert cumulative_cons.isCumulative()
+
+    assert m.getConsNVars(cumulative_cons) == 3
+    assert m.getConsVars(cumulative_cons) == [start1, start2, start3]
+
+    m.setObjective(start1 + start2 + start3, "minimize")
+    m.optimize()
+
+    assert m.isEQ(m.getVal(start1), 0)
+    assert m.isEQ(m.getVal(start2), 3)
+    assert m.isEQ(m.getVal(start3), 0)
+    assert m.isEQ(m.getObjVal(), 3)
+
 def test_getValsLinear():
     m = Model()
     x = m.addVar("x", lb=0, ub=2, obj=-1)