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