PySCIPOpt 5.7.1__cp310-cp310-win_amd64.whl → 6.1.0__cp310-cp310-win_amd64.whl

pyscipopt/scip.pxi

@@ -31,6 +31,7 @@ include "conshdlr.pxi"
 include "cutsel.pxi"
 include "event.pxi"
 include "heuristic.pxi"
+include "iisfinder.pxi"
 include "presol.pxi"
 include "pricer.pxi"
 include "propagator.pxi"
@@ -41,9 +42,9 @@ include "nodesel.pxi"
 include "matrix.pxi"
 
 # recommended SCIP version; major version is required
-MAJOR = 9
-MINOR = 2
-PATCH = 4
+MAJOR = 10
+MINOR = 0
+PATCH = 0
 
 # for external user functions use def; for functions used only inside the interface (starting with _) use cdef
 # todo: check whether this is currently done like this
@@ -207,65 +208,72 @@ cdef class PY_SCIP_HEURTIMING:
 
 EventNames = {}
 cdef class PY_SCIP_EVENTTYPE:
-    DISABLED        = SCIP_EVENTTYPE_DISABLED
-    VARADDED        = SCIP_EVENTTYPE_VARADDED
-    VARDELETED      = SCIP_EVENTTYPE_VARDELETED
-    VARFIXED        = SCIP_EVENTTYPE_VARFIXED
-    VARUNLOCKED     = SCIP_EVENTTYPE_VARUNLOCKED
-    OBJCHANGED      = SCIP_EVENTTYPE_OBJCHANGED
-    GLBCHANGED      = SCIP_EVENTTYPE_GLBCHANGED
-    GUBCHANGED      = SCIP_EVENTTYPE_GUBCHANGED
-    LBTIGHTENED     = SCIP_EVENTTYPE_LBTIGHTENED
-    LBRELAXED       = SCIP_EVENTTYPE_LBRELAXED
-    UBTIGHTENED     = SCIP_EVENTTYPE_UBTIGHTENED
-    UBRELAXED       = SCIP_EVENTTYPE_UBRELAXED
-    GHOLEADDED      = SCIP_EVENTTYPE_GHOLEADDED
-    GHOLEREMOVED    = SCIP_EVENTTYPE_GHOLEREMOVED
-    LHOLEADDED      = SCIP_EVENTTYPE_LHOLEADDED
-    LHOLEREMOVED    = SCIP_EVENTTYPE_LHOLEREMOVED
-    IMPLADDED       = SCIP_EVENTTYPE_IMPLADDED
-    PRESOLVEROUND   = SCIP_EVENTTYPE_PRESOLVEROUND
-    NODEFOCUSED     = SCIP_EVENTTYPE_NODEFOCUSED
-    NODEFEASIBLE    = SCIP_EVENTTYPE_NODEFEASIBLE
-    NODEINFEASIBLE  = SCIP_EVENTTYPE_NODEINFEASIBLE
-    NODEBRANCHED    = SCIP_EVENTTYPE_NODEBRANCHED
-    NODEDELETE      = SCIP_EVENTTYPE_NODEDELETE
-    FIRSTLPSOLVED   = SCIP_EVENTTYPE_FIRSTLPSOLVED
-    LPSOLVED        = SCIP_EVENTTYPE_LPSOLVED
-    LPEVENT         = SCIP_EVENTTYPE_LPEVENT
-    POORSOLFOUND    = SCIP_EVENTTYPE_POORSOLFOUND
-    BESTSOLFOUND    = SCIP_EVENTTYPE_BESTSOLFOUND
-    ROWADDEDSEPA    = SCIP_EVENTTYPE_ROWADDEDSEPA
-    ROWDELETEDSEPA  = SCIP_EVENTTYPE_ROWDELETEDSEPA
-    ROWADDEDLP      = SCIP_EVENTTYPE_ROWADDEDLP
-    ROWDELETEDLP    = SCIP_EVENTTYPE_ROWDELETEDLP
-    ROWCOEFCHANGED  = SCIP_EVENTTYPE_ROWCOEFCHANGED
-    ROWCONSTCHANGED = SCIP_EVENTTYPE_ROWCONSTCHANGED
-    ROWSIDECHANGED  = SCIP_EVENTTYPE_ROWSIDECHANGED
-    SYNC            = SCIP_EVENTTYPE_SYNC
-    GBDCHANGED      = SCIP_EVENTTYPE_GBDCHANGED
-    LBCHANGED       = SCIP_EVENTTYPE_LBCHANGED
-    UBCHANGED       = SCIP_EVENTTYPE_UBCHANGED
-    BOUNDTIGHTENED  = SCIP_EVENTTYPE_BOUNDTIGHTENED
-    BOUNDRELAXED    = SCIP_EVENTTYPE_BOUNDRELAXED
-    BOUNDCHANGED    = SCIP_EVENTTYPE_BOUNDCHANGED
-    GHOLECHANGED    = SCIP_EVENTTYPE_GHOLECHANGED
-    LHOLECHANGED    = SCIP_EVENTTYPE_LHOLECHANGED
-    HOLECHANGED     = SCIP_EVENTTYPE_HOLECHANGED
-    DOMCHANGED      = SCIP_EVENTTYPE_DOMCHANGED
-    VARCHANGED      = SCIP_EVENTTYPE_VARCHANGED
-    VAREVENT        = SCIP_EVENTTYPE_VAREVENT
-    NODESOLVED      = SCIP_EVENTTYPE_NODESOLVED
-    NODEEVENT       = SCIP_EVENTTYPE_NODEEVENT
-    SOLFOUND        = SCIP_EVENTTYPE_SOLFOUND
-    SOLEVENT        = SCIP_EVENTTYPE_SOLEVENT
-    ROWCHANGED      = SCIP_EVENTTYPE_ROWCHANGED
-    ROWEVENT        = SCIP_EVENTTYPE_ROWEVENT
+    DISABLED          = SCIP_EVENTTYPE_DISABLED
+    VARADDED          = SCIP_EVENTTYPE_VARADDED
+    VARDELETED        = SCIP_EVENTTYPE_VARDELETED
+    VARFIXED          = SCIP_EVENTTYPE_VARFIXED
+    VARUNLOCKED       = SCIP_EVENTTYPE_VARUNLOCKED
+    OBJCHANGED        = SCIP_EVENTTYPE_OBJCHANGED
+    GLBCHANGED        = SCIP_EVENTTYPE_GLBCHANGED
+    GUBCHANGED        = SCIP_EVENTTYPE_GUBCHANGED
+    LBTIGHTENED       = SCIP_EVENTTYPE_LBTIGHTENED
+    LBRELAXED         = SCIP_EVENTTYPE_LBRELAXED
+    UBTIGHTENED       = SCIP_EVENTTYPE_UBTIGHTENED
+    UBRELAXED         = SCIP_EVENTTYPE_UBRELAXED
+    GHOLEADDED        = SCIP_EVENTTYPE_GHOLEADDED
+    GHOLEREMOVED      = SCIP_EVENTTYPE_GHOLEREMOVED
+    LHOLEADDED        = SCIP_EVENTTYPE_LHOLEADDED
+    LHOLEREMOVED      = SCIP_EVENTTYPE_LHOLEREMOVED
+    IMPLADDED         = SCIP_EVENTTYPE_IMPLADDED
+    PRESOLVEROUND     = SCIP_EVENTTYPE_PRESOLVEROUND
+    NODEFOCUSED       = SCIP_EVENTTYPE_NODEFOCUSED
+    NODEFEASIBLE      = SCIP_EVENTTYPE_NODEFEASIBLE
+    NODEINFEASIBLE    = SCIP_EVENTTYPE_NODEINFEASIBLE
+    NODEBRANCHED      = SCIP_EVENTTYPE_NODEBRANCHED
+    NODEDELETE        = SCIP_EVENTTYPE_NODEDELETE
+    DUALBOUNDIMPROVED = SCIP_EVENTTYPE_DUALBOUNDIMPROVED
+    FIRSTLPSOLVED     = SCIP_EVENTTYPE_FIRSTLPSOLVED
+    LPSOLVED          = SCIP_EVENTTYPE_LPSOLVED
+    LPEVENT           = SCIP_EVENTTYPE_LPEVENT
+    POORSOLFOUND      = SCIP_EVENTTYPE_POORSOLFOUND
+    BESTSOLFOUND      = SCIP_EVENTTYPE_BESTSOLFOUND
+    ROWADDEDSEPA      = SCIP_EVENTTYPE_ROWADDEDSEPA
+    ROWDELETEDSEPA    = SCIP_EVENTTYPE_ROWDELETEDSEPA
+    ROWADDEDLP        = SCIP_EVENTTYPE_ROWADDEDLP
+    ROWDELETEDLP      = SCIP_EVENTTYPE_ROWDELETEDLP
+    ROWCOEFCHANGED    = SCIP_EVENTTYPE_ROWCOEFCHANGED
+    ROWCONSTCHANGED   = SCIP_EVENTTYPE_ROWCONSTCHANGED
+    ROWSIDECHANGED    = SCIP_EVENTTYPE_ROWSIDECHANGED
+    SYNC              = SCIP_EVENTTYPE_SYNC
+    GBDCHANGED        = SCIP_EVENTTYPE_GBDCHANGED
+    LBCHANGED         = SCIP_EVENTTYPE_LBCHANGED
+    UBCHANGED         = SCIP_EVENTTYPE_UBCHANGED
+    BOUNDTIGHTENED    = SCIP_EVENTTYPE_BOUNDTIGHTENED
+    BOUNDRELAXED      = SCIP_EVENTTYPE_BOUNDRELAXED
+    BOUNDCHANGED      = SCIP_EVENTTYPE_BOUNDCHANGED
+    GHOLECHANGED      = SCIP_EVENTTYPE_GHOLECHANGED
+    LHOLECHANGED      = SCIP_EVENTTYPE_LHOLECHANGED
+    HOLECHANGED       = SCIP_EVENTTYPE_HOLECHANGED
+    DOMCHANGED        = SCIP_EVENTTYPE_DOMCHANGED
+    VARCHANGED        = SCIP_EVENTTYPE_VARCHANGED
+    VAREVENT          = SCIP_EVENTTYPE_VAREVENT
+    NODESOLVED        = SCIP_EVENTTYPE_NODESOLVED
+    NODEEVENT         = SCIP_EVENTTYPE_NODEEVENT
+    SOLFOUND          = SCIP_EVENTTYPE_SOLFOUND
+    SOLEVENT          = SCIP_EVENTTYPE_SOLEVENT
+    GAPUPDATED        = SCIP_EVENTTYPE_GAPUPDATED
+    ROWCHANGED        = SCIP_EVENTTYPE_ROWCHANGED
+    ROWEVENT          = SCIP_EVENTTYPE_ROWEVENT
 
 cdef class PY_SCIP_LOCKTYPE:
     MODEL    = SCIP_LOCKTYPE_MODEL
     CONFLICT = SCIP_LOCKTYPE_CONFLICT
 
