Move more functions to eval. Simplify

Author: rocky

mathics/builtin/specialfns/hypergeom.py

@@ -7,7 +7,6 @@
 """
 
 import mpmath
-import sympy
 
 import mathics.eval.tracing as tracing
 from mathics.core.attributes import (
@@ -18,13 +17,13 @@
 )
 from mathics.core.builtin import MPMathFunction
 from mathics.core.convert.mpmath import from_mpmath
-from mathics.core.convert.sympy import from_sympy
 from mathics.core.evaluation import Evaluation
 from mathics.core.systemsymbols import SymbolComplexInfinity, SymbolMachinePrecision
 from mathics.eval.specialfns.hypergeom import (
     eval_Hypergeometric1F1,
     eval_Hypergeometric2F1,
     eval_HypergeometricPQF,
+    eval_MeijerG,
     eval_N_HypergeometricPQF,
 )
 
@@ -202,6 +201,47 @@ def eval(self, a, b, c, z, evaluation: Evaluation):
         return eval_Hypergeometric2F1(a, b, c, z)
 
 
+class HypergeometricU(MPMathFunction):
+    """
+    <url>
+    :Confluent hypergeometric function: https://en.wikipedia.org/wiki/Confluent_hypergeometric_function</url> (<url>
+    :mpmath: https://mpmath.org/doc/current/functions/bessel.html#mpmath.hyperu</url>, <url>
+    :WMA: https://reference.wolfram.com/language/ref/HypergeometricU.html</url>)
+    <dl>
+      <dt>'HypergeometricU'[$a$, $b$, $z$]
+      <dd>returns $U(a, b, z)$.
+    </dl>
+    Result is symbollicaly simplified, where possible:
+    >> HypergeometricU[3, 2, 1]
+     = MeijerG[{{-2}, {}}, {{0, -1}, {}}, 1] / 2
+    >> HypergeometricU[1,4,8]
+     = HypergeometricU[1, 4, 8]
+    unless a numerical evaluation is explicitly requested:
+    >> HypergeometricU[3, 2, 1] // N
+     = 0.105479
+    >> HypergeometricU[3, 2, 1.]
+     = 0.105479
+
+    Plot 'U'[3, 2, x] from 0 to 10 in steps of 0.5:
+    >> Plot[HypergeometricU[3, 2, x], {x, 0.5, 10}]
+     = -Graphics-
+
+    We handle this special case:
+    >> HypergeometricU[0, b, z]
+     = 1
+    """
+
+    attributes = A_LISTABLE | A_NUMERIC_FUNCTION | A_PROTECTED | A_READ_PROTECTED
+    mpmath_name = "hyperu"
+    nargs = {3}
+    rules = {
+        "HypergeometricU[0, c_, z_]": "1",
+        "HypergeometricU[a_, b_, z_] /; (a > 0) && (a-b+1 > 0)": "MeijerG[{{1-a},{}},{{0,1-b},{}},z]/Gamma[a]/Gamma[a-b+1]",
+    }
+    summary_text = "compute the Tricomi confluent hypergeometric function"
+    sympy_name = ""
+
+
 class MeijerG(MPMathFunction):
     """
     <url>
@@ -232,15 +272,7 @@ class MeijerG(MPMathFunction):
 
     def eval(self, a, b, z, evaluation: Evaluation):
         "MeijerG[a_, b_, z_]"
-        try:
-            a_sympy = [[e2.to_sympy() for e2 in e1] for e1 in a]
-            b_sympy = [[e2.to_sympy() for e2 in e1] for e1 in b]
-            result_sympy = tracing.run_sympy(
-                sympy.meijerg, a_sympy, b_sympy, z.to_sympy()
-            )
-            return from_sympy(result_sympy)
-        except Exception:
-            pass
+        return eval_MeijerG(a, b, z)
 
     def eval_N(self, a, b, z, prec, evaluation: Evaluation):
         "N[MeijerG[a_, b_, z_], prec_]"
@@ -257,44 +289,3 @@ def eval_N(self, a, b, z, prec, evaluation: Evaluation):
     def eval_numeric(self, a, b, z, evaluation: Evaluation):
         "MeijerG[a:{___List?(AllTrue[#, NumericQ, Infinity]&)}, b:{___List?(AllTrue[#, NumericQ, Infinity]&)}, z_?MachineNumberQ]"
         return self.eval_N(a, b, z, SymbolMachinePrecision, evaluation)
