Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r77032 - in sandbox/big_number: boost/multiprecision boost/multiprecision/detail boost/multiprecision/detail/functions libs/multiprecision/doc libs/multiprecision/example libs/multiprecision/performance libs/multiprecision/test libs/multiprecision/test/math
From: john_at_[hidden]
Date: 2012-02-15 08:09:52

Next message: chris_at_[hidden]: "[Boost-commit] svn:boost r77033 - in trunk: boost/asio/detail libs/asio/doc"
Previous message: lorcaminiti_at_[hidden]: "[Boost-commit] svn:boost r77031 - trunk/libs/scope_exit/doc/html/scope_exit"

Author: johnmaddock
Date: 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
New Revision: 77032
URL: http://svn.boost.org/trac/boost/changeset/77032

Log:
Big search and replace: change cpp_float to cpp_dec_float.
Also fix up some numeric_limits test failures.
Added:
   sandbox/big_number/boost/multiprecision/cpp_dec_float.hpp
      - copied, changed from r76721, /sandbox/big_number/boost/multiprecision/cpp_float.hpp
Removed:
   sandbox/big_number/boost/multiprecision/cpp_float.hpp
Text files modified:
   sandbox/big_number/boost/multiprecision/cpp_dec_float.hpp | 952 ++++++++++++++++++++--------------------
   sandbox/big_number/boost/multiprecision/detail/default_ops.hpp | 8
   sandbox/big_number/boost/multiprecision/detail/functions/pow.hpp | 16
   sandbox/big_number/boost/multiprecision/detail/functions/trig.hpp | 16
   sandbox/big_number/libs/multiprecision/doc/multiprecision.qbk | 40
   sandbox/big_number/libs/multiprecision/example/cpp_float_snips.cpp | 4
   sandbox/big_number/libs/multiprecision/performance/Jamfile.v2 | 8
   sandbox/big_number/libs/multiprecision/performance/linpack-benchmark.cpp | 10
   sandbox/big_number/libs/multiprecision/performance/performance_test.cpp | 16
   sandbox/big_number/libs/multiprecision/performance/sf_performance.cpp | 18
   sandbox/big_number/libs/multiprecision/test/Jamfile.v2 | 36
   sandbox/big_number/libs/multiprecision/test/math/log1p_expm1_test.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/powm1_sqrtp1m1_test.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_bessel_i.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_bessel_j.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_bessel_k.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_bessel_y.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_beta.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_binomial_coeff.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_carlson.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_cbrt.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_digamma.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_ellint_1.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_ellint_2.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_ellint_3.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_erf.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_expint.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_gamma.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_hermite.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_ibeta.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_ibeta_2.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_ibeta_3.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_ibeta_4.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_ibeta_inv_1.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_ibeta_inv_ab_4.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_igamma.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_igamma_inv.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_igamma_inva.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_laguerre.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_legendre.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_tgamma_ratio.cpp | 16
   sandbox/big_number/libs/multiprecision/test/math/test_zeta.cpp | 16
   sandbox/big_number/libs/multiprecision/test/mp_number_concept_check.cpp | 12
   sandbox/big_number/libs/multiprecision/test/test_acos.cpp | 10
   sandbox/big_number/libs/multiprecision/test/test_arithmetic.cpp | 10
   sandbox/big_number/libs/multiprecision/test/test_asin.cpp | 10
   sandbox/big_number/libs/multiprecision/test/test_atan.cpp | 10
   sandbox/big_number/libs/multiprecision/test/test_cos.cpp | 10
   sandbox/big_number/libs/multiprecision/test/test_cosh.cpp | 10
   sandbox/big_number/libs/multiprecision/test/test_exp.cpp | 10
   sandbox/big_number/libs/multiprecision/test/test_float_io.cpp | 12
   sandbox/big_number/libs/multiprecision/test/test_fpclassify.cpp | 10
   sandbox/big_number/libs/multiprecision/test/test_log.cpp | 10
   sandbox/big_number/libs/multiprecision/test/test_numeric_limits.cpp | 106 ++--
   sandbox/big_number/libs/multiprecision/test/test_pow.cpp | 10
   sandbox/big_number/libs/multiprecision/test/test_round.cpp | 10
   sandbox/big_number/libs/multiprecision/test/test_sin.cpp | 10
   sandbox/big_number/libs/multiprecision/test/test_sinh.cpp | 10
   sandbox/big_number/libs/multiprecision/test/test_sqrt.cpp | 10
   sandbox/big_number/libs/multiprecision/test/test_tanh.cpp | 10
   sandbox/big_number/libs/multiprecision/test/test_test.cpp | 2
   61 files changed, 951 insertions(+), 951 deletions(-)

Copied: sandbox/big_number/boost/multiprecision/cpp_dec_float.hpp (from r76721, /sandbox/big_number/boost/multiprecision/cpp_float.hpp)
==============================================================================
--- /sandbox/big_number/boost/multiprecision/cpp_float.hpp (original)
+++ sandbox/big_number/boost/multiprecision/cpp_dec_float.hpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -26,7 +26,7 @@
namespace multiprecision{

template <unsigned Digits10>
-class cpp_float
+class cpp_dec_float
{
public:
 typedef mpl::list<long long> signed_types;
@@ -81,7 +81,7 @@
 //
 // Special values constructor:
 //
- cpp_float(t_fpclass c) :
+ cpp_dec_float(t_fpclass c) :
 data(),
 exp (static_cast<boost::int64_t>(0)),
 neg (false),
@@ -95,23 +95,23 @@
 {
 initializer()
 {
- cpp_float<Digits10>::nan();
- cpp_float<Digits10>::inf();
- (cpp_float<Digits10>::min)();
- (cpp_float<Digits10>::max)();
- cpp_float<Digits10>::zero();
- cpp_float<Digits10>::one();
- cpp_float<Digits10>::two();
- cpp_float<Digits10>::half();
- cpp_float<Digits10>::double_min();
- cpp_float<Digits10>::double_max();
- cpp_float<Digits10>::long_double_max();
- cpp_float<Digits10>::long_double_min();
- cpp_float<Digits10>::long_long_max();
- cpp_float<Digits10>::long_long_min();
- cpp_float<Digits10>::ulong_long_max();
- cpp_float<Digits10>::eps();
- cpp_float<Digits10>::pow2(0);
+ cpp_dec_float<Digits10>::nan();
+ cpp_dec_float<Digits10>::inf();
+ (cpp_dec_float<Digits10>::min)();
+ (cpp_dec_float<Digits10>::max)();
+ cpp_dec_float<Digits10>::zero();
+ cpp_dec_float<Digits10>::one();
+ cpp_dec_float<Digits10>::two();
+ cpp_dec_float<Digits10>::half();
+ cpp_dec_float<Digits10>::double_min();
+ cpp_dec_float<Digits10>::double_max();
+ cpp_dec_float<Digits10>::long_double_max();
+ cpp_dec_float<Digits10>::long_double_min();
+ cpp_dec_float<Digits10>::long_long_max();
+ cpp_dec_float<Digits10>::long_long_min();
+ cpp_dec_float<Digits10>::ulong_long_max();
+ cpp_dec_float<Digits10>::eps();
+ cpp_dec_float<Digits10>::pow2(0);
 }
 void do_nothing(){}
 };
@@ -120,14 +120,14 @@

public:
 // Constructors
- cpp_float() :
+ cpp_dec_float() :
 data(),
 exp (static_cast<boost::int64_t>(0)),
 neg (false),
 fpclass (mp_finite),
 prec_elem(mp_elem_number) { }

- cpp_float(const char* s) :
+ cpp_dec_float(const char* s) :
 data(),
 exp (static_cast<boost::int64_t>(0)),
 neg (false),
@@ -138,7 +138,7 @@
 }

 template<class I>
- cpp_float(I i, typename enable_if<is_unsigned >::type* = 0) :
+ cpp_dec_float(I i, typename enable_if<is_unsigned >::type* = 0) :
 data(),
 exp (static_cast<boost::int64_t>(0)),
 neg (false),
@@ -149,7 +149,7 @@
 }

 template <class I>
- cpp_float(I i, typename enable_if<is_signed >::type* = 0) :
+ cpp_dec_float(I i, typename enable_if<is_signed >::type* = 0) :
 data(),
 exp (static_cast<boost::int64_t>(0)),
 neg (false),
@@ -165,7 +165,7 @@
 from_unsigned_long_long(i);
 }

- cpp_float(const cpp_float& f) :
+ cpp_dec_float(const cpp_dec_float& f) :
 data (f.data),
 exp (f.exp),
 neg (f.neg),
@@ -173,7 +173,7 @@
 prec_elem(f.prec_elem) { }

 template <unsigned D>
- cpp_float(const cpp_float<D>& f) :
+ cpp_dec_float(const cpp_dec_float<D>& f) :
 exp (f.exp),
 neg (f.neg),
 fpclass (static_cast<enum_fpclass>(static_cast<int>(f.fpclass))),
@@ -185,7 +185,7 @@
 }

 template <class F>
- cpp_float(const F val, typename enable_if<is_floating_point<F> >::type* = 0):
+ cpp_dec_float(const F val, typename enable_if<is_floating_point<F> >::type* = 0):
 data(),
 exp (static_cast<boost::int64_t>(0)),
 neg (false),
@@ -195,28 +195,28 @@
 *this = val;
 }

- cpp_float(const double val, long long exponent);
+ cpp_dec_float(const double val, long long exponent);

 // Specific special values.
- static const cpp_float& nan()
+ static const cpp_dec_float& nan()
 {
- static const cpp_float val(mp_NaN);
+ static const cpp_dec_float val(mp_NaN);
 init.do_nothing();
 return val;
 }
- static const cpp_float& inf()
+ static const cpp_dec_float& inf()
 {
- static const cpp_float val(mp_inf);
+ static const cpp_dec_float val(mp_inf);
 init.do_nothing();
 return val;
 }
- static const cpp_float& (max)()
+ static const cpp_dec_float& (max)()
 {
 init.do_nothing();
 static bool init = false;
 static const std::string str_max = std::string("9." + std::string(static_cast<std::size_t>(cpp_float_max_digits10), static_cast<char>('9')))
 + std::string("e+" + boost::lexical_cast<std::string>(cpp_float_max_exp10));
- static cpp_float val_max;
+ static cpp_dec_float val_max;
 if(!init)
 {
 init = true;
@@ -225,11 +225,11 @@
 return val_max;
 }

- static const cpp_float& (min)()
+ static const cpp_dec_float& (min)()
 {
 init.do_nothing();
 static bool init = false;
- static cpp_float val_min;
+ static cpp_dec_float val_min;
 if(!init)
 {
 init = true;
@@ -237,81 +237,81 @@
 }
 return val_min;
 }
- static const cpp_float& zero()
+ static const cpp_dec_float& zero()
 {
 init.do_nothing();
- static cpp_float val(static_cast<unsigned long long>(0u));
+ static cpp_dec_float val(static_cast<unsigned long long>(0u));
 return val;
 }
- static const cpp_float& one()
+ static const cpp_dec_float& one()
 {
 init.do_nothing();
- static cpp_float val(static_cast<unsigned long long>(1u));
+ static cpp_dec_float val(static_cast<unsigned long long>(1u));
 return val;
 }
- static const cpp_float& two()
+ static const cpp_dec_float& two()
 {
 init.do_nothing();
- static cpp_float val(static_cast<unsigned long long>(2u));
+ static cpp_dec_float val(static_cast<unsigned long long>(2u));
 return val;
 }
- static const cpp_float& half()
+ static const cpp_dec_float& half()
 {
 init.do_nothing();
- static cpp_float val(0.5L);
+ static cpp_dec_float val(0.5L);
 return val;
 }
- static const cpp_float& double_min()
+ static const cpp_dec_float& double_min()
 {
 init.do_nothing();
- static cpp_float val(static_cast<long double>((std::numeric_limits<double>::min)()));
+ static cpp_dec_float val(static_cast<long double>((std::numeric_limits<double>::min)()));
 return val;
 }
- static const cpp_float& double_max()
+ static const cpp_dec_float& double_max()
 {
 init.do_nothing();
- static cpp_float val(static_cast<long double>((std::numeric_limits<double>::max)()));
+ static cpp_dec_float val(static_cast<long double>((std::numeric_limits<double>::max)()));
 return val;
 }
- static const cpp_float& long_double_min()
+ static const cpp_dec_float& long_double_min()
 {
 init.do_nothing();
- static cpp_float val((std::numeric_limits<long double>::min)());
+ static cpp_dec_float val((std::numeric_limits<long double>::min)());
 return val;
 }
- static const cpp_float& long_double_max()
+ static const cpp_dec_float& long_double_max()
 {
 init.do_nothing();
- static cpp_float val((std::numeric_limits<long double>::max)());
+ static cpp_dec_float val((std::numeric_limits<long double>::max)());
 return val;
 }
- static const cpp_float& long_long_max()
+ static const cpp_dec_float& long_long_max()
 {
 init.do_nothing();
- static cpp_float val((std::numeric_limits<long long>::max)());
+ static cpp_dec_float val((std::numeric_limits<long long>::max)());
 return val;
 }
- static const cpp_float& long_long_min()
+ static const cpp_dec_float& long_long_min()
 {
 init.do_nothing();
- static cpp_float val((std::numeric_limits<long long>::min)());
+ static cpp_dec_float val((std::numeric_limits<long long>::min)());
 return val;
 }
- static const cpp_float& ulong_long_max()
+ static const cpp_dec_float& ulong_long_max()
 {
 init.do_nothing();
- static cpp_float val((std::numeric_limits<unsigned long long>::max)());
+ static cpp_dec_float val((std::numeric_limits<unsigned long long>::max)());
 return val;
 }
- static const cpp_float& eps()
+ static const cpp_dec_float& eps()
 {
 init.do_nothing();
- static cpp_float val(1.0, 1 - (int)Digits10);
+ static cpp_dec_float val(1.0, 1 - (int)Digits10);
 return val;
 }

 // Basic operations.
- cpp_float& operator= (const cpp_float& v)
+ cpp_dec_float& operator= (const cpp_dec_float& v)
 {
 data = v.data;
 exp = v.exp;
@@ -321,7 +321,7 @@
 return *this;
 }
 template <unsigned D>
- cpp_float& operator=(const cpp_float<D>& f)
+ cpp_dec_float& operator=(const cpp_dec_float<D>& f)
 {
 exp = f.exp;
 neg = f.neg;
@@ -330,7 +330,7 @@
 precision(std::min(f.prec_elem, prec_elem));
 return *this;
 }
- cpp_float& operator= (long long v)
+ cpp_dec_float& operator= (long long v)
 {
 if(v < 0)
 {
@@ -341,41 +341,41 @@
 from_unsigned_long_long(v);
 return *this;
 }
- cpp_float& operator= (unsigned long long v)
+ cpp_dec_float& operator= (unsigned long long v)
 {
 from_unsigned_long_long(v);
 return *this;
 }
- cpp_float& operator= (long double v);
- cpp_float& operator= (const char* v)
+ cpp_dec_float& operator= (long double v);
+ cpp_dec_float& operator= (const char* v)
 {
 rd_string(v);
 return *this;
 }

- cpp_float& operator+=(const cpp_float& v);
- cpp_float& operator-=(const cpp_float& v);
- cpp_float& operator*=(const cpp_float& v);
- cpp_float& operator/=(const cpp_float& v);
+ cpp_dec_float& operator+=(const cpp_dec_float& v);
+ cpp_dec_float& operator-=(const cpp_dec_float& v);
+ cpp_dec_float& operator*=(const cpp_dec_float& v);
+ cpp_dec_float& operator/=(const cpp_dec_float& v);

- cpp_float& add_unsigned_long_long(const unsigned long long n)
+ cpp_dec_float& add_unsigned_long_long(const unsigned long long n)
 {
- cpp_float t;
+ cpp_dec_float t;
 t.from_unsigned_long_long(n);
 return *this += t;
 }
- cpp_float& sub_unsigned_long_long(const unsigned long long n)
+ cpp_dec_float& sub_unsigned_long_long(const unsigned long long n)
 {
- cpp_float t;
+ cpp_dec_float t;
 t.from_unsigned_long_long(n);
 return *this -= t;
 }
- cpp_float& mul_unsigned_long_long(const unsigned long long n);
- cpp_float& div_unsigned_long_long(const unsigned long long n);
+ cpp_dec_float& mul_unsigned_long_long(const unsigned long long n);
+ cpp_dec_float& div_unsigned_long_long(const unsigned long long n);

 // Elementary primitives.
- cpp_float& calculate_inv (void);
- cpp_float& calculate_sqrt(void);
+ cpp_dec_float& calculate_inv (void);
+ cpp_dec_float& calculate_sqrt(void);
 void negate()
 {
 if(!iszero())
@@ -396,27 +396,27 @@
 bool isneg (void) const { return neg; }

 // Operators pre-increment and pre-decrement
- cpp_float& operator++(void)
+ cpp_dec_float& operator++(void)
 {
 return *this += one();
 }
- cpp_float& operator--(void)
+ cpp_dec_float& operator--(void)
 {
 return *this -= one();
 }

 std::string str(boost::intmax_t digits, std::ios_base::fmtflags f)const;

- int compare(const cpp_float& v)const;
+ int compare(const cpp_dec_float& v)const;
 template <class V>
 int compare(const V& v)const
 {
- cpp_float<Digits10> t;
+ cpp_dec_float<Digits10> t;
 t = v;
 return compare(t);
 }

- void swap(cpp_float& v)
+ void swap(cpp_dec_float& v)
 {
 data.swap(v.data);
 std::swap(exp, v.exp);
@@ -430,7 +430,7 @@
 signed long long extract_signed_long_long (void) const;
 unsigned long long extract_unsigned_long_long(void) const;
 void extract_parts (double& mantissa, boost::int64_t& exponent) const;
- cpp_float extract_integer_part (void) const;
+ cpp_dec_float extract_integer_part (void) const;
 void precision(const boost::int32_t prec_digits)
 {
 if(prec_digits >= cpp_float_digits10)
@@ -445,7 +445,7 @@
 prec_elem = (std::min)(mp_elem_number, (std::max)(elems, static_cast<boost::int32_t>(2)));
 }
 }
- static cpp_float pow2(long long i);
+ static cpp_dec_float pow2(long long i);
 long long order()const
 {
 const bool bo_order_is_zero = ((!isfinite()) || (data[0] == static_cast<boost::uint32_t>(0u)));
@@ -500,7 +500,7 @@

private:
 static bool data_elem_is_non_zero_predicate(const boost::uint32_t& d) { return (d != static_cast<boost::uint32_t>(0u)); }
- static bool data_elem_is_non_nine_predicate(const boost::uint32_t& d) { return (d != static_cast<boost::uint32_t>(cpp_float::mp_elem_mask - 1)); }
+ static bool data_elem_is_non_nine_predicate(const boost::uint32_t& d) { return (d != static_cast<boost::uint32_t>(cpp_dec_float::mp_elem_mask - 1)); }
 static bool char_is_nonzero_predicate(const char& c) { return (c != static_cast<char>('0')); }

 void from_unsigned_long_long(const unsigned long long u);
@@ -514,47 +514,47 @@
 bool rd_string(const char* const s);

 template <unsigned D>
- friend class cpp_float;
+ friend class cpp_dec_float;

};

template <unsigned Digits10>
-typename cpp_float<Digits10>::initializer cpp_float<Digits10>::init;
+typename cpp_dec_float<Digits10>::initializer cpp_dec_float<Digits10>::init;

template <unsigned Digits10>
-const boost::int32_t cpp_float<Digits10>::mp_radix;
+const boost::int32_t cpp_dec_float<Digits10>::mp_radix;
template <unsigned Digits10>
-const boost::int32_t cpp_float<Digits10>::cpp_float_digits;
+const boost::int32_t cpp_dec_float<Digits10>::cpp_float_digits;
template <unsigned Digits10>
-const boost::int32_t cpp_float<Digits10>::cpp_float_digits10_setting;
+const boost::int32_t cpp_dec_float<Digits10>::cpp_float_digits10_setting;
template <unsigned Digits10>
-const boost::int32_t cpp_float<Digits10>::cpp_float_digits10_limit;
+const boost::int32_t cpp_dec_float<Digits10>::cpp_float_digits10_limit;
template <unsigned Digits10>
-const boost::int32_t cpp_float<Digits10>::cpp_float_digits10;
+const boost::int32_t cpp_dec_float<Digits10>::cpp_float_digits10;
template <unsigned Digits10>
-const boost::int32_t cpp_float<Digits10>::cpp_float_digits10_extra;
+const boost::int32_t cpp_dec_float<Digits10>::cpp_float_digits10_extra;
template <unsigned Digits10>
-const boost::int32_t cpp_float<Digits10>::cpp_float_max_digits10;
+const boost::int32_t cpp_dec_float<Digits10>::cpp_float_max_digits10;
template <unsigned Digits10>
-const boost::int64_t cpp_float<Digits10>::cpp_float_max_exp;
+const boost::int64_t cpp_dec_float<Digits10>::cpp_float_max_exp;
template <unsigned Digits10>
-const boost::int64_t cpp_float<Digits10>::cpp_float_min_exp;
+const boost::int64_t cpp_dec_float<Digits10>::cpp_float_min_exp;
template <unsigned Digits10>
-const boost::int64_t cpp_float<Digits10>::cpp_float_max_exp10;
+const boost::int64_t cpp_dec_float<Digits10>::cpp_float_max_exp10;
template <unsigned Digits10>
-const boost::int64_t cpp_float<Digits10>::cpp_float_min_exp10;
+const boost::int64_t cpp_dec_float<Digits10>::cpp_float_min_exp10;
template <unsigned Digits10>
-const boost::int32_t cpp_float<Digits10>::mp_elem_digits10;
+const boost::int32_t cpp_dec_float<Digits10>::mp_elem_digits10;
template <unsigned Digits10>
-const boost::int32_t cpp_float<Digits10>::cpp_float_digits10_num_base;
+const boost::int32_t cpp_dec_float<Digits10>::cpp_float_digits10_num_base;
template <unsigned Digits10>
-const boost::int32_t cpp_float<Digits10>::mp_elem_number;
+const boost::int32_t cpp_dec_float<Digits10>::mp_elem_number;
template <unsigned Digits10>
-const boost::int32_t cpp_float<Digits10>::mp_elem_mask;
+const boost::int32_t cpp_dec_float<Digits10>::mp_elem_mask;

template <unsigned Digits10>
-cpp_float<Digits10>& cpp_float<Digits10>::operator+=(const cpp_float<Digits10>& v)
+cpp_dec_float<Digits10>& cpp_dec_float<Digits10>::operator+=(const cpp_dec_float<Digits10>& v)
{
 if(isnan())
 {
@@ -750,7 +750,7 @@
 // Check to see if we really truely have an overflow or not...
 if(isneg())
 {
- cpp_float t(*this);
+ cpp_dec_float t(*this);
 t.negate();
 overflow = t.compare((max)()) > 0;
 }
@@ -774,7 +774,7 @@
}

template <unsigned Digits10>
-cpp_float<Digits10>& cpp_float<Digits10>::operator-=(const cpp_float<Digits10>& v)
+cpp_dec_float<Digits10>& cpp_dec_float<Digits10>::operator-=(const cpp_dec_float<Digits10>& v)
{
 // Use *this - v = -(-*this + v).
 negate();
@@ -784,7 +784,7 @@
}

template <unsigned Digits10>
-cpp_float<Digits10>& cpp_float<Digits10>::operator*=(const cpp_float<Digits10>& v)
+cpp_dec_float<Digits10>& cpp_dec_float<Digits10>::operator*=(const cpp_dec_float<Digits10>& v)
{
 // Evaluate the sign of the result.
 const bool b_result_is_neg = (neg != v.neg);
@@ -876,7 +876,7 @@
}

template <unsigned Digits10>
-cpp_float<Digits10>& cpp_float<Digits10>::operator/=(const cpp_float<Digits10>& v)
+cpp_dec_float<Digits10>& cpp_dec_float<Digits10>::operator/=(const cpp_dec_float<Digits10>& v)
{
 const bool u_and_v_are_finite_and_identical = ( isfinite()
 && (fpclass == v.fpclass)
@@ -904,14 +904,14 @@
 }
 return *this;
 }
- cpp_float t(v);
+ cpp_dec_float t(v);
 t.calculate_inv();
 return operator*=(t);
 }
}

template <unsigned Digits10>
-cpp_float<Digits10>& cpp_float<Digits10>::mul_unsigned_long_long(const unsigned long long n)
+cpp_dec_float<Digits10>& cpp_dec_float<Digits10>::mul_unsigned_long_long(const unsigned long long n)
{
 // Multiply *this with a constant unsigned long long.

@@ -947,7 +947,7 @@
 if(n >= static_cast<unsigned long long>(mp_elem_mask))
 {
 neg = b_neg;
- cpp_float t;
+ cpp_dec_float t;
 t = n;
 return operator*=(t);
 }
@@ -981,7 +981,7 @@
 // Check to see if we really truely have an overflow or not...
 if(isneg())
 {
- cpp_float t(*this);
+ cpp_dec_float t(*this);
 t.negate();
 overflow = t.compare((max)()) > 0;
 }
@@ -1006,7 +1006,7 @@
}

template <unsigned Digits10>
-cpp_float<Digits10>& cpp_float<Digits10>::div_unsigned_long_long(const unsigned long long n)
+cpp_dec_float<Digits10>& cpp_dec_float<Digits10>::div_unsigned_long_long(const unsigned long long n)
{
 // Divide *this by a constant unsigned long long.

@@ -1055,7 +1055,7 @@
 if(n >= static_cast<unsigned long long>(mp_elem_mask))
 {
 neg = b_neg;
- cpp_float t;
+ cpp_dec_float t;
 t = n;
 return operator/=(t);
 }
@@ -1095,7 +1095,7 @@
}

template <unsigned Digits10>
-cpp_float<Digits10>& cpp_float<Digits10>::calculate_inv()
+cpp_dec_float<Digits10>& cpp_dec_float<Digits10>::calculate_inv()
{
 // Compute the inverse of *this.
 const bool b_neg = neg;
@@ -1129,7 +1129,7 @@
 }

 // Save the original *this.
- cpp_float<Digits10> x(*this);
+ cpp_dec_float<Digits10> x(*this);

 // Generate the initial estimate using division.
 // Extract the mantissa and exponent for a "manual"
@@ -1139,7 +1139,7 @@
 x.extract_parts(dd, ne);

 // Do the inverse estimate using double precision estimates of mantissa and exponent.
- operator=(cpp_float<Digits10>(1.0 / dd, -ne));
+ operator=(cpp_dec_float<Digits10>(1.0 / dd, -ne));

 // Compute the inverse of *this. Quadratically convergent Newton-Raphson iteration
 // is used. During the iterative steps, the precision of the calculation is limited
@@ -1154,7 +1154,7 @@
 x.precision(static_cast<boost::int32_t>(digits * static_cast<boost::int32_t>(2)));

 // Next iteration.
- cpp_float t(*this);
+ cpp_dec_float t(*this);
 t *= x;
 t -= two();
 t.negate();
@@ -1169,7 +1169,7 @@
}

template <unsigned Digits10>
-cpp_float<Digits10>& cpp_float<Digits10>::calculate_sqrt(void)
+cpp_dec_float<Digits10>& cpp_dec_float<Digits10>::calculate_sqrt(void)
{
 // Compute the square root of *this.

@@ -1185,7 +1185,7 @@
 }

 // Save the original *this.
- cpp_float<Digits10> x(*this);
+ cpp_dec_float<Digits10> x(*this);

 // Generate the initial estimate using division.
 // Extract the mantissa and exponent for a "manual"
@@ -1205,10 +1205,10 @@
 // Estimate the square root using simple manipulations.
 const double sqd = std::sqrt(dd);

- *this = cpp_float<Digits10>(sqd, static_cast<boost::int64_t>(ne / static_cast<boost::int64_t>(2)));
+ *this = cpp_dec_float<Digits10>(sqd, static_cast<boost::int64_t>(ne / static_cast<boost::int64_t>(2)));

 // Estimate 1.0 / (2.0 * x0) using simple manipulations.
- cpp_float<Digits10> vi(0.5 / sqd, static_cast<boost::int64_t>(-ne / static_cast<boost::int64_t>(2)));
+ cpp_dec_float<Digits10> vi(0.5 / sqd, static_cast<boost::int64_t>(-ne / static_cast<boost::int64_t>(2)));

 // Compute the square root of x. Coupled Newton iteration
 // as described in "Pi Unleashed" is used. During the
@@ -1229,7 +1229,7 @@
 vi.precision(digits * 2);

 // Next iteration of vi
- cpp_float t(*this);
+ cpp_dec_float t(*this);
 t *= vi;
 t.negate();
 t.mul_unsigned_long_long(2u);
@@ -1252,7 +1252,7 @@
}

template <unsigned Digits10>
-int cpp_float<Digits10>::cmp_data(const array_type& vd) const
+int cpp_dec_float<Digits10>::cmp_data(const array_type& vd) const
{
 // Compare the data of *this with those of v.
 // Return +1 for *this > v
@@ -1274,7 +1274,7 @@
}

template <unsigned Digits10>
-int cpp_float<Digits10>::compare(const cpp_float& v) const
+int cpp_dec_float<Digits10>::compare(const cpp_dec_float& v) const
{
 // Compare v with *this.
 // Return +1 for *this > v
@@ -1352,7 +1352,7 @@
}

template <unsigned Digits10>
-bool cpp_float<Digits10>::isone() const
+bool cpp_dec_float<Digits10>::isone() const
{
 // Check if the value of *this is identically 1 or very close to 1.

@@ -1376,7 +1376,7 @@
}

template <unsigned Digits10>
-bool cpp_float<Digits10>::isint() const
+bool cpp_dec_float<Digits10>::isint() const
{
 if(fpclass != mp_finite) { return false; }

@@ -1399,9 +1399,9 @@
}

template <unsigned Digits10>
-void cpp_float<Digits10>::extract_parts(double& mantissa, boost::int64_t& exponent) const
+void cpp_dec_float<Digits10>::extract_parts(double& mantissa, boost::int64_t& exponent) const
{
- // Extract the approximate parts mantissa and base-10 exponent from the input cpp_float<Digits10> value x.
+ // Extract the approximate parts mantissa and base-10 exponent from the input cpp_dec_float<Digits10> value x.

 // Extracts the mantissa and exponent.
 exponent = exp;
@@ -1432,11 +1432,11 @@
}

template <unsigned Digits10>
-double cpp_float<Digits10>::extract_double(void) const
+double cpp_dec_float<Digits10>::extract_double(void) const
{
- // Returns the double conversion of a cpp_float<Digits10>.
+ // Returns the double conversion of a cpp_dec_float<Digits10>.

- // Check for non-normal cpp_float<Digits10>.
+ // Check for non-normal cpp_dec_float<Digits10>.
 if(!isfinite())
 {
 if(isnan())
@@ -1450,17 +1450,17 @@
 }
 }

- cpp_float<Digits10> xx(*this);
+ cpp_dec_float<Digits10> xx(*this);
 if(xx.isneg())
 xx.negate();

- // Check for zero cpp_float<Digits10>.
+ // Check for zero cpp_dec_float<Digits10>.
 if(iszero() || (xx.compare(double_min()) < 0))
 {
 return 0.0;
 }

