projects / ceph.git / blame
| Commit | Line | Data |
|---|---|---|
| 7c673cae FG |
1 | <html> |
| 2 | <head> | |
| 3 | <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> | |
| 4 | <title>The Incomplete Beta Function Inverses</title> | |
| 5 | <link rel="stylesheet" href="../../math.css" type="text/css"> | |
| 6 | <meta name="generator" content="DocBook XSL Stylesheets V1.77.1"> | |
| 7 | <link rel="home" href="../../index.html" title="Math Toolkit 2.5.1"> | |
| 8 | <link rel="up" href="../sf_beta.html" title="Beta Functions"> | |
| 9 | <link rel="prev" href="ibeta_function.html" title="Incomplete Beta Functions"> | |
| 10 | <link rel="next" href="beta_derivative.html" title="Derivative of the Incomplete Beta Function"> | |
| 11 | </head> | |
| 12 | <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> | |
| 13 | <table cellpadding="2" width="100%"><tr> | |
| 14 | <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td> | |
| 15 | <td align="center"><a href="../../../../../../index.html">Home</a></td> | |
| 16 | <td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> | |
| 17 | <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> | |
| 18 | <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> | |
| 19 | <td align="center"><a href="../../../../../../more/index.htm">More</a></td> | |
| 20 | </tr></table> | |
| 21 | <hr> | |
| 22 | <div class="spirit-nav"> | |
| 23 | <a accesskey="p" href="ibeta_function.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../sf_beta.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="beta_derivative.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> | |
| 24 | </div> | |
| 25 | <div class="section"> | |
| 26 | <div class="titlepage"><div><div><h3 class="title"> | |
| 27 | <a name="math_toolkit.sf_beta.ibeta_inv_function"></a><a class="link" href="ibeta_inv_function.html" title="The Incomplete Beta Function Inverses">The Incomplete | |
| 28 | Beta Function Inverses</a> | |
| 29 | </h3></div></div></div> | |
| 30 | <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">special_functions</span><span class="special">/</span><span class="identifier">beta</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> | |
| 31 | </pre> | |
| 32 | <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">math</span><span class="special">{</span> | |
| 33 | ||
| 34 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">></span> | |
| 35 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibeta_inv</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">p</span><span class="special">);</span> | |
| 36 | ||
| 37 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">></span> | |
| 38 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibeta_inv</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">p</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&);</span> | |
| 39 | ||
| 40 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T4</span><span class="special">></span> | |
| 41 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibeta_inv</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">p</span><span class="special">,</span> <span class="identifier">T4</span><span class="special">*</span> <span class="identifier">py</span><span class="special">);</span> | |
| 42 | ||
| 43 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T4</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">></span> | |
| 44 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibeta_inv</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">p</span><span class="special">,</span> <span class="identifier">T4</span><span class="special">*</span> <span class="identifier">py</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&);</span> | |
| 45 | ||
| 46 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">></span> | |
| 47 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibetac_inv</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">q</span><span class="special">);</span> | |
| 48 | ||
| 49 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">></span> | |
| 50 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibetac_inv</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">q</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&);</span> | |
| 51 | ||
| 52 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T4</span><span class="special">></span> | |
| 53 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibetac_inv</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">q</span><span class="special">,</span> <span class="identifier">T4</span><span class="special">*</span> <span class="identifier">py</span><span class="special">);</span> | |
| 54 | ||
| 55 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T4</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">></span> | |
| 56 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibetac_inv</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">q</span><span class="special">,</span> <span class="identifier">T4</span><span class="special">*</span> <span class="identifier">py</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&);</span> | |
| 57 | ||
| 58 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">></span> | |
| 59 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibeta_inva</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">p</span><span class="special">);</span> | |
| 60 | ||
| 61 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">></span> | |
| 62 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibeta_inva</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">p</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&);</span> | |
| 63 | ||
| 64 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">></span> | |
| 65 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibetac_inva</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">q</span><span class="special">);</span> | |
| 66 | ||
| 67 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">></span> | |
| 68 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibetac_inva</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">q</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&);</span> | |
| 69 | ||
| 70 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">></span> | |
| 71 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibeta_invb</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">p</span><span class="special">);</span> | |
| 72 | ||
| 73 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">></span> | |
| 74 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibeta_invb</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">p</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&);</span> | |
| 75 | ||
| 76 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">></span> | |
| 77 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibetac_invb</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">q</span><span class="special">);</span> | |
| 78 | ||
| 79 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">></span> | |
| 80 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibetac_invb</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">q</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&);</span> | |
| 81 | ||
| 82 | <span class="special">}}</span> <span class="comment">// namespaces</span> | |
| 83 | </pre> | |
| 84 | <h5> | |
| 85 | <a name="math_toolkit.sf_beta.ibeta_inv_function.h0"></a> | |
| 86 | <span class="phrase"><a name="math_toolkit.sf_beta.ibeta_inv_function.description"></a></span><a class="link" href="ibeta_inv_function.html#math_toolkit.sf_beta.ibeta_inv_function.description">Description</a> | |
| 87 | </h5> | |
| 88 | <p> | |
| 89 | There are six <a href="http://functions.wolfram.com/GammaBetaErf/" target="_top">incomplete | |
| 90 | beta function inverses</a> which allow you solve for any of the three | |
| 91 | parameters to the incomplete beta, starting from either the result of the | |
| 92 | incomplete beta (p) or its complement (q). | |
| 93 | </p> | |
| 94 | <p> | |
| 95 | The final <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a> argument is optional and can | |
| 96 | be used to control the behaviour of the function: how it handles errors, | |
| 97 | what level of precision to use etc. Refer to the <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">policy | |
| 98 | documentation for more details</a>. | |
| 99 | </p> | |
| 100 | <div class="tip"><table border="0" summary="Tip"> | |
| 101 | <tr> | |
| 102 | <td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../../../../doc/src/images/tip.png"></td> | |
| 103 | <th align="left">Tip</th> | |
| 104 | </tr> | |
| 105 | <tr><td align="left" valign="top"> | |
| 106 | <p> | |
| 107 | When people normally talk about the inverse of the incomplete beta function, | |
| 108 | they are talking about inverting on parameter <span class="emphasis"><em>x</em></span>. These | |
| 109 | are implemented here as ibeta_inv and ibetac_inv, and are by far the most | |
| 110 | efficient of the inverses presented here. | |
| 111 | </p> | |
| 112 | <p> | |
| 113 | The inverses on the <span class="emphasis"><em>a</em></span> and <span class="emphasis"><em>b</em></span> parameters | |
| 114 | find use in some statistical applications, but have to be computed by rather | |
| 115 | brute force numerical techniques and are consequently several times slower. | |
| 116 | These are implemented here as ibeta_inva and ibeta_invb, and complement | |
| 117 | versions ibetac_inva and ibetac_invb. | |
| 118 | </p> | |
| 119 | </td></tr> | |
| 120 | </table></div> | |
| 121 | <p> | |
| 122 | The return type of these functions is computed using the <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>result | |
| 123 | type calculation rules</em></span></a> when called with arguments T1...TN | |
| 124 | of different types. | |
| 125 | </p> | |
| 126 | <pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">></span> | |
| 127 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibeta_inv</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">p</span><span class="special">);</span> | |
| 128 | ||
| 129 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">></span> | |
| 130 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibeta_inv</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">p</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&);</span> | |
| 131 | ||
| 132 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T4</span><span class="special">></span> | |
| 133 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibeta_inv</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">p</span><span class="special">,</span> <span class="identifier">T4</span><span class="special">*</span> <span class="identifier">py</span><span class="special">);</span> | |
| 134 | ||
| 135 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T4</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">></span> | |
| 136 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibeta_inv</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">p</span><span class="special">,</span> <span class="identifier">T4</span><span class="special">*</span> <span class="identifier">py</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&);</span> | |
| 137 | </pre> | |
| 138 | <p> | |
| 139 | Returns a value <span class="emphasis"><em>x</em></span> such that: <code class="computeroutput"><span class="identifier">p</span> | |
| 140 | <span class="special">=</span> <span class="identifier">ibeta</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span> | |
| 141 | <span class="identifier">b</span><span class="special">,</span> <span class="identifier">x</span><span class="special">);</span></code> and | |
| 142 | sets <code class="computeroutput"><span class="special">*</span><span class="identifier">py</span> | |
| 143 | <span class="special">=</span> <span class="number">1</span> <span class="special">-</span> <span class="identifier">x</span></code> when | |
| 144 | the <code class="computeroutput"><span class="identifier">py</span></code> parameter is provided | |
| 145 | and is non-null. Note that internally this function computes whichever is | |
| 146 | the smaller of <code class="computeroutput"><span class="identifier">x</span></code> and <code class="computeroutput"><span class="number">1</span><span class="special">-</span><span class="identifier">x</span></code>, | |
| 147 | and therefore the value assigned to <code class="computeroutput"><span class="special">*</span><span class="identifier">py</span></code> is free from cancellation errors. That | |
| 148 | means that even if the function returns <code class="computeroutput"><span class="number">1</span></code>, | |
| 149 | the value stored in <code class="computeroutput"><span class="special">*</span><span class="identifier">py</span></code> | |
| 150 | may be non-zero, albeit very small. | |
| 151 | </p> | |
| 152 | <p> | |
| 153 | Requires: <span class="emphasis"><em>a,b > 0</em></span> and <span class="emphasis"><em>0 <= p <= 1</em></span>. | |
| 154 | </p> | |
| 155 | <p> | |
| 156 | The final <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a> argument is optional and can | |
| 157 | be used to control the behaviour of the function: how it handles errors, | |
| 158 | what level of precision to use etc. Refer to the <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">policy | |
| 159 | documentation for more details</a>. | |
| 160 | </p> | |
| 161 | <pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">></span> | |
| 162 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibetac_inv</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">q</span><span class="special">);</span> | |
| 163 | ||
| 164 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">></span> | |
| 165 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibetac_inv</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">q</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&);</span> | |
| 166 | ||
| 167 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T4</span><span class="special">></span> | |
| 168 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibetac_inv</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">q</span><span class="special">,</span> <span class="identifier">T4</span><span class="special">*</span> <span class="identifier">py</span><span class="special">);</span> | |
| 169 | ||
| 170 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T4</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">></span> | |
| 171 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibetac_inv</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">q</span><span class="special">,</span> <span class="identifier">T4</span><span class="special">*</span> <span class="identifier">py</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&);</span> | |
| 172 | </pre> | |
| 173 | <p> | |
| 174 | Returns a value <span class="emphasis"><em>x</em></span> such that: <code class="computeroutput"><span class="identifier">q</span> | |
| 175 | <span class="special">=</span> <span class="identifier">ibetac</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span> | |
| 176 | <span class="identifier">b</span><span class="special">,</span> <span class="identifier">x</span><span class="special">);</span></code> and | |
| 177 | sets <code class="computeroutput"><span class="special">*</span><span class="identifier">py</span> | |
| 178 | <span class="special">=</span> <span class="number">1</span> <span class="special">-</span> <span class="identifier">x</span></code> when | |
| 179 | the <code class="computeroutput"><span class="identifier">py</span></code> parameter is provided | |
| 180 | and is non-null. Note that internally this function computes whichever is | |
| 181 | the smaller of <code class="computeroutput"><span class="identifier">x</span></code> and <code class="computeroutput"><span class="number">1</span><span class="special">-</span><span class="identifier">x</span></code>, | |
| 182 | and therefore the value assigned to <code class="computeroutput"><span class="special">*</span><span class="identifier">py</span></code> is free from cancellation errors. That | |
| 183 | means that even if the function returns <code class="computeroutput"><span class="number">1</span></code>, | |
| 184 | the value stored in <code class="computeroutput"><span class="special">*</span><span class="identifier">py</span></code> | |
| 185 | may be non-zero, albeit very small. | |
| 186 | </p> | |
| 187 | <p> | |
| 188 | Requires: <span class="emphasis"><em>a,b > 0</em></span> and <span class="emphasis"><em>0 <= q <= 1</em></span>. | |
| 189 | </p> | |
| 190 | <p> | |
| 191 | The final <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a> argument is optional and can | |
| 192 | be used to control the behaviour of the function: how it handles errors, | |
| 193 | what level of precision to use etc. Refer to the <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">policy | |
| 194 | documentation for more details</a>. | |
| 195 | </p> | |
| 196 | <pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">></span> | |
| 197 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibeta_inva</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">p</span><span class="special">);</span> | |
| 198 | ||
| 199 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">></span> | |
| 200 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibeta_inva</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">p</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&);</span> | |
| 201 | </pre> | |
| 202 | <p> | |
| 203 | Returns a value <span class="emphasis"><em>a</em></span> such that: <code class="computeroutput"><span class="identifier">p</span> | |
| 204 | <span class="special">=</span> <span class="identifier">ibeta</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span> | |
| 205 | <span class="identifier">b</span><span class="special">,</span> <span class="identifier">x</span><span class="special">);</span></code> | |
| 206 | </p> | |
| 207 | <p> | |
| 208 | Requires: <span class="emphasis"><em>b > 0</em></span>, <span class="emphasis"><em>0 < x < 1</em></span> | |
| 209 | and <span class="emphasis"><em>0 <= p <= 1</em></span>. | |
| 210 | </p> | |
| 211 | <p> | |
| 212 | The final <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a> argument is optional and can | |
| 213 | be used to control the behaviour of the function: how it handles errors, | |
| 214 | what level of precision to use etc. Refer to the <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">policy | |
| 215 | documentation for more details</a>. | |
| 216 | </p> | |
| 217 | <pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">></span> | |
| 218 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibetac_inva</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">p</span><span class="special">);</span> | |
| 219 | ||
| 220 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">></span> | |
| 221 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibetac_inva</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">p</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&);</span> | |
| 222 | </pre> | |
| 223 | <p> | |
| 224 | Returns a value <span class="emphasis"><em>a</em></span> such that: <code class="computeroutput"><span class="identifier">q</span> | |
| 225 | <span class="special">=</span> <span class="identifier">ibetac</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span> | |
| 226 | <span class="identifier">b</span><span class="special">,</span> <span class="identifier">x</span><span class="special">);</span></code> | |
| 227 | </p> | |
| 228 | <p> | |
| 229 | Requires: <span class="emphasis"><em>b > 0</em></span>, <span class="emphasis"><em>0 < x < 1</em></span> | |
| 230 | and <span class="emphasis"><em>0 <= q <= 1</em></span>. | |
| 231 | </p> | |
| 232 | <p> | |
| 233 | The final <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a> argument is optional and can | |
| 234 | be used to control the behaviour of the function: how it handles errors, | |
| 235 | what level of precision to use etc. Refer to the <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">policy | |
| 236 | documentation for more details</a>. | |
| 237 | </p> | |
| 238 | <pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">></span> | |
| 239 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibeta_invb</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">p</span><span class="special">);</span> | |
| 240 | ||
| 241 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">></span> | |
| 242 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibeta_invb</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">p</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&);</span> | |
| 243 | </pre> | |
| 244 | <p> | |
| 245 | Returns a value <span class="emphasis"><em>b</em></span> such that: <code class="computeroutput"><span class="identifier">p</span> | |
| 246 | <span class="special">=</span> <span class="identifier">ibeta</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span> | |
| 247 | <span class="identifier">b</span><span class="special">,</span> <span class="identifier">x</span><span class="special">);</span></code> | |
| 248 | </p> | |
| 249 | <p> | |
| 250 | Requires: <span class="emphasis"><em>a > 0</em></span>, <span class="emphasis"><em>0 < x < 1</em></span> | |
| 251 | and <span class="emphasis"><em>0 <= p <= 1</em></span>. | |
| 252 | </p> | |
| 253 | <p> | |
| 254 | The final <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a> argument is optional and can | |
| 255 | be used to control the behaviour of the function: how it handles errors, | |
| 256 | what level of precision to use etc. Refer to the <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">policy | |
| 257 | documentation for more details</a>. | |
| 258 | </p> | |
| 259 | <pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">></span> | |
| 260 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibetac_invb</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">p</span><span class="special">);</span> | |
| 261 | ||
| 262 | <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">></span> | |
| 263 | <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ibetac_invb</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">p</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&);</span> | |
| 264 | </pre> | |
| 265 | <p> | |
| 266 | Returns a value <span class="emphasis"><em>b</em></span> such that: <code class="computeroutput"><span class="identifier">q</span> | |
| 267 | <span class="special">=</span> <span class="identifier">ibetac</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span> | |
| 268 | <span class="identifier">b</span><span class="special">,</span> <span class="identifier">x</span><span class="special">);</span></code> | |
| 269 | </p> | |
| 270 | <p> | |
| 271 | Requires: <span class="emphasis"><em>a > 0</em></span>, <span class="emphasis"><em>0 < x < 1</em></span> | |
| 272 | and <span class="emphasis"><em>0 <= q <= 1</em></span>. | |
| 273 | </p> | |
| 274 | <p> | |
| 275 | The final <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">Policy</a> argument is optional and can | |
| 276 | be used to control the behaviour of the function: how it handles errors, | |
| 277 | what level of precision to use etc. Refer to the <a class="link" href="../../policy.html" title="Chapter 15. Policies: Controlling Precision, Error Handling etc">policy | |
| 278 | documentation for more details</a>. | |
| 279 | </p> | |
| 280 | <h5> | |
| 281 | <a name="math_toolkit.sf_beta.ibeta_inv_function.h1"></a> | |
| 282 | <span class="phrase"><a name="math_toolkit.sf_beta.ibeta_inv_function.accuracy"></a></span><a class="link" href="ibeta_inv_function.html#math_toolkit.sf_beta.ibeta_inv_function.accuracy">Accuracy</a> | |
| 283 | </h5> | |
| 284 | <p> | |
| 285 | The accuracy of these functions should closely follow that of the regular | |
| 286 | forward incomplete beta functions. However, note that in some parts of their | |
| 287 | domain, these functions can be extremely sensitive to changes in input, particularly | |
| 288 | when the argument <span class="emphasis"><em>p</em></span> (or it's complement <span class="emphasis"><em>q</em></span>) | |
| 289 | is very close to <code class="computeroutput"><span class="number">0</span></code> or <code class="computeroutput"><span class="number">1</span></code>. | |
| 290 | </p> | |
| 291 | <p> | |
| 292 | Comparisons to other libraries are shown below, note that our test data exercises | |
| 293 | some rather extreme cases in the incomplete beta function which many other | |
| 294 | libraries fail to handle: | |
| 295 | </p> | |
| 296 | <div class="table"> | |
| 297 | <a name="math_toolkit.sf_beta.ibeta_inv_function.table_ibeta_inv"></a><p class="title"><b>Table 6.22. Error rates for ibeta_inv</b></p> | |
| 298 | <div class="table-contents"><table class="table" summary="Error rates for ibeta_inv"> | |
| 299 | <colgroup> | |
| 300 | <col> | |
| 301 | <col> | |
| 302 | <col> | |
| 303 | <col> | |
| 304 | <col> | |
| 305 | </colgroup> | |
| 306 | <thead><tr> | |
| 307 | <th> | |
| 308 | </th> | |
| 309 | <th> | |
| 310 | <p> | |
| 311 | Microsoft Visual C++ version 12.0<br> Win32<br> double | |
| 312 | </p> | |
| 313 | </th> | |
| 314 | <th> | |
| 315 | <p> | |
| 316 | GNU C++ version 5.1.0<br> linux<br> double | |
| 317 | </p> | |
| 318 | </th> | |
| 319 | <th> | |
| 320 | <p> | |
| 321 | GNU C++ version 5.1.0<br> linux<br> long double | |
| 322 | </p> | |
| 323 | </th> | |
| 324 | <th> | |
| 325 | <p> | |
| 326 | Sun compiler version 0x5130<br> Sun Solaris<br> long double | |
| 327 | </p> | |
| 328 | </th> | |
| 329 | </tr></thead> | |
| 330 | <tbody><tr> | |
| 331 | <td> | |
| 332 | <p> | |
| 333 | Inverse incomplete beta | |
| 334 | </p> | |
| 335 | </td> | |
| 336 | <td> | |
| 337 | <p> | |
| 338 | <span class="blue">Max = 7.08e+003ε (Mean = 244ε)</span> | |
| 339 | </p> | |
| 340 | </td> | |
| 341 | <td> | |
| 342 | <p> | |
| 343 | <span class="blue">Max = 3.21ε (Mean = 0.158ε)</span><br> <br> | |
| 344 | (<span class="emphasis"><em>Rmath 3.0.2:</em></span> <span class="red">Max = +INFε (Mean | |
| 345 | = +INFε) <a class="link" href="../logs_and_tables/logs.html#errors_GNU_C_version_5_1_0_linux_double_ibeta_inv_Rmath_3_0_2_Inverse_incomplete_beta">And | |
| 346 | other failures.</a>)</span><br> (<span class="emphasis"><em>Cephes:</em></span> | |
| 347 | <span class="red">Max = 1.28e+10ε (Mean = 5.17e+08ε))</span> | |
| 348 | </p> | |
| 349 | </td> | |
| 350 | <td> | |
| 351 | <p> | |
| 352 | <span class="blue">Max = 4.53e+04ε (Mean = 2.93e+03ε)</span> | |
| 353 | </p> | |
| 354 | </td> | |
| 355 | <td> | |
| 356 | <p> | |
| 357 | <span class="blue">Max = 4.22e+04ε (Mean = 2.8e+03ε)</span> | |
| 358 | </p> | |
| 359 | </td> | |
| 360 | </tr></tbody> | |
| 361 | </table></div> | |
| 362 | </div> | |
| 363 | <br class="table-break"><div class="table"> | |
| 364 | <a name="math_toolkit.sf_beta.ibeta_inv_function.table_ibetac_inv"></a><p class="title"><b>Table 6.23. Error rates for ibetac_inv</b></p> | |
| 365 | <div class="table-contents"><table class="table" summary="Error rates for ibetac_inv"> | |
| 366 | <colgroup> | |
| 367 | <col> | |
| 368 | <col> | |
| 369 | <col> | |
| 370 | <col> | |
| 371 | <col> | |
| 372 | </colgroup> | |
| 373 | <thead><tr> | |
| 374 | <th> | |
| 375 | </th> | |
| 376 | <th> | |
| 377 | <p> | |
| 378 | Microsoft Visual C++ version 12.0<br> Win32<br> double | |
| 379 | </p> | |
| 380 | </th> | |
| 381 | <th> | |
| 382 | <p> | |
| 383 | GNU C++ version 5.1.0<br> linux<br> double | |
| 384 | </p> | |
| 385 | </th> | |
| 386 | <th> | |
| 387 | <p> | |
| 388 | GNU C++ version 5.1.0<br> linux<br> long double | |
| 389 | </p> | |
| 390 | </th> | |
| 391 | <th> | |
| 392 | <p> | |
| 393 | Sun compiler version 0x5130<br> Sun Solaris<br> long double | |
| 394 | </p> | |
| 395 | </th> | |
| 396 | </tr></thead> | |
| 397 | <tbody><tr> | |
| 398 | <td> | |
| 399 | <p> | |
| 400 | Inverse incomplete beta | |
| 401 | </p> | |
| 402 | </td> | |
| 403 | <td> | |
| 404 | <p> | |
| 405 | <span class="blue">Max = 5.53e+003ε (Mean = 220ε)</span> | |
| 406 | </p> | |
| 407 | </td> | |
| 408 | <td> | |
| 409 | <p> | |
| 410 | <span class="blue">Max = 1.71ε (Mean = 0.108ε)</span><br> <br> | |
| 411 | (<span class="emphasis"><em>Rmath 3.0.2:</em></span> <span class="red">Max = +INFε (Mean | |
| 412 | = +INFε) <a class="link" href="../logs_and_tables/logs.html#errors_GNU_C_version_5_1_0_linux_double_ibetac_inv_Rmath_3_0_2_Inverse_incomplete_beta">And | |
| 413 | other failures.</a>)</span><br> (<span class="emphasis"><em>Cephes:</em></span> | |
| 414 | Max = 1.71ε (Mean = 0.108ε)) | |
| 415 | </p> | |
| 416 | </td> | |
| 417 | <td> | |
| 418 | <p> | |
| 419 | <span class="blue">Max = 6.17e+04ε (Mean = 3.77e+03ε)</span> | |
| 420 | </p> | |
| 421 | </td> | |
| 422 | <td> | |
| 423 | <p> | |
| 424 | <span class="blue">Max = 5.15e+04ε (Mean = 3.51e+03ε)</span> | |
| 425 | </p> | |
| 426 | </td> | |
| 427 | </tr></tbody> | |
| 428 | </table></div> | |
| 429 | </div> | |
| 430 | <br class="table-break"><div class="table"> | |
| 431 | <a name="math_toolkit.sf_beta.ibeta_inv_function.table_ibeta_inva"></a><p class="title"><b>Table 6.24. Error rates for ibeta_inva</b></p> | |
| 432 | <div class="table-contents"><table class="table" summary="Error rates for ibeta_inva"> | |
| 433 | <colgroup> | |
| 434 | <col> | |
| 435 | <col> | |
| 436 | <col> | |
| 437 | <col> | |
| 438 | <col> | |
| 439 | </colgroup> | |
| 440 | <thead><tr> | |
| 441 | <th> | |
| 442 | </th> | |
| 443 | <th> | |
| 444 | <p> | |
| 445 | Microsoft Visual C++ version 12.0<br> Win32<br> double | |
| 446 | </p> | |
| 447 | </th> | |
| 448 | <th> | |
| 449 | <p> | |
| 450 | GNU C++ version 5.1.0<br> linux<br> double | |
| 451 | </p> | |
| 452 | </th> | |
| 453 | <th> | |
| 454 | <p> | |
| 455 | GNU C++ version 5.1.0<br> linux<br> long double | |
| 456 | </p> | |
| 457 | </th> | |
| 458 | <th> | |
| 459 | <p> | |
| 460 | Sun compiler version 0x5130<br> Sun Solaris<br> long double | |
| 461 | </p> | |
| 462 | </th> | |
| 463 | </tr></thead> | |
| 464 | <tbody><tr> | |
| 465 | <td> | |
| 466 | <p> | |
| 467 | Inverse incomplete beta | |
| 468 | </p> | |
| 469 | </td> | |
| 470 | <td> | |
| 471 | <p> | |
| 472 | <span class="blue">Max = 395ε (Mean = 24.7ε)</span> | |
| 473 | </p> | |
| 474 | </td> | |
| 475 | <td> | |
| 476 | <p> | |
| 477 | <span class="blue">Max = 0.602ε (Mean = 0.0239ε)</span> | |
| 478 | </p> | |
| 479 | </td> | |
| 480 | <td> | |
| 481 | <p> | |
| 482 | <span class="blue">Max = 377ε (Mean = 25.1ε)</span> | |
| 483 | </p> | |
| 484 | </td> | |
| 485 | <td> | |
| 486 | <p> | |
| 487 | <span class="blue">Max = 438ε (Mean = 31.6ε)</span> | |
| 488 | </p> | |
| 489 | </td> | |
| 490 | </tr></tbody> | |
| 491 | </table></div> | |
| 492 | </div> | |
| 493 | <br class="table-break"><div class="table"> | |
| 494 | <a name="math_toolkit.sf_beta.ibeta_inv_function.table_ibetac_inva"></a><p class="title"><b>Table 6.25. Error rates for ibetac_inva</b></p> | |
| 495 | <div class="table-contents"><table class="table" summary="Error rates for ibetac_inva"> | |
| 496 | <colgroup> | |
| 497 | <col> | |
| 498 | <col> | |
| 499 | <col> | |
| 500 | <col> | |
| 501 | <col> | |
| 502 | </colgroup> | |
| 503 | <thead><tr> | |
| 504 | <th> | |
| 505 | </th> | |
| 506 | <th> | |
| 507 | <p> | |
| 508 | Microsoft Visual C++ version 12.0<br> Win32<br> double | |
| 509 | </p> | |
| 510 | </th> | |
| 511 | <th> | |
| 512 | <p> | |
| 513 | GNU C++ version 5.1.0<br> linux<br> double | |
| 514 | </p> | |
| 515 | </th> | |
| 516 | <th> | |
| 517 | <p> | |
| 518 | GNU C++ version 5.1.0<br> linux<br> long double | |
| 519 | </p> | |
| 520 | </th> | |
| 521 | <th> | |
| 522 | <p> | |
| 523 | Sun compiler version 0x5130<br> Sun Solaris<br> long double | |
| 524 | </p> | |
| 525 | </th> | |
| 526 | </tr></thead> | |
| 527 | <tbody><tr> | |
| 528 | <td> | |
| 529 | <p> | |
| 530 | Inverse incomplete beta | |
| 531 | </p> | |
| 532 | </td> | |
| 533 | <td> | |
| 534 | <p> | |
| 535 | <span class="blue">Max = 408ε (Mean = 27.8ε)</span> | |
| 536 | </p> | |
| 537 | </td> | |
| 538 | <td> | |
| 539 | <p> | |
| 540 | <span class="blue">Max = 0.683ε (Mean = 0.0271ε)</span> | |
| 541 | </p> | |
| 542 | </td> | |
| 543 | <td> | |
| 544 | <p> | |
| 545 | <span class="blue">Max = 382ε (Mean = 22.2ε)</span> | |
| 546 | </p> | |
| 547 | </td> | |
| 548 | <td> | |
| 549 | <p> | |
| 550 | <span class="blue">Max = 315ε (Mean = 23.7ε)</span> | |
| 551 | </p> | |
| 552 | </td> | |
| 553 | </tr></tbody> | |
| 554 | </table></div> | |
| 555 | </div> | |
| 556 | <br class="table-break"><div class="table"> | |
| 557 | <a name="math_toolkit.sf_beta.ibeta_inv_function.table_ibeta_invb"></a><p class="title"><b>Table 6.26. Error rates for ibeta_invb</b></p> | |
| 558 | <div class="table-contents"><table class="table" summary="Error rates for ibeta_invb"> | |
| 559 | <colgroup> | |
| 560 | <col> | |
| 561 | <col> | |
| 562 | <col> | |
| 563 | <col> | |
| 564 | <col> | |
| 565 | </colgroup> | |
| 566 | <thead><tr> | |
| 567 | <th> | |
| 568 | </th> | |
| 569 | <th> | |
| 570 | <p> | |
| 571 | Microsoft Visual C++ version 12.0<br> Win32<br> double | |
| 572 | </p> | |
| 573 | </th> | |
| 574 | <th> | |
| 575 | <p> | |
| 576 | GNU C++ version 5.1.0<br> linux<br> double | |
| 577 | </p> | |
| 578 | </th> | |
| 579 | <th> | |
| 580 | <p> | |
| 581 | GNU C++ version 5.1.0<br> linux<br> long double | |
| 582 | </p> | |
| 583 | </th> | |
| 584 | <th> | |
| 585 | <p> | |
| 586 | Sun compiler version 0x5130<br> Sun Solaris<br> long double | |
| 587 | </p> | |
| 588 | </th> | |
| 589 | </tr></thead> | |
| 590 | <tbody><tr> | |
| 591 | <td> | |
| 592 | <p> | |
| 593 | Inverse incomplete beta | |
| 594 | </p> | |
| 595 | </td> | |
| 596 | <td> | |
| 597 | <p> | |
| 598 | <span class="blue">Max = 409ε (Mean = 17.9ε)</span> | |
| 599 | </p> | |
| 600 | </td> | |
| 601 | <td> | |
| 602 | <p> | |
| 603 | <span class="blue">Max = 0.836ε (Mean = 0.0491ε)</span> | |
| 604 | </p> | |
| 605 | </td> | |
| 606 | <td> | |
| 607 | <p> | |
| 608 | <span class="blue">Max = 407ε (Mean = 27.2ε)</span> | |
| 609 | </p> | |
| 610 | </td> | |
| 611 | <td> | |
| 612 | <p> | |
| 613 | <span class="blue">Max = 407ε (Mean = 24.4ε)</span> | |
| 614 | </p> | |
| 615 | </td> | |
| 616 | </tr></tbody> | |
| 617 | </table></div> | |
| 618 | </div> | |
| 619 | <br class="table-break"><div class="table"> | |
| 620 | <a name="math_toolkit.sf_beta.ibeta_inv_function.table_ibetac_invb"></a><p class="title"><b>Table 6.27. Error rates for ibetac_invb</b></p> | |
| 621 | <div class="table-contents"><table class="table" summary="Error rates for ibetac_invb"> | |
| 622 | <colgroup> | |
| 623 | <col> | |
| 624 | <col> | |
| 625 | <col> | |
| 626 | <col> | |
| 627 | <col> | |
| 628 | </colgroup> | |
| 629 | <thead><tr> | |
| 630 | <th> | |
| 631 | </th> | |
| 632 | <th> | |
| 633 | <p> | |
| 634 | Microsoft Visual C++ version 12.0<br> Win32<br> double | |
| 635 | </p> | |
| 636 | </th> | |
| 637 | <th> | |
| 638 | <p> | |
| 639 | GNU C++ version 5.1.0<br> linux<br> double | |
| 640 | </p> | |
| 641 | </th> | |
| 642 | <th> | |
| 643 | <p> | |
| 644 | GNU C++ version 5.1.0<br> linux<br> long double | |
| 645 | </p> | |
| 646 | </th> | |
| 647 | <th> | |
| 648 | <p> | |
| 649 | Sun compiler version 0x5130<br> Sun Solaris<br> long double | |
| 650 | </p> | |
| 651 | </th> | |
| 652 | </tr></thead> | |
| 653 | <tbody><tr> | |
| 654 | <td> | |
| 655 | <p> | |
| 656 | Inverse incomplete beta | |
| 657 | </p> | |
| 658 | </td> | |
| 659 | <td> | |
| 660 | <p> | |
| 661 | <span class="blue">Max = 329ε (Mean = 18.2ε)</span> | |
| 662 | </p> | |
| 663 | </td> | |
| 664 | <td> | |
| 665 | <p> | |
| 666 | <span class="blue">Max = 0.724ε (Mean = 0.0303ε)</span> | |
| 667 | </p> | |
| 668 | </td> | |
| 669 | <td> | |
| 670 | <p> | |
| 671 | <span class="blue">Max = 317ε (Mean = 19.7ε)</span> | |
| 672 | </p> | |
| 673 | </td> | |
| 674 | <td> | |
| 675 | <p> | |
| 676 | <span class="blue">Max = 369ε (Mean = 21.7ε)</span> | |
| 677 | </p> | |
| 678 | </td> | |
| 679 | </tr></tbody> | |
| 680 | </table></div> | |
| 681 | </div> | |
| 682 | <br class="table-break"><h5> | |
| 683 | <a name="math_toolkit.sf_beta.ibeta_inv_function.h2"></a> | |
| 684 | <span class="phrase"><a name="math_toolkit.sf_beta.ibeta_inv_function.testing"></a></span><a class="link" href="ibeta_inv_function.html#math_toolkit.sf_beta.ibeta_inv_function.testing">Testing</a> | |
| 685 | </h5> | |
| 686 | <p> | |
| 687 | There are two sets of tests: | |
| 688 | </p> | |
| 689 | <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "> | |
| 690 | <li class="listitem"> | |
| 691 | Basic sanity checks attempt to "round-trip" from <span class="emphasis"><em>a, | |
| 692 | b</em></span> and <span class="emphasis"><em>x</em></span> to <span class="emphasis"><em>p</em></span> or | |
| 693 | <span class="emphasis"><em>q</em></span> and back again. These tests have quite generous | |
| 694 | tolerances: in general both the incomplete beta and its inverses change | |
| 695 | so rapidly, that round tripping to more than a couple of significant | |
| 696 | digits isn't possible. This is especially true when <span class="emphasis"><em>p</em></span> | |
| 697 | or <span class="emphasis"><em>q</em></span> is very near one: in this case there isn't | |
| 698 | enough "information content" in the input to the inverse function | |
| 699 | to get back where you started. | |
| 700 | </li> | |
| 701 | <li class="listitem"> | |
| 702 | Accuracy checks using high precision test values. These measure the accuracy | |
| 703 | of the result, given exact input values. | |
| 704 | </li> | |
| 705 | </ul></div> | |
| 706 | <h5> | |
| 707 | <a name="math_toolkit.sf_beta.ibeta_inv_function.h3"></a> | |
| 708 | <span class="phrase"><a name="math_toolkit.sf_beta.ibeta_inv_function.implementation_of_ibeta_inv_and_"></a></span><a class="link" href="ibeta_inv_function.html#math_toolkit.sf_beta.ibeta_inv_function.implementation_of_ibeta_inv_and_">Implementation | |
| 709 | of ibeta_inv and ibetac_inv</a> | |
| 710 | </h5> | |
| 711 | <p> | |
| 712 | These two functions share a common implementation. | |
| 713 | </p> | |
| 714 | <p> | |
| 715 | First an initial approximation to x is computed then the last few bits are | |
| 716 | cleaned up using <a href="http://en.wikipedia.org/wiki/Simple_rational_approximation" target="_top">Halley | |
| 717 | iteration</a>. The iteration limit is set to 1/2 of the number of bits | |
| 718 | in T, which by experiment is sufficient to ensure that the inverses are at | |
| 719 | least as accurate as the normal incomplete beta functions. Up to 5 iterations | |
| 720 | may be required in extreme cases, although normally only one or two are required. | |
| 721 | Further, the number of iterations required decreases with increasing <span class="emphasis"><em>a</em></span> | |
| 722 | and <span class="emphasis"><em>b</em></span> (which generally form the more important use cases). | |
| 723 | </p> | |
| 724 | <p> | |
| 725 | The initial guesses used for iteration are obtained as follows: | |
| 726 | </p> | |
| 727 | <p> | |
| 728 | Firstly recall that: | |
| 729 | </p> | |
| 730 | <p> | |
| 731 | <span class="inlinemediaobject"><img src="../../../equations/ibeta_inv5.svg"></span> | |
| 732 | </p> | |
| 733 | <p> | |
| 734 | We may wish to start from either p or q, and to calculate either x or y. | |
| 735 | In addition at any stage we can exchange a for b, p for q, and x for y if | |
| 736 | it results in a more manageable problem. | |
| 737 | </p> | |
| 738 | <p> | |
| 739 | For <code class="computeroutput"><span class="identifier">a</span><span class="special">+</span><span class="identifier">b</span> <span class="special">>=</span> <span class="number">5</span></code> the initial guess is computed using the methods | |
| 740 | described in: | |
| 741 | </p> | |
| 742 | <p> | |
| 743 | Asymptotic Inversion of the Incomplete Beta Function, by N. M. <a href="http://homepages.cwi.nl/~nicot/" target="_top">Temme</a>. | |
| 744 | Journal of Computational and Applied Mathematics 41 (1992) 145-157. | |
| 745 | </p> | |
| 746 | <p> | |
| 747 | The nearly symmetrical case (section 2 of the paper) is used for | |
| 748 | </p> | |
| 749 | <p> | |
| 750 | <span class="inlinemediaobject"><img src="../../../equations/ibeta_inv2.svg"></span> | |
| 751 | </p> | |
| 752 | <p> | |
| 753 | and involves solving the inverse error function first. The method is accurate | |
| 754 | to at least 2 decimal digits when <code class="literal">a = 5</code> rising to at least | |
| 755 | 8 digits when <code class="literal">a = 10<sup>5</sup></code>. | |
| 756 | </p> | |
| 757 | <p> | |
| 758 | The general error function case (section 3 of the paper) is used for | |
| 759 | </p> | |
| 760 | <p> | |
| 761 | <span class="inlinemediaobject"><img src="../../../equations/ibeta_inv3.svg"></span> | |
| 762 | </p> | |
| 763 | <p> | |
| 764 | and again expresses the inverse incomplete beta in terms of the inverse of | |
| 765 | the error function. The method is accurate to at least 2 decimal digits when | |
| 766 | <code class="literal">a+b = 5</code> rising to 11 digits when <code class="literal">a+b = 10<sup>5</sup></code>. | |
| 767 | However, when the result is expected to be very small, and when a+b is also | |
| 768 | small, then its accuracy tails off, in this case when p<sup>1/a</sup> < 0.0025 then | |
| 769 | it is better to use the following as an initial estimate: | |
| 770 | </p> | |
| 771 | <p> | |
| 772 | <span class="inlinemediaobject"><img src="../../../equations/ibeta_inv4.svg"></span> | |
| 773 | </p> | |
| 774 | <p> | |
| 775 | Finally the for all other cases where <code class="computeroutput"><span class="identifier">a</span><span class="special">+</span><span class="identifier">b</span> <span class="special">></span> | |
| 776 | <span class="number">5</span></code> the method of section 4 of the paper | |
| 777 | is used. This expresses the inverse incomplete beta in terms of the inverse | |
| 778 | of the incomplete gamma function, and is therefore significantly more expensive | |
| 779 | to compute than the other cases. However the method is accurate to at least | |
| 780 | 3 decimal digits when <code class="literal">a = 5</code> rising to at least 10 digits | |
| 781 | when <code class="literal">a = 10<sup>5</sup></code>. This method is limited to a > b, and | |
| 782 | therefore we need to perform an exchange a for b, p for q and x for y when | |
| 783 | this is not the case. In addition when p is close to 1 the method is inaccurate | |
| 784 | should we actually want y rather than x as output. Therefore when q is small | |
| 785 | (<code class="literal">q<sup>1/p</sup> < 10<sup>-3</sup></code>) we use: | |
| 786 | </p> | |
| 787 | <p> | |
| 788 | <span class="inlinemediaobject"><img src="../../../equations/ibeta_inv6.svg"></span> | |
| 789 | </p> | |
| 790 | <p> | |
| 791 | which is both cheaper to compute than the full method, and a more accurate | |
| 792 | estimate on q. | |
| 793 | </p> | |
| 794 | <p> | |
| 795 | When a and b are both small there is a distinct lack of information in the | |
| 796 | literature on how to proceed. I am extremely grateful to Prof Nico Temme | |
| 797 | who provided the following information with a great deal of patience and | |
| 798 | explanation on his part. Any errors that follow are entirely my own, and | |
| 799 | not Prof Temme's. | |
| 800 | </p> | |
| 801 | <p> | |
| 802 | When a and b are both less than 1, then there is a point of inflection in | |
| 803 | the incomplete beta at point <code class="computeroutput"><span class="identifier">xs</span> | |
| 804 | <span class="special">=</span> <span class="special">(</span><span class="number">1</span> <span class="special">-</span> <span class="identifier">a</span><span class="special">)</span> <span class="special">/</span> <span class="special">(</span><span class="number">2</span> <span class="special">-</span> <span class="identifier">a</span> | |
| 805 | <span class="special">-</span> <span class="identifier">b</span><span class="special">)</span></code>. Therefore if <code class="literal">p > I<sub>x</sub>(a,b)</code> | |
| 806 | we swap a for b, p for q and x for y, so that now we always look for a point | |
| 807 | x below the point of inflection <code class="computeroutput"><span class="identifier">xs</span></code>, | |
| 808 | and on a convex curve. An initial estimate for x is made with: | |
| 809 | </p> | |
| 810 | <p> | |
| 811 | <span class="inlinemediaobject"><img src="../../../equations/ibeta_inv7.svg"></span> | |
| 812 | </p> | |
| 813 | <p> | |
| 814 | which is provably below the true value for x: <a href="http://en.wikipedia.org/wiki/Newton%27s_method" target="_top">Newton | |
| 815 | iteration</a> will therefore smoothly converge on x without problems | |
| 816 | caused by overshooting etc. | |
| 817 | </p> | |
| 818 | <p> | |
| 819 | When a and b are both greater than 1, but a+b is too small to use the other | |
| 820 | methods mentioned above, we proceed as follows. Observe that there is a point | |
| 821 | of inflection in the incomplete beta at <code class="computeroutput"><span class="identifier">xs</span> | |
| 822 | <span class="special">=</span> <span class="special">(</span><span class="number">1</span> <span class="special">-</span> <span class="identifier">a</span><span class="special">)</span> <span class="special">/</span> <span class="special">(</span><span class="number">2</span> <span class="special">-</span> <span class="identifier">a</span> | |
| 823 | <span class="special">-</span> <span class="identifier">b</span><span class="special">)</span></code>. Therefore if <code class="literal">p > I<sub>x</sub>(a,b)</code> | |
| 824 | we swap a for b, p for q and x for y, so that now we always look for a point | |
| 825 | x below the point of inflection <code class="computeroutput"><span class="identifier">xs</span></code>, | |
| 826 | and on a concave curve. An initial estimate for x is made with: | |
| 827 | </p> | |
| 828 | <p> | |
| 829 | <span class="inlinemediaobject"><img src="../../../equations/ibeta_inv4.svg"></span> | |
| 830 | </p> | |
| 831 | <p> | |
| 832 | which can be improved somewhat to: | |
| 833 | </p> | |
| 834 | <p> | |
| 835 | <span class="inlinemediaobject"><img src="../../../equations/ibeta_inv1.svg"></span> | |
| 836 | </p> | |
| 837 | <p> | |
| 838 | when b and x are both small (I've used b < a and x < 0.2). This actually | |
| 839 | under-estimates x, which drops us on the wrong side of x for Newton iteration | |
| 840 | to converge monotonically. However, use of higher derivatives and Halley | |
| 841 | iteration keeps everything under control. | |
| 842 | </p> | |
| 843 | <p> | |
| 844 | The final case to be considered if when one of a and b is less than or equal | |
| 845 | to 1, and the other greater that 1. Here, if b < a we swap a for b, p | |
| 846 | for q and x for y. Now the curve of the incomplete beta is convex with no | |
| 847 | points of inflection in [0,1]. For small p, x can be estimated using | |
| 848 | </p> | |
| 849 | <p> | |
| 850 | <span class="inlinemediaobject"><img src="../../../equations/ibeta_inv4.svg"></span> | |
| 851 | </p> | |
| 852 | <p> | |
| 853 | which under-estimates x, and drops us on the right side of the true value | |
| 854 | for Newton iteration to converge monotonically. However, when p is large | |
| 855 | this can quite badly underestimate x. This is especially an issue when we | |
| 856 | really want to find y, in which case this method can be an arbitrary number | |
| 857 | of order of magnitudes out, leading to very poor convergence during iteration. | |
| 858 | </p> | |
| 859 | <p> | |
| 860 | Things can be improved by considering the incomplete beta as a distorted | |
| 861 | quarter circle, and estimating y from: | |
| 862 | </p> | |
| 863 | <p> | |
| 864 | <span class="inlinemediaobject"><img src="../../../equations/ibeta_inv8.svg"></span> | |
| 865 | </p> | |
| 866 | <p> | |
| 867 | This doesn't guarantee that we will drop in on the right side of x for monotonic | |
| 868 | convergence, but it does get us close enough that Halley iteration rapidly | |
| 869 | converges on the true value. | |
| 870 | </p> | |
| 871 | <h5> | |
| 872 | <a name="math_toolkit.sf_beta.ibeta_inv_function.h4"></a> | |
| 873 | <span class="phrase"><a name="math_toolkit.sf_beta.ibeta_inv_function.implementation_of_inverses_on_th"></a></span><a class="link" href="ibeta_inv_function.html#math_toolkit.sf_beta.ibeta_inv_function.implementation_of_inverses_on_th">Implementation | |
| 874 | of inverses on the a and b parameters</a> | |
| 875 | </h5> | |
| 876 | <p> | |
| 877 | These four functions share a common implementation. | |
| 878 | </p> | |
| 879 | <p> | |
| 880 | First an initial approximation is computed for <span class="emphasis"><em>a</em></span> or | |
| 881 | <span class="emphasis"><em>b</em></span>: where possible this uses a Cornish-Fisher expansion | |
| 882 | for the negative binomial distribution to get within around 1 of the result. | |
| 883 | However, when <span class="emphasis"><em>a</em></span> or <span class="emphasis"><em>b</em></span> are very small | |
| 884 | the Cornish Fisher expansion is not usable, in this case the initial approximation | |
| 885 | is chosen so that I<sub>x</sub>(a, b) is near the middle of the range [0,1]. | |
| 886 | </p> | |
| 887 | <p> | |
| 888 | This initial guess is then used as a starting value for a generic root finding | |
| 889 | algorithm. The algorithm converges rapidly on the root once it has been bracketed, | |
| 890 | but bracketing the root may take several iterations. A better initial approximation | |
| 891 | for <span class="emphasis"><em>a</em></span> or <span class="emphasis"><em>b</em></span> would improve these | |
| 892 | functions quite substantially: currently 10-20 incomplete beta function invocations | |
| 893 | are required to find the root. | |
| 894 | </p> | |
| 895 | </div> | |
| 896 | <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> | |
| 897 | <td align="left"></td> | |
| 898 | <td align="right"><div class="copyright-footer">Copyright © 2006-2010, 2012-2014 Nikhar Agrawal, | |
| 899 | Anton Bikineev, Paul A. Bristow, Marco Guazzone, Christopher Kormanyos, Hubert | |
| 900 | Holin, Bruno Lalande, John Maddock, Jeremy Murphy, Johan Råde, Gautam Sewani, | |
| 901 | Benjamin Sobotta, Thijs van den Berg, Daryle Walker and Xiaogang Zhang<p> | |
| 902 | Distributed under the Boost Software License, Version 1.0. (See accompanying | |
| 903 | file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) | |
| 904 | </p> | |
| 905 | </div></td> | |
| 906 | </tr></table> | |
| 907 | <hr> | |
| 908 | <div class="spirit-nav"> | |
| 909 | <a accesskey="p" href="ibeta_function.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../sf_beta.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="beta_derivative.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a> | |
| 910 | </div> | |
| 911 | </body> | |
| 912 | </html> |