cartobase-5.1/doxygen/limits__gcc3_8h_source.html

 /* This software and supporting documentation are distributed by

  *     Institut Federatif de Recherche 49

  *     CEA/NeuroSpin, Batiment 145,

  *     91191 Gif-sur-Yvette cedex

  *     France

  *

  * This software is governed by the CeCILL-B license under

  * French law and abiding by the rules of distribution of free software.

  * You can  use, modify and/or redistribute the software under the

  * terms of the CeCILL-B license as circulated by CEA, CNRS

  * and INRIA at the following URL "http://www.cecill.info".

  *

  * As a counterpart to the access to the source code and  rights to copy,

  * modify and redistribute granted by the license, users are provided only

  * with a limited warranty  and the software's author,  the holder of the

  * economic rights,  and the successive licensors  have only  limited

  * liability.

  *

  * In this respect, the user's attention is drawn to the risks associated

  * with loading,  using,  modifying and/or developing or reproducing the

  * software by the user in light of its specific status of free software,

  * that may mean  that it is complicated to manipulate,  and  that  also

  * therefore means  that it is reserved for developers  and  experienced

  * professionals having in-depth computer knowledge. Users are therefore

  * encouraged to load and test the software's suitability as regards their

  * requirements in conditions enabling the security of their systems and/or

  * data to be ensured and,  more generally, to use and operate it in the

  * same conditions as regards security.

  *

  * The fact that you are presently reading this means that you have had

  * knowledge of the CeCILL-B license and that you accept its terms.

  */


 // Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc.

 //

 // This file is part of the GNU ISO C++ Library.  This library is free

 // software; you can redistribute it and/or modify it under the

 // terms of the GNU General Public License as published by the

 // Free Software Foundation; either version 2, or (at your option)

 // any later version.


 // This library is distributed in the hope that it will be useful,

 // but WITHOUT ANY WARRANTY; without even the implied warranty of

 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 // GNU General Public License for more details.


 // You should have received a copy of the GNU General Public License along

 // with this library; see the file COPYING.  If not, write to the Free

 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,

 // USA.


 // As a special exception, you may use this file as part of a free software

 // library without restriction.  Specifically, if other files instantiate

 // templates or use macros or inline functions from this file, or you compile

 // this file and link it with other files to produce an executable, this

 // file does not by itself cause the resulting executable to be covered by

 // the GNU General Public License.  This exception does not however

 // invalidate any other reasons why the executable file might be covered by

 // the GNU General Public License.


 // Note: this is not a conforming implementation.

 // Written by Gabriel Dos Reis <gdr@codesourcery.com>


 //

 // ISO 14882:1998

 // 18.2.1

 //


 #ifndef _CPP_NUMERIC_LIMITS

 #define _CPP_NUMERIC_LIMITS 1


 #if defined( __GNUC__ ) && (__GNUC__-0 >= 3)


 #error This header should not be included, it should be in the standard C++ \

 library


 #else


 //

 // The numeric_limits<> traits document implementation-defined aspects

 // of fundamental arithmetic data types (integers and floating points).

 // From Standard C++ point of view, there are 13 such types:

 //   * integers

 //         bool                                                 (1)

 //         char, signed char, unsigned char                     (3)

 //         short, unsigned short                                (2)

 //         int, unsigned                                        (2)

 //         long, unsigned long                                  (2)

 //

 //   * floating points

 //         float                                                (1)

 //         double                                               (1)

 //         long double                                          (1)

 //

 // GNU C++ understands (where supported by the host C-library)

 //   * integer

 //         long long, unsigned long long                        (2)

 //

 // which brings us to 15 fundamental arithmetic data types in GNU C++.

 //

 //

 // Since a numeric_limits<> is a bit tricky to get right, we rely on

 // an interface composed of macros which should be defined in config/os

 // or config/cpu when they differ from the generic (read arbitrary)

 // definitions given here.

 //


 // These values can be overridden in the target configuration file.

 // The default values are appropriate for many 32-bit targets.


 #include <climits>

 #include <cfloat>


 /* I don't really understand the direct relationship between max exponent

    and the number of bits to store them... */

 #define __carto_expo_bits( x ) ( x >= 16384 ? 15 : ( x >= 384 ? 11 : 8 ) )

 #define __carto_float_bits ( FLT_MANT_DIG + __carto_expo_bits(FLT_MAX_EXP) )

 #define __carto_double_bits ( DBL_MANT_DIG + __carto_expo_bits(DBL_MAX_EXP) )

 #define __carto_ldouble_bits1 ( LDBL_MANT_DIG + __carto_expo_bits(LDBL_MAX_EXP) )

 /* long double should be 80 bits for linux/32, 64 bits for irix/mips and 128

    bits for solaris/sparc */

 #define __carto_ldouble_bits ( __carto_ldouble_bits1 == 79 ? 80 : __carto_ldouble_bits1 )


 // --


 #ifndef __glibcpp_char_bits

 #define __glibcpp_char_bits 8

 #endif

 #ifdef __CHAR_UNSIGNED__

 #define __glibcpp_plain_char_is_signed false

 #else

 #define __glibcpp_plain_char_is_signed true

 #endif

 #ifndef __glibcpp_short_bits

 #define __glibcpp_short_bits 16

 #endif

 #ifndef __glibcpp_int_bits

 #define __glibcpp_int_bits 32

 #endif

 #ifndef __glibcpp_long_bits

 #define __glibcpp_long_bits 32

 #endif

 #ifndef __glibcpp_wchar_t_bits

 #define __glibcpp_wchar_t_bits 32

 #endif

 #ifndef __glibcpp_wchar_t_is_signed

 #define __glibcpp_wchar_t_is_signed true

 #endif

 #ifndef __glibcpp_long_long_bits

 #define __glibcpp_long_long_bits 64

 #endif

 #ifndef __glibcpp_float_bits

 #define __glibcpp_float_bits __carto_float_bits

 #endif

 #ifndef __glibcpp_double_bits

 #define __glibcpp_double_bits __carto_double_bits

 #endif

 #ifndef __glibcpp_long_double_bits

 #define __glibcpp_long_double_bits __carto_ldouble_bits

 #endif


 #ifndef __glibcpp_char_traps

 #define __glibcpp_char_traps true

 #endif

 #ifndef __glibcpp_short_traps

 #define __glibcpp_short_traps true

 #endif

 #ifndef __glibcpp_int_traps

 #define __glibcpp_int_traps true

 #endif

 #ifndef __glibcpp_long_traps

 #define __glibcpp_long_traps true

 #endif

 #ifndef __glibcpp_wchar_t_traps

 #define __glibcpp_wchar_t_traps true

 #endif

 #ifndef __glibcpp_long_long_traps

 #define __glibcpp_long_long_traps true

 #endif


 // You should not need to define any macros below this point, unless

 // you have a machine with non-standard bit-widths.


 // These values are the minimums and maximums for standard data types

 // of common widths.


 #define __glibcpp_s8_max 127

 #define __glibcpp_s8_min (-__glibcpp_s8_max - 1)

 #define __glibcpp_s8_digits 7

 #define __glibcpp_s8_digits10 2

 #define __glibcpp_u8_min 0U

 #define __glibcpp_u8_max (__glibcpp_s8_max * 2 + 1)

 #define __glibcpp_u8_digits 8

 #define __glibcpp_u8_digits10 2

 #define __glibcpp_s16_max 32767

 #define __glibcpp_s16_min (-__glibcpp_s16_max - 1)

 #define __glibcpp_s16_digits 15

 #define __glibcpp_s16_digits10 4

 #define __glibcpp_u16_min 0U

 #define __glibcpp_u16_max (__glibcpp_s16_max * 2 + 1)

 #define __glibcpp_u16_digits 16

 #define __glibcpp_u16_digits10 4

 #define __glibcpp_s32_max 2147483647L

 #define __glibcpp_s32_min (-__glibcpp_s32_max - 1)

 #define __glibcpp_s32_digits 31

 #define __glibcpp_s32_digits10 9

 #define __glibcpp_u32_min 0UL

 #define __glibcpp_u32_max (__glibcpp_s32_max * 2U + 1)

 #define __glibcpp_u32_digits 32

 #define __glibcpp_u32_digits10 9

 #define __glibcpp_s64_max 9223372036854775807LL

 #define __glibcpp_s64_min (-__glibcpp_s64_max - 1)

 #define __glibcpp_s64_digits 63

 #define __glibcpp_s64_digits10 18

 #define __glibcpp_u64_min 0ULL

 #define __glibcpp_u64_max (__glibcpp_s64_max * 2ULL + 1)

 #define __glibcpp_u64_digits 64

 #define __glibcpp_u64_digits10 19


 #define __glibcpp_f32_min 1.17549435e-38F

 #define __glibcpp_f32_max 3.40282347e+38F

 #define __glibcpp_f32_digits 24

 #define __glibcpp_f32_digits10 6

 #define __glibcpp_f32_radix 2

 #define __glibcpp_f32_epsilon 1.19209290e-07F

 #define __glibcpp_f32_round_error 1.0F

 #define __glibcpp_f32_min_exponent -125

 #define __glibcpp_f32_min_exponent10 -37

 #define __glibcpp_f32_max_exponent 128

 #define __glibcpp_f32_max_exponent10 38

 #define __glibcpp_f64_min 2.2250738585072014e-308

 #define __glibcpp_f64_max 1.7976931348623157e+308

 #define __glibcpp_f64_digits 53

 #define __glibcpp_f64_digits10 15

 #define __glibcpp_f64_radix 2

 #define __glibcpp_f64_epsilon 2.2204460492503131e-16

 #define __glibcpp_f64_round_error 1.0

 #define __glibcpp_f64_min_exponent -1021

 #define __glibcpp_f64_min_exponent10 -307

 #define __glibcpp_f64_max_exponent 1024

 #define __glibcpp_f64_max_exponent10 308

 #define __glibcpp_f80_min 3.36210314311209350626e-4932L

 #define __glibcpp_f80_max 1.18973149535723176502e+4932L

 #define __glibcpp_f80_digits 64

 #define __glibcpp_f80_digits10 18

 #define __glibcpp_f80_radix 2

 #define __glibcpp_f80_epsilon 1.08420217248550443401e-19L

 #define __glibcpp_f80_round_error 1.0L

 #define __glibcpp_f80_min_exponent -16381

 #define __glibcpp_f80_min_exponent10 -4931

 #define __glibcpp_f80_max_exponent 16384

 #define __glibcpp_f80_max_exponent10 4932

 #define __glibcpp_f96_min 1.68105157155604675313e-4932L

 #define __glibcpp_f96_max 1.18973149535723176502e+4932L

 #define __glibcpp_f96_digits 64

 #define __glibcpp_f96_digits10 18

 #define __glibcpp_f96_radix 2

 #define __glibcpp_f96_epsilon 1.08420217248550443401e-19L

 #define __glibcpp_f96_round_error 1.0L

 #define __glibcpp_f96_min_exponent -16382

 #define __glibcpp_f96_min_exponent10 -4931

 #define __glibcpp_f96_max_exponent 16384

 #define __glibcpp_f96_max_exponent10 4932

 #define __glibcpp_f128_min 3.362103143112093506262677817321752603E-4932L

 #define __glibcpp_f128_max 1.189731495357231765085759326628007016E+4932L

 #define __glibcpp_f128_digits 113

 #define __glibcpp_f128_digits10 33

 #define __glibcpp_f128_radix 2

 #define __glibcpp_f128_epsilon 1.925929944387235853055977942584927319E-34L

 #define __glibcpp_f128_round_error 1.0L

 #define __glibcpp_f128_min_exponent -16381

 #define __glibcpp_f128_min_exponent10 -4931

 #define __glibcpp_f128_max_exponent 16384

 #define __glibcpp_f128_max_exponent10 4932


 // bool-specific hooks:

 //     __glibcpp_bool_digits  __glibcpp_int_traps __glibcpp_long_traps


 #ifndef __glibcpp_bool_digits

 #define __glibcpp_bool_digits 1

 #endif


 // char.


 #define __glibcpp_plain_char_traps true

 #define __glibcpp_signed_char_traps true

 #define __glibcpp_unsigned_char_traps true

 #ifndef __glibcpp_char_is_modulo

 #define __glibcpp_char_is_modulo true

 #endif

 #ifndef __glibcpp_signed_char_is_modulo

 #define __glibcpp_signed_char_is_modulo true

 #endif

 #if __glibcpp_char_bits == 8

 #define __glibcpp_signed_char_min __glibcpp_s8_min

 #define __glibcpp_signed_char_max __glibcpp_s8_max

 #define __glibcpp_signed_char_digits __glibcpp_s8_digits

 #define __glibcpp_signed_char_digits10 __glibcpp_s8_digits10

 #define __glibcpp_unsigned_char_min __glibcpp_u8_min

 #define __glibcpp_unsigned_char_max __glibcpp_u8_max

 #define __glibcpp_unsigned_char_digits __glibcpp_u8_digits

 #define __glibcpp_unsigned_char_digits10 __glibcpp_u8_digits10

 #elif __glibcpp_char_bits == 16

 #define __glibcpp_signed_char_min __glibcpp_s16_min

 #define __glibcpp_signed_char_max __glibcpp_s16_max

 #define __glibcpp_signed_char_digits __glibcpp_s16_digits

 #define __glibcpp_signed_char_digits10 __glibcpp_s16_digits10

 #define __glibcpp_unsigned_char_min __glibcpp_u16_min

 #define __glibcpp_unsigned_char_max __glibcpp_u16_max

 #define __glibcpp_unsigned_char_digits __glibcpp_u16_digits

 #define __glibcpp_unsigned_char_digits10 __glibcpp_u16_digits10

 #elif __glibcpp_char_bits == 32

 #define __glibcpp_signed_char_min (signed char)__glibcpp_s32_min

 #define __glibcpp_signed_char_max (signed char)__glibcpp_s32_max

 #define __glibcpp_signed_char_digits __glibcpp_s32_digits

 #define __glibcpp_signed_char_digits10 __glibcpp_s32_digits10

 #define __glibcpp_unsigned_char_min (unsigned char)__glibcpp_u32_min

 #define __glibcpp_unsigned_char_max (unsigned char)__glibcpp_u32_max

 #define __glibcpp_unsigned_char_digits __glibcpp_u32_digits

 #define __glibcpp_unsigned_char_digits10 __glibcpp_u32_digits10

 #elif __glibcpp_char_bits == 64

 #define __glibcpp_signed_char_min (signed char)__glibcpp_s64_min

 #define __glibcpp_signed_char_max (signed char)__glibcpp_s64_max

 #define __glibcpp_signed_char_digits __glibcpp_s64_digits

 #define __glibcpp_signed_char_digits10 __glibcpp_s64_digits10

 #define __glibcpp_unsigned_char_min (unsigned char)__glibcpp_u64_min

 #define __glibcpp_unsigned_char_max (unsigned char)__glibcpp_u64_max

 #define __glibcpp_unsigned_char_digits __glibcpp_u64_digits

 #define __glibcpp_unsigned_char_digits10 __glibcpp_u64_digits10

 #else

 // You must define these macros in the configuration file.

 #endif


 #if __glibcpp_plain_char_is_signed

 #define __glibcpp_char_min (char)__glibcpp_signed_char_min

 #define __glibcpp_char_max (char)__glibcpp_signed_char_max

 #define __glibcpp_char_digits __glibcpp_signed_char_digits

 #define __glibcpp_char_digits10 __glibcpp_signed_char_digits10

 #else

 #define __glibcpp_char_min (char)__glibcpp_unsigned_char_min

 #define __glibcpp_char_max (char)__glibcpp_unsigned_char_max

 #define __glibcpp_char_digits __glibcpp_unsigned_char_digits

 #define __glibcpp_char_digits10 __glibcpp_unsigned_char_digits10

 #endif


 // short


 #define __glibcpp_signed_short_traps true

 #define __glibcpp_unsigned_short_traps true

 #ifndef __glibcpp_signed_short_is_modulo

 #define __glibcpp_signed_short_is_modulo true

 #endif

 #if __glibcpp_short_bits == 8

 #define __glibcpp_signed_short_min __glibcpp_s8_min

 #define __glibcpp_signed_short_max __glibcpp_s8_max

 #define __glibcpp_signed_short_digits __glibcpp_s8_digits

 #define __glibcpp_signed_short_digits10 __glibcpp_s8_digits10

 #define __glibcpp_unsigned_short_min __glibcpp_u8_min

 #define __glibcpp_unsigned_short_max __glibcpp_u8_max

 #define __glibcpp_unsigned_short_digits __glibcpp_u8_digits

 #define __glibcpp_unsigned_short_digits10 __glibcpp_u8_digits10

 #elif __glibcpp_short_bits == 16

 #define __glibcpp_signed_short_min __glibcpp_s16_min

 #define __glibcpp_signed_short_max __glibcpp_s16_max

 #define __glibcpp_signed_short_digits __glibcpp_s16_digits

 #define __glibcpp_signed_short_digits10 __glibcpp_s16_digits10

 #define __glibcpp_unsigned_short_min __glibcpp_u16_min

 #define __glibcpp_unsigned_short_max __glibcpp_u16_max

 #define __glibcpp_unsigned_short_digits __glibcpp_u16_digits

 #define __glibcpp_unsigned_short_digits10 __glibcpp_u16_digits10

 #elif __glibcpp_short_bits == 32

 #define __glibcpp_signed_short_min (short)__glibcpp_s32_min

 #define __glibcpp_signed_short_max (short)__glibcpp_s32_max

 #define __glibcpp_signed_short_digits __glibcpp_s32_digits

 #define __glibcpp_signed_short_digits10 __glibcpp_s32_digits10

 #define __glibcpp_unsigned_short_min (unsigned short)__glibcpp_u32_min

 #define __glibcpp_unsigned_short_max (unsigned short)__glibcpp_u32_max

 #define __glibcpp_unsigned_short_digits __glibcpp_u32_digits

 #define __glibcpp_unsigned_short_digits10 __glibcpp_u32_digits10

 #elif __glibcpp_short_bits == 64

 #define __glibcpp_signed_short_min (short)__glibcpp_s64_min

 #define __glibcpp_signed_short_max (short)__glibcpp_s64_max

 #define __glibcpp_signed_short_digits __glibcpp_s64_digits

 #define __glibcpp_signed_short_digits10 __glibcpp_s64_digits10

 #define __glibcpp_unsigned_short_min (unsigned short)__glibcpp_u64_min

 #define __glibcpp_unsigned_short_max (unsigned short)__glibcpp_u64_max

 #define __glibcpp_unsigned_short_digits __glibcpp_u64_digits

 #define __glibcpp_unsigned_short_digits10 __glibcpp_u64_digits10

 #else

 // You must define these macros in the configuration file.

 #endif


 // int


 #define __glibcpp_signed_int_traps true

 #define __glibcpp_unsigned_int_traps true

 #ifndef __glibcpp_signed_int_is_modulo

 #define __glibcpp_signed_int_is_modulo true

 #endif

 #if __glibcpp_int_bits == 8

 #define __glibcpp_signed_int_min __glibcpp_s8_min

 #define __glibcpp_signed_int_max __glibcpp_s8_max

 #define __glibcpp_signed_int_digits __glibcpp_s8_digits

 #define __glibcpp_signed_int_digits10 __glibcpp_s8_digits10

 #define __glibcpp_unsigned_int_min __glibcpp_u8_min

 #define __glibcpp_unsigned_int_max __glibcpp_u8_max

 #define __glibcpp_unsigned_int_digits __glibcpp_u8_digits

 #define __glibcpp_unsigned_int_digits10 __glibcpp_u8_digits10

 #elif __glibcpp_int_bits == 16

 #define __glibcpp_signed_int_min __glibcpp_s16_min

 #define __glibcpp_signed_int_max __glibcpp_s16_max

 #define __glibcpp_signed_int_digits __glibcpp_s16_digits

 #define __glibcpp_signed_int_digits10 __glibcpp_s16_digits10

 #define __glibcpp_unsigned_int_min __glibcpp_u16_min

 #define __glibcpp_unsigned_int_max __glibcpp_u16_max

 #define __glibcpp_unsigned_int_digits __glibcpp_u16_digits

 #define __glibcpp_unsigned_int_digits10 __glibcpp_u16_digits10

 #elif __glibcpp_int_bits == 32

 #define __glibcpp_signed_int_min (int)__glibcpp_s32_min

 #define __glibcpp_signed_int_max (int)__glibcpp_s32_max

 #define __glibcpp_signed_int_digits __glibcpp_s32_digits

 #define __glibcpp_signed_int_digits10 __glibcpp_s32_digits10

 #define __glibcpp_unsigned_int_min (unsigned)__glibcpp_u32_min

 #define __glibcpp_unsigned_int_max (unsigned)__glibcpp_u32_max

 #define __glibcpp_unsigned_int_digits __glibcpp_u32_digits

 #define __glibcpp_unsigned_int_digits10 __glibcpp_u32_digits10

 #elif __glibcpp_int_bits == 64

 #define __glibcpp_signed_int_min (int)__glibcpp_s64_min

 #define __glibcpp_signed_int_max (int)__glibcpp_s64_max

 #define __glibcpp_signed_int_digits __glibcpp_s64_digits

 #define __glibcpp_signed_int_digits10 __glibcpp_s64_digits10

 #define __glibcpp_unsigned_int_min (unsigned)__glibcpp_u64_min

 #define __glibcpp_unsigned_int_max (unsigned)__glibcpp_u64_max

 #define __glibcpp_unsigned_int_digits __glibcpp_u64_digits

 #define __glibcpp_unsigned_int_digits10 __glibcpp_u64_digits10

 #else

 // You must define these macros in the configuration file.

 #endif


 // long


 #define __glibcpp_signed_long_traps true

 #define __glibcpp_unsigned_long_traps true

 #ifndef __glibcpp_signed_long_is_modulo

 #define __glibcpp_signed_long_is_modulo true

 #endif

 #if __glibcpp_long_bits == 8

 #define __glibcpp_signed_long_min __glibcpp_s8_min

 #define __glibcpp_signed_long_max __glibcpp_s8_max

 #define __glibcpp_signed_long_digits __glibcpp_s8_digits

 #define __glibcpp_signed_long_digits10 __glibcpp_s8_digits10

 #define __glibcpp_unsigned_long_min __glibcpp_u8_min

 #define __glibcpp_unsigned_long_max __glibcpp_u8_max

 #define __glibcpp_unsigned_long_digits __glibcpp_u8_digits

 #define __glibcpp_unsigned_long_digits10 __glibcpp_u8_digits10

 #elif __glibcpp_long_bits == 16

 #define __glibcpp_signed_long_min __glibcpp_s16_min

 #define __glibcpp_signed_long_max __glibcpp_s16_max

 #define __glibcpp_signed_long_digits __glibcpp_s16_digits

 #define __glibcpp_signed_long_digits10 __glibcpp_s16_digits10

 #define __glibcpp_unsigned_long_min __glibcpp_u16_min

 #define __glibcpp_unsigned_long_max __glibcpp_u16_max

 #define __glibcpp_unsigned_long_digits __glibcpp_u16_digits

 #define __glibcpp_unsigned_long_digits10 __glibcpp_u16_digits10

 #elif __glibcpp_long_bits == 32

 #define __glibcpp_signed_long_min __glibcpp_s32_min

 #define __glibcpp_signed_long_max __glibcpp_s32_max

 #define __glibcpp_signed_long_digits __glibcpp_s32_digits

 #define __glibcpp_signed_long_digits10 __glibcpp_s32_digits10

 #define __glibcpp_unsigned_long_min __glibcpp_u32_min

 #define __glibcpp_unsigned_long_max __glibcpp_u32_max

 #define __glibcpp_unsigned_long_digits __glibcpp_u32_digits

 #define __glibcpp_unsigned_long_digits10 __glibcpp_u32_digits10

 #elif __glibcpp_long_bits == 64

 #define __glibcpp_signed_long_min (long)__glibcpp_s64_min

 #define __glibcpp_signed_long_max (long)__glibcpp_s64_max

 #define __glibcpp_signed_long_digits __glibcpp_s64_digits

 #define __glibcpp_signed_long_digits10 __glibcpp_s64_digits10

 #define __glibcpp_unsigned_long_min (unsigned long)__glibcpp_u64_min

 #define __glibcpp_unsigned_long_max (unsigned long)__glibcpp_u64_max

 #define __glibcpp_unsigned_long_digits __glibcpp_u64_digits

 #define __glibcpp_unsigned_long_digits10 __glibcpp_u64_digits10

 #else

 // You must define these macros in the configuration file.

 #endif


 // long long


 #define __glibcpp_signed_long_long_traps true

 #define __glibcpp_signed_long_long_traps true

 #ifndef __glibcpp_signed_long_long_is_modulo

 #define __glibcpp_signed_long_long_is_modulo true

 #endif

 #if __glibcpp_long_long_bits == 8

 #define __glibcpp_signed_long_long_min __glibcpp_s8_min

 #define __glibcpp_signed_long_long_max __glibcpp_s8_max

 #define __glibcpp_signed_long_long_digits __glibcpp_s8_digits

 #define __glibcpp_signed_long_long_digits10 __glibcpp_s8_digits10

 #define __glibcpp_unsigned_long_long_min __glibcpp_u8_min

 #define __glibcpp_unsigned_long_long_max __glibcpp_u8_max

 #define __glibcpp_unsigned_long_long_digits __glibcpp_u8_digits

 #define __glibcpp_unsigned_long_long_digits10 __glibcpp_u8_digits10

 #elif __glibcpp_long_long_bits == 16

 #define __glibcpp_signed_long_long_min __glibcpp_s16_min

 #define __glibcpp_signed_long_long_max __glibcpp_s16_max

 #define __glibcpp_signed_long_long_digits __glibcpp_s16_digits

 #define __glibcpp_signed_long_long_digits10 __glibcpp_s16_digits10

 #define __glibcpp_unsigned_long_long_min __glibcpp_u16_min

 #define __glibcpp_unsigned_long_long_max __glibcpp_u16_max

 #define __glibcpp_unsigned_long_long_digits __glibcpp_u16_digits

 #define __glibcpp_unsigned_long_long_digits10 __glibcpp_u16_digits10

 #elif __glibcpp_long_long_bits == 32

 #define __glibcpp_signed_long_long_min __glibcpp_s32_min

 #define __glibcpp_signed_long_long_max __glibcpp_s32_max

 #define __glibcpp_signed_long_long_digits __glibcpp_s32_digits

 #define __glibcpp_signed_long_long_digits10 __glibcpp_s32_digits10

 #define __glibcpp_unsigned_long_long_min __glibcpp_u32_min

 #define __glibcpp_unsigned_long_long_max __glibcpp_u32_max

 #define __glibcpp_unsigned_long_long_digits __glibcpp_u32_digits

 #define __glibcpp_unsigned_long_long_digits10 __glibcpp_u32_digits10

 #elif __glibcpp_long_long_bits == 64

 #define __glibcpp_signed_long_long_min __glibcpp_s64_min

 #define __glibcpp_signed_long_long_max __glibcpp_s64_max

 #define __glibcpp_signed_long_long_digits __glibcpp_s64_digits

 #define __glibcpp_signed_long_long_digits10 __glibcpp_s64_digits10

 #define __glibcpp_signed_long_long_traps true

 #define __glibcpp_unsigned_long_long_min __glibcpp_u64_min

 #define __glibcpp_unsigned_long_long_max __glibcpp_u64_max

 #define __glibcpp_unsigned_long_long_digits __glibcpp_u64_digits

 #define __glibcpp_unsigned_long_long_digits10 __glibcpp_u64_digits10

 #define __glibcpp_unsigned_long_long_traps true

 #else

 // You must define these macros in the configuration file.

 #endif


 // wchar_t


 #define __glibcpp_wchar_t_traps true

 #ifndef __glibcpp_wchar_t_is_modulo

 #define __glibcpp_wchar_t_is_modulo true

 #endif

 #if __glibcpp_wchar_t_is_signed

 #if __glibcpp_wchar_t_bits == 8

 #define __glibcpp_wchar_t_min __glibcpp_s8_min

 #define __glibcpp_wchar_t_max __glibcpp_s8_max

 #define __glibcpp_wchar_t_digits __glibcpp_s8_digits

 #define __glibcpp_wchar_t_digits10 __glibcpp_s8_digits10

 #elif __glibcpp_wchar_t_bits == 16

 #define __glibcpp_wchar_t_min __glibcpp_s16_min

 #define __glibcpp_wchar_t_max __glibcpp_s16_max

 #define __glibcpp_wchar_t_digits __glibcpp_s16_digits

 #define __glibcpp_wchar_t_digits10 __glibcpp_s16_digits10

 #elif __glibcpp_wchar_t_bits == 32

 #define __glibcpp_wchar_t_min (wchar_t)__glibcpp_s32_min

 #define __glibcpp_wchar_t_max (wchar_t)__glibcpp_s32_max

 #define __glibcpp_wchar_t_digits __glibcpp_s32_digits

 #define __glibcpp_wchar_t_digits10 __glibcpp_s32_digits10

 #elif __glibcpp_wchar_t_bits == 64

 #define __glibcpp_wchar_t_min (wchar_t)__glibcpp_s64_min

 #define __glibcpp_wchar_t_max (wchar_t)__glibcpp_s64_max

 #define __glibcpp_wchar_t_digits __glibcpp_s64_digits

 #define __glibcpp_wchar_t_digits10 __glibcpp_s64_digits10

 #else

 // You must define these macros in the configuration file.

 #endif

 #else

 #if __glibcpp_wchar_t_bits == 8

 #define __glibcpp_wchar_t_min __glibcpp_u8_min

 #define __glibcpp_wchar_t_max __glibcpp_u8_max

 #define __glibcpp_wchar_t_digits __glibcpp_u8_digits

 #define __glibcpp_wchar_t_digits10 __glibcpp_u8_digits10

 #elif __glibcpp_wchar_t_bits == 16

 #define __glibcpp_wchar_t_min __glibcpp_u16_min

 #define __glibcpp_wchar_t_max __glibcpp_u16_max

 #define __glibcpp_wchar_t_digits __glibcpp_u16_digits

 #define __glibcpp_wchar_t_digits10 __glibcpp_u16_digits10

 #elif __glibcpp_wchar_t_bits == 32

 #define __glibcpp_wchar_t_min (wchar_t)__glibcpp_u32_min

 #define __glibcpp_wchar_t_max (wchar_t)__glibcpp_u32_max

 #define __glibcpp_wchar_t_digits __glibcpp_u32_digits

 #define __glibcpp_wchar_t_digits10 __glibcpp_u32_digits10

 #elif __glibcpp_wchar_t_bits == 64

 #define __glibcpp_wchar_t_min (wchar_t)__glibcpp_u64_min

 #define __glibcpp_wchar_t_max (wchar_t)__glibcpp_u64_max

 #define __glibcpp_wchar_t_digits __glibcpp_u64_digits

 #define __glibcpp_wchar_t_digits10 __glibcpp_u64_digits10

 #else

 // You must define these macros in the configuration file.

 #endif

 #endif


 // float

 //


 #if __glibcpp_float_bits == 32

 #define __glibcpp_float_min __glibcpp_f32_min

 #define __glibcpp_float_max __glibcpp_f32_max

 #define __glibcpp_float_digits __glibcpp_f32_digits

 #define __glibcpp_float_digits10 __glibcpp_f32_digits10

 #define __glibcpp_float_radix __glibcpp_f32_radix

 #define __glibcpp_float_epsilon __glibcpp_f32_epsilon

 #define __glibcpp_float_round_error __glibcpp_f32_round_error

 #define __glibcpp_float_min_exponent __glibcpp_f32_min_exponent

 #define __glibcpp_float_min_exponent10 __glibcpp_f32_min_exponent10

 #define __glibcpp_float_max_exponent __glibcpp_f32_max_exponent

 #define __glibcpp_float_max_exponent10 __glibcpp_f32_max_exponent10

 #elif __glibcpp_float_bits == 64

 #define __glibcpp_float_min __glibcpp_f64_min

 #define __glibcpp_float_max __glibcpp_f64_max

 #define __glibcpp_float_digits __glibcpp_f64_digits

 #define __glibcpp_float_digits10 __glibcpp_f64_digits10

 #define __glibcpp_float_radix __glibcpp_f64_radix

 #define __glibcpp_float_epsilon __glibcpp_f64_epsilon

 #define __glibcpp_float_round_error __glibcpp_f64_round_error

 #define __glibcpp_float_min_exponent __glibcpp_f64_min_exponent

 #define __glibcpp_float_min_exponent10 __glibcpp_f64_min_exponent10

 #define __glibcpp_float_max_exponent __glibcpp_f64_max_exponent

 #define __glibcpp_float_max_exponent10 __glibcpp_f64_max_exponent10

 #elif __glibcpp_float_bits == 80

 #define __glibcpp_float_min __glibcpp_f80_min

 #define __glibcpp_float_max __glibcpp_f80_max

 #define __glibcpp_float_digits __glibcpp_f80_digits

 #define __glibcpp_float_digits10 __glibcpp_f80_digits10

 #define __glibcpp_float_radix __glibcpp_f80_radix

 #define __glibcpp_float_epsilon __glibcpp_f80_epsilon

 #define __glibcpp_float_round_error __glibcpp_f80_round_error

 #define __glibcpp_float_min_exponent __glibcpp_f80_min_exponent

 #define __glibcpp_float_min_exponent10 __glibcpp_f80_min_exponent10

 #define __glibcpp_float_max_exponent __glibcpp_f80_max_exponent

 #define __glibcpp_float_max_exponent10 __glibcpp_f80_max_exponent10

 #else

 // You must define these macros in the configuration file.

 #endif


 // FIXME: These are just stubs and inkorrect


 #ifndef __glibcpp_float_has_infinity

 #define __glibcpp_float_has_infinity false

 #endif


 #ifndef __glibcpp_float_has_quiet_NaN

 #define __glibcpp_float_has_quiet_NaN false

 #endif


 #ifndef __glibcpp_float_has_signaling_NaN

 #define __glibcpp_float_has_signaling_NaN false

 #endif


 #ifndef __glibcpp_float_has_denorm

 #define __glibcpp_float_has_denorm denorm_absent

 #endif


 #ifndef __glibcpp_float_has_denorm_loss

 #define __glibcpp_float_has_denorm_loss false

 #endif


 #ifndef __glibcpp_float_infinity

 #define __glibcpp_float_infinity 0.0F

 #endif


 #ifndef __glibcpp_float_quiet_NaN

 #define __glibcpp_float_quiet_NaN 0.0F

 #endif


 #ifndef __glibcpp_float_signaling_NaN

 #define __glibcpp_float_signaling_NaN 0.0F

 #endif


 #ifndef __glibcpp_float_denorm_min

 #define __glibcpp_float_denorm_min 0.0F

 #endif


 #ifndef __glibcpp_float_is_iec559

 #define __glibcpp_float_is_iec559 false

 #endif


 #ifndef __glibcpp_float_is_bounded

 #define __glibcpp_float_is_bounded true

 #endif


 #ifndef __glibcpp_float_is_modulo

 #define __glibcpp_float_is_modulo false

 #endif


 #ifndef __glibcpp_float_traps

 #define __glibcpp_float_traps false

 #endif


 #ifndef __glibcpp_float_tinyness_before

 #define __glibcpp_float_tinyness_before false

 #endif


 #ifndef __glibcpp_float_round_style

 #define __glibcpp_float_round_style round_toward_zero

 #endif


 // double


 #if __glibcpp_double_bits == 32

 #define __glibcpp_double_min __glibcpp_f32_min

 #define __glibcpp_double_max __glibcpp_f32_max

 #define __glibcpp_double_digits __glibcpp_f32_digits

 #define __glibcpp_double_digits10 __glibcpp_f32_digits10

 #define __glibcpp_double_radix __glibcpp_f32_radix

 #define __glibcpp_double_epsilon __glibcpp_f32_epsilon

 #define __glibcpp_double_round_error __glibcpp_f32_round_error

 #define __glibcpp_double_min_exponent __glibcpp_f32_min_exponent

 #define __glibcpp_double_min_exponent10 __glibcpp_f32_min_exponent10

 #define __glibcpp_double_max_exponent __glibcpp_f32_max_exponent

 #define __glibcpp_double_max_exponent10 __glibcpp_f32_max_exponent10

 #elif __glibcpp_double_bits == 64

 #define __glibcpp_double_min __glibcpp_f64_min

 #define __glibcpp_double_max __glibcpp_f64_max

 #define __glibcpp_double_digits __glibcpp_f64_digits

 #define __glibcpp_double_digits10 __glibcpp_f64_digits10

 #define __glibcpp_double_radix __glibcpp_f64_radix

 #define __glibcpp_double_epsilon __glibcpp_f64_epsilon

 #define __glibcpp_double_round_error __glibcpp_f64_round_error

 #define __glibcpp_double_min_exponent __glibcpp_f64_min_exponent

 #define __glibcpp_double_min_exponent10 __glibcpp_f64_min_exponent10

 #define __glibcpp_double_max_exponent __glibcpp_f64_max_exponent

 #define __glibcpp_double_max_exponent10 __glibcpp_f64_max_exponent10

 #elif __glibcpp_double_bits == 80

 #define __glibcpp_double_min __glibcpp_f80_min

 #define __glibcpp_double_max __glibcpp_f80_max

 #define __glibcpp_double_digits __glibcpp_f80_digits

 #define __glibcpp_double_digits10 __glibcpp_f80_digits10

 #define __glibcpp_double_radix __glibcpp_f80_radix

 #define __glibcpp_double_epsilon __glibcpp_f80_epsilon

 #define __glibcpp_double_round_error __glibcpp_f80_round_error

 #define __glibcpp_double_min_exponent __glibcpp_f80_min_exponent

 #define __glibcpp_double_min_exponent10 __glibcpp_f80_min_exponent10

 #define __glibcpp_double_max_exponent __glibcpp_f80_max_exponent

 #define __glibcpp_double_max_exponent10 __glibcpp_f80_max_exponent10

 #else

 // You must define these macros in the configuration file.

 #endif


 // FIXME: These are just stubs and inkorrect


 #ifndef __glibcpp_double_has_infinity

 #define __glibcpp_double_has_infinity false

 #endif


 #ifndef __glibcpp_double_has_quiet_NaN

 #define __glibcpp_double_has_quiet_NaN false

 #endif


 #ifndef __glibcpp_double_has_signaling_NaN

 #define __glibcpp_double_has_signaling_NaN false

 #endif


 #ifndef __glibcpp_double_has_denorm

 #define __glibcpp_double_has_denorm denorm_absent

 #endif


 #ifndef __glibcpp_double_has_denorm_loss

 #define __glibcpp_double_has_denorm_loss false

 #endif


 #ifndef __glibcpp_double_infinity

 #define __glibcpp_double_infinity 0.0

 #endif


 #ifndef __glibcpp_double_quiet_NaN

 #define __glibcpp_double_quiet_NaN 0.0

 #endif


 #ifndef __glibcpp_double_signaling_NaN

 #define __glibcpp_double_signaling_NaN 0.0

 #endif


 #ifndef __glibcpp_double_denorm_min

 #define __glibcpp_double_denorm_min 0.0

 #endif


 #ifndef __glibcpp_double_is_iec559

 #define __glibcpp_double_is_iec559 false

 #endif


 #ifndef __glibcpp_double_is_bounded

 #define __glibcpp_double_is_bounded true

 #endif


 #ifndef __glibcpp_double_is_modulo

 #define __glibcpp_double_is_modulo false

 #endif


 #ifndef __glibcpp_double_traps

 #define __glibcpp_double_traps false

 #endif


 #ifndef __glibcpp_double_tinyness_before

 #define __glibcpp_double_tinyness_before false

 #endif


 #ifndef __glibcpp_double_round_style

 #define __glibcpp_double_round_style round_toward_zero

 #endif


 // long double


 #if __glibcpp_long_double_bits == 32

 #define __glibcpp_long_double_min __glibcpp_f32_min

 #define __glibcpp_long_double_max __glibcpp_f32_max

 #define __glibcpp_long_double_digits __glibcpp_f32_digits

 #define __glibcpp_long_double_digits10 __glibcpp_f32_digits10

 #define __glibcpp_long_double_radix __glibcpp_f32_radix

 #define __glibcpp_long_double_epsilon __glibcpp_f32_epsilon

 #define __glibcpp_long_double_round_error __glibcpp_f32_round_error

 #define __glibcpp_long_double_min_exponent __glibcpp_f32_min_exponent

 #define __glibcpp_long_double_min_exponent10 __glibcpp_f32_min_exponent10

 #define __glibcpp_long_double_max_exponent __glibcpp_f32_max_exponent

 #define __glibcpp_long_double_max_exponent10 __glibcpp_f32_max_exponent10

 #elif __glibcpp_long_double_bits == 64

 #define __glibcpp_long_double_min __glibcpp_f64_min

 #define __glibcpp_long_double_max __glibcpp_f64_max

 #define __glibcpp_long_double_digits __glibcpp_f64_digits

 #define __glibcpp_long_double_digits10 __glibcpp_f64_digits10

 #define __glibcpp_long_double_radix __glibcpp_f64_radix

 #define __glibcpp_long_double_epsilon __glibcpp_f64_epsilon

 #define __glibcpp_long_double_round_error __glibcpp_f64_round_error

 #define __glibcpp_long_double_min_exponent __glibcpp_f64_min_exponent

 #define __glibcpp_long_double_min_exponent10 __glibcpp_f64_min_exponent10

 #define __glibcpp_long_double_max_exponent __glibcpp_f64_max_exponent

 #define __glibcpp_long_double_max_exponent10 __glibcpp_f64_max_exponent10

 #elif __glibcpp_long_double_bits == 80

 #define __glibcpp_long_double_min __glibcpp_f80_min

 #define __glibcpp_long_double_max __glibcpp_f80_max

 #define __glibcpp_long_double_digits __glibcpp_f80_digits

 #define __glibcpp_long_double_digits10 __glibcpp_f80_digits10

 #define __glibcpp_long_double_radix __glibcpp_f80_radix

 #define __glibcpp_long_double_epsilon __glibcpp_f80_epsilon

 #define __glibcpp_long_double_round_error __glibcpp_f80_round_error

 #define __glibcpp_long_double_min_exponent __glibcpp_f80_min_exponent

 #define __glibcpp_long_double_min_exponent10 __glibcpp_f80_min_exponent10

 #define __glibcpp_long_double_max_exponent __glibcpp_f80_max_exponent

 #define __glibcpp_long_double_max_exponent10 __glibcpp_f80_max_exponent10

 #elif __glibcpp_long_double_bits == 96

 #define __glibcpp_long_double_min __glibcpp_f96_min

 #define __glibcpp_long_double_max __glibcpp_f96_max

 #define __glibcpp_long_double_digits __glibcpp_f96_digits

 #define __glibcpp_long_double_digits10 __glibcpp_f96_digits10

 #define __glibcpp_long_double_radix __glibcpp_f96_radix

 #define __glibcpp_long_double_epsilon __glibcpp_f96_epsilon

 #define __glibcpp_long_double_round_error __glibcpp_f96_round_error

 #define __glibcpp_long_double_min_exponent __glibcpp_f96_min_exponent

 #define __glibcpp_long_double_min_exponent10 __glibcpp_f96_min_exponent10

 #define __glibcpp_long_double_max_exponent __glibcpp_f96_max_exponent

 #define __glibcpp_long_double_max_exponent10 __glibcpp_f96_max_exponent10

 #elif __glibcpp_long_double_bits == 128

 #define __glibcpp_long_double_min __glibcpp_f128_min

 #define __glibcpp_long_double_max __glibcpp_f128_max

 #define __glibcpp_long_double_digits __glibcpp_f128_digits

 #define __glibcpp_long_double_digits10 __glibcpp_f128_digits10

 #define __glibcpp_long_double_radix __glibcpp_f128_radix

 #define __glibcpp_long_double_epsilon __glibcpp_f128_epsilon

 #define __glibcpp_long_double_round_error __glibcpp_f128_round_error

 #define __glibcpp_long_double_min_exponent __glibcpp_f128_min_exponent

 #define __glibcpp_long_double_min_exponent10 __glibcpp_f128_min_exponent10

 #define __glibcpp_long_double_max_exponent __glibcpp_f128_max_exponent

 #define __glibcpp_long_double_max_exponent10 __glibcpp_f128_max_exponent10

 #else

 // You must define these macros in the configuration file.

 #endif


 // FIXME: These are just stubs and inkorrect


 #ifndef __glibcpp_long_double_has_infinity

 #define __glibcpp_long_double_has_infinity false

 #endif


 #ifndef __glibcpp_long_double_has_quiet_NaN

 #define __glibcpp_long_double_has_quiet_NaN false

 #endif


 #ifndef __glibcpp_long_double_has_signaling_NaN

 #define __glibcpp_long_double_has_signaling_NaN false

 #endif


 #ifndef __glibcpp_long_double_has_denorm

 #define __glibcpp_long_double_has_denorm denorm_absent

 #endif


 #ifndef __glibcpp_long_double_has_denorm_loss

 #define __glibcpp_long_double_has_denorm_loss false

 #endif


 #ifndef __glibcpp_long_double_infinity

 #define __glibcpp_long_double_infinity 0.0L

 #endif


 #ifndef __glibcpp_long_double_quiet_NaN

 #define __glibcpp_long_double_quiet_NaN 0.0L

 #endif


 #ifndef __glibcpp_long_double_signaling_NaN

 #define __glibcpp_long_double_signaling_NaN 0.0L

 #endif


 #ifndef __glibcpp_long_double_denorm_min

 #define __glibcpp_long_double_denorm_min 0.0L

 #endif


 #ifndef __glibcpp_long_double_is_iec559

 #define __glibcpp_long_double_is_iec559 false

 #endif


 #ifndef __glibcpp_long_double_is_bounded

 #define __glibcpp_long_double_is_bounded true

 #endif


 #ifndef __glibcpp_long_double_is_modulo

 #define __glibcpp_long_double_is_modulo false

 #endif


 #ifndef __glibcpp_long_double_traps

 #define __glibcpp_long_double_traps false

 #endif


 #ifndef __glibcpp_long_double_tinyness_before

 #define __glibcpp_long_double_tinyness_before false

 #endif


 #ifndef __glibcpp_long_double_round_style

 #define __glibcpp_long_double_round_style round_toward_zero

 #endif


 namespace std

 {

   enum float_round_style

   {

     round_indeterminate       = -1,

     round_toward_zero         = 0,

     round_to_nearest          = 1,

     round_toward_infinity     = 2,

     round_toward_neg_infinity = 3

   };


   enum float_denorm_style

   {

     denorm_indeterminate = -1,

     denorm_absent        = 0,

     denorm_present       = 1

   };


   //

   // The primary class traits

   //

   struct __numeric_limits_base

   {

     static const bool is_specialized = false;


     static const int digits = 0;

     static const int digits10 = 0;

     static const bool is_signed = false;

     static const bool is_integer = false;

     static const bool is_exact = false;

     static const int radix = 0;


     static const int min_exponent = 0;

     static const int min_exponent10 = 0;

     static const int max_exponent = 0;

     static const int max_exponent10 = 0;


     static const bool has_infinity = false;

     static const bool has_quiet_NaN = false;

     static const bool has_signaling_NaN = false;

     static const float_denorm_style has_denorm = denorm_absent;

     static const bool has_denorm_loss = false;


     static const bool is_iec559 = false;

     static const bool is_bounded = false;

     static const bool is_modulo = false;


     static const bool traps = false;

     static const bool tinyness_before = false;

     static const float_round_style round_style = round_toward_zero;

   };


   template<typename _Tp>

     struct numeric_limits : public __numeric_limits_base

     {

       static _Tp min() throw() { return static_cast<_Tp>(0); }

       static _Tp max() throw() { return static_cast<_Tp>(0); }

       static _Tp epsilon() throw() { return static_cast<_Tp>(0); }

       static _Tp round_error() throw() { return static_cast<_Tp>(0); }

       static _Tp infinity() throw()  { return static_cast<_Tp>(0); }

       static _Tp quiet_NaN() throw() { return static_cast<_Tp>(0); }

       static _Tp signaling_NaN() throw() { return static_cast<_Tp>(0); }

       static _Tp denorm_min() throw() { return static_cast<_Tp>(0); }

     };


   // Now there follow 15 explicit specializations.  Yes, 15.  Make sure

   // you get the count right.

   template<>

     struct numeric_limits<bool>

     {

       static const bool is_specialized = true;


       static bool min() throw()

       { return false; }


       static bool max() throw()

       { return true; }


       static const int digits = __glibcpp_bool_digits;

       static const int digits10 = 0;

       static const bool is_signed = false;

       static const bool is_integer = true;

       static const bool is_exact = true;

       static const int radix = 2;

       static bool epsilon() throw()

       { return false; }

       static bool round_error() throw()

       { return false; }


       static const int min_exponent = 0;

       static const int min_exponent10 = 0;

       static const int max_exponent = 0;

       static const int max_exponent10 = 0;


       static const bool has_infinity = false;

       static const bool has_quiet_NaN = false;

       static const bool has_signaling_NaN = false;

       static const float_denorm_style has_denorm = denorm_absent;

       static const bool has_denorm_loss = false;


       static bool infinity() throw()

       { return false; }

       static bool quiet_NaN() throw()

       { return false; }

       static bool signaling_NaN() throw()

       { return false; }

       static bool denorm_min() throw()

       { return false; }


       static const bool is_iec559 = false;

       static const bool is_bounded = true;

       static const bool is_modulo = false;


       // It is not clear what it means for a boolean type to trap.

       // This is a DR on the LWG issue list.  Here, I use integer

       // promotion semantics.

       static const bool traps = __glibcpp_signed_int_traps

                || __glibcpp_signed_long_traps;

       static const bool tinyness_before = false;

       static const float_round_style round_style = round_toward_zero;

     };


 #undef __glibcpp_bool_digits


   template<>

     struct numeric_limits<char>

     {

       static const bool is_specialized = true;


       static char min() throw()

       { return __glibcpp_char_min; }

       static char max() throw()

       { return __glibcpp_char_max; }


       static const int digits = __glibcpp_char_digits;

       static const int digits10 = __glibcpp_char_digits10;

       static const bool is_signed = __glibcpp_plain_char_is_signed;

       static const bool is_integer = true;

       static const bool is_exact = true;

       static const int radix = 2;

       static char epsilon() throw()

       { return char(); }

       static char round_error() throw()

       { return char(); }


       static const int min_exponent = 0;

       static const int min_exponent10 = 0;

       static const int max_exponent = 0;

       static const int max_exponent10 = 0;


       static const bool has_infinity = false;

       static const bool has_quiet_NaN = false;

       static const bool has_signaling_NaN = false;

       static const float_denorm_style has_denorm = denorm_absent;

       static const bool has_denorm_loss = false;


       static char infinity() throw()

       { return char(); }

       static char quiet_NaN() throw()

       { return char(); }

       static char signaling_NaN() throw()

       { return char(); }

       static char denorm_min() throw()

       { return static_cast<char>(0); }


       static const bool is_iec559 = false;

       static const bool is_bounded = true;

       static const bool is_modulo = __glibcpp_char_is_modulo;


       static const bool traps = __glibcpp_char_traps;

       static const bool tinyness_before = false;

       static const float_round_style round_style = round_toward_zero;

     };


 #undef __glibcpp_char_min

 #undef __glibcpp_char_max

 #undef __glibcpp_char_digits

 #undef __glibcpp_char_digits10

 #undef __glibcpp_char_is_signed

 #undef __glibcpp_char_is_modulo

 #undef __glibcpp_char_traps


   template<>

     struct numeric_limits<signed char>

     {

       static const bool is_specialized = true;


       static signed char min() throw()

       { return __glibcpp_signed_char_min; }

       static signed char max() throw()

       { return __glibcpp_signed_char_max; }


       static const int digits = __glibcpp_signed_char_digits;

       static const int digits10 = __glibcpp_signed_char_digits10;

       static const bool is_signed = true;

       static const bool is_integer = true;

       static const bool is_exact = true;

       static const int radix = 2;

       static signed char epsilon() throw()

       { return 0; }

       static signed char round_error() throw()

       { return 0; }


       static const int min_exponent = 0;

       static const int min_exponent10 = 0;

       static const int max_exponent = 0;

       static const int max_exponent10 = 0;


       static const bool has_infinity = false;

       static const bool has_quiet_NaN = false;

       static const bool has_signaling_NaN = false;

       static const float_denorm_style has_denorm = denorm_absent;

       static const bool has_denorm_loss = false;


       static signed char infinity() throw()

       { return static_cast<signed char>(0); }

       static signed char quiet_NaN() throw()

       { return static_cast<signed char>(0); }

       static signed char signaling_NaN() throw()

       { return static_cast<signed char>(0); }

       static signed char denorm_min() throw()

       { return static_cast<signed char>(0); }


       static const bool is_iec559 = false;

       static const bool is_bounded = true;

       static const bool is_modulo = __glibcpp_signed_char_is_modulo;


       static const bool traps = __glibcpp_signed_char_traps;

       static const bool tinyness_before = false;

       static const float_round_style round_style = round_toward_zero;

     };


 #undef __glibcpp_signed_char_min

 #undef __glibcpp_signed_char_max

 #undef __glibcpp_signed_char_digits

 #undef __glibcpp_signed_char_digits10

 #undef __glibcpp_signed_char_is_modulo

 #undef __glibcpp_signed_char_traps


   template<>

     struct numeric_limits<unsigned char>

     {

       static const bool is_specialized = true;


       static unsigned char min() throw()

       { return 0; }

       static unsigned char max() throw()

       { return __glibcpp_unsigned_char_max; }


       static const int digits = __glibcpp_unsigned_char_digits;

       static const int digits10 = __glibcpp_unsigned_char_digits10;

       static const bool is_signed = false;

       static const bool is_integer = true;

       static const bool is_exact = true;

       static const int radix = 2;

       static unsigned char epsilon() throw()

       { return 0; }

       static unsigned char round_error() throw()

       { return 0; }


       static const int min_exponent = 0;

       static const int min_exponent10 = 0;

       static const int max_exponent = 0;

       static const int max_exponent10 = 0;


       static const bool has_infinity = false;

       static const bool has_quiet_NaN = false;

       static const bool has_signaling_NaN = false;

       static const float_denorm_style has_denorm = denorm_absent;

       static const bool has_denorm_loss = false;


       static unsigned char infinity() throw()

       { return static_cast<unsigned char>(0); }

       static unsigned char quiet_NaN() throw()

       { return static_cast<unsigned char>(0); }

       static unsigned char signaling_NaN() throw()

       { return static_cast<unsigned char>(0); }

       static unsigned char denorm_min() throw()

       { return static_cast<unsigned char>(0); }


       static const bool is_iec559 = false;

       static const bool is_bounded = true;

       static const bool is_modulo = true;


       static const bool traps = __glibcpp_unsigned_char_traps;

       static const bool tinyness_before = false;

       static const float_round_style round_style = round_toward_zero;

     };


 #undef __glibcpp_unsigned_char_max

 #undef __glibcpp_unsigned_char_digits

 #undef __glibcpp_unsigned_char_digits10

 #undef __glibcpp_unsigned_char_traps


   template<>

     struct numeric_limits<wchar_t>

     {

       static const bool is_specialized = true;


       static wchar_t min() throw()

       { return __glibcpp_wchar_t_min; }

       static wchar_t max() throw()

       { return __glibcpp_wchar_t_max; }


       static const int digits = __glibcpp_wchar_t_digits;

       static const int digits10 = __glibcpp_wchar_t_digits10;

       static const bool is_signed = __glibcpp_wchar_t_is_signed;

       static const bool is_integer = true;

       static const bool is_exact = true;

       static const int radix = 2;

       static wchar_t epsilon() throw()

       { return 0; }

       static wchar_t round_error() throw()

       { return 0; }


       static const int min_exponent = 0;

       static const int min_exponent10 = 0;

       static const int max_exponent = 0;

       static const int max_exponent10 = 0;


       static const bool has_infinity = false;

       static const bool has_quiet_NaN = false;

       static const bool has_signaling_NaN = false;

       static const float_denorm_style has_denorm = denorm_absent;

       static const bool has_denorm_loss = false;


       static wchar_t infinity() throw()

       { return wchar_t(); }

       static wchar_t quiet_NaN() throw()

       { return wchar_t(); }

       static wchar_t signaling_NaN() throw()

       { return wchar_t(); }

       static wchar_t denorm_min() throw()

       { return wchar_t(); }


       static const bool is_iec559 = false;

       static const bool is_bounded = true;

       static const bool is_modulo = __glibcpp_wchar_t_is_modulo;


       static const bool traps = __glibcpp_wchar_t_traps;

       static const bool tinyness_before = false;

       static const float_round_style round_style = round_toward_zero;

     };


 #undef __glibcpp_wchar_t_min

 #undef __glibcpp_wchar_t_max

 #undef __glibcpp_wchar_t_digits

 #undef __glibcpp_wchar_t_digits10

 #undef __glibcpp_wchar_t_is_signed

 #undef __glibcpp_wchar_t_is_modulo

 #undef __glibcpp_wchar_t_traps


   template<>

     struct numeric_limits<short>

     {

       static const bool is_specialized = true;


       static short min() throw()

       { return __glibcpp_signed_short_min; }

       static short max() throw()

       { return __glibcpp_signed_short_max; }


       static const int digits = __glibcpp_signed_short_digits;

       static const int digits10 = __glibcpp_signed_short_digits10;

       static const bool is_signed = true;

       static const bool is_integer = true;

       static const bool is_exact = true;

       static const int radix = 2;

       static short epsilon() throw()

       { return 0; }

       static short round_error() throw()

       { return 0; }


       static const int min_exponent = 0;

       static const int min_exponent10 = 0;

       static const int max_exponent = 0;

       static const int max_exponent10 = 0;


       static const bool has_infinity = false;

       static const bool has_quiet_NaN = false;

       static const bool has_signaling_NaN = false;

       static const float_denorm_style has_denorm = denorm_absent;

       static const bool has_denorm_loss = false;


       static short infinity() throw()

       { return short(); }

       static short quiet_NaN() throw()

       { return short(); }

       static short signaling_NaN() throw()

       { return short(); }

       static short denorm_min() throw()

       { return short(); }


       static const bool is_iec559 = true;

       static const bool is_bounded = true;

       static const bool is_modulo = __glibcpp_signed_short_is_modulo;


       static const bool traps = __glibcpp_signed_short_traps;

       static const bool tinyness_before = false;

       static const float_round_style round_style = round_toward_zero;

     };


 #undef __glibcpp_signed_short_min

 #undef __glibcpp_signed_short_max

 #undef __glibcpp_signed_short_digits

 #undef __glibcpp_signed_short_digits10

 #undef __glibcpp_signed_short_is_modulo

 #undef __glibcpp_signed_short_traps


   template<>

     struct numeric_limits<unsigned short>

     {

       static const bool is_specialized = true;


       static unsigned short min() throw()

       { return 0; }

       static unsigned short max() throw()

       { return __glibcpp_unsigned_short_max; }


       static const int digits = __glibcpp_unsigned_short_digits;

       static const int digits10 = __glibcpp_unsigned_short_digits10;

       static const bool is_signed = false;

       static const bool is_integer = true;

       static const bool is_exact = true;

       static const int radix = 2;

       static unsigned short epsilon() throw()

       { return 0; }

       static unsigned short round_error() throw()

       { return 0; }


       static const int min_exponent = 0;

       static const int min_exponent10 = 0;

       static const int max_exponent = 0;

       static const int max_exponent10 = 0;


       static const bool has_infinity = false;

       static const bool has_quiet_NaN = false;

       static const bool has_signaling_NaN = false;

       static const float_denorm_style has_denorm = denorm_absent;

       static const bool has_denorm_loss = false;


       static unsigned short infinity() throw()

       { return static_cast<unsigned short>(0); }

       static unsigned short quiet_NaN() throw()

       { return static_cast<unsigned short>(0); }

       static unsigned short signaling_NaN() throw()

       { return static_cast<unsigned short>(0); }

       static unsigned short denorm_min() throw()

       { return static_cast<unsigned short>(0); }


       static const bool is_iec559 = true;

       static const bool is_bounded = true;

       static const bool is_modulo = true;


       static const bool traps = __glibcpp_unsigned_short_traps;

       static const bool tinyness_before = false;

       static const float_round_style round_style = round_toward_zero;

     };


 #undef __glibcpp_unsigned_short_max

 #undef __glibcpp_unsigned_short_digits

 #undef __glibcpp_unsigned_short_digits10

 #undef __glibcpp_unsigned_short_traps


   template<>

     struct numeric_limits<int>

     {

       static const bool is_specialized = true;


       static int min() throw()

       { return __glibcpp_signed_int_min; }

       static int max() throw()

       { return __glibcpp_signed_int_max; }


       static const int digits = __glibcpp_signed_int_digits;

       static const int digits10 = __glibcpp_signed_int_digits10;

       static const bool is_signed = true;

       static const bool is_integer = true;

       static const bool is_exact = true;

       static const int radix = 2;

       static int epsilon() throw()

       { return 0; }

       static int round_error() throw()

       { return 0; }


       static const int min_exponent = 0;

       static const int min_exponent10 = 0;

       static const int max_exponent = 0;

       static const int max_exponent10 = 0;


       static const bool has_infinity = false;

       static const bool has_quiet_NaN = false;

       static const bool has_signaling_NaN = false;

       static const float_denorm_style has_denorm = denorm_absent;

       static const bool has_denorm_loss = false;


       static int infinity() throw()

       { return static_cast<int>(0); }

       static int quiet_NaN() throw()

       { return static_cast<int>(0); }

       static int signaling_NaN() throw()

       { return static_cast<int>(0); }

       static int denorm_min() throw()

       { return static_cast<int>(0); }


       static const bool is_iec559 = true;

       static const bool is_bounded = true;

       static const bool is_modulo = __glibcpp_signed_int_is_modulo;


       static const bool traps = __glibcpp_signed_int_traps;

       static const bool tinyness_before = false;

       static const float_round_style round_style = round_toward_zero;

     };


 #undef __glibcpp_signed_int_min

 #undef __glibcpp_signed_int_max

 #undef __glibcpp_signed_int_digits

 #undef __glibcpp_signed_int_digits10

 #undef __glibcpp_signed_int_is_modulo

 #undef __glibcpp_signed_int_traps


   template<>

     struct numeric_limits<unsigned int>

     {

       static const bool is_specialized = true;


       static unsigned int min() throw()

       { return 0; }

           static unsigned int max() throw()

       { return __glibcpp_unsigned_int_max; }


       static const int digits = __glibcpp_unsigned_int_digits;

       static const int digits10 = __glibcpp_unsigned_int_digits10;

       static const bool is_signed = false;

       static const bool is_integer = true;

       static const bool is_exact = true;

       static const int radix = 2;

       static unsigned int epsilon() throw()

       { return 0; }

       static unsigned int round_error() throw()

       { return 0; }


       static const int min_exponent = 0;

       static const int min_exponent10 = 0;

       static const int max_exponent = 0;

       static const int max_exponent10 = 0;


       static const bool has_infinity = false;

       static const bool has_quiet_NaN = false;

       static const bool has_signaling_NaN = false;

       static const float_denorm_style has_denorm = denorm_absent;

       static const bool has_denorm_loss = false;


       static unsigned int infinity() throw()

       { return static_cast<unsigned int>(0); }

       static unsigned int quiet_NaN() throw()

       { return static_cast<unsigned int>(0); }

       static unsigned int signaling_NaN() throw()

       { return static_cast<unsigned int>(0); }

       static unsigned int denorm_min() throw()

       { return static_cast<unsigned int>(0); }


       static const bool is_iec559 = true;

       static const bool is_bounded = true;

       static const bool is_modulo = true;


       static const bool traps = __glibcpp_unsigned_int_traps;

       static const bool tinyness_before = false;

       static const float_round_style round_style = round_toward_zero;

     };


 #undef __glibcpp_unsigned_int_max

 #undef __glibcpp_unsigned_int_digits

 #undef __glibcpp_unsigned_int_digits10

 #undef __glibcpp_unsigned_int_traps


   template<>

     struct numeric_limits<long>

     {

       static const bool is_specialized = true;


       static long min() throw()

       { return __glibcpp_signed_long_min; }

       static long max() throw()

       { return __glibcpp_signed_long_max; }


       static const int digits = __glibcpp_signed_long_digits;

       static const int digits10 = __glibcpp_signed_long_digits10;

       static const bool is_signed = true;

       static const bool is_integer = true;

       static const bool is_exact = true;

       static const int radix = 2;

       static long epsilon() throw()

       { return 0; }

       static long round_error() throw()

       { return 0; }


       static const int min_exponent = 0;

       static const int min_exponent10 = 0;

       static const int max_exponent = 0;

       static const int max_exponent10 = 0;


       static const bool has_infinity = false;

       static const bool has_quiet_NaN = false;

       static const bool has_signaling_NaN = false;

       static const float_denorm_style has_denorm = denorm_absent;

       static const bool has_denorm_loss = false;


       static long infinity() throw()

       { return static_cast<long>(0); }

       static long quiet_NaN() throw()

       { return static_cast<long>(0); }

       static long signaling_NaN() throw()

       { return static_cast<long>(0); }

       static long denorm_min() throw()

       { return static_cast<long>(0); }


       static const bool is_iec559 = true;

       static const bool is_bounded = true;

       static const bool is_modulo = __glibcpp_signed_long_is_modulo;


       static const bool traps = __glibcpp_signed_long_traps;

       static const bool tinyness_before = false;

       static const float_round_style round_style = round_toward_zero;

     };


 #undef __glibcpp_signed_long_min

 #undef __glibcpp_signed_long_max

 #undef __glibcpp_signed_long_digits

 #undef __glibcpp_signed_long_digits10

 #undef __glibcpp_signed_long_is_modulo

 #undef __glibcpp_signed_long_traps


   template<>

     struct numeric_limits<unsigned long>

     {

       static const bool is_specialized = true;


       static unsigned long min() throw()

       { return 0; }

       static unsigned long max() throw()

       { return __glibcpp_unsigned_long_max; }


       static const int digits = __glibcpp_unsigned_long_digits;

       static const int digits10 = __glibcpp_unsigned_long_digits10;

       static const bool is_signed = false;

       static const bool is_integer = true;

       static const bool is_exact = true;

       static const int radix = 2;

       static unsigned long epsilon() throw()

       { return 0; }

       static unsigned long round_error() throw()

       { return 0; }


       static const int min_exponent = 0;

       static const int min_exponent10 = 0;

       static const int max_exponent = 0;

       static const int max_exponent10 = 0;


       static const bool has_infinity = false;

       static const bool has_quiet_NaN = false;

       static const bool has_signaling_NaN = false;

       static const float_denorm_style has_denorm = denorm_absent;

       static const bool has_denorm_loss = false;


       static unsigned long infinity() throw()

       { return static_cast<unsigned long>(0); }

       static unsigned long quiet_NaN() throw()

       { return static_cast<unsigned long>(0); }

       static unsigned long signaling_NaN() throw()

       { return static_cast<unsigned long>(0); }

       static unsigned long denorm_min() throw()

       { return static_cast<unsigned long>(0); }


       static const bool is_iec559 = true;

       static const bool is_bounded = true;

       static const bool is_modulo = true;


       static const bool traps = __glibcpp_unsigned_long_traps;

       static const bool tinyness_before = false;

       static const float_round_style round_style = round_toward_zero;

     };


 #undef __glibcpp_unsigned_long_max

 #undef __glibcpp_unsigned_long_digits

 #undef __glibcpp_unsigned_long_digits10

 #undef __glibcpp_unsigned_long_traps


   template<>

     struct numeric_limits<long long>

     {

       static const bool is_specialized = true;


       static long long min() throw()

       { return __glibcpp_signed_long_long_min; }

       static long long max() throw()

       { return __glibcpp_signed_long_long_max; }


       static const int digits = __glibcpp_signed_long_long_digits;

       static const int digits10 = __glibcpp_signed_long_long_digits10;

       static const bool is_signed = true;

       static const bool is_integer = true;

       static const bool is_exact = true;

       static const int radix = 2;

       static long long epsilon() throw()

       { return 0; }

       static long long round_error() throw()

       { return 0; }


       static const int min_exponent = 0;

       static const int min_exponent10 = 0;

       static const int max_exponent = 0;

       static const int max_exponent10 = 0;


       static const bool has_infinity = false;

       static const bool has_quiet_NaN = false;

       static const bool has_signaling_NaN = false;

       static const float_denorm_style has_denorm = denorm_absent;

       static const bool has_denorm_loss = false;


       static long long infinity() throw()

       { return static_cast<long long>(0); }

       static long long quiet_NaN() throw()

       { return static_cast<long long>(0); }

       static long long signaling_NaN() throw()

       { return static_cast<long long>(0); }

       static long long denorm_min() throw()

       { return static_cast<long long>(0); }


       static const bool is_iec559 = true;

       static const bool is_bounded = true;

       static const bool is_modulo = __glibcpp_signed_long_long_is_modulo;


       static const bool traps = __glibcpp_signed_long_long_traps;

       static const bool tinyness_before = false;

       static const float_round_style round_style = round_toward_zero;

     };


 #undef __glibcpp_signed_long_long_min

 #undef __glibcpp_signed_long_long_max

 #undef __glibcpp_signed_long_long_digits

 #undef __glibcpp_signed_long_long_digits10

 #undef __glibcpp_signed_long_long_is_modulo

 #undef __glibcpp_signed_long_long_traps


   template<>

     struct numeric_limits<unsigned long long>

     {

       static const bool is_specialized = true;


       static unsigned long long min() throw()

       { return 0; }

       static unsigned long long max() throw()

       { return __glibcpp_unsigned_long_long_max; }


       static const int digits = __glibcpp_unsigned_long_long_digits;

       static const int digits10 = __glibcpp_unsigned_long_long_digits10;

       static const bool is_signed = false;

       static const bool is_integer = true;

       static const bool is_exact = true;

       static const int radix = 2;

       static unsigned long long epsilon() throw()

       { return 0; }

       static unsigned long long round_error() throw()

       { return 0; }


       static const int min_exponent = 0;

       static const int min_exponent10 = 0;

       static const int max_exponent = 0;

       static const int max_exponent10 = 0;


       static const bool has_infinity = false;

       static const bool has_quiet_NaN = false;

       static const bool has_signaling_NaN = false;

       static const float_denorm_style has_denorm = denorm_absent;

       static const bool has_denorm_loss = false;


       static unsigned long long infinity() throw()

       { return static_cast<unsigned long long>(0); }

       static unsigned long long quiet_NaN() throw()

       { return static_cast<unsigned long long>(0); }

       static unsigned long long signaling_NaN() throw()

       { return static_cast<unsigned long long>(0); }

       static unsigned long long denorm_min() throw()

       { return static_cast<unsigned long long>(0); }


       static const bool is_iec559 = true;

       static const bool is_bounded = true;

       static const bool is_modulo = true;


       static const bool traps = true;

       static const bool tinyness_before = false;

       static const float_round_style round_style = round_toward_zero;

     };


 #undef __glibcpp_unsigned_long_long_max

 #undef __glibcpp_unsigned_long_long_digits

 #undef __glibcpp_unsigned_long_long_digits10

 #undef __glibcpp_unsigned_long_long_traps


   template<>

     struct numeric_limits<float>

     {

       static const bool is_specialized = true;


       static float min() throw()

       { return __glibcpp_float_min; }

       static float max() throw()

       { return __glibcpp_float_max; }


       static const int digits = __glibcpp_float_digits;

       static const int digits10 = __glibcpp_float_digits10;

       static const bool is_signed = true;

       static const bool is_integer = false;

       static const bool is_exact = false;

       static const int radix = __glibcpp_float_radix;

       static float epsilon() throw()

       { return __glibcpp_float_epsilon; }

       static float round_error() throw()

       { return __glibcpp_float_round_error; }


       static const int min_exponent = __glibcpp_float_min_exponent;

       static const int min_exponent10 = __glibcpp_float_min_exponent10;

       static const int max_exponent = __glibcpp_float_max_exponent;

       static const int max_exponent10 = __glibcpp_float_max_exponent10;


       static const bool has_infinity = __glibcpp_float_has_infinity;

       static const bool has_quiet_NaN = __glibcpp_float_has_quiet_NaN;

       static const bool has_signaling_NaN = __glibcpp_float_has_signaling_NaN;

       static const float_denorm_style has_denorm = __glibcpp_float_has_denorm;

       static const bool has_denorm_loss = __glibcpp_float_has_denorm_loss;


       static float infinity() throw()

       { return __glibcpp_float_infinity; }

       static float quiet_NaN() throw()

       { return __glibcpp_float_quiet_NaN; }

       static float signaling_NaN() throw()

       { return __glibcpp_float_signaling_NaN; }

       static float denorm_min() throw()

       { return __glibcpp_float_denorm_min; }


       static const bool is_iec559 = __glibcpp_float_is_iec559;

       static const bool is_bounded = __glibcpp_float_is_bounded;

       static const bool is_modulo = __glibcpp_float_is_modulo;


       static const bool traps = __glibcpp_float_traps;

       static const bool tinyness_before = __glibcpp_float_tinyness_before;

       static const float_round_style round_style = __glibcpp_float_round_style;

     };


 #undef __glibcpp_float_min

 #undef __glibcpp_float_max

 #undef __glibcpp_float_digits

 #undef __glibcpp_float_digits10

 #undef __glibcpp_float_radix

 #undef __glibcpp_float_round_error

 #undef __glibcpp_float_min_exponent

 #undef __glibcpp_float_min_exponent10

 #undef __glibcpp_float_max_exponent

 #undef __glibcpp_float_max_exponent10

 #undef __glibcpp_float_has_infinity

 #undef __glibcpp_float_has_quiet_NaN

 #undef __glibcpp_float_has_signaling_NaN

 #undef __glibcpp_float_has_denorm

 #undef __glibcpp_float_has_denorm_loss

 #undef __glibcpp_float_infinity

 #undef __glibcpp_float_quiet_NaN

 #undef __glibcpp_float_signaling_NaN

 #undef __glibcpp_float_denorm_min

 #undef __glibcpp_float_is_iec559

 #undef __glibcpp_float_is_bounded

 #undef __glibcpp_float_is_modulo

 #undef __glibcpp_float_traps

 #undef __glibcpp_float_tinyness_before

 #undef __glibcpp_float_round_style


   template<>

     struct numeric_limits<double>

     {

       static const bool is_specialized = true;


       static double min() throw()

       { return __glibcpp_double_min; }

       static double max() throw()

       { return __glibcpp_double_max; }


       static const int digits = __glibcpp_double_digits;

       static const int digits10 = __glibcpp_double_digits10;

       static const bool is_signed = true;

       static const bool is_integer = false;

       static const bool is_exact = false;

       static const int radix = __glibcpp_double_radix;

       static double epsilon() throw()

       { return __glibcpp_double_epsilon; }

       static double round_error() throw()

       { return __glibcpp_double_round_error; }


       static const int min_exponent = __glibcpp_double_min_exponent;

       static const int min_exponent10 = __glibcpp_double_min_exponent10;

       static const int max_exponent = __glibcpp_double_max_exponent;

       static const int max_exponent10 = __glibcpp_double_max_exponent10;


       static const bool has_infinity = __glibcpp_double_has_infinity;

       static const bool has_quiet_NaN = __glibcpp_double_has_quiet_NaN;

       static const bool has_signaling_NaN = __glibcpp_double_has_signaling_NaN;

       static const float_denorm_style has_denorm =

               __glibcpp_double_has_denorm;

       static const bool has_denorm_loss = __glibcpp_double_has_denorm_loss;


       static double infinity() throw()

       { return __glibcpp_double_infinity; }

       static double quiet_NaN() throw()

       { return __glibcpp_double_quiet_NaN; }

       static double signaling_NaN() throw()

       { return __glibcpp_double_signaling_NaN; }

       static double denorm_min() throw()

       { return __glibcpp_double_denorm_min; }


       static const bool is_iec559 = __glibcpp_double_is_iec559;

       static const bool is_bounded = __glibcpp_double_is_bounded;

       static const bool is_modulo = __glibcpp_double_is_modulo;


       static const bool traps = __glibcpp_double_traps;

       static const bool tinyness_before = __glibcpp_double_tinyness_before;

       static const float_round_style round_style =

               __glibcpp_double_round_style;

     };


 #undef __glibcpp_double_min

 #undef __glibcpp_double_max

 #undef __glibcpp_double_digits

 #undef __glibcpp_double_digits10

 #undef __glibcpp_double_radix

 #undef __glibcpp_double_round_error

 #undef __glibcpp_double_min_exponent

 #undef __glibcpp_double_min_exponent10

 #undef __glibcpp_double_max_exponent

 #undef __glibcpp_double_max_exponent10

 #undef __glibcpp_double_has_infinity

 #undef __glibcpp_double_has_quiet_NaN

 #undef __glibcpp_double_has_signaling_NaN

 #undef __glibcpp_double_has_denorm

 #undef __glibcpp_double_has_denorm_loss

 #undef __glibcpp_double_infinity

 #undef __glibcpp_double_quiet_NaN

 #undef __glibcpp_double_signaling_NaN

 #undef __glibcpp_double_denorm_min

 #undef __glibcpp_double_is_iec559

 #undef __glibcpp_double_is_bounded

 #undef __glibcpp_double_is_modulo

 #undef __glibcpp_double_traps

 #undef __glibcpp_double_tinyness_before

 #undef __glibcpp_double_round_style


   template<>

     struct numeric_limits<long double>

     {

       static const bool is_specialized = true;


       static long double min() throw()

       { return __glibcpp_long_double_min; }

       static long double max() throw()

       { return __glibcpp_long_double_max; }


       static const int digits = __glibcpp_long_double_digits;

       static const int digits10 = __glibcpp_long_double_digits10;

       static const bool is_signed = true;

       static const bool is_integer = false;

       static const bool is_exact = false;

       static const int radix = __glibcpp_long_double_radix;

       static long double epsilon() throw()

       { return __glibcpp_long_double_epsilon; }

       static long double round_error() throw()

       { return __glibcpp_long_double_round_error; }


       static const int min_exponent = __glibcpp_long_double_min_exponent;

       static const int min_exponent10 = __glibcpp_long_double_min_exponent10;

       static const int max_exponent = __glibcpp_long_double_max_exponent;

       static const int max_exponent10 = __glibcpp_long_double_max_exponent10;


       static const bool has_infinity = __glibcpp_long_double_has_infinity;

       static const bool has_quiet_NaN = __glibcpp_long_double_has_quiet_NaN;

       static const bool has_signaling_NaN =

                 __glibcpp_long_double_has_signaling_NaN;

       static const float_denorm_style has_denorm =

                 __glibcpp_long_double_has_denorm;

       static const bool has_denorm_loss =

                 __glibcpp_long_double_has_denorm_loss;


       static long double infinity() throw()

       { return __glibcpp_long_double_infinity; }

       static long double quiet_NaN() throw()

       { return __glibcpp_long_double_quiet_NaN; }

       static long double signaling_NaN() throw()

       { return __glibcpp_long_double_signaling_NaN; }

       static long double denorm_min() throw()

       { return __glibcpp_long_double_denorm_min; }


       static const bool is_iec559 = __glibcpp_long_double_is_iec559;

       static const bool is_bounded = __glibcpp_long_double_is_bounded;

       static const bool is_modulo = __glibcpp_long_double_is_modulo;


       static const bool traps = __glibcpp_long_double_traps;

       static const bool tinyness_before = __glibcpp_long_double_tinyness_before;

       static const float_round_style round_style =

         __glibcpp_long_double_round_style;

     };


 #undef __glibcpp_long_double_min

 #undef __glibcpp_long_double_max

 #undef __glibcpp_long_double_digits

 #undef __glibcpp_long_double_digits10

 #undef __glibcpp_long_double_radix

 #undef __glibcpp_long_double_round_error

 #undef __glibcpp_long_double_min_exponent

 #undef __glibcpp_long_double_min_exponent10

 #undef __glibcpp_long_double_max_exponent

 #undef __glibcpp_long_double_max_exponent10

 #undef __glibcpp_long_double_has_infinity

 #undef __glibcpp_long_double_has_quiet_NaN

 #undef __glibcpp_long_double_has_signaling_NaN

 #undef __glibcpp_long_double_has_denorm

 #undef __glibcpp_long_double_has_denorm_loss

 #undef __glibcpp_long_double_infinity

 #undef __glibcpp_long_double_quiet_NaN

 #undef __glibcpp_long_double_signaling_NaN

 #undef __glibcpp_long_double_denorm_min

 #undef __glibcpp_long_double_is_iec559

 #undef __glibcpp_long_double_is_bounded

 #undef __glibcpp_long_double_is_modulo

 #undef __glibcpp_long_double_traps

 #undef __glibcpp_long_double_tinyness_before

 #undef __glibcpp_long_double_round_style


 } // namespace std


 #endif // gcc < 3


 #endif // _CPP_NUMERIC_LIMITS

