libstdc++-v3/include/std/limits

   1 // The template and inlines for the numeric_limits classes. -*- C++ -*-
   2
   3 // Copyright (C) 1999-2015 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    *  _GLIBCXX_RESOLVE_LIB_DEFECTS:  DRs 201 and 184 (hi Gaby!) are
 312    *  noted, but not incorporated in this documented (yet).
 313   */
 314   template<typename _Tp>
 315     struct numeric_limits : public __numeric_limits_base
 316     {
 317       /** The minimum finite value, or for floating types with
 318           denormalization, the minimum positive normalized value.  */
 319       static _GLIBCXX_CONSTEXPR _Tp
 320       min() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
 321
 322       /** The maximum finite value.  */
 323       static _GLIBCXX_CONSTEXPR _Tp
 324       max() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
 325
 326 #if __cplusplus >= 201103L
 327       /** A finite value x such that there is no other finite value y
 328        *  where y < x.  */
 329       static constexpr _Tp
 330       lowest() noexcept { return _Tp(); }
 331 #endif
 332
 333       /** The @e machine @e epsilon:  the difference between 1 and the least
 334           value greater than 1 that is representable.  */
 335       static _GLIBCXX_CONSTEXPR _Tp
 336       epsilon() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
 337
 338       /** The maximum rounding error measurement (see LIA-1).  */
 339       static _GLIBCXX_CONSTEXPR _Tp
 340       round_error() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
 341
 342       /** The representation of positive infinity, if @c has_infinity.  */
 343       static _GLIBCXX_CONSTEXPR _Tp
 344       infinity() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
 345
 346       /** The representation of a quiet Not a Number,
 347           if @c has_quiet_NaN. */
 348       static _GLIBCXX_CONSTEXPR _Tp
 349       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
 350
 351       /** The representation of a signaling Not a Number, if
 352           @c has_signaling_NaN. */
 353       static _GLIBCXX_CONSTEXPR _Tp
 354       signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
 355
 356       /** The minimum positive denormalized value.  For types where
 357           @c has_denorm is false, this is the minimum positive normalized
 358           value.  */
 359       static _GLIBCXX_CONSTEXPR _Tp
 360       denorm_min() _GLIBCXX_USE_NOEXCEPT { return _Tp(); }
 361     };
 362
 363 #if __cplusplus >= 201103L
 364   template<typename _Tp>
 365     struct numeric_limits<const _Tp>
 366     : public numeric_limits<_Tp> { };
 367
 368   template<typename _Tp>
 369     struct numeric_limits<volatile _Tp>
 370     : public numeric_limits<_Tp> { };
 371
 372   template<typename _Tp>
 373     struct numeric_limits<const volatile _Tp>
 374     : public numeric_limits<_Tp> { };
 375 #endif
 376
 377   // Now there follow 16 explicit specializations.  Yes, 16.  Make sure
 378   // you get the count right. (18 in c++0x mode)
 379
 380   /// numeric_limits<bool> specialization.
 381   template<>
 382     struct numeric_limits<bool>
 383     {
 384       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 385
 386       static _GLIBCXX_CONSTEXPR bool
 387       min() _GLIBCXX_USE_NOEXCEPT { return false; }
 388
 389       static _GLIBCXX_CONSTEXPR bool
 390       max() _GLIBCXX_USE_NOEXCEPT { return true; }
 391
 392 #if __cplusplus >= 201103L
 393       static constexpr bool
 394       lowest() noexcept { return min(); }
 395 #endif
 396       static _GLIBCXX_USE_CONSTEXPR int digits = 1;
 397       static _GLIBCXX_USE_CONSTEXPR int digits10 = 0;
 398 #if __cplusplus >= 201103L
 399       static constexpr int max_digits10 = 0;
 400 #endif
 401       static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
 402       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
 403       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
 404       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
 405
 406       static _GLIBCXX_CONSTEXPR bool
 407       epsilon() _GLIBCXX_USE_NOEXCEPT { return false; }
 408
 409       static _GLIBCXX_CONSTEXPR bool
 410       round_error() _GLIBCXX_USE_NOEXCEPT { return false; }
 411
 412       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
 413       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
 414       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
 415       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
 416
 417       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
 418       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
 419       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
 420       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
 421        = denorm_absent;
 422       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 423
 424       static _GLIBCXX_CONSTEXPR bool
 425       infinity() _GLIBCXX_USE_NOEXCEPT { return false; }
 426
 427       static _GLIBCXX_CONSTEXPR bool
 428       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return false; }
 429
 430       static _GLIBCXX_CONSTEXPR bool
 431       signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return false; }
 432
 433       static _GLIBCXX_CONSTEXPR bool
 434       denorm_min() _GLIBCXX_USE_NOEXCEPT { return false; }
 435
 436       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
 437       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
 438       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
 439
 440       // It is not clear what it means for a boolean type to trap.
 441       // This is a DR on the LWG issue list.  Here, I use integer
 442       // promotion semantics.
 443       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
 444       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
 445       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
 446        = round_toward_zero;
 447     };
 448
 449   /// numeric_limits<char> specialization.
 450   template<>
 451     struct numeric_limits<char>
 452     {
 453       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 454
 455       static _GLIBCXX_CONSTEXPR char
 456       min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min(char); }
 457
 458       static _GLIBCXX_CONSTEXPR char
 459       max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max(char); }
 460
 461 #if __cplusplus >= 201103L
 462       static constexpr char
 463       lowest() noexcept { return min(); }
 464 #endif
 465
 466       static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char);
 467       static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (char);
 468 #if __cplusplus >= 201103L
 469       static constexpr int max_digits10 = 0;
 470 #endif
 471       static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (char);
 472       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
 473       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
 474       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
 475
 476       static _GLIBCXX_CONSTEXPR char
 477       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
 478
 479       static _GLIBCXX_CONSTEXPR char
 480       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
 481
 482       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
 483       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
 484       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
 485       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
 486
 487       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
 488       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
 489       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
 490       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
 491        = denorm_absent;
 492       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 493
 494       static _GLIBCXX_CONSTEXPR
 495       char infinity() _GLIBCXX_USE_NOEXCEPT { return char(); }
 496
 497       static _GLIBCXX_CONSTEXPR char
 498       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); }
 499
 500       static _GLIBCXX_CONSTEXPR char
 501       signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); }
 502
 503       static _GLIBCXX_CONSTEXPR char
 504       denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<char>(0); }
 505
 506       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
 507       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
 508       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed;
 509
 510       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
 511       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
 512       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
 513        = round_toward_zero;
 514     };
 515
 516   /// numeric_limits<signed char> specialization.
 517   template<>
 518     struct numeric_limits<signed char>
 519     {
 520       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 521
 522       static _GLIBCXX_CONSTEXPR signed char
 523       min() _GLIBCXX_USE_NOEXCEPT { return -__SCHAR_MAX__ - 1; }
 524
 525       static _GLIBCXX_CONSTEXPR signed char
 526       max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__; }
 527
 528 #if __cplusplus >= 201103L
 529       static constexpr signed char
 530       lowest() noexcept { return min(); }
 531 #endif
 532
 533       static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (signed char);
 534       static _GLIBCXX_USE_CONSTEXPR int digits10
 535        = __glibcxx_digits10 (signed char);
 536 #if __cplusplus >= 201103L
 537       static constexpr int max_digits10 = 0;
 538 #endif
 539       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
 540       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
 541       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
 542       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
 543
 544       static _GLIBCXX_CONSTEXPR signed char
 545       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
 546
 547       static _GLIBCXX_CONSTEXPR signed char
 548       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
 549
 550       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
 551       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
 552       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
 553       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
 554
 555       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
 556       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
 557       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
 558       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
 559        = denorm_absent;
 560       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 561
 562       static _GLIBCXX_CONSTEXPR signed char
 563       infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); }
 564
 565       static _GLIBCXX_CONSTEXPR signed char
 566       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); }
 567
 568       static _GLIBCXX_CONSTEXPR signed char
 569       signaling_NaN() _GLIBCXX_USE_NOEXCEPT
 570       { return static_cast<signed char>(0); }
 571
 572       static _GLIBCXX_CONSTEXPR signed char
 573       denorm_min() _GLIBCXX_USE_NOEXCEPT
 574       { return static_cast<signed char>(0); }
 575
 576       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
 577       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
 578       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
 579
 580       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
 581       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
 582       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
 583        = round_toward_zero;
 584     };
 585
 586   /// numeric_limits<unsigned char> specialization.
 587   template<>
 588     struct numeric_limits<unsigned char>
 589     {
 590       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 591
 592       static _GLIBCXX_CONSTEXPR unsigned char
 593       min() _GLIBCXX_USE_NOEXCEPT { return 0; }
 594
 595       static _GLIBCXX_CONSTEXPR unsigned char
 596       max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__ * 2U + 1; }
 597
 598 #if __cplusplus >= 201103L
 599       static constexpr unsigned char
 600       lowest() noexcept { return min(); }
 601 #endif
 602
 603       static _GLIBCXX_USE_CONSTEXPR int digits
 604        = __glibcxx_digits (unsigned char);
 605       static _GLIBCXX_USE_CONSTEXPR int digits10
 606        = __glibcxx_digits10 (unsigned char);
 607 #if __cplusplus >= 201103L
 608       static constexpr int max_digits10 = 0;
 609 #endif
 610       static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
 611       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
 612       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
 613       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
 614
 615       static _GLIBCXX_CONSTEXPR unsigned char
 616       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
 617
 618       static _GLIBCXX_CONSTEXPR unsigned char
 619       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
 620
 621       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
 622       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
 623       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
 624       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
 625
 626       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
 627       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
 628       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
 629       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
 630        = denorm_absent;
 631       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 632
 633       static _GLIBCXX_CONSTEXPR unsigned char
 634       infinity() _GLIBCXX_USE_NOEXCEPT
 635       { return static_cast<unsigned char>(0); }
 636
 637       static _GLIBCXX_CONSTEXPR unsigned char
 638       quiet_NaN() _GLIBCXX_USE_NOEXCEPT
 639       { return static_cast<unsigned char>(0); }
 640
 641       static _GLIBCXX_CONSTEXPR unsigned char
 642       signaling_NaN() _GLIBCXX_USE_NOEXCEPT
 643       { return static_cast<unsigned char>(0); }
 644
 645       static _GLIBCXX_CONSTEXPR unsigned char
 646       denorm_min() _GLIBCXX_USE_NOEXCEPT
 647       { return static_cast<unsigned char>(0); }
 648
 649       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
 650       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
 651       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
 652
 653       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
 654       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
 655       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
 656        = round_toward_zero;
 657     };
 658
 659   /// numeric_limits<wchar_t> specialization.
 660   template<>
 661     struct numeric_limits<wchar_t>
 662     {
 663       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 664
 665       static _GLIBCXX_CONSTEXPR wchar_t
 666       min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (wchar_t); }
 667
 668       static _GLIBCXX_CONSTEXPR wchar_t
 669       max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (wchar_t); }
 670
 671 #if __cplusplus >= 201103L
 672       static constexpr wchar_t
 673       lowest() noexcept { return min(); }
 674 #endif
 675
 676       static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (wchar_t);
 677       static _GLIBCXX_USE_CONSTEXPR int digits10
 678        = __glibcxx_digits10 (wchar_t);
 679 #if __cplusplus >= 201103L
 680       static constexpr int max_digits10 = 0;
 681 #endif
 682       static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (wchar_t);
 683       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
 684       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
 685       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
 686
 687       static _GLIBCXX_CONSTEXPR wchar_t
 688       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
 689
 690       static _GLIBCXX_CONSTEXPR wchar_t
 691       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
 692
 693       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
 694       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
 695       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
 696       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
 697
 698       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
 699       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
 700       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
 701       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
 702        = denorm_absent;
 703       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 704
 705       static _GLIBCXX_CONSTEXPR wchar_t
 706       infinity() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
 707
 708       static _GLIBCXX_CONSTEXPR wchar_t
 709       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
 710
 711       static _GLIBCXX_CONSTEXPR wchar_t
 712       signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
 713
 714       static _GLIBCXX_CONSTEXPR wchar_t
 715       denorm_min() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); }
 716
 717       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
 718       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
 719       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed;
 720
 721       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
 722       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
 723       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
 724        = round_toward_zero;
 725     };
 726
 727 #if __cplusplus >= 201103L
 728   /// numeric_limits<char16_t> specialization.
 729   template<>
 730     struct numeric_limits<char16_t>
 731     {
 732       static constexpr bool is_specialized = true;
 733
 734       static constexpr char16_t
 735       min() noexcept { return __glibcxx_min (char16_t); }
 736
 737       static constexpr char16_t
 738       max() noexcept { return __glibcxx_max (char16_t); }
 739
 740       static constexpr char16_t
 741       lowest() noexcept { return min(); }
 742
 743       static constexpr int digits = __glibcxx_digits (char16_t);
 744       static constexpr int digits10 = __glibcxx_digits10 (char16_t);
 745       static constexpr int max_digits10 = 0;
 746       static constexpr bool is_signed = __glibcxx_signed (char16_t);
 747       static constexpr bool is_integer = true;
 748       static constexpr bool is_exact = true;
 749       static constexpr int radix = 2;
 750
 751       static constexpr char16_t
 752       epsilon() noexcept { return 0; }
 753
 754       static constexpr char16_t
 755       round_error() noexcept { return 0; }
 756
 757       static constexpr int min_exponent = 0;
 758       static constexpr int min_exponent10 = 0;
 759       static constexpr int max_exponent = 0;
 760       static constexpr int max_exponent10 = 0;
 761
 762       static constexpr bool has_infinity = false;
 763       static constexpr bool has_quiet_NaN = false;
 764       static constexpr bool has_signaling_NaN = false;
 765       static constexpr float_denorm_style has_denorm = denorm_absent;
 766       static constexpr bool has_denorm_loss = false;
 767
 768       static constexpr char16_t
 769       infinity() noexcept { return char16_t(); }
 770
 771       static constexpr char16_t
 772       quiet_NaN() noexcept { return char16_t(); }
 773
 774       static constexpr char16_t
 775       signaling_NaN() noexcept { return char16_t(); }
 776
 777       static constexpr char16_t
 778       denorm_min() noexcept { return char16_t(); }
 779
 780       static constexpr bool is_iec559 = false;
 781       static constexpr bool is_bounded = true;
 782       static constexpr bool is_modulo = !is_signed;
 783
 784       static constexpr bool traps = __glibcxx_integral_traps;
 785       static constexpr bool tinyness_before = false;
 786       static constexpr float_round_style round_style = round_toward_zero;
 787     };
 788
 789   /// numeric_limits<char32_t> specialization.
 790   template<>
 791     struct numeric_limits<char32_t>
 792     {
 793       static constexpr bool is_specialized = true;
 794
 795       static constexpr char32_t
 796       min() noexcept { return __glibcxx_min (char32_t); }
 797
 798       static constexpr char32_t
 799       max() noexcept { return __glibcxx_max (char32_t); }
 800
 801       static constexpr char32_t
 802       lowest() noexcept { return min(); }
 803
 804       static constexpr int digits = __glibcxx_digits (char32_t);
 805       static constexpr int digits10 = __glibcxx_digits10 (char32_t);
 806       static constexpr int max_digits10 = 0;
 807       static constexpr bool is_signed = __glibcxx_signed (char32_t);
 808       static constexpr bool is_integer = true;
 809       static constexpr bool is_exact = true;
 810       static constexpr int radix = 2;
 811
 812       static constexpr char32_t
 813       epsilon() noexcept { return 0; }
 814
 815       static constexpr char32_t
 816       round_error() noexcept { return 0; }
 817
 818       static constexpr int min_exponent = 0;
 819       static constexpr int min_exponent10 = 0;
 820       static constexpr int max_exponent = 0;
 821       static constexpr int max_exponent10 = 0;
 822
 823       static constexpr bool has_infinity = false;
 824       static constexpr bool has_quiet_NaN = false;
 825       static constexpr bool has_signaling_NaN = false;
 826       static constexpr float_denorm_style has_denorm = denorm_absent;
 827       static constexpr bool has_denorm_loss = false;
 828
 829       static constexpr char32_t
 830       infinity() noexcept { return char32_t(); }
 831
 832       static constexpr char32_t
 833       quiet_NaN() noexcept { return char32_t(); }
 834
 835       static constexpr char32_t
 836       signaling_NaN() noexcept { return char32_t(); }
 837
 838       static constexpr char32_t
 839       denorm_min() noexcept { return char32_t(); }
 840
 841       static constexpr bool is_iec559 = false;
 842       static constexpr bool is_bounded = true;
 843       static constexpr bool is_modulo = !is_signed;
 844
 845       static constexpr bool traps = __glibcxx_integral_traps;
 846       static constexpr bool tinyness_before = false;
 847       static constexpr float_round_style round_style = round_toward_zero;
 848     };
 849 #endif
 850
 851   /// numeric_limits<short> specialization.
 852   template<>
 853     struct numeric_limits<short>
 854     {
 855       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 856
 857       static _GLIBCXX_CONSTEXPR short
 858       min() _GLIBCXX_USE_NOEXCEPT { return -__SHRT_MAX__ - 1; }
 859
 860       static _GLIBCXX_CONSTEXPR short
 861       max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__; }
 862
 863 #if __cplusplus >= 201103L
 864       static constexpr short
 865       lowest() noexcept { return min(); }
 866 #endif
 867
 868       static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (short);
 869       static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (short);
 870 #if __cplusplus >= 201103L
 871       static constexpr int max_digits10 = 0;
 872 #endif
 873       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
 874       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
 875       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
 876       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
 877
 878       static _GLIBCXX_CONSTEXPR short
 879       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
 880
 881       static _GLIBCXX_CONSTEXPR short
 882       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
 883
 884       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
 885       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
 886       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
 887       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
 888
 889       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
 890       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
 891       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
 892       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
 893        = denorm_absent;
 894       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 895
 896       static _GLIBCXX_CONSTEXPR short
 897       infinity() _GLIBCXX_USE_NOEXCEPT { return short(); }
 898
 899       static _GLIBCXX_CONSTEXPR short
 900       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); }
 901
 902       static _GLIBCXX_CONSTEXPR short
 903       signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); }
 904
 905       static _GLIBCXX_CONSTEXPR short
 906       denorm_min() _GLIBCXX_USE_NOEXCEPT { return short(); }
 907
 908       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
 909       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
 910       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
 911
 912       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
 913       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
 914       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
 915        = round_toward_zero;
 916     };
 917
 918   /// numeric_limits<unsigned short> specialization.
 919   template<>
 920     struct numeric_limits<unsigned short>
 921     {
 922       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 923
 924       static _GLIBCXX_CONSTEXPR unsigned short
 925       min() _GLIBCXX_USE_NOEXCEPT { return 0; }
 926
 927       static _GLIBCXX_CONSTEXPR unsigned short
 928       max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__ * 2U + 1; }
 929
 930 #if __cplusplus >= 201103L
 931       static constexpr unsigned short
 932       lowest() noexcept { return min(); }
 933 #endif
 934
 935       static _GLIBCXX_USE_CONSTEXPR int digits
 936        = __glibcxx_digits (unsigned short);
 937       static _GLIBCXX_USE_CONSTEXPR int digits10
 938        = __glibcxx_digits10 (unsigned short);
 939 #if __cplusplus >= 201103L
 940       static constexpr int max_digits10 = 0;
 941 #endif
 942       static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
 943       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
 944       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
 945       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
 946
 947       static _GLIBCXX_CONSTEXPR unsigned short
 948       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
 949
 950       static _GLIBCXX_CONSTEXPR unsigned short
 951       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
 952
 953       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
 954       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
 955       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
 956       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
 957
 958       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
 959       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
 960       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
 961       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
 962        = denorm_absent;
 963       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 964
 965       static _GLIBCXX_CONSTEXPR unsigned short
 966       infinity() _GLIBCXX_USE_NOEXCEPT
 967       { return static_cast<unsigned short>(0); }
 968
 969       static _GLIBCXX_CONSTEXPR unsigned short
 970       quiet_NaN() _GLIBCXX_USE_NOEXCEPT
 971       { return static_cast<unsigned short>(0); }
 972
 973       static _GLIBCXX_CONSTEXPR unsigned short
 974       signaling_NaN() _GLIBCXX_USE_NOEXCEPT
 975       { return static_cast<unsigned short>(0); }
 976
 977       static _GLIBCXX_CONSTEXPR unsigned short
 978       denorm_min() _GLIBCXX_USE_NOEXCEPT
 979       { return static_cast<unsigned short>(0); }
 980
 981       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
 982       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
 983       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
 984
 985       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
 986       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
 987       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
 988        = round_toward_zero;
 989     };
 990
 991   /// numeric_limits<int> specialization.
 992   template<>
 993     struct numeric_limits<int>
 994     {
 995       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 996
 997       static _GLIBCXX_CONSTEXPR int
 998       min() _GLIBCXX_USE_NOEXCEPT { return -__INT_MAX__ - 1; }
 999
1000       static _GLIBCXX_CONSTEXPR int
1001       max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__; }
1002
1003 #if __cplusplus >= 201103L
1004       static constexpr int
1005       lowest() noexcept { return min(); }
1006 #endif
1007
1008       static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (int);
1009       static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (int);
1010 #if __cplusplus >= 201103L
1011       static constexpr int max_digits10 = 0;
1012 #endif
1013       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1014       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1015       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1016       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1017
1018       static _GLIBCXX_CONSTEXPR int
1019       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1020
1021       static _GLIBCXX_CONSTEXPR int
1022       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1023
1024       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1025       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1026       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1027       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1028
1029       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1030       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1031       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1032       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1033        = denorm_absent;
1034       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1035
1036       static _GLIBCXX_CONSTEXPR int
1037       infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1038
1039       static _GLIBCXX_CONSTEXPR int
1040       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1041
1042       static _GLIBCXX_CONSTEXPR int
1043       signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1044
1045       static _GLIBCXX_CONSTEXPR int
1046       denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); }
1047
1048       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1049       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1050       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1051
1052       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1053       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1054       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1055        = round_toward_zero;
1056     };
1057
1058   /// numeric_limits<unsigned int> specialization.
1059   template<>
1060     struct numeric_limits<unsigned int>
1061     {
1062       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1063
1064       static _GLIBCXX_CONSTEXPR unsigned int
1065       min() _GLIBCXX_USE_NOEXCEPT { return 0; }
1066
1067       static _GLIBCXX_CONSTEXPR unsigned int
1068       max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__ * 2U + 1; }
1069
1070 #if __cplusplus >= 201103L
1071       static constexpr unsigned int
1072       lowest() noexcept { return min(); }
1073 #endif
1074
1075       static _GLIBCXX_USE_CONSTEXPR int digits
1076        = __glibcxx_digits (unsigned int);
1077       static _GLIBCXX_USE_CONSTEXPR int digits10
1078        = __glibcxx_digits10 (unsigned int);
1079 #if __cplusplus >= 201103L
1080       static constexpr int max_digits10 = 0;
1081 #endif
1082       static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1083       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1084       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1085       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1086
1087       static _GLIBCXX_CONSTEXPR unsigned int
1088       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1089
1090       static _GLIBCXX_CONSTEXPR unsigned int
1091       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1092
1093       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1094       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1095       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1096       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1097
1098       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1099       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1100       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1101       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1102        = denorm_absent;
1103       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1104
1105       static _GLIBCXX_CONSTEXPR unsigned int
1106       infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<unsigned int>(0); }
1107
1108       static _GLIBCXX_CONSTEXPR unsigned int
1109       quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1110       { return static_cast<unsigned int>(0); }
1111
1112       static _GLIBCXX_CONSTEXPR unsigned int
1113       signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1114       { return static_cast<unsigned int>(0); }
1115
1116       static _GLIBCXX_CONSTEXPR unsigned int
1117       denorm_min() _GLIBCXX_USE_NOEXCEPT
1118       { return static_cast<unsigned int>(0); }
1119
1120       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1121       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1122       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1123
1124       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1125       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1126       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1127        = round_toward_zero;
1128     };
1129
1130   /// numeric_limits<long> specialization.
1131   template<>
1132     struct numeric_limits<long>
1133     {
1134       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1135
1136       static _GLIBCXX_CONSTEXPR long
1137       min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_MAX__ - 1; }
1138
1139       static _GLIBCXX_CONSTEXPR long
1140       max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__; }
1141
1142 #if __cplusplus >= 201103L
1143       static constexpr long
1144       lowest() noexcept { return min(); }
1145 #endif
1146
1147       static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (long);
1148       static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (long);
1149 #if __cplusplus >= 201103L
1150       static constexpr int max_digits10 = 0;
1151 #endif
1152       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1153       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1154       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1155       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1156
1157       static _GLIBCXX_CONSTEXPR long
1158       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1159
1160       static _GLIBCXX_CONSTEXPR long
1161       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1162
1163       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1164       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1165       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1166       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1167
1168       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1169       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1170       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1171       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1172        = denorm_absent;
1173       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1174
1175       static _GLIBCXX_CONSTEXPR long
1176       infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1177
1178       static _GLIBCXX_CONSTEXPR long
1179       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1180
1181       static _GLIBCXX_CONSTEXPR long
1182       signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1183
1184       static _GLIBCXX_CONSTEXPR long
1185       denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); }
1186
1187       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1188       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1189       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1190
1191       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1192       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1193       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1194        = round_toward_zero;
1195     };
1196
1197   /// numeric_limits<unsigned long> specialization.
1198   template<>
1199     struct numeric_limits<unsigned long>
1200     {
1201       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1202
1203       static _GLIBCXX_CONSTEXPR unsigned long
1204       min() _GLIBCXX_USE_NOEXCEPT { return 0; }
1205
1206       static _GLIBCXX_CONSTEXPR unsigned long
1207       max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__ * 2UL + 1; }
1208
1209 #if __cplusplus >= 201103L
1210       static constexpr unsigned long
1211       lowest() noexcept { return min(); }
1212 #endif
1213
1214       static _GLIBCXX_USE_CONSTEXPR int digits
1215        = __glibcxx_digits (unsigned long);
1216       static _GLIBCXX_USE_CONSTEXPR int digits10
1217        = __glibcxx_digits10 (unsigned long);
1218 #if __cplusplus >= 201103L
1219       static constexpr int max_digits10 = 0;
1220 #endif
1221       static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1222       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1223       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1224       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1225
1226       static _GLIBCXX_CONSTEXPR unsigned long
1227       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1228
1229       static _GLIBCXX_CONSTEXPR unsigned long
1230       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1231
1232       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1233       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1234       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1235       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1236
1237       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1238       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1239       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1240       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1241        = denorm_absent;
1242       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1243
1244       static _GLIBCXX_CONSTEXPR unsigned long
1245       infinity() _GLIBCXX_USE_NOEXCEPT
1246       { return static_cast<unsigned long>(0); }
1247
1248       static _GLIBCXX_CONSTEXPR unsigned long
1249       quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1250       { return static_cast<unsigned long>(0); }
1251
1252       static _GLIBCXX_CONSTEXPR unsigned long
1253       signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1254       { return static_cast<unsigned long>(0); }
1255
1256       static _GLIBCXX_CONSTEXPR unsigned long
1257       denorm_min() _GLIBCXX_USE_NOEXCEPT
1258       { return static_cast<unsigned long>(0); }
1259
1260       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1261       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1262       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1263
1264       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1265       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1266       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1267        = round_toward_zero;
1268     };
1269
1270   /// numeric_limits<long long> specialization.
1271   template<>
1272     struct numeric_limits<long long>
1273     {
1274       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1275
1276       static _GLIBCXX_CONSTEXPR long long
1277       min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_LONG_MAX__ - 1; }
1278
1279       static _GLIBCXX_CONSTEXPR long long
1280       max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__; }
1281
1282 #if __cplusplus >= 201103L
1283       static constexpr long long
1284       lowest() noexcept { return min(); }
1285 #endif
1286
1287       static _GLIBCXX_USE_CONSTEXPR int digits
1288        = __glibcxx_digits (long long);
1289       static _GLIBCXX_USE_CONSTEXPR int digits10
1290        = __glibcxx_digits10 (long long);
1291 #if __cplusplus >= 201103L
1292       static constexpr int max_digits10 = 0;
1293 #endif
1294       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1295       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1296       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1297       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1298
1299       static _GLIBCXX_CONSTEXPR long long
1300       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1301
1302       static _GLIBCXX_CONSTEXPR long long
1303       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1304
1305       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1306       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1307       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1308       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1309
1310       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1311       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1312       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1313       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1314        = denorm_absent;
1315       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1316
1317       static _GLIBCXX_CONSTEXPR long long
1318       infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
1319
1320       static _GLIBCXX_CONSTEXPR long long
1321       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
1322
1323       static _GLIBCXX_CONSTEXPR long long
1324       signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1325       { return static_cast<long long>(0); }
1326
1327       static _GLIBCXX_CONSTEXPR long long
1328       denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); }
1329
1330       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1331       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1332       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1333
1334       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1335       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1336       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1337        = round_toward_zero;
1338     };
1339
1340   /// numeric_limits<unsigned long long> specialization.
1341   template<>
1342     struct numeric_limits<unsigned long long>
1343     {
1344       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1345
1346       static _GLIBCXX_CONSTEXPR unsigned long long
1347       min() _GLIBCXX_USE_NOEXCEPT { return 0; }
1348
1349       static _GLIBCXX_CONSTEXPR unsigned long long
1350       max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__ * 2ULL + 1; }
1351
1352 #if __cplusplus >= 201103L
1353       static constexpr unsigned long long
1354       lowest() noexcept { return min(); }
1355 #endif
1356
1357       static _GLIBCXX_USE_CONSTEXPR int digits
1358        = __glibcxx_digits (unsigned long long);
1359       static _GLIBCXX_USE_CONSTEXPR int digits10
1360        = __glibcxx_digits10 (unsigned long long);
1361 #if __cplusplus >= 201103L
1362       static constexpr int max_digits10 = 0;
1363 #endif
1364       static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
1365       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
1366       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
1367       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
1368
1369       static _GLIBCXX_CONSTEXPR unsigned long long
1370       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
1371
1372       static _GLIBCXX_CONSTEXPR unsigned long long
1373       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
1374
1375       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
1376       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
1377       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
1378       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
1379
1380       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
1381       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
1382       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
1383       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1384        = denorm_absent;
1385       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
1386
1387       static _GLIBCXX_CONSTEXPR unsigned long long
1388       infinity() _GLIBCXX_USE_NOEXCEPT
1389       { return static_cast<unsigned long long>(0); }
1390
1391       static _GLIBCXX_CONSTEXPR unsigned long long
1392       quiet_NaN() _GLIBCXX_USE_NOEXCEPT
1393       { return static_cast<unsigned long long>(0); }
1394
1395       static _GLIBCXX_CONSTEXPR unsigned long long
1396       signaling_NaN() _GLIBCXX_USE_NOEXCEPT
1397       { return static_cast<unsigned long long>(0); }
1398
1399       static _GLIBCXX_CONSTEXPR unsigned long long
1400       denorm_min() _GLIBCXX_USE_NOEXCEPT
1401       { return static_cast<unsigned long long>(0); }
1402
1403       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
1404       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1405       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;
1406
1407       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
1408       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
1409       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1410        = round_toward_zero;
1411     };
1412
1413 #if !defined(__STRICT_ANSI__)
1414
1415 #define __INT_N(TYPE, BITSIZE, EXT, UEXT)                       \
1416   template<>                                                                    \
1417     struct numeric_limits<TYPE>                                                 \
1418     {                                                                           \
1419       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;                 \
1420                                                                                 \
1421       static _GLIBCXX_CONSTEXPR TYPE                                            \
1422         min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min_b (TYPE, BITSIZE); } \
1423                                                                                 \
1424       static _GLIBCXX_CONSTEXPR TYPE                                            \
1425       max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max_b (TYPE, BITSIZE); }   \
1426                                                                                 \
1427       static _GLIBCXX_USE_CONSTEXPR int digits                                  \
1428        = BITSIZE - 1;                                                           \
1429       static _GLIBCXX_USE_CONSTEXPR int digits10                                \
1430        = (BITSIZE - 1) * 643L / 2136;                                           \
1431                                                                                 \
1432       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;                      \
1433       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;                     \
1434       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;                       \
1435       static _GLIBCXX_USE_CONSTEXPR int radix = 2;                              \
1436                                                                                 \
1437       static _GLIBCXX_CONSTEXPR TYPE                                            \
1438       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }                             \
1439                                                                                 \
1440       static _GLIBCXX_CONSTEXPR TYPE                                            \
1441       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }                         \
1442                                                                                 \
1443       EXT                                                                       \
1444                                                                                 \
1445       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;                       \
1446       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;                     \
1447       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;                       \
1448       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;                     \
1449                                                                                 \
1450       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;                  \
1451       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;                 \
1452       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;             \
1453       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm               \
1454        = denorm_absent;                                                         \
1455       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;               \
1456                                                                                 \
1457       static _GLIBCXX_CONSTEXPR TYPE                                            \
1458       infinity() _GLIBCXX_USE_NOEXCEPT                                          \
1459       { return static_cast<TYPE>(0); }                                          \
1460                                                                                 \
1461       static _GLIBCXX_CONSTEXPR TYPE                                            \
1462       quiet_NaN() _GLIBCXX_USE_NOEXCEPT                                         \
1463       { return static_cast<TYPE>(0); }                                          \
1464                                                                                 \
1465       static _GLIBCXX_CONSTEXPR TYPE                                            \
1466       signaling_NaN() _GLIBCXX_USE_NOEXCEPT                                     \
1467       { return static_cast<TYPE>(0); }                                          \
1468                                                                                 \
1469       static _GLIBCXX_CONSTEXPR TYPE                                            \
1470       denorm_min() _GLIBCXX_USE_NOEXCEPT                                        \
1471       { return static_cast<TYPE>(0); }                                          \
1472                                                                                 \
1473       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;                     \
1474       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;                     \
1475       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;                     \
1476                                                                                 \
1477       static _GLIBCXX_USE_CONSTEXPR bool traps                                  \
1478        = __glibcxx_integral_traps;                                              \
1479       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;               \
1480       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style               \
1481        = round_toward_zero;                                                     \
1482     };                                                                          \
1483                                                                                 \
1484   template<>                                                                    \
1485     struct numeric_limits<unsigned TYPE>                                        \
1486     {                                                                           \
1487       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;                 \
1488                                                                                 \
1489       static _GLIBCXX_CONSTEXPR unsigned TYPE                                   \
1490       min() _GLIBCXX_USE_NOEXCEPT { return 0; }                                 \
1491                                                                                 \
1492       static _GLIBCXX_CONSTEXPR unsigned TYPE                                   \
1493       max() _GLIBCXX_USE_NOEXCEPT                                               \
1494       { return  __glibcxx_max_b (unsigned TYPE, BITSIZE); }                     \
1495                                                                                 \
1496       UEXT                                                                      \
1497                                                                                 \
1498       static _GLIBCXX_USE_CONSTEXPR int digits                                  \
1499        = BITSIZE;                                                               \
1500       static _GLIBCXX_USE_CONSTEXPR int digits10                                \
1501        = BITSIZE * 643L / 2136;                                                 \
1502       static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;                     \
1503       static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;                     \
1504       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;                       \
1505       static _GLIBCXX_USE_CONSTEXPR int radix = 2;                              \
1506                                                                                 \
1507       static _GLIBCXX_CONSTEXPR unsigned TYPE                                   \
1508       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }                             \
1509                                                                                 \
1510       static _GLIBCXX_CONSTEXPR unsigned TYPE                                   \
1511       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }                         \
1512                                                                                 \
1513       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;                       \
1514       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;                     \
1515       static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;                       \
1516       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;                     \
1517                                                                                 \
1518       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;                  \
1519       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;                 \
1520       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;             \
1521       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm               \
1522        = denorm_absent;                                                         \
1523       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;               \
1524                                                                                 \
1525       static _GLIBCXX_CONSTEXPR unsigned TYPE                                   \
1526       infinity() _GLIBCXX_USE_NOEXCEPT                                          \
1527       { return static_cast<unsigned TYPE>(0); }                                 \
1528                                                                                 \
1529       static _GLIBCXX_CONSTEXPR unsigned TYPE                                   \
1530       quiet_NaN() _GLIBCXX_USE_NOEXCEPT                                         \
1531       { return static_cast<unsigned TYPE>(0); }                                 \
1532                                                                                 \
1533       static _GLIBCXX_CONSTEXPR unsigned TYPE                                   \
1534       signaling_NaN() _GLIBCXX_USE_NOEXCEPT                                     \
1535       { return static_cast<unsigned TYPE>(0); }                                 \
1536                                                                                 \
1537       static _GLIBCXX_CONSTEXPR unsigned TYPE                                   \
1538       denorm_min() _GLIBCXX_USE_NOEXCEPT                                        \
1539       { return static_cast<unsigned TYPE>(0); }                                 \
1540                                                                                 \
1541       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;                     \
1542       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;                     \
1543       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true;                      \
1544                                                                                 \
1545       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;      \
1546       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;               \
1547       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style               \
1548        = round_toward_zero;                                                     \
1549     };
1550
1551 #if __cplusplus >= 201103L
1552
1553 #define __INT_N_201103(TYPE)                                                    \
1554       static constexpr TYPE                                                     \
1555       lowest() noexcept { return min(); }                                       \
1556       static constexpr int max_digits10 = 0;
1557
1558 #define __INT_N_U201103(TYPE)                                                   \
1559       static constexpr unsigned TYPE                                            \
1560       lowest() noexcept { return min(); }                                       \
1561       static constexpr int max_digits10 = 0;
1562
1563 #else
1564 #define __INT_N_201103(TYPE)
1565 #define __INT_N_U201103(TYPE)
1566 #endif
1567
1568 #ifdef __GLIBCXX_TYPE_INT_N_0
1569   __INT_N(__GLIBCXX_TYPE_INT_N_0, __GLIBCXX_BITSIZE_INT_N_0,
1570           __INT_N_201103 (__GLIBCXX_TYPE_INT_N_0), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_0))
1571 #endif
1572 #ifdef __GLIBCXX_TYPE_INT_N_1
1573   __INT_N (__GLIBCXX_TYPE_INT_N_1, __GLIBCXX_BITSIZE_INT_N_1,
1574           __INT_N_201103 (__GLIBCXX_TYPE_INT_N_1), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_1))
1575 #endif
1576 #ifdef __GLIBCXX_TYPE_INT_N_2
1577   __INT_N (__GLIBCXX_TYPE_INT_N_2, __GLIBCXX_BITSIZE_INT_N_2,
1578           __INT_N_201103 (__GLIBCXX_TYPE_INT_N_2), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_2))
1579 #endif
1580 #ifdef __GLIBCXX_TYPE_INT_N_3
1581   __INT_N (__GLIBCXX_TYPE_INT_N_3, __GLIBCXX_BITSIZE_INT_N_3,
1582           __INT_N_201103 (__GLIBCXX_TYPE_INT_N_3), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_3))
1583 #endif
1584
1585 #undef __INT_N
1586 #undef __INT_N_201103
1587 #undef __INT_N_U201103
1588
1589 #endif
1590
1591   /// numeric_limits<float> specialization.
1592   template<>
1593     struct numeric_limits<float>
1594     {
1595       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1596
1597       static _GLIBCXX_CONSTEXPR float
1598       min() _GLIBCXX_USE_NOEXCEPT { return __FLT_MIN__; }
1599
1600       static _GLIBCXX_CONSTEXPR float
1601       max() _GLIBCXX_USE_NOEXCEPT { return __FLT_MAX__; }
1602
1603 #if __cplusplus >= 201103L
1604       static constexpr float
1605       lowest() noexcept { return -__FLT_MAX__; }
1606 #endif
1607
1608       static _GLIBCXX_USE_CONSTEXPR int digits = __FLT_MANT_DIG__;
1609       static _GLIBCXX_USE_CONSTEXPR int digits10 = __FLT_DIG__;
1610 #if __cplusplus >= 201103L
1611       static constexpr int max_digits10
1612          = __glibcxx_max_digits10 (__FLT_MANT_DIG__);
1613 #endif
1614       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1615       static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1616       static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1617       static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1618
1619       static _GLIBCXX_CONSTEXPR float
1620       epsilon() _GLIBCXX_USE_NOEXCEPT { return __FLT_EPSILON__; }
1621
1622       static _GLIBCXX_CONSTEXPR float
1623       round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5F; }
1624
1625       static _GLIBCXX_USE_CONSTEXPR int min_exponent = __FLT_MIN_EXP__;
1626       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __FLT_MIN_10_EXP__;
1627       static _GLIBCXX_USE_CONSTEXPR int max_exponent = __FLT_MAX_EXP__;
1628       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __FLT_MAX_10_EXP__;
1629
1630       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __FLT_HAS_INFINITY__;
1631       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__;
1632       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1633       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1634         = bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent;
1635       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1636        = __glibcxx_float_has_denorm_loss;
1637
1638       static _GLIBCXX_CONSTEXPR float
1639       infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_valf(); }
1640
1641       static _GLIBCXX_CONSTEXPR float
1642       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanf(""); }
1643
1644       static _GLIBCXX_CONSTEXPR float
1645       signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansf(""); }
1646
1647       static _GLIBCXX_CONSTEXPR float
1648       denorm_min() _GLIBCXX_USE_NOEXCEPT { return __FLT_DENORM_MIN__; }
1649
1650       static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1651         = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1652       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1653       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1654
1655       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_float_traps;
1656       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before
1657        = __glibcxx_float_tinyness_before;
1658       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1659        = round_to_nearest;
1660     };
1661
1662 #undef __glibcxx_float_has_denorm_loss
1663 #undef __glibcxx_float_traps
1664 #undef __glibcxx_float_tinyness_before
1665
1666   /// numeric_limits<double> specialization.
1667   template<>
1668     struct numeric_limits<double>
1669     {
1670       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1671
1672       static _GLIBCXX_CONSTEXPR double
1673       min() _GLIBCXX_USE_NOEXCEPT { return __DBL_MIN__; }
1674
1675       static _GLIBCXX_CONSTEXPR double
1676       max() _GLIBCXX_USE_NOEXCEPT { return __DBL_MAX__; }
1677
1678 #if __cplusplus >= 201103L
1679       static constexpr double
1680       lowest() noexcept { return -__DBL_MAX__; }
1681 #endif
1682
1683       static _GLIBCXX_USE_CONSTEXPR int digits = __DBL_MANT_DIG__;
1684       static _GLIBCXX_USE_CONSTEXPR int digits10 = __DBL_DIG__;
1685 #if __cplusplus >= 201103L
1686       static constexpr int max_digits10
1687          = __glibcxx_max_digits10 (__DBL_MANT_DIG__);
1688 #endif
1689       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1690       static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1691       static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1692       static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1693
1694       static _GLIBCXX_CONSTEXPR double
1695       epsilon() _GLIBCXX_USE_NOEXCEPT { return __DBL_EPSILON__; }
1696
1697       static _GLIBCXX_CONSTEXPR double
1698       round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5; }
1699
1700       static _GLIBCXX_USE_CONSTEXPR int min_exponent = __DBL_MIN_EXP__;
1701       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __DBL_MIN_10_EXP__;
1702       static _GLIBCXX_USE_CONSTEXPR int max_exponent = __DBL_MAX_EXP__;
1703       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __DBL_MAX_10_EXP__;
1704
1705       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __DBL_HAS_INFINITY__;
1706       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__;
1707       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1708       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1709         = bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent;
1710       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1711         = __glibcxx_double_has_denorm_loss;
1712
1713       static _GLIBCXX_CONSTEXPR double
1714       infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_val(); }
1715
1716       static _GLIBCXX_CONSTEXPR double
1717       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nan(""); }
1718
1719       static _GLIBCXX_CONSTEXPR double
1720       signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nans(""); }
1721
1722       static _GLIBCXX_CONSTEXPR double
1723       denorm_min() _GLIBCXX_USE_NOEXCEPT { return __DBL_DENORM_MIN__; }
1724
1725       static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1726         = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1727       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1728       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1729
1730       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_double_traps;
1731       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before
1732        = __glibcxx_double_tinyness_before;
1733       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style
1734        = round_to_nearest;
1735     };
1736
1737 #undef __glibcxx_double_has_denorm_loss
1738 #undef __glibcxx_double_traps
1739 #undef __glibcxx_double_tinyness_before
1740
1741   /// numeric_limits<long double> specialization.
1742   template<>
1743     struct numeric_limits<long double>
1744     {
1745       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
1746
1747       static _GLIBCXX_CONSTEXPR long double
1748       min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MIN__; }
1749
1750       static _GLIBCXX_CONSTEXPR long double
1751       max() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MAX__; }
1752
1753 #if __cplusplus >= 201103L
1754       static constexpr long double
1755       lowest() noexcept { return -__LDBL_MAX__; }
1756 #endif
1757
1758       static _GLIBCXX_USE_CONSTEXPR int digits = __LDBL_MANT_DIG__;
1759       static _GLIBCXX_USE_CONSTEXPR int digits10 = __LDBL_DIG__;
1760 #if __cplusplus >= 201103L
1761       static _GLIBCXX_USE_CONSTEXPR int max_digits10
1762          = __glibcxx_max_digits10 (__LDBL_MANT_DIG__);
1763 #endif
1764       static _GLIBCXX_USE_CONSTEXPR bool is_signed = true;
1765       static _GLIBCXX_USE_CONSTEXPR bool is_integer = false;
1766       static _GLIBCXX_USE_CONSTEXPR bool is_exact = false;
1767       static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__;
1768
1769       static _GLIBCXX_CONSTEXPR long double
1770       epsilon() _GLIBCXX_USE_NOEXCEPT { return __LDBL_EPSILON__; }
1771
1772       static _GLIBCXX_CONSTEXPR long double
1773       round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5L; }
1774
1775       static _GLIBCXX_USE_CONSTEXPR int min_exponent = __LDBL_MIN_EXP__;
1776       static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __LDBL_MIN_10_EXP__;
1777       static _GLIBCXX_USE_CONSTEXPR int max_exponent = __LDBL_MAX_EXP__;
1778       static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __LDBL_MAX_10_EXP__;
1779
1780       static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __LDBL_HAS_INFINITY__;
1781       static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__;
1782       static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN;
1783       static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm
1784         = bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent;
1785       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss
1786         = __glibcxx_long_double_has_denorm_loss;
1787
1788       static _GLIBCXX_CONSTEXPR long double
1789       infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_vall(); }
1790
1791       static _GLIBCXX_CONSTEXPR long double
1792       quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanl(""); }
1793
1794       static _GLIBCXX_CONSTEXPR long double
1795       signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansl(""); }
1796
1797       static _GLIBCXX_CONSTEXPR long double
1798       denorm_min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_DENORM_MIN__; }
1799
1800       static _GLIBCXX_USE_CONSTEXPR bool is_iec559
1801         = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1802       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
1803       static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
1804
1805       static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_long_double_traps;
1806       static _GLIBCXX_USE_CONSTEXPR bool tinyness_before =
1807                                          __glibcxx_long_double_tinyness_before;
1808       static _GLIBCXX_USE_CONSTEXPR float_round_style round_style =
1809                                                       round_to_nearest;
1810     };
1811
1812 #undef __glibcxx_long_double_has_denorm_loss
1813 #undef __glibcxx_long_double_traps
1814 #undef __glibcxx_long_double_tinyness_before
1815
1816 _GLIBCXX_END_NAMESPACE_VERSION
1817 } // namespace
1818
1819 #undef __glibcxx_signed
1820 #undef __glibcxx_min
1821 #undef __glibcxx_max
1822 #undef __glibcxx_digits
1823 #undef __glibcxx_digits10
1824 #undef __glibcxx_max_digits10
1825
1826 #endif // _GLIBCXX_NUMERIC_LIMITS