                On-line Guides All Guides eBook Store iOS / Android Linux for Beginners Office Productivity Linux Installation Linux Security Linux Utilities Linux Virtualization Linux Kernel System/Network Admin Programming Scripting Languages Development Tools Web Development GUI Toolkits/Desktop Databases Mail Systems openSolaris Eclipse Documentation Techotopia.com Virtuatopia.com How To Guides Virtualization General System Admin Linux Security Linux Filesystems Web Servers Graphics & Desktop PC Hardware Windows Problem Solutions Privacy Policy  ### 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)

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

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

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

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

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)

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

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

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

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

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

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

`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;. Published under the terms of the GNU General Public License Design by Interspire