Merge branch 'master' into go-over-intfns-recurrence

Author: rocky

mathics/builtin/drawing/plot_plot3d.py

@@ -12,6 +12,7 @@
 
 import numpy as np
 
+from mathics.builtin.drawing import plot
 from mathics.builtin.drawing.graphics3d import Graphics3D
 from mathics.builtin.graphics import Graphics
 from mathics.builtin.options import filter_from_iterable, options_to_rules
@@ -21,8 +22,6 @@
 from mathics.core.evaluation import Evaluation
 from mathics.core.systemsymbols import Symbol, SymbolPlotRange, SymbolSequence
 
-from . import plot
-
 # This tells documentation how to sort this module
 sort_order = "mathics.builtin.custom-plots"
 
@@ -143,9 +142,10 @@ def eval(
 
 class ComplexPlot3D(_Plot3D):
     """
-    <url>:WMA link: https://reference.wolfram.com/language/ref/ComplexPlot3D.html</url>
+    <url>:Domain coloring:https://en.wikipedia.org/wiki/Domain_coloring</url> (<url>
+    :WMA link: https://reference.wolfram.com/language/ref/ComplexPlot3D.html</url>)
     <dl>
-      <dt>'Plot3D'[$f$, {$z$, $z_{min}$, $z_{max}$}]
+      <dt>'ComplexPlot3D'[$f$, {$z$, $z_{min}$, $z_{max}$}]
       <dd>creates a three-dimensional plot of the magnitude of $f$ with $z$ ranging from $z_{min}$ to \
           $z_{max}$ with surface colored according to phase
 
@@ -154,21 +154,29 @@ class ComplexPlot3D(_Plot3D):
     </url> for a list of Plot options.
     </dl>
 
+    'ComplexPlot' allows to visualize the changes both in the phase and \
+    the module  of a complex function:
+
+    In the neighborhood of the poles, the module of a rational function \
+    grows without limit, and the phase varies between $-\\Pi$ to $\\Pi$, \
+    an integer number of times:
+    >> ComplexPlot3D[(z^2 + 1)/(z^2 - 1), {z, -2 - 2 I, 2 + 2 I}]
+     = ...
     """
 
-    summary_text = "plots one or more complex functions as a 3D surface"
+    graphics_class = Graphics3D
     expected_args = 2
-    options = _Plot3D.options3d | {"Mesh": "None"}
-
     many_functions = True
-    graphics_class = Graphics3D
+    options = _Plot3D.options3d | {"Mesh": "None"}
+    summary_text = "plot one or more complex functions as a 3D surface"
 
 
 class ComplexPlot(_Plot3D):
     """
+    <url>:Domain coloring:https://en.wikipedia.org/wiki/Domain_coloring</url>
     <url>:WMA link: https://reference.wolfram.com/language/ref/ComplexPlot.html</url>
     <dl>
-      <dt>'Plot3D'[$f$, {$z$, $z_{min}$, $z_{max}$}]
+      <dt>'ComplexPlot'[$f$, {$z$, $z_{min}$, $z_{max}$}]
       <dd>creates two-dimensional plot of $f$ with $z$ ranging from $z_{min}$ to \
           $z_{max}$ colored according to phase
 
@@ -177,39 +185,58 @@ class ComplexPlot(_Plot3D):
     </url> for a list of Plot options.
     </dl>
 
+    'ComplexPlot' allows to visualize the changes in the phase of a \
+    complex function.
+    In the neighborhood of the poles, the module of a rational function \
+    the phase varies between $-\\Pi$ to $\\Pi$ an integer number of times.
+    >> ComplexPlot[(z^2 + 1)/(z^2 - 1), {z, -2 - 2 I, 2 + 2 I}]
+     = ...
     """
 
-    summary_text = "plots a complex function showing phase using colors"
     expected_args = 2
-    options = _Plot3D.options2d
-
-    many_functions = False
     graphics_class = Graphics
+    many_functions = False
+    options = _Plot3D.options2d
+    summary_text = "plots a complex function showing phase using colors"
 
 
 class ContourPlot(_Plot3D):
     """
-    <url>:WMA link: https://reference.wolfram.com/language/ref/ContourPlot.html</url>
+    <url>:heat map:https://en.wikipedia.org/wiki/Heat_map</url>, <url>
+    :contour map:https://en.wikipedia.org/wiki/Contour_line</url> (<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
+      <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/plotting-graphing-and-drawing/drawing-options-and-option-values
     </url> for a list of Plot options.
     </dl>
 
+    Colorize the regions where a function takes values close to different \
+   numeric values
+    >> ContourPlot[x - y^3, {x, -2, 2}, {y, -1, 1}, AspectRatio->Automatic]
+     = ...
+
+    The same, but with a finer division:
+    >> ContourPlot[x^2 - y^2, {x, -2, 2}, {y, -1, 1}, Contours->10]
+     = ...
+
+    Plot curves where the real and the imaginary part of a function take
+    specific values:
+    >> ContourPlot[{Re[Sin[x + I y]] == 5, Im[Sin[x + I y]] == 0}, {x, -10, 10}, {y, -10, 10}]
+     = ...
     """
 
-    requires = ["skimage"]
-    summary_text = "creates a contour plot"
     expected_args = 3
+    graphics_class = Graphics
+    many_functions = True
     options = _Plot3D.options2d | {"Contours": "Automatic"}
     # TODO: other options?
-
-    many_functions = True
-    graphics_class = Graphics
+    requires = ["skimage"]
+    summary_text = "creates a contour plot"
 
 
 class DensityPlot(_Plot3D):
@@ -236,12 +263,11 @@ class DensityPlot(_Plot3D):
      = -Graphics-
     """
 
-    summary_text = "density plot for a function"
     expected_args = 3
-    options = _Plot3D.options2d
-
-    many_functions = False
     graphics_class = Graphics
+    many_functions = False
+    options = _Plot3D.options2d
+    summary_text = "density plot for a function"
 
 
 class Plot3D(_Plot3D):
@@ -273,9 +299,8 @@ class Plot3D(_Plot3D):
      = -Graphics3D-
     """
 
-    summary_text = "plots 3D surfaces of one or more functions"
     expected_args = 3
-    options = _Plot3D.options3d
-
-    many_functions = True
     graphics_class = Graphics3D
+    many_functions = True
+    options = _Plot3D.options3d
+    summary_text = "plots 3D surfaces of one or more functions"

mathics/builtin/functional/apply_fns_to_lists.py

@@ -179,9 +179,21 @@ def callback(level):
             Map $f$ onto each element (denoted by 'level' here) at this level.
             With exception for expr as Association, which is mapped on values only.
             """
-            if is_association and level.has_form("Rule", 2):
+            # TODO: This special behavior applies when the whole expression
+            # is of the form Association[__(Rule|RuleDelayed)], i.e., when
+            # the expression is a well-formatted Association expression.
+            # For example,
+            # `Map[F, Association[a->1,b->2, NotARule]`
+            # produces in WMA
+            # `Association[F[a->1], F[b->2], F[NotARule]`
+            # instead of
+            # `Association[a->F[1], b->F[2], F[NotARule]`]
+            #
+            # Fixing this would require a different implementation of this eval_ method.
+            #
+            if is_association and level.has_form(("Rule", "RuleDelayed"), 2):
                 return Expression(
-                    SymbolRule,
+                    level.get_head(),
                     level.elements[0],
                     Expression(f, level.elements[1]),
                 )

mathics/eval/functional/apply_fns_to_lists.py

@@ -38,9 +38,9 @@ def map_at_replace_one(elements: Iterable, index: ListExpression, i: int) -> lis
             raise PartRangeError
         new_elements = list(elements)
         replace_element = elements[j]
-        if hasattr(replace_element, "head") and replace_element.head is SymbolRule:
+        if replace_element.has_form(("Rule", "RuleDelayed"), 2):
             new_elements[j] = Expression(
-                SymbolRule,
+                replace_element.get_head(),
                 replace_element.elements[0],
                 Expression(f, replace_element.elements[1]),
             )

test/builtin/list/test_association.py

@@ -193,3 +193,75 @@ def test_associations_private_doctests(
         failure_message=assert_message,
         expected_messages=expected_messages,
     )
+
+
+@pytest.mark.parametrize(
+    ("str_expr", "expected_messages", "str_expected", "assert_message"),
+    [
+        (
+            "Map[F, Q[a->1, b:>Association[p->3,q->4]]]",
+            None,
+            "Q[F[a->1], F[b:>Association[p->3, q->4]]]",
+            "Acting on a nested association, the inner association is treated as normal.",
+        ),
+        (
+            "Map[F, Q[a->1, b:>Association[p->3,q->4]],{2}]",
+            None,
+            "Q[F[a]->F[1], F[b]:>F[Association[p->3, q->4]]]",
+            "Acting on a nested association, the inner association is treated as normal.",
+        ),
+        (
+            "Map[F, Association[a->1, b:>Association[p->3,q->4]], {0}]",
+            None,
+            "F[Association[a->1, b:>Association[p->3, q->4]]]",
+            "Special behavior occurs at the first level.",
+        ),
+        (
+            "Map[F, Association[a->1, b:>2]]",
+            None,
+            "Association[a->F[1], b:>F[2]]",
+            "Over associations, Map acts on the values",
+        ),
+        (
+            "Map[F, Association[a->1, b:>Association[p->3,q->4]]]",
+            None,
+            "Association[a->F[1], b:>F[Association[p->3, q->4]]]",
+            "Acting on a nested association, the inner association is treated as normal.",
+        ),
+        (
+            "Map[F, Association[a->1, b:>Association[p->3,q->4]], {1}]",
+            None,
+            "Association[a->F[1], b:>F[Association[p->3, q->4]]]",
+            "Special behavior occurs at the first level.",
+        ),
+        # FIXME
+        (
+            "Map[F, Association[a->1,b:>2,q]]",
+            None,
+            "Association[F[a->1], F[b:>2], F[q]]",
+            "Acting on an invalid association expression, works as in a normal expression.",
+        ),
+        (
+            "Map[F, Association[a->1, b:>Association[p->3,q->4]], {2}]",
+            None,
+            "Association[a->1, b:>Association[F[p->3],F[q->4]]]",
+            "Special behavior occurs at the first level.",
+        ),
+        (
+            "Map[F, Association[a->1, b:>Q[p->3, q->4]], {2}]",
+            None,
+            "Association[a->1, b:>Q[F[p->3],F[q->4]]]",
+            "Special behavior occurs at the first level.",
+        ),
+    ],
+)
+@pytest.mark.xfail
+def test_map_over_associations(
+    str_expr, expected_messages, str_expected, assert_message
+):
+    check_evaluation(
+        str_expr,
+        str_expected,
+        failure_message=assert_message,
+        expected_messages=expected_messages,
+    )