improve chgReoptObjective performance (#1178)

* improve chgReoptObjective performance

* add type check

* use _VarArray and minimize changes compares to master

---------

Co-authored-by: João Dionísio <57299939+Joao-Dionisio@users.noreply.github.com>

Author: a-schmitt

CHANGELOG.md

@@ -25,6 +25,7 @@
 - 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
 ### Removed
 
 ## 6.0.0 - 2025.11.28

src/pyscipopt/scip.pxi

@@ -11852,12 +11852,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')
 
@@ -11866,7 +11866,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
 
@@ -11884,24 +11883,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):

tests/test_reopt.py

@@ -1,17 +1,17 @@
 import unittest
-from pyscipopt import Model
+from pyscipopt import Model, quicksum, Expr
+
 
 class ReoptimizationTest(unittest.TestCase):
 
     def test_reopt(self):
-
+        """Test basic reoptimization."""
         m = Model()
         m.enableReoptimization()
 
         x = m.addVar(name="x", ub=5)
         y = m.addVar(name="y", lb=-2, ub=10)
 
-
         m.addCons(2 * x + y >= 8)
         m.setObjective(x + y)
         m.optimize()
@@ -31,6 +31,70 @@ def test_reopt(self):
         self.assertEqual(m.getVal(x), 3.0)
         self.assertEqual(m.getVal(y), 3.0)
 
+    def test_reopt_maximize(self):
+        """Test reoptimization with maximize sense."""
+        m = Model()
+        m.enableReoptimization()
+        m.hideOutput()
+
+        x = m.addVar(name="x", lb=0, ub=10)
+        y = m.addVar(name="y", lb=0, ub=10)
+
+        m.addCons(x + y <= 15)
+        m.setObjective(x + y, sense="maximize")
+        m.optimize()
+
+        self.assertAlmostEqual(m.getObjVal(), 15.0)
+
+        m.freeReoptSolve()
+        m.chgReoptObjective(x, sense="maximize")
+        m.optimize()
+
+        self.assertAlmostEqual(m.getVal(x), 10.0)
+
+    def test_reopt_many_variables_sparse_objective(self):
+        """Test with many variables but only few in the new objective."""
+        m = Model()
+        m.enableReoptimization()
+        m.hideOutput()
+
+        n_vars = 100
+        vars = [m.addVar(name=f"x_{i}", lb=0, ub=10) for i in range(n_vars)]
+
+        m.addCons(quicksum(vars) >= 50)
+        m.setObjective(quicksum(vars))
+        m.optimize()
+
+        m.freeReoptSolve()
+        m.chgReoptObjective(vars[0] + vars[50] + vars[99])
+        m.optimize()
+
+        self.assertAlmostEqual(m.getVal(vars[0]), 0.0)
+        self.assertAlmostEqual(m.getVal(vars[50]), 0.0)
+        self.assertAlmostEqual(m.getVal(vars[99]), 0.0)
+
+    def test_reopt_zero_objective(self):
+        """Test reoptimization with zero objective (no variables, all coefficients zero)."""
+        m = Model()
+        m.enableReoptimization()
+        m.hideOutput()
+
+        x = m.addVar(name="x", lb=0, ub=10)
+        y = m.addVar(name="y", lb=0, ub=10)
+
+        m.addCons(x + y >= 5)
+        m.setObjective(x + y)
+        m.optimize()
+
+        self.assertAlmostEqual(m.getObjVal(), 5.0)
+
+        m.freeReoptSolve()
+        m.chgReoptObjective(Expr())
+        m.optimize()
+
+        self.assertGreaterEqual(m.getVal(x) + m.getVal(y), 5.0)
+        self.assertAlmostEqual(m.getObjVal(), 0.0)
+
 
 if __name__ == '__main__':
     unittest.main()