l4/pkg/libstdc++-v3/contrib/libstdc++-v3-4.6/include/std/limits

   1 // The template and inlines for the numeric_limits classes. -*- C++ -*-
   2
   3 // Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
   4 // 2008, 2009, 2010  Free Software Foundation, Inc.
   5 //
   6 // This file is part of the GNU ISO C++ Library.  This library is free
   7 // software; you can redistribute it and/or modify it under the
   8 // terms of the GNU General Public License as published by the
   9 // Free Software Foundation; either version 3, or (at your option)
  10 // any later version.
  11
  12 // This library is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16
  17 // Under Section 7 of GPL version 3, you are granted additional
  18 // permissions described in the GCC Runtime Library Exception, version
  19 // 3.1, as published by the Free Software Foundation.
  20
  21 // You should have received a copy of the GNU General Public License and
  22 // a copy of the GCC Runtime Library Exception along with this program;
  23 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  24 // <http://www.gnu.org/licenses/>.
  25
  26 /** @file include/limits
  27  *  This is a Standard C++ Library header.
  28  */
  29
  30 // Note: this is not a conforming implementation.
  31 // Written by Gabriel Dos Reis <gdr@codesourcery.com>
  32
  33 //
  34 // ISO 14882:1998
  35 // 18.2.1
  36 //
  37
  38 #ifndef _GLIBCXX_NUMERIC_LIMITS
  39 #define _GLIBCXX_NUMERIC_LIMITS 1
  40
  41 #pragma GCC system_header
  42
  43 #include <bits/c++config.h>
  44
  45 //
  46 // The numeric_limits<> traits document implementation-defined aspects
  47 // of fundamental arithmetic data types (integers and floating points).
  48 // From Standard C++ point of view, there are 14 such types:
  49 //   * integers
  50 //         bool                                                 (1)
  51 //         char, signed char, unsigned char, wchar_t            (4)
  52 //         short, unsigned short                                (2)
  53 //         int, unsigned                                        (2)
  54 //         long, unsigned long                                  (2)
  55 //
  56 //   * floating points
  57 //         float                                                (1)
  58 //         double                                               (1)
  59 //         long double                                          (1)
  60 //
  61 // GNU C++ understands (where supported by the host C-library)
  62 //   * integer
  63 //         long long, unsigned long long                        (2)
  64 //
  65 // which brings us to 16 fundamental arithmetic data types in GNU C++.
  66 //
  67 //
  68 // Since a numeric_limits<> is a bit tricky to get right, we rely on
  69 // an interface composed of macros which should be defined in config/os
  70 // or config/cpu when they differ from the generic (read arbitrary)
  71 // definitions given here.
  72 //
  73
  74 // These values can be overridden in the target configuration file.
  75 // The default values are appropriate for many 32-bit targets.
  76
  77 // GCC only intrinsically supports modulo integral types.  The only remaining
  78 // integral exceptional values is division by zero.  Only targets that do not
  79 // signal division by zero in some "hard to ignore" way should use false.
  80 #ifndef __glibcxx_integral_traps
  81 # define __glibcxx_integral_traps true
  82 #endif
  83
  84 // float
  85 //
  86
  87 // Default values.  Should be overridden in configuration files if necessary.
  88
  89 #ifndef __glibcxx_float_has_denorm_loss
  90 #  define __glibcxx_float_has_denorm_loss false
  91 #endif
  92 #ifndef __glibcxx_float_traps
  93 #  define __glibcxx_float_traps false
  94 #endif
  95 #ifndef __glibcxx_float_tinyness_before
  96 #  define __glibcxx_float_tinyness_before false
  97 #endif
  98
  99 // double
 100
 101 // Default values.  Should be overridden in configuration files if necessary.
 102
 103 #ifndef __glibcxx_double_has_denorm_loss
 104 #  define __glibcxx_double_has_denorm_loss false
 105 #endif
 106 #ifndef __glibcxx_double_traps
 107 #  define __glibcxx_double_traps false
 108 #endif
 109 #ifndef __glibcxx_double_tinyness_before
 110 #  define __glibcxx_double_tinyness_before false
 111 #endif
 112
 113 // long double
 114
 115 // Default values.  Should be overridden in configuration files if necessary.
 116
 117 #ifndef __glibcxx_long_double_has_denorm_loss
 118 #  define __glibcxx_long_double_has_denorm_loss false
 119 #endif
 120 #ifndef __glibcxx_long_double_traps
 121 #  define __glibcxx_long_double_traps false
 122 #endif
 123 #ifndef __glibcxx_long_double_tinyness_before
 124 #  define __glibcxx_long_double_tinyness_before false
 125 #endif
 126
 127 // You should not need to define any macros below this point.
 128
 129 #define __glibcxx_signed(T)     ((T)(-1) < 0)
 130
 131 #define __glibcxx_min(T) \
 132   (__glibcxx_signed (T) ? (T)1 << __glibcxx_digits (T) : (T)0)
 133
 134 #define __glibcxx_max(T) \
 135   (__glibcxx_signed (T) ? \
 136    (((((T)1 << (__glibcxx_digits (T) - 1)) - 1) << 1) + 1) : ~(T)0)
 137
 138 #define __glibcxx_digits(T) \
 139   (sizeof(T) * __CHAR_BIT__ - __glibcxx_signed (T))
 140
 141 // The fraction 643/2136 approximates log10(2) to 7 significant digits.
 142 #define __glibcxx_digits10(T) \
 143   (__glibcxx_digits (T) * 643L / 2136)
 144
 145 #define __glibcxx_max_digits10(T) \
 146   (2 + (T) * 643L / 2136)
 147
 148 namespace std _GLIBCXX_VISIBILITY(default)
 149 {
 150 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 151
 152   /**
 153    *  @brief Describes the rounding style for floating-point types.
 154    *
 155    *  This is used in the std::numeric_limits class.
 156   */
 157   enum float_round_style
 158   {
 159     round_indeterminate       = -1,    /// Intermediate.
 160     round_toward_zero         = 0,     /// To zero.
 161     round_to_nearest          = 1,     /// To the nearest representable value.
 162     round_toward_infinity     = 2,     /// To infinity.
 163     round_toward_neg_infinity = 3      /// To negative infinity.
 164   };
 165
 166   /**
 167    *  @brief Describes the denormalization for floating-point types.
 168    *
 169    *  These values represent the presence or absence of a variable number
 170    *  of exponent bits.  This type is used in the std::numeric_limits class.
 171   */
 172   enum float_denorm_style
 173   {
 174     /// Indeterminate at compile time whether denormalized values are allowed.
 175     denorm_indeterminate = -1,
 176     /// The type does not allow denormalized values.
 177     denorm_absent        = 0,
 178     /// The type allows denormalized values.
 179     denorm_present       = 1
 180   };
 181
 182   /**
 183    *  @brief Part of std::numeric_limits.
 184    *
 185    *  The @c static @c const members are usable as integral constant
 186    *  expressions.
 187    *
 188    *  @note This is a separate class for purposes of efficiency; you
 189    *        should only access these members as part of an instantiation
 190    *        of the std::numeric_limits class.
 191   */
 192   struct __numeric_limits_base
 193   {
 194     /** This will be true for all fundamental types (which have
 195         specializations), and false for everything else.  */
 196     static _GLIBCXX_USE_CONSTEXPR bool is_specialized = false;
 197
 198     /** The number of @c radix digits that be represented without change:  for
 199         integer types, the number of non-sign bits in the mantissa; for
 200         floating types, the number of @c radix digits in the mantissa.  */
 201     static _GLIBCXX_USE_CONSTEXPR int digits = 0;
 202
 203     /** The number of base 10 digits that can be represented without change. */
 204     static _GLIBCXX_USE_CONSTEXPR int digits10 = 0;
 205
 206 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 207     /** The number of base 10 digits required to ensure that values which
 208         differ are always differentiated.  */
 209     static constexpr int max_digits10 = 0;
 210 #endif
 211
 212     /** True if the type is signed.  */
 213     static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
 214
 215     /** True if the type is integer.
 216      *  Is this supposed to be <em>if the type is integral?</em>  */
 217     static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
 218
 219     /** True if the type uses an exact representation. <em>All integer types are
 220         exact, but not all exact types are integer.  For example, rational and
 221         fixed-exponent representations are exact but not integer.</em>
 222         [18.2.1.2]/15  */
 223     static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
 224
 225     /** For integer types, specifies the base of the representation.  For
 226         floating types, specifies the base of the exponent representation.  */
 227     static _GLIBCXX_USE_CONSTEXPR int radix = 0;
 228
 229     /** The minimum negative integer such that @c radix raised to the power of
 230         (one less than that integer) is a normalized floating point number.  */
 231     static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
 232
 233     /** The minimum negative integer such that 10 raised to that power is in
 234         the range of normalized floating point numbers.  */
 235     static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
 236
 237     /** The maximum positive integer such that @c radix raised to the power of
 238         (one less than that integer) is a representable finite floating point
 239         number.  */
 240     static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
 241
 242     /** The maximum positive integer such that 10 raised to that power is in
 243         the range of representable finite floating point numbers.  */
 244     static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
 245
 246     /** True if the type has a representation for positive infinity.  */
 247     static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
 248
 249     /** True if the type has a representation for a quiet (non-signaling)
 250         <em>Not a Number</em>.  */
 251     static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
 252
 253     /** True if the type has a representation for a signaling
 254         <em>Not a Number</em>.  */
 255     static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
 256
 257     /** See std::float_denorm_style for more information.  */
 258     static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent;
 259
 260     /** <em>True if loss of accuracy is detected as a denormalization loss,
 261         rather than as an inexact result.</em> [18.2.1.2]/42  */
 262     static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 263
 264     /** True if-and-only-if the type adheres to the IEC 559 standard, also
 265         known as IEEE 754.  (Only makes sense for floating point types.)  */
 266     static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
 267
 268     /** <em>True if the set of values representable by the type is
 269         finite.  All built-in types are bounded, this member would be
 270         false for arbitrary precision types.</em> [18.2.1.2]/54  */
 271     static _GLIBCXX_USE_CONSTEXPR bool is_bounded = false;
 272
 273     /** True if the type is @e modulo, that is, if it is possible to add two
 274         positive numbers and have a result that wraps around to a third number
 275         that is less.  Typically false for floating types, true for unsigned
 276         integers, and true for signed integers.  */
 277     static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
 278
 279     /** True if trapping is implemented for this type.  */
 280     static _GLIBCXX_USE_CONSTEXPR bool traps = false;
 281
 282     /** True if tininess is detected before rounding.  (see IEC 559)  */
 283     static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
 284
 285     /** See std::float_round_style for more information.  This is only
 286         meaningful for floating types; integer types will all be
 287         round_toward_zero.  */
 288     static _GLIBCXX_USE_CONSTEXPR float_round_style round_style =
 289                                                     round_toward_zero;
 290   };
 291
 292   /**
 293    *  @brief Properties of fundamental types.
 294    *
 295    *  This class allows a program to obtain information about the
 296    *  representation of a fundamental type on a given platform.  For
 297    *  non-fundamental types, the functions will return 0 and the data
 298    *  members will all be @c false.
 299    *
 300    *  _GLIBCXX_RESOLVE_LIB_DEFECTS:  DRs 201 and 184 (hi Gaby!) are
 301    *  noted, but not incorporated in this documented (yet).
 302   */
 303   template<typename _Tp>
 304     struct numeric_limits : public __numeric_limits_base
 305     {
 306       /** The minimum finite value, or for floating types with
 307           denormalization, the minimum positive normalized value.  */
 308       static _GLIBCXX_CONSTEXPR _Tp
 309       min() throw() { return static_cast<_Tp>(0); }
 310
 311       /** The maximum finite value.  */
 312       static _GLIBCXX_CONSTEXPR _Tp
 313       max() throw() { return static_cast<_Tp>(0); }
 314
 315 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 316       /** A finite value x such that there is no other finite value y
 317        *  where y < x.  */
 318       static constexpr _Tp
 319       lowest() throw() { return static_cast<_Tp>(0); }
 320 #endif
 321
 322       /** The @e machine @e epsilon:  the difference between 1 and the least
 323           value greater than 1 that is representable.  */
 324       static _GLIBCXX_CONSTEXPR _Tp
 325       epsilon() throw() { return static_cast<_Tp>(0); }
 326
 327       /** The maximum rounding error measurement (see LIA-1).  */
 328       static _GLIBCXX_CONSTEXPR _Tp
 329       round_error() throw() { return static_cast<_Tp>(0); }
 330
 331       /** The representation of positive infinity, if @c has_infinity.  */
 332       static _GLIBCXX_CONSTEXPR _Tp
 333       infinity() throw()  { return static_cast<_Tp>(0); }
 334
 335       /** The representation of a quiet <em>Not a Number</em>,
 336           if @c has_quiet_NaN. */
 337       static _GLIBCXX_CONSTEXPR _Tp
 338       quiet_NaN() throw() { return static_cast<_Tp>(0); }
 339
 340       /** The representation of a signaling <em>Not a Number</em>, if
 341           @c has_signaling_NaN. */
 342       static _GLIBCXX_CONSTEXPR _Tp
 343       signaling_NaN() throw() { return static_cast<_Tp>(0); }
 344
 345       /** The minimum positive denormalized value.  For types where
 346           @c has_denorm is false, this is the minimum positive normalized
 347           value.  */
 348       static _GLIBCXX_CONSTEXPR _Tp
 349       denorm_min() throw() { return static_cast<_Tp>(0); }
 350     };
 351
 352 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 353   template<typename _Tp>
 354     struct numeric_limits<const _Tp>
 355     : public numeric_limits<_Tp> { };
 356
 357   template<typename _Tp>
 358     struct numeric_limits<volatile _Tp>
 359     : public numeric_limits<_Tp> { };
 360
 361   template<typename _Tp>
 362     struct numeric_limits<const volatile _Tp>
 363     : public numeric_limits<_Tp> { };
 364 #endif
 365
 366   // Now there follow 16 explicit specializations.  Yes, 16.  Make sure
 367   // you get the count right. (18 in c++0x mode)
 368
 369   /// numeric_limits<bool> specialization.
 370   template<>
 371     struct numeric_limits<bool>
 372     {
 373       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 374
 375       static _GLIBCXX_CONSTEXPR bool
 376       min() throw() { return false; }
 377
 378       static _GLIBCXX_CONSTEXPR bool
 379       max() throw()  { return true; }
 380
 381 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 382       static constexpr bool
 383       lowest() throw() { return min(); }
 384 #endif
 385       static _GLIBCXX_USE_CONSTEXPR int digits = 1;
 386       static _GLIBCXX_USE_CONSTEXPR int digits10 = 0;
 387 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 388       static constexpr int max_digits10 = 0;
 389 #endif
 390       static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
 391       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
 392       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
 393       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
 394
 395       static _GLIBCXX_CONSTEXPR bool
 396       epsilon() throw() { return false; }
 397
 398       static _GLIBCXX_CONSTEXPR bool
 399       round_error() throw() { return false; }
 400
 401       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
 402       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
 403       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
 404       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
 405
 406       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
 407       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
 408       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
 409       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
 410        = denorm_absent;
 411       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 412
 413       static _GLIBCXX_CONSTEXPR bool
 414       infinity() throw() { return false; }
 415
 416       static _GLIBCXX_CONSTEXPR bool
 417       quiet_NaN() throw() { return false; }
 418
 419       static _GLIBCXX_CONSTEXPR bool
 420       signaling_NaN() throw() { return false; }
 421
 422       static _GLIBCXX_CONSTEXPR bool
 423       denorm_min() throw() { return false; }
 424
 425       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
 426       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
 427       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
 428
 429       // It is not clear what it means for a boolean type to trap.
 430       // This is a DR on the LWG issue list.  Here, I use integer
 431       // promotion semantics.
 432       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
 433       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
 434       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
 435        = round_toward_zero;
 436     };
 437
 438   /// numeric_limits<char> specialization.
 439   template<>
 440     struct numeric_limits<char>
 441     {
 442       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 443
 444       static _GLIBCXX_CONSTEXPR char
 445       min() throw() { return __glibcxx_min(char); }
 446
 447       static _GLIBCXX_CONSTEXPR char
 448       max() throw() { return __glibcxx_max(char); }
 449
 450 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 451       static constexpr char
 452       lowest() throw() { return min(); }
 453 #endif
 454
 455       static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char);
 456       static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (char);
 457 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 458       static constexpr int max_digits10 = 0;
 459 #endif
 460       static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (char);
 461       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
 462       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
 463       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
 464
 465       static _GLIBCXX_CONSTEXPR char
 466       epsilon() throw() { return 0; }
 467
 468       static _GLIBCXX_CONSTEXPR char
 469       round_error() throw() { return 0; }
 470
 471       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
 472       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
 473       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
 474       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
 475
 476       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
 477       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
 478       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
 479       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
 480        = denorm_absent;
 481       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 482
 483       static _GLIBCXX_CONSTEXPR
 484       char infinity() throw()  { return char(); }
 485
 486       static _GLIBCXX_CONSTEXPR char
 487       quiet_NaN() throw() { return char(); }
 488
 489       static _GLIBCXX_CONSTEXPR char
 490       signaling_NaN() throw() { return char(); }
 491
 492       static _GLIBCXX_CONSTEXPR char
 493       denorm_min() throw() { return static_cast<char>(0); }
 494
 495       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
 496       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
 497       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
 498
 499       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
 500       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
 501       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
 502        = round_toward_zero;
 503     };
 504
 505   /// numeric_limits<signed char> specialization.
 506   template<>
 507     struct numeric_limits<signed char>
 508     {
 509       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 510
 511       static _GLIBCXX_CONSTEXPR signed char
 512       min() throw() { return -__SCHAR_MAX__ - 1; }
 513
 514       static _GLIBCXX_CONSTEXPR signed char
 515       max() throw() { return __SCHAR_MAX__; }
 516
 517 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 518       static constexpr signed char
 519       lowest() throw() { return min(); }
 520 #endif
 521
 522       static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (signed char);
 523       static _GLIBCXX_USE_CONSTEXPR int digits10
 524        = __glibcxx_digits10 (signed char);
 525 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 526       static constexpr int max_digits10 = 0;
 527 #endif
 528       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
 529       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
 530       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
 531       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
 532
 533       static _GLIBCXX_CONSTEXPR signed char
 534       epsilon() throw() { return 0; }
 535
 536       static _GLIBCXX_CONSTEXPR signed char
 537       round_error() throw() { return 0; }
 538
 539       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
 540       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
 541       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
 542       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
 543
 544       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
 545       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
 546       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
 547       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
 548        = denorm_absent;
 549       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 550
 551       static _GLIBCXX_CONSTEXPR signed char
 552       infinity() throw() { return static_cast<signed char>(0); }
 553
 554       static _GLIBCXX_CONSTEXPR signed char
 555       quiet_NaN() throw() { return static_cast<signed char>(0); }
 556
 557       static _GLIBCXX_CONSTEXPR signed char
 558       signaling_NaN() throw() { return static_cast<signed char>(0); }
 559
 560       static _GLIBCXX_CONSTEXPR signed char
 561       denorm_min() throw() { return static_cast<signed char>(0); }
 562
 563       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
 564       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
 565       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
 566
 567       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
 568       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
 569       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
 570        = round_toward_zero;
 571     };
 572
 573   /// numeric_limits<unsigned char> specialization.
 574   template<>
 575     struct numeric_limits<unsigned char>
 576     {
 577       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 578
 579       static _GLIBCXX_CONSTEXPR unsigned char
 580       min() throw() { return 0; }
 581
 582       static _GLIBCXX_CONSTEXPR unsigned char
 583       max() throw() { return __SCHAR_MAX__ * 2U + 1; }
 584
 585 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 586       static constexpr unsigned char
 587       lowest() throw() { return min(); }
 588 #endif
 589
 590       static _GLIBCXX_USE_CONSTEXPR int digits
 591        = __glibcxx_digits (unsigned char);
 592       static _GLIBCXX_USE_CONSTEXPR int digits10
 593        = __glibcxx_digits10 (unsigned char);
 594 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 595       static constexpr int max_digits10 = 0;
 596 #endif
 597       static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
 598       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
 599       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
 600       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
 601
 602       static _GLIBCXX_CONSTEXPR unsigned char
 603       epsilon() throw() { return 0; }
 604
 605       static _GLIBCXX_CONSTEXPR unsigned char
 606       round_error() throw() { return 0; }
 607
 608       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
 609       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
 610       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
 611       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
 612
 613       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
 614       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
 615       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
 616       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
 617        = denorm_absent;
 618       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 619
 620       static _GLIBCXX_CONSTEXPR unsigned char
 621       infinity() throw() { return static_cast<unsigned char>(0); }
 622
 623       static _GLIBCXX_CONSTEXPR unsigned char
 624       quiet_NaN() throw() { return static_cast<unsigned char>(0); }
 625
 626       static _GLIBCXX_CONSTEXPR unsigned char
 627       signaling_NaN() throw() { return static_cast<unsigned char>(0); }
 628
 629       static _GLIBCXX_CONSTEXPR unsigned char
 630       denorm_min() throw() { return static_cast<unsigned char>(0); }
 631
 632       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
 633       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
 634       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
 635
 636       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
 637       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
 638       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
 639        = round_toward_zero;
 640     };
 641
 642   /// numeric_limits<wchar_t> specialization.
 643   template<>
 644     struct numeric_limits<wchar_t>
 645     {
 646       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 647
 648       static _GLIBCXX_CONSTEXPR wchar_t
 649       min() throw() { return __glibcxx_min (wchar_t); }
 650
 651       static _GLIBCXX_CONSTEXPR wchar_t
 652       max() throw()  { return __glibcxx_max (wchar_t); }
 653
 654 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 655       static constexpr wchar_t
 656       lowest() throw() { return min(); }
 657 #endif
 658
 659       static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (wchar_t);
 660       static _GLIBCXX_USE_CONSTEXPR int digits10
 661        = __glibcxx_digits10 (wchar_t);
 662 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 663       static constexpr int max_digits10 = 0;
 664 #endif
 665       static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (wchar_t);
 666       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
 667       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
 668       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
 669
 670       static _GLIBCXX_CONSTEXPR wchar_t
 671       epsilon() throw() { return 0; }
 672
 673       static _GLIBCXX_CONSTEXPR wchar_t
 674       round_error() throw() { return 0; }
 675
 676       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
 677       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
 678       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
 679       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
 680
 681       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
 682       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
 683       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
 684       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
 685        = denorm_absent;
 686       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 687
 688       static _GLIBCXX_CONSTEXPR wchar_t
 689       infinity() throw() { return wchar_t(); }
 690
 691       static _GLIBCXX_CONSTEXPR wchar_t
 692       quiet_NaN() throw() { return wchar_t(); }
 693
 694       static _GLIBCXX_CONSTEXPR wchar_t
 695       signaling_NaN() throw() { return wchar_t(); }
 696
 697       static _GLIBCXX_CONSTEXPR wchar_t
 698       denorm_min() throw() { return wchar_t(); }
 699
 700       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
 701       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
 702       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
 703
 704       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
 705       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
 706       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
 707        = round_toward_zero;
 708     };
 709
 710 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 711   /// numeric_limits<char16_t> specialization.
 712   template<>
 713     struct numeric_limits<char16_t>
 714     {
 715       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 716
 717       static _GLIBCXX_CONSTEXPR char16_t
 718       min() throw() { return __glibcxx_min (char16_t); }
 719
 720       static _GLIBCXX_CONSTEXPR char16_t
 721       max() throw() { return __glibcxx_max (char16_t); }
 722
 723 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 724       static constexpr char16_t
 725       lowest() throw() { return min(); }
 726 #endif
 727
 728       static _GLIBCXX_USE_CONSTEXPR int digits
 729        = __glibcxx_digits (char16_t);
 730       static _GLIBCXX_USE_CONSTEXPR int digits10
 731        = __glibcxx_digits10 (char16_t);
 732 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 733       static constexpr int max_digits10 = 0;
 734 #endif
 735       static _GLIBCXX_USE_CONSTEXPR bool is_signed
 736        = __glibcxx_signed (char16_t);
 737       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
 738       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
 739       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
 740
 741       static _GLIBCXX_CONSTEXPR char16_t
 742       epsilon() throw() { return 0; }
 743
 744       static _GLIBCXX_CONSTEXPR char16_t
 745       round_error() throw() { return 0; }
 746
 747       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
 748       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
 749       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
 750       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
 751
 752       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
 753       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
 754       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
 755       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
 756        = denorm_absent;
 757       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 758
 759       static _GLIBCXX_CONSTEXPR char16_t
 760       infinity() throw()  { return char16_t(); }
 761
 762       static _GLIBCXX_CONSTEXPR char16_t
 763       quiet_NaN() throw() { return char16_t(); }
 764
 765       static _GLIBCXX_CONSTEXPR char16_t
 766       signaling_NaN() throw() { return char16_t(); }
 767
 768       static _GLIBCXX_CONSTEXPR char16_t
 769       denorm_min() throw() { return char16_t(); }
 770
 771       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
 772       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
 773       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
 774
 775       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
 776       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
 777       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
 778        = round_toward_zero;
 779     };
 780
 781   /// numeric_limits<char32_t> specialization.
 782   template<>
 783     struct numeric_limits<char32_t>
 784     {
 785       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 786
 787       static _GLIBCXX_CONSTEXPR char32_t
 788       min() throw() { return __glibcxx_min (char32_t); }
 789
 790       static _GLIBCXX_CONSTEXPR char32_t
 791       max() throw() { return __glibcxx_max (char32_t); }
 792
 793 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 794       static constexpr char32_t
 795       lowest() throw() { return min(); }
 796 #endif
 797
 798       static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char32_t);
 799       static _GLIBCXX_USE_CONSTEXPR int digits10
 800        = __glibcxx_digits10 (char32_t);
 801 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 802       static constexpr int max_digits10 = 0;
 803 #endif
 804       static _GLIBCXX_USE_CONSTEXPR bool is_signed
 805        = __glibcxx_signed (char32_t);
 806       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
 807       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
 808       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
 809
 810       static _GLIBCXX_CONSTEXPR char32_t
 811       epsilon() throw() { return 0; }
 812
 813       static _GLIBCXX_CONSTEXPR char32_t
 814       round_error() throw() { return 0; }
 815
 816       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
 817       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
 818       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
 819       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
 820
 821       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
 822       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
 823       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
 824       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
 825        = denorm_absent;
 826       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 827
 828       static _GLIBCXX_CONSTEXPR char32_t
 829       infinity() throw() { return char32_t(); }
 830
 831       static _GLIBCXX_CONSTEXPR char32_t
 832       quiet_NaN() throw() { return char32_t(); }
 833
 834       static _GLIBCXX_CONSTEXPR char32_t
 835       signaling_NaN() throw() { return char32_t(); }
 836
 837       static _GLIBCXX_CONSTEXPR char32_t
 838       denorm_min() throw() { return char32_t(); }
 839
 840       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
 841       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
 842       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
 843
 844       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
 845       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
 846       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
 847        = round_toward_zero;
 848     };
 849 #endif
 850
 851   /// numeric_limits<short> specialization.
 852   template<>
 853     struct numeric_limits<short>
 854     {
 855       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 856
 857       static _GLIBCXX_CONSTEXPR short
 858       min() throw() { return -__SHRT_MAX__ - 1; }
 859
 860       static _GLIBCXX_CONSTEXPR short
 861       max() throw() { return __SHRT_MAX__; }
 862
 863 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 864       static constexpr short
 865       lowest() throw() { return min(); }
 866 #endif
 867
 868       static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (short);
 869       static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (short);
 870 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 871       static constexpr int max_digits10 = 0;
 872 #endif
 873       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
 874       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
 875       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
 876       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
 877
 878       static _GLIBCXX_CONSTEXPR short
 879       epsilon() throw() { return 0; }
 880
 881       static _GLIBCXX_CONSTEXPR short
 882       round_error() throw() { return 0; }
 883
 884       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
 885       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
 886       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
 887       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
 888
 889       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
 890       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
 891       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
 892       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
 893        = denorm_absent;
 894       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 895
 896       static _GLIBCXX_CONSTEXPR short
 897       infinity() throw() { return short(); }
 898
 899       static _GLIBCXX_CONSTEXPR short
 900       quiet_NaN() throw() { return short(); }
 901
 902       static _GLIBCXX_CONSTEXPR short
 903       signaling_NaN() throw() { return short(); }
 904
 905       static _GLIBCXX_CONSTEXPR short
 906       denorm_min() throw() { return short(); }
 907
 908       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
 909       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
 910       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
 911
 912       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
 913       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
 914       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
 915        = round_toward_zero;
 916     };
 917
 918   /// numeric_limits<unsigned short> specialization.
 919   template<>
 920     struct numeric_limits<unsigned short>
 921     {
 922       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 923
 924       static _GLIBCXX_CONSTEXPR unsigned short
 925       min() throw() { return 0; }
 926
 927       static _GLIBCXX_CONSTEXPR unsigned short
 928       max() throw() { return __SHRT_MAX__ * 2U + 1; }
 929
 930 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 931       static constexpr unsigned short
 932       lowest() throw() { return min(); }
 933 #endif
 934
 935       static _GLIBCXX_USE_CONSTEXPR int digits
 936        = __glibcxx_digits (unsigned short);
 937       static _GLIBCXX_USE_CONSTEXPR int digits10
 938        = __glibcxx_digits10 (unsigned short);
 939 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 940       static constexpr int max_digits10 = 0;
 941 #endif
 942       static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
 943       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
 944       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
 945       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
 946
 947       static _GLIBCXX_CONSTEXPR unsigned short
 948       epsilon() throw() { return 0; }
 949
 950       static _GLIBCXX_CONSTEXPR unsigned short
 951       round_error() throw() { return 0; }
 952
 953       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
 954       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
 955       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
 956       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
 957
 958       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
 959       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
 960       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
 961       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
 962        = denorm_absent;
 963       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 964
 965       static _GLIBCXX_CONSTEXPR unsigned short
 966       infinity() throw() { return static_cast<unsigned short>(0); }
 967
 968       static _GLIBCXX_CONSTEXPR unsigned short
 969       quiet_NaN() throw() { return static_cast<unsigned short>(0); }
 970
 971       static _GLIBCXX_CONSTEXPR unsigned short
 972       signaling_NaN() throw() { return static_cast<unsigned short>(0); }
 973
 974       static _GLIBCXX_CONSTEXPR unsigned short
 975       denorm_min() throw() { return static_cast<unsigned short>(0); }
 976
 977       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
 978       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
 979       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
 980
 981       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
 982       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
 983       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
 984        = round_toward_zero;
 985     };
 986
 987   /// numeric_limits<int> specialization.
 988   template<>
 989     struct numeric_limits<int>
 990     {
 991       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 992
 993       static _GLIBCXX_CONSTEXPR int
 994       min() throw() { return -__INT_MAX__ - 1; }
 995
 996       static _GLIBCXX_CONSTEXPR int
 997       max() throw() { return __INT_MAX__; }
 998
 999 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1000       static constexpr int
1001       lowest() throw() { return min(); }
1002 #endif
1003
1004       static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (int);
1005       static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (int);
1006 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1007       static constexpr int max_digits10 = 0;
1008 #endif
1009       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1010       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1011       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1012       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1013
1014       static _GLIBCXX_CONSTEXPR int
1015       epsilon() throw() { return 0; }
1016
1017       static _GLIBCXX_CONSTEXPR int
1018       round_error() throw() { return 0; }
1019
1020       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1021       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1022       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1023       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1024
1025       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1026       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1027       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1028       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1029        = denorm_absent;
1030       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1031
1032       static _GLIBCXX_CONSTEXPR int
1033       infinity() throw() { return static_cast<int>(0); }
1034
1035       static _GLIBCXX_CONSTEXPR int
1036       quiet_NaN() throw() { return static_cast<int>(0); }
1037
1038       static _GLIBCXX_CONSTEXPR int
1039       signaling_NaN() throw() { return static_cast<int>(0); }
1040
1041       static _GLIBCXX_CONSTEXPR int
1042       denorm_min() throw() { return static_cast<int>(0); }
1043
1044       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1045       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1046       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1047
1048       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1049       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1050       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1051        = round_toward_zero;
1052     };
1053
1054   /// numeric_limits<unsigned int> specialization.
1055   template<>
1056     struct numeric_limits<unsigned int>
1057     {
1058       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1059
1060       static _GLIBCXX_CONSTEXPR unsigned int
1061       min() throw() { return 0; }
1062
1063       static _GLIBCXX_CONSTEXPR unsigned int
1064       max() throw() { return __INT_MAX__ * 2U + 1; }
1065
1066 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1067       static constexpr unsigned int
1068       lowest() throw() { return min(); }
1069 #endif
1070
1071       static _GLIBCXX_USE_CONSTEXPR int digits
1072        = __glibcxx_digits (unsigned int);
1073       static _GLIBCXX_USE_CONSTEXPR int digits10
1074        = __glibcxx_digits10 (unsigned int);
1075 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1076       static constexpr int max_digits10 = 0;
1077 #endif
1078       static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1079       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1080       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1081       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1082
1083       static _GLIBCXX_CONSTEXPR unsigned int
1084       epsilon() throw() { return 0; }
1085
1086       static _GLIBCXX_CONSTEXPR unsigned int
1087       round_error() throw() { return 0; }
1088
1089       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1090       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1091       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1092       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1093
1094       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1095       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1096       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1097       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1098        = denorm_absent;
1099       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1100
1101       static _GLIBCXX_CONSTEXPR unsigned int
1102       infinity() throw() { return static_cast<unsigned int>(0); }
1103
1104       static _GLIBCXX_CONSTEXPR unsigned int
1105       quiet_NaN() throw() { return static_cast<unsigned int>(0); }
1106
1107       static _GLIBCXX_CONSTEXPR unsigned int
1108       signaling_NaN() throw() { return static_cast<unsigned int>(0); }
1109
1110       static _GLIBCXX_CONSTEXPR unsigned int
1111       denorm_min() throw() { return static_cast<unsigned int>(0); }
1112
1113       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1114       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1115       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1116
1117       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1118       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1119       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1120        = round_toward_zero;
1121     };
1122
1123   /// numeric_limits<long> specialization.
1124   template<>
1125     struct numeric_limits<long>
1126     {
1127       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1128
1129       static _GLIBCXX_CONSTEXPR long
1130       min() throw() { return -__LONG_MAX__ - 1; }
1131
1132       static _GLIBCXX_CONSTEXPR long
1133       max() throw() { return __LONG_MAX__; }
1134
1135 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1136       static constexpr long
1137       lowest() throw() { return min(); }
1138 #endif
1139
1140       static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (long);
1141       static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (long);
1142 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1143       static constexpr int max_digits10 = 0;
1144 #endif
1145       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1146       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1147       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1148       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1149
1150       static _GLIBCXX_CONSTEXPR long
1151       epsilon() throw() { return 0; }
1152
1153       static _GLIBCXX_CONSTEXPR long
1154       round_error() throw() { return 0; }
1155
1156       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1157       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1158       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1159       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1160
1161       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1162       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1163       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1164       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1165        = denorm_absent;
1166       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1167
1168       static _GLIBCXX_CONSTEXPR long
1169       infinity() throw() { return static_cast<long>(0); }
1170
1171       static _GLIBCXX_CONSTEXPR long
1172       quiet_NaN() throw() { return static_cast<long>(0); }
1173
1174       static _GLIBCXX_CONSTEXPR long
1175       signaling_NaN() throw() { return static_cast<long>(0); }
1176
1177       static _GLIBCXX_CONSTEXPR long
1178       denorm_min() throw() { return static_cast<long>(0); }
1179
1180       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1181       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1182       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1183
1184       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1185       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1186       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1187        = round_toward_zero;
1188     };
1189
1190   /// numeric_limits<unsigned long> specialization.
1191   template<>
1192     struct numeric_limits<unsigned long>
1193     {
1194       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1195
1196       static _GLIBCXX_CONSTEXPR unsigned long
1197       min() throw() { return 0; }
1198
1199       static _GLIBCXX_CONSTEXPR unsigned long
1200       max() throw() { return __LONG_MAX__ * 2UL + 1; }
1201
1202 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1203       static constexpr unsigned long
1204       lowest() throw() { return min(); }
1205 #endif
1206
1207       static _GLIBCXX_USE_CONSTEXPR int digits
1208        = __glibcxx_digits (unsigned long);
1209       static _GLIBCXX_USE_CONSTEXPR int digits10
1210        = __glibcxx_digits10 (unsigned long);
1211 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1212       static constexpr int max_digits10 = 0;
1213 #endif
1214       static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1215       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1216       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1217       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1218
1219       static _GLIBCXX_CONSTEXPR unsigned long
1220       epsilon() throw() { return 0; }
1221
1222       static _GLIBCXX_CONSTEXPR unsigned long
1223       round_error() throw() { return 0; }
1224
1225       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1226       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1227       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1228       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1229
1230       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1231       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1232       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1233       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1234        = denorm_absent;
1235       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1236
1237       static _GLIBCXX_CONSTEXPR unsigned long
1238       infinity() throw() { return static_cast<unsigned long>(0); }
1239
1240       static _GLIBCXX_CONSTEXPR unsigned long
1241       quiet_NaN() throw() { return static_cast<unsigned long>(0); }
1242
1243       static _GLIBCXX_CONSTEXPR unsigned long
1244       signaling_NaN() throw() { return static_cast<unsigned long>(0); }
1245
1246       static _GLIBCXX_CONSTEXPR unsigned long
1247       denorm_min() throw() { return static_cast<unsigned long>(0); }
1248
1249       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1250       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1251       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1252
1253       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1254       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1255       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1256        = round_toward_zero;
1257     };
1258
1259   /// numeric_limits<long long> specialization.
1260   template<>
1261     struct numeric_limits<long long>
1262     {
1263       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1264
1265       static _GLIBCXX_CONSTEXPR long long
1266       min() throw() { return -__LONG_LONG_MAX__ - 1; }
1267
1268       static _GLIBCXX_CONSTEXPR long long
1269       max() throw() { return __LONG_LONG_MAX__; }
1270
1271 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1272       static constexpr long long
1273       lowest() throw() { return min(); }
1274 #endif
1275
1276       static _GLIBCXX_USE_CONSTEXPR int digits
1277        = __glibcxx_digits (long long);
1278       static _GLIBCXX_USE_CONSTEXPR int digits10
1279        = __glibcxx_digits10 (long long);
1280 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1281       static constexpr int max_digits10 = 0;
1282 #endif
1283       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1284       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1285       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1286       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1287
1288       static _GLIBCXX_CONSTEXPR long long
1289       epsilon() throw() { return 0; }
1290
1291       static _GLIBCXX_CONSTEXPR long long
1292       round_error() throw() { return 0; }
1293
1294       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1295       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1296       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1297       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1298
1299       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1300       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1301       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1302       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1303        = denorm_absent;
1304       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1305
1306       static _GLIBCXX_CONSTEXPR long long
1307       infinity() throw() { return static_cast<long long>(0); }
1308
1309       static _GLIBCXX_CONSTEXPR long long
1310       quiet_NaN() throw() { return static_cast<long long>(0); }
1311
1312       static _GLIBCXX_CONSTEXPR long long
1313       signaling_NaN() throw() { return static_cast<long long>(0); }
1314
1315       static _GLIBCXX_CONSTEXPR long long
1316       denorm_min() throw() { return static_cast<long long>(0); }
1317
1318       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1319       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1320       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1321
1322       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1323       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1324       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1325        = round_toward_zero;
1326     };
1327
1328   /// numeric_limits<unsigned long long> specialization.
1329   template<>
1330     struct numeric_limits<unsigned long long>
1331     {
1332       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1333
1334       static _GLIBCXX_CONSTEXPR unsigned long long
1335       min() throw() { return 0; }
1336
1337       static _GLIBCXX_CONSTEXPR unsigned long long
1338       max() throw() { return __LONG_LONG_MAX__ * 2ULL + 1; }
1339
1340 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1341       static constexpr unsigned long long
1342       lowest() throw() { return min(); }
1343 #endif
1344
1345       static _GLIBCXX_USE_CONSTEXPR int digits
1346        = __glibcxx_digits (unsigned long long);
1347       static _GLIBCXX_USE_CONSTEXPR int digits10
1348        = __glibcxx_digits10 (unsigned long long);
1349 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1350       static constexpr int max_digits10 = 0;
1351 #endif
1352       static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1353       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1354       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1355       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1356
1357       static _GLIBCXX_CONSTEXPR unsigned long long
1358       epsilon() throw() { return 0; }
1359
1360       static _GLIBCXX_CONSTEXPR unsigned long long
1361       round_error() throw() { return 0; }
1362
1363       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1364       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1365       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1366       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1367
1368       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1369       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1370       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1371       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1372        = denorm_absent;
1373       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1374
1375       static _GLIBCXX_CONSTEXPR unsigned long long
1376       infinity() throw() { return static_cast<unsigned long long>(0); }
1377
1378       static _GLIBCXX_CONSTEXPR unsigned long long
1379       quiet_NaN() throw() { return static_cast<unsigned long long>(0); }
1380
1381       static _GLIBCXX_CONSTEXPR unsigned long long
1382       signaling_NaN() throw() { return static_cast<unsigned long long>(0); }
1383
1384       static _GLIBCXX_CONSTEXPR unsigned long long
1385       denorm_min() throw() { return static_cast<unsigned long long>(0); }
1386
1387       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1388       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1389       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1390
1391       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1392       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1393       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1394        = round_toward_zero;
1395     };
1396
1397   /// numeric_limits<float> specialization.
1398   template<>
1399     struct numeric_limits<float>
1400     {
1401       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1402
1403       static _GLIBCXX_CONSTEXPR float
1404       min() throw() { return __FLT_MIN__; }
1405
1406       static _GLIBCXX_CONSTEXPR float
1407       max() throw() { return __FLT_MAX__; }
1408
1409 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1410       static constexpr float
1411       lowest() throw() { return -__FLT_MAX__; }
1412 #endif
1413
1414       static _GLIBCXX_USE_CONSTEXPR int digits = __FLT_MANT_DIG__;
1415       static _GLIBCXX_USE_CONSTEXPR int digits10 = __FLT_DIG__;
1416 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1417       static constexpr int max_digits10
1418          = __glibcxx_max_digits10 (__FLT_MANT_DIG__);
1419 #endif
1420       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1421       static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1422       static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1423       static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1424
1425       static _GLIBCXX_CONSTEXPR float
1426       epsilon() throw() { return __FLT_EPSILON__; }
1427
1428       static _GLIBCXX_CONSTEXPR float
1429       round_error() throw() { return 0.5F; }
1430
1431       static _GLIBCXX_USE_CONSTEXPR int min_exponent = __FLT_MIN_EXP__;
1432       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __FLT_MIN_10_EXP__;
1433       static _GLIBCXX_USE_CONSTEXPR int max_exponent = __FLT_MAX_EXP__;
1434       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __FLT_MAX_10_EXP__;
1435
1436       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __FLT_HAS_INFINITY__;
1437       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__;
1438       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1439       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1440         = bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent;
1441       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1442        = __glibcxx_float_has_denorm_loss;
1443
1444       static _GLIBCXX_CONSTEXPR float
1445       infinity() throw() { return __builtin_huge_valf (); }
1446
1447       static _GLIBCXX_CONSTEXPR float
1448       quiet_NaN() throw() { return __builtin_nanf (""); }
1449
1450       static _GLIBCXX_CONSTEXPR float
1451       signaling_NaN() throw() { return __builtin_nansf (""); }
1452
1453       static _GLIBCXX_CONSTEXPR float
1454       denorm_min() throw() { return __FLT_DENORM_MIN__; }
1455
1456       static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1457         = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1458       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1459       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1460
1461       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_float_traps;
1462       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before
1463        = __glibcxx_float_tinyness_before;
1464       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1465        = round_to_nearest;
1466     };
1467
1468 #undef __glibcxx_float_has_denorm_loss
1469 #undef __glibcxx_float_traps
1470 #undef __glibcxx_float_tinyness_before
1471
1472   /// numeric_limits<double> specialization.
1473   template<>
1474     struct numeric_limits<double>
1475     {
1476       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1477
1478       static _GLIBCXX_CONSTEXPR double
1479       min() throw()  { return __DBL_MIN__; }
1480
1481       static _GLIBCXX_CONSTEXPR double
1482       max() throw() { return __DBL_MAX__; }
1483
1484 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1485       static constexpr double
1486       lowest() throw() { return -__DBL_MAX__; }
1487 #endif
1488
1489       static _GLIBCXX_USE_CONSTEXPR int digits = __DBL_MANT_DIG__;
1490       static _GLIBCXX_USE_CONSTEXPR int digits10 = __DBL_DIG__;
1491 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1492       static constexpr int max_digits10
1493          = __glibcxx_max_digits10 (__DBL_MANT_DIG__);
1494 #endif
1495       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1496       static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1497       static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1498       static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1499
1500       static _GLIBCXX_CONSTEXPR double
1501       epsilon() throw() { return __DBL_EPSILON__; }
1502
1503       static _GLIBCXX_CONSTEXPR double
1504       round_error() throw() { return 0.5; }
1505
1506       static _GLIBCXX_USE_CONSTEXPR int min_exponent = __DBL_MIN_EXP__;
1507       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __DBL_MIN_10_EXP__;
1508       static _GLIBCXX_USE_CONSTEXPR int max_exponent = __DBL_MAX_EXP__;
1509       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __DBL_MAX_10_EXP__;
1510
1511       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __DBL_HAS_INFINITY__;
1512       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__;
1513       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1514       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1515         = bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent;
1516       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1517         = __glibcxx_double_has_denorm_loss;
1518
1519       static _GLIBCXX_CONSTEXPR double
1520       infinity() throw() { return __builtin_huge_val(); }
1521
1522       static _GLIBCXX_CONSTEXPR double
1523       quiet_NaN() throw() { return __builtin_nan (""); }
1524
1525       static _GLIBCXX_CONSTEXPR double
1526       signaling_NaN() throw() { return __builtin_nans (""); }
1527
1528       static _GLIBCXX_CONSTEXPR double
1529       denorm_min() throw() { return __DBL_DENORM_MIN__; }
1530
1531       static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1532         = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1533       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1534       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1535
1536       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_double_traps;
1537       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before
1538        = __glibcxx_double_tinyness_before;
1539       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1540        = round_to_nearest;
1541     };
1542
1543 #undef __glibcxx_double_has_denorm_loss
1544 #undef __glibcxx_double_traps
1545 #undef __glibcxx_double_tinyness_before
1546
1547   /// numeric_limits<long double> specialization.
1548   template<>
1549     struct numeric_limits<long double>
1550     {
1551       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1552
1553       static _GLIBCXX_CONSTEXPR long double
1554       min() throw() { return __LDBL_MIN__; }
1555
1556       static _GLIBCXX_CONSTEXPR long double
1557       max() throw() { return __LDBL_MAX__; }
1558
1559 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1560       static constexpr long double
1561       lowest() throw() { return -__LDBL_MAX__; }
1562 #endif
1563
1564       static _GLIBCXX_USE_CONSTEXPR int digits = __LDBL_MANT_DIG__;
1565       static _GLIBCXX_USE_CONSTEXPR int digits10 = __LDBL_DIG__;
1566 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1567       static _GLIBCXX_USE_CONSTEXPR int max_digits10
1568          = __glibcxx_max_digits10 (__LDBL_MANT_DIG__);
1569 #endif
1570       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1571       static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1572       static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1573       static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1574
1575       static _GLIBCXX_CONSTEXPR long double
1576       epsilon() throw() { return __LDBL_EPSILON__; }
1577
1578       static _GLIBCXX_CONSTEXPR long double
1579       round_error() throw() { return 0.5L; }
1580
1581       static _GLIBCXX_USE_CONSTEXPR int min_exponent = __LDBL_MIN_EXP__;
1582       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __LDBL_MIN_10_EXP__;
1583       static _GLIBCXX_USE_CONSTEXPR int max_exponent = __LDBL_MAX_EXP__;
1584       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __LDBL_MAX_10_EXP__;
1585
1586       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __LDBL_HAS_INFINITY__;
1587       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__;
1588       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1589       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1590         = bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent;
1591       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1592         = __glibcxx_long_double_has_denorm_loss;
1593
1594       static _GLIBCXX_CONSTEXPR long double
1595       infinity() throw() { return __builtin_huge_vall (); }
1596
1597       static _GLIBCXX_CONSTEXPR long double
1598       quiet_NaN() throw() { return __builtin_nanl (""); }
1599
1600       static _GLIBCXX_CONSTEXPR long double
1601       signaling_NaN() throw() { return __builtin_nansl (""); }
1602
1603       static _GLIBCXX_CONSTEXPR long double
1604       denorm_min() throw() { return __LDBL_DENORM_MIN__; }
1605
1606       static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1607         = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1608       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1609       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1610
1611       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_long_double_traps;
1612       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before =
1613                                          __glibcxx_long_double_tinyness_before;
1614       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style =
1615                                                       round_to_nearest;
1616     };
1617
1618 #undef __glibcxx_long_double_has_denorm_loss
1619 #undef __glibcxx_long_double_traps
1620 #undef __glibcxx_long_double_tinyness_before
1621
1622 _GLIBCXX_END_NAMESPACE_VERSION
1623 } // namespace
1624
1625 #undef __glibcxx_signed
1626 #undef __glibcxx_min
1627 #undef __glibcxx_max
1628 #undef __glibcxx_digits
1629 #undef __glibcxx_digits10
1630 #undef __glibcxx_max_digits10
1631
1632 #endif // _GLIBCXX_NUMERIC_LIMITS