## Gamma Function

The Gamma function is defined by the following integral,

Further information on the Gamma function can be found in Abramowitz & Stegun, Chapter 6. The functions described in this section are declared in the header file gsl_sf_gamma.h'.

Function: double gsl_sf_gamma (double x)
Function: int gsl_sf_gamma_e (double x, gsl_sf_result * result)
These routines compute the Gamma function @math{\Gamma(x)}, subject to x not being a negative integer. The function is computed using the real Lanczos method. The maximum value of @math{x} such that @math{\Gamma(x)} is not considered an overflow is given by the macro GSL_SF_GAMMA_XMAX and is 171.0.

Function: double gsl_sf_lngamma (double x)
Function: int gsl_sf_lngamma_e (double x, gsl_sf_result * result)
These routines compute the logarithm of the Gamma function, @math{\log(\Gamma(x))}, subject to @math{x} not a being negative integer. For @math{x<0} the real part of @math{\log(\Gamma(x))} is returned, which is equivalent to @math{\log(|\Gamma(x)|)}. The function is computed using the real Lanczos method.

Function: int gsl_sf_lngamma_sgn_e (double x, gsl_sf_result * result_lg, double * sgn)
This routine computes the sign of the gamma function and the logarithm its magnitude, subject to @math{x} not being a negative integer. The function is computed using the real Lanczos method. The value of the gamma function can be reconstructed using the relation @math{\Gamma(x) = sgn * \exp(resultlg)}.

Function: double gsl_sf_gammastar (double x)
Function: int gsl_sf_gammastar_e (double x, gsl_sf_result * result)
These routines compute the regulated Gamma Function @math{\Gamma^*(x)} for @math{x > 0}. The regulated gamma function is given by,

and is a useful suggestion of Temme.

Function: double gsl_sf_gammainv (double x)
Function: int gsl_sf_gammainv_e (double x, gsl_sf_result * result)
These routines compute the reciprocal of the gamma function, @math{1/\Gamma(x)} using the real Lanczos method.

Function: int gsl_sf_lngamma_complex_e (double zr, double zi, gsl_sf_result * lnr, gsl_sf_result * arg)
This routine computes @math{\log(\Gamma(z))} for complex @math{z=z_r+i z_i} and @math{z} not a negative integer, using the complex Lanczos method. The returned parameters are @math{lnr = \log|\Gamma(z)|} and @math{arg = \arg(\Gamma(z))} in @math{(-\pi,\pi]}. Note that the phase part (arg) is not well-determined when @math{|z|} is very large, due to inevitable roundoff in restricting to @math{(-\pi,\pi]}. This will result in a GSL_ELOSS error when it occurs. The absolute value part (lnr), however, never suffers from loss of precision.

Function: double gsl_sf_taylorcoeff (int n, double x)
Function: int gsl_sf_taylorcoeff_e (int n, double x, gsl_sf_result * result)
These routines compute the Taylor coefficient @math{x^n / n!} for @math{x >= 0}, @math{n >= 0}.

Function: double gsl_sf_fact (unsigned int n)
Function: int gsl_sf_fact_e (unsigned int n, gsl_sf_result * result)
These routines compute the factorial @math{n!}. The factorial is related to the Gamma function by @math{n! = \Gamma(n+1)}.

Function: double gsl_sf_doublefact (unsigned int n)
Function: int gsl_sf_doublefact_e (unsigned int n, gsl_sf_result * result)
These routines compute the double factorial @math{n!! = n(n-2)(n-4) \dots}.

Function: double gsl_sf_lnfact (unsigned int n)
Function: int gsl_sf_lnfact_e (unsigned int n, gsl_sf_result * result)
These routines compute the logarithm of the factorial of n, @math{\log(n!)}. The algorithm is faster than computing @math{\ln(\Gamma(n+1))} via gsl_sf_lngamma for @math{n < 170}, but defers for larger n.

Function: double gsl_sf_lndoublefact (unsigned int n)
Function: int gsl_sf_lndoublefact_e (unsigned int n, gsl_sf_result * result)
These routines compute the logarithm of the double factorial of n, @math{\log(n!!)}.

