From 018afad39fc0b88d5bfd4842efa52a7923cff371 Mon Sep 17 00:00:00 2001 From: Ed Smith-Rowland <3dw4rd@verizon.net> Date: Thu, 25 Feb 2010 17:13:04 +0000 Subject: [PATCH] limits (__numeric_limits_base::max_digits10, [...]): Add. 2010-02-25 Ed Smith-Rowland <3dw4rd@verizon.net> * include/std/limits (__numeric_limits_base::max_digits10, numeric_limits<>::max_digits10, numeric_limits<>::lowest): Add. * src/limits.cc: Define max_digits10. * config/abi/pre/gnu.ver: Adjust. * testsuite/18_support/numeric_limits/dr559.cc: Test max_digits10 and lowest too. * testsuite/18_support/numeric_limits/lowest.cc: New. * testsuite/18_support/numeric_limits/max_digits10.cc: New. From-SVN: r157067 --- libstdc++-v3/ChangeLog | 11 ++ libstdc++-v3/config/abi/pre/gnu.ver | 29 +++- libstdc++-v3/include/std/limits | 146 +++++++++++++++++- libstdc++-v3/src/limits.cc | 19 +++ .../18_support/numeric_limits/dr559.cc | 2 + .../18_support/numeric_limits/lowest.cc | 82 ++++++++++ .../18_support/numeric_limits/max_digits10.cc | 67 ++++++++ 7 files changed, 349 insertions(+), 7 deletions(-) create mode 100644 libstdc++-v3/testsuite/18_support/numeric_limits/lowest.cc create mode 100644 libstdc++-v3/testsuite/18_support/numeric_limits/max_digits10.cc diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index d3632828081..f66cb342386 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,14 @@ +2010-02-25 Ed Smith-Rowland <3dw4rd@verizon.net> + + * include/std/limits (__numeric_limits_base::max_digits10, + numeric_limits<>::max_digits10, numeric_limits<>::lowest): Add. + * src/limits.cc: Define max_digits10. + * config/abi/pre/gnu.ver: Adjust. + * testsuite/18_support/numeric_limits/dr559.cc: Test max_digits10 + and lowest too. + * testsuite/18_support/numeric_limits/lowest.cc: New. + * testsuite/18_support/numeric_limits/max_digits10.cc: New. + 2010-02-25 Paolo Carlini * include/bits/functional_hash.h (__hash_combine): Remove. diff --git a/libstdc++-v3/config/abi/pre/gnu.ver b/libstdc++-v3/config/abi/pre/gnu.ver index 9d3ff4715e8..1df649911a0 100644 --- a/libstdc++-v3/config/abi/pre/gnu.ver +++ b/libstdc++-v3/config/abi/pre/gnu.ver @@ -164,7 +164,7 @@ GLIBCXX_3.4 { std::_List_node_base::reverse*; std::_List_node_base::transfer*; std::__timepunct*; - std::__numeric_limits_base*; +# std::__numeric_limits_base*; std::__num_base::_S_format_float*; std::__num_base::_S_format_int*; std::__num_base::_S_atoms_in; @@ -476,7 +476,15 @@ GLIBCXX_3.4 { _ZNSt15time_put_byname*; # std::numeric_limits - _ZNSt14numeric_limitsI[^g]E*; + _ZNSt21__numeric_limits_base[5-9]*; + _ZNSt21__numeric_limits_base1[0-7][hirt]*; + _ZNSt21__numeric_limits_base1[0-7]mi*; + _ZNSt21__numeric_limits_base1[0-7]max_e*; + + _ZNSt14numeric_limitsI[^g]E[5-9]*; + _ZNSt14numeric_limitsI[^g]E1[0-7][hirt]*; + _ZNSt14numeric_limitsI[^g]E1[0-7]mi*; + _ZNSt14numeric_limitsI[^g]E1[0-7]max_e*; # std::_Rb_tree _ZSt18_Rb_tree_decrementPKSt18_Rb_tree_node_base; @@ -1010,8 +1018,14 @@ GLIBCXX_3.4.11 { _ZSt20__throw_system_errori; # char16_t and char32_t - _ZNSt14numeric_limitsIDiE*; - _ZNSt14numeric_limitsIDsE*; + _ZNSt14numeric_limitsIDiE[5-9]*; + _ZNSt14numeric_limitsIDsE[5-9]*; + _ZNSt14numeric_limitsIDiE1[0-7][hirt]*; + _ZNSt14numeric_limitsIDsE1[0-7][hirt]*; + _ZNSt14numeric_limitsIDiE1[0-7]mi*; + _ZNSt14numeric_limitsIDsE1[0-7]mi*; + _ZNSt14numeric_limitsIDiE1[0-7]max_e*; + _ZNSt14numeric_limitsIDsE1[0-7]max_e*; # chrono _ZNSt6chrono12system_clock12is_monotonicE; @@ -1128,8 +1142,15 @@ GLIBCXX_3.4.14 { _ZNSt9__cxx199815_List_node_base9_M_unhookEv; _ZNSt9__cxx199815_List_node_base10_M_reverseEv; _ZNSt9__cxx199815_List_node_base11_M_transfer*; + + # std::numeric_limits::max_digits10 + _ZNSt21__numeric_limits_base12max_digits10E; + _ZNSt14numeric_limitsI[^g]E12max_digits10E; + _ZNSt14numeric_limitsID[is]E12max_digits10E; + } GLIBCXX_3.4.13; + # Symbols in the support library (libsupc++) have their own tag. CXXABI_1.3 { diff --git a/libstdc++-v3/include/std/limits b/libstdc++-v3/include/std/limits index a633d78bf03..65b623e853d 100644 --- a/libstdc++-v3/include/std/limits +++ b/libstdc++-v3/include/std/limits @@ -142,6 +142,8 @@ #define __glibcxx_digits10(T) \ (__glibcxx_digits (T) * 643 / 2136) +#define __glibcxx_max_digits10(T) \ + (2 + (T) * 643 / 2136) _GLIBCXX_BEGIN_NAMESPACE(std) @@ -197,11 +199,15 @@ _GLIBCXX_BEGIN_NAMESPACE(std) static const int digits = 0; /** The number of base 10 digits that can be represented without change. */ static const int digits10 = 0; +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + /** The number of base 10 digits required to ensure that values which + differ are always differentiated. */ + static const int max_digits10 = 0; +#endif /** True if the type is signed. */ static const bool is_signed = false; /** True if the type is integer. - * Is this supposed to be if the type is integral? - */ + * Is this supposed to be if the type is integral? */ static const bool is_integer = false; /** True if the type uses an exact representation. All integer types are exact, but not all exact types are integer. For example, rational and @@ -282,6 +288,11 @@ _GLIBCXX_BEGIN_NAMESPACE(std) static _Tp min() throw() { return static_cast<_Tp>(0); } /** The maximum finite value. */ static _Tp max() throw() { return static_cast<_Tp>(0); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + /** A finite value x such that there is no other finite value y + * where y < x. */ + static _Tp lowest() throw() { return static_cast<_Tp>(0); } +#endif /** The @e machine @e epsilon: the difference between 1 and the least value greater than 1 that is representable. */ static _Tp epsilon() throw() { return static_cast<_Tp>(0); } @@ -329,9 +340,15 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { return false; } static bool max() throw() { return true; } - +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static bool lowest() throw() + { return min(); } +#endif static const int digits = 1; static const int digits10 = 0; +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static const int max_digits10 = 0; +#endif static const bool is_signed = false; static const bool is_integer = true; static const bool is_exact = true; @@ -383,9 +400,16 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { return __glibcxx_min(char); } static char max() throw() { return __glibcxx_max(char); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static char lowest() throw() + { return min(); } +#endif static const int digits = __glibcxx_digits (char); static const int digits10 = __glibcxx_digits10 (char); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static const int max_digits10 = 0; +#endif static const bool is_signed = __glibcxx_signed (char); static const bool is_integer = true; static const bool is_exact = true; @@ -434,9 +458,16 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { return -__SCHAR_MAX__ - 1; } static signed char max() throw() { return __SCHAR_MAX__; } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static signed char lowest() throw() + { return min(); } +#endif static const int digits = __glibcxx_digits (signed char); static const int digits10 = __glibcxx_digits10 (signed char); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static const int max_digits10 = 0; +#endif static const bool is_signed = true; static const bool is_integer = true; static const bool is_exact = true; @@ -485,9 +516,16 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { return 0; } static unsigned char max() throw() { return __SCHAR_MAX__ * 2U + 1; } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static unsigned char lowest() throw() + { return min(); } +#endif static const int digits = __glibcxx_digits (unsigned char); static const int digits10 = __glibcxx_digits10 (unsigned char); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static const int max_digits10 = 0; +#endif static const bool is_signed = false; static const bool is_integer = true; static const bool is_exact = true; @@ -536,9 +574,16 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { return __glibcxx_min (wchar_t); } static wchar_t max() throw() { return __glibcxx_max (wchar_t); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static wchar_t lowest() throw() + { return min(); } +#endif static const int digits = __glibcxx_digits (wchar_t); static const int digits10 = __glibcxx_digits10 (wchar_t); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static const int max_digits10 = 0; +#endif static const bool is_signed = __glibcxx_signed (wchar_t); static const bool is_integer = true; static const bool is_exact = true; @@ -588,9 +633,16 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { return __glibcxx_min (char16_t); } static char16_t max() throw() { return __glibcxx_max (char16_t); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static char16_t lowest() throw() + { return min(); } +#endif static const int digits = __glibcxx_digits (char16_t); static const int digits10 = __glibcxx_digits10 (char16_t); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static const int max_digits10 = 0; +#endif static const bool is_signed = __glibcxx_signed (char16_t); static const bool is_integer = true; static const bool is_exact = true; @@ -639,9 +691,16 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { return __glibcxx_min (char32_t); } static char32_t max() throw() { return __glibcxx_max (char32_t); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static char32_t lowest() throw() + { return min(); } +#endif static const int digits = __glibcxx_digits (char32_t); static const int digits10 = __glibcxx_digits10 (char32_t); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static const int max_digits10 = 0; +#endif static const bool is_signed = __glibcxx_signed (char32_t); static const bool is_integer = true; static const bool is_exact = true; @@ -691,9 +750,16 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { return -__SHRT_MAX__ - 1; } static short max() throw() { return __SHRT_MAX__; } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static short lowest() throw() + { return min(); } +#endif static const int digits = __glibcxx_digits (short); static const int digits10 = __glibcxx_digits10 (short); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static const int max_digits10 = 0; +#endif static const bool is_signed = true; static const bool is_integer = true; static const bool is_exact = true; @@ -742,9 +808,16 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { return 0; } static unsigned short max() throw() { return __SHRT_MAX__ * 2U + 1; } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static unsigned short lowest() throw() + { return min(); } +#endif static const int digits = __glibcxx_digits (unsigned short); static const int digits10 = __glibcxx_digits10 (unsigned short); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static const int max_digits10 = 0; +#endif static const bool is_signed = false; static const bool is_integer = true; static const bool is_exact = true; @@ -793,9 +866,16 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { return -__INT_MAX__ - 1; } static int max() throw() { return __INT_MAX__; } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static int lowest() throw() + { return min(); } +#endif static const int digits = __glibcxx_digits (int); static const int digits10 = __glibcxx_digits10 (int); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static const int max_digits10 = 0; +#endif static const bool is_signed = true; static const bool is_integer = true; static const bool is_exact = true; @@ -844,9 +924,16 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { return 0; } static unsigned int max() throw() { return __INT_MAX__ * 2U + 1; } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static unsigned int lowest() throw() + { return min(); } +#endif static const int digits = __glibcxx_digits (unsigned int); static const int digits10 = __glibcxx_digits10 (unsigned int); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static const int max_digits10 = 0; +#endif static const bool is_signed = false; static const bool is_integer = true; static const bool is_exact = true; @@ -895,9 +982,16 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { return -__LONG_MAX__ - 1; } static long max() throw() { return __LONG_MAX__; } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static long lowest() throw() + { return min(); } +#endif static const int digits = __glibcxx_digits (long); static const int digits10 = __glibcxx_digits10 (long); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static const int max_digits10 = 0; +#endif static const bool is_signed = true; static const bool is_integer = true; static const bool is_exact = true; @@ -946,9 +1040,16 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { return 0; } static unsigned long max() throw() { return __LONG_MAX__ * 2UL + 1; } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static unsigned long lowest() throw() + { return min(); } +#endif static const int digits = __glibcxx_digits (unsigned long); static const int digits10 = __glibcxx_digits10 (unsigned long); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static const int max_digits10 = 0; +#endif static const bool is_signed = false; static const bool is_integer = true; static const bool is_exact = true; @@ -997,9 +1098,16 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { return -__LONG_LONG_MAX__ - 1; } static long long max() throw() { return __LONG_LONG_MAX__; } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static long long lowest() throw() + { return min(); } +#endif static const int digits = __glibcxx_digits (long long); static const int digits10 = __glibcxx_digits10 (long long); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static const int max_digits10 = 0; +#endif static const bool is_signed = true; static const bool is_integer = true; static const bool is_exact = true; @@ -1048,9 +1156,16 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { return 0; } static unsigned long long max() throw() { return __LONG_LONG_MAX__ * 2ULL + 1; } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static unsigned long long lowest() throw() + { return min(); } +#endif static const int digits = __glibcxx_digits (unsigned long long); static const int digits10 = __glibcxx_digits10 (unsigned long long); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static const int max_digits10 = 0; +#endif static const bool is_signed = false; static const bool is_integer = true; static const bool is_exact = true; @@ -1099,9 +1214,17 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { return __FLT_MIN__; } static float max() throw() { return __FLT_MAX__; } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static float lowest() throw() + { return -__FLT_MAX__; } +#endif static const int digits = __FLT_MANT_DIG__; static const int digits10 = __FLT_DIG__; +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static const int max_digits10 + = __glibcxx_max_digits10 (__FLT_MANT_DIG__); +#endif static const bool is_signed = true; static const bool is_integer = false; static const bool is_exact = false; @@ -1156,9 +1279,17 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { return __DBL_MIN__; } static double max() throw() { return __DBL_MAX__; } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static double lowest() throw() + { return -__DBL_MAX__; } +#endif static const int digits = __DBL_MANT_DIG__; static const int digits10 = __DBL_DIG__; +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static const int max_digits10 + = __glibcxx_max_digits10 (__DBL_MANT_DIG__); +#endif static const bool is_signed = true; static const bool is_integer = false; static const bool is_exact = false; @@ -1213,9 +1344,17 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { return __LDBL_MIN__; } static long double max() throw() { return __LDBL_MAX__; } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static long double lowest() throw() + { return -__LDBL_MAX__; } +#endif static const int digits = __LDBL_MANT_DIG__; static const int digits10 = __LDBL_DIG__; +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static const int max_digits10 + = __glibcxx_max_digits10 (__LDBL_MANT_DIG__); +#endif static const bool is_signed = true; static const bool is_integer = false; static const bool is_exact = false; @@ -1268,5 +1407,6 @@ _GLIBCXX_END_NAMESPACE #undef __glibcxx_max #undef __glibcxx_digits #undef __glibcxx_digits10 +#undef __glibcxx_max_digits10 #endif // _GLIBCXX_NUMERIC_LIMITS diff --git a/libstdc++-v3/src/limits.cc b/libstdc++-v3/src/limits.cc index 09a5dae8656..9c953c96afd 100644 --- a/libstdc++-v3/src/limits.cc +++ b/libstdc++-v3/src/limits.cc @@ -37,6 +37,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const bool __numeric_limits_base::is_specialized; const int __numeric_limits_base::digits; const int __numeric_limits_base::digits10; + const int __numeric_limits_base::max_digits10; const bool __numeric_limits_base::is_signed; const bool __numeric_limits_base::is_integer; const bool __numeric_limits_base::is_exact; @@ -61,6 +62,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const bool numeric_limits::is_specialized; const int numeric_limits::digits; const int numeric_limits::digits10; + const int numeric_limits::max_digits10; const bool numeric_limits::is_signed; const bool numeric_limits::is_integer; const bool numeric_limits::is_exact; @@ -85,6 +87,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const bool numeric_limits::is_specialized; const int numeric_limits::digits; const int numeric_limits::digits10; + const int numeric_limits::max_digits10; const bool numeric_limits::is_signed; const bool numeric_limits::is_integer; const bool numeric_limits::is_exact; @@ -109,6 +112,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const bool numeric_limits::is_specialized; const int numeric_limits::digits; const int numeric_limits::digits10; + const int numeric_limits::max_digits10; const bool numeric_limits::is_signed; const bool numeric_limits::is_integer; const bool numeric_limits::is_exact; @@ -133,6 +137,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const bool numeric_limits::is_specialized; const int numeric_limits::digits; const int numeric_limits::digits10; + const int numeric_limits::max_digits10; const bool numeric_limits::is_signed; const bool numeric_limits::is_integer; const bool numeric_limits::is_exact; @@ -159,6 +164,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const bool numeric_limits::is_specialized; const int numeric_limits::digits; const int numeric_limits::digits10; + const int numeric_limits::max_digits10; const bool numeric_limits::is_signed; const bool numeric_limits::is_integer; const bool numeric_limits::is_exact; @@ -184,6 +190,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const bool numeric_limits::is_specialized; const int numeric_limits::digits; const int numeric_limits::digits10; + const int numeric_limits::max_digits10; const bool numeric_limits::is_signed; const bool numeric_limits::is_integer; const bool numeric_limits::is_exact; @@ -208,6 +215,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const bool numeric_limits::is_specialized; const int numeric_limits::digits; const int numeric_limits::digits10; + const int numeric_limits::max_digits10; const bool numeric_limits::is_signed; const bool numeric_limits::is_integer; const bool numeric_limits::is_exact; @@ -232,6 +240,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const bool numeric_limits::is_specialized; const int numeric_limits::digits; const int numeric_limits::digits10; + const int numeric_limits::max_digits10; const bool numeric_limits::is_signed; const bool numeric_limits::is_integer; const bool numeric_limits::is_exact; @@ -256,6 +265,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const bool numeric_limits::is_specialized; const int numeric_limits::digits; const int numeric_limits::digits10; + const int numeric_limits::max_digits10; const bool numeric_limits::is_signed; const bool numeric_limits::is_integer; const bool numeric_limits::is_exact; @@ -280,6 +290,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const bool numeric_limits::is_specialized; const int numeric_limits::digits; const int numeric_limits::digits10; + const int numeric_limits::max_digits10; const bool numeric_limits::is_signed; const bool numeric_limits::is_integer; const bool numeric_limits::is_exact; @@ -304,6 +315,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const bool numeric_limits::is_specialized; const int numeric_limits::digits; const int numeric_limits::digits10; + const int numeric_limits::max_digits10; const bool numeric_limits::is_signed; const bool numeric_limits::is_integer; const bool numeric_limits::is_exact; @@ -328,6 +340,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const bool numeric_limits::is_specialized; const int numeric_limits::digits; const int numeric_limits::digits10; + const int numeric_limits::max_digits10; const bool numeric_limits::is_signed; const bool numeric_limits::is_integer; const bool numeric_limits::is_exact; @@ -351,6 +364,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const bool numeric_limits::is_specialized; const int numeric_limits::digits; const int numeric_limits::digits10; + const int numeric_limits::max_digits10; const bool numeric_limits::is_signed; const bool numeric_limits::is_integer; const bool numeric_limits::is_exact; @@ -375,6 +389,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const bool numeric_limits::is_specialized; const int numeric_limits::digits; const int numeric_limits::digits10; + const int numeric_limits::max_digits10; const bool numeric_limits::is_signed; const bool numeric_limits::is_integer; const bool numeric_limits::is_exact; @@ -399,6 +414,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const bool numeric_limits::is_specialized; const int numeric_limits::digits; const int numeric_limits::digits10; + const int numeric_limits::max_digits10; const bool numeric_limits::is_signed; const bool numeric_limits::is_integer; const bool numeric_limits::is_exact; @@ -423,6 +439,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const bool numeric_limits::is_specialized; const int numeric_limits::digits; const int numeric_limits::digits10; + const int numeric_limits::max_digits10; const bool numeric_limits::is_signed; const bool numeric_limits::is_integer; const bool numeric_limits::is_exact; @@ -447,6 +464,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const bool numeric_limits::is_specialized; const int numeric_limits::digits; const int numeric_limits::digits10; + const int numeric_limits::max_digits10; const bool numeric_limits::is_signed; const bool numeric_limits::is_integer; const bool numeric_limits::is_exact; @@ -471,6 +489,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const bool numeric_limits::is_specialized; const int numeric_limits::digits; const int numeric_limits::digits10; + const int numeric_limits::max_digits10; const bool numeric_limits::is_signed; const bool numeric_limits::is_integer; const bool numeric_limits::is_exact; diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/dr559.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/dr559.cc index f541faae583..ffe5a4ba0dc 100644 --- a/libstdc++-v3/testsuite/18_support/numeric_limits/dr559.cc +++ b/libstdc++-v3/testsuite/18_support/numeric_limits/dr559.cc @@ -33,8 +33,10 @@ template VERIFY( cv_limits::is_specialized == limits::is_specialized ); VERIFY( cv_limits::min() == limits::min() ); VERIFY( cv_limits::max() == limits::max() ); + VERIFY( cv_limits::lowest() == limits::lowest() ); VERIFY( cv_limits::digits == limits::digits ); VERIFY( cv_limits::digits10 == limits::digits10 ); + VERIFY( cv_limits::max_digits10 == limits::max_digits10 ); VERIFY( cv_limits::is_signed == limits::is_signed ); VERIFY( cv_limits::is_integer == limits::is_integer ); VERIFY( cv_limits::is_exact == limits::is_exact ); diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/lowest.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/lowest.cc new file mode 100644 index 00000000000..498a03bc0cc --- /dev/null +++ b/libstdc++-v3/testsuite/18_support/numeric_limits/lowest.cc @@ -0,0 +1,82 @@ +// { dg-options "-std=gnu++0x" } +// { dg-add-options ieee } + +// 2010-02-25 Ed Smith-Rowland + +// Copyright (C) 2010 Free Software Foundation +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +// 18.2.1.1 template class numeric_limits + +#include +#include +#include + +template + void + do_test(std::true_type) + { + bool test __attribute__((unused)) = true; + T limits_min = std::numeric_limits::min(); + VERIFY( std::numeric_limits::lowest() == limits_min ); + } + +template + void + do_test(std::false_type) + { + bool test __attribute__((unused)) = true; + T limits_max = std::numeric_limits::max(); + VERIFY( std::numeric_limits::lowest() == -limits_max ); + } + +template + void + do_test() + { do_test(typename std::is_integral::type()); } + +void test01() +{ + do_test(); + do_test(); + do_test(); + do_test(); + do_test(); + do_test(); + + do_test(); + do_test(); + + do_test(); + do_test(); + + do_test(); + do_test(); + + do_test(); + do_test(); + + do_test(); + do_test(); + do_test(); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/max_digits10.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/max_digits10.cc new file mode 100644 index 00000000000..fdce19c36cb --- /dev/null +++ b/libstdc++-v3/testsuite/18_support/numeric_limits/max_digits10.cc @@ -0,0 +1,67 @@ +// { dg-options "-std=gnu++0x" } +// { dg-add-options ieee } + +// 2010-02-25 Ed Smith-Rowland + +// Copyright (C) 2010 Free Software Foundation +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +// 18.2.1.1 template class numeric_limits + +#include +#include +#include + +void +test01() +{ + bool test __attribute__((unused)) = true; + + VERIFY( std::numeric_limits::max_digits10 == 0 ); + VERIFY( std::numeric_limits::max_digits10 == 0 ); + VERIFY( std::numeric_limits::max_digits10 == 0 ); + VERIFY( std::numeric_limits::max_digits10 == 0 ); + VERIFY( std::numeric_limits::max_digits10 == 0 ); + VERIFY( std::numeric_limits::max_digits10 == 0 ); + VERIFY( std::numeric_limits::max_digits10 == 0 ); + VERIFY( std::numeric_limits::max_digits10 == 0 ); + VERIFY( std::numeric_limits::max_digits10 == 0 ); + VERIFY( std::numeric_limits::max_digits10 == 0 ); + VERIFY( std::numeric_limits::max_digits10 == 0 ); + VERIFY( std::numeric_limits::max_digits10 == 0 ); + VERIFY( std::numeric_limits::max_digits10 == 0 ); + VERIFY( std::numeric_limits::max_digits10 == 0 ); + VERIFY( std::numeric_limits::max_digits10 == 0 ); + + const int f_max_digits10 = (2 + std::numeric_limits::digits + * 643 / 2136); + VERIFY( std::numeric_limits::max_digits10 == f_max_digits10 ); + + const int d_max_digits10 = (2 + std::numeric_limits::digits + * 643 / 2136); + VERIFY( std::numeric_limits::max_digits10 == d_max_digits10 ); + + const int ld_max_digits10 = (2 + std::numeric_limits::digits + * 643 / 2136); + VERIFY( std::numeric_limits::max_digits10 == ld_max_digits10 ); +} + +int main() +{ + test01(); + return 0; +}