/*************************************************************************

 *

 * $Id$

 *

 * 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.

 *

 ************************************************************************/

/*

 * TODO:

 *  o Put all the magic into trio_fpclassify_and_signbit(), and use this from

 *    trio_isnan() etc.

 */

/*************************************************************************

 * Include files

 */

#include "triodef.h"

#include "trionan.h"

#include <math.h>

#include <string.h>

#include <limits.h>

#include <float.h>

#if defined(TRIO_PLATFORM_UNIX)

# include <signal.h>

#endif

#if defined(TRIO_COMPILER_DECC)

#  if defined(__linux__)

#   include <cpml.h>

#  else

#   include <fp_class.h>

#  endif

#endif

#include <assert.h>

#if defined(TRIO_DOCUMENTATION)

# include "doc/doc_nan.h"

#endif

/** @addtogroup SpecialQuantities

    @{

*/

/*************************************************************************

 * Definitions

 */

#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

# elif defined(TRIO_COMPILER_GCC) && (defined(__osf__) || defined(__linux__))

#  error "Must be compiled with option -mieee"

# 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 (FLT_RADIX == 2) && (DBL_MAX_EXP == 1024) && (DBL_MANT_DIG == 53)

# define USE_IEEE_754

#endif

/*************************************************************************

 * Constants

 */

static TRIO_CONST char rcsid[] = "@(#)$Id$";

#if defined(USE_IEEE_754)

/*

 * 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)])

#if (defined(__BORLANDC__) && __BORLANDC__ >= 0x0590)

static TRIO_CONST double internalEndianMagic = 7.949928895127362e-275;

#else

static TRIO_CONST double internalEndianMagic = 7.949928895127363e-275;

#endif

/* 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

};

/* Mask for the sign bit */

static TRIO_CONST unsigned char ieee_754_sign_mask[] = {

  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00

};

/* Bit-pattern for negative zero */

static TRIO_CONST unsigned char ieee_754_negzero_array[] = {

  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00

};

/* Bit-pattern for infinity */

static TRIO_CONST unsigned char ieee_754_infinity_array[] = {

  0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00

};

/* Bit-pattern for quiet NaN */

static TRIO_CONST unsigned char ieee_754_qnan_array[] = {

  0x7F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00

};

/*************************************************************************

 * Functions

 */

/*

 * trio_make_double

 */

TRIO_PRIVATE double

trio_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;

}

/*

 * trio_is_special_quantity

 */

TRIO_PRIVATE int

trio_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;

}

/*

 * trio_is_negative

 */

TRIO_PRIVATE int

trio_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 /* USE_IEEE_754 */

/**

   Generate negative zero.

   @return Floating-point representation of negative zero.

*/

TRIO_PUBLIC double

trio_nzero(TRIO_NOARGS)

{

#if defined(USE_IEEE_754)

  return trio_make_double(ieee_754_negzero_array);

#else

  TRIO_VOLATILE double zero = 0.0;

  return -zero;

#endif

}

/**

   Generate positive infinity.

   @return Floating-point representation of positive infinity.

*/

TRIO_PUBLIC double

trio_pinf(TRIO_NOARGS)

{

  /* Cache the result */

  static double result = 0.0;

  if (result == 0.0) {

#if defined(INFINITY) && defined(__STDC_IEC_559__)

    result = (double)INFINITY;

#elif defined(USE_IEEE_754)

    result = trio_make_double(ieee_754_infinity_array);

#else

    /*

     * 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

    result = HUGE_VAL;

    if (HUGE_VAL == DBL_MAX) {

      /* Force overflow */

      result += HUGE_VAL;

    }

# if defined(TRIO_PLATFORM_UNIX)

    signal(SIGFPE, signal_handler);

# endif

#endif

  }

  return result;

}

/**

   Generate negative infinity.

   @return Floating-point value of negative infinity.

*/

TRIO_PUBLIC double

trio_ninf(TRIO_NOARGS)

{

  static double result = 0.0;

  if (result == 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).

     */

    result = -trio_pinf();

  }

  return result;

}

/**

   Generate NaN.

   @return Floating-point representation of NaN.

*/

TRIO_PUBLIC double

trio_nan(TRIO_NOARGS)

