#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
#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)
#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
#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
#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
#if defined(TRIO_FUNC_NZERO)
# if defined(TRIO_IEEE_754)
# define TRIO_NZERO_IEEE_754
# else
# define TRIO_NZERO_FALLBACK
# endif
#endif
#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
#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
#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
#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)
#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)
static TRIO_CONST unsigned char ieee_754_exponent_mask[] = {
0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
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)
static TRIO_CONST unsigned char ieee_754_sign_mask[] = {
0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
#endif
#if defined(TRIO_NZERO_IEEE_754)
static TRIO_CONST unsigned char ieee_754_negzero_array[] = {
0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
#endif
#if defined(TRIO_PINF_IEEE_754)
static TRIO_CONST unsigned char ieee_754_infinity_array[] = {
0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
#endif
#if defined(TRIO_NAN_IEEE_754)
static TRIO_CONST unsigned char ieee_754_qnan_array[] = {
0x7F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
#endif
#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
#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
#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
#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;
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
#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)
unsigned int mask;
mask = _control87(0, 0);
# endif
switch (_fpclass(number)) {
case _FPCLASS_QNAN:
case _FPCLASS_SNAN:
*is_negative = TRIO_FALSE;
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)
(void)_control87(mask, MCW_PC);
# endif
return result;
}
#endif
#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)
{
switch (fpclassify(number)) {
case FP_QNAN:
case FP_SNAN:
*is_negative = TRIO_FALSE;
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
#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)
{
# 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;
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
#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)
return isnan(number);
# endif
# if defined(TRIO_INTERNAL_ISNAN_IEEE_754)
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)
int status;
double integral, fraction;
# if defined(TRIO_PLATFORM_UNIX)
void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN);
# endif
status = (
((TRIO_VOLATILE double)number != (TRIO_VOLATILE double)number) ||
((number != 0.0) &&
(fraction = modf(number, &integral),
integral == fraction)));
# if defined(TRIO_PLATFORM_UNIX)
signal(SIGFPE, signal_handler);
# endif
return status;
# endif
}
#endif
#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)
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)
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
#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)
{
#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)
int rc;
if (number == 0.0) {
# if defined(TRIO_IEEE_754)
*is_negative = internal_is_negative(number);
# else
*is_negative = TRIO_FALSE;
# 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
#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
#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
#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
#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
#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
#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
#if defined(TRIO_FUNC_PINF)
TRIO_PUBLIC_NAN double
trio_pinf(TRIO_NOARGS)
{
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 defined(TRIO_PLATFORM_UNIX)
void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN);
# endif
pinf_value = HUGE_VAL;
if (HUGE_VAL == DBL_MAX) {
pinf_value += HUGE_VAL;
}
# if defined(TRIO_PLATFORM_UNIX)
signal(SIGFPE, signal_handler);
# endif
# endif
}
return pinf_value;
}
#endif
#if defined(TRIO_FUNC_NINF)
TRIO_PUBLIC_NAN double
trio_ninf(TRIO_NOARGS)
{
static double ninf_value = 0.0;
if (ninf_value == 0.0) {
ninf_value = -trio_pinf();
}
return ninf_value;
}
#endif
#if defined(TRIO_FUNC_NAN)
TRIO_PUBLIC_NAN double
trio_nan(TRIO_NOARGS)
{
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)
# 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
#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