Better eval for beta

Author: oscargus

sympy/functions/special/beta_functions.py

@@ -2,6 +2,7 @@
 from sympy.core.function import Function, ArgumentIndexError
 from sympy.core.symbol import Dummy
 from sympy.functions.special.gamma_functions import gamma, digamma
+from sympy.functions.combinatorial.numbers import catalan
 from sympy.functions.elementary.complexes import conjugate
 
 # See mpmath #569 and SymPy #20569
@@ -120,10 +121,32 @@ def fdiff(self, argindex):
     def eval(cls, x, y=None):
         if y is None:
             return beta(x, x)
+        if x.is_Number and y.is_Number:
+            return beta(x, y, evaluate=False).doit()
+
+    def doit(self, **hints):
+        x = xold = self.args[0]
+        # Deal with unevaluated single argument beta
+        single_argument = len(self.args) == 1
+        y = yold = self.args[0] if single_argument else self.args[1]
+        if hints.get('deep', True):
+            x = x.doit(**hints)
+            y = y.doit(**hints)
+        if y.is_zero or x.is_zero:
+            return S.ComplexInfinity
         if y is S.One:
             return 1/x
         if x is S.One:
             return 1/y
+        if y == x + 1:
+            return 1/(x*y*catalan(x))
+        s = x + y
+        if (s.is_integer and s.is_negative and x.is_integer is False and
+            y.is_integer is False):
+            return S.Zero
+        if x == xold and y == yold and not single_argument:
+            return self
+        return beta(x, y)
 
     def _eval_expand_func(self, **hints):
         x, y = self.args

sympy/functions/special/tests/test_beta_functions.py

@@ -1,12 +1,14 @@
 from sympy.core.function import (diff, expand_func)
-from sympy.core.numbers import I
+from sympy.core.numbers import I, Rational, pi
+from sympy.core.singleton import S
 from sympy.core.symbol import (Dummy, symbols)
+from sympy.functions.combinatorial.numbers import catalan
 from sympy.functions.elementary.complexes import conjugate
+from sympy.functions.elementary.miscellaneous import sqrt
 from sympy.functions.special.beta_functions import (beta, betainc, betainc_regularized)
-from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.gamma_functions import gamma, polygamma
 from sympy.functions.special.hyper import hyper
 from sympy.integrals.integrals import Integral
-from sympy.functions.special.gamma_functions import polygamma
 from sympy.core.function import ArgumentIndexError
 from sympy.core.expr import unchanged
 from sympy.testing.pytest import raises
@@ -17,6 +19,7 @@ def test_beta():
     t = Dummy('t')
 
     assert unchanged(beta, x, y)
+    assert unchanged(beta, x, x)
 
     assert beta(5, -3).is_real == True
     assert beta(3, y).is_real is None
@@ -35,6 +38,24 @@ def test_beta():
     assert beta(x, y).rewrite(gamma) == gamma(x)*gamma(y)/gamma(x + y)
     assert beta(x).rewrite(gamma) == gamma(x)**2/gamma(2*x)
     assert beta(x, y).rewrite(Integral).dummy_eq(Integral(t**(x - 1) * (1 - t)**(y - 1), (t, 0, 1)))
+    assert beta(Rational(-19, 10), Rational(-1, 10)) == S.Zero
+    assert beta(Rational(-19, 10), Rational(-9, 10)) == \
+        800*2**(S(4)/5)*sqrt(pi)*gamma(S.One/10)/(171*gamma(-S(7)/5))
+    assert beta(Rational(19, 10), Rational(29, 10)) == 100/(551*catalan(Rational(19, 10)))
+    assert beta(1, 0) == S.ComplexInfinity
+    assert beta(0, 1) == S.ComplexInfinity
+    assert beta(2, 3) == S.One/12
+    assert unchanged(beta, x, x + 1)
+    assert unchanged(beta, x, 1)
+    assert unchanged(beta, 1, y)
+    assert beta(x, x + 1).doit() == 1/(x*(x+1)*catalan(x))
+    assert beta(1, y).doit() == 1/y
+    assert beta(x, 1).doit() == 1/x
+    assert beta(Rational(-19, 10), Rational(-1, 10), evaluate=False).doit() == S.Zero
+    assert beta(2) == beta(2, 2)
+    assert beta(x, evaluate=False) != beta(x, x)
+    assert beta(x, evaluate=False).doit() == beta(x, x)
+
 
 def test_betainc():
     a, b, x1, x2 = symbols('a b x1 x2')
@@ -51,6 +72,7 @@ def test_betainc():
 
     assert betainc(1, 2, 3, 3).evalf() == 0
 
+
 def test_betainc_regularized():
     a, b, x1, x2 = symbols('a b x1 x2')
 

sympy/printing/latex.py

@@ -1219,8 +1219,10 @@ def _print_elliptic_pi(self, expr, exp=None):
             return r"\Pi%s" % tex
 
     def _print_beta(self, expr, exp=None):
-        tex = r"\left(%s, %s\right)" % (self._print(expr.args[0]),
-                                        self._print(expr.args[1]))
+        x = expr.args[0]
+        # Deal with unevaluated single argument beta
+        y = expr.args[0] if len(expr.args) == 1 else expr.args[1]
+        tex = rf"\left({x}, {y}\right)"
 
         if exp is not None:
             return r"\operatorname{B}^{%s}%s" % (exp, tex)

sympy/printing/tests/test_latex.py

@@ -450,6 +450,7 @@ def test_latex_functions():
     # not to be confused with the beta function
     assert latex(mybeta(x, y, z)) == r"\beta{\left(x,y,z \right)}"
     assert latex(beta(x, y)) == r'\operatorname{B}\left(x, y\right)'
+    assert latex(beta(x, evaulate=False)) == r'\operatorname{B}\left(x, x\right)'
     assert latex(beta(x, y)**2) == r'\operatorname{B}^{2}\left(x, y\right)'
     assert latex(mybeta(x)) == r"\beta{\left(x \right)}"
     assert latex(mybeta) == r"\beta"