void
test_abcz_f32(
float32_t trueFunction( float32_t, float32_t, float32_t ),
float32_t subjFunction( float32_t, float32_t, float32_t )
)
{
int count;
float32_t trueZ;
uint_fast8_t trueFlags;
float32_t subjZ;
uint_fast8_t subjFlags;
genCases_f32_abc_init();
genCases_writeTestsTotal( testLoops_forever );
verCases_errorCount = 0;
verCases_tenThousandsCount = 0;
count = 10000;
while ( ! genCases_done || testLoops_forever ) {
genCases_f32_abc_next();
*testLoops_trueFlagsPtr = 0;
trueZ = trueFunction( genCases_f32_a, genCases_f32_b, genCases_f32_c );
trueFlags = *testLoops_trueFlagsPtr;
testLoops_subjFlagsFunction();
subjZ = subjFunction( genCases_f32_a, genCases_f32_b, genCases_f32_c );
subjFlags = testLoops_subjFlagsFunction();
--count;
if ( ! count ) {
verCases_perTenThousand();
count = 10000;
}
if ( ! f32_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) {
if (
! verCases_checkNaNs
&& ( f32_isSignalingNaN( genCases_f32_a )
|| f32_isSignalingNaN( genCases_f32_b )
|| f32_isSignalingNaN( genCases_f32_c )
)
) {
trueFlags |= softfloat_flag_invalid;
}
if (
verCases_checkNaNs
|| ! f32_isNaN( trueZ )
|| ! f32_isNaN( subjZ )
|| f32_isSignalingNaN( subjZ )
|| (trueFlags != subjFlags)
) {
++verCases_errorCount;
verCases_writeErrorFound( 10000 - count );
writeCase_abc_f32(
genCases_f32_a, genCases_f32_b, genCases_f32_c, "\n\t" );
writeCase_z_f32( trueZ, trueFlags, subjZ, subjFlags );
if ( verCases_errorCount == verCases_maxErrorCount ) break;
}
}
}
verCases_writeTestsPerformed( 10000 - count );
}
void
test_az_extF80_rx(
void
trueFunction( const extFloat80_t *, uint_fast8_t, bool, extFloat80_t * ),
void
subjFunction( const extFloat80_t *, uint_fast8_t, bool, extFloat80_t * ),
uint_fast8_t roundingMode,
bool exact
)
{
int count;
extFloat80_t trueZ;
uint_fast8_t trueFlags;
extFloat80_t subjZ;
uint_fast8_t subjFlags;
genCases_extF80_a_init();
genCases_writeTestsTotal( testLoops_forever );
verCases_errorCount = 0;
verCases_tenThousandsCount = 0;
count = 10000;
while ( ! genCases_done || testLoops_forever ) {
genCases_extF80_a_next();
*testLoops_trueFlagsPtr = 0;
trueFunction( &genCases_extF80_a, roundingMode, exact, &trueZ );
trueFlags = *testLoops_trueFlagsPtr;
testLoops_subjFlagsFunction();
subjFunction( &genCases_extF80_a, roundingMode, exact, &subjZ );
subjFlags = testLoops_subjFlagsFunction();
--count;
if ( ! count ) {
verCases_perTenThousand();
count = 10000;
}
if ( ! extF80M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) {
if (
! verCases_checkNaNs
&& extF80M_isSignalingNaN( &genCases_extF80_a )
) {
trueFlags |= softfloat_flag_invalid;
}
if (
verCases_checkNaNs
|| ! extF80M_isNaN( &trueZ )
|| ! extF80M_isNaN( &subjZ )
|| extF80M_isSignalingNaN( &subjZ )
|| (trueFlags != subjFlags)
) {
++verCases_errorCount;
verCases_writeErrorFound( 10000 - count );
writeCase_a_extF80M( &genCases_extF80_a, " " );
writeCase_z_extF80M( &trueZ, trueFlags, &subjZ, subjFlags );
if ( verCases_errorCount == verCases_maxErrorCount ) break;
}
}
}
verCases_writeTestsPerformed( 10000 - count );
}
void
test_a_f64_z_i64_rx(
int_fast64_t trueFunction( float64_t, int_fast8_t, bool ),
int_fast64_t testFunction( float64_t, int_fast8_t, bool ),
int_fast8_t roundingMode,
bool exact
)
{
int count;
int_fast64_t trueZ;
int_fast8_t trueFlags;
int_fast64_t testZ;
int_fast8_t testFlags;
genCases_f64_a_init();
genCases_writeTestsTotal( testLoops_forever );
verCases_errorCount = 0;
verCases_tenThousandsCount = 0;
count = 10000;
while ( ! genCases_done || testLoops_forever ) {
genCases_f64_a_next();
*testLoops_trueFlagsPtr = 0;
trueZ = trueFunction( genCases_f64_a, roundingMode, exact );
trueFlags = *testLoops_trueFlagsPtr;
testLoops_testFlagsFunction();
testZ = testFunction( genCases_f64_a, roundingMode, exact );
testFlags = testLoops_testFlagsFunction();
--count;
if ( ! count ) {
verCases_perTenThousand();
count = 10000;
}
if ( ( trueZ != testZ ) || ( trueFlags != testFlags ) ) {
if (
! verCases_checkNaNs && f64_isSignalingNaN( genCases_f64_a )
) {
trueFlags |= softfloat_flag_invalid;
}
if (
( trueZ != INT64_C( 0x7FFFFFFFFFFFFFFF ) )
|| ( ( testZ != INT64_C( 0x7FFFFFFFFFFFFFFF ) )
&& ( testZ != - INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1 ) )
|| ( trueFlags != softfloat_flag_invalid )
|| ( testFlags != softfloat_flag_invalid )
) {
++verCases_errorCount;
verCases_writeErrorFound( 10000 - count );
writeCase_a_f64( genCases_f64_a, " " );
writeCase_z_i64( trueZ, trueFlags, testZ, testFlags );
if ( verCases_errorCount == verCases_maxErrorCount ) break;
}
}
}
verCases_writeTestsPerformed( 10000 - count );
}
void
test_az_f64_rx(
float64_t trueFunction( float64_t, uint_fast8_t, bool ),
float64_t subjFunction( float64_t, uint_fast8_t, bool ),
uint_fast8_t roundingMode,
bool exact
)
{
int count;
float64_t trueZ;
uint_fast8_t trueFlags;
float64_t subjZ;
uint_fast8_t subjFlags;
genCases_f64_a_init();
genCases_writeTestsTotal( testLoops_forever );
verCases_errorCount = 0;
verCases_tenThousandsCount = 0;
count = 10000;
while ( ! genCases_done || testLoops_forever ) {
genCases_f64_a_next();
*testLoops_trueFlagsPtr = 0;
trueZ = trueFunction( genCases_f64_a, roundingMode, exact );
trueFlags = *testLoops_trueFlagsPtr;
testLoops_subjFlagsFunction();
subjZ = subjFunction( genCases_f64_a, roundingMode, exact );
subjFlags = testLoops_subjFlagsFunction();
--count;
if ( ! count ) {
verCases_perTenThousand();
count = 10000;
}
if ( ! f64_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) {
if (
! verCases_checkNaNs && f64_isSignalingNaN( genCases_f64_a )
) {
trueFlags |= softfloat_flag_invalid;
}
if (
verCases_checkNaNs
|| ! f64_isNaN( trueZ )
|| ! f64_isNaN( subjZ )
|| f64_isSignalingNaN( subjZ )
|| (trueFlags != subjFlags)
) {
++verCases_errorCount;
verCases_writeErrorFound( 10000 - count );
writeCase_a_f64( genCases_f64_a, " " );
writeCase_z_f64( trueZ, trueFlags, subjZ, subjFlags );
if ( verCases_errorCount == verCases_maxErrorCount ) break;
}
}
}
verCases_writeTestsPerformed( 10000 - count );
}
void
test_a_f128_z_ui32_rx(
uint_fast32_t trueFunction( const float128_t *, uint_fast8_t, bool ),
uint_fast32_t subjFunction( const float128_t *, uint_fast8_t, bool ),
uint_fast8_t roundingMode,
bool exact
)
{
int count;
uint_fast32_t trueZ;
uint_fast8_t trueFlags;
uint_fast32_t subjZ;
uint_fast8_t subjFlags;
genCases_f128_a_init();
genCases_writeTestsTotal( testLoops_forever );
verCases_errorCount = 0;
verCases_tenThousandsCount = 0;
count = 10000;
while ( ! genCases_done || testLoops_forever ) {
genCases_f128_a_next();
*testLoops_trueFlagsPtr = 0;
trueZ = trueFunction( &genCases_f128_a, roundingMode, exact );
trueFlags = *testLoops_trueFlagsPtr;
testLoops_subjFlagsFunction();
subjZ = subjFunction( &genCases_f128_a, roundingMode, exact );
subjFlags = testLoops_subjFlagsFunction();
--count;
if ( ! count ) {
verCases_perTenThousand();
count = 10000;
}
if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) {
if (
! verCases_checkNaNs
&& f128M_isSignalingNaN( &genCases_f128_a )
) {
trueFlags |= softfloat_flag_invalid;
}
if (
(trueZ != 0xFFFFFFFF)
|| (subjZ != 0xFFFFFFFF)
|| (trueFlags != softfloat_flag_invalid)
|| (subjFlags != softfloat_flag_invalid)
) {
++verCases_errorCount;
verCases_writeErrorFound( 10000 - count );
writeCase_a_f128M( &genCases_f128_a, " " );
writeCase_z_ui32( trueZ, trueFlags, subjZ, subjFlags );
if ( verCases_errorCount == verCases_maxErrorCount ) break;
}
}
}
verCases_writeTestsPerformed( 10000 - count );
}
void
test_a_f16_z_f128(
void trueFunction( float16_t, float128_t * ),
void subjFunction( float16_t, float128_t * )
)
{
int count;
float128_t trueZ;
uint_fast8_t trueFlags;
float128_t subjZ;
uint_fast8_t subjFlags;
genCases_f16_a_init();
genCases_writeTestsTotal( testLoops_forever );
verCases_errorCount = 0;
verCases_tenThousandsCount = 0;
count = 10000;
while ( ! genCases_done || testLoops_forever ) {
genCases_f16_a_next();
*testLoops_trueFlagsPtr = 0;
trueFunction( genCases_f16_a, &trueZ );
trueFlags = *testLoops_trueFlagsPtr;
testLoops_subjFlagsFunction();
subjFunction( genCases_f16_a, &subjZ );
subjFlags = testLoops_subjFlagsFunction();
--count;
if ( ! count ) {
verCases_perTenThousand();
count = 10000;
}
if ( ! f128M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) {
if (
! verCases_checkNaNs && f16_isSignalingNaN( genCases_f16_a )
) {
trueFlags |= softfloat_flag_invalid;
}
if (
verCases_checkNaNs
|| ! f128M_isNaN( &trueZ )
|| ! f128M_isNaN( &subjZ )
|| f128M_isSignalingNaN( &subjZ )
|| (trueFlags != subjFlags)
) {
++verCases_errorCount;
verCases_writeErrorFound( 10000 - count );
writeCase_a_f16( genCases_f16_a, " " );
writeCase_z_f128M( &trueZ, trueFlags, &subjZ, subjFlags );
if ( verCases_errorCount == verCases_maxErrorCount ) break;
}
}
}
verCases_writeTestsPerformed( 10000 - count );
}
void verCases_perTenThousand( void )
{
++verCases_tenThousandsCount;
if ( verCases_stop ) {
verCases_writeTestsPerformed( 0 );
verCases_exitWithStatus();
}
fprintf(
stderr, "\r%3lu0000", (unsigned long) verCases_tenThousandsCount );
}
void
test_a_extF80_z_i32_rx(
int_fast32_t trueFunction( const extFloat80_t *, uint_fast8_t, bool ),
int_fast32_t subjFunction( const extFloat80_t *, uint_fast8_t, bool ),
uint_fast8_t roundingMode,
bool exact
)
{
int count;
int_fast32_t trueZ;
uint_fast8_t trueFlags;
int_fast32_t subjZ;
uint_fast8_t subjFlags;
genCases_extF80_a_init();
genCases_writeTestsTotal( testLoops_forever );
verCases_errorCount = 0;
verCases_tenThousandsCount = 0;
count = 10000;
while ( ! genCases_done || testLoops_forever ) {
genCases_extF80_a_next();
*testLoops_trueFlagsPtr = 0;
trueZ = trueFunction( &genCases_extF80_a, roundingMode, exact );
trueFlags = *testLoops_trueFlagsPtr;
testLoops_subjFlagsFunction();
subjZ = subjFunction( &genCases_extF80_a, roundingMode, exact );
subjFlags = testLoops_subjFlagsFunction();
--count;
if ( ! count ) {
verCases_perTenThousand();
count = 10000;
}
if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) {
if (
verCases_checkInvInts
|| (trueFlags != softfloat_flag_invalid)
|| (subjFlags != softfloat_flag_invalid)
|| ((subjZ != 0x7FFFFFFF) && (subjZ != -0x7FFFFFFF - 1)
&& (! extF80M_isNaN( &genCases_extF80_a )
|| (subjZ != 0)))
) {
++verCases_errorCount;
verCases_writeErrorFound( 10000 - count );
writeCase_a_extF80M( &genCases_extF80_a, " " );
writeCase_z_i32( trueZ, trueFlags, subjZ, subjFlags );
if ( verCases_errorCount == verCases_maxErrorCount ) break;
}
}
}
verCases_writeTestsPerformed( 10000 - count );
}
void
test_a_f32_z_i64_x(
int_fast64_t trueFunction( float32_t, bool ),
int_fast64_t subjFunction( float32_t, bool ),
bool exact
)
{
int count;
int_fast64_t trueZ;
uint_fast8_t trueFlags;
int_fast64_t subjZ;
uint_fast8_t subjFlags;
genCases_f32_a_init();
genCases_writeTestsTotal( testLoops_forever );
verCases_errorCount = 0;
verCases_tenThousandsCount = 0;
count = 10000;
while ( ! genCases_done || testLoops_forever ) {
genCases_f32_a_next();
*testLoops_trueFlagsPtr = 0;
trueZ = trueFunction( genCases_f32_a, exact );
trueFlags = *testLoops_trueFlagsPtr;
testLoops_subjFlagsFunction();
subjZ = subjFunction( genCases_f32_a, exact );
subjFlags = testLoops_subjFlagsFunction();
--count;
if ( ! count ) {
verCases_perTenThousand();
count = 10000;
}
if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) {
if (
verCases_checkInvInts
|| (trueFlags != softfloat_flag_invalid)
|| (subjFlags != softfloat_flag_invalid)
|| ((subjZ != INT64_C( 0x7FFFFFFFFFFFFFFF ))
&& (subjZ != -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
&& (! f32_isNaN( genCases_f32_a ) || (subjZ != 0)))
) {
++verCases_errorCount;
verCases_writeErrorFound( 10000 - count );
writeCase_a_f32( genCases_f32_a, " " );
writeCase_z_i64( trueZ, trueFlags, subjZ, subjFlags );
if ( verCases_errorCount == verCases_maxErrorCount ) break;
}
}
}
verCases_writeTestsPerformed( 10000 - count );
}
void
test_a_i64_z_extF80(
void trueFunction( int64_t, extFloat80_t * ),
void subjFunction( int64_t, extFloat80_t * )
)
{
int count;
extFloat80_t trueZ;
uint_fast8_t trueFlags;
extFloat80_t subjZ;
uint_fast8_t subjFlags;
genCases_i64_a_init();
genCases_writeTestsTotal( testLoops_forever );
verCases_errorCount = 0;
verCases_tenThousandsCount = 0;
count = 10000;
while ( ! genCases_done || testLoops_forever ) {
genCases_i64_a_next();
*testLoops_trueFlagsPtr = 0;
trueFunction( genCases_i64_a, &trueZ );
trueFlags = *testLoops_trueFlagsPtr;
testLoops_subjFlagsFunction();
subjFunction( genCases_i64_a, &subjZ );
subjFlags = testLoops_subjFlagsFunction();
--count;
if ( ! count ) {
verCases_perTenThousand();
count = 10000;
}
if ( ! extF80M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) {
if (
verCases_checkNaNs
|| ! extF80M_isNaN( &trueZ )
|| ! extF80M_isNaN( &subjZ )
|| extF80M_isSignalingNaN( &subjZ )
|| (trueFlags != subjFlags)
) {
++verCases_errorCount;
verCases_writeErrorFound( 10000 - count );
writeCase_a_i64( genCases_i64_a, " " );
writeCase_z_extF80M( &trueZ, trueFlags, &subjZ, subjFlags );
if ( verCases_errorCount == verCases_maxErrorCount ) break;
}
}
}
verCases_writeTestsPerformed( 10000 - count );
}
void
test_a_i32_z_f32(
float32_t trueFunction( int_fast32_t ),
float32_t testFunction( int_fast32_t )
)
{
int count;
float32_t trueZ;
int_fast8_t trueFlags;
float32_t testZ;
int_fast8_t testFlags;
genCases_i32_a_init();
genCases_writeTestsTotal( testLoops_forever );
verCases_errorCount = 0;
verCases_tenThousandsCount = 0;
count = 10000;
while ( ! genCases_done || testLoops_forever ) {
genCases_i32_a_next();
*testLoops_trueFlagsPtr = 0;
trueZ = trueFunction( genCases_i32_a );
trueFlags = *testLoops_trueFlagsPtr;
testLoops_testFlagsFunction();
testZ = testFunction( genCases_i32_a );
testFlags = testLoops_testFlagsFunction();
--count;
if ( ! count ) {
verCases_perTenThousand();
count = 10000;
}
if ( ! f32_same( trueZ, testZ ) || ( trueFlags != testFlags ) ) {
if (
verCases_checkNaNs
|| ! f32_isNaN( trueZ )
|| ! f32_isNaN( testZ )
|| f32_isSignalingNaN( testZ )
|| ( trueFlags != testFlags )
) {
++verCases_errorCount;
verCases_writeErrorFound( 10000 - count );
writeCase_a_i32( genCases_i32_a, " " );
writeCase_z_f32( trueZ, trueFlags, testZ, testFlags );
if ( verCases_errorCount == verCases_maxErrorCount ) break;
}
}
}
verCases_writeTestsPerformed( 10000 - count );
}
void verCases_writeErrorFound( int count )
{
fputc( '\r', stderr );
if ( verCases_errorCount == 1 ) {
fputs( "Errors found in ", stdout );
verCases_writeFunctionName( stdout );
fputs( ":\n", stdout );
}
if ( verCases_stop ) {
verCases_writeTestsPerformed( count );
verCases_exitWithStatus();
}
verCases_anyErrors = true;
}
