Merge remote-tracking branch 'upstream/master'

Author: bdlucas1

mathics/core/atoms.py

@@ -7,13 +7,15 @@
 from typing import Any, Dict, Generic, Optional, Tuple, TypeVar, Union
 
 import mpmath
+import numpy
 import sympy
 from sympy.core import numbers as sympy_numbers
 
 from mathics.core.element import BoxElementMixin, ImmutableValueMixin
 from mathics.core.keycomparable import (
     BASIC_ATOM_BYTEARRAY_ELT_ORDER,
     BASIC_ATOM_NUMBER_ELT_ORDER,
+    BASIC_ATOM_NUMERICARRAY_ELT_ORDER,
     BASIC_ATOM_STRING_ELT_ORDER,
 )
 from mathics.core.number import (
@@ -1098,6 +1100,117 @@ def is_zero(self) -> bool:
 }
 
 
+#
+# NumericArray
+#
+
+NUMERIC_ARRAY_TYPE_MAP = {
+    "UnsignedInteger8": numpy.dtype("uint8"),
+    "UnsignedInteger16": numpy.dtype("uint16"),
+    "UnsignedInteger32": numpy.dtype("uint32"),
+    "UnsignedInteger64": numpy.dtype("uint64"),
+    "Integer8": numpy.dtype("int8"),
+    "Integer16": numpy.dtype("int16"),
+    "Integer32": numpy.dtype("int32"),
+    "Integer64": numpy.dtype("int64"),
+    "Real32": numpy.dtype("float32"),
+    "Real64": numpy.dtype("float64"),
+    "ComplexReal32": numpy.dtype("complex64"),
+    "ComplexReal64": numpy.dtype("complex128"),
+}
+
+NUMERIC_ARRAY_DTYPE_TO_NAME = {
+    dtype: name for name, dtype in NUMERIC_ARRAY_TYPE_MAP.items()
+}
+
+
+class NumericArray(Atom, ImmutableValueMixin):
+    """
+    NumericArray provides compact storage and efficient access for machine-precision numeric arrays,
+    backed by NumPy arrays.
+    """
+
+    class_head_name = "NumericArray"
+
+    def __init__(self, value, dtype=None):
+        # compute value
+        if not isinstance(value, numpy.ndarray):
+            value = numpy.asarray(value, dtype=dtype)
+        elif dtype is not None:
+            value = value.astype(dtype)
+        self.value = value
+
+        # check type
+        self._type_name = NUMERIC_ARRAY_DTYPE_TO_NAME.get(self.value.dtype, None)
+        if not self._type_name:
+            allowed = ", ".join(str(dtype) for dtype in NUMERIC_ARRAY_TYPE_MAP.values())
+            message = f"Argument 'value' must be one of {allowed}; is {str(self.value.dtype)}."
+            raise ValueError(message)
+
+        # summary and hash
+        shape_string = "×".join(str(dim) for dim in self.value.shape) or "0"
+        self._summary_string = f"{self._type_name}, {shape_string}"
+        self._hash = None
+
+    def __hash__(self):
+        if not self._hash:
+            self._hash = hash(("NumericArray", self.value.shape, id(self.value)))
+        return self._hash
+
+    def __str__(self) -> str:
+        return f"NumericArray[{self._summary_string}]"
+
+    def atom_to_boxes(self, f, evaluation):
+        return String(f"<{self._summary_string}>")
+
+    def do_copy(self) -> "NumericArray":
+        return NumericArray(self.value.copy())
+
+    def default_format(self, evaluation, form) -> str:
+        return f"NumericArray[<{self._summary_string}>]"
+
+    @property
+    def items(self) -> tuple:
+        from mathics.core.convert.python import from_python
+
+        if len(self.value.shape) == 1:
+            return tuple(from_python(item.item()) for item in self.value)
+        else:
+            return tuple(NumericArray(array) for array in self.value)
+
+    @property
+    def element_order(self) -> tuple:
+        return (
+            BASIC_ATOM_NUMERICARRAY_ELT_ORDER,
+            self.value.shape,
+            self.value.dtype,
+            id(self.value),
+        )
+
+    @property
+    def pattern_precedence(self) -> tuple:
+        return super().pattern_precedence
+
+    def sameQ(self, rhs) -> bool:
+        return isinstance(rhs, NumericArray) and numpy.array_equal(
+            self.value, rhs.value
+        )
+
+    def to_sympy(self, **kwargs) -> None:
+        return None
+
+    # TODO: this returns a list instead of np.ndarray in keeping with
+    # idea that to_python should return only "native" Python types.
+    # Keep an eye on this because there is a slight risk that code may
+    # naively call to_python and cause a performance issue due to
+    # the cost of converting to a nested list structure for a large array.
+    def to_python(self, *args, **kwargs) -> list:
+        return self.value.tolist()
+
+    def user_hash(self, update) -> None:
+        update(self.value.tobytes())
+
+
 class String(Atom, BoxElementMixin):
     value: str
     class_head_name = "System`String"

