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, 2010 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 include/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 14 such types: 49 // * integers 50 // bool (1) 51 // char, signed char, unsigned char, wchar_t (4) 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 16 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) * 643L / 2136) 144 145 #define __glibcxx_max_digits10(T) \ 146 (2 + (T) * 643L / 2136) 147 148 namespace std _GLIBCXX_VISIBILITY(default) 149 { 150 _GLIBCXX_BEGIN_NAMESPACE_VERSION 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, /// Intermediate. 160 round_toward_zero = 0, /// To zero. 161 round_to_nearest = 1, /// To the nearest representable value. 162 round_toward_infinity = 2, /// To infinity. 163 round_toward_neg_infinity = 3 /// To negative infinity. 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 separate 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 _GLIBCXX_USE_CONSTEXPR 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 _GLIBCXX_USE_CONSTEXPR int digits = 0; 202 203 /** The number of base 10 digits that can be represented without change. */ 204 static _GLIBCXX_USE_CONSTEXPR int digits10 = 0; 205 206 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 207 /** The number of base 10 digits required to ensure that values which 208 differ are always differentiated. */ 209 static constexpr int max_digits10 = 0; 210 #endif 211 212 /** True if the type is signed. */ 213 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 214 215 /** True if the type is integer. 216 * Is this supposed to be <em>if the type is integral?</em> */ 217 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; 218 219 /** True if the type uses an exact representation. <em>All integer types are 220 exact, but not all exact types are integer. For example, rational and 221 fixed-exponent representations are exact but not integer.</em> 222 [18.2.1.2]/15 */ 223 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; 224 225 /** For integer types, specifies the base of the representation. For 226 floating types, specifies the base of the exponent representation. */ 227 static _GLIBCXX_USE_CONSTEXPR int radix = 0; 228 229 /** The minimum negative integer such that @c radix raised to the power of 230 (one less than that integer) is a normalized floating point number. */ 231 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 232 233 /** The minimum negative integer such that 10 raised to that power is in 234 the range of normalized floating point numbers. */ 235 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 236 237 /** The maximum positive integer such that @c radix raised to the power of 238 (one less than that integer) is a representable finite floating point 239 number. */ 240 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 241 242 /** The maximum positive integer such that 10 raised to that power is in 243 the range of representable finite floating point numbers. */ 244 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 245 246 /** True if the type has a representation for positive infinity. */ 247 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 248 249 /** True if the type has a representation for a quiet (non-signaling) 250 <em>Not a Number</em>. */ 251 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 252 253 /** True if the type has a representation for a signaling 254 <em>Not a Number</em>. */ 255 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 256 257 /** See std::float_denorm_style for more information. */ 258 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; 259 260 /** <em>True if loss of accuracy is detected as a denormalization loss, 261 rather than as an inexact result.</em> [18.2.1.2]/42 */ 262 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 263 264 /** True if-and-only-if the type adheres to the IEC 559 standard, also 265 known as IEEE 754. (Only makes sense for floating point types.) */ 266 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 267 268 /** <em>True if the set of values representable by the type is 269 finite. All built-in types are bounded, this member would be 270 false for arbitrary precision types.</em> [18.2.1.2]/54 */ 271 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = false; 272 273 /** True if the type is @e modulo, that is, if it is possible to add two 274 positive numbers and have a result that wraps around to a third number 275 that is less. Typically false for floating types, true for unsigned 276 integers, and true for signed integers. */ 277 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 278 279 /** True if trapping is implemented for this type. */ 280 static _GLIBCXX_USE_CONSTEXPR bool traps = false; 281 282 /** True if tininess is detected before rounding. (see IEC 559) */ 283 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 284 285 /** See std::float_round_style for more information. This is only 286 meaningful for floating types; integer types will all be 287 round_toward_zero. */ 288 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = 289 round_toward_zero; 290 }; 291 292 /** 293 * @brief Properties of fundamental types. 294 * 295 * This class allows a program to obtain information about the 296 * representation of a fundamental type on a given platform. For 297 * non-fundamental types, the functions will return 0 and the data 298 * members will all be @c false. 299 * 300 * _GLIBCXX_RESOLVE_LIB_DEFECTS: DRs 201 and 184 (hi Gaby!) are 301 * noted, but not incorporated in this documented (yet). 302 */ 303 template<typename _Tp> 304 struct numeric_limits : public __numeric_limits_base 305 { 306 /** The minimum finite value, or for floating types with 307 denormalization, the minimum positive normalized value. */ 308 static _GLIBCXX_CONSTEXPR _Tp 309 min() throw() { return static_cast<_Tp>(0); } 310 311 /** The maximum finite value. */ 312 static _GLIBCXX_CONSTEXPR _Tp 313 max() throw() { return static_cast<_Tp>(0); } 314 315 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 316 /** A finite value x such that there is no other finite value y 317 * where y < x. */ 318 static constexpr _Tp 319 lowest() throw() { return static_cast<_Tp>(0); } 320 #endif 321 322 /** The @e machine @e epsilon: the difference between 1 and the least 323 value greater than 1 that is representable. */ 324 static _GLIBCXX_CONSTEXPR _Tp 325 epsilon() throw() { return static_cast<_Tp>(0); } 326 327 /** The maximum rounding error measurement (see LIA-1). */ 328 static _GLIBCXX_CONSTEXPR _Tp 329 round_error() throw() { return static_cast<_Tp>(0); } 330 331 /** The representation of positive infinity, if @c has_infinity. */ 332 static _GLIBCXX_CONSTEXPR _Tp 333 infinity() throw() { return static_cast<_Tp>(0); } 334 335 /** The representation of a quiet <em>Not a Number</em>, 336 if @c has_quiet_NaN. */ 337 static _GLIBCXX_CONSTEXPR _Tp 338 quiet_NaN() throw() { return static_cast<_Tp>(0); } 339 340 /** The representation of a signaling <em>Not a Number</em>, if 341 @c has_signaling_NaN. */ 342 static _GLIBCXX_CONSTEXPR _Tp 343 signaling_NaN() throw() { return static_cast<_Tp>(0); } 344 345 /** The minimum positive denormalized value. For types where 346 @c has_denorm is false, this is the minimum positive normalized 347 value. */ 348 static _GLIBCXX_CONSTEXPR _Tp 349 denorm_min() throw() { return static_cast<_Tp>(0); } 350 }; 351 352 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 353 template<typename _Tp> 354 struct numeric_limits<const _Tp> 355 : public numeric_limits<_Tp> { }; 356 357 template<typename _Tp> 358 struct numeric_limits<volatile _Tp> 359 : public numeric_limits<_Tp> { }; 360 361 template<typename _Tp> 362 struct numeric_limits<const volatile _Tp> 363 : public numeric_limits<_Tp> { }; 364 #endif 365 366 // Now there follow 16 explicit specializations. Yes, 16. Make sure 367 // you get the count right. (18 in c++0x mode) 368 369 /// numeric_limits<bool> specialization. 370 template<> 371 struct numeric_limits<bool> 372 { 373 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 374 375 static _GLIBCXX_CONSTEXPR bool 376 min() throw() { return false; } 377 378 static _GLIBCXX_CONSTEXPR bool 379 max() throw() { return true; } 380 381 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 382 static constexpr bool 383 lowest() throw() { return min(); } 384 #endif 385 static _GLIBCXX_USE_CONSTEXPR int digits = 1; 386 static _GLIBCXX_USE_CONSTEXPR int digits10 = 0; 387 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 388 static constexpr int max_digits10 = 0; 389 #endif 390 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 391 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 392 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 393 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 394 395 static _GLIBCXX_CONSTEXPR bool 396 epsilon() throw() { return false; } 397 398 static _GLIBCXX_CONSTEXPR bool 399 round_error() throw() { return false; } 400 401 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 402 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 403 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 404 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 405 406 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 407 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 408 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 409 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 410 = denorm_absent; 411 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 412 413 static _GLIBCXX_CONSTEXPR bool 414 infinity() throw() { return false; } 415 416 static _GLIBCXX_CONSTEXPR bool 417 quiet_NaN() throw() { return false; } 418 419 static _GLIBCXX_CONSTEXPR bool 420 signaling_NaN() throw() { return false; } 421 422 static _GLIBCXX_CONSTEXPR bool 423 denorm_min() throw() { return false; } 424 425 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 426 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 427 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 428 429 // It is not clear what it means for a boolean type to trap. 430 // This is a DR on the LWG issue list. Here, I use integer 431 // promotion semantics. 432 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 433 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 434 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 435 = round_toward_zero; 436 }; 437 438 /// numeric_limits<char> specialization. 439 template<> 440 struct numeric_limits<char> 441 { 442 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 443 444 static _GLIBCXX_CONSTEXPR char 445 min() throw() { return __glibcxx_min(char); } 446 447 static _GLIBCXX_CONSTEXPR char 448 max() throw() { return __glibcxx_max(char); } 449 450 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 451 static constexpr char 452 lowest() throw() { return min(); } 453 #endif 454 455 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char); 456 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (char); 457 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 458 static constexpr int max_digits10 = 0; 459 #endif 460 static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (char); 461 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 462 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 463 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 464 465 static _GLIBCXX_CONSTEXPR char 466 epsilon() throw() { return 0; } 467 468 static _GLIBCXX_CONSTEXPR char 469 round_error() throw() { return 0; } 470 471 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 472 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 473 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 474 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 475 476 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 477 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 478 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 479 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 480 = denorm_absent; 481 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 482 483 static _GLIBCXX_CONSTEXPR 484 char infinity() throw() { return char(); } 485 486 static _GLIBCXX_CONSTEXPR char 487 quiet_NaN() throw() { return char(); } 488 489 static _GLIBCXX_CONSTEXPR char 490 signaling_NaN() throw() { return char(); } 491 492 static _GLIBCXX_CONSTEXPR char 493 denorm_min() throw() { return static_cast<char>(0); } 494 495 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 496 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 497 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 498 499 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 500 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 501 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 502 = round_toward_zero; 503 }; 504 505 /// numeric_limits<signed char> specialization. 506 template<> 507 struct numeric_limits<signed char> 508 { 509 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 510 511 static _GLIBCXX_CONSTEXPR signed char 512 min() throw() { return -__SCHAR_MAX__ - 1; } 513 514 static _GLIBCXX_CONSTEXPR signed char 515 max() throw() { return __SCHAR_MAX__; } 516 517 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 518 static constexpr signed char 519 lowest() throw() { return min(); } 520 #endif 521 522 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (signed char); 523 static _GLIBCXX_USE_CONSTEXPR int digits10 524 = __glibcxx_digits10 (signed char); 525 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 526 static constexpr int max_digits10 = 0; 527 #endif 528 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 529 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 530 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 531 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 532 533 static _GLIBCXX_CONSTEXPR signed char 534 epsilon() throw() { return 0; } 535 536 static _GLIBCXX_CONSTEXPR signed char 537 round_error() throw() { return 0; } 538 539 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 540 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 541 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 542 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 543 544 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 545 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 546 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 547 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 548 = denorm_absent; 549 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 550 551 static _GLIBCXX_CONSTEXPR signed char 552 infinity() throw() { return static_cast<signed char>(0); } 553 554 static _GLIBCXX_CONSTEXPR signed char 555 quiet_NaN() throw() { return static_cast<signed char>(0); } 556 557 static _GLIBCXX_CONSTEXPR signed char 558 signaling_NaN() throw() { return static_cast<signed char>(0); } 559 560 static _GLIBCXX_CONSTEXPR signed char 561 denorm_min() throw() { return static_cast<signed char>(0); } 562 563 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 564 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 565 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 566 567 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 568 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 569 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 570 = round_toward_zero; 571 }; 572 573 /// numeric_limits<unsigned char> specialization. 574 template<> 575 struct numeric_limits<unsigned char> 576 { 577 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 578 579 static _GLIBCXX_CONSTEXPR unsigned char 580 min() throw() { return 0; } 581 582 static _GLIBCXX_CONSTEXPR unsigned char 583 max() throw() { return __SCHAR_MAX__ * 2U + 1; } 584 585 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 586 static constexpr unsigned char 587 lowest() throw() { return min(); } 588 #endif 589 590 static _GLIBCXX_USE_CONSTEXPR int digits 591 = __glibcxx_digits (unsigned char); 592 static _GLIBCXX_USE_CONSTEXPR int digits10 593 = __glibcxx_digits10 (unsigned char); 594 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 595 static constexpr int max_digits10 = 0; 596 #endif 597 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 598 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 599 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 600 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 601 602 static _GLIBCXX_CONSTEXPR unsigned char 603 epsilon() throw() { return 0; } 604 605 static _GLIBCXX_CONSTEXPR unsigned char 606 round_error() throw() { return 0; } 607 608 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 609 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 610 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 611 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 612 613 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 614 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 615 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 616 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 617 = denorm_absent; 618 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 619 620 static _GLIBCXX_CONSTEXPR unsigned char 621 infinity() throw() { return static_cast<unsigned char>(0); } 622 623 static _GLIBCXX_CONSTEXPR unsigned char 624 quiet_NaN() throw() { return static_cast<unsigned char>(0); } 625 626 static _GLIBCXX_CONSTEXPR unsigned char 627 signaling_NaN() throw() { return static_cast<unsigned char>(0); } 628 629 static _GLIBCXX_CONSTEXPR unsigned char 630 denorm_min() throw() { return static_cast<unsigned char>(0); } 631 632 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 633 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 634 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 635 636 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 637 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 638 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 639 = round_toward_zero; 640 }; 641 642 /// numeric_limits<wchar_t> specialization. 643 template<> 644 struct numeric_limits<wchar_t> 645 { 646 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 647 648 static _GLIBCXX_CONSTEXPR wchar_t 649 min() throw() { return __glibcxx_min (wchar_t); } 650 651 static _GLIBCXX_CONSTEXPR wchar_t 652 max() throw() { return __glibcxx_max (wchar_t); } 653 654 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 655 static constexpr wchar_t 656 lowest() throw() { return min(); } 657 #endif 658 659 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (wchar_t); 660 static _GLIBCXX_USE_CONSTEXPR int digits10 661 = __glibcxx_digits10 (wchar_t); 662 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 663 static constexpr int max_digits10 = 0; 664 #endif 665 static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (wchar_t); 666 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 667 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 668 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 669 670 static _GLIBCXX_CONSTEXPR wchar_t 671 epsilon() throw() { return 0; } 672 673 static _GLIBCXX_CONSTEXPR wchar_t 674 round_error() throw() { return 0; } 675 676 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 677 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 678 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 679 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 680 681 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 682 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 683 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 684 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 685 = denorm_absent; 686 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 687 688 static _GLIBCXX_CONSTEXPR wchar_t 689 infinity() throw() { return wchar_t(); } 690 691 static _GLIBCXX_CONSTEXPR wchar_t 692 quiet_NaN() throw() { return wchar_t(); } 693 694 static _GLIBCXX_CONSTEXPR wchar_t 695 signaling_NaN() throw() { return wchar_t(); } 696 697 static _GLIBCXX_CONSTEXPR wchar_t 698 denorm_min() throw() { return wchar_t(); } 699 700 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 701 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 702 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 703 704 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 705 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 706 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 707 = round_toward_zero; 708 }; 709 710 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 711 /// numeric_limits<char16_t> specialization. 712 template<> 713 struct numeric_limits<char16_t> 714 { 715 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 716 717 static _GLIBCXX_CONSTEXPR char16_t 718 min() throw() { return __glibcxx_min (char16_t); } 719 720 static _GLIBCXX_CONSTEXPR char16_t 721 max() throw() { return __glibcxx_max (char16_t); } 722 723 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 724 static constexpr char16_t 725 lowest() throw() { return min(); } 726 #endif 727 728 static _GLIBCXX_USE_CONSTEXPR int digits 729 = __glibcxx_digits (char16_t); 730 static _GLIBCXX_USE_CONSTEXPR int digits10 731 = __glibcxx_digits10 (char16_t); 732 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 733 static constexpr int max_digits10 = 0; 734 #endif 735 static _GLIBCXX_USE_CONSTEXPR bool is_signed 736 = __glibcxx_signed (char16_t); 737 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 738 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 739 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 740 741 static _GLIBCXX_CONSTEXPR char16_t 742 epsilon() throw() { return 0; } 743 744 static _GLIBCXX_CONSTEXPR char16_t 745 round_error() throw() { return 0; } 746 747 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 748 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 749 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 750 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 751 752 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 753 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 754 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 755 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 756 = denorm_absent; 757 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 758 759 static _GLIBCXX_CONSTEXPR char16_t 760 infinity() throw() { return char16_t(); } 761 762 static _GLIBCXX_CONSTEXPR char16_t 763 quiet_NaN() throw() { return char16_t(); } 764 765 static _GLIBCXX_CONSTEXPR char16_t 766 signaling_NaN() throw() { return char16_t(); } 767 768 static _GLIBCXX_CONSTEXPR char16_t 769 denorm_min() throw() { return char16_t(); } 770 771 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 772 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 773 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 774 775 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 776 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 777 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 778 = round_toward_zero; 779 }; 780 781 /// numeric_limits<char32_t> specialization. 782 template<> 783 struct numeric_limits<char32_t> 784 { 785 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 786 787 static _GLIBCXX_CONSTEXPR char32_t 788 min() throw() { return __glibcxx_min (char32_t); } 789 790 static _GLIBCXX_CONSTEXPR char32_t 791 max() throw() { return __glibcxx_max (char32_t); } 792 793 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 794 static constexpr char32_t 795 lowest() throw() { return min(); } 796 #endif 797 798 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char32_t); 799 static _GLIBCXX_USE_CONSTEXPR int digits10 800 = __glibcxx_digits10 (char32_t); 801 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 802 static constexpr int max_digits10 = 0; 803 #endif 804 static _GLIBCXX_USE_CONSTEXPR bool is_signed 805 = __glibcxx_signed (char32_t); 806 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 807 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 808 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 809 810 static _GLIBCXX_CONSTEXPR char32_t 811 epsilon() throw() { return 0; } 812 813 static _GLIBCXX_CONSTEXPR char32_t 814 round_error() throw() { return 0; } 815 816 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 817 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 818 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 819 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 820 821 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 822 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 823 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 824 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 825 = denorm_absent; 826 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 827 828 static _GLIBCXX_CONSTEXPR char32_t 829 infinity() throw() { return char32_t(); } 830 831 static _GLIBCXX_CONSTEXPR char32_t 832 quiet_NaN() throw() { return char32_t(); } 833 834 static _GLIBCXX_CONSTEXPR char32_t 835 signaling_NaN() throw() { return char32_t(); } 836 837 static _GLIBCXX_CONSTEXPR char32_t 838 denorm_min() throw() { return char32_t(); } 839 840 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 841 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 842 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 843 844 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 845 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 846 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 847 = round_toward_zero; 848 }; 849 #endif 850 851 /// numeric_limits<short> specialization. 852 template<> 853 struct numeric_limits<short> 854 { 855 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 856 857 static _GLIBCXX_CONSTEXPR short 858 min() throw() { return -__SHRT_MAX__ - 1; } 859 860 static _GLIBCXX_CONSTEXPR short 861 max() throw() { return __SHRT_MAX__; } 862 863 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 864 static constexpr short 865 lowest() throw() { return min(); } 866 #endif 867 868 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (short); 869 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (short); 870 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 871 static constexpr int max_digits10 = 0; 872 #endif 873 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 874 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 875 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 876 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 877 878 static _GLIBCXX_CONSTEXPR short 879 epsilon() throw() { return 0; } 880 881 static _GLIBCXX_CONSTEXPR short 882 round_error() throw() { return 0; } 883 884 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 885 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 886 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 887 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 888 889 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 890 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 891 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 892 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 893 = denorm_absent; 894 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 895 896 static _GLIBCXX_CONSTEXPR short 897 infinity() throw() { return short(); } 898 899 static _GLIBCXX_CONSTEXPR short 900 quiet_NaN() throw() { return short(); } 901 902 static _GLIBCXX_CONSTEXPR short 903 signaling_NaN() throw() { return short(); } 904 905 static _GLIBCXX_CONSTEXPR short 906 denorm_min() throw() { return short(); } 907 908 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 909 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 910 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 911 912 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 913 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 914 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 915 = round_toward_zero; 916 }; 917 918 /// numeric_limits<unsigned short> specialization. 919 template<> 920 struct numeric_limits<unsigned short> 921 { 922 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 923 924 static _GLIBCXX_CONSTEXPR unsigned short 925 min() throw() { return 0; } 926 927 static _GLIBCXX_CONSTEXPR unsigned short 928 max() throw() { return __SHRT_MAX__ * 2U + 1; } 929 930 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 931 static constexpr unsigned short 932 lowest() throw() { return min(); } 933 #endif 934 935 static _GLIBCXX_USE_CONSTEXPR int digits 936 = __glibcxx_digits (unsigned short); 937 static _GLIBCXX_USE_CONSTEXPR int digits10 938 = __glibcxx_digits10 (unsigned short); 939 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 940 static constexpr int max_digits10 = 0; 941 #endif 942 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 943 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 944 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 945 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 946 947 static _GLIBCXX_CONSTEXPR unsigned short 948 epsilon() throw() { return 0; } 949 950 static _GLIBCXX_CONSTEXPR unsigned short 951 round_error() throw() { return 0; } 952 953 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 954 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 955 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 956 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 957 958 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 959 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 960 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 961 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 962 = denorm_absent; 963 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 964 965 static _GLIBCXX_CONSTEXPR unsigned short 966 infinity() throw() { return static_cast<unsigned short>(0); } 967 968 static _GLIBCXX_CONSTEXPR unsigned short 969 quiet_NaN() throw() { return static_cast<unsigned short>(0); } 970 971 static _GLIBCXX_CONSTEXPR unsigned short 972 signaling_NaN() throw() { return static_cast<unsigned short>(0); } 973 974 static _GLIBCXX_CONSTEXPR unsigned short 975 denorm_min() throw() { return static_cast<unsigned short>(0); } 976 977 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 978 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 979 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 980 981 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 982 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 983 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 984 = round_toward_zero; 985 }; 986 987 /// numeric_limits<int> specialization. 988 template<> 989 struct numeric_limits<int> 990 { 991 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 992 993 static _GLIBCXX_CONSTEXPR int 994 min() throw() { return -__INT_MAX__ - 1; } 995 996 static _GLIBCXX_CONSTEXPR int 997 max() throw() { return __INT_MAX__; } 998 999 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 1000 static constexpr int 1001 lowest() throw() { return min(); } 1002 #endif 1003 1004 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (int); 1005 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (int); 1006 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 1007 static constexpr int max_digits10 = 0; 1008 #endif 1009 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1010 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1011 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1012 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1013 1014 static _GLIBCXX_CONSTEXPR int 1015 epsilon() throw() { return 0; } 1016 1017 static _GLIBCXX_CONSTEXPR int 1018 round_error() throw() { return 0; } 1019 1020 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1021 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1022 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1023 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1024 1025 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1026 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1027 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1028 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1029 = denorm_absent; 1030 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1031 1032 static _GLIBCXX_CONSTEXPR int 1033 infinity() throw() { return static_cast<int>(0); } 1034 1035 static _GLIBCXX_CONSTEXPR int 1036 quiet_NaN() throw() { return static_cast<int>(0); } 1037 1038 static _GLIBCXX_CONSTEXPR int 1039 signaling_NaN() throw() { return static_cast<int>(0); } 1040 1041 static _GLIBCXX_CONSTEXPR int 1042 denorm_min() throw() { return static_cast<int>(0); } 1043 1044 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1045 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1046 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 1047 1048 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1049 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1050 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1051 = round_toward_zero; 1052 }; 1053 1054 /// numeric_limits<unsigned int> specialization. 1055 template<> 1056 struct numeric_limits<unsigned int> 1057 { 1058 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1059 1060 static _GLIBCXX_CONSTEXPR unsigned int 1061 min() throw() { return 0; } 1062 1063 static _GLIBCXX_CONSTEXPR unsigned int 1064 max() throw() { return __INT_MAX__ * 2U + 1; } 1065 1066 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 1067 static constexpr unsigned int 1068 lowest() throw() { return min(); } 1069 #endif 1070 1071 static _GLIBCXX_USE_CONSTEXPR int digits 1072 = __glibcxx_digits (unsigned int); 1073 static _GLIBCXX_USE_CONSTEXPR int digits10 1074 = __glibcxx_digits10 (unsigned int); 1075 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 1076 static constexpr int max_digits10 = 0; 1077 #endif 1078 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 1079 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1080 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1081 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1082 1083 static _GLIBCXX_CONSTEXPR unsigned int 1084 epsilon() throw() { return 0; } 1085 1086 static _GLIBCXX_CONSTEXPR unsigned int 1087 round_error() throw() { return 0; } 1088 1089 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1090 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1091 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1092 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1093 1094 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1095 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1096 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1097 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1098 = denorm_absent; 1099 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1100 1101 static _GLIBCXX_CONSTEXPR unsigned int 1102 infinity() throw() { return static_cast<unsigned int>(0); } 1103 1104 static _GLIBCXX_CONSTEXPR unsigned int 1105 quiet_NaN() throw() { return static_cast<unsigned int>(0); } 1106 1107 static _GLIBCXX_CONSTEXPR unsigned int 1108 signaling_NaN() throw() { return static_cast<unsigned int>(0); } 1109 1110 static _GLIBCXX_CONSTEXPR unsigned int 1111 denorm_min() throw() { return static_cast<unsigned int>(0); } 1112 1113 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1114 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1115 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 1116 1117 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1118 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1119 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1120 = round_toward_zero; 1121 }; 1122 1123 /// numeric_limits<long> specialization. 1124 template<> 1125 struct numeric_limits<long> 1126 { 1127 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1128 1129 static _GLIBCXX_CONSTEXPR long 1130 min() throw() { return -__LONG_MAX__ - 1; } 1131 1132 static _GLIBCXX_CONSTEXPR long 1133 max() throw() { return __LONG_MAX__; } 1134 1135 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 1136 static constexpr long 1137 lowest() throw() { return min(); } 1138 #endif 1139 1140 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (long); 1141 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (long); 1142 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 1143 static constexpr int max_digits10 = 0; 1144 #endif 1145 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1146 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1147 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1148 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1149 1150 static _GLIBCXX_CONSTEXPR long 1151 epsilon() throw() { return 0; } 1152 1153 static _GLIBCXX_CONSTEXPR long 1154 round_error() throw() { return 0; } 1155 1156 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1157 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1158 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1159 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1160 1161 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1162 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1163 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1164 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1165 = denorm_absent; 1166 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1167 1168 static _GLIBCXX_CONSTEXPR long 1169 infinity() throw() { return static_cast<long>(0); } 1170 1171 static _GLIBCXX_CONSTEXPR long 1172 quiet_NaN() throw() { return static_cast<long>(0); } 1173 1174 static _GLIBCXX_CONSTEXPR long 1175 signaling_NaN() throw() { return static_cast<long>(0); } 1176 1177 static _GLIBCXX_CONSTEXPR long 1178 denorm_min() throw() { return static_cast<long>(0); } 1179 1180 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1181 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1182 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 1183 1184 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1185 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1186 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1187 = round_toward_zero; 1188 }; 1189 1190 /// numeric_limits<unsigned long> specialization. 1191 template<> 1192 struct numeric_limits<unsigned long> 1193 { 1194 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1195 1196 static _GLIBCXX_CONSTEXPR unsigned long 1197 min() throw() { return 0; } 1198 1199 static _GLIBCXX_CONSTEXPR unsigned long 1200 max() throw() { return __LONG_MAX__ * 2UL + 1; } 1201 1202 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 1203 static constexpr unsigned long 1204 lowest() throw() { return min(); } 1205 #endif 1206 1207 static _GLIBCXX_USE_CONSTEXPR int digits 1208 = __glibcxx_digits (unsigned long); 1209 static _GLIBCXX_USE_CONSTEXPR int digits10 1210 = __glibcxx_digits10 (unsigned long); 1211 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 1212 static constexpr int max_digits10 = 0; 1213 #endif 1214 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 1215 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1216 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1217 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1218 1219 static _GLIBCXX_CONSTEXPR unsigned long 1220 epsilon() throw() { return 0; } 1221 1222 static _GLIBCXX_CONSTEXPR unsigned long 1223 round_error() throw() { return 0; } 1224 1225 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1226 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1227 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1228 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1229 1230 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1231 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1232 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1233 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1234 = denorm_absent; 1235 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1236 1237 static _GLIBCXX_CONSTEXPR unsigned long 1238 infinity() throw() { return static_cast<unsigned long>(0); } 1239 1240 static _GLIBCXX_CONSTEXPR unsigned long 1241 quiet_NaN() throw() { return static_cast<unsigned long>(0); } 1242 1243 static _GLIBCXX_CONSTEXPR unsigned long 1244 signaling_NaN() throw() { return static_cast<unsigned long>(0); } 1245 1246 static _GLIBCXX_CONSTEXPR unsigned long 1247 denorm_min() throw() { return static_cast<unsigned long>(0); } 1248 1249 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1250 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1251 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 1252 1253 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1254 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1255 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1256 = round_toward_zero; 1257 }; 1258 1259 /// numeric_limits<long long> specialization. 1260 template<> 1261 struct numeric_limits<long long> 1262 { 1263 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1264 1265 static _GLIBCXX_CONSTEXPR long long 1266 min() throw() { return -__LONG_LONG_MAX__ - 1; } 1267 1268 static _GLIBCXX_CONSTEXPR long long 1269 max() throw() { return __LONG_LONG_MAX__; } 1270 1271 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 1272 static constexpr long long 1273 lowest() throw() { return min(); } 1274 #endif 1275 1276 static _GLIBCXX_USE_CONSTEXPR int digits 1277 = __glibcxx_digits (long long); 1278 static _GLIBCXX_USE_CONSTEXPR int digits10 1279 = __glibcxx_digits10 (long long); 1280 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 1281 static constexpr int max_digits10 = 0; 1282 #endif 1283 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1284 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1285 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1286 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1287 1288 static _GLIBCXX_CONSTEXPR long long 1289 epsilon() throw() { return 0; } 1290 1291 static _GLIBCXX_CONSTEXPR long long 1292 round_error() throw() { return 0; } 1293 1294 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1295 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1296 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1297 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1298 1299 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1300 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1301 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1302 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1303 = denorm_absent; 1304 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1305 1306 static _GLIBCXX_CONSTEXPR long long 1307 infinity() throw() { return static_cast<long long>(0); } 1308 1309 static _GLIBCXX_CONSTEXPR long long 1310 quiet_NaN() throw() { return static_cast<long long>(0); } 1311 1312 static _GLIBCXX_CONSTEXPR long long 1313 signaling_NaN() throw() { return static_cast<long long>(0); } 1314 1315 static _GLIBCXX_CONSTEXPR long long 1316 denorm_min() throw() { return static_cast<long long>(0); } 1317 1318 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1319 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1320 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 1321 1322 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1323 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1324 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1325 = round_toward_zero; 1326 }; 1327 1328 /// numeric_limits<unsigned long long> specialization. 1329 template<> 1330 struct numeric_limits<unsigned long long> 1331 { 1332 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1333 1334 static _GLIBCXX_CONSTEXPR unsigned long long 1335 min() throw() { return 0; } 1336 1337 static _GLIBCXX_CONSTEXPR unsigned long long 1338 max() throw() { return __LONG_LONG_MAX__ * 2ULL + 1; } 1339 1340 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 1341 static constexpr unsigned long long 1342 lowest() throw() { return min(); } 1343 #endif 1344 1345 static _GLIBCXX_USE_CONSTEXPR int digits 1346 = __glibcxx_digits (unsigned long long); 1347 static _GLIBCXX_USE_CONSTEXPR int digits10 1348 = __glibcxx_digits10 (unsigned long long); 1349 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 1350 static constexpr int max_digits10 = 0; 1351 #endif 1352 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 1353 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1354 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1355 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1356 1357 static _GLIBCXX_CONSTEXPR unsigned long long 1358 epsilon() throw() { return 0; } 1359 1360 static _GLIBCXX_CONSTEXPR unsigned long long 1361 round_error() throw() { return 0; } 1362 1363 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1364 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1365 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1366 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1367 1368 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1369 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1370 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1371 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1372 = denorm_absent; 1373 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1374 1375 static _GLIBCXX_CONSTEXPR unsigned long long 1376 infinity() throw() { return static_cast<unsigned long long>(0); } 1377 1378 static _GLIBCXX_CONSTEXPR unsigned long long 1379 quiet_NaN() throw() { return static_cast<unsigned long long>(0); } 1380 1381 static _GLIBCXX_CONSTEXPR unsigned long long 1382 signaling_NaN() throw() { return static_cast<unsigned long long>(0); } 1383 1384 static _GLIBCXX_CONSTEXPR unsigned long long 1385 denorm_min() throw() { return static_cast<unsigned long long>(0); } 1386 1387 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1388 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1389 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 1390 1391 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1392 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1393 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1394 = round_toward_zero; 1395 }; 1396 1397 /// numeric_limits<float> specialization. 1398 template<> 1399 struct numeric_limits<float> 1400 { 1401 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1402 1403 static _GLIBCXX_CONSTEXPR float 1404 min() throw() { return __FLT_MIN__; } 1405 1406 static _GLIBCXX_CONSTEXPR float 1407 max() throw() { return __FLT_MAX__; } 1408 1409 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 1410 static constexpr float 1411 lowest() throw() { return -__FLT_MAX__; } 1412 #endif 1413 1414 static _GLIBCXX_USE_CONSTEXPR int digits = __FLT_MANT_DIG__; 1415 static _GLIBCXX_USE_CONSTEXPR int digits10 = __FLT_DIG__; 1416 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 1417 static constexpr int max_digits10 1418 = __glibcxx_max_digits10 (__FLT_MANT_DIG__); 1419 #endif 1420 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1421 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; 1422 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; 1423 static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; 1424 1425 static _GLIBCXX_CONSTEXPR float 1426 epsilon() throw() { return __FLT_EPSILON__; } 1427 1428 static _GLIBCXX_CONSTEXPR float 1429 round_error() throw() { return 0.5F; } 1430 1431 static _GLIBCXX_USE_CONSTEXPR int min_exponent = __FLT_MIN_EXP__; 1432 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __FLT_MIN_10_EXP__; 1433 static _GLIBCXX_USE_CONSTEXPR int max_exponent = __FLT_MAX_EXP__; 1434 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __FLT_MAX_10_EXP__; 1435 1436 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __FLT_HAS_INFINITY__; 1437 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__; 1438 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; 1439 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1440 = bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent; 1441 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss 1442 = __glibcxx_float_has_denorm_loss; 1443 1444 static _GLIBCXX_CONSTEXPR float 1445 infinity() throw() { return __builtin_huge_valf (); } 1446 1447 static _GLIBCXX_CONSTEXPR float 1448 quiet_NaN() throw() { return __builtin_nanf (""); } 1449 1450 static _GLIBCXX_CONSTEXPR float 1451 signaling_NaN() throw() { return __builtin_nansf (""); } 1452 1453 static _GLIBCXX_CONSTEXPR float 1454 denorm_min() throw() { return __FLT_DENORM_MIN__; } 1455 1456 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 1457 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 1458 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1459 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1460 1461 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_float_traps; 1462 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before 1463 = __glibcxx_float_tinyness_before; 1464 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1465 = round_to_nearest; 1466 }; 1467 1468 #undef __glibcxx_float_has_denorm_loss 1469 #undef __glibcxx_float_traps 1470 #undef __glibcxx_float_tinyness_before 1471 1472 /// numeric_limits<double> specialization. 1473 template<> 1474 struct numeric_limits<double> 1475 { 1476 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1477 1478 static _GLIBCXX_CONSTEXPR double 1479 min() throw() { return __DBL_MIN__; } 1480 1481 static _GLIBCXX_CONSTEXPR double 1482 max() throw() { return __DBL_MAX__; } 1483 1484 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 1485 static constexpr double 1486 lowest() throw() { return -__DBL_MAX__; } 1487 #endif 1488 1489 static _GLIBCXX_USE_CONSTEXPR int digits = __DBL_MANT_DIG__; 1490 static _GLIBCXX_USE_CONSTEXPR int digits10 = __DBL_DIG__; 1491 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 1492 static constexpr int max_digits10 1493 = __glibcxx_max_digits10 (__DBL_MANT_DIG__); 1494 #endif 1495 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1496 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; 1497 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; 1498 static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; 1499 1500 static _GLIBCXX_CONSTEXPR double 1501 epsilon() throw() { return __DBL_EPSILON__; } 1502 1503 static _GLIBCXX_CONSTEXPR double 1504 round_error() throw() { return 0.5; } 1505 1506 static _GLIBCXX_USE_CONSTEXPR int min_exponent = __DBL_MIN_EXP__; 1507 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __DBL_MIN_10_EXP__; 1508 static _GLIBCXX_USE_CONSTEXPR int max_exponent = __DBL_MAX_EXP__; 1509 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __DBL_MAX_10_EXP__; 1510 1511 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __DBL_HAS_INFINITY__; 1512 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__; 1513 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; 1514 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1515 = bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent; 1516 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss 1517 = __glibcxx_double_has_denorm_loss; 1518 1519 static _GLIBCXX_CONSTEXPR double 1520 infinity() throw() { return __builtin_huge_val(); } 1521 1522 static _GLIBCXX_CONSTEXPR double 1523 quiet_NaN() throw() { return __builtin_nan (""); } 1524 1525 static _GLIBCXX_CONSTEXPR double 1526 signaling_NaN() throw() { return __builtin_nans (""); } 1527 1528 static _GLIBCXX_CONSTEXPR double 1529 denorm_min() throw() { return __DBL_DENORM_MIN__; } 1530 1531 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 1532 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 1533 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1534 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1535 1536 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_double_traps; 1537 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before 1538 = __glibcxx_double_tinyness_before; 1539 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1540 = round_to_nearest; 1541 }; 1542 1543 #undef __glibcxx_double_has_denorm_loss 1544 #undef __glibcxx_double_traps 1545 #undef __glibcxx_double_tinyness_before 1546 1547 /// numeric_limits<long double> specialization. 1548 template<> 1549 struct numeric_limits<long double> 1550 { 1551 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1552 1553 static _GLIBCXX_CONSTEXPR long double 1554 min() throw() { return __LDBL_MIN__; } 1555 1556 static _GLIBCXX_CONSTEXPR long double 1557 max() throw() { return __LDBL_MAX__; } 1558 1559 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 1560 static constexpr long double 1561 lowest() throw() { return -__LDBL_MAX__; } 1562 #endif 1563 1564 static _GLIBCXX_USE_CONSTEXPR int digits = __LDBL_MANT_DIG__; 1565 static _GLIBCXX_USE_CONSTEXPR int digits10 = __LDBL_DIG__; 1566 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 1567 static _GLIBCXX_USE_CONSTEXPR int max_digits10 1568 = __glibcxx_max_digits10 (__LDBL_MANT_DIG__); 1569 #endif 1570 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1571 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; 1572 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; 1573 static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; 1574 1575 static _GLIBCXX_CONSTEXPR long double 1576 epsilon() throw() { return __LDBL_EPSILON__; } 1577 1578 static _GLIBCXX_CONSTEXPR long double 1579 round_error() throw() { return 0.5L; } 1580 1581 static _GLIBCXX_USE_CONSTEXPR int min_exponent = __LDBL_MIN_EXP__; 1582 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __LDBL_MIN_10_EXP__; 1583 static _GLIBCXX_USE_CONSTEXPR int max_exponent = __LDBL_MAX_EXP__; 1584 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __LDBL_MAX_10_EXP__; 1585 1586 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __LDBL_HAS_INFINITY__; 1587 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__; 1588 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; 1589 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1590 = bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent; 1591 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss 1592 = __glibcxx_long_double_has_denorm_loss; 1593 1594 static _GLIBCXX_CONSTEXPR long double 1595 infinity() throw() { return __builtin_huge_vall (); } 1596 1597 static _GLIBCXX_CONSTEXPR long double 1598 quiet_NaN() throw() { return __builtin_nanl (""); } 1599 1600 static _GLIBCXX_CONSTEXPR long double 1601 signaling_NaN() throw() { return __builtin_nansl (""); } 1602 1603 static _GLIBCXX_CONSTEXPR long double 1604 denorm_min() throw() { return __LDBL_DENORM_MIN__; } 1605 1606 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 1607 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 1608 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1609 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1610 1611 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_long_double_traps; 1612 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = 1613 __glibcxx_long_double_tinyness_before; 1614 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = 1615 round_to_nearest; 1616 }; 1617 1618 #undef __glibcxx_long_double_has_denorm_loss 1619 #undef __glibcxx_long_double_traps 1620 #undef __glibcxx_long_double_tinyness_before 1621 1622 _GLIBCXX_END_NAMESPACE_VERSION 1623 } // namespace 1624 1625 #undef __glibcxx_signed 1626 #undef __glibcxx_min 1627 #undef __glibcxx_max 1628 #undef __glibcxx_digits 1629 #undef __glibcxx_digits10 1630 #undef __glibcxx_max_digits10 1631 1632 #endif // _GLIBCXX_NUMERIC_LIMITS 1633
