org.apache.commons.math3.special

## Class Gamma

- java.lang.Object
- - org.apache.commons.math3.special.Gamma

-     public class Gamma
      extends Object

  This is a utility class that provides computation methods related to the Gamma family of functions.
  Version:
    $Id: Gamma.java 1244107 2012-02-14 16:17:55Z erans $

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static double` | `GAMMA` Euler-Mascheroni constant

  - ### Method Summary

    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

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### GAMMA

          public static final double GAMMA

      Euler-Mascheroni constant
      Since:
        2.0
      See Also:
        Constant Field Values

  - ### Method Detail

    - #### logGamma

          public static double logGamma(double x)

      Returns the natural logarithm of the gamma function Γ(x). The implementation of this method is based on:
      - Gamma Function, equation (28).
      - Lanczos Approximation, equations (1) through (5).
      - Paul Godfrey, A note on the computation of the convergent Lanczos complex Gamma approximation
      Parameters:
        `x` - Value.
      Returns:
        log(Γ(x))

    - #### regularizedGammaP

          public static double regularizedGammaP(double a,
                                 double x)

      Returns the regularized gamma function P(a, x).
      Parameters:
        `a` - Parameter.
        `x` - Value.
      Returns:
        the regularized gamma function P(a, x).
      Throws:
        `MaxCountExceededException` - if the algorithm fails to converge.

    - #### regularizedGammaP

          public static double regularizedGammaP(double a,
                                 double x,
                                 double epsilon,
                                 int maxIterations)

      Returns the regularized gamma function P(a, x). The implementation of this method is based on:
      - Regularized Gamma Function, equation (1)
      - Incomplete Gamma Function, equation (4).
      - Confluent Hypergeometric Function of the First Kind, equation (1).
      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:
        `MaxCountExceededException` - if the algorithm fails to converge.

    - #### regularizedGammaQ

          public static double regularizedGammaQ(double a,
                                 double x)

      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:
        `MaxCountExceededException` - if the algorithm fails to converge.

    - #### regularizedGammaQ

          public static double regularizedGammaQ(double a,
                                 double x,
                                 double epsilon,
                                 int maxIterations)

      Returns the regularized gamma function Q(a, x) = 1 - P(a, x). The implementation of this method is based on:
      - Regularized Gamma Function, equation (1).
      - Regularized incomplete gamma function: Continued fraction representations (formula 06.08.10.0003)
      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:
        `MaxCountExceededException` - 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` - Argument.
      Returns:
        digamma(x) to within 10-8 relative or absolute error whichever is smaller.
      Since:
        2.0
      See Also:
        Digamma, 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` - Argument.
      Returns:
        trigamma(x) to within 10-8 relative or absolute error whichever is smaller
      Since:
        2.0
      See Also:
        Trigamma, `digamma(double)`

Copyright © 2003-2012 The Apache Software Foundation. All Rights Reserved.