t-ops.cc revision 1.1.1.4
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