trio/triodef.h


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335

/*************************************************************************
 *
 * $Id: triodef.h,v 1.35 2009/09/20 11:37:14 breese Exp $
 *
 * Copyright (C) 2001 Bjorn Reese <breese@users.sourceforge.net>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
 * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
 * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
 *
 ************************************************************************/

#ifndef TRIO_TRIODEF_H
#define TRIO_TRIODEF_H

/*************************************************************************
 * Compiler support detection
 */

#if defined(__GNUC__)
# define TRIO_COMPILER_GCC
#endif

#if defined(__SUNPRO_CC)
# define TRIO_COMPILER_SUNPRO __SUNPRO_CC
#else
# if defined(__SUNPRO_C)
#  define TRIO_COMPILER_SUNPRO __SUNPRO_C
# endif
#endif

#if defined(__xlC__) || defined(__IBMC__) || defined(__IBMCPP__)
# define TRIO_COMPILER_XLC
#else
# if defined(_AIX) && !defined(__GNUC__)
#  define TRIO_COMPILER_XLC /* Workaround for old xlc */
# endif
#endif

#if defined(__DECC) || defined(__DECCXX)
# define TRIO_COMPILER_DECC
#else
# if defined(__osf__) && defined(__LANGUAGE_C__) && !defined(__GNUC__)
#  define TRIO_COMPILER_DECC /* Workaround for old DEC C compilers */
# endif
#endif

#if defined(__HP_aCC) || defined(__HP_cc)
# define TRIO_COMPILER_HP
#endif

#if defined(sgi) || defined(__sgi)
# define TRIO_COMPILER_MIPSPRO
#endif

#if defined(_MSC_VER)
# define TRIO_COMPILER_MSVC
#endif

#if defined(__BORLANDC__)
# define TRIO_COMPILER_BCB
#endif

/*************************************************************************
 * Platform support detection
 */

#if defined(VMS) || defined(__VMS)
# define TRIO_PLATFORM_VMS
#endif

#if defined(unix) || defined(__unix) || defined(__unix__)
# define TRIO_PLATFORM_UNIX
#endif

#if defined(TRIO_COMPILER_XLC) || defined(_AIX)
# define TRIO_PLATFORM_UNIX
#endif

#if defined(TRIO_COMPILER_DECC) || defined(__osf___)
# if !defined(TRIO_PLATFORM_VMS)
#  define TRIO_PLATFORM_UNIX
# endif
#endif

#if defined(__NetBSD__)
# define TRIO_PLATFORM_UNIX
#endif

#if defined(__Lynx__)
# define TRIO_PLATFORM_UNIX
# define TRIO_PLATFORM_LYNX
#endif

#if defined(__APPLE__) && defined(__MACH__)
# define TRIO_PLATFORM_UNIX
#endif

#if defined(__QNX__)
# define TRIO_PLATFORM_UNIX
# define TRIO_PLATFORM_QNX
#endif

#if defined(__CYGWIN__)
# define TRIO_PLATFORM_UNIX
#endif

#if defined(AMIGA) && defined(TRIO_COMPILER_GCC)
# define TRIO_PLATFORM_UNIX
#endif

#if defined(TRIO_COMPILER_MSVC) || defined(WIN32) || defined(_WIN32)
# define TRIO_PLATFORM_WIN32
#endif

#if defined(_WIN32_WCE)
# define TRIO_PLATFORM_WINCE
#endif

#if defined(mpeix) || defined(__mpexl)
# define TRIO_PLATFORM_MPEIX
#endif

#if defined(_AIX)
# define TRIO_PLATFORM_AIX
#endif

#if defined(__hpux)
# define TRIO_PLATFORM_HPUX
#endif

#if defined(sun) || defined(__sun__)
# if defined(__SVR4) || defined(__svr4__)
#  define TRIO_PLATFORM_SOLARIS
# else
#  define TRIO_PLATFORM_SUNOS
# endif
#endif

/*************************************************************************
 * Standards support detection
 */

#if defined(__STDC__) \
 || defined(_MSC_EXTENSIONS) \
 || defined(TRIO_COMPILER_BCB)
# define PREDEF_STANDARD_C89
#endif
#if defined(__STDC_VERSION__)
# define PREDEF_STANDARD_C90
#endif
#if (__STDC_VERSION__ - 0 >= 199409L)
# define PREDEF_STANDARD_C94
#endif
#if (__STDC_VERSION__ - 0 >= 199901L)
# define PREDEF_STANDARD_C99
#endif
#if defined(TRIO_COMPILER_SUNPRO) && (TRIO_COMPILER_SUNPRO >= 0x420)
# if !defined(PREDEF_STANDARD_C94)
#  define PREDEF_STANDARD_C94
# endif
#endif

#if defined(__cplusplus)
# define PREDEF_STANDARD_CXX
#endif
#if __cplusplus - 0 >= 199711L
# define PREDEF_STANDARD_CXX89
#endif

#if defined(TRIO_PLATFORM_UNIX)
# include <unistd.h>
#endif

#if defined(_POSIX_VERSION)
# define PREDEF_STANDARD_POSIX _POSIX_VERSION
# if (_POSIX_VERSION >= 199506L)
#  define PREDEF_STANDARD_POSIX_1996
# endif
#endif

#if (_XOPEN_VERSION - 0 >= 3) || defined(_XOPEN_XPG3)
# define PREDEF_STANDARD_XPG3
#endif
#if (_XOPEN_VERSION - 0 >= 4) || defined(_XOPEN_XPG4)
# define PREDEF_STANDARD_XPG4
#endif
#if (_XOPEN_VERSION - 0 > 4) \
 || (defined(_XOPEN_UNIX) && (_XOPEN_VERSION - 0 == 4))
# define PREDEF_STANDARD_UNIX95
#endif
#if (_XOPEN_VERSION - 0 >= 500)
# define PREDEF_STANDARD_UNIX98
#endif
#if (_XOPEN_VERSION - 0 >= 600)
# define PREDEF_STANDARD_UNIX03
#endif

/*************************************************************************
 * Generic defines
 */

#if !defined(TRIO_PUBLIC)
# define TRIO_PUBLIC
#endif
#if !defined(TRIO_PRIVATE)
# define TRIO_PRIVATE static
#endif

