Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r86602 - in sandbox/multiprecision.cpp_bin_float: boost/multiprecision libs/multiprecision/doc libs/multiprecision/doc/html libs/multiprecision/doc/html/boost_multiprecision libs/multiprecision/doc/html/boost_multiprecision/ref libs/multiprecision/doc/html/boost_multiprecision/tut libs/multiprecision/doc/html/boost_multiprecision/tut/floats libs/multiprecision/doc/html/boost_multiprecision/tut/limits libs/multiprecision/example libs/multiprecision/test libs/multiprecision/test/math libs/multiprecision/test/math/instances
From: john_at_[hidden]
Date: 2013-11-09 13:53:07

Author: johnmaddock
Date: 2013-11-09 13:53:07 EST (Sat, 09 Nov 2013)
New Revision: 86602
URL: http://svn.boost.org/trac/boost/changeset/86602

Log:
Change some typedef names throughout.

Text files modified:
   sandbox/multiprecision.cpp_bin_float/boost/multiprecision/cpp_bin_float.hpp | 8
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/ref.html | 1
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/ref/cpp_dec_ref.html | 8
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/ref/mpfr_ref.html | 6
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut.html | 49 ----
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_bin_float.html | 20 +
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/input_output.html | 64 +++---
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits.html | 75 ++----
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/limits32.html | 42 ++-
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/index.html | 19 -
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/multiprecision.qbk | 387 +++++++++++++++++++++++++--------------
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/numeric_limits_32_tables.qbk | 16
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/numeric_limits_qbk.cpp | 12
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/example/numeric_limits_snips.cpp | 34 +-
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/test/math/instances/instances.cpp | 2
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/test/math/setup.hpp | 4
   sandbox/multiprecision.cpp_bin_float/libs/multiprecision/test/test_arithmetic_cpp_bin_float_1.cpp | 2
   17 files changed, 408 insertions(+), 341 deletions(-)

Modified: sandbox/multiprecision.cpp_bin_float/boost/multiprecision/cpp_bin_float.hpp
==============================================================================
--- sandbox/multiprecision.cpp_bin_float/boost/multiprecision/cpp_bin_float.hpp Sat Nov 9 12:00:41 2013 (r86601)
+++ sandbox/multiprecision.cpp_bin_float/boost/multiprecision/cpp_bin_float.hpp 2013-11-09 13:53:07 EST (Sat, 09 Nov 2013) (r86602)
@@ -1366,10 +1366,10 @@
typedef number<backends::cpp_bin_float<50> > cpp_bin_float_50;
typedef number<backends::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;
+typedef number<backends::cpp_bin_float<24, backends::digit_base_2, void, boost::int16_t, -126, 127>, et_off> cpp_bin_float_single;
+typedef number<backends::cpp_bin_float<53, backends::digit_base_2, void, boost::int16_t, -1022, 1023>, et_off> cpp_bin_float_double;
+typedef number<backends::cpp_bin_float<64, backends::digit_base_2, void, boost::int16_t, -16382, 16383>, et_off> cpp_bin_float_double_extended;
+typedef number<backends::cpp_bin_float<113, backends::digit_base_2, void, boost::int16_t, -16382, 16383>, et_off> cpp_bin_float_quad;

}} // namespaces

Modified: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/ref.html
==============================================================================
--- sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/ref.html Sat Nov 9 12:00:41 2013 (r86601)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/ref.html 2013-11-09 13:53:07 EST (Sat, 09 Nov 2013) (r86602)
@@ -24,6 +24,7 @@
<dt>tom_int</dt>
<dt>gmp_float</dt>
<dt>mpfr_float_backend</dt>
+<dt>cpp_bin_float</dt>
<dt>cpp_dec_float</dt>
<dt><a href="ref/internals.html">Internal Support
Code</a></dt>

Modified: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/ref/cpp_dec_ref.html
==============================================================================
--- sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/ref/cpp_dec_ref.html Sat Nov 9 12:00:41 2013 (r86601)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/ref/cpp_dec_ref.html 2013-11-09 13:53:07 EST (Sat, 09 Nov 2013) (r86602)
@@ -6,12 +6,12 @@
<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="../ref.html" title="Reference">
-<link rel="prev" href="mpfr_ref.html" title="mpfr_float_backend">
+<link rel="prev" href="cpp_bin_float_ref.html" title="cpp_bin_float">
<link rel="next" href="internals.html" title="Internal Support Code">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<div class="spirit-nav">
-<a accesskey="p" href="mpfr_ref.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.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="internals.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="cpp_bin_float_ref.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.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="internals.html"><img src="../../images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
@@ -61,7 +61,7 @@
</dl>
</div>

- The type of <code class="computeroutput">number_category<cpp_int<Args...> >::type</code> is <code class="computeroutput">mpl::int_<number_kind_floating_point></code>.
+ The type of <code class="computeroutput">number_category<cpp_dec_float<Args...> >::type</code> is <code class="computeroutput">mpl::int_<number_kind_floating_point></code>.


More information on this type can be found in the <a class="link" href="../tut/floats/cpp_dec_float.html" title="cpp_dec_float">tutorial</a>.
@@ -77,7 +77,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="mpfr_ref.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.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="internals.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="cpp_bin_float_ref.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.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="internals.html"><img src="../../images/next.png" alt="Next"></a>
</div>
</body>
</html>

Modified: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/ref/mpfr_ref.html
==============================================================================
--- sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/ref/mpfr_ref.html Sat Nov 9 12:00:41 2013 (r86601)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/ref/mpfr_ref.html 2013-11-09 13:53:07 EST (Sat, 09 Nov 2013) (r86602)
@@ -7,11 +7,11 @@
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../ref.html" title="Reference">
<link rel="prev" href="mpf_ref.html" title="gmp_float">
-<link rel="next" href="cpp_dec_ref.html" title="cpp_dec_float">
+<link rel="next" href="cpp_bin_float_ref.html" title="cpp_bin_float">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<div class="spirit-nav">
-<a accesskey="p" href="mpf_ref.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.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_ref.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="mpf_ref.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.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_bin_float_ref.html"><img src="../../images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
@@ -64,7 +64,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="mpf_ref.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.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_ref.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="mpf_ref.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.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_bin_float_ref.html"><img src="../../images/next.png" alt="Next"></a>
</div>
</body>
</html>

