PySCIPOpt 6.0.0__cp312-cp312-win_amd64.whl → 6.1.0__cp312-cp312-win_amd64.whl

pyscipopt/__init__.py

@@ -1,12 +1,12 @@
 """""" # start delvewheel patch
-def _delvewheel_patch_1_11_2():
+def _delvewheel_patch_1_12_0():
     import os
     if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'pyscipopt.libs'))):
         os.add_dll_directory(libs_dir)
 
 
-_delvewheel_patch_1_11_2()
-del _delvewheel_patch_1_11_2
+_delvewheel_patch_1_12_0()
+del _delvewheel_patch_1_12_0
 # end delvewheel patch
 
 from ._version import __version__
@@ -15,7 +15,7 @@ from ._version import __version__
 import os
 if hasattr(os, 'add_dll_directory'):
     if os.getenv('SCIPOPTDIR'):
-        os.add_dll_directory(os.path.join(os.getenv('SCIPOPTDIR').strip('"'), 'bin'))
+        os.add_dll_directory(os.path.join(os.environ['SCIPOPTDIR'].strip('"'), 'bin'))
 
 # export user-relevant objects:
 from pyscipopt.Multidict import multidict as multidict

pyscipopt/_version.py

@@ -1 +1 @@
-__version__: str = '6.0.0'
+__version__: str = '6.1.0'

pyscipopt/benders.pxi

@@ -35,8 +35,7 @@ cdef class Benders:
 
     def benderscreatesub(self, probnumber):
         '''creates the subproblems and registers it with the Benders decomposition struct '''
-        print("python error in benderscreatesub: this method needs to be implemented")
-        return {}
+        raise NotImplementedError("benderscreatesub() is a fundamental callback and should be implemented in the derived class")
 
     def benderspresubsolve(self, solution, enfotype, checkint):
         '''sets the pre subproblem solve callback of Benders decomposition '''
@@ -60,8 +59,7 @@ cdef class Benders:
 
     def bendersgetvar(self, variable, probnumber):
         '''Returns the corresponding master or subproblem variable for the given variable. This provides a call back for the variable mapping between the master and subproblems. '''
-        print("python error in bendersgetvar: this method needs to be implemented")
-        return {}
+        raise NotImplementedError("bendersgetvar() is a fundamental callback and should be implemented in the derived class")
 
 # local helper functions for the interface
 cdef Variable getPyVar(SCIP_VAR* var):

pyscipopt/benderscut.pxi

@@ -21,8 +21,7 @@ cdef class Benderscut:
         pass
 
     def benderscutexec(self, solution, probnumber, enfotype):
-        print("python error in benderscutexec: this method needs to be implemented")
-        return {}
+        raise NotImplementedError("benderscutexec() is a fundamental callback and should be implemented in the derived class")
 
 cdef SCIP_RETCODE PyBenderscutCopy (SCIP* scip, SCIP_BENDERS* benders, SCIP_BENDERSCUT* benderscut) noexcept with gil:
     return SCIP_OKAY

pyscipopt/conshdlr.pxi

@@ -55,23 +55,19 @@ cdef class Conshdlr:
 
     def consenfolp(self, constraints, nusefulconss, solinfeasible):
         '''calls enforcing method of constraint handler for LP solution for all constraints added'''
-        print("python error in consenfolp: this method needs to be implemented")
-        return {}
+        raise NotImplementedError("consenfolp() is a fundamental callback and should be implemented in the derived class")
 
     def consenforelax(self, solution, constraints, nusefulconss, solinfeasible):
         '''calls enforcing method of constraint handler for a relaxation solution for all constraints added'''
-        print("python error in consenforelax: this method needs to be implemented")
-        return {}
+        raise NotImplementedError("consenforelax() is a fundamental callback and should be implemented in the derived class")
 
     def consenfops(self, constraints, nusefulconss, solinfeasible, objinfeasible):
         '''calls enforcing method of constraint handler for pseudo solution for all constraints added'''
-        print("python error in consenfops: this method needs to be implemented")
-        return {}
+        raise NotImplementedError("consenfops() is a fundamental callback and should be implemented in the derived class")
 
     def conscheck(self, constraints, solution, checkintegrality, checklprows, printreason, completely):
         '''calls feasibility check method of constraint handler '''