__glibcpp_long_double_round_style
#define __glibcpp_long_double_round_style
Definition: limits_gcc3.h:932

__glibcpp_double_quiet_NaN
#define __glibcpp_double_quiet_NaN
Definition: limits_gcc3.h:772

__glibcpp_float_has_infinity
#define __glibcpp_float_has_infinity
Definition: limits_gcc3.h:644

__glibcpp_double_is_iec559
#define __glibcpp_double_is_iec559
Definition: limits_gcc3.h:784

__glibcpp_double_has_signaling_NaN
#define __glibcpp_double_has_signaling_NaN
Definition: limits_gcc3.h:756

__glibcpp_float_is_iec559
#define __glibcpp_float_is_iec559
Definition: limits_gcc3.h:680

__glibcpp_signed_long_long_min
#define __glibcpp_signed_long_long_min
Definition: limits_gcc3.h:528

__glibcpp_long_double_has_infinity
#define __glibcpp_long_double_has_infinity
Definition: limits_gcc3.h:876

__glibcpp_signed_char_is_modulo
#define __glibcpp_signed_char_is_modulo
Definition: limits_gcc3.h:298

__glibcpp_signed_char_min
#define __glibcpp_signed_char_min
Definition: limits_gcc3.h:301

__glibcpp_wchar_t_digits
#define __glibcpp_wchar_t_digits
Definition: limits_gcc3.h:586

