# lgamma(), lgamma_r(), lgammaf(), lgammaf_r(), lgammal(), lgammal_r()

Log gamma function

## Synopsis:

```#include <math.h>

double lgamma( double x );

double lgamma_r( double x,
int* signgamp);

float lgammaf( float x );

float lgammaf_r( float x,
int* signgamp);

long double lgammal( long double x );

long double lgammal_r( long double x,
int* signgamp);
```

## Arguments:

x
An arbitrary number.
signgam
(lgamma_r(), lgammaf_r(), and lgammal_r() only) A pointer to a location where the function can store the sign of Γ(x).

## Library:

libm

Use the -l m option to qcc to link against this library.

## Description:

The lgamma*() and lgamma*_r() functions return the natural log (ln) of the Γ function. These functions return ln|Γ(x)|, where Γ(x) is defined as follows:

For x > 0:
For x < 1:
n / (Γ( 1-x ) * sin( nx ))

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

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

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

The lgamma() and lgammaf() functions use the external integer signgam to return the sign of Γ(x), while lgamma_r() and lgammaf_r() use the user-allocated space addressed by signgamp.

Note: The signgam variable isn't set until lgamma() or lgammaf() returns. For example, don't use the expression:
```g = signgam * exp( lgamma( x ));
```

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

```lg = lgamma(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.

To check for error situations, use feclearexcept() and fetestexcept():

• Call feclearexcept(FE_ALL_EXCEPT) before calling lgamma(), lgamma_r(), lgammaf(), lgammaf_r(), lgammal(), or lgammal_r().
• On return, if fetestexcept(FE_INVALID | FE_DIVBYZERO | FE_OVERFLOW | FE_UNDERFLOW) is nonzero, then an error has occurred.

## Returns:

ln|Γ(x)|

• If x is a non-positive integer, a pole error occurs, and these functions return +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL, depending on the function.
• If the correct value would cause an overflow, a range error occurs and these functions return ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL (having the same sign as the correct value), depending on the function.
• If x is NaN, NaN is returned.
• If x is 1 or 2, +0 is returned.
• If x is ±Inf, +Inf is returned.

## Errors:

FE_DIVBYZERO
The x argument is a negative integer or 0.
FE_OVERFLOW
The result would cause an overflow.

## Examples:

```#include <stdio.h>
#include <fenv.h>
#include <inttypes.h>
#include <math.h>
#include <stdlib.h>

int main(int argc, char** argv)
{
double a, b;
int except_flags;

a = 0.5;
feclearexcept(FE_ALL_EXCEPT);
b = lgamma(a);
except_flags = fetestexcept(FE_INVALID | FE_DIVBYZERO | FE_OVERFLOW | FE_UNDERFLOW);
if(except_flags) {
/* An error occurred; handle it appropriately. */
}

printf("lgamma(%f) = %f \n", a, b);

return EXIT_SUCCESS;
}
```

produces the output:

```lgamma(0.500000) = 0.572365 0
```

## Classification:

lgamma(), lgammaf(), and lgammal() are ANSI, POSIX 1003.1; lgamma_r(), lgammaf_r(), and lgammal_r() are QNX Neutrino

Safety:
Cancellation point No
Interrupt handler No
Signal handler No