#if !(defined(PREDEF_STANDARD_C89) || defined(PREDEF_STANDARD_CXX))
# define TRIO_COMPILER_ANCIENT
#endif

#if defined(TRIO_COMPILER_ANCIENT)
# define TRIO_CONST
# define TRIO_VOLATILE
# define TRIO_SIGNED
typedef double trio_long_double_t;
typedef char * trio_pointer_t;
# define TRIO_SUFFIX_LONG(x) x
# define TRIO_PROTO(x) ()
# define TRIO_NOARGS
# define TRIO_ARGS1(list,a1) list a1;
# define TRIO_ARGS2(list,a1,a2) list a1; a2;
# define TRIO_ARGS3(list,a1,a2,a3) list a1; a2; a3;
# define TRIO_ARGS4(list,a1,a2,a3,a4) list a1; a2; a3; a4;
# define TRIO_ARGS5(list,a1,a2,a3,a4,a5) list a1; a2; a3; a4; a5;
# define TRIO_ARGS6(list,a1,a2,a3,a4,a5,a6) list a1; a2; a3; a4; a5; a6;
# define TRIO_ARGS7(list,a1,a2,a3,a4,a5,a6,a7) list a1; a2; a3; a4; a5; a6; a7;
# define TRIO_VARGS2(list,a1,a2) list a1; a2
# define TRIO_VARGS3(list,a1,a2,a3) list a1; a2; a3
# define TRIO_VARGS4(list,a1,a2,a3,a4) list a1; a2; a3; a4
# define TRIO_VARGS5(list,a1,a2,a3,a4,a5) list a1; a2; a3; a4; a5
# define TRIO_VA_DECL va_dcl
# define TRIO_VA_START(x,y) va_start(x)
# define TRIO_VA_END(x) va_end(x)
#else /* ANSI C */
# define TRIO_CONST const
# define TRIO_VOLATILE volatile
# define TRIO_SIGNED signed
typedef long double trio_long_double_t;
typedef void * trio_pointer_t;
# define TRIO_SUFFIX_LONG(x) x ## L
# define TRIO_PROTO(x) x
# define TRIO_NOARGS void
# define TRIO_ARGS1(list,a1) (a1)
# define TRIO_ARGS2(list,a1,a2) (a1,a2)
# define TRIO_ARGS3(list,a1,a2,a3) (a1,a2,a3)
# define TRIO_ARGS4(list,a1,a2,a3,a4) (a1,a2,a3,a4)
# define TRIO_ARGS5(list,a1,a2,a3,a4,a5) (a1,a2,a3,a4,a5)
# define TRIO_ARGS6(list,a1,a2,a3,a4,a5,a6) (a1,a2,a3,a4,a5,a6)
# define TRIO_ARGS7(list,a1,a2,a3,a4,a5,a6,a7) (a1,a2,a3,a4,a5,a6,a7)
# define TRIO_VARGS2 TRIO_ARGS2
# define TRIO_VARGS3 TRIO_ARGS3
# define TRIO_VARGS4 TRIO_ARGS4
# define TRIO_VARGS5 TRIO_ARGS5
# define TRIO_VA_DECL ...
# define TRIO_VA_START(x,y) va_start(x,y)
# define TRIO_VA_END(x) va_end(x)
#endif

#if defined(PREDEF_STANDARD_C99) || defined(PREDEF_STANDARD_CXX)
# define TRIO_INLINE inline
#else
# if defined(TRIO_COMPILER_GCC)
#  define TRIO_INLINE __inline__
# endif
# if defined(TRIO_COMPILER_MSVC)
#  define TRIO_INLINE _inline
# endif
# if defined(TRIO_COMPILER_BCB)
#  define TRIO_INLINE __inline
# endif
#endif
#if !defined(TRIO_INLINE)
# define TRIO_INLINE
#endif

/*************************************************************************
 * Workarounds
 */

#if defined(TRIO_PLATFORM_VMS)
/*
 * Computations done with constants at compile time can trigger these
 * even when compiling with IEEE enabled.
 */
# pragma message disable (UNDERFLOW, FLOATOVERFL)

# if (__CRTL_VER < 80210001)
/*
 * Although the compiler supports C99 language constructs, the C
 * run-time library does not contain all C99 functions.
 */
#  if defined(PREDEF_STANDARD_C99)
#   undef PREDEF_STANDARD_C99
#  endif
# endif
#endif

/*
 * Not all preprocessors supports the LL token.
 */
#if defined(TRIO_COMPILER_MSVC) || defined(TRIO_COMPILER_BCB)
#else
# define TRIO_COMPILER_SUPPORTS_LL
#endif

#if defined(__CYGWIN__)
/*
 * Cygwin defines the macros for hosted C99, but does not support certain
 * long double math functions.
 */
# include <cygwin/version.h>
# define TRIO_CYGWIN_VERSION_API CYGWIN_VERSION_API_MAJOR * 1000 + \
   CYGWIN_VERSION_API_MINOR
/*
 * Please change the version number below when the Cygwin API supports
 * long double math functions (powl, fmodl, etc.)
 */
# if TRIO_CYGWIN_VERSION_API < 99999999
#  define TRIO_NO_FLOORL 1
#  define TRIO_NO_CEILL 1
#  define TRIO_NO_POWL 1
#  define TRIO_NO_FMODL 1
#  define TRIO_NO_LOG10L 1
# endif
#endif

#endif /* TRIO_TRIODEF_H */
/*************************************************************************
 *
 * $Id: trionan.c,v 1.33 2005/05/29 11:57:25 breese Exp $
 *
 * Copyright (C) 2001 Bjorn Reese <breese@users.sourceforge.net>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
 * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
 * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
 *
 ************************************************************************
 *
 * Functions to handle special quantities in floating-point numbers
 * (that is, NaNs and infinity). They provide the capability to detect
 * and fabricate special quantities.
 *
 * Although written to be as portable as possible, it can never be
 * guaranteed to work on all platforms, as not all hardware supports
 * special quantities.
 *
 * The approach used here (approximately) is to:
 *
 *   1. Use C99 functionality when available.
 *   2. Use IEEE 754 bit-patterns if possible.
 *   3. Use platform-specific techniques.
 *
 ************************************************************************/

/*************************************************************************
 * Include files
 */
#include "triodef.h"
#include "trionan.h"

