Namespaces
Variants
Views
Actions

tgamma

From cppreference.com
< c‎ | numeric‎ | math
 
 
 
Common mathematical functions
Functions
Basic operations
(C99)
(C99)
(C99)
(C99)
(C99)
(C99)(C99)(C99)
Exponential functions
(C99)
(C99)
(C99)
(C99)
Power functions
(C99)
(C99)
Trigonometric and hyperbolic functions
(C99)
(C99)
(C99)
Error and gamma functions
(C99)
(C99)
(C99)
tgamma
(C99)
Nearest integer floating point operations
(C99)(C99)(C99)
(C99)
(C99)(C99)(C99)
Floating point manipulation functions
(C99)(C99)
(C99)
(C99)
Classification
(C99)
(C99)
(C99)
Macro constants
 
Defined in header <math.h>
float       tgammaf( float arg );
(since C99)
double      tgamma( double arg );
(since C99)
long double tgammal( long double arg );
(since C99)

Computes the gamma function of arg.

Contents

[edit] Parameters

arg - floating point value

[edit] Return value

The value of the gamma function of arg, that is
0
targ-1
e-t dt
.

If arg is a natural number, tgamma(arg) is the factorial of arg-1.

[edit] Exceptions

If arg is negative, domain error may occur and FE_INVALID may be raised.

If arg is zero, pole error may occur and FE_DIVBYZERO may be raised.

If arg is too large, range error may occur and FE_OVERFLOW may be raised.

If arg is too small, range error may occur and FE_UNDERFLOW may be raised.

[edit] Notes

Many implementations calculate the exact integer-domain factorial if the argument is a sufficiently small integer.

[edit] Example

#include <stdio.h>
#include <math.h>
#include <errno.h>
#include <fenv.h>
#include <float.h>
#include <string.h>
 
#pragma STDC FENV_ACCESS ON
 
void show_fe_exceptions(void)
{
    printf("current exceptions raised: ");
    if(fetestexcept(FE_DIVBYZERO))     printf(" FE_DIVBYZERO");
    if(fetestexcept(FE_INEXACT))       printf(" FE_INEXACT");
    if(fetestexcept(FE_INVALID))       printf(" FE_INVALID");
    if(fetestexcept(FE_OVERFLOW))      printf(" FE_OVERFLOW");
    if(fetestexcept(FE_UNDERFLOW))     printf(" FE_UNDERFLOW");
    if(fetestexcept(FE_ALL_EXCEPT)==0) printf(" none");
    printf("\n");
}
 
int main(void)
{
    printf("tgamma(6.0) = %.1f\n", tgamma(6.0));   /* 120.0 */
    printf("5!          = %d\n",   5*4*3*2*1);     /* 120   */
    printf("\n");
 
    printf("tgamma(+INFINITY) = %+f\n",   tgamma(+INFINITY));
    printf("tgamma(NAN)       = %f\n",    tgamma(NAN));
    printf("\n");
 
    /* domain error                       */
    /* "invalid" floating-point exception */
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf("tgamma(-1.0)      = %f\n",   tgamma(-1.0));
    printf("%s\n",strerror(errno));
    show_fe_exceptions();
    printf("\n");
 
    /* pole error                                */
    /* "divide-by-zero" floating-point exception */
    /* similarly, tgamma(-0.0)                   */
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf("tgamma(+0.0)      = %f\n",   tgamma(+0.0));
    printf("%s\n",strerror(errno));
    show_fe_exceptions();
    printf("\n");
 
    /* "invalid" floating-point exception */
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf("tgamma(-INFINITY) = %f\n",   tgamma(-INFINITY));
    printf("%s\n",strerror(errno));
    show_fe_exceptions();
    printf("\n");
 
    /* range error                         */
    /* "inexact" floating-point exception  */
    /* "overflow" floating-point exception */
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf("tgamma(DBL_MAX)   = %f\n",   tgamma(DBL_MAX));
    printf("%s\n",strerror(errno));
    show_fe_exceptions();
    printf("\n");
 
    /* "inexact" floating-point exception  */
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf("tgamma(DBL_MIN)   = %g\n",   tgamma(DBL_MIN));
    printf("%s\n",strerror(errno));
    show_fe_exceptions();
    printf("\n");
 
    return 0;
}

Possible output:

tgamma(6.0) = 120.0
5!          = 120
 
tgamma(+INFINITY) = +inf
tgamma(NAN)       = nan
 
tgamma(-1.0)      = nan
Numerical argument out of domain
current exceptions raised:  FE_INVALID
 
tgamma(+0.0)      = inf
Numerical result out of range
current exceptions raised:  FE_DIVBYZERO
 
tgamma(-INFINITY) = -nan
Success
current exceptions raised:  FE_INVALID
 
tgamma(DBL_MAX)   = inf
Numerical result out of range
current exceptions raised:  FE_INEXACT FE_OVERFLOW
 
tgamma(DBL_MIN)   = 4.49423e+307
Success
current exceptions raised:  none

[edit] See also

(C99)
natural logarithm of the gamma function
(function) [edit]

[edit] External links

Weisstein, Eric W. "Gamma Function." From MathWorld--A Wolfram Web Resource.