Merge pull request #28484 from merintheres/remove-cmp

Remove leftover Python 2 __cmp__ references

Author: oscarbenjamin

sympy/core/basic.py

@@ -389,7 +389,7 @@ def compare(self, other):
         1
 
         """
-        # all redefinitions of __cmp__ method should start with the
+        # all redefinitions of compare method should start with the
         # following lines:
         if self is other:
             return 0

sympy/core/logic.py

@@ -246,20 +246,6 @@ def __ne__(a, b):
         else:
             return a.args != b.args
 
-    def __lt__(self, other):
-        if self.__cmp__(other) == -1:
-            return True
-        return False
-
-    def __cmp__(self, other):
-        if type(self) is not type(other):
-            a = str(type(self))
-            b = str(type(other))
-        else:
-            a = self.args
-            b = other.args
-        return (a > b) - (a < b)
-
     def __str__(self):
         return '%s(%s)' % (self.__class__.__name__,
                            ', '.join(str(a) for a in self.args))

sympy/core/tests/test_logic.py

@@ -63,23 +63,6 @@ def test_fuzzy_or():
     raises(TypeError, lambda: fuzzy_or())
 
 
-def test_logic_cmp():
-    l1 = And('a', Not('b'))
-    l2 = And('a', Not('b'))
-
-    assert hash(l1) == hash(l2)
-    assert (l1 == l2) == T
-    assert (l1 != l2) == F
-
-    assert And('a', 'b', 'c') == And('b', 'a', 'c')
-    assert And('a', 'b', 'c') == And('c', 'b', 'a')
-    assert And('a', 'b', 'c') == And('c', 'a', 'b')
-
-    assert Not('a') < Not('b')
-    assert (Not('b') < Not('a')) is False
-    assert (Not('a') < 2) is False
-
-
 def test_logic_onearg():
     assert And() is True
     assert Or() is False

sympy/geometry/entity.py

@@ -39,7 +39,7 @@
 from sympy.utilities.iterables import is_sequence
 
 
-# How entities are ordered; used by __cmp__ in GeometryEntity
+# How entities are ordered; used for comparison in GeometryEntity
 ordering_of_classes = [
     "Point2D",
     "Point3D",
@@ -78,36 +78,6 @@ class GeometryEntity(Basic, EvalfMixin):
 
     __slots__: tuple[str, ...] = ()
 
-    def __cmp__(self, other):
-        """Comparison of two GeometryEntities."""
-        n1 = self.__class__.__name__
-        n2 = other.__class__.__name__
-        c = (n1 > n2) - (n1 < n2)
-        if not c:
-            return 0
-
-        i1 = -1
-        for cls in self.__class__.__mro__:
-            try:
-                i1 = ordering_of_classes.index(cls.__name__)
-                break
-            except ValueError:
-                i1 = -1
-        if i1 == -1:
-            return c
-
-        i2 = -1
-        for cls in other.__class__.__mro__:
-            try:
-                i2 = ordering_of_classes.index(cls.__name__)
-                break
-            except ValueError:
-                i2 = -1
-        if i2 == -1:
-            return c
-
-        return (i1 > i2) - (i1 < i2)
-
     def __contains__(self, other):
         """Subclasses should implement this method for anything more complex than equality."""
         if type(self) is type(other):

sympy/geometry/tests/test_ellipse.py

@@ -116,8 +116,6 @@ def test_ellipse_geom():
     assert hash(c1) == hash(Circle(Point(1, 0), Point(0, 1), Point(0, -1)))
     assert c1 in e1
     assert (Line(p1, p2) in e1) is False
-    assert e1.__cmp__(e1) == 0
-    assert e1.__cmp__(Point(0, 0)) > 0
 
     # Encloses
     assert e1.encloses(Segment(Point(-0.5, -0.5), Point(0.5, 0.5))) is True

sympy/physics/quantum/anticommutator.py

@@ -31,7 +31,7 @@ class AntiCommutator(Expr):
 
     Canonical ordering of an anticommutator is ``{A, B}`` for ``A < B``. The
     arguments of the anticommutator are put into canonical order using
-    ``__cmp__``. If ``B < A``, then ``{A, B}`` is returned as ``{B, A}``.
+    comparison operators. If ``B < A``, then ``{A, B}`` is returned as ``{B, A}``.
 
     Parameters
     ==========

sympy/physics/quantum/commutator.py

@@ -32,7 +32,7 @@ class returns the commutator in an unevaluated form. To evaluate the
     commutator, use the ``.doit()`` method.
 
     Canonical ordering of a commutator is ``[A, B]`` for ``A < B``. The
-    arguments of the commutator are put into canonical order using ``__cmp__``.
+    arguments of the commutator are put into canonical order using comparison operators.
     If ``B < A``, then ``[B, A]`` is returned as ``-[A, B]``.
 
     Parameters

sympy/physics/secondquant.py

@@ -1655,7 +1655,7 @@ class Commutator(Function):
     """
     The Commutator:  [A, B] = A*B - B*A
 
-    The arguments are ordered according to .__cmp__()
+    The arguments are ordered according to comparison operators
 
     Examples
     ========