+cdef class PY_SCIP_IMPLINTTYPE:
+    NONE   = SCIP_IMPLINTTYPE_NONE
+    WEAK   = SCIP_IMPLINTTYPE_WEAK
+    STRONG = SCIP_IMPLINTTYPE_STRONG
+
 cdef class PY_SCIP_LPSOLSTAT:
     NOTSOLVED    = SCIP_LPSOLSTAT_NOTSOLVED
     OPTIMAL      = SCIP_LPSOLSTAT_OPTIMAL
@@ -626,6 +634,31 @@ cdef class Column:
         return (self.__class__ == other.__class__
                 and self.scip_col == (<Column>other).scip_col)
 
+cdef class ColumnExact:
+    """Base class holding a pointer to corresponding SCIP_COLEXACT."""
+
+    @staticmethod
+    cdef create(SCIP_COLEXACT* scipcolexact):
+        """
+        Main method for creating a ColumnExact class. Is used instead of __init__.
+
+        Parameters
+        ----------
+        scipcolexact : SCIP_COLEXACT*
+            A pointer to the SCIP_COLEXACT
+
+        Returns
+        -------
+        col : ColumnExact
+            The Python representative of the SCIP_COLEXACT
+
+        """
+        if scipcolexact == NULL:
+            raise Warning("cannot create ColumnExact with SCIP_COLEXACT* == NULL")
+        col = ColumnExact()
+        col.scip_col_exact = scipcolexact
+        return col
+
 cdef class Row:
     """Base class holding a pointer to corresponding SCIP_ROW."""
 
@@ -910,6 +943,31 @@ cdef class Row:
         return (self.__class__ == other.__class__
                 and self.scip_row == (<Row>other).scip_row)
 
+cdef class RowExact:
+    """Base class holding a pointer to corresponding SCIP_ROW."""
+
+    @staticmethod
+    cdef create(SCIP_ROWEXACT* sciprowexact):
+        """
+        Main method for creating a RowExact class. Is used instead of __init__.
+
+        Parameters
+        ----------
+        sciprow : SCIP_ROWEXACT*
+            A pointer to the SCIP_ROWEXACT
+
+        Returns
+        -------
+        row : Row
+            The Python representative of the SCIP_ROWEXACT
+
+        """
+        if sciprowexact == NULL:
+            raise Warning("cannot create Row with SCIP_ROWEXACT* == NULL")
+        row_exact = RowExact()
+        row_exact.scip_row_exact = sciprowexact
+        return row_exact
+
 cdef class NLRow:
     """Base class holding a pointer to corresponding SCIP_NLROW."""
 
@@ -1010,8 +1068,8 @@ cdef class Solution:
     """Base class holding a pointer to corresponding SCIP_SOL."""
 
     # We are raising an error here to avoid creating a solution without an associated model. See Issue #625
-    def __init__(self, raise_error = False):
-        if not raise_error:
+    def __init__(self, raise_error = True):
+        if raise_error:
             raise ValueError("To create a solution you should use the createSol method of the Model class.")
 
     @staticmethod
@@ -1035,35 +1093,23 @@ cdef class Solution:
         """
         if scip == NULL:
             raise Warning("cannot create Solution with SCIP* == NULL")
-        sol = Solution(True)
+        sol = Solution(raise_error=False)
         sol.sol = scip_sol
         sol.scip = scip
         return sol
 
-    def __getitem__(self, expr: Union[Expr, MatrixExpr]):
-        if isinstance(expr, MatrixExpr):
-            result = np.zeros(expr.shape, dtype=np.float64)
-            for idx in np.ndindex(expr.shape):
-                result[idx] = self.__getitem__(expr[idx])
-            return result
-
-        # fast track for Variable
-        cdef SCIP_Real coeff
-        cdef _VarArray wrapper
-        if isinstance(expr, Variable):
-            wrapper = _VarArray(expr)
-            self._checkStage("SCIPgetSolVal")
-            return SCIPgetSolVal(self.scip, self.sol, wrapper.ptr[0])
-        return sum(self._evaluate(term)*coeff for term, coeff in expr.terms.items() if coeff != 0)
+    def __getitem__(
+        self,
+        expr: Union[Expr, GenExpr, MatrixExpr],
+    ) -> Union[float, np.ndarray]:
+        if not isinstance(expr, (Expr, GenExpr, MatrixExpr)):
+            raise TypeError(
+                "Argument 'expr' has incorrect type, expected 'Expr', 'GenExpr', or "
+                f"'MatrixExpr', got {type(expr).__name__!r}"
+            )
 
-    def _evaluate(self, term):
         self._checkStage("SCIPgetSolVal")
-        result = 1
-        cdef _VarArray wrapper
-        wrapper = _VarArray(term.vartuple)
-        for i in range(len(term.vartuple)):
-            result *= SCIPgetSolVal(self.scip, self.sol, wrapper.ptr[i])
-        return result
+        return expr._evaluate(self)
 
     def __setitem__(self, Variable var, value):
         PY_SCIP_CALL(SCIPsetSolVal(self.scip, self.sol, var.scip_var, value))
@@ -1507,6 +1553,8 @@ cdef class Variable(Expr):
 
     property name:
         def __get__(self):
+            if self.scip_var == NULL:
+                return ""
             cname = bytes( SCIPvarGetName(self.scip_var) )
             return cname.decode('utf-8')
 
@@ -1519,7 +1567,7 @@ cdef class Variable(Expr):
 
     def vtype(self):
         """
-        Retrieve the variables type (BINARY, INTEGER, IMPLINT or CONTINUOUS)
+        Retrieve the variables type (BINARY, INTEGER, CONTINUOUS, or IMPLINT)
 
         Returns
         -------
@@ -1534,8 +1582,58 @@ cdef class Variable(Expr):
             return "INTEGER"
         elif vartype == SCIP_VARTYPE_CONTINUOUS:
             return "CONTINUOUS"
-        elif vartype == SCIP_VARTYPE_IMPLINT:
+        elif vartype == SCIP_DEPRECATED_VARTYPE_IMPLINT:
             return "IMPLINT"
