Changeset 77032


Ignore:
Timestamp:
Feb 15, 2012, 1:09:45 PM (6 years ago)
Author:
John Maddock
Message:

Big search and replace: change cpp_float to cpp_dec_float.
Also fix up some numeric_limits test failures.

Location:
sandbox/big_number
Files:
60 edited
1 moved

Legend:

Unmodified
Added
Removed
  • sandbox/big_number/boost/multiprecision/cpp_dec_float.hpp

    r76721 r77032  
    2727
    2828template <unsigned Digits10>
    29 class cpp_float
     29class cpp_dec_float
    3030{
    3131public:
     
    8282   // Special values constructor:
    8383   //
    84    cpp_float(t_fpclass c) :
     84   cpp_dec_float(t_fpclass c) :
    8585      data(),
    8686      exp      (static_cast<boost::int64_t>(0)),
     
    9696         initializer()
    9797         {
    98             cpp_float<Digits10>::nan();
    99             cpp_float<Digits10>::inf();
    100             (cpp_float<Digits10>::min)();
    101             (cpp_float<Digits10>::max)();
    102             cpp_float<Digits10>::zero();
    103             cpp_float<Digits10>::one();
    104             cpp_float<Digits10>::two();
    105             cpp_float<Digits10>::half();
    106             cpp_float<Digits10>::double_min();
    107             cpp_float<Digits10>::double_max();
    108             cpp_float<Digits10>::long_double_max();
    109             cpp_float<Digits10>::long_double_min();
    110             cpp_float<Digits10>::long_long_max();
    111             cpp_float<Digits10>::long_long_min();
    112             cpp_float<Digits10>::ulong_long_max();
    113             cpp_float<Digits10>::eps();
    114             cpp_float<Digits10>::pow2(0);
     98            cpp_dec_float<Digits10>::nan();
     99            cpp_dec_float<Digits10>::inf();
     100            (cpp_dec_float<Digits10>::min)();
     101            (cpp_dec_float<Digits10>::max)();
     102            cpp_dec_float<Digits10>::zero();
     103            cpp_dec_float<Digits10>::one();
     104            cpp_dec_float<Digits10>::two();
     105            cpp_dec_float<Digits10>::half();
     106            cpp_dec_float<Digits10>::double_min();
     107            cpp_dec_float<Digits10>::double_max();
     108            cpp_dec_float<Digits10>::long_double_max();
     109            cpp_dec_float<Digits10>::long_double_min();
     110            cpp_dec_float<Digits10>::long_long_max();
     111            cpp_dec_float<Digits10>::long_long_min();
     112            cpp_dec_float<Digits10>::ulong_long_max();
     113            cpp_dec_float<Digits10>::eps();
     114            cpp_dec_float<Digits10>::pow2(0);
    115115         }
    116116         void do_nothing(){}
     
    121121public:
    122122   // Constructors
    123    cpp_float() :
     123   cpp_dec_float() :
    124124      data(),
    125125      exp      (static_cast<boost::int64_t>(0)),
     
    128128      prec_elem(mp_elem_number) { }
    129129
    130    cpp_float(const char* s) :
     130   cpp_dec_float(const char* s) :
    131131      data(),
    132132      exp      (static_cast<boost::int64_t>(0)),
     
    139139
    140140   template<class I>
    141    cpp_float(I i, typename enable_if<is_unsigned<I> >::type* = 0) :
     141   cpp_dec_float(I i, typename enable_if<is_unsigned<I> >::type* = 0) :
    142142      data(),
    143143      exp      (static_cast<boost::int64_t>(0)),
     
    150150
    151151   template <class I>
    152    cpp_float(I i, typename enable_if<is_signed<I> >::type* = 0) :
     152   cpp_dec_float(I i, typename enable_if<is_signed<I> >::type* = 0) :
    153153      data(),
    154154      exp      (static_cast<boost::int64_t>(0)),
     
    166166      }
    167167
    168    cpp_float(const cpp_float& f) :
     168   cpp_dec_float(const cpp_dec_float& f) :
    169169      data     (f.data),
    170170      exp      (f.exp),
     
    174174
    175175   template <unsigned D>
    176    cpp_float(const cpp_float<D>& f) :
     176   cpp_dec_float(const cpp_dec_float<D>& f) :
    177177      exp      (f.exp),
    178178      neg      (f.neg),
     
    186186
    187187   template <class F>
    188    cpp_float(const F val, typename enable_if<is_floating_point<F> >::type* = 0):
     188   cpp_dec_float(const F val, typename enable_if<is_floating_point<F> >::type* = 0):
    189189      data(),
    190190      exp      (static_cast<boost::int64_t>(0)),
     
    196196   }
    197197
    198    cpp_float(const double val, long long exponent);
     198   cpp_dec_float(const double val, long long exponent);
    199199
    200200   // Specific special values.
    201    static const cpp_float& nan()
    202    {
    203       static const cpp_float val(mp_NaN);
     201   static const cpp_dec_float& nan()
     202   {
     203      static const cpp_dec_float val(mp_NaN);
    204204      init.do_nothing();
    205205      return val;
    206206   }
    207    static const cpp_float& inf()
    208    {
    209       static const cpp_float val(mp_inf);
     207   static const cpp_dec_float& inf()
     208   {
     209      static const cpp_dec_float val(mp_inf);
    210210      init.do_nothing();
    211211      return val;
    212212   }
    213    static const cpp_float& (max)()
     213   static const cpp_dec_float& (max)()
    214214   {
    215215      init.do_nothing();
     
    217217      static const std::string str_max =   std::string("9." + std::string(static_cast<std::size_t>(cpp_float_max_digits10), static_cast<char>('9')))
    218218         + std::string("e+" + boost::lexical_cast<std::string>(cpp_float_max_exp10));
    219       static cpp_float val_max;
     219      static cpp_dec_float val_max;
    220220      if(!init)
    221221      {
     
    226226   }
    227227
    228    static const cpp_float& (min)()
     228   static const cpp_dec_float& (min)()
    229229   {
    230230      init.do_nothing();
    231231      static bool init = false;
    232       static cpp_float val_min;
     232      static cpp_dec_float val_min;
    233233      if(!init)
    234234      {
     
    238238      return val_min;
    239239   }
    240    static const cpp_float& zero()
     240   static const cpp_dec_float& zero()
    241241   {
    242242      init.do_nothing();
    243       static cpp_float val(static_cast<unsigned long long>(0u));
     243      static cpp_dec_float val(static_cast<unsigned long long>(0u));
    244244      return val;
    245245   }
    246    static const cpp_float& one()
     246   static const cpp_dec_float& one()
    247247   {
    248248      init.do_nothing();
    249       static cpp_float val(static_cast<unsigned long long>(1u));
     249      static cpp_dec_float val(static_cast<unsigned long long>(1u));
    250250      return val;
    251251   }
    252    static const cpp_float& two()
     252   static const cpp_dec_float& two()
    253253   {
    254254      init.do_nothing();
    255       static cpp_float val(static_cast<unsigned long long>(2u));
     255      static cpp_dec_float val(static_cast<unsigned long long>(2u));
    256256      return val;
    257257   }
    258    static const cpp_float& half()
     258   static const cpp_dec_float& half()
    259259   {
    260260      init.do_nothing();
    261       static cpp_float val(0.5L);
     261      static cpp_dec_float val(0.5L);
    262262      return val;
    263263   }
    264    static const cpp_float& double_min()
     264   static const cpp_dec_float& double_min()
    265265   {
    266266      init.do_nothing();
    267       static cpp_float val(static_cast<long double>((std::numeric_limits<double>::min)()));
     267      static cpp_dec_float val(static_cast<long double>((std::numeric_limits<double>::min)()));
    268268      return val;
    269269   }
    270    static const cpp_float& double_max()
     270   static const cpp_dec_float& double_max()
    271271   {
    272272      init.do_nothing();
    273       static cpp_float val(static_cast<long double>((std::numeric_limits<double>::max)()));
     273      static cpp_dec_float val(static_cast<long double>((std::numeric_limits<double>::max)()));
    274274      return val;
    275275   }
    276    static const cpp_float& long_double_min()
     276   static const cpp_dec_float& long_double_min()
    277277   {
    278278      init.do_nothing();
    279       static cpp_float val((std::numeric_limits<long double>::min)());
     279      static cpp_dec_float val((std::numeric_limits<long double>::min)());
    280280      return val;
    281281   }
    282    static const cpp_float& long_double_max()
     282   static const cpp_dec_float& long_double_max()
    283283   {
    284284      init.do_nothing();
    285       static cpp_float val((std::numeric_limits<long double>::max)());
     285      static cpp_dec_float val((std::numeric_limits<long double>::max)());
    286286      return val;
    287287   }
    288    static const cpp_float& long_long_max()
     288   static const cpp_dec_float& long_long_max()
    289289   {
    290290      init.do_nothing();
    291       static cpp_float val((std::numeric_limits<long long>::max)());
     291      static cpp_dec_float val((std::numeric_limits<long long>::max)());
    292292      return val;
    293293   }
    294    static const cpp_float& long_long_min()
     294   static const cpp_dec_float& long_long_min()
    295295   {
    296296      init.do_nothing();
    297       static cpp_float val((std::numeric_limits<long long>::min)());
     297      static cpp_dec_float val((std::numeric_limits<long long>::min)());
    298298      return val;
    299299   }
    300    static const cpp_float& ulong_long_max()
     300   static const cpp_dec_float& ulong_long_max()
    301301   {
    302302      init.do_nothing();
    303       static cpp_float val((std::numeric_limits<unsigned long long>::max)());
     303      static cpp_dec_float val((std::numeric_limits<unsigned long long>::max)());
    304304      return val;
    305305   }
    306    static const cpp_float& eps()
     306   static const cpp_dec_float& eps()
    307307   {
    308308      init.do_nothing();
    309       static cpp_float val(1.0, 1 - (int)Digits10);
     309      static cpp_dec_float val(1.0, 1 - (int)Digits10);
    310310      return val;
    311311   }
    312312
    313313   // Basic operations.
    314    cpp_float& operator= (const cpp_float& v)
     314   cpp_dec_float& operator= (const cpp_dec_float& v)
    315315   {
    316316      data = v.data;
     
    322322   }
    323323   template <unsigned D>
    324    cpp_float& operator=(const cpp_float<D>& f)
     324   cpp_dec_float& operator=(const cpp_dec_float<D>& f)
    325325   {
    326326      exp = f.exp;
     
    331331      return *this;
    332332   }
    333    cpp_float& operator= (long long v)
     333   cpp_dec_float& operator= (long long v)
    334334   {
    335335      if(v < 0)
     
    342342      return *this;
    343343   }
    344    cpp_float& operator= (unsigned long long v)
     344   cpp_dec_float& operator= (unsigned long long v)
    345345   {
    346346      from_unsigned_long_long(v);
    347347      return *this;
    348348   }
    349    cpp_float& operator= (long double v);
    350    cpp_float& operator= (const char* v)
     349   cpp_dec_float& operator= (long double v);
     350   cpp_dec_float& operator= (const char* v)
    351351   {
    352352      rd_string(v);
     
    354354   }
    355355
    356    cpp_float& operator+=(const cpp_float& v);
    357    cpp_float& operator-=(const cpp_float& v);
    358    cpp_float& operator*=(const cpp_float& v);
    359    cpp_float& operator/=(const cpp_float& v);
     356   cpp_dec_float& operator+=(const cpp_dec_float& v);
     357   cpp_dec_float& operator-=(const cpp_dec_float& v);
     358   cpp_dec_float& operator*=(const cpp_dec_float& v);
     359   cpp_dec_float& operator/=(const cpp_dec_float& v);
    360360   
    361    cpp_float& add_unsigned_long_long(const unsigned long long n)
    362    {
    363       cpp_float t;
     361   cpp_dec_float& add_unsigned_long_long(const unsigned long long n)
     362   {
     363      cpp_dec_float t;
    364364      t.from_unsigned_long_long(n);
    365365      return *this += t;
    366366   }
    367    cpp_float& sub_unsigned_long_long(const unsigned long long n)
    368    {
    369       cpp_float t;
     367   cpp_dec_float& sub_unsigned_long_long(const unsigned long long n)
     368   {
     369      cpp_dec_float t;
    370370      t.from_unsigned_long_long(n);
    371371      return *this -= t;
    372372   }
    373    cpp_float& mul_unsigned_long_long(const unsigned long long n);
    374    cpp_float& div_unsigned_long_long(const unsigned long long n);
     373   cpp_dec_float& mul_unsigned_long_long(const unsigned long long n);
     374   cpp_dec_float& div_unsigned_long_long(const unsigned long long n);
    375375
    376376   // Elementary primitives.
    377    cpp_float& calculate_inv (void);
    378    cpp_float& calculate_sqrt(void);
     377   cpp_dec_float& calculate_inv (void);
     378   cpp_dec_float& calculate_sqrt(void);
    379379   void negate()
    380380   {
     
    397397
    398398   // Operators pre-increment and pre-decrement
    399    cpp_float& operator++(void)
     399   cpp_dec_float& operator++(void)
    400400   {
    401401      return *this += one();
    402402   }
    403    cpp_float& operator--(void)
     403   cpp_dec_float& operator--(void)
    404404   {
    405405      return *this -= one();
     
    408408   std::string str(boost::intmax_t digits, std::ios_base::fmtflags f)const;
    409409
    410    int compare(const cpp_float& v)const;
     410   int compare(const cpp_dec_float& v)const;
    411411   template <class V>
    412412   int compare(const V& v)const
    413413   {
    414       cpp_float<Digits10> t;
     414      cpp_dec_float<Digits10> t;
    415415      t = v;
    416416      return compare(t);
    417417   }
    418418
    419    void swap(cpp_float& v)
     419   void swap(cpp_dec_float& v)
    420420   {
    421421      data.swap(v.data);
     
    431431   unsigned long long extract_unsigned_long_long(void) const;
    432432   void               extract_parts             (double& mantissa, boost::int64_t& exponent) const;
    433    cpp_float           extract_integer_part      (void) const;
     433   cpp_dec_float           extract_integer_part      (void) const;
    434434   void precision(const boost::int32_t prec_digits)
    435435   {
     
    446446      }
    447447   }
    448    static cpp_float pow2(long long i);
     448   static cpp_dec_float pow2(long long i);
    449449   long long order()const
    450450   {
     
    501501private:
    502502   static bool data_elem_is_non_zero_predicate(const boost::uint32_t& d) { return (d != static_cast<boost::uint32_t>(0u)); }
    503    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)); }
     503   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)); }
    504504   static bool char_is_nonzero_predicate(const char& c) { return (c != static_cast<char>('0')); }
    505505
     
    515515
    516516   template <unsigned D>
    517    friend class cpp_float;
     517   friend class cpp_dec_float;
    518518
    519519};
    520520
    521521template <unsigned Digits10>
    522 typename cpp_float<Digits10>::initializer cpp_float<Digits10>::init;
    523 
    524 template <unsigned Digits10>
    525 const boost::int32_t cpp_float<Digits10>::mp_radix;
    526 template <unsigned Digits10>
    527 const boost::int32_t cpp_float<Digits10>::cpp_float_digits;
    528 template <unsigned Digits10>
    529 const boost::int32_t cpp_float<Digits10>::cpp_float_digits10_setting;
    530 template <unsigned Digits10>
    531 const boost::int32_t cpp_float<Digits10>::cpp_float_digits10_limit;
    532 template <unsigned Digits10>
    533 const boost::int32_t cpp_float<Digits10>::cpp_float_digits10;
    534 template <unsigned Digits10>
    535 const boost::int32_t cpp_float<Digits10>::cpp_float_digits10_extra;
    536 template <unsigned Digits10>
    537 const boost::int32_t cpp_float<Digits10>::cpp_float_max_digits10;
    538 template <unsigned Digits10>
    539 const boost::int64_t cpp_float<Digits10>::cpp_float_max_exp;
    540 template <unsigned Digits10>
    541 const boost::int64_t cpp_float<Digits10>::cpp_float_min_exp;
    542 template <unsigned Digits10>
    543 const boost::int64_t cpp_float<Digits10>::cpp_float_max_exp10;
    544 template <unsigned Digits10>
    545 const boost::int64_t cpp_float<Digits10>::cpp_float_min_exp10;
    546 template <unsigned Digits10>
    547 const boost::int32_t cpp_float<Digits10>::mp_elem_digits10;
    548 template <unsigned Digits10>
    549 const boost::int32_t cpp_float<Digits10>::cpp_float_digits10_num_base;
    550 template <unsigned Digits10>
    551 const boost::int32_t cpp_float<Digits10>::mp_elem_number;
    552 template <unsigned Digits10>
    553 const boost::int32_t cpp_float<Digits10>::mp_elem_mask;
    554 
    555 
    556 template <unsigned Digits10>
    557 cpp_float<Digits10>& cpp_float<Digits10>::operator+=(const cpp_float<Digits10>& v)
     522typename cpp_dec_float<Digits10>::initializer cpp_dec_float<Digits10>::init;
     523
     524template <unsigned Digits10>
     525const boost::int32_t cpp_dec_float<Digits10>::mp_radix;
     526template <unsigned Digits10>
     527const boost::int32_t cpp_dec_float<Digits10>::cpp_float_digits;
     528template <unsigned Digits10>
     529const boost::int32_t cpp_dec_float<Digits10>::cpp_float_digits10_setting;
     530template <unsigned Digits10>
     531const boost::int32_t cpp_dec_float<Digits10>::cpp_float_digits10_limit;
     532template <unsigned Digits10>
     533const boost::int32_t cpp_dec_float<Digits10>::cpp_float_digits10;
     534template <unsigned Digits10>
     535const boost::int32_t cpp_dec_float<Digits10>::cpp_float_digits10_extra;
     536template <unsigned Digits10>
     537const boost::int32_t cpp_dec_float<Digits10>::cpp_float_max_digits10;
     538template <unsigned Digits10>
     539const boost::int64_t cpp_dec_float<Digits10>::cpp_float_max_exp;
     540template <unsigned Digits10>
     541const boost::int64_t cpp_dec_float<Digits10>::cpp_float_min_exp;
     542template <unsigned Digits10>
     543const boost::int64_t cpp_dec_float<Digits10>::cpp_float_max_exp10;
     544template <unsigned Digits10>
     545const boost::int64_t cpp_dec_float<Digits10>::cpp_float_min_exp10;
     546template <unsigned Digits10>
     547const boost::int32_t cpp_dec_float<Digits10>::mp_elem_digits10;
     548template <unsigned Digits10>
     549const boost::int32_t cpp_dec_float<Digits10>::cpp_float_digits10_num_base;
     550template <unsigned Digits10>
     551const boost::int32_t cpp_dec_float<Digits10>::mp_elem_number;
     552template <unsigned Digits10>
     553const boost::int32_t cpp_dec_float<Digits10>::mp_elem_mask;
     554
     555
     556template <unsigned Digits10>
     557cpp_dec_float<Digits10>& cpp_dec_float<Digits10>::operator+=(const cpp_dec_float<Digits10>& v)
    558558{
    559559   if(isnan())
     
    751751      if(isneg())
    752752      {
    753          cpp_float t(*this);
     753         cpp_dec_float t(*this);
    754754         t.negate();
    755755         overflow = t.compare((max)()) > 0;
     
    775775
    776776template <unsigned Digits10>
    777 cpp_float<Digits10>& cpp_float<Digits10>::operator-=(const cpp_float<Digits10>& v)
     777cpp_dec_float<Digits10>& cpp_dec_float<Digits10>::operator-=(const cpp_dec_float<Digits10>& v)
    778778{
    779779   // Use *this - v = -(-*this + v).
     
    785785
    786786template <unsigned Digits10>
    787 cpp_float<Digits10>& cpp_float<Digits10>::operator*=(const cpp_float<Digits10>& v)
     787cpp_dec_float<Digits10>& cpp_dec_float<Digits10>::operator*=(const cpp_dec_float<Digits10>& v)
    788788{
    789789   // Evaluate the sign of the result.
     
    877877
    878878template <unsigned Digits10>
    879 cpp_float<Digits10>& cpp_float<Digits10>::operator/=(const cpp_float<Digits10>& v)
     879cpp_dec_float<Digits10>& cpp_dec_float<Digits10>::operator/=(const cpp_dec_float<Digits10>& v)
    880880{
    881881   const bool u_and_v_are_finite_and_identical = (   isfinite()
     
    905905         return *this;
    906906      }
    907       cpp_float t(v);
     907      cpp_dec_float t(v);
    908908      t.calculate_inv();
    909909      return operator*=(t);
     
    912912
    913913template <unsigned Digits10>
    914 cpp_float<Digits10>& cpp_float<Digits10>::mul_unsigned_long_long(const unsigned long long n)
     914cpp_dec_float<Digits10>& cpp_dec_float<Digits10>::mul_unsigned_long_long(const unsigned long long n)
    915915{
    916916   // Multiply *this with a constant unsigned long long.
     
    948948   {
    949949      neg = b_neg;
    950       cpp_float t;
     950      cpp_dec_float t;
    951951      t = n;
    952952      return operator*=(t);
     
    982982      if(isneg())
    983983      {
    984          cpp_float t(*this);
     984         cpp_dec_float t(*this);
    985985         t.negate();
    986986         overflow = t.compare((max)()) > 0;
     
    10071007
    10081008template <unsigned Digits10>
    1009 cpp_float<Digits10>& cpp_float<Digits10>::div_unsigned_long_long(const unsigned long long n)
     1009cpp_dec_float<Digits10>& cpp_dec_float<Digits10>::div_unsigned_long_long(const unsigned long long n)
    10101010{
    10111011   // Divide *this by a constant unsigned long long.
     
    10561056   {
    10571057      neg = b_neg;
    1058       cpp_float t;
     1058      cpp_dec_float t;
    10591059      t = n;
    10601060      return operator/=(t);
     
    10961096
    10971097template <unsigned Digits10>
    1098 cpp_float<Digits10>& cpp_float<Digits10>::calculate_inv()
     1098cpp_dec_float<Digits10>& cpp_dec_float<Digits10>::calculate_inv()
    10991099{
    11001100   // Compute the inverse of *this.
     
    11301130
    11311131   // Save the original *this.
    1132    cpp_float<Digits10> x(*this);
     1132   cpp_dec_float<Digits10> x(*this);
    11331133
    11341134   // Generate the initial estimate using division.
     
    11401140
    11411141   // Do the inverse estimate using double precision estimates of mantissa and exponent.
    1142    operator=(cpp_float<Digits10>(1.0 / dd, -ne));
     1142   operator=(cpp_dec_float<Digits10>(1.0 / dd, -ne));
    11431143
    11441144   // Compute the inverse of *this. Quadratically convergent Newton-Raphson iteration
     
    11551155
    11561156      // Next iteration.
    1157       cpp_float t(*this);
     1157      cpp_dec_float t(*this);
    11581158      t *= x;
    11591159      t -= two();
     
    11701170
    11711171template <unsigned Digits10>
    1172 cpp_float<Digits10>& cpp_float<Digits10>::calculate_sqrt(void)
     1172cpp_dec_float<Digits10>& cpp_dec_float<Digits10>::calculate_sqrt(void)
    11731173{
    11741174   // Compute the square root of *this.
     
    11861186
    11871187   // Save the original *this.
    1188    cpp_float<Digits10> x(*this);
     1188   cpp_dec_float<Digits10> x(*this);
    11891189
    11901190   // Generate the initial estimate using division.
     
    12061206   const double sqd = std::sqrt(dd);
    12071207
    1208    *this = cpp_float<Digits10>(sqd, static_cast<boost::int64_t>(ne / static_cast<boost::int64_t>(2)));
     1208   *this = cpp_dec_float<Digits10>(sqd, static_cast<boost::int64_t>(ne / static_cast<boost::int64_t>(2)));
    12091209
    12101210   // Estimate 1.0 / (2.0 * x0) using simple manipulations.
    1211    cpp_float<Digits10> vi(0.5 / sqd, static_cast<boost::int64_t>(-ne / static_cast<boost::int64_t>(2)));
     1211   cpp_dec_float<Digits10> vi(0.5 / sqd, static_cast<boost::int64_t>(-ne / static_cast<boost::int64_t>(2)));
    12121212
    12131213   // Compute the square root of x. Coupled Newton iteration
     
    12301230
    12311231      // Next iteration of vi
    1232       cpp_float t(*this);
     1232      cpp_dec_float t(*this);
    12331233      t *= vi;
    12341234      t.negate();
     
    12531253
    12541254template <unsigned Digits10>
    1255 int cpp_float<Digits10>::cmp_data(const array_type& vd) const
     1255int cpp_dec_float<Digits10>::cmp_data(const array_type& vd) const
    12561256{
    12571257   // Compare the data of *this with those of v.
     
    12751275
    12761276template <unsigned Digits10>
    1277 int cpp_float<Digits10>::compare(const cpp_float& v) const
     1277int cpp_dec_float<Digits10>::compare(const cpp_dec_float& v) const
    12781278{
    12791279   // Compare v with *this.
     
    13531353
    13541354template <unsigned Digits10>
    1355 bool cpp_float<Digits10>::isone() const
     1355bool cpp_dec_float<Digits10>::isone() const
    13561356{
    13571357   // Check if the value of *this is identically 1 or very close to 1.
     
    13771377
    13781378template <unsigned Digits10>
    1379 bool cpp_float<Digits10>::isint() const
     1379bool cpp_dec_float<Digits10>::isint() const
    13801380{
    13811381   if(fpclass != mp_finite) { return false; }
     
    14001400
    14011401template <unsigned Digits10>
    1402 void cpp_float<Digits10>::extract_parts(double& mantissa, boost::int64_t& exponent) const
    1403 {
    1404    // Extract the approximate parts mantissa and base-10 exponent from the input cpp_float<Digits10> value x.
     1402void cpp_dec_float<Digits10>::extract_parts(double& mantissa, boost::int64_t& exponent) const
     1403{
     1404   // Extract the approximate parts mantissa and base-10 exponent from the input cpp_dec_float<Digits10> value x.
    14051405
    14061406   // Extracts the mantissa and exponent.
     
    14331433
    14341434template <unsigned Digits10>
    1435 double cpp_float<Digits10>::extract_double(void) const
    1436 {
    1437    // Returns the double conversion of a cpp_float<Digits10>.
    1438 
    1439    // Check for non-normal cpp_float<Digits10>.
     1435double cpp_dec_float<Digits10>::extract_double(void) const
     1436{
     1437   // Returns the double conversion of a cpp_dec_float<Digits10>.
     1438
     1439   // Check for non-normal cpp_dec_float<Digits10>.
    14401440   if(!isfinite())
    14411441   {
     
    14511451   }
    14521452
    1453    cpp_float<Digits10> xx(*this);
     1453   cpp_dec_float<Digits10> xx(*this);
    14541454   if(xx.isneg())
    14551455      xx.negate();
    14561456
    1457    // Check for zero cpp_float<Digits10>.
     1457   // Check for zero cpp_dec_float<Digits10>.
    14581458   if(iszero() || (xx.compare(double_min()) < 0))
    14591459   {
     
    14611461   }
    14621462
    1463    // Check if cpp_float<Digits10> exceeds the maximum of double.
     1463   // Check if cpp_dec_float<Digits10> exceeds the maximum of double.
    14641464   if(xx.compare(double_max()) > 0)
    14651465   {
     
    14791479
    14801480template <unsigned Digits10>
    1481 long double cpp_float<Digits10>::extract_long_double(void) const
    1482 {
    1483    // Returns the long double conversion of a cpp_float<Digits10>.
    1484 
    1485    // Check for non-normal cpp_float<Digits10>.
     1481long double cpp_dec_float<Digits10>::extract_long_double(void) const
     1482{
     1483   // Returns the long double conversion of a cpp_dec_float<Digits10>.
     1484
     1485   // Check for non-normal cpp_dec_float<Digits10>.
    14861486   if(!isfinite())
    14871487   {
     
    14971497   }
    14981498
    1499    cpp_float<Digits10> xx(*this);
     1499   cpp_dec_float<Digits10> xx(*this);
    15001500   if(xx.isneg())
    15011501      xx.negate();
    15021502
    1503    // Check for zero cpp_float<Digits10>.
     1503   // Check for zero cpp_dec_float<Digits10>.
    15041504   if(iszero() || (xx.compare(long_double_min()) < 0))
    15051505   {
     
    15071507   }
    15081508
    1509    // Check if cpp_float<Digits10> exceeds the maximum of double.
     1509   // Check if cpp_dec_float<Digits10> exceeds the maximum of double.
    15101510   if(xx.compare(long_double_max()) > 0)
    15111511   {
     
    15251525
    15261526template <unsigned Digits10>
    1527 signed long long cpp_float<Digits10>::extract_signed_long_long(void) const
     1527signed long long cpp_dec_float<Digits10>::extract_signed_long_long(void) const
    15281528{
    15291529   // Extracts a signed long long from *this.
     
    15511551   {
    15521552      // Extract the data into an unsigned long long value.
    1553       cpp_float<Digits10> xn(extract_integer_part());
     1553      cpp_dec_float<Digits10> xn(extract_integer_part());
    15541554      if(xn.isneg())
    15551555         xn.negate();
     
    15701570
    15711571template <unsigned Digits10>
    1572 unsigned long long cpp_float<Digits10>::extract_unsigned_long_long(void) const
     1572unsigned long long cpp_dec_float<Digits10>::extract_unsigned_long_long(void) const
    15731573{
    15741574   // Extracts an unsigned long long from *this.
     
    15881588   }
    15891589
    1590    const cpp_float<Digits10> xn(extract_integer_part());
     1590   const cpp_dec_float<Digits10> xn(extract_integer_part());
    15911591
    15921592   unsigned long long val;
     
    16141614
    16151615template <unsigned Digits10>
    1616 cpp_float<Digits10> cpp_float<Digits10>::extract_integer_part(void) const
     1616cpp_dec_float<Digits10> cpp_dec_float<Digits10>::extract_integer_part(void) const
    16171617{
    16181618   // Compute the signed integer part of x.
     
    16371637
    16381638   // Make a local copy.
    1639    cpp_float<Digits10> x = *this;
     1639   cpp_dec_float<Digits10> x = *this;
    16401640
    16411641   // Clear out the decimal portion
     
    16491649
    16501650template <unsigned Digits10>
    1651 std::string cpp_float<Digits10>::str(boost::intmax_t number_of_digits, std::ios_base::fmtflags f) const
     1651std::string cpp_dec_float<Digits10>::str(boost::intmax_t number_of_digits, std::ios_base::fmtflags f) const
    16521652{
    16531653   if(this->isinf())
     
    16761676   else if(f & std::ios_base::scientific)
    16771677      ++number_of_digits;
    1678    // Determine the number of elements needed to provide the requested digits from cpp_float<Digits10>.
     1678   // Determine the number of elements needed to provide the requested digits from cpp_dec_float<Digits10>.
    16791679   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),
    16801680      static_cast<std::size_t>(mp_elem_number));
    16811681
    1682    // Extract the remaining digits from cpp_float<Digits10> after the decimal point.
     1682   // Extract the remaining digits from cpp_dec_float<Digits10> after the decimal point.
    16831683   str = boost::lexical_cast<std::string>(data[0]);
    16841684
    1685    // Extract all of the digits from cpp_float<Digits10>, beginning with the first data element.
     1685   // Extract all of the digits from cpp_dec_float<Digits10>, beginning with the first data element.
    16861686   for(std::size_t i = static_cast<std::size_t>(1u); i < number_of_elements; i++)
    16871687   {
     
    18021802
    18031803template <unsigned Digits10>
    1804 bool cpp_float<Digits10>::rd_string(const char* const s)
     1804bool cpp_dec_float<Digits10>::rd_string(const char* const s)
    18051805{
    18061806   std::string str(s);
     
    18741874   }
    18751875
    1876    // Put the input string into the standard cpp_float<Digits10> input form
     1876   // Put the input string into the standard cpp_dec_float<Digits10> input form
    18771877   // aaa.bbbbE+/-n, where aa has 1...mp_elem_digits10, bbbb has an
    18781878   // even multiple of mp_elem_digits10 which are possibly zero padded
     
    20022002   }
    20032003
    2004    // Now the input string has the standard cpp_float<Digits10> input form.
     2004   // Now the input string has the standard cpp_dec_float<Digits10> input form.
    20052005   // (See the comment above.)
    20062006
     
    20412041      {
    20422042         // Check for identity with the minimum value.
    2043          cpp_float<Digits10> test = *this;
     2043         cpp_dec_float<Digits10> test = *this;
    20442044
    20452045         test.exp = static_cast<boost::int64_t>(0);
     
    20602060
    20612061template <unsigned Digits10>
    2062 cpp_float<Digits10>::cpp_float(const double mantissa, const long long exponent)
     2062cpp_dec_float<Digits10>::cpp_dec_float(const double mantissa, const long long exponent)
    20632063 : data     (),
    20642064   exp      (static_cast<boost::int64_t>(0)),
     
    20672067   prec_elem(mp_elem_number)
    20682068{
    2069    // Create an cpp_float<Digits10> from mantissa and exponent.
     2069   // Create an cpp_dec_float<Digits10> from mantissa and exponent.
    20702070   // This ctor does not maintain the full precision of double.
    20712071
     
    21122112
    21132113template <unsigned Digits10>
    2114 cpp_float<Digits10>& cpp_float<Digits10>::operator = (long double a)
     2114cpp_dec_float<Digits10>& cpp_dec_float<Digits10>::operator = (long double a)
    21152115{
    21162116   // Christopher Kormanyos's original code used a cast to long long here, but that fails
     
    21622162
    21632163template <unsigned Digits10>
    2164 void cpp_float<Digits10>::from_unsigned_long_long(const unsigned long long u)
     2164void cpp_dec_float<Digits10>::from_unsigned_long_long(const unsigned long long u)
    21652165{
    21662166   std::fill(data.begin(), data.end(), static_cast<boost::uint32_t>(0u));
     
    21942194
    21952195template <unsigned Digits10>
    2196 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)
     2196void 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)
    21972197{
    21982198   boost::uint64_t carry = static_cast<boost::uint64_t>(0u);
     
    22152215
    22162216template <unsigned Digits10>
    2217 boost::uint32_t cpp_float<Digits10>::mul_loop_n(boost::uint32_t* const u, boost::uint32_t n, const boost::int32_t p)
     2217boost::uint32_t cpp_dec_float<Digits10>::mul_loop_n(boost::uint32_t* const u, boost::uint32_t n, const boost::int32_t p)
    22182218{
    22192219   boost::uint64_t carry = static_cast<boost::uint64_t>(0u);
     
    22312231
    22322232template <unsigned Digits10>
    2233 boost::uint32_t cpp_float<Digits10>::div_loop_n(boost::uint32_t* const u, boost::uint32_t n, const boost::int32_t p)
     2233boost::uint32_t cpp_dec_float<Digits10>::div_loop_n(boost::uint32_t* const u, boost::uint32_t n, const boost::int32_t p)
    22342234{
    22352235   boost::uint64_t prev = static_cast<boost::uint64_t>(0u);
     
    22462246
    22472247template <unsigned Digits10>
    2248 cpp_float<Digits10> cpp_float<Digits10>::pow2(const long long p)
     2248cpp_dec_float<Digits10> cpp_dec_float<Digits10>::pow2(const long long p)
    22492249{
    22502250   // Create a static const table of p^2 for -128 < p < +128.
     
    22522252   // symmetric about 0.
    22532253   init.do_nothing();
    2254    static const boost::array<cpp_float<Digits10>, 255u> p2_data =
     2254   static const boost::array<cpp_dec_float<Digits10>, 255u> p2_data =
    22552255   {{
    2256       cpp_float("5.877471754111437539843682686111228389093327783860437607543758531392086297273635864257812500000000000e-39"),
    2257          cpp_float("1.175494350822287507968736537222245677818665556772087521508751706278417259454727172851562500000000000e-38"),
    2258          cpp_float("2.350988701644575015937473074444491355637331113544175043017503412556834518909454345703125000000000000e-38"),
    2259          cpp_float("4.701977403289150031874946148888982711274662227088350086035006825113669037818908691406250000000000000e-38"),
    2260          cpp_float("9.403954806578300063749892297777965422549324454176700172070013650227338075637817382812500000000000000e-38"),
    2261          cpp_float("1.880790961315660012749978459555593084509864890835340034414002730045467615127563476562500000000000000e-37"),
    2262          cpp_float("3.761581922631320025499956919111186169019729781670680068828005460090935230255126953125000000000000000e-37"),
    2263          cpp_float("7.523163845262640050999913838222372338039459563341360137656010920181870460510253906250000000000000000e-37"),
    2264          cpp_float("1.504632769052528010199982767644474467607891912668272027531202184036374092102050781250000000000000000e-36"),
    2265          cpp_float("3.009265538105056020399965535288948935215783825336544055062404368072748184204101562500000000000000000e-36"),
    2266          cpp_float("6.018531076210112040799931070577897870431567650673088110124808736145496368408203125000000000000000000e-36"),
    2267          cpp_float("1.203706215242022408159986214115579574086313530134617622024961747229099273681640625000000000000000000e-35"),
    2268          cpp_float("2.407412430484044816319972428231159148172627060269235244049923494458198547363281250000000000000000000e-35"),
    2269          cpp_float("4.814824860968089632639944856462318296345254120538470488099846988916397094726562500000000000000000000e-35"),
    2270          cpp_float("9.629649721936179265279889712924636592690508241076940976199693977832794189453125000000000000000000000e-35"),
    2271          cpp_float("1.925929944387235853055977942584927318538101648215388195239938795566558837890625000000000000000000000e-34"),
    2272          cpp_float("3.851859888774471706111955885169854637076203296430776390479877591133117675781250000000000000000000000e-34"),
    2273          cpp_float("7.703719777548943412223911770339709274152406592861552780959755182266235351562500000000000000000000000e-34"),
    2274          cpp_float("1.540743955509788682444782354067941854830481318572310556191951036453247070312500000000000000000000000e-33"),
    2275          cpp_float("3.081487911019577364889564708135883709660962637144621112383902072906494140625000000000000000000000000e-33"),
    2276          cpp_float("6.162975822039154729779129416271767419321925274289242224767804145812988281250000000000000000000000000e-33"),
    2277          cpp_float("1.232595164407830945955825883254353483864385054857848444953560829162597656250000000000000000000000000e-32"),
    2278          cpp_float("2.465190328815661891911651766508706967728770109715696889907121658325195312500000000000000000000000000e-32"),
    2279          cpp_float("4.930380657631323783823303533017413935457540219431393779814243316650390625000000000000000000000000000e-32"),
    2280          cpp_float("9.860761315262647567646607066034827870915080438862787559628486633300781250000000000000000000000000000e-32"),
    2281          cpp_float("1.972152263052529513529321413206965574183016087772557511925697326660156250000000000000000000000000000e-31"),
    2282          cpp_float("3.944304526105059027058642826413931148366032175545115023851394653320312500000000000000000000000000000e-31"),
    2283          cpp_float("7.888609052210118054117285652827862296732064351090230047702789306640625000000000000000000000000000000e-31"),
    2284          cpp_float("1.577721810442023610823457130565572459346412870218046009540557861328125000000000000000000000000000000e-30"),
    2285          cpp_float("3.155443620884047221646914261131144918692825740436092019081115722656250000000000000000000000000000000e-30"),
    2286          cpp_float("6.310887241768094443293828522262289837385651480872184038162231445312500000000000000000000000000000000e-30"),
    2287          cpp_float("1.262177448353618888658765704452457967477130296174436807632446289062500000000000000000000000000000000e-29"),
    2288          cpp_float("2.524354896707237777317531408904915934954260592348873615264892578125000000000000000000000000000000000e-29"),
    2289          cpp_float("5.048709793414475554635062817809831869908521184697747230529785156250000000000000000000000000000000000e-29"),
    2290          cpp_float("1.009741958682895110927012563561966373981704236939549446105957031250000000000000000000000000000000000e-28"),
    2291          cpp_float("2.019483917365790221854025127123932747963408473879098892211914062500000000000000000000000000000000000e-28"),
    2292          cpp_float("4.038967834731580443708050254247865495926816947758197784423828125000000000000000000000000000000000000e-28"),
    2293          cpp_float("8.077935669463160887416100508495730991853633895516395568847656250000000000000000000000000000000000000e-28"),
    2294          cpp_float("1.615587133892632177483220101699146198370726779103279113769531250000000000000000000000000000000000000e-27"),
    2295          cpp_float("3.231174267785264354966440203398292396741453558206558227539062500000000000000000000000000000000000000e-27"),
    2296          cpp_float("6.462348535570528709932880406796584793482907116413116455078125000000000000000000000000000000000000000e-27"),
    2297          cpp_float("1.292469707114105741986576081359316958696581423282623291015625000000000000000000000000000000000000000e-26"),
    2298          cpp_float("2.584939414228211483973152162718633917393162846565246582031250000000000000000000000000000000000000000e-26"),
    2299          cpp_float("5.169878828456422967946304325437267834786325693130493164062500000000000000000000000000000000000000000e-26"),
    2300          cpp_float("1.033975765691284593589260865087453566957265138626098632812500000000000000000000000000000000000000000e-25"),
    2301          cpp_float("2.067951531382569187178521730174907133914530277252197265625000000000000000000000000000000000000000000e-25"),
    2302          cpp_float("4.135903062765138374357043460349814267829060554504394531250000000000000000000000000000000000000000000e-25"),
    2303          cpp_float("8.271806125530276748714086920699628535658121109008789062500000000000000000000000000000000000000000000e-25"),
    2304          cpp_float("1.654361225106055349742817384139925707131624221801757812500000000000000000000000000000000000000000000e-24"),
    2305          cpp_float("3.308722450212110699485634768279851414263248443603515625000000000000000000000000000000000000000000000e-24"),
    2306          cpp_float("6.617444900424221398971269536559702828526496887207031250000000000000000000000000000000000000000000000e-24"),
    2307          cpp_float("1.323488980084844279794253907311940565705299377441406250000000000000000000000000000000000000000000000e-23"),
    2308          cpp_float("2.646977960169688559588507814623881131410598754882812500000000000000000000000000000000000000000000000e-23"),
    2309          cpp_float("5.293955920339377119177015629247762262821197509765625000000000000000000000000000000000000000000000000e-23"),
    2310          cpp_float("1.058791184067875423835403125849552452564239501953125000000000000000000000000000000000000000000000000e-22"),
    2311          cpp_float("2.117582368135750847670806251699104905128479003906250000000000000000000000000000000000000000000000000e-22"),
    2312          cpp_float("4.235164736271501695341612503398209810256958007812500000000000000000000000000000000000000000000000000e-22"),
    2313          cpp_float("8.470329472543003390683225006796419620513916015625000000000000000000000000000000000000000000000000000e-22"),
    2314          cpp_float("1.694065894508600678136645001359283924102783203125000000000000000000000000000000000000000000000000000e-21"),
    2315          cpp_float("3.388131789017201356273290002718567848205566406250000000000000000000000000000000000000000000000000000e-21"),
    2316          cpp_float("6.776263578034402712546580005437135696411132812500000000000000000000000000000000000000000000000000000e-21"),
    2317          cpp_float("1.355252715606880542509316001087427139282226562500000000000000000000000000000000000000000000000000000e-20"),
    2318          cpp_float("2.710505431213761085018632002174854278564453125000000000000000000000000000000000000000000000000000000e-20"),
    2319          cpp_float("5.421010862427522170037264004349708557128906250000000000000000000000000000000000000000000000000000000e-20"),
    2320          cpp_float("1.084202172485504434007452800869941711425781250000000000000000000000000000000000000000000000000000000e-19"),
    2321          cpp_float("2.168404344971008868014905601739883422851562500000000000000000000000000000000000000000000000000000000e-19"),
    2322          cpp_float("4.336808689942017736029811203479766845703125000000000000000000000000000000000000000000000000000000000e-19"),
    2323          cpp_float("8.673617379884035472059622406959533691406250000000000000000000000000000000000000000000000000000000000e-19"),
    2324          cpp_float("1.734723475976807094411924481391906738281250000000000000000000000000000000000000000000000000000000000e-18"),
    2325          cpp_float("3.469446951953614188823848962783813476562500000000000000000000000000000000000000000000000000000000000e-18"),
    2326          cpp_float("6.938893903907228377647697925567626953125000000000000000000000000000000000000000000000000000000000000e-18"),
    2327          cpp_float("1.387778780781445675529539585113525390625000000000000000000000000000000000000000000000000000000000000e-17"),
    2328          cpp_float("2.775557561562891351059079170227050781250000000000000000000000000000000000000000000000000000000000000e-17"),
    2329          cpp_float("5.551115123125782702118158340454101562500000000000000000000000000000000000000000000000000000000000000e-17"),
    2330          cpp_float("1.110223024625156540423631668090820312500000000000000000000000000000000000000000000000000000000000000e-16"),
    2331          cpp_float("2.220446049250313080847263336181640625000000000000000000000000000000000000000000000000000000000000000e-16"),
    2332          cpp_float("4.440892098500626161694526672363281250000000000000000000000000000000000000000000000000000000000000000e-16"),
    2333          cpp_float("8.881784197001252323389053344726562500000000000000000000000000000000000000000000000000000000000000000e-16"),
    2334          cpp_float("1.776356839400250464677810668945312500000000000000000000000000000000000000000000000000000000000000000e-15"),
    2335          cpp_float("3.552713678800500929355621337890625000000000000000000000000000000000000000000000000000000000000000000e-15"),
    2336          cpp_float("7.105427357601001858711242675781250000000000000000000000000000000000000000000000000000000000000000000e-15"),
    2337          cpp_float("1.421085471520200371742248535156250000000000000000000000000000000000000000000000000000000000000000000e-14"),
    2338          cpp_float("2.842170943040400743484497070312500000000000000000000000000000000000000000000000000000000000000000000e-14"),
    2339          cpp_float("5.684341886080801486968994140625000000000000000000000000000000000000000000000000000000000000000000000e-14"),
    2340          cpp_float("1.136868377216160297393798828125000000000000000000000000000000000000000000000000000000000000000000000e-13"),
    2341          cpp_float("2.273736754432320594787597656250000000000000000000000000000000000000000000000000000000000000000000000e-13"),
    2342          cpp_float("4.547473508864641189575195312500000000000000000000000000000000000000000000000000000000000000000000000e-13"),
    2343          cpp_float("9.094947017729282379150390625000000000000000000000000000000000000000000000000000000000000000000000000e-13"),
    2344          cpp_float("1.818989403545856475830078125000000000000000000000000000000000000000000000000000000000000000000000000e-12"),
    2345          cpp_float("3.637978807091712951660156250000000000000000000000000000000000000000000000000000000000000000000000000e-12"),
    2346          cpp_float("7.275957614183425903320312500000000000000000000000000000000000000000000000000000000000000000000000000e-12"),
    2347          cpp_float("1.455191522836685180664062500000000000000000000000000000000000000000000000000000000000000000000000000e-11"),
    2348          cpp_float("2.910383045673370361328125000000000000000000000000000000000000000000000000000000000000000000000000000e-11"),
    2349          cpp_float("5.820766091346740722656250000000000000000000000000000000000000000000000000000000000000000000000000000e-11"),
    2350          cpp_float("1.164153218269348144531250000000000000000000000000000000000000000000000000000000000000000000000000000e-10"),
    2351          cpp_float("2.328306436538696289062500000000000000000000000000000000000000000000000000000000000000000000000000000e-10"),
    2352          cpp_float("4.656612873077392578125000000000000000000000000000000000000000000000000000000000000000000000000000000e-10"),
    2353          cpp_float("9.313225746154785156250000000000000000000000000000000000000000000000000000000000000000000000000000000e-10"),
    2354          cpp_float("1.862645149230957031250000000000000000000000000000000000000000000000000000000000000000000000000000000e-9"),
    2355          cpp_float("3.725290298461914062500000000000000000000000000000000000000000000000000000000000000000000000000000000e-9"),
    2356          cpp_float("7.450580596923828125000000000000000000000000000000000000000000000000000000000000000000000000000000000e-9"),
    2357          cpp_float("1.490116119384765625000000000000000000000000000000000000000000000000000000000000000000000000000000000e-8"),
    2358          cpp_float("2.980232238769531250000000000000000000000000000000000000000000000000000000000000000000000000000000000e-8"),
    2359          cpp_float("5.960464477539062500000000000000000000000000000000000000000000000000000000000000000000000000000000000e-8"),
    2360          cpp_float("1.192092895507812500000000000000000000000000000000000000000000000000000000000000000000000000000000000e-7"),
    2361          cpp_float("2.384185791015625000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-7"),
    2362          cpp_float("4.768371582031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-7"),
    2363          cpp_float("9.536743164062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-7"),
    2364          cpp_float("1.907348632812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-6"),
    2365          cpp_float("3.814697265625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-6"),
    2366          cpp_float("7.629394531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-6"),
    2367          cpp_float("0.000015258789062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
    2368          cpp_float("0.000030517578125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
    2369          cpp_float("0.000061035156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
    2370          cpp_float("0.000122070312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
    2371          cpp_float("0.000244140625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
    2372          cpp_float("0.000488281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
    2373          cpp_float("0.000976562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
    2374          cpp_float("0.001953125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
    2375          cpp_float("0.003906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
    2376          cpp_float("0.007812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
    2377          cpp_float("0.01562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
    2378          cpp_float("0.03125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
    2379          cpp_float("0.06250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
    2380          cpp_float("0.125"),
    2381          cpp_float("0.25"),
    2382          cpp_float("0.5"),
     2256      cpp_dec_float("5.877471754111437539843682686111228389093327783860437607543758531392086297273635864257812500000000000e-39"),
     2257         cpp_dec_float("1.175494350822287507968736537222245677818665556772087521508751706278417259454727172851562500000000000e-38"),
     2258         cpp_dec_float("2.350988701644575015937473074444491355637331113544175043017503412556834518909454345703125000000000000e-38"),
     2259         cpp_dec_float("4.701977403289150031874946148888982711274662227088350086035006825113669037818908691406250000000000000e-38"),
     2260         cpp_dec_float("9.403954806578300063749892297777965422549324454176700172070013650227338075637817382812500000000000000e-38"),
     2261         cpp_dec_float("1.880790961315660012749978459555593084509864890835340034414002730045467615127563476562500000000000000e-37"),
     2262         cpp_dec_float("3.761581922631320025499956919111186169019729781670680068828005460090935230255126953125000000000000000e-37"),
     2263         cpp_dec_float("7.523163845262640050999913838222372338039459563341360137656010920181870460510253906250000000000000000e-37"),
     2264         cpp_dec_float("1.504632769052528010199982767644474467607891912668272027531202184036374092102050781250000000000000000e-36"),
     2265         cpp_dec_float("3.009265538105056020399965535288948935215783825336544055062404368072748184204101562500000000000000000e-36"),
     2266         cpp_dec_float("6.018531076210112040799931070577897870431567650673088110124808736145496368408203125000000000000000000e-36"),
     2267         cpp_dec_float("1.203706215242022408159986214115579574086313530134617622024961747229099273681640625000000000000000000e-35"),
     2268         cpp_dec_float("2.407412430484044816319972428231159148172627060269235244049923494458198547363281250000000000000000000e-35"),
     2269         cpp_dec_float("4.814824860968089632639944856462318296345254120538470488099846988916397094726562500000000000000000000e-35"),
     2270         cpp_dec_float("9.629649721936179265279889712924636592690508241076940976199693977832794189453125000000000000000000000e-35"),
     2271         cpp_dec_float("1.925929944387235853055977942584927318538101648215388195239938795566558837890625000000000000000000000e-34"),
     2272         cpp_dec_float("3.851859888774471706111955885169854637076203296430776390479877591133117675781250000000000000000000000e-34"),
     2273         cpp_dec_float("7.703719777548943412223911770339709274152406592861552780959755182266235351562500000000000000000000000e-34"),
     2274         cpp_dec_float("1.540743955509788682444782354067941854830481318572310556191951036453247070312500000000000000000000000e-33"),
     2275         cpp_dec_float("3.081487911019577364889564708135883709660962637144621112383902072906494140625000000000000000000000000e-33"),
     2276         cpp_dec_float("6.162975822039154729779129416271767419321925274289242224767804145812988281250000000000000000000000000e-33"),
     2277         cpp_dec_float("1.232595164407830945955825883254353483864385054857848444953560829162597656250000000000000000000000000e-32"),
     2278         cpp_dec_float("2.465190328815661891911651766508706967728770109715696889907121658325195312500000000000000000000000000e-32"),
     2279         cpp_dec_float("4.930380657631323783823303533017413935457540219431393779814243316650390625000000000000000000000000000e-32"),
     2280         cpp_dec_float("9.860761315262647567646607066034827870915080438862787559628486633300781250000000000000000000000000000e-32"),
     2281         cpp_dec_float("1.972152263052529513529321413206965574183016087772557511925697326660156250000000000000000000000000000e-31"),
     2282         cpp_dec_float("3.944304526105059027058642826413931148366032175545115023851394653320312500000000000000000000000000000e-31"),
     2283         cpp_dec_float("7.888609052210118054117285652827862296732064351090230047702789306640625000000000000000000000000000000e-31"),
     2284         cpp_dec_float("1.577721810442023610823457130565572459346412870218046009540557861328125000000000000000000000000000000e-30"),
     2285         cpp_dec_float("3.155443620884047221646914261131144918692825740436092019081115722656250000000000000000000000000000000e-30"),
     2286         cpp_dec_float("6.310887241768094443293828522262289837385651480872184038162231445312500000000000000000000000000000000e-30"),
     2287         cpp_dec_float("1.262177448353618888658765704452457967477130296174436807632446289062500000000000000000000000000000000e-29"),
     2288         cpp_dec_float("2.524354896707237777317531408904915934954260592348873615264892578125000000000000000000000000000000000e-29"),
     2289         cpp_dec_float("5.048709793414475554635062817809831869908521184697747230529785156250000000000000000000000000000000000e-29"),
     2290         cpp_dec_float("1.009741958682895110927012563561966373981704236939549446105957031250000000000000000000000000000000000e-28"),
     2291         cpp_dec_float("2.019483917365790221854025127123932747963408473879098892211914062500000000000000000000000000000000000e-28"),
     2292         cpp_dec_float("4.038967834731580443708050254247865495926816947758197784423828125000000000000000000000000000000000000e-28"),
     2293         cpp_dec_float("8.077935669463160887416100508495730991853633895516395568847656250000000000000000000000000000000000000e-28"),
     2294         cpp_dec_float("1.615587133892632177483220101699146198370726779103279113769531250000000000000000000000000000000000000e-27"),
     2295         cpp_dec_float("3.231174267785264354966440203398292396741453558206558227539062500000000000000000000000000000000000000e-27"),
     2296         cpp_dec_float("6.462348535570528709932880406796584793482907116413116455078125000000000000000000000000000000000000000e-27"),
     2297         cpp_dec_float("1.292469707114105741986576081359316958696581423282623291015625000000000000000000000000000000000000000e-26"),
     2298         cpp_dec_float("2.584939414228211483973152162718633917393162846565246582031250000000000000000000000000000000000000000e-26"),
     2299         cpp_dec_float("5.169878828456422967946304325437267834786325693130493164062500000000000000000000000000000000000000000e-26"),
     2300         cpp_dec_float("1.033975765691284593589260865087453566957265138626098632812500000000000000000000000000000000000000000e-25"),
     2301         cpp_dec_float("2.067951531382569187178521730174907133914530277252197265625000000000000000000000000000000000000000000e-25"),
     2302         cpp_dec_float("4.135903062765138374357043460349814267829060554504394531250000000000000000000000000000000000000000000e-25"),
     2303         cpp_dec_float("8.271806125530276748714086920699628535658121109008789062500000000000000000000000000000000000000000000e-25"),
     2304         cpp_dec_float("1.654361225106055349742817384139925707131624221801757812500000000000000000000000000000000000000000000e-24"),
     2305         cpp_dec_float("3.308722450212110699485634768279851414263248443603515625000000000000000000000000000000000000000000000e-24"),
     2306         cpp_dec_float("6.617444900424221398971269536559702828526496887207031250000000000000000000000000000000000000000000000e-24"),
     2307         cpp_dec_float("1.323488980084844279794253907311940565705299377441406250000000000000000000000000000000000000000000000e-23"),
     2308         cpp_dec_float("2.646977960169688559588507814623881131410598754882812500000000000000000000000000000000000000000000000e-23"),
     2309         cpp_dec_float("5.293955920339377119177015629247762262821197509765625000000000000000000000000000000000000000000000000e-23"),
     2310         cpp_dec_float("1.058791184067875423835403125849552452564239501953125000000000000000000000000000000000000000000000000e-22"),
     2311         cpp_dec_float("2.117582368135750847670806251699104905128479003906250000000000000000000000000000000000000000000000000e-22"),
     2312         cpp_dec_float("4.235164736271501695341612503398209810256958007812500000000000000000000000000000000000000000000000000e-22"),
     2313         cpp_dec_float("8.470329472543003390683225006796419620513916015625000000000000000000000000000000000000000000000000000e-22"),
     2314         cpp_dec_float("1.694065894508600678136645001359283924102783203125000000000000000000000000000000000000000000000000000e-21"),
     2315         cpp_dec_float("3.388131789017201356273290002718567848205566406250000000000000000000000000000000000000000000000000000e-21"),
     2316         cpp_dec_float("6.776263578034402712546580005437135696411132812500000000000000000000000000000000000000000000000000000e-21"),
     2317         cpp_dec_float("1.355252715606880542509316001087427139282226562500000000000000000000000000000000000000000000000000000e-20"),
     2318         cpp_dec_float("2.710505431213761085018632002174854278564453125000000000000000000000000000000000000000000000000000000e-20"),
     2319         cpp_dec_float("5.421010862427522170037264004349708557128906250000000000000000000000000000000000000000000000000000000e-20"),
     2320         cpp_dec_float("1.084202172485504434007452800869941711425781250000000000000000000000000000000000000000000000000000000e-19"),
     2321         cpp_dec_float("2.168404344971008868014905601739883422851562500000000000000000000000000000000000000000000000000000000e-19"),
     2322         cpp_dec_float("4.336808689942017736029811203479766845703125000000000000000000000000000000000000000000000000000000000e-19"),
     2323         cpp_dec_float("8.673617379884035472059622406959533691406250000000000000000000000000000000000000000000000000000000000e-19"),
     2324         cpp_dec_float("1.734723475976807094411924481391906738281250000000000000000000000000000000000000000000000000000000000e-18"),
     2325         cpp_dec_float("3.469446951953614188823848962783813476562500000000000000000000000000000000000000000000000000000000000e-18"),
     2326         cpp_dec_float("6.938893903907228377647697925567626953125000000000000000000000000000000000000000000000000000000000000e-18"),
     2327         cpp_dec_float("1.387778780781445675529539585113525390625000000000000000000000000000000000000000000000000000000000000e-17"),
     2328         cpp_dec_float("2.775557561562891351059079170227050781250000000000000000000000000000000000000000000000000000000000000e-17"),
     2329         cpp_dec_float("5.551115123125782702118158340454101562500000000000000000000000000000000000000000000000000000000000000e-17"),
     2330         cpp_dec_float("1.110223024625156540423631668090820312500000000000000000000000000000000000000000000000000000000000000e-16"),
     2331         cpp_dec_float("2.220446049250313080847263336181640625000000000000000000000000000000000000000000000000000000000000000e-16"),
     2332         cpp_dec_float("4.440892098500626161694526672363281250000000000000000000000000000000000000000000000000000000000000000e-16"),
     2333         cpp_dec_float("8.881784197001252323389053344726562500000000000000000000000000000000000000000000000000000000000000000e-16"),
     2334         cpp_dec_float("1.776356839400250464677810668945312500000000000000000000000000000000000000000000000000000000000000000e-15"),
     2335         cpp_dec_float("3.552713678800500929355621337890625000000000000000000000000000000000000000000000000000000000000000000e-15"),
     2336         cpp_dec_float("7.105427357601001858711242675781250000000000000000000000000000000000000000000000000000000000000000000e-15"),
     2337         cpp_dec_float("1.421085471520200371742248535156250000000000000000000000000000000000000000000000000000000000000000000e-14"),
     2338         cpp_dec_float("2.842170943040400743484497070312500000000000000000000000000000000000000000000000000000000000000000000e-14"),
     2339         cpp_dec_float("5.684341886080801486968994140625000000000000000000000000000000000000000000000000000000000000000000000e-14"),
     2340         cpp_dec_float("1.136868377216160297393798828125000000000000000000000000000000000000000000000000000000000000000000000e-13"),
     2341         cpp_dec_float("2.273736754432320594787597656250000000000000000000000000000000000000000000000000000000000000000000000e-13"),
     2342         cpp_dec_float("4.547473508864641189575195312500000000000000000000000000000000000000000000000000000000000000000000000e-13"),
     2343         cpp_dec_float("9.094947017729282379150390625000000000000000000000000000000000000000000000000000000000000000000000000e-13"),
     2344         cpp_dec_float("1.818989403545856475830078125000000000000000000000000000000000000000000000000000000000000000000000000e-12"),
     2345         cpp_dec_float("3.637978807091712951660156250000000000000000000000000000000000000000000000000000000000000000000000000e-12"),
     2346         cpp_dec_float("7.275957614183425903320312500000000000000000000000000000000000000000000000000000000000000000000000000e-12"),
     2347         cpp_dec_float("1.455191522836685180664062500000000000000000000000000000000000000000000000000000000000000000000000000e-11"),
     2348         cpp_dec_float("2.910383045673370361328125000000000000000000000000000000000000000000000000000000000000000000000000000e-11"),
     2349         cpp_dec_float("5.820766091346740722656250000000000000000000000000000000000000000000000000000000000000000000000000000e-11"),
     2350         cpp_dec_float("1.164153218269348144531250000000000000000000000000000000000000000000000000000000000000000000000000000e-10"),
     2351         cpp_dec_float("2.328306436538696289062500000000000000000000000000000000000000000000000000000000000000000000000000000e-10"),
     2352         cpp_dec_float("4.656612873077392578125000000000000000000000000000000000000000000000000000000000000000000000000000000e-10"),
     2353         cpp_dec_float("9.313225746154785156250000000000000000000000000000000000000000000000000000000000000000000000000000000e-10"),
     2354         cpp_dec_float("1.862645149230957031250000000000000000000000000000000000000000000000000000000000000000000000000000000e-9"),
     2355         cpp_dec_float("3.725290298461914062500000000000000000000000000000000000000000000000000000000000000000000000000000000e-9"),
     2356         cpp_dec_float("7.450580596923828125000000000000000000000000000000000000000000000000000000000000000000000000000000000e-9"),
     2357         cpp_dec_float("1.490116119384765625000000000000000000000000000000000000000000000000000000000000000000000000000000000e-8"),
     2358         cpp_dec_float("2.980232238769531250000000000000000000000000000000000000000000000000000000000000000000000000000000000e-8"),
     2359         cpp_dec_float("5.960464477539062500000000000000000000000000000000000000000000000000000000000000000000000000000000000e-8"),
     2360         cpp_dec_float("1.192092895507812500000000000000000000000000000000000000000000000000000000000000000000000000000000000e-7"),
     2361         cpp_dec_float("2.384185791015625000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-7"),
     2362         cpp_dec_float("4.768371582031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-7"),
     2363         cpp_dec_float("9.536743164062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-7"),
     2364         cpp_dec_float("1.907348632812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-6"),
     2365         cpp_dec_float("3.814697265625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-6"),
     2366         cpp_dec_float("7.629394531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-6"),
     2367         cpp_dec_float("0.000015258789062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
     2368         cpp_dec_float("0.000030517578125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
     2369         cpp_dec_float("0.000061035156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
     2370         cpp_dec_float("0.000122070312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
     2371         cpp_dec_float("0.000244140625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
     2372         cpp_dec_float("0.000488281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
     2373         cpp_dec_float("0.000976562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
     2374         cpp_dec_float("0.001953125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
     2375         cpp_dec_float("0.003906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
     2376         cpp_dec_float("0.007812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
     2377         cpp_dec_float("0.01562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
     2378         cpp_dec_float("0.03125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
     2379         cpp_dec_float("0.06250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
     2380         cpp_dec_float("0.125"),
     2381         cpp_dec_float("0.25"),
     2382         cpp_dec_float("0.5"),
    23832383         one(),
    23842384         two(),
    2385          cpp_float(static_cast<unsigned long long>(4)),
    2386          cpp_float(static_cast<unsigned long long>(8)),
    2387          cpp_float(static_cast<unsigned long long>(16)),
    2388          cpp_float(static_cast<unsigned long long>(32)),
    2389          cpp_float(static_cast<unsigned long long>(64)),
    2390          cpp_float(static_cast<unsigned long long>(128)),
    2391          cpp_float(static_cast<unsigned long long>(256)),
    2392          cpp_float(static_cast<unsigned long long>(512)),
    2393          cpp_float(static_cast<unsigned long long>(1024)),
    2394          cpp_float(static_cast<unsigned long long>(2048)),
    2395          cpp_float(static_cast<unsigned long long>(4096)),
    2396          cpp_float(static_cast<unsigned long long>(8192)),
    2397          cpp_float(static_cast<unsigned long long>(16384)),
    2398          cpp_float(static_cast<unsigned long long>(32768)),
    2399          cpp_float(static_cast<unsigned long long>(65536)),
    2400          cpp_float(static_cast<unsigned long long>(131072)),
    2401          cpp_float(static_cast<unsigned long long>(262144)),
    2402          cpp_float(static_cast<unsigned long long>(524288)),
    2403          cpp_float(static_cast<boost::uint64_t>(1uL << 20u)),
    2404          cpp_float(static_cast<boost::uint64_t>(1uL << 21u)),
    2405          cpp_float(static_cast<boost::uint64_t>(1uL << 22u)),
    2406          cpp_float(static_cast<boost::uint64_t>(1uL << 23u)),
    2407          cpp_float(static_cast<boost::uint64_t>(1uL << 24u)),
    2408          cpp_float(static_cast<boost::uint64_t>(1uL << 25u)),
    2409          cpp_float(static_cast<boost::uint64_t>(1uL << 26u)),
    2410          cpp_float(static_cast<boost::uint64_t>(1uL << 27u)),
    2411          cpp_float(static_cast<boost::uint64_t>(1uL << 28u)),
    2412          cpp_float(static_cast<boost::uint64_t>(1uL << 29u)),
    2413          cpp_float(static_cast<boost::uint64_t>(1uL << 30u)),
    2414          cpp_float(static_cast<boost::uint64_t>(1uL << 31u)),
    2415          cpp_float(static_cast<boost::uint64_t>(1uLL << 32u)),
    2416          cpp_float(static_cast<boost::uint64_t>(1uLL << 33u)),
    2417          cpp_float(static_cast<boost::uint64_t>(1uLL << 34u)),
    2418          cpp_float(static_cast<boost::uint64_t>(1uLL << 35u)),
    2419          cpp_float(static_cast<boost::uint64_t>(1uLL << 36u)),
    2420          cpp_float(static_cast<boost::uint64_t>(1uLL << 37u)),
    2421          cpp_float(static_cast<boost::uint64_t>(1uLL << 38u)),
    2422          cpp_float(static_cast<boost::uint64_t>(1uLL << 39u)),
    2423          cpp_float(static_cast<boost::uint64_t>(1uLL << 40u)),
    2424          cpp_float(static_cast<boost::uint64_t>(1uLL << 41u)),
    2425          cpp_float(static_cast<boost::uint64_t>(1uLL << 42u)),
    2426          cpp_float(static_cast<boost::uint64_t>(1uLL << 43u)),
    2427          cpp_float(static_cast<boost::uint64_t>(1uLL << 44u)),
    2428          cpp_float(static_cast<boost::uint64_t>(1uLL << 45u)),
    2429          cpp_float(static_cast<boost::uint64_t>(1uLL << 46u)),
    2430          cpp_float(static_cast<boost::uint64_t>(1uLL << 47u)),
    2431          cpp_float(static_cast<boost::uint64_t>(1uLL << 48u)),
    2432          cpp_float(static_cast<boost::uint64_t>(1uLL << 49u)),
    2433          cpp_float(static_cast<boost::uint64_t>(1uLL << 50u)),
    2434          cpp_float(static_cast<boost::uint64_t>(1uLL << 51u)),
    2435          cpp_float(static_cast<boost::uint64_t>(1uLL << 52u)),
    2436          cpp_float(static_cast<boost::uint64_t>(1uLL << 53u)),
    2437          cpp_float(static_cast<boost::uint64_t>(1uLL << 54u)),
    2438          cpp_float(static_cast<boost::uint64_t>(1uLL << 55u)),
    2439          cpp_float(static_cast<boost::uint64_t>(1uLL << 56u)),
    2440          cpp_float(static_cast<boost::uint64_t>(1uLL << 57u)),
    2441          cpp_float(static_cast<boost::uint64_t>(1uLL << 58u)),
    2442          cpp_float(static_cast<boost::uint64_t>(1uLL << 59u)),
    2443          cpp_float(static_cast<boost::uint64_t>(1uLL << 60u)),
    2444          cpp_float(static_cast<boost::uint64_t>(1uLL << 61u)),
    2445          cpp_float(static_cast<boost::uint64_t>(1uLL << 62u)),
    2446          cpp_float(static_cast<boost::uint64_t>(1uLL << 63u)),
    2447          cpp_float("1.844674407370955161600000000000000000000000000000000000000000000000000000000000000000000000000000000e19"),
    2448          cpp_float("3.689348814741910323200000000000000000000000000000000000000000000000000000000000000000000000000000000e19"),
    2449          cpp_float("7.378697629483820646400000000000000000000000000000000000000000000000000000000000000000000000000000000e19"),
    2450          cpp_float("1.475739525896764129280000000000000000000000000000000000000000000000000000000000000000000000000000000e20"),
    2451          cpp_float("2.951479051793528258560000000000000000000000000000000000000000000000000000000000000000000000000000000e20"),
    2452          cpp_float("5.902958103587056517120000000000000000000000000000000000000000000000000000000000000000000000000000000e20"),
    2453          cpp_float("1.180591620717411303424000000000000000000000000000000000000000000000000000000000000000000000000000000e21"),
    2454          cpp_float("2.361183241434822606848000000000000000000000000000000000000000000000000000000000000000000000000000000e21"),
    2455          cpp_float("4.722366482869645213696000000000000000000000000000000000000000000000000000000000000000000000000000000e21"),
    2456          cpp_float("9.444732965739290427392000000000000000000000000000000000000000000000000000000000000000000000000000000e21"),
    2457          cpp_float("1.888946593147858085478400000000000000000000000000000000000000000000000000000000000000000000000000000e22"),
    2458          cpp_float("3.777893186295716170956800000000000000000000000000000000000000000000000000000000000000000000000000000e22"),
    2459          cpp_float("7.555786372591432341913600000000000000000000000000000000000000000000000000000000000000000000000000000e22"),
    2460          cpp_float("1.511157274518286468382720000000000000000000000000000000000000000000000000000000000000000000000000000e23"),
    2461          cpp_float("3.022314549036572936765440000000000000000000000000000000000000000000000000000000000000000000000000000e23"),
    2462          cpp_float("6.044629098073145873530880000000000000000000000000000000000000000000000000000000000000000000000000000e23"),
    2463          cpp_float("1.208925819614629174706176000000000000000000000000000000000000000000000000000000000000000000000000000e24"),
    2464          cpp_float("2.417851639229258349412352000000000000000000000000000000000000000000000000000000000000000000000000000e24"),
    2465          cpp_float("4.835703278458516698824704000000000000000000000000000000000000000000000000000000000000000000000000000e24"),
    2466          cpp_float("9.671406556917033397649408000000000000000000000000000000000000000000000000000000000000000000000000000e24"),
    2467          cpp_float("1.934281311383406679529881600000000000000000000000000000000000000000000000000000000000000000000000000e25"),
    2468          cpp_float("3.868562622766813359059763200000000000000000000000000000000000000000000000000000000000000000000000000e25"),
    2469          cpp_float("7.737125245533626718119526400000000000000000000000000000000000000000000000000000000000000000000000000e25"),
    2470          cpp_float("1.547425049106725343623905280000000000000000000000000000000000000000000000000000000000000000000000000e26"),
    2471          cpp_float("3.094850098213450687247810560000000000000000000000000000000000000000000000000000000000000000000000000e26"),
    2472          cpp_float("6.189700196426901374495621120000000000000000000000000000000000000000000000000000000000000000000000000e26"),
    2473          cpp_float("1.237940039285380274899124224000000000000000000000000000000000000000000000000000000000000000000000000e27"),
    2474          cpp_float("2.475880078570760549798248448000000000000000000000000000000000000000000000000000000000000000000000000e27"),
    2475          cpp_float("4.951760157141521099596496896000000000000000000000000000000000000000000000000000000000000000000000000e27"),
    2476          cpp_float("9.903520314283042199192993792000000000000000000000000000000000000000000000000000000000000000000000000e27"),
    2477          cpp_float("1.980704062856608439838598758400000000000000000000000000000000000000000000000000000000000000000000000e28"),
    2478          cpp_float("3.961408125713216879677197516800000000000000000000000000000000000000000000000000000000000000000000000e28"),
    2479          cpp_float("7.922816251426433759354395033600000000000000000000000000000000000000000000000000000000000000000000000e28"),
    2480          cpp_float("1.584563250285286751870879006720000000000000000000000000000000000000000000000000000000000000000000000e29"),
    2481          cpp_float("3.169126500570573503741758013440000000000000000000000000000000000000000000000000000000000000000000000e29"),
    2482          cpp_float("6.338253001141147007483516026880000000000000000000000000000000000000000000000000000000000000000000000e29"),
    2483          cpp_float("1.267650600228229401496703205376000000000000000000000000000000000000000000000000000000000000000000000e30"),
    2484          cpp_float("2.535301200456458802993406410752000000000000000000000000000000000000000000000000000000000000000000000e30"),
    2485          cpp_float("5.070602400912917605986812821504000000000000000000000000000000000000000000000000000000000000000000000e30"),
    2486          cpp_float("1.014120480182583521197362564300800000000000000000000000000000000000000000000000000000000000000000000e31"),
    2487          cpp_float("2.028240960365167042394725128601600000000000000000000000000000000000000000000000000000000000000000000e31"),
    2488          cpp_float("4.056481920730334084789450257203200000000000000000000000000000000000000000000000000000000000000000000e31"),
    2489          cpp_float("8.112963841460668169578900514406400000000000000000000000000000000000000000000000000000000000000000000e31"),
    2490          cpp_float("1.622592768292133633915780102881280000000000000000000000000000000000000000000000000000000000000000000e32"),
    2491          cpp_float("3.245185536584267267831560205762560000000000000000000000000000000000000000000000000000000000000000000e32"),
    2492          cpp_float("6.490371073168534535663120411525120000000000000000000000000000000000000000000000000000000000000000000e32"),
    2493          cpp_float("1.298074214633706907132624082305024000000000000000000000000000000000000000000000000000000000000000000e33"),
    2494          cpp_float("2.596148429267413814265248164610048000000000000000000000000000000000000000000000000000000000000000000e33"),
    2495          cpp_float("5.192296858534827628530496329220096000000000000000000000000000000000000000000000000000000000000000000e33"),
    2496          cpp_float("1.038459371706965525706099265844019200000000000000000000000000000000000000000000000000000000000000000e34"),
    2497          cpp_float("2.076918743413931051412198531688038400000000000000000000000000000000000000000000000000000000000000000e34"),
    2498          cpp_float("4.153837486827862102824397063376076800000000000000000000000000000000000000000000000000000000000000000e34"),
    2499          cpp_float("8.307674973655724205648794126752153600000000000000000000000000000000000000000000000000000000000000000e34"),
    2500          cpp_float("1.661534994731144841129758825350430720000000000000000000000000000000000000000000000000000000000000000e35"),
    2501          cpp_float("3.323069989462289682259517650700861440000000000000000000000000000000000000000000000000000000000000000e35"),
    2502          cpp_float("6.646139978924579364519035301401722880000000000000000000000000000000000000000000000000000000000000000e35"),
    2503          cpp_float("1.329227995784915872903807060280344576000000000000000000000000000000000000000000000000000000000000000e36"),
    2504          cpp_float("2.658455991569831745807614120560689152000000000000000000000000000000000000000000000000000000000000000e36"),
    2505          cpp_float("5.316911983139663491615228241121378304000000000000000000000000000000000000000000000000000000000000000e36"),
    2506          cpp_float("1.063382396627932698323045648224275660800000000000000000000000000000000000000000000000000000000000000e37"),
    2507          cpp_float("2.126764793255865396646091296448551321600000000000000000000000000000000000000000000000000000000000000e37"),
    2508          cpp_float("4.253529586511730793292182592897102643200000000000000000000000000000000000000000000000000000000000000e37"),
    2509          cpp_float("8.507059173023461586584365185794205286400000000000000000000000000000000000000000000000000000000000000e37"),
    2510          cpp_float("1.701411834604692317316873037158841057280000000000000000000000000000000000000000000000000000000000000e38")
     2385         cpp_dec_float(static_cast<unsigned long long>(4)),
     2386         cpp_dec_float(static_cast<unsigned long long>(8)),
     2387         cpp_dec_float(static_cast<unsigned long long>(16)),
     2388         cpp_dec_float(static_cast<unsigned long long>(32)),
     2389         cpp_dec_float(static_cast<unsigned long long>(64)),
     2390         cpp_dec_float(static_cast<unsigned long long>(128)),
     2391         cpp_dec_float(static_cast<unsigned long long>(256)),
     2392         cpp_dec_float(static_cast<unsigned long long>(512)),
     2393         cpp_dec_float(static_cast<unsigned long long>(1024)),
     2394         cpp_dec_float(static_cast<unsigned long long>(2048)),
     2395         cpp_dec_float(static_cast<unsigned long long>(4096)),
     2396         cpp_dec_float(static_cast<unsigned long long>(8192)),
     2397         cpp_dec_float(static_cast<unsigned long long>(16384)),
     2398         cpp_dec_float(static_cast<unsigned long long>(32768)),
     2399         cpp_dec_float(static_cast<unsigned long long>(65536)),
     2400         cpp_dec_float(static_cast<unsigned long long>(131072)),
     2401         cpp_dec_float(static_cast<unsigned long long>(262144)),
     2402         cpp_dec_float(static_cast<unsigned long long>(524288)),
     2403         cpp_dec_float(static_cast<boost::uint64_t>(1uL << 20u)),
     2404         cpp_dec_float(static_cast<boost::uint64_t>(1uL << 21u)),
     2405         cpp_dec_float(static_cast<boost::uint64_t>(1uL << 22u)),
     2406         cpp_dec_float(static_cast<boost::uint64_t>(1uL << 23u)),
     2407         cpp_dec_float(static_cast<boost::uint64_t>(1uL << 24u)),
     2408         cpp_dec_float(static_cast<boost::uint64_t>(1uL << 25u)),
     2409         cpp_dec_float(static_cast<boost::uint64_t>(1uL << 26u)),
     2410         cpp_dec_float(static_cast<boost::uint64_t>(1uL << 27u)),
     2411         cpp_dec_float(static_cast<boost::uint64_t>(1uL << 28u)),
     2412         cpp_dec_float(static_cast<boost::uint64_t>(1uL << 29u)),
     2413         cpp_dec_float(static_cast<boost::uint64_t>(1uL << 30u)),
     2414         cpp_dec_float(static_cast<boost::uint64_t>(1uL << 31u)),
     2415         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 32u)),
     2416         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 33u)),
     2417         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 34u)),
     2418         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 35u)),
     2419         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 36u)),
     2420         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 37u)),
     2421         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 38u)),
     2422         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 39u)),
     2423         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 40u)),
     2424         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 41u)),
     2425         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 42u)),
     2426         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 43u)),
     2427         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 44u)),
     2428         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 45u)),
     2429         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 46u)),
     2430         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 47u)),
     2431         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 48u)),
     2432         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 49u)),
     2433         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 50u)),
     2434         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 51u)),
     2435         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 52u)),
     2436         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 53u)),
     2437         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 54u)),
     2438         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 55u)),
     2439         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 56u)),
     2440         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 57u)),
     2441         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 58u)),
     2442         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 59u)),
     2443         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 60u)),
     2444         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 61u)),
     2445         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 62u)),
     2446         cpp_dec_float(static_cast<boost::uint64_t>(1uLL << 63u)),
     2447         cpp_dec_float("1.844674407370955161600000000000000000000000000000000000000000000000000000000000000000000000000000000e19"),
     2448         cpp_dec_float("3.689348814741910323200000000000000000000000000000000000000000000000000000000000000000000000000000000e19"),
     2449         cpp_dec_float("7.378697629483820646400000000000000000000000000000000000000000000000000000000000000000000000000000000e19"),
     2450         cpp_dec_float("1.475739525896764129280000000000000000000000000000000000000000000000000000000000000000000000000000000e20"),
     2451         cpp_dec_float("2.951479051793528258560000000000000000000000000000000000000000000000000000000000000000000000000000000e20"),
     2452         cpp_dec_float("5.902958103587056517120000000000000000000000000000000000000000000000000000000000000000000000000000000e20"),
     2453         cpp_dec_float("1.180591620717411303424000000000000000000000000000000000000000000000000000000000000000000000000000000e21"),
     2454         cpp_dec_float("2.361183241434822606848000000000000000000000000000000000000000000000000000000000000000000000000000000e21"),
     2455         cpp_dec_float("4.722366482869645213696000000000000000000000000000000000000000000000000000000000000000000000000000000e21"),
     2456         cpp_dec_float("9.444732965739290427392000000000000000000000000000000000000000000000000000000000000000000000000000000e21"),
     2457         cpp_dec_float("1.888946593147858085478400000000000000000000000000000000000000000000000000000000000000000000000000000e22"),
     2458         cpp_dec_float("3.777893186295716170956800000000000000000000000000000000000000000000000000000000000000000000000000000e22"),
     2459         cpp_dec_float("7.555786372591432341913600000000000000000000000000000000000000000000000000000000000000000000000000000e22"),
     2460         cpp_dec_float("1.511157274518286468382720000000000000000000000000000000000000000000000000000000000000000000000000000e23"),
     2461         cpp_dec_float("3.022314549036572936765440000000000000000000000000000000000000000000000000000000000000000000000000000e23"),
     2462         cpp_dec_float("6.044629098073145873530880000000000000000000000000000000000000000000000000000000000000000000000000000e23"),
     2463         cpp_dec_float("1.208925819614629174706176000000000000000000000000000000000000000000000000000000000000000000000000000e24"),
     2464         cpp_dec_float("2.417851639229258349412352000000000000000000000000000000000000000000000000000000000000000000000000000e24"),
     2465         cpp_dec_float("4.835703278458516698824704000000000000000000000000000000000000000000000000000000000000000000000000000e24"),
     2466         cpp_dec_float("9.671406556917033397649408000000000000000000000000000000000000000000000000000000000000000000000000000e24"),
     2467         cpp_dec_float("1.934281311383406679529881600000000000000000000000000000000000000000000000000000000000000000000000000e25"),
     2468         cpp_dec_float("3.868562622766813359059763200000000000000000000000000000000000000000000000000000000000000000000000000e25"),
     2469         cpp_dec_float("7.737125245533626718119526400000000000000000000000000000000000000000000000000000000000000000000000000e25"),
     2470         cpp_dec_float("1.547425049106725343623905280000000000000000000000000000000000000000000000000000000000000000000000000e26"),
     2471         cpp_dec_float("3.094850098213450687247810560000000000000000000000000000000000000000000000000000000000000000000000000e26"),
     2472         cpp_dec_float("6.189700196426901374495621120000000000000000000000000000000000000000000000000000000000000000000000000e26"),
     2473         cpp_dec_float("1.237940039285380274899124224000000000000000000000000000000000000000000000000000000000000000000000000e27"),
     2474         cpp_dec_float("2.475880078570760549798248448000000000000000000000000000000000000000000000000000000000000000000000000e27"),
     2475         cpp_dec_float("4.951760157141521099596496896000000000000000000000000000000000000000000000000000000000000000000000000e27"),
     2476         cpp_dec_float("9.903520314283042199192993792000000000000000000000000000000000000000000000000000000000000000000000000e27"),
     2477         cpp_dec_float("1.980704062856608439838598758400000000000000000000000000000000000000000000000000000000000000000000000e28"),
     2478         cpp_dec_float("3.961408125713216879677197516800000000000000000000000000000000000000000000000000000000000000000000000e28"),
     2479         cpp_dec_float("7.922816251426433759354395033600000000000000000000000000000000000000000000000000000000000000000000000e28"),
     2480         cpp_dec_float("1.584563250285286751870879006720000000000000000000000000000000000000000000000000000000000000000000000e29"),
     2481         cpp_dec_float("3.169126500570573503741758013440000000000000000000000000000000000000000000000000000000000000000000000e29"),
     2482         cpp_dec_float("6.338253001141147007483516026880000000000000000000000000000000000000000000000000000000000000000000000e29"),
     2483         cpp_dec_float("1.267650600228229401496703205376000000000000000000000000000000000000000000000000000000000000000000000e30"),
     2484         cpp_dec_float("2.535301200456458802993406410752000000000000000000000000000000000000000000000000000000000000000000000e30"),
     2485         cpp_dec_float("5.070602400912917605986812821504000000000000000000000000000000000000000000000000000000000000000000000e30"),
     2486         cpp_dec_float("1.014120480182583521197362564300800000000000000000000000000000000000000000000000000000000000000000000e31"),
     2487         cpp_dec_float("2.028240960365167042394725128601600000000000000000000000000000000000000000000000000000000000000000000e31"),
     2488         cpp_dec_float("4.056481920730334084789450257203200000000000000000000000000000000000000000000000000000000000000000000e31"),
     2489         cpp_dec_float("8.112963841460668169578900514406400000000000000000000000000000000000000000000000000000000000000000000e31"),
     2490         cpp_dec_float("1.622592768292133633915780102881280000000000000000000000000000000000000000000000000000000000000000000e32"),
     2491         cpp_dec_float("3.245185536584267267831560205762560000000000000000000000000000000000000000000000000000000000000000000e32"),
     2492         cpp_dec_float("6.490371073168534535663120411525120000000000000000000000000000000000000000000000000000000000000000000e32"),
     2493         cpp_dec_float("1.298074214633706907132624082305024000000000000000000000000000000000000000000000000000000000000000000e33"),
     2494         cpp_dec_float("2.596148429267413814265248164610048000000000000000000000000000000000000000000000000000000000000000000e33"),
     2495         cpp_dec_float("5.192296858534827628530496329220096000000000000000000000000000000000000000000000000000000000000000000e33"),
     2496         cpp_dec_float("1.038459371706965525706099265844019200000000000000000000000000000000000000000000000000000000000000000e34"),
     2497         cpp_dec_float("2.076918743413931051412198531688038400000000000000000000000000000000000000000000000000000000000000000e34"),
     2498         cpp_dec_float("4.153837486827862102824397063376076800000000000000000000000000000000000000000000000000000000000000000e34"),
     2499         cpp_dec_float("8.307674973655724205648794126752153600000000000000000000000000000000000000000000000000000000000000000e34"),
     2500         cpp_dec_float("1.661534994731144841129758825350430720000000000000000000000000000000000000000000000000000000000000000e35"),
     2501         cpp_dec_float("3.323069989462289682259517650700861440000000000000000000000000000000000000000000000000000000000000000e35"),
     2502         cpp_dec_float("6.646139978924579364519035301401722880000000000000000000000000000000000000000000000000000000000000000e35"),
     2503         cpp_dec_float("1.329227995784915872903807060280344576000000000000000000000000000000000000000000000000000000000000000e36"),
     2504         cpp_dec_float("2.658455991569831745807614120560689152000000000000000000000000000000000000000000000000000000000000000e36"),
     2505         cpp_dec_float("5.316911983139663491615228241121378304000000000000000000000000000000000000000000000000000000000000000e36"),
     2506         cpp_dec_float("1.063382396627932698323045648224275660800000000000000000000000000000000000000000000000000000000000000e37"),
     2507         cpp_dec_float("2.126764793255865396646091296448551321600000000000000000000000000000000000000000000000000000000000000e37"),
     2508         cpp_dec_float("4.253529586511730793292182592897102643200000000000000000000000000000000000000000000000000000000000000e37"),
     2509         cpp_dec_float("8.507059173023461586584365185794205286400000000000000000000000000000000000000000000000000000000000000e37"),
     2510         cpp_dec_float("1.701411834604692317316873037158841057280000000000000000000000000000000000000000000000000000000000000e38")
    25112511   }};
    25122512
     
    25242524   {
    25252525      const boost::uint64_t p2 = static_cast<boost::uint64_t>(static_cast<boost::uint64_t>(1uLL) << p);
    2526       return cpp_float(p2);
     2526      return cpp_dec_float(p2);
    25272527   }
    25282528   else
    25292529   {
    2530       cpp_float<Digits10> t;
     2530      cpp_dec_float<Digits10> t;
    25312531      default_ops::detail::pow_imp(t, two(), p, mpl::true_());
    25322532      return t;
     
    25362536
    25372537template <unsigned Digits10>
    2538 inline void add(cpp_float<Digits10>& result, const cpp_float<Digits10>& o)
     2538inline void add(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& o)
    25392539{
    25402540   result += o;
    25412541}
    25422542template <unsigned Digits10>
    2543 inline void subtract(cpp_float<Digits10>& result, const cpp_float<Digits10>& o)
     2543inline void subtract(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& o)
    25442544{
    25452545   result -= o;
    25462546}
    25472547template <unsigned Digits10>
    2548 inline void multiply(cpp_float<Digits10>& result, const cpp_float<Digits10>& o)
     2548inline void multiply(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& o)
    25492549{
    25502550   result *= o;
    25512551}
    25522552template <unsigned Digits10>
    2553 inline void divide(cpp_float<Digits10>& result, const cpp_float<Digits10>& o)
     2553inline void divide(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& o)
    25542554{
    25552555   result /= o;
     
    25572557
    25582558template <unsigned Digits10>
    2559 inline void add(cpp_float<Digits10>& result, const unsigned long long& o)
     2559inline void add(cpp_dec_float<Digits10>& result, const unsigned long long& o)
    25602560{
    25612561   result.add_unsigned_long_long(o);
    25622562}
    25632563template <unsigned Digits10>
    2564 inline void subtract(cpp_float<Digits10>& result, const unsigned long long& o)
     2564inline void subtract(cpp_dec_float<Digits10>& result, const unsigned long long& o)
    25652565{
    25662566   result.sub_unsigned_long_long(o);
    25672567}
    25682568template <unsigned Digits10>
    2569 inline void multiply(cpp_float<Digits10>& result, const unsigned long long& o)
     2569inline void multiply(cpp_dec_float<Digits10>& result, const unsigned long long& o)
    25702570{
    25712571   result.mul_unsigned_long_long(o);
    25722572}
    25732573template <unsigned Digits10>
    2574 inline void divide(cpp_float<Digits10>& result, const unsigned long long& o)
     2574inline void divide(cpp_dec_float<Digits10>& result, const unsigned long long& o)
    25752575{
    25762576   result.div_unsigned_long_long(o);
     
    25782578
    25792579template <unsigned Digits10>
    2580 inline void add(cpp_float<Digits10>& result, long long o)
     2580inline void add(cpp_dec_float<Digits10>& result, long long o)
    25812581{
    25822582   if(o < 0)
     
    25862586}
    25872587template <unsigned Digits10>
    2588 inline void subtract(cpp_float<Digits10>& result, long long o)
     2588inline void subtract(cpp_dec_float<Digits10>& result, long long o)
    25892589{
    25902590   if(o < 0)
     
    25942594}
    25952595template <unsigned Digits10>
    2596 inline void multiply(cpp_float<Digits10>& result, long long o)
     2596inline void multiply(cpp_dec_float<Digits10>& result, long long o)
    25972597{
    25982598   if(o < 0)
     
    26052605}
    26062606template <unsigned Digits10>
    2607 inline void divide(cpp_float<Digits10>& result, long long o)
     2607inline void divide(cpp_dec_float<Digits10>& result, long long o)
    26082608{
    26092609   if(o < 0)
     
    26172617
    26182618template <unsigned Digits10>
    2619 inline void convert_to(unsigned long long* result, const cpp_float<Digits10>& val)
     2619inline void convert_to(unsigned long long* result, const cpp_dec_float<Digits10>& val)
    26202620{
    26212621   *result = val.extract_unsigned_long_long();
    26222622}
    26232623template <unsigned Digits10>
    2624 inline void convert_to(long long* result, const cpp_float<Digits10>& val)
     2624inline void convert_to(long long* result, const cpp_dec_float<Digits10>& val)
    26252625{
    26262626   *result = val.extract_signed_long_long();
    26272627}
    26282628template <unsigned Digits10>
    2629 inline void convert_to(long double* result, cpp_float<Digits10>& val)
     2629inline void convert_to(long double* result, cpp_dec_float<Digits10>& val)
    26302630{
    26312631   *result = val.extract_long_double();
     
    26362636//
    26372637template <unsigned Digits10>
    2638 inline int eval_fpclassify(const cpp_float<Digits10>& x)
     2638inline int eval_fpclassify(const cpp_dec_float<Digits10>& x)
    26392639{
    26402640   if(x.isinf())
     
    26482648
    26492649template <unsigned Digits10>
    2650 inline void eval_abs(cpp_float<Digits10>& result, const cpp_float<Digits10>& x)
     2650inline void eval_abs(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& x)
    26512651{
    26522652   result = x;
     
    26562656
    26572657template <unsigned Digits10>
    2658 inline void eval_fabs(cpp_float<Digits10>& result, const cpp_float<Digits10>& x)
     2658inline void eval_fabs(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& x)
    26592659{
    26602660   result = x;
     
    26642664
    26652665template <unsigned Digits10>
    2666 inline void eval_sqrt(cpp_float<Digits10>& result, const cpp_float<Digits10>& x)
     2666inline void eval_sqrt(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& x)
    26672667{
    26682668   result = x;
     
    26712671
    26722672template <unsigned Digits10>
    2673 inline void eval_floor(cpp_float<Digits10>& result, const cpp_float<Digits10>& x)
     2673inline void eval_floor(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& x)
    26742674{
    26752675   result = x;
     
    26802680
    26812681   if(x.isneg())
    2682       result -= cpp_float<Digits10>::one();
     2682      result -= cpp_dec_float<Digits10>::one();
    26832683   result = result.extract_integer_part();
    26842684}
    26852685
    26862686template <unsigned Digits10>
    2687 inline void eval_ceil(cpp_float<Digits10>& result, const cpp_float<Digits10>& x)
     2687inline void eval_ceil(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& x)
    26882688{
    26892689   result = x;
     
    26942694
    26952695   if(!x.isneg())
    2696       result += cpp_float<Digits10>::one();
     2696      result += cpp_dec_float<Digits10>::one();
    26972697   result = result.extract_integer_part();
    26982698}
    26992699
    27002700template <unsigned Digits10>
    2701 inline void eval_trunc(cpp_float<Digits10>& result, const cpp_float<Digits10>& x)
     2701inline void eval_trunc(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& x)
    27022702{
    27032703   if(!x.isfinite())
    27042704   {
    2705       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();
     2705      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();
    27062706      return;
    27072707   }
     
    27152715
    27162716template <unsigned Digits10>
    2717 inline void eval_ldexp(cpp_float<Digits10>& result, const cpp_float<Digits10>& x, long long e)
     2717inline void eval_ldexp(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& x, long long e)
    27182718{
    27192719   result = x;
    2720    result *= cpp_float<Digits10>::pow2(e);
    2721 }
    2722 
    2723 template <unsigned Digits10>
    2724 inline void eval_frexp(cpp_float<Digits10>& result, const cpp_float<Digits10>& x, long long* e)
     2720   result *= cpp_dec_float<Digits10>::pow2(e);
     2721}
     2722
     2723template <unsigned Digits10>
     2724inline void eval_frexp(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& x, long long* e)
    27252725{
    27262726   result = x;
     
    27472747   }
    27482748
    2749    result *= cpp_float<Digits10>::pow2(-t);
     2749   result *= cpp_dec_float<Digits10>::pow2(-t);
    27502750
    27512751   if(result.iszero() || result.isinf() || result.isnan())
     
    27562756         result.negate();
    27572757      t /= 2;
    2758       result *= cpp_float<Digits10>::pow2(-t);
     2758      result *= cpp_dec_float<Digits10>::pow2(-t);
    27592759   }
    27602760   BOOST_MP_USING_ABS
     
    27632763      // If our first estimate doesn't get close enough then try recursion until we do:
    27642764      long long e2;
    2765       cpp_float<Digits10> r2;
     2765      cpp_dec_float<Digits10> r2;
    27662766      eval_frexp(r2, result, &e2);
    27672767      // overflow prtection:
     
    27742774   }
    27752775
    2776    while(result.compare(cpp_float<Digits10>::one()) >= 0)
    2777    {
    2778       result /= cpp_float<Digits10>::two();
     2776   while(result.compare(cpp_dec_float<Digits10>::one()) >= 0)
     2777   {
     2778      result /= cpp_dec_float<Digits10>::two();
    27792779      ++t;
    27802780   }
    2781    while(result.compare(cpp_float<Digits10>::half()) < 0)
    2782    {
    2783       result *= cpp_float<Digits10>::two();
     2781   while(result.compare(cpp_dec_float<Digits10>::half()) < 0)
     2782   {
     2783      result *= cpp_dec_float<Digits10>::two();
    27842784      --t;
    27852785   }
     
    27902790
    27912791template <unsigned Digits10>
    2792 inline void eval_frexp(cpp_float<Digits10>& result, const cpp_float<Digits10>& x, int* e)
     2792inline void eval_frexp(cpp_dec_float<Digits10>& result, const cpp_dec_float<Digits10>& x, int* e)
    27932793{
    27942794   long long t;
     
    28002800
    28012801template <unsigned Digits10>
    2802 inline bool is_zero(const cpp_float<Digits10>& val)
     2802inline bool is_zero(const cpp_dec_float<Digits10>& val)
    28032803{
    28042804   return val.iszero();
    28052805}
    28062806template <unsigned Digits10>
    2807 inline int get_sign(const cpp_float<Digits10>& val)
     2807inline int get_sign(const cpp_dec_float<Digits10>& val)
    28082808{
    28092809   return val.iszero() ? 0 : val.isneg() ? -1 : 1;
     
    28112811
    28122812
    2813 typedef mp_number<cpp_float<50> > cpp_float_50;
    2814 typedef mp_number<cpp_float<100> > cpp_float_100;
     2813typedef mp_number<cpp_dec_float<50> > cpp_float_50;
     2814typedef mp_number<cpp_dec_float<100> > cpp_float_100;
    28152815
    28162816}}
     
    28192819{
    28202820   template <unsigned Digits10>
    2821    class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > >
     2821   class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10> > >
    28222822   {
    28232823   public:
     
    28302830      static const bool                    is_iec559         = false;
    28312831      static const int                     digits            = Digits10;
    2832       static const int                     digits10          = boost::multiprecision::cpp_float<Digits10>::cpp_float_digits10;
    2833       static const int                     max_digits10      = boost::multiprecision::cpp_float<Digits10>::cpp_float_max_digits10;
    2834       static const boost::int64_t          min_exponent      = boost::multiprecision::cpp_float<Digits10>::cpp_float_min_exp;      // Type differs from int.
    2835       static const boost::int64_t          min_exponent10    = boost::multiprecision::cpp_float<Digits10>::cpp_float_min_exp10;    // Type differs from int.
    2836       static const boost::int64_t          max_exponent      = boost::multiprecision::cpp_float<Digits10>::cpp_float_max_exp;      // Type differs from int.
    2837       static const boost::int64_t          max_exponent10    = boost::multiprecision::cpp_float<Digits10>::cpp_float_max_exp10;    // Type differs from int.
    2838       static const int                     radix             = boost::multiprecision::cpp_float<Digits10>::mp_radix;
     2832      static const int                     digits10          = boost::multiprecision::cpp_dec_float<Digits10>::cpp_float_digits10;
     2833      static const int                     max_digits10      = boost::multiprecision::cpp_dec_float<Digits10>::cpp_float_max_digits10;
     2834      static const boost::int64_t          min_exponent      = boost::multiprecision::cpp_dec_float<Digits10>::cpp_float_min_exp;      // Type differs from int.
     2835      static const boost::int64_t          min_exponent10    = boost::multiprecision::cpp_dec_float<Digits10>::cpp_float_min_exp10;    // Type differs from int.
     2836      static const boost::int64_t          max_exponent      = boost::multiprecision::cpp_dec_float<Digits10>::cpp_float_max_exp;      // Type differs from int.
     2837      static const boost::int64_t          max_exponent10    = boost::multiprecision::cpp_dec_float<Digits10>::cpp_float_max_exp10;    // Type differs from int.
     2838      static const int                     radix             = boost::multiprecision::cpp_dec_float<Digits10>::mp_radix;
    28392839      static const std::float_round_style  round_style       = std::round_to_nearest;
    28402840      static const bool                    has_infinity      = true;
     
    28462846      static const bool                    tinyness_before   = false;
    28472847
    2848       static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > (min)        (void)  { return (boost::multiprecision::cpp_float<Digits10>::min)(); }
    2849       static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > (max)        (void)  { return (boost::multiprecision::cpp_float<Digits10>::max)(); }
    2850       static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > lowest       (void)  { return boost::multiprecision::cpp_float<Digits10>::zero(); }
    2851       static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > epsilon      (void)  { return boost::multiprecision::cpp_float<Digits10>::eps(); }
    2852       static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > round_error  (void)  { return 0.5L; }
    2853       static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > infinity     (void)  { return boost::multiprecision::cpp_float<Digits10>::inf(); }
    2854       static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > quiet_NaN    (void)  { return boost::multiprecision::cpp_float<Digits10>::nan(); }
    2855       static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > signaling_NaN(void)  { return boost::multiprecision::cpp_float<Digits10>::zero(); }
    2856       static const boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> > denorm_min   (void)  { return boost::multiprecision::cpp_float<Digits10>::zero(); }
     2848      static const boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10> > (min)        (void)  { return (boost::multiprecision::cpp_dec_float<Digits10>::min)(); }
     2849      static const boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10> > (max)        (void)  { return (boost::multiprecision::cpp_dec_float<Digits10>::max)(); }
     2850      static const boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10> > lowest       (void)  { return boost::multiprecision::cpp_dec_float<Digits10>::zero(); }
     2851      static const boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10> > epsilon      (void)  { return boost::multiprecision::cpp_dec_float<Digits10>::eps(); }
     2852      static const boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10> > round_error  (void)  { return 0.5L; }
     2853      static const boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10> > infinity     (void)  { return boost::multiprecision::cpp_dec_float<Digits10>::inf(); }
     2854      static const boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10> > quiet_NaN    (void)  { return boost::multiprecision::cpp_dec_float<Digits10>::nan(); }
     2855      static const boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10> > signaling_NaN(void)  { return boost::multiprecision::cpp_dec_float<Digits10>::zero(); }
     2856      static const boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10> > denorm_min   (void)  { return boost::multiprecision::cpp_dec_float<Digits10>::zero(); }
    28572857   };
    28582858}
     
    28632863
    28642864template <unsigned Digits10, class Policy>
    2865 struct precision< boost::multiprecision::mp_number<boost::multiprecision::cpp_float<Digits10> >, Policy>
     2865struct precision< boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10> >, Policy>
    28662866{
    28672867   typedef typename Policy::precision_type precision_type;
  • sandbox/big_number/boost/multiprecision/detail/default_ops.hpp

    r76706 r77032  
    406406void eval_fabs(T& result, const T& arg)
    407407{
    408    BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The fabs function is only valid for floating point types.");
     408   BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The fabs function is only valid for floating point types.");
    409409   typedef typename T::signed_types type_list;
    410410   typedef typename mpl::front<type_list>::type front;
     
    424424inline void eval_fmod(T& result, const T& a, const T& b)
    425425{
    426    BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The fmod function is only valid for floating point types.");
     426   BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The fmod function is only valid for floating point types.");
    427427   if((&result == &a) || (&result == &b))
    428428   {
     
    444444inline void eval_trunc(T& result, const T& a)
    445445{
    446    BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The trunc function is only valid for floating point types.");
     446   BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The trunc function is only valid for floating point types.");
    447447   int c = eval_fpclassify(a);
    448448   if(c == FP_NAN || c == FP_INFINITE)
     
    460460inline void eval_round(T& result, const T& a)
    461461{
    462    BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The round function is only valid for floating point types.");
     462   BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The round function is only valid for floating point types.");
    463463   typedef typename boost::multiprecision::detail::canonical<float, T>::type fp_type;
    464464   int c = eval_fpclassify(a);
  • sandbox/big_number/boost/multiprecision/detail/functions/pow.hpp

    r76706 r77032  
    8787inline void eval_pow(T& result, const T& t, const U& p)
    8888{
    89    BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The pow function is only valid for floating point types.");
     89   BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The pow function is only valid for floating point types.");
    9090   typedef typename is_integral<U>::type tag_type;
    9191   detail::pow_imp(result, t, p, tag_type());
     
    186186void eval_exp(T& result, const T& x)
    187187{
    188    BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The ldexp function is only valid for floating point types.");
     188   BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The ldexp function is only valid for floating point types.");
    189189   if(&x == &result)
    190190   {
     
    326326void eval_log(T& result, const T& arg)
    327327{
    328    BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The log function is only valid for floating point types.");
     328   BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The log function is only valid for floating point types.");
    329329   //
    330330   // We use a variation of http://dlmf.nist.gov/4.45#i
     
    414414void eval_log10(T& result, const T& arg)
    415415{
    416    BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The fabs function is only valid for floating point types.");
     416   BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The fabs function is only valid for floating point types.");
    417417   eval_log(result, arg);
    418418   divide(result, get_constant_log10<T>());
     
    422422inline void eval_pow(T& result, const T& x, const T& a)
    423423{
    424    BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The pow function is only valid for floating point types.");
     424   BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The pow function is only valid for floating point types.");
    425425   typedef typename boost::multiprecision::detail::canonical<int, T>::type si_type;
    426426   typedef typename boost::multiprecision::detail::canonical<unsigned, T>::type ui_type;
     
    642642inline void eval_sinh(T& result, const T& x)
    643643{
    644    BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The sinh function is only valid for floating point types.");
     644   BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The sinh function is only valid for floating point types.");
    645645   detail::sinhcosh(x, &result, static_cast<T*>(0));
    646646}
     
    649649inline void eval_cosh(T& result, const T& x)
    650650{
    651    BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The cosh function is only valid for floating point types.");
     651   BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The cosh function is only valid for floating point types.");
    652652   detail::sinhcosh(x, static_cast<T*>(0), &result);
    653653}
     
    656656inline void eval_tanh(T& result, const T& x)
    657657{
    658    BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The tanh function is only valid for floating point types.");
     658   BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The tanh function is only valid for floating point types.");
    659659  T c;
    660660  detail::sinhcosh(x, &result, &c);
  • sandbox/big_number/boost/multiprecision/detail/functions/trig.hpp

    r76706 r77032  
    6969void eval_sin(T& result, const T& x)
    7070{
    71    BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The sin function is only valid for floating point types.");
     71   BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The sin function is only valid for floating point types.");
    7272   if(&result == &x)
    7373   {
     
    215215void eval_cos(T& result, const T& x)
    216216{
    217    BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The cos function is only valid for floating point types.");
     217   BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The cos function is only valid for floating point types.");
    218218   if(&result == &x)
    219219   {
     
    358358void eval_tan(T& result, const T& x)
    359359{
    360    BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The tan function is only valid for floating point types.");
     360   BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The tan function is only valid for floating point types.");
    361361   T t;
    362362   eval_sin(result, x);
     
    430430void eval_asin(T& result, const T& x)
    431431{
    432    BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The asin function is only valid for floating point types.");
     432   BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The asin function is only valid for floating point types.");
    433433   typedef typename boost::multiprecision::detail::canonical<boost::int32_t, T>::type si_type;
    434434   typedef typename boost::multiprecision::detail::canonical<boost::uint32_t, T>::type ui_type;
     
    540540inline void eval_acos(T& result, const T& x)
    541541{
    542    BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The acos function is only valid for floating point types.");
     542   BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The acos function is only valid for floating point types.");
    543543   typedef typename boost::multiprecision::detail::canonical<boost::uint32_t, T>::type ui_type;
    544544
     
    582582void eval_atan(T& result, const T& x)
    583583{
    584    BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The atan function is only valid for floating point types.");
     584   BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The atan function is only valid for floating point types.");
    585585   typedef typename boost::multiprecision::detail::canonical<boost::int32_t, T>::type si_type;
    586586   typedef typename boost::multiprecision::detail::canonical<boost::uint32_t, T>::type ui_type;
     
    673673void eval_atan2(T& result, const T& y, const T& x)
    674674{
    675    BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The atan2 function is only valid for floating point types.");
     675   BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The atan2 function is only valid for floating point types.");
    676676   if(&result == &y)
    677677   {
     
    771771typename disable_if<is_same<T, Arithmetic> >::type eval_atan2(T& result, const T& a, const Arithmetic& b)
    772772{
    773    BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_floating_point, "The atan2 function is only valid for floating point types.");
     773   BOOST_STATIC_ASSERT_MSG(number_category<T>::value == number_kind_floating_point, "The atan2 function is only valid for floating point types.");
    774774   T x;
    775775   x = static_cast<typename boost::multiprecision::detail::canonical<Arithmetic, T>::type>(b);
  • sandbox/big_number/libs/multiprecision/doc/multiprecision.qbk

    r76653 r77032  
    323323[[`mpf_float<N>`][boost/multiprecision/gmp.hpp][2][[gmp]][Very fast and efficient backend.][Dependency on GNU licenced [gmp] library.]]
    324324[[`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.]]
    325 [[`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.]]
     325[[`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.]]
    326326]
    327327
     
    428428[mpfr_eg]
    429429
    430 [h4 cpp_float]
     430[h4 cpp_dec_float]
    431431
    432432   namespace boost{ namespace multiprecision{
    433433
    434434   template <unsigned Digits10>
    435    class cpp_float;
    436 
    437    typedef mp_number<cpp_float<50> > cpp_float_50;
    438    typedef mp_number<cpp_float<100> > cpp_float_100;
     435   class cpp_dec_float;
     436
     437   typedef mp_number<cpp_dec_float<50> > cpp_float_50;
     438   typedef mp_number<cpp_dec_float<100> > cpp_float_100;
    439439
    440440   }} // namespaces
    441441
    442 The `cpp_float` backend is used in conjunction with `mp_number`: It acts as an entirely C++ (header only and dependency free)
     442The `cpp_dec_float` backend is used in conjunction with `mp_number`: It acts as an entirely C++ (header only and dependency free)
    443443real-number type that is a drop-in replacement for the native C++ floating-point types, but with
    444444much greater precision.
    445445
    446 Type `cpp_float` can be used at fixed precision by specifying a non-zero `Digits10` template parameter. 
     446Type `cpp_dec_float` can be used at fixed precision by specifying a non-zero `Digits10` template parameter. 
    447447The typedefs cpp_float_50 and cpp_float_100 provide arithmetic types at 50 and 100 decimal digits precision
    448448respectively.
     
    452452Things you should know when using this type:
    453453
    454 * Default constructed `cpp_float`'s have a value of zero.
     454* Default constructed `cpp_dec_float`'s have a value of zero.
    455455* The radix of this type is 10.  As a result it can behave subtly differently from base-2 types.
    456456* It is not possible to round-trip this type to and from a string and get back to exactly the same value
     
    459459Normally these should not be visible to the user.
    460460
    461 [h5 cpp_float example:]
     461[h5 cpp_dec_float example:]
    462462
    463463[cpp_float_eg]
     
    11821182[[mpfr_float][[*1.0] (6.472s)][1.193 (10.154s)]]
    11831183[[mpf_float][1.801 (11.662s)][[*1.0](8.511s)]]
    1184 [[cpp_float][3.13 (20.285s)][2.46 (21.019s)]]
     1184[[cpp_dec_float][3.13 (20.285s)][2.46 (21.019s)]]
    11851185[[[mpfr_class]][1.001 (6.480s)][1.15(9.805s)]]
    11861186[[[mpreal]][1.542 (9.981s)][1.61 (13.702s)]]
     
    11911191[[mpfr_float][1.308 (258.09s)][1.30 (516.74s)]]
    11921192[[mpf_float][[*1.0] (197.30s)][[*1.0](397.30s)]]
    1193 [[cpp_float][1.695 (334.50s)][2.68 (1064.53s)]]
     1193[[cpp_dec_float][1.695 (334.50s)][2.68 (1064.53s)]]
    11941194[[[mpfr_class]][1.35 (266.39s)][1.323 (525.74s)]]
    11951195[[[mpreal]][1.75 (346.64s)][1.635 (649.94s)]]
     
    12131213[table Operator +
    12141214[[Backend][50 Decimal Digits][100 Decimal Digits][500 Decimal Digits]]
    1215 [[cpp_float][[*1] (0.02382s)][[*1] (0.0294619s)][[*1] (0.058466s)]]
     1215[[cpp_dec_float][[*1] (0.02382s)][[*1] (0.0294619s)][[*1] (0.058466s)]]
    12161216[[gmp_float][4.55086 (0.108402s)][3.86443 (0.113853s)][2.6241 (0.15342s)]]
    12171217[[mpfr_float][2.52036 (0.060035s)][2.1833 (0.0643242s)][1.37736 (0.0805287s)]]
     
    12191219[table Operator +(int)
    12201220[[Backend][50 Decimal Digits][100 Decimal Digits][500 Decimal Digits]]
    1221 [[cpp_float][1.56759 (0.0527023s)][1.74629 (0.0618102s)][1.68077 (0.105927s)]]
     1221[[cpp_dec_float][1.56759 (0.0527023s)][1.74629 (0.0618102s)][1.68077 (0.105927s)]]
    12221222[[gmp_float][[*1] (0.0336201s)][[*1] (0.0353951s)][[*1] (0.0630232s)]]
    12231223[[mpfr_float][3.14875 (0.105861s)][3.15499 (0.111671s)][1.92831 (0.121528s)]]
     
    12251225[table Operator -
    12261226[[Backend][50 Decimal Digits][100 Decimal Digits][500 Decimal Digits]]
    1227 [[cpp_float][[*1] (0.0265783s)][[*1] (0.031465s)][[*1] (0.0619405s)]]
     1227[[cpp_dec_float][[*1] (0.0265783s)][[*1] (0.031465s)][[*1] (0.0619405s)]]
    12281228[[gmp_float][4.66954 (0.124108s)][3.72645 (0.117253s)][2.67536 (0.165713s)]]
    12291229[[mpfr_float][2.7909 (0.0741774s)][2.48557 (0.0782083s)][1.50944 (0.0934957s)]]
     
    12311231[table Operator -(int)
    12321232[[Backend][50 Decimal Digits][100 Decimal Digits][500 Decimal Digits]]
    1233 [[cpp_float][[*1] (0.0577674s)][[*1] (0.0633795s)][[*1] (0.11146s)]]
     1233[[cpp_dec_float][[*1] (0.0577674s)][[*1] (0.0633795s)][[*1] (0.11146s)]]
    12341234[[gmp_float][2.31811 (0.133911s)][2.07251 (0.131355s)][1.67161 (0.186319s)]]
    12351235[[mpfr_float][2.45081 (0.141577s)][2.29174 (0.145249s)][1.395 (0.155487s)]]
     
    12371237[table Operator *
    12381238[[Backend][50 Decimal Digits][100 Decimal Digits][500 Decimal Digits]]
    1239 [[cpp_float][1.07276 (0.287898s)][1.47724 (0.584569s)][1.55145 (5.09969s)]]
     1239[[cpp_dec_float][1.07276 (0.287898s)][1.47724 (0.584569s)][1.55145 (5.09969s)]]
    12401240[[gmp_float][[*1] (0.268372s)][[*1] (0.395718s)][[*1] (3.28705s)]]
    12411241[[mpfr_float][1.27302 (0.341642s)][1.17649 (0.465557s)][1.14029 (3.7482s)]]
     
    12431243[table Operator *(int)
    12441244[[Backend][50 Decimal Digits][100 Decimal Digits][500 Decimal Digits]]
    1245 [[cpp_float][2.89945 (0.11959s)][4.56335 (0.197945s)][9.03602 (0.742044s)]]
     1245[[cpp_dec_float][2.89945 (0.11959s)][4.56335 (0.197945s)][9.03602 (0.742044s)]]
    12461246[[gmp_float][[*1] (0.0412457s)][[*1] (0.0433772s)][[*1] (0.0821206s)]]
    12471247[[mpfr_float][3.6951 (0.152407s)][3.71977 (0.161353s)][3.30958 (0.271785s)]]
     
    12491249[table Operator /
    12501250[[Backend][50 Decimal Digits][100 Decimal Digits][500 Decimal Digits]]
    1251 [[cpp_float][3.24327 (4.00108s)][5.00532 (8.12985s)][6.79566 (54.2796s)]]
     1251[[cpp_dec_float][3.24327 (4.00108s)][5.00532 (8.12985s)][6.79566 (54.2796s)]]
    12521252[[gmp_float][[*1] (1.23366s)][[*1] (1.62424s)][[*1] (7.9874s)]]
    12531253[[mpfr_float][1.32521 (1.63486s)][1.38967 (2.25716s)][1.72413 (13.7713s)]]
     
    12551255[table Operator /(int)
    12561256[[Backend][50 Decimal Digits][100 Decimal Digits][500 Decimal Digits]]
    1257 [[cpp_float][1.45093 (0.253675s)][1.83306 (0.419569s)][2.3644 (1.64187s)]]
     1257[[cpp_dec_float][1.45093 (0.253675s)][1.83306 (0.419569s)][2.3644 (1.64187s)]]
    12581258[[gmp_float][[*1] (0.174836s)][[*1] (0.22889s)][[*1] (0.694411s)]]
    12591259[[mpfr_float][1.16731 (0.204088s)][1.13211 (0.259127s)][1.02031 (0.708513s)]]
     
    12611261[table Operator str
    12621262[[Backend][50 Decimal Digits][100 Decimal Digits][500 Decimal Digits]]
    1263 [[cpp_float][1.4585 (0.0188303s)][1.55515 (0.03172s)][[*1] (0.131962s)]]
     1263[[cpp_dec_float][1.4585 (0.0188303s)][1.55515 (0.03172s)][[*1] (0.131962s)]]
    12641264[[gmp_float][[*1] (0.0129107s)][[*1] (0.0203967s)][1.04632 (0.138075s)]]
    12651265[[mpfr_float][2.19015 (0.0282764s)][1.84679 (0.0376683s)][1.20295 (0.158743s)]]
  • sandbox/big_number/libs/multiprecision/example/cpp_float_snips.cpp

    r75487 r77032  
    44//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_
    55
    6 #include <boost/multiprecision/cpp_float.hpp>
     6#include <boost/multiprecision/cpp_dec_float.hpp>
    77#include <iostream>
    88
     
    1010{
    1111   //[cpp_float_eg
    12    //=#include <boost/multiprecision/cpp_float.hpp>
     12   //=#include <boost/multiprecision/cpp_dec_float.hpp>
    1313
    1414   using namespace boost::multiprecision;
  • sandbox/big_number/libs/multiprecision/performance/Jamfile.v2

    r76652 r77032  
    5050          [ check-target-builds ../config//has_mpfr : <define>TEST_MPFR <source>mpfr : ]
    5151          [ check-target-builds ../config//has_tommath : <define>TEST_TOMMATH <source>$(TOMMATH) : ]
    52           <define>TEST_CPP_FLOAT
     52          <define>TEST_CPP_DEC_FLOAT
    5353          <define>TEST_FIXED_INT
    5454          ;
     
    5858          [ check-target-builds ../config//has_gmp : <define>TEST_MPF <define>TEST_MPZ <source>gmp : ]
    5959          [ check-target-builds ../config//has_mpfr : <define>TEST_MPFR <source>mpfr : ]
    60           <define>TEST_CPP_FLOAT
     60          <define>TEST_CPP_DEC_FLOAT
    6161          <toolset>msvc:<cxxflags>-bigobj
    6262          ;
     
    7676obj obj_linpack_benchmark_cpp_float : linpack-benchmark.cpp
    7777          : release
    78           <define>TEST_CPP_FLOAT
     78          <define>TEST_CPP_DEC_FLOAT
    7979          ;
    8080
     
    9999exe linpack_benchmark_cpp_float : obj_linpack_benchmark_cpp_float  f2c
    100100          : release
    101           <define>TEST_CPP_FLOAT
     101          <define>TEST_CPP_DEC_FLOAT
    102102          ;
    103103
  • sandbox/big_number/libs/multiprecision/performance/linpack-benchmark.cpp

    r76253 r77032  
    2626#include <gmpfrxx.h>
    2727typedef mpfr_class real_type;
    28 #elif defined(TEST_CPP_FLOAT)
    29 #include <boost/multiprecision/cpp_float.hpp>
     28#elif defined(TEST_CPP_DEC_FLOAT)
     29#include <boost/multiprecision/cpp_dec_float.hpp>
    3030typedef boost::multiprecision::cpp_float_50 real_type;
    3131#elif defined(TEST_MPFR_50)
     
    103103   std::cout << "Testing mpfr_class at 50 decimal degits" << std::endl;
    104104   mpfr_set_default_prec(((50 + 1) * 1000L) / 301L);
    105 #elif defined(TEST_CPP_FLOAT)
    106    std::cout << "Testing mp_number<cpp_float<50> >" << std::endl;
     105#elif defined(TEST_CPP_DEC_FLOAT)
     106   std::cout << "Testing mp_number<cpp_dec_float<50> >" << std::endl;
    107107#else
    108108   std::cout << "Testing double" << std::endl;
     
    912912#if defined(TEST_MPF_100) || defined(TEST_MPFR_100) || defined(TEST_GMPXX) || defined(TEST_MPFRXX)
    913913   return std::ldexp(1.0, 1 - ((100 + 1) * 1000L) / 301L);
    914 #elif defined(TEST_CPP_FLOAT_BN)
     914#elif defined(TEST_CPP_DEC_FLOAT_BN)
    915915   return std::pow(10.0, 1-std::numeric_limits<efx::cpp_float_50>::digits10);
    916916#else
  • sandbox/big_number/libs/multiprecision/performance/performance_test.cpp

    r76706 r77032  
    1111
    1212#if !defined(TEST_MPF) && !defined(TEST_MPZ) && \
    13    !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPQ) \
     13   !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPQ) \
    1414   && !defined(TEST_TOMMATH) && !defined(TEST_TOMMATH_BOOST_RATIONAL) && !defined(TEST_MPZ_BOOST_RATIONAL)\
    1515   && !defined(TEST_FIXED_INT)
     
    1818#  define TEST_MPQ
    1919#  define TEST_MPFR
    20 #  define TEST_CPP_FLOAT
     20#  define TEST_CPP_DEC_FLOAT
    2121#  define TEST_MPQ
    2222#  define TEST_TOMMATH
     
    3636#include <boost/multiprecision/rational_adapter.hpp>
    3737#endif
    38 #ifdef TEST_CPP_FLOAT
    39 #include <boost/multiprecision/cpp_float.hpp>
     38#ifdef TEST_CPP_DEC_FLOAT
     39#include <boost/multiprecision/cpp_dec_float.hpp>
    4040#endif
    4141#if defined(TEST_MPFR)
     
    609609   test<boost::multiprecision::mp_number<boost::multiprecision::fixed_int<1024, true> > >("fixed_int", 1024);
    610610#endif
    611 #ifdef TEST_CPP_FLOAT
    612    test<boost::multiprecision::cpp_float_50>("cpp_float", 50);
    613    test<boost::multiprecision::cpp_float_100>("cpp_float", 100);
    614    test<boost::multiprecision::mp_number<boost::multiprecision::cpp_float<500> > >("cpp_float", 500);
     611#ifdef TEST_CPP_DEC_FLOAT
     612   test<boost::multiprecision::cpp_float_50>("cpp_dec_float", 50);
     613   test<boost::multiprecision::cpp_float_100>("cpp_dec_float", 100);
     614   test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<500> > >("cpp_dec_float", 500);
    615615#endif
    616616#ifdef TEST_MPFR
  • sandbox/big_number/libs/multiprecision/performance/sf_performance.cpp

    r76652 r77032  
    1111#  define TEST_MPF
    1212#  define TEST_MPF
    13 #  define TEST_CPP_FLOAT
     13#  define TEST_CPP_DEC_FLOAT
    1414#  define TEST_MPFR_CLASS
    1515#endif
     
    2727#include <boost/multiprecision/gmp.hpp>
    2828#endif
    29 #ifdef TEST_CPP_FLOAT
    30 #include <boost/multiprecision/cpp_float.hpp>
     29#ifdef TEST_CPP_DEC_FLOAT
     30#include <boost/multiprecision/cpp_dec_float.hpp>
    3131#endif
    3232#include <boost/math/special_functions/bessel.hpp>
     
    232232   allocation_count = 0;
    233233#endif
    234 #ifdef TEST_CPP_FLOAT
     234#ifdef TEST_CPP_DEC_FLOAT
    235235   c.reset();
    236236   test_bessel<boost::multiprecision::cpp_float_50>();
     
    281281   allocation_count = 0;
    282282#endif
    283 #ifdef TEST_CPP_FLOAT
     283#ifdef TEST_CPP_DEC_FLOAT
    284284   c.reset();
    285285   test_bessel<boost::multiprecision::cpp_float_100>();
     
    333333   allocation_count = 0;
    334334#endif
    335 #ifdef TEST_CPP_FLOAT
     335#ifdef TEST_CPP_DEC_FLOAT
    336336   c.reset();
    337337   test_polynomial<boost::multiprecision::cpp_float_50>();
     
    382382   allocation_count = 0;
    383383#endif
    384 #ifdef TEST_CPP_FLOAT
     384#ifdef TEST_CPP_DEC_FLOAT
    385385   c.reset();
    386386   test_polynomial<boost::multiprecision::cpp_float_100>();
     
    433433   allocation_count = 0;
    434434#endif
    435 #ifdef TEST_CPP_FLOAT
     435#ifdef TEST_CPP_DEC_FLOAT
    436436   c.reset();
    437437   test_nct<boost::multiprecision::cpp_float_50>();
     
    482482   allocation_count = 0;
    483483#endif
    484 #ifdef TEST_CPP_FLOAT
     484#ifdef TEST_CPP_DEC_FLOAT
    485485   c.reset();
    486486   test_nct<boost::multiprecision::cpp_float_100>();
  • sandbox/big_number/libs/multiprecision/test/Jamfile.v2

    r76639 r77032  
    5454        : # input files
    5555        : # requirements
    56               <define>TEST_CPP_FLOAT
     56              <define>TEST_CPP_DEC_FLOAT
    5757        : test_arithmetic_cpp_float ;
    5858
     
    202202        : # input files
    203203        : # requirements
    204               <define>TEST_CPP_FLOAT
     204              <define>TEST_CPP_DEC_FLOAT
    205205         [ check-target-builds ../config//has_mpfr : : <build>no ]
    206206        : test_numeric_limits_cpp_float ;
     
    314314        : # input files
    315315        : # requirements
    316               <define>TEST_CPP_FLOAT
     316              <define>TEST_CPP_DEC_FLOAT
    317317        : test_exp_cpp_float ;
    318318
     
    321321        : # input files
    322322        : # requirements
    323               <define>TEST_CPP_FLOAT
     323              <define>TEST_CPP_DEC_FLOAT
    324324        : test_log_cpp_float ;
    325325
     
    328328        : # input files
    329329        : # requirements
    330               <define>TEST_CPP_FLOAT
     330              <define>TEST_CPP_DEC_FLOAT
    331331        : test_pow_cpp_float ;
    332332
     
    335335        : # input files
    336336        : # requirements
    337               <define>TEST_CPP_FLOAT
     337              <define>TEST_CPP_DEC_FLOAT
    338338        : test_sinh_cpp_float ;
    339339
     
    342342        : # input files
    343343        : # requirements
    344               <define>TEST_CPP_FLOAT
     344              <define>TEST_CPP_DEC_FLOAT
    345345        : test_cosh_cpp_float ;
    346346
     
    349349        : # input files
    350350        : # requirements
    351               <define>TEST_CPP_FLOAT
     351              <define>TEST_CPP_DEC_FLOAT
    352352        : test_tanh_cpp_float ;
    353353
     
    356356        : # input files
    357357        : # requirements
    358               <define>TEST_CPP_FLOAT
     358              <define>TEST_CPP_DEC_FLOAT
    359359        : test_sin_cpp_float ;
    360360
     
    379379        : # input files
    380380        : # requirements
    381               <define>TEST_CPP_FLOAT
     381              <define>TEST_CPP_DEC_FLOAT
    382382        : test_cos_cpp_float ;
    383383
     
    402402        : # input files
    403403        : # requirements
    404               <define>TEST_CPP_FLOAT
     404              <define>TEST_CPP_DEC_FLOAT
    405405        : test_asin_cpp_float ;
    406406
     
    425425        : # input files
    426426        : # requirements
    427               <define>TEST_CPP_FLOAT
     427              <define>TEST_CPP_DEC_FLOAT
    428428        : test_acos_cpp_float ;
    429429
     
    456456        : # input files
    457457        : # requirements
    458               <define>TEST_CPP_FLOAT
     458              <define>TEST_CPP_DEC_FLOAT
    459459        : test_atan_cpp_float ;
    460460
     
    506506        : # input files
    507507        : # requirements
    508               <define>TEST_CPP_FLOAT
     508              <define>TEST_CPP_DEC_FLOAT
    509509         [ check-target-builds ../config//has_mpfr : : <build>no ]
    510510        : test_round_cpp_float ;
     
    537537        : # input files
    538538        : # requirements
    539               <define>TEST_CPP_FLOAT
     539              <define>TEST_CPP_DEC_FLOAT
    540540        : test_fpclassify_cpp_float ;
    541541
     
    547547        : # input files
    548548        : # requirements
    549               <define>TEST_CPP_FLOAT
     549              <define>TEST_CPP_DEC_FLOAT
    550550        : test_float_io_cpp_float ;
    551551
     
    672672           : # input files
    673673           : # requirements
    674             <define>TEST_CPP_FLOAT
     674            <define>TEST_CPP_DEC_FLOAT
    675675            <define>BOOST_ALL_NO_LIB
    676676            <optimization>speed
     
    735735           : # input files
    736736           : # requirements
    737                  <define>TEST_CPP_FLOAT
     737                 <define>TEST_CPP_DEC_FLOAT
    738738           : mp_number_concept_check_cpp_float ;
    739739
  • sandbox/big_number/libs/multiprecision/test/math/log1p_expm1_test.cpp

    r76079 r77032  
    1515#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
    1616
    17 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     17#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1818#  define TEST_MPF_50
    1919#  define TEST_MPFR_50
    20 #  define TEST_CPP_FLOAT
     20#  define TEST_CPP_DEC_FLOAT
    2121
    2222#ifdef _MSC_VER
     
    3838#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3939#endif
    40 #ifdef TEST_CPP_FLOAT
    41 #include <boost/multiprecision/cpp_float.hpp>
     40#ifdef TEST_CPP_DEC_FLOAT
     41#include <boost/multiprecision/cpp_dec_float.hpp>
    4242#endif
    4343
     
    138138   test(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    139139#endif
    140 #ifdef TEST_CPP_FLOAT
    141    test(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    142    test(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    143    test(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     140#ifdef TEST_CPP_DEC_FLOAT
     141   test(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     142   test(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     143   test(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    144144#endif
    145145   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/powm1_sqrtp1m1_test.cpp

    r76079 r77032  
    1515#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
    1616
    17 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     17#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1818#  define TEST_MPF_50
    1919#  define TEST_MPFR_50
    20 #  define TEST_CPP_FLOAT
     20#  define TEST_CPP_DEC_FLOAT
    2121
    2222#ifdef _MSC_VER
     
    3838#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3939#endif
    40 #ifdef TEST_CPP_FLOAT
    41 #include <boost/multiprecision/cpp_float.hpp>
     40#ifdef TEST_CPP_DEC_FLOAT
     41#include <boost/multiprecision/cpp_dec_float.hpp>
    4242#endif
    4343
     
    130130   test_powm1_sqrtp1m1(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    131131#endif
    132 #ifdef TEST_CPP_FLOAT
    133    test_powm1_sqrtp1m1(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    134    test_powm1_sqrtp1m1(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    135    test_powm1_sqrtp1m1(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     132#ifdef TEST_CPP_DEC_FLOAT
     133   test_powm1_sqrtp1m1(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     134   test_powm1_sqrtp1m1(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     135   test_powm1_sqrtp1m1(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    136136#endif
    137137   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_bessel_i.cpp

    r76545 r77032  
    1515#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
    1616
    17 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     17#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1818#  define TEST_MPF_50
    1919#  define TEST_MPFR_50
    20 #  define TEST_CPP_FLOAT
     20#  define TEST_CPP_DEC_FLOAT
    2121
    2222#ifdef _MSC_VER
     
    3838#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3939#endif
    40 #ifdef TEST_CPP_FLOAT
    41 #include <boost/multiprecision/cpp_float.hpp>
     40#ifdef TEST_CPP_DEC_FLOAT
     41#include <boost/multiprecision/cpp_dec_float.hpp>
    4242#endif
    4343
     
    9797   test_bessel(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    9898#endif
    99 #ifdef TEST_CPP_FLOAT
    100    test_bessel(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    101    test_bessel(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    102    test_bessel(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     99#ifdef TEST_CPP_DEC_FLOAT
     100   test_bessel(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     101   test_bessel(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     102   test_bessel(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    103103#endif
    104104   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_bessel_j.cpp

    r76545 r77032  
    1515#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
    1616
    17 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     17#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1818#  define TEST_MPF_50
    1919#  define TEST_MPFR_50
    20 #  define TEST_CPP_FLOAT
     20#  define TEST_CPP_DEC_FLOAT
    2121
    2222#ifdef _MSC_VER
     
    3838#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3939#endif
    40 #ifdef TEST_CPP_FLOAT
    41 #include <boost/multiprecision/cpp_float.hpp>
     40#ifdef TEST_CPP_DEC_FLOAT
     41#include <boost/multiprecision/cpp_dec_float.hpp>
    4242#endif
    4343
     
    119119   test_bessel(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    120120#endif
    121 #ifdef TEST_CPP_FLOAT
    122    test_bessel(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    123    test_bessel(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    124    test_bessel(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     121#ifdef TEST_CPP_DEC_FLOAT
     122   test_bessel(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     123   test_bessel(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     124   test_bessel(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    125125#endif
    126126   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_bessel_k.cpp

    r76545 r77032  
    1616#define BOOST_MATH_SMALL_CONSTANT(x) x
    1717
    18 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     18#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1919#  define TEST_MPF_50
    2020#  define TEST_MPFR_50
    21 #  define TEST_CPP_FLOAT
     21#  define TEST_CPP_DEC_FLOAT
    2222
    2323#ifdef _MSC_VER
     
    3939#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    4040#endif
    41 #ifdef TEST_CPP_FLOAT
    42 #include <boost/multiprecision/cpp_float.hpp>
     41#ifdef TEST_CPP_DEC_FLOAT
     42#include <boost/multiprecision/cpp_dec_float.hpp>
    4343#endif
    4444
     
    113113   test_bessel(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    114114#endif
    115 #ifdef TEST_CPP_FLOAT
    116    test_bessel(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    117    test_bessel(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    118    test_bessel(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     115#ifdef TEST_CPP_DEC_FLOAT
     116   test_bessel(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     117   test_bessel(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     118   test_bessel(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    119119#endif
    120120   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_bessel_y.cpp

    r76545 r77032  
    1515#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
    1616
    17 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     17#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1818#  define TEST_MPF_50
    1919#  define TEST_MPFR_50
    20 #  define TEST_CPP_FLOAT
     20#  define TEST_CPP_DEC_FLOAT
    2121
    2222#ifdef _MSC_VER
     
    3838#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3939#endif
    40 #ifdef TEST_CPP_FLOAT
    41 #include <boost/multiprecision/cpp_float.hpp>
     40#ifdef TEST_CPP_DEC_FLOAT
     41#include <boost/multiprecision/cpp_dec_float.hpp>
    4242#endif
    4343
     
    125125   test_bessel(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    126126#endif
    127 #ifdef TEST_CPP_FLOAT
    128    test_bessel(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    129    test_bessel(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    130    test_bessel(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     127#ifdef TEST_CPP_DEC_FLOAT
     128   test_bessel(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     129   test_bessel(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     130   test_bessel(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    131131#endif
    132132   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_beta.cpp

    r76545 r77032  
    1515#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
    1616
    17 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     17#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1818#  define TEST_MPF_50
    1919#  define TEST_MPFR_50
    20 #  define TEST_CPP_FLOAT
     20#  define TEST_CPP_DEC_FLOAT
    2121
    2222#ifdef _MSC_VER
     
    3838#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3939#endif
    40 #ifdef TEST_CPP_FLOAT
    41 #include <boost/multiprecision/cpp_float.hpp>
     40#ifdef TEST_CPP_DEC_FLOAT
     41#include <boost/multiprecision/cpp_dec_float.hpp>
    4242#endif
    4343
     
    118118   test_beta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    119119#endif
    120 #ifdef TEST_CPP_FLOAT
    121    test_beta(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    122    test_beta(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    123    test_beta(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     120#ifdef TEST_CPP_DEC_FLOAT
     121   test_beta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     122   test_beta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     123   test_beta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    124124#endif
    125125   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_binomial_coeff.cpp

    r76545 r77032  
    1515#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
    1616
    17 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     17#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1818#  define TEST_MPF_50
    1919#  define TEST_MPFR_50
    20 #  define TEST_CPP_FLOAT
     20#  define TEST_CPP_DEC_FLOAT
    2121
    2222#ifdef _MSC_VER
     
    3838#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3939#endif
    40 #ifdef TEST_CPP_FLOAT
    41 #include <boost/multiprecision/cpp_float.hpp>
     40#ifdef TEST_CPP_DEC_FLOAT
     41#include <boost/multiprecision/cpp_dec_float.hpp>
    4242#endif
    4343
     
    104104   test_binomial(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    105105#endif
    106 #ifdef TEST_CPP_FLOAT
    107    test_binomial(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    108    test_binomial(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    109    test_binomial(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     106#ifdef TEST_CPP_DEC_FLOAT
     107   test_binomial(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     108   test_binomial(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     109   test_binomial(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    110110#endif
    111111   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_carlson.cpp

    r76545 r77032  
    1010#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
    1111
    12 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     12#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1313#  define TEST_MPF_50
    1414#  define TEST_MPFR_50
    15 #  define TEST_CPP_FLOAT
     15#  define TEST_CPP_DEC_FLOAT
    1616
    1717#ifdef _MSC_VER
     
    3333#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3434#endif
    35 #ifdef TEST_CPP_FLOAT
    36 #include <boost/multiprecision/cpp_float.hpp>
     35#ifdef TEST_CPP_DEC_FLOAT
     36#include <boost/multiprecision/cpp_dec_float.hpp>
    3737#endif
    3838
     
    9696   test_spots(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    9797#endif
    98 #ifdef TEST_CPP_FLOAT
    99    test_spots(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    100    test_spots(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    101    test_spots(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     98#ifdef TEST_CPP_DEC_FLOAT
     99   test_spots(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     100   test_spots(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     101   test_spots(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    102102#endif
    103103   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_cbrt.cpp

    r76545 r77032  
    1010#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
    1111
    12 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     12#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1313#  define TEST_MPF_50
    1414#  define TEST_MPFR_50
    15 #  define TEST_CPP_FLOAT
     15#  define TEST_CPP_DEC_FLOAT
    1616
    1717#ifdef _MSC_VER
     
    3333#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3434#endif
    35 #ifdef TEST_CPP_FLOAT
    36 #include <boost/multiprecision/cpp_float.hpp>
     35#ifdef TEST_CPP_DEC_FLOAT
     36#include <boost/multiprecision/cpp_dec_float.hpp>
    3737#endif
    3838
     
    8585   test_cbrt(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    8686#endif
    87 #ifdef TEST_CPP_FLOAT
    88    test_cbrt(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    89    test_cbrt(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    90    test_cbrt(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     87#ifdef TEST_CPP_DEC_FLOAT
     88   test_cbrt(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     89   test_cbrt(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     90   test_cbrt(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    9191#endif
    9292   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_digamma.cpp

    r76545 r77032  
    1010#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
    1111
    12 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     12#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1313#  define TEST_MPF_50
    1414#  define TEST_MPFR_50
    15 #  define TEST_CPP_FLOAT
     15#  define TEST_CPP_DEC_FLOAT
    1616
    1717#ifdef _MSC_VER
     
    3333#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3434#endif
    35 #ifdef TEST_CPP_FLOAT
    36 #include <boost/multiprecision/cpp_float.hpp>
     35#ifdef TEST_CPP_DEC_FLOAT
     36#include <boost/multiprecision/cpp_dec_float.hpp>
    3737#endif
    3838
     
    9292   test_digamma(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    9393#endif
    94 #ifdef TEST_CPP_FLOAT
    95    test_digamma(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    96    test_digamma(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    97    test_digamma(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     94#ifdef TEST_CPP_DEC_FLOAT
     95   test_digamma(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     96   test_digamma(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     97   test_digamma(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    9898#endif
    9999   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_ellint_1.cpp

    r76545 r77032  
    1010#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
    1111
    12 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     12#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1313#  define TEST_MPF_50
    1414#  define TEST_MPFR_50
    15 #  define TEST_CPP_FLOAT
     15#  define TEST_CPP_DEC_FLOAT
    1616
    1717#ifdef _MSC_VER
     
    3333#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3434#endif
    35 #ifdef TEST_CPP_FLOAT
    36 #include <boost/multiprecision/cpp_float.hpp>
     35#ifdef TEST_CPP_DEC_FLOAT
     36#include <boost/multiprecision/cpp_dec_float.hpp>
    3737#endif
    3838
     
    8585   test_spots(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    8686#endif
    87 #ifdef TEST_CPP_FLOAT
    88    test_spots(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    89    test_spots(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    90    test_spots(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     87#ifdef TEST_CPP_DEC_FLOAT
     88   test_spots(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     89   test_spots(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     90   test_spots(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    9191#endif
    9292   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_ellint_2.cpp

    r76545 r77032  
    1010#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
    1111
    12 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     12#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1313#  define TEST_MPF_50
    1414#  define TEST_MPFR_50
    15 #  define TEST_CPP_FLOAT
     15#  define TEST_CPP_DEC_FLOAT
    1616
    1717#ifdef _MSC_VER
     
    3333#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3434#endif
    35 #ifdef TEST_CPP_FLOAT
    36 #include <boost/multiprecision/cpp_float.hpp>
     35#ifdef TEST_CPP_DEC_FLOAT
     36#include <boost/multiprecision/cpp_dec_float.hpp>
    3737#endif
    3838
     
    8585   test_spots(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    8686#endif
    87 #ifdef TEST_CPP_FLOAT
    88    test_spots(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    89    test_spots(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    90    test_spots(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     87#ifdef TEST_CPP_DEC_FLOAT
     88   test_spots(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     89   test_spots(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     90   test_spots(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    9191#endif
    9292   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_ellint_3.cpp

    r76545 r77032  
    1010#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
    1111
    12 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     12#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1313#  define TEST_MPF_50
    1414#  define TEST_MPFR_50
    15 #  define TEST_CPP_FLOAT
     15#  define TEST_CPP_DEC_FLOAT
    1616
    1717#ifdef _MSC_VER
     
    3333#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3434#endif
    35 #ifdef TEST_CPP_FLOAT
    36 #include <boost/multiprecision/cpp_float.hpp>
     35#ifdef TEST_CPP_DEC_FLOAT
     36#include <boost/multiprecision/cpp_dec_float.hpp>
    3737#endif
    3838
     
    9999   test_spots(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    100100#endif
    101 #ifdef TEST_CPP_FLOAT
    102    test_spots(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    103    test_spots(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    104    test_spots(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     101#ifdef TEST_CPP_DEC_FLOAT
     102   test_spots(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     103   test_spots(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     104   test_spots(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    105105#endif
    106106   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_erf.cpp

    r76545 r77032  
    1010#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
    1111
    12 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     12#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1313#  define TEST_MPF_50
    1414#  define TEST_MPFR_50
    15 #  define TEST_CPP_FLOAT
     15#  define TEST_CPP_DEC_FLOAT
    1616
    1717#ifdef _MSC_VER
     
    3333#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3434#endif
    35 #ifdef TEST_CPP_FLOAT
    36 #include <boost/multiprecision/cpp_float.hpp>
     35#ifdef TEST_CPP_DEC_FLOAT
     36#include <boost/multiprecision/cpp_dec_float.hpp>
    3737#endif
    3838
     
    106106   test_erf(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    107107#endif
    108 #ifdef TEST_CPP_FLOAT
    109    test_erf(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    110    test_erf(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    111    test_erf(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     108#ifdef TEST_CPP_DEC_FLOAT
     109   test_erf(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     110   test_erf(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     111   test_erf(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    112112#endif
    113113   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_expint.cpp

    r76545 r77032  
    1010#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
    1111
    12 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     12#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1313#  define TEST_MPF_50
    1414#  define TEST_MPFR_50
    15 #  define TEST_CPP_FLOAT
     15#  define TEST_CPP_DEC_FLOAT
    1616
    1717#ifdef _MSC_VER
     
    3333#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3434#endif
    35 #ifdef TEST_CPP_FLOAT
    36 #include <boost/multiprecision/cpp_float.hpp>
     35#ifdef TEST_CPP_DEC_FLOAT
     36#include <boost/multiprecision/cpp_dec_float.hpp>
    3737#endif
    3838
     
    106106   test_expint(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    107107#endif
    108 #ifdef TEST_CPP_FLOAT
    109    test_expint(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    110    test_expint(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    111    test_expint(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     108#ifdef TEST_CPP_DEC_FLOAT
     109   test_expint(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     110   test_expint(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     111   test_expint(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    112112#endif
    113113   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_gamma.cpp

    r76545 r77032  
    1010#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
    1111
    12 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     12#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1313#  define TEST_MPF_50
    1414#  define TEST_MPFR_50
    15 #  define TEST_CPP_FLOAT
     15#  define TEST_CPP_DEC_FLOAT
    1616
    1717#ifdef _MSC_VER
     
    3333#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3434#endif
    35 #ifdef TEST_CPP_FLOAT
    36 #include <boost/multiprecision/cpp_float.hpp>
     35#ifdef TEST_CPP_DEC_FLOAT
     36#include <boost/multiprecision/cpp_dec_float.hpp>
    3737#endif
    3838
     
    120120   test_gamma(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    121121#endif
    122 #ifdef TEST_CPP_FLOAT
    123    test_gamma(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    124    test_gamma(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    125    test_gamma(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     122#ifdef TEST_CPP_DEC_FLOAT
     123   test_gamma(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     124   test_gamma(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     125   test_gamma(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    126126#endif
    127127   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_hermite.cpp

    r76545 r77032  
    1010#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
    1111
    12 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     12#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1313#  define TEST_MPF_50
    1414#  define TEST_MPFR_50
    15 #  define TEST_CPP_FLOAT
     15#  define TEST_CPP_DEC_FLOAT
    1616
    1717#ifdef _MSC_VER
     
    3333#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3434#endif
    35 #ifdef TEST_CPP_FLOAT
    36 #include <boost/multiprecision/cpp_float.hpp>
     35#ifdef TEST_CPP_DEC_FLOAT
     36#include <boost/multiprecision/cpp_dec_float.hpp>
    3737#endif
    3838
     
    8585   test_hermite(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    8686#endif
    87 #ifdef TEST_CPP_FLOAT
    88    test_hermite(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    89    test_hermite(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    90    test_hermite(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     87#ifdef TEST_CPP_DEC_FLOAT
     88   test_hermite(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     89   test_hermite(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     90   test_hermite(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    9191#endif
    9292   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_ibeta.cpp

    r76545 r77032  
    1111#define BOOST_MATH_SMALL_CONSTANT(x) x
    1212
    13 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     13#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1414#  define TEST_MPF_50
    1515#  define TEST_MPFR_50
    16 #  define TEST_CPP_FLOAT
     16#  define TEST_CPP_DEC_FLOAT
    1717
    1818#ifdef _MSC_VER
     
    3434#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3535#endif
    36 #ifdef TEST_CPP_FLOAT
    37 #include <boost/multiprecision/cpp_float.hpp>
     36#ifdef TEST_CPP_DEC_FLOAT
     37#include <boost/multiprecision/cpp_dec_float.hpp>
    3838#endif
    3939
     
    109109   test_beta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    110110#endif
    111 #ifdef TEST_CPP_FLOAT
    112    test_beta(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    113    test_beta(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    114    test_beta(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     111#ifdef TEST_CPP_DEC_FLOAT
     112   test_beta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     113   test_beta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     114   test_beta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    115115#endif
    116116   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_ibeta_2.cpp

    r76545 r77032  
    1111#define BOOST_MATH_SMALL_CONSTANT(x) x
    1212
    13 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     13#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1414#  define TEST_MPF_50
    1515#  define TEST_MPFR_50
    16 #  define TEST_CPP_FLOAT
     16#  define TEST_CPP_DEC_FLOAT
    1717
    1818#ifdef _MSC_VER
     
    3434#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3535#endif
    36 #ifdef TEST_CPP_FLOAT
    37 #include <boost/multiprecision/cpp_float.hpp>
     36#ifdef TEST_CPP_DEC_FLOAT
     37#include <boost/multiprecision/cpp_dec_float.hpp>
    3838#endif
    3939
     
    116116   test_beta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    117117#endif
    118 #ifdef TEST_CPP_FLOAT
    119    test_beta(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    120    test_beta(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    121    test_beta(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     118#ifdef TEST_CPP_DEC_FLOAT
     119   test_beta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     120   test_beta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     121   test_beta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    122122#endif
    123123   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_ibeta_3.cpp

    r76545 r77032  
    1111#define BOOST_MATH_SMALL_CONSTANT(x) x
    1212
    13 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     13#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1414#  define TEST_MPF_50
    1515#  define TEST_MPFR_50
    16 #  define TEST_CPP_FLOAT
     16#  define TEST_CPP_DEC_FLOAT
    1717
    1818#ifdef _MSC_VER
     
    3434#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3535#endif
    36 #ifdef TEST_CPP_FLOAT
    37 #include <boost/multiprecision/cpp_float.hpp>
     36#ifdef TEST_CPP_DEC_FLOAT
     37#include <boost/multiprecision/cpp_dec_float.hpp>
    3838#endif
    3939
     
    102102   test_beta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    103103#endif
    104 #ifdef TEST_CPP_FLOAT
    105    test_beta(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    106    test_beta(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    107    test_beta(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     104#ifdef TEST_CPP_DEC_FLOAT
     105   test_beta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     106   test_beta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     107   test_beta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    108108#endif
    109109   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_ibeta_4.cpp

    r76545 r77032  
    1111#define BOOST_MATH_SMALL_CONSTANT(x) x
    1212
    13 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     13#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1414#  define TEST_MPF_50
    1515#  define TEST_MPFR_50
    16 #  define TEST_CPP_FLOAT
     16#  define TEST_CPP_DEC_FLOAT
    1717
    1818#ifdef _MSC_VER
     
    3434#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3535#endif
    36 #ifdef TEST_CPP_FLOAT
    37 #include <boost/multiprecision/cpp_float.hpp>
     36#ifdef TEST_CPP_DEC_FLOAT
     37#include <boost/multiprecision/cpp_dec_float.hpp>
    3838#endif
    3939
     
    109109   test_beta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    110110#endif
    111 #ifdef TEST_CPP_FLOAT
    112    test_beta(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    113    test_beta(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    114    test_beta(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     111#ifdef TEST_CPP_DEC_FLOAT
     112   test_beta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     113   test_beta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     114   test_beta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    115115#endif
    116116   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_ibeta_inv_1.cpp

    r76545 r77032  
    1111#define BOOST_MATH_SMALL_CONSTANT(x) x
    1212
    13 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     13#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1414#  define TEST_MPF_50
    1515#  define TEST_MPFR_50
    16 #  define TEST_CPP_FLOAT
     16#  define TEST_CPP_DEC_FLOAT
    1717
    1818#ifdef _MSC_VER
     
    3434#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3535#endif
    36 #ifdef TEST_CPP_FLOAT
    37 #include <boost/multiprecision/cpp_float.hpp>
     36#ifdef TEST_CPP_DEC_FLOAT
     37#include <boost/multiprecision/cpp_dec_float.hpp>
    3838#endif
    3939
     
    8888   test_beta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    8989#endif
    90 #ifdef TEST_CPP_FLOAT
    91    test_beta(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    92    test_beta(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    93    test_beta(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     90#ifdef TEST_CPP_DEC_FLOAT
     91   test_beta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     92   test_beta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     93   test_beta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    9494#endif
    9595   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_ibeta_inv_ab_4.cpp

    r76545 r77032  
    1010#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
    1111
    12 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     12#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1313#  define TEST_MPF_50
    1414#  define TEST_MPFR_50
    15 #  define TEST_CPP_FLOAT
     15#  define TEST_CPP_DEC_FLOAT
    1616
    1717#ifdef _MSC_VER
     
    3333#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3434#endif
    35 #ifdef TEST_CPP_FLOAT
    36 #include <boost/multiprecision/cpp_float.hpp>
     35#ifdef TEST_CPP_DEC_FLOAT
     36#include <boost/multiprecision/cpp_dec_float.hpp>
    3737#endif
    3838
     
    8888   test_beta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    8989#endif
    90 #ifdef TEST_CPP_FLOAT
    91    test_beta(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    92    test_beta(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    93    test_beta(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     90#ifdef TEST_CPP_DEC_FLOAT
     91   test_beta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     92   test_beta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     93   test_beta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    9494#endif
    9595   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_igamma.cpp

    r76545 r77032  
    1111#define BOOST_MATH_SMALL_CONSTANT(x) x
    1212
    13 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     13#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1414#  define TEST_MPF_50
    1515#  define TEST_MPFR_50
    16 #  define TEST_CPP_FLOAT
     16#  define TEST_CPP_DEC_FLOAT
    1717
    1818#ifdef _MSC_VER
     
    3434#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3535#endif
    36 #ifdef TEST_CPP_FLOAT
    37 #include <boost/multiprecision/cpp_float.hpp>
     36#ifdef TEST_CPP_DEC_FLOAT
     37#include <boost/multiprecision/cpp_dec_float.hpp>
    3838#endif
    3939
     
    9292   test_gamma(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    9393#endif
    94 #ifdef TEST_CPP_FLOAT
    95    test_gamma(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    96    test_gamma(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    97    test_gamma(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     94#ifdef TEST_CPP_DEC_FLOAT
     95   test_gamma(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     96   test_gamma(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     97   test_gamma(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    9898#endif
    9999   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_igamma_inv.cpp

    r76545 r77032  
    1111#define BOOST_MATH_SMALL_CONSTANT(x) x
    1212
    13 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     13#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1414#  define TEST_MPF_50
    1515#  define TEST_MPFR_50
    16 #  define TEST_CPP_FLOAT
     16#  define TEST_CPP_DEC_FLOAT
    1717
    1818#ifdef _MSC_VER
     
    3434#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3535#endif
    36 #ifdef TEST_CPP_FLOAT
    37 #include <boost/multiprecision/cpp_float.hpp>
     36#ifdef TEST_CPP_DEC_FLOAT
     37#include <boost/multiprecision/cpp_dec_float.hpp>
    3838#endif
    3939
     
    100100   test_gamma(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    101101#endif
    102 #ifdef TEST_CPP_FLOAT
    103    test_gamma(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    104    test_gamma(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    105    test_gamma(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     102#ifdef TEST_CPP_DEC_FLOAT
     103   test_gamma(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     104   test_gamma(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     105   test_gamma(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    106106#endif
    107107   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_igamma_inva.cpp

    r76545 r77032  
    1111#define BOOST_MATH_SMALL_CONSTANT(x) x
    1212
    13 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     13#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1414#  define TEST_MPF_50
    1515#  define TEST_MPFR_50
    16 #  define TEST_CPP_FLOAT
     16#  define TEST_CPP_DEC_FLOAT
    1717
    1818#ifdef _MSC_VER
     
    3434#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3535#endif
    36 #ifdef TEST_CPP_FLOAT
    37 #include <boost/multiprecision/cpp_float.hpp>
     36#ifdef TEST_CPP_DEC_FLOAT
     37#include <boost/multiprecision/cpp_dec_float.hpp>
    3838#endif
    3939
     
    8686   test_gamma(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    8787#endif
    88 #ifdef TEST_CPP_FLOAT
    89    test_gamma(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    90    test_gamma(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    91    test_gamma(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     88#ifdef TEST_CPP_DEC_FLOAT
     89   test_gamma(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     90   test_gamma(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     91   test_gamma(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    9292#endif
    9393   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_laguerre.cpp

    r76545 r77032  
    1010#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
    1111
    12 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     12#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1313#  define TEST_MPF_50
    1414#  define TEST_MPFR_50
    15 #  define TEST_CPP_FLOAT
     15#  define TEST_CPP_DEC_FLOAT
    1616
    1717#ifdef _MSC_VER
     
    3333#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3434#endif
    35 #ifdef TEST_CPP_FLOAT
    36 #include <boost/multiprecision/cpp_float.hpp>
     35#ifdef TEST_CPP_DEC_FLOAT
     36#include <boost/multiprecision/cpp_dec_float.hpp>
    3737#endif
    3838
     
    8585   test_laguerre(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    8686#endif
    87 #ifdef TEST_CPP_FLOAT
    88    test_laguerre(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    89    test_laguerre(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    90    test_laguerre(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     87#ifdef TEST_CPP_DEC_FLOAT
     88   test_laguerre(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     89   test_laguerre(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     90   test_laguerre(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    9191#endif
    9292   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_legendre.cpp

    r76545 r77032  
    1010#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
    1111
    12 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     12#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1313#  define TEST_MPF_50
    1414#  define TEST_MPFR_50
    15 #  define TEST_CPP_FLOAT
     15#  define TEST_CPP_DEC_FLOAT
    1616
    1717#ifdef _MSC_VER
     
    3333#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3434#endif
    35 #ifdef TEST_CPP_FLOAT
    36 #include <boost/multiprecision/cpp_float.hpp>
     35#ifdef TEST_CPP_DEC_FLOAT
     36#include <boost/multiprecision/cpp_dec_float.hpp>
    3737#endif
    3838
     
    8585   test_legendre_p(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    8686#endif
    87 #ifdef TEST_CPP_FLOAT
    88    test_legendre_p(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    89    test_legendre_p(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    90    test_legendre_p(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     87#ifdef TEST_CPP_DEC_FLOAT
     88   test_legendre_p(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     89   test_legendre_p(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     90   test_legendre_p(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    9191#endif
    9292   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_tgamma_ratio.cpp

    r76545 r77032  
    1010#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
    1111
    12 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     12#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1313#  define TEST_MPF_50
    1414#  define TEST_MPFR_50
    15 #  define TEST_CPP_FLOAT
     15#  define TEST_CPP_DEC_FLOAT
    1616
    1717#ifdef _MSC_VER
     
    3333#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3434#endif
    35 #ifdef TEST_CPP_FLOAT
    36 #include <boost/multiprecision/cpp_float.hpp>
     35#ifdef TEST_CPP_DEC_FLOAT
     36#include <boost/multiprecision/cpp_dec_float.hpp>
    3737#endif
    3838
     
    9292   test_tgamma_ratio(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    9393#endif
    94 #ifdef TEST_CPP_FLOAT
    95    test_tgamma_ratio(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    96    test_tgamma_ratio(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    97    test_tgamma_ratio(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     94#ifdef TEST_CPP_DEC_FLOAT
     95   test_tgamma_ratio(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     96   test_tgamma_ratio(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     97   test_tgamma_ratio(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    9898#endif
    9999   return 0;
  • sandbox/big_number/libs/multiprecision/test/math/test_zeta.cpp

    r76545 r77032  
    1010#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
    1111
    12 #if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     12#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1313#  define TEST_MPF_50
    1414#  define TEST_MPFR_50
    15 #  define TEST_CPP_FLOAT
     15#  define TEST_CPP_DEC_FLOAT
    1616
    1717#ifdef _MSC_VER
     
    3333#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3434#endif
    35 #ifdef TEST_CPP_FLOAT
    36 #include <boost/multiprecision/cpp_float.hpp>
     35#ifdef TEST_CPP_DEC_FLOAT
     36#include <boost/multiprecision/cpp_dec_float.hpp>
    3737#endif
    3838
     
    9292   test_zeta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
    9393#endif
    94 #ifdef TEST_CPP_FLOAT
    95    test_zeta(mp_number<cpp_float<18> >(), "mp_number<cpp_float<18> >");
    96    test_zeta(mp_number<cpp_float<30> >(), "mp_number<cpp_float<30> >");
    97    test_zeta(mp_number<cpp_float<35> >(), "mp_number<cpp_float<35> >");
     94#ifdef TEST_CPP_DEC_FLOAT
     95   test_zeta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
     96   test_zeta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
     97   test_zeta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
    9898#endif
    9999   return 0;
  • sandbox/big_number/libs/multiprecision/test/mp_number_concept_check.cpp

    r75586 r77032  
    2222
    2323#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) \
    24    && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)\
     24   && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)\
    2525   && !defined(TEST_MPFR_6) && !defined(TEST_MPFR_15) && !defined(TEST_MPFR_17) && !defined(TEST_MPFR_30)
    2626#  define TEST_MPF_50
     
    3232#  define TEST_MPFR_17
    3333#  define TEST_MPFR_30
    34 #  define TEST_CPP_FLOAT
     34#  define TEST_CPP_DEC_FLOAT
    3535
    3636#ifdef _MSC_VER
     
    4949#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    5050#endif
    51 #ifdef TEST_CPP_FLOAT
    52 #include <boost/multiprecision/cpp_float.hpp>
     51#ifdef TEST_CPP_DEC_FLOAT
     52#include <boost/multiprecision/cpp_dec_float.hpp>
    5353#endif
    5454#if defined(TEST_MPFR_50) || defined(TEST_MPFR_6) || defined(TEST_MPFR_15) || defined(TEST_MPFR_17) || defined(TEST_MPFR_30)
     
    8282   instantiate(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<30> >());
    8383#endif
    84 #ifdef TEST_CPP_FLOAT
     84#ifdef TEST_CPP_DEC_FLOAT
    8585   instantiate(boost::multiprecision::cpp_float_50());
    8686#endif
     
    113113   BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mpfr_float_50>));
    114114#endif
    115 #ifdef TEST_CPP_FLOAT
     115#ifdef TEST_CPP_DEC_FLOAT
    116116   BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::cpp_float_50>));
    117117#endif
  • sandbox/big_number/libs/multiprecision/test/test_acos.cpp

    r75723 r77032  
    1717#include "test.hpp"
    1818
    19 #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)
     19#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)
    2020#  define TEST_MPF_50
    2121//#  define TEST_MPF
    2222#  define TEST_BACKEND
    23 #  define TEST_CPP_FLOAT
     23#  define TEST_CPP_DEC_FLOAT
    2424
    2525#ifdef _MSC_VER
     
    4141#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    4242#endif
    43 #ifdef TEST_CPP_FLOAT
    44 #include <boost/multiprecision/cpp_float.hpp>
     43#ifdef TEST_CPP_DEC_FLOAT
     44#include <boost/multiprecision/cpp_dec_float.hpp>
    4545#endif
    4646
     
    100100   test<boost::multiprecision::mpfr_float_100>();
    101101#endif
    102 #ifdef TEST_CPP_FLOAT
     102#ifdef TEST_CPP_DEC_FLOAT
    103103   test<boost::multiprecision::cpp_float_50>();
    104104   test<boost::multiprecision::cpp_float_100>();
  • sandbox/big_number/libs/multiprecision/test/test_arithmetic.cpp

    r76706 r77032  
    1313
    1414#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && \
    15    !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ) \
     15   !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ) \
    1616   && !defined(TEST_TOMMATH) && !defined(TEST_TOMMATH_BOOST_RATIONAL) && !defined(TEST_MPZ_BOOST_RATIONAL)\
    1717   && !defined(TEST_FIXED_INT1) && !defined(TEST_FIXED_INT2)
     
    2222#  define TEST_MPFR
    2323#  define TEST_MPFR_50
    24 #  define TEST_CPP_FLOAT
     24#  define TEST_CPP_DEC_FLOAT
    2525#  define TEST_MPQ
    2626#  define TEST_TOMMATH
     
    4444#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    4545#endif
    46 #ifdef TEST_CPP_FLOAT
    47 #include <boost/multiprecision/cpp_float.hpp>
     46#ifdef TEST_CPP_DEC_FLOAT
     47#include <boost/multiprecision/cpp_dec_float.hpp>
    4848#endif
    4949#if defined(TEST_MPFR) || defined(TEST_MPFR_50)
     
    10031003   test<boost::multiprecision::mpq_rational>();
    10041004#endif
    1005 #ifdef TEST_CPP_FLOAT
     1005#ifdef TEST_CPP_DEC_FLOAT
    10061006   test<boost::multiprecision::cpp_float_50>();
    10071007#endif
  • sandbox/big_number/libs/multiprecision/test/test_asin.cpp

    r75586 r77032  
    1717#include "test.hpp"
    1818
    19 #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)
     19#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)
    2020#  define TEST_MPF_50
    2121//#  define TEST_MPF
    2222#  define TEST_BACKEND
    23 #  define TEST_CPP_FLOAT
     23#  define TEST_CPP_DEC_FLOAT
    2424
    2525#ifdef _MSC_VER
     
    4141#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    4242#endif
    43 #ifdef TEST_CPP_FLOAT
    44 #include <boost/multiprecision/cpp_float.hpp>
     43#ifdef TEST_CPP_DEC_FLOAT
     44#include <boost/multiprecision/cpp_dec_float.hpp>
    4545#endif
    4646
     
    9696   test<boost::multiprecision::mpfr_float_100>();
    9797#endif
    98 #ifdef TEST_CPP_FLOAT
     98#ifdef TEST_CPP_DEC_FLOAT
    9999   test<boost::multiprecision::cpp_float_50>();
    100100   test<boost::multiprecision::cpp_float_100>();
  • sandbox/big_number/libs/multiprecision/test/test_atan.cpp

    r76412 r77032  
    1717#include "test.hpp"
    1818
    19 #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)
     19#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)
    2020#  define TEST_MPF_50
    2121//#  define TEST_MPF
    2222#  define TEST_BACKEND
    23 #  define TEST_CPP_FLOAT
     23#  define TEST_CPP_DEC_FLOAT
    2424
    2525#ifdef _MSC_VER
     
    4141#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    4242#endif
    43 #ifdef TEST_CPP_FLOAT
    44 #include <boost/multiprecision/cpp_float.hpp>
     43#ifdef TEST_CPP_DEC_FLOAT
     44#include <boost/multiprecision/cpp_dec_float.hpp>
    4545#endif
    4646
     
    242242   test<boost::multiprecision::mpfr_float_100>();
    243243#endif
    244 #ifdef TEST_CPP_FLOAT
     244#ifdef TEST_CPP_DEC_FLOAT
    245245   test<boost::multiprecision::cpp_float_50>();
    246246   test<boost::multiprecision::cpp_float_100>();
  • sandbox/big_number/libs/multiprecision/test/test_cos.cpp

    r76412 r77032  
    1717#include "test.hpp"
    1818
    19 #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)
     19#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)
    2020#  define TEST_MPF_50
    2121//#  define TEST_MPF
    2222#  define TEST_BACKEND
    23 #  define TEST_CPP_FLOAT
     23#  define TEST_CPP_DEC_FLOAT
    2424
    2525#ifdef _MSC_VER
     
    4141#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    4242#endif
    43 #ifdef TEST_CPP_FLOAT
    44 #include <boost/multiprecision/cpp_float.hpp>
     43#ifdef TEST_CPP_DEC_FLOAT
     44#include <boost/multiprecision/cpp_dec_float.hpp>
    4545#endif
    4646
     
    296296   test<boost::multiprecision::mpfr_float_100>();
    297297#endif
    298 #ifdef TEST_CPP_FLOAT
     298#ifdef TEST_CPP_DEC_FLOAT
    299299   test<boost::multiprecision::cpp_float_50>();
    300300   test<boost::multiprecision::cpp_float_100>();
  • sandbox/big_number/libs/multiprecision/test/test_cosh.cpp

    r76412 r77032  
    1717#include "test.hpp"
    1818
    19 #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)
     19#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)
    2020#  define TEST_MPF_50
    2121//#  define TEST_MPF
    2222#  define TEST_BACKEND
    23 #  define TEST_CPP_FLOAT
     23#  define TEST_CPP_DEC_FLOAT
    2424
    2525#ifdef _MSC_VER
     
    4141#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    4242#endif
    43 #ifdef TEST_CPP_FLOAT
    44 #include <boost/multiprecision/cpp_float.hpp>
     43#ifdef TEST_CPP_DEC_FLOAT
     44#include <boost/multiprecision/cpp_dec_float.hpp>
    4545#endif
    4646
     
    138138   test<boost::multiprecision::mpfr_float_100>();
    139139#endif
    140 #ifdef TEST_CPP_FLOAT
     140#ifdef TEST_CPP_DEC_FLOAT
    141141   test<boost::multiprecision::cpp_float_50>();
    142142   test<boost::multiprecision::cpp_float_100>();
  • sandbox/big_number/libs/multiprecision/test/test_exp.cpp

    r76412 r77032  
    1717#include "test.hpp"
    1818
    19 #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)
     19#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)
    2020#  define TEST_MPF_50
    2121//#  define TEST_MPF
    2222#  define TEST_BACKEND
    23 #  define TEST_CPP_FLOAT
     23#  define TEST_CPP_DEC_FLOAT
    2424
    2525#ifdef _MSC_VER
     
    4141#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    4242#endif
    43 #ifdef TEST_CPP_FLOAT
    44 #include <boost/multiprecision/cpp_float.hpp>
     43#ifdef TEST_CPP_DEC_FLOAT
     44#include <boost/multiprecision/cpp_dec_float.hpp>
    4545#endif
    4646
     
    178178   test<boost::multiprecision::mpfr_float_100>();
    179179#endif
    180 #ifdef TEST_CPP_FLOAT
     180#ifdef TEST_CPP_DEC_FLOAT
    181181   test<boost::multiprecision::cpp_float_50>();
    182182   test<boost::multiprecision::cpp_float_100>();
  • sandbox/big_number/libs/multiprecision/test/test_float_io.cpp

    r76593 r77032  
    1010#endif
    1111
    12 #if !defined(TEST_MPF_50) && !defined(TEST_CPP_FLOAT) && !defined(TEST_MPFR_50)
     12#if !defined(TEST_MPF_50) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
    1313#  define TEST_MPF_50
    14 #  define TEST_CPP_FLOAT
     14#  define TEST_CPP_DEC_FLOAT
    1515#  define TEST_MPFR_50
    1616
     
    3030#include <boost/multiprecision/mpfr.hpp>
    3131#endif
    32 #ifdef TEST_CPP_FLOAT
    33 #include <boost/multiprecision/cpp_float.hpp>
     32#ifdef TEST_CPP_DEC_FLOAT
     33#include <boost/multiprecision/cpp_dec_float.hpp>
    3434#endif
    3535
     
    257257   test_round_trip<boost::multiprecision::mpfr_float_100>();
    258258#endif
    259 #ifdef TEST_CPP_FLOAT
     259#ifdef TEST_CPP_DEC_FLOAT
    260260   test<boost::multiprecision::cpp_float_50>();
    261261   test<boost::multiprecision::cpp_float_100>();
    262262
    263263   /*
    264    // cpp_float has extra guard digits that messes this up:
     264   // cpp_dec_float has extra guard digits that messes this up:
    265265   test_round_trip<boost::multiprecision::cpp_float_50>();
    266266   test_round_trip<boost::multiprecision::cpp_float_100>();
  • sandbox/big_number/libs/multiprecision/test/test_fpclassify.cpp

    r75586 r77032  
    1515#include "test.hpp"
    1616
    17 #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)
     17#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)
    1818#  define TEST_MPF_50
    1919#  define TEST_MPFR_50
    2020#  define TEST_BACKEND
    21 #  define TEST_CPP_FLOAT
     21#  define TEST_CPP_DEC_FLOAT
    2222
    2323#ifdef _MSC_VER
     
    3939#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    4040#endif
    41 #ifdef TEST_CPP_FLOAT
    42 #include <boost/multiprecision/cpp_float.hpp>
     41#ifdef TEST_CPP_DEC_FLOAT
     42#include <boost/multiprecision/cpp_dec_float.hpp>
    4343#endif
    4444
     
    310310   test<boost::multiprecision::mpfr_float_100>();
    311311#endif
    312 #ifdef TEST_CPP_FLOAT
     312#ifdef TEST_CPP_DEC_FLOAT
    313313   test<boost::multiprecision::cpp_float_50>();
    314314   test<boost::multiprecision::cpp_float_100>();
  • sandbox/big_number/libs/multiprecision/test/test_log.cpp

    r76412 r77032  
    1717#include "test.hpp"
    1818
    19 #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)
     19#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)
    2020#  define TEST_MPF_50
    2121//#  define TEST_MPF
    2222#  define TEST_BACKEND
    23 #  define TEST_CPP_FLOAT
     23#  define TEST_CPP_DEC_FLOAT
    2424
    2525#ifdef _MSC_VER
     
    4141#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    4242#endif
    43 #ifdef TEST_CPP_FLOAT
    44 #include <boost/multiprecision/cpp_float.hpp>
     43#ifdef TEST_CPP_DEC_FLOAT
     44#include <boost/multiprecision/cpp_dec_float.hpp>
    4545#endif
    4646
     
    206206   test<boost::multiprecision::mpfr_float_100>();
    207207#endif
    208 #ifdef TEST_CPP_FLOAT
     208#ifdef TEST_CPP_DEC_FLOAT
    209209   test<boost::multiprecision::cpp_float_50>();
    210210   test<boost::multiprecision::cpp_float_100>();
  • sandbox/big_number/libs/multiprecision/test/test_numeric_limits.cpp

    r75832 r77032  
    1010#include "test.hpp"
    1111
    12 #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)
     12#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)
    1313#  define TEST_MPF_50
    1414#  define TEST_MPF
     
    1717#  define TEST_MPFR
    1818#  define TEST_MPFR_50
    19 #  define TEST_CPP_FLOAT
     19#  define TEST_CPP_DEC_FLOAT
    2020#  define TEST_MPQ
    2121#  define TEST_TOMMATH
     
    3636#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    3737#endif
    38 #ifdef TEST_CPP_FLOAT
    39 #include <boost/multiprecision/cpp_float.hpp>
     38#ifdef TEST_CPP_DEC_FLOAT
     39#include <boost/multiprecision/cpp_dec_float.hpp>
    4040#endif
    4141#if defined(TEST_MPFR) || defined(TEST_MPFR_50)
     
    6161   BOOST_CHECK(boost::math::isnormal(sqrt(minv)));
    6262   BOOST_CHECK(boost::math::isnormal(sqrt(maxv)));
     63
     64   if(std::numeric_limits<Number>::is_specialized)
     65   {
     66      if(std::numeric_limits<Number>::has_quiet_NaN)
     67      {
     68         BOOST_TEST((boost::math::isnan)(std::numeric_limits<Number>::quiet_NaN()));
     69         BOOST_TEST(FP_NAN == (boost::math::fpclassify)(std::numeric_limits<Number>::quiet_NaN()));
     70         BOOST_TEST(!(boost::math::isfinite)(std::numeric_limits<Number>::quiet_NaN()));
     71         BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::quiet_NaN()));
     72         BOOST_TEST(!(boost::math::isinf)(std::numeric_limits<Number>::quiet_NaN()));
     73      }
     74      if(std::numeric_limits<Number>::has_signaling_NaN)
     75      {
     76         BOOST_TEST((boost::math::isnan)(std::numeric_limits<Number>::signaling_NaN()));
     77         BOOST_TEST(FP_NAN == (boost::math::fpclassify)(std::numeric_limits<Number>::signaling_NaN()));
     78         BOOST_TEST(!(boost::math::isfinite)(std::numeric_limits<Number>::signaling_NaN()));
     79         BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::signaling_NaN()));
     80         BOOST_TEST(!(boost::math::isinf)(std::numeric_limits<Number>::signaling_NaN()));
     81      }
     82      if(std::numeric_limits<Number>::has_infinity)
     83      {
     84         BOOST_TEST((boost::math::isinf)(std::numeric_limits<Number>::infinity()));
     85         BOOST_TEST(FP_INFINITE == (boost::math::fpclassify)(std::numeric_limits<Number>::infinity()));
     86         BOOST_TEST(!(boost::math::isfinite)(std::numeric_limits<Number>::infinity()));
     87         BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::infinity()));
     88         BOOST_TEST(!(boost::math::isnan)(std::numeric_limits<Number>::infinity()));
     89      }
     90      if(std::numeric_limits<Number>::has_denorm)
     91      {
     92         BOOST_TEST(FP_SUBNORMAL == (boost::math::fpclassify)(std::numeric_limits<Number>::denorm_min()));
     93         BOOST_TEST((boost::math::isfinite)(std::numeric_limits<Number>::denorm_min()));
     94         BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::denorm_min()));
     95         BOOST_TEST(!(boost::math::isinf)(std::numeric_limits<Number>::denorm_min()));
     96         BOOST_TEST(!(boost::math::isnan)(std::numeric_limits<Number>::denorm_min()));
     97      }
     98   }
     99   Number n = 0;
     100   BOOST_TEST((boost::math::fpclassify)(n) == FP_ZERO);
     101   BOOST_TEST((boost::math::isfinite)(n));
     102   BOOST_TEST(!(boost::math::isnormal)(n));
     103   BOOST_TEST(!(boost::math::isinf)(n));
     104   BOOST_TEST(!(boost::math::isnan)(n));
     105   n = 2;
     106   BOOST_TEST((boost::math::fpclassify)(n) == FP_NORMAL);
     107   BOOST_TEST((boost::math::isfinite)(n));
     108   BOOST_TEST((boost::math::isnormal)(n));
     109   BOOST_TEST(!(boost::math::isinf)(n));
     110   BOOST_TEST(!(boost::math::isnan)(n));
    63111}
    64112
     
    113161   PRINT(round_style);
    114162
    115    if(std::numeric_limits<Number>::is_specialized)
    116    {
    117       if(std::numeric_limits<Number>::has_quiet_NaN)
    118       {
    119          BOOST_TEST((boost::math::isnan)(std::numeric_limits<Number>::quiet_NaN()));
    120          BOOST_TEST(FP_NAN == (boost::math::fpclassify)(std::numeric_limits<Number>::quiet_NaN()));
    121          BOOST_TEST(!(boost::math::isfinite)(std::numeric_limits<Number>::quiet_NaN()));
    122          BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::quiet_NaN()));
    123          BOOST_TEST(!(boost::math::isinf)(std::numeric_limits<Number>::quiet_NaN()));
    124       }
    125       if(std::numeric_limits<Number>::has_signaling_NaN)
    126       {
    127          BOOST_TEST((boost::math::isnan)(std::numeric_limits<Number>::signaling_NaN()));
    128          BOOST_TEST(FP_NAN == (boost::math::fpclassify)(std::numeric_limits<Number>::signaling_NaN()));
    129          BOOST_TEST(!(boost::math::isfinite)(std::numeric_limits<Number>::signaling_NaN()));
    130          BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::signaling_NaN()));
    131          BOOST_TEST(!(boost::math::isinf)(std::numeric_limits<Number>::signaling_NaN()));
    132       }
    133       if(std::numeric_limits<Number>::has_infinity)
    134       {
    135          BOOST_TEST((boost::math::isinf)(std::numeric_limits<Number>::infinity()));
    136          BOOST_TEST(FP_INFINITE == (boost::math::fpclassify)(std::numeric_limits<Number>::infinity()));
    137          BOOST_TEST(!(boost::math::isfinite)(std::numeric_limits<Number>::infinity()));
    138          BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::infinity()));
    139          BOOST_TEST(!(boost::math::isnan)(std::numeric_limits<Number>::infinity()));
    140       }
    141       if(std::numeric_limits<Number>::has_denorm)
    142       {
    143          BOOST_TEST(FP_SUBNORMAL == (boost::math::fpclassify)(std::numeric_limits<Number>::denorm_min()));
    144          BOOST_TEST((boost::math::isfinite)(std::numeric_limits<Number>::denorm_min()));
    145          BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::denorm_min()));
    146          BOOST_TEST(!(boost::math::isinf)(std::numeric_limits<Number>::denorm_min()));
    147          BOOST_TEST(!(boost::math::isnan)(std::numeric_limits<Number>::denorm_min()));
    148       }
    149    }
    150    Number n = 0;
    151    BOOST_TEST((boost::math::fpclassify)(n) == FP_ZERO);
    152    BOOST_TEST((boost::math::isfinite)(n));
    153    BOOST_TEST(!(boost::math::isnormal)(n));
    154    BOOST_TEST(!(boost::math::isinf)(n));
    155    BOOST_TEST(!(boost::math::isnan)(n));
    156    n = 2;
    157    BOOST_TEST((boost::math::fpclassify)(n) == FP_NORMAL);
    158    BOOST_TEST((boost::math::isfinite)(n));
    159    BOOST_TEST((boost::math::isnormal)(n));
    160    BOOST_TEST(!(boost::math::isinf)(n));
    161    BOOST_TEST(!(boost::math::isnan)(n));
    162 
    163163   typedef typename boost::mpl::if_c<
    164164      std::numeric_limits<Number>::is_specialized,
     
    195195   test<boost::multiprecision::mpq_rational>();
    196196#endif
    197 #ifdef TEST_CPP_FLOAT
     197#ifdef TEST_CPP_DEC_FLOAT
    198198   test<boost::multiprecision::cpp_float_50>();
    199199   test<boost::multiprecision::cpp_float_100>();
  • sandbox/big_number/libs/multiprecision/test/test_pow.cpp

    r76412 r77032  
    1717#include "test.hpp"
    1818
    19 #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)
     19#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)
    2020#  define TEST_MPF_50
    2121//#  define TEST_MPF
    2222#  define TEST_BACKEND
    23 #  define TEST_CPP_FLOAT
     23#  define TEST_CPP_DEC_FLOAT
    2424#  define TEST_MPFR_50
    2525
     
    4242#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    4343#endif
    44 #ifdef TEST_CPP_FLOAT
    45 #include <boost/multiprecision/cpp_float.hpp>
     44#ifdef TEST_CPP_DEC_FLOAT
     45#include <boost/multiprecision/cpp_dec_float.hpp>
    4646#endif
    4747
     
    581581   test<boost::multiprecision::mpfr_float_100>();
    582582#endif
    583 #ifdef TEST_CPP_FLOAT
     583#ifdef TEST_CPP_DEC_FLOAT
    584584   test<boost::multiprecision::cpp_float_50>();
    585585   test<boost::multiprecision::cpp_float_100>();
  • sandbox/big_number/libs/multiprecision/test/test_round.cpp

    r75586 r77032  
    1616#include "test.hpp"
    1717
    18 #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)
     18#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)
    1919#  define TEST_MPF_50
    2020#  define TEST_MPFR_50
    2121#  define TEST_BACKEND
    22 #  define TEST_CPP_FLOAT
     22#  define TEST_CPP_DEC_FLOAT
    2323
    2424#ifdef _MSC_VER
     
    4040#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    4141#endif
    42 #ifdef TEST_CPP_FLOAT
    43 #include <boost/multiprecision/cpp_float.hpp>
     42#ifdef TEST_CPP_DEC_FLOAT
     43#include <boost/multiprecision/cpp_dec_float.hpp>
    4444#endif
    4545
     
    387387   test<boost::multiprecision::mpfr_float_100>();
    388388#endif
    389 #ifdef TEST_CPP_FLOAT
     389#ifdef TEST_CPP_DEC_FLOAT
    390390   test<boost::multiprecision::cpp_float_50>();
    391391   test<boost::multiprecision::cpp_float_100>();
  • sandbox/big_number/libs/multiprecision/test/test_sin.cpp

    r76412 r77032  
    1717#include "test.hpp"
    1818
    19 #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)
     19#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)
    2020#  define TEST_MPF_50
    2121//#  define TEST_MPF
    2222#  define TEST_BACKEND
    23 #  define TEST_CPP_FLOAT
     23#  define TEST_CPP_DEC_FLOAT
    2424
    2525#ifdef _MSC_VER
     
    4141#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    4242#endif
    43 #ifdef TEST_CPP_FLOAT
    44 #include <boost/multiprecision/cpp_float.hpp>
     43#ifdef TEST_CPP_DEC_FLOAT
     44#include <boost/multiprecision/cpp_dec_float.hpp>
    4545#endif
    4646
     
    290290   test<boost::multiprecision::mpfr_float_100>();
    291291#endif
    292 #ifdef TEST_CPP_FLOAT
     292#ifdef TEST_CPP_DEC_FLOAT
    293293   test<boost::multiprecision::cpp_float_50>();
    294294#endif
  • sandbox/big_number/libs/multiprecision/test/test_sinh.cpp

    r76412 r77032  
    1717#include "test.hpp"
    1818
    19 #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)
     19#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)
    2020#  define TEST_MPF_50
    2121//#  define TEST_MPF
    2222#  define TEST_BACKEND
    23 #  define TEST_CPP_FLOAT
     23#  define TEST_CPP_DEC_FLOAT
    2424
    2525#ifdef _MSC_VER
     
    4141#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    4242#endif
    43 #ifdef TEST_CPP_FLOAT
    44 #include <boost/multiprecision/cpp_float.hpp>
     43#ifdef TEST_CPP_DEC_FLOAT
     44#include <boost/multiprecision/cpp_dec_float.hpp>
    4545#endif
    4646
     
    214214   test<boost::multiprecision::mpfr_float_100>();
    215215#endif
    216 #ifdef TEST_CPP_FLOAT
     216#ifdef TEST_CPP_DEC_FLOAT
    217217   test<boost::multiprecision::cpp_float_50>();
    218218   test<boost::multiprecision::cpp_float_100>();
  • sandbox/big_number/libs/multiprecision/test/test_sqrt.cpp

    r76412 r77032  
    1717#include "test.hpp"
    1818
    19 #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)
     19#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)
    2020#  define TEST_MPF_50
    2121//#  define TEST_MPF
    2222#  define TEST_BACKEND
    23 #  define TEST_CPP_FLOAT
     23#  define TEST_CPP_DEC_FLOAT
    2424
    2525#ifdef _MSC_VER
     
    4141#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    4242#endif
    43 #ifdef TEST_CPP_FLOAT
    44 #include <boost/multiprecision/cpp_float.hpp>
     43#ifdef TEST_CPP_DEC_FLOAT
     44#include <boost/multiprecision/cpp_dec_float.hpp>
    4545#endif
    4646
     
    184184   test<boost::multiprecision::mpfr_float_100>();
    185185#endif
    186 #ifdef TEST_CPP_FLOAT
     186#ifdef TEST_CPP_DEC_FLOAT
    187187   test<boost::multiprecision::cpp_float_50>();
    188188   test<boost::multiprecision::cpp_float_100>();
  • sandbox/big_number/libs/multiprecision/test/test_tanh.cpp

    r76412 r77032  
    1717#include "test.hpp"
    1818
    19 #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)
     19#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)
    2020#  define TEST_MPF_50
    2121//#  define TEST_MPF
    2222#  define TEST_BACKEND
    23 #  define TEST_CPP_FLOAT
     23#  define TEST_CPP_DEC_FLOAT
    2424
    2525#ifdef _MSC_VER
     
    4141#include <boost/multiprecision/concepts/mp_number_architypes.hpp>
    4242#endif
    43 #ifdef TEST_CPP_FLOAT
    44 #include <boost/multiprecision/cpp_float.hpp>
     43#ifdef TEST_CPP_DEC_FLOAT
     44#include <boost/multiprecision/cpp_dec_float.hpp>
    4545#endif
    4646
     
    133133   test<boost::multiprecision::mpfr_float_100>();
    134134#endif
    135 #ifdef TEST_CPP_FLOAT
     135#ifdef TEST_CPP_DEC_FLOAT
    136136   test<boost::multiprecision::cpp_float_50>();
    137137   test<boost::multiprecision::cpp_float_100>();
  • sandbox/big_number/libs/multiprecision/test/test_test.cpp

    r75586 r77032  
    99
    1010#include "test.hpp"
    11 #include <boost/multiprecision/cpp_float.hpp>
     11#include <boost/multiprecision/cpp_dec_float.hpp>
    1212
    1313void proc_that_throws()
Note: See TracChangeset for help on using the changeset viewer.