- // Check if cpp_float<Digits10> exceeds the maximum of double.
+ // Check if cpp_dec_float<Digits10> exceeds the maximum of double.
 if(xx.compare(double_max()) > 0)
 {
 return ((!neg) ? std::numeric_limits<double>::infinity()
@@ -1478,11 +1478,11 @@
}

template <unsigned Digits10>
-long double cpp_float<Digits10>::extract_long_double(void) const
+long double cpp_dec_float<Digits10>::extract_long_double(void) const
{
- // Returns the long double conversion of a cpp_float<Digits10>.
+ // Returns the long double conversion of a cpp_dec_float<Digits10>.

- // Check for non-normal cpp_float<Digits10>.
+ // Check for non-normal cpp_dec_float<Digits10>.
 if(!isfinite())
 {
 if(isnan())
@@ -1496,17 +1496,17 @@
 }
 }

- cpp_float<Digits10> xx(*this);
+ cpp_dec_float<Digits10> xx(*this);
 if(xx.isneg())
 xx.negate();

- // Check for zero cpp_float<Digits10>.
+ // Check for zero cpp_dec_float<Digits10>.
 if(iszero() || (xx.compare(long_double_min()) < 0))
 {
 return static_cast<long double>(0.0);
 }

- // Check if cpp_float<Digits10> exceeds the maximum of double.
+ // Check if cpp_dec_float<Digits10> exceeds the maximum of double.
 if(xx.compare(long_double_max()) > 0)
 {
 return ((!neg) ? std::numeric_limits<long double>::infinity()
@@ -1524,7 +1524,7 @@
}

template <unsigned Digits10>
-signed long long cpp_float<Digits10>::extract_signed_long_long(void) const
+signed long long cpp_dec_float<Digits10>::extract_signed_long_long(void) const
{
 // Extracts a signed long long from *this.
 // If (x > maximum of signed long long) or (x < minimum of signed long long),
@@ -1550,7 +1550,7 @@
 else
 {
 // Extract the data into an unsigned long long value.
- cpp_float<Digits10> xn(extract_integer_part());
+ cpp_dec_float<Digits10> xn(extract_integer_part());
 if(xn.isneg())
 xn.negate();

@@ -1569,7 +1569,7 @@
}

template <unsigned Digits10>
-unsigned long long cpp_float<Digits10>::extract_unsigned_long_long(void) const
+unsigned long long cpp_dec_float<Digits10>::extract_unsigned_long_long(void) const
{
 // Extracts an unsigned long long from *this.
 // If x exceeds the maximum of unsigned long long,
@@ -1587,7 +1587,7 @@
 return static_cast<unsigned long long>(0u);
 }

- const cpp_float<Digits10> xn(extract_integer_part());
+ const cpp_dec_float<Digits10> xn(extract_integer_part());

 unsigned long long val;

@@ -1613,7 +1613,7 @@
}

template <unsigned Digits10>
-cpp_float<Digits10> cpp_float<Digits10>::extract_integer_part(void) const
+cpp_dec_float<Digits10> cpp_dec_float<Digits10>::extract_integer_part(void) const
{
 // Compute the signed integer part of x.

@@ -1636,7 +1636,7 @@
 }

 // Make a local copy.
- cpp_float<Digits10> x = *this;
+ cpp_dec_float<Digits10> x = *this;

 // Clear out the decimal portion
 const size_t first_clear = (static_cast<size_t>(x.exp) / static_cast<size_t>(mp_elem_digits10)) + 1u;
@@ -1648,7 +1648,7 @@
}

template <unsigned Digits10>
-std::string cpp_float<Digits10>::str(boost::intmax_t number_of_digits, std::ios_base::fmtflags f) const
+std::string cpp_dec_float<Digits10>::str(boost::intmax_t number_of_digits, std::ios_base::fmtflags f) const
{
 if(this->isinf())
 {
@@ -1675,14 +1675,14 @@
 }
 else if(f & std::ios_base::scientific)
 ++number_of_digits;
- // Determine the number of elements needed to provide the requested digits from cpp_float<Digits10>.
+ // Determine the number of elements needed to provide the requested digits from cpp_dec_float<Digits10>.
 const std::size_t number_of_elements = (std::min)(static_cast<std::size_t>((number_of_digits / static_cast<std::size_t>(mp_elem_digits10)) + 2u),
 static_cast<std::size_t>(mp_elem_number));

- // Extract the remaining digits from cpp_float<Digits10> after the decimal point.
+ // Extract the remaining digits from cpp_dec_float<Digits10> after the decimal point.
 str = boost::lexical_cast<std::string>(data[0]);

- // Extract all of the digits from cpp_float<Digits10>, beginning with the first data element.
+ // Extract all of the digits from cpp_dec_float<Digits10>, beginning with the first data element.
 for(std::size_t i = static_cast<std::size_t>(1u); i < number_of_elements; i++)
 {
 std::stringstream ss;
@@ -1801,7 +1801,7 @@
}

template <unsigned Digits10>
-bool cpp_float<Digits10>::rd_string(const char* const s)
+bool cpp_dec_float<Digits10>::rd_string(const char* const s)
{
 std::string str(s);

@@ -1873,7 +1873,7 @@
 }
 }

- // Put the input string into the standard cpp_float<Digits10> input form
+ // Put the input string into the standard cpp_dec_float<Digits10> input form
 // aaa.bbbbE+/-n, where aa has 1...mp_elem_digits10, bbbb has an
 // even multiple of mp_elem_digits10 which are possibly zero padded
 // on the right-end, and n is a signed 32-bit integer which is an
@@ -2001,7 +2001,7 @@
 static_cast<std::size_t>(pos_plus_one + max_dec));
 }

- // Now the input string has the standard cpp_float<Digits10> input form.
+ // Now the input string has the standard cpp_dec_float<Digits10> input form.
 // (See the comment above.)

 // Set all the data elements to 0.
@@ -2040,7 +2040,7 @@
 if(exp == cpp_float_min_exp10)
 {
 // Check for identity with the minimum value.
- cpp_float<Digits10> test = *this;
+ cpp_dec_float<Digits10> test = *this;

 test.exp = static_cast<boost::int64_t>(0);

@@ -2059,14 +2059,14 @@
}

template <unsigned Digits10>
-cpp_float<Digits10>::cpp_float(const double mantissa, const long long exponent)
+cpp_dec_float<Digits10>::cpp_dec_float(const double mantissa, const long long exponent)
 : data (),
 exp (static_cast<boost::int64_t>(0)),
 neg (false),
 fpclass (mp_finite),
 prec_elem(mp_elem_number)
{
- // Create an cpp_float<Digits10> from mantissa and exponent.
+ // Create an cpp_dec_float<Digits10> from mantissa and exponent.
 // This ctor does not maintain the full precision of double.

 const bool mantissa_is_iszero = (::fabs(mantissa) < ((std::numeric_limits<double>::min)() * (1.0 + std::numeric_limits<double>::epsilon())));
@@ -2111,7 +2111,7 @@
}

template <unsigned Digits10>
-cpp_float<Digits10>& cpp_float<Digits10>::operator = (long double a)
+cpp_dec_float<Digits10>& cpp_dec_float<Digits10>::operator = (long double a)
{
 // Christopher Kormanyos's original code used a cast to long long here, but that fails
 // when long double has more digits than a long long.
@@ -2161,7 +2161,7 @@
}

template <unsigned Digits10>
-void cpp_float<Digits10>::from_unsigned_long_long(const unsigned long long u)
+void cpp_dec_float<Digits10>::from_unsigned_long_long(const unsigned long long u)
{
 std::fill(data.begin(), data.end(), static_cast<boost::uint32_t>(0u));

@@ -2193,7 +2193,7 @@
}

template <unsigned Digits10>
-void cpp_float<Digits10>::mul_loop_uv(const boost::uint32_t* const u, const boost::uint32_t* const v, boost::uint32_t* const w, const boost::int32_t p)
+void cpp_dec_float<Digits10>::mul_loop_uv(const boost::uint32_t* const u, const boost::uint32_t* const v, boost::uint32_t* const w, const boost::int32_t p)
{
 boost::uint64_t carry = static_cast<boost::uint64_t>(0u);

@@ -2214,7 +2214,7 @@
}

template <unsigned Digits10>
-boost::uint32_t cpp_float<Digits10>::mul_loop_n(boost::uint32_t* const u, boost::uint32_t n, const boost::int32_t p)
+boost::uint32_t cpp_dec_float<Digits10>::mul_loop_n(boost::uint32_t* const u, boost::uint32_t n, const boost::int32_t p)
{
 boost::uint64_t carry = static_cast<boost::uint64_t>(0u);

@@ -2230,7 +2230,7 @@
}

template <unsigned Digits10>
-boost::uint32_t cpp_float<Digits10>::div_loop_n(boost::uint32_t* const u, boost::uint32_t n, const boost::int32_t p)
+boost::uint32_t cpp_dec_float<Digits10>::div_loop_n(boost::uint32_t* const u, boost::uint32_t n, const boost::int32_t p)
{
 boost::uint64_t prev = static_cast<boost::uint64_t>(0u);

@@ -2245,269 +2245,269 @@
}

template <unsigned Digits10>
-cpp_float<Digits10> cpp_float<Digits10>::pow2(const long long p)
+cpp_dec_float<Digits10> cpp_dec_float<Digits10>::pow2(const long long p)
{
 // Create a static const table of p^2 for -128 , 255u> p2_data =
+ static const boost::array<cpp_dec_float<Digits10>, 255u> p2_data =
 {{
- cpp_float("5.877471754111437539843682686111228389093327783860437607543758531392086297273635864257812500000000000e-39"),
- cpp_float("1.175494350822287507968736537222245677818665556772087521508751706278417259454727172851562500000000000e-38"),
- cpp_float("2.350988701644575015937473074444491355637331113544175043017503412556834518909454345703125000000000000e-38"),
- cpp_float("4.701977403289150031874946148888982711274662227088350086035006825113669037818908691406250000000000000e-38"),
- cpp_float("9.403954806578300063749892297777965422549324454176700172070013650227338075637817382812500000000000000e-38"),
- cpp_float("1.880790961315660012749978459555593084509864890835340034414002730045467615127563476562500000000000000e-37"),
- cpp_float("3.761581922631320025499956919111186169019729781670680068828005460090935230255126953125000000000000000e-37"),
- cpp_float("7.523163845262640050999913838222372338039459563341360137656010920181870460510253906250000000000000000e-37"),
- cpp_float("1.504632769052528010199982767644474467607891912668272027531202184036374092102050781250000000000000000e-36"),
- cpp_float("3.009265538105056020399965535288948935215783825336544055062404368072748184204101562500000000000000000e-36"),
- cpp_float("6.018531076210112040799931070577897870431567650673088110124808736145496368408203125000000000000000000e-36"),
- cpp_float("1.203706215242022408159986214115579574086313530134617622024961747229099273681640625000000000000000000e-35"),
- cpp_float("2.407412430484044816319972428231159148172627060269235244049923494458198547363281250000000000000000000e-35"),
- cpp_float("4.814824860968089632639944856462318296345254120538470488099846988916397094726562500000000000000000000e-35"),
- cpp_float("9.629649721936179265279889712924636592690508241076940976199693977832794189453125000000000000000000000e-35"),
- cpp_float("1.925929944387235853055977942584927318538101648215388195239938795566558837890625000000000000000000000e-34"),
- cpp_float("3.851859888774471706111955885169854637076203296430776390479877591133117675781250000000000000000000000e-34"),
- cpp_float("7.703719777548943412223911770339709274152406592861552780959755182266235351562500000000000000000000000e-34"),
- cpp_float("1.540743955509788682444782354067941854830481318572310556191951036453247070312500000000000000000000000e-33"),
- cpp_float("3.081487911019577364889564708135883709660962637144621112383902072906494140625000000000000000000000000e-33"),
- cpp_float("6.162975822039154729779129416271767419321925274289242224767804145812988281250000000000000000000000000e-33"),
- cpp_float("1.232595164407830945955825883254353483864385054857848444953560829162597656250000000000000000000000000e-32"),
- cpp_float("2.465190328815661891911651766508706967728770109715696889907121658325195312500000000000000000000000000e-32"),
- cpp_float("4.930380657631323783823303533017413935457540219431393779814243316650390625000000000000000000000000000e-32"),
- cpp_float("9.860761315262647567646607066034827870915080438862787559628486633300781250000000000000000000000000000e-32"),
- cpp_float("1.972152263052529513529321413206965574183016087772557511925697326660156250000000000000000000000000000e-31"),
- cpp_float("3.944304526105059027058642826413931148366032175545115023851394653320312500000000000000000000000000000e-31"),
- cpp_float("7.888609052210118054117285652827862296732064351090230047702789306640625000000000000000000000000000000e-31"),
- cpp_float("1.577721810442023610823457130565572459346412870218046009540557861328125000000000000000000000000000000e-30"),
- cpp_float("3.155443620884047221646914261131144918692825740436092019081115722656250000000000000000000000000000000e-30"),
- cpp_float("6.310887241768094443293828522262289837385651480872184038162231445312500000000000000000000000000000000e-30"),
- cpp_float("1.262177448353618888658765704452457967477130296174436807632446289062500000000000000000000000000000000e-29"),
- cpp_float("2.524354896707237777317531408904915934954260592348873615264892578125000000000000000000000000000000000e-29"),
- cpp_float("5.048709793414475554635062817809831869908521184697747230529785156250000000000000000000000000000000000e-29"),
- cpp_float("1.009741958682895110927012563561966373981704236939549446105957031250000000000000000000000000000000000e-28"),
- cpp_float("2.019483917365790221854025127123932747963408473879098892211914062500000000000000000000000000000000000e-28"),
- cpp_float("4.038967834731580443708050254247865495926816947758197784423828125000000000000000000000000000000000000e-28"),
- cpp_float("8.077935669463160887416100508495730991853633895516395568847656250000000000000000000000000000000000000e-28"),
- cpp_float("1.615587133892632177483220101699146198370726779103279113769531250000000000000000000000000000000000000e-27"),
- cpp_float("3.231174267785264354966440203398292396741453558206558227539062500000000000000000000000000000000000000e-27"),
- cpp_float("6.462348535570528709932880406796584793482907116413116455078125000000000000000000000000000000000000000e-27"),
- cpp_float("1.292469707114105741986576081359316958696581423282623291015625000000000000000000000000000000000000000e-26"),
- cpp_float("2.584939414228211483973152162718633917393162846565246582031250000000000000000000000000000000000000000e-26"),
- cpp_float("5.169878828456422967946304325437267834786325693130493164062500000000000000000000000000000000000000000e-26"),
- cpp_float("1.033975765691284593589260865087453566957265138626098632812500000000000000000000000000000000000000000e-25"),
- cpp_float("2.067951531382569187178521730174907133914530277252197265625000000000000000000000000000000000000000000e-25"),
- cpp_float("4.135903062765138374357043460349814267829060554504394531250000000000000000000000000000000000000000000e-25"),
- cpp_float("8.271806125530276748714086920699628535658121109008789062500000000000000000000000000000000000000000000e-25"),
- cpp_float("1.654361225106055349742817384139925707131624221801757812500000000000000000000000000000000000000000000e-24"),
- cpp_float("3.308722450212110699485634768279851414263248443603515625000000000000000000000000000000000000000000000e-24"),
- cpp_float("6.617444900424221398971269536559702828526496887207031250000000000000000000000000000000000000000000000e-24"),
- cpp_float("1.323488980084844279794253907311940565705299377441406250000000000000000000000000000000000000000000000e-23"),
- cpp_float("2.646977960169688559588507814623881131410598754882812500000000000000000000000000000000000000000000000e-23"),
- cpp_float("5.293955920339377119177015629247762262821197509765625000000000000000000000000000000000000000000000000e-23"),
- cpp_float("1.058791184067875423835403125849552452564239501953125000000000000000000000000000000000000000000000000e-22"),
- cpp_float("2.117582368135750847670806251699104905128479003906250000000000000000000000000000000000000000000000000e-22"),
- cpp_float("4.235164736271501695341612503398209810256958007812500000000000000000000000000000000000000000000000000e-22"),
- cpp_float("8.470329472543003390683225006796419620513916015625000000000000000000000000000000000000000000000000000e-22"),
- cpp_float("1.694065894508600678136645001359283924102783203125000000000000000000000000000000000000000000000000000e-21"),
- cpp_float("3.388131789017201356273290002718567848205566406250000000000000000000000000000000000000000000000000000e-21"),
- cpp_float("6.776263578034402712546580005437135696411132812500000000000000000000000000000000000000000000000000000e-21"),
- cpp_float("1.355252715606880542509316001087427139282226562500000000000000000000000000000000000000000000000000000e-20"),
- cpp_float("2.710505431213761085018632002174854278564453125000000000000000000000000000000000000000000000000000000e-20"),
- cpp_float("5.421010862427522170037264004349708557128906250000000000000000000000000000000000000000000000000000000e-20"),
- cpp_float("1.084202172485504434007452800869941711425781250000000000000000000000000000000000000000000000000000000e-19"),
- cpp_float("2.168404344971008868014905601739883422851562500000000000000000000000000000000000000000000000000000000e-19"),
- cpp_float("4.336808689942017736029811203479766845703125000000000000000000000000000000000000000000000000000000000e-19"),
- cpp_float("8.673617379884035472059622406959533691406250000000000000000000000000000000000000000000000000000000000e-19"),
- cpp_float("1.734723475976807094411924481391906738281250000000000000000000000000000000000000000000000000000000000e-18"),
- cpp_float("3.469446951953614188823848962783813476562500000000000000000000000000000000000000000000000000000000000e-18"),
- cpp_float("6.938893903907228377647697925567626953125000000000000000000000000000000000000000000000000000000000000e-18"),
- cpp_float("1.387778780781445675529539585113525390625000000000000000000000000000000000000000000000000000000000000e-17"),
- cpp_float("2.775557561562891351059079170227050781250000000000000000000000000000000000000000000000000000000000000e-17"),
- cpp_float("5.551115123125782702118158340454101562500000000000000000000000000000000000000000000000000000000000000e-17"),
- cpp_float("1.110223024625156540423631668090820312500000000000000000000000000000000000000000000000000000000000000e-16"),
- cpp_float("2.220446049250313080847263336181640625000000000000000000000000000000000000000000000000000000000000000e-16"),
- cpp_float("4.440892098500626161694526672363281250000000000000000000000000000000000000000000000000000000000000000e-16"),
- cpp_float("8.881784197001252323389053344726562500000000000000000000000000000000000000000000000000000000000000000e-16"),
- cpp_float("1.776356839400250464677810668945312500000000000000000000000000000000000000000000000000000000000000000e-15"),
- cpp_float("3.552713678800500929355621337890625000000000000000000000000000000000000000000000000000000000000000000e-15"),
- cpp_float("7.105427357601001858711242675781250000000000000000000000000000000000000000000000000000000000000000000e-15"),
- cpp_float("1.421085471520200371742248535156250000000000000000000000000000000000000000000000000000000000000000000e-14"),
- cpp_float("2.842170943040400743484497070312500000000000000000000000000000000000000000000000000000000000000000000e-14"),
- cpp_float("5.684341886080801486968994140625000000000000000000000000000000000000000000000000000000000000000000000e-14"),
- cpp_float("1.136868377216160297393798828125000000000000000000000000000000000000000000000000000000000000000000000e-13"),
- cpp_float("2.273736754432320594787597656250000000000000000000000000000000000000000000000000000000000000000000000e-13"),
- cpp_float("4.547473508864641189575195312500000000000000000000000000000000000000000000000000000000000000000000000e-13"),
- cpp_float("9.094947017729282379150390625000000000000000000000000000000000000000000000000000000000000000000000000e-13"),
- cpp_float("1.818989403545856475830078125000000000000000000000000000000000000000000000000000000000000000000000000e-12"),
- cpp_float("3.637978807091712951660156250000000000000000000000000000000000000000000000000000000000000000000000000e-12"),
- cpp_float("7.275957614183425903320312500000000000000000000000000000000000000000000000000000000000000000000000000e-12"),
- cpp_float("1.455191522836685180664062500000000000000000000000000000000000000000000000000000000000000000000000000e-11"),
- cpp_float("2.910383045673370361328125000000000000000000000000000000000000000000000000000000000000000000000000000e-11"),
- cpp_float("5.820766091346740722656250000000000000000000000000000000000000000000000000000000000000000000000000000e-11"),
- cpp_float("1.164153218269348144531250000000000000000000000000000000000000000000000000000000000000000000000000000e-10"),
- cpp_float("2.328306436538696289062500000000000000000000000000000000000000000000000000000000000000000000000000000e-10"),
- cpp_float("4.656612873077392578125000000000000000000000000000000000000000000000000000000000000000000000000000000e-10"),
- cpp_float("9.313225746154785156250000000000000000000000000000000000000000000000000000000000000000000000000000000e-10"),
- cpp_float("1.862645149230957031250000000000000000000000000000000000000000000000000000000000000000000000000000000e-9"),
- cpp_float("3.725290298461914062500000000000000000000000000000000000000000000000000000000000000000000000000000000e-9"),
- cpp_float("7.450580596923828125000000000000000000000000000000000000000000000000000000000000000000000000000000000e-9"),
- cpp_float("1.490116119384765625000000000000000000000000000000000000000000000000000000000000000000000000000000000e-8"),
- cpp_float("2.980232238769531250000000000000000000000000000000000000000000000000000000000000000000000000000000000e-8"),
- cpp_float("5.960464477539062500000000000000000000000000000000000000000000000000000000000000000000000000000000000e-8"),
- cpp_float("1.192092895507812500000000000000000000000000000000000000000000000000000000000000000000000000000000000e-7"),
- cpp_float("2.384185791015625000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-7"),
- cpp_float("4.768371582031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-7"),
- cpp_float("9.536743164062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-7"),
- cpp_float("1.907348632812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-6"),
- cpp_float("3.814697265625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-6"),
- cpp_float("7.629394531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-6"),
- cpp_float("0.000015258789062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.000030517578125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.000061035156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.000122070312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.000244140625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.000488281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.000976562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.001953125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.003906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.007812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.01562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.03125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.06250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.125"),
- cpp_float("0.25"),
- cpp_float("0.5"),
+ cpp_dec_float("5.877471754111437539843682686111228389093327783860437607543758531392086297273635864257812500000000000e-39"),
+ cpp_dec_float("1.175494350822287507968736537222245677818665556772087521508751706278417259454727172851562500000000000e-38"),
+ cpp_dec_float("2.350988701644575015937473074444491355637331113544175043017503412556834518909454345703125000000000000e-38"),
+ cpp_dec_float("4.701977403289150031874946148888982711274662227088350086035006825113669037818908691406250000000000000e-38"),
+ cpp_dec_float("9.403954806578300063749892297777965422549324454176700172070013650227338075637817382812500000000000000e-38"),
+ cpp_dec_float("1.880790961315660012749978459555593084509864890835340034414002730045467615127563476562500000000000000e-37"),
+ cpp_dec_float("3.761581922631320025499956919111186169019729781670680068828005460090935230255126953125000000000000000e-37"),
+ cpp_dec_float("7.523163845262640050999913838222372338039459563341360137656010920181870460510253906250000000000000000e-37"),
+ cpp_dec_float("1.504632769052528010199982767644474467607891912668272027531202184036374092102050781250000000000000000e-36"),
+ cpp_dec_float("3.009265538105056020399965535288948935215783825336544055062404368072748184204101562500000000000000000e-36"),
+ cpp_dec_float("6.018531076210112040799931070577897870431567650673088110124808736145496368408203125000000000000000000e-36"),
+ cpp_dec_float("1.203706215242022408159986214115579574086313530134617622024961747229099273681640625000000000000000000e-35"),
+ cpp_dec_float("2.407412430484044816319972428231159148172627060269235244049923494458198547363281250000000000000000000e-35"),
+ cpp_dec_float("4.814824860968089632639944856462318296345254120538470488099846988916397094726562500000000000000000000e-35"),
+ cpp_dec_float("9.629649721936179265279889712924636592690508241076940976199693977832794189453125000000000000000000000e-35"),
+ cpp_dec_float("1.925929944387235853055977942584927318538101648215388195239938795566558837890625000000000000000000000e-34"),
+ cpp_dec_float("3.851859888774471706111955885169854637076203296430776390479877591133117675781250000000000000000000000e-34"),
+ cpp_dec_float("7.703719777548943412223911770339709274152406592861552780959755182266235351562500000000000000000000000e-34"),
+ cpp_dec_float("1.540743955509788682444782354067941854830481318572310556191951036453247070312500000000000000000000000e-33"),
+ cpp_dec_float("3.081487911019577364889564708135883709660962637144621112383902072906494140625000000000000000000000000e-33"),
+ cpp_dec_float("6.162975822039154729779129416271767419321925274289242224767804145812988281250000000000000000000000000e-33"),
+ cpp_dec_float("1.232595164407830945955825883254353483864385054857848444953560829162597656250000000000000000000000000e-32"),
+ cpp_dec_float("2.465190328815661891911651766508706967728770109715696889907121658325195312500000000000000000000000000e-32"),
+ cpp_dec_float("4.930380657631323783823303533017413935457540219431393779814243316650390625000000000000000000000000000e-32"),
+ cpp_dec_float("9.860761315262647567646607066034827870915080438862787559628486633300781250000000000000000000000000000e-32"),
+ cpp_dec_float("1.972152263052529513529321413206965574183016087772557511925697326660156250000000000000000000000000000e-31"),
+ cpp_dec_float("3.944304526105059027058642826413931148366032175545115023851394653320312500000000000000000000000000000e-31"),
+ cpp_dec_float("7.888609052210118054117285652827862296732064351090230047702789306640625000000000000000000000000000000e-31"),
+ cpp_dec_float("1.577721810442023610823457130565572459346412870218046009540557861328125000000000000000000000000000000e-30"),
+ cpp_dec_float("3.155443620884047221646914261131144918692825740436092019081115722656250000000000000000000000000000000e-30"),
+ cpp_dec_float("6.310887241768094443293828522262289837385651480872184038162231445312500000000000000000000000000000000e-30"),
+ cpp_dec_float("1.262177448353618888658765704452457967477130296174436807632446289062500000000000000000000000000000000e-29"),
+ cpp_dec_float("2.524354896707237777317531408904915934954260592348873615264892578125000000000000000000000000000000000e-29"),
+ cpp_dec_float("5.048709793414475554635062817809831869908521184697747230529785156250000000000000000000000000000000000e-29"),
+ cpp_dec_float("1.009741958682895110927012563561966373981704236939549446105957031250000000000000000000000000000000000e-28"),
+ cpp_dec_float("2.019483917365790221854025127123932747963408473879098892211914062500000000000000000000000000000000000e-28"),
+ cpp_dec_float("4.038967834731580443708050254247865495926816947758197784423828125000000000000000000000000000000000000e-28"),
+ cpp_dec_float("8.077935669463160887416100508495730991853633895516395568847656250000000000000000000000000000000000000e-28"),
+ cpp_dec_float("1.615587133892632177483220101699146198370726779103279113769531250000000000000000000000000000000000000e-27"),
+ cpp_dec_float("3.231174267785264354966440203398292396741453558206558227539062500000000000000000000000000000000000000e-27"),
+ cpp_dec_float("6.462348535570528709932880406796584793482907116413116455078125000000000000000000000000000000000000000e-27"),
+ cpp_dec_float("1.292469707114105741986576081359316958696581423282623291015625000000000000000000000000000000000000000e-26"),
+ cpp_dec_float("2.584939414228211483973152162718633917393162846565246582031250000000000000000000000000000000000000000e-26"),
+ cpp_dec_float("5.169878828456422967946304325437267834786325693130493164062500000000000000000000000000000000000000000e-26"),
+ cpp_dec_float("1.033975765691284593589260865087453566957265138626098632812500000000000000000000000000000000000000000e-25"),
+ cpp_dec_float("2.067951531382569187178521730174907133914530277252197265625000000000000000000000000000000000000000000e-25"),
+ cpp_dec_float("4.135903062765138374357043460349814267829060554504394531250000000000000000000000000000000000000000000e-25"),
+ cpp_dec_float("8.271806125530276748714086920699628535658121109008789062500000000000000000000000000000000000000000000e-25"),
+ cpp_dec_float("1.654361225106055349742817384139925707131624221801757812500000000000000000000000000000000000000000000e-24"),
+ cpp_dec_float("3.308722450212110699485634768279851414263248443603515625000000000000000000000000000000000000000000000e-24"),
+ cpp_dec_float("6.617444900424221398971269536559702828526496887207031250000000000000000000000000000000000000000000000e-24"),
+ cpp_dec_float("1.323488980084844279794253907311940565705299377441406250000000000000000000000000000000000000000000000e-23"),
+ cpp_dec_float("2.646977960169688559588507814623881131410598754882812500000000000000000000000000000000000000000000000e-23"),
+ cpp_dec_float("5.293955920339377119177015629247762262821197509765625000000000000000000000000000000000000000000000000e-23"),
+ cpp_dec_float("1.058791184067875423835403125849552452564239501953125000000000000000000000000000000000000000000000000e-22"),
+ cpp_dec_float("2.117582368135750847670806251699104905128479003906250000000000000000000000000000000000000000000000000e-22"),
+ cpp_dec_float("4.235164736271501695341612503398209810256958007812500000000000000000000000000000000000000000000000000e-22"),
+ cpp_dec_float("8.470329472543003390683225006796419620513916015625000000000000000000000000000000000000000000000000000e-22"),
+ cpp_dec_float("1.694065894508600678136645001359283924102783203125000000000000000000000000000000000000000000000000000e-21"),
+ cpp_dec_float("3.388131789017201356273290002718567848205566406250000000000000000000000000000000000000000000000000000e-21"),
+ cpp_dec_float("6.776263578034402712546580005437135696411132812500000000000000000000000000000000000000000000000000000e-21"),
+ cpp_dec_float("1.355252715606880542509316001087427139282226562500000000000000000000000000000000000000000000000000000e-20"),
+ cpp_dec_float("2.710505431213761085018632002174854278564453125000000000000000000000000000000000000000000000000000000e-20"),
+ cpp_dec_float("5.421010862427522170037264004349708557128906250000000000000000000000000000000000000000000000000000000e-20"),
+ cpp_dec_float("1.084202172485504434007452800869941711425781250000000000000000000000000000000000000000000000000000000e-19"),
+ cpp_dec_float("2.168404344971008868014905601739883422851562500000000000000000000000000000000000000000000000000000000e-19"),
+ cpp_dec_float("4.336808689942017736029811203479766845703125000000000000000000000000000000000000000000000000000000000e-19"),
+ cpp_dec_float("8.673617379884035472059622406959533691406250000000000000000000000000000000000000000000000000000000000e-19"),
+ cpp_dec_float("1.734723475976807094411924481391906738281250000000000000000000000000000000000000000000000000000000000e-18"),
+ cpp_dec_float("3.469446951953614188823848962783813476562500000000000000000000000000000000000000000000000000000000000e-18"),
+ cpp_dec_float("6.938893903907228377647697925567626953125000000000000000000000000000000000000000000000000000000000000e-18"),
+ cpp_dec_float("1.387778780781445675529539585113525390625000000000000000000000000000000000000000000000000000000000000e-17"),
+ cpp_dec_float("2.775557561562891351059079170227050781250000000000000000000000000000000000000000000000000000000000000e-17"),
+ cpp_dec_float("5.551115123125782702118158340454101562500000000000000000000000000000000000000000000000000000000000000e-17"),
+ cpp_dec_float("1.110223024625156540423631668090820312500000000000000000000000000000000000000000000000000000000000000e-16"),
+ cpp_dec_float("2.220446049250313080847263336181640625000000000000000000000000000000000000000000000000000000000000000e-16"),
+ cpp_dec_float("4.440892098500626161694526672363281250000000000000000000000000000000000000000000000000000000000000000e-16"),
+ cpp_dec_float("8.881784197001252323389053344726562500000000000000000000000000000000000000000000000000000000000000000e-16"),
+ cpp_dec_float("1.776356839400250464677810668945312500000000000000000000000000000000000000000000000000000000000000000e-15"),
+ cpp_dec_float("3.552713678800500929355621337890625000000000000000000000000000000000000000000000000000000000000000000e-15"),
+ cpp_dec_float("7.105427357601001858711242675781250000000000000000000000000000000000000000000000000000000000000000000e-15"),
+ cpp_dec_float("1.421085471520200371742248535156250000000000000000000000000000000000000000000000000000000000000000000e-14"),
+ cpp_dec_float("2.842170943040400743484497070312500000000000000000000000000000000000000000000000000000000000000000000e-14"),
+ cpp_dec_float("5.684341886080801486968994140625000000000000000000000000000000000000000000000000000000000000000000000e-14"),
+ cpp_dec_float("1.136868377216160297393798828125000000000000000000000000000000000000000000000000000000000000000000000e-13"),
+ cpp_dec_float("2.273736754432320594787597656250000000000000000000000000000000000000000000000000000000000000000000000e-13"),
+ cpp_dec_float("4.547473508864641189575195312500000000000000000000000000000000000000000000000000000000000000000000000e-13"),
+ cpp_dec_float("9.094947017729282379150390625000000000000000000000000000000000000000000000000000000000000000000000000e-13"),
+ cpp_dec_float("1.818989403545856475830078125000000000000000000000000000000000000000000000000000000000000000000000000e-12"),
+ cpp_dec_float("3.637978807091712951660156250000000000000000000000000000000000000000000000000000000000000000000000000e-12"),
+ cpp_dec_float("7.275957614183425903320312500000000000000000000000000000000000000000000000000000000000000000000000000e-12"),
+ cpp_dec_float("1.455191522836685180664062500000000000000000000000000000000000000000000000000000000000000000000000000e-11"),
+ cpp_dec_float("2.910383045673370361328125000000000000000000000000000000000000000000000000000000000000000000000000000e-11"),
+ cpp_dec_float("5.820766091346740722656250000000000000000000000000000000000000000000000000000000000000000000000000000e-11"),
+ cpp_dec_float("1.164153218269348144531250000000000000000000000000000000000000000000000000000000000000000000000000000e-10"),
+ cpp_dec_float("2.328306436538696289062500000000000000000000000000000000000000000000000000000000000000000000000000000e-10"),
+ cpp_dec_float("4.656612873077392578125000000000000000000000000000000000000000000000000000000000000000000000000000000e-10"),
+ cpp_dec_float("9.313225746154785156250000000000000000000000000000000000000000000000000000000000000000000000000000000e-10"),
+ cpp_dec_float("1.862645149230957031250000000000000000000000000000000000000000000000000000000000000000000000000000000e-9"),
+ cpp_dec_float("3.725290298461914062500000000000000000000000000000000000000000000000000000000000000000000000000000000e-9"),
+ cpp_dec_float("7.450580596923828125000000000000000000000000000000000000000000000000000000000000000000000000000000000e-9"),
+ cpp_dec_float("1.490116119384765625000000000000000000000000000000000000000000000000000000000000000000000000000000000e-8"),
+ cpp_dec_float("2.980232238769531250000000000000000000000000000000000000000000000000000000000000000000000000000000000e-8"),
+ cpp_dec_float("5.960464477539062500000000000000000000000000000000000000000000000000000000000000000000000000000000000e-8"),
+ cpp_dec_float("1.192092895507812500000000000000000000000000000000000000000000000000000000000000000000000000000000000e-7"),
+ cpp_dec_float("2.384185791015625000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-7"),
+ cpp_dec_float("4.768371582031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-7"),
+ cpp_dec_float("9.536743164062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-7"),
+ cpp_dec_float("1.907348632812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-6"),
+ cpp_dec_float("3.814697265625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-6"),
+ cpp_dec_float("7.629394531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-6"),
+ cpp_dec_float("0.000015258789062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
+ cpp_dec_float("0.000030517578125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
+ cpp_dec_float("0.000061035156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
+ cpp_dec_float("0.000122070312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
+ cpp_dec_float("0.000244140625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
+ cpp_dec_float("0.000488281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
+ cpp_dec_float("0.000976562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
+ cpp_dec_float("0.001953125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
+ cpp_dec_float("0.003906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
+ cpp_dec_float("0.007812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
+ cpp_dec_float("0.01562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
+ cpp_dec_float("0.03125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
+ cpp_dec_float("0.06250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
+ cpp_dec_float("0.125"),
+ cpp_dec_float("0.25"),
+ cpp_dec_float("0.5"),
 one(),
 two(),
- cpp_float(static_cast<unsigned long long>(4)),
- cpp_float(static_cast<unsigned long long>(8)),
- cpp_float(static_cast<unsigned long long>(16)),
- cpp_float(static_cast<unsigned long long>(32)),
- cpp_float(static_cast<unsigned long long>(64)),
- cpp_float(static_cast<unsigned long long>(128)),
- cpp_float(static_cast<unsigned long long>(256)),
- cpp_float(static_cast<unsigned long long>(512)),
- cpp_float(static_cast<unsigned long long>(1024)),
- cpp_float(static_cast<unsigned long long>(2048)),
- cpp_float(static_cast<unsigned long long>(4096)),
- cpp_float(static_cast<unsigned long long>(8192)),
- cpp_float(static_cast<unsigned long long>(16384)),
- cpp_float(static_cast<unsigned long long>(32768)),
- cpp_float(static_cast<unsigned long long>(65536)),
- cpp_float(static_cast<unsigned long long>(131072)),
- cpp_float(static_cast<unsigned long long>(262144)),
- cpp_float(static_cast<unsigned long long>(524288)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 20u)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 21u)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 22u)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 23u)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 24u)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 25u)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 26u)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 27u)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 28u)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 29u)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 30u)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 31u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 32u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 33u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 34u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 35u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 36u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 37u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 38u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 39u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 40u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 41u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 42u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 43u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 44u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 45u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 46u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 47u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 48u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 49u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 50u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 51u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 52u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 53u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 54u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 55u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 56u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 57u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 58u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 59u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 60u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 61u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 62u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 63u)),
- cpp_float("1.844674407370955161600000000000000000000000000000000000000000000000000000000000000000000000000000000e19"),
- cpp_float("3.689348814741910323200000000000000000000000000000000000000000000000000000000000000000000000000000000e19"),
- cpp_float("7.378697629483820646400000000000000000000000000000000000000000000000000000000000000000000000000000000e19"),
- cpp_float("1.475739525896764129280000000000000000000000000000000000000000000000000000000000000000000000000000000e20"),
- cpp_float("2.951479051793528258560000000000000000000000000000000000000000000000000000000000000000000000000000000e20"),
- cpp_float("5.902958103587056517120000000000000000000000000000000000000000000000000000000000000000000000000000000e20"),
- cpp_float("1.180591620717411303424000000000000000000000000000000000000000000000000000000000000000000000000000000e21"),
- cpp_float("2.361183241434822606848000000000000000000000000000000000000000000000000000000000000000000000000000000e21"),
- cpp_float("4.722366482869645213696000000000000000000000000000000000000000000000000000000000000000000000000000000e21"),
- cpp_float("9.444732965739290427392000000000000000000000000000000000000000000000000000000000000000000000000000000e21"),
- cpp_float("1.888946593147858085478400000000000000000000000000000000000000000000000000000000000000000000000000000e22"),
- cpp_float("3.777893186295716170956800000000000000000000000000000000000000000000000000000000000000000000000000000e22"),
- cpp_float("7.555786372591432341913600000000000000000000000000000000000000000000000000000000000000000000000000000e22"),
- cpp_float("1.511157274518286468382720000000000000000000000000000000000000000000000000000000000000000000000000000e23"),
- cpp_float("3.022314549036572936765440000000000000000000000000000000000000000000000000000000000000000000000000000e23"),
- cpp_float("6.044629098073145873530880000000000000000000000000000000000000000000000000000000000000000000000000000e23"),
- cpp_float("1.208925819614629174706176000000000000000000000000000000000000000000000000000000000000000000000000000e24"),
- cpp_float("2.417851639229258349412352000000000000000000000000000000000000000000000000000000000000000000000000000e24"),
- cpp_float("4.835703278458516698824704000000000000000000000000000000000000000000000000000000000000000000000000000e24"),
- cpp_float("9.671406556917033397649408000000000000000000000000000000000000000000000000000000000000000000000000000e24"),
- cpp_float("1.934281311383406679529881600000000000000000000000000000000000000000000000000000000000000000000000000e25"),
- cpp_float("3.868562622766813359059763200000000000000000000000000000000000000000000000000000000000000000000000000e25"),
- cpp_float("7.737125245533626718119526400000000000000000000000000000000000000000000000000000000000000000000000000e25"),
- cpp_float("1.547425049106725343623905280000000000000000000000000000000000000000000000000000000000000000000000000e26"),
- cpp_float("3.094850098213450687247810560000000000000000000000000000000000000000000000000000000000000000000000000e26"),
- cpp_float("6.189700196426901374495621120000000000000000000000000000000000000000000000000000000000000000000000000e26"),
- cpp_float("1.237940039285380274899124224000000000000000000000000000000000000000000000000000000000000000000000000e27"),
- cpp_float("2.475880078570760549798248448000000000000000000000000000000000000000000000000000000000000000000000000e27"),
- cpp_float("4.951760157141521099596496896000000000000000000000000000000000000000000000000000000000000000000000000e27"),
- cpp_float("9.903520314283042199192993792000000000000000000000000000000000000000000000000000000000000000000000000e27"),
- cpp_float("1.980704062856608439838598758400000000000000000000000000000000000000000000000000000000000000000000000e28"),
- cpp_float("3.961408125713216879677197516800000000000000000000000000000000000000000000000000000000000000000000000e28"),
- cpp_float("7.922816251426433759354395033600000000000000000000000000000000000000000000000000000000000000000000000e28"),
- cpp_float("1.584563250285286751870879006720000000000000000000000000000000000000000000000000000000000000000000000e29"),
- cpp_float("3.169126500570573503741758013440000000000000000000000000000000000000000000000000000000000000000000000e29"),
- cpp_float("6.338253001141147007483516026880000000000000000000000000000000000000000000000000000000000000000000000e29"),
- cpp_float("1.267650600228229401496703205376000000000000000000000000000000000000000000000000000000000000000000000e30"),
- cpp_float("2.535301200456458802993406410752000000000000000000000000000000000000000000000000000000000000000000000e30"),
- cpp_float("5.070602400912917605986812821504000000000000000000000000000000000000000000000000000000000000000000000e30"),
- cpp_float("1.014120480182583521197362564300800000000000000000000000000000000000000000000000000000000000000000000e31"),
- cpp_float("2.028240960365167042394725128601600000000000000000000000000000000000000000000000000000000000000000000e31"),
- cpp_float("4.056481920730334084789450257203200000000000000000000000000000000000000000000000000000000000000000000e31"),
- cpp_float("8.112963841460668169578900514406400000000000000000000000000000000000000000000000000000000000000000000e31"),
- cpp_float("1.622592768292133633915780102881280000000000000000000000000000000000000000000000000000000000000000000e32"),
- cpp_float("3.245185536584267267831560205762560000000000000000000000000000000000000000000000000000000000000000000e32"),
- cpp_float("6.490371073168534535663120411525120000000000000000000000000000000000000000000000000000000000000000000e32"),
- cpp_float("1.298074214633706907132624082305024000000000000000000000000000000000000000000000000000000000000000000e33"),
- cpp_float("2.596148429267413814265248164610048000000000000000000000000000000000000000000000000000000000000000000e33"),
- cpp_float("5.192296858534827628530496329220096000000000000000000000000000000000000000000000000000000000000000000e33"),
- cpp_float("1.038459371706965525706099265844019200000000000000000000000000000000000000000000000000000000000000000e34"),
- cpp_float("2.076918743413931051412198531688038400000000000000000000000000000000000000000000000000000000000000000e34"),
- cpp_float("4.153837486827862102824397063376076800000000000000000000000000000000000000000000000000000000000000000e34"),
- cpp_float("8.307674973655724205648794126752153600000000000000000000000000000000000000000000000000000000000000000e34"),
- cpp_float("1.661534994731144841129758825350430720000000000000000000000000000000000000000000000000000000000000000e35"),
- cpp_float("3.323069989462289682259517650700861440000000000000000000000000000000000000000000000000000000000000000e35"),
- cpp_float("6.646139978924579364519035301401722880000000000000000000000000000000000000000000000000000000000000000e35"),
- cpp_float("1.329227995784915872903807060280344576000000000000000000000000000000000000000000000000000000000000000e36"),
- cpp_float("2.658455991569831745807614120560689152000000000000000000000000000000000000000000000000000000000000000e36"),
- cpp_float("5.316911983139663491615228241121378304000000000000000000000000000000000000000000000000000000000000000e36"),
- cpp_float("1.063382396627932698323045648224275660800000000000000000000000000000000000000000000000000000000000000e37"),
- cpp_float("2.126764793255865396646091296448551321600000000000000000000000000000000000000000000000000000000000000e37"),
- cpp_float("4.253529586511730793292182592897102643200000000000000000000000000000000000000000000000000000000000000e37"),
- cpp_float("8.507059173023461586584365185794205286400000000000000000000000000000000000000000000000000000000000000e37"),
- cpp_float("1.701411834604692317316873037158841057280000000000000000000000000000000000000000000000000000000000000e38")
+ cpp_dec_float(static_cast<unsigned long long>(4)),
+ cpp_dec_float(static_cast<unsigned long long>(8)),
+ cpp_dec_float(static_cast<unsigned long long>(16)),
+ cpp_dec_float(static_cast<unsigned long long>(32)),
+ cpp_dec_float(static_cast<unsigned long long>(64)),
+ cpp_dec_float(static_cast<unsigned long long>(128)),
+ cpp_dec_float(static_cast<unsigned long long>(256)),
+ cpp_dec_float(static_cast<unsigned long long>(512)),
+ cpp_dec_float(static_cast<unsigned long long>(1024)),
+ cpp_dec_float(static_cast<unsigned long long>(2048)),
+ cpp_dec_float(static_cast<unsigned long long>(4096)),
+ cpp_dec_float(static_cast<unsigned long long>(8192)),
+ cpp_dec_float(static_cast<unsigned long long>(16384)),
+ cpp_dec_float(static_cast<unsigned long long>(32768)),
+ cpp_dec_float(static_cast<unsigned long long>(65536)),
+ cpp_dec_float(static_cast<unsigned long long>(131072)),
+ cpp_dec_float(static_cast<unsigned long long>(262144)),
+ cpp_dec_float(static_cast<unsigned long long>(524288)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uL << 20u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uL << 21u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uL << 22u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uL << 23u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uL << 24u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uL << 25u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uL << 26u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uL << 27u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uL << 28u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uL << 29u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uL << 30u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uL << 31u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 32u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 33u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 34u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 35u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 36u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 37u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 38u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 39u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 40u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 41u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 42u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 43u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 44u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 45u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 46u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 47u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 48u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 49u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 50u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 51u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 52u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 53u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 54u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 55u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 56u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 57u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 58u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 59u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 60u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 61u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 62u)),
+ cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 63u)),
+ cpp_dec_float("1.844674407370955161600000000000000000000000000000000000000000000000000000000000000000000000000000000e19"),
+ cpp_dec_float("3.689348814741910323200000000000000000000000000000000000000000000000000000000000000000000000000000000e19"),
+ cpp_dec_float("7.378697629483820646400000000000000000000000000000000000000000000000000000000000000000000000000000000e19"),
+ cpp_dec_float("1.475739525896764129280000000000000000000000000000000000000000000000000000000000000000000000000000000e20"),
+ cpp_dec_float("2.951479051793528258560000000000000000000000000000000000000000000000000000000000000000000000000000000e20"),
+ cpp_dec_float("5.902958103587056517120000000000000000000000000000000000000000000000000000000000000000000000000000000e20"),
+ cpp_dec_float("1.180591620717411303424000000000000000000000000000000000000000000000000000000000000000000000000000000e21"),
+ cpp_dec_float("2.361183241434822606848000000000000000000000000000000000000000000000000000000000000000000000000000000e21"),
+ cpp_dec_float("4.722366482869645213696000000000000000000000000000000000000000000000000000000000000000000000000000000e21"),
+ cpp_dec_float("9.444732965739290427392000000000000000000000000000000000000000000000000000000000000000000000000000000e21"),
+ cpp_dec_float("1.888946593147858085478400000000000000000000000000000000000000000000000000000000000000000000000000000e22"),
+ cpp_dec_float("3.777893186295716170956800000000000000000000000000000000000000000000000000000000000000000000000000000e22"),
+ cpp_dec_float("7.555786372591432341913600000000000000000000000000000000000000000000000000000000000000000000000000000e22"),
+ cpp_dec_float("1.511157274518286468382720000000000000000000000000000000000000000000000000000000000000000000000000000e23"),
+ cpp_dec_float("3.022314549036572936765440000000000000000000000000000000000000000000000000000000000000000000000000000e23"),
+ cpp_dec_float("6.044629098073145873530880000000000000000000000000000000000000000000000000000000000000000000000000000e23"),
+ cpp_dec_float("1.208925819614629174706176000000000000000000000000000000000000000000000000000000000000000000000000000e24"),
+ cpp_dec_float("2.417851639229258349412352000000000000000000000000000000000000000000000000000000000000000000000000000e24"),
+ cpp_dec_float("4.835703278458516698824704000000000000000000000000000000000000000000000000000000000000000000000000000e24"),
+ cpp_dec_float("9.671406556917033397649408000000000000000000000000000000000000000000000000000000000000000000000000000e24"),
+ cpp_dec_float("1.934281311383406679529881600000000000000000000000000000000000000000000000000000000000000000000000000e25"),
+ cpp_dec_float("3.868562622766813359059763200000000000000000000000000000000000000000000000000000000000000000000000000e25"),
+ cpp_dec_float("7.737125245533626718119526400000000000000000000000000000000000000000000000000000000000000000000000000e25"),
+ cpp_dec_float("1.547425049106725343623905280000000000000000000000000000000000000000000000000000000000000000000000000e26"),
+ cpp_dec_float("3.094850098213450687247810560000000000000000000000000000000000000000000000000000000000000000000000000e26"),
+ cpp_dec_float("6.189700196426901374495621120000000000000000000000000000000000000000000000000000000000000000000000000e26"),
+ cpp_dec_float("1.237940039285380274899124224000000000000000000000000000000000000000000000000000000000000000000000000e27"),
+ cpp_dec_float("2.475880078570760549798248448000000000000000000000000000000000000000000000000000000000000000000000000e27"),
+ cpp_dec_float("4.951760157141521099596496896000000000000000000000000000000000000000000000000000000000000000000000000e27"),
+ cpp_dec_float("9.903520314283042199192993792000000000000000000000000000000000000000000000000000000000000000000000000e27"),
+ cpp_dec_float("1.980704062856608439838598758400000000000000000000000000000000000000000000000000000000000000000000000e28"),
+ cpp_dec_float("3.961408125713216879677197516800000000000000000000000000000000000000000000000000000000000000000000000e28"),
+ cpp_dec_float("7.922816251426433759354395033600000000000000000000000000000000000000000000000000000000000000000000000e28"),
+ cpp_dec_float("1.584563250285286751870879006720000000000000000000000000000000000000000000000000000000000000000000000e29"),
+ cpp_dec_float("3.169126500570573503741758013440000000000000000000000000000000000000000000000000000000000000000000000e29"),
+ cpp_dec_float("6.338253001141147007483516026880000000000000000000000000000000000000000000000000000000000000000000000e29"),
+ cpp_dec_float("1.267650600228229401496703205376000000000000000000000000000000000000000000000000000000000000000000000e30"),
+ cpp_dec_float("2.535301200456458802993406410752000000000000000000000000000000000000000000000000000000000000000000000e30"),
+ cpp_dec_float("5.070602400912917605986812821504000000000000000000000000000000000000000000000000000000000000000000000e30"),
+ cpp_dec_float("1.014120480182583521197362564300800000000000000000000000000000000000000000000000000000000000000000000e31"),
+ cpp_dec_float("2.028240960365167042394725128601600000000000000000000000000000000000000000000000000000000000000000000e31"),
+ cpp_dec_float("4.056481920730334084789450257203200000000000000000000000000000000000000000000000000000000000000000000e31"),
+ cpp_dec_float("8.112963841460668169578900514406400000000000000000000000000000000000000000000000000000000000000000000e31"),
+ cpp_dec_float("1.622592768292133633915780102881280000000000000000000000000000000000000000000000000000000000000000000e32"),
+ cpp_dec_float("3.245185536584267267831560205762560000000000000000000000000000000000000000000000000000000000000000000e32"),
+ cpp_dec_float("6.490371073168534535663120411525120000000000000000000000000000000000000000000000000000000000000000000e32"),
+ cpp_dec_float("1.298074214633706907132624082305024000000000000000000000000000000000000000000000000000000000000000000e33"),
+ cpp_dec_float("2.596148429267413814265248164610048000000000000000000000000000000000000000000000000000000000000000000e33"),
+ cpp_dec_float("5.192296858534827628530496329220096000000000000000000000000000000000000000000000000000000000000000000e33"),
+ cpp_dec_float("1.038459371706965525706099265844019200000000000000000000000000000000000000000000000000000000000000000e34"),
+ cpp_dec_float("2.076918743413931051412198531688038400000000000000000000000000000000000000000000000000000000000000000e34"),
+ cpp_dec_float("4.153837486827862102824397063376076800000000000000000000000000000000000000000000000000000000000000000e34"),
+ cpp_dec_float("8.307674973655724205648794126752153600000000000000000000000000000000000000000000000000000000000000000e34"),
+ cpp_dec_float("1.661534994731144841129758825350430720000000000000000000000000000000000000000000000000000000000000000e35"),
+ cpp_dec_float("3.323069989462289682259517650700861440000000000000000000000000000000000000000000000000000000000000000e35"),
+ cpp_dec_float("6.646139978924579364519035301401722880000000000000000000000000000000000000000000000000000000000000000e35"),
+ cpp_dec_float("1.329227995784915872903807060280344576000000000000000000000000000000000000000000000000000000000000000e36"),
+ cpp_dec_float("2.658455991569831745807614120560689152000000000000000000000000000000000000000000000000000000000000000e36"),
+ cpp_dec_float("5.316911983139663491615228241121378304000000000000000000000000000000000000000000000000000000000000000e36"),
+ cpp_dec_float("1.063382396627932698323045648224275660800000000000000000000000000000000000000000000000000000000000000e37"),
+ cpp_dec_float("2.126764793255865396646091296448551321600000000000000000000000000000000000000000000000000000000000000e37"),
+ cpp_dec_float("4.253529586511730793292182592897102643200000000000000000000000000000000000000000000000000000000000000e37"),
+ cpp_dec_float("8.507059173023461586584365185794205286400000000000000000000000000000000000000000000000000000000000000e37"),
+ cpp_dec_float("1.701411834604692317316873037158841057280000000000000000000000000000000000000000000000000000000000000e38")
 }};

 if((p > static_cast<boost::int64_t>(-128)) && (p < static_cast<boost::int64_t>(+128)))
