Original post-\r-rip include files for TestFloat-2a
This commit is contained in:
ross
parent
3fc4c3244f
commit
5a6cac7136
|
|
@ -0,0 +1,29 @@
|
|||
|
||||
/*
|
||||
===============================================================================
|
||||
|
||||
This C header file is part of TestFloat, Release 2a, a package of programs
|
||||
for testing the correctness of floating-point arithmetic complying to the
|
||||
IEC/IEEE Standard for Floating-Point.
|
||||
|
||||
Written by John R. Hauser. More information is available through the Web
|
||||
page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'.
|
||||
|
||||
THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort
|
||||
has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
|
||||
TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO
|
||||
PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
|
||||
AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
|
||||
|
||||
Derivative works are acceptable, even for commercial purposes, so long as
|
||||
(1) they include prominent notice that the work is derivative, and (2) they
|
||||
include prominent notice akin to these four paragraphs for those parts of
|
||||
this code that are retained.
|
||||
|
||||
===============================================================================
|
||||
*/
|
||||
|
||||
extern char *fail_programName;
|
||||
|
||||
void fail( const char *, ... );
|
||||
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
|
||||
/*
|
||||
===============================================================================
|
||||
|
||||
This C header file is part of TestFloat, Release 2a, a package of programs
|
||||
for testing the correctness of floating-point arithmetic complying to the
|
||||
IEC/IEEE Standard for Floating-Point.
|
||||
|
||||
Written by John R. Hauser. More information is available through the Web
|
||||
page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'.
|
||||
|
||||
THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort
|
||||
has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
|
||||
TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO
|
||||
PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
|
||||
AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
|
||||
|
||||
Derivative works are acceptable, even for commercial purposes, so long as
|
||||
(1) they include prominent notice that the work is derivative, and (2) they
|
||||
include prominent notice akin to these four paragraphs for those parts of
|
||||
this code that are retained.
|
||||
|
||||
===============================================================================
|
||||
*/
|
||||
|
||||
uint8 randomUint8( void );
|
||||
uint16 randomUint16( void );
|
||||
uint32 randomUint32( void );
|
||||
#ifdef BITS64
|
||||
uint64 randomUint64( void );
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
|
||||
/*
|
||||
===============================================================================
|
||||
|
||||
This C header file is part of TestFloat, Release 2a, a package of programs
|
||||
for testing the correctness of floating-point arithmetic complying to the
|
||||
IEC/IEEE Standard for Floating-Point.
|
||||
|
||||
Written by John R. Hauser. More information is available through the Web
|
||||
page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'.
|
||||
|
||||
THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort
|
||||
has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
|
||||
TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO
|
||||
PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
|
||||
AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
|
||||
|
||||
Derivative works are acceptable, even for commercial purposes, so long as
|
||||
(1) they include prominent notice that the work is derivative, and (2) they
|
||||
include prominent notice akin to these four paragraphs for those parts of
|
||||
this code that are retained.
|
||||
|
||||
===============================================================================
|
||||
*/
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Target-specific function for clearing the system's IEC/IEEE floating-point
|
||||
exception flags. The previous value of the flags is returned.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
int8 syst_float_flags_clear( void );
|
||||
|
||||
|
|
@ -0,0 +1,233 @@
|
|||
|
||||
/*
|
||||
===============================================================================
|
||||
|
||||
This C header file is part of TestFloat, Release 2a, a package of programs
|
||||
for testing the correctness of floating-point arithmetic complying to the
|
||||
IEC/IEEE Standard for Floating-Point.
|
||||
|
||||
Written by John R. Hauser. More information is available through the Web
|
||||
page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'.
|
||||
|
||||
THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort
|
||||
has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
|
||||
TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO
|
||||
PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
|
||||
AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
|
||||
|
||||
Derivative works are acceptable, even for commercial purposes, so long as
|
||||
(1) they include prominent notice that the work is derivative, and (2) they
|
||||
include prominent notice akin to these four paragraphs for those parts of
|
||||
this code that are retained.
|
||||
|
||||
===============================================================================
|
||||
*/
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
The following macros are defined to indicate that the corresponding
|
||||
functions exist.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
#define SYST_INT32_TO_FLOAT32
|
||||
#define SYST_INT32_TO_FLOAT64
|
||||
#ifdef BITS64
|
||||
#define SYST_INT64_TO_FLOAT32
|
||||
#define SYST_INT64_TO_FLOAT64
|
||||
#endif
|
||||
#define SYST_FLOAT32_TO_INT32_ROUND_TO_ZERO
|
||||
#ifdef BITS64
|
||||
#define SYST_FLOAT32_TO_INT64_ROUND_TO_ZERO
|
||||
#endif
|
||||
#define SYST_FLOAT32_TO_FLOAT64
|
||||
#define SYST_FLOAT32_ADD
|
||||
#define SYST_FLOAT32_SUB
|
||||
#define SYST_FLOAT32_MUL
|
||||
#define SYST_FLOAT32_DIV
|
||||
#define SYST_FLOAT32_EQ
|
||||
#define SYST_FLOAT32_LE
|
||||
#define SYST_FLOAT32_LT
|
||||
#define SYST_FLOAT64_TO_INT32_ROUND_TO_ZERO
|
||||
#ifdef BITS64
|
||||
#define SYST_FLOAT64_TO_INT64_ROUND_TO_ZERO
|
||||
#endif
|
||||
#define SYST_FLOAT64_TO_FLOAT32
|
||||
#define SYST_FLOAT64_ADD
|
||||
#define SYST_FLOAT64_SUB
|
||||
#define SYST_FLOAT64_MUL
|
||||
#define SYST_FLOAT64_DIV
|
||||
#define SYST_FLOAT64_SQRT
|
||||
#define SYST_FLOAT64_EQ
|
||||
#define SYST_FLOAT64_LE
|
||||
#define SYST_FLOAT64_LT
|
||||
#if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 )
|
||||
#define SYST_INT32_TO_FLOATX80
|
||||
#ifdef BITS64
|
||||
#define SYST_INT64_TO_FLOATX80
|
||||
#endif
|
||||
#define SYST_FLOAT32_TO_FLOATX80
|
||||
#define SYST_FLOAT64_TO_FLOATX80
|
||||
#define SYST_FLOATX80_TO_INT32_ROUND_TO_ZERO
|
||||
#ifdef BITS64
|
||||
#define SYST_FLOATX80_TO_INT64_ROUND_TO_ZERO
|
||||
#endif
|
||||
#define SYST_FLOATX80_TO_FLOAT32
|
||||
#define SYST_FLOATX80_TO_FLOAT64
|
||||
#define SYST_FLOATX80_ADD
|
||||
#define SYST_FLOATX80_SUB
|
||||
#define SYST_FLOATX80_MUL
|
||||
#define SYST_FLOATX80_DIV
|
||||
#define SYST_FLOATX80_EQ
|
||||
#define SYST_FLOATX80_LE
|
||||
#define SYST_FLOATX80_LT
|
||||
#endif
|
||||
#if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 )
|
||||
#define SYST_INT32_TO_FLOAT128
|
||||
#ifdef BITS64
|
||||
#define SYST_INT64_TO_FLOAT128
|
||||
#endif
|
||||
#define SYST_FLOAT32_TO_FLOAT128
|
||||
#define SYST_FLOAT64_TO_FLOAT128
|
||||
#define SYST_FLOAT128_TO_INT32_ROUND_TO_ZERO
|
||||
#ifdef BITS64
|
||||
#define SYST_FLOAT128_TO_INT64_ROUND_TO_ZERO
|
||||
#endif
|
||||
#define SYST_FLOAT128_TO_FLOAT32
|
||||
#define SYST_FLOAT128_TO_FLOAT64
|
||||
#define SYST_FLOAT128_ADD
|
||||
#define SYST_FLOAT128_SUB
|
||||
#define SYST_FLOAT128_MUL
|
||||
#define SYST_FLOAT128_DIV
|
||||
#define SYST_FLOAT128_EQ
|
||||
#define SYST_FLOAT128_LE
|
||||
#define SYST_FLOAT128_LT
|
||||
#endif
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
System function declarations. (Some of these functions may not exist.)
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
float32 syst_int32_to_float32( int32 );
|
||||
float64 syst_int32_to_float64( int32 );
|
||||
#ifdef FLOATX80
|
||||
floatx80 syst_int32_to_floatx80( int32 );
|
||||
#endif
|
||||
#ifdef FLOAT128
|
||||
float128 syst_int32_to_float128( int32 );
|
||||
#endif
|
||||
#ifdef BITS64
|
||||
float32 syst_int64_to_float32( int64 );
|
||||
float64 syst_int64_to_float64( int64 );
|
||||
#ifdef FLOATX80
|
||||
floatx80 syst_int64_to_floatx80( int64 );
|
||||
#endif
|
||||
#ifdef FLOAT128
|
||||
float128 syst_int64_to_float128( int64 );
|
||||
#endif
|
||||
#endif
|
||||
int32 syst_float32_to_int32( float32 );
|
||||
int32 syst_float32_to_int32_round_to_zero( float32 );
|
||||
#ifdef BITS64
|
||||
int64 syst_float32_to_int64( float32 );
|
||||
int64 syst_float32_to_int64_round_to_zero( float32 );
|
||||
#endif
|
||||
float64 syst_float32_to_float64( float32 );
|
||||
#ifdef FLOATX80
|
||||
floatx80 syst_float32_to_floatx80( float32 );
|
||||
#endif
|
||||
#ifdef FLOAT128
|
||||
float128 syst_float32_to_float128( float32 );
|
||||
#endif
|
||||
float32 syst_float32_round_to_int( float32 );
|
||||
float32 syst_float32_add( float32, float32 );
|
||||
float32 syst_float32_sub( float32, float32 );
|
||||
float32 syst_float32_mul( float32, float32 );
|
||||
float32 syst_float32_div( float32, float32 );
|
||||
float32 syst_float32_rem( float32, float32 );
|
||||
float32 syst_float32_sqrt( float32 );
|
||||
flag syst_float32_eq( float32, float32 );
|
||||
flag syst_float32_le( float32, float32 );
|
||||
flag syst_float32_lt( float32, float32 );
|
||||
flag syst_float32_eq_signaling( float32, float32 );
|
||||
flag syst_float32_le_quiet( float32, float32 );
|
||||
flag syst_float32_lt_quiet( float32, float32 );
|
||||
int32 syst_float64_to_int32( float64 );
|
||||
int32 syst_float64_to_int32_round_to_zero( float64 );
|
||||
#ifdef BITS64
|
||||
int64 syst_float64_to_int64( float64 );
|
||||
int64 syst_float64_to_int64_round_to_zero( float64 );
|
||||
#endif
|
||||
float32 syst_float64_to_float32( float64 );
|
||||
#ifdef FLOATX80
|
||||
floatx80 syst_float64_to_floatx80( float64 );
|
||||
#endif
|
||||
#ifdef FLOAT128
|
||||
float128 syst_float64_to_float128( float64 );
|
||||
#endif
|
||||
float64 syst_float64_round_to_int( float64 );
|
||||
float64 syst_float64_add( float64, float64 );
|
||||
float64 syst_float64_sub( float64, float64 );
|
||||
float64 syst_float64_mul( float64, float64 );
|
||||
float64 syst_float64_div( float64, float64 );
|
||||
float64 syst_float64_rem( float64, float64 );
|
||||
float64 syst_float64_sqrt( float64 );
|
||||
flag syst_float64_eq( float64, float64 );
|
||||
flag syst_float64_le( float64, float64 );
|
||||
flag syst_float64_lt( float64, float64 );
|
||||
flag syst_float64_eq_signaling( float64, float64 );
|
||||
flag syst_float64_le_quiet( float64, float64 );
|
||||
flag syst_float64_lt_quiet( float64, float64 );
|
||||
#ifdef FLOATX80
|
||||
int32 syst_floatx80_to_int32( floatx80 );
|
||||
int32 syst_floatx80_to_int32_round_to_zero( floatx80 );
|
||||
#ifdef BITS64
|
||||
int64 syst_floatx80_to_int64( floatx80 );
|
||||
int64 syst_floatx80_to_int64_round_to_zero( floatx80 );
|
||||
#endif
|
||||
float32 syst_floatx80_to_float32( floatx80 );
|
||||
float64 syst_floatx80_to_float64( floatx80 );
|
||||
#ifdef FLOAT128
|
||||
float128 syst_floatx80_to_float128( floatx80 );
|
||||
#endif
|
||||
floatx80 syst_floatx80_round_to_int( floatx80 );
|
||||
floatx80 syst_floatx80_add( floatx80, floatx80 );
|
||||
floatx80 syst_floatx80_sub( floatx80, floatx80 );
|
||||
floatx80 syst_floatx80_mul( floatx80, floatx80 );
|
||||
floatx80 syst_floatx80_div( floatx80, floatx80 );
|
||||
floatx80 syst_floatx80_rem( floatx80, floatx80 );
|
||||
floatx80 syst_floatx80_sqrt( floatx80 );
|
||||
flag syst_floatx80_eq( floatx80, floatx80 );
|
||||
flag syst_floatx80_le( floatx80, floatx80 );
|
||||
flag syst_floatx80_lt( floatx80, floatx80 );
|
||||
flag syst_floatx80_eq_signaling( floatx80, floatx80 );
|
||||
flag syst_floatx80_le_quiet( floatx80, floatx80 );
|
||||
flag syst_floatx80_lt_quiet( floatx80, floatx80 );
|
||||
#endif
|
||||
#ifdef FLOAT128
|
||||
int32 syst_float128_to_int32( float128 );
|
||||
int32 syst_float128_to_int32_round_to_zero( float128 );
|
||||
#ifdef BITS64
|
||||
int64 syst_float128_to_int64( float128 );
|
||||
int64 syst_float128_to_int64_round_to_zero( float128 );
|
||||
#endif
|
||||
float32 syst_float128_to_float32( float128 );
|
||||
float64 syst_float128_to_float64( float128 );
|
||||
#ifdef FLOATX80
|
||||
floatx80 syst_float128_to_floatx80( float128 );
|
||||
#endif
|
||||
float128 syst_float128_round_to_int( float128 );
|
||||
float128 syst_float128_add( float128, float128 );
|
||||
float128 syst_float128_sub( float128, float128 );
|
||||
float128 syst_float128_mul( float128, float128 );
|
||||
float128 syst_float128_div( float128, float128 );
|
||||
float128 syst_float128_rem( float128, float128 );
|
||||
float128 syst_float128_sqrt( float128 );
|
||||
flag syst_float128_eq( float128, float128 );
|
||||
flag syst_float128_le( float128, float128 );
|
||||
flag syst_float128_lt( float128, float128 );
|
||||
flag syst_float128_eq_signaling( float128, float128 );
|
||||
flag syst_float128_le_quiet( float128, float128 );
|
||||
flag syst_float128_lt_quiet( float128, float128 );
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
|
||||
/*
|
||||
===============================================================================
|
||||
|
||||
This C header file is part of TestFloat, Release 2a, a package of programs
|
||||
for testing the correctness of floating-point arithmetic complying to the
|
||||
IEC/IEEE Standard for Floating-Point.
|
||||
|
||||
Written by John R. Hauser. More information is available through the Web
|
||||
page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'.
|
||||
|
||||
THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort
|
||||
has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
|
||||
TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO
|
||||
PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
|
||||
AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
|
||||
|
||||
Derivative works are acceptable, even for commercial purposes, so long as
|
||||
(1) they include prominent notice that the work is derivative, and (2) they
|
||||
include prominent notice akin to these four paragraphs for those parts of
|
||||
this code that are retained.
|
||||
|
||||
===============================================================================
|
||||
*/
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Target-specific function for setting the system's IEC/IEEE floating-point
|
||||
rounding mode. Other system modes are also initialized as necessary (for
|
||||
example, exception trapping may be disabled).
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
void syst_float_set_rounding_mode( int8 );
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
Target-specific function for setting the IEC/IEEE rounding precision of
|
||||
subsequent extended double-precision operations performed by the system.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
void syst_float_set_rounding_precision( int8 );
|
||||
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
|
||||
/*
|
||||
===============================================================================
|
||||
|
||||
This C header file is part of TestFloat, Release 2a, a package of programs
|
||||
for testing the correctness of floating-point arithmetic complying to the
|
||||
IEC/IEEE Standard for Floating-Point.
|
||||
|
||||
Written by John R. Hauser. More information is available through the Web
|
||||
page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'.
|
||||
|
||||
THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort
|
||||
has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
|
||||
TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO
|
||||
PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
|
||||
AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
|
||||
|
||||
Derivative works are acceptable, even for commercial purposes, so long as
|
||||
(1) they include prominent notice that the work is derivative, and (2) they
|
||||
include prominent notice akin to these four paragraphs for those parts of
|
||||
this code that are retained.
|
||||
|
||||
===============================================================================
|
||||
*/
|
||||
|
||||
void testCases_setLevel( int8 );
|
||||
|
||||
void testCases_initSequence( int8 );
|
||||
enum {
|
||||
testCases_sequence_a_int32,
|
||||
#ifdef BITS64
|
||||
testCases_sequence_a_int64,
|
||||
#endif
|
||||
testCases_sequence_a_float32,
|
||||
testCases_sequence_ab_float32,
|
||||
testCases_sequence_a_float64,
|
||||
testCases_sequence_ab_float64,
|
||||
#ifdef FLOATX80
|
||||
testCases_sequence_a_floatx80,
|
||||
testCases_sequence_ab_floatx80,
|
||||
#endif
|
||||
#ifdef FLOAT128
|
||||
testCases_sequence_a_float128,
|
||||
testCases_sequence_ab_float128,
|
||||
#endif
|
||||
};
|
||||
|
||||
extern uint32 testCases_total;
|
||||
extern flag testCases_done;
|
||||
|
||||
void testCases_next( void );
|
||||
|
||||
extern int32 testCases_a_int32;
|
||||
#ifdef BITS64
|
||||
extern int64 testCases_a_int64;
|
||||
#endif
|
||||
extern float32 testCases_a_float32;
|
||||
extern float32 testCases_b_float32;
|
||||
extern float64 testCases_a_float64;
|
||||
extern float64 testCases_b_float64;
|
||||
#ifdef FLOATX80
|
||||
extern floatx80 testCases_a_floatx80;
|
||||
extern floatx80 testCases_b_floatx80;
|
||||
#endif
|
||||
#ifdef FLOAT128
|
||||
extern float128 testCases_a_float128;
|
||||
extern float128 testCases_b_float128;
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,135 @@
|
|||
|
||||
/*
|
||||
===============================================================================
|
||||
|
||||
This C header file is part of TestFloat, Release 2a, a package of programs
|
||||
for testing the correctness of floating-point arithmetic complying to the
|
||||
IEC/IEEE Standard for Floating-Point.
|
||||
|
||||
Written by John R. Hauser. More information is available through the Web
|
||||
page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'.
|
||||
|
||||
THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort
|
||||
has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
|
||||
TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO
|
||||
PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
|
||||
AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
|
||||
|
||||
Derivative works are acceptable, even for commercial purposes, so long as
|
||||
(1) they include prominent notice that the work is derivative, and (2) they
|
||||
include prominent notice akin to these four paragraphs for those parts of
|
||||
this code that are retained.
|
||||
|
||||
===============================================================================
|
||||
*/
|
||||
|
||||
enum {
|
||||
INT32_TO_FLOAT32 = 1,
|
||||
INT32_TO_FLOAT64,
|
||||
INT32_TO_FLOATX80,
|
||||
INT32_TO_FLOAT128,
|
||||
INT64_TO_FLOAT32,
|
||||
INT64_TO_FLOAT64,
|
||||
INT64_TO_FLOATX80,
|
||||
INT64_TO_FLOAT128,
|
||||
FLOAT32_TO_INT32,
|
||||
FLOAT32_TO_INT32_ROUND_TO_ZERO,
|
||||
FLOAT32_TO_INT64,
|
||||
FLOAT32_TO_INT64_ROUND_TO_ZERO,
|
||||
FLOAT32_TO_FLOAT64,
|
||||
FLOAT32_TO_FLOATX80,
|
||||
FLOAT32_TO_FLOAT128,
|
||||
FLOAT32_ROUND_TO_INT,
|
||||
FLOAT32_ADD,
|
||||
FLOAT32_SUB,
|
||||
FLOAT32_MUL,
|
||||
FLOAT32_DIV,
|
||||
FLOAT32_REM,
|
||||
FLOAT32_SQRT,
|
||||
FLOAT32_EQ,
|
||||
FLOAT32_LE,
|
||||
FLOAT32_LT,
|
||||
FLOAT32_EQ_SIGNALING,
|
||||
FLOAT32_LE_QUIET,
|
||||
FLOAT32_LT_QUIET,
|
||||
FLOAT64_TO_INT32,
|
||||
FLOAT64_TO_INT32_ROUND_TO_ZERO,
|
||||
FLOAT64_TO_INT64,
|
||||
FLOAT64_TO_INT64_ROUND_TO_ZERO,
|
||||
FLOAT64_TO_FLOAT32,
|
||||
FLOAT64_TO_FLOATX80,
|
||||
FLOAT64_TO_FLOAT128,
|
||||
FLOAT64_ROUND_TO_INT,
|
||||
FLOAT64_ADD,
|
||||
FLOAT64_SUB,
|
||||
FLOAT64_MUL,
|
||||
FLOAT64_DIV,
|
||||
FLOAT64_REM,
|
||||
FLOAT64_SQRT,
|
||||
FLOAT64_EQ,
|
||||
FLOAT64_LE,
|
||||
FLOAT64_LT,
|
||||
FLOAT64_EQ_SIGNALING,
|
||||
FLOAT64_LE_QUIET,
|
||||
FLOAT64_LT_QUIET,
|
||||
FLOATX80_TO_INT32,
|
||||
FLOATX80_TO_INT32_ROUND_TO_ZERO,
|
||||
FLOATX80_TO_INT64,
|
||||
FLOATX80_TO_INT64_ROUND_TO_ZERO,
|
||||
FLOATX80_TO_FLOAT32,
|
||||
FLOATX80_TO_FLOAT64,
|
||||
FLOATX80_TO_FLOAT128,
|
||||
FLOATX80_ROUND_TO_INT,
|
||||
FLOATX80_ADD,
|
||||
FLOATX80_SUB,
|
||||
FLOATX80_MUL,
|
||||
FLOATX80_DIV,
|
||||
FLOATX80_REM,
|
||||
FLOATX80_SQRT,
|
||||
FLOATX80_EQ,
|
||||
FLOATX80_LE,
|
||||
FLOATX80_LT,
|
||||
FLOATX80_EQ_SIGNALING,
|
||||
FLOATX80_LE_QUIET,
|
||||
FLOATX80_LT_QUIET,
|
||||
FLOAT128_TO_INT32,
|
||||
FLOAT128_TO_INT32_ROUND_TO_ZERO,
|
||||
FLOAT128_TO_INT64,
|
||||
FLOAT128_TO_INT64_ROUND_TO_ZERO,
|
||||
FLOAT128_TO_FLOAT32,
|
||||
FLOAT128_TO_FLOAT64,
|
||||
FLOAT128_TO_FLOATX80,
|
||||
FLOAT128_ROUND_TO_INT,
|
||||
FLOAT128_ADD,
|
||||
FLOAT128_SUB,
|
||||
FLOAT128_MUL,
|
||||
FLOAT128_DIV,
|
||||
FLOAT128_REM,
|
||||
FLOAT128_SQRT,
|
||||
FLOAT128_EQ,
|
||||
FLOAT128_LE,
|
||||
FLOAT128_LT,
|
||||
FLOAT128_EQ_SIGNALING,
|
||||
FLOAT128_LE_QUIET,
|
||||
FLOAT128_LT_QUIET,
|
||||
NUM_FUNCTIONS
|
||||
};
|
||||
|
||||
typedef struct {
|
||||
char *name;
|
||||
int8 numInputs;
|
||||
flag roundingPrecision, roundingMode;
|
||||
} functionT;
|
||||
extern const functionT functions[ NUM_FUNCTIONS ];
|
||||
extern const flag functionExists[ NUM_FUNCTIONS ];
|
||||
|
||||
enum {
|
||||
ROUND_NEAREST_EVEN = 1,
|
||||
ROUND_TO_ZERO,
|
||||
ROUND_DOWN,
|
||||
ROUND_UP,
|
||||
NUM_ROUNDINGMODES
|
||||
};
|
||||
|
||||
void testFunction( uint8, int8, int8 );
|
||||
|
||||
|
|
@ -0,0 +1,143 @@
|
|||
|
||||
/*
|
||||
===============================================================================
|
||||
|
||||
This C header file is part of TestFloat, Release 2a, a package of programs
|
||||
for testing the correctness of floating-point arithmetic complying to the
|
||||
IEC/IEEE Standard for Floating-Point.
|
||||
|
||||
Written by John R. Hauser. More information is available through the Web
|
||||
page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'.
|
||||
|
||||
THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort
|
||||
has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
|
||||
TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO
|
||||
PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
|
||||
AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
|
||||
|
||||
Derivative works are acceptable, even for commercial purposes, so long as
|
||||
(1) they include prominent notice that the work is derivative, and (2) they
|
||||
include prominent notice akin to these four paragraphs for those parts of
|
||||
this code that are retained.
|
||||
|
||||
===============================================================================
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
extern volatile flag stop;
|
||||
|
||||
extern char *trueName, *testName;
|
||||
extern flag forever, errorStop;
|
||||
extern uint32 maxErrorCount;
|
||||
extern flag checkNaNs;
|
||||
extern int8 *trueFlagsPtr;
|
||||
extern int8 ( *testFlagsFunctionPtr )( void );
|
||||
extern char *functionName;
|
||||
extern char *roundingPrecisionName, *roundingModeName, *tininessModeName;
|
||||
extern flag anyErrors;
|
||||
|
||||
void writeFunctionName( FILE * );
|
||||
void exitWithStatus( void );
|
||||
|
||||
void test_a_int32_z_float32( float32 ( int32 ), float32 ( int32 ) );
|
||||
void test_a_int32_z_float64( float64 ( int32 ), float64 ( int32 ) );
|
||||
#ifdef FLOATX80
|
||||
void test_a_int32_z_floatx80( floatx80 ( int32 ), floatx80 ( int32 ) );
|
||||
#endif
|
||||
#ifdef FLOAT128
|
||||
void test_a_int32_z_float128( float128 ( int32 ), float128 ( int32 ) );
|
||||
#endif
|
||||
#ifdef BITS64
|
||||
void test_a_int64_z_float32( float32 ( int64 ), float32 ( int64 ) );
|
||||
void test_a_int64_z_float64( float64 ( int64 ), float64 ( int64 ) );
|
||||
#ifdef FLOATX80
|
||||
void test_a_int64_z_floatx80( floatx80 ( int64 ), floatx80 ( int64 ) );
|
||||
#endif
|
||||
#ifdef FLOAT128
|
||||
void test_a_int64_z_float128( float128 ( int64 ), float128 ( int64 ) );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
void test_a_float32_z_int32( int32 ( float32 ), int32 ( float32 ) );
|
||||
#ifdef BITS64
|
||||
void test_a_float32_z_int64( int64 ( float32 ), int64 ( float32 ) );
|
||||
#endif
|
||||
void test_a_float32_z_float64( float64 ( float32 ), float64 ( float32 ) );
|
||||
#ifdef FLOATX80
|
||||
void test_a_float32_z_floatx80( floatx80 ( float32 ), floatx80 ( float32 ) );
|
||||
#endif
|
||||
#ifdef FLOAT128
|
||||
void test_a_float32_z_float128( float128 ( float32 ), float128 ( float32 ) );
|
||||
#endif
|
||||
void test_az_float32( float32 ( float32 ), float32 ( float32 ) );
|
||||
void
|
||||
test_ab_float32_z_flag(
|
||||
flag ( float32, float32 ), flag ( float32, float32 ) );
|
||||
void
|
||||
test_abz_float32(
|
||||
float32 ( float32, float32 ), float32 ( float32, float32 ) );
|
||||
|
||||
void test_a_float64_z_int32( int32 ( float64 ), int32 ( float64 ) );
|
||||
#ifdef BITS64
|
||||
void test_a_float64_z_int64( int64 ( float64 ), int64 ( float64 ) );
|
||||
#endif
|
||||
void test_a_float64_z_float32( float32 ( float64 ), float32 ( float64 ) );
|
||||
#ifdef FLOATX80
|
||||
void test_a_float64_z_floatx80( floatx80 ( float64 ), floatx80 ( float64 ) );
|
||||
#endif
|
||||
#ifdef FLOAT128
|
||||
void test_a_float64_z_float128( float128 ( float64 ), float128 ( float64 ) );
|
||||
#endif
|
||||
void test_az_float64( float64 ( float64 ), float64 ( float64 ) );
|
||||
void
|
||||
test_ab_float64_z_flag(
|
||||
flag ( float64, float64 ), flag ( float64, float64 ) );
|
||||
void
|
||||
test_abz_float64(
|
||||
float64 ( float64, float64 ), float64 ( float64, float64 ) );
|
||||
|
||||
#ifdef FLOATX80
|
||||
|
||||
void test_a_floatx80_z_int32( int32 ( floatx80 ), int32 ( floatx80 ) );
|
||||
#ifdef BITS64
|
||||
void test_a_floatx80_z_int64( int64 ( floatx80 ), int64 ( floatx80 ) );
|
||||
#endif
|
||||
void test_a_floatx80_z_float32( float32 ( floatx80 ), float32 ( floatx80 ) );
|
||||
void test_a_floatx80_z_float64( float64 ( floatx80 ), float64 ( floatx80 ) );
|
||||
#ifdef FLOAT128
|
||||
void
|
||||
test_a_floatx80_z_float128( float128 ( floatx80 ), float128 ( floatx80 ) );
|
||||
#endif
|
||||
void test_az_floatx80( floatx80 ( floatx80 ), floatx80 ( floatx80 ) );
|
||||
void
|
||||
test_ab_floatx80_z_flag(
|
||||
flag ( floatx80, floatx80 ), flag ( floatx80, floatx80 ) );
|
||||
void
|
||||
test_abz_floatx80(
|
||||
floatx80 ( floatx80, floatx80 ), floatx80 ( floatx80, floatx80 ) );
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef FLOAT128
|
||||
|
||||
void test_a_float128_z_int32( int32 ( float128 ), int32 ( float128 ) );
|
||||
#ifdef BITS64
|
||||
void test_a_float128_z_int64( int64 ( float128 ), int64 ( float128 ) );
|
||||
#endif
|
||||
void test_a_float128_z_float32( float32 ( float128 ), float32 ( float128 ) );
|
||||
void test_a_float128_z_float64( float64 ( float128 ), float64 ( float128 ) );
|
||||
#ifdef FLOATX80
|
||||
void
|
||||
test_a_float128_z_floatx80( floatx80 ( float128 ), floatx80 ( float128 ) );
|
||||
#endif
|
||||
void test_az_float128( float128 ( float128 ), float128 ( float128 ) );
|
||||
void
|
||||
test_ab_float128_z_flag(
|
||||
flag ( float128, float128 ), flag ( float128, float128 ) );
|
||||
void
|
||||
test_abz_float128(
|
||||
float128 ( float128, float128 ), float128 ( float128, float128 ) );
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
|
||||
/*
|
||||
===============================================================================
|
||||
|
||||
This C header file is part of TestFloat, Release 2a, a package of programs
|
||||
for testing the correctness of floating-point arithmetic complying to the
|
||||
IEC/IEEE Standard for Floating-Point.
|
||||
|
||||
Written by John R. Hauser. More information is available through the Web
|
||||
page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'.
|
||||
|
||||
THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort
|
||||
has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
|
||||
TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO
|
||||
PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
|
||||
AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
|
||||
|
||||
Derivative works are acceptable, even for commercial purposes, so long as
|
||||
(1) they include prominent notice that the work is derivative, and (2) they
|
||||
include prominent notice akin to these four paragraphs for those parts of
|
||||
this code that are retained.
|
||||
|
||||
===============================================================================
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
void writeHex_flag( flag, FILE * );
|
||||
void writeHex_bits32( bits32, FILE * );
|
||||
#ifdef BITS64
|
||||
void writeHex_bits64( bits64, FILE * );
|
||||
#endif
|
||||
void writeHex_float32( float32, FILE * );
|
||||
void writeHex_float64( float64, FILE * );
|
||||
#ifdef FLOATX80
|
||||
void writeHex_floatx80( floatx80, FILE * );
|
||||
#endif
|
||||
#ifdef FLOAT128
|
||||
void writeHex_float128( float128, FILE * );
|
||||
#endif
|
||||
void writeHex_float_flags( uint8, FILE * );
|
||||
|
||||
Loading…
Reference in New Issue