Merge remote-tracking branch 'origin/evaluate_without_side_effects' into evaluate_without_side_effects

Author: mmatera

SYMBOLS_MANIFEST.txt

@@ -265,6 +265,7 @@ System`Context
 System`Contexts
 System`Continue
 System`ContinuedFraction
+System`ContourPlot
 System`Convert`B64Dump`B64Decode
 System`Convert`B64Dump`B64Encode
 System`ConvertersDump`$ExtensionMappings

mathics/builtin/arithmetic.py

@@ -802,8 +802,13 @@ def to_sympy(self, expr, **kwargs):
             try:
                 e_kwargs = kwargs.copy()
                 e_kwargs["convert_all_global_functions"] = True
+                e_kwargs["dummies"] = e_kwargs.get("dummies", set()).union((index,))
                 e = expr.elements[0].to_sympy(**e_kwargs)
-                i = index.elements[0].to_sympy(**kwargs)
+                e_kwargs["convert_all_global_functions"] = kwargs.get(
+                    "convert_all_global_functions", False
+                )
+
+                i = index.elements[0].to_sympy(**e_kwargs)
                 start = index.elements[1].to_sympy(**kwargs)
                 stop = index.elements[2].to_sympy(**kwargs)
 
@@ -1045,23 +1050,27 @@ def to_sympy(self, expr, **kwargs) -> Optional[SympyExpression]:
             index = expr.elements[1]
             arg_kwargs = kwargs.copy()
             arg_kwargs["convert_all_global_functions"] = True
+            arg_kwargs["dummies"] = kwargs.get("dummies", set()).union((index,))
             f_sympy = expr.elements[0].to_sympy(**arg_kwargs)
             if f_sympy is None:
                 return
 
             evaluation = kwargs.get("evaluation", None)
 
             # Handle summation parameters: variable, min, max
-            var_min_max = index.elements[:3]
-            bounds = [expr.to_sympy(**kwargs) for expr in var_min_max]
 
+            arg_kwargs["convert_all_global_functions"] = kwargs.get(
+                "convert_all_global_functions", False
+            )
+            var_min_max = index.elements[:3]
+            bounds = [expr.to_sympy(**arg_kwargs) for expr in var_min_max]
             if evaluation:
                 # Min and max might be Mathics expressions. If so, evaluate them.
                 for i in (1, 2):
                     min_max_expr = var_min_max[i]
                     if not isinstance(expr, Symbol):
                         min_max_expr_eval = min_max_expr.evaluate(evaluation)
-                        value = min_max_expr_eval.to_sympy(**kwargs)
+                        value = min_max_expr_eval.to_sympy(**arg_kwargs)
                         bounds[i] = value
 
             # FIXME: The below tests on SympyExpression, but really the
@@ -1075,7 +1084,7 @@ def to_sympy(self, expr, **kwargs) -> Optional[SympyExpression]:
                 # If we have integer bounds, we'll use Mathics's iterator Sum
                 # (which is Plus)
 
-                if all(
+                if evaluation and all(
                     (hasattr(i, "is_integer") and i.is_integer)
                     or (hasattr(i, "is_finite") and i.is_finite and i.is_constant())
                     for i in bounds[1:]

mathics/builtin/box/graphics3d.py

@@ -250,6 +250,17 @@ def _prepare_elements(self, elements, options, max_width=None):
             self.background_color = elements.background_color
 
         def calc_dimensions(final_pass=True):
+            # TODO: the code below is broken in any other case but Automatic
+            # because it calls elements.translate which is not implemented.
+            # Plots may pass specific plot ranges, triggering this deficiency
+            # and causing tests to fail The following line avoids this,
+            # and it should not change the behavior of any case which did
+            # previously fail with an exception.
+            #
+            # This code should be DRYed (together with the very similar code
+            # for the 2d case), and the missing .translate method added.
+            plot_range = ["System`Automatic"] * 3
+
             if "System`Automatic" in plot_range:
                 xmin, xmax, ymin, ymax, zmin, zmax = elements.extent()
             else:
@@ -291,7 +302,7 @@ def calc_dimensions(final_pass=True):
                     elif zmin == zmax:
                         zmin -= 1
                         zmax += 1
-                elif isinstance(plot_range[1], list) and len(plot_range[1]) == 2:
+                elif isinstance(plot_range[1], list) and len(plot_range[2]) == 2:
                     zmin, zmax = list(map(float, plot_range[2]))
                     zmin = elements.translate((0, 0, zmin))[2]
                     zmax = elements.translate((0, 0, zmax))[2]

