18.numeric.special.float.cpp

Go to the documentation of this file.

 
#include <rw/_defs.h>
 
#if defined (__IBMCPP__) && !defined (_RWSTD_NO_IMPLICIT_INCLUSION)
   // disable implicit inclusion to work around 
   // a limitation in IBM's VisualAge 5.0.2.0 (see PR#26959) 
#  define _RWSTD_NO_IMPLICIT_INCLUSION 
#endif 
 
 
#include <limits>
 
#include <climits>
#include <cstdlib>   // for atof
#include <cstdio>    // for sprintf
 
#include <float.h>   // for constants, MSVC _fpclass, _isinf, _isnan
#include <math.h>    // for fpclassify, isinf, isnan
 
#ifndef _RWSTD_NO_IEEEFP_H
#  include <ieeefp.h>   // for fpclass, isnan
#endif   // _RWSTD_NO_IEEEFP_H
 
#include <rw_driver.h>
 
// use FLT_ROUNDS if available, otherwise (e.g., when <ieeefp.h> must
// be #included to bring the macro in), fall back on our own macro
#ifndef FLT_ROUNDS
#  define FLT_ROUNDS   _RWSTD_FLT_ROUNDS
#endif   // FLT_ROUNDS
 
 
// determine whether the architecture is little-endian or big-endian
static const int endian_test = 1;
 
// extern works around a SunPro 5.4 bug (PR #28124)
extern const bool big_endian = !*(const char*)&endian_test;
 
 
volatile float  flt_zero  = 0;
volatile double dbl_zero  = 0;
 
#ifndef _RWSTD_NO_LONG_DOUBLE
 
volatile long double ldbl_zero = 0;
 
#endif   // _RWSTD_NO_LONG_DOUBLE
 
 
#if defined (_MSC_VER)
 
const char* fpclass_name (int fpc)
{
    switch (fpc) {
    case _FPCLASS_SNAN: return "_FPCLASS_SNAN";
    case _FPCLASS_QNAN: return "_FPCLASS_QNAN";
    case _FPCLASS_NINF: return "_FPCLASS_NINF";
    case _FPCLASS_NN:   return "_FPCLASS_NN";
    case _FPCLASS_ND:   return "_FPCLASS_ND";
    case _FPCLASS_NZ:   return "_FPCLASS_NZ";
    case _FPCLASS_PZ:   return "_FPCLASS_PZ";
    case _FPCLASS_PD:   return "_FPCLASS_PD";
    case _FPCLASS_PN:   return "_FPCLASS_PN";
    case _FPCLASS_PINF: return "_FPCLASS_PINF";
    }
 
    static char buf [16];
    std::sprintf (buf, "%#x", fpc);
    return buf;
}
 
#elif defined (_RWSTD_OS_SUNOS)
 
const char* fpclass_name (fpclass_t fpc)
{
    switch (fpc) {
    case FP_SNAN:    return "FP_SNAN";
    case FP_QNAN:    return "FP_QNAN";
    case FP_NINF:    return "FP_NINF";
    case FP_PINF:    return "FP_PINF";
    case FP_NDENORM: return "FP_NDENORM";
    case FP_PDENORM: return "FP_PDENORM";
    case FP_NZERO:   return "FP_NZERO";
    case FP_PZERO:   return "FP_PZERO";
    case FP_NNORM:   return "FP_NNORM";
    case FP_PNORM:   return "FP_PNORM";
 
    }
 
    static char buf [16];
    std::sprintf (buf, "%#x", fpc);
    return buf;
}
 
#elif defined (fpclassify)   // C99 classification
 
const char* fpclass_name (int fpc)
{
    switch (fpc) {
#  ifdef FP_INFINITE
    case FP_INFINITE:  return "FP_INFINITE";
#  endif
#  ifdef FP_NAN
    case FP_NAN:       return "FP_NAN";
#  endif
#  ifdef FP_NORMAL
    case FP_NORMAL:    return "FP_NORMAL";
#  endif
#  ifdef FP_SUBNORMAL
    case FP_SUBNORMAL: return "FP_SUBNORMAL";
#  endif
#  ifdef FP_ZERO
    case FP_ZERO:      return "FP_ZERO";
#  endif
    default: break;
    }
 
    static char buf [16];
    std::sprintf (buf, "%#x", fpc);
    return buf;
}
 
#endif
 
 
#ifdef _MSC_VER
 
inline int _fpclass (float val)
{
    long lval = *_RWSTD_REINTERPRET_CAST (long*, &val);
 
    if (0 == (lval & 0x7FFFFFFF))
        return lval ? _FPCLASS_NZ : _FPCLASS_PZ;
 
    if (0 == (lval & 0x7F800000))
        return (lval & 0x80000000) ? _FPCLASS_ND : _FPCLASS_PD;
 
    if (0x7F800000 == (lval & 0x7FFFFFFF))
        return (lval & 0x80000000) ? _FPCLASS_NINF : _FPCLASS_PINF;
 
    if (0x7F800000 == (lval & 0x7F800000))
        return (lval & 0x00400000) ? _FPCLASS_QNAN : _FPCLASS_SNAN;
 
    return (lval & 0x80000000) ? _FPCLASS_NN : _FPCLASS_PN;
}
 
