Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. // The template and inlines for the numeric_limits classes. -*- C++ -*-
  2.  
  3. // Copyright (C) 1999-2013 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
  1787.