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 } 448