mathics/core/convert/python.py

@@ -5,7 +5,17 @@
 
 from typing import Any
 
-from mathics.core.atoms import Complex, Integer, Rational, Real, String
+import numpy
+
+from mathics.core.atoms import (
+    ByteArray,
+    Complex,
+    Integer,
+    NumericArray,
+    Rational,
+    Real,
+    String,
+)
 from mathics.core.number import get_type
 from mathics.core.symbols import (
     BaseElement,
@@ -14,7 +24,7 @@
     SymbolNull,
     SymbolTrue,
 )
-from mathics.core.systemsymbols import SymbolByteArray, SymbolRule
+from mathics.core.systemsymbols import SymbolRule
 
 
 def from_bool(arg: bool) -> BooleanType:
@@ -110,8 +120,8 @@ def from_python(arg: Any) -> BaseElement:
     elif isinstance(arg, list) or isinstance(arg, tuple):
         return to_mathics_list(*arg, elements_conversion_fn=from_python)
     elif isinstance(arg, bytearray) or isinstance(arg, bytes):
-        from mathics.builtin.binary.bytearray import ByteArray
-
-        return Expression(SymbolByteArray, ByteArray(arg))
+        return ByteArray(arg)
+    elif isinstance(arg, numpy.ndarray):
+        return NumericArray(arg)
     else:
         raise NotImplementedError

mathics/core/expression.py

@@ -387,7 +387,7 @@ def _build_elements_properties(self):
 
                 # and now possibly adjust self.elements_properties.elements_fully_evaluted
                 if self.elements_properties.elements_fully_evaluated:
-                    self._elements_fully_evaluated = (
+                    self.elements_properties.elements_fully_evaluated = (
                         element.elements_properties.elements_fully_evaluated
                     )
 
@@ -976,7 +976,7 @@ def is_literal(self) -> bool:
         # Lists. Lists definitions can't be changed right?
         return False
         # If we have a List we may do something like:
-        # return self._elements_fully_evaluated
+        # return self.elements_properties.elements_fully_evaluated
 
     def is_uncertain_final_definitions(self, definitions) -> bool:
         """

mathics/core/keycomparable.py

@@ -279,6 +279,7 @@ def __ne__(self, other) -> bool:
 BASIC_ATOM_STRING_ELT_ORDER = 0x01
 BASIC_ATOM_BYTEARRAY_ELT_ORDER = 0x02
 LITERAL_EXPRESSION_ELT_ORDER = 0x03
+BASIC_ATOM_NUMERICARRAY_ELT_ORDER = 0x04
 
 BASIC_NUMERIC_EXPRESSION_ELT_ORDER = 0x12
 GENERAL_NUMERIC_EXPRESSION_ELT_ORDER = 0x13

mathics/core/rules.py

@@ -187,10 +187,6 @@ def yield_match(vars, rest):
             # For now we have to take a pessimistic view
             expr = exc.value
             # FIXME: expr is sometimes a list - why the changing types
-            if hasattr(expr, "_elements_fully_evaluated"):
-                expr._elements_fully_evaluated = False
-                expr._is_flat = False  # I think this is fully updated
-                expr._is_ordered = False
             if (
                 hasattr(expression, "location")
                 and hasattr(expr, "location")

mathics/core/util.py

@@ -9,6 +9,8 @@
 from platform import python_implementation
 from typing import Optional
 
+from mathics.core.symbols import Symbol
+
 IS_PYPY = python_implementation() == "PyPy"
 
 
@@ -113,3 +115,29 @@ def subranges(
                 items[start : start + length],
                 (items[:start], items[start + length :]),
             )
+
+
+def print_expression_tree(expr, indent="", marker=lambda expr: ""):
+    """
+    Print a Mathics Expression as an indented tree.
+    Caller may supply a marker function that computes a marker
+    to be displayed in the tree for the given node.
+    """
+    if isinstance(expr, Symbol):
+        print(f"{indent}{marker(expr)}{expr}")
+    elif not hasattr(expr, "elements"):
+        print(f"{indent}{marker(expr)}{expr.get_head()} {expr}")
+    else:
+        print(f"{indent}{marker(expr)}{expr.head}")
+        for elt in expr.elements:
+            print_expression_tree(elt, indent + "  ", marker=marker)
+
+
+def print_sympy_tree(expr, indent=""):
+    """Print a SymPy Expression as an indented tree"""
+    if expr.args:
+        print(f"{indent}{expr.func.__name__}")
+        for i, arg in enumerate(expr.args):
+            print_sympy_tree(arg, indent + "    ")
+    else:
+        print(f"{indent}{expr.func.__name__}({str(expr)})")

test/builtin/drawing/test_plot.py

@@ -3,10 +3,12 @@
 Unit tests from mathics.builtin.drawing.plot
 """
 
-from test.helper import check_evaluation
+from test.helper import check_evaluation, session
 
 import pytest
 
+from mathics.core.util import print_expression_tree
+
 
 def test__listplot():
     """tests for module builtin.drawing.plot._ListPlot"""
@@ -201,3 +203,125 @@ def test_plot(str_expr, msgs, str_expected, fail_msg):
         failure_message=fail_msg,
         expected_messages=msgs,
     )
