libs/math/doc/html/math_toolkit/brent_minima.html

   1 <html>
   2 <head>
   3 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
   4 <title>Locating Function Minima using Brent's algorithm</title>
   5 <link rel="stylesheet" href="../math.css" type="text/css">
   6 <meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
   7 <link rel="home" href="../index.html" title="Math Toolkit 2.11.0">
   8 <link rel="up" href="../root_finding.html" title="Chapter&#160;10.&#160;Root Finding &amp; Minimization Algorithms">
   9 <link rel="prev" href="bad_roots.html" title="Examples Where Root Finding Goes Wrong">
  10 <link rel="next" href="root_comparison.html" title="Comparison of Root Finding Algorithms">
  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="bad_roots.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../root_finding.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="root_comparison.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
  24 </div>
  25 <div class="section">
  26 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
  27 <a name="math_toolkit.brent_minima"></a><a class="link" href="brent_minima.html" title="Locating Function Minima using Brent's algorithm">Locating Function Minima using
  28     Brent's algorithm</a>
  29 </h2></div></div></div>
  30 <h5>
  31 <a name="math_toolkit.brent_minima.h0"></a>
  32       <span class="phrase"><a name="math_toolkit.brent_minima.synopsis"></a></span><a class="link" href="brent_minima.html#math_toolkit.brent_minima.synopsis">Synopsis</a>
  33     </h5>
  34 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">tools</span><span class="special">/</span><span class="identifier">minima</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
  35 </pre>
  36 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">F</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
  37 <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">brent_find_minima</span><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">min</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">max</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">bits</span><span class="special">);</span>
  38
  39 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">F</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
  40 <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">brent_find_minima</span><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">min</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">max</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">bits</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">uintmax_t</span><span class="special">&amp;</span> <span class="identifier">max_iter</span><span class="special">);</span>
  41 </pre>
  42 <h5>
  43 <a name="math_toolkit.brent_minima.h1"></a>
  44       <span class="phrase"><a name="math_toolkit.brent_minima.description"></a></span><a class="link" href="brent_minima.html#math_toolkit.brent_minima.description">Description</a>
  45     </h5>
  46 <p>
  47       These two functions locate the minima of the continuous function <span class="emphasis"><em>f</em></span>
  48       using <a href="http://en.wikipedia.org/wiki/Brent%27s_method" target="_top">Brent's method</a>:
  49       specifically it uses quadratic interpolation to locate the minima, or if that
  50       fails, falls back to a <a href="http://en.wikipedia.org/wiki/Golden_section_search" target="_top">golden-section
  51       search</a>.
  52     </p>
  53 <p>
  54       <span class="bold"><strong>Parameters</strong></span>
  55     </p>
  56 <div class="variablelist">
  57 <p class="title"><b></b></p>
  58 <dl class="variablelist">
  59 <dt><span class="term">f</span></dt>
  60 <dd><p>
  61             The function to minimise: a function object (or C++ lambda) that should
  62             be smooth over the range <span class="emphasis"><em>[min, max]</em></span>, with no maxima
  63             occurring in that interval.
  64           </p></dd>
  65 <dt><span class="term">min</span></dt>
  66 <dd><p>
  67             The lower endpoint of the range in which to search for the minima.
  68           </p></dd>
  69 <dt><span class="term">max</span></dt>
  70 <dd><p>
  71             The upper endpoint of the range in which to search for the minima.
  72           </p></dd>
  73 <dt><span class="term">bits</span></dt>
  74 <dd><p>
  75             The number of bits precision to which the minima should be found.<br>
  76             Note that in principle, the minima can not be located to greater accuracy
  77             than the square root of machine epsilon (for 64-bit double, sqrt(1e-16)&#8773;1e-8),
  78             therefore the value of <span class="emphasis"><em>bits</em></span> will be ignored if it's
  79             greater than half the number of bits in the mantissa of T.
  80           </p></dd>
  81 <dt><span class="term">max_iter</span></dt>
  82 <dd><p>
  83             The maximum number of iterations to use in the algorithm, if not provided
  84             the algorithm will just keep on going until the minima is found.
  85           </p></dd>
  86 </dl>
  87 </div>
  88 <p>
  89       <span class="bold"><strong>Returns:</strong></span>
  90     </p>
  91 <p>
  92       A <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span></code> of type T containing the value of the
  93       abscissa (x) at the minima and the value of <span class="emphasis"><em>f(x)</em></span> at the
  94       minima.
  95     </p>
  96 <div class="tip"><table border="0" summary="Tip">
  97 <tr>
  98 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../../../doc/src/images/tip.png"></td>
  99 <th align="left">Tip</th>
 100 </tr>
 101 <tr><td align="left" valign="top">
 102 <p>
 103         Defining BOOST_MATH_INSTRUMENT will show some parameters, for example:
 104       </p>
 105 <pre class="programlisting"><span class="identifier">Type</span> <span class="identifier">T</span> <span class="identifier">is</span> <span class="keyword">double</span>
 106 <span class="identifier">bits</span> <span class="special">=</span> <span class="number">24</span><span class="special">,</span> <span class="identifier">maximum</span> <span class="number">26</span>
 107 <span class="identifier">tolerance</span> <span class="special">=</span> <span class="number">1.19209289550781e-007</span>
 108 <span class="identifier">seeking</span> <span class="identifier">minimum</span> <span class="identifier">in</span> <span class="identifier">range</span> <span class="identifier">min</span><span class="special">-</span><span class="number">4</span> <span class="identifier">to</span> <span class="number">1.33333333333333</span>
 109 <span class="identifier">maximum</span> <span class="identifier">iterations</span> <span class="number">18446744073709551615</span>
 110 <span class="number">10</span> <span class="identifier">iterations</span><span class="special">.</span>
 111 </pre>
 112 </td></tr>
 113 </table></div>
 114 <h5>
 115 <a name="math_toolkit.brent_minima.h2"></a>
 116       <span class="phrase"><a name="math_toolkit.brent_minima.example"></a></span><a class="link" href="brent_minima.html#math_toolkit.brent_minima.example">Brent
 117       Minimisation Example</a>
 118     </h5>
 119 <p>
 120       As a demonstration, we replicate this <a href="http://en.wikipedia.org/wiki/Brent%27s_method#Example" target="_top">Wikipedia
 121       example</a> minimising the function <span class="emphasis"><em>y= (x+3)(x-1)<sup>2</sup></em></span>.
 122     </p>
 123 <p>
 124       It is obvious from the equation and the plot that there is a minimum at exactly
 125       unity (x = 1) and the value of the function at one is exactly zero (y = 0).
 126     </p>
 127 <div class="tip"><table border="0" summary="Tip">
 128 <tr>
 129 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../../../doc/src/images/tip.png"></td>
 130 <th align="left">Tip</th>
 131 </tr>
 132 <tr><td align="left" valign="top"><p>
 133         This observation shows that an analytical or <a href="http://en.wikipedia.org/wiki/Closed-form_expression" target="_top">Closed-form
 134         expression</a> solution always beats brute-force hands-down for both
 135         speed and precision.
 136       </p></td></tr>
 137 </table></div>
 138 <div class="blockquote"><blockquote class="blockquote"><p>
 139         <span class="inlinemediaobject"><img src="../../graphs/brent_test_function_1.svg" align="middle"></span>
 140
 141       </p></blockquote></div>
 142 <p>
 143       First an include is needed:
 144     </p>
 145 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">tools</span><span class="special">/</span><span class="identifier">minima</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 146 </pre>
 147 <p>
 148       This function is encoded in C++ as function object (functor) using <code class="computeroutput"><span class="keyword">double</span></code> precision thus:
 149     </p>
 150 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">funcdouble</span>
 151 <span class="special">{</span>
 152   <span class="keyword">double</span> <span class="keyword">operator</span><span class="special">()(</span><span class="keyword">double</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span>
 153   <span class="special">{</span>
 154     <span class="keyword">return</span> <span class="special">(</span><span class="identifier">x</span> <span class="special">+</span> <span class="number">3</span><span class="special">)</span> <span class="special">*</span> <span class="special">(</span><span class="identifier">x</span> <span class="special">-</span> <span class="number">1</span><span class="special">)</span> <span class="special">*</span> <span class="special">(</span><span class="identifier">x</span> <span class="special">-</span> <span class="number">1</span><span class="special">);</span> <span class="comment">// (x + 3)(x - 1)^2</span>
 155   <span class="special">}</span>
 156 <span class="special">};</span>
 157 </pre>
 158 <p>
 159       The Brent function is conveniently accessed through a <code class="computeroutput"><span class="keyword">using</span></code>
 160       statement (noting sub-namespace <code class="computeroutput"><span class="special">::</span><span class="identifier">tools</span></code>).
 161     </p>
 162 <pre class="programlisting"><span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tools</span><span class="special">::</span><span class="identifier">brent_find_minima</span><span class="special">;</span>
 163 </pre>
 164 <p>
 165       The search minimum and maximum are chosen as -4 to 4/3 (as in the Wikipedia
 166       example).
 167     </p>
 168 <div class="tip"><table border="0" summary="Tip">
 169 <tr>
 170 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../../../doc/src/images/tip.png"></td>
 171 <th align="left">Tip</th>
 172 </tr>
 173 <tr><td align="left" valign="top"><p>
 174         S A Stage (reference 6) reports that the Brent algorithm is <span class="emphasis"><em>slow
 175         to start, but fast to converge</em></span>, so choosing a tight min-max range
 176         is good.
 177       </p></td></tr>
 178 </table></div>
 179 <p>
 180       For simplicity, we set the precision parameter <code class="computeroutput"><span class="identifier">bits</span></code>
 181       to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">digits</span></code>, which is effectively the maximum
 182       possible <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">digits</span><span class="special">/</span><span class="number">2</span></code>.
 183     </p>
 184 <p>
 185       Nor do we provide a value for maximum iterations parameter <code class="computeroutput"><span class="identifier">max_iter</span></code>,
 186       (probably unwisely), so the function will iterate until it finds a minimum.
 187     </p>
 188 <pre class="programlisting"><span class="keyword">const</span> <span class="keyword">int</span> <span class="identifier">double_bits</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">digits</span><span class="special">;</span>
 189 <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">r</span> <span class="special">=</span> <span class="identifier">brent_find_minima</span><span class="special">(</span><span class="identifier">funcdouble</span><span class="special">(),</span> <span class="special">-</span><span class="number">4.</span><span class="special">,</span> <span class="number">4.</span> <span class="special">/</span> <span class="number">3</span><span class="special">,</span> <span class="identifier">double_bits</span><span class="special">);</span>
 190
 191 <span class="identifier">std</span><span class="special">::</span><span class="identifier">streamsize</span> <span class="identifier">precision_1</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">);</span>
 192 <span class="comment">// Show all double precision decimal digits and trailing zeros.</span>
 193 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"x at minimum = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">first</span>
 194   <span class="special">&lt;&lt;</span> <span class="string">", f("</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">first</span> <span class="special">&lt;&lt;</span> <span class="string">") = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">second</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 195 </pre>
 196 <p>
 197       The resulting <a href="http://en.cppreference.com/w/cpp/utility/pair" target="_top">std::pair</a>
 198       contains the minimum close to one, and the minimum value close to zero.
 199     </p>
 200 <pre class="programlisting"><span class="identifier">x</span> <span class="identifier">at</span> <span class="identifier">minimum</span> <span class="special">=</span> <span class="number">1.00000000112345</span><span class="special">,</span>
 201 <span class="identifier">f</span><span class="special">(</span><span class="number">1.00000000112345</span><span class="special">)</span> <span class="special">=</span> <span class="number">5.04852568272458e-018</span>
 202 </pre>
 203 <p>
 204       The differences from the expected <span class="emphasis"><em>one</em></span> and <span class="emphasis"><em>zero</em></span>
 205       are less than the uncertainty, for <code class="computeroutput"><span class="keyword">double</span></code>
 206       1.5e-008, calculated from <code class="computeroutput"><span class="identifier">sqrt</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">())</span></code>.
 207     </p>
 208 <p>
 209       We can use this uncertainty to check that the two values are close-enough to
 210       those expected,
 211     </p>
 212 <pre class="programlisting"><span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">fpc</span><span class="special">::</span><span class="identifier">close_at_tolerance</span><span class="special">;</span>
 213 <span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">fpc</span><span class="special">::</span><span class="identifier">is_small</span><span class="special">;</span>
 214
 215 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"x = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">first</span> <span class="special">&lt;&lt;</span> <span class="string">", f(x) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">second</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 216 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span> <span class="special">&lt;&lt;</span> <span class="string">"x == 1 (compared to uncertainty "</span>
 217   <span class="special">&lt;&lt;</span> <span class="identifier">uncertainty</span> <span class="special">&lt;&lt;</span> <span class="string">") is "</span> <span class="special">&lt;&lt;</span> <span class="identifier">is_close</span><span class="special">(</span><span class="number">1.</span><span class="special">,</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">uncertainty</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// true</span>
 218 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span> <span class="special">&lt;&lt;</span> <span class="string">"f(x) == 0 (compared to uncertainty "</span>
 219   <span class="special">&lt;&lt;</span> <span class="identifier">uncertainty</span> <span class="special">&lt;&lt;</span> <span class="string">") is "</span> <span class="special">&lt;&lt;</span> <span class="identifier">is_close</span><span class="special">(</span><span class="number">0.</span><span class="special">,</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">second</span><span class="special">,</span> <span class="identifier">uncertainty</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// true</span>
 220 </pre>
 221 <p>
 222       that outputs
 223     </p>
 224 <pre class="programlisting"><span class="identifier">x</span> <span class="special">==</span> <span class="number">1</span> <span class="special">(</span><span class="identifier">compared</span> <span class="identifier">to</span> <span class="identifier">uncertainty</span> <span class="number">1.49011611938477e-08</span><span class="special">)</span> <span class="identifier">is</span> <span class="keyword">true</span>
 225 <span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span> <span class="special">==</span> <span class="number">0</span> <span class="special">(</span><span class="identifier">compared</span> <span class="identifier">to</span> <span class="identifier">uncertainty</span> <span class="number">1.49011611938477e-08</span><span class="special">)</span> <span class="identifier">is</span> <span class="keyword">true</span>
 226 </pre>
 227 <div class="note"><table border="0" summary="Note">
 228 <tr>
 229 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../doc/src/images/note.png"></td>
 230 <th align="left">Note</th>
 231 </tr>
 232 <tr><td align="left" valign="top"><p>
 233         The function <code class="computeroutput"><span class="identifier">close_at_tolerance</span></code>
 234         is ineffective for testing if a value is small or zero (because it may divide
 235         by small or zero and cause overflow). Function <code class="computeroutput"><span class="identifier">is_small</span></code>
 236         does this job.
 237       </p></td></tr>
 238 </table></div>
 239 <p>
 240       It is possible to make this comparison more generally with a templated function,
 241       <code class="computeroutput"><span class="identifier">is_close</span></code>, first checking <code class="computeroutput"><span class="identifier">is_small</span></code> before checking <code class="computeroutput"><span class="identifier">close_at_tolerance</span></code>,
 242       returning <code class="computeroutput"><span class="keyword">true</span></code> when small or close,
 243       for example:
 244     </p>
 245 <pre class="programlisting"><span class="comment">//! Compare if value got is close to expected,</span>
 246 <span class="comment">//! checking first if expected is very small</span>
 247 <span class="comment">//! (to avoid divide by tiny or zero during comparison)</span>
 248 <span class="comment">//! before comparing expect with value got.</span>
 249
 250 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 251 <span class="keyword">bool</span> <span class="identifier">is_close</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">expect</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">got</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">tolerance</span><span class="special">)</span>
 252 <span class="special">{</span>
 253   <span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">fpc</span><span class="special">::</span><span class="identifier">close_at_tolerance</span><span class="special">;</span>
 254   <span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">fpc</span><span class="special">::</span><span class="identifier">is_small</span><span class="special">;</span>
 255   <span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">fpc</span><span class="special">::</span><span class="identifier">FPC_STRONG</span><span class="special">;</span>
 256
 257   <span class="keyword">if</span> <span class="special">(</span><span class="identifier">is_small</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">expect</span><span class="special">,</span> <span class="identifier">tolerance</span><span class="special">))</span>
 258   <span class="special">{</span>
 259     <span class="keyword">return</span> <span class="identifier">is_small</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">got</span><span class="special">,</span> <span class="identifier">tolerance</span><span class="special">);</span>
 260   <span class="special">}</span>
 261
 262   <span class="keyword">return</span> <span class="identifier">close_at_tolerance</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">tolerance</span><span class="special">,</span> <span class="identifier">FPC_STRONG</span><span class="special">)</span> <span class="special">(</span><span class="identifier">expect</span><span class="special">,</span> <span class="identifier">got</span><span class="special">);</span>
 263 <span class="special">}</span> <span class="comment">// bool is_close(T expect, T got, T tolerance)</span>
 264 </pre>
 265 <p>
 266       In practical applications, we might want to know how many iterations, and maybe
 267       to limit iterations (in case the function proves ill-behaved), and/or perhaps
 268       to trade some loss of precision for speed, for example:
 269     </p>
 270 <pre class="programlisting"><span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">uintmax_t</span> <span class="identifier">maxit</span> <span class="special">=</span> <span class="number">20</span><span class="special">;</span>
 271 <span class="identifier">boost</span><span class="special">::</span><span class="identifier">uintmax_t</span> <span class="identifier">it</span> <span class="special">=</span> <span class="identifier">maxit</span><span class="special">;</span>
 272 <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">r</span> <span class="special">=</span> <span class="identifier">brent_find_minima</span><span class="special">(</span><span class="identifier">funcdouble</span><span class="special">(),</span> <span class="special">-</span><span class="number">4.</span><span class="special">,</span> <span class="number">4.</span> <span class="special">/</span> <span class="number">3</span><span class="special">,</span> <span class="identifier">bits</span><span class="special">,</span> <span class="identifier">it</span><span class="special">);</span>
 273 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"x at minimum = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">first</span> <span class="special">&lt;&lt;</span> <span class="string">", f("</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">first</span> <span class="special">&lt;&lt;</span> <span class="string">") = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">second</span>
 274   <span class="special">&lt;&lt;</span> <span class="string">" after "</span> <span class="special">&lt;&lt;</span> <span class="identifier">it</span> <span class="special">&lt;&lt;</span> <span class="string">" iterations. "</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 275 </pre>
 276 <p>
 277       limits to a maximum of 20 iterations (a reasonable estimate for this example
 278       function, even for much higher precision shown later).
 279     </p>
 280 <p>
 281       The parameter <code class="computeroutput"><span class="identifier">it</span></code> is updated
 282       to return the actual number of iterations (so it may be useful to also keep
 283       a record of the limit set in <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">maxit</span></code>).
 284     </p>
 285 <p>
 286       It is neat to avoid showing insignificant digits by computing the number of
 287       decimal digits to display.
 288     </p>
 289 <pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">streamsize</span> <span class="identifier">prec</span> <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="number">2</span> <span class="special">+</span> <span class="identifier">sqrt</span><span class="special">((</span><span class="keyword">double</span><span class="special">)</span><span class="identifier">bits</span><span class="special">));</span>  <span class="comment">// Number of significant decimal digits.</span>
 290 <span class="identifier">std</span><span class="special">::</span><span class="identifier">streamsize</span> <span class="identifier">precision_3</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">prec</span><span class="special">);</span> <span class="comment">// Save and set new precision.</span>
 291 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Showing "</span> <span class="special">&lt;&lt;</span> <span class="identifier">bits</span> <span class="special">&lt;&lt;</span> <span class="string">" bits "</span>
 292   <span class="string">"precision with "</span> <span class="special">&lt;&lt;</span> <span class="identifier">prec</span>
 293   <span class="special">&lt;&lt;</span> <span class="string">" decimal digits from tolerance "</span> <span class="special">&lt;&lt;</span> <span class="identifier">sqrt</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">())</span>
 294   <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 295
 296 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"x at minimum = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">first</span>
 297   <span class="special">&lt;&lt;</span> <span class="string">", f("</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">first</span> <span class="special">&lt;&lt;</span> <span class="string">") = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">second</span>
 298   <span class="special">&lt;&lt;</span> <span class="string">" after "</span> <span class="special">&lt;&lt;</span> <span class="identifier">it</span> <span class="special">&lt;&lt;</span> <span class="string">" iterations. "</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 299 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">precision_3</span><span class="special">);</span> <span class="comment">// Restore.</span>
 300 </pre>
 301 <pre class="programlisting"><span class="identifier">Showing</span> <span class="number">53</span> <span class="identifier">bits</span> <span class="identifier">precision</span> <span class="identifier">with</span> <span class="number">9</span> <span class="identifier">decimal</span> <span class="identifier">digits</span> <span class="identifier">from</span> <span class="identifier">tolerance</span> <span class="number">1.49011611938477e-008</span>
 302 <span class="identifier">x</span> <span class="identifier">at</span> <span class="identifier">minimum</span> <span class="special">=</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">f</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">=</span> <span class="number">5.04852568e-018</span>
 303 </pre>
 304 <p>
 305       We can also half the number of precision bits from 52 to 26:
 306     </p>
 307 <pre class="programlisting"><span class="keyword">const</span> <span class="keyword">int</span> <span class="identifier">bits_div_2</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">digits</span> <span class="special">/</span> <span class="number">2</span><span class="special">;</span> <span class="comment">// Half digits precision (effective maximum).</span>
 308 <span class="keyword">double</span> <span class="identifier">epsilon_2</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">pow</span><span class="special">&lt;-(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">digits</span><span class="special">/</span><span class="number">2</span> <span class="special">-</span> <span class="number">1</span><span class="special">),</span> <span class="keyword">double</span><span class="special">&gt;(</span><span class="number">2</span><span class="special">);</span>
 309 <span class="identifier">std</span><span class="special">::</span><span class="identifier">streamsize</span> <span class="identifier">prec</span> <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="number">2</span> <span class="special">+</span> <span class="identifier">sqrt</span><span class="special">((</span><span class="keyword">double</span><span class="special">)</span><span class="identifier">bits_div_2</span><span class="special">));</span>  <span class="comment">// Number of significant decimal digits.</span>
 310
 311 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Showing "</span> <span class="special">&lt;&lt;</span> <span class="identifier">bits_div_2</span> <span class="special">&lt;&lt;</span> <span class="string">" bits precision with "</span> <span class="special">&lt;&lt;</span> <span class="identifier">prec</span>
 312   <span class="special">&lt;&lt;</span> <span class="string">" decimal digits from tolerance "</span> <span class="special">&lt;&lt;</span> <span class="identifier">sqrt</span><span class="special">(</span><span class="identifier">epsilon_2</span><span class="special">)</span>
 313   <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 314 <span class="identifier">std</span><span class="special">::</span><span class="identifier">streamsize</span> <span class="identifier">precision_4</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">prec</span><span class="special">);</span> <span class="comment">// Save.</span>
 315 <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">uintmax_t</span> <span class="identifier">maxit</span> <span class="special">=</span> <span class="number">20</span><span class="special">;</span>
 316 <span class="identifier">boost</span><span class="special">::</span><span class="identifier">uintmax_t</span> <span class="identifier">it_4</span> <span class="special">=</span> <span class="identifier">maxit</span><span class="special">;</span>
 317 <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">r</span> <span class="special">=</span> <span class="identifier">brent_find_minima</span><span class="special">(</span><span class="identifier">funcdouble</span><span class="special">(),</span> <span class="special">-</span><span class="number">4.</span><span class="special">,</span> <span class="number">4.</span> <span class="special">/</span> <span class="number">3</span><span class="special">,</span> <span class="identifier">bits_div_2</span><span class="special">,</span> <span class="identifier">it_4</span><span class="special">);</span>
 318 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"x at minimum = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">first</span> <span class="special">&lt;&lt;</span> <span class="string">", f("</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">first</span> <span class="special">&lt;&lt;</span> <span class="string">") = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">second</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 319 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">it_4</span> <span class="special">&lt;&lt;</span> <span class="string">" iterations. "</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 320 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">precision_4</span><span class="special">);</span> <span class="comment">// Restore.</span>
 321 </pre>
 322 <p>
 323       showing no change in the result and no change in the number of iterations,
 324       as expected.
 325     </p>
 326 <p>
 327       It is only if we reduce the precision to a quarter, specifying only 13 precision
 328       bits
 329     </p>
 330 <pre class="programlisting"><span class="keyword">const</span> <span class="keyword">int</span> <span class="identifier">bits_div_4</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">digits</span> <span class="special">/</span> <span class="number">4</span><span class="special">;</span> <span class="comment">// Quarter precision.</span>
 331 <span class="keyword">double</span> <span class="identifier">epsilon_4</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">pow</span><span class="special">&lt;-(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">digits</span> <span class="special">/</span> <span class="number">4</span> <span class="special">-</span> <span class="number">1</span><span class="special">),</span> <span class="keyword">double</span><span class="special">&gt;(</span><span class="number">2</span><span class="special">);</span>
 332 <span class="identifier">std</span><span class="special">::</span><span class="identifier">streamsize</span> <span class="identifier">prec</span> <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="number">2</span> <span class="special">+</span> <span class="identifier">sqrt</span><span class="special">((</span><span class="keyword">double</span><span class="special">)</span><span class="identifier">bits_div_4</span><span class="special">));</span>  <span class="comment">// Number of significant decimal digits.</span>
 333 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Showing "</span> <span class="special">&lt;&lt;</span> <span class="identifier">bits_div_4</span> <span class="special">&lt;&lt;</span> <span class="string">" bits precision with "</span> <span class="special">&lt;&lt;</span> <span class="identifier">prec</span>
 334   <span class="special">&lt;&lt;</span> <span class="string">" decimal digits from tolerance "</span> <span class="special">&lt;&lt;</span> <span class="identifier">sqrt</span><span class="special">(</span><span class="identifier">epsilon_4</span><span class="special">)</span>
 335   <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 336 <span class="identifier">std</span><span class="special">::</span><span class="identifier">streamsize</span> <span class="identifier">precision_5</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">prec</span><span class="special">);</span> <span class="comment">// Save &amp; set.</span>
 337 <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">uintmax_t</span> <span class="identifier">maxit</span> <span class="special">=</span> <span class="number">20</span><span class="special">;</span>
 338
 339 <span class="identifier">boost</span><span class="special">::</span><span class="identifier">uintmax_t</span> <span class="identifier">it_5</span> <span class="special">=</span> <span class="identifier">maxit</span><span class="special">;</span>
 340 <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">r</span> <span class="special">=</span> <span class="identifier">brent_find_minima</span><span class="special">(</span><span class="identifier">funcdouble</span><span class="special">(),</span> <span class="special">-</span><span class="number">4.</span><span class="special">,</span> <span class="number">4.</span> <span class="special">/</span> <span class="number">3</span><span class="special">,</span> <span class="identifier">bits_div_4</span><span class="special">,</span> <span class="identifier">it_5</span><span class="special">);</span>
 341 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"x at minimum = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">first</span> <span class="special">&lt;&lt;</span> <span class="string">", f("</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">first</span> <span class="special">&lt;&lt;</span> <span class="string">") = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">second</span>
 342 <span class="special">&lt;&lt;</span> <span class="string">", after "</span> <span class="special">&lt;&lt;</span> <span class="identifier">it_5</span> <span class="special">&lt;&lt;</span> <span class="string">" iterations. "</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 343 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">precision_5</span><span class="special">);</span> <span class="comment">// Restore.</span>
 344 </pre>
 345 <p>
 346       that we reduce the number of iterations from 10 to 7 that the result slightly
 347       differs from <span class="emphasis"><em>one</em></span> and <span class="emphasis"><em>zero</em></span>.
 348     </p>
 349 <pre class="programlisting"><span class="identifier">Showing</span> <span class="number">13</span> <span class="identifier">bits</span> <span class="identifier">precision</span> <span class="identifier">with</span> <span class="number">9</span> <span class="identifier">decimal</span> <span class="identifier">digits</span> <span class="identifier">from</span> <span class="identifier">tolerance</span> <span class="number">0.015625</span>
 350 <span class="identifier">x</span> <span class="identifier">at</span> <span class="identifier">minimum</span> <span class="special">=</span> <span class="number">0.9999776</span><span class="special">,</span> <span class="identifier">f</span><span class="special">(</span><span class="number">0.9999776</span><span class="special">)</span> <span class="special">=</span> <span class="number">2.0069572e-009</span> <span class="identifier">after</span> <span class="number">7</span> <span class="identifier">iterations</span><span class="special">.</span>
 351 </pre>
 352 <h6>
 353 <a name="math_toolkit.brent_minima.h3"></a>
 354       <span class="phrase"><a name="math_toolkit.brent_minima.template"></a></span><a class="link" href="brent_minima.html#math_toolkit.brent_minima.template">Templating
 355       on floating-point type</a>
 356     </h6>
 357 <p>
 358       If we want to switch the floating-point type, then the functor must be revised.
 359       Since the functor is stateless, the easiest option is to simply make <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code> a
 360       template member function:
 361     </p>
 362 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">func</span>
 363 <span class="special">{</span>
 364   <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 365   <span class="identifier">T</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span>
 366   <span class="special">{</span>
 367     <span class="keyword">return</span> <span class="special">(</span><span class="identifier">x</span> <span class="special">+</span> <span class="number">3</span><span class="special">)</span> <span class="special">*</span> <span class="special">(</span><span class="identifier">x</span> <span class="special">-</span> <span class="number">1</span><span class="special">)</span> <span class="special">*</span> <span class="special">(</span><span class="identifier">x</span> <span class="special">-</span> <span class="number">1</span><span class="special">);</span> <span class="comment">// (x + 3)(x - 1)^2</span>
 368   <span class="special">}</span>
 369 <span class="special">};</span>
 370 </pre>
 371 <p>
 372       The <code class="computeroutput"><span class="identifier">brent_find_minima</span></code> function
 373       can now be used in template form, for example using <code class="computeroutput"><span class="keyword">long</span>
 374       <span class="keyword">double</span></code>:
 375     </p>
 376 <pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">streamsize</span> <span class="identifier">precision_t1</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">);</span> <span class="comment">// Save &amp; set.</span>
 377 <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">bracket_min</span> <span class="special">=</span> <span class="special">-</span><span class="number">4.</span><span class="special">;</span>
 378 <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">bracket_max</span> <span class="special">=</span> <span class="number">4.</span> <span class="special">/</span> <span class="number">3</span><span class="special">;</span>
 379 <span class="keyword">const</span> <span class="keyword">int</span> <span class="identifier">bits</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">digits</span><span class="special">;</span>
 380 <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">uintmax_t</span> <span class="identifier">maxit</span> <span class="special">=</span> <span class="number">20</span><span class="special">;</span>
 381 <span class="identifier">boost</span><span class="special">::</span><span class="identifier">uintmax_t</span> <span class="identifier">it</span> <span class="special">=</span> <span class="identifier">maxit</span><span class="special">;</span>
 382
 383 <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">r</span> <span class="special">=</span> <span class="identifier">brent_find_minima</span><span class="special">(</span><span class="identifier">func</span><span class="special">(),</span> <span class="identifier">bracket_min</span><span class="special">,</span> <span class="identifier">bracket_max</span><span class="special">,</span> <span class="identifier">bits</span><span class="special">,</span> <span class="identifier">it</span><span class="special">);</span>
 384 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"x at minimum = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">first</span> <span class="special">&lt;&lt;</span> <span class="string">", f("</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">first</span> <span class="special">&lt;&lt;</span> <span class="string">") = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">second</span>
 385   <span class="special">&lt;&lt;</span> <span class="string">", after "</span> <span class="special">&lt;&lt;</span> <span class="identifier">it</span> <span class="special">&lt;&lt;</span> <span class="string">" iterations. "</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 386 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">precision_t1</span><span class="special">);</span>  <span class="comment">// Restore.</span>
 387 </pre>
 388 <p>
 389       The form shown uses the floating-point type <code class="computeroutput"><span class="keyword">long</span>
 390       <span class="keyword">double</span></code> by deduction, but it is also
 391       possible to be more explicit, for example:
 392     </p>
 393 <pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">r</span> <span class="special">=</span> <span class="identifier">brent_find_minima</span><span class="special">&lt;</span><span class="identifier">func</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span><span class="special">&gt;</span>
 394 <span class="special">(</span><span class="identifier">func</span><span class="special">(),</span> <span class="identifier">bracket_min</span><span class="special">,</span> <span class="identifier">bracket_max</span><span class="special">,</span> <span class="identifier">bits</span><span class="special">,</span> <span class="identifier">it</span><span class="special">);</span>
 395 </pre>
 396 <p>
 397       In order to show the use of multiprecision below (or other user-defined types),
 398       it may be convenient to write a templated function to use this:
 399     </p>
 400 <pre class="programlisting"><span class="comment">//! Example template function to find and show minima.</span>
 401 <span class="comment">//! \tparam T floating-point or fixed_point type.</span>
 402 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 403 <span class="keyword">void</span> <span class="identifier">show_minima</span><span class="special">()</span>
 404 <span class="special">{</span>
 405   <span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tools</span><span class="special">::</span><span class="identifier">brent_find_minima</span><span class="special">;</span>
 406   <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">sqrt</span><span class="special">;</span>
 407   <span class="keyword">try</span>
 408   <span class="special">{</span> <span class="comment">// Always use try'n'catch blocks with Boost.Math to ensure you get any error messages.</span>
 409
 410     <span class="keyword">int</span> <span class="identifier">bits</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">digits</span><span class="special">/</span><span class="number">2</span><span class="special">;</span> <span class="comment">// Maximum is digits/2;</span>
 411     <span class="identifier">std</span><span class="special">::</span><span class="identifier">streamsize</span> <span class="identifier">prec</span> <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="number">2</span> <span class="special">+</span> <span class="identifier">sqrt</span><span class="special">((</span><span class="keyword">double</span><span class="special">)</span><span class="identifier">bits</span><span class="special">));</span>  <span class="comment">// Number of significant decimal digits.</span>
 412     <span class="identifier">std</span><span class="special">::</span><span class="identifier">streamsize</span> <span class="identifier">precision</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">prec</span><span class="special">);</span> <span class="comment">// Save and set.</span>
 413
 414     <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"\n\nFor type: "</span> <span class="special">&lt;&lt;</span> <span class="keyword">typeid</span><span class="special">(</span><span class="identifier">T</span><span class="special">).</span><span class="identifier">name</span><span class="special">()</span>
 415       <span class="special">&lt;&lt;</span> <span class="string">",\n  epsilon = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">()</span>
 416       <span class="comment">// &lt;&lt; ", precision of " &lt;&lt; bits &lt;&lt; " bits"</span>
 417       <span class="special">&lt;&lt;</span> <span class="string">",\n  the maximum theoretical precision from Brent's minimization is "</span>
 418       <span class="special">&lt;&lt;</span> <span class="identifier">sqrt</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">())</span>
 419       <span class="special">&lt;&lt;</span> <span class="string">"\n  Displaying to std::numeric_limits&lt;T&gt;::digits10 "</span> <span class="special">&lt;&lt;</span> <span class="identifier">prec</span> <span class="special">&lt;&lt;</span> <span class="string">", significant decimal digits."</span>
 420       <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 421
 422     <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">uintmax_t</span> <span class="identifier">maxit</span> <span class="special">=</span> <span class="number">20</span><span class="special">;</span>
 423     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">uintmax_t</span> <span class="identifier">it</span> <span class="special">=</span> <span class="identifier">maxit</span><span class="special">;</span>
 424     <span class="comment">// Construct using string, not double, avoids loss of precision.</span>
 425     <span class="comment">//T bracket_min = static_cast&lt;T&gt;("-4");</span>
 426     <span class="comment">//T bracket_max = static_cast&lt;T&gt;("1.3333333333333333333333333333333333333333333333333");</span>
 427
 428     <span class="comment">// Construction from double may cause loss of precision for multiprecision types like cpp_bin_float,</span>
 429     <span class="comment">// but brackets values are good enough for using Brent minimization.</span>
 430     <span class="identifier">T</span> <span class="identifier">bracket_min</span> <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(-</span><span class="number">4</span><span class="special">);</span>
 431     <span class="identifier">T</span> <span class="identifier">bracket_max</span> <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="number">1.3333333333333333333333333333333333333333333333333</span><span class="special">);</span>
 432
 433     <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">r</span> <span class="special">=</span> <span class="identifier">brent_find_minima</span><span class="special">&lt;</span><span class="identifier">func</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">func</span><span class="special">(),</span> <span class="identifier">bracket_min</span><span class="special">,</span> <span class="identifier">bracket_max</span><span class="special">,</span> <span class="identifier">bits</span><span class="special">,</span> <span class="identifier">it</span><span class="special">);</span>
 434
 435     <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"  x at minimum = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">first</span> <span class="special">&lt;&lt;</span> <span class="string">", f("</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">first</span> <span class="special">&lt;&lt;</span> <span class="string">") = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">second</span><span class="special">;</span>
 436     <span class="keyword">if</span> <span class="special">(</span><span class="identifier">it</span> <span class="special">&lt;</span> <span class="identifier">maxit</span><span class="special">)</span>
 437     <span class="special">{</span>
 438       <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">",\n  met "</span> <span class="special">&lt;&lt;</span> <span class="identifier">bits</span> <span class="special">&lt;&lt;</span> <span class="string">" bits precision"</span> <span class="special">&lt;&lt;</span> <span class="string">", after "</span> <span class="special">&lt;&lt;</span> <span class="identifier">it</span> <span class="special">&lt;&lt;</span> <span class="string">" iterations."</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 439     <span class="special">}</span>
 440     <span class="keyword">else</span>
 441     <span class="special">{</span>
 442       <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">",\n  did NOT meet "</span> <span class="special">&lt;&lt;</span> <span class="identifier">bits</span> <span class="special">&lt;&lt;</span> <span class="string">" bits precision"</span> <span class="special">&lt;&lt;</span> <span class="string">" after "</span> <span class="special">&lt;&lt;</span> <span class="identifier">it</span> <span class="special">&lt;&lt;</span> <span class="string">" iterations!"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 443     <span class="special">}</span>
 444     <span class="comment">// Check that result is that expected (compared to theoretical uncertainty).</span>
 445     <span class="identifier">T</span> <span class="identifier">uncertainty</span> <span class="special">=</span> <span class="identifier">sqrt</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">());</span>
 446     <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span> <span class="special">&lt;&lt;</span> <span class="string">"x == 1 (compared to uncertainty "</span> <span class="special">&lt;&lt;</span> <span class="identifier">uncertainty</span> <span class="special">&lt;&lt;</span> <span class="string">") is "</span>
 447       <span class="special">&lt;&lt;</span> <span class="identifier">is_close</span><span class="special">(</span><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="number">1</span><span class="special">),</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">uncertainty</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 448     <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span> <span class="special">&lt;&lt;</span> <span class="string">"f(x) == (0 compared to uncertainty "</span> <span class="special">&lt;&lt;</span> <span class="identifier">uncertainty</span> <span class="special">&lt;&lt;</span> <span class="string">") is "</span>
 449       <span class="special">&lt;&lt;</span> <span class="identifier">is_close</span><span class="special">(</span><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="number">0</span><span class="special">),</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">second</span><span class="special">,</span> <span class="identifier">uncertainty</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 450     <span class="comment">// Problems with this using multiprecision with expression template on?</span>
 451     <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">precision</span><span class="special">);</span>  <span class="comment">// Restore.</span>
 452   <span class="special">}</span>
 453   <span class="keyword">catch</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">exception</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">)</span>
 454   <span class="special">{</span> <span class="comment">// Always useful to include try &amp; catch blocks because default policies</span>
 455     <span class="comment">// are to throw exceptions on arguments that cause errors like underflow, overflow.</span>
 456     <span class="comment">// Lacking try &amp; catch blocks, the program will abort without a message below,</span>
 457     <span class="comment">// which may give some helpful clues as to the cause of the exception.</span>
 458     <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span>
 459       <span class="string">"\n"</span><span class="string">"Message from thrown exception was:\n   "</span> <span class="special">&lt;&lt;</span> <span class="identifier">e</span><span class="special">.</span><span class="identifier">what</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 460   <span class="special">}</span>
 461 <span class="special">}</span> <span class="comment">// void show_minima()</span>
 462 </pre>
 463 <div class="note"><table border="0" summary="Note">
 464 <tr>
 465 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../doc/src/images/note.png"></td>
 466 <th align="left">Note</th>
 467 </tr>
 468 <tr><td align="left" valign="top"><p>
 469         the prudent addition of <code class="computeroutput"><span class="keyword">try</span><span class="char">'n'</span><span class="keyword">catch</span></code> blocks
 470         within the function. This ensures that any malfunction will provide a Boost.Math
 471         error message rather than uncommunicatively calling <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">abort</span></code>.
 472       </p></td></tr>
 473 </table></div>
 474 <p>
 475       We can use this with all built-in floating-point types, for example
 476     </p>
 477 <pre class="programlisting"><span class="identifier">show_minima</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&gt;();</span>
 478 <span class="identifier">show_minima</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;();</span>
 479 <span class="identifier">show_minima</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="keyword">double</span><span class="special">&gt;();</span>
 480 </pre>
 481 <h6>
 482 <a name="math_toolkit.brent_minima.h4"></a>
 483       <span class="phrase"><a name="math_toolkit.brent_minima.quad_precision"></a></span><a class="link" href="brent_minima.html#math_toolkit.brent_minima.quad_precision">Quad
 484       128-bit precision</a>
 485     </h6>
 486 <p>
 487       On platforms that provide it, a <a href="http://en.wikipedia.org/wiki/Quadruple-precision_floating-point_format" target="_top">128-bit
 488       quad</a> type can be used. (See <a href="../../../../../libs/multiprecision/doc/html/boost_multiprecision/tut/floats/float128.html" target="_top">float128</a>).
 489     </p>
 490 <p>
 491       If this type is available, the build should define the macro BOOST_HAVE_QUADMATH:
 492     </p>
 493 <pre class="programlisting"><span class="preprocessor">#ifdef</span> <span class="identifier">BOOST_HAVE_QUADMATH</span>  <span class="comment">// Defined only if GCC or Intel and have quadmath.lib or .dll library available.</span>
 494   <span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">float128</span><span class="special">;</span>
 495 <span class="preprocessor">#endif</span>
 496 </pre>
 497 <p>
 498       and can be (conditionally) used this:
 499     </p>
 500 <pre class="programlisting"><span class="preprocessor">#ifdef</span> <span class="identifier">BOOST_HAVE_QUADMATH</span>  <span class="comment">// Defined only if GCC or Intel and have quadmath.lib or .dll library available.</span>
 501   <span class="identifier">show_minima</span><span class="special">&lt;</span><span class="identifier">float128</span><span class="special">&gt;();</span> <span class="comment">// Needs quadmath_snprintf, sqrtQ, fabsq that are in in quadmath library.</span>
 502 <span class="preprocessor">#endif</span>
 503 </pre>
 504 <h6>
 505 <a name="math_toolkit.brent_minima.h5"></a>
 506       <span class="phrase"><a name="math_toolkit.brent_minima.multiprecision"></a></span><a class="link" href="brent_minima.html#math_toolkit.brent_minima.multiprecision">Multiprecision</a>
 507     </h6>
 508 <p>
 509       If a higher precision than <code class="computeroutput"><span class="keyword">double</span></code>
 510       (or <code class="computeroutput"><span class="keyword">long</span> <span class="keyword">double</span></code>
 511       if that is more precise) is required, then this is easily achieved using <a href="../../../../../libs/multiprecision/doc/html/index.html" target="_top">Boost.Multiprecision</a>
 512       with some includes, for example:
 513     </p>
 514 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_dec_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span> <span class="comment">// For decimal boost::multiprecision::cpp_dec_float_50.</span>
 515 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_bin_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span> <span class="comment">// For binary boost::multiprecision::cpp_bin_float_50;</span>
 516 </pre>
 517 <p>
 518       and some <code class="computeroutput"><span class="identifier">typdef</span></code>s.
 519     </p>
 520 <pre class="programlisting"><span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_bin_float_50</span><span class="special">;</span> <span class="comment">// binary multiprecision typedef.</span>
 521 <span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_dec_float_50</span><span class="special">;</span> <span class="comment">// decimal multiprecision typedef.</span>
 522
 523 <span class="comment">// One might also need typedefs like these to switch expression templates off and on (default is on).</span>
 524 <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;,</span>
 525   <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">et_on</span><span class="special">&gt;</span>
 526   <span class="identifier">cpp_bin_float_50_et_on</span><span class="special">;</span>  <span class="comment">// et_on is default so is same as cpp_bin_float_50.</span>
 527
 528 <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;,</span>
 529   <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">et_off</span><span class="special">&gt;</span>
 530   <span class="identifier">cpp_bin_float_50_et_off</span><span class="special">;</span>
 531
 532 <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_dec_float</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;,</span>
 533   <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">et_on</span><span class="special">&gt;</span> <span class="comment">// et_on is default so is same as cpp_dec_float_50.</span>
 534   <span class="identifier">cpp_dec_float_50_et_on</span><span class="special">;</span>
 535
 536 <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_dec_float</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;,</span>
 537   <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">et_off</span><span class="special">&gt;</span>
 538   <span class="identifier">cpp_dec_float_50_et_off</span><span class="special">;</span>
 539 </pre>
 540 <p>
 541       Used thus
 542     </p>
 543 <pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_50</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">);</span>
 544 <span class="keyword">int</span> <span class="identifier">bits</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_50</span><span class="special">&gt;::</span><span class="identifier">digits</span> <span class="special">/</span> <span class="number">2</span> <span class="special">-</span> <span class="number">2</span><span class="special">;</span>
 545 <span class="identifier">cpp_bin_float_50</span> <span class="identifier">bracket_min</span> <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_50</span><span class="special">&gt;(</span><span class="string">"-4"</span><span class="special">);</span>
 546 <span class="identifier">cpp_bin_float_50</span> <span class="identifier">bracket_max</span> <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_50</span><span class="special">&gt;(</span><span class="string">"1.3333333333333333333333333333333333333333333333333"</span><span class="special">);</span>
 547
 548 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Bracketing "</span> <span class="special">&lt;&lt;</span> <span class="identifier">bracket_min</span> <span class="special">&lt;&lt;</span> <span class="string">" to "</span> <span class="special">&lt;&lt;</span> <span class="identifier">bracket_max</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 549 <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">uintmax_t</span> <span class="identifier">maxit</span> <span class="special">=</span> <span class="number">20</span><span class="special">;</span>
 550 <span class="identifier">boost</span><span class="special">::</span><span class="identifier">uintmax_t</span> <span class="identifier">it</span> <span class="special">=</span> <span class="identifier">maxit</span><span class="special">;</span> <span class="comment">// Will be updated with actual iteration count.</span>
 551 <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_50</span><span class="special">,</span> <span class="identifier">cpp_bin_float_50</span><span class="special">&gt;</span> <span class="identifier">r</span>
 552   <span class="special">=</span> <span class="identifier">brent_find_minima</span><span class="special">(</span><span class="identifier">func</span><span class="special">(),</span> <span class="identifier">bracket_min</span><span class="special">,</span> <span class="identifier">bracket_max</span><span class="special">,</span> <span class="identifier">bits</span><span class="special">,</span> <span class="identifier">it</span><span class="special">);</span>
 553
 554 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"x at minimum = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">first</span> <span class="special">&lt;&lt;</span> <span class="string">",\n f("</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">first</span> <span class="special">&lt;&lt;</span> <span class="string">") = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">second</span>
 555 <span class="comment">// x at minimum = 1, f(1) = 5.04853e-018</span>
 556   <span class="special">&lt;&lt;</span> <span class="string">", after "</span> <span class="special">&lt;&lt;</span> <span class="identifier">it</span> <span class="special">&lt;&lt;</span> <span class="string">" iterations. "</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 557
 558 <span class="identifier">is_close_to</span><span class="special">(</span><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_50</span><span class="special">&gt;(</span><span class="string">"1"</span><span class="special">),</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">sqrt</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_50</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">()));</span>
 559 <span class="identifier">is_close_to</span><span class="special">(</span><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_50</span><span class="special">&gt;(</span><span class="string">"0"</span><span class="special">),</span> <span class="identifier">r</span><span class="special">.</span><span class="identifier">second</span><span class="special">,</span> <span class="identifier">sqrt</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_50</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">()));</span>
 560 </pre>
 561 <p>
 562       and with our <code class="computeroutput"><span class="identifier">show_minima</span></code> function
 563     </p>
 564 <pre class="programlisting"><span class="identifier">show_minima</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_50_et_on</span><span class="special">&gt;();</span> <span class="comment">//</span>
 565 </pre>
 566 <pre class="programlisting"><span class="identifier">For</span> <span class="identifier">type</span>  <span class="keyword">class</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">number</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">backends</span><span class="special">::</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">50</span><span class="special">,</span><span class="number">10</span><span class="special">,</span><span class="keyword">void</span><span class="special">,</span><span class="keyword">int</span><span class="special">,</span><span class="number">0</span><span class="special">,</span><span class="number">0</span><span class="special">&gt;,</span><span class="number">1</span><span class="special">&gt;,</span>
 567 <span class="identifier">epsilon</span> <span class="special">=</span> <span class="number">5.3455294202e-51</span><span class="special">,</span>
 568 <span class="identifier">the</span> <span class="identifier">maximum</span> <span class="identifier">theoretical</span> <span class="identifier">precision</span> <span class="identifier">from</span> <span class="identifier">Brent</span> <span class="identifier">minimization</span> <span class="identifier">is</span> <span class="number">7.311312755e-26</span>
 569 <span class="identifier">Displaying</span> <span class="identifier">to</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">digits10</span> <span class="number">11</span> <span class="identifier">significant</span> <span class="identifier">decimal</span> <span class="identifier">digits</span><span class="special">.</span>
 570 <span class="identifier">x</span> <span class="identifier">at</span> <span class="identifier">minimum</span> <span class="special">=</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">f</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">=</span> <span class="number">5.6273022713e-58</span><span class="special">,</span>
 571 <span class="identifier">met</span> <span class="number">84</span> <span class="identifier">bits</span> <span class="identifier">precision</span><span class="special">,</span> <span class="identifier">after</span> <span class="number">14</span> <span class="identifier">iterations</span><span class="special">.</span>
 572 <span class="identifier">x</span> <span class="special">==</span> <span class="number">1</span> <span class="special">(</span><span class="identifier">compared</span> <span class="identifier">to</span> <span class="identifier">uncertainty</span> <span class="number">7.311312755e-26</span><span class="special">)</span> <span class="identifier">is</span> <span class="keyword">true</span>
 573 <span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span> <span class="special">==</span> <span class="special">(</span><span class="number">0</span> <span class="identifier">compared</span> <span class="identifier">to</span> <span class="identifier">uncertainty</span> <span class="number">7.311312755e-26</span><span class="special">)</span> <span class="identifier">is</span> <span class="keyword">true</span>
 574 <span class="special">-</span><span class="number">4</span> <span class="number">1.3333333333333333333333333333333333333333333333333</span>
 575 <span class="identifier">x</span> <span class="identifier">at</span> <span class="identifier">minimum</span> <span class="special">=</span> <span class="number">0.99999999999999999999999999998813903221565569205253</span><span class="special">,</span>
 576 <span class="identifier">f</span><span class="special">(</span><span class="number">0.99999999999999999999999999998813903221565569205253</span><span class="special">)</span> <span class="special">=</span>
 577   <span class="number">5.6273022712501408640665300316078046703496236636624e-58</span>
 578 <span class="number">14</span> <span class="identifier">iterations</span>
 579 </pre>
 580 <pre class="programlisting"><span class="identifier">For</span> <span class="identifier">type</span>  <span class="keyword">class</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">number</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">backends</span><span class="special">::</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">50</span><span class="special">,</span> <span class="number">10</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">&gt;,</span> <span class="number">1</span><span class="special">&gt;,</span>
 581 </pre>
 582 <div class="tip"><table border="0" summary="Tip">
 583 <tr>
 584 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../../../doc/src/images/tip.png"></td>
 585 <th align="left">Tip</th>
 586 </tr>
 587 <tr><td align="left" valign="top"><p>
 588         One can usually rely on template argument deduction to avoid specifying the
 589         verbose multiprecision types, but great care in needed with the <span class="emphasis"><em>type
 590         of the values</em></span> provided to avoid confusing the compiler.
 591       </p></td></tr>
 592 </table></div>
 593 <div class="tip"><table border="0" summary="Tip">
 594 <tr>
 595 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../../../doc/src/images/tip.png"></td>
 596 <th align="left">Tip</th>
 597 </tr>
 598 <tr><td align="left" valign="top"><p>
 599         Using <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">);</span></code>
 600         or <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">);</span></code>
 601         during debugging may be wise because it gives some warning if construction
 602         of multiprecision values involves unintended conversion from <code class="computeroutput"><span class="keyword">double</span></code> by showing trailing zero or random
 603         digits after <a href="http://en.cppreference.com/w/cpp/types/numeric_limits/max_digits10" target="_top">max_digits10</a>,
 604         that is 17 for <code class="computeroutput"><span class="keyword">double</span></code>, digit
 605         18... may be just noise.
 606       </p></td></tr>
 607 </table></div>
 608 <p>
 609       The complete example code is at <a href="../../../example/brent_minimise_example.cpp" target="_top">brent_minimise_example.cpp</a>.
 610     </p>
 611 <h5>
 612 <a name="math_toolkit.brent_minima.h6"></a>
 613       <span class="phrase"><a name="math_toolkit.brent_minima.implementation"></a></span><a class="link" href="brent_minima.html#math_toolkit.brent_minima.implementation">Implementation</a>
 614     </h5>
 615 <p>
 616       This is a reasonably faithful implementation of Brent's algorithm.
 617     </p>
 618 <h5>
 619 <a name="math_toolkit.brent_minima.h7"></a>
 620       <span class="phrase"><a name="math_toolkit.brent_minima.references"></a></span><a class="link" href="brent_minima.html#math_toolkit.brent_minima.references">References</a>
 621     </h5>
 622 <div class="orderedlist"><ol class="orderedlist" type="1">
 623 <li class="listitem">
 624           Brent, R.P. 1973, Algorithms for Minimization without Derivatives, (Englewood
 625           Cliffs, NJ: Prentice-Hall), Chapter 5.
 626         </li>
 627 <li class="listitem">
 628           Numerical Recipes in C, The Art of Scientific Computing, Second Edition,
 629           William H. Press, Saul A. Teukolsky, William T. Vetterling, and Brian P.
 630           Flannery. Cambridge University Press. 1988, 1992.
 631         </li>
 632 <li class="listitem">
 633           An algorithm with guaranteed convergence for finding a zero of a function,
 634           R. P. Brent, The Computer Journal, Vol 44, 1971.
 635         </li>
 636 <li class="listitem">
 637           <a href="http://en.wikipedia.org/wiki/Brent%27s_method" target="_top">Brent's method
 638           in Wikipedia.</a>
 639         </li>
 640 <li class="listitem">
 641           Z. Zhang, An Improvement to the Brent's Method, IJEA, vol. 2, pp. 2 to
 642           26, May 31, 2011. <a href="http://www.cscjournals.org/manuscript/Journals/IJEA/volume2/Issue1/IJEA-7.pdf" target="_top">http://www.cscjournals.org/manuscript/Journals/IJEA/volume2/Issue1/IJEA-7.pdf</a>
 643         </li>
 644 <li class="listitem">
 645           Steven A. Stage, Comments on An Improvement to the Brent's Method (and
 646           comparison of various algorithms) <a href="http://www.cscjournals.org/manuscript/Journals/IJEA/volume4/Issue1/IJEA-33.pdf" target="_top">http://www.cscjournals.org/manuscript/Journals/IJEA/volume4/Issue1/IJEA-33.pdf</a>
 647           Stage concludes that Brent's algorithm is slow to start, but fast to finish
 648           convergence, and has good accuracy.
 649         </li>
 650 </ol></div>
 651 </div>
 652 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 653 <td align="left"></td>
 654 <td align="right"><div class="copyright-footer">Copyright &#169; 2006-2019 Nikhar
 655       Agrawal, Anton Bikineev, Paul A. Bristow, Marco Guazzone, Christopher Kormanyos,
 656       Hubert Holin, Bruno Lalande, John Maddock, Jeremy Murphy, Matthew Pulver, Johan
 657       R&#229;de, Gautam Sewani, Benjamin Sobotta, Nicholas Thompson, Thijs van den Berg,
 658       Daryle Walker and Xiaogang Zhang<p>
 659         Distributed under the Boost Software License, Version 1.0. (See accompanying
 660         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>)
 661       </p>
 662 </div></td>
 663 </tr></table>
 664 <hr>
 665 <div class="spirit-nav">
 666 <a accesskey="p" href="bad_roots.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../root_finding.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="root_comparison.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 667 </div>
 668 </body>
 669 </html>