libstdc++
|
00001 // The template and inlines for the numeric_limits classes. -*- C++ -*- 00002 00003 // Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 00004 // 2008, 2009 Free Software Foundation, Inc. 00005 // 00006 // This file is part of the GNU ISO C++ Library. This library is free 00007 // software; you can redistribute it and/or modify it under the 00008 // terms of the GNU General Public License as published by the 00009 // Free Software Foundation; either version 3, or (at your option) 00010 // any later version. 00011 00012 // This library is distributed in the hope that it will be useful, 00013 // but WITHOUT ANY WARRANTY; without even the implied warranty of 00014 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00015 // GNU General Public License for more details. 00016 00017 // Under Section 7 of GPL version 3, you are granted additional 00018 // permissions described in the GCC Runtime Library Exception, version 00019 // 3.1, as published by the Free Software Foundation. 00020 00021 // You should have received a copy of the GNU General Public License and 00022 // a copy of the GCC Runtime Library Exception along with this program; 00023 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 00024 // <http://www.gnu.org/licenses/>. 00025 00026 /** @file limits 00027 * This is a Standard C++ Library header. 00028 */ 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 #ifndef _GLIBCXX_NUMERIC_LIMITS 00039 #define _GLIBCXX_NUMERIC_LIMITS 1 00040 00041 #pragma GCC system_header 00042 00043 #include <bits/c++config.h> 00044 00045 // 00046 // The numeric_limits<> traits document implementation-defined aspects 00047 // of fundamental arithmetic data types (integers and floating points). 00048 // From Standard C++ point of view, there are 13 such types: 00049 // * integers 00050 // bool (1) 00051 // char, signed char, unsigned char (3) 00052 // short, unsigned short (2) 00053 // int, unsigned (2) 00054 // long, unsigned long (2) 00055 // 00056 // * floating points 00057 // float (1) 00058 // double (1) 00059 // long double (1) 00060 // 00061 // GNU C++ understands (where supported by the host C-library) 00062 // * integer 00063 // long long, unsigned long long (2) 00064 // 00065 // which brings us to 15 fundamental arithmetic data types in GNU C++. 00066 // 00067 // 00068 // Since a numeric_limits<> is a bit tricky to get right, we rely on 00069 // an interface composed of macros which should be defined in config/os 00070 // or config/cpu when they differ from the generic (read arbitrary) 00071 // definitions given here. 00072 // 00073 00074 // These values can be overridden in the target configuration file. 00075 // The default values are appropriate for many 32-bit targets. 00076 00077 // GCC only intrinsically supports modulo integral types. The only remaining 00078 // integral exceptional values is division by zero. Only targets that do not 00079 // signal division by zero in some "hard to ignore" way should use false. 00080 #ifndef __glibcxx_integral_traps 00081 # define __glibcxx_integral_traps true 00082 #endif 00083 00084 // float 00085 // 00086 00087 // Default values. Should be overridden in configuration files if necessary. 00088 00089 #ifndef __glibcxx_float_has_denorm_loss 00090 # define __glibcxx_float_has_denorm_loss false 00091 #endif 00092 #ifndef __glibcxx_float_traps 00093 # define __glibcxx_float_traps false 00094 #endif 00095 #ifndef __glibcxx_float_tinyness_before 00096 # define __glibcxx_float_tinyness_before false 00097 #endif 00098 00099 // double 00100 00101 // Default values. Should be overridden in configuration files if necessary. 00102 00103 #ifndef __glibcxx_double_has_denorm_loss 00104 # define __glibcxx_double_has_denorm_loss false 00105 #endif 00106 #ifndef __glibcxx_double_traps 00107 # define __glibcxx_double_traps false 00108 #endif 00109 #ifndef __glibcxx_double_tinyness_before 00110 # define __glibcxx_double_tinyness_before false 00111 #endif 00112 00113 // long double 00114 00115 // Default values. Should be overridden in configuration files if necessary. 00116 00117 #ifndef __glibcxx_long_double_has_denorm_loss 00118 # define __glibcxx_long_double_has_denorm_loss false 00119 #endif 00120 #ifndef __glibcxx_long_double_traps 00121 # define __glibcxx_long_double_traps false 00122 #endif 00123 #ifndef __glibcxx_long_double_tinyness_before 00124 # define __glibcxx_long_double_tinyness_before false 00125 #endif 00126 00127 // You should not need to define any macros below this point. 00128 00129 #define __glibcxx_signed(T) ((T)(-1) < 0) 00130 00131 #define __glibcxx_min(T) \ 00132 (__glibcxx_signed (T) ? (T)1 << __glibcxx_digits (T) : (T)0) 00133 00134 #define __glibcxx_max(T) \ 00135 (__glibcxx_signed (T) ? \ 00136 (((((T)1 << (__glibcxx_digits (T) - 1)) - 1) << 1) + 1) : ~(T)0) 00137 00138 #define __glibcxx_digits(T) \ 00139 (sizeof(T) * __CHAR_BIT__ - __glibcxx_signed (T)) 00140 00141 // The fraction 643/2136 approximates log10(2) to 7 significant digits. 00142 #define __glibcxx_digits10(T) \ 00143 (__glibcxx_digits (T) * 643 / 2136) 00144 00145 00146 _GLIBCXX_BEGIN_NAMESPACE(std) 00147 00148 /** 00149 * @brief Describes the rounding style for floating-point types. 00150 * 00151 * This is used in the std::numeric_limits class. 00152 */ 00153 enum float_round_style 00154 { 00155 round_indeterminate = -1, ///< Self-explanatory. 00156 round_toward_zero = 0, ///< Self-explanatory. 00157 round_to_nearest = 1, ///< To the nearest representable value. 00158 round_toward_infinity = 2, ///< Self-explanatory. 00159 round_toward_neg_infinity = 3 ///< Self-explanatory. 00160 }; 00161 00162 /** 00163 * @brief Describes the denormalization for floating-point types. 00164 * 00165 * These values represent the presence or absence of a variable number 00166 * of exponent bits. This type is used in the std::numeric_limits class. 00167 */ 00168 enum float_denorm_style 00169 { 00170 /// Indeterminate at compile time whether denormalized values are allowed. 00171 denorm_indeterminate = -1, 00172 /// The type does not allow denormalized values. 00173 denorm_absent = 0, 00174 /// The type allows denormalized values. 00175 denorm_present = 1 00176 }; 00177 00178 /** 00179 * @brief Part of std::numeric_limits. 00180 * 00181 * The @c static @c const members are usable as integral constant 00182 * expressions. 00183 * 00184 * @note This is a separate class for purposes of efficiency; you 00185 * should only access these members as part of an instantiation 00186 * of the std::numeric_limits class. 00187 */ 00188 struct __numeric_limits_base 00189 { 00190 /** This will be true for all fundamental types (which have 00191 specializations), and false for everything else. */ 00192 static const bool is_specialized = false; 00193 00194 /** The number of @c radix digits that be represented without change: for 00195 integer types, the number of non-sign bits in the mantissa; for 00196 floating types, the number of @c radix digits in the mantissa. */ 00197 static const int digits = 0; 00198 /** The number of base 10 digits that can be represented without change. */ 00199 static const int digits10 = 0; 00200 /** True if the type is signed. */ 00201 static const bool is_signed = false; 00202 /** True if the type is integer. 00203 * Is this supposed to be "if the type is integral"? 00204 */ 00205 static const bool is_integer = false; 00206 /** True if the type uses an exact representation. "All integer types are 00207 exact, but not all exact types are integer. For example, rational and 00208 fixed-exponent representations are exact but not integer." 00209 [18.2.1.2]/15 */ 00210 static const bool is_exact = false; 00211 /** For integer types, specifies the base of the representation. For 00212 floating types, specifies the base of the exponent representation. */ 00213 static const int radix = 0; 00214 00215 /** The minimum negative integer such that @c radix raised to the power of 00216 (one less than that integer) is a normalized floating point number. */ 00217 static const int min_exponent = 0; 00218 /** The minimum negative integer such that 10 raised to that power is in 00219 the range of normalized floating point numbers. */ 00220 static const int min_exponent10 = 0; 00221 /** The maximum positive integer such that @c radix raised to the power of 00222 (one less than that integer) is a representable finite floating point 00223 number. */ 00224 static const int max_exponent = 0; 00225 /** The maximum positive integer such that 10 raised to that power is in 00226 the range of representable finite floating point numbers. */ 00227 static const int max_exponent10 = 0; 00228 00229 /** True if the type has a representation for positive infinity. */ 00230 static const bool has_infinity = false; 00231 /** True if the type has a representation for a quiet (non-signaling) 00232 "Not a Number." */ 00233 static const bool has_quiet_NaN = false; 00234 /** True if the type has a representation for a signaling 00235 "Not a Number." */ 00236 static const bool has_signaling_NaN = false; 00237 /** See std::float_denorm_style for more information. */ 00238 static const float_denorm_style has_denorm = denorm_absent; 00239 /** "True if loss of accuracy is detected as a denormalization loss, 00240 rather than as an inexact result." [18.2.1.2]/42 */ 00241 static const bool has_denorm_loss = false; 00242 00243 /** True if-and-only-if the type adheres to the IEC 559 standard, also 00244 known as IEEE 754. (Only makes sense for floating point types.) */ 00245 static const bool is_iec559 = false; 00246 /** "True if the set of values representable by the type is finite. All 00247 built-in types are bounded, this member would be false for arbitrary 00248 precision types." [18.2.1.2]/54 */ 00249 static const bool is_bounded = false; 00250 /** True if the type is @e modulo, that is, if it is possible to add two 00251 positive numbers and have a result that wraps around to a third number 00252 that is less. Typically false for floating types, true for unsigned 00253 integers, and true for signed integers. */ 00254 static const bool is_modulo = false; 00255 00256 /** True if trapping is implemented for this type. */ 00257 static const bool traps = false; 00258 /** True if tininess is detected before rounding. (see IEC 559) */ 00259 static const bool tinyness_before = false; 00260 /** See std::float_round_style for more information. This is only 00261 meaningful for floating types; integer types will all be 00262 round_toward_zero. */ 00263 static const float_round_style round_style = round_toward_zero; 00264 }; 00265 00266 /** 00267 * @brief Properties of fundamental types. 00268 * 00269 * This class allows a program to obtain information about the 00270 * representation of a fundamental type on a given platform. For 00271 * non-fundamental types, the functions will return 0 and the data 00272 * members will all be @c false. 00273 * 00274 * _GLIBCXX_RESOLVE_LIB_DEFECTS: DRs 201 and 184 (hi Gaby!) are 00275 * noted, but not incorporated in this documented (yet). 00276 */ 00277 template<typename _Tp> 00278 struct numeric_limits : public __numeric_limits_base 00279 { 00280 /** The minimum finite value, or for floating types with 00281 denormalization, the minimum positive normalized value. */ 00282 static _Tp min() throw() { return static_cast<_Tp>(0); } 00283 /** The maximum finite value. */ 00284 static _Tp max() throw() { return static_cast<_Tp>(0); } 00285 /** The @e machine @e epsilon: the difference between 1 and the least 00286 value greater than 1 that is representable. */ 00287 static _Tp epsilon() throw() { return static_cast<_Tp>(0); } 00288 /** The maximum rounding error measurement (see LIA-1). */ 00289 static _Tp round_error() throw() { return static_cast<_Tp>(0); } 00290 /** The representation of positive infinity, if @c has_infinity. */ 00291 static _Tp infinity() throw() { return static_cast<_Tp>(0); } 00292 /** The representation of a quiet "Not a Number," if @c has_quiet_NaN. */ 00293 static _Tp quiet_NaN() throw() { return static_cast<_Tp>(0); } 00294 /** The representation of a signaling "Not a Number," if 00295 @c has_signaling_NaN. */ 00296 static _Tp signaling_NaN() throw() { return static_cast<_Tp>(0); } 00297 /** The minimum positive denormalized value. For types where 00298 @c has_denorm is false, this is the minimum positive normalized 00299 value. */ 00300 static _Tp denorm_min() throw() { return static_cast<_Tp>(0); } 00301 }; 00302 00303 // Now there follow 15 explicit specializations. Yes, 15. Make sure 00304 // you get the count right. 00305 00306 /// numeric_limits<bool> specialization. 00307 template<> 00308 struct numeric_limits<bool> 00309 { 00310 static const bool is_specialized = true; 00311 00312 static bool min() throw() 00313 { return false; } 00314 static bool max() throw() 00315 { return true; } 00316 00317 static const int digits = 1; 00318 static const int digits10 = 0; 00319 static const bool is_signed = false; 00320 static const bool is_integer = true; 00321 static const bool is_exact = true; 00322 static const int radix = 2; 00323 static bool epsilon() throw() 00324 { return false; } 00325 static bool round_error() throw() 00326 { return false; } 00327 00328 static const int min_exponent = 0; 00329 static const int min_exponent10 = 0; 00330 static const int max_exponent = 0; 00331 static const int max_exponent10 = 0; 00332 00333 static const bool has_infinity = false; 00334 static const bool has_quiet_NaN = false; 00335 static const bool has_signaling_NaN = false; 00336 static const float_denorm_style has_denorm = denorm_absent; 00337 static const bool has_denorm_loss = false; 00338 00339 static bool infinity() throw() 00340 { return false; } 00341 static bool quiet_NaN() throw() 00342 { return false; } 00343 static bool signaling_NaN() throw() 00344 { return false; } 00345 static bool denorm_min() throw() 00346 { return false; } 00347 00348 static const bool is_iec559 = false; 00349 static const bool is_bounded = true; 00350 static const bool is_modulo = false; 00351 00352 // It is not clear what it means for a boolean type to trap. 00353 // This is a DR on the LWG issue list. Here, I use integer 00354 // promotion semantics. 00355 static const bool traps = __glibcxx_integral_traps; 00356 static const bool tinyness_before = false; 00357 static const float_round_style round_style = round_toward_zero; 00358 }; 00359 00360 /// numeric_limits<char> specialization. 00361 template<> 00362 struct numeric_limits<char> 00363 { 00364 static const bool is_specialized = true; 00365 00366 static char min() throw() 00367 { return __glibcxx_min(char); } 00368 static char max() throw() 00369 { return __glibcxx_max(char); } 00370 00371 static const int digits = __glibcxx_digits (char); 00372 static const int digits10 = __glibcxx_digits10 (char); 00373 static const bool is_signed = __glibcxx_signed (char); 00374 static const bool is_integer = true; 00375 static const bool is_exact = true; 00376 static const int radix = 2; 00377 static char epsilon() throw() 00378 { return 0; } 00379 static char round_error() throw() 00380 { return 0; } 00381 00382 static const int min_exponent = 0; 00383 static const int min_exponent10 = 0; 00384 static const int max_exponent = 0; 00385 static const int max_exponent10 = 0; 00386 00387 static const bool has_infinity = false; 00388 static const bool has_quiet_NaN = false; 00389 static const bool has_signaling_NaN = false; 00390 static const float_denorm_style has_denorm = denorm_absent; 00391 static const bool has_denorm_loss = false; 00392 00393 static char infinity() throw() 00394 { return char(); } 00395 static char quiet_NaN() throw() 00396 { return char(); } 00397 static char signaling_NaN() throw() 00398 { return char(); } 00399 static char denorm_min() throw() 00400 { return static_cast<char>(0); } 00401 00402 static const bool is_iec559 = false; 00403 static const bool is_bounded = true; 00404 static const bool is_modulo = true; 00405 00406 static const bool traps = __glibcxx_integral_traps; 00407 static const bool tinyness_before = false; 00408 static const float_round_style round_style = round_toward_zero; 00409 }; 00410 00411 /// numeric_limits<signed char> specialization. 00412 template<> 00413 struct numeric_limits<signed char> 00414 { 00415 static const bool is_specialized = true; 00416 00417 static signed char min() throw() 00418 { return -__SCHAR_MAX__ - 1; } 00419 static signed char max() throw() 00420 { return __SCHAR_MAX__; } 00421 00422 static const int digits = __glibcxx_digits (signed char); 00423 static const int digits10 = __glibcxx_digits10 (signed char); 00424 static const bool is_signed = true; 00425 static const bool is_integer = true; 00426 static const bool is_exact = true; 00427 static const int radix = 2; 00428 static signed char epsilon() throw() 00429 { return 0; } 00430 static signed char round_error() throw() 00431 { return 0; } 00432 00433 static const int min_exponent = 0; 00434 static const int min_exponent10 = 0; 00435 static const int max_exponent = 0; 00436 static const int max_exponent10 = 0; 00437 00438 static const bool has_infinity = false; 00439 static const bool has_quiet_NaN = false; 00440 static const bool has_signaling_NaN = false; 00441 static const float_denorm_style has_denorm = denorm_absent; 00442 static const bool has_denorm_loss = false; 00443 00444 static signed char infinity() throw() 00445 { return static_cast<signed char>(0); } 00446 static signed char quiet_NaN() throw() 00447 { return static_cast<signed char>(0); } 00448 static signed char signaling_NaN() throw() 00449 { return static_cast<signed char>(0); } 00450 static signed char denorm_min() throw() 00451 { return static_cast<signed char>(0); } 00452 00453 static const bool is_iec559 = false; 00454 static const bool is_bounded = true; 00455 static const bool is_modulo = true; 00456 00457 static const bool traps = __glibcxx_integral_traps; 00458 static const bool tinyness_before = false; 00459 static const float_round_style round_style = round_toward_zero; 00460 }; 00461 00462 /// numeric_limits<unsigned char> specialization. 00463 template<> 00464 struct numeric_limits<unsigned char> 00465 { 00466 static const bool is_specialized = true; 00467 00468 static unsigned char min() throw() 00469 { return 0; } 00470 static unsigned char max() throw() 00471 { return __SCHAR_MAX__ * 2U + 1; } 00472 00473 static const int digits = __glibcxx_digits (unsigned char); 00474 static const int digits10 = __glibcxx_digits10 (unsigned char); 00475 static const bool is_signed = false; 00476 static const bool is_integer = true; 00477 static const bool is_exact = true; 00478 static const int radix = 2; 00479 static unsigned char epsilon() throw() 00480 { return 0; } 00481 static unsigned char round_error() throw() 00482 { return 0; } 00483 00484 static const int min_exponent = 0; 00485 static const int min_exponent10 = 0; 00486 static const int max_exponent = 0; 00487 static const int max_exponent10 = 0; 00488 00489 static const bool has_infinity = false; 00490 static const bool has_quiet_NaN = false; 00491 static const bool has_signaling_NaN = false; 00492 static const float_denorm_style has_denorm = denorm_absent; 00493 static const bool has_denorm_loss = false; 00494 00495 static unsigned char infinity() throw() 00496 { return static_cast<unsigned char>(0); } 00497 static unsigned char quiet_NaN() throw() 00498 { return static_cast<unsigned char>(0); } 00499 static unsigned char signaling_NaN() throw() 00500 { return static_cast<unsigned char>(0); } 00501 static unsigned char denorm_min() throw() 00502 { return static_cast<unsigned char>(0); } 00503 00504 static const bool is_iec559 = false; 00505 static const bool is_bounded = true; 00506 static const bool is_modulo = true; 00507 00508 static const bool traps = __glibcxx_integral_traps; 00509 static const bool tinyness_before = false; 00510 static const float_round_style round_style = round_toward_zero; 00511 }; 00512 00513 /// numeric_limits<wchar_t> specialization. 00514 template<> 00515 struct numeric_limits<wchar_t> 00516 { 00517 static const bool is_specialized = true; 00518 00519 static wchar_t min() throw() 00520 { return __glibcxx_min (wchar_t); } 00521 static wchar_t max() throw() 00522 { return __glibcxx_max (wchar_t); } 00523 00524 static const int digits = __glibcxx_digits (wchar_t); 00525 static const int digits10 = __glibcxx_digits10 (wchar_t); 00526 static const bool is_signed = __glibcxx_signed (wchar_t); 00527 static const bool is_integer = true; 00528 static const bool is_exact = true; 00529 static const int radix = 2; 00530 static wchar_t epsilon() throw() 00531 { return 0; } 00532 static wchar_t round_error() throw() 00533 { return 0; } 00534 00535 static const int min_exponent = 0; 00536 static const int min_exponent10 = 0; 00537 static const int max_exponent = 0; 00538 static const int max_exponent10 = 0; 00539 00540 static const bool has_infinity = false; 00541 static const bool has_quiet_NaN = false; 00542 static const bool has_signaling_NaN = false; 00543 static const float_denorm_style has_denorm = denorm_absent; 00544 static const bool has_denorm_loss = false; 00545 00546 static wchar_t infinity() throw() 00547 { return wchar_t(); } 00548 static wchar_t quiet_NaN() throw() 00549 { return wchar_t(); } 00550 static wchar_t signaling_NaN() throw() 00551 { return wchar_t(); } 00552 static wchar_t denorm_min() throw() 00553 { return wchar_t(); } 00554 00555 static const bool is_iec559 = false; 00556 static const bool is_bounded = true; 00557 static const bool is_modulo = true; 00558 00559 static const bool traps = __glibcxx_integral_traps; 00560 static const bool tinyness_before = false; 00561 static const float_round_style round_style = round_toward_zero; 00562 }; 00563 00564 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 00565 /// numeric_limits<char16_t> specialization. 00566 template<> 00567 struct numeric_limits<char16_t> 00568 { 00569 static const bool is_specialized = true; 00570 00571 static char16_t min() throw() 00572 { return __glibcxx_min (char16_t); } 00573 static char16_t max() throw() 00574 { return __glibcxx_max (char16_t); } 00575 00576 static const int digits = __glibcxx_digits (char16_t); 00577 static const int digits10 = __glibcxx_digits10 (char16_t); 00578 static const bool is_signed = __glibcxx_signed (char16_t); 00579 static const bool is_integer = true; 00580 static const bool is_exact = true; 00581 static const int radix = 2; 00582 static char16_t epsilon() throw() 00583 { return 0; } 00584 static char16_t round_error() throw() 00585 { return 0; } 00586 00587 static const int min_exponent = 0; 00588 static const int min_exponent10 = 0; 00589 static const int max_exponent = 0; 00590 static const int max_exponent10 = 0; 00591 00592 static const bool has_infinity = false; 00593 static const bool has_quiet_NaN = false; 00594 static const bool has_signaling_NaN = false; 00595 static const float_denorm_style has_denorm = denorm_absent; 00596 static const bool has_denorm_loss = false; 00597 00598 static char16_t infinity() throw() 00599 { return char16_t(); } 00600 static char16_t quiet_NaN() throw() 00601 { return char16_t(); } 00602 static char16_t signaling_NaN() throw() 00603 { return char16_t(); } 00604 static char16_t denorm_min() throw() 00605 { return char16_t(); } 00606 00607 static const bool is_iec559 = false; 00608 static const bool is_bounded = true; 00609 static const bool is_modulo = true; 00610 00611 static const bool traps = __glibcxx_integral_traps; 00612 static const bool tinyness_before = false; 00613 static const float_round_style round_style = round_toward_zero; 00614 }; 00615 00616 /// numeric_limits<char32_t> specialization. 00617 template<> 00618 struct numeric_limits<char32_t> 00619 { 00620 static const bool is_specialized = true; 00621 00622 static char32_t min() throw() 00623 { return __glibcxx_min (char32_t); } 00624 static char32_t max() throw() 00625 { return __glibcxx_max (char32_t); } 00626 00627 static const int digits = __glibcxx_digits (char32_t); 00628 static const int digits10 = __glibcxx_digits10 (char32_t); 00629 static const bool is_signed = __glibcxx_signed (char32_t); 00630 static const bool is_integer = true; 00631 static const bool is_exact = true; 00632 static const int radix = 2; 00633 static char32_t epsilon() throw() 00634 { return 0; } 00635 static char32_t round_error() throw() 00636 { return 0; } 00637 00638 static const int min_exponent = 0; 00639 static const int min_exponent10 = 0; 00640 static const int max_exponent = 0; 00641 static const int max_exponent10 = 0; 00642 00643 static const bool has_infinity = false; 00644 static const bool has_quiet_NaN = false; 00645 static const bool has_signaling_NaN = false; 00646 static const float_denorm_style has_denorm = denorm_absent; 00647 static const bool has_denorm_loss = false; 00648 00649 static char32_t infinity() throw() 00650 { return char32_t(); } 00651 static char32_t quiet_NaN() throw() 00652 { return char32_t(); } 00653 static char32_t signaling_NaN() throw() 00654 { return char32_t(); } 00655 static char32_t denorm_min() throw() 00656 { return char32_t(); } 00657 00658 static const bool is_iec559 = false; 00659 static const bool is_bounded = true; 00660 static const bool is_modulo = true; 00661 00662 static const bool traps = __glibcxx_integral_traps; 00663 static const bool tinyness_before = false; 00664 static const float_round_style round_style = round_toward_zero; 00665 }; 00666 #endif 00667 00668 /// numeric_limits<short> specialization. 00669 template<> 00670 struct numeric_limits<short> 00671 { 00672 static const bool is_specialized = true; 00673 00674 static short min() throw() 00675 { return -__SHRT_MAX__ - 1; } 00676 static short max() throw() 00677 { return __SHRT_MAX__; } 00678 00679 static const int digits = __glibcxx_digits (short); 00680 static const int digits10 = __glibcxx_digits10 (short); 00681 static const bool is_signed = true; 00682 static const bool is_integer = true; 00683 static const bool is_exact = true; 00684 static const int radix = 2; 00685 static short epsilon() throw() 00686 { return 0; } 00687 static short round_error() throw() 00688 { return 0; } 00689 00690 static const int min_exponent = 0; 00691 static const int min_exponent10 = 0; 00692 static const int max_exponent = 0; 00693 static const int max_exponent10 = 0; 00694 00695 static const bool has_infinity = false; 00696 static const bool has_quiet_NaN = false; 00697 static const bool has_signaling_NaN = false; 00698 static const float_denorm_style has_denorm = denorm_absent; 00699 static const bool has_denorm_loss = false; 00700 00701 static short infinity() throw() 00702 { return short(); } 00703 static short quiet_NaN() throw() 00704 { return short(); } 00705 static short signaling_NaN() throw() 00706 { return short(); } 00707 static short denorm_min() throw() 00708 { return short(); } 00709 00710 static const bool is_iec559 = false; 00711 static const bool is_bounded = true; 00712 static const bool is_modulo = true; 00713 00714 static const bool traps = __glibcxx_integral_traps; 00715 static const bool tinyness_before = false; 00716 static const float_round_style round_style = round_toward_zero; 00717 }; 00718 00719 /// numeric_limits<unsigned short> specialization. 00720 template<> 00721 struct numeric_limits<unsigned short> 00722 { 00723 static const bool is_specialized = true; 00724 00725 static unsigned short min() throw() 00726 { return 0; } 00727 static unsigned short max() throw() 00728 { return __SHRT_MAX__ * 2U + 1; } 00729 00730 static const int digits = __glibcxx_digits (unsigned short); 00731 static const int digits10 = __glibcxx_digits10 (unsigned short); 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 short epsilon() throw() 00737 { return 0; } 00738 static unsigned short 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 short infinity() throw() 00753 { return static_cast<unsigned short>(0); } 00754 static unsigned short quiet_NaN() throw() 00755 { return static_cast<unsigned short>(0); } 00756 static unsigned short signaling_NaN() throw() 00757 { return static_cast<unsigned short>(0); } 00758 static unsigned short denorm_min() throw() 00759 { return static_cast<unsigned short>(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 = __glibcxx_integral_traps; 00766 static const bool tinyness_before = false; 00767 static const float_round_style round_style = round_toward_zero; 00768 }; 00769 00770 /// numeric_limits<int> specialization. 00771 template<> 00772 struct numeric_limits<int> 00773 { 00774 static const bool is_specialized = true; 00775 00776 static int min() throw() 00777 { return -__INT_MAX__ - 1; } 00778 static int max() throw() 00779 { return __INT_MAX__; } 00780 00781 static const int digits = __glibcxx_digits (int); 00782 static const int digits10 = __glibcxx_digits10 (int); 00783 static const bool is_signed = true; 00784 static const bool is_integer = true; 00785 static const bool is_exact = true; 00786 static const int radix = 2; 00787 static int epsilon() throw() 00788 { return 0; } 00789 static int round_error() throw() 00790 { return 0; } 00791 00792 static const int min_exponent = 0; 00793 static const int min_exponent10 = 0; 00794 static const int max_exponent = 0; 00795 static const int max_exponent10 = 0; 00796 00797 static const bool has_infinity = false; 00798 static const bool has_quiet_NaN = false; 00799 static const bool has_signaling_NaN = false; 00800 static const float_denorm_style has_denorm = denorm_absent; 00801 static const bool has_denorm_loss = false; 00802 00803 static int infinity() throw() 00804 { return static_cast<int>(0); } 00805 static int quiet_NaN() throw() 00806 { return static_cast<int>(0); } 00807 static int signaling_NaN() throw() 00808 { return static_cast<int>(0); } 00809 static int denorm_min() throw() 00810 { return static_cast<int>(0); } 00811 00812 static const bool is_iec559 = false; 00813 static const bool is_bounded = true; 00814 static const bool is_modulo = true; 00815 00816 static const bool traps = __glibcxx_integral_traps; 00817 static const bool tinyness_before = false; 00818 static const float_round_style round_style = round_toward_zero; 00819 }; 00820 00821 /// numeric_limits<unsigned int> specialization. 00822 template<> 00823 struct numeric_limits<unsigned int> 00824 { 00825 static const bool is_specialized = true; 00826 00827 static unsigned int min() throw() 00828 { return 0; } 00829 static unsigned int max() throw() 00830 { return __INT_MAX__ * 2U + 1; } 00831 00832 static const int digits = __glibcxx_digits (unsigned int); 00833 static const int digits10 = __glibcxx_digits10 (unsigned int); 00834 static const bool is_signed = false; 00835 static const bool is_integer = true; 00836 static const bool is_exact = true; 00837 static const int radix = 2; 00838 static unsigned int epsilon() throw() 00839 { return 0; } 00840 static unsigned int round_error() throw() 00841 { return 0; } 00842 00843 static const int min_exponent = 0; 00844 static const int min_exponent10 = 0; 00845 static const int max_exponent = 0; 00846 static const int max_exponent10 = 0; 00847 00848 static const bool has_infinity = false; 00849 static const bool has_quiet_NaN = false; 00850 static const bool has_signaling_NaN = false; 00851 static const float_denorm_style has_denorm = denorm_absent; 00852 static const bool has_denorm_loss = false; 00853 00854 static unsigned int infinity() throw() 00855 { return static_cast<unsigned int>(0); } 00856 static unsigned int quiet_NaN() throw() 00857 { return static_cast<unsigned int>(0); } 00858 static unsigned int signaling_NaN() throw() 00859 { return static_cast<unsigned int>(0); } 00860 static unsigned int denorm_min() throw() 00861 { return static_cast<unsigned int>(0); } 00862 00863 static const bool is_iec559 = false; 00864 static const bool is_bounded = true; 00865 static const bool is_modulo = true; 00866 00867 static const bool traps = __glibcxx_integral_traps; 00868 static const bool tinyness_before = false; 00869 static const float_round_style round_style = round_toward_zero; 00870 }; 00871 00872 /// numeric_limits<long> specialization. 00873 template<> 00874 struct numeric_limits<long> 00875 { 00876 static const bool is_specialized = true; 00877 00878 static long min() throw() 00879 { return -__LONG_MAX__ - 1; } 00880 static long max() throw() 00881 { return __LONG_MAX__; } 00882 00883 static const int digits = __glibcxx_digits (long); 00884 static const int digits10 = __glibcxx_digits10 (long); 00885 static const bool is_signed = true; 00886 static const bool is_integer = true; 00887 static const bool is_exact = true; 00888 static const int radix = 2; 00889 static long epsilon() throw() 00890 { return 0; } 00891 static long round_error() throw() 00892 { return 0; } 00893 00894 static const int min_exponent = 0; 00895 static const int min_exponent10 = 0; 00896 static const int max_exponent = 0; 00897 static const int max_exponent10 = 0; 00898 00899 static const bool has_infinity = false; 00900 static const bool has_quiet_NaN = false; 00901 static const bool has_signaling_NaN = false; 00902 static const float_denorm_style has_denorm = denorm_absent; 00903 static const bool has_denorm_loss = false; 00904 00905 static long infinity() throw() 00906 { return static_cast<long>(0); } 00907 static long quiet_NaN() throw() 00908 { return static_cast<long>(0); } 00909 static long signaling_NaN() throw() 00910 { return static_cast<long>(0); } 00911 static long denorm_min() throw() 00912 { return static_cast<long>(0); } 00913 00914 static const bool is_iec559 = false; 00915 static const bool is_bounded = true; 00916 static const bool is_modulo = true; 00917 00918 static const bool traps = __glibcxx_integral_traps; 00919 static const bool tinyness_before = false; 00920 static const float_round_style round_style = round_toward_zero; 00921 }; 00922 00923 /// numeric_limits<unsigned long> specialization. 00924 template<> 00925 struct numeric_limits<unsigned long> 00926 { 00927 static const bool is_specialized = true; 00928 00929 static unsigned long min() throw() 00930 { return 0; } 00931 static unsigned long max() throw() 00932 { return __LONG_MAX__ * 2UL + 1; } 00933 00934 static const int digits = __glibcxx_digits (unsigned long); 00935 static const int digits10 = __glibcxx_digits10 (unsigned long); 00936 static const bool is_signed = false; 00937 static const bool is_integer = true; 00938 static const bool is_exact = true; 00939 static const int radix = 2; 00940 static unsigned long epsilon() throw() 00941 { return 0; } 00942 static unsigned long round_error() throw() 00943 { return 0; } 00944 00945 static const int min_exponent = 0; 00946 static const int min_exponent10 = 0; 00947 static const int max_exponent = 0; 00948 static const int max_exponent10 = 0; 00949 00950 static const bool has_infinity = false; 00951 static const bool has_quiet_NaN = false; 00952 static const bool has_signaling_NaN = false; 00953 static const float_denorm_style has_denorm = denorm_absent; 00954 static const bool has_denorm_loss = false; 00955 00956 static unsigned long infinity() throw() 00957 { return static_cast<unsigned long>(0); } 00958 static unsigned long quiet_NaN() throw() 00959 { return static_cast<unsigned long>(0); } 00960 static unsigned long signaling_NaN() throw() 00961 { return static_cast<unsigned long>(0); } 00962 static unsigned long denorm_min() throw() 00963 { return static_cast<unsigned long>(0); } 00964 00965 static const bool is_iec559 = false; 00966 static const bool is_bounded = true; 00967 static const bool is_modulo = true; 00968 00969 static const bool traps = __glibcxx_integral_traps; 00970 static const bool tinyness_before = false; 00971 static const float_round_style round_style = round_toward_zero; 00972 }; 00973 00974 /// numeric_limits<long long> specialization. 00975 template<> 00976 struct numeric_limits<long long> 00977 { 00978 static const bool is_specialized = true; 00979 00980 static long long min() throw() 00981 { return -__LONG_LONG_MAX__ - 1; } 00982 static long long max() throw() 00983 { return __LONG_LONG_MAX__; } 00984 00985 static const int digits = __glibcxx_digits (long long); 00986 static const int digits10 = __glibcxx_digits10 (long long); 00987 static const bool is_signed = true; 00988 static const bool is_integer = true; 00989 static const bool is_exact = true; 00990 static const int radix = 2; 00991 static long long epsilon() throw() 00992 { return 0; } 00993 static long long round_error() throw() 00994 { return 0; } 00995 00996 static const int min_exponent = 0; 00997 static const int min_exponent10 = 0; 00998 static const int max_exponent = 0; 00999 static const int max_exponent10 = 0; 01000 01001 static const bool has_infinity = false; 01002 static const bool has_quiet_NaN = false; 01003 static const bool has_signaling_NaN = false; 01004 static const float_denorm_style has_denorm = denorm_absent; 01005 static const bool has_denorm_loss = false; 01006 01007 static long long infinity() throw() 01008 { return static_cast<long long>(0); } 01009 static long long quiet_NaN() throw() 01010 { return static_cast<long long>(0); } 01011 static long long signaling_NaN() throw() 01012 { return static_cast<long long>(0); } 01013 static long long denorm_min() throw() 01014 { return static_cast<long long>(0); } 01015 01016 static const bool is_iec559 = false; 01017 static const bool is_bounded = true; 01018 static const bool is_modulo = true; 01019 01020 static const bool traps = __glibcxx_integral_traps; 01021 static const bool tinyness_before = false; 01022 static const float_round_style round_style = round_toward_zero; 01023 }; 01024 01025 /// numeric_limits<unsigned long long> specialization. 01026 template<> 01027 struct numeric_limits<unsigned long long> 01028 { 01029 static const bool is_specialized = true; 01030 01031 static unsigned long long min() throw() 01032 { return 0; } 01033 static unsigned long long max() throw() 01034 { return __LONG_LONG_MAX__ * 2ULL + 1; } 01035 01036 static const int digits = __glibcxx_digits (unsigned long long); 01037 static const int digits10 = __glibcxx_digits10 (unsigned long long); 01038 static const bool is_signed = false; 01039 static const bool is_integer = true; 01040 static const bool is_exact = true; 01041 static const int radix = 2; 01042 static unsigned long long epsilon() throw() 01043 { return 0; } 01044 static unsigned long long round_error() throw() 01045 { return 0; } 01046 01047 static const int min_exponent = 0; 01048 static const int min_exponent10 = 0; 01049 static const int max_exponent = 0; 01050 static const int max_exponent10 = 0; 01051 01052 static const bool has_infinity = false; 01053 static const bool has_quiet_NaN = false; 01054 static const bool has_signaling_NaN = false; 01055 static const float_denorm_style has_denorm = denorm_absent; 01056 static const bool has_denorm_loss = false; 01057 01058 static unsigned long long infinity() throw() 01059 { return static_cast<unsigned long long>(0); } 01060 static unsigned long long quiet_NaN() throw() 01061 { return static_cast<unsigned long long>(0); } 01062 static unsigned long long signaling_NaN() throw() 01063 { return static_cast<unsigned long long>(0); } 01064 static unsigned long long denorm_min() throw() 01065 { return static_cast<unsigned long long>(0); } 01066 01067 static const bool is_iec559 = false; 01068 static const bool is_bounded = true; 01069 static const bool is_modulo = true; 01070 01071 static const bool traps = __glibcxx_integral_traps; 01072 static const bool tinyness_before = false; 01073 static const float_round_style round_style = round_toward_zero; 01074 }; 01075 01076 /// numeric_limits<float> specialization. 01077 template<> 01078 struct numeric_limits<float> 01079 { 01080 static const bool is_specialized = true; 01081 01082 static float min() throw() 01083 { return __FLT_MIN__; } 01084 static float max() throw() 01085 { return __FLT_MAX__; } 01086 01087 static const int digits = __FLT_MANT_DIG__; 01088 static const int digits10 = __FLT_DIG__; 01089 static const bool is_signed = true; 01090 static const bool is_integer = false; 01091 static const bool is_exact = false; 01092 static const int radix = __FLT_RADIX__; 01093 static float epsilon() throw() 01094 { return __FLT_EPSILON__; } 01095 static float round_error() throw() 01096 { return 0.5F; } 01097 01098 static const int min_exponent = __FLT_MIN_EXP__; 01099 static const int min_exponent10 = __FLT_MIN_10_EXP__; 01100 static const int max_exponent = __FLT_MAX_EXP__; 01101 static const int max_exponent10 = __FLT_MAX_10_EXP__; 01102 01103 static const bool has_infinity = __FLT_HAS_INFINITY__; 01104 static const bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__; 01105 static const bool has_signaling_NaN = has_quiet_NaN; 01106 static const float_denorm_style has_denorm 01107 = bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent; 01108 static const bool has_denorm_loss = __glibcxx_float_has_denorm_loss; 01109 01110 static float infinity() throw() 01111 { return __builtin_huge_valf (); } 01112 static float quiet_NaN() throw() 01113 { return __builtin_nanf (""); } 01114 static float signaling_NaN() throw() 01115 { return __builtin_nansf (""); } 01116 static float denorm_min() throw() 01117 { return __FLT_DENORM_MIN__; } 01118 01119 static const bool is_iec559 01120 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 01121 static const bool is_bounded = true; 01122 static const bool is_modulo = false; 01123 01124 static const bool traps = __glibcxx_float_traps; 01125 static const bool tinyness_before = __glibcxx_float_tinyness_before; 01126 static const float_round_style round_style = round_to_nearest; 01127 }; 01128 01129 #undef __glibcxx_float_has_denorm_loss 01130 #undef __glibcxx_float_traps 01131 #undef __glibcxx_float_tinyness_before 01132 01133 /// numeric_limits<double> specialization. 01134 template<> 01135 struct numeric_limits<double> 01136 { 01137 static const bool is_specialized = true; 01138 01139 static double min() throw() 01140 { return __DBL_MIN__; } 01141 static double max() throw() 01142 { return __DBL_MAX__; } 01143 01144 static const int digits = __DBL_MANT_DIG__; 01145 static const int digits10 = __DBL_DIG__; 01146 static const bool is_signed = true; 01147 static const bool is_integer = false; 01148 static const bool is_exact = false; 01149 static const int radix = __FLT_RADIX__; 01150 static double epsilon() throw() 01151 { return __DBL_EPSILON__; } 01152 static double round_error() throw() 01153 { return 0.5; } 01154 01155 static const int min_exponent = __DBL_MIN_EXP__; 01156 static const int min_exponent10 = __DBL_MIN_10_EXP__; 01157 static const int max_exponent = __DBL_MAX_EXP__; 01158 static const int max_exponent10 = __DBL_MAX_10_EXP__; 01159 01160 static const bool has_infinity = __DBL_HAS_INFINITY__; 01161 static const bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__; 01162 static const bool has_signaling_NaN = has_quiet_NaN; 01163 static const float_denorm_style has_denorm 01164 = bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent; 01165 static const bool has_denorm_loss = __glibcxx_double_has_denorm_loss; 01166 01167 static double infinity() throw() 01168 { return __builtin_huge_val(); } 01169 static double quiet_NaN() throw() 01170 { return __builtin_nan (""); } 01171 static double signaling_NaN() throw() 01172 { return __builtin_nans (""); } 01173 static double denorm_min() throw() 01174 { return __DBL_DENORM_MIN__; } 01175 01176 static const bool is_iec559 01177 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 01178 static const bool is_bounded = true; 01179 static const bool is_modulo = false; 01180 01181 static const bool traps = __glibcxx_double_traps; 01182 static const bool tinyness_before = __glibcxx_double_tinyness_before; 01183 static const float_round_style round_style = round_to_nearest; 01184 }; 01185 01186 #undef __glibcxx_double_has_denorm_loss 01187 #undef __glibcxx_double_traps 01188 #undef __glibcxx_double_tinyness_before 01189 01190 /// numeric_limits<long double> specialization. 01191 template<> 01192 struct numeric_limits<long double> 01193 { 01194 static const bool is_specialized = true; 01195 01196 static long double min() throw() 01197 { return __LDBL_MIN__; } 01198 static long double max() throw() 01199 { return __LDBL_MAX__; } 01200 01201 static const int digits = __LDBL_MANT_DIG__; 01202 static const int digits10 = __LDBL_DIG__; 01203 static const bool is_signed = true; 01204 static const bool is_integer = false; 01205 static const bool is_exact = false; 01206 static const int radix = __FLT_RADIX__; 01207 static long double epsilon() throw() 01208 { return __LDBL_EPSILON__; } 01209 static long double round_error() throw() 01210 { return 0.5L; } 01211 01212 static const int min_exponent = __LDBL_MIN_EXP__; 01213 static const int min_exponent10 = __LDBL_MIN_10_EXP__; 01214 static const int max_exponent = __LDBL_MAX_EXP__; 01215 static const int max_exponent10 = __LDBL_MAX_10_EXP__; 01216 01217 static const bool has_infinity = __LDBL_HAS_INFINITY__; 01218 static const bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__; 01219 static const bool has_signaling_NaN = has_quiet_NaN; 01220 static const float_denorm_style has_denorm 01221 = bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent; 01222 static const bool has_denorm_loss 01223 = __glibcxx_long_double_has_denorm_loss; 01224 01225 static long double infinity() throw() 01226 { return __builtin_huge_vall (); } 01227 static long double quiet_NaN() throw() 01228 { return __builtin_nanl (""); } 01229 static long double signaling_NaN() throw() 01230 { return __builtin_nansl (""); } 01231 static long double denorm_min() throw() 01232 { return __LDBL_DENORM_MIN__; } 01233 01234 static const bool is_iec559 01235 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 01236 static const bool is_bounded = true; 01237 static const bool is_modulo = false; 01238 01239 static const bool traps = __glibcxx_long_double_traps; 01240 static const bool tinyness_before = __glibcxx_long_double_tinyness_before; 01241 static const float_round_style round_style = round_to_nearest; 01242 }; 01243 01244 #undef __glibcxx_long_double_has_denorm_loss 01245 #undef __glibcxx_long_double_traps 01246 #undef __glibcxx_long_double_tinyness_before 01247 01248 _GLIBCXX_END_NAMESPACE 01249 01250 #undef __glibcxx_signed 01251 #undef __glibcxx_min 01252 #undef __glibcxx_max 01253 #undef __glibcxx_digits 01254 #undef __glibcxx_digits10 01255 01256 #endif // _GLIBCXX_NUMERIC_LIMITS