Add getNLocksDown, getNLocksUp, getNLocksUpType, getNLocksDownType and tests

Author: Joao-Dionisio

CHANGELOG.md

@@ -4,7 +4,7 @@
 ### Added
 - Added support for knapsack constraints
 - Added isPositive(), isNegative(), isFeasLE(), isFeasLT(), isFeasGE(), isFeasGT(), isHugeValue(), and tests
-- Added SCIP_LOCKTYPE, addVarLocksType
+- Added SCIP_LOCKTYPE, addVarLocksType, getNLocksDown, getNLocksUp, getNLocksUpType, getNLocksDownType, and tests
 ### Fixed
 ### Changed
 ### Removed

src/pyscipopt/__init__.py

@@ -48,6 +48,7 @@
 from pyscipopt.scip      import PY_SCIP_PRESOLTIMING as SCIP_PRESOLTIMING
 from pyscipopt.scip      import PY_SCIP_HEURTIMING   as SCIP_HEURTIMING
 from pyscipopt.scip      import PY_SCIP_EVENTTYPE    as SCIP_EVENTTYPE
+from pyscipopt.scip      import PY_SCIP_LOCKTYPE     as SCIP_LOCKTYPE
 from pyscipopt.scip      import PY_SCIP_LPSOLSTAT    as SCIP_LPSOLSTAT
 from pyscipopt.scip      import PY_SCIP_BRANCHDIR    as SCIP_BRANCHDIR
 from pyscipopt.scip      import PY_SCIP_BENDERSENFOTYPE as SCIP_BENDERSENFOTYPE

src/pyscipopt/scip.pxd

@@ -295,6 +295,10 @@ cdef extern from "scip/scip.h":
         SCIP_EVENTTYPE SCIP_EVENTTYPE_ROWCHANGED
         SCIP_EVENTTYPE SCIP_EVENTTYPE_ROWEVENT
 
+    ctypedef int SCIP_LOCKTYPE
+    cdef extern from "scip/type_var.h":
+        SCIP_LOCKTYPE SCIP_LOCKTYPE_MODEL
+        SCIP_LOCKTYPE SCIP_LOCKTYPE_CONFLICT
 
     ctypedef int SCIP_LPSOLQUALITY
     cdef extern from "lpi/type_lpi.h":
@@ -793,6 +797,10 @@ cdef extern from "scip/scip.h":
     SCIP_RETCODE SCIPgetTransformedVar(SCIP* scip, SCIP_VAR* var, SCIP_VAR** transvar)
     SCIP_RETCODE SCIPaddVarLocks(SCIP* scip, SCIP_VAR* var, int nlocksdown, int nlocksup)
     SCIP_RETCODE SCIPaddVarLocksType(SCIP* scip, SCIP_VAR* var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)
+    int SCIPvarGetNLocksDown(SCIP_VAR* var)
+    int SCIPvarGetNLocksUp(SCIP_VAR* var)
+    int SCIPvarGetNLocksUpType(SCIP_VAR* var, SCIP_LOCKTYPE locktype)
+    int SCIPvarGetNLocksDownType(SCIP_VAR* var, SCIP_LOCKTYPE locktype)
     SCIP_VAR** SCIPgetVars(SCIP* scip)
     SCIP_VAR** SCIPgetOrigVars(SCIP* scip)
     const char* SCIPvarGetName(SCIP_VAR* var)

src/pyscipopt/scip.pxi

@@ -1674,6 +1674,60 @@ cdef class Variable(Expr):
         """
         return SCIPvarGetAvgSol(self.scip_var)
 
+    def getNLocksDown(self):
+        """
+        Returns the number of locks for rounding down.
+
+        Returns
+        -------
+        int
+
+        """
+        return SCIPvarGetNLocksDown(self.scip_var)
+    
+    def getNLocksUp(self):
+        """
+        Returns the number of locks for rounding up.
+
+        Returns
+        -------
+        int
+
+        """
+        return SCIPvarGetNLocksUp(self.scip_var)
+
+    def getNLocksUpType(self, locktype):
+        """
+        Returns the number of locks for rounding up of a certain type.
+
+        Parameters
+        ----------
+        locktype: PY_SCIP_LOCKTYPE
+            types of variable locks
+
+        Returns
+        -------
+        int
+
+        """
+        return SCIPvarGetNLocksUpType(self.scip_var, locktype)
+    
+    def getNLocksDownType(self, locktype):
+        """
+        Returns the number of locks for rounding down of a certain type.
+
+        Parameters
+        ----------
+        locktype: PY_SCIP_LOCKTYPE
+            types of variable locks
+
+        Returns
+        -------
+        int
+
+        """
+        return SCIPvarGetNLocksDownType(self.scip_var, locktype)
+
     def varMayRound(self, direction="down"):
         """
         Checks whether it is possible to round variable up / down and stay feasible for the relaxation.

tests/test_conshdlr.py

@@ -1,4 +1,4 @@
-from pyscipopt import Model, Conshdlr, SCIP_RESULT, SCIP_PRESOLTIMING, SCIP_PROPTIMING
+from pyscipopt import Model, Conshdlr, SCIP_RESULT, SCIP_PRESOLTIMING, SCIP_PROPTIMING, SCIP_LOCKTYPE
 from sys import version_info
 
 if version_info >= (3, 3):
@@ -42,6 +42,7 @@ class MyConshdlr(Conshdlr):
     def __init__(self, shouldtrans, shouldcopy):
         self.shouldtrans = shouldtrans
         self.shouldcopy = shouldcopy
+        self.first_time = True
 
     def createData(self, constraint, nvars, othername):
         print("Creating data for my constraint: %s"%constraint.name)
@@ -68,6 +69,31 @@ def conslock(self, constraint, locktype, nlockspos, nlocksneg):
         calls.add("conslock")
         assert id(constraint) in ids
 
+        if self.first_time:
+            self.first_time = False
+            var = self.model.getVars()[0]
+            n_locks_up = var.getNLocksUp()
+            n_locks_down = var.getNLocksDown()
+            n_locks_up_model = var.getNLocksUpType(SCIP_LOCKTYPE.MODEL)
+            n_locks_up_conflict = var.getNLocksUpType(SCIP_LOCKTYPE.CONFLICT)
+            n_locks_down_model = var.getNLocksDownType(SCIP_LOCKTYPE.MODEL)
+            n_locks_down_conflict = var.getNLocksDownType(SCIP_LOCKTYPE.CONFLICT)
+            assert n_locks_down == 2
+            assert n_locks_up == 2
+            assert n_locks_up_model == 2
+            assert n_locks_up_conflict == 0
+            assert n_locks_down_model == 2
+            assert n_locks_down_conflict == 0
+
+            if locktype == SCIP_LOCKTYPE.MODEL:
+                self.model.addVarLocks(var, nlockspos, nlocksneg)
+                assert var.getNLocksUpType(SCIP_LOCKTYPE.MODEL) != n_locks_up_model or var.getNLocksDownType(SCIP_LOCKTYPE.MODEL) != n_locks_down_model
+            elif locktype == SCIP_LOCKTYPE.CONFLICT:
+                self.model.addVarLocks(var, nlockspos, nlocksneg)
+                assert var.getNLocksUpType(SCIP_LOCKTYPE.CONFLICT) != n_locks_up_conflict or var.getNLocksDownType(SCIP_LOCKTYPE.CONFLICT) != n_locks_down_conflict
+
+            assert var.getNLocksDown() != n_locks_down or var.getNLocksUp() != n_locks_up
+
     ## callbacks ##
     def consfree(self):
         calls.add("consfree")