inline int _fpclass (long double val)
{
    return _fpclass (double (val));
}
 
#endif
 
template <class FloatT>
void test_infinity (FloatT inf, FloatT max, const char *tname)
{
    if (!std::numeric_limits<FloatT>::traps) {
 
        // infinity must be even greater than the maximum value
        rw_assert (inf > max, 0, __LINE__,
                   "numeric_limits<%s>::infinity() > "
                   "numeric_limits<%s>::max()", tname, tname);
 
        // multiplying infinity by anything other than 0.0 yields infinity
        rw_assert (inf == inf * inf, 0, __LINE__,
                   "numeric_limits<%s>::infinity()", tname);
    }
 
#ifdef _MSC_VER
 
    const int fpc = _fpclass (inf);
    rw_assert (_FPCLASS_PINF == fpc, 0, __LINE__,
               "_fpclass (numeric_limits<%s>::infinity()) == "
               "%d (_FPCLASS_PINF), got %d (%s)",
               tname, _FPCLASS_PINF, fpc, fpclass_name (fpc));
 
#elif defined (_RWSTD_OS_SUNOS)
 
    rw_assert (!finite (inf), 0, __LINE__,
               "finite (numeric_limits<%s>::infinity()) == 0, "
               "got non-zero", tname);
 
    const fpclass_t fpc = fpclass (inf);
    rw_assert (FP_PINF == fpclass (inf), 0, __LINE__,
               "fpclass (numeric_limits<%s>::infinity()) == %d (FP_PINF), "
               "got %d (%s)", tname, FP_PINF, fpc, fpclass_name (fpc));
 
#else
 
#  ifdef isinf
 
    rw_assert (isinf (inf), 0, __LINE__,
               "isinf (numeric_limits<%s>::infinity()) != 0, got 0",
               tname);
 
#  endif   // isinf
 
#  ifdef fpclassify
 
    const int fpc = fpclassify (inf);
    rw_assert (FP_INFINITE == fpc, 0, __LINE__,
               "fpclassify(numeric_limits<%s>::infinity()) == "
               "%d (FP_INFINITE), got %d (%s)", tname,
               FP_INFINITE, fpc, fpclass_name (fpc));
 
#  endif   // fpclassify
 
#endif
 
}
 
 
template <class FloatT>
void test_quiet_NaN (FloatT qnan, FloatT qnan2, const char *tname)
{
    // NAN never compares equal to self or any other number
    rw_assert (!(qnan == qnan2), 0, __LINE__,
               "numeric_limits<%s>::quiet_NaN() != "
               "numeric_limits<%1$s>::quiet_NaN()",
               tname);
 
    const FloatT inf = std::numeric_limits<FloatT>::infinity ();
 
    rw_assert (!(qnan == inf), 0, __LINE__,
               "numeric_limits<%s>::quiet_NaN() != "
               "numeric_limits<%1$s>::infinity()",
               tname);
 
    rw_assert (!(qnan == -inf), 0, __LINE__,
               "numeric_limits<%s>::quiet_NaN() != "
               "-numeric_limits<%1$s>::infinity()",
               tname);
 
#ifdef _MSC_VER
 
    rw_assert (0 != _isnan (qnan), 0, __LINE__,
               "_isnan(numeric_limits<%s>::quiet_NaN()) != 0, got 0",
               tname);
 
    const int fpc = _fpclass (qnan);
    rw_assert (_FPCLASS_QNAN == fpc, 0, __LINE__,
               "_fpclass(numeric_limits<%s>::quiet_NaN()) == "
               "%d (_FPCLASS_QNAN), got %d (%s)",
               tname, _FPCLASS_QNAN, fpc, fpclass_name (fpc));
 
#elif defined (_RWSTD_OS_SUNOS)
 
    rw_assert (!finite (qnan), 0, __LINE__,
               "finite(numeric_limits<%s>::quiet_NaN()) == 0, "
               "got non-zero", tname);
 
    const fpclass_t fpc = fpclass (qnan);
    rw_assert (FP_QNAN == fpc, 0, __LINE__,
               "fpclass(numeric_limits<%s>::infinity()) == %d (FP_QNAN), "
               "got %d (%s)", tname, FP_QNAN, fpc, fpclass_name (fpc));
 
#else
 
#  ifdef isnan
 
    rw_assert (0 != isnan (qnan), 0, __LINE__,
               "isnan(numeric_limits<%s>::quiet_NaN()) != 0, got 0",
               tname);
 
#  endif   // isnan
 
#  ifdef fpclassify
 
    const int fpc = fpclassify (qnan);
    rw_assert (FP_NAN == fpc, 0, __LINE__,
               "fpclassify(numeric_limits<%s>::quiet_NaN()) == "
               "%d (FP_NAN), got %d (%s)", tname,
               FP_NAN, fpc, fpclass_name (fpc));
 
#  endif   // fpclassify
 
#endif
 
}
 
 
template <class FloatT>
void test_signaling_NaN (FloatT snan, FloatT snan2, const char *tname)
{
    // NAN never compares equal to self or any other number
    rw_assert (!(snan == snan2), 0, __LINE__,
               "numeric_limits<%s>::signaling_NaN() != "
               "numeric_limits<%1$s>::signaling_NaN()",
               tname);
 
    const FloatT inf = std::numeric_limits<FloatT>::infinity ();
 
    rw_assert (!(snan == inf), 0, __LINE__,
               "numeric_limits<%s>::signaling_NaN() != "
               "numeric_limits<%1$s>::infinity()",
                tname);
 
    rw_assert (!(snan == -inf), 0, __LINE__,
               "numeric_limits<%s>::signaling_NaN() != "
               "-numeric_limits<%1$s>::infinity()",
               tname);
 
#ifdef _MSC_VER
 
    rw_assert (0 != _isnan (snan), 0, __LINE__,
               "_isnan (numeric_limits<%s>::signaling_NaN()) != 0, got 0",
               tname);
 
    const int fpc = _fpclass (snan);
    rw_assert (_FPCLASS_SNAN == fpc, 0, __LINE__,
               "_fpclass(numeric_limits<%s>::signaling_NaN()) == "
               "%d (_FPCLASS_SNAN), got %d (%s)",
               tname, _FPCLASS_SNAN, fpc, fpclass_name (fpc));
 
#elif defined (_RWSTD_OS_SUNOS)
 
    rw_assert (!finite (snan), 0, __LINE__,
               "finite(numeric_limits<%s>::signaling_NaN()) == 0, "
               "got non-zero", tname);
 
    const fpclass_t fpc = fpclass (snan);
    rw_assert (FP_SNAN == fpc, 0, __LINE__,
               "fpclass(numeric_limits<%s>::signaling_NaN()) == %d "
               "(FP_SNAN), got %d (%s)", tname,
               FP_SNAN, fpc, fpclass_name (fpc));
#else
 
#  ifdef isnan
 
    rw_assert (0 != isnan (snan), 0, __LINE__,
               "isnan(numeric_limits<%s>::signaling_NaN()) != 0, got 0",
               tname);
 
#  endif   // isnan
 
#  ifdef fpclassify
 
    const int fpc = fpclassify (snan);
    rw_assert (FP_NAN == fpc, 0, __LINE__,
               "fpclassify(numeric_limits<%s>::signaling_NaN()) == "
               "%d (FP_NAN), got %d (%s)", tname,
               FP_NAN, fpc, fpclass_name (fpc));
 
#  endif   // fpclassify
 
#endif
 
}
 
 
template <class T>
struct limits_values;
 
