---

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) ¶

Function: _FloatN erffN (_FloatN x) ¶

Function: _FloatNx erffNx (_FloatNx 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) ¶

Function: _FloatN erfcfN (_FloatN x) ¶

Function: _FloatNx erfcfNx (_FloatNx 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) ¶

Function: _FloatN lgammafN (_FloatN x) ¶

Function: _FloatNx lgammafNx (_FloatNx 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 ∞ 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) ¶

Function: _FloatN lgammafN_r (_FloatN x, int *signp) ¶

Function: _FloatNx lgammafNx_r (_FloatNx 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.

The lgammafN_r and lgammafNx_r functions are GNU extensions.

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, and 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) ¶

Function: _FloatN tgammafN (_FloatN x) ¶

Function: _FloatNx tgammafNx (_FloatNx 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 ∞ of t^(x-1) e^-t dt

This function was introduced in ISO C99. The _FloatN and _FloatNx variants were introduced in ISO/IEC TS 18661-3.

Function: double j0 (double x) ¶

Function: float j0f (float x) ¶

Function: long double j0l (long double x) ¶

Function: _FloatN j0fN (_FloatN x) ¶

Function: _FloatNx j0fNx (_FloatNx 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.

The _FloatN and _FloatNx variants are GNU extensions.

Function: double j1 (double x) ¶

Function: float j1f (float x) ¶

Function: long double j1l (long double x) ¶

Function: _FloatN j1fN (_FloatN x) ¶

Function: _FloatNx j1fNx (_FloatNx 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.

The _FloatN and _FloatNx variants are GNU extensions.

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

Function: float jnf (int n, float x) ¶

Function: long double jnl (int n, long double x) ¶

Function: _FloatN jnfN (int n, _FloatN x) ¶

Function: _FloatNx jnfNx (int n, _FloatNx 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.

The _FloatN and _FloatNx variants are GNU extensions.

Function: double y0 (double x) ¶

Function: float y0f (float x) ¶

Function: long double y0l (long double x) ¶

Function: _FloatN y0fN (_FloatN x) ¶

Function: _FloatNx y0fNx (_FloatNx 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 -∞.

The _FloatN and _FloatNx variants are GNU extensions.

Function: double y1 (double x) ¶

Function: float y1f (float x) ¶

Function: long double y1l (long double x) ¶

Function: _FloatN y1fN (_FloatN x) ¶

Function: _FloatNx y1fNx (_FloatNx 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 -∞.

The _FloatN and _FloatNx variants are GNU extensions.

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

Function: float ynf (int n, float x) ¶

Function: long double ynl (int n, long double x) ¶

Function: _FloatN ynfN (int n, _FloatN x) ¶

Function: _FloatNx ynfNx (int n, _FloatNx 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 -∞.

The _FloatN and _FloatNx variants are GNU extensions.