* some related stuff. */
/*
- * GiNaC Copyright (C) 1999-2005 Johannes Gutenberg University Mainz, Germany
+ * GiNaC Copyright (C) 1999-2016 Johannes Gutenberg University Mainz, Germany
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
-#include <vector>
-#include <stdexcept>
-
#include "inifcns.h"
#include "constant.h"
#include "pseries.h"
#include "symmetry.h"
#include "utils.h"
+#include <stdexcept>
+#include <vector>
+
namespace GiNaC {
//////////
/** Evaluation of lgamma(x), the natural logarithm of the Gamma function.
- * Knows about integer arguments and that's it. Somebody ought to provide
- * some good numerical evaluation some day...
+ * Handles integer arguments as a special case.
*
* @exception GiNaC::pole_error("lgamma_eval(): logarithmic pole",0) */
static ex lgamma_eval(const ex & x)
else
throw (pole_error("lgamma_eval(): logarithmic pole",0));
}
- // lgamma_evalf should be called here once it becomes available
+ if (!ex_to<numeric>(x).is_rational())
+ return lgamma(ex_to<numeric>(x));
}
return lgamma(x).hold();
}
+static ex lgamma_conjugate(const ex & x)
+{
+ // conjugate(lgamma(x))==lgamma(conjugate(x)) unless on the branch cut
+ // which runs along the negative real axis.
+ if (x.info(info_flags::positive)) {
+ return lgamma(x);
+ }
+ if (is_exactly_a<numeric>(x) &&
+ !x.imag_part().is_zero()) {
+ return lgamma(x.conjugate());
+ }
+ return conjugate_function(lgamma(x)).hold();
+}
+
+
REGISTER_FUNCTION(lgamma, eval_func(lgamma_eval).
evalf_func(lgamma_evalf).
derivative_func(lgamma_deriv).
series_func(lgamma_series).
+ conjugate_func(lgamma_conjugate).
latex_name("\\log \\Gamma"));
return (pow(*_num_2_p, n).div(doublefactorial(n.mul(*_num2_p).sub(*_num1_p))))*sqrt(Pi);
}
}
- // tgamma_evalf should be called here once it becomes available
+ if (!ex_to<numeric>(x).is_rational())
+ return tgamma(ex_to<numeric>(x));
}
return tgamma(x).hold();
}
+static ex tgamma_conjugate(const ex & x)
+{
+ // conjugate(tgamma(x))==tgamma(conjugate(x))
+ return tgamma(x.conjugate());
+}
+
+
REGISTER_FUNCTION(tgamma, eval_func(tgamma_eval).
evalf_func(tgamma_evalf).
derivative_func(tgamma_deriv).
series_func(tgamma_series).
+ conjugate_func(tgamma_conjugate).
latex_name("\\Gamma"));
{
if (is_exactly_a<numeric>(x) && is_exactly_a<numeric>(y)) {
try {
- return tgamma(ex_to<numeric>(x))*tgamma(ex_to<numeric>(y))/tgamma(ex_to<numeric>(x+y));
+ return exp(lgamma(ex_to<numeric>(x))+lgamma(ex_to<numeric>(y))-lgamma(ex_to<numeric>(x+y)));
} catch (const dunno &e) { }
}
(nx+ny).is_integer() &&
!(nx+ny).is_positive())
return _ex0;
- // beta_evalf should be called here once it becomes available
+ if (!ex_to<numeric>(x).is_rational() || !ex_to<numeric>(x).is_rational())
+ return evalf(beta(x, y).hold());
}
return beta(x,y).hold();
evalf_func(beta_evalf).
derivative_func(beta_deriv).
series_func(beta_series).
- latex_name("\\mbox{B}").
- set_symmetry(sy_symm(0, 1)));
+ latex_name("\\mathrm{B}").
+ set_symmetry(sy_symm(0, 1)));
//////////