00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
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
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085 #ifndef __glibcpp_integral_traps
00086 # define __glibcpp_integral_traps true
00087 #endif
00088
00089
00090
00091
00092
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
00105
00106
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
00119
00120
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
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
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
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
00216
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
00263
00264
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 }
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