__glibcpp_unsigned_long_long_digits
#define __glibcpp_unsigned_long_long_digits
Definition: limits_gcc3.h:535

__glibcpp_signed_long_long_digits
#define __glibcpp_signed_long_long_digits
Definition: limits_gcc3.h:530

__glibcpp_long_double_denorm_min
#define __glibcpp_long_double_denorm_min
Definition: limits_gcc3.h:908

__glibcpp_float_round_style
#define __glibcpp_float_round_style
Definition: limits_gcc3.h:700

__glibcpp_wchar_t_digits10
#define __glibcpp_wchar_t_digits10
Definition: limits_gcc3.h:587

__glibcpp_signed_long_min
#define __glibcpp_signed_long_min
Definition: limits_gcc3.h:472

__glibcpp_float_signaling_NaN
#define __glibcpp_float_signaling_NaN
Definition: limits_gcc3.h:672

__glibcpp_long_double_traps
#define __glibcpp_long_double_traps
Definition: limits_gcc3.h:924

__glibcpp_signed_short_traps
#define __glibcpp_signed_short_traps
Definition: limits_gcc3.h:354

__glibcpp_wchar_t_is_modulo
#define __glibcpp_wchar_t_is_modulo
Definition: limits_gcc3.h:546

__glibcpp_unsigned_short_max
#define __glibcpp_unsigned_short_max
Definition: limits_gcc3.h:374