@@ -2523,11 +2523,11 @@
 else if(p < static_cast<boost::int64_t>(std::numeric_limits<boost::uint64_t>::digits))
 {
 const boost::uint64_t p2 = static_cast<boost::uint64_t>(static_cast<boost::uint64_t>(1uLL) << p);
- return cpp_float(p2);
+ return cpp_dec_float(p2);
 }
 else
 {
- cpp_float<Digits10> t;
+ cpp_dec_float<Digits10> t;
 default_ops::detail::pow_imp(t, two(), p, mpl::true_());
 return t;
 }
@@ -2535,49 +2535,49 @@

template <unsigned Digits10>
-inline void add(cpp_float<Digits10>& result, const cpp_float<Digits10>& o)
+inline void add(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& o)
{
 result += o;
}
template <unsigned Digits10>
-inline void subtract(cpp_float<Digits10>& result, const cpp_float<Digits10>& o)
+inline void subtract(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& o)
{
 result -= o;
}
template <unsigned Digits10>
-inline void multiply(cpp_float<Digits10>& result, const cpp_float<Digits10>& o)
+inline void multiply(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& o)
{
 result *= o;
}
template <unsigned Digits10>
-inline void divide(cpp_float<Digits10>& result, const cpp_float<Digits10>& o)
+inline void divide(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& o)
{
 result /= o;
}

template <unsigned Digits10>
-inline void add(cpp_float<Digits10>& result, const unsigned long long& o)
+inline void add(cpp_dec_float<Digits10>& result, const unsigned long long& o)
{
 result.add_unsigned_long_long(o);
}
template <unsigned Digits10>
-inline void subtract(cpp_float<Digits10>& result, const unsigned long long& o)
+inline void subtract(cpp_dec_float<Digits10>& result, const unsigned long long& o)
{
 result.sub_unsigned_long_long(o);
}
template <unsigned Digits10>
-inline void multiply(cpp_float<Digits10>& result, const unsigned long long& o)
+inline void multiply(cpp_dec_float<Digits10>& result, const unsigned long long& o)
{
 result.mul_unsigned_long_long(o);
}
template <unsigned Digits10>
-inline void divide(cpp_float<Digits10>& result, const unsigned long long& o)
+inline void divide(cpp_dec_float<Digits10>& result, const unsigned long long& o)
{
 result.div_unsigned_long_long(o);
}

template <unsigned Digits10>
-inline void add(cpp_float<Digits10>& result, long long o)
+inline void add(cpp_dec_float<Digits10>& result, long long o)
{
 if(o < 0)
 result.sub_unsigned_long_long(-o);
@@ -2585,7 +2585,7 @@
 result.add_unsigned_long_long(o);
}
template <unsigned Digits10>
-inline void subtract(cpp_float<Digits10>& result, long long o)
+inline void subtract(cpp_dec_float<Digits10>& result, long long o)
{
 if(o < 0)
 result.add_unsigned_long_long(-o);
@@ -2593,7 +2593,7 @@
 result.sub_unsigned_long_long(o);
}
template <unsigned Digits10>
-inline void multiply(cpp_float<Digits10>& result, long long o)
+inline void multiply(cpp_dec_float<Digits10>& result, long long o)
{
 if(o < 0)
 {
@@ -2604,7 +2604,7 @@
 result.mul_unsigned_long_long(o);
}
template <unsigned Digits10>
-inline void divide(cpp_float<Digits10>& result, long long o)
+inline void divide(cpp_dec_float<Digits10>& result, long long o)
{
 if(o < 0)
 {
@@ -2616,17 +2616,17 @@
}

template <unsigned Digits10>
-inline void convert_to(unsigned long long* result, const cpp_float<Digits10>& val)
+inline void convert_to(unsigned long long* result, const cpp_dec_float<Digits10>& val)
{
 *result = val.extract_unsigned_long_long();
}
template <unsigned Digits10>
-inline void convert_to(long long* result, const cpp_float<Digits10>& val)
+inline void convert_to(long long* result, const cpp_dec_float<Digits10>& val)
{
 *result = val.extract_signed_long_long();
}
template <unsigned Digits10>
-inline void convert_to(long double* result, cpp_float<Digits10>& val)
+inline void convert_to(long double* result, cpp_dec_float<Digits10>& val)
{
 *result = val.extract_long_double();
}
@@ -2635,7 +2635,7 @@
// Non member function support:
//
template <unsigned Digits10>
-inline int eval_fpclassify(const cpp_float<Digits10>& x)
+inline int eval_fpclassify(const cpp_dec_float<Digits10>& x)
{
 if(x.isinf())
 return FP_INFINITE;
@@ -2647,7 +2647,7 @@
}

template <unsigned Digits10>
-inline void eval_abs(cpp_float<Digits10>& result, const cpp_float<Digits10>& x)
+inline void eval_abs(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& x)
{
 result = x;
 if(x.isneg())
@@ -2655,7 +2655,7 @@
}

template <unsigned Digits10>
-inline void eval_fabs(cpp_float<Digits10>& result, const cpp_float<Digits10>& x)
+inline void eval_fabs(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& x)
{
 result = x;
 if(x.isneg())
@@ -2663,14 +2663,14 @@
}

template <unsigned Digits10>
-inline void eval_sqrt(cpp_float<Digits10>& result, const cpp_float<Digits10>& x)
+inline void eval_sqrt(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& x)
{
 result = x;
 result.calculate_sqrt();
}

template <unsigned Digits10>
-inline void eval_floor(cpp_float<Digits10>& result, const cpp_float<Digits10>& x)
+inline void eval_floor(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& x)
{
 result = x;
 if(!x.isfinite() || x.isint())
@@ -2679,12 +2679,12 @@
 }

 if(x.isneg())
- result -= cpp_float<Digits10>::one();
+ result -= cpp_dec_float<Digits10>::one();
 result = result.extract_integer_part();
}

template <unsigned Digits10>
-inline void eval_ceil(cpp_float<Digits10>& result, const cpp_float<Digits10>& x)
+inline void eval_ceil(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& x)
{
 result = x;
 if(!x.isfinite() || x.isint())
@@ -2693,16 +2693,16 @@
 }

 if(!x.isneg())
- result += cpp_float<Digits10>::one();
+ result += cpp_dec_float<Digits10>::one();
 result = result.extract_integer_part();
}

template <unsigned Digits10>
-inline void eval_trunc(cpp_float<Digits10>& result, const cpp_float<Digits10>& x)
+inline void eval_trunc(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& x)
{
 if(!x.isfinite())
 {
- result = boost::math::policies::raise_rounding_error("boost::multiprecision::trunc<%1%>(%1%)", 0, mp_number<cpp_float<Digits10> >(x), 0, boost::math::policies::policy<>()).backend();
+ result = boost::math::policies::raise_rounding_error("boost::multiprecision::trunc<%1%>(%1%)", 0, mp_number<cpp_dec_float<Digits10> >(x), 0, boost::math::policies::policy<>()).backend();
 return;
 }
 else if(x.isint())
@@ -2714,14 +2714,14 @@
}

template <unsigned Digits10>
-inline void eval_ldexp(cpp_float<Digits10>& result, const cpp_float<Digits10>& x, long long e)
+inline void eval_ldexp(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& x, long long e)
{
 result = x;
- result *= cpp_float<Digits10>::pow2(e);
+ result *= cpp_dec_float<Digits10>::pow2(e);
}

template <unsigned Digits10>
-inline void eval_frexp(cpp_float<Digits10>& result, const cpp_float<Digits10>& x, long long* e)
+inline void eval_frexp(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& x, long long* e)
{
 result = x;
 if(result.isneg())
@@ -2746,7 +2746,7 @@
 t *= 1000;
 }

- result *= cpp_float<Digits10>::pow2(-t);
+ result *= cpp_dec_float<Digits10>::pow2(-t);

 if(result.iszero() || result.isinf() || result.isnan())
 {
@@ -2755,14 +2755,14 @@
 if(result.isneg())
 result.negate();
 t /= 2;
- result *= cpp_float<Digits10>::pow2(-t);
+ result *= cpp_dec_float<Digits10>::pow2(-t);
 }
 BOOST_MP_USING_ABS
 if(abs(result.order()) > 5)
 {
 // If our first estimate doesn't get close enough then try recursion until we do:
 long long e2;
- cpp_float<Digits10> r2;
+ cpp_dec_float<Digits10> r2;
 eval_frexp(r2, result, &e2);
 // overflow prtection:
 if((t > 0) && (e2 > 0) && (t > (std::numeric_limits<long long>::max)() - e2))
@@ -2773,14 +2773,14 @@
 result = r2;
 }

- while(result.compare(cpp_float<Digits10>::one()) >= 0)
+ while(result.compare(cpp_dec_float<Digits10>::one()) >= 0)
 {
- result /= cpp_float<Digits10>::two();
+ result /= cpp_dec_float<Digits10>::two();
 ++t;
 }
- while(result.compare(cpp_float<Digits10>::half()) < 0)
+ while(result.compare(cpp_dec_float<Digits10>::half()) < 0)
 {
- result *= cpp_float<Digits10>::two();
+ result *= cpp_dec_float<Digits10>::two();
 --t;
 }
 *e = t;
@@ -2789,7 +2789,7 @@
}

template <unsigned Digits10>
-inline void eval_frexp(cpp_float<Digits10>& result, const cpp_float<Digits10>& x, int* e)
+inline void eval_frexp(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& x, int* e)
{
 long long t;
 eval_frexp(result, x, &t);
@@ -2799,26 +2799,26 @@
}

template <unsigned Digits10>
-inline bool is_zero(const cpp_float<Digits10>& val)
+inline bool is_zero(const cpp_dec_float<Digits10>& val)
{
 return val.iszero();
}
template <unsigned Digits10>
-inline int get_sign(const cpp_float<Digits10>& val)
+inline int get_sign(const cpp_dec_float<Digits10>& val)
{
 return val.iszero() ? 0 : val.isneg() ? -1 : 1;
}

-typedef mp_number<cpp_float<50> > cpp_float_50;
-typedef mp_number<cpp_float<100> > cpp_float_100;
+typedef mp_number<cpp_dec_float<50> > cpp_float_50;
+typedef mp_number<cpp_dec_float<100> > cpp_float_100;

}}

namespace std
{
 template <unsigned Digits10>
- class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > >
+ class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10> > >
 {
 public:
 static const bool is_specialized = true;
@@ -2829,13 +2829,13 @@
 static const bool is_modulo = false;
 static const bool is_iec559 = false;
 static const int digits = Digits10;
- static const int digits10 = boost::multiprecision::cpp_float<Digits10>::cpp_float_digits10;
- static const int max_digits10 = boost::multiprecision::cpp_float<Digits10>::cpp_float_max_digits10;
- static const boost::int64_t min_exponent = boost::multiprecision::cpp_float<Digits10>::cpp_float_min_exp; // Type differs from int.
- static const boost::int64_t min_exponent10 = boost::multiprecision::cpp_float<Digits10>::cpp_float_min_exp10; // Type differs from int.
- static const boost::int64_t max_exponent = boost::multiprecision::cpp_float<Digits10>::cpp_float_max_exp; // Type differs from int.
- static const boost::int64_t max_exponent10 = boost::multiprecision::cpp_float<Digits10>::cpp_float_max_exp10; // Type differs from int.
- static const int radix = boost::multiprecision::cpp_float<Digits10>::mp_radix;
+ static const int digits10 = boost::multiprecision::cpp_dec_float<Digits10>::cpp_float_digits10;
+ static const int max_digits10 = boost::multiprecision::cpp_dec_float<Digits10>::cpp_float_max_digits10;
+ static const boost::int64_t min_exponent = boost::multiprecision::cpp_dec_float<Digits10>::cpp_float_min_exp; // Type differs from int.
+ static const boost::int64_t min_exponent10 = boost::multiprecision::cpp_dec_float<Digits10>::cpp_float_min_exp10; // Type differs from int.
+ static const boost::int64_t max_exponent = boost::multiprecision::cpp_dec_float<Digits10>::cpp_float_max_exp; // Type differs from int.
+ static const boost::int64_t max_exponent10 = boost::multiprecision::cpp_dec_float<Digits10>::cpp_float_max_exp10; // Type differs from int.
+ static const int radix = boost::multiprecision::cpp_dec_float<Digits10>::mp_radix;
 static const std::float_round_style round_style = std::round_to_nearest;
 static const bool has_infinity = true;
 static const bool has_quiet_NaN = true;
@@ -2845,15 +2845,15 @@
 static const bool traps = false;
 static const bool tinyness_before = false;

- static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > (min) (void) { return (boost::multiprecision::cpp_float<Digits10>::min)(); }
- static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > (max) (void) { return (boost::multiprecision::cpp_float<Digits10>::max)(); }
- static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > lowest (void) { return boost::multiprecision::cpp_float<Digits10>::zero(); }
- static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > epsilon (void) { return boost::multiprecision::cpp_float<Digits10>::eps(); }
- static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > round_error (void) { return 0.5L; }
- static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > infinity (void) { return boost::multiprecision::cpp_float<Digits10>::inf(); }
- static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > quiet_NaN (void) { return boost::multiprecision::cpp_float<Digits10>::nan(); }
- static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > signaling_NaN(void) { return boost::multiprecision::cpp_float<Digits10>::zero(); }
- static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > denorm_min (void) { return boost::multiprecision::cpp_float<Digits10>::zero(); }
+ static const boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10> > (min) (void) { return (boost::multiprecision::cpp_dec_float<Digits10>::min)(); }
+ static const boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10> > (max) (void) { return (boost::multiprecision::cpp_dec_float<Digits10>::max)(); }
+ static const boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10> > lowest (void) { return boost::multiprecision::cpp_dec_float<Digits10>::zero(); }
+ static const boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10> > epsilon (void) { return boost::multiprecision::cpp_dec_float<Digits10>::eps(); }
+ static const boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10> > round_error (void) { return 0.5L; }
+ static const boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10> > infinity (void) { return boost::multiprecision::cpp_dec_float<Digits10>::inf(); }
+ static const boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10> > quiet_NaN (void) { return boost::multiprecision::cpp_dec_float<Digits10>::nan(); }
+ static const boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10> > signaling_NaN(void) { return boost::multiprecision::cpp_dec_float<Digits10>::zero(); }
+ static const boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10> > denorm_min (void) { return boost::multiprecision::cpp_dec_float<Digits10>::zero(); }
 };
}