#include <math.h>
#include <string.h>
#include <limits.h>
#if !defined(TRIO_PLATFORM_SYMBIAN)
# include <float.h>
#endif
#if defined(TRIO_PLATFORM_UNIX)
# include <signal.h>
#endif
#if defined(TRIO_COMPILER_DECC)
# include <fp_class.h>
#endif
#include <assert.h>

#if defined(TRIO_DOCUMENTATION)
# include "doc/doc_nan.h"
#endif
/** @addtogroup SpecialQuantities
    @{
*/

/*************************************************************************
 * Definitions
 */

#if !defined(TRIO_PUBLIC_NAN)
# define TRIO_PUBLIC_NAN TRIO_PUBLIC
#endif
#if !defined(TRIO_PRIVATE_NAN)
# define TRIO_PRIVATE_NAN TRIO_PRIVATE
#endif

#define TRIO_TRUE (1 == 1)
#define TRIO_FALSE (0 == 1)

/*
 * We must enable IEEE floating-point on Alpha
 */
#if defined(__alpha) && !defined(_IEEE_FP)
# if defined(TRIO_COMPILER_DECC)
#  if defined(TRIO_PLATFORM_VMS)
#   error "Must be compiled with option /IEEE_MODE=UNDERFLOW_TO_ZERO/FLOAT=IEEE"
#  else
#   if !defined(_CFE)
#    error "Must be compiled with option -ieee"
#   endif
#  endif
# else
#  if defined(TRIO_COMPILER_GCC)
#   error "Must be compiled with option -mieee"
#  endif
# endif
#endif /* __alpha && ! _IEEE_FP */

/*
 * In ANSI/IEEE 754-1985 64-bits double format numbers have the
 * following properties (amoungst others)
 *
 *   o FLT_RADIX == 2: binary encoding
 *   o DBL_MAX_EXP == 1024: 11 bits exponent, where one bit is used
 *     to indicate special numbers (e.g. NaN and Infinity), so the
 *     maximum exponent is 10 bits wide (2^10 == 1024).
 *   o DBL_MANT_DIG == 53: The mantissa is 52 bits wide, but because
 *     numbers are normalized the initial binary 1 is represented
 *     implicitly (the so-called "hidden bit"), which leaves us with
 *     the ability to represent 53 bits wide mantissa.
 */
#if defined(__STDC_IEC_559__)
# define TRIO_IEEE_754
#else
# if (FLT_RADIX - 0 == 2) && (DBL_MAX_EXP - 0 == 1024) && (DBL_MANT_DIG - 0 == 53)
#  define TRIO_IEEE_754
# endif
#endif

/*
 * Determine which fpclassify_and_sign() function to use.
 */
#if defined(TRIO_FUNC_FPCLASSIFY_AND_SIGNBIT)
# if defined(PREDEF_STANDARD_C99) && defined(fpclassify)
#  define TRIO_FUNC_C99_FPCLASSIFY_AND_SIGNBIT
# else
#  if defined(TRIO_COMPILER_DECC)
#   define TRIO_FUNC_DECC_FPCLASSIFY_AND_SIGNBIT
#  else
#   if defined(TRIO_COMPILER_VISUALC) || defined(TRIO_COMPILER_BORLAND)
#    define TRIO_FUNC_MS_FPCLASSIFY_AND_SIGNBIT
#   else
#    if defined(TRIO_COMPILER_HP) && defined(FP_PLUS_NORM)
#     define TRIO_FUNC_HP_FPCLASSIFY_AND_SIGNBIT
#    else
#     if defined(TRIO_COMPILER_XLC) && defined(FP_PLUS_NORM)
#      define TRIO_FUNC_XLC_FPCLASSIFY_AND_SIGNBIT
#     else
#      define TRIO_FUNC_INTERNAL_FPCLASSIFY_AND_SIGNBIT
#     endif
#    endif
#   endif
#  endif
# endif
#endif

/*
 * Determine how to generate negative zero.
 */
#if defined(TRIO_FUNC_NZERO)
# if defined(TRIO_IEEE_754)
#  define TRIO_NZERO_IEEE_754
# else
#  define TRIO_NZERO_FALLBACK
# endif
#endif

/*
 * Determine how to generate positive infinity.
 */
#if defined(TRIO_FUNC_PINF)
# if defined(INFINITY) && defined(__STDC_IEC_559__)
#  define TRIO_PINF_C99_MACRO
# else
#  if defined(TRIO_IEEE_754)
#   define TRIO_PINF_IEEE_754
#  else
#   define TRIO_PINF_FALLBACK
#  endif
# endif
#endif

/*
 * Determine how to generate NaN.
 */
#if defined(TRIO_FUNC_NAN)
# if defined(PREDEF_STANDARD_C99) && !defined(TRIO_COMPILER_DECC)
#  define TRIO_NAN_C99_FUNCTION
# else
#  if defined(NAN) && defined(__STDC_IEC_559__)
#   define TRIO_NAN_C99_MACRO
#  else
#   if defined(TRIO_IEEE_754)
#    define TRIO_NAN_IEEE_754
#   else
#    define TRIO_NAN_FALLBACK
#   endif
#  endif
# endif
#endif

/*
 * Resolve internal dependencies.
 */
#if defined(TRIO_FUNC_INTERNAL_FPCLASSIFY_AND_SIGNBIT)
# define TRIO_FUNC_INTERNAL_ISNAN
# define TRIO_FUNC_INTERNAL_ISINF
# if defined(TRIO_IEEE_754)
#  define TRIO_FUNC_INTERNAL_IS_SPECIAL_QUANTITY
#  define TRIO_FUNC_INTERNAL_IS_NEGATIVE
# endif
#endif

#if defined(TRIO_NZERO_IEEE_754) \
 || defined(TRIO_PINF_IEEE_754) \
 || defined(TRIO_NAN_IEEE_754)
# define TRIO_FUNC_INTERNAL_MAKE_DOUBLE
#endif

#if defined(TRIO_FUNC_INTERNAL_ISNAN)
# if defined(PREDEF_STANDARD_XPG3)
#  define TRIO_INTERNAL_ISNAN_XPG3
# else
#  if defined(TRIO_IEEE_754)
#   define TRIO_INTERNAL_ISNAN_IEEE_754
#  else
#   define TRIO_INTERNAL_ISNAN_FALLBACK
#  endif
# endif
#endif

