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