diff options
Diffstat (limited to 'src/third_party/boost/boost/math/special_functions/detail/fp_traits.hpp')
-rw-r--r-- | src/third_party/boost/boost/math/special_functions/detail/fp_traits.hpp | 570 |
1 files changed, 0 insertions, 570 deletions
diff --git a/src/third_party/boost/boost/math/special_functions/detail/fp_traits.hpp b/src/third_party/boost/boost/math/special_functions/detail/fp_traits.hpp deleted file mode 100644 index 50c034d3032..00000000000 --- a/src/third_party/boost/boost/math/special_functions/detail/fp_traits.hpp +++ /dev/null @@ -1,570 +0,0 @@ -// fp_traits.hpp - -#ifndef BOOST_MATH_FP_TRAITS_HPP -#define BOOST_MATH_FP_TRAITS_HPP - -// Copyright (c) 2006 Johan Rade - -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt -// or copy at http://www.boost.org/LICENSE_1_0.txt) - -/* -To support old compilers, care has been taken to avoid partial template -specialization and meta function forwarding. -With these techniques, the code could be simplified. -*/ - -#if defined(__vms) && defined(__DECCXX) && !__IEEE_FLOAT -// The VAX floating point formats are used (for float and double) -# define BOOST_FPCLASSIFY_VAX_FORMAT -#endif - -#include <cstring> - -#include <boost/assert.hpp> -#include <boost/cstdint.hpp> -#include <boost/detail/endian.hpp> -#include <boost/static_assert.hpp> -#include <boost/type_traits/is_floating_point.hpp> - -#ifdef BOOST_NO_STDC_NAMESPACE - namespace std{ using ::memcpy; } -#endif - -#ifndef FP_NORMAL - -#define FP_ZERO 0 -#define FP_NORMAL 1 -#define FP_INFINITE 2 -#define FP_NAN 3 -#define FP_SUBNORMAL 4 - -#else - -#define BOOST_HAS_FPCLASSIFY - -#ifndef fpclassify -# if (defined(__GLIBCPP__) || defined(__GLIBCXX__)) \ - && defined(_GLIBCXX_USE_C99_MATH) \ - && !(defined(_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC) \ - && (_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC != 0)) -# ifdef _STLP_VENDOR_CSTD -# if _STLPORT_VERSION >= 0x520 -# define BOOST_FPCLASSIFY_PREFIX ::__std_alias:: -# else -# define BOOST_FPCLASSIFY_PREFIX ::_STLP_VENDOR_CSTD:: -# endif -# else -# define BOOST_FPCLASSIFY_PREFIX ::std:: -# endif -# else -# undef BOOST_HAS_FPCLASSIFY -# define BOOST_FPCLASSIFY_PREFIX -# endif -#elif (defined(__HP_aCC) && !defined(__hppa)) -// aCC 6 appears to do "#define fpclassify fpclassify" which messes us up a bit! -# define BOOST_FPCLASSIFY_PREFIX :: -#else -# define BOOST_FPCLASSIFY_PREFIX -#endif - -#ifdef __MINGW32__ -# undef BOOST_HAS_FPCLASSIFY -#endif - -#endif - - -//------------------------------------------------------------------------------ - -namespace boost { -namespace math { -namespace detail { - -//------------------------------------------------------------------------------ - -/* -The following classes are used to tag the different methods that are used -for floating point classification -*/ - -struct native_tag {}; -template <bool has_limits> -struct generic_tag {}; -struct ieee_tag {}; -struct ieee_copy_all_bits_tag : public ieee_tag {}; -struct ieee_copy_leading_bits_tag : public ieee_tag {}; - -#ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS -// -// These helper functions are used only when numeric_limits<> -// members are not compile time constants: -// -inline bool is_generic_tag_false(const generic_tag<false>*) -{ - return true; -} -inline bool is_generic_tag_false(const void*) -{ - return false; -} -#endif - -//------------------------------------------------------------------------------ - -/* -Most processors support three different floating point precisions: -single precision (32 bits), double precision (64 bits) -and extended double precision (80 - 128 bits, depending on the processor) - -Note that the C++ type long double can be implemented -both as double precision and extended double precision. -*/ - -struct unknown_precision{}; -struct single_precision {}; -struct double_precision {}; -struct extended_double_precision {}; - -// native_tag version -------------------------------------------------------------- - -template<class T> struct fp_traits_native -{ - typedef native_tag method; -}; - -// generic_tag version ------------------------------------------------------------- - -template<class T, class U> struct fp_traits_non_native -{ -#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS - typedef generic_tag<std::numeric_limits<T>::is_specialized> method; -#else - typedef generic_tag<false> method; -#endif -}; - -// ieee_tag versions --------------------------------------------------------------- - -/* -These specializations of fp_traits_non_native contain information needed -to "parse" the binary representation of a floating point number. - -Typedef members: - - bits -- the target type when copying the leading bytes of a floating - point number. It is a typedef for uint32_t or uint64_t. - - method -- tells us whether all bytes are copied or not. - It is a typedef for ieee_copy_all_bits_tag or ieee_copy_leading_bits_tag. - -Static data members: - - sign, exponent, flag, significand -- bit masks that give the meaning of the - bits in the leading bytes. - -Static function members: - - get_bits(), set_bits() -- provide access to the leading bytes. - -*/ - -// ieee_tag version, float (32 bits) ----------------------------------------------- - -#ifndef BOOST_FPCLASSIFY_VAX_FORMAT - -template<> struct fp_traits_non_native<float, single_precision> -{ - typedef ieee_copy_all_bits_tag method; - - BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000u); - BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7f800000); - BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00000000); - BOOST_STATIC_CONSTANT(uint32_t, significand = 0x007fffff); - - typedef uint32_t bits; - static void get_bits(float x, uint32_t& a) { std::memcpy(&a, &x, 4); } - static void set_bits(float& x, uint32_t a) { std::memcpy(&x, &a, 4); } -}; - -// ieee_tag version, double (64 bits) ---------------------------------------------- - -#if defined(BOOST_NO_INT64_T) || defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION) \ - || defined(__BORLANDC__) || defined(__CODEGEAR__) - -template<> struct fp_traits_non_native<double, double_precision> -{ - typedef ieee_copy_leading_bits_tag method; - - BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000u); - BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7ff00000); - BOOST_STATIC_CONSTANT(uint32_t, flag = 0); - BOOST_STATIC_CONSTANT(uint32_t, significand = 0x000fffff); - - typedef uint32_t bits; - - static void get_bits(double x, uint32_t& a) - { - std::memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4); - } - - static void set_bits(double& x, uint32_t a) - { - std::memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4); - } - -private: - -#if defined(BOOST_BIG_ENDIAN) - BOOST_STATIC_CONSTANT(int, offset_ = 0); -#elif defined(BOOST_LITTLE_ENDIAN) - BOOST_STATIC_CONSTANT(int, offset_ = 4); -#else - BOOST_STATIC_ASSERT(false); -#endif -}; - -//.............................................................................. - -#else - -template<> struct fp_traits_non_native<double, double_precision> -{ - typedef ieee_copy_all_bits_tag method; - - static const uint64_t sign = ((uint64_t)0x80000000u) << 32; - static const uint64_t exponent = ((uint64_t)0x7ff00000) << 32; - static const uint64_t flag = 0; - static const uint64_t significand - = (((uint64_t)0x000fffff) << 32) + ((uint64_t)0xffffffffu); - - typedef uint64_t bits; - static void get_bits(double x, uint64_t& a) { std::memcpy(&a, &x, 8); } - static void set_bits(double& x, uint64_t a) { std::memcpy(&x, &a, 8); } -}; - -#endif - -#endif // #ifndef BOOST_FPCLASSIFY_VAX_FORMAT - -// long double (64 bits) ------------------------------------------------------- - -#if defined(BOOST_NO_INT64_T) || defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)\ - || defined(__BORLANDC__) || defined(__CODEGEAR__) - -template<> struct fp_traits_non_native<long double, double_precision> -{ - typedef ieee_copy_leading_bits_tag method; - - BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000u); - BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7ff00000); - BOOST_STATIC_CONSTANT(uint32_t, flag = 0); - BOOST_STATIC_CONSTANT(uint32_t, significand = 0x000fffff); - - typedef uint32_t bits; - - static void get_bits(long double x, uint32_t& a) - { - std::memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4); - } - - static void set_bits(long double& x, uint32_t a) - { - std::memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4); - } - -private: - -#if defined(BOOST_BIG_ENDIAN) - BOOST_STATIC_CONSTANT(int, offset_ = 0); -#elif defined(BOOST_LITTLE_ENDIAN) - BOOST_STATIC_CONSTANT(int, offset_ = 4); -#else - BOOST_STATIC_ASSERT(false); -#endif -}; - -//.............................................................................. - -#else - -template<> struct fp_traits_non_native<long double, double_precision> -{ - typedef ieee_copy_all_bits_tag method; - - static const uint64_t sign = (uint64_t)0x80000000u << 32; - static const uint64_t exponent = (uint64_t)0x7ff00000 << 32; - static const uint64_t flag = 0; - static const uint64_t significand - = ((uint64_t)0x000fffff << 32) + (uint64_t)0xffffffffu; - - typedef uint64_t bits; - static void get_bits(long double x, uint64_t& a) { std::memcpy(&a, &x, 8); } - static void set_bits(long double& x, uint64_t a) { std::memcpy(&x, &a, 8); } -}; - -#endif - - -// long double (>64 bits), x86 and x64 ----------------------------------------- - -#if defined(__i386) || defined(__i386__) || defined(_M_IX86) \ - || defined(__amd64) || defined(__amd64__) || defined(_M_AMD64) \ - || defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) - -// Intel extended double precision format (80 bits) - -template<> -struct fp_traits_non_native<long double, extended_double_precision> -{ - typedef ieee_copy_leading_bits_tag method; - - BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000u); - BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7fff0000); - BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00008000); - BOOST_STATIC_CONSTANT(uint32_t, significand = 0x00007fff); - - typedef uint32_t bits; - - static void get_bits(long double x, uint32_t& a) - { - std::memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + 6, 4); - } - - static void set_bits(long double& x, uint32_t a) - { - std::memcpy(reinterpret_cast<unsigned char*>(&x) + 6, &a, 4); - } -}; - - -// long double (>64 bits), Itanium --------------------------------------------- - -#elif defined(__ia64) || defined(__ia64__) || defined(_M_IA64) - -// The floating point format is unknown at compile time -// No template specialization is provided. -// The generic_tag definition is used. - -// The Itanium supports both -// the Intel extended double precision format (80 bits) and -// the IEEE extended double precision format with 15 exponent bits (128 bits). - - -// long double (>64 bits), PowerPC --------------------------------------------- - -#elif defined(__powerpc) || defined(__powerpc__) || defined(__POWERPC__) \ - || defined(__ppc) || defined(__ppc__) || defined(__PPC__) - -// PowerPC extended double precision format (128 bits) - -template<> -struct fp_traits_non_native<long double, extended_double_precision> -{ - typedef ieee_copy_leading_bits_tag method; - - BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000u); - BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7ff00000); - BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00000000); - BOOST_STATIC_CONSTANT(uint32_t, significand = 0x000fffff); - - typedef uint32_t bits; - - static void get_bits(long double x, uint32_t& a) - { - std::memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4); - } - - static void set_bits(long double& x, uint32_t a) - { - std::memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4); - } - -private: - -#if defined(BOOST_BIG_ENDIAN) - BOOST_STATIC_CONSTANT(int, offset_ = 0); -#elif defined(BOOST_LITTLE_ENDIAN) - BOOST_STATIC_CONSTANT(int, offset_ = 12); -#else - BOOST_STATIC_ASSERT(false); -#endif -}; - - -// long double (>64 bits), Motorola 68K ---------------------------------------- - -#elif defined(__m68k) || defined(__m68k__) \ - || defined(__mc68000) || defined(__mc68000__) \ - -// Motorola extended double precision format (96 bits) - -// It is the same format as the Intel extended double precision format, -// except that 1) it is big-endian, 2) the 3rd and 4th byte are padding, and -// 3) the flag bit is not set for infinity - -template<> -struct fp_traits_non_native<long double, extended_double_precision> -{ - typedef ieee_copy_leading_bits_tag method; - - BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000u); - BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7fff0000); - BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00008000); - BOOST_STATIC_CONSTANT(uint32_t, significand = 0x00007fff); - - // copy 1st, 2nd, 5th and 6th byte. 3rd and 4th byte are padding. - - typedef uint32_t bits; - - static void get_bits(long double x, uint32_t& a) - { - std::memcpy(&a, &x, 2); - std::memcpy(reinterpret_cast<unsigned char*>(&a) + 2, - reinterpret_cast<const unsigned char*>(&x) + 4, 2); - } - - static void set_bits(long double& x, uint32_t a) - { - std::memcpy(&x, &a, 2); - std::memcpy(reinterpret_cast<unsigned char*>(&x) + 4, - reinterpret_cast<const unsigned char*>(&a) + 2, 2); - } -}; - - -// long double (>64 bits), All other processors -------------------------------- - -#else - -// IEEE extended double precision format with 15 exponent bits (128 bits) - -template<> -struct fp_traits_non_native<long double, extended_double_precision> -{ - typedef ieee_copy_leading_bits_tag method; - - BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000u); - BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7fff0000); - BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00000000); - BOOST_STATIC_CONSTANT(uint32_t, significand = 0x0000ffff); - - typedef uint32_t bits; - - static void get_bits(long double x, uint32_t& a) - { - std::memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4); - } - - static void set_bits(long double& x, uint32_t a) - { - std::memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4); - } - -private: - -#if defined(BOOST_BIG_ENDIAN) - BOOST_STATIC_CONSTANT(int, offset_ = 0); -#elif defined(BOOST_LITTLE_ENDIAN) - BOOST_STATIC_CONSTANT(int, offset_ = 12); -#else - BOOST_STATIC_ASSERT(false); -#endif -}; - -#endif - -//------------------------------------------------------------------------------ - -// size_to_precision is a type switch for converting a C++ floating point type -// to the corresponding precision type. - -template<int n, bool fp> struct size_to_precision -{ - typedef unknown_precision type; -}; - -template<> struct size_to_precision<4, true> -{ - typedef single_precision type; -}; - -template<> struct size_to_precision<8, true> -{ - typedef double_precision type; -}; - -template<> struct size_to_precision<10, true> -{ - typedef extended_double_precision type; -}; - -template<> struct size_to_precision<12, true> -{ - typedef extended_double_precision type; -}; - -template<> struct size_to_precision<16, true> -{ - typedef extended_double_precision type; -}; - -//------------------------------------------------------------------------------ -// -// Figure out whether to use native classification functions based on -// whether T is a built in floating point type or not: -// -template <class T> -struct select_native -{ - typedef BOOST_DEDUCED_TYPENAME size_to_precision<sizeof(T), ::boost::is_floating_point<T>::value>::type precision; - typedef fp_traits_non_native<T, precision> type; -}; -template<> -struct select_native<float> -{ - typedef fp_traits_native<float> type; -}; -template<> -struct select_native<double> -{ - typedef fp_traits_native<double> type; -}; -template<> -struct select_native<long double> -{ - typedef fp_traits_native<long double> type; -}; - -//------------------------------------------------------------------------------ - -// fp_traits is a type switch that selects the right fp_traits_non_native - -#if (defined(BOOST_MATH_USE_C99) && !(defined(__GNUC__) && (__GNUC__ < 4))) \ - && !defined(__hpux) \ - && !defined(__DECCXX)\ - && !defined(__osf__) \ - && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)\ - && !defined(BOOST_MATH_DISABLE_STD_FPCLASSIFY) -# define BOOST_MATH_USE_STD_FPCLASSIFY -#endif - -template<class T> struct fp_traits -{ - typedef BOOST_DEDUCED_TYPENAME size_to_precision<sizeof(T), ::boost::is_floating_point<T>::value>::type precision; -#if defined(BOOST_MATH_USE_STD_FPCLASSIFY) && !defined(BOOST_MATH_DISABLE_STD_FPCLASSIFY) - typedef typename select_native<T>::type type; -#else - typedef fp_traits_non_native<T, precision> type; -#endif - typedef fp_traits_non_native<T, precision> sign_change_type; -}; - -//------------------------------------------------------------------------------ - -} // namespace detail -} // namespace math -} // namespace boost - -#endif |