naginterfaces.library.specfun.gamma_​vector

naginterfaces.library.specfun.gamma_vector(x)

gamma_vector returns an array of values of the gamma function $\Gamma \left(x\right)$.

For full information please refer to the NAG Library document for s14an

https://support.nag.com/numeric/nl/nagdoc_30/flhtml/s/s14anf.html

Parameters

xfloat, array-like, shape $\left(n\right)$

The argument $x_{\text{i}}$ of the function, for $\text{i}=1,2,\dots ,n$.

Returns

ffloat, ndarray, shape $\left(n\right)$

$\Gamma \left(x_i\right)$, the function values.

ivalidint, ndarray, shape $\left(n\right)$

$ivalid[\text{i}-1]$ contains the error code for $x_{\text{i}}$, for $\text{i}=1,2,\dots ,n$.

$ivalid[i-1]=0$

No error.

$ivalid[i-1]=1$

$x_i$ is too large and positive. $f[\text{i}-1]$ contains the approximate value of $\Gamma \left(x_i\right)$ at the nearest valid argument. The threshold value is the same as for $errno$ = 1 in gamma().

$ivalid[i-1]=2$

$x_i$ is too large and negative. $f[\text{i}-1]$ contains zero. The threshold value is the same as for $errno$ = 2 in gamma().

$ivalid[i-1]=3$

$x_i$ is too close to zero. $f[\text{i}-1]$ contains the approximate value of $\Gamma \left(x_i\right)$ at the nearest valid argument. The threshold value is the same as for $errno$ = 2 in gamma().

$ivalid[i-1]=4$

$x_i$ is a negative integer, at which values $\Gamma \left(x_i\right)$ are infinite. $f[\text{i}-1]$ contains a large positive value.

Raises

NagValueError

(errno $2$)

On entry, $n=⟨value⟩$.

Constraint: $n\ge 0$.

Warns

NagAlgorithmicWarning

(errno $1$)

On entry, at least one value of $x$ was invalid.

Check $ivalid$ for more information.

Notes

gamma_vector evaluates an approximation to the gamma function $\Gamma \left(x\right)$ for an array of arguments $x_{\text{i}}$, for $\text{i}=1,2,\dots ,n$. The function is based on the Chebyshev expansion:

$$\Gamma (1+u)=\sum _{r=0}^{\prime }{a}_r{T}_r\left(t\right)$$

where $0\le u<1,t=2u-1\text{,}$ and uses the property $\Gamma (1+x)=x\Gamma \left(x\right)$. If $x=N+1+u$ where $N$ is integral and $0\le u<1$ then it follows that:

for $N>0$,	$\Gamma \left(x\right)=(x-1)(x-2)\cdots (x-N)\Gamma (1+u)$,
for $N=0$,	$\Gamma \left(x\right)=\Gamma (1+u)$,
for $N<0$,	$\Gamma \left(x\right)=\frac{\Gamma (1+u)}{x(x+1)(x+2)\cdots (x-N-1)}$.

There are four possible failures for this function:

1. if $x$ is too large, there is a danger of overflow since $\Gamma \left(x\right)$ could become too large to be represented in the machine;

2. if $x$ is too large and negative, there is a danger of underflow;

3. if $x$ is equal to a negative integer, $\Gamma \left(x\right)$ would overflow since it has poles at such points;

4. if $x$ is too near zero, there is again the danger of overflow on some machines. For small $x$, $\Gamma \left(x\right)\simeq 1/x$, and on some machines there exists a range of nonzero but small values of $x$ for which $1/x$ is larger than the greatest representable value.

References

NIST Digital Library of Mathematical Functions