round_toward_infinity = 2,
round_toward_neg_infinity = 3
};
-
+
+enum float_denorm_style {
+ denorm_indeterminate = -1,
+ denorm_absent = 0,
+ denorm_present = 1
+};
// Base class for all specializations of numeric_limits.
-template <class Number>
-class __numeric_limits_base {
+template <class __number>
+class _Numeric_limits_base {
public:
static const bool is_specialized = false;
- static Number min() __STL_NOTHROW { return Number(); }
- static Number max() __STL_NOTHROW { return Number(); }
+ static __number min() __STL_NOTHROW { return __number(); }
+ static __number max() __STL_NOTHROW { return __number(); }
static const int digits = 0;
static const int digits10 = 0;
static const int radix = 0;
- static Number epsilon() __STL_NOTHROW { return Number(); }
- static Number round_error() __STL_NOTHROW { return Number(); }
+ static __number epsilon() __STL_NOTHROW { return __number(); }
+ static __number round_error() __STL_NOTHROW { return __number(); }
static const int min_exponent = 0;
static const int min_exponent10 = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
- static const bool has_denorm = false;
+ static const float_denorm_style has_denorm = denorm_absent;
static const 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(); }
+ 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(); }
static const bool is_iec559 = false;
static const bool is_bounded = false;
};
#define __declare_numeric_base_member(__type, __mem) \
-template <class Number> \
- const __type __numeric_limits_base<Number>:: __mem
+template <class __number> \
+ const __type _Numeric_limits_base<__number>:: __mem
__declare_numeric_base_member(bool, is_specialized);
__declare_numeric_base_member(int, digits);
__declare_numeric_base_member(bool, has_infinity);
__declare_numeric_base_member(bool, has_quiet_NaN);
__declare_numeric_base_member(bool, has_signaling_NaN);
-__declare_numeric_base_member(bool, has_denorm);
+__declare_numeric_base_member(float_denorm_style, has_denorm);
__declare_numeric_base_member(bool, has_denorm_loss);
__declare_numeric_base_member(bool, is_iec559);
__declare_numeric_base_member(bool, is_bounded);
// Base class for integers.
-template <class __Int,
- __Int IMin,
- __Int IMax,
- int IDigits = -1>
-class __integer_limits : public __numeric_limits_base<__Int>
+template <class _Int,
+ _Int __imin,
+ _Int __imax,
+ int __idigits = -1>
+class _Integer_limits : public _Numeric_limits_base<_Int>
{
public:
static const bool is_specialized = true;
- static __Int min() __STL_NOTHROW { return IMin; }
- static __Int max() __STL_NOTHROW { return IMax; }
+ static _Int min() __STL_NOTHROW { return __imin; }
+ static _Int max() __STL_NOTHROW { return __imax; }
static const int digits =
- (IDigits < 0) ? sizeof(__Int) * CHAR_BIT - (IMin == 0 ? 0 : 1) : IDigits;
+ (__idigits < 0) ? sizeof(_Int) * CHAR_BIT - (__imin == 0 ? 0 : 1)
+ : __idigits;
static const int digits10 = (digits * 301) / 1000;
// log 2 = 0.301029995664...
- static const bool is_signed = IMin != 0;
+ static const bool is_signed = __imin != 0;
static const bool is_integer = true;
static const bool is_exact = true;
static const int radix = 2;
};
#define __declare_integer_limits_member(__type, __mem) \
-template <class __Int, __Int IMin, __Int IMax, int IDigits> \
- const __type __integer_limits<__Int, IMin, IMax, IDigits>:: __mem
+template <class _Int, _Int __imin, _Int __imax, int __idigits> \
+ const __type _Integer_limits<_Int, __imin, __imax, __idigits>:: __mem
__declare_integer_limits_member(bool, is_specialized);
__declare_integer_limits_member(int, digits);
#undef __declare_integer_limits_member
// Base class for floating-point numbers.
-template <class Number,
- int FDigits, int FDigits10,
- int FMinExp, int FMaxExp,
- int FMinExp10, int FMaxExp10,
- unsigned int FInfinityWord,
- unsigned int FQNaNWord, unsigned int FSNaNWord,
- bool FIsIEC559,
- float_round_style FRoundStyle>
-class __floating_limits : public __numeric_limits_base<Number>
+template <class __number,
+ int __Digits, int __Digits10,
+ int __MinExp, int __MaxExp,
+ int __MinExp10, int __MaxExp10,
+ unsigned int __InfinityWord,
+ unsigned int __QNaNWord, unsigned int __SNaNWord,
+ bool __IsIEC559,
+ float_round_style __RoundStyle>
+class _Floating_limits : public _Numeric_limits_base<__number>
{
public:
static const bool is_specialized = true;
- static const int digits = FDigits;
- static const int digits10 = FDigits10;
+ static const int digits = __Digits;
+ static const int digits10 = __Digits10;
static const bool is_signed = true;
static const int radix = 2;
- static const int min_exponent = FMinExp;
- static const int max_exponent = FMaxExp;
- static const int min_exponent10 = FMinExp10;
- static const int max_exponent10 = FMaxExp10;
+ static const int min_exponent = __MinExp;
+ static const int max_exponent = __MaxExp;
+ static const int min_exponent10 = __MinExp10;
+ static const int max_exponent10 = __MaxExp10;
static const bool has_infinity = true;
static const bool has_quiet_NaN = true;
static const bool has_signaling_NaN = true;
- static const bool has_denorm = false;
+ static const float_denorm_style has_denorm = denorm_indeterminate;
static const bool has_denorm_loss = false;
- static Number infinity() __STL_NOTHROW {
- static unsigned int inf[sizeof(Number) / sizeof(int)] = { FInfinityWord };
- return *reinterpret_cast<Number*>(&inf);
+ static __number infinity() __STL_NOTHROW {
+ static unsigned int _S_inf[sizeof(__number) / sizeof(int)] =
+ { __InfinityWord };
+ return *reinterpret_cast<__number*>(&_S_inf);
}
- static Number quiet_NaN() __STL_NOTHROW {
- static unsigned int nan[sizeof(Number) / sizeof(int)] = { FQNaNWord };
- return *reinterpret_cast<Number*>(&nan);
+ static __number quiet_NaN() __STL_NOTHROW {
+ static unsigned int _S_nan[sizeof(__number) / sizeof(int)] =
+ { __QNaNWord };
+ return *reinterpret_cast<__number*>(&_S_nan);
}
- static Number signaling_NaN() __STL_NOTHROW {
- static unsigned int nan[sizeof(Number) / sizeof(int)] = { FSNaNWord };
- return *reinterpret_cast<Number*>(&nan);
+ static __number signaling_NaN() __STL_NOTHROW {
+ static unsigned int _S_nan[sizeof(__number) / sizeof(int)] =
+ { __SNaNWord };
+ return *reinterpret_cast<__number*>(&_S_nan);
}
- static const bool is_iec559 = FIsIEC559;
+ static const bool is_iec559 = __IsIEC559;
static const bool is_bounded = true;
static const bool traps = true;
static const bool tinyness_before = false;
- static const float_round_style round_style = FRoundStyle;
+ static const float_round_style round_style = __RoundStyle;
};
#define __declare_float_limits_member(__type, __mem) \
int __MnX, int __MxX, int __MnX10, int __MxX10, \
unsigned int __Inf, unsigned int __QNaN, unsigned int __SNaN, \
bool __IsIEEE, float_round_style __Sty> \
-const __type __floating_limits<__Num, __Dig, __Dig10, \
- __MnX, __MxX, __MnX10, __MxX10, \
- __Inf, __QNaN, __SNaN,__IsIEEE, __Sty>:: __mem
+const __type _Floating_limits<__Num, __Dig, __Dig10, \
+ __MnX, __MxX, __MnX10, __MxX10, \
+ __Inf, __QNaN, __SNaN,__IsIEEE, __Sty>:: __mem
__declare_float_limits_member(bool, is_specialized);
__declare_float_limits_member(int, digits);
__declare_float_limits_member(bool, has_infinity);
__declare_float_limits_member(bool, has_quiet_NaN);
__declare_float_limits_member(bool, has_signaling_NaN);
-__declare_float_limits_member(bool, has_denorm);
+__declare_float_limits_member(float_denorm_style, has_denorm);
__declare_float_limits_member(bool, has_denorm_loss);
__declare_float_limits_member(bool, is_iec559);
__declare_float_limits_member(bool, is_bounded);
// The unspecialized class.
template<class T>
-class numeric_limits : public __numeric_limits_base<T> {};
+class numeric_limits : public _Numeric_limits_base<T> {};
// Specializations for all built-in integral types.
-#ifndef __STL_NEED_BOOL
+#ifndef __STL_NO_BOOL
template<>
class numeric_limits<bool>
- : public __integer_limits<bool, false, true, 0>
+ : public _Integer_limits<bool, false, true, 0>
{};
-#endif /* __STL_NEED_BOOL */
+#endif /* __STL_NO_BOOL */
template<>
class numeric_limits<char>
- : public __integer_limits<char, CHAR_MIN, CHAR_MAX>
+ : public _Integer_limits<char, CHAR_MIN, CHAR_MAX>
{};
template<>
class numeric_limits<signed char>
- : public __integer_limits<signed char, SCHAR_MIN, SCHAR_MAX>
+ : public _Integer_limits<signed char, SCHAR_MIN, SCHAR_MAX>
{};
template<>
class numeric_limits<unsigned char>
- : public __integer_limits<unsigned char, 0, UCHAR_MAX>
+ : public _Integer_limits<unsigned char, 0, UCHAR_MAX>
{};
-#ifdef _WCHAR_T_IS_KEYWORD
+#ifdef __STL_HAS_WCHAR_T
template<>
class numeric_limits<wchar_t>
- : public __integer_limits<wchar_t, INT_MIN, INT_MAX>
+ : public _Integer_limits<wchar_t, INT_MIN, INT_MAX>
{};
#endif
template<>
class numeric_limits<short>
- : public __integer_limits<short, SHRT_MIN, SHRT_MAX>
+ : public _Integer_limits<short, SHRT_MIN, SHRT_MAX>
{};
template<>
class numeric_limits<unsigned short>
- : public __integer_limits<unsigned short, 0, USHRT_MAX>
+ : public _Integer_limits<unsigned short, 0, USHRT_MAX>
{};
template<>
class numeric_limits<int>
- : public __integer_limits<int, INT_MIN, INT_MAX>
+ : public _Integer_limits<int, INT_MIN, INT_MAX>
{};
template<>
class numeric_limits<unsigned int>
- : public __integer_limits<unsigned int, 0, UINT_MAX>
+ : public _Integer_limits<unsigned int, 0, UINT_MAX>
{};
template<>
class numeric_limits<long>
- : public __integer_limits<long, LONG_MIN, LONG_MAX>
+ : public _Integer_limits<long, LONG_MIN, LONG_MAX>
{};
template<>
class numeric_limits<unsigned long>
- : public __integer_limits<unsigned long, 0, ULONG_MAX>
+ : public _Integer_limits<unsigned long, 0, ULONG_MAX>
{};
-#if defined(_LONGLONG) && _SGIAPI
+#ifdef __STL_LONG_LONG
template<>
class numeric_limits<long long>
- : public __integer_limits<long long, LONGLONG_MIN, LONGLONG_MAX>
+ : public _Integer_limits<long long, LONGLONG_MIN, LONGLONG_MAX>
{};
template<>
class numeric_limits<unsigned long long>
- : public __integer_limits<unsigned long long, 0, ULONGLONG_MAX>
+ : public _Integer_limits<unsigned long long, 0, ULONGLONG_MAX>
{};
-#endif /* _LONGLONG && _SGIAPI */
+#endif /* __STL_LONG_LONG */
// Specializations for all built-in floating-point type.
template<> 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
- 0x7f800000u, // First word of +infinity
- 0x7f810000u, // First word of quiet NaN
- 0x7fc10000u, // First word of signaling NaN
- true, // conforms to iec559
- round_to_nearest>
+ : 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
+ 0x7f800000u, // First word of +infinity
+ 0x7f810000u, // First word of quiet NaN
+ 0x7fc10000u, // First word of signaling NaN
+ true, // conforms to iec559
+ round_to_nearest>
{
public:
static float min() __STL_NOTHROW { return FLT_MIN; }
};
template<> 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
- 0x7ff00000u, // First word of +infinity
- 0x7ff10000u, // First word of quiet NaN
- 0x7ff90000u, // First word of signaling NaN
- true, // conforms to iec559
- round_to_nearest>
+ : 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
+ 0x7ff00000u, // First word of +infinity
+ 0x7ff10000u, // First word of quiet NaN
+ 0x7ff90000u, // First word of signaling NaN
+ true, // conforms to iec559
+ round_to_nearest>
{
public:
static double min() __STL_NOTHROW { return DBL_MIN; }
};
template<> 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
- 0x7ff00000u, // First word of +infinity
- 0x7ff10000u, // First word of quiet NaN
- 0x7ff90000u, // First word of signaling NaN
- false, // Doesn't conform to iec559
- round_to_nearest>
+ : 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
+ 0x7ff00000u, // First word of +infinity
+ 0x7ff10000u, // First word of quiet NaN
+ 0x7ff90000u, // First word of signaling NaN
+ false, // Doesn't conform to iec559
+ round_to_nearest>
{
public:
static long double min() __STL_NOTHROW { return LDBL_MIN; }
OSDN Git Service