#if    defined (__alpha) && !defined (__linux__) \
    && !defined (__VMS) && defined (__DECCXX) && defined (__PURE_CNAME)
 
extern "C" unsigned int read_rnd ();
#define read_rnd   read_rnd
 
#endif   // __alpha && !__linux__ && !__VMS && __DECCXX && __PURE_CNAME
 
 
_RWSTD_SPECIALIZED_CLASS
struct limits_values<float>
{
    static bool is_specialized () { return true; }
 
    static float (min) () { return FLT_MIN; }
    static float (max) () { return FLT_MAX; }
 
    static int digits () { return FLT_MANT_DIG; }
    static int digits10 () { return FLT_DIG; }
    static bool is_signed () { return  0.0f - 1.0f < 0.0f; }
    static bool is_integer () { return false; }
    static bool is_exact () { return false; }
    static int radix () { return FLT_RADIX; }
 
    static float epsilon () { return FLT_EPSILON; }
 
    static float round_error () {
 
#ifdef __osf__
        int rounding = FLT_ROUNDS;
#  ifdef read_rnd
        if (rounding == std::round_indeterminate)
            rounding = _RWSTD_STATIC_CAST (int, read_rnd ());
#  endif   //  read_rnd
 
        switch (rounding) {
        case std::round_toward_zero:
        case std::round_toward_infinity:
        case std::round_toward_neg_infinity:
            return 1.0f;
        default:
            return 0.5f;
        }
#else
        return 0.5f;
#endif
 
    }
 
    static int min_exponent () { return FLT_MIN_EXP; }
    static int min_exponent10 () { return FLT_MIN_10_EXP; }
    static int max_exponent () { return FLT_MAX_EXP; }
    static int max_exponent10 () { return FLT_MAX_10_EXP; }
 
    static bool has_infinity () {
        return true;
    }
 
