Go to the first, previous, next, last section, table of contents.

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}.


Go to the first, previous, next, last section, table of contents.