mathics/builtin/drawing/plot.py

@@ -15,6 +15,8 @@
 
 import palettable
 
+import mathics.eval.drawing.plot3d
+import mathics.eval.drawing.plot3d_vectorized
 from mathics.builtin.drawing.graphics3d import Graphics3D
 from mathics.builtin.graphics import Graphics
 from mathics.builtin.options import options_to_rules
@@ -37,6 +39,7 @@
     SymbolLine,
     SymbolLog10,
     SymbolNone,
+    SymbolPlotRange,
     SymbolRGBColor,
     SymbolSequence,
     SymbolStyle,
@@ -62,21 +65,25 @@
 # Set option such as $UseVectorizedPlot, and maybe a non-standard Plot3D option.
 # For now an env variable is simplest.
 # TODO: work out exactly how to deploy.
+
+
+# can be set via environment variable at startup time,
+# or changed dynamically by setting the use_vectorized_plot flag
 use_vectorized_plot = os.getenv("MATHICS3_USE_VECTORIZED_PLOT", False)
-if use_vectorized_plot:
-    from mathics.eval.drawing.plot3d_vectorized import (
-        eval_ComplexPlot,
-        eval_ComplexPlot3D,
-        eval_DensityPlot,
-        eval_Plot3D,
-    )
-else:
-    from mathics.eval.drawing.plot3d import (
-        eval_ComplexPlot,
-        eval_ComplexPlot3D,
-        eval_DensityPlot,
-        eval_Plot3D,
+
+
+# get the plot eval function for the given class,
+# depending on whether vectorized plot functions are enabled
+def get_plot_eval_function(cls):
+    function_name = "eval_" + cls.__name__
+    plot_module = (
+        mathics.eval.drawing.plot3d_vectorized
+        if use_vectorized_plot
+        else mathics.eval.drawing.plot3d
     )
+    fun = getattr(plot_module, function_name)
+    return fun
+
 
 # This tells documentation how to sort this module
 # Here we are also hiding "drawing" since this erroneously appears at the top level.
@@ -467,7 +474,7 @@ def error(self, what, *args, **kwargs):
     def __init__(self, expr, range_exprs, options, evaluation):
         self.evaluation = evaluation
 
-        # plot ranges
+        # plot ranges of the form {x,xmin,xmax} etc.
         self.ranges = []
         for range_expr in range_exprs:
             if not range_expr.has_form("List", 3):
@@ -488,6 +495,19 @@ def __init__(self, expr, range_exprs, options, evaluation):
                 self.error(expr, "invrange", range_expr)
             self.ranges.append(range)
 
+        # Contours option
+        contours = expr.get_option(options, "Contours", evaluation)
+        if contours is not None:
+            c = contours.to_python()
+            if not (
+                c == "System`Automatic"
+                or isinstance(c, int)
+                or isinstance(c, tuple)
+                and all(isinstance(cc, (int, float)) for cc in c)
+            ):
+                self.error(expr, "invcontour", contours)
+            self.contours = c
+
         # Mesh option
         mesh = expr.get_option(options, "Mesh", evaluation)
         if mesh not in (SymbolNone, SymbolFull, SymbolAll):
@@ -579,6 +599,9 @@ class _Plot3D(Builtin):
             "Plot range `1` must be of the form {variable, min, max}, "
             "where max > min."
         ),
+        "invcontour": (
+            "Contours option must be Automatic, an integer, or a list of numbers."
+        ),
     }
 
     # Plot3D, ComplexPlot3D
