testLoops.c revision 1.2
1 /* $NetBSD: testLoops.c,v 1.2 2001/03/13 06:48:56 ross Exp $ */ 2 3 /* 4 =============================================================================== 5 6 This C source file is part of TestFloat, Release 2a, a package of programs 7 for testing the correctness of floating-point arithmetic complying to the 8 IEC/IEEE Standard for Floating-Point. 9 10 Written by John R. Hauser. More information is available through the Web 11 page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'. 12 13 THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort 14 has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT 15 TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO 16 PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY 17 AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE. 18 19 Derivative works are acceptable, even for commercial purposes, so long as 20 (1) they include prominent notice that the work is derivative, and (2) they 21 include prominent notice akin to these four paragraphs for those parts of 22 this code that are retained. 23 24 =============================================================================== 25 */ 26 27 #include <stdlib.h> 28 #include <stdio.h> 29 #include "milieu.h" 30 #include "softfloat.h" 31 #include "testCases.h" 32 #include "writeHex.h" 33 #include "testLoops.h" 34 35 volatile flag stop = FALSE; 36 37 const char *trueName, *testName; 38 flag forever, errorStop; 39 uint32 maxErrorCount = 0; 40 flag checkNaNs = FALSE; 41 int8 *trueFlagsPtr; 42 int8 ( *testFlagsFunctionPtr )( void ); 43 const char *functionName; 44 const char *roundingPrecisionName, *roundingModeName, *tininessModeName; 45 flag anyErrors = FALSE; 46 47 void writeFunctionName( FILE *stream ) 48 { 49 50 fputs( functionName, stream ); 51 if ( roundingModeName ) { 52 if ( roundingPrecisionName ) { 53 fputs( ", precision ", stream ); 54 fputs( roundingPrecisionName, stream ); 55 } 56 fputs( ", rounding ", stream ); 57 fputs( roundingModeName, stream ); 58 if ( tininessModeName ) { 59 fputs( ", tininess ", stream ); 60 fputs( tininessModeName, stream ); 61 fputs( " rounding", stream ); 62 } 63 } 64 65 } 66 67 void exitWithStatus( void ) 68 { 69 70 exit( anyErrors ? EXIT_FAILURE : EXIT_SUCCESS ); 71 72 } 73 74 static uint32 tenthousandsCount, errorCount = 0; 75 76 static void writeTestsTotal( void ) 77 { 78 79 if ( forever ) { 80 fputs( "Unbounded tests.\n", stderr ); 81 } 82 else { 83 fprintf( stderr, "%d tests total.\n", testCases_total ); 84 } 85 86 } 87 88 static void writeTestsPerformed( int16 count ) 89 { 90 91 if ( tenthousandsCount ) { 92 fprintf( 93 stderr, "%d%04d tests performed", tenthousandsCount, count ); 94 } 95 else { 96 fprintf( stderr, "%d tests performed", count ); 97 } 98 if ( errorCount ) { 99 fprintf( 100 stderr, 101 "; %d error%s found.\n", 102 errorCount, 103 ( errorCount == 1 ) ? "" : "s" 104 ); 105 } 106 else { 107 fputs( ".\n", stderr ); 108 fputs( "No errors found in ", stdout ); 109 writeFunctionName( stdout ); 110 fputs( ".\n", stdout ); 111 fflush( stdout ); 112 } 113 114 } 115 116 static void checkEarlyExit( void ) 117 { 118 119 ++tenthousandsCount; 120 if ( stop ) { 121 writeTestsPerformed( 0 ); 122 exitWithStatus(); 123 } 124 fprintf( stderr, "%3d0000", tenthousandsCount ); 125 126 } 127 128 static void writeErrorFound( int16 count ) 129 { 130 131 if ( errorCount == 1 ) { 132 fputs( "Errors found in ", stdout ); 133 writeFunctionName( stdout ); 134 fputs( ":\n", stdout ); 135 } 136 if ( stop ) { 137 writeTestsPerformed( count ); 138 exitWithStatus(); 139 } 140 anyErrors = TRUE; 141 142 } 143 144 INLINE void writeInput_a_int32( void ) 145 { 146 147 writeHex_bits32( testCases_a_int32, stdout ); 148 149 } 150 151 #ifdef BITS64 152 153 INLINE void writeInput_a_int64( void ) 154 { 155 156 writeHex_bits64( testCases_a_int64, stdout ); 157 158 } 159 160 #endif 161 162 INLINE void writeInput_a_float32( void ) 163 { 164 165 writeHex_float32( testCases_a_float32, stdout ); 166 167 } 168 169 static void writeInputs_ab_float32( void ) 170 { 171 172 writeHex_float32( testCases_a_float32, stdout ); 173 fputs( " ", stdout ); 174 writeHex_float32( testCases_b_float32, stdout ); 175 176 } 177 178 INLINE void writeInput_a_float64( void ) 179 { 180 181 writeHex_float64( testCases_a_float64, stdout ); 182 183 } 184 185 static void writeInputs_ab_float64( void ) 186 { 187 188 writeHex_float64( testCases_a_float64, stdout ); 189 fputs( " ", stdout ); 190 writeHex_float64( testCases_b_float64, stdout ); 191 192 } 193 194 #ifdef FLOATX80 195 196 INLINE void writeInput_a_floatx80( void ) 197 { 198 199 writeHex_floatx80( testCases_a_floatx80, stdout ); 200 201 } 202 203 static void writeInputs_ab_floatx80( void ) 204 { 205 206 writeHex_floatx80( testCases_a_floatx80, stdout ); 207 fputs( " ", stdout ); 208 writeHex_floatx80( testCases_b_floatx80, stdout ); 209 210 } 211 212 #endif 213 214 #ifdef FLOAT128 215 216 INLINE void writeInput_a_float128( void ) 217 { 218 219 writeHex_float128( testCases_a_float128, stdout ); 220 221 } 222 223 static void writeInputs_ab_float128( void ) 224 { 225 226 writeHex_float128( testCases_a_float128, stdout ); 227 fputs( " ", stdout ); 228 writeHex_float128( testCases_b_float128, stdout ); 229 230 } 231 232 #endif 233 234 static void 235 writeOutputs_z_flag( 236 flag trueZ, uint8 trueFlags, flag testZ, uint8 testFlags ) 237 { 238 239 fputs( trueName, stdout ); 240 fputs( ": ", stdout ); 241 writeHex_flag( trueZ, stdout ); 242 fputc( ' ', stdout ); 243 writeHex_float_flags( trueFlags, stdout ); 244 fputs( " ", stdout ); 245 fputs( testName, stdout ); 246 fputs( ": ", stdout ); 247 writeHex_flag( testZ, stdout ); 248 fputc( ' ', stdout ); 249 writeHex_float_flags( testFlags, stdout ); 250 fputc( '\n', stdout ); 251 252 } 253 254 static void 255 writeOutputs_z_int32( 256 int32 trueZ, uint8 trueFlags, int32 testZ, uint8 testFlags ) 257 { 258 259 fputs( trueName, stdout ); 260 fputs( ": ", stdout ); 261 writeHex_bits32( trueZ, stdout ); 262 fputc( ' ', stdout ); 263 writeHex_float_flags( trueFlags, stdout ); 264 fputs( " ", stdout ); 265 fputs( testName, stdout ); 266 fputs( ": ", stdout ); 267 writeHex_bits32( testZ, stdout ); 268 fputc( ' ', stdout ); 269 writeHex_float_flags( testFlags, stdout ); 270 fputc( '\n', stdout ); 271 272 } 273 274 #ifdef BITS64 275 276 static void 277 writeOutputs_z_int64( 278 int64 trueZ, uint8 trueFlags, int64 testZ, uint8 testFlags ) 279 { 280 281 fputs( trueName, stdout ); 282 fputs( ": ", stdout ); 283 writeHex_bits64( trueZ, stdout ); 284 fputc( ' ', stdout ); 285 writeHex_float_flags( trueFlags, stdout ); 286 fputs( " ", stdout ); 287 fputs( testName, stdout ); 288 fputs( ": ", stdout ); 289 writeHex_bits64( testZ, stdout ); 290 fputc( ' ', stdout ); 291 writeHex_float_flags( testFlags, stdout ); 292 fputc( '\n', stdout ); 293 294 } 295 296 #endif 297 298 static void 299 writeOutputs_z_float32( 300 float32 trueZ, uint8 trueFlags, float32 testZ, uint8 testFlags ) 301 { 302 303 fputs( trueName, stdout ); 304 fputs( ": ", stdout ); 305 writeHex_float32( trueZ, stdout ); 306 fputc( ' ', stdout ); 307 writeHex_float_flags( trueFlags, stdout ); 308 fputs( " ", stdout ); 309 fputs( testName, stdout ); 310 fputs( ": ", stdout ); 311 writeHex_float32( testZ, stdout ); 312 fputc( ' ', stdout ); 313 writeHex_float_flags( testFlags, stdout ); 314 fputc( '\n', stdout ); 315 316 } 317 318 static void 319 writeOutputs_z_float64( 320 float64 trueZ, uint8 trueFlags, float64 testZ, uint8 testFlags ) 321 { 322 323 fputs( trueName, stdout ); 324 fputs( ": ", stdout ); 325 writeHex_float64( trueZ, stdout ); 326 fputc( ' ', stdout ); 327 writeHex_float_flags( trueFlags, stdout ); 328 fputs( " ", stdout ); 329 fputs( testName, stdout ); 330 fputs( ": ", stdout ); 331 writeHex_float64( testZ, stdout ); 332 fputc( ' ', stdout ); 333 writeHex_float_flags( testFlags, stdout ); 334 fputc( '\n', stdout ); 335 336 } 337 338 #ifdef FLOATX80 339 340 static void 341 writeOutputs_z_floatx80( 342 floatx80 trueZ, uint8 trueFlags, floatx80 testZ, uint8 testFlags ) 343 { 344 345 fputs( trueName, stdout ); 346 fputs( ": ", stdout ); 347 writeHex_floatx80( trueZ, stdout ); 348 fputc( ' ', stdout ); 349 writeHex_float_flags( trueFlags, stdout ); 350 fputs( " ", stdout ); 351 fputs( testName, stdout ); 352 fputs( ": ", stdout ); 353 writeHex_floatx80( testZ, stdout ); 354 fputc( ' ', stdout ); 355 writeHex_float_flags( testFlags, stdout ); 356 fputc( '\n', stdout ); 357 358 } 359 360 #endif 361 362 #ifdef FLOAT128 363 364 static void 365 writeOutputs_z_float128( 366 float128 trueZ, uint8 trueFlags, float128 testZ, uint8 testFlags ) 367 { 368 369 fputs( trueName, stdout ); 370 fputs( ": ", stdout ); 371 writeHex_float128( trueZ, stdout ); 372 fputc( ' ', stdout ); 373 writeHex_float_flags( trueFlags, stdout ); 374 fputs( "\n\t", stdout ); 375 fputs( testName, stdout ); 376 fputs( ": ", stdout ); 377 writeHex_float128( testZ, stdout ); 378 fputc( ' ', stdout ); 379 writeHex_float_flags( testFlags, stdout ); 380 fputc( '\n', stdout ); 381 382 } 383 384 #endif 385 386 INLINE flag float32_isNaN( float32 a ) 387 { 388 389 return 0x7F800000 < ( a & 0x7FFFFFFF ); 390 391 } 392 393 #ifdef BITS64 394 395 INLINE flag float64_same( float64 a, float64 b ) 396 { 397 398 return a == b; 399 400 } 401 402 INLINE flag float64_isNaN( float64 a ) 403 { 404 405 return LIT64( 0x7FF0000000000000 ) < ( a & LIT64( 0x7FFFFFFFFFFFFFFF ) ); 406 407 } 408 409 #else 410 411 INLINE flag float64_same( float64 a, float64 b ) 412 { 413 414 return ( a.high == b.high ) && ( a.low == b.low ); 415 416 } 417 418 INLINE flag float64_isNaN( float64 a ) 419 { 420 bits32 absAHigh; 421 422 absAHigh = a.high & 0x7FFFFFFF; 423 return 424 ( 0x7FF00000 < absAHigh ) || ( ( absAHigh == 0x7FF00000 ) && a.low ); 425 426 } 427 428 #endif 429 430 #ifdef FLOATX80 431 432 INLINE flag floatx80_same( floatx80 a, floatx80 b ) 433 { 434 435 return ( a.high == b.high ) && ( a.low == b.low ); 436 437 } 438 439 INLINE flag floatx80_isNaN( floatx80 a ) 440 { 441 442 return ( ( a.high & 0x7FFF ) == 0x7FFF ) && a.low; 443 444 } 445 446 #endif 447 448 #ifdef FLOAT128 449 450 INLINE flag float128_same( float128 a, float128 b ) 451 { 452 453 return ( a.high == b.high ) && ( a.low == b.low ); 454 455 } 456 457 INLINE flag float128_isNaN( float128 a ) 458 { 459 bits64 absAHigh; 460 461 absAHigh = a.high & LIT64( 0x7FFFFFFFFFFFFFFF ); 462 return 463 ( LIT64( 0x7FFF000000000000 ) < absAHigh ) 464 || ( ( absAHigh == LIT64( 0x7FFF000000000000 ) ) && a.low ); 465 466 } 467 468 #endif 469 470 void 471 test_a_int32_z_float32( 472 float32 trueFunction( int32 ), float32 testFunction( int32 ) ) 473 { 474 int16 count; 475 float32 trueZ, testZ; 476 uint8 trueFlags, testFlags; 477 478 errorCount = 0; 479 tenthousandsCount = 0; 480 count = 10000; 481 testCases_initSequence( testCases_sequence_a_int32 ); 482 writeTestsTotal(); 483 while ( ! testCases_done || forever ) { 484 testCases_next(); 485 *trueFlagsPtr = 0; 486 trueZ = trueFunction( testCases_a_int32 ); 487 trueFlags = *trueFlagsPtr; 488 (void) testFlagsFunctionPtr(); 489 testZ = testFunction( testCases_a_int32 ); 490 testFlags = testFlagsFunctionPtr(); 491 --count; 492 if ( count == 0 ) { 493 checkEarlyExit(); 494 count = 10000; 495 } 496 if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 497 if ( ! checkNaNs 498 && float32_isNaN( trueZ ) 499 && float32_isNaN( testZ ) 500 && ! float32_is_signaling_nan( testZ ) 501 && ( trueFlags == testFlags ) 502 ) { 503 /* no problem */ 504 } 505 else { 506 ++errorCount; 507 writeErrorFound( 10000 - count ); 508 writeInput_a_int32(); 509 fputs( " ", stdout ); 510 writeOutputs_z_float32( trueZ, trueFlags, testZ, testFlags ); 511 fflush( stdout ); 512 if ( errorCount == maxErrorCount ) goto exit; 513 } 514 } 515 } 516 exit: 517 writeTestsPerformed( 10000 - count ); 518 519 } 520 521 void 522 test_a_int32_z_float64( 523 float64 trueFunction( int32 ), float64 testFunction( int32 ) ) 524 { 525 int16 count; 526 float64 trueZ, testZ; 527 uint8 trueFlags, testFlags; 528 529 errorCount = 0; 530 tenthousandsCount = 0; 531 count = 10000; 532 testCases_initSequence( testCases_sequence_a_int32 ); 533 writeTestsTotal(); 534 while ( ! testCases_done || forever ) { 535 testCases_next(); 536 *trueFlagsPtr = 0; 537 trueZ = trueFunction( testCases_a_int32 ); 538 trueFlags = *trueFlagsPtr; 539 (void) testFlagsFunctionPtr(); 540 testZ = testFunction( testCases_a_int32 ); 541 testFlags = testFlagsFunctionPtr(); 542 --count; 543 if ( count == 0 ) { 544 checkEarlyExit(); 545 count = 10000; 546 } 547 if ( ! float64_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 548 if ( ! checkNaNs 549 && float64_isNaN( trueZ ) 550 && float64_isNaN( testZ ) 551 && ! float64_is_signaling_nan( testZ ) 552 && ( trueFlags == testFlags ) 553 ) { 554 /* no problem */ 555 } 556 else { 557 ++errorCount; 558 writeErrorFound( 10000 - count ); 559 writeInput_a_int32(); 560 fputs( " ", stdout ); 561 writeOutputs_z_float64( trueZ, trueFlags, testZ, testFlags ); 562 fflush( stdout ); 563 if ( errorCount == maxErrorCount ) goto exit; 564 } 565 } 566 } 567 exit: 568 writeTestsPerformed( 10000 - count ); 569 570 } 571 572 #ifdef FLOATX80 573 574 void 575 test_a_int32_z_floatx80( 576 floatx80 trueFunction( int32 ), floatx80 testFunction( int32 ) ) 577 { 578 int16 count; 579 floatx80 trueZ, testZ; 580 uint8 trueFlags, testFlags; 581 582 errorCount = 0; 583 tenthousandsCount = 0; 584 count = 10000; 585 testCases_initSequence( testCases_sequence_a_int32 ); 586 writeTestsTotal(); 587 while ( ! testCases_done || forever ) { 588 testCases_next(); 589 *trueFlagsPtr = 0; 590 trueZ = trueFunction( testCases_a_int32 ); 591 trueFlags = *trueFlagsPtr; 592 (void) testFlagsFunctionPtr(); 593 testZ = testFunction( testCases_a_int32 ); 594 testFlags = testFlagsFunctionPtr(); 595 --count; 596 if ( count == 0 ) { 597 checkEarlyExit(); 598 count = 10000; 599 } 600 if ( ! floatx80_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 601 if ( ! checkNaNs 602 && floatx80_isNaN( trueZ ) 603 && floatx80_isNaN( testZ ) 604 && ! floatx80_is_signaling_nan( testZ ) 605 && ( trueFlags == testFlags ) 606 ) { 607 /* no problem */ 608 } 609 else { 610 ++errorCount; 611 writeErrorFound( 10000 - count ); 612 writeInput_a_int32(); 613 fputs( " ", stdout ); 614 writeOutputs_z_floatx80( trueZ, trueFlags, testZ, testFlags ); 615 fflush( stdout ); 616 if ( errorCount == maxErrorCount ) goto exit; 617 } 618 } 619 } 620 exit: 621 writeTestsPerformed( 10000 - count ); 622 623 } 624 625 #endif 626 627 #ifdef FLOAT128 628 629 void 630 test_a_int32_z_float128( 631 float128 trueFunction( int32 ), float128 testFunction( int32 ) ) 632 { 633 int16 count; 634 float128 trueZ, testZ; 635 uint8 trueFlags, testFlags; 636 637 errorCount = 0; 638 tenthousandsCount = 0; 639 count = 10000; 640 testCases_initSequence( testCases_sequence_a_int32 ); 641 writeTestsTotal(); 642 while ( ! testCases_done || forever ) { 643 testCases_next(); 644 *trueFlagsPtr = 0; 645 trueZ = trueFunction( testCases_a_int32 ); 646 trueFlags = *trueFlagsPtr; 647 (void) testFlagsFunctionPtr(); 648 testZ = testFunction( testCases_a_int32 ); 649 testFlags = testFlagsFunctionPtr(); 650 --count; 651 if ( count == 0 ) { 652 checkEarlyExit(); 653 count = 10000; 654 } 655 if ( ! float128_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 656 if ( ! checkNaNs 657 && float128_isNaN( trueZ ) 658 && float128_isNaN( testZ ) 659 && ! float128_is_signaling_nan( testZ ) 660 && ( trueFlags == testFlags ) 661 ) { 662 /* no problem */ 663 } 664 else { 665 ++errorCount; 666 writeErrorFound( 10000 - count ); 667 writeInput_a_int32(); 668 fputs( "\n\t", stdout ); 669 writeOutputs_z_float128( trueZ, trueFlags, testZ, testFlags ); 670 fflush( stdout ); 671 if ( errorCount == maxErrorCount ) goto exit; 672 } 673 } 674 } 675 exit: 676 writeTestsPerformed( 10000 - count ); 677 678 } 679 680 #endif 681 682 #ifdef BITS64 683 684 void 685 test_a_int64_z_float32( 686 float32 trueFunction( int64 ), float32 testFunction( int64 ) ) 687 { 688 int16 count; 689 float32 trueZ, testZ; 690 uint8 trueFlags, testFlags; 691 692 errorCount = 0; 693 tenthousandsCount = 0; 694 count = 10000; 695 testCases_initSequence( testCases_sequence_a_int64 ); 696 writeTestsTotal(); 697 while ( ! testCases_done || forever ) { 698 testCases_next(); 699 *trueFlagsPtr = 0; 700 trueZ = trueFunction( testCases_a_int64 ); 701 trueFlags = *trueFlagsPtr; 702 (void) testFlagsFunctionPtr(); 703 testZ = testFunction( testCases_a_int64 ); 704 testFlags = testFlagsFunctionPtr(); 705 --count; 706 if ( count == 0 ) { 707 checkEarlyExit(); 708 count = 10000; 709 } 710 if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 711 if ( ! checkNaNs 712 && float32_isNaN( trueZ ) 713 && float32_isNaN( testZ ) 714 && ! float32_is_signaling_nan( testZ ) 715 && ( trueFlags == testFlags ) 716 ) { 717 /* no problem */ 718 } 719 else { 720 ++errorCount; 721 writeErrorFound( 10000 - count ); 722 writeInput_a_int64(); 723 fputs( " ", stdout ); 724 writeOutputs_z_float32( trueZ, trueFlags, testZ, testFlags ); 725 fflush( stdout ); 726 if ( errorCount == maxErrorCount ) goto exit; 727 } 728 } 729 } 730 exit: 731 writeTestsPerformed( 10000 - count ); 732 733 } 734 735 void 736 test_a_int64_z_float64( 737 float64 trueFunction( int64 ), float64 testFunction( int64 ) ) 738 { 739 int16 count; 740 float64 trueZ, testZ; 741 uint8 trueFlags, testFlags; 742 743 errorCount = 0; 744 tenthousandsCount = 0; 745 count = 10000; 746 testCases_initSequence( testCases_sequence_a_int64 ); 747 writeTestsTotal(); 748 while ( ! testCases_done || forever ) { 749 testCases_next(); 750 *trueFlagsPtr = 0; 751 trueZ = trueFunction( testCases_a_int64 ); 752 trueFlags = *trueFlagsPtr; 753 (void) testFlagsFunctionPtr(); 754 testZ = testFunction( testCases_a_int64 ); 755 testFlags = testFlagsFunctionPtr(); 756 --count; 757 if ( count == 0 ) { 758 checkEarlyExit(); 759 count = 10000; 760 } 761 if ( ! float64_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 762 if ( ! checkNaNs 763 && float64_isNaN( trueZ ) 764 && float64_isNaN( testZ ) 765 && ! float64_is_signaling_nan( testZ ) 766 && ( trueFlags == testFlags ) 767 ) { 768 /* no problem */ 769 } 770 else { 771 ++errorCount; 772 writeErrorFound( 10000 - count ); 773 writeInput_a_int64(); 774 fputs( " ", stdout ); 775 writeOutputs_z_float64( trueZ, trueFlags, testZ, testFlags ); 776 fflush( stdout ); 777 if ( errorCount == maxErrorCount ) goto exit; 778 } 779 } 780 } 781 exit: 782 writeTestsPerformed( 10000 - count ); 783 784 } 785 786 #ifdef FLOATX80 787 788 void 789 test_a_int64_z_floatx80( 790 floatx80 trueFunction( int64 ), floatx80 testFunction( int64 ) ) 791 { 792 int16 count; 793 floatx80 trueZ, testZ; 794 uint8 trueFlags, testFlags; 795 796 errorCount = 0; 797 tenthousandsCount = 0; 798 count = 10000; 799 testCases_initSequence( testCases_sequence_a_int64 ); 800 writeTestsTotal(); 801 while ( ! testCases_done || forever ) { 802 testCases_next(); 803 *trueFlagsPtr = 0; 804 trueZ = trueFunction( testCases_a_int64 ); 805 trueFlags = *trueFlagsPtr; 806 (void) testFlagsFunctionPtr(); 807 testZ = testFunction( testCases_a_int64 ); 808 testFlags = testFlagsFunctionPtr(); 809 --count; 810 if ( count == 0 ) { 811 checkEarlyExit(); 812 count = 10000; 813 } 814 if ( ! floatx80_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 815 if ( ! checkNaNs 816 && floatx80_isNaN( trueZ ) 817 && floatx80_isNaN( testZ ) 818 && ! floatx80_is_signaling_nan( testZ ) 819 && ( trueFlags == testFlags ) 820 ) { 821 /* no problem */ 822 } 823 else { 824 ++errorCount; 825 writeErrorFound( 10000 - count ); 826 writeInput_a_int64(); 827 fputs( " ", stdout ); 828 writeOutputs_z_floatx80( trueZ, trueFlags, testZ, testFlags ); 829 fflush( stdout ); 830 if ( errorCount == maxErrorCount ) goto exit; 831 } 832 } 833 } 834 exit: 835 writeTestsPerformed( 10000 - count ); 836 837 } 838 839 #endif 840 841 #ifdef FLOAT128 842 843 void 844 test_a_int64_z_float128( 845 float128 trueFunction( int64 ), float128 testFunction( int64 ) ) 846 { 847 int16 count; 848 float128 trueZ, testZ; 849 uint8 trueFlags, testFlags; 850 851 errorCount = 0; 852 tenthousandsCount = 0; 853 count = 10000; 854 testCases_initSequence( testCases_sequence_a_int64 ); 855 writeTestsTotal(); 856 while ( ! testCases_done || forever ) { 857 testCases_next(); 858 *trueFlagsPtr = 0; 859 trueZ = trueFunction( testCases_a_int64 ); 860 trueFlags = *trueFlagsPtr; 861 (void) testFlagsFunctionPtr(); 862 testZ = testFunction( testCases_a_int64 ); 863 testFlags = testFlagsFunctionPtr(); 864 --count; 865 if ( count == 0 ) { 866 checkEarlyExit(); 867 count = 10000; 868 } 869 if ( ! float128_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 870 if ( ! checkNaNs 871 && float128_isNaN( trueZ ) 872 && float128_isNaN( testZ ) 873 && ! float128_is_signaling_nan( testZ ) 874 && ( trueFlags == testFlags ) 875 ) { 876 /* no problem */ 877 } 878 else { 879 ++errorCount; 880 writeErrorFound( 10000 - count ); 881 writeInput_a_int64(); 882 fputs( "\n\t", stdout ); 883 writeOutputs_z_float128( trueZ, trueFlags, testZ, testFlags ); 884 fflush( stdout ); 885 if ( errorCount == maxErrorCount ) goto exit; 886 } 887 } 888 } 889 exit: 890 writeTestsPerformed( 10000 - count ); 891 892 } 893 894 #endif 895 896 #endif 897 898 void 899 test_a_float32_z_int32( 900 int32 trueFunction( float32 ), int32 testFunction( float32 ) ) 901 { 902 int16 count; 903 int32 trueZ, testZ; 904 uint8 trueFlags, testFlags; 905 906 errorCount = 0; 907 tenthousandsCount = 0; 908 count = 10000; 909 testCases_initSequence( testCases_sequence_a_float32 ); 910 writeTestsTotal(); 911 while ( ! testCases_done || forever ) { 912 testCases_next(); 913 *trueFlagsPtr = 0; 914 trueZ = trueFunction( testCases_a_float32 ); 915 trueFlags = *trueFlagsPtr; 916 (void) testFlagsFunctionPtr(); 917 testZ = testFunction( testCases_a_float32 ); 918 testFlags = testFlagsFunctionPtr(); 919 --count; 920 if ( count == 0 ) { 921 checkEarlyExit(); 922 count = 10000; 923 } 924 if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 925 if ( ! checkNaNs 926 && float32_is_signaling_nan( testCases_a_float32 ) ) { 927 trueFlags |= float_flag_invalid; 928 } 929 if ( ( trueZ == 0x7FFFFFFF ) 930 && ( ( testZ == 0x7FFFFFFF ) 931 || ( testZ == (sbits32) 0x80000000 ) ) 932 && ( trueFlags == float_flag_invalid ) 933 && ( testFlags == float_flag_invalid ) 934 ) { 935 /* no problem */ 936 } 937 else { 938 ++errorCount; 939 writeErrorFound( 10000 - count ); 940 writeInput_a_float32(); 941 fputs( " ", stdout ); 942 writeOutputs_z_int32( trueZ, trueFlags, testZ, testFlags ); 943 fflush( stdout ); 944 if ( errorCount == maxErrorCount ) goto exit; 945 } 946 } 947 } 948 exit: 949 writeTestsPerformed( 10000 - count ); 950 951 } 952 953 #ifdef BITS64 954 955 void 956 test_a_float32_z_int64( 957 int64 trueFunction( float32 ), int64 testFunction( float32 ) ) 958 { 959 int16 count; 960 int64 trueZ, testZ; 961 uint8 trueFlags, testFlags; 962 963 errorCount = 0; 964 tenthousandsCount = 0; 965 count = 10000; 966 testCases_initSequence( testCases_sequence_a_float32 ); 967 writeTestsTotal(); 968 while ( ! testCases_done || forever ) { 969 testCases_next(); 970 *trueFlagsPtr = 0; 971 trueZ = trueFunction( testCases_a_float32 ); 972 trueFlags = *trueFlagsPtr; 973 (void) testFlagsFunctionPtr(); 974 testZ = testFunction( testCases_a_float32 ); 975 testFlags = testFlagsFunctionPtr(); 976 --count; 977 if ( count == 0 ) { 978 checkEarlyExit(); 979 count = 10000; 980 } 981 if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 982 if ( ! checkNaNs 983 && float32_is_signaling_nan( testCases_a_float32 ) ) { 984 trueFlags |= float_flag_invalid; 985 } 986 if ( ( trueZ == LIT64( 0x7FFFFFFFFFFFFFFF ) ) 987 && ( ( testZ == LIT64( 0x7FFFFFFFFFFFFFFF ) ) 988 || ( testZ == (sbits64) LIT64( 0x8000000000000000 ) ) ) 989 && ( trueFlags == float_flag_invalid ) 990 && ( testFlags == float_flag_invalid ) 991 ) { 992 /* no problem */ 993 } 994 else { 995 ++errorCount; 996 writeErrorFound( 10000 - count ); 997 writeInput_a_float32(); 998 fputs( " ", stdout ); 999 writeOutputs_z_int64( trueZ, trueFlags, testZ, testFlags ); 1000 fflush( stdout ); 1001 if ( errorCount == maxErrorCount ) goto exit; 1002 } 1003 } 1004 } 1005 exit: 1006 writeTestsPerformed( 10000 - count ); 1007 1008 } 1009 1010 #endif 1011 1012 void 1013 test_a_float32_z_float64( 1014 float64 trueFunction( float32 ), float64 testFunction( float32 ) ) 1015 { 1016 int16 count; 1017 float64 trueZ, testZ; 1018 uint8 trueFlags, testFlags; 1019 1020 errorCount = 0; 1021 tenthousandsCount = 0; 1022 count = 10000; 1023 testCases_initSequence( testCases_sequence_a_float32 ); 1024 writeTestsTotal(); 1025 while ( ! testCases_done || forever ) { 1026 testCases_next(); 1027 *trueFlagsPtr = 0; 1028 trueZ = trueFunction( testCases_a_float32 ); 1029 trueFlags = *trueFlagsPtr; 1030 (void) testFlagsFunctionPtr(); 1031 testZ = testFunction( testCases_a_float32 ); 1032 testFlags = testFlagsFunctionPtr(); 1033 --count; 1034 if ( count == 0 ) { 1035 checkEarlyExit(); 1036 count = 10000; 1037 } 1038 if ( ! float64_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 1039 if ( ! checkNaNs 1040 && float32_is_signaling_nan( testCases_a_float32 ) ) { 1041 trueFlags |= float_flag_invalid; 1042 } 1043 if ( ! checkNaNs 1044 && float64_isNaN( trueZ ) 1045 && float64_isNaN( testZ ) 1046 && ! float64_is_signaling_nan( testZ ) 1047 && ( trueFlags == testFlags ) 1048 ) { 1049 /* no problem */ 1050 } 1051 else { 1052 ++errorCount; 1053 writeErrorFound( 10000 - count ); 1054 writeInput_a_float32(); 1055 fputs( " ", stdout ); 1056 writeOutputs_z_float64( trueZ, trueFlags, testZ, testFlags ); 1057 fflush( stdout ); 1058 if ( errorCount == maxErrorCount ) goto exit; 1059 } 1060 } 1061 } 1062 exit: 1063 writeTestsPerformed( 10000 - count ); 1064 1065 } 1066 1067 #ifdef FLOATX80 1068 1069 void 1070 test_a_float32_z_floatx80( 1071 floatx80 trueFunction( float32 ), floatx80 testFunction( float32 ) ) 1072 { 1073 int16 count; 1074 floatx80 trueZ, testZ; 1075 uint8 trueFlags, testFlags; 1076 1077 errorCount = 0; 1078 tenthousandsCount = 0; 1079 count = 10000; 1080 testCases_initSequence( testCases_sequence_a_float32 ); 1081 writeTestsTotal(); 1082 while ( ! testCases_done || forever ) { 1083 testCases_next(); 1084 *trueFlagsPtr = 0; 1085 trueZ = trueFunction( testCases_a_float32 ); 1086 trueFlags = *trueFlagsPtr; 1087 (void) testFlagsFunctionPtr(); 1088 testZ = testFunction( testCases_a_float32 ); 1089 testFlags = testFlagsFunctionPtr(); 1090 --count; 1091 if ( count == 0 ) { 1092 checkEarlyExit(); 1093 count = 10000; 1094 } 1095 if ( ! floatx80_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 1096 if ( ! checkNaNs 1097 && float32_is_signaling_nan( testCases_a_float32 ) ) { 1098 trueFlags |= float_flag_invalid; 1099 } 1100 if ( ! checkNaNs 1101 && floatx80_isNaN( trueZ ) 1102 && floatx80_isNaN( testZ ) 1103 && ! floatx80_is_signaling_nan( testZ ) 1104 && ( trueFlags == testFlags ) 1105 ) { 1106 /* no problem */ 1107 } 1108 else { 1109 ++errorCount; 1110 writeErrorFound( 10000 - count ); 1111 writeInput_a_float32(); 1112 fputs( "\n\t", stdout ); 1113 writeOutputs_z_floatx80( trueZ, trueFlags, testZ, testFlags ); 1114 fflush( stdout ); 1115 if ( errorCount == maxErrorCount ) goto exit; 1116 } 1117 } 1118 } 1119 exit: 1120 writeTestsPerformed( 10000 - count ); 1121 1122 } 1123 1124 #endif 1125 1126 #ifdef FLOAT128 1127 1128 void 1129 test_a_float32_z_float128( 1130 float128 trueFunction( float32 ), float128 testFunction( float32 ) ) 1131 { 1132 int16 count; 1133 float128 trueZ, testZ; 1134 uint8 trueFlags, testFlags; 1135 1136 errorCount = 0; 1137 tenthousandsCount = 0; 1138 count = 10000; 1139 testCases_initSequence( testCases_sequence_a_float32 ); 1140 writeTestsTotal(); 1141 while ( ! testCases_done || forever ) { 1142 testCases_next(); 1143 *trueFlagsPtr = 0; 1144 trueZ = trueFunction( testCases_a_float32 ); 1145 trueFlags = *trueFlagsPtr; 1146 (void) testFlagsFunctionPtr(); 1147 testZ = testFunction( testCases_a_float32 ); 1148 testFlags = testFlagsFunctionPtr(); 1149 --count; 1150 if ( count == 0 ) { 1151 checkEarlyExit(); 1152 count = 10000; 1153 } 1154 if ( ! float128_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 1155 if ( ! checkNaNs 1156 && float32_is_signaling_nan( testCases_a_float32 ) ) { 1157 trueFlags |= float_flag_invalid; 1158 } 1159 if ( ! checkNaNs 1160 && float128_isNaN( trueZ ) 1161 && float128_isNaN( testZ ) 1162 && ! float128_is_signaling_nan( testZ ) 1163 && ( trueFlags == testFlags ) 1164 ) { 1165 /* no problem */ 1166 } 1167 else { 1168 ++errorCount; 1169 writeErrorFound( 10000 - count ); 1170 writeInput_a_float32(); 1171 fputs( "\n\t", stdout ); 1172 writeOutputs_z_float128( trueZ, trueFlags, testZ, testFlags ); 1173 fflush( stdout ); 1174 if ( errorCount == maxErrorCount ) goto exit; 1175 } 1176 } 1177 } 1178 exit: 1179 writeTestsPerformed( 10000 - count ); 1180 1181 } 1182 1183 #endif 1184 1185 void 1186 test_az_float32( 1187 float32 trueFunction( float32 ), float32 testFunction( float32 ) ) 1188 { 1189 int16 count; 1190 float32 trueZ, testZ; 1191 uint8 trueFlags, testFlags; 1192 1193 errorCount = 0; 1194 tenthousandsCount = 0; 1195 count = 10000; 1196 testCases_initSequence( testCases_sequence_a_float32 ); 1197 writeTestsTotal(); 1198 while ( ! testCases_done || forever ) { 1199 testCases_next(); 1200 *trueFlagsPtr = 0; 1201 trueZ = trueFunction( testCases_a_float32 ); 1202 trueFlags = *trueFlagsPtr; 1203 (void) testFlagsFunctionPtr(); 1204 testZ = testFunction( testCases_a_float32 ); 1205 testFlags = testFlagsFunctionPtr(); 1206 --count; 1207 if ( count == 0 ) { 1208 checkEarlyExit(); 1209 count = 10000; 1210 } 1211 if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1212 if ( ! checkNaNs 1213 && float32_is_signaling_nan( testCases_a_float32 ) ) { 1214 trueFlags |= float_flag_invalid; 1215 } 1216 if ( ! checkNaNs 1217 && float32_isNaN( trueZ ) 1218 && float32_isNaN( testZ ) 1219 && ! float32_is_signaling_nan( testZ ) 1220 && ( trueFlags == testFlags ) 1221 ) { 1222 /* no problem */ 1223 } 1224 else { 1225 ++errorCount; 1226 writeErrorFound( 10000 - count ); 1227 writeInput_a_float32(); 1228 fputs( " ", stdout ); 1229 writeOutputs_z_float32( trueZ, trueFlags, testZ, testFlags ); 1230 fflush( stdout ); 1231 if ( errorCount == maxErrorCount ) goto exit; 1232 } 1233 } 1234 } 1235 exit: 1236 writeTestsPerformed( 10000 - count ); 1237 1238 } 1239 1240 void 1241 test_ab_float32_z_flag( 1242 flag trueFunction( float32, float32 ), 1243 flag testFunction( float32, float32 ) 1244 ) 1245 { 1246 int16 count; 1247 flag trueZ, testZ; 1248 uint8 trueFlags, testFlags; 1249 1250 errorCount = 0; 1251 tenthousandsCount = 0; 1252 count = 10000; 1253 testCases_initSequence( testCases_sequence_ab_float32 ); 1254 writeTestsTotal(); 1255 while ( ! testCases_done || forever ) { 1256 testCases_next(); 1257 *trueFlagsPtr = 0; 1258 trueZ = trueFunction( testCases_a_float32, testCases_b_float32 ); 1259 trueFlags = *trueFlagsPtr; 1260 (void) testFlagsFunctionPtr(); 1261 testZ = testFunction( testCases_a_float32, testCases_b_float32 ); 1262 testFlags = testFlagsFunctionPtr(); 1263 --count; 1264 if ( count == 0 ) { 1265 checkEarlyExit(); 1266 count = 10000; 1267 } 1268 if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1269 if ( ! checkNaNs 1270 && ( float32_is_signaling_nan( testCases_a_float32 ) 1271 || float32_is_signaling_nan( testCases_b_float32 ) ) 1272 ) { 1273 trueFlags |= float_flag_invalid; 1274 } 1275 if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1276 ++errorCount; 1277 writeErrorFound( 10000 - count ); 1278 writeInputs_ab_float32(); 1279 fputs( " ", stdout ); 1280 writeOutputs_z_flag( trueZ, trueFlags, testZ, testFlags ); 1281 fflush( stdout ); 1282 if ( errorCount == maxErrorCount ) goto exit; 1283 } 1284 } 1285 } 1286 exit: 1287 writeTestsPerformed( 10000 - count ); 1288 return; 1289 1290 } 1291 1292 void 1293 test_abz_float32( 1294 float32 trueFunction( float32, float32 ), 1295 float32 testFunction( float32, float32 ) 1296 ) 1297 { 1298 int16 count; 1299 float32 trueZ, testZ; 1300 uint8 trueFlags, testFlags; 1301 1302 errorCount = 0; 1303 tenthousandsCount = 0; 1304 count = 10000; 1305 testCases_initSequence( testCases_sequence_ab_float32 ); 1306 writeTestsTotal(); 1307 while ( ! testCases_done || forever ) { 1308 testCases_next(); 1309 *trueFlagsPtr = 0; 1310 trueZ = trueFunction( testCases_a_float32, testCases_b_float32 ); 1311 trueFlags = *trueFlagsPtr; 1312 (void) testFlagsFunctionPtr(); 1313 testZ = testFunction( testCases_a_float32, testCases_b_float32 ); 1314 testFlags = testFlagsFunctionPtr(); 1315 --count; 1316 if ( count == 0 ) { 1317 checkEarlyExit(); 1318 count = 10000; 1319 } 1320 if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1321 if ( ! checkNaNs 1322 && ( float32_is_signaling_nan( testCases_a_float32 ) 1323 || float32_is_signaling_nan( testCases_b_float32 ) ) 1324 ) { 1325 trueFlags |= float_flag_invalid; 1326 } 1327 if ( ! checkNaNs 1328 && float32_isNaN( trueZ ) 1329 && float32_isNaN( testZ ) 1330 && ! float32_is_signaling_nan( testZ ) 1331 && ( trueFlags == testFlags ) 1332 ) { 1333 /* no problem */ 1334 } 1335 else { 1336 ++errorCount; 1337 writeErrorFound( 10000 - count ); 1338 writeInputs_ab_float32(); 1339 fputs( " ", stdout ); 1340 writeOutputs_z_float32( trueZ, trueFlags, testZ, testFlags ); 1341 fflush( stdout ); 1342 if ( errorCount == maxErrorCount ) goto exit; 1343 } 1344 } 1345 } 1346 exit: 1347 writeTestsPerformed( 10000 - count ); 1348 return; 1349 1350 } 1351 1352 void 1353 test_a_float64_z_int32( 1354 int32 trueFunction( float64 ), int32 testFunction( float64 ) ) 1355 { 1356 int16 count; 1357 int32 trueZ, testZ; 1358 uint8 trueFlags, testFlags; 1359 1360 errorCount = 0; 1361 tenthousandsCount = 0; 1362 count = 10000; 1363 testCases_initSequence( testCases_sequence_a_float64 ); 1364 writeTestsTotal(); 1365 while ( ! testCases_done || forever ) { 1366 testCases_next(); 1367 *trueFlagsPtr = 0; 1368 trueZ = trueFunction( testCases_a_float64 ); 1369 trueFlags = *trueFlagsPtr; 1370 (void) testFlagsFunctionPtr(); 1371 testZ = testFunction( testCases_a_float64 ); 1372 testFlags = testFlagsFunctionPtr(); 1373 --count; 1374 if ( count == 0 ) { 1375 checkEarlyExit(); 1376 count = 10000; 1377 } 1378 if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1379 if ( ! checkNaNs 1380 && float64_is_signaling_nan( testCases_a_float64 ) ) { 1381 trueFlags |= float_flag_invalid; 1382 } 1383 if ( ( trueZ == 0x7FFFFFFF ) 1384 && ( ( testZ == 0x7FFFFFFF ) 1385 || ( testZ == (sbits32) 0x80000000 ) ) 1386 && ( trueFlags == float_flag_invalid ) 1387 && ( testFlags == float_flag_invalid ) 1388 ) { 1389 /* no problem */ 1390 } 1391 else { 1392 ++errorCount; 1393 writeErrorFound( 10000 - count ); 1394 writeInput_a_float64(); 1395 fputs( " ", stdout ); 1396 writeOutputs_z_int32( trueZ, trueFlags, testZ, testFlags ); 1397 fflush( stdout ); 1398 if ( errorCount == maxErrorCount ) goto exit; 1399 } 1400 } 1401 } 1402 exit: 1403 writeTestsPerformed( 10000 - count ); 1404 1405 } 1406 1407 #ifdef BITS64 1408 1409 void 1410 test_a_float64_z_int64( 1411 int64 trueFunction( float64 ), int64 testFunction( float64 ) ) 1412 { 1413 int16 count; 1414 int64 trueZ, testZ; 1415 uint8 trueFlags, testFlags; 1416 1417 errorCount = 0; 1418 tenthousandsCount = 0; 1419 count = 10000; 1420 testCases_initSequence( testCases_sequence_a_float64 ); 1421 writeTestsTotal(); 1422 while ( ! testCases_done || forever ) { 1423 testCases_next(); 1424 *trueFlagsPtr = 0; 1425 trueZ = trueFunction( testCases_a_float64 ); 1426 trueFlags = *trueFlagsPtr; 1427 (void) testFlagsFunctionPtr(); 1428 testZ = testFunction( testCases_a_float64 ); 1429 testFlags = testFlagsFunctionPtr(); 1430 --count; 1431 if ( count == 0 ) { 1432 checkEarlyExit(); 1433 count = 10000; 1434 } 1435 if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1436 if ( ! checkNaNs 1437 && float64_is_signaling_nan( testCases_a_float64 ) ) { 1438 trueFlags |= float_flag_invalid; 1439 } 1440 if ( ( trueZ == LIT64( 0x7FFFFFFFFFFFFFFF ) ) 1441 && ( ( testZ == LIT64( 0x7FFFFFFFFFFFFFFF ) ) 1442 || ( testZ == (sbits64) LIT64( 0x8000000000000000 ) ) ) 1443 && ( trueFlags == float_flag_invalid ) 1444 && ( testFlags == float_flag_invalid ) 1445 ) { 1446 /* no problem */ 1447 } 1448 else { 1449 ++errorCount; 1450 writeErrorFound( 10000 - count ); 1451 writeInput_a_float64(); 1452 fputs( " ", stdout ); 1453 writeOutputs_z_int64( trueZ, trueFlags, testZ, testFlags ); 1454 fflush( stdout ); 1455 if ( errorCount == maxErrorCount ) goto exit; 1456 } 1457 } 1458 } 1459 exit: 1460 writeTestsPerformed( 10000 - count ); 1461 1462 } 1463 1464 #endif 1465 1466 void 1467 test_a_float64_z_float32( 1468 float32 trueFunction( float64 ), float32 testFunction( float64 ) ) 1469 { 1470 int16 count; 1471 float32 trueZ, testZ; 1472 uint8 trueFlags, testFlags; 1473 1474 errorCount = 0; 1475 tenthousandsCount = 0; 1476 count = 10000; 1477 testCases_initSequence( testCases_sequence_a_float64 ); 1478 writeTestsTotal(); 1479 while ( ! testCases_done || forever ) { 1480 testCases_next(); 1481 *trueFlagsPtr = 0; 1482 trueZ = trueFunction( testCases_a_float64 ); 1483 trueFlags = *trueFlagsPtr; 1484 (void) testFlagsFunctionPtr(); 1485 testZ = testFunction( testCases_a_float64 ); 1486 testFlags = testFlagsFunctionPtr(); 1487 --count; 1488 if ( count == 0 ) { 1489 checkEarlyExit(); 1490 count = 10000; 1491 } 1492 if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1493 if ( ! checkNaNs 1494 && float64_is_signaling_nan( testCases_a_float64 ) ) { 1495 trueFlags |= float_flag_invalid; 1496 } 1497 if ( ! checkNaNs 1498 && float32_isNaN( trueZ ) 1499 && float32_isNaN( testZ ) 1500 && ! float32_is_signaling_nan( testZ ) 1501 && ( trueFlags == testFlags ) 1502 ) { 1503 /* no problem */ 1504 } 1505 else { 1506 ++errorCount; 1507 writeErrorFound( 10000 - count ); 1508 writeInput_a_float64(); 1509 fputs( " ", stdout ); 1510 writeOutputs_z_float32( trueZ, trueFlags, testZ, testFlags ); 1511 fflush( stdout ); 1512 if ( errorCount == maxErrorCount ) goto exit; 1513 } 1514 } 1515 } 1516 exit: 1517 writeTestsPerformed( 10000 - count ); 1518 1519 } 1520 1521 #ifdef FLOATX80 1522 1523 void 1524 test_a_float64_z_floatx80( 1525 floatx80 trueFunction( float64 ), floatx80 testFunction( float64 ) ) 1526 { 1527 int16 count; 1528 floatx80 trueZ, testZ; 1529 uint8 trueFlags, testFlags; 1530 1531 errorCount = 0; 1532 tenthousandsCount = 0; 1533 count = 10000; 1534 testCases_initSequence( testCases_sequence_a_float64 ); 1535 writeTestsTotal(); 1536 while ( ! testCases_done || forever ) { 1537 testCases_next(); 1538 *trueFlagsPtr = 0; 1539 trueZ = trueFunction( testCases_a_float64 ); 1540 trueFlags = *trueFlagsPtr; 1541 (void) testFlagsFunctionPtr(); 1542 testZ = testFunction( testCases_a_float64 ); 1543 testFlags = testFlagsFunctionPtr(); 1544 --count; 1545 if ( count == 0 ) { 1546 checkEarlyExit(); 1547 count = 10000; 1548 } 1549 if ( ! floatx80_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 1550 if ( ! checkNaNs 1551 && float64_is_signaling_nan( testCases_a_float64 ) ) { 1552 trueFlags |= float_flag_invalid; 1553 } 1554 if ( ! checkNaNs 1555 && floatx80_isNaN( trueZ ) 1556 && floatx80_isNaN( testZ ) 1557 && ! floatx80_is_signaling_nan( testZ ) 1558 && ( trueFlags == testFlags ) 1559 ) { 1560 /* no problem */ 1561 } 1562 else { 1563 ++errorCount; 1564 writeErrorFound( 10000 - count ); 1565 writeInput_a_float64(); 1566 fputs( "\n\t", stdout ); 1567 writeOutputs_z_floatx80( trueZ, trueFlags, testZ, testFlags ); 1568 fflush( stdout ); 1569 if ( errorCount == maxErrorCount ) goto exit; 1570 } 1571 } 1572 } 1573 exit: 1574 writeTestsPerformed( 10000 - count ); 1575 1576 } 1577 1578 #endif 1579 1580 #ifdef FLOAT128 1581 1582 void 1583 test_a_float64_z_float128( 1584 float128 trueFunction( float64 ), float128 testFunction( float64 ) ) 1585 { 1586 int16 count; 1587 float128 trueZ, testZ; 1588 uint8 trueFlags, testFlags; 1589 1590 errorCount = 0; 1591 tenthousandsCount = 0; 1592 count = 10000; 1593 testCases_initSequence( testCases_sequence_a_float64 ); 1594 writeTestsTotal(); 1595 while ( ! testCases_done || forever ) { 1596 testCases_next(); 1597 *trueFlagsPtr = 0; 1598 trueZ = trueFunction( testCases_a_float64 ); 1599 trueFlags = *trueFlagsPtr; 1600 (void) testFlagsFunctionPtr(); 1601 testZ = testFunction( testCases_a_float64 ); 1602 testFlags = testFlagsFunctionPtr(); 1603 --count; 1604 if ( count == 0 ) { 1605 checkEarlyExit(); 1606 count = 10000; 1607 } 1608 if ( ! float128_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 1609 if ( ! checkNaNs 1610 && float64_is_signaling_nan( testCases_a_float64 ) ) { 1611 trueFlags |= float_flag_invalid; 1612 } 1613 if ( ! checkNaNs 1614 && float128_isNaN( trueZ ) 1615 && float128_isNaN( testZ ) 1616 && ! float128_is_signaling_nan( testZ ) 1617 && ( trueFlags == testFlags ) 1618 ) { 1619 /* no problem */ 1620 } 1621 else { 1622 ++errorCount; 1623 writeErrorFound( 10000 - count ); 1624 writeInput_a_float64(); 1625 fputs( "\n\t", stdout ); 1626 writeOutputs_z_float128( trueZ, trueFlags, testZ, testFlags ); 1627 fflush( stdout ); 1628 if ( errorCount == maxErrorCount ) goto exit; 1629 } 1630 } 1631 } 1632 exit: 1633 writeTestsPerformed( 10000 - count ); 1634 1635 } 1636 1637 #endif 1638 1639 void 1640 test_az_float64( 1641 float64 trueFunction( float64 ), float64 testFunction( float64 ) ) 1642 { 1643 int16 count; 1644 float64 trueZ, testZ; 1645 uint8 trueFlags, testFlags; 1646 1647 errorCount = 0; 1648 tenthousandsCount = 0; 1649 count = 10000; 1650 testCases_initSequence( testCases_sequence_a_float64 ); 1651 writeTestsTotal(); 1652 while ( ! testCases_done || forever ) { 1653 testCases_next(); 1654 *trueFlagsPtr = 0; 1655 trueZ = trueFunction( testCases_a_float64 ); 1656 trueFlags = *trueFlagsPtr; 1657 (void) testFlagsFunctionPtr(); 1658 testZ = testFunction( testCases_a_float64 ); 1659 testFlags = testFlagsFunctionPtr(); 1660 --count; 1661 if ( count == 0 ) { 1662 checkEarlyExit(); 1663 count = 10000; 1664 } 1665 if ( ! float64_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 1666 if ( ! checkNaNs 1667 && float64_is_signaling_nan( testCases_a_float64 ) ) { 1668 trueFlags |= float_flag_invalid; 1669 } 1670 if ( ! checkNaNs 1671 && float64_isNaN( trueZ ) 1672 && float64_isNaN( testZ ) 1673 && ! float64_is_signaling_nan( testZ ) 1674 && ( trueFlags == testFlags ) 1675 ) { 1676 /* no problem */ 1677 } 1678 else { 1679 ++errorCount; 1680 writeErrorFound( 10000 - count ); 1681 writeInput_a_float64(); 1682 fputs( " ", stdout ); 1683 writeOutputs_z_float64( trueZ, trueFlags, testZ, testFlags ); 1684 fflush( stdout ); 1685 if ( errorCount == maxErrorCount ) goto exit; 1686 } 1687 } 1688 } 1689 exit: 1690 writeTestsPerformed( 10000 - count ); 1691 1692 } 1693 1694 void 1695 test_ab_float64_z_flag( 1696 flag trueFunction( float64, float64 ), 1697 flag testFunction( float64, float64 ) 1698 ) 1699 { 1700 int16 count; 1701 flag trueZ, testZ; 1702 uint8 trueFlags, testFlags; 1703 1704 errorCount = 0; 1705 tenthousandsCount = 0; 1706 count = 10000; 1707 testCases_initSequence( testCases_sequence_ab_float64 ); 1708 writeTestsTotal(); 1709 while ( ! testCases_done || forever ) { 1710 testCases_next(); 1711 *trueFlagsPtr = 0; 1712 trueZ = trueFunction( testCases_a_float64, testCases_b_float64 ); 1713 trueFlags = *trueFlagsPtr; 1714 (void) testFlagsFunctionPtr(); 1715 testZ = testFunction( testCases_a_float64, testCases_b_float64 ); 1716 testFlags = testFlagsFunctionPtr(); 1717 --count; 1718 if ( count == 0 ) { 1719 checkEarlyExit(); 1720 count = 10000; 1721 } 1722 if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1723 if ( ! checkNaNs 1724 && ( float64_is_signaling_nan( testCases_a_float64 ) 1725 || float64_is_signaling_nan( testCases_b_float64 ) ) 1726 ) { 1727 trueFlags |= float_flag_invalid; 1728 } 1729 if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1730 ++errorCount; 1731 writeErrorFound( 10000 - count ); 1732 writeInputs_ab_float64(); 1733 fputs( " ", stdout ); 1734 writeOutputs_z_flag( trueZ, trueFlags, testZ, testFlags ); 1735 fflush( stdout ); 1736 if ( errorCount == maxErrorCount ) goto exit; 1737 } 1738 } 1739 } 1740 exit: 1741 writeTestsPerformed( 10000 - count ); 1742 return; 1743 1744 } 1745 1746 void 1747 test_abz_float64( 1748 float64 trueFunction( float64, float64 ), 1749 float64 testFunction( float64, float64 ) 1750 ) 1751 { 1752 int16 count; 1753 float64 trueZ, testZ; 1754 uint8 trueFlags, testFlags; 1755 1756 errorCount = 0; 1757 tenthousandsCount = 0; 1758 count = 10000; 1759 testCases_initSequence( testCases_sequence_ab_float64 ); 1760 writeTestsTotal(); 1761 while ( ! testCases_done || forever ) { 1762 testCases_next(); 1763 *trueFlagsPtr = 0; 1764 trueZ = trueFunction( testCases_a_float64, testCases_b_float64 ); 1765 trueFlags = *trueFlagsPtr; 1766 (void) testFlagsFunctionPtr(); 1767 testZ = testFunction( testCases_a_float64, testCases_b_float64 ); 1768 testFlags = testFlagsFunctionPtr(); 1769 --count; 1770 if ( count == 0 ) { 1771 checkEarlyExit(); 1772 count = 10000; 1773 } 1774 if ( ! float64_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 1775 if ( ! checkNaNs 1776 && ( float64_is_signaling_nan( testCases_a_float64 ) 1777 || float64_is_signaling_nan( testCases_b_float64 ) ) 1778 ) { 1779 trueFlags |= float_flag_invalid; 1780 } 1781 if ( ! checkNaNs 1782 && float64_isNaN( trueZ ) 1783 && float64_isNaN( testZ ) 1784 && ! float64_is_signaling_nan( testZ ) 1785 && ( trueFlags == testFlags ) 1786 ) { 1787 /* no problem */ 1788 } 1789 else { 1790 ++errorCount; 1791 writeErrorFound( 10000 - count ); 1792 writeInputs_ab_float64(); 1793 fputs( "\n\t", stdout ); 1794 writeOutputs_z_float64( trueZ, trueFlags, testZ, testFlags ); 1795 fflush( stdout ); 1796 if ( errorCount == maxErrorCount ) goto exit; 1797 } 1798 } 1799 } 1800 exit: 1801 writeTestsPerformed( 10000 - count ); 1802 return; 1803 1804 } 1805 1806 #ifdef FLOATX80 1807 1808 void 1809 test_a_floatx80_z_int32( 1810 int32 trueFunction( floatx80 ), int32 testFunction( floatx80 ) ) 1811 { 1812 int16 count; 1813 int32 trueZ, testZ; 1814 uint8 trueFlags, testFlags; 1815 1816 errorCount = 0; 1817 tenthousandsCount = 0; 1818 count = 10000; 1819 testCases_initSequence( testCases_sequence_a_floatx80 ); 1820 writeTestsTotal(); 1821 while ( ! testCases_done || forever ) { 1822 testCases_next(); 1823 *trueFlagsPtr = 0; 1824 trueZ = trueFunction( testCases_a_floatx80 ); 1825 trueFlags = *trueFlagsPtr; 1826 (void) testFlagsFunctionPtr(); 1827 testZ = testFunction( testCases_a_floatx80 ); 1828 testFlags = testFlagsFunctionPtr(); 1829 --count; 1830 if ( count == 0 ) { 1831 checkEarlyExit(); 1832 count = 10000; 1833 } 1834 if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1835 if ( ! checkNaNs 1836 && floatx80_is_signaling_nan( testCases_a_floatx80 ) ) { 1837 trueFlags |= float_flag_invalid; 1838 } 1839 if ( ( trueZ == 0x7FFFFFFF ) 1840 && ( ( testZ == 0x7FFFFFFF ) 1841 || ( testZ == (sbits32) 0x80000000 ) ) 1842 && ( trueFlags == float_flag_invalid ) 1843 && ( testFlags == float_flag_invalid ) 1844 ) { 1845 /* no problem */ 1846 } 1847 else { 1848 ++errorCount; 1849 writeErrorFound( 10000 - count ); 1850 writeInput_a_floatx80(); 1851 fputs( " ", stdout ); 1852 writeOutputs_z_int32( trueZ, trueFlags, testZ, testFlags ); 1853 fflush( stdout ); 1854 if ( errorCount == maxErrorCount ) goto exit; 1855 } 1856 } 1857 } 1858 exit: 1859 writeTestsPerformed( 10000 - count ); 1860 1861 } 1862 1863 #ifdef BITS64 1864 1865 void 1866 test_a_floatx80_z_int64( 1867 int64 trueFunction( floatx80 ), int64 testFunction( floatx80 ) ) 1868 { 1869 int16 count; 1870 int64 trueZ, testZ; 1871 uint8 trueFlags, testFlags; 1872 1873 errorCount = 0; 1874 tenthousandsCount = 0; 1875 count = 10000; 1876 testCases_initSequence( testCases_sequence_a_floatx80 ); 1877 writeTestsTotal(); 1878 while ( ! testCases_done || forever ) { 1879 testCases_next(); 1880 *trueFlagsPtr = 0; 1881 trueZ = trueFunction( testCases_a_floatx80 ); 1882 trueFlags = *trueFlagsPtr; 1883 (void) testFlagsFunctionPtr(); 1884 testZ = testFunction( testCases_a_floatx80 ); 1885 testFlags = testFlagsFunctionPtr(); 1886 --count; 1887 if ( count == 0 ) { 1888 checkEarlyExit(); 1889 count = 10000; 1890 } 1891 if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1892 if ( ! checkNaNs 1893 && floatx80_is_signaling_nan( testCases_a_floatx80 ) ) { 1894 trueFlags |= float_flag_invalid; 1895 } 1896 if ( ( trueZ == LIT64( 0x7FFFFFFFFFFFFFFF ) ) 1897 && ( ( testZ == LIT64( 0x7FFFFFFFFFFFFFFF ) ) 1898 || ( testZ == (sbits64) LIT64( 0x8000000000000000 ) ) ) 1899 && ( trueFlags == float_flag_invalid ) 1900 && ( testFlags == float_flag_invalid ) 1901 ) { 1902 /* no problem */ 1903 } 1904 else { 1905 ++errorCount; 1906 writeErrorFound( 10000 - count ); 1907 writeInput_a_floatx80(); 1908 fputs( " ", stdout ); 1909 writeOutputs_z_int64( trueZ, trueFlags, testZ, testFlags ); 1910 fflush( stdout ); 1911 if ( errorCount == maxErrorCount ) goto exit; 1912 } 1913 } 1914 } 1915 exit: 1916 writeTestsPerformed( 10000 - count ); 1917 1918 } 1919 1920 #endif 1921 1922 void 1923 test_a_floatx80_z_float32( 1924 float32 trueFunction( floatx80 ), float32 testFunction( floatx80 ) ) 1925 { 1926 int16 count; 1927 float32 trueZ, testZ; 1928 uint8 trueFlags, testFlags; 1929 1930 errorCount = 0; 1931 tenthousandsCount = 0; 1932 count = 10000; 1933 testCases_initSequence( testCases_sequence_a_floatx80 ); 1934 writeTestsTotal(); 1935 while ( ! testCases_done || forever ) { 1936 testCases_next(); 1937 *trueFlagsPtr = 0; 1938 trueZ = trueFunction( testCases_a_floatx80 ); 1939 trueFlags = *trueFlagsPtr; 1940 (void) testFlagsFunctionPtr(); 1941 testZ = testFunction( testCases_a_floatx80 ); 1942 testFlags = testFlagsFunctionPtr(); 1943 --count; 1944 if ( count == 0 ) { 1945 checkEarlyExit(); 1946 count = 10000; 1947 } 1948 if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1949 if ( ! checkNaNs 1950 && floatx80_is_signaling_nan( testCases_a_floatx80 ) ) { 1951 trueFlags |= float_flag_invalid; 1952 } 1953 if ( ! checkNaNs 1954 && float32_isNaN( trueZ ) 1955 && float32_isNaN( testZ ) 1956 && ! float32_is_signaling_nan( testZ ) 1957 && ( trueFlags == testFlags ) 1958 ) { 1959 /* no problem */ 1960 } 1961 else { 1962 ++errorCount; 1963 writeErrorFound( 10000 - count ); 1964 writeInput_a_floatx80(); 1965 fputs( " ", stdout ); 1966 writeOutputs_z_float32( trueZ, trueFlags, testZ, testFlags ); 1967 fflush( stdout ); 1968 if ( errorCount == maxErrorCount ) goto exit; 1969 } 1970 } 1971 } 1972 exit: 1973 writeTestsPerformed( 10000 - count ); 1974 1975 } 1976 1977 void 1978 test_a_floatx80_z_float64( 1979 float64 trueFunction( floatx80 ), float64 testFunction( floatx80 ) ) 1980 { 1981 int16 count; 1982 float64 trueZ, testZ; 1983 uint8 trueFlags, testFlags; 1984 1985 errorCount = 0; 1986 tenthousandsCount = 0; 1987 count = 10000; 1988 testCases_initSequence( testCases_sequence_a_floatx80 ); 1989 writeTestsTotal(); 1990 while ( ! testCases_done || forever ) { 1991 testCases_next(); 1992 *trueFlagsPtr = 0; 1993 trueZ = trueFunction( testCases_a_floatx80 ); 1994 trueFlags = *trueFlagsPtr; 1995 (void) testFlagsFunctionPtr(); 1996 testZ = testFunction( testCases_a_floatx80 ); 1997 testFlags = testFlagsFunctionPtr(); 1998 --count; 1999 if ( count == 0 ) { 2000 checkEarlyExit(); 2001 count = 10000; 2002 } 2003 if ( ! float64_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 2004 if ( ! checkNaNs 2005 && floatx80_is_signaling_nan( testCases_a_floatx80 ) ) { 2006 trueFlags |= float_flag_invalid; 2007 } 2008 if ( ! checkNaNs 2009 && float64_isNaN( trueZ ) 2010 && float64_isNaN( testZ ) 2011 && ! float64_is_signaling_nan( testZ ) 2012 && ( trueFlags == testFlags ) 2013 ) { 2014 /* no problem */ 2015 } 2016 else { 2017 ++errorCount; 2018 writeErrorFound( 10000 - count ); 2019 writeInput_a_floatx80(); 2020 fputs( "\n\t", stdout ); 2021 writeOutputs_z_float64( trueZ, trueFlags, testZ, testFlags ); 2022 fflush( stdout ); 2023 if ( errorCount == maxErrorCount ) goto exit; 2024 } 2025 } 2026 } 2027 exit: 2028 writeTestsPerformed( 10000 - count ); 2029 2030 } 2031 2032 #ifdef FLOAT128 2033 2034 void 2035 test_a_floatx80_z_float128( 2036 float128 trueFunction( floatx80 ), float128 testFunction( floatx80 ) ) 2037 { 2038 int16 count; 2039 float128 trueZ, testZ; 2040 uint8 trueFlags, testFlags; 2041 2042 errorCount = 0; 2043 tenthousandsCount = 0; 2044 count = 10000; 2045 testCases_initSequence( testCases_sequence_a_floatx80 ); 2046 writeTestsTotal(); 2047 while ( ! testCases_done || forever ) { 2048 testCases_next(); 2049 *trueFlagsPtr = 0; 2050 trueZ = trueFunction( testCases_a_floatx80 ); 2051 trueFlags = *trueFlagsPtr; 2052 (void) testFlagsFunctionPtr(); 2053 testZ = testFunction( testCases_a_floatx80 ); 2054 testFlags = testFlagsFunctionPtr(); 2055 --count; 2056 if ( count == 0 ) { 2057 checkEarlyExit(); 2058 count = 10000; 2059 } 2060 if ( ! float128_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 2061 if ( ! checkNaNs 2062 && floatx80_is_signaling_nan( testCases_a_floatx80 ) ) { 2063 trueFlags |= float_flag_invalid; 2064 } 2065 if ( ! checkNaNs 2066 && float128_isNaN( trueZ ) 2067 && float128_isNaN( testZ ) 2068 && ! float128_is_signaling_nan( testZ ) 2069 && ( trueFlags == testFlags ) 2070 ) { 2071 /* no problem */ 2072 } 2073 else { 2074 ++errorCount; 2075 writeErrorFound( 10000 - count ); 2076 writeInput_a_floatx80(); 2077 fputs( "\n\t", stdout ); 2078 writeOutputs_z_float128( trueZ, trueFlags, testZ, testFlags ); 2079 fflush( stdout ); 2080 if ( errorCount == maxErrorCount ) goto exit; 2081 } 2082 } 2083 } 2084 exit: 2085 writeTestsPerformed( 10000 - count ); 2086 2087 } 2088 2089 #endif 2090 2091 void 2092 test_az_floatx80( 2093 floatx80 trueFunction( floatx80 ), floatx80 testFunction( floatx80 ) ) 2094 { 2095 int16 count; 2096 floatx80 trueZ, testZ; 2097 uint8 trueFlags, testFlags; 2098 2099 errorCount = 0; 2100 tenthousandsCount = 0; 2101 count = 10000; 2102 testCases_initSequence( testCases_sequence_a_floatx80 ); 2103 writeTestsTotal(); 2104 while ( ! testCases_done || forever ) { 2105 testCases_next(); 2106 *trueFlagsPtr = 0; 2107 trueZ = trueFunction( testCases_a_floatx80 ); 2108 trueFlags = *trueFlagsPtr; 2109 (void) testFlagsFunctionPtr(); 2110 testZ = testFunction( testCases_a_floatx80 ); 2111 testFlags = testFlagsFunctionPtr(); 2112 --count; 2113 if ( count == 0 ) { 2114 checkEarlyExit(); 2115 count = 10000; 2116 } 2117 if ( ! floatx80_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 2118 if ( ! checkNaNs 2119 && floatx80_is_signaling_nan( testCases_a_floatx80 ) ) { 2120 trueFlags |= float_flag_invalid; 2121 } 2122 if ( ! checkNaNs 2123 && floatx80_isNaN( trueZ ) 2124 && floatx80_isNaN( testZ ) 2125 && ! floatx80_is_signaling_nan( testZ ) 2126 && ( trueFlags == testFlags ) 2127 ) { 2128 /* no problem */ 2129 } 2130 else { 2131 ++errorCount; 2132 writeErrorFound( 10000 - count ); 2133 writeInput_a_floatx80(); 2134 fputs( "\n\t", stdout ); 2135 writeOutputs_z_floatx80( trueZ, trueFlags, testZ, testFlags ); 2136 fflush( stdout ); 2137 if ( errorCount == maxErrorCount ) goto exit; 2138 } 2139 } 2140 } 2141 exit: 2142 writeTestsPerformed( 10000 - count ); 2143 2144 } 2145 2146 void 2147 test_ab_floatx80_z_flag( 2148 flag trueFunction( floatx80, floatx80 ), 2149 flag testFunction( floatx80, floatx80 ) 2150 ) 2151 { 2152 int16 count; 2153 flag trueZ, testZ; 2154 uint8 trueFlags, testFlags; 2155 2156 errorCount = 0; 2157 tenthousandsCount = 0; 2158 count = 10000; 2159 testCases_initSequence( testCases_sequence_ab_floatx80 ); 2160 writeTestsTotal(); 2161 while ( ! testCases_done || forever ) { 2162 testCases_next(); 2163 *trueFlagsPtr = 0; 2164 trueZ = trueFunction( testCases_a_floatx80, testCases_b_floatx80 ); 2165 trueFlags = *trueFlagsPtr; 2166 (void) testFlagsFunctionPtr(); 2167 testZ = testFunction( testCases_a_floatx80, testCases_b_floatx80 ); 2168 testFlags = testFlagsFunctionPtr(); 2169 --count; 2170 if ( count == 0 ) { 2171 checkEarlyExit(); 2172 count = 10000; 2173 } 2174 if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 2175 if ( ! checkNaNs 2176 && ( floatx80_is_signaling_nan( testCases_a_floatx80 ) 2177 || floatx80_is_signaling_nan( testCases_b_floatx80 ) ) 2178 ) { 2179 trueFlags |= float_flag_invalid; 2180 } 2181 if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 2182 ++errorCount; 2183 writeErrorFound( 10000 - count ); 2184 writeInputs_ab_floatx80(); 2185 fputs( " ", stdout ); 2186 writeOutputs_z_flag( trueZ, trueFlags, testZ, testFlags ); 2187 fflush( stdout ); 2188 if ( errorCount == maxErrorCount ) goto exit; 2189 } 2190 } 2191 } 2192 exit: 2193 writeTestsPerformed( 10000 - count ); 2194 return; 2195 2196 } 2197 2198 void 2199 test_abz_floatx80( 2200 floatx80 trueFunction( floatx80, floatx80 ), 2201 floatx80 testFunction( floatx80, floatx80 ) 2202 ) 2203 { 2204 int16 count; 2205 floatx80 trueZ, testZ; 2206 uint8 trueFlags, testFlags; 2207 2208 errorCount = 0; 2209 tenthousandsCount = 0; 2210 count = 10000; 2211 testCases_initSequence( testCases_sequence_ab_floatx80 ); 2212 writeTestsTotal(); 2213 while ( ! testCases_done || forever ) { 2214 testCases_next(); 2215 *trueFlagsPtr = 0; 2216 trueZ = trueFunction( testCases_a_floatx80, testCases_b_floatx80 ); 2217 trueFlags = *trueFlagsPtr; 2218 (void) testFlagsFunctionPtr(); 2219 testZ = testFunction( testCases_a_floatx80, testCases_b_floatx80 ); 2220 testFlags = testFlagsFunctionPtr(); 2221 --count; 2222 if ( count == 0 ) { 2223 checkEarlyExit(); 2224 count = 10000; 2225 } 2226 if ( ! floatx80_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 2227 if ( ! checkNaNs 2228 && ( floatx80_is_signaling_nan( testCases_a_floatx80 ) 2229 || floatx80_is_signaling_nan( testCases_b_floatx80 ) ) 2230 ) { 2231 trueFlags |= float_flag_invalid; 2232 } 2233 if ( ! checkNaNs 2234 && floatx80_isNaN( trueZ ) 2235 && floatx80_isNaN( testZ ) 2236 && ! floatx80_is_signaling_nan( testZ ) 2237 && ( trueFlags == testFlags ) 2238 ) { 2239 /* no problem */ 2240 } 2241 else { 2242 ++errorCount; 2243 writeErrorFound( 10000 - count ); 2244 writeInputs_ab_floatx80(); 2245 fputs( "\n\t", stdout ); 2246 writeOutputs_z_floatx80( trueZ, trueFlags, testZ, testFlags ); 2247 fflush( stdout ); 2248 if ( errorCount == maxErrorCount ) goto exit; 2249 } 2250 } 2251 } 2252 exit: 2253 writeTestsPerformed( 10000 - count ); 2254 return; 2255 2256 } 2257 2258 #endif 2259 2260 #ifdef FLOAT128 2261 2262 void 2263 test_a_float128_z_int32( 2264 int32 trueFunction( float128 ), int32 testFunction( float128 ) ) 2265 { 2266 int16 count; 2267 int32 trueZ, testZ; 2268 uint8 trueFlags, testFlags; 2269 2270 errorCount = 0; 2271 tenthousandsCount = 0; 2272 count = 10000; 2273 testCases_initSequence( testCases_sequence_a_float128 ); 2274 writeTestsTotal(); 2275 while ( ! testCases_done || forever ) { 2276 testCases_next(); 2277 *trueFlagsPtr = 0; 2278 trueZ = trueFunction( testCases_a_float128 ); 2279 trueFlags = *trueFlagsPtr; 2280 (void) testFlagsFunctionPtr(); 2281 testZ = testFunction( testCases_a_float128 ); 2282 testFlags = testFlagsFunctionPtr(); 2283 --count; 2284 if ( count == 0 ) { 2285 checkEarlyExit(); 2286 count = 10000; 2287 } 2288 if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 2289 if ( ! checkNaNs 2290 && float128_is_signaling_nan( testCases_a_float128 ) ) { 2291 trueFlags |= float_flag_invalid; 2292 } 2293 if ( ( trueZ == 0x7FFFFFFF ) 2294 && ( ( testZ == 0x7FFFFFFF ) 2295 || ( testZ == (sbits32) 0x80000000 ) ) 2296 && ( trueFlags == float_flag_invalid ) 2297 && ( testFlags == float_flag_invalid ) 2298 ) { 2299 /* no problem */ 2300 } 2301 else { 2302 ++errorCount; 2303 writeErrorFound( 10000 - count ); 2304 writeInput_a_float128(); 2305 fputs( " ", stdout ); 2306 writeOutputs_z_int32( trueZ, trueFlags, testZ, testFlags ); 2307 fflush( stdout ); 2308 if ( errorCount == maxErrorCount ) goto exit; 2309 } 2310 } 2311 } 2312 exit: 2313 writeTestsPerformed( 10000 - count ); 2314 2315 } 2316 2317 #ifdef BITS64 2318 2319 void 2320 test_a_float128_z_int64( 2321 int64 trueFunction( float128 ), int64 testFunction( float128 ) ) 2322 { 2323 int16 count; 2324 int64 trueZ, testZ; 2325 uint8 trueFlags, testFlags; 2326 2327 errorCount = 0; 2328 tenthousandsCount = 0; 2329 count = 10000; 2330 testCases_initSequence( testCases_sequence_a_float128 ); 2331 writeTestsTotal(); 2332 while ( ! testCases_done || forever ) { 2333 testCases_next(); 2334 *trueFlagsPtr = 0; 2335 trueZ = trueFunction( testCases_a_float128 ); 2336 trueFlags = *trueFlagsPtr; 2337 (void) testFlagsFunctionPtr(); 2338 testZ = testFunction( testCases_a_float128 ); 2339 testFlags = testFlagsFunctionPtr(); 2340 --count; 2341 if ( count == 0 ) { 2342 checkEarlyExit(); 2343 count = 10000; 2344 } 2345 if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 2346 if ( ! checkNaNs 2347 && float128_is_signaling_nan( testCases_a_float128 ) ) { 2348 trueFlags |= float_flag_invalid; 2349 } 2350 if ( ( trueZ == LIT64( 0x7FFFFFFFFFFFFFFF ) ) 2351 && ( ( testZ == LIT64( 0x7FFFFFFFFFFFFFFF ) ) 2352 || ( testZ == (sbits64) LIT64( 0x8000000000000000 ) ) ) 2353 && ( trueFlags == float_flag_invalid ) 2354 && ( testFlags == float_flag_invalid ) 2355 ) { 2356 /* no problem */ 2357 } 2358 else { 2359 ++errorCount; 2360 writeErrorFound( 10000 - count ); 2361 writeInput_a_float128(); 2362 fputs( "\n\t", stdout ); 2363 writeOutputs_z_int64( trueZ, trueFlags, testZ, testFlags ); 2364 fflush( stdout ); 2365 if ( errorCount == maxErrorCount ) goto exit; 2366 } 2367 } 2368 } 2369 exit: 2370 writeTestsPerformed( 10000 - count ); 2371 2372 } 2373 2374 #endif 2375 2376 void 2377 test_a_float128_z_float32( 2378 float32 trueFunction( float128 ), float32 testFunction( float128 ) ) 2379 { 2380 int16 count; 2381 float32 trueZ, testZ; 2382 uint8 trueFlags, testFlags; 2383 2384 errorCount = 0; 2385 tenthousandsCount = 0; 2386 count = 10000; 2387 testCases_initSequence( testCases_sequence_a_float128 ); 2388 writeTestsTotal(); 2389 while ( ! testCases_done || forever ) { 2390 testCases_next(); 2391 *trueFlagsPtr = 0; 2392 trueZ = trueFunction( testCases_a_float128 ); 2393 trueFlags = *trueFlagsPtr; 2394 (void) testFlagsFunctionPtr(); 2395 testZ = testFunction( testCases_a_float128 ); 2396 testFlags = testFlagsFunctionPtr(); 2397 --count; 2398 if ( count == 0 ) { 2399 checkEarlyExit(); 2400 count = 10000; 2401 } 2402 if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 2403 if ( ! checkNaNs 2404 && float128_is_signaling_nan( testCases_a_float128 ) ) { 2405 trueFlags |= float_flag_invalid; 2406 } 2407 if ( ! checkNaNs 2408 && float32_isNaN( trueZ ) 2409 && float32_isNaN( testZ ) 2410 && ! float32_is_signaling_nan( testZ ) 2411 && ( trueFlags == testFlags ) 2412 ) { 2413 /* no problem */ 2414 } 2415 else { 2416 ++errorCount; 2417 writeErrorFound( 10000 - count ); 2418 writeInput_a_float128(); 2419 fputs( " ", stdout ); 2420 writeOutputs_z_float32( trueZ, trueFlags, testZ, testFlags ); 2421 fflush( stdout ); 2422 if ( errorCount == maxErrorCount ) goto exit; 2423 } 2424 } 2425 } 2426 exit: 2427 writeTestsPerformed( 10000 - count ); 2428 2429 } 2430 2431 void 2432 test_a_float128_z_float64( 2433 float64 trueFunction( float128 ), float64 testFunction( float128 ) ) 2434 { 2435 int16 count; 2436 float64 trueZ, testZ; 2437 uint8 trueFlags, testFlags; 2438 2439 errorCount = 0; 2440 tenthousandsCount = 0; 2441 count = 10000; 2442 testCases_initSequence( testCases_sequence_a_float128 ); 2443 writeTestsTotal(); 2444 while ( ! testCases_done || forever ) { 2445 testCases_next(); 2446 *trueFlagsPtr = 0; 2447 trueZ = trueFunction( testCases_a_float128 ); 2448 trueFlags = *trueFlagsPtr; 2449 (void) testFlagsFunctionPtr(); 2450 testZ = testFunction( testCases_a_float128 ); 2451 testFlags = testFlagsFunctionPtr(); 2452 --count; 2453 if ( count == 0 ) { 2454 checkEarlyExit(); 2455 count = 10000; 2456 } 2457 if ( ! float64_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 2458 if ( ! checkNaNs 2459 && float128_is_signaling_nan( testCases_a_float128 ) ) { 2460 trueFlags |= float_flag_invalid; 2461 } 2462 if ( ! checkNaNs 2463 && float64_isNaN( trueZ ) 2464 && float64_isNaN( testZ ) 2465 && ! float64_is_signaling_nan( testZ ) 2466 && ( trueFlags == testFlags ) 2467 ) { 2468 /* no problem */ 2469 } 2470 else { 2471 ++errorCount; 2472 writeErrorFound( 10000 - count ); 2473 writeInput_a_float128(); 2474 fputs( "\n\t", stdout ); 2475 writeOutputs_z_float64( trueZ, trueFlags, testZ, testFlags ); 2476 fflush( stdout ); 2477 if ( errorCount == maxErrorCount ) goto exit; 2478 } 2479 } 2480 } 2481 exit: 2482 writeTestsPerformed( 10000 - count ); 2483 2484 } 2485 2486 #ifdef FLOATX80 2487 2488 void 2489 test_a_float128_z_floatx80( 2490 floatx80 trueFunction( float128 ), floatx80 testFunction( float128 ) ) 2491 { 2492 int16 count; 2493 floatx80 trueZ, testZ; 2494 uint8 trueFlags, testFlags; 2495 2496 errorCount = 0; 2497 tenthousandsCount = 0; 2498 count = 10000; 2499 testCases_initSequence( testCases_sequence_a_float128 ); 2500 writeTestsTotal(); 2501 while ( ! testCases_done || forever ) { 2502 testCases_next(); 2503 *trueFlagsPtr = 0; 2504 trueZ = trueFunction( testCases_a_float128 ); 2505 trueFlags = *trueFlagsPtr; 2506 (void) testFlagsFunctionPtr(); 2507 testZ = testFunction( testCases_a_float128 ); 2508 testFlags = testFlagsFunctionPtr(); 2509 --count; 2510 if ( count == 0 ) { 2511 checkEarlyExit(); 2512 count = 10000; 2513 } 2514 if ( ! floatx80_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 2515 if ( ! checkNaNs 2516 && float128_is_signaling_nan( testCases_a_float128 ) ) { 2517 trueFlags |= float_flag_invalid; 2518 } 2519 if ( ! checkNaNs 2520 && floatx80_isNaN( trueZ ) 2521 && floatx80_isNaN( testZ ) 2522 && ! floatx80_is_signaling_nan( testZ ) 2523 && ( trueFlags == testFlags ) 2524 ) { 2525 /* no problem */ 2526 } 2527 else { 2528 ++errorCount; 2529 writeErrorFound( 10000 - count ); 2530 writeInput_a_float128(); 2531 fputs( "\n\t", stdout ); 2532 writeOutputs_z_floatx80( trueZ, trueFlags, testZ, testFlags ); 2533 fflush( stdout ); 2534 if ( errorCount == maxErrorCount ) goto exit; 2535 } 2536 } 2537 } 2538 exit: 2539 writeTestsPerformed( 10000 - count ); 2540 2541 } 2542 2543 #endif 2544 2545 void 2546 test_az_float128( 2547 float128 trueFunction( float128 ), float128 testFunction( float128 ) ) 2548 { 2549 int16 count; 2550 float128 trueZ, testZ; 2551 uint8 trueFlags, testFlags; 2552 2553 errorCount = 0; 2554 tenthousandsCount = 0; 2555 count = 10000; 2556 testCases_initSequence( testCases_sequence_a_float128 ); 2557 writeTestsTotal(); 2558 while ( ! testCases_done || forever ) { 2559 testCases_next(); 2560 *trueFlagsPtr = 0; 2561 trueZ = trueFunction( testCases_a_float128 ); 2562 trueFlags = *trueFlagsPtr; 2563 (void) testFlagsFunctionPtr(); 2564 testZ = testFunction( testCases_a_float128 ); 2565 testFlags = testFlagsFunctionPtr(); 2566 --count; 2567 if ( count == 0 ) { 2568 checkEarlyExit(); 2569 count = 10000; 2570 } 2571 if ( ! float128_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 2572 if ( ! checkNaNs 2573 && float128_is_signaling_nan( testCases_a_float128 ) ) { 2574 trueFlags |= float_flag_invalid; 2575 } 2576 if ( ! checkNaNs 2577 && float128_isNaN( trueZ ) 2578 && float128_isNaN( testZ ) 2579 && ! float128_is_signaling_nan( testZ ) 2580 && ( trueFlags == testFlags ) 2581 ) { 2582 /* no problem */ 2583 } 2584 else { 2585 ++errorCount; 2586 writeErrorFound( 10000 - count ); 2587 writeInput_a_float128(); 2588 fputs( "\n\t", stdout ); 2589 writeOutputs_z_float128( trueZ, trueFlags, testZ, testFlags ); 2590 fflush( stdout ); 2591 if ( errorCount == maxErrorCount ) goto exit; 2592 } 2593 } 2594 } 2595 exit: 2596 writeTestsPerformed( 10000 - count ); 2597 2598 } 2599 2600 void 2601 test_ab_float128_z_flag( 2602 flag trueFunction( float128, float128 ), 2603 flag testFunction( float128, float128 ) 2604 ) 2605 { 2606 int16 count; 2607 flag trueZ, testZ; 2608 uint8 trueFlags, testFlags; 2609 2610 errorCount = 0; 2611 tenthousandsCount = 0; 2612 count = 10000; 2613 testCases_initSequence( testCases_sequence_ab_float128 ); 2614 writeTestsTotal(); 2615 while ( ! testCases_done || forever ) { 2616 testCases_next(); 2617 *trueFlagsPtr = 0; 2618 trueZ = trueFunction( testCases_a_float128, testCases_b_float128 ); 2619 trueFlags = *trueFlagsPtr; 2620 (void) testFlagsFunctionPtr(); 2621 testZ = testFunction( testCases_a_float128, testCases_b_float128 ); 2622 testFlags = testFlagsFunctionPtr(); 2623 --count; 2624 if ( count == 0 ) { 2625 checkEarlyExit(); 2626 count = 10000; 2627 } 2628 if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 2629 if ( ! checkNaNs 2630 && ( float128_is_signaling_nan( testCases_a_float128 ) 2631 || float128_is_signaling_nan( testCases_b_float128 ) ) 2632 ) { 2633 trueFlags |= float_flag_invalid; 2634 } 2635 if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 2636 ++errorCount; 2637 writeErrorFound( 10000 - count ); 2638 writeInputs_ab_float128(); 2639 fputs( "\n\t", stdout ); 2640 writeOutputs_z_flag( trueZ, trueFlags, testZ, testFlags ); 2641 fflush( stdout ); 2642 if ( errorCount == maxErrorCount ) goto exit; 2643 } 2644 } 2645 } 2646 exit: 2647 writeTestsPerformed( 10000 - count ); 2648 return; 2649 2650 } 2651 2652 void 2653 test_abz_float128( 2654 float128 trueFunction( float128, float128 ), 2655 float128 testFunction( float128, float128 ) 2656 ) 2657 { 2658 int16 count; 2659 float128 trueZ, testZ; 2660 uint8 trueFlags, testFlags; 2661 2662 errorCount = 0; 2663 tenthousandsCount = 0; 2664 count = 10000; 2665 testCases_initSequence( testCases_sequence_ab_float128 ); 2666 writeTestsTotal(); 2667 while ( ! testCases_done || forever ) { 2668 testCases_next(); 2669 *trueFlagsPtr = 0; 2670 trueZ = trueFunction( testCases_a_float128, testCases_b_float128 ); 2671 trueFlags = *trueFlagsPtr; 2672 (void) testFlagsFunctionPtr(); 2673 testZ = testFunction( testCases_a_float128, testCases_b_float128 ); 2674 testFlags = testFlagsFunctionPtr(); 2675 --count; 2676 if ( count == 0 ) { 2677 checkEarlyExit(); 2678 count = 10000; 2679 } 2680 if ( ! float128_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 2681 if ( ! checkNaNs 2682 && ( float128_is_signaling_nan( testCases_a_float128 ) 2683 || float128_is_signaling_nan( testCases_b_float128 ) ) 2684 ) { 2685 trueFlags |= float_flag_invalid; 2686 } 2687 if ( ! checkNaNs 2688 && float128_isNaN( trueZ ) 2689 && float128_isNaN( testZ ) 2690 && ! float128_is_signaling_nan( testZ ) 2691 && ( trueFlags == testFlags ) 2692 ) { 2693 /* no problem */ 2694 } 2695 else { 2696 ++errorCount; 2697 writeErrorFound( 10000 - count ); 2698 writeInputs_ab_float128(); 2699 fputs( "\n\t", stdout ); 2700 writeOutputs_z_float128( trueZ, trueFlags, testZ, testFlags ); 2701 fflush( stdout ); 2702 if ( errorCount == maxErrorCount ) goto exit; 2703 } 2704 } 2705 } 2706 exit: 2707 writeTestsPerformed( 10000 - count ); 2708 return; 2709 2710 } 2711 2712 #endif 2713 2714
Indexes created Mon Sep 22 13:09:51 GMT 2025