1: /*************************************************************************
2: *
3: * $Id: trionan.c,v 1.1.1.2 2014/06/15 19:53:29 misho Exp $
4: *
5: * Copyright (C) 2001 Bjorn Reese <breese@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: trionan.c,v 1.1.1.2 2014/06/15 19:53:29 misho Exp $";
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
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to trionan.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2