### 19.6 Special Functions

These are some more exotic mathematical functions which are sometimes useful. Currently they only have real-valued versions.

— Function: double erf (double x)

> — Function: float erff (float x)

> > — Function: long double erfl (long double x)

> > > Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

> > > `erf` returns the error function of x. The error function is defined as

> > >               erf (x) = 2/sqrt(pi) * integral from 0 to x of exp(-t^2) dt

— Function: double erfc (double x)

> — Function: float erfcf (float x)

> > — Function: long double erfcl (long double x)

> > > Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

> > > `erfc` returns `1.0 - erf(`x`)`, but computed in a fashion that avoids round-off error when x is large.

— Function: double lgamma (double x)

> — Function: float lgammaf (float x)

> > — Function: long double lgammal (long double x)

> > > Preliminary: | MT-Unsafe race:signgam | AS-Unsafe | AC-Safe | See POSIX Safety Concepts.

> > > `lgamma` returns the natural logarithm of the absolute value of the gamma function of x. The gamma function is defined as

> > >               gamma (x) = integral from 0 to &infin; of t^(x-1) e^-t dt

> > > The sign of the gamma function is stored in the global variable signgam, which is declared in `math.h`. It is `1` if the intermediate result was positive or zero, or `-1` if it was negative.

> > > To compute the real gamma function you can use the `tgamma` function or you can compute the values as follows:

> > >               lgam = lgamma(x);
> > >               gam  = signgam*exp(lgam);

> > > The gamma function has singularities at the non-positive integers. `lgamma` will raise the zero divide exception if evaluated at a singularity.

— Function: double lgamma_r (double x, int *signp)

> — Function: float lgammaf_r (float x, int *signp)

> > — Function: long double lgammal_r (long double x, int *signp)

> > > Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

> > > `lgamma_r` is just like `lgamma`, but it stores the sign of the intermediate result in the variable pointed to by signp instead of in the signgam global. This means it is reentrant.

— Function: double gamma (double x)

> — Function: float gammaf (float x)

> > — Function: long double gammal (long double x)

> > > Preliminary: | MT-Unsafe race:signgam | AS-Unsafe | AC-Safe | See POSIX Safety Concepts.

> > > These functions exist for compatibility reasons. They are equivalent to `lgamma` etc. It is better to use `lgamma` since for one the name reflects better the actual computation, moreover `lgamma` is standardized in ISO C99 while `gamma` is not.

— Function: double tgamma (double x)

> — Function: float tgammaf (float x)

> > — Function: long double tgammal (long double x)

> > > Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

> > > `tgamma` applies the gamma function to x. The gamma function is defined as

> > >               gamma (x) = integral from 0 to &infin; of t^(x-1) e^-t dt

> > > This function was introduced in ISO C99.

— Function: double j0 (double x)

> — Function: float j0f (float x)

> > — Function: long double j0l (long double x)

> > > Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

> > > `j0` returns the Bessel function of the first kind of order 0 of x. It may signal underflow if x is too large.

— Function: double j1 (double x)

> — Function: float j1f (float x)

> > — Function: long double j1l (long double x)

> > > Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

> > > `j1` returns the Bessel function of the first kind of order 1 of x. It may signal underflow if x is too large.

— Function: double jn (int n, double x)

> — Function: float jnf (int n, float x)

> > — Function: long double jnl (int n, long double x)

> > > Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

> > > `jn` returns the Bessel function of the first kind of order n of x. It may signal underflow if x is too large.

— Function: double y0 (double x)

> — Function: float y0f (float x)

> > — Function: long double y0l (long double x)

> > > Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

> > > `y0` returns the Bessel function of the second kind of order 0 of x. It may signal underflow if x is too large. If x is negative, `y0` signals a domain error; if it is zero, `y0` signals overflow and returns -&infin;.

— Function: double y1 (double x)

> — Function: float y1f (float x)

> > — Function: long double y1l (long double x)

> > > Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

> > > `y1` returns the Bessel function of the second kind of order 1 of x. It may signal underflow if x is too large. If x is negative, `y1` signals a domain error; if it is zero, `y1` signals overflow and returns -&infin;.

— Function: double yn (int n, double x)

> — Function: float ynf (int n, float x)

> > — Function: long double ynl (int n, long double x)

> > > Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

> > > `yn` returns the Bessel function of the second kind of order n of x. It may signal underflow if x is too large. If x is negative, `yn` signals a domain error; if it is zero, `yn` signals overflow and returns -&infin;.