New plot compile functions 2 (#1530)

* Added an optional keyword argument `raise_on_error` to `to_sympy` and
`expression_to_sympy` that causes it to raise the specified exception in
cases where it would otherwise silently have returned `None`. This is
used by `plot_compile` to aid in identifying the cause of compilation
failure, which will help to build out compilation functionality. That is
the only place it is specified, and if it is not specified, behavior is
as it was before.
* Added compilation test cases in `test_plot_compile.py` for `If`,
`Switch`, and `Which`. These are defined in `procedural.py`, but they
are not really procedural.
* Enabled `Mod`, `FractionalPart`, `IntegerPart`, `If`, `Which`, `Min`,
and `Max` for compilation by sympy-enabling them: subclass from
`SympyFunction` and implement `to_sympy`. Verified that this enables
compilation using the test cases in `test_plot_compile.py`, and by doing
some plots:

<img width="726" height="983" alt="test-030"
src="https://github.com/user-attachments/assets/05bd5aec-bf12-41bb-a021-d4b5c84491cf"
/>

---------

Co-authored-by: Juan Mauricio Matera <[email protected]>

Author: bdlucas1

mathics/builtin/arithmetic.py

@@ -373,6 +373,11 @@ def to_sympy(self, expr, **kwargs):
                 sympy_cond = False
         if sympy_cond is None:
             sympy_cond = cond.to_sympy(**kwargs)
+            # See similar code and comment in mathics.builtin.procedural.If
+            # TODO: consider adding .is_Symbol (as with If) so that this
+            # can be used for compilation. I tried that but it invalidated
+            # doctest 1876 in Simplify which depends on ConditionalExpression
+            # not getting rewritten, so may need update that secion of doc?
             if not (sympy_cond.is_Relational or sympy_cond.is_Boolean):
                 return
 

mathics/builtin/intfns/divlike.py

@@ -160,7 +160,7 @@ def eval(self, ns: List[Integer], evaluation: Evaluation):
         return Integer(result)
 
 
-class Mod(Builtin):
+class Mod(SympyFunction):
     """
     <url>:WMA link:https://reference.wolfram.com/language/ref/Mod.html</url>
 
@@ -183,6 +183,8 @@ class Mod(Builtin):
     attributes = A_LISTABLE | A_NUMERIC_FUNCTION | A_PROTECTED
     summary_text = "the remainder in an integer division"
 
+    sympy_name = "Mod"
+
     def eval(self, n: Integer, m: Integer, evaluation: Evaluation):
         "Mod[n_Integer, m_Integer]"
 

mathics/builtin/numbers/numbertheory.py

@@ -350,7 +350,7 @@ def _fractional_part(n, expr, evaluation: Evaluation):
         return expr
 
 
-class FractionalPart(Builtin):
+class FractionalPart(SympyFunction):
     """
     <url>:WMA link:https://reference.wolfram.com/language/ref/FractionalPart.html</url>
 
@@ -384,6 +384,11 @@ def eval_complex_n(self, n, evaluation: Evaluation):
         image_fractional_part = _fractional_part(n_image, expr, evaluation)
         return Expression(SymbolComplex, real_fractional_part, image_fractional_part)
 
+    def to_sympy(self, expr, **kwargs):
+        if len(expr.elements) > 0:
+            x_sympy = expr.elements[0].to_sympy(**kwargs)
+            return sympy.sign(x_sympy) * sympy.frac(abs(x_sympy))
+
 
 class FromContinuedFraction(SympyFunction):
     """
@@ -415,7 +420,7 @@ def eval(self, expr, evaluation: Evaluation):
             return from_sympy(sympy.continued_fraction_reduce(nums))
 
 
-class IntegerPart(Builtin):
+class IntegerPart(SympyFunction):
     """
     <url>:WMA link:https://reference.wolfram.com/language/ref/IntegerPart.html</url>
 
@@ -449,6 +454,11 @@ def eval_complex_n(self, n, evaluation: Evaluation):
         image_integer_part = _integer_part(n_image, expr, evaluation)
         return Expression(SymbolComplex, real_integer_part, image_integer_part)
 
+    def to_sympy(self, expr, **kwargs):
+        if len(expr.elements) > 0:
+            x_sympy = expr.elements[0].to_sympy(**kwargs)
+            return sympy.sign(x_sympy) * sympy.floor(abs(x_sympy))
+
 
 class IntegerPartitions(Builtin):
     """

mathics/builtin/procedural.py

@@ -16,13 +16,20 @@
 environment.
 """
 
+import sympy
+
 from mathics.core.attributes import (
     A_HOLD_ALL,
     A_HOLD_REST,
     A_PROTECTED,
     A_READ_PROTECTED,
 )
-from mathics.core.builtin import Builtin, InfixOperator, IterationFunction
+from mathics.core.builtin import (
+    Builtin,
+    InfixOperator,
+    IterationFunction,
+    SympyFunction,
+)
 from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression
 from mathics.core.interrupt import (
@@ -365,7 +372,7 @@ def eval(self, start, test, incr, body, evaluation):
         return SymbolNull
 
 
-class If(Builtin):
+class If(SympyFunction):
     """
     <url>:WMA link:https://reference.wolfram.com/language/ref/If.html</url>
 
@@ -443,6 +450,26 @@ def eval_with_false_and_other(self, condition, t, f, u, evaluation):
         else:
             return u.evaluate(evaluation)
 
+    def to_sympy(self, expr, **kwargs):
+        if len(expr.elements) == 3:
+            sympy_cond = expr.elements[0].to_sympy(**kwargs)
+            sympy_true = expr.elements[1].to_sympy(**kwargs)
+            sympy_false = expr.elements[2].to_sympy(**kwargs)
+            if sympy_cond is None:
+                return
+            # sympy.Piecewise is is picky as to what type of conds it will accept,
+            # allowing Boolean, Relational, and Symbol (as an honorary Boolean,
+            # accompanied by a comment in the code that this isn't really correct).
+            # Seems an attempt at early typechecking, but maybe too restrictive -
+            # what about Exprs in general that might or might not evaluate to Boolean?
+            # See similar code in mathics.builtin.arithmetic.ConditionalExpression.
+            if (
+                sympy_cond.is_Boolean
+                or sympy_cond.is_Relational
+                or sympy_cond.is_Symbol
+            ):
+                return sympy.Piecewise((sympy_true, sympy_cond), (sympy_false, True))
+
 
 class Interrupt(Builtin):
     r"""
@@ -648,7 +675,7 @@ def eval_with_tag(
         raise WLThrowInterrupt(value, tag)
 
 
-class Which(Builtin):
+class Which(SympyFunction):
     """
     <url>
     :WMA link:
@@ -710,6 +737,15 @@ def eval(self, items, evaluation):
             items = items[2:]
         return SymbolNull
 
+    def to_sympy(self, expr, **kwargs):
+        if len(expr.elements) % 2 == 0:
+            args = []
+            for cond, value in zip(expr.elements[::2], expr.elements[1::2]):
+                sympy_cond = cond.to_sympy(**kwargs)
+                sympy_value = value.to_sympy(**kwargs)
+                args.append((sympy_value, sympy_cond))
+            return sympy.Piecewise(*args)
+
 
 class While(Builtin):
     """

mathics/builtin/testing_expressions/equality_inequality.py

@@ -269,7 +269,7 @@ def eval_other(self, args, evaluation: Evaluation):
         return SymbolTrue
 
 
-class _MinMax(Builtin):
+class _MinMax(SympyFunction):
     attributes = (
         A_FLAT | A_NUMERIC_FUNCTION | A_ONE_IDENTITY | A_ORDERLESS | A_PROTECTED
     )
@@ -729,6 +729,7 @@ class Max(_MinMax):
     """
 
     summary_text = "get maximum value"
+    sympy_name = "Max"
 
 
 class Min(_MinMax):
@@ -763,6 +764,7 @@ class Min(_MinMax):
 
     sense = -1
     summary_text = "get minimum value"
+    sympy_name = "Min"
 
 
 class SameQ(_ComparisonOperator):

mathics/core/builtin.py

@@ -713,8 +713,11 @@ def to_sympy(self, expr, **kwargs):
                 sympy_function = self.get_sympy_function(elements)
                 if sympy_function is not None:
                     return tracing.run_sympy(sympy_function, *sympy_args)
-        except TypeError:
-            pass
+            elif exc := kwargs.get("raise_on_error", None):
+                raise exc(f"{self.get_name()}.sympy_name is {repr(self.sympy_name)}")
+        except TypeError as oops:
+            if exc := kwargs.get("raise_on_error", None):
+                raise exc(f"TypeError: {oops}")
 
     def from_sympy(self, elements: Tuple[BaseElement, ...]) -> Expression:
         return Expression(Symbol(self.get_name()), *elements)

mathics/core/convert/sympy.py

@@ -247,6 +247,8 @@ def expression_to_sympy(expr: Expression, **kwargs):
         sympy_expr = builtin.to_sympy(expr, **kwargs)
         if sympy_expr is not None:
             return sympy_expr
+    elif exc := kwargs.get("raise_on_error", None):
+        raise exc(f"{lookup_name} not registered in mathics_to_sympy")
     return SympyExpression(expr, **kwargs)
 
 

mathics/eval/drawing/plot_compile.py

@@ -18,7 +18,7 @@
 import scipy
 import sympy
 
-from mathics.core.convert.sympy import SympyExpression, mathics_to_sympy
+from mathics.core.convert.sympy import SympyExpression
 from mathics.core.symbols import strip_context
 from mathics.core.util import print_expression_tree, print_sympy_tree
 
@@ -63,21 +63,8 @@ def plot_compile(evaluation, expr, names, debug=0):
         print("post-eval", expr)
 
     # Ask the expr Expression to generate a sympy expression and handle errors
-    try:
-        sympy_expr = expr.to_sympy()
-    except Exception as oops:
-        raise CompileError(f"{expr}.to_sympy() failed: {oops}")
+    sympy_expr = expr.to_sympy(raise_on_error=CompileError)
     if isinstance(sympy_expr, SympyExpression):
-        if debug:
-            # duplicates lookup logic in mathics.core.convert.sympy
-            lookup_name = expr.get_lookup_name()
-            builtin = mathics_to_sympy.get(lookup_name)
-            if builtin:
-                sympy_name = getattr(builtin, "sympy_name", None) if builtin else None
-                print(f"compile: Invalid sympy_expr {sympy_expr}")
-                print(f"compile: {builtin}.sympy_name is {repr(sympy_name)}")
-            else:
-                print(f"compile: {lookup_name} not registered with mathics_to_sympy")
         raise CompileError(f"{expr.head}.to_sympy returns invalid sympy expr.")
 
     # Strip symbols in sympy expression of context.