libstdc++-v3/include/std/std_limits.h

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