    static bool has_quiet_NaN () {
 
#if defined (NAN)
        // 7.12, p5 of C99:
        // The macro NAN is defined if and only if the implementation
        // supports quiet NaNs for the float type. It expands to a
        // constant expression of type float representing a quiet NaN.
        return true;
#else
        return true;
#endif
 
    }
 
 
    static bool has_signaling_NaN () {
 
#if defined (FLT_SNAN)
        return true;
#else
#  ifndef _RWSTD_NO_SIGNALING_NAN
        return true;
#  else
        return false;
#  endif   // _RWSTD_NO_SIGNALING_NAN
#endif
 
    }
 
 
    static std::float_denorm_style has_denorm () {
 
#if defined (_AIX)       \
    || defined (__hpux)  \
    || defined (__osf__) \
    || defined (_MSC_VER)
        return std::denorm_present;
#else
        return std::denorm_indeterminate;
#endif
    }
 
 
    static bool has_denorm_loss () { return false; }
 
 
    static float infinity () {
 
#if defined (FLT_INFINITY)
        return FLT_INFINITY;
#elif defined (_RWSTD_NO_DBL_TRAPS)
 
        float inf = float (std::atof ("inf"));
        if (inf > FLT_MAX)
            return inf;
 
        inf = 1.0f / flt_zero;
 
        return inf;
 
#else
        const union {
            char bits [sizeof (float)];
            float val;
        } val = {
            _RWSTD_FLT_INF_BITS
        };
            
        return val.val;
#endif
 
    }
 
 
    static float quiet_NaN () {
 
#if defined (NAN)
        return NAN;
#elif defined (FLT_QNAN)
        return FLT_QNAN;
#elif defined (_RWSTD_NO_DBL_TRAPS)
 
        float nan = float (std::atof ("nan"));
 
        if (nan != float (std::atof ("nan")))
            return nan;
 
        nan = float (dbl_zero / flt_zero);
 
        return nan;
 
#else
        const union {
            char bits [sizeof (float)];
            float val;
        } val = {
            _RWSTD_FLT_QNAN_BITS
        };
            
        return val.val;
 
#endif
 
    }
 
 
    static float signaling_NaN () {
 
#if defined (FLT_SNAN)
        return FLT_SNAN;
#elif defined (_RWSTD_NO_DBL_TRAPS)
 
        union {
            float val;
            char bits [sizeof (float)];
        } snan;
 
        snan.val = infinity ();
 
#  ifdef __hpux
 
        if (big_endian) {
            snan.bits [sizeof snan.val - 2] = '\xc0';
        }
        else {
            snan.bits [1] = '\xc0';
        }
 
#  else   // if !defined (__hpux)
 
        // convert infinity into a signaling NAN
        // (toggle any bit in signifcand)
        if (big_endian) {
            snan.bits [sizeof snan.val - 1] |= 1;
        }
        else {
            snan.bits [0] |= 1;
        }
 
#  endif   // __hpux
 
        return snan.val;
 
#else
 
        const union {
            char bits [sizeof (float)];
            float val;
        } val = {
            _RWSTD_FLT_SNAN_BITS
        };
            
        return val.val;
 
#endif
 
    }
 
 
    static float denorm_min () {
 
#if defined (__FLT_DENORM_MIN__)
        // gcc 3.x predefined macro
        return __FLT_DENORM_MIN__;
#elif defined (__osf__)
        const unsigned short pos_denorm [] = { 0x0001, 0x0000 };
        return *_RWSTD_REINTERPRET_CAST (const float*, pos_denorm);
#else
        // assume IEEE 754
 
        static union {
            float denorm_min;
            char denorm_min_bits [sizeof (float)];
        } u;
 
        if (big_endian)
            u.denorm_min_bits [sizeof (float) - 1] = '\001';
        else
            u.denorm_min_bits [0] = '\001';
 
        return u.denorm_min;
 
#endif
 
    }
 
 
    static bool is_iec559 () {
 
#if defined (__osf__)
 
        // Tru64 UNIX with Compaq C++: IEC 559 support is enabled
        // by specifying the -ieee flag on the compiler command line
 
#  ifdef _IEEE_FP
        return true;
#  else
        return false;
#  endif   //  _IEEE_FP
#else
        return true;
#endif
 
    }
 
 
    static bool is_bounded () { return true; }
    static bool is_modulo () { return false; }
 
    static bool traps () { return true; }
    static bool tinyness_before () { return false; }
 
 
    static std::float_round_style round_style () {
 
#if defined (_AIX)
        return std::round_to_nearest;
#else
        return _RWSTD_STATIC_CAST (std::float_round_style, FLT_ROUNDS);
#endif
    }
 
};
 
 
_RWSTD_SPECIALIZED_CLASS
struct limits_values<double>
{
    static bool is_specialized () { return true; }
 
    static double (min)() { return DBL_MIN; }
    static double (max)() { return DBL_MAX; }
 
    static int digits () { return DBL_MANT_DIG; }
    static int digits10 () { return DBL_DIG; }
    static bool is_signed () { return  0.0 - 1.0 < 0.0; }
    static bool is_integer () { return false; }
    static bool is_exact () { return false; }
    static int radix () { return FLT_RADIX; }
 
