1 /* Test file for in-place operations. 2 3 Copyright 2000-2023 Free Software Foundation, Inc. 4 Contributed by the AriC and Caramba projects, INRIA. 5 6 This file is part of the GNU MPFR Library. 7 8 The GNU MPFR Library is free software; you can redistribute it and/or modify 9 it under the terms of the GNU Lesser General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or (at your 11 option) any later version. 12 13 The GNU MPFR Library is distributed in the hope that it will be useful, but 14 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public 16 License for more details. 17 18 You should have received a copy of the GNU Lesser General Public License 19 along with the GNU MPFR Library; see the file COPYING.LESSER. If not, see 20 https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc., 21 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. */ 22 23 #include "mpfr-test.h" 24 25 #define DISP(s,t) \ 26 do \ 27 { \ 28 printf (s); \ 29 mpfr_out_str (stdout, 2, 0, t, MPFR_RNDN); \ 30 } \ 31 while (0) 32 33 #define DISP2(s,t) do { DISP(s,t); putchar ('\n'); } while (0) 34 35 #define SPECIAL_MAX 12 36 37 static void 38 set_special (mpfr_ptr x, unsigned int select) 39 { 40 MPFR_ASSERTN (select < SPECIAL_MAX); 41 switch (select) 42 { 43 case 0: 44 MPFR_SET_NAN (x); 45 break; 46 case 1: 47 MPFR_SET_INF (x); 48 MPFR_SET_POS (x); 49 break; 50 case 2: 51 MPFR_SET_INF (x); 52 MPFR_SET_NEG (x); 53 break; 54 case 3: 55 MPFR_SET_ZERO (x); 56 MPFR_SET_POS (x); 57 break; 58 case 4: 59 MPFR_SET_ZERO (x); 60 MPFR_SET_NEG (x); 61 break; 62 case 5: 63 mpfr_set_str_binary (x, "1"); 64 break; 65 case 6: 66 mpfr_set_str_binary (x, "-1"); 67 break; 68 case 7: 69 mpfr_set_str_binary (x, "1e-1"); 70 break; 71 case 8: 72 mpfr_set_str_binary (x, "1e+1"); 73 break; 74 case 9: 75 mpfr_const_pi (x, MPFR_RNDN); 76 break; 77 case 10: 78 mpfr_const_pi (x, MPFR_RNDN); 79 MPFR_SET_EXP (x, MPFR_GET_EXP (x)-1); 80 break; 81 case 11: 82 mpfr_urandomb (x, RANDS); 83 if (RAND_BOOL ()) 84 mpfr_neg (x, x, MPFR_RNDN); 85 break; 86 default: 87 MPFR_ASSERTN (0); 88 } 89 } 90 91 static void 92 test3 (int (*testfunc)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t), 93 const char *foo, mpfr_prec_t prec, mpfr_rnd_t rnd) 94 { 95 mpfr_t ref1, ref2, ref3; 96 mpfr_t res1; 97 int i; 98 99 #ifdef MPFR_DEBUG 100 printf ("checking %s\n", foo); 101 #endif 102 mpfr_init2 (ref1, prec); 103 mpfr_init2 (ref2, prec); 104 mpfr_init2 (ref3, prec); 105 mpfr_init2 (res1, prec); 106 107 /* for each variable, consider each of the following 6 possibilities: 108 NaN, +Infinity, -Infinity, +0, -0 or a random number */ 109 for (i = 0; i < SPECIAL_MAX * SPECIAL_MAX; i++) 110 { 111 set_special (ref2, i % SPECIAL_MAX); 112 set_special (ref3, i / SPECIAL_MAX); 113 114 /* reference call: foo(a, b, c) */ 115 testfunc (ref1, ref2, ref3, rnd); 116 117 /* foo(a, a, c) */ 118 mpfr_set (res1, ref2, rnd); /* exact operation */ 119 testfunc (res1, res1, ref3, rnd); 120 121 if (! SAME_VAL (res1, ref1)) 122 { 123 printf ("Error for %s(a, a, c) with %s for ", foo, 124 mpfr_print_rnd_mode (rnd)); 125 DISP("a=", ref2); DISP2(", c=", ref3); 126 printf ("expected "); mpfr_dump (ref1); 127 printf ("got "); mpfr_dump (res1); 128 exit (1); 129 } 130 131 /* foo(a, b, a) */ 132 mpfr_set (res1, ref3, rnd); 133 testfunc (res1, ref2, res1, rnd); 134 if (! SAME_VAL (res1, ref1)) 135 { 136 printf ("Error for %s(a, b, a) for ", foo); 137 DISP("b=", ref2); DISP2(", a=", ref3); 138 printf ("expected "); mpfr_dump (ref1); 139 printf ("got "); mpfr_dump (res1); 140 exit (1); 141 } 142 143 /* foo(a, a, a) */ 144 mpfr_set (ref3, ref2, rnd); 145 testfunc (ref1, ref2, ref3, rnd); 146 mpfr_set (res1, ref2, rnd); 147 testfunc (res1, res1, res1, rnd); 148 149 if (! SAME_VAL (res1, ref1)) 150 { 151 printf ("Error for %s(a, a, a) for ", foo); 152 DISP2("a=", ref2); 153 printf ("expected "); mpfr_dump (ref1); 154 printf ("got "); mpfr_dump (res1); 155 exit (1); 156 } 157 } 158 159 mpfr_clear (ref1); 160 mpfr_clear (ref2); 161 mpfr_clear (ref3); 162 mpfr_clear (res1); 163 } 164 165 static void 166 test4 (int (*testfunc)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, 167 mpfr_rnd_t), 168 const char *foo, mpfr_prec_t prec, mpfr_rnd_t rnd) 169 { 170 mpfr_t ref, op1, op2, op3; 171 mpfr_t res; 172 int i, j, k; 173 174 #ifdef MPFR_DEBUG 175 printf ("checking %s\n", foo); 176 #endif 177 mpfr_init2 (ref, prec); 178 mpfr_init2 (op1, prec); 179 mpfr_init2 (op2, prec); 180 mpfr_init2 (op3, prec); 181 mpfr_init2 (res, prec); 182 183 /* for each variable, consider each of the following 6 possibilities: 184 NaN, +Infinity, -Infinity, +0, -0 or a random number */ 185 186 for (i = 0; i < SPECIAL_MAX; i++) 187 { 188 set_special (op1, i); 189 for (j = 0; j < SPECIAL_MAX; j++) 190 { 191 set_special (op2, j); 192 for (k = 0; k < SPECIAL_MAX; k++) 193 { 194 set_special (op3, k); 195 196 /* reference call: foo(s, a, b, c) */ 197 testfunc (ref, op1, op2, op3, rnd); 198 199 /* foo(a, a, b, c) */ 200 mpfr_set (res, op1, rnd); /* exact operation */ 201 testfunc (res, res, op2, op3, rnd); 202 203 if (! SAME_VAL (res, ref)) 204 { 205 printf ("Error for %s(a, a, b, c) for ", foo); 206 DISP("a=", op1); DISP(", b=", op2); DISP2(", c=", op3); 207 printf ("expected "); mpfr_dump (ref); 208 printf ("got "); mpfr_dump (res); 209 exit (1); 210 } 211 212 /* foo(b, a, b, c) */ 213 mpfr_set (res, op2, rnd); 214 testfunc (res, op1, res, op3, rnd); 215 216 if (! SAME_VAL (res, ref)) 217 { 218 printf ("Error for %s(a, a, b, c) for ", foo); 219 DISP("a=", op1); DISP(", b=", op2); DISP2(", c=", op3); 220 printf ("expected "); mpfr_dump (ref); 221 printf ("got "); mpfr_dump (res); 222 exit (1); 223 } 224 225 /* foo(c, a, b, c) */ 226 mpfr_set (res, op3, rnd); 227 testfunc (res, op1, op2, res, rnd); 228 229 if (! SAME_VAL (res, ref)) 230 { 231 printf ("Error for %s(a, a, b, c) for ", foo); 232 DISP("a=", op1); DISP(", b=", op2); DISP2(", c=", op3); 233 printf ("expected "); mpfr_dump (ref); 234 printf ("got "); mpfr_dump (res); 235 exit (1); 236 } 237 238 /* foo(a, a, a, c) */ 239 testfunc (ref, op1, op1, op3, rnd); 240 mpfr_set (res, op1, rnd); 241 testfunc (res, res, res, op3, rnd); 242 if (! SAME_VAL (res, ref)) 243 { 244 printf ("Error for %s(a, a, b, c) for ", foo); 245 DISP("a=", op1); DISP(", a=", op2); DISP2(", c=", op3); 246 printf ("expected "); mpfr_dump (ref); 247 printf ("got "); mpfr_dump (res); 248 exit (1); 249 } 250 251 /* foo(a, a, b, a) */ 252 testfunc (ref, op1, op2, op1, rnd); 253 mpfr_set (res, op1, rnd); 254 testfunc (res, res, op2, res, rnd); 255 if (! SAME_VAL (res, ref)) 256 { 257 printf ("Error for %s(a, a, b, c) for ", foo); 258 DISP("a=", op1); DISP(", a=", op2); DISP2(", c=", op3); 259 printf ("expected "); mpfr_dump (ref); 260 printf ("got "); mpfr_dump (res); 261 exit (1); 262 } 263 264 /* foo(b, a, b, b) */ 265 testfunc (ref, op1, op2, op2, rnd); 266 mpfr_set (res, op2, rnd); 267 testfunc (res, op1, res, res, rnd); 268 if (! SAME_VAL (res, ref)) 269 { 270 printf ("Error for %s(a, a, b, c) for ", foo); 271 DISP("a=", op1); DISP(", a=", op2); DISP2(", c=", op3); 272 printf ("expected "); mpfr_dump (ref); 273 printf ("got "); mpfr_dump (res); 274 exit (1); 275 } 276 277 /* foo (a, a, a, a) */ 278 testfunc (ref, op1, op1, op1, rnd); 279 mpfr_set (res, op1, rnd); 280 testfunc (res, res, res, res, rnd); 281 if (! SAME_VAL (res, ref)) 282 { 283 printf ("Error for %s(a, a, a, a) for ", foo); 284 DISP2("a=", op1); 285 printf ("expected "); mpfr_dump (ref); 286 printf ("got "); mpfr_dump (res); 287 exit (1); 288 } 289 } 290 } 291 } 292 293 mpfr_clear (ref); 294 mpfr_clear (op1); 295 mpfr_clear (op2); 296 mpfr_clear (op3); 297 mpfr_clear (res); 298 299 } 300 301 static void 302 test2ui (int (*testfunc)(mpfr_ptr, mpfr_srcptr, unsigned long int, mpfr_rnd_t), 303 const char *foo, mpfr_prec_t prec, mpfr_rnd_t rnd) 304 { 305 mpfr_t ref1, ref2; 306 unsigned int ref3; 307 mpfr_t res1; 308 int i; 309 310 #ifdef MPFR_DEBUG 311 printf ("checking %s\n", foo); 312 #endif 313 mpfr_init2 (ref1, prec); 314 mpfr_init2 (ref2, prec); 315 mpfr_init2 (res1, prec); 316 317 /* ref2 can be NaN, +Inf, -Inf, +0, -0 or any number 318 ref3 can be 0 or any number */ 319 for (i = 0; i < SPECIAL_MAX * 2; i++) 320 { 321 set_special (ref2, i % SPECIAL_MAX); 322 ref3 = i / SPECIAL_MAX == 0 ? 0 : randlimb (); 323 324 /* reference call: foo(a, b, c) */ 325 testfunc (ref1, ref2, ref3, rnd); 326 327 /* foo(a, a, c) */ 328 mpfr_set (res1, ref2, rnd); /* exact operation */ 329 testfunc (res1, res1, ref3, rnd); 330 331 if (! SAME_VAL (res1, ref1)) 332 { 333 printf ("Error for %s(a, a, c) for c=%u\n", foo, ref3); 334 DISP2("a=", ref2); 335 printf ("expected "); mpfr_dump (ref1); 336 printf ("got "); mpfr_dump (res1); 337 exit (1); 338 } 339 } 340 341 mpfr_clear (ref1); 342 mpfr_clear (ref2); 343 mpfr_clear (res1); 344 } 345 346 static void 347 testui2 (int (*testfunc)(mpfr_ptr, unsigned long int, mpfr_srcptr, mpfr_rnd_t), 348 const char *foo, mpfr_prec_t prec, mpfr_rnd_t rnd) 349 { 350 mpfr_t ref1, ref3; 351 unsigned int ref2; 352 mpfr_t res1; 353 int i; 354 355 #ifdef MPFR_DEBUG 356 printf ("checking %s\n", foo); 357 #endif 358 mpfr_init2 (ref1, prec); 359 mpfr_init2 (ref3, prec); 360 mpfr_init2 (res1, prec); 361 362 for (i = 0; i < SPECIAL_MAX * 2; i++) 363 { 364 set_special (ref3, i % SPECIAL_MAX); 365 ref2 = i / SPECIAL_MAX == 0 ? 0 : randlimb (); 366 367 /* reference call: foo(a, b, c) */ 368 testfunc (ref1, ref2, ref3, rnd); 369 370 /* foo(a, b, a) */ 371 mpfr_set (res1, ref3, rnd); /* exact operation */ 372 testfunc (res1, ref2, res1, rnd); 373 if (! SAME_VAL (res1, ref1)) 374 { 375 printf ("Error for %s(a, b, a) for b=%u \n", foo, ref2); 376 DISP2("a=", ref3); 377 DISP("expected", ref1); DISP2(", got ", res1); 378 exit (1); 379 } 380 } 381 382 mpfr_clear (ref1); 383 mpfr_clear (ref3); 384 mpfr_clear (res1); 385 } 386 387 /* foo(mpfr_ptr, mpfr_srcptr, mp_rndt) */ 388 static void 389 test2 (int (*testfunc)(mpfr_ptr, mpfr_srcptr, mpfr_rnd_t), 390 const char *foo, mpfr_prec_t prec, mpfr_rnd_t rnd) 391 { 392 mpfr_t ref1, ref2; 393 mpfr_t res1; 394 int i; 395 396 #ifdef MPFR_DEBUG 397 printf ("checking %s\n", foo); 398 #endif 399 mpfr_init2 (ref1, prec); 400 mpfr_init2 (ref2, prec); 401 mpfr_init2 (res1, prec); 402 403 for (i = 0; i < SPECIAL_MAX; i++) 404 { 405 set_special (ref2, i); 406 407 /* reference call: foo(a, b) */ 408 testfunc (ref1, ref2, rnd); 409 410 /* foo(a, a) */ 411 mpfr_set (res1, ref2, rnd); /* exact operation */ 412 testfunc (res1, res1, rnd); 413 if (! SAME_VAL (res1, ref1)) 414 { 415 printf ("Error for %s(a, a) for ", foo); 416 DISP2("a=", ref2); 417 DISP("expected", ref1); DISP2(", got ", res1); 418 exit (1); 419 } 420 } 421 422 mpfr_clear (ref1); 423 mpfr_clear (ref2); 424 mpfr_clear (res1); 425 } 426 427 /* foo(mpfr_ptr, mpfr_srcptr) */ 428 static void 429 test2a (int (*testfunc)(mpfr_ptr, mpfr_srcptr), 430 const char *foo, mpfr_prec_t prec) 431 { 432 mpfr_t ref1, ref2; 433 mpfr_t res1; 434 int i; 435 436 #ifdef MPFR_DEBUG 437 printf ("checking %s\n", foo); 438 #endif 439 mpfr_init2 (ref1, prec); 440 mpfr_init2 (ref2, prec); 441 mpfr_init2 (res1, prec); 442 443 for (i = 0; i < SPECIAL_MAX; i++) 444 { 445 set_special (ref2, i); 446 447 /* reference call: foo(a, b) */ 448 testfunc (ref1, ref2); 449 450 /* foo(a, a) */ 451 mpfr_set (res1, ref2, MPFR_RNDN); /* exact operation */ 452 testfunc (res1, res1); 453 if (! SAME_VAL (res1, ref1)) 454 { 455 printf ("Error for %s(a, a) for ", foo); 456 DISP2("a=", ref2); 457 DISP("expected", ref1); DISP2(", got ", res1); 458 exit (1); 459 } 460 } 461 462 mpfr_clear (ref1); 463 mpfr_clear (ref2); 464 mpfr_clear (res1); 465 } 466 467 /* one operand, two results */ 468 static void 469 test3a (int (*testfunc)(mpfr_ptr, mpfr_ptr, mpfr_srcptr, mpfr_rnd_t), 470 const char *foo, mpfr_prec_t prec, mpfr_rnd_t rnd) 471 { 472 mpfr_t ref1, ref2, ref3; 473 mpfr_t res1, res2; 474 int i; 475 476 #ifdef MPFR_DEBUG 477 printf ("checking %s\n", foo); 478 #endif 479 mpfr_init2 (ref1, prec); 480 mpfr_init2 (ref2, prec); 481 mpfr_init2 (ref3, prec); 482 mpfr_init2 (res1, prec); 483 mpfr_init2 (res2, prec); 484 485 for (i = 0; i < SPECIAL_MAX; i++) 486 { 487 set_special (ref3, i); 488 489 /* reference call: foo(a, b, c) */ 490 testfunc (ref1, ref2, ref3, rnd); 491 492 /* foo(a, b, a) */ 493 mpfr_set (res1, ref3, rnd); /* exact operation */ 494 testfunc (res1, res2, res1, rnd); 495 if (! SAME_VAL (res1, ref1) || ! SAME_VAL (res2, ref2)) 496 { 497 printf ("Error for %s(a, b, a) for rnd=%s, ", foo, 498 mpfr_print_rnd_mode (rnd)); 499 DISP2("a=", ref3); 500 DISP("expected (", ref1); DISP(",", ref2); 501 DISP("), got (", res1); DISP(",", res2); printf(")\n"); 502 exit (1); 503 } 504 505 /* foo(a, b, b) */ 506 mpfr_set (res2, ref3, rnd); /* exact operation */ 507 testfunc (res1, res2, res2, rnd); 508 if (! SAME_VAL (res1, ref1) || ! SAME_VAL (res2, ref2)) 509 { 510 printf ("Error for %s(a, b, b) for ", foo); 511 DISP2("b=", ref3); 512 DISP("expected (", ref1); DISP(",", ref2); 513 DISP("), got (", res1); DISP(",", res2); printf(")\n"); 514 exit (1); 515 } 516 } 517 518 mpfr_clear (ref1); 519 mpfr_clear (ref2); 520 mpfr_clear (ref3); 521 mpfr_clear (res1); 522 mpfr_clear (res2); 523 } 524 525 static int 526 reldiff_wrapper (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode) 527 { 528 mpfr_reldiff (a, b, c, rnd_mode); 529 return 0; 530 } 531 532 static void 533 pow_int (mpfr_rnd_t rnd) 534 { 535 mpfr_t ref1, ref2, ref3; 536 mpfr_t res1; 537 int i; 538 539 #ifdef MPFR_DEBUG 540 printf ("pow_int\n"); 541 #endif 542 mpfr_inits2 ((randlimb () % 200) + MPFR_PREC_MIN, 543 ref1, ref2, res1, (mpfr_ptr) 0); 544 mpfr_init2 (ref3, 1005); 545 546 for (i = 0; i <= 15; i++) 547 { 548 mpfr_urandomb (ref2, RANDS); 549 if (i & 1) 550 mpfr_neg (ref2, ref2, MPFR_RNDN); 551 mpfr_set_ui (ref3, 20, MPFR_RNDN); 552 /* We need to test huge integers because different algorithms/codes 553 are used for not-too-large integers (mpfr_pow_z) and for general 554 cases, in particular huge integers (mpfr_pow_general). [r7606] */ 555 if (i & 2) 556 mpfr_mul_2ui (ref3, ref3, 1000, MPFR_RNDN); 557 if (i & 4) 558 mpfr_add_ui (ref3, ref3, 1, MPFR_RNDN); /* odd integer */ 559 560 /* reference call: pow(a, b, c) */ 561 mpfr_pow (ref1, ref2, ref3, rnd); 562 563 /* pow(a, a, c) */ 564 mpfr_set (res1, ref2, rnd); /* exact operation */ 565 mpfr_pow (res1, res1, ref3, rnd); 566 567 if (! SAME_VAL (res1, ref1)) 568 { 569 printf ("Error for pow_int(a, a, c) for "); 570 DISP("a=", ref2); DISP2(", c=", ref3); 571 printf ("expected "); mpfr_dump (ref1); 572 printf ("got "); mpfr_dump (res1); 573 exit (1); 574 } 575 } 576 577 mpfr_clears (ref1, ref2, ref3, res1, (mpfr_ptr) 0); 578 } 579 580 int 581 main (void) 582 { 583 int i, rnd; 584 mpfr_prec_t p; 585 586 tests_start_mpfr (); 587 588 for (i = 1; i <= 5; i++) 589 { 590 /* Test on i limb(s), with a random number of trailing bits. */ 591 p = GMP_NUMB_BITS * i - (randlimb () % GMP_NUMB_BITS); 592 if (p < MPFR_PREC_MIN) 593 p = MPFR_PREC_MIN; 594 595 RND_LOOP (rnd) 596 { 597 test2a (mpfr_round, "mpfr_round", p); 598 test2a (mpfr_ceil, "mpfr_ceil", p); 599 test2a (mpfr_floor, "mpfr_floor", p); 600 test2a (mpfr_trunc, "mpfr_trunc", p); 601 602 test2ui (mpfr_add_ui, "mpfr_add_ui", p, (mpfr_rnd_t) rnd); 603 test2ui (mpfr_div_2exp, "mpfr_div_2exp", p, (mpfr_rnd_t) rnd); 604 test2ui (mpfr_div_2ui, "mpfr_div_2ui", p, (mpfr_rnd_t) rnd); 605 test2ui (mpfr_div_ui, "mpfr_div_ui", p, (mpfr_rnd_t) rnd); 606 test2ui (mpfr_mul_2exp, "mpfr_mul_2exp", p, (mpfr_rnd_t) rnd); 607 test2ui (mpfr_mul_2ui, "mpfr_mul_2ui", p, (mpfr_rnd_t) rnd); 608 test2ui (mpfr_mul_ui, "mpfr_mul_ui", p, (mpfr_rnd_t) rnd); 609 test2ui (mpfr_pow_ui, "mpfr_pow_ui", p, (mpfr_rnd_t) rnd); 610 test2ui (mpfr_sub_ui, "mpfr_sub_ui", p, (mpfr_rnd_t) rnd); 611 612 testui2 (mpfr_ui_div, "mpfr_ui_div", p, (mpfr_rnd_t) rnd); 613 testui2 (mpfr_ui_sub, "mpfr_ui_sub", p, (mpfr_rnd_t) rnd); 614 testui2 (mpfr_ui_pow, "mpfr_ui_pow", p, (mpfr_rnd_t) rnd); 615 616 test2 (mpfr_sqr, "mpfr_sqr", p, (mpfr_rnd_t) rnd); 617 test2 (mpfr_sqrt, "mpfr_sqrt", p, (mpfr_rnd_t) rnd); 618 test2 (mpfr_abs, "mpfr_abs", p, (mpfr_rnd_t) rnd); 619 test2 (mpfr_neg, "mpfr_neg", p, (mpfr_rnd_t) rnd); 620 621 test2 (mpfr_log, "mpfr_log", p, (mpfr_rnd_t) rnd); 622 test2 (mpfr_log2, "mpfr_log2", p, (mpfr_rnd_t) rnd); 623 test2 (mpfr_log10, "mpfr_log10", p, (mpfr_rnd_t) rnd); 624 test2 (mpfr_log1p, "mpfr_log1p", p, (mpfr_rnd_t) rnd); 625 626 test2 (mpfr_exp, "mpfr_exp", p, (mpfr_rnd_t) rnd); 627 test2 (mpfr_exp2, "mpfr_exp2", p, (mpfr_rnd_t) rnd); 628 test2 (mpfr_exp10, "mpfr_exp10", p, (mpfr_rnd_t) rnd); 629 test2 (mpfr_expm1, "mpfr_expm1", p, (mpfr_rnd_t) rnd); 630 test2 (mpfr_eint, "mpfr_eint", p, (mpfr_rnd_t) rnd); 631 632 test2 (mpfr_sinh, "mpfr_sinh", p, (mpfr_rnd_t) rnd); 633 test2 (mpfr_cosh, "mpfr_cosh", p, (mpfr_rnd_t) rnd); 634 test2 (mpfr_tanh, "mpfr_tanh", p, (mpfr_rnd_t) rnd); 635 test2 (mpfr_asinh, "mpfr_asinh", p, (mpfr_rnd_t) rnd); 636 test2 (mpfr_acosh, "mpfr_acosh", p, (mpfr_rnd_t) rnd); 637 test2 (mpfr_atanh, "mpfr_atanh", p, (mpfr_rnd_t) rnd); 638 test2 (mpfr_sech, "mpfr_sech", p, (mpfr_rnd_t) rnd); 639 test2 (mpfr_csch, "mpfr_csch", p, (mpfr_rnd_t) rnd); 640 test2 (mpfr_coth, "mpfr_coth", p, (mpfr_rnd_t) rnd); 641 642 test2 (mpfr_asin, "mpfr_asin", p, (mpfr_rnd_t) rnd); 643 test2 (mpfr_acos, "mpfr_acos", p, (mpfr_rnd_t) rnd); 644 test2 (mpfr_atan, "mpfr_atan", p, (mpfr_rnd_t) rnd); 645 test2 (mpfr_cos, "mpfr_cos", p, (mpfr_rnd_t) rnd); 646 test2 (mpfr_sin, "mpfr_sin", p, (mpfr_rnd_t) rnd); 647 test2 (mpfr_tan, "mpfr_tan", p, (mpfr_rnd_t) rnd); 648 test2 (mpfr_sec, "mpfr_sec", p, (mpfr_rnd_t) rnd); 649 test2 (mpfr_csc, "mpfr_csc", p, (mpfr_rnd_t) rnd); 650 test2 (mpfr_cot, "mpfr_cot", p, (mpfr_rnd_t) rnd); 651 652 test2 (mpfr_erf, "mpfr_erf", p, (mpfr_rnd_t) rnd); 653 test2 (mpfr_erfc, "mpfr_erfc", p, (mpfr_rnd_t) rnd); 654 test2 (mpfr_j0, "mpfr_j0", p, (mpfr_rnd_t) rnd); 655 test2 (mpfr_j1, "mpfr_j1", p, (mpfr_rnd_t) rnd); 656 test2 (mpfr_y0, "mpfr_y0", p, (mpfr_rnd_t) rnd); 657 test2 (mpfr_y1, "mpfr_y1", p, (mpfr_rnd_t) rnd); 658 test2 (mpfr_zeta, "mpfr_zeta", p, (mpfr_rnd_t) rnd); 659 test2 (mpfr_gamma, "mpfr_gamma", p, (mpfr_rnd_t) rnd); 660 test2 (mpfr_lngamma, "mpfr_lngamma", p, (mpfr_rnd_t) rnd); 661 662 test2 (mpfr_rint, "mpfr_rint", p, (mpfr_rnd_t) rnd); 663 test2 (mpfr_rint_ceil, "mpfr_rint_ceil", p, (mpfr_rnd_t) rnd); 664 test2 (mpfr_rint_floor, "mpfr_rint_floor", p, (mpfr_rnd_t) rnd); 665 test2 (mpfr_rint_round, "mpfr_rint_round", p, (mpfr_rnd_t) rnd); 666 test2 (mpfr_rint_trunc, "mpfr_rint_trunc", p, (mpfr_rnd_t) rnd); 667 test2 (mpfr_frac, "mpfr_frac", p, (mpfr_rnd_t) rnd); 668 669 test3 (mpfr_add, "mpfr_add", p, (mpfr_rnd_t) rnd); 670 test3 (mpfr_sub, "mpfr_sub", p, (mpfr_rnd_t) rnd); 671 /* the following will generate a call to mpn_mul_n with 672 identical arguments */ 673 test3 (mpfr_mul, "mpfr_mul", p, (mpfr_rnd_t) rnd); 674 test3 (mpfr_div, "mpfr_div", p, (mpfr_rnd_t) rnd); 675 676 test3 (mpfr_agm, "mpfr_agm", p, (mpfr_rnd_t) rnd); 677 test3 (mpfr_min, "mpfr_min", p, (mpfr_rnd_t) rnd); 678 test3 (mpfr_max, "mpfr_max", p, (mpfr_rnd_t) rnd); 679 680 test3 (reldiff_wrapper, "mpfr_reldiff", p, (mpfr_rnd_t) rnd); 681 test3 (mpfr_dim, "mpfr_dim", p, (mpfr_rnd_t) rnd); 682 683 test3 (mpfr_remainder, "mpfr_remainder", p, (mpfr_rnd_t) rnd); 684 test3 (mpfr_pow, "mpfr_pow", p, (mpfr_rnd_t) rnd); 685 pow_int ((mpfr_rnd_t) rnd); 686 test3 (mpfr_atan2, "mpfr_atan2", p, (mpfr_rnd_t) rnd); 687 test3 (mpfr_hypot, "mpfr_hypot", p, (mpfr_rnd_t) rnd); 688 689 test3a (mpfr_sin_cos, "mpfr_sin_cos", p, (mpfr_rnd_t) rnd); 690 691 test4 (mpfr_fma, "mpfr_fma", p, (mpfr_rnd_t) rnd); 692 test4 (mpfr_fms, "mpfr_fms", p, (mpfr_rnd_t) rnd); 693 694 test2 (mpfr_li2, "mpfr_li2", p, (mpfr_rnd_t) rnd); 695 test2 (mpfr_rec_sqrt, "mpfr_rec_sqrt", p, (mpfr_rnd_t) rnd); 696 test3 (mpfr_fmod, "mpfr_fmod", p, (mpfr_rnd_t) rnd); 697 test3a (mpfr_modf, "mpfr_modf", p, (mpfr_rnd_t) rnd); 698 test3a (mpfr_sinh_cosh, "mpfr_sinh_cosh", p, (mpfr_rnd_t) rnd); 699 700 #if MPFR_VERSION >= MPFR_VERSION_NUM(3,0,0) 701 test2 (mpfr_ai, "mpfr_ai", p, (mpfr_rnd_t) rnd); 702 test2 (mpfr_digamma, "mpfr_digamma", p, (mpfr_rnd_t) rnd); 703 #endif 704 } 705 } 706 707 tests_end_mpfr (); 708 return 0; 709 } 710