← Back to branch summary

~ai.tron/armagetronad/0.4-winlibs-updated

« back to all changes in this revision

Viewing changes to boost/includes/boost/multiprecision/mpfi.hpp

  • Committer: Nik K.
  • Date: 2013-11-07 16:58:35 UTC
  • Revision ID: nik.karbaum@gmail.com-20131107165835-kq99jz23drfj4dkh
Forgot to add some files; here they are

Show diffs side-by-side

added added

removed removed

Lines of Context:
boost/includes/boost/multiprecision/mpfi.hpp
 
1
///////////////////////////////////////////////////////////////////////////////
 
2
//  Copyright 2011 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_0.txt)
 
5
 
 
6
#ifndef BOOST_MATH_BN_MPFI_HPP
 
7
#define BOOST_MATH_BN_MPFI_HPP
 
8
 
 
9
#include <boost/multiprecision/number.hpp>
 
10
#include <boost/math/special_functions/fpclassify.hpp>
 
11
#include <boost/cstdint.hpp>
 
12
#include <boost/multiprecision/detail/big_lanczos.hpp>
 
13
#include <boost/multiprecision/detail/digits.hpp>
 
14
#include <boost/multiprecision/mpfr.hpp>
 
15
#include <mpfi.h>
 
16
#include <cmath>
 
17
#include <algorithm>
 
