Merge pull request #1185 from mathics/ExactNumber-comparisions

Exact number comparisions

Author: rocky

mathics/builtin/comparison.py

@@ -2,11 +2,12 @@
 # -*- coding: utf-8 -*-
 
 
+from mathics.version import __version__  # noqa used in loading to check consistency.
+
 import itertools
 from typing import Optional, Union
 
 import sympy
-from mathics.version import __version__  # noqa used in loading to check consistency.
 
 from mathics.builtin.base import (
     BinaryOperator,
@@ -21,6 +22,7 @@
     Expression,
     Integer,
     Number,
+    Real,
     String,
     Symbol,
     SymbolFalse,
@@ -32,6 +34,9 @@ def cmp(a, b) -> int:
     "Returns 0 if a == b, -1 if a < b and 1 if a > b"
     return (a > b) - (a < b)
 
+def is_number(sympy_value) -> bool:
+    return hasattr(sympy_value, "is_number") or isinstance(sympy_value, sympy.Float)
+
 class SameQ(BinaryOperator):
     """
     <dl>
@@ -231,17 +236,30 @@ def do_compare(self, l1, l2) -> Union[bool, None]:
                     return result
             return True
 
+        # Use Mathics' built-in comparisons for Real and Integer. These use
+        # WL's interpretation of Equal[] which allows for slop in Reals
+        # in the least significant digit of precision, while for Integers, comparison
+        # has to be exact.
+
+        if ((isinstance(l1, Real) and isinstance(l2, Real)) or
+            (isinstance(l1, Integer) and isinstance(l2, Integer))):
+                return l1 == l2
+
+        # For everything else, use sympy.
+
         l1_sympy = l1.to_sympy(evaluate=True, prec=COMPARE_PREC)
         l2_sympy = l2.to_sympy(evaluate=True, prec=COMPARE_PREC)
 
         if l1_sympy is None or l2_sympy is None:
             return None
 
-        if not hasattr(l1_sympy, "is_number"):
+
+        if not is_number(l1_sympy):
             l1_sympy = mp_convert_constant(l1_sympy, prec=COMPARE_PREC)
-        if not hasattr(l2_sympy, "is_number"):
+        if not is_number(l2_sympy):
             l2_sympy = mp_convert_constant(l2_sympy, prec=COMPARE_PREC)
 
+
         if l1_sympy.is_number and l2_sympy.is_number:
             # assert min_prec(l1, l2) is None
             prec = COMPARE_PREC  # TODO: Use $MaxExtraPrecision
@@ -254,8 +272,12 @@ def do_compare(self, l1, l2) -> Union[bool, None]:
     def apply(self, items, evaluation):
         "%(name)s[items___]"
         items_sequence = items.get_sequence()
-        if len(items_sequence) <= 1:
+        n = len(items_sequence)
+        if n <= 1:
             return SymbolTrue
+        is_exact_vals = [Expression("ExactNumberQ", arg).evaluate(evaluation) for arg in items_sequence]
+        if all(val == SymbolTrue for val in is_exact_vals):
+            return self.apply_other(items, evaluation)
         args = self.numerify_args(items, evaluation)
         wanted = operators[self.get_name()]
         for x, y in itertools.combinations(args, 2):
@@ -274,7 +296,7 @@ def apply(self, items, evaluation):
         return SymbolTrue
 
     def apply_other(self, args, evaluation):
-        "%(name)s[args___?(!RealNumberQ[#]&)]"
+        "%(name)s[args___?(!ExactNumberQ[#]&)]"
         args = args.get_sequence()
         for x, y in itertools.combinations(args, 2):
             c = self.do_compare(x, y)
@@ -285,6 +307,7 @@ def apply_other(self, args, evaluation):
         return SymbolTrue
 
 
+
 class _ComparisonOperator(_InequalityOperator):
     "Compares arguments in a chain e.g. a < b < c compares a < b and b < c."
 
@@ -355,7 +378,6 @@ def apply(self, items, evaluation):
             ]
             return Expression("And", *groups)
 
-
 def do_cmp(x1, x2) -> Optional[int]:
 
     # don't attempt to compare complex numbers
@@ -369,8 +391,10 @@ def do_cmp(x1, x2) -> Optional[int]:
     s1 = x1.to_sympy()
     s2 = x2.to_sympy()
 
-    # use internal comparisons only for Reals
-    # and use sympy for everything else
+    # Use internal comparisons only for Real which is uses
+    # WL's interpretation of equal (which allows for slop
+    # in the least significant digit of precision), and use
+    # use sympy for everything else
     if s1.is_Float and s2.is_Float:
         if x1 == x2:
             return 0
@@ -450,8 +474,9 @@ class Equal(_EqualityOperator, SympyComparison):
     ## TODO Needs power precision tracking
     ## >> 0.1 ^ 10000 == 0.1 ^ 10000 + 0.1 ^ 10012
     ##  = False
-    ## >> 0.1 ^ 10000 == 0.1 ^ 10000 + 0.1 ^ 10013
-    ##  = True
+
+    #> 0.1 ^ 10000 == 0.1 ^ 10000 + 0.1 ^ 10013
+      = True
 
     #> 0.1111111111111111 ==  0.1111111111111126
      = True

mathics/core/expression.py

@@ -2352,7 +2352,7 @@ def __new__(cls, value) -> "MachineReal":
     def to_python(self, *args, **kwargs) -> float:
         return self.value
 
-    def to_sympy(self):
+    def to_sympy(self, *args, **kwargs):
         return sympy.Float(self.value)
 
     def to_mpmath(self):
@@ -2427,7 +2427,7 @@ def __new__(cls, value) -> "PrecisionReal":
     def to_python(self, *args, **kwargs):
         return float(self.value)
 
-    def to_sympy(self):
+    def to_sympy(self, *args, **kwargs):
         return self.value
 
     def to_mpmath(self):

test/test_compare.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+from .helper import check_evaluation
+
+def test_compare():
+    for str_expr, str_expected in (
+        (
+            "I == I",
+            "True",
+        ),
+        (
+            "I == 0",
+            "False",
+        ),
+        (
+            "I + 0 == 1 I - 0",
+            "True",
+        ),
+        (
+            "I + 5 == I",
+            "False",
+        ),
+    ):
+        check_evaluation(str_expr, str_expected)