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

source code of include/boost/math/tools/precision.hpp