__glibcpp_char_digits10
#define __glibcpp_char_digits10
Definition: limits_gcc3.h:349

__glibcpp_unsigned_int_digits10
#define __glibcpp_unsigned_int_digits10
Definition: limits_gcc3.h:432

__glibcpp_float_is_bounded
#define __glibcpp_float_is_bounded
Definition: limits_gcc3.h:684

__glibcpp_float_quiet_NaN
#define __glibcpp_float_quiet_NaN
Definition: limits_gcc3.h:668

__glibcpp_long_double_is_modulo
#define __glibcpp_long_double_is_modulo
Definition: limits_gcc3.h:920

__glibcpp_long_double_quiet_NaN
#define __glibcpp_long_double_quiet_NaN
Definition: limits_gcc3.h:900

__glibcpp_plain_char_is_signed
#define __glibcpp_plain_char_is_signed
Definition: limits_gcc3.h:138

__glibcpp_long_double_has_denorm
#define __glibcpp_long_double_has_denorm
Definition: limits_gcc3.h:888

__glibcpp_unsigned_short_digits
#define __glibcpp_unsigned_short_digits
Definition: limits_gcc3.h:375

__glibcpp_float_is_modulo
#define __glibcpp_float_is_modulo
Definition: limits_gcc3.h:688

__glibcpp_char_max
#define __glibcpp_char_max
Definition: limits_gcc3.h:347

