1 ///////////////////////////////////////////////////////////////
2 // Copyright 2012 John Maddock. Distributed under the Boost
3 // Software License, Version 1.0. (See accompanying file
4 // LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
5
6 #ifdef TEST_VLD
7 #include <vld.h>
8 #endif
9
10 #include <boost/math/special_functions/pow.hpp>
11 #include <boost/integer/common_factor_rt.hpp>
12 #include <boost/functional/hash.hpp>
13 #include <functional>
14 #include "test.hpp"
15
16 template <class T>
17 struct is_boost_rational : public boost::mpl::false_
18 {};
19 template <class T>
20 struct is_checked_cpp_int : public boost::mpl::false_
21 {};
22
23 #ifdef BOOST_MSVC
24 // warning C4127: conditional expression is constant
25 #pragma warning(disable : 4127)
26 #endif
27
28 template <class Target, class Source>
checked_lexical_cast(const Source & val)29 Target checked_lexical_cast(const Source& val)
30 {
31 #ifndef BOOST_NO_EXCEPTIONS
32 try
33 {
34 #endif
35 return boost::lexical_cast<Target>(val);
36 #ifndef BOOST_NO_EXCEPTIONS
37 }
38 catch (...)
39 {
40 std::cerr << "Error in lexical cast\nSource type = " << typeid(Source).name() << " \"" << val << "\"\n";
41 std::cerr << "Target type = " << typeid(Target).name() << std::endl;
42 throw;
43 }
44 #endif
45 }
46
isfloat(float)47 bool isfloat(float) { return true; }
isfloat(double)48 bool isfloat(double) { return true; }
isfloat(long double)49 bool isfloat(long double) { return true; }
50 template <class T>
isfloat(T)51 bool isfloat(T) { return false; }
52
53 namespace detail {
54
55 template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
56 typename boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type
abs(boost::multiprecision::detail::expression<tag,Arg1,Arg2,Arg3,Arg4> const & v)57 abs(boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4> const& v)
58 {
59 typedef typename boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type result_type;
60 return v < 0 ? result_type(-v) : result_type(v);
61 }
62
63 } // namespace detail
64
65 template <class T>
66 struct is_twos_complement_integer : public boost::mpl::true_
67 {};
68
69 template <class T>
70 struct related_type
71 {
72 typedef T type;
73 };
74
75 template <class Real, class Val>
test_comparisons(Val,Val,const boost::mpl::false_)76 void test_comparisons(Val, Val, const boost::mpl::false_)
77 {}
78
normalize_compare_result(int r)79 int normalize_compare_result(int r)
80 {
81 return r > 0 ? 1 : r < 0 ? -1 : 0;
82 }
83
84 template <class Real, class Val>
85 typename boost::disable_if_c<boost::multiprecision::number_category<Real>::value == boost::multiprecision::number_kind_complex>::type
test_comparisons(Val a,Val b,const boost::mpl::true_)86 test_comparisons(Val a, Val b, const boost::mpl::true_)
87 {
88 Real r1(a);
89 Real r2(b);
90 Real z(1);
91
92 int cr = a < b ? -1 : a > b ? 1 : 0;
93
94 BOOST_CHECK_EQUAL(r1 == r2, a == b);
95 BOOST_CHECK_EQUAL(r1 != r2, a != b);
96 BOOST_CHECK_EQUAL(r1 <= r2, a <= b);
97 BOOST_CHECK_EQUAL(r1 < r2, a < b);
98 BOOST_CHECK_EQUAL(r1 >= r2, a >= b);
99 BOOST_CHECK_EQUAL(r1 > r2, a > b);
100
101 BOOST_CHECK_EQUAL(r1 == b, a == b);
102 BOOST_CHECK_EQUAL(r1 != b, a != b);
103 BOOST_CHECK_EQUAL(r1 <= b, a <= b);
104 BOOST_CHECK_EQUAL(r1 < b, a < b);
105 BOOST_CHECK_EQUAL(r1 >= b, a >= b);
106 BOOST_CHECK_EQUAL(r1 > b, a > b);
107
108 BOOST_CHECK_EQUAL(a == r2, a == b);
109 BOOST_CHECK_EQUAL(a != r2, a != b);
110 BOOST_CHECK_EQUAL(a <= r2, a <= b);
111 BOOST_CHECK_EQUAL(a < r2, a < b);
112 BOOST_CHECK_EQUAL(a >= r2, a >= b);
113 BOOST_CHECK_EQUAL(a > r2, a > b);
114
115 BOOST_CHECK_EQUAL(r1 * z == r2, a == b);
116 BOOST_CHECK_EQUAL(r1 * z != r2, a != b);
117 BOOST_CHECK_EQUAL(r1 * z <= r2, a <= b);
118 BOOST_CHECK_EQUAL(r1 * z < r2, a < b);
119 BOOST_CHECK_EQUAL(r1 * z >= r2, a >= b);
120 BOOST_CHECK_EQUAL(r1 * z > r2, a > b);
121
122 BOOST_CHECK_EQUAL(r1 == r2 * z, a == b);
123 BOOST_CHECK_EQUAL(r1 != r2 * z, a != b);
124 BOOST_CHECK_EQUAL(r1 <= r2 * z, a <= b);
125 BOOST_CHECK_EQUAL(r1 < r2 * z, a < b);
126 BOOST_CHECK_EQUAL(r1 >= r2 * z, a >= b);
127 BOOST_CHECK_EQUAL(r1 > r2 * z, a > b);
128
129 BOOST_CHECK_EQUAL(r1 * z == r2 * z, a == b);
130 BOOST_CHECK_EQUAL(r1 * z != r2 * z, a != b);
131 BOOST_CHECK_EQUAL(r1 * z <= r2 * z, a <= b);
132 BOOST_CHECK_EQUAL(r1 * z < r2 * z, a < b);
133 BOOST_CHECK_EQUAL(r1 * z >= r2 * z, a >= b);
134 BOOST_CHECK_EQUAL(r1 * z > r2 * z, a > b);
135
136 BOOST_CHECK_EQUAL(r1 * z == b, a == b);
137 BOOST_CHECK_EQUAL(r1 * z != b, a != b);
138 BOOST_CHECK_EQUAL(r1 * z <= b, a <= b);
139 BOOST_CHECK_EQUAL(r1 * z < b, a < b);
140 BOOST_CHECK_EQUAL(r1 * z >= b, a >= b);
141 BOOST_CHECK_EQUAL(r1 * z > b, a > b);
142
143 BOOST_CHECK_EQUAL(a == r2 * z, a == b);
144 BOOST_CHECK_EQUAL(a != r2 * z, a != b);
145 BOOST_CHECK_EQUAL(a <= r2 * z, a <= b);
146 BOOST_CHECK_EQUAL(a < r2 * z, a < b);
147 BOOST_CHECK_EQUAL(a >= r2 * z, a >= b);
148 BOOST_CHECK_EQUAL(a > r2 * z, a > b);
149
150 BOOST_CHECK_EQUAL(normalize_compare_result(r1.compare(r2)), cr);
151 BOOST_CHECK_EQUAL(normalize_compare_result(r2.compare(r1)), -cr);
152 BOOST_CHECK_EQUAL(normalize_compare_result(r1.compare(b)), cr);
153 BOOST_CHECK_EQUAL(normalize_compare_result(r2.compare(a)), -cr);
154 }
155
156 template <class Real, class Val>
157 typename boost::enable_if_c<boost::multiprecision::number_category<Real>::value == boost::multiprecision::number_kind_complex>::type
test_comparisons(Val a,Val b,const boost::mpl::true_)158 test_comparisons(Val a, Val b, const boost::mpl::true_)
159 {
160 Real r1(a);
161 Real r2(b);
162 Real z(1);
163
164 int cr = a < b ? -1 : a > b ? 1 : 0;
165 (void)cr;
166
167 BOOST_CHECK_EQUAL(r1 == r2, a == b);
168 BOOST_CHECK_EQUAL(r1 != r2, a != b);
169
170 BOOST_CHECK_EQUAL(r1 == b, a == b);
171 BOOST_CHECK_EQUAL(r1 != b, a != b);
172
173 BOOST_CHECK_EQUAL(a == r2, a == b);
174 BOOST_CHECK_EQUAL(a != r2, a != b);
175
176 BOOST_CHECK_EQUAL(r1 * z == r2, a == b);
177 BOOST_CHECK_EQUAL(r1 * z != r2, a != b);
178
179 BOOST_CHECK_EQUAL(r1 == r2 * z, a == b);
180 BOOST_CHECK_EQUAL(r1 != r2 * z, a != b);
181
182 BOOST_CHECK_EQUAL(r1 * z == r2 * z, a == b);
183 BOOST_CHECK_EQUAL(r1 * z != r2 * z, a != b);
184
185 BOOST_CHECK_EQUAL(r1 * z == b, a == b);
186 BOOST_CHECK_EQUAL(r1 * z != b, a != b);
187
188 BOOST_CHECK_EQUAL(a == r2 * z, a == b);
189 BOOST_CHECK_EQUAL(a != r2 * z, a != b);
190
191 if (r1 == r2)
192 {
193 BOOST_CHECK_EQUAL(normalize_compare_result(r1.compare(r2)), 0);
194 BOOST_CHECK_EQUAL(normalize_compare_result(r2.compare(r1)), 0);
195 BOOST_CHECK_EQUAL(normalize_compare_result(r1.compare(b)), 0);
196 BOOST_CHECK_EQUAL(normalize_compare_result(r2.compare(a)), 0);
197 }
198 else
199 {
200 BOOST_CHECK_NE(normalize_compare_result(r1.compare(r2)), 0);
201 BOOST_CHECK_NE(normalize_compare_result(r2.compare(r1)), 0);
202 BOOST_CHECK_NE(normalize_compare_result(r1.compare(b)), 0);
203 BOOST_CHECK_NE(normalize_compare_result(r2.compare(a)), 0);
204 }
205 }
206
207 template <class Real, class Exp>
test_conditional(Real v,Exp e)208 void test_conditional(Real v, Exp e)
209 {
210 //
211 // Verify that Exp is usable in Boolean contexts, and has the same value as v:
212 //
213 if (e)
214 {
215 BOOST_CHECK(v);
216 }
217 else
218 {
219 BOOST_CHECK(!v);
220 }
221 if (!e)
222 {
223 BOOST_CHECK(!v);
224 }
225 else
226 {
227 BOOST_CHECK(v);
228 }
229 }
230
231 template <class Real>
test_complement(Real a,Real b,Real c,const boost::mpl::true_ &)232 void test_complement(Real a, Real b, Real c, const boost::mpl::true_&)
233 {
234 int i = 1020304;
235 int j = 56789123;
236 int sign_mask = ~0;
237 if (std::numeric_limits<Real>::is_signed)
238 {
239 BOOST_CHECK_EQUAL(~a, (~i & sign_mask));
240 c = a & ~b;
241 BOOST_CHECK_EQUAL(c, (i & (~j & sign_mask)));
242 c = ~(a | b);
243 BOOST_CHECK_EQUAL(c, (~(i | j) & sign_mask));
244 }
245 else
246 {
247 BOOST_CHECK_EQUAL((~a & a), 0);
248 }
249 }
250
251 template <class Real>
test_complement(Real,Real,Real,const boost::mpl::false_ &)252 void test_complement(Real, Real, Real, const boost::mpl::false_&)
253 {
254 }
255
256 template <class Real, class T>
test_integer_ops(const T &)257 void test_integer_ops(const T&) {}
258
259 template <class Real>
test_rational(const boost::mpl::true_ &)260 void test_rational(const boost::mpl::true_&)
261 {
262 Real a(2);
263 a /= 3;
264 BOOST_CHECK_EQUAL(numerator(a), 2);
265 BOOST_CHECK_EQUAL(denominator(a), 3);
266 Real b(4);
267 b /= 6;
268 BOOST_CHECK_EQUAL(a, b);
269
270 //
271 // Check IO code:
272 //
273 std::stringstream ss;
274 ss << a;
275 ss >> b;
276 BOOST_CHECK_EQUAL(a, b);
277 }
278
279 template <class Real>
test_rational(const boost::mpl::false_ &)280 void test_rational(const boost::mpl::false_&)
281 {
282 Real a(2);
283 a /= 3;
284 BOOST_CHECK_EQUAL(numerator(a), 2);
285 BOOST_CHECK_EQUAL(denominator(a), 3);
286 Real b(4);
287 b /= 6;
288 BOOST_CHECK_EQUAL(a, b);
289
290 #ifndef BOOST_NO_EXCEPTIONS
291 BOOST_CHECK_THROW(Real(a / 0), std::overflow_error);
292 BOOST_CHECK_THROW(Real("3.14"), std::runtime_error);
293 #endif
294 b = Real("2/3");
295 BOOST_CHECK_EQUAL(a, b);
296 //
297 // Check IO code:
298 //
299 std::stringstream ss;
300 ss << a;
301 ss >> b;
302 BOOST_CHECK_EQUAL(a, b);
303 }
304
305 template <class Real>
test_integer_ops(const boost::mpl::int_<boost::multiprecision::number_kind_rational> &)306 void test_integer_ops(const boost::mpl::int_<boost::multiprecision::number_kind_rational>&)
307 {
308 test_rational<Real>(is_boost_rational<Real>());
309 }
310
311 template <class Real>
test_signed_integer_ops(const boost::mpl::true_ &)312 void test_signed_integer_ops(const boost::mpl::true_&)
313 {
314 Real a(20);
315 Real b(7);
316 Real c(5);
317 BOOST_CHECK_EQUAL(-a % c, 0);
318 BOOST_CHECK_EQUAL(-a % b, -20 % 7);
319 BOOST_CHECK_EQUAL(-a % -b, -20 % -7);
320 BOOST_CHECK_EQUAL(a % -b, 20 % -7);
321 BOOST_CHECK_EQUAL(-a % 7, -20 % 7);
322 BOOST_CHECK_EQUAL(-a % -7, -20 % -7);
323 BOOST_CHECK_EQUAL(a % -7, 20 % -7);
324 BOOST_CHECK_EQUAL(-a % 7u, -20 % 7);
325 BOOST_CHECK_EQUAL(-a % a, 0);
326 BOOST_CHECK_EQUAL(-a % 5, 0);
327 BOOST_CHECK_EQUAL(-a % -5, 0);
328 BOOST_CHECK_EQUAL(a % -5, 0);
329
330 b = -b;
331 BOOST_CHECK_EQUAL(a % b, 20 % -7);
332 a = -a;
333 BOOST_CHECK_EQUAL(a % b, -20 % -7);
334 BOOST_CHECK_EQUAL(a % -7, -20 % -7);
335 b = 7;
336 BOOST_CHECK_EQUAL(a % b, -20 % 7);
337 BOOST_CHECK_EQUAL(a % 7, -20 % 7);
338 BOOST_CHECK_EQUAL(a % 7u, -20 % 7);
339
340 a = 20;
341 a %= b;
342 BOOST_CHECK_EQUAL(a, 20 % 7);
343 a = -20;
344 a %= b;
345 BOOST_CHECK_EQUAL(a, -20 % 7);
346 a = 20;
347 a %= -b;
348 BOOST_CHECK_EQUAL(a, 20 % -7);
349 a = -20;
350 a %= -b;
351 BOOST_CHECK_EQUAL(a, -20 % -7);
352 a = 5;
353 a %= b - a;
354 BOOST_CHECK_EQUAL(a, 5 % (7 - 5));
355 a = -20;
356 a %= 7;
357 BOOST_CHECK_EQUAL(a, -20 % 7);
358 a = 20;
359 a %= -7;
360 BOOST_CHECK_EQUAL(a, 20 % -7);
361 a = -20;
362 a %= -7;
363 BOOST_CHECK_EQUAL(a, -20 % -7);
364 #ifndef BOOST_NO_LONG_LONG
365 a = -20;
366 a %= 7uLL;
367 BOOST_CHECK_EQUAL(a, -20 % 7);
368 a = 20;
369 a %= -7LL;
370 BOOST_CHECK_EQUAL(a, 20 % -7);
371 a = -20;
372 a %= -7LL;
373 BOOST_CHECK_EQUAL(a, -20 % -7);
374 #endif
375 a = 400;
376 b = 45;
377 BOOST_CHECK_EQUAL(gcd(a, -45), boost::integer::gcd(400, 45));
378 BOOST_CHECK_EQUAL(lcm(a, -45), boost::integer::lcm(400, 45));
379 BOOST_CHECK_EQUAL(gcd(-400, b), boost::integer::gcd(400, 45));
380 BOOST_CHECK_EQUAL(lcm(-400, b), boost::integer::lcm(400, 45));
381 a = -20;
382 BOOST_CHECK_EQUAL(abs(a), 20);
383 BOOST_CHECK_EQUAL(abs(-a), 20);
384 BOOST_CHECK_EQUAL(abs(+a), 20);
385 a = 20;
386 BOOST_CHECK_EQUAL(abs(a), 20);
387 BOOST_CHECK_EQUAL(abs(-a), 20);
388 BOOST_CHECK_EQUAL(abs(+a), 20);
389 a = -400;
390 b = 45;
391 BOOST_CHECK_EQUAL(gcd(a, b), boost::integer::gcd(-400, 45));
392 BOOST_CHECK_EQUAL(lcm(a, b), boost::integer::lcm(-400, 45));
393 BOOST_CHECK_EQUAL(gcd(a, 45), boost::integer::gcd(-400, 45));
394 BOOST_CHECK_EQUAL(lcm(a, 45), boost::integer::lcm(-400, 45));
395 BOOST_CHECK_EQUAL(gcd(-400, b), boost::integer::gcd(-400, 45));
396 BOOST_CHECK_EQUAL(lcm(-400, b), boost::integer::lcm(-400, 45));
397 Real r;
398 divide_qr(a, b, c, r);
399 BOOST_CHECK_EQUAL(c, a / b);
400 BOOST_CHECK_EQUAL(r, a % b);
401 BOOST_CHECK_EQUAL(integer_modulus(a, 57), abs(a % 57));
402 b = -57;
403 divide_qr(a, b, c, r);
404 BOOST_CHECK_EQUAL(c, a / b);
405 BOOST_CHECK_EQUAL(r, a % b);
406 BOOST_CHECK_EQUAL(integer_modulus(a, -57), abs(a % -57));
407 a = 458;
408 divide_qr(a, b, c, r);
409 BOOST_CHECK_EQUAL(c, a / b);
410 BOOST_CHECK_EQUAL(r, a % b);
411 BOOST_CHECK_EQUAL(integer_modulus(a, -57), abs(a % -57));
412 #ifndef TEST_CHECKED_INT
413 if (is_checked_cpp_int<Real>::value)
414 {
415 a = -1;
416 #ifndef BOOST_NO_EXCEPTIONS
417 BOOST_CHECK_THROW(a << 2, std::range_error);
418 BOOST_CHECK_THROW(a >> 2, std::range_error);
419 BOOST_CHECK_THROW(a <<= 2, std::range_error);
420 BOOST_CHECK_THROW(a >>= 2, std::range_error);
421 #endif
422 }
423 else
424 {
425 a = -1;
426 BOOST_CHECK_EQUAL(a << 10, -1024);
427 a = -23;
428 BOOST_CHECK_EQUAL(a << 10, -23552);
429 a = -23456;
430 BOOST_CHECK_EQUAL(a >> 10, -23);
431 a = -3;
432 BOOST_CHECK_EQUAL(a >> 10, -1);
433 }
434 #endif
435 }
436 template <class Real>
test_signed_integer_ops(const boost::mpl::false_ &)437 void test_signed_integer_ops(const boost::mpl::false_&)
438 {
439 }
440
441 template <class Real>
negate_if_signed(Real r,const boost::mpl::bool_<true> &)442 inline Real negate_if_signed(Real r, const boost::mpl::bool_<true>&)
443 {
444 return -r;
445 }
446 template <class Real>
negate_if_signed(Real r,const boost::mpl::bool_<false> &)447 inline Real negate_if_signed(Real r, const boost::mpl::bool_<false>&)
448 {
449 return r;
450 }
451
452 template <class Real, class Int>
test_integer_overflow()453 void test_integer_overflow()
454 {
455 if (std::numeric_limits<Real>::digits > std::numeric_limits<Int>::digits)
456 {
457 Real m((std::numeric_limits<Int>::max)());
458 Int r;
459 ++m;
460 if (is_checked_cpp_int<Real>::value)
461 {
462 BOOST_CHECK_THROW(m.template convert_to<Int>(), std::overflow_error);
463 }
464 else if (boost::is_signed<Int>::value)
465 {
466 r = m.template convert_to<Int>();
467 BOOST_CHECK_EQUAL(r, (std::numeric_limits<Int>::max)());
468 }
469 else
470 {
471 r = m.template convert_to<Int>();
472 BOOST_CHECK_EQUAL(r, 0);
473 }
474 // Again with much larger value:
475 m = 1u;
476 m <<= (std::min)(std::numeric_limits<Real>::digits - 1, 1000);
477 if (is_checked_cpp_int<Real>::value)
478 {
479 BOOST_CHECK_THROW(m.template convert_to<Int>(), std::overflow_error);
480 }
481 else if (boost::is_signed<Int>::value)
482 {
483 r = m.template convert_to<Int>();
484 BOOST_CHECK_EQUAL(r, (std::numeric_limits<Int>::max)());
485 }
486 else
487 {
488 r = m.template convert_to<Int>();
489 BOOST_CHECK_EQUAL(r, 0);
490 }
491
492 if (std::numeric_limits<Real>::is_signed && (boost::is_signed<Int>::value))
493 {
494 m = (std::numeric_limits<Int>::min)();
495 --m;
496 if (is_checked_cpp_int<Real>::value)
497 {
498 BOOST_CHECK_THROW(m.template convert_to<Int>(), std::overflow_error);
499 }
500 else
501 {
502 r = m.template convert_to<Int>();
503 BOOST_CHECK_EQUAL(r, (std::numeric_limits<Int>::min)());
504 }
505 // Again with much larger value:
506 m = 2u;
507 m = pow(m, (std::min)(std::numeric_limits<Real>::digits - 1, 1000));
508 ++m;
509 m = negate_if_signed(m, boost::mpl::bool_<std::numeric_limits<Real>::is_signed>());
510 if (is_checked_cpp_int<Real>::value)
511 {
512 BOOST_CHECK_THROW(m.template convert_to<Int>(), std::overflow_error);
513 }
514 else
515 {
516 r = m.template convert_to<Int>();
517 BOOST_CHECK_EQUAL(r, (std::numeric_limits<Int>::min)());
518 }
519 }
520 else if (std::numeric_limits<Real>::is_signed && !boost::is_signed<Int>::value)
521 {
522 // signed to unsigned converison with overflow, it's really not clear what should happen here!
523 m = (std::numeric_limits<Int>::max)();
524 ++m;
525 m = negate_if_signed(m, boost::mpl::bool_<std::numeric_limits<Real>::is_signed>());
526 BOOST_CHECK_THROW(m.template convert_to<Int>(), std::range_error);
527 // Again with much larger value:
528 m = 2u;
529 m = pow(m, (std::min)(std::numeric_limits<Real>::digits - 1, 1000));
530 m = negate_if_signed(m, boost::mpl::bool_<std::numeric_limits<Real>::is_signed>());
531 BOOST_CHECK_THROW(m.template convert_to<Int>(), std::range_error);
532 }
533 }
534 }
535
536 template <class Real, class Int>
test_integer_round_trip()537 void test_integer_round_trip()
538 {
539 if (std::numeric_limits<Real>::digits >= std::numeric_limits<Int>::digits)
540 {
541 Real m((std::numeric_limits<Int>::max)());
542 Int r = m.template convert_to<Int>();
543 BOOST_CHECK_EQUAL(m, r);
544 if (std::numeric_limits<Real>::is_signed && (std::numeric_limits<Real>::digits > std::numeric_limits<Int>::digits))
545 {
546 m = (std::numeric_limits<Int>::min)();
547 r = m.template convert_to<Int>();
548 BOOST_CHECK_EQUAL(m, r);
549 }
550 }
551 test_integer_overflow<Real, Int>();
552 }
553
554 template <class Real>
test_integer_ops(const boost::mpl::int_<boost::multiprecision::number_kind_integer> &)555 void test_integer_ops(const boost::mpl::int_<boost::multiprecision::number_kind_integer>&)
556 {
557 test_signed_integer_ops<Real>(boost::mpl::bool_<std::numeric_limits<Real>::is_signed>());
558
559 Real a(20);
560 Real b(7);
561 Real c(5);
562 BOOST_CHECK_EQUAL(a % b, 20 % 7);
563 BOOST_CHECK_EQUAL(a % 7, 20 % 7);
564 BOOST_CHECK_EQUAL(a % 7u, 20 % 7);
565 BOOST_CHECK_EQUAL(a % a, 0);
566 BOOST_CHECK_EQUAL(a % c, 0);
567 BOOST_CHECK_EQUAL(a % 5, 0);
568 a = a % (b + 0);
569 BOOST_CHECK_EQUAL(a, 20 % 7);
570 a = 20;
571 c = (a + 2) % (a - 1);
572 BOOST_CHECK_EQUAL(c, 22 % 19);
573 c = 5;
574 a = b % (a - 15);
575 BOOST_CHECK_EQUAL(a, 7 % 5);
576 a = 20;
577
578 a = 20;
579 a %= 7;
580 BOOST_CHECK_EQUAL(a, 20 % 7);
581 #ifndef BOOST_NO_LONG_LONG
582 a = 20;
583 a %= 7uLL;
584 BOOST_CHECK_EQUAL(a, 20 % 7);
585 #endif
586 a = 20;
587 ++a;
588 BOOST_CHECK_EQUAL(a, 21);
589 --a;
590 BOOST_CHECK_EQUAL(a, 20);
591 BOOST_CHECK_EQUAL(a++, 20);
592 BOOST_CHECK_EQUAL(a, 21);
593 BOOST_CHECK_EQUAL(a--, 21);
594 BOOST_CHECK_EQUAL(a, 20);
595 a = 2000;
596 a <<= 20;
597 BOOST_CHECK_EQUAL(a, 2000L << 20);
598 a >>= 20;
599 BOOST_CHECK_EQUAL(a, 2000);
600 a <<= 20u;
601 BOOST_CHECK_EQUAL(a, 2000L << 20);
602 a >>= 20u;
603 BOOST_CHECK_EQUAL(a, 2000);
604 #ifndef BOOST_NO_EXCEPTIONS
605 BOOST_CHECK_THROW(a <<= -20, std::out_of_range);
606 BOOST_CHECK_THROW(a >>= -20, std::out_of_range);
607 BOOST_CHECK_THROW(Real(a << -20), std::out_of_range);
608 BOOST_CHECK_THROW(Real(a >> -20), std::out_of_range);
609 #endif
610 #ifndef BOOST_NO_LONG_LONG
611 if (sizeof(long long) > sizeof(std::size_t))
612 {
613 // extreme values should trigger an exception:
614 #ifndef BOOST_NO_EXCEPTIONS
615 BOOST_CHECK_THROW(a >>= (1uLL << (sizeof(long long) * CHAR_BIT - 2)), std::out_of_range);
616 BOOST_CHECK_THROW(a <<= (1uLL << (sizeof(long long) * CHAR_BIT - 2)), std::out_of_range);
617 BOOST_CHECK_THROW(a >>= -(1LL << (sizeof(long long) * CHAR_BIT - 2)), std::out_of_range);
618 BOOST_CHECK_THROW(a <<= -(1LL << (sizeof(long long) * CHAR_BIT - 2)), std::out_of_range);
619 BOOST_CHECK_THROW(a >>= (1LL << (sizeof(long long) * CHAR_BIT - 2)), std::out_of_range);
620 BOOST_CHECK_THROW(a <<= (1LL << (sizeof(long long) * CHAR_BIT - 2)), std::out_of_range);
621 #endif
622 // Unless they fit within range:
623 a = 2000L;
624 a <<= 20uLL;
625 BOOST_CHECK_EQUAL(a, (2000L << 20));
626 a = 2000;
627 a <<= 20LL;
628 BOOST_CHECK_EQUAL(a, (2000L << 20));
629
630 #ifndef BOOST_NO_EXCEPTIONS
631 BOOST_CHECK_THROW(Real(a >> (1uLL << (sizeof(long long) * CHAR_BIT - 2))), std::out_of_range);
632 BOOST_CHECK_THROW(Real(a <<= (1uLL << (sizeof(long long) * CHAR_BIT - 2))), std::out_of_range);
633 BOOST_CHECK_THROW(Real(a >>= -(1LL << (sizeof(long long) * CHAR_BIT - 2))), std::out_of_range);
634 BOOST_CHECK_THROW(Real(a <<= -(1LL << (sizeof(long long) * CHAR_BIT - 2))), std::out_of_range);
635 BOOST_CHECK_THROW(Real(a >>= (1LL << (sizeof(long long) * CHAR_BIT - 2))), std::out_of_range);
636 BOOST_CHECK_THROW(Real(a <<= (1LL << (sizeof(long long) * CHAR_BIT - 2))), std::out_of_range);
637 #endif
638 // Unless they fit within range:
639 a = 2000L;
640 BOOST_CHECK_EQUAL(Real(a << 20uLL), (2000L << 20));
641 a = 2000;
642 BOOST_CHECK_EQUAL(Real(a << 20LL), (2000L << 20));
643 }
644 #endif
645 a = 20;
646 b = a << 20;
647 BOOST_CHECK_EQUAL(b, (20 << 20));
648 b = a >> 2;
649 BOOST_CHECK_EQUAL(b, (20 >> 2));
650 b = (a + 2) << 10;
651 BOOST_CHECK_EQUAL(b, (22 << 10));
652 b = (a + 3) >> 3;
653 BOOST_CHECK_EQUAL(b, (23 >> 3));
654 //
655 // Bit fiddling:
656 //
657 int i = 1020304;
658 int j = 56789123;
659 int k = 4523187;
660 a = i;
661 b = j;
662 c = a;
663 c &= b;
664 BOOST_CHECK_EQUAL(c, (i & j));
665 c = a;
666 c &= j;
667 BOOST_CHECK_EQUAL(c, (i & j));
668 c = a;
669 c &= a + b;
670 BOOST_CHECK_EQUAL(c, (i & (i + j)));
671 BOOST_CHECK_EQUAL((a & b), (i & j));
672 c = k;
673 a = a & (b + k);
674 BOOST_CHECK_EQUAL(a, (i & (j + k)));
675 a = i;
676 a = (b + k) & a;
677 BOOST_CHECK_EQUAL(a, (i & (j + k)));
678 a = i;
679 c = a & b & k;
680 BOOST_CHECK_EQUAL(c, (i & j & k));
681 c = a;
682 c &= (c + b);
683 BOOST_CHECK_EQUAL(c, (i & (i + j)));
684 c = a & (b | 1);
685 BOOST_CHECK_EQUAL(c, (i & (j | 1)));
686
687 test_complement<Real>(a, b, c, typename is_twos_complement_integer<Real>::type());
688
689 a = i;
690 b = j;
691 c = a;
692 c |= b;
693 BOOST_CHECK_EQUAL(c, (i | j));
694 c = a;
695 c |= j;
696 BOOST_CHECK_EQUAL(c, (i | j));
697 c = a;
698 c |= a + b;
699 BOOST_CHECK_EQUAL(c, (i | (i + j)));
700 BOOST_CHECK_EQUAL((a | b), (i | j));
701 c = k;
702 a = a | (b + k);
703 BOOST_CHECK_EQUAL(a, (i | (j + k)));
704 a = i;
705 a = (b + k) | a;
706 BOOST_CHECK_EQUAL(a, (i | (j + k)));
707 a = i;
708 c = a | b | k;
709 BOOST_CHECK_EQUAL(c, (i | j | k));
710 c = a;
711 c |= (c + b);
712 BOOST_CHECK_EQUAL(c, (i | (i + j)));
713 c = a | (b | 1);
714 BOOST_CHECK_EQUAL(c, (i | (j | 1)));
715
716 a = i;
717 b = j;
718 c = a;
719 c ^= b;
720 BOOST_CHECK_EQUAL(c, (i ^ j));
721 c = a;
722 c ^= j;
723 BOOST_CHECK_EQUAL(c, (i ^ j));
724 c = a;
725 c ^= a + b;
726 BOOST_CHECK_EQUAL(c, (i ^ (i + j)));
727 BOOST_CHECK_EQUAL((a ^ b), (i ^ j));
728 c = k;
729 a = a ^ (b + k);
730 BOOST_CHECK_EQUAL(a, (i ^ (j + k)));
731 a = i;
732 a = (b + k) ^ a;
733 BOOST_CHECK_EQUAL(a, (i ^ (j + k)));
734 a = i;
735 c = a ^ b ^ k;
736 BOOST_CHECK_EQUAL(c, (i ^ j ^ k));
737 c = a;
738 c ^= (c + b);
739 BOOST_CHECK_EQUAL(c, (i ^ (i + j)));
740 c = a ^ (b | 1);
741 BOOST_CHECK_EQUAL(c, (i ^ (j | 1)));
742
743 a = i;
744 b = j;
745 c = k;
746 //
747 // Non-member functions:
748 //
749 a = 400;
750 b = 45;
751 BOOST_CHECK_EQUAL(gcd(a, b), boost::integer::gcd(400, 45));
752 BOOST_CHECK_EQUAL(lcm(a, b), boost::integer::lcm(400, 45));
753 BOOST_CHECK_EQUAL(gcd(a, 45), boost::integer::gcd(400, 45));
754 BOOST_CHECK_EQUAL(lcm(a, 45), boost::integer::lcm(400, 45));
755 BOOST_CHECK_EQUAL(gcd(a, 45u), boost::integer::gcd(400, 45));
756 BOOST_CHECK_EQUAL(lcm(a, 45u), boost::integer::lcm(400, 45));
757 BOOST_CHECK_EQUAL(gcd(400, b), boost::integer::gcd(400, 45));
758 BOOST_CHECK_EQUAL(lcm(400, b), boost::integer::lcm(400, 45));
759 BOOST_CHECK_EQUAL(gcd(400u, b), boost::integer::gcd(400, 45));
760 BOOST_CHECK_EQUAL(lcm(400u, b), boost::integer::lcm(400, 45));
761
762 //
763 // Conditionals involving 2 arg functions:
764 //
765 test_conditional(Real(gcd(a, b)), gcd(a, b));
766
767 Real r;
768 divide_qr(a, b, c, r);
769 BOOST_CHECK_EQUAL(c, a / b);
770 BOOST_CHECK_EQUAL(r, a % b);
771 divide_qr(a + 0, b, c, r);
772 BOOST_CHECK_EQUAL(c, a / b);
773 BOOST_CHECK_EQUAL(r, a % b);
774 divide_qr(a, b + 0, c, r);
775 BOOST_CHECK_EQUAL(c, a / b);
776 BOOST_CHECK_EQUAL(r, a % b);
777 divide_qr(a + 0, b + 0, c, r);
778 BOOST_CHECK_EQUAL(c, a / b);
779 BOOST_CHECK_EQUAL(r, a % b);
780 BOOST_CHECK_EQUAL(integer_modulus(a, 57), a % 57);
781 for (i = 0; i < 20; ++i)
782 {
783 if (std::numeric_limits<Real>::is_specialized && (!std::numeric_limits<Real>::is_bounded || ((int)i * 17 < std::numeric_limits<Real>::digits)))
784 {
785 BOOST_CHECK_EQUAL(lsb(Real(1) << (i * 17)), static_cast<unsigned>(i * 17));
786 BOOST_CHECK_EQUAL(msb(Real(1) << (i * 17)), static_cast<unsigned>(i * 17));
787 BOOST_CHECK(bit_test(Real(1) << (i * 17), i * 17));
788 BOOST_CHECK(!bit_test(Real(1) << (i * 17), i * 17 + 1));
789 if (i)
790 {
791 BOOST_CHECK(!bit_test(Real(1) << (i * 17), i * 17 - 1));
792 }
793 Real zero(0);
794 BOOST_CHECK(bit_test(bit_set(zero, i * 17), i * 17));
795 zero = 0;
796 BOOST_CHECK_EQUAL(bit_flip(zero, i * 17), Real(1) << i * 17);
797 zero = Real(1) << i * 17;
798 BOOST_CHECK_EQUAL(bit_flip(zero, i * 17), 0);
799 zero = Real(1) << i * 17;
800 BOOST_CHECK_EQUAL(bit_unset(zero, i * 17), 0);
801 }
802 }
803 //
804 // pow, powm:
805 //
806 BOOST_CHECK_EQUAL(pow(Real(3), 4u), 81);
807 BOOST_CHECK_EQUAL(pow(Real(3) + Real(0), 4u), 81);
808 BOOST_CHECK_EQUAL(powm(Real(3), Real(4), Real(13)), 81 % 13);
809 BOOST_CHECK_EQUAL(powm(Real(3), Real(4), 13), 81 % 13);
810 BOOST_CHECK_EQUAL(powm(Real(3), Real(4), Real(13) + 0), 81 % 13);
811 BOOST_CHECK_EQUAL(powm(Real(3), Real(4) + 0, Real(13)), 81 % 13);
812 BOOST_CHECK_EQUAL(powm(Real(3), Real(4) + 0, 13), 81 % 13);
813 BOOST_CHECK_EQUAL(powm(Real(3), Real(4) + 0, Real(13) + 0), 81 % 13);
814 BOOST_CHECK_EQUAL(powm(Real(3), 4 + 0, Real(13)), 81 % 13);
815 BOOST_CHECK_EQUAL(powm(Real(3), 4 + 0, 13), 81 % 13);
816 BOOST_CHECK_EQUAL(powm(Real(3), 4 + 0, Real(13) + 0), 81 % 13);
817 BOOST_CHECK_EQUAL(powm(Real(3) + 0, Real(4), Real(13)), 81 % 13);
818 BOOST_CHECK_EQUAL(powm(Real(3) + 0, Real(4), 13), 81 % 13);
819 BOOST_CHECK_EQUAL(powm(Real(3) + 0, Real(4), Real(13) + 0), 81 % 13);
820 BOOST_CHECK_EQUAL(powm(Real(3) + 0, Real(4) + 0, Real(13)), 81 % 13);
821 BOOST_CHECK_EQUAL(powm(Real(3) + 0, Real(4) + 0, 13), 81 % 13);
822 BOOST_CHECK_EQUAL(powm(Real(3) + 0, Real(4) + 0, Real(13) + 0), 81 % 13);
823 BOOST_CHECK_EQUAL(powm(Real(3) + 0, 4 + 0, Real(13)), 81 % 13);
824 BOOST_CHECK_EQUAL(powm(Real(3) + 0, 4 + 0, 13), 81 % 13);
825 BOOST_CHECK_EQUAL(powm(Real(3) + 0, 4 + 0, Real(13) + 0), 81 % 13);
826 //
827 // Conditionals involving 3 arg functions:
828 //
829 test_conditional(Real(powm(Real(3), Real(4), Real(13))), powm(Real(3), Real(4), Real(13)));
830
831 #ifndef BOOST_NO_EXCEPTIONS
832 //
833 // Things that are expected errors:
834 //
835 BOOST_CHECK_THROW(Real("3.14"), std::runtime_error);
836 BOOST_CHECK_THROW(Real("3L"), std::runtime_error);
837 BOOST_CHECK_THROW(Real(Real(20) / 0u), std::overflow_error);
838 #endif
839 //
840 // Extra tests added for full coverage:
841 //
842 a = 20;
843 b = 7;
844 c = 20 % b;
845 BOOST_CHECK_EQUAL(c, (20 % 7));
846 c = 20 % (b + 0);
847 BOOST_CHECK_EQUAL(c, (20 % 7));
848 c = a & 10;
849 BOOST_CHECK_EQUAL(c, (20 & 10));
850 c = 10 & a;
851 BOOST_CHECK_EQUAL(c, (20 & 10));
852 c = (a + 0) & (b + 0);
853 BOOST_CHECK_EQUAL(c, (20 & 7));
854 c = 10 & (a + 0);
855 BOOST_CHECK_EQUAL(c, (20 & 10));
856 c = 10 | a;
857 BOOST_CHECK_EQUAL(c, (20 | 10));
858 c = (a + 0) | (b + 0);
859 BOOST_CHECK(c == (20 | 7))
860 c = 20 | (b + 0);
861 BOOST_CHECK_EQUAL(c, (20 | 7));
862 c = a ^ 7;
863 BOOST_CHECK_EQUAL(c, (20 ^ 7));
864 c = 20 ^ b;
865 BOOST_CHECK_EQUAL(c, (20 ^ 7));
866 c = (a + 0) ^ (b + 0);
867 BOOST_CHECK_EQUAL(c, (20 ^ 7));
868 c = 20 ^ (b + 0);
869 BOOST_CHECK_EQUAL(c, (20 ^ 7));
870 //
871 // RValue ref tests:
872 //
873 c = Real(20) % b;
874 BOOST_CHECK_EQUAL(c, (20 % 7));
875 c = a % Real(7);
876 BOOST_CHECK_EQUAL(c, (20 % 7));
877 c = Real(20) % Real(7);
878 BOOST_CHECK_EQUAL(c, (20 % 7));
879 c = Real(20) % 7;
880 BOOST_CHECK_EQUAL(c, (20 % 7));
881 c = 20 % Real(7);
882 BOOST_CHECK_EQUAL(c, (20 % 7));
883 c = Real(20) % (b * 1);
884 BOOST_CHECK_EQUAL(c, (20 % 7));
885 c = (a * 1 + 0) % Real(7);
886 BOOST_CHECK_EQUAL(c, (20 % 7));
887 c = Real(20) >> 2;
888 BOOST_CHECK_EQUAL(c, (20 >> 2));
889 c = Real(20) & b;
890 BOOST_CHECK_EQUAL(c, (20 & 7));
891 c = a & Real(7);
892 BOOST_CHECK_EQUAL(c, (20 & 7));
893 c = Real(20) & Real(7);
894 BOOST_CHECK_EQUAL(c, (20 & 7));
895 c = Real(20) & 7;
896 BOOST_CHECK_EQUAL(c, (20 & 7));
897 c = 20 & Real(7);
898 BOOST_CHECK_EQUAL(c, (20 & 7));
899 c = Real(20) & (b * 1 + 0);
900 BOOST_CHECK_EQUAL(c, (20 & 7));
901 c = (a * 1 + 0) & Real(7);
902 BOOST_CHECK_EQUAL(c, (20 & 7));
903 c = Real(20) | b;
904 BOOST_CHECK_EQUAL(c, (20 | 7));
905 c = a | Real(7);
906 BOOST_CHECK_EQUAL(c, (20 | 7));
907 c = Real(20) | Real(7);
908 BOOST_CHECK_EQUAL(c, (20 | 7));
909 c = Real(20) | 7;
910 BOOST_CHECK_EQUAL(c, (20 | 7));
911 c = 20 | Real(7);
912 BOOST_CHECK_EQUAL(c, (20 | 7));
913 c = Real(20) | (b * 1 + 0);
914 BOOST_CHECK_EQUAL(c, (20 | 7));
915 c = (a * 1 + 0) | Real(7);
916 BOOST_CHECK_EQUAL(c, (20 | 7));
917 c = Real(20) ^ b;
918 BOOST_CHECK_EQUAL(c, (20 ^ 7));
919 c = a ^ Real(7);
920 BOOST_CHECK_EQUAL(c, (20 ^ 7));
921 c = Real(20) ^ Real(7);
922 BOOST_CHECK_EQUAL(c, (20 ^ 7));
923 c = Real(20) ^ 7;
924 BOOST_CHECK_EQUAL(c, (20 ^ 7));
925 c = 20 ^ Real(7);
926 BOOST_CHECK_EQUAL(c, (20 ^ 7));
927 c = Real(20) ^ (b * 1 + 0);
928 BOOST_CHECK_EQUAL(c, (20 ^ 7));
929 c = (a * 1 + 0) ^ Real(7);
930 BOOST_CHECK_EQUAL(c, (20 ^ 7));
931
932 //
933 // Round tripping of built in integers:
934 //
935 test_integer_round_trip<Real, short>();
936 test_integer_round_trip<Real, unsigned short>();
937 test_integer_round_trip<Real, int>();
938 test_integer_round_trip<Real, unsigned int>();
939 test_integer_round_trip<Real, long>();
940 test_integer_round_trip<Real, unsigned long>();
941 #ifndef BOOST_NO_CXX11_LONG_LONG
942 test_integer_round_trip<Real, long long>();
943 test_integer_round_trip<Real, unsigned long long>();
944 #endif
945 }
946
947 template <class Real, class T>
test_float_funcs(const T &)948 void test_float_funcs(const T&) {}
949
950 template <class Real>
test_float_funcs(const boost::mpl::true_ &)951 void test_float_funcs(const boost::mpl::true_&)
952 {
953 if (boost::multiprecision::is_interval_number<Real>::value)
954 return;
955 //
956 // Test variable reuse in function calls, see https://svn.boost.org/trac/boost/ticket/8326
957 //
958 Real a(2), b(10), c, d;
959 a = pow(a, b);
960 BOOST_CHECK_EQUAL(a, 1024);
961 a = 2;
962 b = pow(a, b);
963 BOOST_CHECK_EQUAL(b, 1024);
964 b = 10;
965 a = pow(a, 10);
966 BOOST_CHECK_EQUAL(a, 1024);
967 a = -2;
968 a = abs(a);
969 BOOST_CHECK_EQUAL(a, 2);
970 a = -2;
971 a = fabs(a);
972 BOOST_CHECK_EQUAL(a, 2);
973 a = 2.5;
974 a = floor(a);
975 BOOST_CHECK_EQUAL(a, 2);
976 a = 2.5;
977 a = ceil(a);
978 BOOST_CHECK_EQUAL(a, 3);
979 a = 2.5;
980 a = trunc(a);
981 BOOST_CHECK_EQUAL(a, 2);
982 a = 2.25;
983 a = round(a);
984 BOOST_CHECK_EQUAL(a, 2);
985 a = 2;
986 a = ldexp(a, 1);
987 BOOST_CHECK_EQUAL(a, 4);
988 int i;
989 a = frexp(a, &i);
990 BOOST_CHECK_EQUAL(a, 0.5);
991
992 Real tol = std::numeric_limits<Real>::epsilon() * 3;
993 a = 4;
994 a = sqrt(a);
995 BOOST_CHECK_CLOSE_FRACTION(a, 2, tol);
996 a = 3;
997 a = exp(a);
998 BOOST_CHECK_CLOSE_FRACTION(a, Real(exp(Real(3))), tol);
999 a = 3;
1000 a = log(a);
1001 BOOST_CHECK_CLOSE_FRACTION(a, Real(log(Real(3))), tol);
1002 a = 3;
1003 a = log10(a);
1004 BOOST_CHECK_CLOSE_FRACTION(a, Real(log10(Real(3))), tol);
1005
1006 a = 0.5;
1007 a = sin(a);
1008 BOOST_CHECK_CLOSE_FRACTION(a, Real(sin(Real(0.5))), tol);
1009 a = 0.5;
1010 a = cos(a);
1011 BOOST_CHECK_CLOSE_FRACTION(a, Real(cos(Real(0.5))), tol);
1012 a = 0.5;
1013 a = tan(a);
1014 BOOST_CHECK_CLOSE_FRACTION(a, Real(tan(Real(0.5))), tol);
1015 a = 0.5;
1016 a = asin(a);
1017 BOOST_CHECK_CLOSE_FRACTION(a, Real(asin(Real(0.5))), tol);
1018 a = 0.5;
1019 a = acos(a);
1020 BOOST_CHECK_CLOSE_FRACTION(a, Real(acos(Real(0.5))), tol);
1021 a = 0.5;
1022 a = atan(a);
1023 BOOST_CHECK_CLOSE_FRACTION(a, Real(atan(Real(0.5))), tol);
1024 a = 0.5;
1025 a = sinh(a);
1026 BOOST_CHECK_CLOSE_FRACTION(a, Real(sinh(Real(0.5))), tol);
1027 a = 0.5;
1028 a = cosh(a);
1029 BOOST_CHECK_CLOSE_FRACTION(a, Real(cosh(Real(0.5))), tol);
1030 a = 0.5;
1031 a = tanh(a);
1032 BOOST_CHECK_CLOSE_FRACTION(a, Real(tanh(Real(0.5))), tol);
1033 // fmod, need to check all the sign permutations:
1034 a = 4;
1035 b = 2;
1036 a = fmod(a, b);
1037 BOOST_CHECK_CLOSE_FRACTION(a, Real(fmod(Real(4), Real(2))), tol);
1038 a = 4;
1039 b = fmod(a, b);
1040 BOOST_CHECK_CLOSE_FRACTION(b, Real(fmod(Real(4), Real(2))), tol);
1041 a = 4;
1042 b = 2;
1043 a = fmod(-a, b);
1044 BOOST_CHECK_CLOSE_FRACTION(a, Real(fmod(-Real(4), Real(2))), tol);
1045 a = 4;
1046 b = fmod(-a, b);
1047 BOOST_CHECK_CLOSE_FRACTION(b, Real(-fmod(Real(4), Real(2))), tol);
1048 a = 4;
1049 b = 2;
1050 a = fmod(a, -b);
1051 BOOST_CHECK_CLOSE_FRACTION(a, Real(fmod(Real(4), -Real(2))), tol);
1052 a = 4;
1053 b = fmod(a, -b);
1054 BOOST_CHECK_CLOSE_FRACTION(b, Real(fmod(Real(4), -Real(2))), tol);
1055 a = 4;
1056 b = 2;
1057 a = fmod(-a, -b);
1058 BOOST_CHECK_CLOSE_FRACTION(a, Real(fmod(-Real(4), -Real(2))), tol);
1059 a = 4;
1060 b = fmod(-a, -b);
1061 BOOST_CHECK_CLOSE_FRACTION(b, Real(fmod(-Real(4), -Real(2))), tol);
1062 // modf:
1063 a = 5;
1064 a /= 2;
1065 b = modf(a, &c);
1066 BOOST_CHECK_EQUAL(b + c, a);
1067 BOOST_CHECK_EQUAL(b > 0, a > 0);
1068 BOOST_CHECK_EQUAL(c > 0, a > 0);
1069 a = -a;
1070 b = modf(a, &c);
1071 BOOST_CHECK_EQUAL(b + c, a);
1072 BOOST_CHECK_EQUAL(b > 0, a > 0);
1073 BOOST_CHECK_EQUAL(c > 0, a > 0);
1074 b = modf(a, &c);
1075 c = 0;
1076 modf(a, &c);
1077 BOOST_CHECK_EQUAL(b + c, a);
1078 BOOST_CHECK_EQUAL(b > 0, a > 0);
1079 BOOST_CHECK_EQUAL(c > 0, a > 0);
1080 a = -a;
1081 b = modf(a, &c);
1082 c = 0;
1083 modf(a, &c);
1084 BOOST_CHECK_EQUAL(b + c, a);
1085 BOOST_CHECK_EQUAL(b > 0, a > 0);
1086 BOOST_CHECK_EQUAL(c > 0, a > 0);
1087
1088 if (std::numeric_limits<Real>::has_infinity)
1089 {
1090 a = std::numeric_limits<Real>::infinity();
1091 b = modf(a, &c);
1092 BOOST_CHECK_EQUAL(a, c);
1093 BOOST_CHECK_EQUAL(b, 0);
1094 a = -std::numeric_limits<Real>::infinity();
1095 b = modf(a, &c);
1096 BOOST_CHECK_EQUAL(a, c);
1097 BOOST_CHECK_EQUAL(b, 0);
1098 }
1099 if (std::numeric_limits<Real>::has_quiet_NaN)
1100 {
1101 a = std::numeric_limits<Real>::quiet_NaN();
1102 b = modf(a, &c);
1103 BOOST_CHECK((boost::math::isnan)(b));
1104 BOOST_CHECK((boost::math::isnan)(c));
1105 }
1106
1107 a = 4;
1108 b = 2;
1109 a = atan2(a, b);
1110 BOOST_CHECK_CLOSE_FRACTION(a, Real(atan2(Real(4), Real(2))), tol);
1111 a = 4;
1112 b = atan2(a, b);
1113 BOOST_CHECK_CLOSE_FRACTION(b, Real(atan2(Real(4), Real(2))), tol);
1114
1115 // fma:
1116 a = 2;
1117 b = 4;
1118 c = 6;
1119 BOOST_CHECK_EQUAL(fma(a, b, c), 14);
1120 BOOST_CHECK_EQUAL(fma(a, 4, c), 14);
1121 BOOST_CHECK_EQUAL(fma(a, b, 6), 14);
1122 BOOST_CHECK_EQUAL(fma(a, 4, 6), 14);
1123 BOOST_CHECK_EQUAL(fma(a + 0, b, c), 14);
1124 BOOST_CHECK_EQUAL(fma(a - 0, 4, c), 14);
1125 BOOST_CHECK_EQUAL(fma(a * 1, b, 6), 14);
1126 BOOST_CHECK_EQUAL(fma(a / 1, 4, 6), 14);
1127 BOOST_CHECK_EQUAL(fma(2, b, c), 14);
1128 BOOST_CHECK_EQUAL(fma(2, b, 6), 14);
1129 BOOST_CHECK_EQUAL(fma(2, b * 1, c), 14);
1130 BOOST_CHECK_EQUAL(fma(2, b + 0, 6), 14);
1131 BOOST_CHECK_EQUAL(fma(2, 4, c), 14);
1132 BOOST_CHECK_EQUAL(fma(2, 4, c + 0), 14);
1133
1134 // Default construct, for consistency with native floats, default constructed values are zero:
1135 Real zero;
1136 BOOST_CHECK_EQUAL(zero, 0);
1137
1138 //
1139 // Complex number functions on scalars:
1140 //
1141 a = 40;
1142 BOOST_CHECK_EQUAL(Real(arg(a)), 0);
1143 BOOST_CHECK_EQUAL(Real(arg(a + 0)), 0);
1144 a - 20;
1145 BOOST_CHECK_EQUAL(Real(arg(a)), 0);
1146 BOOST_CHECK_EQUAL(Real(arg(a - 20)), 0);
1147 }
1148
1149 template <class T, class U>
compare_NaNs(const T & a,const U & b)1150 void compare_NaNs(const T& a, const U& b)
1151 {
1152 BOOST_CHECK_EQUAL(a == b, false);
1153 BOOST_CHECK_EQUAL(a != b, true);
1154 BOOST_CHECK_EQUAL(a <= b, false);
1155 BOOST_CHECK_EQUAL(a >= b, false);
1156 BOOST_CHECK_EQUAL(a > b, false);
1157 BOOST_CHECK_EQUAL(a < b, false);
1158 //
1159 // Again where LHS may be an expression template:
1160 //
1161 BOOST_CHECK_EQUAL(1 * a == b, false);
1162 BOOST_CHECK_EQUAL(1 * a != b, true);
1163 BOOST_CHECK_EQUAL(1 * a <= b, false);
1164 BOOST_CHECK_EQUAL(1 * a >= b, false);
1165 BOOST_CHECK_EQUAL(1 * a > b, false);
1166 BOOST_CHECK_EQUAL(1 * a < b, false);
1167 //
1168 // Again where RHS may be an expression template:
1169 //
1170 BOOST_CHECK_EQUAL(a == b * 1, false);
1171 BOOST_CHECK_EQUAL(a != b * 1, true);
1172 BOOST_CHECK_EQUAL(a <= b * 1, false);
1173 BOOST_CHECK_EQUAL(a >= b * 1, false);
1174 BOOST_CHECK_EQUAL(a > b * 1, false);
1175 BOOST_CHECK_EQUAL(a < b * 1, false);
1176 //
1177 // Again where LHS and RHS may be an expression templates:
1178 //
1179 BOOST_CHECK_EQUAL(1 * a == b * 1, false);
1180 BOOST_CHECK_EQUAL(1 * a != b * 1, true);
1181 BOOST_CHECK_EQUAL(1 * a <= b * 1, false);
1182 BOOST_CHECK_EQUAL(1 * a >= b * 1, false);
1183 BOOST_CHECK_EQUAL(1 * a > b * 1, false);
1184 BOOST_CHECK_EQUAL(1 * a < b * 1, false);
1185 }
1186
1187 template <class Real, class T>
test_float_ops(const T &)1188 void test_float_ops(const T&) {}
1189
1190 template <class Real>
test_float_ops(const boost::mpl::int_<boost::multiprecision::number_kind_floating_point> &)1191 void test_float_ops(const boost::mpl::int_<boost::multiprecision::number_kind_floating_point>&)
1192 {
1193 BOOST_CHECK_EQUAL(abs(Real(2)), 2);
1194 BOOST_CHECK_EQUAL(abs(Real(-2)), 2);
1195 BOOST_CHECK_EQUAL(fabs(Real(2)), 2);
1196 BOOST_CHECK_EQUAL(fabs(Real(-2)), 2);
1197 BOOST_CHECK_EQUAL(floor(Real(5) / 2), 2);
1198 BOOST_CHECK_EQUAL(ceil(Real(5) / 2), 3);
1199 BOOST_CHECK_EQUAL(floor(Real(-5) / 2), -3);
1200 BOOST_CHECK_EQUAL(ceil(Real(-5) / 2), -2);
1201 BOOST_CHECK_EQUAL(trunc(Real(5) / 2), 2);
1202 BOOST_CHECK_EQUAL(trunc(Real(-5) / 2), -2);
1203 //
1204 // ldexp and frexp, these pretty much have to be implemented by each backend:
1205 //
1206 typedef typename Real::backend_type::exponent_type e_type;
1207 BOOST_CHECK_EQUAL(ldexp(Real(2), 5), 64);
1208 BOOST_CHECK_EQUAL(ldexp(Real(2), -5), Real(2) / 32);
1209 Real v(512);
1210 e_type exponent;
1211 Real r = frexp(v, &exponent);
1212 BOOST_CHECK_EQUAL(r, 0.5);
1213 BOOST_CHECK_EQUAL(exponent, 10);
1214 BOOST_CHECK_EQUAL(v, 512);
1215 v = 1 / v;
1216 r = frexp(v, &exponent);
1217 BOOST_CHECK_EQUAL(r, 0.5);
1218 BOOST_CHECK_EQUAL(exponent, -8);
1219 BOOST_CHECK_EQUAL(ldexp(Real(2), e_type(5)), 64);
1220 BOOST_CHECK_EQUAL(ldexp(Real(2), e_type(-5)), Real(2) / 32);
1221 v = 512;
1222 e_type exp2;
1223 r = frexp(v, &exp2);
1224 BOOST_CHECK_EQUAL(r, 0.5);
1225 BOOST_CHECK_EQUAL(exp2, 10);
1226 BOOST_CHECK_EQUAL(v, 512);
1227 v = 1 / v;
1228 r = frexp(v, &exp2);
1229 BOOST_CHECK_EQUAL(r, 0.5);
1230 BOOST_CHECK_EQUAL(exp2, -8);
1231 //
1232 // scalbn and logb, these are the same as ldexp and frexp unless the radix is
1233 // something other than 2:
1234 //
1235 if (std::numeric_limits<Real>::is_specialized && std::numeric_limits<Real>::radix)
1236 {
1237 BOOST_CHECK_EQUAL(scalbn(Real(2), 5), 2 * pow(double(std::numeric_limits<Real>::radix), 5));
1238 BOOST_CHECK_EQUAL(scalbn(Real(2), -5), Real(2) / pow(double(std::numeric_limits<Real>::radix), 5));
1239 v = 512;
1240 exponent = ilogb(v);
1241 r = scalbn(v, -exponent);
1242 BOOST_CHECK(r >= 1);
1243 BOOST_CHECK(r < std::numeric_limits<Real>::radix);
1244 BOOST_CHECK_EQUAL(exponent, logb(v));
1245 BOOST_CHECK_EQUAL(v, scalbn(r, exponent));
1246 v = 1 / v;
1247 exponent = ilogb(v);
1248 r = scalbn(v, -exponent);
1249 BOOST_CHECK(r >= 1);
1250 BOOST_CHECK(r < std::numeric_limits<Real>::radix);
1251 BOOST_CHECK_EQUAL(exponent, logb(v));
1252 BOOST_CHECK_EQUAL(v, scalbn(r, exponent));
1253 }
1254 //
1255 // pow and exponent:
1256 //
1257 v = 3.25;
1258 r = pow(v, 0);
1259 BOOST_CHECK_EQUAL(r, 1);
1260 r = pow(v, 1);
1261 BOOST_CHECK_EQUAL(r, 3.25);
1262 r = pow(v, 2);
1263 BOOST_CHECK_EQUAL(r, boost::math::pow<2>(3.25));
1264 r = pow(v, 3);
1265 BOOST_CHECK_EQUAL(r, boost::math::pow<3>(3.25));
1266 r = pow(v, 4);
1267 BOOST_CHECK_EQUAL(r, boost::math::pow<4>(3.25));
1268 r = pow(v, 5);
1269 BOOST_CHECK_EQUAL(r, boost::math::pow<5>(3.25));
1270 r = pow(v, 6);
1271 BOOST_CHECK_EQUAL(r, boost::math::pow<6>(3.25));
1272 r = pow(v, 25);
1273 BOOST_CHECK_EQUAL(r, boost::math::pow<25>(Real(3.25)));
1274
1275 #ifndef BOOST_NO_EXCEPTIONS
1276 //
1277 // Things that are expected errors:
1278 //
1279 BOOST_CHECK_THROW(Real("3.14L"), std::runtime_error);
1280 if (std::numeric_limits<Real>::is_specialized)
1281 {
1282 if (std::numeric_limits<Real>::has_infinity)
1283 {
1284 BOOST_CHECK((boost::math::isinf)(Real(20) / 0u));
1285 }
1286 else
1287 {
1288 BOOST_CHECK_THROW(r = Real(Real(20) / 0u), std::overflow_error);
1289 }
1290 }
1291 #endif
1292 //
1293 // Comparisons of NaN's should always fail:
1294 //
1295 if (std::numeric_limits<Real>::has_quiet_NaN)
1296 {
1297 r = v = std::numeric_limits<Real>::quiet_NaN();
1298 compare_NaNs(r, v);
1299 v = 0;
1300 compare_NaNs(r, v);
1301 r.swap(v);
1302 compare_NaNs(r, v);
1303 //
1304 // Conmpare NaN to int:
1305 //
1306 compare_NaNs(v, 0);
1307 compare_NaNs(0, v);
1308 //
1309 // Compare to floats:
1310 //
1311 compare_NaNs(v, 0.5);
1312 compare_NaNs(0.5, v);
1313 if (std::numeric_limits<double>::has_quiet_NaN)
1314 {
1315 compare_NaNs(r, std::numeric_limits<double>::quiet_NaN());
1316 compare_NaNs(std::numeric_limits<double>::quiet_NaN(), r);
1317 }
1318 }
1319
1320 //
1321 // Operations involving NaN's as one argument:
1322 //
1323 if (std::numeric_limits<Real>::has_quiet_NaN)
1324 {
1325 v = 20.25;
1326 r = std::numeric_limits<Real>::quiet_NaN();
1327 BOOST_CHECK((boost::math::isnan)(v + r));
1328 BOOST_CHECK((boost::math::isnan)(r + v));
1329 BOOST_CHECK((boost::math::isnan)(r - v));
1330 BOOST_CHECK((boost::math::isnan)(v - r));
1331 BOOST_CHECK((boost::math::isnan)(r * v));
1332 BOOST_CHECK((boost::math::isnan)(v * r));
1333 BOOST_CHECK((boost::math::isnan)(r / v));
1334 BOOST_CHECK((boost::math::isnan)(v / r));
1335 Real t = v;
1336 BOOST_CHECK((boost::math::isnan)(t += r));
1337 t = r;
1338 BOOST_CHECK((boost::math::isnan)(t += v));
1339 t = r;
1340 BOOST_CHECK((boost::math::isnan)(t -= v));
1341 t = v;
1342 BOOST_CHECK((boost::math::isnan)(t -= r));
1343 t = r;
1344 BOOST_CHECK((boost::math::isnan)(t *= v));
1345 t = v;
1346 BOOST_CHECK((boost::math::isnan)(t *= r));
1347 t = r;
1348 BOOST_CHECK((boost::math::isnan)(t /= v));
1349 t = v;
1350 BOOST_CHECK((boost::math::isnan)(t /= r));
1351 }
1352 //
1353 // Operations involving infinities as one argument:
1354 //
1355 if (std::numeric_limits<Real>::has_infinity)
1356 {
1357 v = 20.25;
1358 r = std::numeric_limits<Real>::infinity();
1359 BOOST_CHECK((boost::math::isinf)(v + r));
1360 BOOST_CHECK((boost::math::isinf)(r + v));
1361 BOOST_CHECK((boost::math::isinf)(r - v));
1362 BOOST_CHECK((boost::math::isinf)(v - r));
1363 BOOST_CHECK_LT(v - r, 0);
1364 BOOST_CHECK((boost::math::isinf)(r * v));
1365 BOOST_CHECK((boost::math::isinf)(v * r));
1366 BOOST_CHECK((boost::math::isinf)(r / v));
1367 BOOST_CHECK_EQUAL(v / r, 0);
1368 Real t = v;
1369 BOOST_CHECK((boost::math::isinf)(t += r));
1370 t = r;
1371 BOOST_CHECK((boost::math::isinf)(t += v));
1372 t = r;
1373 BOOST_CHECK((boost::math::isinf)(t -= v));
1374 t = v;
1375 BOOST_CHECK((boost::math::isinf)(t -= r));
1376 t = v;
1377 BOOST_CHECK(t -= r < 0);
1378 t = r;
1379 BOOST_CHECK((boost::math::isinf)(t *= v));
1380 t = v;
1381 BOOST_CHECK((boost::math::isinf)(t *= r));
1382 t = r;
1383 BOOST_CHECK((boost::math::isinf)(t /= v));
1384 t = v;
1385 BOOST_CHECK((t /= r) == 0);
1386 }
1387 //
1388 // Operations that should produce NaN as a result:
1389 //
1390 if (std::numeric_limits<Real>::has_quiet_NaN)
1391 {
1392 v = r = 0;
1393 Real t = v / r;
1394 BOOST_CHECK((boost::math::isnan)(t));
1395 v /= r;
1396 BOOST_CHECK((boost::math::isnan)(v));
1397 t = v / 0;
1398 BOOST_CHECK((boost::math::isnan)(v));
1399 if (std::numeric_limits<Real>::has_infinity)
1400 {
1401 v = 0;
1402 r = std::numeric_limits<Real>::infinity();
1403 t = v * r;
1404 if (!boost::multiprecision::is_interval_number<Real>::value)
1405 {
1406 BOOST_CHECK((boost::math::isnan)(t));
1407 t = r * 0;
1408 BOOST_CHECK((boost::math::isnan)(t));
1409 }
1410 v = r;
1411 t = r / v;
1412 BOOST_CHECK((boost::math::isnan)(t));
1413 }
1414 }
1415
1416 test_float_funcs<Real>(boost::mpl::bool_<std::numeric_limits<Real>::is_specialized>());
1417 }
1418
1419 template <class T>
1420 struct lexical_cast_target_type
1421 {
1422 typedef typename boost::mpl::if_<
1423 boost::is_signed<T>,
1424 boost::intmax_t,
1425 typename boost::mpl::if_<
1426 boost::is_unsigned<T>,
1427 boost::uintmax_t,
1428 T>::type>::type type;
1429 };
1430
1431 template <class Real, class Num>
test_negative_mixed_minmax(boost::mpl::true_ const &)1432 void test_negative_mixed_minmax(boost::mpl::true_ const&)
1433 {
1434 if (!std::numeric_limits<Real>::is_bounded || (std::numeric_limits<Real>::digits >= std::numeric_limits<Num>::digits))
1435 {
1436 Real mx1((std::numeric_limits<Num>::max)() - 1);
1437 ++mx1;
1438 Real mx2((std::numeric_limits<Num>::max)());
1439 BOOST_CHECK_EQUAL(mx1, mx2);
1440 mx1 = (std::numeric_limits<Num>::max)() - 1;
1441 ++mx1;
1442 mx2 = (std::numeric_limits<Num>::max)();
1443 BOOST_CHECK_EQUAL(mx1, mx2);
1444
1445 if (!std::numeric_limits<Real>::is_bounded || (std::numeric_limits<Real>::digits > std::numeric_limits<Num>::digits))
1446 {
1447 Real mx3((std::numeric_limits<Num>::min)() + 1);
1448 --mx3;
1449 Real mx4((std::numeric_limits<Num>::min)());
1450 BOOST_CHECK_EQUAL(mx3, mx4);
1451 mx3 = (std::numeric_limits<Num>::min)() + 1;
1452 --mx3;
1453 mx4 = (std::numeric_limits<Num>::min)();
1454 BOOST_CHECK_EQUAL(mx3, mx4);
1455 }
1456 }
1457 }
1458 template <class Real, class Num>
test_negative_mixed_minmax(boost::mpl::false_ const &)1459 void test_negative_mixed_minmax(boost::mpl::false_ const&)
1460 {
1461 }
1462
1463 template <class Real, class Num>
test_negative_mixed_numeric_limits(boost::mpl::true_ const &)1464 void test_negative_mixed_numeric_limits(boost::mpl::true_ const&)
1465 {
1466 typedef typename lexical_cast_target_type<Num>::type target_type;
1467 #if defined(TEST_MPFR)
1468 Num tol = 10 * std::numeric_limits<Num>::epsilon();
1469 #else
1470 Num tol = 0;
1471 #endif
1472 static const int left_shift = std::numeric_limits<Num>::digits - 1;
1473 Num n1 = -static_cast<Num>(1uLL << ((left_shift < 63) && (left_shift > 0) ? left_shift : 10));
1474 Num n2 = -1;
1475 Num n3 = 0;
1476 Num n4 = -20;
1477 std::ios_base::fmtflags f = boost::is_floating_point<Num>::value ? std::ios_base::scientific : std::ios_base::fmtflags(0);
1478 int digits_to_print = boost::is_floating_point<Num>::value && std::numeric_limits<Num>::is_specialized
1479 ? std::numeric_limits<Num>::digits10 + 5
1480 : 0;
1481 if (std::numeric_limits<target_type>::digits <= std::numeric_limits<Real>::digits)
1482 {
1483 BOOST_CHECK_CLOSE(n1, checked_lexical_cast<target_type>(Real(n1).str(digits_to_print, f)), tol);
1484 }
1485 BOOST_CHECK_CLOSE(n2, checked_lexical_cast<target_type>(Real(n2).str(digits_to_print, f)), 0);
1486 BOOST_CHECK_CLOSE(n3, checked_lexical_cast<target_type>(Real(n3).str(digits_to_print, f)), 0);
1487 BOOST_CHECK_CLOSE(n4, checked_lexical_cast<target_type>(Real(n4).str(digits_to_print, f)), 0);
1488 }
1489
1490 template <class Real, class Num>
test_negative_mixed_numeric_limits(boost::mpl::false_ const &)1491 void test_negative_mixed_numeric_limits(boost::mpl::false_ const&) {}
1492
1493 template <class Real, class Num>
test_negative_mixed(boost::mpl::true_ const &)1494 void test_negative_mixed(boost::mpl::true_ const&)
1495 {
1496 typedef typename boost::mpl::if_<
1497 boost::is_convertible<Num, Real>,
1498 typename boost::mpl::if_c<boost::is_integral<Num>::value && (sizeof(Num) < sizeof(int)), int, Num>::type,
1499 Real>::type cast_type;
1500 typedef typename boost::mpl::if_<
1501 boost::is_convertible<Num, Real>,
1502 Num,
1503 Real>::type simple_cast_type;
1504 std::cout << "Testing mixed arithmetic with type: " << typeid(Real).name() << " and " << typeid(Num).name() << std::endl;
1505 static const int left_shift = std::numeric_limits<Num>::digits - 1;
1506 Num n1 = -static_cast<Num>(1uLL << ((left_shift < 63) && (left_shift > 0) ? left_shift : 10));
1507 Num n2 = -1;
1508 Num n3 = 0;
1509 Num n4 = -20;
1510 Num n5 = -8;
1511
1512 test_comparisons<Real>(n1, n2, boost::is_convertible<Num, Real>());
1513 test_comparisons<Real>(n1, n3, boost::is_convertible<Num, Real>());
1514 test_comparisons<Real>(n3, n1, boost::is_convertible<Num, Real>());
1515 test_comparisons<Real>(n2, n1, boost::is_convertible<Num, Real>());
1516 test_comparisons<Real>(n1, n1, boost::is_convertible<Num, Real>());
1517 test_comparisons<Real>(n3, n3, boost::is_convertible<Num, Real>());
1518
1519 // Default construct:
1520 BOOST_CHECK_EQUAL(Real(n1), static_cast<cast_type>(n1));
1521 BOOST_CHECK_EQUAL(Real(n2), static_cast<cast_type>(n2));
1522 BOOST_CHECK_EQUAL(Real(n3), static_cast<cast_type>(n3));
1523 BOOST_CHECK_EQUAL(Real(n4), static_cast<cast_type>(n4));
1524 BOOST_CHECK_EQUAL(static_cast<cast_type>(n1), Real(n1));
1525 BOOST_CHECK_EQUAL(static_cast<cast_type>(n2), Real(n2));
1526 BOOST_CHECK_EQUAL(static_cast<cast_type>(n3), Real(n3));
1527 BOOST_CHECK_EQUAL(static_cast<cast_type>(n4), Real(n4));
1528 BOOST_CHECK_EQUAL(Real(n1).template convert_to<Num>(), n1);
1529 BOOST_CHECK_EQUAL(Real(n2).template convert_to<Num>(), n2);
1530 BOOST_CHECK_EQUAL(Real(n3).template convert_to<Num>(), n3);
1531 BOOST_CHECK_EQUAL(Real(n4).template convert_to<Num>(), n4);
1532 #ifndef BOOST_MP_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
1533 BOOST_CHECK_EQUAL(static_cast<Num>(Real(n1)), n1);
1534 BOOST_CHECK_EQUAL(static_cast<Num>(Real(n2)), n2);
1535 BOOST_CHECK_EQUAL(static_cast<Num>(Real(n3)), n3);
1536 BOOST_CHECK_EQUAL(static_cast<Num>(Real(n4)), n4);
1537 #endif
1538 // Conversions when source is an expression template:
1539 BOOST_CHECK_EQUAL((Real(n1) + 0).template convert_to<Num>(), n1);
1540 BOOST_CHECK_EQUAL((Real(n2) + 0).template convert_to<Num>(), n2);
1541 BOOST_CHECK_EQUAL((Real(n3) + 0).template convert_to<Num>(), n3);
1542 BOOST_CHECK_EQUAL((Real(n4) + 0).template convert_to<Num>(), n4);
1543 #ifndef BOOST_MP_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
1544 BOOST_CHECK_EQUAL(static_cast<Num>((Real(n1) + 0)), n1);
1545 BOOST_CHECK_EQUAL(static_cast<Num>((Real(n2) + 0)), n2);
1546 BOOST_CHECK_EQUAL(static_cast<Num>((Real(n3) + 0)), n3);
1547 BOOST_CHECK_EQUAL(static_cast<Num>((Real(n4) + 0)), n4);
1548 #endif
1549 test_negative_mixed_numeric_limits<Real, Num>(boost::mpl::bool_<std::numeric_limits<Real>::is_specialized>());
1550 // Assignment:
1551 Real r(0);
1552 BOOST_CHECK(r != static_cast<cast_type>(n1));
1553 r = static_cast<simple_cast_type>(n1);
1554 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n1));
1555 r = static_cast<simple_cast_type>(n2);
1556 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n2));
1557 r = static_cast<simple_cast_type>(n3);
1558 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n3));
1559 r = static_cast<simple_cast_type>(n4);
1560 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4));
1561 // Addition:
1562 r = static_cast<simple_cast_type>(n2);
1563 BOOST_CHECK_EQUAL(r + static_cast<simple_cast_type>(n4), static_cast<cast_type>(n2 + n4));
1564 BOOST_CHECK_EQUAL(Real(r + static_cast<simple_cast_type>(n4)), static_cast<cast_type>(n2 + n4));
1565 r += static_cast<simple_cast_type>(n4);
1566 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n2 + n4));
1567 // subtraction:
1568 r = static_cast<simple_cast_type>(n4);
1569 BOOST_CHECK_EQUAL(r - static_cast<simple_cast_type>(n5), static_cast<cast_type>(n4 - n5));
1570 BOOST_CHECK_EQUAL(Real(r - static_cast<simple_cast_type>(n5)), static_cast<cast_type>(n4 - n5));
1571 r -= static_cast<simple_cast_type>(n5);
1572 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4 - n5));
1573 // Multiplication:
1574 r = static_cast<simple_cast_type>(n2);
1575 BOOST_CHECK_EQUAL(r * static_cast<simple_cast_type>(n4), static_cast<cast_type>(n2 * n4));
1576 BOOST_CHECK_EQUAL(Real(r * static_cast<simple_cast_type>(n4)), static_cast<cast_type>(n2 * n4));
1577 r *= static_cast<simple_cast_type>(n4);
1578 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n2 * n4));
1579 // Division:
1580 r = static_cast<simple_cast_type>(n1);
1581 BOOST_CHECK_EQUAL(r / static_cast<simple_cast_type>(n5), static_cast<cast_type>(n1 / n5));
1582 BOOST_CHECK_EQUAL(Real(r / static_cast<simple_cast_type>(n5)), static_cast<cast_type>(n1 / n5));
1583 r /= static_cast<simple_cast_type>(n5);
1584 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n1 / n5));
1585 //
1586 // Extra cases for full coverage:
1587 //
1588 r = Real(n4) + static_cast<simple_cast_type>(n5);
1589 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4 + n5));
1590 r = static_cast<simple_cast_type>(n4) + Real(n5);
1591 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4 + n5));
1592 r = Real(n4) - static_cast<simple_cast_type>(n5);
1593 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4 - n5));
1594 r = static_cast<simple_cast_type>(n4) - Real(n5);
1595 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4 - n5));
1596 r = static_cast<simple_cast_type>(n4) * Real(n5);
1597 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4 * n5));
1598 r = static_cast<cast_type>(Num(4) * n4) / Real(4);
1599 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4));
1600
1601 Real a, b, c;
1602 a = 20;
1603 b = 30;
1604 c = -a + b;
1605 BOOST_CHECK_EQUAL(c, 10);
1606 c = b + -a;
1607 BOOST_CHECK_EQUAL(c, 10);
1608 n4 = 30;
1609 c = -a + static_cast<cast_type>(n4);
1610 BOOST_CHECK_EQUAL(c, 10);
1611 c = static_cast<cast_type>(n4) + -a;
1612 BOOST_CHECK_EQUAL(c, 10);
1613 c = -a + -b;
1614 BOOST_CHECK_EQUAL(c, -50);
1615 n4 = 4;
1616 c = -(a + b) + static_cast<cast_type>(n4);
1617 BOOST_CHECK_EQUAL(c, -50 + 4);
1618 n4 = 50;
1619 c = (a + b) - static_cast<cast_type>(n4);
1620 BOOST_CHECK_EQUAL(c, 0);
1621 c = (a + b) - static_cast<cast_type>(n4);
1622 BOOST_CHECK_EQUAL(c, 0);
1623 c = a - -(b + static_cast<cast_type>(n4));
1624 BOOST_CHECK_EQUAL(c, 20 - -(30 + 50));
1625 c = -(b + static_cast<cast_type>(n4)) - a;
1626 BOOST_CHECK_EQUAL(c, -(30 + 50) - 20);
1627 c = a - -b;
1628 BOOST_CHECK_EQUAL(c, 50);
1629 c = -a - b;
1630 BOOST_CHECK_EQUAL(c, -50);
1631 c = -a - static_cast<cast_type>(n4);
1632 BOOST_CHECK_EQUAL(c, -20 - 50);
1633 c = static_cast<cast_type>(n4) - -a;
1634 BOOST_CHECK_EQUAL(c, 50 + 20);
1635 c = -(a + b) - Real(n4);
1636 BOOST_CHECK_EQUAL(c, -(20 + 30) - 50);
1637 c = static_cast<cast_type>(n4) - (a + b);
1638 BOOST_CHECK_EQUAL(c, 0);
1639 c = (a + b) * static_cast<cast_type>(n4);
1640 BOOST_CHECK_EQUAL(c, 50 * 50);
1641 c = static_cast<cast_type>(n4) * (a + b);
1642 BOOST_CHECK_EQUAL(c, 50 * 50);
1643 c = a * -(b + static_cast<cast_type>(n4));
1644 BOOST_CHECK_EQUAL(c, 20 * -(30 + 50));
1645 c = -(b + static_cast<cast_type>(n4)) * a;
1646 BOOST_CHECK_EQUAL(c, 20 * -(30 + 50));
1647 c = a * -b;
1648 BOOST_CHECK_EQUAL(c, 20 * -30);
1649 c = -a * b;
1650 BOOST_CHECK_EQUAL(c, 20 * -30);
1651 c = -a * static_cast<cast_type>(n4);
1652 BOOST_CHECK_EQUAL(c, -20 * 50);
1653 c = static_cast<cast_type>(n4) * -a;
1654 BOOST_CHECK_EQUAL(c, -20 * 50);
1655 c = -(a + b) + a;
1656 BOOST_CHECK(-50 + 20);
1657 c = static_cast<cast_type>(n4) - (a + b);
1658 BOOST_CHECK_EQUAL(c, 0);
1659 Real d = 10;
1660 c = (a + b) / d;
1661 BOOST_CHECK_EQUAL(c, 5);
1662 c = (a + b) / (d + 0);
1663 BOOST_CHECK_EQUAL(c, 5);
1664 c = (a + b) / static_cast<cast_type>(n4);
1665 BOOST_CHECK_EQUAL(c, 1);
1666 c = static_cast<cast_type>(n4) / (a + b);
1667 BOOST_CHECK_EQUAL(c, 1);
1668 d = 50;
1669 c = d / -(a + b);
1670 BOOST_CHECK_EQUAL(c, -1);
1671 c = -(a + b) / d;
1672 BOOST_CHECK_EQUAL(c, -1);
1673 d = 2;
1674 c = a / -d;
1675 BOOST_CHECK_EQUAL(c, 20 / -2);
1676 c = -a / d;
1677 BOOST_CHECK_EQUAL(c, 20 / -2);
1678 d = 50;
1679 c = -d / static_cast<cast_type>(n4);
1680 BOOST_CHECK_EQUAL(c, -1);
1681 c = static_cast<cast_type>(n4) / -d;
1682 BOOST_CHECK_EQUAL(c, -1);
1683 c = static_cast<cast_type>(n4) + a;
1684 BOOST_CHECK_EQUAL(c, 70);
1685 c = static_cast<cast_type>(n4) - a;
1686 BOOST_CHECK_EQUAL(c, 30);
1687 c = static_cast<cast_type>(n4) * a;
1688 BOOST_CHECK_EQUAL(c, 50 * 20);
1689
1690 n1 = -2;
1691 n2 = -3;
1692 n3 = -4;
1693 a = static_cast<cast_type>(n1);
1694 b = static_cast<cast_type>(n2);
1695 c = static_cast<cast_type>(n3);
1696 d = a + b * c;
1697 BOOST_CHECK_EQUAL(d, -2 + -3 * -4);
1698 d = static_cast<cast_type>(n1) + b * c;
1699 BOOST_CHECK_EQUAL(d, -2 + -3 * -4);
1700 d = a + static_cast<cast_type>(n2) * c;
1701 BOOST_CHECK_EQUAL(d, -2 + -3 * -4);
1702 d = a + b * static_cast<cast_type>(n3);
1703 BOOST_CHECK_EQUAL(d, -2 + -3 * -4);
1704 d = static_cast<cast_type>(n1) + static_cast<cast_type>(n2) * c;
1705 BOOST_CHECK_EQUAL(d, -2 + -3 * -4);
1706 d = static_cast<cast_type>(n1) + b * static_cast<cast_type>(n3);
1707 BOOST_CHECK_EQUAL(d, -2 + -3 * -4);
1708 a += static_cast<cast_type>(n2) * c;
1709 BOOST_CHECK_EQUAL(a, -2 + -3 * -4);
1710 a = static_cast<cast_type>(n1);
1711 a += b * static_cast<cast_type>(n3);
1712 BOOST_CHECK_EQUAL(a, -2 + -3 * -4);
1713 a = static_cast<cast_type>(n1);
1714
1715 d = b * c + a;
1716 BOOST_CHECK_EQUAL(d, -2 + -3 * -4);
1717 d = b * c + static_cast<cast_type>(n1);
1718 BOOST_CHECK_EQUAL(d, -2 + -3 * -4);
1719 d = static_cast<cast_type>(n2) * c + a;
1720 BOOST_CHECK_EQUAL(d, -2 + -3 * -4);
1721 d = b * static_cast<cast_type>(n3) + a;
1722 BOOST_CHECK_EQUAL(d, -2 + -3 * -4);
1723 d = static_cast<cast_type>(n2) * c + static_cast<cast_type>(n1);
1724 BOOST_CHECK_EQUAL(d, -2 + -3 * -4);
1725 d = b * static_cast<cast_type>(n3) + static_cast<cast_type>(n1);
1726 BOOST_CHECK_EQUAL(d, -2 + -3 * -4);
1727
1728 a = -20;
1729 d = a - b * c;
1730 BOOST_CHECK_EQUAL(d, -20 - -3 * -4);
1731 n1 = -20;
1732 d = static_cast<cast_type>(n1) - b * c;
1733 BOOST_CHECK_EQUAL(d, -20 - -3 * -4);
1734 d = a - static_cast<cast_type>(n2) * c;
1735 BOOST_CHECK_EQUAL(d, -20 - -3 * -4);
1736 d = a - b * static_cast<cast_type>(n3);
1737 BOOST_CHECK_EQUAL(d, -20 - -3 * -4);
1738 d = static_cast<cast_type>(n1) - static_cast<cast_type>(n2) * c;
1739 BOOST_CHECK_EQUAL(d, -20 - -3 * -4);
1740 d = static_cast<cast_type>(n1) - b * static_cast<cast_type>(n3);
1741 BOOST_CHECK_EQUAL(d, -20 - -3 * -4);
1742 a -= static_cast<cast_type>(n2) * c;
1743 BOOST_CHECK_EQUAL(a, -20 - -3 * -4);
1744 a = static_cast<cast_type>(n1);
1745 a -= b * static_cast<cast_type>(n3);
1746 BOOST_CHECK_EQUAL(a, -20 - -3 * -4);
1747
1748 a = -2;
1749 d = b * c - a;
1750 BOOST_CHECK_EQUAL(d, -3 * -4 - -2);
1751 n1 = -2;
1752 d = b * c - static_cast<cast_type>(n1);
1753 BOOST_CHECK_EQUAL(d, -3 * -4 - -2);
1754 d = static_cast<cast_type>(n2) * c - a;
1755 BOOST_CHECK_EQUAL(d, -3 * -4 - -2);
1756 d = b * static_cast<cast_type>(n3) - a;
1757 BOOST_CHECK_EQUAL(d, -3 * -4 - -2);
1758 d = static_cast<cast_type>(n2) * c - static_cast<cast_type>(n1);
1759 BOOST_CHECK_EQUAL(d, -3 * -4 - -2);
1760 d = b * static_cast<cast_type>(n3) - static_cast<cast_type>(n1);
1761 BOOST_CHECK_EQUAL(d, -3 * -4 - -2);
1762 //
1763 // Conversion from min and max values:
1764 //
1765 test_negative_mixed_minmax<Real, Num>(boost::mpl::bool_ < std::numeric_limits<Real>::is_integer && std::numeric_limits<Num>::is_integer > ());
1766 //
1767 // RValue ref overloads:
1768 //
1769 a = 2;
1770 n1 = 3;
1771 d = -a + static_cast<cast_type>(n1);
1772 BOOST_CHECK_EQUAL(d, 1);
1773 d = static_cast<cast_type>(n1) + -a;
1774 BOOST_CHECK_EQUAL(d, 1);
1775 d = -a - static_cast<cast_type>(n1);
1776 BOOST_CHECK_EQUAL(d, -5);
1777 d = static_cast<cast_type>(n1) - -a;
1778 BOOST_CHECK_EQUAL(d, 5);
1779 d = -a * static_cast<cast_type>(n1);
1780 BOOST_CHECK_EQUAL(d, -6);
1781 d = static_cast<cast_type>(n1) * -a;
1782 BOOST_CHECK_EQUAL(d, -6);
1783 n1 = 4;
1784 d = -static_cast<cast_type>(n1) / a;
1785 BOOST_CHECK_EQUAL(d, -2);
1786 d = static_cast<cast_type>(n1) / -a;
1787 BOOST_CHECK_EQUAL(d, -2);
1788 }
1789
1790 template <class Real, class Num>
test_negative_mixed(boost::mpl::false_ const &)1791 void test_negative_mixed(boost::mpl::false_ const&)
1792 {
1793 }
1794
1795 template <class Real, class Num>
test_mixed(const boost::mpl::false_ &)1796 void test_mixed(const boost::mpl::false_&)
1797 {
1798 }
1799
1800 template <class Real>
check_is_nan(const Real & val,const boost::mpl::true_ &)1801 inline bool check_is_nan(const Real& val, const boost::mpl::true_&)
1802 {
1803 return (boost::math::isnan)(val);
1804 }
1805 template <class Real>
check_is_nan(const Real &,const boost::mpl::false_ &)1806 inline bool check_is_nan(const Real&, const boost::mpl::false_&)
1807 {
1808 return false;
1809 }
1810 template <class Real>
negate_value(const Real & val,const boost::mpl::true_ &)1811 inline Real negate_value(const Real& val, const boost::mpl::true_&)
1812 {
1813 return -val;
1814 }
1815 template <class Real>
negate_value(const Real & val,const boost::mpl::false_ &)1816 inline Real negate_value(const Real& val, const boost::mpl::false_&)
1817 {
1818 return val;
1819 }
1820
1821 template <class Real, class Num>
test_mixed_numeric_limits(const boost::mpl::true_ &)1822 void test_mixed_numeric_limits(const boost::mpl::true_&)
1823 {
1824 typedef typename lexical_cast_target_type<Num>::type target_type;
1825 #if defined(TEST_MPFR)
1826 Num tol = 10 * std::numeric_limits<Num>::epsilon();
1827 #else
1828 Num tol = 0;
1829 #endif
1830
1831 Real d;
1832 if (std::numeric_limits<Real>::has_infinity && std::numeric_limits<Num>::has_infinity)
1833 {
1834 d = static_cast<Real>(std::numeric_limits<Num>::infinity());
1835 BOOST_CHECK_GT(d, (std::numeric_limits<Real>::max)());
1836 d = static_cast<Real>(negate_value(std::numeric_limits<Num>::infinity(), boost::mpl::bool_<std::numeric_limits<Num>::is_signed>()));
1837 BOOST_CHECK_LT(d, negate_value((std::numeric_limits<Real>::max)(), boost::mpl::bool_<std::numeric_limits<Real>::is_signed>()));
1838 }
1839 if (std::numeric_limits<Real>::has_quiet_NaN && std::numeric_limits<Num>::has_quiet_NaN)
1840 {
1841 d = static_cast<Real>(std::numeric_limits<Num>::quiet_NaN());
1842 BOOST_CHECK(check_is_nan(d, boost::mpl::bool_<std::numeric_limits<Real>::has_quiet_NaN>()));
1843 d = static_cast<Real>(negate_value(std::numeric_limits<Num>::quiet_NaN(), boost::mpl::bool_<std::numeric_limits<Num>::is_signed>()));
1844 BOOST_CHECK(check_is_nan(d, boost::mpl::bool_<std::numeric_limits<Real>::has_quiet_NaN>()));
1845 }
1846
1847 static const int left_shift = std::numeric_limits<Num>::digits - 1;
1848 Num n1 = static_cast<Num>(1uLL << ((left_shift < 63) && (left_shift > 0) ? left_shift : 10));
1849 Num n2 = 1;
1850 Num n3 = 0;
1851 Num n4 = 20;
1852
1853 std::ios_base::fmtflags f = boost::is_floating_point<Num>::value ? std::ios_base::scientific : std::ios_base::fmtflags(0);
1854 int digits_to_print = boost::is_floating_point<Num>::value && std::numeric_limits<Num>::is_specialized
1855 ? std::numeric_limits<Num>::digits10 + 5
1856 : 0;
1857 if (std::numeric_limits<target_type>::digits <= std::numeric_limits<Real>::digits)
1858 {
1859 BOOST_CHECK_CLOSE(n1, checked_lexical_cast<target_type>(Real(n1).str(digits_to_print, f)), tol);
1860 }
1861 BOOST_CHECK_CLOSE(n2, checked_lexical_cast<target_type>(Real(n2).str(digits_to_print, f)), 0);
1862 BOOST_CHECK_CLOSE(n3, checked_lexical_cast<target_type>(Real(n3).str(digits_to_print, f)), 0);
1863 BOOST_CHECK_CLOSE(n4, checked_lexical_cast<target_type>(Real(n4).str(digits_to_print, f)), 0);
1864 }
1865 template <class Real, class Num>
test_mixed_numeric_limits(const boost::mpl::false_ &)1866 void test_mixed_numeric_limits(const boost::mpl::false_&)
1867 {
1868 }
1869
1870 template <class Real, class Num>
test_mixed(const boost::mpl::true_ &)1871 void test_mixed(const boost::mpl::true_&)
1872 {
1873 typedef typename boost::mpl::if_<
1874 boost::is_convertible<Num, Real>,
1875 typename boost::mpl::if_c<boost::is_integral<Num>::value && (sizeof(Num) < sizeof(int)), int, Num>::type,
1876 Real>::type cast_type;
1877 typedef typename boost::mpl::if_<
1878 boost::is_convertible<Num, Real>,
1879 Num,
1880 Real>::type simple_cast_type;
1881
1882 if (std::numeric_limits<Real>::is_specialized && std::numeric_limits<Real>::is_bounded && std::numeric_limits<Real>::digits < std::numeric_limits<Num>::digits)
1883 return;
1884
1885 std::cout << "Testing mixed arithmetic with type: " << typeid(Real).name() << " and " << typeid(Num).name() << std::endl;
1886 static const int left_shift = std::numeric_limits<Num>::digits - 1;
1887 Num n1 = static_cast<Num>(1uLL << ((left_shift < 63) && (left_shift > 0) ? left_shift : 10));
1888 Num n2 = 1;
1889 Num n3 = 0;
1890 Num n4 = 20;
1891 Num n5 = 8;
1892
1893 test_comparisons<Real>(n1, n2, boost::is_convertible<Num, Real>());
1894 test_comparisons<Real>(n1, n3, boost::is_convertible<Num, Real>());
1895 test_comparisons<Real>(n1, n1, boost::is_convertible<Num, Real>());
1896 test_comparisons<Real>(n3, n1, boost::is_convertible<Num, Real>());
1897 test_comparisons<Real>(n2, n1, boost::is_convertible<Num, Real>());
1898 test_comparisons<Real>(n3, n3, boost::is_convertible<Num, Real>());
1899
1900 // Default construct:
1901 BOOST_CHECK_EQUAL(Real(n1), static_cast<cast_type>(n1));
1902 BOOST_CHECK_EQUAL(Real(n2), static_cast<cast_type>(n2));
1903 BOOST_CHECK_EQUAL(Real(n3), static_cast<cast_type>(n3));
1904 BOOST_CHECK_EQUAL(Real(n4), static_cast<cast_type>(n4));
1905 BOOST_CHECK_EQUAL(Real(n1).template convert_to<Num>(), n1);
1906 BOOST_CHECK_EQUAL(Real(n2).template convert_to<Num>(), n2);
1907 BOOST_CHECK_EQUAL(Real(n3).template convert_to<Num>(), n3);
1908 BOOST_CHECK_EQUAL(Real(n4).template convert_to<Num>(), n4);
1909 #ifndef BOOST_MP_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
1910 BOOST_CHECK_EQUAL(static_cast<Num>(Real(n1)), n1);
1911 BOOST_CHECK_EQUAL(static_cast<Num>(Real(n2)), n2);
1912 BOOST_CHECK_EQUAL(static_cast<Num>(Real(n3)), n3);
1913 BOOST_CHECK_EQUAL(static_cast<Num>(Real(n4)), n4);
1914 #endif
1915 // Again with expression templates:
1916 BOOST_CHECK_EQUAL((Real(n1) + 0).template convert_to<Num>(), n1);
1917 BOOST_CHECK_EQUAL((Real(n2) + 0).template convert_to<Num>(), n2);
1918 BOOST_CHECK_EQUAL((Real(n3) + 0).template convert_to<Num>(), n3);
1919 BOOST_CHECK_EQUAL((Real(n4) + 0).template convert_to<Num>(), n4);
1920 #ifndef BOOST_MP_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
1921 BOOST_CHECK_EQUAL(static_cast<Num>(Real(n1) + 0), n1);
1922 BOOST_CHECK_EQUAL(static_cast<Num>(Real(n2) + 0), n2);
1923 BOOST_CHECK_EQUAL(static_cast<Num>(Real(n3) + 0), n3);
1924 BOOST_CHECK_EQUAL(static_cast<Num>(Real(n4) + 0), n4);
1925 #endif
1926 BOOST_CHECK_EQUAL(static_cast<cast_type>(n1), Real(n1));
1927 BOOST_CHECK_EQUAL(static_cast<cast_type>(n2), Real(n2));
1928 BOOST_CHECK_EQUAL(static_cast<cast_type>(n3), Real(n3));
1929 BOOST_CHECK_EQUAL(static_cast<cast_type>(n4), Real(n4));
1930 // Assignment:
1931 Real r(0);
1932 BOOST_CHECK(r != static_cast<cast_type>(n1));
1933 r = static_cast<simple_cast_type>(n1);
1934 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n1));
1935 r = static_cast<simple_cast_type>(n2);
1936 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n2));
1937 r = static_cast<simple_cast_type>(n3);
1938 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n3));
1939 r = static_cast<simple_cast_type>(n4);
1940 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4));
1941 // Addition:
1942 r = static_cast<simple_cast_type>(n2);
1943 BOOST_CHECK_EQUAL(r + static_cast<simple_cast_type>(n4), static_cast<cast_type>(n2 + n4));
1944 BOOST_CHECK_EQUAL(Real(r + static_cast<simple_cast_type>(n4)), static_cast<cast_type>(n2 + n4));
1945 r += static_cast<simple_cast_type>(n4);
1946 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n2 + n4));
1947 // subtraction:
1948 r = static_cast<simple_cast_type>(n4);
1949 BOOST_CHECK_EQUAL(r - static_cast<simple_cast_type>(n5), static_cast<cast_type>(n4 - n5));
1950 BOOST_CHECK_EQUAL(Real(r - static_cast<simple_cast_type>(n5)), static_cast<cast_type>(n4 - n5));
1951 r -= static_cast<simple_cast_type>(n5);
1952 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4 - n5));
1953 // Multiplication:
1954 r = static_cast<simple_cast_type>(n2);
1955 BOOST_CHECK_EQUAL(r * static_cast<simple_cast_type>(n4), static_cast<cast_type>(n2 * n4));
1956 BOOST_CHECK_EQUAL(Real(r * static_cast<simple_cast_type>(n4)), static_cast<cast_type>(n2 * n4));
1957 r *= static_cast<simple_cast_type>(n4);
1958 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n2 * n4));
1959 // Division:
1960 r = static_cast<simple_cast_type>(n1);
1961 BOOST_CHECK_EQUAL(r / static_cast<simple_cast_type>(n5), static_cast<cast_type>(n1 / n5));
1962 BOOST_CHECK_EQUAL(Real(r / static_cast<simple_cast_type>(n5)), static_cast<cast_type>(n1 / n5));
1963 r /= static_cast<simple_cast_type>(n5);
1964 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n1 / n5));
1965 //
1966 // special cases for full coverage:
1967 //
1968 r = static_cast<simple_cast_type>(n5) + Real(n4);
1969 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4 + n5));
1970 r = static_cast<simple_cast_type>(n4) - Real(n5);
1971 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4 - n5));
1972 r = static_cast<simple_cast_type>(n4) * Real(n5);
1973 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4 * n5));
1974 r = static_cast<cast_type>(Num(4) * n4) / Real(4);
1975 BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4));
1976
1977 typedef boost::mpl::bool_<
1978 (!std::numeric_limits<Num>::is_specialized || std::numeric_limits<Num>::is_signed) && (!std::numeric_limits<Real>::is_specialized || std::numeric_limits<Real>::is_signed)>
1979 signed_tag;
1980
1981 test_negative_mixed<Real, Num>(signed_tag());
1982
1983 n1 = 2;
1984 n2 = 3;
1985 n3 = 4;
1986 Real a(n1), b(n2), c(n3), d;
1987 d = a + b * c;
1988 BOOST_CHECK_EQUAL(d, 2 + 3 * 4);
1989 d = static_cast<cast_type>(n1) + b * c;
1990 BOOST_CHECK_EQUAL(d, 2 + 3 * 4);
1991 d = a + static_cast<cast_type>(n2) * c;
1992 BOOST_CHECK_EQUAL(d, 2 + 3 * 4);
1993 d = a + b * static_cast<cast_type>(n3);
1994 BOOST_CHECK_EQUAL(d, 2 + 3 * 4);
1995 d = static_cast<cast_type>(n1) + static_cast<cast_type>(n2) * c;
1996 BOOST_CHECK_EQUAL(d, 2 + 3 * 4);
1997 d = static_cast<cast_type>(n1) + b * static_cast<cast_type>(n3);
1998 BOOST_CHECK_EQUAL(d, 2 + 3 * 4);
1999 a += static_cast<cast_type>(n2) * c;
2000 BOOST_CHECK_EQUAL(a, 2 + 3 * 4);
2001 a = static_cast<cast_type>(n1);
2002 a += b * static_cast<cast_type>(n3);
2003 BOOST_CHECK_EQUAL(a, 2 + 3 * 4);
2004 a = static_cast<cast_type>(n1);
2005
2006 d = b * c + a;
2007 BOOST_CHECK_EQUAL(d, 2 + 3 * 4);
2008 d = b * c + static_cast<cast_type>(n1);
2009 BOOST_CHECK_EQUAL(d, 2 + 3 * 4);
2010 d = static_cast<cast_type>(n2) * c + a;
2011 BOOST_CHECK_EQUAL(d, 2 + 3 * 4);
2012 d = b * static_cast<cast_type>(n3) + a;
2013 BOOST_CHECK_EQUAL(d, 2 + 3 * 4);
2014 d = static_cast<cast_type>(n2) * c + static_cast<cast_type>(n1);
2015 BOOST_CHECK_EQUAL(d, 2 + 3 * 4);
2016 d = b * static_cast<cast_type>(n3) + static_cast<cast_type>(n1);
2017 BOOST_CHECK_EQUAL(d, 2 + 3 * 4);
2018
2019 a = 20;
2020 d = a - b * c;
2021 BOOST_CHECK_EQUAL(d, 20 - 3 * 4);
2022 n1 = 20;
2023 d = static_cast<cast_type>(n1) - b * c;
2024 BOOST_CHECK_EQUAL(d, 20 - 3 * 4);
2025 d = a - static_cast<cast_type>(n2) * c;
2026 BOOST_CHECK_EQUAL(d, 20 - 3 * 4);
2027 d = a - b * static_cast<cast_type>(n3);
2028 BOOST_CHECK_EQUAL(d, 20 - 3 * 4);
2029 d = static_cast<cast_type>(n1) - static_cast<cast_type>(n2) * c;
2030 BOOST_CHECK_EQUAL(d, 20 - 3 * 4);
2031 d = static_cast<cast_type>(n1) - b * static_cast<cast_type>(n3);
2032 BOOST_CHECK_EQUAL(d, 20 - 3 * 4);
2033 a -= static_cast<cast_type>(n2) * c;
2034 BOOST_CHECK_EQUAL(a, 20 - 3 * 4);
2035 a = static_cast<cast_type>(n1);
2036 a -= b * static_cast<cast_type>(n3);
2037 BOOST_CHECK_EQUAL(a, 20 - 3 * 4);
2038
2039 a = 2;
2040 d = b * c - a;
2041 BOOST_CHECK_EQUAL(d, 3 * 4 - 2);
2042 n1 = 2;
2043 d = b * c - static_cast<cast_type>(n1);
2044 BOOST_CHECK_EQUAL(d, 3 * 4 - 2);
2045 d = static_cast<cast_type>(n2) * c - a;
2046 BOOST_CHECK_EQUAL(d, 3 * 4 - 2);
2047 d = b * static_cast<cast_type>(n3) - a;
2048 BOOST_CHECK_EQUAL(d, 3 * 4 - a);
2049 d = static_cast<cast_type>(n2) * c - static_cast<cast_type>(n1);
2050 BOOST_CHECK_EQUAL(d, 3 * 4 - 2);
2051 d = b * static_cast<cast_type>(n3) - static_cast<cast_type>(n1);
2052 BOOST_CHECK_EQUAL(d, 3 * 4 - 2);
2053
2054 test_mixed_numeric_limits<Real, Num>(boost::mpl::bool_<std::numeric_limits<Real>::is_specialized>());
2055 }
2056
2057 template <class Real>
test_members(Real)2058 typename boost::enable_if_c<boost::multiprecision::number_category<Real>::value == boost::multiprecision::number_kind_complex>::type test_members(Real)
2059 {
2060 //
2061 // Test sign and zero functions:
2062 //
2063 Real a = 20;
2064 Real b = 30;
2065 BOOST_CHECK(!a.is_zero());
2066 a = -20;
2067 BOOST_CHECK(!a.is_zero());
2068 a = 0;
2069 BOOST_CHECK(a.is_zero());
2070
2071 a = 20;
2072 b = 30;
2073 a.swap(b);
2074 BOOST_CHECK_EQUAL(a, 30);
2075 BOOST_CHECK_EQUAL(b, 20);
2076
2077 Real c(2, 3);
2078
2079 BOOST_CHECK_EQUAL(a.real(), 30);
2080 BOOST_CHECK_EQUAL(a.imag(), 0);
2081 BOOST_CHECK_EQUAL(c.real(), 2);
2082 BOOST_CHECK_EQUAL(c.imag(), 3);
2083
2084 //
2085 // try some more 2-argument constructors:
2086 //
2087 {
2088 Real d(40.5, 2);
2089 BOOST_CHECK_EQUAL(d.real(), 40.5);
2090 BOOST_CHECK_EQUAL(d.imag(), 2);
2091 }
2092 {
2093 Real d("40.5", "2");
2094 BOOST_CHECK_EQUAL(d.real(), 40.5);
2095 BOOST_CHECK_EQUAL(d.imag(), 2);
2096 }
2097 {
2098 Real d("40.5", std::string("2"));
2099 BOOST_CHECK_EQUAL(d.real(), 40.5);
2100 BOOST_CHECK_EQUAL(d.imag(), 2);
2101 }
2102 #ifndef BOOST_NO_CXX17_HDR_STRING_VIEW
2103 {
2104 std::string sx("40.550"), sy("222");
2105 std::string_view vx(sx.c_str(), 4), vy(sy.c_str(), 1);
2106 Real d(vx, vy);
2107 BOOST_CHECK_EQUAL(d.real(), 40.5);
2108 BOOST_CHECK_EQUAL(d.imag(), 2);
2109 }
2110 #endif
2111 {
2112 typename Real::value_type x(40.5), y(2);
2113 Real d(x, y);
2114 BOOST_CHECK_EQUAL(d.real(), 40.5);
2115 BOOST_CHECK_EQUAL(d.imag(), 2);
2116 }
2117 #ifdef TEST_MPC
2118 {
2119 typename Real::value_type x(40.5), y(2);
2120 Real d(x.backend().data(), y.backend().data());
2121 BOOST_CHECK_EQUAL(d.real(), 40.5);
2122 BOOST_CHECK_EQUAL(d.imag(), 2);
2123 }
2124 #endif
2125 {
2126 typename Real::value_type x(40.5);
2127 Real d(x, 2);
2128 BOOST_CHECK_EQUAL(d.real(), 40.5);
2129 BOOST_CHECK_EQUAL(d.imag(), 2);
2130 }
2131 {
2132 typename Real::value_type x(40.5);
2133 Real d(2, x);
2134 BOOST_CHECK_EQUAL(d.imag(), 40.5);
2135 BOOST_CHECK_EQUAL(d.real(), 2);
2136 }
2137 {
2138 typename Real::value_type x(real(a) * real(b) + imag(a) * imag(b)), y(imag(a) * real(b) - real(a) * imag(b));
2139 Real d(real(a) * real(b) + imag(a) * imag(b), imag(a) * real(b) - real(a) * imag(b));
2140 Real e(x, y);
2141 BOOST_CHECK_EQUAL(d, e);
2142 }
2143 //
2144 // real and imag setters:
2145 //
2146 c.real(4);
2147 BOOST_CHECK_EQUAL(real(c), 4);
2148 c.imag(-55);
2149 BOOST_CHECK_EQUAL(imag(c), -55);
2150 typename Real::value_type z(20);
2151 c.real(z);
2152 BOOST_CHECK_EQUAL(real(c), 20);
2153 c.real(21L);
2154 BOOST_CHECK_EQUAL(real(c), 21);
2155 c.real(22L);
2156 BOOST_CHECK_EQUAL(real(c), 22);
2157 c.real(23UL);
2158 BOOST_CHECK_EQUAL(real(c), 23);
2159 c.real(24U);
2160 BOOST_CHECK_EQUAL(real(c), 24);
2161 c.real(25.0f);
2162 BOOST_CHECK_EQUAL(real(c), 25);
2163 c.real(26.0);
2164 BOOST_CHECK_EQUAL(real(c), 26);
2165 c.real(27.0L);
2166 BOOST_CHECK_EQUAL(real(c), 27);
2167 #if defined(BOOST_HAS_LONG_LONG)
2168 c.real(28LL);
2169 BOOST_CHECK_EQUAL(real(c), 28);
2170 c.real(29ULL);
2171 BOOST_CHECK_EQUAL(real(c), 29);
2172 #endif
2173 c.imag(z);
2174 BOOST_CHECK_EQUAL(imag(c), 20);
2175 c.imag(21L);
2176 BOOST_CHECK_EQUAL(imag(c), 21);
2177 c.imag(22L);
2178 BOOST_CHECK_EQUAL(imag(c), 22);
2179 c.imag(23UL);
2180 BOOST_CHECK_EQUAL(imag(c), 23);
2181 c.imag(24U);
2182 BOOST_CHECK_EQUAL(imag(c), 24);
2183 c.imag(25.0f);
2184 BOOST_CHECK_EQUAL(imag(c), 25);
2185 c.imag(26.0);
2186 BOOST_CHECK_EQUAL(imag(c), 26);
2187 c.imag(27.0L);
2188 BOOST_CHECK_EQUAL(imag(c), 27);
2189 #if defined(BOOST_HAS_LONG_LONG)
2190 c.imag(28LL);
2191 BOOST_CHECK_EQUAL(imag(c), 28);
2192 c.imag(29ULL);
2193 BOOST_CHECK_EQUAL(imag(c), 29);
2194 #endif
2195
2196 c.real(2).imag(3);
2197
2198 BOOST_CHECK_EQUAL(real(a), 30);
2199 BOOST_CHECK_EQUAL(imag(a), 0);
2200 BOOST_CHECK_EQUAL(real(c), 2);
2201 BOOST_CHECK_EQUAL(imag(c), 3);
2202 BOOST_CHECK_EQUAL(real(a + 0), 30);
2203 BOOST_CHECK_EQUAL(imag(a + 0), 0);
2204 BOOST_CHECK_EQUAL(real(c + 0), 2);
2205 BOOST_CHECK_EQUAL(imag(c + 0), 3);
2206
2207 // string construction:
2208 a = Real("2");
2209 BOOST_CHECK_EQUAL(real(a), 2);
2210 BOOST_CHECK_EQUAL(imag(a), 0);
2211 a = Real("(2)");
2212 BOOST_CHECK_EQUAL(real(a), 2);
2213 BOOST_CHECK_EQUAL(imag(a), 0);
2214 a = Real("(,2)");
2215 BOOST_CHECK_EQUAL(real(a), 0);
2216 BOOST_CHECK_EQUAL(imag(a), 2);
2217 a = Real("(2,3)");
2218 BOOST_CHECK_EQUAL(real(a), 2);
2219 BOOST_CHECK_EQUAL(imag(a), 3);
2220
2221 typedef typename boost::multiprecision::component_type<Real>::type real_type;
2222
2223 real_type r(3);
2224 real_type tol = std::numeric_limits<real_type>::epsilon() * 30;
2225
2226 a = r;
2227 BOOST_CHECK_EQUAL(real(a), 3);
2228 BOOST_CHECK_EQUAL(imag(a), 0);
2229
2230 a += r;
2231 BOOST_CHECK_EQUAL(real(a), 6);
2232 BOOST_CHECK_EQUAL(imag(a), 0);
2233
2234 a *= r;
2235 BOOST_CHECK_EQUAL(real(a), 18);
2236 BOOST_CHECK_EQUAL(imag(a), 0);
2237
2238 a = a / r;
2239 BOOST_CHECK_EQUAL(real(a), 6);
2240 BOOST_CHECK_EQUAL(imag(a), 0);
2241 a = a - r;
2242 BOOST_CHECK_EQUAL(real(a), 3);
2243 BOOST_CHECK_EQUAL(imag(a), 0);
2244 a = r + a;
2245 BOOST_CHECK_EQUAL(real(a), 6);
2246 BOOST_CHECK_EQUAL(imag(a), 0);
2247
2248 r = abs(c);
2249 BOOST_CHECK_CLOSE_FRACTION(real_type("3.60555127546398929311922126747049594625129657384524621271045305622716694829301044520461908201849071767351418202406"), r, tol);
2250 r = arg(c);
2251 BOOST_CHECK_CLOSE_FRACTION(real_type("0.98279372324732906798571061101466601449687745363162855676142508831798807154979603538970653437281731110816513970201"), r, tol);
2252 r = norm(c);
2253 BOOST_CHECK_CLOSE_FRACTION(real_type(13), r, tol);
2254 a = conj(c);
2255 BOOST_CHECK_EQUAL(real(a), 2);
2256 BOOST_CHECK_EQUAL(imag(a), -3);
2257 a = proj(c);
2258 BOOST_CHECK_EQUAL(real(a), 2);
2259 BOOST_CHECK_EQUAL(imag(a), 3);
2260 a = polar(real_type(3), real_type(-10));
2261 BOOST_CHECK_CLOSE_FRACTION(real_type("-2.517214587229357356776591843472194503559790495399505640507861193146377760598812305202801138281266416782353163216"), real(a), tol);
2262 BOOST_CHECK_CLOSE_FRACTION(real_type("1.63206333266810944021424298555413184505092903874867167472255203785027162892148027712122702168494964847488147271478"), imag(a), tol);
2263 a = polar(real_type(3) + 0, real_type(-10));
2264 BOOST_CHECK_CLOSE_FRACTION(real_type("-2.517214587229357356776591843472194503559790495399505640507861193146377760598812305202801138281266416782353163216"), real(a), tol);
2265 BOOST_CHECK_CLOSE_FRACTION(real_type("1.63206333266810944021424298555413184505092903874867167472255203785027162892148027712122702168494964847488147271478"), imag(a), tol);
2266 a = polar(real_type(3), real_type(-10) + 0);
2267 BOOST_CHECK_CLOSE_FRACTION(real_type("-2.517214587229357356776591843472194503559790495399505640507861193146377760598812305202801138281266416782353163216"), real(a), tol);
2268 BOOST_CHECK_CLOSE_FRACTION(real_type("1.63206333266810944021424298555413184505092903874867167472255203785027162892148027712122702168494964847488147271478"), imag(a), tol);
2269 a = polar(real_type(3) + 0, real_type(-10) + 0);
2270 BOOST_CHECK_CLOSE_FRACTION(real_type("-2.517214587229357356776591843472194503559790495399505640507861193146377760598812305202801138281266416782353163216"), real(a), tol);
2271 BOOST_CHECK_CLOSE_FRACTION(real_type("1.63206333266810944021424298555413184505092903874867167472255203785027162892148027712122702168494964847488147271478"), imag(a), tol);
2272 a = polar(3, real_type(-10));
2273 BOOST_CHECK_CLOSE_FRACTION(real_type("-2.517214587229357356776591843472194503559790495399505640507861193146377760598812305202801138281266416782353163216"), real(a), tol);
2274 BOOST_CHECK_CLOSE_FRACTION(real_type("1.63206333266810944021424298555413184505092903874867167472255203785027162892148027712122702168494964847488147271478"), imag(a), tol);
2275 a = polar(3.0, real_type(-10) + 0);
2276 BOOST_CHECK_CLOSE_FRACTION(real_type("-2.517214587229357356776591843472194503559790495399505640507861193146377760598812305202801138281266416782353163216"), real(a), tol);
2277 BOOST_CHECK_CLOSE_FRACTION(real_type("1.63206333266810944021424298555413184505092903874867167472255203785027162892148027712122702168494964847488147271478"), imag(a), tol);
2278
2279 a = polar(real_type(3));
2280 BOOST_CHECK_EQUAL(3, real(a));
2281 BOOST_CHECK_EQUAL(0, imag(a));
2282 a = polar(real_type(3) + 0);
2283 BOOST_CHECK_EQUAL(3, real(a));
2284 BOOST_CHECK_EQUAL(0, imag(a));
2285
2286 r = abs(c + 0);
2287 BOOST_CHECK_CLOSE_FRACTION(real_type("3.60555127546398929311922126747049594625129657384524621271045305622716694829301044520461908201849071767351418202406"), r, tol);
2288 r = arg(c + 0);
2289 BOOST_CHECK_CLOSE_FRACTION(real_type("0.98279372324732906798571061101466601449687745363162855676142508831798807154979603538970653437281731110816513970201"), r, tol);
2290 r = norm(c + 0);
2291 BOOST_CHECK_CLOSE_FRACTION(real_type(13), r, tol);
2292 a = conj(c + 0);
2293 BOOST_CHECK_EQUAL(real(a), 2);
2294 BOOST_CHECK_EQUAL(imag(a), -3);
2295 a = proj(c + 0);
2296 BOOST_CHECK_EQUAL(real(a), 2);
2297 BOOST_CHECK_EQUAL(imag(a), 3);
2298
2299 a = exp(c);
2300 BOOST_CHECK_CLOSE_FRACTION(real_type("-7.3151100949011025174865361510507893218698794489446322367845159660828327860599907104337742108443234172141249777"), real(a), tol);
2301 BOOST_CHECK_CLOSE_FRACTION(real_type("1.0427436562359044141015039404625521939183300604422348975424523449538886779880818796291971422701951470533151185"), imag(a), tol);
2302
2303 a = log(c);
2304 BOOST_CHECK_CLOSE_FRACTION(real_type("1.282474678730768368026743720782659302402633972380103558209522755331732333662205089699787331720244744384629096046"), real(a), tol);
2305 BOOST_CHECK_CLOSE_FRACTION(real_type("0.9827937232473290679857106110146660144968774536316285567614250883179880715497960353897065343728173111081651397020"), imag(a), tol);
2306
2307 a = log10(c);
2308 BOOST_CHECK_CLOSE_FRACTION(real_type("0.556971676153418384603252578971164215414864594193534135900595487498776545815097120403823727129449829836488977743"), real(a), tol);
2309 BOOST_CHECK_CLOSE_FRACTION(real_type("0.426821890855466638944275673291166123449562356934437957244904971730668088711719757900679614536803436424488603794"), imag(a), tol);
2310
2311 a = exp(c + 0);
2312 BOOST_CHECK_CLOSE_FRACTION(real_type("-7.3151100949011025174865361510507893218698794489446322367845159660828327860599907104337742108443234172141249777"), real(a), tol);
2313 BOOST_CHECK_CLOSE_FRACTION(real_type("1.0427436562359044141015039404625521939183300604422348975424523449538886779880818796291971422701951470533151185"), imag(a), tol);
2314
2315 a = log(c + 0);
2316 BOOST_CHECK_CLOSE_FRACTION(real_type("1.282474678730768368026743720782659302402633972380103558209522755331732333662205089699787331720244744384629096046"), real(a), tol);
2317 BOOST_CHECK_CLOSE_FRACTION(real_type("0.9827937232473290679857106110146660144968774536316285567614250883179880715497960353897065343728173111081651397020"), imag(a), tol);
2318
2319 a = log10(c + 0);
2320 BOOST_CHECK_CLOSE_FRACTION(real_type("0.556971676153418384603252578971164215414864594193534135900595487498776545815097120403823727129449829836488977743"), real(a), tol);
2321 BOOST_CHECK_CLOSE_FRACTION(real_type("0.426821890855466638944275673291166123449562356934437957244904971730668088711719757900679614536803436424488603794"), imag(a), tol);
2322
2323 // Powers where one arg is an integer.
2324 b = Real(5, -2);
2325 a = pow(c, b);
2326 BOOST_CHECK_CLOSE_FRACTION(real_type("-3053.8558566606567369633610140423321260211388217942246293871310470377722279440084474789529228008638668934381183"), real(a), tol);
2327 BOOST_CHECK_CLOSE_FRACTION(real_type("3097.9975862915005132449772136982559285192410496951232473245540634244845290672745578327467396750607773968246915"), imag(a), tol);
2328 a = pow(c, 3);
2329 BOOST_CHECK_CLOSE_FRACTION(real_type(-46), real(a), tol);
2330 BOOST_CHECK_CLOSE_FRACTION(real_type(9), imag(a), tol);
2331 a = pow(3, c);
2332 BOOST_CHECK_CLOSE_FRACTION(real_type("-8.8931513442797186948734782808862447235385767991868219480917324534839621090167050538805196124711247247992169338"), real(a), tol);
2333 BOOST_CHECK_CLOSE_FRACTION(real_type("-1.3826999557878897572499699021550296885662132089951379549068064961882821777067532977546360861176011175070188118"), imag(a), tol * 3);
2334 a = pow(c + 0, b);
2335 BOOST_CHECK_CLOSE_FRACTION(real_type("-3053.8558566606567369633610140423321260211388217942246293871310470377722279440084474789529228008638668934381183"), real(a), tol);
2336 BOOST_CHECK_CLOSE_FRACTION(real_type("3097.9975862915005132449772136982559285192410496951232473245540634244845290672745578327467396750607773968246915"), imag(a), tol);
2337 a = pow(c + 0, 3);
2338 BOOST_CHECK_CLOSE_FRACTION(real_type(-46), real(a), tol);
2339 BOOST_CHECK_CLOSE_FRACTION(real_type(9), imag(a), tol);
2340 a = pow(3, c + 0);
2341 BOOST_CHECK_CLOSE_FRACTION(real_type("-8.8931513442797186948734782808862447235385767991868219480917324534839621090167050538805196124711247247992169338"), real(a), tol);
2342 BOOST_CHECK_CLOSE_FRACTION(real_type("-1.3826999557878897572499699021550296885662132089951379549068064961882821777067532977546360861176011175070188118"), imag(a), tol * 3);
2343
2344 r = 3;
2345 // Powers where one arg is a real_type.
2346 a = pow(c, r);
2347 BOOST_CHECK_CLOSE_FRACTION(real_type(-46), real(a), tol);
2348 BOOST_CHECK_CLOSE_FRACTION(real_type(9), imag(a), tol);
2349 a = pow(r, c);
2350 BOOST_CHECK_CLOSE_FRACTION(real_type("-8.8931513442797186948734782808862447235385767991868219480917324534839621090167050538805196124711247247992169338"), real(a), tol);
2351 BOOST_CHECK_CLOSE_FRACTION(real_type("-1.3826999557878897572499699021550296885662132089951379549068064961882821777067532977546360861176011175070188118"), imag(a), tol * 3);
2352 a = pow(c + 0, r);
2353 BOOST_CHECK_CLOSE_FRACTION(real_type(-46), real(a), tol);
2354 BOOST_CHECK_CLOSE_FRACTION(real_type(9), imag(a), tol);
2355 a = pow(r, c + 0);
2356 BOOST_CHECK_CLOSE_FRACTION(real_type("-8.8931513442797186948734782808862447235385767991868219480917324534839621090167050538805196124711247247992169338"), real(a), tol);
2357 BOOST_CHECK_CLOSE_FRACTION(real_type("-1.3826999557878897572499699021550296885662132089951379549068064961882821777067532977546360861176011175070188118"), imag(a), tol * 3);
2358 a = pow(c, r + 0);
2359 BOOST_CHECK_CLOSE_FRACTION(real_type(-46), real(a), tol);
2360 BOOST_CHECK_CLOSE_FRACTION(real_type(9), imag(a), tol);
2361 a = pow(r + 0, c);
2362 BOOST_CHECK_CLOSE_FRACTION(real_type("-8.8931513442797186948734782808862447235385767991868219480917324534839621090167050538805196124711247247992169338"), real(a), tol);
2363 BOOST_CHECK_CLOSE_FRACTION(real_type("-1.3826999557878897572499699021550296885662132089951379549068064961882821777067532977546360861176011175070188118"), imag(a), tol * 3);
2364
2365 // Powers where one arg is an float.
2366 a = pow(c, 3.0);
2367 BOOST_CHECK_CLOSE_FRACTION(real_type(-46), real(a), tol);
2368 BOOST_CHECK_CLOSE_FRACTION(real_type(9), imag(a), tol);
2369 a = pow(3.0, c);
2370 BOOST_CHECK_CLOSE_FRACTION(real_type("-8.8931513442797186948734782808862447235385767991868219480917324534839621090167050538805196124711247247992169338"), real(a), tol);
2371 BOOST_CHECK_CLOSE_FRACTION(real_type("-1.3826999557878897572499699021550296885662132089951379549068064961882821777067532977546360861176011175070188118"), imag(a), tol * 3);
2372 a = pow(c + 0, 3.0);
2373 BOOST_CHECK_CLOSE_FRACTION(real_type(-46), real(a), tol);
2374 BOOST_CHECK_CLOSE_FRACTION(real_type(9), imag(a), tol);
2375 a = pow(3.0, c + 0);
2376 BOOST_CHECK_CLOSE_FRACTION(real_type("-8.8931513442797186948734782808862447235385767991868219480917324534839621090167050538805196124711247247992169338"), real(a), tol);
2377 BOOST_CHECK_CLOSE_FRACTION(real_type("-1.3826999557878897572499699021550296885662132089951379549068064961882821777067532977546360861176011175070188118"), imag(a), tol * 3);
2378
2379 a = sqrt(c);
2380 BOOST_CHECK_CLOSE_FRACTION(real_type("1.674149228035540040448039300849051821674708677883920366727287836003399240343274891876712629708287692163156802065"), real(a), tol);
2381 BOOST_CHECK_CLOSE_FRACTION(real_type("0.8959774761298381247157337552900434410433241995549314932449006989874470582160955817053273057885402621549320588976"), imag(a), tol);
2382 a = sin(c);
2383 BOOST_CHECK_CLOSE_FRACTION(real_type("9.154499146911429573467299544609832559158860568765182977899828142590020335321896403936690014669532606510294425039"), real(a), tol);
2384 BOOST_CHECK_CLOSE_FRACTION(real_type("-4.168906959966564350754813058853754843573565604758055889965478710592666260138453299795649308385497563475115931624"), imag(a), tol);
2385 a = cos(c);
2386 BOOST_CHECK_CLOSE_FRACTION(real_type("-4.1896256909688072301325550196159737286219454041279210357407905058369727912162626993926269783331491034500484583"), real(a), tol);
2387 BOOST_CHECK_CLOSE_FRACTION(real_type("-9.1092278937553365979791972627788621213326202389201695649104967309554222940748568716960841549279996556547993373"), imag(a), tol);
2388 a = tan(c);
2389 BOOST_CHECK_CLOSE_FRACTION(real_type("-0.0037640256415042482927512211303226908396306202016580864328644932511249097100916559688254811519914564480500042311"), real(a), tol * 5);
2390 BOOST_CHECK_CLOSE_FRACTION(real_type("1.0032386273536098014463585978219272598077897241071003399272426939850671219193120708438426543945017427085738411"), imag(a), tol);
2391 a = asin(c);
2392 BOOST_CHECK_CLOSE_FRACTION(real_type("0.5706527843210994007102838796856696501828032450960401365302732598209740064262509342420347149436326252483895113827"), real(a), tol);
2393 BOOST_CHECK_CLOSE_FRACTION(real_type("1.983387029916535432347076902894039565014248302909345356125267430944752731616095111727103650117987412058949254132"), imag(a), tol);
2394 a = acos(c);
2395 BOOST_CHECK_CLOSE_FRACTION(real_type("1.000143542473797218521037811954081791915781454591512773957199036332934196716853565071982697727425908742684531873"), real(a), tol);
2396 BOOST_CHECK_CLOSE_FRACTION(real_type("-1.983387029916535432347076902894039565014248302909345356125267430944752731616095111727103650117987412058949254132"), imag(a), tol);
2397 a = atan(c);
2398 BOOST_CHECK_CLOSE_FRACTION(real_type("1.409921049596575522530619384460420782588207051908724814771070766475530084440199227135813201495737846771570458568"), real(a), tol);
2399 BOOST_CHECK_CLOSE_FRACTION(real_type("0.2290726829685387662958818029420027678625253049770656169479919704951963414344907622560676377741902308144912055002"), imag(a), tol);
2400 a = sqrt(c + 0);
2401 BOOST_CHECK_CLOSE_FRACTION(real_type("1.674149228035540040448039300849051821674708677883920366727287836003399240343274891876712629708287692163156802065"), real(a), tol);
2402 BOOST_CHECK_CLOSE_FRACTION(real_type("0.8959774761298381247157337552900434410433241995549314932449006989874470582160955817053273057885402621549320588976"), imag(a), tol);
2403 a = sin(c + 0);
2404 BOOST_CHECK_CLOSE_FRACTION(real_type("9.154499146911429573467299544609832559158860568765182977899828142590020335321896403936690014669532606510294425039"), real(a), tol);
2405 BOOST_CHECK_CLOSE_FRACTION(real_type("-4.168906959966564350754813058853754843573565604758055889965478710592666260138453299795649308385497563475115931624"), imag(a), tol);
2406 a = cos(c + 0);
2407 BOOST_CHECK_CLOSE_FRACTION(real_type("-4.1896256909688072301325550196159737286219454041279210357407905058369727912162626993926269783331491034500484583"), real(a), tol);
2408 BOOST_CHECK_CLOSE_FRACTION(real_type("-9.1092278937553365979791972627788621213326202389201695649104967309554222940748568716960841549279996556547993373"), imag(a), tol);
2409 a = tan(c + 0);
2410 BOOST_CHECK_CLOSE_FRACTION(real_type("-0.0037640256415042482927512211303226908396306202016580864328644932511249097100916559688254811519914564480500042311"), real(a), tol * 5);
2411 BOOST_CHECK_CLOSE_FRACTION(real_type("1.0032386273536098014463585978219272598077897241071003399272426939850671219193120708438426543945017427085738411"), imag(a), tol);
2412 a = asin(c + 0);
2413 BOOST_CHECK_CLOSE_FRACTION(real_type("0.5706527843210994007102838796856696501828032450960401365302732598209740064262509342420347149436326252483895113827"), real(a), tol);
2414 BOOST_CHECK_CLOSE_FRACTION(real_type("1.983387029916535432347076902894039565014248302909345356125267430944752731616095111727103650117987412058949254132"), imag(a), tol);
2415 a = acos(c + 0);
2416 BOOST_CHECK_CLOSE_FRACTION(real_type("1.000143542473797218521037811954081791915781454591512773957199036332934196716853565071982697727425908742684531873"), real(a), tol);
2417 BOOST_CHECK_CLOSE_FRACTION(real_type("-1.983387029916535432347076902894039565014248302909345356125267430944752731616095111727103650117987412058949254132"), imag(a), tol);
2418 a = atan(c + 0);
2419 BOOST_CHECK_CLOSE_FRACTION(real_type("1.409921049596575522530619384460420782588207051908724814771070766475530084440199227135813201495737846771570458568"), real(a), tol);
2420 BOOST_CHECK_CLOSE_FRACTION(real_type("0.2290726829685387662958818029420027678625253049770656169479919704951963414344907622560676377741902308144912055002"), imag(a), tol);
2421
2422 a = sinh(c);
2423 BOOST_CHECK_CLOSE_FRACTION(real_type("-3.5905645899857799520125654477948167931949136757293015099986213974178826801534614215227593814301490087307920223"), real(a), tol);
2424 BOOST_CHECK_CLOSE_FRACTION(real_type("0.53092108624851980526704009066067655967277345095149103008706855371803528753067068552935673000832252607835087747"), imag(a), tol);
2425 a = cosh(c);
2426 BOOST_CHECK_CLOSE_FRACTION(real_type("-3.7245455049153225654739707032559725286749657732153307267858945686649501059065292889110148294141744084833329553"), real(a), tol);
2427 BOOST_CHECK_CLOSE_FRACTION(real_type("0.51182256998738460883446384980187563424555660949074386745538379123585339045741119409984041226187262097496424111"), imag(a), tol);
2428 a = tanh(c);
2429 BOOST_CHECK_CLOSE_FRACTION(real_type("0.965385879022133124278480269394560685879729650005757773636908240066639772853967550095754361348005358178253777920"), real(a), tol * 5);
2430 BOOST_CHECK_CLOSE_FRACTION(real_type("-0.00988437503832249372031403430350121097961813353467039031861010606115560355679254344335582852193041894874685555114"), imag(a), tol);
2431 a = asinh(c);
2432 BOOST_CHECK_CLOSE_FRACTION(real_type("1.968637925793096291788665095245498189520731012682010573842811017352748255492485345887875752070076230641308014923"), real(a), tol);
2433 BOOST_CHECK_CLOSE_FRACTION(real_type("0.9646585044076027920454110594995323555197773725073316527132580297155508786089335572049608301897631767195194427315"), imag(a), tol);
2434 a = acosh(c);
2435 BOOST_CHECK_CLOSE_FRACTION(real_type("1.983387029916535432347076902894039565014248302909345356125267430944752731616095111727103650117987412058949254132"), real(a), tol);
2436 BOOST_CHECK_CLOSE_FRACTION(real_type("1.000143542473797218521037811954081791915781454591512773957199036332934196716853565071982697727425908742684531873"), imag(a), tol);
2437 a = atanh(c);
2438 BOOST_CHECK_CLOSE_FRACTION(real_type("0.1469466662255297520474327851547159424423449403442452953891851939502023996823900422792744078835711416939934387775"), real(a), tol);
2439 BOOST_CHECK_CLOSE_FRACTION(real_type("1.338972522294493561124193575909144241084316172544492778582005751793809271060233646663717270678614587712809117131"), imag(a), tol);
2440 a = sinh(c + 0);
2441 BOOST_CHECK_CLOSE_FRACTION(real_type("-3.5905645899857799520125654477948167931949136757293015099986213974178826801534614215227593814301490087307920223"), real(a), tol);
2442 BOOST_CHECK_CLOSE_FRACTION(real_type("0.53092108624851980526704009066067655967277345095149103008706855371803528753067068552935673000832252607835087747"), imag(a), tol);
2443 a = cosh(c + 0);
2444 BOOST_CHECK_CLOSE_FRACTION(real_type("-3.7245455049153225654739707032559725286749657732153307267858945686649501059065292889110148294141744084833329553"), real(a), tol);
2445 BOOST_CHECK_CLOSE_FRACTION(real_type("0.51182256998738460883446384980187563424555660949074386745538379123585339045741119409984041226187262097496424111"), imag(a), tol);
2446 a = tanh(c + 0);
2447 BOOST_CHECK_CLOSE_FRACTION(real_type("0.965385879022133124278480269394560685879729650005757773636908240066639772853967550095754361348005358178253777920"), real(a), tol);
2448 BOOST_CHECK_CLOSE_FRACTION(real_type("-0.00988437503832249372031403430350121097961813353467039031861010606115560355679254344335582852193041894874685555114"), imag(a), tol);
2449 a = asinh(c + 0);
2450 BOOST_CHECK_CLOSE_FRACTION(real_type("1.968637925793096291788665095245498189520731012682010573842811017352748255492485345887875752070076230641308014923"), real(a), tol);
2451 BOOST_CHECK_CLOSE_FRACTION(real_type("0.9646585044076027920454110594995323555197773725073316527132580297155508786089335572049608301897631767195194427315"), imag(a), tol);
2452 a = acosh(c + 0);
2453 BOOST_CHECK_CLOSE_FRACTION(real_type("1.983387029916535432347076902894039565014248302909345356125267430944752731616095111727103650117987412058949254132"), real(a), tol);
2454 BOOST_CHECK_CLOSE_FRACTION(real_type("1.000143542473797218521037811954081791915781454591512773957199036332934196716853565071982697727425908742684531873"), imag(a), tol);
2455 a = atanh(c + 0);
2456 BOOST_CHECK_CLOSE_FRACTION(real_type("0.1469466662255297520474327851547159424423449403442452953891851939502023996823900422792744078835711416939934387775"), real(a), tol);
2457 BOOST_CHECK_CLOSE_FRACTION(real_type("1.338972522294493561124193575909144241084316172544492778582005751793809271060233646663717270678614587712809117131"), imag(a), tol);
2458 }
2459
2460 template <class Real>
test_members(Real)2461 typename boost::enable_if_c<boost::multiprecision::number_category<Real>::value != boost::multiprecision::number_kind_complex>::type test_members(Real)
2462 {
2463 //
2464 // Test sign and zero functions:
2465 //
2466 Real a = 20;
2467 Real b = 30;
2468 BOOST_CHECK(a.sign() > 0);
2469 BOOST_CHECK(!a.is_zero());
2470 if (std::numeric_limits<Real>::is_signed)
2471 {
2472 a = -20;
2473 BOOST_CHECK(a.sign() < 0);
2474 BOOST_CHECK(!a.is_zero());
2475 }
2476 a = 0;
2477 BOOST_CHECK_EQUAL(a.sign(), 0);
2478 BOOST_CHECK(a.is_zero());
2479
2480 a = 20;
2481 b = 30;
2482 a.swap(b);
2483 BOOST_CHECK_EQUAL(a, 30);
2484 BOOST_CHECK_EQUAL(b, 20);
2485 //
2486 // Test complex number functions which are also overloaded for scalar type:
2487 //
2488 BOOST_CHECK_EQUAL(real(a), a);
2489 BOOST_CHECK_EQUAL(imag(a), 0);
2490 BOOST_CHECK_EQUAL(real(a + 0), a);
2491 BOOST_CHECK_EQUAL(imag(a + 2), 0);
2492 BOOST_CHECK_EQUAL(norm(a), a * a);
2493 BOOST_CHECK_EQUAL(norm(a * 1), a * a);
2494 BOOST_CHECK_EQUAL(conj(a), a);
2495 BOOST_CHECK_EQUAL(conj(a * 1), a);
2496 BOOST_CHECK_EQUAL(proj(a), a);
2497 BOOST_CHECK_EQUAL(proj(a * 1), a);
2498 BOOST_CHECK_EQUAL(a.real(), a);
2499 BOOST_CHECK_EQUAL(a.imag(), 0);
2500 a.real(55);
2501 BOOST_CHECK_EQUAL(a, 55);
2502 }
2503
2504 template <class Real>
test_members(boost::rational<Real>)2505 void test_members(boost::rational<Real>)
2506 {
2507 }
2508
2509 template <class Real>
test_signed_ops(const boost::mpl::true_ &)2510 void test_signed_ops(const boost::mpl::true_&)
2511 {
2512 Real a(8);
2513 Real b(64);
2514 Real c(500);
2515 Real d(1024);
2516 Real ac;
2517 BOOST_CHECK_EQUAL(-a, -8);
2518 ac = a;
2519 ac = ac - b;
2520 BOOST_CHECK_EQUAL(ac, 8 - 64);
2521 ac = a;
2522 ac -= a + b;
2523 BOOST_CHECK_EQUAL(ac, -64);
2524 ac = a;
2525 ac -= b - a;
2526 BOOST_CHECK_EQUAL(ac, 16 - 64);
2527 ac = -a;
2528 BOOST_CHECK_EQUAL(ac, -8);
2529 ac = a;
2530 ac -= -a;
2531 BOOST_CHECK_EQUAL(ac, 16);
2532 ac = a;
2533 ac += -a;
2534 BOOST_CHECK_EQUAL(ac, 0);
2535 ac = b;
2536 ac /= -a;
2537 BOOST_CHECK_EQUAL(ac, -8);
2538 ac = a;
2539 ac *= -a;
2540 BOOST_CHECK_EQUAL(ac, -64);
2541 ac = a + -b;
2542 BOOST_CHECK_EQUAL(ac, 8 - 64);
2543 ac = -a + b;
2544 BOOST_CHECK_EQUAL(ac, -8 + 64);
2545 ac = -a + -b;
2546 BOOST_CHECK_EQUAL(ac, -72);
2547 ac = a + -+-b; // lots of unary operators!!
2548 BOOST_CHECK_EQUAL(ac, 72);
2549 test_conditional(Real(-a), -a);
2550
2551 //
2552 // RValue ref tests:
2553 //
2554 a = 3;
2555 b = 4;
2556 c = Real(20) + -(a + b);
2557 BOOST_CHECK_EQUAL(c, 13);
2558 c = Real(20) + -a;
2559 BOOST_CHECK_EQUAL(c, 17);
2560 c = -a + Real(20);
2561 BOOST_CHECK_EQUAL(c, 17);
2562 c = -a + b;
2563 BOOST_CHECK_EQUAL(c, 1);
2564 c = b + -a;
2565 BOOST_CHECK_EQUAL(c, 1);
2566 a = 2;
2567 b = 3;
2568 c = Real(10) - a;
2569 BOOST_CHECK_EQUAL(c, 8);
2570 c = a - Real(2);
2571 BOOST_CHECK_EQUAL(c, 0);
2572 c = Real(3) - Real(2);
2573 BOOST_CHECK_EQUAL(c, 1);
2574 a = 20;
2575 c = a - (a + b);
2576 BOOST_CHECK_EQUAL(c, -3);
2577 a = 2;
2578 c = (a * b) - (a + b);
2579 BOOST_CHECK_EQUAL(c, 1);
2580 c = Real(20) - -(a + b);
2581 BOOST_CHECK_EQUAL(c, 25);
2582 c = Real(20) - (-a);
2583 BOOST_CHECK_EQUAL(c, 22);
2584 c = (-b) - Real(-5);
2585 BOOST_CHECK_EQUAL(c, 2);
2586 c = (-b) - a;
2587 BOOST_CHECK_EQUAL(c, -5);
2588 c = b - (-a);
2589 BOOST_CHECK_EQUAL(c, 5);
2590 c = Real(3) * -(a + b);
2591 BOOST_CHECK_EQUAL(c, -15);
2592 c = -(a + b) * Real(3);
2593 BOOST_CHECK_EQUAL(c, -15);
2594 c = Real(2) * -a;
2595 BOOST_CHECK_EQUAL(c, -4);
2596 c = -a * Real(2);
2597 BOOST_CHECK_EQUAL(c, -4);
2598 c = -a * b;
2599 BOOST_CHECK_EQUAL(c, -6);
2600 a = 2;
2601 b = 4;
2602 c = Real(4) / -a;
2603 BOOST_CHECK_EQUAL(c, -2);
2604 c = -b / Real(2);
2605 BOOST_CHECK_EQUAL(c, -2);
2606 c = Real(4) / -(2 * a);
2607 BOOST_CHECK_EQUAL(c, -1);
2608 c = b / -(2 * a);
2609 BOOST_CHECK_EQUAL(c, -1);
2610 c = -(2 * a) / Real(2);
2611 BOOST_CHECK_EQUAL(c, -2);
2612 }
2613 template <class Real>
test_signed_ops(const boost::mpl::false_ &)2614 void test_signed_ops(const boost::mpl::false_&)
2615 {
2616 }
2617
2618 template <class Real>
test_basic_conditionals(Real a,Real b)2619 void test_basic_conditionals(Real a, Real b)
2620 {
2621 if (a)
2622 {
2623 BOOST_ERROR("Unexpected non-zero result");
2624 }
2625 if (!a)
2626 {
2627 }
2628 else
2629 {
2630 BOOST_ERROR("Unexpected zero result");
2631 }
2632 b = 2;
2633 if (!b)
2634 {
2635 BOOST_ERROR("Unexpected zero result");
2636 }
2637 if (b)
2638 {
2639 }
2640 else
2641 {
2642 BOOST_ERROR("Unexpected non-zero result");
2643 }
2644 if (a && b)
2645 {
2646 BOOST_ERROR("Unexpected zero result");
2647 }
2648 if (!(a || b))
2649 {
2650 BOOST_ERROR("Unexpected zero result");
2651 }
2652 if (a + b)
2653 {
2654 }
2655 else
2656 {
2657 BOOST_ERROR("Unexpected zero result");
2658 }
2659 if (b - 2)
2660 {
2661 BOOST_ERROR("Unexpected non-zero result");
2662 }
2663 }
2664
2665 template <class T>
2666 typename boost::enable_if_c<boost::multiprecision::number_category<T>::value == boost::multiprecision::number_kind_complex>::type
test_relationals(T a,T b)2667 test_relationals(T a, T b)
2668 {
2669 BOOST_CHECK_EQUAL((a == b), false);
2670 BOOST_CHECK_EQUAL((a != b), true);
2671
2672 BOOST_CHECK_EQUAL((a + b == b), false);
2673 BOOST_CHECK_EQUAL((a + b != b), true);
2674
2675 BOOST_CHECK_EQUAL((a == b + a), false);
2676 BOOST_CHECK_EQUAL((a != b + a), true);
2677
2678 BOOST_CHECK_EQUAL((a + b == b + a), true);
2679 BOOST_CHECK_EQUAL((a + b != b + a), false);
2680
2681 BOOST_CHECK_EQUAL((8 == b + a), false);
2682 BOOST_CHECK_EQUAL((8 != b + a), true);
2683 BOOST_CHECK_EQUAL((800 == b + a), false);
2684 BOOST_CHECK_EQUAL((800 != b + a), true);
2685 BOOST_CHECK_EQUAL((72 == b + a), true);
2686 BOOST_CHECK_EQUAL((72 != b + a), false);
2687
2688 BOOST_CHECK_EQUAL((b + a == 8), false);
2689 BOOST_CHECK_EQUAL((b + a != 8), true);
2690 BOOST_CHECK_EQUAL((b + a == 800), false);
2691 BOOST_CHECK_EQUAL((b + a != 800), true);
2692 BOOST_CHECK_EQUAL((b + a == 72), true);
2693 BOOST_CHECK_EQUAL((b + a != 72), false);
2694 }
2695
2696 template <class T>
2697 typename boost::disable_if_c<boost::multiprecision::number_category<T>::value == boost::multiprecision::number_kind_complex>::type
test_relationals(T a,T b)2698 test_relationals(T a, T b)
2699 {
2700 BOOST_CHECK_EQUAL((a == b), false);
2701 BOOST_CHECK_EQUAL((a != b), true);
2702 BOOST_CHECK_EQUAL((a <= b), true);
2703 BOOST_CHECK_EQUAL((a < b), true);
2704 BOOST_CHECK_EQUAL((a >= b), false);
2705 BOOST_CHECK_EQUAL((a > b), false);
2706
2707 BOOST_CHECK_EQUAL((a + b == b), false);
2708 BOOST_CHECK_EQUAL((a + b != b), true);
2709 BOOST_CHECK_EQUAL((a + b >= b), true);
2710 BOOST_CHECK_EQUAL((a + b > b), true);
2711 BOOST_CHECK_EQUAL((a + b <= b), false);
2712 BOOST_CHECK_EQUAL((a + b < b), false);
2713
2714 BOOST_CHECK_EQUAL((a == b + a), false);
2715 BOOST_CHECK_EQUAL((a != b + a), true);
2716 BOOST_CHECK_EQUAL((a <= b + a), true);
2717 BOOST_CHECK_EQUAL((a < b + a), true);
2718 BOOST_CHECK_EQUAL((a >= b + a), false);
2719 BOOST_CHECK_EQUAL((a > b + a), false);
2720
2721 BOOST_CHECK_EQUAL((a + b == b + a), true);
2722 BOOST_CHECK_EQUAL((a + b != b + a), false);
2723 BOOST_CHECK_EQUAL((a + b <= b + a), true);
2724 BOOST_CHECK_EQUAL((a + b < b + a), false);
2725 BOOST_CHECK_EQUAL((a + b >= b + a), true);
2726 BOOST_CHECK_EQUAL((a + b > b + a), false);
2727
2728 BOOST_CHECK_EQUAL((8 == b + a), false);
2729 BOOST_CHECK_EQUAL((8 != b + a), true);
2730 BOOST_CHECK_EQUAL((8 <= b + a), true);
2731 BOOST_CHECK_EQUAL((8 < b + a), true);
2732 BOOST_CHECK_EQUAL((8 >= b + a), false);
2733 BOOST_CHECK_EQUAL((8 > b + a), false);
2734 BOOST_CHECK_EQUAL((800 == b + a), false);
2735 BOOST_CHECK_EQUAL((800 != b + a), true);
2736 BOOST_CHECK_EQUAL((800 >= b + a), true);
2737 BOOST_CHECK_EQUAL((800 > b + a), true);
2738 BOOST_CHECK_EQUAL((800 <= b + a), false);
2739 BOOST_CHECK_EQUAL((800 < b + a), false);
2740 BOOST_CHECK_EQUAL((72 == b + a), true);
2741 BOOST_CHECK_EQUAL((72 != b + a), false);
2742 BOOST_CHECK_EQUAL((72 <= b + a), true);
2743 BOOST_CHECK_EQUAL((72 < b + a), false);
2744 BOOST_CHECK_EQUAL((72 >= b + a), true);
2745 BOOST_CHECK_EQUAL((72 > b + a), false);
2746
2747 BOOST_CHECK_EQUAL((b + a == 8), false);
2748 BOOST_CHECK_EQUAL((b + a != 8), true);
2749 BOOST_CHECK_EQUAL((b + a >= 8), true);
2750 BOOST_CHECK_EQUAL((b + a > 8), true);
2751 BOOST_CHECK_EQUAL((b + a <= 8), false);
2752 BOOST_CHECK_EQUAL((b + a < 8), false);
2753 BOOST_CHECK_EQUAL((b + a == 800), false);
2754 BOOST_CHECK_EQUAL((b + a != 800), true);
2755 BOOST_CHECK_EQUAL((b + a <= 800), true);
2756 BOOST_CHECK_EQUAL((b + a < 800), true);
2757 BOOST_CHECK_EQUAL((b + a >= 800), false);
2758 BOOST_CHECK_EQUAL((b + a > 800), false);
2759 BOOST_CHECK_EQUAL((b + a == 72), true);
2760 BOOST_CHECK_EQUAL((b + a != 72), false);
2761 BOOST_CHECK_EQUAL((b + a >= 72), true);
2762 BOOST_CHECK_EQUAL((b + a > 72), false);
2763 BOOST_CHECK_EQUAL((b + a <= 72), true);
2764 BOOST_CHECK_EQUAL((b + a < 72), false);
2765
2766 T c;
2767 //
2768 // min and max overloads:
2769 //
2770 #if !defined(min) && !defined(max)
2771 // using std::max;
2772 // using std::min;
2773 // This works, but still causes complaints from inspect.exe, so use brackets to prevent macrosubstitution,
2774 // and to explicitly specify type T seems necessary, for reasons unclear.
2775 a = 2;
2776 b = 5;
2777 c = 6;
2778 BOOST_CHECK_EQUAL((std::min<T>)(a, b), a);
2779 BOOST_CHECK_EQUAL((std::min<T>)(b, a), a);
2780 BOOST_CHECK_EQUAL((std::max<T>)(a, b), b);
2781 BOOST_CHECK_EQUAL((std::max<T>)(b, a), b);
2782 BOOST_CHECK_EQUAL((std::min<T>)(a, b + c), a);
2783 BOOST_CHECK_EQUAL((std::min<T>)(b + c, a), a);
2784 BOOST_CHECK_EQUAL((std::min<T>)(a, c - b), 1);
2785 BOOST_CHECK_EQUAL((std::min<T>)(c - b, a), 1);
2786 BOOST_CHECK_EQUAL((std::max<T>)(a, b + c), 11);
2787 BOOST_CHECK_EQUAL((std::max<T>)(b + c, a), 11);
2788 BOOST_CHECK_EQUAL((std::max<T>)(a, c - b), a);
2789 BOOST_CHECK_EQUAL((std::max<T>)(c - b, a), a);
2790 BOOST_CHECK_EQUAL((std::min<T>)(a + b, b + c), 7);
2791 BOOST_CHECK_EQUAL((std::min<T>)(b + c, a + b), 7);
2792 BOOST_CHECK_EQUAL((std::max<T>)(a + b, b + c), 11);
2793 BOOST_CHECK_EQUAL((std::max<T>)(b + c, a + b), 11);
2794 BOOST_CHECK_EQUAL((std::min<T>)(a + b, c - a), 4);
2795 BOOST_CHECK_EQUAL((std::min<T>)(c - a, a + b), 4);
2796 BOOST_CHECK_EQUAL((std::max<T>)(a + b, c - a), 7);
2797 BOOST_CHECK_EQUAL((std::max<T>)(c - a, a + b), 7);
2798
2799 long l1(2), l2(3), l3;
2800 l3 = (std::min)(l1, l2) + (std::max)(l1, l2) + (std::max<long>)(l1, l2) + (std::min<long>)(l1, l2);
2801 BOOST_CHECK_EQUAL(l3, 10);
2802
2803 #endif
2804 }
2805
2806 template <class T>
self(const T & a)2807 const T& self(const T& a) { return a; }
2808
2809 template <class Real>
test()2810 void test()
2811 {
2812 #if !defined(NO_MIXED_OPS) && !defined(SLOW_COMPILER)
2813 boost::multiprecision::is_number<Real> tag;
2814 test_mixed<Real, unsigned char>(tag);
2815 test_mixed<Real, signed char>(tag);
2816 test_mixed<Real, char>(tag);
2817 test_mixed<Real, short>(tag);
2818 test_mixed<Real, unsigned short>(tag);
2819 test_mixed<Real, int>(tag);
2820 test_mixed<Real, unsigned int>(tag);
2821 test_mixed<Real, long>(tag);
2822 test_mixed<Real, unsigned long>(tag);
2823 #ifdef BOOST_HAS_LONG_LONG
2824 test_mixed<Real, long long>(tag);
2825 test_mixed<Real, unsigned long long>(tag);
2826 #endif
2827 test_mixed<Real, float>(tag);
2828 test_mixed<Real, double>(tag);
2829 test_mixed<Real, long double>(tag);
2830
2831 typedef typename related_type<Real>::type related_type;
2832 boost::mpl::bool_<boost::multiprecision::is_number<Real>::value && !boost::is_same<related_type, Real>::value> tag2;
2833
2834 test_mixed<Real, related_type>(tag2);
2835
2836 boost::mpl::bool_<boost::multiprecision::is_number<Real>::value && (boost::multiprecision::number_category<Real>::value == boost::multiprecision::number_kind_complex)> complex_tag;
2837 test_mixed<Real, std::complex<float> >(complex_tag);
2838 test_mixed<Real, std::complex<double> >(complex_tag);
2839 test_mixed<Real, std::complex<long double> >(complex_tag);
2840
2841 #endif
2842 #ifndef MIXED_OPS_ONLY
2843 //
2844 // Integer only functions:
2845 //
2846 test_integer_ops<Real>(typename boost::multiprecision::number_category<Real>::type());
2847 //
2848 // Real number only functions:
2849 //
2850 test_float_ops<Real>(typename boost::multiprecision::number_category<Real>::type());
2851 //
2852 // Test basic arithmetic:
2853 //
2854 Real a(8);
2855 Real b(64);
2856 Real c(500);
2857 Real d(1024);
2858 BOOST_CHECK_EQUAL(a + b, 72);
2859 a += b;
2860 BOOST_CHECK_EQUAL(a, 72);
2861 BOOST_CHECK_EQUAL(a - b, 8);
2862 a -= b;
2863 BOOST_CHECK_EQUAL(a, 8);
2864 BOOST_CHECK_EQUAL(a * b, 8 * 64L);
2865 a *= b;
2866 BOOST_CHECK_EQUAL(a, 8 * 64L);
2867 BOOST_CHECK_EQUAL(a / b, 8);
2868 a /= b;
2869 BOOST_CHECK_EQUAL(a, 8);
2870 Real ac(a);
2871 BOOST_CHECK_EQUAL(ac, a);
2872 ac = a * c;
2873 BOOST_CHECK_EQUAL(ac, 8 * 500L);
2874 ac = 8 * 500L;
2875 ac = ac + b + c;
2876 BOOST_CHECK_EQUAL(ac, 8 * 500L + 64 + 500);
2877 ac = a;
2878 ac = b + c + ac;
2879 BOOST_CHECK_EQUAL(ac, 8 + 64 + 500);
2880 ac = ac - b + c;
2881 BOOST_CHECK_EQUAL(ac, 8 + 64 + 500 - 64 + 500);
2882 ac = a;
2883 ac = b + c - ac;
2884 BOOST_CHECK_EQUAL(ac, -8 + 64 + 500);
2885 ac = a;
2886 ac = ac * b;
2887 BOOST_CHECK_EQUAL(ac, 8 * 64);
2888 ac = a;
2889 ac *= b * ac;
2890 BOOST_CHECK_EQUAL(ac, 8 * 8 * 64);
2891 ac = b;
2892 ac = ac / a;
2893 BOOST_CHECK_EQUAL(ac, 64 / 8);
2894 ac = b;
2895 ac /= ac / a;
2896 BOOST_CHECK_EQUAL(ac, 64 / (64 / 8));
2897 ac = a;
2898 ac = b + ac * a;
2899 BOOST_CHECK_EQUAL(ac, 64 * 2);
2900 ac = a;
2901 ac = b - ac * a;
2902 BOOST_CHECK_EQUAL(ac, 0);
2903 ac = a;
2904 ac = b * (ac + a);
2905 BOOST_CHECK_EQUAL(ac, 64 * (16));
2906 ac = a;
2907 ac = b / (ac * 1);
2908 BOOST_CHECK_EQUAL(ac, 64 / 8);
2909 ac = a;
2910 ac = ac + b;
2911 BOOST_CHECK_EQUAL(ac, 8 + 64);
2912 ac = a;
2913 ac = a + ac;
2914 BOOST_CHECK_EQUAL(ac, 16);
2915 ac = a;
2916 ac = a - ac;
2917 BOOST_CHECK_EQUAL(ac, 0);
2918 ac = a;
2919 ac += a + b;
2920 BOOST_CHECK_EQUAL(ac, 80);
2921 ac = a;
2922 ac += b + a;
2923 BOOST_CHECK_EQUAL(ac, 80);
2924 ac = +a;
2925 BOOST_CHECK_EQUAL(ac, 8);
2926 ac = 8;
2927 ac = a * ac;
2928 BOOST_CHECK_EQUAL(ac, 8 * 8);
2929 ac = a;
2930 ac = a;
2931 ac += +a;
2932 BOOST_CHECK_EQUAL(ac, 16);
2933 ac = a;
2934 ac += b - a;
2935 BOOST_CHECK_EQUAL(ac, 8 + 64 - 8);
2936 ac = a;
2937 ac += b * c;
2938 BOOST_CHECK_EQUAL(ac, 8 + 64 * 500);
2939 ac = a;
2940 ac = a;
2941 ac -= +a;
2942 BOOST_CHECK_EQUAL(ac, 0);
2943 ac = a;
2944 if (std::numeric_limits<Real>::is_signed || is_twos_complement_integer<Real>::value)
2945 {
2946 ac = a;
2947 ac -= c - b;
2948 BOOST_CHECK_EQUAL(ac, 8 - (500 - 64));
2949 ac = a;
2950 ac -= b * c;
2951 BOOST_CHECK_EQUAL(ac, 8 - 500 * 64);
2952 }
2953 ac = a;
2954 ac += ac * b;
2955 BOOST_CHECK_EQUAL(ac, 8 + 8 * 64);
2956 if (std::numeric_limits<Real>::is_signed || is_twos_complement_integer<Real>::value)
2957 {
2958 ac = a;
2959 ac -= ac * b;
2960 BOOST_CHECK_EQUAL(ac, 8 - 8 * 64);
2961 }
2962 ac = a * 8;
2963 ac *= +a;
2964 BOOST_CHECK_EQUAL(ac, 64 * 8);
2965 ac = a;
2966 ac *= b * c;
2967 BOOST_CHECK_EQUAL(ac, 8 * 64 * 500);
2968 ac = a;
2969 ac *= b / a;
2970 BOOST_CHECK_EQUAL(ac, 8 * 64 / 8);
2971 ac = a;
2972 ac *= b + c;
2973 BOOST_CHECK_EQUAL(ac, 8 * (64 + 500));
2974 ac = b;
2975 ac /= +a;
2976 BOOST_CHECK_EQUAL(ac, 8);
2977 ac = b;
2978 ac /= b / a;
2979 BOOST_CHECK_EQUAL(ac, 64 / (64 / 8));
2980 ac = b;
2981 ac /= a + Real(0);
2982 BOOST_CHECK_EQUAL(ac, 8);
2983 //
2984 // simple tests with immediate values, these calls can be optimised in many backends:
2985 //
2986 ac = a + b;
2987 BOOST_CHECK_EQUAL(ac, 72);
2988 ac = a + +b;
2989 BOOST_CHECK_EQUAL(ac, 72);
2990 ac = +a + b;
2991 BOOST_CHECK_EQUAL(ac, 72);
2992 ac = +a + +b;
2993 BOOST_CHECK_EQUAL(ac, 72);
2994 ac = a;
2995 ac = b / ac;
2996 BOOST_CHECK_EQUAL(ac, b / a);
2997 //
2998 // Comparisons:
2999 //
3000 test_relationals(a, b);
3001 test_members(a);
3002 //
3003 // Use in Boolean context:
3004 //
3005 a = 0;
3006 b = 2;
3007 test_basic_conditionals(a, b);
3008 //
3009 // Test iostreams:
3010 //
3011 std::stringstream ss;
3012 a = 20;
3013 b = 2;
3014 ss << a;
3015 ss >> c;
3016 BOOST_CHECK_EQUAL(a, c);
3017 ss.clear();
3018 ss << a + b;
3019 ss >> c;
3020 BOOST_CHECK_EQUAL(c, 22);
3021 BOOST_CHECK_EQUAL(c, a + b);
3022 //
3023 // More cases for complete code coverage:
3024 //
3025 a = 20;
3026 b = 30;
3027 swap(a, b);
3028 BOOST_CHECK_EQUAL(a, 30);
3029 BOOST_CHECK_EQUAL(b, 20);
3030 a = 20;
3031 b = 30;
3032 std::swap(a, b);
3033 BOOST_CHECK_EQUAL(a, 30);
3034 BOOST_CHECK_EQUAL(b, 20);
3035 a = 20;
3036 b = 30;
3037 a = a + b * 2;
3038 BOOST_CHECK_EQUAL(a, 20 + 30 * 2);
3039 a = 100;
3040 a = a - b * 2;
3041 BOOST_CHECK_EQUAL(a, 100 - 30 * 2);
3042 a = 20;
3043 a = a * (b + 2);
3044 BOOST_CHECK_EQUAL(a, 20 * (32));
3045 a = 20;
3046 a = (b + 2) * a;
3047 BOOST_CHECK_EQUAL(a, 20 * (32));
3048 a = 90;
3049 b = 2;
3050 a = a / (b + 0);
3051 BOOST_CHECK_EQUAL(a, 45);
3052 a = 20;
3053 b = 30;
3054 c = (a * b) + 22;
3055 BOOST_CHECK_EQUAL(c, 20 * 30 + 22);
3056 c = 22 + (a * b);
3057 BOOST_CHECK_EQUAL(c, 20 * 30 + 22);
3058 c = 10;
3059 ac = a + b * c;
3060 BOOST_CHECK_EQUAL(ac, 20 + 30 * 10);
3061 ac = b * c + a;
3062 BOOST_CHECK_EQUAL(ac, 20 + 30 * 10);
3063 a = a + b * c;
3064 BOOST_CHECK_EQUAL(a, 20 + 30 * 10);
3065 a = 20;
3066 b = a + b * c;
3067 BOOST_CHECK_EQUAL(b, 20 + 30 * 10);
3068 b = 30;
3069 c = a + b * c;
3070 BOOST_CHECK_EQUAL(c, 20 + 30 * 10);
3071 c = 10;
3072 c = a + b / c;
3073 BOOST_CHECK_EQUAL(c, 20 + 30 / 10);
3074 //
3075 // Additional tests for rvalue ref overloads:
3076 //
3077 a = 3;
3078 b = 4;
3079 c = Real(2) + a;
3080 BOOST_CHECK_EQUAL(c, 5);
3081 c = a + Real(2);
3082 BOOST_CHECK_EQUAL(c, 5);
3083 c = Real(3) + Real(2);
3084 BOOST_CHECK_EQUAL(c, 5);
3085 c = Real(2) + (a + b);
3086 BOOST_CHECK_EQUAL(c, 9);
3087 c = (a + b) + Real(2);
3088 BOOST_CHECK_EQUAL(c, 9);
3089 c = (a + b) + (a + b);
3090 BOOST_CHECK_EQUAL(c, 14);
3091 c = a * Real(4);
3092 BOOST_CHECK_EQUAL(c, 12);
3093 c = Real(3) * Real(4);
3094 BOOST_CHECK_EQUAL(c, 12);
3095 c = (a + b) * (a + b);
3096 BOOST_CHECK_EQUAL(c, 49);
3097 a = 2;
3098 c = b / Real(2);
3099 BOOST_CHECK_EQUAL(c, 2);
3100 c = Real(4) / a;
3101 BOOST_CHECK_EQUAL(c, 2);
3102 c = Real(4) / Real(2);
3103 BOOST_CHECK_EQUAL(c, 2);
3104 //
3105 // Test conditionals:
3106 //
3107 a = 20;
3108 test_conditional(a, +a);
3109 test_conditional(a, (a + 0));
3110
3111 test_signed_ops<Real>(boost::mpl::bool_<std::numeric_limits<Real>::is_signed>());
3112 //
3113 // Test hashing:
3114 //
3115 boost::hash<Real> hasher;
3116 std::size_t s = hasher(a);
3117 BOOST_CHECK_NE(s, 0);
3118 #ifndef BOOST_NO_CXX11_HDR_FUNCTIONAL
3119 std::hash<Real> hasher2;
3120 s = hasher2(a);
3121 BOOST_CHECK_NE(s, 0);
3122 #endif
3123
3124 //
3125 // Test move:
3126 //
3127 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
3128 Real m(static_cast<Real&&>(a));
3129 BOOST_CHECK_EQUAL(m, 20);
3130 // Move from already moved from object:
3131 Real m2(static_cast<Real&&>(a));
3132 // assign from moved from object
3133 // (may result in "a" being left in valid state as implementation artifact):
3134 c = static_cast<Real&&>(a);
3135 // assignment to moved-from objects:
3136 c = static_cast<Real&&>(m);
3137 BOOST_CHECK_EQUAL(c, 20);
3138 m2 = c;
3139 BOOST_CHECK_EQUAL(c, 20);
3140 // Destructor of "a" checks destruction of moved-from-object...
3141 Real m3(static_cast<Real&&>(a));
3142 #endif
3143 #ifndef BOOST_MP_NOT_TESTING_NUMBER
3144 //
3145 // string and string_view:
3146 //
3147 {
3148 std::string s1("2");
3149 Real x(s1);
3150 BOOST_CHECK_EQUAL(x, 2);
3151 s1 = "3";
3152 x.assign(s1);
3153 BOOST_CHECK_EQUAL(x, 3);
3154 #ifndef BOOST_NO_CXX17_HDR_STRING_VIEW
3155 s1 = "20";
3156 std::string_view v(s1.c_str(), 1);
3157 Real y(v);
3158 BOOST_CHECK_EQUAL(y, 2);
3159 std::string_view v2(s1.c_str(), 2);
3160 y.assign(v2);
3161 BOOST_CHECK_EQUAL(y, 20);
3162 #endif
3163 }
3164 #endif
3165 //
3166 // Bug cases, self assignment first:
3167 //
3168 a = 20;
3169 a = self(a);
3170 BOOST_CHECK_EQUAL(a, 20);
3171
3172 a = 2;
3173 a = a * a * a;
3174 BOOST_CHECK_EQUAL(a, 8);
3175 a = 2;
3176 a = a + a + a;
3177 BOOST_CHECK_EQUAL(a, 6);
3178 a = 2;
3179 a = a - a + a;
3180 BOOST_CHECK_EQUAL(a, 2);
3181 a = 2;
3182 a = a + a - a;
3183 BOOST_CHECK_EQUAL(a, 2);
3184 a = 2;
3185 a = a * a - a;
3186 BOOST_CHECK_EQUAL(a, 2);
3187 a = 2;
3188 a = a + a * a;
3189 BOOST_CHECK_EQUAL(a, 6);
3190 a = 2;
3191 a = (a + a) * a;
3192 BOOST_CHECK_EQUAL(a, 8);
3193 #endif
3194 }
3195