18
 
 
19
namespace boost{
 
20
namespace multiprecision{
 
21
namespace backends{
 
22
 
 
23
template <unsigned digits10>
 
24
struct mpfi_float_backend;
 
25
 
 
26
} // namespace backends
 
27
 
 
28
template <unsigned digits10>
 
29
struct number_category<backends::mpfi_float_backend<digits10> > : public mpl::int_<number_kind_floating_point>{};
 
30
 
 
31
struct interval_error : public std::runtime_error
 
32
{
 
33
   interval_error(const std::string& s) : std::runtime_error(s) {}
 
34
};
 
35
 
 
36
namespace backends{
 
37
 
 
38
namespace detail{
 
39
 
 
40
inline int mpfi_sgn(mpfi_srcptr p)
 
41
{
 
42
   if(mpfi_is_zero(p))
 
43
      return 0;
 
44
   if(mpfi_is_strictly_pos(p))
 
45
      return 1;
 
46
   if(mpfi_is_strictly_neg(p))
 
47
      return -1;
 
48
   BOOST_THROW_EXCEPTION(interval_error("Sign of interval is ambiguous."));
 
49
}
 
50
 
 
51
template <unsigned digits10>
 
52
struct mpfi_float_imp;
 
53
 
 
54
template <unsigned digits10>
 
55
struct mpfi_float_imp
 
56
{
 
57
   typedef mpl::list<long, long long>                     signed_types;
 
58
   typedef mpl::list<unsigned long, unsigned long long>   unsigned_types;
 
59
   typedef mpl::list<double, long double>                 float_types;
 
60
   typedef long                                           exponent_type;
 
61
 
 
62
   mpfi_float_imp()
 
63
   {
 
64
      mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
 
65
   }
 
66
   mpfi_float_imp(unsigned prec)
 
67
   {
 
68
      mpfi_init2(m_data, prec);
 
69
   }
 
70
 
 
71
   mpfi_float_imp(const mpfi_float_imp& o)
 
72
   {
 
73
      mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
 
74
      if(o.m_data[0].left._mpfr_d)
 
75
         mpfi_set(m_data, o.m_data);
 
76
   }
 
77
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
 
78
   mpfi_float_imp(mpfi_float_imp&& o) BOOST_NOEXCEPT
 
79
   {
 
80
      m_data[0] = o.m_data[0];
 
81
      o.m_data[0].left._mpfr_d = 0;
 
82
   }
 
83
#endif
 
84
   mpfi_float_imp& operator = (const mpfi_float_imp& o)
 
85
   {
 
86
      if(m_data[0].left._mpfr_d == 0)
 
87
         mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
 
88
      if(o.m_data[0].left._mpfr_d)
 
89
         mpfi_set(m_data, o.m_data);
 
90
      return *this;
 
91
   }
 
92
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
 
93
   mpfi_float_imp& operator = (mpfi_float_imp&& o) BOOST_NOEXCEPT
 
94
   {
 
95
      mpfi_swap(m_data, o.m_data);
 
96
      return *this;
 
97
   }
 
98
#endif
 
99
#ifdef _MPFR_H_HAVE_INTMAX_T
 
100
   mpfi_float_imp& operator = (unsigned long long i)
 
101
   {
 
102
      if(m_data[0].left._mpfr_d == 0)
 
103
         mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
 
104
      mpfr_set_uj(left_data(), i, GMP_RNDD);
 
105
      mpfr_set_uj(right_data(), i, GMP_RNDU);
 
106
      return *this;
 
107
   }
 
108
   mpfi_float_imp& operator = (long long i)
 
109
   {
 
110
      if(m_data[0].left._mpfr_d == 0)
 
111
         mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
 
112
      mpfr_set_sj(left_data(), i, GMP_RNDD);
 
113
      mpfr_set_sj(right_data(), i, GMP_RNDU);
 
114
      return *this;
 
115
   }
 
116
#else
 
117
   mpfi_float_imp& operator = (unsigned long long i)
 
118
   {
 
119
      if(m_data[0].left._mpfr_d == 0)
 
120
         mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
 
121
      unsigned long long mask = ((1uLL << std::numeric_limits<unsigned>::digits) - 1);
 
122
      unsigned shift = 0;
 
123
      mpfi_t t;
 
124
      mpfi_init2(t, (std::max)(static_cast<unsigned>(std::numeric_limits<unsigned long long>::digits), static_cast<unsigned>(multiprecision::detail::digits10_2_2(digits10))));
 
125
      mpfi_set_ui(m_data, 0);
 
126
      while(i)
 
127
      {
 
128
         mpfi_set_ui(t, static_cast<unsigned>(i & mask));
 
129
         if(shift)
 
130
            mpfi_mul_2exp(t, t, shift);
 
131
         mpfi_add(m_data, m_data, t);
 
132
         shift += std::numeric_limits<unsigned>::digits;
 
133
         i >>= std::numeric_limits<unsigned>::digits;
 
134
      }
 
135
      mpfi_clear(t);
 
136
      return *this;
 
137
   }
 
138
   mpfi_float_imp& operator = (long long i)
 
139
   {
 
140
      BOOST_MP_USING_ABS
 
141
      if(m_data[0].left._mpfr_d == 0)
 
142
         mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
 
143
      bool neg = i < 0;
 
144
      *this = static_cast<unsigned long long>(abs(i));
 
145
      if(neg)
 
146
         mpfi_neg(m_data, m_data);
 
147
      return *this;
 
148
   }
 
149
#endif
 
150
   mpfi_float_imp& operator = (unsigned long i)
 
151
   {
 
152
      if(m_data[0].left._mpfr_d == 0)
 
153
         mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
 
154
      mpfi_set_ui(m_data, i);
 
155
      return *this;
 
156
   }
 
157
   mpfi_float_imp& operator = (long i)
 
158
   {
 
159
      if(m_data[0].left._mpfr_d == 0)
 
160
         mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
 
161
      mpfi_set_si(m_data, i);
 
162
      return *this;
 
163
   }
 
164
   mpfi_float_imp& operator = (double d)
 
165
   {
 
166
      if(m_data[0].left._mpfr_d == 0)
 
167
         mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
 
168
      mpfi_set_d(m_data, d);
 
169
      return *this;
 
170
   }
 
171
   mpfi_float_imp& operator = (long double a)
 
172
   {
 
173
      if(m_data[0].left._mpfr_d == 0)
 
174
         mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
 
175
      mpfr_set_ld(left_data(), a, GMP_RNDD);
 
176
      mpfr_set_ld(right_data(), a, GMP_RNDU);
 
177
      return *this;
 
178
   }
 
179
   mpfi_float_imp& operator = (const char* s)
 
180
   {
 
181
      if(m_data[0].left._mpfr_d == 0)
 
182
         mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
 
183
 
 
184
      if(s && (*s == '{'))
 
185
      {
 
186
         mpfr_float_backend<digits10> a, b;
 
187
         std::string part;
 
188
         const char* p = ++s;
 
189
         while(*p && (*p != ',') && (*p != '}'))
 
190
            ++p;
 
191
         part.assign(s + 1, p);
 
192
         a = part.c_str();
 
193
         s = p;
 
194
         if(*p && (*p != '}'))
 
195
         {
 
196
            ++p;
 
197
            while(*p && (*p != ',') && (*p != '}'))
 
198
               ++p;
 
199
            part.assign(s + 1, p);
 
200
         }
 
201
         else
 
202
            part.erase();
 
203
         b = part.c_str();
 
204
 
 
205
         mpfi_interv_fr(m_data, a.data(), b.data());
 
206
      }
 
207
      else if(mpfi_set_str(m_data, s, 10) != 0)
 
208
      {
 
209
         BOOST_THROW_EXCEPTION(std::runtime_error(std::string("Unable to parse string \"") + s + std::string("\"as a valid floating point number.")));
 
210
      }
 
211
      return *this;
 
212
   }
 
213
   void swap(mpfi_float_imp& o) BOOST_NOEXCEPT
 
214
   {
 
215
      mpfi_swap(m_data, o.m_data);
 
216
   }
 
217
   std::string str(std::streamsize digits, std::ios_base::fmtflags f)const
 
218
   {
 
219
      BOOST_ASSERT(m_data[0].left._mpfr_d);
 
220
 
 
221
      mpfr_float_backend<digits10> a, b;
 
222
 
 
223
      mpfi_get_left(a.data(), m_data);
 
224
      mpfi_get_right(b.data(), m_data);
 
225
 
 
226
      if(a.compare(b) == 0)
 
227
         return a.str(digits, f);
 
228
 
 
229
      return "{" + a.str(digits, f) + "," + b.str(digits, f) + "}";
 
230
   }
 
231
   ~mpfi_float_imp() BOOST_NOEXCEPT
 
232
   {
 
233
      if(m_data[0].left._mpfr_d)
 
234
         mpfi_clear(m_data);
 
235
   }
 
236
   void negate() BOOST_NOEXCEPT
 
237
   {
 
238
      BOOST_ASSERT(m_data[0].left._mpfr_d);
 
239
      mpfi_neg(m_data, m_data);
 
240
   }
 
241
   int compare(const mpfi_float_imp& o)const BOOST_NOEXCEPT
 
242
   {
 
243
      BOOST_ASSERT(m_data[0].left._mpfr_d && o.m_data[0].left._mpfr_d);
 
244
      if(mpfr_cmp(right_data(), o.left_data()) < 0)
 
245
         return -1;
 
246
      if(mpfr_cmp(left_data(), o.right_data()) > 0)
 
247
         return 1;
 
248
      if((mpfr_cmp(left_data(), o.left_data()) == 0) && (mpfr_cmp(right_data(), o.right_data()) == 0))
 
249
         return 0;
 
250
      BOOST_THROW_EXCEPTION(interval_error("Ambiguous comparison between two values."));
 
251
      return 0;
 
252
   }
 
253
   template <class V>
 
254
   int compare(V v)const BOOST_NOEXCEPT
 
255
   {
 
256
      mpfi_float_imp d;
 
257
      d = v;
 
258
      return compare(d);
 
259
   }
 
260
   mpfi_t& data() BOOST_NOEXCEPT
 
261
   {
 
262
      BOOST_ASSERT(m_data[0].left._mpfr_d);
 
263
      return m_data;
 
264
   }
 
265
   const mpfi_t& data()const BOOST_NOEXCEPT
 
266
   {
 
267
      BOOST_ASSERT(m_data[0].left._mpfr_d);
 
268
      return m_data;
 
269
   }
 
270
   mpfr_ptr left_data() BOOST_NOEXCEPT
 
271
   {
 
272
      BOOST_ASSERT(m_data[0].left._mpfr_d);
 
273
      return &(m_data[0].left);
 
274
   }
 
275
   mpfr_srcptr left_data()const BOOST_NOEXCEPT
 
276
   {
 
277
      BOOST_ASSERT(m_data[0].left._mpfr_d);
 
278
      return &(m_data[0].left);
 
279
   }
 
280
   mpfr_ptr right_data() BOOST_NOEXCEPT
 
281
   {
 
282
      BOOST_ASSERT(m_data[0].left._mpfr_d);
 
283
      return &(m_data[0].right);
 
284
   }
 
285
   mpfr_srcptr right_data()const BOOST_NOEXCEPT
 
286
   {
 
287
      BOOST_ASSERT(m_data[0].left._mpfr_d);
 
288
      return &(m_data[0].right);
 
289
   }
 
290
protected:
 
291
   mpfi_t m_data;
 
292
   static unsigned& get_default_precision() BOOST_NOEXCEPT
 
293
   {
 
294
      static unsigned val = 50;
 
295
      return val;
 
296
   }
 
297
};
 
298
 
 
299
} // namespace detail
 
300
 
 
301
template <unsigned digits10>
 
302
struct mpfi_float_backend : public detail::mpfi_float_imp<digits10>
 
303
{
 
304
   mpfi_float_backend() : detail::mpfi_float_imp<digits10>() {}
 
305
   mpfi_float_backend(const mpfi_float_backend& o) : detail::mpfi_float_imp<digits10>(o) {}
 
306
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
 
307
   mpfi_float_backend(mpfi_float_backend&& o) : detail::mpfi_float_imp<digits10>(static_cast<detail::mpfi_float_imp<digits10>&&>(o)) {}
 
308
#endif
 
309
   template <unsigned D>
 
310
   mpfi_float_backend(const mpfi_float_backend<D>& val, typename enable_if_c<D <= digits10>::type* = 0)
 
311
       : detail::mpfi_float_imp<digits10>()
 
312
   {
 
313
      mpfi_set(this->m_data, val.data());
 
314
   }
 
315
   template <unsigned D>
 
316
   explicit mpfi_float_backend(const mpfi_float_backend<D>& val, typename disable_if_c<D <= digits10>::type* = 0)
 
317
       : detail::mpfi_float_imp<digits10>()
 
318
   {
 
319
      mpfi_set(this->m_data, val.data());
 
320
   }
 
321
   mpfi_float_backend(const mpfi_t val)
 
322
       : detail::mpfi_float_imp<digits10>()
 
323
   {
 
324
      mpfi_set(this->m_data, val);
 
325
   }
 
326
   mpfi_float_backend& operator=(const mpfi_float_backend& o)
 
327
   {
 
328
      *static_cast<detail::mpfi_float_imp<digits10>*>(this) = static_cast<detail::mpfi_float_imp<digits10> const&>(o);
 
329
      return *this;
 
330
   }
 
331
   template <unsigned D>
 
332
   mpfi_float_backend(const mpfr_float_backend<D>& val, typename enable_if_c<D <= digits10>::type* = 0)
 
333
       : detail::mpfi_float_imp<digits10>()
 
334
   {
 
335
      mpfi_set_fr(this->m_data, val.data());
 
336
   }
 
337
   template <unsigned D>
 
338
   mpfi_float_backend& operator=(const mpfr_float_backend<D>& val)
 
339
   {
 
340
      mpfi_set_fr(this->m_data, val.data());
 
341
      return *this;
 
342
   }
 
343
   template <unsigned D>
 
344
   explicit mpfi_float_backend(const mpfr_float_backend<D>& val, typename disable_if_c<D <= digits10>::type* = 0)
 
345
       : detail::mpfi_float_imp<digits10>()
 
346
   {
 
347
      mpfi_set_fr(this->m_data, val.data());
 
348
   }
 
349
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
 
350
   mpfi_float_backend& operator=(mpfi_float_backend&& o) BOOST_NOEXCEPT
 
351
   {
 
352
      *static_cast<detail::mpfi_float_imp<digits10>*>(this) = static_cast<detail::mpfi_float_imp<digits10>&&>(o);
 
353
      return *this;
 
354
   }
 
355
#endif
 
356
   template <class V>
 
357
   mpfi_float_backend& operator=(const V& v)
 
358
   {
 
359
      *static_cast<detail::mpfi_float_imp<digits10>*>(this) = v;
 
360
      return *this;
 
361
   }
 
362
   mpfi_float_backend& operator=(const mpfi_t val)
 
363
   {
 
364
      mpfi_set(this->m_data, val);
 
365
      return *this;
 
366
   }
 
367
   // We don't change our precision here, this is a fixed precision type:
 
368
   template <unsigned D>
 
369
   mpfi_float_backend& operator=(const mpfi_float_backend<D>& val)
 
370
   {
 
371
      mpfi_set(this->m_data, val.data());
 
372
      return *this;
 
373
   }
 
374
};
 
375
 
 
376
template <>
 
377
struct mpfi_float_backend<0> : public detail::mpfi_float_imp<0>
 
378
{
 
379
   mpfi_float_backend() : detail::mpfi_float_imp<0>() {}
 
380
   mpfi_float_backend(const mpfi_t val)
 
381
      : detail::mpfi_float_imp<0>(mpfi_get_prec(val))
 
382
   {
 
383
      mpfi_set(this->m_data, val);
 
384
   }
 
385
   mpfi_float_backend(const mpfi_float_backend& o) : detail::mpfi_float_imp<0>(o) {}
 
386
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
 
387
   mpfi_float_backend(mpfi_float_backend&& o) BOOST_NOEXCEPT : detail::mpfi_float_imp<0>(static_cast<detail::mpfi_float_imp<0>&&>(o)) {}
 
388
#endif
 
389
   mpfi_float_backend(const mpfi_float_backend& o, unsigned digits10)
 
390
      : detail::mpfi_float_imp<0>(digits10)
 
391
   {
 
392
      *this = o;
 
393
   }
 
394
   template <unsigned D>
 
395
   mpfi_float_backend(const mpfi_float_backend<D>& val)
 
396
      : detail::mpfi_float_imp<0>(mpfi_get_prec(val.data()))
 
397
   {
 
398
      mpfi_set(this->m_data, val.data());
 
399
   }
 
400
   mpfi_float_backend& operator=(const mpfi_float_backend& o)
 
401
   {
 
402
      mpfi_set_prec(this->m_data, mpfi_get_prec(o.data()));
 
403
      mpfi_set(this->m_data, o.data());
 
404
      return *this;
 
405
   }
 
406
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
 
407
   mpfi_float_backend& operator=(mpfi_float_backend&& o) BOOST_NOEXCEPT
 
408
   {
 
409
      *static_cast<detail::mpfi_float_imp<0>*>(this) = static_cast<detail::mpfi_float_imp<0> &&>(o);
 
410
      return *this;
 
411
   }
 
412
#endif
 
413
   template <class V>
 
414
   mpfi_float_backend& operator=(const V& v)
 
415
   {
 
416
      *static_cast<detail::mpfi_float_imp<0>*>(this) = v;
 
417
      return *this;
 
418
   }
 
419
   mpfi_float_backend& operator=(const mpfi_t val)
 
420
   {
 
421
      mpfi_set_prec(this->m_data, mpfi_get_prec(val));
 
422
      mpfi_set(this->m_data, val);
 
423
      return *this;
 
424
   }
 
425
   template <unsigned D>
 
426
   mpfi_float_backend& operator=(const mpfi_float_backend<D>& val)
 
427
   {
 
428
      mpfi_set_prec(this->m_data, mpfi_get_prec(val.data()));
 
429
      mpfi_set(this->m_data, val.data());
 
430
      return *this;
 
431
   }
 
432
   static unsigned default_precision() BOOST_NOEXCEPT
 
433
   {
 
434
      return get_default_precision();
 
435
   }
 
436
   static void default_precision(unsigned v) BOOST_NOEXCEPT
 
437
   {
 
438
      get_default_precision() = v;
 
439
   }
 
440
   unsigned precision()const BOOST_NOEXCEPT
 
441
   {
 
442
      return multiprecision::detail::digits2_2_10(mpfi_get_prec(this->m_data));
 
443
   }
 
444
   void precision(unsigned digits10) BOOST_NOEXCEPT
 
445
   {
 
446
      mpfi_set_prec(this->m_data, multiprecision::detail::digits2_2_10((digits10)));
 
447
   }
 
448
};
 
449
 
 
450
template <unsigned digits10, class T>
 
451
inline typename enable_if<is_arithmetic<T>, bool>::type eval_eq(const mpfi_float_backend<digits10>& a, const T& b) BOOST_NOEXCEPT
 
452
{
 
453
   return a.compare(b) == 0;
 
454
}
 
455
template <unsigned digits10, class T>
 
456
inline typename enable_if<is_arithmetic<T>, bool>::type eval_lt(const mpfi_float_backend<digits10>& a, const T& b) BOOST_NOEXCEPT
 
457
{
 
458
   return a.compare(b) < 0;
 
459
}
 
460
template <unsigned digits10, class T>
 
461
inline typename enable_if<is_arithmetic<T>, bool>::type eval_gt(const mpfi_float_backend<digits10>& a, const T& b) BOOST_NOEXCEPT
 
462
{
 
463
   return a.compare(b) > 0;
 
464
}
 
465
 
 
466
template <unsigned D1, unsigned D2>
 
467
inline void eval_add(mpfi_float_backend<D1>& result, const mpfi_float_backend<D2>& o)
 
468
{
 
469
   mpfi_add(result.data(), result.data(), o.data());
 
470
}
 
471
template <unsigned D1, unsigned D2>
 
472
inline void eval_subtract(mpfi_float_backend<D1>& result, const mpfi_float_backend<D2>& o)
 
473
{
 
474
   mpfi_sub(result.data(), result.data(), o.data());
 
475
}
 
476
template <unsigned D1, unsigned D2>
 
477
inline void eval_multiply(mpfi_float_backend<D1>& result, const mpfi_float_backend<D2>& o)
 
478
{
 
479
   mpfi_mul(result.data(), result.data(), o.data());
 
480
}
 
481
template <unsigned D1, unsigned D2>
 
482
inline void eval_divide(mpfi_float_backend<D1>& result, const mpfi_float_backend<D2>& o)
 
483
{
 
484
   mpfi_div(result.data(), result.data(), o.data());
 
485
}
 
486
template <unsigned digits10>
 
487
inline void eval_add(mpfi_float_backend<digits10>& result, unsigned long i)
 
488
{
 
489
   mpfi_add_ui(result.data(), result.data(), i);
 
490
}
 
491
template <unsigned digits10>
 
492
inline void eval_subtract(mpfi_float_backend<digits10>& result, unsigned long i)
 
493
{
 
494
   mpfi_sub_ui(result.data(), result.data(), i);
 
495
}
 
496
template <unsigned digits10>
 
497
inline void eval_multiply(mpfi_float_backend<digits10>& result, unsigned long i)
 
498
{
 
499
   mpfi_mul_ui(result.data(), result.data(), i);
 
500
}
 
501
template <unsigned digits10>
 
502
inline void eval_divide(mpfi_float_backend<digits10>& result, unsigned long i)
 
503
{
 
504
   mpfi_div_ui(result.data(), result.data(), i);
 
505
}
 
506
template <unsigned digits10>
 
507
inline void eval_add(mpfi_float_backend<digits10>& result, long i)
 
508
{
 
509
   if(i > 0)
 
510
      mpfi_add_ui(result.data(), result.data(), i);
 
511
   else
 
512
      mpfi_sub_ui(result.data(), result.data(), std::abs(i));
 
513
}
 
514
template <unsigned digits10>
 
515
inline void eval_subtract(mpfi_float_backend<digits10>& result, long i)
 
516
{
 
517
   if(i > 0)
 
518
      mpfi_sub_ui(result.data(), result.data(), i);
 
519
   else
 
520
      mpfi_add_ui(result.data(), result.data(), std::abs(i));
 
521
}
 
522
template <unsigned digits10>
 
523
inline void eval_multiply(mpfi_float_backend<digits10>& result, long i)
 
524
{
 
525
   mpfi_mul_ui(result.data(), result.data(), std::abs(i));
 
526
   if(i < 0)
 
527
      mpfi_neg(result.data(), result.data());
 
528
}
 
529
template <unsigned digits10>
 
530
inline void eval_divide(mpfi_float_backend<digits10>& result, long i)
 
531
{
 
532
   mpfi_div_ui(result.data(), result.data(), std::abs(i));
 
533
   if(i < 0)
 
534
      mpfi_neg(result.data(), result.data());
 
535
}
 
536
//
 
537
// Specialised 3 arg versions of the basic operators:
 
538
//
 
539
template <unsigned D1, unsigned D2, unsigned D3>
 
540
inline void eval_add(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, const mpfi_float_backend<D3>& y)
 
541
{
 
542
   mpfi_add(a.data(), x.data(), y.data());
 
543
}
 
544
template <unsigned D1, unsigned D2>
 
545
inline void eval_add(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, unsigned long y)
 
546
{
 
547
   mpfi_add_ui(a.data(), x.data(), y);
 
548
}
 
549
template <unsigned D1, unsigned D2>
 
550
inline void eval_add(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, long y)
 
551
{
 
552
   if(y < 0)
 
553
      mpfi_sub_ui(a.data(), x.data(), -y);
 
554
   else
 
555
      mpfi_add_ui(a.data(), x.data(), y);
 
556
}
 
557
template <unsigned D1, unsigned D2>
 
558
inline void eval_add(mpfi_float_backend<D1>& a, unsigned long x, const mpfi_float_backend<D2>& y)
 
559
{
 
560
   mpfi_add_ui(a.data(), y.data(), x);
 
561
}
 
562
template <unsigned D1, unsigned D2>
 
563
inline void eval_add(mpfi_float_backend<D1>& a, long x, const mpfi_float_backend<D2>& y)
 
564
{
 
565
   if(x < 0)
 
566
   {
 
567
      mpfi_ui_sub(a.data(), -x, y.data());
 
568
      mpfi_neg(a.data(), a.data());
 
569
   }
 
570
   else
 
571
      mpfi_add_ui(a.data(), y.data(), x);
 
572
}
 
573
template <unsigned D1, unsigned D2, unsigned D3>
 
574
inline void eval_subtract(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, const mpfi_float_backend<D3>& y)
 
575
{
 
576
   mpfi_sub(a.data(), x.data(), y.data());
 
577
}
 
578
template <unsigned D1, unsigned D2>
 
579
inline void eval_subtract(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, unsigned long y)
 
580
{
 
581
   mpfi_sub_ui(a.data(), x.data(), y);
 
582
}
 
583
template <unsigned D1, unsigned D2>
 
584
inline void eval_subtract(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, long y)
 
585
{
 
586
   if(y < 0)
 
587
      mpfi_add_ui(a.data(), x.data(), -y);
 
588
   else
 
589
      mpfi_sub_ui(a.data(), x.data(), y);
 
590
}
 
591
template <unsigned D1, unsigned D2>
 
592
inline void eval_subtract(mpfi_float_backend<D1>& a, unsigned long x, const mpfi_float_backend<D2>& y)
 
593
{
 
594
   mpfi_ui_sub(a.data(), x, y.data());
 
595
}
 
596
template <unsigned D1, unsigned D2>
 
597
inline void eval_subtract(mpfi_float_backend<D1>& a, long x, const mpfi_float_backend<D2>& y)
 
598
{
 
599
   if(x < 0)
 
600
   {
 
601
      mpfi_add_ui(a.data(), y.data(), -x);
 
602
      mpfi_neg(a.data(), a.data());
 
603
   }
 
604
   else
 
605
      mpfi_ui_sub(a.data(), x, y.data());
 
606
}
 
607
 
 
608
template <unsigned D1, unsigned D2, unsigned D3>
 
609
inline void eval_multiply(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, const mpfi_float_backend<D3>& y)
 
610
{
 
611
   mpfi_mul(a.data(), x.data(), y.data());
 
612
}
 
613
template <unsigned D1, unsigned D2>
 
614
inline void eval_multiply(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, unsigned long y)
 
615
{
 
616
   mpfi_mul_ui(a.data(), x.data(), y);
 
617
}
 
618
template <unsigned D1, unsigned D2>
 
619
inline void eval_multiply(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, long y)
 
620
{
 
621
   if(y < 0)
 
622
   {
 
623
      mpfi_mul_ui(a.data(), x.data(), -y);
 
624
      a.negate();
 
625
   }
 
626
   else
 
627
      mpfi_mul_ui(a.data(), x.data(), y);
 
628
}
 
629
template <unsigned D1, unsigned D2>
 
630
inline void eval_multiply(mpfi_float_backend<D1>& a, unsigned long x, const mpfi_float_backend<D2>& y)
 
631
{
 
632
   mpfi_mul_ui(a.data(), y.data(), x);
 
633
}
 
634
template <unsigned D1, unsigned D2>
 
635
inline void eval_multiply(mpfi_float_backend<D1>& a, long x, const mpfi_float_backend<D2>& y)
 
636
{
 
637
   if(x < 0)
 
638
   {
 
639
      mpfi_mul_ui(a.data(), y.data(), -x);
 
640
      mpfi_neg(a.data(), a.data());
 
641
   }
 
642
   else
 
643
      mpfi_mul_ui(a.data(), y.data(), x);
 
644
}
 
645
 
 
646
template <unsigned D1, unsigned D2, unsigned D3>
 
647
inline void eval_divide(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, const mpfi_float_backend<D3>& y)
 
648
{
 
649
   mpfi_div(a.data(), x.data(), y.data());
 
650
}
 
651
template <unsigned D1, unsigned D2>
 
652
inline void eval_divide(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, unsigned long y)
 
653
{
 
654
   mpfi_div_ui(a.data(), x.data(), y);
 
655
}
 
656
template <unsigned D1, unsigned D2>
 
657
inline void eval_divide(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, long y)
 
658
{
 
659
   if(y < 0)
 
660
   {
 
661
      mpfi_div_ui(a.data(), x.data(), -y);
 
662
      a.negate();
 
663
   }
 
664
   else
 
665
      mpfi_div_ui(a.data(), x.data(), y);
 
666
}
 
667
template <unsigned D1, unsigned D2>
 
668
inline void eval_divide(mpfi_float_backend<D1>& a, unsigned long x, const mpfi_float_backend<D2>& y)
 
669
{
 
670
   mpfi_ui_div(a.data(), x, y.data());
 
671
}
 
672
template <unsigned D1, unsigned D2>
 
673
inline void eval_divide(mpfi_float_backend<D1>& a, long x, const mpfi_float_backend<D2>& y)
 
674
{
 
675
   if(x < 0)
 
676
   {
 
677
      mpfi_ui_div(a.data(), -x, y.data());
 
678
      mpfi_neg(a.data(), a.data());
 
679
   }
 
680
   else
 
681
      mpfi_ui_div(a.data(), x, y.data());
 
682
}
 
683
 
 
684
template <unsigned digits10>
 
685
inline bool eval_is_zero(const mpfi_float_backend<digits10>& val) BOOST_NOEXCEPT
 
686
{
 
687
   return 0 != mpfi_is_zero(val.data());
 
688
}
 
689
template <unsigned digits10>
 
690
inline int eval_get_sign(const mpfi_float_backend<digits10>& val)
 
691
{
 
692
   return detail::mpfi_sgn(val.data());
 
693
}
 
694
 
 
695
template <unsigned digits10>
 
696
inline void eval_convert_to(unsigned long* result, const mpfi_float_backend<digits10>& val)
 
697
{
 
698
   mpfr_float_backend<digits10> t;
 
699
   mpfi_mid(t.data(), val.data());
 
700
   eval_convert_to(result, t);
 
701
}
 
702
template <unsigned digits10>
 
703
inline void eval_convert_to(long* result, const mpfi_float_backend<digits10>& val)
 
704
{
 
705
   mpfr_float_backend<digits10> t;
 
706
   mpfi_mid(t.data(), val.data());
 
707
   eval_convert_to(result, t);
 
708
}
 
709
#ifdef _MPFR_H_HAVE_INTMAX_T
 
710
template <unsigned digits10>
 
711
inline void eval_convert_to(unsigned long long* result, const mpfi_float_backend<digits10>& val)
 
712
{
 
713
   mpfr_float_backend<digits10> t;
 
714
   mpfi_mid(t.data(), val.data());
 
715
   eval_convert_to(result, t);
 
716
}
 
717
template <unsigned digits10>
 
718
inline void eval_convert_to(long long* result, const mpfi_float_backend<digits10>& val)
 
719
{
 
720
   mpfr_float_backend<digits10> t;
 
721
   mpfi_mid(t.data(), val.data());
 
722
   eval_convert_to(result, t);
 
723
}
 
724
#endif
 
725
template <unsigned digits10>
 
726
inline void eval_convert_to(double* result, const mpfi_float_backend<digits10>& val) BOOST_NOEXCEPT
 
727
{
 
728
   *result = mpfi_get_d(val.data());
 
729
}
 
730
template <unsigned digits10>
 
731
inline void eval_convert_to(long double* result, const mpfi_float_backend<digits10>& val) BOOST_NOEXCEPT
 
732
{
 
733
   mpfr_float_backend<digits10> t;
 
734
   mpfi_mid(t.data(), val.data());
 
735
   eval_convert_to(result, t);
 
736
}
 
737
 
 
738
template <unsigned D1, unsigned D2, mpfr_allocation_type AllocationType>
 
739
inline void assign_components(mpfi_float_backend<D1>& result, const mpfr_float_backend<D2, AllocationType>& a, const mpfr_float_backend<D2, AllocationType>& b)
 
740
{
 
741
   mpfi_interv_fr(result.data(), a.data(), b.data());
 
742
}
 
743
 
 
744
template <unsigned Digits10, class V>
 
745
inline typename enable_if_c<is_convertible<V, number<mpfr_float_backend<Digits10, allocate_dynamic>, et_on> >::value >::type 
 
746
   assign_components(mpfi_float_backend<Digits10>& result, const V& a, const V& b)
 
747
{
 
748
   number<mpfr_float_backend<Digits10, allocate_dynamic>, et_on> x(a), y(b);
 
749
   assign_components(result, x.backend(), y.backend());
 
750
}
 
751
 
 
752
//
 
753
// Native non-member operations:
 
754
//
 
755
template <unsigned Digits10>
 
756
inline void eval_sqrt(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& val)
 
757
{
 
758
   mpfi_sqrt(result.data(), val.data());
 
759
}
 
760
 
 
761
template <unsigned Digits10>
 
762
inline void eval_abs(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& val)
 
763
{
 
764
   mpfi_abs(result.data(), val.data());
 
765
}
 
766
 
 
767
template <unsigned Digits10>
 
768
inline void eval_fabs(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& val)
 
769
{
 
770
   mpfi_abs(result.data(), val.data());
 
771
}
 
772
template <unsigned Digits10>
 
773
inline void eval_ceil(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& val)
 
774
{
 
775
   mpfr_float_backend<Digits10> a, b;
 
776
   mpfr_set(a.data(), val.left_data(), GMP_RNDN);
 
777
   mpfr_set(b.data(), val.right_data(), GMP_RNDN);
 
778
   eval_ceil(a, a);
 
779
   eval_ceil(b, b);
 
780
   if(a.compare(b) != 0)
 
781
   {
 
782
      BOOST_THROW_EXCEPTION(interval_error("Attempt to take the ceil of a value that straddles an integer boundary."));
 
783
   }
 
784
   mpfi_set_fr(result.data(), a.data());
 
785
}
 
786
template <unsigned Digits10>
 
787
inline void eval_floor(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& val)
 
788
{
 
789
   mpfr_float_backend<Digits10> a, b;
 
790
   mpfr_set(a.data(), val.left_data(), GMP_RNDN);
 
791
   mpfr_set(b.data(), val.right_data(), GMP_RNDN);
 
792
   eval_floor(a, a);
 
793
   eval_floor(b, b);
 
794
   if(a.compare(b) != 0)
 
795
   {
 
796
      BOOST_THROW_EXCEPTION(interval_error("Attempt to take the floor of a value that straddles an integer boundary."));
 
797
   }
 
798
   mpfi_set_fr(result.data(), a.data());
 
799
}
 
800
template <unsigned Digits10>
 
801
inline void eval_ldexp(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& val, long e)
 
802
{
 
803
   if(e > 0)
 
804
      mpfi_mul_2exp(result.data(), val.data(), e);
 
805
   else if(e < 0)
 
806
      mpfi_div_2exp(result.data(), val.data(), -e);
 
807
   else
 
808
      result = val;
 
809
}
 
810
template <unsigned Digits10>
 
811
inline void eval_frexp(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& val, int* e)
 
812
{
 
813
   mpfr_float_backend<Digits10> t, rt;
 
814
   mpfi_mid(t.data(), val.data());
 
815
   eval_frexp(rt, t, e);
 
816
   eval_ldexp(result, val, -*e);
 
817
}
 
818
template <unsigned Digits10>
 
819
inline void eval_frexp(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& val, long* e)
 
820
{
 
821
   mpfr_float_backend<Digits10> t, rt;
 
822
   mpfi_mid(t.data(), val.data());
 
823
   eval_frexp(rt, t, e);
 
824
   eval_ldexp(result, val, -*e);
 
825
}
 
826
 
 
827
template <unsigned Digits10>
 
828
inline int eval_fpclassify(const mpfi_float_backend<Digits10>& val) BOOST_NOEXCEPT
 
829
{
 
830
   return mpfi_inf_p(val.data()) ? FP_INFINITE : mpfi_nan_p(val.data()) ? FP_NAN : mpfi_is_zero(val.data()) ? FP_ZERO : FP_NORMAL;
 
831
}
 
832
 
 
833
template <unsigned Digits10>
 
834
inline void eval_pow(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& b, const mpfi_float_backend<Digits10>& e)
 
835
{
 
836
   mpfi_log(result.data(), b.data());
 
837
   mpfi_mul(result.data(), result.data(), e.data());
 
838
   mpfi_exp(result.data(), result.data());
 
839
}
 
840
 
 
841
template <unsigned Digits10>
 
842
inline void eval_exp(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
 
843
{
 
844
   mpfi_exp(result.data(), arg.data());
 
845
}
 
846
 
 
847
template <unsigned Digits10>
 
848
inline void eval_log(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
 
849
{
 
850
   mpfi_log(result.data(), arg.data());
 
851
}
 
852
 
 
853
template <unsigned Digits10>
 
854
inline void eval_log10(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
 
855
{
 
856
   mpfi_log10(result.data(), arg.data());
 
857
}
 
858
 
 
859
template <unsigned Digits10>
 
860
inline void eval_sin(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
 
861
{
 
862
   mpfi_sin(result.data(), arg.data());
 
863
}
 
864
 
 
865
template <unsigned Digits10>
 
866
inline void eval_cos(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
 
867
{
 
868
   mpfi_cos(result.data(), arg.data());
 
869
}
 
870
 
 
871
template <unsigned Digits10>
 
872
inline void eval_tan(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
 
873
{
 
874
   mpfi_tan(result.data(), arg.data());
 
875
}
 
876
 
 
877
template <unsigned Digits10>
 
878
inline void eval_asin(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
 
879
{
 
880
   mpfi_asin(result.data(), arg.data());
 
881
}
 
882
 
 
883
template <unsigned Digits10>
 
884
inline void eval_acos(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
 
885
{
 
886
   mpfi_acos(result.data(), arg.data());
 
887
}
 
888
 
 
889
template <unsigned Digits10>
 
890
inline void eval_atan(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
 
891
{
 
892
   mpfi_atan(result.data(), arg.data());
 
893
}
 
894
 
 
895
template <unsigned Digits10>
 
896
inline void eval_atan2(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg1, const mpfi_float_backend<Digits10>& arg2)
 
897
{
 
898
   mpfi_atan2(result.data(), arg1.data(), arg2.data());
 
899
}
 
900
 
 
901
template <unsigned Digits10>
 
902
inline void eval_sinh(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
 
903
{
 
904
   mpfi_sinh(result.data(), arg.data());
 
905
}
 
906
 
 
907
template <unsigned Digits10>
 
908
inline void eval_cosh(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
 
909
{
 
910
   mpfi_cosh(result.data(), arg.data());
 
911
}
 
912
 
 
913
template <unsigned Digits10>
 
914
inline void eval_tanh(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
 
915
{
 
916
   mpfi_tanh(result.data(), arg.data());
 
917
}
 
918
 
 
919
} // namespace backends
 
920
 
 
921
#ifdef BOOST_NO_SFINAE_EXPR
 
922
 
 
923
namespace detail{
 
924
 
 
925
template<unsigned D1, unsigned D2>
 
926
struct is_explicitly_convertible<backends::mpfi_float_backend<D1>, backends::mpfi_float_backend<D2> > : public mpl::true_ {};
 
927
 
 
928
}
 
929
 
 
930
#endif
 
931
 
 
932
template<>
 
933
struct number_category<detail::canonical<mpfi_t, backends::mpfi_float_backend<0> >::type> : public mpl::int_<number_kind_floating_point>{};
 
934
template <unsigned Digits10>
 
935
struct is_interval_number<backends::mpfi_float_backend<Digits10> > : public mpl::true_ {};
 
936
 
 
937
using boost::multiprecision::backends::mpfi_float_backend;
 
938
 
 
939
typedef number<mpfi_float_backend<50> >    mpfi_float_50;
 
940
typedef number<mpfi_float_backend<100> >   mpfi_float_100;
 
941
typedef number<mpfi_float_backend<500> >   mpfi_float_500;
 
942
typedef number<mpfi_float_backend<1000> >  mpfi_float_1000;
 
943
typedef number<mpfi_float_backend<0> >     mpfi_float;
 
944
 
 
945
//
 
946
// Special interval specific functions:
 
947
//
 
948
template <unsigned Digits10, expression_template_option ExpressionTemplates>
 
949
inline number<mpfr_float_backend<Digits10>, ExpressionTemplates> lower(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& val)
 
950
{
 
951
   number<mpfr_float_backend<Digits10> > result;
 
952
   mpfr_set(result.backend().data(), val.backend().left_data(), GMP_RNDN);
 
953
   return result;
 
954
}
 
955
 
 
956
template <unsigned Digits10, expression_template_option ExpressionTemplates>
 
957
inline number<mpfr_float_backend<Digits10>, ExpressionTemplates> upper(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& val)
 
958
{
 
959
   number<mpfr_float_backend<Digits10> > result;
 
960
   mpfr_set(result.backend().data(), val.backend().right_data(), GMP_RNDN);
 
961
   return result;
 
962
}
 
963
 
 
964
template <unsigned Digits10, expression_template_option ExpressionTemplates>
 
965
inline number<mpfr_float_backend<Digits10>, ExpressionTemplates> median(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& val)
 
966
{
 
967
   number<mpfr_float_backend<Digits10> > result;
 
968
   mpfi_mid(result.backend().data(), val.backend().data());
 
969
   return result;
 
970
}
 
971
 
 
972
template <unsigned Digits10, expression_template_option ExpressionTemplates>
 
973
inline number<mpfr_float_backend<Digits10>, ExpressionTemplates> width(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& val)
 
974
{
 
975
   number<mpfr_float_backend<Digits10> > result;
 
976
   mpfi_diam_abs(result.backend().data(), val.backend().data());
 
977
   return result;
 
978
}
 
979
 
 
980
template <unsigned Digits10, expression_template_option ExpressionTemplates>
 
981
inline number<mpfi_float_backend<Digits10>, ExpressionTemplates> intersect(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a, const number<mpfi_float_backend<Digits10>, ExpressionTemplates>&  b)
 
982
{
 
983
   number<mpfi_float_backend<Digits10>, ExpressionTemplates> result;
 
984
   mpfi_intersect(result.backend().data(), a.backend().data(), b.backend().data());
 
985
   return result;
 
986
}
 
987
 
 
988
template <unsigned Digits10, expression_template_option ExpressionTemplates>
 
989
inline number<mpfi_float_backend<Digits10>, ExpressionTemplates> hull(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a, const number<mpfi_float_backend<Digits10>, ExpressionTemplates>&  b)
 
990
{
 
991
   number<mpfi_float_backend<Digits10>, ExpressionTemplates> result;
 
992
   mpfi_union(result.backend().data(), a.backend().data(), b.backend().data());
 
993
   return result;
 
994
}
 
995
 
 
996
template <unsigned Digits10, expression_template_option ExpressionTemplates>
 
997
inline bool overlap(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a, const number<mpfi_float_backend<Digits10>, ExpressionTemplates>&  b)
 
998
{
 
999
  return (lower(a) <= lower(b) && lower(b) <= upper(a)) ||
 
1000
         (lower(b) <= lower(a) && lower(a) <= upper(b));
 
1001
}
 
1002
 
 
1003
template <unsigned Digits10, expression_template_option ExpressionTemplates1, expression_template_option ExpressionTemplates2>
 
1004
inline bool in(const number<mpfr_float_backend<Digits10>, ExpressionTemplates1>& a, const number<mpfi_float_backend<Digits10>, ExpressionTemplates2>&  b)
 
1005
{
 
1006
  return mpfi_is_inside_fr(a.backend().data(), b.backend().data()) != 0;
 
1007
}
 
1008
 
 
1009
template <unsigned Digits10, expression_template_option ExpressionTemplates>
 
1010
inline bool zero_in(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>&  a)
 
1011
{
 
1012
  return mpfi_has_zero(a.backend().data()) != 0;
 
1013
}
 
1014
 
 
1015
template <unsigned Digits10, expression_template_option ExpressionTemplates>
 
1016
inline bool subset(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a, const number<mpfi_float_backend<Digits10>, ExpressionTemplates>&  b)
 
1017
{
 
1018
  return mpfi_is_inside(a.backend().data(), b.backend().data()) != 0;
 
1019
}
 
1020
 
 
1021
template <unsigned Digits10, expression_template_option ExpressionTemplates>
 
1022
inline bool proper_subset(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a, const number<mpfi_float_backend<Digits10>, ExpressionTemplates>&  b)
 
1023
{
 
1024
  return mpfi_is_strictly_inside(a.backend().data(), b.backend().data()) != 0;
 
1025
}
 
1026
 
 
1027
template <unsigned Digits10, expression_template_option ExpressionTemplates>
 
1028
inline bool empty(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>&  a)
 
1029
{
 
1030
  return mpfi_is_empty(a.backend().data()) != 0;
 
1031
}
 
1032
 
 
1033
template <unsigned Digits10, expression_template_option ExpressionTemplates>
 
1034
inline bool singleton(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>&  a)
 
1035
{
 
1036
  return mpfr_cmp(a.backend().left_data(), a.backend().right_data()) == 0;
 
1037
}
 
1038
 
 
1039
template <unsigned Digits10, expression_template_option ExpressionTemplates>
 
1040
struct component_type<number<mpfi_float_backend<Digits10>, ExpressionTemplates> >
 
1041
{
 
1042
   typedef number<mpfr_float_backend<Digits10>, ExpressionTemplates> type;
 
1043
};
 
1044
 
 
1045
} // namespace multiprecision
 
1046
 
 
1047
namespace math{
 
1048
 
 
1049
namespace tools{
 
1050
 
 
1051
template <>
 
1052
inline int digits<boost::multiprecision::mpfi_float>()
 
1053
{
 
1054
   return boost::multiprecision::backends::detail::get_default_precision();
 
1055
}
 
1056
template <>
 
1057
inline int digits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, boost::multiprecision::et_off> >()
 
1058
{
 
1059
   return boost::multiprecision::backends::detail::get_default_precision();
 
1060
}
 
1061
 
 
1062
} // namespace tools
 
1063
 
 
1064
namespace constants{ namespace detail{
 
1065
 
 
1066
template <class T> struct constant_pi;
 
1067
template <class T> struct constant_ln_two;
 
1068
template <class T> struct constant_euler;
 
1069
template <class T> struct constant_catalan;
 
1070
 
 
1071
template<unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1072
struct constant_pi<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >
 
1073
{
 
1074
   typedef boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> result_type;
 
1075
   template<int N>
 
1076
   static inline result_type get(const mpl::int_<N>&)
 
1077
   {
 
1078
      result_type result;
 
1079
      mpfi_const_pi(result.backend().data());
 
1080
      return result;
 
1081
   }
 
1082
};
 
1083
template<unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1084
struct constant_ln_two<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >
 
1085
{
 
1086
   typedef boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> result_type;
 
1087
   template<int N>
 
1088
   static inline result_type get(const mpl::int_<N>&)
 
1089
   {
 
1090
      result_type result;
 
1091
      mpfi_const_log2(result.backend().data());
 
1092
      return result;
 
1093
   }
 
1094
};
 
1095
template<unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1096
struct constant_euler<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >
 
1097
{
 
1098
   typedef boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> result_type;
 
1099
   template<int N>
 
1100
   static inline result_type get(const mpl::int_<N>&)
 
1101
   {
 
1102
      result_type result;
 
1103
      mpfi_const_euler(result.backend().data());
 
1104
      return result;
 
1105
   }
 
1106
};
 
1107
template<unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1108
struct constant_catalan<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >
 
1109
{
 
1110
   typedef boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> result_type;
 
1111
   template<int N>
 
1112
   static inline result_type get(const mpl::int_<N>&)
 
1113
   {
 
1114
      result_type result;
 
1115
      mpfi_const_catalan(result.backend().data());
 
1116
      return result;
 
1117
   }
 
1118
};
 
1119
 
 
1120
}} // namespaces
 
1121
 
 
1122
}}  // namespaces
 
1123
 
 
1124
namespace std{
 
1125
 
 
1126
//
 
1127
// numeric_limits [partial] specializations for the types declared in this header:
 
1128
//
 
1129
template<unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1130
class numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >
 
1131
{
 
1132
   typedef boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> number_type;
 
1133
public:
 
1134
   BOOST_STATIC_CONSTEXPR bool is_specialized = true;
 
1135
   static number_type (min)()
 
1136
   {
 
1137
      initializer.do_nothing();
 
1138
      static std::pair<bool, number_type> value;
 
1139
      if(!value.first)
 
1140
      {
 
1141
         value.first = true;
 
1142
         value.second = 0.5;
 
1143
         mpfi_div_2exp(value.second.backend().data(), value.second.backend().data(), -mpfr_get_emin());
 
1144
      }
 
1145
      return value.second;
 
1146
   }
 
1147
   static number_type (max)()
 
1148
   {
 
1149
      initializer.do_nothing();
 
1150
      static std::pair<bool, number_type> value;
 
1151
      if(!value.first)
 
1152
      {
 
1153
         value.first = true;
 
1154
         value.second = 0.5;
 
1155
         mpfi_mul_2exp(value.second.backend().data(), value.second.backend().data(), mpfr_get_emax());
 
1156
      }
 
1157
      return value.second;
 
1158
   }
 
1159
   BOOST_STATIC_CONSTEXPR number_type lowest()
 
1160
   {
 
1161
      return -(max)();
 
1162
   }
 
1163
   BOOST_STATIC_CONSTEXPR int digits = static_cast<int>((Digits10 * 1000L) / 301L + ((Digits10 * 1000L) % 301 ? 2 : 1));
 
1164
   BOOST_STATIC_CONSTEXPR int digits10 = Digits10;
 
1165
   // Is this really correct???
 
1166
   BOOST_STATIC_CONSTEXPR int max_digits10 = Digits10 + 2;
 
1167
   BOOST_STATIC_CONSTEXPR bool is_signed = true;
 
1168
   BOOST_STATIC_CONSTEXPR bool is_integer = false;
 
1169
   BOOST_STATIC_CONSTEXPR bool is_exact = false;
 
1170
   BOOST_STATIC_CONSTEXPR int radix = 2;
 
1171
   static number_type epsilon()
 
1172
   {
 
1173
      initializer.do_nothing();
 
1174
      static std::pair<bool, number_type> value;
 
1175
      if(!value.first)
 
1176
      {
 
1177
         value.first = true;
 
1178
         value.second = 1;
 
1179
         mpfi_div_2exp(value.second.backend().data(), value.second.backend().data(), std::numeric_limits<number_type>::digits - 1);
 
1180
      }
 
1181
      return value.second;
 
1182
   }
 
1183
   // What value should this be????
 
1184
   static number_type round_error()
 
1185
   {
 
1186
      // returns epsilon/2
 
1187
      initializer.do_nothing();
 
1188
      static std::pair<bool, number_type> value;
 
1189
      if(!value.first)
 
1190
      {
 
1191
         value.first = true;
 
1192
         value.second = 1;
 
1193
         mpfi_div_2exp(value.second.backend().data(), value.second.backend().data(), digits);
 
1194
      }
 
1195
      return value.second;
 
1196
   }
 
1197
   BOOST_STATIC_CONSTEXPR long min_exponent = MPFR_EMIN_DEFAULT;
 
1198
   BOOST_STATIC_CONSTEXPR long min_exponent10 = (MPFR_EMIN_DEFAULT / 1000) * 301L;
 
1199
   BOOST_STATIC_CONSTEXPR long max_exponent = MPFR_EMAX_DEFAULT;
 
1200
   BOOST_STATIC_CONSTEXPR long max_exponent10 = (MPFR_EMAX_DEFAULT / 1000) * 301L;
 
1201
   BOOST_STATIC_CONSTEXPR bool has_infinity = true;
 
1202
   BOOST_STATIC_CONSTEXPR bool has_quiet_NaN = true;
 
1203
   BOOST_STATIC_CONSTEXPR bool has_signaling_NaN = false;
 
1204
   BOOST_STATIC_CONSTEXPR float_denorm_style has_denorm = denorm_absent;
 
1205
   BOOST_STATIC_CONSTEXPR bool has_denorm_loss = false;
 
1206
   static number_type infinity()
 
1207
   {
 
1208
      initializer.do_nothing();
 
1209
      static std::pair<bool, number_type> value;
 
1210
      if(!value.first)
 
1211
      {
 
1212
         boost::multiprecision::mpfr_float_backend<Digits10> t;
 
1213
         mpfr_set_inf(t.data(), 1);
 
1214
         value.first = true;
 
1215
         mpfi_set_fr(value.second.backend().data(), t.data());
 
1216
      }
 
1217
      return value.second;
 
1218
   }
 
1219
   static number_type quiet_NaN()
 
1220
   {
 
1221
      initializer.do_nothing();
 
1222
      static std::pair<bool, number_type> value;
 
1223
      if(!value.first)
 
1224
      {
 
1225
         boost::multiprecision::mpfr_float_backend<Digits10> t;
 
1226
         mpfr_set_nan(t.data());
 
1227
         value.first = true;
 
1228
         mpfi_set_fr(value.second.backend().data(), t.data());
 
1229
      }
 
1230
      return value.second;
 
1231
   }
 
1232
   BOOST_STATIC_CONSTEXPR number_type signaling_NaN()
 
1233
   {
 
1234
      return number_type(0);
 
1235
   }
 
1236
   BOOST_STATIC_CONSTEXPR number_type denorm_min() { return number_type(0); }
 
1237
   BOOST_STATIC_CONSTEXPR bool is_iec559 = false;
 
1238
   BOOST_STATIC_CONSTEXPR bool is_bounded = true;
 
1239
   BOOST_STATIC_CONSTEXPR bool is_modulo = false;
 
1240
   BOOST_STATIC_CONSTEXPR bool traps = true;
 
1241
   BOOST_STATIC_CONSTEXPR bool tinyness_before = false;
 
1242
   BOOST_STATIC_CONSTEXPR float_round_style round_style = round_to_nearest;
 
1243
 
 
1244
private:
 
1245
   struct data_initializer
 
1246
   {
 
1247
      data_initializer()
 
1248
      {
 
1249
         std::numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<digits10> > >::epsilon();
 
1250
         std::numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<digits10> > >::round_error();
 
1251
         (std::numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<digits10> > >::min)();
 
1252
         (std::numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<digits10> > >::max)();
 
1253
         std::numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<digits10> > >::infinity();
 
1254
         std::numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<digits10> > >::quiet_NaN();
 
1255
      }
 
1256
      void do_nothing()const{}
 
1257
   };
 
1258
   static const data_initializer initializer;
 
1259
};
 
1260
 
 
1261
template<unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1262
const typename numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::data_initializer numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::initializer;
 
1263
 
 
1264
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
 
1265
 
 
1266
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1267
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::digits;
 
1268
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1269
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::digits10;
 
1270
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1271
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::max_digits10;
 
1272
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1273
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::is_signed;
 
1274
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1275
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::is_integer;
 
1276
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1277
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::is_exact;
 
1278
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1279
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::radix;
 
1280
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1281
BOOST_CONSTEXPR_OR_CONST long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::min_exponent;
 
1282
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1283
BOOST_CONSTEXPR_OR_CONST long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::min_exponent10;
 
1284
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1285
BOOST_CONSTEXPR_OR_CONST long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::max_exponent;
 
1286
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1287
BOOST_CONSTEXPR_OR_CONST long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::max_exponent10;
 
1288
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1289
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::has_infinity;
 
1290
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1291
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::has_quiet_NaN;
 
1292
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1293
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::has_signaling_NaN;
 
1294
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1295
BOOST_CONSTEXPR_OR_CONST float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::has_denorm;
 
1296
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1297
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::has_denorm_loss;
 
1298
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1299
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::is_iec559;
 
1300
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1301
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::is_bounded;
 
1302
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1303
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::is_modulo;
 
1304
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1305
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::traps;
 
1306
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1307
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::tinyness_before;
 
1308
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 
1309
BOOST_CONSTEXPR_OR_CONST float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::round_style;
 
1310
 
 
1311
#endif
 
1312
 
 
1313
 
 
1314
template<boost::multiprecision::expression_template_option ExpressionTemplates>
 
1315
class numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >
 
1316
{
 
1317
   typedef boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> number_type;
 
1318
public:
 
1319
   BOOST_STATIC_CONSTEXPR bool is_specialized = false;
 
1320
   static number_type (min)() { return number_type(0); }
 
1321
   static number_type (max)() { return number_type(0); }
 
1322
   static number_type lowest() { return number_type(0); }
 
1323
   BOOST_STATIC_CONSTEXPR int digits = 0;
 
1324
   BOOST_STATIC_CONSTEXPR int digits10 = 0;
 
1325
   BOOST_STATIC_CONSTEXPR int max_digits10 = 0;
 
1326
   BOOST_STATIC_CONSTEXPR bool is_signed = false;
 
1327
   BOOST_STATIC_CONSTEXPR bool is_integer = false;
 
1328
   BOOST_STATIC_CONSTEXPR bool is_exact = false;
 
1329
   BOOST_STATIC_CONSTEXPR int radix = 0;
 
1330
   static number_type epsilon() { return number_type(0); }
 
1331
   static number_type round_error() { return number_type(0); }
 
1332
   BOOST_STATIC_CONSTEXPR int min_exponent = 0;
 
1333
   BOOST_STATIC_CONSTEXPR int min_exponent10 = 0;
 
1334
   BOOST_STATIC_CONSTEXPR int max_exponent = 0;
 
1335
   BOOST_STATIC_CONSTEXPR int max_exponent10 = 0;
 
1336
   BOOST_STATIC_CONSTEXPR bool has_infinity = false;
 
1337
   BOOST_STATIC_CONSTEXPR bool has_quiet_NaN = false;
 
1338
   BOOST_STATIC_CONSTEXPR bool has_signaling_NaN = false;
 
1339
   BOOST_STATIC_CONSTEXPR float_denorm_style has_denorm = denorm_absent;
 
1340
   BOOST_STATIC_CONSTEXPR bool has_denorm_loss = false;
 
1341
   static number_type infinity() { return number_type(0); }
 
1342
   static number_type quiet_NaN() { return number_type(0); }
 
1343
   static number_type signaling_NaN() { return number_type(0); }
 
1344
   static number_type denorm_min() { return number_type(0); }
 
1345
   BOOST_STATIC_CONSTEXPR bool is_iec559 = false;
 
1346
   BOOST_STATIC_CONSTEXPR bool is_bounded = false;
 
1347
   BOOST_STATIC_CONSTEXPR bool is_modulo = false;
 
1348
   BOOST_STATIC_CONSTEXPR bool traps = false;
 
1349
   BOOST_STATIC_CONSTEXPR bool tinyness_before = false;
 
1350
   BOOST_STATIC_CONSTEXPR float_round_style round_style = round_toward_zero;
 
1351
};
 
1352
 
 
1353
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
 
1354
 
 
1355
template <boost::multiprecision::expression_template_option ExpressionTemplates>
 
1356
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::digits;
 
1357
template <boost::multiprecision::expression_template_option ExpressionTemplates>
 
1358
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::digits10;
 
1359
template <boost::multiprecision::expression_template_option ExpressionTemplates>
 
1360
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::max_digits10;
 
1361
template <boost::multiprecision::expression_template_option ExpressionTemplates>
 
1362
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::is_signed;
 
1363
template <boost::multiprecision::expression_template_option ExpressionTemplates>
 
1364
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::is_integer;
 
1365
template <boost::multiprecision::expression_template_option ExpressionTemplates>
 
1366
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::is_exact;
 
1367
template <boost::multiprecision::expression_template_option ExpressionTemplates>
 
1368
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::radix;
 
1369
template <boost::multiprecision::expression_template_option ExpressionTemplates>
 
1370
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::min_exponent;
 
1371
template <boost::multiprecision::expression_template_option ExpressionTemplates>
 
1372
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::min_exponent10;
 
1373
template <boost::multiprecision::expression_template_option ExpressionTemplates>
 
1374
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::max_exponent;
 
1375
template <boost::multiprecision::expression_template_option ExpressionTemplates>
 
1376
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::max_exponent10;
 
1377
template <boost::multiprecision::expression_template_option ExpressionTemplates>
 
1378
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::has_infinity;
 
1379
template <boost::multiprecision::expression_template_option ExpressionTemplates>
 
1380
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::has_quiet_NaN;
 
1381
template <boost::multiprecision::expression_template_option ExpressionTemplates>
 
1382
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::has_signaling_NaN;
 
1383
template <boost::multiprecision::expression_template_option ExpressionTemplates>
 
1384
BOOST_CONSTEXPR_OR_CONST float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::has_denorm;
 
1385
template <boost::multiprecision::expression_template_option ExpressionTemplates>
 
1386
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::has_denorm_loss;
 
1387
template <boost::multiprecision::expression_template_option ExpressionTemplates>
 
1388
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::is_iec559;
 
1389
template <boost::multiprecision::expression_template_option ExpressionTemplates>
 
1390
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::is_bounded;
 
1391
template <boost::multiprecision::expression_template_option ExpressionTemplates>
 
1392
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::is_modulo;
 
1393
template <boost::multiprecision::expression_template_option ExpressionTemplates>
 
1394
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::traps;
 
1395
template <boost::multiprecision::expression_template_option ExpressionTemplates>
 
1396
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::tinyness_before;
 
1397
template <boost::multiprecision::expression_template_option ExpressionTemplates>
 
1398
BOOST_CONSTEXPR_OR_CONST float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::round_style;
 
1399
 
 
1400
#endif
 
1401
} // namespace std
 
1402
#endif