Merge remote-tracking branch 'upstream/master'

Author: bdlucas1

mathics/builtin/drawing/plot.py

@@ -29,6 +29,7 @@
 from mathics.core.symbols import Symbol, SymbolList
 from mathics.core.systemsymbols import (
     SymbolAll,
+    SymbolAutomatic,
     SymbolBlack,
     SymbolEdgeForm,
     SymbolFull,
@@ -260,43 +261,53 @@ def eval(self, functions, x, start, stop, evaluation: Evaluation, options: dict)
 
         # Mesh Option
         mesh_option = self.get_option(options, "Mesh", evaluation)
-        mesh = mesh_option.to_python()
-        if mesh not in ["System`None", "System`Full", "System`All"]:
+        if mesh_option not in (SymbolNone, SymbolFull, SymbolAll):
             evaluation.message("Mesh", "ilevels", mesh_option)
             mesh = "System`None"
+        else:
+            mesh = mesh_option.to_python()
 
         # PlotPoints Option
         plotpoints_option = self.get_option(options, "PlotPoints", evaluation)
-        plotpoints = plotpoints_option.to_python()
-        if plotpoints == "System`None":
+        if plotpoints_option is SymbolNone:
             plotpoints = 57
+        else:
+            plotpoints = plotpoints_option.to_python()
         if not (isinstance(plotpoints, int) and plotpoints >= 2):
             evaluation.message(self.get_name(), "ppts", plotpoints)
             return
 
         # MaxRecursion Option
         max_recursion_limit = 15
         maxrecursion_option = self.get_option(options, "MaxRecursion", evaluation)
-        maxrecursion = maxrecursion_option.to_python()
+
+        # Investigate whether the maxrecursion value is optimal. Bruce
+        # Lucas observes that in some cases, using more points and
+        # decreasing recursion is faster and gives better results.
+        # Note that the tradeoff may be different for Plot versus
+        # Plot3D. Recursive subdivision in Plot3D is probably a lot
+        # harder.
+        maxrecursion = 3
+
         try:
-            if maxrecursion == "System`Automatic":
-                maxrecursion = 3
-            elif maxrecursion == float("inf"):
-                maxrecursion = max_recursion_limit
-                raise ValueError
-            elif isinstance(maxrecursion, int):
-                if maxrecursion > max_recursion_limit:
+            if maxrecursion_option is not SymbolAutomatic:
+                maxrecursion = maxrecursion_option.to_python()
+                if maxrecursion == float("inf"):
                     maxrecursion = max_recursion_limit
                     raise ValueError
-                if maxrecursion < 0:
+                elif isinstance(maxrecursion, int):
+                    if maxrecursion > max_recursion_limit:
+                        maxrecursion = max_recursion_limit
+                        raise ValueError
+                    if maxrecursion < 0:
+                        maxrecursion = 0
+                        raise ValueError
+                else:
                     maxrecursion = 0
                     raise ValueError
-            else:
-                maxrecursion = 0
-                raise ValueError
         except ValueError:
             evaluation.message(
-                self.get_name(), "invmaxrec", maxrecursion, max_recursion_limit
+                self.get_name(), "invmaxrec", maxrecursion_option, max_recursion_limit
             )
         assert isinstance(maxrecursion, int)
 
@@ -312,22 +323,23 @@ def check_exclusion(excl):
             return True
 
         exclusions_option = self.get_option(options, "Exclusions", evaluation)
-        exclusions = eval_N(exclusions_option, evaluation).to_python()
         # TODO Turn expressions into points E.g. Sin[x] == 0 becomes 0, 2 Pi...
 
-        if exclusions in ["System`None", ["System`None"]]:
+        if exclusions_option in (SymbolNone, (SymbolNone,)):
             exclusions = "System`None"
-        elif not isinstance(exclusions, list):
-            exclusions = [exclusions]
+        else:
+            exclusions = eval_N(exclusions_option, evaluation).to_python()
+            if not isinstance(exclusions, list):
+                exclusions = [exclusions]
 
-            if isinstance(exclusions, list) and all(  # noqa
-                check_exclusion(excl) for excl in exclusions
-            ):
-                pass
+                if isinstance(exclusions, list) and all(  # noqa
+                    check_exclusion(excl) for excl in exclusions
+                ):
+                    pass
 
-            else:
-                evaluation.message(self.get_name(), "invexcl", exclusions_option)
-                exclusions = ["System`Automatic"]
+                else:
+                    evaluation.message(self.get_name(), "invexcl", exclusions_option)
+                    exclusions = ["System`Automatic"]
 
         # exclusions is now either 'None' or a list of reals and 'Automatic'
         assert exclusions == "System`None" or isinstance(exclusions, list)

mathics/core/atoms.py

@@ -5,7 +5,7 @@
 import math
 import re
 from functools import cache
-from typing import Any, Dict, Generic, Optional, Tuple, TypeVar, Union
+from typing import Any, Dict, Generic, Optional, Tuple, TypeVar, Union, cast
 
 import mpmath
 import numpy
@@ -239,11 +239,14 @@ def __new__(cls, value) -> "Integer":
         return self
 
     def __eq__(self, other) -> bool:
-        return (
-            self._value == other.value
-            if isinstance(other, Integer)
-            else super().__eq__(other)
-        )
+        if isinstance(other, Integer):
+            return self._value == other._value
+        if isinstance(other, Number):
+            # If other is a number of a wider class, use
+            # its implementation:
+            return other.__eq__(self)
+
+        return super().__eq__(other)
 
     def __ge__(self, other) -> bool:
         return (
@@ -346,7 +349,7 @@ def to_sympy(self, **_) -> sympy_numbers.Integer:
 
     def sameQ(self, rhs) -> bool:
         """Mathics SameQ"""
-        return isinstance(rhs, Integer) and self._value == rhs.value
+        return isinstance(rhs, Integer) and self._value == rhs._value
 
     def do_copy(self) -> "Integer":
         return Integer(self._value)
@@ -404,17 +407,18 @@ def __new__(cls, value, p: Optional[int] = None) -> "Real":
             return PrecisionReal.__new__(PrecisionReal, value)
 
     def __eq__(self, other) -> bool:
-        if isinstance(other, Real):
-            # MMA Docs: "Approximate numbers that differ in their last seven
-            # binary digits are considered equal"
-            _prec = min_prec(self, other)
-            if _prec is not None:
-                with mpmath.workprec(_prec):
-                    rel_eps = 0.5 ** float(_prec - 7)
-                    return mpmath.almosteq(
-                        self.to_mpmath(), other.to_mpmath(), abs_eps=0, rel_eps=rel_eps
-                    )
-        return super().__eq__(other)
+        if not isinstance(other, Number):
+            return super().__eq__(other)
+
+        _prec: Optional[int] = min_prec(self, other)
+        if _prec is None:
+            return self._value == other._value
+
+        with mpmath.workprec(_prec):
+            rel_eps = 0.5 ** float(_prec - 7)
+            return mpmath.almosteq(
+                self.to_mpmath(), other.to_mpmath(), abs_eps=0, rel_eps=rel_eps
+            )
 
     def __hash__(self):
         # ignore last 7 binary digits when hashing
@@ -492,6 +496,20 @@ def get_precision(self) -> int:
     def get_float_value(self, permit_complex=False) -> float:
         return self._value
 
+    @property
+    def element_order(self) -> tuple:
+        """
+        Return a tuple value that is used in ordering elements
+        of an expression. The tuple is ultimately compared lexicographically.
+        """
+        return (
+            BASIC_ATOM_NUMBER_ELT_ORDER,
+            self._value,
+            0,
+            1,
+            0,  # Machine precision comes first, and after Integers
+        )
+
     @property
     def is_approx_zero(self) -> bool:
         # In WMA, Chop[10.^(-10)] == 0,
@@ -514,7 +532,7 @@ def make_boxes(self, form):
 
     @property
     def is_zero(self) -> bool:
-        return self.value == 0.0
+        return self._value == 0.0
 
     def sameQ(self, rhs) -> bool:
         """Mathics SameQ for MachineReal.
@@ -524,9 +542,9 @@ def sameQ(self, rhs) -> bool:
         rhs-value's precision.  For any rhs type, sameQ is False.
         """
         if isinstance(rhs, MachineReal):
-            return self.value == rhs.value
+            return self._value == rhs._value
         if isinstance(rhs, PrecisionReal):
-            rhs_value = rhs.value
+            rhs_value = rhs._value
             value = self.to_sympy()
             # If sympy fixes the issue, this comparison would be
             # enough
@@ -603,6 +621,21 @@ def get_precision(self) -> int:
         """Returns the default specification for precision (in binary digits) in N and other numerical functions."""
         return self.value._prec + 1
 
+    @property
+    def element_order(self) -> tuple:
+        """
+        Return a tuple value that is used in ordering elements
+        of an expression. The tuple is ultimately compared lexicographically.
+        """
+
+        value = self._value
+        value, prec = float(value), value._prec
+        # For large values, use the sympy.Float value...
+        if math.isinf(value):
+            value, prec = self._value, value._prec
+
+        return (BASIC_ATOM_NUMBER_ELT_ORDER, value, 0, 2, prec)
+
     @property
     def is_zero(self) -> bool:
         # self.value == 0 does not work for sympy >=1.13
@@ -757,7 +790,7 @@ def sameQ(self, rhs) -> bool:
         """Mathics3 SameQ"""
         # FIX: check
         if isinstance(rhs, ByteArray):
-            return self.value == rhs.value
+            return self._value == rhs._value
         return False
 
     def get_string_value(self) -> Optional[str]:
@@ -902,12 +935,15 @@ def element_order(self) -> tuple:
         Return a tuple value that is used in ordering elements
         of an expression. The tuple is ultimately compared lexicographically.
         """
-        return (
-            BASIC_ATOM_NUMBER_ELT_ORDER,
-            self.real.element_order[1],
-            self.imag.element_order[1],
-            1,
-        )
+        order_real, order_imag = self.real.element_order, self.imag.element_order
+
+        # If the real of the imag parts are real numbers, sort according
+        # the minimum precision.
+        # Example:
+        # Sort[{1+2I, 1.+2.I, 1.`4+2.`5I, 1.`2+2.`7 I}]
+        #
+        # = {1+2I, 1.+2.I, 1.`2+2.`7 I, 1.`4+2.`5I}
+        return order_real + order_imag
 
     @property
     def pattern_precedence(self) -> tuple:
@@ -965,9 +1001,13 @@ def user_hash(self, update) -> None:
 
     def __eq__(self, other) -> bool:
         if isinstance(other, Complex):
-            return self.real == other.real and self.imag == other.imag
-        else:
-            return super().__eq__(other)
+            return self.real.__eq__(other.real) and self.imag.__eq__(other.imag)
+        if isinstance(other, Number):
+            if abs(self.imag._value) != 0:
+                return False
+            return self.real.__eq__(other)
+
+        return super().__eq__(other)
 
     @property
     def is_zero(self) -> bool:
@@ -1019,6 +1059,17 @@ def __new__(cls, numerator, denominator=1) -> "Rational":
             self.hash = hash(key)
         return self
 
+    def __eq__(self, other) -> bool:
+        if isinstance(other, Rational):
+            return self.value.as_numer_denom() == other.value.as_numer_denom()
+        if isinstance(other, Integer):
+            return (other._value, 1) == self.value.as_numer_denom()
+        if isinstance(other, Number):
+            # For general numbers, rely on Real or Complex implementations.
+            return other.__eq__(self)
+        # General expressions
+        return super().__eq__(other)
+
     def __getnewargs__(self) -> tuple:
         return (self.numerator().value, self.denominator().value)
 
@@ -1078,7 +1129,7 @@ def element_order(self) -> tuple:
         return (
             BASIC_ATOM_NUMBER_ELT_ORDER,
             sympy.Float(self.value),
-            0,
+            1,
             1,
         )
 

test/builtin/test_file_operations.py

@@ -2,7 +2,7 @@
 """
 Unit tests for mathics.builtin.file_operations
 """
-
+import os
 import sys
 import time
 from test.helper import check_evaluation, evaluate
@@ -101,6 +101,10 @@
         ),
     ],
 )
+@pytest.mark.skipif(
+    os.getenv("SANDBOX", False),
+    reason="Test doesn't work in a sandboxed environment with access to local files",
+)
 def test_private_doctests_file_properties(str_expr, msgs, str_expected, fail_msg):
     """file_opertions.file_properties"""
     check_evaluation(

test/core/convert/test_mpmath.py

@@ -44,7 +44,8 @@ def test_from_to_mpmath():
         (MachineReal(1.2), MachineReal(1.2)),
         (PrecisionReal(SympyFloat(1.3, 10)), PrecisionReal(SympyFloat(1.3, 10))),
         (PrecisionReal(SympyFloat(1.3, 30)), PrecisionReal(SympyFloat(1.3, 30))),
-        (Complex(Integer1, IntegerM1), Complex(Integer1, IntegerM1)),
+        # After conversion, val1 == val2 but not SameQ[val1,val2]
+        # (Complex(Integer1, IntegerM1), Complex(Integer1, IntegerM1)),
         (Complex(Integer1, Real(-1.0)), Complex(Integer1, Real(-1.0))),
         (Complex(Real(1.0), Real(-1.0)), Complex(Real(1.0), Real(-1.0))),
         (