+    
+    def isBinary(self):
+        """
+        Returns whether variable is of BINARY type.
+
+        Returns
+        -------
+        bool
+        """
+        return SCIPvarIsBinary(self.scip_var)
+    
+    def isIntegral(self):
+        """
+        Returns whether variable is of INTEGER type.
+
+        Returns
+        -------
+        bool
+        """
+        return SCIPvarIsIntegral(self.scip_var)
+    
+    def isImpliedIntegral(self):
+        """
+        Returns whether variable is implied integral (weakly or strongly).
+
+        Returns
+        -------
+        bool
+        """
+        return SCIPvarIsImpliedIntegral(self.scip_var)
+    
+    def isNonImpliedIntegral(self):
+        """
+        Returns TRUE if the variable is integral, but not implied integral..
+
+        Returns
+        -------
+        bool
+        """
+        return SCIPvarIsNonimpliedIntegral(self.scip_var)
+
+    def getImplType(self):
+        """
+        Returns the implied integral type of the variable
+
+        Returns
+        -------
+        PY_SCIP_IMPLINTTYPE
+        """
+        return SCIPvarGetImplType(self.scip_var)
 
     def getStatus(self):
         """
@@ -1762,6 +1860,16 @@ cdef class Variable(Expr):
         """
         return SCIPvarIsDeletable(self.scip_var)
 
+    def isActive(self):
+        """
+        Returns whether variable is an active (neither fixed nor aggregated) variable.
+
+        Returns
+        -------
+        boolean
+        """
+        return SCIPvarIsActive(self.scip_var)
+
     def getNLocksDown(self):
         """
         Returns the number of locks for rounding down.
@@ -2105,9 +2213,14 @@ cdef class Constraint:
 
     property name:
         def __get__(self):
+            if self.scip_cons == NULL:
+                return ""
             cname = bytes( SCIPconsGetName(self.scip_cons) )
             return cname.decode('utf-8')
 
+    def ptr(self):
+        return <size_t>(self.scip_cons)
+
     def __repr__(self):
         return self.name
 
@@ -2555,6 +2668,115 @@ cdef class _VarArray:
         if self.ptr != NULL:
             free(self.ptr)
 
+cdef class IIS:
+
+    @staticmethod
+    cdef create(SCIP_IIS* scip_iis):
+        """
+        Main method for creating an IIS class.
+
+        Parameters
+        ----------
+        scip : SCIP_IIS*
+            A pointer to the SCIP_IIS
+
+        Returns
+        -------
+        sol : IIS
+            The Python representative of the IIS
+
+        """
+        iis = IIS()
+        iis._iis = scip_iis
+        return iis
+    
+    def getTime(self):
+        """
+        Retrieve the solving time of the IIS.
+
+        Returns
+        -------
+        float
+        """
+        return SCIPiisGetTime(self._iis)
+
+    def isSubscipIrreducible(self):
+        """
+        Returns whether the IIS is irreducible.
+
+        Returns
+        -------
+        bool
+        """
+        return SCIPiisIsSubscipIrreducible(self._iis)
+
+    def isSubscipInfeasible(self):
+        """
+        Returns whether the IIS is infeasible.
+
+        Returns
+        -------
+        bool
+        """
+        return SCIPiisIsSubscipInfeasible(self._iis)
+    
+    def setSubscipIrreducible(self, irreducible):
+        """
+        Sets the flag that states whether the IIS subscip is irreducible.
+
+        Parameters
+        ----------
+        irreducible : bool
+            the value to set the irreducible flag to
+        """
+
+        SCIPiisSetSubscipIrreducible(self._iis, irreducible)
+
+    def setSubscipInfeasible(self, infeasible):
+        """
+        Sets the flag that states whether the IIS subscip is infeasible.
+
+        Parameters
+        ----------
+        infeasible : bool
+            the value to set the infeasible flag to
+        """
+
+        SCIPiisSetSubscipInfeasible(self._iis, infeasible)
+
+    def getNNodes(self):
+        """
+        Gets number of nodes in the IIS solve.
+
+        Returns
+        -------
+        int
+
+        """
+        return SCIPiisGetNNodes(self._iis)
+    
+    def getSubscip(self):
+        """
+        Get the subscip of an IIS.
+
+        Returns
+        -------
+        Model
+        """
+        cdef SCIP* subscip
+
+        subscip = SCIPiisGetSubscip(self._iis)
+        model = Model.create(subscip)
+        return model
+
+    def greedyMakeIrreducible(self):
+       """
+       Perform the greedy deletion algorithm with singleton batches to obtain an irreducible infeasible subsystem (IIS)
+       """
+
+       PY_SCIP_CALL(SCIPiisGreedyMakeIrreducible(self._iis))
+
+
 # - remove create(), includeDefaultPlugins(), createProbBasic() methods
 # - replace free() by "destructor"
 # - interface SCIPfreeProb()
@@ -2563,7 +2785,7 @@ cdef class _VarArray:
 ##
 cdef class Model:
 
-    def __init__(self, problemName='model', defaultPlugins=True, Model sourceModel=None, origcopy=False, globalcopy=True, enablepricing=False, createscip=True, threadsafe=False):
+    def __init__(self, problemName='model', defaultPlugins=True, Model sourceModel=None, origcopy=False, globalcopy=True, enablepricing=True, createscip=True, threadsafe=False):
         """
         Main class holding a pointer to SCIP for managing most interactions
 
@@ -2580,7 +2802,7 @@ cdef class Model:
         globalcopy : bool, optional
             whether to create a global or a local copy (default True)
         enablepricing : bool, optional
-            whether to enable pricing in copy (default False)
+            whether to enable pricing in copy (default True)
         createscip : bool, optional
             initialize the Model object and creates a SCIP instance (default True)
         threadsafe : bool, optional
@@ -2596,8 +2818,10 @@ cdef class Model:
 
         self._freescip = True
         self._modelvars = {}
+        self._modelconss = {}
         self._generated_event_handlers_count = 0
         self._benders_subproblems = []  # Keep references to Benders subproblem Models
+        self._iis = NULL
 
         if not createscip:
             # if no SCIP instance should be created, then an empty Model object is created.
@@ -2691,6 +2915,16 @@ cdef class Model:
                 # Clear the references to allow Python GC to clean up the Model objects
                 self._benders_subproblems = []
 
+            # Invalidate all variable and constraint pointers before freeing SCIP. See issue #604.
+            if self._modelvars:
+                for var in self._modelvars.values():
+                    (<Variable>var).scip_var = NULL
+                self._modelvars = {}
+            if self._modelconss:
+                for cons in self._modelconss.values():
+                    (<Constraint>cons).scip_cons = NULL
+                self._modelconss = {}
+
             PY_SCIP_CALL( SCIPfree(&self._scip) )
 
     def __hash__(self):
@@ -2723,6 +2957,24 @@ cdef class Model:
         model._benders_subproblems = []  # Initialize Benders subproblems list
         return model
 
+    cdef _getOrCreateCons(self, SCIP_CONS* scip_cons):
+        """Get existing Constraint wrapper or create and track a new one."""
+        cdef size_t ptr = <size_t>scip_cons
+        if ptr in self._modelconss:
+            return self._modelconss[ptr]
+        pyCons = Constraint.create(scip_cons)
+        self._modelconss[ptr] = pyCons
+        return pyCons
+
+    cdef _getOrCreateVar(self, SCIP_VAR* scip_var):
+        """Get existing Variable wrapper or create and track a new one."""
+        cdef size_t ptr = <size_t>scip_var
+        if ptr in self._modelvars:
+            return self._modelvars[ptr]
+        pyVar = Variable.create(scip_var)
+        self._modelvars[ptr] = pyVar
+        return pyVar
+
     @property
     def _freescip(self):
         """
@@ -2830,11 +3082,20 @@ cdef class Model:
                                  SCIP_STAGE_SOLVED]:
             raise Warning("method cannot be called in stage %i." % self.getStage())
 
-        self._modelvars = {
-            var: value
-            for var, value in self._modelvars.items()
-            if value.isOriginal()
-        }
+        # Invalidate transformed variables. See issue #604.
+        origvars = {ptr: var for ptr, var in self._modelvars.items() if var.isOriginal()}
+        for ptr, var in self._modelvars.items():
+            if ptr not in origvars:
+                (<Variable>var).scip_var = NULL
+        self._modelvars = origvars
+
+        # Invalidate transformed constraints. See issue #604.
+        origconss = {ptr: cons for ptr, cons in self._modelconss.items() if cons.isOriginal()}
+        for ptr, cons in self._modelconss.items():
+            if ptr not in origconss:
+                (<Constraint>cons).scip_cons = NULL
+        self._modelconss = origconss
+
         PY_SCIP_CALL(SCIPfreeTransform(self._scip))
 
     def version(self):
@@ -3143,6 +3404,16 @@ cdef class Model:
         """
         return SCIPgetNStrongbranchLPIterations(self._scip)
 
