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