    static double epsilon () { return DBL_EPSILON; }
 
 
    static double round_error () {
 
#ifdef __osf__
        int rounding = FLT_ROUNDS;
#  ifdef read_rnd
        if (rounding == std::round_indeterminate)
            rounding = _RWSTD_STATIC_CAST (int, read_rnd ());
#  endif   //  read_rnd
        switch (rounding) {
        case std::round_toward_zero:
        case std::round_toward_infinity:
        case std::round_toward_neg_infinity:
            return 1.0;
        default:
            return 0.5;
        }
#else
        return 0.5;
#endif
 
    }
 
 
    static int min_exponent () { return DBL_MIN_EXP; }
    static int min_exponent10 () { return DBL_MIN_10_EXP; }
    static int max_exponent () { return DBL_MAX_EXP; }
    static int max_exponent10 () { return DBL_MAX_10_EXP; }
 
 
    static bool has_infinity () {
        return true;
    }
 
 
    static bool has_quiet_NaN () {
        return true;
    }
 
 
    static bool has_signaling_NaN () {
 
#if defined DBL_SNAN
        return true;
#else
#  ifndef _RWSTD_NO_SIGNALING_NAN
        return true;
#  else
        return false;
#  endif   // _RWSTD_NO_SIGNALING_NAN
#endif
 
    }
 
 
    static std::float_denorm_style has_denorm () {
#if defined (_AIX)       \
    || defined (__hpux)  \
    || defined (__osf__) \
    || defined (_MSC_VER)
        return std::denorm_present;
#else
        return std::denorm_indeterminate;
#endif
    }
 
 
    static bool has_denorm_loss () { return false; }
 
 
    static double infinity () {
 
#if defined (DBL_INFINITY)
        return DBL_INFINITY;
#elif defined (_RWSTD_NO_DBL_TRAPS)
 
        double inf = std::atof ("inf");
        if (inf > DBL_MAX)
            return inf;
 
        inf = 1.0 / dbl_zero;
 
        return inf;
 
#else
        const union {
            char bits [sizeof (double)];
            double val;
        } val = {
            _RWSTD_DBL_INF_BITS
        };
            
        return val.val;
#endif
 
    }
 
 
    static double quiet_NaN () {
 
#if defined (NAN)
        return NAN;
#elif defined (DBL_QNAN)
        return DBL_QNAN;
#elif defined (_RWSTD_NO_DBL_TRAPS)
 
        double nan = std::atof ("nan");
 
        if (nan != std::atof ("nan"))
            return nan;
 
        nan = flt_zero / dbl_zero;
 
        return nan;
 
#else
        const union {
            char bits [sizeof (double)];
            double val;
        } val = {
            _RWSTD_DBL_QNAN_BITS
        };
            
        return val.val;
 
#endif
 
    }
 
 
    static double signaling_NaN () {
 
#if defined (DBL_SNAN)
        return DBL_SNAN;
#elif defined (_RWSTD_NO_DBL_TRAPS)
 
        union {
            double val;
            char bits [sizeof (double)];
        } snan;
 
        snan.val = infinity ();
 
#  ifdef __hpux
 
        if (big_endian) {
            snan.bits [sizeof snan.val - 2] = '\xf8';
        }
        else {
            snan.bits [1] = '\xf8';
        }
 
#  else   // if !defined (__hpux)
 
        // convert infinity into a signaling NAN
        // (toggle any bit in signifcand)
        if (big_endian) {
            snan.bits [sizeof snan.val - 1] |= 1;
        }
        else {
            snan.bits [0] |= 1;
        }
 
#  endif   // __hpux
 
        return snan.val;
 
#else
 
        const union {
            char bits [sizeof (double)];
            double val;
        } val = {
            _RWSTD_DBL_SNAN_BITS
        };
            
        return val.val;
 
#endif
 
    }
 
 
    static double denorm_min () {
 
#if defined (__DBL_DENORM_MIN__)
        // gcc 3.x predefined macro
        return __DBL_DENORM_MIN__;
#elif defined (__osf__)
        const unsigned short pos_denorm [] = { 0x0001, 0x0000 };
        return *_RWSTD_REINTERPRET_CAST (const double*, pos_denorm);
#else
        // assume IEEE 754
 
        static union {
            double denorm_min;
            char denorm_min_bits [sizeof (double)];
        } u;
 
        if (big_endian)
            u.denorm_min_bits [sizeof (double) - 1] = '\001';
        else
            u.denorm_min_bits [0] = '\001';
 
        return u.denorm_min;
 
#endif
 
    }
 
 
    static bool is_iec559 () {
 
#if defined (__osf__)
#  ifdef _IEEE_FP
        return true;
#  else
        return false;
#  endif   //  _IEEE_FP
#else
        return true;
#endif
 
    }
 
 
    static bool is_bounded () { return true; }
    static bool is_modulo () { return false; }
 
    static bool traps () { return true; }
    static bool tinyness_before () { return false; }
 
 
    static std::float_round_style round_style () {
 
#if defined (_AIX)
        return std::round_to_nearest;
#else
        return _RWSTD_STATIC_CAST (std::float_round_style, FLT_ROUNDS);
#endif
 
    }
 
};
 
 
_RWSTD_SPECIALIZED_CLASS
struct limits_values<long double>
{
    static bool is_specialized () { return true; }
 
    static long double (min)() { return LDBL_MIN; }
    static long double (max)() { return LDBL_MAX; }
 
    static int digits () { return LDBL_MANT_DIG; }
    static int digits10 () { return LDBL_DIG; }
    static bool is_signed () { return  0.0 - 1.0 < 0.0; }
    static bool is_integer () { return false; }
    static bool is_exact () { return false; }
    static int radix () { return FLT_RADIX; }
 
    static long double epsilon () { return LDBL_EPSILON; }
 
