Next: , Previous: , Up: Mathematics   [Contents][Index]

### 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, 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)

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

Next: Known Maximum Errors in Math Functions, Previous: Hyperbolic Functions, Up: Mathematics   [Contents][Index]