+    def getPrimalDualIntegral(self):
+        """
+        Recomputes and returns the primal dual gap stored in the stats
+
+        Returns
+        ------
+        float
+        """
+        return SCIPgetPrimalDualIntegral(self._scip)
+
     def cutoffNode(self, Node node):
         """
         marks node and whole subtree to be cut off from the branch and bound tree.
@@ -3351,6 +3622,62 @@ cdef class Model:
         """
         return SCIPisFeasIntegral(self._scip, value)
 
+    def isIntegral(self, value):
+        """
+        Returns whether value is integral within epsilon tolerance.
+
+        Parameters
+        ----------
+        value : float
+            value to check
+
+        Returns
+        -------
+        bool
+
+        """
+        return SCIPisIntegral(self._scip, value)
+
+    def adjustedVarLb(self, Variable var, lb):
+        """
+        Returns the adjusted (i.e. rounded, if the given variable is of integral type) lower bound value;
+        does not change the bounds of the variable.
+
+        Parameters
+        ----------
+        var : Variable
+            variable for which the bound is adjusted
+        lb : float
+            lower bound value to adjust
+
+        Returns
+        -------
+        float
+            adjusted lower bound
+
+        """
+        return SCIPadjustedVarLb(self._scip, var.scip_var, lb)
+
+    def adjustedVarUb(self, Variable var, ub):
+        """
+        Returns the adjusted (i.e. rounded, if the given variable is of integral type) upper bound value;
+        does not change the bounds of the variable.
+
+        Parameters
+        ----------
+        var : Variable
+            variable for which the bound is adjusted
+        ub : float
+            upper bound value to adjust
+
+        Returns
+        -------
+        float
+            adjusted upper bound
+
+        """
+        return SCIPadjustedVarUb(self._scip, var.scip_var, ub)
+
     def isEQ(self, val1, val2):
         """
         Checks, if values are in range of epsilon.
@@ -3763,6 +4090,17 @@ cdef class Model:
         """
         PY_SCIP_CALL(SCIPsetObjIntegral(self._scip))
 
+    def isObjIntegral(self):
+        """
+        Returns whether the objective function is integral.
+
+        Returns
+        -------
+        bool
+
+        """
+        return SCIPisObjIntegral(self._scip)
+
     def getLocalEstimate(self, original = False):
         """
         Gets estimate of best primal solution w.r.t. original or transformed problem contained in current subtree.
@@ -4008,7 +4346,7 @@ cdef class Model:
         elif vtype in ['I', 'INTEGER']:
             PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_INTEGER))
         elif vtype in ['M', 'IMPLINT']:
-            PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_IMPLINT))
+            PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_DEPRECATED_VARTYPE_IMPLINT))
         else:
             raise Warning("unrecognized variable type")
 
@@ -4020,11 +4358,7 @@ cdef class Model:
         else:
             PY_SCIP_CALL(SCIPaddVar(self._scip, scip_var))
 
-        pyVar = Variable.create(scip_var)
-
-        # store variable in the model to avoid creating new python variable objects in getVars()
-        assert not pyVar.ptr() in self._modelvars
-        self._modelvars[pyVar.ptr()] = pyVar
+        pyVar = self._getOrCreateVar(scip_var)
 
         #setting the variable data
         SCIPvarSetData(scip_var, <SCIP_VARDATA*>pyVar)
@@ -4154,8 +4488,7 @@ cdef class Model:
         """
         cdef SCIP_VAR* _tvar
         PY_SCIP_CALL(SCIPgetTransformedVar(self._scip, var.scip_var, &_tvar))
-
-        return Variable.create(_tvar)
+        return self._getOrCreateVar(_tvar)
 
     def addVarLocks(self, Variable var, int nlocksdown, int nlocksup):
         """
@@ -4231,11 +4564,72 @@ cdef class Model:
 
         """
         cdef SCIP_Bool deleted
-        if var.ptr() in self._modelvars:
-            del self._modelvars[var.ptr()]
+        del self._modelvars[var.ptr()]
         PY_SCIP_CALL(SCIPdelVar(self._scip, var.scip_var, &deleted))
+        # Invalidate pointer after deletion. See issue #604.
+        var.scip_var = NULL
         return deleted
 
+    def aggregateVars(self, Variable varx, Variable vary, coefx=1.0, coefy=-1.0, rhs=0.0):
+        """
+        Aggregate two variables by adding an aggregation constraint.
+
+        The aggregation is defined by the linear equation:
+
+            coefx * varx + coefy * vary = rhs
+
+        After aggregation, varx becomes a redundant variable and vary remains active.
+        The aggregation effectively substitutes varx with: (rhs - coefy * vary) / coefx
+
+        This method can only be called during presolving.
+
+        Parameters
+        ----------
+        varx : Variable
+            variable to be aggregated (will become redundant)
+        vary : Variable
+            variable to aggregate with (will remain active)
+        coefx : float, optional
+            coefficient for varx in the aggregation equation (default: 1.0)
+        coefy : float, optional
+            coefficient for vary in the aggregation equation (default: -1.0)
+        rhs : float, optional
+            right-hand side of the aggregation equation (default: 0.0)
+
+        Returns
+        -------
+        infeasible : bool
+            whether the aggregation is infeasible (e.g., bounds are incompatible)
+        redundant : bool
+            whether the aggregation makes varx redundant
+        aggregated : bool
+            whether the aggregation was actually performed
+
+        Examples
+        --------
+        To express x = y (i.e., 1*x + (-1)*y = 0):
+
+            infeas, redun, aggr = model.aggregateVars(x, y, 1.0, -1.0, 0.0)
+
+        To express x = 5 - y (i.e., 1*x + 1*y = 5):
+
+            infeas, redun, aggr = model.aggregateVars(x, y, 1.0, 1.0, 5.0)
+
+        """
+        cdef SCIP_Bool infeasible
+        cdef SCIP_Bool redundant
+        cdef SCIP_Bool aggregated
+        PY_SCIP_CALL(SCIPaggregateVars(self._scip,
+                                    varx.scip_var,
+                                    vary.scip_var,
+                                    coefx,
+                                    coefy,
+                                    rhs,
+                                    &infeasible,
+                                    &redundant,
+                                    &aggregated))
+        return infeasible, redundant, aggregated
+
     def tightenVarLb(self, Variable var, lb, force=False):
         """
         Tighten the lower bound in preprocessing or current node, if the bound is tighter.
@@ -4456,7 +4850,7 @@ cdef class Model:
         elif vtype in ['I', 'INTEGER']:
             PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_INTEGER, &infeasible))
         elif vtype in ['M', 'IMPLINT']:
-            PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_IMPLINT, &infeasible))
+            PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_DEPRECATED_VARTYPE_IMPLINT, &infeasible))
         else:
             raise Warning("unrecognized variable type")
         if infeasible:
@@ -4511,17 +4905,7 @@ cdef class Model:
             nvars = SCIPgetNOrigVars(self._scip)
 
         for i in range(nvars):
-            ptr = <size_t>(_vars[i])
-
-            # check whether the corresponding variable exists already
-            if ptr in self._modelvars:
-                vars.append(self._modelvars[ptr])
-            else:
-                # create a new variable
-                var = Variable.create(_vars[i])
-                assert var.ptr() == ptr
-                self._modelvars[ptr] = var
-                vars.append(var)
+            vars.append(self._getOrCreateVar(_vars[i]))
 
         return vars
 
@@ -5795,7 +6179,7 @@ cdef class Model:
         Parameters
         ----------
         cons : ExprCons
-            The expression constraint that is not yet an actual constraint
+            the constraint expression to add to the model (e.g., x + y <= 5) 
         name : str, optional
             the name of the constraint, generic name if empty (Default value = "")
         initial : bool, optional
@@ -5845,7 +6229,7 @@ cdef class Model:
         scip_cons = (<Constraint>pycons_initial).scip_cons
 
         PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons))
-        pycons = Constraint.create(scip_cons)
+        pycons = self._getOrCreateCons(scip_cons)
         PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons))
 
         return pycons
@@ -6167,7 +6551,7 @@ cdef class Model:
             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)
+        PyCons = self._getOrCreateCons(disj_cons)
         PY_SCIP_CALL(SCIPreleaseCons(self._scip, &disj_cons))
 
         return PyCons
@@ -6253,20 +6637,11 @@ cdef class Model:
 
         vars = []
         for i in range(nvars):
-            ptr = <size_t>(_vars[i])
-            # check whether the corresponding variable exists already
-            if ptr in self._modelvars:
-                vars.append(self._modelvars[ptr])
-            else:
-                # create a new variable
-                var = Variable.create(_vars[i])
-                assert var.ptr() == ptr
-                self._modelvars[ptr] = var
-                vars.append(var)
+            vars.append(self._getOrCreateVar(_vars[i]))
 
         free(_vars)
         return vars
-    
+
     def getConsVals(self, Constraint constraint):
         """
         Returns the value array of an arbitrary SCIP constraint that can be represented as a single linear constraint.
