*Log gamma function*

#include <math.h> double gamma( doublex); double gamma_r( doublex, int*signgam); float gammaf( floatx); float gammaf_r( floatx, int*signgam);

`x`- An arbitrary number.
`signgam`- (gamma_r(), gammaf_r() only)
A pointer to a location where the function can store the sign of
Γ(
`x`).

The gamma() and gamma_r() functions return
the natural log (`ln`) of the gamma() function and are
equivalent to lgamma().
These functions return `ln|Γ(``x``)|`,
where Γ(`x`) is defined as follows:

- For
`x`> 0:

- For
`x`< 1: - n / (Γ( 1-
`x`) * sin( n`x`))

The results converge when `x` is between 0 and 1.
The Γ function has the property:

Γ(N) = Γ(N-1)×N

The gamma* functions compute the log because the Γ function grows very quickly.

The gamma() and gammaf() functions use the external
integer `signgam` to return the
sign of Γ(`x`), while gamma_r() and gammaf_r() use
the user-allocated space addressed by `signgamp`.

Note:
The `signgam` variable isn't set until gamma() or
gammaf() returns.
For example, don't use the expression:

g = signgam * exp( gamma( x ));

to compute `g`` = Γ(``x``)'`. Instead,
compute gamma() first:

lg = gamma(x); g = signgam * exp( lg );

Note that Γ(`x`) must overflow when `x` is large enough, underflow when
-`x` is large enough, and generate a division by 0
exception at the singularities `x` a nonpositive integer.

`ln|Γ(``x``)|`

Note:
If an error occurs, these functions return 0, but this is also a valid
mathematical result.
If you want to check for errors, set
`errno`
to 0, call the function, and then check `errno` again.
These functions don't change `errno` if no errors occurred.

Safety: | |
---|---|

Cancellation point | No |

Interrupt handler | No |

Signal handler | No |

Thread | Yes |