Merge pull request #1191 from mathics/simplify-sympy-fns

Try simplying SympyFunction builtins

Author: rocky

mathics/Makefile

@@ -1095,6 +1095,7 @@ class Re(SympyFunction):
     """
 
     attributes = ("Listable", "NumericFunction")
+    sympy_name = "re"
 
     def apply_complex(self, number, evaluation):
         "Re[number_Complex]"
@@ -1209,7 +1210,7 @@ class Abs(_MPMathFunction):
     mpmath_name = "fabs"  # mpmath actually uses python abs(x) / x.__abs__()
 
 
-class Sign(Builtin):
+class Sign(SympyFunction):
     """
     <dl>
     <dt>'Sign[$x$]'
@@ -1237,8 +1238,7 @@ class Sign(Builtin):
      = Sign[20]
     """
 
-    # Sympy and mpmath do not give the desired form of complex number
-    # sympy_name = 'sign'
+    sympy_name = "sign"
     # mpmath_name = 'sign'
 
     attributes = ("Listable", "NumericFunction")
@@ -1248,14 +1248,15 @@ class Sign(Builtin):
     }
 
     def apply(self, x, evaluation):
-        "Sign[x_]"
+        "%(name)s[x_]"
+        # Sympy and mpmath do not give the desired form of complex number
         if isinstance(x, Complex):
             return Expression("Times", x, Expression("Power", Expression("Abs", x), -1))
 
         sympy_x = x.to_sympy()
         if sympy_x is None:
             return None
-        return from_sympy(sympy.sign(sympy_x))
+        return super().apply(x)
 
     def apply_error(self, x, seqs, evaluation):
         "Sign[x_, seqs__]"
@@ -1591,7 +1592,7 @@ class Rational_(Builtin):
     name = "Rational"
 
     def apply(self, n, m, evaluation):
-        "Rational[n_Integer, m_Integer]"
+        "%(name)s[n_Integer, m_Integer]"
 
         if m.to_sympy() == 1:
             return Integer(n.to_sympy())
@@ -1658,7 +1659,7 @@ class Complex_(Builtin):
     name = "Complex"
 
     def apply(self, r, i, evaluation):
-        "Complex[r_?NumberQ, i_?NumberQ]"
+        "%(name)s[r_?NumberQ, i_?NumberQ]"
 
         if isinstance(r, Complex) or isinstance(i, Complex):
             sym_form = r.to_sympy() + sympy.I * i.to_sympy()
@@ -2063,7 +2064,7 @@ class Piecewise(SympyFunction):
     attributes = ("HoldAll",)
 
     def apply(self, items, evaluation):
-        "Piecewise[items__]"
+        "%(name)s[items__]"
         result = self.to_sympy(Expression("Piecewise", *items.get_sequence()))
         if result is None:
             return
@@ -2129,7 +2130,7 @@ class Boole(Builtin):
     attributes = ("Listable",)
 
     def apply(self, expr, evaluation):
-        "Boole[expr_]"
+        "%(name)s[expr_]"
         if isinstance(expr, Symbol):
             if expr == SymbolTrue:
                 return Integer(1)

mathics/builtin/arithmetic.py

@@ -2,7 +2,6 @@
 
 import re
 import sympy
-
 from functools import total_ordering
 import importlib
 from itertools import chain
@@ -11,6 +10,7 @@
 
 from mathics.version import __version__  # noqa used in loading to check consistency.
 
+from mathics.core.convert import from_sympy
 from mathics.core.definitions import Definition
 from mathics.core.parser.util import SystemDefinitions, PyMathicsDefinitions
 from mathics.core.rules import Rule, BuiltinRule, Pattern
@@ -444,7 +444,6 @@ def get_sympy_names(self) -> typing.List[str]:
             return [self.sympy_name]
         return []
 
-
 class UnaryOperator(Operator):
     def __init__(self, format_function, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -532,6 +531,17 @@ def apply(self, expr, evaluation) -> Symbol:
 
 
 class SympyFunction(SympyObject):
+
+    def apply(self, *args):
+        """
+        Generic apply method that uses the class sympy_name.
+        to call the corresponding sympy function. Arguments are
+        converted to python and the result is converted from sympy
+        """
+        sympy_args = [a.to_sympy() for a in args]
+        sympy_fn = getattr(sympy, self.sympy_name)
+        return from_sympy(sympy_fn(*sympy_args))
+
     def get_constant(self, precision, evaluation, have_mpmath=False):
         try:
             d = get_precision(precision, evaluation)
@@ -572,6 +582,8 @@ def prepare_mathics(self, sympy_expr):
         return sympy_expr
 
 
+
+
 class InvalidLevelspecError(Exception):
     pass
 

mathics/builtin/base.py

@@ -39,7 +39,7 @@ class ContinuedFraction(SympyFunction):
 
     def apply_1(self, x, evaluation):
         "%(name)s[x_]"
-        return from_python(sympy.continued_fraction(x.to_sympy()))
+        return super().apply(x)
 
     def apply_2(self, x, n, evaluation):
         "%(name)s[x_, n_Integer]"
@@ -686,7 +686,7 @@ class PartitionsP(SympyFunction):
 
     def apply(self, n, evaluation):
         "PartitionsP[n_Integer]"
-        return from_sympy(sympy.npartitions(n.to_sympy()))
+        return super().apply(n)
 
 
 class PowerMod(Builtin):