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

   1 // The template and inlines for the numeric_limits classes. -*- C++ -*-
   2
   3 // Copyright (C) 1999-2014 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(T)     ((T)(-1) < 0)
 129
 130 #define __glibcxx_min(T) \
 131   (__glibcxx_signed (T) ? -__glibcxx_max (T) - 1 : (T)0)
 132
 133 #define __glibcxx_max(T) \
 134   (__glibcxx_signed (T) ? \
 135    (((((T)1 << (__glibcxx_digits (T) - 1)) - 1) << 1) + 1) : ~(T)0)
 136
 137 #define __glibcxx_digits(T) \
 138   (sizeof(T) * __CHAR_BIT__ - __glibcxx_signed (T))
 139
 140 // The fraction 643/2136 approximates log10(2) to 7 significant digits.
 141 #define __glibcxx_digits10(T) \
 142   (__glibcxx_digits (T) * 643L / 2136)
 143
 144 #define __glibcxx_max_digits10(T) \
 145   (2 + (T) * 643L / 2136)
 146
 147 namespace std _GLIBCXX_VISIBILITY(default)
 148 {
 149 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 150
 151   /**
 152    *  @brief Describes the rounding style for floating-point types.
 153    *
 154    *  This is used in the std::numeric_limits class.
 155   */
 156   enum float_round_style
 157   {
 158     round_indeterminate       = -1,    /// Intermediate.
 159     round_toward_zero         = 0,     /// To zero.
 160     round_to_nearest          = 1,     /// To the nearest representable value.
 161     round_toward_infinity     = 2,     /// To infinity.
 162     round_toward_neg_infinity = 3      /// To negative infinity.
 163   };
 164
 165   /**
 166    *  @brief Describes the denormalization for floating-point types.
 167    *
 168    *  These values represent the presence or absence of a variable number
 169    *  of exponent bits.  This type is used in the std::numeric_limits class.
 170   */
 171   enum float_denorm_style
 172   {
 173     /// Indeterminate at compile time whether denormalized values are allowed.
 174     denorm_indeterminate = -1,
 175     /// The type does not allow denormalized values.
 176     denorm_absent        = 0,
 177     /// The type allows denormalized values.
 178     denorm_present       = 1
 179   };
 180
 181   /**
 182    *  @brief Part of std::numeric_limits.
 183    *
 184    *  The @c static @c const members are usable as integral constant
 185    *  expressions.
 186    *
 187    *  @note This is a separate class for purposes of efficiency; you
 188    *        should only access these members as part of an instantiation
 189    *        of the std::numeric_limits class.
 190   */
 191   struct __numeric_limits_base
 192   {
 193     /** This will be true for all fundamental types (which have
 194         specializations), and false for everything else.  */
 195     static _GLIBCXX_USE_CONSTEXPR bool is_specialized = false;
 196
 197     /** The number of @c radix digits that be represented without change:  for
 198         integer types, the number of non-sign bits in the mantissa; for
 199         floating types, the number of @c radix digits in the mantissa.  */
 200     static _GLIBCXX_USE_CONSTEXPR int digits = 0;
 201
 202     /** The number of base 10 digits that can be represented without change. */
 203     static _GLIBCXX_USE_CONSTEXPR int digits10 = 0;
 204
 205 #if __cplusplus >= 201103L
 206     /** The number of base 10 digits required to ensure that values which
 207         differ are always differentiated.  */
 208     static constexpr int max_digits10 = 0;
 209 #endif
 210
 211     /** True if the type is signed.  */
 212     static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
 213
 214     /** True if the type is integer.  */
 215     static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
 216
 217     /** True if the type uses an exact representation. All integer types are
 218         exact, but not all exact types are integer.  For example, rational and
 219         fixed-exponent representations are exact but not integer. */
 220     static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
 221
 222     /** For integer types, specifies the base of the representation.  For
 223         floating types, specifies the base of the exponent representation.  */
 224     static _GLIBCXX_USE_CONSTEXPR int radix = 0;
 225
 226     /** The minimum negative integer such that @c radix raised to the power of
 227         (one less than that integer) is a normalized floating point number.  */
 228     static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
 229
 230     /** The minimum negative integer such that 10 raised to that power is in
 231         the range of normalized floating point numbers.  */
 232     static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
 233
 234     /** The maximum positive integer such that @c radix raised to the power of
 235         (one less than that integer) is a representable finite floating point
 236         number.  */
 237     static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
 238
 239     /** The maximum positive integer such that 10 raised to that power is in
 240         the range of representable finite floating point numbers.  */
 241     static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
 242
 243     /** True if the type has a representation for positive infinity.  */
 244     static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
 245
 246     /** True if the type has a representation for a quiet (non-signaling)
 247         Not a Number.  */
 248     static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
 249
 250     /** True if the type has a representation for a signaling
 251         Not a Number.  */
 252     static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
 253
 254     /** See std::float_denorm_style for more information.  */
 255     static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent;
 256
 257     /** True if loss of accuracy is detected as a denormalization loss,
 258         rather than as an inexact result. */
 259     static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 260
 261     /** True if-and-only-if the type adheres to the IEC 559 standard, also
 262         known as IEEE 754.  (Only makes sense for floating point types.)  */
 263     static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
 264
 265     /** True if the set of values representable by the type is
 266         finite.  All built-in types are bounded, this member would be
 267         false for arbitrary precision types. */
 268     static _GLIBCXX_USE_CONSTEXPR bool is_bounded = false;
 269
 270     /** True if the type is @e modulo. A type is modulo if, for any
 271         operation involving +, -, or * on values of that type whose
 272         result would fall outside the range [min(),max()], the value
 273         returned differs from the true value by an integer multiple of
 274         max() - min() + 1. On most machines, this is false for floating
 275         types, true for unsigned integers, and true for signed integers.
 276         See PR22200 about 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() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
 310
 311       /** The maximum finite value.  */
 312       static _GLIBCXX_CONSTEXPR _Tp
 313       max() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
 314
 315 #if __cplusplus >= 201103L
 316       /** A finite value x such that there is no other finite value y
 317        *  where y < x.  */
 318       static constexpr _Tp
 319       lowest() noexcept { return _Tp(); }
 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() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
 326
 327       /** The maximum rounding error measurement (see LIA-1).  */
 328       static _GLIBCXX_CONSTEXPR _Tp
 329       round_error() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
 330
 331       /** The representation of positive infinity, if @c has_infinity.  */
 332       static _GLIBCXX_CONSTEXPR _Tp
 333       infinity() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
 334
 335       /** The representation of a quiet Not a Number,
 336           if @c has_quiet_NaN. */
 337       static _GLIBCXX_CONSTEXPR _Tp
 338       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
 339
 340       /** The representation of a signaling Not a Number, if
 341           @c has_signaling_NaN. */
 342       static _GLIBCXX_CONSTEXPR _Tp
 343       signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
 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() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
 350     };
 351
 352 #if __cplusplus >= 201103L
 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() _GLIBCXX_USE_NOEXCEPT { return false; }
 377
 378       static _GLIBCXX_CONSTEXPR bool
 379       max() _GLIBCXX_USE_NOEXCEPT { return true; }
 380
 381 #if __cplusplus >= 201103L
 382       static constexpr bool
 383       lowest() noexcept { return min(); }
 384 #endif
 385       static _GLIBCXX_USE_CONSTEXPR int digits = 1;
 386       static _GLIBCXX_USE_CONSTEXPR int digits10 = 0;
 387 #if __cplusplus >= 201103L
 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() _GLIBCXX_USE_NOEXCEPT { return false; }
 397
 398       static _GLIBCXX_CONSTEXPR bool
 399       round_error() _GLIBCXX_USE_NOEXCEPT { 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() _GLIBCXX_USE_NOEXCEPT { return false; }
 415
 416       static _GLIBCXX_CONSTEXPR bool
 417       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return false; }
 418
 419       static _GLIBCXX_CONSTEXPR bool
 420       signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return false; }
 421
 422       static _GLIBCXX_CONSTEXPR bool
 423       denorm_min() _GLIBCXX_USE_NOEXCEPT { 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() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min(char); }
 446
 447       static _GLIBCXX_CONSTEXPR char
 448       max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max(char); }
 449
 450 #if __cplusplus >= 201103L
 451       static constexpr char
 452       lowest() noexcept { 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 #if __cplusplus >= 201103L
 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() _GLIBCXX_USE_NOEXCEPT { return 0; }
 467
 468       static _GLIBCXX_CONSTEXPR char
 469       round_error() _GLIBCXX_USE_NOEXCEPT { 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() _GLIBCXX_USE_NOEXCEPT { return char(); }
 485
 486       static _GLIBCXX_CONSTEXPR char
 487       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); }
 488
 489       static _GLIBCXX_CONSTEXPR char
 490       signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); }
 491
 492       static _GLIBCXX_CONSTEXPR char
 493       denorm_min() _GLIBCXX_USE_NOEXCEPT { 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 = !is_signed;
 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() _GLIBCXX_USE_NOEXCEPT { return -__SCHAR_MAX__ - 1; }
 513
 514       static _GLIBCXX_CONSTEXPR signed char
 515       max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__; }
 516
 517 #if __cplusplus >= 201103L
 518       static constexpr signed char
 519       lowest() noexcept { 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 #if __cplusplus >= 201103L
 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() _GLIBCXX_USE_NOEXCEPT { return 0; }
 535
 536       static _GLIBCXX_CONSTEXPR signed char
 537       round_error() _GLIBCXX_USE_NOEXCEPT { 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() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); }
 553
 554       static _GLIBCXX_CONSTEXPR signed char
 555       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); }
 556
 557       static _GLIBCXX_CONSTEXPR signed char
 558       signaling_NaN() _GLIBCXX_USE_NOEXCEPT
 559       { return static_cast<signed char>(0); }
 560
 561       static _GLIBCXX_CONSTEXPR signed char
 562       denorm_min() _GLIBCXX_USE_NOEXCEPT
 563       { return static_cast<signed char>(0); }
 564
 565       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
 566       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
 567       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
 568
 569       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
 570       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
 571       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
 572        = round_toward_zero;
 573     };
 574
 575   /// numeric_limits<unsigned char> specialization.
 576   template<>
 577     struct numeric_limits<unsigned char>
 578     {
 579       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 580
 581       static _GLIBCXX_CONSTEXPR unsigned char
 582       min() _GLIBCXX_USE_NOEXCEPT { return 0; }
 583
 584       static _GLIBCXX_CONSTEXPR unsigned char
 585       max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__ * 2U + 1; }
 586
 587 #if __cplusplus >= 201103L
 588       static constexpr unsigned char
 589       lowest() noexcept { return min(); }
 590 #endif
 591
 592       static _GLIBCXX_USE_CONSTEXPR int digits
 593        = __glibcxx_digits (unsigned char);
 594       static _GLIBCXX_USE_CONSTEXPR int digits10
 595        = __glibcxx_digits10 (unsigned char);
 596 #if __cplusplus >= 201103L
 597       static constexpr int max_digits10 = 0;
 598 #endif
 599       static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
 600       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
 601       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
 602       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
 603
 604       static _GLIBCXX_CONSTEXPR unsigned char
 605       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
 606
 607       static _GLIBCXX_CONSTEXPR unsigned char
 608       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
 609
 610       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
 611       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
 612       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
 613       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
 614
 615       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
 616       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
 617       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
 618       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
 619        = denorm_absent;
 620       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 621
 622       static _GLIBCXX_CONSTEXPR unsigned char
 623       infinity() _GLIBCXX_USE_NOEXCEPT
 624       { return static_cast<unsigned char>(0); }
 625
 626       static _GLIBCXX_CONSTEXPR unsigned char
 627       quiet_NaN() _GLIBCXX_USE_NOEXCEPT
 628       { return static_cast<unsigned char>(0); }
 629
 630       static _GLIBCXX_CONSTEXPR unsigned char
 631       signaling_NaN() _GLIBCXX_USE_NOEXCEPT
 632       { return static_cast<unsigned char>(0); }
 633
 634       static _GLIBCXX_CONSTEXPR unsigned char
 635       denorm_min() _GLIBCXX_USE_NOEXCEPT
 636       { return static_cast<unsigned char>(0); }
 637
 638       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
 639       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
 640       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
 641
 642       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
 643       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
 644       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
 645        = round_toward_zero;
 646     };
 647
 648   /// numeric_limits<wchar_t> specialization.
 649   template<>
 650     struct numeric_limits<wchar_t>
 651     {
 652       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 653
 654       static _GLIBCXX_CONSTEXPR wchar_t
 655       min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (wchar_t); }
 656
 657       static _GLIBCXX_CONSTEXPR wchar_t
 658       max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (wchar_t); }
 659
 660 #if __cplusplus >= 201103L
 661       static constexpr wchar_t
 662       lowest() noexcept { return min(); }
 663 #endif
 664
 665       static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (wchar_t);
 666       static _GLIBCXX_USE_CONSTEXPR int digits10
 667        = __glibcxx_digits10 (wchar_t);
 668 #if __cplusplus >= 201103L
 669       static constexpr int max_digits10 = 0;
 670 #endif
 671       static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (wchar_t);
 672       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
 673       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
 674       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
 675
 676       static _GLIBCXX_CONSTEXPR wchar_t
 677       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
 678
 679       static _GLIBCXX_CONSTEXPR wchar_t
 680       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
 681
 682       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
 683       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
 684       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
 685       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
 686
 687       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
 688       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
 689       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
 690       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
 691        = denorm_absent;
 692       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 693
 694       static _GLIBCXX_CONSTEXPR wchar_t
 695       infinity() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
 696
 697       static _GLIBCXX_CONSTEXPR wchar_t
 698       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
 699
 700       static _GLIBCXX_CONSTEXPR wchar_t
 701       signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
 702
 703       static _GLIBCXX_CONSTEXPR wchar_t
 704       denorm_min() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
 705
 706       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
 707       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
 708       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed;
 709
 710       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
 711       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
 712       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
 713        = round_toward_zero;
 714     };
 715
 716 #if __cplusplus >= 201103L
 717   /// numeric_limits<char16_t> specialization.
 718   template<>
 719     struct numeric_limits<char16_t>
 720     {
 721       static constexpr bool is_specialized = true;
 722
 723       static constexpr char16_t
 724       min() noexcept { return __glibcxx_min (char16_t); }
 725
 726       static constexpr char16_t
 727       max() noexcept { return __glibcxx_max (char16_t); }
 728
 729       static constexpr char16_t
 730       lowest() noexcept { return min(); }
 731
 732       static constexpr int digits = __glibcxx_digits (char16_t);
 733       static constexpr int digits10 = __glibcxx_digits10 (char16_t);
 734       static constexpr int max_digits10 = 0;
 735       static constexpr bool is_signed = __glibcxx_signed (char16_t);
 736       static constexpr bool is_integer = true;
 737       static constexpr bool is_exact = true;
 738       static constexpr int radix = 2;
 739
 740       static constexpr char16_t
 741       epsilon() noexcept { return 0; }
 742
 743       static constexpr char16_t
 744       round_error() noexcept { return 0; }
 745
 746       static constexpr int min_exponent = 0;
 747       static constexpr int min_exponent10 = 0;
 748       static constexpr int max_exponent = 0;
 749       static constexpr int max_exponent10 = 0;
 750
 751       static constexpr bool has_infinity = false;
 752       static constexpr bool has_quiet_NaN = false;
 753       static constexpr bool has_signaling_NaN = false;
 754       static constexpr float_denorm_style has_denorm = denorm_absent;
 755       static constexpr bool has_denorm_loss = false;
 756
 757       static constexpr char16_t
 758       infinity() noexcept { return char16_t(); }
 759
 760       static constexpr char16_t
 761       quiet_NaN() noexcept { return char16_t(); }
 762
 763       static constexpr char16_t
 764       signaling_NaN() noexcept { return char16_t(); }
 765
 766       static constexpr char16_t
 767       denorm_min() noexcept { return char16_t(); }
 768
 769       static constexpr bool is_iec559 = false;
 770       static constexpr bool is_bounded = true;
 771       static constexpr bool is_modulo = !is_signed;
 772
 773       static constexpr bool traps = __glibcxx_integral_traps;
 774       static constexpr bool tinyness_before = false;
 775       static constexpr float_round_style round_style = round_toward_zero;
 776     };
 777
 778   /// numeric_limits<char32_t> specialization.
 779   template<>
 780     struct numeric_limits<char32_t>
 781     {
 782       static constexpr bool is_specialized = true;
 783
 784       static constexpr char32_t
 785       min() noexcept { return __glibcxx_min (char32_t); }
 786
 787       static constexpr char32_t
 788       max() noexcept { return __glibcxx_max (char32_t); }
 789
 790       static constexpr char32_t
 791       lowest() noexcept { return min(); }
 792
 793       static constexpr int digits = __glibcxx_digits (char32_t);
 794       static constexpr int digits10 = __glibcxx_digits10 (char32_t);
 795       static constexpr int max_digits10 = 0;
 796       static constexpr bool is_signed = __glibcxx_signed (char32_t);
 797       static constexpr bool is_integer = true;
 798       static constexpr bool is_exact = true;
 799       static constexpr int radix = 2;
 800
 801       static constexpr char32_t
 802       epsilon() noexcept { return 0; }
 803
 804       static constexpr char32_t
 805       round_error() noexcept { return 0; }
 806
 807       static constexpr int min_exponent = 0;
 808       static constexpr int min_exponent10 = 0;
 809       static constexpr int max_exponent = 0;
 810       static constexpr int max_exponent10 = 0;
 811
 812       static constexpr bool has_infinity = false;
 813       static constexpr bool has_quiet_NaN = false;
 814       static constexpr bool has_signaling_NaN = false;
 815       static constexpr float_denorm_style has_denorm = denorm_absent;
 816       static constexpr bool has_denorm_loss = false;
 817
 818       static constexpr char32_t
 819       infinity() noexcept { return char32_t(); }
 820
 821       static constexpr char32_t
 822       quiet_NaN() noexcept { return char32_t(); }
 823
 824       static constexpr char32_t
 825       signaling_NaN() noexcept { return char32_t(); }
 826
 827       static constexpr char32_t
 828       denorm_min() noexcept { return char32_t(); }
 829
 830       static constexpr bool is_iec559 = false;
 831       static constexpr bool is_bounded = true;
 832       static constexpr bool is_modulo = !is_signed;
 833
 834       static constexpr bool traps = __glibcxx_integral_traps;
 835       static constexpr bool tinyness_before = false;
 836       static constexpr float_round_style round_style = round_toward_zero;
 837     };
 838 #endif
 839
 840   /// numeric_limits<short> specialization.
 841   template<>
 842     struct numeric_limits<short>
 843     {
 844       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 845
 846       static _GLIBCXX_CONSTEXPR short
 847       min() _GLIBCXX_USE_NOEXCEPT { return -__SHRT_MAX__ - 1; }
 848
 849       static _GLIBCXX_CONSTEXPR short
 850       max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__; }
 851
 852 #if __cplusplus >= 201103L
 853       static constexpr short
 854       lowest() noexcept { return min(); }
 855 #endif
 856
 857       static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (short);
 858       static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (short);
 859 #if __cplusplus >= 201103L
 860       static constexpr int max_digits10 = 0;
 861 #endif
 862       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
 863       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
 864       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
 865       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
 866
 867       static _GLIBCXX_CONSTEXPR short
 868       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
 869
 870       static _GLIBCXX_CONSTEXPR short
 871       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
 872
 873       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
 874       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
 875       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
 876       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
 877
 878       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
 879       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
 880       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
 881       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
 882        = denorm_absent;
 883       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 884
 885       static _GLIBCXX_CONSTEXPR short
 886       infinity() _GLIBCXX_USE_NOEXCEPT { return short(); }
 887
 888       static _GLIBCXX_CONSTEXPR short
 889       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); }
 890
 891       static _GLIBCXX_CONSTEXPR short
 892       signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); }
 893
 894       static _GLIBCXX_CONSTEXPR short
 895       denorm_min() _GLIBCXX_USE_NOEXCEPT { return short(); }
 896
 897       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
 898       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
 899       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
 900
 901       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
 902       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
 903       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
 904        = round_toward_zero;
 905     };
 906
 907   /// numeric_limits<unsigned short> specialization.
 908   template<>
 909     struct numeric_limits<unsigned short>
 910     {
 911       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 912
 913       static _GLIBCXX_CONSTEXPR unsigned short
 914       min() _GLIBCXX_USE_NOEXCEPT { return 0; }
 915
 916       static _GLIBCXX_CONSTEXPR unsigned short
 917       max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__ * 2U + 1; }
 918
 919 #if __cplusplus >= 201103L
 920       static constexpr unsigned short
 921       lowest() noexcept { return min(); }
 922 #endif
 923
 924       static _GLIBCXX_USE_CONSTEXPR int digits
 925        = __glibcxx_digits (unsigned short);
 926       static _GLIBCXX_USE_CONSTEXPR int digits10
 927        = __glibcxx_digits10 (unsigned short);
 928 #if __cplusplus >= 201103L
 929       static constexpr int max_digits10 = 0;
 930 #endif
 931       static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
 932       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
 933       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
 934       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
 935
 936       static _GLIBCXX_CONSTEXPR unsigned short
 937       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
 938
 939       static _GLIBCXX_CONSTEXPR unsigned short
 940       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
 941
 942       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
 943       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
 944       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
 945       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
 946
 947       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
 948       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
 949       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
 950       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
 951        = denorm_absent;
 952       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 953
 954       static _GLIBCXX_CONSTEXPR unsigned short
 955       infinity() _GLIBCXX_USE_NOEXCEPT
 956       { return static_cast<unsigned short>(0); }
 957
 958       static _GLIBCXX_CONSTEXPR unsigned short
 959       quiet_NaN() _GLIBCXX_USE_NOEXCEPT
 960       { return static_cast<unsigned short>(0); }
 961
 962       static _GLIBCXX_CONSTEXPR unsigned short
 963       signaling_NaN() _GLIBCXX_USE_NOEXCEPT
 964       { return static_cast<unsigned short>(0); }
 965
 966       static _GLIBCXX_CONSTEXPR unsigned short
 967       denorm_min() _GLIBCXX_USE_NOEXCEPT
 968       { return static_cast<unsigned short>(0); }
 969
 970       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
 971       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
 972       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
 973
 974       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
 975       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
 976       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
 977        = round_toward_zero;
 978     };
 979
 980   /// numeric_limits<int> specialization.
 981   template<>
 982     struct numeric_limits<int>
 983     {
 984       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 985
 986       static _GLIBCXX_CONSTEXPR int
 987       min() _GLIBCXX_USE_NOEXCEPT { return -__INT_MAX__ - 1; }
 988
 989       static _GLIBCXX_CONSTEXPR int
 990       max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__; }
 991
 992 #if __cplusplus >= 201103L
 993       static constexpr int
 994       lowest() noexcept { return min(); }
 995 #endif
 996
 997       static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (int);
 998       static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (int);
 999 #if __cplusplus >= 201103L
