Incomplete Gamma Function Inverses

| Home | Libraries | People | FAQ | More

#### Incomplete Gamma Function Inverses

##### Synopsis

    #include <boost/math/special_functions/gamma.hpp>

    namespace boost{ namespace math{

    template <class T1, class T2>
    calculated-result-type gamma_q_inv(T1 a, T2 q);

    template <class T1, class T2, class Policy>
    calculated-result-type gamma_q_inv(T1 a, T2 q, const Policy&);

    template <class T1, class T2>
    calculated-result-type gamma_p_inv(T1 a, T2 p);

    template <class T1, class T2, class Policy>
    calculated-result-type gamma_p_inv(T1 a, T2 p, const Policy&);

    template <class T1, class T2>
    calculated-result-type gamma_q_inva(T1 x, T2 q);

    template <class T1, class T2, class Policy>
    calculated-result-type gamma_q_inva(T1 x, T2 q, const Policy&);

    template <class T1, class T2>
    calculated-result-type gamma_p_inva(T1 x, T2 p);

    template <class T1, class T2, class Policy>
    calculated-result-type gamma_p_inva(T1 x, T2 p, const Policy&);

    }} // namespaces

##### Description

There are four incomplete gamma function inverses which either compute x given a and p or q, or else compute a given x and either p or q.

The return type of these functions is computed using the result type calculation rules when T1 and T2 are different types, otherwise the return type is simply T1.

The final Policy argument is optional and can be used to control the behaviour of the function: how it handles errors, what level of precision to use etc. Refer to the policy documentation for more details.

| Tip

When people normally talk about the inverse of the incomplete gamma function, they are talking about inverting on parameter x. These are implemented here as gamma_p_inv and gamma_q_inv, and are by far the most efficient of the inverses presented here.

The inverse on the a parameter finds use in some statistical applications but has to be computed by rather brute force numerical techniques and is consequently several times slower. These are implemented here as gamma_p_inva and gamma_q_inva.

    template <class T1, class T2>
    calculated-result-type gamma_q_inv(T1 a, T2 q);

    template <class T1, class T2, class Policy>
    calculated-result-type gamma_q_inv(T1 a, T2 q, const Policy&);

Returns a value x such that: `q = gamma_q(a, x);`

Requires: a > 0 and 1 >= p,q >= 0.

    template <class T1, class T2>
    calculated-result-type gamma_p_inv(T1 a, T2 p);

    template <class T1, class T2, class Policy>
    calculated-result-type gamma_p_inv(T1 a, T2 p, const Policy&);

Returns a value x such that: `p = gamma_p(a, x);`

Requires: a > 0 and 1 >= p,q >= 0.

    template <class T1, class T2>
    calculated-result-type gamma_q_inva(T1 x, T2 q);

    template <class T1, class T2, class Policy>
    calculated-result-type gamma_q_inva(T1 x, T2 q, const Policy&);

Returns a value a such that: `q = gamma_q(a, x);`

Requires: x > 0 and 1 >= p,q >= 0.

    template <class T1, class T2>
    calculated-result-type gamma_p_inva(T1 x, T2 p);

    template <class T1, class T2, class Policy>
    calculated-result-type gamma_p_inva(T1 x, T2 p, const Policy&);

Returns a value a such that: `p = gamma_p(a, x);`

Requires: x > 0 and 1 >= p,q >= 0.

##### Accuracy

The accuracy of these functions doesn't vary much by platform or by the type T. Given that these functions are computed by iterative methods, they are deliberately "detuned" so as not to be too accurate: it is in any case impossible for these function to be more accurate than the regular forward incomplete gamma functions. In practice, the accuracy of these functions is very similar to that of gamma_p and gamma_q functions.

##### Testing

There are two sets of tests:

- Basic sanity checks attempt to "round-trip" from a and x to p or q and back again. These tests have quite generous tolerances: in general both the incomplete gamma, and its inverses, change so rapidly that round tripping to more than a couple of significant digits isn't possible. This is especially true when p or q is very near one: in this case there isn't enough "information content" in the input to the inverse function to get back where you started.
- Accuracy checks using high precision test values. These measure the accuracy of the result, given exact input values.

##### Implementation

The functions gamma_p_inv and gamma_q_inv share a common implementation.

First an initial approximation is computed using the methodology described in:

A. R. Didonato and A. H. Morris, Computation of the Incomplete Gamma Function Ratios and their Inverse, ACM Trans. Math. Software 12 (1986), 377-393.

Finally, the last few bits are cleaned up using Halley iteration, the iteration limit is set to 2/3 of the number of bits in T, which by experiment is sufficient to ensure that the inverses are at least as accurate as the normal incomplete gamma functions. In testing, no more than 3 iterations are required to produce a result as accurate as the forward incomplete gamma function, and in many cases only one iteration is required.

The functions gamma_p_inva and gamma_q_inva also share a common implementation but are handled separately from gamma_p_inv and gamma_q_inv.

An initial approximation for a is computed very crudely so that gamma_p(a, x) ~ 0.5, this value is then used as a starting point for a generic derivative-free root finding algorithm. As a consequence, these two functions are rather more expensive to compute than the gamma_p_inv or gamma_q_inv functions. Even so, the root is usually found in fewer than 10 iterations.