Merge branch 'master' into expr/notimplemented

Author: Zeroto521

CHANGELOG.md

@@ -2,35 +2,44 @@
 
 ## Unreleased
 ### Added
+### Fixed
+### Changed
+- Return NotImplemented for `Expr` and `GenExpr` operators, if they can't handle input types in the calculation
+### Removed
+
+## 6.1.0 - 2026.01.31
+### Added
+- Support for SCIP 10.0.1
 - Added automated script for generating type stubs
 - Include parameter names in type stubs
-- Added pre-commit hook for automatic stub regeneration (see .pre-commit-config.yaml)
-- Wrapped isObjIntegral() and test
-- Added structured_optimization_trace recipe for structured optimization progress tracking
-- Added methods: getPrimalDualIntegral()
+- Added pre-commit hook for automatic stub regeneration (see `.pre-commit-config.yaml`)
+- Wrapped `isObjIntegral()` and test
+- Added `structured_optimization_trace` recipe for structured optimization progress tracking
+- Added methods: `getPrimalDualIntegral()`
+- `getSolVal()` supports `MatrixExpr` now
 ### Fixed
-- getBestSol() now returns None for infeasible problems instead of a Solution with NULL pointer
+- `getBestSol()` now returns `None` for infeasible problems instead of a `Solution` with `NULL` pointer
 - all fundamental callbacks now raise an error if not implemented
-- Fixed the type of MatrixExpr.sum(axis=...) result from MatrixVariable to MatrixExpr.
-- Updated IIS result in PyiisfinderExec()
-- Model.getVal now supports GenExpr type
-- Fixed lotsizing_lazy example
-- Fixed incorrect getVal() result when _bestSol.sol was outdated
-- Fixed segmentation fault when using Variable or Constraint objects after freeTransform() or Model destruction
+- Fixed the type of `MatrixExpr.sum(axis=...)` result from `MatrixVariable` to `MatrixExpr`.
+- Updated IIS result in `PyiisfinderExec()`
+- `Model.getVal` now supports `GenExpr` type
+- Fixed `lotsizing_lazy` example
+- Fixed incorrect `getVal()` result when `_bestSol.sol` was outdated
+- Fixed segmentation fault when using `Variable` or `Constraint` objects after `freeTransform()` or `Model` destruction
+- `getTermsQuadratic()` now correctly returns all linear terms
 ### Changed
-- changed default value of enablepricing flag to True
-- Speed up MatrixExpr.sum(axis=...) via quicksum
-- Speed up MatrixExpr.add.reduce via quicksum
-- Speed up np.ndarray(..., dtype=np.float64) @ MatrixExpr
-- Speed up Expr * Expr via C-level API and Term * Term
-- Speed up Term * Term via a $O(n)$ sort algorithm instead of Python $O(n\log(n))$ sorted function. `Term.__mul__` requires that Term.vartuple is sorted.
-- Rename from `Term.__add__` to `Term.__mul__`, due to this method only working with Expr * Expr.
-- MatrixExpr and MatrixExprCons use `__array_ufunc__` protocol to control all numpy.ufunc inputs and outputs
-- Set `__array_priority__` for MatrixExpr and MatrixExprCons
-- changed addConsNode() and addConsLocal() to mirror addCons() and accept ExprCons instead of Constraint
+- changed default value of `enablepricing` flag to `True`
+- Speed up `MatrixExpr.sum(axis=...)` via `quicksum`
+- Speed up `MatrixExpr.add.reduce` via `quicksum`
+- Speed up `np.ndarray(..., dtype=np.float64) @ MatrixExpr`
+- Speed up `Expr * Expr` via C-level API and `Term * Term`
+- Speed up `Term * Term` via a $O(n)$ sort algorithm instead of Python $O(n\log(n))$ sorted function. `Term.__mul__` requires that `Term.vartuple` is sorted.
+- Rename from `Term.__add__` to `Term.__mul__`, due to this method only working with `Expr * Expr`.
+- `MatrixExpr` and `MatrixExprCons` use `__array_ufunc__` protocol to control all `numpy.ufunc` inputs and outputs
+- Set `__array_priority__` for `MatrixExpr` and `MatrixExprCons`
+- changed `addConsNode()` and `addConsLocal()` to mirror `addCons()` and accept `ExprCons` instead of `Constraint`
 - Improved `chgReoptObjective()` performance
-- Return NotImplemented for Expr and GenExpr operators, if they can't handle input types in the calculation
-- Return itself for abs to UnaryExpr(Operator.fabs)
+- Return itself for `abs` to `UnaryExpr(Operator.fabs)`
 ### Removed
 
 ## 6.0.0 - 2025.11.28
@@ -115,7 +124,7 @@
 - Stopped tests from running in draft PRs
 ### Removed
 
-## 5.4.1 - 2024.02.24
+## 5.4.1 - 2025.02.24
 ### Added
 - Added option to get Lhs, Rhs of nonlinear constraints
 - Added cutoffNode and test

docs/build.rst

@@ -21,6 +21,8 @@ To download SCIP please either use the pre-built SCIP Optimization Suite availab
 
     * - SCIP
       - PySCIPOpt
+    * - 10.0.1
+      - 6.1
     * - 10.0.0
       - 6.0
     * - 9.2

pyproject.toml

@@ -11,17 +11,15 @@ authors = [
 dependencies = ['numpy >=1.16.0']
 requires-python = ">=3.8"
 readme = "README.md"
-license = {text = "MIT License"}
 classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Education",
     "Intended Audience :: Science/Research",
-    "License :: OSI Approved :: MIT License",
     "Programming Language :: Cython",
     "Programming Language :: Python :: 3",
     "Topic :: Scientific/Engineering :: Mathematics",
 ]
