ceph/src/boost/boost/math/tools/precision.hpp

   1 //  Copyright John Maddock 2005-2006.
   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 #ifndef BOOST_MATH_TOOLS_PRECISION_INCLUDED
   7 #define BOOST_MATH_TOOLS_PRECISION_INCLUDED
   8
   9 #ifdef _MSC_VER
  10 #pragma once
  11 #endif
  12
  13 #include <boost/limits.hpp>
  14 #include <boost/assert.hpp>
  15 #include <boost/static_assert.hpp>
  16 #include <boost/mpl/int.hpp>
  17 #include <boost/mpl/bool.hpp>
  18 #include <boost/mpl/if.hpp>
  19 #include <boost/math/policies/policy.hpp>
  20
  21 // These two are for LDBL_MAN_DIG:
  22 #include <limits.h>
  23 #include <math.h>
  24
  25 namespace boost{ namespace math
  26 {
  27 namespace tools
  28 {
  29 // If T is not specialized, the functions digits, max_value and min_value,
  30 // all get synthesised automatically from std::numeric_limits.
  31 // However, if numeric_limits is not specialised for type RealType,
  32 // for example with NTL::RR type, then you will get a compiler error
  33 // when code tries to use these functions, unless you explicitly specialise them.
  34
  35 // For example if the precision of RealType varies at runtime,
  36 // then numeric_limits support may not be appropriate,
  37 // see boost/math/tools/ntl.hpp  for examples like
  38 // template <> NTL::RR max_value<NTL::RR> ...
  39 // See  Conceptual Requirements for Real Number Types.
  40
  41 template <class T>
  42 inline BOOST_MATH_CONSTEXPR int digits(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(T)) BOOST_NOEXCEPT
  43 {
  44 #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
  45    BOOST_STATIC_ASSERT( ::std::numeric_limits<T>::is_specialized);
  46    BOOST_STATIC_ASSERT( ::std::numeric_limits<T>::radix == 2 || ::std::numeric_limits<T>::radix == 10);
  47 #else
  48    BOOST_ASSERT(::std::numeric_limits<T>::is_specialized);
  49    BOOST_ASSERT(::std::numeric_limits<T>::radix == 2 || ::std::numeric_limits<T>::radix == 10);
  50 #endif
  51    return std::numeric_limits<T>::radix == 2
  52       ? std::numeric_limits<T>::digits
  53       : ((std::numeric_limits<T>::digits + 1) * 1000L) / 301L;
  54 }
  55
  56 template <class T>
  57 inline BOOST_MATH_CONSTEXPR T max_value(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T))  BOOST_MATH_NOEXCEPT(T)
  58 {
  59 #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
  60    BOOST_STATIC_ASSERT( ::std::numeric_limits<T>::is_specialized);
  61 #else
  62    BOOST_ASSERT(::std::numeric_limits<T>::is_specialized);
  63 #endif
  64    return (std::numeric_limits<T>::max)();
  65 } // Also used as a finite 'infinite' value for - and +infinity, for example:
  66 // -max_value<double> = -1.79769e+308, max_value<double> = 1.79769e+308.
  67
  68 template <class T>
  69 inline BOOST_MATH_CONSTEXPR T min_value(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T)
  70 {
  71 #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
  72    BOOST_STATIC_ASSERT( ::std::numeric_limits<T>::is_specialized);
  73 #else
  74    BOOST_ASSERT(::std::numeric_limits<T>::is_specialized);
  75 #endif
  76    return (std::numeric_limits<T>::min)();
  77 }
  78
  79 namespace detail{
  80 //
  81 // Logarithmic limits come next, note that although
  82 // we can compute these from the log of the max value
  83 // that is not in general thread safe (if we cache the value)
  84 // so it's better to specialise these:
  85 //
  86 // For type float first:
  87 //
  88 template <class T>
  89 inline BOOST_MATH_CONSTEXPR T log_max_value(const mpl::int_<128>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T)
  90 {
  91    return 88.0f;
  92 }
  93
  94 template <class T>
  95 inline BOOST_MATH_CONSTEXPR T log_min_value(const mpl::int_<128>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T)
  96 {
  97    return -87.0f;
  98 }
  99 //
 100 // Now double:
 101 //
 102 template <class T>
 103 inline BOOST_MATH_CONSTEXPR T log_max_value(const mpl::int_<1024>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T)
 104 {
 105    return 709.0;
 106 }
 107
 108 template <class T>
 109 inline BOOST_MATH_CONSTEXPR T log_min_value(const mpl::int_<1024>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T)
 110 {
 111    return -708.0;
 112 }
 113 //
 114 // 80 and 128-bit long doubles:
 115 //
 116 template <class T>
 117 inline BOOST_MATH_CONSTEXPR T log_max_value(const mpl::int_<16384>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T)
 118 {
 119    return 11356.0L;
 120 }
 121
 122 template <class T>
 123 inline BOOST_MATH_CONSTEXPR T log_min_value(const mpl::int_<16384>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T)
 124 {
 125    return -11355.0L;
 126 }
 127
 128 template <class T>
 129 inline T log_max_value(const mpl::int_<0>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T))
 130 {
 131    BOOST_MATH_STD_USING
 132 #ifdef __SUNPRO_CC
 133    static const T m = boost::math::tools::max_value<T>();
 134    static const T val = log(m);
 135 #else
 136    static const T val = log(boost::math::tools::max_value<T>());
 137 #endif
 138    return val;
 139 }
 140
 141 template <class T>
 142 inline T log_min_value(const mpl::int_<0>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T))
 143 {
 144    BOOST_MATH_STD_USING
 145 #ifdef __SUNPRO_CC
 146    static const T m = boost::math::tools::min_value<T>();
 147    static const T val = log(m);
 148 #else
 149    static const T val = log(boost::math::tools::min_value<T>());
 150 #endif
 151    return val;
 152 }
 153
 154 template <class T>
 155 inline BOOST_MATH_CONSTEXPR T epsilon(const mpl::true_& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T)
 156 {
 157    return std::numeric_limits<T>::epsilon();
 158 }
 159
 160 #if defined(__GNUC__) && ((LDBL_MANT_DIG == 106) || (__LDBL_MANT_DIG__ == 106))
 161 template <>
 162 inline BOOST_MATH_CONSTEXPR long double epsilon<long double>(const mpl::true_& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(long double)) BOOST_MATH_NOEXCEPT(long double)
 163 {
 164    // numeric_limits on Darwin (and elsewhere) tells lies here:
 165    // the issue is that long double on a few platforms is
 166    // really a "double double" which has a non-contiguous
 167    // mantissa: 53 bits followed by an unspecified number of
 168    // zero bits, followed by 53 more bits.  Thus the apparent
 169    // precision of the type varies depending where it's been.
 170    // Set epsilon to the value that a 106 bit fixed mantissa
 171    // type would have, as that will give us sensible behaviour everywhere.
 172    //
 173    // This static assert fails for some unknown reason, so
 174    // disabled for now...
 175    // BOOST_STATIC_ASSERT(std::numeric_limits<long double>::digits == 106);
 176    return 2.4651903288156618919116517665087e-32L;
 177 }
 178 #endif
 179
 180 template <class T>
 181 inline T epsilon(const mpl::false_& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T))
 182 {
 183    // Note: don't cache result as precision may vary at runtime:
 184    BOOST_MATH_STD_USING  // for ADL of std names
 185    return ldexp(static_cast<T>(1), 1-policies::digits<T, policies::policy<> >());
 186 }
 187
 188 template <class T>
 189 struct log_limit_traits
 190 {
 191    typedef typename mpl::if_c<
 192       (std::numeric_limits<T>::radix == 2) &&
 193       (std::numeric_limits<T>::max_exponent == 128
 194          || std::numeric_limits<T>::max_exponent == 1024
 195          || std::numeric_limits<T>::max_exponent == 16384),
 196       mpl::int_<(std::numeric_limits<T>::max_exponent > INT_MAX ? INT_MAX : static_cast<int>(std::numeric_limits<T>::max_exponent))>,
 197       mpl::int_<0>
 198    >::type tag_type;
 199    BOOST_STATIC_CONSTANT(bool, value = tag_type::value ? true : false);
 200    BOOST_STATIC_ASSERT(::std::numeric_limits<T>::is_specialized || (value == 0));
 201 };
 202
 203 template <class T, bool b> struct log_limit_noexcept_traits_imp : public log_limit_traits<T> {};
 204 template <class T> struct log_limit_noexcept_traits_imp<T, false> : public boost::integral_constant<bool, false> {};
 205
 206 template <class T>
 207 struct log_limit_noexcept_traits : public log_limit_noexcept_traits_imp<T, BOOST_MATH_IS_FLOAT(T)> {};
 208
 209 } // namespace detail
 210
 211 #ifdef BOOST_MSVC
 212 #pragma warning(push)
 213 #pragma warning(disable:4309)
 214 #endif
 215
 216 template <class T>
 217 inline BOOST_MATH_CONSTEXPR T log_max_value(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_NOEXCEPT_IF(detail::log_limit_noexcept_traits<T>::value)
 218 {
 219 #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
 220    return detail::log_max_value<T>(typename detail::log_limit_traits<T>::tag_type());
 221 #else
 222    BOOST_ASSERT(::std::numeric_limits<T>::is_specialized);
 223    BOOST_MATH_STD_USING
 224    static const T val = log((std::numeric_limits<T>::max)());
 225    return val;
 226 #endif
 227 }
 228
 229 template <class T>
 230 inline BOOST_MATH_CONSTEXPR T log_min_value(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_NOEXCEPT_IF(detail::log_limit_noexcept_traits<T>::value)
 231 {
 232 #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
 233    return detail::log_min_value<T>(typename detail::log_limit_traits<T>::tag_type());
 234 #else
 235    BOOST_ASSERT(::std::numeric_limits<T>::is_specialized);
 236    BOOST_MATH_STD_USING
 237    static const T val = log((std::numeric_limits<T>::min)());
 238    return val;
 239 #endif
 240 }
 241
 242 #ifdef BOOST_MSVC
 243 #pragma warning(pop)
 244 #endif
 245
 246 template <class T>
 247 inline BOOST_MATH_CONSTEXPR T epsilon(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(T)) BOOST_MATH_NOEXCEPT(T)
 248 {
 249 #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
 250    return detail::epsilon<T>(mpl::bool_< ::std::numeric_limits<T>::is_specialized>());
 251 #else
 252    return ::std::numeric_limits<T>::is_specialized ?
 253       detail::epsilon<T>(mpl::true_()) :
 254       detail::epsilon<T>(mpl::false_());
 255 #endif
 256 }
 257
 258 namespace detail{
 259
 260 template <class T>
 261 inline BOOST_MATH_CONSTEXPR T root_epsilon_imp(const mpl::int_<24>&) BOOST_MATH_NOEXCEPT(T)
 262 {
 263    return static_cast<T>(0.00034526698300124390839884978618400831996329879769945L);
 264 }
 265
 266 template <class T>
 267 inline BOOST_MATH_CONSTEXPR T root_epsilon_imp(const T*, const mpl::int_<53>&) BOOST_MATH_NOEXCEPT(T)
 268 {
 269    return static_cast<T>(0.1490116119384765625e-7L);
 270 }
 271
 272 template <class T>
 273 inline BOOST_MATH_CONSTEXPR T root_epsilon_imp(const T*, const mpl::int_<64>&) BOOST_MATH_NOEXCEPT(T)
 274 {
 275    return static_cast<T>(0.32927225399135962333569506281281311031656150598474e-9L);
 276 }
 277
 278 template <class T>
 279 inline BOOST_MATH_CONSTEXPR T root_epsilon_imp(const T*, const mpl::int_<113>&) BOOST_MATH_NOEXCEPT(T)
 280 {
 281    return static_cast<T>(0.1387778780781445675529539585113525390625e-16L);
 282 }
 283
 284 template <class T, class Tag>
 285 inline T root_epsilon_imp(const T*, const Tag&)
 286 {
 287    BOOST_MATH_STD_USING
 288    static const T r_eps = sqrt(tools::epsilon<T>());
 289    return r_eps;
 290 }
 291
 292 template <class T>
 293 inline T root_epsilon_imp(const T*, const mpl::int_<0>&)
 294 {
 295    BOOST_MATH_STD_USING
 296    return sqrt(tools::epsilon<T>());
 297 }
 298
 299 template <class T>
 300 inline BOOST_MATH_CONSTEXPR T cbrt_epsilon_imp(const mpl::int_<24>&) BOOST_MATH_NOEXCEPT(T)
 301 {
 302    return static_cast<T>(0.0049215666011518482998719164346805794944150447839903L);
 303 }
 304
 305 template <class T>
 306 inline BOOST_MATH_CONSTEXPR T cbrt_epsilon_imp(const T*, const mpl::int_<53>&) BOOST_MATH_NOEXCEPT(T)
 307 {
 308    return static_cast<T>(6.05545445239333906078989272793696693569753008995e-6L);
 309 }
 310
 311 template <class T>
 312 inline BOOST_MATH_CONSTEXPR T cbrt_epsilon_imp(const T*, const mpl::int_<64>&) BOOST_MATH_NOEXCEPT(T)
 313 {
 314    return static_cast<T>(4.76837158203125e-7L);
 315 }
 316
 317 template <class T>
 318 inline BOOST_MATH_CONSTEXPR T cbrt_epsilon_imp(const T*, const mpl::int_<113>&) BOOST_MATH_NOEXCEPT(T)
 319 {
 320    return static_cast<T>(5.7749313854154005630396773604745549542403508090496e-12L);
 321 }
 322
 323 template <class T, class Tag>
 324 inline T cbrt_epsilon_imp(const T*, const Tag&)
 325 {
 326    BOOST_MATH_STD_USING;
 327    static const T cbrt_eps = pow(tools::epsilon<T>(), T(1) / 3);
 328    return cbrt_eps;
 329 }
 330
 331 template <class T>
 332 inline T cbrt_epsilon_imp(const T*, const mpl::int_<0>&)
 333 {
 334    BOOST_MATH_STD_USING;
 335    return pow(tools::epsilon<T>(), T(1) / 3);
 336 }
 337
 338 template <class T>
 339 inline BOOST_MATH_CONSTEXPR T forth_root_epsilon_imp(const T*, const mpl::int_<24>&) BOOST_MATH_NOEXCEPT(T)
 340 {
 341    return static_cast<T>(0.018581361171917516667460937040007436176452688944747L);
 342 }
 343
 344 template <class T>
 345 inline BOOST_MATH_CONSTEXPR T forth_root_epsilon_imp(const T*, const mpl::int_<53>&) BOOST_MATH_NOEXCEPT(T)
 346 {
 347    return static_cast<T>(0.0001220703125L);
 348 }
 349
 350 template <class T>
 351 inline BOOST_MATH_CONSTEXPR T forth_root_epsilon_imp(const T*, const mpl::int_<64>&) BOOST_MATH_NOEXCEPT(T)
 352 {
 353    return static_cast<T>(0.18145860519450699870567321328132261891067079047605e-4L);
 354 }
 355
 356 template <class T>
 357 inline BOOST_MATH_CONSTEXPR T forth_root_epsilon_imp(const T*, const mpl::int_<113>&) BOOST_MATH_NOEXCEPT(T)
 358 {
 359    return static_cast<T>(0.37252902984619140625e-8L);
 360 }
 361
 362 template <class T, class Tag>
 363 inline T forth_root_epsilon_imp(const T*, const Tag&)
 364 {
 365    BOOST_MATH_STD_USING
 366    static const T r_eps = sqrt(sqrt(tools::epsilon<T>()));
 367    return r_eps;
 368 }
 369
 370 template <class T>
 371 inline T forth_root_epsilon_imp(const T*, const mpl::int_<0>&)
 372 {
 373    BOOST_MATH_STD_USING
 374    return sqrt(sqrt(tools::epsilon<T>()));
 375 }
 376
 377 template <class T>
 378 struct root_epsilon_traits
 379 {
 380    typedef mpl::int_< (::std::numeric_limits<T>::radix == 2) ? std::numeric_limits<T>::digits : 0> tag_type;
 381    BOOST_STATIC_CONSTANT(bool, has_noexcept = (tag_type::value == 113) || (tag_type::value == 64) || (tag_type::value == 53) || (tag_type::value == 24));
 382 };
 383
 384 }
 385
 386 template <class T>
 387 inline BOOST_MATH_CONSTEXPR T root_epsilon() BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && detail::root_epsilon_traits<T>::has_noexcept)
 388 {
 389    return detail::root_epsilon_imp(static_cast<T const*>(0), typename detail::root_epsilon_traits<T>::tag_type());
 390 }
 391
 392 template <class T>
 393 inline BOOST_MATH_CONSTEXPR T cbrt_epsilon() BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && detail::root_epsilon_traits<T>::has_noexcept)
 394 {
 395    return detail::cbrt_epsilon_imp(static_cast<T const*>(0), typename detail::root_epsilon_traits<T>::tag_type());
 396 }
 397
 398 template <class T>
 399 inline BOOST_MATH_CONSTEXPR T forth_root_epsilon() BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && detail::root_epsilon_traits<T>::has_noexcept)
 400 {
 401    return detail::forth_root_epsilon_imp(static_cast<T const*>(0), typename detail::root_epsilon_traits<T>::tag_type());
 402 }
 403
 404 } // namespace tools
 405 } // namespace math
 406 } // namespace boost
 407
 408 #endif // BOOST_MATH_TOOLS_PRECISION_INCLUDED
 409