Caution: This version of this document is no longer maintained. For the latest documentation, see http://www.qnx.com/developers/docs.

lgamma(), lgamma_r(), lgammaf(), lgammaf_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);

Arguments:

x
An arbitrary number.
signgam
(lgamma_r(), lgammaf_r() only) A pointer to a location where the function can store the sign of Gamma(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 Gamma function and are equivalent to gamma(). These functions return ln|Gamma(x)|, where Gamma(x) is defined as follows:

For x > 0:
integral from 0 to +Infinity of pow(t,x-1)*exp(-t) dt
For x < 1:
n / (Gamma( 1-x ) * sin( nx ))

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

Gamma(N) = Gamma(N-1)*N

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

The lgamma() and lgammaf() functions use the external integer signgam to return the sign of Gamma(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 = Gamma(x)'. Instead, compute lgamma() first:

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

Note that Gamma(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.

Returns:

ln|Gamma(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.

Examples:

#include <stdio.h>
#include <errno.h>
#include <inttypes.h>
#include <math.h>
#include <fpstatus.h>

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

    errno = EOK;
    a = 0.5;
    b = lgamma(a);
    printf("lgamma(%f) = %f %d \n", a, b, errno);

    return(0);
}

produces the output:

lgamma(0.500000) = 0.572365 0

Classification:

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

Safety:
Cancellation point No
Interrupt handler No
Signal handler No
Thread Yes

See also:

gamma()