Speed up -Expr, -SumExpr, -ProdExpr and -Constant

[Zeroto521]

Use a C-level to speed up Expr.__neg__, ProdExpr.__neg, and Constant.__neg__.
Expr is 1.3x faster than before,SumExpr is 2.1x faster than before, and ProdExpr is 4.9x faster than before.

• Optimized before
  • -Expr time: 0.51s
  • -SumExpr time: 1.38s
  • -ProdExpr time: 1.39s
• Optimized after
  • -Expr time: 0.39s
  • -SumExpr time: 0.64s
  • -ProdExpr time: 0.28s

from timeit import timeit

from pyscipopt import Model, sin


m = Model()
x = m.addVar("x")
y = m.addVar("y")

expr = (x + 1) ** 3
sumexpr = sin(x) + x + y + 1
prodexpr = sumexpr * -42
print(f"Expr: {expr}")
# Expr: Expr({Term(x, x, x): 1.0, Term(x, x): 3.0, Term(x): 3.0, Term(): 1.0})
print(f"SumExpr: {sumexpr}")
# SumExpr: sum(1.0,sin(sum(0.0,prod(1.0,x))),prod(1.0,x),prod(1.0,y))
print(f"ProdExpr: {prodexpr}")
# ProdExpr: prod(-42.0,sum(1.0,sin(sum(0.0,prod(1.0,x))),prod(1.0,x),prod(1.0,y)))

n = 1000000
print(f"-Expr time: {timeit(lambda: -expr, number=n):.2f}s")
print(f"-SumExpr time: {timeit(lambda: -sumexpr, number=n):.2f}s")
print(f"-ProdExpr time: {timeit(lambda: -prodexpr, number=n):.2f}s")

[Copilot]

Pull request overview

This PR aims to speed up expression negation by moving __neg__ implementations to faster C-level loops for core expression types.

Changes:

• Optimized Expr.__neg__ by iterating the underlying term dictionary using CPython C-API helpers.
• Added specialized __neg__ implementations for SumExpr and ProdExpr (including new GenExpr.copy helper).
• Added a new unit test covering negation behavior for ProdExpr and SumExpr, and refined type stubs for __neg__.

Reviewed changes

Copilot reviewed 4 out of 4 changed files in this pull request and generated 3 comments.

File	Description
tests/test_expr.py	Adds a test_neg test validating negation results/types for product and sum expressions.
src/pyscipopt/scip.pyi	Tightens typing for __neg__ on Expr and GenExpr.
src/pyscipopt/expr.pxi	Implements faster negation paths and introduces GenExpr.copy; changes SumExpr.coefs storage to array('d').

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Zeroto521]

@Joao-Dionisio Could you have a loop about this problem? SumExpr.coefs has a bug, so this CI failed.
If SumExpr.coefs is not [1, 1], the result from expr_to_array to addCons won't be right.

All GenExpr will use the expr_to_array function to add to SCIP. But expr_to_array doesn't have any code to handle SumExpr.coefs. SumExpr.coefs doesn't work at all.

PySCIPOpt/src/pyscipopt/expr.pxi

Lines 829 to 849 in bc24757

	def expr_to_array(expr, nodes):
	"""adds expression to array"""
	op = expr._op
	if op == Operator.const: # FIXME: constant expr should also have children!
	nodes.append(tuple([op, [expr.number]]))
	elif op != Operator.varidx:
	indices = []
	nchildren = len(expr.children)
	for child in expr.children:
	pos = expr_to_array(child, nodes) # position of child in the final array of nodes, 'nodes'
	indices.append(pos)
	if op == Operator.power:
	pos = value_to_array(expr.expo, nodes)
	indices.append(pos)
	elif (op == Operator.add and expr.constant != 0.0) or (op == Operator.prod and expr.constant != 1.0):
	pos = value_to_array(expr.constant, nodes)
	indices.append(pos)
	nodes.append( tuple( [op, indices] ) )
	else: # var
	nodes.append( tuple( [op, expr.children] ) )
	return len(nodes) - 1

Two solutions to fix this.

• Remove SumExpr.coefs. Any coefficient to a SumExpr will be a ProdExpr. And each element coefficient should be 1. We follow current behavior. So, SumExpr.coefs related codes could be removed.
• Let expr_to_array support SumExpr.coefs.