Remove cmp() from compatibility

Author: flacjacket

sympy/core/basic.py

@@ -3,8 +3,8 @@
 from sympy.core.cache import cacheit
 from sympy.core.core import BasicType, C
 from sympy.core.sympify import _sympify, sympify, SympifyError
-from sympy.core.compatibility import (reduce, cmp, iterable,
-    Iterator, ordered, string_types, with_metaclass)
+from sympy.core.compatibility import (reduce, iterable, Iterator, ordered,
+    string_types, with_metaclass)
 from sympy.core.decorators import deprecated
 from sympy.core.singleton import S
 
@@ -172,16 +172,18 @@ def compare(self, other):
 
         """
         # all redefinitions of __cmp__ method should start with the
-        # following three lines:
+        # following lines:
         if self is other:
             return 0
-        c = cmp(self.__class__, other.__class__)
+        n1 = self.__class__
+        n2 = other.__class__
+        c = (n1 > n2) - (n1 < n2)
         if c:
             return c
         #
         st = self._hashable_content()
         ot = other._hashable_content()
-        c = cmp(len(st), len(ot))
+        c = (len(st) > len(ot)) - (len(st) < len(ot))
         if c:
             return c
         for l, r in zip(st, ot):
@@ -190,7 +192,7 @@ def compare(self, other):
             elif isinstance(l, frozenset):
                 c = 0
             else:
-                c = cmp(l, r)
+                c = (l > r) - (l < r)
             if c:
                 return c
         return 0
@@ -204,7 +206,9 @@ def _compare_pretty(a, b):
             return -1
 
         if a.is_Rational and b.is_Rational:
-            return cmp(a.p*b.q, b.p*a.q)
+            l = a.p * b.q
+            r = b.p * a.q
+            return (l > r) - (l < r)
         else:
             from sympy.core.symbol import Wild
             p1, p2, p3 = Wild("p1"), Wild("p2"), Wild("p3")
@@ -269,18 +273,13 @@ def compare_pretty(a, b):
         except SympifyError:
             pass
 
-        # both objects are non-SymPy
-        if (not isinstance(a, Basic)) and (not isinstance(b, Basic)):
-            return cmp(a, b)
-
-        if not isinstance(a, Basic):
-            return -1   # other < sympy
-
         if not isinstance(b, Basic):
             return +1   # sympy > other
 
         # now both objects are from SymPy, so we can proceed to usual comparison
-        return cmp(a.sort_key(), b.sort_key())
+        a = a.sort_key()
+        b = b.sort_key()
+        return (a > b) - (a < b)
 
     @classmethod
     def fromiter(cls, args, **assumptions):

sympy/core/compatibility.py

@@ -79,8 +79,6 @@ def u_decode(x):
     get_function_name = operator.attrgetter("__name__")
 
     import builtins
-    def cmp(a, b):
-        return (a > b) - (a < b)
     # This is done to make filter importable
     from functools import reduce
     from io import StringIO
@@ -113,7 +111,6 @@ def next(self):
     get_function_name = operator.attrgetter("func_name")
 
     import __builtin__ as builtins
-    cmp = cmp
     reduce = reduce
     from StringIO import StringIO
     from cStringIO import StringIO as cStringIO

sympy/core/core.py

@@ -1,6 +1,4 @@
 """ The core's core. """
-from sympy.core.compatibility import cmp
-
 # used for canonical ordering of symbolic sequences
 # via __cmp__ method:
 # FIXME this is *so* irrelevant and outdated!
@@ -108,8 +106,7 @@ def __cmp__(cls, other):
             return -1
         n1 = cls.__name__
         n2 = other.__name__
-        c = cmp(n1, n2)
-        if not c:
+        if n1 == n2:
             return 0
 
         UNKNOWN = len(ordering_of_classes) + 1
@@ -122,8 +119,8 @@ def __cmp__(cls, other):
         except ValueError:
             i2 = UNKNOWN
         if i1 == UNKNOWN and i2 == UNKNOWN:
-            return c
-        return cmp(i1, i2)
+            return (n1 > n2) - (n1 < n2)
+        return (i1 > i2) - (i1 < i2)
 
     def __lt__(cls, other):
         if cls.__cmp__(other) == -1:

sympy/core/logic.py

@@ -6,7 +6,7 @@
 at present this is mainly needed for facts.py , feel free however to improve
 this stuff for general purpose.
 """
-from sympy.core.compatibility import iterable, cmp
+from sympy.core.compatibility import iterable
 
 
 def fuzzy_bool(x):
@@ -128,10 +128,12 @@ def __lt__(cls, other):
 
     def __cmp__(a, b):
         if type(a) is not type(b):
-            return cmp( str(type(a)), str(type(b)) )
-
+            a = str(type(a))
+            b = str(type(b))
         else:
-            return cmp(a.args, b.args)
+            a = a.args
+            b = b.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/operations.py

@@ -2,7 +2,7 @@
 from sympy.core.sympify import _sympify, sympify
 from sympy.core.basic import Basic, _aresame
 from sympy.core.cache import cacheit
-from sympy.core.compatibility import cmp, ordered
+from sympy.core.compatibility import ordered
 from sympy.core.logic import fuzzy_and
 
 
@@ -469,4 +469,4 @@ def args(self):
 
     @staticmethod
     def _compare_pretty(a, b):
-        return cmp(str(a), str(b))
+        return (str(a) > str(b)) - (str(a) < str(b))

sympy/core/tests/test_logic.py

@@ -1,8 +1,6 @@
 from sympy.core.logic import fuzzy_not, Logic, And, Or, Not, fuzzy_and
 from sympy.utilities.pytest import raises
 
-from sympy.core.compatibility import cmp
-
 T = True
 F = False
 U = None
@@ -39,7 +37,6 @@ def test_logic_cmp():
     assert hash(l1) == hash(l2)
     assert (l1 == l2) == T
     assert (l1 != l2) == F
-    assert cmp(l1, l2) == 0
 
     assert And('a', 'b', 'c') == And('b', 'a', 'c')
     assert And('a', 'b', 'c') == And('c', 'b', 'a')

sympy/geometry/entity.py

@@ -7,7 +7,7 @@
 
 """
 
-from sympy.core.compatibility import cmp, is_sequence
+from sympy.core.compatibility import is_sequence
 from sympy.core.basic import Basic
 from sympy.core.sympify import sympify
 from sympy.functions import cos, sin
@@ -286,7 +286,7 @@ def __cmp__(self, other):
         """Comparison of two GeometryEntities."""
         n1 = self.__class__.__name__
         n2 = other.__class__.__name__
-        c = cmp(n1, n2)
+        c = (n1 > n2) - (n1 < n2)
         if not c:
             return 0
 
@@ -310,7 +310,7 @@ def __cmp__(self, other):
         if i2 == -1:
             return c
 
-        return cmp(i1, i2)
+        return (i1 > i2) - (i1 < i2)
 
     def __contains__(self, other):
         """Subclasses should implement this method for anything more complex than equality."""