-
-
-class HypergeometricU(MPMathFunction):
-    """
-    <url>
-    :Confluent hypergeometric function: https://en.wikipedia.org/wiki/Confluent_hypergeometric_function</url> (<url>
-    :mpmath: https://mpmath.org/doc/current/functions/bessel.html#mpmath.hyperu</url>, <url>
-    :WMA: https://reference.wolfram.com/language/ref/HypergeometricU.html</url>)
-    <dl>
-      <dt>'HypergeometricU'[$a$, $b$, $z$]
-      <dd>returns $U(a, b, z)$.
-    </dl>
-    Result is symbollicaly simplified, where possible:
-    >> HypergeometricU[3, 2, 1]
-     = MeijerG[{{-2}, {}}, {{0, -1}, {}}, 1] / 2
-    >> HypergeometricU[1,4,8]
-     = HypergeometricU[1, 4, 8]
-    unless a numerical evaluation is explicitly requested:
-    >> HypergeometricU[3, 2, 1] // N
-     = 0.105479
-    >> HypergeometricU[3, 2, 1.]
-     = 0.105479
-
-    Plot 'U'[3, 2, x] from 0 to 10 in steps of 0.5:
-    >> Plot[HypergeometricU[3, 2, x], {x, 0.5, 10}]
-     = -Graphics-
-
-    We handle this special case:
-    >> HypergeometricU[0, b, z]
-     = 1
-    """
-
-    attributes = A_LISTABLE | A_NUMERIC_FUNCTION | A_PROTECTED | A_READ_PROTECTED
-    mpmath_name = "hyperu"
-    nargs = {3}
-    rules = {
-        "HypergeometricU[0, c_, z_]": "1",
-        "HypergeometricU[a_, b_, z_] /; (a > 0) && (a-b+1 > 0)": "MeijerG[{{1-a},{}},{{0,1-b},{}},z]/Gamma[a]/Gamma[a-b+1]",
-    }
-    summary_text = "compute the Tricomi confluent hypergeometric function"
-    sympy_name = ""

mathics/eval/specialfns/hypergeom.py

@@ -2,7 +2,7 @@
 Evaluation functions for built-in Hypergeometric functions
 """
 
-from typing import Sequence, cast
+from typing import Sequence, Tuple, cast
 
 import mpmath
 import sympy
@@ -27,23 +27,7 @@ def eval_Hypergeometric1F1(a, b, z):
     """
 
     args = (a, b, z)
-
-    sympy_args = []
-    all_numeric = True
-    for arg in args:
-        if isinstance(arg, Number):
-            # FIXME: in the future, .value
-            # should work on Complex numbers.
-            if isinstance(arg, Complex):
-                sympy_arg = arg.to_python()
-            else:
-                sympy_arg = arg.value
-        else:
-            sympy_arg = arg.to_sympy()
-            all_numeric = False
-
-        sympy_args.append(sympy_arg)
-
+    sympy_args, all_numeric = to_sympy_with_classification(args)
     sympy_result = tracing.run_sympy(
         sympy.hyper, [sympy_args[0]], [sympy_args[1]], sympy_args[2]
     )
@@ -79,20 +63,7 @@ def eval_Hypergeometric2F1(a, b, c, z):
     """
 
     args = (a, b, c, z)
-    sympy_args = []
-    all_numeric = True
-    for arg in args:
-        if isinstance(arg, Number):
-            if isinstance(arg, Complex):
-                sympy_arg = arg.to_python()
-            else:
-                sympy_arg = arg.value
-        else:
-            sympy_arg = arg.to_sympy()
-            all_numeric = False
-
-        sympy_args.append(sympy_arg)
-
+    sympy_args, all_numeric = to_sympy_with_classification(args)
     if all_numeric:
         args = cast(Sequence[Number], args)
 
@@ -138,7 +109,66 @@ def eval_N_HypergeometricPQF(a, b, z):
         return None
 
 
+def eval_MeijerG(a, b, z):
+    """
+    Use sympy.meijerg to compute MeijerG(a, b, z)
+    """
+    try:
+        a_sympy = [[e2.to_sympy() for e2 in e1] for e1 in a]
+        b_sympy = [[e2.to_sympy() for e2 in e1] for e1 in b]
+        result_sympy = tracing.run_sympy(sympy.meijerg, a_sympy, b_sympy, z.to_sympy())
+        # For now, we don't allow simplification and conversion
+        # to other functions like Bessel, because this can introduce
+        # SymPy's exp_polar() function for which we don't have a
+        # Mathics3 equivalent for yet.
+        # return from_sympy(sympy.hyperexpand(result_sympy))
+        return from_sympy(result_sympy)
+    except Exception:
+        return None
+
+
+# FIXME: ADDING THIS causes test/doc/test_common.py to fail! It reports that Hypergeometric has been included more than once
+# Weird!
+
+# def eval_N_MeijerG(a, b, z):
+#     "N[MeijerG[a_, b_, z_], prec_]"
+#     try:
+#         result_mpmath = tracing.run_mpmath(
+#             mpmath.meijerg, a.to_python(), b.to_python(), z.to_python()
+#         )
+#         return from_mpmath(result_mpmath)
+#     except ZeroDivisionError:
+#         return SymbolComplexInfinity
+#     except Exception:
+#         return None
+
+
 def run_sympy_hyper(a, b, z):
     sympy_result = tracing.run_sympy(sympy.hyper, a, b, z)
     result = sympy.hyperexpand(sympy_result)
     return from_sympy(result)
+
+
+def to_sympy_with_classification(args: tuple) -> Tuple[list, bool]:
+    """Converts `args` to its corresponding SymPy form.  However, if
+    all elements of args are numeric, then we detect and report that.
+    We do this so that the caller can decide whether to use mpmath if
+    SymPy fails. One might expect SymPy to do this automatically, but
+    it doesn't catch all opportunites.
+    """
+    sympy_args = []
+    all_numeric = True
+    for arg in args:
+        if isinstance(arg, Number):
+            # FIXME: in the future, .value
+            # should work on Complex numbers.
+            if isinstance(arg, Complex):
+                sympy_arg = arg.to_python()
+            else:
+                sympy_arg = arg.value
+        else:
+            sympy_arg = arg.to_sympy()
+            all_numeric = False
+
+        sympy_args.append(sympy_arg)
+    return sympy_args, all_numeric