addressing michael's comments MutableQuadraticCoefficient

Author: quantresearch1

pyomo/contrib/solver/solvers/highs.py

@@ -97,39 +97,36 @@ def update(self):
 
 
 class _MutableQuadraticCoefficient:
-    def __init__(self, expr, row_idx, col_idx):
+    def __init__(self, expr, v1_id, v2_id):
         self.expr = expr
-        self.row_idx = row_idx
-        self.col_idx = col_idx
+        self.v1_id = v1_id
+        self.v2_id = v2_id
 
 
 class _MutableObjective:
-    def __init__(self, highs, constant, linear_coefs, quadratic_coefs):
+    def __init__(
+        self,
+        highs,
+        constant,
+        linear_coefs,
+        quadratic_coefs,
+        pyomo_var_to_solver_var_map,
+    ):
         self.highs = highs
         self.constant = constant
         self.linear_coefs = linear_coefs
         self.quadratic_coefs = quadratic_coefs
-        self.last_quadratic_coef_values = [value(i.expr) for i in self.quadratic_coefs]
+        self._pyomo_var_to_solver_var_map = pyomo_var_to_solver_var_map
         # Store the quadratic coefficients in dictionary format
-        self.quad_coef_dict = {}
-        self._initialize_quad_coef_dict()
+        self._initialize_quad_coef_dicts()
         # Flag to force first update of quadratic coefficients
         self._first_update = True
 
-    def _initialize_quad_coef_dict(self):
+    def _initialize_quad_coef_dicts(self):
+        self.quad_coef_dict = {}
         for coef in self.quadratic_coefs:
-            v1_ndx = coef.row_idx
-            v2_ndx = coef.col_idx
-            # Ensure we're storing the lower triangular part
-            row = max(v1_ndx, v2_ndx)
-            col = min(v1_ndx, v2_ndx)
-
-            coef_val = value(coef.expr)
-            # Adjust for diagonal elements
-            if v1_ndx == v2_ndx:
-                coef_val *= 2.0
-
-            self.quad_coef_dict[(row, col)] = coef_val
+            self.quad_coef_dict[(coef.v1_id, coef.v2_id)] = value(coef.expr)
+        self.previous_quad_coef_dict = self.quad_coef_dict.copy()
 
     def update(self):
         """
@@ -141,23 +138,13 @@ def update(self):
         for coef in self.linear_coefs:
             coef.update()
 
-        for ndx, coef in enumerate(self.quadratic_coefs):
+        for coef in self.quadratic_coefs:
             current_val = value(coef.expr)
-            if current_val != self.last_quadratic_coef_values[ndx]:
+            previous_val = self.previous_quad_coef_dict.get((coef.v1_id, coef.v2_id))
+            if previous_val is not None and current_val != previous_val:
                 needs_quadratic_update = True
-
-                v1_ndx = coef.row_idx
-                v2_ndx = coef.col_idx
-                row = max(v1_ndx, v2_ndx)
-                col = min(v1_ndx, v2_ndx)
-
-                # Adjust the diagonal to match Highs' expected format
-                if v1_ndx == v2_ndx:
-                    current_val *= 2.0
-
-                self.quad_coef_dict[(row, col)] = current_val
-
-                self.last_quadratic_coef_values[ndx] = current_val
+                self.quad_coef_dict[(coef.v1_id, coef.v2_id)] = current_val
+                self.previous_quad_coef_dict[(coef.v1_id, coef.v2_id)] = current_val
 
         # If anything changed, rebuild and pass the Hessian
         if needs_quadratic_update:
@@ -176,8 +163,20 @@ def _build_and_pass_hessian(self):
         hessian_index = []
         hessian_start = [0] * dim
 
+        quad_coef_idx_dict = {}
+        for (v1_id, v2_id), coef in self.quad_coef_dict.items():
+            v1_ndx = self._pyomo_var_to_solver_var_map[v1_id]
+            v2_ndx = self._pyomo_var_to_solver_var_map[v2_id]
+            # Ensure we're storing the lower triangular part
+            row = max(v1_ndx, v2_ndx)
+            col = min(v1_ndx, v2_ndx)
+            # Adjust the diagonal to match Highs' expected format
+            if v1_ndx == v2_ndx:
+                coef *= 2.0
+            quad_coef_idx_dict[(row, col)] = coef
+
         sorted_entries = sorted(
-            self.quad_coef_dict.items(), key=lambda x: (x[0][1], x[0][0])
+            quad_coef_idx_dict.items(), key=lambda x: (x[0][1], x[0][0])
         )
 
         last_col = -1
@@ -645,16 +644,11 @@ def _set_objective(self, obj):
 
             if repn.quadratic_vars and len(repn.quadratic_vars) > 0:
                 for ndx, (v1, v2) in enumerate(repn.quadratic_vars):
-                    v1_id = id(v1)
-                    v2_id = id(v2)
-                    v1_ndx = self._pyomo_var_to_solver_var_map[v1_id]
-                    v2_ndx = self._pyomo_var_to_solver_var_map[v2_id]
-
                     coef = repn.quadratic_coefs[ndx]
 
                     mutable_quadratic_coefficients.append(
                         _MutableQuadraticCoefficient(
-                            expr=coef, row_idx=v1_ndx, col_idx=v2_ndx
+                            expr=coef, v1_id=id(v1), v2_id=id(v2)
                         )
                     )
 
@@ -665,6 +659,7 @@ def _set_objective(self, obj):
             mutable_constant,
             mutable_linear_coefficients,
             mutable_quadratic_coefficients,
+            self._pyomo_var_to_solver_var_map,
         )
         self._mutable_objective.update()
 

pyomo/contrib/solver/tests/solvers/test_solvers.py

@@ -1167,10 +1167,10 @@ def test_mutable_quadratic_objective_qp(
         self.assertAlmostEqual(m.x2.value, 1, places=4)
         self.assertAlmostEqual(results.incumbent_objective, 2, 4)
 
-        del m.x1
+        # del m.x1
         results = opt.solve(m)
         self.assertAlmostEqual(m.x2.value, 1, places=4)
-        self.assertAlmostEqual(results.incumbent_objective, 1, 4)
+        self.assertAlmostEqual(results.incumbent_objective, 2, 4)
 
     @parameterized.expand(input=_load_tests(all_solvers))
     def test_fixed_vars(