PySCIPOpt 6.0.0__cp314-cp314t-win_amd64.whl → 6.1.0__cp314-cp314t-win_amd64.whl

pyscipopt/matrix.pxi

@@ -1,112 +1,255 @@
-"""
-# TODO Cythonize things. Improve performance.
-# TODO Add tests
-"""
-
+import operator
+from typing import Literal, Optional, Tuple, Union
 import numpy as np
-from typing import Union
+try:
+    # NumPy 2.x location
+    from numpy.lib.array_utils import normalize_axis_tuple
+except ImportError:
+    # Fallback for NumPy 1.x
+    from numpy.core.numeric import normalize_axis_tuple
 
+cimport numpy as cnp
+from pyscipopt.scip cimport Expr, Solution
 
-def _is_number(e):
-    try:
-        f = float(e)
-        return True
-    except ValueError: # for malformed strings
-        return False
-    except TypeError: # for other types (Variable, Expr)
-        return False
+cnp.import_array()
 
 
-def _matrixexpr_richcmp(self, other, op):
-    def _richcmp(self, other, op):
-        if op == 1: # <=
-            return self.__le__(other)
-        elif op == 5: # >=
-            return self.__ge__(other)
-        elif op == 2: # ==
-            return self.__eq__(other)
-        else:
-            raise NotImplementedError("Can only support constraints with '<=', '>=', or '=='.")
+class MatrixExpr(np.ndarray):
 
-    if _is_number(other) or isinstance(other, Expr):
-        res = np.empty(self.shape, dtype=object)
-        res.flat = [_richcmp(i, other, op) for i in self.flat]
+    __array_priority__ = 100
 