-        print("python error in conscheck: this method needs to be implemented")
-        return {}
+        raise NotImplementedError("conscheck() is a fundamental callback and should be implemented in the derived class")
 
     def consprop(self, constraints, nusefulconss, nmarkedconss, proptiming):
         '''calls propagation method of constraint handler '''
@@ -89,8 +85,7 @@ cdef class Conshdlr:
 
     def conslock(self, constraint, locktype, nlockspos, nlocksneg):
         '''variable rounding lock method of constraint handler'''
-        print("python error in conslock: this method needs to be implemented")
-        return {}
+        raise NotImplementedError("conslock() is a fundamental callback and should be implemented in the derived class")
 
     def consactive(self, constraint):
         '''sets activation notification method of constraint handler '''

pyscipopt/event.pxi

@@ -34,8 +34,7 @@ cdef class Eventhdlr:
 
     def eventexec(self, event):
         '''calls execution method of event handler '''
-        print("python error in eventexec: this method needs to be implemented")
-        return {}
+        raise NotImplementedError("eventexec() is a fundamental callback and should be implemented in the derived class")
 
 
 # local helper functions for the interface

pyscipopt/expr.pxi

@@ -42,7 +42,20 @@
 # which should, in princple, modify the expr. However, since we do not implement __isub__, __sub__
 # gets called (I guess) and so a copy is returned.
 # Modifying the expression directly would be a bug, given that the expression might be re-used by the user. </pre>
-include "matrix.pxi"
+import math
+from typing import TYPE_CHECKING
+
+from cpython.dict cimport PyDict_Next, PyDict_GetItem
+from cpython.object cimport Py_TYPE
+from cpython.ref cimport PyObject
+from cpython.tuple cimport PyTuple_GET_ITEM
+from pyscipopt.scip cimport Variable, Solution
+
+import numpy as np
+
+
+if TYPE_CHECKING:
+    double = float
 
 
 def _is_number(e):
@@ -61,7 +74,7 @@ def _expr_richcmp(self, other, op):
             return (self - other) <= 0.0
         elif _is_number(other):
             return ExprCons(self, rhs=float(other))
-        elif isinstance(other, MatrixExpr):
+        elif isinstance(other, np.ndarray):
             return _expr_richcmp(other, self, 5)
         else:
             raise TypeError(f"Unsupported type {type(other)}")
@@ -70,7 +83,7 @@ def _expr_richcmp(self, other, op):
             return (self - other) >= 0.0
         elif _is_number(other):
             return ExprCons(self, lhs=float(other))
-        elif isinstance(other, MatrixExpr):
+        elif isinstance(other, np.ndarray):
             return _expr_richcmp(other, self, 1)
         else:
             raise TypeError(f"Unsupported type {type(other)}")
@@ -79,7 +92,7 @@ def _expr_richcmp(self, other, op):
             return (self - other) == 0.0
         elif _is_number(other):
             return ExprCons(self, lhs=float(other), rhs=float(other))
-        elif isinstance(other, MatrixExpr):
+        elif isinstance(other, np.ndarray):
             return _expr_richcmp(other, self, 2)
         else:
             raise TypeError(f"Unsupported type {type(other)}")
@@ -87,35 +100,83 @@ def _expr_richcmp(self, other, op):
         raise NotImplementedError("Can only support constraints with '<=', '>=', or '=='.")
 
 
-class Term:
+cdef class Term:
     '''This is a monomial term'''
 
-    __slots__ = ('vartuple', 'ptrtuple', 'hashval')
+    cdef readonly tuple vartuple
+    cdef readonly tuple ptrtuple
+    cdef Py_ssize_t hashval
 
-    def __init__(self, *vartuple):
+    def __init__(self, *vartuple: Variable):
         self.vartuple = tuple(sorted(vartuple, key=lambda v: v.ptr()))
         self.ptrtuple = tuple(v.ptr() for v in self.vartuple)
-        self.hashval = sum(self.ptrtuple)
+        self.hashval = <Py_ssize_t>hash(self.ptrtuple)
 
     def __getitem__(self, idx):
         return self.vartuple[idx]
 
-    def __hash__(self):
+    def __hash__(self) -> Py_ssize_t:
         return self.hashval
 
-    def __eq__(self, other):
+    def __eq__(self, other: Term):
         return self.ptrtuple == other.ptrtuple
 
     def __len__(self):
         return len(self.vartuple)
 
