SpecialQuantities

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

Functions
TRIO_PUBLIC double	trio_nzero (TRIO_NOARGS)
TRIO_PUBLIC double	trio_pinf (TRIO_NOARGS)
TRIO_PUBLIC double	trio_ninf (TRIO_NOARGS)
TRIO_PUBLIC double	trio_nan (TRIO_NOARGS)
TRIO_PUBLIC int trio_isnan	TRIO_ARGS1 ((number), double number)
TRIO_PUBLIC int trio_fpclassify_and_signbit	TRIO_ARGS2 ((number, is_negative), double number, int *is_negative)

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

Detailed Description

Macro Definition Documentation

TRIO_FALSE

#define TRIO_FALSE   (0 == 1)

Definition at line 74 of file trionan.c.

TRIO_TRUE

#define TRIO_TRUE   (1 == 1)

Definition at line 73 of file trionan.c.

Function Documentation

TRIO_ARGS1()

TRIO_PUBLIC int trio_signbit TRIO_ARGS1	(	(number)	,
		double	number
	)

Check for NaN.

Parameters

number

An arbitrary floating-point number.

Returns

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

Check for infinity.

Parameters

number

An arbitrary floating-point number.

Returns

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

Examine the sign of a number.

Parameters

number

An arbitrary floating-point number.

Returns

Boolean value indicating whether or not the number has the sign bit set (i.e. is negative).

Definition at line 372 of file trionan.c.

{
#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
}

TRIO_ARGS2()

TRIO_PUBLIC int trio_fpclassify_and_signbit TRIO_ARGS2	(	(number, is_negative)	,
		double	number,
		int *	is_negative
	)

Definition at line 561 of file trionan.c.

{
#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
}

trio_nan()

TRIO_PUBLIC double trio_nan

(

TRIO_NOARGS

)

Generate NaN.

Returns

Floating-point representation of NaN.

Definition at line 323 of file trionan.c.

{
  /* Cache the result */
  static double result = 0.0;
 
  if (result == 0.0) {
 
#if defined(TRIO_COMPILER_SUPPORTS_C99) && (!defined(__REACTOS__) || !defined(__clang__))
    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;
}

trio_ninf()

TRIO_PUBLIC double trio_ninf

(

TRIO_NOARGS

)

Generate negative infinity.

Returns

Floating-point value of negative infinity.

Definition at line 302 of file trionan.c.

{
  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;
}

trio_nzero()

TRIO_PUBLIC double trio_nzero

(

TRIO_NOARGS

)

Generate negative zero.

Returns

Floating-point representation of negative zero.

Definition at line 241 of file trionan.c.

{
#if defined(USE_IEEE_754)
  return trio_make_double(ieee_754_negzero_array);
#else
  TRIO_VOLATILE double zero = 0.0;
 
  return -zero;
#endif
}

trio_pinf()

TRIO_PUBLIC double trio_pinf

(

TRIO_NOARGS

)

Generate positive infinity.

Returns

Floating-point representation of positive infinity.

Definition at line 258 of file trionan.c.

{
  /* 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;
}

Referenced by trio_nan(), and trio_ninf().

Variable Documentation

rcsid

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

static

Definition at line 115 of file trionan.c.