]> git.proxmox.com Git - ceph.git/blame - ceph/src/boost/libs/multiprecision/include/boost/multiprecision/float128.hpp
projects / ceph.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bump version to 12.2.2-pve1
[ceph.git] / ceph / src / boost / libs / multiprecision / include / boost / multiprecision / float128.hpp
CommitLineData
7c673cae
FG		 1///////////////////////////////////////////////////////////////
2// Copyright 2013 John Maddock. Distributed under the Boost
3// Software License, Version 1.0. (See accompanying file
4// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_
5
6#ifndef BOOST_MP_FLOAT128_HPP
7#define BOOST_MP_FLOAT128_HPP
8
9#include <boost/config.hpp>
10#include <boost/scoped_array.hpp>
11#include <boost/functional/hash.hpp>
12#include <boost/multiprecision/number.hpp>
13
14#if defined(BOOST_INTEL) && !defined(BOOST_MP_USE_FLOAT128) && !defined(BOOST_MP_USE_QUAD)
15# if defined(BOOST_INTEL_CXX_VERSION) && (BOOST_INTEL_CXX_VERSION >= 1310) && defined(__GNUC__)
16# if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6))
17# define BOOST_MP_USE_FLOAT128
18# endif
19# endif
20
21# ifndef BOOST_MP_USE_FLOAT128
22# define BOOST_MP_USE_QUAD
23# endif
24#endif
25
26#if defined(__GNUC__) && !defined(BOOST_MP_USE_FLOAT128) && !defined(BOOST_MP_USE_QUAD)
27# define BOOST_MP_USE_FLOAT128
28#endif
29
30#if !defined(BOOST_MP_USE_FLOAT128) && !defined(BOOST_MP_USE_QUAD)
31# error "Sorry compiler is neither GCC, not Intel, don't know how to configure this header."
32#endif
33#if defined(BOOST_MP_USE_FLOAT128) && defined(BOOST_MP_USE_QUAD)
34# error "Oh dear, both BOOST_MP_USE_FLOAT128 and BOOST_MP_USE_QUAD are defined, which one should I be using?"
35#endif
36
37#if defined(BOOST_MP_USE_FLOAT128)
38
39extern "C" {
40#include <quadmath.h>
41}
42
43typedef __float128 float128_type;
44
45#elif defined(BOOST_MP_USE_QUAD)
46
47#include <boost/multiprecision/detail/float_string_cvt.hpp>
48
49typedef _Quad float128_type;
50
51extern "C" {
52_Quad __ldexpq(_Quad, int);
53_Quad __frexpq(_Quad, int*);
54_Quad __fabsq(_Quad);
55_Quad __floorq(_Quad);
56_Quad __ceilq(_Quad);
57_Quad __sqrtq(_Quad);
58_Quad __truncq(_Quad);
59_Quad __expq(_Quad);
60_Quad __powq(_Quad, _Quad);
61_Quad __logq(_Quad);
62_Quad __log10q(_Quad);
63_Quad __sinq(_Quad);
64_Quad __cosq(_Quad);
65_Quad __tanq(_Quad);
66_Quad __asinq(_Quad);
67_Quad __acosq(_Quad);
68_Quad __atanq(_Quad);
69_Quad __sinhq(_Quad);
70_Quad __coshq(_Quad);
71_Quad __tanhq(_Quad);
72_Quad __fmodq(_Quad, _Quad);
73_Quad __atan2q(_Quad, _Quad);
74
75#define ldexpq __ldexpq
76#define frexpq __frexpq
77#define fabsq __fabsq
78#define floorq __floorq
79#define ceilq __ceilq
80#define sqrtq __sqrtq
81#define truncq __truncq
82#define expq __expq
83#define powq __powq
84#define logq __logq
85#define log10q __log10q
86#define sinq __sinq
87#define cosq __cosq
88#define tanq __tanq
89#define asinq __asinq
90#define acosq __acosq
91#define atanq __atanq
92#define sinhq __sinhq
93#define coshq __coshq
94#define tanhq __tanhq
95#define fmodq __fmodq
96#define atan2q __atan2q
97}
98
99inline _Quad isnanq(_Quad v)
100{
101 return v != v;
102}
103inline _Quad isinfq(_Quad v)
104{
105 return __fabsq(v) > 1.18973149535723176508575932662800702e4932Q;
106}
107
108#endif
109
110namespace boost{
111namespace multiprecision{
112namespace backends{
113
114struct float128_backend;
115
116}
117
118using backends::float128_backend;
119
120template<>
121struct number_category<backends::float128_backend> : public mpl::int_<number_kind_floating_point> {};
122template<>
123struct number_category<float128_type> : public mpl::int_<number_kind_floating_point> {};
124
125typedef number<float128_backend, et_off> float128;
126
127namespace backends{
128
129struct float128_backend
130{
131 typedef mpl::list<signed char, short, int, long, boost::long_long_type> signed_types;
132 typedef mpl::list<unsigned char, unsigned short,
133 unsigned int, unsigned long, boost::ulong_long_type> unsigned_types;
134 typedef mpl::list<float, double, long double> float_types;
135 typedef int exponent_type;
136
137private:
138 float128_type m_value;
139public:
140 BOOST_CONSTEXPR float128_backend() BOOST_NOEXCEPT : m_value(0) {}
141 BOOST_CONSTEXPR float128_backend(const float128_backend& o) BOOST_NOEXCEPT : m_value(o.m_value) {}
142 float128_backend& operator = (const float128_backend& o) BOOST_NOEXCEPT
143 {
144 m_value = o.m_value;
145 return *this;
146 }
147 template <class T>
148 BOOST_CONSTEXPR float128_backend(const T& i, const typename enable_if_c<is_convertible<T, float128_type>::value>::type* = 0) BOOST_NOEXCEPT_IF(noexcept(std::declval<float128_type&>() = std::declval<const T&>()))
149 : m_value(i) {}
150 template <class T>
151 typename enable_if_c<is_arithmetic<T>::value || is_convertible<T, float128_type>::value, float128_backend&>::type operator = (const T& i) BOOST_NOEXCEPT_IF(noexcept(std::declval<float128_type&>() = std::declval<const T&>()))
152 {
153 m_value = i;
154 return *this;
155 }
156 float128_backend(long double const& f)
157 {
158 if(boost::math::isinf(f))
159 m_value = (f < 0) ? -1.0Q / 0.0Q : 1.0Q / 0.0Q;
160 else
161 m_value = f;
162 }
163 float128_backend& operator=(long double const& f)
164 {
165 if(boost::math::isinf(f))
166 m_value = (f < 0) ? -1.0Q / 0.0Q : 1.0Q / 0.0Q;
167 else
168 m_value = f;
169 return *this;
170 }
171 float128_backend& operator = (const char* s)
172 {
173#ifndef BOOST_MP_USE_QUAD
174 char* p_end;
175 m_value = strtoflt128(s, &p_end);
176 if(p_end - s != (std::ptrdiff_t)std::strlen(s))
177 {
178 BOOST_THROW_EXCEPTION(std::runtime_error("Unable to interpret input string as a floating point value"));
179 }
180#else
181 boost::multiprecision::detail::convert_from_string(*this, s);
182#endif
183 return *this;
184 }
185 void swap(float128_backend& o) BOOST_NOEXCEPT
186 {
187 std::swap(m_value, o.value());
188 }
189 std::string str(std::streamsize digits, std::ios_base::fmtflags f)const
190 {
191#ifndef BOOST_MP_USE_QUAD
192 char buf[100];
193 boost::scoped_array<char> buf2;
194 std::string format = "%";
195 if(f & std::ios_base::showpos)
196 format += "+";
197 if(f & std::ios_base::showpoint)
198 format += "#";
199 format += ".*";
200 if(digits == 0)
201 digits = 36;
202 format += "Q";
203 if(f & std::ios_base::scientific)
204 format += "e";
205 else if(f & std::ios_base::fixed)
206 format += "f";
207 else
208 format += "g";
209
210 int v = quadmath_snprintf (buf, 100, format.c_str(), digits, m_value);
211
212 if((v < 0) || (v >= 99))
213 {
214 int v_max = v;
215 buf2.reset(new char[v+3]);
216 v = quadmath_snprintf (&buf2[0], v_max + 3, format.c_str(), digits, m_value);
217 if(v >= v_max + 3)
218 {
219 BOOST_THROW_EXCEPTION(std::runtime_error("Formatting of float128_type failed."));
220 }
221 return &buf2[0];
222 }
223 return buf;
224#else
225 return boost::multiprecision::detail::convert_to_string(*this, digits ? digits : 37, f);
226#endif
227 }
228 void negate() BOOST_NOEXCEPT
229 {
230 m_value = -m_value;
231 }
232 int compare(const float128_backend& o)const
233 {
234 return m_value == o.m_value ? 0 : m_value < o.m_value ? -1 : 1;
235 }
236 template <class T>
237 int compare(const T& i)const
238 {
239 return m_value == i ? 0 : m_value < i ? -1 : 1;
240 }
241 float128_type& value()
242 {
243 return m_value;
244 }
245 const float128_type& value()const
246 {
247 return m_value;
248 }
249};
250
251inline void eval_add(float128_backend& result, const float128_backend& a)
252{
253 result.value() += a.value();
254}
255template <class A>
256inline void eval_add(float128_backend& result, const A& a)
257{
258 result.value() += a;
259}
260inline void eval_subtract(float128_backend& result, const float128_backend& a)
261{
262 result.value() -= a.value();
263}
264template <class A>
265inline void eval_subtract(float128_backend& result, const A& a)
266{
267 result.value() -= a;
268}
269inline void eval_multiply(float128_backend& result, const float128_backend& a)
270{
271 result.value() *= a.value();
272}
273template <class A>
274inline void eval_multiply(float128_backend& result, const A& a)
275{
276 result.value() *= a;
277}
278inline void eval_divide(float128_backend& result, const float128_backend& a)
279{
280 result.value() /= a.value();
281}
282template <class A>
283inline void eval_divide(float128_backend& result, const A& a)
284{
285 result.value() /= a;
286}
287
288inline void eval_add(float128_backend& result, const float128_backend& a, const float128_backend& b)
289{
290 result.value() = a.value() + b.value();
291}
292template <class A>
293inline void eval_add(float128_backend& result, const float128_backend& a, const A& b)
294{
295 result.value() = a.value() + b;
296}
297inline void eval_subtract(float128_backend& result, const float128_backend& a, const float128_backend& b)
298{
299 result.value() = a.value() - b.value();
300}
301template <class A>
302inline void eval_subtract(float128_backend& result, const float128_backend& a, const A& b)
303{
304 result.value() = a.value() - b;
305}
306template <class A>
307inline void eval_subtract(float128_backend& result, const A& a, const float128_backend& b)
308{
309 result.value() = a - b.value();
310}
311inline void eval_multiply(float128_backend& result, const float128_backend& a, const float128_backend& b)
312{
313 result.value() = a.value() * b.value();
314}
315template <class A>
316inline void eval_multiply(float128_backend& result, const float128_backend& a, const A& b)
317{
318 result.value() = a.value() * b;
319}
320inline void eval_divide(float128_backend& result, const float128_backend& a, const float128_backend& b)
321{
322 result.value() = a.value() / b.value();
323}
324
325template <class R>
326inline void eval_convert_to(R* result, const float128_backend& val)
327{
328 *result = static_cast<R>(val.value());
329}
330
331inline void eval_frexp(float128_backend& result, const float128_backend& arg, int* exp)
332{
333 result.value() = frexpq(arg.value(), exp);
334}
335
336inline void eval_ldexp(float128_backend& result, const float128_backend& arg, int exp)
337{
338 result.value() = ldexpq(arg.value(), exp);
339}
340
341inline void eval_floor(float128_backend& result, const float128_backend& arg)
342{
343 result.value() = floorq(arg.value());
344}
345inline void eval_ceil(float128_backend& result, const float128_backend& arg)
346{
347 result.value() = ceilq(arg.value());
348}
349inline void eval_sqrt(float128_backend& result, const float128_backend& arg)
350{
351 result.value() = sqrtq(arg.value());
352}
353inline int eval_fpclassify(const float128_backend& arg)
354{
355 if(isnanq(arg.value()))
356 return FP_NAN;
357 else if(isinfq(arg.value()))
358 return FP_INFINITE;
359 else if(arg.value() == 0)
360 return FP_ZERO;
361
362 float128_backend t(arg);
363 if(t.value() < 0)
364 t.negate();
365 if(t.value() < 3.36210314311209350626267781732175260e-4932Q)
366 return FP_SUBNORMAL;
367 return FP_NORMAL;
368}
369
370inline void eval_increment(float128_backend& arg)
371{
372 ++arg.value();
373}
374inline void eval_decrement(float128_backend& arg)
375{
376 --arg.value();
377}
378
379/*********************************************************************
380*
381* abs/fabs:
382*
383*********************************************************************/
384
385inline void eval_abs(float128_backend& result, const float128_backend& arg)
386{
387 result.value() = fabsq(arg.value());
388}
389inline void eval_fabs(float128_backend& result, const float128_backend& arg)
390{
391 result.value() = fabsq(arg.value());
392}
393
394/*********************************************************************
395*
396* Floating point functions:
397*
398*********************************************************************/
399
400inline void eval_trunc(float128_backend& result, const float128_backend& arg)
401{
402 if(isnanq(arg.value()) || isinfq(arg.value()))
403 {
404 result = boost::math::policies::raise_rounding_error(
405 "boost::multiprecision::trunc<%1%>(%1%)", 0,
406 number<float128_backend, et_off>(arg),
407 number<float128_backend, et_off>(arg),
408 boost::math::policies::policy<>()).backend();
409 return;
410 }
411 result.value() = truncq(arg.value());
412}
413/*
414//
415// This doesn't actually work... rely on our own default version instead.
416//
417inline void eval_round(float128_backend& result, const float128_backend& arg)
418{
419 if(isnanq(arg.value()) || isinf(arg.value()))
420 {
421 result = boost::math::policies::raise_rounding_error(
422 "boost::multiprecision::trunc<%1%>(%1%)", 0,
423 number<float128_backend, et_off>(arg),
424 number<float128_backend, et_off>(arg),
425 boost::math::policies::policy<>()).backend();
426 return;
427 }
428 result.value() = roundq(arg.value());
429}
430*/
431
432inline void eval_exp(float128_backend& result, const float128_backend& arg)
433{
434 result.value() = expq(arg.value());
435}
436inline void eval_log(float128_backend& result, const float128_backend& arg)
437{
438 result.value() = logq(arg.value());
439}
440inline void eval_log10(float128_backend& result, const float128_backend& arg)
441{
442 result.value() = log10q(arg.value());
443}
444inline void eval_sin(float128_backend& result, const float128_backend& arg)
445{
446 result.value() = sinq(arg.value());
447}
448inline void eval_cos(float128_backend& result, const float128_backend& arg)
449{
450 result.value() = cosq(arg.value());
451}
452inline void eval_tan(float128_backend& result, const float128_backend& arg)
453{
454 result.value() = tanq(arg.value());
455}
456inline void eval_asin(float128_backend& result, const float128_backend& arg)
457{
458 result.value() = asinq(arg.value());
459}
460inline void eval_acos(float128_backend& result, const float128_backend& arg)
461{
462 result.value() = acosq(arg.value());
463}
464inline void eval_atan(float128_backend& result, const float128_backend& arg)
465{
466 result.value() = atanq(arg.value());
467}
468inline void eval_sinh(float128_backend& result, const float128_backend& arg)
469{
470 result.value() = sinhq(arg.value());
471}
472inline void eval_cosh(float128_backend& result, const float128_backend& arg)
473{
474 result.value() = coshq(arg.value());
475}
476inline void eval_tanh(float128_backend& result, const float128_backend& arg)
477{
478 result.value() = tanhq(arg.value());
479}
480inline void eval_fmod(float128_backend& result, const float128_backend& a, const float128_backend& b)
481{
482 result.value() = fmodq(a.value(), b.value());
483}
484inline void eval_pow(float128_backend& result, const float128_backend& a, const float128_backend& b)
485{
486 result.value() = powq(a.value(), b.value());
487}
488inline void eval_atan2(float128_backend& result, const float128_backend& a, const float128_backend& b)
489{
490 result.value() = atan2q(a.value(), b.value());
491}
492inline void eval_multiply_add(float128_backend& result, const float128_backend& a, const float128_backend& b, const float128_backend& c)
493{
494 result.value() = fmaq(a.value(), b.value(), c.value());
495}
496
497inline std::size_t hash_value(const float128_backend& val)
498{
499 return boost::hash_value(static_cast<double>(val.value()));
500}
501
502} // namespace backends
503
504 template<boost::multiprecision::expression_template_option ExpressionTemplates>
505 inline boost::multiprecision::number<float128_backend, ExpressionTemplates> asinh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<float128_backend, ExpressionTemplates>& arg)
506 {
507 return asinhq(arg.backend().value());
508 }
509 template<boost::multiprecision::expression_template_option ExpressionTemplates>
510 inline boost::multiprecision::number<float128_backend, ExpressionTemplates> acosh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<float128_backend, ExpressionTemplates>& arg)
511 {
512 return acoshq(arg.backend().value());
513 }
514 template<boost::multiprecision::expression_template_option ExpressionTemplates>
515 inline boost::multiprecision::number<float128_backend, ExpressionTemplates> atanh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<float128_backend, ExpressionTemplates>& arg)
516 {
517 return atanhq(arg.backend().value());
518 }
519 template<boost::multiprecision::expression_template_option ExpressionTemplates>
520 inline boost::multiprecision::number<float128_backend, ExpressionTemplates> cbrt BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<float128_backend, ExpressionTemplates>& arg)
521 {
522 return cbrtq(arg.backend().value());
523 }
524 template<boost::multiprecision::expression_template_option ExpressionTemplates>
525 inline boost::multiprecision::number<float128_backend, ExpressionTemplates> erf BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<float128_backend, ExpressionTemplates>& arg)
526 {
527 return erfq(arg.backend().value());
528 }
529 template<boost::multiprecision::expression_template_option ExpressionTemplates>
530 inline boost::multiprecision::number<float128_backend, ExpressionTemplates> erfc BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<float128_backend, ExpressionTemplates>& arg)
531 {
532 return erfcq(arg.backend().value());
533 }
534 template<boost::multiprecision::expression_template_option ExpressionTemplates>
535 inline boost::multiprecision::number<float128_backend, ExpressionTemplates> expm1 BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<float128_backend, ExpressionTemplates>& arg)
536 {
537 return expm1q(arg.backend().value());
538 }
539 template<boost::multiprecision::expression_template_option ExpressionTemplates>
540 inline boost::multiprecision::number<float128_backend, ExpressionTemplates> lgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<float128_backend, ExpressionTemplates>& arg)
541 {
542 return lgammaq(arg.backend().value());
543 }
544 template<boost::multiprecision::expression_template_option ExpressionTemplates>
545 inline boost::multiprecision::number<float128_backend, ExpressionTemplates> tgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<float128_backend, ExpressionTemplates>& arg)
546 {
547 return tgammaq(arg.backend().value());
548 }
549 template<boost::multiprecision::expression_template_option ExpressionTemplates>
550 inline boost::multiprecision::number<float128_backend, ExpressionTemplates> log1p BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<float128_backend, ExpressionTemplates>& arg)
551 {
552 return log1pq(arg.backend().value());
553 }
554
555 template <multiprecision::expression_template_option ExpressionTemplates>
556 inline int signbit BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates>& arg)
557 {
558 return ::signbitq(arg.backend().value());
559 }
560
561 template <multiprecision::expression_template_option ExpressionTemplates>
562 inline boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> copysign BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates>& a, const boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates>& b)
563 {
564 return ::copysignq(a.backend().value(), b.backend().value());
565 }
566
567 inline void eval_remainder(float128_backend& result, const float128_backend& a, const float128_backend& b)
568 {
569 result.value() = remainderq(a.value(), b.value());
570 }
571 inline void eval_remainder(float128_backend& result, const float128_backend& a, const float128_backend& b, int* pi)
572 {
573 result.value() = remquoq(a.value(), b.value(), pi);
574 }
575
576} // namespace multiprecision
577
578namespace math {
579
580 using boost::multiprecision::signbit;
581 using boost::multiprecision::copysign;
582
583} // namespace math
584
585} // namespace boost
586
587namespace boost{
588namespace archive{
589
590class binary_oarchive;
591class binary_iarchive;
592
593}
594
595namespace serialization{ namespace float128_detail{
596
597template <class Archive>
598void do_serialize(Archive& ar, boost::multiprecision::backends::float128_backend& val, const mpl::false_&, const mpl::false_&)
599{
600 // saving
601 // non-binary
602 std::string s(val.str(0, std::ios_base::scientific));
603 ar & s;
604}
605template <class Archive>
606void do_serialize(Archive& ar, boost::multiprecision::backends::float128_backend& val, const mpl::true_&, const mpl::false_&)
607{
608 // loading
609 // non-binary
610 std::string s;
611 ar & s;
612 val = s.c_str();
613}
614
615template <class Archive>
616void do_serialize(Archive& ar, boost::multiprecision::backends::float128_backend& val, const mpl::false_&, const mpl::true_&)
617{
618 // saving
619 // binary
620 ar.save_binary(&val, sizeof(val));
621}
622template <class Archive>
623void do_serialize(Archive& ar, boost::multiprecision::backends::float128_backend& val, const mpl::true_&, const mpl::true_&)
624{
625 // loading
626 // binary
627 ar.load_binary(&val, sizeof(val));
628}
629
630} // detail
631
632template <class Archive>
633void serialize(Archive& ar, boost::multiprecision::backends::float128_backend& val, unsigned int /*version*/)
634{
635 typedef typename Archive::is_loading load_tag;
636 typedef typename mpl::bool_<boost::is_same<Archive, boost::archive::binary_oarchive>::value || boost::is_same<Archive, boost::archive::binary_iarchive>::value> binary_tag;
637
638 float128_detail::do_serialize(ar, val, load_tag(), binary_tag());
639}
640
641} // namepsace archive
642
643} // namespace boost
644
645namespace std{
646
647template <boost::multiprecision::expression_template_option ExpressionTemplates>
648class numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >
649{
650 typedef boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> number_type;
651public:
652 BOOST_STATIC_CONSTEXPR bool is_specialized = true;
653 static number_type (min)() BOOST_NOEXCEPT { return 3.36210314311209350626267781732175260e-4932Q; }
654 static number_type (max)() BOOST_NOEXCEPT { return 1.18973149535723176508575932662800702e4932Q; }
655 static number_type lowest() BOOST_NOEXCEPT { return -(max)(); }
656 BOOST_STATIC_CONSTEXPR int digits = 113;
657 BOOST_STATIC_CONSTEXPR int digits10 = 33;
658 BOOST_STATIC_CONSTEXPR int max_digits10 = 36;
659 BOOST_STATIC_CONSTEXPR bool is_signed = true;
660 BOOST_STATIC_CONSTEXPR bool is_integer = false;
661 BOOST_STATIC_CONSTEXPR bool is_exact = false;
662 BOOST_STATIC_CONSTEXPR int radix = 2;
663 static number_type epsilon() { return 1.92592994438723585305597794258492732e-34Q; }
664 static number_type round_error() { return 0.5; }
665 BOOST_STATIC_CONSTEXPR int min_exponent = -16381;
666 BOOST_STATIC_CONSTEXPR int min_exponent10 = min_exponent * 301L / 1000L;
667 BOOST_STATIC_CONSTEXPR int max_exponent = 16384;
668 BOOST_STATIC_CONSTEXPR int max_exponent10 = max_exponent * 301L / 1000L;
669 BOOST_STATIC_CONSTEXPR bool has_infinity = true;
670 BOOST_STATIC_CONSTEXPR bool has_quiet_NaN = true;
671 BOOST_STATIC_CONSTEXPR bool has_signaling_NaN = false;
672 BOOST_STATIC_CONSTEXPR float_denorm_style has_denorm = denorm_present;
673 BOOST_STATIC_CONSTEXPR bool has_denorm_loss = true;
674 static number_type infinity() { return 1.0q / 0.0q; }
675 static number_type quiet_NaN() { return number_type("nan"); }
676 static number_type signaling_NaN() { return 0; }
677 static number_type denorm_min() { return 6.475175119438025110924438958227646552e-4966Q; }
678 BOOST_STATIC_CONSTEXPR bool is_iec559 = true;
679 BOOST_STATIC_CONSTEXPR bool is_bounded = false;
680 BOOST_STATIC_CONSTEXPR bool is_modulo = false;
681 BOOST_STATIC_CONSTEXPR bool traps = false;
682 BOOST_STATIC_CONSTEXPR bool tinyness_before = false;
683 BOOST_STATIC_CONSTEXPR float_round_style round_style = round_to_nearest;
684};
685
686template <boost::multiprecision::expression_template_option ExpressionTemplates>
687BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::is_specialized;
688template <boost::multiprecision::expression_template_option ExpressionTemplates>
689BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::digits;
690template <boost::multiprecision::expression_template_option ExpressionTemplates>
691BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::digits10;
692template <boost::multiprecision::expression_template_option ExpressionTemplates>
693BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::max_digits10;
694
695template <boost::multiprecision::expression_template_option ExpressionTemplates>
696BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::is_signed;
697template <boost::multiprecision::expression_template_option ExpressionTemplates>
698BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::is_integer;
699template <boost::multiprecision::expression_template_option ExpressionTemplates>
700BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::is_exact;
701template <boost::multiprecision::expression_template_option ExpressionTemplates>
702BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::radix;
703
704
705template <boost::multiprecision::expression_template_option ExpressionTemplates>
706BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::min_exponent;
707template <boost::multiprecision::expression_template_option ExpressionTemplates>
708BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::max_exponent;
709template <boost::multiprecision::expression_template_option ExpressionTemplates>
710BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::min_exponent10;
711template <boost::multiprecision::expression_template_option ExpressionTemplates>
712BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::max_exponent10;
713
714template <boost::multiprecision::expression_template_option ExpressionTemplates>
715BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::has_infinity;
716template <boost::multiprecision::expression_template_option ExpressionTemplates>
717BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::has_quiet_NaN;
718template <boost::multiprecision::expression_template_option ExpressionTemplates>
719BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::has_signaling_NaN;
720template <boost::multiprecision::expression_template_option ExpressionTemplates>
721BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::has_denorm_loss;
722
723template <boost::multiprecision::expression_template_option ExpressionTemplates>
724BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::is_iec559;
725template <boost::multiprecision::expression_template_option ExpressionTemplates>
726BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::is_bounded;
727template <boost::multiprecision::expression_template_option ExpressionTemplates>
728BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::is_modulo;
729template <boost::multiprecision::expression_template_option ExpressionTemplates>
730BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::traps;
731template <boost::multiprecision::expression_template_option ExpressionTemplates>
732BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::tinyness_before;
733
734template <boost::multiprecision::expression_template_option ExpressionTemplates>
735BOOST_CONSTEXPR_OR_CONST float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::round_style;
736template <boost::multiprecision::expression_template_option ExpressionTemplates>
737BOOST_CONSTEXPR_OR_CONST float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::has_denorm;
738
739} // namespace std
740
741
742#endif
Ceph