__glibcpp_wchar_t_min
#define __glibcpp_wchar_t_min
Definition: limits_gcc3.h:584

__glibcpp_unsigned_long_digits
#define __glibcpp_unsigned_long_digits
Definition: limits_gcc3.h:478

__glibcpp_unsigned_long_long_digits10
#define __glibcpp_unsigned_long_long_digits10
Definition: limits_gcc3.h:536

__glibcpp_unsigned_long_digits10
#define __glibcpp_unsigned_long_digits10
Definition: limits_gcc3.h:479

__glibcpp_wchar_t_is_signed
#define __glibcpp_wchar_t_is_signed
Definition: limits_gcc3.h:153

__glibcpp_unsigned_char_traps
#define __glibcpp_unsigned_char_traps
Definition: limits_gcc3.h:293

__glibcpp_unsigned_int_digits
#define __glibcpp_unsigned_int_digits
Definition: limits_gcc3.h:431

std::float_round_style
float_round_style
Definition: limits_gcc3.h:939

std::round_toward_zero
@ round_toward_zero
Definition: limits_gcc3.h:941

std::round_toward_infinity
@ round_toward_infinity
Definition: limits_gcc3.h:943

std::round_to_nearest
@ round_to_nearest
Definition: limits_gcc3.h:942

std::round_toward_neg_infinity
@ round_toward_neg_infinity
Definition: limits_gcc3.h:944

