Merge branch 'master' into addmatrixcons

Author: Joao-Dionisio

.github/workflows/coverage.yml

@@ -40,8 +40,9 @@ jobs:
 
       - name: Install PySCIPOpt
         run: |
-          export CFLAGS="-O0 -ggdb" # disable compiler optimizations for faster builds
-          python -m pip install .
+          export CFLAGS="-O0 -ggdb -Wall -Wextra -Werror" # Debug mode. More warnings. Warnings as errors.
+          python -m pip install . -v 2>&1 | tee build.log
+          grep -i "warning" build.log || true
 
       - name: Run pyscipopt tests
         run: |

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## Unreleased
 ### Added
+- Added recipe for getting local constraints
 - More support for AND-Constraints
 - Added support for knapsack constraints
 - Added isPositive(), isNegative(), isFeasLE(), isFeasLT(), isFeasGE(), isFeasGT(), isHugeValue(), and tests
@@ -13,6 +14,7 @@
 - Generalized getLhs() and getRhs() to additionally support any linear type constraint
 ### Fixed
 - Raised an error when an expression is used when a variable is required
+- Fixed some compile warnings
 ### Changed
 - MatrixExpr.sum() now supports axis arguments and can return either a scalar or MatrixExpr depending on the result dimensions
 - AddMatrixCons supports accepting ExprCons following matrix dimension reduction via MatrixExpr.sum() or more operation.

src/pyscipopt/event.pxi

@@ -39,7 +39,7 @@ cdef class Eventhdlr:
 
 
 # local helper functions for the interface
-cdef Eventhdlr getPyEventhdlr(SCIP_EVENTHDLR* eventhdlr) noexcept with gil:
+cdef Eventhdlr getPyEventhdlr(SCIP_EVENTHDLR* eventhdlr):
     cdef SCIP_EVENTHDLRDATA* eventhdlrdata
     eventhdlrdata = SCIPeventhdlrGetData(eventhdlr)
     return <Eventhdlr>eventhdlrdata

src/pyscipopt/expr.pxi

@@ -358,7 +358,7 @@ cdef class ExprCons:
     def __repr__(self):
         return 'ExprCons(%s, %s, %s)' % (self.expr, self._lhs, self._rhs)
 
-    def __nonzero__(self):
+    def __bool__(self):
         '''Make sure that equality of expressions is not asserted with =='''
 
         msg = """Can't evaluate constraints as booleans.

src/pyscipopt/recipes/getLocalConss.py

@@ -0,0 +1,50 @@
+from pyscipopt import Model, Constraint
+
+def getLocalConss(model: Model, node = None) -> list[list[Constraint]]:
+    """
+    Returns local constraints.
+
+    Parameters
+    ----------
+    model : Model
+        The model from which to retrieve the local constraints.
+    node : Node, optional
+        The node from which to retrieve the local constraints. If not provided, the current node is used.
+
+    Returns
+    -------
+    list[Constraint]
+        A list of local constraints. First entry are global constraints, second entry are all the added constraints.
+    """
+
+    if node is None:
+        assert model.getStageName() in ["INITPRESOLVE", "PRESOLVING", "EXITPRESOLVE", "SOLVING"], "Model cannot be called in stage %s." % model.getStageName()
+        cur_node = model.getCurrentNode()
+    else:
+        cur_node = node
+
+    added_conss = []
+    while cur_node is not None:
+        added_conss = cur_node.getAddedConss() + added_conss
+        cur_node = cur_node.getParent()
+    
+    return [model.getConss(), added_conss]
+
+def getNLocalConss(model: Model, node = None) -> tuple[int,int]:
+    """
+    Returns the number of local constraints of a node.
+
+    Parameters
+    ----------
+    model : Model
+        The model from which to retrieve the number of local constraints.
+    node : Node, optional
+        The node from which to retrieve the number of local constraints. If not provided, the current node is used.
+
+    Returns
+    -------
+    list[int]
+        A list of the number of local constraints. First entry is the number of global constraints, second entry is the number of all the added constraints.
+    """
+    local_conss = getLocalConss(model, node)
+    return [len(local_conss[0]), len(local_conss[1])]

src/pyscipopt/recipes/nonlinear.py

@@ -1,6 +1,5 @@
 from pyscipopt import Model
 
-
 def set_nonlinear_objective(model: Model, expr, sense="minimize"):
     """
     Takes a nonlinear expression and performs an epigraph reformulation.

src/pyscipopt/scip.pxd

@@ -408,12 +408,6 @@ cdef extern from "scip/scip.h":
     ctypedef struct SCIP_PROPDATA:
         pass
 
-    ctypedef struct SCIP_PROPTIMING:
-        pass
-
-    ctypedef struct SCIP_PRESOLTIMING:
-        pass
-
     ctypedef struct SCIP_PRESOL:
         pass
 
@@ -456,9 +450,6 @@ cdef extern from "scip/scip.h":
     ctypedef struct SCIP_PRESOL:
         pass
 
-    ctypedef struct SCIP_HEURTIMING:
-        pass
-
     ctypedef struct SCIP_SEPA:
         pass
 