Modified: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut.html
==============================================================================
--- sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut.html Sat Nov 9 12:00:41 2013 (r86601)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut.html 2013-11-09 13:53:07 EST (Sat, 09 Nov 2013) (r86602)
@@ -78,51 +78,14 @@
<dt>Generic Integer Operations</dt>
<dt>Numeric Limits</dt>
<dd><dl>
-<dt><a href="tut/limits/implementation.html">Notes
- on Implementation of <code class="computeroutput">std::numeric_limits</code></a></dt>
-<dd><dl>
-<dt><a href="tut/limits/implementation/constants.html">std::numeric_limits<>
- constants</a></dt>
-<dd><dl>
-<dt>is_specialized</dt>
-<dt>infinity</dt>
-<dt>is_signed</dt>
-<dt>is_exact</dt>
-<dt>is_bounded</dt>
-<dt>is_modulo</dt>
-<dt>radix</dt>
-<dt>digits</dt>
-<dt>digits10</dt>
-<dt>max_digits10</dt>
-<dt>round_style</dt>
-<dt>has_denorm_loss</dt>
-<dt>denorm_style</dt>
-<dt><a href="tut/limits/implementation/constants/tinyness.html">Tinyness
- before rounding</a></dt>
-</dl></dd>
-<dt><a href="tut/limits/implementation/functions.html">std::numeric_limits<>
- functions</a></dt>
-<dd><dl>
-<dt><a href="tut/limits/implementation/functions/max.html">max
- function</a></dt>
-<dt><a href="tut/limits/implementation/functions/lowest.html">lowest
- function</a></dt>
-<dt><a href="tut/limits/implementation/functions/min.html">min
- function</a></dt>
-<dt><a href="tut/limits/implementation/functions/denorm_min.html">denorm_min
- function</a></dt>
-<dt>round_error</dt>
-<dt>epsilon</dt>
-<dt><a href="tut/limits/implementation/functions/infinity.html">Infinity
- - positive and negative</a></dt>
-<dt><a href="tut/limits/implementation/functions/NaN.html">Not-A-Number
- NaN</a></dt>
-</dl></dd>
-</dl></dd>
-<dt><a href="tut/limits/version_32.html">32-bit
- version information used for tables below.</a></dt>
+<dt><a href="tut/limits/constants.html">std::numeric_limits<>
+ constants</a></dt>
+<dt><a href="tut/limits/functions.html">std::numeric_limits<>
+ functions</a></dt>
<dt><a href="tut/limits/limits32.html">Numeric limits
for 32-bit platform</a></dt>
+<dt><a href="tut/limits/how_to_tell.html">How to
+ Determine the Kind of a Number From <code class="computeroutput">std::numeric_limits</code></a></dt>
</dl></dd>
<dt>Input Output</dt>
</dl></div>

Modified: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_bin_float.html
==============================================================================
--- sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_bin_float.html Sat Nov 9 12:00:41 2013 (r86601)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_bin_float.html 2013-11-09 13:53:07 EST (Sat, 09 Nov 2013) (r86602)
@@ -34,10 +34,10 @@
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;
+typedef number<backends::cpp_bin_float<24, backends::digit_base_2, void, boost::int16_t, -126, 127>, et_off> cpp_bin_float_single;
+typedef number<backends::cpp_bin_float<53, backends::digit_base_2, void, boost::int16_t, -1022, 1023>, et_off> cpp_bin_float_double;
+typedef number<backends::cpp_bin_float<64, backends::digit_base_2, void, boost::int16_t, -16382, 16383>, et_off> cpp_bin_float_double_extended;
+typedef number<backends::cpp_bin_float<113, backends::digit_base_2, void, boost::int16_t, -16382, 16383>, et_off> cpp_bin_float_quad;

}} // namespaces
</pre>
@@ -60,10 +60,14 @@
 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>
+ The typedefs <code class="computeroutput">cpp_bin_float_single</code>,
+ <code class="computeroutput">cpp_bin_float_double</code>,
+ <code class="computeroutput">cpp_bin_float_quad</code> and
+ <code class="computeroutput">cpp_bin_float_double_extended</code>
 provide software analogues of the IEEE single, double and quad float data
- types, plus the intel-extended-double type respectively.
+ types, plus the Intel-extended-double type respectively. Note that while
+ these types are functionally equivalent to the native IEEE types, but they
+ do not have the same size or bit-layout as true IEEE compatible types.
 

 Normally <code class="computeroutput">cpp_bin_float</code>
@@ -71,7 +75,7 @@
 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>
+ as a 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

Modified: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/input_output.html
==============================================================================
--- sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/input_output.html Sat Nov 9 12:00:41 2013 (r86601)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/input_output.html 2013-11-09 13:53:07 EST (Sat, 09 Nov 2013) (r86602)
@@ -6,12 +6,12 @@
<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="prev" href="limits/how_to_tell.html" title="How to Determine the Kind of a Number From std::numeric_limits">
<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>
+<a accesskey="p" href="limits/how_to_tell.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">
@@ -23,7 +23,8 @@
 testing</a>
 </h5>

- or refers to writing out a value as a decimal digit string using <code class="computeroutput">std::iostream</code>,
+ Loopback or round-tripping 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>
@@ -39,7 +40,7 @@
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.
+ and this can be run in a loop 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
@@ -62,10 +63,11 @@
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.
+ The test at test_cpp_bin_float_io.cpp
+ allows any floating-point type to be round_tripped using
+ a wide range of fairly random values. It also includes tests compared a collection
+ of stringdata test cases
+ in a file.
 
<h5>
<a name="boost_multiprecision.tut.input_output.h1"></a>
@@ -75,29 +77,30 @@

 One can make some comparisons with the output of
 
-<pre class="programlisting"><number<cpp_bin_float<53> >
+<pre class="programlisting"><number<cpp_bin_float<53, digit_count_2> >
</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
+ However, although most outputs are identical, 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."
- 
+<div class="blockquote"><blockquote class="blockquote">
+ "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."
+ </blockquote></div>

 So not only is correct rounding for the full number of digits not required,
 but even if the optional recomended practice
@@ -138,18 +141,15 @@

 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
+ that from built-in floating-point types on compilers that use Microsofts
+ runtime then use:
+ 
+<pre class="programlisting">#define BOOST_MP_MIN_EXPONENT_DIGITS 3
</pre>

 Also useful to get the minimum exponent field width is
 
-<pre class="programlisting"># define BOOST_MP_MIN_EXPONENT_DIGITS 1
+<pre class="programlisting">#define BOOST_MP_MIN_EXPONENT_DIGITS 1
</pre>

 producing a compact output like <code class="computeroutput">2e+4</code>,
@@ -170,7 +170,7 @@
</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>
+<a accesskey="p" href="limits/how_to_tell.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>

Modified: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits.html
==============================================================================
--- sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits.html Sat Nov 9 12:00:41 2013 (r86601)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits.html 2013-11-09 13:53:07 EST (Sat, 09 Nov 2013) (r86602)
@@ -7,62 +7,25 @@
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../tut.html" title="Tutorial">
<link rel="prev" href="gen_int.html" title="Generic Integer Operations">
-<link rel="next" href="limits/implementation.html" title="Notes on Implementation of std::numeric_limits">
+<link rel="next" href="limits/constants.html" title="std::numeric_limits<> constants">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<div class="spirit-nav">
-<a accesskey="p" href="gen_int.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="limits/implementation.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="gen_int.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="limits/constants.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.limits"></a><a class="link" href="limits.html" title="Numeric Limits">Numeric Limits</a>
</h3></div></div></div>
<div class="toc"><dl class="toc">
-<dt><a href="limits/implementation.html">Notes
- on Implementation of <code class="computeroutput">std::numeric_limits</code></a></dt>
-<dd><dl>
-<dt><a href="limits/implementation/constants.html">std::numeric_limits<>
- constants</a></dt>
-<dd><dl>
-<dt>is_specialized</dt>
-<dt>infinity</dt>
-<dt>is_signed</dt>
-<dt>is_exact</dt>
-<dt>is_bounded</dt>
-<dt>is_modulo</dt>
-<dt>radix</dt>
-<dt>digits</dt>
-<dt>digits10</dt>
-<dt>max_digits10</dt>
-<dt>round_style</dt>
-<dt>has_denorm_loss</dt>
-<dt>denorm_style</dt>
-<dt><a href="limits/implementation/constants/tinyness.html">Tinyness
- before rounding</a></dt>
-</dl></dd>
-<dt><a href="limits/implementation/functions.html">std::numeric_limits<>
- functions</a></dt>
-<dd><dl>
-<dt><a href="limits/implementation/functions/max.html">max
- function</a></dt>
-<dt><a href="limits/implementation/functions/lowest.html">lowest
- function</a></dt>
-<dt><a href="limits/implementation/functions/min.html">min
- function</a></dt>
-<dt><a href="limits/implementation/functions/denorm_min.html">denorm_min
- function</a></dt>
-<dt>round_error</dt>
-<dt>epsilon</dt>
-<dt><a href="limits/implementation/functions/infinity.html">Infinity
- - positive and negative</a></dt>
-<dt><a href="limits/implementation/functions/NaN.html">Not-A-Number
- NaN</a></dt>
-</dl></dd>
-</dl></dd>
-<dt><a href="limits/version_32.html">32-bit
- version information used for tables below.</a></dt>
+<dt><a href="limits/constants.html">std::numeric_limits<>
+ constants</a></dt>
+<dt><a href="limits/functions.html">std::numeric_limits<>
+ functions</a></dt>
<dt><a href="limits/limits32.html">Numeric limits
 for 32-bit platform</a></dt>
