1 /* Test mp*_class operators and functions.
2 
3 Copyright 2001-2003 Free Software Foundation, Inc.
4 
5 This file is part of the GNU MP Library test suite.
6 
7 The GNU MP Library test suite is free software; you can redistribute it
8 and/or modify it under the terms of the GNU General Public License as
9 published by the Free Software Foundation; either version 3 of the License,
10 or (at your option) any later version.
11 
12 The GNU MP Library test suite is distributed in the hope that it will be
13 useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
15 Public License for more details.
16 
17 You should have received a copy of the GNU General Public License along with
18 the 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 
29 using namespace std;
30 
31 
32 void
check_mpz(void)33 check_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 
423 void
check_mpq(void)424 check_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 
546 void
check_mpf(void)547 check_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 
712 int
main(void)713 main (void)
714 {
715   tests_start();
716 
717   check_mpz();
718   check_mpq();
719   check_mpf();
720 
721   tests_end();
722   return 0;
723 }
724