contrib/gcc-4.4/libstdc++-v3/include/std/limits

   1 // The template and inlines for the numeric_limits classes. -*- C++ -*-
   2
   3 // Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
   4 // 2008, 2009  Free Software Foundation, Inc.
   5 //
   6 // This file is part of the GNU ISO C++ Library.  This library is free
   7 // software; you can redistribute it and/or modify it under the
   8 // terms of the GNU General Public License as published by the
   9 // Free Software Foundation; either version 3, or (at your option)
  10 // any later version.
  11
  12 // This library is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16
  17 // Under Section 7 of GPL version 3, you are granted additional
  18 // permissions described in the GCC Runtime Library Exception, version
  19 // 3.1, as published by the Free Software Foundation.
  20
  21 // You should have received a copy of the GNU General Public License and
  22 // a copy of the GCC Runtime Library Exception along with this program;
  23 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  24 // <http://www.gnu.org/licenses/>.
  25
  26 /** @file limits
  27  *  This is a Standard C++ Library header.
  28  */
  29
  30 // Note: this is not a conforming implementation.
  31 // Written by Gabriel Dos Reis <gdr@codesourcery.com>
  32
  33 //
  34 // ISO 14882:1998
  35 // 18.2.1
  36 //
  37
  38 #ifndef _GLIBCXX_NUMERIC_LIMITS
  39 #define _GLIBCXX_NUMERIC_LIMITS 1
  40
  41 #pragma GCC system_header
  42
  43 #include <bits/c++config.h>
  44
  45 //
  46 // The numeric_limits<> traits document implementation-defined aspects
  47 // of fundamental arithmetic data types (integers and floating points).
  48 // From Standard C++ point of view, there are 13 such types:
  49 //   * integers
  50 //         bool                                                 (1)
  51 //         char, signed char, unsigned char                     (3)
  52 //         short, unsigned short                                (2)
  53 //         int, unsigned                                        (2)
  54 //         long, unsigned long                                  (2)
  55 //
  56 //   * floating points
  57 //         float                                                (1)
  58 //         double                                               (1)
  59 //         long double                                          (1)
  60 //
  61 // GNU C++ understands (where supported by the host C-library)
  62 //   * integer
  63 //         long long, unsigned long long                        (2)
  64 //
  65 // which brings us to 15 fundamental arithmetic data types in GNU C++.
  66 //
  67 //
  68 // Since a numeric_limits<> is a bit tricky to get right, we rely on
  69 // an interface composed of macros which should be defined in config/os
  70 // or config/cpu when they differ from the generic (read arbitrary)
  71 // definitions given here.
  72 //
  73
  74 // These values can be overridden in the target configuration file.
  75 // The default values are appropriate for many 32-bit targets.
  76
  77 // GCC only intrinsically supports modulo integral types.  The only remaining
  78 // integral exceptional values is division by zero.  Only targets that do not
  79 // signal division by zero in some "hard to ignore" way should use false.
  80 #ifndef __glibcxx_integral_traps
  81 # define __glibcxx_integral_traps true
  82 #endif
  83
  84 // float
  85 //
  86
  87 // Default values.  Should be overridden in configuration files if necessary.
  88
  89 #ifndef __glibcxx_float_has_denorm_loss
  90 #  define __glibcxx_float_has_denorm_loss false
  91 #endif
  92 #ifndef __glibcxx_float_traps
  93 #  define __glibcxx_float_traps false
  94 #endif
  95 #ifndef __glibcxx_float_tinyness_before
  96 #  define __glibcxx_float_tinyness_before false
  97 #endif
  98
  99 // double
 100
 101 // Default values.  Should be overridden in configuration files if necessary.
 102
 103 #ifndef __glibcxx_double_has_denorm_loss
 104 #  define __glibcxx_double_has_denorm_loss false
 105 #endif
 106 #ifndef __glibcxx_double_traps
 107 #  define __glibcxx_double_traps false
 108 #endif
 109 #ifndef __glibcxx_double_tinyness_before
 110 #  define __glibcxx_double_tinyness_before false
 111 #endif
 112
 113 // long double
 114
 115 // Default values.  Should be overridden in configuration files if necessary.
 116
 117 #ifndef __glibcxx_long_double_has_denorm_loss
 118 #  define __glibcxx_long_double_has_denorm_loss false
 119 #endif
 120 #ifndef __glibcxx_long_double_traps
 121 #  define __glibcxx_long_double_traps false
 122 #endif
 123 #ifndef __glibcxx_long_double_tinyness_before
 124 #  define __glibcxx_long_double_tinyness_before false
 125 #endif
 126
 127 // You should not need to define any macros below this point.
 128
 129 #define __glibcxx_signed(T)     ((T)(-1) < 0)
 130
 131 #define __glibcxx_min(T) \
 132   (__glibcxx_signed (T) ? (T)1 << __glibcxx_digits (T) : (T)0)
 133
 134 #define __glibcxx_max(T) \
 135   (__glibcxx_signed (T) ? \
 136    (((((T)1 << (__glibcxx_digits (T) - 1)) - 1) << 1) + 1) : ~(T)0)
 137
 138 #define __glibcxx_digits(T) \
 139   (sizeof(T) * __CHAR_BIT__ - __glibcxx_signed (T))
 140
 141 // The fraction 643/2136 approximates log10(2) to 7 significant digits.
 142 #define __glibcxx_digits10(T) \
 143   (__glibcxx_digits (T) * 643 / 2136)
 144
 145
 146 _GLIBCXX_BEGIN_NAMESPACE(std)
 147
 148   /**
 149    *  @brief Describes the rounding style for floating-point types.
 150    *
 151    *  This is used in the std::numeric_limits class.
 152   */
 153   enum float_round_style
 154   {
 155     round_indeterminate       = -1,    ///< Self-explanatory.
 156     round_toward_zero         = 0,     ///< Self-explanatory.
 157     round_to_nearest          = 1,     ///< To the nearest representable value.
 158     round_toward_infinity     = 2,     ///< Self-explanatory.
 159     round_toward_neg_infinity = 3      ///< Self-explanatory.
 160   };
 161
 162   /**
 163    *  @brief Describes the denormalization for floating-point types.
 164    *
 165    *  These values represent the presence or absence of a variable number
 166    *  of exponent bits.  This type is used in the std::numeric_limits class.
 167   */
 168   enum float_denorm_style
 169   {
 170     /// Indeterminate at compile time whether denormalized values are allowed.
 171     denorm_indeterminate = -1,
 172     /// The type does not allow denormalized values.
 173     denorm_absent        = 0,
 174     /// The type allows denormalized values.
 175     denorm_present       = 1
 176   };
 177
 178   /**
 179    *  @brief Part of std::numeric_limits.
 180    *
 181    *  The @c static @c const members are usable as integral constant
 182    *  expressions.
 183    *
 184    *  @note This is a separate class for purposes of efficiency; you
 185    *        should only access these members as part of an instantiation
 186    *        of the std::numeric_limits class.
 187   */
 188   struct __numeric_limits_base
 189   {
 190     /** This will be true for all fundamental types (which have
 191         specializations), and false for everything else.  */
 192     static const bool is_specialized = false;
 193
 194     /** The number of @c radix digits that be represented without change:  for
 195         integer types, the number of non-sign bits in the mantissa; for
 196         floating types, the number of @c radix digits in the mantissa.  */
 197     static const int digits = 0;
 198     /** The number of base 10 digits that can be represented without change. */
 199     static const int digits10 = 0;
 200     /** True if the type is signed.  */
 201     static const bool is_signed = false;
 202     /** True if the type is integer.
 203      *  Is this supposed to be "if the type is integral"?
 204     */
 205     static const bool is_integer = false;
 206     /** True if the type uses an exact representation.  "All integer types are
 207         exact, but not all exact types are integer.  For example, rational and
 208         fixed-exponent representations are exact but not integer."
 209         [18.2.1.2]/15  */
 210     static const bool is_exact = false;
 211     /** For integer types, specifies the base of the representation.  For
 212         floating types, specifies the base of the exponent representation.  */
 213     static const int radix = 0;
 214
 215     /** The minimum negative integer such that @c radix raised to the power of
 216         (one less than that integer) is a normalized floating point number.  */
 217     static const int min_exponent = 0;
 218     /** The minimum negative integer such that 10 raised to that power is in
 219         the range of normalized floating point numbers.  */
 220     static const int min_exponent10 = 0;
 221     /** The maximum positive integer such that @c radix raised to the power of
 222         (one less than that integer) is a representable finite floating point
 223         number.  */
 224     static const int max_exponent = 0;
 225     /** The maximum positive integer such that 10 raised to that power is in
 226         the range of representable finite floating point numbers.  */
 227     static const int max_exponent10 = 0;
 228
 229     /** True if the type has a representation for positive infinity.  */
 230     static const bool has_infinity = false;
 231     /** True if the type has a representation for a quiet (non-signaling)
 232         "Not a Number."  */
 233     static const bool has_quiet_NaN = false;
 234     /** True if the type has a representation for a signaling
 235         "Not a Number."  */
 236     static const bool has_signaling_NaN = false;
 237     /** See std::float_denorm_style for more information.  */
 238     static const float_denorm_style has_denorm = denorm_absent;
 239     /** "True if loss of accuracy is detected as a denormalization loss,
 240         rather than as an inexact result." [18.2.1.2]/42  */
 241     static const bool has_denorm_loss = false;
 242
 243     /** True if-and-only-if the type adheres to the IEC 559 standard, also
 244         known as IEEE 754.  (Only makes sense for floating point types.)  */
 245     static const bool is_iec559 = false;
 246     /** "True if the set of values representable by the type is finite.   All
 247         built-in types are bounded, this member would be false for arbitrary
 248         precision types." [18.2.1.2]/54  */
 249     static const bool is_bounded = false;
 250     /** True if the type is @e modulo, that is, if it is possible to add two
 251         positive numbers and have a result that wraps around to a third number
 252         that is less.  Typically false for floating types, true for unsigned
 253         integers, and true for signed integers.  */
 254     static const bool is_modulo = false;
 255
 256     /** True if trapping is implemented for this type.  */
 257     static const bool traps = false;
 258     /** True if tininess is detected before rounding.  (see IEC 559)  */
 259     static const bool tinyness_before = false;
 260     /** See std::float_round_style for more information.  This is only
 261         meaningful for floating types; integer types will all be
 262         round_toward_zero.  */
 263     static const float_round_style round_style = round_toward_zero;
 264   };
 265
 266   /**
 267    *  @brief Properties of fundamental types.
 268    *
 269    *  This class allows a program to obtain information about the
 270    *  representation of a fundamental type on a given platform.  For
 271    *  non-fundamental types, the functions will return 0 and the data
 272    *  members will all be @c false.
 273    *
 274    *  _GLIBCXX_RESOLVE_LIB_DEFECTS:  DRs 201 and 184 (hi Gaby!) are
 275    *  noted, but not incorporated in this documented (yet).
 276   */
 277   template<typename _Tp>
 278     struct numeric_limits : public __numeric_limits_base
 279     {
 280       /** The minimum finite value, or for floating types with
 281           denormalization, the minimum positive normalized value.  */
 282       static _Tp min() throw() { return static_cast<_Tp>(0); }
 283       /** The maximum finite value.  */
 284       static _Tp max() throw() { return static_cast<_Tp>(0); }
 285       /** The @e machine @e epsilon:  the difference between 1 and the least
 286           value greater than 1 that is representable.  */
 287       static _Tp epsilon() throw() { return static_cast<_Tp>(0); }
 288       /** The maximum rounding error measurement (see LIA-1).  */
 289       static _Tp round_error() throw() { return static_cast<_Tp>(0); }
 290       /** The representation of positive infinity, if @c has_infinity.  */
 291       static _Tp infinity() throw()  { return static_cast<_Tp>(0); }
 292       /** The representation of a quiet "Not a Number," if @c has_quiet_NaN. */
 293       static _Tp quiet_NaN() throw() { return static_cast<_Tp>(0); }
 294       /** The representation of a signaling "Not a Number," if
 295           @c has_signaling_NaN. */
 296       static _Tp signaling_NaN() throw() { return static_cast<_Tp>(0); }
 297       /** The minimum positive denormalized value.  For types where
 298           @c has_denorm is false, this is the minimum positive normalized
 299           value.  */
 300       static _Tp denorm_min() throw() { return static_cast<_Tp>(0); }
 301     };
 302
 303   // Now there follow 15 explicit specializations.  Yes, 15.  Make sure
 304   // you get the count right.
 305
 306   /// numeric_limits<bool> specialization.
 307   template<>
 308     struct numeric_limits<bool>
 309     {
 310       static const bool is_specialized = true;
 311
 312       static bool min() throw()
 313       { return false; }
 314       static bool max() throw()
 315       { return true; }
 316
 317       static const int digits = 1;
 318       static const int digits10 = 0;
 319       static const bool is_signed = false;
 320       static const bool is_integer = true;
 321       static const bool is_exact = true;
 322       static const int radix = 2;
 323       static bool epsilon() throw()
 324       { return false; }
 325       static bool round_error() throw()
 326       { return false; }
 327
 328       static const int min_exponent = 0;
 329       static const int min_exponent10 = 0;
 330       static const int max_exponent = 0;
 331       static const int max_exponent10 = 0;
 332
 333       static const bool has_infinity = false;
 334       static const bool has_quiet_NaN = false;
 335       static const bool has_signaling_NaN = false;
 336       static const float_denorm_style has_denorm = denorm_absent;
 337       static const bool has_denorm_loss = false;
 338
 339       static bool infinity() throw()
 340       { return false; }
 341       static bool quiet_NaN() throw()
 342       { return false; }
 343       static bool signaling_NaN() throw()
 344       { return false; }
 345       static bool denorm_min() throw()
 346       { return false; }
 347
 348       static const bool is_iec559 = false;
 349       static const bool is_bounded = true;
 350       static const bool is_modulo = false;
 351
 352       // It is not clear what it means for a boolean type to trap.
 353       // This is a DR on the LWG issue list.  Here, I use integer
 354       // promotion semantics.
 355       static const bool traps = __glibcxx_integral_traps;
 356       static const bool tinyness_before = false;
 357       static const float_round_style round_style = round_toward_zero;
 358     };
 359
 360   /// numeric_limits<char> specialization.
 361   template<>
 362     struct numeric_limits<char>
 363     {
 364       static const bool is_specialized = true;
 365
 366       static char min() throw()
 367       { return __glibcxx_min(char); }
 368       static char max() throw()
 369       { return __glibcxx_max(char); }
 370
 371       static const int digits = __glibcxx_digits (char);
 372       static const int digits10 = __glibcxx_digits10 (char);
 373       static const bool is_signed = __glibcxx_signed (char);
 374       static const bool is_integer = true;
 375       static const bool is_exact = true;
 376       static const int radix = 2;
 377       static char epsilon() throw()
 378       { return 0; }
 379       static char round_error() throw()
 380       { return 0; }
 381
 382       static const int min_exponent = 0;
 383       static const int min_exponent10 = 0;
 384       static const int max_exponent = 0;
 385       static const int max_exponent10 = 0;
 386
 387       static const bool has_infinity = false;
 388       static const bool has_quiet_NaN = false;
 389       static const bool has_signaling_NaN = false;
 390       static const float_denorm_style has_denorm = denorm_absent;
 391       static const bool has_denorm_loss = false;
 392
 393       static char infinity() throw()
 394       { return char(); }
 395       static char quiet_NaN() throw()
 396       { return char(); }
 397       static char signaling_NaN() throw()
 398       { return char(); }
 399       static char denorm_min() throw()
 400       { return static_cast<char>(0); }
 401
 402       static const bool is_iec559 = false;
 403       static const bool is_bounded = true;
 404       static const bool is_modulo = true;
 405
 406       static const bool traps = __glibcxx_integral_traps;
 407       static const bool tinyness_before = false;
 408       static const float_round_style round_style = round_toward_zero;
 409     };
 410
 411   /// numeric_limits<signed char> specialization.
 412   template<>
 413     struct numeric_limits<signed char>
 414     {
 415       static const bool is_specialized = true;
 416
 417       static signed char min() throw()
 418       { return -__SCHAR_MAX__ - 1; }
 419       static signed char max() throw()
 420       { return __SCHAR_MAX__; }
 421
 422       static const int digits = __glibcxx_digits (signed char);
 423       static const int digits10 = __glibcxx_digits10 (signed char);
 424       static const bool is_signed = true;
 425       static const bool is_integer = true;
 426       static const bool is_exact = true;
 427       static const int radix = 2;
 428       static signed char epsilon() throw()
 429       { return 0; }
 430       static signed char round_error() throw()
 431       { return 0; }
 432
 433       static const int min_exponent = 0;
 434       static const int min_exponent10 = 0;
 435       static const int max_exponent = 0;
 436       static const int max_exponent10 = 0;
 437
 438       static const bool has_infinity = false;
 439       static const bool has_quiet_NaN = false;
 440       static const bool has_signaling_NaN = false;
 441       static const float_denorm_style has_denorm = denorm_absent;
 442       static const bool has_denorm_loss = false;
 443
 444       static signed char infinity() throw()
 445       { return static_cast<signed char>(0); }
 446       static signed char quiet_NaN() throw()
 447       { return static_cast<signed char>(0); }
 448       static signed char signaling_NaN() throw()
 449       { return static_cast<signed char>(0); }
 450       static signed char denorm_min() throw()
 451       { return static_cast<signed char>(0); }
 452
 453       static const bool is_iec559 = false;
 454       static const bool is_bounded = true;
 455       static const bool is_modulo = true;
 456
 457       static const bool traps = __glibcxx_integral_traps;
 458       static const bool tinyness_before = false;
 459       static const float_round_style round_style = round_toward_zero;
 460     };
 461
 462   /// numeric_limits<unsigned char> specialization.
 463   template<>
 464     struct numeric_limits<unsigned char>
 465     {
 466       static const bool is_specialized = true;
 467
 468       static unsigned char min() throw()
 469       { return 0; }
 470       static unsigned char max() throw()
 471       { return __SCHAR_MAX__ * 2U + 1; }
 472
 473       static const int digits = __glibcxx_digits (unsigned char);
 474       static const int digits10 = __glibcxx_digits10 (unsigned char);
 475       static const bool is_signed = false;
 476       static const bool is_integer = true;
 477       static const bool is_exact = true;
 478       static const int radix = 2;
 479       static unsigned char epsilon() throw()
 480       { return 0; }
 481       static unsigned char round_error() throw()
 482       { return 0; }
 483
 484       static const int min_exponent = 0;
 485       static const int min_exponent10 = 0;
 486       static const int max_exponent = 0;
 487       static const int max_exponent10 = 0;
 488
 489       static const bool has_infinity = false;
 490       static const bool has_quiet_NaN = false;
 491       static const bool has_signaling_NaN = false;
 492       static const float_denorm_style has_denorm = denorm_absent;
 493       static const bool has_denorm_loss = false;
 494
 495       static unsigned char infinity() throw()
 496       { return static_cast<unsigned char>(0); }
 497       static unsigned char quiet_NaN() throw()
 498       { return static_cast<unsigned char>(0); }
 499       static unsigned char signaling_NaN() throw()
 500       { return static_cast<unsigned char>(0); }
 501       static unsigned char denorm_min() throw()
 502       { return static_cast<unsigned char>(0); }
 503
 504       static const bool is_iec559 = false;
 505       static const bool is_bounded = true;
 506       static const bool is_modulo = true;
 507
 508       static const bool traps = __glibcxx_integral_traps;
 509       static const bool tinyness_before = false;
 510       static const float_round_style round_style = round_toward_zero;
 511     };
 512
 513   /// numeric_limits<wchar_t> specialization.
 514   template<>
 515     struct numeric_limits<wchar_t>
 516     {
 517       static const bool is_specialized = true;
 518
 519       static wchar_t min() throw()
 520       { return __glibcxx_min (wchar_t); }
 521       static wchar_t max() throw()
 522       { return __glibcxx_max (wchar_t); }
 523
 524       static const int digits = __glibcxx_digits (wchar_t);
 525       static const int digits10 = __glibcxx_digits10 (wchar_t);
 526       static const bool is_signed = __glibcxx_signed (wchar_t);
 527       static const bool is_integer = true;
 528       static const bool is_exact = true;
 529       static const int radix = 2;
 530       static wchar_t epsilon() throw()
 531       { return 0; }
 532       static wchar_t round_error() throw()
 533       { return 0; }
 534
 535       static const int min_exponent = 0;
 536       static const int min_exponent10 = 0;
 537       static const int max_exponent = 0;
 538       static const int max_exponent10 = 0;
 539
 540       static const bool has_infinity = false;
 541       static const bool has_quiet_NaN = false;
 542       static const bool has_signaling_NaN = false;
 543       static const float_denorm_style has_denorm = denorm_absent;
 544       static const bool has_denorm_loss = false;
 545
 546       static wchar_t infinity() throw()
 547       { return wchar_t(); }
 548       static wchar_t quiet_NaN() throw()
 549       { return wchar_t(); }
 550       static wchar_t signaling_NaN() throw()
 551       { return wchar_t(); }
 552       static wchar_t denorm_min() throw()
 553       { return wchar_t(); }
 554
 555       static const bool is_iec559 = false;
 556       static const bool is_bounded = true;
 557       static const bool is_modulo = true;
 558
 559       static const bool traps = __glibcxx_integral_traps;
 560       static const bool tinyness_before = false;
 561       static const float_round_style round_style = round_toward_zero;
 562     };
 563
 564 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 565   /// numeric_limits<char16_t> specialization.
 566   template<>
 567     struct numeric_limits<char16_t>
 568     {
 569       static const bool is_specialized = true;
 570
 571       static char16_t min() throw()
 572       { return __glibcxx_min (char16_t); }
 573       static char16_t max() throw()
 574       { return __glibcxx_max (char16_t); }
 575
 576       static const int digits = __glibcxx_digits (char16_t);
 577       static const int digits10 = __glibcxx_digits10 (char16_t);
 578       static const bool is_signed = __glibcxx_signed (char16_t);
 579       static const bool is_integer = true;
 580       static const bool is_exact = true;
 581       static const int radix = 2;
 582       static char16_t epsilon() throw()
 583       { return 0; }
 584       static char16_t round_error() throw()
 585       { return 0; }
 586
 587       static const int min_exponent = 0;
 588       static const int min_exponent10 = 0;
 589       static const int max_exponent = 0;
 590       static const int max_exponent10 = 0;
 591
 592       static const bool has_infinity = false;
 593       static const bool has_quiet_NaN = false;
 594       static const bool has_signaling_NaN = false;
 595       static const float_denorm_style has_denorm = denorm_absent;
 596       static const bool has_denorm_loss = false;
 597
 598       static char16_t infinity() throw()
 599       { return char16_t(); }
 600       static char16_t quiet_NaN() throw()
 601       { return char16_t(); }
 602       static char16_t signaling_NaN() throw()
 603       { return char16_t(); }
 604       static char16_t denorm_min() throw()
 605       { return char16_t(); }
 606
 607       static const bool is_iec559 = false;
 608       static const bool is_bounded = true;
 609       static const bool is_modulo = true;
 610
 611       static const bool traps = __glibcxx_integral_traps;
 612       static const bool tinyness_before = false;
 613       static const float_round_style round_style = round_toward_zero;
 614     };
 615
 616   /// numeric_limits<char32_t> specialization.
 617   template<>
 618     struct numeric_limits<char32_t>
 619     {
 620       static const bool is_specialized = true;
 621
 622       static char32_t min() throw()
 623       { return __glibcxx_min (char32_t); }
 624       static char32_t max() throw()
 625       { return __glibcxx_max (char32_t); }
 626
 627       static const int digits = __glibcxx_digits (char32_t);
 628       static const int digits10 = __glibcxx_digits10 (char32_t);
 629       static const bool is_signed = __glibcxx_signed (char32_t);
 630       static const bool is_integer = true;
 631       static const bool is_exact = true;
 632       static const int radix = 2;
 633       static char32_t epsilon() throw()
 634       { return 0; }
 635       static char32_t round_error() throw()
 636       { return 0; }
 637
 638       static const int min_exponent = 0;
 639       static const int min_exponent10 = 0;
 640       static const int max_exponent = 0;
 641       static const int max_exponent10 = 0;
 642
 643       static const bool has_infinity = false;
 644       static const bool has_quiet_NaN = false;
 645       static const bool has_signaling_NaN = false;
 646       static const float_denorm_style has_denorm = denorm_absent;
 647       static const bool has_denorm_loss = false;
 648
 649       static char32_t infinity() throw()
 650       { return char32_t(); }
 651       static char32_t quiet_NaN() throw()
 652       { return char32_t(); }
 653       static char32_t signaling_NaN() throw()
 654       { return char32_t(); }
 655       static char32_t denorm_min() throw()
 656       { return char32_t(); }
 657
 658       static const bool is_iec559 = false;
 659       static const bool is_bounded = true;
 660       static const bool is_modulo = true;
 661
 662       static const bool traps = __glibcxx_integral_traps;
 663       static const bool tinyness_before = false;
 664       static const float_round_style round_style = round_toward_zero;
 665     };
 666 #endif
 667
 668   /// numeric_limits<short> specialization.
 669   template<>
 670     struct numeric_limits<short>
 671     {
 672       static const bool is_specialized = true;
 673
 674       static short min() throw()
 675       { return -__SHRT_MAX__ - 1; }
 676       static short max() throw()
 677       { return __SHRT_MAX__; }
 678
 679       static const int digits = __glibcxx_digits (short);
 680       static const int digits10 = __glibcxx_digits10 (short);
 681       static const bool is_signed = true;
 682       static const bool is_integer = true;
 683       static const bool is_exact = true;
 684       static const int radix = 2;
 685       static short epsilon() throw()
 686       { return 0; }
 687       static short round_error() throw()
 688       { return 0; }
 689
 690       static const int min_exponent = 0;
 691       static const int min_exponent10 = 0;
 692       static const int max_exponent = 0;
 693       static const int max_exponent10 = 0;
 694
 695       static const bool has_infinity = false;
 696       static const bool has_quiet_NaN = false;
 697       static const bool has_signaling_NaN = false;
 698       static const float_denorm_style has_denorm = denorm_absent;
 699       static const bool has_denorm_loss = false;
 700
 701       static short infinity() throw()
 702       { return short(); }
 703       static short quiet_NaN() throw()
 704       { return short(); }
 705       static short signaling_NaN() throw()
 706       { return short(); }
 707       static short denorm_min() throw()
 708       { return short(); }
 709
 710       static const bool is_iec559 = false;
 711       static const bool is_bounded = true;
 712       static const bool is_modulo = true;
 713
 714       static const bool traps = __glibcxx_integral_traps;
 715       static const bool tinyness_before = false;
 716       static const float_round_style round_style = round_toward_zero;
 717     };
 718
 719   /// numeric_limits<unsigned short> specialization.
 720   template<>
 721     struct numeric_limits<unsigned short>
 722     {
 723       static const bool is_specialized = true;
 724
 725       static unsigned short min() throw()
 726       { return 0; }
 727       static unsigned short max() throw()
 728       { return __SHRT_MAX__ * 2U + 1; }
 729
 730       static const int digits = __glibcxx_digits (unsigned short);
 731       static const int digits10 = __glibcxx_digits10 (unsigned short);
 732       static const bool is_signed = false;
 733       static const bool is_integer = true;
 734       static const bool is_exact = true;
 735       static const int radix = 2;
 736       static unsigned short epsilon() throw()
 737       { return 0; }
 738       static unsigned short round_error() throw()
 739       { return 0; }
 740
 741       static const int min_exponent = 0;
 742       static const int min_exponent10 = 0;
 743       static const int max_exponent = 0;
 744       static const int max_exponent10 = 0;
 745
 746       static const bool has_infinity = false;
 747       static const bool has_quiet_NaN = false;
 748       static const bool has_signaling_NaN = false;
 749       static const float_denorm_style has_denorm = denorm_absent;
 750       static const bool has_denorm_loss = false;
 751
 752       static unsigned short infinity() throw()
 753       { return static_cast<unsigned short>(0); }
 754       static unsigned short quiet_NaN() throw()
 755       { return static_cast<unsigned short>(0); }
 756       static unsigned short signaling_NaN() throw()
 757       { return static_cast<unsigned short>(0); }
 758       static unsigned short denorm_min() throw()
 759       { return static_cast<unsigned short>(0); }
 760
 761       static const bool is_iec559 = false;
 762       static const bool is_bounded = true;
 763       static const bool is_modulo = true;
 764
 765       static const bool traps = __glibcxx_integral_traps;
 766       static const bool tinyness_before = false;
 767       static const float_round_style round_style = round_toward_zero;
 768     };
 769
 770   /// numeric_limits<int> specialization.
 771   template<>
 772     struct numeric_limits<int>
 773     {
 774       static const bool is_specialized = true;
 775
 776       static int min() throw()
 777       { return -__INT_MAX__ - 1; }
 778       static int max() throw()
 779       { return __INT_MAX__; }
 780
 781       static const int digits = __glibcxx_digits (int);
 782       static const int digits10 = __glibcxx_digits10 (int);
 783       static const bool is_signed = true;
 784       static const bool is_integer = true;
 785       static const bool is_exact = true;
 786       static const int radix = 2;
 787       static int epsilon() throw()
 788       { return 0; }
 789       static int round_error() throw()
 790       { return 0; }
 791
 792       static const int min_exponent = 0;
 793       static const int min_exponent10 = 0;
 794       static const int max_exponent = 0;
 795       static const int max_exponent10 = 0;
 796
 797       static const bool has_infinity = false;
 798       static const bool has_quiet_NaN = false;
 799       static const bool has_signaling_NaN = false;
 800       static const float_denorm_style has_denorm = denorm_absent;
 801       static const bool has_denorm_loss = false;
 802
 803       static int infinity() throw()
 804       { return static_cast<int>(0); }
 805       static int quiet_NaN() throw()
 806       { return static_cast<int>(0); }
 807       static int signaling_NaN() throw()
 808       { return static_cast<int>(0); }
 809       static int denorm_min() throw()
 810       { return static_cast<int>(0); }
 811
 812       static const bool is_iec559 = false;
 813       static const bool is_bounded = true;
 814       static const bool is_modulo = true;
 815
 816       static const bool traps = __glibcxx_integral_traps;
 817       static const bool tinyness_before = false;
 818       static const float_round_style round_style = round_toward_zero;
 819     };
 820
 821   /// numeric_limits<unsigned int> specialization.
 822   template<>
 823     struct numeric_limits<unsigned int>
 824     {
 825       static const bool is_specialized = true;
 826
 827       static unsigned int min() throw()
 828       { return 0; }
 829       static unsigned int max() throw()
 830       { return __INT_MAX__ * 2U + 1; }
 831
 832       static const int digits = __glibcxx_digits (unsigned int);
 833       static const int digits10 = __glibcxx_digits10 (unsigned int);
 834       static const bool is_signed = false;
 835       static const bool is_integer = true;
 836       static const bool is_exact = true;
 837       static const int radix = 2;
 838       static unsigned int epsilon() throw()
 839       { return 0; }
 840       static unsigned int round_error() throw()
 841       { return 0; }
 842
 843       static const int min_exponent = 0;
 844       static const int min_exponent10 = 0;
 845       static const int max_exponent = 0;
 846       static const int max_exponent10 = 0;
 847
 848       static const bool has_infinity = false;
 849       static const bool has_quiet_NaN = false;
 850       static const bool has_signaling_NaN = false;
 851       static const float_denorm_style has_denorm = denorm_absent;
 852       static const bool has_denorm_loss = false;
 853
 854       static unsigned int infinity() throw()
 855       { return static_cast<unsigned int>(0); }
 856       static unsigned int quiet_NaN() throw()
 857       { return static_cast<unsigned int>(0); }
 858       static unsigned int signaling_NaN() throw()
 859       { return static_cast<unsigned int>(0); }
 860       static unsigned int denorm_min() throw()
 861       { return static_cast<unsigned int>(0); }
 862
 863       static const bool is_iec559 = false;
 864       static const bool is_bounded = true;
 865       static const bool is_modulo = true;
 866
 867       static const bool traps = __glibcxx_integral_traps;
 868       static const bool tinyness_before = false;
 869       static const float_round_style round_style = round_toward_zero;
 870     };
 871
 872   /// numeric_limits<long> specialization.
 873   template<>
 874     struct numeric_limits<long>
 875     {
 876       static const bool is_specialized = true;
 877
 878       static long min() throw()
 879       { return -__LONG_MAX__ - 1; }
 880       static long max() throw()
 881       { return __LONG_MAX__; }
 882
 883       static const int digits = __glibcxx_digits (long);
 884       static const int digits10 = __glibcxx_digits10 (long);
 885       static const bool is_signed = true;
 886       static const bool is_integer = true;
 887       static const bool is_exact = true;
 888       static const int radix = 2;
 889       static long epsilon() throw()
 890       { return 0; }
 891       static long round_error() throw()
 892       { return 0; }
 893
 894       static const int min_exponent = 0;
 895       static const int min_exponent10 = 0;
 896       static const int max_exponent = 0;
 897       static const int max_exponent10 = 0;
 898
 899       static const bool has_infinity = false;
 900       static const bool has_quiet_NaN = false;
 901       static const bool has_signaling_NaN = false;
 902       static const float_denorm_style has_denorm = denorm_absent;
 903       static const bool has_denorm_loss = false;
 904
 905       static long infinity() throw()
 906       { return static_cast<long>(0); }
 907       static long quiet_NaN() throw()
 908       { return static_cast<long>(0); }
 909       static long signaling_NaN() throw()
 910       { return static_cast<long>(0); }
 911       static long denorm_min() throw()
 912       { return static_cast<long>(0); }
 913
 914       static const bool is_iec559 = false;
 915       static const bool is_bounded = true;
 916       static const bool is_modulo = true;
 917
 918       static const bool traps = __glibcxx_integral_traps;
 919       static const bool tinyness_before = false;
 920       static const float_round_style round_style = round_toward_zero;
 921     };
 922
 923   /// numeric_limits<unsigned long> specialization.
 924   template<>
 925     struct numeric_limits<unsigned long>
 926     {
 927       static const bool is_specialized = true;
 928
 929       static unsigned long min() throw()
 930       { return 0; }
 931       static unsigned long max() throw()
 932       { return __LONG_MAX__ * 2UL + 1; }
 933
 934       static const int digits = __glibcxx_digits (unsigned long);
 935       static const int digits10 = __glibcxx_digits10 (unsigned long);
 936       static const bool is_signed = false;
 937       static const bool is_integer = true;
 938       static const bool is_exact = true;
 939       static const int radix = 2;
 940       static unsigned long epsilon() throw()
 941       { return 0; }
 942       static unsigned long round_error() throw()
 943       { return 0; }
 944
 945       static const int min_exponent = 0;
 946       static const int min_exponent10 = 0;
 947       static const int max_exponent = 0;
 948       static const int max_exponent10 = 0;
 949
 950       static const bool has_infinity = false;
 951       static const bool has_quiet_NaN = false;
 952       static const bool has_signaling_NaN = false;
 953       static const float_denorm_style has_denorm = denorm_absent;
 954       static const bool has_denorm_loss = false;
 955
 956       static unsigned long infinity() throw()
 957       { return static_cast<unsigned long>(0); }
 958       static unsigned long quiet_NaN() throw()
 959       { return static_cast<unsigned long>(0); }
 960       static unsigned long signaling_NaN() throw()
 961       { return static_cast<unsigned long>(0); }
 962       static unsigned long denorm_min() throw()
 963       { return static_cast<unsigned long>(0); }
 964
 965       static const bool is_iec559 = false;
 966       static const bool is_bounded = true;
 967       static const bool is_modulo = true;
 968
 969       static const bool traps = __glibcxx_integral_traps;
 970       static const bool tinyness_before = false;
 971       static const float_round_style round_style = round_toward_zero;
 972     };
 973
 974   /// numeric_limits<long long> specialization.
 975   template<>
 976     struct numeric_limits<long long>
 977     {
 978       static const bool is_specialized = true;
 979
 980       static long long min() throw()
 981       { return -__LONG_LONG_MAX__ - 1; }
 982       static long long max() throw()
 983       { return __LONG_LONG_MAX__; }
 984
 985       static const int digits = __glibcxx_digits (long long);
 986       static const int digits10 = __glibcxx_digits10 (long long);
 987       static const bool is_signed = true;
 988       static const bool is_integer = true;
 989       static const bool is_exact = true;
 990       static const int radix = 2;
 991       static long long epsilon() throw()
 992       { return 0; }
 993       static long long round_error() throw()
 994       { return 0; }
 995
 996       static const int min_exponent = 0;
 997       static const int min_exponent10 = 0;
 998       static const int max_exponent = 0;
 999       static const int max_exponent10 = 0;
1000
1001       static const bool has_infinity = false;
1002       static const bool has_quiet_NaN = false;
1003       static const bool has_signaling_NaN = false;
1004       static const float_denorm_style has_denorm = denorm_absent;
1005       static const bool has_denorm_loss = false;
1006
1007       static long long infinity() throw()
1008       { return static_cast<long long>(0); }
1009       static long long quiet_NaN() throw()
1010       { return static_cast<long long>(0); }
1011       static long long signaling_NaN() throw()
1012       { return static_cast<long long>(0); }
1013       static long long denorm_min() throw()
1014       { return static_cast<long long>(0); }
1015
1016       static const bool is_iec559 = false;
1017       static const bool is_bounded = true;
1018       static const bool is_modulo = true;
1019
1020       static const bool traps = __glibcxx_integral_traps;
1021       static const bool tinyness_before = false;
1022       static const float_round_style round_style = round_toward_zero;
1023     };
1024
1025   /// numeric_limits<unsigned long long> specialization.
1026   template<>
1027     struct numeric_limits<unsigned long long>
1028     {
1029       static const bool is_specialized = true;
1030
1031       static unsigned long long min() throw()
1032       { return 0; }
1033       static unsigned long long max() throw()
1034       { return __LONG_LONG_MAX__ * 2ULL + 1; }
1035
1036       static const int digits = __glibcxx_digits (unsigned long long);
1037       static const int digits10 = __glibcxx_digits10 (unsigned long long);
1038       static const bool is_signed = false;
1039       static const bool is_integer = true;
1040       static const bool is_exact = true;
1041       static const int radix = 2;
1042       static unsigned long long epsilon() throw()
1043       { return 0; }
1044       static unsigned long long round_error() throw()
1045       { return 0; }
1046
1047       static const int min_exponent = 0;
1048       static const int min_exponent10 = 0;
1049       static const int max_exponent = 0;
1050       static const int max_exponent10 = 0;
1051
1052       static const bool has_infinity = false;
1053       static const bool has_quiet_NaN = false;
1054       static const bool has_signaling_NaN = false;
1055       static const float_denorm_style has_denorm = denorm_absent;
1056       static const bool has_denorm_loss = false;
1057
1058       static unsigned long long infinity() throw()
1059       { return static_cast<unsigned long long>(0); }
1060       static unsigned long long quiet_NaN() throw()
1061       { return static_cast<unsigned long long>(0); }
1062       static unsigned long long signaling_NaN() throw()
1063       { return static_cast<unsigned long long>(0); }
1064       static unsigned long long denorm_min() throw()
1065       { return static_cast<unsigned long long>(0); }
1066
1067       static const bool is_iec559 = false;
1068       static const bool is_bounded = true;
1069       static const bool is_modulo = true;
1070
1071       static const bool traps = __glibcxx_integral_traps;
1072       static const bool tinyness_before = false;
1073       static const float_round_style round_style = round_toward_zero;
1074     };
1075
1076   /// numeric_limits<float> specialization.
1077   template<>
1078     struct numeric_limits<float>
1079     {
1080       static const bool is_specialized = true;
1081
1082       static float min() throw()
1083       { return __FLT_MIN__; }
1084       static float max() throw()
1085       { return __FLT_MAX__; }
1086
1087       static const int digits = __FLT_MANT_DIG__;
1088       static const int digits10 = __FLT_DIG__;
1089       static const bool is_signed = true;
1090       static const bool is_integer = false;
1091       static const bool is_exact = false;
1092       static const int radix = __FLT_RADIX__;
1093       static float epsilon() throw()
1094       { return __FLT_EPSILON__; }
1095       static float round_error() throw()
1096       { return 0.5F; }
1097
1098       static const int min_exponent = __FLT_MIN_EXP__;
1099       static const int min_exponent10 = __FLT_MIN_10_EXP__;
1100       static const int max_exponent = __FLT_MAX_EXP__;
1101       static const int max_exponent10 = __FLT_MAX_10_EXP__;
1102
1103       static const bool has_infinity = __FLT_HAS_INFINITY__;
1104       static const bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__;
1105       static const bool has_signaling_NaN = has_quiet_NaN;
1106       static const float_denorm_style has_denorm
1107         = bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent;
1108       static const bool has_denorm_loss = __glibcxx_float_has_denorm_loss;
1109
1110       static float infinity() throw()
1111       { return __builtin_huge_valf (); }
1112       static float quiet_NaN() throw()
1113       { return __builtin_nanf (""); }
1114       static float signaling_NaN() throw()
1115       { return __builtin_nansf (""); }
1116       static float denorm_min() throw()
1117       { return __FLT_DENORM_MIN__; }
1118
1119       static const bool is_iec559
1120         = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1121       static const bool is_bounded = true;
1122       static const bool is_modulo = false;
1123
1124       static const bool traps = __glibcxx_float_traps;
1125       static const bool tinyness_before = __glibcxx_float_tinyness_before;
1126       static const float_round_style round_style = round_to_nearest;
1127     };
1128
1129 #undef __glibcxx_float_has_denorm_loss
1130 #undef __glibcxx_float_traps
1131 #undef __glibcxx_float_tinyness_before
1132
1133   /// numeric_limits<double> specialization.
1134   template<>
1135     struct numeric_limits<double>
1136     {
1137       static const bool is_specialized = true;
1138
1139       static double min() throw()
1140       { return __DBL_MIN__; }
1141       static double max() throw()
1142       { return __DBL_MAX__; }
1143
1144       static const int digits = __DBL_MANT_DIG__;
1145       static const int digits10 = __DBL_DIG__;
1146       static const bool is_signed = true;
1147       static const bool is_integer = false;
1148       static const bool is_exact = false;
1149       static const int radix = __FLT_RADIX__;
1150       static double epsilon() throw()
1151       { return __DBL_EPSILON__; }
1152       static double round_error() throw()
1153       { return 0.5; }
1154
1155       static const int min_exponent = __DBL_MIN_EXP__;
1156       static const int min_exponent10 = __DBL_MIN_10_EXP__;
1157       static const int max_exponent = __DBL_MAX_EXP__;
1158       static const int max_exponent10 = __DBL_MAX_10_EXP__;
1159
1160       static const bool has_infinity = __DBL_HAS_INFINITY__;
1161       static const bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__;
1162       static const bool has_signaling_NaN = has_quiet_NaN;
1163       static const float_denorm_style has_denorm
1164         = bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent;
1165       static const bool has_denorm_loss = __glibcxx_double_has_denorm_loss;
1166
1167       static double infinity() throw()
1168       { return __builtin_huge_val(); }
1169       static double quiet_NaN() throw()
1170       { return __builtin_nan (""); }
1171       static double signaling_NaN() throw()
1172       { return __builtin_nans (""); }
1173       static double denorm_min() throw()
1174       { return __DBL_DENORM_MIN__; }
1175
1176       static const bool is_iec559
1177         = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1178       static const bool is_bounded = true;
1179       static const bool is_modulo = false;
1180
1181       static const bool traps = __glibcxx_double_traps;
1182       static const bool tinyness_before = __glibcxx_double_tinyness_before;
1183       static const float_round_style round_style = round_to_nearest;
1184     };
1185
1186 #undef __glibcxx_double_has_denorm_loss
1187 #undef __glibcxx_double_traps
1188 #undef __glibcxx_double_tinyness_before
1189
1190   /// numeric_limits<long double> specialization.
1191   template<>
1192     struct numeric_limits<long double>
1193     {
1194       static const bool is_specialized = true;
1195
1196       static long double min() throw()
1197       { return __LDBL_MIN__; }
1198       static long double max() throw()
1199       { return __LDBL_MAX__; }
1200
1201       static const int digits = __LDBL_MANT_DIG__;
1202       static const int digits10 = __LDBL_DIG__;
1203       static const bool is_signed = true;
1204       static const bool is_integer = false;
1205       static const bool is_exact = false;
1206       static const int radix = __FLT_RADIX__;
1207       static long double epsilon() throw()
1208       { return __LDBL_EPSILON__; }
1209       static long double round_error() throw()
1210       { return 0.5L; }
1211
1212       static const int min_exponent = __LDBL_MIN_EXP__;
1213       static const int min_exponent10 = __LDBL_MIN_10_EXP__;
1214       static const int max_exponent = __LDBL_MAX_EXP__;
1215       static const int max_exponent10 = __LDBL_MAX_10_EXP__;
1216
1217       static const bool has_infinity = __LDBL_HAS_INFINITY__;
1218       static const bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__;
1219       static const bool has_signaling_NaN = has_quiet_NaN;
1220       static const float_denorm_style has_denorm
1221         = bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent;
1222       static const bool has_denorm_loss
1223         = __glibcxx_long_double_has_denorm_loss;
1224
1225       static long double infinity() throw()
1226       { return __builtin_huge_vall (); }
1227       static long double quiet_NaN() throw()
1228       { return __builtin_nanl (""); }
1229       static long double signaling_NaN() throw()
1230       { return __builtin_nansl (""); }
1231       static long double denorm_min() throw()
1232       { return __LDBL_DENORM_MIN__; }
1233
1234       static const bool is_iec559
1235         = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
1236       static const bool is_bounded = true;
1237       static const bool is_modulo = false;
1238
1239       static const bool traps = __glibcxx_long_double_traps;
1240       static const bool tinyness_before = __glibcxx_long_double_tinyness_before;
1241       static const float_round_style round_style = round_to_nearest;
1242     };
1243
1244 #undef __glibcxx_long_double_has_denorm_loss
1245 #undef __glibcxx_long_double_traps
1246 #undef __glibcxx_long_double_tinyness_before
1247
1248 _GLIBCXX_END_NAMESPACE
1249
1250 #undef __glibcxx_signed
1251 #undef __glibcxx_min
1252 #undef __glibcxx_max
1253 #undef __glibcxx_digits
1254 #undef __glibcxx_digits10
1255
1256 #endif // _GLIBCXX_NUMERIC_LIMITS