{

  /* Cache the result */

  static double result = 0.0;

  if (result == 0.0) {

#if defined(TRIO_COMPILER_SUPPORTS_C99)

    result = nan("");

#elif defined(NAN) && defined(__STDC_IEC_559__)

    result = (double)NAN;

#elif defined(USE_IEEE_754)

    result = trio_make_double(ieee_754_qnan_array);

#else

    /*

     * 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

    result = trio_pinf() / trio_pinf();

# if defined(TRIO_PLATFORM_UNIX)

    signal(SIGFPE, signal_handler);

# endif

#endif

  }

  return result;

}

/**

   Check for NaN.

   @param number An arbitrary floating-point number.

   @return Boolean value indicating whether or not the number is a NaN.

*/

TRIO_PUBLIC int

trio_isnan

TRIO_ARGS1((number),

	   double number)

{

#if (defined(TRIO_COMPILER_SUPPORTS_C99) && defined(isnan)) \

 || defined(TRIO_COMPILER_SUPPORTS_UNIX95)

  /*

   * C99 defines isnan() as a macro. UNIX95 defines isnan() as a

   * function. This function was already present in XPG4, but this

   * is a bit tricky to detect with compiler defines, so we choose

   * the conservative approach and only use it for UNIX95.

   */

  return isnan(number);

#elif defined(TRIO_COMPILER_MSVC) || defined(TRIO_COMPILER_BCB)

  /*

   * Microsoft Visual C++ and Borland C++ Builder have an _isnan()

   * function.

   */

  return _isnan(number) ? TRIO_TRUE : TRIO_FALSE;

#elif defined(USE_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 = trio_is_special_quantity(number, &has_mantissa);

  return (is_special_quantity && has_mantissa);

#else

  /*

   * 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

}

/**

   Check for infinity.

   @param number An arbitrary floating-point number.

   @return 1 if positive infinity, -1 if negative infinity, 0 otherwise.

*/

TRIO_PUBLIC int

trio_isinf

TRIO_ARGS1((number),

	   double number)

{

#if defined(TRIO_COMPILER_DECC) && !defined(__linux__)

  /*

   * DECC has an isinf() macro, but it works differently than that

   * of C99, so we use the fp_class() function instead.

   */

  return ((fp_class(number) == FP_POS_INF)

	  ? 1

	  : ((fp_class(number) == FP_NEG_INF) ? -1 : 0));

#elif defined(isinf)

  /*

   * C99 defines isinf() as a macro.

   */

  return isinf(number)

    ? ((number > 0.0) ? 1 : -1)

    : 0;

#elif defined(TRIO_COMPILER_MSVC) || defined(TRIO_COMPILER_BCB)

  /*

   * Microsoft Visual C++ and Borland C++ Builder have an _fpclass()

   * function that can be used to detect infinity.

   */

  return ((_fpclass(number) == _FPCLASS_PINF)

	  ? 1

	  : ((_fpclass(number) == _FPCLASS_NINF) ? -1 : 0));

#elif defined(USE_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 = trio_is_special_quantity(number, &has_mantissa);

  return (is_special_quantity && !has_mantissa)

    ? ((number < 0.0) ? -1 : 1)

    : 0;

#else

  /*

   * 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

}

#if 0

	/* Temporary fix - this routine is not used anywhere */

/**

   Check for finity.

   @param number An arbitrary floating-point number.

   @return Boolean value indicating whether or not the number is a finite.

*/

TRIO_PUBLIC int

trio_isfinite

TRIO_ARGS1((number),

	   double number)

{

#if defined(TRIO_COMPILER_SUPPORTS_C99) && defined(isfinite)

  /*

   * C99 defines isfinite() as a macro.

   */

  return isfinite(number);

#elif defined(TRIO_COMPILER_MSVC) || defined(TRIO_COMPILER_BCB)

  /*

   * Microsoft Visual C++ and Borland C++ Builder use _finite().

   */

  return _finite(number);

#elif defined(USE_IEEE_754)

  /*

   * Examine IEEE 754 bit-pattern. For finity we do not care about the

   * mantissa.

   */

  int dummy;

  return (! trio_is_special_quantity(number, &dummy));

#else

  /*

   * Fallback solution.

   */

  return ((trio_isinf(number) == 0) && (trio_isnan(number) == 0));

#endif

}

#endif

/*

 * The sign of NaN is always false

 */

TRIO_PUBLIC int

trio_fpclassify_and_signbit

TRIO_ARGS2((number, is_negative),

	   double number,

	   int *is_negative)

{

#if defined(fpclassify) && defined(signbit)

  /*

   * C99 defines fpclassify() and signbit() as a macros

   */

  *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;

  }

#else

# if defined(TRIO_COMPILER_DECC)

  /*

   * DECC has an fp_class() function.

   */

#  define TRIO_FPCLASSIFY(n) fp_class(n)

#  define TRIO_QUIET_NAN FP_QNAN

#  define TRIO_SIGNALLING_NAN FP_SNAN

#  define TRIO_POSITIVE_INFINITY FP_POS_INF

#  define TRIO_NEGATIVE_INFINITY FP_NEG_INF

#  define TRIO_POSITIVE_SUBNORMAL FP_POS_DENORM

#  define TRIO_NEGATIVE_SUBNORMAL FP_NEG_DENORM

#  define TRIO_POSITIVE_ZERO FP_POS_ZERO

#  define TRIO_NEGATIVE_ZERO FP_NEG_ZERO

#  define TRIO_POSITIVE_NORMAL FP_POS_NORM

#  define TRIO_NEGATIVE_NORMAL FP_NEG_NORM

# elif defined(TRIO_COMPILER_MSVC) || defined(TRIO_COMPILER_BCB)

  /*

   * Microsoft Visual C++ and Borland C++ Builder have an _fpclass()

   * function.

   */

#  define TRIO_FPCLASSIFY(n) _fpclass(n)

#  define TRIO_QUIET_NAN _FPCLASS_QNAN

#  define TRIO_SIGNALLING_NAN _FPCLASS_SNAN

#  define TRIO_POSITIVE_INFINITY _FPCLASS_PINF

#  define TRIO_NEGATIVE_INFINITY _FPCLASS_NINF

#  define TRIO_POSITIVE_SUBNORMAL _FPCLASS_PD

#  define TRIO_NEGATIVE_SUBNORMAL _FPCLASS_ND

#  define TRIO_POSITIVE_ZERO _FPCLASS_PZ

#  define TRIO_NEGATIVE_ZERO _FPCLASS_NZ

#  define TRIO_POSITIVE_NORMAL _FPCLASS_PN

#  define TRIO_NEGATIVE_NORMAL _FPCLASS_NN

# elif defined(FP_PLUS_NORM)

  /*

   * 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.

   *

   * AIX has class() for C, and _class() for C++, which returns the

   * same values as the HP-UX fpclassify() function.

   */

#  if defined(TRIO_PLATFORM_AIX)

#   if defined(__cplusplus)

#    define TRIO_FPCLASSIFY(n) _class(n)

#   else

#    define TRIO_FPCLASSIFY(n) class(n)

#   endif

#  else

#   define TRIO_FPCLASSIFY(n) fpclassify(n)

#  endif

#  define TRIO_QUIET_NAN FP_QNAN

#  define TRIO_SIGNALLING_NAN FP_SNAN

#  define TRIO_POSITIVE_INFINITY FP_PLUS_INF

#  define TRIO_NEGATIVE_INFINITY FP_MINUS_INF

#  define TRIO_POSITIVE_SUBNORMAL FP_PLUS_DENORM

#  define TRIO_NEGATIVE_SUBNORMAL FP_MINUS_DENORM

#  define TRIO_POSITIVE_ZERO FP_PLUS_ZERO

#  define TRIO_NEGATIVE_ZERO FP_MINUS_ZERO

#  define TRIO_POSITIVE_NORMAL FP_PLUS_NORM

#  define TRIO_NEGATIVE_NORMAL FP_MINUS_NORM

# endif

# if defined(TRIO_FPCLASSIFY)

  switch (TRIO_FPCLASSIFY(number)) {

  case TRIO_QUIET_NAN:

  case TRIO_SIGNALLING_NAN:

    *is_negative = TRIO_FALSE; /* NaN has no sign */

    return TRIO_FP_NAN;

  case TRIO_POSITIVE_INFINITY:

    *is_negative = TRIO_FALSE;

    return TRIO_FP_INFINITE;

  case TRIO_NEGATIVE_INFINITY:

    *is_negative = TRIO_TRUE;

    return TRIO_FP_INFINITE;

  case TRIO_POSITIVE_SUBNORMAL:

    *is_negative = TRIO_FALSE;

    return TRIO_FP_SUBNORMAL;

  case TRIO_NEGATIVE_SUBNORMAL:

    *is_negative = TRIO_TRUE;

    return TRIO_FP_SUBNORMAL;

  case TRIO_POSITIVE_ZERO:

    *is_negative = TRIO_FALSE;

    return TRIO_FP_ZERO;

  case TRIO_NEGATIVE_ZERO:

    *is_negative = TRIO_TRUE;

    return TRIO_FP_ZERO;

  case TRIO_POSITIVE_NORMAL:

    *is_negative = TRIO_FALSE;

    return TRIO_FP_NORMAL;

  case TRIO_NEGATIVE_NORMAL:

    *is_negative = TRIO_TRUE;

    return TRIO_FP_NORMAL;

  default:

    /* Just in case... */

    *is_negative = (number < 0.0);

    return TRIO_FP_NORMAL;

  }

# else

  /*

   * 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(USE_IEEE_754)

    *is_negative = trio_is_negative(number);

#  else

    *is_negative = TRIO_FALSE; /* FIXME */

#  endif

    return TRIO_FP_ZERO;

  }

  if (trio_isnan(number)) {

    *is_negative = TRIO_FALSE;

    return TRIO_FP_NAN;

  }

  if ((rc = trio_isinf(number))) {

    *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

}

/**

   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).

*/

TRIO_PUBLIC int

trio_signbit

TRIO_ARGS1((number),

	   double number)

{

  int is_negative;

  (void)trio_fpclassify_and_signbit(number, &is_negative);

  return is_negative;

}

#if 0

	/* Temporary fix - this routine is not used in libxml */

/**

   Examine the class of a number.

   @param number An arbitrary floating-point number.

   @return Enumerable value indicating the class of @p number

*/

TRIO_PUBLIC int

trio_fpclassify

TRIO_ARGS1((number),

	   double number)

{

  int dummy;

  return trio_fpclassify_and_signbit(number, &dummy);

}

#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)\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));

  printf("PInf: %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%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));

  printf("NInf: %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%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));

# 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)\n",

	 my_nan,

	 ((unsigned char *)&my_nan)[0],