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 #pragma warning(disable : 4127) // conditional expression is constant
   8 #endif
   9
  10 #if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT) && !defined(TEST_CPP_DEC_FLOAT_2) && !defined(TEST_CPP_DEC_FLOAT_3) && !defined(TEST_CPP_DEC_FLOAT_4) && !defined(TEST_CPP_DEC_FLOAT_5) && !defined(TEST_CPP_DEC_FLOAT_6) && !defined(TEST_CPP_BIN_FLOAT_2) && !defined(TEST_CPP_BIN_FLOAT_3)
  11 #define TEST_MPF_50
  12 #define TEST_MPFR_50
  13 #define TEST_MPFI_50
  14 #define TEST_CPP_DEC_FLOAT
  15 #define TEST_CPP_DEC_FLOAT_2
  16 #define TEST_CPP_DEC_FLOAT_3
  17 #define TEST_CPP_DEC_FLOAT_4
  18 #define TEST_CPP_DEC_FLOAT_5
  19 #define TEST_CPP_DEC_FLOAT_6
  20 #define TEST_FLOAT128
  21 #define TEST_CPP_BIN_FLOAT
  22 #define TEST_CPP_BIN_FLOAT_2
  23 #define TEST_CPP_BIN_FLOAT_3
  24
  25 #ifdef _MSC_VER
  26 #pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
  27 #endif
  28 #ifdef __GNUC__
  29 #pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
  30 #endif
  31
  32 #endif
  33
  34 #if defined(TEST_MPF_50)
  35 #include <boost/multiprecision/gmp.hpp>
  36 #endif
  37 #ifdef TEST_MPFR_50
  38 #include <boost/multiprecision/mpfr.hpp>
  39 #endif
  40 #ifdef TEST_MPFI_50
  41 #include <boost/multiprecision/mpfi.hpp>
  42 #endif
  43 #if defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_DEC_FLOAT_2) || defined(TEST_CPP_DEC_FLOAT_3) || defined(TEST_CPP_DEC_FLOAT_4) || defined(TEST_CPP_DEC_FLOAT_5) || defined(TEST_CPP_DEC_FLOAT_6)
  44 #include <boost/multiprecision/cpp_dec_float.hpp>
  45 #endif
  46 #if defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_BIN_FLOAT_2) || defined(TEST_CPP_BIN_FLOAT_3)
  47 #include <boost/multiprecision/cpp_bin_float.hpp>
  48 #include <boost/multiprecision/debug_adaptor.hpp>
  49 #endif
  50 #ifdef TEST_FLOAT128
  51 #include <boost/multiprecision/float128.hpp>
  52 #endif
  53
  54 #include <boost/math/constants/constants.hpp>
  55 #include <boost/math/special_functions/gamma.hpp>
  56 #include "test.hpp"
  57
  58 #ifdef signbit
  59 #undef signbit
  60 #endif
  61 #ifdef sign
  62 #undef sign
  63 #endif
  64 #ifdef changesign
  65 #undef changesign
  66 #endif
  67 #ifdef copysign
  68 #undef copysign
  69 #endif
  70 #ifdef fpclassify
  71 #undef fpclassify
  72 #endif
  73 #ifdef isinf
  74 #undef isinf
  75 #endif
  76 #ifdef isnan
  77 #undef isnan
  78 #endif
  79 #ifdef isnormal
  80 #undef isnormal
  81 #endif
  82
  83 #ifdef MPFR_VERSION_MAJOR
  84 #define BOOST_MPFR_VERSION MPFR_VERSION_MAJOR * 10000 + MPFR_VERSION_MINOR * 100 + MPFR_VERSION_PATCHLEVEL
  85 #endif
  86
  87 template <class T, class U>
  88 void test_less(T a, U b)
  89 {
  90    BOOST_CHECK(a < b);
  91    BOOST_CHECK(a <= b);
  92    BOOST_CHECK(!(a > b));
  93    BOOST_CHECK(!(a >= b));
  94    BOOST_CHECK(!(a == b));
  95    BOOST_CHECK((a != b));
  96
  97    BOOST_CHECK(b > a);
  98    BOOST_CHECK(b >= a);
  99    BOOST_CHECK(!(b < a));
 100    BOOST_CHECK(!(b <= a));
 101    BOOST_CHECK(!(b == a));
 102    BOOST_CHECK((b != a));
 103
 104    BOOST_CHECK(isless(a, b));
 105    BOOST_CHECK(islessequal(a, b));
 106    BOOST_CHECK(!isgreater(a, b));
 107    BOOST_CHECK(!isgreaterequal(a, b));
 108    BOOST_CHECK(islessgreater(a, b));
 109
 110    BOOST_CHECK(!isless(b, a));
 111    BOOST_CHECK(!islessequal(b, a));
 112    BOOST_CHECK(isgreater(b, a));
 113    BOOST_CHECK(isgreaterequal(b, a));
 114    BOOST_CHECK(islessgreater(b, a));
 115 }
 116 template <class T, class U>
 117 void test_equal(T a, U b)
 118 {
 119    BOOST_CHECK(!(a < b));
 120    BOOST_CHECK(a <= b);
 121    BOOST_CHECK(!(a > b));
 122    BOOST_CHECK((a >= b));
 123    BOOST_CHECK((a == b));
 124    BOOST_CHECK(!(a != b));
 125
 126    BOOST_CHECK(!(b > a));
 127    BOOST_CHECK(b >= a);
 128    BOOST_CHECK(!(b < a));
 129    BOOST_CHECK((b <= a));
 130    BOOST_CHECK((b == a));
 131    BOOST_CHECK(!(b != a));
 132
 133    BOOST_CHECK(!isless(a, b));
 134    BOOST_CHECK(islessequal(a, b));
 135    BOOST_CHECK(!isgreater(a, b));
 136    BOOST_CHECK(isgreaterequal(a, b));
 137    BOOST_CHECK(!islessgreater(a, b));
 138
 139    BOOST_CHECK(!isless(b, a));
 140    BOOST_CHECK(islessequal(b, a));
 141    BOOST_CHECK(!isgreater(b, a));
 142    BOOST_CHECK(isgreaterequal(b, a));
 143    BOOST_CHECK(!islessgreater(b, a));
 144 }
 145 template <class T, class U>
 146 void test_unordered(T a, U b)
 147 {
 148    BOOST_CHECK(!(a < b));
 149    BOOST_CHECK(!(a <= b));
 150    BOOST_CHECK(!(a > b));
 151    BOOST_CHECK(!(a >= b));
 152    BOOST_CHECK(!(a == b));
 153    BOOST_CHECK((a != b));
 154
 155    BOOST_CHECK(!(b > a));
 156    BOOST_CHECK(!(b >= a));
 157    BOOST_CHECK(!(b < a));
 158    BOOST_CHECK(!(b <= a));
 159    BOOST_CHECK(!(b == a));
 160    BOOST_CHECK((b != a));
 161
 162    BOOST_CHECK(!isless(a, b));
 163    BOOST_CHECK(!islessequal(a, b));
 164    BOOST_CHECK(!isgreater(a, b));
 165    BOOST_CHECK(!isgreaterequal(a, b));
 166    BOOST_CHECK(!islessgreater(a, b));
 167
 168    BOOST_CHECK(!isless(b, a));
 169    BOOST_CHECK(!islessequal(b, a));
 170    BOOST_CHECK(!isgreater(b, a));
 171    BOOST_CHECK(!isgreaterequal(b, a));
 172    BOOST_CHECK(!islessgreater(b, a));
 173 }
 174
 175 template <class T>
 176 void test()
 177 {
 178    //
 179    // Basic sanity checks for C99 functions which are just imported versions
 180    // from Boost.Math.  These should still be found via ADL so no using declarations here...
 181    //
 182    T val = 2;
 183    BOOST_CHECK(signbit(val) == 0);
 184    BOOST_CHECK(signbit(val + 2) == 0);
 185    val = -val;
 186    BOOST_CHECK(signbit(val));
 187    BOOST_CHECK(signbit(val * 2));
 188
 189    val = 2;
 190    BOOST_CHECK_EQUAL(sign(val), 1);
 191    BOOST_CHECK_EQUAL(sign(val + 2), 1);
 192    val = -val;
 193    BOOST_CHECK_EQUAL(sign(val), -1);
 194    BOOST_CHECK_EQUAL(sign(val * 2), -1);
 195    val = 0;
 196    BOOST_CHECK_EQUAL(sign(val), 0);
 197    BOOST_CHECK_EQUAL(sign(val * 2), 0);
 198
 199    val = 2;
 200    BOOST_CHECK_EQUAL(changesign(val), -2);
 201    BOOST_CHECK_EQUAL(changesign(val * 2), -4);
 202    val = -2;
 203    BOOST_CHECK_EQUAL(changesign(val), 2);
 204    BOOST_CHECK_EQUAL(changesign(val * 2), 4);
 205    val = 0;
 206    BOOST_CHECK_EQUAL(changesign(val), 0);
 207    BOOST_CHECK_EQUAL(changesign(val * 2), 0);
 208    // Things involving signed zero, need to detect it first:
 209    T neg_zero_test = -(std::numeric_limits<T>::min)();
 210    neg_zero_test /= (std::numeric_limits<T>::max)();
 211    T    one(1);
 212    bool test_signed_zero = !boost::multiprecision::is_interval_number<T>::value && std::numeric_limits<T>::has_infinity && (one / neg_zero_test < 0);
 213    if (test_signed_zero)
 214    {
 215       BOOST_CHECK(signbit(changesign(val)));
 216       BOOST_CHECK(signbit(changesign(val * 2)));
 217    }
 218
 219    T s = 2;
 220    val = 3;
 221    BOOST_CHECK_EQUAL(copysign(val, s), 3);
 222    BOOST_CHECK_EQUAL(copysign(val, s * -2), -3);
 223    BOOST_CHECK_EQUAL(copysign(-2 * val, s), 6);
 224    BOOST_CHECK_EQUAL(copysign(-2 * val, 2 * s), 6);
 225    s = -2;
 226    BOOST_CHECK_EQUAL(copysign(val, s), -3);
 227    BOOST_CHECK_EQUAL(copysign(val, s * -2), 3);
 228    BOOST_CHECK_EQUAL(copysign(-2 * val, s), -6);
 229    BOOST_CHECK_EQUAL(copysign(-2 * val, 2 * s), -6);
 230    val = -3;
 231    BOOST_CHECK_EQUAL(copysign(val, s), -3);
 232    BOOST_CHECK_EQUAL(copysign(val, s * -2), 3);
 233    BOOST_CHECK_EQUAL(copysign(-2 * val, s), -6);
 234    BOOST_CHECK_EQUAL(copysign(-2 * val, 2 * s), -6);
 235    s = 0;
 236    BOOST_CHECK_EQUAL(copysign(val, s), 3);
 237    // Things involving signed zero, need to detect it first:
 238    if (test_signed_zero)
 239    {
 240       BOOST_CHECK_EQUAL(copysign(val, s * -2), -3);
 241    }
 242    BOOST_CHECK_EQUAL(copysign(-2 * val, s), 6);
 243    BOOST_CHECK_EQUAL(copysign(-2 * val, 2 * s), 6);
 244    // Things involving signed zero, need to detect it first:
 245    if (test_signed_zero)
 246    {
 247       s = changesign(s);
 248       if (signbit(s))
 249       {
 250          BOOST_CHECK_EQUAL(copysign(val, s), -3);
 251          BOOST_CHECK_EQUAL(copysign(val, s * -2), 3);
 252          BOOST_CHECK_EQUAL(copysign(-2 * val, s), -6);
 253          BOOST_CHECK_EQUAL(copysign(-2 * val, 2 * s), -6);
 254       }
 255    }
 256
 257    val = 3;
 258    BOOST_CHECK_EQUAL(fpclassify(val), FP_NORMAL);
 259    BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_NORMAL);
 260    BOOST_CHECK(!isinf(val));
 261    BOOST_CHECK(!isinf(val + 2));
 262    BOOST_CHECK(!isnan(val));
 263    BOOST_CHECK(!isnan(val + 2));
 264    BOOST_CHECK(isnormal(val));
 265    BOOST_CHECK(isnormal(val + 2));
 266    val = -3;
 267    BOOST_CHECK_EQUAL(fpclassify(val), FP_NORMAL);
 268    BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_NORMAL);
 269    BOOST_CHECK(!isinf(val));
 270    BOOST_CHECK(!isinf(val + 2));
 271    BOOST_CHECK(!isnan(val));
 272    BOOST_CHECK(!isnan(val + 2));
 273    BOOST_CHECK(isnormal(val));
 274    BOOST_CHECK(isnormal(val + 2));
 275    val = 0;
 276    BOOST_CHECK_EQUAL(fpclassify(val), FP_ZERO);
 277    BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_ZERO);
 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    BOOST_CHECK(!isnormal(val * -2));
 285    if (std::numeric_limits<T>::has_infinity)
 286    {
 287       val = std::numeric_limits<T>::infinity();
 288       BOOST_CHECK_EQUAL(fpclassify(val), FP_INFINITE);
 289       BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_INFINITE);
 290       BOOST_CHECK(isinf(val));
 291       BOOST_CHECK(isinf(val + 2));
 292       BOOST_CHECK(!isnan(val));
 293       BOOST_CHECK(!isnan(val + 2));
 294       BOOST_CHECK(!isnormal(val));
 295       BOOST_CHECK(!isnormal(val + 2));
 296       val = -val;
 297       BOOST_CHECK_EQUAL(fpclassify(val), FP_INFINITE);
 298       BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_INFINITE);
 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    if (std::numeric_limits<T>::has_quiet_NaN)
 307    {
 308       val = std::numeric_limits<T>::quiet_NaN();
 309       BOOST_CHECK_EQUAL(fpclassify(val), FP_NAN);
 310       BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_NAN);
 311       BOOST_CHECK(!isinf(val));
 312       BOOST_CHECK(!isinf(val + 2));
 313       BOOST_CHECK(isnan(val));
 314       BOOST_CHECK(isnan(val + 2));
 315       BOOST_CHECK(!isnormal(val));
 316       BOOST_CHECK(!isnormal(val + 2));
 317    }
 318    s   = 8 * std::numeric_limits<T>::epsilon();
 319    val = 2.5;
 320    BOOST_CHECK_CLOSE_FRACTION(asinh(val), T("1.6472311463710957106248586104436196635044144301932365282203100930843983757633104078778420255069424907777006132075516484778755360595913172299093829522950397895699619540523579875476513967578478619028438291006578604823887119907434"), s);
 321    BOOST_CHECK_CLOSE_FRACTION(asinh(val + T(0)), T("1.6472311463710957106248586104436196635044144301932365282203100930843983757633104078778420255069424907777006132075516484778755360595913172299093829522950397895699619540523579875476513967578478619028438291006578604823887119907434"), s);
 322    BOOST_CHECK_CLOSE_FRACTION(acosh(val), T("1.5667992369724110786640568625804834938620823510926588639329459980122148134693922696279968499622201141051039184050936311066453565386393240356562374302417843319480223211857615778787272615171906055455922537080327062362258846337050"), s);
 323    BOOST_CHECK_CLOSE_FRACTION(acosh(val + T(0)), T("1.5667992369724110786640568625804834938620823510926588639329459980122148134693922696279968499622201141051039184050936311066453565386393240356562374302417843319480223211857615778787272615171906055455922537080327062362258846337050"), s);
 324    val = 0.5;
 325    BOOST_CHECK_CLOSE_FRACTION(atanh(val), T("0.5493061443340548456976226184612628523237452789113747258673471668187471466093044834368078774068660443939850145329789328711840021129652599105264009353836387053015813845916906835896868494221804799518712851583979557605727959588753"), s);
 326    BOOST_CHECK_CLOSE_FRACTION(atanh(val + T(0)), T("0.5493061443340548456976226184612628523237452789113747258673471668187471466093044834368078774068660443939850145329789328711840021129652599105264009353836387053015813845916906835896868494221804799518712851583979557605727959588753"), s);
 327    val = 55.25;
 328    BOOST_CHECK_CLOSE_FRACTION(cbrt(val), T("3.8087058015466360309383876359583281382991983919300128125378938779672144843676192684301168479657279498120767424724024965319869248797423276064015643361426189576415670917818313417529572608229017809069355688606687557031643655896118"), s);
 329    BOOST_CHECK_CLOSE_FRACTION(cbrt(val + T(0)), T("3.8087058015466360309383876359583281382991983919300128125378938779672144843676192684301168479657279498120767424724024965319869248797423276064015643361426189576415670917818313417529572608229017809069355688606687557031643655896118"), s);
 330    if (!boost::multiprecision::is_interval_number<T>::value)
 331    {
 332       val = 2.75;
 333       BOOST_CHECK_CLOSE_FRACTION(erf(val), T("0.9998993780778803631630956080249130432349352621422640655161095794654526422025908961447328296681056892975214344779300734620255391682713519265048496199034963706976420982849598189071465666866369396765001072187538732800143945532487"), s);
 334       BOOST_CHECK_CLOSE_FRACTION(erf(val + T(0)), T("0.9998993780778803631630956080249130432349352621422640655161095794654526422025908961447328296681056892975214344779300734620255391682713519265048496199034963706976420982849598189071465666866369396765001072187538732800143945532487"), s);
 335       BOOST_CHECK_CLOSE_FRACTION(erfc(val), T("0.0001006219221196368369043919750869567650647378577359344838904205345473577974091038552671703318943107024785655220699265379744608317286480734951503800965036293023579017150401810928534333133630603234998927812461267199856054467512"), s);
 336       BOOST_CHECK_CLOSE_FRACTION(erfc(val + T(0)), T("0.0001006219221196368369043919750869567650647378577359344838904205345473577974091038552671703318943107024785655220699265379744608317286480734951503800965036293023579017150401810928534333133630603234998927812461267199856054467512"), s);
 337    }
 338    val = 0.125;
 339    BOOST_CHECK_CLOSE_FRACTION(expm1(val), T("0.1331484530668263168290072278117938725655031317451816259128200360788235778800483865139399907949417285732315270156473075657048210452584733998785564025916995261162759280700397984729320345630340659469435372721057879969170503978449"), s);
 340    BOOST_CHECK_CLOSE_FRACTION(expm1(val + T(0)), T("0.1331484530668263168290072278117938725655031317451816259128200360788235778800483865139399907949417285732315270156473075657048210452584733998785564025916995261162759280700397984729320345630340659469435372721057879969170503978449"), s);
 341
 342    val = 20;
 343    s   = 2;
 344    BOOST_CHECK_EQUAL(fdim(val, s), 18);
 345    BOOST_CHECK_EQUAL(fdim(s, val), 0);
 346    BOOST_CHECK_EQUAL(fdim(val, s * 2), 16);
 347    BOOST_CHECK_EQUAL(fdim(s * 2, val), 0);
 348    BOOST_CHECK_EQUAL(fdim(val, 2), 18);
 349    BOOST_CHECK_EQUAL(fdim(2, val), 0);
 350
 351    BOOST_CHECK_EQUAL(fmax(val, s), val);
 352    BOOST_CHECK_EQUAL(fmax(s, val), val);
 353    BOOST_CHECK_EQUAL(fmax(val * 2, s), val * 2);
 354    BOOST_CHECK_EQUAL(fmax(val, s * 2), val);
 355    BOOST_CHECK_EQUAL(fmax(val * 2, s * 2), val * 2);
 356    BOOST_CHECK_EQUAL(fmin(val, s), s);
 357    BOOST_CHECK_EQUAL(fmin(s, val), s);
 358    BOOST_CHECK_EQUAL(fmin(val * 2, s), s);
 359    BOOST_CHECK_EQUAL(fmin(val, s * 2), s * 2);
 360    BOOST_CHECK_EQUAL(fmin(val * 2, s * 2), s * 2);
 361
 362    BOOST_CHECK_EQUAL(fmax(val, 2), val);
 363    BOOST_CHECK_EQUAL(fmax(val, 2.0), val);
 364    BOOST_CHECK_EQUAL(fmax(20, s), val);
 365    BOOST_CHECK_EQUAL(fmax(20.0, s), val);
 366    BOOST_CHECK_EQUAL(fmin(val, 2), s);
 367    BOOST_CHECK_EQUAL(fmin(val, 2.0), s);
 368    BOOST_CHECK_EQUAL(fmin(20, s), s);
 369    BOOST_CHECK_EQUAL(fmin(20.0, s), s);
 370    if (std::numeric_limits<T>::has_quiet_NaN)
 371    {
 372       BOOST_CHECK_EQUAL(fmax(val, std::numeric_limits<T>::quiet_NaN()), val);
 373       BOOST_CHECK_EQUAL(fmax(std::numeric_limits<T>::quiet_NaN(), val), val);
 374       BOOST_CHECK_EQUAL(fmin(val, std::numeric_limits<T>::quiet_NaN()), val);
 375       BOOST_CHECK_EQUAL(fmin(std::numeric_limits<T>::quiet_NaN(), val), val);
 376    }
 377    if (std::numeric_limits<double>::has_quiet_NaN)
 378    {
 379       BOOST_CHECK_EQUAL(fmax(val, std::numeric_limits<double>::quiet_NaN()), val);
 380       BOOST_CHECK_EQUAL(fmax(std::numeric_limits<double>::quiet_NaN(), val), val);
 381       BOOST_CHECK_EQUAL(fmin(val, std::numeric_limits<double>::quiet_NaN()), val);
 382       BOOST_CHECK_EQUAL(fmin(std::numeric_limits<double>::quiet_NaN(), val), val);
 383    }
 384
 385    test_less(s, val);
 386    test_less(2, val);
 387    test_less(s, 20);
 388    test_less(s + 0, val);
 389    test_less(s, val * 1);
 390    test_less(s * 1, val * 1);
 391    test_less(s * 1, 20);
 392    test_less(s + 2, val * 2);
 393
 394    test_equal(val, val);
 395    test_equal(20, val);
 396    test_equal(val, 20);
 397    test_equal(val + 0, val);
 398    test_equal(val, val * 1);
 399    test_equal(val * 1, val * 1);
 400    test_equal(val * 1, 20);
 401    test_equal(val * 20, val * 20);
 402
 403    if (std::numeric_limits<T>::has_quiet_NaN)
 404    {
 405       s = std::numeric_limits<T>::quiet_NaN();
 406       test_unordered(s, val);
 407       test_unordered(s, 20);
 408       test_unordered(s + 0, val);
 409       test_unordered(s, val * 1);
 410       test_unordered(s * 1, val * 1);
 411       test_unordered(s * 1, 20);
 412       test_unordered(s + 2, val * 2);
 413       if (std::numeric_limits<double>::has_quiet_NaN)
 414       {
 415          double n = std::numeric_limits<double>::quiet_NaN();
 416          test_unordered(n, val);
 417       }
 418    }
 419
 420    T tol = 8 * std::numeric_limits<T>::epsilon();
 421    s     = 2;
 422    BOOST_CHECK_CLOSE_FRACTION(T(hypot(val, s)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
 423    BOOST_CHECK_CLOSE_FRACTION(T(hypot(val, 2)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
 424    BOOST_CHECK_CLOSE_FRACTION(T(hypot(val, 2.0)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
 425    BOOST_CHECK_CLOSE_FRACTION(T(hypot(20, s)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
 426    BOOST_CHECK_CLOSE_FRACTION(T(hypot(20.0, s)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
 427    BOOST_CHECK_CLOSE_FRACTION(T(hypot(val * 1, s)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
 428    BOOST_CHECK_CLOSE_FRACTION(T(hypot(val * 1, s * 1)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
 429    BOOST_CHECK_CLOSE_FRACTION(T(hypot(val * 1, 2)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
 430    BOOST_CHECK_CLOSE_FRACTION(T(hypot(val * 1, 2.0)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
 431    BOOST_CHECK_CLOSE_FRACTION(T(hypot(20, s * 1)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
 432    BOOST_CHECK_CLOSE_FRACTION(T(hypot(20.0, s * 1)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
 433
 434    BOOST_CHECK_CLOSE_FRACTION(lgamma(val), T("39.339884187199494036224652394567381081691457206897853119937969989377572554993874476249340525204204720861169039582"), tol);
 435    BOOST_CHECK_CLOSE_FRACTION(lgamma(val + 0), T("39.339884187199494036224652394567381081691457206897853119937969989377572554993874476249340525204204720861169039582"), tol);
 436
 437    BOOST_CHECK_EQUAL(lrint(val), 20);
 438    BOOST_CHECK_EQUAL(lrint(val * 2), 40);
 439    BOOST_CHECK_EQUAL(llrint(val), 20);
 440    BOOST_CHECK_EQUAL(llrint(val * 2), 40);
 441
 442    val = 0.125;
 443    BOOST_CHECK_CLOSE_FRACTION(log1p(val), T("0.117783035656383454538794109470521705068480712564733141107348638794807720528133786929641528638208114949935615070"), tol);
 444    BOOST_CHECK_CLOSE_FRACTION(log1p(val + 0), T("0.117783035656383454538794109470521705068480712564733141107348638794807720528133786929641528638208114949935615070"), tol);
 445    val = 20;
 446    BOOST_CHECK_CLOSE_FRACTION(T(log2(val)), T("4.321928094887362347870319429489390175864831393024580612054756395815934776608625215850139743359370155099657371710"), tol);
 447    BOOST_CHECK_CLOSE_FRACTION(T(log2(val + 0)), T("4.321928094887362347870319429489390175864831393024580612054756395815934776608625215850139743359370155099657371710"), tol);
 448
 449    BOOST_CHECK_EQUAL(T(nearbyint(val)), 20);
 450    BOOST_CHECK_EQUAL(T(nearbyint(val + 0.25)), 20);
 451    BOOST_CHECK_EQUAL(T(rint(val)), 20);
 452    BOOST_CHECK_EQUAL(T(rint(val + 0.25)), 20);
 453
 454    BOOST_CHECK_GT(nextafter(val, T(200)), val);
 455    BOOST_CHECK_GT(nextafter(val + 0, T(200)), val);
 456    BOOST_CHECK_GT(nextafter(val + 0, T(200) + 1), val);
 457    BOOST_CHECK_GT(nextafter(val, T(200) + 1), val);
 458
 459    BOOST_CHECK_GT(nexttoward(val, T(200)), val);
 460    BOOST_CHECK_GT(nexttoward(val + 0, T(200)), val);
 461    BOOST_CHECK_GT(nexttoward(val + 0, T(200) + 1), val);
 462    BOOST_CHECK_GT(nexttoward(val, T(200) + 1), val);
 463
 464    val = 21;
 465    s   = 5;
 466    BOOST_CHECK_EQUAL(T(remainder(val, s)), 1);
 467    BOOST_CHECK_EQUAL(T(remainder(val, 5)), 1);
 468    BOOST_CHECK_EQUAL(T(remainder(21, s)), 1);
 469    BOOST_CHECK_EQUAL(T(remainder(val * 1, s)), 1);
 470    BOOST_CHECK_EQUAL(T(remainder(val * 1, s * 1)), 1);
 471    BOOST_CHECK_EQUAL(T(remainder(val, s * 1)), 1);
 472    BOOST_CHECK_EQUAL(T(remainder(val * 1, 5)), 1);
 473    BOOST_CHECK_EQUAL(T(remainder(21, s * 1)), 1);
 474    int i(0);
 475    BOOST_CHECK_EQUAL(T(remquo(val, s, &i)), 1);
 476    BOOST_CHECK_EQUAL(i, 4);
 477    i = 0;
 478    BOOST_CHECK_EQUAL(T(remquo(val, 5, &i)), 1);
 479    BOOST_CHECK_EQUAL(i, 4);
 480    i = 0;
 481    BOOST_CHECK_EQUAL(T(remquo(21, s, &i)), 1);
 482    BOOST_CHECK_EQUAL(i, 4);
 483    i = 0;
 484    BOOST_CHECK_EQUAL(T(remquo(val * 1, s, &i)), 1);
 485    BOOST_CHECK_EQUAL(i, 4);
 486    i = 0;
 487    BOOST_CHECK_EQUAL(T(remquo(val * 1, s * 1, &i)), 1);
 488    BOOST_CHECK_EQUAL(i, 4);
 489    i = 0;
 490    BOOST_CHECK_EQUAL(T(remquo(val, s * 1, &i)), 1);
 491    BOOST_CHECK_EQUAL(i, 4);
 492    i = 0;
 493    BOOST_CHECK_EQUAL(T(remquo(val * 1, 5, &i)), 1);
 494    BOOST_CHECK_EQUAL(i, 4);
 495    i = 0;
 496    BOOST_CHECK_EQUAL(T(remquo(21, s * 1, &i)), 1);
 497    BOOST_CHECK_EQUAL(i, 4);
 498    i   = 0;
 499    val = 5.25;
 500    tol = 3000;
 501    BOOST_CHECK_CLOSE_FRACTION(tgamma(val), T("35.211611852799685705225257690531248115026311138908448314086859575901217653313145619623624570033258659272301335544"), tol);
 502    BOOST_CHECK_CLOSE_FRACTION(tgamma(val + 1), T("184.86096222719834995243260287528905260388813347926935364895601277348139267989401450302402899267460796117958201160"), tol);
 503
 504    BOOST_CHECK_CLOSE_FRACTION(T(exp2(val)), T("38.054627680087074134959999057935229289375106958842157216608071191022933383261349115865003025220405558913196632792"), tol);
 505    BOOST_CHECK_CLOSE_FRACTION(T(exp2(val + 1)), T("76.109255360174148269919998115870458578750213917684314433216142382045866766522698231730006050440811117826393265585"), tol);
 506    val = 15;
 507    BOOST_CHECK_CLOSE_FRACTION(T(exp2(val)), T(32768uL), tol);
 508    BOOST_CHECK_CLOSE_FRACTION(T(exp2(val + 1)), T(65536uL), tol);
 509
 510    i = fpclassify(val) + isgreaterequal(val, s) + islessequal(val, s) + isnan(val) + isunordered(val, s) + isfinite(val) + isinf(val) + islessgreater(val, s) + isnormal(val) + signbit(val) + isgreater(val, s) + isless(val, s);
 511 }
 512
 513 template <class T>
 514 void test_poison()
 515 {
 516    // use these macros as proxies for determining C99 support:
 517 #if defined(FP_ILOGB0) && defined(FP_INFINITE)
 518    //
 519    // These tests verify that our function overloads for Boost.Multiprecision
 520    // don't do anything nasty to the std:: overloads for built in types:
 521    //
 522    using namespace std;
 523    using namespace boost::multiprecision;
 524    //using namespace boost::math;
 525
 526    T   a(2), b(0.3f), c(4), result(0);
 527    int i;
 528
 529    result += abs(a);
 530    result += cosh(a);
 531    result += fmod(a, b);
 532    result += logb(a);
 533    result += remquo(a, b, &i);
 534    result += acos(b);
 535    result += erf(a);
 536    result += frexp(a, &i);
 537    result += lrint(a);
 538    result += rint(a);
 539    result += acosh(b);
 540    result += erfc(b);
 541    result += hypot(a, b);
 542    result += lround(c);
 543    result += round(c);
 544    result += asin(b);
 545    result += exp2(a);
 546    result += ilogb(b);
 547    result += modf(a, &b);
 548    result += scalbln(a, i);
 549    result += asinh(b);
 550    result += exp(b);
 551    result += ldexp(a, i);
 552    result += scalbn(a, i);
 553    result += atan(b);
 554    result += expm1(a);
 555    result += lgamma(a);
 556    result += sin(b);
 557    result += atan2(a, c);
 558    result += fabs(a);
 559    result += llrint(a);
 560    result += sinh(b);
 561    result += atanh(b);
 562    result += fdim(a, b);
 563    result += llround(a);
 564    result += nearbyint(a);
 565    result += sqrt(b);
 566    result += cbrt(a);
 567    result += floor(b);
 568    result += log(a);
 569    result += nextafter(a, b);
 570    result += tan(b);
 571    result += ceil(b);
 572    result += fma(a, b, c);
 573    result += log10(a);
 574    result += nexttoward(a, b);
 575    result += tanh(a);
 576    result += copysign(a, b);
 577    result += fmax(a, b);
 578    result += log1p(a);
 579    result += pow(a, b);
 580    result += tgamma(a);
 581    result += cos(b);
 582    result += fmin(a, b);
 583    result += log2(a);
 584    result += remainder(a, b);
 585    result += trunc(b);
 586    result += (min)(a, b);
 587    result += (max)(a, b);
 588
 589 #if !BOOST_WORKAROUND(BOOST_LIBSTDCXX_VERSION, < 60000)
 590
 591    i = fpclassify(a) + isgreaterequal(a, b) + islessequal(a, b) + isnan(a) + isunordered(a, b) + isfinite(a) + isinf(a) + islessgreater(a, b) + isnormal(a) + signbit(a) + isgreater(a, b) + isless(a, b);
 592 #endif
 593 #endif
 594 }
 595
 596 template <class T>
 597 bool type_sets_errno(const T&)
 598 {
 599    return true;
 600 }
 601 #ifdef TEST_MPFR_50
 602 template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
 603 bool type_sets_errno(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>&)
 604 {
 605    return false;
 606 }
 607 #endif
 608 #ifdef TEST_FLOAT128
 609 bool type_sets_errno(const boost::multiprecision::float128&)
 610 {
 611    return false;
 612 }
 613 #endif
 614
 615 template <class T>
 616 typename boost::enable_if_c<std::numeric_limits<T>::is_specialized>::type check_invalid(const T& val)
 617 {
 618    if (std::numeric_limits<T>::has_quiet_NaN)
 619    {
 620       BOOST_CHECK(isnan(val));
 621    }
 622    else
 623    {
 624       BOOST_CHECK_EQUAL(val, 0);
 625    }
 626    if (type_sets_errno(val))
 627       BOOST_CHECK_EQUAL(errno, EDOM);
 628    errno = 0;
 629 }
 630
 631 template <class T>
 632 typename boost::disable_if_c<std::numeric_limits<T>::is_specialized>::type check_invalid(const T& val)
 633 {
 634    check_invalid(static_cast<typename T::result_type>(val));
 635 }
 636
 637 template <class T>
 638 void check_erange(const T& val)
 639 {
 640    if (type_sets_errno(val))
 641       BOOST_CHECK_EQUAL(errno, ERANGE);
 642    errno = 0;
 643 }
 644
 645 template <class T>
 646 void test_c99_appendix_F()
 647 {
 648    //
 649    // Tests conformance to non-normative appendix F.9.1 of C99, basically how to handle
 650    // special cases, infinities and NaN's.
 651    //
 652    errno = 0;
 653    T tol = std::numeric_limits<T>::epsilon();
 654    // F.9.1.1:
 655    T arg = 1;
 656    T val = acos(arg);
 657    BOOST_CHECK_EQUAL(val, 0);
 658    BOOST_CHECK(signbit(val) == 0);
 659    arg = 2;
 660    check_invalid(acos(arg));
 661    arg = -2;
 662    check_invalid(acos(arg));
 663    if (std::numeric_limits<T>::has_infinity)
 664    {
 665       arg = std::numeric_limits<T>::infinity();
 666       check_invalid(acos(arg));
 667       arg = -std::numeric_limits<T>::infinity();
 668       check_invalid(acos(arg));
 669    }
 670    if (std::numeric_limits<T>::has_quiet_NaN)
 671    {
 672       arg = std::numeric_limits<T>::quiet_NaN();
 673       check_invalid(acos(arg));
 674       arg = -std::numeric_limits<T>::quiet_NaN();
 675       check_invalid(acos(arg));
 676    }
 677    // F.9.1.2:
 678    arg = 0;
 679    val = asin(arg);
 680    BOOST_CHECK_EQUAL(val, 0);
 681    BOOST_CHECK(signbit(val) == 0);
 682    arg = -arg;
 683    if (signbit(arg))
 684    {
 685       val = asin(arg);
 686       BOOST_CHECK_EQUAL(val, 0);
 687       BOOST_CHECK(signbit(val));
 688    }
 689    arg = 2;
 690    check_invalid(asin(arg));
 691    arg = -2;
 692    check_invalid(asin(arg));
 693    if (std::numeric_limits<T>::has_infinity)
 694    {
 695       arg = std::numeric_limits<T>::infinity();
 696       check_invalid(asin(arg));
 697       arg = -std::numeric_limits<T>::infinity();
 698       check_invalid(asin(arg));
 699    }
 700    if (std::numeric_limits<T>::has_quiet_NaN)
 701    {
 702       arg = std::numeric_limits<T>::quiet_NaN();
 703       check_invalid(asin(arg));
 704       arg = -std::numeric_limits<T>::quiet_NaN();
 705       check_invalid(asin(arg));
 706    }
 707    // F.9.1.3:
 708    arg = 0;
 709    val = atan(arg);
 710    BOOST_CHECK_EQUAL(val, 0);
 711    BOOST_CHECK(signbit(val) == 0);
 712    arg = -arg;
 713    if (signbit(arg))
 714    {
 715       val = atan(arg);
 716       BOOST_CHECK_EQUAL(val, 0);
 717       BOOST_CHECK(signbit(val));
 718    }
 719    if (std::numeric_limits<T>::has_infinity)
 720    {
 721       arg = std::numeric_limits<T>::infinity();
 722       val = atan(arg);
 723       BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi<T>());
 724       arg = -std::numeric_limits<T>::infinity();
 725       val = atan(arg);
 726       BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi<T>());
 727    }
 728    if (std::numeric_limits<T>::has_quiet_NaN)
 729    {
 730       arg = std::numeric_limits<T>::quiet_NaN();
 731       check_invalid(asin(arg));
 732       arg = -std::numeric_limits<T>::quiet_NaN();
 733       check_invalid(asin(arg));
 734    }
 735    // F.9.1.4:
 736    arg    = 0;
 737    T arg2 = 0;
 738    val    = atan2(arg, arg2);
 739    BOOST_CHECK_EQUAL(val, 0);
 740    BOOST_CHECK(signbit(val) == 0);
 741    arg = -arg;
 742    if (signbit(arg))
 743    {
 744       val = atan2(arg, arg2);
 745       BOOST_CHECK_EQUAL(val, 0);
 746       BOOST_CHECK(signbit(val));
 747    }
 748    arg2 = -arg2;
 749    if (signbit(arg2))
 750    {
 751       arg = 0;
 752       val = atan2(arg, arg2);
 753       BOOST_CHECK_EQUAL(val, boost::math::constants::pi<T>());
 754       BOOST_CHECK(signbit(val) == 0);
 755       arg = -arg;
 756       val = atan2(arg, arg2);
 757       BOOST_CHECK_EQUAL(val, -boost::math::constants::pi<T>());
 758       BOOST_CHECK(signbit(val));
 759    }
 760    arg  = 0;
 761    arg2 = -2;
 762    val  = atan2(arg, arg2);
 763    BOOST_CHECK_EQUAL(val, boost::math::constants::pi<T>());
 764    arg = -arg;
 765    if (signbit(arg))
 766    {
 767       val = atan2(arg, arg2);
 768       BOOST_CHECK_EQUAL(val, -boost::math::constants::pi<T>());
 769    }
 770    arg  = 0;
 771    arg2 = 2;
 772    val  = atan2(arg, arg2);
 773    BOOST_CHECK_EQUAL(val, 0);
 774    BOOST_CHECK(signbit(val) == 0);
 775    arg = -arg;
 776    if (signbit(arg))
 777    {
 778       val = atan2(arg, arg2);
 779       BOOST_CHECK_EQUAL(val, 0);
 780       BOOST_CHECK(signbit(val));
 781    }
 782    arg  = -2;
 783    arg2 = 0;
 784    val  = atan2(arg, arg2);
 785    BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi<T>());
 786    arg2 = -arg2;
 787    if (signbit(arg2))
 788    {
 789       val = atan2(arg, arg2);
 790       BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi<T>());
 791    }
 792    arg  = 2;
 793    arg2 = 0;
 794    val  = atan2(arg, arg2);
 795    BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi<T>());
 796    arg2 = -arg2;
 797    if (signbit(arg2))
 798    {
 799       val = atan2(arg, arg2);
 800       BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi<T>());
 801    }
 802    if (std::numeric_limits<T>::has_infinity)
 803    {
 804       arg  = 2;
 805       arg2 = -std::numeric_limits<T>::infinity();
 806       val  = atan2(arg, arg2);
 807       BOOST_CHECK_EQUAL(val, boost::math::constants::pi<T>());
 808       arg = -arg;
 809       val = atan2(arg, arg2);
 810       BOOST_CHECK_EQUAL(val, -boost::math::constants::pi<T>());
 811       arg  = 2;
 812       arg2 = std::numeric_limits<T>::infinity();
 813       val  = atan2(arg, arg2);
 814       BOOST_CHECK_EQUAL(val, 0);
 815       BOOST_CHECK(signbit(val) == 0);
 816       arg = -arg;
 817       if (signbit(-T(0)))
 818       {
 819          val = atan2(arg, arg2);
 820          BOOST_CHECK_EQUAL(val, 0);
 821          BOOST_CHECK(signbit(val));
 822       }
 823       arg  = std::numeric_limits<T>::infinity();
 824       arg2 = 2;
 825       val  = atan2(arg, arg2);
 826       BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi<T>());
 827       arg = -arg;
 828       val = atan2(arg, arg2);
 829       BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi<T>());
 830       arg  = std::numeric_limits<T>::infinity();
 831       arg2 = -2;
 832       val  = atan2(arg, arg2);
 833       BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi<T>());
 834       arg = -arg;
 835       val = atan2(arg, arg2);
 836       BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi<T>());
 837       arg  = std::numeric_limits<T>::infinity();
 838       arg2 = -std::numeric_limits<T>::infinity();
 839       val  = atan2(arg, arg2);
 840       BOOST_CHECK_CLOSE_FRACTION(val, boost::math::constants::three_quarters_pi<T>(), tol);
 841       arg = -arg;
 842       val = atan2(arg, arg2);
 843       BOOST_CHECK_CLOSE_FRACTION(val, -boost::math::constants::three_quarters_pi<T>(), tol);
 844       arg  = std::numeric_limits<T>::infinity();
 845       arg2 = std::numeric_limits<T>::infinity();
 846       val  = atan2(arg, arg2);
 847       BOOST_CHECK_CLOSE_FRACTION(val, ldexp(boost::math::constants::pi<T>(), -2), tol);
 848       arg = -arg;
 849       val = atan2(arg, arg2);
 850       BOOST_CHECK_CLOSE_FRACTION(val, -ldexp(boost::math::constants::pi<T>(), -2), tol);
 851       if (std::numeric_limits<T>::has_quiet_NaN)
 852       {
 853          arg  = std::numeric_limits<T>::quiet_NaN();
 854          arg2 = 2;
 855          check_invalid(atan2(arg, arg2));
 856          std::swap(arg, arg2);
 857          check_invalid(atan2(arg, arg2));
 858          arg = std::numeric_limits<T>::quiet_NaN();
 859          check_invalid(atan2(arg, arg2));
 860       }
 861    }
 862    // F.9.1.5:
 863    arg = 0;
 864    val = cos(arg);
 865    BOOST_CHECK_EQUAL(val, 1);
 866    arg = -arg;
 867    BOOST_CHECK_EQUAL(val, 1);
 868    if (std::numeric_limits<T>::has_infinity)
 869    {
 870       arg = std::numeric_limits<T>::infinity();
 871       check_invalid(cos(arg));
 872       arg = -std::numeric_limits<T>::infinity();
 873       check_invalid(cos(arg));
 874    }
 875    if (std::numeric_limits<T>::has_quiet_NaN)
 876    {
 877       arg = std::numeric_limits<T>::quiet_NaN();
 878       check_invalid(cos(arg));
 879       arg = -std::numeric_limits<T>::quiet_NaN();
 880       check_invalid(cos(arg));
 881    }
 882    // F.9.1.6:
 883    arg = 0;
 884    val = sin(arg);
 885    BOOST_CHECK_EQUAL(val, 0);
 886    BOOST_CHECK(signbit(val) == 0);
 887    arg = -arg;
 888    if (signbit(arg))
 889    {
 890       val = sin(arg);
 891       BOOST_CHECK_EQUAL(val, 0);
 892       BOOST_CHECK(signbit(val));
 893    }
 894    if (std::numeric_limits<T>::has_infinity)
 895    {
 896       arg = std::numeric_limits<T>::infinity();
 897       check_invalid(sin(arg));
 898       arg = -std::numeric_limits<T>::infinity();
 899       check_invalid(sin(arg));
 900    }
 901    if (std::numeric_limits<T>::has_quiet_NaN)
 902    {
 903       arg = std::numeric_limits<T>::quiet_NaN();
 904       check_invalid(sin(arg));
 905       arg = -std::numeric_limits<T>::quiet_NaN();
 906       check_invalid(sin(arg));
 907    }
 908    // F.9.1.7:
 909    arg = 0;
 910    val = tan(arg);
 911    BOOST_CHECK_EQUAL(val, 0);
 912    BOOST_CHECK(signbit(val) == 0);
 913    arg = -arg;
 914    if (signbit(arg))
 915    {
 916       val = tan(arg);
 917       BOOST_CHECK_EQUAL(val, 0);
 918       BOOST_CHECK(signbit(val));
 919    }
 920    if (std::numeric_limits<T>::has_infinity)
 921    {
 922       arg = std::numeric_limits<T>::infinity();
 923       check_invalid(tan(arg));
 924       arg = -std::numeric_limits<T>::infinity();
 925       check_invalid(tan(arg));
 926    }
 927    if (std::numeric_limits<T>::has_quiet_NaN)
 928    {
 929       arg = std::numeric_limits<T>::quiet_NaN();
 930       check_invalid(tan(arg));
 931       arg = -std::numeric_limits<T>::quiet_NaN();
 932       check_invalid(tan(arg));
 933    }
 934    // F.9.2.1:
 935    arg = 1;
 936    val = acosh(arg);
 937    BOOST_CHECK_EQUAL(val, 0);
 938    BOOST_CHECK(signbit(val) == 0);
 939    arg = -arg;
 940    check_invalid(acosh(arg));
 941    if (std::numeric_limits<T>::has_infinity)
 942    {
 943       arg = std::numeric_limits<T>::infinity();
 944       val = acosh(arg);
 945       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
 946
 947       arg = -std::numeric_limits<T>::infinity();
 948       check_invalid(acosh(arg));
 949    }
 950    if (std::numeric_limits<T>::has_quiet_NaN)
 951    {
 952       arg = std::numeric_limits<T>::quiet_NaN();
 953       check_invalid(acosh(arg));
 954       arg = -std::numeric_limits<T>::quiet_NaN();
 955       check_invalid(acosh(arg));
 956    }
 957    // F.9.2.2:
 958    arg = 0;
 959    val = asinh(arg);
 960    BOOST_CHECK_EQUAL(val, 0);
 961    BOOST_CHECK(signbit(val) == 0);
 962    arg = -arg;
 963    if (signbit(arg))
 964    {
 965       val = asinh(arg);
 966       BOOST_CHECK_EQUAL(val, 0);
 967       BOOST_CHECK(signbit(val));
 968    }
 969    if (std::numeric_limits<T>::has_infinity)
 970    {
 971       arg = std::numeric_limits<T>::infinity();
 972       val = asinh(arg);
 973       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
 974
 975       arg = -std::numeric_limits<T>::infinity();
 976       val = asinh(arg);
 977       BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
 978    }
 979    if (std::numeric_limits<T>::has_quiet_NaN)
 980    {
 981       arg = std::numeric_limits<T>::quiet_NaN();
 982       check_invalid(asinh(arg));
 983       arg = -std::numeric_limits<T>::quiet_NaN();
 984       check_invalid(asinh(arg));
 985    }
 986    // F.9.2.3:
 987    arg = 0;
 988    val = atanh(arg);
 989    BOOST_CHECK_EQUAL(val, 0);
 990    BOOST_CHECK(signbit(val) == 0);
 991    arg = -arg;
 992    if (signbit(arg))
 993    {
 994       val = atanh(arg);
 995       BOOST_CHECK_EQUAL(val, 0);
 996       BOOST_CHECK(signbit(val));
 997    }
 998    arg = 2;
 999    check_invalid(atanh(arg));
1000    arg = -3;
1001    check_invalid(atanh(arg));
1002
1003    if (std::numeric_limits<T>::has_infinity)
1004    {
1005       arg = 1;
1006       val = atanh(arg);
1007       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1008       BOOST_CHECK(signbit(val) == 0);
1009       check_erange(val);
1010       arg = -arg;
1011       val = atanh(arg);
1012       BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1013       BOOST_CHECK(signbit(val));
1014       check_erange(val);
1015
1016       arg = std::numeric_limits<T>::infinity();
1017       check_invalid(atanh(arg));
1018       arg = -std::numeric_limits<T>::infinity();
1019       check_invalid(atanh(arg));
1020    }
1021    if (std::numeric_limits<T>::has_quiet_NaN)
1022    {
1023       arg = std::numeric_limits<T>::quiet_NaN();
1024       check_invalid(atanh(arg));
1025       arg = -std::numeric_limits<T>::quiet_NaN();
1026       check_invalid(atanh(arg));
1027    }
1028    // F.9.2.4:
1029    arg = 0;
1030    val = cosh(arg);
1031    BOOST_CHECK_EQUAL(val, 1);
1032    arg = -arg;
1033    if (signbit(arg))
1034    {
1035       val = cosh(arg);
1036       BOOST_CHECK_EQUAL(val, 1);
1037    }
1038    if (std::numeric_limits<T>::has_infinity)
1039    {
1040       arg = (std::numeric_limits<T>::max)();
1041       val = cosh(arg);
1042       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1043       arg = -arg;
1044       val = cosh(arg);
1045       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1046       arg = std::numeric_limits<T>::infinity();
1047       val = cosh(arg);
1048       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1049       arg = -arg;
1050       val = cosh(arg);
1051       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1052    }
1053    if (std::numeric_limits<T>::has_quiet_NaN)
1054    {
1055       arg = std::numeric_limits<T>::quiet_NaN();
1056       check_invalid(cosh(arg));
1057       arg = -std::numeric_limits<T>::quiet_NaN();
1058       check_invalid(cosh(arg));
1059    }
1060    // F.9.2.5:
1061    arg = 0;
1062    val = sinh(arg);
1063    BOOST_CHECK_EQUAL(val, 0);
1064    BOOST_CHECK(signbit(val) == 0);
1065    arg = -arg;
1066    if (signbit(arg))
1067    {
1068       val = sinh(arg);
1069       BOOST_CHECK_EQUAL(val, 0);
1070       BOOST_CHECK(signbit(val));
1071    }
1072    if (std::numeric_limits<T>::has_infinity)
1073    {
1074       arg = (std::numeric_limits<T>::max)();
1075       val = sinh(arg);
1076       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1077       arg = -arg;
1078       val = sinh(arg);
1079       BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1080       arg = std::numeric_limits<T>::infinity();
1081       val = sinh(arg);
1082       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1083       arg = -arg;
1084       val = sinh(arg);
1085       BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1086    }
1087    if (std::numeric_limits<T>::has_quiet_NaN)
1088    {
1089       arg = std::numeric_limits<T>::quiet_NaN();
1090       check_invalid(sinh(arg));
1091       arg = -std::numeric_limits<T>::quiet_NaN();
1092       check_invalid(sinh(arg));
1093    }
1094    // F.9.2.6:
1095    arg = 0;
1096    val = tanh(arg);
1097    BOOST_CHECK_EQUAL(val, 0);
1098    BOOST_CHECK(signbit(val) == 0);
1099    arg = -arg;
1100    if (signbit(arg))
1101    {
1102       val = tanh(arg);
1103       BOOST_CHECK_EQUAL(val, 0);
1104       BOOST_CHECK(signbit(val));
1105    }
1106    arg = (std::numeric_limits<T>::max)();
1107    val = tanh(arg);
1108    BOOST_CHECK_EQUAL(val, 1);
1109    arg = -arg;
1110    val = tanh(arg);
1111    BOOST_CHECK_EQUAL(val, -1);
1112    if (std::numeric_limits<T>::has_infinity)
1113    {
1114       arg = std::numeric_limits<T>::infinity();
1115       val = tanh(arg);
1116       BOOST_CHECK_EQUAL(val, 1);
1117       arg = -arg;
1118       val = tanh(arg);
1119       BOOST_CHECK_EQUAL(val, -1);
1120    }
1121    if (std::numeric_limits<T>::has_quiet_NaN)
1122    {
1123       arg = std::numeric_limits<T>::quiet_NaN();
1124       check_invalid(tanh(arg));
1125       arg = -std::numeric_limits<T>::quiet_NaN();
1126       check_invalid(tanh(arg));
1127    }
1128    // F.9.3.1:
1129    arg = 0;
1130    val = exp(arg);
1131    BOOST_CHECK_EQUAL(val, 1);
1132    arg = -arg;
1133    if (signbit(arg))
1134    {
1135       val = exp(arg);
1136       BOOST_CHECK_EQUAL(val, 1);
1137    }
1138    if (std::numeric_limits<T>::has_infinity)
1139    {
1140       arg = std::numeric_limits<T>::infinity();
1141       val = exp(arg);
1142       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1143       arg = -arg;
1144       val = exp(arg);
1145       BOOST_CHECK_EQUAL(val, 0);
1146       BOOST_CHECK(signbit(val) == 0);
1147       arg = (std::numeric_limits<T>::max)();
1148       val = exp(arg);
1149       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1150       arg = -arg;
1151       val = exp(arg);
1152       BOOST_CHECK_EQUAL(val, 0);
1153       BOOST_CHECK(signbit(val) == 0);
1154    }
1155    if (std::numeric_limits<T>::has_quiet_NaN)
1156    {
1157       arg = std::numeric_limits<T>::quiet_NaN();
1158       check_invalid(exp(arg));
1159       arg = -std::numeric_limits<T>::quiet_NaN();
1160       check_invalid(exp(arg));
1161    }
1162    // F.9.3.2:
1163    arg = 0;
1164    val = exp2(arg);
1165    BOOST_CHECK_EQUAL(val, 1);
1166    arg = -arg;
1167    if (signbit(arg))
1168    {
1169       val = exp2(arg);
1170       BOOST_CHECK_EQUAL(val, 1);
1171    }
1172    if (std::numeric_limits<T>::has_infinity)
1173    {
1174       arg = std::numeric_limits<T>::infinity();
1175       val = exp2(arg);
1176       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1177       arg = -arg;
1178       val = exp2(arg);
1179       BOOST_CHECK_EQUAL(val, 0);
1180       BOOST_CHECK(signbit(val) == 0);
1181       arg = (std::numeric_limits<T>::max)();
1182       val = exp2(arg);
1183       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1184       arg = -arg;
1185       val = exp2(arg);
1186       BOOST_CHECK_EQUAL(val, 0);
1187       BOOST_CHECK(signbit(val) == 0);
1188    }
1189    if (std::numeric_limits<T>::has_quiet_NaN)
1190    {
1191       arg = std::numeric_limits<T>::quiet_NaN();
1192       check_invalid(exp2(arg));
1193       arg = -std::numeric_limits<T>::quiet_NaN();
1194       check_invalid(exp2(arg));
1195    }
1196    // F.9.3.3:
1197    arg = 0;
1198    val = expm1(arg);
1199    BOOST_CHECK_EQUAL(val, 0);
1200    BOOST_CHECK(signbit(val) == 0);
1201    arg = -arg;
1202    if (signbit(arg))
1203    {
1204       val = expm1(arg);
1205       BOOST_CHECK_EQUAL(val, 0);
1206       BOOST_CHECK(signbit(val));
1207    }
1208    if (std::numeric_limits<T>::has_infinity)
1209    {
1210       arg = std::numeric_limits<T>::infinity();
1211       val = expm1(arg);
1212       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1213       arg = -arg;
1214       val = expm1(arg);
1215       BOOST_CHECK_EQUAL(val, -1);
1216       arg = (std::numeric_limits<T>::max)();
1217       val = expm1(arg);
1218       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1219       arg = -arg;
1220       val = expm1(arg);
1221       BOOST_CHECK_EQUAL(val, -1);
1222    }
1223    if (std::numeric_limits<T>::has_quiet_NaN)
1224    {
1225       arg = std::numeric_limits<T>::quiet_NaN();
1226       check_invalid(expm1(arg));
1227       arg = -std::numeric_limits<T>::quiet_NaN();
1228       check_invalid(expm1(arg));
1229    }
1230    // F.9.3.4:
1231    arg = 0;
1232    int ival;
1233    val = frexp(arg, &ival);
1234    BOOST_CHECK_EQUAL(val, 0);
1235    BOOST_CHECK_EQUAL(ival, 0);
1236    BOOST_CHECK(signbit(val) == 0);
1237    arg = -arg;
1238    if (signbit(arg))
1239    {
1240       val = frexp(arg, &ival);
1241       BOOST_CHECK_EQUAL(val, 0);
1242       BOOST_CHECK(signbit(val));
1243       BOOST_CHECK(signbit(val));
1244    }
1245    if (std::numeric_limits<T>::has_infinity)
1246    {
1247       arg = std::numeric_limits<T>::infinity();
1248       val = frexp(arg, &ival);
1249       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1250       arg = -arg;
1251       val = frexp(arg, &ival);
1252       BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1253    }
1254    if (std::numeric_limits<T>::has_quiet_NaN)
1255    {
1256       arg = std::numeric_limits<T>::quiet_NaN();
1257       val = frexp(arg, &ival);
1258       BOOST_CHECK(isnan(val));
1259    }
1260    // F.9.3.5:
1261    typename T::backend_type::exponent_type eval;
1262    typename T::backend_type::exponent_type fp_ilogb0 = (std::numeric_limits<typename T::backend_type::exponent_type>::min)();
1263    typename T::backend_type::exponent_type fp_ilogbnan =
1264 #ifdef FP_ILOGBNAN
1265        FP_ILOGBNAN < 0 ? (std::numeric_limits<typename T::backend_type::exponent_type>::min)() : (std::numeric_limits<typename T::backend_type::exponent_type>::max)();
1266 #else
1267        INT_MAX;
1268 #endif
1269
1270    arg  = 0;
1271    eval = ilogb(arg);
1272    BOOST_CHECK_EQUAL(eval, fp_ilogb0);
1273    if (std::numeric_limits<T>::has_infinity)
1274    {
1275       arg  = std::numeric_limits<T>::infinity();
1276       eval = ilogb(arg);
1277       BOOST_CHECK_EQUAL(eval, (std::numeric_limits<typename T::backend_type::exponent_type>::max)());
1278       arg  = -arg;
1279       eval = ilogb(arg);
1280       BOOST_CHECK_EQUAL(eval, (std::numeric_limits<typename T::backend_type::exponent_type>::max)());
1281    }
1282    if (std::numeric_limits<T>::has_quiet_NaN)
1283    {
1284       arg  = std::numeric_limits<T>::quiet_NaN();
1285       eval = ilogb(arg);
1286       BOOST_CHECK_EQUAL(eval, fp_ilogbnan);
1287    }
1288    // F.9.3.7:
1289    arg = 1;
1290    val = log(arg);
1291    BOOST_CHECK_EQUAL(val, 0);
1292    BOOST_CHECK(signbit(val) == 0);
1293    if (std::numeric_limits<T>::has_infinity)
1294    {
1295       arg = 0;
1296       val = log(arg);
1297       BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1298       check_erange(val);
1299       arg = -arg;
1300       if (signbit(arg))
1301       {
1302          val = log(arg);
1303          BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1304          check_erange(val);
1305       }
1306       arg = -1;
1307       check_invalid(log(arg));
1308       arg = -std::numeric_limits<T>::infinity();
1309       check_invalid(log(arg));
1310       arg = std::numeric_limits<T>::infinity();
1311       val = log(arg);
1312       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1313    }
1314    if (std::numeric_limits<T>::has_quiet_NaN)
1315    {
1316       arg = std::numeric_limits<T>::quiet_NaN();
1317       check_invalid(log(arg));
1318       arg = -std::numeric_limits<T>::quiet_NaN();
1319       check_invalid(log(arg));
1320    }
1321    // F.9.3.8:
1322    arg = 1;
1323    val = log10(arg);
1324    BOOST_CHECK_EQUAL(val, 0);
1325    BOOST_CHECK(signbit(val) == 0);
1326    if (std::numeric_limits<T>::has_infinity)
1327    {
1328       arg = 0;
1329       val = log10(arg);
1330       BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1331       check_erange(val);
1332       arg = -arg;
1333       if (signbit(arg))
1334       {
1335          val = log10(arg);
1336          BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1337          check_erange(val);
1338       }
1339       arg = -1;
1340       check_invalid(log10(arg));
1341       arg = -std::numeric_limits<T>::infinity();
1342       check_invalid(log10(arg));
1343       arg = std::numeric_limits<T>::infinity();
1344       val = log10(arg);
1345       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1346    }
1347    if (std::numeric_limits<T>::has_quiet_NaN)
1348    {
1349       arg = std::numeric_limits<T>::quiet_NaN();
1350       check_invalid(log10(arg));
1351       arg = -std::numeric_limits<T>::quiet_NaN();
1352       check_invalid(log10(arg));
1353    }
1354    // F.9.3.9:
1355    arg = 0;
1356    val = log1p(arg);
1357    BOOST_CHECK_EQUAL(val, 0);
1358    BOOST_CHECK(signbit(val) == 0);
1359    arg = -arg;
1360    if (signbit(arg))
1361    {
1362       val = log1p(arg);
1363       BOOST_CHECK_EQUAL(val, 0);
1364       BOOST_CHECK(signbit(val));
1365    }
1366    if (std::numeric_limits<T>::has_infinity)
1367    {
1368       arg = -1;
1369       val = log1p(arg);
1370       BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1371       check_erange(val);
1372       arg = -2;
1373       check_invalid(log1p(arg));
1374       arg = -std::numeric_limits<T>::infinity();
1375       check_invalid(log1p(arg));
1376       arg = std::numeric_limits<T>::infinity();
1377       val = log1p(arg);
1378       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1379    }
1380    if (std::numeric_limits<T>::has_quiet_NaN)
1381    {
1382       arg = std::numeric_limits<T>::quiet_NaN();
1383       check_invalid(log1p(arg));
1384       arg = -std::numeric_limits<T>::quiet_NaN();
1385       check_invalid(log1p(arg));
1386    }
1387    // F.9.3.10:
1388    arg = 1;
1389    val = log2(arg);
1390    BOOST_CHECK_EQUAL(val, 0);
1391    BOOST_CHECK(signbit(val) == 0);
1392    if (std::numeric_limits<T>::has_infinity)
1393    {
1394       arg = 0;
1395       val = log2(arg);
1396       BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1397       check_erange(val);
1398       arg = -arg;
1399       if (signbit(arg))
1400       {
1401          val = log2(arg);
1402          BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1403          check_erange(val);
1404       }
1405       arg = -1;
1406       check_invalid(log2(arg));
1407       arg = -std::numeric_limits<T>::infinity();
1408       check_invalid(log2(arg));
1409       arg = std::numeric_limits<T>::infinity();
1410       val = log2(arg);
1411       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1412    }
1413    if (std::numeric_limits<T>::has_quiet_NaN)
1414    {
1415       arg = std::numeric_limits<T>::quiet_NaN();
1416       check_invalid(log2(arg));
1417       arg = -std::numeric_limits<T>::quiet_NaN();
1418       check_invalid(log2(arg));
1419    }
1420    // F.9.3.11:
1421    if (std::numeric_limits<T>::has_infinity)
1422    {
1423       arg = 0;
1424       val = logb(arg);
1425       BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1426       check_erange(val);
1427       arg = -arg;
1428       if (signbit(arg))
1429       {
1430          val = logb(arg);
1431          BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1432          check_erange(val);
1433       }
1434       arg = std::numeric_limits<T>::infinity();
1435       val = logb(arg);
1436       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1437       arg = -std::numeric_limits<T>::infinity();
1438       val = logb(arg);
1439       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1440    }
1441    if (std::numeric_limits<T>::has_quiet_NaN)
1442    {
1443       arg = std::numeric_limits<T>::quiet_NaN();
1444       check_invalid(logb(arg));
1445       arg = -std::numeric_limits<T>::quiet_NaN();
1446       check_invalid(logb(arg));
1447    }
1448    // F.9.3.13:
1449    arg = 0;
1450    val = scalbn(arg, 2);
1451    BOOST_CHECK_EQUAL(val, 0);
1452    BOOST_CHECK(signbit(val) == 0);
1453    arg = -arg;
1454    if (signbit(arg))
1455    {
1456       val = scalbn(arg, 2);
1457       BOOST_CHECK_EQUAL(val, 0);
1458       BOOST_CHECK(signbit(val));
1459    }
1460    if (std::numeric_limits<T>::has_infinity)
1461    {
1462       arg = std::numeric_limits<T>::infinity();
1463       val = scalbn(arg, -100);
1464       BOOST_CHECK_EQUAL(val, arg);
1465       arg = -arg;
1466       val = scalbn(arg, -100);
1467       BOOST_CHECK_EQUAL(val, arg);
1468    }
1469    // F.9.4.1:
1470    arg = 0;
1471    val = cbrt(arg);
1472    BOOST_CHECK_EQUAL(val, 0);
1473    BOOST_CHECK(signbit(val) == 0);
1474    arg = -arg;
1475    if (signbit(arg))
1476    {
1477       val = cbrt(arg);
1478       BOOST_CHECK_EQUAL(val, 0);
1479       BOOST_CHECK(signbit(val));
1480    }
1481 #if !(defined(TEST_FLOAT128) && defined(BOOST_GCC_VERSION) && (BOOST_GCC_VERSION < 40800))
1482    //
1483    // This test fails with early implementations of libquadmath - not our issue!
1484    //
1485    if (std::numeric_limits<T>::has_infinity)
1486    {
1487       arg = std::numeric_limits<T>::infinity();
1488       val = cbrt(arg);
1489       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1490       arg = -std::numeric_limits<T>::infinity();
1491       val = cbrt(arg);
1492       BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1493    }
1494 #endif
1495    if (std::numeric_limits<T>::has_quiet_NaN)
1496    {
1497       arg = std::numeric_limits<T>::quiet_NaN();
1498       check_invalid(cbrt(arg));
1499       arg = -std::numeric_limits<T>::quiet_NaN();
1500       check_invalid(cbrt(arg));
1501    }
1502    // F.9.4.2:
1503    arg = 0;
1504    val = fabs(arg);
1505    BOOST_CHECK_EQUAL(val, 0);
1506    BOOST_CHECK(signbit(val) == 0);
1507    arg = -arg;
1508    if (signbit(arg))
1509    {
1510       val = fabs(arg);
1511       BOOST_CHECK_EQUAL(val, 0);
1512       BOOST_CHECK(signbit(val) == 0);
1513    }
1514    if (std::numeric_limits<T>::has_infinity)
1515    {
1516       arg = std::numeric_limits<T>::infinity();
1517       val = fabs(arg);
1518       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1519       arg = -std::numeric_limits<T>::infinity();
1520       val = fabs(arg);
1521       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1522    }
1523    // F.9.4.3:
1524    arg  = 2;
1525    arg2 = 0;
1526    val  = hypot(arg, arg2);
1527    BOOST_CHECK_EQUAL(val, arg);
1528    arg2 = -arg2;
1529    val  = hypot(arg, arg2);
1530    BOOST_CHECK_EQUAL(val, arg);
1531    if (std::numeric_limits<T>::has_infinity)
1532    {
1533       arg  = std::numeric_limits<T>::infinity();
1534       arg2 = 2;
1535       val  = hypot(arg, arg2);
1536       BOOST_CHECK_EQUAL(val, arg);
1537       arg = -arg;
1538       val = hypot(arg, arg2);
1539       BOOST_CHECK_EQUAL(val, -arg);
1540       arg2 = std::numeric_limits<T>::quiet_NaN();
1541       val  = hypot(arg, arg2);
1542       BOOST_CHECK_EQUAL(val, -arg);
1543       arg = -arg;
1544       val = hypot(arg, arg2);
1545       BOOST_CHECK_EQUAL(val, arg);
1546    }
1547    // F.9.4.4:
1548    if (std::numeric_limits<T>::has_infinity)
1549    {
1550       arg  = 0;
1551       arg2 = -3;
1552       val  = pow(arg, arg2);
1553       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1554       check_erange(val);
1555       arg = -arg;
1556       if (signbit(arg))
1557       {
1558          val = pow(arg, arg2);
1559          BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1560          check_erange(val);
1561       }
1562       arg  = 0;
1563       arg2 = -2;
1564       val  = pow(arg, arg2);
1565       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1566       check_erange(val);
1567       arg = -arg;
1568       if (signbit(arg))
1569       {
1570          val = pow(arg, arg2);
1571          BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1572          check_erange(val);
1573       }
1574       arg  = 0;
1575       arg2 = 3;
1576       val  = pow(arg, arg2);
1577       BOOST_CHECK_EQUAL(val, 0);
1578       BOOST_CHECK(signbit(val) == 0);
1579       arg = -arg;
1580       if (signbit(arg))
1581       {
1582          val = pow(arg, arg2);
1583          BOOST_CHECK_EQUAL(val, 0);
1584          BOOST_CHECK(signbit(val));
1585       }
1586       arg  = 0;
1587       arg2 = 2;
1588       val  = pow(arg, arg2);
1589       BOOST_CHECK_EQUAL(val, 0);
1590       BOOST_CHECK(signbit(val) == 0);
1591       arg = -arg;
1592       if (signbit(arg))
1593       {
1594          val = pow(arg, arg2);
1595          BOOST_CHECK_EQUAL(val, 0);
1596          BOOST_CHECK(signbit(val) == 0);
1597       }
1598       arg  = -1;
1599       arg2 = std::numeric_limits<T>::infinity();
1600       val  = pow(arg, arg2);
1601       BOOST_CHECK_EQUAL(val, 1);
1602       arg2 = -std::numeric_limits<T>::infinity();
1603       val  = pow(arg, arg2);
1604       BOOST_CHECK_EQUAL(val, 1);
1605       arg  = 1;
1606       arg2 = 0;
1607       val  = pow(arg, arg2);
1608       BOOST_CHECK_EQUAL(val, 1);
1609       arg2 = std::numeric_limits<T>::infinity();
1610       val  = pow(arg, arg2);
1611       BOOST_CHECK_EQUAL(val, 1);
1612       arg2 = -std::numeric_limits<T>::infinity();
1613       val  = pow(arg, arg2);
1614       BOOST_CHECK_EQUAL(val, 1);
1615       arg2 = std::numeric_limits<T>::quiet_NaN();
1616       val  = pow(arg, arg2);
1617       BOOST_CHECK_EQUAL(val, 1);
1618       arg  = 0;
1619       arg2 = 0;
1620       val  = pow(arg, arg2);
1621       BOOST_CHECK_EQUAL(val, 1);
1622       arg2 = -arg2;
1623       val  = pow(arg, arg2);
1624       BOOST_CHECK_EQUAL(val, 1);
1625       arg = std::numeric_limits<T>::infinity();
1626       val = pow(arg, arg2);
1627       BOOST_CHECK_EQUAL(val, 1);
1628       arg2 = -arg2;
1629       val  = pow(arg, arg2);
1630       BOOST_CHECK_EQUAL(val, 1);
1631       arg = std::numeric_limits<T>::quiet_NaN();
1632       val = pow(arg, arg2);
1633       BOOST_CHECK_EQUAL(val, 1);
1634       arg2 = -arg2;
1635       val  = pow(arg, arg2);
1636       BOOST_CHECK_EQUAL(val, 1);
1637    }
1638    if (std::numeric_limits<T>::has_quiet_NaN)
1639    {
1640       arg  = -2.5;
1641       arg2 = 2.5;
1642       check_invalid(pow(arg, arg2));
1643    }
1644    if (std::numeric_limits<T>::has_infinity)
1645    {
1646       arg  = 0.5;
1647       arg2 = -std::numeric_limits<T>::infinity();
1648       val  = pow(arg, arg2);
1649       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1650       arg = -0.25;
1651       val = pow(arg, arg2);
1652       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1653       arg  = 2.5;
1654       arg2 = -std::numeric_limits<T>::infinity();
1655       val  = pow(arg, arg2);
1656       BOOST_CHECK_EQUAL(val, 0);
1657       arg = -arg;
1658       val = pow(arg, arg2);
1659       BOOST_CHECK_EQUAL(val, 0);
1660       arg  = 2.5;
1661       arg2 = std::numeric_limits<T>::infinity();
1662       val  = pow(arg, arg2);
1663       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1664       arg = -arg;
1665       val = pow(arg, arg2);
1666       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1667       arg  = -std::numeric_limits<T>::infinity();
1668       arg2 = -3;
1669       val  = pow(arg, arg2);
1670       BOOST_CHECK_EQUAL(val, 0);
1671       if (signbit(-T(0)))
1672          BOOST_CHECK(signbit(val));
1673       arg2 = -2;
1674       val  = pow(arg, arg2);
1675       BOOST_CHECK_EQUAL(val, 0);
1676       BOOST_CHECK(signbit(val) == 0);
1677       arg2 = -2.5;
1678       val  = pow(arg, arg2);
1679       BOOST_CHECK_EQUAL(val, 0);
1680       BOOST_CHECK(signbit(val) == 0);
1681       arg2 = 3;
1682       val  = pow(arg, arg2);
1683       BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1684       arg2 = 2;
1685       val  = pow(arg, arg2);
1686       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1687       arg2 = 2.5;
1688       val  = pow(arg, arg2);
1689       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1690       arg  = -arg; // +INF
1691       arg2 = -2;
1692       val  = pow(arg, arg2);
1693       BOOST_CHECK_EQUAL(val, 0);
1694       BOOST_CHECK(signbit(val) == 0);
1695       arg2 = -3;
1696       val  = pow(arg, arg2);
1697       BOOST_CHECK_EQUAL(val, 0);
1698       BOOST_CHECK(signbit(val) == 0);
1699       arg2 = -3.5;
1700       val  = pow(arg, arg2);
1701       BOOST_CHECK_EQUAL(val, 0);
1702       BOOST_CHECK(signbit(val) == 0);
1703       arg2 = 2;
1704       val  = pow(arg, arg2);
1705       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1706       arg2 = 3;
1707       val  = pow(arg, arg2);
1708       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1709       arg2 = 3.5;
1710       val  = pow(arg, arg2);
1711       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1712    }
1713    // F.9.4.5:
1714    arg = 0;
1715    val = sqrt(arg);
1716    BOOST_CHECK_EQUAL(val, 0);
1717    BOOST_CHECK(signbit(val) == 0);
1718    arg = -arg;
1719    if (signbit(arg))
1720    {
1721       val = sqrt(arg);
1722       BOOST_CHECK_EQUAL(val, 0);
1723       BOOST_CHECK(signbit(val));
1724    }
1725 #if !(defined(TEST_FLOAT128) && defined(BOOST_GCC_VERSION) && (BOOST_GCC_VERSION < 40800))
1726    //
1727    // This test fails with early implementations of libquadmath - not our issue!
1728    //
1729    if (std::numeric_limits<T>::has_infinity)
1730    {
1731       arg = std::numeric_limits<T>::infinity();
1732       val = sqrt(arg);
1733       BOOST_CHECK_EQUAL(val, arg);
1734       arg = -arg;
1735       check_invalid(sqrt(arg));
1736    }
1737 #endif
1738    if (std::numeric_limits<T>::has_quiet_NaN)
1739    {
1740       arg = std::numeric_limits<T>::quiet_NaN();
1741       check_invalid(sqrt(arg));
1742    }
1743    // F.9.5.1:
1744    arg = 0;
1745    val = erf(arg);
1746    BOOST_CHECK_EQUAL(val, 0);
1747    BOOST_CHECK(signbit(val) == 0);
1748    arg = -arg;
1749    if (signbit(arg))
1750    {
1751       val = erf(arg);
1752       BOOST_CHECK_EQUAL(val, 0);
1753       BOOST_CHECK(signbit(val));
1754    }
1755    if (std::numeric_limits<T>::has_infinity)
1756    {
1757       arg = std::numeric_limits<T>::infinity();
1758       val = erf(arg);
1759       BOOST_CHECK_EQUAL(val, 1);
1760       arg = -arg;
1761       val = erf(arg);
1762       BOOST_CHECK_EQUAL(val, -1);
1763    }
1764    if (std::numeric_limits<T>::has_quiet_NaN)
1765    {
1766       arg = std::numeric_limits<T>::quiet_NaN();
1767       check_invalid(erf(arg));
1768    }
1769    // F.9.5.2:
1770    if (std::numeric_limits<T>::has_infinity)
1771    {
1772       arg = std::numeric_limits<T>::infinity();
1773       val = erfc(arg);
1774       BOOST_CHECK_EQUAL(val, 0);
1775       BOOST_CHECK(signbit(val) == 0);
1776       arg = -arg;
1777       val = erfc(arg);
1778       BOOST_CHECK_EQUAL(val, 2);
1779    }
1780    if (std::numeric_limits<T>::has_quiet_NaN)
1781    {
1782       arg = std::numeric_limits<T>::quiet_NaN();
1783       check_invalid(erfc(arg));
1784    }
1785    // F.9.5.3:
1786    arg = 1;
1787    val = lgamma(arg);
1788    BOOST_CHECK_EQUAL(val, 0);
1789    BOOST_CHECK(signbit(val) == 0);
1790    arg = 2;
1791    val = lgamma(arg);
1792    BOOST_CHECK_EQUAL(val, 0);
1793    BOOST_CHECK(signbit(val) == 0);
1794 #if !defined(BOOST_MPFR_VERSION) || (BOOST_MPFR_VERSION > 30103)
1795    arg = 0;
1796    val = lgamma(arg);
1797    BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1798    check_erange(val);
1799    arg = -1;
1800    val = lgamma(arg);
1801    BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1802    check_erange(val);
1803    arg = -2;
1804    val = lgamma(arg);
1805    BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1806    check_erange(val);
1807    arg = -std::numeric_limits<T>::infinity();
1808    val = lgamma(arg);
1809    BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1810 #endif
1811    arg = std::numeric_limits<T>::infinity();
1812    val = lgamma(arg);
1813    BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1814    if (std::numeric_limits<T>::has_quiet_NaN)
1815    {
1816       arg = std::numeric_limits<T>::quiet_NaN();
1817       check_invalid(lgamma(arg));
1818    }
1819    // F.9.5.4:
1820    if (std::numeric_limits<T>::has_infinity)
1821    {
1822       arg = 0;
1823       val = tgamma(arg);
1824       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1825       check_erange(val);
1826       arg = -arg;
1827       if (signbit(arg))
1828       {
1829          val = tgamma(arg);
1830          BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1831          check_erange(val);
1832       }
1833       arg = -1;
1834       check_invalid(tgamma(arg));
1835       arg = -std::numeric_limits<T>::infinity();
1836       check_invalid(tgamma(arg));
1837       arg = std::numeric_limits<T>::infinity();
1838       val = tgamma(arg);
1839       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1840    }
1841    if (std::numeric_limits<T>::has_quiet_NaN)
1842    {
1843       arg = std::numeric_limits<T>::quiet_NaN();
1844       check_invalid(tgamma(arg));
1845    }
1846    // F.9.6.1:
1847    arg = 0;
1848    val = ceil(arg);
1849    BOOST_CHECK_EQUAL(val, 0);
1850    BOOST_CHECK(signbit(val) == 0);
1851    arg = -arg;
1852    if (signbit(arg))
1853    {
1854       val = ceil(arg);
1855       BOOST_CHECK_EQUAL(val, 0);
1856       BOOST_CHECK(signbit(val));
1857    }
1858    if (std::numeric_limits<T>::has_infinity)
1859    {
1860       arg = std::numeric_limits<T>::infinity();
1861       val = ceil(arg);
1862       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1863       arg = -arg;
1864       val = ceil(arg);
1865       BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1866    }
1867    if (std::numeric_limits<T>::has_quiet_NaN)
1868    {
1869       arg = std::numeric_limits<T>::quiet_NaN();
1870       check_invalid(ceil(arg));
1871    }
1872    // F.9.6.2:
1873    arg = 0;
1874    val = floor(arg);
1875    BOOST_CHECK_EQUAL(val, 0);
1876    BOOST_CHECK(signbit(val) == 0);
1877    arg = -arg;
1878    if (signbit(arg))
1879    {
1880       val = floor(arg);
1881       BOOST_CHECK_EQUAL(val, 0);
1882       BOOST_CHECK(signbit(val));
1883    }
1884    if (std::numeric_limits<T>::has_infinity)
1885    {
1886       arg = std::numeric_limits<T>::infinity();
1887       val = floor(arg);
1888       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1889       arg = -arg;
1890       val = floor(arg);
1891       BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1892    }
1893    if (std::numeric_limits<T>::has_quiet_NaN)
1894    {
1895       arg = std::numeric_limits<T>::quiet_NaN();
1896       check_invalid(floor(arg));
1897    }
1898    // F.9.6.3:
1899    arg = 0;
1900    val = nearbyint(arg);
1901    BOOST_CHECK_EQUAL(val, 0);
1902    BOOST_CHECK(signbit(val) == 0);
1903    arg = -arg;
1904    if (signbit(arg))
1905    {
1906       val = nearbyint(arg);
1907       BOOST_CHECK_EQUAL(val, 0);
1908       BOOST_CHECK(signbit(val));
1909    }
1910    if (std::numeric_limits<T>::has_infinity)
1911    {
1912       arg = std::numeric_limits<T>::infinity();
1913       val = nearbyint(arg);
1914       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1915       arg = -arg;
1916       val = nearbyint(arg);
1917       BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1918    }
1919    if (std::numeric_limits<T>::has_quiet_NaN)
1920    {
1921       arg = std::numeric_limits<T>::quiet_NaN();
1922       check_invalid(nearbyint(arg));
1923    }
1924    // F.9.6.4:
1925    arg = 0;
1926    val = rint(arg);
1927    BOOST_CHECK_EQUAL(val, 0);
1928    BOOST_CHECK(signbit(val) == 0);
1929    arg = -arg;
1930    if (signbit(arg))
1931    {
1932       val = rint(arg);
1933       BOOST_CHECK_EQUAL(val, 0);
1934       BOOST_CHECK(signbit(val));
1935    }
1936    if (std::numeric_limits<T>::has_infinity)
1937    {
1938       arg = std::numeric_limits<T>::infinity();
1939       val = rint(arg);
1940       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1941       arg = -arg;
1942       val = rint(arg);
1943       BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1944    }
1945    if (std::numeric_limits<T>::has_quiet_NaN)
1946    {
1947       arg = std::numeric_limits<T>::quiet_NaN();
1948       check_invalid(rint(arg));
1949    }
1950    // F.9.6.6:
1951    arg = 0;
1952    val = round(arg);
1953    BOOST_CHECK_EQUAL(val, 0);
1954    BOOST_CHECK(signbit(val) == 0);
1955    arg = -arg;
1956    if (signbit(arg))
1957    {
1958       val = round(arg);
1959       BOOST_CHECK_EQUAL(val, 0);
1960       BOOST_CHECK(signbit(val));
1961    }
1962    if (std::numeric_limits<T>::has_infinity)
1963    {
1964       arg = std::numeric_limits<T>::infinity();
1965       val = round(arg);
1966       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1967       arg = -arg;
1968       val = round(arg);
1969       BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1970    }
1971    if (std::numeric_limits<T>::has_quiet_NaN)
1972    {
1973       arg = std::numeric_limits<T>::quiet_NaN();
1974       check_invalid(round(arg));
1975    }
1976    // F.9.6.8:
1977    arg = 0;
1978    val = trunc(arg);
1979    BOOST_CHECK_EQUAL(val, 0);
1980    BOOST_CHECK(signbit(val) == 0);
1981    arg = -arg;
1982    if (signbit(arg))
1983    {
1984       val = trunc(arg);
1985       BOOST_CHECK_EQUAL(val, 0);
1986       BOOST_CHECK(signbit(val));
1987    }
1988    if (std::numeric_limits<T>::has_infinity)
1989    {
1990       arg = std::numeric_limits<T>::infinity();
1991       val = trunc(arg);
1992       BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1993       arg = -arg;
1994       val = trunc(arg);
1995       BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1996    }
1997    if (std::numeric_limits<T>::has_quiet_NaN)
1998    {
1999       arg = std::numeric_limits<T>::quiet_NaN();
2000       check_invalid(trunc(arg));
2001    }
2002    // F.9.7.1:
2003    arg  = 0;
2004    arg2 = 2;
2005    val  = fmod(arg, arg2);
2006    BOOST_CHECK_EQUAL(val, 0);
2007    BOOST_CHECK(signbit(val) == 0);
2008    arg = -arg;
2009    if (signbit(arg))
2010    {
2011       val = fmod(arg, arg2);
2012       BOOST_CHECK_EQUAL(val, 0);
2013       BOOST_CHECK(signbit(val));
2014    }
2015    if (std::numeric_limits<T>::has_infinity)
2016    {
2017       arg = std::numeric_limits<T>::infinity();
2018       check_invalid(fmod(arg, arg2));
2019       arg = -arg;
2020       check_invalid(fmod(arg, arg2));
2021       arg  = 2;
2022       arg2 = 0;
2023       check_invalid(fmod(arg, arg2));
2024       check_invalid(fmod(arg, -arg2));
2025    }
2026    if (std::numeric_limits<T>::has_quiet_NaN)
2027    {
2028       arg  = std::numeric_limits<T>::quiet_NaN();
2029       arg2 = 2;
2030       check_invalid(fmod(arg, arg2));
2031       swap(arg, arg2);
2032       check_invalid(fmod(arg, arg2));
2033       check_invalid(fmod(arg2, arg2));
2034    }
2035    //
2036    // Bugs:
2037    //
2038    int sign = 0;
2039    boost::math::lgamma(T(0.000001), &sign);
2040    BOOST_CHECK_EQUAL(sign, 1);
2041    sign = 0;
2042    boost::math::lgamma(T(0.5), &sign);
2043    BOOST_CHECK_EQUAL(sign, 1);
2044    sign = 0;
2045    boost::math::lgamma(T(0.9), &sign);
2046    BOOST_CHECK_EQUAL(sign, 1);
2047    sign = 0;
2048    boost::math::lgamma(T(1.1), &sign);
2049    BOOST_CHECK_EQUAL(sign, 1);
2050    sign = 0;
2051    boost::math::lgamma(T(1.9), &sign);
2052    BOOST_CHECK_EQUAL(sign, 1);
2053    sign = 0;
2054    boost::math::lgamma(T(2.1), &sign);
2055    BOOST_CHECK_EQUAL(sign, 1);
2056    sign = 0;
2057    boost::math::lgamma(T(20), &sign);
2058    BOOST_CHECK_EQUAL(sign, 1);
2059    sign = 0;
2060    boost::math::lgamma(T(-0.0000000000001), &sign);
2061    BOOST_CHECK_EQUAL(sign, -1);
2062    sign = 0;
2063    boost::math::lgamma(T(-0.5), &sign);
2064    BOOST_CHECK_EQUAL(sign, -1);
2065    sign = 0;
2066    boost::math::lgamma(T(-1.5), &sign);
2067    BOOST_CHECK_EQUAL(sign, 1);
2068    sign = 0;
2069    boost::math::lgamma(T(-2.5), &sign);
2070    BOOST_CHECK_EQUAL(sign, -1);
2071    sign = 0;
2072    boost::math::lgamma(T(-3.5), &sign);
2073    BOOST_CHECK_EQUAL(sign, 1);
2074 }
2075
2076 int main()
2077 {
2078    test_poison<float>();
2079    test_poison<double>();
2080 #ifdef TEST_MPF_50
2081    test<boost::multiprecision::mpf_float_50>();
2082    test<boost::multiprecision::mpf_float_100>();
2083 #endif
2084 #ifdef TEST_MPFR_50
2085    std::cout << "Testing MPFR: " << MPFR_VERSION_STRING << std::endl;
2086    test<boost::multiprecision::mpfr_float_50>();
2087    test<boost::multiprecision::mpfr_float_100>();
2088    test_c99_appendix_F<boost::multiprecision::mpfr_float_50>();
2089 #endif
2090 #ifdef TEST_MPFI_50
2091    test<boost::multiprecision::mpfi_float_50>();
2092    test<boost::multiprecision::mpfi_float_100>();
2093 #endif
2094 #ifdef TEST_CPP_DEC_FLOAT
2095    test<boost::multiprecision::cpp_dec_float_50>();
2096 #if !(defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
2097    test<boost::multiprecision::cpp_dec_float_100>();
2098 #endif
2099    test_c99_appendix_F<boost::multiprecision::cpp_dec_float_50>();
2100 #endif
2101 #ifdef TEST_CPP_DEC_FLOAT_2
2102    // Some "peculiar" digit counts which stress our code:
2103    test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
2104 #if !(defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
2105    test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
2106 #endif
2107 #endif
2108 #ifdef TEST_CPP_DEC_FLOAT_3
2109    test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
2110 #if !(defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
2111    test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
2112 #endif
2113 #endif
2114 #ifdef TEST_CPP_DEC_FLOAT_4
2115    test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61, long long> > >();
2116 #if !(defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
2117    test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60, long long> > >();
2118 #endif
2119 #endif
2120 #ifdef TEST_CPP_DEC_FLOAT_5
2121    test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59, long long, std::allocator<char> > > >();
2122 #endif
2123 #ifdef TEST_CPP_DEC_FLOAT_6
2124    test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58, long long, std::allocator<char> > > >();
2125 #endif
2126 #ifdef TEST_CPP_BIN_FLOAT
2127    test<boost::multiprecision::cpp_bin_float_50>();
2128    test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<100>, boost::multiprecision::et_on> >();
2129 #endif
2130 #ifdef TEST_CPP_BIN_FLOAT_2
2131    test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<35, boost::multiprecision::digit_base_10, std::allocator<char>, boost::long_long_type> > >();
2132 #endif
2133 #ifdef TEST_CPP_BIN_FLOAT_3
2134    test_c99_appendix_F<boost::multiprecision::cpp_bin_float_50>();
2135    test_c99_appendix_F<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<100>, boost::multiprecision::et_on> >();
2136 #endif
2137 #ifdef TEST_FLOAT128
2138    test<boost::multiprecision::float128>();
2139    test_c99_appendix_F<boost::multiprecision::float128>();
2140 #endif
2141
2142    return boost::report_errors();
2143 }