    static long double round_error () {
 
#ifdef __osf__
        int rounding = FLT_ROUNDS;
#  ifdef read_rnd
        if (rounding == std::round_indeterminate)
            rounding = _RWSTD_STATIC_CAST (int, read_rnd ());
#  endif   //  read_rnd
        switch (rounding) {
        case std::round_toward_zero:
        case std::round_toward_infinity:
        case std::round_toward_neg_infinity:
            return 1.0;
        default:
            return 0.5;
        }
#else
        return 0.5;
#endif
 
    }
 
    static int min_exponent () { return LDBL_MIN_EXP; }
    static int min_exponent10 () { return LDBL_MIN_10_EXP; }
    static int max_exponent () { return LDBL_MAX_EXP; }
    static int max_exponent10 () { return LDBL_MAX_10_EXP; }
 
    static bool has_infinity () {
        return true;
    }
 
    static bool has_quiet_NaN () {
        return true;
    }
 
 
    static bool has_signaling_NaN () {
 
#if defined (LDBL_SNAN)
        return true;
#else
#  ifndef _RWSTD_NO_SIGNALING_NAN
        return true;
#  else
        return false;
#  endif   // _RWSTD_NO_SIGNALING_NAN
#endif
 
    }
 
 
    static std::float_denorm_style has_denorm () {
#if defined (_AIX)       \
    || defined (__hpux)  \
    || defined (__osf__) \
    || defined (_MSC_VER)
        return std::denorm_present;
#else
        return std::denorm_indeterminate;
#endif
    }
 
    static bool has_denorm_loss () { return false; }
 
 
    static long double infinity () {
 
#if defined (LDBL_INFINITY)
        return LDBL_INFINITY;
#elif defined (_RWSTD_NO_DBL_TRAPS)
 
        long double inf = std::atof ("inf");
        if (inf > LDBL_MAX)
            return inf;
 
        inf = (long double)1.0 / ldbl_zero;
 
        return inf;
 
#else
        const union {
            char bits [sizeof (long double)];
            long double val;
        } val = {
            _RWSTD_LDBL_INF_BITS
        };
            
        return val.val;
#endif
 
    }
 
 
    static long double quiet_NaN () {
 
#if defined (NAN)
        return NAN;
#elif defined (LDBL_QNAN)
        return LDBL_QNAN;
#elif defined (_RWSTD_NO_DBL_TRAPS)
 
        long double nan = std::atof ("nan");
 
        if (nan != (long double)std::atof ("nan"))
            return nan;
 
        nan = ldbl_zero / ldbl_zero;
 
        return nan;
 
#else
        const union {
            char bits [sizeof (long double)];
            long double val;
        } val = {
            _RWSTD_LDBL_QNAN_BITS
        };
            
        return val.val;
 
#endif
 
    }
 
 
    static long double signaling_NaN () {
 
#if defined (LDBL_SNAN)
        return LDBL_SNAN;
#elif defined (_RWSTD_NO_DBL_TRAPS)
 
        union {
            long double val;
            char bits [sizeof (long double)];
        } snan;
 
        snan.val = infinity ();
 
#  ifdef __hpux
 
        if (big_endian) {
            snan.bits [sizeof snan.val - 3] = '\x80';
        }
        else {
            snan.bits [2] = '\x80';
        }
 
#  else   // if !defined (__hpux)
 
        // convert infinity into a signaling NAN
        // (toggle any bit in signifcand)
        if (big_endian) {
            snan.bits [sizeof snan.val - 1] |= 1;
        }
        else {
            snan.bits [0] |= 1;
        }
 
#  endif   // __hpux
 
        return snan.val;
 
#else
 
        const union {
            char bits [sizeof (long double)];
            long double val;
        } val = {
            _RWSTD_LDBL_SNAN_BITS
        };
            
        return val.val;
 
#endif
 
    }
 
 
    static long double denorm_min () {
 
#if defined (__LDBL_DENORM_MIN__)
        // gcc 3.x predefined macro
        return __LDBL_DENORM_MIN__;
#elif defined (__osf__)
        const unsigned short pos_denorm [] = { 0x0001, 0x0000 };
        return *_RWSTD_REINTERPRET_CAST (const long double*, pos_denorm);
#else
        // assume IEEE 754
 
        static union {
            long double denorm_min;
            char denorm_min_bits [sizeof (long double)];
        } u;
 
        if (big_endian)
            u.denorm_min_bits [sizeof (long double) - 1] = '\001';
        else
            u.denorm_min_bits [0] = '\001';
 
        return u.denorm_min;
#endif
 
    }
 
 
    static bool is_iec559 () {
#if defined (__osf__)
#  ifdef _IEEE_FP
        return true;
#  else
        return false;
#  endif   //  _IEEE_FP
#else
        return true;
#endif
    }
 
    static bool is_bounded () { return true; }
    static bool is_modulo () { return false; }
 
    static bool traps () { return true; }
    static bool tinyness_before () { return false; }
 
