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