Merge branch 'master' into good_bye_sympy_dummy_attribute

Author: mmatera

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,28 @@ 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)
+            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 not (
+                sympy_cond.is_Boolean
+                or sympy_cond.is_Relational
+                or sympy_cond.is_Symbol
+            ):
+                return
+            sympy_true = expr.elements[1].to_sympy(**kwargs)
+            sympy_false = expr.elements[2].to_sympy(**kwargs)
+
+            return sympy.Piecewise((sympy_true, sympy_cond), (sympy_false, True))
+
 
 class Interrupt(Builtin):
     r"""
@@ -648,7 +677,7 @@ def eval_with_tag(
         raise WLThrowInterrupt(value, tag)
 
 
-class Which(Builtin):
+class Which(SympyFunction):
     """
     <url>
     :WMA link:
@@ -710,6 +739,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

@@ -254,6 +254,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.