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