1 /************************************************************************* 2 * 3 * $Id$ 4 * 5 * Copyright (C) 2001 Bjorn Reese <breese (at) users.sourceforge.net> 6 * 7 * Permission to use, copy, modify, and distribute this software for any 8 * purpose with or without fee is hereby granted, provided that the above 9 * copyright notice and this permission notice appear in all copies. 10 * 11 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED 12 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF 13 * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND 14 * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER. 15 * 16 ************************************************************************ 17 * 18 * Functions to handle special quantities in floating-point numbers 19 * (that is, NaNs and infinity). They provide the capability to detect 20 * and fabricate special quantities. 21 * 22 * Although written to be as portable as possible, it can never be 23 * guaranteed to work on all platforms, as not all hardware supports 24 * special quantities. 25 * 26 * The approach used here (approximately) is to: 27 * 28 * 1. Use C99 functionality when available. 29 * 2. Use IEEE 754 bit-patterns if possible. 30 * 3. Use platform-specific techniques. 31 * 32 ************************************************************************/ 33 34 /* 35 * TODO: 36 * o Put all the magic into trio_fpclassify_and_signbit(), and use this from 37 * trio_isnan() etc. 38 */ 39 40 /************************************************************************* 41 * Include files 42 */ 43 #include "triodef.h" 44 #include "trionan.h" 45 46 #include <math.h> 47 #include <string.h> 48 #include <limits.h> 49 #include <float.h> 50 #if defined(TRIO_PLATFORM_UNIX) 51 # include <signal.h> 52 #endif 53 #if defined(TRIO_COMPILER_DECC) 54 # if defined(__linux__) 55 # include <cpml.h> 56 # else 57 # include <fp_class.h> 58 # endif 59 #endif 60 #include <assert.h> 61 62 #if defined(TRIO_DOCUMENTATION) 63 # include "doc/doc_nan.h" 64 #endif 65 /** @addtogroup SpecialQuantities 66 @{ 67 */ 68 69 /************************************************************************* 70 * Definitions 71 */ 72 73 #define TRIO_TRUE (1 == 1) 74 #define TRIO_FALSE (0 == 1) 75 76 /* 77 * We must enable IEEE floating-point on Alpha 78 */ 79 #if defined(__alpha) && !defined(_IEEE_FP) 80 # if defined(TRIO_COMPILER_DECC) 81 # if defined(TRIO_PLATFORM_VMS) 82 # error "Must be compiled with option /IEEE_MODE=UNDERFLOW_TO_ZERO/FLOAT=IEEE" 83 # else 84 # if !defined(_CFE) 85 # error "Must be compiled with option -ieee" 86 # endif 87 # endif 88 # elif defined(TRIO_COMPILER_GCC) && (defined(__osf__) || defined(__linux__)) 89 # error "Must be compiled with option -mieee" 90 # endif 91 #endif /* __alpha && ! _IEEE_FP */ 92 93 /* 94 * In ANSI/IEEE 754-1985 64-bits double format numbers have the 95 * following properties (amoungst others) 96 * 97 * o FLT_RADIX == 2: binary encoding 98 * o DBL_MAX_EXP == 1024: 11 bits exponent, where one bit is used 99 * to indicate special numbers (e.g. NaN and Infinity), so the 100 * maximum exponent is 10 bits wide (2^10 == 1024). 101 * o DBL_MANT_DIG == 53: The mantissa is 52 bits wide, but because 102 * numbers are normalized the initial binary 1 is represented 103 * implicitly (the so-called "hidden bit"), which leaves us with 104 * the ability to represent 53 bits wide mantissa. 105 */ 106 #if (FLT_RADIX == 2) && (DBL_MAX_EXP == 1024) && (DBL_MANT_DIG == 53) 107 # define USE_IEEE_754 108 #endif 109 110 111 /************************************************************************* 112 * Constants 113 */ 114 115 static TRIO_CONST char rcsid[] = "@(#)$Id$"; 116 117 #if defined(USE_IEEE_754) 118 119 /* 120 * Endian-agnostic indexing macro. 121 * 122 * The value of internalEndianMagic, when converted into a 64-bit 123 * integer, becomes 0x0706050403020100 (we could have used a 64-bit 124 * integer value instead of a double, but not all platforms supports 125 * that type). The value is automatically encoded with the correct 126 * endianess by the compiler, which means that we can support any 127 * kind of endianess. The individual bytes are then used as an index 128 * for the IEEE 754 bit-patterns and masks. 129 */ 130 #define TRIO_DOUBLE_INDEX(x) (((unsigned char *)&internalEndianMagic)[7-(x)]) 131 132 #if (defined(__BORLANDC__) && __BORLANDC__ >= 0x0590) 133 static TRIO_CONST double internalEndianMagic = 7.949928895127362e-275; 134 #else 135 static TRIO_CONST double internalEndianMagic = 7.949928895127363e-275; 136 #endif 137 138 /* Mask for the exponent */ 139 static TRIO_CONST unsigned char ieee_754_exponent_mask[] = { 140 0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 141 }; 142 143 /* Mask for the mantissa */ 144 static TRIO_CONST unsigned char ieee_754_mantissa_mask[] = { 145 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF 146 }; 147 148 /* Mask for the sign bit */ 149 static TRIO_CONST unsigned char ieee_754_sign_mask[] = { 150 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 151 }; 152 153 /* Bit-pattern for negative zero */ 154 static TRIO_CONST unsigned char ieee_754_negzero_array[] = { 155 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 156 }; 157 158 /* Bit-pattern for infinity */ 159 static TRIO_CONST unsigned char ieee_754_infinity_array[] = { 160 0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 161 }; 162 163 /* Bit-pattern for quiet NaN */ 164 static TRIO_CONST unsigned char ieee_754_qnan_array[] = { 165 0x7F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 166 }; 167 168 169 /************************************************************************* 170 * Functions 171 */ 172 173 /* 174 * trio_make_double 175 */ 176 TRIO_PRIVATE double 177 trio_make_double 178 TRIO_ARGS1((values), 179 TRIO_CONST unsigned char *values) 180 { 181 TRIO_VOLATILE double result; 182 int i; 183 184 for (i = 0; i < (int)sizeof(double); i++) { 185 ((TRIO_VOLATILE unsigned char *)&result)[TRIO_DOUBLE_INDEX(i)] = values[i]; 186 } 187 return result; 188 } 189 190 /* 191 * trio_is_special_quantity 192 */ 193 TRIO_PRIVATE int 194 trio_is_special_quantity 195 TRIO_ARGS2((number, has_mantissa), 196 double number, 197 int *has_mantissa) 198 { 199 unsigned int i; 200 unsigned char current; 201 int is_special_quantity = TRIO_TRUE; 202 203 *has_mantissa = 0; 204 205 for (i = 0; i < (unsigned int)sizeof(double); i++) { 206 current = ((unsigned char *)&number)[TRIO_DOUBLE_INDEX(i)]; 207 is_special_quantity 208 &= ((current & ieee_754_exponent_mask[i]) == ieee_754_exponent_mask[i]); 209 *has_mantissa |= (current & ieee_754_mantissa_mask[i]); 210 } 211 return is_special_quantity; 212 } 213 214 /* 215 * trio_is_negative 216 */ 217 TRIO_PRIVATE int 218 trio_is_negative 219 TRIO_ARGS1((number), 220 double number) 221 { 222 unsigned int i; 223 int is_negative = TRIO_FALSE; 224 225 for (i = 0; i < (unsigned int)sizeof(double); i++) { 226 is_negative |= (((unsigned char *)&number)[TRIO_DOUBLE_INDEX(i)] 227 & ieee_754_sign_mask[i]); 228 } 229 return is_negative; 230 } 231 232 #endif /* USE_IEEE_754 */ 233 234 235 /** 236 Generate negative zero. 237 238 @return Floating-point representation of negative zero. 239 */ 240 TRIO_PUBLIC double 241 trio_nzero(TRIO_NOARGS) 242 { 243 #if defined(USE_IEEE_754) 244 return trio_make_double(ieee_754_negzero_array); 245 #else 246 TRIO_VOLATILE double zero = 0.0; 247 248 return -zero; 249 #endif 250 } 251 252 /** 253 Generate positive infinity. 254 255 @return Floating-point representation of positive infinity. 256 */ 257 TRIO_PUBLIC double 258 trio_pinf(TRIO_NOARGS) 259 { 260 /* Cache the result */ 261 static double result = 0.0; 262 263 if (result == 0.0) { 264 265 #if defined(INFINITY) && defined(__STDC_IEC_559__) 266 result = (double)INFINITY; 267 268 #elif defined(USE_IEEE_754) 269 result = trio_make_double(ieee_754_infinity_array); 270 271 #else 272 /* 273 * If HUGE_VAL is different from DBL_MAX, then HUGE_VAL is used 274 * as infinity. Otherwise we have to resort to an overflow 275 * operation to generate infinity. 276 */ 277 # if defined(TRIO_PLATFORM_UNIX) 278 void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN); 279 # endif 280 281 result = HUGE_VAL; 282 if (HUGE_VAL == DBL_MAX) { 283 /* Force overflow */ 284 result += HUGE_VAL; 285 } 286 287 # if defined(TRIO_PLATFORM_UNIX) 288 signal(SIGFPE, signal_handler); 289 # endif 290 291 #endif 292 } 293 return result; 294 } 295 296 /** 297 Generate negative infinity. 298 299 @return Floating-point value of negative infinity. 300 */ 301 TRIO_PUBLIC double 302 trio_ninf(TRIO_NOARGS) 303 { 304 static double result = 0.0; 305 306 if (result == 0.0) { 307 /* 308 * Negative infinity is calculated by negating positive infinity, 309 * which can be done because it is legal to do calculations on 310 * infinity (for example, 1 / infinity == 0). 311 */ 312 result = -trio_pinf(); 313 } 314 return result; 315 } 316 317 /** 318 Generate NaN. 319 320 @return Floating-point representation of NaN. 321 */ 322 TRIO_PUBLIC double 323 trio_nan(TRIO_NOARGS) 324 { 325 /* Cache the result */ 326 static double result = 0.0; 327 328 if (result == 0.0) { 329 330 #if defined(TRIO_COMPILER_SUPPORTS_C99) 331 result = nan(""); 332 333 #elif defined(NAN) && defined(__STDC_IEC_559__) 334 result = (double)NAN; 335 336 #elif defined(USE_IEEE_754) 337 result = trio_make_double(ieee_754_qnan_array); 338 339 #else 340 /* 341 * There are several ways to generate NaN. The one used here is 342 * to divide infinity by infinity. I would have preferred to add 343 * negative infinity to positive infinity, but that yields wrong 344 * result (infinity) on FreeBSD. 345 * 346 * This may fail if the hardware does not support NaN, or if 347 * the Invalid Operation floating-point exception is unmasked. 348 */ 349 # if defined(TRIO_PLATFORM_UNIX) 350 void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN); 351 # endif 352 353 result = trio_pinf() / trio_pinf(); 354 355 # if defined(TRIO_PLATFORM_UNIX) 356 signal(SIGFPE, signal_handler); 357 # endif 358 359 #endif 360 } 361 return result; 362 } 363 364 /** 365 Check for NaN. 366 367 @param number An arbitrary floating-point number. 368 @return Boolean value indicating whether or not the number is a NaN. 369 */ 370 TRIO_PUBLIC int 371 trio_isnan 372 TRIO_ARGS1((number), 373 double number) 374 { 375 #if (defined(TRIO_COMPILER_SUPPORTS_C99) && defined(isnan)) \ 376 || defined(TRIO_COMPILER_SUPPORTS_UNIX95) 377 /* 378 * C99 defines isnan() as a macro. UNIX95 defines isnan() as a 379 * function. This function was already present in XPG4, but this 380 * is a bit tricky to detect with compiler defines, so we choose 381 * the conservative approach and only use it for UNIX95. 382 */ 383 return isnan(number); 384 385 #elif defined(TRIO_COMPILER_MSVC) || defined(TRIO_COMPILER_BCB) 386 /* 387 * Microsoft Visual C++ and Borland C++ Builder have an _isnan() 388 * function. 389 */ 390 return _isnan(number) ? TRIO_TRUE : TRIO_FALSE; 391 392 #elif defined(USE_IEEE_754) 393 /* 394 * Examine IEEE 754 bit-pattern. A NaN must have a special exponent 395 * pattern, and a non-empty mantissa. 396 */ 397 int has_mantissa; 398 int is_special_quantity; 399 400 is_special_quantity = trio_is_special_quantity(number, &has_mantissa); 401 402 return (is_special_quantity && has_mantissa); 403 404 #else 405 /* 406 * Fallback solution 407 */ 408 int status; 409 double integral, fraction; 410 411 # if defined(TRIO_PLATFORM_UNIX) 412 void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN); 413 # endif 414 415 status = (/* 416 * NaN is the only number which does not compare to itself 417 */ 418 ((TRIO_VOLATILE double)number != (TRIO_VOLATILE double)number) || 419 /* 420 * Fallback solution if NaN compares to NaN 421 */ 422 ((number != 0.0) && 423 (fraction = modf(number, &integral), 424 integral == fraction))); 425 426 # if defined(TRIO_PLATFORM_UNIX) 427 signal(SIGFPE, signal_handler); 428 # endif 429 430 return status; 431 432 #endif 433 } 434 435 /** 436 Check for infinity. 437 438 @param number An arbitrary floating-point number. 439 @return 1 if positive infinity, -1 if negative infinity, 0 otherwise. 440 */ 441 TRIO_PUBLIC int 442 trio_isinf 443 TRIO_ARGS1((number), 444 double number) 445 { 446 #if defined(TRIO_COMPILER_DECC) && !defined(__linux__) 447 /* 448 * DECC has an isinf() macro, but it works differently than that 449 * of C99, so we use the fp_class() function instead. 450 */ 451 return ((fp_class(number) == FP_POS_INF) 452 ? 1 453 : ((fp_class(number) == FP_NEG_INF) ? -1 : 0)); 454 455 #elif defined(isinf) 456 /* 457 * C99 defines isinf() as a macro. 458 */ 459 return isinf(number) 460 ? ((number > 0.0) ? 1 : -1) 461 : 0; 462 463 #elif defined(TRIO_COMPILER_MSVC) || defined(TRIO_COMPILER_BCB) 464 /* 465 * Microsoft Visual C++ and Borland C++ Builder have an _fpclass() 466 * function that can be used to detect infinity. 467 */ 468 return ((_fpclass(number) == _FPCLASS_PINF) 469 ? 1 470 : ((_fpclass(number) == _FPCLASS_NINF) ? -1 : 0)); 471 472 #elif defined(USE_IEEE_754) 473 /* 474 * Examine IEEE 754 bit-pattern. Infinity must have a special exponent 475 * pattern, and an empty mantissa. 476 */ 477 int has_mantissa; 478 int is_special_quantity; 479 480 is_special_quantity = trio_is_special_quantity(number, &has_mantissa); 481 482 return (is_special_quantity && !has_mantissa) 483 ? ((number < 0.0) ? -1 : 1) 484 : 0; 485 486 #else 487 /* 488 * Fallback solution. 489 */ 490 int status; 491 492 # if defined(TRIO_PLATFORM_UNIX) 493 void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN); 494 # endif 495 496 double infinity = trio_pinf(); 497 498 status = ((number == infinity) 499 ? 1 500 : ((number == -infinity) ? -1 : 0)); 501 502 # if defined(TRIO_PLATFORM_UNIX) 503 signal(SIGFPE, signal_handler); 504 # endif 505 506 return status; 507 508 #endif 509 } 510 511 #if 0 512 /* Temporary fix - this routine is not used anywhere */ 513 /** 514 Check for finity. 515 516 @param number An arbitrary floating-point number. 517 @return Boolean value indicating whether or not the number is a finite. 518 */ 519 TRIO_PUBLIC int 520 trio_isfinite 521 TRIO_ARGS1((number), 522 double number) 523 { 524 #if defined(TRIO_COMPILER_SUPPORTS_C99) && defined(isfinite) 525 /* 526 * C99 defines isfinite() as a macro. 527 */ 528 return isfinite(number); 529 530 #elif defined(TRIO_COMPILER_MSVC) || defined(TRIO_COMPILER_BCB) 531 /* 532 * Microsoft Visual C++ and Borland C++ Builder use _finite(). 533 */ 534 return _finite(number); 535 536 #elif defined(USE_IEEE_754) 537 /* 538 * Examine IEEE 754 bit-pattern. For finity we do not care about the 539 * mantissa. 540 */ 541 int dummy; 542 543 return (! trio_is_special_quantity(number, &dummy)); 544 545 #else 546 /* 547 * Fallback solution. 548 */ 549 return ((trio_isinf(number) == 0) && (trio_isnan(number) == 0)); 550 551 #endif 552 } 553 554 #endif 555 556 /* 557 * The sign of NaN is always false 558 */ 559 TRIO_PUBLIC int 560 trio_fpclassify_and_signbit 561 TRIO_ARGS2((number, is_negative), 562 double number, 563 int *is_negative) 564 { 565 #if defined(fpclassify) && defined(signbit) 566 /* 567 * C99 defines fpclassify() and signbit() as a macros 568 */ 569 *is_negative = signbit(number); 570 switch (fpclassify(number)) { 571 case FP_NAN: 572 return TRIO_FP_NAN; 573 case FP_INFINITE: 574 return TRIO_FP_INFINITE; 575 case FP_SUBNORMAL: 576 return TRIO_FP_SUBNORMAL; 577 case FP_ZERO: 578 return TRIO_FP_ZERO; 579 default: 580 return TRIO_FP_NORMAL; 581 } 582 583 #else 584 # if defined(TRIO_COMPILER_DECC) 585 /* 586 * DECC has an fp_class() function. 587 */ 588 # define TRIO_FPCLASSIFY(n) fp_class(n) 589 # define TRIO_QUIET_NAN FP_QNAN 590 # define TRIO_SIGNALLING_NAN FP_SNAN 591 # define TRIO_POSITIVE_INFINITY FP_POS_INF 592 # define TRIO_NEGATIVE_INFINITY FP_NEG_INF 593 # define TRIO_POSITIVE_SUBNORMAL FP_POS_DENORM 594 # define TRIO_NEGATIVE_SUBNORMAL FP_NEG_DENORM 595 # define TRIO_POSITIVE_ZERO FP_POS_ZERO 596 # define TRIO_NEGATIVE_ZERO FP_NEG_ZERO 597 # define TRIO_POSITIVE_NORMAL FP_POS_NORM 598 # define TRIO_NEGATIVE_NORMAL FP_NEG_NORM 599 600 # elif defined(TRIO_COMPILER_MSVC) || defined(TRIO_COMPILER_BCB) 601 /* 602 * Microsoft Visual C++ and Borland C++ Builder have an _fpclass() 603 * function. 604 */ 605 # define TRIO_FPCLASSIFY(n) _fpclass(n) 606 # define TRIO_QUIET_NAN _FPCLASS_QNAN 607 # define TRIO_SIGNALLING_NAN _FPCLASS_SNAN 608 # define TRIO_POSITIVE_INFINITY _FPCLASS_PINF 609 # define TRIO_NEGATIVE_INFINITY _FPCLASS_NINF 610 # define TRIO_POSITIVE_SUBNORMAL _FPCLASS_PD 611 # define TRIO_NEGATIVE_SUBNORMAL _FPCLASS_ND 612 # define TRIO_POSITIVE_ZERO _FPCLASS_PZ 613 # define TRIO_NEGATIVE_ZERO _FPCLASS_NZ 614 # define TRIO_POSITIVE_NORMAL _FPCLASS_PN 615 # define TRIO_NEGATIVE_NORMAL _FPCLASS_NN 616 617 # elif defined(FP_PLUS_NORM) 618 /* 619 * HP-UX 9.x and 10.x have an fpclassify() function, that is different 620 * from the C99 fpclassify() macro supported on HP-UX 11.x. 621 * 622 * AIX has class() for C, and _class() for C++, which returns the 623 * same values as the HP-UX fpclassify() function. 624 */ 625 # if defined(TRIO_PLATFORM_AIX) 626 # if defined(__cplusplus) 627 # define TRIO_FPCLASSIFY(n) _class(n) 628 # else 629 # define TRIO_FPCLASSIFY(n) class(n) 630 # endif 631 # else 632 # define TRIO_FPCLASSIFY(n) fpclassify(n) 633 # endif 634 # define TRIO_QUIET_NAN FP_QNAN 635 # define TRIO_SIGNALLING_NAN FP_SNAN 636 # define TRIO_POSITIVE_INFINITY FP_PLUS_INF 637 # define TRIO_NEGATIVE_INFINITY FP_MINUS_INF 638 # define TRIO_POSITIVE_SUBNORMAL FP_PLUS_DENORM 639 # define TRIO_NEGATIVE_SUBNORMAL FP_MINUS_DENORM 640 # define TRIO_POSITIVE_ZERO FP_PLUS_ZERO 641 # define TRIO_NEGATIVE_ZERO FP_MINUS_ZERO 642 # define TRIO_POSITIVE_NORMAL FP_PLUS_NORM 643 # define TRIO_NEGATIVE_NORMAL FP_MINUS_NORM 644 # endif 645 646 # if defined(TRIO_FPCLASSIFY) 647 switch (TRIO_FPCLASSIFY(number)) { 648 case TRIO_QUIET_NAN: 649 case TRIO_SIGNALLING_NAN: 650 *is_negative = TRIO_FALSE; /* NaN has no sign */ 651 return TRIO_FP_NAN; 652 case TRIO_POSITIVE_INFINITY: 653 *is_negative = TRIO_FALSE; 654 return TRIO_FP_INFINITE; 655 case TRIO_NEGATIVE_INFINITY: 656 *is_negative = TRIO_TRUE; 657 return TRIO_FP_INFINITE; 658 case TRIO_POSITIVE_SUBNORMAL: 659 *is_negative = TRIO_FALSE; 660 return TRIO_FP_SUBNORMAL; 661 case TRIO_NEGATIVE_SUBNORMAL: 662 *is_negative = TRIO_TRUE; 663 return TRIO_FP_SUBNORMAL; 664 case TRIO_POSITIVE_ZERO: 665 *is_negative = TRIO_FALSE; 666 return TRIO_FP_ZERO; 667 case TRIO_NEGATIVE_ZERO: 668 *is_negative = TRIO_TRUE; 669 return TRIO_FP_ZERO; 670 case TRIO_POSITIVE_NORMAL: 671 *is_negative = TRIO_FALSE; 672 return TRIO_FP_NORMAL; 673 case TRIO_NEGATIVE_NORMAL: 674 *is_negative = TRIO_TRUE; 675 return TRIO_FP_NORMAL; 676 default: 677 /* Just in case... */ 678 *is_negative = (number < 0.0); 679 return TRIO_FP_NORMAL; 680 } 681 682 # else 683 /* 684 * Fallback solution. 685 */ 686 int rc; 687 688 if (number == 0.0) { 689 /* 690 * In IEEE 754 the sign of zero is ignored in comparisons, so we 691 * have to handle this as a special case by examining the sign bit 692 * directly. 693 */ 694 # if defined(USE_IEEE_754) 695 *is_negative = trio_is_negative(number); 696 # else 697 *is_negative = TRIO_FALSE; /* FIXME */ 698 # endif 699 return TRIO_FP_ZERO; 700 } 701 if (trio_isnan(number)) { 702 *is_negative = TRIO_FALSE; 703 return TRIO_FP_NAN; 704 } 705 if ((rc = trio_isinf(number))) { 706 *is_negative = (rc == -1); 707 return TRIO_FP_INFINITE; 708 } 709 if ((number > 0.0) && (number < DBL_MIN)) { 710 *is_negative = TRIO_FALSE; 711 return TRIO_FP_SUBNORMAL; 712 } 713 if ((number < 0.0) && (number > -DBL_MIN)) { 714 *is_negative = TRIO_TRUE; 715 return TRIO_FP_SUBNORMAL; 716 } 717 *is_negative = (number < 0.0); 718 return TRIO_FP_NORMAL; 719 720 # endif 721 #endif 722 } 723 724 /** 725 Examine the sign of a number. 726 727 @param number An arbitrary floating-point number. 728 @return Boolean value indicating whether or not the number has the 729 sign bit set (i.e. is negative). 730 */ 731 TRIO_PUBLIC int 732 trio_signbit 733 TRIO_ARGS1((number), 734 double number) 735 { 736 int is_negative; 737 738 (void)trio_fpclassify_and_signbit(number, &is_negative); 739 return is_negative; 740 } 741 742 #if 0 743 /* Temporary fix - this routine is not used in libxml */ 744 /** 745 Examine the class of a number. 746 747 @param number An arbitrary floating-point number. 748 @return Enumerable value indicating the class of @p number 749 */ 750 TRIO_PUBLIC int 751 trio_fpclassify 752 TRIO_ARGS1((number), 753 double number) 754 { 755 int dummy; 756 757 return trio_fpclassify_and_signbit(number, &dummy); 758 } 759 760 #endif 761 762 /** @} SpecialQuantities */ 763 764 /************************************************************************* 765 * For test purposes. 766 * 767 * Add the following compiler option to include this test code. 768 * 769 * Unix : -DSTANDALONE 770 * VMS : /DEFINE=(STANDALONE) 771 */ 772 #if defined(STANDALONE) 773 # include <stdio.h> 774 775 static TRIO_CONST char * 776 getClassification 777 TRIO_ARGS1((type), 778 int type) 779 { 780 switch (type) { 781 case TRIO_FP_INFINITE: 782 return "FP_INFINITE"; 783 case TRIO_FP_NAN: 784 return "FP_NAN"; 785 case TRIO_FP_NORMAL: 786 return "FP_NORMAL"; 787 case TRIO_FP_SUBNORMAL: 788 return "FP_SUBNORMAL"; 789 case TRIO_FP_ZERO: 790 return "FP_ZERO"; 791 default: 792 return "FP_UNKNOWN"; 793 } 794 } 795 796 static void 797 print_class 798 TRIO_ARGS2((prefix, number), 799 TRIO_CONST char *prefix, 800 double number) 801 { 802 printf("%-6s: %s %-15s %g\n", 803 prefix, 804 trio_signbit(number) ? "-" : "+", 805 getClassification(TRIO_FPCLASSIFY(number)), 806 number); 807 } 808 809 int main(TRIO_NOARGS) 810 { 811 double my_nan; 812 double my_pinf; 813 double my_ninf; 814 # if defined(TRIO_PLATFORM_UNIX) 815 void (*signal_handler) TRIO_PROTO((int)); 816 # endif 817 818 my_nan = trio_nan(); 819 my_pinf = trio_pinf(); 820 my_ninf = trio_ninf(); 821 822 print_class("Nan", my_nan); 823 print_class("PInf", my_pinf); 824 print_class("NInf", my_ninf); 825 print_class("PZero", 0.0); 826 print_class("NZero", -0.0); 827 print_class("PNorm", 1.0); 828 print_class("NNorm", -1.0); 829 print_class("PSub", 1.01e-307 - 1.00e-307); 830 print_class("NSub", 1.00e-307 - 1.01e-307); 831 832 printf("NaN : %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d)\n", 833 my_nan, 834 ((unsigned char *)&my_nan)[0], 835 ((unsigned char *)&my_nan)[1], 836 ((unsigned char *)&my_nan)[2], 837 ((unsigned char *)&my_nan)[3], 838 ((unsigned char *)&my_nan)[4], 839 ((unsigned char *)&my_nan)[5], 840 ((unsigned char *)&my_nan)[6], 841 ((unsigned char *)&my_nan)[7], 842 trio_isnan(my_nan), trio_isinf(my_nan)); 843 printf("PInf: %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d)\n", 844 my_pinf, 845 ((unsigned char *)&my_pinf)[0], 846 ((unsigned char *)&my_pinf)[1], 847 ((unsigned char *)&my_pinf)[2], 848 ((unsigned char *)&my_pinf)[3], 849 ((unsigned char *)&my_pinf)[4], 850 ((unsigned char *)&my_pinf)[5], 851 ((unsigned char *)&my_pinf)[6], 852 ((unsigned char *)&my_pinf)[7], 853 trio_isnan(my_pinf), trio_isinf(my_pinf)); 854 printf("NInf: %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d)\n", 855 my_ninf, 856 ((unsigned char *)&my_ninf)[0], 857 ((unsigned char *)&my_ninf)[1], 858 ((unsigned char *)&my_ninf)[2], 859 ((unsigned char *)&my_ninf)[3], 860 ((unsigned char *)&my_ninf)[4], 861 ((unsigned char *)&my_ninf)[5], 862 ((unsigned char *)&my_ninf)[6], 863 ((unsigned char *)&my_ninf)[7], 864 trio_isnan(my_ninf), trio_isinf(my_ninf)); 865 866 # if defined(TRIO_PLATFORM_UNIX) 867 signal_handler = signal(SIGFPE, SIG_IGN); 868 # endif 869 870 my_pinf = DBL_MAX + DBL_MAX; 871 my_ninf = -my_pinf; 872 my_nan = my_pinf / my_pinf; 873 874 # if defined(TRIO_PLATFORM_UNIX) 875 signal(SIGFPE, signal_handler); 876 # endif 877 878 printf("NaN : %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d)\n", 879 my_nan, 880 ((unsigned char *)&my_nan)[0], 881 ((unsigned char *)&my_nan)[1], 882 ((unsigned char *)&my_nan)[2], 883 ((unsigned char *)&my_nan)[3], 884 ((unsigned char *)&my_nan)[4], 885 ((unsigned char *)&my_nan)[5], 886 ((unsigned char *)&my_nan)[6], 887 ((unsigned char *)&my_nan)[7], 888 trio_isnan(my_nan), trio_isinf(my_nan)); 889 printf("PInf: %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d)\n", 890 my_pinf, 891 ((unsigned char *)&my_pinf)[0], 892 ((unsigned char *)&my_pinf)[1], 893 ((unsigned char *)&my_pinf)[2], 894 ((unsigned char *)&my_pinf)[3], 895 ((unsigned char *)&my_pinf)[4], 896 ((unsigned char *)&my_pinf)[5], 897 ((unsigned char *)&my_pinf)[6], 898 ((unsigned char *)&my_pinf)[7], 899 trio_isnan(my_pinf), trio_isinf(my_pinf)); 900 printf("NInf: %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d)\n", 901 my_ninf, 902 ((unsigned char *)&my_ninf)[0], 903 ((unsigned char *)&my_ninf)[1], 904 ((unsigned char *)&my_ninf)[2], 905 ((unsigned char *)&my_ninf)[3], 906 ((unsigned char *)&my_ninf)[4], 907 ((unsigned char *)&my_ninf)[5], 908 ((unsigned char *)&my_ninf)[6], 909 ((unsigned char *)&my_ninf)[7], 910 trio_isnan(my_ninf), trio_isinf(my_ninf)); 911 912 return 0; 913 } 914 #endif 915
