# limits

Go to the documentation of this file.

    00001 // The template and inlines for the numeric_limits classes. -*- C++ -*-
    00002
    00003 // Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
    00004 // 2008, 2009, 2010  Free Software Foundation, Inc.
    00005 //
    00006 // This file is part of the GNU ISO C++ Library.  This library is free
    00007 // software; you can redistribute it and/or modify it under the
    00008 // terms of the GNU General Public License as published by the
    00009 // Free Software Foundation; either version 3, or (at your option)
    00010 // any later version.
    00011
    00012 // This library is distributed in the hope that it will be useful,
    00013 // but WITHOUT ANY WARRANTY; without even the implied warranty of
    00014 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    00015 // GNU General Public License for more details.
    00016
    00017 // Under Section 7 of GPL version 3, you are granted additional
    00018 // permissions described in the GCC Runtime Library Exception, version
    00019 // 3.1, as published by the Free Software Foundation.
    00020
    00021 // You should have received a copy of the GNU General Public License and
    00022 // a copy of the GCC Runtime Library Exception along with this program;
    00023 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
    00024 // <http://www.gnu.org/licenses/>.
    00025
    00026 /** @file limits
    00027  *  This is a Standard C++ Library header.
    00028  */
    00029
    00030 // Note: this is not a conforming implementation.
    00031 // Written by Gabriel Dos Reis <gdr@codesourcery.com>
    00032
    00033 //
    00034 // ISO 14882:1998
    00035 // 18.2.1
    00036 //
    00037
    00038 #ifndef _GLIBCXX_NUMERIC_LIMITS
    00039 #define _GLIBCXX_NUMERIC_LIMITS 1
    00040
    00041 #pragma GCC system_header
    00042
    00043 #include <bits/c++config.h>
    00044
    00045 //
    00046 // The numeric_limits<> traits document implementation-defined aspects
    00047 // of fundamental arithmetic data types (integers and floating points).
    00048 // From Standard C++ point of view, there are 14 such types:
    00049 //   * integers
    00050 //         bool                             (1)
    00051 //         char, signed char, unsigned char, wchar_t            (4)
    00052 //         short, unsigned short                (2)
    00053 //         int, unsigned                    (2)
    00054 //         long, unsigned long                  (2)
    00055 //
    00056 //   * floating points
    00057 //         float                        (1)
    00058 //         double                       (1)
    00059 //         long double                      (1)
    00060 //
    00061 // GNU C++ understands (where supported by the host C-library)
    00062 //   * integer
    00063 //         long long, unsigned long long            (2)
    00064 //
    00065 // which brings us to 16 fundamental arithmetic data types in GNU C++.
    00066 //
    00067 //
    00068 // Since a numeric_limits<> is a bit tricky to get right, we rely on
    00069 // an interface composed of macros which should be defined in config/os
    00070 // or config/cpu when they differ from the generic (read arbitrary)
    00071 // definitions given here.
    00072 //
    00073
    00074 // These values can be overridden in the target configuration file.
    00075 // The default values are appropriate for many 32-bit targets.
    00076
    00077 // GCC only intrinsically supports modulo integral types.  The only remaining
    00078 // integral exceptional values is division by zero.  Only targets that do not
    00079 // signal division by zero in some "hard to ignore" way should use false.
    00080 #ifndef __glibcxx_integral_traps
    00081 # define __glibcxx_integral_traps true
    00082 #endif
    00083
    00084 // float
    00085 //
    00086
    00087 // Default values.  Should be overridden in configuration files if necessary.
    00088
    00089 #ifndef __glibcxx_float_has_denorm_loss
    00090 #  define __glibcxx_float_has_denorm_loss false
    00091 #endif
    00092 #ifndef __glibcxx_float_traps
    00093 #  define __glibcxx_float_traps false
    00094 #endif
    00095 #ifndef __glibcxx_float_tinyness_before
    00096 #  define __glibcxx_float_tinyness_before false
    00097 #endif
    00098
    00099 // double
    00100
    00101 // Default values.  Should be overridden in configuration files if necessary.
    00102
    00103 #ifndef __glibcxx_double_has_denorm_loss
    00104 #  define __glibcxx_double_has_denorm_loss false
    00105 #endif
    00106 #ifndef __glibcxx_double_traps
    00107 #  define __glibcxx_double_traps false
    00108 #endif
    00109 #ifndef __glibcxx_double_tinyness_before
    00110 #  define __glibcxx_double_tinyness_before false
    00111 #endif
    00112
    00113 // long double
    00114
    00115 // Default values.  Should be overridden in configuration files if necessary.
    00116
    00117 #ifndef __glibcxx_long_double_has_denorm_loss
    00118 #  define __glibcxx_long_double_has_denorm_loss false
    00119 #endif
    00120 #ifndef __glibcxx_long_double_traps
    00121 #  define __glibcxx_long_double_traps false
    00122 #endif
    00123 #ifndef __glibcxx_long_double_tinyness_before
    00124 #  define __glibcxx_long_double_tinyness_before false
    00125 #endif
    00126
    00127 // You should not need to define any macros below this point.
    00128
    00129 #define __glibcxx_signed(T) ((T)(-1) < 0)
    00130
    00131 #define __glibcxx_min(T) \
    00132   (__glibcxx_signed (T) ? (T)1 << __glibcxx_digits (T) : (T)0)
    00133
    00134 #define __glibcxx_max(T) \
    00135   (__glibcxx_signed (T) ? \
    00136    (((((T)1 << (__glibcxx_digits (T) - 1)) - 1) << 1) + 1) : ~(T)0)
    00137
    00138 #define __glibcxx_digits(T) \
    00139   (sizeof(T) * __CHAR_BIT__ - __glibcxx_signed (T))
    00140
    00141 // The fraction 643/2136 approximates log10(2) to 7 significant digits.
    00142 #define __glibcxx_digits10(T) \
    00143   (__glibcxx_digits (T) * 643 / 2136)
    00144
    00145 #define __glibcxx_max_digits10(T) \
    00146   (2 + (T) * 643 / 2136)
    00147
    00148 _GLIBCXX_BEGIN_NAMESPACE(std)
    00149
    00150   /**
    00151    *  @brief Describes the rounding style for floating-point types.
    00152    *
    00153    *  This is used in the std::numeric_limits class.
    00154   */
    00155   enum float_round_style
    00156   {
    00157     round_indeterminate       = -1,    ///< Self-explanatory.
    00158     round_toward_zero         = 0,     ///< Self-explanatory.
    00159     round_to_nearest          = 1,     ///< To the nearest representable value.
    00160     round_toward_infinity     = 2,     ///< Self-explanatory.
    00161     round_toward_neg_infinity = 3      ///< Self-explanatory.
    00162   };
    00163
    00164   /**
    00165    *  @brief Describes the denormalization for floating-point types.
    00166    *
    00167    *  These values represent the presence or absence of a variable number
    00168    *  of exponent bits.  This type is used in the std::numeric_limits class.
    00169   */
    00170   enum float_denorm_style
    00171   {
    00172     /// Indeterminate at compile time whether denormalized values are allowed.
    00173     denorm_indeterminate = -1,
    00174     /// The type does not allow denormalized values.
    00175     denorm_absent        = 0,
    00176     /// The type allows denormalized values.
    00177     denorm_present       = 1
    00178   };
    00179
    00180   /**
    00181    *  @brief Part of std::numeric_limits.
    00182    *
    00183    *  The @c static @c const members are usable as integral constant
    00184    *  expressions.
    00185    *
    00186    *  @note This is a separate class for purposes of efficiency; you
    00187    *        should only access these members as part of an instantiation
    00188    *        of the std::numeric_limits class.
    00189   */
    00190   struct __numeric_limits_base
    00191   {
    00192     /** This will be true for all fundamental types (which have
    00193         specializations), and false for everything else.  */
    00194     static const bool is_specialized = false;
    00195
    00196     /** The number of @c radix digits that be represented without change:  for
    00197         integer types, the number of non-sign bits in the mantissa; for
    00198         floating types, the number of @c radix digits in the mantissa.  */
    00199     static const int digits = 0;
    00200     /** The number of base 10 digits that can be represented without change. */
    00201     static const int digits10 = 0;
    00202 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00203     /** The number of base 10 digits required to ensure that values which
    00204     differ are always differentiated.  */
    00205     static const int max_digits10 = 0;
    00206 #endif
    00207     /** True if the type is signed.  */
    00208     static const bool is_signed = false;
    00209     /** True if the type is integer.
    00210      *  Is this supposed to be <em>if the type is integral?</em>  */
    00211     static const bool is_integer = false;
    00212     /** True if the type uses an exact representation. <em>All integer types are
    00213         exact, but not all exact types are integer.  For example, rational and
    00214         fixed-exponent representations are exact but not integer.</em>
    00215         [18.2.1.2]/15  */
    00216     static const bool is_exact = false;
    00217     /** For integer types, specifies the base of the representation.  For
    00218         floating types, specifies the base of the exponent representation.  */
    00219     static const int radix = 0;
    00220
    00221     /** The minimum negative integer such that @c radix raised to the power of
    00222         (one less than that integer) is a normalized floating point number.  */
    00223     static const int min_exponent = 0;
    00224     /** The minimum negative integer such that 10 raised to that power is in
    00225         the range of normalized floating point numbers.  */
    00226     static const int min_exponent10 = 0;
    00227     /** The maximum positive integer such that @c radix raised to the power of
    00228         (one less than that integer) is a representable finite floating point
    00229     number.  */
    00230     static const int max_exponent = 0;
    00231     /** The maximum positive integer such that 10 raised to that power is in
    00232         the range of representable finite floating point numbers.  */
    00233     static const int max_exponent10 = 0;
    00234
    00235     /** True if the type has a representation for positive infinity.  */
    00236     static const bool has_infinity = false;
    00237     /** True if the type has a representation for a quiet (non-signaling)
    00238         <em>Not a Number</em>.  */
    00239     static const bool has_quiet_NaN = false;
    00240     /** True if the type has a representation for a signaling
    00241         <em>Not a Number</em>.  */
    00242     static const bool has_signaling_NaN = false;
    00243     /** See std::float_denorm_style for more information.  */
    00244     static const float_denorm_style has_denorm = denorm_absent;
    00245     /** <em>True if loss of accuracy is detected as a denormalization loss,
    00246         rather than as an inexact result.</em> [18.2.1.2]/42  */
    00247     static const bool has_denorm_loss = false;
    00248
    00249     /** True if-and-only-if the type adheres to the IEC 559 standard, also
    00250         known as IEEE 754.  (Only makes sense for floating point types.)  */
    00251     static const bool is_iec559 = false;
    00252     /** <em>True if the set of values representable by the type is
    00253         finite.  All built-in types are bounded, this member would be
    00254         false for arbitrary precision types.</em> [18.2.1.2]/54  */
    00255     static const bool is_bounded = false;
    00256     /** True if the type is @e modulo, that is, if it is possible to add two
    00257         positive numbers and have a result that wraps around to a third number
    00258         that is less.  Typically false for floating types, true for unsigned
    00259         integers, and true for signed integers.  */
    00260     static const bool is_modulo = false;
    00261
    00262     /** True if trapping is implemented for this type.  */
    00263     static const bool traps = false;
    00264     /** True if tininess is detected before rounding.  (see IEC 559)  */
    00265     static const bool tinyness_before = false;
    00266     /** See std::float_round_style for more information.  This is only
    00267         meaningful for floating types; integer types will all be
    00268     round_toward_zero.  */
    00269     static const float_round_style round_style = round_toward_zero;
    00270   };
    00271
    00272   /**
    00273    *  @brief Properties of fundamental types.
    00274    *
    00275    *  This class allows a program to obtain information about the
    00276    *  representation of a fundamental type on a given platform.  For
    00277    *  non-fundamental types, the functions will return 0 and the data
    00278    *  members will all be @c false.
    00279    *
    00280    *  _GLIBCXX_RESOLVE_LIB_DEFECTS:  DRs 201 and 184 (hi Gaby!) are
    00281    *  noted, but not incorporated in this documented (yet).
    00282   */
    00283   template<typename _Tp>
    00284     struct numeric_limits : public __numeric_limits_base
    00285     {
    00286       /** The minimum finite value, or for floating types with
    00287           denormalization, the minimum positive normalized value.  */
    00288       static _Tp min() throw() { return static_cast<_Tp>(0); }
    00289       /** The maximum finite value.  */
    00290       static _Tp max() throw() { return static_cast<_Tp>(0); }
    00291 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00292       /** A finite value x such that there is no other finite value y
    00293        *  where y < x.  */
    00294       static _Tp lowest() throw() { return static_cast<_Tp>(0); }
    00295 #endif
    00296       /** The @e machine @e epsilon:  the difference between 1 and the least
    00297           value greater than 1 that is representable.  */
    00298       static _Tp epsilon() throw() { return static_cast<_Tp>(0); }
    00299       /** The maximum rounding error measurement (see LIA-1).  */
    00300       static _Tp round_error() throw() { return static_cast<_Tp>(0); }
    00301       /** The representation of positive infinity, if @c has_infinity.  */
    00302       static _Tp infinity() throw()  { return static_cast<_Tp>(0); }
    00303
    00304       /** The representation of a quiet <em>Not a Number</em>,
    00305       if @c has_quiet_NaN. */
    00306       static _Tp quiet_NaN() throw() { return static_cast<_Tp>(0); }
    00307       /** The representation of a signaling <em>Not a Number</em>, if
    00308           @c has_signaling_NaN. */
    00309       static _Tp signaling_NaN() throw() { return static_cast<_Tp>(0); }
    00310       /** The minimum positive denormalized value.  For types where
    00311           @c has_denorm is false, this is the minimum positive normalized
    00312       value.  */
    00313       static _Tp denorm_min() throw() { return static_cast<_Tp>(0); }
    00314     };
    00315
    00316 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00317   template<typename _Tp>
    00318     struct numeric_limits<const _Tp>
    00319     : public numeric_limits<_Tp> { };
    00320
    00321   template<typename _Tp>
    00322     struct numeric_limits<volatile _Tp>
    00323     : public numeric_limits<_Tp> { };
    00324
    00325   template<typename _Tp>
    00326     struct numeric_limits<const volatile _Tp>
    00327     : public numeric_limits<_Tp> { };
    00328 #endif
    00329
    00330   // Now there follow 16 explicit specializations.  Yes, 16.  Make sure
    00331   // you get the count right. (18 in c++0x mode)
    00332
    00333   /// numeric_limits<bool> specialization.
    00334   template<>
    00335     struct numeric_limits<bool>
    00336     {
    00337       static const bool is_specialized = true;
    00338
    00339       static bool min() throw()
    00340       { return false; }
    00341       static bool max() throw()
    00342       { return true; }
    00343 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00344       static bool lowest() throw()
    00345       { return min(); }
    00346 #endif
    00347       static const int digits = 1;
    00348       static const int digits10 = 0;
    00349 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00350       static const int max_digits10 = 0;
    00351 #endif
    00352       static const bool is_signed = false;
    00353       static const bool is_integer = true;
    00354       static const bool is_exact = true;
    00355       static const int radix = 2;
    00356       static bool epsilon() throw()
    00357       { return false; }
    00358       static bool round_error() throw()
    00359       { return false; }
    00360
    00361       static const int min_exponent = 0;
    00362       static const int min_exponent10 = 0;
    00363       static const int max_exponent = 0;
    00364       static const int max_exponent10 = 0;
    00365
    00366       static const bool has_infinity = false;
    00367       static const bool has_quiet_NaN = false;
    00368       static const bool has_signaling_NaN = false;
    00369       static const float_denorm_style has_denorm = denorm_absent;
    00370       static const bool has_denorm_loss = false;
    00371
    00372       static bool infinity() throw()
    00373       { return false; }
    00374       static bool quiet_NaN() throw()
    00375       { return false; }
    00376       static bool signaling_NaN() throw()
    00377       { return false; }
    00378       static bool denorm_min() throw()
    00379       { return false; }
    00380
    00381       static const bool is_iec559 = false;
    00382       static const bool is_bounded = true;
    00383       static const bool is_modulo = false;
    00384
    00385       // It is not clear what it means for a boolean type to trap.
    00386       // This is a DR on the LWG issue list.  Here, I use integer
    00387       // promotion semantics.
    00388       static const bool traps = __glibcxx_integral_traps;
    00389       static const bool tinyness_before = false;
    00390       static const float_round_style round_style = round_toward_zero;
    00391     };
    00392
    00393   /// numeric_limits<char> specialization.
    00394   template<>
    00395     struct numeric_limits<char>
    00396     {
    00397       static const bool is_specialized = true;
    00398
    00399       static char min() throw()
    00400       { return __glibcxx_min(char); }
    00401       static char max() throw()
    00402       { return __glibcxx_max(char); }
    00403 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00404       static char lowest() throw()
    00405       { return min(); }
    00406 #endif
    00407
    00408       static const int digits = __glibcxx_digits (char);
    00409       static const int digits10 = __glibcxx_digits10 (char);
    00410 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00411       static const int max_digits10 = 0;
    00412 #endif
    00413       static const bool is_signed = __glibcxx_signed (char);
    00414       static const bool is_integer = true;
    00415       static const bool is_exact = true;
    00416       static const int radix = 2;
    00417       static char epsilon() throw()
    00418       { return 0; }
    00419       static char round_error() throw()
    00420       { return 0; }
    00421
    00422       static const int min_exponent = 0;
    00423       static const int min_exponent10 = 0;
    00424       static const int max_exponent = 0;
    00425       static const int max_exponent10 = 0;
    00426
    00427       static const bool has_infinity = false;
    00428       static const bool has_quiet_NaN = false;
    00429       static const bool has_signaling_NaN = false;
    00430       static const float_denorm_style has_denorm = denorm_absent;
    00431       static const bool has_denorm_loss = false;
    00432
    00433       static char infinity() throw()
    00434       { return char(); }
    00435       static char quiet_NaN() throw()
    00436       { return char(); }
    00437       static char signaling_NaN() throw()
    00438       { return char(); }
    00439       static char denorm_min() throw()
    00440       { return static_cast<char>(0); }
    00441
    00442       static const bool is_iec559 = false;
    00443       static const bool is_bounded = true;
    00444       static const bool is_modulo = true;
    00445
    00446       static const bool traps = __glibcxx_integral_traps;
    00447       static const bool tinyness_before = false;
    00448       static const float_round_style round_style = round_toward_zero;
    00449     };
    00450
    00451   /// numeric_limits<signed char> specialization.
    00452   template<>
    00453     struct numeric_limits<signed char>
    00454     {
    00455       static const bool is_specialized = true;
    00456
    00457       static signed char min() throw()
    00458       { return -__SCHAR_MAX__ - 1; }
    00459       static signed char max() throw()
    00460       { return __SCHAR_MAX__; }
    00461 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00462       static signed char lowest() throw()
    00463       { return min(); }
    00464 #endif
    00465
    00466       static const int digits = __glibcxx_digits (signed char);
    00467       static const int digits10 = __glibcxx_digits10 (signed char);
    00468 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00469       static const int max_digits10 = 0;
    00470 #endif
    00471       static const bool is_signed = true;
    00472       static const bool is_integer = true;
    00473       static const bool is_exact = true;
    00474       static const int radix = 2;
    00475       static signed char epsilon() throw()
    00476       { return 0; }
    00477       static signed char round_error() throw()
    00478       { return 0; }
    00479
    00480       static const int min_exponent = 0;
    00481       static const int min_exponent10 = 0;
    00482       static const int max_exponent = 0;
    00483       static const int max_exponent10 = 0;
    00484
    00485       static const bool has_infinity = false;
    00486       static const bool has_quiet_NaN = false;
    00487       static const bool has_signaling_NaN = false;
    00488       static const float_denorm_style has_denorm = denorm_absent;
    00489       static const bool has_denorm_loss = false;
    00490
    00491       static signed char infinity() throw()
    00492       { return static_cast<signed char>(0); }
    00493       static signed char quiet_NaN() throw()
    00494       { return static_cast<signed char>(0); }
    00495       static signed char signaling_NaN() throw()
    00496       { return static_cast<signed char>(0); }
    00497       static signed char denorm_min() throw()
    00498       { return static_cast<signed char>(0); }
    00499
    00500       static const bool is_iec559 = false;
    00501       static const bool is_bounded = true;
    00502       static const bool is_modulo = true;
    00503
    00504       static const bool traps = __glibcxx_integral_traps;
    00505       static const bool tinyness_before = false;
    00506       static const float_round_style round_style = round_toward_zero;
    00507     };
    00508
    00509   /// numeric_limits<unsigned char> specialization.
    00510   template<>
    00511     struct numeric_limits<unsigned char>
    00512     {
    00513       static const bool is_specialized = true;
    00514
    00515       static unsigned char min() throw()
    00516       { return 0; }
    00517       static unsigned char max() throw()
    00518       { return __SCHAR_MAX__ * 2U + 1; }
    00519 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00520       static unsigned char lowest() throw()
    00521       { return min(); }
    00522 #endif
    00523
    00524       static const int digits = __glibcxx_digits (unsigned char);
    00525       static const int digits10 = __glibcxx_digits10 (unsigned char);
    00526 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00527       static const int max_digits10 = 0;
    00528 #endif
    00529       static const bool is_signed = false;
    00530       static const bool is_integer = true;
    00531       static const bool is_exact = true;
    00532       static const int radix = 2;
    00533       static unsigned char epsilon() throw()
    00534       { return 0; }
    00535       static unsigned char round_error() throw()
    00536       { return 0; }
    00537
    00538       static const int min_exponent = 0;
    00539       static const int min_exponent10 = 0;
    00540       static const int max_exponent = 0;
    00541       static const int max_exponent10 = 0;
    00542
    00543       static const bool has_infinity = false;
    00544       static const bool has_quiet_NaN = false;
    00545       static const bool has_signaling_NaN = false;
    00546       static const float_denorm_style has_denorm = denorm_absent;
    00547       static const bool has_denorm_loss = false;
    00548
    00549       static unsigned char infinity() throw()
    00550       { return static_cast<unsigned char>(0); }
    00551       static unsigned char quiet_NaN() throw()
    00552       { return static_cast<unsigned char>(0); }
    00553       static unsigned char signaling_NaN() throw()
    00554       { return static_cast<unsigned char>(0); }
    00555       static unsigned char denorm_min() throw()
    00556       { return static_cast<unsigned char>(0); }
    00557
    00558       static const bool is_iec559 = false;
    00559       static const bool is_bounded = true;
    00560       static const bool is_modulo = true;
    00561
    00562       static const bool traps = __glibcxx_integral_traps;
    00563       static const bool tinyness_before = false;
    00564       static const float_round_style round_style = round_toward_zero;
    00565     };
    00566
    00567   /// numeric_limits<wchar_t> specialization.
    00568   template<>
    00569     struct numeric_limits<wchar_t>
    00570     {
    00571       static const bool is_specialized = true;
    00572
    00573       static wchar_t min() throw()
    00574       { return __glibcxx_min (wchar_t); }
    00575       static wchar_t max() throw()
    00576       { return __glibcxx_max (wchar_t); }
    00577 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00578       static wchar_t lowest() throw()
    00579       { return min(); }
    00580 #endif
    00581
    00582       static const int digits = __glibcxx_digits (wchar_t);
    00583       static const int digits10 = __glibcxx_digits10 (wchar_t);
    00584 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00585       static const int max_digits10 = 0;
    00586 #endif
    00587       static const bool is_signed = __glibcxx_signed (wchar_t);
    00588       static const bool is_integer = true;
    00589       static const bool is_exact = true;
    00590       static const int radix = 2;
    00591       static wchar_t epsilon() throw()
    00592       { return 0; }
    00593       static wchar_t round_error() throw()
    00594       { return 0; }
    00595
    00596       static const int min_exponent = 0;
    00597       static const int min_exponent10 = 0;
    00598       static const int max_exponent = 0;
    00599       static const int max_exponent10 = 0;
    00600
    00601       static const bool has_infinity = false;
    00602       static const bool has_quiet_NaN = false;
    00603       static const bool has_signaling_NaN = false;
    00604       static const float_denorm_style has_denorm = denorm_absent;
    00605       static const bool has_denorm_loss = false;
    00606
    00607       static wchar_t infinity() throw()
    00608       { return wchar_t(); }
    00609       static wchar_t quiet_NaN() throw()
    00610       { return wchar_t(); }
    00611       static wchar_t signaling_NaN() throw()
    00612       { return wchar_t(); }
    00613       static wchar_t denorm_min() throw()
    00614       { return wchar_t(); }
    00615
    00616       static const bool is_iec559 = false;
    00617       static const bool is_bounded = true;
    00618       static const bool is_modulo = true;
    00619
    00620       static const bool traps = __glibcxx_integral_traps;
    00621       static const bool tinyness_before = false;
    00622       static const float_round_style round_style = round_toward_zero;
    00623     };
    00624
    00625 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00626   /// numeric_limits<char16_t> specialization.
    00627   template<>
    00628     struct numeric_limits<char16_t>
    00629     {
    00630       static const bool is_specialized = true;
    00631
    00632       static char16_t min() throw()
    00633       { return __glibcxx_min (char16_t); }
    00634       static char16_t max() throw()
    00635       { return __glibcxx_max (char16_t); }
    00636 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00637       static char16_t lowest() throw()
    00638       { return min(); }
    00639 #endif
    00640
    00641       static const int digits = __glibcxx_digits (char16_t);
    00642       static const int digits10 = __glibcxx_digits10 (char16_t);
    00643 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00644       static const int max_digits10 = 0;
    00645 #endif
    00646       static const bool is_signed = __glibcxx_signed (char16_t);
    00647       static const bool is_integer = true;
    00648       static const bool is_exact = true;
    00649       static const int radix = 2;
    00650       static char16_t epsilon() throw()
    00651       { return 0; }
    00652       static char16_t round_error() throw()
    00653       { return 0; }
    00654
    00655       static const int min_exponent = 0;
    00656       static const int min_exponent10 = 0;
    00657       static const int max_exponent = 0;
    00658       static const int max_exponent10 = 0;
    00659
    00660       static const bool has_infinity = false;
    00661       static const bool has_quiet_NaN = false;
    00662       static const bool has_signaling_NaN = false;
    00663       static const float_denorm_style has_denorm = denorm_absent;
    00664       static const bool has_denorm_loss = false;
    00665
    00666       static char16_t infinity() throw()
    00667       { return char16_t(); }
    00668       static char16_t quiet_NaN() throw()
    00669       { return char16_t(); }
    00670       static char16_t signaling_NaN() throw()
    00671       { return char16_t(); }
    00672       static char16_t denorm_min() throw()
    00673       { return char16_t(); }
    00674
    00675       static const bool is_iec559 = false;
    00676       static const bool is_bounded = true;
    00677       static const bool is_modulo = true;
    00678
    00679       static const bool traps = __glibcxx_integral_traps;
    00680       static const bool tinyness_before = false;
    00681       static const float_round_style round_style = round_toward_zero;
    00682     };
    00683
    00684   /// numeric_limits<char32_t> specialization.
    00685   template<>
    00686     struct numeric_limits<char32_t>
    00687     {
    00688       static const bool is_specialized = true;
    00689
    00690       static char32_t min() throw()
    00691       { return __glibcxx_min (char32_t); }
    00692       static char32_t max() throw()
    00693       { return __glibcxx_max (char32_t); }
    00694 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00695       static char32_t lowest() throw()
    00696       { return min(); }
    00697 #endif
    00698
    00699       static const int digits = __glibcxx_digits (char32_t);
    00700       static const int digits10 = __glibcxx_digits10 (char32_t);
    00701 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00702       static const int max_digits10 = 0;
    00703 #endif
    00704       static const bool is_signed = __glibcxx_signed (char32_t);
    00705       static const bool is_integer = true;
    00706       static const bool is_exact = true;
    00707       static const int radix = 2;
    00708       static char32_t epsilon() throw()
    00709       { return 0; }
    00710       static char32_t round_error() throw()
    00711       { return 0; }
    00712
    00713       static const int min_exponent = 0;
    00714       static const int min_exponent10 = 0;
    00715       static const int max_exponent = 0;
    00716       static const int max_exponent10 = 0;
    00717
    00718       static const bool has_infinity = false;
    00719       static const bool has_quiet_NaN = false;
    00720       static const bool has_signaling_NaN = false;
    00721       static const float_denorm_style has_denorm = denorm_absent;
    00722       static const bool has_denorm_loss = false;
    00723
    00724       static char32_t infinity() throw()
    00725       { return char32_t(); }
    00726       static char32_t quiet_NaN() throw()
    00727       { return char32_t(); }
    00728       static char32_t signaling_NaN() throw()
    00729       { return char32_t(); }
    00730       static char32_t denorm_min() throw()
    00731       { return char32_t(); }
    00732
    00733       static const bool is_iec559 = false;
    00734       static const bool is_bounded = true;
    00735       static const bool is_modulo = true;
    00736
    00737       static const bool traps = __glibcxx_integral_traps;
    00738       static const bool tinyness_before = false;
    00739       static const float_round_style round_style = round_toward_zero;
    00740     };
    00741 #endif
    00742
    00743   /// numeric_limits<short> specialization.
    00744   template<>
    00745     struct numeric_limits<short>
    00746     {
    00747       static const bool is_specialized = true;
    00748
    00749       static short min() throw()
    00750       { return -__SHRT_MAX__ - 1; }
    00751       static short max() throw()
    00752       { return __SHRT_MAX__; }
    00753 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00754       static short lowest() throw()
    00755       { return min(); }
    00756 #endif
    00757
    00758       static const int digits = __glibcxx_digits (short);
    00759       static const int digits10 = __glibcxx_digits10 (short);
    00760 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00761       static const int max_digits10 = 0;
    00762 #endif
    00763       static const bool is_signed = true;
    00764       static const bool is_integer = true;
    00765       static const bool is_exact = true;
    00766       static const int radix = 2;
    00767       static short epsilon() throw()
    00768       { return 0; }
    00769       static short round_error() throw()
    00770       { return 0; }
    00771
    00772       static const int min_exponent = 0;
    00773       static const int min_exponent10 = 0;
    00774       static const int max_exponent = 0;
    00775       static const int max_exponent10 = 0;
    00776
    00777       static const bool has_infinity = false;
    00778       static const bool has_quiet_NaN = false;
    00779       static const bool has_signaling_NaN = false;
    00780       static const float_denorm_style has_denorm = denorm_absent;
    00781       static const bool has_denorm_loss = false;
    00782
    00783       static short infinity() throw()
    00784       { return short(); }
    00785       static short quiet_NaN() throw()
    00786       { return short(); }
    00787       static short signaling_NaN() throw()
    00788       { return short(); }
    00789       static short denorm_min() throw()
    00790       { return short(); }
    00791
    00792       static const bool is_iec559 = false;
    00793       static const bool is_bounded = true;
    00794       static const bool is_modulo = true;
    00795
    00796       static const bool traps = __glibcxx_integral_traps;
    00797       static const bool tinyness_before = false;
    00798       static const float_round_style round_style = round_toward_zero;
    00799     };
    00800
    00801   /// numeric_limits<unsigned short> specialization.
    00802   template<>
    00803     struct numeric_limits<unsigned short>
    00804     {
    00805       static const bool is_specialized = true;
    00806
    00807       static unsigned short min() throw()
    00808       { return 0; }
    00809       static unsigned short max() throw()
    00810       { return __SHRT_MAX__ * 2U + 1; }
    00811 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00812       static unsigned short lowest() throw()
    00813       { return min(); }
    00814 #endif
    00815
    00816       static const int digits = __glibcxx_digits (unsigned short);
    00817       static const int digits10 = __glibcxx_digits10 (unsigned short);
    00818 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00819       static const int max_digits10 = 0;
    00820 #endif
    00821       static const bool is_signed = false;
    00822       static const bool is_integer = true;
    00823       static const bool is_exact = true;
    00824       static const int radix = 2;
    00825       static unsigned short epsilon() throw()
    00826       { return 0; }
    00827       static unsigned short round_error() throw()
    00828       { return 0; }
    00829
    00830       static const int min_exponent = 0;
    00831       static const int min_exponent10 = 0;
    00832       static const int max_exponent = 0;
    00833       static const int max_exponent10 = 0;
    00834
    00835       static const bool has_infinity = false;
    00836       static const bool has_quiet_NaN = false;
    00837       static const bool has_signaling_NaN = false;
    00838       static const float_denorm_style has_denorm = denorm_absent;
    00839       static const bool has_denorm_loss = false;
    00840
    00841       static unsigned short infinity() throw()
    00842       { return static_cast<unsigned short>(0); }
    00843       static unsigned short quiet_NaN() throw()
    00844       { return static_cast<unsigned short>(0); }
    00845       static unsigned short signaling_NaN() throw()
    00846       { return static_cast<unsigned short>(0); }
    00847       static unsigned short denorm_min() throw()
    00848       { return static_cast<unsigned short>(0); }
    00849
    00850       static const bool is_iec559 = false;
    00851       static const bool is_bounded = true;
    00852       static const bool is_modulo = true;
    00853
    00854       static const bool traps = __glibcxx_integral_traps;
    00855       static const bool tinyness_before = false;
    00856       static const float_round_style round_style = round_toward_zero;
    00857     };
    00858
    00859   /// numeric_limits<int> specialization.
    00860   template<>
    00861     struct numeric_limits<int>
    00862     {
    00863       static const bool is_specialized = true;
    00864
    00865       static int min() throw()
    00866       { return -__INT_MAX__ - 1; }
    00867       static int max() throw()
    00868       { return __INT_MAX__; }
    00869 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00870       static int lowest() throw()
    00871       { return min(); }
    00872 #endif
    00873
    00874       static const int digits = __glibcxx_digits (int);
    00875       static const int digits10 = __glibcxx_digits10 (int);
    00876 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00877       static const int max_digits10 = 0;
    00878 #endif
    00879       static const bool is_signed = true;
    00880       static const bool is_integer = true;
    00881       static const bool is_exact = true;
    00882       static const int radix = 2;
    00883       static int epsilon() throw()
    00884       { return 0; }
    00885       static int round_error() throw()
    00886       { return 0; }
    00887
    00888       static const int min_exponent = 0;
    00889       static const int min_exponent10 = 0;
    00890       static const int max_exponent = 0;
    00891       static const int max_exponent10 = 0;
    00892
    00893       static const bool has_infinity = false;
    00894       static const bool has_quiet_NaN = false;
    00895       static const bool has_signaling_NaN = false;
    00896       static const float_denorm_style has_denorm = denorm_absent;
    00897       static const bool has_denorm_loss = false;
    00898
    00899       static int infinity() throw()
    00900       { return static_cast<int>(0); }
    00901       static int quiet_NaN() throw()
    00902       { return static_cast<int>(0); }
    00903       static int signaling_NaN() throw()
    00904       { return static_cast<int>(0); }
    00905       static int denorm_min() throw()
    00906       { return static_cast<int>(0); }
    00907
    00908       static const bool is_iec559 = false;
    00909       static const bool is_bounded = true;
    00910       static const bool is_modulo = true;
    00911
    00912       static const bool traps = __glibcxx_integral_traps;
    00913       static const bool tinyness_before = false;
    00914       static const float_round_style round_style = round_toward_zero;
    00915     };
    00916
    00917   /// numeric_limits<unsigned int> specialization.
    00918   template<>
    00919     struct numeric_limits<unsigned int>
    00920     {
    00921       static const bool is_specialized = true;
    00922
    00923       static unsigned int min() throw()
    00924       { return 0; }
    00925       static unsigned int max() throw()
    00926       { return __INT_MAX__ * 2U + 1; }
    00927 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00928       static unsigned int lowest() throw()
    00929       { return min(); }
    00930 #endif
    00931
    00932       static const int digits = __glibcxx_digits (unsigned int);
    00933       static const int digits10 = __glibcxx_digits10 (unsigned int);
    00934 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00935       static const int max_digits10 = 0;
    00936 #endif
    00937       static const bool is_signed = false;
    00938       static const bool is_integer = true;
    00939       static const bool is_exact = true;
    00940       static const int radix = 2;
    00941       static unsigned int epsilon() throw()
    00942       { return 0; }
    00943       static unsigned int round_error() throw()
    00944       { return 0; }
    00945
    00946       static const int min_exponent = 0;
    00947       static const int min_exponent10 = 0;
    00948       static const int max_exponent = 0;
    00949       static const int max_exponent10 = 0;
    00950
    00951       static const bool has_infinity = false;
    00952       static const bool has_quiet_NaN = false;
    00953       static const bool has_signaling_NaN = false;
    00954       static const float_denorm_style has_denorm = denorm_absent;
    00955       static const bool has_denorm_loss = false;
    00956
    00957       static unsigned int infinity() throw()
    00958       { return static_cast<unsigned int>(0); }
    00959       static unsigned int quiet_NaN() throw()
    00960       { return static_cast<unsigned int>(0); }
    00961       static unsigned int signaling_NaN() throw()
    00962       { return static_cast<unsigned int>(0); }
    00963       static unsigned int denorm_min() throw()
    00964       { return static_cast<unsigned int>(0); }
    00965
    00966       static const bool is_iec559 = false;
    00967       static const bool is_bounded = true;
    00968       static const bool is_modulo = true;
    00969
    00970       static const bool traps = __glibcxx_integral_traps;
    00971       static const bool tinyness_before = false;
    00972       static const float_round_style round_style = round_toward_zero;
    00973     };
    00974
    00975   /// numeric_limits<long> specialization.
    00976   template<>
    00977     struct numeric_limits<long>
    00978     {
    00979       static const bool is_specialized = true;
    00980
    00981       static long min() throw()
    00982       { return -__LONG_MAX__ - 1; }
    00983       static long max() throw()
    00984       { return __LONG_MAX__; }
    00985 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00986       static long lowest() throw()
    00987       { return min(); }
    00988 #endif
    00989
    00990       static const int digits = __glibcxx_digits (long);
    00991       static const int digits10 = __glibcxx_digits10 (long);
    00992 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00993       static const int max_digits10 = 0;
    00994 #endif
    00995       static const bool is_signed = true;
    00996       static const bool is_integer = true;
    00997       static const bool is_exact = true;
    00998       static const int radix = 2;
    00999       static long epsilon() throw()
    01000       { return 0; }
    01001       static long round_error() throw()
    01002       { return 0; }
    01003
    01004       static const int min_exponent = 0;
    01005       static const int min_exponent10 = 0;
    01006       static const int max_exponent = 0;
    01007       static const int max_exponent10 = 0;
    01008
    01009       static const bool has_infinity = false;
    01010       static const bool has_quiet_NaN = false;
    01011       static const bool has_signaling_NaN = false;
    01012       static const float_denorm_style has_denorm = denorm_absent;
    01013       static const bool has_denorm_loss = false;
    01014
    01015       static long infinity() throw()
    01016       { return static_cast<long>(0); }
    01017       static long quiet_NaN() throw()
    01018       { return static_cast<long>(0); }
    01019       static long signaling_NaN() throw()
    01020       { return static_cast<long>(0); }
    01021       static long denorm_min() throw()
    01022       { return static_cast<long>(0); }
    01023
    01024       static const bool is_iec559 = false;
    01025       static const bool is_bounded = true;
    01026       static const bool is_modulo = true;
    01027
    01028       static const bool traps = __glibcxx_integral_traps;
    01029       static const bool tinyness_before = false;
    01030       static const float_round_style round_style = round_toward_zero;
    01031     };
    01032
    01033   /// numeric_limits<unsigned long> specialization.
    01034   template<>
    01035     struct numeric_limits<unsigned long>
    01036     {
    01037       static const bool is_specialized = true;
    01038
    01039       static unsigned long min() throw()
    01040       { return 0; }
    01041       static unsigned long max() throw()
    01042       { return __LONG_MAX__ * 2UL + 1; }
    01043 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    01044       static unsigned long lowest() throw()
    01045       { return min(); }
    01046 #endif
    01047
    01048       static const int digits = __glibcxx_digits (unsigned long);
    01049       static const int digits10 = __glibcxx_digits10 (unsigned long);
    01050 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    01051       static const int max_digits10 = 0;
    01052 #endif
    01053       static const bool is_signed = false;
    01054       static const bool is_integer = true;
    01055       static const bool is_exact = true;
    01056       static const int radix = 2;
    01057       static unsigned long epsilon() throw()
    01058       { return 0; }
    01059       static unsigned long round_error() throw()
    01060       { return 0; }
    01061
    01062       static const int min_exponent = 0;
    01063       static const int min_exponent10 = 0;
    01064       static const int max_exponent = 0;
    01065       static const int max_exponent10 = 0;
    01066
    01067       static const bool has_infinity = false;
    01068       static const bool has_quiet_NaN = false;
    01069       static const bool has_signaling_NaN = false;
    01070       static const float_denorm_style has_denorm = denorm_absent;
    01071       static const bool has_denorm_loss = false;
    01072
    01073       static unsigned long infinity() throw()
    01074       { return static_cast<unsigned long>(0); }
    01075       static unsigned long quiet_NaN() throw()
    01076       { return static_cast<unsigned long>(0); }
    01077       static unsigned long signaling_NaN() throw()
    01078       { return static_cast<unsigned long>(0); }
    01079       static unsigned long denorm_min() throw()
    01080       { return static_cast<unsigned long>(0); }
    01081
    01082       static const bool is_iec559 = false;
    01083       static const bool is_bounded = true;
    01084       static const bool is_modulo = true;
    01085
    01086       static const bool traps = __glibcxx_integral_traps;
    01087       static const bool tinyness_before = false;
    01088       static const float_round_style round_style = round_toward_zero;
    01089     };
    01090
    01091   /// numeric_limits<long long> specialization.
    01092   template<>
    01093     struct numeric_limits<long long>
    01094     {
    01095       static const bool is_specialized = true;
    01096
    01097       static long long min() throw()
    01098       { return -__LONG_LONG_MAX__ - 1; }
    01099       static long long max() throw()
    01100       { return __LONG_LONG_MAX__; }
    01101 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    01102       static long long lowest() throw()
    01103       { return min(); }
    01104 #endif
    01105
    01106       static const int digits = __glibcxx_digits (long long);
    01107       static const int digits10 = __glibcxx_digits10 (long long);
    01108 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    01109       static const int max_digits10 = 0;
    01110 #endif
    01111       static const bool is_signed = true;
    01112       static const bool is_integer = true;
    01113       static const bool is_exact = true;
    01114       static const int radix = 2;
    01115       static long long epsilon() throw()
    01116       { return 0; }
    01117       static long long round_error() throw()
    01118       { return 0; }
    01119
    01120       static const int min_exponent = 0;
    01121       static const int min_exponent10 = 0;
    01122       static const int max_exponent = 0;
    01123       static const int max_exponent10 = 0;
    01124
    01125       static const bool has_infinity = false;
    01126       static const bool has_quiet_NaN = false;
    01127       static const bool has_signaling_NaN = false;
    01128       static const float_denorm_style has_denorm = denorm_absent;
    01129       static const bool has_denorm_loss = false;
    01130
    01131       static long long infinity() throw()
    01132       { return static_cast<long long>(0); }
    01133       static long long quiet_NaN() throw()
    01134       { return static_cast<long long>(0); }
    01135       static long long signaling_NaN() throw()
    01136       { return static_cast<long long>(0); }
    01137       static long long denorm_min() throw()
    01138       { return static_cast<long long>(0); }
    01139
    01140       static const bool is_iec559 = false;
    01141       static const bool is_bounded = true;
    01142       static const bool is_modulo = true;
    01143
    01144       static const bool traps = __glibcxx_integral_traps;
    01145       static const bool tinyness_before = false;
    01146       static const float_round_style round_style = round_toward_zero;
    01147     };
    01148
    01149   /// numeric_limits<unsigned long long> specialization.
    01150   template<>
    01151     struct numeric_limits<unsigned long long>
    01152     {
    01153       static const bool is_specialized = true;
    01154
    01155       static unsigned long long min() throw()
    01156       { return 0; }
    01157       static unsigned long long max() throw()
    01158       { return __LONG_LONG_MAX__ * 2ULL + 1; }
    01159 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    01160       static unsigned long long lowest() throw()
    01161       { return min(); }
    01162 #endif
    01163
    01164       static const int digits = __glibcxx_digits (unsigned long long);
    01165       static const int digits10 = __glibcxx_digits10 (unsigned long long);
    01166 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    01167       static const int max_digits10 = 0;
    01168 #endif
    01169       static const bool is_signed = false;
    01170       static const bool is_integer = true;
    01171       static const bool is_exact = true;
    01172       static const int radix = 2;
    01173       static unsigned long long epsilon() throw()
    01174       { return 0; }
    01175       static unsigned long long round_error() throw()
    01176       { return 0; }
    01177
    01178       static const int min_exponent = 0;
    01179       static const int min_exponent10 = 0;
    01180       static const int max_exponent = 0;
    01181       static const int max_exponent10 = 0;
    01182
    01183       static const bool has_infinity = false;
    01184       static const bool has_quiet_NaN = false;
    01185       static const bool has_signaling_NaN = false;
    01186       static const float_denorm_style has_denorm = denorm_absent;
    01187       static const bool has_denorm_loss = false;
    01188
    01189       static unsigned long long infinity() throw()
    01190       { return static_cast<unsigned long long>(0); }
    01191       static unsigned long long quiet_NaN() throw()
    01192       { return static_cast<unsigned long long>(0); }
    01193       static unsigned long long signaling_NaN() throw()
    01194       { return static_cast<unsigned long long>(0); }
    01195       static unsigned long long denorm_min() throw()
    01196       { return static_cast<unsigned long long>(0); }
    01197
    01198       static const bool is_iec559 = false;
    01199       static const bool is_bounded = true;
    01200       static const bool is_modulo = true;
    01201
    01202       static const bool traps = __glibcxx_integral_traps;
    01203       static const bool tinyness_before = false;
    01204       static const float_round_style round_style = round_toward_zero;
    01205     };
    01206
    01207   /// numeric_limits<float> specialization.
    01208   template<>
    01209     struct numeric_limits<float>
    01210     {
    01211       static const bool is_specialized = true;
    01212
    01213       static float min() throw()
    01214       { return __FLT_MIN__; }
    01215       static float max() throw()
    01216       { return __FLT_MAX__; }
    01217 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    01218       static float lowest() throw()
    01219       { return -__FLT_MAX__; }
    01220 #endif
    01221
    01222       static const int digits = __FLT_MANT_DIG__;
    01223       static const int digits10 = __FLT_DIG__;
    01224 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    01225       static const int max_digits10
    01226      = __glibcxx_max_digits10 (__FLT_MANT_DIG__);
    01227 #endif
    01228       static const bool is_signed = true;
    01229       static const bool is_integer = false;
    01230       static const bool is_exact = false;
    01231       static const int radix = __FLT_RADIX__;
    01232       static float epsilon() throw()
    01233       { return __FLT_EPSILON__; }
    01234       static float round_error() throw()
    01235       { return 0.5F; }
    01236
    01237       static const int min_exponent = __FLT_MIN_EXP__;
    01238       static const int min_exponent10 = __FLT_MIN_10_EXP__;
    01239       static const int max_exponent = __FLT_MAX_EXP__;
    01240       static const int max_exponent10 = __FLT_MAX_10_EXP__;
    01241
    01242       static const bool has_infinity = __FLT_HAS_INFINITY__;
    01243       static const bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__;
    01244       static const bool has_signaling_NaN = has_quiet_NaN;
    01245       static const float_denorm_style has_denorm
    01246     = bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent;
    01247       static const bool has_denorm_loss = __glibcxx_float_has_denorm_loss;
    01248
    01249       static float infinity() throw()
    01250       { return __builtin_huge_valf (); }
    01251       static float quiet_NaN() throw()
    01252       { return __builtin_nanf (""); }
    01253       static float signaling_NaN() throw()
    01254       { return __builtin_nansf (""); }
    01255       static float denorm_min() throw()
    01256       { return __FLT_DENORM_MIN__; }
    01257
    01258       static const bool is_iec559
    01259     = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
    01260       static const bool is_bounded = true;
    01261       static const bool is_modulo = false;
    01262
    01263       static const bool traps = __glibcxx_float_traps;
    01264       static const bool tinyness_before = __glibcxx_float_tinyness_before;
    01265       static const float_round_style round_style = round_to_nearest;
    01266     };
    01267
    01268 #undef __glibcxx_float_has_denorm_loss
    01269 #undef __glibcxx_float_traps
    01270 #undef __glibcxx_float_tinyness_before
    01271
    01272   /// numeric_limits<double> specialization.
    01273   template<>
    01274     struct numeric_limits<double>
    01275     {
    01276       static const bool is_specialized = true;
    01277
    01278       static double min() throw()
    01279       { return __DBL_MIN__; }
    01280       static double max() throw()
    01281       { return __DBL_MAX__; }
    01282 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    01283       static double lowest() throw()
    01284       { return -__DBL_MAX__; }
    01285 #endif
    01286
    01287       static const int digits = __DBL_MANT_DIG__;
    01288       static const int digits10 = __DBL_DIG__;
    01289 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    01290       static const int max_digits10
    01291      = __glibcxx_max_digits10 (__DBL_MANT_DIG__);
    01292 #endif
    01293       static const bool is_signed = true;
    01294       static const bool is_integer = false;
    01295       static const bool is_exact = false;
    01296       static const int radix = __FLT_RADIX__;
    01297       static double epsilon() throw()
    01298       { return __DBL_EPSILON__; }
    01299       static double round_error() throw()
    01300       { return 0.5; }
    01301
    01302       static const int min_exponent = __DBL_MIN_EXP__;
    01303       static const int min_exponent10 = __DBL_MIN_10_EXP__;
    01304       static const int max_exponent = __DBL_MAX_EXP__;
    01305       static const int max_exponent10 = __DBL_MAX_10_EXP__;
    01306
    01307       static const bool has_infinity = __DBL_HAS_INFINITY__;
    01308       static const bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__;
    01309       static const bool has_signaling_NaN = has_quiet_NaN;
    01310       static const float_denorm_style has_denorm
    01311     = bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent;
    01312       static const bool has_denorm_loss = __glibcxx_double_has_denorm_loss;
    01313
    01314       static double infinity() throw()
    01315       { return __builtin_huge_val(); }
    01316       static double quiet_NaN() throw()
    01317       { return __builtin_nan (""); }
    01318       static double signaling_NaN() throw()
    01319       { return __builtin_nans (""); }
    01320       static double denorm_min() throw()
    01321       { return __DBL_DENORM_MIN__; }
    01322
    01323       static const bool is_iec559
    01324     = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
    01325       static const bool is_bounded = true;
    01326       static const bool is_modulo = false;
    01327
    01328       static const bool traps = __glibcxx_double_traps;
    01329       static const bool tinyness_before = __glibcxx_double_tinyness_before;
    01330       static const float_round_style round_style = round_to_nearest;
    01331     };
    01332
    01333 #undef __glibcxx_double_has_denorm_loss
    01334 #undef __glibcxx_double_traps
    01335 #undef __glibcxx_double_tinyness_before
    01336
    01337   /// numeric_limits<long double> specialization.
    01338   template<>
    01339     struct numeric_limits<long double>
    01340     {
    01341       static const bool is_specialized = true;
    01342
    01343       static long double min() throw()
    01344       { return __LDBL_MIN__; }
    01345       static long double max() throw()
    01346       { return __LDBL_MAX__; }
    01347 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    01348       static long double lowest() throw()
    01349       { return -__LDBL_MAX__; }
    01350 #endif
    01351
    01352       static const int digits = __LDBL_MANT_DIG__;
    01353       static const int digits10 = __LDBL_DIG__;
    01354 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    01355       static const int max_digits10
    01356      = __glibcxx_max_digits10 (__LDBL_MANT_DIG__);
    01357 #endif
    01358       static const bool is_signed = true;
    01359       static const bool is_integer = false;
    01360       static const bool is_exact = false;
    01361       static const int radix = __FLT_RADIX__;
    01362       static long double epsilon() throw()
    01363       { return __LDBL_EPSILON__; }
    01364       static long double round_error() throw()
    01365       { return 0.5L; }
    01366
    01367       static const int min_exponent = __LDBL_MIN_EXP__;
    01368       static const int min_exponent10 = __LDBL_MIN_10_EXP__;
    01369       static const int max_exponent = __LDBL_MAX_EXP__;
    01370       static const int max_exponent10 = __LDBL_MAX_10_EXP__;
    01371
    01372       static const bool has_infinity = __LDBL_HAS_INFINITY__;
    01373       static const bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__;
    01374       static const bool has_signaling_NaN = has_quiet_NaN;
    01375       static const float_denorm_style has_denorm
    01376     = bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent;
    01377       static const bool has_denorm_loss
    01378     = __glibcxx_long_double_has_denorm_loss;
    01379
    01380       static long double infinity() throw()
    01381       { return __builtin_huge_vall (); }
    01382       static long double quiet_NaN() throw()
    01383       { return __builtin_nanl (""); }
    01384       static long double signaling_NaN() throw()
    01385       { return __builtin_nansl (""); }
    01386       static long double denorm_min() throw()
    01387       { return __LDBL_DENORM_MIN__; }
    01388
    01389       static const bool is_iec559
    01390     = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
    01391       static const bool is_bounded = true;
    01392       static const bool is_modulo = false;
    01393
    01394       static const bool traps = __glibcxx_long_double_traps;
    01395       static const bool tinyness_before = __glibcxx_long_double_tinyness_before;
    01396       static const float_round_style round_style = round_to_nearest;
    01397     };
    01398
    01399 #undef __glibcxx_long_double_has_denorm_loss
    01400 #undef __glibcxx_long_double_traps
    01401 #undef __glibcxx_long_double_tinyness_before
    01402
    01403 _GLIBCXX_END_NAMESPACE
    01404
    01405 #undef __glibcxx_signed
    01406 #undef __glibcxx_min
    01407 #undef __glibcxx_max
    01408 #undef __glibcxx_digits
    01409 #undef __glibcxx_digits10
    01410 #undef __glibcxx_max_digits10
    01411
    01412 #endif // _GLIBCXX_NUMERIC_LIMITS