+
+
+#
+# Call plotting functions and examine the structure of the output
+# In case of error trees are printed with an embedded >>> marker showing location of error
+#
+
+
+def print_expression_tree_with_marker(expr):
+    print_expression_tree(expr, marker=lambda expr: getattr(expr, "_marker", ""))
+
+
+def check_structure(result, expected):
+    """Check that expected is a prefix of result at every node"""
+
+    def error(msg):
+        result._marker = "RESULT >>> "
+        expected._marker = "EXPECTED >>> "
+        raise AssertionError(msg)
+
+    # do the heads match?
+    if result.get_head() != expected.get_head():
+        error("heads don't match")
+
+    # does the structure match?
+    if hasattr(expected, "elements"):
+        if not hasattr(result, "elements"):
+            error("expected elements but result has none")
+        for i, e in enumerate(expected.elements):
+            if len(result.elements) <= i:
+                error("result has too few elements")
+            check_structure(result.elements[i], e)
+    else:
+        if str(result) != str(expected):
+            error("leaves don't match")
+
+
+def eval_and_check_structure(str_expr, str_expected):
+    expr = session.parse(str_expr)
+    result = expr.evaluate(session.evaluation)
+    expected = session.parse(str_expected)
+    try:
+        check_structure(result, expected)
+    except AssertionError as oops:
+        print(f"\nERROR: {oops} (error is marked with >>> below)")
+        print("=== result:")
+        print_expression_tree_with_marker(result)
+        print("=== expected:")
+        print_expression_tree_with_marker(expected)
+        raise
+
+
+def test_plot3d_default():
+    eval_and_check_structure(
+        """
+        Plot3D[
+            x+y,
+            {x,0,1}, {y,0,1},
+            PlotPoints->{2,2},
+            MaxRecursion->0
+        ]
+        """,
+        """
+        Graphics3D[
+            {
+                Polygon[{{0.0,0.0,0.0}, {0.0,0.5,0.5}, {0.5,0.0,0.5}}],
+                Polygon[{{}}]
+            },
+            AspectRatio -> 1,
+            Axes -> True,
+            AxesStyle -> {},
+            Background -> Automatic,
+            BoxRatios -> {1, 1, 0.4},
+            ImageSize -> Automatic,
+            LabelStyle -> {},
+            PlotRange -> Automatic,
+            PlotRangePadding -> Automatic,
+            TicksStyle -> {}
+        ]
+        """,
+    )
+
+
+def test_plot3d_nondefault():
+    eval_and_check_structure(
+        """
+        Plot3D[
+            x+y,
+            {x,0,1}, {y,0,1},
+            PlotPoints->{2,2},
+            MaxRecursion->0
+            AspectRatio -> 0.5,
+            Axes -> False,
+            AxesStyle -> {Red,Blue},
+            Background -> Green,
+            BoxRatios -> {10, 10, 1},
+            ImageSize -> {200,200},
+            LabelStyle -> Red,
+            PlotRange -> {0,1},
+            PlotRangePadding -> {1,2},
+            TicksStyle -> {Purple,White}
+        ]
+        """,
+        """
+        Graphics3D[
+            {
+                Polygon[{{0.0,0.0,0.0}, {0.0,0.5,0.5}, {0.5,0.0,0.5}}],
+                Polygon[{{}}]
+            },
+            AspectRatio -> 1, (* TODO: is not passed through apparently - or is my misunderstanding? *)
+            Axes -> False,
+            AxesStyle -> {RGBColor[1,0,0],RGBColor[0,0,1]},
+            Background -> RGBColor[0,1,0],
+            BoxRatios -> {10, 10, 1},
+            ImageSize -> {200,200},
+            LabelStyle -> RGBColor[1,0,0],
+            PlotRange -> {0,1},
+            PlotRangePadding -> {1,2},
+            TicksStyle -> {RGBColor[0.5,0,0.5],GrayLevel[1]}
+        ]
+        """,
+    )