boost/math/special_functions/detail/fp_traits.hpp

   1 // fp_traits.hpp
   2
   3 #ifndef BOOST_MATH_FP_TRAITS_HPP
   4 #define BOOST_MATH_FP_TRAITS_HPP
   5
   6 // Copyright (c) 2006 Johan Rade
   7
   8 // Distributed under the Boost Software License, Version 1.0.
   9 // (See accompanying file LICENSE_1_0.txt
  10 // or copy at http://www.boost.org/LICENSE_1_0.txt)
  11
  12 /*
  13 To support old compilers, care has been taken to avoid partial template
  14 specialization and meta function forwarding.
  15 With these techniques, the code could be simplified.
  16 */
  17
  18 #if defined(__vms) && defined(__DECCXX) && !__IEEE_FLOAT
  19 // The VAX floating point formats are used (for float and double)
  20 #   define BOOST_FPCLASSIFY_VAX_FORMAT
  21 #endif
  22
  23 #include <cstring>
  24
  25 #include <boost/assert.hpp>
  26 #include <boost/cstdint.hpp>
  27 #include <boost/detail/endian.hpp>
  28 #include <boost/static_assert.hpp>
  29 #include <boost/type_traits/is_floating_point.hpp>
  30
  31 #ifdef BOOST_NO_STDC_NAMESPACE
  32   namespace std{ using ::memcpy; }
  33 #endif
  34
  35 #ifndef FP_NORMAL
  36
  37 #define FP_ZERO        0
  38 #define FP_NORMAL      1
  39 #define FP_INFINITE    2
  40 #define FP_NAN         3
  41 #define FP_SUBNORMAL   4
  42
  43 #else
  44
  45 #define BOOST_HAS_FPCLASSIFY
  46
  47 #ifndef fpclassify
  48 #  if (defined(__GLIBCPP__) || defined(__GLIBCXX__)) \
  49          && defined(_GLIBCXX_USE_C99_MATH) \
  50          && !(defined(_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC) \
  51          && (_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC != 0))
  52 #     ifdef _STLP_VENDOR_CSTD
  53 #        if _STLPORT_VERSION >= 0x520
  54 #           define BOOST_FPCLASSIFY_PREFIX ::__std_alias::
  55 #        else
  56 #           define BOOST_FPCLASSIFY_PREFIX ::_STLP_VENDOR_CSTD::
  57 #        endif
  58 #     else
  59 #        define BOOST_FPCLASSIFY_PREFIX ::std::
  60 #     endif
  61 #  else
  62 #     undef BOOST_HAS_FPCLASSIFY
  63 #     define BOOST_FPCLASSIFY_PREFIX
  64 #  endif
  65 #elif (defined(__HP_aCC) && !defined(__hppa))
  66 // aCC 6 appears to do "#define fpclassify fpclassify" which messes us up a bit!
  67 #  define BOOST_FPCLASSIFY_PREFIX ::
  68 #else
  69 #  define BOOST_FPCLASSIFY_PREFIX
  70 #endif
  71
  72 #ifdef __MINGW32__
  73 #  undef BOOST_HAS_FPCLASSIFY
  74 #endif
  75
  76 #endif
  77
  78
  79 //------------------------------------------------------------------------------
  80
  81 namespace boost {
  82 namespace math {
  83 namespace detail {
  84
  85 //------------------------------------------------------------------------------
  86
  87 /*
  88 The following classes are used to tag the different methods that are used
  89 for floating point classification
  90 */
  91
  92 struct native_tag {};
  93 template <bool has_limits>
  94 struct generic_tag {};
  95 struct ieee_tag {};
  96 struct ieee_copy_all_bits_tag : public ieee_tag {};
  97 struct ieee_copy_leading_bits_tag : public ieee_tag {};
  98
  99 #ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
 100 //
 101 // These helper functions are used only when numeric_limits<>
 102 // members are not compile time constants:
 103 //
 104 inline bool is_generic_tag_false(const generic_tag<false>*)
 105 {
 106    return true;
 107 }
 108 inline bool is_generic_tag_false(const void*)
 109 {
 110    return false;
 111 }
 112 #endif
 113
 114 //------------------------------------------------------------------------------
 115
 116 /*
 117 Most processors support three different floating point precisions:
 118 single precision (32 bits), double precision (64 bits)
 119 and extended double precision (80 - 128 bits, depending on the processor)
 120
 121 Note that the C++ type long double can be implemented
 122 both as double precision and extended double precision.
 123 */
 124
 125 struct unknown_precision{};
 126 struct single_precision {};
 127 struct double_precision {};
 128 struct extended_double_precision {};
 129
 130 // native_tag version --------------------------------------------------------------
 131
 132 template<class T> struct fp_traits_native
 133 {
 134     typedef native_tag method;
 135 };
 136
 137 // generic_tag version -------------------------------------------------------------
 138
 139 template<class T, class U> struct fp_traits_non_native
 140 {
 141 #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
 142    typedef generic_tag<std::numeric_limits<T>::is_specialized> method;
 143 #else
 144    typedef generic_tag<false> method;
 145 #endif
 146 };
 147
 148 // ieee_tag versions ---------------------------------------------------------------
 149
 150 /*
 151 These specializations of fp_traits_non_native contain information needed
 152 to "parse" the binary representation of a floating point number.
 153
 154 Typedef members:
 155
 156   bits -- the target type when copying the leading bytes of a floating
 157       point number. It is a typedef for uint32_t or uint64_t.
 158
 159   method -- tells us whether all bytes are copied or not.
 160       It is a typedef for ieee_copy_all_bits_tag or ieee_copy_leading_bits_tag.
 161
 162 Static data members:
 163
 164   sign, exponent, flag, significand -- bit masks that give the meaning of the
 165   bits in the leading bytes.
 166
 167 Static function members:
 168
 169   get_bits(), set_bits() -- provide access to the leading bytes.
 170
 171 */
 172
 173 // ieee_tag version, float (32 bits) -----------------------------------------------
 174
 175 #ifndef BOOST_FPCLASSIFY_VAX_FORMAT
 176
 177 template<> struct fp_traits_non_native<float, single_precision>
 178 {
 179     typedef ieee_copy_all_bits_tag method;
 180
 181     BOOST_STATIC_CONSTANT(uint32_t, sign        = 0x80000000u);
 182     BOOST_STATIC_CONSTANT(uint32_t, exponent    = 0x7f800000);
 183     BOOST_STATIC_CONSTANT(uint32_t, flag        = 0x00000000);
 184     BOOST_STATIC_CONSTANT(uint32_t, significand = 0x007fffff);
 185
 186     typedef uint32_t bits;
 187     static void get_bits(float x, uint32_t& a) { std::memcpy(&a, &x, 4); }
 188     static void set_bits(float& x, uint32_t a) { std::memcpy(&x, &a, 4); }
 189 };
 190
 191 // ieee_tag version, double (64 bits) ----------------------------------------------
 192
 193 #if defined(BOOST_NO_INT64_T) || defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION) \
 194    || defined(__BORLANDC__) || defined(__CODEGEAR__)
 195
 196 template<> struct fp_traits_non_native<double, double_precision>
 197 {
 198     typedef ieee_copy_leading_bits_tag method;
 199
 200     BOOST_STATIC_CONSTANT(uint32_t, sign        = 0x80000000u);
 201     BOOST_STATIC_CONSTANT(uint32_t, exponent    = 0x7ff00000);
 202     BOOST_STATIC_CONSTANT(uint32_t, flag        = 0);
 203     BOOST_STATIC_CONSTANT(uint32_t, significand = 0x000fffff);
 204
 205     typedef uint32_t bits;
 206
 207     static void get_bits(double x, uint32_t& a)
 208     {
 209         std::memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
 210     }
 211
 212     static void set_bits(double& x, uint32_t a)
 213     {
 214         std::memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
 215     }
 216
 217 private:
 218
 219 #if defined(BOOST_BIG_ENDIAN)
 220     BOOST_STATIC_CONSTANT(int, offset_ = 0);
 221 #elif defined(BOOST_LITTLE_ENDIAN)
 222     BOOST_STATIC_CONSTANT(int, offset_ = 4);
 223 #else
 224     BOOST_STATIC_ASSERT(false);
 225 #endif
 226 };
 227
 228 //..............................................................................
 229
 230 #else
 231
 232 template<> struct fp_traits_non_native<double, double_precision>
 233 {
 234     typedef ieee_copy_all_bits_tag method;
 235
 236     static const uint64_t sign     = ((uint64_t)0x80000000u) << 32;
 237     static const uint64_t exponent = ((uint64_t)0x7ff00000) << 32;
 238     static const uint64_t flag     = 0;
 239     static const uint64_t significand
 240         = (((uint64_t)0x000fffff) << 32) + ((uint64_t)0xffffffffu);
 241
 242     typedef uint64_t bits;
 243     static void get_bits(double x, uint64_t& a) { std::memcpy(&a, &x, 8); }
 244     static void set_bits(double& x, uint64_t a) { std::memcpy(&x, &a, 8); }
 245 };
 246
 247 #endif
 248
 249 #endif  // #ifndef BOOST_FPCLASSIFY_VAX_FORMAT
 250
 251 // long double (64 bits) -------------------------------------------------------
 252
 253 #if defined(BOOST_NO_INT64_T) || defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)\
 254    || defined(__BORLANDC__) || defined(__CODEGEAR__)
 255
 256 template<> struct fp_traits_non_native<long double, double_precision>
 257 {
 258     typedef ieee_copy_leading_bits_tag method;
 259
 260     BOOST_STATIC_CONSTANT(uint32_t, sign        = 0x80000000u);
 261     BOOST_STATIC_CONSTANT(uint32_t, exponent    = 0x7ff00000);
 262     BOOST_STATIC_CONSTANT(uint32_t, flag        = 0);
 263     BOOST_STATIC_CONSTANT(uint32_t, significand = 0x000fffff);
 264
 265     typedef uint32_t bits;
 266
 267     static void get_bits(long double x, uint32_t& a)
 268     {
 269         std::memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
 270     }
 271
 272     static void set_bits(long double& x, uint32_t a)
 273     {
 274         std::memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
 275     }
 276
 277 private:
 278
 279 #if defined(BOOST_BIG_ENDIAN)
 280     BOOST_STATIC_CONSTANT(int, offset_ = 0);
 281 #elif defined(BOOST_LITTLE_ENDIAN)
 282     BOOST_STATIC_CONSTANT(int, offset_ = 4);
 283 #else
 284     BOOST_STATIC_ASSERT(false);
 285 #endif
 286 };
 287
 288 //..............................................................................
 289
 290 #else
 291
 292 template<> struct fp_traits_non_native<long double, double_precision>
 293 {
 294     typedef ieee_copy_all_bits_tag method;
 295
 296     static const uint64_t sign     = (uint64_t)0x80000000u << 32;
 297     static const uint64_t exponent = (uint64_t)0x7ff00000 << 32;
 298     static const uint64_t flag     = 0;
 299     static const uint64_t significand
 300         = ((uint64_t)0x000fffff << 32) + (uint64_t)0xffffffffu;
 301
 302     typedef uint64_t bits;
 303     static void get_bits(long double x, uint64_t& a) { std::memcpy(&a, &x, 8); }
 304     static void set_bits(long double& x, uint64_t a) { std::memcpy(&x, &a, 8); }
 305 };
 306
 307 #endif
 308
 309
 310 // long double (>64 bits), x86 and x64 -----------------------------------------
 311
 312 #if defined(__i386) || defined(__i386__) || defined(_M_IX86) \
 313     || defined(__amd64) || defined(__amd64__)  || defined(_M_AMD64) \
 314     || defined(__x86_64) || defined(__x86_64__) || defined(_M_X64)
 315
 316 // Intel extended double precision format (80 bits)
 317
 318 template<>
 319 struct fp_traits_non_native<long double, extended_double_precision>
 320 {
 321     typedef ieee_copy_leading_bits_tag method;
 322
 323     BOOST_STATIC_CONSTANT(uint32_t, sign        = 0x80000000u);
 324     BOOST_STATIC_CONSTANT(uint32_t, exponent    = 0x7fff0000);
 325     BOOST_STATIC_CONSTANT(uint32_t, flag        = 0x00008000);
 326     BOOST_STATIC_CONSTANT(uint32_t, significand = 0x00007fff);
 327
 328     typedef uint32_t bits;
 329
 330     static void get_bits(long double x, uint32_t& a)
 331     {
 332         std::memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + 6, 4);
 333     }
 334
 335     static void set_bits(long double& x, uint32_t a)
 336     {
 337         std::memcpy(reinterpret_cast<unsigned char*>(&x) + 6, &a, 4);
 338     }
 339 };
 340
 341
 342 // long double (>64 bits), Itanium ---------------------------------------------
 343
 344 #elif defined(__ia64) || defined(__ia64__) || defined(_M_IA64)
 345
 346 // The floating point format is unknown at compile time
 347 // No template specialization is provided.
 348 // The generic_tag definition is used.
 349
 350 // The Itanium supports both
 351 // the Intel extended double precision format (80 bits) and
 352 // the IEEE extended double precision format with 15 exponent bits (128 bits).
 353
 354
 355 // long double (>64 bits), PowerPC ---------------------------------------------
 356
 357 #elif defined(__powerpc) || defined(__powerpc__) || defined(__POWERPC__) \
 358     || defined(__ppc) || defined(__ppc__) || defined(__PPC__)
 359
 360 // PowerPC extended double precision format (128 bits)
 361
 362 template<>
 363 struct fp_traits_non_native<long double, extended_double_precision>
 364 {
 365     typedef ieee_copy_leading_bits_tag method;
 366
 367     BOOST_STATIC_CONSTANT(uint32_t, sign        = 0x80000000u);
 368     BOOST_STATIC_CONSTANT(uint32_t, exponent    = 0x7ff00000);
 369     BOOST_STATIC_CONSTANT(uint32_t, flag        = 0x00000000);
 370     BOOST_STATIC_CONSTANT(uint32_t, significand = 0x000fffff);
 371
 372     typedef uint32_t bits;
 373
 374     static void get_bits(long double x, uint32_t& a)
 375     {
 376         std::memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
 377     }
 378
 379     static void set_bits(long double& x, uint32_t a)
 380     {
 381         std::memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
 382     }
 383
 384 private:
 385
 386 #if defined(BOOST_BIG_ENDIAN)
 387     BOOST_STATIC_CONSTANT(int, offset_ = 0);
 388 #elif defined(BOOST_LITTLE_ENDIAN)
 389     BOOST_STATIC_CONSTANT(int, offset_ = 12);
 390 #else
 391     BOOST_STATIC_ASSERT(false);
 392 #endif
 393 };
 394
 395
 396 // long double (>64 bits), Motorola 68K ----------------------------------------
 397
 398 #elif defined(__m68k) || defined(__m68k__) \
 399     || defined(__mc68000) || defined(__mc68000__) \
 400
 401 // Motorola extended double precision format (96 bits)
 402
 403 // It is the same format as the Intel extended double precision format,
 404 // except that 1) it is big-endian, 2) the 3rd and 4th byte are padding, and
 405 // 3) the flag bit is not set for infinity
 406
 407 template<>
 408 struct fp_traits_non_native<long double, extended_double_precision>
 409 {
 410     typedef ieee_copy_leading_bits_tag method;
 411
 412     BOOST_STATIC_CONSTANT(uint32_t, sign        = 0x80000000u);
 413     BOOST_STATIC_CONSTANT(uint32_t, exponent    = 0x7fff0000);
 414     BOOST_STATIC_CONSTANT(uint32_t, flag        = 0x00008000);
 415     BOOST_STATIC_CONSTANT(uint32_t, significand = 0x00007fff);
 416
 417     // copy 1st, 2nd, 5th and 6th byte. 3rd and 4th byte are padding.
 418
 419     typedef uint32_t bits;
 420
 421     static void get_bits(long double x, uint32_t& a)
 422     {
 423         std::memcpy(&a, &x, 2);
 424         std::memcpy(reinterpret_cast<unsigned char*>(&a) + 2,
 425                reinterpret_cast<const unsigned char*>(&x) + 4, 2);
 426     }
 427
 428     static void set_bits(long double& x, uint32_t a)
 429     {
 430         std::memcpy(&x, &a, 2);
 431         std::memcpy(reinterpret_cast<unsigned char*>(&x) + 4,
 432                reinterpret_cast<const unsigned char*>(&a) + 2, 2);
 433     }
 434 };
 435
 436
 437 // long double (>64 bits), All other processors --------------------------------
 438
 439 #else
 440
 441 // IEEE extended double precision format with 15 exponent bits (128 bits)
 442
 443 template<>
 444 struct fp_traits_non_native<long double, extended_double_precision>
 445 {
 446     typedef ieee_copy_leading_bits_tag method;
 447
 448     BOOST_STATIC_CONSTANT(uint32_t, sign        = 0x80000000u);
 449     BOOST_STATIC_CONSTANT(uint32_t, exponent    = 0x7fff0000);
 450     BOOST_STATIC_CONSTANT(uint32_t, flag        = 0x00000000);
 451     BOOST_STATIC_CONSTANT(uint32_t, significand = 0x0000ffff);
 452
 453     typedef uint32_t bits;
 454
 455     static void get_bits(long double x, uint32_t& a)
 456     {
 457         std::memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
 458     }
 459
 460     static void set_bits(long double& x, uint32_t a)
 461     {
 462         std::memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
 463     }
 464
 465 private:
 466
 467 #if defined(BOOST_BIG_ENDIAN)
 468     BOOST_STATIC_CONSTANT(int, offset_ = 0);
 469 #elif defined(BOOST_LITTLE_ENDIAN)
 470     BOOST_STATIC_CONSTANT(int, offset_ = 12);
 471 #else
 472     BOOST_STATIC_ASSERT(false);
 473 #endif
 474 };
 475
 476 #endif
 477
 478 //------------------------------------------------------------------------------
 479
 480 // size_to_precision is a type switch for converting a C++ floating point type
 481 // to the corresponding precision type.
 482
 483 template<int n, bool fp> struct size_to_precision
 484 {
 485    typedef unknown_precision type;
 486 };
 487
 488 template<> struct size_to_precision<4, true>
 489 {
 490     typedef single_precision type;
 491 };
 492
 493 template<> struct size_to_precision<8, true>
 494 {
 495     typedef double_precision type;
 496 };
 497
 498 template<> struct size_to_precision<10, true>
 499 {
 500     typedef extended_double_precision type;
 501 };
 502
 503 template<> struct size_to_precision<12, true>
 504 {
 505     typedef extended_double_precision type;
 506 };
 507
 508 template<> struct size_to_precision<16, true>
 509 {
 510     typedef extended_double_precision type;
 511 };
 512
 513 //------------------------------------------------------------------------------
 514 //
 515 // Figure out whether to use native classification functions based on
 516 // whether T is a built in floating point type or not:
 517 //
 518 template <class T>
 519 struct select_native
 520 {
 521     typedef BOOST_DEDUCED_TYPENAME size_to_precision<sizeof(T), ::boost::is_floating_point<T>::value>::type precision;
 522     typedef fp_traits_non_native<T, precision> type;
 523 };
 524 template<>
 525 struct select_native<float>
 526 {
 527     typedef fp_traits_native<float> type;
 528 };
 529 template<>
 530 struct select_native<double>
 531 {
 532     typedef fp_traits_native<double> type;
 533 };
 534 template<>
 535 struct select_native<long double>
 536 {
 537     typedef fp_traits_native<long double> type;
 538 };
 539
 540 //------------------------------------------------------------------------------
 541
 542 // fp_traits is a type switch that selects the right fp_traits_non_native
 543
 544 #if (defined(BOOST_MATH_USE_C99) && !(defined(__GNUC__) && (__GNUC__ < 4))) \
 545    && !defined(__hpux) \
 546    && !defined(__DECCXX)\
 547    && !defined(__osf__) \
 548    && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)\
 549    && !defined(BOOST_MATH_DISABLE_STD_FPCLASSIFY)
 550 #  define BOOST_MATH_USE_STD_FPCLASSIFY
 551 #endif
 552
 553 template<class T> struct fp_traits
 554 {
 555     typedef BOOST_DEDUCED_TYPENAME size_to_precision<sizeof(T), ::boost::is_floating_point<T>::value>::type precision;
 556 #if defined(BOOST_MATH_USE_STD_FPCLASSIFY) && !defined(BOOST_MATH_DISABLE_STD_FPCLASSIFY)
 557     typedef typename select_native<T>::type type;
 558 #else
 559     typedef fp_traits_non_native<T, precision> type;
 560 #endif
 561     typedef fp_traits_non_native<T, precision> sign_change_type;
 562 };
 563
 564 //------------------------------------------------------------------------------
 565
 566 }   // namespace detail
 567 }   // namespace math
 568 }   // namespace boost
 569
 570 #endif