+<dt><a href="limits/how_to_tell.html">How to
+ Determine the Kind of a Number From <code class="computeroutput">std::numeric_limits</code></a></dt>
</dl></div>

 Boost.Multiprecision tries hard to implement <code class="computeroutput">std::numeric_limits</code>
@@ -91,6 +54,26 @@
 There is a useful summary at <a href="http://www.cplusplus.com/reference/limits/numeric_limits/" target="_top">C++
 reference</a>.
 
+
+ The chosen backend often determines how completely <code class="computeroutput">std::numeric_limits</code>
+ is available.
+ 
+
+ Compiler options, processor type, and definition of macros or assembler instructions
+ to control denormal numbers will alter the values in the tables given below.
+ 
+<div class="warning"><table border="0" summary="Warning">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../images/warning.png"></td>
+<th align="left">Warning</th>
+</tr>
+<tr><td align="left" valign="top">
+ GMP's <code class="computeroutput">mpf_t</code> does not have
+ a concept of overflow: operations that lead to overflow eventually run
+ of out of resources and terminate with stack overflow (often after several
+ seconds).
+ </td></tr>
+</table></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
@@ -102,7 +85,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="gen_int.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="limits/implementation.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="gen_int.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="limits/constants.html"><img src="../../images/next.png" alt="Next"></a>
</div>
</body>
</html>

Modified: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/limits32.html
==============================================================================
--- sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/limits32.html Sat Nov 9 12:00:41 2013 (r86601)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/limits32.html 2013-11-09 13:53:07 EST (Sat, 09 Nov 2013) (r86602)
@@ -6,18 +6,32 @@
<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="../limits.html" title="Numeric Limits">
-<link rel="prev" href="version_32.html" title="32-bit version information used for tables below.">
-<link rel="next" href="../input_output.html" title="Input Output">
+<link rel="prev" href="functions.html" title="std::numeric_limits<> functions">
+<link rel="next" href="how_to_tell.html" title="How to Determine the Kind of a Number From std::numeric_limits">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<div class="spirit-nav">
-<a accesskey="p" href="version_32.html"><img src="../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../limits.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="../input_output.html"><img src="../../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="functions.html"><img src="../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../limits.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="how_to_tell.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.limits.limits32"></a><a class="link" href="limits32.html" title="Numeric limits for 32-bit platform">Numeric limits
 for 32-bit platform</a>
</h4></div></div></div>
+
+ These tables were generated using the following program and options:
+ 
+<pre class="programlisting">
+Program:
+ numeric_limits_qbk.cpp
+Mon Nov 4 18:09:06 2013
+BuildInfo:
+ Platform Win32
+ Compiler Microsoft Visual C++ version 10.0
+ MSVC version 160040219.
+ STL Dinkumware standard library version 520
+ Boost version 1.55.0
+</pre>
<div class="table">
<a name="boost_multiprecision.tut.limits.limits32.integral_constants"></a>Table 1.4. Integer types constants (<code class="computeroutput">std::numeric_limits<T>::is_integer
 == true</code>
@@ -1656,37 +1670,37 @@
 </td>
<td>
 
- 113
+ 377
 
 </td>
<td>
 
- 34
+ 113
 
 </td>
<td>
 
- 36
+ 115
 
 </td>
<td>
 
- -2147483422
+ -2147482894
 
 </td>
<td>
 
- -646392383
+ -646392082
 
 </td>
<td>
 
- 2147483421
+ 2147482893
 
 </td>
<td>
 
- 646392383
+ 646392082
 
 </td>
<td>
@@ -1777,7 +1791,7 @@
 </td>
<td>
 
- 1.63355e+646456925
+ 1.85906e+646456766
 
 </td>
</tr>
@@ -1809,7 +1823,7 @@
 </td>
<td>
 
- 6.12165e-646456926
+ 5.37906e-646456767
 
 </td>
</tr>
@@ -1841,7 +1855,7 @@
 </td>
<td>
 
- 1.92593e-34
+ 6.49713e-114
 
 </td>
</tr>
@@ -2020,7 +2034,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="version_32.html"><img src="../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../limits.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="../input_output.html"><img src="../../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="functions.html"><img src="../../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../limits.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="how_to_tell.html"><img src="../../../images/next.png" alt="Next"></a>
</div>
</body>
</html>

Modified: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/index.html
==============================================================================
--- sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/index.html Sat Nov 9 12:00:41 2013 (r86601)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/html/index.html 2013-11-09 13:53:07 EST (Sat, 09 Nov 2013) (r86602)
@@ -93,18 +93,14 @@
<dt>Generic Integer Operations</dt>
<dt>Numeric Limits</dt>
<dd><dl>
-<dt><a href="boost_multiprecision/tut/limits/implementation.html">Notes
- on Implementation of <code class="computeroutput">std::numeric_limits</code></a></dt>
-<dd><dl>
-<dt><a href="boost_multiprecision/tut/limits/implementation/constants.html">std::numeric_limits<>
- constants</a></dt>
-<dt><a href="boost_multiprecision/tut/limits/implementation/functions.html">std::numeric_limits<>
- functions</a></dt>
-</dl></dd>
-<dt><a href="boost_multiprecision/tut/limits/version_32.html">32-bit
- version information used for tables below.</a></dt>
+<dt><a href="boost_multiprecision/tut/limits/constants.html">std::numeric_limits<>
+ constants</a></dt>
+<dt><a href="boost_multiprecision/tut/limits/functions.html">std::numeric_limits<>
+ functions</a></dt>
<dt><a href="boost_multiprecision/tut/limits/limits32.html">Numeric limits
for 32-bit platform</a></dt>
+<dt><a href="boost_multiprecision/tut/limits/how_to_tell.html">How to
+ Determine the Kind of a Number From <code class="computeroutput">std::numeric_limits</code></a></dt>
</dl></dd>
<dt>Input Output</dt>
</dl></dd>
@@ -116,6 +112,7 @@
<dt>tom_int</dt>
<dt>gmp_float</dt>
<dt>mpfr_float_backend</dt>
+<dt>cpp_bin_float</dt>
<dt>cpp_dec_float</dt>
<dt><a href="boost_multiprecision/ref/internals.html">Internal Support
Code</a></dt>
@@ -149,7 +146,7 @@
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left">Last revised: October 21, 2013 at 12:18:46 GMT</td>
+<td align="left">Last revised: November 09, 2013 at 18:51:50 GMT</td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>

Modified: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/multiprecision.qbk
==============================================================================
--- sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/multiprecision.qbk Sat Nov 9 12:00:41 2013 (r86601)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/multiprecision.qbk 2013-11-09 13:53:07 EST (Sat, 09 Nov 2013) (r86602)
@@ -671,10 +671,10 @@
 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;
+ typedef number<backends::cpp_bin_float<24, backends::digit_base_2, void, boost::int16_t, -126, 127>, et_off> cpp_bin_float_single;
+ typedef number<backends::cpp_bin_float<53, backends::digit_base_2, void, boost::int16_t, -1022, 1023>, et_off> cpp_bin_float_double;
+ typedef number<backends::cpp_bin_float<64, backends::digit_base_2, void, boost::int16_t, -16382, 16383>, et_off> cpp_bin_float_double_extended;
+ typedef number<backends::cpp_bin_float<113, backends::digit_base_2, void, boost::int16_t, -16382, 16383>, et_off> cpp_bin_float_quad;

 }} // namespaces