#if defined(TRIO_FUNC_INTERNAL_ISINF)
# if defined(TRIO_IEEE_754)
#  define TRIO_INTERNAL_ISINF_IEEE_754
# else
#  define TRIO_INTERNAL_ISINF_FALLBACK
# endif
#endif

/*************************************************************************
 * Constants
 */

#if !defined(TRIO_EMBED_NAN)
static TRIO_CONST char rcsid[] = "@(#)$Id: trionan.c,v 1.33 2005/05/29 11:57:25 breese Exp $";
#endif

#if defined(TRIO_FUNC_INTERNAL_MAKE_DOUBLE) \
 || defined(TRIO_FUNC_INTERNAL_IS_SPECIAL_QUANTITY) \
 || defined(TRIO_FUNC_INTERNAL_IS_NEGATIVE)
/*
 * Endian-agnostic indexing macro.
 *
 * The value of internalEndianMagic, when converted into a 64-bit
 * integer, becomes 0x0706050403020100 (we could have used a 64-bit
 * integer value instead of a double, but not all platforms supports
 * that type). The value is automatically encoded with the correct
 * endianess by the compiler, which means that we can support any
 * kind of endianess. The individual bytes are then used as an index
 * for the IEEE 754 bit-patterns and masks.
 */
#define TRIO_DOUBLE_INDEX(x) (((unsigned char *)&internalEndianMagic)[7-(x)])
static TRIO_CONST double internalEndianMagic = 7.949928895127363e-275;
#endif

