text: Go to the first, previous, next, last section, table of contents. `gsl_sf_airy.h', `gsl_sf_bessel.h', etc. The complete set of header files can be included using the file `gsl_sf.h'.
  The special functions are available in two calling conventions, a natural form which returns the numerical value of the function and an error-handling form which returns an error code. The two types of function provide alternative ways of accessing the same underlying code.
  The natural form returns only the value of the function and can be used directly in mathematical expressions. For example, the following function call will compute the value of the Bessel function J_0(x),
  double y = gsl_sf_bessel_J0 (x);
  There is no way to access an error code or to estimate the error using this method. To allow access to this information the alternative error-handling form stores the value and error in a modifiable argument,
  gsl_sf_result result; int status = gsl_sf_bessel_J0_e (x, &result);
  The error-handling functions have the suffix
  _e. The returned
  status value indicates error conditions such as overflow, underflow or
  loss of precision. If there are no errors the error-handling functions
  return
  GSL_SUCCESS.
  GSL_PREC_SINGLE
  GSL_PREC_APPROX
  The approximate mode provides the fastest evaluation at the lowest accuracy.'.
  The routines described in this section compute the Cylindrical Bessel functions J_n(x), Y_n(x), Modified cylindrical Bessel functions I_n(x), K_n(x), Spherical Bessel functions j_l(x), y_l(x), and Modified Spherical Bessel functions i_l(x), k_l(x). For more information see Abramowitz & Stegun, Chapters 9 and 10. The Bessel functions are defined in the header file `gsl_sf_bessel.h'.
  The regular modified spherical Bessel functions i_l(x) are related to the modified Bessel functions of fractional order, i_l(x) = \sqrt{\pi/(2x)} I_{l+1/2}(x)
  The irregular modified spherical Bessel functions k_l(x) are related to the irregular modified Bessel functions of fractional order, k_l(x) = \sqrt{\pi/(2x)} K_{l+1/2}(x).'.
  The prototypes of the Coulomb functions are declared in the header file `gsl_sf_coulomb.h'. Both bound state and scattering solutions are available. section Laguerre Functions). The normalization is chosen such that the wavefunction \psi is given by \psi(n,l,r) = R_n Y_{lm}.
  The Coulomb wave functions F_L(\eta,x), G_L(\eta,x) are
  described in Abramowitz & Stegun, Chapter 14. Because there can be a
  large dynamic range of values for these functions, overflows are handled
  gracefully. If an overflow occurs,
  GSL_EOVRFLW is signalled and
  exponent(s) are returned through the modifiable parameters exp_F,
  exp_G. The full solution can be reconstructed from the following
  relations,
  F_L(eta,x) = fc[k_L] * exp(exp_F) G_L(eta,x) = gc[k_L] * exp(exp_G) F_L'(eta,x) = fcp[k_L] * exp(exp_F) G_L'(eta,x) = gcp[k_L] * exp(exp_G)
  GSL_EOVRFLWis returned and scaling exponents are stored in the modifiable parameters exp_F, exp_G.
  The Coulomb wave function normalization constant is defined in Abramowitz 14.1.7.
  The Wigner 3-j, 6-j and 9-j symbols give the coupling coefficients for combined angular momentum vectors. Since the arguments of the standard coupling coefficient functions are integer or half-integer, the arguments of the following functions are, by convention, integers equal to twice the actual spin value. For information on the 3-j coefficients see Abramowitz & Stegun, Section 27.9. The functions described in this section are declared in the header file `gsl_sf_coupling.h'.
  (ja jb jc ma mb mc)
  where the arguments are given in half-integer units, ja = two_ja/2, ma = two_ma/2, etc.
  {ja jb jc jd je jf}
  where the arguments are given in half-integer units, ja = two_ja/2, ma = two_ma/2, etc.
  {ja jb jc jd je jf jg jh ji}
  where the arguments are given in half-integer units, ja = two_ja/2, ma = two_ma/2, etc.
  The Dawson integral is defined by \exp(-x^2) \int_0^x dt \exp(t^2). A table of Dawson's integral can be found in Abramowitz & Stegun, Table 7.5. The Dawson functions are declared in the header file `gsl_sf_dawson.h'.
  The Debye functions D_n(x) are defined by the following integral,
  D_n(x) = n/x^n \int_0^x dt (t^n/(e^t - 1))
  For further information see Abramowitz & Stegun, Section 27.1. The Debye functions are declared in the header file `gsl_sf_debye.h'.
  The functions described in this section are declared in the header file `gsl_sf_dilog.h'.
  Note that Abramowitz & Stegun refer to the Spence integral S(x)=Li_2(1-x) as the dilogarithm rather than Li_2(x).
  The following functions allow for the propagation of errors when combining quantities by multiplication. The functions are declared in the header file `gsl_sf_elementary.h'.
  The functions described in this section are declared in the header file `gsl_sf_ellint.h'. Further information about the elliptic integrals can be found in Abramowitz & Stegun, Chapter 17..
  The Carlson symmetric forms of elliptical integrals RC(x,y), RD(x,y,z), RF(x,y,z) and RJ(x,y,z,p) are defined by,
  RC(x,y) = 1/2 \int_0^\infty dt (t+x)^(-1/2) (t+y)^(-1) RD(x,y,z) = 3/2 \int_0^\infty dt (t+x)^(-1/2) (t+y)^(-1/2) (t+z)^(-3/2) RF(x,y,z) = 1/2 \int_0^\infty dt (t+x)^(-1/2) (t+y)^(-1/2) (t+z)^(-1/2) RJ(x,y,z,p) = 3/2 \int_0^\infty dt (t+x)^(-1/2) (t+y)^(-1/2) (t+z)^(-1/2) (t+p)^(-1)
  D(\phi,k,n) = (1/3)(\sin(\phi))^3 RD (1-\sin^2(\phi), 1-k^2 \sin^2(\phi), 1).
  The argument n is not used and will be removed in a future release.
  The Jacobian Elliptic functions are defined in Abramowitz & Stegun, Chapter 16. The functions are declared in the header file `gsl_sf_elljac.h'.
  The error function is described in Abramowitz & Stegun, Chapter 7. The functions in this section are declared in the header file `gsl_sf_erf.h'.
  The probability functions for the Normal or Gaussian distribution are described in Abramowitz & Stegun, Section 26.
  The functions described in this section are declared in the header file `gsl_sf_exp.h'.
  gsl_sf_result_e10type to return a result with extended range. This function may be useful if the value of \exp(x) would overflow the numeric range of
  double.
  gsl_sf_result_e10type to return a result with extended numeric range.
  gsl_sf_expreland
  gsl_sf_exprel_2. The N-relative exponential is given by,
  exprel_N(x) = N!/x^N (\exp(x) - \sum_{k=0}^{N-1} x^k/k!) = 1 + x/(N+1) + x^2/((N+1)(N+2)) + ... = 1F1 (1,1+N,x)
  gsl_sf_result_e10type to return a result with extended range.
  gsl_sf_result_e10type to return a result with extended range.
  Information on the exponential integrals can be found in Abramowitz & Stegun, Chapter 5. These functions are declared in the header file `gsl_sf_expint.h'.
  E_1(x) := \Re \int_1^\infty dt \exp(-xt)/t.
  E_2(x) := \Re \int_1^\infty dt \exp(-xt)/t^2.
  E_n(x) := \Re \int_1^\infty dt \exp(-xt)/t^n.
  Ei(x) := - PV(\int_{-x}^\infty dt \exp(-t)/t)
  where PV denotes the principal value of the integral.
  M_EULER).
  The functions described in this section are declared in the header file `gsl_sf_fermi_dirac.h'.
  The complete Fermi-Dirac integral F_j(x) is given by,
  F_j(x) := (1/\Gamma(j+1)) \int_0^\infty dt (t^j / (\exp(t-x) + 1))
  Note that the Fermi-Dirac integral is sometimes defined without the normalisation factor in other texts.
  The incomplete Fermi-Dirac integral F_j(x,b) is given by,
  F_j(x,b) := (1/\Gamma(j+1)) \int_b^\infty dt (t^j / (\Exp(t-x) + 1))
  This following routines compute the gamma and beta functions in their full and incomplete forms, as well as various kinds of factorials. The functions described in this section are declared in the header file `gsl_sf_gamma.h'..
  GSL_SF_GAMMA_XMAXand is 171.0.
  \Gamma^*(x) = \Gamma(x)/(\sqrt{2\pi} x^{(x-1/2)} \exp(-x)) = (1 + (1/12x) + ...) for x \to \infty
  and is a useful suggestion of Temme.
  GSL_ELOSSerror when it occurs. The absolute value part (lnr), however, never suffers from loss of precision..
  GSL_SF_FACT_NMAXand is 170.
  GSL_SF_DOUBLEFACT_NMAXand is 297.
  gsl_sf_lngammafor n < 170, but defers for larger n.
  n choose m= n!/(m!(n-m)!)
  n choose m. This is equivalent to the sum \log(n!) - \log(m!) - \log((n-m)!).
  Note that Abramowitz & Stegun call P(a,x) the incomplete gamma function (section 6.5).'.
  Hypergeometric functions are described in Abramowitz & Stegun, Chapters 13 and 15. These functions are declared in the header file `gsl_sf_hyperg.h'.
  gsl_sf_result_e10type to return a result with extended range.
  gsl_sf_result_e10type to return a result with extended range.
  If the arguments (a,b,c,x) are too close to a singularity then
  the function can return the error code
  GSL_EMAXITER when the
  series approximation converges too slowly. This occurs in the region of
  x=1, c - a - b = m for integer m.'.'.
  The Legendre Functions and Legendre Polynomials are described in Abramowitz & Stegun, Chapter 8. These functions are declared in the header file `gsl_sf_legendre.h'.
  These functions compute arrays of Legendre polynomials P_l(x) and derivatives dP_l(x)/dx, for l = 0, \dots, lmax, |x| <= 1.
  The Conical Functions P^\mu_{-(1/2)+i\lambda}(x) and Q^\mu_{-(1/2)+i\lambda} are described in Abramowitz & Stegun, Section 8.12.
  The following spherical functions are specializations of Legendre functions which give the regular eigenfunctions of the Laplacian on a 3-dimensional hyperbolic space H3d. Of particular interest is the flat limit, \lambda \to \infty, \eta \to 0, \lambda\eta fixed.
  Information on the properties of the Logarithm function can be found in Abramowitz & Stegun, Chapter 4. The functions described in this section are declared in the header file `gsl_sf_log.h'.'.
  The Mathieu functions can be computed for a single order or for multiple orders, using array-based routines. The array-based routines require a preallocated workspace.
  The allowed values of j are 1 and 2. The functions for j = 3,4 can be computed as M_n^{(3)} = M_n^{(1)} + iM_n^{(2)} and M_n^{(4)} = M_n^{(1)} - iM_n^{(2)}, where M_n^{(j)} = Mc_n^{(j)} or Ms_n^{(j)}.
  The following functions are equivalent to the function
  gsl_pow_int
  (see section Small integer powers) with an error estimate. These functions are
  declared in the header file `gsl_sf_pow_int.h'.
  #include <gsl/gsl_sf_pow_int.h> /* compute 3.0**12 */ double y = gsl_sf_pow_int(3.0, 12);
  The polygamma functions of order n are defined by
  \psi^{(n)}(x) = (d/dx)^n \psi(x) = (d/dx)^{n+1} \log(\Gamma(x))
  where \psi(x) = \Gamma'(x)/\Gamma(x) is known as the digamma function. These functions are declared in the header file `gsl_sf_psi.h'.
  The functions described in this section are declared in the header file `gsl_sf_synchrotron.h'.
  The transport functions J(n,x) are defined by the integral representations J(n,x) := \int_0^x dt t^n e^t /(e^t - 1)^2. They are declared in the header file `gsl_sf_transport.h'.
  The library includes its own trigonometric functions in order to provide consistency across platforms and reliable error estimates. These functions are declared in the header file `gsl_sf_trig.h'.
  Note that the mathematical value of \pi is slightly greater
  than
  M_PI, so the machine numbers
  M_PI and
  -M_PI
  are included in the range.
  Note that the mathematical value of 2\pi is slightly greater
  than
  2*M_PI, so the machine number
  2*M_PI is included in
  the range.
  The Riemann zeta function is defined in Abramowitz & Stegun, Section 23.2. The functions described in this section are declared in the header file `gsl_sf_zeta.h'.
  The Riemann zeta function is defined by the infinite sum \zeta(s) = \sum_{k=1}^\infty k^{-s}.
  For large positive argument, the Riemann zeta function approaches one. In this region the fractional part is interesting, and therefore we need a function to evaluate it explicitly.
  The Hurwitz zeta function is defined by \zeta(s,q) = \sum_0^\infty (k+q)^{-s}.
  The eta function is defined by \eta(s) = (1-2^{1-s}) \zeta(s).
  The following example demonstrates the use of the error handling form of the special functions, in this case to compute the Bessel function J_0(5; }
  Here are the results of running the program,
  $ ./a.out status = success J0(5.0) = -0.177596771314338292 +/- 0.000000000000000193 exact = -0.177596771314338292
  The next program computes the same quantity using the natural form of the function. In this case the error term result.err and return status are not accessible.
  #include <stdio.h> #include <gsl/gsl_sf_bessel.h> int main (void) { double x = 5.0; double expected = -0.17759677131433830434739701; double y = gsl_sf_bessel_J0 (x); printf ("J0(5.0) = %.18f\n", y); printf ("exact = %.18f\n", expected); return 0; }
  The results of the function are the same,
  $ ./a.out J0(5.0) = -0.177596771314338292 exact = -0.177596771314338292
  The library follows the conventions of Abramowitz & Stegun where possible,
  The following papers contain information on the algorithms used to compute the special functions,
  Go to the first, previous, next, last section, table of contents.