tests/cxx/t-ops.cc

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