Merge pull request #743 from Joao-Dionisio/getPrimalRay

Add hasPrimalRay, getPrimalRay, getPrimalRayVal

CHANGELOG.md

@@ -6,7 +6,9 @@
 - Add SCIP functions SCIPchgCoefLinear, SCIPaddCoefLinear and SCIPdelCoefLinear
 - Add SCIP function SCIPgetSolTime and wrapper getSolTime
 - Add convenience methods relax and getVarDict
+- Add SCIP functions hasPrimalRay, getPrimalRay, getPrimalRayVal
 ### Fixed
+- Fixed typo in documentation of chgRhs
 - Pricer plugin fundamental callbacks now raise an error if not implemented
 - Brachrule plugin fundamental callbacks now raise an error if not implemented
 - Fixed segmentation fault when accessing the Solution class directly

src/pyscipopt/scip.pxd

@@ -806,6 +806,8 @@ cdef extern from "scip/scip.h":
     SCIP_Real SCIPgetPrimalbound(SCIP* scip)
     SCIP_Real SCIPgetGap(SCIP* scip)
     int SCIPgetDepth(SCIP* scip)
+    SCIP_Bool SCIPhasPrimalRay(SCIP * scip)
+    SCIP_Real SCIPgetPrimalRayVal(SCIP * scip, SCIP_VAR * var)
     SCIP_RETCODE SCIPaddSolFree(SCIP* scip, SCIP_SOL** sol, SCIP_Bool* stored)
     SCIP_RETCODE SCIPaddSol(SCIP* scip, SCIP_SOL* sol, SCIP_Bool* stored)
     SCIP_RETCODE SCIPreadSol(SCIP* scip, const char* filename)

src/pyscipopt/scip.pxi

@@ -2883,7 +2883,7 @@ cdef class Model:
         """Change right hand side value of a constraint.
 
         :param Constraint cons: linear or quadratic constraint
-        :param rhs: new ride hand side (set to None for +infinity)
+        :param rhs: new right hand side (set to None for +infinity)
 
         """
 
@@ -4621,6 +4621,35 @@ cdef class Model:
         if not self.getStage() >= SCIP_STAGE_SOLVING:
             raise Warning("method cannot be called before problem is solved")
         return self.getSolVal(self._bestSol, expr)
+
+    def hasPrimalRay(self):
+        """
+        Returns whether a primal ray is stored that proves unboundedness of the LP relaxation
+        """
+        return SCIPhasPrimalRay(self._scip)
+
+    def getPrimalRayVal(self, Variable var):
+        """
+        Gets value of given variable in primal ray causing unboundedness of the LP relaxation
+        """
+        assert SCIPhasPrimalRay(self._scip), "The problem does not have a primal ray."
+
+        return SCIPgetPrimalRayVal(self._scip, var.scip_var)
+
+    def getPrimalRay(self):
+        """
+        Gets primal ray causing unboundedness of the LP relaxation
+        """
+        assert SCIPhasPrimalRay(self._scip), "The problem does not have a primal ray."
+
+        cdef int _nvars = SCIPgetNVars(self._scip)
+        cdef SCIP_VAR ** _vars = SCIPgetVars(self._scip)
+
+        ray = []
+        for i in range(_nvars):
+            ray.append(float(SCIPgetPrimalRayVal(self._scip, _vars[i])))
+
+        return ray
 
     def getPrimalbound(self):
         """Retrieve the best primal bound."""

tests/test_solution.py

@@ -1,4 +1,4 @@
-from pyscipopt import Model, scip
+from pyscipopt import Model, scip, SCIP_PARAMSETTING
 import pytest
 
 def test_solution_getbest():
@@ -62,6 +62,47 @@ def test_solution_evaluation():
     assert sol[expr] == m.getVal(expr)
     assert sol[expr2] == m.getVal(expr2)
 
+def test_hasPrimalRay():
+    m = Model()
+    x = m.addVar()
+    m.setObjective(x, "maximize")
+    m.setPresolve(SCIP_PARAMSETTING.OFF)
+
+    m.optimize()
+
+    assert m.hasPrimalRay()
+
+    m = Model()
+    x = m.addVar(lb = 0) # for readability
+    m.setPresolve(SCIP_PARAMSETTING.OFF)
+
+    m.optimize()
+
+    assert not m.hasPrimalRay()
+
+def test_getPrimalRayVal():
+    m = Model()
+    x = m.addVar()
+    m.setObjective(x, "maximize")
+    m.setPresolve(SCIP_PARAMSETTING.OFF)
+
+    m.hideOutput()
+    m.optimize()
+
+    assert m.getPrimalRayVal(x) == 1
+
+def test_getPrimalRay():
+    m = Model()
+    x = m.addVar()
+    y = m.addVar()
+    m.setObjective(x, "maximize")
+    m.setPresolve(SCIP_PARAMSETTING.OFF)
+
+    m.hideOutput()
+    m.optimize()
+
+    assert m.getPrimalRay() == [1,0]
+
 
 def test_create_solution():
     with pytest.raises(ValueError):
@@ -86,5 +127,4 @@ def test_getSols():
     assert any(sol[x] == 0.0 for sol in m.getSols())
 
 if __name__ == "__main__":
-    test_solution_getbest()
-    test_solution_create()
+    test_getPrimalRayVal()