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