    static std::float_round_style round_style () {
#if defined (_AIX)
        return std::round_to_nearest;
#else
        return _RWSTD_STATIC_CAST (std::float_round_style, FLT_ROUNDS);
#endif
    }
};
 
 
template <class FloatT>
void test_limits (FloatT, const char *tname, const char *fmt)
{
    typedef std::numeric_limits<FloatT> FLim;
    typedef limits_values<FloatT>       FVal;
 
    // self-test: assert that endianness is correctly computed
#if defined (__alpha)
    rw_warn (!big_endian, 0, __LINE__, "alpha is typically little-endian");
#elif defined (_AIX)
    rw_warn (big_endian, 0, __LINE__, "AIX is big-endian");
#elif defined (__hpux) && defined (_BIG_ENDIAN)
    rw_warn (big_endian, 0, __LINE__, "HP-UX is big-endian");
#elif defined (__i386__)
    rw_warn (!big_endian, 0, __LINE__, "Intel x86 is little-endian");
#elif defined (__sparc)
    rw_warn (big_endian, 0, __LINE__, "SPARC is big-endian");
#elif defined (_WIN64)
    rw_warn (!big_endian, 0, __LINE__, "WIN64 is little-endian");
#elif defined (_WIN32)
    rw_warn (!big_endian, 0, __LINE__, "WIN32 is little-endian");
#endif
 
#ifndef _RWSTD_NO_STATIC_CONST_MEMBER_INIT
 
#  if !defined (__EDG__) || __EDG_VERSION__ > 245
#    define CHECK_CONST(const_int)   \
         enum { e = const_int };     \
         (void)&const_int
#  else   // if EDG eccp < 3.0
    // working around an EDG eccp 2.4x ICE (not in 3.0)
#    define CHECK_CONST(const_int)                        \
         switch (const_int) { case const_int: break; };   \
         (void)&const_int
#  endif   // __EDG__
#else
   // static const integral members must be usable
   //  as constant integral expressions
#  define CHECK_CONST(const_int)      enum { e = const_int }
#endif   // _RWSTD_NO_STATIC_CONST_MEMBER_INIT
 
 
// compare against a computed value
#define VERIFY_DATA(member) do {                                        \
        /* verify that member is a constant integral expression */      \
        CHECK_CONST (FLim::member);                                     \
        /* verify value */                                              \
        rw_assert (FLim::member == FVal::member (), 0, __LINE__,        \
                   "numeric_limits<%s>::" #member " == %i, got %i",     \
                   tname, FVal::member (), FLim::member);               \
    } while (0)
 
// compare against a constant
#define VERIFY_CONST(member, value) do {                                 \
        /* verify that member if a constant integral expression */       \
        CHECK_CONST (FLim::member);                                      \
        /* verify value */                                               \
        rw_assert (FLim::member == value, 0, __LINE__,                   \
                   "numeric_limits<%s>::" #member " == %i, got %i",      \
                   tname, FVal::member (), value);                       \
    } while (0)
 
// account for NaN != NaN
#define VERIFY_FUNCTION(member) do {                                       \
        /* verify function signature */                                    \
        FloatT (*pf)() _PTR_THROWS(()) = &FLim::member;                    \
        _RWSTD_UNUSED (pf);                                                \
        /* verify value */                                                 \
        rw_assert (   FLim::member () == FVal::member ()                   \
                   || (   FLim::member () != FLim::member ()               \
                       && FVal::member () != FVal::member ()),             \
                   0, __LINE__,                                            \
                   "numeric_limits<%s>::" #member "() == %{@}, got %{@}",  \
                   tname, fmt, FVal::member (), fmt, FLim::member ());     \
    } while (0)
 
#define VERIFY_SIGNATURE(member) do {                   \
        /* verify function signature */                 \
        FloatT (*pf)() _PTR_THROWS(()) = &FLim::member; \
        _RWSTD_UNUSED (pf);                             \
    } while (0)
 
#undef min
#undef max
 
    VERIFY_FUNCTION (min);           // 18.2.1.2, p1
    VERIFY_FUNCTION (max);           //           p4
    VERIFY_DATA (digits);            //           p6
    VERIFY_DATA (digits10);          //           p9
    VERIFY_DATA (is_signed);         //           p11
    VERIFY_DATA (is_integer);        //           p13
    VERIFY_DATA (is_exact);          //           p15
    VERIFY_DATA (radix);             //           p17
    
    VERIFY_FUNCTION (epsilon);       // 18.2.1.2, p19
    VERIFY_FUNCTION (round_error);   //           p22
 
    VERIFY_DATA (min_exponent);      // 18.2.1.2, p23
    VERIFY_DATA (min_exponent10);    //           p25
    VERIFY_DATA (max_exponent);      //           p27
    VERIFY_DATA (max_exponent10);    //           p29
 
    VERIFY_FUNCTION (infinity);      // 18.2.1.2, p42
 
    if (FLim::has_infinity)
        test_infinity (FLim::infinity (), FLim::max (), tname);
 
    if (std::numeric_limits<FloatT>::traps)   //  p45
        VERIFY_SIGNATURE (quiet_NaN);
    else {
        VERIFY_FUNCTION (quiet_NaN);
 
        if (FLim::has_quiet_NaN)
            test_quiet_NaN (FLim::quiet_NaN (),
                            FLim::quiet_NaN (), tname);
    }
    
    if (std::numeric_limits<FloatT>::traps)   //  p47
        VERIFY_SIGNATURE (signaling_NaN);
    else {
        VERIFY_FUNCTION (signaling_NaN);
 
        if (FLim::has_signaling_NaN) 
            test_signaling_NaN (FLim::signaling_NaN (),
                                FLim::signaling_NaN (), tname);
    }
 
    if (std::numeric_limits<FloatT>::traps) { //  p49
        // denorm min may trap (e.g., Tru64 UNIX on Alpha
        // with Compaq C++ without the -ieee compiler flag)
        VERIFY_SIGNATURE (denorm_min);
    }
    else {
        VERIFY_FUNCTION (denorm_min);
    }
 
