Try simplying SympyFunction builtins

Would have expected to catch/DRY more items here. But I am optimistic
that by starting this as we add more Sympy functions we will be making
more use of this.

I think it is better to have one way that is used regularly than open-code this
a number of places.

Author: rocky

mathics/builtin/arithmetic.py

@@ -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")
@@ -1249,13 +1249,14 @@ class Sign(Builtin):
 
     def apply(self, x, evaluation):
         "Sign[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__]"

mathics/builtin/base.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/numbertheory.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):