@@ -2862,7 +2862,7 @@
namespace policies{

template <unsigned Digits10, class Policy>
-struct precision< boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> >, Policy>
+struct precision< boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10> >, Policy>
{
 typedef typename Policy::precision_type precision_type;
 typedef digits2<((Digits10 + 1) * 1000L) / 301L> digits_2;

Deleted: sandbox/big_number/boost/multiprecision/cpp_float.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/cpp_float.hpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
+++ (empty file)
@@ -1,2885 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// Copyright Christopher Kormanyos 2002 - 2011.
-// Copyright 2011 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_0.txt)
-//
-// This work is based on an earlier work:
-// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
-// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469
-//
-
-#ifndef BOOST_MP_EFX_BACKEND_HPP
-#define BOOST_MP_EFX_BACKEND_HPP
-
-#include <boost/cstdint.hpp>
-#include <boost/array.hpp>
-#include <boost/multiprecision/mp_number.hpp>
-#include <boost/multiprecision/detail/big_lanczos.hpp>
-
-//
-// Headers required for Boost.Math integration:
-//
-#include <boost/math/policies/policy.hpp>
-
-namespace boost{
-namespace multiprecision{
-
-template <unsigned Digits10>
-class cpp_float
-{
-public:
- typedef mpl::list<long long> signed_types;
- typedef mpl::list<unsigned long long> unsigned_types;
- typedef mpl::list<long double> float_types;
- typedef long long exponent_type;
-
-
- static const boost::int32_t mp_radix = 10;
- static const boost::int32_t cpp_float_digits = Digits10;
-
- static const boost::int32_t cpp_float_digits10_setting = Digits10;
- static const boost::int32_t cpp_float_digits10_limit = boost::integer_traits<boost::int32_t>::const_max;
- static const boost::int32_t cpp_float_digits10 = ((cpp_float_digits10_setting < static_cast<boost::int32_t>(30)) ? static_cast<boost::int32_t>(30) : ((cpp_float_digits10_setting > cpp_float_digits10_limit) ? cpp_float_digits10_limit : cpp_float_digits10_setting));
- static const boost::int32_t cpp_float_digits10_extra = static_cast<boost::int32_t>(((static_cast<boost::int64_t>(cpp_float_digits10) * 15LL) + 50LL) / 100LL);
- static const boost::int32_t cpp_float_max_digits10 = static_cast<boost::int32_t>(cpp_float_digits10 + ((cpp_float_digits10_extra < static_cast<boost::int32_t>(5)) ? static_cast<boost::int32_t>(5) : ((cpp_float_digits10_extra > static_cast<boost::int32_t>(30)) ? static_cast<boost::int32_t>(30) : cpp_float_digits10_extra)));
- static const boost::int64_t cpp_float_max_exp10 = 2776234983093287512;
- static const boost::int64_t cpp_float_min_exp10 = -2776234983093287512;
- static const boost::int64_t cpp_float_max_exp = (cpp_float_max_exp10 / 301LL) * 1000LL;
- static const boost::int64_t cpp_float_min_exp = (cpp_float_min_exp10 / 301LL) * 1000LL;
- static const boost::int32_t mp_elem_digits10 = static_cast<boost::int32_t>(8);
-
- BOOST_STATIC_ASSERT(0 == cpp_float_max_exp10 % mp_elem_digits10);
- BOOST_STATIC_ASSERT(cpp_float_max_exp10 == -cpp_float_min_exp10);
-
-private:
- static const boost::int32_t cpp_float_digits10_num_base = static_cast<boost::int32_t>((cpp_float_max_digits10 / mp_elem_digits10) + (((cpp_float_max_digits10 % mp_elem_digits10) != 0) ? 1 : 0));
- static const boost::int32_t mp_elem_number = static_cast<boost::int32_t>(cpp_float_digits10_num_base + 2);
- static const boost::int32_t mp_elem_mask = static_cast<boost::int32_t>(100000000);
-
-public:
- static const boost::int32_t cpp_float_total_digits10 = mp_elem_number * mp_elem_digits10;
-
-private:
-
- typedef enum enum_fpclass
- {
- mp_finite,
- mp_inf,
- mp_NaN
- }
- t_fpclass;
-
- typedef boost::array<boost::uint32_t, mp_elem_number> array_type;
-
- array_type data;
- boost::int64_t exp;
- bool neg;
- t_fpclass fpclass;
- boost::int32_t prec_elem;
-
- //
- // Special values constructor:
- //
- cpp_float(t_fpclass c) :
- data(),
- exp (static_cast<boost::int64_t>(0)),
- neg (false),
- fpclass (c),
- prec_elem(mp_elem_number) { }
-
- //
- // Static data initializer:
- //
- struct initializer
- {
- initializer()
- {
- cpp_float<Digits10>::nan();
- cpp_float<Digits10>::inf();
- (cpp_float<Digits10>::min)();
- (cpp_float<Digits10>::max)();
- cpp_float<Digits10>::zero();
- cpp_float<Digits10>::one();
- cpp_float<Digits10>::two();
- cpp_float<Digits10>::half();
- cpp_float<Digits10>::double_min();
- cpp_float<Digits10>::double_max();
- cpp_float<Digits10>::long_double_max();
- cpp_float<Digits10>::long_double_min();
- cpp_float<Digits10>::long_long_max();
- cpp_float<Digits10>::long_long_min();
- cpp_float<Digits10>::ulong_long_max();
- cpp_float<Digits10>::eps();
- cpp_float<Digits10>::pow2(0);
- }
- void do_nothing(){}
- };
-
- static initializer init;
-
-public:
- // Constructors
- cpp_float() :
- data(),
- exp (static_cast<boost::int64_t>(0)),
- neg (false),
- fpclass (mp_finite),
- prec_elem(mp_elem_number) { }
-
- cpp_float(const char* s) :
- data(),
- exp (static_cast<boost::int64_t>(0)),
- neg (false),
- fpclass (mp_finite),
- prec_elem(mp_elem_number)
- {
- *this = s;
- }
-
- template<class I>
- cpp_float(I i, typename enable_if<is_unsigned >::type* = 0) :
- data(),
- exp (static_cast<boost::int64_t>(0)),
- neg (false),
- fpclass (mp_finite),
- prec_elem(mp_elem_number)
- {
- from_unsigned_long_long(i);
- }
-
- template <class I>
- cpp_float(I i, typename enable_if<is_signed >::type* = 0) :
- data(),
- exp (static_cast<boost::int64_t>(0)),
- neg (false),
- fpclass (mp_finite),
- prec_elem(mp_elem_number)
- {
- if(i < 0)
- {
- from_unsigned_long_long(-i);
- negate();
- }
- else
- from_unsigned_long_long(i);
- }
-
- cpp_float(const cpp_float& f) :
- data (f.data),
- exp (f.exp),
- neg (f.neg),
- fpclass (f.fpclass),
- prec_elem(f.prec_elem) { }
-
- template <unsigned D>
- cpp_float(const cpp_float<D>& f) :
- exp (f.exp),
- neg (f.neg),
- fpclass (static_cast<enum_fpclass>(static_cast<int>(f.fpclass))),
- prec_elem(mp_elem_number)
- {
- // TODO: this doesn't round!
- std::copy(f.data.begin(), f.data.begin() + std::min(f.prec_elem, prec_elem), data.begin());
- precision(std::min(f.prec_elem, prec_elem));
- }
-
- template <class F>
- cpp_float(const F val, typename enable_if<is_floating_point<F> >::type* = 0):
- data(),
- exp (static_cast<boost::int64_t>(0)),
- neg (false),
- fpclass (mp_finite),
- prec_elem(mp_elem_number)
- {
- *this = val;
- }
-
- cpp_float(const double val, long long exponent);
-
- // Specific special values.
- static const cpp_float& nan()
- {
- static const cpp_float val(mp_NaN);
- init.do_nothing();
- return val;
- }
- static const cpp_float& inf()
- {
- static const cpp_float val(mp_inf);
- init.do_nothing();
- return val;
- }
- static const cpp_float& (max)()
- {
- init.do_nothing();
- static bool init = false;
- static const std::string str_max = std::string("9." + std::string(static_cast<std::size_t>(cpp_float_max_digits10), static_cast<char>('9')))
- + std::string("e+" + boost::lexical_cast<std::string>(cpp_float_max_exp10));
- static cpp_float val_max;
- if(!init)
- {
- init = true;
- val_max = str_max.c_str();
- }
- return val_max;
- }
-
- static const cpp_float& (min)()
- {
- init.do_nothing();
- static bool init = false;
- static cpp_float val_min;
- if(!init)
- {
- init = true;
- val_min = std::string("1.0e" + boost::lexical_cast<std::string>(cpp_float_min_exp10)).c_str();
- }
- return val_min;
- }
- static const cpp_float& zero()
- {
- init.do_nothing();
- static cpp_float val(static_cast<unsigned long long>(0u));
- return val;
- }
- static const cpp_float& one()
- {
- init.do_nothing();
- static cpp_float val(static_cast<unsigned long long>(1u));
- return val;
- }
- static const cpp_float& two()
- {
- init.do_nothing();
- static cpp_float val(static_cast<unsigned long long>(2u));
- return val;
- }
- static const cpp_float& half()
- {
- init.do_nothing();
- static cpp_float val(0.5L);
- return val;
- }
- static const cpp_float& double_min()
- {
- init.do_nothing();
- static cpp_float val(static_cast<long double>((std::numeric_limits<double>::min)()));
- return val;
- }
- static const cpp_float& double_max()
- {
- init.do_nothing();
- static cpp_float val(static_cast<long double>((std::numeric_limits<double>::max)()));
- return val;
- }
- static const cpp_float& long_double_min()
- {
- init.do_nothing();
- static cpp_float val((std::numeric_limits<long double>::min)());
- return val;
- }
- static const cpp_float& long_double_max()
- {
- init.do_nothing();
- static cpp_float val((std::numeric_limits<long double>::max)());
- return val;
- }
- static const cpp_float& long_long_max()
- {
- init.do_nothing();
- static cpp_float val((std::numeric_limits<long long>::max)());
- return val;
- }
- static const cpp_float& long_long_min()
- {
- init.do_nothing();
- static cpp_float val((std::numeric_limits<long long>::min)());
- return val;
- }
- static const cpp_float& ulong_long_max()
- {
- init.do_nothing();
- static cpp_float val((std::numeric_limits<unsigned long long>::max)());
- return val;
- }
- static const cpp_float& eps()
- {
- init.do_nothing();
- static cpp_float val(1.0, 1 - (int)Digits10);
- return val;
- }
-
- // Basic operations.
- cpp_float& operator= (const cpp_float& v)
- {
- data = v.data;
- exp = v.exp;
- neg = v.neg;
- fpclass = v.fpclass;
- prec_elem = v.prec_elem;
- return *this;
- }
- template <unsigned D>
- cpp_float& operator=(const cpp_float<D>& f)
- {
- exp = f.exp;
- neg = f.neg;
- fpclass = static_cast<enum_fpclass>(static_cast<int>(f.fpclass));
- std::copy(f.data.begin(), f.data.begin() + std::min(f.prec_elem, prec_elem), data.begin());
- precision(std::min(f.prec_elem, prec_elem));
- return *this;
- }
- cpp_float& operator= (long long v)
- {
- if(v < 0)
- {
- from_unsigned_long_long(-v);
- negate();
- }
- else
- from_unsigned_long_long(v);
- return *this;
- }
- cpp_float& operator= (unsigned long long v)
- {
- from_unsigned_long_long(v);
- return *this;
- }
- cpp_float& operator= (long double v);
- cpp_float& operator= (const char* v)
- {
- rd_string(v);
- return *this;
- }
-
- cpp_float& operator+=(const cpp_float& v);
- cpp_float& operator-=(const cpp_float& v);
- cpp_float& operator*=(const cpp_float& v);
- cpp_float& operator/=(const cpp_float& v);
-
- cpp_float& add_unsigned_long_long(const unsigned long long n)
- {
- cpp_float t;
- t.from_unsigned_long_long(n);
- return *this += t;
- }
- cpp_float& sub_unsigned_long_long(const unsigned long long n)
- {
- cpp_float t;
- t.from_unsigned_long_long(n);
- return *this -= t;
- }
- cpp_float& mul_unsigned_long_long(const unsigned long long n);
- cpp_float& div_unsigned_long_long(const unsigned long long n);
-
- // Elementary primitives.
- cpp_float& calculate_inv (void);
- cpp_float& calculate_sqrt(void);
- void negate()
- {
- if(!iszero())
- neg = !neg;
- }
-
- // Comparison functions
- bool isnan (void) const { return (fpclass == mp_NaN); }
- bool isinf (void) const { return (fpclass == mp_inf); }
- bool isfinite(void) const { return (fpclass == mp_finite); }
-
- bool iszero (void) const
- {
- return ((fpclass == mp_finite) && (data[0u] == 0u));
- }
- bool isone (void) const;
- bool isint (void) const;
- bool isneg (void) const { return neg; }
-
- // Operators pre-increment and pre-decrement
- cpp_float& operator++(void)
- {
- return *this += one();
- }
- cpp_float& operator--(void)
- {
- return *this -= one();
- }
-
- std::string str(boost::intmax_t digits, std::ios_base::fmtflags f)const;
-
- int compare(const cpp_float& v)const;
- template <class V>
- int compare(const V& v)const
- {
- cpp_float<Digits10> t;
- t = v;
- return compare(t);
- }
-
- void swap(cpp_float& v)
- {
- data.swap(v.data);
- std::swap(exp, v.exp);
- std::swap(neg, v.neg);
- std::swap(fpclass, v.fpclass);
- std::swap(prec_elem, v.prec_elem);
- }
-
- double extract_double (void) const;
- long double extract_long_double (void) const;
- signed long long extract_signed_long_long (void) const;
- unsigned long long extract_unsigned_long_long(void) const;
- void extract_parts (double& mantissa, boost::int64_t& exponent) const;
- cpp_float extract_integer_part (void) const;
- void precision(const boost::int32_t prec_digits)
- {
- if(prec_digits >= cpp_float_digits10)
- {
- prec_elem = mp_elem_number;
- }
- else
- {
- const boost::int32_t elems = static_cast<boost::int32_t>( static_cast<boost::int32_t>( (prec_digits + (mp_elem_digits10 / 2)) / mp_elem_digits10)
- + static_cast<boost::int32_t>(((prec_digits % mp_elem_digits10) != 0) ? 1 : 0));
-
- prec_elem = (std::min)(mp_elem_number, (std::max)(elems, static_cast<boost::int32_t>(2)));
- }
- }
- static cpp_float pow2(long long i);
- long long order()const
- {
- const bool bo_order_is_zero = ((!isfinite()) || (data[0] == static_cast<boost::uint32_t>(0u)));
- //
- // Binary search to find the order of the leading term:
- //
- boost::uint32_t prefix = 0;
-
- if(data[0] >= 100000UL)
- {
- if(data[0] >= 10000000UL)
- {
- if(data[0] >= 100000000UL)
- {
- if(data[0] >= 1000000000UL)
- prefix = 9;
- else
- prefix = 8;
- }
- else
- prefix = 7;
- }
- else
- {
- if(data[0] >= 1000000UL)
- prefix = 6;
- else
- prefix = 5;
- }
- }
- else
- {
- if(data[0] >= 1000UL)
- {
- if(data[0] >= 10000UL)
- prefix = 4;
- else
- prefix = 3;
- }
- else
- {
- if(data[0] >= 100)
- prefix = 2;
- else if(data[0] >= 10)
- prefix = 1;
- }
- }
-
- return (bo_order_is_zero ? static_cast<boost::int64_t>(0)
- : static_cast<boost::int64_t>(exp + prefix));
- }
-
-private:
- static bool data_elem_is_non_zero_predicate(const boost::uint32_t& d) { return (d != static_cast<boost::uint32_t>(0u)); }
- static bool data_elem_is_non_nine_predicate(const boost::uint32_t& d) { return (d != static_cast<boost::uint32_t>(cpp_float::mp_elem_mask - 1)); }
- static bool char_is_nonzero_predicate(const char& c) { return (c != static_cast<char>('0')); }
-
- void from_unsigned_long_long(const unsigned long long u);
-
- int cmp_data(const array_type& vd) const;
-
- static void mul_loop_uv(const boost::uint32_t* const u, const boost::uint32_t* const v, boost::uint32_t* const w, const boost::int32_t p);
- static boost::uint32_t mul_loop_n(boost::uint32_t* const u, boost::uint32_t n, const boost::int32_t p);
- static boost::uint32_t div_loop_n(boost::uint32_t* const u, boost::uint32_t n, const boost::int32_t p);
-
- bool rd_string(const char* const s);
-
- template <unsigned D>
- friend class cpp_float;
-
-};
-
-template <unsigned Digits10>
-typename cpp_float<Digits10>::initializer cpp_float<Digits10>::init;
-
-template <unsigned Digits10>
-const boost::int32_t cpp_float<Digits10>::mp_radix;
-template <unsigned Digits10>
-const boost::int32_t cpp_float<Digits10>::cpp_float_digits;
-template <unsigned Digits10>
-const boost::int32_t cpp_float<Digits10>::cpp_float_digits10_setting;
-template <unsigned Digits10>
-const boost::int32_t cpp_float<Digits10>::cpp_float_digits10_limit;
-template <unsigned Digits10>
-const boost::int32_t cpp_float<Digits10>::cpp_float_digits10;
-template <unsigned Digits10>
-const boost::int32_t cpp_float<Digits10>::cpp_float_digits10_extra;
-template <unsigned Digits10>
-const boost::int32_t cpp_float<Digits10>::cpp_float_max_digits10;
-template <unsigned Digits10>
-const boost::int64_t cpp_float<Digits10>::cpp_float_max_exp;
-template <unsigned Digits10>
-const boost::int64_t cpp_float<Digits10>::cpp_float_min_exp;
-template <unsigned Digits10>
-const boost::int64_t cpp_float<Digits10>::cpp_float_max_exp10;
-template <unsigned Digits10>
-const boost::int64_t cpp_float<Digits10>::cpp_float_min_exp10;
-template <unsigned Digits10>
-const boost::int32_t cpp_float<Digits10>::mp_elem_digits10;
-template <unsigned Digits10>
-const boost::int32_t cpp_float<Digits10>::cpp_float_digits10_num_base;
-template <unsigned Digits10>
-const boost::int32_t cpp_float<Digits10>::mp_elem_number;
-template <unsigned Digits10>
-const boost::int32_t cpp_float<Digits10>::mp_elem_mask;
-
-
-template <unsigned Digits10>
-cpp_float<Digits10>& cpp_float<Digits10>::operator+=(const cpp_float<Digits10>& v)
-{
- if(isnan())
- {
- return *this;
- }
-
- if(isinf())
- {
- if(v.isinf() && (isneg() != v.isneg()))
- {
- *this = nan();
- }
- return *this;
- }
-
- if(iszero())
- {
- return operator=(v);
- }
-
- // Get the offset for the add/sub operation.
- static const boost::int64_t max_delta_exp = static_cast<boost::int64_t>((mp_elem_number - 1) * mp_elem_digits10);
-
- const boost::int64_t ofs_exp = static_cast<boost::int64_t>(exp - v.exp);
-
- // Check if the operation is out of range, requiring special handling.
- if(v.iszero() || (ofs_exp > max_delta_exp))
- {
- // Result is *this unchanged since v is negligible compared to *this.
- return *this;
- }
- else if(ofs_exp < -max_delta_exp)
- {
- // Result is *this = v since *this is negligible compared to v.
- return operator=(v);
- }
-
- // Do the add/sub operation.
-
- typename array_type::iterator p_u = data.begin();
- typename array_type::const_iterator p_v = v.data.begin();
- bool b_copy = false;
- const boost::int32_t ofs = static_cast<boost::int32_t>(static_cast<boost::int32_t>(ofs_exp) / mp_elem_digits10);
- array_type n_data;
-
- if(neg == v.neg)
- {
- // Add v to *this, where the data array of either *this or v
- // might have to be treated with a positive, negative or zero offset.
- // The result is stored in *this. The data are added one element
- // at a time, each element with carry.
- if(ofs >= static_cast<boost::int32_t>(0))
- {
- std::copy(v.data.begin(), v.data.end() - static_cast<size_t>(ofs), n_data.begin() + static_cast<size_t>(ofs));
- std::fill(n_data.begin(), n_data.begin() + static_cast<size_t>(ofs), static_cast<boost::uint32_t>(0u));
- p_v = n_data.begin();
- }
- else
- {
- std::copy(data.begin(), data.end() - static_cast<size_t>(-ofs), n_data.begin() + static_cast<size_t>(-ofs));
- std::fill(n_data.begin(), n_data.begin() + static_cast<size_t>(-ofs), static_cast<boost::uint32_t>(0u));
- p_u = n_data.begin();
- b_copy = true;
- }
-
- // Addition algorithm
- boost::uint32_t carry = static_cast<boost::uint32_t>(0u);
-
- for(boost::int32_t j = static_cast<boost::int32_t>(mp_elem_number - static_cast<boost::int32_t>(1)); j >= static_cast<boost::int32_t>(0); j--)
- {
- boost::uint32_t t = static_cast<boost::uint32_t>(static_cast<boost::uint32_t>(p_u[j] + p_v[j]) + carry);
- carry = t / static_cast<boost::uint32_t>(mp_elem_mask);
- p_u[j] = static_cast<boost::uint32_t>(t - static_cast<boost::uint32_t>(carry * static_cast<boost::uint32_t>(mp_elem_mask)));
- }
-
- if(b_copy)
- {
- data = n_data;
- exp = v.exp;
- }
-
- // There needs to be a carry into the element -1 of the array data
- if(carry != static_cast<boost::uint32_t>(0u))
- {
- std::copy_backward(data.begin(), data.end() - static_cast<std::size_t>(1u), data.end());
- data[0] = carry;
- exp += static_cast<boost::int64_t>(mp_elem_digits10);
- }
- }
- else
- {
- // Subtract v from *this, where the data array of either *this or v
- // might have to be treated with a positive, negative or zero offset.
- if((ofs > static_cast<boost::int32_t>(0))
- || ( (ofs == static_cast<boost::int32_t>(0))
- && (cmp_data(v.data) > static_cast<boost::int32_t>(0)))
- )
- {
- // In this case, |u| > |v| and ofs is positive.
- // Copy the data of v, shifted down to a lower value
- // into the data array m_n. Set the operand pointer p_v
- // to point to the copied, shifted data m_n.
- std::copy(v.data.begin(), v.data.end() - static_cast<size_t>(ofs), n_data.begin() + static_cast<size_t>(ofs));
- std::fill(n_data.begin(), n_data.begin() + static_cast<size_t>(ofs), static_cast<boost::uint32_t>(0u));
- p_v = n_data.begin();
- }
- else
- {
- if(ofs != static_cast<boost::int32_t>(0))
- {
- // In this case, |u| < |v| and ofs is negative.
- // Shift the data of u down to a lower value.
- std::copy_backward(data.begin(), data.end() - static_cast<size_t>(-ofs), data.end());
- std::fill(data.begin(), data.begin() + static_cast<size_t>(-ofs), static_cast<boost::uint32_t>(0u));
- }
-
- // Copy the data of v into the data array n_data.
- // Set the u-pointer p_u to point to m_n and the
- // operand pointer p_v to point to the shifted
- // data m_data.
- n_data = v.data;
- p_u = n_data.begin();
- p_v = data.begin();
- b_copy = true;
- }
-
- boost::int32_t j;
-
- // Subtraction algorithm
- boost::int32_t borrow = static_cast<boost::int32_t>(0);
-
- for(j = static_cast<boost::int32_t>(mp_elem_number - static_cast<boost::int32_t>(1)); j >= static_cast<boost::int32_t>(0); j--)
- {
- boost::int32_t t = static_cast<boost::int32_t>(static_cast<boost::int32_t>( static_cast<boost::int32_t>(p_u[j])
- - static_cast<boost::int32_t>(p_v[j])) - borrow);
-
- // Underflow? Borrow?
- if(t < static_cast<boost::int32_t>(0))
- {
- // Yes, underflow and borrow
- t += static_cast<boost::int32_t>(mp_elem_mask);
- borrow = static_cast<boost::int32_t>(1);
- }
- else
- {
- borrow = static_cast<boost::int32_t>(0);
- }
-
- p_u[j] = static_cast<boost::uint32_t>(static_cast<boost::uint32_t>(t) % static_cast<boost::uint32_t>(mp_elem_mask));
- }
-
- if(b_copy)
- {
- data = n_data;
- exp = v.exp;
- neg = v.neg;
- }
-
- // Is it necessary to justify the data?
- const typename array_type::const_iterator first_nonzero_elem = std::find_if(data.begin(), data.end(), data_elem_is_non_zero_predicate);
-
- if(first_nonzero_elem != data.begin())
- {
- if(first_nonzero_elem == data.end())
- {
- // This result of the subtraction is exactly zero.
- // Reset the sign and the exponent.
- neg = false;
- exp = static_cast<boost::int64_t>(0);
- }
- else
- {
- // Justify the data
- const std::size_t sj = static_cast<std::size_t>(std::distance<typename array_type::const_iterator>(data.begin(), first_nonzero_elem));
-
- std::copy(data.begin() + static_cast<std::size_t>(sj), data.end(), data.begin());
- std::fill(data.end() - sj, data.end(), static_cast<boost::uint32_t>(0u));
-
- exp -= static_cast<boost::int64_t>(sj * static_cast<std::size_t>(mp_elem_digits10));
- }
- }
- }
-
- // Check for underflow.
- if(iszero())
- {
- return *this = zero();
- }
-
- bool overflow = exp >= cpp_float_max_exp10;
- if(exp == cpp_float_max_exp10)
- {
- // Check to see if we really truely have an overflow or not...
- if(isneg())
- {
- cpp_float t(*this);
- t.negate();
- overflow = t.compare((max)()) > 0;
- }
- else
- {
- overflow = compare((max)()) > 0;
- }
- }
-
- // Check for overflow.
- if(overflow)
- {
- const bool b_result_is_neg = neg;
-
- *this = inf();
- if(b_result_is_neg)
- negate();
- }
-
- return *this;
-}
-
-template <unsigned Digits10>
-cpp_float<Digits10>& cpp_float<Digits10>::operator-=(const cpp_float<Digits10>& v)
-{
- // Use *this - v = -(-*this + v).
- negate();
- *this += v;
- negate();
- return *this;
-}
-
-template <unsigned Digits10>
-cpp_float<Digits10>& cpp_float<Digits10>::operator*=(const cpp_float<Digits10>& v)
-{
- // Evaluate the sign of the result.
- const bool b_result_is_neg = (neg != v.neg);
-
- // Artificially set the sign of the result to be positive.
- neg = false;
-
- // Handle special cases like zero, inf and NaN.
- const bool b_u_is_inf = isinf();
- const bool b_v_is_inf = v.isinf();
- const bool b_u_is_zero = iszero();
- const bool b_v_is_zero = v.iszero();
-
- if( (isnan() || v.isnan())
- || (b_u_is_inf && b_v_is_zero)
- || (b_v_is_inf && b_u_is_zero)
- )
- {
- *this = nan();
- return *this;
- }
-
- if(b_u_is_inf || b_v_is_inf)
- {
- *this = inf();
- if(b_result_is_neg)
- negate();
- return *this;
- }
-
- if(b_u_is_zero || b_v_is_zero)
- {
- return *this = zero();
- }
-
- // Check for overflow or underflow.
- const bool u_exp_is_neg = (exp < static_cast<boost::int64_t>(0));
- const bool v_exp_is_neg = (v.exp < static_cast<boost::int64_t>(0));
-
- if(u_exp_is_neg == v_exp_is_neg)
- {
- // Get the unsigned base-10 exponents of *this and v and...
- const boost::int64_t u_exp = ((!u_exp_is_neg) ? exp : static_cast<boost::int64_t>( -exp));
- const boost::int64_t v_exp = ((!v_exp_is_neg) ? v.exp : static_cast<boost::int64_t>(-v.exp));
-
- // Check the range of the upcoming multiplication.
- const bool b_result_is_out_of_range = (v_exp >= static_cast<boost::int64_t>(cpp_float_max_exp10 - u_exp));
-
- if(b_result_is_out_of_range)
- {
- if(u_exp_is_neg)
- {
- *this = zero();
- }
- else
- {
- *this = inf();
- if(b_result_is_neg)
- negate();
- }
- return *this;
- }
- }
-
- // Set the exponent of the result.
- exp += v.exp;
-
- boost::array<boost::uint32_t, static_cast<std::size_t>(mp_elem_number + static_cast<boost::int32_t>(1))> w = {{ 0u }};
-
- mul_loop_uv(data.data(), v.data.data(), w.data(), (std::min)(prec_elem, v.prec_elem));
-
- // Copy the multiplication data into the result.
- // Shift the result and adjust the exponent if necessary.
- if(w[static_cast<std::size_t>(0u)] != static_cast<boost::uint32_t>(0u))
- {
- exp += static_cast<boost::int64_t>(mp_elem_digits10);
-
- std::copy(w.begin(), w.end() - 1u, data.begin());
- }
- else
- {
- std::copy(w.begin() + 1u, w.end(), data.begin());
- }
-
- // Set the sign of the result.
- neg = b_result_is_neg;
-
- return *this;
-}
-
-template <unsigned Digits10>
-cpp_float<Digits10>& cpp_float<Digits10>::operator/=(const cpp_float<Digits10>& v)
-{
- const bool u_and_v_are_finite_and_identical = ( isfinite()
- && (fpclass == v.fpclass)
- && (exp == v.exp)
- && (cmp_data(v.data) == static_cast<boost::int32_t>(0)));
-
- if(u_and_v_are_finite_and_identical)
- {
- if(neg != v.neg)
- {
- *this = one();
- negate();
- }
- else
- *this = one();
- return *this;
- }
- else
- {
- if(iszero())
- {
- if(v.isnan() || v.iszero())
- {
- return *this = v;
- }
- return *this;
- }
- cpp_float t(v);
- t.calculate_inv();
- return operator*=(t);
- }
-}
-
-template <unsigned Digits10>
-cpp_float<Digits10>& cpp_float<Digits10>::mul_unsigned_long_long(const unsigned long long n)
-{
- // Multiply *this with a constant unsigned long long.
-
- // Evaluate the sign of the result.
- const bool b_neg = neg;
-
- // Artificially set the sign of the result to be positive.
- neg = false;
-
- // Handle special cases like zero, inf and NaN.
- const bool b_u_is_inf = isinf();
- const bool b_n_is_zero = (n == static_cast<boost::int32_t>(0));
-
- if(isnan() || (b_u_is_inf && b_n_is_zero))
- {
- return (*this = nan());
- }
-
- if(b_u_is_inf)
- {
- *this = inf();
- if(b_neg)
- negate();
- return *this;
- }
-
- if(iszero() || b_n_is_zero)
- {
- // Multiplication by zero.
- return *this = zero();
- }
-
- if(n >= static_cast<unsigned long long>(mp_elem_mask))
- {
- neg = b_neg;
- cpp_float t;
- t = n;
- return operator*=(t);
- }
-
- if(n == static_cast<unsigned long long>(1u))
- {
- neg = b_neg;
- return *this;
- }
-
- // Set up the multiplication loop.
- const boost::uint32_t nn = static_cast<boost::uint32_t>(n);
- const boost::uint32_t carry = mul_loop_n(data.data(), nn, prec_elem);
-
- // Handle the carry and adjust the exponent.
- if(carry != static_cast<boost::uint32_t>(0u))
- {
- exp += static_cast<boost::int64_t>(mp_elem_digits10);
-
- // Shift the result of the multiplication one element to the right.
- std::copy_backward(data.begin(),
- data.begin() + static_cast<std::size_t>(prec_elem - static_cast<boost::int32_t>(1)),
- data.begin() + static_cast<std::size_t>(prec_elem));
-
- data.front() = static_cast<boost::uint32_t>(carry);
- }
-
- bool overflow = exp >= cpp_float_max_exp10;
- if(exp == cpp_float_max_exp10)
- {
- // Check to see if we really truely have an overflow or not...
- if(isneg())
- {
- cpp_float t(*this);
- t.negate();
- overflow = t.compare((max)()) > 0;
- }
- else
- {
- overflow = compare((max)()) > 0;
- }
- }
-
- if(overflow)
- {
- *this = inf();
- if(b_neg)
- negate();
- return *this;
- }
-
- // Set the sign.
- neg = b_neg;
-
- return *this;
-}
-
-template <unsigned Digits10>
-cpp_float<Digits10>& cpp_float<Digits10>::div_unsigned_long_long(const unsigned long long n)
-{
- // Divide *this by a constant unsigned long long.
-
- // Evaluate the sign of the result.
- const bool b_neg = neg;
-
- // Artificially set the sign of the result to be positive.
- neg = false;
-
- // Handle special cases like zero, inf and NaN.
- if(isnan())
- {
- return *this;
- }
-
- if(isinf())
- {
- *this = inf();
- if(b_neg)
- negate();
- return *this;
- }
-
- if(n == static_cast<unsigned long long>(0u))
- {
- // Divide by 0.
- if(iszero())
- {
- *this = nan();
- return *this;
- }
- else
- {
- *this = inf();
- if(isneg())
- negate();
- return *this;
- }
- }
-
- if(iszero())
- {
- return *this;
- }
-
- if(n >= static_cast<unsigned long long>(mp_elem_mask))
- {
- neg = b_neg;
- cpp_float t;
- t = n;
- return operator/=(t);
- }
-
- const boost::uint32_t nn = static_cast<boost::uint32_t>(n);
-
- if(nn > static_cast<boost::uint32_t>(1u))
- {
- // Do the division loop.
- const boost::uint32_t prev = div_loop_n(data.data(), nn, prec_elem);
-
- // Determine if one leading zero is in the result data.
- if(data[0] == static_cast<boost::uint32_t>(0u))
- {
- // Adjust the exponent
- exp -= static_cast<boost::int64_t>(mp_elem_digits10);
-
- // Shift result of the division one element to the left.
- std::copy(data.begin() + static_cast<std::size_t>(1u),
- data.begin() + static_cast<std::size_t>(prec_elem - static_cast<boost::int32_t>(1)),
- data.begin());
-
- data[prec_elem - static_cast<boost::int32_t>(1)] = static_cast<boost::uint32_t>(static_cast<boost::uint64_t>(prev * static_cast<boost::uint64_t>(mp_elem_mask)) / nn);
- }
- }
-
- // Check for underflow.
- if(iszero())
- {
- return *this = zero();
- }
-
- // Set the sign of the result.
- neg = b_neg;
-
- return *this;
-}
-
-template <unsigned Digits10>
-cpp_float<Digits10>& cpp_float<Digits10>::calculate_inv()
-{
- // Compute the inverse of *this.
- const bool b_neg = neg;
-
- neg = false;
-
- // Handle special cases like zero, inf and NaN.
- if(iszero())
- {
- *this = inf();
- if(b_neg)
- negate();
- return *this;
- }
-
- if(isnan())
- {
- return *this;
- }
-
- if(isinf())
- {
- return *this = zero();
- }
-
- if(isone())
- {
- if(b_neg)
- negate();
- return *this;
- }
-
- // Save the original *this.
- cpp_float<Digits10> x(*this);
-
- // Generate the initial estimate using division.
- // Extract the mantissa and exponent for a "manual"
- // computation of the estimate.
- double dd;
- boost::int64_t ne;
- x.extract_parts(dd, ne);
-
- // Do the inverse estimate using double precision estimates of mantissa and exponent.
- operator=(cpp_float<Digits10>(1.0 / dd, -ne));
-
- // Compute the inverse of *this. Quadratically convergent Newton-Raphson iteration
- // is used. During the iterative steps, the precision of the calculation is limited
- // to the minimum required in order to minimize the run-time.
-
- static const boost::int32_t double_digits10_minus_one = std::numeric_limits<double>::digits10 - 1;
-
- for(boost::int32_t digits = double_digits10_minus_one; digits <= cpp_float_max_digits10; digits *= static_cast<boost::int32_t>(2))
- {
- // Adjust precision of the terms.
- precision(static_cast<boost::int32_t>(digits * static_cast<boost::int32_t>(2)));
- x.precision(static_cast<boost::int32_t>(digits * static_cast<boost::int32_t>(2)));
-
- // Next iteration.
- cpp_float t(*this);
- t *= x;
- t -= two();
- t.negate();
- *this *= t;
- }
-
- neg = b_neg;
-
- prec_elem = mp_elem_number;
-
- return *this;
-}
-
-template <unsigned Digits10>
-cpp_float<Digits10>& cpp_float<Digits10>::calculate_sqrt(void)
-{
- // Compute the square root of *this.
-
- if(isneg() || (!isfinite()))
- {
- *this = nan();
- return *this;
- }
-
- if(iszero() || isone())
- {
- return *this;
- }
-
- // Save the original *this.
- cpp_float<Digits10> x(*this);
-
- // Generate the initial estimate using division.
- // Extract the mantissa and exponent for a "manual"
- // computation of the estimate.
- double dd;
- boost::int64_t ne;
- extract_parts(dd, ne);
-
- // Force the exponent to be an even multiple of two.
- if((ne % static_cast<boost::int64_t>(2)) != static_cast<boost::int64_t>(0))
- {
- ++ne;
- dd /= 10.0;
- }
-
- // Setup the iteration.
- // Estimate the square root using simple manipulations.
- const double sqd = std::sqrt(dd);
-
- *this = cpp_float<Digits10>(sqd, static_cast<boost::int64_t>(ne / static_cast<boost::int64_t>(2)));
-
- // Estimate 1.0 / (2.0 * x0) using simple manipulations.
- cpp_float<Digits10> vi(0.5 / sqd, static_cast<boost::int64_t>(-ne / static_cast<boost::int64_t>(2)));
-
- // Compute the square root of x. Coupled Newton iteration
- // as described in "Pi Unleashed" is used. During the
- // iterative steps, the precision of the calculation is
- // limited to the minimum required in order to minimize
- // the run-time.
- //
- // Book references:
- // http://www.jjj.de/pibook/pibook.html
- // http://www.amazon.com/exec/obidos/tg/detail/-/3540665722/qid=1035535482/sr=8-7/ref=sr_8_7/104-3357872-6059916?v=glance&n=507846
-
- static const boost::uint32_t double_digits10_minus_one = std::numeric_limits<double>::digits10 - 1;
-
- for(boost::int32_t digits = double_digits10_minus_one; digits <= cpp_float_max_digits10; digits *= 2u)
- {
- // Adjust precision of the terms.
- precision(digits * 2);
- vi.precision(digits * 2);
-
- // Next iteration of vi
- cpp_float t(*this);
- t *= vi;
- t.negate();
- t.mul_unsigned_long_long(2u);
- t += one();
- t *= vi;
- vi += t;
-
- // Next iteration of *this
- t = *this;
- t *= *this;
- t.negate();
- t += x;
- t *= vi;
- *this += t;
- }
-
- prec_elem = mp_elem_number;
-
- return *this;
-}
-
-template <unsigned Digits10>
-int cpp_float<Digits10>::cmp_data(const array_type& vd) const
-{
- // Compare the data of *this with those of v.
- // Return +1 for *this > v
- // 0 for *this = v
- // -1 for *this < v
-
- const std::pair<typename array_type::const_iterator, typename array_type::const_iterator> mismatch_pair = std::mismatch(data.begin(), data.end(), vd.begin());
-
- const bool is_equal = ((mismatch_pair.first == data.end()) && (mismatch_pair.second == vd.end()));
-
- if(is_equal)
- {
- return 0;
- }
- else
- {
- return ((*mismatch_pair.first > *mismatch_pair.second) ? 1 : -1);
- }
-}
-
-template <unsigned Digits10>
-int cpp_float<Digits10>::compare(const cpp_float& v) const
-{
- // Compare v with *this.
- // Return +1 for *this > v
- // 0 for *this = v
- // -1 for *this < v
-
- // Handle all non-finite cases.
- if((!isfinite()) || (!v.isfinite()))
- {
- // NaN can never equal NaN. Return an implementation-dependent
- // signed result. Also note that comparison of NaN with NaN
- // using operators greater-than or less-than is undefined.
- if(isnan() || v.isnan()) { return (isnan() ? 1 : -1); }
-
- if(isinf() && v.isinf())
- {
- // Both *this and v are infinite. They are equal if they have the same sign.
- // Otherwise, *this is less than v if and only if *this is negative.
- return ((neg == v.neg) ? 0 : (neg ? -1 : 1));
- }
-
- if(isinf())
- {
- // *this is infinite, but v is finite.
- // So negative infinite *this is less than any finite v.
- // Whereas positive infinite *this is greater than any finite v.
- return (isneg() ? -1 : 1);
- }
- else
- {
- // *this is finite, and v is infinite.
- // So any finite *this is greater than negative infinite v.
- // Whereas any finite *this is less than positive infinite v.
- return (v.neg ? 1 : -1);
- }
- }
-
- // And now handle all *finite* cases.
- if(iszero())
- {
- // The value of *this is zero and v is either zero or non-zero.
- return (v.iszero() ? 0
- : (v.neg ? 1 : -1));
- }
- else if(v.iszero())
- {
- // The value of v is zero and *this is non-zero.
- return (neg ? -1 : 1);
- }
- else
- {
- // Both *this and v are non-zero.
-
- if(neg != v.neg)
- {
- // The signs are different.
- return (neg ? -1 : 1);
- }
- else if(exp != v.exp)
- {
- // The signs are the same and the exponents are different.
- const int val_cmp_exp = ((exp < v.exp) ? 1 : -1);
-
- return (neg ? val_cmp_exp : -val_cmp_exp);
- }
- else
- {
- // The signs are the same and the exponents are the same.
- // Compare the data.
- const int val_cmp_data = cmp_data(v.data);
-
- return ((!neg) ? val_cmp_data : -val_cmp_data);
- }
- }
-}
-
-template <unsigned Digits10>
-bool cpp_float<Digits10>::isone() const
-{
- // Check if the value of *this is identically 1 or very close to 1.
-
- const bool not_negative_and_is_finite = ((!neg) && isfinite());
-
- if(not_negative_and_is_finite)
- {
- if((data[0u] == static_cast<boost::uint32_t>(1u)) && (exp == static_cast<boost::int64_t>(0)))
- {
- const typename array_type::const_iterator it_non_zero = std::find_if(data.begin(), data.end(), data_elem_is_non_zero_predicate);
- return (it_non_zero == data.end());
- }
- else if((data[0u] == static_cast<boost::uint32_t>(mp_elem_mask - 1)) && (exp == static_cast<boost::int64_t>(-mp_elem_digits10)))
- {
- const typename array_type::const_iterator it_non_nine = std::find_if(data.begin(), data.end(), data_elem_is_non_nine_predicate);
- return (it_non_nine == data.end());
- }
- }
-
- return false;
-}
-
-template <unsigned Digits10>
-bool cpp_float<Digits10>::isint() const
-{
- if(fpclass != mp_finite) { return false; }
-
- if(iszero()) { return true; }
-
- if(exp < static_cast<boost::int64_t>(0)) { return false; } // |*this| < 1.
-
- const typename array_type::size_type offset_decimal_part = static_cast<typename array_type::size_type>(exp / mp_elem_digits10) + 1u;
-
- if(offset_decimal_part >= static_cast<typename array_type::size_type>(mp_elem_number))
- {
- // The number is too large to resolve the integer part.
- // It considered to be a pure integer.
- return true;
- }
-
- typename array_type::const_iterator it_non_zero = std::find_if(data.begin() + offset_decimal_part, data.end(), data_elem_is_non_zero_predicate);
-
- return (it_non_zero == data.end());
-}
-
-template <unsigned Digits10>
-void cpp_float<Digits10>::extract_parts(double& mantissa, boost::int64_t& exponent) const
-{
- // Extract the approximate parts mantissa and base-10 exponent from the input cpp_float<Digits10> value x.
-
- // Extracts the mantissa and exponent.
- exponent = exp;
-
- boost::uint32_t p10 = static_cast<boost::uint32_t>(1u);
- boost::uint32_t test = data[0u];
-
- for(;;)
- {
- test /= static_cast<boost::uint32_t>(10u);
-
- if(test == static_cast<boost::uint32_t>(0u))
- {
- break;
- }
-
- p10 *= static_cast<boost::uint32_t>(10u);
- ++exponent;
- }
-
- mantissa = static_cast<double>(data[0])
- + (static_cast<double>(data[1]) / static_cast<double>(mp_elem_mask))
- + ((static_cast<double>(data[2]) / static_cast<double>(mp_elem_mask)) / static_cast<double>(mp_elem_mask));
-
- mantissa /= static_cast<double>(p10);
-
- if(neg) { mantissa = -mantissa; }
-}
-
-template <unsigned Digits10>
-double cpp_float<Digits10>::extract_double(void) const
-{
- // Returns the double conversion of a cpp_float<Digits10>.
-
- // Check for non-normal cpp_float<Digits10>.
- if(!isfinite())
- {
- if(isnan())
- {
- return std::numeric_limits<double>::quiet_NaN();
- }
- else
- {
- return ((!neg) ? std::numeric_limits<double>::infinity()
- : -std::numeric_limits<double>::infinity());
- }
- }
-
- cpp_float<Digits10> xx(*this);
- if(xx.isneg())
- xx.negate();
-
- // Check for zero cpp_float<Digits10>.
- if(iszero() || (xx.compare(double_min()) < 0))
- {
- return 0.0;
- }
-
- // Check if cpp_float<Digits10> exceeds the maximum of double.
- if(xx.compare(double_max()) > 0)
- {
- return ((!neg) ? std::numeric_limits<double>::infinity()
- : -std::numeric_limits<double>::infinity());
- }
-
- std::stringstream ss;
-
- ss << str(std::numeric_limits<double>::digits10 + (2 + 1), std::ios_base::scientific);
-
- double d;
- ss >> d;
-
- return d;
-}
-
-template <unsigned Digits10>
-long double cpp_float<Digits10>::extract_long_double(void) const
-{
- // Returns the long double conversion of a cpp_float<Digits10>.
-
- // Check for non-normal cpp_float<Digits10>.
- if(!isfinite())
- {
- if(isnan())
- {
- return std::numeric_limits<long double>::quiet_NaN();
- }
- else
- {
- return ((!neg) ? std::numeric_limits<long double>::infinity()
- : -std::numeric_limits<long double>::infinity());
- }
- }
-
- cpp_float<Digits10> xx(*this);
- if(xx.isneg())
- xx.negate();
-
- // Check for zero cpp_float<Digits10>.
- if(iszero() || (xx.compare(long_double_min()) < 0))
- {
- return static_cast<long double>(0.0);
- }
-
- // Check if cpp_float<Digits10> exceeds the maximum of double.
- if(xx.compare(long_double_max()) > 0)
- {
- return ((!neg) ? std::numeric_limits<long double>::infinity()
- : -std::numeric_limits<long double>::infinity());
- }
-
- std::stringstream ss;
-
- ss << str(std::numeric_limits<long double>::digits10 + (2 + 1), std::ios_base::scientific);
-
- long double ld;
- ss >> ld;
-
- return ld;
-}
-
-template <unsigned Digits10>
-signed long long cpp_float<Digits10>::extract_signed_long_long(void) const
-{
- // Extracts a signed long long from *this.
- // If (x > maximum of signed long long) or (x < minimum of signed long long),
- // then the maximum or minimum of signed long long is returned accordingly.
-
- if(exp < static_cast<boost::int64_t>(0))
- {
- return static_cast<signed long long>(0);
- }
-
- const bool b_neg = isneg();
-
- unsigned long long val;
-
- if((!b_neg) && (compare(long_long_max()) > 0))
- {
- return (std::numeric_limits<signed long long>::max)();
- }
- else if(b_neg && (compare(long_long_min()) < 0))
- {
- return (std::numeric_limits<signed long long>::min)();
- }
- else
- {
- // Extract the data into an unsigned long long value.
- cpp_float<Digits10> xn(extract_integer_part());
- if(xn.isneg())
- xn.negate();
-
- val = static_cast<unsigned long long>(xn.data[0]);
-
- const boost::int32_t imax = (std::min)(static_cast<boost::int32_t>(static_cast<boost::int32_t>(xn.exp) / mp_elem_digits10), static_cast<boost::int32_t>(mp_elem_number - static_cast<boost::int32_t>(1)));
-
- for(boost::int32_t i = static_cast<boost::int32_t>(1); i <= imax; i++)
- {
- val *= static_cast<unsigned long long>(mp_elem_mask);
- val += static_cast<unsigned long long>(xn.data[i]);
- }
- }
-
- return ((!b_neg) ? static_cast<signed long long>(val) : static_cast<signed long long>(-static_cast<signed long long>(val)));
-}
-
-template <unsigned Digits10>
-unsigned long long cpp_float<Digits10>::extract_unsigned_long_long(void) const
-{
- // Extracts an unsigned long long from *this.
- // If x exceeds the maximum of unsigned long long,
- // then the maximum of unsigned long long is returned.
- // If x is negative, then the unsigned long long cast of
- // the signed long long extracted value is returned.
-
- if(isneg())
- {
- return static_cast<unsigned long long>(extract_signed_long_long());
- }
-
- if(exp < static_cast<boost::int64_t>(0))
- {
- return static_cast<unsigned long long>(0u);
- }
-
- const cpp_float<Digits10> xn(extract_integer_part());
-
- unsigned long long val;
-
- if(xn.compare(ulong_long_max()) > 0)
- {
- return (std::numeric_limits<unsigned long long>::max)();
- }
- else
- {
- // Extract the data into an unsigned long long value.
- val = static_cast<unsigned long long>(xn.data[0]);
-
- const boost::int32_t imax = (std::min)(static_cast<boost::int32_t>(static_cast<boost::int32_t>(xn.exp) / mp_elem_digits10), static_cast<boost::int32_t>(mp_elem_number - static_cast<boost::int32_t>(1)));
-
- for(boost::int32_t i = static_cast<boost::int32_t>(1); i <= imax; i++)
- {
- val *= static_cast<unsigned long long>(mp_elem_mask);
- val += static_cast<unsigned long long>(xn.data[i]);
- }
- }
-
- return val;
-}
-
-template <unsigned Digits10>
-cpp_float<Digits10> cpp_float<Digits10>::extract_integer_part(void) const
-{
- // Compute the signed integer part of x.
-
- if(!isfinite())
- {
- return *this;
- }
-
- if(exp < static_cast<boost::int64_t>(0))
- {
- // The absolute value of the number is smaller than 1.
- // Thus the integer part is zero.
- return zero();
- }
- else if(exp >= Digits10 - 1)
- {
- // The number is too large to resolve the integer part.
- // Thus it is already a pure integer part.
- return *this;
- }
-
- // Make a local copy.
- cpp_float<Digits10> x = *this;
-
- // Clear out the decimal portion
- const size_t first_clear = (static_cast<size_t>(x.exp) / static_cast<size_t>(mp_elem_digits10)) + 1u;
- const size_t last_clear = static_cast<size_t>(mp_elem_number);
-
- std::fill(x.data.begin() + first_clear, x.data.begin() + last_clear, static_cast<boost::uint32_t>(0u));
-
- return x;
-}
-
-template <unsigned Digits10>
-std::string cpp_float<Digits10>::str(boost::intmax_t number_of_digits, std::ios_base::fmtflags f) const
-{
- if(this->isinf())
- {
- if(this->isneg())
- return "-inf";
- else if(f & std::ios_base::showpos)
- return "+inf";
- else
- return "inf";
- }
- else if(this->isnan())
- {
- return "nan";
- }
-
- std::string str;
- boost::intmax_t org_digits(number_of_digits);
- boost::int64_t my_exp = order();
- if(number_of_digits == 0)
- number_of_digits = cpp_float_max_digits10;
- if(f & std::ios_base::fixed)
- {
- number_of_digits += my_exp + 1;
- }
- else if(f & std::ios_base::scientific)
- ++number_of_digits;
- // Determine the number of elements needed to provide the requested digits from cpp_float<Digits10>.
- const std::size_t number_of_elements = (std::min)(static_cast<std::size_t>((number_of_digits / static_cast<std::size_t>(mp_elem_digits10)) + 2u),
- static_cast<std::size_t>(mp_elem_number));
-
- // Extract the remaining digits from cpp_float<Digits10> after the decimal point.
- str = boost::lexical_cast<std::string>(data[0]);
-
- // Extract all of the digits from cpp_float<Digits10>, beginning with the first data element.
- for(std::size_t i = static_cast<std::size_t>(1u); i < number_of_elements; i++)
- {
- std::stringstream ss;
-
- ss << std::setw(static_cast<std::streamsize>(mp_elem_digits10))
- << std::setfill(static_cast<char>('0'))
- << data[i];
-
- str += ss.str();
- }
- bool have_leading_zeros = false;
- if(number_of_digits == 0)
- {
- // We only get here if the output format is "fixed" and we just need to
- // round the first non-zero digit.
- number_of_digits -= my_exp + 1; // reset to original value
- str.insert(0, std::string::size_type(number_of_digits), '0');
- have_leading_zeros = true;
- }
- if(number_of_digits < 0)
- {
- str = "0";
- if(isneg())
- str.insert(0, 1, '-');
- boost::multiprecision::detail::format_float_string(str, 0, number_of_digits - my_exp - 1, f, this->iszero());
- return str;
- }
- else
- {
- // Cut the output to the size of the precision.
- if(str.length() > static_cast<std::string::size_type>(number_of_digits))
- {
- // Get the digit after the last needed digit for rounding
- const boost::uint32_t round = static_cast<boost::uint32_t>(static_cast<boost::uint32_t>(str[static_cast<std::string::size_type>(number_of_digits)]) - static_cast<boost::uint32_t>('0'));
-
- bool need_round_up = round >= 5u;
-
- if(round == 5u)
- {
- const boost::uint32_t ix = static_cast<boost::uint32_t>(static_cast<boost::uint32_t>(str[static_cast<std::string::size_type>(number_of_digits - 1)]) - static_cast<boost::uint32_t>('0'));
- if((ix & 1u) == 0)
- {
- // We have an even digit followed by a 5, so we might not actually need to round up
- // if all the remaining digits are zero:
- if(str.find_first_not_of('0', static_cast<std::string::size_type>(number_of_digits + 1)) == std::string::npos)
- {
- bool all_zeros = true;
- // No none-zero trailing digits in the string, now check whatever parts we didn't convert to the string:
- for(std::size_t i = number_of_elements; i < data.size(); i++)
- {
- if(data[i])
- {
- all_zeros = false;
- break;
- }
- }
- if(all_zeros)
- need_round_up = false; // tie break - round to even.
- }
- }
- }
-
- // Truncate the string
- str.erase(static_cast<std::string::size_type>(number_of_digits));
-
- if(need_round_up)
- {
- std::size_t ix = static_cast<std::size_t>(str.length() - 1u);
-
- // Every trailing 9 must be rounded up
- while(ix && (static_cast<boost::int32_t>(str.at(ix)) - static_cast<boost::int32_t>('0') == static_cast<boost::int32_t>(9)))
- {
- str.at(ix) = static_cast<char>('0');
- --ix;
- }
-
- if(!ix)
- {
- // There were nothing but trailing nines.
- if(static_cast<boost::int32_t>(static_cast<boost::int32_t>(str.at(ix)) - static_cast<boost::int32_t>(0x30)) == static_cast<boost::int32_t>(9))
- {
- // Increment up to the next order and adjust exponent.
- str.at(ix) = static_cast<char>('1');
- ++my_exp;
- }
- else
- {
- // Round up this digit.
- ++str.at(ix);
- }
- }
- else
- {
- // Round up the last digit.
- ++str[ix];
- }
- }
- }
- }
- if(have_leading_zeros)
- {
- // We need to take the zeros back out again, and correct the exponent
- // if we rounded up:
- if(str[std::string::size_type(number_of_digits - 1)] != '0')
- {
- ++my_exp;
- str.erase(0, std::string::size_type(number_of_digits - 1));
- }
- else
- str.erase(0, std::string::size_type(number_of_digits));
- }
- if(isneg())
- str.insert(0, 1, '-');
- boost::multiprecision::detail::format_float_string(str, my_exp, org_digits, f, this->iszero());
- return str;
-}
-
-template <unsigned Digits10>
-bool cpp_float<Digits10>::rd_string(const char* const s)
-{
- std::string str(s);
-
- // Get a possible exponent and remove it.
- exp = static_cast<boost::int64_t>(0);
-
- std::size_t pos;
-
- if( ((pos = str.find('e')) != std::string::npos)
- || ((pos = str.find('E')) != std::string::npos)
- )
- {
- // Remove the exponent part from the string.
- exp = boost::lexical_cast<boost::int64_t>(static_cast<const char*>(str.c_str() + (pos + 1u)));
- str = str.substr(static_cast<std::size_t>(0u), pos);
- }
-
- // Get a possible +/- sign and remove it.
- neg = false;
-
- if(str.size())
- {
- if(str[0] == '-')
- {
- neg = true;
- str.erase(0, 1);
- }
- else if(str[0] == '+')
- {
- str.erase(0, 1);
- }
- }
- //
- // Special cases for infinities and NaN's:
- //
- if((str == "inf") || (str == "INF") || (str == "infinity") || (str == "INFINITY"))
- {
- if(neg)
- {
- *this = this->inf();
- this->negate();
- }
- else
- *this = this->inf();
- return true;
- }
- if((str.size() >= 3) && ((str.substr(0, 3) == "nan") || (str.substr(0, 3) == "NAN")))
- {
- *this = this->nan();
- return true;
- }
-
-
- // Remove leading zeros for all input types.
- const std::string::iterator fwd_it_leading_zero = std::find_if(str.begin(), str.end(), char_is_nonzero_predicate);
-
- if(fwd_it_leading_zero != str.begin())
- {
- if(fwd_it_leading_zero == str.end())
- {
- // The string contains nothing but leading zeros.
- // This string represents zero.
- operator=(zero());
- return true;
- }
- else
- {
- str.erase(str.begin(), fwd_it_leading_zero);
- }
- }
-
- // Put the input string into the standard cpp_float<Digits10> input form
- // aaa.bbbbE+/-n, where aa has 1...mp_elem_digits10, bbbb has an
- // even multiple of mp_elem_digits10 which are possibly zero padded
- // on the right-end, and n is a signed 32-bit integer which is an
- // even multiple of mp_elem_digits10.
-
- // Find a possible decimal point.
- pos = str.find(static_cast<char>('.'));
-
- if(pos != std::string::npos)
- {
- // Remove all trailing insignificant zeros.
- const std::string::const_reverse_iterator rit_non_zero = std::find_if(str.rbegin(), str.rend(), char_is_nonzero_predicate);
-
- if(rit_non_zero != str.rbegin())
- {
- const std::string::size_type ofs = str.length() - std::distance<std::string::const_reverse_iterator>(str.rbegin(), rit_non_zero);
- str.erase(str.begin() + ofs, str.end());
- }
-
- // Check if the input is identically zero.
- if(str == std::string("."))
- {
- operator=(zero());
- return true;
- }
-
- // Remove leading significant zeros just after the decimal point
- // and adjust the exponent accordingly.
- // Note that the while-loop operates only on strings of the form ".000abcd..."
- // and peels away the zeros just after the decimal point.
- if(str.at(static_cast<std::size_t>(0u)) == static_cast<char>('.'))
- {
- const std::string::iterator it_non_zero = std::find_if(str.begin() + 1u, str.end(), char_is_nonzero_predicate);
-
- std::size_t delta_exp = static_cast<std::size_t>(0u);
-
- if(str.at(static_cast<std::size_t>(1u)) == static_cast<char>('0'))
- {
- delta_exp = std::distance<std::string::const_iterator>(str.begin() + 1u, it_non_zero);
- }
-
- // Bring one single digit into the mantissa and adjust exponent accordingly.
- str.erase(str.begin(), it_non_zero);
- str.insert(static_cast<std::size_t>(1u), ".");
- exp -= static_cast<boost::int64_t>(delta_exp + 1u);
- }
- }
- else
- {
- // Input string has no decimal point: Append decimal point.
- str.append(".");
- }
-
- // Shift the decimal point such that the exponent is an even multiple of mp_elem_digits10.
- std::size_t n_shift = static_cast<std::size_t>(0u);
- const std::size_t n_exp_rem = static_cast<std::size_t>(exp % static_cast<boost::int64_t>(mp_elem_digits10));
-
- if((exp % static_cast<boost::int64_t>(mp_elem_digits10)) != static_cast<boost::int64_t>(0))
- {
- n_shift = ((exp < static_cast<boost::int64_t>(0))
- ? static_cast<std::size_t>(n_exp_rem + static_cast<std::size_t>(mp_elem_digits10))
- : static_cast<std::size_t>(n_exp_rem));
- }
-
- // Make sure that there are enough digits for the decimal point shift.
- pos = str.find(static_cast<char>('.'));
-
- std::size_t pos_plus_one = static_cast<std::size_t>(pos + 1u);
-
- if((str.length() - pos_plus_one) < n_shift)
- {
- const std::size_t sz = static_cast<std::size_t>(n_shift - (str.length() - pos_plus_one));
-
- str.append(std::string(sz, static_cast<char>('0')));
- }
-
- // Do the decimal point shift.
- if(n_shift != static_cast<std::size_t>(0u))
- {
- str.insert(static_cast<std::size_t>(pos_plus_one + n_shift), ".");
-
- str.erase(pos, static_cast<std::size_t>(1u));
-
- exp -= static_cast<boost::int64_t>(n_shift);
- }
-
- // Cut the size of the mantissa to <= mp_elem_digits10.
- pos = str.find(static_cast<char>('.'));
- pos_plus_one = static_cast<std::size_t>(pos + 1u);
-
- if(pos > static_cast<std::size_t>(mp_elem_digits10))
- {
- const boost::int32_t n_pos = static_cast<boost::int32_t>(pos);
- const boost::int32_t n_rem_is_zero = ((static_cast<boost::int32_t>(n_pos % mp_elem_digits10) == static_cast<boost::int32_t>(0)) ? static_cast<boost::int32_t>(1) : static_cast<boost::int32_t>(0));
- const boost::int32_t n = static_cast<boost::int32_t>(static_cast<boost::int32_t>(n_pos / mp_elem_digits10) - n_rem_is_zero);
-
- str.insert(static_cast<std::size_t>(static_cast<boost::int32_t>(n_pos - static_cast<boost::int32_t>(n * mp_elem_digits10))), ".");
-
- str.erase(pos_plus_one, static_cast<std::size_t>(1u));
-
- exp += static_cast<boost::int64_t>(static_cast<boost::int64_t>(n) * static_cast<boost::int64_t>(mp_elem_digits10));
- }
-
- // Pad the decimal part such that its value is an even
- // multiple of mp_elem_digits10.
- pos = str.find(static_cast<char>('.'));
- pos_plus_one = static_cast<std::size_t>(pos + 1u);
-
- const boost::int32_t n_dec = static_cast<boost::int32_t>(static_cast<boost::int32_t>(str.length() - 1u) - static_cast<boost::int32_t>(pos));
- const boost::int32_t n_rem = static_cast<boost::int32_t>(n_dec % mp_elem_digits10);
- boost::int32_t n_cnt = ((n_rem != static_cast<boost::int32_t>(0)) ? static_cast<boost::int32_t>(mp_elem_digits10 - n_rem)
- : static_cast<boost::int32_t>(0));
-
- if(n_cnt != static_cast<boost::int32_t>(0))
- {
- str.append(static_cast<std::size_t>(n_cnt), static_cast<char>('0'));
- }
-
- // Truncate decimal part if it is too long.
- const std::size_t max_dec = static_cast<std::size_t>((mp_elem_number - 1) * mp_elem_digits10);
-
- if(static_cast<std::size_t>(str.length() - pos) > max_dec)
- {
- str = str.substr(static_cast<std::size_t>(0u),
- static_cast<std::size_t>(pos_plus_one + max_dec));
- }
-
- // Now the input string has the standard cpp_float<Digits10> input form.
- // (See the comment above.)
-
- // Set all the data elements to 0.
- std::fill(data.begin(), data.end(), static_cast<boost::uint32_t>(0u));
-
- // Extract the data.
-
- // First get the digits to the left of the decimal point...
- data[0u] = boost::lexical_cast<boost::uint32_t>(str.substr(static_cast<std::size_t>(0u), pos));
-
- // ...then get the remaining digits to the right of the decimal point.
- const std::string::size_type i_end = ((str.length() - pos_plus_one) / static_cast<std::string::size_type>(mp_elem_digits10));
-
- for(std::string::size_type i = static_cast<std::string::size_type>(0u); i < i_end; i++)
- {
- const std::string::const_iterator it = str.begin()
- + pos_plus_one
- + (i * static_cast<std::string::size_type>(mp_elem_digits10));
-
- data[i + 1u] = boost::lexical_cast<boost::uint32_t>(std::string(it, it + static_cast<std::string::size_type>(mp_elem_digits10)));
- }
-
- // Check for overflow...
- if(exp > cpp_float_max_exp10)
- {
- const bool b_result_is_neg = neg;
-
- *this = inf();
- if(b_result_is_neg)
- negate();
- }
-
- // ...and check for underflow.
- if(exp <= cpp_float_min_exp10)
- {
- if(exp == cpp_float_min_exp10)
- {
- // Check for identity with the minimum value.
- cpp_float<Digits10> test = *this;
-
- test.exp = static_cast<boost::int64_t>(0);
-
- if(test.isone())
- {
- *this = zero();
- }
- }
- else
- {
- *this = zero();
- }
- }
-
- return true;
-}
-
-template <unsigned Digits10>
-cpp_float<Digits10>::cpp_float(const double mantissa, const long long exponent)
- : data (),
- exp (static_cast<boost::int64_t>(0)),
- neg (false),
- fpclass (mp_finite),
- prec_elem(mp_elem_number)
-{
- // Create an cpp_float<Digits10> from mantissa and exponent.
- // This ctor does not maintain the full precision of double.
-
- const bool mantissa_is_iszero = (::fabs(mantissa) < ((std::numeric_limits<double>::min)() * (1.0 + std::numeric_limits<double>::epsilon())));
-
- if(mantissa_is_iszero)
- {
- std::fill(data.begin(), data.end(), static_cast<boost::uint32_t>(0u));
- return;
- }
-
- const bool b_neg = (mantissa < 0.0);
-
- double d = ((!b_neg) ? mantissa : -mantissa);
- boost::int64_t e = exponent;
-
- while(d > 10.0) { d /= 10.0; ++e; }
- while(d < 1.0) { d *= 10.0; --e; }
-
- boost::int32_t shift = static_cast<boost::int32_t>(e % static_cast<boost::int32_t>(mp_elem_digits10));
-
- while(static_cast<boost::int32_t>(shift-- % mp_elem_digits10) != static_cast<boost::int32_t>(0))
- {
- d *= 10.0;
- --e;
- }
-
- exp = e;
- neg = b_neg;
-
- std::fill(data.begin(), data.end(), static_cast<boost::uint32_t>(0u));
-
- static const boost::int32_t digit_ratio = static_cast<boost::int32_t>(static_cast<boost::int32_t>(std::numeric_limits<double>::digits10) / static_cast<boost::int32_t>(mp_elem_digits10));
- static const boost::int32_t digit_loops = static_cast<boost::int32_t>(digit_ratio + static_cast<boost::int32_t>(2));
-
- for(boost::int32_t i = static_cast<boost::int32_t>(0); i < digit_loops; i++)
- {
- boost::uint32_t n = static_cast<boost::uint32_t>(static_cast<boost::uint64_t>(d));
- data[i] = static_cast<boost::uint32_t>(n);
- d -= static_cast<double>(n);
- d *= static_cast<double>(mp_elem_mask);
- }
-}
-
-template <unsigned Digits10>
-cpp_float<Digits10>& cpp_float<Digits10>::operator = (long double a)
-{
- // Christopher Kormanyos's original code used a cast to long long here, but that fails
- // when long double has more digits than a long long.
- using std::frexp;
- using std::ldexp;
- using std::floor;
-
- if (a == 0) {
- return *this = zero();
- }
-
- if (a == 1) {
- return *this = one();
- }
-
- if((boost::math::isinf)(a))
- {
- return *this = inf();
- }
- if((boost::math::isnan)(a))
- return *this = nan();
-
- int e;
- long double f, term;
- *this = zero();
-
- f = frexp(a, &e);
-
- static const int shift = std::numeric_limits<int>::digits - 1;
-
- while(f)
- {
- // extract int sized bits from f:
- f = ldexp(f, shift);
- term = floor(f);
- e -= shift;
- *this *= pow2(shift);
- if(term > 0)
- add_unsigned_long_long(static_cast<unsigned>(term));
- else
- sub_unsigned_long_long(static_cast<unsigned>(-term));
- f -= term;
- }
- if(e != 0)
- *this *= pow2(e);
- return *this;
-}
-
-template <unsigned Digits10>
-void cpp_float<Digits10>::from_unsigned_long_long(const unsigned long long u)
-{
- std::fill(data.begin(), data.end(), static_cast<boost::uint32_t>(0u));
-
- exp = static_cast<boost::int64_t>(0);
- neg = false;
- fpclass = mp_finite;
- prec_elem = mp_elem_number;
-
- std::size_t i =static_cast<std::size_t>(0u);
-
- unsigned long long uu = u;
-
- boost::uint32_t temp[(std::numeric_limits<unsigned long long>::digits10 / static_cast<int>(mp_elem_digits10)) + 3] = { static_cast<boost::uint32_t>(0u) };
-
- while(uu != static_cast<unsigned long long>(0u))
- {
- temp[i] = static_cast<boost::uint32_t>(uu % static_cast<unsigned long long>(mp_elem_mask));
- uu = static_cast<unsigned long long>(uu / static_cast<unsigned long long>(mp_elem_mask));
- ++i;
- }
-
- if(i > static_cast<std::size_t>(1u))
- {
- exp += static_cast<boost::int64_t>((i - 1u) * static_cast<std::size_t>(mp_elem_digits10));
- }
-
- std::reverse(temp, temp + i);
- std::copy(temp, temp + (std::min)(i, static_cast<std::size_t>(mp_elem_number)), data.begin());
-}
-
-template <unsigned Digits10>
-void cpp_float<Digits10>::mul_loop_uv(const boost::uint32_t* const u, const boost::uint32_t* const v, boost::uint32_t* const w, const boost::int32_t p)
-{
- boost::uint64_t carry = static_cast<boost::uint64_t>(0u);
-
- for(boost::int32_t j = static_cast<boost::int32_t>(p - 1u); j >= static_cast<boost::int32_t>(0); j--)
- {
- boost::uint64_t sum = carry;
-
- for(boost::int32_t i = j; i >= static_cast<boost::int32_t>(0); i--)
- {
- sum += static_cast<boost::uint64_t>(u[i] * static_cast<boost::uint64_t>(v[j - i]));
- }
-
- w[j + 1] = static_cast<boost::uint32_t>(sum % static_cast<boost::uint32_t>(mp_elem_mask));
- carry = static_cast<boost::uint64_t>(sum / static_cast<boost::uint32_t>(mp_elem_mask));
- }
-
- w[0u] = static_cast<boost::uint32_t>(carry);
-}
-
-template <unsigned Digits10>
-boost::uint32_t cpp_float<Digits10>::mul_loop_n(boost::uint32_t* const u, boost::uint32_t n, const boost::int32_t p)
-{
- boost::uint64_t carry = static_cast<boost::uint64_t>(0u);
-
- // Multiplication loop.
- for(boost::int32_t j = p - 1; j >= static_cast<boost::int32_t>(0); j--)
- {
- const boost::uint64_t t = static_cast<boost::uint64_t>(carry + static_cast<boost::uint64_t>(u[j] * static_cast<boost::uint64_t>(n)));
- carry = static_cast<boost::uint64_t>(t / static_cast<boost::uint32_t>(mp_elem_mask));
- u[j] = static_cast<boost::uint32_t>(t - static_cast<boost::uint64_t>(static_cast<boost::uint32_t>(mp_elem_mask) * static_cast<boost::uint64_t>(carry)));
- }
-
- return static_cast<boost::uint32_t>(carry);
-}
-
-template <unsigned Digits10>
-boost::uint32_t cpp_float<Digits10>::div_loop_n(boost::uint32_t* const u, boost::uint32_t n, const boost::int32_t p)
-{
- boost::uint64_t prev = static_cast<boost::uint64_t>(0u);
-
- for(boost::int32_t j = static_cast<boost::int32_t>(0); j < p; j++)
- {
- const boost::uint64_t t = static_cast<boost::uint64_t>(u[j] + static_cast<boost::uint64_t>(prev * static_cast<boost::uint32_t>(mp_elem_mask)));
- u[j] = static_cast<boost::uint32_t>(t / n);
- prev = static_cast<boost::uint64_t>(t - static_cast<boost::uint64_t>(n * static_cast<boost::uint64_t>(u[j])));
- }
-
- return static_cast<boost::uint32_t>(prev);
-}
-
-template <unsigned Digits10>
-cpp_float<Digits10> cpp_float<Digits10>::pow2(const long long p)
-{
- // Create a static const table of p^2 for -128 , 255u> p2_data =
- {{
- cpp_float("5.877471754111437539843682686111228389093327783860437607543758531392086297273635864257812500000000000e-39"),
- cpp_float("1.175494350822287507968736537222245677818665556772087521508751706278417259454727172851562500000000000e-38"),
- cpp_float("2.350988701644575015937473074444491355637331113544175043017503412556834518909454345703125000000000000e-38"),
- cpp_float("4.701977403289150031874946148888982711274662227088350086035006825113669037818908691406250000000000000e-38"),
- cpp_float("9.403954806578300063749892297777965422549324454176700172070013650227338075637817382812500000000000000e-38"),
- cpp_float("1.880790961315660012749978459555593084509864890835340034414002730045467615127563476562500000000000000e-37"),
- cpp_float("3.761581922631320025499956919111186169019729781670680068828005460090935230255126953125000000000000000e-37"),
- cpp_float("7.523163845262640050999913838222372338039459563341360137656010920181870460510253906250000000000000000e-37"),
- cpp_float("1.504632769052528010199982767644474467607891912668272027531202184036374092102050781250000000000000000e-36"),
- cpp_float("3.009265538105056020399965535288948935215783825336544055062404368072748184204101562500000000000000000e-36"),
- cpp_float("6.018531076210112040799931070577897870431567650673088110124808736145496368408203125000000000000000000e-36"),
- cpp_float("1.203706215242022408159986214115579574086313530134617622024961747229099273681640625000000000000000000e-35"),
- cpp_float("2.407412430484044816319972428231159148172627060269235244049923494458198547363281250000000000000000000e-35"),
- cpp_float("4.814824860968089632639944856462318296345254120538470488099846988916397094726562500000000000000000000e-35"),
- cpp_float("9.629649721936179265279889712924636592690508241076940976199693977832794189453125000000000000000000000e-35"),
- cpp_float("1.925929944387235853055977942584927318538101648215388195239938795566558837890625000000000000000000000e-34"),
- cpp_float("3.851859888774471706111955885169854637076203296430776390479877591133117675781250000000000000000000000e-34"),
- cpp_float("7.703719777548943412223911770339709274152406592861552780959755182266235351562500000000000000000000000e-34"),
- cpp_float("1.540743955509788682444782354067941854830481318572310556191951036453247070312500000000000000000000000e-33"),
- cpp_float("3.081487911019577364889564708135883709660962637144621112383902072906494140625000000000000000000000000e-33"),
- cpp_float("6.162975822039154729779129416271767419321925274289242224767804145812988281250000000000000000000000000e-33"),
- cpp_float("1.232595164407830945955825883254353483864385054857848444953560829162597656250000000000000000000000000e-32"),
- cpp_float("2.465190328815661891911651766508706967728770109715696889907121658325195312500000000000000000000000000e-32"),
- cpp_float("4.930380657631323783823303533017413935457540219431393779814243316650390625000000000000000000000000000e-32"),
- cpp_float("9.860761315262647567646607066034827870915080438862787559628486633300781250000000000000000000000000000e-32"),
- cpp_float("1.972152263052529513529321413206965574183016087772557511925697326660156250000000000000000000000000000e-31"),
- cpp_float("3.944304526105059027058642826413931148366032175545115023851394653320312500000000000000000000000000000e-31"),
- cpp_float("7.888609052210118054117285652827862296732064351090230047702789306640625000000000000000000000000000000e-31"),
- cpp_float("1.577721810442023610823457130565572459346412870218046009540557861328125000000000000000000000000000000e-30"),
- cpp_float("3.155443620884047221646914261131144918692825740436092019081115722656250000000000000000000000000000000e-30"),
- cpp_float("6.310887241768094443293828522262289837385651480872184038162231445312500000000000000000000000000000000e-30"),
- cpp_float("1.262177448353618888658765704452457967477130296174436807632446289062500000000000000000000000000000000e-29"),
- cpp_float("2.524354896707237777317531408904915934954260592348873615264892578125000000000000000000000000000000000e-29"),
- cpp_float("5.048709793414475554635062817809831869908521184697747230529785156250000000000000000000000000000000000e-29"),
- cpp_float("1.009741958682895110927012563561966373981704236939549446105957031250000000000000000000000000000000000e-28"),
- cpp_float("2.019483917365790221854025127123932747963408473879098892211914062500000000000000000000000000000000000e-28"),
- cpp_float("4.038967834731580443708050254247865495926816947758197784423828125000000000000000000000000000000000000e-28"),
- cpp_float("8.077935669463160887416100508495730991853633895516395568847656250000000000000000000000000000000000000e-28"),
- cpp_float("1.615587133892632177483220101699146198370726779103279113769531250000000000000000000000000000000000000e-27"),
- cpp_float("3.231174267785264354966440203398292396741453558206558227539062500000000000000000000000000000000000000e-27"),
- cpp_float("6.462348535570528709932880406796584793482907116413116455078125000000000000000000000000000000000000000e-27"),
- cpp_float("1.292469707114105741986576081359316958696581423282623291015625000000000000000000000000000000000000000e-26"),
- cpp_float("2.584939414228211483973152162718633917393162846565246582031250000000000000000000000000000000000000000e-26"),
- cpp_float("5.169878828456422967946304325437267834786325693130493164062500000000000000000000000000000000000000000e-26"),
- cpp_float("1.033975765691284593589260865087453566957265138626098632812500000000000000000000000000000000000000000e-25"),
- cpp_float("2.067951531382569187178521730174907133914530277252197265625000000000000000000000000000000000000000000e-25"),
- cpp_float("4.135903062765138374357043460349814267829060554504394531250000000000000000000000000000000000000000000e-25"),
- cpp_float("8.271806125530276748714086920699628535658121109008789062500000000000000000000000000000000000000000000e-25"),
- cpp_float("1.654361225106055349742817384139925707131624221801757812500000000000000000000000000000000000000000000e-24"),
- cpp_float("3.308722450212110699485634768279851414263248443603515625000000000000000000000000000000000000000000000e-24"),
- cpp_float("6.617444900424221398971269536559702828526496887207031250000000000000000000000000000000000000000000000e-24"),
- cpp_float("1.323488980084844279794253907311940565705299377441406250000000000000000000000000000000000000000000000e-23"),
- cpp_float("2.646977960169688559588507814623881131410598754882812500000000000000000000000000000000000000000000000e-23"),
- cpp_float("5.293955920339377119177015629247762262821197509765625000000000000000000000000000000000000000000000000e-23"),
- cpp_float("1.058791184067875423835403125849552452564239501953125000000000000000000000000000000000000000000000000e-22"),
- cpp_float("2.117582368135750847670806251699104905128479003906250000000000000000000000000000000000000000000000000e-22"),
- cpp_float("4.235164736271501695341612503398209810256958007812500000000000000000000000000000000000000000000000000e-22"),
- cpp_float("8.470329472543003390683225006796419620513916015625000000000000000000000000000000000000000000000000000e-22"),
- cpp_float("1.694065894508600678136645001359283924102783203125000000000000000000000000000000000000000000000000000e-21"),
- cpp_float("3.388131789017201356273290002718567848205566406250000000000000000000000000000000000000000000000000000e-21"),
- cpp_float("6.776263578034402712546580005437135696411132812500000000000000000000000000000000000000000000000000000e-21"),
- cpp_float("1.355252715606880542509316001087427139282226562500000000000000000000000000000000000000000000000000000e-20"),
- cpp_float("2.710505431213761085018632002174854278564453125000000000000000000000000000000000000000000000000000000e-20"),
- cpp_float("5.421010862427522170037264004349708557128906250000000000000000000000000000000000000000000000000000000e-20"),
- cpp_float("1.084202172485504434007452800869941711425781250000000000000000000000000000000000000000000000000000000e-19"),
- cpp_float("2.168404344971008868014905601739883422851562500000000000000000000000000000000000000000000000000000000e-19"),
- cpp_float("4.336808689942017736029811203479766845703125000000000000000000000000000000000000000000000000000000000e-19"),
- cpp_float("8.673617379884035472059622406959533691406250000000000000000000000000000000000000000000000000000000000e-19"),
- cpp_float("1.734723475976807094411924481391906738281250000000000000000000000000000000000000000000000000000000000e-18"),
- cpp_float("3.469446951953614188823848962783813476562500000000000000000000000000000000000000000000000000000000000e-18"),
- cpp_float("6.938893903907228377647697925567626953125000000000000000000000000000000000000000000000000000000000000e-18"),
- cpp_float("1.387778780781445675529539585113525390625000000000000000000000000000000000000000000000000000000000000e-17"),
- cpp_float("2.775557561562891351059079170227050781250000000000000000000000000000000000000000000000000000000000000e-17"),
- cpp_float("5.551115123125782702118158340454101562500000000000000000000000000000000000000000000000000000000000000e-17"),
- cpp_float("1.110223024625156540423631668090820312500000000000000000000000000000000000000000000000000000000000000e-16"),
- cpp_float("2.220446049250313080847263336181640625000000000000000000000000000000000000000000000000000000000000000e-16"),
- cpp_float("4.440892098500626161694526672363281250000000000000000000000000000000000000000000000000000000000000000e-16"),
- cpp_float("8.881784197001252323389053344726562500000000000000000000000000000000000000000000000000000000000000000e-16"),
- cpp_float("1.776356839400250464677810668945312500000000000000000000000000000000000000000000000000000000000000000e-15"),
- cpp_float("3.552713678800500929355621337890625000000000000000000000000000000000000000000000000000000000000000000e-15"),
- cpp_float("7.105427357601001858711242675781250000000000000000000000000000000000000000000000000000000000000000000e-15"),
- cpp_float("1.421085471520200371742248535156250000000000000000000000000000000000000000000000000000000000000000000e-14"),
- cpp_float("2.842170943040400743484497070312500000000000000000000000000000000000000000000000000000000000000000000e-14"),
- cpp_float("5.684341886080801486968994140625000000000000000000000000000000000000000000000000000000000000000000000e-14"),
- cpp_float("1.136868377216160297393798828125000000000000000000000000000000000000000000000000000000000000000000000e-13"),
- cpp_float("2.273736754432320594787597656250000000000000000000000000000000000000000000000000000000000000000000000e-13"),
- cpp_float("4.547473508864641189575195312500000000000000000000000000000000000000000000000000000000000000000000000e-13"),
- cpp_float("9.094947017729282379150390625000000000000000000000000000000000000000000000000000000000000000000000000e-13"),
- cpp_float("1.818989403545856475830078125000000000000000000000000000000000000000000000000000000000000000000000000e-12"),
- cpp_float("3.637978807091712951660156250000000000000000000000000000000000000000000000000000000000000000000000000e-12"),
- cpp_float("7.275957614183425903320312500000000000000000000000000000000000000000000000000000000000000000000000000e-12"),
- cpp_float("1.455191522836685180664062500000000000000000000000000000000000000000000000000000000000000000000000000e-11"),
- cpp_float("2.910383045673370361328125000000000000000000000000000000000000000000000000000000000000000000000000000e-11"),
- cpp_float("5.820766091346740722656250000000000000000000000000000000000000000000000000000000000000000000000000000e-11"),
- cpp_float("1.164153218269348144531250000000000000000000000000000000000000000000000000000000000000000000000000000e-10"),
- cpp_float("2.328306436538696289062500000000000000000000000000000000000000000000000000000000000000000000000000000e-10"),
- cpp_float("4.656612873077392578125000000000000000000000000000000000000000000000000000000000000000000000000000000e-10"),
- cpp_float("9.313225746154785156250000000000000000000000000000000000000000000000000000000000000000000000000000000e-10"),
- cpp_float("1.862645149230957031250000000000000000000000000000000000000000000000000000000000000000000000000000000e-9"),
- cpp_float("3.725290298461914062500000000000000000000000000000000000000000000000000000000000000000000000000000000e-9"),
- cpp_float("7.450580596923828125000000000000000000000000000000000000000000000000000000000000000000000000000000000e-9"),
- cpp_float("1.490116119384765625000000000000000000000000000000000000000000000000000000000000000000000000000000000e-8"),
- cpp_float("2.980232238769531250000000000000000000000000000000000000000000000000000000000000000000000000000000000e-8"),
- cpp_float("5.960464477539062500000000000000000000000000000000000000000000000000000000000000000000000000000000000e-8"),
- cpp_float("1.192092895507812500000000000000000000000000000000000000000000000000000000000000000000000000000000000e-7"),
- cpp_float("2.384185791015625000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-7"),
- cpp_float("4.768371582031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-7"),
- cpp_float("9.536743164062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-7"),
- cpp_float("1.907348632812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-6"),
- cpp_float("3.814697265625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-6"),
- cpp_float("7.629394531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-6"),
- cpp_float("0.000015258789062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.000030517578125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.000061035156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.000122070312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.000244140625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.000488281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.000976562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.001953125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.003906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.007812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.01562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.03125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.06250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
- cpp_float("0.125"),
- cpp_float("0.25"),
- cpp_float("0.5"),
- one(),
- two(),
- cpp_float(static_cast<unsigned long long>(4)),
- cpp_float(static_cast<unsigned long long>(8)),
- cpp_float(static_cast<unsigned long long>(16)),
- cpp_float(static_cast<unsigned long long>(32)),
- cpp_float(static_cast<unsigned long long>(64)),
- cpp_float(static_cast<unsigned long long>(128)),
- cpp_float(static_cast<unsigned long long>(256)),
- cpp_float(static_cast<unsigned long long>(512)),
- cpp_float(static_cast<unsigned long long>(1024)),
- cpp_float(static_cast<unsigned long long>(2048)),
- cpp_float(static_cast<unsigned long long>(4096)),
- cpp_float(static_cast<unsigned long long>(8192)),
- cpp_float(static_cast<unsigned long long>(16384)),
- cpp_float(static_cast<unsigned long long>(32768)),
- cpp_float(static_cast<unsigned long long>(65536)),
- cpp_float(static_cast<unsigned long long>(131072)),
- cpp_float(static_cast<unsigned long long>(262144)),
- cpp_float(static_cast<unsigned long long>(524288)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 20u)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 21u)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 22u)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 23u)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 24u)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 25u)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 26u)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 27u)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 28u)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 29u)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 30u)),
- cpp_float(static_cast<boost::uint64_t>(1uL << 31u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 32u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 33u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 34u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 35u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 36u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 37u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 38u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 39u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 40u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 41u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 42u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 43u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 44u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 45u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 46u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 47u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 48u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 49u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 50u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 51u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 52u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 53u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 54u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 55u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 56u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 57u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 58u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 59u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 60u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 61u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 62u)),
- cpp_float(static_cast<boost::uint64_t>(1uLL << 63u)),
- cpp_float("1.844674407370955161600000000000000000000000000000000000000000000000000000000000000000000000000000000e19"),
- cpp_float("3.689348814741910323200000000000000000000000000000000000000000000000000000000000000000000000000000000e19"),
- cpp_float("7.378697629483820646400000000000000000000000000000000000000000000000000000000000000000000000000000000e19"),
- cpp_float("1.475739525896764129280000000000000000000000000000000000000000000000000000000000000000000000000000000e20"),
- cpp_float("2.951479051793528258560000000000000000000000000000000000000000000000000000000000000000000000000000000e20"),
- cpp_float("5.902958103587056517120000000000000000000000000000000000000000000000000000000000000000000000000000000e20"),
- cpp_float("1.180591620717411303424000000000000000000000000000000000000000000000000000000000000000000000000000000e21"),
- cpp_float("2.361183241434822606848000000000000000000000000000000000000000000000000000000000000000000000000000000e21"),
- cpp_float("4.722366482869645213696000000000000000000000000000000000000000000000000000000000000000000000000000000e21"),
- cpp_float("9.444732965739290427392000000000000000000000000000000000000000000000000000000000000000000000000000000e21"),
- cpp_float("1.888946593147858085478400000000000000000000000000000000000000000000000000000000000000000000000000000e22"),
- cpp_float("3.777893186295716170956800000000000000000000000000000000000000000000000000000000000000000000000000000e22"),
- cpp_float("7.555786372591432341913600000000000000000000000000000000000000000000000000000000000000000000000000000e22"),
- cpp_float("1.511157274518286468382720000000000000000000000000000000000000000000000000000000000000000000000000000e23"),
- cpp_float("3.022314549036572936765440000000000000000000000000000000000000000000000000000000000000000000000000000e23"),
- cpp_float("6.044629098073145873530880000000000000000000000000000000000000000000000000000000000000000000000000000e23"),
- cpp_float("1.208925819614629174706176000000000000000000000000000000000000000000000000000000000000000000000000000e24"),
- cpp_float("2.417851639229258349412352000000000000000000000000000000000000000000000000000000000000000000000000000e24"),
- cpp_float("4.835703278458516698824704000000000000000000000000000000000000000000000000000000000000000000000000000e24"),
- cpp_float("9.671406556917033397649408000000000000000000000000000000000000000000000000000000000000000000000000000e24"),
- cpp_float("1.934281311383406679529881600000000000000000000000000000000000000000000000000000000000000000000000000e25"),
- cpp_float("3.868562622766813359059763200000000000000000000000000000000000000000000000000000000000000000000000000e25"),
- cpp_float("7.737125245533626718119526400000000000000000000000000000000000000000000000000000000000000000000000000e25"),
- cpp_float("1.547425049106725343623905280000000000000000000000000000000000000000000000000000000000000000000000000e26"),
- cpp_float("3.094850098213450687247810560000000000000000000000000000000000000000000000000000000000000000000000000e26"),
- cpp_float("6.189700196426901374495621120000000000000000000000000000000000000000000000000000000000000000000000000e26"),
- cpp_float("1.237940039285380274899124224000000000000000000000000000000000000000000000000000000000000000000000000e27"),
- cpp_float("2.475880078570760549798248448000000000000000000000000000000000000000000000000000000000000000000000000e27"),
- cpp_float("4.951760157141521099596496896000000000000000000000000000000000000000000000000000000000000000000000000e27"),
- cpp_float("9.903520314283042199192993792000000000000000000000000000000000000000000000000000000000000000000000000e27"),
- cpp_float("1.980704062856608439838598758400000000000000000000000000000000000000000000000000000000000000000000000e28"),
- cpp_float("3.961408125713216879677197516800000000000000000000000000000000000000000000000000000000000000000000000e28"),
- cpp_float("7.922816251426433759354395033600000000000000000000000000000000000000000000000000000000000000000000000e28"),
- cpp_float("1.584563250285286751870879006720000000000000000000000000000000000000000000000000000000000000000000000e29"),
- cpp_float("3.169126500570573503741758013440000000000000000000000000000000000000000000000000000000000000000000000e29"),
- cpp_float("6.338253001141147007483516026880000000000000000000000000000000000000000000000000000000000000000000000e29"),
- cpp_float("1.267650600228229401496703205376000000000000000000000000000000000000000000000000000000000000000000000e30"),
- cpp_float("2.535301200456458802993406410752000000000000000000000000000000000000000000000000000000000000000000000e30"),
- cpp_float("5.070602400912917605986812821504000000000000000000000000000000000000000000000000000000000000000000000e30"),
- cpp_float("1.014120480182583521197362564300800000000000000000000000000000000000000000000000000000000000000000000e31"),
- cpp_float("2.028240960365167042394725128601600000000000000000000000000000000000000000000000000000000000000000000e31"),
- cpp_float("4.056481920730334084789450257203200000000000000000000000000000000000000000000000000000000000000000000e31"),
- cpp_float("8.112963841460668169578900514406400000000000000000000000000000000000000000000000000000000000000000000e31"),
- cpp_float("1.622592768292133633915780102881280000000000000000000000000000000000000000000000000000000000000000000e32"),
- cpp_float("3.245185536584267267831560205762560000000000000000000000000000000000000000000000000000000000000000000e32"),
- cpp_float("6.490371073168534535663120411525120000000000000000000000000000000000000000000000000000000000000000000e32"),
- cpp_float("1.298074214633706907132624082305024000000000000000000000000000000000000000000000000000000000000000000e33"),
- cpp_float("2.596148429267413814265248164610048000000000000000000000000000000000000000000000000000000000000000000e33"),
- cpp_float("5.192296858534827628530496329220096000000000000000000000000000000000000000000000000000000000000000000e33"),
- cpp_float("1.038459371706965525706099265844019200000000000000000000000000000000000000000000000000000000000000000e34"),
- cpp_float("2.076918743413931051412198531688038400000000000000000000000000000000000000000000000000000000000000000e34"),
- cpp_float("4.153837486827862102824397063376076800000000000000000000000000000000000000000000000000000000000000000e34"),
- cpp_float("8.307674973655724205648794126752153600000000000000000000000000000000000000000000000000000000000000000e34"),
- cpp_float("1.661534994731144841129758825350430720000000000000000000000000000000000000000000000000000000000000000e35"),
- cpp_float("3.323069989462289682259517650700861440000000000000000000000000000000000000000000000000000000000000000e35"),
- cpp_float("6.646139978924579364519035301401722880000000000000000000000000000000000000000000000000000000000000000e35"),
- cpp_float("1.329227995784915872903807060280344576000000000000000000000000000000000000000000000000000000000000000e36"),
- cpp_float("2.658455991569831745807614120560689152000000000000000000000000000000000000000000000000000000000000000e36"),
- cpp_float("5.316911983139663491615228241121378304000000000000000000000000000000000000000000000000000000000000000e36"),
- cpp_float("1.063382396627932698323045648224275660800000000000000000000000000000000000000000000000000000000000000e37"),
- cpp_float("2.126764793255865396646091296448551321600000000000000000000000000000000000000000000000000000000000000e37"),
- cpp_float("4.253529586511730793292182592897102643200000000000000000000000000000000000000000000000000000000000000e37"),
- cpp_float("8.507059173023461586584365185794205286400000000000000000000000000000000000000000000000000000000000000e37"),
- cpp_float("1.701411834604692317316873037158841057280000000000000000000000000000000000000000000000000000000000000e38")
- }};
-
- if((p > static_cast<boost::int64_t>(-128)) && (p < static_cast<boost::int64_t>(+128)))
- {
- return p2_data[static_cast<std::size_t>(p + ((p2_data.size() - 1u) / 2u))];
- }
-
- // Compute and return 2^p.
- if(p < static_cast<boost::int64_t>(0))
- {
- return pow2(static_cast<boost::int64_t>(-p)).calculate_inv();
- }
- else if(p < static_cast<boost::int64_t>(std::numeric_limits<boost::uint64_t>::digits))
- {
- const boost::uint64_t p2 = static_cast<boost::uint64_t>(static_cast<boost::uint64_t>(1uLL) << p);
- return cpp_float(p2);
- }
- else
- {
- cpp_float<Digits10> t;
- default_ops::detail::pow_imp(t, two(), p, mpl::true_());
- return t;
- }
-}
-
-
-template <unsigned Digits10>
-inline void add(cpp_float<Digits10>& result, const cpp_float<Digits10>& o)
-{
- result += o;
-}
-template <unsigned Digits10>
-inline void subtract(cpp_float<Digits10>& result, const cpp_float<Digits10>& o)
-{
- result -= o;
-}
-template <unsigned Digits10>
-inline void multiply(cpp_float<Digits10>& result, const cpp_float<Digits10>& o)
-{
- result *= o;
-}
-template <unsigned Digits10>
-inline void divide(cpp_float<Digits10>& result, const cpp_float<Digits10>& o)
-{
- result /= o;
-}
-
-template <unsigned Digits10>
-inline void add(cpp_float<Digits10>& result, const unsigned long long& o)
-{
- result.add_unsigned_long_long(o);
-}
-template <unsigned Digits10>
-inline void subtract(cpp_float<Digits10>& result, const unsigned long long& o)
-{
- result.sub_unsigned_long_long(o);
-}
-template <unsigned Digits10>
-inline void multiply(cpp_float<Digits10>& result, const unsigned long long& o)
-{
- result.mul_unsigned_long_long(o);
-}
-template <unsigned Digits10>
-inline void divide(cpp_float<Digits10>& result, const unsigned long long& o)
-{
- result.div_unsigned_long_long(o);
-}
-
-template <unsigned Digits10>
-inline void add(cpp_float<Digits10>& result, long long o)
-{
- if(o < 0)
- result.sub_unsigned_long_long(-o);
- else
- result.add_unsigned_long_long(o);
-}
-template <unsigned Digits10>
-inline void subtract(cpp_float<Digits10>& result, long long o)
-{
- if(o < 0)
- result.add_unsigned_long_long(-o);
- else
- result.sub_unsigned_long_long(o);
-}
-template <unsigned Digits10>
-inline void multiply(cpp_float<Digits10>& result, long long o)
-{
- if(o < 0)
- {
- result.mul_unsigned_long_long(-o);
- result.negate();
- }
- else
- result.mul_unsigned_long_long(o);
-}
-template <unsigned Digits10>
-inline void divide(cpp_float<Digits10>& result, long long o)
-{
- if(o < 0)
- {
- result.div_unsigned_long_long(-o);
- result.negate();
- }
- else
- result.div_unsigned_long_long(o);
-}
-
-template <unsigned Digits10>
-inline void convert_to(unsigned long long* result, const cpp_float<Digits10>& val)
-{
- *result = val.extract_unsigned_long_long();
-}
-template <unsigned Digits10>
-inline void convert_to(long long* result, const cpp_float<Digits10>& val)
-{
- *result = val.extract_signed_long_long();
-}
-template <unsigned Digits10>
-inline void convert_to(long double* result, cpp_float<Digits10>& val)
-{
- *result = val.extract_long_double();
-}
-
-//
-// Non member function support:
-//
-template <unsigned Digits10>
-inline int eval_fpclassify(const cpp_float<Digits10>& x)
-{
- if(x.isinf())
- return FP_INFINITE;
- if(x.isnan())
- return FP_NAN;
- if(x.iszero())
- return FP_ZERO;
- return FP_NORMAL;
-}
-
-template <unsigned Digits10>
-inline void eval_abs(cpp_float<Digits10>& result, const cpp_float<Digits10>& x)
-{
- result = x;
- if(x.isneg())
- result.negate();
-}
-
-template <unsigned Digits10>
-inline void eval_fabs(cpp_float<Digits10>& result, const cpp_float<Digits10>& x)
-{
- result = x;
- if(x.isneg())
- result.negate();
-}
-
-template <unsigned Digits10>
-inline void eval_sqrt(cpp_float<Digits10>& result, const cpp_float<Digits10>& x)
-{
- result = x;
- result.calculate_sqrt();
-}
-
-template <unsigned Digits10>
-inline void eval_floor(cpp_float<Digits10>& result, const cpp_float<Digits10>& x)
-{
- result = x;
- if(!x.isfinite() || x.isint())
- {
- return;
- }
-
- if(x.isneg())
- result -= cpp_float<Digits10>::one();
- result = result.extract_integer_part();
-}
-
-template <unsigned Digits10>
-inline void eval_ceil(cpp_float<Digits10>& result, const cpp_float<Digits10>& x)
-{
- result = x;
- if(!x.isfinite() || x.isint())
- {
- return;
- }
-
- if(!x.isneg())
- result += cpp_float<Digits10>::one();
- result = result.extract_integer_part();
-}
-
-template <unsigned Digits10>
-inline void eval_trunc(cpp_float<Digits10>& result, const cpp_float<Digits10>& x)
-{
- if(!x.isfinite())
- {
- result = boost::math::policies::raise_rounding_error("boost::multiprecision::trunc<%1%>(%1%)", 0, mp_number<cpp_float<Digits10> >(x), 0, boost::math::policies::policy<>()).backend();
- return;
- }
- else if(x.isint())
- {
- result = x;
- return;
- }
- result = x.extract_integer_part();
-}
-
-template <unsigned Digits10>
-inline void eval_ldexp(cpp_float<Digits10>& result, const cpp_float<Digits10>& x, long long e)
-{
- result = x;
- result *= cpp_float<Digits10>::pow2(e);
-}
-
-template <unsigned Digits10>
-inline void eval_frexp(cpp_float<Digits10>& result, const cpp_float<Digits10>& x, long long* e)
-{
- result = x;
- if(result.isneg())
- result.negate();
-
- if(result.iszero())
- {
- *e = 0;
- return;
- }
-
- long long t = result.order();
- BOOST_MP_USING_ABS
- if(abs(t) < ((std::numeric_limits<long long>::max)() / 1000))
- {
- t *= 1000;
- t /= 301;
- }
- else
- {
- t /= 301;
- t *= 1000;
- }
-
- result *= cpp_float<Digits10>::pow2(-t);
-
- if(result.iszero() || result.isinf() || result.isnan())
- {
- // pow2 overflowed, slip the calculation up:
- result = x;
- if(result.isneg())
- result.negate();
- t /= 2;
- result *= cpp_float<Digits10>::pow2(-t);
- }
- BOOST_MP_USING_ABS
- if(abs(result.order()) > 5)
- {
- // If our first estimate doesn't get close enough then try recursion until we do:
- long long e2;
- cpp_float<Digits10> r2;
- eval_frexp(r2, result, &e2);
- // overflow prtection:
- if((t > 0) && (e2 > 0) && (t > (std::numeric_limits<long long>::max)() - e2))
- BOOST_THROW_EXCEPTION(std::runtime_error("Exponent is too large to be represented as a power of 2."));
- if((t < 0) && (e2 < 0) && (t < (std::numeric_limits<long long>::min)() - e2))
- BOOST_THROW_EXCEPTION(std::runtime_error("Exponent is too large to be represented as a power of 2."));
- t += e2;
- result = r2;
- }
-
- while(result.compare(cpp_float<Digits10>::one()) >= 0)
- {
- result /= cpp_float<Digits10>::two();
- ++t;
- }
- while(result.compare(cpp_float<Digits10>::half()) < 0)
- {
- result *= cpp_float<Digits10>::two();
- --t;
- }
- *e = t;
- if(x.isneg())
- result.negate();
-}
-
-template <unsigned Digits10>
-inline void eval_frexp(cpp_float<Digits10>& result, const cpp_float<Digits10>& x, int* e)
-{
- long long t;
- eval_frexp(result, x, &t);
- if(t > (std::numeric_limits<int>::max)())
- BOOST_THROW_EXCEPTION(std::runtime_error("Exponent is outside the range of an int"));
- *e = static_cast<int>(t);
-}
-
-template <unsigned Digits10>
-inline bool is_zero(const cpp_float<Digits10>& val)
-{
- return val.iszero();
-}
-template <unsigned Digits10>
-inline int get_sign(const cpp_float<Digits10>& val)
-{
- return val.iszero() ? 0 : val.isneg() ? -1 : 1;
-}
-
-
-typedef mp_number<cpp_float<50> > cpp_float_50;
-typedef mp_number<cpp_float<100> > cpp_float_100;
-
-}}
-
-namespace std
-{
- template <unsigned Digits10>
- class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > >
- {
- public:
- static const bool is_specialized = true;
- static const bool is_signed = true;
- static const bool is_integer = false;
- static const bool is_exact = false;
- static const bool is_bounded = true;
- static const bool is_modulo = false;
- static const bool is_iec559 = false;
- static const int digits = Digits10;
- static const int digits10 = boost::multiprecision::cpp_float<Digits10>::cpp_float_digits10;
- static const int max_digits10 = boost::multiprecision::cpp_float<Digits10>::cpp_float_max_digits10;
- static const boost::int64_t min_exponent = boost::multiprecision::cpp_float<Digits10>::cpp_float_min_exp; // Type differs from int.
- static const boost::int64_t min_exponent10 = boost::multiprecision::cpp_float<Digits10>::cpp_float_min_exp10; // Type differs from int.
- static const boost::int64_t max_exponent = boost::multiprecision::cpp_float<Digits10>::cpp_float_max_exp; // Type differs from int.
- static const boost::int64_t max_exponent10 = boost::multiprecision::cpp_float<Digits10>::cpp_float_max_exp10; // Type differs from int.
- static const int radix = boost::multiprecision::cpp_float<Digits10>::mp_radix;
- static const std::float_round_style round_style = std::round_to_nearest;
- static const bool has_infinity = true;
- static const bool has_quiet_NaN = true;
- static const bool has_signaling_NaN = false;
- static const std::float_denorm_style has_denorm = std::denorm_absent;
- static const bool has_denorm_loss = false;
- static const bool traps = false;
- static const bool tinyness_before = false;
-
- static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > (min) (void) { return (boost::multiprecision::cpp_float<Digits10>::min)(); }
- static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > (max) (void) { return (boost::multiprecision::cpp_float<Digits10>::max)(); }
- static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > lowest (void) { return boost::multiprecision::cpp_float<Digits10>::zero(); }
- static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > epsilon (void) { return boost::multiprecision::cpp_float<Digits10>::eps(); }
- static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > round_error (void) { return 0.5L; }
- static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > infinity (void) { return boost::multiprecision::cpp_float<Digits10>::inf(); }
- static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > quiet_NaN (void) { return boost::multiprecision::cpp_float<Digits10>::nan(); }
- static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > signaling_NaN(void) { return boost::multiprecision::cpp_float<Digits10>::zero(); }
- static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > denorm_min (void) { return boost::multiprecision::cpp_float<Digits10>::zero(); }
- };
-}
-
-namespace boost{ namespace math{
-
-namespace policies{
-
-template <unsigned Digits10, class Policy>
-struct precision< boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> >, Policy>
-{
- typedef typename Policy::precision_type precision_type;
- typedef digits2<((Digits10 + 1) * 1000L) / 301L> digits_2;
- typedef typename mpl::if_c<
- ((digits_2::value <= precision_type::value)
- || (Policy::precision_type::value <= 0)),
- // Default case, full precision for RealType:
- digits_2,
- // User customised precision:
- precision_type
- >::type type;
-};
-
-} // namespace policies
-
-}} // namespaces boost::math
-
-
-#endif
-

