+/** Evaluation of digamma-function psi(x).
+ * Somebody ought to provide some good numerical evaluation some day... */
+static ex psi1_eval(ex const & x)
+{
+ if (x.info(info_flags::numeric)) {
+ if (x.info(info_flags::integer) && !x.info(info_flags::positive))
+ throw (std::domain_error("psi_eval(): simple pole"));
+ if (x.info(info_flags::positive)) {
+ // psi(n) -> 1 + 1/2 +...+ 1/(n-1) - EulerGamma
+ if (x.info(info_flags::integer)) {
+ numeric rat(0);
+ for (numeric i(ex_to_numeric(x)-_num1()); i.is_positive(); --i)
+ rat += i.inverse();
+ return rat-EulerGamma;
+ }
+ // psi((2m+1)/2) -> 2/(2m+1) + 2/2m +...+ 2/1 - EulerGamma - 2log(2)
+ if ((_ex2()*x).info(info_flags::integer)) {
+ numeric rat(0);
+ for (numeric i((ex_to_numeric(x)-_num1())*_num2()); i.is_positive(); i-=_num2())
+ rat += _num2()*i.inverse();
+ return rat-EulerGamma-_ex2()*log(_ex2());
+ }
+ if (x.compare(_ex1())==1) {
+ // should call numeric, since >1
+ }
+ }
+ }
+ return psi(x).hold();
+}
+
+static ex psi1_diff(ex const & x, unsigned diff_param)
+{
+ GINAC_ASSERT(diff_param==0);
+
+ // d/dx psi(x) -> psi(1,x)
+ return psi(_ex1(), x);
+}
+
+static ex psi1_series(ex const & x, symbol const & s, ex const & point, int order)
+{
+ // method:
+ // Taylor series where there is no pole falls back to polygamma function
+ // evaluation.
+ // On a pole at -m use the recurrence relation
+ // psi(x) == psi(x+1) - 1/z
+ // from which follows
+ // series(psi(x),x,-m,order) ==
+ // series(psi(x+m+1) - 1/x - 1/(x+1) - 1/(x+m)),x,-m,order);
+ ex xpoint = x.subs(s==point);
+ if (!xpoint.info(info_flags::integer) || xpoint.info(info_flags::positive))
+ throw do_taylor(); // caught by function::series()
+ // if we got here we have to care for a simple pole at -m:
+ numeric m = -ex_to_numeric(xpoint);
+ ex recur;
+ for (numeric p; p<=m; ++p)
+ recur += power(x+p,_ex_1());
+ return (psi(x+m+_ex1())-recur).series(s, point, order);
+}
+
+const unsigned function_index_psi1 = function::register_new("psi", psi1_eval, psi1_evalf, psi1_diff, psi1_series);
+
+//////////
+// Psi-functions (aka polygamma-functions) psi(0,x)==psi(x)
+//////////
+
+static ex psi2_evalf(ex const & n, ex const & x)
+{
+ BEGIN_TYPECHECK
+ TYPECHECK(n,numeric)
+ TYPECHECK(x,numeric)
+ END_TYPECHECK(psi(n,x))
+
+ return psi(ex_to_numeric(n), ex_to_numeric(x));
+}
+
+/** Evaluation of polygamma-function psi(n,x).
+ * Somebody ought to provide some good numerical evaluation some day... */
+static ex psi2_eval(ex const & n, ex const & x)
+{
+ // psi(0,x) -> psi(x)
+ if (n.is_zero())
+ return psi(x);
+ // psi(-1,x) -> log(gamma(x))
+ if (n.is_equal(_ex_1()))
+ return log(gamma(x));
+ if (n.info(info_flags::numeric) && n.info(info_flags::posint) &&
+ x.info(info_flags::numeric)) {
+ numeric nn = ex_to_numeric(n);
+ numeric nx = ex_to_numeric(x);
+ if (x.is_equal(_ex1()))
+ return _num_1().power(nn+_num1())*factorial(nn)*zeta(ex(nn+_num1()));
+ }
+ return psi(n, x).hold();
+}
+
+static ex psi2_diff(ex const & n, ex const & x, unsigned diff_param)
+{
+ GINAC_ASSERT(diff_param<2);
+
+ if (diff_param==0) {
+ // d/dn psi(n,x)
+ throw(std::logic_error("cannot diff psi(n,x) with respect to n"));
+ }
+ // d/dx psi(n,x) -> psi(n+1,x)
+ return psi(n+1, x);
+}
+
+static ex psi2_series(ex const & n, ex const & x, symbol const & s, ex const & point, int order)
+{
+ // method:
+ // Taylor series where there is no pole falls back to polygamma function
+ // evaluation.
+ // On a pole at -m use the recurrence relation
+ // psi(n,x) == psi(n,x+1) - (-)^n * n! / z^(n+1)
+ // from which follows
+ // series(psi(x),x,-m,order) ==
+ // series(psi(x+m+1) - (-1)^n * n!
+ // * ((x)^(-n-1) + (x+1)^(-n-1) + (x+m)^(-n-1))),x,-m,order);
+ ex xpoint = x.subs(s==point);
+ if (!xpoint.info(info_flags::integer) || xpoint.info(info_flags::positive))
+ throw do_taylor(); // caught by function::series()
+ // if we got here we have to care for a pole of order n+1 at -m:
+ numeric m = -ex_to_numeric(xpoint);
+ ex recur;
+ for (numeric p; p<=m; ++p)
+ recur += power(x+p,-n+_ex_1());
+ recur *= factorial(n)*power(_ex_1(),n);
+ return (psi(n, x+m+_ex1())-recur).series(s, point, order);
+}
+
+const unsigned function_index_psi2 = function::register_new("psi", psi2_eval, psi2_evalf, psi2_diff, psi2_series);
+
+#ifndef NO_GINAC_NAMESPACE
+} // namespace GiNaC
+#endif // ndef NO_GINAC_NAMESPACE