3 ===============================================================================
5 This C source file is part of TestFloat, Release 2a, a package of programs
6 for testing the correctness of floating-point arithmetic complying to the
7 IEC/IEEE Standard for Floating-Point.
9 Written by John R. Hauser. More information is available through the Web
10 page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'.
12 THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort
13 has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
14 TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO
15 PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
16 AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
18 Derivative works are acceptable, even for commercial purposes, so long as
19 (1) they include prominent notice that the work is derivative, and (2) they
20 include prominent notice akin to these four paragraphs for those parts of
21 this code that are retained.
23 ===============================================================================
28 #include "softfloat.h"
29 #include "systfloat.h"
31 float32 syst_int32_to_float32( int32 a )
35 *( (float *) &z ) = a;
40 float64 syst_int32_to_float64( int32 a )
44 *( (double *) &z ) = a;
49 #if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 )
51 floatx80 syst_int32_to_floatx80( int32 a )
55 *( (long double *) &z ) = a;
62 #if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 )
64 float128 syst_int32_to_float128( int32 a )
68 *( (long double *) &z ) = a;
77 float32 syst_int64_to_float32( int64 a )
81 *( (float *) &z ) = a;
86 float64 syst_int64_to_float64( int64 a )
90 *( (double *) &z ) = a;
95 #if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 )
97 floatx80 syst_int64_to_floatx80( int64 a )
101 *( (long double *) &z ) = a;
108 #if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 )
110 float128 syst_int64_to_float128( int64 a )
114 *( (long double *) &z ) = a;
123 int32 syst_float32_to_int32_round_to_zero( float32 a )
126 return *( (float *) &a );
132 int64 syst_float32_to_int64_round_to_zero( float32 a )
135 return *( (float *) &a );
141 float64 syst_float32_to_float64( float32 a )
145 *( (double *) &z ) = *( (float *) &a );
150 #if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 )
152 floatx80 syst_float32_to_floatx80( float32 a )
156 *( (long double *) &z ) = *( (float *) &a );
163 #if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 )
165 float128 syst_float32_to_float128( float32 a )
169 *( (long double *) &z ) = *( (float *) &a );
176 float32 syst_float32_add( float32 a, float32 b )
180 *( (float *) &z ) = *( (float *) &a ) + *( (float *) &b );
185 float32 syst_float32_sub( float32 a, float32 b )
189 *( (float *) &z ) = *( (float *) &a ) - *( (float *) &b );
194 float32 syst_float32_mul( float32 a, float32 b )
198 *( (float *) &z ) = *( (float *) &a ) * *( (float *) &b );
203 float32 syst_float32_div( float32 a, float32 b )
207 *( (float *) &z ) = *( (float *) &a ) / *( (float *) &b );
212 flag syst_float32_eq( float32 a, float32 b )
215 return ( *( (float *) &a ) == *( (float *) &b ) );
219 flag syst_float32_le( float32 a, float32 b )
222 return ( *( (float *) &a ) <= *( (float *) &b ) );
226 flag syst_float32_lt( float32 a, float32 b )
229 return ( *( (float *) &a ) < *( (float *) &b ) );
233 int32 syst_float64_to_int32_round_to_zero( float64 a )
236 return *( (double *) &a );
242 int64 syst_float64_to_int64_round_to_zero( float64 a )
245 return *( (double *) &a );
251 float32 syst_float64_to_float32( float64 a )
255 *( (float *) &z ) = *( (double *) &a );
260 #if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 )
262 floatx80 syst_float64_to_floatx80( float64 a )
266 *( (long double *) &z ) = *( (double *) &a );
273 #if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 )
275 float128 syst_float64_to_float128( float64 a )
279 *( (long double *) &z ) = *( (double *) &a );
286 float64 syst_float64_add( float64 a, float64 b )
290 *( (double *) &z ) = *( (double *) &a ) + *( (double *) &b );
295 float64 syst_float64_sub( float64 a, float64 b )
299 *( (double *) &z ) = *( (double *) &a ) - *( (double *) &b );
304 float64 syst_float64_mul( float64 a, float64 b )
308 *( (double *) &z ) = *( (double *) &a ) * *( (double *) &b );
313 float64 syst_float64_div( float64 a, float64 b )
317 *( (double *) &z ) = *( (double *) &a ) / *( (double *) &b );
322 float64 syst_float64_sqrt( float64 a )
326 *( (double *) &z ) = sqrt( *( (double *) &a ) );
331 flag syst_float64_eq( float64 a, float64 b )
334 return ( *( (double *) &a ) == *( (double *) &b ) );
338 flag syst_float64_le( float64 a, float64 b )
341 return ( *( (double *) &a ) <= *( (double *) &b ) );
345 flag syst_float64_lt( float64 a, float64 b )
348 return ( *( (double *) &a ) < *( (double *) &b ) );
352 #if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 )
354 int32 syst_floatx80_to_int32_round_to_zero( floatx80 a )
357 return *( (long double *) &a );
363 int64 syst_floatx80_to_int64_round_to_zero( floatx80 a )
366 return *( (long double *) &a );
372 float32 syst_floatx80_to_float32( floatx80 a )
376 *( (float *) &z ) = *( (long double *) &a );
381 float64 syst_floatx80_to_float64( floatx80 a )
385 *( (double *) &z ) = *( (long double *) &a );
390 floatx80 syst_floatx80_add( floatx80 a, floatx80 b )
394 *( (long double *) &z ) =
395 *( (long double *) &a ) + *( (long double *) &b );
400 floatx80 syst_floatx80_sub( floatx80 a, floatx80 b )
404 *( (long double *) &z ) =
405 *( (long double *) &a ) - *( (long double *) &b );
410 floatx80 syst_floatx80_mul( floatx80 a, floatx80 b )
414 *( (long double *) &z ) =
415 *( (long double *) &a ) * *( (long double *) &b );
420 floatx80 syst_floatx80_div( floatx80 a, floatx80 b )
424 *( (long double *) &z ) =
425 *( (long double *) &a ) / *( (long double *) &b );
430 flag syst_floatx80_eq( floatx80 a, floatx80 b )
433 return ( *( (long double *) &a ) == *( (long double *) &b ) );
437 flag syst_floatx80_le( floatx80 a, floatx80 b )
440 return ( *( (long double *) &a ) <= *( (long double *) &b ) );
444 flag syst_floatx80_lt( floatx80 a, floatx80 b )
447 return ( *( (long double *) &a ) < *( (long double *) &b ) );
453 #if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 )
455 int32 syst_float128_to_int32_round_to_zero( float128 a )
458 return *( (long double *) &a );
464 int64 syst_float128_to_int64_round_to_zero( float128 a )
467 return *( (long double *) &a );
473 float32 syst_float128_to_float32( float128 a )
477 *( (float *) &z ) = *( (long double *) &a );
482 float64 syst_float128_to_float64( float128 a )
486 *( (double *) &z ) = *( (long double *) &a );
491 float128 syst_float128_add( float128 a, float128 b )
495 *( (long double *) &z ) =
496 *( (long double *) &a ) + *( (long double *) &b );
501 float128 syst_float128_sub( float128 a, float128 b )
505 *( (long double *) &z ) =
506 *( (long double *) &a ) - *( (long double *) &b );
511 float128 syst_float128_mul( float128 a, float128 b )
515 *( (long double *) &z ) =
516 *( (long double *) &a ) * *( (long double *) &b );
521 float128 syst_float128_div( float128 a, float128 b )
525 *( (long double *) &z ) =
526 *( (long double *) &a ) / *( (long double *) &b );
531 flag syst_float128_eq( float128 a, float128 b )
534 return ( *( (long double *) &a ) == *( (long double *) &b ) );
538 flag syst_float128_le( float128 a, float128 b )
541 return ( *( (long double *) &a ) <= *( (long double *) &b ) );
545 flag syst_float128_lt( float128 a, float128 b )
548 return ( *( (long double *) &a ) < *( (long double *) &b ) );