Boost-Commit mailing page: [Boost-commit] svn:boost r86373 - in sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut: . floats limits/implementation limits/implementation/constants limits/implementation/functions

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r86373 - in sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut: . floats limits/implementation limits/implementation/constants limits/implementation/functions
From: john_at_[hidden]
Date: 2013-10-20 12:57:44

Author: johnmaddock
Date: 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013)
New Revision: 86373
URL: http://svn.boost.org/trac/boost/changeset/86373

Log:
Add generated HTML files.

Added:
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_bin_float.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/input_output.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/bound.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/denorm_loss.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/denorm_style.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/digits.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/digits10.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/exact.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/infinity.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/is_bounded.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/is_specialized.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/max_digits10.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/modulo.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/radix.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/round_style.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/signed.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/tinyness.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/NaN.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/denorm_min.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/epsilon.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/infinity.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/lowest.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/max.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/min.html (contents, props changed)
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/round_error.html (contents, props changed)

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_bin_float.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_bin_float.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,179 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>cpp_bin_float</title>
+<link rel="stylesheet" href="../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../floats.html" title="Floating Point Numbers">
+<link rel="prev" href="../floats.html" title="Floating Point Numbers">
+<link rel="next" href="cpp_dec_float.html" title="cpp_dec_float">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="../floats.html"><img src="../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.html"><img src="../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../images/home.png" alt="Home"></a><a accesskey="n" href="cpp_dec_float.html"><img src="../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_multiprecision.tut.floats.cpp_bin_float"></a><a class="link" href="cpp_bin_float.html" title="cpp_bin_float">cpp_bin_float</a>
+</h4></div></div></div>
+
+ <code class="computeroutput">#include <boost/multiprecision/cpp_bin_float.hpp></code>
+ 
+<pre class="programlisting">namespace boost{ namespace multiprecision{
+
+enum digit_base_type
+{
+ digit_base_2 = 2,
+ digit_base_10 = 10
+};
+
+template <unsigned Digits, digit_base_type base = digit_base_10, class Allocator = void, class Exponent = int, ExponentMin = 0, ExponentMax = 0>
+class cpp_bin_float;
+
+typedef number<cpp_bin_float<50> > cpp_bin_float_50;
+typedef number<cpp_bin_float<100> > cpp_bin_float_100;
+
+typedef number<backends::cpp_bin_float<24, backends::digit_base_2, void, boost::int16_t, -126, 127>, et_off> float32_t;
+typedef number<backends::cpp_bin_float<53, backends::digit_base_2, void, boost::int16_t, -1022, 1023>, et_off> float64_t;
+typedef number<backends::cpp_bin_float<64, backends::digit_base_2, void, boost::int16_t, -16382, 16383>, et_off> float80_t;
+typedef number<backends::cpp_bin_float<113, backends::digit_base_2, void, boost::int16_t, -16382, 16383>, et_off> float128_t;
+
+}} // namespaces
+</pre>
+
+ The <code class="computeroutput">cpp_bin_float</code> back-end
+ is used in conjunction with <code class="computeroutput">number</code>:
+ It acts as an entirely C++ (header only and dependency free) floating-point
+ number type that is a drop-in replacement for the native C++ floating-point
+ types, but with much greater precision.
+ 
+
+ Type <code class="computeroutput">cpp_bin_float</code> can
+ be used at fixed precision by specifying a non-zero <code class="computeroutput">Digits</code>
+ template parameter. The typedefs <code class="computeroutput">cpp_dec_float_50</code>
+ and <code class="computeroutput">cpp_dec_float_100</code> provide
+ arithmetic types at 50 and 100 decimal digits precision respectively.
+ 
+
+ Optionally, you can specify whether the precision is specified in decimal
+ digits or binary bits - for example to declare a <code class="computeroutput">cpp_bin_float</code>
+ with exactly the same precision as <code class="computeroutput">double</code>
+ one would use <code class="computeroutput">number<cpp_bin_float<53, digit_base_2> ></code>.
+ The typedefs <code class="computeroutput">float32_t</code>,
+ <code class="computeroutput">float64_t</code>, <code class="computeroutput">float128_t</code> and <code class="computeroutput">float80_t</code>
+ provide software analogues of the IEEE single, double and quad float data
+ types, plus the intel-extended-double type respectively.
+ 
+
+ Normally <code class="computeroutput">cpp_bin_float</code>
+ allocates no memory: all of the space required for its digits are allocated
+ directly within the class. As a result care should be taken not to use
+ the class with too high a digit count as stack space requirements can grow
+ out of control. If that represents a problem then providing an allocator
+ as the final template parameter causes <code class="computeroutput">cpp_bin_float</code>
+ to dynamically allocate the memory it needs: this significantly reduces
+ the size of <code class="computeroutput">cpp_bin_float</code>
+ and increases the viable upper limit on the number of digits at the expense
+ of performance. However, please bear in mind that arithmetic operations
+ rapidly become very expensive as the digit count grows:
+ the current implementation really isn't optimized or designed for large
+ digit counts. Note that since the actual type of the objects allocated
+ is completely opaque, the suggestion would be to use an allocator with
+ <code class="computeroutput">void</code> <code class="computeroutput">value_type</code>,
+ for example: <code class="computeroutput">number<cpp_bin_float<1000, digit_base_10, std::allocator<void> > ></code>.
+ 
+
+ The final template parameters determine the type and range of the exponent:
+ parameter <code class="computeroutput">Exponent</code> can
+ be any signed integer type, but note that <code class="computeroutput">MinExponent</code>
+ and <code class="computeroutput">MaxExponent</code> can not
+ go right up to the limits of the <code class="computeroutput">Exponent</code>
+ type as there has to be a little extra headroom for internal calculations.
+ You will get a compile time error if if this is the case. In addition if
+ MinExponent or MaxExponent are zero, then the library will choose suitable
+ values that are as large as possible given the constraints of the type
+ and need for extra headhoom for internal calculations.
+ 
+
+ There is full standard library and <code class="computeroutput">numeric_limits</code>
+ support available for this type.
+ 
+
+ Things you should know when using this type:
+ 
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+ Default constructed <code class="computeroutput">cpp_bin_float</code>s
+ have a value of zero.
+ </li>
+<li class="listitem">
+ The radix of this type is 2, even when the precision is specified as
+ decimal digits.
+ </li>
+<li class="listitem">
+ The type supports both infinities and NaN's. An infinity is generated
+ whenever the result would overflow, and a NaN is generated for any
+ mathematically undefined operation.
+ </li>
+<li class="listitem">
+ There is a <code class="computeroutput">std::numeric_limits</code> specialisation for
+ this type.
+ </li>
+<li class="listitem">
+ Any <code class="computeroutput">number</code> instantiated
+ on this type, is convertible to any other <code class="computeroutput">number</code>
+ instantiated on this type - for example you can convert from <code class="computeroutput">number<cpp_bin_float<50> ></code> to <code class="computeroutput">number<cpp_bin_float<SomeOtherValue> ></code>.
+ Narrowing conversions round to nearest and are <code class="computeroutput">explicit</code>.
+ </li>
+<li class="listitem">
+ Conversion from a string results in a <code class="computeroutput">std::runtime_error</code>
+ being thrown if the string can not be interpreted as a valid floating
+ point number.
+ </li>
+<li class="listitem">
+ All arithmetic operations are correctly rounded to nearest. String
+ comversions and the <code class="computeroutput">sqrt</code>
+ function are also correctly rounded, but transcendental functions (sin,
+ cos, pow, exp etc) are not.
+ </li>
+</ul></div>
+<h6>
+<a name="boost_multiprecision.tut.floats.cpp_bin_float.h0"></a>
+ <a name="boost_multiprecision.tut.floats.cpp_bin_float.cpp_bin_float_example"></a><a class="link" href="cpp_bin_float.html#boost_multiprecision.tut.floats.cpp_bin_float.cpp_bin_float_example">cpp_bin_float
+ example:</a>
+ </h6>
+<pre class="programlisting">#include <boost/multiprecision/cpp_bin_float.hpp>
+
+using namespace boost::multiprecision;
+
+// Operations at fixed precision and full numeric_limits support:
+cpp_bin_float_100 b = 2;
+std::cout << std::numeric_limits<cpp_bin_float_100>::digits << std::endl;
+std::cout << std::numeric_limits<cpp_bin_float_100>::digits10 << std::endl;
+// We can use any C++ std lib function, lets print all the digits as well:
+std::cout << std::setprecision(std::numeric_limits<cpp_bin_float_100>::max_digits10)
+ << log(b) << std::endl; // print log(2)
+// We can also use any function from Boost.Math:
+std::cout << boost::math::tgamma(b) << std::endl;
+// These even work when the argument is an expression template:
+std::cout << boost::math::tgamma(b * b) << std::endl;
+// And since we have an extended exponent range we can generate some really large 
+// numbers here (4.0238726007709377354370243e+2564):
+std::cout << boost::math::tgamma(cpp_bin_float_100(1000)) << std::endl;
+</pre>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../floats.html"><img src="../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.html"><img src="../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../images/home.png" alt="Home"></a><a accesskey="n" href="cpp_dec_float.html"><img src="../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/input_output.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/input_output.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,176 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Input Output</title>
+<link rel="stylesheet" href="../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../tut.html" title="Tutorial">
+<link rel="prev" href="limits/limits32.html" title="Numeric limits for 32-bit platform">
+<link rel="next" href="../ref.html" title="Reference">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="limits/limits32.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="../ref.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_multiprecision.tut.input_output"></a><a class="link" href="input_output.html" title="Input Output">Input Output</a>
+</h3></div></div></div>
+<h5>
+<a name="boost_multiprecision.tut.input_output.h0"></a>
+ <a name="boost_multiprecision.tut.input_output.loopback_testing"></a><a class="link" href="input_output.html#boost_multiprecision.tut.input_output.loopback_testing">Loopback
+ testing</a>
+ </h5>
+
+ or refers to writing out a value as a decimal digit string using <code class="computeroutput">std::iostream</code>,
+ usually to a <code class="computeroutput">std::stringstream</code>, and then reading the string
+ back in to another value, and confirming that the two values are identical.
+ A trivial example using <code class="computeroutput">float</code>
+ is:
+ 
+<pre class="programlisting">float write; // Value to round-trip.
+std::stringstream ss; // Read and write std::stringstream.
+ss.precision(std::numeric_limits<T>::max_digits10); // Ensure all potentially significant bits are output.
+ss.flags(std::ios_base::fmtflags(std::ios_base::scientific)); // Use scientific format.
+ss << write; // Output to string.
+float read; // Expected.
+ss >> read; // Read decimal digits string from stringstream.
+BOOST_CHECK_EQUAL(write, read); // Should be the same.
+</pre>
+
+ and this can be run in a look for all possible values of a 32-bit float.
+ For other floating-point types <code class="computeroutput">T</code>,
+ including built-in <code class="computeroutput">double</code>, it
+ takes far too long to test all values, so a reasonable test strategy is to
+ use a large number of random values.
+ 
+<pre class="programlisting">T write;
+std::stringstream ss;
+ss.precision(std::numeric_limits<T>::max_digits10); // Ensure all potentially significant bits are output.
+ss.flags(f); // Changed from default iostream format flags if desired.
+ss << write; // Output to stringstream.
+
+T read;
+ss >> read; // Get read using operator>> from stringstream.
+BOOST_CHECK_EQUAL(read, write);
+
+read = static_cast<T>(ss.str()); // Get read by converting from decimal digits string representation of write.
+BOOST_CHECK_EQUAL(read, write);
+
+read = static_cast<T>(write.str(0, f)); // Get read using format specified when written.
+BOOST_CHECK_EQUAL(read, write);
+</pre>
+
+ The test at <img src="boost:/multiprecision.cpp_bin_float/libs/multiprecision/test/test_cpp_bin_float_io.cpp%20test_cpp_bin_float_io.cpp">
+ allows any floating-point type to be using a wide range of fairly random
+ values. It also includes tests compared a collection of <img src="boost:libs/multiprecision/test/string_data.ipp%20stringdata">
+ test cases in a file.
+ 
+<h5>
+<a name="boost_multiprecision.tut.input_output.h1"></a>
+ <a name="boost_multiprecision.tut.input_output.comparing_with_output_using_buil"></a><a class="link" href="input_output.html#boost_multiprecision.tut.input_output.comparing_with_output_using_buil">Comparing
+ with output using Built-in types</a>
+ </h5>
+
+ One can make some comparisons with the output of
+ 
+<pre class="programlisting"><number<cpp_bin_float<53> >
+</pre>
+
+ which has the same number of significant bits (53) as 64-bit double precision
+ floating-point.
+ 
+
+ However, although most outputs are identical, but there are differences on
+ some platforms caused by the implementation-dependent behaviours allowed
+ by the C99 specification <a href="http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf" target="_top">C99
+ ISO/IEC 9899:TC2</a>, incorporated by C++.
+ 
+
+ "For e, E, f, F, g, and G conversions, if the number of significant
+ decimal digits is at most DECIMAL_DIG, then the result should be correctly
+ rounded. If the number of significant decimal digits is more than DECIMAL_DIG
+ but the source value is exactly representable with DECIMAL_DIG digits, then
+ the result should be an exact representation with trailing zeros. Otherwise,
+ the source value is bounded by two adjacent decimal strings L < U, both
+ having DECIMAL_DIG significant digits; the value of the resultant decimal
+ string D should satisfy L<= D <= U, with the extra stipulation that
+ the error should have a correct sign for the current rounding direction."
+ 
+
+ So not only is correct rounding for the full number of digits not required,
+ but even if the optional recomended practice
+ is followed, then the value of these last few digits is unspecified as long
+ as the value is within certain bounds.
+ 
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+ Do not expect the output from different platforms to be identical,
+ but <code class="computeroutput">cpp_dec_float</code>, <code class="computeroutput">cpp_bin_float</code> (and other backends) outputs
+ should be correctly rounded to the number of digits requested by the set
+ precision and format.
+ </td></tr>
+</table></div>
+<h5>
+<a name="boost_multiprecision.tut.input_output.h2"></a>
+ <a name="boost_multiprecision.tut.input_output.macro_boost_mp_min_exponent_digi"></a><a class="link" href="input_output.html#boost_multiprecision.tut.input_output.macro_boost_mp_min_exponent_digi">Macro
+ BOOST_MP_MIN_EXPONENT_DIGITS</a>
+ </h5>
+
+ <a href="http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf" target="_top">C99
+ Standard</a> for format specifiers, 7.19.6 Formatted input/output functions
+ requires:
+ 
+
+ "The exponent always contains at least two digits, and only as many
+ more digits as necessary to represent the exponent."
+ 
+
+ So to conform to the C99 standard (incorporated by C++)
+ 
+<pre class="programlisting">#define BOOST_MP_MIN_EXPONENT_DIGITS 2
+</pre>
+
+ Confusingly, Microsoft (and MinGW) do not conform to this standard and provide
+ at least three digits, for example <code class="computeroutput">1e+001</code>. So if you want the output to match
+ the format output using built-in floating-point types, or to make output
+ the same for all platforms like GCC and Clang, then you need to override
+ the above definition:
+ 
+<pre class="programlisting">#ifdef MSC_VER
+# define BOOST_MP_MIN_EXPONENT_DIGITS 3
+#endif
+</pre>
+
+ Also useful to get the minimum exponent field width is
+ 
+<pre class="programlisting"># define BOOST_MP_MIN_EXPONENT_DIGITS 1
+</pre>
+
+ producing a compact output like <code class="computeroutput">2e+4</code>,
+ useful when conserving space is important.
+ 
+
+ Larger values are also supported, for example, value 4 for <code class="computeroutput">2e+0004</code> which may be useful to ensure that
+ columns line up.
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="limits/limits32.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="../ref.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,33 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>std::numeric_limits<> constants</title>
+<link rel="stylesheet" href="../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../implementation.html" title="Notes on Implementation of std::numeric_limits">
+<link rel="prev" href="../implementation.html" title="Notes on Implementation of std::numeric_limits">
+<link rel="next" href="constants/is_specialized.html" title="is_specialized">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="../implementation.html"><img src="../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../implementation.html"><img src="../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../images/home.png" alt="Home"></a><a accesskey="n" href="constants/is_specialized.html"><img src="../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section"><div class="titlepage"><div><div><h5 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.constants"></a><a class="link" href="constants.html" title="std::numeric_limits<> constants">std::numeric_limits<>
+ constants</a>
+</h5></div></div></div></div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../implementation.html"><img src="../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../implementation.html"><img src="../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../images/home.png" alt="Home"></a><a accesskey="n" href="constants/is_specialized.html"><img src="../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/bound.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/bound.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,51 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>is_bounded</title>
+<link rel="stylesheet" href="../../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../constants.html" title="std::numeric_limits<> constants">
+<link rel="prev" href="exact.html" title="is_exact">
+<link rel="next" href="modulo.html" title="is_modulo">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="exact.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="modulo.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.constants.bound"></a><a class="link" href="bound.html" title="is_bounded">is_bounded</a>
+</h6></div></div></div>
+
+ <code class="computeroutput">std::numeric_limits<T>::is_bounded ==
+ true</code> if the set of values represented
+ by the type <code class="computeroutput">T</code> is finite.
+ 
+
+ This is <code class="computeroutput">true</code> for all built-in
+ integer, fixed and floating-point types, and most multi-precision types.
+ 
+
+ It is only <code class="computeroutput">false</code> for a
+ few <a href="http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic" target="_top">arbitrary
+ precision</a> types like <code class="computeroutput">cpp_int</code>.
+ 
+
+ Rational and fixed-exponent representations are exact but not integer.
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="exact.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="modulo.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/denorm_loss.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/denorm_loss.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,48 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>has_denorm_loss</title>
+<link rel="stylesheet" href="../../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../constants.html" title="std::numeric_limits<> constants">
+<link rel="prev" href="round_style.html" title="round_style">
+<link rel="next" href="denorm_style.html" title="denorm_style">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="round_style.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="denorm_style.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.constants.denorm_loss"></a><a class="link" href="denorm_loss.html" title="has_denorm_loss">has_denorm_loss</a>
+</h6></div></div></div>
+
+ <code class="computeroutput">true</code> if a loss of precision
+ is detected as a denormalization
+ loss, rather than an inexact result.
+ 
+
+ Always <code class="computeroutput">false</code> for integer
+ types.
+ 
+
+ <code class="computeroutput">false</code> for all types which
+ do not have <code class="computeroutput">has_denorm</code>
+ == <code class="computeroutput">std::denorm_present</code>.
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="round_style.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="denorm_style.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/denorm_style.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/denorm_style.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,60 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>denorm_style</title>
+<link rel="stylesheet" href="../../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../constants.html" title="std::numeric_limits<> constants">
+<link rel="prev" href="denorm_loss.html" title="has_denorm_loss">
+<link rel="next" href="tinyness.html" title="Tinyness before rounding">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="denorm_loss.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="tinyness.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.constants.denorm_style"></a><a class="link" href="denorm_style.html" title="denorm_style">denorm_style</a>
+</h6></div></div></div>
+
+ <a href="http://en.wikipedia.org/wiki/Denormal_number" target="_top">Denormalized
+ values</a> are representations with a variable number of exponent
+ bits that can permit gradual underflow, so that, if type T is <code class="computeroutput">double</code>.
+ 
+<pre class="programlisting">std::numeric_limits<T>::denorm_min() < std::numeric_limits<T>::min()
+</pre>
+
+ A type may have any of the following <code class="computeroutput">enum
+ float_denorm_style</code> values:
+ 
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+ <code class="computeroutput">std::denorm_absent</code>, if it does not
+ allow denormalized values. (Always used for all integer and exact
+ types).
+ </li>
+<li class="listitem">
+ <code class="computeroutput">std::denorm_present</code>, if the floating-point
+ type allows denormalized values.
+ </li>
+<li class="listitem">
+ <code class="computeroutput">std::denorm_indeterminate</code>, if indeterminate
+ at compile time.
+ </li>
+</ul></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="denorm_loss.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="tinyness.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/digits.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/digits.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,78 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>digits</title>
+<link rel="stylesheet" href="../../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../constants.html" title="std::numeric_limits<> constants">
+<link rel="prev" href="radix.html" title="radix">
+<link rel="next" href="digits10.html" title="digits10">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="radix.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="digits10.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.constants.digits"></a><a class="link" href="digits.html" title="digits">digits</a>
+</h6></div></div></div>
+
+ The number of <code class="computeroutput">radix</code>
+ digits that be represented without change:
+ 
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+ for integer types, the number of non-sign
+ bits in the significand.
+ </li>
+<li class="listitem">
+ for floating types, the number of radix digits
+ in the significand.
+ </li>
+</ul></div>
+
+ The values include any implicit bit, so for example, for the ubiquious
+ <code class="computeroutput">double</code> using 64 bits (<a href="http://en.wikipedia.org/wiki/Double_precision_floating-point_format" target="_top">IEEE
+ binary64 </a>), <code class="computeroutput">digits</code>
+ == 53, even though there are only 52 actual bits of the significand
+ stored in the representation. The value of <code class="computeroutput">digits</code>
+ reflects the fact that there is one implicit bit which is always set
+ to 1.
+ 
+
+ The Boost.Multiprecision binary types do not use an implicit bit, so
+ the <code class="computeroutput">digits</code> member reflects
+ exactly how many bits of precision were requested:
+ 
+<pre class="programlisting">typedef number<cpp_bin_float<53, digit_base_2> > float64;
+typedef number<cpp_bin_float<113, digit_base_2> > float128;
+std::numeric_limits<float64>::digits == 53.
+std::numeric_limits<float128>::digits == 113.
+</pre>
+
+ For the most common case of <code class="computeroutput">radix
+ == 2</code>,
+ <code class="computeroutput">std::numeric_limits<T>::digits</code> is the number of bits in the
+ representation, not counting any sign bit.
+ 
+
+ For a decimal integer type, when <code class="computeroutput">radix
+ == 10</code>,
+ it is the number of decimal digits.
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="radix.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="digits10.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/digits10.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/digits10.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,179 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>digits10</title>
+<link rel="stylesheet" href="../../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../constants.html" title="std::numeric_limits<> constants">
+<link rel="prev" href="digits.html" title="digits">
+<link rel="next" href="max_digits10.html" title="max_digits10">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="digits.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="max_digits10.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.constants.digits10"></a><a class="link" href="digits10.html" title="digits10">digits10</a>
+</h6></div></div></div>
+
+ Constant <code class="computeroutput">std::numeric_limits<T>::digits</code> returns the
+ 
+
+ Number of decimal digits that can be represented without change or
+ loss.
+ 
+
+ For example, <code class="computeroutput">numeric_limits<unsigned
+ char>::digits10</code> is 2.
+ 
+
+ This somewhat inscrutable definition means that an <code class="computeroutput">unsigned
+ char</code> can hold decimal values
+ <code class="computeroutput">0..99</code> without loss of precision or accuracy,
+ usually from truncation.
+ 
+
+ If it were 3 it could hold 0..999,
+ but as we all know, an 8-bit <code class="computeroutput">unsigned
+ char</code> can only hold 0..255, and
+ an attempt to store 256 or more will involve loss or change.
+ 
+
+ In practice, one gets noisy warnings about truncation and the result
+ is zero.
+ 
+
+ Somewhat confusingly, some 3-digit numbers can be stored, for example
+ 255.
+ 
+
+ For bounded integers, it is thus one less
+ than number of decimal digits you need to display the biggest integer
+ <code class="computeroutput">std::numeric_limits<T>::max()</code>.
+ This value can be used to predict the layout width required for
+ 
+<pre class="programlisting">std::cout
+ << std::setw(std::numeric_limits<short>::digits10 +1 +1) // digits10+1, and +1 for sign.
+ << std::showpos << (std::numeric_limits<short>::max)() // +32767
+ << std::endl
+ << std::setw(std::numeric_limits<short>::digits10 +1 +1)
+ << (std::numeric_limits<short>::min)() << std::endl; // -32767
+</pre>
+
+ For example, <code class="computeroutput">unsigned short</code> is often stored in 16 bits, so
+ the maximum value is 0xFFFF or 65535.
+ 
+<pre class="programlisting">std::cout
+ << std::setw(std::numeric_limits<unsigned short>::digits10 +1 +1) // digits10+1, and +1 for sign.
+ << std::showpos << (std::numeric_limits<unsigned short>::max)() // 65535
+ << std::endl
+ << std::setw(std::numeric_limits<unsigned short>::digits10 +1 +1) // digits10+1, and +1 for sign.
+ << (std::numeric_limits<unsigned short>::min)() << std::endl; // 0
+</pre>
+
+ For bounded floating-point types, if we create a <code class="computeroutput">double</code>
+ with a value with <code class="computeroutput">digits10</code>
+ (usually 15) decimal digits, <code class="computeroutput">1e15</code>
+ or <code class="computeroutput">1000000000000000</code> :
+ 
+<pre class="programlisting">std::cout.precision(std::numeric_limits<double>::max_digits10);
+double d = 1e15;
+double dp1 = d+1;
+std::cout << d << "\n" << dp1 << std::endl;
+// 1000000000000000
+// 1000000000000001
+std::cout << dp1 - d << std::endl; // 1
+</pre>
+
+ and we can increment this value to <code class="computeroutput">1000000000000001</code>
+ as expected and show the difference too.
+ 
+
+ But if we try to repeat this with more than <code class="computeroutput">digits10</code>
+ digits,
+ 
+<pre class="programlisting">std::cout.precision(std::numeric_limits<double>::max_digits10);
+double d = 1e16;
+double dp1 = d+1;
+std::cout << d << "\n" << dp1 << std::endl;
+// 10000000000000000
+// 10000000000000000
+ std::cout << dp1 - d << std::endl; // 0 !!!
+</pre>
+
+ then we find that when we add one it has no effect, and display show
+ that there is loss of precision. See <a href="http://en.wikipedia.org/wiki/Loss_of_significance" target="_top">Loss
+ of significance or cancellation error</a>.
+ 
+
+ So <code class="computeroutput">digits10</code> is the
+ number of decimal digits guaranteed
+ to be correct.
+ 
+
+ For example, 'round-tripping' for <code class="computeroutput">double</code>:
+ 
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+ If a decimal string with at most <code class="computeroutput">digits10</code>(
+ == 15) significant decimal digits is converted to <code class="computeroutput">double</code> and then converted back to
+ the same number of significant decimal digits, then the final string
+ will match the original 15 decimal digit string.
+ </li>
+<li class="listitem">
+ If a <code class="computeroutput">double</code> floating-point
+ number is converted to a decimal string with at least 17 decimal
+ digits and then converted back to <code class="computeroutput">double</code>,
+ then the result will be binary indentical to the original <code class="computeroutput">double</code> value.
+ </li>
+</ul></div>
+
+ For most purposes, you will much more likely want <code class="computeroutput">std::numeric_limits<>::max_digits10</code>,
+ the number of decimal digits that ensure that a change of one least
+ significant bit (ULP) produces a different decimal digits string.
+ 
+
+ For nearly all floating-point types, <code class="computeroutput">max_digits10</code>
+ is <code class="computeroutput">digits10+2</code>, but you should use <code class="computeroutput">max_digits10</code>
+ where possible.
+ 
+
+ If <code class="computeroutput">max_digits10</code> is
+ not available, you should using the <a href="http://www.cs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF" target="_top">Kahan
+ formula for floating-point type T</a>
+ 
+<pre class="programlisting">max_digits10 = std::numeric_limits<T>::digits * 3010U/10000U;
+</pre>
+
+ The factor is log10(2) = 0.3010 but must be evaluated at compile time
+ using only integers.
+ 
+
+ (See also <a href="http://www.loria.fr/~zimmerma/mca/mca-cup-0.5.9.pdf" target="_top">Richard
+ P. Brent and Paul Zimmerman, Modern Computer Arithmetic</a> Equation
+ 3.8 on page 116.).
+ 
+
+ The extra two (or 3) least significant digits are 'noisy' and may be
+ junk, but if you want to 'round-trip' - printing a value out and reading
+ it back in - you must use <code class="computeroutput">os.precision(std::numeric_limits<T>::max_digits10)</code>. For at least one popular compiler,
+ you must also use <code class="computeroutput">std::scientific</code>
+ format.
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="digits.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="max_digits10.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/exact.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/exact.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,87 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>is_exact</title>
+<link rel="stylesheet" href="../../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../constants.html" title="std::numeric_limits<> constants">
+<link rel="prev" href="signed.html" title="is_signed">
+<link rel="next" href="bound.html" title="is_bounded">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="signed.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="bound.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.constants.exact"></a><a class="link" href="exact.html" title="is_exact">is_exact</a>
+</h6></div></div></div>
+
+ <code class="computeroutput">std::numeric_limits<T>::is_exact ==
+ true</code> if type T uses exact representations.
+ 
+
+ This is defined as <code class="computeroutput">true</code>
+ for all integer types and <code class="computeroutput">false</code>
+ for floating-point types.
+ 
+
+ <a href="http://stackoverflow.com/questions/14203654/stdnumeric-limitsis-exact-what-is-a-usable-definition" target="_top">A
+ usable definition</a> has been discussed.
+ 
+
+ ISO/IEC 10967-1, Language independent arithmetic, noted by the C++
+ Standard defines
+ 
+<pre class="programlisting">A floating point type F shall be a finite subset of [real].
+</pre>
+
+ The important practical distinction is that all integers (up to <code class="computeroutput">max()</code>)
+ can be stored exactly.
+ 
+
+ Rational
+ types using two integer types are also exact.
+ 
+
+ Floating-point types cannot store all real values
+ (those in the set of ℜ) exactly. For
+ example, 0.5 can be stored exactly in a binary floating-point, but
+ 0.1 cannot. What is stored is the nearest representable real value,
+ that is, rounded to nearest.
+ 
+
+ Fixed-point types (usually decimal) are also defined as exact, in that
+ they only store a fixed precision,
+ so half cents or pennies (or less) cannot be stored. The results of
+ computations are rounded up or down, just like the result of integer
+ division stored as an integer result.
+ 
+
+ There are number of proposals to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3407.html" target="_top">add
+ Decimal Floating Point Support to C++</a>.
+ 
+
+ <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2849.pdf" target="_top">Decimal
+ TR</a>.
+ 
+
+ And also <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3352.html" target="_top">C++
+ Binary Fixed-Point Arithmetic</a>.
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="signed.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="bound.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/infinity.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/infinity.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,57 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>infinity</title>
+<link rel="stylesheet" href="../../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../constants.html" title="std::numeric_limits<> constants">
+<link rel="prev" href="is_specialized.html" title="is_specialized">
+<link rel="next" href="signed.html" title="is_signed">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="is_specialized.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="signed.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.constants.infinity"></a><a class="link" href="infinity.html" title="infinity">infinity</a>
+</h6></div></div></div>
+
+ For floating-point types, ∞ is defined whereever possible, but clearly
+ infinity is meaningless for <a href="http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic" target="_top">arbitrary
+ precision</a> arithmetic backends, and there is one floating point
+ type (GMP's <code class="computeroutput">mpf_t</code>,
+ see <a class="link" href="../../../floats/gmp_float.html" title="gmp_float">gmp_float</a>)
+ which has no notion of infinity or NaN at all.
+ 
+
+ A typical test whether infinity is implemented is
+ 
+<pre class="programlisting">if(std::numeric_limits<T>::has_infinity)
+{
+ std::cout << std::numeric_limits<T>::infinity() << std::endl;
+}
+</pre>
+
+ and using tests like this is strongly recommended to improve portability.
+ 
+
+ If the backend is switched to a type that does not support infinity
+ then, without checks like this, there will be trouble.
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="is_specialized.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="signed.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/is_bounded.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/is_bounded.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,44 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>is_bounded</title>
+<link rel="stylesheet" href="../../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../constants.html" title="std::numeric_limits<> constants">
+<link rel="prev" href="modulo.html" title="is_modulo">
+<link rel="next" href="radix.html" title="radix">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="modulo.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="radix.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.constants.is_bounded"></a><a class="link" href="is_bounded.html" title="is_bounded">is_bounded</a>
+</h6></div></div></div>
+
+ Constant <code class="computeroutput">std::numeric_limits<T>::is_bounded</code> is true if there is a
+ limit to values that can be stored.
+ 
+
+ This is obviously true for all built-in integer, fixed and floating-point
+ types, but will be false for <a href="http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic" target="_top">arbitrary
+ precision</a> integer (for example <code class="computeroutput">cpp_int</code>)
+ and floating-point types because these expand until memory is exhausted.
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="modulo.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="radix.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/is_specialized.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/is_specialized.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,65 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>is_specialized</title>
+<link rel="stylesheet" href="../../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../constants.html" title="std::numeric_limits<> constants">
+<link rel="prev" href="../constants.html" title="std::numeric_limits<> constants">
+<link rel="next" href="infinity.html" title="infinity">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="../constants.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="infinity.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.constants.is_specialized"></a><a class="link" href="is_specialized.html" title="is_specialized">is_specialized</a>
+</h6></div></div></div>
+
+ <code class="computeroutput">true</code> for all arithmetic
+ types (integer, floating and fixed-point) for which <code class="computeroutput">std::numeric_limits<T>::numeric_limits</code>
+ is specialized.
+ 
+
+ A typical test is
+ 
+<pre class="programlisting">if (std::numeric_limits<T>::is_specialized == false)
+{
+ std::cout << "type " << typeid(T).name() << " is not specialized for std::numeric_limits!" << std::endl;
+// ...
+}
+</pre>
+
+ Typically <code class="computeroutput">numeric_limits<T>::is_specialized</code>
+ is <code class="computeroutput">true</code> for all <code class="computeroutput">T</code> where the compile-time constant
+ members of <code class="computeroutput">numeric_limits</code>
+ are indeed known at compile time, and don't vary at runtime. For example
+ floating point types with runtime-variable precision such as <code class="computeroutput">mpfr_float</code> have no <code class="computeroutput">numeric_limits</code> specialization as
+ it would be impossible to define all the members at compile time. In
+ contrast the precision of a type such as <code class="computeroutput">mpfr_float_50</code>
+ is known at compile time, and so it does have
+ a <code class="computeroutput">numeric_limits</code> specialization.
+ 
+
+ Note that not all the <code class="computeroutput">std::numeric_limits</code>
+ member constants and functions are meaningful for all user-defined
+ types (UDT), such as the decimal and binary multiprecision types provided
+ here. More information on this is given in the sections below.
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../constants.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="infinity.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/max_digits10.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/max_digits10.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,166 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>max_digits10</title>
+<link rel="stylesheet" href="../../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../constants.html" title="std::numeric_limits<> constants">
+<link rel="prev" href="digits10.html" title="digits10">
+<link rel="next" href="round_style.html" title="round_style">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="digits10.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="round_style.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.constants.max_digits10"></a><a class="link" href="max_digits10.html" title="max_digits10">max_digits10</a>
+</h6></div></div></div>
+
+ <code class="computeroutput">std::numeric_limits<T>::max_digits10</code> was added for floating-point
+ because <code class="computeroutput">digits10</code> decimal
+ digits are insufficient to show a least significant bit (ULP) change
+ giving puzzling displays like
+ 
+<pre class="programlisting">0.666666666666667 != 0.666666666666667
+</pre>
+
+ from failure to 'round-trip', for example:
+ 
+<pre class="programlisting">double write = 2./3; // Any arbitrary value that cannot be represented exactly.
+double read = 0;
+std::stringstream s;
+s.precision(std::numeric_limits<double>::digits10); // or `float64_t` for 64-bit IEE754 double.
+s << write;
+s >> read;
+if(read != write)
+{
+ std::cout << std::setprecision(std::numeric_limits<double>::digits10)
+ << read << " != " << write << std::endl;
+}
+</pre>
+
+ If you wish to ensure that a change of one least significant bit (ULP)
+ produces a different decimal digits string, then <code class="computeroutput">max_digits10</code>
+ is the precision to use.
+ 
+
+ For example:
+ 
+<pre class="programlisting">double pi = boost::math::double_constants::pi;
+std::cout.precision(std::numeric_limits<double>::max_digits10);
+std::cout << pi << std::endl; // 3.1415926535897931
+</pre>
+
+ will display π to the maximum possible precision using a <code class="computeroutput">double</code>.
+ 
+
+ and similarly for a much higher precision type:
+ 
+<pre class="programlisting">using namespace boost::multiprecision;
+
+typedef number<cpp_dec_float<50> > cpp_dec_float_50; // 50 decimal digits.
+
+using boost::multiprecision::cpp_dec_float_50;
+
+cpp_dec_float_50 pi = boost::math::constants::pi<cpp_dec_float_50>();
+std::cout.precision(std::numeric_limits<cpp_dec_float_50>::max_digits10);
+std::cout << pi << std::endl;
+// 3.141592653589793238462643383279502884197169399375105820974944592307816406
+</pre>
+
+ For integer types, <code class="computeroutput">max_digits10</code>
+ is implementation-dependant, but is usually <code class="computeroutput">digits10
+ + 2</code>.
+ This is the output field width required for the maximum value of the
+ type T <code class="computeroutput">std::numeric_limits<T>::max()</code>
+ including a sign and a space.
+ 
+
+ So this will produce neat columns.
+ 
+<pre class="programlisting">std::cout << std::setw(std::numeric_limits<int>::max_digits10) ...
+</pre>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+ For Microsoft Visual Studio 2010, <code class="computeroutput">std::numeric_limits<float>::max_digits10</code>
+ is wrongly defined as 8. It should be 9.
+ </td></tr>
+</table></div>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+
+ For Microsoft Visual Studio, and default float format, a small range
+ of values approximately 0.0001 to 0.004, with exponent values of
+ 3f2 to 3f6, are wrongly input by one least significant bit, probably
+ every third value of significand.
+ 
+
+ A workaround is using scientific or exponential format <code class="computeroutput"><< std::scientific</code>.
+ 
+</td></tr>
+</table></div>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+ BOOST_NO_NUMERIC_LIMITS_LOWEST is a suitable proxy to determine if
+ <code class="computeroutput">std::numeric_limits<float>::max_digits10</code> is implemented on
+ any platform. If <code class="computeroutput">max_digits10</code>
+ is not available, you should using the <a href="http://www.cs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF" target="_top">Kahan
+ formula for floating-point type T</a>. See above.
+ </td></tr>
+</table></div>
+
+ For example, to be portable, including older platforms:
+ 
+<pre class="programlisting"> typedef float T; // Any type: `double`, cpp_dec_float_50, bin_128bit_double_type ...
+
+#if defined(BOOST_NO_NUMERIC_LIMITS_LOWEST)
+ std::cout.precision(2 + std::numeric_limits<T>::digits * 3010U/10000U);
+#else
+# if (_MSC_VER <= 1600) // Correct wrong value for float.
+ std::cout.precision(2 + std::numeric_limits<T>::digits * 3010U/10000U);
+# else
+ std::cout.precision(std::numeric_limits<T>::max_digits10);
+# endif
+#endif
+
+ std::cout << "std::cout.precision = " << std::cout.precision() << std::endl;
+
+ double x = 1.2345678901234567889;
+
+ std::cout << "x = " << x << std::endl; //
+</pre>
+
+ which should output:
+ 
+<pre class="programlisting">std::cout.precision = 9
+x = 1.23456789
+</pre>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="digits10.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="round_style.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/modulo.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/modulo.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,81 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>is_modulo</title>
+<link rel="stylesheet" href="../../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../constants.html" title="std::numeric_limits<> constants">
+<link rel="prev" href="bound.html" title="is_bounded">
+<link rel="next" href="radix.html" title="radix">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="bound.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="radix.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.constants.modulo"></a><a class="link" href="modulo.html" title="is_modulo">is_modulo</a>
+</h6></div></div></div>
+
+ <code class="computeroutput">std::numeric_limits<T>::is_modulo</code> is defined as <code class="computeroutput">true</code> if adding two positive values of
+ type T can yield a result less than either value.
+ 
+
+ <code class="computeroutput">is_modulo ==
+ true</code> means that the type does
+ not overflow, but, for example, 'wraps around' to zero, when adding
+ one to the <code class="computeroutput">max()</code>
+ value.
+ 
+
+ For most built-in integer types, <code class="computeroutput">std::numeric_limits<>::is_modulo</code>
+ is <code class="computeroutput">true</code>.
+ 
+
+ <code class="computeroutput">bool</code> is the only exception.
+ 
+
+ The modulo behaviour is sometimes useful, often irrelevent (with 32
+ or more bit integers), but also can be unexpected, and sometimes undesired,
+ behaviour.
+ 
+
+ Overflow of signed integers can be especially unexpected, possibly
+ causing change of sign.
+ 
+
+ Boost.Multiprecision integer type <code class="computeroutput">cpp_int</code>
+ is not modulo because as an <a href="http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic" target="_top">arbitrary
+ precision</a> types, it expands to hold any value that the machine
+ resources permit.
+ 
+
+ However fixed precision <a class="link" href="../../../ints/cpp_int.html" title="cpp_int">cpp_int</a>'s
+ may be modulo if they are unchecked (i.e. they behave just like built
+ in integers), but not if they are checked (overflow causes an exception
+ to be raised).
+ 
+
+ Built-in and multi-precision floating-point types are normally not
+ modulo.
+ 
+
+ Where possible, overflow is to <code class="computeroutput">std::numeric_limits<>::infinity()</code>, provided <code class="computeroutput">std::numeric_limits<>::has_infinity
+ == true</code>.
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="bound.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="radix.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/radix.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/radix.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,38 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>radix</title>
+<link rel="stylesheet" href="../../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../constants.html" title="std::numeric_limits<> constants">
+<link rel="prev" href="modulo.html" title="is_modulo">
+<link rel="next" href="digits.html" title="digits">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="modulo.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="digits.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.constants.radix"></a><a class="link" href="radix.html" title="radix">radix</a>
+</h6></div></div></div>
+
+ Constant <code class="computeroutput">std::numeric_limits<T>::radix</code> returns either 2 (for built-in
+ and binary types) or 10 (for decimal types).
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="modulo.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="digits.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/round_style.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/round_style.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,81 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>round_style</title>
+<link rel="stylesheet" href="../../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../constants.html" title="std::numeric_limits<> constants">
+<link rel="prev" href="max_digits10.html" title="max_digits10">
+<link rel="next" href="denorm_loss.html" title="has_denorm_loss">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="max_digits10.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="denorm_loss.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.constants.round_style"></a><a class="link" href="round_style.html" title="round_style">round_style</a>
+</h6></div></div></div>
+
+ The rounding style determines how the result of floating-point operations
+ is treated when the result cannot be exactly
+ represented in the significand. Various rounding modes may
+ be provided:
+ 
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+ round to nearest up or down (default for floating-point types).
+ </li>
+<li class="listitem">
+ round up (toward positive infinity).
+ </li>
+<li class="listitem">
+ round down (toward negative infinity).
+ </li>
+<li class="listitem">
+ round toward zero (integer types).
+ </li>
+<li class="listitem">
+ no rounding (if decimal radix).
+ </li>
+<li class="listitem">
+ rounding mode is not determinable.
+ </li>
+</ul></div>
+
+ For integer types, <code class="computeroutput">std::numeric_limits<T>::round_style</code>
+ is always towards zero, so
+ 
+<pre class="programlisting">std::numeric_limits<T>::round_style == std::round_to_zero;
+</pre>
+
+ A decimal type, <code class="computeroutput">cpp_dec_float</code>
+ rounds in no particular direction, which is to say it doesn't round
+ at all. And since there are several guard digits, it's not really the
+ same as truncation (round toward zero) either.
+ 
+
+ For floating-point types, it is normal to round to nearest.
+ 
+<pre class="programlisting">std::numeric_limits<T>::round_style == std::round_to_nearest;
+</pre>
+
+ See function <code class="computeroutput">std::numeric_limits<T>::round_error</code> for the maximum error
+ (in ULP) that rounding can cause.
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="max_digits10.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="denorm_loss.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/signed.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/signed.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,43 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>is_signed</title>
+<link rel="stylesheet" href="../../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../constants.html" title="std::numeric_limits<> constants">
+<link rel="prev" href="infinity.html" title="infinity">
+<link rel="next" href="exact.html" title="is_exact">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="infinity.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="exact.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.constants.signed"></a><a class="link" href="signed.html" title="is_signed">is_signed</a>
+</h6></div></div></div>
+
+ <code class="computeroutput">std::numeric_limits<T>::is_signed ==
+ true</code> if the type <code class="computeroutput">T</code> is signed.
+ 
+
+ For built-in binary types, the sign is held in a single bit, but for
+ other types (cpp_dec_float and cpp_bin_float) it may be a separate
+ storage element, usually <code class="computeroutput">bool</code>.
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="infinity.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="exact.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/tinyness.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/constants/tinyness.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,69 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Tinyness before rounding</title>
+<link rel="stylesheet" href="../../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../constants.html" title="std::numeric_limits<> constants">
+<link rel="prev" href="denorm_style.html" title="denorm_style">
+<link rel="next" href="../functions.html" title="std::numeric_limits<> functions">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="denorm_style.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="../functions.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.constants.tinyness"></a><a class="link" href="tinyness.html" title="Tinyness before rounding">Tinyness
+ before rounding</a>
+</h6></div></div></div>
+
+ <code class="computeroutput">bool std::numeric_limits<T>::tinyness_before</code>
+ 
+
+ <code class="computeroutput">true</code> if a type can determine
+ that a value is too small to be represent as a normalized value before
+ rounding it.
+ 
+
+ Generally true for <code class="computeroutput">is_iec559</code>
+ floating-point built-in types, but false for integer types.
+ 
+
+ Standard-compliant IEEE 754 floating-point implementations may detect
+ the floating-point underflow at three predefined moments:
+ 
+<div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+ After computation of a result with absolute value smaller than
+ <code class="computeroutput">std::numeric_limits<T>::min()</code>,
+ such implementation detects tinyness before rounding
+ (e.g. UltraSparc).
+ </li>
+<li class="listitem">
+ After rounding of the result to <code class="computeroutput">std::numeric_limits<T>::digits</code>
+ bits, if the result is tiny, such implementation detects tinyness
+ after rounding (e.g. SuperSparc).
+ </li>
+<li class="listitem">
+ If the conversion of the rounded tiny result to subnormal form
+ resulted in the loss of precision, such implementation detects
+ denorm loss.
+ </li>
+</ol></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="denorm_style.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../constants.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="../functions.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,33 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>std::numeric_limits<> functions</title>
+<link rel="stylesheet" href="../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../implementation.html" title="Notes on Implementation of std::numeric_limits">
+<link rel="prev" href="constants/tinyness.html" title="Tinyness before rounding">
+<link rel="next" href="functions/max.html" title="max function">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="constants/tinyness.html"><img src="../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../implementation.html"><img src="../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../images/home.png" alt="Home"></a><a accesskey="n" href="functions/max.html"><img src="../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section"><div class="titlepage"><div><div><h5 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.functions"></a><a class="link" href="functions.html" title="std::numeric_limits<> functions">std::numeric_limits<>
+ functions</a>
+</h5></div></div></div></div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="constants/tinyness.html"><img src="../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../implementation.html"><img src="../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../images/home.png" alt="Home"></a><a accesskey="n" href="functions/max.html"><img src="../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/NaN.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/NaN.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,160 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Not-A-Number NaN</title>
+<link rel="stylesheet" href="../../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../functions.html" title="std::numeric_limits<> functions">
+<link rel="prev" href="infinity.html" title="Infinity - positive and negative">
+<link rel="next" href="../../version_32.html" title="32-bit version information used for tables below.">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="infinity.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../functions.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="../../version_32.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.functions.NaN"></a><a class="link" href="NaN.html" title="Not-A-Number NaN">Not-A-Number
+ NaN</a>
+</h6></div></div></div>
+<h5>
+<a name="boost_multiprecision.tut.limits.implementation.functions.NaN.h0"></a>
+ <a name="boost_multiprecision.tut.limits.implementation.functions.NaN.quiet_nan"></a><a class="link" href="NaN.html#boost_multiprecision.tut.limits.implementation.functions.NaN.quiet_nan">Quiet_NaN</a>
+ </h5>
+
+ For floating-point types only, for which <code class="computeroutput">std::numeric_limits<T>::has_quiet_NaN
+ == true</code>,
+ function <code class="computeroutput">std::numeric_limits<T>::quiet_NaN()</code>
+ provides an implementation-defined representation for NaN.
+ 
+
+ NaNs are values
+ to indicate that the result of an assignment or computation is meaningless.
+ A typical example is <code class="computeroutput">0/0</code> but
+ there are many others.
+ 
+
+ NaNs may also be used, to represent missing values: for example, these
+ could, by convention, be ignored in calculations of statistics like
+ means.
+ 
+
+ Many of the problems with a representation for Not-A-Number
+ has hampered portable use, similar to those with infinity.
+ 
+
+ NaN can be used with binary multiprecision types like <code class="computeroutput">bin_float128</code>:
+ 
+<pre class="programlisting">using boost::multiprecision::bin_float128;
+
+if (std::numeric_limits<bin_float128>::has_quiet_NaN == true)
+{
+ bin_float128 tolerance = 3 * std::numeric_limits<bin_float128>::epsilon();
+
+ bin_float128 NaN = std::numeric_limits<bin_float128>::quiet_NaN();
+ std::cout << "bin_float128 NaN is " << NaN << std::endl; // bin_float128 NaN is nan
+
+ bin_float128 expected = NaN;
+ bin_float128 calculated = 2 * NaN;
+ using boost::test_tools::check_is_close;
+
+ bool r = check_is_close(expected, expected, tolerance);
+ std::cout << std::boolalpha << r << std::endl; // false, as expected because all comparisons with NaNs are false.
+
+ r = check_is_close(expected, calculated, tolerance);
+ std::cout << std::boolalpha << r << std::endl; // false, as expected because all comparisons with NaNs are false.
+}
+else
+{
+ std::cout << "Type " << typeid(bin_float128).name() << " does not have NaNs!" << std::endl;
+}
+</pre>
+
+ But using Boost.Math and suitable facets can permit portable use of
+ both NaNs and positive and negative infinity.
+ 
+
+ See boost:/libs/math/example/nonfinite_facet_sstream.cpp
+ and we also need
+ 
+<pre class="programlisting">#include <boost/math/special_functions/nonfinite_num_facets.hpp>
+</pre>
+
+ Then we can equally well use a multiprecision type bin_float128:
+ 
+<pre class="programlisting">using boost::multiprecision::bin_float128;
+
+typedef bin_float128 T;
+
+using boost::math::nonfinite_num_put;
+using boost::math::nonfinite_num_get;
+{
+ std::locale old_locale;
+ std::locale tmp_locale(old_locale, new nonfinite_num_put<char>);
+ std::locale new_locale(tmp_locale, new nonfinite_num_get<char>);
+ std::stringstream ss;
+ ss.imbue(new_locale);
+ T inf = std::numeric_limits<T>::infinity();
+ ss << inf; // Write out.
+ assert(ss.str() == "inf");
+ T r;
+ ss >> r; // Read back in.
+ assert(inf == r); // Confirms that the floating-point values really are identical.
+ std::cout << "infinity output was " << ss.str() << std::endl;
+ std::cout << "infinity input was " << r << std::endl;
+}
+</pre>
+<pre class="programlisting">infinity output was inf
+infinity input was inf
+</pre>
+
+ Similarly we can do the same with NaN (except that we cannot use <code class="computeroutput">assert</code>)
+ 
+<pre class="programlisting">{
+ std::locale old_locale;
+ std::locale tmp_locale(old_locale, new nonfinite_num_put<char>);
+ std::locale new_locale(tmp_locale, new nonfinite_num_get<char>);
+ std::stringstream ss;
+ ss.imbue(new_locale);
+ T n;
+ T NaN = std::numeric_limits<T>::quiet_NaN();
+ ss << NaN; // Write out.
+ assert(ss.str() == "nan");
+ std::cout << "NaN output was " << ss.str() << std::endl;
+ ss >> n; // Read back in.
+ assert(NaN == n); // Confirms that the floating-point values really are identical.
+ std::cout << "NaN input was " << n << std::endl;
+}
+</pre>
+
+ NaN output was nan NaN input was nan
+ 
+<h5>
+<a name="boost_multiprecision.tut.limits.implementation.functions.NaN.h1"></a>
+ <a name="boost_multiprecision.tut.limits.implementation.functions.NaN.signaling_nan"></a><a class="link" href="NaN.html#boost_multiprecision.tut.limits.implementation.functions.NaN.signaling_nan">Signaling
+ NaN</a>
+ </h5>
+
+ For floating-point types only, for which <code class="computeroutput">std::numeric_limits<T>::has_signaling_NaN
+ == true</code>,
+ function <code class="computeroutput">std::numeric_limits<T>::signaling_NaN()</code>
+ provides an implementation-defined representation for NaN that causes
+ a hardware trap. However these are not found in any popular processor
+ or platforms, if at all, and may be ignored for all practical purposes.
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="infinity.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../functions.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="../../version_32.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/denorm_min.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/denorm_min.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,65 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>denorm_min function</title>
+<link rel="stylesheet" href="../../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../functions.html" title="std::numeric_limits<> functions">
+<link rel="prev" href="min.html" title="min function">
+<link rel="next" href="round_error.html" title="round_error">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="min.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../functions.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="round_error.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.functions.denorm_min"></a><a class="link" href="denorm_min.html" title="denorm_min function">denorm_min
+ function</a>
+</h6></div></div></div>
+
+ Function <code class="computeroutput">std::numeric_limits<T>::denorm_min()</code>
+ returns the smallest <a href="http://en.wikipedia.org/wiki/Denormal_number" target="_top">denormalized
+ value</a>, provided
+ 
+<pre class="programlisting">std::numeric_limits<T>::has_denorm == std::denorm_present
+</pre>
+<pre class="programlisting">std::cout.precision(std::numeric_limits<double>::max_digits10);
+if (std::numeric_limits<double>::has_denorm == std::denorm_present)
+{
+ double d = std::numeric_limits<double>::denorm_min();
+
+ std::cout << d << std::endl; // 4.9406564584124654e-324
+
+ int exponent;
+
+ double significand = frexp(d, &exponent);
+ std::cout << "exponent = " << std::hex << exponent << std::endl; // fffffbcf
+ std::cout << "significand = " << std::hex << significand << std::endl; // 0.50000000000000000
+}
+else
+{
+ std::cout << "No denormalization. " << std::endl;
+}
+</pre>
+
+ The exponent is effectively reduced from -308 to -324 (though it remains
+ encoded as zero and leading zeros appear in the significand, thereby
+ losing precision until the significand reaches zero).
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="min.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../functions.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="round_error.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/epsilon.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/epsilon.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,197 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>epsilon</title>
+<link rel="stylesheet" href="../../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../functions.html" title="std::numeric_limits<> functions">
+<link rel="prev" href="round_error.html" title="round_error">
+<link rel="next" href="infinity.html" title="Infinity - positive and negative">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="round_error.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../functions.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="infinity.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.functions.epsilon"></a><a class="link" href="epsilon.html" title="epsilon">epsilon</a>
+</h6></div></div></div>
+
+ Function <code class="computeroutput">std::numeric_limits<T>::epsilon()</code>
+ is meaningful only for non-integral types.
+ 
+
+ It returns the difference between <code class="computeroutput">1.0</code>
+ and the next value representable by the floating-point type T. So it
+ is a one least-significant-bit change in this floating-point value.
+ 
+
+ For <code class="computeroutput">double</code> (<code class="computeroutput">float_64t</code>) it is <code class="computeroutput">2.2204460492503131e-016</code>
+ showing all possibly significant 17 decimal digits.
+ 
+<pre class="programlisting">std::cout.precision(std::numeric_limits<double>::max_digits10);
+double d = 1.;
+double eps = std::numeric_limits<double>::epsilon();
+double dpeps = d+eps;
+std::cout << std::showpoint // Ensure all trailing zeros are shown.
+ << d << "\n" // 1.0000000000000000
+ << dpeps << std::endl; // 2.2204460492503131e-016
+std::cout << dpeps - d // 1.0000000000000002
+ << std::endl;
+</pre>
+
+ We can explicitly increment by one bit using the function <code class="computeroutput">boost::math::float_next()</code>
+ and the result is the same as adding <code class="computeroutput">epsilon</code>.
+ 
+<pre class="programlisting">double one = 1.;
+double nad = boost::math::float_next(one);
+std::cout << nad << "\n" // 1.0000000000000002
+ << nad - one // 2.2204460492503131e-016
+ << std::endl;
+</pre>
+
+ Adding any smaller value, like half <code class="computeroutput">epsilon</code>,
+ will have no effect on this value.
+ 
+<pre class="programlisting">std::cout.precision(std::numeric_limits<double>::max_digits10);
+double d = 1.;
+double eps = std::numeric_limits<double>::epsilon();
+double dpeps = d + eps/2;
+
+std::cout << std::showpoint // Ensure all trailing zeros are shown.
+ << dpeps << "\n" // 1.0000000000000000
+ << eps/2 << std::endl; // 1.1102230246251565e-016
+std::cout << dpeps - d // 0.00000000000000000
+ << std::endl;
+</pre>
+
+ So this cancellation error leaves the values equal, despite adding
+ half <code class="computeroutput">epsilon</code>.
+ 
+
+ To achieve greater portability over platform and floating-point type,
+ Boost.Math and Boost.Multiprecion provide a package of functions that
+ 'do something sensible' if the standard <code class="computeroutput">numeric_limits</code>
+ is not available. To use these <code class="computeroutput">#include
+ <boost/math/tools/precision.hpp></code>.
+ 
+
+ A tolerance might be defined using this version of epsilon thus:
+ 
+<pre class="programlisting">RealType tolerance = boost::math::tools::epsilon<RealType>() * 2;
+</pre>
+<h5>
+<a name="boost_multiprecision.tut.limits.implementation.functions.epsilon.h0"></a>
+ <a name="boost_multiprecision.tut.limits.implementation.functions.epsilon.tolerance_for_floating_point_com"></a><a class="link" href="epsilon.html#boost_multiprecision.tut.limits.implementation.functions.epsilon.tolerance_for_floating_point_com">Tolerance
+ for Floating-point Comparisons</a>
+ </h5>
+
+ <code class="computeroutput">epsilon</code> is very useful
+ to compute a tolerance when comparing floating-point values, a much
+ more difficult task than is commonly imagined.
+ 
+
+ For more information you probably want (but still need) see <a href="http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html" target="_top">What
+ Every Computer Scientist Should Know About Floating-Point Arithmetic</a>
+ 
+
+ The naive test comparing the absolute difference between two values
+ and a tolerance does not give useful results if the values are too
+ large or too small.
+ 
+
+ So Boost.Test uses an algorithm first devised by Knuth for reliably
+ checking if floating-point values are close enough.
+ 
+
+ See Donald. E. Knuth. The art of computer programming (vol II). Copyright
+ 1998 Addison-Wesley Longman, Inc., 0-201-89684-2. Addison-Wesley Professional;
+ 3rd edition.
+ 
+
+ See also:
+ 
+
+ <a href="http://adtmag.com/articles/2000/03/15/comparing-floats-how-to-determine-if-floating-quantities-are-close-enough-once-a-tolerance-has-been.aspx" target="_top">Alberto
+ Squassia, Comparing floats</a>
+ 
+
+ <a href="http://adtmag.com/articles/2000/03/16/comparing-floats-how-to-determine-if-floating-quantities-are-close-enough-once-a-tolerance-has-been.aspx" target="_top">Alberto
+ Squassia, Comparing floats code</a>
+ 
+
+ <a href="../../../../../../../../../libs/test/doc/html/utf/testing-tools/floating_point_comparison.html" target="_top">floating-point
+ comparison</a>.
+ 
+
+ For example, if we want a tolerance that might suit about 9 arithmetical
+ operations, say sqrt(9) = 3, we could define:
+ 
+<pre class="programlisting">T tolerance = 3 * std::numeric_limits<T>::epsilon();
+</pre>
+
+ This is very widely used in Boost.Math testing with Boost.Test's macro
+ <code class="computeroutput">BOOST_CHECK_CLOSE_FRACTION</code>
+ 
+<pre class="programlisting">T expected = 1.0;
+T calculated = 1.0 + std::numeric_limits<T>::epsilon();
+
+using boost::test_tools::check_is_close;
+
+bool r = check_is_close(expected, calculated, tolerance);
+std::cout << std::boolalpha << r << std::endl; // true
+</pre>
+
+ If using Boost.Test, then call the macro version:
+ 
+<pre class="programlisting">BOOST_CHECK_CLOSE_FRACTION(expected, calculated, tolerance);</pre>
+
+ used thus:
+ 
+<pre class="programlisting">BOOST_CHECK_CLOSE_FRACTION(expected, calculated, tolerance);
+</pre>
+
+ (There is also a version using tolerance as a percentage rather than
+ a fraction).
+ 
+<pre class="programlisting">using boost::multiprecision::number;
+using boost::multiprecision::cpp_dec_float;
+using boost::multiprecision::et_off;
+
+typedef number<cpp_dec_float<50>, et_off > cpp_dec_float_50; // 50 decimal digits.
+</pre>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+ that Boost.Test does not yet allow floating-point comparisons with
+ expression templates on, so the default expression template parameter
+ has been replaced by <code class="computeroutput">et_off</code>.
+ </td></tr>
+</table></div>
+<pre class="programlisting">cpp_dec_float_50 tolerance = 3 * std::numeric_limits<cpp_dec_float_50>::epsilon();
+cpp_dec_float_50 expected = boost::math::constants::two_pi<cpp_dec_float_50>();
+cpp_dec_float_50 calculated = 2 * boost::math::constants::pi<cpp_dec_float_50>();
+using boost::test_tools::check_is_close;
+
+bool r = check_is_close(expected, calculated, tolerance);
+std::cout << std::boolalpha << r << std::endl; // true
+</pre>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="round_error.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../functions.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="infinity.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/infinity.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/infinity.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,69 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Infinity - positive and negative</title>
+<link rel="stylesheet" href="../../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../functions.html" title="std::numeric_limits<> functions">
+<link rel="prev" href="epsilon.html" title="epsilon">
+<link rel="next" href="NaN.html" title="Not-A-Number NaN">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="epsilon.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../functions.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="NaN.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.functions.infinity"></a><a class="link" href="infinity.html" title="Infinity - positive and negative">Infinity
+ - positive and negative</a>
+</h6></div></div></div>
+
+ For floating-point types only, for which <code class="computeroutput">std::numeric_limits<T>::has_infinity
+ == true</code>,
+ function <code class="computeroutput">std::numeric_limits<T>::infinity()</code>
+ provides an implementation-defined representation for ∞.
+ 
+
+ The 'representation' is a particular bit pattern reserved for infinity.
+ For IEEE754 system (for which <code class="computeroutput">std::numeric_limits<T>::is_iec559
+ == true</code>)
+ 
+
+ <a href="http://en.wikipedia.org/wiki/IEEE_754-1985#Positive_and_negative_infinity" target="_top">positive
+ and negative infinity</a> are assigned bit patterns for all defined
+ floating-point types.
+ 
+
+ Confusingly, the string resulting from outputting this representation,
+ is also implementation-defined. And the string that can be input to
+ generate the representation is also implementation-defined.
+ 
+
+ For example, the output is <code class="computeroutput">1.#INF</code>
+ on Microsoft systems, but <code class="computeroutput">inf</code>
+ on some *nix platforms.
+ 
+
+ This implementation-defined-ness has hampered use of infinity (and
+ NaNs) but Boost.Math and Boost.Multiprecision work hard to provide
+ a sensible representation for all
+ floating-point types, not just the built-in types, which with the use
+ of suitable facets to define the input and output strings, makes it
+ possible to use these useful features portably and including Boost.Serialization.
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="epsilon.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../functions.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="NaN.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/lowest.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/lowest.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,50 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>lowest function</title>
+<link rel="stylesheet" href="../../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../functions.html" title="std::numeric_limits<> functions">
+<link rel="prev" href="max.html" title="max function">
+<link rel="next" href="min.html" title="min function">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="max.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../functions.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="min.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.functions.lowest"></a><a class="link" href="lowest.html" title="lowest function">lowest
+ function</a>
+</h6></div></div></div>
+
+ Since C++11: <code class="computeroutput">std::numeric_limits<T>::lowest()</code>
+ is
+ 
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+ For integral types, the same as function <code class="computeroutput">min()</code>.
+ </li>
+<li class="listitem">
+ For floating-point types, generally the negative of <code class="computeroutput">max()</code>
+ (but implementation-dependent).
+ </li>
+</ul></div>
+<pre class="programlisting">-(std::numeric_limits<double>::max)() == std::numeric_limits<double>::lowest();
+</pre>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="max.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../functions.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="min.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/max.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/max.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,64 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>max function</title>
+<link rel="stylesheet" href="../../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../functions.html" title="std::numeric_limits<> functions">
+<link rel="prev" href="../functions.html" title="std::numeric_limits<> functions">
+<link rel="next" href="lowest.html" title="lowest function">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="../functions.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../functions.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="lowest.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.functions.max"></a><a class="link" href="max.html" title="max function">max
+ function</a>
+</h6></div></div></div>
+
+ Function <code class="computeroutput">std::numeric_limits<T>::max()</code>
+ returns the largest finite value that can be represented by the type
+ T. If there is no such value (and <code class="computeroutput">numeric_limits<T>::bounded</code>
+ is <code class="computeroutput">false</code>) then returns
+ <code class="computeroutput">T()</code>.
+ 
+
+ For built-in types there is usually a corresponding MACRO value TYPE_MAX,
+ where TYPE is CHAR, INT, FLOAT etc.
+ 
+
+ Other types, including those provided by a typedef, for example <code class="computeroutput">INT64_T_MAX</code> for <code class="computeroutput">int64_t</code>,
+ may provide a macro definition.
+ 
+
+ To cater for situations where no <code class="computeroutput">numeric_limits</code>
+ specialization is available (for example because the precision of the
+ type varies at runtime), packaged versions of this (and other functions)
+ are provided using
+ 
+<pre class="programlisting">#include <boost/math/tools/precision.hpp>
+
+T = boost::math::tools::max_value<T>();
+</pre>
+
+ Of course, these simply use <code class="computeroutput">std::numeric_limits<T>::max()</code> if available, but otherwise 'do something
+ sensible'.
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../functions.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../functions.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="lowest.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/min.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/min.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,71 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>min function</title>
+<link rel="stylesheet" href="../../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../functions.html" title="std::numeric_limits<> functions">
+<link rel="prev" href="lowest.html" title="lowest function">
+<link rel="next" href="denorm_min.html" title="denorm_min function">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="lowest.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../functions.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="denorm_min.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.functions.min"></a><a class="link" href="min.html" title="min function">min
+ function</a>
+</h6></div></div></div>
+
+ Function <code class="computeroutput">std::numeric_limits<T>::min()</code>
+ returns the minimum finite value that can be represented by the type
+ T.
+ 
+
+ For built-in types there is usually a corresponding MACRO value TYPE_MIN,
+ where TYPE is CHAR, INT, FLOAT etc.
+ 
+
+ Other types, including those provided by a typedef, for example <code class="computeroutput">INT64_T_MIN</code> for <code class="computeroutput">int64_t</code>,
+ may provide a macro definition.
+ 
+
+ For floating-point types, it is more fully defined as the minimum
+ positive normalized value.
+ 
+
+ See <code class="computeroutput">std::numeric_limits<T>::denorm_min()</code>
+ for the smallest denormalized value, provided
+ 
+<pre class="programlisting">std::numeric_limits<T>::has_denorm == std::denorm_present
+</pre>
+
+ To cater for situations where no <code class="computeroutput">numeric_limits</code>
+ specialization is available (for example because the precision of the
+ type varies at runtime), packaged versions of this (and other functions)
+ are provided using
+ 
+<pre class="programlisting">#include <boost/math/tools/precision.hpp>
+
+T = boost::math::tools::min_value<T>();
+</pre>
+
+ Of course, these simply use <code class="computeroutput">std::numeric_limits<T>::min()</code> if available.
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="lowest.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../functions.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="denorm_min.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/round_error.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/implementation/functions/round_error.html 2013-10-20 12:57:43 EDT (Sun, 20 Oct 2013) (r86373)
@@ -0,0 +1,98 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>round_error</title>
+<link rel="stylesheet" href="../../../../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../../../index.html" title="Chapter 1. Boost.Multiprecision">
+<link rel="up" href="../functions.html" title="std::numeric_limits<> functions">
+<link rel="prev" href="denorm_min.html" title="denorm_min function">
+<link rel="next" href="epsilon.html" title="epsilon">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="spirit-nav">
+<a accesskey="p" href="denorm_min.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../functions.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="epsilon.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_multiprecision.tut.limits.implementation.functions.round_error"></a><a class="link" href="round_error.html" title="round_error">round_error</a>
+</h6></div></div></div>
+
+ Function <code class="computeroutput">std::numeric_limits<T>::round_error()</code>
+ returns the maximum error (in units of ULP)
+ that can be caused by rounding from binary to decimal.
+ 
+
+ For decimal types, no rounding is needed to get to decimal, so <code class="computeroutput">round_error</code> is always zero.
+ 
+<pre class="programlisting">round_style == std::round_indeterminate;
+</pre>
+
+ The rounding style is indeterminable at compile time.
+ 
+
+ (This standard says 'indeterminable at compile time', though this is
+ not strictly true for decimal types, not envisaged at the time that
+ the standard was written).
+ 
+
+ For floating-point types, rounding is to nearest, up or down, so at
+ worst, only half a bit is lost by rounding, and <code class="computeroutput">round_error
+ == 0.5</code>.
+ 
+
+ For integer types, rounding always to zero, so at worst almost one
+ bit can be rounded, so <code class="computeroutput">round_error
+ == 1</code>.
+ 
+
+ Similarly for other rounding styles that are not <code class="computeroutput">std::round_to_nearest</code>.
+ 
+
+ <code class="computeroutput">round_error()</code>
+ can be used with <code class="computeroutput">std::numeric_limits<T>::epsilon()</code> to estimate the maximum potential
+ error caused by rounding. For typical floating-point types, <code class="computeroutput">round_error()
+ = 1/2</code>, so
+ half epsilon is the maximum potential error.
+ 
+<pre class="programlisting">double round_err = std::numeric_limits<double>::epsilon() // 2.2204460492503131e-016
+ * std::numeric_limits<double>::round_error(); // 1/2
+std::cout << round_err << std::endl; // 1.1102230246251565e-016
+</pre>
+
+ This value can be used to set tolerances (see epsilon).
+ 
+
+ Of course, this is the rounding for just one arithmetic operation.
+ Some arithmetic operations will involve rounding to integer when almost
+ one bit can be lost by rounding.
+ 
+
+ Real life computations involve many, or very many, steps each of which
+ can be rounded.
+ 
+
+ So as a very rough approximation, we might multiply by the square root
+ of the number of arithmetic operations. Thus it is common to expect
+ tolerances of a few times as great as <code class="computeroutput">epsilon() * round_error()</code>.
+ 
+
+ There are, of course, many occasions when much bigger loss of precision
+ occurs, for exampe, caused by <a href="http://en.wikipedia.org/wiki/Loss_of_significance" target="_top">Loss
+ of significance or cancellation error</a> or very many iterations.
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2013 John Maddock and Christopher Kormanyos
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="denorm_min.html"><img src="../../../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../functions.html"><img src="../../../../../images/up.png" alt="Up"></a><a accesskey="h" href="../../../../../index.html"><img src="../../../../../images/home.png" alt="Home"></a><a accesskey="n" href="epsilon.html"><img src="../../../../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Date view	Thread view	Subject view	Author view