@@ -6342,16 +6717,7 @@ cdef class Model:
 
         vars = []
         for i in range(nvars):
-            ptr = <size_t>(_vars[i])
-            # check whether the corresponding variable exists already
-            if ptr in self._modelvars:
-                vars.append(self._modelvars[ptr])
-            else:
-                # create a new variable
-                var = Variable.create(_vars[i])
-                assert var.ptr() == ptr
-                self._modelvars[ptr] = var
-                vars.append(var)
+            vars.append(self._getOrCreateVar(_vars[i]))
 
         return vars
 
@@ -6369,22 +6735,10 @@ cdef class Model:
         Variable
 
         """
-        
         cdef SCIP_VAR* _resultant
 
         _resultant = SCIPgetResultantAnd(self._scip, and_cons.scip_cons)
-
-        ptr = <size_t>(_resultant)
-        # check whether the corresponding variable exists already
-        if ptr not in self._modelvars:
-            # create a new variable
-            resultant = Variable.create(_resultant)
-            assert resultant.ptr() == ptr
-            self._modelvars[ptr] = resultant
-        else:
-            resultant = self._modelvars[ptr]
-            
-        return resultant
+        return self._getOrCreateVar(_resultant)
 
     def isAndConsSorted(self, Constraint and_cons):
         """
@@ -6415,38 +6769,6 @@ cdef class Model:
         """
 
         PY_SCIP_CALL(SCIPsortAndCons(self._scip, and_cons.scip_cons))
-    
-    def chgAndConsCheckFlagWhenUpgr(self, Constraint cons, flag):
-        """
-        when 'upgrading' the given AND-constraint, should the check flag for the upgraded 
-        constraint be set to TRUE, even if the check flag of this AND-constraint is set to FALSE?
-        
-        Parameters
-        ----------
-        cons : Constraint
-            The AND constraint to change.
-        flag : bool
-            The new value for the check flag.
-
-        """
-
-        PY_SCIP_CALL(SCIPchgAndConsCheckFlagWhenUpgr(self._scip, cons.scip_cons, flag))
-
-    def chgAndConsRemovableFlagWhenUpgr(self, Constraint cons, flag):
-        """
-        when 'upgrading' the given AND-constraint, should the removable flag for the upgraded 
-        constraint be set to TRUE, even if the removable flag of this AND-constraint is set to FALSE?
-        
-        Parameters
-        ----------
-        cons : Constraint
-            The AND constraint to change.
-        flag : bool
-            The new value for the removable flag.
-
-        """
-
-        PY_SCIP_CALL(SCIPchgAndConsRemovableFlagWhenUpgr(self._scip, cons.scip_cons, flag))
 
     def printCons(self, Constraint constraint):
         """
@@ -6505,7 +6827,10 @@ cdef class Model:
         else:
             raise NotImplementedError("Adding coefficients to %s constraints is not implemented." % constype)
 
-    def addConsNode(self, Node node, Constraint cons, Node validnode=None):
+    def addConsNode(self, Node node, ExprCons cons, Node validnode=None, name='',
+                    initial=True, separate=True, enforce=True, check=True,
+                    propagate=True, local=True, dynamic=False, removable=True,
+                    stickingatnode=True):
         """
         Add a constraint to the given node.
 
@@ -6513,35 +6838,120 @@ cdef class Model:
         ----------
         node : Node
             node at which the constraint will be added
-        cons : Constraint
-            the constraint to add to the node
+        cons : ExprCons
+            the constraint expression to add to the node (e.g., x + y <= 5)
         validnode : Node or None, optional
             more global node where cons is also valid. (Default=None)
+        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 = True)
+        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 = True)
+        stickingatnode : bool, optional
+            should the constraint always be kept at the node where it was added? (Default value = True)
+
+        Returns
+        -------
+        Constraint
+            The added Constraint object.
 
         """
+        assert isinstance(cons, ExprCons), "given constraint is not ExprCons but %s" % cons.__class__.__name__
+
+        cdef SCIP_CONS* scip_cons
+
+        kwargs = dict(name=name, initial=initial, separate=separate,
+                      enforce=enforce, check=check, propagate=propagate,
+                      local=local, modifiable=False, dynamic=dynamic,
+                      removable=removable, stickingatnode=stickingatnode)
+        pycons_initial = self.createConsFromExpr(cons, **kwargs)
+        scip_cons = (<Constraint>pycons_initial).scip_cons
+
         if isinstance(validnode, Node):
-            PY_SCIP_CALL(SCIPaddConsNode(self._scip, node.scip_node, cons.scip_cons, validnode.scip_node))
+            PY_SCIP_CALL(SCIPaddConsNode(self._scip, node.scip_node, scip_cons, validnode.scip_node))
         else:
-            PY_SCIP_CALL(SCIPaddConsNode(self._scip, node.scip_node, cons.scip_cons, NULL))
-        Py_INCREF(cons)
+            PY_SCIP_CALL(SCIPaddConsNode(self._scip, node.scip_node, scip_cons, NULL))
+
+        pycons = Constraint.create(scip_cons)
+        pycons.data = (<Constraint>pycons_initial).data
+        PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons))
+
+        return pycons
 
-    def addConsLocal(self, Constraint cons, Node validnode=None):
+    def addConsLocal(self, ExprCons cons, Node validnode=None, name='',
+                     initial=True, separate=True, enforce=True, check=True,
+                     propagate=True, local=True, dynamic=False, removable=True,
+                     stickingatnode=True):
         """
         Add a constraint to the current node.
 
         Parameters
         ----------
-        cons : Constraint
-            the constraint to add to the current node
+        cons : ExprCons
+            the constraint expression to add to the current node (e.g., x + y <= 5)
         validnode : Node or None, optional
             more global node where cons is also valid. (Default=None)
+        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 = True)
+        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 = True)
+        stickingatnode : bool, optional
+            should the constraint always be kept at the node where it was added? (Default value = True)
+
+        Returns
+        -------
+        Constraint
+            The added Constraint object.
 
         """
+        assert isinstance(cons, ExprCons), "given constraint is not ExprCons but %s" % cons.__class__.__name__
+
+        cdef SCIP_CONS* scip_cons
+
+        kwargs = dict(name=name, initial=initial, separate=separate,
+                      enforce=enforce, check=check, propagate=propagate,
+                      local=local, modifiable=False, dynamic=dynamic,
+                      removable=removable, stickingatnode=stickingatnode)
+        pycons_initial = self.createConsFromExpr(cons, **kwargs)
+        scip_cons = (<Constraint>pycons_initial).scip_cons
+
         if isinstance(validnode, Node):
-            PY_SCIP_CALL(SCIPaddConsLocal(self._scip, cons.scip_cons, validnode.scip_node))
+            PY_SCIP_CALL(SCIPaddConsLocal(self._scip, scip_cons, validnode.scip_node))
         else:
-            PY_SCIP_CALL(SCIPaddConsLocal(self._scip, cons.scip_cons, NULL))
-        Py_INCREF(cons)
+            PY_SCIP_CALL(SCIPaddConsLocal(self._scip, scip_cons, NULL))
+
+        pycons = Constraint.create(scip_cons)
+        pycons.data = (<Constraint>pycons_initial).data
+        PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons))
+
+        return pycons
     
     def addConsKnapsack(self, vars, weights, capacity, name="",
                 initial=True, separate=True, enforce=True, check=True,
@@ -6608,9 +7018,9 @@ cdef class Model:
 
         PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons))
 
-        pyCons = Constraint.create(scip_cons)
+        pyCons = self._getOrCreateCons(scip_cons)
         PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons))
