t-ops.cc revision 1.1.1.3 
1/* Test mp*_class operators and functions.
2
3Copyright 2001-2003, 2015 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 https://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    mpq_class a(123);
546    mpz_class b(45);
547    int c;
548    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
549    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
550  }
551}
552
553void
554check_mpf (void)
555{
556  // unary operators and functions
557
558  // operator+
559  {
560    mpf_class a(1);
561    mpf_class b;
562    b = +a; ASSERT_ALWAYS(b == 1);
563  }
564
565  // operator-
566  {
567    mpf_class a(2);
568    mpf_class b;
569    b = -a; ASSERT_ALWAYS(b == -2);
570  }
571
572  // abs
573  {
574    mpf_class a(-123);
575    mpf_class b;
576    b = abs(a); ASSERT_ALWAYS(b == 123);
577  }
578
579  // trunc
580  {
581    mpf_class a(1.5);
582    mpf_class b;
583    b = trunc(a); ASSERT_ALWAYS(b == 1);
584  }
585  {
586    mpf_class a(-1.5);
587    mpf_class b;
588    b = trunc(a); ASSERT_ALWAYS(b == -1);
589  }
590
591  // floor
592  {
593    mpf_class a(1.9);
594    mpf_class b;
595    b = floor(a); ASSERT_ALWAYS(b == 1);
596  }
597  {
598    mpf_class a(-1.1);
599    mpf_class b;
600    b = floor(a); ASSERT_ALWAYS(b == -2);
601  }
602
603  // ceil
604  {
605    mpf_class a(1.1);
606    mpf_class b;
607    b = ceil(a); ASSERT_ALWAYS(b == 2);
608  }
609  {
610    mpf_class a(-1.9);
611    mpf_class b;
612    b = ceil(a); ASSERT_ALWAYS(b == -1);
613  }
614
615  // sqrt
616  {
617    mpf_class a(25);
618    mpf_class b;
619    b = sqrt(a); ASSERT_ALWAYS(b == 5);
620  }
621  {
622    mpf_class a(2.25);
623    mpf_class b;
624    b = sqrt(a); ASSERT_ALWAYS(b == 1.5);
625  }
626
627  // sgn
628  {
629    mpf_class a(123);
630    int b = sgn(a); ASSERT_ALWAYS(b == 1);
631  }
632  {
633    mpf_class a(0);
634    int b = sgn(a); ASSERT_ALWAYS(b == 0);
635  }
636  {
637    mpf_class a(-123);
638    int b = sgn(a); ASSERT_ALWAYS(b == -1);
639  }
640
641
642  // binary operators and functions
643
644  // operator+
645  {
646    mpf_class a(1), b(2);
647    mpf_class c;
648    c = a + b; ASSERT_ALWAYS(c == 3);
649  }
650
651  // operator-
652  {
653    mpf_class a(3), b(4);
654    mpf_class c;
655    c = a - b; ASSERT_ALWAYS(c == -1);
656  }
657
658  // operator*
659  {
660    mpf_class a(2), b(5);
661    mpf_class c;
662    c = a * b; ASSERT_ALWAYS(c == 10);
663  }
664
665  // operator/
666  {
667    mpf_class a(7), b(4);
668    mpf_class c;
669    c = a / b; ASSERT_ALWAYS(c == 1.75);
670  }
671
672  // operator<<
673  // operator>>
674  // operator==
675  // operator!=
676  // operator<
677  // operator<=
678  // operator>
679  // operator>=
680
681  // hypot
682  {
683    mpf_class a(3), b(4);
684    mpf_class c;
685    c = hypot(a, b); ASSERT_ALWAYS(c == 5);
686  }
687
688  // cmp
689  {
690    mpf_class a(123), 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    unsigned 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    long 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    mpf_class a(123);
711    double b = 45;
712    int c;
713    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
714    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
715  }
716  {
717    mpf_class a(123);
718    mpz_class b(45);
719    int c;
720    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
721    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
722  }
723  {
724    mpf_class a(123);
725    mpq_class b(45);
726    int c;
727    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
728    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
729  }
730}
731
732
733int
734main (void)
735{
736  tests_start();
737
738  check_mpz();
739  check_mpq();
740  check_mpf();
741
742  tests_end();
743  return 0;
744}
745