1
2/*
3===============================================================================
4
5This C source file is part of TestFloat, Release 2a, a package of programs
6for testing the correctness of floating-point arithmetic complying to the
7IEC/IEEE Standard for Floating-Point.
8
9Written by John R. Hauser.  More information is available through the Web
10page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'.
11
12THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort
13has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
14TIMES RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO
15PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
16AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
17
18Derivative works are acceptable, even for commercial purposes, so long as
19(1) they include prominent notice that the work is derivative, and (2) they
20include prominent notice akin to these four paragraphs for those parts of
21this code that are retained.
22
23===============================================================================
24*/
25
26#include <math.h>
27#include "milieu.h"
28#include "softfloat.h"
29#include "systfloat.h"
30
31float32 syst_int32_to_float32( int32 a )
32{
33    float32 z;
34
35    *( (float *) &z ) = a;
36    return z;
37
38}
39
40float64 syst_int32_to_float64( int32 a )
41{
42    float64 z;
43
44    *( (double *) &z ) = a;
45    return z;
46
47}
48
49#if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 )
50
51floatx80 syst_int32_to_floatx80( int32 a )
52{
53    floatx80 z;
54
55    *( (long double *) &z ) = a;
56    return z;
57
58}
59
60#endif
61
62#if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 )
63
64float128 syst_int32_to_float128( int32 a )
65{
66    float128 z;
67
68    *( (long double *) &z ) = a;
69    return z;
70
71}
72
73#endif
74
75#ifdef BITS64
76
77float32 syst_int64_to_float32( int64 a )
78{
79    float32 z;
80
81    *( (float *) &z ) = a;
82    return z;
83
84}
85
86float64 syst_int64_to_float64( int64 a )
87{
88    float64 z;
89
90    *( (double *) &z ) = a;
91    return z;
92
93}
94
95#if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 )
96
97floatx80 syst_int64_to_floatx80( int64 a )
98{
99    floatx80 z;
100
101    *( (long double *) &z ) = a;
102    return z;
103
104}
105
106#endif
107
108#if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 )
109
110float128 syst_int64_to_float128( int64 a )
111{
112    float128 z;
113
114    *( (long double *) &z ) = a;
115    return z;
116
117}
118
119#endif
120
121#endif
122
123int32 syst_float32_to_int32_round_to_zero( float32 a )
124{
125
126    return *( (float *) &a );
127
128}
129
130#ifdef BITS64
131
132int64 syst_float32_to_int64_round_to_zero( float32 a )
133{
134
135    return *( (float *) &a );
136
137}
138
139#endif
140
141float64 syst_float32_to_float64( float32 a )
142{
143    float64 z;
144
145    *( (double *) &z ) = *( (float *) &a );
146    return z;
147
148}
149
150#if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 )
151
152floatx80 syst_float32_to_floatx80( float32 a )
153{
154    floatx80 z;
155
156    *( (long double *) &z ) = *( (float *) &a );
157    return z;
158
159}
160
161#endif
162
163#if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 )
164
165float128 syst_float32_to_float128( float32 a )
166{
167    float128 z;
168
169    *( (long double *) &z ) = *( (float *) &a );
170    return z;
171
172}
173
174#endif
175
176float32 syst_float32_add( float32 a, float32 b )
177{
178    float32 z;
179
180    *( (float *) &z ) = *( (float *) &a ) + *( (float *) &b );
181    return z;
182
183}
184
185float32 syst_float32_sub( float32 a, float32 b )
186{
187    float32 z;
188
189    *( (float *) &z ) = *( (float *) &a ) - *( (float *) &b );
190    return z;
191
192}
193
194float32 syst_float32_mul( float32 a, float32 b )
195{
196    float32 z;
197
198    *( (float *) &z ) = *( (float *) &a ) * *( (float *) &b );
199    return z;
200
201}
202
203float32 syst_float32_div( float32 a, float32 b )
204{
205    float32 z;
206
207    *( (float *) &z ) = *( (float *) &a ) / *( (float *) &b );
208    return z;
209
210}
211
212flag syst_float32_eq( float32 a, float32 b )
213{
214
215    return ( *( (float *) &a ) == *( (float *) &b ) );
216
217}
218
219flag syst_float32_le( float32 a, float32 b )
220{
221
222    return ( *( (float *) &a ) <= *( (float *) &b ) );
223
224}
225
226flag syst_float32_lt( float32 a, float32 b )
227{
228
229    return ( *( (float *) &a ) < *( (float *) &b ) );
230
231}
232
233int32 syst_float64_to_int32_round_to_zero( float64 a )
234{
235
236    return *( (double *) &a );
237
238}
239
240#ifdef BITS64
241
242int64 syst_float64_to_int64_round_to_zero( float64 a )
243{
244
245    return *( (double *) &a );
246
247}
248
249#endif
250
251float32 syst_float64_to_float32( float64 a )
252{
253    float32 z;
254
255    *( (float *) &z ) = *( (double *) &a );
256    return z;
257
258}
259
260#if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 )
261
262floatx80 syst_float64_to_floatx80( float64 a )
263{
264    floatx80 z;
265
266    *( (long double *) &z ) = *( (double *) &a );
267    return z;
268
269}
270
271#endif
272
273#if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 )
274
275float128 syst_float64_to_float128( float64 a )
276{
277    float128 z;
278
279    *( (long double *) &z ) = *( (double *) &a );
280    return z;
281
282}
283
284#endif
285
286float64 syst_float64_add( float64 a, float64 b )
287{
288    float64 z;
289
290    *( (double *) &z ) = *( (double *) &a ) + *( (double *) &b );
291    return z;
292
293}
294
295float64 syst_float64_sub( float64 a, float64 b )
296{
297    float64 z;
298
299    *( (double *) &z ) = *( (double *) &a ) - *( (double *) &b );
300    return z;
301
302}
303
304float64 syst_float64_mul( float64 a, float64 b )
305{
306    float64 z;
307
308    *( (double *) &z ) = *( (double *) &a ) * *( (double *) &b );
309    return z;
310
311}
312
313float64 syst_float64_div( float64 a, float64 b )
314{
315    float64 z;
316
317    *( (double *) &z ) = *( (double *) &a ) / *( (double *) &b );
318    return z;
319
320}
321
322float64 syst_float64_sqrt( float64 a )
323{
324    float64 z;
325
326    *( (double *) &z ) = sqrt( *( (double *) &a ) );
327    return z;
328
329}
330
331flag syst_float64_eq( float64 a, float64 b )
332{
333
334    return ( *( (double *) &a ) == *( (double *) &b ) );
335
336}
337
338flag syst_float64_le( float64 a, float64 b )
339{
340
341    return ( *( (double *) &a ) <= *( (double *) &b ) );
342
343}
344
345flag syst_float64_lt( float64 a, float64 b )
346{
347
348    return ( *( (double *) &a ) < *( (double *) &b ) );
349
350}
351
352#if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 )
353
354int32 syst_floatx80_to_int32_round_to_zero( floatx80 a )
355{
356
357    return *( (long double *) &a );
358
359}
360
361#ifdef BITS64
362
363int64 syst_floatx80_to_int64_round_to_zero( floatx80 a )
364{
365
366    return *( (long double *) &a );
367
368}
369
370#endif
371
372float32 syst_floatx80_to_float32( floatx80 a )
373{
374    float32 z;
375
376    *( (float *) &z ) = *( (long double *) &a );
377    return z;
378
379}
380
381float64 syst_floatx80_to_float64( floatx80 a )
382{
383    float64 z;
384
385    *( (double *) &z ) = *( (long double *) &a );
386    return z;
387
388}
389
390floatx80 syst_floatx80_add( floatx80 a, floatx80 b )
391{
392    floatx80 z;
393
394    *( (long double *) &z ) =
395        *( (long double *) &a ) + *( (long double *) &b );
396    return z;
397
398}
399
400floatx80 syst_floatx80_sub( floatx80 a, floatx80 b )
401{
402    floatx80 z;
403
404    *( (long double *) &z ) =
405        *( (long double *) &a ) - *( (long double *) &b );
406    return z;
407
408}
409
410floatx80 syst_floatx80_mul( floatx80 a, floatx80 b )
411{
412    floatx80 z;
413
414    *( (long double *) &z ) =
415        *( (long double *) &a ) * *( (long double *) &b );
416    return z;
417
418}
419
420floatx80 syst_floatx80_div( floatx80 a, floatx80 b )
421{
422    floatx80 z;
423
424    *( (long double *) &z ) =
425        *( (long double *) &a ) / *( (long double *) &b );
426    return z;
427
428}
429
430flag syst_floatx80_eq( floatx80 a, floatx80 b )
431{
432
433    return ( *( (long double *) &a ) == *( (long double *) &b ) );
434
435}
436
437flag syst_floatx80_le( floatx80 a, floatx80 b )
438{
439
440    return ( *( (long double *) &a ) <= *( (long double *) &b ) );
441
442}
443
444flag syst_floatx80_lt( floatx80 a, floatx80 b )
445{
446
447    return ( *( (long double *) &a ) < *( (long double *) &b ) );
448
449}
450
451#endif
452
453#if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 )
454
455int32 syst_float128_to_int32_round_to_zero( float128 a )
456{
457
458    return *( (long double *) &a );
459
460}
461
462#ifdef BITS64
463
464int64 syst_float128_to_int64_round_to_zero( float128 a )
465{
466
467    return *( (long double *) &a );
468
469}
470
471#endif
472
473float32 syst_float128_to_float32( float128 a )
474{
475    float32 z;
476
477    *( (float *) &z ) = *( (long double *) &a );
478    return z;
479
480}
481
482float64 syst_float128_to_float64( float128 a )
483{
484    float64 z;
485
486    *( (double *) &z ) = *( (long double *) &a );
487    return z;
488
489}
490
491float128 syst_float128_add( float128 a, float128 b )
492{
493    float128 z;
494
495    *( (long double *) &z ) =
496        *( (long double *) &a ) + *( (long double *) &b );
497    return z;
498
499}
500
501float128 syst_float128_sub( float128 a, float128 b )
502{
503    float128 z;
504
505    *( (long double *) &z ) =
506        *( (long double *) &a ) - *( (long double *) &b );
507    return z;
508
509}
510
511float128 syst_float128_mul( float128 a, float128 b )
512{
513    float128 z;
514
515    *( (long double *) &z ) =
516        *( (long double *) &a ) * *( (long double *) &b );
517    return z;
518
519}
520
521float128 syst_float128_div( float128 a, float128 b )
522{
523    float128 z;
524
525    *( (long double *) &z ) =
526        *( (long double *) &a ) / *( (long double *) &b );
527    return z;
528
529}
530
531flag syst_float128_eq( float128 a, float128 b )
532{
533
534    return ( *( (long double *) &a ) == *( (long double *) &b ) );
535
536}
537
538flag syst_float128_le( float128 a, float128 b )
539{
540
541    return ( *( (long double *) &a ) <= *( (long double *) &b ) );
542
543}
544
545flag syst_float128_lt( float128 a, float128 b )
546{
547
548    return ( *( (long double *) &a ) < *( (long double *) &b ) );
549
550}
551
552#endif
553
554