538 lines
20 KiB
Plaintext
538 lines
20 KiB
Plaintext
/*
|
|
* Copyright (c) 1997
|
|
* Silicon Graphics Computer Systems, Inc.
|
|
*
|
|
* Permission to use, copy, modify, distribute and sell this software
|
|
* and its documentation for any purpose is hereby granted without fee,
|
|
* provided that the above copyright notice appear in all copies and
|
|
* that both that copyright notice and this permission notice appear
|
|
* in supporting documentation. Silicon Graphics makes no
|
|
* representations about the suitability of this software for any
|
|
* purpose. It is provided "as is" without express or implied warranty.
|
|
*/
|
|
|
|
/* NOTE: This is not portable code. Parts of numeric_limits<> are
|
|
* inherently machine-dependent. At present this file is suitable
|
|
* for the MIPS and ia32 architectures.
|
|
*/
|
|
|
|
#ifndef __SGI_CPP_LIMITS
|
|
#define __SGI_CPP_LIMITS
|
|
|
|
#include <limits.h>
|
|
#include <float.h>
|
|
#include <stl_config.h>
|
|
|
|
__STL_BEGIN_NAMESPACE
|
|
|
|
enum float_round_style {
|
|
round_indeterminate = -1,
|
|
round_toward_zero = 0,
|
|
round_to_nearest = 1,
|
|
round_toward_infinity = 2,
|
|
round_toward_neg_infinity = 3
|
|
};
|
|
|
|
enum float_denorm_style {
|
|
denorm_indeterminate = -1,
|
|
denorm_absent = 0,
|
|
denorm_present = 1
|
|
};
|
|
|
|
// The C++ standard (section 18.2.1) requires that some of the members of
|
|
// numeric_limits be static const data members that are given constant-
|
|
// initializers within the class declaration. On compilers where the
|
|
// __STL_STATIC_CONST_INIT_BUG macro is defined, it is impossible to write
|
|
// a standard-conforming numeric_limits class.
|
|
//
|
|
// There are two possible workarounds: either initialize the data
|
|
// members outside the class, or change them from data members to
|
|
// enums. Neither workaround is satisfactory: the former makes it
|
|
// impossible to use the data members in constant-expressions, and the
|
|
// latter means they have the wrong type and that it is impossible to
|
|
// take their addresses. We choose the former workaround.
|
|
|
|
#ifdef __STL_STATIC_CONST_INIT_BUG
|
|
# define __STL_DECLARE_LIMITS_MEMBER(__mem_type, __mem_name, __mem_value) \
|
|
enum { __mem_name = __mem_value }
|
|
#else /* __STL_STATIC_CONST_INIT_BUG */
|
|
# define __STL_DECLARE_LIMITS_MEMBER(__mem_type, __mem_name, __mem_value) \
|
|
static const __mem_type __mem_name = __mem_value
|
|
#endif /* __STL_STATIC_CONST_INIT_BUG */
|
|
|
|
// Base class for all specializations of numeric_limits.
|
|
|
|
template <class __number>
|
|
class _Numeric_limits_base {
|
|
public:
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, false);
|
|
|
|
static __number min() __STL_NOTHROW { return __number(); }
|
|
static __number max() __STL_NOTHROW { return __number(); }
|
|
|
|
__STL_DECLARE_LIMITS_MEMBER(int, digits, 0);
|
|
__STL_DECLARE_LIMITS_MEMBER(int, digits10, 0);
|
|
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, is_signed, false);
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, is_integer, false);
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, is_exact, false);
|
|
|
|
__STL_DECLARE_LIMITS_MEMBER(int, radix, 0);
|
|
|
|
static __number epsilon() __STL_NOTHROW { return __number(); }
|
|
static __number round_error() __STL_NOTHROW { return __number(); }
|
|
|
|
__STL_DECLARE_LIMITS_MEMBER(int, min_exponent, 0);
|
|
__STL_DECLARE_LIMITS_MEMBER(int, min_exponent10, 0);
|
|
__STL_DECLARE_LIMITS_MEMBER(int, max_exponent, 0);
|
|
__STL_DECLARE_LIMITS_MEMBER(int, max_exponent10, 0);
|
|
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, has_infinity, false);
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, has_quiet_NaN, false);
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, has_signaling_NaN, false);
|
|
__STL_DECLARE_LIMITS_MEMBER(float_denorm_style,
|
|
has_denorm,
|
|
denorm_absent);
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, has_denorm_loss, false);
|
|
|
|
static __number infinity() __STL_NOTHROW { return __number(); }
|
|
static __number quiet_NaN() __STL_NOTHROW { return __number(); }
|
|
static __number signaling_NaN() __STL_NOTHROW { return __number(); }
|
|
static __number denorm_min() __STL_NOTHROW { return __number(); }
|
|
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, is_iec559, false);
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, is_bounded, false);
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, is_modulo, false);
|
|
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, traps, false);
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, tinyness_before, false);
|
|
__STL_DECLARE_LIMITS_MEMBER(float_round_style,
|
|
round_style,
|
|
round_toward_zero);
|
|
};
|
|
|
|
#ifdef __STL_STATIC_CONST_INIT_BUG
|
|
# define __STL_DEFINE_NUMERIC_BASE_MEMBER(__type, __mem)
|
|
#else /* __STL_STATIC_CONST_INIT_BUG */
|
|
# define __STL_DEFINE_NUMERIC_BASE_MEMBER(__type, __mem) \
|
|
template <class __number> \
|
|
const __type _Numeric_limits_base<__number>:: __mem
|
|
#endif /* __STL_STATIC_CONST_INIT_BUG */
|
|
|
|
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, is_specialized);
|
|
__STL_DEFINE_NUMERIC_BASE_MEMBER(int, digits);
|
|
__STL_DEFINE_NUMERIC_BASE_MEMBER(int, digits10);
|
|
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, is_signed);
|
|
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, is_integer);
|
|
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, is_exact);
|
|
__STL_DEFINE_NUMERIC_BASE_MEMBER(int, radix);
|
|
__STL_DEFINE_NUMERIC_BASE_MEMBER(int, min_exponent);
|
|
__STL_DEFINE_NUMERIC_BASE_MEMBER(int, max_exponent);
|
|
__STL_DEFINE_NUMERIC_BASE_MEMBER(int, min_exponent10);
|
|
__STL_DEFINE_NUMERIC_BASE_MEMBER(int, max_exponent10);
|
|
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, has_infinity);
|
|
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, has_quiet_NaN);
|
|
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, has_signaling_NaN);
|
|
__STL_DEFINE_NUMERIC_BASE_MEMBER(float_denorm_style, has_denorm);
|
|
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, has_denorm_loss);
|
|
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, is_iec559);
|
|
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, is_bounded);
|
|
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, is_modulo);
|
|
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, traps);
|
|
__STL_DEFINE_NUMERIC_BASE_MEMBER(bool, tinyness_before);
|
|
__STL_DEFINE_NUMERIC_BASE_MEMBER(float_round_style, round_style);
|
|
|
|
|
|
// Base class for integers.
|
|
|
|
template <class _Int,
|
|
_Int __imin, _Int __imax,
|
|
int __idigits = -1, bool __ismod = true>
|
|
class _Integer_limits : public _Numeric_limits_base<_Int>
|
|
{
|
|
public:
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, true);
|
|
|
|
static _Int min() __STL_NOTHROW { return __imin; }
|
|
static _Int max() __STL_NOTHROW { return __imax; }
|
|
|
|
__STL_DECLARE_LIMITS_MEMBER(int,
|
|
digits,
|
|
(__idigits < 0) ? (int)(sizeof(_Int) * CHAR_BIT)
|
|
- (__imin == 0 ? 0 : 1)
|
|
: __idigits);
|
|
__STL_DECLARE_LIMITS_MEMBER(int, digits10, (digits * 301) / 1000);
|
|
// log 2 = 0.301029995664...
|
|
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, is_signed, __imin != 0);
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, is_integer, true);
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, is_exact, true);
|
|
__STL_DECLARE_LIMITS_MEMBER(int, radix, 2);
|
|
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, is_bounded, true);
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, is_modulo, __ismod);
|
|
};
|
|
|
|
#ifdef __STL_STATIC_CONST_INIT_BUG
|
|
# define __STL_DEFINE_INTEGER_LIMITS_MEMBER(__type, __mem)
|
|
#else /* __STL_STATIC_CONST_INIT_BUG */
|
|
# define __STL_DEFINE_INTEGER_LIMITS_MEMBER(__type, __mem) \
|
|
template <class _Int, _Int __imin, _Int __imax, int __idig, bool __ismod> \
|
|
const __type _Integer_limits<_Int, __imin, __imax, __idig, __ismod>::__mem
|
|
#endif /* __STL_STATIC_CONST_INIT_BUG */
|
|
|
|
__STL_DEFINE_INTEGER_LIMITS_MEMBER(bool, is_specialized);
|
|
__STL_DEFINE_INTEGER_LIMITS_MEMBER(int, digits);
|
|
__STL_DEFINE_INTEGER_LIMITS_MEMBER(int, digits10);
|
|
__STL_DEFINE_INTEGER_LIMITS_MEMBER(bool, is_signed);
|
|
__STL_DEFINE_INTEGER_LIMITS_MEMBER(bool, is_integer);
|
|
__STL_DEFINE_INTEGER_LIMITS_MEMBER(bool, is_exact);
|
|
__STL_DEFINE_INTEGER_LIMITS_MEMBER(int, radix);
|
|
__STL_DEFINE_INTEGER_LIMITS_MEMBER(bool, is_bounded);
|
|
__STL_DEFINE_INTEGER_LIMITS_MEMBER(bool, is_modulo);
|
|
|
|
|
|
// Base class for floating-point numbers.
|
|
template <class __number,
|
|
int __Digits, int __Digits10,
|
|
int __MinExp, int __MaxExp,
|
|
int __MinExp10, int __MaxExp10,
|
|
bool __IsIEC559,
|
|
float_round_style __RoundStyle>
|
|
class _Floating_limits : public _Numeric_limits_base<__number>
|
|
{
|
|
public:
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, true);
|
|
|
|
__STL_DECLARE_LIMITS_MEMBER(int, digits, __Digits);
|
|
__STL_DECLARE_LIMITS_MEMBER(int, digits10, __Digits10);
|
|
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, is_signed, true);
|
|
|
|
__STL_DECLARE_LIMITS_MEMBER(int, radix, 2);
|
|
|
|
__STL_DECLARE_LIMITS_MEMBER(int, min_exponent, __MinExp);
|
|
__STL_DECLARE_LIMITS_MEMBER(int, max_exponent, __MaxExp);
|
|
__STL_DECLARE_LIMITS_MEMBER(int, min_exponent10, __MinExp10);
|
|
__STL_DECLARE_LIMITS_MEMBER(int, max_exponent10, __MaxExp10);
|
|
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, has_infinity, true);
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, has_quiet_NaN, true);
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, has_signaling_NaN, true);
|
|
__STL_DECLARE_LIMITS_MEMBER(float_denorm_style,
|
|
has_denorm,
|
|
denorm_indeterminate);
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, has_denorm_loss, false);
|
|
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, is_iec559, __IsIEC559);
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, is_bounded, true);
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, traps, true);
|
|
__STL_DECLARE_LIMITS_MEMBER(bool, tinyness_before, false);
|
|
|
|
__STL_DECLARE_LIMITS_MEMBER(float_round_style, round_style, __RoundStyle);
|
|
};
|
|
|
|
#ifdef __STL_STATIC_CONST_INIT_BUG
|
|
# define __STL_DEFINE_FLOAT_LIMITS_MEMBER(__type, __mem)
|
|
#else /* __STL_STATIC_CONST_INIT_BUG */
|
|
# define __STL_DEFINE_FLOAT_LIMITS_MEMBER(__type, __mem) \
|
|
template <class __Num, int __Dig, int __Dig10, \
|
|
int __MnX, int __MxX, int __MnX10, int __MxX10, \
|
|
bool __IsIEEE, float_round_style __Sty> \
|
|
const __type _Floating_limits<__Num, __Dig, __Dig10, \
|
|
__MnX, __MxX, __MnX10, __MxX10, \
|
|
__IsIEEE, __Sty>:: __mem
|
|
#endif /* __STL_STATIC_CONST_INIT_BUG */
|
|
|
|
__STL_DEFINE_FLOAT_LIMITS_MEMBER(bool, is_specialized);
|
|
__STL_DEFINE_FLOAT_LIMITS_MEMBER(int, digits);
|
|
__STL_DEFINE_FLOAT_LIMITS_MEMBER(int, digits10);
|
|
__STL_DEFINE_FLOAT_LIMITS_MEMBER(bool, is_signed);
|
|
__STL_DEFINE_FLOAT_LIMITS_MEMBER(int, radix);
|
|
__STL_DEFINE_FLOAT_LIMITS_MEMBER(int, min_exponent);
|
|
__STL_DEFINE_FLOAT_LIMITS_MEMBER(int, max_exponent);
|
|
__STL_DEFINE_FLOAT_LIMITS_MEMBER(int, min_exponent10);
|
|
__STL_DEFINE_FLOAT_LIMITS_MEMBER(int, max_exponent10);
|
|
__STL_DEFINE_FLOAT_LIMITS_MEMBER(bool, has_infinity);
|
|
__STL_DEFINE_FLOAT_LIMITS_MEMBER(bool, has_quiet_NaN);
|
|
__STL_DEFINE_FLOAT_LIMITS_MEMBER(bool, has_signaling_NaN);
|
|
__STL_DEFINE_FLOAT_LIMITS_MEMBER(float_denorm_style, has_denorm);
|
|
__STL_DEFINE_FLOAT_LIMITS_MEMBER(bool, has_denorm_loss);
|
|
__STL_DEFINE_FLOAT_LIMITS_MEMBER(bool, is_iec559);
|
|
__STL_DEFINE_FLOAT_LIMITS_MEMBER(bool, is_bounded);
|
|
__STL_DEFINE_FLOAT_LIMITS_MEMBER(bool, traps);
|
|
__STL_DEFINE_FLOAT_LIMITS_MEMBER(bool, tinyness_before);
|
|
__STL_DEFINE_FLOAT_LIMITS_MEMBER(float_round_style, round_style);
|
|
|
|
|
|
#undef __STL_DECLARE_NUMERIC_LIMITS_MEMBER
|
|
#undef __STL_DEFINE_NUMERIC_BASE_MEMBER
|
|
#undef __STL_DEFINE_INTEGER_LIMITS_MEMBER
|
|
#undef __STL_DEFINE_FLOAT_LIMITS_MEMBER
|
|
|
|
// Class numeric_limits
|
|
|
|
// The unspecialized class.
|
|
|
|
template<class _Tp>
|
|
class numeric_limits : public _Numeric_limits_base<_Tp> {};
|
|
|
|
// Specializations for all built-in integral types.
|
|
|
|
#ifndef __STL_NO_BOOL
|
|
|
|
__STL_TEMPLATE_NULL
|
|
class numeric_limits<bool>
|
|
: public _Integer_limits<bool, false, true, 1, false>
|
|
{};
|
|
|
|
#endif /* __STL_NO_BOOL */
|
|
|
|
__STL_TEMPLATE_NULL
|
|
class numeric_limits<char>
|
|
: public _Integer_limits<char, CHAR_MIN, CHAR_MAX>
|
|
{};
|
|
|
|
__STL_TEMPLATE_NULL
|
|
class numeric_limits<signed char>
|
|
: public _Integer_limits<signed char, SCHAR_MIN, SCHAR_MAX>
|
|
{};
|
|
|
|
__STL_TEMPLATE_NULL
|
|
class numeric_limits<unsigned char>
|
|
: public _Integer_limits<unsigned char, 0, UCHAR_MAX>
|
|
{};
|
|
|
|
#ifdef __STL_HAS_WCHAR_T
|
|
|
|
__STL_TEMPLATE_NULL
|
|
class numeric_limits<wchar_t>
|
|
: public _Integer_limits<wchar_t, INT_MIN, INT_MAX>
|
|
{};
|
|
|
|
#endif
|
|
|
|
__STL_TEMPLATE_NULL
|
|
class numeric_limits<short>
|
|
: public _Integer_limits<short, SHRT_MIN, SHRT_MAX>
|
|
{};
|
|
|
|
__STL_TEMPLATE_NULL
|
|
class numeric_limits<unsigned short>
|
|
: public _Integer_limits<unsigned short, 0, USHRT_MAX>
|
|
{};
|
|
|
|
__STL_TEMPLATE_NULL
|
|
class numeric_limits<int>
|
|
: public _Integer_limits<int, INT_MIN, INT_MAX>
|
|
{};
|
|
|
|
__STL_TEMPLATE_NULL
|
|
class numeric_limits<unsigned int>
|
|
: public _Integer_limits<unsigned int, 0, UINT_MAX>
|
|
{};
|
|
|
|
__STL_TEMPLATE_NULL
|
|
class numeric_limits<long>
|
|
: public _Integer_limits<long, LONG_MIN, LONG_MAX>
|
|
{};
|
|
|
|
__STL_TEMPLATE_NULL
|
|
class numeric_limits<unsigned long>
|
|
: public _Integer_limits<unsigned long, 0, ULONG_MAX>
|
|
{};
|
|
|
|
#ifdef __STL_LONG_LONG
|
|
|
|
// Some compilers have long long, but don't define the
|
|
// LONGLONG_MIN and LONGLONG_MAX macros in limits.h. This
|
|
// assumes that long long is 64 bits.
|
|
#if !defined(LONGLONG_MIN) && !defined(LONGLONG_MAX) \
|
|
&& !defined(ULONGLONG_MAX)
|
|
|
|
#define ULONGLONG_MAX 0xffffffffffffffffLLU
|
|
#define LONGLONG_MAX 0x7fffffffffffffffLL
|
|
#define LONGLONG_MIN (-LONGLONG_MAX - 1LL)
|
|
|
|
#endif
|
|
|
|
__STL_TEMPLATE_NULL
|
|
class numeric_limits<long long>
|
|
: public _Integer_limits<long long, LONGLONG_MIN, LONGLONG_MAX>
|
|
{};
|
|
|
|
__STL_TEMPLATE_NULL
|
|
class numeric_limits<unsigned long long>
|
|
: public _Integer_limits<unsigned long long, 0, ULONGLONG_MAX>
|
|
{};
|
|
|
|
#endif /* __STL_LONG_LONG */
|
|
|
|
// Specializations for all built-in floating-point type.
|
|
|
|
__STL_TEMPLATE_NULL class numeric_limits<float>
|
|
: public _Floating_limits<float,
|
|
FLT_MANT_DIG, // Binary digits of precision
|
|
FLT_DIG, // Decimal digits of precision
|
|
FLT_MIN_EXP, // Minimum exponent
|
|
FLT_MAX_EXP, // Maximum exponent
|
|
FLT_MIN_10_EXP, // Minimum base 10 exponent
|
|
FLT_MAX_10_EXP, // Maximum base 10 exponent
|
|
true, // conforms to iec559
|
|
round_to_nearest>
|
|
{
|
|
public:
|
|
static float min() __STL_NOTHROW { return FLT_MIN; }
|
|
static float denorm_min() __STL_NOTHROW { return FLT_MIN; }
|
|
static float max() __STL_NOTHROW { return FLT_MAX; }
|
|
static float epsilon() __STL_NOTHROW { return FLT_EPSILON; }
|
|
static float round_error() __STL_NOTHROW { return 0.5f; } // Units: ulps.
|
|
static float infinity() __STL_NOTHROW;
|
|
static float quiet_NaN() __STL_NOTHROW;
|
|
static float signaling_NaN() __STL_NOTHROW;
|
|
};
|
|
|
|
__STL_TEMPLATE_NULL class numeric_limits<double>
|
|
: public _Floating_limits<double,
|
|
DBL_MANT_DIG, // Binary digits of precision
|
|
DBL_DIG, // Decimal digits of precision
|
|
DBL_MIN_EXP, // Minimum exponent
|
|
DBL_MAX_EXP, // Maximum exponent
|
|
DBL_MIN_10_EXP, // Minimum base 10 exponent
|
|
DBL_MAX_10_EXP, // Maximum base 10 exponent
|
|
true, // conforms to iec559
|
|
round_to_nearest>
|
|
{
|
|
public:
|
|
static double min() __STL_NOTHROW { return DBL_MIN; }
|
|
static double denorm_min() __STL_NOTHROW { return DBL_MIN; }
|
|
static double max() __STL_NOTHROW { return DBL_MAX; }
|
|
static double epsilon() __STL_NOTHROW { return DBL_EPSILON; }
|
|
static double round_error() __STL_NOTHROW { return 0.5; } // Units: ulps.
|
|
static double infinity() __STL_NOTHROW;
|
|
static double quiet_NaN() __STL_NOTHROW;
|
|
static double signaling_NaN() __STL_NOTHROW;
|
|
};
|
|
|
|
__STL_TEMPLATE_NULL class numeric_limits<long double>
|
|
: public _Floating_limits<long double,
|
|
LDBL_MANT_DIG, // Binary digits of precision
|
|
LDBL_DIG, // Decimal digits of precision
|
|
LDBL_MIN_EXP, // Minimum exponent
|
|
LDBL_MAX_EXP, // Maximum exponent
|
|
LDBL_MIN_10_EXP,// Minimum base 10 exponent
|
|
LDBL_MAX_10_EXP,// Maximum base 10 exponent
|
|
false, // Doesn't conform to iec559
|
|
round_to_nearest>
|
|
{
|
|
public:
|
|
static long double min() __STL_NOTHROW { return LDBL_MIN; }
|
|
static long double denorm_min() __STL_NOTHROW { return LDBL_MIN; }
|
|
static long double max() __STL_NOTHROW { return LDBL_MAX; }
|
|
static long double epsilon() __STL_NOTHROW { return LDBL_EPSILON; }
|
|
static long double round_error() __STL_NOTHROW { return 4; } // Units: ulps.
|
|
static long double infinity() __STL_NOTHROW;
|
|
static long double quiet_NaN() __STL_NOTHROW;
|
|
static long double signaling_NaN() __STL_NOTHROW;
|
|
};
|
|
|
|
// We write special values (Inf and NaN) as bit patterns and
|
|
// cast the the appropriate floating-point types.
|
|
|
|
#if defined(_MIPSEB)
|
|
// Big-endian MIPS. float is 32 bits, double 64, long double 128.
|
|
|
|
#define _Define_float(__f, __h, __l) \
|
|
inline float numeric_limits<float>::__f() __STL_NOTHROW { \
|
|
static const unsigned short __x[2] = { __h, __l }; \
|
|
return *reinterpret_cast<const float*>(__x); }
|
|
#define _Define_double(__f, __h, __l) \
|
|
inline double numeric_limits<double>::__f() __STL_NOTHROW { \
|
|
static const unsigned short __x[4] = { __h, __l }; \
|
|
return *reinterpret_cast<const double*>(__x); }
|
|
#define _Define_ldouble(__f, __h, __l) \
|
|
inline long double numeric_limits<long double>::__f() __STL_NOTHROW { \
|
|
static const unsigned short __x[8] = { __h, __l }; \
|
|
return *reinterpret_cast<const long double*>(__x); }
|
|
|
|
_Define_float(infinity, 0x7f80, 0)
|
|
_Define_float(quiet_NaN, 0x7f81, 0)
|
|
_Define_float(signaling_NaN, 0x7fc1, 0)
|
|
|
|
_Define_double(infinity, 0x7ff0, 0)
|
|
_Define_double(quiet_NaN, 0x7ff1, 0)
|
|
_Define_double(signaling_NaN, 0x7ff9, 0)
|
|
|
|
_Define_ldouble(infinity, 0x7ff0, 0)
|
|
_Define_ldouble(quiet_NaN, 0x7ff1, 0)
|
|
_Define_ldouble(signaling_NaN, 0x7ff9, 0)
|
|
|
|
#elif defined(__i386) || defined(_M_IX86)
|
|
// Little-endian ia32. float is 32 bits, double 64, long double 80.
|
|
|
|
#define _Define_float(__f, __h, __l) \
|
|
inline float numeric_limits<float>::__f() __STL_NOTHROW { \
|
|
static const unsigned short __x[2] = { __l, __h }; \
|
|
return *reinterpret_cast<const float*>(__x); }
|
|
#define _Define_double(__f, __h, __l) \
|
|
inline double numeric_limits<double>::__f() __STL_NOTHROW { \
|
|
static const unsigned short __x[4] = { 0, 0, __l, __h }; \
|
|
return *reinterpret_cast<const double*>(__x); }
|
|
#define _Define_ldouble(__f, __h, __l) \
|
|
inline long double numeric_limits<long double>::__f() __STL_NOTHROW { \
|
|
static const unsigned short __x[5] = { 0, 0, 0, __l, __h }; \
|
|
return *reinterpret_cast<const long double*>(__x); }
|
|
|
|
_Define_float(infinity, 0x7f80, 0)
|
|
_Define_float(quiet_NaN, 0x7fa0, 0)
|
|
_Define_float(signaling_NaN, 0x7fc0, 0)
|
|
|
|
_Define_double(infinity, 0x7ff0, 0)
|
|
_Define_double(quiet_NaN, 0x7ff4, 0)
|
|
_Define_double(signaling_NaN, 0x7ff8, 0)
|
|
|
|
_Define_ldouble(infinity, 0x7fff, 0x8000)
|
|
_Define_ldouble(quiet_NaN, 0x7fff, 0xa000)
|
|
_Define_ldouble(signaling_NaN, 0x7fff, 0xc000)
|
|
|
|
#else
|
|
|
|
/* This is an architecture we don't know how to handle. Return some
|
|
obviously wrong values. */
|
|
|
|
#define _Define_float(__f) \
|
|
inline float numeric_limits<float>::__f() __STL_NOTHROW { \
|
|
return 0; }
|
|
#define _Define_double(__f) \
|
|
inline double numeric_limits<double>::__f() __STL_NOTHROW { \
|
|
return 0; }
|
|
#define _Define_ldouble(__f) \
|
|
inline long double numeric_limits<long double>::__f() __STL_NOTHROW { \
|
|
return 0; }
|
|
|
|
_Define_float(infinity)
|
|
_Define_float(quiet_NaN)
|
|
_Define_float(signaling_NaN)
|
|
|
|
_Define_double(infinity)
|
|
_Define_double(quiet_NaN)
|
|
_Define_double(signaling_NaN)
|
|
|
|
_Define_ldouble(infinity)
|
|
_Define_ldouble(quiet_NaN)
|
|
_Define_ldouble(signaling_NaN)
|
|
|
|
#endif
|
|
|
|
#undef _Define_float
|
|
#undef _Define_double
|
|
#undef _Define_ldouble
|
|
|
|
__STL_END_NAMESPACE
|
|
|
|
#endif /* __SGI_CPP_LIMITS */
|
|
|
|
// Local Variables:
|
|
// mode:C++
|
|
// End:
|