std::round_indeterminate
@ round_indeterminate
Definition: limits_gcc3.h:940

__glibcpp_long_double_has_denorm_loss
#define __glibcpp_long_double_has_denorm_loss
Definition: limits_gcc3.h:892

__glibcpp_signed_char_digits10
#define __glibcpp_signed_char_digits10
Definition: limits_gcc3.h:304

__glibcpp_signed_short_digits10
#define __glibcpp_signed_short_digits10
Definition: limits_gcc3.h:372

__glibcpp_unsigned_long_long_max
#define __glibcpp_unsigned_long_long_max
Definition: limits_gcc3.h:534

std::float_denorm_style
float_denorm_style
Definition: limits_gcc3.h:948

std::denorm_present
@ denorm_present
Definition: limits_gcc3.h:951

std::denorm_indeterminate
@ denorm_indeterminate
Definition: limits_gcc3.h:949

std::denorm_absent
@ denorm_absent
Definition: limits_gcc3.h:950

__glibcpp_signed_int_is_modulo
#define __glibcpp_signed_int_is_modulo
Definition: limits_gcc3.h:404

__glibcpp_unsigned_int_max
#define __glibcpp_unsigned_int_max
Definition: limits_gcc3.h:430

__glibcpp_char_traps
#define __glibcpp_char_traps
Definition: limits_gcc3.h:169

