ceph/src/boost/libs/multiprecision/test/test_sf_import_c99.cpp

   1 //  (C) Copyright John Maddock 2016.
   2 //  Use, modification and distribution are subject to the
   3 //  Boost Software License, Version 1.0. (See accompanying file
   4 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   5
   6 #ifdef _MSC_VER
   7 #  define _SCL_SECURE_NO_WARNINGS
   8 #endif
   9
  10 #if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT)\
  11    && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128)\
  12    && !defined(TEST_CPP_BIN_FLOAT)
  13 #  define TEST_MPF_50
  14 #  define TEST_MPFR_50
  15 #  define TEST_MPFI_50
  16 #  define TEST_CPP_DEC_FLOAT
  17 #  define TEST_FLOAT128
  18 #  define TEST_CPP_BIN_FLOAT
  19
  20 #ifdef _MSC_VER
  21 #pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
  22 #endif
  23 #ifdef __GNUC__
  24 #pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
  25 #endif
  26
  27 #endif
  28
  29 #if defined(TEST_MPF_50)
  30 #include <boost/multiprecision/gmp.hpp>
  31 #endif
  32 #ifdef TEST_MPFR_50
  33 #include <boost/multiprecision/mpfr.hpp>
  34 #endif
  35 #ifdef TEST_MPFI_50
  36 #include <boost/multiprecision/mpfi.hpp>
  37 #endif
  38 #ifdef TEST_CPP_DEC_FLOAT
  39 #include <boost/multiprecision/cpp_dec_float.hpp>
  40 #endif
  41 #ifdef TEST_CPP_BIN_FLOAT
  42 #include <boost/multiprecision/cpp_bin_float.hpp>
  43 #endif
  44 #ifdef TEST_FLOAT128
  45 #include <boost/multiprecision/float128.hpp>
  46 #endif
  47
  48 #include "test.hpp"
  49
  50 #ifdef signbit
  51 #undef signbit
  52 #endif
  53 #ifdef sign
  54 #undef sign
  55 #endif
  56 #ifdef changesign
  57 #undef changesign
  58 #endif
  59 #ifdef copysign
  60 #undef copysign
  61 #endif
  62 #ifdef fpclassify
  63 #undef fpclassify
  64 #endif
  65 #ifdef isinf
  66 #undef isinf
  67 #endif
  68 #ifdef isnan
  69 #undef isnan
  70 #endif
  71 #ifdef isnormal
  72 #undef isnormal
  73 #endif
  74
  75 template <class T, class U>
  76 void test_less(T a, U b)
  77 {
  78    BOOST_CHECK(a < b);
  79    BOOST_CHECK(a <= b);
  80    BOOST_CHECK(!(a > b));
  81    BOOST_CHECK(!(a >= b));
  82    BOOST_CHECK(!(a == b));
  83    BOOST_CHECK((a != b));
  84
  85    BOOST_CHECK(b > a);
  86    BOOST_CHECK(b >= a);
  87    BOOST_CHECK(!(b < a));
  88    BOOST_CHECK(!(b <= a));
  89    BOOST_CHECK(!(b == a));
  90    BOOST_CHECK((b != a));
  91
  92    BOOST_CHECK(isless(a, b));
  93    BOOST_CHECK(islessequal(a, b));
  94    BOOST_CHECK(!isgreater(a, b));
  95    BOOST_CHECK(!isgreaterequal(a, b));
  96    BOOST_CHECK(islessgreater(a, b));
  97
  98    BOOST_CHECK(!isless(b, a));
  99    BOOST_CHECK(!islessequal(b, a));
 100    BOOST_CHECK(isgreater(b, a));
 101    BOOST_CHECK(isgreaterequal(b, a));
 102    BOOST_CHECK(islessgreater(b, a));
 103 }
 104 template <class T, class U>
 105 void test_equal(T a, U b)
 106 {
 107    BOOST_CHECK(!(a < b));
 108    BOOST_CHECK(a <= b);
 109    BOOST_CHECK(!(a > b));
 110    BOOST_CHECK((a >= b));
 111    BOOST_CHECK((a == b));
 112    BOOST_CHECK(!(a != b));
 113
 114    BOOST_CHECK(!(b > a));
 115    BOOST_CHECK(b >= a);
 116    BOOST_CHECK(!(b < a));
 117    BOOST_CHECK((b <= a));
 118    BOOST_CHECK((b == a));
 119    BOOST_CHECK(!(b != a));
 120
 121    BOOST_CHECK(!isless(a, b));
 122    BOOST_CHECK(islessequal(a, b));
 123    BOOST_CHECK(!isgreater(a, b));
 124    BOOST_CHECK(isgreaterequal(a, b));
 125    BOOST_CHECK(!islessgreater(a, b));
 126
 127    BOOST_CHECK(!isless(b, a));
 128    BOOST_CHECK(islessequal(b, a));
 129    BOOST_CHECK(!isgreater(b, a));
 130    BOOST_CHECK(isgreaterequal(b, a));
 131    BOOST_CHECK(!islessgreater(b, a));
 132 }
 133 template <class T, class U>
 134 void test_unordered(T a, U b)
 135 {
 136    BOOST_CHECK(!(a < b));
 137    BOOST_CHECK(!(a <= b));
 138    BOOST_CHECK(!(a > b));
 139    BOOST_CHECK(!(a >= b));
 140    BOOST_CHECK(!(a == b));
 141    BOOST_CHECK((a != b));
 142
 143    BOOST_CHECK(!(b > a));
 144    BOOST_CHECK(!(b >= a));
 145    BOOST_CHECK(!(b < a));
 146    BOOST_CHECK(!(b <= a));
 147    BOOST_CHECK(!(b == a));
 148    BOOST_CHECK((b != a));
 149
 150    BOOST_CHECK(!isless(a, b));
 151    BOOST_CHECK(!islessequal(a, b));
 152    BOOST_CHECK(!isgreater(a, b));
 153    BOOST_CHECK(!isgreaterequal(a, b));
 154    BOOST_CHECK(!islessgreater(a, b));
 155
 156    BOOST_CHECK(!isless(b, a));
 157    BOOST_CHECK(!islessequal(b, a));
 158    BOOST_CHECK(!isgreater(b, a));
 159    BOOST_CHECK(!isgreaterequal(b, a));
 160    BOOST_CHECK(!islessgreater(b, a));
 161 }
 162
 163 template <class T>
 164 void test()
 165 {
 166    //
 167    // Basic sanity checks for C99 functions which are just imported versions
 168    // from Boost.Math.  These should still be found via ADL so no using declarations here...
 169    //
 170    T val = 2;
 171    BOOST_CHECK(signbit(val) == 0);
 172    BOOST_CHECK(signbit(val + 2) == 0);
 173    val = -val;
 174    BOOST_CHECK(signbit(val));
 175    BOOST_CHECK(signbit(val * 2));
 176
 177    val = 2;
 178    BOOST_CHECK_EQUAL(sign(val), 1);
 179    BOOST_CHECK_EQUAL(sign(val + 2), 1);
 180    val = -val;
 181    BOOST_CHECK_EQUAL(sign(val), -1);
 182    BOOST_CHECK_EQUAL(sign(val * 2), -1);
 183    val = 0;
 184    BOOST_CHECK_EQUAL(sign(val), 0);
 185    BOOST_CHECK_EQUAL(sign(val * 2), 0);
 186
 187    val = 2;
 188    BOOST_CHECK_EQUAL(changesign(val), -2);
 189    BOOST_CHECK_EQUAL(changesign(val * 2), -4);
 190    val = -2;
 191    BOOST_CHECK_EQUAL(changesign(val), 2);
 192    BOOST_CHECK_EQUAL(changesign(val * 2), 4);
 193    val = 0;
 194    BOOST_CHECK_EQUAL(changesign(val), 0);
 195    BOOST_CHECK_EQUAL(changesign(val * 2), 0);
 196    // Things involving signed zero, need to detect it first:
 197    T neg_zero_test = -(std::numeric_limits<T>::min)();
 198    neg_zero_test /= (std::numeric_limits<T>::max)();
 199    T one(1);
 200    bool test_signed_zero = !boost::multiprecision::is_interval_number<T>::value && std::numeric_limits<T>::has_infinity && (one / neg_zero_test < 0);
 201    if(test_signed_zero)
 202    {
 203       BOOST_CHECK(signbit(changesign(val)));
 204       BOOST_CHECK(signbit(changesign(val * 2)));
 205    }
 206
 207    T s = 2;
 208    val = 3;
 209    BOOST_CHECK_EQUAL(copysign(val, s), 3);
 210    BOOST_CHECK_EQUAL(copysign(val, s * -2), -3);
 211    BOOST_CHECK_EQUAL(copysign(-2 * val, s), 6);
 212    BOOST_CHECK_EQUAL(copysign(-2 * val, 2 * s), 6);
 213    s = -2;
 214    BOOST_CHECK_EQUAL(copysign(val, s), -3);
 215    BOOST_CHECK_EQUAL(copysign(val, s * -2), 3);
 216    BOOST_CHECK_EQUAL(copysign(-2 * val, s), -6);
 217    BOOST_CHECK_EQUAL(copysign(-2 * val, 2 * s), -6);
 218    val = -3;
 219    BOOST_CHECK_EQUAL(copysign(val, s), -3);
 220    BOOST_CHECK_EQUAL(copysign(val, s * -2), 3);
 221    BOOST_CHECK_EQUAL(copysign(-2 * val, s), -6);
 222    BOOST_CHECK_EQUAL(copysign(-2 * val, 2 * s), -6);
 223    s = 0;
 224    BOOST_CHECK_EQUAL(copysign(val, s), 3);
 225    // Things involving signed zero, need to detect it first:
 226    if(test_signed_zero)
 227    {
 228       BOOST_CHECK_EQUAL(copysign(val, s * -2), -3);
 229    }
 230    BOOST_CHECK_EQUAL(copysign(-2 * val, s), 6);
 231    BOOST_CHECK_EQUAL(copysign(-2 * val, 2 * s), 6);
 232    // Things involving signed zero, need to detect it first:
 233    if(test_signed_zero)
 234    {
 235       s = changesign(s);
 236       if(signbit(s))
 237       {
 238          BOOST_CHECK_EQUAL(copysign(val, s), -3);
 239          BOOST_CHECK_EQUAL(copysign(val, s * -2), 3);
 240          BOOST_CHECK_EQUAL(copysign(-2 * val, s), -6);
 241          BOOST_CHECK_EQUAL(copysign(-2 * val, 2 * s), -6);
 242       }
 243    }
 244
 245    val = 3;
 246    BOOST_CHECK_EQUAL(fpclassify(val), FP_NORMAL);
 247    BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_NORMAL);
 248    BOOST_CHECK(!isinf(val));
 249    BOOST_CHECK(!isinf(val + 2));
 250    BOOST_CHECK(!isnan(val));
 251    BOOST_CHECK(!isnan(val + 2));
 252    BOOST_CHECK(isnormal(val));
 253    BOOST_CHECK(isnormal(val + 2));
 254    val = -3;
 255    BOOST_CHECK_EQUAL(fpclassify(val), FP_NORMAL);
 256    BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_NORMAL);
 257    BOOST_CHECK(!isinf(val));
 258    BOOST_CHECK(!isinf(val + 2));
 259    BOOST_CHECK(!isnan(val));
 260    BOOST_CHECK(!isnan(val + 2));
 261    BOOST_CHECK(isnormal(val));
 262    BOOST_CHECK(isnormal(val + 2));
 263    val = 0;
 264    BOOST_CHECK_EQUAL(fpclassify(val), FP_ZERO);
 265    BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_ZERO);
 266    BOOST_CHECK(!isinf(val));
 267    BOOST_CHECK(!isinf(val + 2));
 268    BOOST_CHECK(!isnan(val));
 269    BOOST_CHECK(!isnan(val + 2));
 270    BOOST_CHECK(!isnormal(val));
 271    BOOST_CHECK(!isnormal(val * 2));
 272    BOOST_CHECK(!isnormal(val * -2));
 273    if(std::numeric_limits<T>::has_infinity)
 274    {
 275       val = std::numeric_limits<T>::infinity();
 276       BOOST_CHECK_EQUAL(fpclassify(val), FP_INFINITE);
 277       BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_INFINITE);
 278       BOOST_CHECK(isinf(val));
 279       BOOST_CHECK(isinf(val + 2));
 280       BOOST_CHECK(!isnan(val));
 281       BOOST_CHECK(!isnan(val + 2));
 282       BOOST_CHECK(!isnormal(val));
 283       BOOST_CHECK(!isnormal(val + 2));
 284       val = -val;
 285       BOOST_CHECK_EQUAL(fpclassify(val), FP_INFINITE);
 286       BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_INFINITE);
 287       BOOST_CHECK(isinf(val));
 288       BOOST_CHECK(isinf(val + 2));
 289       BOOST_CHECK(!isnan(val));
 290       BOOST_CHECK(!isnan(val + 2));
 291       BOOST_CHECK(!isnormal(val));
 292       BOOST_CHECK(!isnormal(val + 2));
 293    }
 294    if(std::numeric_limits<T>::has_quiet_NaN)
 295    {
 296       val = std::numeric_limits <T>::quiet_NaN();
 297       BOOST_CHECK_EQUAL(fpclassify(val), FP_NAN);
 298       BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_NAN);
 299       BOOST_CHECK(!isinf(val));
 300       BOOST_CHECK(!isinf(val + 2));
 301       BOOST_CHECK(isnan(val));
 302       BOOST_CHECK(isnan(val + 2));
 303       BOOST_CHECK(!isnormal(val));
 304       BOOST_CHECK(!isnormal(val + 2));
 305    }
 306    s = 8 * std::numeric_limits<T>::epsilon();
 307    val = 2.5;
 308    BOOST_CHECK_CLOSE_FRACTION(asinh(val), T("1.6472311463710957106248586104436196635044144301932365282203100930843983757633104078778420255069424907777006132075516484778755360595913172299093829522950397895699619540523579875476513967578478619028438291006578604823887119907434"), s);
 309    BOOST_CHECK_CLOSE_FRACTION(asinh(val + T(0)), T("1.6472311463710957106248586104436196635044144301932365282203100930843983757633104078778420255069424907777006132075516484778755360595913172299093829522950397895699619540523579875476513967578478619028438291006578604823887119907434"), s);
 310    BOOST_CHECK_CLOSE_FRACTION(acosh(val), T("1.5667992369724110786640568625804834938620823510926588639329459980122148134693922696279968499622201141051039184050936311066453565386393240356562374302417843319480223211857615778787272615171906055455922537080327062362258846337050"), s);
 311    BOOST_CHECK_CLOSE_FRACTION(acosh(val + T(0)), T("1.5667992369724110786640568625804834938620823510926588639329459980122148134693922696279968499622201141051039184050936311066453565386393240356562374302417843319480223211857615778787272615171906055455922537080327062362258846337050"), s);
 312    val = 0.5;
 313    BOOST_CHECK_CLOSE_FRACTION(atanh(val), T("0.5493061443340548456976226184612628523237452789113747258673471668187471466093044834368078774068660443939850145329789328711840021129652599105264009353836387053015813845916906835896868494221804799518712851583979557605727959588753"), s);
 314    BOOST_CHECK_CLOSE_FRACTION(atanh(val + T(0)), T("0.5493061443340548456976226184612628523237452789113747258673471668187471466093044834368078774068660443939850145329789328711840021129652599105264009353836387053015813845916906835896868494221804799518712851583979557605727959588753"), s);
 315    val = 55.25;
 316    BOOST_CHECK_CLOSE_FRACTION(cbrt(val), T("3.8087058015466360309383876359583281382991983919300128125378938779672144843676192684301168479657279498120767424724024965319869248797423276064015643361426189576415670917818313417529572608229017809069355688606687557031643655896118"), s);
 317    BOOST_CHECK_CLOSE_FRACTION(cbrt(val + T(0)), T("3.8087058015466360309383876359583281382991983919300128125378938779672144843676192684301168479657279498120767424724024965319869248797423276064015643361426189576415670917818313417529572608229017809069355688606687557031643655896118"), s);
 318    if(!boost::multiprecision::is_interval_number<T>::value)
 319    {
 320       val = 2.75;
 321       BOOST_CHECK_CLOSE_FRACTION(erf(val), T("0.9998993780778803631630956080249130432349352621422640655161095794654526422025908961447328296681056892975214344779300734620255391682713519265048496199034963706976420982849598189071465666866369396765001072187538732800143945532487"), s);
 322       BOOST_CHECK_CLOSE_FRACTION(erf(val + T(0)), T("0.9998993780778803631630956080249130432349352621422640655161095794654526422025908961447328296681056892975214344779300734620255391682713519265048496199034963706976420982849598189071465666866369396765001072187538732800143945532487"), s);
 323       BOOST_CHECK_CLOSE_FRACTION(erfc(val), T("0.0001006219221196368369043919750869567650647378577359344838904205345473577974091038552671703318943107024785655220699265379744608317286480734951503800965036293023579017150401810928534333133630603234998927812461267199856054467512"), s);
 324       BOOST_CHECK_CLOSE_FRACTION(erfc(val + T(0)), T("0.0001006219221196368369043919750869567650647378577359344838904205345473577974091038552671703318943107024785655220699265379744608317286480734951503800965036293023579017150401810928534333133630603234998927812461267199856054467512"), s);
 325    }
 326    val = 0.125;
 327    BOOST_CHECK_CLOSE_FRACTION(expm1(val), T("0.1331484530668263168290072278117938725655031317451816259128200360788235778800483865139399907949417285732315270156473075657048210452584733998785564025916995261162759280700397984729320345630340659469435372721057879969170503978449"), s);
 328    BOOST_CHECK_CLOSE_FRACTION(expm1(val + T(0)), T("0.1331484530668263168290072278117938725655031317451816259128200360788235778800483865139399907949417285732315270156473075657048210452584733998785564025916995261162759280700397984729320345630340659469435372721057879969170503978449"), s);
 329
 330    val = 20;
 331    s = 2;
 332    BOOST_CHECK_EQUAL(fdim(val, s), 18);
 333    BOOST_CHECK_EQUAL(fdim(s, val), 0);
 334    BOOST_CHECK_EQUAL(fdim(val, s * 2), 16);
 335    BOOST_CHECK_EQUAL(fdim(s * 2, val), 0);
 336    BOOST_CHECK_EQUAL(fdim(val, 2), 18);
 337    BOOST_CHECK_EQUAL(fdim(2, val), 0);
 338
 339    BOOST_CHECK_EQUAL(fmax(val, s), val);
 340    BOOST_CHECK_EQUAL(fmax(s, val), val);
 341    BOOST_CHECK_EQUAL(fmax(val * 2, s), val * 2);
 342    BOOST_CHECK_EQUAL(fmax(val, s * 2), val);
 343    BOOST_CHECK_EQUAL(fmax(val * 2, s * 2), val * 2);
 344    BOOST_CHECK_EQUAL(fmin(val, s), s);
 345    BOOST_CHECK_EQUAL(fmin(s, val), s);
 346    BOOST_CHECK_EQUAL(fmin(val * 2, s), s);
 347    BOOST_CHECK_EQUAL(fmin(val, s * 2), s * 2);
 348    BOOST_CHECK_EQUAL(fmin(val * 2, s * 2), s * 2);
 349
 350    BOOST_CHECK_EQUAL(fmax(val, 2), val);
 351    BOOST_CHECK_EQUAL(fmax(val, 2.0), val);
 352    BOOST_CHECK_EQUAL(fmax(20, s), val);
 353    BOOST_CHECK_EQUAL(fmax(20.0, s), val);
 354    BOOST_CHECK_EQUAL(fmin(val, 2), s);
 355    BOOST_CHECK_EQUAL(fmin(val, 2.0), s);
 356    BOOST_CHECK_EQUAL(fmin(20, s), s);
 357    BOOST_CHECK_EQUAL(fmin(20.0, s), s);
 358    if(std::numeric_limits<T>::has_quiet_NaN)
 359    {
 360       BOOST_CHECK_EQUAL(fmax(val, std::numeric_limits<T>::quiet_NaN()), val);
 361       BOOST_CHECK_EQUAL(fmax(std::numeric_limits<T>::quiet_NaN(), val), val);
 362       BOOST_CHECK_EQUAL(fmin(val, std::numeric_limits<T>::quiet_NaN()), val);
 363       BOOST_CHECK_EQUAL(fmin(std::numeric_limits<T>::quiet_NaN(), val), val);
 364    }
 365    if(std::numeric_limits<double>::has_quiet_NaN)
 366    {
 367       BOOST_CHECK_EQUAL(fmax(val, std::numeric_limits<double>::quiet_NaN()), val);
 368       BOOST_CHECK_EQUAL(fmax(std::numeric_limits<double>::quiet_NaN(), val), val);
 369       BOOST_CHECK_EQUAL(fmin(val, std::numeric_limits<double>::quiet_NaN()), val);
 370       BOOST_CHECK_EQUAL(fmin(std::numeric_limits<double>::quiet_NaN(), val), val);
 371    }
 372
 373    test_less(s, val);
 374    test_less(2, val);
 375    test_less(s, 20);
 376    test_less(s + 0, val);
 377    test_less(s, val * 1);
 378    test_less(s * 1, val * 1);
 379    test_less(s * 1, 20);
 380    test_less(s + 2, val * 2);
 381
 382    test_equal(val, val);
 383    test_equal(20, val);
 384    test_equal(val, 20);
 385    test_equal(val + 0, val);
 386    test_equal(val, val * 1);
 387    test_equal(val * 1, val * 1);
 388    test_equal(val * 1, 20);
 389    test_equal(val * 20, val * 20);
 390
 391    if(std::numeric_limits<T>::has_quiet_NaN)
 392    {
 393       s = std::numeric_limits<T>::quiet_NaN();
 394       test_unordered(s, val);
 395       test_unordered(s, 20);
 396       test_unordered(s + 0, val);
 397       test_unordered(s, val * 1);
 398       test_unordered(s * 1, val * 1);
 399       test_unordered(s * 1, 20);
 400       test_unordered(s + 2, val * 2);
 401       if(std::numeric_limits<double>::has_quiet_NaN)
 402       {
 403          double n = std::numeric_limits<double>::quiet_NaN();
 404          test_unordered(n, val);
 405       }
 406    }
 407
 408    T tol = 8 * std::numeric_limits<T>::epsilon();
 409    s = 2;
 410    BOOST_CHECK_CLOSE_FRACTION(T(hypot(val, s)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
 411    BOOST_CHECK_CLOSE_FRACTION(T(hypot(val, 2)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
 412    BOOST_CHECK_CLOSE_FRACTION(T(hypot(val, 2.0)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
 413    BOOST_CHECK_CLOSE_FRACTION(T(hypot(20, s)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
 414    BOOST_CHECK_CLOSE_FRACTION(T(hypot(20.0, s)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
 415    BOOST_CHECK_CLOSE_FRACTION(T(hypot(val * 1, s)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
 416    BOOST_CHECK_CLOSE_FRACTION(T(hypot(val * 1, s * 1)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
 417    BOOST_CHECK_CLOSE_FRACTION(T(hypot(val * 1, 2)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
 418    BOOST_CHECK_CLOSE_FRACTION(T(hypot(val * 1, 2.0)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
 419    BOOST_CHECK_CLOSE_FRACTION(T(hypot(20, s * 1)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
 420    BOOST_CHECK_CLOSE_FRACTION(T(hypot(20.0, s * 1)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
 421
 422    BOOST_CHECK_CLOSE_FRACTION(lgamma(val), T("39.339884187199494036224652394567381081691457206897853119937969989377572554993874476249340525204204720861169039582"), tol);
 423    BOOST_CHECK_CLOSE_FRACTION(lgamma(val + 0), T("39.339884187199494036224652394567381081691457206897853119937969989377572554993874476249340525204204720861169039582"), tol);
 424
 425    BOOST_CHECK_EQUAL(lrint(val), 20);
 426    BOOST_CHECK_EQUAL(lrint(val * 2), 40);
 427    BOOST_CHECK_EQUAL(llrint(val), 20);
 428    BOOST_CHECK_EQUAL(llrint(val * 2), 40);
 429
 430    val = 0.125;
 431    BOOST_CHECK_CLOSE_FRACTION(log1p(val), T("0.117783035656383454538794109470521705068480712564733141107348638794807720528133786929641528638208114949935615070"), tol);
 432    BOOST_CHECK_CLOSE_FRACTION(log1p(val + 0), T("0.117783035656383454538794109470521705068480712564733141107348638794807720528133786929641528638208114949935615070"), tol);
 433    val = 20;
 434    BOOST_CHECK_CLOSE_FRACTION(T(log2(val)), T("4.321928094887362347870319429489390175864831393024580612054756395815934776608625215850139743359370155099657371710"), tol);
 435    BOOST_CHECK_CLOSE_FRACTION(T(log2(val + 0)), T("4.321928094887362347870319429489390175864831393024580612054756395815934776608625215850139743359370155099657371710"), tol);
 436
 437    BOOST_CHECK_EQUAL(T(nearbyint(val)), 20);
 438    BOOST_CHECK_EQUAL(T(nearbyint(val + 0.25)), 20);
 439    BOOST_CHECK_EQUAL(T(rint(val)), 20);
 440    BOOST_CHECK_EQUAL(T(rint(val + 0.25)), 20);
 441
 442    BOOST_CHECK_GT(nextafter(val, T(200)), val);
 443    BOOST_CHECK_GT(nextafter(val + 0, T(200)), val);
 444    BOOST_CHECK_GT(nextafter(val + 0, T(200) + 1), val);
 445    BOOST_CHECK_GT(nextafter(val, T(200) + 1), val);
 446
 447    BOOST_CHECK_GT(nexttoward(val, T(200)), val);
 448    BOOST_CHECK_GT(nexttoward(val + 0, T(200)), val);
 449    BOOST_CHECK_GT(nexttoward(val + 0, T(200) + 1), val);
 450    BOOST_CHECK_GT(nexttoward(val, T(200) + 1), val);
 451
 452    val = 21;
 453    s = 5;
 454    BOOST_CHECK_EQUAL(T(remainder(val, s)), 1);
 455    BOOST_CHECK_EQUAL(T(remainder(val, 5)), 1);
 456    BOOST_CHECK_EQUAL(T(remainder(21, s)), 1);
 457    BOOST_CHECK_EQUAL(T(remainder(val * 1, s)), 1);
 458    BOOST_CHECK_EQUAL(T(remainder(val * 1, s * 1)), 1);
 459    BOOST_CHECK_EQUAL(T(remainder(val, s * 1)), 1);
 460    BOOST_CHECK_EQUAL(T(remainder(val * 1, 5)), 1);
 461    BOOST_CHECK_EQUAL(T(remainder(21, s * 1)), 1);
 462    int i(0);
 463    BOOST_CHECK_EQUAL(T(remquo(val, s, &i)), 1);
 464    BOOST_CHECK_EQUAL(i, 4);
 465    i = 0;
 466    BOOST_CHECK_EQUAL(T(remquo(val, 5, &i)), 1);
 467    BOOST_CHECK_EQUAL(i, 4);
 468    i = 0;
 469    BOOST_CHECK_EQUAL(T(remquo(21, s, &i)), 1);
 470    BOOST_CHECK_EQUAL(i, 4);
 471    i = 0;
 472    BOOST_CHECK_EQUAL(T(remquo(val * 1, s, &i)), 1);
 473    BOOST_CHECK_EQUAL(i, 4);
 474    i = 0;
 475    BOOST_CHECK_EQUAL(T(remquo(val * 1, s * 1, &i)), 1);
 476    BOOST_CHECK_EQUAL(i, 4);
 477    i = 0;
 478    BOOST_CHECK_EQUAL(T(remquo(val, s * 1, &i)), 1);
 479    BOOST_CHECK_EQUAL(i, 4);
 480    i = 0;
 481    BOOST_CHECK_EQUAL(T(remquo(val * 1, 5, &i)), 1);
 482    BOOST_CHECK_EQUAL(i, 4);
 483    i = 0;
 484    BOOST_CHECK_EQUAL(T(remquo(21, s * 1, &i)), 1);
 485    BOOST_CHECK_EQUAL(i, 4);
 486    i = 0;
 487    val = 5.25;
 488    tol = 3000;
 489    BOOST_CHECK_CLOSE_FRACTION(tgamma(val), T("35.211611852799685705225257690531248115026311138908448314086859575901217653313145619623624570033258659272301335544"), tol);
 490    BOOST_CHECK_CLOSE_FRACTION(tgamma(val + 1), T("184.86096222719834995243260287528905260388813347926935364895601277348139267989401450302402899267460796117958201160"), tol);
 491
 492    BOOST_CHECK_CLOSE_FRACTION(T(exp2(val)), T("38.054627680087074134959999057935229289375106958842157216608071191022933383261349115865003025220405558913196632792"), tol);
 493    BOOST_CHECK_CLOSE_FRACTION(T(exp2(val + 1)), T("76.109255360174148269919998115870458578750213917684314433216142382045866766522698231730006050440811117826393265585"), tol);
 494    val = 15;
 495    BOOST_CHECK_CLOSE_FRACTION(T(exp2(val)), T(32768uL), tol);
 496    BOOST_CHECK_CLOSE_FRACTION(T(exp2(val + 1)), T(65536uL), tol);
 497
 498    i = fpclassify(val) + isgreaterequal(val, s) + islessequal(val, s) + isnan(val) + isunordered(val, s)
 499       + isfinite(val) + isinf(val) + islessgreater(val, s) + isnormal(val) + signbit(val) + isgreater(val, s) + isless(val, s);
 500 }
 501
 502 template <class T>
 503 void test_poison()
 504 {
 505    // use these macros as proxies for determining C99 support:
 506 #if defined(FP_ILOGB0) && defined(FP_INFINITE)
 507    //
 508    // These tests verify that our function overloads for Boost.Multiprecision
 509    // don't do anything nasty to the std:: overloads for built in types:
 510    //
 511    using namespace std;
 512    using namespace boost::multiprecision;
 513    //using namespace boost::math;
 514
 515    T a(2), b(0.3f), c(4), result(0);
 516    int i;
 517
 518    result += abs(a);
 519    result += cosh(a);
 520    result += fmod(a, b);
 521    result += logb(a);
 522    result += remquo(a, b, &i);
 523    result += acos(b);
 524    result += erf(a);
 525    result += frexp(a, &i);
 526    result += lrint(a);
 527    result += rint(a);
 528    result += acosh(b);
 529    result += erfc(b);
 530    result += hypot(a, b);
 531    result += lround(c);
 532    result += round(c);
 533    result += asin(b);
 534    result += exp2(a);
 535    result += ilogb(b);
 536    result += modf(a, &b);
 537    result += scalbln(a, i);
 538    result += asinh(b);
 539    result += exp(b);
 540    result += ldexp(a, i);
 541    result += scalbn(a, i);
 542    result += atan(b);
 543    result += expm1(a);
 544    result += lgamma(a);
 545    result += sin(b);
 546    result += atan2(a, c);
 547    result += fabs(a);
 548    result += llrint(a);
 549    result += sinh(b);
 550    result += atanh(b);
 551    result += fdim(a, b);
 552    result += llround(a);
 553    result += nearbyint(a);
 554    result += sqrt(b);
 555    result += cbrt(a);
 556    result += floor(b);
 557    result += log(a);
 558    result += nextafter(a, b);
 559    result += tan(b);
 560    result += ceil(b);
 561    result += fma(a, b, c);
 562    result += log10(a);
 563    result += nexttoward(a, b);
 564    result += tanh(a);
 565    result += copysign(a, b);
 566    result += fmax(a, b);
 567    result += log1p(a);
 568    result += pow(a, b);
 569    result += tgamma(a);
 570    result += cos(b);
 571    result += fmin(a, b);
 572    result += log2(a);
 573    result += remainder(a, b);
 574    result += trunc(b);
 575    result += min(a, b);
 576    result += max(a, b);
 577
 578 #if !BOOST_WORKAROUND(BOOST_LIBSTDCXX_VERSION, < 60000)
 579
 580    i = fpclassify(a) + isgreaterequal(a, b) + islessequal(a, b) + isnan(a) + isunordered(a, b)
 581       + isfinite(a) + isinf(a) + islessgreater(a, b) + isnormal(a) + signbit(a) + isgreater(a, b) + isless(a, b);
 582 #endif
 583 #endif
 584 }
 585
 586 int main()
 587 {
 588    test_poison<float>();
 589    test_poison<double>();
 590 #ifdef TEST_MPF_50
 591    test<boost::multiprecision::mpf_float_50>();
 592    test<boost::multiprecision::mpf_float_100>();
 593 #endif
 594 #ifdef TEST_MPFR_50
 595    test<boost::multiprecision::mpfr_float_50>();
 596    test<boost::multiprecision::mpfr_float_100>();
 597 #endif
 598 #ifdef TEST_MPFI_50
 599    test<boost::multiprecision::mpfi_float_50>();
 600    test<boost::multiprecision::mpfi_float_100>();
 601 #endif
 602 #ifdef TEST_CPP_DEC_FLOAT
 603    test<boost::multiprecision::cpp_dec_float_50>();
 604    test<boost::multiprecision::cpp_dec_float_100>();
 605 #ifndef SLOW_COMPLER
 606    // Some "peculiar" digit counts which stress our code:
 607    test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
 608    test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
 609    test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
 610    test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
 611    test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61, long long> > >();
 612    test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60, long long> > >();
 613    test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59, long long, std::allocator<void> > > >();
 614    test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58, long long, std::allocator<void> > > >();
 615 #endif
 616 #endif
 617 #ifdef TEST_CPP_BIN_FLOAT
 618    test<boost::multiprecision::cpp_bin_float_50>();
 619    test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<100>, boost::multiprecision::et_on> >();
 620 #endif
 621 #ifdef TEST_FLOAT128
 622    test<boost::multiprecision::float128>();
 623 #endif
 624
 625    return boost::report_errors();
 626 }
 627
 628