limits

Go to the documentation of this file.
00001 // The template and inlines for the -*- C++ -*- numeric_limits classes.
00002 
00003 // Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
00004 //
00005 // This file is part of the GNU ISO C++ Library.  This library is free
00006 // software; you can redistribute it and/or modify it under the
00007 // terms of the GNU General Public License as published by the
00008 // Free Software Foundation; either version 2, or (at your option)
00009 // any later version.
00010 
00011 // This library is distributed in the hope that it will be useful,
00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014 // GNU General Public License for more details.
00015 
00016 // You should have received a copy of the GNU General Public License along
00017 // with this library; see the file COPYING.  If not, write to the Free
00018 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
00019 // USA.
00020 
00021 // As a special exception, you may use this file as part of a free software
00022 // library without restriction.  Specifically, if other files instantiate
00023 // templates or use macros or inline functions from this file, or you compile
00024 // this file and link it with other files to produce an executable, this
00025 // file does not by itself cause the resulting executable to be covered by
00026 // the GNU General Public License.  This exception does not however
00027 // invalidate any other reasons why the executable file might be covered by
00028 // the GNU General Public License.
00029 
00030 // Note: this is not a conforming implementation.
00031 // Written by Gabriel Dos Reis <gdr@codesourcery.com>
00032 
00033 //
00034 // ISO 14882:1998
00035 // 18.2.1
00036 //
00037 
00038 /** @file limits
00039  *  This is a Standard C++ Library header.  You should @c #include this header
00040  *  in your programs, rather than any of the "st[dl]_*.h" implementation files.
00041  */
00042 
00043 #ifndef _CPP_NUMERIC_LIMITS
00044 #define _CPP_NUMERIC_LIMITS 1
00045 
00046 #pragma GCC system_header
00047 
00048 #include <bits/c++config.h>
00049 
00050 //
00051 // The numeric_limits<> traits document implementation-defined aspects
00052 // of fundamental arithmetic data types (integers and floating points).
00053 // From Standard C++ point of view, there are 13 such types:
00054 //   * integers
00055 //         bool                             (1)
00056 //         char, signed char, unsigned char         (3)
00057 //         short, unsigned short                (2)
00058 //         int, unsigned                    (2)
00059 //         long, unsigned long                  (2)
00060 //
00061 //   * floating points
00062 //         float                        (1)
00063 //         double                       (1)
00064 //         long double                      (1)
00065 //
00066 // GNU C++ undertstands (where supported by the host C-library)
00067 //   * integer
00068 //         long long, unsigned long long            (2)
00069 //
00070 // which brings us to 15 fundamental arithmetic data types in GNU C++.
00071 //
00072 //
00073 // Since a numeric_limits<> is a bit tricky to get right, we rely on
00074 // an interface composed of macros which should be defined in config/os
00075 // or config/cpu when they differ from the generic (read arbitrary)
00076 // definitions given here.
00077 //
00078 
00079 // These values can be overridden in the target configuration file.
00080 // The default values are appropriate for many 32-bit targets.
00081 
00082 // GCC only intrinsicly supports modulo integral types.  The only remaining
00083 // integral exceptional values is division by zero.  Only targets that do not
00084 // signal division by zero in some "hard to ignore" way should use false.
00085 #ifndef __glibcpp_integral_traps
00086 # define __glibcpp_integral_traps true
00087 #endif
00088 
00089 // float
00090 //
00091 
00092 // Default values.  Should be overriden in configuration files if necessary.
00093 
00094 #ifndef __glibcpp_float_has_denorm_loss
00095 #  define __glibcpp_float_has_denorm_loss false
00096 #endif
00097 #ifndef __glibcpp_float_traps
00098 #  define __glibcpp_float_traps false
00099 #endif
00100 #ifndef __glibcpp_float_tinyness_before
00101 #  define __glibcpp_float_tinyness_before false
00102 #endif
00103 
00104 // double
00105 
00106 // Default values.  Should be overriden in configuration files if necessary.
00107 
00108 #ifndef __glibcpp_double_has_denorm_loss
00109 #  define __glibcpp_double_has_denorm_loss false
00110 #endif
00111 #ifndef __glibcpp_double_traps
00112 #  define __glibcpp_double_traps false
00113 #endif
00114 #ifndef __glibcpp_double_tinyness_before
00115 #  define __glibcpp_double_tinyness_before false
00116 #endif
00117 
00118 // long double
00119 
00120 // Default values.  Should be overriden in configuration files if necessary.
00121 
00122 #ifndef __glibcpp_long_double_has_denorm_loss
00123 #  define __glibcpp_long_double_has_denorm_loss false
00124 #endif
00125 #ifndef __glibcpp_long_double_traps
00126 #  define __glibcpp_long_double_traps false
00127 #endif
00128 #ifndef __glibcpp_long_double_tinyness_before
00129 #  define __glibcpp_long_double_tinyness_before false
00130 #endif
00131 
00132 // You should not need to define any macros below this point.
00133 
00134 #define __glibcpp_signed(T) ((T)(-1) < 0)
00135 
00136 #define __glibcpp_min(T) \
00137   (__glibcpp_signed (T) ? (T)1 << __glibcpp_digits (T) : (T)0)
00138 
00139 #define __glibcpp_max(T) \
00140   (__glibcpp_signed (T) ? ((T)1 << __glibcpp_digits (T)) - 1 : ~(T)0)
00141 
00142 #define __glibcpp_digits(T) \
00143   (sizeof(T) * __CHAR_BIT__ - __glibcpp_signed (T))
00144 
00145 // The fraction 643/2136 approximates log10(2) to 7 significant digits.
00146 #define __glibcpp_digits10(T) \
00147   (__glibcpp_digits (T) * 643 / 2136)
00148 
00149 
00150 namespace std
00151 {
00152   enum float_round_style
00153   {
00154     round_indeterminate       = -1,
00155     round_toward_zero         = 0,
00156     round_to_nearest          = 1,
00157     round_toward_infinity     = 2,
00158     round_toward_neg_infinity = 3
00159   };
00160 
00161   enum float_denorm_style
00162   {
00163     denorm_indeterminate = -1,
00164     denorm_absent        = 0,
00165     denorm_present       = 1
00166   };
00167 
00168   //
00169   // The primary class traits
00170   //
00171   struct __numeric_limits_base
00172   {
00173     static const bool is_specialized = false;
00174 
00175     static const int digits = 0;
00176     static const int digits10 = 0;
00177     static const bool is_signed = false;
00178     static const bool is_integer = false;
00179     static const bool is_exact = false;
00180     static const int radix = 0;
00181 
00182     static const int min_exponent = 0;
00183     static const int min_exponent10 = 0;
00184     static const int max_exponent = 0;
00185     static const int max_exponent10 = 0;
00186 
00187     static const bool has_infinity = false;
00188     static const bool has_quiet_NaN = false;
00189     static const bool has_signaling_NaN = false;
00190     static const float_denorm_style has_denorm = denorm_absent;
00191     static const bool has_denorm_loss = false;
00192 
00193     static const bool is_iec559 = false;
00194     static const bool is_bounded = false;
00195     static const bool is_modulo = false;
00196 
00197     static const bool traps = false;
00198     static const bool tinyness_before = false;
00199     static const float_round_style round_style = round_toward_zero;
00200   };
00201 
00202   template<typename _Tp>
00203     struct numeric_limits : public __numeric_limits_base
00204     {
00205       static _Tp min() throw() { return static_cast<_Tp>(0); }
00206       static _Tp max() throw() { return static_cast<_Tp>(0); }
00207       static _Tp epsilon() throw() { return static_cast<_Tp>(0); }
00208       static _Tp round_error() throw() { return static_cast<_Tp>(0); }
00209       static _Tp infinity() throw()  { return static_cast<_Tp>(0); }
00210       static _Tp quiet_NaN() throw() { return static_cast<_Tp>(0); }
00211       static _Tp signaling_NaN() throw() { return static_cast<_Tp>(0); }
00212       static _Tp denorm_min() throw() { return static_cast<_Tp>(0); }
00213     };
00214 
00215   // Now there follow 15 explicit specializations.  Yes, 15.  Make sure
00216   // you get the count right.
00217   template<>
00218     struct numeric_limits<bool>
00219     {
00220       static const bool is_specialized = true;
00221 
00222       static bool min() throw()
00223       { return false; }
00224       static bool max() throw()
00225       { return true; }
00226 
00227       static const int digits = 1;
00228       static const int digits10 = 0;
00229       static const bool is_signed = false;
00230       static const bool is_integer = true;
00231       static const bool is_exact = true;
00232       static const int radix = 2;
00233       static bool epsilon() throw()
00234       { return false; }
00235       static bool round_error() throw()
00236       { return false; }
00237 
00238       static const int min_exponent = 0;
00239       static const int min_exponent10 = 0;
00240       static const int max_exponent = 0;
00241       static const int max_exponent10 = 0;
00242 
00243       static const bool has_infinity = false;
00244       static const bool has_quiet_NaN = false;
00245       static const bool has_signaling_NaN = false;
00246       static const float_denorm_style has_denorm = denorm_absent;
00247       static const bool has_denorm_loss = false;
00248 
00249       static bool infinity() throw()
00250       { return false; }
00251       static bool quiet_NaN() throw()
00252       { return false; }
00253       static bool signaling_NaN() throw()
00254       { return false; }
00255       static bool denorm_min() throw()
00256       { return false; }
00257 
00258       static const bool is_iec559 = false;
00259       static const bool is_bounded = true;
00260       static const bool is_modulo = false;
00261 
00262       // It is not clear what it means for a boolean type to trap.
00263       // This is a DR on the LWG issue list.  Here, I use integer
00264       // promotion semantics.
00265       static const bool traps = __glibcpp_integral_traps;
00266       static const bool tinyness_before = false;
00267       static const float_round_style round_style = round_toward_zero;
00268     };
00269 
00270   template<>
00271     struct numeric_limits<char>
00272     {
00273       static const bool is_specialized = true;
00274 
00275       static char min() throw()
00276       { return __glibcpp_min(char); }
00277       static char max() throw()
00278       { return __glibcpp_max(char); }
00279 
00280       static const int digits = __glibcpp_digits (char);
00281       static const int digits10 = __glibcpp_digits10 (char);
00282       static const bool is_signed = __glibcpp_signed (char);
00283       static const bool is_integer = true;
00284       static const bool is_exact = true;
00285       static const int radix = 2;
00286       static char epsilon() throw()
00287       { return 0; }
00288       static char round_error() throw()
00289       { return 0; }
00290 
00291       static const int min_exponent = 0;
00292       static const int min_exponent10 = 0;
00293       static const int max_exponent = 0;
00294       static const int max_exponent10 = 0;
00295 
00296       static const bool has_infinity = false;
00297       static const bool has_quiet_NaN = false;
00298       static const bool has_signaling_NaN = false;
00299       static const float_denorm_style has_denorm = denorm_absent;
00300       static const bool has_denorm_loss = false;
00301 
00302       static char infinity() throw()
00303       { return char(); }
00304       static char quiet_NaN() throw()
00305       { return char(); }
00306       static char signaling_NaN() throw()
00307       { return char(); }
00308       static char denorm_min() throw()
00309       { return static_cast<char>(0); }
00310 
00311       static const bool is_iec559 = false;
00312       static const bool is_bounded = true;
00313       static const bool is_modulo = true;
00314 
00315       static const bool traps = __glibcpp_integral_traps;
00316       static const bool tinyness_before = false;
00317       static const float_round_style round_style = round_toward_zero;
00318     };
00319 
00320   template<>
00321     struct numeric_limits<signed char>
00322     {
00323       static const bool is_specialized = true;
00324 
00325       static signed char min() throw()
00326       { return -__SCHAR_MAX__ - 1; }
00327       static signed char max() throw()
00328       { return __SCHAR_MAX__; }
00329 
00330       static const int digits = __glibcpp_digits (signed char);
00331       static const int digits10 = __glibcpp_digits10 (signed char);
00332       static const bool is_signed = true;
00333       static const bool is_integer = true;
00334       static const bool is_exact = true;
00335       static const int radix = 2;
00336       static signed char epsilon() throw()
00337       { return 0; }
00338       static signed char round_error() throw()
00339       { return 0; }
00340 
00341       static const int min_exponent = 0;
00342       static const int min_exponent10 = 0;
00343       static const int max_exponent = 0;
00344       static const int max_exponent10 = 0;
00345 
00346       static const bool has_infinity = false;
00347       static const bool has_quiet_NaN = false;
00348       static const bool has_signaling_NaN = false;
00349       static const float_denorm_style has_denorm = denorm_absent;
00350       static const bool has_denorm_loss = false;
00351 
00352       static signed char infinity() throw()
00353       { return static_cast<signed char>(0); }
00354       static signed char quiet_NaN() throw()
00355       { return static_cast<signed char>(0); }
00356       static signed char signaling_NaN() throw()
00357       { return static_cast<signed char>(0); }
00358       static signed char denorm_min() throw()
00359       { return static_cast<signed char>(0); }
00360 
00361       static const bool is_iec559 = false;
00362       static const bool is_bounded = true;
00363       static const bool is_modulo = true;
00364 
00365       static const bool traps = __glibcpp_integral_traps;
00366       static const bool tinyness_before = false;
00367       static const float_round_style round_style = round_toward_zero;
00368     };
00369 
00370   template<>
00371     struct numeric_limits<unsigned char>
00372     {
00373       static const bool is_specialized = true;
00374 
00375       static unsigned char min() throw()
00376       { return 0; }
00377       static unsigned char max() throw()
00378       { return __SCHAR_MAX__ * 2U + 1; }
00379 
00380       static const int digits = __glibcpp_digits (unsigned char);
00381       static const int digits10 = __glibcpp_digits10 (unsigned char);
00382       static const bool is_signed = false;
00383       static const bool is_integer = true;
00384       static const bool is_exact = true;
00385       static const int radix = 2;
00386       static unsigned char epsilon() throw()
00387       { return 0; }
00388       static unsigned char round_error() throw()
00389       { return 0; }
00390 
00391       static const int min_exponent = 0;
00392       static const int min_exponent10 = 0;
00393       static const int max_exponent = 0;
00394       static const int max_exponent10 = 0;
00395 
00396       static const bool has_infinity = false;
00397       static const bool has_quiet_NaN = false;
00398       static const bool has_signaling_NaN = false;
00399       static const float_denorm_style has_denorm = denorm_absent;
00400       static const bool has_denorm_loss = false;
00401 
00402       static unsigned char infinity() throw()
00403       { return static_cast<unsigned char>(0); }
00404       static unsigned char quiet_NaN() throw()
00405       { return static_cast<unsigned char>(0); }
00406       static unsigned char signaling_NaN() throw()
00407       { return static_cast<unsigned char>(0); }
00408       static unsigned char denorm_min() throw()
00409       { return static_cast<unsigned char>(0); }
00410 
00411       static const bool is_iec559 = false;
00412       static const bool is_bounded = true;
00413       static const bool is_modulo = true;
00414 
00415       static const bool traps = __glibcpp_integral_traps;
00416       static const bool tinyness_before = false;
00417       static const float_round_style round_style = round_toward_zero;
00418     };
00419 
00420   template<>
00421     struct numeric_limits<wchar_t>
00422     {
00423       static const bool is_specialized = true;
00424 
00425       static wchar_t min() throw()
00426       { return __glibcpp_min (wchar_t); }
00427       static wchar_t max() throw()
00428       { return __glibcpp_max (wchar_t); }
00429 
00430       static const int digits = __glibcpp_digits (wchar_t);
00431       static const int digits10 = __glibcpp_digits10 (wchar_t);
00432       static const bool is_signed = __glibcpp_signed (wchar_t);
00433       static const bool is_integer = true;
00434       static const bool is_exact = true;
00435       static const int radix = 2;
00436       static wchar_t epsilon() throw()
00437       { return 0; }
00438       static wchar_t round_error() throw()
00439       { return 0; }
00440 
00441       static const int min_exponent = 0;
00442       static const int min_exponent10 = 0;
00443       static const int max_exponent = 0;
00444       static const int max_exponent10 = 0;
00445 
00446       static const bool has_infinity = false;
00447       static const bool has_quiet_NaN = false;
00448       static const bool has_signaling_NaN = false;
00449       static const float_denorm_style has_denorm = denorm_absent;
00450       static const bool has_denorm_loss = false;
00451 
00452       static wchar_t infinity() throw()
00453       { return wchar_t(); }
00454       static wchar_t quiet_NaN() throw()
00455       { return wchar_t(); }
00456       static wchar_t signaling_NaN() throw()
00457       { return wchar_t(); }
00458       static wchar_t denorm_min() throw()
00459       { return wchar_t(); }
00460 
00461       static const bool is_iec559 = false;
00462       static const bool is_bounded = true;
00463       static const bool is_modulo = true;
00464 
00465       static const bool traps = __glibcpp_integral_traps;
00466       static const bool tinyness_before = false;
00467       static const float_round_style round_style = round_toward_zero;
00468     };
00469 
00470   template<>
00471     struct numeric_limits<short>
00472     {
00473       static const bool is_specialized = true;
00474 
00475       static short min() throw()
00476       { return -__SHRT_MAX__ - 1; }
00477       static short max() throw()
00478       { return __SHRT_MAX__; }
00479 
00480       static const int digits = __glibcpp_digits (short);
00481       static const int digits10 = __glibcpp_digits10 (short);
00482       static const bool is_signed = true;
00483       static const bool is_integer = true;
00484       static const bool is_exact = true;
00485       static const int radix = 2;
00486       static short epsilon() throw()
00487       { return 0; }
00488       static short round_error() throw()
00489       { return 0; }
00490 
00491       static const int min_exponent = 0;
00492       static const int min_exponent10 = 0;
00493       static const int max_exponent = 0;
00494       static const int max_exponent10 = 0;
00495 
00496       static const bool has_infinity = false;
00497       static const bool has_quiet_NaN = false;
00498       static const bool has_signaling_NaN = false;
00499       static const float_denorm_style has_denorm = denorm_absent;
00500       static const bool has_denorm_loss = false;
00501 
00502       static short infinity() throw()
00503       { return short(); }
00504       static short quiet_NaN() throw()
00505       { return short(); }
00506       static short signaling_NaN() throw()
00507       { return short(); }
00508       static short denorm_min() throw()
00509       { return short(); }
00510 
00511       static const bool is_iec559 = false;
00512       static const bool is_bounded = true;
00513       static const bool is_modulo = true;
00514 
00515       static const bool traps = __glibcpp_integral_traps;
00516       static const bool tinyness_before = false;
00517       static const float_round_style round_style = round_toward_zero;
00518     };
00519 
00520   template<>
00521     struct numeric_limits<unsigned short>
00522     {
00523       static const bool is_specialized = true;
00524 
00525       static unsigned short min() throw()
00526       { return 0; }
00527       static unsigned short max() throw()
00528       { return __SHRT_MAX__ * 2U + 1; }
00529 
00530       static const int digits = __glibcpp_digits (unsigned short);
00531       static const int digits10 = __glibcpp_digits10 (unsigned short);
00532       static const bool is_signed = false;
00533       static const bool is_integer = true;
00534       static const bool is_exact = true;
00535       static const int radix = 2;
00536       static unsigned short epsilon() throw()
00537       { return 0; }
00538       static unsigned short round_error() throw()
00539       { return 0; }
00540 
00541       static const int min_exponent = 0;
00542       static const int min_exponent10 = 0;
00543       static const int max_exponent = 0;
00544       static const int max_exponent10 = 0;
00545 
00546       static const bool has_infinity = false;
00547       static const bool has_quiet_NaN = false;
00548       static const bool has_signaling_NaN = false;
00549       static const float_denorm_style has_denorm = denorm_absent;
00550       static const bool has_denorm_loss = false;
00551 
00552       static unsigned short infinity() throw()
00553       { return static_cast<unsigned short>(0); }
00554       static unsigned short quiet_NaN() throw()
00555       { return static_cast<unsigned short>(0); }
00556       static unsigned short signaling_NaN() throw()
00557       { return static_cast<unsigned short>(0); }
00558       static unsigned short denorm_min() throw()
00559       { return static_cast<unsigned short>(0); }
00560 
00561       static const bool is_iec559 = false;
00562       static const bool is_bounded = true;
00563       static const bool is_modulo = true;
00564 
00565       static const bool traps = __glibcpp_integral_traps;
00566       static const bool tinyness_before = false;
00567       static const float_round_style round_style = round_toward_zero;
00568     };
00569 
00570   template<>
00571     struct numeric_limits<int>
00572     {
00573       static const bool is_specialized = true;
00574 
00575       static int min() throw()
00576       { return -__INT_MAX__ - 1; }
00577       static int max() throw()
00578       { return __INT_MAX__; }
00579 
00580       static const int digits = __glibcpp_digits (int);
00581       static const int digits10 = __glibcpp_digits10 (int);
00582       static const bool is_signed = true;
00583       static const bool is_integer = true;
00584       static const bool is_exact = true;
00585       static const int radix = 2;
00586       static int epsilon() throw()
00587       { return 0; }
00588       static int round_error() throw()
00589       { return 0; }
00590 
00591       static const int min_exponent = 0;
00592       static const int min_exponent10 = 0;
00593       static const int max_exponent = 0;
00594       static const int max_exponent10 = 0;
00595 
00596       static const bool has_infinity = false;
00597       static const bool has_quiet_NaN = false;
00598       static const bool has_signaling_NaN = false;
00599       static const float_denorm_style has_denorm = denorm_absent;
00600       static const bool has_denorm_loss = false;
00601 
00602       static int infinity() throw()
00603       { return static_cast<int>(0); }
00604       static int quiet_NaN() throw()
00605       { return static_cast<int>(0); }
00606       static int signaling_NaN() throw()
00607       { return static_cast<int>(0); }
00608       static int denorm_min() throw()
00609       { return static_cast<int>(0); }
00610 
00611       static const bool is_iec559 = false;
00612       static const bool is_bounded = true;
00613       static const bool is_modulo = true;
00614 
00615       static const bool traps = __glibcpp_integral_traps;
00616       static const bool tinyness_before = false;
00617       static const float_round_style round_style = round_toward_zero;
00618     };
00619 
00620   template<>
00621     struct numeric_limits<unsigned int>
00622     {
00623       static const bool is_specialized = true;
00624 
00625       static unsigned int min() throw()
00626       { return 0; }
00627       static unsigned int max() throw()
00628       { return __INT_MAX__ * 2U + 1; }
00629 
00630       static const int digits = __glibcpp_digits (unsigned int);
00631       static const int digits10 = __glibcpp_digits10 (unsigned int);
00632       static const bool is_signed = false;
00633       static const bool is_integer = true;
00634       static const bool is_exact = true;
00635       static const int radix = 2;
00636       static unsigned int epsilon() throw()
00637       { return 0; }
00638       static unsigned int round_error() throw()
00639       { return 0; }
00640 
00641       static const int min_exponent = 0;
00642       static const int min_exponent10 = 0;
00643       static const int max_exponent = 0;
00644       static const int max_exponent10 = 0;
00645 
00646       static const bool has_infinity = false;
00647       static const bool has_quiet_NaN = false;
00648       static const bool has_signaling_NaN = false;
00649       static const float_denorm_style has_denorm = denorm_absent;
00650       static const bool has_denorm_loss = false;
00651 
00652       static unsigned int infinity() throw()
00653       { return static_cast<unsigned int>(0); }
00654       static unsigned int quiet_NaN() throw()
00655       { return static_cast<unsigned int>(0); }
00656       static unsigned int signaling_NaN() throw()
00657       { return static_cast<unsigned int>(0); }
00658       static unsigned int denorm_min() throw()
00659       { return static_cast<unsigned int>(0); }
00660 
00661       static const bool is_iec559 = false;
00662       static const bool is_bounded = true;
00663       static const bool is_modulo = true;
00664 
00665       static const bool traps = __glibcpp_integral_traps;
00666       static const bool tinyness_before = false;
00667       static const float_round_style round_style = round_toward_zero;
00668     };
00669 
00670   template<>
00671     struct numeric_limits<long>
00672     {
00673       static const bool is_specialized = true;
00674 
00675       static long min() throw()
00676       { return -__LONG_MAX__ - 1; }
00677       static long max() throw()
00678       { return __LONG_MAX__; }
00679 
00680       static const int digits = __glibcpp_digits (long);
00681       static const int digits10 = __glibcpp_digits10 (long);
00682       static const bool is_signed = true;
00683       static const bool is_integer = true;
00684       static const bool is_exact = true;
00685       static const int radix = 2;
00686       static long epsilon() throw()
00687       { return 0; }
00688       static long round_error() throw()
00689       { return 0; }
00690 
00691       static const int min_exponent = 0;
00692       static const int min_exponent10 = 0;
00693       static const int max_exponent = 0;
00694       static const int max_exponent10 = 0;
00695 
00696       static const bool has_infinity = false;
00697       static const bool has_quiet_NaN = false;
00698       static const bool has_signaling_NaN = false;
00699       static const float_denorm_style has_denorm = denorm_absent;
00700       static const bool has_denorm_loss = false;
00701 
00702       static long infinity() throw()
00703       { return static_cast<long>(0); }
00704       static long quiet_NaN() throw()
00705       { return static_cast<long>(0); }
00706       static long signaling_NaN() throw()
00707       { return static_cast<long>(0); }
00708       static long denorm_min() throw()
00709       { return static_cast<long>(0); }
00710 
00711       static const bool is_iec559 = false;
00712       static const bool is_bounded = true;
00713       static const bool is_modulo = true;
00714 
00715       static const bool traps = __glibcpp_integral_traps;
00716       static const bool tinyness_before = false;
00717       static const float_round_style round_style = round_toward_zero;
00718     };
00719 
00720   template<>
00721     struct numeric_limits<unsigned long>
00722     {
00723       static const bool is_specialized = true;
00724 
00725       static unsigned long min() throw()
00726       { return 0; }
00727       static unsigned long max() throw()
00728       { return __LONG_MAX__ * 2UL + 1; }
00729 
00730       static const int digits = __glibcpp_digits (unsigned long);
00731       static const int digits10 = __glibcpp_digits10 (unsigned long);
00732       static const bool is_signed = false;
00733       static const bool is_integer = true;
00734       static const bool is_exact = true;
00735       static const int radix = 2;
00736       static unsigned long epsilon() throw()
00737       { return 0; }
00738       static unsigned long round_error() throw()
00739       { return 0; }
00740 
00741       static const int min_exponent = 0;
00742       static const int min_exponent10 = 0;
00743       static const int max_exponent = 0;
00744       static const int max_exponent10 = 0;
00745 
00746       static const bool has_infinity = false;
00747       static const bool has_quiet_NaN = false;
00748       static const bool has_signaling_NaN = false;
00749       static const float_denorm_style has_denorm = denorm_absent;
00750       static const bool has_denorm_loss = false;
00751 
00752       static unsigned long infinity() throw()
00753       { return static_cast<unsigned long>(0); }
00754       static unsigned long quiet_NaN() throw()
00755       { return static_cast<unsigned long>(0); }
00756       static unsigned long signaling_NaN() throw()
00757       { return static_cast<unsigned long>(0); }
00758       static unsigned long denorm_min() throw()
00759       { return static_cast<unsigned long>(0); }
00760 
00761       static const bool is_iec559 = false;
00762       static const bool is_bounded = true;
00763       static const bool is_modulo = true;
00764 
00765       static const bool traps = __glibcpp_integral_traps;
00766       static const bool tinyness_before = false;
00767       static const float_round_style round_style = round_toward_zero;
00768     };
00769 
00770   template<>
00771     struct numeric_limits<long long>
00772     {
00773       static const bool is_specialized = true;
00774 
00775       static long long min() throw()
00776       { return -__LONG_LONG_MAX__ - 1; }
00777       static long long max() throw()
00778       { return __LONG_LONG_MAX__; }
00779 
00780       static const int digits = __glibcpp_digits (long long);
00781       static const int digits10 = __glibcpp_digits10 (long long);
00782       static const bool is_signed = true;
00783       static const bool is_integer = true;
00784       static const bool is_exact = true;
00785       static const int radix = 2;
00786       static long long epsilon() throw()
00787       { return 0; }
00788       static long long round_error() throw()
00789       { return 0; }
00790 
00791       static const int min_exponent = 0;
00792       static const int min_exponent10 = 0;
00793       static const int max_exponent = 0;
00794       static const int max_exponent10 = 0;
00795 
00796       static const bool has_infinity = false;
00797       static const bool has_quiet_NaN = false;
00798       static const bool has_signaling_NaN = false;
00799       static const float_denorm_style has_denorm = denorm_absent;
00800       static const bool has_denorm_loss = false;
00801 
00802       static long long infinity() throw()
00803       { return static_cast<long long>(0); }
00804       static long long quiet_NaN() throw()
00805       { return static_cast<long long>(0); }
00806       static long long signaling_NaN() throw()
00807       { return static_cast<long long>(0); }
00808       static long long denorm_min() throw()
00809       { return static_cast<long long>(0); }
00810 
00811       static const bool is_iec559 = false;
00812       static const bool is_bounded = true;
00813       static const bool is_modulo = true;
00814 
00815       static const bool traps = __glibcpp_integral_traps;
00816       static const bool tinyness_before = false;
00817       static const float_round_style round_style = round_toward_zero;
00818     };
00819 
00820   template<>
00821     struct numeric_limits<unsigned long long>
00822     {
00823       static const bool is_specialized = true;
00824 
00825       static unsigned long long min() throw()
00826       { return 0; }
00827       static unsigned long long max() throw()
00828       { return __LONG_LONG_MAX__ * 2ULL + 1; }
00829 
00830       static const int digits = __glibcpp_digits (unsigned long long);
00831       static const int digits10 = __glibcpp_digits10 (unsigned long long);
00832       static const bool is_signed = false;
00833       static const bool is_integer = true;
00834       static const bool is_exact = true;
00835       static const int radix = 2;
00836       static unsigned long long epsilon() throw()
00837       { return 0; }
00838       static unsigned long long round_error() throw()
00839       { return 0; }
00840 
00841       static const int min_exponent = 0;
00842       static const int min_exponent10 = 0;
00843       static const int max_exponent = 0;
00844       static const int max_exponent10 = 0;
00845 
00846       static const bool has_infinity = false;
00847       static const bool has_quiet_NaN = false;
00848       static const bool has_signaling_NaN = false;
00849       static const float_denorm_style has_denorm = denorm_absent;
00850       static const bool has_denorm_loss = false;
00851 
00852       static unsigned long long infinity() throw()
00853       { return static_cast<unsigned long long>(0); }
00854       static unsigned long long quiet_NaN() throw()
00855       { return static_cast<unsigned long long>(0); }
00856       static unsigned long long signaling_NaN() throw()
00857       { return static_cast<unsigned long long>(0); }
00858       static unsigned long long denorm_min() throw()
00859       { return static_cast<unsigned long long>(0); }
00860 
00861       static const bool is_iec559 = false;
00862       static const bool is_bounded = true;
00863       static const bool is_modulo = true;
00864 
00865       static const bool traps = __glibcpp_integral_traps;
00866       static const bool tinyness_before = false;
00867       static const float_round_style round_style = round_toward_zero;
00868     };
00869 
00870   template<>
00871     struct numeric_limits<float>
00872     {
00873       static const bool is_specialized = true;
00874 
00875       static float min() throw()
00876       { return __FLT_MIN__; }
00877       static float max() throw()
00878       { return __FLT_MAX__; }
00879 
00880       static const int digits = __FLT_MANT_DIG__;
00881       static const int digits10 = __FLT_DIG__;
00882       static const bool is_signed = true;
00883       static const bool is_integer = false;
00884       static const bool is_exact = false;
00885       static const int radix = __FLT_RADIX__;
00886       static float epsilon() throw()
00887       { return __FLT_EPSILON__; }
00888       static float round_error() throw()
00889       { return 0.5F; }
00890 
00891       static const int min_exponent = __FLT_MIN_EXP__;
00892       static const int min_exponent10 = __FLT_MIN_10_EXP__;
00893       static const int max_exponent = __FLT_MAX_EXP__;
00894       static const int max_exponent10 = __FLT_MAX_10_EXP__;
00895 
00896       static const bool has_infinity
00897     = __builtin_huge_valf () / 2 == __builtin_huge_valf ();
00898       static const bool has_quiet_NaN
00899     = __builtin_nanf ("") != __builtin_nanf ("");
00900       static const bool has_signaling_NaN = has_quiet_NaN;
00901       static const float_denorm_style has_denorm
00902     = __FLT_DENORM_MIN__ ? denorm_present : denorm_absent;
00903       static const bool has_denorm_loss = __glibcpp_float_has_denorm_loss;
00904 
00905       static float infinity() throw()
00906       { return __builtin_huge_valf (); }
00907       static float quiet_NaN() throw()
00908       { return __builtin_nanf (""); }
00909       static float signaling_NaN() throw()
00910       { return __builtin_nansf (""); }
00911       static float denorm_min() throw()
00912       { return __FLT_DENORM_MIN__; }
00913 
00914       static const bool is_iec559
00915     = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
00916       static const bool is_bounded = true;
00917       static const bool is_modulo = false;
00918 
00919       static const bool traps = __glibcpp_float_traps;
00920       static const bool tinyness_before = __glibcpp_float_tinyness_before;
00921       static const float_round_style round_style = round_to_nearest;
00922     };
00923 
00924 #undef __glibcpp_float_has_denorm_loss
00925 #undef __glibcpp_float_traps
00926 #undef __glibcpp_float_tinyness_before
00927 
00928   template<>
00929     struct numeric_limits<double>
00930     {
00931       static const bool is_specialized = true;
00932 
00933       static double min() throw()
00934       { return __DBL_MIN__; }
00935       static double max() throw()
00936       { return __DBL_MAX__; }
00937 
00938       static const int digits = __DBL_MANT_DIG__;
00939       static const int digits10 = __DBL_DIG__;
00940       static const bool is_signed = true;
00941       static const bool is_integer = false;
00942       static const bool is_exact = false;
00943       static const int radix = __FLT_RADIX__;
00944       static double epsilon() throw()
00945       { return __DBL_EPSILON__; }
00946       static double round_error() throw()
00947       { return 0.5; }
00948 
00949       static const int min_exponent = __DBL_MIN_EXP__;
00950       static const int min_exponent10 = __DBL_MIN_10_EXP__;
00951       static const int max_exponent = __DBL_MAX_EXP__;
00952       static const int max_exponent10 = __DBL_MAX_10_EXP__;
00953 
00954       static const bool has_infinity
00955     = __builtin_huge_val () / 2 == __builtin_huge_val ();
00956       static const bool has_quiet_NaN
00957     = __builtin_nan ("") != __builtin_nan ("");
00958       static const bool has_signaling_NaN = has_quiet_NaN;
00959       static const float_denorm_style has_denorm
00960     = __DBL_DENORM_MIN__ ? denorm_present : denorm_absent;
00961       static const bool has_denorm_loss = __glibcpp_double_has_denorm_loss;
00962 
00963       static double infinity() throw()
00964       { return __builtin_huge_val(); }
00965       static double quiet_NaN() throw()
00966       { return __builtin_nan (""); }
00967       static double signaling_NaN() throw()
00968       { return __builtin_nans (""); }
00969       static double denorm_min() throw()
00970       { return __DBL_DENORM_MIN__; }
00971 
00972       static const bool is_iec559
00973     = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
00974       static const bool is_bounded = true;
00975       static const bool is_modulo = false;
00976 
00977       static const bool traps = __glibcpp_double_traps;
00978       static const bool tinyness_before = __glibcpp_double_tinyness_before;
00979       static const float_round_style round_style = round_to_nearest;
00980     };
00981 
00982 #undef __glibcpp_double_has_denorm_loss
00983 #undef __glibcpp_double_traps
00984 #undef __glibcpp_double_tinyness_before
00985 
00986   template<>
00987     struct numeric_limits<long double>
00988     {
00989       static const bool is_specialized = true;
00990 
00991       static long double min() throw()
00992       { return __LDBL_MIN__; }
00993       static long double max() throw()
00994       { return __LDBL_MAX__; }
00995 
00996       static const int digits = __LDBL_MANT_DIG__;
00997       static const int digits10 = __LDBL_DIG__;
00998       static const bool is_signed = true;
00999       static const bool is_integer = false;
01000       static const bool is_exact = false;
01001       static const int radix = __FLT_RADIX__;
01002       static long double epsilon() throw()
01003       { return __LDBL_EPSILON__; }
01004       static long double round_error() throw()
01005       { return 0.5L; }
01006 
01007       static const int min_exponent = __LDBL_MIN_EXP__;
01008       static const int min_exponent10 = __LDBL_MIN_10_EXP__;
01009       static const int max_exponent = __LDBL_MAX_EXP__;
01010       static const int max_exponent10 = __LDBL_MAX_10_EXP__;
01011 
01012       static const bool has_infinity
01013     = __builtin_huge_vall () / 2 == __builtin_huge_vall ();
01014       static const bool has_quiet_NaN
01015     = __builtin_nanl ("") != __builtin_nanl ("");
01016       static const bool has_signaling_NaN = has_quiet_NaN;
01017       static const float_denorm_style has_denorm
01018     = __LDBL_DENORM_MIN__ ? denorm_present : denorm_absent;
01019       static const bool has_denorm_loss
01020     = __glibcpp_long_double_has_denorm_loss;
01021 
01022       static long double infinity() throw()
01023       { return __builtin_huge_vall (); }
01024       static long double quiet_NaN() throw()
01025       { return __builtin_nanl (""); }
01026       static long double signaling_NaN() throw()
01027       { return __builtin_nansl (""); }
01028       static long double denorm_min() throw()
01029       { return __LDBL_DENORM_MIN__; }
01030 
01031       static const bool is_iec559
01032     = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
01033       static const bool is_bounded = true;
01034       static const bool is_modulo = false;
01035 
01036       static const bool traps = __glibcpp_long_double_traps;
01037       static const bool tinyness_before = __glibcpp_long_double_tinyness_before;
01038       static const float_round_style round_style = round_to_nearest;
01039     };
01040 
01041 #undef __glibcpp_long_double_has_denorm_loss
01042 #undef __glibcpp_long_double_traps
01043 #undef __glibcpp_long_double_tinyness_before
01044 
01045 } // namespace std
01046 
01047 #undef __glibcpp_signed
01048 #undef __glibcpp_min
01049 #undef __glibcpp_max
01050 #undef __glibcpp_digits
01051 #undef __glibcpp_digits10
01052 
01053 #endif // _CPP_NUMERIC_LIMITS

Generated on Thu Feb 10 23:22:56 2005 for libstdc++-v3 Source by  doxygen 1.4.0