org.apache.commons.math.special

## Class Gamma

• java.lang.Object
• org.apache.commons.math.special.Gamma

• ```public class Gamma
extends java.lang.Object```
This is a utility class that provides computation methods related to the Gamma family of functions.
• ### Field Summary

Fields
Modifier and Type Field and Description
`static double` `GAMMA`
• ### Method Summary

All Methods
Modifier and Type Method and Description
`static double` `digamma(double x)`
Computes the digamma function of x.
`static double` `logGamma(double x)`
Returns the natural logarithm of the gamma function Γ(x).
`static double` ```regularizedGammaP(double a, double x)```
Returns the regularized gamma function P(a, x).
`static double` ```regularizedGammaP(double a, double x, double epsilon, int maxIterations)```
Returns the regularized gamma function P(a, x).
`static double` ```regularizedGammaQ(double a, double x)```
Returns the regularized gamma function Q(a, x) = 1 - P(a, x).
`static double` ```regularizedGammaQ(double a, double x, double epsilon, int maxIterations)```
Returns the regularized gamma function Q(a, x) = 1 - P(a, x).
`static double` `trigamma(double x)`
Computes the trigamma function of x.
• ### Methods inherited from class java.lang.Object

`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`
• ### Method Detail

• #### regularizedGammaP

```public static double regularizedGammaP(double a,
double x)
throws MathException```
Returns the regularized gamma function P(a, x).
Parameters:
`a` - the a parameter.
`x` - the value.
Returns:
the regularized gamma function P(a, x)
Throws:
`MathException` - if the algorithm fails to converge.
• #### regularizedGammaP

```public static double regularizedGammaP(double a,
double x,
double epsilon,
int maxIterations)
throws MathException```
Returns the regularized gamma function P(a, x). The implementation of this method is based on:
Parameters:
`a` - the a parameter.
`x` - the value.
`epsilon` - When the absolute value of the nth item in the series is less than epsilon the approximation ceases to calculate further elements in the series.
`maxIterations` - Maximum number of "iterations" to complete.
Returns:
the regularized gamma function P(a, x)
Throws:
`MathException` - if the algorithm fails to converge.
• #### regularizedGammaQ

```public static double regularizedGammaQ(double a,
double x)
throws MathException```
Returns the regularized gamma function Q(a, x) = 1 - P(a, x).
Parameters:
`a` - the a parameter.
`x` - the value.
Returns:
the regularized gamma function Q(a, x)
Throws:
`MathException` - if the algorithm fails to converge.
• #### regularizedGammaQ

```public static double regularizedGammaQ(double a,
double x,
double epsilon,
int maxIterations)
throws MathException```
Returns the regularized gamma function Q(a, x) = 1 - P(a, x). The implementation of this method is based on:
Parameters:
`a` - the a parameter.
`x` - the value.
`epsilon` - When the absolute value of the nth item in the series is less than epsilon the approximation ceases to calculate further elements in the series.
`maxIterations` - Maximum number of "iterations" to complete.
Returns:
the regularized gamma function P(a, x)
Throws:
`MathException` - if the algorithm fails to converge.
• #### digamma

`public static double digamma(double x)`

Computes the digamma function of x.

This is an independently written implementation of the algorithm described in Jose Bernardo, Algorithm AS 103: Psi (Digamma) Function, Applied Statistics, 1976.

Some of the constants have been changed to increase accuracy at the moderate expense of run-time. The result should be accurate to within 10^-8 absolute tolerance for x >= 10^-5 and within 10^-8 relative tolerance for x > 0.

Performance for large negative values of x will be quite expensive (proportional to |x|). Accuracy for negative values of x should be about 10^-8 absolute for results less than 10^5 and 10^-8 relative for results larger than that.

Parameters:
`x` - the argument
Returns:
digamma(x) to within 10-8 relative or absolute error whichever is smaller
Since:
2.0
Digamma at wikipedia , Bernardo's original article
• #### trigamma

`public static double trigamma(double x)`

Computes the trigamma function of x. This function is derived by taking the derivative of the implementation of digamma.

Parameters:
`x` - the argument
Returns:
trigamma(x) to within 10-8 relative or absolute error whichever is smaller
Since:
2.0
Trigamma at wikipedia , `digamma(double)`