/home/ntakagi/work/STLport-5.1.5/stlport/stl/_limits.h Go to the documentation of this file. /* * Copyright (c) 1997 * Silicon Graphics Computer Systems, Inc. * * Copyright (c) 1999 * Boris Fomitchev * * This material is provided "as is", with absolutely no warranty expressed * or implied. Any use is at your own risk. * * Permission to use or copy this software for any purpose is hereby granted * without fee, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ /* NOTE: This may be not portable code. Parts of numeric_limits<> are * inherently machine-dependent. At present this file is suitable * for the MIPS, SPARC, Alpha and ia32 architectures. */ #ifndef _STLP_INTERNAL_LIMITS #define _STLP_INTERNAL_LIMITS #ifndef _STLP_CLIMITS # include <climits> #endif #ifndef _STLP_CFLOAT # include <cfloat> #endif #if defined (_STLP_HAS_WCHAR_T) && !defined (_STLP_INTERNAL_CWCHAR) # include <stl/_cwchar.h> #endif _STLP_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 }; _STLP_MOVE_TO_PRIV_NAMESPACE // Base class for all specializations of numeric_limits. template <class __number> class _Numeric_limits_base { public: static __number (_STLP_CALL min)() _STLP_NOTHROW { return __number(); } static __number (_STLP_CALL max)() _STLP_NOTHROW { return __number(); } #if defined ( _STLP_STATIC_CONST_INIT_BUG) enum { #else static const int #endif digits = 0, digits10 = 0, radix = 0, min_exponent = 0, min_exponent10 = 0, max_exponent = 0, max_exponent10 = 0 #if defined ( _STLP_STATIC_CONST_INIT_BUG) , has_denorm = denorm_absent, round_style = round_toward_zero, #else ; static const float_denorm_style has_denorm = denorm_absent; static const float_round_style round_style = round_toward_zero; static const bool #endif is_specialized = false, is_signed = false, is_integer = false, is_exact = false, has_infinity = false, has_quiet_NaN = false, has_signaling_NaN = false, has_denorm_loss = false, is_iec559 = false, is_bounded = false, is_modulo = false, traps = false, tinyness_before = false #if defined ( _STLP_STATIC_CONST_INIT_BUG) } #endif ; static __number _STLP_CALL epsilon() _STLP_NOTHROW { return __number(); } static __number _STLP_CALL round_error() _STLP_NOTHROW { return __number(); } static __number _STLP_CALL infinity() _STLP_NOTHROW { return __number(); } static __number _STLP_CALL quiet_NaN() _STLP_NOTHROW { return __number(); } static __number _STLP_CALL signaling_NaN() _STLP_NOTHROW { return __number(); } static __number _STLP_CALL denorm_min() _STLP_NOTHROW { return __number(); } }; // Base class for integers. #ifdef _STLP_LIMITED_DEFAULT_TEMPLATES # ifdef _STLP_LONG_LONG # define _STLP_LIMITS_MIN_TYPE _STLP_LONG_LONG # define _STLP_LIMITS_MAX_TYPE unsigned _STLP_LONG_LONG # else # define _STLP_LIMITS_MIN_TYPE long # define _STLP_LIMITS_MAX_TYPE unsigned long # endif #else # define _STLP_LIMITS_MIN_TYPE _Int # define _STLP_LIMITS_MAX_TYPE _Int #endif /* _STLP_LIMITED_DEFAULT_TEMPLATES */ template <class _Int, _STLP_LIMITS_MIN_TYPE __imin, _STLP_LIMITS_MAX_TYPE __imax, int __idigits, bool __ismod> class _Integer_limits : public _Numeric_limits_base<_Int> { public: static _Int (_STLP_CALL min) () _STLP_NOTHROW { return (_Int)__imin; } static _Int (_STLP_CALL max) () _STLP_NOTHROW { return (_Int)__imax; } #if defined (_STLP_STATIC_CONST_INIT_BUG) enum { #else static const int #endif digits = (__idigits < 0) ? ((int)((sizeof(_Int) * (CHAR_BIT))) - ((__imin == 0) ? 0 : 1)) : (__idigits), digits10 = (digits * 301UL) / 1000, radix = 2 #if !defined (_STLP_STATIC_CONST_INIT_BUG) ; static const bool #else , #endif is_specialized = true, is_signed = (__imin != 0), is_integer = true, is_exact = true, is_bounded = true, is_modulo = __ismod #if defined ( _STLP_STATIC_CONST_INIT_BUG) } #endif ; }; // 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: #if defined (_STLP_STATIC_CONST_INIT_BUG) enum { #else static const int #endif digits = __Digits, digits10 = __Digits10, radix = ( FLT_RADIX /* 2 */ ), min_exponent = __MinExp, max_exponent = __MaxExp, min_exponent10 = __MinExp10, max_exponent10 = __MaxExp10 #if defined (_STLP_STATIC_CONST_INIT_BUG) , has_denorm = denorm_indeterminate, round_style = __RoundStyle, #else ; static const float_denorm_style has_denorm = denorm_indeterminate; static const float_round_style round_style = __RoundStyle; static const bool #endif is_specialized = true, is_signed = true, //IEC 559 specify the floating point representation of //infinity, quiet and signaling Not a Number. Not supporting //it is consider as not being able to grant those values. #if (defined (_STLP_MSVC) && (_STLP_MSVC < 1300)) //MSVC 6 do not fully support IEC 599 but grant a good infinity value. has_infinity = true, #else has_infinity = __IsIEC559, #endif has_quiet_NaN = __IsIEC559, has_signaling_NaN = __IsIEC559, has_denorm_loss = false, is_iec559 = __IsIEC559, is_bounded = true, traps = true, tinyness_before= false #if defined (_STLP_STATIC_CONST_INIT_BUG) } #endif ; }; _STLP_MOVE_TO_STD_NAMESPACE // Class numeric_limits // The unspecialized class. template<class _Tp> class numeric_limits : public _STLP_PRIV _Numeric_limits_base<_Tp> {}; // Specializations for all built-in integral types. #if !defined (_STLP_NO_BOOL) _STLP_TEMPLATE_NULL class numeric_limits<bool> : public _STLP_PRIV _Integer_limits<bool, false, true, 1, false> {}; #endif /* _STLP_NO_BOOL */ _STLP_TEMPLATE_NULL class numeric_limits<char> : public _STLP_PRIV _Integer_limits<char, CHAR_MIN, CHAR_MAX, -1, true> {}; #if !defined (_STLP_NO_SIGNED_BUILTINS) _STLP_TEMPLATE_NULL class numeric_limits<signed char> : public _STLP_PRIV _Integer_limits<signed char, SCHAR_MIN, SCHAR_MAX, -1, true> {}; #endif _STLP_TEMPLATE_NULL class numeric_limits<unsigned char> : public _STLP_PRIV _Integer_limits<unsigned char, 0, UCHAR_MAX, -1, true> {}; #if !(defined (_STLP_NO_WCHAR_T) || defined (_STLP_WCHAR_T_IS_USHORT)) _STLP_TEMPLATE_NULL class numeric_limits<wchar_t> : public _STLP_PRIV _Integer_limits<wchar_t, WCHAR_MIN, WCHAR_MAX, -1, true> {}; #endif _STLP_TEMPLATE_NULL class numeric_limits<short> : public _STLP_PRIV _Integer_limits<short, SHRT_MIN, SHRT_MAX, -1, true> {}; _STLP_TEMPLATE_NULL class numeric_limits<unsigned short> : public _STLP_PRIV _Integer_limits<unsigned short, 0, USHRT_MAX, -1, true> {}; #if defined (__xlC__) && (__xlC__ == 0x500) # undef INT_MIN # define INT_MIN -2147483648 #endif _STLP_TEMPLATE_NULL class numeric_limits<int> : public _STLP_PRIV _Integer_limits<int, INT_MIN, INT_MAX, -1, true> {}; _STLP_TEMPLATE_NULL class numeric_limits<unsigned int> : public _STLP_PRIV _Integer_limits<unsigned int, 0, UINT_MAX, -1, true> {}; _STLP_TEMPLATE_NULL class numeric_limits<long> : public _STLP_PRIV _Integer_limits<long, LONG_MIN, LONG_MAX, -1, true> {}; _STLP_TEMPLATE_NULL class numeric_limits<unsigned long> : public _STLP_PRIV _Integer_limits<unsigned long, 0, ULONG_MAX, -1, true> {}; #if defined (_STLP_LONG_LONG) # if defined (_STLP_MSVC) || defined (__BORLANDC__) # define LONGLONG_MAX 0x7fffffffffffffffi64 # define LONGLONG_MIN (-LONGLONG_MAX-1i64) # define ULONGLONG_MAX 0xffffffffffffffffUi64 # else # ifndef LONGLONG_MAX # define LONGLONG_MAX 0x7fffffffffffffffLL # endif # ifndef LONGLONG_MIN # define LONGLONG_MIN (-LONGLONG_MAX-1LL) # endif # ifndef ULONGLONG_MAX # define ULONGLONG_MAX 0xffffffffffffffffULL # endif # endif # if !defined(__GNUC__) || (__GNUC__ == 2 && __GNUC_MINOR__ <= 96) _STLP_TEMPLATE_NULL class numeric_limits<_STLP_LONG_LONG> : public _STLP_PRIV _Integer_limits<_STLP_LONG_LONG, LONGLONG_MIN, LONGLONG_MAX, -1, true> {}; _STLP_TEMPLATE_NULL class numeric_limits<unsigned _STLP_LONG_LONG> : public _STLP_PRIV _Integer_limits<unsigned _STLP_LONG_LONG, 0, ULONGLONG_MAX, -1, true> {}; # else /* gcc 2.97 (after 2000-11-01), 2.98, 3.0 */ /* newest gcc has new mangling scheme, that has problem with generating name [instantiated] of template specialization like _Integer_limits<_STLP_LONG_LONG, LONGLONG_MIN, LONGLONG_MAX, -1, true> ~~~~~~~~~~~~ ~~~~~~~~~~~~ Below is code that solve this problem. - ptr */ _STLP_TEMPLATE_NULL class numeric_limits<_STLP_LONG_LONG> : public _STLP_PRIV _Numeric_limits_base<_STLP_LONG_LONG> { public: static _STLP_LONG_LONG (_STLP_CALL min) () _STLP_NOTHROW { return LONGLONG_MIN; } static _STLP_LONG_LONG (_STLP_CALL max) () _STLP_NOTHROW { return LONGLONG_MAX; } # if defined ( _STLP_STATIC_CONST_INIT_BUG) enum { # else static const int # endif digits = ((int)((sizeof(_STLP_LONG_LONG) * (CHAR_BIT))) - 1), digits10 = (digits * 301UL) / 1000, radix = 2 # if ! defined (_STLP_STATIC_CONST_INIT_BUG) ; static const bool # else , # endif is_specialized = true, is_signed = true, is_integer = true, is_exact = true, is_bounded = true, is_modulo = true # if defined (_STLP_STATIC_CONST_INIT_BUG) } # endif ; }; _STLP_TEMPLATE_NULL class numeric_limits<unsigned _STLP_LONG_LONG> : public _STLP_PRIV _Numeric_limits_base<unsigned _STLP_LONG_LONG> { public: static unsigned _STLP_LONG_LONG (_STLP_CALL min) () _STLP_NOTHROW { return 0ULL; } static unsigned _STLP_LONG_LONG (_STLP_CALL max) () _STLP_NOTHROW { return ULONGLONG_MAX; } # if defined (_STLP_STATIC_CONST_INIT_BUG) enum { # else static const int # endif digits = ((int)((sizeof(unsigned _STLP_LONG_LONG) * (CHAR_BIT)))), digits10 = (digits * 301UL) / 1000, radix = 2 # if ! defined (_STLP_STATIC_CONST_INIT_BUG) ; static const bool # else , # endif is_specialized = true, is_signed = false, is_integer = true, is_exact = true, is_bounded = true, is_modulo = true # if defined ( _STLP_STATIC_CONST_INIT_BUG) } # endif ; }; # endif /* __GNUC__ > 2000-11-01 */ #endif /* _STLP_LONG_LONG */ _STLP_MOVE_TO_PRIV_NAMESPACE // Specializations for all built-in floating-point types. template <class __dummy> class _LimG { public: static float _STLP_CALL get_F_inf(); static float _STLP_CALL get_F_qNaN(); static float _STLP_CALL get_F_sNaN(); static double _STLP_CALL get_D_inf(); static double _STLP_CALL get_D_qNaN(); static double _STLP_CALL get_D_sNaN(); #if !defined (_STLP_NO_LONG_DOUBLE) static long double _STLP_CALL get_LD_inf(); static long double _STLP_CALL get_LD_qNaN(); static long double _STLP_CALL get_LD_sNaN(); #endif }; #if defined (_STLP_USE_TEMPLATE_EXPORT) _STLP_EXPORT_TEMPLATE_CLASS _LimG<bool>; #endif _STLP_MOVE_TO_STD_NAMESPACE _STLP_TEMPLATE_NULL class numeric_limits<float> : public _STLP_PRIV _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 #if defined (_STLP_NO_IEC559_SUPPORT) false, // do not conform to iec559 #else true, // conforms to iec559 #endif round_to_nearest> { public: static float (_STLP_CALL min) () _STLP_NOTHROW { return FLT_MIN; } static float _STLP_CALL denorm_min() _STLP_NOTHROW { return FLT_MIN; } static float (_STLP_CALL max) () _STLP_NOTHROW { _STLP_USING_VENDOR_CSTD return FLT_MAX; } static float _STLP_CALL epsilon() _STLP_NOTHROW { return FLT_EPSILON; } static float _STLP_CALL round_error() _STLP_NOTHROW { return 0.5f; } // Units: ulps. static float _STLP_CALL infinity() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_F_inf(); } static float _STLP_CALL quiet_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_F_qNaN(); } static float _STLP_CALL signaling_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_F_sNaN(); } }; _STLP_TEMPLATE_NULL class numeric_limits<double> : public _STLP_PRIV _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 #if defined (_STLP_NO_IEC559_SUPPORT) false, // do not conform to iec559 #else true, // conforms to iec559 #endif round_to_nearest> { public: static double (_STLP_CALL min)() _STLP_NOTHROW { return DBL_MIN; } static double _STLP_CALL denorm_min() _STLP_NOTHROW { return DBL_MIN; } static double (_STLP_CALL max)() _STLP_NOTHROW { _STLP_USING_VENDOR_CSTD return DBL_MAX; } static double _STLP_CALL epsilon() _STLP_NOTHROW { return DBL_EPSILON; } static double _STLP_CALL round_error() _STLP_NOTHROW { return 0.5; } // Units: ulps. static double _STLP_CALL infinity() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_D_inf(); } static double _STLP_CALL quiet_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_D_qNaN(); } static double _STLP_CALL signaling_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_D_sNaN(); } }; #if !defined (_STLP_NO_LONG_DOUBLE) _STLP_TEMPLATE_NULL class numeric_limits<long double> : public _STLP_PRIV _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, // do not conform to iec559 round_to_nearest> { public: static long double (_STLP_CALL min) () _STLP_NOTHROW { _STLP_USING_VENDOR_CSTD return LDBL_MIN; } static long double _STLP_CALL denorm_min() _STLP_NOTHROW { _STLP_USING_VENDOR_CSTD return LDBL_MIN; } static long double (_STLP_CALL max) () _STLP_NOTHROW { _STLP_USING_VENDOR_CSTD return LDBL_MAX; } static long double _STLP_CALL epsilon() _STLP_NOTHROW { return LDBL_EPSILON; } static long double _STLP_CALL round_error() _STLP_NOTHROW { return 4; } // Units: ulps. static long double _STLP_CALL infinity() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_LD_inf(); } static long double _STLP_CALL quiet_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_LD_qNaN(); } static long double _STLP_CALL signaling_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_LD_sNaN(); } }; #endif // We write special values (Inf and NaN) as bit patterns and // cast the the appropriate floating-point types. _STLP_END_NAMESPACE #if !defined (_STLP_LINK_TIME_INSTANTIATION) # include <stl/_limits.c> #endif #endif // Local Variables: // mode:C++ // End:

• ソフトウェア開発
• ホームページ制作
• Doxygen Source Document
• Tcl Source Document