text: /*************************************************************************
   *
   * $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)])
  
  static TRIO_CONST double internalEndianMagic = 7.949928895127363e-275;
  
  /* 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)
  {
    /* avoid static function not used not used warning */
    (void)trio_is_negative;
    (void)trio_is_special_quantity;
  {
  #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],
           ((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));
    
    return 0;
  }
  #endif
  