Speed up constant * Expr (#1185)

* Speed up `constant * Expr`

Replace local prod_v with coef and refactor the numeric-scaling branch to iterate with PyDict_Next instead of a Python dict comprehension. Reuse coef for the product of term coefficients in the Expr * Expr branch and update res assignments accordingly. This simplifies the code and avoids creating intermediate Python dicts during scaling, improving clarity and likely performance.

* Document speedup for constant * Expr

Add a line to CHANGELOG.md noting a performance improvement: "Speed up `constant * Expr` via C-level API". This documents an optimization that accelerates multiplication of constants by Expr using the C-level API for the upcoming 6.0.0 release.

* Add tests for Expr multiplication

Extend tests/test_expr.py (test_mul) to cover multiplication of Expr by a scalar and mark Expr*Expr cases. Adds an assertion verifying (x + y) * 2.0 produces the expected string representation and a comment indicating Expr * Expr tests.

* Add test for scalar * Expr multiplication

Add an assertion in tests/test_expr.py to verify left-side scalar multiplication works: assert str(2.0 * (x + y)) == "Expr({Term(x): 2.0, Term(y): 2.0})". This ensures that multiplying an Expr by a scalar on the left yields the same result and string representation as Expr * scalar.

* Merge branch 'master' into expr/__mul__

---------

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

Author: Zeroto521

CHANGELOG.md

@@ -8,6 +8,7 @@
 - Removed `Py_INCREF`/`Py_DECREF` on `Model` in `catchEvent`/`dropEvent` that caused memory leak for imbalanced usage
 - Used `getIndex()` instead of `ptr()` for sorting nonlinear expression terms to avoid nondeterministic behavior 
 ### Changed
+- Speed up `constant * Expr` via C-level API
 ### Removed
 - Removed outdated warning about Make build system incompatibility
 

src/pyscipopt/expr.pxi

@@ -289,22 +289,24 @@ cdef class Expr:
         cdef PyObject *v2_ptr = NULL
         cdef PyObject *old_v_ptr = NULL
         cdef Term child
-        cdef double prod_v
+        cdef double coef
 
         if _is_number(other):
-            f = float(other)
-            return Expr({v:f*c for v,c in self.terms.items()})
+            coef = float(other)
+            while PyDict_Next(self.terms, &pos1, &k1_ptr, &v1_ptr):
+                res[<Term>k1_ptr] = <double>(<object>v1_ptr) * coef
+            return Expr(res)
 
         elif isinstance(other, Expr):
             while PyDict_Next(self.terms, &pos1, &k1_ptr, &v1_ptr):
                 pos2 = <Py_ssize_t>0
                 while PyDict_Next(other.terms, &pos2, &k2_ptr, &v2_ptr):
                     child = (<Term>k1_ptr) * (<Term>k2_ptr)
-                    prod_v = (<double>(<object>v1_ptr)) * (<double>(<object>v2_ptr))
+                    coef = (<double>(<object>v1_ptr)) * (<double>(<object>v2_ptr))
                     if (old_v_ptr := PyDict_GetItem(res, child)) != NULL:
-                        res[child] = <double>(<object>old_v_ptr) + prod_v
+                        res[child] = <double>(<object>old_v_ptr) + coef
                     else:
-                        res[child] = prod_v
+                        res[child] = coef
             return Expr(res)
 
         elif isinstance(other, GenExpr):

tests/test_expr.py

@@ -224,6 +224,11 @@ def test_mul():
     x = m.addVar(name="x")
     y = m.addVar(name="y")
 
+    # test Expr * number
+    assert str((x + y) * 2.0) == "Expr({Term(x): 2.0, Term(y): 2.0})"
+    assert str(2.0 * (x + y)) == "Expr({Term(x): 2.0, Term(y): 2.0})"
+
+    # test Expr * Expr
     assert str(Expr({CONST: 1.0}) * x) == "Expr({Term(x): 1.0})"
     assert str(y * Expr({CONST: -1.0})) == "Expr({Term(y): -1.0})"
     assert str((x - x) * y) == "Expr({Term(x, y): 0.0})"