/*============================================================================ This C source file is part of TestFloat, Release 3a, a package of programs for testing the correctness of floating-point arithmetic complying with the IEEE Standard for Floating-Point, by John R. Hauser. Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of California. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions, and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of the University nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. =============================================================================*/ #include #include #include #include #include #include #include "platform.h" #include "uint128.h" #include "fail.h" #include "softfloat.h" #include "functions.h" enum { minIterations = 1000 }; static const char *functionNamePtr; static uint_fast8_t roundingPrecision; static int roundingCode; static int tininessCode; static bool usesExact; static bool exact; static void reportTime( int_fast64_t count, clock_t clockTicks ) { static const char *roundingModeNames[NUM_ROUNDINGMODES] = { 0, ", rounding near_even", ", rounding minMag", ", rounding min", ", rounding max", ", rounding near_maxMag" }; printf( "%9.4f Mop/s: %s", count / ((float) clockTicks / CLOCKS_PER_SEC) / 1000000, functionNamePtr ); if ( roundingCode ) { #ifdef EXTFLOAT80 if ( roundingPrecision ) { printf( ", precision %d", (int) roundingPrecision ); } #endif fputs( roundingModeNames[roundingCode], stdout ); if ( tininessCode ) { fputs( (tininessCode == TININESS_BEFORE_ROUNDING) ? ", tininess before rounding" : ", tininess after rounding", stdout ); } } if ( usesExact ) fputs( exact ? ", exact" : ", not exact", stdout ); fputc( '\n', stdout ); fflush( stdout ); } union ui32_f32 { uint32_t ui; float32_t f; }; union ui64_f64 { uint64_t ui; float64_t f; }; enum { numInputs_ui32 = 32 }; static const uint32_t inputs_ui32[numInputs_ui32] = { 0x00004487, 0x405CF80F, 0x00000000, 0x000002FC, 0x000DFFFE, 0x0C8EF795, 0x0FFFEE01, 0x000006CA, 0x00009BFE, 0x00B79D1D, 0x60001002, 0x00000049, 0x0BFF7FFF, 0x0000F37A, 0x0011DFFE, 0x00000006, 0x000FDFFA, 0x0000082F, 0x10200003, 0x2172089B, 0x00003E02, 0x000019E8, 0x0008FFFE, 0x000004A4, 0x00208002, 0x07C42FBF, 0x0FFFE3FF, 0x040B9F13, 0x40000008, 0x0001BF56, 0x000017F6, 0x000A908A }; static void time_a_ui32_z_f32( float32_t function( uint32_t ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( inputs_ui32[inputNum] ); inputNum = (inputNum + 1) & (numInputs_ui32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( inputs_ui32[inputNum] ); inputNum = (inputNum + 1) & (numInputs_ui32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_ui32_z_f64( float64_t function( uint32_t ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( inputs_ui32[inputNum] ); inputNum = (inputNum + 1) & (numInputs_ui32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( inputs_ui32[inputNum] ); inputNum = (inputNum + 1) & (numInputs_ui32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #ifdef EXTFLOAT80 static void time_a_ui32_z_extF80( void function( uint32_t, extFloat80_t * ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; extFloat80_t z; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( inputs_ui32[inputNum], &z ); inputNum = (inputNum + 1) & (numInputs_ui32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( inputs_ui32[inputNum], &z ); inputNum = (inputNum + 1) & (numInputs_ui32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #endif #ifdef FLOAT128 static void time_a_ui32_z_f128( void function( uint32_t, float128_t * ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; float128_t z; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( inputs_ui32[inputNum], &z ); inputNum = (inputNum + 1) & (numInputs_ui32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( inputs_ui32[inputNum], &z ); inputNum = (inputNum + 1) & (numInputs_ui32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #endif enum { numInputs_ui64 = 32 }; static const int64_t inputs_ui64[numInputs_ui64] = { UINT64_C( 0x04003C0000000001 ), UINT64_C( 0x0000000003C589BC ), UINT64_C( 0x00000000400013FE ), UINT64_C( 0x0000000000186171 ), UINT64_C( 0x0000000000010406 ), UINT64_C( 0x000002861920038D ), UINT64_C( 0x0000000010001DFF ), UINT64_C( 0x22E5F0F387AEC8F0 ), UINT64_C( 0x00007C0000010002 ), UINT64_C( 0x00756EBD1AD0C1C7 ), UINT64_C( 0x0003FDFFFFFFFFBE ), UINT64_C( 0x0007D0FB2C2CA951 ), UINT64_C( 0x0007FC0007FFFFFE ), UINT64_C( 0x0000001F942B18BB ), UINT64_C( 0x0000080101FFFFFE ), UINT64_C( 0x000000000000F688 ), UINT64_C( 0x000000000008BFFF ), UINT64_C( 0x0000000006F5AF08 ), UINT64_C( 0x0021008000000002 ), UINT64_C( 0x0000000000000003 ), UINT64_C( 0x3FFFFFFFFF80007D ), UINT64_C( 0x0000000000000078 ), UINT64_C( 0x0007FFFFFF802003 ), UINT64_C( 0x1BBC775B78016AB0 ), UINT64_C( 0x0006FFE000000002 ), UINT64_C( 0x0002B89854671BC1 ), UINT64_C( 0x0000010001FFFFE2 ), UINT64_C( 0x00000000000FB103 ), UINT64_C( 0x07FFFFFFFFFFF7FF ), UINT64_C( 0x00036155C7076FB0 ), UINT64_C( 0x00000020FBFFFFFE ), UINT64_C( 0x0000099AE6455357 ) }; static void time_a_ui64_z_f32( float32_t function( uint64_t ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( inputs_ui64[inputNum] ); inputNum = (inputNum + 1) & (numInputs_ui64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( inputs_ui64[inputNum] ); inputNum = (inputNum + 1) & (numInputs_ui64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_ui64_z_f64( float64_t function( uint64_t ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( inputs_ui64[inputNum] ); inputNum = (inputNum + 1) & (numInputs_ui64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( inputs_ui64[inputNum] ); inputNum = (inputNum + 1) & (numInputs_ui64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #ifdef EXTFLOAT80 static void time_a_ui64_z_extF80( void function( uint64_t, extFloat80_t * ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; extFloat80_t z; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( inputs_ui64[inputNum], &z ); inputNum = (inputNum + 1) & (numInputs_ui64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( inputs_ui64[inputNum], &z ); inputNum = (inputNum + 1) & (numInputs_ui64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #endif #ifdef FLOAT128 static void time_a_ui64_z_f128( void function( uint64_t, float128_t * ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; float128_t z; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( inputs_ui64[inputNum], &z ); inputNum = (inputNum + 1) & (numInputs_ui64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( inputs_ui64[inputNum], &z ); inputNum = (inputNum + 1) & (numInputs_ui64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #endif enum { numInputs_i32 = 32 }; static const int32_t inputs_i32[numInputs_i32] = { -0x00004487, 0x405CF80F, 0x00000000, -0x000002FC, -0x000DFFFE, 0x0C8EF795, -0x0FFFEE01, 0x000006CA, 0x00009BFE, -0x00B79D1D, -0x60001002, -0x00000049, 0x0BFF7FFF, 0x0000F37A, 0x0011DFFE, 0x00000006, -0x000FDFFA, -0x0000082F, 0x10200003, -0x2172089B, 0x00003E02, 0x000019E8, 0x0008FFFE, -0x000004A4, -0x00208002, 0x07C42FBF, 0x0FFFE3FF, 0x040B9F13, -0x40000008, 0x0001BF56, 0x000017F6, 0x000A908A }; static void time_a_i32_z_f32( float32_t function( int32_t ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( inputs_i32[inputNum] ); inputNum = (inputNum + 1) & (numInputs_i32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( inputs_i32[inputNum] ); inputNum = (inputNum + 1) & (numInputs_i32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_i32_z_f64( float64_t function( int32_t ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( inputs_i32[inputNum] ); inputNum = (inputNum + 1) & (numInputs_i32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( inputs_i32[inputNum] ); inputNum = (inputNum + 1) & (numInputs_i32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #ifdef EXTFLOAT80 static void time_a_i32_z_extF80( void function( int32_t, extFloat80_t * ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; extFloat80_t z; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( inputs_i32[inputNum], &z ); inputNum = (inputNum + 1) & (numInputs_i32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( inputs_i32[inputNum], &z ); inputNum = (inputNum + 1) & (numInputs_i32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #endif #ifdef FLOAT128 static void time_a_i32_z_f128( void function( int32_t, float128_t * ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; float128_t z; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( inputs_i32[inputNum], &z ); inputNum = (inputNum + 1) & (numInputs_i32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( inputs_i32[inputNum], &z ); inputNum = (inputNum + 1) & (numInputs_i32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #endif enum { numInputs_i64 = 32 }; static const int64_t inputs_i64[numInputs_i64] = { -INT64_C( 0x04003C0000000001 ), INT64_C( 0x0000000003C589BC ), INT64_C( 0x00000000400013FE ), INT64_C( 0x0000000000186171 ), -INT64_C( 0x0000000000010406 ), -INT64_C( 0x000002861920038D ), INT64_C( 0x0000000010001DFF ), -INT64_C( 0x22E5F0F387AEC8F0 ), -INT64_C( 0x00007C0000010002 ), INT64_C( 0x00756EBD1AD0C1C7 ), INT64_C( 0x0003FDFFFFFFFFBE ), INT64_C( 0x0007D0FB2C2CA951 ), INT64_C( 0x0007FC0007FFFFFE ), INT64_C( 0x0000001F942B18BB ), INT64_C( 0x0000080101FFFFFE ), -INT64_C( 0x000000000000F688 ), INT64_C( 0x000000000008BFFF ), INT64_C( 0x0000000006F5AF08 ), -INT64_C( 0x0021008000000002 ), INT64_C( 0x0000000000000003 ), INT64_C( 0x3FFFFFFFFF80007D ), INT64_C( 0x0000000000000078 ), -INT64_C( 0x0007FFFFFF802003 ), INT64_C( 0x1BBC775B78016AB0 ), -INT64_C( 0x0006FFE000000002 ), -INT64_C( 0x0002B89854671BC1 ), -INT64_C( 0x0000010001FFFFE2 ), -INT64_C( 0x00000000000FB103 ), INT64_C( 0x07FFFFFFFFFFF7FF ), -INT64_C( 0x00036155C7076FB0 ), INT64_C( 0x00000020FBFFFFFE ), INT64_C( 0x0000099AE6455357 ) }; static void time_a_i64_z_f32( float32_t function( int64_t ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( inputs_i64[inputNum] ); inputNum = (inputNum + 1) & (numInputs_i64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( inputs_i64[inputNum] ); inputNum = (inputNum + 1) & (numInputs_i64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_i64_z_f64( float64_t function( int64_t ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( inputs_i64[inputNum] ); inputNum = (inputNum + 1) & (numInputs_i64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( inputs_i64[inputNum] ); inputNum = (inputNum + 1) & (numInputs_i64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #ifdef EXTFLOAT80 static void time_a_i64_z_extF80( void function( int64_t, extFloat80_t * ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; extFloat80_t z; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( inputs_i64[inputNum], &z ); inputNum = (inputNum + 1) & (numInputs_i64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( inputs_i64[inputNum], &z ); inputNum = (inputNum + 1) & (numInputs_i64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #endif #ifdef FLOAT128 static void time_a_i64_z_f128( void function( int64_t, float128_t * ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; float128_t z; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( inputs_i64[inputNum], &z ); inputNum = (inputNum + 1) & (numInputs_i64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( inputs_i64[inputNum], &z ); inputNum = (inputNum + 1) & (numInputs_i64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #endif enum { numInputs_f32 = 32 }; static const uint32_t inputs_F32UI[numInputs_f32] = { 0x4EFA0000, 0xC1D0B328, 0x80000000, 0x3E69A31E, 0xAF803EFF, 0x3F800000, 0x17BF8000, 0xE74A301A, 0x4E010003, 0x7EE3C75D, 0xBD803FE0, 0xBFFEFF00, 0x7981F800, 0x431FFFFC, 0xC100C000, 0x3D87EFFF, 0x4103FEFE, 0xBC000007, 0xBF01F7FF, 0x4E6C6B5C, 0xC187FFFE, 0xC58B9F13, 0x4F88007F, 0xDF004007, 0xB7FFD7FE, 0x7E8001FB, 0x46EFFBFF, 0x31C10000, 0xDB428661, 0x33F89B1F, 0xA3BFEFFF, 0x537BFFBE }; static void time_a_f32_z_ui32_rx( uint_fast32_t function( float32_t, uint_fast8_t, bool ), uint_fast8_t roundingMode, bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui32_f32 uA; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f32_z_ui64_rx( uint_fast64_t function( float32_t, uint_fast8_t, bool ), uint_fast8_t roundingMode, bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui32_f32 uA; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f32_z_i32_rx( int_fast32_t function( float32_t, uint_fast8_t, bool ), uint_fast8_t roundingMode, bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui32_f32 uA; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f32_z_i64_rx( int_fast64_t function( float32_t, uint_fast8_t, bool ), uint_fast8_t roundingMode, bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui32_f32 uA; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f32_z_ui32_x( uint_fast32_t function( float32_t, bool ), bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui32_f32 uA; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f, exact ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f, exact ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f32_z_ui64_x( uint_fast64_t function( float32_t, bool ), bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui32_f32 uA; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f, exact ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f, exact ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f32_z_i32_x( int_fast32_t function( float32_t, bool ), bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui32_f32 uA; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f, exact ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f, exact ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f32_z_i64_x( int_fast64_t function( float32_t, bool ), bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui32_f32 uA; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f, exact ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f, exact ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f32_z_f64( float64_t function( float32_t ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui32_f32 uA; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #ifdef EXTFLOAT80 static void time_a_f32_z_extF80( void function( float32_t, extFloat80_t * ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui32_f32 uA; extFloat80_t z; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f, &z ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f, &z ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #endif #ifdef FLOAT128 static void time_a_f32_z_f128( void function( float32_t, float128_t * ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui32_f32 uA; float128_t z; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f, &z ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f, &z ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #endif static void time_az_f32_rx( float32_t function( float32_t, uint_fast8_t, bool ), uint_fast8_t roundingMode, bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui32_f32 uA; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F32UI[inputNum]; function( uA.f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_abz_f32( float32_t function( float32_t, float32_t ) ) { int_fast64_t count; int inputNumA, inputNumB; clock_t startClock; int_fast64_t i; union ui32_f32 uA, uB; clock_t endClock; count = 0; inputNumA = 0; inputNumB = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F32UI[inputNumA]; uB.ui = inputs_F32UI[inputNumB]; function( uA.f, uB.f ); inputNumA = (inputNumA + 1) & (numInputs_f32 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_f32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNumA = 0; inputNumB = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F32UI[inputNumA]; uB.ui = inputs_F32UI[inputNumB]; function( uA.f, uB.f ); inputNumA = (inputNumA + 1) & (numInputs_f32 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_f32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_abcz_f32( float32_t function( float32_t, float32_t, float32_t ) ) { int_fast64_t count; int inputNumA, inputNumB, inputNumC; clock_t startClock; int_fast64_t i; union ui32_f32 uA, uB, uC; clock_t endClock; count = 0; inputNumA = 0; inputNumB = 0; inputNumC = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F32UI[inputNumA]; uB.ui = inputs_F32UI[inputNumB]; uC.ui = inputs_F32UI[inputNumC]; function( uA.f, uB.f, uC.f ); inputNumA = (inputNumA + 1) & (numInputs_f32 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_f32 - 1); if ( ! inputNumB ) ++inputNumC; inputNumC = (inputNumC + 1) & (numInputs_f32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNumA = 0; inputNumB = 0; inputNumC = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F32UI[inputNumA]; uB.ui = inputs_F32UI[inputNumB]; uC.ui = inputs_F32UI[inputNumC]; function( uA.f, uB.f, uC.f ); inputNumA = (inputNumA + 1) & (numInputs_f32 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_f32 - 1); if ( ! inputNumB ) ++inputNumC; inputNumC = (inputNumC + 1) & (numInputs_f32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_ab_f32_z_bool( bool function( float32_t, float32_t ) ) { int_fast64_t count; int inputNumA, inputNumB; clock_t startClock; int_fast64_t i; union ui32_f32 uA, uB; clock_t endClock; count = 0; inputNumA = 0; inputNumB = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F32UI[inputNumA]; uB.ui = inputs_F32UI[inputNumB]; function( uA.f, uB.f ); inputNumA = (inputNumA + 1) & (numInputs_f32 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_f32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNumA = 0; inputNumB = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F32UI[inputNumA]; uB.ui = inputs_F32UI[inputNumB]; function( uA.f, uB.f ); inputNumA = (inputNumA + 1) & (numInputs_f32 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_f32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static const uint32_t inputs_F32UI_pos[numInputs_f32] = { 0x4EFA0000, 0x41D0B328, 0x00000000, 0x3E69A31E, 0x2F803EFF, 0x3F800000, 0x17BF8000, 0x674A301A, 0x4E010003, 0x7EE3C75D, 0x3D803FE0, 0x3FFEFF00, 0x7981F800, 0x431FFFFC, 0x4100C000, 0x3D87EFFF, 0x4103FEFE, 0x3C000007, 0x3F01F7FF, 0x4E6C6B5C, 0x4187FFFE, 0x458B9F13, 0x4F88007F, 0x5F004007, 0x37FFD7FE, 0x7E8001FB, 0x46EFFBFF, 0x31C10000, 0x5B428661, 0x33F89B1F, 0x23BFEFFF, 0x537BFFBE }; static void time_az_f32_pos( float32_t function( float32_t ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui32_f32 uA; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F32UI_pos[inputNum]; function( uA.f ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F32UI_pos[inputNum]; function( uA.f ); inputNum = (inputNum + 1) & (numInputs_f32 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } enum { numInputs_f64 = 32 }; static const uint64_t inputs_F64UI[numInputs_f64] = { UINT64_C( 0x422FFFC008000000 ), UINT64_C( 0xB7E0000480000000 ), UINT64_C( 0xF3FD2546120B7935 ), UINT64_C( 0x3FF0000000000000 ), UINT64_C( 0xCE07F766F09588D6 ), UINT64_C( 0x8000000000000000 ), UINT64_C( 0x3FCE000400000000 ), UINT64_C( 0x8313B60F0032BED8 ), UINT64_C( 0xC1EFFFFFC0002000 ), UINT64_C( 0x3FB3C75D224F2B0F ), UINT64_C( 0x7FD00000004000FF ), UINT64_C( 0xA12FFF8000001FFF ), UINT64_C( 0x3EE0000000FE0000 ), UINT64_C( 0x0010000080000004 ), UINT64_C( 0x41CFFFFE00000020 ), UINT64_C( 0x40303FFFFFFFFFFD ), UINT64_C( 0x3FD000003FEFFFFF ), UINT64_C( 0xBFD0000010000000 ), UINT64_C( 0xB7FC6B5C16CA55CF ), UINT64_C( 0x413EEB940B9D1301 ), UINT64_C( 0xC7E00200001FFFFF ), UINT64_C( 0x47F00021FFFFFFFE ), UINT64_C( 0xBFFFFFFFF80000FF ), UINT64_C( 0xC07FFFFFE00FFFFF ), UINT64_C( 0x001497A63740C5E8 ), UINT64_C( 0xC4BFFFE0001FFFFF ), UINT64_C( 0x96FFDFFEFFFFFFFF ), UINT64_C( 0x403FC000000001FE ), UINT64_C( 0xFFD00000000001F6 ), UINT64_C( 0x0640400002000000 ), UINT64_C( 0x479CEE1E4F789FE0 ), UINT64_C( 0xC237FFFFFFFFFDFE ) }; static void time_a_f64_z_ui32_rx( uint_fast32_t function( float64_t, uint_fast8_t, bool ), uint_fast8_t roundingMode, bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui64_f64 uA; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f64_z_ui64_rx( uint_fast64_t function( float64_t, uint_fast8_t, bool ), uint_fast8_t roundingMode, bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui64_f64 uA; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f64_z_i32_rx( int_fast32_t function( float64_t, uint_fast8_t, bool ), uint_fast8_t roundingMode, bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui64_f64 uA; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f64_z_i64_rx( int_fast64_t function( float64_t, uint_fast8_t, bool ), uint_fast8_t roundingMode, bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui64_f64 uA; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f64_z_ui32_x( uint_fast32_t function( float64_t, bool ), bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui64_f64 uA; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f, exact ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f, exact ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f64_z_ui64_x( uint_fast64_t function( float64_t, bool ), bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui64_f64 uA; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f, exact ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f, exact ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f64_z_i32_x( int_fast32_t function( float64_t, bool ), bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui64_f64 uA; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f, exact ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f, exact ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f64_z_i64_x( int_fast64_t function( float64_t, bool ), bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui64_f64 uA; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f, exact ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f, exact ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f64_z_f32( float32_t function( float64_t ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui64_f64 uA; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #ifdef EXTFLOAT80 static void time_a_f64_z_extF80( void function( float64_t, extFloat80_t * ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui64_f64 uA; extFloat80_t z; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f, &z ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f, &z ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #endif #ifdef FLOAT128 static void time_a_f64_z_f128( void function( float64_t, float128_t * ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui64_f64 uA; float128_t z; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f, &z ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f, &z ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #endif static void time_az_f64_rx( float64_t function( float64_t, uint_fast8_t, bool ), uint_fast8_t roundingMode, bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui64_f64 uA; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F64UI[inputNum]; function( uA.f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_abz_f64( float64_t function( float64_t, float64_t ) ) { int_fast64_t count; int inputNumA, inputNumB; clock_t startClock; int_fast64_t i; union ui64_f64 uA, uB; clock_t endClock; count = 0; inputNumA = 0; inputNumB = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F64UI[inputNumA]; uB.ui = inputs_F64UI[inputNumB]; function( uA.f, uB.f ); inputNumA = (inputNumA + 1) & (numInputs_f64 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_f64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNumA = 0; inputNumB = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F64UI[inputNumA]; uB.ui = inputs_F64UI[inputNumB]; function( uA.f, uB.f ); inputNumA = (inputNumA + 1) & (numInputs_f64 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_f64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_abcz_f64( float64_t function( float64_t, float64_t, float64_t ) ) { int_fast64_t count; int inputNumA, inputNumB, inputNumC; clock_t startClock; int_fast64_t i; union ui64_f64 uA, uB, uC; clock_t endClock; count = 0; inputNumA = 0; inputNumB = 0; inputNumC = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F64UI[inputNumA]; uB.ui = inputs_F64UI[inputNumB]; uC.ui = inputs_F64UI[inputNumC]; function( uA.f, uB.f, uC.f ); inputNumA = (inputNumA + 1) & (numInputs_f64 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_f64 - 1); if ( ! inputNumB ) ++inputNumC; inputNumC = (inputNumC + 1) & (numInputs_f64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNumA = 0; inputNumB = 0; inputNumC = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F64UI[inputNumA]; uB.ui = inputs_F64UI[inputNumB]; uC.ui = inputs_F64UI[inputNumC]; function( uA.f, uB.f, uC.f ); inputNumA = (inputNumA + 1) & (numInputs_f64 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_f64 - 1); if ( ! inputNumB ) ++inputNumC; inputNumC = (inputNumC + 1) & (numInputs_f64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_ab_f64_z_bool( bool function( float64_t, float64_t ) ) { int_fast64_t count; int inputNumA, inputNumB; clock_t startClock; int_fast64_t i; union ui64_f64 uA, uB; clock_t endClock; count = 0; inputNumA = 0; inputNumB = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F64UI[inputNumA]; uB.ui = inputs_F64UI[inputNumB]; function( uA.f, uB.f ); inputNumA = (inputNumA + 1) & (numInputs_f64 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_f64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNumA = 0; inputNumB = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F64UI[inputNumA]; uB.ui = inputs_F64UI[inputNumB]; function( uA.f, uB.f ); inputNumA = (inputNumA + 1) & (numInputs_f64 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_f64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static const uint64_t inputs_F64UI_pos[numInputs_f64] = { UINT64_C( 0x422FFFC008000000 ), UINT64_C( 0x37E0000480000000 ), UINT64_C( 0x73FD2546120B7935 ), UINT64_C( 0x3FF0000000000000 ), UINT64_C( 0x4E07F766F09588D6 ), UINT64_C( 0x0000000000000000 ), UINT64_C( 0x3FCE000400000000 ), UINT64_C( 0x0313B60F0032BED8 ), UINT64_C( 0x41EFFFFFC0002000 ), UINT64_C( 0x3FB3C75D224F2B0F ), UINT64_C( 0x7FD00000004000FF ), UINT64_C( 0x212FFF8000001FFF ), UINT64_C( 0x3EE0000000FE0000 ), UINT64_C( 0x0010000080000004 ), UINT64_C( 0x41CFFFFE00000020 ), UINT64_C( 0x40303FFFFFFFFFFD ), UINT64_C( 0x3FD000003FEFFFFF ), UINT64_C( 0x3FD0000010000000 ), UINT64_C( 0x37FC6B5C16CA55CF ), UINT64_C( 0x413EEB940B9D1301 ), UINT64_C( 0x47E00200001FFFFF ), UINT64_C( 0x47F00021FFFFFFFE ), UINT64_C( 0x3FFFFFFFF80000FF ), UINT64_C( 0x407FFFFFE00FFFFF ), UINT64_C( 0x001497A63740C5E8 ), UINT64_C( 0x44BFFFE0001FFFFF ), UINT64_C( 0x16FFDFFEFFFFFFFF ), UINT64_C( 0x403FC000000001FE ), UINT64_C( 0x7FD00000000001F6 ), UINT64_C( 0x0640400002000000 ), UINT64_C( 0x479CEE1E4F789FE0 ), UINT64_C( 0x4237FFFFFFFFFDFE ) }; static void time_az_f64_pos( float64_t function( float64_t ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; union ui64_f64 uA; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { uA.ui = inputs_F64UI_pos[inputNum]; function( uA.f ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { uA.ui = inputs_F64UI_pos[inputNum]; function( uA.f ); inputNum = (inputNum + 1) & (numInputs_f64 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #ifdef EXTFLOAT80 #ifdef LITTLEENDIAN #define extF80Const( v64, v0 ) { UINT64_C( v0 ), v64 } #else #define extF80Const( v64, v0 ) { v64, UINT64_C( v0 ) } #endif enum { numInputs_extF80 = 32 }; static const union { struct extFloat80M s; extFloat80_t f; } inputs_extF80[numInputs_extF80] = { extF80Const( 0xC03F, 0xA9BE15A19C1E8B62 ), extF80Const( 0x8000, 0x0000000000000000 ), extF80Const( 0x75A8, 0xE59591E4788957A5 ), extF80Const( 0xBFFF, 0xFFF0000000000040 ), extF80Const( 0x0CD8, 0xFC000000000007FE ), extF80Const( 0x43BA, 0x99A4000000000000 ), extF80Const( 0x3FFF, 0x8000000000000000 ), extF80Const( 0x4081, 0x94FBF1BCEB5545F0 ), extF80Const( 0x403E, 0xFFF0000000002000 ), extF80Const( 0x3FFE, 0xC860E3C75D224F28 ), extF80Const( 0x407E, 0xFC00000FFFFFFFFE ), extF80Const( 0x737A, 0x800000007FFDFFFE ), extF80Const( 0x4044, 0xFFFFFF80000FFFFF ), extF80Const( 0xBBFE, 0x8000040000001FFE ), extF80Const( 0xC002, 0xFF80000000000020 ), extF80Const( 0xDE8D, 0xFFFFFFFFFFE00004 ), extF80Const( 0xC004, 0x8000000000003FFB ), extF80Const( 0x407F, 0x800000000003FFFE ), extF80Const( 0xC000, 0xA459EE6A5C16CA55 ), extF80Const( 0x8003, 0xC42CBF7399AEEB94 ), extF80Const( 0xBF7F, 0xF800000000000006 ), extF80Const( 0xC07F, 0xBF56BE8871F28FEA ), extF80Const( 0xC07E, 0xFFFF77FFFFFFFFFE ), extF80Const( 0xADC9, 0x8000000FFFFFFFDE ), extF80Const( 0xC001, 0xEFF7FFFFFFFFFFFF ), extF80Const( 0x4001, 0xBE84F30125C497A6 ), extF80Const( 0xC06B, 0xEFFFFFFFFFFFFFFF ), extF80Const( 0x4080, 0xFFFFFFFFBFFFFFFF ), extF80Const( 0x87E9, 0x81FFFFFFFFFFFBFF ), extF80Const( 0xA63F, 0x801FFFFFFEFFFFFE ), extF80Const( 0x403C, 0x801FFFFFFFF7FFFF ), extF80Const( 0x4018, 0x8000000000080003 ) }; static void time_a_extF80_z_ui32_rx( uint_fast32_t function( const extFloat80_t *, uint_fast8_t, bool ), uint_fast8_t roundingMode, bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_extF80[inputNum].f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_extF80[inputNum].f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_extF80_z_ui64_rx( uint_fast64_t function( const extFloat80_t *, uint_fast8_t, bool ), uint_fast8_t roundingMode, bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_extF80[inputNum].f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_extF80[inputNum].f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_extF80_z_i32_rx( int_fast32_t function( const extFloat80_t *, uint_fast8_t, bool ), uint_fast8_t roundingMode, bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_extF80[inputNum].f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_extF80[inputNum].f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_extF80_z_i64_rx( int_fast64_t function( const extFloat80_t *, uint_fast8_t, bool ), uint_fast8_t roundingMode, bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_extF80[inputNum].f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_extF80[inputNum].f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_extF80_z_ui32_x( uint_fast32_t function( const extFloat80_t *, bool ), bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_extF80[inputNum].f, exact ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_extF80[inputNum].f, exact ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_extF80_z_ui64_x( uint_fast64_t function( const extFloat80_t *, bool ), bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_extF80[inputNum].f, exact ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_extF80[inputNum].f, exact ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_extF80_z_i32_x( int_fast32_t function( const extFloat80_t *, bool ), bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_extF80[inputNum].f, exact ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_extF80[inputNum].f, exact ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_extF80_z_i64_x( int_fast64_t function( const extFloat80_t *, bool ), bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_extF80[inputNum].f, exact ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_extF80[inputNum].f, exact ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_extF80_z_f32( float32_t function( const extFloat80_t * ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_extF80[inputNum].f ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_extF80[inputNum].f ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_extF80_z_f64( float64_t function( const extFloat80_t * ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_extF80[inputNum].f ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_extF80[inputNum].f ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #ifdef FLOAT128 static void time_a_extF80_z_f128( void function( const extFloat80_t *, float128_t * ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; float128_t z; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_extF80[inputNum].f, &z ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_extF80[inputNum].f, &z ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #endif static void time_az_extF80_rx( void function( const extFloat80_t *, uint_fast8_t, bool, extFloat80_t * ), uint_fast8_t roundingMode, bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; extFloat80_t z; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_extF80[inputNum].f, roundingMode, exact, &z ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_extF80[inputNum].f, roundingMode, exact, &z ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_abz_extF80( void function( const extFloat80_t *, const extFloat80_t *, extFloat80_t * ) ) { int_fast64_t count; int inputNumA, inputNumB; clock_t startClock; int_fast64_t i; extFloat80_t z; clock_t endClock; count = 0; inputNumA = 0; inputNumB = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_extF80[inputNumA].f, &inputs_extF80[inputNumB].f, &z ); inputNumA = (inputNumA + 1) & (numInputs_extF80 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_extF80 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNumA = 0; inputNumB = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_extF80[inputNumA].f, &inputs_extF80[inputNumB].f, &z ); inputNumA = (inputNumA + 1) & (numInputs_extF80 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_extF80 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_abcz_extF80( void function( const extFloat80_t *, const extFloat80_t *, const extFloat80_t *, extFloat80_t * ) ) { int_fast64_t count; int inputNumA, inputNumB, inputNumC; clock_t startClock; int_fast64_t i; extFloat80_t z; clock_t endClock; count = 0; inputNumA = 0; inputNumB = 0; inputNumC = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_extF80[inputNumA].f, &inputs_extF80[inputNumB].f, &inputs_extF80[inputNumC].f, &z ); inputNumA = (inputNumA + 1) & (numInputs_extF80 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_extF80 - 1); if ( ! inputNumB ) ++inputNumC; inputNumC = (inputNumC + 1) & (numInputs_extF80 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNumA = 0; inputNumB = 0; inputNumC = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_extF80[inputNumA].f, &inputs_extF80[inputNumB].f, &inputs_extF80[inputNumC].f, &z ); inputNumA = (inputNumA + 1) & (numInputs_extF80 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_extF80 - 1); if ( ! inputNumB ) ++inputNumC; inputNumC = (inputNumC + 1) & (numInputs_extF80 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_ab_extF80_z_bool( bool function( const extFloat80_t *, const extFloat80_t * ) ) { int_fast64_t count; int inputNumA, inputNumB; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNumA = 0; inputNumB = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_extF80[inputNumA].f, &inputs_extF80[inputNumB].f ); inputNumA = (inputNumA + 1) & (numInputs_extF80 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_extF80 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNumA = 0; inputNumB = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_extF80[inputNumA].f, &inputs_extF80[inputNumB].f ); inputNumA = (inputNumA + 1) & (numInputs_extF80 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_extF80 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static const union { struct extFloat80M s; extFloat80_t f; } inputs_extF80_pos[numInputs_extF80] = { extF80Const( 0x403F, 0xA9BE15A19C1E8B62 ), extF80Const( 0x0000, 0x0000000000000000 ), extF80Const( 0x75A8, 0xE59591E4788957A5 ), extF80Const( 0x3FFF, 0xFFF0000000000040 ), extF80Const( 0x0CD8, 0xFC000000000007FE ), extF80Const( 0x43BA, 0x99A4000000000000 ), extF80Const( 0x3FFF, 0x8000000000000000 ), extF80Const( 0x4081, 0x94FBF1BCEB5545F0 ), extF80Const( 0x403E, 0xFFF0000000002000 ), extF80Const( 0x3FFE, 0xC860E3C75D224F28 ), extF80Const( 0x407E, 0xFC00000FFFFFFFFE ), extF80Const( 0x737A, 0x800000007FFDFFFE ), extF80Const( 0x4044, 0xFFFFFF80000FFFFF ), extF80Const( 0x3BFE, 0x8000040000001FFE ), extF80Const( 0x4002, 0xFF80000000000020 ), extF80Const( 0x5E8D, 0xFFFFFFFFFFE00004 ), extF80Const( 0x4004, 0x8000000000003FFB ), extF80Const( 0x407F, 0x800000000003FFFE ), extF80Const( 0x4000, 0xA459EE6A5C16CA55 ), extF80Const( 0x0003, 0xC42CBF7399AEEB94 ), extF80Const( 0x3F7F, 0xF800000000000006 ), extF80Const( 0x407F, 0xBF56BE8871F28FEA ), extF80Const( 0x407E, 0xFFFF77FFFFFFFFFE ), extF80Const( 0x2DC9, 0x8000000FFFFFFFDE ), extF80Const( 0x4001, 0xEFF7FFFFFFFFFFFF ), extF80Const( 0x4001, 0xBE84F30125C497A6 ), extF80Const( 0x406B, 0xEFFFFFFFFFFFFFFF ), extF80Const( 0x4080, 0xFFFFFFFFBFFFFFFF ), extF80Const( 0x07E9, 0x81FFFFFFFFFFFBFF ), extF80Const( 0x263F, 0x801FFFFFFEFFFFFE ), extF80Const( 0x403C, 0x801FFFFFFFF7FFFF ), extF80Const( 0x4018, 0x8000000000080003 ) }; static void time_az_extF80_pos( void function( const extFloat80_t *, extFloat80_t * ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; extFloat80_t z; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_extF80[inputNum].f, &z ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_extF80[inputNum].f, &z ); inputNum = (inputNum + 1) & (numInputs_extF80 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #endif #ifdef FLOAT128 #ifdef LITTLEENDIAN #define f128Const( v64, v0 ) { UINT64_C( v0 ), UINT64_C( v64 ) } #else #define f128Const( v64, v0 ) { UINT64_C( v64 ), UINT64_C( v0 ) } #endif enum { numInputs_f128 = 32 }; static const union { struct uint128 ui; float128_t f; } inputs_f128[numInputs_f128] = { f128Const( 0x3FDA200000100000, 0x0000000000000000 ), f128Const( 0x3FFF000000000000, 0x0000000000000000 ), f128Const( 0x85F14776190C8306, 0xD8715F4E3D54BB92 ), f128Const( 0xF2B00000007FFFFF, 0xFFFFFFFFFFF7FFFF ), f128Const( 0x8000000000000000, 0x0000000000000000 ), f128Const( 0xBFFFFFFFFFE00000, 0x0000008000000000 ), f128Const( 0x407F1719CE722F3E, 0xDA6B3FE5FF29425B ), f128Const( 0x43FFFF8000000000, 0x0000000000400000 ), f128Const( 0x401E000000000100, 0x0000000000002000 ), f128Const( 0x3FFED71DACDA8E47, 0x4860E3C75D224F28 ), f128Const( 0xBF7ECFC1E90647D1, 0x7A124FE55623EE44 ), f128Const( 0x0DF7007FFFFFFFFF, 0xFFFFFFFFEFFFFFFF ), f128Const( 0x3FE5FFEFFFFFFFFF, 0xFFFFFFFFFFFFEFFF ), f128Const( 0x403FFFFFFFFFFFFF, 0xFFFFFFFFFFFFFBFE ), f128Const( 0xBFFB2FBF7399AFEB, 0xA459EE6A5C16CA55 ), f128Const( 0xBDB8FFFFFFFFFFFC, 0x0000000000000400 ), f128Const( 0x3FC8FFDFFFFFFFFF, 0xFFFFFFFFF0000000 ), f128Const( 0x3FFBFFFFFFDFFFFF, 0xFFF8000000000000 ), f128Const( 0x407043C11737BE84, 0xDDD58212ADC937F4 ), f128Const( 0x8001000000000000, 0x0000001000000001 ), f128Const( 0xC036FFFFFFFFFFFF, 0xFE40000000000000 ), f128Const( 0x4002FFFFFE000002, 0x0000000000000000 ), f128Const( 0x4000C3FEDE897773, 0x326AC4FD8EFBE6DC ), f128Const( 0xBFFF0000000FFFFF, 0xFFFFFE0000000000 ), f128Const( 0x62C3E502146E426D, 0x43F3CAA0DC7DF1A0 ), f128Const( 0xB5CBD32E52BB570E, 0xBCC477CB11C6236C ), f128Const( 0xE228FFFFFFC00000, 0x0000000000000000 ), f128Const( 0x3F80000000000000, 0x0000000080000008 ), f128Const( 0xC1AFFFDFFFFFFFFF, 0xFFFC000000000000 ), f128Const( 0xC96F000000000000, 0x00000001FFFBFFFF ), f128Const( 0x3DE09BFE7923A338, 0xBCC8FBBD7CEC1F4F ), f128Const( 0x401CFFFFFFFFFFFF, 0xFFFFFFFEFFFFFF80 ) }; static void time_a_f128_z_ui32_rx( uint_fast32_t function( const float128_t *, uint_fast8_t, bool ), uint_fast8_t roundingMode, bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_f128[inputNum].f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_f128[inputNum].f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f128_z_ui64_rx( uint_fast64_t function( const float128_t *, uint_fast8_t, bool ), uint_fast8_t roundingMode, bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_f128[inputNum].f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_f128[inputNum].f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f128_z_i32_rx( int_fast32_t function( const float128_t *, uint_fast8_t, bool ), uint_fast8_t roundingMode, bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_f128[inputNum].f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_f128[inputNum].f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f128_z_i64_rx( int_fast64_t function( const float128_t *, uint_fast8_t, bool ), uint_fast8_t roundingMode, bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_f128[inputNum].f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_f128[inputNum].f, roundingMode, exact ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f128_z_ui32_x( uint_fast32_t function( const float128_t *, bool ), bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_f128[inputNum].f, exact ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_f128[inputNum].f, exact ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f128_z_ui64_x( uint_fast64_t function( const float128_t *, bool ), bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_f128[inputNum].f, exact ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_f128[inputNum].f, exact ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f128_z_i32_x( int_fast32_t function( const float128_t *, bool ), bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_f128[inputNum].f, exact ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_f128[inputNum].f, exact ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f128_z_i64_x( int_fast64_t function( const float128_t *, bool ), bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_f128[inputNum].f, exact ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_f128[inputNum].f, exact ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f128_z_f32( float32_t function( const float128_t * ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_f128[inputNum].f ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_f128[inputNum].f ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_a_f128_z_f64( float64_t function( const float128_t * ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_f128[inputNum].f ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_f128[inputNum].f ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #ifdef EXTFLOAT80 static void time_a_f128_z_extF80( void function( const float128_t *, extFloat80_t * ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; extFloat80_t z; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_f128[inputNum].f, &z ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_f128[inputNum].f, &z ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #endif static void time_az_f128_rx( void function( const float128_t *, uint_fast8_t, bool, float128_t * ), uint_fast8_t roundingMode, bool exact ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; float128_t z; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_f128[inputNum].f, roundingMode, exact, &z ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_f128[inputNum].f, roundingMode, exact, &z ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_abz_f128( void function( const float128_t *, const float128_t *, float128_t * ) ) { int_fast64_t count; int inputNumA, inputNumB; clock_t startClock; int_fast64_t i; float128_t z; clock_t endClock; count = 0; inputNumA = 0; inputNumB = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_f128[inputNumA].f, &inputs_f128[inputNumB].f, &z ); inputNumA = (inputNumA + 1) & (numInputs_f128 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_f128 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNumA = 0; inputNumB = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_f128[inputNumA].f, &inputs_f128[inputNumB].f, &z ); inputNumA = (inputNumA + 1) & (numInputs_f128 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_f128 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_abcz_f128( void function( const float128_t *, const float128_t *, const float128_t *, float128_t * ) ) { int_fast64_t count; int inputNumA, inputNumB, inputNumC; clock_t startClock; int_fast64_t i; float128_t z; clock_t endClock; count = 0; inputNumA = 0; inputNumB = 0; inputNumC = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_f128[inputNumA].f, &inputs_f128[inputNumB].f, &inputs_f128[inputNumC].f, &z ); inputNumA = (inputNumA + 1) & (numInputs_f128 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_f128 - 1); if ( ! inputNumB ) ++inputNumC; inputNumC = (inputNumC + 1) & (numInputs_f128 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNumA = 0; inputNumB = 0; inputNumC = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_f128[inputNumA].f, &inputs_f128[inputNumB].f, &inputs_f128[inputNumC].f, &z ); inputNumA = (inputNumA + 1) & (numInputs_f128 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_f128 - 1); if ( ! inputNumB ) ++inputNumC; inputNumC = (inputNumC + 1) & (numInputs_f128 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static void time_ab_f128_z_bool( bool function( const float128_t *, const float128_t * ) ) { int_fast64_t count; int inputNumA, inputNumB; clock_t startClock; int_fast64_t i; clock_t endClock; count = 0; inputNumA = 0; inputNumB = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_f128[inputNumA].f, &inputs_f128[inputNumB].f ); inputNumA = (inputNumA + 1) & (numInputs_f128 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_f128 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNumA = 0; inputNumB = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_f128[inputNumA].f, &inputs_f128[inputNumB].f ); inputNumA = (inputNumA + 1) & (numInputs_f128 - 1); if ( ! inputNumA ) ++inputNumB; inputNumB = (inputNumB + 1) & (numInputs_f128 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } static const union { struct uint128 ui; float128_t f; } inputs_f128_pos[numInputs_f128] = { f128Const( 0x3FDA200000100000, 0x0000000000000000 ), f128Const( 0x3FFF000000000000, 0x0000000000000000 ), f128Const( 0x05F14776190C8306, 0xD8715F4E3D54BB92 ), f128Const( 0x72B00000007FFFFF, 0xFFFFFFFFFFF7FFFF ), f128Const( 0x0000000000000000, 0x0000000000000000 ), f128Const( 0x3FFFFFFFFFE00000, 0x0000008000000000 ), f128Const( 0x407F1719CE722F3E, 0xDA6B3FE5FF29425B ), f128Const( 0x43FFFF8000000000, 0x0000000000400000 ), f128Const( 0x401E000000000100, 0x0000000000002000 ), f128Const( 0x3FFED71DACDA8E47, 0x4860E3C75D224F28 ), f128Const( 0x3F7ECFC1E90647D1, 0x7A124FE55623EE44 ), f128Const( 0x0DF7007FFFFFFFFF, 0xFFFFFFFFEFFFFFFF ), f128Const( 0x3FE5FFEFFFFFFFFF, 0xFFFFFFFFFFFFEFFF ), f128Const( 0x403FFFFFFFFFFFFF, 0xFFFFFFFFFFFFFBFE ), f128Const( 0x3FFB2FBF7399AFEB, 0xA459EE6A5C16CA55 ), f128Const( 0x3DB8FFFFFFFFFFFC, 0x0000000000000400 ), f128Const( 0x3FC8FFDFFFFFFFFF, 0xFFFFFFFFF0000000 ), f128Const( 0x3FFBFFFFFFDFFFFF, 0xFFF8000000000000 ), f128Const( 0x407043C11737BE84, 0xDDD58212ADC937F4 ), f128Const( 0x0001000000000000, 0x0000001000000001 ), f128Const( 0x4036FFFFFFFFFFFF, 0xFE40000000000000 ), f128Const( 0x4002FFFFFE000002, 0x0000000000000000 ), f128Const( 0x4000C3FEDE897773, 0x326AC4FD8EFBE6DC ), f128Const( 0x3FFF0000000FFFFF, 0xFFFFFE0000000000 ), f128Const( 0x62C3E502146E426D, 0x43F3CAA0DC7DF1A0 ), f128Const( 0x35CBD32E52BB570E, 0xBCC477CB11C6236C ), f128Const( 0x6228FFFFFFC00000, 0x0000000000000000 ), f128Const( 0x3F80000000000000, 0x0000000080000008 ), f128Const( 0x41AFFFDFFFFFFFFF, 0xFFFC000000000000 ), f128Const( 0x496F000000000000, 0x00000001FFFBFFFF ), f128Const( 0x3DE09BFE7923A338, 0xBCC8FBBD7CEC1F4F ), f128Const( 0x401CFFFFFFFFFFFF, 0xFFFFFFFEFFFFFF80 ) }; static void time_az_f128_pos( void function( const float128_t *, float128_t * ) ) { int_fast64_t count; int inputNum; clock_t startClock; int_fast64_t i; float128_t z; clock_t endClock; count = 0; inputNum = 0; startClock = clock(); do { for ( i = minIterations; i; --i ) { function( &inputs_f128[inputNum].f, &z ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } count += minIterations; } while ( clock() - startClock < CLOCKS_PER_SEC ); inputNum = 0; startClock = clock(); for ( i = count; i; --i ) { function( &inputs_f128[inputNum].f, &z ); inputNum = (inputNum + 1) & (numInputs_f128 - 1); } endClock = clock(); reportTime( count, endClock - startClock ); } #endif static void timeFunctionInstance( int functionCode, uint_fast8_t roundingMode, bool exact ) { float32_t (*function_abz_f32)( float32_t, float32_t ); bool (*function_ab_f32_z_bool)( float32_t, float32_t ); float64_t (*function_abz_f64)( float64_t, float64_t ); bool (*function_ab_f64_z_bool)( float64_t, float64_t ); #ifdef EXTFLOAT80 void (*function_abz_extF80)( const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); bool (*function_ab_extF80_z_bool)( const extFloat80_t *, const extFloat80_t * ); void #endif #ifdef FLOAT128 (*function_abz_f128)( const float128_t *, const float128_t *, float128_t * ); bool (*function_ab_f128_z_bool)( const float128_t *, const float128_t * ); #endif switch ( functionCode ) { /*-------------------------------------------------------------------- *--------------------------------------------------------------------*/ case UI32_TO_F32: time_a_ui32_z_f32( ui32_to_f32 ); break; case UI32_TO_F64: time_a_ui32_z_f64( ui32_to_f64 ); break; #ifdef EXTFLOAT80 case UI32_TO_EXTF80: time_a_ui32_z_extF80( ui32_to_extF80M ); break; #endif #ifdef FLOAT128 case UI32_TO_F128: time_a_ui32_z_f128( ui32_to_f128M ); break; #endif case UI64_TO_F32: time_a_ui64_z_f32( ui64_to_f32 ); break; case UI64_TO_F64: time_a_ui64_z_f64( ui64_to_f64 ); break; #ifdef EXTFLOAT80 case UI64_TO_EXTF80: time_a_ui64_z_extF80( ui64_to_extF80M ); break; #endif #ifdef FLOAT128 case UI64_TO_F128: time_a_ui64_z_f128( ui64_to_f128M ); break; #endif case I32_TO_F32: time_a_i32_z_f32( i32_to_f32 ); break; case I32_TO_F64: time_a_i32_z_f64( i32_to_f64 ); break; #ifdef EXTFLOAT80 case I32_TO_EXTF80: time_a_i32_z_extF80( i32_to_extF80M ); break; #endif #ifdef FLOAT128 case I32_TO_F128: time_a_i32_z_f128( i32_to_f128M ); break; #endif case I64_TO_F32: time_a_i64_z_f32( i64_to_f32 ); break; case I64_TO_F64: time_a_i64_z_f64( i64_to_f64 ); break; #ifdef EXTFLOAT80 case I64_TO_EXTF80: time_a_i64_z_extF80( i64_to_extF80M ); break; #endif #ifdef FLOAT128 case I64_TO_F128: time_a_i64_z_f128( i64_to_f128M ); break; #endif /*-------------------------------------------------------------------- *--------------------------------------------------------------------*/ case F32_TO_UI32: time_a_f32_z_ui32_rx( f32_to_ui32, roundingMode, exact ); break; case F32_TO_UI64: time_a_f32_z_ui64_rx( f32_to_ui64, roundingMode, exact ); break; case F32_TO_I32: time_a_f32_z_i32_rx( f32_to_i32, roundingMode, exact ); break; case F32_TO_I64: time_a_f32_z_i64_rx( f32_to_i64, roundingMode, exact ); break; case F32_TO_UI32_R_MINMAG: time_a_f32_z_ui32_x( f32_to_ui32_r_minMag, exact ); break; case F32_TO_UI64_R_MINMAG: time_a_f32_z_ui64_x( f32_to_ui64_r_minMag, exact ); break; case F32_TO_I32_R_MINMAG: time_a_f32_z_i32_x( f32_to_i32_r_minMag, exact ); break; case F32_TO_I64_R_MINMAG: time_a_f32_z_i64_x( f32_to_i64_r_minMag, exact ); break; case F32_TO_F64: time_a_f32_z_f64( f32_to_f64 ); break; #ifdef EXTFLOAT80 case F32_TO_EXTF80: time_a_f32_z_extF80( f32_to_extF80M ); break; #endif #ifdef FLOAT128 case F32_TO_F128: time_a_f32_z_f128( f32_to_f128M ); break; #endif case F32_ROUNDTOINT: time_az_f32_rx( f32_roundToInt, roundingMode, exact ); break; case F32_ADD: function_abz_f32 = f32_add; goto time_abz_f32; case F32_SUB: function_abz_f32 = f32_sub; goto time_abz_f32; case F32_MUL: function_abz_f32 = f32_mul; goto time_abz_f32; case F32_DIV: function_abz_f32 = f32_div; goto time_abz_f32; case F32_REM: function_abz_f32 = f32_rem; time_abz_f32: time_abz_f32( function_abz_f32 ); break; case F32_MULADD: time_abcz_f32( f32_mulAdd ); break; case F32_SQRT: time_az_f32_pos( f32_sqrt ); break; case F32_EQ: function_ab_f32_z_bool = f32_eq; goto time_ab_f32_z_bool; case F32_LE: function_ab_f32_z_bool = f32_le; goto time_ab_f32_z_bool; case F32_LT: function_ab_f32_z_bool = f32_lt; goto time_ab_f32_z_bool; case F32_EQ_SIGNALING: function_ab_f32_z_bool = f32_eq_signaling; goto time_ab_f32_z_bool; case F32_LE_QUIET: function_ab_f32_z_bool = f32_le_quiet; goto time_ab_f32_z_bool; case F32_LT_QUIET: function_ab_f32_z_bool = f32_lt_quiet; time_ab_f32_z_bool: time_ab_f32_z_bool( function_ab_f32_z_bool ); break; /*-------------------------------------------------------------------- *--------------------------------------------------------------------*/ case F64_TO_UI32: time_a_f64_z_ui32_rx( f64_to_ui32, roundingMode, exact ); break; case F64_TO_UI64: time_a_f64_z_ui64_rx( f64_to_ui64, roundingMode, exact ); break; case F64_TO_I32: time_a_f64_z_i32_rx( f64_to_i32, roundingMode, exact ); break; case F64_TO_I64: time_a_f64_z_i64_rx( f64_to_i64, roundingMode, exact ); break; case F64_TO_UI32_R_MINMAG: time_a_f64_z_ui32_x( f64_to_ui32_r_minMag, exact ); break; case F64_TO_UI64_R_MINMAG: time_a_f64_z_ui64_x( f64_to_ui64_r_minMag, exact ); break; case F64_TO_I32_R_MINMAG: time_a_f64_z_i32_x( f64_to_i32_r_minMag, exact ); break; case F64_TO_I64_R_MINMAG: time_a_f64_z_i64_x( f64_to_i64_r_minMag, exact ); break; case F64_TO_F32: time_a_f64_z_f32( f64_to_f32 ); break; #ifdef EXTFLOAT80 case F64_TO_EXTF80: time_a_f64_z_extF80( f64_to_extF80M ); break; #endif #ifdef FLOAT128 case F64_TO_F128: time_a_f64_z_f128( f64_to_f128M ); break; #endif case F64_ROUNDTOINT: time_az_f64_rx( f64_roundToInt, roundingMode, exact ); break; case F64_ADD: function_abz_f64 = f64_add; goto time_abz_f64; case F64_SUB: function_abz_f64 = f64_sub; goto time_abz_f64; case F64_MUL: function_abz_f64 = f64_mul; goto time_abz_f64; case F64_DIV: function_abz_f64 = f64_div; goto time_abz_f64; case F64_REM: function_abz_f64 = f64_rem; time_abz_f64: time_abz_f64( function_abz_f64 ); break; case F64_MULADD: time_abcz_f64( f64_mulAdd ); break; case F64_SQRT: time_az_f64_pos( f64_sqrt ); break; case F64_EQ: function_ab_f64_z_bool = f64_eq; goto time_ab_f64_z_bool; case F64_LE: function_ab_f64_z_bool = f64_le; goto time_ab_f64_z_bool; case F64_LT: function_ab_f64_z_bool = f64_lt; goto time_ab_f64_z_bool; case F64_EQ_SIGNALING: function_ab_f64_z_bool = f64_eq_signaling; goto time_ab_f64_z_bool; case F64_LE_QUIET: function_ab_f64_z_bool = f64_le_quiet; goto time_ab_f64_z_bool; case F64_LT_QUIET: function_ab_f64_z_bool = f64_lt_quiet; time_ab_f64_z_bool: time_ab_f64_z_bool( function_ab_f64_z_bool ); break; /*-------------------------------------------------------------------- *--------------------------------------------------------------------*/ #ifdef EXTFLOAT80 case EXTF80_TO_UI32: time_a_extF80_z_ui32_rx( extF80M_to_ui32, roundingMode, exact ); break; case EXTF80_TO_UI64: time_a_extF80_z_ui64_rx( extF80M_to_ui64, roundingMode, exact ); break; case EXTF80_TO_I32: time_a_extF80_z_i32_rx( extF80M_to_i32, roundingMode, exact ); break; case EXTF80_TO_I64: time_a_extF80_z_i64_rx( extF80M_to_i64, roundingMode, exact ); break; case EXTF80_TO_UI32_R_MINMAG: time_a_extF80_z_ui32_x( extF80M_to_ui32_r_minMag, exact ); break; case EXTF80_TO_UI64_R_MINMAG: time_a_extF80_z_ui64_x( extF80M_to_ui64_r_minMag, exact ); break; case EXTF80_TO_I32_R_MINMAG: time_a_extF80_z_i32_x( extF80M_to_i32_r_minMag, exact ); break; case EXTF80_TO_I64_R_MINMAG: time_a_extF80_z_i64_x( extF80M_to_i64_r_minMag, exact ); break; case EXTF80_TO_F32: time_a_extF80_z_f32( extF80M_to_f32 ); break; case EXTF80_TO_F64: time_a_extF80_z_f64( extF80M_to_f64 ); break; #ifdef FLOAT128 case EXTF80_TO_F128: time_a_extF80_z_f128( extF80M_to_f128M ); break; #endif case EXTF80_ROUNDTOINT: time_az_extF80_rx( extF80M_roundToInt, roundingMode, exact ); break; case EXTF80_ADD: function_abz_extF80 = extF80M_add; goto time_abz_extF80; case EXTF80_SUB: function_abz_extF80 = extF80M_sub; goto time_abz_extF80; case EXTF80_MUL: function_abz_extF80 = extF80M_mul; goto time_abz_extF80; case EXTF80_DIV: function_abz_extF80 = extF80M_div; goto time_abz_extF80; case EXTF80_REM: function_abz_extF80 = extF80M_rem; time_abz_extF80: time_abz_extF80( function_abz_extF80 ); break; case EXTF80_SQRT: time_az_extF80_pos( extF80M_sqrt ); break; case EXTF80_EQ: function_ab_extF80_z_bool = extF80M_eq; goto time_ab_extF80_z_bool; case EXTF80_LE: function_ab_extF80_z_bool = extF80M_le; goto time_ab_extF80_z_bool; case EXTF80_LT: function_ab_extF80_z_bool = extF80M_lt; goto time_ab_extF80_z_bool; case EXTF80_EQ_SIGNALING: function_ab_extF80_z_bool = extF80M_eq_signaling; goto time_ab_extF80_z_bool; case EXTF80_LE_QUIET: function_ab_extF80_z_bool = extF80M_le_quiet; goto time_ab_extF80_z_bool; case EXTF80_LT_QUIET: function_ab_extF80_z_bool = extF80M_lt_quiet; time_ab_extF80_z_bool: time_ab_extF80_z_bool( function_ab_extF80_z_bool ); break; #endif /*-------------------------------------------------------------------- *--------------------------------------------------------------------*/ #ifdef FLOAT128 case F128_TO_UI32: time_a_f128_z_ui32_rx( f128M_to_ui32, roundingMode, exact ); break; case F128_TO_UI64: time_a_f128_z_ui64_rx( f128M_to_ui64, roundingMode, exact ); break; case F128_TO_I32: time_a_f128_z_i32_rx( f128M_to_i32, roundingMode, exact ); break; case F128_TO_I64: time_a_f128_z_i64_rx( f128M_to_i64, roundingMode, exact ); break; case F128_TO_UI32_R_MINMAG: time_a_f128_z_ui32_x( f128M_to_ui32_r_minMag, exact ); break; case F128_TO_UI64_R_MINMAG: time_a_f128_z_ui64_x( f128M_to_ui64_r_minMag, exact ); break; case F128_TO_I32_R_MINMAG: time_a_f128_z_i32_x( f128M_to_i32_r_minMag, exact ); break; case F128_TO_I64_R_MINMAG: time_a_f128_z_i64_x( f128M_to_i64_r_minMag, exact ); break; case F128_TO_F32: time_a_f128_z_f32( f128M_to_f32 ); break; case F128_TO_F64: time_a_f128_z_f64( f128M_to_f64 ); break; #ifdef EXTFLOAT80 case F128_TO_EXTF80: time_a_f128_z_extF80( f128M_to_extF80M ); break; #endif case F128_ROUNDTOINT: time_az_f128_rx( f128M_roundToInt, roundingMode, exact ); break; case F128_ADD: function_abz_f128 = f128M_add; goto time_abz_f128; case F128_SUB: function_abz_f128 = f128M_sub; goto time_abz_f128; case F128_MUL: function_abz_f128 = f128M_mul; goto time_abz_f128; case F128_DIV: function_abz_f128 = f128M_div; goto time_abz_f128; case F128_REM: function_abz_f128 = f128M_rem; time_abz_f128: time_abz_f128( function_abz_f128 ); break; case F128_MULADD: time_abcz_f128( f128M_mulAdd ); break; case F128_SQRT: time_az_f128_pos( f128M_sqrt ); break; case F128_EQ: function_ab_f128_z_bool = f128M_eq; goto time_ab_f128_z_bool; case F128_LE: function_ab_f128_z_bool = f128M_le; goto time_ab_f128_z_bool; case F128_LT: function_ab_f128_z_bool = f128M_lt; goto time_ab_f128_z_bool; case F128_EQ_SIGNALING: function_ab_f128_z_bool = f128M_eq_signaling; goto time_ab_f128_z_bool; case F128_LE_QUIET: function_ab_f128_z_bool = f128M_le_quiet; goto time_ab_f128_z_bool; case F128_LT_QUIET: function_ab_f128_z_bool = f128M_lt_quiet; time_ab_f128_z_bool: time_ab_f128_z_bool( function_ab_f128_z_bool ); break; #endif } } enum { EXACT_FALSE = 1, EXACT_TRUE }; static void timeFunction( int functionCode, uint_fast8_t roundingPrecisionIn, int roundingCodeIn, int tininessCodeIn, int exactCodeIn ) { int functionAttribs, exactCode; uint_fast8_t roundingMode, tininessMode; functionNamePtr = functionInfos[functionCode].namePtr; functionAttribs = functionInfos[functionCode].attribs; roundingPrecision = 32; for (;;) { if ( functionAttribs & FUNC_EFF_ROUNDINGPRECISION ) { if ( roundingPrecisionIn ) roundingPrecision = roundingPrecisionIn; } else { roundingPrecision = 0; } #ifdef EXTFLOAT80 if ( roundingPrecision ) extF80_roundingPrecision = roundingPrecision; #endif for ( roundingCode = 1; roundingCode < NUM_ROUNDINGMODES; ++roundingCode ) { if ( functionAttribs & (FUNC_ARG_ROUNDINGMODE | FUNC_EFF_ROUNDINGMODE) ) { if ( roundingCodeIn ) roundingCode = roundingCodeIn; } else { roundingCode = 0; } if ( roundingCode ) { roundingMode = roundingModes[roundingCode]; if ( functionAttribs & FUNC_EFF_ROUNDINGMODE ) { softfloat_roundingMode = roundingMode; } } for ( exactCode = EXACT_FALSE; exactCode <= EXACT_TRUE; ++exactCode ) { if ( functionAttribs & FUNC_ARG_EXACT ) { if ( exactCodeIn ) exactCode = exactCodeIn; } else { exactCode = 0; } exact = (exactCode == EXACT_TRUE ); usesExact = (exactCode != 0 ); for ( tininessCode = 1; tininessCode < NUM_TININESSMODES; ++tininessCode ) { if ( (functionAttribs & FUNC_EFF_TININESSMODE) || ((functionAttribs & FUNC_EFF_TININESSMODE_REDUCEDPREC) && roundingPrecision && (roundingPrecision < 80)) ) { if ( tininessCodeIn ) tininessCode = tininessCodeIn; } else { tininessCode = 0; } if ( tininessCode ) { tininessMode = tininessModes[tininessCode]; softfloat_detectTininess = tininessMode; } timeFunctionInstance( functionCode, roundingMode, exact ); if ( tininessCodeIn || ! tininessCode ) break; } if ( exactCodeIn || ! exactCode ) break; } if ( roundingCodeIn || ! roundingCode ) break; } if ( roundingPrecisionIn || ! roundingPrecision ) break; if ( roundingPrecision == 80 ) { break; } else if ( roundingPrecision == 64 ) { roundingPrecision = 80; } else if ( roundingPrecision == 32 ) { roundingPrecision = 64; } } } int main( int argc, char *argv[] ) { bool haveFunctionArg; int functionCode, numOperands; uint_fast8_t roundingPrecision; int roundingCode, tininessCode, exactCode; const char *argPtr; fail_programName = "timesoftfloat"; if ( argc <= 1 ) goto writeHelpMessage; haveFunctionArg = false; functionCode = 0; numOperands = 0; roundingPrecision = 0; roundingCode = 0; tininessCode = 0; exactCode = 0; for (;;) { --argc; if ( ! argc ) break; argPtr = *++argv; if ( ! argPtr ) break; if ( argPtr[0] == '-' ) ++argPtr; if ( ! strcmp( argPtr, "help" ) || ! strcmp( argPtr, "-help" ) || ! strcmp( argPtr, "h" ) ) { writeHelpMessage: fputs( "timesoftfloat [