libs/math/doc/html/math_toolkit/root_finding_examples/multiprecision_root.html

   1 <html>
   2 <head>
   3 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
   4 <title>Root-finding using Boost.Multiprecision</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_examples.html" title="Examples of Root-Finding (with and without derivatives)">
   9 <link rel="prev" href="5th_root_eg.html" title="Computing the Fifth Root">
  10 <link rel="next" href="nth_root.html" title="Generalizing to Compute the nth root">
  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="5th_root_eg.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../root_finding_examples.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="nth_root.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
  24 </div>
  25 <div class="section">
  26 <div class="titlepage"><div><div><h3 class="title">
  27 <a name="math_toolkit.root_finding_examples.multiprecision_root"></a><a class="link" href="multiprecision_root.html" title="Root-finding using Boost.Multiprecision">Root-finding
  28       using Boost.Multiprecision</a>
  29 </h3></div></div></div>
  30 <p>
  31         The apocryphally astute reader might, by now, be asking "How do we know
  32         if this computes the 'right' answer?".
  33       </p>
  34 <p>
  35         For most values, there is, sadly, no 'right' answer. This is because values
  36         can only rarely be <span class="emphasis"><em>exactly represented</em></span> by C++ floating-point
  37         types. What we do want is the 'best' representation - one that is the nearest
  38         <a href="http://en.wikipedia.org/wiki/Floating_point#Representable_numbers.2C_conversion_and_rounding" target="_top">representable</a>
  39         value. (For more about how numbers are represented see <a href="http://en.wikipedia.org/wiki/Floating_point" target="_top">Floating
  40         point</a>).
  41       </p>
  42 <p>
  43         Of course, we might start with finding an external reference source like
  44         <a href="http://www.wolframalpha.com/" target="_top">Wolfram Alpha</a>, as above,
  45         but this is not always possible.
  46       </p>
  47 <p>
  48         Another way to reassure is to compute 'reference' values at higher precision
  49         with which to compare the results of our iterative computations using built-in
  50         like <code class="computeroutput"><span class="keyword">double</span></code>. They should agree
  51         within the tolerance that was set.
  52       </p>
  53 <p>
  54         The result of <code class="computeroutput"><span class="keyword">static_cast</span></code>ing
  55         to <code class="computeroutput"><span class="keyword">double</span></code> from a higher-precision
  56         type like <code class="computeroutput"><span class="identifier">cpp_bin_float_50</span></code>
  57         is guaranteed to be the <span class="bold"><strong>nearest representable</strong></span>
  58         <code class="computeroutput"><span class="keyword">double</span></code> value.
  59       </p>
  60 <p>
  61         For example, the cube root functions in our example for <code class="computeroutput"><span class="identifier">cbrt</span><span class="special">(</span><span class="number">28.</span><span class="special">)</span></code>
  62         compute
  63       </p>
  64 <p>
  65         <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cbrt</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;(</span><span class="number">28.</span><span class="special">)</span> <span class="special">=</span>
  66         <span class="number">3.0365889718756627</span></code>
  67       </p>
  68 <p>
  69         WolframAlpha says <code class="computeroutput"><span class="number">3.036588971875662519420809578505669635581453977248111123242141</span><span class="special">...</span></code>
  70       </p>
  71 <p>
  72         <code class="computeroutput"><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;(</span><span class="number">3.03658897187566251942080957850</span><span class="special">)</span>
  73         <span class="special">=</span> <span class="number">3.0365889718756627</span></code>
  74       </p>
  75 <p>
  76         This example <code class="computeroutput"><span class="identifier">cbrt</span><span class="special">(</span><span class="number">28.</span><span class="special">)</span> <span class="special">=</span>
  77         <span class="number">3.0365889718756627</span></code>
  78       </p>
  79 <div class="tip"><table border="0" summary="Tip">
  80 <tr>
  81 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../../../../doc/src/images/tip.png"></td>
  82 <th align="left">Tip</th>
  83 </tr>
  84 <tr><td align="left" valign="top">
  85 <p>
  86           To ensure that all potentially significant decimal digits are displayed
  87           use <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="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span></code> (or if not available on
  88           older platforms or compilers use <code class="computeroutput"><span class="number">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">3010</span><span class="special">/</span><span class="number">10000</span></code>).<br>
  89         </p>
  90 <p>
  91           Ideally, values should agree to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">-</span><span class="identifier">limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">digits10</span></code>
  92           decimal digits.
  93         </p>
  94 <p>
  95           This also means that a 'reference' value to be <span class="bold"><strong>input</strong></span>
  96           or <code class="computeroutput"><span class="keyword">static_cast</span></code> should have
  97           at least <code class="computeroutput"><span class="identifier">max_digits10</span></code> decimal
  98           digits (17 for 64-bit <code class="computeroutput"><span class="keyword">double</span></code>).
  99         </p>
 100 </td></tr>
 101 </table></div>
 102 <p>
 103         If we wish to compute <span class="bold"><strong>higher-precision values</strong></span>
 104         then, on some platforms, we may be able to use <code class="computeroutput"><span class="keyword">long</span>
 105         <span class="keyword">double</span></code> with a higher precision than
 106         <code class="computeroutput"><span class="keyword">double</span></code> to compare with the very
 107         common <code class="computeroutput"><span class="keyword">double</span></code> and/or a more
 108         efficient built-in quad floating-point type like <code class="computeroutput"><span class="identifier">__float128</span></code>.
 109       </p>
 110 <p>
 111         Almost all platforms can easily use <a href="../../../../../../libs/multiprecision/doc/html/index.html" target="_top">Boost.Multiprecision</a>,
 112         for example, <a href="../../../../../../libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_dec_float.html" target="_top">cpp_dec_float</a>
 113         or a binary type <a href="../../../../../../libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_bin_float.html" target="_top">cpp_bin_float</a>
 114         types, to compute values at very much higher precision.
 115       </p>
 116 <div class="note"><table border="0" summary="Note">
 117 <tr>
 118 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/src/images/note.png"></td>
 119 <th align="left">Note</th>
 120 </tr>
 121 <tr><td align="left" valign="top"><p>
 122           With multiprecision types, it is debatable whether to use the type <code class="computeroutput"><span class="identifier">T</span></code> for computing the initial guesses.
 123           Type <code class="computeroutput"><span class="keyword">double</span></code> is like to be
 124           accurate enough for the method used in these examples. This would limit
 125           the exponent range of possible values to that of <code class="computeroutput"><span class="keyword">double</span></code>.
 126           There is also the cost of conversion to and from type <code class="computeroutput"><span class="identifier">T</span></code>
 127           to consider. In these examples, <code class="computeroutput"><span class="keyword">double</span></code>
 128           is used via <code class="computeroutput"><span class="keyword">typedef</span> <span class="keyword">double</span>
 129           <span class="identifier">guess_type</span></code>.
 130         </p></td></tr>
 131 </table></div>
 132 <p>
 133         Since the functors and functions used above are templated on the value type,
 134         we can very simply use them with any of the <a href="../../../../../../libs/multiprecision/doc/html/index.html" target="_top">Boost.Multiprecision</a>
 135         types. As a reminder, here's our toy cube root function using 2 derivatives
 136         and C++11 lambda functions to find the root:
 137       </p>
 138 <pre class="programlisting"><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>
 139 <span class="identifier">T</span> <span class="identifier">cbrt_2deriv_lambda</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">x</span><span class="special">)</span>
 140 <span class="special">{</span>
 141    <span class="comment">// return cube root of x using 1st and 2nd derivatives and Halley.</span>
 142    <span class="comment">//using namespace std;  // Help ADL of std functions.</span>
 143    <span class="keyword">using</span> <span class="keyword">namespace</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>
 144    <span class="keyword">int</span> <span class="identifier">exponent</span><span class="special">;</span>
 145    <span class="identifier">frexp</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">exponent</span><span class="special">);</span>                                <span class="comment">// Get exponent of z (ignore mantissa).</span>
 146    <span class="identifier">T</span> <span class="identifier">guess</span> <span class="special">=</span> <span class="identifier">ldexp</span><span class="special">(</span><span class="number">1.</span><span class="special">,</span> <span class="identifier">exponent</span> <span class="special">/</span> <span class="number">3</span><span class="special">);</span>                    <span class="comment">// Rough guess is to divide the exponent by three.</span>
 147    <span class="identifier">T</span> <span class="identifier">min</span> <span class="special">=</span> <span class="identifier">ldexp</span><span class="special">(</span><span class="number">0.5</span><span class="special">,</span> <span class="identifier">exponent</span> <span class="special">/</span> <span class="number">3</span><span class="special">);</span>                     <span class="comment">// Minimum possible value is half our guess.</span>
 148    <span class="identifier">T</span> <span class="identifier">max</span> <span class="special">=</span> <span class="identifier">ldexp</span><span class="special">(</span><span class="number">2.</span><span class="special">,</span> <span class="identifier">exponent</span> <span class="special">/</span> <span class="number">3</span><span class="special">);</span>                      <span class="comment">// Maximum possible value is twice our guess.</span>
 149    <span class="keyword">const</span> <span class="keyword">int</span> <span class="identifier">digits</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="comment">// Maximum possible binary digits accuracy for type T.</span>
 150    <span class="comment">// digits used to control how accurate to try to make the result.</span>
 151    <span class="keyword">int</span> <span class="identifier">get_digits</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="identifier">digits</span> <span class="special">*</span> <span class="number">0.4</span><span class="special">);</span>    <span class="comment">// Accuracy triples with each step, so stop when just</span>
 152    <span class="comment">// over one third of the digits are correct.</span>
 153    <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>
 154    <span class="identifier">T</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">halley_iterate</span><span class="special">(</span>
 155       <span class="comment">// lambda function:</span>
 156       <span class="special">[</span><span class="identifier">x</span><span class="special">](</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">g</span><span class="special">){</span> <span class="keyword">return</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">make_tuple</span><span class="special">(</span><span class="identifier">g</span> <span class="special">*</span> <span class="identifier">g</span> <span class="special">*</span> <span class="identifier">g</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="identifier">g</span> <span class="special">*</span> <span class="identifier">g</span><span class="special">,</span> <span class="number">6</span> <span class="special">*</span> <span class="identifier">g</span><span class="special">);</span> <span class="special">},</span>
 157       <span class="identifier">guess</span><span class="special">,</span> <span class="identifier">min</span><span class="special">,</span> <span class="identifier">max</span><span class="special">,</span> <span class="identifier">get_digits</span><span class="special">,</span> <span class="identifier">maxit</span><span class="special">);</span>
 158    <span class="keyword">return</span> <span class="identifier">result</span><span class="special">;</span>
 159 <span class="special">}</span>
 160 </pre>
 161 <p>
 162         Some examples below are 50 decimal digit decimal and binary types (and on
 163         some platforms a much faster <code class="computeroutput"><span class="identifier">float128</span></code>
 164         or <code class="computeroutput"><span class="identifier">quad_float</span></code> type ) that
 165         we can use with these includes:
 166       </p>
 167 <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_bin_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span> <span class="comment">// For cpp_bin_float_50.</span>
 168 <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 cpp_dec_float_50.</span>
 169 <span class="preprocessor">#ifndef</span> <span class="identifier">_MSC_VER</span>  <span class="comment">// float128 is not yet supported by Microsoft compiler at 2013.</span>
 170 <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">float128</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span> <span class="comment">// Requires libquadmath.</span>
 171 <span class="preprocessor">#endif</span>
 172 </pre>
 173 <p>
 174         Some using statements simplify their use:
 175       </p>
 176 <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_dec_float_50</span><span class="special">;</span> <span class="comment">// decimal.</span>
 177   <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.</span>
 178 <span class="preprocessor">#ifndef</span> <span class="identifier">_MSC_VER</span>  <span class="comment">// Not supported by Microsoft compiler.</span>
 179   <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>
 180 <span class="preprocessor">#endif</span>
 181 </pre>
 182 <p>
 183         They can be used thus:
 184       </p>
 185 <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_dec_float_50</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">);</span>
 186
 187 <span class="identifier">cpp_dec_float_50</span> <span class="identifier">two</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span> <span class="comment">// </span>
 188 <span class="identifier">cpp_dec_float_50</span>  <span class="identifier">r</span> <span class="special">=</span> <span class="identifier">cbrt_2deriv</span><span class="special">(</span><span class="identifier">two</span><span class="special">);</span>
 189 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"cbrt("</span> <span class="special">&lt;&lt;</span> <span class="identifier">two</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">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 190
 191 <span class="identifier">r</span> <span class="special">=</span> <span class="identifier">cbrt_2deriv</span><span class="special">(</span><span class="number">2.</span><span class="special">);</span> <span class="comment">// Passing a double, so ADL will compute a double precision result.</span>
 192 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"cbrt("</span> <span class="special">&lt;&lt;</span> <span class="identifier">two</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">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 193 <span class="comment">// cbrt(2) = 1.2599210498948731906665443602832965552806854248047 'wrong' from digits 17 onwards!</span>
 194 <span class="identifier">r</span> <span class="special">=</span> <span class="identifier">cbrt_2deriv</span><span class="special">(</span><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_50</span><span class="special">&gt;(</span><span class="number">2.</span><span class="special">));</span> <span class="comment">// Passing a cpp_dec_float_50, </span>
 195 <span class="comment">// so will compute a cpp_dec_float_50 precision result.</span>
 196 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"cbrt("</span> <span class="special">&lt;&lt;</span> <span class="identifier">two</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">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 197 <span class="identifier">r</span> <span class="special">=</span> <span class="identifier">cbrt_2deriv</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_50</span><span class="special">&gt;(</span><span class="number">2.</span><span class="special">);</span> <span class="comment">// Explictly a cpp_dec_float_50, so will compute a cpp_dec_float_50 precision result.</span>
 198 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"cbrt("</span> <span class="special">&lt;&lt;</span> <span class="identifier">two</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">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 199 <span class="comment">// cpp_dec_float_50 1.2599210498948731647672106072782283505702514647015</span>
 200 </pre>
 201 <p>
 202         A reference value computed by <a href="http://www.wolframalpha.com/" target="_top">Wolfram
 203         Alpha</a> is
 204       </p>
 205 <pre class="programlisting"><span class="identifier">N</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="number">3</span><span class="special">),</span> <span class="number">50</span><span class="special">]</span>  <span class="number">1.2599210498948731647672106072782283505702514647015</span>
 206 </pre>
 207 <p>
 208         which agrees exactly.
 209       </p>
 210 <p>
 211         To <span class="bold"><strong>show</strong></span> values to their full precision,
 212         it is necessary to adjust the <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span></code>
 213         <code class="computeroutput"><span class="identifier">precision</span></code> to suit the type,
 214         for example:
 215       </p>
 216 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
 217 <span class="identifier">T</span> <span class="identifier">show_cube_root</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">value</span><span class="special">)</span>
 218 <span class="special">{</span> <span class="comment">// Demonstrate by printing the root using all definitely significant digits.</span>
 219   <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>
 220   <span class="identifier">T</span> <span class="identifier">r</span> <span class="special">=</span> <span class="identifier">cbrt_2deriv</span><span class="special">(</span><span class="identifier">value</span><span class="special">);</span>
 221   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"value = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">value</span> <span class="special">&lt;&lt;</span> <span class="string">", cube root ="</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</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>
 222   <span class="keyword">return</span> <span class="identifier">r</span><span class="special">;</span>
 223 <span class="special">}</span>
 224 </pre>
 225 <pre class="programlisting"><span class="identifier">show_cube_root</span><span class="special">(</span><span class="number">2.</span><span class="special">);</span>
 226 <span class="identifier">show_cube_root</span><span class="special">(</span><span class="number">2.L</span><span class="special">);</span>
 227 <span class="identifier">show_cube_root</span><span class="special">(</span><span class="identifier">two</span><span class="special">);</span>
 228 </pre>
 229 <p>
 230         which outputs:
 231       </p>
 232 <pre class="programlisting">cbrt(2) = 1.2599210498948731647672106072782283505702514647015
 233
 234 value = 2, cube root =1.25992104989487
 235 value = 2, cube root =1.25992104989487
 236 value = 2, cube root =1.2599210498948731647672106072782283505702514647015
 237 </pre>
 238 <div class="tip"><table border="0" summary="Tip">
 239 <tr>
 240 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../../../../doc/src/images/tip.png"></td>
 241 <th align="left">Tip</th>
 242 </tr>
 243 <tr><td align="left" valign="top">
 244 <p>
 245           Be <span class="bold"><strong>very careful</strong></span> about the floating-point
 246           type <code class="computeroutput"><span class="identifier">T</span></code> that is passed to
 247           the root-finding function. Carelessly passing a integer by writing <code class="computeroutput"><span class="identifier">cpp_dec_float_50</span> <span class="identifier">r</span>
 248           <span class="special">=</span> <span class="identifier">cbrt_2deriv</span><span class="special">(</span><span class="number">2</span><span class="special">);</span></code>
 249           or <code class="computeroutput"><span class="identifier">show_cube_root</span><span class="special">(</span><span class="number">2</span><span class="special">);</span></code> will
 250           provoke many warnings and compile errors.
 251         </p>
 252 <p>
 253           Even <code class="computeroutput"><span class="identifier">show_cube_root</span><span class="special">(</span><span class="number">2.F</span><span class="special">);</span></code> will
 254           produce warnings because <code class="computeroutput"><span class="keyword">typedef</span>
 255           <span class="keyword">double</span> <span class="identifier">guess_type</span></code>
 256           defines the type used to compute the guess and bracket values as <code class="computeroutput"><span class="keyword">double</span></code>.
 257         </p>
 258 <p>
 259           Even more treacherous is passing a <code class="computeroutput"><span class="keyword">double</span></code>
 260           as in <code class="computeroutput"><span class="identifier">cpp_dec_float_50</span> <span class="identifier">r</span> <span class="special">=</span> <span class="identifier">cbrt_2deriv</span><span class="special">(</span><span class="number">2.</span><span class="special">);</span></code> which
 261           silently gives the 'wrong' result, computing a <code class="computeroutput"><span class="keyword">double</span></code>
 262           result and <span class="bold"><strong>then</strong></span> converting to <code class="computeroutput"><span class="identifier">cpp_dec_float_50</span></code>! All digits beyond
 263           <code class="computeroutput"><span class="identifier">max_digits10</span></code> will be incorrect.
 264           Making the <code class="computeroutput"><span class="identifier">cbrt</span></code> type explicit
 265           with <code class="computeroutput"><span class="identifier">cbrt_2deriv</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_50</span><span class="special">&gt;(</span><span class="number">2.</span><span class="special">);</span></code> will
 266           give you the desired 50 decimal digit precision result.
 267         </p>
 268 </td></tr>
 269 </table></div>
 270 <p>
 271         Full code of this example is at <a href="../../../../example/root_finding_multiprecision_example.cpp" target="_top">root_finding_multiprecision_example.cpp</a>.
 272       </p>
 273 </div>
 274 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 275 <td align="left"></td>
 276 <td align="right"><div class="copyright-footer">Copyright &#169; 2006-2019 Nikhar
 277       Agrawal, Anton Bikineev, Paul A. Bristow, Marco Guazzone, Christopher Kormanyos,
 278       Hubert Holin, Bruno Lalande, John Maddock, Jeremy Murphy, Matthew Pulver, Johan
 279       R&#229;de, Gautam Sewani, Benjamin Sobotta, Nicholas Thompson, Thijs van den Berg,
 280       Daryle Walker and Xiaogang Zhang<p>
 281         Distributed under the Boost Software License, Version 1.0. (See accompanying
 282         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>)
 283       </p>
 284 </div></td>
 285 </tr></table>
 286 <hr>
 287 <div class="spirit-nav">
 288 <a accesskey="p" href="5th_root_eg.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../root_finding_examples.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="nth_root.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 289 </div>
 290 </body>
 291 </html>