• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 <html>
2 <head>
3 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
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.12.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">// Explicitly 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 © 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å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>
292