@@ -630,9 +653,43 @@ def eval(
             plot_options.functions = [functions]
 
         # subclass must set eval_function and graphics_class
-        graphics = self.eval_function(plot_options, evaluation)
+        eval_function = get_plot_eval_function(self.__class__)
+        graphics = eval_function(plot_options, evaluation)
         if not graphics:
             return
+
+        # Expand PlotRange option using the {x,xmin,xmax} etc. range specifications
+        # Pythonize it, so Symbol becomes str, numeric becomes int or float
+        plot_range = self.get_option(options, str(SymbolPlotRange), evaluation)
+        plot_range = plot_range.to_python()
+        dim = 3 if self.graphics_class is Graphics3D else 2
+        if isinstance(plot_range, str):
+            # PlotRange -> Automatic becomes PlotRange -> {Automatic, ...}
+            plot_range = [str(SymbolAutomatic)] * dim
+        if isinstance(plot_range, (int, float)):
+            # PlotRange -> s becomes PlotRange -> {Automatic,...,{-s,s}}
+            pr = plot_range
+            plot_range = [str(SymbolAutomatic)] * dim
+            plot_range[-1] = [-pr, pr]
+        elif isinstance(plot_range, (list, tuple)) and isinstance(
+            plot_range[0], (int, float)
+        ):
+            # PlotRange -> {s0,s1} becomes  PlotRange -> {Automatic,...,{s0,s1}}
+            pr = plot_range
+            plot_range = [str(SymbolAutomatic)] * dim
+            plot_range[-1] = pr
+
+        # now we have a list of length dim
+        # handle Automatic ~ {xmin,xmax} etc.
+        for i, (pr, r) in enumerate(zip(plot_range, plot_options.ranges)):
+            # TODO: this treats Automatic and Full as the same, which isn't quite right
+            if isinstance(pr, str) and not isinstance(r[1], complex):
+                plot_range[i] = r[1:]  # extract {xmin,xmax} from {x,xmin,xmax}
+
+        # unpythonize and update PlotRange option
+        options[str(SymbolPlotRange)] = to_mathics_list(*plot_range)
+
+        # generate the Graphics[3D] result
         graphics_expr = graphics.generate(
             options_to_rules(options, self.graphics_class.options)
         )
@@ -781,7 +838,6 @@ class ComplexPlot3D(_Plot3D):
     options = _Plot3D.options3d | {"Mesh": "None"}
 
     many_functions = True
-    eval_function = staticmethod(eval_ComplexPlot3D)
     graphics_class = Graphics3D
 
 
@@ -805,7 +861,31 @@ class ComplexPlot(_Plot3D):
     options = _Plot3D.options2d
 
     many_functions = False
-    eval_function = staticmethod(eval_ComplexPlot)
+    graphics_class = Graphics
+
+
+class ContourPlot(_Plot3D):
+    """
+    <url>:WMA link: https://reference.wolfram.com/language/ref/ContourPlot.html</url>
+    <dl>
+      <dt>'Contour'[$f$, {$x$, $x_{min}$, $x_{max}$}, {$y$, $y_{min}$, $y_{max}$}]
+      <dd>creates a two-dimensional contour plot ofh $f$ over the region
+          $x$ ranging from $x_{min}$ to $x_{max}$ and $y$ ranging from $y_{min}$ to $y_{max}$.
+
+          See <url>:Drawing Option and Option Values:
+    /doc/reference-of-built-in-symbols/graphics-and-drawing/drawing-options-and-option-values
+    </url> for a list of Plot options.
+    </dl>
+
+    """
+
+    requires = ["skimage"]
+    summary_text = "creates a contour plot"
+    expected_args = 3
+    options = _Plot3D.options2d | {"Contours": "Automatic"}
+    # TODO: other options?
+
+    many_functions = True
     graphics_class = Graphics
 
 
@@ -838,7 +918,6 @@ class DensityPlot(_Plot3D):
     options = _Plot3D.options2d
 
     many_functions = False
-    eval_function = staticmethod(eval_DensityPlot)
     graphics_class = Graphics
 
 
@@ -1958,5 +2037,4 @@ class Plot3D(_Plot3D):
     options = _Plot3D.options3d
 
     many_functions = True
-    eval_function = staticmethod(eval_Plot3D)
     graphics_class = Graphics3D

mathics/builtin/numbers/calculus.py

@@ -57,6 +57,7 @@
     SymbolPower,
     SymbolTimes,
     SymbolTrue,
+    sympy_name,
 )
 from mathics.core.systemsymbols import (
     SymbolAnd,
@@ -528,7 +529,7 @@ def to_sympy(self, expr, **kwargs):
             return
 
         func = exprs[1].elements[0]
-        sym_func = sympy.Function(str(SYMPY_SYMBOL_PREFIX + func.__str__()))(*sym_args)
+        sym_func = sympy.Function(sympy_name(func))(*sym_args)
 
         counts = [element.get_int_value() for element in exprs[2].elements]
         if None in counts:

mathics/core/builtin.py

@@ -864,12 +864,14 @@ class UnavailableFunction:
 
     def __init__(self, builtin):
         self.name = builtin.get_name()
+        self.requires = builtin.requires
 
     def __call__(self, **kwargs):
         kwargs["evaluation"].message(
             "General",
             "pyimport",  # see messages.py for error message definition
             strip_context(self.name),
+            ", ".join(self.requires),
         )