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