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 //
7 // Compare arithmetic results using fixed_int to GMP results.
8 //
9
10 #ifdef _MSC_VER
11 #define _SCL_SECURE_NO_WARNINGS
12 #endif
13
14 //
15 // This ensures all our code gets tested, even though it may
16 // not be the fastest configuration in normal use:
17 //
18 #define BOOST_MP_USE_LIMB_SHIFT
19
20 #include <boost/multiprecision/gmp.hpp>
21 #include <boost/multiprecision/cpp_int.hpp>
22 #include <boost/random/mersenne_twister.hpp>
23 #include <boost/random/uniform_int.hpp>
24 #include <boost/timer.hpp>
25 #include "test.hpp"
26
27 #ifdef _MSC_VER
28 #pragma warning(disable : 4127) // Conditional expression is constant
29 #endif
30
31 #if !defined(TEST1) && !defined(TEST2) && !defined(TEST3) && !defined(TEST4) && !defined(TEST5) && !defined(TEST6)
32 #define TEST1
33 #define TEST2
34 #define TEST3
35 #define TEST4
36 #define TEST5
37 #define TEST6
38 #endif
39
40 template <class T>
generate_random(unsigned bits_wanted)41 T generate_random(unsigned bits_wanted)
42 {
43 static boost::random::mt19937 gen;
44 typedef boost::random::mt19937::result_type random_type;
45
46 T max_val;
47 unsigned digits;
48 if (std::numeric_limits<T>::is_bounded && (bits_wanted == (unsigned)std::numeric_limits<T>::digits))
49 {
50 max_val = (std::numeric_limits<T>::max)();
51 digits = std::numeric_limits<T>::digits;
52 }
53 else
54 {
55 max_val = T(1) << bits_wanted;
56 digits = bits_wanted;
57 }
58
59 unsigned bits_per_r_val = std::numeric_limits<random_type>::digits - 1;
60 while ((random_type(1) << bits_per_r_val) > (gen.max)())
61 --bits_per_r_val;
62
63 unsigned terms_needed = digits / bits_per_r_val + 1;
64
65 T val = 0;
66 for (unsigned i = 0; i < terms_needed; ++i)
67 {
68 val *= (gen.max)();
69 val += gen();
70 }
71 val %= max_val;
72 return val;
73 }
74
75 template <class T>
76 struct is_checked_cpp_int : public boost::mpl::false_
77 {};
78 template <unsigned MinBits, unsigned MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ET>
79 struct is_checked_cpp_int<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ET> > : public boost::mpl::true_
80 {};
81
82 template <class Number>
83 struct tester
84 {
85 typedef Number test_type;
86 typedef typename test_type::backend_type::checked_type checked;
87
88 unsigned last_error_count;
89 boost::timer tim;
90
91 boost::multiprecision::mpz_int a, b, c, d;
92 int si;
93 unsigned ui;
94 test_type a1, b1, c1, d1;
95
t1tester96 void t1()
97 {
98 using namespace boost::multiprecision;
99 BOOST_CHECK_EQUAL(a.str(), a1.str());
100 BOOST_CHECK_EQUAL(b.str(), b1.str());
101 BOOST_CHECK_EQUAL(c.str(), c1.str());
102 BOOST_CHECK_EQUAL(d.str(), d1.str());
103 BOOST_CHECK_EQUAL(mpz_int(a + b).str(), test_type(a1 + b1).str());
104 BOOST_CHECK_EQUAL((mpz_int(a) += b).str(), (test_type(a1) += b1).str());
105 BOOST_CHECK_EQUAL((mpz_int(b) += a).str(), (test_type(b1) += a1).str());
106 BOOST_CHECK_EQUAL(mpz_int(a - b).str(), test_type(a1 - b1).str());
107 BOOST_CHECK_EQUAL((mpz_int(a) -= b).str(), (test_type(a1) -= b1).str());
108 BOOST_CHECK_EQUAL(mpz_int(mpz_int(-a) + b).str(), test_type(test_type(-a1) + b1).str());
109 BOOST_CHECK_EQUAL(mpz_int(mpz_int(-a) - b).str(), test_type(test_type(-a1) - b1).str());
110 BOOST_CHECK_EQUAL(mpz_int(c * d).str(), test_type(c1 * d1).str());
111 BOOST_CHECK_EQUAL((mpz_int(c) *= d).str(), (test_type(c1) *= d1).str());
112 BOOST_CHECK_EQUAL((mpz_int(d) *= c).str(), (test_type(d1) *= c1).str());
113 BOOST_CHECK_EQUAL(mpz_int(c * -d).str(), test_type(c1 * -d1).str());
114 BOOST_CHECK_EQUAL(mpz_int(-c * d).str(), test_type(-c1 * d1).str());
115 BOOST_CHECK_EQUAL((mpz_int(c) *= -d).str(), (test_type(c1) *= -d1).str());
116 BOOST_CHECK_EQUAL((mpz_int(-d) *= c).str(), (test_type(-d1) *= c1).str());
117 BOOST_CHECK_EQUAL(mpz_int(b * c).str(), test_type(b1 * c1).str());
118 BOOST_CHECK_EQUAL(mpz_int(a / b).str(), test_type(a1 / b1).str());
119 BOOST_CHECK_EQUAL((mpz_int(a) /= b).str(), (test_type(a1) /= b1).str());
120 BOOST_CHECK_EQUAL(mpz_int(a / -b).str(), test_type(a1 / -b1).str());
121 BOOST_CHECK_EQUAL(mpz_int(-a / b).str(), test_type(-a1 / b1).str());
122 BOOST_CHECK_EQUAL((mpz_int(a) /= -b).str(), (test_type(a1) /= -b1).str());
123 BOOST_CHECK_EQUAL((mpz_int(-a) /= b).str(), (test_type(-a1) /= b1).str());
124 BOOST_CHECK_EQUAL(mpz_int(a / d).str(), test_type(a1 / d1).str());
125 BOOST_CHECK_EQUAL(mpz_int(a % b).str(), test_type(a1 % b1).str());
126 BOOST_CHECK_EQUAL((mpz_int(a) %= b).str(), (test_type(a1) %= b1).str());
127 BOOST_CHECK_EQUAL(mpz_int(a % -b).str(), test_type(a1 % -b1).str());
128 BOOST_CHECK_EQUAL((mpz_int(a) %= -b).str(), (test_type(a1) %= -b1).str());
129 BOOST_CHECK_EQUAL(mpz_int(-a % b).str(), test_type(-a1 % b1).str());
130 BOOST_CHECK_EQUAL((mpz_int(-a) %= b).str(), (test_type(-a1) %= b1).str());
131 BOOST_CHECK_EQUAL(mpz_int(a % d).str(), test_type(a1 % d1).str());
132 BOOST_CHECK_EQUAL((mpz_int(a) %= d).str(), (test_type(a1) %= d1).str());
133
134 if (!std::numeric_limits<test_type>::is_bounded)
135 {
136 test_type p = a1 * b1;
137 test_type r;
138 divide_qr(p, b1, p, r);
139 BOOST_CHECK_EQUAL(p, a1);
140 BOOST_CHECK_EQUAL(r, test_type(0));
141
142 p = a1 * d1;
143 divide_qr(p, d1, p, r);
144 BOOST_CHECK_EQUAL(p, a1);
145 BOOST_CHECK_EQUAL(r, test_type(0));
146
147 divide_qr(p, test_type(1), p, r);
148 BOOST_CHECK_EQUAL(p, a1);
149 BOOST_CHECK_EQUAL(r, test_type(0));
150 }
151 }
152
t2tester153 void t2()
154 {
155 using namespace boost::multiprecision;
156 // bitwise ops:
157 BOOST_CHECK_EQUAL(mpz_int(a | b).str(), test_type(a1 | b1).str());
158 BOOST_CHECK_EQUAL((mpz_int(a) |= b).str(), (test_type(a1) |= b1).str());
159 if (!is_checked_cpp_int<test_type>::value)
160 {
161 BOOST_CHECK_EQUAL(mpz_int(-a | b).str(), test_type(-a1 | b1).str());
162 BOOST_CHECK_EQUAL((mpz_int(-a) |= b).str(), (test_type(-a1) |= b1).str());
163 BOOST_CHECK_EQUAL(mpz_int(a | -b).str(), test_type(a1 | -b1).str());
164 BOOST_CHECK_EQUAL((mpz_int(a) |= -b).str(), (test_type(a1) |= -b1).str());
165 BOOST_CHECK_EQUAL(mpz_int(-a | -b).str(), test_type(-a1 | -b1).str());
166 BOOST_CHECK_EQUAL((mpz_int(-a) |= -b).str(), (test_type(-a1) |= -b1).str());
167 }
168 BOOST_CHECK_EQUAL(mpz_int(a & b).str(), test_type(a1 & b1).str());
169 BOOST_CHECK_EQUAL((mpz_int(a) &= b).str(), (test_type(a1) &= b1).str());
170 if (!is_checked_cpp_int<test_type>::value)
171 {
172 BOOST_CHECK_EQUAL(mpz_int(-a & b).str(), test_type(-a1 & b1).str());
173 BOOST_CHECK_EQUAL((mpz_int(-a) &= b).str(), (test_type(-a1) &= b1).str());
174 BOOST_CHECK_EQUAL(mpz_int(a & -b).str(), test_type(a1 & -b1).str());
175 BOOST_CHECK_EQUAL((mpz_int(a) &= -b).str(), (test_type(a1) &= -b1).str());
176 BOOST_CHECK_EQUAL(mpz_int(-a & -b).str(), test_type(-a1 & -b1).str());
177 BOOST_CHECK_EQUAL((mpz_int(-a) &= -b).str(), (test_type(-a1) &= -b1).str());
178 }
179 BOOST_CHECK_EQUAL(mpz_int(a ^ b).str(), test_type(a1 ^ b1).str());
180 BOOST_CHECK_EQUAL((mpz_int(a) ^= b).str(), (test_type(a1) ^= b1).str());
181 if (!is_checked_cpp_int<test_type>::value)
182 {
183 BOOST_CHECK_EQUAL(mpz_int(-a ^ b).str(), test_type(-a1 ^ b1).str());
184 BOOST_CHECK_EQUAL((mpz_int(-a) ^= b).str(), (test_type(-a1) ^= b1).str());
185 BOOST_CHECK_EQUAL(mpz_int(a ^ -b).str(), test_type(a1 ^ -b1).str());
186 BOOST_CHECK_EQUAL((mpz_int(a) ^= -b).str(), (test_type(a1) ^= -b1).str());
187 BOOST_CHECK_EQUAL(mpz_int(-a ^ -b).str(), test_type(-a1 ^ -b1).str());
188 BOOST_CHECK_EQUAL((mpz_int(-a) ^= -b).str(), (test_type(-a1) ^= -b1).str());
189 }
190 // Shift ops:
191 for (unsigned i = 0; i < 128; ++i)
192 {
193 if (!std::numeric_limits<test_type>::is_bounded)
194 {
195 BOOST_CHECK_EQUAL(mpz_int(a << i).str(), test_type(a1 << i).str());
196 BOOST_CHECK_EQUAL(mpz_int(-a << i).str(), test_type(-a1 << i).str());
197 }
198 else if (!is_checked_cpp_int<test_type>::value)
199 {
200 test_type t1(mpz_int(a << i).str());
201 test_type t2 = a1 << i;
202 BOOST_CHECK_EQUAL(t1, t2);
203 t1 = test_type(mpz_int(-a << i).str());
204 t2 = -a1 << i;
205 BOOST_CHECK_EQUAL(t1, t2);
206 }
207 BOOST_CHECK_EQUAL(mpz_int(a >> i).str(), test_type(a1 >> i).str());
208 if (!is_checked_cpp_int<test_type>::value)
209 {
210 BOOST_CHECK_EQUAL(mpz_int(-a >> i).str(), test_type(-a1 >> i).str());
211 }
212 }
213 // gcd/lcm
214 BOOST_CHECK_EQUAL(mpz_int(gcd(a, b)).str(), test_type(gcd(a1, b1)).str());
215 BOOST_CHECK_EQUAL(mpz_int(lcm(c, d)).str(), test_type(lcm(c1, d1)).str());
216 BOOST_CHECK_EQUAL(mpz_int(gcd(-a, b)).str(), test_type(gcd(-a1, b1)).str());
217 BOOST_CHECK_EQUAL(mpz_int(lcm(-c, d)).str(), test_type(lcm(-c1, d1)).str());
218 BOOST_CHECK_EQUAL(mpz_int(gcd(-a, -b)).str(), test_type(gcd(-a1, -b1)).str());
219 BOOST_CHECK_EQUAL(mpz_int(lcm(-c, -d)).str(), test_type(lcm(-c1, -d1)).str());
220 BOOST_CHECK_EQUAL(mpz_int(gcd(a, -b)).str(), test_type(gcd(a1, -b1)).str());
221 BOOST_CHECK_EQUAL(mpz_int(lcm(c, -d)).str(), test_type(lcm(c1, -d1)).str());
222 // Integer sqrt:
223 mpz_int r;
224 test_type r1;
225 BOOST_CHECK_EQUAL(sqrt(a, r).str(), sqrt(a1, r1).str());
226 BOOST_CHECK_EQUAL(r.str(), r1.str());
227 }
228
t3tester229 void t3()
230 {
231 using namespace boost::multiprecision;
232 // Now check operations involving signed integers:
233 BOOST_CHECK_EQUAL(mpz_int(a + si).str(), test_type(a1 + si).str());
234 BOOST_CHECK_EQUAL(mpz_int(a + -si).str(), test_type(a1 + -si).str());
235 BOOST_CHECK_EQUAL(mpz_int(-a + si).str(), test_type(-a1 + si).str());
236 BOOST_CHECK_EQUAL(mpz_int(si + a).str(), test_type(si + a1).str());
237 BOOST_CHECK_EQUAL((mpz_int(a) += si).str(), (test_type(a1) += si).str());
238 BOOST_CHECK_EQUAL((mpz_int(a) += -si).str(), (test_type(a1) += -si).str());
239 BOOST_CHECK_EQUAL((mpz_int(-a) += si).str(), (test_type(-a1) += si).str());
240 BOOST_CHECK_EQUAL((mpz_int(-a) += -si).str(), (test_type(-a1) += -si).str());
241 BOOST_CHECK_EQUAL(mpz_int(a - si).str(), test_type(a1 - si).str());
242 BOOST_CHECK_EQUAL(mpz_int(a - -si).str(), test_type(a1 - -si).str());
243 BOOST_CHECK_EQUAL(mpz_int(-a - si).str(), test_type(-a1 - si).str());
244 BOOST_CHECK_EQUAL(mpz_int(si - a).str(), test_type(si - a1).str());
245 BOOST_CHECK_EQUAL((mpz_int(a) -= si).str(), (test_type(a1) -= si).str());
246 BOOST_CHECK_EQUAL((mpz_int(a) -= -si).str(), (test_type(a1) -= -si).str());
247 BOOST_CHECK_EQUAL((mpz_int(-a) -= si).str(), (test_type(-a1) -= si).str());
248 BOOST_CHECK_EQUAL((mpz_int(-a) -= -si).str(), (test_type(-a1) -= -si).str());
249 BOOST_CHECK_EQUAL(mpz_int(b * si).str(), test_type(b1 * si).str());
250 BOOST_CHECK_EQUAL(mpz_int(b * -si).str(), test_type(b1 * -si).str());
251 BOOST_CHECK_EQUAL(mpz_int(-b * si).str(), test_type(-b1 * si).str());
252 BOOST_CHECK_EQUAL(mpz_int(si * b).str(), test_type(si * b1).str());
253 BOOST_CHECK_EQUAL((mpz_int(a) *= si).str(), (test_type(a1) *= si).str());
254 BOOST_CHECK_EQUAL((mpz_int(a) *= -si).str(), (test_type(a1) *= -si).str());
255 BOOST_CHECK_EQUAL((mpz_int(-a) *= si).str(), (test_type(-a1) *= si).str());
256 BOOST_CHECK_EQUAL((mpz_int(-a) *= -si).str(), (test_type(-a1) *= -si).str());
257 BOOST_CHECK_EQUAL(mpz_int(a / si).str(), test_type(a1 / si).str());
258 BOOST_CHECK_EQUAL(mpz_int(a / -si).str(), test_type(a1 / -si).str());
259 BOOST_CHECK_EQUAL(mpz_int(-a / si).str(), test_type(-a1 / si).str());
260 BOOST_CHECK_EQUAL((mpz_int(a) /= si).str(), (test_type(a1) /= si).str());
261 BOOST_CHECK_EQUAL((mpz_int(a) /= -si).str(), (test_type(a1) /= -si).str());
262 BOOST_CHECK_EQUAL((mpz_int(-a) /= si).str(), (test_type(-a1) /= si).str());
263 BOOST_CHECK_EQUAL((mpz_int(-a) /= -si).str(), (test_type(-a1) /= -si).str());
264 BOOST_CHECK_EQUAL(mpz_int(a % si).str(), test_type(a1 % si).str());
265 BOOST_CHECK_EQUAL(mpz_int(a % -si).str(), test_type(a1 % -si).str());
266 BOOST_CHECK_EQUAL(mpz_int(-a % si).str(), test_type(-a1 % si).str());
267 BOOST_CHECK_EQUAL((mpz_int(a) %= si).str(), (test_type(a1) %= si).str());
268 BOOST_CHECK_EQUAL((mpz_int(a) %= -si).str(), (test_type(a1) %= -si).str());
269 BOOST_CHECK_EQUAL((mpz_int(-a) %= si).str(), (test_type(-a1) %= si).str());
270 BOOST_CHECK_EQUAL((mpz_int(-a) %= -si).str(), (test_type(-a1) %= -si).str());
271 if ((si > 0) || !is_checked_cpp_int<test_type>::value)
272 {
273 BOOST_CHECK_EQUAL(mpz_int(a | si).str(), test_type(a1 | si).str());
274 BOOST_CHECK_EQUAL((mpz_int(a) |= si).str(), (test_type(a1) |= si).str());
275 BOOST_CHECK_EQUAL(mpz_int(a & si).str(), test_type(a1 & si).str());
276 BOOST_CHECK_EQUAL((mpz_int(a) &= si).str(), (test_type(a1) &= si).str());
277 BOOST_CHECK_EQUAL(mpz_int(a ^ si).str(), test_type(a1 ^ si).str());
278 BOOST_CHECK_EQUAL((mpz_int(a) ^= si).str(), (test_type(a1) ^= si).str());
279 BOOST_CHECK_EQUAL(mpz_int(si | a).str(), test_type(si | a1).str());
280 BOOST_CHECK_EQUAL(mpz_int(si & a).str(), test_type(si & a1).str());
281 BOOST_CHECK_EQUAL(mpz_int(si ^ a).str(), test_type(si ^ a1).str());
282 }
283 BOOST_CHECK_EQUAL(mpz_int(gcd(a, si)).str(), test_type(gcd(a1, si)).str());
284 BOOST_CHECK_EQUAL(mpz_int(gcd(si, b)).str(), test_type(gcd(si, b1)).str());
285 BOOST_CHECK_EQUAL(mpz_int(lcm(c, si)).str(), test_type(lcm(c1, si)).str());
286 BOOST_CHECK_EQUAL(mpz_int(lcm(si, d)).str(), test_type(lcm(si, d1)).str());
287 BOOST_CHECK_EQUAL(mpz_int(gcd(-a, si)).str(), test_type(gcd(-a1, si)).str());
288 BOOST_CHECK_EQUAL(mpz_int(gcd(-si, b)).str(), test_type(gcd(-si, b1)).str());
289 BOOST_CHECK_EQUAL(mpz_int(lcm(-c, si)).str(), test_type(lcm(-c1, si)).str());
290 BOOST_CHECK_EQUAL(mpz_int(lcm(-si, d)).str(), test_type(lcm(-si, d1)).str());
291 BOOST_CHECK_EQUAL(mpz_int(gcd(-a, -si)).str(), test_type(gcd(-a1, -si)).str());
292 BOOST_CHECK_EQUAL(mpz_int(gcd(-si, -b)).str(), test_type(gcd(-si, -b1)).str());
293 BOOST_CHECK_EQUAL(mpz_int(lcm(-c, -si)).str(), test_type(lcm(-c1, -si)).str());
294 BOOST_CHECK_EQUAL(mpz_int(lcm(-si, -d)).str(), test_type(lcm(-si, -d1)).str());
295 BOOST_CHECK_EQUAL(mpz_int(gcd(a, -si)).str(), test_type(gcd(a1, -si)).str());
296 BOOST_CHECK_EQUAL(mpz_int(gcd(si, -b)).str(), test_type(gcd(si, -b1)).str());
297 BOOST_CHECK_EQUAL(mpz_int(lcm(c, -si)).str(), test_type(lcm(c1, -si)).str());
298 BOOST_CHECK_EQUAL(mpz_int(lcm(si, -d)).str(), test_type(lcm(si, -d1)).str());
299 }
300
t4tester301 void t4()
302 {
303 using namespace boost::multiprecision;
304 // Now check operations involving unsigned integers:
305 BOOST_CHECK_EQUAL(mpz_int(a + ui).str(), test_type(a1 + ui).str());
306 BOOST_CHECK_EQUAL(mpz_int(-a + ui).str(), test_type(-a1 + ui).str());
307 BOOST_CHECK_EQUAL(mpz_int(ui + a).str(), test_type(ui + a1).str());
308 BOOST_CHECK_EQUAL((mpz_int(a) += ui).str(), (test_type(a1) += ui).str());
309 BOOST_CHECK_EQUAL((mpz_int(-a) += ui).str(), (test_type(-a1) += ui).str());
310 BOOST_CHECK_EQUAL(mpz_int(a - ui).str(), test_type(a1 - ui).str());
311 BOOST_CHECK_EQUAL(mpz_int(-a - ui).str(), test_type(-a1 - ui).str());
312 BOOST_CHECK_EQUAL(mpz_int(ui - a).str(), test_type(ui - a1).str());
313 BOOST_CHECK_EQUAL((mpz_int(a) -= ui).str(), (test_type(a1) -= ui).str());
314 BOOST_CHECK_EQUAL((mpz_int(-a) -= ui).str(), (test_type(-a1) -= ui).str());
315 BOOST_CHECK_EQUAL(mpz_int(b * ui).str(), test_type(b1 * ui).str());
316 BOOST_CHECK_EQUAL(mpz_int(-b * ui).str(), test_type(-b1 * ui).str());
317 BOOST_CHECK_EQUAL(mpz_int(ui * b).str(), test_type(ui * b1).str());
318 BOOST_CHECK_EQUAL((mpz_int(a) *= ui).str(), (test_type(a1) *= ui).str());
319 BOOST_CHECK_EQUAL((mpz_int(-a) *= ui).str(), (test_type(-a1) *= ui).str());
320 BOOST_CHECK_EQUAL(mpz_int(a / ui).str(), test_type(a1 / ui).str());
321 BOOST_CHECK_EQUAL(mpz_int(-a / ui).str(), test_type(-a1 / ui).str());
322 BOOST_CHECK_EQUAL((mpz_int(a) /= ui).str(), (test_type(a1) /= ui).str());
323 BOOST_CHECK_EQUAL((mpz_int(-a) /= ui).str(), (test_type(-a1) /= ui).str());
324 BOOST_CHECK_EQUAL(mpz_int(a % ui).str(), test_type(a1 % ui).str());
325 BOOST_CHECK_EQUAL(mpz_int(-a % ui).str(), test_type(-a1 % ui).str());
326 BOOST_CHECK_EQUAL((mpz_int(a) %= ui).str(), (test_type(a1) %= ui).str());
327 BOOST_CHECK_EQUAL((mpz_int(-a) %= ui).str(), (test_type(-a1) %= ui).str());
328 BOOST_CHECK_EQUAL(mpz_int(a | ui).str(), test_type(a1 | ui).str());
329 BOOST_CHECK_EQUAL((mpz_int(a) |= ui).str(), (test_type(a1) |= ui).str());
330 BOOST_CHECK_EQUAL(mpz_int(a & ui).str(), test_type(a1 & ui).str());
331 BOOST_CHECK_EQUAL((mpz_int(a) &= ui).str(), (test_type(a1) &= ui).str());
332 BOOST_CHECK_EQUAL(mpz_int(a ^ ui).str(), test_type(a1 ^ ui).str());
333 BOOST_CHECK_EQUAL((mpz_int(a) ^= ui).str(), (test_type(a1) ^= ui).str());
334 BOOST_CHECK_EQUAL(mpz_int(ui | a).str(), test_type(ui | a1).str());
335 BOOST_CHECK_EQUAL(mpz_int(ui & a).str(), test_type(ui & a1).str());
336 BOOST_CHECK_EQUAL(mpz_int(ui ^ a).str(), test_type(ui ^ a1).str());
337 BOOST_CHECK_EQUAL(mpz_int(gcd(a, ui)).str(), test_type(gcd(a1, ui)).str());
338 BOOST_CHECK_EQUAL(mpz_int(gcd(ui, b)).str(), test_type(gcd(ui, b1)).str());
339 BOOST_CHECK_EQUAL(mpz_int(lcm(c, ui)).str(), test_type(lcm(c1, ui)).str());
340 BOOST_CHECK_EQUAL(mpz_int(lcm(ui, d)).str(), test_type(lcm(ui, d1)).str());
341 BOOST_CHECK_EQUAL(mpz_int(gcd(-a, ui)).str(), test_type(gcd(-a1, ui)).str());
342 BOOST_CHECK_EQUAL(mpz_int(lcm(-c, ui)).str(), test_type(lcm(-c1, ui)).str());
343 BOOST_CHECK_EQUAL(mpz_int(gcd(ui, -b)).str(), test_type(gcd(ui, -b1)).str());
344 BOOST_CHECK_EQUAL(mpz_int(lcm(ui, -d)).str(), test_type(lcm(ui, -d1)).str());
345
346 if (std::numeric_limits<test_type>::is_modulo && checked::value)
347 {
348 static mpz_int m = mpz_int(1) << std::numeric_limits<test_type>::digits;
349 mpz_int t(a);
350 test_type t1(a1);
351 for (unsigned i = 0; i < 10; ++i)
352 {
353 t *= a;
354 t %= m;
355 t += a;
356 t %= m;
357 t1 *= a1;
358 t1 += a1;
359 }
360 BOOST_CHECK_EQUAL(t.str(), t1.str());
361 }
362 }
363
t5tester364 void t5()
365 {
366 using namespace boost::multiprecision;
367 //
368 // Now integer functions:
369 //
370 mpz_int z1, z2;
371 test_type t1, t2;
372 divide_qr(a, b, z1, z2);
373 divide_qr(a1, b1, t1, t2);
374 BOOST_CHECK_EQUAL(z1.str(), t1.str());
375 BOOST_CHECK_EQUAL(z2.str(), t2.str());
376 BOOST_CHECK_EQUAL(integer_modulus(a, si), integer_modulus(a1, si));
377 BOOST_CHECK_EQUAL(lsb(a), lsb(a1));
378 BOOST_CHECK_EQUAL(msb(a), msb(a1));
379
380 for (unsigned i = 0; i < 1000; i += 13)
381 {
382 BOOST_CHECK_EQUAL(bit_test(a, i), bit_test(a1, i));
383 }
384 if (!std::numeric_limits<test_type>::is_modulo)
385 {
386 // We have to take care that our powers don't grow too large, otherwise this takes "forever",
387 // also don't test for modulo types, as these may give a different result from arbitrary
388 // precision types:
389 BOOST_CHECK_EQUAL(mpz_int(pow(d, ui % 19)).str(), test_type(pow(d1, ui % 19)).str());
390 BOOST_CHECK_EQUAL(mpz_int(powm(a, b, c)).str(), test_type(powm(a1, b1, c1)).str());
391 BOOST_CHECK_EQUAL(mpz_int(powm(a, b, ui)).str(), test_type(powm(a1, b1, ui)).str());
392 BOOST_CHECK_EQUAL(mpz_int(powm(a, ui, c)).str(), test_type(powm(a1, ui, c1)).str());
393 }
394 BOOST_CHECK_EQUAL(lsb(a), lsb(a1));
395 BOOST_CHECK_EQUAL(msb(a), msb(a1));
396 }
397
test_bug_casestester398 static void test_bug_cases()
399 {
400 if (!std::numeric_limits<test_type>::is_bounded)
401 {
402 // https://svn.boost.org/trac/boost/ticket/7878
403 test_type a("0x1000000000000000000000000000000000000000000000000000000000000000");
404 test_type b = 0xFFFFFFFF;
405 test_type c = a * b + b; // quotient has 1 in the final place
406 test_type q, r;
407 divide_qr(c, b, q, r);
408 BOOST_CHECK_EQUAL(a + 1, q);
409 BOOST_CHECK_EQUAL(r, 0);
410
411 b = static_cast<test_type>("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
412 c = a * b + b; // quotient has 1 in the final place
413 divide_qr(c, b, q, r);
414 BOOST_CHECK_EQUAL(a + 1, q);
415 BOOST_CHECK_EQUAL(r, 0);
416 //
417 // Not a bug, but test some other special cases that don't otherwise occur through
418 // random testing:
419 //
420 c = a * b; // quotient has zero in the final place
421 divide_qr(c, b, q, r);
422 BOOST_CHECK_EQUAL(q, a);
423 BOOST_CHECK_EQUAL(r, 0);
424 divide_qr(c, a, q, r);
425 BOOST_CHECK_EQUAL(q, b);
426 BOOST_CHECK_EQUAL(r, 0);
427 ++c;
428 divide_qr(c, b, q, r);
429 BOOST_CHECK_EQUAL(q, a);
430 BOOST_CHECK_EQUAL(r, 1);
431 }
432 // Bug https://svn.boost.org/trac/boost/ticket/8126:
433 test_type a("-4294967296");
434 test_type b("4294967296");
435 test_type c("-1");
436 a = (a / b);
437 BOOST_CHECK_EQUAL(a, -1);
438 a = -4294967296;
439 a = (a / b) * c;
440 BOOST_CHECK_EQUAL(a, 1);
441 a = -23;
442 b = 23;
443 a = (a / b) * c;
444 BOOST_CHECK_EQUAL(a, 1);
445 a = -23;
446 a = (a / b) / c;
447 BOOST_CHECK_EQUAL(a, 1);
448 a = test_type("-26607734784073568386365259775");
449 b = test_type("8589934592");
450 a = a / b;
451 BOOST_CHECK_EQUAL(a, test_type("-3097548007973652377"));
452 // Bug https://svn.boost.org/trac/boost/ticket/8133:
453 a = test_type("0x12345600012434ffffffffffffffffffffffff");
454 unsigned ui = 0xffffffff;
455 a = a - ui;
456 BOOST_CHECK_EQUAL(a, test_type("0x12345600012434ffffffffffffffff00000000"));
457 a = test_type("0x12345600012434ffffffffffffffffffffffff");
458 #ifndef BOOST_NO_LONG_LONG
459 unsigned long long ull = 0xffffffffffffffffuLL;
460 a = a - ull;
461 BOOST_CHECK_EQUAL(a, test_type("0x12345600012434ffffffff0000000000000000"));
462 #endif
463 //
464 // Now check that things which should be zero really are
465 // https://svn.boost.org/trac/boost/ticket/8145:
466 //
467 a = -1;
468 a += 1;
469 BOOST_CHECK_EQUAL(a, 0);
470 a = 1;
471 a += -1;
472 BOOST_CHECK_EQUAL(a, 0);
473 a = -1;
474 a += test_type(1);
475 BOOST_CHECK_EQUAL(a, 0);
476 a = 1;
477 a += test_type(-1);
478 BOOST_CHECK_EQUAL(a, 0);
479 a = test_type("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
480 a -= test_type("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
481 BOOST_CHECK_EQUAL(a, 0);
482 a = -test_type("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
483 a += test_type("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
484 BOOST_CHECK_EQUAL(a, 0);
485 a = 2;
486 a *= 0;
487 BOOST_CHECK_EQUAL(a, 0);
488 a = -2;
489 a *= 0;
490 BOOST_CHECK_EQUAL(a, 0);
491 a = 2;
492 a *= test_type(0);
493 BOOST_CHECK_EQUAL(a, 0);
494 a = -2;
495 a *= test_type(0);
496 BOOST_CHECK_EQUAL(a, 0);
497 a = -2;
498 a /= 50;
499 BOOST_CHECK_EQUAL(a, 0);
500 a = -test_type("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
501 a /= (1 + test_type("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"));
502 BOOST_CHECK_EQUAL(a, 0);
503 // https://svn.boost.org/trac/boost/ticket/8160
504 a = 1;
505 a = 0 / test_type(1);
506 BOOST_CHECK_EQUAL(a, 0);
507 a = 1;
508 a = 0 % test_type(25);
509 BOOST_CHECK_EQUAL(a, 0);
510 #if !defined(TEST2) && !defined(TEST6)
511 // https://svn.boost.org/trac/boost/ticket/11364
512 a = 0xfffffffeu;
513 b = -2;
514 c = a ^ b;
515 test_type d = ~(a ^ ~b);
516 BOOST_CHECK_EQUAL(c, d);
517 #endif
518 #if defined(TEST2) || defined(TEST3) || defined(TEST6)
519 // https://svn.boost.org/trac/boost/ticket/11648
520 a = (std::numeric_limits<test_type>::max)() - 69;
521 b = a / 139;
522 ++b;
523 c = a / b;
524 test_type r = a % b;
525 BOOST_CHECK(r < b);
526 BOOST_CHECK_EQUAL(a - c * b, r);
527 #endif
528 for (ui = 0; ui < 1000; ++ui)
529 {
530 boost::multiprecision::mpz_int t;
531 boost::multiprecision::mpz_int s1 = sqrt(boost::multiprecision::mpz_int(ui), t);
532 a = sqrt(test_type(ui), b);
533 BOOST_CHECK_EQUAL(a.str(), s1.str());
534 BOOST_CHECK_EQUAL(b.str(), t.str());
535 }
536 a = -1;
537 ++a;
538 BOOST_CHECK_EQUAL(a, 0);
539 ++--a;
540 BOOST_CHECK_EQUAL(a, 0);
541 --++a;
542 BOOST_CHECK_EQUAL(a, 0);
543
544 {
545 typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<> > bigint;
546 //typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<64, 64, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void> > u64;
547 //typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<128, 128, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void> > u128;
548 typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<256, 256, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void> > u256;
549 typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<256, 256, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void> > s256;
550 //typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<160, 160, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void> > u160;
551 //typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<160, 160, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void> > s160;
552 //typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<512, 512, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void> > u512;
553 //typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<512, 512, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void> > s512;
554
555 {
556 u256 a = 14;
557 bigint b = bigint("115792089237316195423570985008687907853269984665640564039457584007913129639948");
558 // to fix cast `a` to dev::bigint
559 BOOST_CHECK(a < b);
560 }
561 {
562 u256 a = 1;
563 boost::uint64_t amount = 1;
564 u256 b = a << amount;
565 BOOST_CHECK_EQUAL(b, 2);
566
567 u256 high_bit = u256(0);
568 bit_set(high_bit, 255);
569 BOOST_CHECK_EQUAL(a << 255, high_bit);
570 BOOST_CHECK_EQUAL(a << boost::uint64_t(256), 0);
571 BOOST_CHECK_EQUAL(a << 0, a);
572
573 u256 c = 3;
574 BOOST_CHECK_EQUAL(c, 3);
575 BOOST_CHECK_EQUAL(c << boost::uint64_t(256), 0);
576 BOOST_CHECK_EQUAL(c << 0, c);
577
578 // Bug workaround:
579 BOOST_CHECK_EQUAL(static_cast<u256>(bigint(u256(3)) << 255), u256(1) << 255);
580 }
581 {
582 BOOST_CHECK_EQUAL(u256(3) << 255, u256(1) << 255);
583
584 u256 a = 1;
585 boost::uint64_t amount = 1;
586 u256 b = a >> amount;
587 BOOST_CHECK_EQUAL(b, 0);
588 BOOST_CHECK_EQUAL(a >> 255, 0);
589 BOOST_CHECK_EQUAL(a >> boost::uint64_t(256), 0);
590 BOOST_CHECK_EQUAL(a >> boost::uint64_t(-1), 0);
591
592 u256 h;
593 bit_set(h, 255);
594 BOOST_CHECK_EQUAL(h >> 0, u256(1) << 255);
595 BOOST_CHECK_EQUAL(h >> 1, u256(1) << 254);
596 BOOST_CHECK_EQUAL(h >> 2, u256(1) << 253);
597 BOOST_CHECK_EQUAL(h >> 254, u256(1) << 1);
598 BOOST_CHECK_EQUAL(h >> 255, u256(1) << 0);
599 BOOST_CHECK_EQUAL(h >> 256, 0);
600 BOOST_CHECK_EQUAL(h >> boost::uint64_t(-1), 0);
601
602 u256 g;
603 bit_set(g, 255);
604 bit_set(g, 254);
605 BOOST_CHECK_EQUAL(g >> 255, 1);
606 BOOST_CHECK_EQUAL(g >> 254, 3);
607 BOOST_CHECK_EQUAL(g >> 253, 3 << 1);
608 BOOST_CHECK_EQUAL(g >> 252, 3 << 2);
609 BOOST_CHECK_EQUAL(g >> 251, 3 << 3);
610 BOOST_CHECK_EQUAL(g >> 0, u256(3) << 254);
611 BOOST_CHECK_EQUAL(g >> 1, u256(3) << 253);
612 BOOST_CHECK_EQUAL(g >> 2, u256(3) << 252);
613 BOOST_CHECK_EQUAL(g >> 3, u256(3) << 251);
614 BOOST_CHECK_EQUAL(g >> 100, u256(3) << 154);
615 BOOST_CHECK_EQUAL(g >> 256, 0);
616 BOOST_CHECK_EQUAL(g >> 257, 0);
617 BOOST_CHECK_EQUAL(g >> boost::uint32_t(-1), 0);
618 BOOST_CHECK_EQUAL(g >> boost::uint64_t(-1), 0);
619 BOOST_CHECK_EQUAL(g >> boost::uint16_t(-1), 0);
620 BOOST_CHECK_EQUAL(g >> (boost::uint16_t(-1) - 1), 0);
621 }
622 {
623 s256 a = 1;
624 uint64_t amount = 1;
625 s256 b = a >> amount;
626 BOOST_CHECK_EQUAL(b, 0);
627 BOOST_CHECK_EQUAL(a >> 255, 0);
628 BOOST_CHECK_EQUAL(a >> boost::uint64_t(256), 0);
629 BOOST_CHECK_EQUAL(a >> boost::uint64_t(-1), 0);
630
631 s256 n = -1;
632 BOOST_CHECK_EQUAL(n >> 0, n);
633 BOOST_CHECK_EQUAL(n >> 1, n);
634 BOOST_CHECK_EQUAL(n >> 2, n);
635 BOOST_CHECK_EQUAL(n >> 254, n);
636 BOOST_CHECK_EQUAL(n >> 255, n);
637 BOOST_CHECK_EQUAL(n >> 256, n);
638 BOOST_CHECK_EQUAL(n >> 257, n);
639 BOOST_CHECK_EQUAL(n >> ~boost::uint64_t(0), n);
640
641 // Test min value. This actually -(2^256-1), not -(2^255) as in C.
642 s256 h = (std::numeric_limits<s256>::min)();
643 BOOST_CHECK_LT(h, 0);
644 BOOST_CHECK_EQUAL(h >> 0, h);
645 BOOST_CHECK_EQUAL(h >> 256, -1);
646
647 // Test EVM min value.
648 s256 g = s256(-1) << 255;
649 BOOST_CHECK_LT(g, 0);
650 BOOST_CHECK_EQUAL(static_cast<u256>(g), u256(1) << 255);
651 BOOST_CHECK_EQUAL(g >> 0, g);
652 BOOST_CHECK_EQUAL(static_cast<u256>(g >> 1), u256(0b11) << 254);
653 BOOST_CHECK_EQUAL(static_cast<u256>(g >> 2), u256(0b111) << 253);
654 BOOST_CHECK_EQUAL(static_cast<u256>(g >> 3), u256(0b1111) << 252);
655
656 BOOST_CHECK_EQUAL(static_cast<u256>(g >> 255), ~u256(0));
657 BOOST_CHECK_EQUAL(static_cast<u256>(g >> 254), ~u256(0b1));
658 BOOST_CHECK_EQUAL(static_cast<u256>(g >> 253), ~u256(0b11));
659
660 // Test shifting more that one bit.
661 s256 k = s256(0b111) << 252;
662 BOOST_CHECK_EQUAL(k, u256(0b111) << 252);
663 BOOST_CHECK_EQUAL(k >> 1, u256(0b111) << 251);
664 BOOST_CHECK_EQUAL(k >> 2, u256(0b111) << 250);
665 BOOST_CHECK_EQUAL(k >> 252, 0b111);
666 BOOST_CHECK_EQUAL(k >> 253, 0b11);
667 BOOST_CHECK_EQUAL(k >> 254, 0b1);
668 BOOST_CHECK_EQUAL(k >> 255, 0);
669 BOOST_CHECK_EQUAL(k >> 256, 0);
670 BOOST_CHECK_EQUAL(k >> ~boost::uint32_t(0), 0);
671
672 // Division equivalence.
673
674 // Built-in type:
675 if (std::numeric_limits<boost::int64_t>::is_specialized)
676 {
677 boost::int64_t d = (std::numeric_limits<boost::int64_t>::min)();
678 BOOST_CHECK_EQUAL(d >> 1, d / 2);
679 int64_t e = d + 1;
680 BOOST_CHECK_EQUAL(e >> 1, e / 2 - 1);
681
682 // Boost type:
683 BOOST_CHECK_EQUAL(h >> 1, h / 2 - 1);
684 }
685 }
686 }
687 }
688
testtester689 void test()
690 {
691 using namespace boost::multiprecision;
692
693 test_bug_cases();
694
695 last_error_count = 0;
696
697 BOOST_CHECK_EQUAL(Number(), 0);
698
699 for (int i = 0; i < 10000; ++i)
700 {
701 a = generate_random<mpz_int>(1000);
702 b = generate_random<mpz_int>(512);
703 c = generate_random<mpz_int>(256);
704 d = generate_random<mpz_int>(32);
705
706 si = d.convert_to<int>();
707 ui = si;
708
709 a1 = static_cast<test_type>(a.str());
710 b1 = static_cast<test_type>(b.str());
711 c1 = static_cast<test_type>(c.str());
712 d1 = static_cast<test_type>(d.str());
713
714 t1();
715 t2();
716 #ifndef SLOW_COMPILER
717 t3();
718 t4();
719 t5();
720 #endif
721
722 if (last_error_count != (unsigned)boost::detail::test_errors())
723 {
724 last_error_count = boost::detail::test_errors();
725 std::cout << std::hex << std::showbase;
726
727 std::cout << "a = " << a << std::endl;
728 std::cout << "a1 = " << a1 << std::endl;
729 std::cout << "b = " << b << std::endl;
730 std::cout << "b1 = " << b1 << std::endl;
731 std::cout << "c = " << c << std::endl;
732 std::cout << "c1 = " << c1 << std::endl;
733 std::cout << "d = " << d << std::endl;
734 std::cout << "d1 = " << d1 << std::endl;
735 std::cout << "a + b = " << a + b << std::endl;
736 std::cout << "a1 + b1 = " << a1 + b1 << std::endl;
737 std::cout << std::dec;
738 std::cout << "a - b = " << a - b << std::endl;
739 std::cout << "a1 - b1 = " << a1 - b1 << std::endl;
740 std::cout << "-a + b = " << mpz_int(-a) + b << std::endl;
741 std::cout << "-a1 + b1 = " << test_type(-a1) + b1 << std::endl;
742 std::cout << "-a - b = " << mpz_int(-a) - b << std::endl;
743 std::cout << "-a1 - b1 = " << test_type(-a1) - b1 << std::endl;
744 std::cout << "c*d = " << c * d << std::endl;
745 std::cout << "c1*d1 = " << c1 * d1 << std::endl;
746 std::cout << "b*c = " << b * c << std::endl;
747 std::cout << "b1*c1 = " << b1 * c1 << std::endl;
748 std::cout << "a/b = " << a / b << std::endl;
749 std::cout << "a1/b1 = " << a1 / b1 << std::endl;
750 std::cout << "a/d = " << a / d << std::endl;
751 std::cout << "a1/d1 = " << a1 / d1 << std::endl;
752 std::cout << "a%b = " << a % b << std::endl;
753 std::cout << "a1%b1 = " << a1 % b1 << std::endl;
754 std::cout << "a%d = " << a % d << std::endl;
755 std::cout << "a1%d1 = " << a1 % d1 << std::endl;
756 }
757
758 //
759 // Check to see if test is taking too long.
760 // Tests run on the compiler farm time out after 300 seconds,
761 // so don't get too close to that:
762 //
763 #ifndef CI_SUPPRESS_KNOWN_ISSUES
764 if (tim.elapsed() > 200)
765 #else
766 if (tim.elapsed() > 25)
767 #endif
768 {
769 std::cout << "Timeout reached, aborting tests now....\n";
770 break;
771 }
772 }
773 }
774 };
775
main()776 int main()
777 {
778 using namespace boost::multiprecision;
779
780 #ifdef TEST1
781 tester<cpp_int> t1;
782 t1.test();
783 #endif
784 #ifdef TEST2
785 tester<number<cpp_int_backend<2048, 2048, signed_magnitude, checked, void> > > t2;
786 t2.test();
787 #endif
788 #ifdef TEST3
789 // Unchecked test verifies modulo arithmetic:
790 tester<number<cpp_int_backend<2048, 2048, signed_magnitude, unchecked, void> > > t3;
791 t3.test();
792 #endif
793 #ifdef TEST4
794 tester<number<cpp_int_backend<0, 2048, signed_magnitude, unchecked, std::allocator<char> > > > t4;
795 t4.test();
796 #endif
797 #ifdef TEST5
798 tester<number<cpp_int_backend<0, 2048, signed_magnitude, unchecked> > > t5;
799 t5.test();
800 #endif
801 #ifdef TEST6
802 tester<number<cpp_int_backend<2048, 2048, signed_magnitude, checked, void> > > t6;
803 t6.test();
804 #endif
805 return boost::report_errors();
806 }
807