tests/cxx/t-binary.cc

   1 /* Test mp*_class binary expressions.
   2
   3 Copyright 2001, 2002, 2003, 2008 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   // template <class T, class Op>
  36   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, T>, Op> >
  37   {
  38     mpz_class a(1), b(2);
  39     mpz_class c(a + b); ASSERT_ALWAYS(c == 3);
  40   }
  41   {
  42     mpz_class a(3), b(4);
  43     mpz_class c;
  44     c = a * b; ASSERT_ALWAYS(c == 12);
  45   }
  46   {
  47     mpz_class a(5), b(3);
  48     mpz_class c;
  49     c = a % b; ASSERT_ALWAYS(c == 2);
  50   }
  51
  52   // template <class T, class U, class Op>
  53   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, U, Op> >
  54   {
  55     mpz_class a(1);
  56     signed int b = 3;
  57     mpz_class c(a - b); ASSERT_ALWAYS(c == -2);
  58   }
  59   {
  60     mpz_class a(-8);
  61     unsigned int b = 2;
  62     mpz_class c;
  63     c = a / b; ASSERT_ALWAYS(c == -4);
  64   }
  65   {
  66     mpz_class a(2);
  67     double b = 3.0;
  68     mpz_class c(a + b); ASSERT_ALWAYS(c == 5);
  69   }
  70   {
  71     mpz_class a(4);
  72     mpz_class b;
  73     b = a + 0; ASSERT_ALWAYS(b == 4);
  74   }
  75
  76   // template <class T, class U, class Op>
  77   // __gmp_expr<T, __gmp_binary_expr<U, __gmp_expr<T, T>, Op> >
  78   {
  79     mpz_class a(3);
  80     signed int b = 9;
  81     mpz_class c(b / a); ASSERT_ALWAYS(c == 3);
  82   }
  83
  84   // template <class T, class U, class V, class W, class Op>
  85   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, Op> >
  86   // type of result can't be mpz
  87
  88   // template <class T, class U, class V, class W, class Op>
  89   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, W>, Op> >
  90   // type of result can't be mpz
  91
  92   // template <class T, class U, class Op>
  93   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, U>, Op> >
  94   {
  95     mpz_class a(3), b(4);
  96     mpz_class c(a * (-b)); ASSERT_ALWAYS(c == -12);
  97   }
  98
  99   // template <class T, class U, class Op>
 100   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, T>, Op> >
 101   {
 102     mpz_class a(3), b(2), c(1);
 103     mpz_class d;
 104     d = (a % b) + c; ASSERT_ALWAYS(d == 2);
 105   }
 106
 107   // template <class T, class U, class V, class Op>
 108   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, V, Op> >
 109   {
 110     mpz_class a(-5);
 111     unsigned int b = 2;
 112     mpz_class c((-a) << b); ASSERT_ALWAYS(c == 20);
 113   }
 114   {
 115     mpz_class a(5), b(-4);
 116     signed int c = 3;
 117     mpz_class d;
 118     d = (a * b) >> c; ASSERT_ALWAYS(d == -3);
 119   }
 120
 121   // template <class T, class U, class V, class Op>
 122   // __gmp_expr<T, __gmp_binary_expr<U, __gmp_expr<T, V>, Op> >
 123   {
 124     mpz_class a(2), b(4);
 125     double c = 6;
 126     mpz_class d(c / (a - b)); ASSERT_ALWAYS(d == -3);
 127   }
 128   {
 129     mpz_class a(3), b(2);
 130     double c = 1;
 131     mpz_class d;
 132     d = c + (a + b); ASSERT_ALWAYS(d == 6);
 133   }
 134
 135   // template <class T, class U, class V, class W, class Op>
 136   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, Op> >
 137   // type of result can't be mpz
 138
 139   // template <class T, class U, class V, class W, class Op>
 140   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, W>, Op> >
 141   // type of result can't be mpz
 142
 143   // template <class T, class U, class V, class Op>
 144   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, V>, Op> >
 145   {
 146     mpz_class a(3), b(5), c(7);
 147     mpz_class d;
 148     d = (a - b) * (-c); ASSERT_ALWAYS(d == 14);
 149   }
 150
 151   {
 152     mpz_class a(0xcafe), b(0xbeef), c, want;
 153     c = a & b; ASSERT_ALWAYS (c == 0x8aee);
 154     c = a | b; ASSERT_ALWAYS (c == 0xfeff);
 155     c = a ^ b; ASSERT_ALWAYS (c == 0x7411);
 156     c = a & 0xbeef; ASSERT_ALWAYS (c == 0x8aee);
 157     c = a | 0xbeef; ASSERT_ALWAYS (c == 0xfeff);
 158     c = a ^ 0xbeef; ASSERT_ALWAYS (c == 0x7411);
 159     c = a & -0xbeef; ASSERT_ALWAYS (c == 0x4010);
 160     c = a | -0xbeef; ASSERT_ALWAYS (c == -0x3401);
 161     c = a ^ -0xbeef; ASSERT_ALWAYS (c == -0x7411);
 162     c = a & 48879.0; ASSERT_ALWAYS (c == 0x8aee);
 163     c = a | 48879.0; ASSERT_ALWAYS (c == 0xfeff);
 164     c = a ^ 48879.0; ASSERT_ALWAYS (c == 0x7411);
 165
 166     c = a | 1267650600228229401496703205376.0; // 2^100
 167     want = "0x1000000000000000000000cafe";
 168     ASSERT_ALWAYS (c == want);
 169   }
 170
 171 }
 172
 173 void
 174 check_mpq (void)
 175 {
 176   // template <class T, class Op>
 177   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, T>, Op> >
 178   {
 179     mpq_class a(1, 2), b(3, 4);
 180     mpq_class c(a + b); ASSERT_ALWAYS(c == 1.25);
 181   }
 182
 183   // template <class T, class U, class Op>
 184   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, U, Op> >
 185   {
 186     mpq_class a(1, 2);
 187     signed int b = 3;
 188     mpq_class c(a - b); ASSERT_ALWAYS(c == -2.5);
 189   }
 190   {
 191     mpq_class a(1, 2);
 192     mpq_class b;
 193     b = a + 0; ASSERT_ALWAYS(b == 0.5);
 194   }
 195
 196   // template <class T, class U, class Op>
 197   // __gmp_expr<T, __gmp_binary_expr<U, __gmp_expr<T, T>, Op> >
 198   {
 199     mpq_class a(2, 3);
 200     signed int b = 4;
 201     mpq_class c;
 202     c = b / a; ASSERT_ALWAYS(c == 6);
 203   }
 204
 205   // template <class T, class U, class V, class Op>
 206   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<U, V>, Op> >
 207   {
 208     mpq_class a(1, 2);
 209     mpz_class b(1);
 210     mpq_class c(a + b); ASSERT_ALWAYS(c == 1.5);
 211   }
 212   {
 213     mpq_class a(2, 3);
 214     mpz_class b(1);
 215     double c = 2.0;
 216     mpq_class d;
 217     d = a * (b + c); ASSERT_ALWAYS(d == 2);
 218   }
 219
 220   // template <class T, class U, class V, class Op>
 221   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, T>, Op> >
 222   {
 223     mpq_class a(2, 3);
 224     mpz_class b(4);
 225     mpq_class c(b / a); ASSERT_ALWAYS(c == 6);
 226   }
 227   {
 228     mpq_class a(2, 3);
 229     mpz_class b(1), c(4);
 230     mpq_class d;
 231     d = (b - c) * a; ASSERT_ALWAYS(d == -2);
 232   }
 233
 234   // template <class T, class U, class Op>
 235   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, U>, Op> >
 236   {
 237     mpq_class a(1, 3), b(3, 4);
 238     mpq_class c;
 239     c = a * (-b); ASSERT_ALWAYS(c == -0.25);
 240   }
 241
 242   // template <class T, class U, class Op>
 243   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, T>, Op> >
 244   {
 245     mpq_class a(1, 3), b(2, 3), c(1, 4);
 246     mpq_class d((a / b) + c); ASSERT_ALWAYS(d == 0.75);
 247   }
 248
 249   // template <class T, class U, class V, class Op>
 250   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, V, Op> >
 251   {
 252     mpq_class a(3, 8);
 253     unsigned int b = 4;
 254     mpq_class c((-a) << b); ASSERT_ALWAYS(c == -6);
 255   }
 256
 257   // template <class T, class U, class V, class Op>
 258   // __gmp_expr<T, __gmp_binary_expr<U, __gmp_expr<T, V>, Op> >
 259   {
 260     mpq_class a(1, 2), b(1, 4);
 261     double c = 6.0;
 262     mpq_class d;
 263     d = c / (a + b); ASSERT_ALWAYS(d == 8);
 264   }
 265
 266   // template <class T, class U, class V, class W, class Op>
 267   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, Op> >
 268   {
 269     mpq_class a(1, 2), b(1, 4);
 270     mpz_class c(1);
 271     mpq_class d((a + b) - c); ASSERT_ALWAYS(d == -0.25);
 272   }
 273   {
 274     mpq_class a(1, 3), b(3, 2);
 275     mpz_class c(2), d(4);
 276     mpq_class e;
 277     e = (a * b) / (c - d); ASSERT_ALWAYS(e == -0.25);
 278   }
 279
 280   // template <class T, class U, class V, class W, class Op>
 281   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, W>, Op> >
 282   {
 283     mpq_class a(1, 3), b(3, 4);
 284     mpz_class c(-3);
 285     mpq_class d(c * (a * b)); ASSERT_ALWAYS(d == -0.75);
 286   }
 287   {
 288     mpq_class a(1, 3), b(3, 5);
 289     mpz_class c(6);
 290     signed int d = 4;
 291     mpq_class e;
 292     e = (c % d) / (a * b); ASSERT_ALWAYS(e == 10);
 293   }
 294
 295   // template <class T, class U, class V, class Op>
 296   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, V>, Op> >
 297   {
 298     mpq_class a(1, 3), b(3, 4), c(2, 5);
 299     mpq_class d;
 300     d = (a * b) / (-c); ASSERT_ALWAYS(d == -0.625);
 301   }
 302 }
 303
 304 void
 305 check_mpf (void)
 306 {
 307   // template <class T, class Op>
 308   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, T>, Op> >
 309   {
 310     mpf_class a(1), b(2);
 311     mpf_class c(a + b); ASSERT_ALWAYS(c == 3);
 312   }
 313   {
 314     mpf_class a(1.5), b(6);
 315     mpf_class c;
 316     c = a / b; ASSERT_ALWAYS(c == 0.25);
 317   }
 318
 319   // template <class T, class U, class Op>
 320   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, U, Op> >
 321   {
 322     mpf_class a(1);
 323     signed int b = -2;
 324     mpf_class c(a - b); ASSERT_ALWAYS(c == 3);
 325   }
 326   {
 327     mpf_class a(2);
 328     mpf_class b;
 329     b = a + 0; ASSERT_ALWAYS(b == 2);
 330   }
 331
 332   // template <class T, class U, class Op>
 333   // __gmp_expr<T, __gmp_binary_expr<U, __gmp_expr<T, T>, Op> >
 334   {
 335     mpf_class a(2);
 336     unsigned int b = 3;
 337     mpf_class c;
 338     c = b / a; ASSERT_ALWAYS(c == 1.5);
 339   }
 340
 341   // template <class T, class U, class V, class Op>
 342   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<U, V>, Op> >
 343   {
 344     mpf_class a(2);
 345     mpz_class b(3);
 346     mpf_class c(a - b); ASSERT_ALWAYS(c == -1);
 347   }
 348   {
 349     mpf_class a(3);
 350     mpz_class b(2), c(1);
 351     mpf_class d;
 352     d = a * (b + c); ASSERT_ALWAYS(d == 9);
 353   }
 354
 355   // template <class T, class U, class V, class Op>
 356   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, T>, Op> >
 357   {
 358     mpf_class a(6);
 359     mpq_class b(3, 4);
 360     mpf_class c(a * b); ASSERT_ALWAYS(c == 4.5);
 361   }
 362
 363   // template <class T, class U, class Op>
 364   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, U>, Op> >
 365   {
 366     mpf_class a(2), b(-3);
 367     mpf_class c;
 368     c = a * (-b); ASSERT_ALWAYS(c == 6);
 369   }
 370
 371   // template <class T, class U, class Op>
 372   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, T>, Op> >
 373   {
 374     mpf_class a(3), b(4), c(5);
 375     mpf_class d;
 376     d = (a / b) - c; ASSERT_ALWAYS(d == -4.25);
 377   }
 378
 379   // template <class T, class U, class V, class Op>
 380   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, V, Op> >
 381   {
 382     mpf_class a(3);
 383     unsigned int b = 2;
 384     mpf_class c((-a) >> b); ASSERT_ALWAYS(c == -0.75);
 385   }
 386
 387   // template <class T, class U, class V, class Op>
 388   // __gmp_expr<T, __gmp_binary_expr<U, __gmp_expr<T, V>, Op> >
 389   {
 390     mpf_class a(2), b(3);
 391     double c = 5.0;
 392     mpf_class d;
 393     d = c / (a + b); ASSERT_ALWAYS(d == 1);
 394   }
 395
 396   // template <class T, class U, class V, class W, class Op>
 397   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, Op> >
 398   {
 399     mpf_class a(2), b(3);
 400     mpz_class c(4);
 401     mpf_class d;
 402     d = (a + b) * c; ASSERT_ALWAYS(d == 20);
 403   }
 404   {
 405     mpf_class a(2), b(3);
 406     mpq_class c(1, 2), d(1, 4);
 407     mpf_class e;
 408     e = (a * b) / (c + d); ASSERT_ALWAYS(e == 8);
 409   }
 410
 411   // template <class T, class U, class V, class W, class Op>
 412   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, W>, Op> >
 413   {
 414     mpf_class a(1), b(2);
 415     mpq_class c(3);
 416     mpf_class d(c / (a + b)); ASSERT_ALWAYS(d == 1);
 417   }
 418   {
 419     mpf_class a(1);
 420     mpz_class b(2);
 421     mpq_class c(3, 4);
 422     mpf_class d;
 423     d = (-c) + (a + b); ASSERT_ALWAYS(d == 2.25);
 424   }
 425
 426   // template <class T, class U, class V, class Op>
 427   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, V>, Op> >
 428   {
 429     mpf_class a(1), b(2), c(3);
 430     mpf_class d;
 431     d = (a + b) * (-c); ASSERT_ALWAYS(d == -9);
 432   }
 433 }
 434
 435
 436 int
 437 main (void)
 438 {
 439   tests_start();
 440
 441   check_mpz();
 442   check_mpq();
 443   check_mpf();
 444
 445   tests_end();
 446   return 0;
 447 }