@@ -510,9 +501,6 @@ cdef extern from "scip/scip.h":
     ctypedef struct BMS_BLKMEM:
         pass
 
-    ctypedef struct SCIP_EXPR:
-        pass
-
     ctypedef struct SCIP_EXPRHDLR:
         pass
 
@@ -699,6 +687,7 @@ cdef extern from "scip/scip.h":
     SCIP_RETCODE SCIPwriteOrigProblem(SCIP* scip, char* filename, char* extension, SCIP_Bool genericnames)
     SCIP_RETCODE SCIPwriteTransProblem(SCIP* scip, char* filename, char* extension, SCIP_Bool genericnames)
     SCIP_RETCODE SCIPwriteLP(SCIP* scip, const char*)
+    SCIP_RETCODE SCIPwriteMIP(SCIP * scip, const char * filename, SCIP_Bool genericnames, SCIP_Bool origobj, SCIP_Bool lazyconss)
     SCIP_STATUS SCIPgetStatus(SCIP* scip)
     SCIP_Real SCIPepsilon(SCIP* scip)
     SCIP_Real SCIPfeastol(SCIP* scip)
@@ -707,7 +696,6 @@ cdef extern from "scip/scip.h":
     SCIP_Real SCIPgetLocalTransEstimate(SCIP* scip)
 
     # Solve Methods
-    SCIP_RETCODE SCIPsolve(SCIP* scip)
     SCIP_RETCODE SCIPsolve(SCIP* scip) noexcept nogil
     SCIP_RETCODE SCIPsolveConcurrent(SCIP* scip)
     SCIP_RETCODE SCIPfreeTransform(SCIP* scip)

src/pyscipopt/scip.pxi

@@ -7979,7 +7979,6 @@ cdef class Model:
 
         """
         raise Warning("model.getDualMultiplier(cons) is deprecated: please use model.getDualsolLinear(cons)")
-        return self.getDualsolLinear(cons)
 
     def getDualfarkasLinear(self, Constraint cons):
         """
@@ -9670,6 +9669,29 @@ cdef class Model:
         PY_SCIP_CALL( SCIPwriteLP(self._scip, absfile) )
 
         locale.setlocale(locale.LC_NUMERIC,user_locale)
+    
+    def writeMIP(self, filename, genericnames=False, origobj=False, lazyconss=False):
+        """
+        Writes MIP relaxation of the current branch-and-bound node to a file
+
+        Parameters
+        ----------
+        filename : str
+            name of the output file
+        genericnames : bool, optional
+            should generic names like x_i and row_j be used in order to avoid troubles with reserved symbols? (Default value = False)
+        origobj : bool, optional
+            should the original objective function be used (Default value = False)
+        lazyconss : bool, optional
+            output removable rows as lazy constraints? (Default value = False)
+        """
+        user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+        locale.setlocale(locale.LC_NUMERIC, "C")
+
+        absfile = str_conversion(abspath(filename))
+        PY_SCIP_CALL(SCIPwriteMIP(self._scip, absfile, genericnames, origobj, lazyconss))
+
+        locale.setlocale(locale.LC_NUMERIC,user_locale)
 
     def createSol(self, Heur heur = None, initlp=False):
         """

tests/test_recipe_getLocalConss.py

@@ -0,0 +1,38 @@
+from pyscipopt import Model, SCIP_EVENTTYPE
+from pyscipopt.recipes.getLocalConss import *
+from helpers.utils import random_mip_1
+
+def localconss(model, event):
+    local_conss = getLocalConss(model)
+    assert len(local_conss[1]) == getNLocalConss(model)[1]
+    assert len(local_conss[0]) == len(model.getConss())
+    assert local_conss[0] == model.getConss()
+
+    vars = model.getVars()
+    if model.getCurrentNode().getNumber() == 1:
+        pass
+
+    elif model.getCurrentNode().getNumber() == 2:
+        model.data["local_cons1"] = model.addCons(vars[0] + vars[1] <= 1, name="c1", local=True)
+        assert getNLocalConss(model)[1] == 1
+        assert getLocalConss(model)[1][0] == model.data["local_cons1"]
+
+    elif model.getCurrentNode().getNumber() == 4:
+        local_conss = getLocalConss(model)
+        model.data["local_cons2"] = model.addCons(vars[1] + vars[2] <= 1, name="c2", local=True)
+        model.data["local_cons3"] = model.addCons(vars[2] + vars[3] <= 1, name="c3", local=True)
+        assert getNLocalConss(model)[1] == 3
+        assert getLocalConss(model)[1][0] == model.data["local_cons1"]
+        assert getLocalConss(model)[1][1] == model.data["local_cons2"]
+        assert getLocalConss(model)[1][2] == model.data["local_cons3"]
+
+    elif model.getCurrentNode().getParent().getNumber() not in [2,4]:
+        assert getLocalConss(model) == [model.getConss(), []]
+
+def test_getLocalConss():
+    model = random_mip_1(node_lim=4)
+    model.data = {}
+
+    model.attachEventHandlerCallback(localconss, [SCIP_EVENTTYPE.NODEFOCUSED])
+    model.optimize()
+    assert len(model.data) == 3