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