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