__glibcpp_unsigned_char_digits
#define __glibcpp_unsigned_char_digits
Definition: limits_gcc3.h:307

__glibcpp_char_min
#define __glibcpp_char_min
Definition: limits_gcc3.h:346

__glibcpp_signed_long_long_digits10
#define __glibcpp_signed_long_long_digits10
Definition: limits_gcc3.h:531

__glibcpp_float_has_denorm
#define __glibcpp_float_has_denorm
Definition: limits_gcc3.h:656

__glibcpp_signed_int_max
#define __glibcpp_signed_int_max
Definition: limits_gcc3.h:426

__glibcpp_signed_long_digits10
#define __glibcpp_signed_long_digits10
Definition: limits_gcc3.h:475

__glibcpp_bool_digits
#define __glibcpp_bool_digits
Definition: limits_gcc3.h:286

__glibcpp_signed_char_traps
#define __glibcpp_signed_char_traps
Definition: limits_gcc3.h:292

__glibcpp_float_has_signaling_NaN
#define __glibcpp_float_has_signaling_NaN
Definition: limits_gcc3.h:652

__glibcpp_wchar_t_max
#define __glibcpp_wchar_t_max
Definition: limits_gcc3.h:585

__glibcpp_double_is_bounded
#define __glibcpp_double_is_bounded
Definition: limits_gcc3.h:788

__glibcpp_signed_int_traps
#define __glibcpp_signed_int_traps
Definition: limits_gcc3.h:401

__glibcpp_unsigned_char_max
#define __glibcpp_unsigned_char_max
Definition: limits_gcc3.h:306

__glibcpp_signed_int_digits
#define __glibcpp_signed_int_digits
Definition: limits_gcc3.h:427

__glibcpp_signed_long_long_is_modulo
#define __glibcpp_signed_long_long_is_modulo
Definition: limits_gcc3.h:498

__glibcpp_float_tinyness_before
#define __glibcpp_float_tinyness_before
Definition: limits_gcc3.h:696

__glibcpp_float_infinity
#define __glibcpp_float_infinity
Definition: limits_gcc3.h:664

__glibcpp_signed_long_is_modulo
#define __glibcpp_signed_long_is_modulo
Definition: limits_gcc3.h:451

__glibcpp_signed_long_digits
#define __glibcpp_signed_long_digits
Definition: limits_gcc3.h:474

__glibcpp_long_double_is_iec559
#define __glibcpp_long_double_is_iec559
Definition: limits_gcc3.h:912

__glibcpp_unsigned_int_traps
#define __glibcpp_unsigned_int_traps
Definition: limits_gcc3.h:402

__glibcpp_long_double_is_bounded
#define __glibcpp_long_double_is_bounded
Definition: limits_gcc3.h:916

__glibcpp_double_round_style
#define __glibcpp_double_round_style
Definition: limits_gcc3.h:804

__glibcpp_signed_char_digits
#define __glibcpp_signed_char_digits
Definition: limits_gcc3.h:303

__glibcpp_float_traps
#define __glibcpp_float_traps
Definition: limits_gcc3.h:692

__glibcpp_double_traps
#define __glibcpp_double_traps
Definition: limits_gcc3.h:796

__glibcpp_long_double_has_quiet_NaN
#define __glibcpp_long_double_has_quiet_NaN
Definition: limits_gcc3.h:880

__glibcpp_signed_long_traps
#define __glibcpp_signed_long_traps
Definition: limits_gcc3.h:448

__glibcpp_long_double_signaling_NaN
#define __glibcpp_long_double_signaling_NaN
Definition: limits_gcc3.h:904

__glibcpp_double_tinyness_before
#define __glibcpp_double_tinyness_before
Definition: limits_gcc3.h:800

__glibcpp_signed_short_min
#define __glibcpp_signed_short_min
Definition: limits_gcc3.h:369

__glibcpp_double_infinity
#define __glibcpp_double_infinity
Definition: limits_gcc3.h:768

__glibcpp_float_has_quiet_NaN
#define __glibcpp_float_has_quiet_NaN
Definition: limits_gcc3.h:648

__glibcpp_signed_int_digits10
#define __glibcpp_signed_int_digits10
Definition: limits_gcc3.h:428

__glibcpp_signed_long_long_max
#define __glibcpp_signed_long_long_max
Definition: limits_gcc3.h:529

__glibcpp_double_is_modulo
#define __glibcpp_double_is_modulo
Definition: limits_gcc3.h:792

__glibcpp_unsigned_short_traps
#define __glibcpp_unsigned_short_traps
Definition: limits_gcc3.h:355

__glibcpp_double_has_infinity
#define __glibcpp_double_has_infinity
Definition: limits_gcc3.h:748

__glibcpp_float_has_denorm_loss
#define __glibcpp_float_has_denorm_loss
Definition: limits_gcc3.h:660

__glibcpp_long_double_has_signaling_NaN
#define __glibcpp_long_double_has_signaling_NaN
Definition: limits_gcc3.h:884

__glibcpp_unsigned_long_max
#define __glibcpp_unsigned_long_max
Definition: limits_gcc3.h:477

__glibcpp_unsigned_char_digits10
#define __glibcpp_unsigned_char_digits10
Definition: limits_gcc3.h:308

__glibcpp_char_is_modulo
#define __glibcpp_char_is_modulo
Definition: limits_gcc3.h:295

__glibcpp_signed_short_digits
#define __glibcpp_signed_short_digits
Definition: limits_gcc3.h:371

__glibcpp_long_double_tinyness_before
#define __glibcpp_long_double_tinyness_before
Definition: limits_gcc3.h:928

__glibcpp_signed_short_max
#define __glibcpp_signed_short_max
Definition: limits_gcc3.h:370

__glibcpp_signed_char_max
#define __glibcpp_signed_char_max
Definition: limits_gcc3.h:302

__glibcpp_signed_short_is_modulo
#define __glibcpp_signed_short_is_modulo
Definition: limits_gcc3.h:357

__glibcpp_signed_long_max
#define __glibcpp_signed_long_max
Definition: limits_gcc3.h:473

__glibcpp_signed_long_long_traps
#define __glibcpp_signed_long_long_traps
Definition: limits_gcc3.h:532

__glibcpp_float_denorm_min
#define __glibcpp_float_denorm_min
Definition: limits_gcc3.h:676

__glibcpp_double_signaling_NaN
#define __glibcpp_double_signaling_NaN
Definition: limits_gcc3.h:776

__glibcpp_signed_int_min
#define __glibcpp_signed_int_min
Definition: limits_gcc3.h:425

__glibcpp_unsigned_short_digits10
#define __glibcpp_unsigned_short_digits10
Definition: limits_gcc3.h:376

__glibcpp_unsigned_long_traps
#define __glibcpp_unsigned_long_traps
Definition: limits_gcc3.h:449

__glibcpp_double_denorm_min
#define __glibcpp_double_denorm_min
Definition: limits_gcc3.h:780

__glibcpp_wchar_t_traps
#define __glibcpp_wchar_t_traps
Definition: limits_gcc3.h:544

__glibcpp_double_has_quiet_NaN
#define __glibcpp_double_has_quiet_NaN
Definition: limits_gcc3.h:752

__glibcpp_double_has_denorm_loss
#define __glibcpp_double_has_denorm_loss
Definition: limits_gcc3.h:764

__glibcpp_char_digits
#define __glibcpp_char_digits
Definition: limits_gcc3.h:348

__glibcpp_double_has_denorm
#define __glibcpp_double_has_denorm
Definition: limits_gcc3.h:760

__glibcpp_long_double_infinity
#define __glibcpp_long_double_infinity
Definition: limits_gcc3.h:896

std::__numeric_limits_base
Definition: limits_gcc3.h:958

std::__numeric_limits_base::is_modulo
static const bool is_modulo
Definition: limits_gcc3.h:981

std::__numeric_limits_base::is_integer
static const bool is_integer
Definition: limits_gcc3.h:964

std::__numeric_limits_base::digits
static const int digits
Definition: limits_gcc3.h:961

std::__numeric_limits_base::is_iec559
static const bool is_iec559
Definition: limits_gcc3.h:979

std::__numeric_limits_base::min_exponent
static const int min_exponent
Definition: limits_gcc3.h:968

std::__numeric_limits_base::is_exact
static const bool is_exact
Definition: limits_gcc3.h:965

std::__numeric_limits_base::traps
static const bool traps
Definition: limits_gcc3.h:983

std::__numeric_limits_base::max_exponent10
static const int max_exponent10
Definition: limits_gcc3.h:971

std::__numeric_limits_base::has_quiet_NaN
static const bool has_quiet_NaN
Definition: limits_gcc3.h:974

std::__numeric_limits_base::is_signed
static const bool is_signed
Definition: limits_gcc3.h:963

std::__numeric_limits_base::radix
static const int radix
Definition: limits_gcc3.h:966

std::__numeric_limits_base::tinyness_before
static const bool tinyness_before
Definition: limits_gcc3.h:984

std::__numeric_limits_base::min_exponent10
static const int min_exponent10
Definition: limits_gcc3.h:969

std::__numeric_limits_base::has_signaling_NaN
static const bool has_signaling_NaN
Definition: limits_gcc3.h:975

std::__numeric_limits_base::round_style
static const float_round_style round_style
Definition: limits_gcc3.h:985

std::__numeric_limits_base::max_exponent
static const int max_exponent
Definition: limits_gcc3.h:970

std::__numeric_limits_base::is_bounded
static const bool is_bounded
Definition: limits_gcc3.h:980

std::__numeric_limits_base::has_infinity
static const bool has_infinity
Definition: limits_gcc3.h:973

std::__numeric_limits_base::has_denorm_loss
static const bool has_denorm_loss
Definition: limits_gcc3.h:977

std::__numeric_limits_base::is_specialized
static const bool is_specialized
Definition: limits_gcc3.h:959

std::__numeric_limits_base::has_denorm
static const float_denorm_style has_denorm
Definition: limits_gcc3.h:976

std::__numeric_limits_base::digits10
static const int digits10
Definition: limits_gcc3.h:962

std::numeric_limits< bool >::round_error
static bool round_error()
Definition: limits_gcc3.h:1022

std::numeric_limits< bool >::max
static bool max()
Definition: limits_gcc3.h:1011

std::numeric_limits< bool >::denorm_min
static bool denorm_min()
Definition: limits_gcc3.h:1042

std::numeric_limits< bool >::min
static bool min()
Definition: limits_gcc3.h:1008

std::numeric_limits< bool >::signaling_NaN
static bool signaling_NaN()
Definition: limits_gcc3.h:1040

std::numeric_limits< bool >::quiet_NaN
static bool quiet_NaN()
Definition: limits_gcc3.h:1038

std::numeric_limits< bool >::epsilon
static bool epsilon()
Definition: limits_gcc3.h:1020

std::numeric_limits< bool >::infinity
static bool infinity()
Definition: limits_gcc3.h:1036