#ifdef _MSC_VER
 
    if (sizeof (FloatT) > sizeof (float)) {
        // for doubles and long doubles only, verify that denorm_min
        // is properly classified
 
        const FloatT denorm_min = FLim::denorm_min ();
 
        const int fpc = _fpclass (double (denorm_min));
 
        rw_assert (_FPCLASS_PD == fpc, 0, __LINE__,
                   "_fpclass(numeric_limits<%s>::denorm_min()) == "
                   "%d (_FPCLASS_PD), got %d (%s)",
                   tname, _FPCLASS_PD, fpc, fpclass_name (fpc));
    }
 
#endif   // _MSC_VER
 
    VERIFY_DATA (is_iec559);         // 18.2.1.2, p52
    VERIFY_DATA (is_bounded);        //           p54
    VERIFY_DATA (is_modulo);         //           p56
 
    VERIFY_DATA (tinyness_before);   // 18.2.1.2, p61
    VERIFY_DATA (round_style);       //           p63
 
    if (!FLim::traps) {              // 18.2.1.2, p59
        // invalid floating point operations must not trap
 
        // IEEE 754 specifies that the following operations
        // return NaN unless they trap:
        //     1.   sqrt (n); n < 0
        //     2.   rem (x, 0.0), rem (inf, x)
        //     3.   0 * inf
        //     4.   0.0 / 0.0, inf / inf
        //     5.   inf - inf (when both inf have the same sign)
 
        // use a variable (not a literal) to prevent warnings
        volatile FloatT zero = 0;
 
        // compute infinity (division may trap)
        const FloatT inf = FLim::infinity ();
 
        FloatT nan = zero * inf;   // #3
        nan = zero / zero;         // #4a
        nan = inf / inf;           // #4b
        nan = inf - inf;           // #5
 
        _RWSTD_UNUSED (inf);
        _RWSTD_UNUSED (nan);
    }
 
    if (FLim::is_iec559) {
        // 18.2.1.2, p33
        VERIFY_CONST (has_infinity, true);
 
        // 18.2.1.2, p36
        VERIFY_CONST (has_quiet_NaN, true);
 
        // 18.2.1.2, p39
        VERIFY_CONST (has_signaling_NaN, true);
 
        // 18.2.1.2, p40 - 42
        VERIFY_DATA (has_denorm);
        VERIFY_DATA (has_denorm_loss);
    }
    else {
        // 18.2.1.2, p34 - 42
        VERIFY_DATA (has_quiet_NaN);
        VERIFY_DATA (has_signaling_NaN);
        VERIFY_DATA (has_denorm);
        VERIFY_DATA (has_denorm_loss);
    }
}
 
 
static int
run_test (int, char**)
{
#undef VERIFY_CONST
#define VERIFY_CONST(x, value) do {                     \
        enum { e = x };                                 \
        rw_assert (value == x, 0, __LINE__,             \
                   #x " == %d, got %d", value, x);      \
    } while (0)
 
    // verify values of constants in 18.2.1.3
    VERIFY_CONST (std::round_indeterminate,      -1);
    VERIFY_CONST (std::round_toward_zero,         0);
    VERIFY_CONST (std::round_to_nearest,          1);
    VERIFY_CONST (std::round_toward_infinity,     2);
    VERIFY_CONST (std::round_toward_neg_infinity, 3);
 
    // verify values of constants in 18.2.1.4
    VERIFY_CONST (std::denorm_indeterminate, std::float_denorm_style (-1));
    VERIFY_CONST (std::denorm_absent,        std::float_denorm_style (0));
    VERIFY_CONST (std::denorm_present,       std::float_denorm_style (1));
        
    test_limits (float (), "float", "%g");
    test_limits (double (), "double", "%g");
 
#ifndef _RWSTD_NO_LONG_DOUBLE
 
   // working around a SunPro 5.3 ICE (PR #25968)
#  if !defined (__SUNPRO_CC) || __SUNPRO_CC > 0x530
 
    const char fmt[] = "%" _RWSTD_LDBL_PRINTF_PREFIX "g";
    test_limits ((long double)0.0, "long double", fmt);
 
#  endif   // SunPro > 5.3
 
#endif   //_RWSTD_NO_LONG_DOUBLE
 
    return 0;
}
 
 
int main (int argc, char *argv[])
{
    // working around a bogus EDG eccp warning (see PR #25679)
    _RWSTD_UNUSED (big_endian);
 
    return rw_test (argc, argv, __FILE__,
                    "numeric.special",
                    "floating specializations",
                    run_test,
                    "",
                    (void*)0);
}