+static ex beta_evalf(const ex & x, const ex & y)
+{
+ if (is_exactly_a<numeric>(x) && is_exactly_a<numeric>(y)) {
+ try {
+ return exp(lgamma(ex_to<numeric>(x))+lgamma(ex_to<numeric>(y))-lgamma(ex_to<numeric>(x+y)));
+ } catch (const dunno &e) { }
+ }
+
+ return beta(x,y).hold();
+}
+
+
+static ex beta_eval(const ex & x, const ex & y)
+{
+ if (x.is_equal(_ex1))
+ return 1/y;
+ if (y.is_equal(_ex1))
+ return 1/x;
+ if (x.info(info_flags::numeric) && y.info(info_flags::numeric)) {
+ // treat all problematic x and y that may not be passed into tgamma,
+ // because they would throw there although beta(x,y) is well-defined
+ // using the formula beta(x,y) == (-1)^y * beta(1-x-y, y)
+ const numeric &nx = ex_to<numeric>(x);
+ const numeric &ny = ex_to<numeric>(y);
+ if (nx.is_real() && nx.is_integer() &&
+ ny.is_real() && ny.is_integer()) {
+ if (nx.is_negative()) {
+ if (nx<=-ny)
+ return pow(*_num_1_p, ny)*beta(1-x-y, y);
+ else
+ throw (pole_error("beta_eval(): simple pole",1));
+ }
+ if (ny.is_negative()) {
+ if (ny<=-nx)
+ return pow(*_num_1_p, nx)*beta(1-y-x, x);
+ else
+ throw (pole_error("beta_eval(): simple pole",1));
+ }
+ return tgamma(x)*tgamma(y)/tgamma(x+y);
+ }
+ // no problem in numerator, but denominator has pole:
+ if ((nx+ny).is_real() &&
+ (nx+ny).is_integer() &&
+ !(nx+ny).is_positive())
+ return _ex0;
+ if (!ex_to<numeric>(x).is_rational() || !ex_to<numeric>(x).is_rational())
+ return evalf(beta(x, y).hold());
+ }
+
+ return beta(x,y).hold();
+}
+
+
+static ex beta_deriv(const ex & x, const ex & y, unsigned deriv_param)
+{
+ GINAC_ASSERT(deriv_param<2);
+ ex retval;
+
+ // d/dx beta(x,y) -> (psi(x)-psi(x+y)) * beta(x,y)
+ if (deriv_param==0)
+ retval = (psi(x)-psi(x+y))*beta(x,y);
+ // d/dy beta(x,y) -> (psi(y)-psi(x+y)) * beta(x,y)
+ if (deriv_param==1)
+ retval = (psi(y)-psi(x+y))*beta(x,y);
+ return retval;
+}
+
+
+static ex beta_series(const ex & arg1,
+ const ex & arg2,
+ const relational & rel,
+ int order,
+ unsigned options)
+{
+ // method:
+ // Taylor series where there is no pole of one of the tgamma functions
+ // falls back to beta function evaluation. Otherwise, fall back to
+ // tgamma series directly.
+ const ex arg1_pt = arg1.subs(rel, subs_options::no_pattern);
+ const ex arg2_pt = arg2.subs(rel, subs_options::no_pattern);
+ GINAC_ASSERT(is_a<symbol>(rel.lhs()));
+ const symbol &s = ex_to<symbol>(rel.lhs());
+ ex arg1_ser, arg2_ser, arg1arg2_ser;
+ if ((!arg1_pt.info(info_flags::integer) || arg1_pt.info(info_flags::positive)) &&
+ (!arg2_pt.info(info_flags::integer) || arg2_pt.info(info_flags::positive)))
+ throw do_taylor(); // caught by function::series()
+ // trap the case where arg1 is on a pole:
+ if (arg1.info(info_flags::integer) && !arg1.info(info_flags::positive))
+ arg1_ser = tgamma(arg1+s);
+ else
+ arg1_ser = tgamma(arg1);
+ // trap the case where arg2 is on a pole:
+ if (arg2.info(info_flags::integer) && !arg2.info(info_flags::positive))
+ arg2_ser = tgamma(arg2+s);
+ else
+ arg2_ser = tgamma(arg2);
+ // trap the case where arg1+arg2 is on a pole:
+ if ((arg1+arg2).info(info_flags::integer) && !(arg1+arg2).info(info_flags::positive))
+ arg1arg2_ser = tgamma(arg2+arg1+s);
+ else
+ arg1arg2_ser = tgamma(arg2+arg1);
+ // compose the result (expanding all the terms):
+ return (arg1_ser*arg2_ser/arg1arg2_ser).series(rel, order, options).expand();
+}
+
+
+REGISTER_FUNCTION(beta, eval_func(beta_eval).
+ evalf_func(beta_evalf).
+ derivative_func(beta_deriv).
+ series_func(beta_series).
+ latex_name("\\mathrm{B}").
+ set_symmetry(sy_symm(0, 1)));
+
+
+//////////
+// Psi-function (aka digamma-function)
+//////////
+
+static ex psi1_evalf(const ex & x)
+{
+ if (is_exactly_a<numeric>(x)) {
+ try {
+ return psi(ex_to<numeric>(x));
+ } catch (const dunno &e) { }
+ }
+
+ return psi(x).hold();
+}
+
+/** Evaluation of digamma-function psi(x).