tools/test/testfloat/systfloat.c

   1
   2 /*
   3 ===============================================================================
   4
   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.
   8
   9 Written by John R. Hauser.  More information is available through the Web
  10 page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'.
  11
  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.
  17
  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.
  22
  23 ===============================================================================
  24 */
  25
  26 #include <math.h>
  27 #include "milieu.h"
  28 #include "softfloat.h"
  29 #include "systfloat.h"
  30
  31 float32 syst_int32_to_float32( int32 a )
  32 {
  33     float32 z;
  34
  35     *( (float *) &z ) = a;
  36     return z;
  37
  38 }
  39
  40 float64 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
  51 floatx80 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
  64 float128 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
  77 float32 syst_int64_to_float32( int64 a )
  78 {
  79     float32 z;
  80
  81     *( (float *) &z ) = a;
  82     return z;
  83
  84 }
  85
  86 float64 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
  97 floatx80 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
 110 float128 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
 123 int32 syst_float32_to_int32_round_to_zero( float32 a )
 124 {
 125
 126     return *( (float *) &a );
 127
 128 }
 129
 130 #ifdef BITS64
 131
 132 int64 syst_float32_to_int64_round_to_zero( float32 a )
 133 {
 134
 135     return *( (float *) &a );
 136
 137 }
 138
 139 #endif
 140
 141 float64 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
 152 floatx80 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
 165 float128 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
 176 float32 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
 185 float32 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
 194 float32 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
 203 float32 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
 212 flag syst_float32_eq( float32 a, float32 b )
 213 {
 214
 215     return ( *( (float *) &a ) == *( (float *) &b ) );
 216
 217 }
 218
 219 flag syst_float32_le( float32 a, float32 b )
 220 {
 221
 222     return ( *( (float *) &a ) <= *( (float *) &b ) );
 223
 224 }
 225
 226 flag syst_float32_lt( float32 a, float32 b )
 227 {
 228
 229     return ( *( (float *) &a ) < *( (float *) &b ) );
 230
 231 }
 232
 233 int32 syst_float64_to_int32_round_to_zero( float64 a )
 234 {
 235
 236     return *( (double *) &a );
 237
 238 }
 239
 240 #ifdef BITS64
 241
 242 int64 syst_float64_to_int64_round_to_zero( float64 a )
 243 {
 244
 245     return *( (double *) &a );
 246
 247 }
 248
 249 #endif
 250
 251 float32 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
 262 floatx80 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
 275 float128 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
 286 float64 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
 295 float64 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
 304 float64 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
 313 float64 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
 322 float64 syst_float64_sqrt( float64 a )
 323 {
 324     float64 z;
 325
 326     *( (double *) &z ) = sqrt( *( (double *) &a ) );
 327     return z;
 328
 329 }
 330
 331 flag syst_float64_eq( float64 a, float64 b )
 332 {
 333
 334     return ( *( (double *) &a ) == *( (double *) &b ) );
 335
 336 }
 337
 338 flag syst_float64_le( float64 a, float64 b )
 339 {
 340
 341     return ( *( (double *) &a ) <= *( (double *) &b ) );
 342
 343 }
 344
 345 flag 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
 354 int32 syst_floatx80_to_int32_round_to_zero( floatx80 a )
 355 {
 356
 357     return *( (long double *) &a );
 358
 359 }
 360
 361 #ifdef BITS64
 362
 363 int64 syst_floatx80_to_int64_round_to_zero( floatx80 a )
 364 {
 365
 366     return *( (long double *) &a );
 367
 368 }
 369
 370 #endif
 371
 372 float32 syst_floatx80_to_float32( floatx80 a )
 373 {
 374     float32 z;
 375
 376     *( (float *) &z ) = *( (long double *) &a );
 377     return z;
 378
 379 }
 380
 381 float64 syst_floatx80_to_float64( floatx80 a )
 382 {
 383     float64 z;
 384
 385     *( (double *) &z ) = *( (long double *) &a );
 386     return z;
 387
 388 }
 389
 390 floatx80 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
 400 floatx80 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
 410 floatx80 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
 420 floatx80 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
 430 flag syst_floatx80_eq( floatx80 a, floatx80 b )
 431 {
 432
 433     return ( *( (long double *) &a ) == *( (long double *) &b ) );
 434
 435 }
 436
 437 flag syst_floatx80_le( floatx80 a, floatx80 b )
 438 {
 439
 440     return ( *( (long double *) &a ) <= *( (long double *) &b ) );
 441
 442 }
 443
 444 flag 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
 455 int32 syst_float128_to_int32_round_to_zero( float128 a )
 456 {
 457
 458     return *( (long double *) &a );
 459
 460 }
 461
 462 #ifdef BITS64
 463
 464 int64 syst_float128_to_int64_round_to_zero( float128 a )
 465 {
 466
 467     return *( (long double *) &a );
 468
 469 }
 470
 471 #endif
 472
 473 float32 syst_float128_to_float32( float128 a )
 474 {
 475     float32 z;
 476
 477     *( (float *) &z ) = *( (long double *) &a );
 478     return z;
 479
 480 }
 481
 482 float64 syst_float128_to_float64( float128 a )
 483 {
 484     float64 z;
 485
 486     *( (double *) &z ) = *( (long double *) &a );
 487     return z;
 488
 489 }
 490
 491 float128 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
 501 float128 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
 511 float128 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
 521 float128 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
 531 flag syst_float128_eq( float128 a, float128 b )
 532 {
 533
 534     return ( *( (long double *) &a ) == *( (long double *) &b ) );
 535
 536 }
 537
 538 flag syst_float128_le( float128 a, float128 b )
 539 {
 540
 541     return ( *( (long double *) &a ) <= *( (long double *) &b ) );
 542
 543 }
 544
 545 flag syst_float128_lt( float128 a, float128 b )
 546 {
 547
 548     return ( *( (long double *) &a ) < *( (long double *) &b ) );
 549
 550 }
 551
 552 #endif
 553