Function: double gsl_sf_choose (unsigned int n, unsigned int m)
Function: int gsl_sf_choose_e (unsigned int n, unsigned int m, gsl_sf_result * result)
These routines compute the combinatorial factor n choose m @math{= n!/(m!(n-m)!)}

Function: double gsl_sf_lnchoose (unsigned int n, unsigned int m)
Function: int gsl_sf_lnchoose_e (unsigned int n, unsigned int m, gsl_sf_result * result)
These routines compute the logarithm of n choose m`. This is equivalent to the sum @math{\log(n!) - \log(m!) - \log((n-m)!)}.

Function: double gsl_sf_poch (double a, double x)
Function: int gsl_sf_poch_e (double a, double x, gsl_sf_result * result)
These routines compute the Pochhammer symbol @math{(a)_x := \Gamma(a + x)/\Gamma(x)}, subject to @math{a} and @math{a+x} not being negative integers. The Pochhammer symbol is also known as the Apell symbol.

Function: double gsl_sf_lnpoch (double a, double x)
Function: int gsl_sf_lnpoch_e (double a, double x, gsl_sf_result * result)
These routines compute the logarithm of the Pochhammer symbol, @math{\log((a)_x) = \log(\Gamma(a + x)/\Gamma(a))} for @math{a > 0}, @math{a+x > 0}.

Function: int gsl_sf_lnpoch_sgn_e (double a, double x, gsl_sf_result * result, double * sgn)
These routines compute the sign of the Pochhammer symbol and the logarithm of its magnitude. The computed parameters are @math{result = \log(|(a)_x|)} and @math{sgn = sgn((a)_x)} where @math{(a)_x := \Gamma(a + x)/\Gamma(a)}, subject to @math{a}, @math{a+x} not being negative integers.

Function: double gsl_sf_pochrel (double a, double x)
Function: int gsl_sf_pochrel_e (double a, double x, gsl_sf_result * result)
These routines compute the relative Pochhammer symbol @math{((a,x) - 1)/x} where @math{(a,x) = (a)_x := \Gamma(a + x)/\Gamma(a)}.

Function: double gsl_sf_gamma_inc_Q (double a, double x)
Function: int gsl_sf_gamma_inc_Q_e (double a, double x, gsl_sf_result * result)
These routines compute the normalized incomplete Gamma Function @math{P(a,x) = 1/\Gamma(a) \int_x\infty dt t^{a-1} \exp(-t)} for @math{a > 0}, @c{$x \ge 0$} @math{x >= 0}.

Function: double gsl_sf_gamma_inc_P (double a, double x)
Function: int gsl_sf_gamma_inc_P_e (double a, double x, gsl_sf_result * result)
These routines compute the complementary normalized incomplete Gamma Function @math{P(a,x) = 1/\Gamma(a) \int_0^x dt t^{a-1} \exp(-t)} for @math{a > 0}, @c{$x \ge 0$} @math{x >= 0}.

Function: double gsl_sf_beta (double a, double b)
Function: int gsl_sf_beta_e (double a, double b, gsl_sf_result * result)
These routines compute the Beta Function, @math{B(a,b) = \Gamma(a)\Gamma(b)/\Gamma(a+b)} for @math{a > 0}, @math{b > 0}.

Function: double gsl_sf_lnbeta (double a, double b)
Function: int gsl_sf_lnbeta_e (double a, double b, gsl_sf_result * result)
These routines compute the logarithm of the Beta Function, @math{\log(B(a,b))} for @math{a > 0}, @math{b > 0}.

Function: double gsl_sf_beta_inc (double a, double b, double x)
Function: int gsl_sf_beta_inc_e (double a, double b, double x, gsl_sf_result * result)
These routines compute the normalize incomplete Beta function @math{B_x(a,b)/B(a,b)} for @math{a > 0}, @math{b > 0}, and @c{$0 \le x \le 1$} @math{0 <= x <= 1}.