correct handling of purely linear and bilinear terms

Author: Joao-Dionisio

src/pyscipopt/scip.pxi

@@ -5887,13 +5887,6 @@ cdef class Model:
 
         PyCons = Constraint.create(scip_cons)
 
-        # Store the original polynomial expression on the constraint so that
-        # helpers such as getTermsQuadratic can reconstruct full linear terms
-        # even if SCIP's internal quadratic representation does not expose
-        # all linear coefficients explicitly.
-        if PyCons.data is None:
-            PyCons.data = quadcons.expr
-
         return PyCons
 
     def _createConsNonlinear(self, cons, **kwargs):
@@ -8310,14 +8303,13 @@ cdef class Model:
             Triples ``(var1, var2, coef)`` for terms of the form
             ``coef * var1 * var2`` with ``var1 != var2``.
         quadterms : list of tuple
-            Triples ``(var, sqrcoef, lincoef)`` corresponding to diagonal
-            quadratic terms of the form ``sqrcoef * var**2`` and the linear
-            coefficient ``lincoef`` associated with the same variable when it
-            also appears linearly in the quadratic part.
+            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 all variables with a nonzero linear
-            coefficient in the constraint, including variables that also
-            appear in quadratic or bilinear terms.
+            Pairs ``(var, coef)`` for purely linear variables, i.e.,
+            variables that do not participate in any quadratic or bilinear term.
 
         """
         cdef SCIP_EXPR* expr
@@ -8336,6 +8328,7 @@ cdef class Model:
         cdef int nbilinterms
 
         # quadratic terms
+        cdef SCIP_EXPR* quadexpr
         cdef SCIP_EXPR* sqrexpr
         cdef SCIP_Real sqrcoef
         cdef int nquadterms
@@ -8353,28 +8346,44 @@ cdef class Model:
 
         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:
+                    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 = [(entry[0], entry[1], entry[2]) for entry in quaddict.values()]
 
         return (bilinterms, quadterms, linterms)
 

tests/test_nonlinear.py

@@ -311,18 +311,19 @@ def test_quad_coeffs_mixed_linear_and_quadratic():
 
     bilinterms, quadterms, linterms = scip.getTermsQuadratic(cons)
 
-    # Linear part: getTermsQuadratic must report all linear coefficients,
-    # including those of variables that also appear quadratically or
-    # bilinearly.
+    # linterms contains only purely linear variables (not in any quadratic/bilinear term)
     lin_only = {v.name: c for (v, c) in linterms}
     assert lin_only["var4"] == 8
-    assert lin_only["var3"] == 4
-    assert lin_only["var2"] == -5
-    # var1 has no linear component and must not appear in linterms
-    assert "var1" not in lin_only or lin_only.get("var1", 0.0) == 0.0
+    assert len(linterms) == 1  # only var4 is purely linear
 
-    # For completeness, checking if the coefficients from reconstructing the full linear
-    # coefficients from both linterms and quadterms match
+    # quadterms contains all variables that appear in quadratic/bilinear terms,
+    # with both their squared coefficient and linear coefficient
+    quad_dict = {v.name: (sqrcoef, lincoef) for v, sqrcoef, lincoef in quadterms}
+    assert quad_dict["var3"] == (6.0, 4.0)   # 6*var3^2 + 4*var3
+    assert quad_dict["var1"] == (-3.0, 0.0)  # -3*var1^2, no linear term
+    assert quad_dict["var2"] == (0.0, -5.0)  # -5*var2, no squared term
+
+    # Verify we can reconstruct all linear coefficients by combining linterms and quadterms
     full_lin = {}
     for v, c in linterms:
         full_lin[v.name] = full_lin.get(v.name, 0.0) + c