-        
+
         return pyCons
 
     def addConsSOS1(self, vars, weights=None, name="",
@@ -6676,7 +7086,7 @@ cdef class Model:
 
         PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons))
 
-        return Constraint.create(scip_cons)
+        return self._getOrCreateCons(scip_cons)
 
     def addConsSOS2(self, vars, weights=None, name="",
                 initial=True, separate=True, enforce=True, check=True,
@@ -6741,7 +7151,7 @@ cdef class Model:
 
         PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons))
 
-        return Constraint.create(scip_cons)
+        return self._getOrCreateCons(scip_cons)
 
     def addConsAnd(self, vars, resvar, name="",
             initial=True, separate=True, enforce=True, check=True,
@@ -6802,7 +7212,7 @@ cdef class Model:
             initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode))
 
         PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons))
-        pyCons = Constraint.create(scip_cons)
+        pyCons = self._getOrCreateCons(scip_cons)
         PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons))
 
         return pyCons
@@ -6866,7 +7276,7 @@ cdef class Model:
             initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode))
 
         PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons))
-        pyCons = Constraint.create(scip_cons)
+        pyCons = self._getOrCreateCons(scip_cons)
         PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons))
 
         return pyCons
@@ -6929,7 +7339,7 @@ cdef class Model:
             initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode))
 
         PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons))
-        pyCons = Constraint.create(scip_cons)
+        pyCons = self._getOrCreateCons(scip_cons)
         PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons))
 
         return pyCons
@@ -7014,7 +7424,7 @@ cdef class Model:
                 PY_SCIP_CALL(SCIPaddVarCardinality(self._scip, scip_cons, scip_var, indvar, <SCIP_Real>weights[i]))
 
         PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons))
-        pyCons = Constraint.create(scip_cons)
+        pyCons = self._getOrCreateCons(scip_cons)
 
         PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons))
 
@@ -7107,7 +7517,7 @@ cdef class Model:
             PY_SCIP_CALL(SCIPaddVarIndicator(self._scip, scip_cons, wrapper.ptr[0], <SCIP_Real>coeff))
 
         PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons))
-        pyCons = Constraint.create(scip_cons)
+        pyCons = self._getOrCreateCons(scip_cons)
 
         PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons))
 
@@ -7297,7 +7707,7 @@ cdef class Model:
         cdef SCIP_CONS* lincons = SCIPgetLinearConsIndicator(cons.scip_cons)
         if lincons == NULL:
             return None
-        return Constraint.create(lincons)
+        return self._getOrCreateCons(lincons)
 
     def getSlackVarIndicator(self, Constraint cons):
         """
@@ -7315,7 +7725,7 @@ cdef class Model:
 
         """
         cdef SCIP_VAR* var = SCIPgetSlackVarIndicator(cons.scip_cons)
-        return Variable.create(var)
+        return self._getOrCreateVar(var)
 
     def addPyCons(self, Constraint cons):
         """
@@ -7759,7 +8169,7 @@ cdef class Model:
         """
         cdef SCIP_CONS* transcons
         PY_SCIP_CALL(SCIPgetTransformedCons(self._scip, cons.scip_cons, &transcons))
-        return Constraint.create(transcons)
+        return self._getOrCreateCons(transcons)
 
     def isNLPConstructed(self):
         """
@@ -7899,8 +8309,16 @@ cdef class Model:
         Returns
         -------
         bilinterms : list of tuple
+            Triples ``(var1, var2, coef)`` for terms of the form
+            ``coef * var1 * var2`` with ``var1 != var2``.
         quadterms : list of tuple
+            Triples ``(var, sqrcoef, lincoef)`` for variables that appear in
+            quadratic or bilinear terms. ``sqrcoef`` is the coefficient of
+            ``var**2``, and ``lincoef`` is the linear coefficient of ``var``
+            if it also appears linearly.
         linterms : list of tuple
+            Pairs ``(var, coef)`` for purely linear variables, i.e.,
+            variables that do not participate in any quadratic or bilinear term.
 
         """
         cdef SCIP_EXPR* expr
@@ -7919,6 +8337,7 @@ cdef class Model:
         cdef int nbilinterms
 
         # quadratic terms
+        cdef SCIP_EXPR* quadexpr
         cdef SCIP_EXPR* sqrexpr
         cdef SCIP_Real sqrcoef
         cdef int nquadterms
@@ -7931,33 +8350,49 @@ cdef class Model:
         assert self.checkQuadraticNonlinear(cons), "constraint is not quadratic"
 
         expr = SCIPgetExprNonlinear(cons.scip_cons)
-        SCIPexprGetQuadraticData(expr, NULL, &nlinvars, &linexprs, &lincoefs, &nquadterms, &nbilinterms, NULL, NULL)
+        SCIPexprGetQuadraticData(expr, NULL, &nlinvars, &linexprs, &lincoefs,
+                                 &nquadterms, &nbilinterms, NULL, NULL)
 
         linterms   = []
         bilinterms = []
-        quadterms  = []
 
+        # Purely linear terms (variables not in any quadratic/bilinear term)
         for termidx in range(nlinvars):
-            var = Variable.create(SCIPgetVarExprVar(linexprs[termidx]))
+            var = self._getOrCreateVar(SCIPgetVarExprVar(linexprs[termidx]))
             linterms.append((var, lincoefs[termidx]))
 
+        # Collect quadratic terms in a dict so we can merge entries for the same variable.
+        quaddict = {}  # var.ptr() -> [var, sqrcoef, lincoef]
+
         for termidx in range(nbilinterms):
             SCIPexprGetQuadraticBilinTerm(expr, termidx, &bilinterm1, &bilinterm2, &bilincoef, NULL, NULL)
             scipvar1 = SCIPgetVarExprVar(bilinterm1)
             scipvar2 = SCIPgetVarExprVar(bilinterm2)
-            var1 = Variable.create(scipvar1)
-            var2 = Variable.create(scipvar2)
+            var1 = self._getOrCreateVar(scipvar1)
+            var2 = self._getOrCreateVar(scipvar2)
             if scipvar1 != scipvar2:
-                bilinterms.append((var1,var2,bilincoef))
+                bilinterms.append((var1, var2, bilincoef))
             else:
-                quadterms.append((var1,bilincoef,0.0))
-
+                # Squared term reported as bilinear var*var
+                key = var1.ptr()
+                if key in quaddict:
+                    quaddict[key][1] += bilincoef
+                else: # TODO: SCIP handles expr like x**2 appropriately, but PySCIPOpt requires this. Need to investigate why.
+                    quaddict[key] = [var1, bilincoef, 0.0]
+
+        # Also collect linear coefficients from the quadratic terms
         for termidx in range(nquadterms):
-            SCIPexprGetQuadraticQuadTerm(expr, termidx, NULL, &lincoef, &sqrcoef, NULL, NULL, &sqrexpr)
-            if sqrexpr == NULL:
-                continue
-            var = Variable.create(SCIPgetVarExprVar(sqrexpr))
-            quadterms.append((var,sqrcoef,lincoef))
+            SCIPexprGetQuadraticQuadTerm(expr, termidx, &quadexpr, &lincoef, &sqrcoef, NULL, NULL, &sqrexpr)
+            scipvar1 = SCIPgetVarExprVar(quadexpr)
+            var = self._getOrCreateVar(scipvar1)
+            key = var.ptr()
+            if key in quaddict:
+                quaddict[key][1] += sqrcoef
+                quaddict[key][2] += lincoef
+            else:
+                quaddict[key] = [var, sqrcoef, lincoef]
+
+        quadterms = [tuple(entry) for entry in quaddict.values()]
 
         return (bilinterms, quadterms, linterms)
 
@@ -8016,7 +8451,7 @@ cdef class Model:
             conss = SCIPgetOrigConss(self._scip)
             nconss = SCIPgetNOrigConss(self._scip)
 
-        return [Constraint.create(conss[i]) for i in range(nconss)]
+        return [self._getOrCreateCons(conss[i]) for i in range(nconss)]
 
     def getNConss(self, transformed=True):
         """
@@ -8047,7 +8482,10 @@ cdef class Model:
             constraint to be deleted
 
         """
+        del self._modelconss[cons.ptr()]
         PY_SCIP_CALL(SCIPdelCons(self._scip, cons.scip_cons))