-    def __add__(self, other):
-        both = self.vartuple + other.vartuple
-        return Term(*both)
+    def __mul__(self, Term other):
+        # NOTE: This merge algorithm requires a sorted `Term.vartuple`.
+        # This should be ensured in the constructor of Term.
+        cdef int n1 = len(self)
+        cdef int n2 = len(other)
+        if n1 == 0: return other
+        if n2 == 0: return self
+
+        cdef list vartuple = [None] * (n1 + n2)
+        cdef int i = 0, j = 0, k = 0
+        cdef Variable var1, var2
+        while i < n1 and j < n2:
+            var1 = <Variable>PyTuple_GET_ITEM(self.vartuple, i)
+            var2 = <Variable>PyTuple_GET_ITEM(other.vartuple, j)
+            if var1.ptr() <= var2.ptr():
+                vartuple[k] = var1
+                i += 1
+            else:
+                vartuple[k] = var2
+                j += 1
+            k += 1
+        while i < n1:
+            vartuple[k] = <Variable>PyTuple_GET_ITEM(self.vartuple, i)
+            i += 1
+            k += 1
+        while j < n2:
+            vartuple[k] = <Variable>PyTuple_GET_ITEM(other.vartuple, j)
+            j += 1
+            k += 1
+
+        cdef Term res = Term.__new__(Term)
+        res.vartuple = tuple(vartuple)
+        res.ptrtuple = tuple(v.ptr() for v in res.vartuple)
+        res.hashval = <Py_ssize_t>hash(res.ptrtuple)
+        return res
 
     def __repr__(self):
         return 'Term(%s)' % ', '.join([str(v) for v in self.vartuple])
 
+    cpdef double _evaluate(self, Solution sol) except *:
+        cdef double res = 1.0
+        cdef SCIP* scip_ptr = sol.scip
+        cdef SCIP_SOL* sol_ptr = sol.sol
+        cdef int i = 0, n = len(self)
+        cdef Variable var
+
+        for i in range(n):
+            var = <Variable>self.vartuple[i]
+            res *= SCIPgetSolVal(scip_ptr, sol_ptr, var.scip_var)
+            if res == 0:  # early stop
+                return 0.0
+        return res
+
 
 CONST = Term()
 
@@ -144,7 +205,7 @@ def buildGenExprObj(expr):
                 sumexpr += coef * prodexpr
         return sumexpr
 
-    elif isinstance(expr, MatrixExpr):   
+    elif isinstance(expr, np.ndarray):   
         GenExprs = np.empty(expr.shape, dtype=object)
         for idx in np.ndindex(expr.shape):
             GenExprs[idx] = buildGenExprObj(expr[idx])
@@ -157,7 +218,7 @@ def buildGenExprObj(expr):
 ##@details Polynomial expressions of variables with operator overloading. \n
 #See also the @ref ExprDetails "description" in the expr.pxi. 
 cdef class Expr:
-    
+
     def __init__(self, terms=None):
         '''terms is a dict of variables to coefficients.
 
@@ -175,20 +236,12 @@ cdef class Expr:
     def __iter__(self):
         return iter(self.terms)
 
-    def __next__(self):
-        try: return next(self.terms)
-        except: raise StopIteration
-
     def __abs__(self):
         return abs(buildGenExprObj(self))
 
     def __add__(self, other):
         left = self
         right = other
-
-        if _is_number(self):
-            assert isinstance(other, Expr)
-            left,right = right,left
         terms = left.terms.copy()
 
         if isinstance(right, Expr):
@@ -200,7 +253,7 @@ cdef class Expr:
             terms[CONST] = terms.get(CONST, 0.0) + c
         elif isinstance(right, GenExpr):
             return buildGenExprObj(left) + right
-        elif isinstance(right, MatrixExpr):
+        elif isinstance(right, np.ndarray):
             return right + left
         else:
             raise TypeError(f"Unsupported type {type(right)}")
@@ -225,22 +278,35 @@ cdef class Expr:
         return self
 
     def __mul__(self, other):
-        if isinstance(other, MatrixExpr):
+        if isinstance(other, np.ndarray):
             return other * self
 
+        cdef dict res = {}
+        cdef Py_ssize_t pos1 = <Py_ssize_t>0, pos2 = <Py_ssize_t>0
+        cdef PyObject *k1_ptr = NULL
+        cdef PyObject *v1_ptr = NULL
+        cdef PyObject *k2_ptr = NULL
+        cdef PyObject *v2_ptr = NULL
+        cdef PyObject *old_v_ptr = NULL
+        cdef Term child
+        cdef double prod_v
+
         if _is_number(other):
             f = float(other)
             return Expr({v:f*c for v,c in self.terms.items()})
-        elif _is_number(self):
-            f = float(self)
-            return Expr({v:f*c for v,c in other.terms.items()})
+
         elif isinstance(other, Expr):
-            terms = {}
-            for v1, c1 in self.terms.items():
-                for v2, c2 in other.terms.items():
-                    v = v1 + v2
-                    terms[v] = terms.get(v, 0.0) + c1 * c2
-            return Expr(terms)
+            while PyDict_Next(self.terms, &pos1, &k1_ptr, &v1_ptr):
+                pos2 = <Py_ssize_t>0
+                while PyDict_Next(other.terms, &pos2, &k2_ptr, &v2_ptr):
+                    child = (<Term>k1_ptr) * (<Term>k2_ptr)
+                    prod_v = (<double>(<object>v1_ptr)) * (<double>(<object>v2_ptr))
+                    if (old_v_ptr := PyDict_GetItem(res, child)) != NULL:
+                        res[child] = <double>(<object>old_v_ptr) + prod_v
+                    else:
+                        res[child] = prod_v
+            return Expr(res)
+
         elif isinstance(other, GenExpr):
             return buildGenExprObj(self) * other
         else:
@@ -255,11 +321,7 @@ cdef class Expr:
 
     def __rtruediv__(self, other):
         ''' other / self '''
-        if _is_number(self):
-            f = 1.0/float(self)
-            return f * other
-        otherexpr = buildGenExprObj(other)
-        return otherexpr.__truediv__(self)
+        return buildGenExprObj(other) / self
 
     def __pow__(self, other, modulo):
         if float(other).is_integer() and other >= 0:
@@ -318,6 +380,20 @@ cdef class Expr:
         else:
             return max(len(v) for v in self.terms)
 
+    cpdef double _evaluate(self, Solution sol) except *:
+        cdef double res = 0
+        cdef Py_ssize_t pos = <Py_ssize_t>0
+        cdef PyObject* key_ptr
+        cdef PyObject* val_ptr
+        cdef Term term
+        cdef double coef
+
+        while PyDict_Next(self.terms, &pos, &key_ptr, &val_ptr):
+            term = <Term>key_ptr
+            coef = <double>(<object>val_ptr)
+            res += coef * term._evaluate(sol)
+        return res
+
 
 cdef class ExprCons:
     '''Constraints with a polynomial expressions and lower/upper bounds.'''
@@ -427,10 +503,10 @@ Operator = Op()
 #
 #See also the @ref ExprDetails "description" in the expr.pxi. 
 cdef class GenExpr:
+
     cdef public _op
     cdef public children
 
-
     def __init__(self): # do we need it
         ''' '''
 
@@ -438,7 +514,7 @@ cdef class GenExpr:
         return UnaryExpr(Operator.fabs, self)
 
     def __add__(self, other):
-        if isinstance(other, MatrixExpr):
+        if isinstance(other, np.ndarray):
             return other + self
 
         left = buildGenExprObj(self)
@@ -496,7 +572,7 @@ cdef class GenExpr:
     #    return self
 
     def __mul__(self, other):
-        if isinstance(other, MatrixExpr):
+        if isinstance(other, np.ndarray):
             return other * self
 
         left = buildGenExprObj(self)
@@ -610,6 +686,20 @@ cdef class GenExpr:
         '''returns operator of GenExpr'''
         return self._op
 
+    cdef GenExpr copy(self, bool copy = True):
+        cdef object cls = <type>Py_TYPE(self)
+        cdef GenExpr res = cls.__new__(cls)
+        res._op = self._op
+        res.children = self.children.copy() if copy else self.children
+        if cls is SumExpr:
+            (<SumExpr>res).constant = (<SumExpr>self).constant
+            (<SumExpr>res).coefs = (<SumExpr>self).coefs.copy() if copy else (<SumExpr>self).coefs
+        if cls is ProdExpr:
+            (<ProdExpr>res).constant = (<ProdExpr>self).constant
+        elif cls is PowExpr:
+            (<PowExpr>res).expo = (<PowExpr>self).expo
+        return res
+
 
 # Sum Expressions
 cdef class SumExpr(GenExpr):
@@ -625,44 +715,93 @@ cdef class SumExpr(GenExpr):
     def __repr__(self):
         return self._op + "(" + str(self.constant) + "," + ",".join(map(lambda child : child.__repr__(), self.children)) + ")"
 
+    cpdef double _evaluate(self, Solution sol) except *:
+        cdef double res = self.constant
+        cdef int i = 0, n = len(self.children)
+        cdef list children = self.children
+        cdef list coefs = self.coefs
+        for i in range(n):
+            res += <double>coefs[i] * (<GenExpr>children[i])._evaluate(sol)
+        return res
+
+
 # Prod Expressions
 cdef class ProdExpr(GenExpr):
+
     cdef public constant
+
     def __init__(self):
         self.constant = 1.0
         self.children = []
         self._op = Operator.prod
+
     def __repr__(self):
         return self._op + "(" + str(self.constant) + "," + ",".join(map(lambda child : child.__repr__(), self.children)) + ")"
 
+    cpdef double _evaluate(self, Solution sol) except *:
+        cdef double res = self.constant
+        cdef list children = self.children
+        cdef int i = 0, n = len(children)
+        for i in range(n):
+            res *= (<GenExpr>children[i])._evaluate(sol)
+            if res == 0:  # early stop
+                return 0.0
+        return res
+
+
 # Var Expressions
 cdef class VarExpr(GenExpr):
+
     cdef public var
+
     def __init__(self, var):
         self.children = [var]
         self._op = Operator.varidx
+
     def __repr__(self):
         return self.children[0].__repr__()
 
+    cpdef double _evaluate(self, Solution sol) except *:
+        return (<Expr>self.children[0])._evaluate(sol)
+
+
 # Pow Expressions
 cdef class PowExpr(GenExpr):
+
     cdef public expo
+
     def __init__(self):
         self.expo = 1.0
         self.children = []
         self._op = Operator.power
+
     def __repr__(self):
         return self._op + "(" + self.children[0].__repr__() + "," + str(self.expo) + ")"
 
+    cpdef double _evaluate(self, Solution sol) except *:
+        return (<GenExpr>self.children[0])._evaluate(sol) ** self.expo
+
+
 # Exp, Log, Sqrt, Sin, Cos Expressions
 cdef class UnaryExpr(GenExpr):
     def __init__(self, op, expr):
         self.children = []
         self.children.append(expr)
         self._op = op
+
+    def __abs__(self) -> UnaryExpr:
+        if self._op == "abs":
+            return <UnaryExpr>self.copy()
+        return UnaryExpr(Operator.fabs, self)
+
     def __repr__(self):
         return self._op + "(" + self.children[0].__repr__() + ")"
 
+    cpdef double _evaluate(self, Solution sol) except *:
+        cdef double res = (<GenExpr>self.children[0])._evaluate(sol)
+        return math.fabs(res) if self._op == "abs" else getattr(math, self._op)(res)
+
+
 # class for constant expressions
 cdef class Constant(GenExpr):
     cdef public number
@@ -673,6 +812,10 @@ cdef class Constant(GenExpr):
     def __repr__(self):
         return str(self.number)
 
+    cpdef double _evaluate(self, Solution sol) except *:
+        return self.number
+
+
 def exp(expr):
     """returns expression with exp-function"""
     if isinstance(expr, MatrixExpr):   

pyscipopt/heuristic.pxi

@@ -26,8 +26,7 @@ cdef class Heur:
 
     def heurexec(self, heurtiming, nodeinfeasible):
         '''should the heuristic the executed at the given depth, frequency, timing,...'''
-        print("python error in heurexec: this method needs to be implemented")
-        return {}
+        raise NotImplementedError("heurexec() is a fundamental callback and should be implemented in the derived class")
 
 
 

pyscipopt/iisfinder.pxi

@@ -33,4 +33,5 @@ cdef SCIP_RETCODE PyiisfinderExec (SCIP_IIS* iis, SCIP_IISFINDER* iisfinder, SCI
     PyIIS.iis._iis = iis
     result_dict = PyIIS.iisfinderexec()
     assert isinstance(result_dict, dict), "iisfinderexec() must return a dictionary."
+    result[0] = result_dict.get("result", <SCIP_RESULT>result[0])
     return SCIP_OKAY