Deprecated Term.ptrtuple and speed up Term.__eq__ (#1184)

* Deprecated `Term.ptrtuple`

Remove the separate ptrtuple from Term and switch sorting/merging to use each Variable's hash instead of a ptr() tuple. Compute Term.hashval from vartuple directly and implement a robust __eq__ that checks identity, type, length, hashval and then element-wise variable identity. In Variable, expose __hash__ returning the underlying scip_var pointer and make ptr() delegate to that hash. Update the .pyi stub to drop the now-removed ptrtuple. These changes simplify Term state and unify ordering/identity on Variable hashes (pointer-based).

* Changelog: Term __eq__ speedup, ptrtuple deprecated

Update CHANGELOG.md to record a performance improvement: Term.__eq__ was sped up using the C-level API, and to note that Term.ptrtuple is deprecated to enable Term memory optimizations.

* Add rich comparison to Variable

Implement __richcmp__ in Variable (src/pyscipopt/scip.pxi) to delegate rich-comparison operations to _expr_richcmp, enabling Python comparison operators between Variable and other Expr objects.

* tests: add term equality tests for expressions

Import quickprod and add test_term_eq to verify term equality/inequality behavior. The new test creates terms from quickprod over a matrix variable and checks that identical terms compare equal, different terms (even of same length) compare unequal, terms of different lengths are unequal, and comparison with a different type returns False. This ensures Expr term __eq__ semantics are correct.

* Use hash comparison for variable equality in Term

Replace identity check with hash comparison when comparing variables in Term equality. Using hash(var) != hash(var) instead of `is not` avoids false negatives when two distinct Python wrapper objects represent the same underlying variable, ensuring Term comparisons treat equivalent variables as equal. This relies on Variable.__hash__ to reflect variable identity.

* Apply AI suggestion

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Improve Term.__eq__ type check

Remove the strict Cython annotation on the __eq__ parameter and replace the Python-level type() check with a C-level Py_TYPE check. Also normalize the identity check order. These changes make the equality method more robust and slightly faster by avoiding a Python call for type comparison and allowing broader input types during runtime.

* Promote Term changes to top of CHANGELOG

Move two entries about Term optimizations out of the 6.1.0 section and into the top-level changelog sections: "Speed up Term.__eq__ via the C-level API" (Changed) and "Removed Term.ptrtuple to optimize Term memory usage" (Removed). This removes duplicate lines from 6.1.0 and surfaces these changes for the upcoming release.

* Remove return type annotations in scip.pxi

warning: src\pyscipopt\scip.pxi:1564:21: Unknown type declaration 'Py_ssize_t' in annotation, ignoring

* Drop `Variable.__hash__`

* Hash Term by tuple of variable pointers

hash(iteration) isn't fixed value

---------

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

Author: 3 people

CHANGELOG.md

@@ -10,8 +10,10 @@
 - Fixed stubtest failures with mypy 1.20 by marking dunder method parameters as positional-only
 ### Changed
 - Speed up `constant * Expr` via C-level API
+- Speed up `Term.__eq__` via the C-level API
 ### Removed
 - Removed outdated warning about Make build system incompatibility
+- Removed `Term.ptrtuple` to optimize `Term` memory usage
 
 ## 6.1.0 - 2026.01.31
 ### Added

src/pyscipopt/expr.pxi

@@ -104,22 +104,37 @@ cdef class Term:
     '''This is a monomial term'''
 
     cdef readonly tuple vartuple
-    cdef readonly tuple ptrtuple
     cdef Py_ssize_t hashval
 
     def __init__(self, *vartuple: Variable):
         self.vartuple = tuple(sorted(vartuple, key=lambda v: v.getIndex()))
-        self.ptrtuple = tuple(v.ptr() for v in self.vartuple)
-        self.hashval = <Py_ssize_t>hash(self.ptrtuple)
+        self.hashval = <Py_ssize_t>hash(tuple(v.ptr() for v in self.vartuple))
 
     def __getitem__(self, idx):
         return self.vartuple[idx]
 
     def __hash__(self) -> Py_ssize_t:
         return self.hashval
 
-    def __eq__(self, other: Term):
-        return self.ptrtuple == other.ptrtuple
+    def __eq__(self, other) -> bool:
+        if other is self:
+            return True
+        if <type>Py_TYPE(other) is not Term:
+            return False
+
+        cdef int n = len(self)
+        cdef Term _other = <Term>other
+        if n != len(_other) or self.hashval != _other.hashval:
+            return False
+
+        cdef int i
+        cdef Variable var1, var2
+        for i in range(n):
+            var1 = <Variable>PyTuple_GET_ITEM(self.vartuple, i)
+            var2 = <Variable>PyTuple_GET_ITEM(_other.vartuple, i)
+            if var1.ptr() != var2.ptr():
+                return False
+        return True
 
     def __len__(self):
         return len(self.vartuple)
@@ -156,8 +171,7 @@ cdef class Term:
 
         cdef Term res = Term.__new__(Term)
         res.vartuple = tuple(vartuple)
-        res.ptrtuple = tuple(v.ptr() for v in res.vartuple)
-        res.hashval = <Py_ssize_t>hash(res.ptrtuple)
+        res.hashval = <Py_ssize_t>hash(tuple(v.ptr() for v in res.vartuple))
         return res
 
     def __repr__(self):

src/pyscipopt/scip.pxi

@@ -1565,7 +1565,6 @@ cdef class Variable(Expr):
             return cname.decode('utf-8')
 
     def ptr(self):
-        """ """
         return <size_t>(self.scip_var)
 
     def __repr__(self):

src/pyscipopt/scip.pyi

@@ -2202,7 +2202,6 @@ class SumExpr(GenExpr):
 
 @disjoint_base
 class Term:
-    ptrtuple: Incomplete
     vartuple: Incomplete
     def __init__(self, *vartuple: Incomplete) -> None: ...
     def __mul__(self, other: Term, /) -> Term: ...

tests/test_expr.py

@@ -2,7 +2,7 @@
 
 import pytest
 
-from pyscipopt import Model, sqrt, log, exp, sin, cos
+from pyscipopt import Model, sqrt, log, exp, sin, cos, quickprod
 from pyscipopt.scip import Expr, GenExpr, ExprCons, CONST
 
 
@@ -249,3 +249,24 @@ def test_abs_abs_expr():
 
     # should print abs(x) not abs(abs(x))
     assert str(abs(abs(x))) == str(abs(x))
+
+
+def test_term_eq():
+    m = Model()
+
+    x = m.addMatrixVar(1000)
+    y = m.addVar()
+    z = m.addVar()
+
+    e1 = quickprod(x.flat)
+    e2 = quickprod(x.flat)
+    t1 = next(iter(e1))
+    t2 = next(iter(e2))
+    t3 = next(iter(e1 * y))
+    t4 = next(iter(e2 * z))
+
+    assert t1 == t1  # same term
+    assert t1 == t2  # same term
+    assert t3 != t4  # same length, but different term
+    assert t1 != t3  # different length
+    assert t1 != "not a term"  # different type