t-ops.cc revision 1.1.1.2 
1/* Test mp*_class operators and functions.
2
3Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
4
5This file is part of the GNU MP Library test suite.
6
7The GNU MP Library test suite is free software; you can redistribute it
8and/or modify it under the terms of the GNU General Public License as
9published by the Free Software Foundation; either version 3 of the License,
10or (at your option) any later version.
11
12The GNU MP Library test suite is distributed in the hope that it will be
13useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
15Public License for more details.
16
17You should have received a copy of the GNU General Public License along with
18the GNU MP Library test suite.  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  // unary operators and functions
36
37  // operator+
38  {
39    mpz_class a(1);
40    mpz_class b;
41    b = +a; ASSERT_ALWAYS(b == 1);
42  }
43
44  // operator-
45  {
46    mpz_class a(2);
47    mpz_class b;
48    b = -a; ASSERT_ALWAYS(b == -2);
49  }
50
51  // operator~
52  {
53    mpz_class a(3);
54    mpz_class b;
55    b = ~a; ASSERT_ALWAYS(b == -4);
56  }
57
58  // abs
59  {
60    mpz_class a(-123);
61    mpz_class b;
62    b = abs(a); ASSERT_ALWAYS(b == 123);
63    a <<= 300;
64    b = abs(a); ASSERT_ALWAYS(a + b == 0);
65  }
66
67  // sqrt
68  {
69    mpz_class a(25);
70    mpz_class b;
71    b = sqrt(a); ASSERT_ALWAYS(b == 5);
72  }
73  {
74    mpz_class a(125);
75    mpz_class b;
76    b = sqrt(a); ASSERT_ALWAYS(b == 11); // round toward zero
77  }
78
79  // sgn
80  {
81    mpz_class a(123);
82    int b = sgn(a); ASSERT_ALWAYS(b == 1);
83  }
84  {
85    mpz_class a(0);
86    int b = sgn(a); ASSERT_ALWAYS(b == 0);
87  }
88  {
89    mpz_class a(-123);
90    int b = sgn(a); ASSERT_ALWAYS(b == -1);
91  }
92
93
94  // binary operators and functions
95
96  // operator+
97  {
98    mpz_class a(1), b(2);
99    mpz_class c;
100    c = a + b; ASSERT_ALWAYS(c == 3);
101  }
102  {
103    mpz_class a(3);
104    signed int b = 4;
105    mpz_class c;
106    c = a + b; ASSERT_ALWAYS(c == 7);
107  }
108  {
109    mpz_class a(5);
110    double b = 6.0;
111    mpz_class c;
112    c = b + a; ASSERT_ALWAYS(c == 11);
113  }
114
115  // operator-
116  {
117    mpz_class a(3), b(6);
118    mpz_class c;
119    c = a - b; ASSERT_ALWAYS(c == -3);
120  }
121
122  // operator*
123  {
124    mpz_class a(-2), b(4);
125    mpz_class c;
126    c = a * b; ASSERT_ALWAYS(c == -8);
127  }
128  {
129    mpz_class a(2);
130    long b = -4;
131    mpz_class c;
132    c = a * b; ASSERT_ALWAYS(c == -8);
133    c = b * a; ASSERT_ALWAYS(c == -8);
134  }
135  {
136    mpz_class a(-2);
137    unsigned long b = 4;
138    mpz_class c;
139    c = a * b; ASSERT_ALWAYS(c == -8);
140    c = b * a; ASSERT_ALWAYS(c == -8);
141  }
142
143  // operator/ and operator%
144  {
145    mpz_class a(12), b(4);
146    mpz_class c;
147    c = a / b; ASSERT_ALWAYS(c == 3);
148    c = a % b; ASSERT_ALWAYS(c == 0);
149  }
150  {
151    mpz_class a(7), b(5);
152    mpz_class c;
153    c = a / b; ASSERT_ALWAYS(c == 1);
154    c = a % b; ASSERT_ALWAYS(c == 2);
155  }
156  {
157    mpz_class a(-10);
158    signed int ai = -10;
159    mpz_class b(3);
160    signed int bi = 3;
161    mpz_class c;
162    c = a / b;  ASSERT_ALWAYS(c == -3);
163    c = a % b;  ASSERT_ALWAYS(c == -1);
164    c = a / bi; ASSERT_ALWAYS(c == -3);
165    c = a % bi; ASSERT_ALWAYS(c == -1);
166    c = ai / b; ASSERT_ALWAYS(c == -3);
167    c = ai % b; ASSERT_ALWAYS(c == -1);
168  }
169  {
170    mpz_class a(-10);
171    signed int ai = -10;
172    mpz_class b(-3);
173    signed int bi = -3;
174    mpz_class c;
175    c = a / b;  ASSERT_ALWAYS(c == 3);
176    c = a % b;  ASSERT_ALWAYS(c == -1);
177    c = a / bi; ASSERT_ALWAYS(c == 3);
178    c = a % bi; ASSERT_ALWAYS(c == -1);
179    c = ai / b; ASSERT_ALWAYS(c == 3);
180    c = ai % b; ASSERT_ALWAYS(c == -1);
181  }
182  {
183    mpz_class a (LONG_MIN);
184    signed long ai = LONG_MIN;
185    mpz_class b = - mpz_class (LONG_MIN);
186    mpz_class c;
187    c = a / b;  ASSERT_ALWAYS(c == -1);
188    c = a % b;  ASSERT_ALWAYS(c == 0);
189    c = ai / b; ASSERT_ALWAYS(c == -1);
190    c = ai % b; ASSERT_ALWAYS(c == 0);
191  }
192
193  // operator&
194  // operator|
195  // operator^
196
197  // operator<<
198  {
199    mpz_class a(3);
200    unsigned int b = 4;
201    mpz_class c;
202    c = a << b; ASSERT_ALWAYS(c == 48);
203  }
204
205  // operator>>
206  {
207    mpz_class a(127);
208    unsigned int b = 4;
209    mpz_class c;
210    c = a >> b; ASSERT_ALWAYS(c == 7);
211  }
212
213  // operator==
214  // operator!=
215  // operator<
216  // operator<=
217  // operator>
218  // operator>=
219
220  // cmp
221  {
222    mpz_class a(123), b(45);
223    int c;
224    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
225    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
226  }
227  {
228    mpz_class a(123);
229    unsigned long b = 45;
230    int c;
231    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
232    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
233  }
234  {
235    mpz_class a(123);
236    long b = 45;
237    int c;
238    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
239    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
240  }
241  {
242    mpz_class a(123);
243    double b = 45;
244    int c;
245    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
246    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
247  }
248
249
250  // ternary operators
251
252  // mpz_addmul
253  {
254    mpz_class a(1), b(2), c(3);
255    mpz_class d;
256    d = a + b * c; ASSERT_ALWAYS(d == 7);
257  }
258  {
259    mpz_class a(1), b(2);
260    unsigned int c = 3;
261    mpz_class d;
262    d = a + b * c; ASSERT_ALWAYS(d == 7);
263  }
264  {
265    mpz_class a(1), b(3);
266    unsigned int c = 2;
267    mpz_class d;
268    d = a + c * b; ASSERT_ALWAYS(d == 7);
269  }
270  {
271    mpz_class a(1), b(2);
272    signed int c = 3;
273    mpz_class d;
274    d = a + b * c; ASSERT_ALWAYS(d == 7);
275  }
276  {
277    mpz_class a(1), b(3);
278    signed int c = 2;
279    mpz_class d;
280    d = a + c * b; ASSERT_ALWAYS(d == 7);
281  }
282  {
283    mpz_class a(1), b(2);
284    double c = 3.0;
285    mpz_class d;
286    d = a + b * c; ASSERT_ALWAYS(d == 7);
287  }
288  {
289    mpz_class a(1), b(3);
290    double c = 2.0;
291    mpz_class d;
292    d = a + c * b; ASSERT_ALWAYS(d == 7);
293  }
294
295  {
296    mpz_class a(2), b(3), c(4);
297    mpz_class d;
298    d = a * b + c; ASSERT_ALWAYS(d == 10);
299  }
300  {
301    mpz_class a(2), b(4);
302    unsigned int c = 3;
303    mpz_class d;
304    d = a * c + b; ASSERT_ALWAYS(d == 10);
305  }
306  {
307    mpz_class a(3), b(4);
308    unsigned int c = 2;
309    mpz_class d;
310    d = c * a + b; ASSERT_ALWAYS(d == 10);
311  }
312  {
313    mpz_class a(2), b(4);
314    signed int c = 3;
315    mpz_class d;
316    d = a * c + b; ASSERT_ALWAYS(d == 10);
317  }
318  {
319    mpz_class a(3), b(4);
320    signed int c = 2;
321    mpz_class d;
322    d = c * a + b; ASSERT_ALWAYS(d == 10);
323  }
324  {
325    mpz_class a(2), b(4);
326    double c = 3.0;
327    mpz_class d;
328    d = a * c + b; ASSERT_ALWAYS(d == 10);
329  }
330  {
331    mpz_class a(3), b(4);
332    double c = 2.0;
333    mpz_class d;
334    d = c * a + b; ASSERT_ALWAYS(d == 10);
335  }
336
337  // mpz_submul
338  {
339    mpz_class a(1), b(2), c(3);
340    mpz_class d;
341    d = a - b * c; ASSERT_ALWAYS(d == -5);
342  }
343  {
344    mpz_class a(1), b(2);
345    unsigned int c = 3;
346    mpz_class d;
347    d = a - b * c; ASSERT_ALWAYS(d == -5);
348  }
349  {
350    mpz_class a(1), b(3);
351    unsigned int c = 2;
352    mpz_class d;
353    d = a - c * b; ASSERT_ALWAYS(d == -5);
354  }
355  {
356    mpz_class a(1), b(2);
357    signed int c = 3;
358    mpz_class d;
359    d = a - b * c; ASSERT_ALWAYS(d == -5);
360  }
361  {
362    mpz_class a(1), b(3);
363    signed int c = 2;
364    mpz_class d;
365    d = a - c * b; ASSERT_ALWAYS(d == -5);
366  }
367  {
368    mpz_class a(1), b(2);
369    double c = 3.0;
370    mpz_class d;
371    d = a - b * c; ASSERT_ALWAYS(d == -5);
372  }
373  {
374    mpz_class a(1), b(3);
375    double c = 2.0;
376    mpz_class d;
377    d = a - c * b; ASSERT_ALWAYS(d == -5);
378  }
379
380  {
381    mpz_class a(2), b(3), c(4);
382    mpz_class d;
383    d = a * b - c; ASSERT_ALWAYS(d == 2);
384  }
385  {
386    mpz_class a(2), b(4);
387    unsigned int c = 3;
388    mpz_class d;
389    d = a * c - b; ASSERT_ALWAYS(d == 2);
390  }
391  {
392    mpz_class a(3), b(4);
393    unsigned int c = 2;
394    mpz_class d;
395    d = c * a - b; ASSERT_ALWAYS(d == 2);
396  }
397  {
398    mpz_class a(2), b(4);
399    signed int c = 3;
400    mpz_class d;
401    d = a * c - b; ASSERT_ALWAYS(d == 2);
402  }
403  {
404    mpz_class a(3), b(4);
405    signed int c = 2;
406    mpz_class d;
407    d = c * a - b; ASSERT_ALWAYS(d == 2);
408  }
409  {
410    mpz_class a(2), b(4);
411    double c = 3.0;
412    mpz_class d;
413    d = a * c - b; ASSERT_ALWAYS(d == 2);
414  }
415  {
416    mpz_class a(3), b(4);
417    double c = 2.0;
418    mpz_class d;
419    d = c * a - b; ASSERT_ALWAYS(d == 2);
420  }
421}
422
423void
424check_mpq (void)
425{
426  // unary operators and functions
427
428  // operator+
429  {
430    mpq_class a(1, 2);
431    mpq_class b;
432    b = +a; ASSERT_ALWAYS(b == 0.5);
433  }
434
435  // operator-
436  {
437    mpq_class a(3, 4);
438    mpq_class b;
439    b = -a; ASSERT_ALWAYS(b == -0.75);
440  }
441
442  // abs
443  {
444    mpq_class a(-123);
445    mpq_class b;
446    b = abs(a); ASSERT_ALWAYS(b == 123);
447  }
448
449  // sgn
450  {
451    mpq_class a(123);
452    int b = sgn(a); ASSERT_ALWAYS(b == 1);
453  }
454  {
455    mpq_class a(0);
456    int b = sgn(a); ASSERT_ALWAYS(b == 0);
457  }
458  {
459    mpq_class a(-123);
460    int b = sgn(a); ASSERT_ALWAYS(b == -1);
461  }
462
463
464  // binary operators and functions
465
466  // operator+
467  {
468    mpq_class a(1, 2), b(3, 4);
469    mpq_class c;
470    c = a + b; ASSERT_ALWAYS(c == 1.25);
471  }
472  {
473    mpq_class a(1, 2);
474    signed int b = 2;
475    mpq_class c;
476    c = a + b; ASSERT_ALWAYS(c == 2.5);
477  }
478  {
479    mpq_class a(1, 2);
480    double b = 1.5;
481    mpq_class c;
482    c = b + a; ASSERT_ALWAYS(c == 2);
483  }
484
485  // operator-
486  {
487    mpq_class a(1, 2), b(3, 4);
488    mpq_class c;
489    c = a - b; ASSERT_ALWAYS(c == -0.25);
490  }
491
492  // operator*
493  {
494    mpq_class a(1, 3), b(3, 4);
495    mpq_class c;
496    c = a * b; ASSERT_ALWAYS(c == 0.25);
497    c = b * b; ASSERT_ALWAYS(c == 0.5625);
498  }
499
500  // operator/
501  {
502    mpq_class a(1, 2), b(2, 3);
503    mpq_class c;
504    c = a / b; ASSERT_ALWAYS(c == 0.75);
505  }
506
507  // operator<<
508  // operator>>
509  // operator==
510  // operator!=
511  // operator<
512  // operator<=
513  // operator>
514  // operator>=
515
516  // cmp
517  {
518    mpq_class a(123), b(45);
519    int c;
520    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
521    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
522  }
523  {
524    mpq_class a(123);
525    unsigned long b = 45;
526    int c;
527    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
528    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
529  }
530  {
531    mpq_class a(123);
532    long b = 45;
533    int c;
534    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
535    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
536  }
537  {
538    mpq_class a(123);
539    double b = 45;
540    int c;
541    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
542    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
543  }
544}
545
546void
547check_mpf (void)
548{
549  // unary operators and functions
550
551  // operator+
552  {
553    mpf_class a(1);
554    mpf_class b;
555    b = +a; ASSERT_ALWAYS(b == 1);
556  }
557
558  // operator-
559  {
560    mpf_class a(2);
561    mpf_class b;
562    b = -a; ASSERT_ALWAYS(b == -2);
563  }
564
565  // abs
566  {
567    mpf_class a(-123);
568    mpf_class b;
569    b = abs(a); ASSERT_ALWAYS(b == 123);
570  }
571
572  // trunc
573  {
574    mpf_class a(1.5);
575    mpf_class b;
576    b = trunc(a); ASSERT_ALWAYS(b == 1);
577  }
578  {
579    mpf_class a(-1.5);
580    mpf_class b;
581    b = trunc(a); ASSERT_ALWAYS(b == -1);
582  }
583
584  // floor
585  {
586    mpf_class a(1.9);
587    mpf_class b;
588    b = floor(a); ASSERT_ALWAYS(b == 1);
589  }
590  {
591    mpf_class a(-1.1);
592    mpf_class b;
593    b = floor(a); ASSERT_ALWAYS(b == -2);
594  }
595
596  // ceil
597  {
598    mpf_class a(1.1);
599    mpf_class b;
600    b = ceil(a); ASSERT_ALWAYS(b == 2);
601  }
602  {
603    mpf_class a(-1.9);
604    mpf_class b;
605    b = ceil(a); ASSERT_ALWAYS(b == -1);
606  }
607
608  // sqrt
609  {
610    mpf_class a(25);
611    mpf_class b;
612    b = sqrt(a); ASSERT_ALWAYS(b == 5);
613  }
614  {
615    mpf_class a(2.25);
616    mpf_class b;
617    b = sqrt(a); ASSERT_ALWAYS(b == 1.5);
618  }
619
620  // sgn
621  {
622    mpf_class a(123);
623    int b = sgn(a); ASSERT_ALWAYS(b == 1);
624  }
625  {
626    mpf_class a(0);
627    int b = sgn(a); ASSERT_ALWAYS(b == 0);
628  }
629  {
630    mpf_class a(-123);
631    int b = sgn(a); ASSERT_ALWAYS(b == -1);
632  }
633
634
635  // binary operators and functions
636
637  // operator+
638  {
639    mpf_class a(1), b(2);
640    mpf_class c;
641    c = a + b; ASSERT_ALWAYS(c == 3);
642  }
643
644  // operator-
645  {
646    mpf_class a(3), b(4);
647    mpf_class c;
648    c = a - b; ASSERT_ALWAYS(c == -1);
649  }
650
651  // operator*
652  {
653    mpf_class a(2), b(5);
654    mpf_class c;
655    c = a * b; ASSERT_ALWAYS(c == 10);
656  }
657
658  // operator/
659  {
660    mpf_class a(7), b(4);
661    mpf_class c;
662    c = a / b; ASSERT_ALWAYS(c == 1.75);
663  }
664
665  // operator<<
666  // operator>>
667  // operator==
668  // operator!=
669  // operator<
670  // operator<=
671  // operator>
672  // operator>=
673
674  // hypot
675  {
676    mpf_class a(3), b(4);
677    mpf_class c;
678    c = hypot(a, b); ASSERT_ALWAYS(c == 5);
679  }
680
681  // cmp
682  {
683    mpf_class a(123), b(45);
684    int c;
685    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
686    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
687  }
688  {
689    mpf_class a(123);
690    unsigned long b = 45;
691    int c;
692    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
693    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
694  }
695  {
696    mpf_class a(123);
697    long b = 45;
698    int c;
699    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
700    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
701  }
702  {
703    mpf_class a(123);
704    double b = 45;
705    int c;
706    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
707    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
708  }
709}
710
711
712int
713main (void)
714{
715  tests_start();
716
717  check_mpz();
718  check_mpq();
719  check_mpf();
720
721  tests_end();
722  return 0;
723}
724