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

   1 // Copyright John Maddock 2013.
   2
   3 // Use, modification and distribution are subject to the
   4 // Boost Software License, Version 1.0.
   5 // (See accompanying file LICENSE_1_0.txt
   6 // or copy at http://www.boost.org/LICENSE_1_0.txt)
   7
   8 #ifdef _MSC_VER
   9 #define _SCL_SECURE_NO_WARNINGS
  10 #endif
  11
  12 #include <boost/multiprecision/cpp_bin_float.hpp>
  13 #ifdef TEST_MPFR
  14 #include <boost/multiprecision/mpfr.hpp>
  15 #endif
  16 #include <boost/random/mersenne_twister.hpp>
  17 #include <boost/random/uniform_int.hpp>
  18 #include "libs/multiprecision/test/test.hpp"
  19 #include <iostream>
  20 #include <iomanip>
  21
  22 template <class T>
  23 T generate_random()
  24 {
  25    typedef int                   e_type;
  26    static boost::random::mt19937 gen;
  27    T                             val      = gen();
  28    T                             prev_val = -1;
  29    while (val != prev_val)
  30    {
  31       val *= (gen.max)();
  32       prev_val = val;
  33       val += gen();
  34    }
  35    e_type e;
  36    val = frexp(val, &e);
  37
  38    static boost::random::uniform_int_distribution<e_type> ui(-20, 20);
  39    return ldexp(val, ui(gen));
  40 }
  41
  42 using namespace boost::multiprecision;
  43 #ifdef TEST_MPFR
  44 typedef number<mpfr_float_backend<35> > good_type;
  45 #else
  46 typedef double good_type;
  47 #endif
  48 typedef number<cpp_bin_float<std::numeric_limits<good_type>::digits, digit_base_2>, et_off> test_type;
  49
  50 void test_special_cases()
  51 {
  52 #if !defined(BOOST_CI_ASAN_BUILD) && !defined(BOOST_CI_USAN_BUID)
  53    test_type max_val     = (std::numeric_limits<test_type>::max)();
  54    test_type min_val     = (std::numeric_limits<test_type>::min)();
  55    test_type eps         = std::numeric_limits<test_type>::epsilon();
  56    test_type inf_val     = (std::numeric_limits<test_type>::infinity)();
  57    test_type nan_val     = (std::numeric_limits<test_type>::quiet_NaN)();
  58    test_type half        = 0.5;
  59    test_type one_point_5 = 1.5;
  60
  61    BOOST_CHECK((boost::math::isnormal)(max_val));
  62    BOOST_CHECK((boost::math::isnormal)(-max_val));
  63    BOOST_CHECK((boost::math::isnormal)(min_val));
  64    BOOST_CHECK((boost::math::isnormal)(-min_val));
  65    BOOST_CHECK((boost::math::isinf)(inf_val));
  66    BOOST_CHECK((boost::math::isinf)(-inf_val));
  67    BOOST_CHECK((boost::math::isnan)(nan_val));
  68    BOOST_CHECK((boost::math::isnan)(-nan_val));
  69
  70    if (std::numeric_limits<test_type>::has_denorm)
  71       min_val = std::numeric_limits<test_type>::denorm_min();
  72
  73    // Adding epsilon will increment 1.0:
  74    BOOST_CHECK(test_type(1) + eps != test_type(1));
  75    BOOST_CHECK(test_type(1) + eps / 2 == test_type(1));
  76    // But it's not the smallest value that will do that:
  77    test_type small = 1 + eps;
  78    small           = ldexp(small, -std::numeric_limits<test_type>::digits);
  79    BOOST_CHECK(test_type(1) + small != test_type(1));
  80    // And if we increment 1.0 first, then an even smaller
  81    // addition will round up:
  82    test_type one_next = test_type(1) + eps;
  83    BOOST_CHECK(one_next + eps / 2 != one_next);
  84
  85    // Overflow:
  86    BOOST_CHECK_EQUAL(max_val + max_val * eps, inf_val);
  87    BOOST_CHECK_EQUAL(-max_val - max_val * eps, -inf_val);
  88    BOOST_CHECK_EQUAL(max_val * 2, inf_val);
  89    BOOST_CHECK_EQUAL(max_val * -2, -inf_val);
  90    BOOST_CHECK_EQUAL(max_val / half, inf_val);
  91    BOOST_CHECK_EQUAL(max_val / -half, -inf_val);
  92    BOOST_CHECK_EQUAL(max_val / min_val, inf_val);
  93    BOOST_CHECK_EQUAL(max_val / -min_val, -inf_val);
  94    // Underflow:
  95    BOOST_CHECK_EQUAL(min_val * 2 - one_point_5 * min_val, 0);
  96    BOOST_CHECK_EQUAL(-min_val * 2 + one_point_5 * min_val, 0);
  97    BOOST_CHECK_EQUAL(min_val / 2, 0);
  98    BOOST_CHECK_EQUAL(min_val / max_val, 0);
  99    BOOST_CHECK_EQUAL(min_val * half, 0);
 100    BOOST_CHECK_EQUAL(min_val - min_val, 0);
 101    BOOST_CHECK_EQUAL(max_val - max_val, 0);
 102    BOOST_CHECK_EQUAL(-min_val + min_val, 0);
 103    BOOST_CHECK_EQUAL(-max_val + max_val, 0);
 104    // Things which should not over/underflow:
 105    BOOST_CHECK_EQUAL((min_val * 2) / 2, min_val);
 106    BOOST_CHECK_EQUAL((max_val / 2) * 2, max_val);
 107    BOOST_CHECK_GE((min_val * 2.0000001) / 1.9999999999999999, min_val);
 108    BOOST_CHECK_LE((max_val / 2.0000001) * 1.9999999999999999, max_val);
 109    BOOST_CHECK_EQUAL(min_val * 2 - min_val, min_val);
 110    BOOST_CHECK_EQUAL(max_val / 2 + max_val / 2, max_val);
 111    // Things involving zero:
 112    BOOST_CHECK_EQUAL(max_val + 0, max_val);
 113    BOOST_CHECK_EQUAL(max_val - 0, max_val);
 114    BOOST_CHECK_EQUAL(0 + max_val, max_val);
 115    BOOST_CHECK_EQUAL(0 - max_val, -max_val);
 116    BOOST_CHECK_EQUAL(max_val * 0, 0);
 117    BOOST_CHECK_EQUAL(0 * max_val, 0);
 118    BOOST_CHECK_EQUAL(max_val / 0, inf_val);
 119    BOOST_CHECK_EQUAL(0 / max_val, 0);
 120    BOOST_CHECK_EQUAL(-max_val / 0, -inf_val);
 121    BOOST_CHECK_EQUAL(0 / -max_val, 0);
 122    // Things involving infinity:
 123    BOOST_CHECK_EQUAL(inf_val + 2, inf_val);
 124    BOOST_CHECK_EQUAL(inf_val - 2, inf_val);
 125    BOOST_CHECK_EQUAL(inf_val + -2, inf_val);
 126    BOOST_CHECK_EQUAL(inf_val - -2, inf_val);
 127    BOOST_CHECK_EQUAL(-inf_val + 2, -inf_val);
 128    BOOST_CHECK_EQUAL(-inf_val - 2, -inf_val);
 129    BOOST_CHECK_EQUAL(-inf_val + -2, -inf_val);
 130    BOOST_CHECK_EQUAL(-inf_val - -2, -inf_val);
 131
 132    BOOST_CHECK_EQUAL(2 + inf_val, inf_val);
 133    BOOST_CHECK_EQUAL(2 - inf_val, -inf_val);
 134    BOOST_CHECK_EQUAL(-2 + inf_val, inf_val);
 135    BOOST_CHECK_EQUAL(-2 - inf_val, -inf_val);
 136    BOOST_CHECK_EQUAL(2 + (-inf_val), -inf_val);
 137    BOOST_CHECK_EQUAL(2 - (-inf_val), inf_val);
 138    BOOST_CHECK_EQUAL(-2 + (-inf_val), -inf_val);
 139    BOOST_CHECK_EQUAL(-2 - (-inf_val), inf_val);
 140
 141    BOOST_CHECK_EQUAL(sqrt(inf_val), inf_val);
 142    BOOST_CHECK(boost::math::isnan(sqrt(-inf_val)));
 143
 144    BOOST_CHECK_EQUAL(inf_val + test_type(2), inf_val);
 145    BOOST_CHECK_EQUAL(inf_val - test_type(2), inf_val);
 146    BOOST_CHECK_EQUAL(inf_val + test_type(-2), inf_val);
 147    BOOST_CHECK_EQUAL(inf_val - test_type(-2), inf_val);
 148    BOOST_CHECK_EQUAL(-inf_val + test_type(2), -inf_val);
 149    BOOST_CHECK_EQUAL(-inf_val - test_type(2), -inf_val);
 150    BOOST_CHECK_EQUAL(-inf_val + test_type(-2), -inf_val);
 151    BOOST_CHECK_EQUAL(-inf_val - test_type(-2), -inf_val);
 152
 153    BOOST_CHECK_EQUAL(test_type(2) + inf_val, inf_val);
 154    BOOST_CHECK_EQUAL(test_type(2) - inf_val, -inf_val);
 155    BOOST_CHECK_EQUAL(test_type(-2) + inf_val, inf_val);
 156    BOOST_CHECK_EQUAL(test_type(-2) - inf_val, -inf_val);
 157    BOOST_CHECK_EQUAL(test_type(2) + (-inf_val), -inf_val);
 158    BOOST_CHECK_EQUAL(test_type(2) - (-inf_val), inf_val);
 159    BOOST_CHECK_EQUAL(test_type(-2) + (-inf_val), -inf_val);
 160    BOOST_CHECK_EQUAL(test_type(-2) - (-inf_val), inf_val);
 161
 162    BOOST_CHECK((boost::math::isnan)(inf_val - inf_val));
 163    BOOST_CHECK_EQUAL(inf_val * 2, inf_val);
 164    BOOST_CHECK_EQUAL(-inf_val * 2, -inf_val);
 165    BOOST_CHECK_EQUAL(inf_val * -2, -inf_val);
 166    BOOST_CHECK_EQUAL(-inf_val * -2, inf_val);
 167    BOOST_CHECK_EQUAL(inf_val * test_type(-2), -inf_val);
 168    BOOST_CHECK_EQUAL(-inf_val * test_type(-2), inf_val);
 169    BOOST_CHECK((boost::math::isnan)(inf_val * 0));
 170    BOOST_CHECK((boost::math::isnan)(-inf_val * 0));
 171    BOOST_CHECK_EQUAL(inf_val / 2, inf_val);
 172    BOOST_CHECK_EQUAL(-inf_val / 2, -inf_val);
 173    BOOST_CHECK_EQUAL(inf_val / -2, -inf_val);
 174    BOOST_CHECK_EQUAL(-inf_val / -2, inf_val);
 175    BOOST_CHECK_EQUAL(inf_val / test_type(-2), -inf_val);
 176    BOOST_CHECK_EQUAL(-inf_val / test_type(-2), inf_val);
 177    BOOST_CHECK_EQUAL(inf_val / 0, inf_val);
 178    BOOST_CHECK_EQUAL(-inf_val / 0, -inf_val);
 179    BOOST_CHECK((boost::math::isnan)(inf_val / inf_val));
 180    BOOST_CHECK((boost::math::isnan)(-inf_val / inf_val));
 181    // Things involving nan:
 182    BOOST_CHECK((boost::math::isnan)(nan_val + 2));
 183    BOOST_CHECK((boost::math::isnan)(nan_val - 2));
 184    BOOST_CHECK((boost::math::isnan)(nan_val + 0));
 185    BOOST_CHECK((boost::math::isnan)(nan_val - 0));
 186    BOOST_CHECK((boost::math::isnan)(nan_val + inf_val));
 187    BOOST_CHECK((boost::math::isnan)(nan_val - inf_val));
 188    BOOST_CHECK((boost::math::isnan)(nan_val + nan_val));
 189    BOOST_CHECK((boost::math::isnan)(nan_val - nan_val));
 190    BOOST_CHECK((boost::math::isnan)(2 + nan_val));
 191    BOOST_CHECK((boost::math::isnan)(2 - nan_val));
 192    BOOST_CHECK((boost::math::isnan)(0 - nan_val));
 193    BOOST_CHECK((boost::math::isnan)(0 - nan_val));
 194    BOOST_CHECK((boost::math::isnan)(inf_val + nan_val));
 195    BOOST_CHECK((boost::math::isnan)(inf_val - nan_val));
 196    BOOST_CHECK((boost::math::isnan)(nan_val * 2));
 197    BOOST_CHECK((boost::math::isnan)(nan_val / 2));
 198    BOOST_CHECK((boost::math::isnan)(nan_val * 0));
 199    BOOST_CHECK((boost::math::isnan)(nan_val / 0));
 200    BOOST_CHECK((boost::math::isnan)(nan_val * inf_val));
 201    BOOST_CHECK((boost::math::isnan)(nan_val / inf_val));
 202    BOOST_CHECK((boost::math::isnan)(nan_val * nan_val));
 203    BOOST_CHECK((boost::math::isnan)(nan_val / nan_val));
 204    BOOST_CHECK((boost::math::isnan)(2 * nan_val));
 205    BOOST_CHECK((boost::math::isnan)(2 / nan_val));
 206    BOOST_CHECK((boost::math::isnan)(0 / nan_val));
 207    BOOST_CHECK((boost::math::isnan)(0 / nan_val));
 208    BOOST_CHECK((boost::math::isnan)(inf_val * nan_val));
 209    BOOST_CHECK((boost::math::isnan)(inf_val / nan_val));
 210    // Corner cases:
 211    BOOST_CHECK_EQUAL((max_val * half) / half, max_val);
 212    BOOST_CHECK_EQUAL((max_val / 2) * 2, max_val);
 213    BOOST_CHECK_EQUAL((min_val / half) * half, min_val);
 214    BOOST_CHECK_EQUAL((min_val * 2) / 2, min_val);
 215    BOOST_CHECK_EQUAL(max_val + min_val, max_val);
 216    BOOST_CHECK_EQUAL(min_val + max_val, max_val);
 217    BOOST_CHECK_EQUAL(max_val - min_val, max_val);
 218    BOOST_CHECK_EQUAL(min_val - max_val, -max_val);
 219    // Signed zeros:
 220    BOOST_CHECK(boost::math::signbit(min_val * -min_val));
 221    BOOST_CHECK(boost::math::signbit(min_val * min_val) == 0);
 222    BOOST_CHECK(boost::math::signbit(-min_val * -min_val) == 0);
 223    BOOST_CHECK(boost::math::signbit(-min_val * min_val));
 224    BOOST_CHECK(boost::math::signbit(min_val / max_val) == 0);
 225    BOOST_CHECK(boost::math::signbit(min_val / -max_val));
 226    BOOST_CHECK(boost::math::signbit(-min_val / -max_val) == 0);
 227    BOOST_CHECK(boost::math::signbit(-min_val / max_val));
 228    BOOST_CHECK(boost::math::signbit(min_val / 2) == 0);
 229    BOOST_CHECK(boost::math::signbit(min_val / -2));
 230    BOOST_CHECK(boost::math::signbit(-min_val / -2) == 0);
 231    BOOST_CHECK(boost::math::signbit(-min_val / 2));
 232    test_type neg_zero = min_val * -min_val;
 233    test_type zero     = 0;
 234    // Arithmetic involving signed zero:
 235    BOOST_CHECK_EQUAL(-neg_zero, 0);
 236    BOOST_CHECK(!boost::math::signbit(-neg_zero));
 237    BOOST_CHECK_EQUAL(neg_zero + 2, 2);
 238    BOOST_CHECK_EQUAL(neg_zero + test_type(2), 2);
 239    BOOST_CHECK_EQUAL(2 + neg_zero, 2);
 240    BOOST_CHECK_EQUAL(test_type(2) + neg_zero, 2);
 241    BOOST_CHECK_EQUAL(neg_zero + -2, -2);
 242    BOOST_CHECK_EQUAL(neg_zero + test_type(-2), -2);
 243    BOOST_CHECK_EQUAL(-2 + neg_zero, -2);
 244    BOOST_CHECK_EQUAL(test_type(-2) + neg_zero, -2);
 245    BOOST_CHECK_EQUAL(neg_zero - 2, -2);
 246    BOOST_CHECK_EQUAL(neg_zero - test_type(2), -2);
 247    BOOST_CHECK_EQUAL(2 - neg_zero, 2);
 248    BOOST_CHECK_EQUAL(test_type(2) - neg_zero, 2);
 249    BOOST_CHECK_EQUAL(neg_zero - -2, 2);
 250    BOOST_CHECK_EQUAL(neg_zero - test_type(-2), 2);
 251    BOOST_CHECK_EQUAL(-2 - neg_zero, -2);
 252    BOOST_CHECK_EQUAL(test_type(-2) - neg_zero, -2);
 253    BOOST_CHECK(!boost::math::signbit(test_type(2) + test_type(-2)));
 254    BOOST_CHECK(!boost::math::signbit(test_type(2) - test_type(2)));
 255    BOOST_CHECK(!boost::math::signbit(test_type(-2) - test_type(-2)));
 256    BOOST_CHECK(!boost::math::signbit(test_type(-2) + test_type(2)));
 257    BOOST_CHECK(!boost::math::signbit(zero + zero));
 258    BOOST_CHECK(!boost::math::signbit(zero - zero));
 259    BOOST_CHECK(!boost::math::signbit(neg_zero + zero));
 260    BOOST_CHECK(!boost::math::signbit(zero + neg_zero));
 261    BOOST_CHECK(boost::math::signbit(neg_zero + neg_zero));
 262    BOOST_CHECK(boost::math::signbit(neg_zero - zero));
 263    BOOST_CHECK(!boost::math::signbit(zero - neg_zero));
 264    BOOST_CHECK(!boost::math::signbit(neg_zero - neg_zero));
 265    small = 0.25;
 266    BOOST_CHECK(!boost::math::signbit(floor(small)));
 267    BOOST_CHECK(!boost::math::signbit(round(small)));
 268    BOOST_CHECK(!boost::math::signbit(trunc(small)));
 269    small = -small;
 270    BOOST_CHECK(boost::math::signbit(ceil(small)));
 271    BOOST_CHECK(boost::math::signbit(round(small)));
 272    BOOST_CHECK(boost::math::signbit(trunc(small)));
 273
 274    BOOST_CHECK_EQUAL(neg_zero * 2, 0);
 275    BOOST_CHECK_EQUAL(neg_zero * test_type(2), 0);
 276    BOOST_CHECK_EQUAL(2 * neg_zero, 0);
 277    BOOST_CHECK_EQUAL(test_type(2) * neg_zero, 0);
 278    BOOST_CHECK_EQUAL(neg_zero * -2, 0);
 279    BOOST_CHECK_EQUAL(neg_zero * test_type(-2), 0);
 280    BOOST_CHECK_EQUAL(-2 * neg_zero, 0);
 281    BOOST_CHECK_EQUAL(test_type(-2) * neg_zero, 0);
 282    BOOST_CHECK(boost::math::signbit(neg_zero * 2));
 283    BOOST_CHECK(boost::math::signbit(neg_zero * test_type(2)));
 284    BOOST_CHECK(boost::math::signbit(2 * neg_zero));
 285    BOOST_CHECK(boost::math::signbit(test_type(2) * neg_zero));
 286    BOOST_CHECK(!boost::math::signbit(neg_zero * -2));
 287    BOOST_CHECK(!boost::math::signbit(neg_zero * test_type(-2)));
 288    BOOST_CHECK(!boost::math::signbit(-2 * neg_zero));
 289    BOOST_CHECK(!boost::math::signbit(test_type(-2) * neg_zero));
 290
 291    BOOST_CHECK_EQUAL(neg_zero / 2, 0);
 292    BOOST_CHECK_EQUAL(neg_zero / test_type(2), 0);
 293    BOOST_CHECK_EQUAL(2 / neg_zero, -inf_val);
 294    BOOST_CHECK_EQUAL(test_type(2) / neg_zero, -inf_val);
 295    BOOST_CHECK_EQUAL(neg_zero / -2, 0);
 296    BOOST_CHECK_EQUAL(neg_zero / test_type(-2), 0);
 297    BOOST_CHECK_EQUAL(-2 / neg_zero, inf_val);
 298    BOOST_CHECK_EQUAL(test_type(-2) / neg_zero, inf_val);
 299    BOOST_CHECK(boost::math::signbit(neg_zero / 2));
 300    BOOST_CHECK(boost::math::signbit(neg_zero / test_type(2)));
 301    BOOST_CHECK(boost::math::signbit(2 / neg_zero));
 302    BOOST_CHECK(boost::math::signbit(test_type(2) / neg_zero));
 303    BOOST_CHECK(!boost::math::signbit(neg_zero / -2));
 304    BOOST_CHECK(!boost::math::signbit(neg_zero / test_type(-2)));
 305    BOOST_CHECK(!boost::math::signbit(-2 / neg_zero));
 306    BOOST_CHECK(!boost::math::signbit(test_type(-2) / neg_zero));
 307
 308    BOOST_CHECK(boost::math::signbit(neg_zero.convert_to<double>()));
 309    BOOST_CHECK(boost::math::signbit(neg_zero.convert_to<float>()));
 310    BOOST_CHECK(boost::math::signbit(neg_zero.convert_to<long double>()));
 311    BOOST_CHECK(!boost::math::signbit(zero.convert_to<double>()));
 312    BOOST_CHECK(!boost::math::signbit(zero.convert_to<float>()));
 313    BOOST_CHECK(!boost::math::signbit(zero.convert_to<long double>()));
 314
 315    // Conversions to other types of special values:
 316    if (std::numeric_limits<float>::has_infinity)
 317    {
 318       BOOST_CHECK_EQUAL(inf_val.convert_to<float>(), std::numeric_limits<float>::infinity());
 319       BOOST_CHECK_EQUAL((-inf_val).convert_to<float>(), -std::numeric_limits<float>::infinity());
 320    }
 321    if (std::numeric_limits<float>::has_quiet_NaN)
 322    {
 323       BOOST_CHECK((boost::math::isnan)(nan_val.convert_to<float>()));
 324    }
 325    if (std::numeric_limits<double>::has_infinity)
 326    {
 327       BOOST_CHECK_EQUAL(inf_val.convert_to<double>(), std::numeric_limits<double>::infinity());
 328       BOOST_CHECK_EQUAL((-inf_val).convert_to<double>(), -std::numeric_limits<double>::infinity());
 329    }
 330    if (std::numeric_limits<double>::has_quiet_NaN)
 331    {
 332       BOOST_CHECK((boost::math::isnan)(nan_val.convert_to<double>()));
 333    }
 334    if (std::numeric_limits<long double>::has_infinity)
 335    {
 336       BOOST_CHECK_EQUAL(inf_val.convert_to<long double>(), std::numeric_limits<long double>::infinity());
 337       BOOST_CHECK_EQUAL((-inf_val).convert_to<long double>(), -std::numeric_limits<long double>::infinity());
 338    }
 339    if (std::numeric_limits<long double>::has_quiet_NaN)
 340    {
 341       BOOST_CHECK((boost::math::isnan)(nan_val.convert_to<long double>()));
 342    }
 343    //
 344    // Bug https://svn.boost.org/trac/boost/attachment/ticket/12580
 345    //
 346    using std::ldexp;
 347    test_type a(1);
 348    test_type b = ldexp(test_type(0.99), -std::numeric_limits<test_type>::digits);
 349    good_type ga(1);
 350    good_type gb = ldexp(good_type(0.99), -std::numeric_limits<good_type>::digits);
 351    BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
 352    BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
 353    BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
 354    BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));
 355
 356    BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
 357    BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
 358    BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
 359    BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));
 360
 361    BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
 362    BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
 363    BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
 364    BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));
 365
 366    BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
 367    BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
 368    BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
 369    BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));
 370
 371    b  = ldexp(test_type(0.5), -std::numeric_limits<test_type>::digits);
 372    gb = ldexp(good_type(0.5), -std::numeric_limits<good_type>::digits);
 373    BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
 374    BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
 375    BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
 376    BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));
 377
 378    BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
 379    BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
 380    BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
 381    BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));
 382
 383    BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
 384    BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
 385    BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
 386    BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));
 387
 388    BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
 389    BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
 390    BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
 391    BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));
 392
 393    b  = ldexp(test_type(1), -std::numeric_limits<test_type>::digits);
 394    gb = ldexp(good_type(1), -std::numeric_limits<good_type>::digits);
 395    BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
 396    BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
 397    BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
 398    BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));
 399
 400    BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
 401    BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
 402    BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
 403    BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));
 404
 405    BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
 406    BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
 407    BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
 408    BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));
 409
 410    BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
 411    BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
 412    BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
 413    BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));
 414
 415    b  = ldexp(test_type(0.50000000001), -std::numeric_limits<test_type>::digits);
 416    gb = ldexp(good_type(0.50000000001), -std::numeric_limits<good_type>::digits);
 417    BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
 418    BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
 419    BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
 420    BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));
 421
 422    BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
 423    BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
 424    BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
 425    BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));
 426
 427    BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
 428    BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
 429    BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
 430    BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));
 431
 432    BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
 433    BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
 434    BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
 435    BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));
 436
 437    a  = a + ldexp(a, -20);
 438    ga = ga + ldexp(ga, -20);
 439    BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
 440    BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
 441    BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
 442    BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));
 443
 444    BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
 445    BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
 446    BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
 447    BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));
 448
 449    BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
 450    BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
 451    BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
 452    BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));
 453
 454    BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
 455    BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
 456    BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
 457    BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));
 458
 459    b  = ldexp(test_type(0.5), -std::numeric_limits<test_type>::digits);
 460    gb = ldexp(good_type(0.5), -std::numeric_limits<good_type>::digits);
 461    BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
 462    BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
 463    BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
 464    BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));
 465
 466    BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
 467    BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
 468    BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
 469    BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));
 470
 471    BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
 472    BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
 473    BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
 474    BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));
 475
 476    BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
 477    BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
 478    BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
 479    BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));
 480
 481    b  = ldexp(test_type(1), -std::numeric_limits<test_type>::digits);
 482    gb = ldexp(good_type(1), -std::numeric_limits<good_type>::digits);
 483    BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
 484    BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
 485    BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
 486    BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));
 487
 488    BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
 489    BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
 490    BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
 491    BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));
 492
 493    BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
 494    BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
 495    BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
 496    BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));
 497
 498    BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
 499    BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
 500    BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
 501    BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));
 502
 503    b  = ldexp(test_type(0.50000000001), -std::numeric_limits<test_type>::digits);
 504    gb = ldexp(good_type(0.50000000001), -std::numeric_limits<good_type>::digits);
 505    BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
 506    BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
 507    BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
 508    BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));
 509
 510    BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
 511    BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
 512    BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
 513    BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));
 514
 515    BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
 516    BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
 517    BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
 518    BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));
 519
 520    BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
 521    BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
 522    BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
 523    BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));
 524
 525    a  = 1;
 526    a  = boost::math::float_prior(a);
 527    ga = 1;
 528    ga = boost::math::float_prior(ga);
 529    BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
 530    BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
 531    BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
 532    BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));
 533
 534    BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
 535    BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
 536    BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
 537    BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));
 538
 539    BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
 540    BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
 541    BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
 542    BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));
 543
 544    BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
 545    BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
 546    BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
 547    BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));
 548
 549    b  = ldexp(test_type(0.5), -std::numeric_limits<test_type>::digits);
 550    gb = ldexp(good_type(0.5), -std::numeric_limits<good_type>::digits);
 551    BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
 552    BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
 553    BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
 554    BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));
 555
 556    BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
 557    BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
 558    BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
 559    BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));
 560
 561    BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
 562    BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
 563    BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
 564    BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));
 565
 566    BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
 567    BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
 568    BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
 569    BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));
 570
 571    b  = ldexp(test_type(1), -std::numeric_limits<test_type>::digits);
 572    gb = ldexp(good_type(1), -std::numeric_limits<good_type>::digits);
 573    BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
 574    BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
 575    BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
 576    BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));
 577
 578    BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
 579    BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
 580    BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
 581    BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));
 582
 583    BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
 584    BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
 585    BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
 586    BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));
 587
 588    BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
 589    BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
 590    BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
 591    BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));
 592
 593    b  = ldexp(test_type(0.50000000001), -std::numeric_limits<test_type>::digits);
 594    gb = ldexp(good_type(0.50000000001), -std::numeric_limits<good_type>::digits);
 595    BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
 596    BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
 597    BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
 598    BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));
 599
 600    BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
 601    BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
 602    BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
 603    BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));
 604
 605    BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
 606    BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
 607    BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
 608    BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));
 609
 610    BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
 611    BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
 612    BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
 613    BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));
 614
 615    a = boost::math::float_next(test_type(1));
 616    ga = boost::math::float_next(good_type(1));
 617    b  = ldexp(boost::math::float_prior(test_type(1)), -std::numeric_limits<test_type>::digits);
 618    gb = ldexp(boost::math::float_prior(good_type(1)), -std::numeric_limits<test_type>::digits);
 619    BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
 620    BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
 621    BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
 622    BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));
 623
 624    BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
 625    BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
 626    BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
 627    BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));
 628
 629    BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
 630    BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
 631    BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
 632    BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));
 633
 634    BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
 635    BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
 636    BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
 637    BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));
 638
 639    b = ldexp(b, -1);
 640    gb = ldexp(gb, -1);
 641    BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
 642    BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
 643    BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
 644    BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));
 645
 646    BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
 647    BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
 648    BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
 649    BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));
 650
 651    BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
 652    BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
 653    BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
 654    BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));
 655
 656    BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
 657    BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
 658    BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
 659    BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));
 660
 661    a = 1.75;  // even mantissa, not a power of 2
 662    ga = 1.75;
 663    b  = ldexp(test_type(1), -std::numeric_limits<test_type>::digits);
 664    gb = ldexp(good_type(1), -std::numeric_limits<test_type>::digits);
 665    BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
 666    BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
 667    BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
 668    BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));
 669
 670    BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
 671    BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
 672    BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
 673    BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));
 674
 675    BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
 676    BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
 677    BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
 678    BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));
 679
 680    BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
 681    BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
 682    BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
 683    BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));
 684    b = ldexp(b, -1);
 685    gb = ldexp(gb, -1);
 686    BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
 687    BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
 688    BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
 689    BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));
 690
 691    BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
 692    BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
 693    BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
 694    BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));
 695
 696    BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
 697    BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
 698    BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
 699    BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));
 700
 701    BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
 702    BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
 703    BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
 704    BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));
 705
 706    b  = ldexp(boost::math::float_prior(test_type(1)), -std::numeric_limits<test_type>::digits);
 707    gb = ldexp(boost::math::float_prior(good_type(1)), -std::numeric_limits<test_type>::digits);
 708    BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
 709    BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
 710    BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
 711    BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));
 712
 713    BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
 714    BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
 715    BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
 716    BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));
 717
 718    BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
 719    BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
 720    BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
 721    BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));
 722
 723    BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
 724    BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
 725    BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
 726    BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));
 727
 728    b  = ldexp(b, -1);
 729    gb = ldexp(gb, -1);
 730    BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
 731    BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
 732    BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
 733    BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));
 734
 735    BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
 736    BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
 737    BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
 738    BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));
 739
 740    BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
 741    BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
 742    BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
 743    BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));
 744
 745    BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
 746    BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
 747    BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
 748    BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));
 749
 750    b  = ldexp(test_type(0.75), -std::numeric_limits<test_type>::digits);  // even mantissa not a power of 2.
 751    gb = ldexp(good_type(0.75), -std::numeric_limits<test_type>::digits);
 752    BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
 753    BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
 754    BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
 755    BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));
 756
 757    BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
 758    BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
 759    BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
 760    BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));
 761
 762    BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
 763    BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
 764    BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
 765    BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));
 766
 767    BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
 768    BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
 769    BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
 770    BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));
 771
 772    b  = ldexp(b, -1);
 773    gb = ldexp(gb, -1);
 774    BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
 775    BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
 776    BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
 777    BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));
 778
 779    BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
 780    BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
 781    BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
 782    BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));
 783
 784    BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
 785    BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
 786    BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
 787    BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));
 788
 789    BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
 790    BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
 791    BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
 792    BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));
 793    #endif
 794 }
 795
 796 int main()
 797 {
 798    // compile times are too long for CI when ASAN is enabled, prune things down a bit:
 799 #if !defined(BOOST_CI_ASAN_BUILD) && !defined(BOOST_CI_USAN_BUID)
 800    test_special_cases();
 801 #endif
 802    unsigned error_count = 0;
 803    for (unsigned i = 0; i < 100000; ++i)
 804    {
 805       good_type a = generate_random<good_type>();
 806       good_type b = generate_random<good_type>();
 807       test_type ta(a);
 808       test_type tb(b);
 809       BOOST_CHECK_EQUAL(test_type(a * b), ta * tb);
 810       BOOST_CHECK_EQUAL(test_type(-a * b), -ta * tb);
 811       BOOST_CHECK_EQUAL(test_type(a * -b), ta * -tb);
 812       BOOST_CHECK_EQUAL(test_type(-a * -b), -ta * -tb);
 813
 814       BOOST_CHECK_EQUAL(test_type(a + b), ta + tb);
 815       BOOST_CHECK_EQUAL(test_type(-a + b), -ta + tb);
 816       BOOST_CHECK_EQUAL(test_type(a + -b), ta + -tb);
 817       BOOST_CHECK_EQUAL(test_type(-a + -b), -ta + -tb);
 818
 819       BOOST_CHECK_EQUAL(test_type(a - b), ta - tb);
 820       BOOST_CHECK_EQUAL(test_type(-a - b), -ta - tb);
 821       BOOST_CHECK_EQUAL(test_type(a - -b), ta - -tb);
 822       BOOST_CHECK_EQUAL(test_type(-a - -b), -ta - -tb);
 823
 824       BOOST_CHECK_EQUAL(test_type(a / b), ta / tb);
 825       BOOST_CHECK_EQUAL(test_type(-a / b), -ta / tb);
 826       BOOST_CHECK_EQUAL(test_type(a / -b), ta / -tb);
 827       BOOST_CHECK_EQUAL(test_type(-a / -b), -ta / -tb);
 828
 829       BOOST_CHECK_EQUAL(test_type(sqrt(a)), sqrt(ta));
 830       BOOST_CHECK_EQUAL(test_type(floor(a)), floor(ta));
 831       BOOST_CHECK_EQUAL(test_type(floor(-a)), floor(-ta));
 832       BOOST_CHECK_EQUAL(test_type(ceil(a)), ceil(ta));
 833       BOOST_CHECK_EQUAL(test_type(ceil(-a)), ceil(-ta));
 834
 835 #ifdef TEST_MPFR
 836       //
 837       // Conversions:
 838       //
 839       BOOST_CHECK_EQUAL(a.convert_to<double>(), ta.convert_to<double>());
 840       BOOST_CHECK_EQUAL(a.convert_to<float>(), ta.convert_to<float>());
 841       BOOST_CHECK_EQUAL(b.convert_to<double>(), tb.convert_to<double>());
 842       BOOST_CHECK_EQUAL(b.convert_to<float>(), tb.convert_to<float>());
 843 #else
 844       BOOST_CHECK_EQUAL(a, ta.convert_to<double>());
 845       BOOST_CHECK_EQUAL(static_cast<float>(a), ta.convert_to<float>());
 846       BOOST_CHECK_EQUAL(b, tb.convert_to<double>());
 847       BOOST_CHECK_EQUAL(static_cast<float>(b), tb.convert_to<float>());
 848 #endif
 849
 850       static boost::random::mt19937 i_gen;
 851
 852       int si = i_gen();
 853       BOOST_CHECK_EQUAL(test_type(a * si), ta * si);
 854       BOOST_CHECK_EQUAL(test_type(-a * si), -ta * si);
 855       BOOST_CHECK_EQUAL(test_type(-a * -si), -ta * -si);
 856       BOOST_CHECK_EQUAL(test_type(a * -si), ta * -si);
 857       unsigned ui = std::abs(si);
 858       BOOST_CHECK_EQUAL(test_type(a * ui), ta * ui);
 859       BOOST_CHECK_EQUAL(test_type(-a * ui), -ta * ui);
 860
 861       // Divide:
 862       BOOST_CHECK_EQUAL(test_type(a / si), ta / si);
 863       BOOST_CHECK_EQUAL(test_type(-a / si), -ta / si);
 864       BOOST_CHECK_EQUAL(test_type(-a / -si), -ta / -si);
 865       BOOST_CHECK_EQUAL(test_type(a / -si), ta / -si);
 866       BOOST_CHECK_EQUAL(test_type(a / ui), ta / ui);
 867       BOOST_CHECK_EQUAL(test_type(-a / ui), -ta / ui);
 868       // Error reporting:
 869       if ((unsigned)boost::detail::test_errors() != error_count)
 870       {
 871          error_count = boost::detail::test_errors();
 872          std::cout << std::setprecision(std::numeric_limits<test_type>::max_digits10) << std::scientific;
 873          std::cout << "a (mpfr) = " << a << std::endl;
 874          std::cout << "a (test) = " << ta << std::endl;
 875          std::cout << "b (mpfr) = " << b << std::endl;
 876          std::cout << "b (test) = " << tb << std::endl;
 877          std::cout << "si       = " << si << std::endl;
 878          std::cout << "ui       = " << ui << std::endl;
 879       }
 880    }
 881    return boost::report_errors();
 882 }