std::numeric_limits< char >::infinity
static char infinity()
Definition: limits_gcc3.h:1092

std::numeric_limits< char >::denorm_min
static char denorm_min()
Definition: limits_gcc3.h:1098

std::numeric_limits< char >::epsilon
static char epsilon()
Definition: limits_gcc3.h:1076

std::numeric_limits< char >::quiet_NaN
static char quiet_NaN()
Definition: limits_gcc3.h:1094

std::numeric_limits< char >::signaling_NaN
static char signaling_NaN()
Definition: limits_gcc3.h:1096

std::numeric_limits< char >::round_error
static char round_error()
Definition: limits_gcc3.h:1078

std::numeric_limits< char >::max
static char max()
Definition: limits_gcc3.h:1067

std::numeric_limits< char >::min
static char min()
Definition: limits_gcc3.h:1065

std::numeric_limits< double >::quiet_NaN
static double quiet_NaN()
Definition: limits_gcc3.h:1849

std::numeric_limits< double >::infinity
static double infinity()
Definition: limits_gcc3.h:1847

std::numeric_limits< double >::denorm_min
static double denorm_min()
Definition: limits_gcc3.h:1853

std::numeric_limits< double >::round_error
static double round_error()
Definition: limits_gcc3.h:1832

std::numeric_limits< double >::min
static double min()
Definition: limits_gcc3.h:1819

std::numeric_limits< double >::max
static double max()
Definition: limits_gcc3.h:1821

std::numeric_limits< double >::epsilon
static double epsilon()
Definition: limits_gcc3.h:1830

std::numeric_limits< double >::signaling_NaN
static double signaling_NaN()
Definition: limits_gcc3.h:1851

std::numeric_limits< float >::infinity
static float infinity()
Definition: limits_gcc3.h:1770

std::numeric_limits< float >::denorm_min
static float denorm_min()
Definition: limits_gcc3.h:1776

std::numeric_limits< float >::round_error
static float round_error()
Definition: limits_gcc3.h:1756

std::numeric_limits< float >::signaling_NaN
static float signaling_NaN()
Definition: limits_gcc3.h:1774

std::numeric_limits< float >::min
static float min()
Definition: limits_gcc3.h:1743

std::numeric_limits< float >::quiet_NaN
static float quiet_NaN()
Definition: limits_gcc3.h:1772

std::numeric_limits< float >::epsilon
static float epsilon()
Definition: limits_gcc3.h:1754

std::numeric_limits< float >::max
static float max()
Definition: limits_gcc3.h:1745

std::numeric_limits< int >::min
static int min()
Definition: limits_gcc3.h:1407

std::numeric_limits< int >::infinity
static int infinity()
Definition: limits_gcc3.h:1434

std::numeric_limits< int >::quiet_NaN
static int quiet_NaN()
Definition: limits_gcc3.h:1436

std::numeric_limits< int >::max
static int max()
Definition: limits_gcc3.h:1409

std::numeric_limits< int >::signaling_NaN
static int signaling_NaN()
Definition: limits_gcc3.h:1438

std::numeric_limits< int >::epsilon
static int epsilon()
Definition: limits_gcc3.h:1418

std::numeric_limits< int >::round_error
static int round_error()
Definition: limits_gcc3.h:1420

std::numeric_limits< int >::denorm_min
static int denorm_min()
Definition: limits_gcc3.h:1440

std::numeric_limits< long >::denorm_min
static long denorm_min()
Definition: limits_gcc3.h:1552

std::numeric_limits< long >::round_error
static long round_error()
Definition: limits_gcc3.h:1532

std::numeric_limits< long >::infinity
static long infinity()
Definition: limits_gcc3.h:1546

std::numeric_limits< long >::max
static long max()
Definition: limits_gcc3.h:1521

std::numeric_limits< long >::quiet_NaN
static long quiet_NaN()
Definition: limits_gcc3.h:1548

std::numeric_limits< long >::signaling_NaN
static long signaling_NaN()
Definition: limits_gcc3.h:1550

std::numeric_limits< long >::epsilon
static long epsilon()
Definition: limits_gcc3.h:1530

std::numeric_limits< long >::min
static long min()
Definition: limits_gcc3.h:1519

std::numeric_limits< long double >::max
static long double max()
Definition: limits_gcc3.h:1900

std::numeric_limits< long double >::signaling_NaN
static long double signaling_NaN()
Definition: limits_gcc3.h:1932

std::numeric_limits< long double >::quiet_NaN
static long double quiet_NaN()
Definition: limits_gcc3.h:1930

std::numeric_limits< long double >::round_error
static long double round_error()
Definition: limits_gcc3.h:1911

std::numeric_limits< long double >::epsilon
static long double epsilon()
Definition: limits_gcc3.h:1909

std::numeric_limits< long double >::min
static long double min()
Definition: limits_gcc3.h:1898

std::numeric_limits< long double >::denorm_min
static long double denorm_min()
Definition: limits_gcc3.h:1934

std::numeric_limits< long double >::infinity
static long double infinity()
Definition: limits_gcc3.h:1928

std::numeric_limits< long long >::round_error
static long long round_error()
Definition: limits_gcc3.h:1644

std::numeric_limits< long long >::infinity
static long long infinity()
Definition: limits_gcc3.h:1658

std::numeric_limits< long long >::min
static long long min()
Definition: limits_gcc3.h:1631

std::numeric_limits< long long >::denorm_min
static long long denorm_min()
Definition: limits_gcc3.h:1664

std::numeric_limits< long long >::max
static long long max()
Definition: limits_gcc3.h:1633

std::numeric_limits< long long >::signaling_NaN
static long long signaling_NaN()
Definition: limits_gcc3.h:1662

std::numeric_limits< long long >::quiet_NaN
static long long quiet_NaN()
Definition: limits_gcc3.h:1660

std::numeric_limits< long long >::epsilon
static long long epsilon()
Definition: limits_gcc3.h:1642

std::numeric_limits< short >::max
static short max()
Definition: limits_gcc3.h:1297

std::numeric_limits< short >::epsilon
static short epsilon()
Definition: limits_gcc3.h:1306

std::numeric_limits< short >::quiet_NaN
static short quiet_NaN()
Definition: limits_gcc3.h:1324

std::numeric_limits< short >::infinity
static short infinity()
Definition: limits_gcc3.h:1322

std::numeric_limits< short >::min
static short min()
Definition: limits_gcc3.h:1295

std::numeric_limits< short >::denorm_min
static short denorm_min()
Definition: limits_gcc3.h:1328

std::numeric_limits< short >::signaling_NaN
static short signaling_NaN()
Definition: limits_gcc3.h:1326

std::numeric_limits< short >::round_error
static short round_error()
Definition: limits_gcc3.h:1308

std::numeric_limits< signed char >::epsilon
static signed char epsilon()
Definition: limits_gcc3.h:1136

std::numeric_limits< signed char >::infinity
static signed char infinity()
Definition: limits_gcc3.h:1152

std::numeric_limits< signed char >::denorm_min
static signed char denorm_min()
Definition: limits_gcc3.h:1158

std::numeric_limits< signed char >::round_error
static signed char round_error()
Definition: limits_gcc3.h:1138

std::numeric_limits< signed char >::signaling_NaN
static signed char signaling_NaN()
Definition: limits_gcc3.h:1156

std::numeric_limits< signed char >::max
static signed char max()
Definition: limits_gcc3.h:1127

std::numeric_limits< signed char >::quiet_NaN
static signed char quiet_NaN()
Definition: limits_gcc3.h:1154

std::numeric_limits< signed char >::min
static signed char min()
Definition: limits_gcc3.h:1125

std::numeric_limits< unsigned char >::max
static unsigned char max()
Definition: limits_gcc3.h:1184

std::numeric_limits< unsigned char >::infinity
static unsigned char infinity()
Definition: limits_gcc3.h:1209

std::numeric_limits< unsigned char >::quiet_NaN
static unsigned char quiet_NaN()
Definition: limits_gcc3.h:1211

std::numeric_limits< unsigned char >::min
static unsigned char min()
Definition: limits_gcc3.h:1182

std::numeric_limits< unsigned char >::signaling_NaN
static unsigned char signaling_NaN()
Definition: limits_gcc3.h:1213

std::numeric_limits< unsigned char >::denorm_min
static unsigned char denorm_min()
Definition: limits_gcc3.h:1215

std::numeric_limits< unsigned char >::epsilon
static unsigned char epsilon()
Definition: limits_gcc3.h:1193

std::numeric_limits< unsigned char >::round_error
static unsigned char round_error()
Definition: limits_gcc3.h:1195

std::numeric_limits< unsigned int >::denorm_min
static unsigned int denorm_min()
Definition: limits_gcc3.h:1497

std::numeric_limits< unsigned int >::signaling_NaN
static unsigned int signaling_NaN()
Definition: limits_gcc3.h:1495

std::numeric_limits< unsigned int >::quiet_NaN
static unsigned int quiet_NaN()
Definition: limits_gcc3.h:1493

std::numeric_limits< unsigned int >::epsilon
static unsigned int epsilon()
Definition: limits_gcc3.h:1475

std::numeric_limits< unsigned int >::round_error
static unsigned int round_error()
Definition: limits_gcc3.h:1477

std::numeric_limits< unsigned int >::min
static unsigned int min()
Definition: limits_gcc3.h:1464

std::numeric_limits< unsigned int >::max
static unsigned int max()
Definition: limits_gcc3.h:1466

std::numeric_limits< unsigned int >::infinity
static unsigned int infinity()
Definition: limits_gcc3.h:1491

std::numeric_limits< unsigned long >::round_error
static unsigned long round_error()
Definition: limits_gcc3.h:1589

std::numeric_limits< unsigned long >::epsilon
static unsigned long epsilon()
Definition: limits_gcc3.h:1587

std::numeric_limits< unsigned long >::max
static unsigned long max()
Definition: limits_gcc3.h:1578

std::numeric_limits< unsigned long >::quiet_NaN
static unsigned long quiet_NaN()
Definition: limits_gcc3.h:1605

std::numeric_limits< unsigned long >::signaling_NaN
static unsigned long signaling_NaN()
Definition: limits_gcc3.h:1607

std::numeric_limits< unsigned long >::infinity
static unsigned long infinity()
Definition: limits_gcc3.h:1603

std::numeric_limits< unsigned long >::min
static unsigned long min()
Definition: limits_gcc3.h:1576

std::numeric_limits< unsigned long >::denorm_min
static unsigned long denorm_min()
Definition: limits_gcc3.h:1609

std::numeric_limits< unsigned long long >::infinity
static unsigned long long infinity()
Definition: limits_gcc3.h:1715

std::numeric_limits< unsigned long long >::quiet_NaN
static unsigned long long quiet_NaN()
Definition: limits_gcc3.h:1717

std::numeric_limits< unsigned long long >::round_error
static unsigned long long round_error()
Definition: limits_gcc3.h:1701

std::numeric_limits< unsigned long long >::max
static unsigned long long max()
Definition: limits_gcc3.h:1690

std::numeric_limits< unsigned long long >::epsilon
static unsigned long long epsilon()
Definition: limits_gcc3.h:1699

std::numeric_limits< unsigned long long >::denorm_min
static unsigned long long denorm_min()
Definition: limits_gcc3.h:1721

std::numeric_limits< unsigned long long >::signaling_NaN
static unsigned long long signaling_NaN()
Definition: limits_gcc3.h:1719

std::numeric_limits< unsigned long long >::min
static unsigned long long min()
Definition: limits_gcc3.h:1688

std::numeric_limits< unsigned short >::denorm_min
static unsigned short denorm_min()
Definition: limits_gcc3.h:1385

std::numeric_limits< unsigned short >::min
static unsigned short min()
Definition: limits_gcc3.h:1352

std::numeric_limits< unsigned short >::signaling_NaN
static unsigned short signaling_NaN()
Definition: limits_gcc3.h:1383

std::numeric_limits< unsigned short >::epsilon
static unsigned short epsilon()
Definition: limits_gcc3.h:1363

std::numeric_limits< unsigned short >::quiet_NaN
static unsigned short quiet_NaN()
Definition: limits_gcc3.h:1381

std::numeric_limits< unsigned short >::max
static unsigned short max()
Definition: limits_gcc3.h:1354

std::numeric_limits< unsigned short >::round_error
static unsigned short round_error()
Definition: limits_gcc3.h:1365

std::numeric_limits< unsigned short >::infinity
static unsigned short infinity()
Definition: limits_gcc3.h:1379

std::numeric_limits< wchar_t >::min
static wchar_t min()
Definition: limits_gcc3.h:1237

std::numeric_limits< wchar_t >::quiet_NaN
static wchar_t quiet_NaN()
Definition: limits_gcc3.h:1266

std::numeric_limits< wchar_t >::max
static wchar_t max()
Definition: limits_gcc3.h:1239

std::numeric_limits< wchar_t >::round_error
static wchar_t round_error()
Definition: limits_gcc3.h:1250

std::numeric_limits< wchar_t >::epsilon
static wchar_t epsilon()
Definition: limits_gcc3.h:1248

std::numeric_limits< wchar_t >::signaling_NaN
static wchar_t signaling_NaN()
Definition: limits_gcc3.h:1268

std::numeric_limits< wchar_t >::infinity
static wchar_t infinity()
Definition: limits_gcc3.h:1264

std::numeric_limits< wchar_t >::denorm_min
static wchar_t denorm_min()
Definition: limits_gcc3.h:1270

std::numeric_limits
Definition: limits_gcc3.h:990

std::numeric_limits::min
static _Tp min()
Definition: limits_gcc3.h:991

std::numeric_limits::round_error
static _Tp round_error()
Definition: limits_gcc3.h:994

std::numeric_limits::signaling_NaN
static _Tp signaling_NaN()
Definition: limits_gcc3.h:997

std::numeric_limits::epsilon
static _Tp epsilon()
Definition: limits_gcc3.h:993

std::numeric_limits::infinity
static _Tp infinity()
Definition: limits_gcc3.h:995

std::numeric_limits::denorm_min
static _Tp denorm_min()
Definition: limits_gcc3.h:998

std::numeric_limits::max
static _Tp max()
Definition: limits_gcc3.h:992

std::numeric_limits::quiet_NaN
static _Tp quiet_NaN()
Definition: limits_gcc3.h:996