-    elif isinstance(other, np.ndarray):
-        out = np.broadcast(self, other)
-        res = np.empty(out.shape, dtype=object)
-        res.flat = [_richcmp(i, j, op) for i, j in out]
+    def __array_ufunc__(
+        self,
+        ufunc: np.ufunc,
+        method: Literal["__call__", "reduce", "reduceat", "accumulate", "outer", "at"],
+        *args,
+        **kwargs,
+    ):
+        """
+        Customizes the behavior of NumPy ufuncs for MatrixExpr.
 
-    else:
-        raise TypeError(f"Unsupported type {type(other)}")
+        Parameters
+        ----------
+        ufunc : numpy.ufunc
+            The ufunc object that was called.
 
-    return res.view(MatrixExprCons)
+        method : {"__call__", "reduce", "reduceat", "accumulate", "outer", "at"}
+            A string indicating which ufunc method was called.
 
+        *args : tuple
+            The input arguments to the ufunc.
+
+        **kwargs : dict
+            Additional keyword arguments to the ufunc.
+
+        Returns
+        -------
+        Expr, MatrixExpr
+            The result of the ufunc operation is wrapped back into a MatrixExpr if
+            applicable.
 
-class MatrixExpr(np.ndarray):
-    def sum(self, **kwargs):
-        """
-        Based on `numpy.ndarray.sum`, but returns a scalar if `axis=None`.
-        This is useful for matrix expressions to compare with a matrix or a scalar.
         """
+        res = NotImplemented
+        # Unboxing MatrixExpr to stop __array_ufunc__ recursion
+        args = tuple(_ensure_array(arg) for arg in args)
+        if method == "reduce":  # Handle reduction operations, e.g., np.sum(a)
+            if ufunc is np.add:
+                res = _core_sum(args[0], **kwargs)
+
+        if method == "__call__":  # Standard ufunc call, e.g., np.add(a, b)
+            if ufunc in {np.matmul, np.dot}:
+                res = _core_dot(args[0], args[1])
+            elif ufunc is np.less_equal:
+                return _vec_le(args[0], args[1]).view(MatrixExprCons)
+            elif ufunc is np.greater_equal:
+                return _vec_ge(args[0], args[1]).view(MatrixExprCons)
+            elif ufunc is np.equal:
+                return _vec_eq(args[0], args[1]).view(MatrixExprCons)
+            elif ufunc in {np.less, np.greater, np.not_equal}:
+                raise NotImplementedError("can only support '<=', '>=', or '=='")
+
+        if res is NotImplemented:
+            if "out" in kwargs: # Unboxing MatrixExpr to stop __array_ufunc__ recursion
+                kwargs["out"] = tuple(_ensure_array(arg, False) for arg in kwargs["out"])
+            res = super().__array_ufunc__(ufunc, method, *args, **kwargs)
+        return res.view(MatrixExpr) if isinstance(res, np.ndarray) else res
+
+    def _evaluate(self, Solution sol) -> NDArray[np.float64]:
+        return _vec_evaluate(self, sol).view(np.ndarray)
 
-        if kwargs.get("axis") is None:
-            # Speed up `.sum()` #1070
-            return quicksum(self.flat)
-        return super().sum(**kwargs)
-
-    def __le__(self, other: Union[float, int, "Expr", np.ndarray, "MatrixExpr"]) -> MatrixExprCons:
-        return _matrixexpr_richcmp(self, other, 1)
-
-    def __ge__(self, other: Union[float, int, "Expr", np.ndarray, "MatrixExpr"]) -> MatrixExprCons:
-        return _matrixexpr_richcmp(self, other, 5)
-
-    def __eq__(self, other: Union[float, int, "Expr", np.ndarray, "MatrixExpr"]) -> MatrixExprCons:
-        return _matrixexpr_richcmp(self, other, 2)
-
-    def __add__(self, other):
-        return super().__add__(other).view(MatrixExpr)
-    
-    def __iadd__(self, other):
-        return super().__iadd__(other).view(MatrixExpr)
-
-    def __mul__(self, other):
-        return super().__mul__(other).view(MatrixExpr)
-
-    def __truediv__(self, other):
-        return super().__truediv__(other).view(MatrixExpr)
-    
-    def __rtruediv__(self, other):
-        return super().__rtruediv__(other).view(MatrixExpr)
-        
-    def __pow__(self, other):
-        return super().__pow__(other).view(MatrixExpr)
-    
-    def __sub__(self, other):
-        return super().__sub__(other).view(MatrixExpr)
-    
-    def __radd__(self, other):
-        return super().__radd__(other).view(MatrixExpr)
-    
-    def __rmul__(self, other):
-        return super().__rmul__(other).view(MatrixExpr)
-    
-    def __rsub__(self, other):
-        return super().__rsub__(other).view(MatrixExpr)
-
-    def __matmul__(self, other):
-        return super().__matmul__(other).view(MatrixExpr)
 
 class MatrixGenExpr(MatrixExpr):
     pass
 
-class MatrixExprCons(np.ndarray):
 
-    def __le__(self, other: Union[float, int, np.ndarray]) -> MatrixExprCons:
-        return _matrixexpr_richcmp(self, other, 1)
-
-    def __ge__(self, other: Union[float, int, np.ndarray]) -> MatrixExprCons:
-        return _matrixexpr_richcmp(self, other, 5)
+class MatrixExprCons(np.ndarray):
 
-    def __eq__(self, other):
-        raise NotImplementedError("Cannot compare MatrixExprCons with '=='.")
+    __array_priority__ = 101
+
+    def __array_ufunc__(self, ufunc, method, *args, **kwargs):
+        if method == "__call__":
+            args = tuple(_ensure_array(arg) for arg in args)
+            if ufunc is np.less_equal:
+                return _vec_le(args[0], args[1]).view(MatrixExprCons)
+            elif ufunc is np.greater_equal:
+                return _vec_ge(args[0], args[1]).view(MatrixExprCons)
+        raise NotImplementedError("can only support '<=' or '>='")
+
+    def __eq__(self, _):
+        # TODO: Once numpy version >= 2.x, remove `__eq__`, as it will be handled by
+        # `__array_ufunc__`.
+        raise NotImplementedError("can only support '<=' or '>='")
+
+
+_vec_le = np.frompyfunc(operator.le, 2, 1)
+_vec_ge = np.frompyfunc(operator.ge, 2, 1)
+_vec_eq = np.frompyfunc(operator.eq, 2, 1)
+_vec_evaluate = np.frompyfunc(lambda expr, sol: expr._evaluate(sol), 2, 1)
+
+
+cdef inline _ensure_array(arg, bint convert_scalar = True):
+    if isinstance(arg, np.ndarray):
+        return arg.view(np.ndarray)
+    elif isinstance(arg, (list, tuple)):
+        return np.asarray(arg)
+    return np.array(arg, dtype=object) if convert_scalar else arg
+
+
+def _core_dot(cnp.ndarray a, cnp.ndarray b) -> Union[Expr, np.ndarray]:
+    """
+    Perform matrix multiplication between a N-Demension constant array and a N-Demension
+    `np.ndarray` of type `object` and containing `Expr` objects.
+
+    Parameters
+    ----------
+    a : np.ndarray
+        A constant n-d `np.ndarray` of type `np.float64`.
+
+    b : np.ndarray
+        A n-d `np.ndarray` of type `object` and containing `Expr` objects.
+
+    Returns
+    -------
+    Expr or np.ndarray
+        If both `a` and `b` are 1-D arrays, return an `Expr`, otherwise return a
+        `np.ndarray` of type `object` and containing `Expr` objects.
+    """
+    cdef bint a_is_1d = a.ndim == 1
+    cdef bint b_is_1d = b.ndim == 1
+    cdef cnp.ndarray a_nd = a[..., np.newaxis, :] if a_is_1d else a
+    cdef cnp.ndarray b_nd = b[..., :, np.newaxis] if b_is_1d else b
+    cdef bint a_is_num = a_nd.dtype.kind in "fiub"
+
+    if a_is_num ^ (b_nd.dtype.kind in "fiub"):
+        res = _core_dot_nd(a_nd, b_nd) if a_is_num else _core_dot_nd(b_nd.T, a_nd.T).T
+        if a_is_1d and b_is_1d:
+            return res.item()
+        if a_is_1d:
+            return res.reshape(np.delete(res.shape, -2))
+        if b_is_1d:
+            return res.reshape(np.delete(res.shape, -1))
+        return res
+    return NotImplemented
+
+
+def _core_dot_2d(cnp.ndarray a, cnp.ndarray x) -> np.ndarray:
+    """
+    Perform matrix multiplication between a 2-Demension constant array and a 2-Demension
+    `np.ndarray` of type `object` and containing `Expr` objects.
+
+    Parameters
+    ----------
+    a : np.ndarray
+        A 2-D `np.ndarray` of type `np.float64`.
+
+    x : np.ndarray
+        A 2-D `np.ndarray` of type `object` and containing `Expr` objects.
+
+    Returns
+    -------
+    np.ndarray
+        A 2-D `np.ndarray` of type `object` and containing `Expr` objects.
+    """
+    if not a.flags.c_contiguous or a.dtype != np.float64:
+        a = np.ascontiguousarray(a, dtype=np.float64)
+
+    cdef const double[:, :] a_view = a
+    cdef int m = a.shape[0], k = x.shape[1]
+    cdef cnp.ndarray[object, ndim=2] res = np.zeros((m, k), dtype=object)
+    cdef Py_ssize_t[:] nonzero
+    cdef int i, j, idx
+
+    for i in range(m):
+        if (nonzero := np.flatnonzero(a_view[i, :])).size == 0:
+            continue
+
+        for j in range(k):
+            res[i, j] = quicksum(a_view[i, idx] * x[idx, j] for idx in nonzero)
+
+    return res
+
+
+_core_dot_nd = np.vectorize(
+    _core_dot_2d,
+    otypes=[object],
+    signature="(m,n),(n,p)->(m,p)",
+)
+
+
+def _core_sum(
+    cnp.ndarray a,
+    axis: Optional[Union[int, Tuple[int, ...]]] = None,
+    keepdims: bool = False,
+    **kwargs,
+) -> Union[Expr, np.ndarray]:
+    """
+    Return the sum of the array elements over the given axis.
+
+    Parameters
+    ----------
+    a : np.ndarray
+        A `np.ndarray` of type `object` and containing `Expr` objects.
+
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which a sum is performed. The default, axis=None, will
+        sum all of the elements of the input array. If axis is negative it counts
+        from the last to the first axis. If axis is a tuple of ints, a sum is
+        performed on all of the axes specified in the tuple instead of a single axis
+        or all the axes as before.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left in the result as
+        dimensions with size one. With this option, the result will broadcast
+        correctly against the input array.
+
+    **kwargs : ignored
+        Additional keyword arguments are ignored. They exist for compatibility
+        with `numpy.ndarray.sum`.
+
+    Returns
+    -------
+    Expr or np.ndarray
+        If the sum is performed over all axes, return an Expr, otherwise return
+        a np.ndarray.
+
+    """
+    axis: Tuple[int, ...] = normalize_axis_tuple(
+        range(a.ndim) if axis is None else axis, a.ndim
+    )
+    if len(axis) == a.ndim:
+        res = quicksum(a.flat)
+        return (
+            np.array([res], dtype=object).reshape([1] * a.ndim)
+            if keepdims
+            else res
+        )
+
+    keep_axes = tuple(i for i in range(a.ndim) if i not in axis)
+    shape = (
+        tuple(1 if i in axis else a.shape[i] for i in range(a.ndim))
+        if keepdims
+        else tuple(a.shape[i] for i in keep_axes)
+    )
+    return np.apply_along_axis(
+        quicksum, -1, a.transpose(keep_axes + axis).reshape(shape + (-1,))
+    )

pyscipopt/presol.pxi

@@ -25,8 +25,7 @@ cdef class Presol:
 
     def presolexec(self, nrounds, presoltiming):
         '''executes presolver'''
-        print("python error in presolexec: this method needs to be implemented")
-        return {}
+        raise NotImplementedError("presolexec() is a fundamental callback and should be implemented in the derived class")
 
 
 

pyscipopt/propagator.pxi

@@ -37,13 +37,11 @@ cdef class Prop:
 
     def propexec(self, proptiming):
         '''calls execution method of propagator'''
-        print("python error in propexec: this method needs to be implemented")
-        return {}
+        raise NotImplementedError("propexec() is a fundamental callback and should be implemented in the derived class")
 
     def propresprop(self, confvar, inferinfo, bdtype, relaxedbd):
         '''resolves the given conflicting bound, that was reduced by the given propagator'''
-        print("python error in propresprop: this method needs to be implemented")
-        return {}
+        raise NotImplementedError("propresprop() is a fundamental callback and should be implemented in the derived class")
 
 
 

pyscipopt/recipes/getLocalConss.py

@@ -24,7 +24,7 @@ def getLocalConss(model: Model, node = None) -> List[List[Constraint]]:
     else:
         cur_node = node
 
-    added_conss = []
+    added_conss: List[Constraint] = []
     while cur_node is not None:
         added_conss = cur_node.getAddedConss() + added_conss
         cur_node = cur_node.getParent()

pyscipopt/recipes/primal_dual_evolution.py

@@ -15,31 +15,24 @@ def attach_primal_dual_evolution_eventhdlr(model: Model):
 
         def eventinit(self): # we want to collect best primal solutions and best dual solutions
             self.model.catchEvent(SCIP_EVENTTYPE.BESTSOLFOUND, self)
-            self.model.catchEvent(SCIP_EVENTTYPE.LPSOLVED, self)
-            self.model.catchEvent(SCIP_EVENTTYPE.NODESOLVED, self)
-            
+            self.model.catchEvent(SCIP_EVENTTYPE.DUALBOUNDIMPROVED, self)
 
         def eventexec(self, event):
             # if a new best primal solution was found, we save when it was found and also its objective
             if event.getType() == SCIP_EVENTTYPE.BESTSOLFOUND:
                 self.model.data["primal_log"].append([self.model.getSolvingTime(), self.model.getPrimalbound()])
             
-            if not self.model.data["dual_log"]:
-                self.model.data["dual_log"].append([self.model.getSolvingTime(), self.model.getDualbound()])
-            
-            if self.model.getObjectiveSense() == "minimize":
-                if self.model.isGT(self.model.getDualbound(), self.model.data["dual_log"][-1][1]):
-                    self.model.data["dual_log"].append([self.model.getSolvingTime(), self.model.getDualbound()])
-            else:
-                if self.model.isLT(self.model.getDualbound(), self.model.data["dual_log"][-1][1]):
-                    self.model.data["dual_log"].append([self.model.getSolvingTime(), self.model.getDualbound()])
-                    
+            if event.getType() == SCIP_EVENTTYPE.DUALBOUNDIMPROVED:
+                self.model.data["dual_log"].append([self.model.getSolvingTime(), self.model.getDualbound()])                    
 
     if not hasattr(model, "data") or model.data==None:
         model.data = {}
 
-    model.data["primal_log"] = []
-    model.data["dual_log"] = []
+    model.data.update({
+            'primal_log': [],
+            'dual_log': []
+            })
+
     hdlr = GapEventhdlr()
     model.includeEventhdlr(hdlr, "gapEventHandler", "Event handler which collects primal and dual solution evolution")
 

pyscipopt/recipes/structured_optimization_trace.py

@@ -0,0 +1,37 @@
+from pyscipopt import SCIP_EVENTTYPE, Eventhdlr, Model
+
+
+def attach_structured_optimization_trace(model: Model):
+    """
+    Attaches an event handler that records optimization progress in structured JSONL format.
+
+    Args:
+        model: SCIP Model
+    """
+
+    class _TraceEventhdlr(Eventhdlr):
+        def eventinit(self):
+            self.model.catchEvent(SCIP_EVENTTYPE.BESTSOLFOUND, self)
+            self.model.catchEvent(SCIP_EVENTTYPE.DUALBOUNDIMPROVED, self)
+
+        def eventexec(self, event):
+            record = {
+                "time": self.model.getSolvingTime(),
+                "primalbound": self.model.getPrimalbound(),
+                "dualbound": self.model.getDualbound(),
+                "gap": self.model.getGap(),
+                "nodes": self.model.getNNodes(),
+                "nsol": self.model.getNSols(),
+            }
+            self.model.data["trace"].append(record)
+
+    if not hasattr(model, "data") or model.data is None:
+        model.data = {}
+    model.data["trace"] = []
+
+    hdlr = _TraceEventhdlr()
+    model.includeEventhdlr(
+        hdlr, "structured_trace", "Structured optimization trace handler"
+    )
+
+    return model

pyscipopt/scip.pxd

@@ -737,6 +737,7 @@ cdef extern from "scip/scip.h":
     SCIP_Real SCIPepsilon(SCIP* scip)
     SCIP_Real SCIPfeastol(SCIP* scip)
     SCIP_RETCODE SCIPsetObjIntegral(SCIP* scip)
+    SCIP_Bool SCIPisObjIntegral(SCIP* scip)
     SCIP_Real SCIPgetLocalOrigEstimate(SCIP* scip)
     SCIP_Real SCIPgetLocalTransEstimate(SCIP* scip)
 
@@ -870,6 +871,18 @@ cdef extern from "scip/scip.h":
     SCIP_Longint SCIPvarGetNBranchingsCurrentRun(SCIP_VAR* var, SCIP_BRANCHDIR dir)
     SCIP_Bool SCIPvarMayRoundUp(SCIP_VAR* var)
     SCIP_Bool SCIPvarMayRoundDown(SCIP_VAR* var)
+    SCIP_Bool SCIPvarIsActive(SCIP_VAR* var)
+    SCIP_Real SCIPadjustedVarLb(SCIP* scip, SCIP_VAR* var, SCIP_Real lb)
+    SCIP_Real SCIPadjustedVarUb(SCIP* scip, SCIP_VAR* var, SCIP_Real ub)
+    SCIP_RETCODE SCIPaggregateVars(SCIP* scip,
+                                   SCIP_VAR* varx,
+                                   SCIP_VAR* vary,
+                                   SCIP_Real scalarx,
+                                   SCIP_Real scalary,
+                                   SCIP_Real rhs,
+                                   SCIP_Bool* infeasible,
+                                   SCIP_Bool* redundant,
+                                   SCIP_Bool* aggregated)
 
     # LP Methods
     SCIP_RETCODE SCIPgetLPColsData(SCIP* scip, SCIP_COL*** cols, int* ncols)
@@ -1472,6 +1485,7 @@ cdef extern from "scip/scip.h":
     int SCIPgetPlungeDepth(SCIP* scip)
     SCIP_Longint SCIPgetNNodeLPIterations(SCIP* scip)
     SCIP_Longint SCIPgetNStrongbranchLPIterations(SCIP* scip)
+    SCIP_Real SCIPgetPrimalDualIntegral(SCIP* scip)
 
     # Parameter Functions
     SCIP_RETCODE SCIPsetBoolParam(SCIP* scip, char* name, SCIP_Bool value)
@@ -2110,6 +2124,8 @@ cdef extern from "tpi/tpi.h":
 cdef class Expr:
     cdef public terms
 
+    cpdef double _evaluate(self, Solution sol)
+
 cdef class Event:
     cdef SCIP_EVENT* event
     # can be used to store problem data
@@ -2222,12 +2238,17 @@ cdef class Model:
     cdef SCIP_Bool _freescip
     # map to store python variables
     cdef _modelvars
+    # map to store python constraints
+    cdef _modelconss
     # used to keep track of the number of event handlers generated
     cdef int _generated_event_handlers_count
     # store references to Benders subproblem Models for proper cleanup
     cdef _benders_subproblems
     # store iis, if found
     cdef SCIP_IIS* _iis
+    # helper methods for later var and cons cleanup
+    cdef _getOrCreateCons(self, SCIP_CONS* scip_cons)
+    cdef _getOrCreateVar(self, SCIP_VAR* scip_var)
 
     @staticmethod
     cdef create(SCIP* scip)