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