ceph/src/boost/libs/math/doc/html/math_toolkit/special_tut/special_tut_impl.html

   1 <html>
   2 <head>
   3 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
   4 <title>Implementation</title>
   5 <link rel="stylesheet" href="../../math.css" type="text/css">
   6 <meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
   7 <link rel="home" href="../../index.html" title="Math Toolkit 2.5.1">
   8 <link rel="up" href="../special_tut.html" title="Tutorial: How to Write a New Special Function">
   9 <link rel="prev" href="../special_tut.html" title="Tutorial: How to Write a New Special Function">
  10 <link rel="next" href="special_tut_test.html" title="Testing">
  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="../special_tut.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../special_tut.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="special_tut_test.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.special_tut.special_tut_impl"></a><a class="link" href="special_tut_impl.html" title="Implementation">Implementation</a>
  28 </h3></div></div></div>
  29 <p>
  30         In this section, we'll provide a "recipe" for adding a new special
  31         function to this library to make life easier for future authors wishing to
  32         contribute. We'll assume the function returns a single floating-point result,
  33         and takes two floating-point arguments. For the sake of exposition we'll
  34         give the function the name <em class="replaceable"><code>my_special</code></em>.
  35       </p>
  36 <p>
  37         Normally, the implementation of such a function is split into two layers
  38         - a public user layer, and an internal implementation layer that does the
  39         actual work. The implementation layer is declared inside a <code class="computeroutput"><span class="identifier">detail</span></code> namespace and has a simple signature:
  40       </p>
  41 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">math</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">detail</span> <span class="special">{</span>
  42
  43 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Policy</span><span class="special">&gt;</span>
  44 <span class="identifier">T</span> <span class="identifier">my_special_imp</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Policy</span><span class="special">&amp;</span> <span class="identifier">pol</span><span class="special">)</span>
  45 <span class="special">{</span>
  46    <span class="comment">/* Implementation goes here */</span>
  47 <span class="special">}</span>
  48
  49 <span class="special">}}}</span> <span class="comment">// namespaces</span>
  50 </pre>
  51 <p>
  52         We'll come back to what can go inside the implementation later, but first
  53         lets look at the user layer. This consists of two overloads of the function,
  54         with and without a <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a> argument:
  55       </p>
  56 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">math</span><span class="special">{</span>
  57
  58 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span>
  59 <span class="keyword">typename</span> <span class="identifier">tools</span><span class="special">::</span><span class="identifier">promote_args</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">my_special</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">U</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
  60
  61 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Policy</span><span class="special">&gt;</span>
  62 <span class="keyword">typename</span> <span class="identifier">tools</span><span class="special">::</span><span class="identifier">promote_args</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">my_special</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">U</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Policy</span><span class="special">&amp;</span> <span class="identifier">pol</span><span class="special">);</span>
  63
  64 <span class="special">}}</span> <span class="comment">// namespaces</span>
  65 </pre>
  66 <p>
  67         Note how each argument has a different template type - this allows for mixed
  68         type arguments - the return type is computed from a traits class and is the
  69         "common type" of all the arguments after any integer arguments
  70         have been promoted to type <code class="computeroutput"><span class="keyword">double</span></code>.
  71       </p>
  72 <p>
  73         The implementation of the non-policy overload is trivial:
  74       </p>
  75 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">math</span><span class="special">{</span>
  76
  77 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span>
  78 <span class="keyword">inline</span> <span class="keyword">typename</span> <span class="identifier">tools</span><span class="special">::</span><span class="identifier">promote_args</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">my_special</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">U</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span>
  79 <span class="special">{</span>
  80    <span class="comment">// Simply forward with a default policy:</span>
  81    <span class="keyword">return</span> <span class="identifier">my_special</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">policies</span><span class="special">::</span><span class="identifier">policy</span><span class="special">&lt;&gt;();</span>
  82 <span class="special">}</span>
  83
  84 <span class="special">}}</span> <span class="comment">// namespaces</span>
  85 </pre>
  86 <p>
  87         The implementation of the other overload is somewhat more complex, as there's
  88         some meta-programming to do, but from a runtime perspective is still a one-line
  89         forwarding function. Here it is with comments explaining what each line does:
  90       </p>
  91 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">math</span><span class="special">{</span>
  92
  93 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Policy</span><span class="special">&gt;</span>
  94 <span class="keyword">inline</span> <span class="keyword">typename</span> <span class="identifier">tools</span><span class="special">::</span><span class="identifier">promote_args</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">my_special</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">U</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Policy</span><span class="special">&amp;</span> <span class="identifier">pol</span><span class="special">)</span>
  95 <span class="special">{</span>
  96    <span class="comment">//</span>
  97    <span class="comment">// We've found some standard library functions to misbehave if any FPU exception flags</span>
  98    <span class="comment">// are set prior to their call, this code will clear those flags, then reset them</span>
  99    <span class="comment">// on exit:</span>
 100    <span class="comment">//</span>
 101    <span class="identifier">BOOST_FPU_EXCEPTION_GUARD</span>
 102    <span class="comment">//</span>
 103    <span class="comment">// The type of the result - the common type of T and U after</span>
 104    <span class="comment">// any integer types have been promoted to double:</span>
 105    <span class="comment">//</span>
 106    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">tools</span><span class="special">::</span><span class="identifier">promote_args</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">result_type</span><span class="special">;</span>
 107    <span class="comment">//</span>
 108    <span class="comment">// The type used for the calculation.  This may be a wider type than</span>
 109    <span class="comment">// the result in order to ensure full precision:</span>
 110    <span class="comment">//</span>
 111    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">policies</span><span class="special">::</span><span class="identifier">evaluation</span><span class="special">&lt;</span><span class="identifier">result_type</span><span class="special">,</span> <span class="identifier">Policy</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">value_type</span><span class="special">;</span>
 112    <span class="comment">//</span>
 113    <span class="comment">// The type of the policy to forward to the actual implementation.</span>
 114    <span class="comment">// We disable promotion of float and double as that's [possibly]</span>
 115    <span class="comment">// happened already in the line above.  Also reset to the default</span>
 116    <span class="comment">// any policies we don't use (reduces code bloat if we're called</span>
 117    <span class="comment">// multiple times with differing policies we don't actually use).</span>
 118    <span class="comment">// Also normalise the type, again to reduce code bloat in case we're</span>
 119    <span class="comment">// called multiple times with functionally identical policies that happen</span>
 120    <span class="comment">// to be different types.</span>
 121    <span class="comment">//</span>
 122    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">policies</span><span class="special">::</span><span class="identifier">normalise</span><span class="special">&lt;</span>
 123       <span class="identifier">Policy</span><span class="special">,</span>
 124       <span class="identifier">policies</span><span class="special">::</span><span class="identifier">promote_float</span><span class="special">&lt;</span><span class="keyword">false</span><span class="special">&gt;,</span>
 125       <span class="identifier">policies</span><span class="special">::</span><span class="identifier">promote_double</span><span class="special">&lt;</span><span class="keyword">false</span><span class="special">&gt;,</span>
 126       <span class="identifier">policies</span><span class="special">::</span><span class="identifier">discrete_quantile</span><span class="special">&lt;&gt;,</span>
 127       <span class="identifier">policies</span><span class="special">::</span><span class="identifier">assert_undefined</span><span class="special">&lt;&gt;</span> <span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">forwarding_policy</span><span class="special">;</span>
 128    <span class="comment">//</span>
 129    <span class="comment">// Whew.  Now we can make the actual call to the implementation.</span>
 130    <span class="comment">// Arguments are explicitly cast to the evaluation type, and the result</span>
 131    <span class="comment">// passed through checked_narrowing_cast which handles things like overflow</span>
 132    <span class="comment">// according to the policy passed:</span>
 133    <span class="comment">//</span>
 134    <span class="keyword">return</span> <span class="identifier">policies</span><span class="special">::</span><span class="identifier">checked_narrowing_cast</span><span class="special">&lt;</span><span class="identifier">result_type</span><span class="special">,</span> <span class="identifier">forwarding_policy</span><span class="special">&gt;(</span>
 135          <span class="identifier">detail</span><span class="special">::</span><span class="identifier">my_special_imp</span><span class="special">(</span>
 136                <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">value_type</span><span class="special">&gt;(</span><span class="identifier">a</span><span class="special">),</span>
 137                <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">value_type</span><span class="special">&gt;(</span><span class="identifier">x</span><span class="special">),</span>
 138                <span class="identifier">forwarding_policy</span><span class="special">()),</span>
 139          <span class="string">"boost::math::my_special&lt;%1%&gt;(%1%, %1%)"</span><span class="special">);</span>
 140 <span class="special">}</span>
 141
 142 <span class="special">}}</span> <span class="comment">// namespaces</span>
 143 </pre>
 144 <p>
 145         We're now almost there, we just need to flesh out the details of the implementation
 146         layer:
 147       </p>
 148 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">math</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">detail</span> <span class="special">{</span>
 149
 150 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Policy</span><span class="special">&gt;</span>
 151 <span class="identifier">T</span> <span class="identifier">my_special_imp</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Policy</span><span class="special">&amp;</span> <span class="identifier">pol</span><span class="special">)</span>
 152 <span class="special">{</span>
 153    <span class="comment">/* Implementation goes here */</span>
 154 <span class="special">}</span>
 155
 156 <span class="special">}}}</span> <span class="comment">// namespaces</span>
 157 </pre>
 158 <p>
 159         The following guidelines indicate what (other than basic arithmetic) can
 160         go in the implementation:
 161       </p>
 162 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 163 <li class="listitem">
 164             Error conditions (for example bad arguments) should be handled by calling
 165             one of the <a class="link" href="../error_handling.html#math_toolkit.error_handling.finding_more_information">policy
 166             based error handlers</a>.
 167           </li>
 168 <li class="listitem">
 169             Calls to standard library functions should be made unqualified (this
 170             allows argument dependent lookup to find standard library functions for
 171             user-defined floating point types such as those from <a href="../../../../../../libs/multiprecision/doc/html/index.html" target="_top">Boost.Multiprecision</a>).
 172             In addition, the macro <code class="computeroutput"><span class="identifier">BOOST_MATH_STD_USING</span></code>
 173             should appear at the start of the function (note no semi-colon afterwards!)
 174             so that all the math functions in <code class="computeroutput"><span class="keyword">namespace</span>
 175             <span class="identifier">std</span></code> are visible in the current
 176             scope.
 177           </li>
 178 <li class="listitem">
 179             Calls to other special functions should be made as fully qualified calls,
 180             and include the policy parameter as the last argument, for example <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">pol</span><span class="special">)</span></code>.
 181           </li>
 182 <li class="listitem">
 183             Where possible, evaluation of series, continued fractions, polynomials,
 184             or root finding should use one of the <a class="link" href="../internals_overview.html" title="Overview">boiler-plate
 185             functions</a>. In any case, after any iterative method, you should
 186             verify that the number of iterations did not exceed the maximum specified
 187             in the <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a> type, and if it did terminate
 188             as a result of exceeding the maximum, then the appropriate error handler
 189             should be called (see existing code for examples).
 190           </li>
 191 <li class="listitem">
 192             Numeric constants such as &#960; etc should be obtained via a call to the <a class="link" href="../constants.html" title="The Mathematical Constants">appropriate function</a>, for example:
 193             <code class="computeroutput"><span class="identifier">constants</span><span class="special">::</span><span class="identifier">pi</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;()</span></code>.
 194           </li>
 195 <li class="listitem">
 196             Where tables of coefficients are used (for example for rational approximations),
 197             care should be taken to ensure these are initialized at program startup
 198             to ensure thread safety when using user-defined number types. See for
 199             example the use of <code class="computeroutput"><span class="identifier">erf_initializer</span></code>
 200             in <a href="../../../../include/boost/math/special_functions/erf.hpp" target="_top">erf.hpp</a>.
 201           </li>
 202 </ul></div>
 203 <p>
 204         Here are some other useful internal functions:
 205       </p>
 206 <div class="informaltable"><table class="table">
 207 <colgroup>
 208 <col>
 209 <col>
 210 </colgroup>
 211 <thead><tr>
 212 <th>
 213                 <p>
 214                   function
 215                 </p>
 216               </th>
 217 <th>
 218                 <p>
 219                   Meaning
 220                 </p>
 221               </th>
 222 </tr></thead>
 223 <tbody>
 224 <tr>
 225 <td>
 226                 <p>
 227                   <code class="computeroutput"><span class="identifier">policies</span><span class="special">::</span><span class="identifier">digits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span>
 228                   <span class="identifier">Policy</span><span class="special">&gt;()</span></code>
 229                 </p>
 230               </td>
 231 <td>
 232                 <p>
 233                   Returns number of binary digits in T (possible overridden by the
 234                   policy).
 235                 </p>
 236               </td>
 237 </tr>
 238 <tr>
 239 <td>
 240                 <p>
 241                   <code class="computeroutput"><span class="identifier">policies</span><span class="special">::</span><span class="identifier">get_max_series_iterations</span><span class="special">&lt;</span><span class="identifier">Policy</span><span class="special">&gt;()</span></code>
 242                 </p>
 243               </td>
 244 <td>
 245                 <p>
 246                   Maximum number of iterations for series evaluation.
 247                 </p>
 248               </td>
 249 </tr>
 250 <tr>
 251 <td>
 252                 <p>
 253                   <code class="computeroutput"><span class="identifier">policies</span><span class="special">::</span><span class="identifier">get_max_root_iterations</span><span class="special">&lt;</span><span class="identifier">Policy</span><span class="special">&gt;()</span></code>
 254                 </p>
 255               </td>
 256 <td>
 257                 <p>
 258                   Maximum number of iterations for root finding.
 259                 </p>
 260               </td>
 261 </tr>
 262 <tr>
 263 <td>
 264                 <p>
 265                   <code class="computeroutput"><span class="identifier">polices</span><span class="special">::</span><span class="identifier">get_epsilon</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span>
 266                   <span class="identifier">Policy</span><span class="special">&gt;()</span></code>
 267                 </p>
 268               </td>
 269 <td>
 270                 <p>
 271                   Epsilon for type T, possibly overridden by the Policy.
 272                 </p>
 273               </td>
 274 </tr>
 275 <tr>
 276 <td>
 277                 <p>
 278                   <code class="computeroutput"><span class="identifier">tools</span><span class="special">::</span><span class="identifier">digits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;()</span></code>
 279                 </p>
 280               </td>
 281 <td>
 282                 <p>
 283                   Returns the number of binary digits in T.
 284                 </p>
 285               </td>
 286 </tr>
 287 <tr>
 288 <td>
 289                 <p>
 290                   <code class="computeroutput"><span class="identifier">tools</span><span class="special">::</span><span class="identifier">max_value</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;()</span></code>
 291                 </p>
 292               </td>
 293 <td>
 294                 <p>
 295                   Equivalent 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="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">()</span></code>
 296                 </p>
 297               </td>
 298 </tr>
 299 <tr>
 300 <td>
 301                 <p>
 302                   <code class="computeroutput"><span class="identifier">tools</span><span class="special">::</span><span class="identifier">min_value</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;()</span></code>
 303                 </p>
 304               </td>
 305 <td>
 306                 <p>
 307                   Equivalent 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="identifier">T</span><span class="special">&gt;::</span><span class="identifier">min</span><span class="special">()</span></code>
 308                 </p>
 309               </td>
 310 </tr>
 311 <tr>
 312 <td>
 313                 <p>
 314                   <code class="computeroutput"><span class="identifier">tools</span><span class="special">::</span><span class="identifier">log_max_value</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;()</span></code>
 315                 </p>
 316               </td>
 317 <td>
 318                 <p>
 319                   Equivalent to the natural logarithm of <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</span><span class="special">()</span></code>
 320                 </p>
 321               </td>
 322 </tr>
 323 <tr>
 324 <td>
 325                 <p>
 326                   <code class="computeroutput"><span class="identifier">tools</span><span class="special">::</span><span class="identifier">log_min_value</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;()</span></code>
 327                 </p>
 328               </td>
 329 <td>
 330                 <p>
 331                   Equivalent to the natural logarithm of <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">min</span><span class="special">()</span></code>
 332                 </p>
 333               </td>
 334 </tr>
 335 <tr>
 336 <td>
 337                 <p>
 338                   <code class="computeroutput"><span class="identifier">tools</span><span class="special">::</span><span class="identifier">epsilon</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;()</span></code>
 339                 </p>
 340               </td>
 341 <td>
 342                 <p>
 343                   Equivalent 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="identifier">T</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">()</span></code>.
 344                 </p>
 345               </td>
 346 </tr>
 347 <tr>
 348 <td>
 349                 <p>
 350                   <code class="computeroutput"><span class="identifier">tools</span><span class="special">::</span><span class="identifier">root_epsilon</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;()</span></code>
 351                 </p>
 352               </td>
 353 <td>
 354                 <p>
 355                   Equivalent to the square root of <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">epsilon</span><span class="special">()</span></code>.
 356                 </p>
 357               </td>
 358 </tr>
 359 <tr>
 360 <td>
 361                 <p>
 362                   <code class="computeroutput"><span class="identifier">tools</span><span class="special">::</span><span class="identifier">forth_root_epsilon</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;()</span></code>
 363                 </p>
 364               </td>
 365 <td>
 366                 <p>
 367                   Equivalent to the forth root of <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">epsilon</span><span class="special">()</span></code>.
 368                 </p>
 369               </td>
 370 </tr>
 371 </tbody>
 372 </table></div>
 373 </div>
 374 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 375 <td align="left"></td>
 376 <td align="right"><div class="copyright-footer">Copyright &#169; 2006-2010, 2012-2014 Nikhar Agrawal,
 377       Anton Bikineev, Paul A. Bristow, Marco Guazzone, Christopher Kormanyos, Hubert
 378       Holin, Bruno Lalande, John Maddock, Jeremy Murphy, Johan R&#229;de, Gautam Sewani,
 379       Benjamin Sobotta, Thijs van den Berg, Daryle Walker and Xiaogang Zhang<p>
 380         Distributed under the Boost Software License, Version 1.0. (See accompanying
 381         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>)
 382       </p>
 383 </div></td>
 384 </tr></table>
 385 <hr>
 386 <div class="spirit-nav">
 387 <a accesskey="p" href="../special_tut.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../special_tut.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="special_tut_test.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 388 </div>
 389 </body>
 390 </html>