-dynamic = ["version"]
+dynamic = ["version", "license"]
 
 [project.urls]
 Homepage = "https://github.com/SCIP-Interfaces/PySCIPOpt"
@@ -51,9 +49,9 @@ AARCH=$(uname -m)
 echo "------"
 echo $AARCH
 if [[ $AARCH == "aarch64" ]]; then
-    wget https://github.com/scipopt/scipoptsuite-deploy/releases/download/v0.10.0/libscip-linux-arm.zip -O scip.zip
+    wget https://github.com/scipopt/scipoptsuite-deploy/releases/download/v0.11.0/libscip-linux-arm.zip -O scip.zip
 else
-    wget https://github.com/scipopt/scipoptsuite-deploy/releases/download/v0.10.0/libscip-linux.zip -O scip.zip
+    wget https://github.com/scipopt/scipoptsuite-deploy/releases/download/v0.11.0/libscip-linux.zip -O scip.zip
 fi
 unzip scip.zip
 mv scip_install scip
@@ -67,10 +65,10 @@ before-all = '''
 #!/bin/bash
 brew install wget zlib gcc
 if [[ $CIBW_ARCHS == *"arm"* ]]; then
-    wget https://github.com/scipopt/scipoptsuite-deploy/releases/download/v0.10.0/libscip-macos-arm.zip -O scip.zip
+    wget https://github.com/scipopt/scipoptsuite-deploy/releases/download/v0.11.0/libscip-macos-arm.zip -O scip.zip
     export MACOSX_DEPLOYMENT_TARGET=14.0
 else
-    wget https://github.com/scipopt/scipoptsuite-deploy/releases/download/v0.10.0/libscip-macos-intel.zip -O scip.zip
+    wget https://github.com/scipopt/scipoptsuite-deploy/releases/download/v0.11.0/libscip-macos-intel.zip -O scip.zip
     export MACOSX_DEPLOYMENT_TARGET=14.0
 fi
 unzip scip.zip
@@ -96,7 +94,7 @@ repair-wheel-command = '''
 skip="pp* cp36* cp37*"
 before-all = [
     "choco install 7zip wget",
-    "wget https://github.com/scipopt/scipoptsuite-deploy/releases/download/v0.10.0/libscip-windows.zip -O scip.zip",
+    "wget https://github.com/scipopt/scipoptsuite-deploy/releases/download/v0.11.0/libscip-windows.zip -O scip.zip",
     "\"C:\\Program Files\\7-Zip\\7z.exe\" x \"scip.zip\" -o\"scip-test\"",
     "mv .\\scip-test\\scip_install .\\test",
     "mv .\\test .\\scip"

setup.py

@@ -133,7 +133,7 @@
 
 setup(
     name="PySCIPOpt",
-    version="6.0.0",
+    version="6.1.0",
     description="Python interface and modeling environment for SCIP",
     long_description=long_description,
     long_description_content_type="text/markdown",

src/pyscipopt/_version.py

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

src/pyscipopt/scip.pxi

@@ -1098,7 +1098,16 @@ cdef class Solution:
         sol.scip = scip
         return sol
 
-    def __getitem__(self, expr: Union[Expr, MatrixExpr]):
+    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}"
+            )
+
         self._checkStage("SCIPgetSolVal")
         return expr._evaluate(self)
 
@@ -8299,8 +8308,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
@@ -8319,6 +8336,7 @@ cdef class Model:
         cdef int nbilinterms
 
         # quadratic terms
+        cdef SCIP_EXPR* quadexpr
         cdef SCIP_EXPR* sqrexpr
         cdef SCIP_Real sqrcoef
         cdef int nquadterms
@@ -8331,33 +8349,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 = 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 = 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 = self._getOrCreateVar(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)
 
@@ -10967,75 +11001,63 @@ cdef class Model:
     def getSolVal(
         self,
         Solution sol,
-        expr: Union[Expr, GenExpr],
+        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
         -----
         A variable is also an expression.
 
         """
-        if not isinstance(expr, (Expr, GenExpr)):
-            raise TypeError(
-                "Argument 'expr' has incorrect type (expected 'Expr' or 'GenExpr', "
-                f"got {type(expr)})"
-            )
         # no need to create a NULL solution wrapper in case we have a variable
         return (sol or Solution.create(self._scip, NULL))[expr]
 
-    def getVal(self, expr: Union[Expr, GenExpr, 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, GenExpr or MatrixExpr
+            Expression to query the value of.
 
         Returns
         -------
-        float
+        float or np.ndarray
 
         Notes
         -----
         A variable is also an expression.
 
         """
-        cdef SCIP_SOL* current_best_sol
-
-        stage_check = SCIPgetStage(self._scip) not in [SCIP_STAGE_INIT, SCIP_STAGE_FREE]
-        if not stage_check:
+        if SCIPgetStage(self._scip) in {SCIP_STAGE_INIT, SCIP_STAGE_FREE}:
             raise Warning("Method cannot be called in stage ", self.getStage())
 
         # Ensure _bestSol is up-to-date (cheap pointer comparison)
-        current_best_sol = SCIPgetBestSol(self._scip)
+        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)
 
         if self._bestSol.sol == NULL and SCIPgetStage(self._scip) != SCIP_STAGE_SOLVING:
             raise Warning("No solution available")
 
-        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)
-
-        return result
+        return self._bestSol[expr]
 
     def hasPrimalRay(self):
         """