t-binary.cc revision 1.1.1.1 
1/* Test mp*_class binary expressions.
2
3Copyright 2001, 2002, 2003, 2008 Free Software Foundation, Inc.
4
5This file is part of the GNU MP Library.
6
7The GNU MP Library is free software; you can redistribute it and/or modify
8it under the terms of the GNU Lesser General Public License as published by
9the Free Software Foundation; either version 3 of the License, or (at your
10option) any later version.
11
12The GNU MP Library is distributed in the hope that it will be useful, but
13WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
15License for more details.
16
17You should have received a copy of the GNU Lesser General Public License
18along with the GNU MP Library.  If not, see http://www.gnu.org/licenses/.  */
19
20#include "config.h"
21
22#include <iostream>
23
24#include "gmp.h"
25#include "gmpxx.h"
26#include "gmp-impl.h"
27#include "tests.h"
28
29using namespace std;
30
31
32void
33check_mpz (void)
34{
35  // template <class T, class Op>
36  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, T>, Op> >
37  {
38    mpz_class a(1), b(2);
39    mpz_class c(a + b); ASSERT_ALWAYS(c == 3);
40  }
41  {
42    mpz_class a(3), b(4);
43    mpz_class c;
44    c = a * b; ASSERT_ALWAYS(c == 12);
45  }
46  {
47    mpz_class a(5), b(3);
48    mpz_class c;
49    c = a % b; ASSERT_ALWAYS(c == 2);
50  }
51
52  // template <class T, class U, class Op>
53  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, U, Op> >
54  {
55    mpz_class a(1);
56    signed int b = 3;
57    mpz_class c(a - b); ASSERT_ALWAYS(c == -2);
58  }
59  {
60    mpz_class a(-8);
61    unsigned int b = 2;
62    mpz_class c;
63    c = a / b; ASSERT_ALWAYS(c == -4);
64  }
65  {
66    mpz_class a(2);
67    double b = 3.0;
68    mpz_class c(a + b); ASSERT_ALWAYS(c == 5);
69  }
70  {
71    mpz_class a(4);
72    mpz_class b;
73    b = a + 0; ASSERT_ALWAYS(b == 4);
74  }
75
76  // template <class T, class U, class Op>
77  // __gmp_expr<T, __gmp_binary_expr<U, __gmp_expr<T, T>, Op> >
78  {
79    mpz_class a(3);
80    signed int b = 9;
81    mpz_class c(b / a); ASSERT_ALWAYS(c == 3);
82  }
83
84  // template <class T, class U, class V, class W, class Op>
85  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, Op> >
86  // type of result can't be mpz
87
88  // template <class T, class U, class V, class W, class Op>
89  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, W>, Op> >
90  // type of result can't be mpz
91
92  // template <class T, class U, class Op>
93  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, U>, Op> >
94  {
95    mpz_class a(3), b(4);
96    mpz_class c(a * (-b)); ASSERT_ALWAYS(c == -12);
97  }
98
99  // template <class T, class U, class Op>
100  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, T>, Op> >
101  {
102    mpz_class a(3), b(2), c(1);
103    mpz_class d;
104    d = (a % b) + c; ASSERT_ALWAYS(d == 2);
105  }
106
107  // template <class T, class U, class V, class Op>
108  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, V, Op> >
109  {
110    mpz_class a(-5);
111    unsigned int b = 2;
112    mpz_class c((-a) << b); ASSERT_ALWAYS(c == 20);
113  }
114  {
115    mpz_class a(5), b(-4);
116    signed int c = 3;
117    mpz_class d;
118    d = (a * b) >> c; ASSERT_ALWAYS(d == -3);
119  }
120
121  // template <class T, class U, class V, class Op>
122  // __gmp_expr<T, __gmp_binary_expr<U, __gmp_expr<T, V>, Op> >
123  {
124    mpz_class a(2), b(4);
125    double c = 6;
126    mpz_class d(c / (a - b)); ASSERT_ALWAYS(d == -3);
127  }
128  {
129    mpz_class a(3), b(2);
130    double c = 1;
131    mpz_class d;
132    d = c + (a + b); ASSERT_ALWAYS(d == 6);
133  }
134
135  // template <class T, class U, class V, class W, class Op>
136  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, Op> >
137  // type of result can't be mpz
138
139  // template <class T, class U, class V, class W, class Op>
140  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, W>, Op> >
141  // type of result can't be mpz
142
143  // template <class T, class U, class V, class Op>
144  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, V>, Op> >
145  {
146    mpz_class a(3), b(5), c(7);
147    mpz_class d;
148    d = (a - b) * (-c); ASSERT_ALWAYS(d == 14);
149  }
150
151  {
152    mpz_class a(0xcafe), b(0xbeef), c, want;
153    c = a & b; ASSERT_ALWAYS (c == 0x8aee);
154    c = a | b; ASSERT_ALWAYS (c == 0xfeff);
155    c = a ^ b; ASSERT_ALWAYS (c == 0x7411);
156    c = a & 0xbeef; ASSERT_ALWAYS (c == 0x8aee);
157    c = a | 0xbeef; ASSERT_ALWAYS (c == 0xfeff);
158    c = a ^ 0xbeef; ASSERT_ALWAYS (c == 0x7411);
159    c = a & -0xbeef; ASSERT_ALWAYS (c == 0x4010);
160    c = a | -0xbeef; ASSERT_ALWAYS (c == -0x3401);
161    c = a ^ -0xbeef; ASSERT_ALWAYS (c == -0x7411);
162    c = a & 48879.0; ASSERT_ALWAYS (c == 0x8aee);
163    c = a | 48879.0; ASSERT_ALWAYS (c == 0xfeff);
164    c = a ^ 48879.0; ASSERT_ALWAYS (c == 0x7411);
165
166    c = a | 1267650600228229401496703205376.0; // 2^100
167    want = "0x1000000000000000000000cafe";
168    ASSERT_ALWAYS (c == want);
169  }
170
171}
172
173void
174check_mpq (void)
175{
176  // template <class T, class Op>
177  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, T>, Op> >
178  {
179    mpq_class a(1, 2), b(3, 4);
180    mpq_class c(a + b); ASSERT_ALWAYS(c == 1.25);
181  }
182
183  // template <class T, class U, class Op>
184  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, U, Op> >
185  {
186    mpq_class a(1, 2);
187    signed int b = 3;
188    mpq_class c(a - b); ASSERT_ALWAYS(c == -2.5);
189  }
190  {
191    mpq_class a(1, 2);
192    mpq_class b;
193    b = a + 0; ASSERT_ALWAYS(b == 0.5);
194  }
195
196  // template <class T, class U, class Op>
197  // __gmp_expr<T, __gmp_binary_expr<U, __gmp_expr<T, T>, Op> >
198  {
199    mpq_class a(2, 3);
200    signed int b = 4;
201    mpq_class c;
202    c = b / a; ASSERT_ALWAYS(c == 6);
203  }
204
205  // template <class T, class U, class V, class Op>
206  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<U, V>, Op> >
207  {
208    mpq_class a(1, 2);
209    mpz_class b(1);
210    mpq_class c(a + b); ASSERT_ALWAYS(c == 1.5);
211  }
212  {
213    mpq_class a(2, 3);
214    mpz_class b(1);
215    double c = 2.0;
216    mpq_class d;
217    d = a * (b + c); ASSERT_ALWAYS(d == 2);
218  }
219
220  // template <class T, class U, class V, class Op>
221  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, T>, Op> >
222  {
223    mpq_class a(2, 3);
224    mpz_class b(4);
225    mpq_class c(b / a); ASSERT_ALWAYS(c == 6);
226  }
227  {
228    mpq_class a(2, 3);
229    mpz_class b(1), c(4);
230    mpq_class d;
231    d = (b - c) * a; ASSERT_ALWAYS(d == -2);
232  }
233
234  // template <class T, class U, class Op>
235  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, U>, Op> >
236  {
237    mpq_class a(1, 3), b(3, 4);
238    mpq_class c;
239    c = a * (-b); ASSERT_ALWAYS(c == -0.25);
240  }
241
242  // template <class T, class U, class Op>
243  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, T>, Op> >
244  {
245    mpq_class a(1, 3), b(2, 3), c(1, 4);
246    mpq_class d((a / b) + c); ASSERT_ALWAYS(d == 0.75);
247  }
248
249  // template <class T, class U, class V, class Op>
250  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, V, Op> >
251  {
252    mpq_class a(3, 8);
253    unsigned int b = 4;
254    mpq_class c((-a) << b); ASSERT_ALWAYS(c == -6);
255  }
256
257  // template <class T, class U, class V, class Op>
258  // __gmp_expr<T, __gmp_binary_expr<U, __gmp_expr<T, V>, Op> >
259  {
260    mpq_class a(1, 2), b(1, 4);
261    double c = 6.0;
262    mpq_class d;
263    d = c / (a + b); ASSERT_ALWAYS(d == 8);
264  }
265
266  // template <class T, class U, class V, class W, class Op>
267  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, Op> >
268  {
269    mpq_class a(1, 2), b(1, 4);
270    mpz_class c(1);
271    mpq_class d((a + b) - c); ASSERT_ALWAYS(d == -0.25);
272  }
273  {
274    mpq_class a(1, 3), b(3, 2);
275    mpz_class c(2), d(4);
276    mpq_class e;
277    e = (a * b) / (c - d); ASSERT_ALWAYS(e == -0.25);
278  }
279
280  // template <class T, class U, class V, class W, class Op>
281  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, W>, Op> >
282  {
283    mpq_class a(1, 3), b(3, 4);
284    mpz_class c(-3);
285    mpq_class d(c * (a * b)); ASSERT_ALWAYS(d == -0.75);
286  }
287  {
288    mpq_class a(1, 3), b(3, 5);
289    mpz_class c(6);
290    signed int d = 4;
291    mpq_class e;
292    e = (c % d) / (a * b); ASSERT_ALWAYS(e == 10);
293  }
294
295  // template <class T, class U, class V, class Op>
296  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, V>, Op> >
297  {
298    mpq_class a(1, 3), b(3, 4), c(2, 5);
299    mpq_class d;
300    d = (a * b) / (-c); ASSERT_ALWAYS(d == -0.625);
301  }
302}
303
304void
305check_mpf (void)
306{
307  // template <class T, class Op>
308  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, T>, Op> >
309  {
310    mpf_class a(1), b(2);
311    mpf_class c(a + b); ASSERT_ALWAYS(c == 3);
312  }
313  {
314    mpf_class a(1.5), b(6);
315    mpf_class c;
316    c = a / b; ASSERT_ALWAYS(c == 0.25);
317  }
318
319  // template <class T, class U, class Op>
320  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, U, Op> >
321  {
322    mpf_class a(1);
323    signed int b = -2;
324    mpf_class c(a - b); ASSERT_ALWAYS(c == 3);
325  }
326  {
327    mpf_class a(2);
328    mpf_class b;
329    b = a + 0; ASSERT_ALWAYS(b == 2);
330  }
331
332  // template <class T, class U, class Op>
333  // __gmp_expr<T, __gmp_binary_expr<U, __gmp_expr<T, T>, Op> >
334  {
335    mpf_class a(2);
336    unsigned int b = 3;
337    mpf_class c;
338    c = b / a; ASSERT_ALWAYS(c == 1.5);
339  }
340
341  // template <class T, class U, class V, class Op>
342  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<U, V>, Op> >
343  {
344    mpf_class a(2);
345    mpz_class b(3);
346    mpf_class c(a - b); ASSERT_ALWAYS(c == -1);
347  }
348  {
349    mpf_class a(3);
350    mpz_class b(2), c(1);
351    mpf_class d;
352    d = a * (b + c); ASSERT_ALWAYS(d == 9);
353  }
354
355  // template <class T, class U, class V, class Op>
356  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, T>, Op> >
357  {
358    mpf_class a(6);
359    mpq_class b(3, 4);
360    mpf_class c(a * b); ASSERT_ALWAYS(c == 4.5);
361  }
362
363  // template <class T, class U, class Op>
364  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, U>, Op> >
365  {
366    mpf_class a(2), b(-3);
367    mpf_class c;
368    c = a * (-b); ASSERT_ALWAYS(c == 6);
369  }
370
371  // template <class T, class U, class Op>
372  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, T>, Op> >
373  {
374    mpf_class a(3), b(4), c(5);
375    mpf_class d;
376    d = (a / b) - c; ASSERT_ALWAYS(d == -4.25);
377  }
378
379  // template <class T, class U, class V, class Op>
380  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, V, Op> >
381  {
382    mpf_class a(3);
383    unsigned int b = 2;
384    mpf_class c((-a) >> b); ASSERT_ALWAYS(c == -0.75);
385  }
386
387  // template <class T, class U, class V, class Op>
388  // __gmp_expr<T, __gmp_binary_expr<U, __gmp_expr<T, V>, Op> >
389  {
390    mpf_class a(2), b(3);
391    double c = 5.0;
392    mpf_class d;
393    d = c / (a + b); ASSERT_ALWAYS(d == 1);
394  }
395
396  // template <class T, class U, class V, class W, class Op>
397  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, Op> >
398  {
399    mpf_class a(2), b(3);
400    mpz_class c(4);
401    mpf_class d;
402    d = (a + b) * c; ASSERT_ALWAYS(d == 20);
403  }
404  {
405    mpf_class a(2), b(3);
406    mpq_class c(1, 2), d(1, 4);
407    mpf_class e;
408    e = (a * b) / (c + d); ASSERT_ALWAYS(e == 8);
409  }
410
411  // template <class T, class U, class V, class W, class Op>
412  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, W>, Op> >
413  {
414    mpf_class a(1), b(2);
415    mpq_class c(3);
416    mpf_class d(c / (a + b)); ASSERT_ALWAYS(d == 1);
417  }
418  {
419    mpf_class a(1);
420    mpz_class b(2);
421    mpq_class c(3, 4);
422    mpf_class d;
423    d = (-c) + (a + b); ASSERT_ALWAYS(d == 2.25);
424  }
425
426  // template <class T, class U, class V, class Op>
427  // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, V>, Op> >
428  {
429    mpf_class a(1), b(2), c(3);
430    mpf_class d;
431    d = (a + b) * (-c); ASSERT_ALWAYS(d == -9);
432  }
433}
434
435
436int
437main (void)
438{
439  tests_start();
440
441  check_mpz();
442  check_mpq();
443  check_mpf();
444
445  tests_end();
446  return 0;
447}
448