Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r86781 - in trunk: boost/multiprecision boost/multiprecision/cpp_bin_float libs/multiprecision/doc libs/multiprecision/doc/html libs/multiprecision/doc/html/boost_multiprecision libs/multiprecision/doc/html/boost_multiprecision/map libs/multiprecision/doc/html/boost_multiprecision/perf 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/floats/fp_eg libs/multiprecision/doc/html/boost_multiprecision/tut/interval libs/multiprecision/doc/html/boost_multiprecision/tut/ints libs/multiprecision/doc/html/boost_multiprecision/tut/ints/egs libs/multiprecision/doc/html/boost_multiprecision/tut/limits libs/multiprecision/doc/html/boost_multiprecision/tut/misc libs/multiprecision/doc/html/boost_multiprecision/tut/rational libs/multiprecision/example libs/multiprecision/performance libs/multiprecision/test libs/multiprecision/test/concepts libs/multiprecision/test/include_test libs/multiprecision/test/math libs/multiprecision/test/math/instances libs/multiprecision/tools
From: john_at_[hidden]
Date: 2013-11-21 14:05:42


Author: johnmaddock
Date: 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013)
New Revision: 86781
URL: http://svn.boost.org/trac/boost/changeset/86781

Log:
Initial merge of cpp_bin_float code from sandbox.

Added:
   trunk/boost/multiprecision/cpp_bin_float/
   trunk/boost/multiprecision/cpp_bin_float.hpp (contents, props changed)
   trunk/boost/multiprecision/cpp_bin_float/io.hpp (contents, props changed)
   trunk/boost/multiprecision/cpp_bin_float/transcendental.hpp (contents, props changed)
   trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/cpp_bin_float_ref.html (contents, props changed)
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_bin_float.html (contents, props changed)
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/input_output.html (contents, props changed)
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/limits.html (contents, props changed)
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/constants.html (contents, props changed)
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/functions.html (contents, props changed)
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/how_to_tell.html (contents, props changed)
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/limits32.html (contents, props changed)
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/serial.html (contents, props changed)
   trunk/libs/multiprecision/doc/numeric_limits_32_tables.qbk (contents, props changed)
   trunk/libs/multiprecision/doc/numeric_limits_qbk.cpp (contents, props changed)
   trunk/libs/multiprecision/example/cpp_bin_float_snips.cpp (contents, props changed)
   trunk/libs/multiprecision/example/numeric_limits_snips.cpp (contents, props changed)
   trunk/libs/multiprecision/test/include_test/cpp_bin_float_include_test.cpp (contents, props changed)
   trunk/libs/multiprecision/test/sincos.ipp (contents, props changed)
   trunk/libs/multiprecision/test/test_arithmetic_cpp_bin_float_1.cpp (contents, props changed)
   trunk/libs/multiprecision/test/test_arithmetic_cpp_bin_float_2.cpp (contents, props changed)
   trunk/libs/multiprecision/test/test_arithmetic_cpp_bin_float_3.cpp (contents, props changed)
   trunk/libs/multiprecision/test/test_cpp_bin_float.cpp (contents, props changed)
   trunk/libs/multiprecision/test/test_cpp_bin_float_io.cpp (contents, props changed)
   trunk/libs/multiprecision/tools/
      - copied from r86779, sandbox/multiprecision.cpp_bin_float/libs/multiprecision/tools/
Text files modified:
   trunk/boost/multiprecision/cpp_bin_float.hpp | 1559 ++++++++++++++++++++++++++++++
   trunk/boost/multiprecision/cpp_bin_float/io.hpp | 690 +++++++++++++
   trunk/boost/multiprecision/cpp_bin_float/transcendental.hpp | 132 ++
   trunk/libs/multiprecision/doc/Jamfile.v2 | 3
   trunk/libs/multiprecision/doc/html/boost_multiprecision/indexes.html | 17
   trunk/libs/multiprecision/doc/html/boost_multiprecision/intro.html | 8
   trunk/libs/multiprecision/doc/html/boost_multiprecision/map.html | 2
   trunk/libs/multiprecision/doc/html/boost_multiprecision/map/ack.html | 2
   trunk/libs/multiprecision/doc/html/boost_multiprecision/map/faq.html | 2
   trunk/libs/multiprecision/doc/html/boost_multiprecision/map/hist.html | 17
   trunk/libs/multiprecision/doc/html/boost_multiprecision/map/todo.html | 2
   trunk/libs/multiprecision/doc/html/boost_multiprecision/perf.html | 4
   trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/float_performance.html | 42
   trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/int_real_world.html | 4
   trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/integer_performance.html | 66
   trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/overhead.html | 4
   trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/rational_performance.html | 42
   trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/realworld.html | 10
   trunk/libs/multiprecision/doc/html/boost_multiprecision/ref.html | 9
   trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/backendconc.html | 6
   trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/cpp_bin_float_ref.html | 186 +++
   trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/cpp_dec_ref.html | 10
   trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/cpp_int_ref.html | 2
   trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/gmp_int_ref.html | 2
   trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/headers.html | 8
   trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/internals.html | 2
   trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/mpf_ref.html | 2
   trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/mpfr_ref.html | 8
   trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/number.html | 14
   trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/tom_int_ref.html | 2
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut.html | 15
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/conversions.html | 48
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats.html | 42
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_bin_float.html | 192 +++
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_dec_float.html | 14
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/float128.html | 8
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg.html | 2
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/aos.html | 10
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/gi.html | 14
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/jel.html | 18
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/nd.html | 14
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/poly_eg.html | 6
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/gmp_float.html | 9
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/mpfr_float.html | 9
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/gen_int.html | 2
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/input_output.html | 185 +++
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/interval.html | 2
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/interval/mpfi.html | 17
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints.html | 2
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/cpp_int.html | 8
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/egs.html | 2
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/egs/bitops.html | 10
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/egs/factorials.html | 6
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/gmp_int.html | 8
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/tom_int.html | 8
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/limits.html | 100 +
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/constants.html | 705 +++++++++++++
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/functions.html | 546 ++++++++++
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/how_to_tell.html | 168 +++
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/limits32.html | 2049 ++++++++++++++++++++++++++++++++++++++++
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/lits.html | 2
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/misc.html | 2
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/misc/debug_adaptor.html | 8
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/misc/logged_adaptor.html | 10
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/misc/visualizers.html | 14
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/mixed.html | 14
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/primetest.html | 6
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/random.html | 18
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational.html | 2
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational/br.html | 2
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational/cpp_rational.html | 8
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational/gmp_rational.html | 8
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational/rational_adaptor.html | 2
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational/tommath_rational.html | 8
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rounding.html | 2
   trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/serial.html | 63 +
   trunk/libs/multiprecision/doc/html/index.html | 26
   trunk/libs/multiprecision/doc/multiprecision.qbk | 1395 +++++++++++++++++++++++---
   trunk/libs/multiprecision/doc/numeric_limits_32_tables.qbk | 94 +
   trunk/libs/multiprecision/doc/numeric_limits_qbk.cpp | 719 ++++++++++++++
   trunk/libs/multiprecision/example/cpp_bin_float_snips.cpp | 39
   trunk/libs/multiprecision/example/numeric_limits_snips.cpp | 458 ++++++++
   trunk/libs/multiprecision/performance/performance_test.cpp | 20
   trunk/libs/multiprecision/performance/sf_performance.hpp | 11
   trunk/libs/multiprecision/performance/sf_performance_bessel2.cpp | 3
   trunk/libs/multiprecision/performance/sf_performance_bessel6.cpp | 3
   trunk/libs/multiprecision/performance/sf_performance_nct3.cpp | 3
   trunk/libs/multiprecision/performance/sf_performance_nct6.cpp | 3
   trunk/libs/multiprecision/performance/sf_performance_poly.cpp | 6
   trunk/libs/multiprecision/test/Jamfile.v2 | 68 +
   trunk/libs/multiprecision/test/concepts/number_concept_check.cpp | 13
   trunk/libs/multiprecision/test/concepts/sf_concept_check_basic.cpp | 9
   trunk/libs/multiprecision/test/concepts/sf_concept_check_bessel.cpp | 10
   trunk/libs/multiprecision/test/concepts/sf_concept_check_elliptic.cpp | 10
   trunk/libs/multiprecision/test/concepts/sf_concept_check_gamma.cpp | 10
   trunk/libs/multiprecision/test/concepts/sf_concept_check_poly.cpp | 10
   trunk/libs/multiprecision/test/include_test/cpp_bin_float_include_test.cpp | 12
   trunk/libs/multiprecision/test/math/instances/Jamfile.v2 | 3
   trunk/libs/multiprecision/test/math/setup.hpp | 22
   trunk/libs/multiprecision/test/sincos.ipp | 358 ++++++
   trunk/libs/multiprecision/test/test_acos.cpp | 15
   trunk/libs/multiprecision/test/test_arithmetic_cpp_bin_float_1.cpp | 28
   trunk/libs/multiprecision/test/test_arithmetic_cpp_bin_float_2.cpp | 27
   trunk/libs/multiprecision/test/test_arithmetic_cpp_bin_float_3.cpp | 27
   trunk/libs/multiprecision/test/test_asin.cpp | 9
   trunk/libs/multiprecision/test/test_atan.cpp | 9
   trunk/libs/multiprecision/test/test_cos.cpp | 22
   trunk/libs/multiprecision/test/test_cosh.cpp | 15
   trunk/libs/multiprecision/test/test_cpp_bin_float.cpp | 219 ++++
   trunk/libs/multiprecision/test/test_cpp_bin_float_io.cpp | 258 +++++
   trunk/libs/multiprecision/test/test_exp.cpp | 13
   trunk/libs/multiprecision/test/test_fpclassify.cpp | 9
   trunk/libs/multiprecision/test/test_log.cpp | 16
   trunk/libs/multiprecision/test/test_numeric_limits.cpp | 24
   trunk/libs/multiprecision/test/test_pow.cpp | 9
   trunk/libs/multiprecision/test/test_round.cpp | 12
   trunk/libs/multiprecision/test/test_sin.cpp | 23
   trunk/libs/multiprecision/test/test_sinh.cpp | 9
   trunk/libs/multiprecision/test/test_sqrt.cpp | 14
   trunk/libs/multiprecision/test/test_tan.cpp | 9
   trunk/libs/multiprecision/test/test_tanh.cpp | 9
   121 files changed, 10720 insertions(+), 606 deletions(-)

Added: trunk/boost/multiprecision/cpp_bin_float.hpp
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/boost/multiprecision/cpp_bin_float.hpp 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -0,0 +1,1559 @@
+///////////////////////////////////////////////////////////////
+// Copyright 2013 John Maddock. 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_
+
+#ifndef BOOST_MATH_CPP_BIN_FLOAT_HPP
+#define BOOST_MATH_CPP_BIN_FLOAT_HPP
+
+#include <boost/multiprecision/cpp_int.hpp>
+#include <boost/multiprecision/integer.hpp>
+#include <boost/math/special_functions/trunc.hpp>
+#include <boost/multiprecision/detail/float_string_cvt.hpp>
+
+namespace boost{ namespace multiprecision{ namespace backends{
+
+enum digit_base_type
+{
+ digit_base_2 = 2,
+ digit_base_10 = 10
+};
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4522) // multiple assignment operators specified
+#endif
+
+template <unsigned Digits, digit_base_type DigitBase = digit_base_10, class Allocator = void, class Exponent = int, Exponent MinExponent = 0, Exponent MaxExponent = 0>
+class cpp_bin_float
+{
+public:
+ static const unsigned bit_count = DigitBase == digit_base_2 ? Digits : (Digits * 1000uL) / 301uL + ((Digits * 1000uL) % 301 ? 2u : 1u);
+ typedef cpp_int_backend<is_void<Allocator>::value ? bit_count : 0, bit_count, is_void<Allocator>::value ? unsigned_magnitude : signed_magnitude, unchecked, Allocator> rep_type;
+ typedef cpp_int_backend<is_void<Allocator>::value ? 2 * bit_count : 0, 2 * bit_count, is_void<Allocator>::value ? unsigned_magnitude : signed_magnitude, unchecked, Allocator> double_rep_type;
+
+ typedef typename rep_type::signed_types signed_types;
+ typedef typename rep_type::unsigned_types unsigned_types;
+ typedef boost::mpl::list<double, long double> float_types;
+ typedef Exponent exponent_type;
+
+ static const exponent_type max_exponent_limit = boost::integer_traits<exponent_type>::const_max - 2 * static_cast<exponent_type>(bit_count);
+ static const exponent_type min_exponent_limit = boost::integer_traits<exponent_type>::const_min + 2 * static_cast<exponent_type>(bit_count);
+
+ BOOST_STATIC_ASSERT_MSG(MinExponent >= min_exponent_limit, "Template parameter MinExponent is too negative for our internal logic to function correctly, sorry!");
+ BOOST_STATIC_ASSERT_MSG(MaxExponent <= max_exponent_limit, "Template parameter MaxExponent is too large for our internal logic to function correctly, sorry!");
+ BOOST_STATIC_ASSERT_MSG(MinExponent <= 0, "Template parameter MinExponent can not be positive!");
+ BOOST_STATIC_ASSERT_MSG(MaxExponent >= 0, "Template parameter MaxExponent can not be negative!");
+
+ static const exponent_type max_exponent = MaxExponent == 0 ? max_exponent_limit : MaxExponent;
+ static const exponent_type min_exponent = MinExponent == 0 ? min_exponent_limit : MinExponent;
+
+ static const exponent_type exponent_zero = max_exponent + 1;
+ static const exponent_type exponent_infinity = max_exponent + 2;
+ static const exponent_type exponent_nan = max_exponent + 3;
+
+private:
+
+ rep_type m_data;
+ exponent_type m_exponent;
+ bool m_sign;
+public:
+ cpp_bin_float() : m_data(), m_exponent(exponent_nan), m_sign(false) {}
+
+ cpp_bin_float(const cpp_bin_float &o)
+ : m_data(o.m_data), m_exponent(o.m_exponent), m_sign(o.m_sign) {}
+
+ template <unsigned D, digit_base_type B, class A, class E, E MinE, E MaxE>
+ cpp_bin_float(const cpp_bin_float<D, B, A, E, MinE, MaxE> &o, typename boost::enable_if_c<(bit_count >= cpp_bin_float<D, B, A, E, MinE, MaxE>::bit_count)>::type const* = 0)
+ : m_exponent(o.exponent()), m_sign(o.sign())
+ {
+ typename cpp_bin_float<D, B, A, E, MinE, MaxE>::rep_type b(o.bits());
+ copy_and_round(*this, b);
+ }
+
+ template <unsigned D, digit_base_type B, class A, class E, E MinE, E MaxE>
+ explicit cpp_bin_float(const cpp_bin_float<D, B, A, E, MinE, MaxE> &o, typename boost::disable_if_c<(bit_count >= cpp_bin_float<D, B, A, E, MinE, MaxE>::bit_count)>::type const* = 0)
+ : m_exponent(o.exponent()), m_sign(o.sign())
+ {
+ typename cpp_bin_float<D, B, A, E, MinE, MaxE>::rep_type b(o.bits());
+ copy_and_round(*this, b);
+ }
+
+ template <class Float>
+ cpp_bin_float(const Float& f,
+ typename boost::enable_if_c<
+ (number_category<Float>::value == number_kind_floating_point)
+ && (std::numeric_limits<Float>::digits <= bit_count)
+ && (std::numeric_limits<Float>::radix == 2)
+ >::type const* = 0)
+ : m_data(), m_exponent(0), m_sign(false)
+ {
+ this->assign_float(f);
+ }
+
+ cpp_bin_float& operator=(const cpp_bin_float &o)
+ {
+ m_data = o.m_data;
+ m_exponent = o.m_exponent;
+ m_sign = o.m_sign;
+ return *this;
+ }
+
+ template <unsigned D, digit_base_type B, class A, class E, E MinE, E MaxE>
+ typename boost::enable_if_c<bit_count >= cpp_bin_float<D, B, A, E, MinE, MaxE>::bit_count, cpp_bin_float&>::type operator=(const cpp_bin_float &o)
+ {
+ typename cpp_bin_float<D, B, A, E, MinE, MaxE>::rep_type b(o.bits());
+ copy_and_round(*this, b);
+ }
+
+ template <class Float>
+ typename boost::enable_if_c<
+ (number_category<Float>::value == number_kind_floating_point)
+ && (std::numeric_limits<Float>::digits <= bit_count)
+ && (std::numeric_limits<Float>::radix == 2), cpp_bin_float&>::type operator=(const Float& f)
+ {
+ return assign_float(f);
+ }
+
+ template <class Float>
+ typename boost::enable_if_c<is_floating_point<Float>::value, cpp_bin_float&>::type assign_float(Float f)
+ {
+ BOOST_MATH_STD_USING
+ using default_ops::eval_add;
+
+ switch((boost::math::fpclassify)(f))
+ {
+ case FP_ZERO:
+ m_data = limb_type(0);
+ m_sign = false;
+ m_exponent = exponent_zero;
+ return *this;
+ case FP_NAN:
+ m_data = limb_type(0);
+ m_sign = false;
+ m_exponent = exponent_nan;
+ return *this;
+ case FP_INFINITE:
+ m_data = limb_type(0);
+ m_sign = false;
+ m_exponent = exponent_infinity;
+ return *this;
+ }
+ if(f < 0)
+ {
+ *this = -f;
+ this->negate();
+ return *this;
+ }
+
+ typedef typename mpl::front<unsigned_types>::type ui_type;
+ m_data = static_cast<ui_type>(0u);
+ m_sign = false;
+ m_exponent = 0;
+
+ static const int bits = sizeof(int) * CHAR_BIT - 1;
+ int e;
+ f = frexp(f, &e);
+ while(f)
+ {
+ f = ldexp(f, bits);
+ e -= bits;
+ int ipart = itrunc(f);
+ f -= ipart;
+ m_exponent += bits;
+ eval_add(*this, ipart);
+ }
+ m_exponent += static_cast<Exponent>(e);
+ return *this;
+ }
+
+ template <class Float>
+ typename boost::enable_if_c<
+ (number_category<Float>::value == number_kind_floating_point)
+ && !is_floating_point<Float>::value
+ /*&& (std::numeric_limits<number<Float> >::radix == 2)*/,
+ cpp_bin_float&>::type assign_float(Float f)
+ {
+ BOOST_MATH_STD_USING
+ using default_ops::eval_add;
+ using default_ops::eval_get_sign;
+ using default_ops::eval_convert_to;
+ using default_ops::eval_subtract;
+
+ typedef typename boost::multiprecision::detail::canonical<int, Float>::type f_int_type;
+ typedef typename boost::multiprecision::detail::canonical<int, cpp_bin_float>::type bf_int_type;
+
+ switch(eval_fpclassify(f))
+ {
+ case FP_ZERO:
+ m_data = limb_type(0);
+ m_sign = false;
+ m_exponent = exponent_zero;
+ return *this;
+ case FP_NAN:
+ m_data = limb_type(0);
+ m_sign = false;
+ m_exponent = exponent_nan;
+ return *this;
+ case FP_INFINITE:
+ m_data = limb_type(0);
+ m_sign = false;
+ m_exponent = exponent_infinity;
+ return *this;
+ }
+ if(eval_get_sign(f) < 0)
+ {
+ f.negate();
+ *this = f;
+ this->negate();
+ return *this;
+ }
+
+ typedef typename mpl::front<unsigned_types>::type ui_type;
+ m_data = static_cast<ui_type>(0u);
+ m_sign = false;
+ m_exponent = 0;
+
+ static const int bits = sizeof(int) * CHAR_BIT - 1;
+ int e;
+ eval_frexp(f, f, &e);
+ while(eval_get_sign(f) != 0)
+ {
+ eval_ldexp(f, f, bits);
+ e -= bits;
+ int ipart;
+ eval_convert_to(&ipart, f);
+ eval_subtract(f, static_cast<f_int_type>(ipart));
+ m_exponent += bits;
+ eval_add(*this, static_cast<bf_int_type>(ipart));
+ }
+ m_exponent += e;
+ if(m_exponent > max_exponent)
+ m_exponent = exponent_infinity;
+ if(m_exponent < min_exponent)
+ {
+ m_data = limb_type(0u);
+ m_exponent = exponent_zero;
+ m_sign = false;
+ }
+ else if(eval_get_sign(m_data) == 0)
+ {
+ m_exponent = exponent_zero;
+ m_sign = false;
+ }
+ return *this;
+ }
+
+ template <class I>
+ typename boost::enable_if<is_integral<I>, cpp_bin_float&>::type operator=(const I& i)
+ {
+ using default_ops::eval_bit_test;
+ if(!i)
+ {
+ m_data = static_cast<limb_type>(0);
+ m_exponent = exponent_zero;
+ m_sign = false;
+ }
+ else
+ {
+ typedef typename make_unsigned<I>::type ui_type;
+ ui_type fi = static_cast<ui_type>(boost::multiprecision::detail::abs(i));
+ typedef typename boost::multiprecision::detail::canonical<ui_type, rep_type>::type ar_type;
+ m_data = static_cast<ar_type>(fi);
+ unsigned shift = msb(fi);
+ if(shift >= bit_count)
+ {
+ m_exponent = static_cast<Exponent>(shift);
+ m_data = static_cast<limb_type>(fi >> (shift + 1 - bit_count));
+ }
+ else
+ {
+ m_exponent = static_cast<Exponent>(shift);
+ eval_left_shift(m_data, bit_count - shift - 1);
+ }
+ BOOST_ASSERT(eval_bit_test(m_data, bit_count-1));
+ m_sign = i < 0;
+ }
+ return *this;
+ }
+
+ cpp_bin_float& operator=(const char *s);
+
+ void swap(cpp_bin_float &o) BOOST_NOEXCEPT
+ {
+ m_data.swap(o.m_data);
+ std::swap(m_exponent, o.m_exponent);
+ std::swap(m_sign, o.m_sign);
+ }
+
+ std::string str(std::streamsize dig, std::ios_base::fmtflags f) const;
+
+ void negate()
+ {
+ if((m_exponent != exponent_zero) && (m_exponent != exponent_nan))
+ m_sign = !m_sign;
+ }
+
+ int compare(const cpp_bin_float &o) const BOOST_NOEXCEPT
+ {
+ if(m_sign != o.m_sign)
+ return m_sign ? -1 : 1;
+ int result;
+ if(m_exponent != o.m_exponent)
+ {
+ if(m_exponent == exponent_zero)
+ result = -1;
+ else if(o.m_exponent == exponent_zero)
+ result = 1;
+ else
+ result = m_exponent > o.m_exponent ? 1 : -1;
+ }
+ else
+ result = m_data.compare(o.m_data);
+ if(m_sign)
+ result = -result;
+ return result;
+ }
+ template <class A>
+ int compare(const A& o) const BOOST_NOEXCEPT
+ {
+ cpp_bin_float b;
+ b = o;
+ return compare(b);
+ }
+
+ rep_type& bits() { return m_data; }
+ const rep_type& bits()const { return m_data; }
+ exponent_type& exponent() { return m_exponent; }
+ const exponent_type& exponent()const { return m_exponent; }
+ bool& sign() { return m_sign; }
+ const bool& sign()const { return m_sign; }
+ void check_invariants()
+ {
+ using default_ops::eval_bit_test;
+ using default_ops::eval_is_zero;
+ if((m_exponent <= max_exponent) && (m_exponent >= min_exponent))
+ {
+ BOOST_ASSERT(eval_bit_test(m_data, bit_count - 1));
+ }
+ else
+ {
+ BOOST_ASSERT(m_exponent > max_exponent);
+ BOOST_ASSERT(m_exponent <= exponent_nan);
+ BOOST_ASSERT(eval_is_zero(m_data));
+ }
+ }
+};
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, class Int>
+inline void copy_and_round(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, Int &arg)
+{
+ // Precondition: exponent of res must have been set before this function is called
+ // as we may need to adjust it based on how many cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count in arg are set.
+ using default_ops::eval_msb;
+ using default_ops::eval_lsb;
+ using default_ops::eval_left_shift;
+ using default_ops::eval_bit_test;
+ using default_ops::eval_right_shift;
+ using default_ops::eval_increment;
+ using default_ops::eval_get_sign;
+
+ // cancellation may have resulted in arg being all zeros:
+ if(eval_get_sign(arg) == 0)
+ {
+ res.exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero;
+ res.sign() = false;
+ res.bits() = static_cast<limb_type>(0u);
+ return;
+ }
+ int msb = eval_msb(arg);
+ if(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count > msb + 1)
+ {
+ // Must have had cancellation in subtraction, shift left and copy:
+ eval_left_shift(arg, cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - msb - 1);
+ res.exponent() -= static_cast<Exponent>(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - msb - 1);
+ }
+ else if(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count < msb + 1)
+ {
+ // We have more cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count than we need, so round as required,
+ // first get the rounding bit:
+ bool roundup = eval_bit_test(arg, msb - cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count);
+ // Then check for a tie:
+ if(roundup && (msb - cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count == eval_lsb(arg)))
+ {
+ // Ties round towards even:
+ if(!eval_bit_test(arg, msb - cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count + 1))
+ roundup = false;
+ }
+ // Shift off the cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count we don't need:
+ eval_right_shift(arg, msb - cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count + 1);
+ res.exponent() += static_cast<Exponent>(msb - (int)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count + 1);
+ if(roundup)
+ {
+ eval_increment(arg);
+ if(eval_bit_test(arg, cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count))
+ {
+ // This happens very very rairly:
+ eval_right_shift(arg, 1u);
+ ++res.exponent();
+ }
+ }
+ }
+ BOOST_ASSERT((eval_msb(arg) == cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1));
+ res.bits() = arg;
+
+ if(res.exponent() > cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent)
+ {
+ // Overflow:
+ res.exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity;
+ res.bits() = static_cast<limb_type>(0u);
+ }
+ else if(res.exponent() < cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent)
+ {
+ // Underflow:
+ res.exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero;
+ res.bits() = static_cast<limb_type>(0u);
+ res.sign() = false;
+ }
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline void do_eval_add(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &a, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &b)
+{
+ using default_ops::eval_add;
+ using default_ops::eval_bit_test;
+
+ typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::double_rep_type dt;
+
+ // Special cases first:
+ switch(a.exponent())
+ {
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
+ res = b;
+ if(res.sign())
+ res.negate();
+ return;
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
+ if(b.exponent() == cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan)
+ res = b;
+ else
+ res = a;
+ return; // ault is still infinite.
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
+ res = a;
+ return; // ault is still a NaN.
+ }
+ switch(b.exponent())
+ {
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
+ res = a;
+ return;
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
+ res = b;
+ if(res.sign())
+ res.negate();
+ return; // ault is infinite.
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
+ res = b;
+ return; // ault is a NaN.
+ }
+
+ typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type e_diff = a.exponent() - b.exponent();
+ bool s = a.sign();
+ if(e_diff >= 0)
+ {
+ dt = a.bits();
+ if(e_diff < cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count)
+ {
+ eval_left_shift(dt, e_diff);
+ res.exponent() = a.exponent() - e_diff;
+ eval_add(dt, b.bits());
+ }
+ else
+ res.exponent() = a.exponent();
+ }
+ else
+ {
+ dt= b.bits();
+ if(-e_diff < cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count)
+ {
+ eval_left_shift(dt, -e_diff);
+ res.exponent() = b.exponent() + e_diff;
+ eval_add(dt, a.bits());
+ }
+ else
+ res.exponent() = b.exponent();
+ }
+
+ copy_and_round(res, dt);
+ res.check_invariants();
+ if(res.sign() != s)
+ res.negate();
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline void do_eval_subtract(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &a, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &b)
+{
+ using default_ops::eval_subtract;
+ using default_ops::eval_bit_test;
+
+ typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::double_rep_type dt;
+
+ // Special cases first:
+ switch(a.exponent())
+ {
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
+ if(b.exponent() == cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan)
+ res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
+ else
+ {
+ res = b;
+ if(!res.sign())
+ res.negate();
+ }
+ return;
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
+ if((b.exponent() == cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan) || (b.exponent() == cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity))
+ res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
+ else
+ res = a;
+ return;
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
+ res = a;
+ return; // result is still a NaN.
+ }
+ switch(b.exponent())
+ {
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
+ res = a;
+ return;
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
+ res.exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan;
+ res.sign() = false;
+ res.bits() = static_cast<limb_type>(0u);
+ return; // result is a NaN.
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
+ res = b;
+ return; // result is still a NaN.
+ }
+
+ typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type e_diff = a.exponent() - b.exponent();
+ bool s = a.sign();
+ if((e_diff > 0) || ((e_diff == 0) && a.bits().compare(b.bits()) >= 0))
+ {
+ dt = a.bits();
+ if(e_diff < cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count)
+ {
+ eval_left_shift(dt, e_diff);
+ res.exponent() = a.exponent() - e_diff;
+ eval_subtract(dt, b.bits());
+ }
+ else
+ res.exponent() = a.exponent();
+ }
+ else
+ {
+ dt = b.bits();
+ if(-e_diff < cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count)
+ {
+ eval_left_shift(dt, -e_diff);
+ res.exponent() = b.exponent() + e_diff;
+ eval_subtract(dt, a.bits());
+ }
+ else
+ res.exponent() = b.exponent();
+ s = !s;
+ }
+
+ copy_and_round(res, dt);
+ if(res.sign() != s)
+ res.negate();
+ res.check_invariants();
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline void eval_add(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &a, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &b)
+{
+ if(a.sign() == b.sign())
+ do_eval_add(res, a, b);
+ else
+ do_eval_subtract(res, a, b);
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline void eval_add(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &a)
+{
+ return eval_add(res, res, a);
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline void eval_subtract(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &a, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &b)
+{
+ if(a.sign() != b.sign())
+ do_eval_add(res, a, b);
+ else
+ do_eval_subtract(res, a, b);
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline void eval_subtract(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &a)
+{
+ return eval_subtract(res, res, a);
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline void eval_multiply(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &a, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &b)
+{
+ using default_ops::eval_bit_test;
+ using default_ops::eval_multiply;
+
+ // Special cases first:
+ switch(a.exponent())
+ {
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
+ if(b.exponent() == cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan)
+ res = b;
+ else
+ res = a;
+ return;
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
+ switch(b.exponent())
+ {
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
+ res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
+ break;
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
+ res = b;
+ break;
+ default:
+ res = a;
+ break;
+ }
+ return;
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
+ res = a;
+ return;
+ }
+ if(b.exponent() > cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent)
+ {
+ res = b;
+ return;
+ }
+ if((a.exponent() > 0) && (b.exponent() > 0))
+ {
+ if(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent + 2 - a.exponent() < b.exponent())
+ {
+ // We will certainly overflow:
+ res.exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity;
+ res.sign() = a.sign() != b.sign();
+ res.bits() = static_cast<limb_type>(0u);
+ return;
+ }
+ }
+ if((a.exponent() < 0) && (b.exponent() < 0))
+ {
+ if(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent - 2 - a.exponent() > b.exponent())
+ {
+ // We will certainly underflow:
+ res.exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero;
+ res.sign() = false;
+ res.bits() = static_cast<limb_type>(0u);
+ return;
+ }
+ }
+
+ typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::double_rep_type dt;
+ eval_multiply(dt, a.bits(), b.bits());
+ res.exponent() = a.exponent() + b.exponent() - cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count + 1;
+ copy_and_round(res, dt);
+ res.check_invariants();
+ res.sign() = a.sign() != b.sign();
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline void eval_multiply(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &a)
+{
+ eval_multiply(res, res, a);
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, class U>
+inline typename enable_if_c<is_unsigned<U>::value>::type eval_multiply(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &a, const U &b)
+{
+ using default_ops::eval_bit_test;
+ using default_ops::eval_multiply;
+
+ // Special cases first:
+ switch(a.exponent())
+ {
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
+ res = a;
+ return;
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
+ if(b == 0)
+ res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
+ else
+ res = a;
+ return;
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
+ res = a;
+ return;
+ }
+
+ typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::double_rep_type dt;
+ typedef typename boost::multiprecision::detail::canonical<U, typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::double_rep_type>::type canon_ui_type;
+ eval_multiply(dt, a.bits(), static_cast<canon_ui_type>(b));
+ res.exponent() = a.exponent();
+ copy_and_round(res, dt);
+ res.check_invariants();
+ res.sign() = a.sign();
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, class U>
+inline typename enable_if_c<is_unsigned<U>::value>::type eval_multiply(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const U &b)
+{
+ eval_multiply(res, res, b);
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, class S>
+inline typename enable_if_c<is_signed<S>::value>::type eval_multiply(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &a, const S &b)
+{
+ typedef typename make_unsigned<S>::type ui_type;
+ eval_multiply(res, a, static_cast<ui_type>(boost::multiprecision::detail::abs(b)));
+ if(b < 0)
+ res.negate();
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, class S>
+inline typename enable_if_c<is_signed<S>::value>::type eval_multiply(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const S &b)
+{
+ eval_multiply(res, res, b);
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline void eval_divide(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &u, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &v)
+{
+ using default_ops::eval_subtract;
+ using default_ops::eval_qr;
+ using default_ops::eval_bit_test;
+ using default_ops::eval_get_sign;
+ using default_ops::eval_increment;
+
+ //
+ // Special cases first:
+ //
+ switch(u.exponent())
+ {
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
+ switch(v.exponent())
+ {
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
+ res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
+ return;
+ }
+ res = u;
+ return;
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
+ switch(v.exponent())
+ {
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
+ res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
+ return;
+ }
+ res = u;
+ return;
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
+ res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
+ return;
+ }
+ switch(v.exponent())
+ {
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
+ {
+ bool s = u.sign() != v.sign();
+ res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::infinity().backend();
+ res.sign() = s;
+ return;
+ }
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
+ res.exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero;
+ res.bits() = limb_type(0);
+ res.sign() = false;
+ return;
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
+ res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
+ return;
+ }
+
+ // We can scale u and v so that both are integers, then perform integer
+ // division to obtain quotient q and remainder r, such that:
+ //
+ // q * v + r = u
+ //
+ // and hense:
+ //
+ // q + r/v = u/v
+ //
+ // From this, assuming q has "cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count" cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count, we only need to determine whether
+ // r/v is less than, equal to, or greater than 0.5 to determine rounding -
+ // this we can do with a shift and comparison.
+ //
+ // We can set the exponent and sign of the result up front:
+ //
+ res.exponent() = u.exponent() - v.exponent() - 1;
+ res.sign() = u.sign() != v.sign();
+ //
+ // Now get the quotient and remainder:
+ //
+ typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::double_rep_type t(u.bits()), t2(v.bits()), q, r;
+ eval_left_shift(t, cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count);
+ eval_qr(t, t2, q, r);
+ //
+ // We now have either "cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count" or "cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count+1" significant cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count in q.
+ //
+ static const unsigned limb_bits = sizeof(limb_type) * CHAR_BIT;
+ if(eval_bit_test(q, cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count))
+ {
+ //
+ // OK we have cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count+1 cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count, so we already have rounding info,
+ // we just need to changes things if the last bit is 1 and the
+ // remainder is non-zero (ie we do not have a tie).
+ //
+ BOOST_ASSERT((eval_msb(q) == cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count));
+ if((q.limbs()[0] & 1u) && eval_get_sign(r))
+ {
+ eval_increment(q);
+ }
+ }
+ else
+ {
+ //
+ // We have exactly "cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count" cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count in q.
+ // Get rounding info, which we can get by comparing 2r with v.
+ // We want to call copy_and_round to handle rounding and general cleanup,
+ // so we'll left shift q and add some fake digits on the end to represent
+ // how we'll be rounding.
+ //
+ BOOST_ASSERT((eval_msb(q) == cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1));
+ static const unsigned lshift = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count < limb_bits ? 2 : limb_bits;
+ eval_left_shift(q, lshift);
+ res.exponent() -= lshift;
+ eval_left_shift(r, 1u);
+ int c = r.compare(v.bits());
+ if(c == 0)
+ q.limbs()[0] |= static_cast<limb_type>(1u) << (lshift - 1);
+ else if(c > 0)
+ q.limbs()[0] |= (static_cast<limb_type>(1u) << (lshift - 1)) + static_cast<limb_type>(1u);
+ }
+ copy_and_round(res, q);
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline void eval_divide(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &arg)
+{
+ eval_divide(res, res, arg);
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, class U>
+inline typename enable_if_c<is_unsigned<U>::value>::type eval_divide(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &u, const U &v)
+{
+ using default_ops::eval_subtract;
+ using default_ops::eval_qr;
+ using default_ops::eval_bit_test;
+ using default_ops::eval_get_sign;
+ using default_ops::eval_increment;
+
+ //
+ // Special cases first:
+ //
+ switch(u.exponent())
+ {
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
+ if(v == 0)
+ {
+ res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
+ return;
+ }
+ res = u;
+ return;
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
+ res = u;
+ return;
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
+ res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
+ return;
+ }
+ if(v == 0)
+ {
+ bool s = u.sign();
+ res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::infinity().backend();
+ res.sign() = s;
+ return;
+ }
+
+ // We can scale u and v so that both are integers, then perform integer
+ // division to obtain quotient q and remainder r, such that:
+ //
+ // q * v + r = u
+ //
+ // and hense:
+ //
+ // q + r/v = u/v
+ //
+ // From this, assuming q has "cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count" cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count, we only need to determine whether
+ // r/v is less than, equal to, or greater than 0.5 to determine rounding -
+ // this we can do with a shift and comparison.
+ //
+ // We can set the exponent and sign of the result up front:
+ //
+ int gb = msb(v);
+ res.exponent() = u.exponent() - static_cast<Exponent>(gb) - static_cast<Exponent>(1);
+ res.sign() = u.sign();
+ //
+ // Now get the quotient and remainder:
+ //
+ typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::double_rep_type t(u.bits()), q, r;
+ eval_left_shift(t, gb + 1);
+ eval_qr(t, number<typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::double_rep_type>::canonical_value(v), q, r);
+ //
+ // We now have either "cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count" or "cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count+1" significant cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count in q.
+ //
+ static const unsigned limb_bits = sizeof(limb_type) * CHAR_BIT;
+ if(eval_bit_test(q, cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count))
+ {
+ //
+ // OK we have cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count+1 cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count, so we already have rounding info,
+ // we just need to changes things if the last bit is 1 and the
+ // remainder is non-zero (ie we do not have a tie).
+ //
+ BOOST_ASSERT((eval_msb(q) == cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count));
+ if((q.limbs()[0] & 1u) && eval_get_sign(r))
+ {
+ eval_increment(q);
+ }
+ }
+ else
+ {
+ //
+ // We have exactly "cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count" cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count in q.
+ // Get rounding info, which we can get by comparing 2r with v.
+ // We want to call copy_and_round to handle rounding and general cleanup,
+ // so we'll left shift q and add some fake cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count on the end to represent
+ // how we'll be rounding.
+ //
+ BOOST_ASSERT((eval_msb(q) == cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1));
+ static const unsigned lshift = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count < limb_bits ? 2 : limb_bits;
+ eval_left_shift(q, lshift);
+ res.exponent() -= lshift;
+ eval_left_shift(r, 1u);
+ int c = r.compare(number<typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::double_rep_type>::canonical_value(v));
+ if(c == 0)
+ q.limbs()[0] |= static_cast<limb_type>(1u) << (lshift - 1);
+ else if(c > 0)
+ q.limbs()[0] |= (static_cast<limb_type>(1u) << (lshift - 1)) + static_cast<limb_type>(1u);
+ }
+ copy_and_round(res, q);
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, class U>
+inline typename enable_if_c<is_unsigned<U>::value>::type eval_divide(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const U &v)
+{
+ eval_divide(res, res, v);
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, class S>
+inline typename enable_if_c<is_signed<S>::value>::type eval_divide(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &u, const S &v)
+{
+ typedef typename make_unsigned<S>::type ui_type;
+ eval_divide(res, u, static_cast<ui_type>(boost::multiprecision::detail::abs(v)));
+ if(v < 0)
+ res.negate();
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, class S>
+inline typename enable_if_c<is_signed<S>::value>::type eval_divide(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const S &v)
+{
+ eval_divide(res, res, v);
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline int eval_get_sign(const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &arg)
+{
+ return arg.exponent() == cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero ? 0 : arg.sign() ? -1 : 1;
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline bool eval_is_zero(const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &arg)
+{
+ return arg.exponent() == cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero;
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline bool eval_eq(const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &a, cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &b)
+{
+ return (a.exponent() == b.exponent())
+ && (a.sign() == b.sign())
+ && (a.bits().compare(b.bits()) == 0)
+ && (a.exponent() != cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan);
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline void eval_convert_to(long long *res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &arg)
+{
+ switch(arg.exponent())
+ {
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
+ *res = 0;
+ return;
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
+ BOOST_THROW_EXCEPTION(std::runtime_error("Could not convert NaN to integer."));
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
+ *res = (std::numeric_limits<long long>::max)();
+ if(arg.sign())
+ *res = -*res;
+ return;
+ }
+ typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::rep_type man(arg.bits());
+ typename mpl::if_c<sizeof(typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type) < sizeof(int), int, typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type>::type shift
+ = (int)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1 - arg.exponent();
+ if(shift > (int)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1)
+ {
+ *res = 0;
+ return;
+ }
+ else if(shift < 0)
+ {
+ // TODO: what if we have fewer cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count than a long long?
+ *res = (std::numeric_limits<long long>::max)();
+ if(arg.sign())
+ *res = -*res;
+ return;
+ }
+ eval_right_shift(man, shift);
+ eval_convert_to(res, man);
+ if(arg.sign())
+ *res = -*res;
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline void eval_convert_to(unsigned long long *res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &arg)
+{
+ switch(arg.exponent())
+ {
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
+ *res = 0;
+ return;
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
+ BOOST_THROW_EXCEPTION(std::runtime_error("Could not convert NaN to integer."));
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
+ *res = (std::numeric_limits<unsigned long long>::max)();
+ return;
+ }
+ typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::rep_type man(arg.bits());
+ typename mpl::if_c<sizeof(typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type) < sizeof(int), int, typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type>::type shift
+ = (int)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1 - arg.exponent();
+ if(shift > (int)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1)
+ {
+ *res = 0;
+ return;
+ }
+ else if(shift < 0)
+ {
+ // TODO: what if we have fewer cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count than a long long?
+ *res = (std::numeric_limits<long long>::max)();
+ return;
+ }
+ eval_right_shift(man, shift);
+ eval_convert_to(res, man);
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline void eval_convert_to(long double *res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &arg)
+{
+ switch(arg.exponent())
+ {
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
+ *res = 0;
+ return;
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
+ *res = std::numeric_limits<long double>::quiet_NaN();
+ return;
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
+ *res = (std::numeric_limits<long double>::infinity)();
+ if(arg.sign())
+ *res = -*res;
+ return;
+ }
+ typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type e = arg.exponent();
+ e -= cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1;
+ *res = std::ldexp(static_cast<long double>(*arg.bits().limbs()), e);
+ for(unsigned i = 1; i < arg.bits().size(); ++i)
+ {
+ e += sizeof(*arg.bits().limbs()) * CHAR_BIT;
+ *res += std::ldexp(static_cast<long double>(arg.bits().limbs()[i]), e);
+ }
+ if(arg.sign())
+ *res = -*res;
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline void eval_frexp(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &arg, Exponent *e)
+{
+ switch(arg.exponent())
+ {
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
+ *e = 0;
+ res = arg;
+ return;
+ }
+ res = arg;
+ *e = arg.exponent() + 1;
+ res.exponent() = -1;
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, class I>
+inline void eval_frexp(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &arg, I *pe)
+{
+ Exponent e;
+ eval_frexp(res, arg, &e);
+ if((e > (std::numeric_limits<I>::max)()) || (e < (std::numeric_limits<I>::min)()))
+ {
+ BOOST_THROW_EXCEPTION(std::runtime_error("Exponent was outside of the range of the argument type to frexp."));
+ }
+ *pe = static_cast<I>(e);
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline void eval_ldexp(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &arg, Exponent e)
+{
+ switch(arg.exponent())
+ {
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
+ res = arg;
+ return;
+ }
+ if((e > 0) && (cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent - e < arg.exponent()))
+ {
+ // Overflow:
+ res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::infinity().backend();
+ res.sign() = arg.sign();
+ }
+ else if((e < 0) && (cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent - e > arg.exponent()))
+ {
+ // Underflow:
+ res = limb_type(0);
+ }
+ else
+ {
+ res = arg;
+ res.exponent() += e;
+ }
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, class I>
+inline typename enable_if_c<is_unsigned<I>::value>::type eval_ldexp(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &arg, I e)
+{
+ typedef typename make_signed<I>::type si_type;
+ if(e > static_cast<I>((std::numeric_limits<si_type>::max)()))
+ res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::infinity().backend();
+ else
+ eval_ldexp(res, arg, static_cast<si_type>(e));
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, class I>
+inline typename enable_if_c<is_signed<I>::value>::type eval_ldexp(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &arg, I e)
+{
+ if((e > (std::numeric_limits<Exponent>::max)()) || (e < (std::numeric_limits<Exponent>::min)()))
+ {
+ res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::infinity().backend();
+ if(e < 0)
+ res.negate();
+ }
+ else
+ eval_ldexp(res, arg, static_cast<Exponent>(e));
+}
+
+/*
+* Sign manipulation
+*/
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline void eval_abs(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &arg)
+{
+ res = arg;
+ res.sign() = false;
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline void eval_fabs(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &arg)
+{
+ res = arg;
+ res.sign() = false;
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline int eval_fpclassify(const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &arg)
+{
+ switch(arg.exponent())
+ {
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
+ return FP_ZERO;
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
+ return FP_INFINITE;
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
+ return FP_NAN;
+ }
+ return FP_NORMAL;
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline void eval_sqrt(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &arg)
+{
+ using default_ops::eval_integer_sqrt;
+ using default_ops::eval_bit_test;
+ using default_ops::eval_increment;
+ switch(arg.exponent())
+ {
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
+ res = arg;
+ return;
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
+ res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
+ return;
+ }
+ if(arg.sign())
+ {
+ res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
+ return;
+ }
+
+ typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::double_rep_type t(arg.bits()), r, s;
+ eval_left_shift(t, arg.exponent() & 1 ? cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count : cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1);
+ eval_integer_sqrt(s, r, t);
+
+ if(!eval_bit_test(s, cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count))
+ {
+ // We have exactly the right number of cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count in the result, round as required:
+ if(s.compare(r) < 0)
+ {
+ eval_increment(s);
+ }
+ }
+ typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type ae = arg.exponent();
+ res.exponent() = ae / 2;
+ if((ae & 1) && (ae < 0))
+ --res.exponent();
+ copy_and_round(res, s);
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline void eval_floor(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &arg)
+{
+ using default_ops::eval_increment;
+ switch(arg.exponent())
+ {
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
+ res = arg;
+ return;
+ }
+ typename mpl::if_c<sizeof(typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type) < sizeof(int), int, typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type>::type shift =
+ (int)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - arg.exponent() - 1;
+ if((arg.exponent() > (int)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent) || (shift <= 0))
+ {
+ // Either arg is already an integer, or a special value:
+ res = arg;
+ return;
+ }
+ if(shift >= (int)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count)
+ {
+ res = static_cast<signed_limb_type>(arg.sign() ? -1 : 0);
+ return;
+ }
+ bool fractional = (int)eval_lsb(arg.bits()) < shift;
+ res = arg;
+ eval_right_shift(res.bits(), shift);
+ if(fractional && res.sign())
+ {
+ eval_increment(res.bits());
+ if(eval_msb(res.bits()) != cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1 - shift)
+ {
+ // Must have extended result by one bit in the increment:
+ --shift;
+ ++res.exponent();
+ }
+ }
+ eval_left_shift(res.bits(), shift);
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+inline void eval_ceil(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &arg)
+{
+ using default_ops::eval_increment;
+ switch(arg.exponent())
+ {
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
+ case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
+ res = arg;
+ return;
+ }
+ typename mpl::if_c<sizeof(typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type) < sizeof(int), int, typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type>::type shift = (int)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - arg.exponent() - 1;
+ if((arg.exponent() > (int)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent) || (shift <= 0))
+ {
+ // Either arg is already an integer, or a special value:
+ res = arg;
+ return;
+ }
+ if(shift >= cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count)
+ {
+ res = static_cast<signed_limb_type>(arg.sign() ? 0 : 1);
+ return;
+ }
+ bool fractional = (int)eval_lsb(arg.bits()) < shift;
+ res = arg;
+ eval_right_shift(res.bits(), shift);
+ if(fractional && !res.sign())
+ {
+ eval_increment(res.bits());
+ if(eval_msb(res.bits()) != cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1 - shift)
+ {
+ // Must have extended result by one bit in the increment:
+ --shift;
+ ++res.exponent();
+ }
+ }
+ eval_left_shift(res.bits(), shift);
+}
+
+} // namespace backends
+
+#ifdef BOOST_NO_SFINAE_EXPR
+
+namespace detail{
+
+template<unsigned D1, backends::digit_base_type B1, class A1, unsigned D2, backends::digit_base_type B2, class A2>
+struct is_explicitly_convertible<backends::cpp_bin_float<D1, B1, A1>, backends::cpp_bin_float<D2, B2, A2> > : public mpl::true_ {};
+
+}
+#endif
+
+
+using backends::cpp_bin_float;
+using backends::digit_base_2;
+using backends::digit_base_10;
+
+template<unsigned Digits, backends::digit_base_type DigitBase, class Exponent, Exponent MinE, Exponent MaxE, class Allocator>
+struct number_category<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > : public boost::mpl::int_<boost::multiprecision::number_kind_floating_point>{};
+
+template<unsigned Digits, backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+struct expression_template_default<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> >
+{
+ static const expression_template_option value = is_void<Allocator>::value ? et_off : et_on;
+};
+
+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> 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
+
+#include <boost/multiprecision/cpp_bin_float/io.hpp>
+#include <boost/multiprecision/cpp_bin_float/transcendental.hpp>
+
+namespace std{
+
+//
+// numeric_limits [partial] specializations for the types declared in this header:
+//
+template<unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+class numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >
+{
+ typedef boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> number_type;
+public:
+ BOOST_STATIC_CONSTEXPR bool is_specialized = true;
+ static number_type (min)()
+ {
+ initializer.do_nothing();
+ static std::pair<bool, number_type> value;
+ if(!value.first)
+ {
+ value.first = true;
+ value.second = 1u;
+ value.second.backend().exponent() = boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent;
+ }
+ return value.second;
+ }
+ static number_type (max)()
+ {
+ initializer.do_nothing();
+ static std::pair<bool, number_type> value;
+ if(!value.first)
+ {
+ value.first = true;
+ eval_complement(value.second.backend().bits(), value.second.backend().bits());
+ value.second.backend().exponent() = boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent;
+ }
+ return value.second;
+ }
+ BOOST_STATIC_CONSTEXPR number_type lowest()
+ {
+ return -(max)();
+ }
+ BOOST_STATIC_CONSTEXPR int digits = boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count;
+ BOOST_STATIC_CONSTEXPR int digits10 = digits * 301 / 1000;
+ // Is this really correct???
+ BOOST_STATIC_CONSTEXPR int max_digits10 = digits10 + 2;
+ BOOST_STATIC_CONSTEXPR bool is_signed = true;
+ BOOST_STATIC_CONSTEXPR bool is_integer = false;
+ BOOST_STATIC_CONSTEXPR bool is_exact = false;
+ BOOST_STATIC_CONSTEXPR int radix = 2;
+ static number_type epsilon()
+ {
+ initializer.do_nothing();
+ static std::pair<bool, number_type> value;
+ if(!value.first)
+ {
+ value.first = true;
+ value.second = 1;
+ value.second = ldexp(value.second, 1 - (int)digits);
+ }
+ return value.second;
+ }
+ // What value should this be????
+ static number_type round_error()
+ {
+ // returns 0.5
+ initializer.do_nothing();
+ static std::pair<bool, number_type> value;
+ if(!value.first)
+ {
+ value.first = true;
+ value.second = 1;
+ value.second = ldexp(value.second, -1);
+ }
+ return value.second;
+ }
+ BOOST_STATIC_CONSTEXPR typename boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type min_exponent = boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent;
+ BOOST_STATIC_CONSTEXPR typename boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type min_exponent10 = (min_exponent / 1000) * 301L;
+ BOOST_STATIC_CONSTEXPR typename boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type max_exponent = boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent;
+ BOOST_STATIC_CONSTEXPR typename boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type max_exponent10 = (max_exponent / 1000) * 301L;
+ BOOST_STATIC_CONSTEXPR bool has_infinity = true;
+ BOOST_STATIC_CONSTEXPR bool has_quiet_NaN = true;
+ BOOST_STATIC_CONSTEXPR bool has_signaling_NaN = false;
+ BOOST_STATIC_CONSTEXPR float_denorm_style has_denorm = denorm_absent;
+ BOOST_STATIC_CONSTEXPR bool has_denorm_loss = false;
+ static number_type infinity()
+ {
+ // returns epsilon/2
+ initializer.do_nothing();
+ static std::pair<bool, number_type> value;
+ if(!value.first)
+ {
+ value.first = true;
+ value.second.backend().exponent() = boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity;
+ }
+ return value.second;
+ }
+ static number_type quiet_NaN()
+ {
+ return number_type();
+ }
+ BOOST_STATIC_CONSTEXPR number_type signaling_NaN()
+ {
+ return number_type(0);
+ }
+ BOOST_STATIC_CONSTEXPR number_type denorm_min() { return number_type(0); }
+ BOOST_STATIC_CONSTEXPR bool is_iec559 = false;
+ BOOST_STATIC_CONSTEXPR bool is_bounded = true;
+ BOOST_STATIC_CONSTEXPR bool is_modulo = false;
+ BOOST_STATIC_CONSTEXPR bool traps = true;
+ BOOST_STATIC_CONSTEXPR bool tinyness_before = false;
+ BOOST_STATIC_CONSTEXPR float_round_style round_style = round_to_nearest;
+private:
+ struct data_initializer
+ {
+ data_initializer()
+ {
+ std::numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::epsilon();
+ std::numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::round_error();
+ (std::numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::min)();
+ (std::numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::max)();
+ std::numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::infinity();
+ std::numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN();
+ }
+ void do_nothing()const{}
+ };
+ static const data_initializer initializer;
+};
+
+template<unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+const typename numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::data_initializer numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::initializer;
+
+#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+
+template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::digits;
+template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::digits10;
+template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::max_digits10;
+template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::is_signed;
+template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::is_integer;
+template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::is_exact;
+template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::radix;
+template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+BOOST_CONSTEXPR_OR_CONST typename boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::min_exponent;
+template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+BOOST_CONSTEXPR_OR_CONST typename boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::min_exponent10;
+template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+BOOST_CONSTEXPR_OR_CONST typename boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::max_exponent;
+template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+BOOST_CONSTEXPR_OR_CONST typename boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::max_exponent10;
+template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::has_infinity;
+template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::has_quiet_NaN;
+template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::has_signaling_NaN;
+template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+BOOST_CONSTEXPR_OR_CONST float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::has_denorm;
+template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::has_denorm_loss;
+template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::is_iec559;
+template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::is_bounded;
+template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::is_modulo;
+template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::traps;
+template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::tinyness_before;
+template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
+BOOST_CONSTEXPR_OR_CONST float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::round_style;
+
+#endif
+
+} // namespace std
+
+#endif

Added: trunk/boost/multiprecision/cpp_bin_float/io.hpp
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/boost/multiprecision/cpp_bin_float/io.hpp 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -0,0 +1,690 @@
+///////////////////////////////////////////////////////////////
+// Copyright 2013 John Maddock. 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_
+
+#ifndef BOOST_MP_CPP_BIN_FLOAT_IO_HPP
+#define BOOST_MP_CPP_BIN_FLOAT_IO_HPP
+
+namespace boost{ namespace multiprecision{ namespace cpp_bf_io_detail{
+
+//
+// Multiplies a by b and shifts the result so it fits inside max_bits bits,
+// returns by how much the result was shifted.
+//
+template <class I>
+inline I restricted_multiply(cpp_int& result, const cpp_int& a, const cpp_int& b, I max_bits, boost::int64_t& error)
+{
+ result = a * b;
+ I gb = msb(result);
+ I rshift = 0;
+ if(gb > max_bits)
+ {
+ rshift = gb - max_bits;
+ I lb = lsb(result);
+ int roundup = 0;
+ // The error rate increases by the error of both a and b,
+ // this may be overly pessimistic in many case as we're assuming
+ // that a and b have the same level of uncertainty...
+ if(lb < rshift)
+ error = error ? error * 2 : 1;
+ if(rshift)
+ {
+ BOOST_ASSERT(rshift < INT_MAX);
+ if(bit_test(result, static_cast<unsigned>(rshift - 1)))
+ {
+ if(lb == rshift - 1)
+ roundup = 1;
+ else
+ roundup = 2;
+ }
+ result >>= rshift;
+ }
+ if((roundup == 2) || ((roundup == 1) && (result.backend().limbs()[0] & 1)))
+ ++result;
+ }
+ return rshift;
+}
+//
+// Computes a^e shifted to the right so it fits in max_bits, returns how far
+// to the right we are shifted.
+//
+template <class I>
+inline I restricted_pow(cpp_int& result, const cpp_int& a, I e, I max_bits, boost::int64_t& error)
+{
+ BOOST_ASSERT(&result != &a);
+ I exp = 0;
+ if(e == 1)
+ {
+ result = a;
+ return exp;
+ }
+ else if(e == 2)
+ {
+ return restricted_multiply(result, a, a, max_bits, error);
+ }
+ else if(e == 3)
+ {
+ exp = restricted_multiply(result, a, a, max_bits, error);
+ exp += restricted_multiply(result, result, a, max_bits, error);
+ return exp;
+ }
+ I p = e / 2;
+ exp = restricted_pow(result, a, p, max_bits, error);
+ exp *= 2;
+ exp += restricted_multiply(result, result, result, max_bits, error);
+ if(e & 1)
+ exp += restricted_multiply(result, result, a, max_bits, error);
+ return exp;
+}
+
+inline int get_round_mode(const cpp_int& what, boost::int64_t location, boost::int64_t error)
+{
+ //
+ // Can we round what at /location/, if the error in what is /error/ in
+ // units of 0.5ulp. Return:
+ //
+ // -1: Can't round.
+ // 0: leave as is.
+ // 1: tie.
+ // 2: round up.
+ //
+ BOOST_ASSERT(location >= 0);
+ BOOST_ASSERT(location < INT_MAX);
+ boost::int64_t error_radius = error & 1 ? (1 + error) / 2 : error / 2;
+ if(error_radius && ((int)msb(error_radius) >= location))
+ return -1;
+ if(bit_test(what, static_cast<unsigned>(location)))
+ {
+ if((int)lsb(what) == location)
+ return error ? -1 : 1; // Either a tie or can't round depending on whether we have any error
+ if(!error)
+ return 2; // no error, round up.
+ cpp_int t = what - error_radius;
+ if((int)lsb(t) >= location)
+ return -1;
+ return 2;
+ }
+ else if(error)
+ {
+ cpp_int t = what + error_radius;
+ return bit_test(t, static_cast<unsigned>(location)) ? -1 : 0;
+ }
+ return 0;
+}
+
+inline int get_round_mode(cpp_int& r, cpp_int& d, boost::int64_t error, const cpp_int& q)
+{
+ //
+ // Lets suppose we have an inexact division by d+delta, where the true
+ // value for the divisor is d, and with |delta| <= error/2, then
+ // we have calculated q and r such that:
+ //
+ // n r
+ // --- = q + -----------
+ // d + error d + error
+ //
+ // Rearranging for n / d we get:
+ //
+ // n delta*q + r
+ // --- = q + -------------
+ // d d
+ //
+ // So rounding depends on whether 2r + error * q > d.
+ //
+ // We return:
+ // 0 = down down.
+ // 1 = tie.
+ // 2 = round up.
+ // -1 = couldn't decide.
+ //
+ r <<= 1;
+ int c = r.compare(d);
+ if(c == 0)
+ return error ? -1 : 1;
+ if(c > 0)
+ {
+ if(error)
+ {
+ r -= error * q;
+ return r.compare(d) > 0 ? 2 : -1;
+ }
+ return 2;
+ }
+ if(error)
+ {
+ r += error * q;
+ return r.compare(d) < 0 ? 0 : -1;
+ }
+ return 0;
+}
+
+} // namespace
+
+namespace backends{
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::operator=(const char *s)
+{
+ cpp_int n;
+ boost::intmax_t decimal_exp = 0;
+ boost::intmax_t digits_seen = 0;
+ static const boost::intmax_t max_digits_seen = 4 + (cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count * 301L) / 1000;
+ bool ss = false;
+ //
+ // Extract the sign:
+ //
+ if(*s == '-')
+ {
+ ss = true;
+ ++s;
+ }
+ else if(*s == '+')
+ ++s;
+ //
+ // Special cases first:
+ //
+ if((std::strcmp(s, "nan") == 0) || (std::strcmp(s, "NaN") == 0) || (std::strcmp(s, "NAN") == 0))
+ {
+ return *this = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
+ }
+ if((std::strcmp(s, "inf") == 0) || (std::strcmp(s, "Inf") == 0) || (std::strcmp(s, "INF") == 0) || (std::strcmp(s, "infinity") == 0) || (std::strcmp(s, "Infinity") == 0) || (std::strcmp(s, "INFINITY") == 0))
+ {
+ *this = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::infinity().backend();
+ if(ss)
+ negate();
+ return *this;
+ }
+ //
+ // Digits before the point:
+ //
+ while(*s && (*s >= '0') && (*s <= '9'))
+ {
+ n *= 10u;
+ n += *s - '0';
+ if(digits_seen || (*s != '0'))
+ ++digits_seen;
+ ++s;
+ }
+ // The decimal point (we really should localise this!!)
+ if(*s && (*s == '.'))
+ ++s;
+ //
+ // Digits after the point:
+ //
+ while(*s && (*s >= '0') && (*s <= '9'))
+ {
+ n *= 10u;
+ n += *s - '0';
+ --decimal_exp;
+ if(digits_seen || (*s != '0'))
+ ++digits_seen;
+ ++s;
+ if(digits_seen > max_digits_seen)
+ break;
+ }
+ //
+ // Digits we're skipping:
+ //
+ while(*s && (*s >= '0') && (*s <= '9'))
+ ++s;
+ //
+ // See if there's an exponent:
+ //
+ if(*s && ((*s == 'e') || (*s == 'E')))
+ {
+ ++s;
+ boost::intmax_t e = 0;
+ bool es = false;
+ if(*s && (*s == '-'))
+ {
+ es = true;
+ ++s;
+ }
+ else if(*s && (*s == '+'))
+ ++s;
+ while(*s && (*s >= '0') && (*s <= '9'))
+ {
+ e *= 10u;
+ e += *s - '0';
+ ++s;
+ }
+ if(es)
+ e = -e;
+ decimal_exp += e;
+ }
+ if(*s)
+ {
+ //
+ // Oops unexpected input at the end of the number:
+ //
+ BOOST_THROW_EXCEPTION(std::runtime_error("Unable to parse string as a valid floating point number."));
+ }
+ if(n == 0)
+ {
+ // Result is necessarily zero:
+ *this = static_cast<limb_type>(0u);
+ return *this;
+ }
+
+ static const unsigned limb_bits = sizeof(limb_type) * CHAR_BIT;
+ //
+ // Set our working precision - this is heuristic based, we want
+ // a value as small as possible > cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count to avoid large computations
+ // and excessive memory usage, but we also want to avoid having to
+ // up the computation and start again at a higher precision.
+ // So we round cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count up to the nearest whole number of limbs, and add
+ // one limb for good measure. This works very well for small exponents,
+ // but for larger exponents we may may need to restart, we could add some
+ // extra precision right from the start for larger exponents, but this
+ // seems to be slightly slower in the *average* case:
+ //
+#ifdef BOOST_MP_STRESS_IO
+ boost::intmax_t max_bits = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count + 32;
+#else
+ boost::intmax_t max_bits = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count + (cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count % limb_bits ? limb_bits - cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count % limb_bits : 0) + limb_bits;
+#endif
+ boost::int64_t error = 0;
+ boost::intmax_t calc_exp = 0;
+ boost::intmax_t final_exponent = 0;
+
+ if(decimal_exp >= 0)
+ {
+ // Nice and simple, the result is an integer...
+ do
+ {
+ cpp_int t;
+ if(decimal_exp)
+ {
+ calc_exp = boost::multiprecision::cpp_bf_io_detail::restricted_pow(t, cpp_int(5), decimal_exp, max_bits, error);
+ calc_exp += boost::multiprecision::cpp_bf_io_detail::restricted_multiply(t, t, n, max_bits, error);
+ }
+ else
+ t = n;
+ final_exponent = (boost::int64_t)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1 + decimal_exp + calc_exp;
+ int rshift = msb(t) - cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count + 1;
+ if(rshift > 0)
+ {
+ final_exponent += rshift;
+ int roundup = boost::multiprecision::cpp_bf_io_detail::get_round_mode(t, rshift - 1, error);
+ t >>= rshift;
+ if((roundup == 2) || ((roundup == 1) && t.backend().limbs()[0] & 1))
+ ++t;
+ else if(roundup < 0)
+ {
+#ifdef BOOST_MP_STRESS_IO
+ max_bits += 32;
+#else
+ max_bits *= 2;
+#endif
+ error = 0;
+ continue;
+ }
+ }
+ else
+ {
+ BOOST_ASSERT(!error);
+ }
+ if(final_exponent > cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent)
+ {
+ exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent;
+ final_exponent -= cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent;
+ }
+ else if(final_exponent < cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent)
+ {
+ // Underflow:
+ exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent;
+ final_exponent -= cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent;
+ }
+ else
+ {
+ exponent() = static_cast<Exponent>(final_exponent);
+ final_exponent = 0;
+ }
+ copy_and_round(*this, t.backend());
+ break;
+ }
+ while(true);
+
+ if(ss != sign())
+ negate();
+ }
+ else
+ {
+ // Result is the ratio of two integers: we need to organise the
+ // division so as to produce at least an N-bit result which we can
+ // round according to the remainder.
+ //cpp_int d = pow(cpp_int(5), -decimal_exp);
+ do
+ {
+ cpp_int d;
+ calc_exp = boost::multiprecision::cpp_bf_io_detail::restricted_pow(d, cpp_int(5), -decimal_exp, max_bits, error);
+ int shift = (int)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - msb(n) + msb(d);
+ final_exponent = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1 + decimal_exp - calc_exp;
+ if(shift > 0)
+ {
+ n <<= shift;
+ final_exponent -= static_cast<Exponent>(shift);
+ }
+ cpp_int q, r;
+ divide_qr(n, d, q, r);
+ int gb = msb(q);
+ BOOST_ASSERT((gb >= cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1));
+ //
+ // Check for rounding conditions we have to
+ // handle ourselves:
+ //
+ int roundup = 0;
+ if(gb == cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1)
+ {
+ // Exactly the right number of bits, use the remainder to round:
+ roundup = boost::multiprecision::cpp_bf_io_detail::get_round_mode(r, d, error, q);
+ }
+ else if(bit_test(q, gb - (int)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count) && ((int)lsb(q) == (gb - (int)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count)))
+ {
+ // Too many bits in q and the bits in q indicate a tie, but we can break that using r,
+ // note that the radius of error in r is error/2 * q:
+ int shift = gb - (int)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count + 1;
+ q >>= shift;
+ final_exponent += static_cast<Exponent>(shift);
+ BOOST_ASSERT((msb(q) >= cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1));
+ if(error && (r < (error / 2) * q))
+ roundup = -1;
+ else if(error && (r + (error / 2) * q >= d))
+ roundup = -1;
+ else
+ roundup = r ? 2 : 1;
+ }
+ else if(error && (((error / 2) * q + r >= d) || (r < (error / 2) * q)))
+ {
+ // We might have been rounding up, or got the wrong quotient: can't tell!
+ roundup = -1;
+ }
+ if(roundup < 0)
+ {
+#ifdef BOOST_MP_STRESS_IO
+ max_bits += 32;
+#else
+ max_bits *= 2;
+#endif
+ error = 0;
+ if(shift > 0)
+ {
+ n >>= shift;
+ final_exponent += static_cast<Exponent>(shift);
+ }
+ continue;
+ }
+ else if((roundup == 2) || ((roundup == 1) && q.backend().limbs()[0] & 1))
+ ++q;
+ if(final_exponent > cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent)
+ {
+ // Overflow:
+ exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent;
+ final_exponent -= cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent;
+ }
+ else if(final_exponent < cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent)
+ {
+ // Underflow:
+ exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent;
+ final_exponent -= cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent;
+ }
+ else
+ {
+ exponent() = static_cast<Exponent>(final_exponent);
+ final_exponent = 0;
+ }
+ copy_and_round(*this, q.backend());
+ if(ss != sign())
+ negate();
+ break;
+ }
+ while(true);
+ }
+ //
+ // Check for scaling and/or over/under-flow:
+ //
+ final_exponent += exponent();
+ if(final_exponent > cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent)
+ {
+ // Overflow:
+ exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity;
+ bits() = limb_type(0);
+ }
+ else if(final_exponent < cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent)
+ {
+ // Underflow:
+ exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero;
+ bits() = limb_type(0);
+ sign() = 0;
+ }
+ else
+ {
+ exponent() = static_cast<Exponent>(final_exponent);
+ }
+ return *this;
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+std::string cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::str(std::streamsize dig, std::ios_base::fmtflags f) const
+{
+ if(dig == 0)
+ dig = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::max_digits10;
+
+ bool scientific = (f & std::ios_base::scientific) == std::ios_base::scientific;
+ bool fixed = !scientific && (f & std::ios_base::fixed);
+
+ std::string s;
+
+ if(exponent() <= cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent)
+ {
+ // How far to left-shift in order to demormalise the mantissa:
+ boost::intmax_t shift = (int)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - exponent() - 1;
+ boost::intmax_t digits_wanted = static_cast<int>(dig);
+ boost::intmax_t base10_exp = exponent() >= 0 ? static_cast<boost::intmax_t>(std::floor(0.30103 * exponent())) : static_cast<boost::intmax_t>(std::ceil(0.30103 * exponent()));
+ //
+ // For fixed formatting we want /dig/ digits after the decimal point,
+ // so if the exponent is zero, allowing for the one digit before the
+ // decimal point, we want 1 + dig digits etc.
+ //
+ if(fixed)
+ digits_wanted += 1 + base10_exp;
+ if(scientific)
+ digits_wanted += 1;
+ if(digits_wanted < -1)
+ {
+ // Fixed precision, no significant digits, and nothing to round!
+ s = "0";
+ if(sign())
+ s.insert(0, 1, '-');
+ boost::multiprecision::detail::format_float_string(s, base10_exp, dig, f, true);
+ return s;
+ }
+ //
+ // power10 is the base10 exponent we need to multiply/divide by in order
+ // to convert our denormalised number to an integer with the right number of digits:
+ //
+ boost::intmax_t power10 = digits_wanted - base10_exp - 1;
+ //
+ // If we calculate 5^power10 rather than 10^power10 we need to move
+ // 2^power10 into /shift/
+ //
+ shift -= power10;
+ cpp_int i;
+ int roundup = 0; // 0=no rounding, 1=tie, 2=up
+ static const unsigned limb_bits = sizeof(limb_type) * CHAR_BIT;
+ //
+ // Set our working precision - this is heuristic based, we want
+ // a value as small as possible > cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count to avoid large computations
+ // and excessive memory usage, but we also want to avoid having to
+ // up the computation and start again at a higher precision.
+ // So we round cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count up to the nearest whole number of limbs, and add
+ // one limb for good measure. This works very well for small exponents,
+ // but for larger exponents we add a few extra limbs to max_bits:
+ //
+#ifdef BOOST_MP_STRESS_IO
+ boost::intmax_t max_bits = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count + 32;
+#else
+ boost::intmax_t max_bits = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count + (cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count % limb_bits ? limb_bits - cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count % limb_bits : 0) + limb_bits;
+ if(power10)
+ max_bits += (msb(std::abs(power10)) / 8) * limb_bits;
+#endif
+ do
+ {
+ boost::int64_t error = 0;
+ boost::intmax_t calc_exp = 0;
+ //
+ // Our integer result is: bits() * 2^-shift * 5^power10
+ //
+ i = bits();
+ if(shift < 0)
+ {
+ if(power10 >= 0)
+ {
+ // We go straight to the answer with all integer arithmetic,
+ // the result is always exact and never needs rounding:
+ BOOST_ASSERT(power10 <= (boost::intmax_t)INT_MAX);
+ i <<= -shift;
+ if(power10)
+ i *= pow(cpp_int(5), static_cast<unsigned>(power10));
+ }
+ else if(power10 < 0)
+ {
+ cpp_int d;
+ calc_exp = boost::multiprecision::cpp_bf_io_detail::restricted_pow(d, cpp_int(5), -power10, max_bits, error);
+ shift += calc_exp;
+ BOOST_ASSERT(shift < 0); // Must still be true!
+ i <<= -shift;
+ cpp_int r;
+ divide_qr(i, d, i, r);
+ roundup = boost::multiprecision::cpp_bf_io_detail::get_round_mode(r, d, error, i);
+ if(roundup < 0)
+ {
+#ifdef BOOST_MP_STRESS_IO
+ max_bits += 32;
+#else
+ max_bits *= 2;
+#endif
+ shift = (int)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - exponent() - 1 - power10;
+ continue;
+ }
+ }
+ }
+ else
+ {
+ //
+ // Our integer is bits() * 2^-shift * 10^power10
+ //
+ if(power10 > 0)
+ {
+ if(power10)
+ {
+ cpp_int t;
+ calc_exp = boost::multiprecision::cpp_bf_io_detail::restricted_pow(t, cpp_int(5), power10, max_bits, error);
+ calc_exp += boost::multiprecision::cpp_bf_io_detail::restricted_multiply(i, i, t, max_bits, error);
+ shift -= calc_exp;
+ }
+ if((shift < 0) || ((shift == 0) && error))
+ {
+ // We only get here if we were asked for a crazy number of decimal digits -
+ // more than are present in a 2^max_bits number.
+#ifdef BOOST_MP_STRESS_IO
+ max_bits += 32;
+#else
+ max_bits *= 2;
+#endif
+ shift = (int)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - exponent() - 1 - power10;
+ continue;
+ }
+ if(shift)
+ {
+ roundup = boost::multiprecision::cpp_bf_io_detail::get_round_mode(i, shift - 1, error);
+ if(roundup < 0)
+ {
+#ifdef BOOST_MP_STRESS_IO
+ max_bits += 32;
+#else
+ max_bits *= 2;
+#endif
+ shift = (int)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - exponent() - 1 - power10;
+ continue;
+ }
+ i >>= shift;
+ }
+ }
+ else
+ {
+ // We're right shifting, *and* dividing by 5^-power10,
+ // so 5^-power10 can never be that large or we'd simply
+ // get zero as a result, and that case is already handled above:
+ cpp_int r;
+ BOOST_ASSERT(-power10 < INT_MAX);
+ cpp_int d = pow(cpp_int(5), static_cast<unsigned>(-power10));
+ d <<= shift;
+ divide_qr(i, d, i, r);
+ r <<= 1;
+ int c = r.compare(d);
+ roundup = c < 0 ? 0 : c == 0 ? 1 : 2;
+ }
+ }
+ s = i.str(0, std::ios_base::fmtflags(0));
+ //
+ // Check if we got the right number of digits, this
+ // is really a test of whether we calculated the
+ // decimal exponent correctly:
+ //
+ boost::intmax_t digits_got = i ? static_cast<boost::intmax_t>(s.size()) : 0;
+ if(digits_got != digits_wanted)
+ {
+ base10_exp += digits_got - digits_wanted;
+ if(fixed)
+ digits_wanted = digits_got; // strange but true.
+ power10 = digits_wanted - base10_exp - 1;
+ shift = (int)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - exponent() - 1 - power10;
+ if(fixed)
+ break;
+ roundup = 0;
+ }
+ else
+ break;
+ }
+ while(true);
+ //
+ // Check whether we need to round up: note that we could equally round up
+ // the integer /i/ above, but since we need to perform the rounding *after*
+ // the conversion to a string and the digit count check, we might as well
+ // do it here:
+ //
+ if((roundup == 2) || ((roundup == 1) && ((s[s.size() - 1] - '0') & 1)))
+ {
+ boost::multiprecision::detail::round_string_up_at(s, static_cast<int>(s.size() - 1), base10_exp);
+ }
+
+ if(sign())
+ s.insert(0, 1, '-');
+
+ boost::multiprecision::detail::format_float_string(s, base10_exp, dig, f, false);
+ }
+ else
+ {
+ switch(exponent())
+ {
+ case exponent_zero:
+ s = "0";
+ boost::multiprecision::detail::format_float_string(s, 0, dig, f, true);
+ break;
+ case exponent_nan:
+ s = "nan";
+ break;
+ case exponent_infinity:
+ s = sign() ? "-inf" : f & std::ios_base::showpos ? "+inf" : "inf";
+ break;
+ }
+ }
+ return s;
+}
+
+}}} // namespaces
+
+#endif
+

Added: trunk/boost/multiprecision/cpp_bin_float/transcendental.hpp
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/boost/multiprecision/cpp_bin_float/transcendental.hpp 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -0,0 +1,132 @@
+///////////////////////////////////////////////////////////////
+// Copyright 2013 John Maddock. 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_
+
+#ifndef BOOST_MULTIPRECISION_CPP_BIN_FLOAT_TRANSCENDENTAL_HPP
+#define BOOST_MULTIPRECISION_CPP_BIN_FLOAT_TRANSCENDENTAL_HPP
+
+namespace boost{ namespace multiprecision{ namespace backends{
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+void eval_exp_taylor(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &arg)
+{
+ static const int bits = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count;
+ //
+ // Taylor series for small argument, note returns exp(x) - 1:
+ //
+ res = limb_type(0);
+ cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> num(arg), denom, t;
+ denom = limb_type(1);
+ eval_add(res, num);
+
+ for(unsigned k = 2; ; ++k)
+ {
+ eval_multiply(denom, k);
+ eval_multiply(num, arg);
+ eval_divide(t, num, denom);
+ eval_add(res, t);
+ if(eval_is_zero(t) || (res.exponent() - bits > t.exponent()))
+ break;
+ }
+}
+
+template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
+void eval_exp(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &arg)
+{
+ //
+ // This is based on MPFR's method, let:
+ //
+ // n = floor(x / ln(2))
+ //
+ // Then:
+ //
+ // r = x - n ln(2) : 0 <= r < ln(2)
+ //
+ // We can reduce r further by dividing by 2^k, with k ~ sqrt(n),
+ // so if:
+ //
+ // e0 = exp(r / 2^k) - 1
+ //
+ // With e0 evaluated by taylor series for small arguments, then:
+ //
+ // exp(x) = 2^n (1 + e0)^2^k
+ //
+ // Note that to preserve precision we actually square (1 + e0) k times, calculating
+ // the result less one each time, i.e.
+ //
+ // (1 + e0)^2 - 1 = e0^2 + 2e0
+ //
+ // Then add the final 1 at the end, given that e0 is small, this effectively wipes
+ // out the error in the last step.
+ //
+ using default_ops::eval_multiply;
+ using default_ops::eval_subtract;
+ using default_ops::eval_add;
+ using default_ops::eval_convert_to;
+
+ int type = eval_fpclassify(arg);
+ bool isneg = eval_get_sign(arg) < 0;
+ if(type == FP_NAN)
+ {
+ res = arg;
+ return;
+ }
+ else if(type == FP_INFINITE)
+ {
+ res = arg;
+ if(isneg)
+ res = limb_type(0u);
+ else
+ res = arg;
+ return;
+ }
+ else if(type == FP_ZERO)
+ {
+ res = limb_type(1);
+ return;
+ }
+ cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> t, n;
+ if(isneg)
+ {
+ t = arg;
+ t.negate();
+ eval_exp(res, t);
+ t.swap(res);
+ res = limb_type(1);
+ eval_divide(res, t);
+ return;
+ }
+
+ eval_divide(n, arg, default_ops::get_constant_ln2<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> >());
+ eval_floor(n, n);
+ eval_multiply(t, n, default_ops::get_constant_ln2<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> >());
+ eval_subtract(t, arg);
+ t.negate();
+ BOOST_ASSERT(t.compare(limb_type(0)) >= 0);
+ BOOST_ASSERT(t.compare(default_ops::get_constant_ln2<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> >()) < 0);
+
+ Exponent k, nn;
+ eval_convert_to(&nn, n);
+ k = nn ? Exponent(1) << (msb(nn) / 2) : 0;
+ eval_ldexp(t, t, -k);
+
+ eval_exp_taylor(res, t);
+ //
+ // Square 1 + res k times:
+ //
+ for(int s = 0; s < k; ++s)
+ {
+ t.swap(res);
+ eval_multiply(res, t, t);
+ eval_ldexp(t, t, 1);
+ eval_add(res, t);
+ }
+ eval_add(res, limb_type(1));
+ eval_ldexp(res, res, nn);
+}
+
+}}} // namespaces
+
+#endif
+

Modified: trunk/libs/multiprecision/doc/Jamfile.v2
==============================================================================
--- trunk/libs/multiprecision/doc/Jamfile.v2 Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/Jamfile.v2 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -74,7 +74,8 @@
         <format>pdf:<xsl:param>index.on.type=1
     ;
 
-install pdf-install : standalone : <location>. <install-type>PDF <name>multiprecision.pdf ;
+install pdfinstall : standalone : <location>. <install-type>PDF <name>multiprecision.pdf ;
+
 
 
 

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/indexes.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/indexes.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/indexes.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -7,7 +7,6 @@
 <link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Multiprecision">
 <link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Multiprecision">
 <link rel="prev" href="map/ack.html" title="Acknowledgements">
-<link rel="next" href="indexes/s01.html" title="Function Index">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -20,22 +19,20 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="map/ack.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="indexes/s01.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="map/ack.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_multiprecision.indexes"></a><a class="link" href="indexes.html" title="Indexes">Indexes</a>
 </h2></div></div></div>
-<div class="toc"><dl class="toc">
-<dt><span class="section">Function Index</span></dt>
-<dt><span class="section">Class Index</span></dt>
-<dt><span class="section">Typedef Index</span></dt>
-<dt><span class="section">Index</span></dt>
-</dl></div>
+<p>
+ [named_index function_name Function Index] [named_index class_name Class Index]
+ [named_index typedef_name Typedef Index] [index]
+ </p>
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>
@@ -43,7 +40,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="map/ack.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="indexes/s01.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="map/ack.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a>
 </div>
 </body>
 </html>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/intro.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/intro.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/intro.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -372,7 +372,7 @@
       for polynomial execution:
     </p>
 <div class="table">
-<a name="boost_multiprecision.intro.evaluation_of_order_6_polynomial_"></a><p class="title"><b>Table&#160;1.1.&#160;Evaluation of Order 6 Polynomial.</b></p>
+<a name="boost_multiprecision.intro.evaluation_of_order_6_polynomial"></a><p class="title"><b>Table&#160;1.1.&#160;Evaluation of Order 6 Polynomial.</b></p>
 <div class="table-contents"><table class="table" summary="Evaluation of Order 6 Polynomial.">
 <colgroup>
 <col>
@@ -486,7 +486,7 @@
       (50 decimal digits):
     </p>
 <div class="table">
-<a name="boost_multiprecision.intro.evaluation_of_boost_math_s_bessel_function_test_data"></a><p class="title"><b>Table&#160;1.2.&#160;Evaluation of Boost.Math's Bessel function test data</b></p>
+<a name="boost_multiprecision.intro.evaluation_of_boost_math_s_besse"></a><p class="title"><b>Table&#160;1.2.&#160;Evaluation of Boost.Math's Bessel function test data</b></p>
 <div class="table-contents"><table class="table" summary="Evaluation of Boost.Math's Bessel function test data">
 <colgroup>
 <col>
@@ -584,7 +584,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.intro.evaluation_of_boost_math_s_non_central_t_distribution_test_data"></a><p class="title"><b>Table&#160;1.3.&#160;Evaluation of Boost.Math's Non-Central T distribution test data</b></p>
+<a name="boost_multiprecision.intro.evaluation_of_boost_math_s_non_c"></a><p class="title"><b>Table&#160;1.3.&#160;Evaluation of Boost.Math's Non-Central T distribution test data</b></p>
 <div class="table-contents"><table class="table" summary="Evaluation of Boost.Math's Non-Central T distribution test data">
 <colgroup>
 <col>
@@ -696,7 +696,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/map.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/map.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/map.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -35,7 +35,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/map/ack.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/map/ack.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/map/ack.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -50,7 +50,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/map/faq.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/map/faq.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/map/faq.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -106,7 +106,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/map/hist.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/map/hist.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/map/hist.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -28,6 +28,13 @@
 </h3></div></div></div>
 <h5>
 <a name="boost_multiprecision.map.hist.h0"></a>
+ <span class="phrase"><a name="boost_multiprecision.map.hist.1_56"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.1_56">1.56</a>
+ </h5>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+ Added list of values for numeric_limits.
+ </li></ul></div>
+<h5>
+<a name="boost_multiprecision.map.hist.h1"></a>
         <span class="phrase"><a name="boost_multiprecision.map.hist.1_55"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.1_55">1.55</a>
       </h5>
 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
@@ -65,7 +72,7 @@
           </li>
 </ul></div>
 <h5>
-<a name="boost_multiprecision.map.hist.h1"></a>
+<a name="boost_multiprecision.map.hist.h2"></a>
         <span class="phrase"><a name="boost_multiprecision.map.hist.1_54"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.1_54">1.54</a>
       </h5>
 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
@@ -120,7 +127,7 @@
           </li>
 </ul></div>
 <h5>
-<a name="boost_multiprecision.map.hist.h2"></a>
+<a name="boost_multiprecision.map.hist.h3"></a>
         <span class="phrase"><a name="boost_multiprecision.map.hist.1_53"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.1_53">1.53</a>
       </h5>
 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
@@ -136,7 +143,7 @@
           </li>
 </ul></div>
 <h5>
-<a name="boost_multiprecision.map.hist.h3"></a>
+<a name="boost_multiprecision.map.hist.h4"></a>
         <span class="phrase"><a name="boost_multiprecision.map.hist.post_review_changes"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.post_review_changes">Post
         review changes</a>
       </h5>
@@ -190,7 +197,7 @@
           </li>
 </ul></div>
 <h5>
-<a name="boost_multiprecision.map.hist.h4"></a>
+<a name="boost_multiprecision.map.hist.h5"></a>
         <span class="phrase"><a name="boost_multiprecision.map.hist.pre_review_history"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.pre_review_history">Pre-review
         history</a>
       </h5>
@@ -213,7 +220,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/map/todo.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/map/todo.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/map/todo.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -221,7 +221,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/perf.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/perf.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/perf.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -29,7 +29,7 @@
 <div class="toc"><dl class="toc">
 <dt><span class="section"><a href="perf/overhead.html">The Overhead in the
       Number Class Wrapper</a></span></dt>
-<dt><span class="section"><a href="perf/realworld.html">Floating Point Real
+<dt><span class="section"><a href="perf/realworld.html">Floating-Point Real
       World Tests</a></span></dt>
 <dt><span class="section"><a href="perf/int_real_world.html">Integer Real
       World Tests</a></span></dt>
@@ -43,7 +43,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/float_performance.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/float_performance.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/float_performance.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -37,7 +37,7 @@
         for 500000 operations.
       </p>
 <div class="table">
-<a name="boost_multiprecision.perf.float_performance.operator__"></a><p class="title"><b>Table&#160;1.10.&#160;Operator +</b></p>
+<a name="boost_multiprecision.perf.float_performance.operator"></a><p class="title"><b>Table&#160;1.14.&#160;Operator +</b></p>
 <div class="table-contents"><table class="table" summary="Operator +">
 <colgroup>
 <col>
@@ -138,7 +138,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.float_performance.operator___int_"></a><p class="title"><b>Table&#160;1.11.&#160;Operator +(int)</b></p>
+<a name="boost_multiprecision.perf.float_performance.operator_int"></a><p class="title"><b>Table&#160;1.15.&#160;Operator +(int)</b></p>
 <div class="table-contents"><table class="table" summary="Operator +(int)">
 <colgroup>
 <col>
@@ -239,7 +239,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.float_performance.operator___unsigned_long_long_"></a><p class="title"><b>Table&#160;1.12.&#160;Operator +(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.float_performance.operator_unsigned_long_long"></a><p class="title"><b>Table&#160;1.16.&#160;Operator +(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator +(unsigned long long)">
 <colgroup>
 <col>
@@ -340,7 +340,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.float_performance.operator____unsigned_long_long_"></a><p class="title"><b>Table&#160;1.13.&#160;Operator +=(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.float_performance.operator_unsigned_long_long0"></a><p class="title"><b>Table&#160;1.17.&#160;Operator +=(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator +=(unsigned long long)">
 <colgroup>
 <col>
@@ -441,7 +441,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.float_performance.operator0"></a><p class="title"><b>Table&#160;1.14.&#160;Operator -</b></p>
+<a name="boost_multiprecision.perf.float_performance.operator0"></a><p class="title"><b>Table&#160;1.18.&#160;Operator -</b></p>
 <div class="table-contents"><table class="table" summary="Operator -">
 <colgroup>
 <col>
@@ -542,7 +542,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.float_performance.operator_int0"></a><p class="title"><b>Table&#160;1.15.&#160;Operator -(int)</b></p>
+<a name="boost_multiprecision.perf.float_performance.operator_int0"></a><p class="title"><b>Table&#160;1.19.&#160;Operator -(int)</b></p>
 <div class="table-contents"><table class="table" summary="Operator -(int)">
 <colgroup>
 <col>
@@ -643,7 +643,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.float_performance.operator_unsigned_long_long0"></a><p class="title"><b>Table&#160;1.16.&#160;Operator -(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.float_performance.operator_unsigned_long_long1"></a><p class="title"><b>Table&#160;1.20.&#160;Operator -(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator -(unsigned long long)">
 <colgroup>
 <col>
@@ -744,7 +744,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.float_performance.operator_unsigned_long_long1"></a><p class="title"><b>Table&#160;1.17.&#160;Operator -=(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.float_performance.operator_unsigned_long_long2"></a><p class="title"><b>Table&#160;1.21.&#160;Operator -=(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator -=(unsigned long long)">
 <colgroup>
 <col>
@@ -845,7 +845,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.float_performance.operator1"></a><p class="title"><b>Table&#160;1.18.&#160;Operator *</b></p>
+<a name="boost_multiprecision.perf.float_performance.operator1"></a><p class="title"><b>Table&#160;1.22.&#160;Operator *</b></p>
 <div class="table-contents"><table class="table" summary="Operator *">
 <colgroup>
 <col>
@@ -946,7 +946,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.float_performance.operator_int1"></a><p class="title"><b>Table&#160;1.19.&#160;Operator *(int)</b></p>
+<a name="boost_multiprecision.perf.float_performance.operator_int1"></a><p class="title"><b>Table&#160;1.23.&#160;Operator *(int)</b></p>
 <div class="table-contents"><table class="table" summary="Operator *(int)">
 <colgroup>
 <col>
@@ -1047,7 +1047,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.float_performance.operator_unsigned_long_long2"></a><p class="title"><b>Table&#160;1.20.&#160;Operator *(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.float_performance.operator_unsigned_long_long3"></a><p class="title"><b>Table&#160;1.24.&#160;Operator *(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator *(unsigned long long)">
 <colgroup>
 <col>
@@ -1148,7 +1148,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.float_performance.operator_unsigned_long_long3"></a><p class="title"><b>Table&#160;1.21.&#160;Operator *=(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.float_performance.operator_unsigned_long_long4"></a><p class="title"><b>Table&#160;1.25.&#160;Operator *=(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator *=(unsigned long long)">
 <colgroup>
 <col>
@@ -1249,7 +1249,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.float_performance.operator2"></a><p class="title"><b>Table&#160;1.22.&#160;Operator /</b></p>
+<a name="boost_multiprecision.perf.float_performance.operator2"></a><p class="title"><b>Table&#160;1.26.&#160;Operator /</b></p>
 <div class="table-contents"><table class="table" summary="Operator /">
 <colgroup>
 <col>
@@ -1350,7 +1350,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.float_performance.operator_int2"></a><p class="title"><b>Table&#160;1.23.&#160;Operator /(int)</b></p>
+<a name="boost_multiprecision.perf.float_performance.operator_int2"></a><p class="title"><b>Table&#160;1.27.&#160;Operator /(int)</b></p>
 <div class="table-contents"><table class="table" summary="Operator /(int)">
 <colgroup>
 <col>
@@ -1451,7 +1451,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.float_performance.operator_unsigned_long_long4"></a><p class="title"><b>Table&#160;1.24.&#160;Operator /(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.float_performance.operator_unsigned_long_long5"></a><p class="title"><b>Table&#160;1.28.&#160;Operator /(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator /(unsigned long long)">
 <colgroup>
 <col>
@@ -1552,7 +1552,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.float_performance.operator_unsigned_long_long5"></a><p class="title"><b>Table&#160;1.25.&#160;Operator /=(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.float_performance.operator_unsigned_long_long6"></a><p class="title"><b>Table&#160;1.29.&#160;Operator /=(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator /=(unsigned long long)">
 <colgroup>
 <col>
@@ -1653,7 +1653,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.float_performance.operator_construct"></a><p class="title"><b>Table&#160;1.26.&#160;Operator construct</b></p>
+<a name="boost_multiprecision.perf.float_performance.operator_construct"></a><p class="title"><b>Table&#160;1.30.&#160;Operator construct</b></p>
 <div class="table-contents"><table class="table" summary="Operator construct">
 <colgroup>
 <col>
@@ -1754,7 +1754,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.float_performance.operator_construct_unsigned_"></a><p class="title"><b>Table&#160;1.27.&#160;Operator construct(unsigned)</b></p>
+<a name="boost_multiprecision.perf.float_performance.operator_construct_unsigned"></a><p class="title"><b>Table&#160;1.31.&#160;Operator construct(unsigned)</b></p>
 <div class="table-contents"><table class="table" summary="Operator construct(unsigned)">
 <colgroup>
 <col>
@@ -1855,7 +1855,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.float_performance.operator_construct_unsigned_long_long_"></a><p class="title"><b>Table&#160;1.28.&#160;Operator construct(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.float_performance.operator_construct_unsigned_long"></a><p class="title"><b>Table&#160;1.32.&#160;Operator construct(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator construct(unsigned long long)">
 <colgroup>
 <col>
@@ -1956,7 +1956,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.float_performance.operator_str"></a><p class="title"><b>Table&#160;1.29.&#160;Operator str</b></p>
+<a name="boost_multiprecision.perf.float_performance.operator_str"></a><p class="title"><b>Table&#160;1.33.&#160;Operator str</b></p>
 <div class="table-contents"><table class="table" summary="Operator str">
 <colgroup>
 <col>
@@ -2064,7 +2064,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/int_real_world.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/int_real_world.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/int_real_world.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -6,7 +6,7 @@
 <meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
 <link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Multiprecision">
 <link rel="up" href="../perf.html" title="Performance Comparison">
-<link rel="prev" href="realworld.html" title="Floating Point Real World Tests">
+<link rel="prev" href="realworld.html" title="Floating-Point Real World Tests">
 <link rel="next" href="float_performance.html" title="Float Algorithm Performance">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -367,7 +367,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/integer_performance.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/integer_performance.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/integer_performance.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -37,7 +37,7 @@
         for 500000 operations.
       </p>
 <div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator__"></a><p class="title"><b>Table&#160;1.30.&#160;Operator +</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator"></a><p class="title"><b>Table&#160;1.34.&#160;Operator +</b></p>
 <div class="table-contents"><table class="table" summary="Operator +">
 <colgroup>
 <col>
@@ -186,7 +186,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator___int_"></a><p class="title"><b>Table&#160;1.31.&#160;Operator +(int)</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator_int"></a><p class="title"><b>Table&#160;1.35.&#160;Operator +(int)</b></p>
 <div class="table-contents"><table class="table" summary="Operator +(int)">
 <colgroup>
 <col>
@@ -335,7 +335,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator___unsigned_long_long_"></a><p class="title"><b>Table&#160;1.32.&#160;Operator +(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator_unsigned_long_long"></a><p class="title"><b>Table&#160;1.36.&#160;Operator +(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator +(unsigned long long)">
 <colgroup>
 <col>
@@ -484,7 +484,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator____unsigned_long_long_"></a><p class="title"><b>Table&#160;1.33.&#160;Operator +=(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator_unsigned_long_long0"></a><p class="title"><b>Table&#160;1.37.&#160;Operator +=(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator +=(unsigned long long)">
 <colgroup>
 <col>
@@ -633,7 +633,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator0"></a><p class="title"><b>Table&#160;1.34.&#160;Operator -</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator0"></a><p class="title"><b>Table&#160;1.38.&#160;Operator -</b></p>
 <div class="table-contents"><table class="table" summary="Operator -">
 <colgroup>
 <col>
@@ -782,7 +782,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_int0"></a><p class="title"><b>Table&#160;1.35.&#160;Operator -(int)</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator_int0"></a><p class="title"><b>Table&#160;1.39.&#160;Operator -(int)</b></p>
 <div class="table-contents"><table class="table" summary="Operator -(int)">
 <colgroup>
 <col>
@@ -931,7 +931,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_unsigned_long_long0"></a><p class="title"><b>Table&#160;1.36.&#160;Operator -(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator_unsigned_long_long1"></a><p class="title"><b>Table&#160;1.40.&#160;Operator -(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator -(unsigned long long)">
 <colgroup>
 <col>
@@ -1080,7 +1080,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_unsigned_long_long1"></a><p class="title"><b>Table&#160;1.37.&#160;Operator -=(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator_unsigned_long_long2"></a><p class="title"><b>Table&#160;1.41.&#160;Operator -=(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator -=(unsigned long long)">
 <colgroup>
 <col>
@@ -1229,7 +1229,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator1"></a><p class="title"><b>Table&#160;1.38.&#160;Operator *</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator1"></a><p class="title"><b>Table&#160;1.42.&#160;Operator *</b></p>
 <div class="table-contents"><table class="table" summary="Operator *">
 <colgroup>
 <col>
@@ -1378,7 +1378,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_int1"></a><p class="title"><b>Table&#160;1.39.&#160;Operator *(int)</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator_int1"></a><p class="title"><b>Table&#160;1.43.&#160;Operator *(int)</b></p>
 <div class="table-contents"><table class="table" summary="Operator *(int)">
 <colgroup>
 <col>
@@ -1527,7 +1527,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_unsigned_long_long2"></a><p class="title"><b>Table&#160;1.40.&#160;Operator *(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator_unsigned_long_long3"></a><p class="title"><b>Table&#160;1.44.&#160;Operator *(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator *(unsigned long long)">
 <colgroup>
 <col>
@@ -1676,7 +1676,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_unsigned_long_long3"></a><p class="title"><b>Table&#160;1.41.&#160;Operator *=(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator_unsigned_long_long4"></a><p class="title"><b>Table&#160;1.45.&#160;Operator *=(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator *=(unsigned long long)">
 <colgroup>
 <col>
@@ -1825,7 +1825,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator2"></a><p class="title"><b>Table&#160;1.42.&#160;Operator /</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator2"></a><p class="title"><b>Table&#160;1.46.&#160;Operator /</b></p>
 <div class="table-contents"><table class="table" summary="Operator /">
 <colgroup>
 <col>
@@ -1974,7 +1974,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_int2"></a><p class="title"><b>Table&#160;1.43.&#160;Operator /(int)</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator_int2"></a><p class="title"><b>Table&#160;1.47.&#160;Operator /(int)</b></p>
 <div class="table-contents"><table class="table" summary="Operator /(int)">
 <colgroup>
 <col>
@@ -2123,7 +2123,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_unsigned_long_long4"></a><p class="title"><b>Table&#160;1.44.&#160;Operator /(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator_unsigned_long_long5"></a><p class="title"><b>Table&#160;1.48.&#160;Operator /(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator /(unsigned long long)">
 <colgroup>
 <col>
@@ -2272,7 +2272,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_unsigned_long_long5"></a><p class="title"><b>Table&#160;1.45.&#160;Operator /=(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator_unsigned_long_long6"></a><p class="title"><b>Table&#160;1.49.&#160;Operator /=(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator /=(unsigned long long)">
 <colgroup>
 <col>
@@ -2421,7 +2421,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator3"></a><p class="title"><b>Table&#160;1.46.&#160;Operator %</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator3"></a><p class="title"><b>Table&#160;1.50.&#160;Operator %</b></p>
 <div class="table-contents"><table class="table" summary="Operator %">
 <colgroup>
 <col>
@@ -2570,7 +2570,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_int3"></a><p class="title"><b>Table&#160;1.47.&#160;Operator %(int)</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator_int3"></a><p class="title"><b>Table&#160;1.51.&#160;Operator %(int)</b></p>
 <div class="table-contents"><table class="table" summary="Operator %(int)">
 <colgroup>
 <col>
@@ -2719,7 +2719,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_construct"></a><p class="title"><b>Table&#160;1.48.&#160;Operator construct</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator_construct"></a><p class="title"><b>Table&#160;1.52.&#160;Operator construct</b></p>
 <div class="table-contents"><table class="table" summary="Operator construct">
 <colgroup>
 <col>
@@ -2868,7 +2868,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_construct_unsigned_"></a><p class="title"><b>Table&#160;1.49.&#160;Operator construct(unsigned)</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator_construct_unsigned"></a><p class="title"><b>Table&#160;1.53.&#160;Operator construct(unsigned)</b></p>
 <div class="table-contents"><table class="table" summary="Operator construct(unsigned)">
 <colgroup>
 <col>
@@ -3017,7 +3017,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_construct_unsigned_long_long_"></a><p class="title"><b>Table&#160;1.50.&#160;Operator construct(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator_construct_unsigned_long"></a><p class="title"><b>Table&#160;1.54.&#160;Operator construct(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator construct(unsigned long long)">
 <colgroup>
 <col>
@@ -3166,7 +3166,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_gcd"></a><p class="title"><b>Table&#160;1.51.&#160;Operator gcd</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator_gcd"></a><p class="title"><b>Table&#160;1.55.&#160;Operator gcd</b></p>
 <div class="table-contents"><table class="table" summary="Operator gcd">
 <colgroup>
 <col>
@@ -3315,7 +3315,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_powm"></a><p class="title"><b>Table&#160;1.52.&#160;Operator powm</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator_powm"></a><p class="title"><b>Table&#160;1.56.&#160;Operator powm</b></p>
 <div class="table-contents"><table class="table" summary="Operator powm">
 <colgroup>
 <col>
@@ -3464,7 +3464,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_str"></a><p class="title"><b>Table&#160;1.53.&#160;Operator str</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator_str"></a><p class="title"><b>Table&#160;1.57.&#160;Operator str</b></p>
 <div class="table-contents"><table class="table" summary="Operator str">
 <colgroup>
 <col>
@@ -3613,7 +3613,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator4"></a><p class="title"><b>Table&#160;1.54.&#160;Operator |</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator4"></a><p class="title"><b>Table&#160;1.58.&#160;Operator |</b></p>
 <div class="table-contents"><table class="table" summary="Operator |">
 <colgroup>
 <col>
@@ -3762,7 +3762,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_int4"></a><p class="title"><b>Table&#160;1.55.&#160;Operator |(int)</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator_int4"></a><p class="title"><b>Table&#160;1.59.&#160;Operator |(int)</b></p>
 <div class="table-contents"><table class="table" summary="Operator |(int)">
 <colgroup>
 <col>
@@ -3911,7 +3911,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator5"></a><p class="title"><b>Table&#160;1.56.&#160;Operator ^</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator5"></a><p class="title"><b>Table&#160;1.60.&#160;Operator ^</b></p>
 <div class="table-contents"><table class="table" summary="Operator ^">
 <colgroup>
 <col>
@@ -4060,7 +4060,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_int5"></a><p class="title"><b>Table&#160;1.57.&#160;Operator ^(int)</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator_int5"></a><p class="title"><b>Table&#160;1.61.&#160;Operator ^(int)</b></p>
 <div class="table-contents"><table class="table" summary="Operator ^(int)">
 <colgroup>
 <col>
@@ -4209,7 +4209,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator6"></a><p class="title"><b>Table&#160;1.58.&#160;Operator &amp;</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator6"></a><p class="title"><b>Table&#160;1.62.&#160;Operator &amp;</b></p>
 <div class="table-contents"><table class="table" summary="Operator &amp;">
 <colgroup>
 <col>
@@ -4358,7 +4358,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_int6"></a><p class="title"><b>Table&#160;1.59.&#160;Operator &amp;(int)</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator_int6"></a><p class="title"><b>Table&#160;1.63.&#160;Operator &amp;(int)</b></p>
 <div class="table-contents"><table class="table" summary="Operator &amp;(int)">
 <colgroup>
 <col>
@@ -4507,7 +4507,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator___"></a><p class="title"><b>Table&#160;1.60.&#160;Operator &lt;&lt;</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator7"></a><p class="title"><b>Table&#160;1.64.&#160;Operator &lt;&lt;</b></p>
 <div class="table-contents"><table class="table" summary="Operator &lt;&lt;">
 <colgroup>
 <col>
@@ -4656,7 +4656,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator7"></a><p class="title"><b>Table&#160;1.61.&#160;Operator &gt;&gt;</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator8"></a><p class="title"><b>Table&#160;1.65.&#160;Operator &gt;&gt;</b></p>
 <div class="table-contents"><table class="table" summary="Operator &gt;&gt;">
 <colgroup>
 <col>
@@ -4816,7 +4816,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/overhead.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/overhead.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/overhead.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -7,7 +7,7 @@
 <link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Multiprecision">
 <link rel="up" href="../perf.html" title="Performance Comparison">
 <link rel="prev" href="../perf.html" title="Performance Comparison">
-<link rel="next" href="realworld.html" title="Floating Point Real World Tests">
+<link rel="next" href="realworld.html" title="Floating-Point Real World Tests">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -186,7 +186,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/rational_performance.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/rational_performance.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/rational_performance.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -37,7 +37,7 @@
         for 500000 operations.
       </p>
 <div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator__"></a><p class="title"><b>Table&#160;1.62.&#160;Operator +</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator"></a><p class="title"><b>Table&#160;1.66.&#160;Operator +</b></p>
 <div class="table-contents"><table class="table" summary="Operator +">
 <colgroup>
 <col>
@@ -132,7 +132,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator___int_"></a><p class="title"><b>Table&#160;1.63.&#160;Operator +(int)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_int"></a><p class="title"><b>Table&#160;1.67.&#160;Operator +(int)</b></p>
 <div class="table-contents"><table class="table" summary="Operator +(int)">
 <colgroup>
 <col>
@@ -227,7 +227,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator___unsigned_long_long_"></a><p class="title"><b>Table&#160;1.64.&#160;Operator +(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long"></a><p class="title"><b>Table&#160;1.68.&#160;Operator +(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator +(unsigned long long)">
 <colgroup>
 <col>
@@ -322,7 +322,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator____unsigned_long_long_"></a><p class="title"><b>Table&#160;1.65.&#160;Operator +=(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long0"></a><p class="title"><b>Table&#160;1.69.&#160;Operator +=(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator +=(unsigned long long)">
 <colgroup>
 <col>
@@ -417,7 +417,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator0"></a><p class="title"><b>Table&#160;1.66.&#160;Operator -</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator0"></a><p class="title"><b>Table&#160;1.70.&#160;Operator -</b></p>
 <div class="table-contents"><table class="table" summary="Operator -">
 <colgroup>
 <col>
@@ -512,7 +512,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_int0"></a><p class="title"><b>Table&#160;1.67.&#160;Operator -(int)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_int0"></a><p class="title"><b>Table&#160;1.71.&#160;Operator -(int)</b></p>
 <div class="table-contents"><table class="table" summary="Operator -(int)">
 <colgroup>
 <col>
@@ -607,7 +607,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long0"></a><p class="title"><b>Table&#160;1.68.&#160;Operator -(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long1"></a><p class="title"><b>Table&#160;1.72.&#160;Operator -(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator -(unsigned long long)">
 <colgroup>
 <col>
@@ -702,7 +702,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long1"></a><p class="title"><b>Table&#160;1.69.&#160;Operator -=(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long2"></a><p class="title"><b>Table&#160;1.73.&#160;Operator -=(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator -=(unsigned long long)">
 <colgroup>
 <col>
@@ -797,7 +797,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator1"></a><p class="title"><b>Table&#160;1.70.&#160;Operator *</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator1"></a><p class="title"><b>Table&#160;1.74.&#160;Operator *</b></p>
 <div class="table-contents"><table class="table" summary="Operator *">
 <colgroup>
 <col>
@@ -892,7 +892,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_int1"></a><p class="title"><b>Table&#160;1.71.&#160;Operator *(int)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_int1"></a><p class="title"><b>Table&#160;1.75.&#160;Operator *(int)</b></p>
 <div class="table-contents"><table class="table" summary="Operator *(int)">
 <colgroup>
 <col>
@@ -987,7 +987,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long2"></a><p class="title"><b>Table&#160;1.72.&#160;Operator *(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long3"></a><p class="title"><b>Table&#160;1.76.&#160;Operator *(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator *(unsigned long long)">
 <colgroup>
 <col>
@@ -1082,7 +1082,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long3"></a><p class="title"><b>Table&#160;1.73.&#160;Operator *=(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long4"></a><p class="title"><b>Table&#160;1.77.&#160;Operator *=(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator *=(unsigned long long)">
 <colgroup>
 <col>
@@ -1177,7 +1177,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator2"></a><p class="title"><b>Table&#160;1.74.&#160;Operator /</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator2"></a><p class="title"><b>Table&#160;1.78.&#160;Operator /</b></p>
 <div class="table-contents"><table class="table" summary="Operator /">
 <colgroup>
 <col>
@@ -1272,7 +1272,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_int2"></a><p class="title"><b>Table&#160;1.75.&#160;Operator /(int)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_int2"></a><p class="title"><b>Table&#160;1.79.&#160;Operator /(int)</b></p>
 <div class="table-contents"><table class="table" summary="Operator /(int)">
 <colgroup>
 <col>
@@ -1367,7 +1367,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long4"></a><p class="title"><b>Table&#160;1.76.&#160;Operator /(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long5"></a><p class="title"><b>Table&#160;1.80.&#160;Operator /(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator /(unsigned long long)">
 <colgroup>
 <col>
@@ -1462,7 +1462,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long5"></a><p class="title"><b>Table&#160;1.77.&#160;Operator /=(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long6"></a><p class="title"><b>Table&#160;1.81.&#160;Operator /=(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator /=(unsigned long long)">
 <colgroup>
 <col>
@@ -1557,7 +1557,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_construct"></a><p class="title"><b>Table&#160;1.78.&#160;Operator construct</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_construct"></a><p class="title"><b>Table&#160;1.82.&#160;Operator construct</b></p>
 <div class="table-contents"><table class="table" summary="Operator construct">
 <colgroup>
 <col>
@@ -1652,7 +1652,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_construct_unsigned_"></a><p class="title"><b>Table&#160;1.79.&#160;Operator construct(unsigned)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_construct_unsigned"></a><p class="title"><b>Table&#160;1.83.&#160;Operator construct(unsigned)</b></p>
 <div class="table-contents"><table class="table" summary="Operator construct(unsigned)">
 <colgroup>
 <col>
@@ -1747,7 +1747,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_construct_unsigned_long_long_"></a><p class="title"><b>Table&#160;1.80.&#160;Operator construct(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_construct_unsigned_long"></a><p class="title"><b>Table&#160;1.84.&#160;Operator construct(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator construct(unsigned long long)">
 <colgroup>
 <col>
@@ -1842,7 +1842,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_str"></a><p class="title"><b>Table&#160;1.81.&#160;Operator str</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_str"></a><p class="title"><b>Table&#160;1.85.&#160;Operator str</b></p>
 <div class="table-contents"><table class="table" summary="Operator str">
 <colgroup>
 <col>
@@ -1944,7 +1944,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/realworld.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/realworld.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/perf/realworld.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -1,7 +1,7 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Floating Point Real World Tests</title>
+<title>Floating-Point Real World Tests</title>
 <link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
 <meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
 <link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Multiprecision">
@@ -24,7 +24,7 @@
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_multiprecision.perf.realworld"></a><a class="link" href="realworld.html" title="Floating Point Real World Tests">Floating Point Real
+<a name="boost_multiprecision.perf.realworld"></a><a class="link" href="realworld.html" title="Floating-Point Real World Tests">Floating-Point Real
       World Tests</a>
 </h3></div></div></div>
 <p>
@@ -37,7 +37,7 @@
         also shown.
       </p>
 <div class="table">
-<a name="boost_multiprecision.perf.realworld.bessel_function_performance"></a><p class="title"><b>Table&#160;1.8.&#160;Bessel Function Performance</b></p>
+<a name="boost_multiprecision.perf.realworld.bessel_function_performance"></a><p class="title"><b>Table&#160;1.12.&#160;Bessel Function Performance</b></p>
 <div class="table-contents"><table class="table" summary="Bessel Function Performance">
 <colgroup>
 <col>
@@ -168,7 +168,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.realworld.non_central_t_distribution_performance"></a><p class="title"><b>Table&#160;1.9.&#160;Non-Central T Distribution Performance</b></p>
+<a name="boost_multiprecision.perf.realworld.non_central_t_distribution_perfo"></a><p class="title"><b>Table&#160;1.13.&#160;Non-Central T Distribution Performance</b></p>
 <div class="table-contents"><table class="table" summary="Non-Central T Distribution Performance">
 <colgroup>
 <col>
@@ -270,7 +270,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/ref.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/ref.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/ref.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -6,7 +6,7 @@
 <meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
 <link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Multiprecision">
 <link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Multiprecision">
-<link rel="prev" href="tut/serial.html" title="Boost.Serialization Support">
+<link rel="prev" href="tut/input_output.html" title="Input Output">
 <link rel="next" href="ref/number.html" title="number">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="tut/serial.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="ref/number.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="tut/input_output.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="ref/number.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
@@ -33,6 +33,7 @@
 <dt><span class="section">tom_int</span></dt>
 <dt><span class="section">gmp_float</span></dt>
 <dt><span class="section">mpfr_float_backend</span></dt>
+<dt><span class="section">cpp_bin_float</span></dt>
 <dt><span class="section">cpp_dec_float</span></dt>
 <dt><span class="section"><a href="ref/internals.html">Internal Support
       Code</a></span></dt>
@@ -42,7 +43,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>
@@ -50,7 +51,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="tut/serial.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="ref/number.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="tut/input_output.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="ref/number.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/backendconc.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/backendconc.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/backendconc.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -67,7 +67,7 @@
         is a variable of type <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">fmtflags</span></code>.
       </p>
 <div class="table">
-<a name="boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_backend_type_"></a><p class="title"><b>Table&#160;1.4.&#160;Compulsory Requirements on the Backend type.</b></p>
+<a name="boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b"></a><p class="title"><b>Table&#160;1.8.&#160;Compulsory Requirements on the Backend type.</b></p>
 <div class="table-contents"><table class="table" summary="Compulsory Requirements on the Backend type.">
 <colgroup>
 <col>
@@ -954,7 +954,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.ref.backendconc.optional_requirements_on_the_backend_type"></a><p class="title"><b>Table&#160;1.5.&#160;Optional Requirements on the Backend Type</b></p>
+<a name="boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac"></a><p class="title"><b>Table&#160;1.9.&#160;Optional Requirements on the Backend Type</b></p>
 <div class="table-contents"><table class="table" summary="Optional Requirements on the Backend Type">
 <colgroup>
 <col>
@@ -3897,7 +3897,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Added: trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/cpp_bin_float_ref.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/cpp_bin_float_ref.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -0,0 +1,186 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>cpp_bin_float</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Multiprecision">
+<link rel="up" href="../ref.html" title="Reference">
+<link rel="prev" href="mpfr_ref.html" title="mpfr_float_backend">
+<link rel="next" href="cpp_dec_ref.html" title="cpp_dec_float">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="mpfr_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="cpp_dec_ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_multiprecision.ref.cpp_bin_float_ref"></a><a class="link" href="cpp_bin_float_ref.html" title="cpp_bin_float">cpp_bin_float</a>
+</h3></div></div></div>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>
+
+<span class="keyword">enum</span> <span class="identifier">digit_base_type</span>
+<span class="special">{</span>
+ <span class="identifier">digit_base_2</span> <span class="special">=</span> <span class="number">2</span><span class="special">,</span>
+ <span class="identifier">digit_base_10</span> <span class="special">=</span> <span class="number">10</span>
+<span class="special">};</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits</span><span class="special">,</span> <span class="identifier">digit_base_type</span> <span class="identifier">base</span> <span class="special">=</span> <span class="identifier">digit_base_10</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Exponent</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">ExponentMin</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span> <span class="identifier">ExponentMax</span> <span class="special">=</span> <span class="number">0</span><span class="special">&gt;</span>
+<span class="keyword">class</span> <span class="identifier">cpp_bin_float</span><span class="special">;</span>
+
+<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">cpp_bin_float_50</span><span class="special">;</span>
+<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">100</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">cpp_bin_float_100</span><span class="special">;</span>
+
+<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">backends</span><span class="special">::</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">24</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_2</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">int16_t</span><span class="special">,</span> <span class="special">-</span><span class="number">126</span><span class="special">,</span> <span class="number">127</span><span class="special">&gt;,</span> <span class="identifier">et_off</span><span class="special">&gt;</span> <span class="identifier">cpp_bin_float_single</span><span class="special">;</span>
+<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">backends</span><span class="special">::</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">53</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_2</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">int16_t</span><span class="special">,</span> <span class="special">-</span><span class="number">1022</span><span class="special">,</span> <span class="number">1023</span><span class="special">&gt;,</span> <span class="identifier">et_off</span><span class="special">&gt;</span> <span class="identifier">cpp_bin_float_double</span><span class="special">;</span>
+<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">backends</span><span class="special">::</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">64</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_2</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">int16_t</span><span class="special">,</span> <span class="special">-</span><span class="number">16382</span><span class="special">,</span> <span class="number">16383</span><span class="special">&gt;,</span> <span class="identifier">et_off</span><span class="special">&gt;</span> <span class="identifier">cpp_bin_float_double_extended</span><span class="special">;</span>
+<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">backends</span><span class="special">::</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">113</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_2</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">int16_t</span><span class="special">,</span> <span class="special">-</span><span class="number">16382</span><span class="special">,</span> <span class="number">16383</span><span class="special">&gt;,</span> <span class="identifier">et_off</span><span class="special">&gt;</span> <span class="identifier">cpp_bin_float_quad</span><span class="special">;</span>
+
+<span class="special">}}</span> <span class="comment">// namespaces</span>
+</pre>
+<p>
+ Class template <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code>
+ fulfils all of the requirements for a <a class="link" href="backendconc.html" title="Backend Requirements">Backend</a>
+ type. Its members and non-member functions are deliberately not documented:
+ these are considered implementation details that are subject to change.
+ </p>
+<p>
+ The class takes six template parameters:
+ </p>
+<div class="variablelist">
+<p class="title"><b></b></p>
+<dl class="variablelist">
+<dt><span class="term">Digits</span></dt>
+<dd><p>
+ 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.
+ </p></dd>
+<dt><span class="term">base</span></dt>
+<dd><p>
+ An enumerated value (either <code class="computeroutput"><span class="identifier">digit_base_10</span></code>
+ or <code class="computeroutput"><span class="identifier">digit_base_2</span></code>) that
+ indicates whether <code class="computeroutput"><span class="identifier">Digits</span></code>
+ is base-10 or base-2
+ </p></dd>
+<dt><span class="term">Allocator</span></dt>
+<dd><p>
+ The allocator used: defaults to type <code class="computeroutput"><span class="keyword">void</span></code>,
+ 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.
+ </p></dd>
+<dt><span class="term">Exponent</span></dt>
+<dd><p>
+ A signed integer type to use as the type of the exponent - defaults
+ to <code class="computeroutput"><span class="keyword">int</span></code>.
+ </p></dd>
+<dt><span class="term">ExponentMin</span></dt>
+<dd><p>
+ 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".
+ </p></dd>
+<dt><span class="term">ExponentMax</span></dt>
+<dd><p>
+ 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".
+ </p></dd>
+</dl>
+</div>
+<p>
+ The type of <code class="computeroutput"><span class="identifier">number_category</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">...&gt;</span> <span class="special">&gt;::</span><span class="identifier">type</span></code> is <code class="computeroutput"><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">int_</span><span class="special">&lt;</span><span class="identifier">number_kind_floating_point</span><span class="special">&gt;</span></code>.
+ </p>
+<p>
+ More information on this type can be found in the <a class="link" href="../tut/floats/cpp_bin_float.html" title="cpp_bin_float">tutorial</a>.
+ </p>
+<h5>
+<a name="boost_multiprecision.ref.cpp_bin_float_ref.h0"></a>
+ <span class="phrase"><a name="boost_multiprecision.ref.cpp_bin_float_ref.implementation_notes"></a></span><a class="link" href="cpp_bin_float_ref.html#boost_multiprecision.ref.cpp_bin_float_ref.implementation_notes">Implementation
+ Notes</a>
+ </h5>
+<p>
+ Internally, an N-bit <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code>
+ 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.
+ </p>
+<p>
+ 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.
+ </p>
+<p>
+ 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.
+ </p>
+<p>
+ 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).
+ </p>
+<p>
+ Square root uses integer square root in a manner analogous to division.
+ </p>
+<p>
+ 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.
+ </p>
+<p>
+ Binary to decimal conversion proceeds very similarly to the above, our aim
+ is to calculate <code class="computeroutput"><span class="identifier">mantissa</span> <span class="special">*</span> <span class="number">2</span><span class="special">^</span><span class="identifier">shift</span> <span class="special">*</span> <span class="number">10</span><span class="special">^</span><span class="identifier">E</span></code>
+ where <code class="computeroutput"><span class="identifier">E</span></code> is the decimal exponent
+ and <code class="computeroutput"><span class="identifier">shift</span></code> 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.
+ </p>
+</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 &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
+ 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)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="mpfr_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="cpp_dec_ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/cpp_dec_ref.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/cpp_dec_ref.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/cpp_dec_ref.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -6,7 +6,7 @@
 <meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
 <link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;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">
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="mpfr_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="internals.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="cpp_bin_float_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="internals.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -70,7 +70,7 @@
 </dl>
 </div>
 <p>
- The type of <code class="computeroutput"><span class="identifier">number_category</span><span class="special">&lt;</span><span class="identifier">cpp_int</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">...&gt;</span> <span class="special">&gt;::</span><span class="identifier">type</span></code> is <code class="computeroutput"><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">int_</span><span class="special">&lt;</span><span class="identifier">number_kind_floating_point</span><span class="special">&gt;</span></code>.
+ The type of <code class="computeroutput"><span class="identifier">number_category</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">...&gt;</span> <span class="special">&gt;::</span><span class="identifier">type</span></code> is <code class="computeroutput"><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">int_</span><span class="special">&lt;</span><span class="identifier">number_kind_floating_point</span><span class="special">&gt;</span></code>.
       </p>
 <p>
         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>.
@@ -78,7 +78,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>
@@ -86,7 +86,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="mpfr_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="internals.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="cpp_bin_float_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="internals.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/cpp_int_ref.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/cpp_int_ref.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/cpp_int_ref.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -143,7 +143,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/gmp_int_ref.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/gmp_int_ref.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/gmp_int_ref.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -49,7 +49,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/headers.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/headers.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/headers.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -27,7 +27,7 @@
 <a name="boost_multiprecision.ref.headers"></a><a class="link" href="headers.html" title="Header File Structure">Header File Structure</a>
 </h3></div></div></div>
 <div class="table">
-<a name="boost_multiprecision.ref.headers.top_level_headers"></a><p class="title"><b>Table&#160;1.6.&#160;Top level headers</b></p>
+<a name="boost_multiprecision.ref.headers.top_level_headers"></a><p class="title"><b>Table&#160;1.10.&#160;Top level headers</b></p>
 <div class="table-contents"><table class="table" summary="Top level headers">
 <colgroup>
 <col>
@@ -176,8 +176,8 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.ref.headers.implementation_headers_"></a><p class="title"><b>Table&#160;1.7.&#160;Implementation Headers]</b></p>
-<div class="table-contents"><table class="table" summary="Implementation Headers]">
+<a name="boost_multiprecision.ref.headers.implementation_headers"></a><p class="title"><b>Table&#160;1.11.&#160;Implementation Headers</b></p>
+<div class="table-contents"><table class="table" summary="Implementation Headers">
 <colgroup>
 <col>
 <col>
@@ -410,7 +410,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/internals.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/internals.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/internals.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -100,7 +100,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/mpf_ref.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/mpf_ref.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/mpf_ref.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -65,7 +65,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/mpfr_ref.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/mpfr_ref.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/mpfr_ref.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -7,7 +7,7 @@
 <link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;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">
 <table cellpadding="2" width="100%"><tr>
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="mpf_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="cpp_dec_ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="mpf_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="cpp_bin_float_ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -65,7 +65,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>
@@ -73,7 +73,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="mpf_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="cpp_dec_ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="mpf_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="cpp_bin_float_ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/number.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/number.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/number.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -477,11 +477,11 @@
 <li class="listitem">
             Zero for <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span>
             <span class="special">==</span> <span class="identifier">other</span></code>
- </li>
-</ul></div>
 <pre class="programlisting"><span class="identifier">Backend</span><span class="special">&amp;</span> <span class="identifier">backend</span><span class="special">();</span>
 <span class="keyword">const</span> <span class="identifier">Backend</span><span class="special">&amp;</span> <span class="identifier">backend</span><span class="special">()</span><span class="keyword">const</span><span class="special">;</span>
 </pre>
+ </li>
+</ul></div>
 <p>
         Returns the underlying back-end instance used by <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
       </p>
@@ -589,7 +589,7 @@
       </p>
 <h5>
 <a name="boost_multiprecision.ref.number.h5"></a>
- <span class="phrase"><a name="boost_multiprecision.ref.number.arithmetic_with_a_higher_precision_result"></a></span><a class="link" href="number.html#boost_multiprecision.ref.number.arithmetic_with_a_higher_precision_result">Arithmetic
+ <span class="phrase"><a name="boost_multiprecision.ref.number.arithmetic_with_a_higher_precisi"></a></span><a class="link" href="number.html#boost_multiprecision.ref.number.arithmetic_with_a_higher_precisi">Arithmetic
         with a higher precision result</a>
       </h5>
 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ResultType</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Source1</span> <span class="keyword">class</span> <span class="identifier">Source2</span><span class="special">&gt;</span>
@@ -621,7 +621,7 @@
       </p>
 <h5>
 <a name="boost_multiprecision.ref.number.h6"></a>
- <span class="phrase"><a name="boost_multiprecision.ref.number.non_member_standard_library_function_support"></a></span><a class="link" href="number.html#boost_multiprecision.ref.number.non_member_standard_library_function_support">Non-member
+ <span class="phrase"><a name="boost_multiprecision.ref.number.non_member_standard_library_func"></a></span><a class="link" href="number.html#boost_multiprecision.ref.number.non_member_standard_library_func">Non-member
         standard library function support</a>
       </h5>
 <pre class="programlisting"><span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="identifier">abs</span> <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
@@ -1255,7 +1255,7 @@
       </p>
 <h5>
 <a name="boost_multiprecision.ref.number.h10"></a>
- <span class="phrase"><a name="boost_multiprecision.ref.number.boost_math_interoperability_support"></a></span><a class="link" href="number.html#boost_multiprecision.ref.number.boost_math_interoperability_support">Boost.Math
+ <span class="phrase"><a name="boost_multiprecision.ref.number.boost_math_interoperability_supp"></a></span><a class="link" href="number.html#boost_multiprecision.ref.number.boost_math_interoperability_supp">Boost.Math
         Interoperability Support</a>
       </h5>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">math</span><span class="special">{</span>
@@ -1278,7 +1278,7 @@
       </p>
 <h5>
 <a name="boost_multiprecision.ref.number.h11"></a>
- <span class="phrase"><a name="boost_multiprecision.ref.number.std__numeric_limits_support"></a></span><a class="link" href="number.html#boost_multiprecision.ref.number.std__numeric_limits_support">std::numeric_limits
+ <span class="phrase"><a name="boost_multiprecision.ref.number.std_numeric_limits_support"></a></span><a class="link" href="number.html#boost_multiprecision.ref.number.std_numeric_limits_support">std::numeric_limits
         support</a>
       </h5>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span><span class="special">{</span>
@@ -1301,7 +1301,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/tom_int_ref.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/tom_int_ref.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/ref/tom_int_ref.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -49,7 +49,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -40,6 +40,7 @@
 </dl></dd>
 <dt><span class="section">Floating Point Numbers</span></dt>
 <dd><dl>
+<dt><span class="section">cpp_bin_float</span></dt>
 <dt><span class="section">cpp_dec_float</span></dt>
 <dt><span class="section">gmp_float</span></dt>
 <dt><span class="section">mpfr_float</span></dt>
@@ -86,6 +87,18 @@
 <dt><span class="section">Generic Integer Operations</span></dt>
 <dt><span class="section"><a href="tut/serial.html">Boost.Serialization
       Support</a></span></dt>
+<dt><span class="section">Numeric Limits</span></dt>
+<dd><dl>
+<dt><span class="section"><a href="tut/limits/constants.html">std::numeric_limits&lt;&gt;
+ constants</a></span></dt>
+<dt><span class="section"><a href="tut/limits/functions.html">std::numeric_limits&lt;&gt;
+ functions</a></span></dt>
+<dt><span class="section"><a href="tut/limits/limits32.html">Numeric limits
+ for 32-bit platform</a></span></dt>
+<dt><span class="section"><a href="tut/limits/how_to_tell.html">How to
+ Determine the Kind of a Number From <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code></a></span></dt>
+</dl></dd>
+<dt><span class="section">Input Output</span></dt>
 </dl></div>
 <p>
       In order to use this library you need to make two choices:
@@ -104,7 +117,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/conversions.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/conversions.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/conversions.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -31,51 +31,53 @@
         All of the number types that are based on <code class="computeroutput"><span class="identifier">number</span></code>
         have certain conversion rules in common. In particular:
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
             Any number type can be constructed (or assigned) from any builtin arithmetic
             type, as long as the conversion isn't lossy (for example float to int
             conversion):
- </li></ul></div>
 <pre class="programlisting"><span class="identifier">cpp_dec_float_50</span> <span class="identifier">df</span><span class="special">(</span><span class="number">0.5</span><span class="special">);</span> <span class="comment">// OK construction from double</span>
 <span class="identifier">cpp_int</span> <span class="identifier">i</span><span class="special">(</span><span class="number">450</span><span class="special">);</span> <span class="comment">// OK constructs from signed int</span>
 <span class="identifier">cpp_int</span> <span class="identifier">j</span> <span class="special">=</span> <span class="number">3.14</span><span class="special">;</span> <span class="comment">// Error, lossy conversion.</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+ </li>
+<li class="listitem">
             A number can be explicitly constructed from an arithmetic type, even
             when the conversion is lossy:
- </li></ul></div>
 <pre class="programlisting"><span class="identifier">cpp_int</span> <span class="identifier">i</span><span class="special">(</span><span class="number">3.14</span><span class="special">);</span> <span class="comment">// OK explicit conversion</span>
 <span class="identifier">i</span> <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">cpp_int</span><span class="special">&gt;(</span><span class="number">3.14</span><span class="special">)</span> <span class="comment">// OK explicit conversion</span>
 <span class="identifier">i</span><span class="special">.</span><span class="identifier">assign</span><span class="special">(</span><span class="number">3.14</span><span class="special">);</span> <span class="comment">// OK, explicit assign and avoid a temporary from the cast above</span>
 <span class="identifier">i</span> <span class="special">=</span> <span class="number">3.14</span><span class="special">;</span> <span class="comment">// Error, no implicit assignment operator for lossy conversion.</span>
 <span class="identifier">cpp_int</span> <span class="identifier">j</span> <span class="special">=</span> <span class="number">3.14</span><span class="special">;</span> <span class="comment">// Error, no implicit constructor for lossy conversion.</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+ </li>
+<li class="listitem">
             A <code class="computeroutput"><span class="identifier">number</span></code> can be converted
             to any built in type, via the <code class="computeroutput"><span class="identifier">convert_to</span></code>
             member function:
- </li></ul></div>
 <pre class="programlisting"><span class="identifier">mpz_int</span> <span class="identifier">z</span><span class="special">(</span><span class="number">2</span><span class="special">);</span>
 <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="identifier">z</span><span class="special">.</span><span class="keyword">template</span> <span class="identifier">convert_to</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;();</span> <span class="comment">// sets i to 2</span>
 </pre>
+ </li>
+</ul></div>
 <p>
         Additional conversions may be supported by particular backends.
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
             A <code class="computeroutput"><span class="identifier">number</span></code> can be converted
             to any built in type, via an explicit conversion operator: this functionality
             is only available on compilers supporting C++11's explicit conversion
             syntax.
- </li></ul></div>
 <pre class="programlisting"><span class="identifier">mpz_int</span> <span class="identifier">z</span><span class="special">(</span><span class="number">2</span><span class="special">);</span>
 <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="identifier">z</span><span class="special">;</span> <span class="comment">// Error, implicit conversion not allowed.</span>
 <span class="keyword">int</span> <span class="identifier">j</span> <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">z</span><span class="special">);</span> <span class="comment">// OK explicit conversion.</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+ </li>
+<li class="listitem">
             Any number type can be <span class="emphasis"><em>explicitly</em></span> constructed (or
             assigned) from a <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span></code>
             or a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code>:
- </li></ul></div>
 <pre class="programlisting"><span class="comment">// pi to 50 places from a string:</span>
 <span class="identifier">cpp_dec_float_50</span> <span class="identifier">df</span><span class="special">(</span><span class="string">"3.14159265358979323846264338327950288419716939937510"</span><span class="special">);</span>
 <span class="comment">// Integer type will automatically detect "0x" and "0" prefixes and parse the string accordingly:</span>
@@ -87,10 +89,10 @@
 <span class="comment">// assign member function, avoids having to create a temporary via a static_cast:</span>
 <span class="identifier">i</span><span class="special">.</span><span class="identifier">assign</span><span class="special">(</span><span class="string">"23"</span><span class="special">);</span> <span class="comment">// OK</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+ </li>
+<li class="listitem">
             Any number type will interoperate with the builtin types in arithmetic
             expressions as long as the conversions are not lossy:
- </li></ul></div>
 <pre class="programlisting"><span class="comment">// pi to 50 places from a string:</span>
 <span class="identifier">cpp_dec_float_50</span> <span class="identifier">df</span> <span class="special">=</span> <span class="string">"3.14159265358979323846264338327950288419716939937510"</span><span class="special">;</span>
 <span class="comment">// Multiply by 2 - using an integer literal here is usually more efficient</span>
@@ -101,9 +103,9 @@
 <span class="identifier">cpp_int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
 <span class="identifier">i</span> <span class="special">*=</span> <span class="number">3.14</span><span class="special">;</span> <span class="comment">// Error, no *= operator will be found.</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+ </li>
+<li class="listitem">
             Any number type can be streamed to and from the C++ iostreams:
- </li></ul></div>
 <pre class="programlisting"><span class="identifier">cpp_dec_float_50</span> <span class="identifier">df</span> <span class="special">=</span> <span class="string">"3.14159265358979323846264338327950288419716939937510"</span><span class="special">;</span>
 <span class="comment">// Now print at full precision:</span>
 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_50</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">)</span>
@@ -113,11 +115,11 @@
 <span class="comment">// Now print in hex format with prefix:</span>
 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hex</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">showbase</span> <span class="special">&lt;&lt;</span> <span class="identifier">i</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+ </li>
+<li class="listitem">
             Interconversions between number types of the same family are allowed
             and are implicit conversions if no loss of precision is involved, and
             explicit if it is:
- </li></ul></div>
 <pre class="programlisting"><span class="identifier">int128_t</span> <span class="identifier">i128</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
 <span class="identifier">int266_t</span> <span class="identifier">i256</span> <span class="special">=</span> <span class="identifier">i128</span><span class="special">;</span> <span class="comment">// OK implicit widening conversion</span>
 <span class="identifier">i128_t</span> <span class="special">=</span> <span class="identifier">i256</span><span class="special">;</span> <span class="comment">// Error, no assignment operator found, narrowing conversion is explicit</span>
@@ -130,12 +132,12 @@
 <span class="identifier">f</span> <span class="special">=</span> <span class="identifier">f50</span><span class="special">;</span> <span class="comment">// OK, conversion from fixed to variable precision, f will have 50 digits precision.</span>
 <span class="identifier">f50</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">;</span> <span class="comment">// Error, conversion from variable to fixed precision is potentially lossy, explicit cast required.</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+ </li>
+<li class="listitem">
             Some interconversions between number types are completely generic, and
             are always available, albeit the conversions are always <span class="emphasis"><em>explicit</em></span>:
- </li></ul></div>
 <pre class="programlisting"><span class="identifier">cpp_int</span> <span class="identifier">cppi</span><span class="special">(</span><span class="number">2</span><span class="special">);</span>
-<span class="comment">// We can always convert between numbers of the same category - </span>
+<span class="comment">// We can always convert between numbers of the same category -</span>
 <span class="comment">// int to int, rational to rational, or float to float, so this is OK</span>
 <span class="comment">// as long as we use an explicit conversion:</span>
 <span class="identifier">mpz_int</span> <span class="identifier">z</span><span class="special">(</span><span class="identifier">cppi</span><span class="special">);</span>
@@ -146,14 +148,16 @@
 <span class="comment">// However narrowing and/or implicit conversions always fail:</span>
 <span class="identifier">cppi</span> <span class="special">=</span> <span class="identifier">df</span><span class="special">;</span> <span class="comment">// Compiler error, conversion not allowed</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+ </li>
+<li class="listitem">
             Other interconversions may be allowed as special cases, whenever the
             backend allows it:
- </li></ul></div>
 <pre class="programlisting"><span class="identifier">mpf_t</span> <span class="identifier">m</span><span class="special">;</span> <span class="comment">// Native GMP type.</span>
 <span class="identifier">mpf_init_set_ui</span><span class="special">(</span><span class="identifier">m</span><span class="special">,</span> <span class="number">0</span><span class="special">);</span> <span class="comment">// set to a value;</span>
 <span class="identifier">mpf_float</span> <span class="identifier">i</span><span class="special">(</span><span class="identifier">m</span><span class="special">);</span> <span class="comment">// copies the value of the native type.</span>
 </pre>
+ </li>
+</ul></div>
 <p>
         More information on what additional types a backend supports conversions
         from are given in the tutorial for each backend. The converting constructor
@@ -163,7 +167,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -7,7 +7,7 @@
 <link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Multiprecision">
 <link rel="up" href="../tut.html" title="Tutorial">
 <link rel="prev" href="ints/egs/bitops.html" title="Bit Operations">
-<link rel="next" href="floats/cpp_dec_float.html" title="cpp_dec_float">
+<link rel="next" href="floats/cpp_bin_float.html" title="cpp_bin_float">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -20,13 +20,14 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="ints/egs/bitops.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="floats/cpp_dec_float.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="ints/egs/bitops.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="floats/cpp_bin_float.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_multiprecision.tut.floats"></a><a class="link" href="floats.html" title="Floating Point Numbers">Floating Point Numbers</a>
 </h3></div></div></div>
 <div class="toc"><dl class="toc">
+<dt><span class="section">cpp_bin_float</span></dt>
 <dt><span class="section">cpp_dec_float</span></dt>
 <dt><span class="section">gmp_float</span></dt>
 <dt><span class="section">mpfr_float</span></dt>
@@ -93,6 +94,39 @@
 <tr>
 <td>
                 <p>
+ <code class="computeroutput"><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">&gt;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ boost/multiprecision/cpp_bin_float.hpp
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ None
+ </p>
+ </td>
+<td>
+ <p>
+ Header only, all C++ implementation. Boost licence.
+ </p>
+ </td>
+<td>
+ <p>
+ Approximately 2x slower than the MPFR
+ or GMP libraries.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
                   <code class="computeroutput"><span class="identifier">cpp_dec_float</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">&gt;</span></code>
                 </p>
               </td>
@@ -229,7 +263,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>
@@ -237,7 +271,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="ints/egs/bitops.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="floats/cpp_dec_float.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="ints/egs/bitops.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="floats/cpp_bin_float.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

Added: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_bin_float.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_bin_float.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -0,0 +1,192 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>cpp_bin_float</title>
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../index.html" title="Chapter&#160;1.&#160;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">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../floats.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="cpp_dec_float.html"><img src="../../../../../../../doc/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>
+<p>
+ <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_bin_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+ </p>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>
+
+<span class="keyword">enum</span> <span class="identifier">digit_base_type</span>
+<span class="special">{</span>
+ <span class="identifier">digit_base_2</span> <span class="special">=</span> <span class="number">2</span><span class="special">,</span>
+ <span class="identifier">digit_base_10</span> <span class="special">=</span> <span class="number">10</span>
+<span class="special">};</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits</span><span class="special">,</span> <span class="identifier">digit_base_type</span> <span class="identifier">base</span> <span class="special">=</span> <span class="identifier">digit_base_10</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Exponent</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">ExponentMin</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span> <span class="identifier">ExponentMax</span> <span class="special">=</span> <span class="number">0</span><span class="special">&gt;</span>
+<span class="keyword">class</span> <span class="identifier">cpp_bin_float</span><span class="special">;</span>
+
+<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">cpp_bin_float_50</span><span class="special">;</span>
+<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">100</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">cpp_bin_float_100</span><span class="special">;</span>
+
+<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">backends</span><span class="special">::</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">24</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_2</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">int16_t</span><span class="special">,</span> <span class="special">-</span><span class="number">126</span><span class="special">,</span> <span class="number">127</span><span class="special">&gt;,</span> <span class="identifier">et_off</span><span class="special">&gt;</span> <span class="identifier">cpp_bin_float_single</span><span class="special">;</span>
+<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">backends</span><span class="special">::</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">53</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_2</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">int16_t</span><span class="special">,</span> <span class="special">-</span><span class="number">1022</span><span class="special">,</span> <span class="number">1023</span><span class="special">&gt;,</span> <span class="identifier">et_off</span><span class="special">&gt;</span> <span class="identifier">cpp_bin_float_double</span><span class="special">;</span>
+<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">backends</span><span class="special">::</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">64</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_2</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">int16_t</span><span class="special">,</span> <span class="special">-</span><span class="number">16382</span><span class="special">,</span> <span class="number">16383</span><span class="special">&gt;,</span> <span class="identifier">et_off</span><span class="special">&gt;</span> <span class="identifier">cpp_bin_float_double_extended</span><span class="special">;</span>
+<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">backends</span><span class="special">::</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">113</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_2</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">int16_t</span><span class="special">,</span> <span class="special">-</span><span class="number">16382</span><span class="special">,</span> <span class="number">16383</span><span class="special">&gt;,</span> <span class="identifier">et_off</span><span class="special">&gt;</span> <span class="identifier">cpp_bin_float_quad</span><span class="special">;</span>
+
+<span class="special">}}</span> <span class="comment">// namespaces</span>
+</pre>
+<p>
+ The <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code> back-end
+ is used in conjunction with <code class="computeroutput"><span class="identifier">number</span></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.
+ </p>
+<p>
+ Type <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code> can
+ be used at fixed precision by specifying a non-zero <code class="computeroutput"><span class="identifier">Digits</span></code>
+ template parameter. The typedefs <code class="computeroutput"><span class="identifier">cpp_bin_float_50</span></code>
+ and <code class="computeroutput"><span class="identifier">cpp_bin_float_100</span></code> provide
+ arithmetic types at 50 and 100 decimal digits precision respectively.
+ </p>
+<p>
+ Optionally, you can specify whether the precision is specified in decimal
+ digits or binary bits - for example to declare a <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code>
+ with exactly the same precision as <code class="computeroutput"><span class="keyword">double</span></code>
+ one would use <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">53</span><span class="special">,</span> <span class="identifier">digit_base_2</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>.
+ The typedefs <code class="computeroutput"><span class="identifier">cpp_bin_float_single</span></code>,
+ <code class="computeroutput"><span class="identifier">cpp_bin_float_double</span></code>,
+ <code class="computeroutput"><span class="identifier">cpp_bin_float_quad</span></code> and
+ <code class="computeroutput"><span class="identifier">cpp_bin_float_double_extended</span></code>
+ 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.
+ </p>
+<p>
+ Normally <code class="computeroutput"><span class="identifier">cpp_bin_float</span></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 a template parameter causes <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code>
+ to dynamically allocate the memory it needs: this significantly reduces
+ the size of <code class="computeroutput"><span class="identifier">cpp_bin_float</span></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 <span class="emphasis"><em>very</em></span> 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"><span class="keyword">void</span></code> <code class="computeroutput"><span class="identifier">value_type</span></code>,
+ for example: <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">1000</span><span class="special">,</span> <span class="identifier">digit_base_10</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="special">&gt;</span></code>.
+ </p>
+<p>
+ The final template parameters determine the type and range of the exponent:
+ parameter <code class="computeroutput"><span class="identifier">Exponent</span></code> can
+ be any signed integer type, but note that <code class="computeroutput"><span class="identifier">MinExponent</span></code>
+ and <code class="computeroutput"><span class="identifier">MaxExponent</span></code> can not
+ go right up to the limits of the <code class="computeroutput"><span class="identifier">Exponent</span></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.
+ </p>
+<p>
+ There is full standard library and <code class="computeroutput"><span class="identifier">numeric_limits</span></code>
+ support available for this type.
+ </p>
+<p>
+ Things you should know when using this type:
+ </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+ Default constructed <code class="computeroutput"><span class="identifier">cpp_bin_float</span></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"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code> specialisation for
+ this type.
+ </li>
+<li class="listitem">
+ Any <code class="computeroutput"><span class="identifier">number</span></code> instantiated
+ on this type, is convertible to any other <code class="computeroutput"><span class="identifier">number</span></code>
+ instantiated on this type - for example you can convert from <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;</span> <span class="special">&gt;</span></code> to <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="identifier">SomeOtherValue</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>.
+ Narrowing conversions round to nearest and are <code class="computeroutput"><span class="keyword">explicit</span></code>.
+ </li>
+<li class="listitem">
+ Conversion from a string results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></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"><span class="identifier">sqrt</span></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>
+ <span class="phrase"><a name="boost_multiprecision.tut.floats.cpp_bin_float.cpp_bin_float_example"></a></span><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"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_bin_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+
+<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>
+
+<span class="comment">// Operations at fixed precision and full numeric_limits support:</span>
+<span class="identifier">cpp_bin_float_100</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_100</span><span class="special">&gt;::</span><span class="identifier">digits</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_100</span><span class="special">&gt;::</span><span class="identifier">digits10</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="comment">// We can use any C++ std lib function, lets print all the digits as well:</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_100</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">)</span>
+ <span class="special">&lt;&lt;</span> <span class="identifier">log</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// print log(2)</span>
+<span class="comment">// We can also use any function from Boost.Math:</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="comment">// These even work when the argument is an expression template:</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">b</span> <span class="special">*</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="comment">// And since we have an extended exponent range we can generate some really large </span>
+<span class="comment">// numbers here (4.0238726007709377354370243e+2564):</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">cpp_bin_float_100</span><span class="special">(</span><span class="number">1000</span><span class="special">))</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+</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 &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
+ 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)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../floats.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="cpp_dec_float.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_dec_float.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_dec_float.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_dec_float.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -6,7 +6,7 @@
 <meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
 <link rel="home" href="../../../index.html" title="Chapter&#160;1.&#160;Boost.Multiprecision">
 <link rel="up" href="../floats.html" title="Floating Point Numbers">
-<link rel="prev" href="../floats.html" title="Floating Point Numbers">
+<link rel="prev" href="cpp_bin_float.html" title="cpp_bin_float">
 <link rel="next" href="gmp_float.html" title="gmp_float">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="../floats.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="gmp_float.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="cpp_bin_float.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="gmp_float.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h4 class="title">
@@ -130,11 +130,9 @@
 </ul></div>
 <h6>
 <a name="boost_multiprecision.tut.floats.cpp_dec_float.h0"></a>
- <span class="phrase"><a name="boost_multiprecision.tut.floats.cpp_dec_float.cpp_dec_float_example_"></a></span><a class="link" href="cpp_dec_float.html#boost_multiprecision.tut.floats.cpp_dec_float.cpp_dec_float_example_">cpp_dec_float
+ <span class="phrase"><a name="boost_multiprecision.tut.floats.cpp_dec_float.cpp_dec_float_example"></a></span><a class="link" href="cpp_dec_float.html#boost_multiprecision.tut.floats.cpp_dec_float.cpp_dec_float_example">cpp_dec_float
           example:</a>
         </h6>
-<p>
-</p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_dec_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 
 <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>
@@ -155,12 +153,10 @@
 <span class="comment">// numbers here (4.0238726007709377354370243e+2564):</span>
 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">cpp_dec_float_100</span><span class="special">(</span><span class="number">1000</span><span class="special">))</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 </pre>
-<p>
- </p>
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>
@@ -168,7 +164,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="../floats.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="gmp_float.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="cpp_bin_float.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="gmp_float.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/float128.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/float128.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/float128.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -109,11 +109,9 @@
 </ul></div>
 <h6>
 <a name="boost_multiprecision.tut.floats.float128.h0"></a>
- <span class="phrase"><a name="boost_multiprecision.tut.floats.float128.float128_example_"></a></span><a class="link" href="float128.html#boost_multiprecision.tut.floats.float128.float128_example_">float128
+ <span class="phrase"><a name="boost_multiprecision.tut.floats.float128.float128_example"></a></span><a class="link" href="float128.html#boost_multiprecision.tut.floats.float128.float128_example">float128
           example:</a>
         </h6>
-<p>
-</p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">float128</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 
 <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>
@@ -138,8 +136,6 @@
 
 <span class="keyword">constexpr</span> <span class="identifier">float128</span> <span class="identifier">pi</span> <span class="special">=</span> <span class="number">3.1415926535897932384626433832795028841971693993751058</span><span class="identifier">Q</span><span class="special">;</span>
 </pre>
-<p>
- </p>
 <div class="footnotes">
 <br><hr style="width:100; text-align:left;margin-left: 0">
 <div id="ftn.boost_multiprecision.tut.floats.float128.f0" class="footnote"><p>[3]
@@ -149,7 +145,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -41,7 +41,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/aos.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/aos.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/aos.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -39,8 +39,6 @@
             The area of a circle can be computed in generic programming using Boost.Math
             for the constant &#960; as shown below:
           </p>
-<p>
-</p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">constants</span><span class="special">/</span><span class="identifier">constants</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 
 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
@@ -51,8 +49,6 @@
 <span class="special">}</span>
 </pre>
 <p>
- </p>
-<p>
             It is possible to use <code class="computeroutput"><span class="identifier">area_of_a_circle</span><span class="special">()</span></code> with built-in floating-point types
             as well as floating-point types from Boost.Multiprecision. In particular,
             consider a system with 4-byte single-precision float, 8-byte double-precision
@@ -64,8 +60,6 @@
             123/100 for <code class="computeroutput"><span class="keyword">float</span></code>, <code class="computeroutput"><span class="keyword">double</span></code> and <code class="computeroutput"><span class="identifier">cpp_dec_float_50</span></code>
             with the program below.
           </p>
-<p>
-</p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iomanip</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_dec_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
@@ -103,8 +97,6 @@
 <span class="special">}</span>
 </pre>
 <p>
- </p>
-<p>
             In the next example we'll look at calling both standard library and Boost.Math
             functions from within generic code. We'll also show how to cope with
             template arguments which are expression-templates rather than number
@@ -113,7 +105,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/gi.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/gi.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/gi.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -31,8 +31,6 @@
             Similar to the generic derivative example, we can calculate integrals
             in a similar manner:
           </p>
-<p>
-</p>
 <pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">value_type</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">function_type</span><span class="special">&gt;</span>
 <span class="keyword">inline</span> <span class="identifier">value_type</span> <span class="identifier">integral</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">a</span><span class="special">,</span>
                            <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">b</span><span class="special">,</span>
@@ -73,14 +71,10 @@
 <span class="special">}</span>
 </pre>
 <p>
- </p>
-<p>
             The following sample program shows how the function can be called, we
             begin by defining a function object, which when integrated should yield
             the Bessel J function:
           </p>
-<p>
-</p>
 <pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">value_type</span><span class="special">&gt;</span>
 <span class="keyword">class</span> <span class="identifier">cyl_bessel_j_integral_rep</span>
 <span class="special">{</span>
@@ -99,10 +93,6 @@
    <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">x</span><span class="special">;</span>
 <span class="special">};</span>
 </pre>
-<p>
- </p>
-<p>
-</p>
 <pre class="programlisting"> <span class="comment">/* The function can now be called as follows: */</span>
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">**)</span>
 <span class="special">{</span>
@@ -151,12 +141,10 @@
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">cyl_bessel_j</span><span class="special">(</span><span class="number">2</span><span class="special">,</span> <span class="identifier">mp_type</span><span class="special">(</span><span class="number">123</span><span class="special">)</span> <span class="special">/</span> <span class="number">100</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-<p>
- </p>
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/jel.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/jel.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/jel.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -42,16 +42,12 @@
             If we were to implement this at double precision using Boost.Math's facilities
             for the Gamma and Bessel function calls it would look like this:
           </p>
-<p>
-</p>
 <pre class="programlisting"><span class="keyword">double</span> <span class="identifier">JEL1</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">v</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">z</span><span class="special">)</span>
 <span class="special">{</span>
    <span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">v</span> <span class="special">+</span> <span class="number">1</span><span class="special">)</span> <span class="special">*</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">cyl_bessel_j</span><span class="special">(</span><span class="identifier">v</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> <span class="special">/</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pow</span><span class="special">(</span><span class="identifier">z</span> <span class="special">/</span> <span class="number">2</span><span class="special">,</span>
<span class="identifier">v</span><span class="special">);</span>
 <span class="special">}</span>
 </pre>
 <p>
- </p>
-<p>
             Calling this function as:
           </p>
 <pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">scientific</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">);</span>
@@ -66,8 +62,6 @@
             type <code class="computeroutput"><span class="identifier">cpp_dec_float_50</span></code>
             as the argument type:
           </p>
-<p>
-</p>
 <pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_dec_float_50</span>
    <span class="identifier">JEL2</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_dec_float_50</span> <span class="identifier">v</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_dec_float_50</span> <span class="identifier">z</span><span class="special">)</span>
 <span class="special">{</span>
@@ -75,8 +69,6 @@
 <span class="special">}</span>
 </pre>
 <p>
- </p>
-<p>
             The implementation is almost the same as before, but with one key difference
             - we can no longer call <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pow</span></code>,
             instead we must call the version inside the <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span></code>
@@ -107,8 +99,6 @@
             type (<code class="computeroutput"><span class="keyword">float</span></code>, <code class="computeroutput"><span class="keyword">double</span></code> etc), or with a multiprecision
             type:
           </p>
-<p>
-</p>
 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Float</span><span class="special">&gt;</span>
 <span class="identifier">Float</span> <span class="identifier">JEL3</span><span class="special">(</span><span class="identifier">Float</span> <span class="identifier">v</span><span class="special">,</span> <span class="identifier">Float</span> <span class="identifier">z</span><span class="special">)</span>
 <span class="special">{</span>
@@ -117,8 +107,6 @@
 <span class="special">}</span>
 </pre>
 <p>
- </p>
-<p>
             Once again the code is almost the same as before, but the call to <code class="computeroutput"><span class="identifier">pow</span></code> has changed yet again. We need
             the call to resolve to either <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pow</span></code>
             (when the argument is a builtin type), or to <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">pow</span></code>
@@ -165,8 +153,6 @@
             from Boost.Math which calculates the return type of mixed-argument functions,
             here's how the new code looks now:
           </p>
-<p>
-</p>
 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Float1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Float2</span><span class="special">&gt;</span>
 <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tools</span><span class="special">::</span><span class="identifier">promote_args</span><span class="special">&lt;</span><span class="identifier">Float1</span><span class="special">,</span> <span class="identifier">Float2</span><span class="special">&gt;::</span><span class="identifier">type</span>
    <span class="identifier">JEL4</span><span class="special">(</span><span class="identifier">Float1</span> <span class="identifier">v</span><span class="special">,</span> <span class="identifier">Float2</span> <span class="identifier">z</span><span class="special">)</span>
@@ -176,8 +162,6 @@
 <span class="special">}</span>
 </pre>
 <p>
- </p>
-<p>
             As you can see the two arguments to the function are now separate template
             types, and the return type is computed using the <code class="computeroutput"><span class="identifier">promote_args</span></code>
             metafunction from Boost.Math.
@@ -217,7 +201,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/nd.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/nd.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/nd.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -55,8 +55,6 @@
             float. Let's make a generic template subroutine using this three-point
             central difference rule. In particular:
           </p>
-<p>
-</p>
 <pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">value_type</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">function_type</span><span class="special">&gt;</span>
    <span class="identifier">value_type</span> <span class="identifier">derivative</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">dx</span><span class="special">,</span> <span class="identifier">function_type</span> <span class="identifier">func</span><span class="special">)</span>
 <span class="special">{</span>
@@ -79,8 +77,6 @@
 <span class="special">}</span>
 </pre>
 <p>
- </p>
-<p>
             The <code class="computeroutput"><span class="identifier">derivative</span><span class="special">()</span></code>
             template function can be used to compute the first derivative of any
             function to <span class="emphasis"><em>O(dx<sup>6</sup>)</em></span>. For example, consider the first
@@ -94,8 +90,6 @@
             The code below computes the derivative in Equation 3 for float, double
             and boost's multiple-precision type cpp_dec_float_50.
           </p>
-<p>
-</p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iomanip</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_dec_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
@@ -158,8 +152,6 @@
 <span class="special">}</span>
 </pre>
 <p>
- </p>
-<p>
             The expected value of the derivative is 0.5. This central difference
             rule in this example is ill-conditioned, meaning it suffers from slight
             loss of precision. With that in mind, the results agree with the expected
@@ -174,8 +166,6 @@
             result obtained from a call to <span class="emphasis"><em>gamma_p_derivative</em></span>,
             the results agree to approximately 44 digits:
           </p>
-<p>
-</p>
 <pre class="programlisting"><span class="identifier">cpp_dec_float_50</span> <span class="identifier">gd</span> <span class="special">=</span> <span class="identifier">derivative</span><span class="special">(</span>
    <span class="identifier">cpp_dec_float_50</span><span class="special">(</span><span class="number">2</span><span class="special">),</span>
    <span class="identifier">cpp_dec_float_50</span><span class="special">(</span><span class="number">1.0E-9</span><span class="special">),</span>
@@ -192,12 +182,10 @@
 <span class="comment">// 2.70670566473225383787998989944968806815253190143120e-01</span>
 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">gamma_p_derivative</span><span class="special">(</span><span class="identifier">cpp_dec_float_50</span><span class="special">(</span><span class="number">2</span><span class="special">),</span> <span class="identifier">cpp_dec_float_50</span><span class="special">(</span><span class="number">2</span><span class="special">))</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 </pre>
-<p>
- </p>
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/poly_eg.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/poly_eg.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/poly_eg.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -38,8 +38,6 @@
             The following code evaluates <code class="computeroutput"><span class="identifier">sin</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span></code> as a polynomial, accurate to at least
             64 decimal places:
           </p>
-<p>
-</p>
 <pre class="programlisting"><span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_dec_float</span><span class="special">;</span>
 <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float</span><span class="special">&lt;</span><span class="number">64</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">mp_type</span><span class="special">;</span>
 
@@ -127,8 +125,6 @@
 <span class="special">}</span>
 </pre>
 <p>
- </p>
-<p>
             Calling the function like so:
           </p>
 <pre class="programlisting"><span class="identifier">mp_type</span> <span class="identifier">pid4</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">constants</span><span class="special">::</span><span class="identifier">pi</span><span class="special">&lt;</span><span class="identifier">mp_type</span><span class="special">&gt;()</span> <span class="special">/</span> <span class="number">4</span><span class="special">;</span>
@@ -142,7 +138,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/gmp_float.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/gmp_float.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/gmp_float.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -143,11 +143,8 @@
 </ul></div>
 <h6>
 <a name="boost_multiprecision.tut.floats.gmp_float.h0"></a>
- <span class="phrase"><a name="boost_multiprecision.tut.floats.gmp_float.__ulink_url__http___gmplib_org__gmp__ulink__example_"></a></span><a class="link" href="gmp_float.html#boost_multiprecision.tut.floats.gmp_float.__ulink_url__http___gmplib_org__gmp__ulink__example_">
- GMP example:</a>
+ <span class="phrase"><a name="boost_multiprecision.tut.floats.gmp_float.gmp_example"></a></span><a class="link" href="gmp_float.html#boost_multiprecision.tut.floats.gmp_float.gmp_example"> GMP example:</a>
         </h6>
-<p>
-</p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">gmp</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 
 <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>
@@ -173,12 +170,10 @@
 <span class="identifier">mpf_init</span><span class="special">(</span><span class="identifier">f</span><span class="special">);</span>
 <span class="identifier">mpf_set</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">a</span><span class="special">.</span><span class="identifier">backend</span><span class="special">().</span><span class="identifier">data</span><span class="special">());</span>
 </pre>
-<p>
- </p>
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/mpfr_float.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/mpfr_float.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/mpfr_float.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -226,11 +226,8 @@
 </ul></div>
 <h6>
 <a name="boost_multiprecision.tut.floats.mpfr_float.h0"></a>
- <span class="phrase"><a name="boost_multiprecision.tut.floats.mpfr_float.__ulink_url__http___www_mpfr_org__mpfr__ulink__example_"></a></span><a class="link" href="mpfr_float.html#boost_multiprecision.tut.floats.mpfr_float.__ulink_url__http___www_mpfr_org__mpfr__ulink__example_">
- MPFR example:</a>
+ <span class="phrase"><a name="boost_multiprecision.tut.floats.mpfr_float.mpfr_example"></a></span><a class="link" href="mpfr_float.html#boost_multiprecision.tut.floats.mpfr_float.mpfr_example"> MPFR example:</a>
         </h6>
-<p>
-</p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">mpfr</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 
 <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>
@@ -256,8 +253,6 @@
 <span class="identifier">mpfr_init</span><span class="special">(</span><span class="identifier">r</span><span class="special">);</span>
 <span class="identifier">mpfr_set</span><span class="special">(</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">b</span><span class="special">.</span><span class="identifier">backend</span><span class="special">().</span><span class="identifier">data</span><span class="special">(),</span> <span class="identifier">GMP_RNDN</span><span class="special">);</span>
 </pre>
-<p>
- </p>
 <div class="footnotes">
 <br><hr style="width:100; text-align:left;margin-left: 0">
 <div id="ftn.boost_multiprecision.tut.floats.mpfr_float.f0" class="footnote"><p>[2]
@@ -267,7 +262,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/gen_int.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/gen_int.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/gen_int.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -166,7 +166,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Added: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/input_output.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/input_output.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -0,0 +1,185 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Input Output</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Multiprecision">
+<link rel="up" href="../tut.html" title="Tutorial">
+<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">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="limits/how_to_tell.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../ref.html"><img src="../../../../../../doc/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>
+ <span class="phrase"><a name="boost_multiprecision.tut.input_output.loopback_testing"></a></span><a class="link" href="input_output.html#boost_multiprecision.tut.input_output.loopback_testing">Loopback
+ testing</a>
+ </h5>
+<p>
+ <span class="emphasis"><em>Loopback</em></span> or <span class="emphasis"><em>round-tripping</em></span> refers
+ to writing out a value as a decimal digit string using <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">iostream</span></code>,
+ usually to a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">stringstream</span></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"><span class="keyword">float</span></code>
+ is:
+ </p>
+<pre class="programlisting"><span class="keyword">float</span> <span class="identifier">write</span><span class="special">;</span> <span class="comment">// Value to round-trip.</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">stringstream</span> <span class="identifier">ss</span><span class="special">;</span> <span class="comment">// Read and write std::stringstream.</span>
+<span class="identifier">ss</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">);</span> <span class="comment">// Ensure all potentially significant bits are output.</span>
+<span class="identifier">ss</span><span class="special">.</span><span class="identifier">flags</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">fmtflags</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">scientific</span><span class="special">));</span> <span class="comment">// Use scientific format.</span>
+<span class="identifier">ss</span> <span class="special">&lt;&lt;</span> <span class="identifier">write</span><span class="special">;</span> <span class="comment">// Output to string.</span>
+<span class="keyword">float</span> <span class="identifier">read</span><span class="special">;</span> <span class="comment">// Expected.</span>
+<span class="identifier">ss</span> <span class="special">&gt;&gt;</span> <span class="identifier">read</span><span class="special">;</span> <span class="comment">// Read decimal digits string from stringstream.</span>
+<span class="identifier">BOOST_CHECK_EQUAL</span><span class="special">(</span><span class="identifier">write</span><span class="special">,</span> <span class="identifier">read</span><span class="special">);</span> <span class="comment">// Should be the same.</span>
+</pre>
+<p>
+ 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"><span class="identifier">T</span></code>,
+ including built-in <code class="computeroutput"><span class="keyword">double</span></code>, it
+ takes far too long to test all values, so a reasonable test strategy is to
+ use a large number of random values.
+ </p>
+<pre class="programlisting"><span class="identifier">T</span> <span class="identifier">write</span><span class="special">;</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">stringstream</span> <span class="identifier">ss</span><span class="special">;</span>
+<span class="identifier">ss</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">);</span> <span class="comment">// Ensure all potentially significant bits are output.</span>
+<span class="identifier">ss</span><span class="special">.</span><span class="identifier">flags</span><span class="special">(</span><span class="identifier">f</span><span class="special">);</span> <span class="comment">// Changed from default iostream format flags if desired.</span>
+<span class="identifier">ss</span> <span class="special">&lt;&lt;</span> <span class="identifier">write</span><span class="special">;</span> <span class="comment">// Output to stringstream.</span>
+
+<span class="identifier">T</span> <span class="identifier">read</span><span class="special">;</span>
+<span class="identifier">ss</span> <span class="special">&gt;&gt;</span> <span class="identifier">read</span><span class="special">;</span> <span class="comment">// Get read using operator&gt;&gt; from stringstream.</span>
+<span class="identifier">BOOST_CHECK_EQUAL</span><span class="special">(</span><span class="identifier">read</span><span class="special">,</span> <span class="identifier">write</span><span class="special">);</span>
+
+<span class="identifier">read</span> <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">ss</span><span class="special">.</span><span class="identifier">str</span><span class="special">());</span> <span class="comment">// Get read by converting from decimal digits string representation of write.</span>
+<span class="identifier">BOOST_CHECK_EQUAL</span><span class="special">(</span><span class="identifier">read</span><span class="special">,</span> <span class="identifier">write</span><span class="special">);</span>
+
+<span class="identifier">read</span> <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">write</span><span class="special">.</span><span class="identifier">str</span><span class="special">(</span><span class="number">0</span><span class="special">,</span> <span class="identifier">f</span><span class="special">));</span> <span class="comment">// Get read using format specified when written.</span>
+<span class="identifier">BOOST_CHECK_EQUAL</span><span class="special">(</span><span class="identifier">read</span><span class="special">,</span> <span class="identifier">write</span><span class="special">);</span>
+</pre>
+<p>
+ The test at test_cpp_bin_float_io.cpp
+ allows any floating-point type to be <span class="emphasis"><em>round_tripped</em></span> using
+ a wide range of fairly random values. It also includes tests compared a collection
+ of stringdata test cases
+ in a file.
+ </p>
+<h5>
+<a name="boost_multiprecision.tut.input_output.h1"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.input_output.comparing_with_output_using_buil"></a></span><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>
+<p>
+ One can make some comparisons with the output of
+ </p>
+<pre class="programlisting"><span class="special">&lt;</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">53</span><span class="special">,</span> <span class="identifier">digit_count_2</span><span class="special">&gt;</span> <span class="special">&gt;</span>
+</pre>
+<p>
+ which has the same number of significant bits (53) as 64-bit double precision
+ floating-point.
+ </p>
+<p>
+ 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++.
+ </p>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <span class="emphasis"><em>"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 &lt; U, both having DECIMAL_DIG significant digits; the value of the
+ resultant decimal string D should satisfy L&lt;= D &lt;= U, with the extra
+ stipulation that the error should have a correct sign for the current rounding
+ direction."</em></span>
+ </p></blockquote></div>
+<p>
+ So not only is correct rounding for the full number of digits not required,
+ but even if the <span class="bold"><strong>optional</strong></span> recomended practice
+ is followed, then the value of these last few digits is unspecified as long
+ as the value is within certain bounds.
+ </p>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/src/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+ Do not expect the output from different platforms to be <span class="bold"><strong>identical</strong></span>,
+ but <code class="computeroutput"><span class="identifier">cpp_dec_float</span></code>, <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code> (and other backends) outputs
+ should be correctly rounded to the number of digits requested by the set
+ precision and format.
+ </p></td></tr>
+</table></div>
+<h5>
+<a name="boost_multiprecision.tut.input_output.h2"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.input_output.macro_boost_mp_min_exponent_digi"></a></span><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>
+<p>
+ <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:
+ </p>
+<p>
+ "The exponent always contains at least two digits, and only as many
+ more digits as necessary to represent the exponent."
+ </p>
+<p>
+ So to conform to the C99 standard (incorporated by C++)
+ </p>
+<pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">BOOST_MP_MIN_EXPONENT_DIGITS</span> <span class="number">2</span>
+</pre>
+<p>
+ Confusingly, Microsoft (and MinGW) do not conform to this standard and provide
+ <span class="bold"><strong>at least three digits</strong></span>, for example <code class="computeroutput"><span class="number">1e+001</span></code>. So if you want the output to match
+ that from built-in floating-point types on compilers that use Microsofts
+ runtime then use:
+ </p>
+<pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">BOOST_MP_MIN_EXPONENT_DIGITS</span> <span class="number">3</span>
+</pre>
+<p>
+ Also useful to get the minimum exponent field width is
+ </p>
+<pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">BOOST_MP_MIN_EXPONENT_DIGITS</span> <span class="number">1</span>
+</pre>
+<p>
+ producing a compact output like <code class="computeroutput"><span class="number">2e+4</span></code>,
+ useful when conserving space is important.
+ </p>
+<p>
+ Larger values are also supported, for example, value 4 for <code class="computeroutput"><span class="number">2e+0004</span></code> which may be useful to ensure that
+ columns line up.
+ </p>
+</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 &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
+ 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)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="limits/how_to_tell.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/interval.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/interval.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/interval.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -33,7 +33,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/interval/mpfi.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/interval/mpfi.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/interval/mpfi.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -158,8 +158,8 @@
         </p>
 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
 <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span> <span class="identifier">intersect</span><span class="special">(</span>
- <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span>
- <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">b</span><span class="special">);</span>
+ <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span>
+ <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">b</span><span class="special">);</span>
 </pre>
 <p>
           Returns the interval which is the intersection of the <span class="emphasis"><em>a</em></span>
@@ -168,8 +168,8 @@
         </p>
 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
 <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span> <span class="identifier">hull</span><span class="special">(</span>
- <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span>
- <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">b</span><span class="special">);</span>
+ <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span>
+ <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">b</span><span class="special">);</span>
 </pre>
 <p>
           Returns the interval which is the union of <span class="emphasis"><em>a</em></span> and
@@ -231,12 +231,9 @@
         </p>
 <h6>
 <a name="boost_multiprecision.tut.interval.mpfi.h0"></a>
- <span class="phrase"><a name="boost_multiprecision.tut.interval.mpfi.__ulink_url__http___perso_ens_lyon_fr_nathalie_revol_software_html__mpfi__ulink__example_"></a></span><a class="link" href="mpfi.html#boost_multiprecision.tut.interval.mpfi.__ulink_url__http___perso_ens_lyon_fr_nathalie_revol_software_html__mpfi__ulink__example_">
- MPFI
+ <span class="phrase"><a name="boost_multiprecision.tut.interval.mpfi.mpfi_example"></a></span><a class="link" href="mpfi.html#boost_multiprecision.tut.interval.mpfi.mpfi_example"> MPFI
           example:</a>
         </h6>
-<p>
-</p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">mpfi</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 
 <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>
@@ -265,12 +262,10 @@
 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">overlap</span><span class="special">(</span><span class="identifier">i1</span><span class="special">,</span> <span class="identifier">i2</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">subset</span><span class="special">(</span><span class="identifier">i1</span><span class="special">,</span> <span class="identifier">i2</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 </pre>
-<p>
- </p>
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -186,7 +186,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/cpp_int.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/cpp_int.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/cpp_int.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -341,10 +341,8 @@
 </ul></div>
 <h6>
 <a name="boost_multiprecision.tut.ints.cpp_int.h0"></a>
- <span class="phrase"><a name="boost_multiprecision.tut.ints.cpp_int.example_"></a></span><a class="link" href="cpp_int.html#boost_multiprecision.tut.ints.cpp_int.example_">Example:</a>
+ <span class="phrase"><a name="boost_multiprecision.tut.ints.cpp_int.example"></a></span><a class="link" href="cpp_int.html#boost_multiprecision.tut.ints.cpp_int.example">Example:</a>
         </h6>
-<p>
-</p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_int</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 
 <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>
@@ -364,12 +362,10 @@
 
 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">u</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// prints 100!</span>
 </pre>
-<p>
- </p>
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/egs.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/egs.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/egs.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -33,7 +33,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/egs/bitops.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/egs/bitops.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/egs/bitops.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -31,8 +31,6 @@
             be manipulated, we'll start with an often needed calculation of <span class="emphasis"><em>2<sup>n</sup> -
             1</em></span>, which we could obviously implement like this:
           </p>
-<p>
-</p>
 <pre class="programlisting"><span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_int</span><span class="special">;</span>
 
 <span class="identifier">cpp_int</span> <span class="identifier">b1</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">)</span>
@@ -42,8 +40,6 @@
 <span class="special">}</span>
 </pre>
 <p>
- </p>
-<p>
             Calling:
           </p>
 <pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hex</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">showbase</span> <span class="special">&lt;&lt;</span> <span class="identifier">b1</span><span class="special">(</span><span class="number">200</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
@@ -55,8 +51,6 @@
 <p>
             However, we could equally just set the n'th bit in the result, like this:
           </p>
-<p>
-</p>
 <pre class="programlisting"><span class="identifier">cpp_int</span> <span class="identifier">b2</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">)</span>
 <span class="special">{</span>
    <span class="identifier">cpp_int</span> <span class="identifier">r</span><span class="special">(</span><span class="number">0</span><span class="special">);</span>
@@ -64,8 +58,6 @@
 <span class="special">}</span>
 </pre>
 <p>
- </p>
-<p>
             Note how the <code class="computeroutput"><span class="identifier">bit_set</span></code>
             function sets the specified bit in its argument and then returns a reference
             to the result - which we can then simply decrement. The result from a
@@ -89,7 +81,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/egs/factorials.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/egs/factorials.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/egs/factorials.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -31,8 +31,6 @@
             factorials which will fit into a 128-bit integer. At the end of the routine
             we do some fancy iostream formatting of the results:
           </p>
-<p>
-</p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_int</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iomanip</span><span class="special">&gt;</span>
@@ -94,8 +92,6 @@
 <span class="special">}</span>
 </pre>
 <p>
- </p>
-<p>
             The output from this routine is:
           </p>
 <a name="fix%20for%20quickbook%20bug"></a><pre class="programlisting">
@@ -140,7 +136,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/gmp_int.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/gmp_int.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/gmp_int.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -106,10 +106,8 @@
 </ul></div>
 <h6>
 <a name="boost_multiprecision.tut.ints.gmp_int.h0"></a>
- <span class="phrase"><a name="boost_multiprecision.tut.ints.gmp_int.example_"></a></span><a class="link" href="gmp_int.html#boost_multiprecision.tut.ints.gmp_int.example_">Example:</a>
+ <span class="phrase"><a name="boost_multiprecision.tut.ints.gmp_int.example"></a></span><a class="link" href="gmp_int.html#boost_multiprecision.tut.ints.gmp_int.example">Example:</a>
         </h6>
-<p>
-</p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">gmp</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 
 <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>
@@ -127,12 +125,10 @@
 <span class="identifier">mpz_init</span><span class="special">(</span><span class="identifier">z</span><span class="special">);</span>
 <span class="identifier">mpz_set</span><span class="special">(</span><span class="identifier">z</span><span class="special">,</span> <span class="identifier">v</span><span class="special">.</span><span class="identifier">backend</span><span class="special">().</span><span class="identifier">data</span><span class="special">());</span>
 </pre>
-<p>
- </p>
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/tom_int.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/tom_int.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/tom_int.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -80,10 +80,8 @@
 </ul></div>
 <h6>
 <a name="boost_multiprecision.tut.ints.tom_int.h0"></a>
- <span class="phrase"><a name="boost_multiprecision.tut.ints.tom_int.example_"></a></span><a class="link" href="tom_int.html#boost_multiprecision.tut.ints.tom_int.example_">Example:</a>
+ <span class="phrase"><a name="boost_multiprecision.tut.ints.tom_int.example"></a></span><a class="link" href="tom_int.html#boost_multiprecision.tut.ints.tom_int.example">Example:</a>
         </h6>
-<p>
-</p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">tommath</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 
 <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">tom_int</span> <span class="identifier">v</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span>
@@ -113,12 +111,10 @@
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">e</span><span class="special">.</span><span class="identifier">what</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-<p>
- </p>
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Added: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/limits.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/limits.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -0,0 +1,100 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Numeric Limits</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Multiprecision">
+<link rel="up" href="../tut.html" title="Tutorial">
+<link rel="prev" href="serial.html" title="Boost.Serialization Support">
+<link rel="next" href="limits/constants.html" title="std::numeric_limits&lt;&gt; constants">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="serial.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="limits/constants.html"><img src="../../../../../../doc/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><span class="section"><a href="limits/constants.html">std::numeric_limits&lt;&gt;
+ constants</a></span></dt>
+<dt><span class="section"><a href="limits/functions.html">std::numeric_limits&lt;&gt;
+ functions</a></span></dt>
+<dt><span class="section"><a href="limits/limits32.html">Numeric limits
+ for 32-bit platform</a></span></dt>
+<dt><span class="section"><a href="limits/how_to_tell.html">How to
+ Determine the Kind of a Number From <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code></a></span></dt>
+</dl></div>
+<p>
+ Boost.Multiprecision tries hard to implement <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code>
+ for all types as far as possible and meaningful because experience with Boost.Math
+ has shown that this aids portability.
+ </p>
+<p>
+ The <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3690.pdf" target="_top">C++
+ standard library</a> defines <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code>
+ in section 18.3.2.
+ </p>
+<p>
+ This in turn refers to the C standard <a href="http://www.open-std.org/jtc1/sc22/wg11/docs/n507.pdf" target="_top">SC22/WG11
+ N507 DRAFT INTERNATIONAL ISO/IEC STANDARD WD 10967-1</a> Information
+ technology Language independent arithmetic Part 1: Integer and Floating point
+ arithmetic.
+ </p>
+<p>
+ That C Standard in turn refers to
+ </p>
+<p>
+ <a href="http://754r.ucbtest.org/standards/754.pdf" target="_top">IEEE754 IEEE Standard
+ for Binary Floating-Point Arithmetic</a>
+ </p>
+<p>
+ There is a useful summary at <a href="http://www.cplusplus.com/reference/limits/numeric_limits/" target="_top">C++
+ reference</a>.
+ </p>
+<p>
+ The chosen backend often determines how completely <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code>
+ is available.
+ </p>
+<p>
+ Compiler options, processor type, and definition of macros or assembler instructions
+ to control denormal numbers will alter the values in the tables given below.
+ </p>
+<div class="warning"><table border="0" summary="Warning">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../../../../doc/src/images/warning.png"></td>
+<th align="left">Warning</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+ GMP's <code class="computeroutput"><span class="identifier">mpf_t</span></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).
+ </p></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>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
+ 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)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="serial.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="limits/constants.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/constants.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/constants.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -0,0 +1,705 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>std::numeric_limits&lt;&gt; constants</title>
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../index.html" title="Chapter&#160;1.&#160;Boost.Multiprecision">
+<link rel="up" href="../limits.html" title="Numeric Limits">
+<link rel="prev" href="../limits.html" title="Numeric Limits">
+<link rel="next" href="functions.html" title="std::numeric_limits&lt;&gt; functions">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../limits.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../limits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="functions.html"><img src="../../../../../../../doc/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.constants"></a><a class="link" href="constants.html" title="std::numeric_limits&lt;&gt; constants">std::numeric_limits&lt;&gt;
+ constants</a>
+</h4></div></div></div>
+<h5>
+<a name="boost_multiprecision.tut.limits.constants.h0"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.is_specialized"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.is_specialized">is_specialized</a>
+ </h5>
+<p>
+ <code class="computeroutput"><span class="keyword">true</span></code> for all arithmetic types
+ (integer, floating and fixed-point) for which <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">numeric_limits</span></code>
+ is specialized.
+ </p>
+<p>
+ A typical test is
+ </p>
+<pre class="programlisting"><span class="keyword">if</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_specialized</span> <span class="special">==</span> <span class="keyword">false</span><span class="special">)</span>
+<span class="special">{</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"type "</span> <span class="special">&lt;&lt;</span> <span class="keyword">typeid</span><span class="special">(</span><span class="identifier">T</span><span class="special">).</span><span class="identifier">name</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">" is not specialized for std::numeric_limits!"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="comment">// ...</span>
+<span class="special">}</span>
+</pre>
+<p>
+ Typically <code class="computeroutput"><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_specialized</span></code>
+ is <code class="computeroutput"><span class="keyword">true</span></code> for all <code class="computeroutput"><span class="identifier">T</span></code> where the compile-time constant members
+ of <code class="computeroutput"><span class="identifier">numeric_limits</span></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"><span class="identifier">mpfr_float</span></code>
+ have no <code class="computeroutput"><span class="identifier">numeric_limits</span></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"><span class="identifier">mpfr_float_50</span></code>
+ is known at compile time, and so it <span class="emphasis"><em>does</em></span> have a <code class="computeroutput"><span class="identifier">numeric_limits</span></code> specialization.
+ </p>
+<p>
+ Note that not all the <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></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.
+ </p>
+<h5>
+<a name="boost_multiprecision.tut.limits.constants.h1"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.infinity"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.infinity">infinity</a>
+ </h5>
+<p>
+ For floating-point types, &#8734; is defined wherever possible, but clearly infinity
+ is meaningless for __arbitrary_precision arithmetic backends, and there
+ is one floating point type (GMP's <code class="computeroutput"><span class="identifier">mpf_t</span></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.
+ </p>
+<p>
+ A typical test whether infinity is implemented is
+ </p>
+<pre class="programlisting"><span class="keyword">if</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">has_infinity</span><span class="special">)</span>
+<span class="special">{</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">infinity</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+<p>
+ and using tests like this is strongly recommended to improve portability.
+ </p>
+<p>
+ If the backend is switched to a type that does not support infinity then,
+ without checks like this, there will be trouble.
+ </p>
+<h5>
+<a name="boost_multiprecision.tut.limits.constants.h2"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.is_signed"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.is_signed">is_signed</a>
+ </h5>
+<p>
+ <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_signed</span> <span class="special">==</span>
+ <span class="keyword">true</span></code> if the type <code class="computeroutput"><span class="identifier">T</span></code>
+ is signed.
+ </p>
+<p>
+ 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"><span class="keyword">bool</span></code>.
+ </p>
+<h5>
+<a name="boost_multiprecision.tut.limits.constants.h3"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.is_exact"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.is_exact">is_exact</a>
+ </h5>
+<p>
+ <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_exact</span> <span class="special">==</span>
+ <span class="keyword">true</span></code> if type T uses exact representations.
+ </p>
+<p>
+ This is defined as <code class="computeroutput"><span class="keyword">true</span></code> for
+ all integer types and <code class="computeroutput"><span class="keyword">false</span></code>
+ for floating-point types.
+ </p>
+<p>
+ <a href="http://stackoverflow.com/questions/14203654/stdnumeric-limitsis-exact-what-is-a-usable-definition" target="_top">A
+ usable definition</a> has been discussed.
+ </p>
+<p>
+ ISO/IEC 10967-1, Language independent arithmetic, noted by the C++ Standard
+ defines
+ </p>
+<pre class="programlisting"><span class="identifier">A</span> <span class="identifier">floating</span> <span class="identifier">point</span> <span class="identifier">type</span> <span class="identifier">F</span> <span class="identifier">shall</span> <span class="identifier">be</span> <span class="identifier">a</span> <span class="identifier">finite</span> <span class="identifier">subset</span> <span class="identifier">of</span> <span class="special">[</span><span class="identifier">real</span><span class="special">].</span>
+</pre>
+<p>
+ The important practical distinction is that all integers (up to <code class="computeroutput"><span class="identifier">max</span><span class="special">()</span></code>)
+ can be stored exactly.
+ </p>
+<p>
+ Rational
+ types using two integer types are also exact.
+ </p>
+<p>
+ Floating-point types <span class="bold"><strong>cannot store all real values</strong></span>
+ (those in the set of &#8476;) <span class="bold"><strong>exactly</strong></span>. 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.
+ </p>
+<p>
+ Fixed-point types (usually decimal) are also defined as exact, in that
+ they only store a <span class="bold"><strong>fixed precision</strong></span>, 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.
+ </p>
+<p>
+ 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>.
+ </p>
+<p>
+ <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2849.pdf" target="_top">Decimal
+ TR</a>.
+ </p>
+<p>
+ 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>.
+ </p>
+<h5>
+<a name="boost_multiprecision.tut.limits.constants.h4"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.is_bounded"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.is_bounded">is_bounded</a>
+ </h5>
+<p>
+ <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_bounded</span> <span class="special">==</span>
+ <span class="keyword">true</span></code> if the set of values represented
+ by the type <code class="computeroutput"><span class="identifier">T</span></code> is finite.
+ </p>
+<p>
+ This is <code class="computeroutput"><span class="keyword">true</span></code> for all built-in
+ integer, fixed and floating-point types, and most multi-precision types.
+ </p>
+<p>
+ It is only <code class="computeroutput"><span class="keyword">false</span></code> for a few
+ __arbitrary_precision types like <code class="computeroutput"><span class="identifier">cpp_int</span></code>.
+ </p>
+<p>
+ Rational and fixed-exponent representations are exact but not integer.
+ </p>
+<h5>
+<a name="boost_multiprecision.tut.limits.constants.h5"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.is_modulo"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.is_modulo">is_modulo</a>
+ </h5>
+<p>
+ <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_modulo</span></code> is defined as <code class="computeroutput"><span class="keyword">true</span></code> if adding two positive values of type
+ T can yield a result less than either value.
+ </p>
+<p>
+ <code class="computeroutput"><span class="identifier">is_modulo</span> <span class="special">==</span>
+ <span class="keyword">true</span></code> means that the type does not
+ overflow, but, for example, 'wraps around' to zero, when adding one to
+ the <code class="computeroutput"><span class="identifier">max</span><span class="special">()</span></code>
+ value.
+ </p>
+<p>
+ For most built-in integer types, <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;&gt;::</span><span class="identifier">is_modulo</span></code>
+ is <code class="computeroutput"><span class="keyword">true</span></code>.
+ </p>
+<p>
+ <code class="computeroutput"><span class="keyword">bool</span></code> is the only exception.
+ </p>
+<p>
+ The modulo behaviour is sometimes useful, but also can be unexpected, and
+ sometimes undesired, behaviour.
+ </p>
+<p>
+ Overflow of signed integers can be especially unexpected, possibly causing
+ change of sign.
+ </p>
+<p>
+ Boost.Multiprecision integer type <code class="computeroutput"><span class="identifier">cpp_int</span></code>
+ is not modulo because as an __arbitrary_precision types, it expands to
+ hold any value that the machine resources permit.
+ </p>
+<p>
+ 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).
+ </p>
+<p>
+ Built-in and multi-precision floating-point types are normally not modulo.
+ </p>
+<p>
+ Where possible, overflow is to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;&gt;::</span><span class="identifier">infinity</span><span class="special">()</span></code>, provided <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;&gt;::</span><span class="identifier">has_infinity</span>
+ <span class="special">==</span> <span class="keyword">true</span></code>.
+ </p>
+<h5>
+<a name="boost_multiprecision.tut.limits.constants.h6"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.radix"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.radix">radix</a>
+ </h5>
+<p>
+ Constant <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">radix</span></code> returns either 2 (for built-in
+ and binary types) or 10 (for decimal types).
+ </p>
+<h5>
+<a name="boost_multiprecision.tut.limits.constants.h7"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.digits"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.digits">digits</a>
+ </h5>
+<p>
+ The number of <code class="computeroutput"><span class="identifier">radix</span></code> digits
+ that be represented without change:
+ </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+ for integer types, the number of <span class="bold"><strong>non-sign bits</strong></span>
+ in the significand.
+ </li>
+<li class="listitem">
+ for floating types, the number of <span class="bold"><strong>radix digits</strong></span>
+ in the significand.
+ </li>
+</ul></div>
+<p>
+ The values include any implicit bit, so for example, for the ubiquious
+ <code class="computeroutput"><span class="keyword">double</span></code> using 64 bits (<a href="http://en.wikipedia.org/wiki/Double_precision_floating-point_format" target="_top">IEEE
+ binary64 </a>), <code class="computeroutput"><span class="identifier">digits</span></code>
+ == 53, even though there are only 52 actual bits of the significand stored
+ in the representation. The value of <code class="computeroutput"><span class="identifier">digits</span></code>
+ reflects the fact that there is one implicit bit which is always set to
+ 1.
+ </p>
+<p>
+ The Boost.Multiprecision binary types do not use an implicit bit, so the
+ <code class="computeroutput"><span class="identifier">digits</span></code> member reflects
+ exactly how many bits of precision were requested:
+ </p>
+<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">53</span><span class="special">,</span> <span class="identifier">digit_base_2</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">float64</span><span class="special">;</span>
+<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">113</span><span class="special">,</span> <span class="identifier">digit_base_2</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">float128</span><span class="special">;</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">float64</span><span class="special">&gt;::</span><span class="identifier">digits</span> <span class="special">==</span> <span class="number">53.</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">float128</span><span class="special">&gt;::</span><span class="identifier">digits</span> <span class="special">==</span> <span class="number">113.</span>
+</pre>
+<p>
+ For the most common case of <code class="computeroutput"><span class="identifier">radix</span>
+ <span class="special">==</span> <span class="number">2</span></code>,
+ <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">digits</span></code> is the number of bits in the representation,
+ not counting any sign bit.
+ </p>
+<p>
+ For a decimal integer type, when <code class="computeroutput"><span class="identifier">radix</span>
+ <span class="special">==</span> <span class="number">10</span></code>,
+ it is the number of decimal digits.
+ </p>
+<h5>
+<a name="boost_multiprecision.tut.limits.constants.h8"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.digits10"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.digits10">digits10</a>
+ </h5>
+<p>
+ Constant <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">digits10</span></code> returns the number of decimal
+ digits that can be represented without change or loss.
+ </p>
+<p>
+ For example, <code class="computeroutput"><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="keyword">char</span><span class="special">&gt;::</span><span class="identifier">digits10</span></code> is 2.
+ </p>
+<p>
+ This somewhat inscrutable definition means that an <code class="computeroutput"><span class="keyword">unsigned</span>
+ <span class="keyword">char</span></code> can hold decimal values <code class="computeroutput"><span class="number">0.</span><span class="special">.</span><span class="number">99</span></code>
+ without loss of precision or accuracy, usually from truncation.
+ </p>
+<p>
+ Had the definition been 3 then that would imply it could hold 0..999, but
+ as we all know, an 8-bit <code class="computeroutput"><span class="keyword">unsigned</span>
+ <span class="keyword">char</span></code> can only hold 0..255, and an
+ attempt to store 256 or more will involve loss or change.
+ </p>
+<p>
+ For bounded integers, it is thus <span class="bold"><strong>one less</strong></span>
+ than number of decimal digits you need to display the biggest integer
+ <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">()</span></code>.
+ This value can be used to predict the layout width required for
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span>
+ <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setw</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">short</span><span class="special">&gt;::</span><span class="identifier">digits10</span> <span class="special">+</span><span class="number">1</span> <span class="special">+</span><span class="number">1</span><span class="special">)</span> <span class="comment">// digits10+1, and +1 for sign.</span>
+ <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">showpos</span> <span class="special">&lt;&lt;</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">short</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">)()</span> <span class="comment">// +32767</span>
+ <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span>
+ <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setw</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">short</span><span class="special">&gt;::</span><span class="identifier">digits10</span> <span class="special">+</span><span class="number">1</span> <span class="special">+</span><span class="number">1</span><span class="special">)</span>
+ <span class="special">&lt;&lt;</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">short</span><span class="special">&gt;::</span><span class="identifier">min</span><span class="special">)()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// -32767</span>
+</pre>
+<p>
+ For example, <code class="computeroutput"><span class="keyword">unsigned</span> <span class="keyword">short</span></code>
+ is often stored in 16 bits, so the maximum value is 0xFFFF or 65535.
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span>
+ <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setw</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="keyword">short</span><span class="special">&gt;::</span><span class="identifier">digits10</span> <span class="special">+</span><span class="number">1</span> <span class="special">+</span><span class="number">1</span><span class="special">)</span> <span class="comment">// digits10+1, and +1 for sign.</span>
+ <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">showpos</span> <span class="special">&lt;&lt;</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="keyword">short</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">)()</span> <span class="comment">// 65535</span>
+ <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span>
+ <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setw</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="keyword">short</span><span class="special">&gt;::</span><span class="identifier">digits10</span> <span class="special">+</span><span class="number">1</span> <span class="special">+</span><span class="number">1</span><span class="special">)</span> <span class="comment">// digits10+1, and +1 for sign.</span>
+ <span class="special">&lt;&lt;</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="keyword">short</span><span class="special">&gt;::</span><span class="identifier">min</span><span class="special">)()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// 0</span>
+</pre>
+<p>
+ For bounded floating-point types, if we create a <code class="computeroutput"><span class="keyword">double</span></code>
+ with a value with <code class="computeroutput"><span class="identifier">digits10</span></code>
+ (usually 15) decimal digits, <code class="computeroutput"><span class="number">1e15</span></code>
+ or <code class="computeroutput"><span class="number">1000000000000000</span></code> :
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">);</span>
+<span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span> <span class="number">1e15</span><span class="special">;</span>
+<span class="keyword">double</span> <span class="identifier">dp1</span> <span class="special">=</span> <span class="identifier">d</span><span class="special">+</span><span class="number">1</span><span class="special">;</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">d</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span> <span class="special">&lt;&lt;</span> <span class="identifier">dp1</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="comment">// 1000000000000000</span>
+<span class="comment">// 1000000000000001</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">dp1</span> <span class="special">-</span> <span class="identifier">d</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// 1</span>
+</pre>
+<p>
+ and we can increment this value to <code class="computeroutput"><span class="number">1000000000000001</span></code>
+ as expected and show the difference too.
+ </p>
+<p>
+ But if we try to repeat this with more than <code class="computeroutput"><span class="identifier">digits10</span></code>
+ digits,
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">);</span>
+<span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span> <span class="number">1e16</span><span class="special">;</span>
+<span class="keyword">double</span> <span class="identifier">dp1</span> <span class="special">=</span> <span class="identifier">d</span><span class="special">+</span><span class="number">1</span><span class="special">;</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">d</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span> <span class="special">&lt;&lt;</span> <span class="identifier">dp1</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="comment">// 10000000000000000</span>
+<span class="comment">// 10000000000000000</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">dp1</span> <span class="special">-</span> <span class="identifier">d</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// 0 !!!</span>
+</pre>
+<p>
+ 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>.
+ </p>
+<p>
+ So <code class="computeroutput"><span class="identifier">digits10</span></code> is the number
+ of decimal digits <span class="bold"><strong>guaranteed</strong></span> to be correct.
+ </p>
+<p>
+ For example, 'round-tripping' for <code class="computeroutput"><span class="keyword">double</span></code>:
+ </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+ If a decimal string with at most <code class="computeroutput"><span class="identifier">digits10</span></code>(
+ == 15) significant decimal digits is converted to <code class="computeroutput"><span class="keyword">double</span></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"><span class="keyword">double</span></code> floating-point
+ number is converted to a decimal string with at least 17 decimal digits
+ and then converted back to <code class="computeroutput"><span class="keyword">double</span></code>,
+ then the result will be binary indentical to the original <code class="computeroutput"><span class="keyword">double</span></code> value.
+ </li>
+</ul></div>
+<p>
+ For most purposes, you will much more likely want <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;&gt;::</span><span class="identifier">max_digits10</span></code>,
+ the number of decimal digits that ensure that a change of one least significant
+ bit (ULP) produces a different decimal digits string.
+ </p>
+<p>
+ For nearly all floating-point types, <code class="computeroutput"><span class="identifier">max_digits10</span></code>
+ is <code class="computeroutput"><span class="identifier">digits10</span><span class="special">+</span><span class="number">2</span></code>, but you should use <code class="computeroutput"><span class="identifier">max_digits10</span></code>
+ where possible.
+ </p>
+<p>
+ If <code class="computeroutput"><span class="identifier">max_digits10</span></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>
+ </p>
+<pre class="programlisting"><span class="identifier">max_digits10</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">digits</span> <span class="special">*</span> <span class="number">3010U</span><span class="special">/</span><span class="number">10000U</span><span class="special">;</span>
+</pre>
+<p>
+ The factor is log<sub>10</sub>(2) = 0.3010 but must be evaluated at compile time using
+ only integers.
+ </p>
+<p>
+ (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.).
+ </p>
+<p>
+ 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"><span class="identifier">os</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">)</span></code>.
+ For at least one popular compiler, you must also use <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">scientific</span></code>
+ format.
+ </p>
+<h5>
+<a name="boost_multiprecision.tut.limits.constants.h9"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.max_digits10"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.max_digits10">max_digits10</a>
+ </h5>
+<p>
+ <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span></code> was added for floating-point
+ because <code class="computeroutput"><span class="identifier">digits10</span></code> decimal
+ digits are insufficient to show a least significant bit (ULP) change giving
+ puzzling displays like
+ </p>
+<pre class="programlisting"><span class="number">0.666666666666667</span> <span class="special">!=</span> <span class="number">0.666666666666667</span>
+</pre>
+<p>
+ from failure to 'round-trip', for example:
+ </p>
+<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">write</span> <span class="special">=</span> <span class="number">2.</span><span class="special">/</span><span class="number">3</span><span class="special">;</span> <span class="comment">// Any arbitrary value that cannot be represented exactly.</span>
+<span class="keyword">double</span> <span class="identifier">read</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">stringstream</span> <span class="identifier">s</span><span class="special">;</span>
+<span class="identifier">s</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">);</span> <span class="comment">// or `float64_t` for 64-bit IEE754 double.</span>
+<span class="identifier">s</span> <span class="special">&lt;&lt;</span> <span class="identifier">write</span><span class="special">;</span>
+<span class="identifier">s</span> <span class="special">&gt;&gt;</span> <span class="identifier">read</span><span class="special">;</span>
+<span class="keyword">if</span><span class="special">(</span><span class="identifier">read</span> <span class="special">!=</span> <span class="identifier">write</span><span class="special">)</span>
+<span class="special">{</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">)</span>
+ <span class="special">&lt;&lt;</span> <span class="identifier">read</span> <span class="special">&lt;&lt;</span> <span class="string">" != "</span> <span class="special">&lt;&lt;</span> <span class="identifier">write</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+<p>
+ If you wish to ensure that a change of one least significant bit (ULP)
+ produces a different decimal digits string, then <code class="computeroutput"><span class="identifier">max_digits10</span></code>
+ is the precision to use.
+ </p>
+<p>
+ For example:
+ </p>
+<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">pi</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">double_constants</span><span class="special">::</span><span class="identifier">pi</span><span class="special">;</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">pi</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// 3.1415926535897931</span>
+</pre>
+<p>
+ will display &#960; to the maximum possible precision using a <code class="computeroutput"><span class="keyword">double</span></code>.
+ </p>
+<p>
+ and similarly for a much higher precision type:
+ </p>
+<pre class="programlisting"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>
+
+<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">cpp_dec_float_50</span><span class="special">;</span> <span class="comment">// 50 decimal digits.</span>
+
+<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_dec_float_50</span><span class="special">;</span>
+
+<span class="identifier">cpp_dec_float_50</span> <span class="identifier">pi</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">constants</span><span class="special">::</span><span class="identifier">pi</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_50</span><span class="special">&gt;();</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_50</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">pi</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="comment">// 3.141592653589793238462643383279502884197169399375105820974944592307816406</span>
+</pre>
+<p>
+ For integer types, <code class="computeroutput"><span class="identifier">max_digits10</span></code>
+ is implementation-dependant, but is usually <code class="computeroutput"><span class="identifier">digits10</span>
+ <span class="special">+</span> <span class="number">2</span></code>.
+ This is the output field width required for the maximum value of the type
+ T <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">()</span></code>
+ including a sign and a space.
+ </p>
+<p>
+ So this will produce neat columns.
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setw</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">)</span> <span class="special">...</span>
+</pre>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+ For Microsoft Visual Studio 2010, <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span></code>
+ is wrongly defined as 8. It should be 9.
+ </p></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="../../../../../../../doc/src/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+<p>
+ 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.
+ </p>
+<p>
+ A workaround is using scientific or exponential format <code class="computeroutput"><span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">scientific</span></code>.
+ </p>
+</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="../../../../../../../doc/src/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+ BOOST_NO_CXX11_NUMERIC_LIMITS is a suitable feature-test macro to determine
+ if <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span></code> is implemented on any
+ platform. If <code class="computeroutput"><span class="identifier">max_digits10</span></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.
+ </p></td></tr>
+</table></div>
+<p>
+ For example, to be portable, including older platforms:
+ </p>
+<pre class="programlisting"> <span class="keyword">typedef</span> <span class="keyword">float</span> <span class="identifier">T</span><span class="special">;</span> <span class="comment">// Any type: `double`, cpp_dec_float_50, bin_128bit_double_type ...</span>
+
+<span class="preprocessor">#if</span> <span class="identifier">defined</span><span class="special">(</span><span class="identifier">BOOST_NO_CXX11_NUMERIC_LIMITS</span><span class="special">)</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="number">2</span> <span class="special">+</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">digits</span> <span class="special">*</span> <span class="number">3010U</span><span class="special">/</span><span class="number">10000U</span><span class="special">);</span>
+<span class="preprocessor">#else</span>
+<span class="preprocessor"># if</span> <span class="special">(</span><span class="identifier">_MSC_VER</span> <span class="special">&lt;=</span> <span class="number">1600</span><span class="special">)</span> <span class="comment">// Correct wrong value for float.</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="number">2</span> <span class="special">+</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">digits</span> <span class="special">*</span> <span class="number">3010U</span><span class="special">/</span><span class="number">10000U</span><span class="special">);</span>
+<span class="preprocessor"># else</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">);</span>
+<span class="preprocessor"># endif</span>
+<span class="preprocessor">#endif</span>
+
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"std::cout.precision = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+
+ <span class="keyword">double</span> <span class="identifier">x</span> <span class="special">=</span> <span class="number">1.2345678901234567889</span><span class="special">;</span>
+
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"x = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">x</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">//</span>
+</pre>
+<p>
+ which should output:
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span> <span class="special">=</span> <span class="number">9</span>
+<span class="identifier">x</span> <span class="special">=</span> <span class="number">1.23456789</span>
+</pre>
+<h5>
+<a name="boost_multiprecision.tut.limits.constants.h10"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.round_style"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.round_style">round_style</a>
+ </h5>
+<p>
+ The rounding style determines how the result of floating-point operations
+ is treated when the result cannot be <span class="bold"><strong>exactly represented</strong></span>
+ in the significand. Various rounding modes may be provided:
+ </p>
+<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>
+<p>
+ For integer types, <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">round_style</span></code>
+ is always towards zero, so
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">round_style</span> <span class="special">==</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">round_to_zero</span><span class="special">;</span>
+</pre>
+<p>
+ A decimal type, <code class="computeroutput"><span class="identifier">cpp_dec_float</span></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.
+ </p>
+<p>
+ For floating-point types, it is normal to round to nearest.
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">round_style</span> <span class="special">==</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">round_to_nearest</span><span class="special">;</span>
+</pre>
+<p>
+ See function <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">round_error</span></code> for the maximum error (in
+ ULP) that rounding can cause.
+ </p>
+<h5>
+<a name="boost_multiprecision.tut.limits.constants.h11"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.has_denorm_loss"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.has_denorm_loss">has_denorm_loss</a>
+ </h5>
+<p>
+ <code class="computeroutput"><span class="keyword">true</span></code> if a loss of precision
+ is detected as a denormalization
+ loss, rather than an inexact result.
+ </p>
+<p>
+ Always <code class="computeroutput"><span class="keyword">false</span></code> for integer types.
+ </p>
+<p>
+ <code class="computeroutput"><span class="keyword">false</span></code> for all types which
+ do not have <code class="computeroutput"><span class="identifier">has_denorm</span></code>
+ == <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">denorm_present</span></code>.
+ </p>
+<h5>
+<a name="boost_multiprecision.tut.limits.constants.h12"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.denorm_style"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.denorm_style">denorm_style</a>
+ </h5>
+<p>
+ <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"><span class="keyword">double</span></code>.
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">denorm_min</span><span class="special">()</span> <span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">min</span><span class="special">()</span>
+</pre>
+<p>
+ A type may have any of the following <code class="computeroutput"><span class="keyword">enum</span>
+ <span class="identifier">float_denorm_style</span></code> values:
+ </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+ <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">denorm_absent</span></code>, if it does not allow
+ denormalized values. (Always used for all integer and exact types).
+ </li>
+<li class="listitem">
+ <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">denorm_present</span></code>, if the floating-point
+ type allows denormalized values.
+ </li>
+<li class="listitem">
+ <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">denorm_indeterminate</span></code>, if indeterminate
+ at compile time.
+ </li>
+</ul></div>
+<h5>
+<a name="boost_multiprecision.tut.limits.constants.h13"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.tinyness_before_rounding"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.tinyness_before_rounding">Tinyness
+ before rounding</a>
+ </h5>
+<p>
+ <code class="computeroutput"><span class="keyword">bool</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">tinyness_before</span></code>
+ </p>
+<p>
+ <code class="computeroutput"><span class="keyword">true</span></code> if a type can determine
+ that a value is too small to be represent as a normalized value before
+ rounding it.
+ </p>
+<p>
+ Generally true for <code class="computeroutput"><span class="identifier">is_iec559</span></code>
+ floating-point built-in types, but false for integer types.
+ </p>
+<p>
+ Standard-compliant IEEE 754 floating-point implementations may detect the
+ floating-point underflow at three predefined moments:
+ </p>
+<div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+ After computation of a result with absolute value smaller than <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">min</span><span class="special">()</span></code>,
+ such implementation detects <span class="emphasis"><em>tinyness before rounding</em></span>
+ (e.g. UltraSparc).
+ </li>
+<li class="listitem">
+ After rounding of the result to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">digits</span></code>
+ bits, if the result is tiny, such implementation detects <span class="emphasis"><em>tinyness
+ after rounding</em></span> (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 <span class="emphasis"><em>denorm
+ loss</em></span>.
+ </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 &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
+ 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)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../limits.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../limits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="functions.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/functions.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/functions.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -0,0 +1,546 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>std::numeric_limits&lt;&gt; functions</title>
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../index.html" title="Chapter&#160;1.&#160;Boost.Multiprecision">
+<link rel="up" href="../limits.html" title="Numeric Limits">
+<link rel="prev" href="constants.html" title="std::numeric_limits&lt;&gt; constants">
+<link rel="next" href="limits32.html" title="Numeric limits for 32-bit platform">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="constants.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../limits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="limits32.html"><img src="../../../../../../../doc/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.functions"></a><a class="link" href="functions.html" title="std::numeric_limits&lt;&gt; functions">std::numeric_limits&lt;&gt;
+ functions</a>
+</h4></div></div></div>
+<h5>
+<a name="boost_multiprecision.tut.limits.functions.h0"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.functions.max_function"></a></span><a class="link" href="functions.html#boost_multiprecision.tut.limits.functions.max_function">max function</a>
+ </h5>
+<p>
+ Function <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">()</span></code>
+ returns the largest finite value that can be represented by the type T.
+ If there is no such value (and <code class="computeroutput"><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">bounded</span></code>
+ is <code class="computeroutput"><span class="keyword">false</span></code>) then returns <code class="computeroutput"><span class="identifier">T</span><span class="special">()</span></code>.
+ </p>
+<p>
+ For built-in types there is usually a corresponding MACRO value TYPE_MAX,
+ where TYPE is CHAR, INT, FLOAT etc.
+ </p>
+<p>
+ Other types, including those provided by a typedef, for example <code class="computeroutput"><span class="identifier">INT64_T_MAX</span></code> for <code class="computeroutput"><span class="identifier">int64_t</span></code>,
+ may provide a macro definition.
+ </p>
+<p>
+ To cater for situations where no <code class="computeroutput"><span class="identifier">numeric_limits</span></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
+ </p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">tools</span><span class="special">/</span><span class="identifier">precision</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+
+<span class="identifier">T</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tools</span><span class="special">::</span><span class="identifier">max_value</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;();</span>
+</pre>
+<p>
+ Of course, these simply use <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">()</span></code> if available, but otherwise 'do something
+ sensible'.
+ </p>
+<h5>
+<a name="boost_multiprecision.tut.limits.functions.h1"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.functions.lowest_function"></a></span><a class="link" href="functions.html#boost_multiprecision.tut.limits.functions.lowest_function">lowest
+ function</a>
+ </h5>
+<p>
+ Since C++11: <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">lowest</span><span class="special">()</span></code>
+ is
+ </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+ For integral types, the same as function <code class="computeroutput"><span class="identifier">min</span><span class="special">()</span></code>.
+ </li>
+<li class="listitem">
+ For floating-point types, generally the negative of <code class="computeroutput"><span class="identifier">max</span><span class="special">()</span></code> (but implementation-dependent).
+ </li>
+</ul></div>
+<pre class="programlisting"><span class="special">-(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">)()</span> <span class="special">==</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">lowest</span><span class="special">();</span>
+</pre>
+<h5>
+<a name="boost_multiprecision.tut.limits.functions.h2"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.functions.min_function"></a></span><a class="link" href="functions.html#boost_multiprecision.tut.limits.functions.min_function">min function</a>
+ </h5>
+<p>
+ Function <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">min</span><span class="special">()</span></code>
+ returns the minimum finite value that can be represented by the type T.
+ </p>
+<p>
+ For built-in types there is usually a corresponding MACRO value TYPE_MIN,
+ where TYPE is CHAR, INT, FLOAT etc.
+ </p>
+<p>
+ Other types, including those provided by a typedef, for example <code class="computeroutput"><span class="identifier">INT64_T_MIN</span></code> for <code class="computeroutput"><span class="identifier">int64_t</span></code>,
+ may provide a macro definition.
+ </p>
+<p>
+ For floating-point types, it is more fully defined as the <span class="emphasis"><em>minimum
+ positive normalized value</em></span>.
+ </p>
+<p>
+ See <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">denorm_min</span><span class="special">()</span></code>
+ for the smallest denormalized value, provided
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">has_denorm</span> <span class="special">==</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">denorm_present</span>
+</pre>
+<p>
+ To cater for situations where no <code class="computeroutput"><span class="identifier">numeric_limits</span></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
+ </p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">tools</span><span class="special">/</span><span class="identifier">precision</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+
+<span class="identifier">T</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tools</span><span class="special">::</span><span class="identifier">min_value</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;();</span>
+</pre>
+<p>
+ Of course, these simply use <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">min</span><span class="special">()</span></code> if available.
+ </p>
+<h5>
+<a name="boost_multiprecision.tut.limits.functions.h3"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.functions.denorm_min_function"></a></span><a class="link" href="functions.html#boost_multiprecision.tut.limits.functions.denorm_min_function">denorm_min
+ function</a>
+ </h5>
+<p>
+ Function <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">denorm_min</span><span class="special">()</span></code>
+ returns the smallest <a href="http://en.wikipedia.org/wiki/Denormal_number" target="_top">denormalized
+ value</a>, provided
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">has_denorm</span> <span class="special">==</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">denorm_present</span>
+</pre>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">);</span>
+<span class="keyword">if</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">has_denorm</span> <span class="special">==</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">denorm_present</span><span class="special">)</span>
+<span class="special">{</span>
+ <span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">denorm_min</span><span class="special">();</span>
+
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">d</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// 4.9406564584124654e-324</span>
+
+ <span class="keyword">int</span> <span class="identifier">exponent</span><span class="special">;</span>
+
+ <span class="keyword">double</span> <span class="identifier">significand</span> <span class="special">=</span> <span class="identifier">frexp</span><span class="special">(</span><span class="identifier">d</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">exponent</span><span class="special">);</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"exponent = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hex</span> <span class="special">&lt;&lt;</span> <span class="identifier">exponent</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// fffffbcf</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"significand = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hex</span> <span class="special">&lt;&lt;</span> <span class="identifier">significand</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// 0.50000000000000000</span>
+<span class="special">}</span>
+<span class="keyword">else</span>
+<span class="special">{</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"No denormalization. "</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+<p>
+ 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).
+ </p>
+<h5>
+<a name="boost_multiprecision.tut.limits.functions.h4"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.functions.round_error"></a></span><a class="link" href="functions.html#boost_multiprecision.tut.limits.functions.round_error">round_error</a>
+ </h5>
+<p>
+ Function <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">round_error</span><span class="special">()</span></code>
+ returns the maximum error (in units of ULP)
+ that can be caused by any basic arithmetic operation.
+ </p>
+<pre class="programlisting"><span class="identifier">round_style</span> <span class="special">==</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">round_indeterminate</span><span class="special">;</span>
+</pre>
+<p>
+ The rounding style is indeterminable at compile time.
+ </p>
+<p>
+ For floating-point types, when rounding is to nearest, only half a bit
+ is lost by rounding, and <code class="computeroutput"><span class="identifier">round_error</span>
+ <span class="special">==</span> <span class="number">0.5</span></code>.
+ In contrast when rounding is towards zero, or plus/minus infinity, we can
+ loose up to one bit from rounding, and <code class="computeroutput"><span class="identifier">round_error</span>
+ <span class="special">==</span> <span class="number">1</span></code>.
+ </p>
+<p>
+ For integer types, rounding always to zero, so at worst almost one bit
+ can be rounded, so <code class="computeroutput"><span class="identifier">round_error</span>
+ <span class="special">==</span> <span class="number">1</span></code>.
+ </p>
+<p>
+ <code class="computeroutput"><span class="identifier">round_error</span><span class="special">()</span></code>
+ can be used with <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">()</span></code>
+ to estimate the maximum potential error caused by rounding. For typical
+ floating-point types, <code class="computeroutput"><span class="identifier">round_error</span><span class="special">()</span> <span class="special">=</span> <span class="number">1</span><span class="special">/</span><span class="number">2</span></code>, so half
+ epsilon is the maximum potential error.
+ </p>
+<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">round_err</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">()</span> <span class="comment">// 2.2204460492503131e-016</span>
+ <span class="special">*</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">round_error</span><span class="special">();</span> <span class="comment">// 1/2</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">round_err</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// 1.1102230246251565e-016</span>
+</pre>
+<p>
+ 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.
+ </p>
+<h5>
+<a name="boost_multiprecision.tut.limits.functions.h5"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.functions.epsilon"></a></span><a class="link" href="functions.html#boost_multiprecision.tut.limits.functions.epsilon">epsilon</a>
+ </h5>
+<p>
+ Function <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">()</span></code>
+ is meaningful only for non-integral types.
+ </p>
+<p>
+ It returns the difference between <code class="computeroutput"><span class="number">1.0</span></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.
+ </p>
+<p>
+ For <code class="computeroutput"><span class="keyword">double</span></code> (<code class="computeroutput"><span class="identifier">float_64t</span></code>) it is <code class="computeroutput"><span class="number">2.2204460492503131e-016</span></code>
+ showing all possibly significant 17 decimal digits.
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">);</span>
+<span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span> <span class="number">1.</span><span class="special">;</span>
+<span class="keyword">double</span> <span class="identifier">eps</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">();</span>
+<span class="keyword">double</span> <span class="identifier">dpeps</span> <span class="special">=</span> <span class="identifier">d</span><span class="special">+</span><span class="identifier">eps</span><span class="special">;</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">showpoint</span> <span class="comment">// Ensure all trailing zeros are shown.</span>
+ <span class="special">&lt;&lt;</span> <span class="identifier">d</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span> <span class="comment">// 1.0000000000000000</span>
+ <span class="special">&lt;&lt;</span> <span class="identifier">dpeps</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// 2.2204460492503131e-016</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">dpeps</span> <span class="special">-</span> <span class="identifier">d</span> <span class="comment">// 1.0000000000000002</span>
+ <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+</pre>
+<p>
+ We can explicitly increment by one bit using the function <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">float_next</span><span class="special">()</span></code>
+ and the result is the same as adding <code class="computeroutput"><span class="identifier">epsilon</span></code>.
+ </p>
+<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">one</span> <span class="special">=</span> <span class="number">1.</span><span class="special">;</span>
+<span class="keyword">double</span> <span class="identifier">nad</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">float_next</span><span class="special">(</span><span class="identifier">one</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">nad</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span> <span class="comment">// 1.0000000000000002</span>
+ <span class="special">&lt;&lt;</span> <span class="identifier">nad</span> <span class="special">-</span> <span class="identifier">one</span> <span class="comment">// 2.2204460492503131e-016</span>
+ <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+</pre>
+<p>
+ Adding any smaller value, like half <code class="computeroutput"><span class="identifier">epsilon</span></code>,
+ will have no effect on this value.
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">);</span>
+<span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span> <span class="number">1.</span><span class="special">;</span>
+<span class="keyword">double</span> <span class="identifier">eps</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">();</span>
+<span class="keyword">double</span> <span class="identifier">dpeps</span> <span class="special">=</span> <span class="identifier">d</span> <span class="special">+</span> <span class="identifier">eps</span><span class="special">/</span><span class="number">2</span><span class="special">;</span>
+
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">showpoint</span> <span class="comment">// Ensure all trailing zeros are shown.</span>
+ <span class="special">&lt;&lt;</span> <span class="identifier">dpeps</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span> <span class="comment">// 1.0000000000000000</span>
+ <span class="special">&lt;&lt;</span> <span class="identifier">eps</span><span class="special">/</span><span class="number">2</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// 1.1102230246251565e-016</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">dpeps</span> <span class="special">-</span> <span class="identifier">d</span> <span class="comment">// 0.00000000000000000</span>
+ <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+</pre>
+<p>
+ So this cancellation error leaves the values equal, despite adding half
+ <code class="computeroutput"><span class="identifier">epsilon</span></code>.
+ </p>
+<p>
+ 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"><span class="identifier">numeric_limits</span></code>
+ is not available. To use these <code class="computeroutput"><span class="preprocessor">#include</span>
+ <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">tools</span><span class="special">/</span><span class="identifier">precision</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>.
+ </p>
+<p>
+ A tolerance might be defined using this version of epsilon thus:
+ </p>
+<pre class="programlisting"><span class="identifier">RealType</span> <span class="identifier">tolerance</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tools</span><span class="special">::</span><span class="identifier">epsilon</span><span class="special">&lt;</span><span class="identifier">RealType</span><span class="special">&gt;()</span> <span class="special">*</span> <span class="number">2</span><span class="special">;</span>
+</pre>
+<h6>
+<a name="boost_multiprecision.tut.limits.functions.h6"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.functions.tolerance_for_floating_point_com"></a></span><a class="link" href="functions.html#boost_multiprecision.tut.limits.functions.tolerance_for_floating_point_com">Tolerance
+ for Floating-point Comparisons</a>
+ </h6>
+<p>
+ <code class="computeroutput"><span class="identifier">epsilon</span></code> is very useful
+ to compute a tolerance when comparing floating-point values, a much more
+ difficult task than is commonly imagined.
+ </p>
+<p>
+ 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>
+ </p>
+<p>
+ 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.
+ </p>
+<p>
+ So Boost.Test uses an algorithm first devised by Knuth for reliably checking
+ if floating-point values are close enough.
+ </p>
+<p>
+ 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.
+ </p>
+<p>
+ See also:
+ </p>
+<p>
+ <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>
+ </p>
+<p>
+ <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>
+ </p>
+<p>
+ <a href="../../../../../../../libs/test/doc/html/utf/testing-tools/floating_point_comparison.html" target="_top">floating-point
+ comparison</a>.
+ </p>
+<p>
+ For example, if we want a tolerance that might suit about 9 arithmetical
+ operations, say sqrt(9) = 3, we could define:
+ </p>
+<pre class="programlisting"><span class="identifier">T</span> <span class="identifier">tolerance</span> <span class="special">=</span> <span class="number">3</span> <span class="special">*</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">();</span>
+</pre>
+<p>
+ This is very widely used in Boost.Math testing with Boost.Test's macro
+ <code class="computeroutput"><span class="identifier">BOOST_CHECK_CLOSE_FRACTION</span></code>
+ </p>
+<pre class="programlisting"><span class="identifier">T</span> <span class="identifier">expected</span> <span class="special">=</span> <span class="number">1.0</span><span class="special">;</span>
+<span class="identifier">T</span> <span class="identifier">calculated</span> <span class="special">=</span> <span class="number">1.0</span> <span class="special">+</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">();</span>
+
+<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">test_tools</span><span class="special">::</span><span class="identifier">check_is_close</span><span class="special">;</span>
+
+<span class="keyword">bool</span> <span class="identifier">r</span> <span class="special">=</span> <span class="identifier">check_is_close</span><span class="special">(</span><span class="identifier">expected</span><span class="special">,</span> <span class="identifier">calculated</span><span class="special">,</span> <span class="identifier">tolerance</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// true</span>
+</pre>
+<p>
+ If using Boost.Test, then call the macro version:
+ </p>
+<pre class="programlisting"><span class="identifier">BOOST_CHECK_CLOSE_FRACTION</span><span class="special">(</span><span class="identifier">expected</span><span class="special">,</span> <span class="identifier">calculated</span><span class="special">,</span> <span class="identifier">tolerance</span><span class="special">);</span></pre>
+<p>
+ used thus:
+ </p>
+<pre class="programlisting"><span class="identifier">BOOST_CHECK_CLOSE_FRACTION</span><span class="special">(</span><span class="identifier">expected</span><span class="special">,</span> <span class="identifier">calculated</span><span class="special">,</span> <span class="identifier">tolerance</span><span class="special">);</span>
+</pre>
+<p>
+ (There is also a version using tolerance as a percentage rather than a
+ fraction).
+ </p>
+<pre class="programlisting"><span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">number</span><span class="special">;</span>
+<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_dec_float</span><span class="special">;</span>
+<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">et_off</span><span class="special">;</span>
+
+<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;,</span> <span class="identifier">et_off</span> <span class="special">&gt;</span> <span class="identifier">cpp_dec_float_50</span><span class="special">;</span> <span class="comment">// 50 decimal digits.</span>
+</pre>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+ 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"><span class="identifier">et_off</span></code>.
+ </p></td></tr>
+</table></div>
+<pre class="programlisting"><span class="identifier">cpp_dec_float_50</span> <span class="identifier">tolerance</span> <span class="special">=</span> <span class="number">3</span> <span class="special">*</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_50</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">();</span>
+<span class="identifier">cpp_dec_float_50</span> <span class="identifier">expected</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">constants</span><span class="special">::</span><span class="identifier">two_pi</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_50</span><span class="special">&gt;();</span>
+<span class="identifier">cpp_dec_float_50</span> <span class="identifier">calculated</span> <span class="special">=</span> <span class="number">2</span> <span class="special">*</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">constants</span><span class="special">::</span><span class="identifier">pi</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_50</span><span class="special">&gt;();</span>
+<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">test_tools</span><span class="special">::</span><span class="identifier">check_is_close</span><span class="special">;</span>
+
+<span class="keyword">bool</span> <span class="identifier">r</span> <span class="special">=</span> <span class="identifier">check_is_close</span><span class="special">(</span><span class="identifier">expected</span><span class="special">,</span> <span class="identifier">calculated</span><span class="special">,</span> <span class="identifier">tolerance</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// true</span>
+</pre>
+<h5>
+<a name="boost_multiprecision.tut.limits.functions.h7"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.functions.infinity_positive_and_negative"></a></span><a class="link" href="functions.html#boost_multiprecision.tut.limits.functions.infinity_positive_and_negative">Infinity
+ - positive and negative</a>
+ </h5>
+<p>
+ For floating-point types only, for which <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">has_infinity</span>
+ <span class="special">==</span> <span class="keyword">true</span></code>,
+ function <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">infinity</span><span class="special">()</span></code>
+ provides an implementation-defined representation for &#8734;.
+ </p>
+<p>
+ The 'representation' is a particular bit pattern reserved for infinity.
+ For IEEE754 system (for which <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_iec559</span>
+ <span class="special">==</span> <span class="keyword">true</span></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.
+ </p>
+<p>
+ 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.
+ </p>
+<p>
+ For example, the output is <code class="computeroutput"><span class="number">1.</span><span class="special">#</span><span class="identifier">INF</span></code>
+ on Microsoft systems, but <code class="computeroutput"><span class="identifier">inf</span></code>
+ on most *nix platforms.
+ </p>
+<p>
+ 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 <span class="bold"><strong>all</strong></span> 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.
+ </p>
+<h5>
+<a name="boost_multiprecision.tut.limits.functions.h8"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.functions.not_a_number_nan"></a></span><a class="link" href="functions.html#boost_multiprecision.tut.limits.functions.not_a_number_nan">Not-A-Number
+ NaN</a>
+ </h5>
+<h6>
+<a name="boost_multiprecision.tut.limits.functions.h9"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.functions.quiet_nan"></a></span><a class="link" href="functions.html#boost_multiprecision.tut.limits.functions.quiet_nan">Quiet_NaN</a>
+ </h6>
+<p>
+ For floating-point types only, for which <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">has_quiet_NaN</span>
+ <span class="special">==</span> <span class="keyword">true</span></code>,
+ function <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">quiet_NaN</span><span class="special">()</span></code>
+ provides an implementation-defined representation for NaN.
+ </p>
+<p>
+ NaNs are values to
+ indicate that the result of an assignment or computation is meaningless.
+ A typical example is <code class="computeroutput"><span class="number">0</span><span class="special">/</span><span class="number">0</span></code> but there are many others.
+ </p>
+<p>
+ NaNs may also be used, to represent missing values: for example, these
+ could, by convention, be ignored in calculations of statistics like means.
+ </p>
+<p>
+ Many of the problems with a representation for Not-A-Number
+ has hampered portable use, similar to those with infinity.
+ </p>
+<p>
+ NaN can be used with binary multiprecision types like <code class="computeroutput"><span class="identifier">cpp_bin_float_quad</span></code>:
+ </p>
+<pre class="programlisting"><span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_bin_float_quad</span><span class="special">;</span>
+
+<span class="keyword">if</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_quad</span><span class="special">&gt;::</span><span class="identifier">has_quiet_NaN</span> <span class="special">==</span> <span class="keyword">true</span><span class="special">)</span>
+<span class="special">{</span>
+ <span class="identifier">cpp_bin_float_quad</span> <span class="identifier">tolerance</span> <span class="special">=</span> <span class="number">3</span> <span class="special">*</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_quad</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">();</span>
+
+ <span class="identifier">cpp_bin_float_quad</span> <span class="identifier">NaN</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_quad</span><span class="special">&gt;::</span><span class="identifier">quiet_NaN</span><span class="special">();</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"cpp_bin_float_quad NaN is "</span> <span class="special">&lt;&lt;</span> <span class="identifier">NaN</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// cpp_bin_float_quad NaN is nan</span>
+
+ <span class="identifier">cpp_bin_float_quad</span> <span class="identifier">expected</span> <span class="special">=</span> <span class="identifier">NaN</span><span class="special">;</span>
+ <span class="identifier">cpp_bin_float_quad</span> <span class="identifier">calculated</span> <span class="special">=</span> <span class="number">2</span> <span class="special">*</span> <span class="identifier">NaN</span><span class="special">;</span>
+ <span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">test_tools</span><span class="special">::</span><span class="identifier">check_is_close</span><span class="special">;</span>
+
+ <span class="keyword">bool</span> <span class="identifier">r</span> <span class="special">=</span> <span class="identifier">check_is_close</span><span class="special">(</span><span class="identifier">expected</span><span class="special">,</span> <span class="identifier">expected</span><span class="special">,</span> <span class="identifier">tolerance</span><span class="special">);</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// false, as expected because all comparisons with NaNs are false.</span>
+
+ <span class="identifier">r</span> <span class="special">=</span> <span class="identifier">check_is_close</span><span class="special">(</span><span class="identifier">expected</span><span class="special">,</span> <span class="identifier">calculated</span><span class="special">,</span> <span class="identifier">tolerance</span><span class="special">);</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// false, as expected because all comparisons with NaNs are false.</span>
+<span class="special">}</span>
+<span class="keyword">else</span>
+<span class="special">{</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Type "</span> <span class="special">&lt;&lt;</span> <span class="keyword">typeid</span><span class="special">(</span><span class="identifier">cpp_bin_float_quad</span><span class="special">).</span><span class="identifier">name</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">" does not have NaNs!"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+<p>
+ But using Boost.Math and suitable facets can permit portable use of both
+ NaNs and positive and negative infinity.
+ </p>
+<p>
+ See boost:/libs/math/example/nonfinite_facet_sstream.cpp
+ and we also need
+ </p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">special_functions</span><span class="special">/</span><span class="identifier">nonfinite_num_facets</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+</pre>
+<p>
+ Then we can equally well use a multiprecision type cpp_bin_float_quad:
+ </p>
+<pre class="programlisting"><span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_bin_float_quad</span><span class="special">;</span>
+
+<span class="keyword">typedef</span> <span class="identifier">cpp_bin_float_quad</span> <span class="identifier">T</span><span class="special">;</span>
+
+<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">nonfinite_num_put</span><span class="special">;</span>
+<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">nonfinite_num_get</span><span class="special">;</span>
+<span class="special">{</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">locale</span> <span class="identifier">old_locale</span><span class="special">;</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">locale</span> <span class="identifier">tmp_locale</span><span class="special">(</span><span class="identifier">old_locale</span><span class="special">,</span> <span class="keyword">new</span> <span class="identifier">nonfinite_num_put</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;);</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">locale</span> <span class="identifier">new_locale</span><span class="special">(</span><span class="identifier">tmp_locale</span><span class="special">,</span> <span class="keyword">new</span> <span class="identifier">nonfinite_num_get</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;);</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">stringstream</span> <span class="identifier">ss</span><span class="special">;</span>
+ <span class="identifier">ss</span><span class="special">.</span><span class="identifier">imbue</span><span class="special">(</span><span class="identifier">new_locale</span><span class="special">);</span>
+ <span class="identifier">T</span> <span class="identifier">inf</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">infinity</span><span class="special">();</span>
+ <span class="identifier">ss</span> <span class="special">&lt;&lt;</span> <span class="identifier">inf</span><span class="special">;</span> <span class="comment">// Write out.</span>
+ <span class="identifier">assert</span><span class="special">(</span><span class="identifier">ss</span><span class="special">.</span><span class="identifier">str</span><span class="special">()</span> <span class="special">==</span> <span class="string">"inf"</span><span class="special">);</span>
+ <span class="identifier">T</span> <span class="identifier">r</span><span class="special">;</span>
+ <span class="identifier">ss</span> <span class="special">&gt;&gt;</span> <span class="identifier">r</span><span class="special">;</span> <span class="comment">// Read back in.</span>
+ <span class="identifier">assert</span><span class="special">(</span><span class="identifier">inf</span> <span class="special">==</span> <span class="identifier">r</span><span class="special">);</span> <span class="comment">// Confirms that the floating-point values really are identical.</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"infinity output was "</span> <span class="special">&lt;&lt;</span> <span class="identifier">ss</span><span class="special">.</span><span class="identifier">str</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"infinity input was "</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+<pre class="programlisting"><span class="identifier">infinity</span> <span class="identifier">output</span> <span class="identifier">was</span> <span class="identifier">inf</span>
+<span class="identifier">infinity</span> <span class="identifier">input</span> <span class="identifier">was</span> <span class="identifier">inf</span>
+</pre>
+<p>
+ Similarly we can do the same with NaN (except that we cannot use <code class="computeroutput"><span class="identifier">assert</span></code>)
+ </p>
+<pre class="programlisting"><span class="special">{</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">locale</span> <span class="identifier">old_locale</span><span class="special">;</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">locale</span> <span class="identifier">tmp_locale</span><span class="special">(</span><span class="identifier">old_locale</span><span class="special">,</span> <span class="keyword">new</span> <span class="identifier">nonfinite_num_put</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;);</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">locale</span> <span class="identifier">new_locale</span><span class="special">(</span><span class="identifier">tmp_locale</span><span class="special">,</span> <span class="keyword">new</span> <span class="identifier">nonfinite_num_get</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;);</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">stringstream</span> <span class="identifier">ss</span><span class="special">;</span>
+ <span class="identifier">ss</span><span class="special">.</span><span class="identifier">imbue</span><span class="special">(</span><span class="identifier">new_locale</span><span class="special">);</span>
+ <span class="identifier">T</span> <span class="identifier">n</span><span class="special">;</span>
+ <span class="identifier">T</span> <span class="identifier">NaN</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">quiet_NaN</span><span class="special">();</span>
+ <span class="identifier">ss</span> <span class="special">&lt;&lt;</span> <span class="identifier">NaN</span><span class="special">;</span> <span class="comment">// Write out.</span>
+ <span class="identifier">assert</span><span class="special">(</span><span class="identifier">ss</span><span class="special">.</span><span class="identifier">str</span><span class="special">()</span> <span class="special">==</span> <span class="string">"nan"</span><span class="special">);</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"NaN output was "</span> <span class="special">&lt;&lt;</span> <span class="identifier">ss</span><span class="special">.</span><span class="identifier">str</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+ <span class="identifier">ss</span> <span class="special">&gt;&gt;</span> <span class="identifier">n</span><span class="special">;</span> <span class="comment">// Read back in.</span>
+ <span class="identifier">assert</span><span class="special">(</span><span class="identifier">NaN</span> <span class="special">==</span> <span class="identifier">n</span><span class="special">);</span> <span class="comment">// Confirms that the floating-point values really are identical.</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"NaN input was "</span> <span class="special">&lt;&lt;</span> <span class="identifier">n</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+<p>
+ NaN output was nan NaN input was nan
+ </p>
+<h6>
+<a name="boost_multiprecision.tut.limits.functions.h10"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.functions.signaling_nan"></a></span><a class="link" href="functions.html#boost_multiprecision.tut.limits.functions.signaling_nan">Signaling
+ NaN</a>
+ </h6>
+<p>
+ For floating-point types only, for which <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">has_signaling_NaN</span>
+ <span class="special">==</span> <span class="keyword">true</span></code>,
+ function <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">signaling_NaN</span><span class="special">()</span></code>
+ provides an implementation-defined representation for NaN that causes a
+ hardware trap. It should be noted however, that at least one implementation
+ of this function causes a hardware trap to be triggered simply by calling
+ <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">signaling_NaN</span><span class="special">()</span></code>,
+ and not only by using the value returned.
+ </p>
+</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 &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
+ 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)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="constants.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../limits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="limits32.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/how_to_tell.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/how_to_tell.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -0,0 +1,168 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>How to Determine the Kind of a Number From std::numeric_limits</title>
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../index.html" title="Chapter&#160;1.&#160;Boost.Multiprecision">
+<link rel="up" href="../limits.html" title="Numeric Limits">
+<link rel="prev" href="limits32.html" title="Numeric limits for 32-bit platform">
+<link rel="next" href="../input_output.html" title="Input Output">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="limits32.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../limits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../input_output.html"><img src="../../../../../../../doc/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.how_to_tell"></a><a class="link" href="how_to_tell.html" title="How to Determine the Kind of a Number From std::numeric_limits">How to
+ Determine the Kind of a Number From <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code></a>
+</h4></div></div></div>
+<p>
+ Based on the information above, one can see that different kinds of numbers
+ can be differentiated based on the information stored in <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code>. This is in addition to
+ the traits class <a class="link" href="../../ref/number.html#boost_multiprecision.ref.number.traits_class_support">number_category</a>
+ provided by this library.
+ </p>
+<h5>
+<a name="boost_multiprecision.tut.limits.how_to_tell.h0"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.how_to_tell.integer_types"></a></span><a class="link" href="how_to_tell.html#boost_multiprecision.tut.limits.how_to_tell.integer_types">Integer
+ Types</a>
+ </h5>
+<p>
+ For an integer type T, all of the following conditions hold:
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_specialized</span> <span class="special">==</span> <span class="keyword">true</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_integer</span> <span class="special">==</span> <span class="keyword">true</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_exact</span> <span class="special">==</span> <span class="keyword">true</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">min_exponent</span> <span class="special">==</span> <span class="number">0</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_exponent</span> <span class="special">==</span> <span class="number">0</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">min_exponent10</span> <span class="special">==</span> <span class="number">0</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_exponent10</span> <span class="special">==</span> <span class="number">0</span>
+</pre>
+<p>
+ In addition the type is <span class="emphasis"><em>signed</em></span> if:
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_signed</span> <span class="special">==</span> <span class="keyword">true</span>
+</pre>
+<p>
+ If the type is arbitrary precision then:
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_bounded</span> <span class="special">==</span> <span class="keyword">false</span>
+</pre>
+<p>
+ Otherwise the type is bounded, and returns a non zero value from:
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">()</span>
+</pre>
+<p>
+ and has:
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_modulo</span> <span class="special">==</span> <span class="keyword">true</span>
+</pre>
+<p>
+ if the type implements modulo arithmetic on overflow.
+ </p>
+<h5>
+<a name="boost_multiprecision.tut.limits.how_to_tell.h1"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.how_to_tell.rational_types"></a></span><a class="link" href="how_to_tell.html#boost_multiprecision.tut.limits.how_to_tell.rational_types">Rational
+ Types</a>
+ </h5>
+<p>
+ Rational types are just like integers except that:
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_integer</span> <span class="special">==</span> <span class="keyword">false</span>
+</pre>
+<h5>
+<a name="boost_multiprecision.tut.limits.how_to_tell.h2"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.how_to_tell.fixed_precision_types"></a></span><a class="link" href="how_to_tell.html#boost_multiprecision.tut.limits.how_to_tell.fixed_precision_types">Fixed
+ Precision Types</a>
+ </h5>
+<p>
+ There appears to be no way to tell these apart from rational types, unless
+ they set:
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_exact</span> <span class="special">==</span> <span class="keyword">false</span>
+</pre>
+<p>
+ This is because these types are in essense a rational type with a fixed
+ denominator.
+ </p>
+<h5>
+<a name="boost_multiprecision.tut.limits.how_to_tell.h3"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.how_to_tell.floating_point_types"></a></span><a class="link" href="how_to_tell.html#boost_multiprecision.tut.limits.how_to_tell.floating_point_types">Floating
+ Point Types</a>
+ </h5>
+<p>
+ For a floating point type T, all of the following conditions hold:
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_specialized</span> <span class="special">==</span> <span class="keyword">true</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_integer</span> <span class="special">==</span> <span class="keyword">false</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_exact</span> <span class="special">==</span> <span class="keyword">false</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">min_exponent</span> <span class="special">!=</span> <span class="number">0</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_exponent</span> <span class="special">!=</span> <span class="number">0</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">min_exponent10</span> <span class="special">!=</span> <span class="number">0</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_exponent10</span> <span class="special">!=</span> <span class="number">0</span>
+</pre>
+<p>
+ In addition the type is <span class="emphasis"><em>signed</em></span> if:
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_signed</span> <span class="special">==</span> <span class="keyword">true</span>
+</pre>
+<p>
+ And the type may be decimal or binary depending on the value of:
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">radix</span>
+</pre>
+<p>
+ In general, there are no arbitrary precision floating point types, and
+ so:
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_bounded</span> <span class="special">==</span> <span class="keyword">false</span>
+</pre>
+<h5>
+<a name="boost_multiprecision.tut.limits.how_to_tell.h4"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.how_to_tell.exact_floating_point_types"></a></span><a class="link" href="how_to_tell.html#boost_multiprecision.tut.limits.how_to_tell.exact_floating_point_types">Exact
+ Floating Point Types</a>
+ </h5>
+<p>
+ Exact floating point types are a 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:
+ </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_exact</span> <span class="special">==</span> <span class="keyword">true</span>
+</pre>
+<h5>
+<a name="boost_multiprecision.tut.limits.how_to_tell.h5"></a>
+ <span class="phrase"><a name="boost_multiprecision.tut.limits.how_to_tell.complex_numbers"></a></span><a class="link" href="how_to_tell.html#boost_multiprecision.tut.limits.how_to_tell.complex_numbers">Complex
+ Numbers</a>
+ </h5>
+<p>
+ For historical reasons, complex numbers do not specialize <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code>, instead you must inspect
+ <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">&gt;</span></code>.
+ </p>
+</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 &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
+ 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)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="limits32.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../limits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../input_output.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/limits32.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/limits/limits32.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -0,0 +1,2049 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Numeric limits for 32-bit platform</title>
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../../index.html" title="Chapter&#160;1.&#160;Boost.Multiprecision">
+<link rel="up" href="../limits.html" title="Numeric Limits">
+<link rel="prev" href="functions.html" title="std::numeric_limits&lt;&gt; 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">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="functions.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../limits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="how_to_tell.html"><img src="../../../../../../../doc/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>
+<p>
+ These tables were generated using the following program and options:
+ </p>
+<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><p class="title"><b>Table&#160;1.4.&#160;Integer types constants (<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_integer</span>
+ <span class="special">==</span> <span class="keyword">true</span></code>
+ &amp;&amp; is_exact == true)</b></p>
+<div class="table-contents"><table class="table" summary="Integer types constants (std::numeric_limits&lt;T&gt;::is_integer
+ == true
+ &amp;&amp; is_exact == true)">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ type
+ </p>
+ </th>
+<th>
+ <p>
+ signed
+ </p>
+ </th>
+<th>
+ <p>
+ bound
+ </p>
+ </th>
+<th>
+ <p>
+ modulo
+ </p>
+ </th>
+<th>
+ <p>
+ round
+ </p>
+ </th>
+<th>
+ <p>
+ radix
+ </p>
+ </th>
+<th>
+ <p>
+ digits
+ </p>
+ </th>
+<th>
+ <p>
+ digits10
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ bool
+ </p>
+ </td>
+<td>
+ <p>
+ unsigned
+ </p>
+ </td>
+<td>
+ <p>
+ bound
+ </p>
+ </td>
+<td>
+ <p>
+ no
+ </p>
+ </td>
+<td>
+ <p>
+ to zero
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 1
+ </p>
+ </td>
+<td>
+ <p>
+ 0
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ char
+ </p>
+ </td>
+<td>
+ <p>
+ signed
+ </p>
+ </td>
+<td>
+ <p>
+ bound
+ </p>
+ </td>
+<td>
+ <p>
+ modulo
+ </p>
+ </td>
+<td>
+ <p>
+ to zero
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 7
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ unsigned char
+ </p>
+ </td>
+<td>
+ <p>
+ unsigned
+ </p>
+ </td>
+<td>
+ <p>
+ bound
+ </p>
+ </td>
+<td>
+ <p>
+ modulo
+ </p>
+ </td>
+<td>
+ <p>
+ to zero
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 8
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ char16_t
+ </p>
+ </td>
+<td>
+ <p>
+ unsigned
+ </p>
+ </td>
+<td>
+ <p>
+ bound
+ </p>
+ </td>
+<td>
+ <p>
+ modulo
+ </p>
+ </td>
+<td>
+ <p>
+ to zero
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 16
+ </p>
+ </td>
+<td>
+ <p>
+ 4
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ char32_t
+ </p>
+ </td>
+<td>
+ <p>
+ unsigned
+ </p>
+ </td>
+<td>
+ <p>
+ bound
+ </p>
+ </td>
+<td>
+ <p>
+ modulo
+ </p>
+ </td>
+<td>
+ <p>
+ to zero
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 32
+ </p>
+ </td>
+<td>
+ <p>
+ 9
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ short
+ </p>
+ </td>
+<td>
+ <p>
+ signed
+ </p>
+ </td>
+<td>
+ <p>
+ bound
+ </p>
+ </td>
+<td>
+ <p>
+ modulo
+ </p>
+ </td>
+<td>
+ <p>
+ to zero
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 15
+ </p>
+ </td>
+<td>
+ <p>
+ 4
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ unsigned short
+ </p>
+ </td>
+<td>
+ <p>
+ unsigned
+ </p>
+ </td>
+<td>
+ <p>
+ bound
+ </p>
+ </td>
+<td>
+ <p>
+ modulo
+ </p>
+ </td>
+<td>
+ <p>
+ to zero
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 16
+ </p>
+ </td>
+<td>
+ <p>
+ 4
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ int
+ </p>
+ </td>
+<td>
+ <p>
+ signed
+ </p>
+ </td>
+<td>
+ <p>
+ bound
+ </p>
+ </td>
+<td>
+ <p>
+ modulo
+ </p>
+ </td>
+<td>
+ <p>
+ to zero
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 31
+ </p>
+ </td>
+<td>
+ <p>
+ 9
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ unsigned
+ </p>
+ </td>
+<td>
+ <p>
+ unsigned
+ </p>
+ </td>
+<td>
+ <p>
+ bound
+ </p>
+ </td>
+<td>
+ <p>
+ modulo
+ </p>
+ </td>
+<td>
+ <p>
+ to zero
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 32
+ </p>
+ </td>
+<td>
+ <p>
+ 9
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ long
+ </p>
+ </td>
+<td>
+ <p>
+ signed
+ </p>
+ </td>
+<td>
+ <p>
+ bound
+ </p>
+ </td>
+<td>
+ <p>
+ modulo
+ </p>
+ </td>
+<td>
+ <p>
+ to zero
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 31
+ </p>
+ </td>
+<td>
+ <p>
+ 9
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ unsigned long
+ </p>
+ </td>
+<td>
+ <p>
+ unsigned
+ </p>
+ </td>
+<td>
+ <p>
+ bound
+ </p>
+ </td>
+<td>
+ <p>
+ modulo
+ </p>
+ </td>
+<td>
+ <p>
+ to zero
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 32
+ </p>
+ </td>
+<td>
+ <p>
+ 9
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ long long
+ </p>
+ </td>
+<td>
+ <p>
+ signed
+ </p>
+ </td>
+<td>
+ <p>
+ bound
+ </p>
+ </td>
+<td>
+ <p>
+ modulo
+ </p>
+ </td>
+<td>
+ <p>
+ to zero
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 63
+ </p>
+ </td>
+<td>
+ <p>
+ 18
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ unsigned long long
+ </p>
+ </td>
+<td>
+ <p>
+ unsigned
+ </p>
+ </td>
+<td>
+ <p>
+ bound
+ </p>
+ </td>
+<td>
+ <p>
+ modulo
+ </p>
+ </td>
+<td>
+ <p>
+ to zero
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 64
+ </p>
+ </td>
+<td>
+ <p>
+ 19
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ int32_t
+ </p>
+ </td>
+<td>
+ <p>
+ signed
+ </p>
+ </td>
+<td>
+ <p>
+ bound
+ </p>
+ </td>
+<td>
+ <p>
+ modulo
+ </p>
+ </td>
+<td>
+ <p>
+ to zero
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 31
+ </p>
+ </td>
+<td>
+ <p>
+ 9
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ uint32_t
+ </p>
+ </td>
+<td>
+ <p>
+ unsigned
+ </p>
+ </td>
+<td>
+ <p>
+ bound
+ </p>
+ </td>
+<td>
+ <p>
+ modulo
+ </p>
+ </td>
+<td>
+ <p>
+ to zero
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 32
+ </p>
+ </td>
+<td>
+ <p>
+ 9
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ int64_t
+ </p>
+ </td>
+<td>
+ <p>
+ signed
+ </p>
+ </td>
+<td>
+ <p>
+ bound
+ </p>
+ </td>
+<td>
+ <p>
+ modulo
+ </p>
+ </td>
+<td>
+ <p>
+ to zero
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 63
+ </p>
+ </td>
+<td>
+ <p>
+ 18
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ uint64_t
+ </p>
+ </td>
+<td>
+ <p>
+ unsigned
+ </p>
+ </td>
+<td>
+ <p>
+ bound
+ </p>
+ </td>
+<td>
+ <p>
+ modulo
+ </p>
+ </td>
+<td>
+ <p>
+ to zero
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 64
+ </p>
+ </td>
+<td>
+ <p>
+ 19
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ int128_t
+ </p>
+ </td>
+<td>
+ <p>
+ signed
+ </p>
+ </td>
+<td>
+ <p>
+ bound
+ </p>
+ </td>
+<td>
+ <p>
+ modulo
+ </p>
+ </td>
+<td>
+ <p>
+ to zero
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 128
+ </p>
+ </td>
+<td>
+ <p>
+ 38
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ uint128_t
+ </p>
+ </td>
+<td>
+ <p>
+ unsigned
+ </p>
+ </td>
+<td>
+ <p>
+ bound
+ </p>
+ </td>
+<td>
+ <p>
+ modulo
+ </p>
+ </td>
+<td>
+ <p>
+ to zero
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 128
+ </p>
+ </td>
+<td>
+ <p>
+ 38
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ int256_t
+ </p>
+ </td>
+<td>
+ <p>
+ signed
+ </p>
+ </td>
+<td>
+ <p>
+ bound
+ </p>
+ </td>
+<td>
+ <p>
+ modulo
+ </p>
+ </td>
+<td>
+ <p>
+ to zero
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 256
+ </p>
+ </td>
+<td>
+ <p>
+ 77
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ uint256_t
+ </p>
+ </td>
+<td>
+ <p>
+ unsigned
+ </p>
+ </td>
+<td>
+ <p>
+ bound
+ </p>
+ </td>
+<td>
+ <p>
+ modulo
+ </p>
+ </td>
+<td>
+ <p>
+ to zero
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 256
+ </p>
+ </td>
+<td>
+ <p>
+ 77
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ cpp_int
+ </p>
+ </td>
+<td>
+ <p>
+ signed
+ </p>
+ </td>
+<td>
+ <p>
+ unbounded
+ </p>
+ </td>
+<td>
+ <p>
+ no
+ </p>
+ </td>
+<td>
+ <p>
+ to zero
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 2147483647
+ </p>
+ </td>
+<td>
+ <p>
+ 646392383
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<br class="table-break"><div class="table">
+<a name="boost_multiprecision.tut.limits.limits32.integral_functions"></a><p class="title"><b>Table&#160;1.5.&#160;Integer types functions (<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_integer</span>
+ <span class="special">==</span> <span class="keyword">true</span>
+ <span class="special">&amp;&amp;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">min</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">lowest</span><span class="special">()</span></code> )</b></p>
+<div class="table-contents"><table class="table" summary="Integer types functions (std::numeric_limits&lt;T&gt;::is_integer
+ == true
+ &amp;&amp; std::numeric_limits&lt;T&gt;::min() == std::numeric_limits&lt;T&gt;::lowest() )">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ function
+ </p>
+ </th>
+<th>
+ <p>
+ max
+ </p>
+ </th>
+<th>
+ <p>
+ min
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ bool
+ </p>
+ </td>
+<td>
+ <p>
+ 1
+ </p>
+ </td>
+<td>
+ <p>
+ 0
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ char
+ </p>
+ </td>
+<td>
+ <p>
+ 127
+ </p>
+ </td>
+<td>
+ <p>
+ -128
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ unsigned char
+ </p>
+ </td>
+<td>
+ <p>
+ 255
+ </p>
+ </td>
+<td>
+ <p>
+ 0
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ char16_t
+ </p>
+ </td>
+<td>
+ <p>
+ 65535
+ </p>
+ </td>
+<td>
+ <p>
+ 0
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ char32_t
+ </p>
+ </td>
+<td>
+ <p>
+ 4294967295
+ </p>
+ </td>
+<td>
+ <p>
+ 0
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ short
+ </p>
+ </td>
+<td>
+ <p>
+ 32767
+ </p>
+ </td>
+<td>
+ <p>
+ -32768
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ unsigned short
+ </p>
+ </td>
+<td>
+ <p>
+ 65535
+ </p>
+ </td>
+<td>
+ <p>
+ 0
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ int
+ </p>
+ </td>
+<td>
+ <p>
+ 2147483647
+ </p>
+ </td>
+<td>
+ <p>
+ -2147483648
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ unsigned int
+ </p>
+ </td>
+<td>
+ <p>
+ 4294967295
+ </p>
+ </td>
+<td>
+ <p>
+ 0
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ long
+ </p>
+ </td>
+<td>
+ <p>
+ 2147483647
+ </p>
+ </td>
+<td>
+ <p>
+ -2147483648
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ unsigned long
+ </p>
+ </td>
+<td>
+ <p>
+ 4294967295
+ </p>
+ </td>
+<td>
+ <p>
+ 0
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ long long
+ </p>
+ </td>
+<td>
+ <p>
+ 9223372036854775807
+ </p>
+ </td>
+<td>
+ <p>
+ -9223372036854775808
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ unsigned long long
+ </p>
+ </td>
+<td>
+ <p>
+ 18446744073709551615
+ </p>
+ </td>
+<td>
+ <p>
+ 0
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ int32_t
+ </p>
+ </td>
+<td>
+ <p>
+ 2147483647
+ </p>
+ </td>
+<td>
+ <p>
+ -2147483648
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ int64_t
+ </p>
+ </td>
+<td>
+ <p>
+ 9223372036854775807
+ </p>
+ </td>
+<td>
+ <p>
+ -9223372036854775808
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ int128_t
+ </p>
+ </td>
+<td>
+ <p>
+ 340282366920938463463374607431768211455
+ </p>
+ </td>
+<td>
+ <p>
+ -340282366920938463463374607431768211455
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<br class="table-break"><div class="table">
+<a name="boost_multiprecision.tut.limits.limits32.float_functions"></a><p class="title"><b>Table&#160;1.6.&#160;Floating-point types constants (<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_integer</span><span class="special">==</span><span class="keyword">false</span> <span class="special">&amp;&amp;</span> <span class="identifier">is_signed</span><span class="special">==</span><span class="keyword">true</span> <span class="special">&amp;&amp;</span> <span class="identifier">is_modulo</span><span class="special">==</span><span class="keyword">false</span> <span class="special">&amp;&amp;</span> <span class="identifier">is_exact</span><span class="special">==</span><span class="keyword">false</span> <span class="special">&amp;&amp;</span> <span class="identifier">is_bound</span><span cla
ss="special">==</span><span class="keyword">true</span></code>)</b></p>
+<div class="table-contents"><table class="table" summary="Floating-point types constants (std::numeric_limits&lt;T&gt;::is_integer==false &amp;&amp; is_signed==true &amp;&amp; is_modulo==false &amp;&amp; is_exact==false &amp;&amp; is_bound==true)">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+<col>
+<col>
+<col>
+<col>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ type
+ </p>
+ </th>
+<th>
+ <p>
+ round
+ </p>
+ </th>
+<th>
+ <p>
+ radix
+ </p>
+ </th>
+<th>
+ <p>
+ digits
+ </p>
+ </th>
+<th>
+ <p>
+ digits10
+ </p>
+ </th>
+<th>
+ <p>
+ max_digits10
+ </p>
+ </th>
+<th>
+ <p>
+ min_exp
+ </p>
+ </th>
+<th>
+ <p>
+ min_exp10
+ </p>
+ </th>
+<th>
+ <p>
+ max_exp
+ </p>
+ </th>
+<th>
+ <p>
+ max_exp10
+ </p>
+ </th>
+<th>
+ <p>
+ tiny
+ </p>
+ </th>
+<th>
+ <p>
+ trap
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ float
+ </p>
+ </td>
+<td>
+ <p>
+ to nearest
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 24
+ </p>
+ </td>
+<td>
+ <p>
+ 6
+ </p>
+ </td>
+<td>
+ <p>
+ 8
+ </p>
+ </td>
+<td>
+ <p>
+ -125
+ </p>
+ </td>
+<td>
+ <p>
+ -37
+ </p>
+ </td>
+<td>
+ <p>
+ 128
+ </p>
+ </td>
+<td>
+ <p>
+ 38
+ </p>
+ </td>
+<td>
+ <p>
+ tiny
+ </p>
+ </td>
+<td>
+ <p>
+ traps
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ double
+ </p>
+ </td>
+<td>
+ <p>
+ to nearest
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 53
+ </p>
+ </td>
+<td>
+ <p>
+ 15
+ </p>
+ </td>
+<td>
+ <p>
+ 17
+ </p>
+ </td>
+<td>
+ <p>
+ -1021
+ </p>
+ </td>
+<td>
+ <p>
+ -307
+ </p>
+ </td>
+<td>
+ <p>
+ 1024
+ </p>
+ </td>
+<td>
+ <p>
+ 308
+ </p>
+ </td>
+<td>
+ <p>
+ tiny
+ </p>
+ </td>
+<td>
+ <p>
+ traps
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ long double
+ </p>
+ </td>
+<td>
+ <p>
+ to nearest
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 53
+ </p>
+ </td>
+<td>
+ <p>
+ 15
+ </p>
+ </td>
+<td>
+ <p>
+ 17
+ </p>
+ </td>
+<td>
+ <p>
+ -1021
+ </p>
+ </td>
+<td>
+ <p>
+ -307
+ </p>
+ </td>
+<td>
+ <p>
+ 1024
+ </p>
+ </td>
+<td>
+ <p>
+ 308
+ </p>
+ </td>
+<td>
+ <p>
+ tiny
+ </p>
+ </td>
+<td>
+ <p>
+ traps
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ cpp_dec_float_50
+ </p>
+ </td>
+<td>
+ <p>
+ indeterminate
+ </p>
+ </td>
+<td>
+ <p>
+ 10
+ </p>
+ </td>
+<td>
+ <p>
+ 50
+ </p>
+ </td>
+<td>
+ <p>
+ 50
+ </p>
+ </td>
+<td>
+ <p>
+ 80
+ </p>
+ </td>
+<td>
+ <p>
+ -222953000
+ </p>
+ </td>
+<td>
+ <p>
+ -67108864
+ </p>
+ </td>
+<td>
+ <p>
+ 222953000
+ </p>
+ </td>
+<td>
+ <p>
+ 67108864
+ </p>
+ </td>
+<td>
+ <p>
+ no
+ </p>
+ </td>
+<td>
+ <p>
+ no
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ bin_128bit_double_type
+ </p>
+ </td>
+<td>
+ <p>
+ to nearest
+ </p>
+ </td>
+<td>
+ <p>
+ 2
+ </p>
+ </td>
+<td>
+ <p>
+ 377
+ </p>
+ </td>
+<td>
+ <p>
+ 113
+ </p>
+ </td>
+<td>
+ <p>
+ 115
+ </p>
+ </td>
+<td>
+ <p>
+ -2147482894
+ </p>
+ </td>
+<td>
+ <p>
+ -646392082
+ </p>
+ </td>
+<td>
+ <p>
+ 2147482893
+ </p>
+ </td>
+<td>
+ <p>
+ 646392082
+ </p>
+ </td>
+<td>
+ <p>
+ no
+ </p>
+ </td>
+<td>
+ <p>
+ traps
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<br class="table-break"><div class="table">
+<a name="boost_multiprecision.tut.limits.limits32.float_functions0"></a><p class="title"><b>Table&#160;1.7.&#160;Floating-point types functions (<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_integer</span>
+ <span class="special">==</span> <span class="keyword">false</span></code>)</b></p>
+<div class="table-contents"><table class="table" summary="Floating-point types functions (std::numeric_limits&lt;T&gt;::is_integer
+ == false)">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ function
+ </p>
+ </th>
+<th>
+ <p>
+ float
+ </p>
+ </th>
+<th>
+ <p>
+ double
+ </p>
+ </th>
+<th>
+ <p>
+ long double
+ </p>
+ </th>
+<th>
+ <p>
+ cpp_dec_50
+ </p>
+ </th>
+<th>
+ <p>
+ cpp_bin_128
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ max
+ </p>
+ </td>
+<td>
+ <p>
+ 3.40282e+038
+ </p>
+ </td>
+<td>
+ <p>
+ 1.79769e+308
+ </p>
+ </td>
+<td>
+ <p>
+ 1.79769e+308
+ </p>
+ </td>
+<td>
+ <p>
+ 1e+67108865
+ </p>
+ </td>
+<td>
+ <p>
+ 1.85906e+646456766
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ min
+ </p>
+ </td>
+<td>
+ <p>
+ 1.17549e-038
+ </p>
+ </td>
+<td>
+ <p>
+ 2.22507e-308
+ </p>
+ </td>
+<td>
+ <p>
+ 2.22507e-308
+ </p>
+ </td>
+<td>
+ <p>
+ 1e-67108864
+ </p>
+ </td>
+<td>
+ <p>
+ 5.37906e-646456767
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ epsilon
+ </p>
+ </td>
+<td>
+ <p>
+ 1.19209e-007
+ </p>
+ </td>
+<td>
+ <p>
+ 2.22045e-016
+ </p>
+ </td>
+<td>
+ <p>
+ 2.22045e-016
+ </p>
+ </td>
+<td>
+ <p>
+ 1e-49
+ </p>
+ </td>
+<td>
+ <p>
+ 6.49713e-114
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ round_error
+ </p>
+ </td>
+<td>
+ <p>
+ 0.5
+ </p>
+ </td>
+<td>
+ <p>
+ 0.5
+ </p>
+ </td>
+<td>
+ <p>
+ 0.5
+ </p>
+ </td>
+<td>
+ <p>
+ 0.5
+ </p>
+ </td>
+<td>
+ <p>
+ 0.5
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ infinity
+ </p>
+ </td>
+<td>
+ <p>
+ 1.#INF
+ </p>
+ </td>
+<td>
+ <p>
+ 1.#INF
+ </p>
+ </td>
+<td>
+ <p>
+ 1.#INF
+ </p>
+ </td>
+<td>
+ <p>
+ inf
+ </p>
+ </td>
+<td>
+ <p>
+ inf
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ quiet_NaN
+ </p>
+ </td>
+<td>
+ <p>
+ 1.#QNAN
+ </p>
+ </td>
+<td>
+ <p>
+ 1.#QNAN
+ </p>
+ </td>
+<td>
+ <p>
+ 1.#QNAN
+ </p>
+ </td>
+<td>
+ <p>
+ nan
+ </p>
+ </td>
+<td>
+ <p>
+ nan
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ signaling_NaN
+ </p>
+ </td>
+<td>
+ <p>
+ 1.#QNAN
+ </p>
+ </td>
+<td>
+ <p>
+ 1.#QNAN
+ </p>
+ </td>
+<td>
+ <p>
+ 1.#QNAN
+ </p>
+ </td>
+<td>
+ <p>
+ 0
+ </p>
+ </td>
+<td>
+ <p>
+ 0
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ denorm_min
+ </p>
+ </td>
+<td>
+ <p>
+ 1.4013e-045
+ </p>
+ </td>
+<td>
+ <p>
+ 4.94066e-324
+ </p>
+ </td>
+<td>
+ <p>
+ 4.94066e-324
+ </p>
+ </td>
+<td>
+ <p>
+ 0
+ </p>
+ </td>
+<td>
+ <p>
+ 0
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<br class="table-break">
+</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 &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
+ 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)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="functions.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../limits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="how_to_tell.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/lits.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/lits.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/lits.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -196,7 +196,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/misc.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/misc.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/misc.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -38,7 +38,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/misc/debug_adaptor.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/misc/debug_adaptor.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/misc/debug_adaptor.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -65,14 +65,14 @@
           <span class="special">&gt;</span></code>:
         </p>
 <p>
- <span class="inlinemediaobject"><img src="../../../../debugger1.png" alt="debugger1"></span>
+ <span class="inlinemediaobject"><img src="../../../../debugger1.png"></span>
         </p>
 <p>
           Otherwise you will need to expand out the view and look at the "debug_value"
           member:
         </p>
 <p>
- <span class="inlinemediaobject"><img src="../../../../debugger2.png" alt="debugger2"></span>
+ <span class="inlinemediaobject"><img src="../../../../debugger2.png"></span>
         </p>
 <p>
           It works for all the backend types equally too, here it is inspecting a
@@ -80,12 +80,12 @@
           <span class="special">&gt;</span></code>:
         </p>
 <p>
- <span class="inlinemediaobject"><img src="../../../../debugger3.png" alt="debugger3"></span>
+ <span class="inlinemediaobject"><img src="../../../../debugger3.png"></span>
         </p>
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/misc/logged_adaptor.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/misc/logged_adaptor.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/misc/logged_adaptor.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -89,8 +89,6 @@
           The following example demonstrates this technique in a trivial algorithm
           that deliberately introduces cancellation error:
         </p>
-<p>
-</p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">mpfi</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">logged_adaptor</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
@@ -140,13 +138,9 @@
 <span class="special">}</span>
 </pre>
 <p>
- </p>
-<p>
           When we examine program output we can clearly see that the diameter of
           the interval increases after each subtraction:
         </p>
-<p>
-</p>
 <pre class="programlisting"><span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="identifier">nan</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="identifier">Default</span> <span class="identifier">construct</span>
 <span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">0</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="identifier">Assignment</span> <span class="identifier">from</span> <span class="identifier">arithmetic</span> <span class="identifier">type</span>
 <span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">4.33681e-18</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">/=</span>
@@ -204,12 +198,10 @@
 <span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">0.296861</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">-=</span>
 <span class="identifier">Final</span> <span class="identifier">value</span> <span class="identifier">was</span><span class="special">:</span> <span class="special">{</span><span class="number">8.51569e-15</span><span class="special">,</span><span class="number">1.14843e-14</span><span class="special">}</span>
 </pre>
-<p>
- </p>
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/misc/visualizers.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/misc/visualizers.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/misc/visualizers.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -33,7 +33,7 @@
           partial solution in the shape of "visualizers" which provide
           improved views of complex data structures, these visualizers need to be
           added to the <code class="computeroutput"><span class="special">[</span><span class="identifier">Visualizer</span><span class="special">]</span></code> section of <code class="computeroutput"><span class="identifier">autoexp</span><span class="special">.</span><span class="identifier">dat</span></code>
- located in the <code class="computeroutput"><span class="identifier">Common7</span><span class="special">\</span><span class="identifier">Packages</span><span class="special">\</span><span class="identifier">Debugger</span></code>
+ located in the <code class="computeroutput"><span class="identifier">Common7</span><span class="special">/</span><span class="identifier">Packages</span><span class="special">/</span><span class="identifier">Debugger</span></code>
           directory of your Visual Studio installation. The actual visualizer code
           is in the sandbox here
           - just cut and paste the code into your <code class="computeroutput"><span class="identifier">autoexp</span><span class="special">.</span><span class="identifier">dat</span></code>
@@ -54,7 +54,7 @@
           The first visualizer provides improved views of <code class="computeroutput"><span class="identifier">debug_adaptor</span></code>:
         </p>
 <p>
- <span class="inlinemediaobject"><img src="../../../../debugger1.png" alt="debugger1"></span>
+ <span class="inlinemediaobject"><img src="../../../../debugger1.png"></span>
         </p>
 <p>
           The next visualizer provides improved views of cpp_int: small numbers are
@@ -65,20 +65,20 @@
           Here's what it looks like for small values:
         </p>
 <p>
- <span class="inlinemediaobject"><img src="../../../../debugger4.png" alt="debugger4"></span>
+ <span class="inlinemediaobject"><img src="../../../../debugger4.png"></span>
         </p>
 <p>
           And for larger values:
         </p>
 <p>
- <span class="inlinemediaobject"><img src="../../../../debugger5.png" alt="debugger5"></span>
+ <span class="inlinemediaobject"><img src="../../../../debugger5.png"></span>
         </p>
 <p>
           There is also a <code class="computeroutput"><span class="special">~</span><span class="identifier">raw</span></code>
           child member that lets you see the actual members of the class:
         </p>
 <p>
- <span class="inlinemediaobject"><img src="../../../../debugger6.png" alt="debugger6"></span>
+ <span class="inlinemediaobject"><img src="../../../../debugger6.png"></span>
         </p>
 <p>
           The visualizer for <code class="computeroutput"><span class="identifier">cpp_dec_float</span></code>
@@ -87,12 +87,12 @@
           data members:
         </p>
 <p>
- <span class="inlinemediaobject"><img src="../../../../debugger7.png" alt="debugger7"></span>
+ <span class="inlinemediaobject"><img src="../../../../debugger7.png"></span>
         </p>
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/mixed.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/mixed.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/mixed.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -43,7 +43,7 @@
 </ul></div>
 <h5>
 <a name="boost_multiprecision.tut.mixed.h0"></a>
- <span class="phrase"><a name="boost_multiprecision.tut.mixed.mixing_operands_of_differing_precision"></a></span><a class="link" href="mixed.html#boost_multiprecision.tut.mixed.mixing_operands_of_differing_precision">Mixing
+ <span class="phrase"><a name="boost_multiprecision.tut.mixed.mixing_operands_of_differing_pre"></a></span><a class="link" href="mixed.html#boost_multiprecision.tut.mixed.mixing_operands_of_differing_pre">Mixing
         Operands of Differing Precision</a>
       </h5>
 <p>
@@ -109,8 +109,6 @@
 <p>
         For example:
       </p>
-<p>
-</p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_int</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 
 <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>
@@ -133,22 +131,16 @@
 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hex</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">showbase</span> <span class="special">&lt;&lt;</span> <span class="identifier">multiply</span><span class="special">(</span><span class="identifier">ui256</span><span class="special">,</span> <span class="identifier">ui128</span><span class="special">,</span> <span class="identifier">ui128</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 </pre>
 <p>
- </p>
-<p>
         Produces the output:
       </p>
-<p>
-</p>
 <pre class="programlisting"><span class="number">0</span><span class="identifier">xffffffffffffffff</span>
 <span class="number">0</span><span class="identifier">x10000000000000000</span>
 <span class="number">0</span><span class="identifier">xFFFFFFFFFFFFFFFE0000000000000001</span>
 <span class="number">0</span><span class="identifier">xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE00000000000000000000000000000001</span>
 </pre>
-<p>
- </p>
 <h5>
 <a name="boost_multiprecision.tut.mixed.h2"></a>
- <span class="phrase"><a name="boost_multiprecision.tut.mixed.backends_with_optimized_mixed_precision_arithmetic"></a></span><a class="link" href="mixed.html#boost_multiprecision.tut.mixed.backends_with_optimized_mixed_precision_arithmetic">Backends
+ <span class="phrase"><a name="boost_multiprecision.tut.mixed.backends_with_optimized_mixed_pr"></a></span><a class="link" href="mixed.html#boost_multiprecision.tut.mixed.backends_with_optimized_mixed_pr">Backends
         With Optimized Mixed Precision Arithmetic</a>
       </h5>
 <p>
@@ -166,7 +158,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/primetest.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/primetest.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/primetest.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -60,8 +60,6 @@
         The following example searches for a prime <code class="computeroutput"><span class="identifier">p</span></code>
         for which <code class="computeroutput"><span class="special">(</span><span class="identifier">p</span><span class="special">-</span><span class="number">1</span><span class="special">)/</span><span class="number">2</span></code> is also probably prime:
       </p>
-<p>
-</p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_int</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">miller_rabin</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
@@ -99,12 +97,10 @@
    <span class="keyword">return</span> <span class="number">1</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-<p>
- </p>
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/random.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/random.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/random.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -39,8 +39,6 @@
 <p>
         Integers with <span class="emphasis"><em>N</em></span> random bits are generated using <code class="computeroutput"><span class="identifier">independent_bits_engine</span></code>:
       </p>
-<p>
-</p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">gmp</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">random</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 
@@ -61,14 +59,10 @@
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">gen</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 </pre>
 <p>
- </p>
-<p>
         Alternatively we can generate integers in a given range using <code class="computeroutput"><span class="identifier">uniform_int_distribution</span></code>, this will invoke
         the underlying engine multiple times to build up the required number of bits
         in the result:
       </p>
-<p>
-</p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">gmp</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">random</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 
@@ -90,16 +84,12 @@
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">ui</span><span class="special">(</span><span class="identifier">mt</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 </pre>
 <p>
- </p>
-<p>
         Floating point values in [0,1) are generated using <code class="computeroutput"><span class="identifier">uniform_01</span></code>,
         the trick here is to ensure that the underlying generator produces as many
         random bits as there are digits in the floating point type. As above <code class="computeroutput"><span class="identifier">independent_bits_engine</span></code> can be used for
         this purpose, note that we also have to convert decimal digits (in the floating
         point type) to bits (in the random number generator):
       </p>
-<p>
-</p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">gmp</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">random</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 
@@ -120,13 +110,9 @@
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">uf</span><span class="special">(</span><span class="identifier">gen</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 </pre>
 <p>
- </p>
-<p>
         Finally, we can modify the above example to produce numbers distributed according
         to some distribution:
       </p>
-<p>
-</p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">gmp</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">random</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 
@@ -147,12 +133,10 @@
 <span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">20</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">gd</span><span class="special">(</span><span class="identifier">gen</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 </pre>
-<p>
- </p>
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -247,7 +247,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational/br.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational/br.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational/br.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -37,7 +37,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational/cpp_rational.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational/cpp_rational.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational/cpp_rational.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -81,10 +81,8 @@
 </ul></div>
 <h6>
 <a name="boost_multiprecision.tut.rational.cpp_rational.h0"></a>
- <span class="phrase"><a name="boost_multiprecision.tut.rational.cpp_rational.example_"></a></span><a class="link" href="cpp_rational.html#boost_multiprecision.tut.rational.cpp_rational.example_">Example:</a>
+ <span class="phrase"><a name="boost_multiprecision.tut.rational.cpp_rational.example"></a></span><a class="link" href="cpp_rational.html#boost_multiprecision.tut.rational.cpp_rational.example">Example:</a>
         </h6>
-<p>
-</p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_int</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 
 <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>
@@ -103,12 +101,10 @@
 <span class="identifier">cpp_rational</span> <span class="identifier">w</span><span class="special">(</span><span class="number">2</span><span class="special">,</span> <span class="number">3</span><span class="special">);</span> <span class="comment">// component wise constructor</span>
 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">w</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// prints 2/3</span>
 </pre>
-<p>
- </p>
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational/gmp_rational.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational/gmp_rational.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational/gmp_rational.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -107,10 +107,8 @@
 </ul></div>
 <h6>
 <a name="boost_multiprecision.tut.rational.gmp_rational.h0"></a>
- <span class="phrase"><a name="boost_multiprecision.tut.rational.gmp_rational.example_"></a></span><a class="link" href="gmp_rational.html#boost_multiprecision.tut.rational.gmp_rational.example_">Example:</a>
+ <span class="phrase"><a name="boost_multiprecision.tut.rational.gmp_rational.example"></a></span><a class="link" href="gmp_rational.html#boost_multiprecision.tut.rational.gmp_rational.example">Example:</a>
         </h6>
-<p>
-</p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">gmp</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 
 <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>
@@ -134,12 +132,10 @@
 <span class="identifier">mpq_init</span><span class="special">(</span><span class="identifier">q</span><span class="special">);</span>
 <span class="identifier">mpq_set</span><span class="special">(</span><span class="identifier">q</span><span class="special">,</span> <span class="identifier">v</span><span class="special">.</span><span class="identifier">backend</span><span class="special">().</span><span class="identifier">data</span><span class="special">());</span>
 </pre>
-<p>
- </p>
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational/rational_adaptor.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational/rational_adaptor.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational/rational_adaptor.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -53,7 +53,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational/tommath_rational.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational/tommath_rational.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rational/tommath_rational.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -87,10 +87,8 @@
 </ul></div>
 <h6>
 <a name="boost_multiprecision.tut.rational.tommath_rational.h0"></a>
- <span class="phrase"><a name="boost_multiprecision.tut.rational.tommath_rational.example_"></a></span><a class="link" href="tommath_rational.html#boost_multiprecision.tut.rational.tommath_rational.example_">Example:</a>
+ <span class="phrase"><a name="boost_multiprecision.tut.rational.tommath_rational.example"></a></span><a class="link" href="tommath_rational.html#boost_multiprecision.tut.rational.tommath_rational.example">Example:</a>
         </h6>
-<p>
-</p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">tommath</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 
 <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>
@@ -109,12 +107,10 @@
 <span class="identifier">tom_rational</span> <span class="identifier">w</span><span class="special">(</span><span class="number">2</span><span class="special">,</span> <span class="number">3</span><span class="special">);</span> <span class="comment">// Component wise constructor</span>
 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">w</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// prints 2/3</span>
 </pre>
-<p>
- </p>
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Modified: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rounding.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rounding.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/rounding.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -177,7 +177,7 @@
 </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 &#169; 2002-2012 John Maddock and Christopher Kormanyos<p>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
         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)
       </p>

Added: trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/serial.html
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/libs/multiprecision/doc/html/boost_multiprecision/tut/serial.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -0,0 +1,63 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Boost.Serialization Support</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;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.html" title="Numeric Limits">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="gen_int.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="limits.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_multiprecision.tut.serial"></a><a class="link" href="serial.html" title="Boost.Serialization Support">Boost.Serialization
+ Support</a>
+</h3></div></div></div>
+<p>
+ Support for serialization comes in two forms:
+ </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+ Classes <a class="link" href="../ref/number.html" title="number">number</a>,
+ <a class="link" href="misc/debug_adaptor.html" title="debug_adaptor">debug_adaptor</a>,
+ <a class="link" href="misc/logged_adaptor.html" title="logged_adaptor">logged_adaptor</a>
+ and <a class="link" href="rational/rational_adaptor.html" title="rational_adaptor">rational_adaptor</a>
+ have "pass through" serialization support which requires the
+ underlying backend to be serializable.
+ </li>
+<li class="listitem">
+ Backends <a class="link" href="ints/cpp_int.html" title="cpp_int">cpp_int</a>,
+ <a class="link" href="floats/cpp_dec_float.html" title="cpp_dec_float">cpp_dec_float</a>
+ and <a class="link" href="floats/float128.html" title="float128">float128</a>
+ have full support for Boost.Serialization.
+ </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 &#169; 2002-2013 John Maddock and Christopher Kormanyos<p>
+ 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)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="gen_int.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="limits.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Modified: trunk/libs/multiprecision/doc/html/index.html
==============================================================================
--- trunk/libs/multiprecision/doc/html/index.html Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/html/index.html 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -28,7 +28,7 @@
 <div><div class="author"><h3 class="author">
 <span class="firstname">Christopher</span> <span class="surname">Kormanyos</span>
 </h3></div></div>
-<div><p class="copyright">Copyright &#169; 2002-2012 John Maddock and Christopher Kormanyos</p></div>
+<div><p class="copyright">Copyright &#169; 2002-2013 John Maddock and Christopher Kormanyos</p></div>
 <div><div class="legalnotice">
 <a name="boost_multiprecision.legal"></a><p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -55,6 +55,7 @@
 </dl></dd>
 <dt><span class="section">Floating Point Numbers</span></dt>
 <dd><dl>
+<dt><span class="section">cpp_bin_float</span></dt>
 <dt><span class="section">cpp_dec_float</span></dt>
 <dt><span class="section">gmp_float</span></dt>
 <dt><span class="section">mpfr_float</span></dt>
@@ -101,6 +102,18 @@
 <dt><span class="section">Generic Integer Operations</span></dt>
 <dt><span class="section"><a href="boost_multiprecision/tut/serial.html">Boost.Serialization
       Support</a></span></dt>
+<dt><span class="section">Numeric Limits</span></dt>
+<dd><dl>
+<dt><span class="section"><a href="boost_multiprecision/tut/limits/constants.html">std::numeric_limits&lt;&gt;
+ constants</a></span></dt>
+<dt><span class="section"><a href="boost_multiprecision/tut/limits/functions.html">std::numeric_limits&lt;&gt;
+ functions</a></span></dt>
+<dt><span class="section"><a href="boost_multiprecision/tut/limits/limits32.html">Numeric limits
+ for 32-bit platform</a></span></dt>
+<dt><span class="section"><a href="boost_multiprecision/tut/limits/how_to_tell.html">How to
+ Determine the Kind of a Number From <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code></a></span></dt>
+</dl></dd>
+<dt><span class="section">Input Output</span></dt>
 </dl></dd>
 <dt><span class="section">Reference</span></dt>
 <dd><dl>
@@ -110,6 +123,7 @@
 <dt><span class="section">tom_int</span></dt>
 <dt><span class="section">gmp_float</span></dt>
 <dt><span class="section">mpfr_float_backend</span></dt>
+<dt><span class="section">cpp_bin_float</span></dt>
 <dt><span class="section">cpp_dec_float</span></dt>
 <dt><span class="section"><a href="boost_multiprecision/ref/internals.html">Internal Support
       Code</a></span></dt>
@@ -120,7 +134,7 @@
 <dd><dl>
 <dt><span class="section"><a href="boost_multiprecision/perf/overhead.html">The Overhead in the
       Number Class Wrapper</a></span></dt>
-<dt><span class="section"><a href="boost_multiprecision/perf/realworld.html">Floating Point Real
+<dt><span class="section"><a href="boost_multiprecision/perf/realworld.html">Floating-Point Real
       World Tests</a></span></dt>
 <dt><span class="section"><a href="boost_multiprecision/perf/int_real_world.html">Integer Real
       World Tests</a></span></dt>
@@ -139,17 +153,11 @@
 <dt><span class="section">Acknowledgements</span></dt>
 </dl></dd>
 <dt><span class="section">Indexes</span></dt>
-<dd><dl>
-<dt><span class="section">Function Index</span></dt>
-<dt><span class="section">Class Index</span></dt>
-<dt><span class="section">Typedef Index</span></dt>
-<dt><span class="section">Index</span></dt>
-</dl></dd>
 </dl>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><p><small>Last revised: September 30, 2013 at 17:51:19 GMT</small></p></td>
+<td align="left"><p><small>Last revised: November 21, 2013 at 18:50:39 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>

Modified: trunk/libs/multiprecision/doc/multiprecision.qbk
==============================================================================
--- trunk/libs/multiprecision/doc/multiprecision.qbk Thu Nov 21 13:57:41 2013 (r86780)
+++ trunk/libs/multiprecision/doc/multiprecision.qbk 2013-11-21 14:05:42 EST (Thu, 21 Nov 2013) (r86781)
@@ -1,13 +1,16 @@
-[/
- Copyright 2011 John Maddock.
+[/
+ Copyright 2011, 2013 John Maddock.
+ Copyright 2013 Paul A. Bristow.
+ Copyright 2013 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).
 ]
 
 [library Boost.Multiprecision
- [quickbook 1.5]
- [copyright 2002-2012 John Maddock and Christopher Kormanyos]
+ [quickbook 1.7]
+ [copyright 2002-2013 John Maddock and Christopher Kormanyos]
     [purpose Multiprecision Number library]
     [license
          Distributed under the Boost Software License, Version 1.0.
@@ -18,18 +21,21 @@
     [/last-revision $Date: 2011-07-08 18:51:46 +0100 (Fri, 08 Jul 2011) $]
 ]
 
-[include html4_symbols.qbk]
+[import html4_symbols.qbk]
+
 [import ../example/gmp_snips.cpp]
 [import ../example/mpfr_snips.cpp]
 [import ../example/mpfi_snips.cpp]
 [import ../example/float128_snips.cpp]
 [import ../example/cpp_dec_float_snips.cpp]
+[import ../example/cpp_bin_float_snips.cpp]
 [import ../example/tommath_snips.cpp]
 [import ../example/cpp_int_snips.cpp]
 [import ../example/random_snips.cpp]
 [import ../example/safe_prime.cpp]
 [import ../example/mixed_integer_arithmetic.cpp]
 [import ../example/logged_adaptor.cpp]
+[import ../example/numeric_limits_snips.cpp]
 
 [template mpfr[] [@http://www.mpfr.org MPFR]]
 [template mpfi[] [@http://perso.ens-lyon.fr/nathalie.revol/software.html MPFI]]
@@ -59,6 +65,7 @@
 [def __gmp_float [link boost_multiprecision.tut.floats.gmp_float gmp_float]]
 [def __mpf_float [link boost_multiprecision.tut.floats.gmp_float gmp_float]]
 [def __mpfr_float_backend [link boost_multiprecision.tut.floats.mpfr_float mpfr_float]]
+[def __cpp_bin_float [link boost_multiprecision.tut.floats.cpp_bin_float cpp_bin_float]]
 [def __cpp_dec_float [link boost_multiprecision.tut.floats.cpp_dec_float cpp_dec_float]]
 [def __gmp_rational [link boost_multiprecision.tut.rational.gmp_rational gmp_rational]]
 [def __cpp_rational [link boost_multiprecision.tut.rational.cpp_rational cpp_rational]]
@@ -94,7 +101,7 @@
 its own collection of Boost-licensed, header-only back ends for
 integers, rationals and floats. In addition, user-defined back ends
 can be created and used with the interface of Multiprecision,
-provided the class implementation adheres to the necessary
+provided the class implementation adheres to the necessary
 [link boost_multiprecision.ref.backendconc concepts].
 
 Depending upon the number type, precision may be arbitrarily large
@@ -119,7 +126,8 @@
 __cpp_int for multiprecision integers, __cpp_dec_float for multiprecision floating point types
 and __cpp_rational for rational types.
 
-The library is often used via one of the predefined typedefs: for example if you wanted an [@http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic arbitrary precision]
+The library is often used via one of the predefined typedefs: for example if you wanted an
+[@http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic arbitrary precision]
 integer type using [gmp] as the underlying implementation then you could use:
 
    #include <boost/multiprecision/gmp.hpp> // Defines the wrappers around the GMP library's types
@@ -184,7 +192,7 @@
 
 On compilers that support rvalue-references, class `number` is move-enabled if the underlying backend is.
 
-In addition the non-expression template operator overloads (see below) are move aware and have overloads
+In addition the non-expression template operator overloads (see below) are move aware and have overloads
 that look something like:
 
    template <class B>
@@ -201,7 +209,7 @@
 Which don't noticeably benefit from move support. Therefore, optimal performance comes from having both
 move-support, and expression templates enabled.
 
-Note that while "moved-from" objects are left in a sane state, they have an unspecified value, and the only permitted
+Note that while "moved-from" objects are left in a sane state, they have an unspecified value, and the only permitted
 operations on them are destruction or the assignment of a new value. Any other operation should be considered
 a programming error and all of our backends will trigger an assertion if any other operation is attempted. This behavior
 allows for optimal performance on move-construction (i.e. no allocation required, we just take ownership of the existing
@@ -231,8 +239,8 @@
 is.
 
 The great advantage of this method is the ['elimination of temporaries]: for example the "naive" implementation
-of `operator*` above, requires one temporary for computing the result, and at least another one to return it. It's true
-that sometimes this overhead can be reduced by using move-semantics, but it can't be eliminated completely. For example,
+of `operator*` above, requires one temporary for computing the result, and at least another one to return it. It's true
+that sometimes this overhead can be reduced by using move-semantics, but it can't be eliminated completely. For example,
 lets suppose we're evaluating a polynomial via Horner's method, something like this:
 
     T a[7] = { /* some values */ };
@@ -243,8 +251,8 @@
 if we were using the [mpfr_class] C++ wrapper for [mpfr] - then this expression would result in no less than 11
 temporaries (this is true even though [mpfr_class] does use expression templates to reduce the number of temporaries somewhat). Had
 we used an even simpler wrapper around [mpfr] like [mpreal] things would have been even worse and no less that 24 temporaries
-are created for this simple expression (note - we actually measure the number of memory allocations performed rather than
-the number of temporaries directly, note also that the [mpf_class] wrapper that will be supplied with GMP-5.1 reduces the number of
+are created for this simple expression (note - we actually measure the number of memory allocations performed rather than
+the number of temporaries directly, note also that the [mpf_class] wrapper that will be supplied with GMP-5.1 reduces the number of
 temporaries to pretty much zero). Note that if we compile with expression templates disabled and rvalue-reference support
 on, then actually still have no wasted memory allocations as even though temporaries are created, their contents are moved
 rather than copied.
@@ -318,7 +326,7 @@
 unless you're absolutely sure that the lifetimes of `a`, `b` and `c` will outlive that of `my_expression`.
 
 And finally... the performance improvements from an expression template library like this are often not as
-dramatic as the reduction in number of temporaries would suggest. For example if we compare this library with
+dramatic as the reduction in number of temporaries would suggest. For example if we compare this library with
 [mpfr_class] and [mpreal], with all three using the underlying [mpfr] library at 50 decimal digits precision then
 we see the following typical results for polynomial execution:
 
@@ -329,7 +337,7 @@
 [[[mpreal]] [1.6 (0.0151s)] [9.3 (27947 total)]]
 ]
 
-As you can see, the execution time increases a lot more slowly than the number of memory allocations. There are
+As you can see, the execution time increases a lot more slowly than the number of memory allocations. There are
 a number of reasons for this:
 
 * The cost of extended-precision multiplication and division is so great, that the times taken for these tend to
@@ -351,7 +359,7 @@
 [table Evaluation of Boost.Math's Bessel function test data
 [[Library] [Relative Time] [Relative Number of Memory Allocations]]
 [[mpfr_float_50] [1.0 (5.78s)] [1.0 (1611963)]]
-[[number<mpfr_float_backend<50>, et_off>[br](but with rvalue reference support)]
+[[number<mpfr_float_backend<50>, et_off>[br](but with rvalue reference support)]
                                             [1.1 (6.29s)] [2.64 (4260868)]]
 [[[mpfr_class]] [1.1 (6.28s)] [2.45 (3948316)]]
 [[[mpreal]] [1.65 (9.54s)] [8.21 (13226029)]]
@@ -360,7 +368,7 @@
 [table Evaluation of Boost.Math's Non-Central T distribution test data
 [[Library][Relative Time][Relative Number of Memory Allocations]]
 [[number] [1.0 (263s)][1.0 (127710873)]]
-[[number<mpfr_float_backend<50>, et_off>[br](but with rvalue reference support)]
+[[number<mpfr_float_backend<50>, et_off>[br](but with rvalue reference support)]
                                             [1.0 (260s)][1.2 (156797871)]]
 [[[mpfr_class]] [1.1 (287s)][2.1 (268336640)]]
 [[[mpreal]] [1.5 (389s)][3.6 (466960653)]]
@@ -373,9 +381,9 @@
 
 [section:tut Tutorial]
 
-In order to use this library you need to make two choices:
+In order to use this library you need to make two choices:
 
-* What kind of number do I want ([link boost_multiprecision.tut.ints integer],
+* What kind of number do I want ([link boost_multiprecision.tut.ints integer],
 [link boost_multiprecision.tut.floats floating point] or [link boost_multiprecision.tut.rational rational]).
 * Which back-end do I want to perform the actual arithmetic (Boost-supplied, GMP, MPFR, Tommath etc)?
 
@@ -402,10 +410,10 @@
    enum cpp_integer_type { signed_magnitude, unsigned_magnitude };
    enum cpp_int_check_type { checked, unchecked };
 
- template <unsigned MinDigits = 0,
- unsigned MaxDits = 0,
- cpp_integer_type SignType = signed_magnitude,
- cpp_int_check_type Checked = unchecked,
+ template <unsigned MinDigits = 0,
+ unsigned MaxDits = 0,
+ cpp_integer_type SignType = signed_magnitude,
+ cpp_int_check_type Checked = unchecked,
              class Allocator = std::allocator<limb_type> >
    class cpp_int_backend;
    //
@@ -450,9 +458,9 @@
 
    }} // namespaces
 
-The `cpp_int_backend` type is normally used via one of the convenience typedefs given above.
+The `cpp_int_backend` type is normally used via one of the convenience typedefs given above.
 
-This back-end is the "Swiss Army Knife" of integer types as it can represent both fixed and
+This back-end is the "Swiss Army Knife" of integer types as it can represent both fixed and
 [@http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic arbitrary precision]
 integer types, and both signed and unsigned types. There are five template arguments:
 
@@ -467,7 +475,7 @@
            type `void`. Note that this parameter should not be used simply to prevent large memory
            allocations, not only is that role better performed by the allocator, but fixed precision
            integers have a tendency to allocate all of MaxBits of storage more often than one would expect.]]
-[[SignType][Determines whether the resulting type is signed or not. Note that for
+[[SignType][Determines whether the resulting type is signed or not. Note that for
 [@http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic arbitrary precision] types
           this parameter must be `signed_magnitude`. For fixed precision
           types then this type may be either `signed_magnitude` or `unsigned_magnitude`.]]
@@ -475,7 +483,7 @@
 [[Allocator][The allocator to use for dynamic memory allocation, or type `void` if MaxBits == MinBits.]]
 ]
 
-When the template parameter Checked is set to `checked` then the result is a ['checked-integer], checked
+When the template parameter Checked is set to `checked` then the result is a ['checked-integer], checked
 and unchecked integers have the following properties:
 
 [table
@@ -495,7 +503,7 @@
 * Default constructed `cpp_int_backend`s have the value zero.
 * Division by zero results in a `std::overflow_error` being thrown.
 * Construction from a string that contains invalid non-numeric characters results in a `std::runtime_error` being thrown.
-* Since the precision of `cpp_int_backend` is necessarily limited when the allocator parameter is void,
+* Since the precision of `cpp_int_backend` is necessarily limited when the allocator parameter is void,
 care should be taken to avoid numeric overflow when using this type
 unless you actually want modulo-arithmetic behavior.
 * The type uses a sign-magnitude representation internally, so type `int128_t` has 128-bits of precision plus an extra sign bit.
@@ -506,10 +514,10 @@
 is the most common format by far.
 * Attempting to print negative values as either an Octal or Hexadecimal string results in a `std::runtime_error` being thrown,
 this is a direct consequence of the sign-magnitude representation.
-* The fixed precision types `[checked_][u]intXXX_t` have expression template support turned off - it seems to make little
+* The fixed precision types `[checked_][u]intXXX_t` have expression template support turned off - it seems to make little
 difference to the performance of these types either way - so we may as well have the faster compile times by turning
 the feature off.
-* Unsigned types support subtraction - the result is "as if" a 2's complement operation had been performed as long as they are not
+* Unsigned types support subtraction - the result is "as if" a 2's complement operation had been performed as long as they are not
  ['checked-integers] (see above).
  In other words they behave pretty much as a built in integer type would in this situation. So for example if we were using
  `uint128_t` then `uint128_t(1)-4` would result in the value `0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD`
@@ -517,8 +525,8 @@
  been thrown.
 * Unary negation of unsigned types results in a compiler error (static assertion).
 * This backend supports rvalue-references and is move-aware, making instantiations of `number` on this backend move aware.
-* When used at fixed precision, the size of this type is always one machine word larger than you would expect for an N-bit integer:
-the extra word stores both the sign, and how many machine words in the integer are actually in use.
+* When used at fixed precision, the size of this type is always one machine word larger than you would expect for an N-bit integer:
+the extra word stores both the sign, and how many machine words in the integer are actually in use.
 The latter is an optimisation for larger fixed precision integers, so that a 1024-bit integer has almost the same performance
 characteristics as a 128-bit integer, rather than being 4 times slower for addition and 16 times slower for multiplication
  (assuming the values involved would always fit in 128 bits).
@@ -527,7 +535,7 @@
 the arithmetic could in fact be done with a narrower type.
 * When used at fixed precision and MaxBits is smaller than the number of bits in the largest native integer type, then
 internally `cpp_int_backend` switches to a "trivial" implementation where it is just a thin wrapper around a single
-integer. Note that it will still be slightly slower than a bare native integer, as it emulates a
+integer. Note that it will still be slightly slower than a bare native integer, as it emulates a
 signed-magnitude representation rather than simply using the platforms native sign representation: this ensures
 there is no step change in behavior as a cpp_int grows in size.
 * Fixed precision `cpp_int`'s have some support for `constexpr` values and user-defined literals, see
@@ -568,10 +576,10 @@
 * No changes are made to the GMP library's global settings - so you can safely mix this type with
 existing code that uses [gmp].
 * Default constructed `gmp_int`s have the value zero (this is GMP's default behavior).
-* Formatted IO for this type does not support octal or hexadecimal notation for negative values,
+* Formatted IO for this type does not support octal or hexadecimal notation for negative values,
 as a result performing formatted output on this type when the argument is negative and either of the flags
 `std::ios_base::oct` or `std::ios_base::hex` are set, will result in a `std::runtime_error` will be thrown.
-* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
+* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
 as a valid integer.
 * Division by zero results in a `std::overflow_error` being thrown.
 * Although this type is a wrapper around [gmp] it will work equally well with [mpir]. Indeed use of [mpir]
@@ -606,10 +614,10 @@
 rather strange beast as it's a signed type that is not a 2's complement type. As a result the bitwise operations
 `| & ^` will throw a `std::runtime_error` exception if either of the arguments is negative. Similarly the complement
 operator`~` is deliberately not implemented for this type.
-* Formatted IO for this type does not support octal or hexadecimal notation for negative values,
+* Formatted IO for this type does not support octal or hexadecimal notation for negative values,
 as a result performing formatted output on this type when the argument is negative and either of the flags
 `std::ios_base::oct` or `std::ios_base::hex` are set, will result in a `std::runtime_error` will be thrown.
-* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
+* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
 as a valid integer.
 * Division by zero results in a `std::overflow_error` being thrown.
 
@@ -641,12 +649,95 @@
 
 [table
 [[Backend Type][Header][Radix][Dependencies][Pros][Cons]]
+[[`cpp_bin_float<N>`][boost/multiprecision/cpp_bin_float.hpp][2][None][Header only, all C++ implementation. Boost licence.][Approximately 2x slower than the [mpfr] or [gmp] libraries.]]
 [[`cpp_dec_float<N>`][boost/multiprecision/cpp_dec_float.hpp][10][None][Header only, all C++ implementation. Boost licence.][Approximately 2x slower than the [mpfr] or [gmp] libraries.]]
 [[`mpf_float<N>`][boost/multiprecision/gmp.hpp][2][[gmp]][Very fast and efficient back-end.][Dependency on GNU licensed [gmp] library.]]
 [[`mpfr_float<N>`][boost/multiprecision/mpfr.hpp][2][[gmp] and [mpfr]][Very fast and efficient back-end, with its own standard library implementation.][Dependency on GNU licensed [gmp] and [mpfr] libraries.]]
 [[`float128`][boost/multiprecision/float128.hpp][2][Either [quadmath] or the Intel C++ Math library.][Very fast and efficient back-end for 128-bit floating point values (113-bit mantissa, equivalent to FORTRAN's QUAD real)][Depends on the compiler being either recent GCC or Intel C++ versions.]]
 ]
 
+[section:cpp_bin_float cpp_bin_float]
+
+`#include <boost/multiprecision/cpp_bin_float.hpp>`
+
+ 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
+
+The `cpp_bin_float` back-end is used in conjunction with `number`: 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 `cpp_bin_float` can be used at fixed precision by specifying a non-zero `Digits` template parameter.
+The typedefs `cpp_bin_float_50` and `cpp_bin_float_100` 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 `cpp_bin_float` with exactly the same precision as `double` one would use
+`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
+as stack space requirements can grow out of control. If that represents a problem then providing an allocator
+as a template parameter causes `cpp_bin_float` to dynamically allocate the memory it needs: this
+significantly reduces the size of `cpp_bin_float` 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 `void` `value_type`, for example:
+`number<cpp_bin_float<1000, digit_base_10, std::allocator<void> > >`.
+
+The final template parameters determine the type and range of the exponent: parameter `Exponent` can be
+any signed integer type, but note that `MinExponent` and `MaxExponent` can not go right up to the limits
+of the `Exponent` 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 `numeric_limits` support available for this type.
+
+Things you should know when using this type:
+
+* Default constructed `cpp_bin_float`s have a value of zero.
+* The radix of this type is 2, even when the precision is specified as decimal digits.
+* 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.
+* There is a `std::numeric_limits` specialisation for this type.
+* Any `number` instantiated on this type, is convertible to any other `number` instantiated on this type -
+for example you can convert from `number<cpp_bin_float<50> >` to `number<cpp_bin_float<SomeOtherValue> >`.
+Narrowing conversions round to nearest and are `explicit`.
+* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
+as a valid floating point number.
+* All arithmetic operations are correctly rounded to nearest. String comversions and the `sqrt` function
+are also correctly rounded, but transcendental functions (sin, cos, pow, exp etc) are not.
+
+[h5 cpp_bin_float example:]
+
+[cpp_bin_float_eg]
+
+[endsect]
+
 [section:cpp_dec_float cpp_dec_float]
 
 `#include <boost/multiprecision/cpp_dec_float.hpp>`
@@ -662,14 +753,14 @@
    }} // namespaces
 
 The `cpp_dec_float` back-end is used in conjunction with `number`: 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
+floating-point number type that is a drop-in replacement for the native C++ floating-point types, but with
 much greater precision.
 
-Type `cpp_dec_float` can be used at fixed precision by specifying a non-zero `Digits10` template parameter.
+Type `cpp_dec_float` can be used at fixed precision by specifying a non-zero `Digits10` template parameter.
 The typedefs `cpp_dec_float_50` and `cpp_dec_float_100` provide arithmetic types at 50 and 100 decimal digits precision
 respectively. Optionally, you can specify an integer type to use for the exponent, this defaults to a 32-bit integer type
 which is more than large enough for the vast majority of use cases, but larger types such as `long long` can also be specified
-if you need a truly huge exponent range. In any case the ExponentType must be a built in signed integer type at least 2 bytes
+if you need a truly huge exponent range. In any case the ExponentType must be a built in signed integer type at least 2 bytes
 and 16-bits wide.
 
 Normally `cpp_dec_float` allocates no memory: all of the space required for its digits are allocated
@@ -691,15 +782,15 @@
 * 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.
 * There is a `std::numeric_limits` specialisation for this type.
-* Any `number` instantiated on this type, is convertible to any other `number` instantiated on this type -
+* Any `number` instantiated on this type, is convertible to any other `number` instantiated on this type -
 for example you can convert from `number<cpp_dec_float<50> >` to `number<cpp_dec_float<SomeOtherValue> >`.
 Narrowing conversions are truncating and `explicit`.
 * Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
 as a valid floating point number.
 * The actual precision of a `cpp_dec_float` is always slightly higher than the number of digits specified in
-the template parameter, actually how much higher is an implementation detail but is always at least 8 decimal
+the template parameter, actually how much higher is an implementation detail but is always at least 8 decimal
 digits.
-* Operations involving `cpp_dec_float` are always truncating. However, note that since their are guard digits
+* Operations involving `cpp_dec_float` are always truncating. However, note that since their are guard digits
 in effect, in practice this has no real impact on accuracy for most use cases.
 
 [h5 cpp_dec_float example:]
@@ -726,7 +817,7 @@
    }} // namespaces
 
 The `gmp_float` back-end is used in conjunction with `number` : it acts as a thin wrapper around the [gmp] `mpf_t`
-to provide an real-number type that is a drop-in replacement for the native C++ floating-point types, but with
+to provide an real-number type that is a drop-in replacement for the native C++ floating-point types, but with
 much greater precision.
 
 Type `gmp_float` can be used at fixed precision by specifying a non-zero `Digits10` template parameter, or
@@ -754,13 +845,13 @@
 * It is not possible to round-trip objects of this type to and from a string and get back
 exactly the same value. This appears to be a limitation of [gmp].
 * Since the underlying [gmp] types have no notion of infinities or NaN's, care should be taken
-to avoid numeric overflow or division by zero. That latter will result in a std::overflow_error being thrown,
+to avoid numeric overflow or division by zero. That latter will result in a std::overflow_error being thrown,
 while generating excessively large exponents may result in instability of the underlying [gmp]
-library (in testing, converting a number with an excessively large or small exponent
+library (in testing, converting a number with an excessively large or small exponent
 to a string caused [gmp] to segfault).
 * This type can equally be used with [mpir] as the underlying implementation - indeed that is
 the recommended option on Win32.
-* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
+* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
 as a valid floating point number.
 * Division by zero results in a `std::overflow_error` being thrown.
 
@@ -797,7 +888,7 @@
    }} // namespaces
 
 The `mpfr_float_backend` type is used in conjunction with `number`: It acts as a thin wrapper around the [mpfr] `mpfr_t`
-to provide an real-number type that is a drop-in replacement for the native C++ floating-point types, but with
+to provide an real-number type that is a drop-in replacement for the native C++ floating-point types, but with
 much greater precision.
 
 Type `mpfr_float_backend` can be used at fixed precision by specifying a non-zero `Digits10` template parameter, or
@@ -813,7 +904,7 @@
 expense of growing the size of `mpfr_float_backend`. It can only be used at fixed precision, and
 should only be used for lower digit counts. Note that we can not guarantee that using `allocate_stack`
 won't cause any calls to mpfr's allocation routines, as mpfr may call these inside it's own code.
-The following table gives an idea of the performance tradeoff's at 50 decimal digits
+The following table gives an idea of the performance tradeoff's at 50 decimal digits
 precision[footnote Compiled with VC++10 and /Ox, with MPFR-3.0.0 and MPIR-2.3.0]:
 
 [table
@@ -843,7 +934,7 @@
 [mpfr] or [gmp] code.
 * The code can equally use [mpir] in place of [gmp] - indeed that is the preferred option on Win32.
 * This backend supports rvalue-references and is move-aware, making instantiations of `number` on this backend move aware.
-* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
+* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
 as a valid floating point number.
 * Division by zero results in an infinity.
 
@@ -866,17 +957,17 @@
    }} // namespaces
 
 The `float128` number type is a very thin wrapper around GCC's `__float128` or Intel's `_Quad` data types
-and provides an real-number type that is a drop-in replacement for the native C++ floating-point types, but with
+and provides an real-number type that is a drop-in replacement for the native C++ floating-point types, but with
 a 113 bit mantissa, and compatible with FORTRAN's 128-bit QUAD real.
 
 All the usual standard library and `numeric_limits` support are available, performance should be equivalent
-to the underlying native types: for example the LINPACK benchmarks for GCC's `__float128` and
+to the underlying native types: for example the LINPACK benchmarks for GCC's `__float128` and
 `boost::multiprecision::float128` both achieved 5.6 MFLOPS[footnote On 64-bit Ubuntu 11.10, GCC-4.8.0, Intel Core 2 Duo T5800.].
 
 As well as the usual conversions from arithmetic and string types, instances of `float128` are
 copy constructible and assignable from GCC's `__float128` and Intel's `_Quad` data types.
 
-It's also possible to access the underlying `__float128` or `_Quad` type via the `data()` member
+It's also possible to access the underlying `__float128` or `_Quad` type via the `data()` member
 function of `float128_backend`.
 
 Things you should know when using this type:
@@ -965,7 +1056,7 @@
    }} // namespaces
 
 The `mpfi_float_backend` type is used in conjunction with `number`: It acts as a thin wrapper around the [mpfi] `mpfi_t`
-to provide an real-number type that is a drop-in replacement for the native C++ floating-point types, but with
+to provide an real-number type that is a drop-in replacement for the native C++ floating-point types, but with
 much greater precision and implementing interval arithmetic.
 
 Type `mpfi_float_backend` can be used at fixed precision by specifying a non-zero `Digits10` template parameter, or
@@ -992,83 +1083,83 @@
 [mpfr] or [gmp] code.
 * The code can equally use [mpir] in place of [gmp] - indeed that is the preferred option on Win32.
 * This backend supports rvalue-references and is move-aware, making instantiations of `number` on this backend move aware.
-* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
+* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
 as a valid floating point number.
 * Division by zero results in an infinity.
 
 There are some additional non member functions for working on intervals:
 
- template <unsigned Digits10, expression_template_option ExpressionTemplates>
- number<mpfr_float_backend<Digits10>, ExpressionTemplates> lower(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& val);
+ template <unsigned Digits10, expression_template_option ExpressionTemplates>
+ number<mpfr_float_backend<Digits10>, ExpressionTemplates> lower(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& val);
 
 Returns the lower end of the interval.
 
- template <unsigned Digits10, expression_template_option ExpressionTemplates>
- number<mpfr_float_backend<Digits10>, ExpressionTemplates> upper(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& val);
+ template <unsigned Digits10, expression_template_option ExpressionTemplates>
+ number<mpfr_float_backend<Digits10>, ExpressionTemplates> upper(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& val);
 
 Returns the upper end of the interval.
 
- template <unsigned Digits10, expression_template_option ExpressionTemplates>
- number<mpfr_float_backend<Digits10>, ExpressionTemplates> median(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& val);
+ template <unsigned Digits10, expression_template_option ExpressionTemplates>
+ number<mpfr_float_backend<Digits10>, ExpressionTemplates> median(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& val);
 
 Returns the mid point of the interval.
 
- template <unsigned Digits10, expression_template_option ExpressionTemplates>
- number<mpfr_float_backend<Digits10>, ExpressionTemplates> width(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& val);
+ template <unsigned Digits10, expression_template_option ExpressionTemplates>
+ number<mpfr_float_backend<Digits10>, ExpressionTemplates> width(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& val);
 
 Returns the absolute width of the interval.
 
- template <unsigned Digits10, expression_template_option ExpressionTemplates>
- number<mpfi_float_backend<Digits10>, ExpressionTemplates> intersect(
- const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a,
- const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& b);
+ template <unsigned Digits10, expression_template_option ExpressionTemplates>
+ number<mpfi_float_backend<Digits10>, ExpressionTemplates> intersect(
+ const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a,
+ const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& b);
 
-Returns the interval which is the intersection of the ['a] and ['b]. Returns an
+Returns the interval which is the intersection of the ['a] and ['b]. Returns an
 unspecified empty interval if there is no such intersection.
 
- template <unsigned Digits10, expression_template_option ExpressionTemplates>
- number<mpfi_float_backend<Digits10>, ExpressionTemplates> hull(
- const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a,
- const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& b);
+ template <unsigned Digits10, expression_template_option ExpressionTemplates>
+ number<mpfi_float_backend<Digits10>, ExpressionTemplates> hull(
+ const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a,
+ const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& b);
 
 Returns the interval which is the union of ['a] and ['b].
 
- template <unsigned Digits10, expression_template_option ExpressionTemplates>
- bool overlap(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a,
- const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& b);
+ template <unsigned Digits10, expression_template_option ExpressionTemplates>
+ bool overlap(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a,
+ const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& b);
 
 Returns `true` only if the intervals ['a] and ['b] overlap.
 
- template <unsigned Digits10, expression_template_option ExpressionTemplates1, expression_template_option ExpressionTemplates2>
- bool in(const number<mpfr_float_backend<Digits10>, ExpressionTemplates1>& a,
- const number<mpfi_float_backend<Digits10>, ExpressionTemplates2>& b);
+ template <unsigned Digits10, expression_template_option ExpressionTemplates1, expression_template_option ExpressionTemplates2>
+ bool in(const number<mpfr_float_backend<Digits10>, ExpressionTemplates1>& a,
+ const number<mpfi_float_backend<Digits10>, ExpressionTemplates2>& b);
 
 Returns `true` only if point ['a] is contained within the interval ['b].
 
- template <unsigned Digits10, expression_template_option ExpressionTemplates>
- bool zero_in(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a);
+ template <unsigned Digits10, expression_template_option ExpressionTemplates>
+ bool zero_in(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a);
 
 Returns `true` only if the interval ['a] contains the value zero.
 
- template <unsigned Digits10, expression_template_option ExpressionTemplates>
- bool subset(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a,
- const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& b);
+ template <unsigned Digits10, expression_template_option ExpressionTemplates>
+ bool subset(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a,
+ const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& b);
 
 Returns `true` only if ['a] is a subset of ['b].
 
- template <unsigned Digits10, expression_template_option ExpressionTemplates>
- bool proper_subset(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a,
- const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& b);
+ template <unsigned Digits10, expression_template_option ExpressionTemplates>
+ bool proper_subset(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a,
+ const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& b);
 
 Returns `true` only if ['a] is a proper subset of ['b].
 
- template <unsigned Digits10, expression_template_option ExpressionTemplates>
- bool empty(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a);
+ template <unsigned Digits10, expression_template_option ExpressionTemplates>
+ bool empty(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a);
 
 Returns `true` only if ['a] is an empty interval, equivalent to `upper(a) < lower(a)`.
 
- template <unsigned Digits10, expression_template_option ExpressionTemplates>
- bool singleton(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a);
+ template <unsigned Digits10, expression_template_option ExpressionTemplates>
+ bool singleton(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a);
 
 Returns `true` if `lower(a) == upper(a)`.
 
@@ -1192,7 +1283,7 @@
 
    }} // namespaces
 
-The `tommath_rational` back-end is used via the typedef `boost::multiprecision::tom_rational`. It acts as a thin wrapper around
+The `tommath_rational` back-end is used via the typedef `boost::multiprecision::tom_rational`. It acts as a thin wrapper around
 `boost::rational<tom_int>`
 to provide a rational number type that is a drop-in replacement for the native C++ number types, but with unlimited precision.
 
@@ -1234,7 +1325,7 @@
 
    namespace boost{ namespace multiprecision{
 
- template <class IntBackend>
+ template <class IntBackend>
    class rational_adpater;
 
    }}
@@ -1285,7 +1376,7 @@
 
    }} // namespaces
 
-The `logged_adaptor` type is used in conjunction with `number` and some other backend type: it acts as a thin wrapper around
+The `logged_adaptor` type is used in conjunction with `number` and some other backend type: it acts as a thin wrapper around
 some other backend to class `number` and logs all the events that take place on that object. Before any number operation takes
 place, it calls `log_prefix_event` with the arguments to the operation (up to 4), plus a string describing the operation.
 Then after the operation it calls `log_postfix_event` with the result of the operation, plus a string describing the operation.
@@ -1323,7 +1414,7 @@
 
    }} // namespaces
 
-The `debug_adaptor` type is used in conjunction with `number` and some other backend type: it acts as a thin wrapper around
+The `debug_adaptor` type is used in conjunction with `number` and some other backend type: it acts as a thin wrapper around
 some other backend to class `number` and intercepts all operations on that object storing the result as a string within itself.
 
 This type provides `numeric_limits` support whenever the template argument Backend does so.
@@ -1354,8 +1445,8 @@
 
 Let's face it debugger multiprecision numbers is hard - simply because we can't easily inspect the value of the numbers.
 Visual C++ provides a partial solution in the shape of "visualizers" which provide improved views of complex data structures,
-these visualizers need to be added to the `[Visualizer]` section of `autoexp.dat` located in the `Common7\Packages\Debugger`
-directory of your Visual Studio installation. The actual visualizer code is in the sandbox
+these visualizers need to be added to the `[Visualizer]` section of `autoexp.dat` located in the `Common7/Packages/Debugger`
+directory of your Visual Studio installation. The actual visualizer code is in the sandbox
 [@https://svn.boost.org/svn/boost/sandbox/boost_docs/subprojects/DebuggerVisualizers/multiprecision.vis.txt here] - just cut and paste the code
 into your `autoexp.dat` file.
 
@@ -1367,7 +1458,7 @@
 [$../debugger1.png]
 
 The next visualizer provides improved views of cpp_int: small numbers are displayed as actual values, while larger numbers are
-displayed as an array of hexadecimal parts, with the most significant part first.
+displayed as an array of hexadecimal parts, with the most significant part first.
 
 Here's what it looks like for small values:
 
@@ -1418,7 +1509,7 @@
 
 Additional conversions may be supported by particular backends.
 
-* A `number` can be converted to any built in type, via an explicit conversion operator:
+* A `number` can be converted to any built in type, via an explicit conversion operator:
 this functionality is only available on compilers supporting C++11's explicit conversion syntax.
 
    mpz_int z(2);
@@ -1452,7 +1543,7 @@
    i *= 3.14; // Error, no *= operator will be found.
 
 * Any number type can be streamed to and from the C++ iostreams:
-
+
 
    cpp_dec_float_50 df = "3.14159265358979323846264338327950288419716939937510";
    // Now print at full precision:
@@ -1473,7 +1564,7 @@
 
    mpz_int z = 0;
    mpf_float f = z; // OK, GMP handles this conversion natively, and it's not lossy and therefore implicit
-
+
    mpf_float_50 f50 = 2;
    f = f50; // OK, conversion from fixed to variable precision, f will have 50 digits precision.
    f50 = f; // Error, conversion from variable to fixed precision is potentially lossy, explicit cast required.
@@ -1481,7 +1572,7 @@
 * Some interconversions between number types are completely generic, and are always available, albeit the conversions are always ['explicit]:
 
    cpp_int cppi(2);
- // We can always convert between numbers of the same category -
+ // We can always convert between numbers of the same category -
    // int to int, rational to rational, or float to float, so this is OK
    // as long as we use an explicit conversion:
    mpz_int z(cppi);
@@ -1554,8 +1645,8 @@
 Knuth Vol 2, which recommends 25 trials for a pretty strong likelihood that /n/ is prime.
 
 The third optional argument is for a Uniform Random Number Generator from Boost.Random. When not provided the `mt19937`
-generator is used. Note that when producing random primes then you should probably use a different random number generator
-to produce candidate prime numbers for testing, than is used internally by `miller_rabin_test` for determining
+generator is used. Note that when producing random primes then you should probably use a different random number generator
+to produce candidate prime numbers for testing, than is used internally by `miller_rabin_test` for determining
 whether the value is prime. It also helps of course to seed the generators with some source of randomness.
 
 The following example searches for a prime `p` for which `(p-1)/2` is also probably prime:
@@ -1566,19 +1657,19 @@
 
 [section:lits Literal Types and `constexpr` Support]
 
-[note The features described in this section make heavy use of C++11 language features, currently
+[note The features described in this section make heavy use of C++11 language features, currently
 (as of May 2013) only
 GCC-4.7 and later, and Clang 3.3 and later have the support required to make these features work.]
 
-There is limited support for `constexpr` and user-defined literals in the library, currently the
+There is limited support for `constexpr` and user-defined literals in the library, currently the
 `number` front end supports `constexpr`
-on default construction and all forwarding constructors, but not on any of the non-member operators. So if
-some type `B` is a literal type, then `number<B>` is also a literal type, and you will be able to
+on default construction and all forwarding constructors, but not on any of the non-member operators. So if
+some type `B` is a literal type, then `number<B>` is also a literal type, and you will be able to
 compile-time-construct such a type from any literal that `B` is compile-time-constructible from.
 However, you will not be able to perform compile-time arithmetic on such types.
 
 Currently the only backend type provided by the library that is also a literal type are instantiations
-of `cpp_int_backend` where the Allocator parameter is type `void`, and the Checked parameter is
+of `cpp_int_backend` where the Allocator parameter is type `void`, and the Checked parameter is
 `boost::multiprecision::unchecked`.
 
 For example:
@@ -1681,7 +1772,7 @@
 
 [section:mixed Mixed Precision Arithmetic]
 
-Mixed precision arithmetic is fully supported by the library.
+Mixed precision arithmetic is fully supported by the library.
 
 There are two different forms:
 
@@ -1710,7 +1801,7 @@
 
 [h4 Operands of the Same Precision]
 
-Sometimes you want to apply an operator to two arguments of the same precision in
+Sometimes you want to apply an operator to two arguments of the same precision in
 such a way as to obtain a result of higher precision. The most common situation
 occurs with fixed precision integers, where you want to multiply two N-bit numbers
 to obtain a 2N-bit result. This is supported in this library by the following
@@ -1726,7 +1817,7 @@
    ResultType& multiply(ResultType& result, const Source1& a, const Source2& b);
 
 These functions apply the named operator to the arguments ['a] and ['b] and store the
-result in ['result], returning ['result]. In all cases they behave "as if"
+result in ['result], returning ['result]. In all cases they behave "as if"
 arguments ['a] and ['b] were first promoted to type `ResultType` before applying the
 operator, though particular backends may well avoid that step by way of an optimization.
 
@@ -1744,9 +1835,9 @@
 
 [h4 Backends With Optimized Mixed Precision Arithmetic]
 
-The following backends have at least some direct support for mixed precision arithmetic,
+The following backends have at least some direct support for mixed precision arithmetic,
 and therefore avoid creating unnecessary temporaries when using the interfaces above.
-Therefore when using these types it's more efficient to use mixed precision arithmetic,
+Therefore when using these types it's more efficient to use mixed precision arithmetic,
 than it is to explicitly cast the operands to the result type:
 
 __mpfr_float_backend, __mpf_float, __cpp_int.
@@ -1755,7 +1846,7 @@
 
 [section:gen_int Generic Integer Operations]
 
-All of the [link boost_multiprecision.ref.number.integer_functions non-member integer operations] are overloaded for the
+All of the [link boost_multiprecision.ref.number.integer_functions non-member integer operations] are overloaded for the
 built in integer types in
 `<boost/multiprecision/integer.hpp>`.
 Where these operations require a temporary increase in precision (such as for powm), then
@@ -1862,6 +1953,861 @@
 
 [endsect]
 
+[section:limits Numeric Limits]
+
+Boost.Multiprecision tries hard to implement `std::numeric_limits` for all types
+as far as possible and meaningful because experience with Boost.Math
+has shown that this aids portability.
+
+The [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3690.pdf C++ standard library]
+defines `std::numeric_limits` in section 18.3.2.
+
+This in turn refers to the C standard
+[@http://www.open-std.org/jtc1/sc22/wg11/docs/n507.pdf SC22/WG11 N507 DRAFT INTERNATIONAL ISO/IEC STANDARD
+ WD 10967-1]
+Information technology Language independent arithmetic Part 1: Integer and Floating point arithmetic.
+
+That C Standard in turn refers to
+
+[@http://754r.ucbtest.org/standards/754.pdf IEEE754 IEEE Standard for Binary
+Floating-Point Arithmetic]
+
+There is a useful summary at
+[@http://www.cplusplus.com/reference/limits/numeric_limits/ C++ reference].
+
+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
+the values in the tables given below.
+
+[warning GMP's `mpf_t` 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).]
+
+[section:constants std::numeric_limits<> constants]
+
+
+[h4 is_specialized]
+
+`true` for all arithmetic types (integer, floating and fixed-point)
+for which `std::numeric_limits<T>::numeric_limits` is specialized.
+
+A typical test is
+
+ if (std::numeric_limits<T>::is_specialized == false)
+ {
+ std::cout << "type " << typeid(T).name() << " is not specialized for std::numeric_limits!" << std::endl;
+ // ...
+ }
+
+Typically `numeric_limits<T>::is_specialized` is `true` for all `T` where the compile-time constant
+members of `numeric_limits` are indeed known at compile time, and don't vary at runtime. For example
+floating point types with runtime-variable precision such as `mpfr_float` have no `numeric_limits`
+specialization as it would be impossible to define all the members at compile time. In contrast
+the precision of a type such as `mpfr_float_50` is known at compile time, and so it ['does] have a
+`numeric_limits` specialization.
+
+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.
+
+[h4 infinity]
+
+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.
+
+A typical test whether infinity is implemented is
+
+ if(std::numeric_limits<T>::has_infinity)
+ {
+ std::cout << std::numeric_limits<T>::infinity() << std::endl;
+ }
+
+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.
+
+[h4 is_signed]
+
+`std::numeric_limits<T>::is_signed == true` if the type `T` 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 `bool`.
+
+[h4 is_exact]
+
+`std::numeric_limits<T>::is_exact == true` if type T uses exact representations.
+
+This is defined as `true` for all integer types and `false` for floating-point types.
+
+[@http://stackoverflow.com/questions/14203654/stdnumeric-limitsis-exact-what-is-a-usable-definition A usable definition]
+has been discussed.
+
+ISO/IEC 10967-1, Language independent arithmetic, noted by the C++ Standard defines
+
+ A floating point type F shall be a finite subset of [real].
+
+The important practical distinction is that all integers (up to `max()`) can be stored exactly.
+
+[@http://en.wikipedia.org/wiki/Rational_number Rational]
+types using two integer types are also exact.
+
+Floating-point types [*cannot store all real values]
+(those in the set of [real]) [*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
+[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3407.html
+add Decimal Floating Point Support to C++].
+
+[@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2849.pdf Decimal TR].
+
+And also
+[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3352.html
+C++ Binary Fixed-Point Arithmetic].
+
+[h4 is_bounded]
+
+`std::numeric_limits<T>::is_bounded == true` if the set of values represented by the type `T` is finite.
+
+This is `true` for all built-in integer, fixed and floating-point types,
+and most multi-precision types.
+
+It is only `false` for a few __arbitrary_precision types like `cpp_int`.
+
+Rational and fixed-exponent representations are exact but not integer.
+
+[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.
+
+`is_modulo == true` means that the type does not overflow, but, for example,
+'wraps around' to zero, when adding one to the `max()` value.
+
+For most built-in integer types, `std::numeric_limits<>::is_modulo` is `true`.
+
+`bool` is the only exception.
+
+The modulo behaviour is sometimes useful,
+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 `cpp_int` is not modulo
+because as an __arbitrary_precision types,
+it expands to hold any value that the machine resources permit.
+
+However fixed precision __cpp_int'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 `std::numeric_limits<>::infinity()`,
+provided `std::numeric_limits<>::has_infinity == true`.
+
+[h4 radix]
+
+Constant `std::numeric_limits<T>::radix` returns either 2 (for built-in and binary types)
+or 10 (for decimal types).
+
+[h4 digits]
+
+The number of `radix` digits that be represented without change:
+
+* for integer types, the number of [*non-sign bits] in the significand.
+* for floating types, the number of [*radix digits] in the significand.
+
+The values include any implicit bit, so for example, for the ubiquious
+`double` using 64 bits
+([@http://en.wikipedia.org/wiki/Double_precision_floating-point_format IEEE binary64 ]),
+`digits` == 53, even though there are only 52 actual bits of the significand stored in the representation.
+The value of `digits` 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
+`digits` member reflects exactly how many bits of precision were requested:
+
+ 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.
+
+For the most common case of `radix == 2`,
+`std::numeric_limits<T>::digits` is the number of bits in the representation,
+not counting any sign bit.
+
+For a decimal integer type, when `radix == 10`, it is the number of decimal digits.
+
+[h4 digits10]
+
+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.
+
+This somewhat inscrutable definition means that an `unsigned char`
+can hold decimal values `0..99`
+without loss of precision or accuracy, usually from truncation.
+
+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.
+
+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
+
+[digits10_1]
+
+For example, `unsigned short` is often stored in 16 bits,
+so the maximum value is 0xFFFF or 65535.
+
+[digits10_2]
+
+
+For bounded floating-point types,
+if we create a `double` with a value with `digits10` (usually 15) decimal digits,
+`1e15` or `1000000000000000` :
+
+[digits10_3]
+
+and we can increment this value to `1000000000000001`
+as expected and show the difference too.
+
+But if we try to repeat this with more than `digits10` digits,
+
+[digits10_4]
+
+then we find that when we add one it has no effect,
+and display show that there is loss of precision. See
+[@http://en.wikipedia.org/wiki/Loss_of_significance Loss of significance or cancellation error].
+
+So `digits10` is the number of decimal digits [*guaranteed] to be correct.
+
+For example, 'round-tripping' for `double`:
+
+* If a decimal string with at most `digits10`( == 15) significant decimal digits
+is converted to `double` and then converted back to the
+same number of significant decimal digits,
+then the final string will match the original 15 decimal digit string.
+* If a `double` floating-point number is converted to a decimal string
+with at least 17 decimal digits
+and then converted back to `double`,
+then the result will be binary indentical to the original `double` value.
+
+For most purposes, you will much more likely want
+`std::numeric_limits<>::max_digits10`,
+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, `max_digits10` is `digits10+2`,
+but you should use `max_digits10` where possible.
+
+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]
+
+ max_digits10 = std::numeric_limits<T>::digits * 3010U/10000U;
+
+The factor is log[sub 10](2) = 0.3010
+but must be evaluated at compile time using only integers.
+
+(See also
+[@http://www.loria.fr/~zimmerma/mca/mca-cup-0.5.9.pdf Richard P. Brent and Paul Zimmerman, Modern Computer Arithmetic]
+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 `os.precision(std::numeric_limits<T>::max_digits10)`.
+For at least one popular compiler, you must also use `std::scientific` format.
+
+[h4 max_digits10]
+
+`std::numeric_limits<T>::max_digits10` was added for floating-point
+because `digits10` decimal digits are insufficient to show
+a least significant bit (ULP) change giving puzzling displays like
+
+ 0.666666666666667 != 0.666666666666667
+
+from failure to 'round-trip', for example:
+
+[max_digits10_2]
+
+If you wish to ensure that a change of one least significant bit (ULP)
+produces a different decimal digits string,
+then `max_digits10` is the precision to use.
+
+For example:
+
+[max_digits10_3]
+
+will display [pi] to the maximum possible precision using a `double`.
+
+[max_digits10_4]
+
+For integer types, `max_digits10` is implementation-dependant,
+but is usually `digits10 + 2`.
+This is the output field width required for the maximum value of the type T
+`std::numeric_limits<T>::max()` including a sign and a space.
+
+So this will produce neat columns.
+
+ std::cout << std::setw(std::numeric_limits<int>::max_digits10) ...
+
+[note For Microsoft Visual Studio 2010,
+`std::numeric_limits<float>::max_digits10` is wrongly defined as 8. It should be 9.]
+
+[note 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 `<< std::scientific`.]
+
+[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].
+See above.]
+
+[max_digits10_1] [/ example for using max_digits10]
+
+[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.
+Various rounding modes may be provided:
+
+* round to nearest up or down (default for floating-point types).
+* round up (toward positive infinity).
+* round down (toward negative infinity).
+* round toward zero (integer types).
+* no rounding (if decimal radix).
+* rounding mode is not determinable.
+
+For integer types, `std::numeric_limits<T>::round_style` is always towards zero, so
+
+ std::numeric_limits<T>::round_style == std::round_to_zero;
+
+A decimal type, `cpp_dec_float` 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.
+
+ std::numeric_limits<T>::round_style == std::round_to_nearest;
+
+See function `std::numeric_limits<T>::round_error` for the maximum error (in ULP)
+that rounding can cause.
+
+[h4 has_denorm_loss]
+
+`true` if a loss of precision is detected as a
+[@http://en.wikipedia.org/wiki/Denormalization denormalization] loss,
+rather than an inexact result.
+
+Always `false` for integer types.
+
+`false` for all types which do not have `has_denorm` == `std::denorm_present`.
+
+[h4 denorm_style]
+
+[@http://en.wikipedia.org/wiki/Denormal_number Denormalized values] are
+representations with a variable number of exponent bits that can permit
+gradual underflow, so that, if type T is `double`.
+
+ std::numeric_limits<T>::denorm_min() < std::numeric_limits<T>::min()
+
+A type may have any of the following `enum float_denorm_style` values:
+
+* `std::denorm_absent`, if it does not allow denormalized values.
+(Always used for all integer and exact types).
+* `std::denorm_present`, if the floating-point type allows denormalized values.
+*`std::denorm_indeterminate`, if indeterminate at compile time.
+
+[h4 Tinyness before rounding]
+
+`bool std::numeric_limits<T>::tinyness_before`
+
+`true` if a type can determine that a value is too small
+to be represent as a normalized value before rounding it.
+
+Generally true for `is_iec559` 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:
+
+# After computation of a result with absolute value smaller than
+`std::numeric_limits<T>::min()`,
+such implementation detects ['tinyness before rounding] (e.g. UltraSparc).
+
+# After rounding of the result to `std::numeric_limits<T>::digits` bits,
+if the result is tiny, such implementation detects ['tinyness after rounding]
+(e.g. SuperSparc).
+
+# If the conversion of the rounded tiny result to subnormal form
+resulted in the loss of precision, such implementation detects ['denorm loss].
+
+[endsect] [/section:constants std::numeric_limits<> Constants]
+
+[section:functions std::numeric_limits<> functions]
+
+[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
+`numeric_limits<T>::bounded` is `false`) then returns `T()`.
+
+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 `INT64_T_MAX` for `int64_t`, may provide a macro definition.
+
+To cater for situations where no `numeric_limits` specialization is available
+(for example because the precision of the type varies at runtime),
+packaged versions of this (and other functions) are provided using
+
+ #include <boost/math/tools/precision.hpp>
+
+ T = boost::math::tools::max_value<T>();
+
+Of course, these simply use `std::numeric_limits<T>::max()` if available,
+but otherwise 'do something sensible'.
+
+[h4 lowest function]
+
+Since C++11: `std::numeric_limits<T>::lowest()` is
+
+* For integral types, the same as function `min()`.
+* For floating-point types, generally the negative of `max()`
+(but implementation-dependent).
+
+[digits10_5]
+
+[h4 min function]
+
+Function `std::numeric_limits<T>::min()` 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 `INT64_T_MIN` for `int64_t`, may provide a macro definition.
+
+For floating-point types,
+it is more fully defined as the ['minimum positive normalized value].
+
+See `std::numeric_limits<T>::denorm_min()` for the smallest denormalized value, provided
+
+ std::numeric_limits<T>::has_denorm == std::denorm_present
+
+
+To cater for situations where no `numeric_limits` specialization is available
+(for example because the precision of the type varies at runtime),
+packaged versions of this (and other functions) are provided using
+
+ #include <boost/math/tools/precision.hpp>
+
+ T = boost::math::tools::min_value<T>();
+
+Of course, these simply use `std::numeric_limits<T>::min()` if available.
+
+[h4 denorm_min function]
+
+Function `std::numeric_limits<T>::denorm_min()`
+returns the smallest
+[@http://en.wikipedia.org/wiki/Denormal_number denormalized value],
+provided
+
+ std::numeric_limits<T>::has_denorm == std::denorm_present
+
+[denorm_min_1]
+
+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).
+
+[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 any basic arithmetic operation.
+
+ round_style == std::round_indeterminate;
+
+The rounding style is indeterminable at compile time.
+
+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`.
+
+`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]
+
+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.
+
+[h4 epsilon]
+
+Function `std::numeric_limits<T>::epsilon()` is meaningful only for non-integral types.
+
+It returns the difference between `1.0` 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 `double` (`float_64t`) it is `2.2204460492503131e-016`
+showing all possibly significant 17 decimal digits.
+
+[epsilon_1]
+
+We can explicitly increment by one bit using the function `boost::math::float_next()`
+and the result is the same as adding `epsilon`.
+
+[epsilon_2]
+
+Adding any smaller value, like half `epsilon`, will have no effect on this value.
+
+[epsilon_3]
+
+So this cancellation error leaves the values equal, despite adding half `epsilon`.
+
+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 `numeric_limits` is not available.
+To use these `#include <boost/math/tools/precision.hpp>`.
+
+[epsilon_4]
+
+[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.
+
+For more information you probably want (but still need) see
+[@http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html What Every Computer Scientist Should Know About Floating-Point Arithmetic]
+
+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:
+
+[@http://adtmag.com/articles/2000/03/15/comparing-floats-how-to-determine-if-floating-quantities-are-close-enough-once-a-tolerance-has-been.aspx Alberto Squassia, Comparing floats]
+
+[@http://adtmag.com/articles/2000/03/16/comparing-floats-how-to-determine-if-floating-quantities-are-close-enough-once-a-tolerance-has-been.aspx Alberto Squassia, Comparing floats code]
+
+[@boost:/libs/test/doc/html/utf/testing-tools/floating_point_comparison.html floating-point comparison].
+
+[tolerance_1]
+
+used thus:
+
+ BOOST_CHECK_CLOSE_FRACTION(expected, calculated, tolerance);
+
+(There is also a version using tolerance as a percentage rather than a fraction).
+
+[tolerance_2]
+
+[h4 Infinity - positive and negative]
+
+For floating-point types only, for which
+`std::numeric_limits<T>::has_infinity == true`,
+function `std::numeric_limits<T>::infinity()`
+provides an implementation-defined representation for [infin].
+
+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 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
+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.
+
+[h4 Not-A-Number NaN]
+
+[h5 Quiet_NaN]
+
+For floating-point types only, for which
+`std::numeric_limits<T>::has_quiet_NaN == true`,
+function `std::numeric_limits<T>::quiet_NaN()`
+provides an implementation-defined representation for NaN.
+
+[@http://en.wikipedia.org/wiki/NaN NaNs] are values to indicate that the
+result of an assignment or computation is meaningless.
+A typical example is `0/0` 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
+[@http://en.wikipedia.org/wiki/NaN Not-A-Number] has hampered portable use,
+similar to those with infinity.
+
+[nan_1]
+
+But using Boost.Math and suitable facets can permit portable use
+of both NaNs and positive and negative infinity.
+
+[facet_1]
+
+[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.
+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]
+
+[/ 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]
+
+
+[section:input_output Input Output]
+
+
+[h4 Loopback testing]
+
+['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:
+
+ 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.
+
+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.
+
+ 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);
+
+
+The test at
+[@../../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
+[@../../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, 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, 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
+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.
+
+[note Do not expect the output from different platforms
+to be [*identical], but `cpp_dec_float`, `cpp_bin_float` (and other backends) outputs should be
+correctly rounded to the number of digits requested by the set precision and format.]
+
+
+[h4 Macro BOOST_MP_MIN_EXPONENT_DIGITS]
+
+[@http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf C99 Standard]
+for [/e and E] 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++)
+
+ #define BOOST_MP_MIN_EXPONENT_DIGITS 2
+
+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 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
+
+producing a compact output like `2e+4`,
+useful when conserving space is important.
+
+Larger values are also supported, for example, value 4 for `2e+0004`
+which may be useful to ensure that columns line up.
+
+[endsect] [/section:input_output Input Output]
+
+
 [endsect]
 
 [section:ref Reference]
@@ -1874,7 +2820,7 @@
 
    enum expression_template_option { et_on = 1, et_off = 0 };
 
- template <class Backend> struct expression_template_default
+ template <class Backend> struct expression_template_default
    { static const expression_template_option value = et_on; };
 
    template <class Backend, expression_template_option ExpressionTemplates = expression_template_default<Backend>::value>
@@ -1924,7 +2870,7 @@
       // Comparison:
       int compare(const number<Backend>& o)const;
       template <class V>
- typename enable_if<is_convertible<V, number<Backend, ExpressionTemplates> >, int>::type
+ typename enable_if<is_convertible<V, number<Backend, ExpressionTemplates> >, int>::type
          compare(const V& o)const;
       // Access to the underlying implementation:
       Backend& backend();
@@ -2076,7 +3022,7 @@
 
 This enumerated type is used to specify whether expression templates are turned on (et_on) or turned off (et_off).
 
- template <class Backend> struct expression_template_default
+ template <class Backend> struct expression_template_default
    { static const expression_template_option value = et_on; };
 
 This traits class specifies the default expression template option to be used with a particular Backend type.
@@ -2211,7 +3157,7 @@
 
       int compare(const number<Backend, ExpressionTemplates>& o)const;
       template <class V>
- typename enable_if<is_convertible<V, number<Backend, ExpressionTemplates> >, int>::type
+ typename enable_if<is_convertible<V, number<Backend, ExpressionTemplates> >, int>::type
          compare(const V& other)const;
 
 Returns:
@@ -2263,7 +3209,7 @@
 * Type `number<Backend, et_off>` when `ExpressionTemplates` is `false`.
 * Type `bool` if the operator is a comparison operator.
 
-Finally note that the second argument to the left and right shift operations must be a builtin integer type,
+Finally note that the second argument to the left and right shift operations must be a builtin integer type,
 and that the argument must be positive (negative arguments result in a `std::runtime_error` being thrown).
 
 [h4 swap]
@@ -2299,7 +3245,7 @@
    ResultType& multiply(ResultType& result, const Source1& a, const Source2& b);
 
 These functions apply the named operator to the arguments ['a] and ['b] and store the
-result in ['result], returning ['result]. In all cases they behave "as if"
+result in ['result], returning ['result]. In all cases they behave "as if"
 arguments ['a] and ['b] were first promoted to type `ResultType` before applying the
 operator, though particular backends may well avoid that step by way of an optimization.
 
@@ -2347,7 +3293,7 @@
 
 These functions are normally implemented by the Backend type. However, default versions are provided for Backend types that
 don't have native support for these functions. Please note however, that this default support requires the precision of the type
-to be a compile time constant - this means for example that the [gmp] MPF Backend will not work with these functions when that type is
+to be a compile time constant - this means for example that the [gmp] MPF Backend will not work with these functions when that type is
 used at variable precision.
 
 Also note that with the exception of `abs` that these functions can only be used with floating-point Backend types (if any other types
@@ -2414,7 +3360,7 @@
 In addition to functioning with types from this library, these functions are also overloaded for built in integer
 types if you include `<boost/multiprecision/integer.hpp>`. Further, when used with fixed precision types (whether
 built in integers or multiprecision ones), the functions will promote to a wider type internally when the algorithm
-requires it. Versions overloaded for built in integer types return that integer type rather than an expression
+requires it. Versions overloaded for built in integer types return that integer type rather than an expression
 template.
 
    ``['unmentionable-expression-template-type]`` gcd(const ``['number-or-expression-template-type]``& a, const ``['number-or-expression-template-type]``& b);
@@ -2427,7 +3373,7 @@
 
    ``['unmentionable-expression-template-type]`` pow(const ``['number-or-expression-template-type]``& b, unsigned p);
 
-Returns ['b[super p]] as an expression template. Note that this function should be used with extreme care as the result can grow so
+Returns ['b[super p]] as an expression template. Note that this function should be used with extreme care as the result can grow so
 large as to take "effectively forever" to compute, or else simply run the host machine out of memory. This is the one function in
 this category that is not overloaded for built in integer types, further, it's probably not a good idea to use it with
 fixed precision `cpp_int`'s either.
@@ -2549,10 +3495,10 @@
    enum cpp_integer_type { signed_magnitude, unsigned_magnitude };
    enum cpp_int_check_type { checked, unchecked };
 
- template <unsigned MinDigits = 0,
- unsigned MaxDits = 0,
- cpp_integer_type SignType = signed_magnitude,
- cpp_int_check_type Checked = unchecked,
+ template <unsigned MinDigits = 0,
+ unsigned MaxDits = 0,
+ cpp_integer_type SignType = signed_magnitude,
+ cpp_int_check_type Checked = unchecked,
              class Allocator = std::allocator<limb_type> >
    class cpp_int_backend;
    //
@@ -2597,8 +3543,8 @@
 
    }} // namespaces
 
-Class template `cpp_int_backend` 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
+Class template `cpp_int_backend` 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 template arguments are:
@@ -2614,7 +3560,7 @@
            type `void`. Note that this parameter should not be used simply to prevent large memory
            allocations, not only is that role better performed by the allocator, but fixed precision
            integers have a tendency to allocate all of MaxBits of storage more often than one would expect.]]
-[[SignType][Determines whether the resulting type is signed or not. Note that for
+[[SignType][Determines whether the resulting type is signed or not. Note that for
 [@http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic arbitrary precision] types
           this parameter must be `signed_magnitude`. For fixed precision
           types then this type may be either `signed_magnitude` or `unsigned_magnitude`.]]
@@ -2638,8 +3584,8 @@
 
    }} // namespaces
 
-Class template `gmp_int` 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
+Class template `gmp_int` 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 type of `number_category<cpp_int<Args...> >::type` is `mpl::int_<number_kind_integer>`.
@@ -2658,8 +3604,8 @@
 
    }} // namespaces
 
-Class template `tommath_int` 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
+Class template `tommath_int` 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 type of `number_category<cpp_int<Args...> >::type` is `mpl::int_<number_kind_integer>`.
@@ -2683,8 +3629,8 @@
 
    }} // namespaces
 
-Class template `gmp_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
+Class template `gmp_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 a single template parameter - `Digits10` - which is the number of decimal digits precision the type
@@ -2714,8 +3660,8 @@
 
    }} // namespaces
 
-Class template `mpfr_float_backend` 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
+Class template `mpfr_float_backend` 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 a single template parameter - `Digits10` - which is the number of decimal digits precision the type
@@ -2730,6 +3676,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 t