forked from KolibriOS/kolibrios
upload sdk
git-svn-id: svn://kolibrios.org@4349 a494cfbc-eb01-0410-851d-a64ba20cac60
This commit is contained in:
Sergey Semyonov (Serge)
226
contrib/sdk/sources/newlib/math/w_gamma.c
Normal file
226
contrib/sdk/sources/newlib/math/w_gamma.c
Normal file
@@ -0,0 +1,226 @@
|
||||
|
||||
/* @(#)w_gamma.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*
|
||||
*/
|
||||
|
||||
/* BUG: FIXME?
|
||||
According to Linux man pages for tgamma, lgamma, and gamma, the gamma
|
||||
function was originally defined in BSD as implemented here--the log of the gamma
|
||||
function. BSD 4.3 changed the name to lgamma, apparently removing gamma. BSD
|
||||
4.4 re-introduced the gamma name with the more intuitive, without logarithm,
|
||||
plain gamma function. The C99 standard apparently wanted to avoid a problem
|
||||
with the poorly-named earlier gamma and used tgamma when adding a plain
|
||||
gamma function.
|
||||
So the current gamma is matching an old, bad definition, and not
|
||||
matching a newer, better definition. */
|
||||
/*
|
||||
FUNCTION
|
||||
<<gamma>>, <<gammaf>>, <<lgamma>>, <<lgammaf>>, <<gamma_r>>, <<gammaf_r>>, <<lgamma_r>>, <<lgammaf_r>>, <<tgamma>>, and <<tgammaf>>--logarithmic and plain gamma functions
|
||||
|
||||
INDEX
|
||||
gamma
|
||||
INDEX
|
||||
gammaf
|
||||
INDEX
|
||||
lgamma
|
||||
INDEX
|
||||
lgammaf
|
||||
INDEX
|
||||
gamma_r
|
||||
INDEX
|
||||
gammaf_r
|
||||
INDEX
|
||||
lgamma_r
|
||||
INDEX
|
||||
lgammaf_r
|
||||
INDEX
|
||||
tgamma
|
||||
INDEX
|
||||
tgammaf
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
#include <math.h>
|
||||
double gamma(double <[x]>);
|
||||
float gammaf(float <[x]>);
|
||||
double lgamma(double <[x]>);
|
||||
float lgammaf(float <[x]>);
|
||||
double gamma_r(double <[x]>, int *<[signgamp]>);
|
||||
float gammaf_r(float <[x]>, int *<[signgamp]>);
|
||||
double lgamma_r(double <[x]>, int *<[signgamp]>);
|
||||
float lgammaf_r(float <[x]>, int *<[signgamp]>);
|
||||
double tgamma(double <[x]>);
|
||||
float tgammaf(float <[x]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <math.h>
|
||||
double gamma(<[x]>)
|
||||
double <[x]>;
|
||||
float gammaf(<[x]>)
|
||||
float <[x]>;
|
||||
double lgamma(<[x]>)
|
||||
double <[x]>;
|
||||
float lgammaf(<[x]>)
|
||||
float <[x]>;
|
||||
double gamma_r(<[x]>, <[signgamp]>)
|
||||
double <[x]>;
|
||||
int <[signgamp]>;
|
||||
float gammaf_r(<[x]>, <[signgamp]>)
|
||||
float <[x]>;
|
||||
int <[signgamp]>;
|
||||
double lgamma_r(<[x]>, <[signgamp]>)
|
||||
double <[x]>;
|
||||
int <[signgamp]>;
|
||||
float lgammaf_r(<[x]>, <[signgamp]>)
|
||||
float <[x]>;
|
||||
int <[signgamp]>;
|
||||
double tgamma(<[x]>)
|
||||
double <[x]>;
|
||||
float tgammaf(<[x]>)
|
||||
float <[x]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<gamma>> calculates
|
||||
@tex
|
||||
$\mit ln\bigl(\Gamma(x)\bigr)$,
|
||||
@end tex
|
||||
the natural logarithm of the gamma function of <[x]>. The gamma function
|
||||
(<<exp(gamma(<[x]>))>>) is a generalization of factorial, and retains
|
||||
the property that
|
||||
@ifnottex
|
||||
<<exp(gamma(N))>> is equivalent to <<N*exp(gamma(N-1))>>.
|
||||
@end ifnottex
|
||||
@tex
|
||||
$\mit \Gamma(N)\equiv N\times\Gamma(N-1)$.
|
||||
@end tex
|
||||
Accordingly, the results of the gamma function itself grow very
|
||||
quickly. <<gamma>> is defined as
|
||||
@tex
|
||||
$\mit ln\bigl(\Gamma(x)\bigr)$ rather than simply $\mit \Gamma(x)$
|
||||
@end tex
|
||||
@ifnottex
|
||||
the natural log of the gamma function, rather than the gamma function
|
||||
itself,
|
||||
@end ifnottex
|
||||
to extend the useful range of results representable.
|
||||
|
||||
The sign of the result is returned in the global variable <<signgam>>,
|
||||
which is declared in math.h.
|
||||
|
||||
<<gammaf>> performs the same calculation as <<gamma>>, but uses and
|
||||
returns <<float>> values.
|
||||
|
||||
<<lgamma>> and <<lgammaf>> are alternate names for <<gamma>> and
|
||||
<<gammaf>>. The use of <<lgamma>> instead of <<gamma>> is a reminder
|
||||
that these functions compute the log of the gamma function, rather
|
||||
than the gamma function itself.
|
||||
|
||||
The functions <<gamma_r>>, <<gammaf_r>>, <<lgamma_r>>, and
|
||||
<<lgammaf_r>> are just like <<gamma>>, <<gammaf>>, <<lgamma>>, and
|
||||
<<lgammaf>>, respectively, but take an additional argument. This
|
||||
additional argument is a pointer to an integer. This additional
|
||||
argument is used to return the sign of the result, and the global
|
||||
variable <<signgam>> is not used. These functions may be used for
|
||||
reentrant calls (but they will still set the global variable <<errno>>
|
||||
if an error occurs).
|
||||
|
||||
<<tgamma>> and <<tgammaf>> are the "true gamma" functions, returning
|
||||
@tex
|
||||
$\mit \Gamma(x)$,
|
||||
@end tex
|
||||
the gamma function of <[x]>--without a logarithm.
|
||||
(They are apparently so named because of the prior existence of the old,
|
||||
poorly-named <<gamma>> functions which returned the log of gamma up
|
||||
through BSD 4.2.)
|
||||
|
||||
RETURNS
|
||||
Normally, the computed result is returned.
|
||||
|
||||
When <[x]> is a nonpositive integer, <<gamma>> returns <<HUGE_VAL>>
|
||||
and <<errno>> is set to <<EDOM>>. If the result overflows, <<gamma>>
|
||||
returns <<HUGE_VAL>> and <<errno>> is set to <<ERANGE>>.
|
||||
|
||||
You can modify this error treatment using <<matherr>>.
|
||||
|
||||
PORTABILITY
|
||||
Neither <<gamma>> nor <<gammaf>> is ANSI C. It is better not to use either
|
||||
of these; use <<lgamma>> or <<tgamma>> instead.@*
|
||||
<<lgamma>>, <<lgammaf>>, <<tgamma>>, and <<tgammaf>> are nominally C standard
|
||||
in terms of the base return values, although the <<matherr>> error-handling
|
||||
is not standard, nor is the <[signgam]> global for <<lgamma>>.
|
||||
*/
|
||||
|
||||
/* double gamma(double x)
|
||||
* Return the logarithm of the Gamma function of x.
|
||||
*
|
||||
* Method: call gamma_r
|
||||
*/
|
||||
|
||||
#include "fdlibm.h"
|
||||
#include <reent.h>
|
||||
#include <errno.h>
|
||||
|
||||
#ifndef _DOUBLE_IS_32BITS
|
||||
|
||||
#ifdef __STDC__
|
||||
double gamma(double x)
|
||||
#else
|
||||
double gamma(x)
|
||||
double x;
|
||||
#endif
|
||||
{
|
||||
#ifdef _IEEE_LIBM
|
||||
return __ieee754_gamma_r(x,&(_REENT_SIGNGAM(_REENT)));
|
||||
#else
|
||||
double y;
|
||||
struct exception exc;
|
||||
y = __ieee754_gamma_r(x,&(_REENT_SIGNGAM(_REENT)));
|
||||
if(_LIB_VERSION == _IEEE_) return y;
|
||||
if(!finite(y)&&finite(x)) {
|
||||
#ifndef HUGE_VAL
|
||||
#define HUGE_VAL inf
|
||||
double inf = 0.0;
|
||||
|
||||
SET_HIGH_WORD(inf,0x7ff00000); /* set inf to infinite */
|
||||
#endif
|
||||
exc.name = "gamma";
|
||||
exc.err = 0;
|
||||
exc.arg1 = exc.arg2 = x;
|
||||
if (_LIB_VERSION == _SVID_)
|
||||
exc.retval = HUGE;
|
||||
else
|
||||
exc.retval = HUGE_VAL;
|
||||
if(floor(x)==x&&x<=0.0) {
|
||||
/* gamma(-integer) or gamma(0) */
|
||||
exc.type = SING;
|
||||
if (_LIB_VERSION == _POSIX_)
|
||||
errno = EDOM;
|
||||
else if (!matherr(&exc)) {
|
||||
errno = EDOM;
|
||||
}
|
||||
} else {
|
||||
/* gamma(finite) overflow */
|
||||
exc.type = OVERFLOW;
|
||||
if (_LIB_VERSION == _POSIX_)
|
||||
errno = ERANGE;
|
||||
else if (!matherr(&exc)) {
|
||||
errno = ERANGE;
|
||||
}
|
||||
}
|
||||
if (exc.err != 0)
|
||||
errno = exc.err;
|
||||
return exc.retval;
|
||||
} else
|
||||
return y;
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif /* defined(_DOUBLE_IS_32BITS) */
|
||||
Reference in New Issue
Block a user