Hypergeometric2F1

Author: pbrubeck

ufl/algorithms/apply_derivatives.py

@@ -90,6 +90,7 @@
     Cosh,
     Erf,
     Exp,
+    Hypergeometric2F1,
     Ln,
     MathFunction,
     Sin,
@@ -583,6 +584,19 @@ def _(self, o: Expr, fp: Expr) -> Expr:
         (f,) = o.ufl_operands
         return fp * (2.0 / sqrt(pi) * exp(-(f**2)))
 
+    @process.register(Hypergeometric2F1)
+    @DAGTraverser.postorder
+    def _(self, o: Expr, ap: Expr, bp: Expr, cp: Expr, fp: Expr) -> Expr:
+        """Differentiate a bessel_j."""
+        a, b, c, f = o.ufl_operands
+        if not all(nup is None or isinstance(nup, Zero) for nup in (ap, bp, cp)):
+            raise NotImplementedError(
+                "Differentiation of bessel function w.r.t. (a, b, c) is not supported."
+            )
+
+        op = (a*b/c) * Hypergeometric2F1(a+1, b+1, c+1, f)
+        return op * fp
+
     # --- Bessel functions
 
     @process.register(BesselJ)

ufl/classes.py

@@ -166,6 +166,7 @@
     Cosh,
     Erf,
     Exp,
+    Hypergeometric2F1,
     Ln,
     MathFunction,
     Sin,

ufl/mathfunctions.py

@@ -388,6 +388,40 @@ def evaluate(self, x, mapping, component, index_values):
         return math.erf(a)
 
 
+@ufl_type(is_scalar=True, num_ops=4)
+class Hypergeometric2F1(Operator):
+    """Class for hypergeometric 2F1 functions."""
+
+    __slots__ = "_name"
+
+    def __init__(self, a, b, c, argument):
+        """Initialise."""
+        if not all(is_true_ufl_scalar(f) for f in (a, b, c)):
+            raise ValueError("Expecting scalar (a, b, c).")
+        if not is_true_ufl_scalar(argument):
+            raise ValueError("Expecting scalar argument.")
+
+        Operator.__init__(self, (a, b, c, argument))
+
+        self._name = "hyp2f1"
+
+    def evaluate(self, x, mapping, component, index_values):
+        """Evaluate."""
+        try:
+            import scipy.special  # type: ignore
+        except ImportError:
+            raise ValueError(
+                "You must have scipy installed to evaluate hypergeometric functions in python."
+            )
+        func = getattr(scipy.special, self._name)
+        return func(*(arg.evaluate(x, mapping, component, index_values) for arg in self.ufl_operands))
+
+    def __str__(self):
+        """Format as a string."""
+        return f"{self._name}({self.ufl_operands[0]}, {self.ufl_operands[1]}, {self.ufl_operands[2]}, {self.ufl_operands[3]})"
+
+
+
 @ufl_type(is_abstract=True, is_scalar=True, num_ops=2)
 class BesselFunction(Operator):
     """Base class for all bessel functions."""

ufl/operators.py

@@ -51,6 +51,7 @@
     Cosh,
     Erf,
     Exp,
+    Hypergeometric2F1,
     Ln,
     Sin,
     Sinh,