#if defined(TRIO_FUNC_INTERNAL_IS_SPECIAL_QUANTITY)
/* Mask for the exponent */
static TRIO_CONST unsigned char ieee_754_exponent_mask[] = {
  0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

/* Mask for the mantissa */
static TRIO_CONST unsigned char ieee_754_mantissa_mask[] = {
  0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};
#endif

#if defined(TRIO_FUNC_INTERNAL_IS_NEGATIVE)
/* Mask for the sign bit */
static TRIO_CONST unsigned char ieee_754_sign_mask[] = {
  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
#endif

#if defined(TRIO_NZERO_IEEE_754)
/* Bit-pattern for negative zero */
static TRIO_CONST unsigned char ieee_754_negzero_array[] = {
  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
#endif

#if defined(TRIO_PINF_IEEE_754)
/* Bit-pattern for infinity */
static TRIO_CONST unsigned char ieee_754_infinity_array[] = {
  0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
#endif

#if defined(TRIO_NAN_IEEE_754)
/* Bit-pattern for quiet NaN */
static TRIO_CONST unsigned char ieee_754_qnan_array[] = {
  0x7F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
#endif


/*************************************************************************
 * Internal functions
 */

/*
 * internal_make_double
 */
#if defined(TRIO_FUNC_INTERNAL_MAKE_DOUBLE)

TRIO_PRIVATE_NAN double
internal_make_double
TRIO_ARGS1((values),
	   TRIO_CONST unsigned char *values)
{
  TRIO_VOLATILE double result;
  int i;

  for (i = 0; i < (int)sizeof(double); i++) {
    ((TRIO_VOLATILE unsigned char *)&result)[TRIO_DOUBLE_INDEX(i)] = values[i];
  }
  return result;
}

#endif

/*
 * internal_is_special_quantity
 */
#if defined(TRIO_FUNC_INTERNAL_IS_SPECIAL_QUANTITY)

TRIO_PRIVATE_NAN int
internal_is_special_quantity
TRIO_ARGS2((number, has_mantissa),
	   double number,
	   int *has_mantissa)
{
  unsigned int i;
  unsigned char current;
  int is_special_quantity = TRIO_TRUE;

  *has_mantissa = 0;

  for (i = 0; i < (unsigned int)sizeof(double); i++) {
    current = ((unsigned char *)&number)[TRIO_DOUBLE_INDEX(i)];
    is_special_quantity
      &= ((current & ieee_754_exponent_mask[i]) == ieee_754_exponent_mask[i]);
    *has_mantissa |= (current & ieee_754_mantissa_mask[i]);
  }
  return is_special_quantity;
}

#endif

/*
 * internal_is_negative
 */
#if defined(TRIO_FUNC_INTERNAL_IS_NEGATIVE)

TRIO_PRIVATE_NAN int
internal_is_negative
TRIO_ARGS1((number),
	   double number)
{
  unsigned int i;
  int is_negative = TRIO_FALSE;

  for (i = 0; i < (unsigned int)sizeof(double); i++) {
    is_negative |= (((unsigned char *)&number)[TRIO_DOUBLE_INDEX(i)]
		    & ieee_754_sign_mask[i]);
  }
  return is_negative;
}

#endif

#if defined(TRIO_FUNC_C99_FPCLASSIFY_AND_SIGNBIT)

TRIO_PRIVATE_NAN TRIO_INLINE int
c99_fpclassify_and_signbit
TRIO_ARGS2((number, is_negative),
	   double number,
	   int *is_negative)
{
  *is_negative = signbit(number);
  switch (fpclassify(number)) {
  case FP_NAN:
    return TRIO_FP_NAN;
  case FP_INFINITE:
    return TRIO_FP_INFINITE;
  case FP_SUBNORMAL:
    return TRIO_FP_SUBNORMAL;
  case FP_ZERO:
    return TRIO_FP_ZERO;
  default:
    return TRIO_FP_NORMAL;
  }
}

#endif /* TRIO_FUNC_C99_FPCLASSIFY_AND_SIGNBIT */

#if defined(TRIO_FUNC_DECC_FPCLASSIFY_AND_SIGNBIT)

TRIO_PRIVATE_NAN TRIO_INLINE int
decc_fpclassify_and_signbit
TRIO_ARGS2((number, is_negative),
	  double number,
	  int *is_negative)
{
  switch (fp_class(number)) {
  case FP_QNAN:
  case FP_SNAN:
    *is_negative = TRIO_FALSE; /* NaN has no sign */
    return TRIO_FP_NAN;
  case FP_POS_INF:
    *is_negative = TRIO_FALSE;
    return TRIO_FP_INFINITE;
  case FP_NEG_INF:
    *is_negative = TRIO_TRUE;
    return TRIO_FP_INFINITE;
  case FP_POS_DENORM:
    *is_negative = TRIO_FALSE;
    return TRIO_FP_SUBNORMAL;
  case FP_NEG_DENORM:
    *is_negative = TRIO_TRUE;
    return TRIO_FP_SUBNORMAL;
  case FP_POS_ZERO:
    *is_negative = TRIO_FALSE;
    return TRIO_FP_ZERO;
  case FP_NEG_ZERO:
    *is_negative = TRIO_TRUE;
    return TRIO_FP_ZERO;
  case FP_POS_NORM:
    *is_negative = TRIO_FALSE;
    return TRIO_FP_NORMAL;
  case FP_NEG_NORM:
    *is_negative = TRIO_TRUE;
    return TRIO_FP_NORMAL;
  default:
    *is_negative = (number < 0.0);
    return TRIO_FP_NORMAL;
  }
}

#endif /* TRIO_FUNC_DECC_FPCLASSIFY_AND_SIGNBIT */

#if defined(TRIO_FUNC_MS_FPCLASSIFY_AND_SIGNBIT)

TRIO_PRIVATE_NAN int
ms_fpclassify_and_signbit
TRIO_ARGS2((number, is_negative),
	  double number,
	  int *is_negative)
{
  int result;
# if defined(TRIO_COMPILER_BORLAND)
  /*
   * The floating-point precision may be changed by the Borland _fpclass()
   * function, so we have to save and restore the floating-point control mask.
   */
  unsigned int mask;
  /* Remember the old mask */
  mask = _control87(0, 0);
# endif
  
  switch (_fpclass(number)) {
  case _FPCLASS_QNAN:
  case _FPCLASS_SNAN:
    *is_negative = TRIO_FALSE; /* NaN has no sign */
    result = TRIO_FP_NAN;
    break;
  case _FPCLASS_PINF:
    *is_negative = TRIO_FALSE;
    result = TRIO_FP_INFINITE;
    break;
  case _FPCLASS_NINF:
    *is_negative = TRIO_TRUE;
    result = TRIO_FP_INFINITE;
    break;
  case _FPCLASS_PD:
    *is_negative = TRIO_FALSE;
    result = TRIO_FP_SUBNORMAL;
    break;
  case _FPCLASS_ND:
    *is_negative = TRIO_TRUE;
    result = TRIO_FP_SUBNORMAL;
    break;
  case _FPCLASS_PZ:
    *is_negative = TRIO_FALSE;
    result = TRIO_FP_ZERO;
    break;
  case _FPCLASS_NZ:
    *is_negative = TRIO_TRUE;
    result = TRIO_FP_ZERO;
    break;
  case _FPCLASS_PN:
    *is_negative = TRIO_FALSE;
    result = TRIO_FP_NORMAL;
    break;
  case _FPCLASS_NN:
    *is_negative = TRIO_TRUE;
    result = TRIO_FP_NORMAL;
    break;
  default:
    *is_negative = (number < 0.0);
    result = TRIO_FP_NORMAL;
    break;
  }
  
# if defined(TRIO_COMPILER_BORLAND)
  /* Restore the old precision */
  (void)_control87(mask, MCW_PC);
# endif
  
  return result;
}

#endif /* TRIO_FUNC_MS_FPCLASSIFY_AND_SIGNBIT */

#if defined(TRIO_FUNC_HP_FPCLASSIFY_AND_SIGNBIT)

TRIO_PRIVATE_NAN TRIO_INLINE int
hp_fpclassify_and_signbit
TRIO_ARGS2((number, is_negative),
	  double number,
	  int *is_negative)
{
  /*
   * HP-UX 9.x and 10.x have an fpclassify() function, that is different
   * from the C99 fpclassify() macro supported on HP-UX 11.x.
   */
  switch (fpclassify(number)) {
  case FP_QNAN:
  case FP_SNAN:
    *is_negative = TRIO_FALSE; /* NaN has no sign */
    return TRIO_FP_NAN;
  case FP_PLUS_INF:
    *is_negative = TRIO_FALSE;
    return TRIO_FP_INFINITE;
  case FP_MINUS_INF:
    *is_negative = TRIO_TRUE;
    return TRIO_FP_INFINITE;
  case FP_PLUS_DENORM:
    *is_negative = TRIO_FALSE;
    return TRIO_FP_SUBNORMAL;
  case FP_MINUS_DENORM:
    *is_negative = TRIO_TRUE;
    return TRIO_FP_SUBNORMAL;
  case FP_PLUS_ZERO:
    *is_negative = TRIO_FALSE;
    return TRIO_FP_ZERO;
  case FP_MINUS_ZERO:
    *is_negative = TRIO_TRUE;
    return TRIO_FP_ZERO;
  case FP_PLUS_NORM:
    *is_negative = TRIO_FALSE;
    return TRIO_FP_NORMAL;
  case FP_MINUS_NORM:
    *is_negative = TRIO_TRUE;
    return TRIO_FP_NORMAL;
  default:
    *is_negative = (number < 0.0);
    return TRIO_FP_NORMAL;
  }
}

#endif /* TRIO_FUNC_HP_FPCLASSIFY_AND_SIGNBIT */

#if defined(TRIO_FUNC_XLC_FPCLASSIFY_AND_SIGNBIT)

TRIO_PRIVATE_NAN TRIO_INLINE int
xlc_fpclassify_and_signbit
TRIO_ARGS2((number, is_negative),
	  double number,
	  int *is_negative)
{
  /*
   * AIX has class() for C, and _class() for C++
   */
# if defined(__cplusplus)
#  define AIX_CLASS(n) _class(n)
# else
#  define AIX_CLASS(n) class(n)
# endif

  switch (AIX_CLASS(number)) {
  case FP_QNAN:
  case FP_SNAN:
    *is_negative = TRIO_FALSE; /* NaN has no sign */
    return TRIO_FP_NAN;
  case FP_PLUS_INF:
    *is_negative = TRIO_FALSE;
    return TRIO_FP_INFINITE;
  case FP_MINUS_INF:
    *is_negative = TRIO_TRUE;
    return TRIO_FP_INFINITE;
  case FP_PLUS_DENORM:
    *is_negative = TRIO_FALSE;
    return TRIO_FP_SUBNORMAL;
  case FP_MINUS_DENORM:
    *is_negative = TRIO_TRUE;
    return TRIO_FP_SUBNORMAL;
  case FP_PLUS_ZERO:
    *is_negative = TRIO_FALSE;
    return TRIO_FP_ZERO;
  case FP_MINUS_ZERO:
    *is_negative = TRIO_TRUE;
    return TRIO_FP_ZERO;
  case FP_PLUS_NORM:
    *is_negative = TRIO_FALSE;
    return TRIO_FP_NORMAL;
  case FP_MINUS_NORM:
    *is_negative = TRIO_TRUE;
    return TRIO_FP_NORMAL;
  default:
    *is_negative = (number < 0.0);
    return TRIO_FP_NORMAL;
  }
}

#endif /* TRIO_FUNC_XLC_FPCLASSIFY_AND_SIGNBIT */

#if defined(TRIO_FUNC_INTERNAL_ISNAN)

TRIO_PRIVATE_NAN TRIO_INLINE int
internal_isnan
TRIO_ARGS1((number),
	   double number)
{
# if defined(TRIO_INTERNAL_ISNAN_XPG3) || defined(TRIO_PLATFORM_SYMBIAN)
  /*
   * XPG3 defines isnan() as a function.
   */
  return isnan(number);

# endif
  
# if defined(TRIO_INTERNAL_ISNAN_IEEE_754)
  
  /*
   * Examine IEEE 754 bit-pattern. A NaN must have a special exponent
   * pattern, and a non-empty mantissa.
   */
  int has_mantissa;
  int is_special_quantity;

  is_special_quantity = internal_is_special_quantity(number, &has_mantissa);
  
  return (is_special_quantity && has_mantissa);
  
# endif

# if defined(TRIO_INTERNAL_ISNAN_FALLBACK)
  
  /*
   * Fallback solution
   */
  int status;
  double integral, fraction;
  
#  if defined(TRIO_PLATFORM_UNIX)
  void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN);
#  endif
  
  status = (/*
	     * NaN is the only number which does not compare to itself
	     */
	    ((TRIO_VOLATILE double)number != (TRIO_VOLATILE double)number) ||
	    /*
	     * Fallback solution if NaN compares to NaN
	     */
	    ((number != 0.0) &&
	     (fraction = modf(number, &integral),
	      integral == fraction)));
  
#  if defined(TRIO_PLATFORM_UNIX)
  signal(SIGFPE, signal_handler);
#  endif
  
  return status;
  
# endif
}

#endif /* TRIO_FUNC_INTERNAL_ISNAN */

#if defined(TRIO_FUNC_INTERNAL_ISINF)

TRIO_PRIVATE_NAN TRIO_INLINE int
internal_isinf
TRIO_ARGS1((number),
	   double number)
{
# if defined(TRIO_PLATFORM_SYMBIAN)

  return isinf(number);

# endif

# if defined(TRIO_INTERNAL_ISINF_IEEE_754)
  /*
   * Examine IEEE 754 bit-pattern. Infinity must have a special exponent
   * pattern, and an empty mantissa.
   */
  int has_mantissa;
  int is_special_quantity;

  is_special_quantity = internal_is_special_quantity(number, &has_mantissa);
  
  return (is_special_quantity && !has_mantissa)
    ? ((number < 0.0) ? -1 : 1)
    : 0;

# endif

# if defined(TRIO_INTERNAL_ISINF_FALLBACK)
  
  /*
   * Fallback solution.
   */
  int status;
  
#  if defined(TRIO_PLATFORM_UNIX)
  void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN);
#  endif
  
  double infinity = trio_pinf();
  
  status = ((number == infinity)
	    ? 1
	    : ((number == -infinity) ? -1 : 0));
  
#  if defined(TRIO_PLATFORM_UNIX)
  signal(SIGFPE, signal_handler);
#  endif
  
  return status;

# endif
}

#endif /* TRIO_FUNC_INTERNAL_ISINF */

/*************************************************************************
 * Public functions
 */

#if defined(TRIO_FUNC_FPCLASSIFY_AND_SIGNBIT)

TRIO_PUBLIC_NAN int
trio_fpclassify_and_signbit
TRIO_ARGS2((number, is_negative),
	   double number,
	   int *is_negative)
{
  /* The TRIO_FUNC_xxx_FPCLASSIFY_AND_SIGNBIT macros are mutually exclusive */
  
#if defined(TRIO_FUNC_C99_FPCLASSIFY_AND_SIGNBIT)

  return c99_fpclassify_and_signbit(number, is_negative);

#endif

#if defined(TRIO_FUNC_DECC_FPCLASSIFY_AND_SIGNBIT)

  return decc_fpclassify_and_signbit(number, is_negative);

#endif

#if defined(TRIO_FUNC_MS_FPCLASSIFY_AND_SIGNBIT)

  return ms_fpclassify_and_signbit(number, is_negative);

#endif

#if defined(TRIO_FUNC_HP_FPCLASSIFY_AND_SIGNBIT)

  return hp_fpclassify_and_signbit(number, is_negative);

#endif

#if defined(TRIO_FUNC_XLC_FPCLASSIFY_AND_SIGNBIT)

  return xlc_fpclassify_and_signbit(number, is_negative);

#endif

#if defined(TRIO_FUNC_INTERNAL_FPCLASSIFY_AND_SIGNBIT)
  
  /*
   * Fallback solution.
   */
  int rc;
  
  if (number == 0.0) {
    /*
     * In IEEE 754 the sign of zero is ignored in comparisons, so we
     * have to handle this as a special case by examining the sign bit
     * directly.
     */
# if defined(TRIO_IEEE_754)
    *is_negative = internal_is_negative(number);
# else
    *is_negative = TRIO_FALSE; /* FIXME */
# endif
    return TRIO_FP_ZERO;
  }
  if (internal_isnan(number)) {
    *is_negative = TRIO_FALSE;
    return TRIO_FP_NAN;
  }
  rc = internal_isinf(number);
  if (rc != 0) {
    *is_negative = (rc == -1);
    return TRIO_FP_INFINITE;
  }
  if ((number > 0.0) && (number < DBL_MIN)) {
    *is_negative = TRIO_FALSE;
    return TRIO_FP_SUBNORMAL;
  }
  if ((number < 0.0) && (number > -DBL_MIN)) {
    *is_negative = TRIO_TRUE;
    return TRIO_FP_SUBNORMAL;
  }
  *is_negative = (number < 0.0);
  return TRIO_FP_NORMAL;

#endif
}

#endif

/**
   Check for NaN.

   @param number An arbitrary floating-point number.
   @return Boolean value indicating whether or not the number is a NaN.
*/
#if defined(TRIO_FUNC_ISNAN)

TRIO_PUBLIC_NAN int
trio_isnan
TRIO_ARGS1((number),
	   double number)
{
  int dummy;
  
  return (trio_fpclassify_and_signbit(number, &dummy) == TRIO_FP_NAN);
}

#endif

/**
   Check for infinity.

   @param number An arbitrary floating-point number.
   @return 1 if positive infinity, -1 if negative infinity, 0 otherwise.
*/
#if defined(TRIO_FUNC_ISINF)

TRIO_PUBLIC_NAN int
trio_isinf
TRIO_ARGS1((number),
	   double number)
{
  int is_negative;
  
  if (trio_fpclassify_and_signbit(number, &is_negative) == TRIO_FP_INFINITE)
    {
      return (is_negative) ? -1 : 1;
    }
  else
    {
      return 0;
    }
}

#endif

/**
   Check for finity.

   @param number An arbitrary floating-point number.
   @return Boolean value indicating whether or not the number is a finite.
*/
#if defined(TRIO_FUNC_ISFINITE)

TRIO_PUBLIC_NAN int
trio_isfinite
TRIO_ARGS1((number),
	   double number)
{
  int dummy;
  
  switch (trio_fpclassify_and_signbit(number, &dummy))
    {
    case TRIO_FP_INFINITE:
    case TRIO_FP_NAN:
      return 0;
    default:
      return 1;
    }
}

#endif

/**
   Examine the sign of a number.

   @param number An arbitrary floating-point number.
   @return Boolean value indicating whether or not the number has the
   sign bit set (i.e. is negative).
*/
#if defined(TRIO_FUNC_SIGNBIT)

TRIO_PUBLIC_NAN int
trio_signbit
TRIO_ARGS1((number),
	   double number)
{
  int is_negative;
  
  (void)trio_fpclassify_and_signbit(number, &is_negative);
  return is_negative;
}

#endif

/**
   Examine the class of a number.

   @param number An arbitrary floating-point number.
   @return Enumerable value indicating the class of @p number
*/
#if defined(TRIO_FUNC_FPCLASSIFY)

TRIO_PUBLIC_NAN int
trio_fpclassify
TRIO_ARGS1((number),
	   double number)
{
  int dummy;
  
  return trio_fpclassify_and_signbit(number, &dummy);
}

#endif

/**
   Generate negative zero.

   @return Floating-point representation of negative zero.
*/
#if defined(TRIO_FUNC_NZERO)

TRIO_PUBLIC_NAN double
trio_nzero(TRIO_NOARGS)
{
# if defined(TRIO_NZERO_IEEE_754)
  
  return internal_make_double(ieee_754_negzero_array);

# endif
  
# if defined(TRIO_NZERO_FALLBACK)
  
  TRIO_VOLATILE double zero = 0.0;

  return -zero;
  
# endif
}

#endif

/**
   Generate positive infinity.

   @return Floating-point representation of positive infinity.
*/
#if defined(TRIO_FUNC_PINF)

TRIO_PUBLIC_NAN double
trio_pinf(TRIO_NOARGS)
{
  /* Cache the result */
  static double pinf_value = 0.0;

  if (pinf_value == 0.0) {

# if defined(TRIO_PINF_C99_MACRO)
    
    pinf_value = (double)INFINITY;

# endif
    
# if defined(TRIO_PINF_IEEE_754)
    
    pinf_value = internal_make_double(ieee_754_infinity_array);

# endif

# if defined(TRIO_PINF_FALLBACK)
    /*
     * If HUGE_VAL is different from DBL_MAX, then HUGE_VAL is used
     * as infinity. Otherwise we have to resort to an overflow
     * operation to generate infinity.
     */
#  if defined(TRIO_PLATFORM_UNIX)
    void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN);
#  endif

    pinf_value = HUGE_VAL;
    if (HUGE_VAL == DBL_MAX) {
      /* Force overflow */
      pinf_value += HUGE_VAL;
    }
    
#  if defined(TRIO_PLATFORM_UNIX)
    signal(SIGFPE, signal_handler);
#  endif

# endif
  }
  return pinf_value;
}

#endif

/**
   Generate negative infinity.

   @return Floating-point value of negative infinity.
*/
#if defined(TRIO_FUNC_NINF)

TRIO_PUBLIC_NAN double
trio_ninf(TRIO_NOARGS)
{
  static double ninf_value = 0.0;

  if (ninf_value == 0.0) {
    /*
     * Negative infinity is calculated by negating positive infinity,
     * which can be done because it is legal to do calculations on
     * infinity (for example,  1 / infinity == 0).
     */
    ninf_value = -trio_pinf();
  }
  return ninf_value;
}

#endif

/**
   Generate NaN.

   @return Floating-point representation of NaN.
*/
#if defined(TRIO_FUNC_NAN)

TRIO_PUBLIC_NAN double
trio_nan(TRIO_NOARGS)
{
  /* Cache the result */
  static double nan_value = 0.0;

  if (nan_value == 0.0) {
    
# if defined(TRIO_NAN_C99_FUNCTION) || defined(TRIO_PLATFORM_SYMBIAN)
    
    nan_value = nan("");

# endif
    
# if defined(TRIO_NAN_C99_MACRO)
    
    nan_value = (double)NAN;

# endif

# if defined(TRIO_NAN_IEEE_754)
    
    nan_value = internal_make_double(ieee_754_qnan_array);

# endif
    
# if defined(TRIO_NAN_FALLBACK)
    /*
     * There are several ways to generate NaN. The one used here is
     * to divide infinity by infinity. I would have preferred to add
     * negative infinity to positive infinity, but that yields wrong
     * result (infinity) on FreeBSD.
     *
     * This may fail if the hardware does not support NaN, or if
     * the Invalid Operation floating-point exception is unmasked.
     */
#  if defined(TRIO_PLATFORM_UNIX)
    void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN);
#  endif
    
    nan_value = trio_pinf() / trio_pinf();
    
#  if defined(TRIO_PLATFORM_UNIX)
    signal(SIGFPE, signal_handler);
#  endif

# endif
  }
  return nan_value;
}

#endif

/** @} SpecialQuantities */

/*************************************************************************
 * For test purposes.
 *
 * Add the following compiler option to include this test code.
 *
 *  Unix : -DSTANDALONE
 *  VMS  : /DEFINE=(STANDALONE)
 */
#if defined(STANDALONE)
# include <stdio.h>

static TRIO_CONST char *
getClassification
TRIO_ARGS1((type),
	   int type)
{
  switch (type) {
  case TRIO_FP_INFINITE:
    return "FP_INFINITE";
  case TRIO_FP_NAN:
    return "FP_NAN";
  case TRIO_FP_NORMAL:
    return "FP_NORMAL";
  case TRIO_FP_SUBNORMAL:
    return "FP_SUBNORMAL";
  case TRIO_FP_ZERO:
    return "FP_ZERO";
  default:
    return "FP_UNKNOWN";
  }
}

static void
print_class
TRIO_ARGS2((prefix, number),
	   TRIO_CONST char *prefix,
	   double number)
{
  printf("%-6s: %s %-15s %g\n",
	 prefix,
	 trio_signbit(number) ? "-" : "+",
	 getClassification(trio_fpclassify(number)),
	 number);
}

int main(TRIO_NOARGS)
{
  double my_nan;
  double my_pinf;
  double my_ninf;
# if defined(TRIO_PLATFORM_UNIX)
  void (*signal_handler) TRIO_PROTO((int));
# endif

  my_nan = trio_nan();
  my_pinf = trio_pinf();
  my_ninf = trio_ninf();

  print_class("Nan", my_nan);
  print_class("PInf", my_pinf);
  print_class("NInf", my_ninf);
  print_class("PZero", 0.0);
  print_class("NZero", -0.0);
  print_class("PNorm", 1.0);
  print_class("NNorm", -1.0);
  print_class("PSub", 1.01e-307 - 1.00e-307);
  print_class("NSub", 1.00e-307 - 1.01e-307);
  
  printf("NaN : %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d, %2d)\n",
	 my_nan,
	 ((unsigned char *)&my_nan)[0],
	 ((unsigned char *)&my_nan)[1],
	 ((unsigned char *)&my_nan)[2],
	 ((unsigned char *)&my_nan)[3],
	 ((unsigned char *)&my_nan)[4],
	 ((unsigned char *)&my_nan)[5],
	 ((unsigned char *)&my_nan)[6],
	 ((unsigned char *)&my_nan)[7],
	 trio_isnan(my_nan), trio_isinf(my_nan), trio_isfinite(my_nan));
  printf("PInf: %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d, %2d)\n",
	 my_pinf,
	 ((unsigned char *)&my_pinf)[0],
	 ((unsigned char *)&my_pinf)[1],
	 ((unsigned char *)&my_pinf)[2],
	 ((unsigned char *)&my_pinf)[3],
	 ((unsigned char *)&my_pinf)[4],
	 ((unsigned char *)&my_pinf)[5],
	 ((unsigned char *)&my_pinf)[6],
	 ((unsigned char *)&my_pinf)[7],
	 trio_isnan(my_pinf), trio_isinf(my_pinf), trio_isfinite(my_pinf));
  printf("NInf: %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d, %2d)\n",
	 my_ninf,
	 ((unsigned char *)&my_ninf)[0],
	 ((unsigned char *)&my_ninf)[1],
	 ((unsigned char *)&my_ninf)[2],
	 ((unsigned char *)&my_ninf)[3],
	 ((unsigned char *)&my_ninf)[4],
	 ((unsigned char *)&my_ninf)[5],
	 ((unsigned char *)&my_ninf)[6],
	 ((unsigned char *)&my_ninf)[7],
	 trio_isnan(my_ninf), trio_isinf(my_ninf), trio_isfinite(my_ninf));
  
# if defined(TRIO_PLATFORM_UNIX)
  signal_handler = signal(SIGFPE, SIG_IGN);
# endif
  
  my_pinf = DBL_MAX + DBL_MAX;
  my_ninf = -my_pinf;
  my_nan = my_pinf / my_pinf;

# if defined(TRIO_PLATFORM_UNIX)
  signal(SIGFPE, signal_handler);
# endif
  
  printf("NaN : %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d, %2d)\n",
	 my_nan,
	 ((unsigned char *)&my_nan)[0],
	 ((unsigned char *)&my_nan)[1],
	 ((unsigned char *)&my_nan)[2],
	 ((unsigned char *)&my_nan)[3],
	 ((unsigned char *)&my_nan)[4],
	 ((unsigned char *)&my_nan)[5],
	 ((unsigned char *)&my_nan)[6],
	 ((unsigned char *)&my_nan)[7],
	 trio_isnan(my_nan), trio_isinf(my_nan), trio_isfinite(my_nan));
  printf("PInf: %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d, %2d)\n",
	 my_pinf,
	 ((unsigned char *)&my_pinf)[0],
	 ((unsigned char *)&my_pinf)[1],
	 ((unsigned char *)&my_pinf)[2],
	 ((unsigned char *)&my_pinf)[3],
	 ((unsigned char *)&my_pinf)[4],
	 ((unsigned char *)&my_pinf)[5],
	 ((unsigned char *)&my_pinf)[6],
	 ((unsigned char *)&my_pinf)[7],
	 trio_isnan(my_pinf), trio_isinf(my_pinf), trio_isfinite(my_pinf));
  printf("NInf: %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d, %2d)\n",
	 my_ninf,
	 ((unsigned char *)&my_ninf)[0],
	 ((unsigned char *)&my_ninf)[1],
	 ((unsigned char *)&my_ninf)[2],
	 ((unsigned char *)&my_ninf)[3],
	 ((unsigned char *)&my_ninf)[4],
	 ((unsigned char *)&my_ninf)[5],
	 ((unsigned char *)&my_ninf)[6],
	 ((unsigned char *)&my_ninf)[7],
	 trio_isnan(my_ninf), trio_isinf(my_ninf), trio_isfinite(my_ninf));
  
  return 0;
}
#endif