libstdc++-v3/include/std/limits

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