1000       static constexpr int max_digits10 = 0;
1001 #endif
1002       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1003       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1004       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1005       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1006
1007       static _GLIBCXX_CONSTEXPR int
1008       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1009
1010       static _GLIBCXX_CONSTEXPR int
1011       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1012
1013       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1014       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1015       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1016       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1017
1018       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1019       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1020       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1021       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1022        = denorm_absent;
1023       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1024
1025       static _GLIBCXX_CONSTEXPR int
1026       infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1027
1028       static _GLIBCXX_CONSTEXPR int
1029       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1030
1031       static _GLIBCXX_CONSTEXPR int
1032       signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1033
1034       static _GLIBCXX_CONSTEXPR int
1035       denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1036
1037       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1038       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1039       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1040
1041       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1042       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1043       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1044        = round_toward_zero;
1045     };
1046
1047   /// numeric_limits<unsigned int> specialization.
1048   template<>
1049     struct numeric_limits<unsigned int>
1050     {
1051       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1052
1053       static _GLIBCXX_CONSTEXPR unsigned int
1054       min() _GLIBCXX_USE_NOEXCEPT { return 0; }
1055
1056       static _GLIBCXX_CONSTEXPR unsigned int
1057       max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__ * 2U + 1; }
1058
1059 #if __cplusplus >= 201103L
1060       static constexpr unsigned int
1061       lowest() noexcept { return min(); }
1062 #endif
1063
1064       static _GLIBCXX_USE_CONSTEXPR int digits
1065        = __glibcxx_digits (unsigned int);
1066       static _GLIBCXX_USE_CONSTEXPR int digits10
1067        = __glibcxx_digits10 (unsigned int);
1068 #if __cplusplus >= 201103L
1069       static constexpr int max_digits10 = 0;
1070 #endif
1071       static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1072       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1073       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1074       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1075
1076       static _GLIBCXX_CONSTEXPR unsigned int
1077       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1078
1079       static _GLIBCXX_CONSTEXPR unsigned int
1080       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1081
1082       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1083       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1084       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1085       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1086
1087       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1088       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1089       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1090       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1091        = denorm_absent;
1092       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1093
1094       static _GLIBCXX_CONSTEXPR unsigned int
1095       infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<unsigned int>(0); }
1096
1097       static _GLIBCXX_CONSTEXPR unsigned int
1098       quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1099       { return static_cast<unsigned int>(0); }
1100
1101       static _GLIBCXX_CONSTEXPR unsigned int
1102       signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1103       { return static_cast<unsigned int>(0); }
1104
1105       static _GLIBCXX_CONSTEXPR unsigned int
1106       denorm_min() _GLIBCXX_USE_NOEXCEPT
1107       { return static_cast<unsigned int>(0); }
1108
1109       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1110       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1111       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1112
1113       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1114       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1115       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1116        = round_toward_zero;
1117     };
1118
1119   /// numeric_limits<long> specialization.
1120   template<>
1121     struct numeric_limits<long>
1122     {
1123       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1124
1125       static _GLIBCXX_CONSTEXPR long
1126       min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_MAX__ - 1; }
1127
1128       static _GLIBCXX_CONSTEXPR long
1129       max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__; }
1130
1131 #if __cplusplus >= 201103L
1132       static constexpr long
1133       lowest() noexcept { return min(); }
1134 #endif
1135
1136       static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (long);
1137       static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (long);
1138 #if __cplusplus >= 201103L
1139       static constexpr int max_digits10 = 0;
1140 #endif
1141       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1142       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1143       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1144       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1145
1146       static _GLIBCXX_CONSTEXPR long
1147       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1148
1149       static _GLIBCXX_CONSTEXPR long
1150       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1151
1152       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1153       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1154       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1155       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1156
1157       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1158       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1159       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1160       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1161        = denorm_absent;
1162       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1163
1164       static _GLIBCXX_CONSTEXPR long
1165       infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1166
1167       static _GLIBCXX_CONSTEXPR long
1168       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1169
1170       static _GLIBCXX_CONSTEXPR long
1171       signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1172
1173       static _GLIBCXX_CONSTEXPR long
1174       denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1175
1176       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1177       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1178       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1179
1180       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1181       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1182       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1183        = round_toward_zero;
1184     };
1185
1186   /// numeric_limits<unsigned long> specialization.
1187   template<>
1188     struct numeric_limits<unsigned long>
1189     {
1190       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1191
1192       static _GLIBCXX_CONSTEXPR unsigned long
1193       min() _GLIBCXX_USE_NOEXCEPT { return 0; }
1194
1195       static _GLIBCXX_CONSTEXPR unsigned long
1196       max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__ * 2UL + 1; }
1197
1198 #if __cplusplus >= 201103L
1199       static constexpr unsigned long
1200       lowest() noexcept { return min(); }
1201 #endif
1202
1203       static _GLIBCXX_USE_CONSTEXPR int digits
1204        = __glibcxx_digits (unsigned long);
1205       static _GLIBCXX_USE_CONSTEXPR int digits10
1206        = __glibcxx_digits10 (unsigned long);
1207 #if __cplusplus >= 201103L
1208       static constexpr int max_digits10 = 0;
1209 #endif
1210       static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1211       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1212       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1213       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1214
1215       static _GLIBCXX_CONSTEXPR unsigned long
1216       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1217
1218       static _GLIBCXX_CONSTEXPR unsigned long
1219       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1220
1221       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1222       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1223       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1224       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1225
1226       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1227       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1228       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1229       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1230        = denorm_absent;
1231       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1232
1233       static _GLIBCXX_CONSTEXPR unsigned long
1234       infinity() _GLIBCXX_USE_NOEXCEPT
1235       { return static_cast<unsigned long>(0); }
1236
1237       static _GLIBCXX_CONSTEXPR unsigned long
1238       quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1239       { return static_cast<unsigned long>(0); }
1240
1241       static _GLIBCXX_CONSTEXPR unsigned long
1242       signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1243       { return static_cast<unsigned long>(0); }
1244
1245       static _GLIBCXX_CONSTEXPR unsigned long
1246       denorm_min() _GLIBCXX_USE_NOEXCEPT
1247       { 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() _GLIBCXX_USE_NOEXCEPT { return -__LONG_LONG_MAX__ - 1; }
1267
1268       static _GLIBCXX_CONSTEXPR long long
1269       max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__; }
1270
1271 #if __cplusplus >= 201103L
1272       static constexpr long long
1273       lowest() noexcept { 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 #if __cplusplus >= 201103L
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() _GLIBCXX_USE_NOEXCEPT { return 0; }
1290
1291       static _GLIBCXX_CONSTEXPR long long
1292       round_error() _GLIBCXX_USE_NOEXCEPT { 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() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
1308
1309       static _GLIBCXX_CONSTEXPR long long
1310       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
1311
1312       static _GLIBCXX_CONSTEXPR long long
1313       signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1314       { return static_cast<long long>(0); }
1315
1316       static _GLIBCXX_CONSTEXPR long long
1317       denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
1318
1319       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1320       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1321       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1322
1323       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1324       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1325       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1326        = round_toward_zero;
1327     };
1328
1329   /// numeric_limits<unsigned long long> specialization.
1330   template<>
1331     struct numeric_limits<unsigned long long>
1332     {
1333       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1334
1335       static _GLIBCXX_CONSTEXPR unsigned long long
1336       min() _GLIBCXX_USE_NOEXCEPT { return 0; }
1337
1338       static _GLIBCXX_CONSTEXPR unsigned long long
1339       max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__ * 2ULL + 1; }
1340
1341 #if __cplusplus >= 201103L
1342       static constexpr unsigned long long
1343       lowest() noexcept { return min(); }
1344 #endif
1345
1346       static _GLIBCXX_USE_CONSTEXPR int digits
1347        = __glibcxx_digits (unsigned long long);
1348       static _GLIBCXX_USE_CONSTEXPR int digits10
1349        = __glibcxx_digits10 (unsigned long long);
1350 #if __cplusplus >= 201103L
1351       static constexpr int max_digits10 = 0;
1352 #endif
1353       static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1354       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1355       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1356       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1357
1358       static _GLIBCXX_CONSTEXPR unsigned long long
1359       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1360
1361       static _GLIBCXX_CONSTEXPR unsigned long long
1362       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1363
1364       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1365       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1366       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1367       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1368
1369       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1370       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1371       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1372       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1373        = denorm_absent;
1374       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1375
1376       static _GLIBCXX_CONSTEXPR unsigned long long
1377       infinity() _GLIBCXX_USE_NOEXCEPT
1378       { return static_cast<unsigned long long>(0); }
1379
1380       static _GLIBCXX_CONSTEXPR unsigned long long
1381       quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1382       { return static_cast<unsigned long long>(0); }
1383
1384       static _GLIBCXX_CONSTEXPR unsigned long long
1385       signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1386       { return static_cast<unsigned long long>(0); }
1387
1388       static _GLIBCXX_CONSTEXPR unsigned long long
1389       denorm_min() _GLIBCXX_USE_NOEXCEPT
1390       { return static_cast<unsigned long long>(0); }
1391
1392       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1393       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1394       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1395
1396       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1397       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1398       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1399        = round_toward_zero;
1400     };
1401
1402 #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
1403   /// numeric_limits<__int128> specialization.
1404   template<>
1405     struct numeric_limits<__int128>
1406     {
1407       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1408
1409       static _GLIBCXX_CONSTEXPR __int128
1410       min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (__int128); }
1411
1412       static _GLIBCXX_CONSTEXPR __int128
1413       max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (__int128); }
1414
1415 #if __cplusplus >= 201103L
1416       static constexpr __int128
1417       lowest() noexcept { return min(); }
1418 #endif
1419
1420       static _GLIBCXX_USE_CONSTEXPR int digits
1421        = __glibcxx_digits (__int128);
1422       static _GLIBCXX_USE_CONSTEXPR int digits10
1423        = __glibcxx_digits10 (__int128);
1424 #if __cplusplus >= 201103L
1425       static constexpr int max_digits10 = 0;
1426 #endif
1427       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1428       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1429       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1430       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1431
1432       static _GLIBCXX_CONSTEXPR __int128
1433       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1434
1435       static _GLIBCXX_CONSTEXPR __int128
1436       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1437
1438       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1439       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1440       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1441       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1442
1443       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1444       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1445       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1446       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1447        = denorm_absent;
1448       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1449
1450       static _GLIBCXX_CONSTEXPR __int128
1451       infinity() _GLIBCXX_USE_NOEXCEPT
1452       { return static_cast<__int128>(0); }
1453
1454       static _GLIBCXX_CONSTEXPR __int128
1455       quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1456       { return static_cast<__int128>(0); }
1457
1458       static _GLIBCXX_CONSTEXPR __int128
1459       signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1460       { return static_cast<__int128>(0); }
1461
1462       static _GLIBCXX_CONSTEXPR __int128
1463       denorm_min() _GLIBCXX_USE_NOEXCEPT
1464       { return static_cast<__int128>(0); }
1465
1466       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1467       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1468       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1469
1470       static _GLIBCXX_USE_CONSTEXPR bool traps
1471        = __glibcxx_integral_traps;
1472       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1473       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1474        = round_toward_zero;
1475     };
1476
1477   /// numeric_limits<unsigned __int128> specialization.
1478   template<>
1479     struct numeric_limits<unsigned __int128>
1480     {
1481       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1482
1483       static _GLIBCXX_CONSTEXPR unsigned __int128
1484       min() _GLIBCXX_USE_NOEXCEPT { return 0; }
1485
1486       static _GLIBCXX_CONSTEXPR unsigned __int128
1487       max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (unsigned __int128); }
1488
1489 #if __cplusplus >= 201103L
1490       static constexpr unsigned __int128
1491       lowest() noexcept { return min(); }
1492 #endif
1493
1494       static _GLIBCXX_USE_CONSTEXPR int digits
1495        = __glibcxx_digits (unsigned __int128);
1496       static _GLIBCXX_USE_CONSTEXPR int digits10
1497        = __glibcxx_digits10 (unsigned __int128);
1498 #if __cplusplus >= 201103L
1499       static constexpr int max_digits10 = 0;
1500 #endif
1501       static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1502       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1503       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1504       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1505
1506       static _GLIBCXX_CONSTEXPR unsigned __int128
1507       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1508
1509       static _GLIBCXX_CONSTEXPR unsigned __int128
1510       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1511
1512       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1513       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1514       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1515       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1516
1517       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1518       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1519       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1520       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1521        = denorm_absent;
1522       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1523
1524       static _GLIBCXX_CONSTEXPR unsigned __int128
1525       infinity() _GLIBCXX_USE_NOEXCEPT
1526       { return static_cast<unsigned __int128>(0); }
1527
1528       static _GLIBCXX_CONSTEXPR unsigned __int128
1529       quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1530       { return static_cast<unsigned __int128>(0); }
1531
1532       static _GLIBCXX_CONSTEXPR unsigned __int128
1533       signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1534       { return static_cast<unsigned __int128>(0); }
1535
1536       static _GLIBCXX_CONSTEXPR unsigned __int128
1537       denorm_min() _GLIBCXX_USE_NOEXCEPT
1538       { return static_cast<unsigned __int128>(0); }
1539
1540       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1541       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1542       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1543
1544       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1545       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1546       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1547        = round_toward_zero;
1548     };
1549 #endif
1550
1551   /// numeric_limits<float> specialization.
1552   template<>
1553     struct numeric_limits<float>
1554     {
1555       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1556
1557       static _GLIBCXX_CONSTEXPR float
1558       min() _GLIBCXX_USE_NOEXCEPT { return __FLT_MIN__; }
1559
1560       static _GLIBCXX_CONSTEXPR float
1561       max() _GLIBCXX_USE_NOEXCEPT { return __FLT_MAX__; }
1562
1563 #if __cplusplus >= 201103L
1564       static constexpr float
1565       lowest() noexcept { return -__FLT_MAX__; }
1566 #endif
1567
1568       static _GLIBCXX_USE_CONSTEXPR int digits = __FLT_MANT_DIG__;
1569       static _GLIBCXX_USE_CONSTEXPR int digits10 = __FLT_DIG__;
1570 #if __cplusplus >= 201103L
1571       static constexpr int max_digits10
1572          = __glibcxx_max_digits10 (__FLT_MANT_DIG__);
1573 #endif
1574       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1575       static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1576       static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1577       static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1578
1579       static _GLIBCXX_CONSTEXPR float
1580       epsilon() _GLIBCXX_USE_NOEXCEPT { return __FLT_EPSILON__; }
1581
1582       static _GLIBCXX_CONSTEXPR float
1583       round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5F; }
1584
1585       static _GLIBCXX_USE_CONSTEXPR int min_exponent = __FLT_MIN_EXP__;
1586       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __FLT_MIN_10_EXP__;
1587       static _GLIBCXX_USE_CONSTEXPR int max_exponent = __FLT_MAX_EXP__;
1588       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __FLT_MAX_10_EXP__;
1589
1590       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __FLT_HAS_INFINITY__;
1591       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__;
1592       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1593       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1594         = bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent;
1595       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1596        = __glibcxx_float_has_denorm_loss;
1597
1598       static _GLIBCXX_CONSTEXPR float
1599       infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_valf(); }
1600
1601       static _GLIBCXX_CONSTEXPR float
1602       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanf(""); }
1603
1604       static _GLIBCXX_CONSTEXPR float
1605       signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansf(""); }
1606
1607       static _GLIBCXX_CONSTEXPR float
1608       denorm_min() _GLIBCXX_USE_NOEXCEPT { return __FLT_DENORM_MIN__; }
1609
1610       static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1611         = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1612       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1613       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1614
1615       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_float_traps;
1616       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before
1617        = __glibcxx_float_tinyness_before;
1618       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1619        = round_to_nearest;
1620     };
1621
1622 #undef __glibcxx_float_has_denorm_loss
1623 #undef __glibcxx_float_traps
1624 #undef __glibcxx_float_tinyness_before
1625
1626   /// numeric_limits<double> specialization.
1627   template<>
1628     struct numeric_limits<double>
1629     {
1630       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1631
1632       static _GLIBCXX_CONSTEXPR double
1633       min() _GLIBCXX_USE_NOEXCEPT { return __DBL_MIN__; }
1634
1635       static _GLIBCXX_CONSTEXPR double
1636       max() _GLIBCXX_USE_NOEXCEPT { return __DBL_MAX__; }
1637
1638 #if __cplusplus >= 201103L
1639       static constexpr double
1640       lowest() noexcept { return -__DBL_MAX__; }
1641 #endif
1642
1643       static _GLIBCXX_USE_CONSTEXPR int digits = __DBL_MANT_DIG__;
1644       static _GLIBCXX_USE_CONSTEXPR int digits10 = __DBL_DIG__;
1645 #if __cplusplus >= 201103L
1646       static constexpr int max_digits10
1647          = __glibcxx_max_digits10 (__DBL_MANT_DIG__);
1648 #endif
1649       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1650       static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1651       static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1652       static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1653
1654       static _GLIBCXX_CONSTEXPR double
1655       epsilon() _GLIBCXX_USE_NOEXCEPT { return __DBL_EPSILON__; }
1656
1657       static _GLIBCXX_CONSTEXPR double
1658       round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5; }
1659
1660       static _GLIBCXX_USE_CONSTEXPR int min_exponent = __DBL_MIN_EXP__;
1661       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __DBL_MIN_10_EXP__;
1662       static _GLIBCXX_USE_CONSTEXPR int max_exponent = __DBL_MAX_EXP__;
1663       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __DBL_MAX_10_EXP__;
1664
1665       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __DBL_HAS_INFINITY__;
1666       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__;
1667       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1668       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1669         = bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent;
1670       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1671         = __glibcxx_double_has_denorm_loss;
1672
1673       static _GLIBCXX_CONSTEXPR double
1674       infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_val(); }
1675
1676       static _GLIBCXX_CONSTEXPR double
1677       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nan(""); }
1678
1679       static _GLIBCXX_CONSTEXPR double
1680       signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nans(""); }
1681
1682       static _GLIBCXX_CONSTEXPR double
1683       denorm_min() _GLIBCXX_USE_NOEXCEPT { return __DBL_DENORM_MIN__; }
1684
1685       static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1686         = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1687       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1688       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1689
1690       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_double_traps;
1691       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before
1692        = __glibcxx_double_tinyness_before;
1693       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1694        = round_to_nearest;
1695     };
1696
1697 #undef __glibcxx_double_has_denorm_loss
1698 #undef __glibcxx_double_traps
1699 #undef __glibcxx_double_tinyness_before
1700
1701   /// numeric_limits<long double> specialization.
1702   template<>
1703     struct numeric_limits<long double>
1704     {
1705       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1706
1707       static _GLIBCXX_CONSTEXPR long double
1708       min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MIN__; }
1709
1710       static _GLIBCXX_CONSTEXPR long double
1711       max() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MAX__; }
1712
1713 #if __cplusplus >= 201103L
1714       static constexpr long double
1715       lowest() noexcept { return -__LDBL_MAX__; }
1716 #endif
1717
1718       static _GLIBCXX_USE_CONSTEXPR int digits = __LDBL_MANT_DIG__;
1719       static _GLIBCXX_USE_CONSTEXPR int digits10 = __LDBL_DIG__;
1720 #if __cplusplus >= 201103L
1721       static _GLIBCXX_USE_CONSTEXPR int max_digits10
1722          = __glibcxx_max_digits10 (__LDBL_MANT_DIG__);
1723 #endif
1724       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1725       static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1726       static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1727       static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1728
1729       static _GLIBCXX_CONSTEXPR long double
1730       epsilon() _GLIBCXX_USE_NOEXCEPT { return __LDBL_EPSILON__; }
1731
1732       static _GLIBCXX_CONSTEXPR long double
1733       round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5L; }
1734
1735       static _GLIBCXX_USE_CONSTEXPR int min_exponent = __LDBL_MIN_EXP__;
1736       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __LDBL_MIN_10_EXP__;
1737       static _GLIBCXX_USE_CONSTEXPR int max_exponent = __LDBL_MAX_EXP__;
1738       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __LDBL_MAX_10_EXP__;
1739
1740       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __LDBL_HAS_INFINITY__;
1741       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__;
1742       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1743       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1744         = bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent;
1745       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1746         = __glibcxx_long_double_has_denorm_loss;
1747
1748       static _GLIBCXX_CONSTEXPR long double
1749       infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_vall(); }
1750
1751       static _GLIBCXX_CONSTEXPR long double
1752       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanl(""); }
1753
1754       static _GLIBCXX_CONSTEXPR long double
1755       signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansl(""); }
1756
1757       static _GLIBCXX_CONSTEXPR long double
1758       denorm_min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_DENORM_MIN__; }
1759
1760       static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1761         = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1762       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1763       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1764
1765       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_long_double_traps;
1766       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before =
1767                                          __glibcxx_long_double_tinyness_before;
1768       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style =
1769                                                       round_to_nearest;
1770     };
1771
1772 #undef __glibcxx_long_double_has_denorm_loss
1773 #undef __glibcxx_long_double_traps
1774 #undef __glibcxx_long_double_tinyness_before
1775
1776 _GLIBCXX_END_NAMESPACE_VERSION
1777 } // namespace
1778
1779 #undef __glibcxx_signed
1780 #undef __glibcxx_min
1781 #undef __glibcxx_max
1782 #undef __glibcxx_digits
1783 #undef __glibcxx_digits10
1784 #undef __glibcxx_max_digits10
1785
1786 #endif // _GLIBCXX_NUMERIC_LIMITS