+        # Remove from tracking and invalidate pointer. See issue #604.
+        cons.scip_cons = NULL
 
     def delConsLocal(self, Constraint cons):
         """
@@ -8647,11 +9085,8 @@ cdef class Model:
             PY_SCIP_CALL(SCIPgetBendersSubproblemVar(self._scip, _benders, var.scip_var, &_mappedvar, probnumber))
 
         if _mappedvar == NULL:
-            mappedvar = None
-        else:
-            mappedvar = Variable.create(_mappedvar)
-
-        return mappedvar
+            return None
+        return self._getOrCreateVar(_mappedvar)
 
     def getBendersAuxiliaryVar(self, probnumber, Benders benders = None):
         """
@@ -8678,9 +9113,7 @@ cdef class Model:
             _benders = benders._benders
 
         _auxvar = SCIPbendersGetAuxiliaryVar(_benders, probnumber)
-        auxvar = Variable.create(_auxvar)
-
-        return auxvar
+        return self._getOrCreateVar(_auxvar)
 
     def checkBendersSubproblemOptimality(self, Solution solution, probnumber, Benders benders = None):
         """
@@ -9154,7 +9587,10 @@ cdef class Model:
         maxdepth : int, optional
             maximal depth level to call heuristic at (Default value = -1)
         timingmask : PY_SCIP_HEURTIMING, optional
-            positions in the node solving loop where heuristic should be executed
+            positions in the node solvingreturn {
+            'result': SCIP_RESULT.SUCCESS,
+            'lowerbound': 10e4
+        } loop where heuristic should be executed
             (Default value = SCIP_HEURTIMING_BEFORENODE)
         usessubscip : bool, optional
             does the heuristic use a secondary SCIP instance? (Default value = False)
@@ -9172,6 +9608,72 @@ cdef class Model:
         heur.model = <Model>weakref.proxy(self)
         heur.name = name
         Py_INCREF(heur)
+    
+    def includeIISfinder(self, IISfinder iisfinder, name, desc, priority=10000, freq=1):
+        """
+        Include an IIS (Irreducible Infeasible Set) finder handler.
+
+        Parameters
+        ----------
+        iisfinder : IISfinder
+            IIS finder
+        name : str
+            name of IIS finder
+        desc : str
+            description of IIS finder
+        priority : int, optional
+            priority of the IISfinder (#todo description)
+        freq : int, optional
+            frequency for calling IIS finder
+
+        """
+        cdef SCIP_IISFINDER* scip_iisfinder
+
+        nam = str_conversion(name)
+        des = str_conversion(desc)
+
+        iisfinder.iis = IIS()
+
+        PY_SCIP_CALL(SCIPincludeIISfinder(self._scip, nam, des, priority, PyiisfinderCopy, PyiisfinderFree,
+                                         PyiisfinderExec, <SCIP_IISFINDERDATA*> iisfinder))
+
+        scip_iisfinder = SCIPfindIISfinder(self._scip, nam)
+        iisfinder.name = name
+        Py_INCREF(iisfinder)
+        iisfinder.scip_iisfinder = scip_iisfinder
+
+    def generateIIS(self):
+        """
+        Generates an Irreducible Infeasible Subsystem (IIS) from the current
+        problem.
+
+        Returns
+        -------
+        IIS
+
+        """
+        cdef SCIP_IIS* _iis
+
+        PY_SCIP_CALL( SCIPgenerateIIS(self._scip) )
+
+        _iis = SCIPgetIIS(self._scip)
+        return IIS.create(_iis)
+    
+    def getIIS(self):
+        """
+        Get the IIS object.
+        Note: Needs to be called after generateIIS, or after a single execution of the iisfinderExec.
+        
+        Returns
+        -------
+        IIS 
+        """
+        cdef SCIP_IIS* _iis
+
+        _iis = SCIPgetIIS(self._scip)
+        assert _iis != NULL, "No IIS exists. You need to first call generateIIS() or run the iisfinderexec method of your custom IISfinder class."
+
+        return IIS.create(_iis)
 
     def includeRelax(self, Relax relax, name, desc, priority=10000, freq=1):
         """
@@ -9404,7 +9906,7 @@ cdef class Model:
         PY_SCIP_CALL(SCIPgetLPBranchCands(self._scip, &lpcands, &lpcandssol, &lpcandsfrac,
                                           &nlpcands, &npriolpcands, &nfracimplvars))
 
-        return ([Variable.create(lpcands[i]) for i in range(nlpcands)], [lpcandssol[i] for i in range(nlpcands)],
+        return ([self._getOrCreateVar(lpcands[i]) for i in range(nlpcands)], [lpcandssol[i] for i in range(nlpcands)],
                 [lpcandsfrac[i] for i in range(nlpcands)], nlpcands, npriolpcands, nfracimplvars)
 
     def getNLPBranchCands(self):
@@ -9441,7 +9943,7 @@ cdef class Model:
 
         PY_SCIP_CALL(SCIPgetPseudoBranchCands(self._scip, &pseudocands, &npseudocands, &npriopseudocands))
 
-        return ([Variable.create(pseudocands[i]) for i in range(npseudocands)], npseudocands, npriopseudocands)
+        return ([self._getOrCreateVar(pseudocands[i]) for i in range(npseudocands)], npseudocands, npriopseudocands)
 
     def branchVar(self, Variable variable):
         """
@@ -10416,7 +10918,10 @@ cdef class Model:
         Solution or None
 
         """
-        self._bestSol = Solution.create(self._scip, SCIPgetBestSol(self._scip))
+        cdef SCIP_SOL* _sol = SCIPgetBestSol(self._scip)
+        if _sol == NULL:
+            return None
+        self._bestSol = Solution.create(self._scip, _sol)
         return self._bestSol
 
     def getSolObjVal(self, Solution sol, original=True):
@@ -10459,6 +10964,8 @@ cdef class Model:
         float
 
         """
+        if sol is None or sol.sol == NULL:
+            raise ValueError("Cannot get solution time: solution is None or NULL")
         return SCIPgetSolTime(self._scip, sol.sol)
 
     def getObjVal(self, original=True):
@@ -10492,20 +10999,26 @@ cdef class Model:
 
         return self.getSolObjVal(self._bestSol, original)
 
-    def getSolVal(self, Solution sol, Expr expr):
+    def getSolVal(
+        self,
+        Solution sol,
+        expr: Union[Expr, GenExpr, MatrixExpr],
+    ) -> Union[float, np.ndarray]:
         """
-        Retrieve value of given variable or expression in the given solution or in
-        the LP/pseudo solution if sol == None
+        Retrieve value of given variable or expression in the given solution.
 
         Parameters
         ----------
         sol : Solution
-        expr : Expr
-            polynomial expression to query the value of
+            Solution to query the value from. If None, the current LP/pseudo solution is
+            used.
+
+        expr : Expr, GenExpr, MatrixExpr
+            Expression to query the value of.
 
         Returns
         -------
-        float
+        float or np.ndarray
 
         Notes
         -----
@@ -10513,46 +11026,39 @@ cdef class Model:
 
         """
         # no need to create a NULL solution wrapper in case we have a variable
-        cdef _VarArray wrapper
-        if sol == None and isinstance(expr, Variable):
-            wrapper = _VarArray(expr)
-            return SCIPgetSolVal(self._scip, NULL, wrapper.ptr[0])
-        if sol == None:
-            sol = Solution.create(self._scip, NULL)
-        return sol[expr]
+        return (sol or Solution.create(self._scip, NULL))[expr]
 
-    def getVal(self, expr: Union[Expr, MatrixExpr] ):
+    def getVal(self, expr: Union[Expr, GenExpr, MatrixExpr]) -> Union[float, np.ndarray]:
         """
         Retrieve the value of the given variable or expression in the best known solution.
         Can only be called after solving is completed.
 
         Parameters
         ----------
-        expr : Expr ot MatrixExpr
-            polynomial expression to query the value of
+        expr : Expr, GenExpr or MatrixExpr
+            Expression to query the value of.
 
         Returns
         -------
-        float
+        float or np.ndarray
 
         Notes
         -----
         A variable is also an expression.
 
         """
-        stage_check = SCIPgetStage(self._scip) not in [SCIP_STAGE_INIT, SCIP_STAGE_FREE]
-
-        if not stage_check or self._bestSol.sol == NULL and SCIPgetStage(self._scip) != SCIP_STAGE_SOLVING:
+        if SCIPgetStage(self._scip) in {SCIP_STAGE_INIT, SCIP_STAGE_FREE}:
             raise Warning("Method cannot be called in stage ", self.getStage())
 
-        if isinstance(expr, MatrixExpr):
-            result = np.empty(expr.shape, dtype=float)
-            for idx in np.ndindex(result.shape):
-                result[idx] = self.getSolVal(self._bestSol, expr[idx])
-        else:
-            result = self.getSolVal(self._bestSol, expr)
+        # Ensure _bestSol is up-to-date (cheap pointer comparison)
+        cdef SCIP_SOL* current_best_sol = SCIPgetBestSol(self._scip)
+        if self._bestSol is None or self._bestSol.sol != current_best_sol:
+            self._bestSol = Solution.create(self._scip, current_best_sol)
 
-        return result
+        if self._bestSol.sol == NULL and SCIPgetStage(self._scip) != SCIP_STAGE_SOLVING:
+            raise Warning("No solution available")
+
+        return self._bestSol[expr]
 
     def hasPrimalRay(self):
         """
@@ -10863,12 +11369,58 @@ cdef class Model:
 
     # Statistic Methods
 
-    def printStatistics(self):
-        """Print statistics."""
+    def printStatistics(self, filename=None):
+        """
+        Print statistics.
+
+        Parameters
+        ----------
+        filename : str, optional
+            name of the output file (Default = None)
+
+        """ 
+
         user_locale = locale.getlocale(category=locale.LC_NUMERIC)
         locale.setlocale(locale.LC_NUMERIC, "C")
 
-        PY_SCIP_CALL(SCIPprintStatistics(self._scip, NULL))
+        if not filename:
+            PY_SCIP_CALL(SCIPprintStatistics(self._scip, NULL))
+        else:
+            with open(filename, "w") as f:
+                cfile = fdopen(f.fileno(), "w")
+                PY_SCIP_CALL(SCIPprintStatistics(self._scip, cfile))
+
+        locale.setlocale(locale.LC_NUMERIC,user_locale)
+    
+    def printStatisticsJson(self, filename=None):
+        """
+        Print statistics in JSON format.
+
+        Parameters
+        ----------
+        filename : str, optional
+            name of the output file (Default = None)
+
+        """ 
+
+        user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+        locale.setlocale(locale.LC_NUMERIC, "C")
+
+        if not filename:
+            PY_SCIP_CALL(SCIPprintStatisticsJson(self._scip, NULL))
+        else:
+            with open(filename, "w") as f:
+                cfile = fdopen(f.fileno(), "w")
+                PY_SCIP_CALL(SCIPprintStatisticsJson(self._scip, cfile))
+
+        locale.setlocale(locale.LC_NUMERIC,user_locale)
+    
+    def printStatisticsJson(self):
+        """Print statistics in JSON format."""
+        user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+        locale.setlocale(locale.LC_NUMERIC, "C")
+
+        PY_SCIP_CALL(SCIPprintStatisticsJson(self._scip, NULL))
 
         locale.setlocale(locale.LC_NUMERIC,user_locale)
 
@@ -10892,6 +11444,28 @@ cdef class Model:
             PY_SCIP_CALL(SCIPprintStatistics(self._scip, cfile))
 
         locale.setlocale(locale.LC_NUMERIC,user_locale)
+    
+
+    def writeStatisticsJson(self, filename="origprob.stats.json"):
+        """
+        Write statistics to a JSON file.
+
+        Parameters
+        ----------
+        filename : str, optional
+            name of the output file (Default = "origprob.stats.json")
+
+        """
+        user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+        locale.setlocale(locale.LC_NUMERIC, "C")
+
+        # use this doubled opening pattern to ensure that IOErrors are
+        #   triggered early and in Python not in C,Cython or SCIP.
+        with open(filename, "w") as f:
+            cfile = fdopen(f.fileno(), "w")
+            PY_SCIP_CALL(SCIPprintStatisticsJson(self._scip, cfile))
+
+        locale.setlocale(locale.LC_NUMERIC,user_locale)
 
     def getNLPs(self):
         """
@@ -11300,12 +11874,12 @@ cdef class Model:
 
     def chgReoptObjective(self, coeffs, sense = 'minimize'):
         """
-        Establish the objective function as a linear expression.
+        Change the objective function for reoptimization.
 
         Parameters
         ----------
-        coeffs : list of float
-            the coefficients
+        coeffs : Expr
+            the coefficients as a linear expression
         sense : str
             the objective sense (Default value = 'minimize')
 
@@ -11314,7 +11888,6 @@ cdef class Model:
         cdef int nvars
         cdef SCIP_Real* _coeffs
         cdef SCIP_OBJSENSE objsense
-        cdef SCIP_Real coef
         cdef int i
         cdef _VarArray wrapper
 
@@ -11332,24 +11905,27 @@ cdef class Model:
         if coeffs[CONST] != 0.0:
             raise ValueError("Constant offsets in objective are not supported!")
 
-        vars = SCIPgetOrigVars(self._scip)
-        nvars = SCIPgetNOrigVars(self._scip)
-        _coeffs = <SCIP_Real*> malloc(nvars * sizeof(SCIP_Real))
+        nvars = len(coeffs.terms) - (CONST in coeffs.terms)
 
-        for i in range(nvars):
-            _coeffs[i] = 0.0
+        if nvars == 0:
+            PY_SCIP_CALL(SCIPchgReoptObjective(self._scip, objsense, NULL, NULL, 0))
+            return
+
+        _coeffs = <SCIP_Real*> malloc(nvars * sizeof(SCIP_Real))
+        vars = <SCIP_VAR**> malloc(nvars * sizeof(SCIP_VAR*))
 
+        i = 0
         for term, coef in coeffs.terms.items():
             # avoid CONST term of Expr
             if term != CONST:
-                assert len(term) == 1
-                for i in range(nvars):
-                    wrapper = _VarArray(term[0])
-                    if vars[i] == wrapper.ptr[0]:
-                        _coeffs[i] = coef
+                wrapper = _VarArray(term[0])
+                vars[i] = wrapper.ptr[0]
+                _coeffs[i] = coef
+                i += 1
 
-        PY_SCIP_CALL(SCIPchgReoptObjective(self._scip, objsense, vars, &_coeffs[0], nvars))
+        PY_SCIP_CALL(SCIPchgReoptObjective(self._scip, objsense, vars, _coeffs, nvars))
 
+        free(vars)
         free(_coeffs)
 
     def chgVarBranchPriority(self, Variable var, priority):
@@ -11562,6 +12138,65 @@ cdef class Model:
         """
         return SCIPgetTreesizeEstimation(self._scip)
 
+
+    # Exact SCIP methods
+    def enableExactSolving(self, SCIP_Bool enable):
+        """
+        Enables or disables exact solving mode in SCIP.
+
+        Parameters
+        ----------
+        enable : SCIP_Bool
+            Whether to enable exact solving mode (True) or disable it (False).
+        """
+
+        PY_SCIP_CALL(SCIPenableExactSolving(self._scip, enable))
+
+    def isExact(self):
+        """
+        Returns whether exact solving mode is enabled in SCIP.
+
+        Returns
+        -------
+        bool
+        """
+
+        return SCIPisExact(self._scip)
+
+    def allowNegSlackExact(self):
+        """
+        Returns whether negative slack is allowed in exact solving mode.
+
+        Returns
+        -------
+        bool
+        """
+
+        return SCIPallowNegSlack(self._scip)
+    
+    def branchLPExact(self):
+        """
+        Performs exact LP branching.
+
+        Returns
+        -------
+        SCIP_RESULT
+        """
+        cdef SCIP_RESULT result
+        PY_SCIP_CALL(SCIPbranchLPExact(self._scip, &result))
+        return result
+
+    def addRowExact(self, RowExact rowexact):
+        """
+        Adds an exact row to the LP.
+
+        Parameters
+        ----------
+        rowexact : RowExact
+            The exact row to add.
+        """
+        PY_SCIP_CALL(SCIPaddRowExact(self._scip, rowexact.scip_row_exact))
+
     def getBipartiteGraphRepresentation(self, prev_col_features=None, prev_edge_features=None, prev_row_features=None,
                                         static_only=False, suppress_warnings=False):
         """
@@ -11669,7 +12304,7 @@ cdef class Model:
                     col_features[col_i][col_feature_map["integer"]] = 1
                 elif vtype == SCIP_VARTYPE_CONTINUOUS:
                     col_features[col_i][col_feature_map["continuous"]] = 1
-                elif vtype == SCIP_VARTYPE_IMPLINT:
+                elif vtype == SCIP_DEPRECATED_VARTYPE_IMPLINT:
                     col_features[col_i][col_feature_map["implicit_integer"]] = 1
                 # Objective coefficient
                 col_features[col_i][col_feature_map["obj_coef"]] = SCIPcolGetObj(cols[i])