1 // The template and inlines for the numeric_limits classes. -*- C++ -*- 2 3 // Copyright (C) 1999-2013 Free Software Foundation, Inc. 4 // 5 // This file is part of the GNU ISO C++ Library. This library is free 6 // software; you can redistribute it and/or modify it under the 7 // terms of the GNU General Public License as published by the 8 // Free Software Foundation; either version 3, or (at your option) 9 // any later version. 10 11 // This library is distributed in the hope that it will be useful, 12 // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 // GNU General Public License for more details. 15 16 // Under Section 7 of GPL version 3, you are granted additional 17 // permissions described in the GCC Runtime Library Exception, version 18 // 3.1, as published by the Free Software Foundation. 19 20 // You should have received a copy of the GNU General Public License and 21 // a copy of the GCC Runtime Library Exception along with this program; 22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 // <http://www.gnu.org/licenses/>. 24 25 /** @file include/limits 26 * This is a Standard C++ Library header. 27 */ 28 29 // Note: this is not a conforming implementation. 30 // Written by Gabriel Dos Reis <gdr (a] codesourcery.com> 31 32 // 33 // ISO 14882:1998 34 // 18.2.1 35 // 36 37 #ifndef _GLIBCXX_NUMERIC_LIMITS 38 #define _GLIBCXX_NUMERIC_LIMITS 1 39 40 #pragma GCC system_header 41 42 #include <bits/c++config.h> 43 44 // 45 // The numeric_limits<> traits document implementation-defined aspects 46 // of fundamental arithmetic data types (integers and floating points). 47 // From Standard C++ point of view, there are 14 such types: 48 // * integers 49 // bool (1) 50 // char, signed char, unsigned char, wchar_t (4) 51 // short, unsigned short (2) 52 // int, unsigned (2) 53 // long, unsigned long (2) 54 // 55 // * floating points 56 // float (1) 57 // double (1) 58 // long double (1) 59 // 60 // GNU C++ understands (where supported by the host C-library) 61 // * integer 62 // long long, unsigned long long (2) 63 // 64 // which brings us to 16 fundamental arithmetic data types in GNU C++. 65 // 66 // 67 // Since a numeric_limits<> is a bit tricky to get right, we rely on 68 // an interface composed of macros which should be defined in config/os 69 // or config/cpu when they differ from the generic (read arbitrary) 70 // definitions given here. 71 // 72 73 // These values can be overridden in the target configuration file. 74 // The default values are appropriate for many 32-bit targets. 75 76 // GCC only intrinsically supports modulo integral types. The only remaining 77 // integral exceptional values is division by zero. Only targets that do not 78 // signal division by zero in some "hard to ignore" way should use false. 79 #ifndef __glibcxx_integral_traps 80 # define __glibcxx_integral_traps true 81 #endif 82 83 // float 84 // 85 86 // Default values. Should be overridden in configuration files if necessary. 87 88 #ifndef __glibcxx_float_has_denorm_loss 89 # define __glibcxx_float_has_denorm_loss false 90 #endif 91 #ifndef __glibcxx_float_traps 92 # define __glibcxx_float_traps false 93 #endif 94 #ifndef __glibcxx_float_tinyness_before 95 # define __glibcxx_float_tinyness_before false 96 #endif 97 98 // double 99 100 // Default values. Should be overridden in configuration files if necessary. 101 102 #ifndef __glibcxx_double_has_denorm_loss 103 # define __glibcxx_double_has_denorm_loss false 104 #endif 105 #ifndef __glibcxx_double_traps 106 # define __glibcxx_double_traps false 107 #endif 108 #ifndef __glibcxx_double_tinyness_before 109 # define __glibcxx_double_tinyness_before false 110 #endif 111 112 // long double 113 114 // Default values. Should be overridden in configuration files if necessary. 115 116 #ifndef __glibcxx_long_double_has_denorm_loss 117 # define __glibcxx_long_double_has_denorm_loss false 118 #endif 119 #ifndef __glibcxx_long_double_traps 120 # define __glibcxx_long_double_traps false 121 #endif 122 #ifndef __glibcxx_long_double_tinyness_before 123 # define __glibcxx_long_double_tinyness_before false 124 #endif 125 126 // You should not need to define any macros below this point. 127 128 #define __glibcxx_signed(T) ((T)(-1) < 0) 129 130 #define __glibcxx_min(T) \ 131 (__glibcxx_signed (T) ? -__glibcxx_max (T) - 1 : (T)0) 132 133 #define __glibcxx_max(T) \ 134 (__glibcxx_signed (T) ? \ 135 (((((T)1 << (__glibcxx_digits (T) - 1)) - 1) << 1) + 1) : ~(T)0) 136 137 #define __glibcxx_digits(T) \ 138 (sizeof(T) * __CHAR_BIT__ - __glibcxx_signed (T)) 139 140 // The fraction 643/2136 approximates log10(2) to 7 significant digits. 141 #define __glibcxx_digits10(T) \ 142 (__glibcxx_digits (T) * 643L / 2136) 143 144 #define __glibcxx_max_digits10(T) \ 145 (2 + (T) * 643L / 2136) 146 147 namespace std _GLIBCXX_VISIBILITY(default) 148 { 149 _GLIBCXX_BEGIN_NAMESPACE_VERSION 150 151 /** 152 * @brief Describes the rounding style for floating-point types. 153 * 154 * This is used in the std::numeric_limits class. 155 */ 156 enum float_round_style 157 { 158 round_indeterminate = -1, /// Intermediate. 159 round_toward_zero = 0, /// To zero. 160 round_to_nearest = 1, /// To the nearest representable value. 161 round_toward_infinity = 2, /// To infinity. 162 round_toward_neg_infinity = 3 /// To negative infinity. 163 }; 164 165 /** 166 * @brief Describes the denormalization for floating-point types. 167 * 168 * These values represent the presence or absence of a variable number 169 * of exponent bits. This type is used in the std::numeric_limits class. 170 */ 171 enum float_denorm_style 172 { 173 /// Indeterminate at compile time whether denormalized values are allowed. 174 denorm_indeterminate = -1, 175 /// The type does not allow denormalized values. 176 denorm_absent = 0, 177 /// The type allows denormalized values. 178 denorm_present = 1 179 }; 180 181 /** 182 * @brief Part of std::numeric_limits. 183 * 184 * The @c static @c const members are usable as integral constant 185 * expressions. 186 * 187 * @note This is a separate class for purposes of efficiency; you 188 * should only access these members as part of an instantiation 189 * of the std::numeric_limits class. 190 */ 191 struct __numeric_limits_base 192 { 193 /** This will be true for all fundamental types (which have 194 specializations), and false for everything else. */ 195 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = false; 196 197 /** The number of @c radix digits that be represented without change: for 198 integer types, the number of non-sign bits in the mantissa; for 199 floating types, the number of @c radix digits in the mantissa. */ 200 static _GLIBCXX_USE_CONSTEXPR int digits = 0; 201 202 /** The number of base 10 digits that can be represented without change. */ 203 static _GLIBCXX_USE_CONSTEXPR int digits10 = 0; 204 205 #if __cplusplus >= 201103L 206 /** The number of base 10 digits required to ensure that values which 207 differ are always differentiated. */ 208 static constexpr int max_digits10 = 0; 209 #endif 210 211 /** True if the type is signed. */ 212 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 213 214 /** True if the type is integer. */ 215 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; 216 217 /** True if the type uses an exact representation. All integer types are 218 exact, but not all exact types are integer. For example, rational and 219 fixed-exponent representations are exact but not integer. */ 220 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; 221 222 /** For integer types, specifies the base of the representation. For 223 floating types, specifies the base of the exponent representation. */ 224 static _GLIBCXX_USE_CONSTEXPR int radix = 0; 225 226 /** The minimum negative integer such that @c radix raised to the power of 227 (one less than that integer) is a normalized floating point number. */ 228 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 229 230 /** The minimum negative integer such that 10 raised to that power is in 231 the range of normalized floating point numbers. */ 232 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 233 234 /** The maximum positive integer such that @c radix raised to the power of 235 (one less than that integer) is a representable finite floating point 236 number. */ 237 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 238 239 /** The maximum positive integer such that 10 raised to that power is in 240 the range of representable finite floating point numbers. */ 241 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 242 243 /** True if the type has a representation for positive infinity. */ 244 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 245 246 /** True if the type has a representation for a quiet (non-signaling) 247 Not a Number. */ 248 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 249 250 /** True if the type has a representation for a signaling 251 Not a Number. */ 252 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 253 254 /** See std::float_denorm_style for more information. */ 255 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; 256 257 /** True if loss of accuracy is detected as a denormalization loss, 258 rather than as an inexact result. */ 259 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 260 261 /** True if-and-only-if the type adheres to the IEC 559 standard, also 262 known as IEEE 754. (Only makes sense for floating point types.) */ 263 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 264 265 /** True if the set of values representable by the type is 266 finite. All built-in types are bounded, this member would be 267 false for arbitrary precision types. */ 268 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = false; 269 270 /** True if the type is @e modulo. A type is modulo if, for any 271 operation involving +, -, or * on values of that type whose 272 result would fall outside the range [min(),max()], the value 273 returned differs from the true value by an integer multiple of 274 max() - min() + 1. On most machines, this is false for floating 275 types, true for unsigned integers, and true for signed integers. 276 See PR22200 about 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() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 310 311 /** The maximum finite value. */ 312 static _GLIBCXX_CONSTEXPR _Tp 313 max() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 314 315 #if __cplusplus >= 201103L 316 /** A finite value x such that there is no other finite value y 317 * where y < x. */ 318 static constexpr _Tp 319 lowest() noexcept { return _Tp(); } 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() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 326 327 /** The maximum rounding error measurement (see LIA-1). */ 328 static _GLIBCXX_CONSTEXPR _Tp 329 round_error() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 330 331 /** The representation of positive infinity, if @c has_infinity. */ 332 static _GLIBCXX_CONSTEXPR _Tp 333 infinity() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 334 335 /** The representation of a quiet Not a Number, 336 if @c has_quiet_NaN. */ 337 static _GLIBCXX_CONSTEXPR _Tp 338 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 339 340 /** The representation of a signaling Not a Number, if 341 @c has_signaling_NaN. */ 342 static _GLIBCXX_CONSTEXPR _Tp 343 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 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() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 350 }; 351 352 #if __cplusplus >= 201103L 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() _GLIBCXX_USE_NOEXCEPT { return false; } 377 378 static _GLIBCXX_CONSTEXPR bool 379 max() _GLIBCXX_USE_NOEXCEPT { return true; } 380 381 #if __cplusplus >= 201103L 382 static constexpr bool 383 lowest() noexcept { return min(); } 384 #endif 385 static _GLIBCXX_USE_CONSTEXPR int digits = 1; 386 static _GLIBCXX_USE_CONSTEXPR int digits10 = 0; 387 #if __cplusplus >= 201103L 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() _GLIBCXX_USE_NOEXCEPT { return false; } 397 398 static _GLIBCXX_CONSTEXPR bool 399 round_error() _GLIBCXX_USE_NOEXCEPT { 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() _GLIBCXX_USE_NOEXCEPT { return false; } 415 416 static _GLIBCXX_CONSTEXPR bool 417 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return false; } 418 419 static _GLIBCXX_CONSTEXPR bool 420 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return false; } 421 422 static _GLIBCXX_CONSTEXPR bool 423 denorm_min() _GLIBCXX_USE_NOEXCEPT { 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() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min(char); } 446 447 static _GLIBCXX_CONSTEXPR char 448 max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max(char); } 449 450 #if __cplusplus >= 201103L 451 static constexpr char 452 lowest() noexcept { 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 #if __cplusplus >= 201103L 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() _GLIBCXX_USE_NOEXCEPT { return 0; } 467 468 static _GLIBCXX_CONSTEXPR char 469 round_error() _GLIBCXX_USE_NOEXCEPT { 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() _GLIBCXX_USE_NOEXCEPT { return char(); } 485 486 static _GLIBCXX_CONSTEXPR char 487 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); } 488 489 static _GLIBCXX_CONSTEXPR char 490 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); } 491 492 static _GLIBCXX_CONSTEXPR char 493 denorm_min() _GLIBCXX_USE_NOEXCEPT { 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 = !is_signed; 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() _GLIBCXX_USE_NOEXCEPT { return -__SCHAR_MAX__ - 1; } 513 514 static _GLIBCXX_CONSTEXPR signed char 515 max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__; } 516 517 #if __cplusplus >= 201103L 518 static constexpr signed char 519 lowest() noexcept { 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 #if __cplusplus >= 201103L 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() _GLIBCXX_USE_NOEXCEPT { return 0; } 535 536 static _GLIBCXX_CONSTEXPR signed char 537 round_error() _GLIBCXX_USE_NOEXCEPT { 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() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); } 553 554 static _GLIBCXX_CONSTEXPR signed char 555 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); } 556 557 static _GLIBCXX_CONSTEXPR signed char 558 signaling_NaN() _GLIBCXX_USE_NOEXCEPT 559 { return static_cast<signed char>(0); } 560 561 static _GLIBCXX_CONSTEXPR signed char 562 denorm_min() _GLIBCXX_USE_NOEXCEPT 563 { return static_cast<signed char>(0); } 564 565 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 566 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 567 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 568 569 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 570 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 571 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 572 = round_toward_zero; 573 }; 574 575 /// numeric_limits<unsigned char> specialization. 576 template<> 577 struct numeric_limits<unsigned char> 578 { 579 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 580 581 static _GLIBCXX_CONSTEXPR unsigned char 582 min() _GLIBCXX_USE_NOEXCEPT { return 0; } 583 584 static _GLIBCXX_CONSTEXPR unsigned char 585 max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__ * 2U + 1; } 586 587 #if __cplusplus >= 201103L 588 static constexpr unsigned char 589 lowest() noexcept { return min(); } 590 #endif 591 592 static _GLIBCXX_USE_CONSTEXPR int digits 593 = __glibcxx_digits (unsigned char); 594 static _GLIBCXX_USE_CONSTEXPR int digits10 595 = __glibcxx_digits10 (unsigned char); 596 #if __cplusplus >= 201103L 597 static constexpr int max_digits10 = 0; 598 #endif 599 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 600 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 601 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 602 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 603 604 static _GLIBCXX_CONSTEXPR unsigned char 605 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 606 607 static _GLIBCXX_CONSTEXPR unsigned char 608 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 609 610 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 611 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 612 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 613 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 614 615 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 616 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 617 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 618 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 619 = denorm_absent; 620 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 621 622 static _GLIBCXX_CONSTEXPR unsigned char 623 infinity() _GLIBCXX_USE_NOEXCEPT 624 { return static_cast<unsigned char>(0); } 625 626 static _GLIBCXX_CONSTEXPR unsigned char 627 quiet_NaN() _GLIBCXX_USE_NOEXCEPT 628 { return static_cast<unsigned char>(0); } 629 630 static _GLIBCXX_CONSTEXPR unsigned char 631 signaling_NaN() _GLIBCXX_USE_NOEXCEPT 632 { return static_cast<unsigned char>(0); } 633 634 static _GLIBCXX_CONSTEXPR unsigned char 635 denorm_min() _GLIBCXX_USE_NOEXCEPT 636 { return static_cast<unsigned char>(0); } 637 638 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 639 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 640 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 641 642 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 643 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 644 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 645 = round_toward_zero; 646 }; 647 648 /// numeric_limits<wchar_t> specialization. 649 template<> 650 struct numeric_limits<wchar_t> 651 { 652 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 653 654 static _GLIBCXX_CONSTEXPR wchar_t 655 min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (wchar_t); } 656 657 static _GLIBCXX_CONSTEXPR wchar_t 658 max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (wchar_t); } 659 660 #if __cplusplus >= 201103L 661 static constexpr wchar_t 662 lowest() noexcept { return min(); } 663 #endif 664 665 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (wchar_t); 666 static _GLIBCXX_USE_CONSTEXPR int digits10 667 = __glibcxx_digits10 (wchar_t); 668 #if __cplusplus >= 201103L 669 static constexpr int max_digits10 = 0; 670 #endif 671 static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (wchar_t); 672 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 673 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 674 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 675 676 static _GLIBCXX_CONSTEXPR wchar_t 677 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 678 679 static _GLIBCXX_CONSTEXPR wchar_t 680 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 681 682 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 683 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 684 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 685 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 686 687 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 688 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 689 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 690 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 691 = denorm_absent; 692 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 693 694 static _GLIBCXX_CONSTEXPR wchar_t 695 infinity() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } 696 697 static _GLIBCXX_CONSTEXPR wchar_t 698 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } 699 700 static _GLIBCXX_CONSTEXPR wchar_t 701 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } 702 703 static _GLIBCXX_CONSTEXPR wchar_t 704 denorm_min() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } 705 706 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 707 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 708 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed; 709 710 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 711 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 712 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 713 = round_toward_zero; 714 }; 715 716 #if __cplusplus >= 201103L 717 /// numeric_limits<char16_t> specialization. 718 template<> 719 struct numeric_limits<char16_t> 720 { 721 static constexpr bool is_specialized = true; 722 723 static constexpr char16_t 724 min() noexcept { return __glibcxx_min (char16_t); } 725 726 static constexpr char16_t 727 max() noexcept { return __glibcxx_max (char16_t); } 728 729 static constexpr char16_t 730 lowest() noexcept { return min(); } 731 732 static constexpr int digits = __glibcxx_digits (char16_t); 733 static constexpr int digits10 = __glibcxx_digits10 (char16_t); 734 static constexpr int max_digits10 = 0; 735 static constexpr bool is_signed = __glibcxx_signed (char16_t); 736 static constexpr bool is_integer = true; 737 static constexpr bool is_exact = true; 738 static constexpr int radix = 2; 739 740 static constexpr char16_t 741 epsilon() noexcept { return 0; } 742 743 static constexpr char16_t 744 round_error() noexcept { return 0; } 745 746 static constexpr int min_exponent = 0; 747 static constexpr int min_exponent10 = 0; 748 static constexpr int max_exponent = 0; 749 static constexpr int max_exponent10 = 0; 750 751 static constexpr bool has_infinity = false; 752 static constexpr bool has_quiet_NaN = false; 753 static constexpr bool has_signaling_NaN = false; 754 static constexpr float_denorm_style has_denorm = denorm_absent; 755 static constexpr bool has_denorm_loss = false; 756 757 static constexpr char16_t 758 infinity() noexcept { return char16_t(); } 759 760 static constexpr char16_t 761 quiet_NaN() noexcept { return char16_t(); } 762 763 static constexpr char16_t 764 signaling_NaN() noexcept { return char16_t(); } 765 766 static constexpr char16_t 767 denorm_min() noexcept { return char16_t(); } 768 769 static constexpr bool is_iec559 = false; 770 static constexpr bool is_bounded = true; 771 static constexpr bool is_modulo = !is_signed; 772 773 static constexpr bool traps = __glibcxx_integral_traps; 774 static constexpr bool tinyness_before = false; 775 static constexpr float_round_style round_style = round_toward_zero; 776 }; 777 778 /// numeric_limits<char32_t> specialization. 779 template<> 780 struct numeric_limits<char32_t> 781 { 782 static constexpr bool is_specialized = true; 783 784 static constexpr char32_t 785 min() noexcept { return __glibcxx_min (char32_t); } 786 787 static constexpr char32_t 788 max() noexcept { return __glibcxx_max (char32_t); } 789 790 static constexpr char32_t 791 lowest() noexcept { return min(); } 792 793 static constexpr int digits = __glibcxx_digits (char32_t); 794 static constexpr int digits10 = __glibcxx_digits10 (char32_t); 795 static constexpr int max_digits10 = 0; 796 static constexpr bool is_signed = __glibcxx_signed (char32_t); 797 static constexpr bool is_integer = true; 798 static constexpr bool is_exact = true; 799 static constexpr int radix = 2; 800 801 static constexpr char32_t 802 epsilon() noexcept { return 0; } 803 804 static constexpr char32_t 805 round_error() noexcept { return 0; } 806 807 static constexpr int min_exponent = 0; 808 static constexpr int min_exponent10 = 0; 809 static constexpr int max_exponent = 0; 810 static constexpr int max_exponent10 = 0; 811 812 static constexpr bool has_infinity = false; 813 static constexpr bool has_quiet_NaN = false; 814 static constexpr bool has_signaling_NaN = false; 815 static constexpr float_denorm_style has_denorm = denorm_absent; 816 static constexpr bool has_denorm_loss = false; 817 818 static constexpr char32_t 819 infinity() noexcept { return char32_t(); } 820 821 static constexpr char32_t 822 quiet_NaN() noexcept { return char32_t(); } 823 824 static constexpr char32_t 825 signaling_NaN() noexcept { return char32_t(); } 826 827 static constexpr char32_t 828 denorm_min() noexcept { return char32_t(); } 829 830 static constexpr bool is_iec559 = false; 831 static constexpr bool is_bounded = true; 832 static constexpr bool is_modulo = !is_signed; 833 834 static constexpr bool traps = __glibcxx_integral_traps; 835 static constexpr bool tinyness_before = false; 836 static constexpr float_round_style round_style = round_toward_zero; 837 }; 838 #endif 839 840 /// numeric_limits<short> specialization. 841 template<> 842 struct numeric_limits<short> 843 { 844 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 845 846 static _GLIBCXX_CONSTEXPR short 847 min() _GLIBCXX_USE_NOEXCEPT { return -__SHRT_MAX__ - 1; } 848 849 static _GLIBCXX_CONSTEXPR short 850 max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__; } 851 852 #if __cplusplus >= 201103L 853 static constexpr short 854 lowest() noexcept { return min(); } 855 #endif 856 857 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (short); 858 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (short); 859 #if __cplusplus >= 201103L 860 static constexpr int max_digits10 = 0; 861 #endif 862 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 863 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 864 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 865 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 866 867 static _GLIBCXX_CONSTEXPR short 868 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 869 870 static _GLIBCXX_CONSTEXPR short 871 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 872 873 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 874 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 875 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 876 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 877 878 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 879 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 880 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 881 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 882 = denorm_absent; 883 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 884 885 static _GLIBCXX_CONSTEXPR short 886 infinity() _GLIBCXX_USE_NOEXCEPT { return short(); } 887 888 static _GLIBCXX_CONSTEXPR short 889 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); } 890 891 static _GLIBCXX_CONSTEXPR short 892 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); } 893 894 static _GLIBCXX_CONSTEXPR short 895 denorm_min() _GLIBCXX_USE_NOEXCEPT { return short(); } 896 897 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 898 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 899 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 900 901 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 902 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 903 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 904 = round_toward_zero; 905 }; 906 907 /// numeric_limits<unsigned short> specialization. 908 template<> 909 struct numeric_limits<unsigned short> 910 { 911 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 912 913 static _GLIBCXX_CONSTEXPR unsigned short 914 min() _GLIBCXX_USE_NOEXCEPT { return 0; } 915 916 static _GLIBCXX_CONSTEXPR unsigned short 917 max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__ * 2U + 1; } 918 919 #if __cplusplus >= 201103L 920 static constexpr unsigned short 921 lowest() noexcept { return min(); } 922 #endif 923 924 static _GLIBCXX_USE_CONSTEXPR int digits 925 = __glibcxx_digits (unsigned short); 926 static _GLIBCXX_USE_CONSTEXPR int digits10 927 = __glibcxx_digits10 (unsigned short); 928 #if __cplusplus >= 201103L 929 static constexpr int max_digits10 = 0; 930 #endif 931 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 932 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 933 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 934 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 935 936 static _GLIBCXX_CONSTEXPR unsigned short 937 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 938 939 static _GLIBCXX_CONSTEXPR unsigned short 940 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 941 942 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 943 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 944 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 945 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 946 947 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 948 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 949 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 950 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 951 = denorm_absent; 952 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 953 954 static _GLIBCXX_CONSTEXPR unsigned short 955 infinity() _GLIBCXX_USE_NOEXCEPT 956 { return static_cast<unsigned short>(0); } 957 958 static _GLIBCXX_CONSTEXPR unsigned short 959 quiet_NaN() _GLIBCXX_USE_NOEXCEPT 960 { return static_cast<unsigned short>(0); } 961 962 static _GLIBCXX_CONSTEXPR unsigned short 963 signaling_NaN() _GLIBCXX_USE_NOEXCEPT 964 { return static_cast<unsigned short>(0); } 965 966 static _GLIBCXX_CONSTEXPR unsigned short 967 denorm_min() _GLIBCXX_USE_NOEXCEPT 968 { return static_cast<unsigned short>(0); } 969 970 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 971 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 972 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 973 974 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 975 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 976 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 977 = round_toward_zero; 978 }; 979 980 /// numeric_limits<int> specialization. 981 template<> 982 struct numeric_limits<int> 983 { 984 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 985 986 static _GLIBCXX_CONSTEXPR int 987 min() _GLIBCXX_USE_NOEXCEPT { return -__INT_MAX__ - 1; } 988 989 static _GLIBCXX_CONSTEXPR int 990 max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__; } 991 992 #if __cplusplus >= 201103L 993 static constexpr int 994 lowest() noexcept { return min(); } 995 #endif 996 997 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (int); 998 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (int); 999 #if __cplusplus >= 201103L 1000 static constexpr int max_digits10 = 0; 1001 #endif 1002 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1003 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1004 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1005 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1006 1007 static _GLIBCXX_CONSTEXPR int 1008 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 1009 1010 static _GLIBCXX_CONSTEXPR int 1011 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 1012 1013 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1014 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1015 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1016 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1017 1018 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1019 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1020 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1021 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1022 = denorm_absent; 1023 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1024 1025 static _GLIBCXX_CONSTEXPR int 1026 infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); } 1027 1028 static _GLIBCXX_CONSTEXPR int 1029 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); } 1030 1031 static _GLIBCXX_CONSTEXPR int 1032 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); } 1033 1034 static _GLIBCXX_CONSTEXPR int 1035 denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); } 1036 1037 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1038 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1039 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1040 1041 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1042 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1043 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1044 = round_toward_zero; 1045 }; 1046 1047 /// numeric_limits<unsigned int> specialization. 1048 template<> 1049 struct numeric_limits<unsigned int> 1050 { 1051 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1052 1053 static _GLIBCXX_CONSTEXPR unsigned int 1054 min() _GLIBCXX_USE_NOEXCEPT { return 0; } 1055 1056 static _GLIBCXX_CONSTEXPR unsigned int 1057 max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__ * 2U + 1; } 1058 1059 #if __cplusplus >= 201103L 1060 static constexpr unsigned int 1061 lowest() noexcept { return min(); } 1062 #endif 1063 1064 static _GLIBCXX_USE_CONSTEXPR int digits 1065 = __glibcxx_digits (unsigned int); 1066 static _GLIBCXX_USE_CONSTEXPR int digits10 1067 = __glibcxx_digits10 (unsigned int); 1068 #if __cplusplus >= 201103L 1069 static constexpr int max_digits10 = 0; 1070 #endif 1071 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 1072 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1073 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1074 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1075 1076 static _GLIBCXX_CONSTEXPR unsigned int 1077 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 1078 1079 static _GLIBCXX_CONSTEXPR unsigned int 1080 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 1081 1082 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1083 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1084 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1085 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1086 1087 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1088 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1089 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1090 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1091 = denorm_absent; 1092 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1093 1094 static _GLIBCXX_CONSTEXPR unsigned int 1095 infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<unsigned int>(0); } 1096 1097 static _GLIBCXX_CONSTEXPR unsigned int 1098 quiet_NaN() _GLIBCXX_USE_NOEXCEPT 1099 { return static_cast<unsigned int>(0); } 1100 1101 static _GLIBCXX_CONSTEXPR unsigned int 1102 signaling_NaN() _GLIBCXX_USE_NOEXCEPT 1103 { return static_cast<unsigned int>(0); } 1104 1105 static _GLIBCXX_CONSTEXPR unsigned int 1106 denorm_min() _GLIBCXX_USE_NOEXCEPT 1107 { return static_cast<unsigned int>(0); } 1108 1109 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1110 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1111 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 1112 1113 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1114 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1115 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1116 = round_toward_zero; 1117 }; 1118 1119 /// numeric_limits<long> specialization. 1120 template<> 1121 struct numeric_limits<long> 1122 { 1123 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1124 1125 static _GLIBCXX_CONSTEXPR long 1126 min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_MAX__ - 1; } 1127 1128 static _GLIBCXX_CONSTEXPR long 1129 max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__; } 1130 1131 #if __cplusplus >= 201103L 1132 static constexpr long 1133 lowest() noexcept { return min(); } 1134 #endif 1135 1136 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (long); 1137 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (long); 1138 #if __cplusplus >= 201103L 1139 static constexpr int max_digits10 = 0; 1140 #endif 1141 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1142 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1143 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1144 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1145 1146 static _GLIBCXX_CONSTEXPR long 1147 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 1148 1149 static _GLIBCXX_CONSTEXPR long 1150 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 1151 1152 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1153 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1154 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1155 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1156 1157 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1158 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1159 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1160 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1161 = denorm_absent; 1162 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1163 1164 static _GLIBCXX_CONSTEXPR long 1165 infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); } 1166 1167 static _GLIBCXX_CONSTEXPR long 1168 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); } 1169 1170 static _GLIBCXX_CONSTEXPR long 1171 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); } 1172 1173 static _GLIBCXX_CONSTEXPR long 1174 denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); } 1175 1176 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1177 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1178 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1179 1180 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1181 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1182 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1183 = round_toward_zero; 1184 }; 1185 1186 /// numeric_limits<unsigned long> specialization. 1187 template<> 1188 struct numeric_limits<unsigned long> 1189 { 1190 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1191 1192 static _GLIBCXX_CONSTEXPR unsigned long 1193 min() _GLIBCXX_USE_NOEXCEPT { return 0; } 1194 1195 static _GLIBCXX_CONSTEXPR unsigned long 1196 max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__ * 2UL + 1; } 1197 1198 #if __cplusplus >= 201103L 1199 static constexpr unsigned long 1200 lowest() noexcept { return min(); } 1201 #endif 1202 1203 static _GLIBCXX_USE_CONSTEXPR int digits 1204 = __glibcxx_digits (unsigned long); 1205 static _GLIBCXX_USE_CONSTEXPR int digits10 1206 = __glibcxx_digits10 (unsigned long); 1207 #if __cplusplus >= 201103L 1208 static constexpr int max_digits10 = 0; 1209 #endif 1210 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 1211 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1212 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1213 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1214 1215 static _GLIBCXX_CONSTEXPR unsigned long 1216 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 1217 1218 static _GLIBCXX_CONSTEXPR unsigned long 1219 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 1220 1221 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1222 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1223 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1224 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1225 1226 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1227 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1228 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1229 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1230 = denorm_absent; 1231 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1232 1233 static _GLIBCXX_CONSTEXPR unsigned long 1234 infinity() _GLIBCXX_USE_NOEXCEPT 1235 { return static_cast<unsigned long>(0); } 1236 1237 static _GLIBCXX_CONSTEXPR unsigned long 1238 quiet_NaN() _GLIBCXX_USE_NOEXCEPT 1239 { return static_cast<unsigned long>(0); } 1240 1241 static _GLIBCXX_CONSTEXPR unsigned long 1242 signaling_NaN() _GLIBCXX_USE_NOEXCEPT 1243 { return static_cast<unsigned long>(0); } 1244 1245 static _GLIBCXX_CONSTEXPR unsigned long 1246 denorm_min() _GLIBCXX_USE_NOEXCEPT 1247 { 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() _GLIBCXX_USE_NOEXCEPT { return -__LONG_LONG_MAX__ - 1; } 1267 1268 static _GLIBCXX_CONSTEXPR long long 1269 max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__; } 1270 1271 #if __cplusplus >= 201103L 1272 static constexpr long long 1273 lowest() noexcept { 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 #if __cplusplus >= 201103L 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() _GLIBCXX_USE_NOEXCEPT { return 0; } 1290 1291 static _GLIBCXX_CONSTEXPR long long 1292 round_error() _GLIBCXX_USE_NOEXCEPT { 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() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); } 1308 1309 static _GLIBCXX_CONSTEXPR long long 1310 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); } 1311 1312 static _GLIBCXX_CONSTEXPR long long 1313 signaling_NaN() _GLIBCXX_USE_NOEXCEPT 1314 { return static_cast<long long>(0); } 1315 1316 static _GLIBCXX_CONSTEXPR long long 1317 denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); } 1318 1319 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1320 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1321 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1322 1323 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1324 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1325 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1326 = round_toward_zero; 1327 }; 1328 1329 /// numeric_limits<unsigned long long> specialization. 1330 template<> 1331 struct numeric_limits<unsigned long long> 1332 { 1333 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1334 1335 static _GLIBCXX_CONSTEXPR unsigned long long 1336 min() _GLIBCXX_USE_NOEXCEPT { return 0; } 1337 1338 static _GLIBCXX_CONSTEXPR unsigned long long 1339 max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__ * 2ULL + 1; } 1340 1341 #if __cplusplus >= 201103L 1342 static constexpr unsigned long long 1343 lowest() noexcept { return min(); } 1344 #endif 1345 1346 static _GLIBCXX_USE_CONSTEXPR int digits 1347 = __glibcxx_digits (unsigned long long); 1348 static _GLIBCXX_USE_CONSTEXPR int digits10 1349 = __glibcxx_digits10 (unsigned long long); 1350 #if __cplusplus >= 201103L 1351 static constexpr int max_digits10 = 0; 1352 #endif 1353 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 1354 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1355 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1356 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1357 1358 static _GLIBCXX_CONSTEXPR unsigned long long 1359 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 1360 1361 static _GLIBCXX_CONSTEXPR unsigned long long 1362 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 1363 1364 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1365 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1366 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1367 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1368 1369 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1370 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1371 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1372 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1373 = denorm_absent; 1374 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1375 1376 static _GLIBCXX_CONSTEXPR unsigned long long 1377 infinity() _GLIBCXX_USE_NOEXCEPT 1378 { return static_cast<unsigned long long>(0); } 1379 1380 static _GLIBCXX_CONSTEXPR unsigned long long 1381 quiet_NaN() _GLIBCXX_USE_NOEXCEPT 1382 { return static_cast<unsigned long long>(0); } 1383 1384 static _GLIBCXX_CONSTEXPR unsigned long long 1385 signaling_NaN() _GLIBCXX_USE_NOEXCEPT 1386 { return static_cast<unsigned long long>(0); } 1387 1388 static _GLIBCXX_CONSTEXPR unsigned long long 1389 denorm_min() _GLIBCXX_USE_NOEXCEPT 1390 { return static_cast<unsigned long long>(0); } 1391 1392 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1393 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1394 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 1395 1396 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1397 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1398 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1399 = round_toward_zero; 1400 }; 1401 1402 #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128) 1403 /// numeric_limits<__int128> specialization. 1404 template<> 1405 struct numeric_limits<__int128> 1406 { 1407 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1408 1409 static _GLIBCXX_CONSTEXPR __int128 1410 min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (__int128); } 1411 1412 static _GLIBCXX_CONSTEXPR __int128 1413 max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (__int128); } 1414 1415 #if __cplusplus >= 201103L 1416 static constexpr __int128 1417 lowest() noexcept { return min(); } 1418 #endif 1419 1420 static _GLIBCXX_USE_CONSTEXPR int digits 1421 = __glibcxx_digits (__int128); 1422 static _GLIBCXX_USE_CONSTEXPR int digits10 1423 = __glibcxx_digits10 (__int128); 1424 #if __cplusplus >= 201103L 1425 static constexpr int max_digits10 = 0; 1426 #endif 1427 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1428 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1429 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1430 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1431 1432 static _GLIBCXX_CONSTEXPR __int128 1433 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 1434 1435 static _GLIBCXX_CONSTEXPR __int128 1436 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 1437 1438 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1439 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1440 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1441 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1442 1443 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1444 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1445 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1446 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1447 = denorm_absent; 1448 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1449 1450 static _GLIBCXX_CONSTEXPR __int128 1451 infinity() _GLIBCXX_USE_NOEXCEPT 1452 { return static_cast<__int128>(0); } 1453 1454 static _GLIBCXX_CONSTEXPR __int128 1455 quiet_NaN() _GLIBCXX_USE_NOEXCEPT 1456 { return static_cast<__int128>(0); } 1457 1458 static _GLIBCXX_CONSTEXPR __int128 1459 signaling_NaN() _GLIBCXX_USE_NOEXCEPT 1460 { return static_cast<__int128>(0); } 1461 1462 static _GLIBCXX_CONSTEXPR __int128 1463 denorm_min() _GLIBCXX_USE_NOEXCEPT 1464 { return static_cast<__int128>(0); } 1465 1466 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1467 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1468 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1469 1470 static _GLIBCXX_USE_CONSTEXPR bool traps 1471 = __glibcxx_integral_traps; 1472 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1473 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1474 = round_toward_zero; 1475 }; 1476 1477 /// numeric_limits<unsigned __int128> specialization. 1478 template<> 1479 struct numeric_limits<unsigned __int128> 1480 { 1481 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1482 1483 static _GLIBCXX_CONSTEXPR unsigned __int128 1484 min() _GLIBCXX_USE_NOEXCEPT { return 0; } 1485 1486 static _GLIBCXX_CONSTEXPR unsigned __int128 1487 max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (unsigned __int128); } 1488 1489 #if __cplusplus >= 201103L 1490 static constexpr unsigned __int128 1491 lowest() noexcept { return min(); } 1492 #endif 1493 1494 static _GLIBCXX_USE_CONSTEXPR int digits 1495 = __glibcxx_digits (unsigned __int128); 1496 static _GLIBCXX_USE_CONSTEXPR int digits10 1497 = __glibcxx_digits10 (unsigned __int128); 1498 #if __cplusplus >= 201103L 1499 static constexpr int max_digits10 = 0; 1500 #endif 1501 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 1502 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1503 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1504 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1505 1506 static _GLIBCXX_CONSTEXPR unsigned __int128 1507 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 1508 1509 static _GLIBCXX_CONSTEXPR unsigned __int128 1510 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 1511 1512 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1513 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1514 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1515 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1516 1517 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1518 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1519 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1520 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1521 = denorm_absent; 1522 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1523 1524 static _GLIBCXX_CONSTEXPR unsigned __int128 1525 infinity() _GLIBCXX_USE_NOEXCEPT 1526 { return static_cast<unsigned __int128>(0); } 1527 1528 static _GLIBCXX_CONSTEXPR unsigned __int128 1529 quiet_NaN() _GLIBCXX_USE_NOEXCEPT 1530 { return static_cast<unsigned __int128>(0); } 1531 1532 static _GLIBCXX_CONSTEXPR unsigned __int128 1533 signaling_NaN() _GLIBCXX_USE_NOEXCEPT 1534 { return static_cast<unsigned __int128>(0); } 1535 1536 static _GLIBCXX_CONSTEXPR unsigned __int128 1537 denorm_min() _GLIBCXX_USE_NOEXCEPT 1538 { return static_cast<unsigned __int128>(0); } 1539 1540 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1541 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1542 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 1543 1544 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1545 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1546 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1547 = round_toward_zero; 1548 }; 1549 #endif 1550 1551 /// numeric_limits<float> specialization. 1552 template<> 1553 struct numeric_limits<float> 1554 { 1555 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1556 1557 static _GLIBCXX_CONSTEXPR float 1558 min() _GLIBCXX_USE_NOEXCEPT { return __FLT_MIN__; } 1559 1560 static _GLIBCXX_CONSTEXPR float 1561 max() _GLIBCXX_USE_NOEXCEPT { return __FLT_MAX__; } 1562 1563 #if __cplusplus >= 201103L 1564 static constexpr float 1565 lowest() noexcept { return -__FLT_MAX__; } 1566 #endif 1567 1568 static _GLIBCXX_USE_CONSTEXPR int digits = __FLT_MANT_DIG__; 1569 static _GLIBCXX_USE_CONSTEXPR int digits10 = __FLT_DIG__; 1570 #if __cplusplus >= 201103L 1571 static constexpr int max_digits10 1572 = __glibcxx_max_digits10 (__FLT_MANT_DIG__); 1573 #endif 1574 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1575 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; 1576 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; 1577 static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; 1578 1579 static _GLIBCXX_CONSTEXPR float 1580 epsilon() _GLIBCXX_USE_NOEXCEPT { return __FLT_EPSILON__; } 1581 1582 static _GLIBCXX_CONSTEXPR float 1583 round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5F; } 1584 1585 static _GLIBCXX_USE_CONSTEXPR int min_exponent = __FLT_MIN_EXP__; 1586 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __FLT_MIN_10_EXP__; 1587 static _GLIBCXX_USE_CONSTEXPR int max_exponent = __FLT_MAX_EXP__; 1588 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __FLT_MAX_10_EXP__; 1589 1590 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __FLT_HAS_INFINITY__; 1591 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__; 1592 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; 1593 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1594 = bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent; 1595 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss 1596 = __glibcxx_float_has_denorm_loss; 1597 1598 static _GLIBCXX_CONSTEXPR float 1599 infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_valf(); } 1600 1601 static _GLIBCXX_CONSTEXPR float 1602 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanf(""); } 1603 1604 static _GLIBCXX_CONSTEXPR float 1605 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansf(""); } 1606 1607 static _GLIBCXX_CONSTEXPR float 1608 denorm_min() _GLIBCXX_USE_NOEXCEPT { return __FLT_DENORM_MIN__; } 1609 1610 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 1611 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 1612 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1613 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1614 1615 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_float_traps; 1616 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before 1617 = __glibcxx_float_tinyness_before; 1618 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1619 = round_to_nearest; 1620 }; 1621 1622 #undef __glibcxx_float_has_denorm_loss 1623 #undef __glibcxx_float_traps 1624 #undef __glibcxx_float_tinyness_before 1625 1626 /// numeric_limits<double> specialization. 1627 template<> 1628 struct numeric_limits<double> 1629 { 1630 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1631 1632 static _GLIBCXX_CONSTEXPR double 1633 min() _GLIBCXX_USE_NOEXCEPT { return __DBL_MIN__; } 1634 1635 static _GLIBCXX_CONSTEXPR double 1636 max() _GLIBCXX_USE_NOEXCEPT { return __DBL_MAX__; } 1637 1638 #if __cplusplus >= 201103L 1639 static constexpr double 1640 lowest() noexcept { return -__DBL_MAX__; } 1641 #endif 1642 1643 static _GLIBCXX_USE_CONSTEXPR int digits = __DBL_MANT_DIG__; 1644 static _GLIBCXX_USE_CONSTEXPR int digits10 = __DBL_DIG__; 1645 #if __cplusplus >= 201103L 1646 static constexpr int max_digits10 1647 = __glibcxx_max_digits10 (__DBL_MANT_DIG__); 1648 #endif 1649 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1650 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; 1651 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; 1652 static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; 1653 1654 static _GLIBCXX_CONSTEXPR double 1655 epsilon() _GLIBCXX_USE_NOEXCEPT { return __DBL_EPSILON__; } 1656 1657 static _GLIBCXX_CONSTEXPR double 1658 round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5; } 1659 1660 static _GLIBCXX_USE_CONSTEXPR int min_exponent = __DBL_MIN_EXP__; 1661 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __DBL_MIN_10_EXP__; 1662 static _GLIBCXX_USE_CONSTEXPR int max_exponent = __DBL_MAX_EXP__; 1663 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __DBL_MAX_10_EXP__; 1664 1665 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __DBL_HAS_INFINITY__; 1666 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__; 1667 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; 1668 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1669 = bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent; 1670 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss 1671 = __glibcxx_double_has_denorm_loss; 1672 1673 static _GLIBCXX_CONSTEXPR double 1674 infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_val(); } 1675 1676 static _GLIBCXX_CONSTEXPR double 1677 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nan(""); } 1678 1679 static _GLIBCXX_CONSTEXPR double 1680 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nans(""); } 1681 1682 static _GLIBCXX_CONSTEXPR double 1683 denorm_min() _GLIBCXX_USE_NOEXCEPT { return __DBL_DENORM_MIN__; } 1684 1685 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 1686 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 1687 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1688 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1689 1690 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_double_traps; 1691 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before 1692 = __glibcxx_double_tinyness_before; 1693 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1694 = round_to_nearest; 1695 }; 1696 1697 #undef __glibcxx_double_has_denorm_loss 1698 #undef __glibcxx_double_traps 1699 #undef __glibcxx_double_tinyness_before 1700 1701 /// numeric_limits<long double> specialization. 1702 template<> 1703 struct numeric_limits<long double> 1704 { 1705 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1706 1707 static _GLIBCXX_CONSTEXPR long double 1708 min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MIN__; } 1709 1710 static _GLIBCXX_CONSTEXPR long double 1711 max() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MAX__; } 1712 1713 #if __cplusplus >= 201103L 1714 static constexpr long double 1715 lowest() noexcept { return -__LDBL_MAX__; } 1716 #endif 1717 1718 static _GLIBCXX_USE_CONSTEXPR int digits = __LDBL_MANT_DIG__; 1719 static _GLIBCXX_USE_CONSTEXPR int digits10 = __LDBL_DIG__; 1720 #if __cplusplus >= 201103L 1721 static _GLIBCXX_USE_CONSTEXPR int max_digits10 1722 = __glibcxx_max_digits10 (__LDBL_MANT_DIG__); 1723 #endif 1724 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1725 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; 1726 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; 1727 static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; 1728 1729 static _GLIBCXX_CONSTEXPR long double 1730 epsilon() _GLIBCXX_USE_NOEXCEPT { return __LDBL_EPSILON__; } 1731 1732 static _GLIBCXX_CONSTEXPR long double 1733 round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5L; } 1734 1735 static _GLIBCXX_USE_CONSTEXPR int min_exponent = __LDBL_MIN_EXP__; 1736 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __LDBL_MIN_10_EXP__; 1737 static _GLIBCXX_USE_CONSTEXPR int max_exponent = __LDBL_MAX_EXP__; 1738 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __LDBL_MAX_10_EXP__; 1739 1740 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __LDBL_HAS_INFINITY__; 1741 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__; 1742 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; 1743 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1744 = bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent; 1745 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss 1746 = __glibcxx_long_double_has_denorm_loss; 1747 1748 static _GLIBCXX_CONSTEXPR long double 1749 infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_vall(); } 1750 1751 static _GLIBCXX_CONSTEXPR long double 1752 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanl(""); } 1753 1754 static _GLIBCXX_CONSTEXPR long double 1755 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansl(""); } 1756 1757 static _GLIBCXX_CONSTEXPR long double 1758 denorm_min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_DENORM_MIN__; } 1759 1760 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 1761 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 1762 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1763 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1764 1765 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_long_double_traps; 1766 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = 1767 __glibcxx_long_double_tinyness_before; 1768 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = 1769 round_to_nearest; 1770 }; 1771 1772 #undef __glibcxx_long_double_has_denorm_loss 1773 #undef __glibcxx_long_double_traps 1774 #undef __glibcxx_long_double_tinyness_before 1775 1776 _GLIBCXX_END_NAMESPACE_VERSION 1777 } // namespace 1778 1779 #undef __glibcxx_signed 1780 #undef __glibcxx_min 1781 #undef __glibcxx_max 1782 #undef __glibcxx_digits 1783 #undef __glibcxx_digits10 1784 #undef __glibcxx_max_digits10 1785 1786 #endif // _GLIBCXX_NUMERIC_LIMITS 1787