Modified: sandbox/big_number/boost/multiprecision/detail/default_ops.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/detail/default_ops.hpp (original)
+++ sandbox/big_number/boost/multiprecision/detail/default_ops.hpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -405,7 +405,7 @@
template <class T>
void eval_fabs(T& result, const T& arg)
{
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The fabs function is only valid for floating point types.");
+ BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The fabs function is only valid for floating point types.");
 typedef typename T::signed_types type_list;
 typedef typename mpl::front<type_list>::type front;
 result = arg;
@@ -423,7 +423,7 @@
template <class T>
inline void eval_fmod(T& result, const T& a, const T& b)
{
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The fmod function is only valid for floating point types.");
+ BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The fmod function is only valid for floating point types.");
 if((&result == &a) || (&result == &b))
 {
 T temp;
@@ -443,7 +443,7 @@
template <class T>
inline void eval_trunc(T& result, const T& a)
{
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The trunc function is only valid for floating point types.");
+ BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The trunc function is only valid for floating point types.");
 int c = eval_fpclassify(a);
 if(c == FP_NAN || c == FP_INFINITE)
 {
@@ -459,7 +459,7 @@
template <class T>
inline void eval_round(T& result, const T& a)
{
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The round function is only valid for floating point types.");
+ BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The round function is only valid for floating point types.");
 typedef typename boost::multiprecision::detail::canonical<float, T>::type fp_type;
 int c = eval_fpclassify(a);
 if(c == FP_NAN || c == FP_INFINITE)

Modified: sandbox/big_number/boost/multiprecision/detail/functions/pow.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/detail/functions/pow.hpp (original)
+++ sandbox/big_number/boost/multiprecision/detail/functions/pow.hpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -86,7 +86,7 @@
template<typename T, typename U>
inline void eval_pow(T& result, const T& t, const U& p)
{
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The pow function is only valid for floating point types.");
+ BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The pow function is only valid for floating point types.");
 typedef typename is_integral::type tag_type;
 detail::pow_imp(result, t, p, tag_type());
}
@@ -185,7 +185,7 @@
template <class T>
void eval_exp(T& result, const T& x)
{
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The ldexp function is only valid for floating point types.");
+ BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The ldexp function is only valid for floating point types.");
 if(&x == &result)
 {
 T temp;
@@ -325,7 +325,7 @@
template <class T>
void eval_log(T& result, const T& arg)
{
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The log function is only valid for floating point types.");
+ BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The log function is only valid for floating point types.");
 //
 // We use a variation of http://dlmf.nist.gov/4.45#i
 // using frexp to reduce the argument to x * 2^n,
@@ -413,7 +413,7 @@
template <class T>
void eval_log10(T& result, const T& arg)
{
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The fabs function is only valid for floating point types.");
+ BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The fabs function is only valid for floating point types.");
 eval_log(result, arg);
 divide(result, get_constant_log10<T>());
}
@@ -421,7 +421,7 @@
template<typename T>
inline void eval_pow(T& result, const T& x, const T& a)
{
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The pow function is only valid for floating point types.");
+ BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The pow function is only valid for floating point types.");
 typedef typename boost::multiprecision::detail::canonical<int, T>::type si_type;
 typedef typename boost::multiprecision::detail::canonical<unsigned, T>::type ui_type;
 typedef typename T::exponent_type exp_type;
@@ -641,21 +641,21 @@
template <class T>
inline void eval_sinh(T& result, const T& x)
{
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The sinh function is only valid for floating point types.");
+ BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The sinh function is only valid for floating point types.");
 detail::sinhcosh(x, &result, static_cast<T*>(0));
}

template <class T>
inline void eval_cosh(T& result, const T& x)
{
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The cosh function is only valid for floating point types.");
+ BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The cosh function is only valid for floating point types.");
 detail::sinhcosh(x, static_cast<T*>(0), &result);
}

template <class T>
inline void eval_tanh(T& result, const T& x)
{
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The tanh function is only valid for floating point types.");
+ BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The tanh function is only valid for floating point types.");
 T c;
 detail::sinhcosh(x, &result, &c);
 divide(result, c);

Modified: sandbox/big_number/boost/multiprecision/detail/functions/trig.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/detail/functions/trig.hpp (original)
+++ sandbox/big_number/boost/multiprecision/detail/functions/trig.hpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -68,7 +68,7 @@
template <class T>
void eval_sin(T& result, const T& x)
{
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The sin function is only valid for floating point types.");
+ BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The sin function is only valid for floating point types.");
 if(&result == &x)
 {
 T temp;
@@ -214,7 +214,7 @@
template <class T>
void eval_cos(T& result, const T& x)
{
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The cos function is only valid for floating point types.");
+ BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The cos function is only valid for floating point types.");
 if(&result == &x)
 {
 T temp;
@@ -357,7 +357,7 @@
template <class T>
void eval_tan(T& result, const T& x)
{
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The tan function is only valid for floating point types.");
+ BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The tan function is only valid for floating point types.");
 T t;
 eval_sin(result, x);
 eval_cos(t, x);
@@ -429,7 +429,7 @@
template <class T>
void eval_asin(T& result, const T& x)
{
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The asin function is only valid for floating point types.");
+ BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The asin function is only valid for floating point types.");
 typedef typename boost::multiprecision::detail::canonical<boost::int32_t, T>::type si_type;
 typedef typename boost::multiprecision::detail::canonical<boost::uint32_t, T>::type ui_type;
 typedef typename T::exponent_type exp_type;
@@ -539,7 +539,7 @@
template <class T>
inline void eval_acos(T& result, const T& x)
{
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The acos function is only valid for floating point types.");
+ BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The acos function is only valid for floating point types.");
 typedef typename boost::multiprecision::detail::canonical<boost::uint32_t, T>::type ui_type;

 switch(eval_fpclassify(x))
@@ -581,7 +581,7 @@
template <class T>
void eval_atan(T& result, const T& x)
{
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The atan function is only valid for floating point types.");
+ BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The atan function is only valid for floating point types.");
 typedef typename boost::multiprecision::detail::canonical<boost::int32_t, T>::type si_type;
 typedef typename boost::multiprecision::detail::canonical<boost::uint32_t, T>::type ui_type;
 typedef typename T::exponent_type exp_type;
@@ -672,7 +672,7 @@
template <class T>
void eval_atan2(T& result, const T& y, const T& x)
{
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The atan2 function is only valid for floating point types.");
+ BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The atan2 function is only valid for floating point types.");
 if(&result == &y)
 {
 T temp(y);
@@ -770,7 +770,7 @@
template <class T, class Arithmetic>
typename disable_if<is_same<T, Arithmetic> >::type eval_atan2(T& result, const T& a, const Arithmetic& b)
{
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The atan2 function is only valid for floating point types.");
+ BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The atan2 function is only valid for floating point types.");
 T x;
 x = static_cast<typename boost::multiprecision::detail::canonical<Arithmetic, T>::type>(b);
 eval_atan2(result, a, x);

Modified: sandbox/big_number/libs/multiprecision/doc/multiprecision.qbk
==============================================================================
--- sandbox/big_number/libs/multiprecision/doc/multiprecision.qbk (original)
+++ sandbox/big_number/libs/multiprecision/doc/multiprecision.qbk 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -322,7 +322,7 @@
[[Backend Type][Header][Radix][Dependencies][Pros][Cons]]
[[`mpf_float<N>`][boost/multiprecision/gmp.hpp][2][[gmp]][Very fast and efficient backend.][Dependency on GNU licenced [gmp] library.]]
[[`mpfr_float<N>`][boost/multiprecision/mpfr.hpp][2][[gmp] and [mpfr]][Very fast and efficient backend, with its own standard library implementation.][Dependency on GNU licenced [gmp] and [mpfr] libraries.]]
-[[`cpp_float<N>`][boost/multiprecision/cpp_float.hpp][10][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.]]
]

[h4 gmp_float]
@@ -427,23 +427,23 @@

[mpfr_eg]

-[h4 cpp_float]
+[h4 cpp_dec_float]

 namespace boost{ namespace multiprecision{

 template <unsigned Digits10>
- class cpp_float;
+ class cpp_dec_float;

- typedef mp_number<cpp_float<50> > cpp_float_50;
- typedef mp_number<cpp_float<100> > cpp_float_100;
+ typedef mp_number<cpp_dec_float<50> > cpp_float_50;
+ typedef mp_number<cpp_dec_float<100> > cpp_float_100;

 }} // namespaces

-The `cpp_float` backend is used in conjunction with `mp_number`: It acts as an entirely C++ (header only and dependency free)
+The `cpp_dec_float` backend is used in conjunction with `mp_number`: It acts as an entirely C++ (header only and dependency free)
real-number type that is a drop-in replacement for the native C++ floating-point types, but with
much greater precision.

-Type `cpp_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_float_50 and cpp_float_100 provide arithmetic types at 50 and 100 decimal digits precision
respectively.

@@ -451,14 +451,14 @@

Things you should know when using this type:

-* Default constructed `cpp_float`'s have a value of zero.
+* Default constructed `cpp_dec_float`'s have a value of zero.
* The radix of this type is 10. As a result it can behave subtly differently from base-2 types.
* It is not possible to round-trip this type to and from a string and get back to exactly the same value
(this is a result of the type having some hidden internal guard digits).
* The type has a number of internal guard digits over and above those specified in the template argument.
Normally these should not be visible to the user.

-[h5 cpp_float example:]
+[h5 cpp_dec_float example:]

[cpp_float_eg]

@@ -1181,7 +1181,7 @@
[[Library][50 Decimal Digits][100 Decimal Digits]]
[[mpfr_float][[*1.0] (6.472s)][1.193 (10.154s)]]
[[mpf_float][1.801 (11.662s)][[*1.0](8.511s)]]
-[[cpp_float][3.13 (20.285s)][2.46 (21.019s)]]
+[[cpp_dec_float][3.13 (20.285s)][2.46 (21.019s)]]
[[[mpfr_class]][1.001 (6.480s)][1.15(9.805s)]]
[[[mpreal]][1.542 (9.981s)][1.61 (13.702s)]]
]
@@ -1190,7 +1190,7 @@
[[Library][50 Decimal Digits][100 Decimal Digits]]
[[mpfr_float][1.308 (258.09s)][1.30 (516.74s)]]
[[mpf_float][[*1.0] (197.30s)][[*1.0](397.30s)]]
-[[cpp_float][1.695 (334.50s)][2.68 (1064.53s)]]
+[[cpp_dec_float][1.695 (334.50s)][2.68 (1064.53s)]]
[[[mpfr_class]][1.35 (266.39s)][1.323 (525.74s)]]
[[[mpreal]][1.75 (346.64s)][1.635 (649.94s)]]
]
@@ -1212,55 +1212,55 @@

[table Operator +
[[Backend][50 Decimal Digits][100 Decimal Digits][500 Decimal Digits]]
-[[cpp_float][[*1] (0.02382s)][[*1] (0.0294619s)][[*1] (0.058466s)]]
+[[cpp_dec_float][[*1] (0.02382s)][[*1] (0.0294619s)][[*1] (0.058466s)]]
[[gmp_float][4.55086 (0.108402s)][3.86443 (0.113853s)][2.6241 (0.15342s)]]
[[mpfr_float][2.52036 (0.060035s)][2.1833 (0.0643242s)][1.37736 (0.0805287s)]]
]
[table Operator +(int)
[[Backend][50 Decimal Digits][100 Decimal Digits][500 Decimal Digits]]
-[[cpp_float][1.56759 (0.0527023s)][1.74629 (0.0618102s)][1.68077 (0.105927s)]]
+[[cpp_dec_float][1.56759 (0.0527023s)][1.74629 (0.0618102s)][1.68077 (0.105927s)]]
[[gmp_float][[*1] (0.0336201s)][[*1] (0.0353951s)][[*1] (0.0630232s)]]
[[mpfr_float][3.14875 (0.105861s)][3.15499 (0.111671s)][1.92831 (0.121528s)]]
]
[table Operator -
[[Backend][50 Decimal Digits][100 Decimal Digits][500 Decimal Digits]]
-[[cpp_float][[*1] (0.0265783s)][[*1] (0.031465s)][[*1] (0.0619405s)]]
+[[cpp_dec_float][[*1] (0.0265783s)][[*1] (0.031465s)][[*1] (0.0619405s)]]
[[gmp_float][4.66954 (0.124108s)][3.72645 (0.117253s)][2.67536 (0.165713s)]]
[[mpfr_float][2.7909 (0.0741774s)][2.48557 (0.0782083s)][1.50944 (0.0934957s)]]
]
[table Operator -(int)
[[Backend][50 Decimal Digits][100 Decimal Digits][500 Decimal Digits]]
-[[cpp_float][[*1] (0.0577674s)][[*1] (0.0633795s)][[*1] (0.11146s)]]
+[[cpp_dec_float][[*1] (0.0577674s)][[*1] (0.0633795s)][[*1] (0.11146s)]]
[[gmp_float][2.31811 (0.133911s)][2.07251 (0.131355s)][1.67161 (0.186319s)]]
[[mpfr_float][2.45081 (0.141577s)][2.29174 (0.145249s)][1.395 (0.155487s)]]
]
[table Operator *
[[Backend][50 Decimal Digits][100 Decimal Digits][500 Decimal Digits]]
-[[cpp_float][1.07276 (0.287898s)][1.47724 (0.584569s)][1.55145 (5.09969s)]]
+[[cpp_dec_float][1.07276 (0.287898s)][1.47724 (0.584569s)][1.55145 (5.09969s)]]
[[gmp_float][[*1] (0.268372s)][[*1] (0.395718s)][[*1] (3.28705s)]]
[[mpfr_float][1.27302 (0.341642s)][1.17649 (0.465557s)][1.14029 (3.7482s)]]
]
[table Operator *(int)
[[Backend][50 Decimal Digits][100 Decimal Digits][500 Decimal Digits]]
-[[cpp_float][2.89945 (0.11959s)][4.56335 (0.197945s)][9.03602 (0.742044s)]]
+[[cpp_dec_float][2.89945 (0.11959s)][4.56335 (0.197945s)][9.03602 (0.742044s)]]
[[gmp_float][[*1] (0.0412457s)][[*1] (0.0433772s)][[*1] (0.0821206s)]]
[[mpfr_float][3.6951 (0.152407s)][3.71977 (0.161353s)][3.30958 (0.271785s)]]
]
[table Operator /
[[Backend][50 Decimal Digits][100 Decimal Digits][500 Decimal Digits]]
-[[cpp_float][3.24327 (4.00108s)][5.00532 (8.12985s)][6.79566 (54.2796s)]]
+[[cpp_dec_float][3.24327 (4.00108s)][5.00532 (8.12985s)][6.79566 (54.2796s)]]
[[gmp_float][[*1] (1.23366s)][[*1] (1.62424s)][[*1] (7.9874s)]]
[[mpfr_float][1.32521 (1.63486s)][1.38967 (2.25716s)][1.72413 (13.7713s)]]
]
[table Operator /(int)
[[Backend][50 Decimal Digits][100 Decimal Digits][500 Decimal Digits]]
-[[cpp_float][1.45093 (0.253675s)][1.83306 (0.419569s)][2.3644 (1.64187s)]]
+[[cpp_dec_float][1.45093 (0.253675s)][1.83306 (0.419569s)][2.3644 (1.64187s)]]
[[gmp_float][[*1] (0.174836s)][[*1] (0.22889s)][[*1] (0.694411s)]]
[[mpfr_float][1.16731 (0.204088s)][1.13211 (0.259127s)][1.02031 (0.708513s)]]
]
[table Operator str
[[Backend][50 Decimal Digits][100 Decimal Digits][500 Decimal Digits]]
-[[cpp_float][1.4585 (0.0188303s)][1.55515 (0.03172s)][[*1] (0.131962s)]]
+[[cpp_dec_float][1.4585 (0.0188303s)][1.55515 (0.03172s)][[*1] (0.131962s)]]
[[gmp_float][[*1] (0.0129107s)][[*1] (0.0203967s)][1.04632 (0.138075s)]]
[[mpfr_float][2.19015 (0.0282764s)][1.84679 (0.0376683s)][1.20295 (0.158743s)]]
]

Modified: sandbox/big_number/libs/multiprecision/example/cpp_float_snips.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/example/cpp_float_snips.cpp (original)
+++ sandbox/big_number/libs/multiprecision/example/cpp_float_snips.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -3,13 +3,13 @@
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_

-#include <boost/multiprecision/cpp_float.hpp>
+#include <boost/multiprecision/cpp_dec_float.hpp>
#include <iostream>

void t1()
{
//[cpp_float_eg
- //=#include <boost/multiprecision/cpp_float.hpp>
+ //=#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

Modified: sandbox/big_number/libs/multiprecision/performance/Jamfile.v2
==============================================================================
--- sandbox/big_number/libs/multiprecision/performance/Jamfile.v2 (original)
+++ sandbox/big_number/libs/multiprecision/performance/Jamfile.v2 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -49,7 +49,7 @@
 [ check-target-builds ../config//has_gmp : <define>TEST_MPF <define>TEST_MPZ <source>gmp : ]
 [ check-target-builds ../config//has_mpfr : <define>TEST_MPFR <source>mpfr : ]
 [ check-target-builds ../config//has_tommath : <define>TEST_TOMMATH <source>$(TOMMATH) : ]
- <define>TEST_CPP_FLOAT
+ <define>TEST_CPP_DEC_FLOAT
 <define>TEST_FIXED_INT
 ;

@@ -57,7 +57,7 @@
 : release
 [ check-target-builds ../config//has_gmp : <define>TEST_MPF <define>TEST_MPZ <source>gmp : ]
 [ check-target-builds ../config//has_mpfr : <define>TEST_MPFR <source>mpfr : ]
- <define>TEST_CPP_FLOAT
+ <define>TEST_CPP_DEC_FLOAT
 <toolset>msvc:<cxxflags>-bigobj
 ;

@@ -75,7 +75,7 @@

obj obj_linpack_benchmark_cpp_float : linpack-benchmark.cpp
 : release
- <define>TEST_CPP_FLOAT
+ <define>TEST_CPP_DEC_FLOAT
 ;

obj obj_linpack_benchmark_double : linpack-benchmark.cpp
@@ -98,7 +98,7 @@

exe linpack_benchmark_cpp_float : obj_linpack_benchmark_cpp_float f2c
 : release
- <define>TEST_CPP_FLOAT
+ <define>TEST_CPP_DEC_FLOAT
 ;

exe linpack_benchmark_double : obj_linpack_benchmark_double f2c

Modified: sandbox/big_number/libs/multiprecision/performance/linpack-benchmark.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/performance/linpack-benchmark.cpp (original)
+++ sandbox/big_number/libs/multiprecision/performance/linpack-benchmark.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -25,8 +25,8 @@
#elif defined(TEST_MPFRXX)
#include <gmpfrxx.h>
typedef mpfr_class real_type;
-#elif defined(TEST_CPP_FLOAT)
-#include <boost/multiprecision/cpp_float.hpp>
+#elif defined(TEST_CPP_DEC_FLOAT)
+#include <boost/multiprecision/cpp_dec_float.hpp>
typedef boost::multiprecision::cpp_float_50 real_type;
#elif defined(TEST_MPFR_50)
#include <boost/multiprecision/mpfr.hpp>
@@ -102,8 +102,8 @@
#elif defined(TEST_MPFRXX)
 std::cout << "Testing mpfr_class at 50 decimal degits" << std::endl;
 mpfr_set_default_prec(((50 + 1) * 1000L) / 301L);
-#elif defined(TEST_CPP_FLOAT)
- std::cout << "Testing mp_number<cpp_float<50> >" << std::endl;
+#elif defined(TEST_CPP_DEC_FLOAT)
+ std::cout << "Testing mp_number<cpp_dec_float<50> >" << std::endl;
#else
 std::cout << "Testing double" << std::endl;
#endif
@@ -911,7 +911,7 @@
{
#if defined(TEST_MPF_100) || defined(TEST_MPFR_100) || defined(TEST_GMPXX) || defined(TEST_MPFRXX)
 return std::ldexp(1.0, 1 - ((100 + 1) * 1000L) / 301L);
-#elif defined(TEST_CPP_FLOAT_BN)
+#elif defined(TEST_CPP_DEC_FLOAT_BN)
 return std::pow(10.0, 1-std::numeric_limits<efx::cpp_float_50>::digits10);
#else
 return CAST_TO_RT(std::numeric_limits<real_type>::epsilon());

Modified: sandbox/big_number/libs/multiprecision/performance/performance_test.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/performance/performance_test.cpp (original)
+++ sandbox/big_number/libs/multiprecision/performance/performance_test.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -10,14 +10,14 @@
#endif

#if !defined(TEST_MPF) && !defined(TEST_MPZ) && \
- !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPQ) \
+ !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPQ) \
 && !defined(TEST_TOMMATH) && !defined(TEST_TOMMATH_BOOST_RATIONAL) && !defined(TEST_MPZ_BOOST_RATIONAL)\
 && !defined(TEST_FIXED_INT)
# define TEST_MPF
# define TEST_MPZ
# define TEST_MPQ
# define TEST_MPFR
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT
# define TEST_MPQ
# define TEST_TOMMATH
# define TEST_FIXED_INT
@@ -35,8 +35,8 @@
#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/rational_adapter.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#if defined(TEST_MPFR)
#include <boost/multiprecision/mpfr.hpp>
@@ -608,10 +608,10 @@
 test<boost::multiprecision::mp_int512_t>("fixed_int", 512);
 test<boost::multiprecision::mp_number<boost::multiprecision::fixed_int<1024, true> > >("fixed_int", 1024);
#endif
-#ifdef TEST_CPP_FLOAT
- test<boost::multiprecision::cpp_float_50>("cpp_float", 50);
- test<boost::multiprecision::cpp_float_100>("cpp_float", 100);
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_float<500> > >("cpp_float", 500);
+#ifdef TEST_CPP_DEC_FLOAT
+ test<boost::multiprecision::cpp_float_50>("cpp_dec_float", 50);
+ test<boost::multiprecision::cpp_float_100>("cpp_dec_float", 100);
+ test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<500> > >("cpp_dec_float", 500);
#endif
#ifdef TEST_MPFR
 test<boost::multiprecision::mpfr_float_50>("mpfr_float", 50);

Modified: sandbox/big_number/libs/multiprecision/performance/sf_performance.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/performance/sf_performance.cpp (original)
+++ sandbox/big_number/libs/multiprecision/performance/sf_performance.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -10,7 +10,7 @@
# define TEST_MPFR
# define TEST_MPF
# define TEST_MPF
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT
# define TEST_MPFR_CLASS
#endif

@@ -26,8 +26,8 @@
#ifdef TEST_MPF
#include <boost/multiprecision/gmp.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#include <boost/math/special_functions/bessel.hpp>
#include <boost/math/tools/rational.hpp>
@@ -231,7 +231,7 @@
 std::cout << "Total allocations for mpf_float_50 = " << allocation_count << std::endl;
 allocation_count = 0;
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 c.reset();
 test_bessel<boost::multiprecision::cpp_float_50>();
 time = c.elapsed();
@@ -280,7 +280,7 @@
 std::cout << "Total allocations for mpf_float_100 = " << allocation_count << std::endl;
 allocation_count = 0;
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 c.reset();
 test_bessel<boost::multiprecision::cpp_float_100>();
 time = c.elapsed();
@@ -332,7 +332,7 @@
 std::cout << "Total allocations for mpf_float_50 = " << allocation_count << std::endl;
 allocation_count = 0;
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 c.reset();
 test_polynomial<boost::multiprecision::cpp_float_50>();
 time = c.elapsed();
@@ -381,7 +381,7 @@
 std::cout << "Total allocations for mpf_float_100 = " << allocation_count << std::endl;
 allocation_count = 0;
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 c.reset();
 test_polynomial<boost::multiprecision::cpp_float_100>();
 time = c.elapsed();
@@ -432,7 +432,7 @@
 std::cout << "Total allocations for mpf_float_50 = " << allocation_count << std::endl;
 allocation_count = 0;
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 c.reset();
 test_nct<boost::multiprecision::cpp_float_50>();
 time = c.elapsed();
@@ -481,7 +481,7 @@
 std::cout << "Total allocations for mpf_float_100 = " << allocation_count << std::endl;
 allocation_count = 0;
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 c.reset();
 test_nct<boost::multiprecision::cpp_float_100>();
 time = c.elapsed();

Modified: sandbox/big_number/libs/multiprecision/test/Jamfile.v2
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/Jamfile.v2 (original)
+++ sandbox/big_number/libs/multiprecision/test/Jamfile.v2 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -53,7 +53,7 @@
 : # command line
 : # input files
 : # requirements
- <define>TEST_CPP_FLOAT
+ <define>TEST_CPP_DEC_FLOAT
 : test_arithmetic_cpp_float ;

run test_arithmetic.cpp gmp
@@ -201,7 +201,7 @@
 : # command line
 : # input files
 : # requirements
- <define>TEST_CPP_FLOAT
+ <define>TEST_CPP_DEC_FLOAT
 [ check-target-builds ../config//has_mpfr : : <build>no ]
 : test_numeric_limits_cpp_float ;

@@ -313,49 +313,49 @@
 : # command line
 : # input files
 : # requirements
- <define>TEST_CPP_FLOAT
+ <define>TEST_CPP_DEC_FLOAT
 : test_exp_cpp_float ;

run test_log.cpp
 : # command line
 : # input files
 : # requirements
- <define>TEST_CPP_FLOAT
+ <define>TEST_CPP_DEC_FLOAT
 : test_log_cpp_float ;

run test_pow.cpp
 : # command line
 : # input files
 : # requirements
- <define>TEST_CPP_FLOAT
+ <define>TEST_CPP_DEC_FLOAT
 : test_pow_cpp_float ;

run test_sinh.cpp
 : # command line
 : # input files
 : # requirements
- <define>TEST_CPP_FLOAT
+ <define>TEST_CPP_DEC_FLOAT
 : test_sinh_cpp_float ;

run test_cosh.cpp
 : # command line
 : # input files
 : # requirements
- <define>TEST_CPP_FLOAT
+ <define>TEST_CPP_DEC_FLOAT
 : test_cosh_cpp_float ;

run test_tanh.cpp
 : # command line
 : # input files
 : # requirements
- <define>TEST_CPP_FLOAT
+ <define>TEST_CPP_DEC_FLOAT
 : test_tanh_cpp_float ;

run test_sin.cpp
 : # command line
 : # input files
 : # requirements
- <define>TEST_CPP_FLOAT
+ <define>TEST_CPP_DEC_FLOAT
 : test_sin_cpp_float ;

run test_sin.cpp gmp
@@ -378,7 +378,7 @@
 : # command line
 : # input files
 : # requirements
- <define>TEST_CPP_FLOAT
+ <define>TEST_CPP_DEC_FLOAT
 : test_cos_cpp_float ;

run test_cos.cpp gmp
@@ -401,7 +401,7 @@
 : # command line
 : # input files
 : # requirements
- <define>TEST_CPP_FLOAT
+ <define>TEST_CPP_DEC_FLOAT
 : test_asin_cpp_float ;

run test_asin.cpp gmp
@@ -424,7 +424,7 @@
 : # command line
 : # input files
 : # requirements
- <define>TEST_CPP_FLOAT
+ <define>TEST_CPP_DEC_FLOAT
 : test_acos_cpp_float ;

run test_acos.cpp gmp
@@ -455,7 +455,7 @@
 : # command line
 : # input files
 : # requirements
- <define>TEST_CPP_FLOAT
+ <define>TEST_CPP_DEC_FLOAT
 : test_atan_cpp_float ;

run test_atan.cpp mpfr
@@ -505,7 +505,7 @@
 : # command line
 : # input files
 : # requirements
- <define>TEST_CPP_FLOAT
+ <define>TEST_CPP_DEC_FLOAT
 [ check-target-builds ../config//has_mpfr : : <build>no ]
 : test_round_cpp_float ;

@@ -536,7 +536,7 @@
 : # command line
 : # input files
 : # requirements
- <define>TEST_CPP_FLOAT
+ <define>TEST_CPP_DEC_FLOAT
 : test_fpclassify_cpp_float ;

@@ -546,7 +546,7 @@
 : # command line
 : # input files
 : # requirements
- <define>TEST_CPP_FLOAT
+ <define>TEST_CPP_DEC_FLOAT
 : test_float_io_cpp_float ;

run test_float_io.cpp gmp
@@ -671,7 +671,7 @@
 : # command line
 : # input files
 : # requirements
- <define>TEST_CPP_FLOAT
+ <define>TEST_CPP_DEC_FLOAT
 <define>BOOST_ALL_NO_LIB
 <optimization>speed
 <toolset>msvc:<cxxflags>-bigobj
@@ -734,7 +734,7 @@
 : # command line
 : # input files
 : # requirements
- <define>TEST_CPP_FLOAT
+ <define>TEST_CPP_DEC_FLOAT
 : mp_number_concept_check_cpp_float ;

 run mp_number_concept_check.cpp

Modified: sandbox/big_number/libs/multiprecision/test/math/log1p_expm1_test.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/log1p_expm1_test.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/log1p_expm1_test.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -14,10 +14,10 @@

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -37,8 +37,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#include <boost/test/test_exec_monitor.hpp>
@@ -137,10 +137,10 @@
 test(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/powm1_sqrtp1m1_test.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/powm1_sqrtp1m1_test.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/powm1_sqrtp1m1_test.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -14,10 +14,10 @@

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -37,8 +37,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#include <boost/test/test_exec_monitor.hpp>
@@ -129,10 +129,10 @@
 test_powm1_sqrtp1m1(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_powm1_sqrtp1m1(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_powm1_sqrtp1m1(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_powm1_sqrtp1m1(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_powm1_sqrtp1m1(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_powm1_sqrtp1m1(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_powm1_sqrtp1m1(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_powm1_sqrtp1m1(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_bessel_i.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_bessel_i.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_bessel_i.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -14,10 +14,10 @@

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -37,8 +37,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -96,10 +96,10 @@
 test_bessel(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_bessel(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_bessel(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_bessel(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_bessel(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_bessel(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_bessel(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_bessel(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_bessel_j.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_bessel_j.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_bessel_j.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -14,10 +14,10 @@

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -37,8 +37,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -118,10 +118,10 @@
 test_bessel(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_bessel(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_bessel(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_bessel(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_bessel(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_bessel(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_bessel(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_bessel(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_bessel_k.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_bessel_k.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_bessel_k.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -15,10 +15,10 @@
#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
#define BOOST_MATH_SMALL_CONSTANT(x) x

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -38,8 +38,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -112,10 +112,10 @@
 test_bessel(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_bessel(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_bessel(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_bessel(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_bessel(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_bessel(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_bessel(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_bessel(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_bessel_y.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_bessel_y.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_bessel_y.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -14,10 +14,10 @@

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -37,8 +37,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -124,10 +124,10 @@
 test_bessel(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_bessel(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_bessel(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_bessel(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_bessel(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_bessel(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_bessel(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_bessel(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_beta.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_beta.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_beta.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -14,10 +14,10 @@

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -37,8 +37,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -117,10 +117,10 @@
 test_beta(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_beta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_beta(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_beta(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_beta(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_beta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_beta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_beta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_binomial_coeff.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_binomial_coeff.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_binomial_coeff.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -14,10 +14,10 @@

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -37,8 +37,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -103,10 +103,10 @@
 test_binomial(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_binomial(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_binomial(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_binomial(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_binomial(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_binomial(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_binomial(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_binomial(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_carlson.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_carlson.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_carlson.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -9,10 +9,10 @@

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -32,8 +32,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -95,10 +95,10 @@
 test_spots(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_spots(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_spots(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_spots(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_spots(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_spots(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_spots(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_spots(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_cbrt.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_cbrt.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_cbrt.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -9,10 +9,10 @@

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -32,8 +32,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -84,10 +84,10 @@
 test_cbrt(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_cbrt(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_cbrt(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_cbrt(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_cbrt(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_cbrt(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_cbrt(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_cbrt(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_digamma.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_digamma.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_digamma.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -9,10 +9,10 @@

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -32,8 +32,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -91,10 +91,10 @@
 test_digamma(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_digamma(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_digamma(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_digamma(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_digamma(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_digamma(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_digamma(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_digamma(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_ellint_1.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_ellint_1.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_ellint_1.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -9,10 +9,10 @@

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -32,8 +32,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -84,10 +84,10 @@
 test_spots(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_spots(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_spots(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_spots(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_spots(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_spots(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_spots(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_spots(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_ellint_2.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_ellint_2.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_ellint_2.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -9,10 +9,10 @@

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -32,8 +32,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -84,10 +84,10 @@
 test_spots(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_spots(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_spots(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_spots(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_spots(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_spots(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_spots(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_spots(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_ellint_3.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_ellint_3.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_ellint_3.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -9,10 +9,10 @@

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -32,8 +32,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -98,10 +98,10 @@
 test_spots(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_spots(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_spots(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_spots(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_spots(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_spots(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_spots(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_spots(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_erf.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_erf.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_erf.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -9,10 +9,10 @@

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -32,8 +32,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -105,10 +105,10 @@
 test_erf(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_erf(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_erf(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_erf(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_erf(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_erf(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_erf(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_erf(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_expint.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_expint.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_expint.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -9,10 +9,10 @@

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -32,8 +32,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -105,10 +105,10 @@
 test_expint(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_expint(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_expint(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_expint(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_expint(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_expint(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_expint(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_expint(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_gamma.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_gamma.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_gamma.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -9,10 +9,10 @@

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -32,8 +32,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -119,10 +119,10 @@
 test_gamma(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_gamma(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_gamma(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_gamma(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_gamma(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_gamma(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_gamma(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_gamma(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_hermite.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_hermite.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_hermite.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -9,10 +9,10 @@

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -32,8 +32,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -84,10 +84,10 @@
 test_hermite(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_hermite(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_hermite(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_hermite(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_hermite(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_hermite(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_hermite(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_hermite(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_ibeta.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_ibeta.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_ibeta.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -10,10 +10,10 @@
#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
#define BOOST_MATH_SMALL_CONSTANT(x) x

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -33,8 +33,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -108,10 +108,10 @@
 test_beta(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_beta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_beta(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_beta(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_beta(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_beta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_beta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_beta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_ibeta_2.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_ibeta_2.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_ibeta_2.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -10,10 +10,10 @@
#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
#define BOOST_MATH_SMALL_CONSTANT(x) x

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -33,8 +33,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -115,10 +115,10 @@
 test_beta(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_beta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_beta(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_beta(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_beta(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_beta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_beta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_beta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_ibeta_3.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_ibeta_3.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_ibeta_3.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -10,10 +10,10 @@
#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
#define BOOST_MATH_SMALL_CONSTANT(x) x

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -33,8 +33,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -101,10 +101,10 @@
 test_beta(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_beta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_beta(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_beta(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_beta(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_beta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_beta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_beta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_ibeta_4.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_ibeta_4.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_ibeta_4.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -10,10 +10,10 @@
#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
#define BOOST_MATH_SMALL_CONSTANT(x) x

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -33,8 +33,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -108,10 +108,10 @@
 test_beta(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_beta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_beta(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_beta(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_beta(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_beta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_beta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_beta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_ibeta_inv_1.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_ibeta_inv_1.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_ibeta_inv_1.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -10,10 +10,10 @@
#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
#define BOOST_MATH_SMALL_CONSTANT(x) x

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -33,8 +33,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -87,10 +87,10 @@
 test_beta(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_beta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_beta(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_beta(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_beta(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_beta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_beta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_beta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_ibeta_inv_ab_4.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_ibeta_inv_ab_4.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_ibeta_inv_ab_4.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -9,10 +9,10 @@

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -32,8 +32,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -87,10 +87,10 @@
 test_beta(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_beta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_beta(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_beta(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_beta(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_beta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_beta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_beta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_igamma.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_igamma.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_igamma.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -10,10 +10,10 @@
#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
#define BOOST_MATH_SMALL_CONSTANT(x) x

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -33,8 +33,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -91,10 +91,10 @@
 test_gamma(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_gamma(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_gamma(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_gamma(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_gamma(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_gamma(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_gamma(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_gamma(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_igamma_inv.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_igamma_inv.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_igamma_inv.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -10,10 +10,10 @@
#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
#define BOOST_MATH_SMALL_CONSTANT(x) x

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -33,8 +33,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -99,10 +99,10 @@
 test_gamma(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_gamma(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_gamma(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_gamma(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_gamma(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_gamma(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_gamma(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_gamma(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_igamma_inva.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_igamma_inva.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_igamma_inva.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -10,10 +10,10 @@
#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
#define BOOST_MATH_SMALL_CONSTANT(x) x

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -33,8 +33,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -85,10 +85,10 @@
 test_gamma(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_gamma(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_gamma(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_gamma(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_gamma(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_gamma(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_gamma(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_gamma(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_laguerre.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_laguerre.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_laguerre.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -9,10 +9,10 @@

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -32,8 +32,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -84,10 +84,10 @@
 test_laguerre(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_laguerre(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_laguerre(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_laguerre(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_laguerre(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_laguerre(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_laguerre(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_laguerre(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_legendre.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_legendre.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_legendre.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -9,10 +9,10 @@

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -32,8 +32,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -84,10 +84,10 @@
 test_legendre_p(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_legendre_p(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_legendre_p(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_legendre_p(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_legendre_p(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_legendre_p(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_legendre_p(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_legendre_p(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_tgamma_ratio.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_tgamma_ratio.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_tgamma_ratio.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -9,10 +9,10 @@

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -32,8 +32,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -91,10 +91,10 @@
 test_tgamma_ratio(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_tgamma_ratio(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_tgamma_ratio(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_tgamma_ratio(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_tgamma_ratio(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_tgamma_ratio(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_tgamma_ratio(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_tgamma_ratio(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_zeta.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_zeta.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_zeta.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -9,10 +9,10 @@

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -32,8 +32,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#define SC_(x) BOOST_STRINGIZE(x)
@@ -91,10 +91,10 @@
 test_zeta(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
 test_zeta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
#endif
-#ifdef TEST_CPP_FLOAT
- test_zeta(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
- test_zeta(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
- test_zeta(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
+#ifdef TEST_CPP_DEC_FLOAT
+ test_zeta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
+ test_zeta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
+ test_zeta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/mp_number_concept_check.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/mp_number_concept_check.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/mp_number_concept_check.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -21,7 +21,7 @@
#endif

#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) \
- && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)\
+ && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)\
 && !defined(TEST_MPFR_6) && !defined(TEST_MPFR_15) && !defined(TEST_MPFR_17) && !defined(TEST_MPFR_30)
# define TEST_MPF_50
# define TEST_BACKEND
@@ -31,7 +31,7 @@
# define TEST_MPFR_15
# define TEST_MPFR_17
# define TEST_MPFR_30
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -48,8 +48,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#if defined(TEST_MPFR_50) || defined(TEST_MPFR_6) || defined(TEST_MPFR_15) || defined(TEST_MPFR_17) || defined(TEST_MPFR_30)
#include <boost/multiprecision/mpfr.hpp>
@@ -81,7 +81,7 @@
#ifdef TEST_MPFR_30
 instantiate(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<30> >());
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 instantiate(boost::multiprecision::cpp_float_50());
#endif
}
@@ -112,7 +112,7 @@
#ifdef TEST_MPFR_50
 BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mpfr_float_50>));
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::cpp_float_50>));
#endif

Modified: sandbox/big_number/libs/multiprecision/test/test_acos.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_acos.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_acos.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -16,11 +16,11 @@
#include <boost/array.hpp>
#include "test.hpp"

-#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
# define TEST_MPF_50
//# define TEST_MPF
# define TEST_BACKEND
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -40,8 +40,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

template <class T>
@@ -99,7 +99,7 @@
 test<boost::multiprecision::mpfr_float_50>();
 test<boost::multiprecision::mpfr_float_100>();
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 test<boost::multiprecision::cpp_float_50>();
 test<boost::multiprecision::cpp_float_100>();
#endif

Modified: sandbox/big_number/libs/multiprecision/test/test_arithmetic.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_arithmetic.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_arithmetic.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -12,7 +12,7 @@
#include <boost/math/common_factor_rt.hpp>

#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && \
- !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ) \
+ !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ) \
 && !defined(TEST_TOMMATH) && !defined(TEST_TOMMATH_BOOST_RATIONAL) && !defined(TEST_MPZ_BOOST_RATIONAL)\
 && !defined(TEST_FIXED_INT1) && !defined(TEST_FIXED_INT2)
# define TEST_MPF_50
@@ -21,7 +21,7 @@
# define TEST_MPZ
# define TEST_MPFR
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT
# define TEST_MPQ
# define TEST_TOMMATH
# define TEST_FIXED_INT1
@@ -43,8 +43,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#if defined(TEST_MPFR) || defined(TEST_MPFR_50)
#include <boost/multiprecision/mpfr.hpp>
@@ -1002,7 +1002,7 @@
#ifdef TEST_MPQ
 test<boost::multiprecision::mpq_rational>();
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 test<boost::multiprecision::cpp_float_50>();
#endif
#ifdef TEST_MPFR

Modified: sandbox/big_number/libs/multiprecision/test/test_asin.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_asin.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_asin.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -16,11 +16,11 @@
#include <boost/array.hpp>
#include "test.hpp"

-#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
# define TEST_MPF_50
//# define TEST_MPF
# define TEST_BACKEND
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -40,8 +40,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

template <class T>
@@ -95,7 +95,7 @@
 test<boost::multiprecision::mpfr_float_50>();
 test<boost::multiprecision::mpfr_float_100>();
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 test<boost::multiprecision::cpp_float_50>();
 test<boost::multiprecision::cpp_float_100>();
#endif

Modified: sandbox/big_number/libs/multiprecision/test/test_atan.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_atan.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_atan.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -16,11 +16,11 @@
#include <boost/array.hpp>
#include "test.hpp"

-#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
# define TEST_MPF_50
//# define TEST_MPF
# define TEST_BACKEND
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -40,8 +40,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

template <class T>
@@ -241,7 +241,7 @@
 test<boost::multiprecision::mpfr_float_50>();
 test<boost::multiprecision::mpfr_float_100>();
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 test<boost::multiprecision::cpp_float_50>();
 test<boost::multiprecision::cpp_float_100>();
#endif

Modified: sandbox/big_number/libs/multiprecision/test/test_cos.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_cos.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_cos.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -16,11 +16,11 @@
#include <boost/array.hpp>
#include "test.hpp"

-#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
# define TEST_MPF_50
//# define TEST_MPF
# define TEST_BACKEND
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -40,8 +40,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

template <class T>
@@ -295,7 +295,7 @@
 test<boost::multiprecision::mpfr_float_50>();
 test<boost::multiprecision::mpfr_float_100>();
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 test<boost::multiprecision::cpp_float_50>();
 test<boost::multiprecision::cpp_float_100>();
#endif

Modified: sandbox/big_number/libs/multiprecision/test/test_cosh.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_cosh.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_cosh.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -16,11 +16,11 @@
#include <boost/array.hpp>
#include "test.hpp"

-#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
# define TEST_MPF_50
//# define TEST_MPF
# define TEST_BACKEND
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -40,8 +40,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

template <class T>
@@ -137,7 +137,7 @@
 test<boost::multiprecision::mpfr_float_50>();
 test<boost::multiprecision::mpfr_float_100>();
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 test<boost::multiprecision::cpp_float_50>();
 test<boost::multiprecision::cpp_float_100>();
#endif

Modified: sandbox/big_number/libs/multiprecision/test/test_exp.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_exp.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_exp.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -16,11 +16,11 @@
#include <boost/array.hpp>
#include "test.hpp"

-#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
# define TEST_MPF_50
//# define TEST_MPF
# define TEST_BACKEND
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -40,8 +40,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

template <class T>
@@ -177,7 +177,7 @@
 test<boost::multiprecision::mpfr_float_50>();
 test<boost::multiprecision::mpfr_float_100>();
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 test<boost::multiprecision::cpp_float_50>();
 test<boost::multiprecision::cpp_float_100>();
#endif

Modified: sandbox/big_number/libs/multiprecision/test/test_float_io.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_float_io.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_float_io.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -9,9 +9,9 @@
# define _SCL_SECURE_NO_WARNINGS
#endif

-#if !defined(TEST_MPF_50) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
+#if !defined(TEST_MPF_50) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
# define TEST_MPF_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT
# define TEST_MPFR_50

#ifdef _MSC_VER
@@ -29,8 +29,8 @@
#if defined(TEST_MPFR_50)
#include <boost/multiprecision/mpfr.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#include <boost/random/mersenne_twister.hpp>
@@ -256,12 +256,12 @@
 test_round_trip<boost::multiprecision::mpfr_float_50>();
 test_round_trip<boost::multiprecision::mpfr_float_100>();
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 test<boost::multiprecision::cpp_float_50>();
 test<boost::multiprecision::cpp_float_100>();

 /*
- // cpp_float has extra guard digits that messes this up:
+ // cpp_dec_float has extra guard digits that messes this up:
 test_round_trip<boost::multiprecision::cpp_float_50>();
 test_round_trip<boost::multiprecision::cpp_float_100>();
 */

Modified: sandbox/big_number/libs/multiprecision/test/test_fpclassify.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_fpclassify.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_fpclassify.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -14,11 +14,11 @@
#include <boost/math/special_functions/fpclassify.hpp>
#include "test.hpp"

-#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
# define TEST_MPF_50
# define TEST_MPFR_50
# define TEST_BACKEND
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -38,8 +38,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#ifdef _MSC_VER
@@ -309,7 +309,7 @@
 test<boost::multiprecision::mpfr_float_50>();
 test<boost::multiprecision::mpfr_float_100>();
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 test<boost::multiprecision::cpp_float_50>();
 test<boost::multiprecision::cpp_float_100>();
#endif

Modified: sandbox/big_number/libs/multiprecision/test/test_log.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_log.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_log.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -16,11 +16,11 @@
#include <boost/array.hpp>
#include "test.hpp"

-#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
# define TEST_MPF_50
//# define TEST_MPF
# define TEST_BACKEND
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -40,8 +40,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

template <class T>
@@ -205,7 +205,7 @@
 test<boost::multiprecision::mpfr_float_50>();
 test<boost::multiprecision::mpfr_float_100>();
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 test<boost::multiprecision::cpp_float_50>();
 test<boost::multiprecision::cpp_float_100>();
#endif

Modified: sandbox/big_number/libs/multiprecision/test/test_numeric_limits.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_numeric_limits.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_numeric_limits.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -9,14 +9,14 @@

#include "test.hpp"

-#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ) && !defined(TEST_TOMMATH)
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ) && !defined(TEST_TOMMATH)
# define TEST_MPF_50
# define TEST_MPF
# define TEST_BACKEND
# define TEST_MPZ
# define TEST_MPFR
# define TEST_MPFR_50
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT
# define TEST_MPQ
# define TEST_TOMMATH

@@ -35,8 +35,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#if defined(TEST_MPFR) || defined(TEST_MPFR_50)
#include <boost/multiprecision/mpfr.hpp>
@@ -60,6 +60,54 @@
 BOOST_CHECK(boost::math::isnormal(log(maxv)));
 BOOST_CHECK(boost::math::isnormal(sqrt(minv)));
 BOOST_CHECK(boost::math::isnormal(sqrt(maxv)));
+
+ if(std::numeric_limits<Number>::is_specialized)
+ {
+ if(std::numeric_limits<Number>::has_quiet_NaN)
+ {
+ BOOST_TEST((boost::math::isnan)(std::numeric_limits<Number>::quiet_NaN()));
+ BOOST_TEST(FP_NAN == (boost::math::fpclassify)(std::numeric_limits<Number>::quiet_NaN()));
+ BOOST_TEST(!(boost::math::isfinite)(std::numeric_limits<Number>::quiet_NaN()));
+ BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::quiet_NaN()));
+ BOOST_TEST(!(boost::math::isinf)(std::numeric_limits<Number>::quiet_NaN()));
+ }
+ if(std::numeric_limits<Number>::has_signaling_NaN)
+ {
+ BOOST_TEST((boost::math::isnan)(std::numeric_limits<Number>::signaling_NaN()));
+ BOOST_TEST(FP_NAN == (boost::math::fpclassify)(std::numeric_limits<Number>::signaling_NaN()));
+ BOOST_TEST(!(boost::math::isfinite)(std::numeric_limits<Number>::signaling_NaN()));
+ BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::signaling_NaN()));
+ BOOST_TEST(!(boost::math::isinf)(std::numeric_limits<Number>::signaling_NaN()));
+ }
+ if(std::numeric_limits<Number>::has_infinity)
+ {
+ BOOST_TEST((boost::math::isinf)(std::numeric_limits<Number>::infinity()));
+ BOOST_TEST(FP_INFINITE == (boost::math::fpclassify)(std::numeric_limits<Number>::infinity()));
+ BOOST_TEST(!(boost::math::isfinite)(std::numeric_limits<Number>::infinity()));
+ BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::infinity()));
+ BOOST_TEST(!(boost::math::isnan)(std::numeric_limits<Number>::infinity()));
+ }
+ if(std::numeric_limits<Number>::has_denorm)
+ {
+ BOOST_TEST(FP_SUBNORMAL == (boost::math::fpclassify)(std::numeric_limits<Number>::denorm_min()));
+ BOOST_TEST((boost::math::isfinite)(std::numeric_limits<Number>::denorm_min()));
+ BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::denorm_min()));
+ BOOST_TEST(!(boost::math::isinf)(std::numeric_limits<Number>::denorm_min()));
+ BOOST_TEST(!(boost::math::isnan)(std::numeric_limits<Number>::denorm_min()));
+ }
+ }
+ Number n = 0;
+ BOOST_TEST((boost::math::fpclassify)(n) == FP_ZERO);
+ BOOST_TEST((boost::math::isfinite)(n));
+ BOOST_TEST(!(boost::math::isnormal)(n));
+ BOOST_TEST(!(boost::math::isinf)(n));
+ BOOST_TEST(!(boost::math::isnan)(n));
+ n = 2;
+ BOOST_TEST((boost::math::fpclassify)(n) == FP_NORMAL);
+ BOOST_TEST((boost::math::isfinite)(n));
+ BOOST_TEST((boost::math::isnormal)(n));
+ BOOST_TEST(!(boost::math::isinf)(n));
+ BOOST_TEST(!(boost::math::isnan)(n));
}

template <class Number, class T>
@@ -112,54 +160,6 @@
 PRINT(tinyness_before);
 PRINT(round_style);

- if(std::numeric_limits<Number>::is_specialized)
- {
- if(std::numeric_limits<Number>::has_quiet_NaN)
- {
- BOOST_TEST((boost::math::isnan)(std::numeric_limits<Number>::quiet_NaN()));
- BOOST_TEST(FP_NAN == (boost::math::fpclassify)(std::numeric_limits<Number>::quiet_NaN()));
- BOOST_TEST(!(boost::math::isfinite)(std::numeric_limits<Number>::quiet_NaN()));
- BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::quiet_NaN()));
- BOOST_TEST(!(boost::math::isinf)(std::numeric_limits<Number>::quiet_NaN()));
- }
- if(std::numeric_limits<Number>::has_signaling_NaN)
- {
- BOOST_TEST((boost::math::isnan)(std::numeric_limits<Number>::signaling_NaN()));
- BOOST_TEST(FP_NAN == (boost::math::fpclassify)(std::numeric_limits<Number>::signaling_NaN()));
- BOOST_TEST(!(boost::math::isfinite)(std::numeric_limits<Number>::signaling_NaN()));
- BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::signaling_NaN()));
- BOOST_TEST(!(boost::math::isinf)(std::numeric_limits<Number>::signaling_NaN()));
- }
- if(std::numeric_limits<Number>::has_infinity)
- {
- BOOST_TEST((boost::math::isinf)(std::numeric_limits<Number>::infinity()));
- BOOST_TEST(FP_INFINITE == (boost::math::fpclassify)(std::numeric_limits<Number>::infinity()));
- BOOST_TEST(!(boost::math::isfinite)(std::numeric_limits<Number>::infinity()));
- BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::infinity()));
- BOOST_TEST(!(boost::math::isnan)(std::numeric_limits<Number>::infinity()));
- }
- if(std::numeric_limits<Number>::has_denorm)
- {
- BOOST_TEST(FP_SUBNORMAL == (boost::math::fpclassify)(std::numeric_limits<Number>::denorm_min()));
- BOOST_TEST((boost::math::isfinite)(std::numeric_limits<Number>::denorm_min()));
- BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::denorm_min()));
- BOOST_TEST(!(boost::math::isinf)(std::numeric_limits<Number>::denorm_min()));
- BOOST_TEST(!(boost::math::isnan)(std::numeric_limits<Number>::denorm_min()));
- }
- }
- Number n = 0;
- BOOST_TEST((boost::math::fpclassify)(n) == FP_ZERO);
- BOOST_TEST((boost::math::isfinite)(n));
- BOOST_TEST(!(boost::math::isnormal)(n));
- BOOST_TEST(!(boost::math::isinf)(n));
- BOOST_TEST(!(boost::math::isnan)(n));
- n = 2;
- BOOST_TEST((boost::math::fpclassify)(n) == FP_NORMAL);
- BOOST_TEST((boost::math::isfinite)(n));
- BOOST_TEST((boost::math::isnormal)(n));
- BOOST_TEST(!(boost::math::isinf)(n));
- BOOST_TEST(!(boost::math::isnan)(n));
-
 typedef typename boost::mpl::if_c<
 std::numeric_limits<Number>::is_specialized,
 typename boost::multiprecision::number_category<Number>::type,
@@ -194,7 +194,7 @@
#ifdef TEST_MPQ
 test<boost::multiprecision::mpq_rational>();
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 test<boost::multiprecision::cpp_float_50>();
 test<boost::multiprecision::cpp_float_100>();
#endif

Modified: sandbox/big_number/libs/multiprecision/test/test_pow.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_pow.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_pow.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -16,11 +16,11 @@
#include <boost/array.hpp>
#include "test.hpp"

-#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
# define TEST_MPF_50
//# define TEST_MPF
# define TEST_BACKEND
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT
# define TEST_MPFR_50

#ifdef _MSC_VER
@@ -41,8 +41,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

template <class T>
@@ -580,7 +580,7 @@
 test<boost::multiprecision::mpfr_float_50>();
 test<boost::multiprecision::mpfr_float_100>();
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 test<boost::multiprecision::cpp_float_50>();
 test<boost::multiprecision::cpp_float_100>();
#endif

Modified: sandbox/big_number/libs/multiprecision/test/test_round.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_round.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_round.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -15,11 +15,11 @@
#include <boost/random/mersenne_twister.hpp>
#include "test.hpp"

-#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
# define TEST_MPF_50
# define TEST_MPFR_50
# define TEST_BACKEND
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -39,8 +39,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

boost::mt19937 rng;
@@ -386,7 +386,7 @@
 test<boost::multiprecision::mpfr_float_50>();
 test<boost::multiprecision::mpfr_float_100>();
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 test<boost::multiprecision::cpp_float_50>();
 test<boost::multiprecision::cpp_float_100>();
#endif

Modified: sandbox/big_number/libs/multiprecision/test/test_sin.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_sin.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_sin.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -16,11 +16,11 @@
#include <boost/array.hpp>
#include "test.hpp"

-#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
# define TEST_MPF_50
//# define TEST_MPF
# define TEST_BACKEND
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -40,8 +40,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

template <class T>
@@ -289,7 +289,7 @@
 test<boost::multiprecision::mpfr_float_50>();
 test<boost::multiprecision::mpfr_float_100>();
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 test<boost::multiprecision::cpp_float_50>();
#endif
 return boost::report_errors();

Modified: sandbox/big_number/libs/multiprecision/test/test_sinh.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_sinh.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_sinh.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -16,11 +16,11 @@
#include <boost/array.hpp>
#include "test.hpp"

-#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
# define TEST_MPF_50
//# define TEST_MPF
# define TEST_BACKEND
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -40,8 +40,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

template <class T>
@@ -213,7 +213,7 @@
 test<boost::multiprecision::mpfr_float_50>();
 test<boost::multiprecision::mpfr_float_100>();
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 test<boost::multiprecision::cpp_float_50>();
 test<boost::multiprecision::cpp_float_100>();
#endif

Modified: sandbox/big_number/libs/multiprecision/test/test_sqrt.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_sqrt.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_sqrt.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -16,11 +16,11 @@
#include <boost/array.hpp>
#include "test.hpp"

-#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
# define TEST_MPF_50
//# define TEST_MPF
# define TEST_BACKEND
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -40,8 +40,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

template <class T>
@@ -183,7 +183,7 @@
 test<boost::multiprecision::mpfr_float_50>();
 test<boost::multiprecision::mpfr_float_100>();
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 test<boost::multiprecision::cpp_float_50>();
 test<boost::multiprecision::cpp_float_100>();
#endif

Modified: sandbox/big_number/libs/multiprecision/test/test_tanh.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_tanh.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_tanh.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -16,11 +16,11 @@
#include <boost/array.hpp>
#include "test.hpp"

-#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
# define TEST_MPF_50
//# define TEST_MPF
# define TEST_BACKEND
-# define TEST_CPP_FLOAT
+# define TEST_CPP_DEC_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
@@ -40,8 +40,8 @@
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
#endif
-#ifdef TEST_CPP_FLOAT
-#include <boost/multiprecision/cpp_float.hpp>
+#ifdef TEST_CPP_DEC_FLOAT
+#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

template <class T>
@@ -132,7 +132,7 @@
 test<boost::multiprecision::mpfr_float_50>();
 test<boost::multiprecision::mpfr_float_100>();
#endif
-#ifdef TEST_CPP_FLOAT
+#ifdef TEST_CPP_DEC_FLOAT
 test<boost::multiprecision::cpp_float_50>();
 test<boost::multiprecision::cpp_float_100>();
#endif

Modified: sandbox/big_number/libs/multiprecision/test/test_test.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_test.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_test.cpp 2012-02-15 08:09:45 EST (Wed, 15 Feb 2012)
@@ -8,7 +8,7 @@
#endif

#include "test.hpp"
-#include <boost/multiprecision/cpp_float.hpp>
+#include <boost/multiprecision/cpp_dec_float.hpp>

void proc_that_throws()
{

Next message: chris_at_[hidden]: "[Boost-commit] svn:boost r77033 - in trunk: boost/asio/detail libs/asio/doc"
Previous message: lorcaminiti_at_[hidden]: "[Boost-commit] svn:boost r77031 - trunk/libs/scope_exit/doc/html/scope_exit"

Date view	Thread view	Subject view	Author view

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