wpkg test coverage results

Coverage test results of the Windows Packager by Made to Order Software Corporation.

LCOV - code coverage report
Current view: top level - usr/include/c++/4.8 - limits (source / functions) Hit Total Coverage
Test: coverage.info Lines: 2 2 100.0 %
Date: 2014-07-27 Functions: 2 2 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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          24 :       min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_MAX__ - 1; }
    1127             : 
    1128             :       static _GLIBCXX_CONSTEXPR long 
    1129          24 :       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

Generated by: LCOV version 1.9

The wpkg tool is an open source tool created by Made to Order Software Corporation.