1206917Smarius 2206917Smarius/* 3206917Smarius=============================================================================== 4206917Smarius 5206917SmariusThis C source file is part of TestFloat, Release 2a, a package of programs 6206917Smariusfor testing the correctness of floating-point arithmetic complying to the 7206917SmariusIEC/IEEE Standard for Floating-Point. 8206917Smarius 9206917SmariusWritten by John R. Hauser. More information is available through the Web 10206917Smariuspage `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'. 11206917Smarius 12206917SmariusTHIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort 13206917Smariushas been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT 14206917SmariusTIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO 15206917SmariusPERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY 16206917SmariusAND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE. 17206917Smarius 18206917SmariusDerivative works are acceptable, even for commercial purposes, so long as 19206917Smarius(1) they include prominent notice that the work is derivative, and (2) they 20206917Smariusinclude prominent notice akin to these four paragraphs for those parts of 21206917Smariusthis code that are retained. 22206917Smarius 23206917Smarius=============================================================================== 24206917Smarius*/ 25206917Smarius 26206917Smarius#include <stdlib.h> 27206917Smarius#include <stdio.h> 28206917Smarius#include "milieu.h" 29206917Smarius#include "softfloat.h" 30206917Smarius#include "testCases.h" 31206917Smarius#include "writeHex.h" 32206917Smarius#include "testLoops.h" 33206917Smarius 34206917Smariusvolatile flag stop = FALSE; 35206917Smarius 36206917Smariuschar *trueName, *testName; 37206917Smariusflag forever, errorStop; 38206917Smariusuint32 maxErrorCount = 0; 39206917Smariusflag checkNaNs = FALSE; 40206917Smariusint8 *trueFlagsPtr; 41206917Smariusint8 ( *testFlagsFunctionPtr )( void ); 42206917Smariuschar *functionName; 43206917Smariuschar *roundingPrecisionName, *roundingModeName, *tininessModeName; 44206917Smariusflag anyErrors = FALSE; 45206917Smarius 46206917Smariusvoid writeFunctionName( FILE *stream ) 47206917Smarius{ 48206917Smarius 49206917Smarius fputs( functionName, stream ); 50206917Smarius if ( roundingModeName ) { 51206917Smarius if ( roundingPrecisionName ) { 52206917Smarius fputs( ", precision ", stream ); 53206917Smarius fputs( roundingPrecisionName, stream ); 54206917Smarius } 55206917Smarius fputs( ", rounding ", stream ); 56206917Smarius fputs( roundingModeName, stream ); 57206917Smarius if ( tininessModeName ) { 58206917Smarius fputs( ", tininess ", stream ); 59206917Smarius fputs( tininessModeName, stream ); 60206917Smarius fputs( " rounding", stream ); 61206917Smarius } 62206917Smarius } 63206917Smarius 64206917Smarius} 65206917Smarius 66206917Smariusvoid exitWithStatus( void ) 67206917Smarius{ 68206917Smarius 69206917Smarius exit( anyErrors ? EXIT_FAILURE : EXIT_SUCCESS ); 70206917Smarius 71206917Smarius} 72206917Smarius 73206917Smariusstatic uint32 tenthousandsCount, errorCount = 0; 74206917Smarius 75206917Smariusstatic void writeTestsTotal( void ) 76206917Smarius{ 77206917Smarius 78206917Smarius if ( forever ) { 79206917Smarius fputs( "Unbounded tests.\n", stderr ); 80206917Smarius } 81206917Smarius else { 82206917Smarius fprintf( stderr, "\r%d tests total.\n", testCases_total ); 83206917Smarius } 84206917Smarius 85206917Smarius} 86206917Smarius 87206917Smariusstatic void writeTestsPerformed( int16 count ) 88206917Smarius{ 89206917Smarius 90206917Smarius if ( tenthousandsCount ) { 91206917Smarius fprintf( 92206917Smarius stderr, "\r%d%04d tests performed", tenthousandsCount, count ); 93206917Smarius } 94206917Smarius else { 95206917Smarius fprintf( stderr, "\r%d tests performed", count ); 96206917Smarius } 97206917Smarius if ( errorCount ) { 98206917Smarius fprintf( 99206917Smarius stderr, 100206917Smarius "; %d error%s found.\n", 101206917Smarius errorCount, 102206917Smarius ( errorCount == 1 ) ? "" : "s" 103206917Smarius ); 104206917Smarius } 105206917Smarius else { 106206917Smarius fputs( ".\n", stderr ); 107206917Smarius fputs( "No errors found in ", stdout ); 108206917Smarius writeFunctionName( stdout ); 109206917Smarius fputs( ".\n", stdout ); 110206917Smarius fflush( stdout ); 111206917Smarius } 112206917Smarius 113206917Smarius} 114206917Smarius 115206917Smariusstatic void checkEarlyExit( void ) 116206917Smarius{ 117206917Smarius 118206917Smarius ++tenthousandsCount; 119206917Smarius if ( stop ) { 120206917Smarius writeTestsPerformed( 0 ); 121206917Smarius exitWithStatus(); 122206917Smarius } 123206917Smarius fprintf( stderr, "\r%3d0000", tenthousandsCount ); 124206917Smarius 125206917Smarius} 126206917Smarius 127206917Smariusstatic void writeErrorFound( int16 count ) 128206917Smarius{ 129206917Smarius 130206917Smarius fputc( '\r', stderr ); 131206917Smarius if ( errorCount == 1 ) { 132206917Smarius fputs( "Errors found in ", stdout ); 133206917Smarius writeFunctionName( stdout ); 134206917Smarius fputs( ":\n", stdout ); 135206917Smarius } 136206917Smarius if ( stop ) { 137206917Smarius writeTestsPerformed( count ); 138206917Smarius exitWithStatus(); 139206917Smarius } 140206917Smarius anyErrors = TRUE; 141206917Smarius 142206917Smarius} 143206917Smarius 144206917SmariusINLINE void writeInput_a_int32( void ) 145206917Smarius{ 146206917Smarius 147206917Smarius writeHex_bits32( testCases_a_int32, stdout ); 148206917Smarius 149206917Smarius} 150206917Smarius 151206917Smarius#ifdef BITS64 152206917Smarius 153206917SmariusINLINE void writeInput_a_int64( void ) 154206917Smarius{ 155206917Smarius 156206917Smarius writeHex_bits64( testCases_a_int64, stdout ); 157206917Smarius 158206917Smarius} 159206917Smarius 160206917Smarius#endif 161206917Smarius 162206917SmariusINLINE void writeInput_a_float32( void ) 163206917Smarius{ 164206917Smarius 165206917Smarius writeHex_float32( testCases_a_float32, stdout ); 166206917Smarius 167206917Smarius} 168206917Smarius 169206917Smariusstatic void writeInputs_ab_float32( void ) 170206917Smarius{ 171206917Smarius 172206917Smarius writeHex_float32( testCases_a_float32, stdout ); 173206917Smarius fputs( " ", stdout ); 174206917Smarius writeHex_float32( testCases_b_float32, stdout ); 175206917Smarius 176206917Smarius} 177206917Smarius 178206917SmariusINLINE void writeInput_a_float64( void ) 179206917Smarius{ 180206917Smarius 181206917Smarius writeHex_float64( testCases_a_float64, stdout ); 182206917Smarius 183206917Smarius} 184206917Smarius 185206917Smariusstatic void writeInputs_ab_float64( void ) 186206917Smarius{ 187206917Smarius 188206917Smarius writeHex_float64( testCases_a_float64, stdout ); 189206917Smarius fputs( " ", stdout ); 190206917Smarius writeHex_float64( testCases_b_float64, stdout ); 191206917Smarius 192206917Smarius} 193206917Smarius 194206917Smarius#ifdef FLOATX80 195206917Smarius 196206917SmariusINLINE void writeInput_a_floatx80( void ) 197206917Smarius{ 198206917Smarius 199206917Smarius writeHex_floatx80( testCases_a_floatx80, stdout ); 200206917Smarius 201206917Smarius} 202206917Smarius 203206917Smariusstatic void writeInputs_ab_floatx80( void ) 204206917Smarius{ 205206917Smarius 206206917Smarius writeHex_floatx80( testCases_a_floatx80, stdout ); 207206917Smarius fputs( " ", stdout ); 208206917Smarius writeHex_floatx80( testCases_b_floatx80, stdout ); 209206917Smarius 210206917Smarius} 211206917Smarius 212206917Smarius#endif 213206917Smarius 214206917Smarius#ifdef FLOAT128 215206917Smarius 216206917SmariusINLINE void writeInput_a_float128( void ) 217206917Smarius{ 218206917Smarius 219206917Smarius writeHex_float128( testCases_a_float128, stdout ); 220206917Smarius 221206917Smarius} 222206917Smarius 223206917Smariusstatic void writeInputs_ab_float128( void ) 224206917Smarius{ 225206917Smarius 226206917Smarius writeHex_float128( testCases_a_float128, stdout ); 227206917Smarius fputs( " ", stdout ); 228206917Smarius writeHex_float128( testCases_b_float128, stdout ); 229206917Smarius 230206917Smarius} 231206917Smarius 232206917Smarius#endif 233206917Smarius 234206917Smariusstatic void 235206917Smarius writeOutputs_z_flag( 236206917Smarius flag trueZ, uint8 trueFlags, flag testZ, uint8 testFlags ) 237206917Smarius{ 238206917Smarius 239206917Smarius fputs( trueName, stdout ); 240206917Smarius fputs( ": ", stdout ); 241206917Smarius writeHex_flag( trueZ, stdout ); 242206917Smarius fputc( ' ', stdout ); 243206917Smarius writeHex_float_flags( trueFlags, stdout ); 244206917Smarius fputs( " ", stdout ); 245206917Smarius fputs( testName, stdout ); 246206917Smarius fputs( ": ", stdout ); 247206917Smarius writeHex_flag( testZ, stdout ); 248206917Smarius fputc( ' ', stdout ); 249206917Smarius writeHex_float_flags( testFlags, stdout ); 250206917Smarius fputc( '\n', stdout ); 251206917Smarius 252206917Smarius} 253206917Smarius 254206917Smariusstatic void 255206917Smarius writeOutputs_z_int32( 256206917Smarius int32 trueZ, uint8 trueFlags, int32 testZ, uint8 testFlags ) 257206917Smarius{ 258206917Smarius 259206917Smarius fputs( trueName, stdout ); 260206917Smarius fputs( ": ", stdout ); 261206917Smarius writeHex_bits32( trueZ, stdout ); 262206917Smarius fputc( ' ', stdout ); 263206917Smarius writeHex_float_flags( trueFlags, stdout ); 264206917Smarius fputs( " ", stdout ); 265206917Smarius fputs( testName, stdout ); 266206917Smarius fputs( ": ", stdout ); 267206917Smarius writeHex_bits32( testZ, stdout ); 268206917Smarius fputc( ' ', stdout ); 269206917Smarius writeHex_float_flags( testFlags, stdout ); 270206917Smarius fputc( '\n', stdout ); 271206917Smarius 272206917Smarius} 273206917Smarius 274206917Smarius#ifdef BITS64 275206917Smarius 276206917Smariusstatic void 277206917Smarius writeOutputs_z_int64( 278206917Smarius int64 trueZ, uint8 trueFlags, int64 testZ, uint8 testFlags ) 279206917Smarius{ 280206917Smarius 281206917Smarius fputs( trueName, stdout ); 282206917Smarius fputs( ": ", stdout ); 283206917Smarius writeHex_bits64( trueZ, stdout ); 284206917Smarius fputc( ' ', stdout ); 285206917Smarius writeHex_float_flags( trueFlags, stdout ); 286206917Smarius fputs( " ", stdout ); 287206917Smarius fputs( testName, stdout ); 288206917Smarius fputs( ": ", stdout ); 289206917Smarius writeHex_bits64( testZ, stdout ); 290206917Smarius fputc( ' ', stdout ); 291206917Smarius writeHex_float_flags( testFlags, stdout ); 292206917Smarius fputc( '\n', stdout ); 293206917Smarius 294206917Smarius} 295206917Smarius 296206917Smarius#endif 297206917Smarius 298206917Smariusstatic void 299206917Smarius writeOutputs_z_float32( 300206917Smarius float32 trueZ, uint8 trueFlags, float32 testZ, uint8 testFlags ) 301206917Smarius{ 302206917Smarius 303206917Smarius fputs( trueName, stdout ); 304206917Smarius fputs( ": ", stdout ); 305206917Smarius writeHex_float32( trueZ, stdout ); 306206917Smarius fputc( ' ', stdout ); 307206917Smarius writeHex_float_flags( trueFlags, stdout ); 308206917Smarius fputs( " ", stdout ); 309206917Smarius fputs( testName, stdout ); 310206917Smarius fputs( ": ", stdout ); 311206917Smarius writeHex_float32( testZ, stdout ); 312206917Smarius fputc( ' ', stdout ); 313206917Smarius writeHex_float_flags( testFlags, stdout ); 314206917Smarius fputc( '\n', stdout ); 315206917Smarius 316206917Smarius} 317206917Smarius 318206917Smariusstatic void 319206917Smarius writeOutputs_z_float64( 320206917Smarius float64 trueZ, uint8 trueFlags, float64 testZ, uint8 testFlags ) 321206917Smarius{ 322206917Smarius 323206917Smarius fputs( trueName, stdout ); 324206917Smarius fputs( ": ", stdout ); 325206917Smarius writeHex_float64( trueZ, stdout ); 326206917Smarius fputc( ' ', stdout ); 327206917Smarius writeHex_float_flags( trueFlags, stdout ); 328206917Smarius fputs( " ", stdout ); 329206917Smarius fputs( testName, stdout ); 330206917Smarius fputs( ": ", stdout ); 331206917Smarius writeHex_float64( testZ, stdout ); 332206917Smarius fputc( ' ', stdout ); 333206917Smarius writeHex_float_flags( testFlags, stdout ); 334206917Smarius fputc( '\n', stdout ); 335206917Smarius 336206917Smarius} 337206917Smarius 338206917Smarius#ifdef FLOATX80 339206917Smarius 340206917Smariusstatic void 341206917Smarius writeOutputs_z_floatx80( 342206917Smarius floatx80 trueZ, uint8 trueFlags, floatx80 testZ, uint8 testFlags ) 343206917Smarius{ 344206917Smarius 345206917Smarius fputs( trueName, stdout ); 346206917Smarius fputs( ": ", stdout ); 347206917Smarius writeHex_floatx80( trueZ, stdout ); 348206917Smarius fputc( ' ', stdout ); 349206917Smarius writeHex_float_flags( trueFlags, stdout ); 350206917Smarius fputs( " ", stdout ); 351206917Smarius fputs( testName, stdout ); 352206917Smarius fputs( ": ", stdout ); 353206917Smarius writeHex_floatx80( testZ, stdout ); 354206917Smarius fputc( ' ', stdout ); 355206917Smarius writeHex_float_flags( testFlags, stdout ); 356206917Smarius fputc( '\n', stdout ); 357206917Smarius 358206917Smarius} 359206917Smarius 360206917Smarius#endif 361206917Smarius 362206917Smarius#ifdef FLOAT128 363206917Smarius 364206917Smariusstatic void 365206917Smarius writeOutputs_z_float128( 366206917Smarius float128 trueZ, uint8 trueFlags, float128 testZ, uint8 testFlags ) 367206917Smarius{ 368206917Smarius 369206917Smarius fputs( trueName, stdout ); 370206917Smarius fputs( ": ", stdout ); 371206917Smarius writeHex_float128( trueZ, stdout ); 372206917Smarius fputc( ' ', stdout ); 373206917Smarius writeHex_float_flags( trueFlags, stdout ); 374206917Smarius fputs( "\n\t", stdout ); 375206917Smarius fputs( testName, stdout ); 376206917Smarius fputs( ": ", stdout ); 377206917Smarius writeHex_float128( testZ, stdout ); 378206917Smarius fputc( ' ', stdout ); 379206917Smarius writeHex_float_flags( testFlags, stdout ); 380206917Smarius fputc( '\n', stdout ); 381206917Smarius 382206917Smarius} 383206917Smarius 384206917Smarius#endif 385206917Smarius 386206917SmariusINLINE flag float32_isNaN( float32 a ) 387206917Smarius{ 388206917Smarius 389206917Smarius return 0x7F800000 < ( a & 0x7FFFFFFF ); 390206917Smarius 391206917Smarius} 392206917Smarius 393206917Smarius#ifdef BITS64 394206917Smarius 395206917SmariusINLINE flag float64_same( float64 a, float64 b ) 396206917Smarius{ 397206917Smarius 398206917Smarius return a == b; 399206917Smarius 400206917Smarius} 401206917Smarius 402206917SmariusINLINE flag float64_isNaN( float64 a ) 403206917Smarius{ 404206917Smarius 405206917Smarius return LIT64( 0x7FF0000000000000 ) < ( a & LIT64( 0x7FFFFFFFFFFFFFFF ) ); 406206917Smarius 407206917Smarius} 408206917Smarius 409206917Smarius#else 410206917Smarius 411206917SmariusINLINE flag float64_same( float64 a, float64 b ) 412206917Smarius{ 413206917Smarius 414206917Smarius return ( a.high == b.high ) && ( a.low == b.low ); 415206917Smarius 416206917Smarius} 417206917Smarius 418206917SmariusINLINE flag float64_isNaN( float64 a ) 419206917Smarius{ 420206917Smarius bits32 absAHigh; 421206917Smarius 422206917Smarius absAHigh = a.high & 0x7FFFFFFF; 423206917Smarius return 424206917Smarius ( 0x7FF00000 < absAHigh ) || ( ( absAHigh == 0x7FF00000 ) && a.low ); 425206917Smarius 426206917Smarius} 427206917Smarius 428206917Smarius#endif 429206917Smarius 430206917Smarius#ifdef FLOATX80 431206917Smarius 432206917SmariusINLINE flag floatx80_same( floatx80 a, floatx80 b ) 433206917Smarius{ 434206917Smarius 435206917Smarius return ( a.high == b.high ) && ( a.low == b.low ); 436206917Smarius 437206917Smarius} 438206917Smarius 439206917SmariusINLINE flag floatx80_isNaN( floatx80 a ) 440206917Smarius{ 441206917Smarius 442206917Smarius return ( ( a.high & 0x7FFF ) == 0x7FFF ) && a.low; 443206917Smarius 444206917Smarius} 445206917Smarius 446206917Smarius#endif 447206917Smarius 448206917Smarius#ifdef FLOAT128 449206917Smarius 450206917SmariusINLINE flag float128_same( float128 a, float128 b ) 451206917Smarius{ 452206917Smarius 453206917Smarius return ( a.high == b.high ) && ( a.low == b.low ); 454206917Smarius 455206917Smarius} 456206917Smarius 457206917SmariusINLINE flag float128_isNaN( float128 a ) 458206917Smarius{ 459206917Smarius bits64 absAHigh; 460206917Smarius 461206917Smarius absAHigh = a.high & LIT64( 0x7FFFFFFFFFFFFFFF ); 462206917Smarius return 463206917Smarius ( LIT64( 0x7FFF000000000000 ) < absAHigh ) 464206917Smarius || ( ( absAHigh == LIT64( 0x7FFF000000000000 ) ) && a.low ); 465206917Smarius 466206917Smarius} 467206917Smarius 468206917Smarius#endif 469206917Smarius 470206917Smariusvoid 471206917Smarius test_a_int32_z_float32( 472206917Smarius float32 trueFunction( int32 ), float32 testFunction( int32 ) ) 473206917Smarius{ 474206917Smarius int16 count; 475206917Smarius float32 trueZ, testZ; 476206917Smarius uint8 trueFlags, testFlags; 477206917Smarius 478206917Smarius errorCount = 0; 479206917Smarius tenthousandsCount = 0; 480206917Smarius count = 10000; 481206917Smarius testCases_initSequence( testCases_sequence_a_int32 ); 482206917Smarius writeTestsTotal(); 483206917Smarius while ( ! testCases_done || forever ) { 484206917Smarius testCases_next(); 485206917Smarius *trueFlagsPtr = 0; 486206917Smarius trueZ = trueFunction( testCases_a_int32 ); 487206917Smarius trueFlags = *trueFlagsPtr; 488206917Smarius (void) testFlagsFunctionPtr(); 489206917Smarius testZ = testFunction( testCases_a_int32 ); 490206917Smarius testFlags = testFlagsFunctionPtr(); 491206917Smarius --count; 492206917Smarius if ( count == 0 ) { 493206917Smarius checkEarlyExit(); 494206917Smarius count = 10000; 495206917Smarius } 496206917Smarius if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 497206917Smarius if ( ! checkNaNs 498206917Smarius && float32_isNaN( trueZ ) 499206917Smarius && float32_isNaN( testZ ) 500206917Smarius && ! float32_is_signaling_nan( testZ ) 501206917Smarius && ( trueFlags == testFlags ) 502206917Smarius ) { 503206917Smarius /* no problem */ 504206917Smarius } 505206917Smarius else { 506206917Smarius ++errorCount; 507206917Smarius writeErrorFound( 10000 - count ); 508206917Smarius writeInput_a_int32(); 509206917Smarius fputs( " ", stdout ); 510206917Smarius writeOutputs_z_float32( trueZ, trueFlags, testZ, testFlags ); 511206917Smarius fflush( stdout ); 512206917Smarius if ( errorCount == maxErrorCount ) goto exit; 513206917Smarius } 514206917Smarius } 515206917Smarius } 516206917Smarius exit: 517206917Smarius writeTestsPerformed( 10000 - count ); 518206917Smarius 519206917Smarius} 520206917Smarius 521206917Smariusvoid 522206917Smarius test_a_int32_z_float64( 523206917Smarius float64 trueFunction( int32 ), float64 testFunction( int32 ) ) 524206917Smarius{ 525206917Smarius int16 count; 526206917Smarius float64 trueZ, testZ; 527206917Smarius uint8 trueFlags, testFlags; 528206917Smarius 529206917Smarius errorCount = 0; 530206917Smarius tenthousandsCount = 0; 531206917Smarius count = 10000; 532206917Smarius testCases_initSequence( testCases_sequence_a_int32 ); 533206917Smarius writeTestsTotal(); 534206917Smarius while ( ! testCases_done || forever ) { 535206917Smarius testCases_next(); 536206917Smarius *trueFlagsPtr = 0; 537206917Smarius trueZ = trueFunction( testCases_a_int32 ); 538206917Smarius trueFlags = *trueFlagsPtr; 539206917Smarius (void) testFlagsFunctionPtr(); 540206917Smarius testZ = testFunction( testCases_a_int32 ); 541206917Smarius testFlags = testFlagsFunctionPtr(); 542206917Smarius --count; 543206917Smarius if ( count == 0 ) { 544206917Smarius checkEarlyExit(); 545206917Smarius count = 10000; 546206917Smarius } 547206917Smarius if ( ! float64_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 548206917Smarius if ( ! checkNaNs 549206917Smarius && float64_isNaN( trueZ ) 550206917Smarius && float64_isNaN( testZ ) 551206917Smarius && ! float64_is_signaling_nan( testZ ) 552206917Smarius && ( trueFlags == testFlags ) 553206917Smarius ) { 554206917Smarius /* no problem */ 555206917Smarius } 556206917Smarius else { 557206917Smarius ++errorCount; 558206917Smarius writeErrorFound( 10000 - count ); 559206917Smarius writeInput_a_int32(); 560206917Smarius fputs( " ", stdout ); 561206917Smarius writeOutputs_z_float64( trueZ, trueFlags, testZ, testFlags ); 562206917Smarius fflush( stdout ); 563206917Smarius if ( errorCount == maxErrorCount ) goto exit; 564206917Smarius } 565206917Smarius } 566206917Smarius } 567206917Smarius exit: 568206917Smarius writeTestsPerformed( 10000 - count ); 569206917Smarius 570206917Smarius} 571206917Smarius 572206917Smarius#ifdef FLOATX80 573206917Smarius 574206917Smariusvoid 575206917Smarius test_a_int32_z_floatx80( 576206917Smarius floatx80 trueFunction( int32 ), floatx80 testFunction( int32 ) ) 577206917Smarius{ 578206917Smarius int16 count; 579206917Smarius floatx80 trueZ, testZ; 580206917Smarius uint8 trueFlags, testFlags; 581206917Smarius 582206917Smarius errorCount = 0; 583206917Smarius tenthousandsCount = 0; 584206917Smarius count = 10000; 585206917Smarius testCases_initSequence( testCases_sequence_a_int32 ); 586206917Smarius writeTestsTotal(); 587206917Smarius while ( ! testCases_done || forever ) { 588206917Smarius testCases_next(); 589206917Smarius *trueFlagsPtr = 0; 590206917Smarius trueZ = trueFunction( testCases_a_int32 ); 591206917Smarius trueFlags = *trueFlagsPtr; 592206917Smarius (void) testFlagsFunctionPtr(); 593206917Smarius testZ = testFunction( testCases_a_int32 ); 594206917Smarius testFlags = testFlagsFunctionPtr(); 595206917Smarius --count; 596206917Smarius if ( count == 0 ) { 597206917Smarius checkEarlyExit(); 598206917Smarius count = 10000; 599206917Smarius } 600206917Smarius if ( ! floatx80_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 601206917Smarius if ( ! checkNaNs 602206917Smarius && floatx80_isNaN( trueZ ) 603206917Smarius && floatx80_isNaN( testZ ) 604206917Smarius && ! floatx80_is_signaling_nan( testZ ) 605206917Smarius && ( trueFlags == testFlags ) 606206917Smarius ) { 607206917Smarius /* no problem */ 608206917Smarius } 609206917Smarius else { 610206917Smarius ++errorCount; 611206917Smarius writeErrorFound( 10000 - count ); 612206917Smarius writeInput_a_int32(); 613206917Smarius fputs( " ", stdout ); 614206917Smarius writeOutputs_z_floatx80( trueZ, trueFlags, testZ, testFlags ); 615206917Smarius fflush( stdout ); 616206917Smarius if ( errorCount == maxErrorCount ) goto exit; 617206917Smarius } 618206917Smarius } 619206917Smarius } 620206917Smarius exit: 621206917Smarius writeTestsPerformed( 10000 - count ); 622206917Smarius 623206917Smarius} 624206917Smarius 625206917Smarius#endif 626206917Smarius 627206917Smarius#ifdef FLOAT128 628206917Smarius 629206917Smariusvoid 630206917Smarius test_a_int32_z_float128( 631206917Smarius float128 trueFunction( int32 ), float128 testFunction( int32 ) ) 632206917Smarius{ 633206917Smarius int16 count; 634206917Smarius float128 trueZ, testZ; 635206917Smarius uint8 trueFlags, testFlags; 636206917Smarius 637206917Smarius errorCount = 0; 638206917Smarius tenthousandsCount = 0; 639206917Smarius count = 10000; 640206917Smarius testCases_initSequence( testCases_sequence_a_int32 ); 641206917Smarius writeTestsTotal(); 642206917Smarius while ( ! testCases_done || forever ) { 643206917Smarius testCases_next(); 644206917Smarius *trueFlagsPtr = 0; 645206917Smarius trueZ = trueFunction( testCases_a_int32 ); 646206917Smarius trueFlags = *trueFlagsPtr; 647206917Smarius (void) testFlagsFunctionPtr(); 648206917Smarius testZ = testFunction( testCases_a_int32 ); 649206917Smarius testFlags = testFlagsFunctionPtr(); 650206917Smarius --count; 651206917Smarius if ( count == 0 ) { 652206917Smarius checkEarlyExit(); 653206917Smarius count = 10000; 654206917Smarius } 655206917Smarius if ( ! float128_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 656206917Smarius if ( ! checkNaNs 657206917Smarius && float128_isNaN( trueZ ) 658206917Smarius && float128_isNaN( testZ ) 659206917Smarius && ! float128_is_signaling_nan( testZ ) 660206917Smarius && ( trueFlags == testFlags ) 661206917Smarius ) { 662206917Smarius /* no problem */ 663206917Smarius } 664206917Smarius else { 665206917Smarius ++errorCount; 666206917Smarius writeErrorFound( 10000 - count ); 667206917Smarius writeInput_a_int32(); 668206917Smarius fputs( "\n\t", stdout ); 669206917Smarius writeOutputs_z_float128( trueZ, trueFlags, testZ, testFlags ); 670206917Smarius fflush( stdout ); 671206917Smarius if ( errorCount == maxErrorCount ) goto exit; 672206917Smarius } 673206917Smarius } 674206917Smarius } 675206917Smarius exit: 676206917Smarius writeTestsPerformed( 10000 - count ); 677206917Smarius 678206917Smarius} 679206917Smarius 680206917Smarius#endif 681206917Smarius 682206917Smarius#ifdef BITS64 683206917Smarius 684206917Smariusvoid 685206917Smarius test_a_int64_z_float32( 686206917Smarius float32 trueFunction( int64 ), float32 testFunction( int64 ) ) 687206917Smarius{ 688206917Smarius int16 count; 689206917Smarius float32 trueZ, testZ; 690206917Smarius uint8 trueFlags, testFlags; 691206917Smarius 692206917Smarius errorCount = 0; 693206917Smarius tenthousandsCount = 0; 694206917Smarius count = 10000; 695206917Smarius testCases_initSequence( testCases_sequence_a_int64 ); 696206917Smarius writeTestsTotal(); 697206917Smarius while ( ! testCases_done || forever ) { 698206917Smarius testCases_next(); 699206917Smarius *trueFlagsPtr = 0; 700206917Smarius trueZ = trueFunction( testCases_a_int64 ); 701206917Smarius trueFlags = *trueFlagsPtr; 702206917Smarius (void) testFlagsFunctionPtr(); 703206917Smarius testZ = testFunction( testCases_a_int64 ); 704206917Smarius testFlags = testFlagsFunctionPtr(); 705206917Smarius --count; 706206917Smarius if ( count == 0 ) { 707206917Smarius checkEarlyExit(); 708206917Smarius count = 10000; 709206917Smarius } 710206917Smarius if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 711206917Smarius if ( ! checkNaNs 712206917Smarius && float32_isNaN( trueZ ) 713206917Smarius && float32_isNaN( testZ ) 714206917Smarius && ! float32_is_signaling_nan( testZ ) 715206917Smarius && ( trueFlags == testFlags ) 716206917Smarius ) { 717206917Smarius /* no problem */ 718206917Smarius } 719206917Smarius else { 720206917Smarius ++errorCount; 721206917Smarius writeErrorFound( 10000 - count ); 722206917Smarius writeInput_a_int64(); 723206917Smarius fputs( " ", stdout ); 724206917Smarius writeOutputs_z_float32( trueZ, trueFlags, testZ, testFlags ); 725206917Smarius fflush( stdout ); 726206917Smarius if ( errorCount == maxErrorCount ) goto exit; 727206917Smarius } 728206917Smarius } 729206917Smarius } 730206917Smarius exit: 731206917Smarius writeTestsPerformed( 10000 - count ); 732206917Smarius 733206917Smarius} 734206917Smarius 735206917Smariusvoid 736206917Smarius test_a_int64_z_float64( 737206917Smarius float64 trueFunction( int64 ), float64 testFunction( int64 ) ) 738206917Smarius{ 739206917Smarius int16 count; 740206917Smarius float64 trueZ, testZ; 741206917Smarius uint8 trueFlags, testFlags; 742206917Smarius 743206917Smarius errorCount = 0; 744206917Smarius tenthousandsCount = 0; 745206917Smarius count = 10000; 746206917Smarius testCases_initSequence( testCases_sequence_a_int64 ); 747206917Smarius writeTestsTotal(); 748206917Smarius while ( ! testCases_done || forever ) { 749206917Smarius testCases_next(); 750206917Smarius *trueFlagsPtr = 0; 751206917Smarius trueZ = trueFunction( testCases_a_int64 ); 752206917Smarius trueFlags = *trueFlagsPtr; 753206917Smarius (void) testFlagsFunctionPtr(); 754206917Smarius testZ = testFunction( testCases_a_int64 ); 755206917Smarius testFlags = testFlagsFunctionPtr(); 756206917Smarius --count; 757206917Smarius if ( count == 0 ) { 758206917Smarius checkEarlyExit(); 759206917Smarius count = 10000; 760206917Smarius } 761206917Smarius if ( ! float64_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 762206917Smarius if ( ! checkNaNs 763206917Smarius && float64_isNaN( trueZ ) 764206917Smarius && float64_isNaN( testZ ) 765206917Smarius && ! float64_is_signaling_nan( testZ ) 766206917Smarius && ( trueFlags == testFlags ) 767206917Smarius ) { 768206917Smarius /* no problem */ 769206917Smarius } 770206917Smarius else { 771206917Smarius ++errorCount; 772206917Smarius writeErrorFound( 10000 - count ); 773206917Smarius writeInput_a_int64(); 774206917Smarius fputs( " ", stdout ); 775206917Smarius writeOutputs_z_float64( trueZ, trueFlags, testZ, testFlags ); 776206917Smarius fflush( stdout ); 777206917Smarius if ( errorCount == maxErrorCount ) goto exit; 778206917Smarius } 779206917Smarius } 780206917Smarius } 781206917Smarius exit: 782206917Smarius writeTestsPerformed( 10000 - count ); 783206917Smarius 784206917Smarius} 785206917Smarius 786206917Smarius#ifdef FLOATX80 787206917Smarius 788206917Smariusvoid 789206917Smarius test_a_int64_z_floatx80( 790206917Smarius floatx80 trueFunction( int64 ), floatx80 testFunction( int64 ) ) 791206917Smarius{ 792206917Smarius int16 count; 793206917Smarius floatx80 trueZ, testZ; 794206917Smarius uint8 trueFlags, testFlags; 795206917Smarius 796206917Smarius errorCount = 0; 797206917Smarius tenthousandsCount = 0; 798206917Smarius count = 10000; 799206917Smarius testCases_initSequence( testCases_sequence_a_int64 ); 800206917Smarius writeTestsTotal(); 801206917Smarius while ( ! testCases_done || forever ) { 802206917Smarius testCases_next(); 803206917Smarius *trueFlagsPtr = 0; 804206917Smarius trueZ = trueFunction( testCases_a_int64 ); 805206917Smarius trueFlags = *trueFlagsPtr; 806206917Smarius (void) testFlagsFunctionPtr(); 807206917Smarius testZ = testFunction( testCases_a_int64 ); 808206917Smarius testFlags = testFlagsFunctionPtr(); 809206917Smarius --count; 810206917Smarius if ( count == 0 ) { 811206917Smarius checkEarlyExit(); 812206917Smarius count = 10000; 813206917Smarius } 814206917Smarius if ( ! floatx80_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 815206917Smarius if ( ! checkNaNs 816206917Smarius && floatx80_isNaN( trueZ ) 817206917Smarius && floatx80_isNaN( testZ ) 818206917Smarius && ! floatx80_is_signaling_nan( testZ ) 819206917Smarius && ( trueFlags == testFlags ) 820206917Smarius ) { 821206917Smarius /* no problem */ 822206917Smarius } 823206917Smarius else { 824206917Smarius ++errorCount; 825206917Smarius writeErrorFound( 10000 - count ); 826206917Smarius writeInput_a_int64(); 827206917Smarius fputs( " ", stdout ); 828206917Smarius writeOutputs_z_floatx80( trueZ, trueFlags, testZ, testFlags ); 829206917Smarius fflush( stdout ); 830206917Smarius if ( errorCount == maxErrorCount ) goto exit; 831206917Smarius } 832206917Smarius } 833206917Smarius } 834206917Smarius exit: 835206917Smarius writeTestsPerformed( 10000 - count ); 836206917Smarius 837206917Smarius} 838206917Smarius 839206917Smarius#endif 840206917Smarius 841206917Smarius#ifdef FLOAT128 842206917Smarius 843206917Smariusvoid 844206917Smarius test_a_int64_z_float128( 845206917Smarius float128 trueFunction( int64 ), float128 testFunction( int64 ) ) 846206917Smarius{ 847206917Smarius int16 count; 848206917Smarius float128 trueZ, testZ; 849206917Smarius uint8 trueFlags, testFlags; 850206917Smarius 851206917Smarius errorCount = 0; 852206917Smarius tenthousandsCount = 0; 853206917Smarius count = 10000; 854206917Smarius testCases_initSequence( testCases_sequence_a_int64 ); 855206917Smarius writeTestsTotal(); 856206917Smarius while ( ! testCases_done || forever ) { 857206917Smarius testCases_next(); 858206917Smarius *trueFlagsPtr = 0; 859206917Smarius trueZ = trueFunction( testCases_a_int64 ); 860206917Smarius trueFlags = *trueFlagsPtr; 861206917Smarius (void) testFlagsFunctionPtr(); 862206917Smarius testZ = testFunction( testCases_a_int64 ); 863206917Smarius testFlags = testFlagsFunctionPtr(); 864206917Smarius --count; 865206917Smarius if ( count == 0 ) { 866206917Smarius checkEarlyExit(); 867206917Smarius count = 10000; 868206917Smarius } 869206917Smarius if ( ! float128_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 870206917Smarius if ( ! checkNaNs 871206917Smarius && float128_isNaN( trueZ ) 872206917Smarius && float128_isNaN( testZ ) 873206917Smarius && ! float128_is_signaling_nan( testZ ) 874206917Smarius && ( trueFlags == testFlags ) 875206917Smarius ) { 876206917Smarius /* no problem */ 877206917Smarius } 878206917Smarius else { 879206917Smarius ++errorCount; 880206917Smarius writeErrorFound( 10000 - count ); 881206917Smarius writeInput_a_int64(); 882206917Smarius fputs( "\n\t", stdout ); 883206917Smarius writeOutputs_z_float128( trueZ, trueFlags, testZ, testFlags ); 884206917Smarius fflush( stdout ); 885206917Smarius if ( errorCount == maxErrorCount ) goto exit; 886206917Smarius } 887206917Smarius } 888206917Smarius } 889206917Smarius exit: 890206917Smarius writeTestsPerformed( 10000 - count ); 891206917Smarius 892206917Smarius} 893206917Smarius 894206917Smarius#endif 895206917Smarius 896206917Smarius#endif 897206917Smarius 898206917Smariusvoid 899206917Smarius test_a_float32_z_int32( 900206917Smarius int32 trueFunction( float32 ), int32 testFunction( float32 ) ) 901206917Smarius{ 902206917Smarius int16 count; 903206917Smarius int32 trueZ, testZ; 904206917Smarius uint8 trueFlags, testFlags; 905206917Smarius 906206917Smarius errorCount = 0; 907206917Smarius tenthousandsCount = 0; 908206917Smarius count = 10000; 909206917Smarius testCases_initSequence( testCases_sequence_a_float32 ); 910206917Smarius writeTestsTotal(); 911206917Smarius while ( ! testCases_done || forever ) { 912206917Smarius testCases_next(); 913206917Smarius *trueFlagsPtr = 0; 914206917Smarius trueZ = trueFunction( testCases_a_float32 ); 915206917Smarius trueFlags = *trueFlagsPtr; 916206917Smarius (void) testFlagsFunctionPtr(); 917206917Smarius testZ = testFunction( testCases_a_float32 ); 918206917Smarius testFlags = testFlagsFunctionPtr(); 919206917Smarius --count; 920206917Smarius if ( count == 0 ) { 921206917Smarius checkEarlyExit(); 922206917Smarius count = 10000; 923206917Smarius } 924206917Smarius if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 925206917Smarius if ( ! checkNaNs 926206917Smarius && float32_is_signaling_nan( testCases_a_float32 ) ) { 927206917Smarius trueFlags |= float_flag_invalid; 928206917Smarius } 929206917Smarius if ( ( trueZ == 0x7FFFFFFF ) 930206917Smarius && ( ( testZ == 0x7FFFFFFF ) 931206917Smarius || ( testZ == (sbits32) 0x80000000 ) ) 932206917Smarius && ( trueFlags == float_flag_invalid ) 933206917Smarius && ( testFlags == float_flag_invalid ) 934206917Smarius ) { 935206917Smarius /* no problem */ 936206917Smarius } 937206917Smarius else { 938206917Smarius ++errorCount; 939206917Smarius writeErrorFound( 10000 - count ); 940206917Smarius writeInput_a_float32(); 941206917Smarius fputs( " ", stdout ); 942206917Smarius writeOutputs_z_int32( trueZ, trueFlags, testZ, testFlags ); 943206917Smarius fflush( stdout ); 944206917Smarius if ( errorCount == maxErrorCount ) goto exit; 945206917Smarius } 946206917Smarius } 947206917Smarius } 948206917Smarius exit: 949206917Smarius writeTestsPerformed( 10000 - count ); 950206917Smarius 951206917Smarius} 952206917Smarius 953206917Smarius#ifdef BITS64 954206917Smarius 955206917Smariusvoid 956206917Smarius test_a_float32_z_int64( 957206917Smarius int64 trueFunction( float32 ), int64 testFunction( float32 ) ) 958206917Smarius{ 959206917Smarius int16 count; 960206917Smarius int64 trueZ, testZ; 961206917Smarius uint8 trueFlags, testFlags; 962206917Smarius 963206917Smarius errorCount = 0; 964206917Smarius tenthousandsCount = 0; 965206917Smarius count = 10000; 966206917Smarius testCases_initSequence( testCases_sequence_a_float32 ); 967206917Smarius writeTestsTotal(); 968206917Smarius while ( ! testCases_done || forever ) { 969206917Smarius testCases_next(); 970206917Smarius *trueFlagsPtr = 0; 971206917Smarius trueZ = trueFunction( testCases_a_float32 ); 972206917Smarius trueFlags = *trueFlagsPtr; 973206917Smarius (void) testFlagsFunctionPtr(); 974206917Smarius testZ = testFunction( testCases_a_float32 ); 975206917Smarius testFlags = testFlagsFunctionPtr(); 976206917Smarius --count; 977206917Smarius if ( count == 0 ) { 978206917Smarius checkEarlyExit(); 979206917Smarius count = 10000; 980206917Smarius } 981206917Smarius if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 982206917Smarius if ( ! checkNaNs 983206917Smarius && float32_is_signaling_nan( testCases_a_float32 ) ) { 984206917Smarius trueFlags |= float_flag_invalid; 985206917Smarius } 986206917Smarius if ( ( trueZ == LIT64( 0x7FFFFFFFFFFFFFFF ) ) 987206917Smarius && ( ( testZ == LIT64( 0x7FFFFFFFFFFFFFFF ) ) 988206917Smarius || ( testZ == (sbits64) LIT64( 0x8000000000000000 ) ) ) 989206917Smarius && ( trueFlags == float_flag_invalid ) 990206917Smarius && ( testFlags == float_flag_invalid ) 991206917Smarius ) { 992206917Smarius /* no problem */ 993206917Smarius } 994206917Smarius else { 995206917Smarius ++errorCount; 996206917Smarius writeErrorFound( 10000 - count ); 997206917Smarius writeInput_a_float32(); 998206917Smarius fputs( " ", stdout ); 999206917Smarius writeOutputs_z_int64( trueZ, trueFlags, testZ, testFlags ); 1000206917Smarius fflush( stdout ); 1001206917Smarius if ( errorCount == maxErrorCount ) goto exit; 1002206917Smarius } 1003206917Smarius } 1004206917Smarius } 1005206917Smarius exit: 1006206917Smarius writeTestsPerformed( 10000 - count ); 1007206917Smarius 1008206917Smarius} 1009206917Smarius 1010206917Smarius#endif 1011206917Smarius 1012206917Smariusvoid 1013206917Smarius test_a_float32_z_float64( 1014206917Smarius float64 trueFunction( float32 ), float64 testFunction( float32 ) ) 1015206917Smarius{ 1016206917Smarius int16 count; 1017206917Smarius float64 trueZ, testZ; 1018206917Smarius uint8 trueFlags, testFlags; 1019206917Smarius 1020206917Smarius errorCount = 0; 1021206917Smarius tenthousandsCount = 0; 1022206917Smarius count = 10000; 1023206917Smarius testCases_initSequence( testCases_sequence_a_float32 ); 1024206917Smarius writeTestsTotal(); 1025206917Smarius while ( ! testCases_done || forever ) { 1026206917Smarius testCases_next(); 1027206917Smarius *trueFlagsPtr = 0; 1028206917Smarius trueZ = trueFunction( testCases_a_float32 ); 1029206917Smarius trueFlags = *trueFlagsPtr; 1030206917Smarius (void) testFlagsFunctionPtr(); 1031206917Smarius testZ = testFunction( testCases_a_float32 ); 1032206917Smarius testFlags = testFlagsFunctionPtr(); 1033206917Smarius --count; 1034206917Smarius if ( count == 0 ) { 1035206917Smarius checkEarlyExit(); 1036206917Smarius count = 10000; 1037206917Smarius } 1038206917Smarius if ( ! float64_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 1039206917Smarius if ( ! checkNaNs 1040206917Smarius && float32_is_signaling_nan( testCases_a_float32 ) ) { 1041206917Smarius trueFlags |= float_flag_invalid; 1042206917Smarius } 1043206917Smarius if ( ! checkNaNs 1044206917Smarius && float64_isNaN( trueZ ) 1045206917Smarius && float64_isNaN( testZ ) 1046206917Smarius && ! float64_is_signaling_nan( testZ ) 1047206917Smarius && ( trueFlags == testFlags ) 1048206917Smarius ) { 1049206917Smarius /* no problem */ 1050206917Smarius } 1051206917Smarius else { 1052206917Smarius ++errorCount; 1053206917Smarius writeErrorFound( 10000 - count ); 1054206917Smarius writeInput_a_float32(); 1055206917Smarius fputs( " ", stdout ); 1056206917Smarius writeOutputs_z_float64( trueZ, trueFlags, testZ, testFlags ); 1057206917Smarius fflush( stdout ); 1058206917Smarius if ( errorCount == maxErrorCount ) goto exit; 1059206917Smarius } 1060206917Smarius } 1061206917Smarius } 1062206917Smarius exit: 1063206917Smarius writeTestsPerformed( 10000 - count ); 1064206917Smarius 1065206917Smarius} 1066206917Smarius 1067206917Smarius#ifdef FLOATX80 1068206917Smarius 1069206917Smariusvoid 1070206917Smarius test_a_float32_z_floatx80( 1071206917Smarius floatx80 trueFunction( float32 ), floatx80 testFunction( float32 ) ) 1072206917Smarius{ 1073206917Smarius int16 count; 1074206917Smarius floatx80 trueZ, testZ; 1075206917Smarius uint8 trueFlags, testFlags; 1076206917Smarius 1077206917Smarius errorCount = 0; 1078206917Smarius tenthousandsCount = 0; 1079206917Smarius count = 10000; 1080206917Smarius testCases_initSequence( testCases_sequence_a_float32 ); 1081206917Smarius writeTestsTotal(); 1082206917Smarius while ( ! testCases_done || forever ) { 1083206917Smarius testCases_next(); 1084206917Smarius *trueFlagsPtr = 0; 1085206917Smarius trueZ = trueFunction( testCases_a_float32 ); 1086206917Smarius trueFlags = *trueFlagsPtr; 1087206917Smarius (void) testFlagsFunctionPtr(); 1088206917Smarius testZ = testFunction( testCases_a_float32 ); 1089206917Smarius testFlags = testFlagsFunctionPtr(); 1090206917Smarius --count; 1091206917Smarius if ( count == 0 ) { 1092206917Smarius checkEarlyExit(); 1093206917Smarius count = 10000; 1094206917Smarius } 1095206917Smarius if ( ! floatx80_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 1096206917Smarius if ( ! checkNaNs 1097206917Smarius && float32_is_signaling_nan( testCases_a_float32 ) ) { 1098206917Smarius trueFlags |= float_flag_invalid; 1099206917Smarius } 1100206917Smarius if ( ! checkNaNs 1101206917Smarius && floatx80_isNaN( trueZ ) 1102206917Smarius && floatx80_isNaN( testZ ) 1103206917Smarius && ! floatx80_is_signaling_nan( testZ ) 1104206917Smarius && ( trueFlags == testFlags ) 1105206917Smarius ) { 1106206917Smarius /* no problem */ 1107206917Smarius } 1108206917Smarius else { 1109206917Smarius ++errorCount; 1110206917Smarius writeErrorFound( 10000 - count ); 1111206917Smarius writeInput_a_float32(); 1112206917Smarius fputs( "\n\t", stdout ); 1113206917Smarius writeOutputs_z_floatx80( trueZ, trueFlags, testZ, testFlags ); 1114206917Smarius fflush( stdout ); 1115206917Smarius if ( errorCount == maxErrorCount ) goto exit; 1116206917Smarius } 1117206917Smarius } 1118206917Smarius } 1119206917Smarius exit: 1120206917Smarius writeTestsPerformed( 10000 - count ); 1121206917Smarius 1122206917Smarius} 1123206917Smarius 1124206917Smarius#endif 1125206917Smarius 1126206917Smarius#ifdef FLOAT128 1127206917Smarius 1128206917Smariusvoid 1129206917Smarius test_a_float32_z_float128( 1130206917Smarius float128 trueFunction( float32 ), float128 testFunction( float32 ) ) 1131206917Smarius{ 1132206917Smarius int16 count; 1133206917Smarius float128 trueZ, testZ; 1134206917Smarius uint8 trueFlags, testFlags; 1135206917Smarius 1136206917Smarius errorCount = 0; 1137206917Smarius tenthousandsCount = 0; 1138206917Smarius count = 10000; 1139206917Smarius testCases_initSequence( testCases_sequence_a_float32 ); 1140206917Smarius writeTestsTotal(); 1141206917Smarius while ( ! testCases_done || forever ) { 1142206917Smarius testCases_next(); 1143206917Smarius *trueFlagsPtr = 0; 1144206917Smarius trueZ = trueFunction( testCases_a_float32 ); 1145206917Smarius trueFlags = *trueFlagsPtr; 1146206917Smarius (void) testFlagsFunctionPtr(); 1147206917Smarius testZ = testFunction( testCases_a_float32 ); 1148206917Smarius testFlags = testFlagsFunctionPtr(); 1149206917Smarius --count; 1150206917Smarius if ( count == 0 ) { 1151206917Smarius checkEarlyExit(); 1152206917Smarius count = 10000; 1153206917Smarius } 1154206917Smarius if ( ! float128_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 1155206917Smarius if ( ! checkNaNs 1156206917Smarius && float32_is_signaling_nan( testCases_a_float32 ) ) { 1157206917Smarius trueFlags |= float_flag_invalid; 1158206917Smarius } 1159206917Smarius if ( ! checkNaNs 1160206917Smarius && float128_isNaN( trueZ ) 1161206917Smarius && float128_isNaN( testZ ) 1162206917Smarius && ! float128_is_signaling_nan( testZ ) 1163206917Smarius && ( trueFlags == testFlags ) 1164206917Smarius ) { 1165206917Smarius /* no problem */ 1166206917Smarius } 1167206917Smarius else { 1168206917Smarius ++errorCount; 1169206917Smarius writeErrorFound( 10000 - count ); 1170206917Smarius writeInput_a_float32(); 1171206917Smarius fputs( "\n\t", stdout ); 1172206917Smarius writeOutputs_z_float128( trueZ, trueFlags, testZ, testFlags ); 1173206917Smarius fflush( stdout ); 1174206917Smarius if ( errorCount == maxErrorCount ) goto exit; 1175206917Smarius } 1176206917Smarius } 1177206917Smarius } 1178206917Smarius exit: 1179206917Smarius writeTestsPerformed( 10000 - count ); 1180206917Smarius 1181206917Smarius} 1182206917Smarius 1183206917Smarius#endif 1184206917Smarius 1185206917Smariusvoid 1186206917Smarius test_az_float32( 1187206917Smarius float32 trueFunction( float32 ), float32 testFunction( float32 ) ) 1188206917Smarius{ 1189206917Smarius int16 count; 1190206917Smarius float32 trueZ, testZ; 1191206917Smarius uint8 trueFlags, testFlags; 1192206917Smarius 1193206917Smarius errorCount = 0; 1194206917Smarius tenthousandsCount = 0; 1195206917Smarius count = 10000; 1196206917Smarius testCases_initSequence( testCases_sequence_a_float32 ); 1197206917Smarius writeTestsTotal(); 1198206917Smarius while ( ! testCases_done || forever ) { 1199206917Smarius testCases_next(); 1200206917Smarius *trueFlagsPtr = 0; 1201206917Smarius trueZ = trueFunction( testCases_a_float32 ); 1202206917Smarius trueFlags = *trueFlagsPtr; 1203206917Smarius (void) testFlagsFunctionPtr(); 1204206917Smarius testZ = testFunction( testCases_a_float32 ); 1205206917Smarius testFlags = testFlagsFunctionPtr(); 1206206917Smarius --count; 1207206917Smarius if ( count == 0 ) { 1208206917Smarius checkEarlyExit(); 1209206917Smarius count = 10000; 1210206917Smarius } 1211206917Smarius if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1212206917Smarius if ( ! checkNaNs 1213206917Smarius && float32_is_signaling_nan( testCases_a_float32 ) ) { 1214206917Smarius trueFlags |= float_flag_invalid; 1215206917Smarius } 1216206917Smarius if ( ! checkNaNs 1217206917Smarius && float32_isNaN( trueZ ) 1218206917Smarius && float32_isNaN( testZ ) 1219206917Smarius && ! float32_is_signaling_nan( testZ ) 1220206917Smarius && ( trueFlags == testFlags ) 1221206917Smarius ) { 1222206917Smarius /* no problem */ 1223206917Smarius } 1224206917Smarius else { 1225206917Smarius ++errorCount; 1226206917Smarius writeErrorFound( 10000 - count ); 1227206917Smarius writeInput_a_float32(); 1228206917Smarius fputs( " ", stdout ); 1229206917Smarius writeOutputs_z_float32( trueZ, trueFlags, testZ, testFlags ); 1230206917Smarius fflush( stdout ); 1231206917Smarius if ( errorCount == maxErrorCount ) goto exit; 1232206917Smarius } 1233206917Smarius } 1234206917Smarius } 1235206917Smarius exit: 1236206917Smarius writeTestsPerformed( 10000 - count ); 1237206917Smarius 1238206917Smarius} 1239206917Smarius 1240206917Smariusvoid 1241206917Smarius test_ab_float32_z_flag( 1242206917Smarius flag trueFunction( float32, float32 ), 1243206917Smarius flag testFunction( float32, float32 ) 1244206917Smarius ) 1245206917Smarius{ 1246206917Smarius int16 count; 1247206917Smarius flag trueZ, testZ; 1248206917Smarius uint8 trueFlags, testFlags; 1249206917Smarius 1250206917Smarius errorCount = 0; 1251206917Smarius tenthousandsCount = 0; 1252206917Smarius count = 10000; 1253206917Smarius testCases_initSequence( testCases_sequence_ab_float32 ); 1254206917Smarius writeTestsTotal(); 1255206917Smarius while ( ! testCases_done || forever ) { 1256206917Smarius testCases_next(); 1257206917Smarius *trueFlagsPtr = 0; 1258206917Smarius trueZ = trueFunction( testCases_a_float32, testCases_b_float32 ); 1259206917Smarius trueFlags = *trueFlagsPtr; 1260206917Smarius (void) testFlagsFunctionPtr(); 1261206917Smarius testZ = testFunction( testCases_a_float32, testCases_b_float32 ); 1262206917Smarius testFlags = testFlagsFunctionPtr(); 1263206917Smarius --count; 1264206917Smarius if ( count == 0 ) { 1265206917Smarius checkEarlyExit(); 1266206917Smarius count = 10000; 1267206917Smarius } 1268206917Smarius if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1269206917Smarius if ( ! checkNaNs 1270206917Smarius && ( float32_is_signaling_nan( testCases_a_float32 ) 1271206917Smarius || float32_is_signaling_nan( testCases_b_float32 ) ) 1272206917Smarius ) { 1273206917Smarius trueFlags |= float_flag_invalid; 1274206917Smarius } 1275206917Smarius if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1276206917Smarius ++errorCount; 1277206917Smarius writeErrorFound( 10000 - count ); 1278206917Smarius writeInputs_ab_float32(); 1279206917Smarius fputs( " ", stdout ); 1280206917Smarius writeOutputs_z_flag( trueZ, trueFlags, testZ, testFlags ); 1281206917Smarius fflush( stdout ); 1282206917Smarius if ( errorCount == maxErrorCount ) goto exit; 1283206917Smarius } 1284206917Smarius } 1285206917Smarius } 1286206917Smarius exit: 1287206917Smarius writeTestsPerformed( 10000 - count ); 1288206917Smarius return; 1289206917Smarius 1290206917Smarius} 1291206917Smarius 1292206917Smariusvoid 1293206917Smarius test_abz_float32( 1294206917Smarius float32 trueFunction( float32, float32 ), 1295206917Smarius float32 testFunction( float32, float32 ) 1296206917Smarius ) 1297206917Smarius{ 1298206917Smarius int16 count; 1299206917Smarius float32 trueZ, testZ; 1300206917Smarius uint8 trueFlags, testFlags; 1301206917Smarius 1302206917Smarius errorCount = 0; 1303206917Smarius tenthousandsCount = 0; 1304206917Smarius count = 10000; 1305206917Smarius testCases_initSequence( testCases_sequence_ab_float32 ); 1306206917Smarius writeTestsTotal(); 1307206917Smarius while ( ! testCases_done || forever ) { 1308206917Smarius testCases_next(); 1309206917Smarius *trueFlagsPtr = 0; 1310206917Smarius trueZ = trueFunction( testCases_a_float32, testCases_b_float32 ); 1311206917Smarius trueFlags = *trueFlagsPtr; 1312206917Smarius (void) testFlagsFunctionPtr(); 1313206917Smarius testZ = testFunction( testCases_a_float32, testCases_b_float32 ); 1314206917Smarius testFlags = testFlagsFunctionPtr(); 1315206917Smarius --count; 1316206917Smarius if ( count == 0 ) { 1317206917Smarius checkEarlyExit(); 1318206917Smarius count = 10000; 1319206917Smarius } 1320206917Smarius if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1321206917Smarius if ( ! checkNaNs 1322206917Smarius && ( float32_is_signaling_nan( testCases_a_float32 ) 1323206917Smarius || float32_is_signaling_nan( testCases_b_float32 ) ) 1324206917Smarius ) { 1325206917Smarius trueFlags |= float_flag_invalid; 1326206917Smarius } 1327206917Smarius if ( ! checkNaNs 1328206917Smarius && float32_isNaN( trueZ ) 1329206917Smarius && float32_isNaN( testZ ) 1330206917Smarius && ! float32_is_signaling_nan( testZ ) 1331206917Smarius && ( trueFlags == testFlags ) 1332206917Smarius ) { 1333206917Smarius /* no problem */ 1334206917Smarius } 1335206917Smarius else { 1336206917Smarius ++errorCount; 1337206917Smarius writeErrorFound( 10000 - count ); 1338206917Smarius writeInputs_ab_float32(); 1339206917Smarius fputs( " ", stdout ); 1340206917Smarius writeOutputs_z_float32( trueZ, trueFlags, testZ, testFlags ); 1341206917Smarius fflush( stdout ); 1342206917Smarius if ( errorCount == maxErrorCount ) goto exit; 1343206917Smarius } 1344206917Smarius } 1345206917Smarius } 1346206917Smarius exit: 1347206917Smarius writeTestsPerformed( 10000 - count ); 1348206917Smarius return; 1349206917Smarius 1350206917Smarius} 1351206917Smarius 1352206917Smariusvoid 1353206917Smarius test_a_float64_z_int32( 1354206917Smarius int32 trueFunction( float64 ), int32 testFunction( float64 ) ) 1355206917Smarius{ 1356206917Smarius int16 count; 1357206917Smarius int32 trueZ, testZ; 1358206917Smarius uint8 trueFlags, testFlags; 1359206917Smarius 1360206917Smarius errorCount = 0; 1361206917Smarius tenthousandsCount = 0; 1362206917Smarius count = 10000; 1363206917Smarius testCases_initSequence( testCases_sequence_a_float64 ); 1364206917Smarius writeTestsTotal(); 1365206917Smarius while ( ! testCases_done || forever ) { 1366206917Smarius testCases_next(); 1367206917Smarius *trueFlagsPtr = 0; 1368206917Smarius trueZ = trueFunction( testCases_a_float64 ); 1369206917Smarius trueFlags = *trueFlagsPtr; 1370206917Smarius (void) testFlagsFunctionPtr(); 1371206917Smarius testZ = testFunction( testCases_a_float64 ); 1372206917Smarius testFlags = testFlagsFunctionPtr(); 1373206917Smarius --count; 1374206917Smarius if ( count == 0 ) { 1375206917Smarius checkEarlyExit(); 1376206917Smarius count = 10000; 1377206917Smarius } 1378206917Smarius if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1379206917Smarius if ( ! checkNaNs 1380206917Smarius && float64_is_signaling_nan( testCases_a_float64 ) ) { 1381206917Smarius trueFlags |= float_flag_invalid; 1382206917Smarius } 1383206917Smarius if ( ( trueZ == 0x7FFFFFFF ) 1384206917Smarius && ( ( testZ == 0x7FFFFFFF ) 1385206917Smarius || ( testZ == (sbits32) 0x80000000 ) ) 1386206917Smarius && ( trueFlags == float_flag_invalid ) 1387206917Smarius && ( testFlags == float_flag_invalid ) 1388206917Smarius ) { 1389206917Smarius /* no problem */ 1390206917Smarius } 1391206917Smarius else { 1392206917Smarius ++errorCount; 1393206917Smarius writeErrorFound( 10000 - count ); 1394206917Smarius writeInput_a_float64(); 1395206917Smarius fputs( " ", stdout ); 1396206917Smarius writeOutputs_z_int32( trueZ, trueFlags, testZ, testFlags ); 1397206917Smarius fflush( stdout ); 1398206917Smarius if ( errorCount == maxErrorCount ) goto exit; 1399206917Smarius } 1400206917Smarius } 1401206917Smarius } 1402206917Smarius exit: 1403206917Smarius writeTestsPerformed( 10000 - count ); 1404206917Smarius 1405206917Smarius} 1406206917Smarius 1407206917Smarius#ifdef BITS64 1408206917Smarius 1409206917Smariusvoid 1410206917Smarius test_a_float64_z_int64( 1411206917Smarius int64 trueFunction( float64 ), int64 testFunction( float64 ) ) 1412206917Smarius{ 1413206917Smarius int16 count; 1414206917Smarius int64 trueZ, testZ; 1415206917Smarius uint8 trueFlags, testFlags; 1416206917Smarius 1417206917Smarius errorCount = 0; 1418206917Smarius tenthousandsCount = 0; 1419206917Smarius count = 10000; 1420206917Smarius testCases_initSequence( testCases_sequence_a_float64 ); 1421206917Smarius writeTestsTotal(); 1422206917Smarius while ( ! testCases_done || forever ) { 1423206917Smarius testCases_next(); 1424206917Smarius *trueFlagsPtr = 0; 1425206917Smarius trueZ = trueFunction( testCases_a_float64 ); 1426206917Smarius trueFlags = *trueFlagsPtr; 1427206917Smarius (void) testFlagsFunctionPtr(); 1428206917Smarius testZ = testFunction( testCases_a_float64 ); 1429206917Smarius testFlags = testFlagsFunctionPtr(); 1430206917Smarius --count; 1431206917Smarius if ( count == 0 ) { 1432206917Smarius checkEarlyExit(); 1433206917Smarius count = 10000; 1434206917Smarius } 1435206917Smarius if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1436206917Smarius if ( ! checkNaNs 1437206917Smarius && float64_is_signaling_nan( testCases_a_float64 ) ) { 1438206917Smarius trueFlags |= float_flag_invalid; 1439206917Smarius } 1440206917Smarius if ( ( trueZ == LIT64( 0x7FFFFFFFFFFFFFFF ) ) 1441206917Smarius && ( ( testZ == LIT64( 0x7FFFFFFFFFFFFFFF ) ) 1442206917Smarius || ( testZ == (sbits64) LIT64( 0x8000000000000000 ) ) ) 1443206917Smarius && ( trueFlags == float_flag_invalid ) 1444206917Smarius && ( testFlags == float_flag_invalid ) 1445206917Smarius ) { 1446206917Smarius /* no problem */ 1447206917Smarius } 1448206917Smarius else { 1449206917Smarius ++errorCount; 1450206917Smarius writeErrorFound( 10000 - count ); 1451206917Smarius writeInput_a_float64(); 1452206917Smarius fputs( " ", stdout ); 1453206917Smarius writeOutputs_z_int64( trueZ, trueFlags, testZ, testFlags ); 1454206917Smarius fflush( stdout ); 1455206917Smarius if ( errorCount == maxErrorCount ) goto exit; 1456206917Smarius } 1457206917Smarius } 1458206917Smarius } 1459206917Smarius exit: 1460206917Smarius writeTestsPerformed( 10000 - count ); 1461206917Smarius 1462206917Smarius} 1463206917Smarius 1464206917Smarius#endif 1465206917Smarius 1466206917Smariusvoid 1467206917Smarius test_a_float64_z_float32( 1468206917Smarius float32 trueFunction( float64 ), float32 testFunction( float64 ) ) 1469206917Smarius{ 1470206917Smarius int16 count; 1471206917Smarius float32 trueZ, testZ; 1472206917Smarius uint8 trueFlags, testFlags; 1473206917Smarius 1474206917Smarius errorCount = 0; 1475206917Smarius tenthousandsCount = 0; 1476206917Smarius count = 10000; 1477206917Smarius testCases_initSequence( testCases_sequence_a_float64 ); 1478206917Smarius writeTestsTotal(); 1479206917Smarius while ( ! testCases_done || forever ) { 1480206917Smarius testCases_next(); 1481206917Smarius *trueFlagsPtr = 0; 1482206917Smarius trueZ = trueFunction( testCases_a_float64 ); 1483206917Smarius trueFlags = *trueFlagsPtr; 1484206917Smarius (void) testFlagsFunctionPtr(); 1485206917Smarius testZ = testFunction( testCases_a_float64 ); 1486206917Smarius testFlags = testFlagsFunctionPtr(); 1487206917Smarius --count; 1488206917Smarius if ( count == 0 ) { 1489206917Smarius checkEarlyExit(); 1490206917Smarius count = 10000; 1491206917Smarius } 1492206917Smarius if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1493206917Smarius if ( ! checkNaNs 1494206917Smarius && float64_is_signaling_nan( testCases_a_float64 ) ) { 1495206917Smarius trueFlags |= float_flag_invalid; 1496206917Smarius } 1497206917Smarius if ( ! checkNaNs 1498206917Smarius && float32_isNaN( trueZ ) 1499206917Smarius && float32_isNaN( testZ ) 1500206917Smarius && ! float32_is_signaling_nan( testZ ) 1501206917Smarius && ( trueFlags == testFlags ) 1502206917Smarius ) { 1503206917Smarius /* no problem */ 1504206917Smarius } 1505206917Smarius else { 1506206917Smarius ++errorCount; 1507206917Smarius writeErrorFound( 10000 - count ); 1508206917Smarius writeInput_a_float64(); 1509206917Smarius fputs( " ", stdout ); 1510206917Smarius writeOutputs_z_float32( trueZ, trueFlags, testZ, testFlags ); 1511206917Smarius fflush( stdout ); 1512206917Smarius if ( errorCount == maxErrorCount ) goto exit; 1513206917Smarius } 1514206917Smarius } 1515206917Smarius } 1516206917Smarius exit: 1517206917Smarius writeTestsPerformed( 10000 - count ); 1518206917Smarius 1519206917Smarius} 1520206917Smarius 1521206917Smarius#ifdef FLOATX80 1522206917Smarius 1523206917Smariusvoid 1524206917Smarius test_a_float64_z_floatx80( 1525206917Smarius floatx80 trueFunction( float64 ), floatx80 testFunction( float64 ) ) 1526206917Smarius{ 1527206917Smarius int16 count; 1528206917Smarius floatx80 trueZ, testZ; 1529206917Smarius uint8 trueFlags, testFlags; 1530206917Smarius 1531206917Smarius errorCount = 0; 1532206917Smarius tenthousandsCount = 0; 1533206917Smarius count = 10000; 1534206917Smarius testCases_initSequence( testCases_sequence_a_float64 ); 1535206917Smarius writeTestsTotal(); 1536206917Smarius while ( ! testCases_done || forever ) { 1537206917Smarius testCases_next(); 1538206917Smarius *trueFlagsPtr = 0; 1539206917Smarius trueZ = trueFunction( testCases_a_float64 ); 1540206917Smarius trueFlags = *trueFlagsPtr; 1541206917Smarius (void) testFlagsFunctionPtr(); 1542206917Smarius testZ = testFunction( testCases_a_float64 ); 1543206917Smarius testFlags = testFlagsFunctionPtr(); 1544206917Smarius --count; 1545206917Smarius if ( count == 0 ) { 1546206917Smarius checkEarlyExit(); 1547206917Smarius count = 10000; 1548206917Smarius } 1549206917Smarius if ( ! floatx80_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 1550206917Smarius if ( ! checkNaNs 1551206917Smarius && float64_is_signaling_nan( testCases_a_float64 ) ) { 1552206917Smarius trueFlags |= float_flag_invalid; 1553206917Smarius } 1554206917Smarius if ( ! checkNaNs 1555206917Smarius && floatx80_isNaN( trueZ ) 1556206917Smarius && floatx80_isNaN( testZ ) 1557206917Smarius && ! floatx80_is_signaling_nan( testZ ) 1558206917Smarius && ( trueFlags == testFlags ) 1559206917Smarius ) { 1560206917Smarius /* no problem */ 1561206917Smarius } 1562206917Smarius else { 1563206917Smarius ++errorCount; 1564206917Smarius writeErrorFound( 10000 - count ); 1565206917Smarius writeInput_a_float64(); 1566206917Smarius fputs( "\n\t", stdout ); 1567206917Smarius writeOutputs_z_floatx80( trueZ, trueFlags, testZ, testFlags ); 1568206917Smarius fflush( stdout ); 1569206917Smarius if ( errorCount == maxErrorCount ) goto exit; 1570206917Smarius } 1571206917Smarius } 1572206917Smarius } 1573206917Smarius exit: 1574206917Smarius writeTestsPerformed( 10000 - count ); 1575206917Smarius 1576206917Smarius} 1577206917Smarius 1578206917Smarius#endif 1579206917Smarius 1580206917Smarius#ifdef FLOAT128 1581206917Smarius 1582206917Smariusvoid 1583206917Smarius test_a_float64_z_float128( 1584206917Smarius float128 trueFunction( float64 ), float128 testFunction( float64 ) ) 1585206917Smarius{ 1586206917Smarius int16 count; 1587206917Smarius float128 trueZ, testZ; 1588206917Smarius uint8 trueFlags, testFlags; 1589206917Smarius 1590206917Smarius errorCount = 0; 1591206917Smarius tenthousandsCount = 0; 1592206917Smarius count = 10000; 1593206917Smarius testCases_initSequence( testCases_sequence_a_float64 ); 1594206917Smarius writeTestsTotal(); 1595206917Smarius while ( ! testCases_done || forever ) { 1596206917Smarius testCases_next(); 1597206917Smarius *trueFlagsPtr = 0; 1598206917Smarius trueZ = trueFunction( testCases_a_float64 ); 1599206917Smarius trueFlags = *trueFlagsPtr; 1600206917Smarius (void) testFlagsFunctionPtr(); 1601206917Smarius testZ = testFunction( testCases_a_float64 ); 1602206917Smarius testFlags = testFlagsFunctionPtr(); 1603206917Smarius --count; 1604206917Smarius if ( count == 0 ) { 1605206917Smarius checkEarlyExit(); 1606206917Smarius count = 10000; 1607206917Smarius } 1608206917Smarius if ( ! float128_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 1609206917Smarius if ( ! checkNaNs 1610206917Smarius && float64_is_signaling_nan( testCases_a_float64 ) ) { 1611206917Smarius trueFlags |= float_flag_invalid; 1612206917Smarius } 1613206917Smarius if ( ! checkNaNs 1614206917Smarius && float128_isNaN( trueZ ) 1615206917Smarius && float128_isNaN( testZ ) 1616206917Smarius && ! float128_is_signaling_nan( testZ ) 1617206917Smarius && ( trueFlags == testFlags ) 1618206917Smarius ) { 1619206917Smarius /* no problem */ 1620206917Smarius } 1621206917Smarius else { 1622206917Smarius ++errorCount; 1623206917Smarius writeErrorFound( 10000 - count ); 1624206917Smarius writeInput_a_float64(); 1625206917Smarius fputs( "\n\t", stdout ); 1626206917Smarius writeOutputs_z_float128( trueZ, trueFlags, testZ, testFlags ); 1627206917Smarius fflush( stdout ); 1628206917Smarius if ( errorCount == maxErrorCount ) goto exit; 1629206917Smarius } 1630206917Smarius } 1631206917Smarius } 1632206917Smarius exit: 1633206917Smarius writeTestsPerformed( 10000 - count ); 1634206917Smarius 1635206917Smarius} 1636206917Smarius 1637206917Smarius#endif 1638206917Smarius 1639206917Smariusvoid 1640206917Smarius test_az_float64( 1641206917Smarius float64 trueFunction( float64 ), float64 testFunction( float64 ) ) 1642206917Smarius{ 1643206917Smarius int16 count; 1644206917Smarius float64 trueZ, testZ; 1645206917Smarius uint8 trueFlags, testFlags; 1646206917Smarius 1647206917Smarius errorCount = 0; 1648206917Smarius tenthousandsCount = 0; 1649206917Smarius count = 10000; 1650206917Smarius testCases_initSequence( testCases_sequence_a_float64 ); 1651206917Smarius writeTestsTotal(); 1652206917Smarius while ( ! testCases_done || forever ) { 1653206917Smarius testCases_next(); 1654206917Smarius *trueFlagsPtr = 0; 1655206917Smarius trueZ = trueFunction( testCases_a_float64 ); 1656206917Smarius trueFlags = *trueFlagsPtr; 1657206917Smarius (void) testFlagsFunctionPtr(); 1658206917Smarius testZ = testFunction( testCases_a_float64 ); 1659206917Smarius testFlags = testFlagsFunctionPtr(); 1660206917Smarius --count; 1661206917Smarius if ( count == 0 ) { 1662206917Smarius checkEarlyExit(); 1663206917Smarius count = 10000; 1664206917Smarius } 1665206917Smarius if ( ! float64_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 1666206917Smarius if ( ! checkNaNs 1667206917Smarius && float64_is_signaling_nan( testCases_a_float64 ) ) { 1668206917Smarius trueFlags |= float_flag_invalid; 1669206917Smarius } 1670206917Smarius if ( ! checkNaNs 1671206917Smarius && float64_isNaN( trueZ ) 1672206917Smarius && float64_isNaN( testZ ) 1673206917Smarius && ! float64_is_signaling_nan( testZ ) 1674206917Smarius && ( trueFlags == testFlags ) 1675206917Smarius ) { 1676206917Smarius /* no problem */ 1677206917Smarius } 1678206917Smarius else { 1679206917Smarius ++errorCount; 1680206917Smarius writeErrorFound( 10000 - count ); 1681206917Smarius writeInput_a_float64(); 1682206917Smarius fputs( " ", stdout ); 1683206917Smarius writeOutputs_z_float64( trueZ, trueFlags, testZ, testFlags ); 1684206917Smarius fflush( stdout ); 1685206917Smarius if ( errorCount == maxErrorCount ) goto exit; 1686206917Smarius } 1687206917Smarius } 1688206917Smarius } 1689206917Smarius exit: 1690206917Smarius writeTestsPerformed( 10000 - count ); 1691206917Smarius 1692206917Smarius} 1693206917Smarius 1694206917Smariusvoid 1695206917Smarius test_ab_float64_z_flag( 1696206917Smarius flag trueFunction( float64, float64 ), 1697206917Smarius flag testFunction( float64, float64 ) 1698206917Smarius ) 1699206917Smarius{ 1700206917Smarius int16 count; 1701206917Smarius flag trueZ, testZ; 1702206917Smarius uint8 trueFlags, testFlags; 1703206917Smarius 1704206917Smarius errorCount = 0; 1705206917Smarius tenthousandsCount = 0; 1706206917Smarius count = 10000; 1707206917Smarius testCases_initSequence( testCases_sequence_ab_float64 ); 1708206917Smarius writeTestsTotal(); 1709206917Smarius while ( ! testCases_done || forever ) { 1710206917Smarius testCases_next(); 1711206917Smarius *trueFlagsPtr = 0; 1712206917Smarius trueZ = trueFunction( testCases_a_float64, testCases_b_float64 ); 1713206917Smarius trueFlags = *trueFlagsPtr; 1714206917Smarius (void) testFlagsFunctionPtr(); 1715206917Smarius testZ = testFunction( testCases_a_float64, testCases_b_float64 ); 1716206917Smarius testFlags = testFlagsFunctionPtr(); 1717206917Smarius --count; 1718206917Smarius if ( count == 0 ) { 1719206917Smarius checkEarlyExit(); 1720206917Smarius count = 10000; 1721206917Smarius } 1722206917Smarius if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1723206917Smarius if ( ! checkNaNs 1724206917Smarius && ( float64_is_signaling_nan( testCases_a_float64 ) 1725206917Smarius || float64_is_signaling_nan( testCases_b_float64 ) ) 1726206917Smarius ) { 1727206917Smarius trueFlags |= float_flag_invalid; 1728206917Smarius } 1729206917Smarius if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1730206917Smarius ++errorCount; 1731206917Smarius writeErrorFound( 10000 - count ); 1732206917Smarius writeInputs_ab_float64(); 1733206917Smarius fputs( " ", stdout ); 1734206917Smarius writeOutputs_z_flag( trueZ, trueFlags, testZ, testFlags ); 1735206917Smarius fflush( stdout ); 1736206917Smarius if ( errorCount == maxErrorCount ) goto exit; 1737206917Smarius } 1738206917Smarius } 1739206917Smarius } 1740206917Smarius exit: 1741206917Smarius writeTestsPerformed( 10000 - count ); 1742206917Smarius return; 1743206917Smarius 1744206917Smarius} 1745206917Smarius 1746206917Smariusvoid 1747206917Smarius test_abz_float64( 1748206917Smarius float64 trueFunction( float64, float64 ), 1749206917Smarius float64 testFunction( float64, float64 ) 1750206917Smarius ) 1751206917Smarius{ 1752206917Smarius int16 count; 1753206917Smarius float64 trueZ, testZ; 1754206917Smarius uint8 trueFlags, testFlags; 1755206917Smarius 1756206917Smarius errorCount = 0; 1757206917Smarius tenthousandsCount = 0; 1758206917Smarius count = 10000; 1759206917Smarius testCases_initSequence( testCases_sequence_ab_float64 ); 1760206917Smarius writeTestsTotal(); 1761206917Smarius while ( ! testCases_done || forever ) { 1762206917Smarius testCases_next(); 1763206917Smarius *trueFlagsPtr = 0; 1764206917Smarius trueZ = trueFunction( testCases_a_float64, testCases_b_float64 ); 1765206917Smarius trueFlags = *trueFlagsPtr; 1766206917Smarius (void) testFlagsFunctionPtr(); 1767206917Smarius testZ = testFunction( testCases_a_float64, testCases_b_float64 ); 1768206917Smarius testFlags = testFlagsFunctionPtr(); 1769206917Smarius --count; 1770206917Smarius if ( count == 0 ) { 1771206917Smarius checkEarlyExit(); 1772206917Smarius count = 10000; 1773206917Smarius } 1774206917Smarius if ( ! float64_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 1775206917Smarius if ( ! checkNaNs 1776206917Smarius && ( float64_is_signaling_nan( testCases_a_float64 ) 1777206917Smarius || float64_is_signaling_nan( testCases_b_float64 ) ) 1778206917Smarius ) { 1779206917Smarius trueFlags |= float_flag_invalid; 1780206917Smarius } 1781206917Smarius if ( ! checkNaNs 1782206917Smarius && float64_isNaN( trueZ ) 1783206917Smarius && float64_isNaN( testZ ) 1784206917Smarius && ! float64_is_signaling_nan( testZ ) 1785206917Smarius && ( trueFlags == testFlags ) 1786206917Smarius ) { 1787206917Smarius /* no problem */ 1788206917Smarius } 1789206917Smarius else { 1790206917Smarius ++errorCount; 1791206917Smarius writeErrorFound( 10000 - count ); 1792206917Smarius writeInputs_ab_float64(); 1793206917Smarius fputs( "\n\t", stdout ); 1794206917Smarius writeOutputs_z_float64( trueZ, trueFlags, testZ, testFlags ); 1795206917Smarius fflush( stdout ); 1796206917Smarius if ( errorCount == maxErrorCount ) goto exit; 1797206917Smarius } 1798206917Smarius } 1799206917Smarius } 1800206917Smarius exit: 1801206917Smarius writeTestsPerformed( 10000 - count ); 1802206917Smarius return; 1803206917Smarius 1804206917Smarius} 1805206917Smarius 1806206917Smarius#ifdef FLOATX80 1807206917Smarius 1808206917Smariusvoid 1809206917Smarius test_a_floatx80_z_int32( 1810206917Smarius int32 trueFunction( floatx80 ), int32 testFunction( floatx80 ) ) 1811206917Smarius{ 1812206917Smarius int16 count; 1813206917Smarius int32 trueZ, testZ; 1814206917Smarius uint8 trueFlags, testFlags; 1815206917Smarius 1816206917Smarius errorCount = 0; 1817206917Smarius tenthousandsCount = 0; 1818206917Smarius count = 10000; 1819206917Smarius testCases_initSequence( testCases_sequence_a_floatx80 ); 1820206917Smarius writeTestsTotal(); 1821206917Smarius while ( ! testCases_done || forever ) { 1822206917Smarius testCases_next(); 1823206917Smarius *trueFlagsPtr = 0; 1824206917Smarius trueZ = trueFunction( testCases_a_floatx80 ); 1825206917Smarius trueFlags = *trueFlagsPtr; 1826206917Smarius (void) testFlagsFunctionPtr(); 1827206917Smarius testZ = testFunction( testCases_a_floatx80 ); 1828206917Smarius testFlags = testFlagsFunctionPtr(); 1829206917Smarius --count; 1830206917Smarius if ( count == 0 ) { 1831206917Smarius checkEarlyExit(); 1832206917Smarius count = 10000; 1833206917Smarius } 1834206917Smarius if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1835206917Smarius if ( ! checkNaNs 1836206917Smarius && floatx80_is_signaling_nan( testCases_a_floatx80 ) ) { 1837206917Smarius trueFlags |= float_flag_invalid; 1838206917Smarius } 1839206917Smarius if ( ( trueZ == 0x7FFFFFFF ) 1840206917Smarius && ( ( testZ == 0x7FFFFFFF ) 1841206917Smarius || ( testZ == (sbits32) 0x80000000 ) ) 1842206917Smarius && ( trueFlags == float_flag_invalid ) 1843206917Smarius && ( testFlags == float_flag_invalid ) 1844206917Smarius ) { 1845206917Smarius /* no problem */ 1846206917Smarius } 1847206917Smarius else { 1848206917Smarius ++errorCount; 1849206917Smarius writeErrorFound( 10000 - count ); 1850206917Smarius writeInput_a_floatx80(); 1851206917Smarius fputs( " ", stdout ); 1852206917Smarius writeOutputs_z_int32( trueZ, trueFlags, testZ, testFlags ); 1853206917Smarius fflush( stdout ); 1854206917Smarius if ( errorCount == maxErrorCount ) goto exit; 1855206917Smarius } 1856206917Smarius } 1857206917Smarius } 1858206917Smarius exit: 1859206917Smarius writeTestsPerformed( 10000 - count ); 1860206917Smarius 1861206917Smarius} 1862206917Smarius 1863206917Smarius#ifdef BITS64 1864206917Smarius 1865206917Smariusvoid 1866206917Smarius test_a_floatx80_z_int64( 1867206917Smarius int64 trueFunction( floatx80 ), int64 testFunction( floatx80 ) ) 1868206917Smarius{ 1869206917Smarius int16 count; 1870206917Smarius int64 trueZ, testZ; 1871206917Smarius uint8 trueFlags, testFlags; 1872206917Smarius 1873206917Smarius errorCount = 0; 1874206917Smarius tenthousandsCount = 0; 1875206917Smarius count = 10000; 1876206917Smarius testCases_initSequence( testCases_sequence_a_floatx80 ); 1877206917Smarius writeTestsTotal(); 1878206917Smarius while ( ! testCases_done || forever ) { 1879206917Smarius testCases_next(); 1880206917Smarius *trueFlagsPtr = 0; 1881206917Smarius trueZ = trueFunction( testCases_a_floatx80 ); 1882206917Smarius trueFlags = *trueFlagsPtr; 1883206917Smarius (void) testFlagsFunctionPtr(); 1884206917Smarius testZ = testFunction( testCases_a_floatx80 ); 1885206917Smarius testFlags = testFlagsFunctionPtr(); 1886206917Smarius --count; 1887206917Smarius if ( count == 0 ) { 1888206917Smarius checkEarlyExit(); 1889206917Smarius count = 10000; 1890206917Smarius } 1891206917Smarius if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1892206917Smarius if ( ! checkNaNs 1893206917Smarius && floatx80_is_signaling_nan( testCases_a_floatx80 ) ) { 1894206917Smarius trueFlags |= float_flag_invalid; 1895206917Smarius } 1896206917Smarius if ( ( trueZ == LIT64( 0x7FFFFFFFFFFFFFFF ) ) 1897206917Smarius && ( ( testZ == LIT64( 0x7FFFFFFFFFFFFFFF ) ) 1898206917Smarius || ( testZ == (sbits64) LIT64( 0x8000000000000000 ) ) ) 1899206917Smarius && ( trueFlags == float_flag_invalid ) 1900206917Smarius && ( testFlags == float_flag_invalid ) 1901206917Smarius ) { 1902206917Smarius /* no problem */ 1903206917Smarius } 1904206917Smarius else { 1905206917Smarius ++errorCount; 1906206917Smarius writeErrorFound( 10000 - count ); 1907206917Smarius writeInput_a_floatx80(); 1908206917Smarius fputs( " ", stdout ); 1909206917Smarius writeOutputs_z_int64( trueZ, trueFlags, testZ, testFlags ); 1910206917Smarius fflush( stdout ); 1911206917Smarius if ( errorCount == maxErrorCount ) goto exit; 1912206917Smarius } 1913206917Smarius } 1914206917Smarius } 1915206917Smarius exit: 1916206917Smarius writeTestsPerformed( 10000 - count ); 1917206917Smarius 1918206917Smarius} 1919206917Smarius 1920206917Smarius#endif 1921206917Smarius 1922206917Smariusvoid 1923206917Smarius test_a_floatx80_z_float32( 1924206917Smarius float32 trueFunction( floatx80 ), float32 testFunction( floatx80 ) ) 1925206917Smarius{ 1926206917Smarius int16 count; 1927206917Smarius float32 trueZ, testZ; 1928206917Smarius uint8 trueFlags, testFlags; 1929206917Smarius 1930206917Smarius errorCount = 0; 1931206917Smarius tenthousandsCount = 0; 1932206917Smarius count = 10000; 1933206917Smarius testCases_initSequence( testCases_sequence_a_floatx80 ); 1934206917Smarius writeTestsTotal(); 1935206917Smarius while ( ! testCases_done || forever ) { 1936206917Smarius testCases_next(); 1937206917Smarius *trueFlagsPtr = 0; 1938206917Smarius trueZ = trueFunction( testCases_a_floatx80 ); 1939206917Smarius trueFlags = *trueFlagsPtr; 1940206917Smarius (void) testFlagsFunctionPtr(); 1941206917Smarius testZ = testFunction( testCases_a_floatx80 ); 1942206917Smarius testFlags = testFlagsFunctionPtr(); 1943206917Smarius --count; 1944206917Smarius if ( count == 0 ) { 1945206917Smarius checkEarlyExit(); 1946206917Smarius count = 10000; 1947206917Smarius } 1948206917Smarius if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 1949206917Smarius if ( ! checkNaNs 1950206917Smarius && floatx80_is_signaling_nan( testCases_a_floatx80 ) ) { 1951206917Smarius trueFlags |= float_flag_invalid; 1952206917Smarius } 1953206917Smarius if ( ! checkNaNs 1954206917Smarius && float32_isNaN( trueZ ) 1955206917Smarius && float32_isNaN( testZ ) 1956206917Smarius && ! float32_is_signaling_nan( testZ ) 1957206917Smarius && ( trueFlags == testFlags ) 1958206917Smarius ) { 1959206917Smarius /* no problem */ 1960206917Smarius } 1961206917Smarius else { 1962206917Smarius ++errorCount; 1963206917Smarius writeErrorFound( 10000 - count ); 1964206917Smarius writeInput_a_floatx80(); 1965206917Smarius fputs( " ", stdout ); 1966206917Smarius writeOutputs_z_float32( trueZ, trueFlags, testZ, testFlags ); 1967206917Smarius fflush( stdout ); 1968206917Smarius if ( errorCount == maxErrorCount ) goto exit; 1969206917Smarius } 1970206917Smarius } 1971206917Smarius } 1972206917Smarius exit: 1973206917Smarius writeTestsPerformed( 10000 - count ); 1974206917Smarius 1975206917Smarius} 1976206917Smarius 1977206917Smariusvoid 1978206917Smarius test_a_floatx80_z_float64( 1979206917Smarius float64 trueFunction( floatx80 ), float64 testFunction( floatx80 ) ) 1980206917Smarius{ 1981206917Smarius int16 count; 1982206917Smarius float64 trueZ, testZ; 1983206917Smarius uint8 trueFlags, testFlags; 1984206917Smarius 1985206917Smarius errorCount = 0; 1986206917Smarius tenthousandsCount = 0; 1987206917Smarius count = 10000; 1988206917Smarius testCases_initSequence( testCases_sequence_a_floatx80 ); 1989206917Smarius writeTestsTotal(); 1990206917Smarius while ( ! testCases_done || forever ) { 1991206917Smarius testCases_next(); 1992206917Smarius *trueFlagsPtr = 0; 1993206917Smarius trueZ = trueFunction( testCases_a_floatx80 ); 1994206917Smarius trueFlags = *trueFlagsPtr; 1995206917Smarius (void) testFlagsFunctionPtr(); 1996206917Smarius testZ = testFunction( testCases_a_floatx80 ); 1997206917Smarius testFlags = testFlagsFunctionPtr(); 1998206917Smarius --count; 1999206917Smarius if ( count == 0 ) { 2000206917Smarius checkEarlyExit(); 2001206917Smarius count = 10000; 2002206917Smarius } 2003206917Smarius if ( ! float64_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 2004206917Smarius if ( ! checkNaNs 2005206917Smarius && floatx80_is_signaling_nan( testCases_a_floatx80 ) ) { 2006206917Smarius trueFlags |= float_flag_invalid; 2007206917Smarius } 2008206917Smarius if ( ! checkNaNs 2009206917Smarius && float64_isNaN( trueZ ) 2010206917Smarius && float64_isNaN( testZ ) 2011206917Smarius && ! float64_is_signaling_nan( testZ ) 2012206917Smarius && ( trueFlags == testFlags ) 2013206917Smarius ) { 2014206917Smarius /* no problem */ 2015206917Smarius } 2016206917Smarius else { 2017206917Smarius ++errorCount; 2018206917Smarius writeErrorFound( 10000 - count ); 2019206917Smarius writeInput_a_floatx80(); 2020206917Smarius fputs( "\n\t", stdout ); 2021206917Smarius writeOutputs_z_float64( trueZ, trueFlags, testZ, testFlags ); 2022206917Smarius fflush( stdout ); 2023206917Smarius if ( errorCount == maxErrorCount ) goto exit; 2024206917Smarius } 2025206917Smarius } 2026206917Smarius } 2027206917Smarius exit: 2028206917Smarius writeTestsPerformed( 10000 - count ); 2029206917Smarius 2030206917Smarius} 2031206917Smarius 2032206917Smarius#ifdef FLOAT128 2033206917Smarius 2034206917Smariusvoid 2035206917Smarius test_a_floatx80_z_float128( 2036206917Smarius float128 trueFunction( floatx80 ), float128 testFunction( floatx80 ) ) 2037206917Smarius{ 2038206917Smarius int16 count; 2039206917Smarius float128 trueZ, testZ; 2040206917Smarius uint8 trueFlags, testFlags; 2041206917Smarius 2042206917Smarius errorCount = 0; 2043206917Smarius tenthousandsCount = 0; 2044206917Smarius count = 10000; 2045206917Smarius testCases_initSequence( testCases_sequence_a_floatx80 ); 2046206917Smarius writeTestsTotal(); 2047206917Smarius while ( ! testCases_done || forever ) { 2048206917Smarius testCases_next(); 2049206917Smarius *trueFlagsPtr = 0; 2050206917Smarius trueZ = trueFunction( testCases_a_floatx80 ); 2051206917Smarius trueFlags = *trueFlagsPtr; 2052206917Smarius (void) testFlagsFunctionPtr(); 2053206917Smarius testZ = testFunction( testCases_a_floatx80 ); 2054206917Smarius testFlags = testFlagsFunctionPtr(); 2055206917Smarius --count; 2056206917Smarius if ( count == 0 ) { 2057206917Smarius checkEarlyExit(); 2058206917Smarius count = 10000; 2059206917Smarius } 2060206917Smarius if ( ! float128_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 2061206917Smarius if ( ! checkNaNs 2062206917Smarius && floatx80_is_signaling_nan( testCases_a_floatx80 ) ) { 2063206917Smarius trueFlags |= float_flag_invalid; 2064206917Smarius } 2065206917Smarius if ( ! checkNaNs 2066206917Smarius && float128_isNaN( trueZ ) 2067206917Smarius && float128_isNaN( testZ ) 2068206917Smarius && ! float128_is_signaling_nan( testZ ) 2069206917Smarius && ( trueFlags == testFlags ) 2070206917Smarius ) { 2071206917Smarius /* no problem */ 2072206917Smarius } 2073206917Smarius else { 2074206917Smarius ++errorCount; 2075206917Smarius writeErrorFound( 10000 - count ); 2076206917Smarius writeInput_a_floatx80(); 2077206917Smarius fputs( "\n\t", stdout ); 2078206917Smarius writeOutputs_z_float128( trueZ, trueFlags, testZ, testFlags ); 2079206917Smarius fflush( stdout ); 2080206917Smarius if ( errorCount == maxErrorCount ) goto exit; 2081206917Smarius } 2082206917Smarius } 2083206917Smarius } 2084206917Smarius exit: 2085206917Smarius writeTestsPerformed( 10000 - count ); 2086206917Smarius 2087206917Smarius} 2088206917Smarius 2089206917Smarius#endif 2090206917Smarius 2091206917Smariusvoid 2092206917Smarius test_az_floatx80( 2093206917Smarius floatx80 trueFunction( floatx80 ), floatx80 testFunction( floatx80 ) ) 2094206917Smarius{ 2095206917Smarius int16 count; 2096206917Smarius floatx80 trueZ, testZ; 2097206917Smarius uint8 trueFlags, testFlags; 2098206917Smarius 2099206917Smarius errorCount = 0; 2100206917Smarius tenthousandsCount = 0; 2101206917Smarius count = 10000; 2102206917Smarius testCases_initSequence( testCases_sequence_a_floatx80 ); 2103206917Smarius writeTestsTotal(); 2104206917Smarius while ( ! testCases_done || forever ) { 2105206917Smarius testCases_next(); 2106206917Smarius *trueFlagsPtr = 0; 2107206917Smarius trueZ = trueFunction( testCases_a_floatx80 ); 2108206917Smarius trueFlags = *trueFlagsPtr; 2109206917Smarius (void) testFlagsFunctionPtr(); 2110206917Smarius testZ = testFunction( testCases_a_floatx80 ); 2111206917Smarius testFlags = testFlagsFunctionPtr(); 2112206917Smarius --count; 2113206917Smarius if ( count == 0 ) { 2114206917Smarius checkEarlyExit(); 2115206917Smarius count = 10000; 2116206917Smarius } 2117206917Smarius if ( ! floatx80_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 2118206917Smarius if ( ! checkNaNs 2119206917Smarius && floatx80_is_signaling_nan( testCases_a_floatx80 ) ) { 2120206917Smarius trueFlags |= float_flag_invalid; 2121206917Smarius } 2122206917Smarius if ( ! checkNaNs 2123206917Smarius && floatx80_isNaN( trueZ ) 2124206917Smarius && floatx80_isNaN( testZ ) 2125206917Smarius && ! floatx80_is_signaling_nan( testZ ) 2126206917Smarius && ( trueFlags == testFlags ) 2127206917Smarius ) { 2128206917Smarius /* no problem */ 2129206917Smarius } 2130206917Smarius else { 2131206917Smarius ++errorCount; 2132206917Smarius writeErrorFound( 10000 - count ); 2133206917Smarius writeInput_a_floatx80(); 2134206917Smarius fputs( "\n\t", stdout ); 2135206917Smarius writeOutputs_z_floatx80( trueZ, trueFlags, testZ, testFlags ); 2136206917Smarius fflush( stdout ); 2137206917Smarius if ( errorCount == maxErrorCount ) goto exit; 2138206917Smarius } 2139206917Smarius } 2140206917Smarius } 2141206917Smarius exit: 2142206917Smarius writeTestsPerformed( 10000 - count ); 2143206917Smarius 2144206917Smarius} 2145206917Smarius 2146206917Smariusvoid 2147206917Smarius test_ab_floatx80_z_flag( 2148206917Smarius flag trueFunction( floatx80, floatx80 ), 2149206917Smarius flag testFunction( floatx80, floatx80 ) 2150206917Smarius ) 2151206917Smarius{ 2152206917Smarius int16 count; 2153206917Smarius flag trueZ, testZ; 2154206917Smarius uint8 trueFlags, testFlags; 2155206917Smarius 2156206917Smarius errorCount = 0; 2157206917Smarius tenthousandsCount = 0; 2158206917Smarius count = 10000; 2159206917Smarius testCases_initSequence( testCases_sequence_ab_floatx80 ); 2160206917Smarius writeTestsTotal(); 2161206917Smarius while ( ! testCases_done || forever ) { 2162206917Smarius testCases_next(); 2163206917Smarius *trueFlagsPtr = 0; 2164206917Smarius trueZ = trueFunction( testCases_a_floatx80, testCases_b_floatx80 ); 2165206917Smarius trueFlags = *trueFlagsPtr; 2166206917Smarius (void) testFlagsFunctionPtr(); 2167206917Smarius testZ = testFunction( testCases_a_floatx80, testCases_b_floatx80 ); 2168206917Smarius testFlags = testFlagsFunctionPtr(); 2169206917Smarius --count; 2170206917Smarius if ( count == 0 ) { 2171206917Smarius checkEarlyExit(); 2172206917Smarius count = 10000; 2173206917Smarius } 2174206917Smarius if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 2175206917Smarius if ( ! checkNaNs 2176206917Smarius && ( floatx80_is_signaling_nan( testCases_a_floatx80 ) 2177206917Smarius || floatx80_is_signaling_nan( testCases_b_floatx80 ) ) 2178206917Smarius ) { 2179206917Smarius trueFlags |= float_flag_invalid; 2180206917Smarius } 2181206917Smarius if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 2182206917Smarius ++errorCount; 2183206917Smarius writeErrorFound( 10000 - count ); 2184206917Smarius writeInputs_ab_floatx80(); 2185206917Smarius fputs( " ", stdout ); 2186206917Smarius writeOutputs_z_flag( trueZ, trueFlags, testZ, testFlags ); 2187206917Smarius fflush( stdout ); 2188206917Smarius if ( errorCount == maxErrorCount ) goto exit; 2189206917Smarius } 2190206917Smarius } 2191206917Smarius } 2192206917Smarius exit: 2193206917Smarius writeTestsPerformed( 10000 - count ); 2194206917Smarius return; 2195206917Smarius 2196206917Smarius} 2197206917Smarius 2198206917Smariusvoid 2199206917Smarius test_abz_floatx80( 2200206917Smarius floatx80 trueFunction( floatx80, floatx80 ), 2201206917Smarius floatx80 testFunction( floatx80, floatx80 ) 2202206917Smarius ) 2203206917Smarius{ 2204206917Smarius int16 count; 2205206917Smarius floatx80 trueZ, testZ; 2206206917Smarius uint8 trueFlags, testFlags; 2207206917Smarius 2208206917Smarius errorCount = 0; 2209206917Smarius tenthousandsCount = 0; 2210206917Smarius count = 10000; 2211206917Smarius testCases_initSequence( testCases_sequence_ab_floatx80 ); 2212206917Smarius writeTestsTotal(); 2213206917Smarius while ( ! testCases_done || forever ) { 2214206917Smarius testCases_next(); 2215206917Smarius *trueFlagsPtr = 0; 2216206917Smarius trueZ = trueFunction( testCases_a_floatx80, testCases_b_floatx80 ); 2217206917Smarius trueFlags = *trueFlagsPtr; 2218206917Smarius (void) testFlagsFunctionPtr(); 2219206917Smarius testZ = testFunction( testCases_a_floatx80, testCases_b_floatx80 ); 2220206917Smarius testFlags = testFlagsFunctionPtr(); 2221206917Smarius --count; 2222206917Smarius if ( count == 0 ) { 2223206917Smarius checkEarlyExit(); 2224206917Smarius count = 10000; 2225206917Smarius } 2226206917Smarius if ( ! floatx80_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 2227206917Smarius if ( ! checkNaNs 2228206917Smarius && ( floatx80_is_signaling_nan( testCases_a_floatx80 ) 2229206917Smarius || floatx80_is_signaling_nan( testCases_b_floatx80 ) ) 2230206917Smarius ) { 2231206917Smarius trueFlags |= float_flag_invalid; 2232206917Smarius } 2233206917Smarius if ( ! checkNaNs 2234206917Smarius && floatx80_isNaN( trueZ ) 2235206917Smarius && floatx80_isNaN( testZ ) 2236206917Smarius && ! floatx80_is_signaling_nan( testZ ) 2237206917Smarius && ( trueFlags == testFlags ) 2238206917Smarius ) { 2239206917Smarius /* no problem */ 2240206917Smarius } 2241206917Smarius else { 2242206917Smarius ++errorCount; 2243206917Smarius writeErrorFound( 10000 - count ); 2244206917Smarius writeInputs_ab_floatx80(); 2245206917Smarius fputs( "\n\t", stdout ); 2246206917Smarius writeOutputs_z_floatx80( trueZ, trueFlags, testZ, testFlags ); 2247206917Smarius fflush( stdout ); 2248206917Smarius if ( errorCount == maxErrorCount ) goto exit; 2249206917Smarius } 2250206917Smarius } 2251206917Smarius } 2252206917Smarius exit: 2253206917Smarius writeTestsPerformed( 10000 - count ); 2254206917Smarius return; 2255206917Smarius 2256206917Smarius} 2257206917Smarius 2258206917Smarius#endif 2259206917Smarius 2260206917Smarius#ifdef FLOAT128 2261206917Smarius 2262206917Smariusvoid 2263206917Smarius test_a_float128_z_int32( 2264206917Smarius int32 trueFunction( float128 ), int32 testFunction( float128 ) ) 2265206917Smarius{ 2266206917Smarius int16 count; 2267206917Smarius int32 trueZ, testZ; 2268206917Smarius uint8 trueFlags, testFlags; 2269206917Smarius 2270206917Smarius errorCount = 0; 2271206917Smarius tenthousandsCount = 0; 2272206917Smarius count = 10000; 2273206917Smarius testCases_initSequence( testCases_sequence_a_float128 ); 2274206917Smarius writeTestsTotal(); 2275206917Smarius while ( ! testCases_done || forever ) { 2276206917Smarius testCases_next(); 2277206917Smarius *trueFlagsPtr = 0; 2278206917Smarius trueZ = trueFunction( testCases_a_float128 ); 2279206917Smarius trueFlags = *trueFlagsPtr; 2280206917Smarius (void) testFlagsFunctionPtr(); 2281206917Smarius testZ = testFunction( testCases_a_float128 ); 2282206917Smarius testFlags = testFlagsFunctionPtr(); 2283206917Smarius --count; 2284206917Smarius if ( count == 0 ) { 2285206917Smarius checkEarlyExit(); 2286206917Smarius count = 10000; 2287206917Smarius } 2288206917Smarius if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 2289206917Smarius if ( ! checkNaNs 2290206917Smarius && float128_is_signaling_nan( testCases_a_float128 ) ) { 2291206917Smarius trueFlags |= float_flag_invalid; 2292206917Smarius } 2293206917Smarius if ( ( trueZ == 0x7FFFFFFF ) 2294206917Smarius && ( ( testZ == 0x7FFFFFFF ) 2295206917Smarius || ( testZ == (sbits32) 0x80000000 ) ) 2296206917Smarius && ( trueFlags == float_flag_invalid ) 2297206917Smarius && ( testFlags == float_flag_invalid ) 2298206917Smarius ) { 2299206917Smarius /* no problem */ 2300206917Smarius } 2301206917Smarius else { 2302206917Smarius ++errorCount; 2303206917Smarius writeErrorFound( 10000 - count ); 2304206917Smarius writeInput_a_float128(); 2305206917Smarius fputs( " ", stdout ); 2306206917Smarius writeOutputs_z_int32( trueZ, trueFlags, testZ, testFlags ); 2307206917Smarius fflush( stdout ); 2308206917Smarius if ( errorCount == maxErrorCount ) goto exit; 2309206917Smarius } 2310206917Smarius } 2311206917Smarius } 2312206917Smarius exit: 2313206917Smarius writeTestsPerformed( 10000 - count ); 2314206917Smarius 2315206917Smarius} 2316206917Smarius 2317206917Smarius#ifdef BITS64 2318206917Smarius 2319206917Smariusvoid 2320206917Smarius test_a_float128_z_int64( 2321206917Smarius int64 trueFunction( float128 ), int64 testFunction( float128 ) ) 2322206917Smarius{ 2323206917Smarius int16 count; 2324206917Smarius int64 trueZ, testZ; 2325206917Smarius uint8 trueFlags, testFlags; 2326206917Smarius 2327206917Smarius errorCount = 0; 2328206917Smarius tenthousandsCount = 0; 2329206917Smarius count = 10000; 2330206917Smarius testCases_initSequence( testCases_sequence_a_float128 ); 2331206917Smarius writeTestsTotal(); 2332206917Smarius while ( ! testCases_done || forever ) { 2333206917Smarius testCases_next(); 2334206917Smarius *trueFlagsPtr = 0; 2335206917Smarius trueZ = trueFunction( testCases_a_float128 ); 2336206917Smarius trueFlags = *trueFlagsPtr; 2337206917Smarius (void) testFlagsFunctionPtr(); 2338206917Smarius testZ = testFunction( testCases_a_float128 ); 2339206917Smarius testFlags = testFlagsFunctionPtr(); 2340206917Smarius --count; 2341206917Smarius if ( count == 0 ) { 2342206917Smarius checkEarlyExit(); 2343206917Smarius count = 10000; 2344206917Smarius } 2345206917Smarius if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 2346206917Smarius if ( ! checkNaNs 2347206917Smarius && float128_is_signaling_nan( testCases_a_float128 ) ) { 2348206917Smarius trueFlags |= float_flag_invalid; 2349206917Smarius } 2350206917Smarius if ( ( trueZ == LIT64( 0x7FFFFFFFFFFFFFFF ) ) 2351206917Smarius && ( ( testZ == LIT64( 0x7FFFFFFFFFFFFFFF ) ) 2352206917Smarius || ( testZ == (sbits64) LIT64( 0x8000000000000000 ) ) ) 2353206917Smarius && ( trueFlags == float_flag_invalid ) 2354206917Smarius && ( testFlags == float_flag_invalid ) 2355206917Smarius ) { 2356206917Smarius /* no problem */ 2357206917Smarius } 2358206917Smarius else { 2359206917Smarius ++errorCount; 2360206917Smarius writeErrorFound( 10000 - count ); 2361206917Smarius writeInput_a_float128(); 2362206917Smarius fputs( "\n\t", stdout ); 2363206917Smarius writeOutputs_z_int64( trueZ, trueFlags, testZ, testFlags ); 2364206917Smarius fflush( stdout ); 2365206917Smarius if ( errorCount == maxErrorCount ) goto exit; 2366206917Smarius } 2367206917Smarius } 2368206917Smarius } 2369206917Smarius exit: 2370206917Smarius writeTestsPerformed( 10000 - count ); 2371206917Smarius 2372206917Smarius} 2373206917Smarius 2374206917Smarius#endif 2375206917Smarius 2376206917Smariusvoid 2377206917Smarius test_a_float128_z_float32( 2378206917Smarius float32 trueFunction( float128 ), float32 testFunction( float128 ) ) 2379206917Smarius{ 2380206917Smarius int16 count; 2381206917Smarius float32 trueZ, testZ; 2382206917Smarius uint8 trueFlags, testFlags; 2383206917Smarius 2384206917Smarius errorCount = 0; 2385206917Smarius tenthousandsCount = 0; 2386206917Smarius count = 10000; 2387206917Smarius testCases_initSequence( testCases_sequence_a_float128 ); 2388206917Smarius writeTestsTotal(); 2389206917Smarius while ( ! testCases_done || forever ) { 2390206917Smarius testCases_next(); 2391206917Smarius *trueFlagsPtr = 0; 2392206917Smarius trueZ = trueFunction( testCases_a_float128 ); 2393206917Smarius trueFlags = *trueFlagsPtr; 2394206917Smarius (void) testFlagsFunctionPtr(); 2395206917Smarius testZ = testFunction( testCases_a_float128 ); 2396206917Smarius testFlags = testFlagsFunctionPtr(); 2397206917Smarius --count; 2398206917Smarius if ( count == 0 ) { 2399206917Smarius checkEarlyExit(); 2400206917Smarius count = 10000; 2401206917Smarius } 2402206917Smarius if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 2403206917Smarius if ( ! checkNaNs 2404206917Smarius && float128_is_signaling_nan( testCases_a_float128 ) ) { 2405206917Smarius trueFlags |= float_flag_invalid; 2406206917Smarius } 2407206917Smarius if ( ! checkNaNs 2408206917Smarius && float32_isNaN( trueZ ) 2409206917Smarius && float32_isNaN( testZ ) 2410206917Smarius && ! float32_is_signaling_nan( testZ ) 2411206917Smarius && ( trueFlags == testFlags ) 2412206917Smarius ) { 2413206917Smarius /* no problem */ 2414206917Smarius } 2415206917Smarius else { 2416206917Smarius ++errorCount; 2417206917Smarius writeErrorFound( 10000 - count ); 2418206917Smarius writeInput_a_float128(); 2419206917Smarius fputs( " ", stdout ); 2420206917Smarius writeOutputs_z_float32( trueZ, trueFlags, testZ, testFlags ); 2421206917Smarius fflush( stdout ); 2422206917Smarius if ( errorCount == maxErrorCount ) goto exit; 2423206917Smarius } 2424206917Smarius } 2425206917Smarius } 2426206917Smarius exit: 2427206917Smarius writeTestsPerformed( 10000 - count ); 2428206917Smarius 2429206917Smarius} 2430206917Smarius 2431206917Smariusvoid 2432206917Smarius test_a_float128_z_float64( 2433206917Smarius float64 trueFunction( float128 ), float64 testFunction( float128 ) ) 2434206917Smarius{ 2435206917Smarius int16 count; 2436206917Smarius float64 trueZ, testZ; 2437206917Smarius uint8 trueFlags, testFlags; 2438206917Smarius 2439206917Smarius errorCount = 0; 2440206917Smarius tenthousandsCount = 0; 2441206917Smarius count = 10000; 2442206917Smarius testCases_initSequence( testCases_sequence_a_float128 ); 2443206917Smarius writeTestsTotal(); 2444206917Smarius while ( ! testCases_done || forever ) { 2445206917Smarius testCases_next(); 2446206917Smarius *trueFlagsPtr = 0; 2447206917Smarius trueZ = trueFunction( testCases_a_float128 ); 2448206917Smarius trueFlags = *trueFlagsPtr; 2449206917Smarius (void) testFlagsFunctionPtr(); 2450206917Smarius testZ = testFunction( testCases_a_float128 ); 2451206917Smarius testFlags = testFlagsFunctionPtr(); 2452206917Smarius --count; 2453206917Smarius if ( count == 0 ) { 2454206917Smarius checkEarlyExit(); 2455206917Smarius count = 10000; 2456206917Smarius } 2457206917Smarius if ( ! float64_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 2458206917Smarius if ( ! checkNaNs 2459206917Smarius && float128_is_signaling_nan( testCases_a_float128 ) ) { 2460206917Smarius trueFlags |= float_flag_invalid; 2461206917Smarius } 2462206917Smarius if ( ! checkNaNs 2463206917Smarius && float64_isNaN( trueZ ) 2464206917Smarius && float64_isNaN( testZ ) 2465206917Smarius && ! float64_is_signaling_nan( testZ ) 2466206917Smarius && ( trueFlags == testFlags ) 2467206917Smarius ) { 2468206917Smarius /* no problem */ 2469206917Smarius } 2470206917Smarius else { 2471206917Smarius ++errorCount; 2472206917Smarius writeErrorFound( 10000 - count ); 2473206917Smarius writeInput_a_float128(); 2474206917Smarius fputs( "\n\t", stdout ); 2475206917Smarius writeOutputs_z_float64( trueZ, trueFlags, testZ, testFlags ); 2476206917Smarius fflush( stdout ); 2477206917Smarius if ( errorCount == maxErrorCount ) goto exit; 2478206917Smarius } 2479206917Smarius } 2480206917Smarius } 2481206917Smarius exit: 2482206917Smarius writeTestsPerformed( 10000 - count ); 2483206917Smarius 2484206917Smarius} 2485206917Smarius 2486206917Smarius#ifdef FLOATX80 2487206917Smarius 2488206917Smariusvoid 2489206917Smarius test_a_float128_z_floatx80( 2490206917Smarius floatx80 trueFunction( float128 ), floatx80 testFunction( float128 ) ) 2491206917Smarius{ 2492206917Smarius int16 count; 2493206917Smarius floatx80 trueZ, testZ; 2494206917Smarius uint8 trueFlags, testFlags; 2495206917Smarius 2496206917Smarius errorCount = 0; 2497206917Smarius tenthousandsCount = 0; 2498206917Smarius count = 10000; 2499206917Smarius testCases_initSequence( testCases_sequence_a_float128 ); 2500206917Smarius writeTestsTotal(); 2501206917Smarius while ( ! testCases_done || forever ) { 2502206917Smarius testCases_next(); 2503206917Smarius *trueFlagsPtr = 0; 2504206917Smarius trueZ = trueFunction( testCases_a_float128 ); 2505206917Smarius trueFlags = *trueFlagsPtr; 2506206917Smarius (void) testFlagsFunctionPtr(); 2507206917Smarius testZ = testFunction( testCases_a_float128 ); 2508206917Smarius testFlags = testFlagsFunctionPtr(); 2509206917Smarius --count; 2510206917Smarius if ( count == 0 ) { 2511206917Smarius checkEarlyExit(); 2512206917Smarius count = 10000; 2513206917Smarius } 2514206917Smarius if ( ! floatx80_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 2515206917Smarius if ( ! checkNaNs 2516206917Smarius && float128_is_signaling_nan( testCases_a_float128 ) ) { 2517206917Smarius trueFlags |= float_flag_invalid; 2518206917Smarius } 2519206917Smarius if ( ! checkNaNs 2520206917Smarius && floatx80_isNaN( trueZ ) 2521206917Smarius && floatx80_isNaN( testZ ) 2522206917Smarius && ! floatx80_is_signaling_nan( testZ ) 2523206917Smarius && ( trueFlags == testFlags ) 2524206917Smarius ) { 2525206917Smarius /* no problem */ 2526206917Smarius } 2527206917Smarius else { 2528206917Smarius ++errorCount; 2529206917Smarius writeErrorFound( 10000 - count ); 2530206917Smarius writeInput_a_float128(); 2531206917Smarius fputs( "\n\t", stdout ); 2532206917Smarius writeOutputs_z_floatx80( trueZ, trueFlags, testZ, testFlags ); 2533206917Smarius fflush( stdout ); 2534206917Smarius if ( errorCount == maxErrorCount ) goto exit; 2535206917Smarius } 2536206917Smarius } 2537206917Smarius } 2538206917Smarius exit: 2539206917Smarius writeTestsPerformed( 10000 - count ); 2540206917Smarius 2541206917Smarius} 2542206917Smarius 2543206917Smarius#endif 2544206917Smarius 2545206917Smariusvoid 2546206917Smarius test_az_float128( 2547206917Smarius float128 trueFunction( float128 ), float128 testFunction( float128 ) ) 2548206917Smarius{ 2549206917Smarius int16 count; 2550206917Smarius float128 trueZ, testZ; 2551206917Smarius uint8 trueFlags, testFlags; 2552206917Smarius 2553206917Smarius errorCount = 0; 2554206917Smarius tenthousandsCount = 0; 2555206917Smarius count = 10000; 2556206917Smarius testCases_initSequence( testCases_sequence_a_float128 ); 2557206917Smarius writeTestsTotal(); 2558206917Smarius while ( ! testCases_done || forever ) { 2559206917Smarius testCases_next(); 2560206917Smarius *trueFlagsPtr = 0; 2561206917Smarius trueZ = trueFunction( testCases_a_float128 ); 2562206917Smarius trueFlags = *trueFlagsPtr; 2563206917Smarius (void) testFlagsFunctionPtr(); 2564206917Smarius testZ = testFunction( testCases_a_float128 ); 2565206917Smarius testFlags = testFlagsFunctionPtr(); 2566206917Smarius --count; 2567206917Smarius if ( count == 0 ) { 2568206917Smarius checkEarlyExit(); 2569206917Smarius count = 10000; 2570206917Smarius } 2571206917Smarius if ( ! float128_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 2572206917Smarius if ( ! checkNaNs 2573206917Smarius && float128_is_signaling_nan( testCases_a_float128 ) ) { 2574206917Smarius trueFlags |= float_flag_invalid; 2575206917Smarius } 2576206917Smarius if ( ! checkNaNs 2577206917Smarius && float128_isNaN( trueZ ) 2578206917Smarius && float128_isNaN( testZ ) 2579206917Smarius && ! float128_is_signaling_nan( testZ ) 2580206917Smarius && ( trueFlags == testFlags ) 2581206917Smarius ) { 2582206917Smarius /* no problem */ 2583206917Smarius } 2584206917Smarius else { 2585206917Smarius ++errorCount; 2586206917Smarius writeErrorFound( 10000 - count ); 2587206917Smarius writeInput_a_float128(); 2588206917Smarius fputs( "\n\t", stdout ); 2589206917Smarius writeOutputs_z_float128( trueZ, trueFlags, testZ, testFlags ); 2590206917Smarius fflush( stdout ); 2591206917Smarius if ( errorCount == maxErrorCount ) goto exit; 2592206917Smarius } 2593206917Smarius } 2594206917Smarius } 2595206917Smarius exit: 2596206917Smarius writeTestsPerformed( 10000 - count ); 2597206917Smarius 2598206917Smarius} 2599206917Smarius 2600206917Smariusvoid 2601206917Smarius test_ab_float128_z_flag( 2602206917Smarius flag trueFunction( float128, float128 ), 2603206917Smarius flag testFunction( float128, float128 ) 2604206917Smarius ) 2605206917Smarius{ 2606206917Smarius int16 count; 2607206917Smarius flag trueZ, testZ; 2608206917Smarius uint8 trueFlags, testFlags; 2609206917Smarius 2610206917Smarius errorCount = 0; 2611206917Smarius tenthousandsCount = 0; 2612206917Smarius count = 10000; 2613206917Smarius testCases_initSequence( testCases_sequence_ab_float128 ); 2614206917Smarius writeTestsTotal(); 2615206917Smarius while ( ! testCases_done || forever ) { 2616206917Smarius testCases_next(); 2617206917Smarius *trueFlagsPtr = 0; 2618206917Smarius trueZ = trueFunction( testCases_a_float128, testCases_b_float128 ); 2619206917Smarius trueFlags = *trueFlagsPtr; 2620206917Smarius (void) testFlagsFunctionPtr(); 2621206917Smarius testZ = testFunction( testCases_a_float128, testCases_b_float128 ); 2622206917Smarius testFlags = testFlagsFunctionPtr(); 2623206917Smarius --count; 2624206917Smarius if ( count == 0 ) { 2625206917Smarius checkEarlyExit(); 2626206917Smarius count = 10000; 2627206917Smarius } 2628206917Smarius if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 2629206917Smarius if ( ! checkNaNs 2630206917Smarius && ( float128_is_signaling_nan( testCases_a_float128 ) 2631206917Smarius || float128_is_signaling_nan( testCases_b_float128 ) ) 2632206917Smarius ) { 2633206917Smarius trueFlags |= float_flag_invalid; 2634206917Smarius } 2635206917Smarius if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) { 2636206917Smarius ++errorCount; 2637206917Smarius writeErrorFound( 10000 - count ); 2638206917Smarius writeInputs_ab_float128(); 2639206917Smarius fputs( "\n\t", stdout ); 2640206917Smarius writeOutputs_z_flag( trueZ, trueFlags, testZ, testFlags ); 2641206917Smarius fflush( stdout ); 2642206917Smarius if ( errorCount == maxErrorCount ) goto exit; 2643206917Smarius } 2644206917Smarius } 2645206917Smarius } 2646206917Smarius exit: 2647206917Smarius writeTestsPerformed( 10000 - count ); 2648206917Smarius return; 2649206917Smarius 2650206917Smarius} 2651206917Smarius 2652206917Smariusvoid 2653206917Smarius test_abz_float128( 2654206917Smarius float128 trueFunction( float128, float128 ), 2655206917Smarius float128 testFunction( float128, float128 ) 2656206917Smarius ) 2657206917Smarius{ 2658206917Smarius int16 count; 2659206917Smarius float128 trueZ, testZ; 2660206917Smarius uint8 trueFlags, testFlags; 2661206917Smarius 2662206917Smarius errorCount = 0; 2663206917Smarius tenthousandsCount = 0; 2664206917Smarius count = 10000; 2665206917Smarius testCases_initSequence( testCases_sequence_ab_float128 ); 2666206917Smarius writeTestsTotal(); 2667206917Smarius while ( ! testCases_done || forever ) { 2668206917Smarius testCases_next(); 2669206917Smarius *trueFlagsPtr = 0; 2670206917Smarius trueZ = trueFunction( testCases_a_float128, testCases_b_float128 ); 2671206917Smarius trueFlags = *trueFlagsPtr; 2672206917Smarius (void) testFlagsFunctionPtr(); 2673206917Smarius testZ = testFunction( testCases_a_float128, testCases_b_float128 ); 2674206917Smarius testFlags = testFlagsFunctionPtr(); 2675206917Smarius --count; 2676206917Smarius if ( count == 0 ) { 2677206917Smarius checkEarlyExit(); 2678206917Smarius count = 10000; 2679206917Smarius } 2680206917Smarius if ( ! float128_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) { 2681206917Smarius if ( ! checkNaNs 2682206917Smarius && ( float128_is_signaling_nan( testCases_a_float128 ) 2683206917Smarius || float128_is_signaling_nan( testCases_b_float128 ) ) 2684206917Smarius ) { 2685206917Smarius trueFlags |= float_flag_invalid; 2686206917Smarius } 2687206917Smarius if ( ! checkNaNs 2688206917Smarius && float128_isNaN( trueZ ) 2689206917Smarius && float128_isNaN( testZ ) 2690206917Smarius && ! float128_is_signaling_nan( testZ ) 2691206917Smarius && ( trueFlags == testFlags ) 2692206917Smarius ) { 2693206917Smarius /* no problem */ 2694206917Smarius } 2695206917Smarius else { 2696206917Smarius ++errorCount; 2697206917Smarius writeErrorFound( 10000 - count ); 2698206917Smarius writeInputs_ab_float128(); 2699206917Smarius fputs( "\n\t", stdout ); 2700206917Smarius writeOutputs_z_float128( trueZ, trueFlags, testZ, testFlags ); 2701206917Smarius fflush( stdout ); 2702206917Smarius if ( errorCount == maxErrorCount ) goto exit; 2703206917Smarius } 2704206917Smarius } 2705206917Smarius } 2706206917Smarius exit: 2707206917Smarius writeTestsPerformed( 10000 - count ); 2708206917Smarius return; 2709206917Smarius 2710206917Smarius} 2711206917Smarius 2712206917Smarius#endif 2713206917Smarius 2714