@@ -688,8 +688,11 @@

Optionally, you can specify whether the precision is specified in decimal digits or binary bits - for example
to declare a `cpp_bin_float` with exactly the same precision as `double` one would use
-`number<cpp_bin_float<53, digit_base_2> >`. The typedefs `float32_t`, `float64_t`, `float128_t` and `float80_t` provide
-software analogues of the IEEE single, double and quad float data types, plus the intel-extended-double type respectively.
+`number<cpp_bin_float<53, digit_base_2> >`. The typedefs `cpp_bin_float_single`, `cpp_bin_float_double`,
+`cpp_bin_float_quad` and `cpp_bin_float_double_extended` provide
+software analogues of the IEEE single, double and quad float data types, plus the Intel-extended-double type respectively.
+Note that while these types are functionally equivalent to the native IEEE types, but they do not have the same size
+or bit-layout as true IEEE compatible types.

Normally `cpp_bin_float` 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
@@ -1956,8 +1959,6 @@
There is a useful summary at
[@http://www.cplusplus.com/reference/limits/numeric_limits/ C++ reference].

-[section:implementation Notes on Implementation of `std::numeric_limits`]
-
The chosen backend often determines how completely `std::numeric_limits` is available.

Compiler options, processor type, and definition of macros or assembler instructions to control denormal numbers will alter
@@ -1970,7 +1971,7 @@
[section:constants std::numeric_limits<> constants]

-[section:is_specialized is_specialized]
+[h4 is_specialized]

`true` for all arithmetic types (integer, floating and fixed-point)
for which `std::numeric_limits<T>::numeric_limits` is specialized.
@@ -1993,11 +1994,9 @@
Note that not all the `std::numeric_limits` 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.

-[endsect] [/section:is_specialized is_specialized]
-
-[section:infinity infinity]
+[h4 infinity]

-For floating-point types, [infin] is defined whereever possible,
+For floating-point types, [infin] is defined wherever possible,
but clearly infinity is meaningless for __arbitrary_precision arithmetic backends,
and there is one floating point type (GMP's `mpf_t`, see __mpf_float) which has no notion
of infinity or NaN at all.
@@ -2014,9 +2013,7 @@
If the backend is switched to a type that does not support infinity then,
without checks like this, there will be trouble.

-[endsect] [/section:infinity infinity]
-
-[section:signed is_signed]
+[h4 is_signed]

`std::numeric_limits<T>::is_signed == true` if the type `T` is signed.

@@ -2024,9 +2021,7 @@
but for other types (cpp_dec_float and cpp_bin_float)
it may be a separate storage element, usually `bool`.

-[endsect] [/section:signed signed]
-
-[section:exact is_exact]
+[h4 is_exact]

`std::numeric_limits<T>::is_exact == true` if type T uses exact representations.

@@ -2064,9 +2059,7 @@
[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3352.html
C++ Binary Fixed-Point Arithmetic].

-[endsect] [/section:exact is_exact]
-
-[section:bound is_bounded]
+[h4 is_bounded]

`std::numeric_limits<T>::is_bounded == true` if the set of values represented by the type `T` is finite.

@@ -2077,9 +2070,7 @@

Rational and fixed-exponent representations are exact but not integer.

-[endsect] [/ section:bound is_bounded]
-
-[section:modulo is_modulo]
+[h4 is_modulo]

`std::numeric_limits<T>::is_modulo` is defined as `true` if adding two positive values of type T
can yield a result less than either value.
@@ -2091,8 +2082,7 @@

`bool` is the only exception.

-The modulo behaviour is sometimes useful, often irrelevent
-(with 32 or more bit integers),
+The modulo behaviour is sometimes useful,
but also can be unexpected, and sometimes undesired, behaviour.

Overflow of signed integers can be especially unexpected,
@@ -2111,16 +2101,12 @@
Where possible, overflow is to `std::numeric_limits<>::infinity()`,
provided `std::numeric_limits<>::has_infinity == true`.

-[endsect] [/section:modulo is_modulo]
-
-[section:radix radix]
+[h4 radix]

Constant `std::numeric_limits<T>::radix` returns either 2 (for built-in and binary types)
or 10 (for decimal types).

-[endsect] [/section:radix radix]
-
-[section:digits digits]
+[h4 digits]

The number of `radix` digits that be represented without change:

@@ -2147,14 +2133,10 @@

For a decimal integer type, when `radix == 10`, it is the number of decimal digits.

-[endsect] [/section:digits digits]
-
-
-[section:digits10 digits10]
+[h4 digits10]

-Constant `std::numeric_limits<T>::digits` returns the
-
-Number of decimal digits that can be represented without change or loss.
+Constant `std::numeric_limits<T>::digits10` returns the number of
+decimal digits that can be represented without change or loss.

For example, `numeric_limits<unsigned char>::digits10` is 2.

@@ -2162,14 +2144,10 @@
can hold decimal values `0..99`
without loss of precision or accuracy, usually from truncation.

-[*If it were 3] it could hold 0..999,
+Had the definition been 3 then that would imply it could hold 0..999,
but as we all know, an 8-bit `unsigned char` 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 `std::numeric_limits<T>::max()`.
This value can be used to predict the layout width required for
@@ -2237,9 +2215,7 @@
you must use `os.precision(std::numeric_limits<T>::max_digits10)`.
For at least one popular compiler, you must also use `std::scientific` format.

-[endsect] [/section:digits digits]
-
-[section:max_digits10 max_digits10]
+[h4 max_digits10]

`std::numeric_limits<T>::max_digits10` was added for floating-point
because `digits10` decimal digits are insufficient to show
@@ -2282,7 +2258,7 @@

A workaround is using scientific or exponential format `<< std::scientific`.]

-[note BOOST_NO_NUMERIC_LIMITS_LOWEST is a suitable proxy to determine if
+[note BOOST_NO_CXX11_NUMERIC_LIMITS is a suitable feature-test macro to determine if
`std::numeric_limits<float>::max_digits10` is implemented on any platform.
If `max_digits10` is not available, you should using the
[@http://www.cs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF Kahan formula for floating-point type T].
@@ -2290,10 +2266,7 @@

[max_digits10_1] [/ example for using max_digits10]

-[endsect] [/section:max_digits10 max_digits10]
-
-
-[section:round_style round_style]
+[h4 round_style]

The rounding style determines how the result of floating-point operations
is treated when the result cannot be [*exactly represented] in the significand.
@@ -2322,9 +2295,7 @@
See function `std::numeric_limits<T>::round_error` for the maximum error (in ULP)
that rounding can cause.

-[endsect] [/section:round_style route_style]
-
-[section:denorm_loss has_denorm_loss]
+[h4 has_denorm_loss]

`true` if a loss of precision is detected as a
[@http://en.wikipedia.org/wiki/Denormalization denormalization] loss,
@@ -2334,9 +2305,7 @@

`false` for all types which do not have `has_denorm` == `std::denorm_present`.

-[endsect] [/section:denorm_loss has_denorm_loss]
-
-[section:denorm_style denorm_style]
+[h4 denorm_style]

[@http://en.wikipedia.org/wiki/Denormal_number Denormalized values] are
representations with a variable number of exponent bits that can permit
@@ -2351,9 +2320,7 @@
* `std::denorm_present`, if the floating-point type allows denormalized values.
*`std::denorm_indeterminate`, if indeterminate at compile time.

-[endsect] [/section:denorm_style denorm_style]
-
-[section:tinyness Tinyness before rounding]
+[h4 Tinyness before rounding]

`bool std::numeric_limits<T>::tinyness_before`

@@ -2376,13 +2343,11 @@
# If the conversion of the rounded tiny result to subnormal form
resulted in the loss of precision, such implementation detects ['denorm loss].

-[endsect] [/section:tinyness Tinyness_before rounding]
-
[endsect] [/section:constants std::numeric_limits<> Constants]

[section:functions std::numeric_limits<> functions]

-[section:max max function]
+[h4 max function]

Function `std::numeric_limits<T>::max()` returns the largest finite value
that can be represented by the type T. If there is no such value (and
@@ -2405,10 +2370,7 @@
Of course, these simply use `std::numeric_limits<T>::max()` if available,
but otherwise 'do something sensible'.

-[endsect] [/section:max max function]
-
-
-[section:lowest lowest function]
+[h4 lowest function]

Since C++11: `std::numeric_limits<T>::lowest()` is

@@ -2418,9 +2380,7 @@

[digits10_5]

-[endsect] [/section:lowest lowest function]
-
-[section:min min function]
+[h4 min function]

Function `std::numeric_limits<T>::min()` returns the minimum finite value
that can be represented by the type T.
@@ -2449,9 +2409,7 @@

Of course, these simply use `std::numeric_limits<T>::min()` if available.

-[endsect] [/section:min min function]
-
-[section:denorm_min denorm_min function]
+[h4 denorm_min function]

Function `std::numeric_limits<T>::denorm_min()`
returns the smallest
@@ -2466,59 +2424,36 @@
(though it remains encoded as zero and leading zeros appear in the significand,
thereby losing precision until the significand reaches zero).

-[endsect]
-
-[section:round_error round_error]
+[h4 round_error]

Function `std::numeric_limits<T>::round_error()` returns the maximum error
(in units of [@http://en.wikipedia.org/wiki/Unit_in_the_last_place ULP])
-that can be caused by rounding from binary to decimal.
-
-For decimal types, no rounding is needed to get to decimal,
-so `round_error` is always zero.
+that can be caused by any basic arithmetic operation.

 round_style == std::round_indeterminate;

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 `round_error == 0.5`.
+For floating-point types, when rounding is to nearest,
+only half a bit is lost by rounding, and `round_error == 0.5`.
+In contrast when rounding is towards zero, or plus/minus infinity,
+we can loose up to one bit from rounding, and `round_error == 1`.

For integer types, rounding always to zero, so at worst almost one bit can be rounded,
so `round_error == 1`.

-Similarly for other rounding styles that are not `std::round_to_nearest`.
-
`round_error()` can be used with `std::numeric_limits<T>::epsilon()` to estimate
the maximum potential error caused by rounding. For typical floating-point types,
`round_error() = 1/2`, so half epsilon is the maximum potential error.

[round_error_1]

-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
-`epsilon() * round_error()`.
-
There are, of course, many occasions when much bigger loss of precision occurs,
for exampe, caused by
[@http://en.wikipedia.org/wiki/Loss_of_significance Loss of significance or cancellation error]
or very many iterations.

-[endsect] [/section:round_error round_error]
-
-[section:epsilon epsilon]
+[h4 epsilon]

Function `std::numeric_limits<T>::epsilon()` is meaningful only for non-integral types.

@@ -2549,7 +2484,7 @@

[epsilon_4]

-[h4 Tolerance for Floating-point Comparisons]
+[h5 Tolerance for Floating-point Comparisons]

`epsilon` is very useful to compute a tolerance when comparing floating-point values,
a much more difficult task than is commonly imagined.
@@ -2585,9 +2520,7 @@

[tolerance_2]

-[endsect] [/section:epsilon epsilon]
-
-[section:infinity Infinity - positive and negative]
+[h4 Infinity - positive and negative]

For floating-point types only, for which
`std::numeric_limits<T>::has_infinity == true`,
@@ -2596,14 +2529,13 @@

The 'representation' is a particular bit pattern reserved for infinity.
For IEEE754 system (for which `std::numeric_limits<T>::is_iec559 == true`)
-
[@http://en.wikipedia.org/wiki/IEEE_754-1985#Positive_and_negative_infinity positive and negative infinity]
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 `1.#INF` on Microsoft systems, but `inf` on some *nix platforms.
+For example, the output is `1.#INF` on Microsoft systems, but `inf` on most *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
@@ -2611,11 +2543,9 @@
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.

-[endsect] [/section:infinity infinity]
-
-[section:NaN Not-A-Number NaN]
+[h4 Not-A-Number NaN]

-[h4 Quiet_NaN]
+[h5 Quiet_NaN]

For floating-point types only, for which
`std::numeric_limits<T>::has_quiet_NaN == true`,
@@ -2640,25 +2570,113 @@

[facet_1]

-[h4 Signaling NaN]
+[h5 Signaling NaN]

For floating-point types only, for which
`std::numeric_limits<T>::has_signaling_NaN == true`,
function `std::numeric_limits<T>::signaling_NaN()`
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.
-
-[endsect] [/section:NaN NotANumber NaN]
+It should be noted however, that at least one implementation of this function causes a hardware
+trap to be triggered simply by calling `std::numeric_limits<T>::signaling_NaN()`, and not only
+by using the value returned.

[endsect] [/section:functions std::numeric_limits<> functions]

-[endsect] [/section:implementation Implementation Notes]
-
[/ Tables of values for numeric_limits for various built-in and cpp_bin_float types]
[include numeric_limits_32_tables.qbk]
[/include numeric_limits_64_tables.qbk]

+[section:how_to_tell How to Determine the Kind of a Number From `std::numeric_limits`]
+
+Based on the information above, one can see that different kinds of numbers can be
+differentiated based on the information stored in `std::numeric_limits`. This is
+in addition to the traits class [link boost_multiprecision.ref.number.traits_class_support
+number_category] provided by this library.
+
+[h4 Integer Types]
+
+For an integer type T, all of the following conditions hold:
+
+ std::numeric_limits<T>::is_specialized == true
+ std::numeric_limits<T>::is_integer == true
+ std::numeric_limits<T>::is_exact == true
+ std::numeric_limits<T>::min_exponent == 0
+ std::numeric_limits<T>::max_exponent == 0
+ std::numeric_limits<T>::min_exponent10 == 0
+ std::numeric_limits<T>::max_exponent10 == 0
+
+In addition the type is /signed/ if:
+
+ std::numeric_limits<T>::is_signed == true
+
+If the type is arbitrary precision then:
+
+ std::numeric_limits<T>::is_bounded == false
+
+Otherwise the type is bounded, and returns a non zero value
+from:
+
+ std::numeric_limits<T>::max()
+
+and has:
+
+ std::numeric_limits<T>::is_modulo == true
+
+if the type implements modulo arithmetic on overflow.
+
+[h4 Rational Types]
+
+Rational types are just like integers except that:
+
+ std::numeric_limits<T>::is_integer == false
+
+[h4 Fixed Precision Types]
+
+There appears to be no way to tell these apart from rational types, unless they set:
+
+ std::numeric_limits<T>::is_exact == false
+
+This is because these types are in essense a rational type with a fixed denominator.
+
+[h4 Floating Point Types]
+
+For a floating point type T, all of the following conditions hold:
+
+ std::numeric_limits<T>::is_specialized == true
+ std::numeric_limits<T>::is_integer == false
+ std::numeric_limits<T>::is_exact == false
+ std::numeric_limits<T>::min_exponent != 0
+ std::numeric_limits<T>::max_exponent != 0
+ std::numeric_limits<T>::min_exponent10 != 0
+ std::numeric_limits<T>::max_exponent10 != 0
+
+In addition the type is /signed/ if:
+
+ std::numeric_limits<T>::is_signed == true
+
+And the type may be decimal or binary depending on the value of:
+
+ std::numeric_limits<T>::radix
+
+In general, there are no arbitrary precision floating point types, and so:
+
+ std::numeric_limits<T>::is_bounded == false
+
+[h4 Exact Floating Point Types]
+
+Exact floating point types are a [@http://en.wikipedia.org/wiki/Field_%28mathematics%29 field]
+composed of an arbitrary precision integer scaled by an exponent. Such types
+have no division operator and are the same as floating point types except:
+
+ std::numeric_limits<T>::is_exact == true
+
+[h4 Complex Numbers]
+
+For historical reasons, complex numbers do not specialize `std::numeric_limits`, instead you must
+inspect `std::numeric_limits<T::value_type>`.
+
+[endsect]
+
[endsect] [/section:limits Numeric Limits]

@@ -2667,7 +2685,7 @@

[h4 Loopback testing]

-[/Loopback] or [/round-tripping] refers to writing out a value as a decimal digit string using `std::iostream`,
+['Loopback] or ['round-tripping] refers to writing out a value as a decimal digit string using `std::iostream`,
usually to a `std::stringstream`, and then reading the string back in to another value,
and confirming that the two values are identical. A trivial example using `float` is:

@@ -2680,7 +2698,7 @@
 ss >> read; // Read decimal digits string from stringstream.
 BOOST_CHECK_EQUAL(write, read); // Should be the same.

-and this can be run in a look for all possible values of a 32-bit float.
+and this can be run in a loop for all possible values of a 32-bit float.
For other floating-point types `T`, including built-in `double`,
it takes far too long to test all values,
so a reasonable test strategy is to use a large number of random values.
@@ -2703,25 +2721,25 @@

The test at
-[$boost:/multiprecision.cpp_bin_float/libs/multiprecision/test/test_cpp_bin_float_io.cpp test_cpp_bin_float_io.cpp]
-allows any floating-point type to be [/round_tripped] using a wide range of fairly random values.
+[@../../test/test_cpp_bin_float_io.cpp test_cpp_bin_float_io.cpp]
+allows any floating-point type to be ['round_tripped] using a wide range of fairly random values.
It also includes tests compared a collection of
-[$boost:libs/multiprecision/test/string_data.ipp stringdata] test cases in a file.
+[@../../test/string_data.ipp stringdata] test cases in a file.

[h4 Comparing with output using Built-in types]

One can make some comparisons with the output of

- <number<cpp_bin_float<53> >
+ <number<cpp_bin_float<53, digit_count_2> >

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
+However, although most outputs are identical, there are differences on some platforms
caused by the implementation-dependent behaviours allowed by the C99 specification
[@http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf C99 ISO/IEC 9899:TC2],
incorporated by C++.

-"For e, E, f, F, g, and G conversions, if the number of significant decimal digits
+[:['"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,
@@ -2730,7 +2748,7 @@
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."
+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,
@@ -2756,17 +2774,14 @@

Confusingly, Microsoft (and MinGW) do not conform to this standard and provide
[*at least three digits], for example `1e+001`.
-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:
-
- #ifdef MSC_VER
- # define BOOST_MP_MIN_EXPONENT_DIGITS 3
- #endif
+So if you want the output to match that from
+built-in floating-point types on compilers that use Microsofts runtime then use:
+
+ #define BOOST_MP_MIN_EXPONENT_DIGITS 3

Also useful to get the minimum exponent field width is

- # define BOOST_MP_MIN_EXPONENT_DIGITS 1
+ #define BOOST_MP_MIN_EXPONENT_DIGITS 1

producing a compact output like `2e+4`,
useful when conserving space is important.
@@ -3645,6 +3660,98 @@

[endsect]

+[section:cpp_bin_float_ref cpp_bin_float]
+
+ 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> cpp_bin_float_single;
+ typedef number<backends::cpp_bin_float<53, backends::digit_base_2, void, boost::int16_t, -1022, 1023>, et_off> cpp_bin_float_double;
+ typedef number<backends::cpp_bin_float<64, backends::digit_base_2, void, boost::int16_t, -16382, 16383>, et_off> cpp_bin_float_double_extended;
+ typedef number<backends::cpp_bin_float<113, backends::digit_base_2, void, boost::int16_t, -16382, 16383>, et_off> cpp_bin_float_quad;
+
+ }} // namespaces
+
+Class template `cpp_bin_float` fulfils all of the requirements for a [link boost_multiprecision.ref.backendconc Backend] type.
+Its members and non-member functions are deliberately not documented: these are considered implementation details that are subject
+to change.
+
+The class takes six template parameters:
+
+[variablelist
+[[Digits][The number of digits precision the type
+should support. This is normally expresed as base-10 digits, but that can be changed via the second template parameter.]]
+[[base][An enumerated value (either `digit_base_10` or `digit_base_2`) that indicates whether `Digits` is base-10 or base-2]]
+[[Allocator][The allocator used: defaults to type `void`, meaning all storage is within the class, and no dynamic
+allocation is performed, but can be set to a standard library allocator if dynamic allocation makes more sense.]]
+[[Exponent][A signed integer type to use as the type of the exponent - defaults to `int`.]]
+[[ExponentMin][The smallest (most negative) permitted exponent, defaults to zero, meaning "define as small as possible
+given the limitations of the type and our internal requirements".]]
+[[ExponentMax][The largest (most positive) permitted exponent, defaults to zero, meaning "define as large as possible
+given the limitations of the type and our internal requirements".]]
+]
+
+The type of `number_category<cpp_bin_float<Args...> >::type` is `mpl::int_<number_kind_floating_point>`.
+
+More information on this type can be found in the [link boost_multiprecision.tut.floats.cpp_bin_float tutorial].
+
+[h4 Implementation Notes]
+
+Internally, an N-bit `cpp_bin_float` is represented as an N-bit unsigned integer along with an exponent and a sign.
+The integer part is normalized so that it's most significant bit is always 1. The decimal point is assumed to be
+directly after the most significant bit of the integer part. The special values zero, infinity and NaN all have
+the integer part set to zero, and the exponent to one of 3 special values above the maximum permitted exponent.
+
+Multiplication is trivial: multiply the two N-bit integer mantissa's to obtain a 2N-bit number, then round and
+adjust the sign and exponent.
+
+Addition and subtraction proceed similarly - if the exponents are such that there is overlap between the two
+values, then left shift the larger value to produce a number with between N and 2N bits, then perform integer
+addition or subtraction, round, and adjust the exponent.
+
+Division proceeds as follows: first scale the numerator by some power of 2 so that integer division will
+produce either an N-bit or N+1 bit result plus a remainder. If we get an N bit result then the size of
+twice the remainder compared to the denominator gives us the rounding direction. Otherwise we have one extra bit
+in the result which we can use to determine rounding (in this case ties occur only if the remainder is zero and
+the extra bit is a 1).
+
+Square root uses integer square root in a manner analogous to division.
+
+Decimal string to binary conversion proceeds as follows: first parse the digits to
+produce an integer multiplied by a decimal exponent. Note that we stop parsing digits
+once we have parsed as many as can possibly effect the result - this stops the integer
+part growing too large when there are a very large number of input digits provided.
+At this stage if the decimal exponent is positive then the result is an integer and we
+can in principle simply multiply by 10^N to get an exact integer result. In practice
+however, that could produce some very large integers. We also need to be able to divide
+by 10^N in the event that the exponent is negative. Therefore calculation of the 10^N
+values plus the multiplication or division are performed using limited precision
+integer arithmetic, plus an exponent, and a track of the accumulated error. At the end of
+the calculation we will either be able to round unambiguously, or the error will be such
+that we can't tell which way to round. In the latter case we simply up the precision and try
+again until we have an unambiguously rounded result.
+
+Binary to decimal conversion proceeds very similarly to the above, our aim is to calculate
+`mantissa * 2^shift * 10^E` where `E` is the decimal exponent and `shift` is calculated
+so that the result is an N bit integer assuming we want N digits printed in the result.
+As before we use limitted precision arithmetic to calculate the result and up the
+precision as necessary until the result is unambiguously correctly rounded. In addition
+our initial calculation of the decimal exponent may be out by 1, so we have to correct
+that and loop as well in the that case.
+
+[endsect]
+
[section:cpp_dec_ref cpp_dec_float]

 namespace boost{ namespace multiprecision{
@@ -3672,7 +3779,7 @@
allocation is performed, but can be set to a standard library allocator if dynamic allocation makes more sense.]]
]

-The type of `number_category<cpp_int<Args...> >::type` is `mpl::int_<number_kind_floating_point>`.
+The type of `number_category<cpp_dec_float<Args...> >::type` is `mpl::int_<number_kind_floating_point>`.

More information on this type can be found in the [link boost_multiprecision.tut.floats.cpp_dec_float tutorial].

Modified: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/numeric_limits_32_tables.qbk
==============================================================================
--- sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/numeric_limits_32_tables.qbk Sat Nov 9 12:00:41 2013 (r86601)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/numeric_limits_32_tables.qbk 2013-11-09 13:53:07 EST (Sat, 09 Nov 2013) (r86602)
@@ -6,12 +6,14 @@
http://www.boost.org/LICENSE_1_0.txt).
]

-[section:version_32 32-bit version information used for tables below.]
+[section:limits32 Numeric limits for 32-bit platform]
+These tables were generated using the following program and options:
+
[pre

Program:
 numeric_limits_qbk.cpp
-Wed Aug 28 14:27:58 2013
+Mon Nov 4 18:09:06 2013
BuildInfo:
 Platform Win32
 Compiler Microsoft Visual C++ version 10.0
@@ -19,9 +21,7 @@
 STL Dinkumware standard library version 520
 Boost version 1.55.0
]
-[endsect] [/section:version_32]

-[section:limits32 Numeric limits for 32-bit platform]
[table:integral_constants Integer types constants (`std::numeric_limits<T>::is_integer == true` && is_exact == true)
[[type][signed][bound][modulo][round][radix][digits][digits10]]
[[bool][unsigned][bound][no][to zero][2][1][0]]
@@ -76,12 +76,12 @@

[[cpp_dec_float_50][indeterminate][10][50][50][80][-222953000][-67108864][222953000][67108864][no][no]]

-[[bin_128bit_double_type][to nearest][2][113][34][36][-2147483422][-646392383][2147483421][646392383][no][traps]]
+[[bin_128bit_double_type][to nearest][2][377][113][115][-2147482894][-646392082][2147482893][646392082][no][traps]]
]
[table:float_functions Floating-point types functions (`std::numeric_limits<T>::is_integer == false`)
-[[function][float][double][long double][cpp_dec_50][cpp_bin_128]][[max][3.40282e+038][1.79769e+308][1.79769e+308][1e+67108865][1.63355e+646456925]]
-[[min][1.17549e-038][2.22507e-308][2.22507e-308][1e-67108864][6.12165e-646456926]]
-[[epsilon][1.19209e-007][2.22045e-016][2.22045e-016][1e-49][1.92593e-34]]
+[[function][float][double][long double][cpp_dec_50][cpp_bin_128]][[max][3.40282e+038][1.79769e+308][1.79769e+308][1e+67108865][1.85906e+646456766]]
+[[min][1.17549e-038][2.22507e-308][2.22507e-308][1e-67108864][5.37906e-646456767]]
+[[epsilon][1.19209e-007][2.22045e-016][2.22045e-016][1e-49][6.49713e-114]]
[[round_error][0.5][0.5][0.5][0.5][0.5]]
[[infinity][1.#INF][1.#INF][1.#INF][inf][inf]]
[[quiet_NaN][1.#QNAN][1.#QNAN][1.#QNAN][nan][nan]]

Modified: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/numeric_limits_qbk.cpp
==============================================================================
--- sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/numeric_limits_qbk.cpp Sat Nov 9 12:00:41 2013 (r86601)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/numeric_limits_qbk.cpp 2013-11-09 13:53:07 EST (Sat, 09 Nov 2013) (r86602)
@@ -52,10 +52,10 @@
// Assume that this will be run on MSVC to get the 32 or 64 bit info.
#ifdef _WIN32
 std::string bits32_64 = "32";
-std::string filename = "I:/boost-sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/numeric_limits_32_tables.qbk";
+std::string filename = "numeric_limits_32_tables.qbk";
#else
 std::string bits32_64 = "64";
-std::string filename = "I:/boost-sandbox/multiprecision.cpp_bin_float/libs/multiprecision/doc/numeric_limits_64_tables.qbk";
+std::string filename = "numeric_limits_64_tables.qbk";
#endif

#ifdef INT32_T_MAX
@@ -429,17 +429,15 @@
 "]""\n"
 << std::endl;

+ fout << "[section:limits"<< bits32_64 << " Numeric limits for " << bits32_64 << "-bit platform]" << std::endl;
+
 // Output platform version info (32 or 64).
- fout << "[section:version_" << bits32_64 << " "
- << bits32_64 << "-bit version information used for tables below." "]\n"
+ fout << "These tables were generated using the following program and options:\n\n"
 "[pre""\n"
 << versions()
 << "]""\n"
- "[endsect] [/section:version_32]" "\n"
 << std::endl;

- fout << "[section:limits"<< bits32_64 << " Numeric limits for " << bits32_64 << "-bit platform]" << std::endl;
-
 fout << "[table:integral_constants Integer types constants (`std::numeric_limits<T>::is_integer == true` && is_exact == true)" "\n"
 "[";

Modified: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/example/numeric_limits_snips.cpp
==============================================================================
--- sandbox/multiprecision.cpp_bin_float/libs/multiprecision/example/numeric_limits_snips.cpp Sat Nov 9 12:00:41 2013 (r86601)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/example/numeric_limits_snips.cpp 2013-11-09 13:53:07 EST (Sat, 09 Nov 2013) (r86602)
@@ -57,7 +57,7 @@

 typedef float T; // Any type: `double`, cpp_dec_float_50, bin_128bit_double_type ...

-#if defined(BOOST_NO_NUMERIC_LIMITS_LOWEST)
+#if defined(BOOST_NO_CXX11_NUMERIC_LIMITS)
 std::cout.precision(2 + std::numeric_limits<T>::digits * 3010U/10000U);
#else
# if (_MSC_VER <= 1600) // Correct wrong value for float.
@@ -347,11 +347,11 @@
 {
//[tolerance_3

- using boost::multiprecision::bin_float128;
+ using boost::multiprecision::cpp_bin_float_quad;

- bin_float128 tolerance = 3 * std::numeric_limits<bin_float128>::epsilon();
- bin_float128 expected = boost::math::constants::two_pi<bin_float128>();
- bin_float128 calculated = 2 * boost::math::constants::pi<bin_float128>();
+ cpp_bin_float_quad tolerance = 3 * std::numeric_limits<cpp_bin_float_quad>::epsilon();
+ cpp_bin_float_quad expected = boost::math::constants::two_pi<cpp_bin_float_quad>();
+ cpp_bin_float_quad calculated = 2 * boost::math::constants::pi<cpp_bin_float_quad>();
 using boost::test_tools::check_is_close;

 bool r = check_is_close(expected, calculated, tolerance);
@@ -363,19 +363,19 @@
 {
//[nan_1]

-/*`NaN can be used with binary multiprecision types like `bin_float128`:
+/*`NaN can be used with binary multiprecision types like `cpp_bin_float_quad`:
*/
- using boost::multiprecision::bin_float128;
+ using boost::multiprecision::cpp_bin_float_quad;

- if (std::numeric_limits<bin_float128>::has_quiet_NaN == true)
+ if (std::numeric_limits<cpp_bin_float_quad>::has_quiet_NaN == true)
 {
- bin_float128 tolerance = 3 * std::numeric_limits<bin_float128>::epsilon();
+ cpp_bin_float_quad tolerance = 3 * std::numeric_limits<cpp_bin_float_quad>::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
+ cpp_bin_float_quad NaN = std::numeric_limits<cpp_bin_float_quad>::quiet_NaN();
+ std::cout << "cpp_bin_float_quad NaN is " << NaN << std::endl; // cpp_bin_float_quad NaN is nan

- bin_float128 expected = NaN;
- bin_float128 calculated = 2 * NaN;
+ cpp_bin_float_quad expected = NaN;
+ cpp_bin_float_quad calculated = 2 * NaN;
 using boost::test_tools::check_is_close;

 bool r = check_is_close(expected, expected, tolerance);
@@ -386,7 +386,7 @@
 }
 else
 {
- std::cout << "Type " << typeid(bin_float128).name() << " does not have NaNs!" << std::endl;
+ std::cout << "Type " << typeid(cpp_bin_float_quad).name() << " does not have NaNs!" << std::endl;
 }

//] [/nan_1]
@@ -401,12 +401,12 @@

 #include <boost/math/special_functions/nonfinite_num_facets.hpp>

-Then we can equally well use a multiprecision type bin_float128:
+Then we can equally well use a multiprecision type cpp_bin_float_quad:

*/
- using boost::multiprecision::bin_float128;
+ using boost::multiprecision::cpp_bin_float_quad;

- typedef bin_float128 T;
+ typedef cpp_bin_float_quad T;

 using boost::math::nonfinite_num_put;
 using boost::math::nonfinite_num_get;

Modified: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/test/math/instances/instances.cpp
==============================================================================
--- sandbox/multiprecision.cpp_bin_float/libs/multiprecision/test/math/instances/instances.cpp Sat Nov 9 12:00:41 2013 (r86601)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/test/math/instances/instances.cpp 2013-11-09 13:53:07 EST (Sat, 09 Nov 2013) (r86602)
@@ -6,7 +6,7 @@
#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
#include <boost/math/special_functions.hpp>

-#define BOOST_MATH_TEST_TYPE boost::multiprecision::float128_t
+#define BOOST_MATH_TEST_TYPE boost::multiprecision::cpp_bin_float_quad

#include "../setup.hpp"

Modified: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/test/math/setup.hpp
==============================================================================
--- sandbox/multiprecision.cpp_bin_float/libs/multiprecision/test/math/setup.hpp Sat Nov 9 12:00:41 2013 (r86601)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/test/math/setup.hpp 2013-11-09 13:53:07 EST (Sat, 09 Nov 2013) (r86602)
@@ -95,9 +95,9 @@
#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>

-#define CPP_BIN_FLOAT_TESTS test(float128_t(), "float128_t");
+#define CPP_BIN_FLOAT_TESTS test(cpp_bin_float_quad(), "cpp_bin_float_quad");

-typedef boost::multiprecision::float128_t test_type_1;
+typedef boost::multiprecision::cpp_bin_float_quad test_type_1;

#else

Modified: sandbox/multiprecision.cpp_bin_float/libs/multiprecision/test/test_arithmetic_cpp_bin_float_1.cpp
==============================================================================
--- sandbox/multiprecision.cpp_bin_float/libs/multiprecision/test/test_arithmetic_cpp_bin_float_1.cpp Sat Nov 9 12:00:41 2013 (r86601)
+++ sandbox/multiprecision.cpp_bin_float/libs/multiprecision/test/test_arithmetic_cpp_bin_float_1.cpp 2013-11-09 13:53:07 EST (Sat, 09 Nov 2013) (r86602)
@@ -22,7 +22,7 @@
 test<boost::multiprecision::cpp_bin_float_50>();
 //test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<21> > >();
 test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<1000, boost::multiprecision::digit_base_10, std::allocator<void> > > >();
- //test<boost::multiprecision::float128_t>();
+ //test<boost::multiprecision::cpp_bin_float_quad>();
 return boost::report_errors();
}

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk