244 KiB
244 KiB
<html lang="en">
<head>
</head>
</html>
| LCOV - code coverage report | ||||||||||||||||||||||
 | ||||||||||||||||||||||
|
||||||||||||||||||||||
|
Line data Source code 1 : // The template and inlines for the numeric_limits classes. -*- C++ -*- 2 : 3 : // Copyright (C) 1999-2023 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@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_b(T,B) ((T)(-1) < 0) 129 : 130 : #define __glibcxx_min_b(T,B) \ 131 : (__glibcxx_signed_b (T,B) ? -__glibcxx_max_b (T,B) - 1 : (T)0) 132 : 133 : #define __glibcxx_max_b(T,B) \ 134 : (__glibcxx_signed_b (T,B) ? \ 135 : (((((T)1 << (__glibcxx_digits_b (T,B) - 1)) - 1) << 1) + 1) : ~(T)0) 136 : 137 : #define __glibcxx_digits_b(T,B) \ 138 : (B - __glibcxx_signed_b (T,B)) 139 : 140 : // The fraction 643/2136 approximates log10(2) to 7 significant digits. 141 : #define __glibcxx_digits10_b(T,B) \ 142 : (__glibcxx_digits_b (T,B) * 643L / 2136) 143 : 144 : #define __glibcxx_signed(T) \ 145 : __glibcxx_signed_b (T, sizeof(T) * __CHAR_BIT__) 146 : #define __glibcxx_min(T) \ 147 : __glibcxx_min_b (T, sizeof(T) * __CHAR_BIT__) 148 : #define __glibcxx_max(T) \ 149 : __glibcxx_max_b (T, sizeof(T) * __CHAR_BIT__) 150 : #define __glibcxx_digits(T) \ 151 : __glibcxx_digits_b (T, sizeof(T) * __CHAR_BIT__) 152 : #define __glibcxx_digits10(T) \ 153 : __glibcxx_digits10_b (T, sizeof(T) * __CHAR_BIT__) 154 : 155 : #define __glibcxx_max_digits10(T) \ 156 : (2 + (T) * 643L / 2136) 157 : 158 : namespace std _GLIBCXX_VISIBILITY(default) 159 : { 160 : _GLIBCXX_BEGIN_NAMESPACE_VERSION 161 : 162 : /** 163 : * @brief Describes the rounding style for floating-point types. 164 : * 165 : * This is used in the std::numeric_limits class. 166 : */ 167 : enum float_round_style 168 : { 169 : round_indeterminate = -1, ///< Intermediate. 170 : round_toward_zero = 0, ///< To zero. 171 : round_to_nearest = 1, ///< To the nearest representable value. 172 : round_toward_infinity = 2, ///< To infinity. 173 : round_toward_neg_infinity = 3 ///< To negative infinity. 174 : }; 175 : 176 : /** 177 : * @brief Describes the denormalization for floating-point types. 178 : * 179 : * These values represent the presence or absence of a variable number 180 : * of exponent bits. This type is used in the std::numeric_limits class. 181 : */ 182 : enum float_denorm_style 183 : { 184 : /// Indeterminate at compile time whether denormalized values are allowed. 185 : denorm_indeterminate = -1, 186 : /// The type does not allow denormalized values. 187 : denorm_absent = 0, 188 : /// The type allows denormalized values. 189 : denorm_present = 1 190 : }; 191 : 192 : /** 193 : * @brief Part of std::numeric_limits. 194 : * 195 : * The @c static @c const members are usable as integral constant 196 : * expressions. 197 : * 198 : * @note This is a separate class for purposes of efficiency; you 199 : * should only access these members as part of an instantiation 200 : * of the std::numeric_limits class. 201 : */ 202 : struct __numeric_limits_base 203 : { 204 : /** This will be true for all fundamental types (which have 205 : specializations), and false for everything else. */ 206 : static _GLIBCXX_USE_CONSTEXPR bool is_specialized = false; 207 : 208 : /** The number of @c radix digits that be represented without change: for 209 : integer types, the number of non-sign bits in the mantissa; for 210 : floating types, the number of @c radix digits in the mantissa. */ 211 : static _GLIBCXX_USE_CONSTEXPR int digits = 0; 212 : 213 : /** The number of base 10 digits that can be represented without change. */ 214 : static _GLIBCXX_USE_CONSTEXPR int digits10 = 0; 215 : 216 : #if __cplusplus >= 201103L 217 : /** The number of base 10 digits required to ensure that values which 218 : differ are always differentiated. */ 219 : static constexpr int max_digits10 = 0; 220 : #endif 221 : 222 : /** True if the type is signed. */ 223 : static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 224 : 225 : /** True if the type is integer. */ 226 : static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; 227 : 228 : /** True if the type uses an exact representation. All integer types are 229 : exact, but not all exact types are integer. For example, rational and 230 : fixed-exponent representations are exact but not integer. */ 231 : static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; 232 : 233 : /** For integer types, specifies the base of the representation. For 234 : floating types, specifies the base of the exponent representation. */ 235 : static _GLIBCXX_USE_CONSTEXPR int radix = 0; 236 : 237 : /** The minimum negative integer such that @c radix raised to the power of 238 : (one less than that integer) is a normalized floating point number. */ 239 : static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 240 : 241 : /** The minimum negative integer such that 10 raised to that power is in 242 : the range of normalized floating point numbers. */ 243 : static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 244 : 245 : /** The maximum positive integer such that @c radix raised to the power of 246 : (one less than that integer) is a representable finite floating point 247 : number. */ 248 : static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 249 : 250 : /** The maximum positive integer such that 10 raised to that power is in 251 : the range of representable finite floating point numbers. */ 252 : static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 253 : 254 : /** True if the type has a representation for positive infinity. */ 255 : static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 256 : 257 : /** True if the type has a representation for a quiet (non-signaling) 258 : Not a Number. */ 259 : static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 260 : 261 : /** True if the type has a representation for a signaling 262 : Not a Number. */ 263 : static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 264 : 265 : /** See std::float_denorm_style for more information. */ 266 : static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; 267 : 268 : /** True if loss of accuracy is detected as a denormalization loss, 269 : rather than as an inexact result. */ 270 : static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 271 : 272 : /** True if-and-only-if the type adheres to the IEC 559 standard, also 273 : known as IEEE 754. (Only makes sense for floating point types.) */ 274 : static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 275 : 276 : /** True if the set of values representable by the type is 277 : finite. All built-in types are bounded, this member would be 278 : false for arbitrary precision types. */ 279 : static _GLIBCXX_USE_CONSTEXPR bool is_bounded = false; 280 : 281 : /** True if the type is @e modulo. A type is modulo if, for any 282 : operation involving +, -, or * on values of that type whose 283 : result would fall outside the range [min(),max()], the value 284 : returned differs from the true value by an integer multiple of 285 : max() - min() + 1. On most machines, this is false for floating 286 : types, true for unsigned integers, and true for signed integers. 287 : See PR22200 about signed integers. */ 288 : static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 289 : 290 : /** True if trapping is implemented for this type. */ 291 : static _GLIBCXX_USE_CONSTEXPR bool traps = false; 292 : 293 : /** True if tininess is detected before rounding. (see IEC 559) */ 294 : static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 295 : 296 : /** See std::float_round_style for more information. This is only 297 : meaningful for floating types; integer types will all be 298 : round_toward_zero. */ 299 : static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = 300 : round_toward_zero; 301 : }; 302 : 303 : /** 304 : * @brief Properties of fundamental types. 305 : * 306 : * This class allows a program to obtain information about the 307 : * representation of a fundamental type on a given platform. For 308 : * non-fundamental types, the functions will return 0 and the data 309 : * members will all be @c false. 310 : */ 311 : template<typename _Tp> 312 : struct numeric_limits : public __numeric_limits_base 313 : { 314 : /** The minimum finite value, or for floating types with 315 : denormalization, the minimum positive normalized value. */ 316 : static _GLIBCXX_CONSTEXPR _Tp 317 : min() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 318 : 319 : /** The maximum finite value. */ 320 : static _GLIBCXX_CONSTEXPR _Tp 321 : max() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 322 : 323 : #if __cplusplus >= 201103L 324 : /** A finite value x such that there is no other finite value y 325 : * where y < x. */ 326 : static constexpr _Tp 327 : lowest() noexcept { return _Tp(); } 328 : #endif 329 : 330 : /** The @e machine @e epsilon: the difference between 1 and the least 331 : value greater than 1 that is representable. */ 332 : static _GLIBCXX_CONSTEXPR _Tp 333 : epsilon() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 334 : 335 : /** The maximum rounding error measurement (see LIA-1). */ 336 : static _GLIBCXX_CONSTEXPR _Tp 337 : round_error() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 338 : 339 : /** The representation of positive infinity, if @c has_infinity. */ 340 : static _GLIBCXX_CONSTEXPR _Tp 341 : infinity() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 342 : 343 : /** The representation of a quiet Not a Number, 344 : if @c has_quiet_NaN. */ 345 : static _GLIBCXX_CONSTEXPR _Tp 346 : quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 347 : 348 : /** The representation of a signaling Not a Number, if 349 : @c has_signaling_NaN. */ 350 : static _GLIBCXX_CONSTEXPR _Tp 351 : signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 352 : 353 : /** The minimum positive denormalized value. For types where 354 : @c has_denorm is false, this is the minimum positive normalized 355 : value. */ 356 : static _GLIBCXX_CONSTEXPR _Tp 357 : denorm_min() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } 358 : }; 359 : 360 : // _GLIBCXX_RESOLVE_LIB_DEFECTS 361 : // 559. numeric_limits<const T> 362 : 363 : template<typename _Tp> 364 : struct numeric_limits<const _Tp> 365 : : public numeric_limits<_Tp> { }; 366 : 367 : template<typename _Tp> 368 : struct numeric_limits<volatile _Tp> 369 : : public numeric_limits<_Tp> { }; 370 : 371 : template<typename _Tp> 372 : struct numeric_limits<const volatile _Tp> 373 : : public numeric_limits<_Tp> { }; 374 : 375 : // Now there follow 16 explicit specializations. Yes, 16. Make sure 376 : // you get the count right. (18 in C++11 mode, with char16_t and char32_t.) 377 : // (+1 if char8_t is enabled.) 378 : 379 : // _GLIBCXX_RESOLVE_LIB_DEFECTS 380 : // 184. numeric_limits<bool> wording problems 381 : 382 : /// numeric_limits<bool> specialization. 383 : template<> 384 : struct numeric_limits<bool> 385 : { 386 : static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 387 : 388 : static _GLIBCXX_CONSTEXPR bool 389 : min() _GLIBCXX_USE_NOEXCEPT { return false; } 390 : 391 : static _GLIBCXX_CONSTEXPR bool 392 : max() _GLIBCXX_USE_NOEXCEPT { return true; } 393 : 394 : #if __cplusplus >= 201103L 395 : static constexpr bool 396 : lowest() noexcept { return min(); } 397 : #endif 398 : static _GLIBCXX_USE_CONSTEXPR int digits = 1; 399 : static _GLIBCXX_USE_CONSTEXPR int digits10 = 0; 400 : #if __cplusplus >= 201103L 401 : static constexpr int max_digits10 = 0; 402 : #endif 403 : static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 404 : static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 405 : static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 406 : static _GLIBCXX_USE_CONSTEXPR int radix = 2; 407 : 408 : static _GLIBCXX_CONSTEXPR bool 409 : epsilon() _GLIBCXX_USE_NOEXCEPT { return false; } 410 : 411 : static _GLIBCXX_CONSTEXPR bool 412 : round_error() _GLIBCXX_USE_NOEXCEPT { return false; } 413 : 414 : static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 415 : static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 416 : static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 417 : static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 418 : 419 : static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 420 : static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 421 : static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 422 : static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 423 : = denorm_absent; 424 : static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 425 : 426 : static _GLIBCXX_CONSTEXPR bool 427 : infinity() _GLIBCXX_USE_NOEXCEPT { return false; } 428 : 429 : static _GLIBCXX_CONSTEXPR bool 430 : quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return false; } 431 : 432 : static _GLIBCXX_CONSTEXPR bool 433 : signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return false; } 434 : 435 : static _GLIBCXX_CONSTEXPR bool 436 : denorm_min() _GLIBCXX_USE_NOEXCEPT { return false; } 437 : 438 : static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 439 : static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 440 : static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 441 : 442 : // It is not clear what it means for a boolean type to trap. 443 : // This is a DR on the LWG issue list. Here, I use integer 444 : // promotion semantics. 445 : static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 446 : static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 447 : static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 448 : = round_toward_zero; 449 : }; 450 : 451 : /// numeric_limits<char> specialization. 452 : template<> 453 : struct numeric_limits<char> 454 : { 455 : static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 456 : 457 : static _GLIBCXX_CONSTEXPR char 458 : min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min(char); } 459 : 460 : static _GLIBCXX_CONSTEXPR char 461 : max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max(char); } 462 : 463 : #if __cplusplus >= 201103L 464 : static constexpr char 465 : lowest() noexcept { return min(); } 466 : #endif 467 : 468 : static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char); 469 : static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (char); 470 : #if __cplusplus >= 201103L 471 : static constexpr int max_digits10 = 0; 472 : #endif 473 : static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (char); 474 : static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 475 : static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 476 : static _GLIBCXX_USE_CONSTEXPR int radix = 2; 477 : 478 : static _GLIBCXX_CONSTEXPR char 479 : epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 480 : 481 : static _GLIBCXX_CONSTEXPR char 482 : round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 483 : 484 : static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 485 : static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 486 : static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 487 : static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 488 : 489 : static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 490 : static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 491 : static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 492 : static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 493 : = denorm_absent; 494 : static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 495 : 496 : static _GLIBCXX_CONSTEXPR 497 : char infinity() _GLIBCXX_USE_NOEXCEPT { return char(); } 498 : 499 : static _GLIBCXX_CONSTEXPR char 500 : quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); } 501 : 502 : static _GLIBCXX_CONSTEXPR char 503 : signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); } 504 : 505 : static _GLIBCXX_CONSTEXPR char 506 : denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<char>(0); } 507 : 508 : static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 509 : static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 510 : static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed; 511 : 512 : static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 513 : static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 514 : static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 515 : = round_toward_zero; 516 : }; 517 : 518 : /// numeric_limits<signed char> specialization. 519 : template<> 520 : struct numeric_limits<signed char> 521 : { 522 : static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 523 : 524 : static _GLIBCXX_CONSTEXPR signed char 525 : min() _GLIBCXX_USE_NOEXCEPT { return -__SCHAR_MAX__ - 1; } 526 : 527 : static _GLIBCXX_CONSTEXPR signed char 528 : max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__; } 529 : 530 : #if __cplusplus >= 201103L 531 : static constexpr signed char 532 : lowest() noexcept { return min(); } 533 : #endif 534 : 535 : static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (signed char); 536 : static _GLIBCXX_USE_CONSTEXPR int digits10 537 : = __glibcxx_digits10 (signed char); 538 : #if __cplusplus >= 201103L 539 : static constexpr int max_digits10 = 0; 540 : #endif 541 : static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 542 : static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 543 : static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 544 : static _GLIBCXX_USE_CONSTEXPR int radix = 2; 545 : 546 : static _GLIBCXX_CONSTEXPR signed char 547 : epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 548 : 549 : static _GLIBCXX_CONSTEXPR signed char 550 : round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 551 : 552 : static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 553 : static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 554 : static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 555 : static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 556 : 557 : static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 558 : static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 559 : static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 560 : static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 561 : = denorm_absent; 562 : static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 563 : 564 : static _GLIBCXX_CONSTEXPR signed char 565 : infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); } 566 : 567 : static _GLIBCXX_CONSTEXPR signed char 568 : quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); } 569 : 570 : static _GLIBCXX_CONSTEXPR signed char 571 : signaling_NaN() _GLIBCXX_USE_NOEXCEPT 572 : { return static_cast<signed char>(0); } 573 : 574 : static _GLIBCXX_CONSTEXPR signed char 575 : denorm_min() _GLIBCXX_USE_NOEXCEPT 576 : { return static_cast<signed char>(0); } 577 : 578 : static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 579 : static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 580 : static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 581 : 582 : static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 583 : static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 584 : static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 585 : = round_toward_zero; 586 : }; 587 : 588 : /// numeric_limits<unsigned char> specialization. 589 : template<> 590 : struct numeric_limits<unsigned char> 591 : { 592 : static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 593 : 594 : static _GLIBCXX_CONSTEXPR unsigned char 595 : min() _GLIBCXX_USE_NOEXCEPT { return 0; } 596 : 597 : static _GLIBCXX_CONSTEXPR unsigned char 598 : max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__ * 2U + 1; } 599 : 600 : #if __cplusplus >= 201103L 601 : static constexpr unsigned char 602 : lowest() noexcept { return min(); } 603 : #endif 604 : 605 : static _GLIBCXX_USE_CONSTEXPR int digits 606 : = __glibcxx_digits (unsigned char); 607 : static _GLIBCXX_USE_CONSTEXPR int digits10 608 : = __glibcxx_digits10 (unsigned char); 609 : #if __cplusplus >= 201103L 610 : static constexpr int max_digits10 = 0; 611 : #endif 612 : static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 613 : static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 614 : static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 615 : static _GLIBCXX_USE_CONSTEXPR int radix = 2; 616 : 617 : static _GLIBCXX_CONSTEXPR unsigned char 618 : epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 619 : 620 : static _GLIBCXX_CONSTEXPR unsigned char 621 : round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 622 : 623 : static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 624 : static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 625 : static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 626 : static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 627 : 628 : static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 629 : static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 630 : static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 631 : static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 632 : = denorm_absent; 633 : static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 634 : 635 : static _GLIBCXX_CONSTEXPR unsigned char 636 : infinity() _GLIBCXX_USE_NOEXCEPT 637 : { return static_cast<unsigned char>(0); } 638 : 639 : static _GLIBCXX_CONSTEXPR unsigned char 640 : quiet_NaN() _GLIBCXX_USE_NOEXCEPT 641 : { return static_cast<unsigned char>(0); } 642 : 643 : static _GLIBCXX_CONSTEXPR unsigned char 644 : signaling_NaN() _GLIBCXX_USE_NOEXCEPT 645 : { return static_cast<unsigned char>(0); } 646 : 647 : static _GLIBCXX_CONSTEXPR unsigned char 648 : denorm_min() _GLIBCXX_USE_NOEXCEPT 649 : { return static_cast<unsigned char>(0); } 650 : 651 : static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 652 : static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 653 : static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 654 : 655 : static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 656 : static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 657 : static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 658 : = round_toward_zero; 659 : }; 660 : 661 : /// numeric_limits<wchar_t> specialization. 662 : template<> 663 : struct numeric_limits<wchar_t> 664 : { 665 : static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 666 : 667 : static _GLIBCXX_CONSTEXPR wchar_t 668 : min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (wchar_t); } 669 : 670 : static _GLIBCXX_CONSTEXPR wchar_t 671 : max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (wchar_t); } 672 : 673 : #if __cplusplus >= 201103L 674 : static constexpr wchar_t 675 : lowest() noexcept { return min(); } 676 : #endif 677 : 678 : static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (wchar_t); 679 : static _GLIBCXX_USE_CONSTEXPR int digits10 680 : = __glibcxx_digits10 (wchar_t); 681 : #if __cplusplus >= 201103L 682 : static constexpr int max_digits10 = 0; 683 : #endif 684 : static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (wchar_t); 685 : static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 686 : static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 687 : static _GLIBCXX_USE_CONSTEXPR int radix = 2; 688 : 689 : static _GLIBCXX_CONSTEXPR wchar_t 690 : epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 691 : 692 : static _GLIBCXX_CONSTEXPR wchar_t 693 : round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 694 : 695 : static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 696 : static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 697 : static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 698 : static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 699 : 700 : static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 701 : static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 702 : static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 703 : static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 704 : = denorm_absent; 705 : static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 706 : 707 : static _GLIBCXX_CONSTEXPR wchar_t 708 : infinity() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } 709 : 710 : static _GLIBCXX_CONSTEXPR wchar_t 711 : quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } 712 : 713 : static _GLIBCXX_CONSTEXPR wchar_t 714 : signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } 715 : 716 : static _GLIBCXX_CONSTEXPR wchar_t 717 : denorm_min() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } 718 : 719 : static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 720 : static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 721 : static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed; 722 : 723 : static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 724 : static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 725 : static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 726 : = round_toward_zero; 727 : }; 728 : 729 : #if _GLIBCXX_USE_CHAR8_T 730 : /// numeric_limits<char8_t> specialization. 731 : template<> 732 : struct numeric_limits<char8_t> 733 : { 734 : static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 735 : 736 : static _GLIBCXX_CONSTEXPR char8_t 737 : min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (char8_t); } 738 : 739 : static _GLIBCXX_CONSTEXPR char8_t 740 : max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (char8_t); } 741 : 742 : static _GLIBCXX_CONSTEXPR char8_t 743 : lowest() _GLIBCXX_USE_NOEXCEPT { return min(); } 744 : 745 : static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char8_t); 746 : static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (char8_t); 747 : static _GLIBCXX_USE_CONSTEXPR int max_digits10 = 0; 748 : static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (char8_t); 749 : static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 750 : static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 751 : static _GLIBCXX_USE_CONSTEXPR int radix = 2; 752 : 753 : static _GLIBCXX_CONSTEXPR char8_t 754 : epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 755 : 756 : static _GLIBCXX_CONSTEXPR char8_t 757 : round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 758 : 759 : static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 760 : static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 761 : static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 762 : static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 763 : 764 : static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 765 : static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 766 : static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 767 : static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 768 : = denorm_absent; 769 : static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 770 : 771 : static _GLIBCXX_CONSTEXPR char8_t 772 : infinity() _GLIBCXX_USE_NOEXCEPT { return char8_t(); } 773 : 774 : static _GLIBCXX_CONSTEXPR char8_t 775 : quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return char8_t(); } 776 : 777 : static _GLIBCXX_CONSTEXPR char8_t 778 : signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return char8_t(); } 779 : 780 : static _GLIBCXX_CONSTEXPR char8_t 781 : denorm_min() _GLIBCXX_USE_NOEXCEPT { return char8_t(); } 782 : 783 : static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 784 : static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 785 : static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed; 786 : 787 : static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 788 : static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 789 : static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 790 : = round_toward_zero; 791 : }; 792 : #endif 793 : 794 : #if __cplusplus >= 201103L 795 : /// numeric_limits<char16_t> specialization. 796 : template<> 797 : struct numeric_limits<char16_t> 798 : { 799 : static constexpr bool is_specialized = true; 800 : 801 : static constexpr char16_t 802 : min() noexcept { return __glibcxx_min (char16_t); } 803 : 804 : static constexpr char16_t 805 : max() noexcept { return __glibcxx_max (char16_t); } 806 : 807 : static constexpr char16_t 808 : lowest() noexcept { return min(); } 809 : 810 : static constexpr int digits = __glibcxx_digits (char16_t); 811 : static constexpr int digits10 = __glibcxx_digits10 (char16_t); 812 : static constexpr int max_digits10 = 0; 813 : static constexpr bool is_signed = __glibcxx_signed (char16_t); 814 : static constexpr bool is_integer = true; 815 : static constexpr bool is_exact = true; 816 : static constexpr int radix = 2; 817 : 818 : static constexpr char16_t 819 : epsilon() noexcept { return 0; } 820 : 821 : static constexpr char16_t 822 : round_error() noexcept { return 0; } 823 : 824 : static constexpr int min_exponent = 0; 825 : static constexpr int min_exponent10 = 0; 826 : static constexpr int max_exponent = 0; 827 : static constexpr int max_exponent10 = 0; 828 : 829 : static constexpr bool has_infinity = false; 830 : static constexpr bool has_quiet_NaN = false; 831 : static constexpr bool has_signaling_NaN = false; 832 : static constexpr float_denorm_style has_denorm = denorm_absent; 833 : static constexpr bool has_denorm_loss = false; 834 : 835 : static constexpr char16_t 836 : infinity() noexcept { return char16_t(); } 837 : 838 : static constexpr char16_t 839 : quiet_NaN() noexcept { return char16_t(); } 840 : 841 : static constexpr char16_t 842 : signaling_NaN() noexcept { return char16_t(); } 843 : 844 : static constexpr char16_t 845 : denorm_min() noexcept { return char16_t(); } 846 : 847 : static constexpr bool is_iec559 = false; 848 : static constexpr bool is_bounded = true; 849 : static constexpr bool is_modulo = !is_signed; 850 : 851 : static constexpr bool traps = __glibcxx_integral_traps; 852 : static constexpr bool tinyness_before = false; 853 : static constexpr float_round_style round_style = round_toward_zero; 854 : }; 855 : 856 : /// numeric_limits<char32_t> specialization. 857 : template<> 858 : struct numeric_limits<char32_t> 859 : { 860 : static constexpr bool is_specialized = true; 861 : 862 : static constexpr char32_t 863 : min() noexcept { return __glibcxx_min (char32_t); } 864 : 865 : static constexpr char32_t 866 : max() noexcept { return __glibcxx_max (char32_t); } 867 : 868 : static constexpr char32_t 869 : lowest() noexcept { return min(); } 870 : 871 : static constexpr int digits = __glibcxx_digits (char32_t); 872 : static constexpr int digits10 = __glibcxx_digits10 (char32_t); 873 : static constexpr int max_digits10 = 0; 874 : static constexpr bool is_signed = __glibcxx_signed (char32_t); 875 : static constexpr bool is_integer = true; 876 : static constexpr bool is_exact = true; 877 : static constexpr int radix = 2; 878 : 879 : static constexpr char32_t 880 : epsilon() noexcept { return 0; } 881 : 882 : static constexpr char32_t 883 : round_error() noexcept { return 0; } 884 : 885 : static constexpr int min_exponent = 0; 886 : static constexpr int min_exponent10 = 0; 887 : static constexpr int max_exponent = 0; 888 : static constexpr int max_exponent10 = 0; 889 : 890 : static constexpr bool has_infinity = false; 891 : static constexpr bool has_quiet_NaN = false; 892 : static constexpr bool has_signaling_NaN = false; 893 : static constexpr float_denorm_style has_denorm = denorm_absent; 894 : static constexpr bool has_denorm_loss = false; 895 : 896 : static constexpr char32_t 897 : infinity() noexcept { return char32_t(); } 898 : 899 : static constexpr char32_t 900 : quiet_NaN() noexcept { return char32_t(); } 901 : 902 : static constexpr char32_t 903 : signaling_NaN() noexcept { return char32_t(); } 904 : 905 : static constexpr char32_t 906 : denorm_min() noexcept { return char32_t(); } 907 : 908 : static constexpr bool is_iec559 = false; 909 : static constexpr bool is_bounded = true; 910 : static constexpr bool is_modulo = !is_signed; 911 : 912 : static constexpr bool traps = __glibcxx_integral_traps; 913 : static constexpr bool tinyness_before = false; 914 : static constexpr float_round_style round_style = round_toward_zero; 915 : }; 916 : #endif 917 : 918 : /// numeric_limits<short> specialization. 919 : template<> 920 : struct numeric_limits<short> 921 : { 922 : static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 923 : 924 : static _GLIBCXX_CONSTEXPR short 925 : min() _GLIBCXX_USE_NOEXCEPT { return -__SHRT_MAX__ - 1; } 926 : 927 : static _GLIBCXX_CONSTEXPR short 928 : max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__; } 929 : 930 : #if __cplusplus >= 201103L 931 : static constexpr short 932 : lowest() noexcept { return min(); } 933 : #endif 934 : 935 : static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (short); 936 : static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (short); 937 : #if __cplusplus >= 201103L 938 : static constexpr int max_digits10 = 0; 939 : #endif 940 : static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 941 : static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 942 : static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 943 : static _GLIBCXX_USE_CONSTEXPR int radix = 2; 944 : 945 : static _GLIBCXX_CONSTEXPR short 946 : epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 947 : 948 : static _GLIBCXX_CONSTEXPR short 949 : round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 950 : 951 : static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 952 : static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 953 : static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 954 : static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 955 : 956 : static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 957 : static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 958 : static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 959 : static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 960 : = denorm_absent; 961 : static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 962 : 963 : static _GLIBCXX_CONSTEXPR short 964 : infinity() _GLIBCXX_USE_NOEXCEPT { return short(); } 965 : 966 : static _GLIBCXX_CONSTEXPR short 967 : quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); } 968 : 969 : static _GLIBCXX_CONSTEXPR short 970 : signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); } 971 : 972 : static _GLIBCXX_CONSTEXPR short 973 : denorm_min() _GLIBCXX_USE_NOEXCEPT { return short(); } 974 : 975 : static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 976 : static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 977 : static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 978 : 979 : static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 980 : static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 981 : static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 982 : = round_toward_zero; 983 : }; 984 : 985 : /// numeric_limits<unsigned short> specialization. 986 : template<> 987 : struct numeric_limits<unsigned short> 988 : { 989 : static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 990 : 991 : static _GLIBCXX_CONSTEXPR unsigned short 992 : min() _GLIBCXX_USE_NOEXCEPT { return 0; } 993 : 994 : static _GLIBCXX_CONSTEXPR unsigned short 995 : max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__ * 2U + 1; } 996 : 997 : #if __cplusplus >= 201103L 998 : static constexpr unsigned short 999 : lowest() noexcept { return min(); } 1000 : #endif 1001 : 1002 : static _GLIBCXX_USE_CONSTEXPR int digits 1003 : = __glibcxx_digits (unsigned short); 1004 : static _GLIBCXX_USE_CONSTEXPR int digits10 1005 : = __glibcxx_digits10 (unsigned short); 1006 : #if __cplusplus >= 201103L 1007 : static constexpr int max_digits10 = 0; 1008 : #endif 1009 : static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 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 unsigned short 1015 : epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 1016 : 1017 : static _GLIBCXX_CONSTEXPR unsigned short 1018 : round_error() _GLIBCXX_USE_NOEXCEPT { 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 unsigned short 1033 : infinity() _GLIBCXX_USE_NOEXCEPT 1034 : { return static_cast<unsigned short>(0); } 1035 : 1036 : static _GLIBCXX_CONSTEXPR unsigned short 1037 : quiet_NaN() _GLIBCXX_USE_NOEXCEPT 1038 : { return static_cast<unsigned short>(0); } 1039 : 1040 : static _GLIBCXX_CONSTEXPR unsigned short 1041 : signaling_NaN() _GLIBCXX_USE_NOEXCEPT 1042 : { return static_cast<unsigned short>(0); } 1043 : 1044 : static _GLIBCXX_CONSTEXPR unsigned short 1045 : denorm_min() _GLIBCXX_USE_NOEXCEPT 1046 : { return static_cast<unsigned short>(0); } 1047 : 1048 : static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1049 : static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1050 : static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 1051 : 1052 : static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1053 : static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1054 : static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1055 : = round_toward_zero; 1056 : }; 1057 : 1058 : /// numeric_limits<int> specialization. 1059 : template<> 1060 : struct numeric_limits<int> 1061 : { 1062 : static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1063 : 1064 : static _GLIBCXX_CONSTEXPR int 1065 : min() _GLIBCXX_USE_NOEXCEPT { return -__INT_MAX__ - 1; } 1066 : 1067 : static _GLIBCXX_CONSTEXPR int 1068 : max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__; } 1069 : 1070 : #if __cplusplus >= 201103L 1071 : static constexpr int 1072 : lowest() noexcept { return min(); } 1073 : #endif 1074 : 1075 : static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (int); 1076 : static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (int); 1077 : #if __cplusplus >= 201103L 1078 : static constexpr int max_digits10 = 0; 1079 : #endif 1080 : static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1081 : static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1082 : static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1083 : static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1084 : 1085 : static _GLIBCXX_CONSTEXPR int 1086 : epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 1087 : 1088 : static _GLIBCXX_CONSTEXPR int 1089 : round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 1090 : 1091 : static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1092 : static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1093 : static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1094 : static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1095 : 1096 : static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1097 : static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1098 : static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1099 : static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1100 : = denorm_absent; 1101 : static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1102 : 1103 : static _GLIBCXX_CONSTEXPR int 1104 : infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); } 1105 : 1106 : static _GLIBCXX_CONSTEXPR int 1107 : quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); } 1108 : 1109 : static _GLIBCXX_CONSTEXPR int 1110 : signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); } 1111 : 1112 : static _GLIBCXX_CONSTEXPR int 1113 : denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); } 1114 : 1115 : static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1116 : static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1117 : static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1118 : 1119 : static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1120 : static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1121 : static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1122 : = round_toward_zero; 1123 : }; 1124 : 1125 : /// numeric_limits<unsigned int> specialization. 1126 : template<> 1127 : struct numeric_limits<unsigned int> 1128 : { 1129 : static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1130 : 1131 : static _GLIBCXX_CONSTEXPR unsigned int 1132 : min() _GLIBCXX_USE_NOEXCEPT { return 0; } 1133 : 1134 : static _GLIBCXX_CONSTEXPR unsigned int 1135 : max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__ * 2U + 1; } 1136 : 1137 : #if __cplusplus >= 201103L 1138 : static constexpr unsigned int 1139 : lowest() noexcept { return min(); } 1140 : #endif 1141 : 1142 : static _GLIBCXX_USE_CONSTEXPR int digits 1143 : = __glibcxx_digits (unsigned int); 1144 : static _GLIBCXX_USE_CONSTEXPR int digits10 1145 : = __glibcxx_digits10 (unsigned int); 1146 : #if __cplusplus >= 201103L 1147 : static constexpr int max_digits10 = 0; 1148 : #endif 1149 : static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 1150 : static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1151 : static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1152 : static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1153 : 1154 : static _GLIBCXX_CONSTEXPR unsigned int 1155 : epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 1156 : 1157 : static _GLIBCXX_CONSTEXPR unsigned int 1158 : round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 1159 : 1160 : static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1161 : static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1162 : static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1163 : static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1164 : 1165 : static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1166 : static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1167 : static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1168 : static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1169 : = denorm_absent; 1170 : static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1171 : 1172 : static _GLIBCXX_CONSTEXPR unsigned int 1173 : infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<unsigned int>(0); } 1174 : 1175 : static _GLIBCXX_CONSTEXPR unsigned int 1176 : quiet_NaN() _GLIBCXX_USE_NOEXCEPT 1177 : { return static_cast<unsigned int>(0); } 1178 : 1179 : static _GLIBCXX_CONSTEXPR unsigned int 1180 : signaling_NaN() _GLIBCXX_USE_NOEXCEPT 1181 : { return static_cast<unsigned int>(0); } 1182 : 1183 : static _GLIBCXX_CONSTEXPR unsigned int 1184 : denorm_min() _GLIBCXX_USE_NOEXCEPT 1185 : { return static_cast<unsigned int>(0); } 1186 : 1187 : static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1188 : static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1189 : static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 1190 : 1191 : static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1192 : static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1193 : static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1194 : = round_toward_zero; 1195 : }; 1196 : 1197 : /// numeric_limits<long> specialization. 1198 : template<> 1199 : struct numeric_limits<long> 1200 : { 1201 : static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1202 : 1203 : static _GLIBCXX_CONSTEXPR long 1204 7080 : min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_MAX__ - 1; } 1205 : 1206 : static _GLIBCXX_CONSTEXPR long 1207 0 : max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__; } 1208 : 1209 : #if __cplusplus >= 201103L 1210 : static constexpr long 1211 7072 : lowest() noexcept { return min(); } 1212 : #endif 1213 : 1214 : static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (long); 1215 : static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (long); 1216 : #if __cplusplus >= 201103L 1217 : static constexpr int max_digits10 = 0; 1218 : #endif 1219 : static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1220 : static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1221 : static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1222 : static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1223 : 1224 : static _GLIBCXX_CONSTEXPR long 1225 : epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 1226 : 1227 : static _GLIBCXX_CONSTEXPR long 1228 : round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 1229 : 1230 : static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1231 : static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1232 : static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1233 : static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1234 : 1235 : static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1236 : static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1237 : static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1238 : static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1239 : = denorm_absent; 1240 : static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1241 : 1242 : static _GLIBCXX_CONSTEXPR long 1243 : infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); } 1244 : 1245 : static _GLIBCXX_CONSTEXPR long 1246 : quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); } 1247 : 1248 : static _GLIBCXX_CONSTEXPR long 1249 : signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); } 1250 : 1251 : static _GLIBCXX_CONSTEXPR long 1252 : denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); } 1253 : 1254 : static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1255 : static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1256 : static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1257 : 1258 : static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1259 : static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1260 : static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1261 : = round_toward_zero; 1262 : }; 1263 : 1264 : /// numeric_limits<unsigned long> specialization. 1265 : template<> 1266 : struct numeric_limits<unsigned long> 1267 : { 1268 : static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1269 : 1270 : static _GLIBCXX_CONSTEXPR unsigned long 1271 : min() _GLIBCXX_USE_NOEXCEPT { return 0; } 1272 : 1273 : static _GLIBCXX_CONSTEXPR unsigned long 1274 26788 : max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__ * 2UL + 1; } 1275 : 1276 : #if __cplusplus >= 201103L 1277 : static constexpr unsigned long 1278 : lowest() noexcept { return min(); } 1279 : #endif 1280 : 1281 : static _GLIBCXX_USE_CONSTEXPR int digits 1282 : = __glibcxx_digits (unsigned long); 1283 : static _GLIBCXX_USE_CONSTEXPR int digits10 1284 : = __glibcxx_digits10 (unsigned long); 1285 : #if __cplusplus >= 201103L 1286 : static constexpr int max_digits10 = 0; 1287 : #endif 1288 : static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 1289 : static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1290 : static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1291 : static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1292 : 1293 : static _GLIBCXX_CONSTEXPR unsigned long 1294 : epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 1295 : 1296 : static _GLIBCXX_CONSTEXPR unsigned long 1297 : round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 1298 : 1299 : static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1300 : static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1301 : static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1302 : static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1303 : 1304 : static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1305 : static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1306 : static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1307 : static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1308 : = denorm_absent; 1309 : static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1310 : 1311 : static _GLIBCXX_CONSTEXPR unsigned long 1312 : infinity() _GLIBCXX_USE_NOEXCEPT 1313 : { return static_cast<unsigned long>(0); } 1314 : 1315 : static _GLIBCXX_CONSTEXPR unsigned long 1316 : quiet_NaN() _GLIBCXX_USE_NOEXCEPT 1317 : { return static_cast<unsigned long>(0); } 1318 : 1319 : static _GLIBCXX_CONSTEXPR unsigned long 1320 : signaling_NaN() _GLIBCXX_USE_NOEXCEPT 1321 : { return static_cast<unsigned long>(0); } 1322 : 1323 : static _GLIBCXX_CONSTEXPR unsigned long 1324 : denorm_min() _GLIBCXX_USE_NOEXCEPT 1325 : { return static_cast<unsigned long>(0); } 1326 : 1327 : static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1328 : static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1329 : static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 1330 : 1331 : static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1332 : static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1333 : static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1334 : = round_toward_zero; 1335 : }; 1336 : 1337 : /// numeric_limits<long long> specialization. 1338 : template<> 1339 : struct numeric_limits<long long> 1340 : { 1341 : static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1342 : 1343 : static _GLIBCXX_CONSTEXPR long long 1344 : min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_LONG_MAX__ - 1; } 1345 : 1346 : static _GLIBCXX_CONSTEXPR long long 1347 : max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__; } 1348 : 1349 : #if __cplusplus >= 201103L 1350 : static constexpr long long 1351 : lowest() noexcept { return min(); } 1352 : #endif 1353 : 1354 : static _GLIBCXX_USE_CONSTEXPR int digits 1355 : = __glibcxx_digits (long long); 1356 : static _GLIBCXX_USE_CONSTEXPR int digits10 1357 : = __glibcxx_digits10 (long long); 1358 : #if __cplusplus >= 201103L 1359 : static constexpr int max_digits10 = 0; 1360 : #endif 1361 : static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1362 : static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1363 : static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1364 : static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1365 : 1366 : static _GLIBCXX_CONSTEXPR long long 1367 : epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 1368 : 1369 : static _GLIBCXX_CONSTEXPR long long 1370 : round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 1371 : 1372 : static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1373 : static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1374 : static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1375 : static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1376 : 1377 : static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1378 : static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1379 : static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1380 : static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1381 : = denorm_absent; 1382 : static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1383 : 1384 : static _GLIBCXX_CONSTEXPR long long 1385 : infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); } 1386 : 1387 : static _GLIBCXX_CONSTEXPR long long 1388 : quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); } 1389 : 1390 : static _GLIBCXX_CONSTEXPR long long 1391 : signaling_NaN() _GLIBCXX_USE_NOEXCEPT 1392 : { return static_cast<long long>(0); } 1393 : 1394 : static _GLIBCXX_CONSTEXPR long long 1395 : denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); } 1396 : 1397 : static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1398 : static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1399 : static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1400 : 1401 : static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1402 : static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1403 : static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1404 : = round_toward_zero; 1405 : }; 1406 : 1407 : /// numeric_limits<unsigned long long> specialization. 1408 : template<> 1409 : struct numeric_limits<unsigned long long> 1410 : { 1411 : static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1412 : 1413 : static _GLIBCXX_CONSTEXPR unsigned long long 1414 : min() _GLIBCXX_USE_NOEXCEPT { return 0; } 1415 : 1416 : static _GLIBCXX_CONSTEXPR unsigned long long 1417 : max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__ * 2ULL + 1; } 1418 : 1419 : #if __cplusplus >= 201103L 1420 : static constexpr unsigned long long 1421 : lowest() noexcept { return min(); } 1422 : #endif 1423 : 1424 : static _GLIBCXX_USE_CONSTEXPR int digits 1425 : = __glibcxx_digits (unsigned long long); 1426 : static _GLIBCXX_USE_CONSTEXPR int digits10 1427 : = __glibcxx_digits10 (unsigned long long); 1428 : #if __cplusplus >= 201103L 1429 : static constexpr int max_digits10 = 0; 1430 : #endif 1431 : static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 1432 : static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1433 : static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1434 : static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1435 : 1436 : static _GLIBCXX_CONSTEXPR unsigned long long 1437 : epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 1438 : 1439 : static _GLIBCXX_CONSTEXPR unsigned long long 1440 : round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 1441 : 1442 : static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1443 : static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1444 : static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1445 : static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1446 : 1447 : static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1448 : static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1449 : static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1450 : static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1451 : = denorm_absent; 1452 : static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1453 : 1454 : static _GLIBCXX_CONSTEXPR unsigned long long 1455 : infinity() _GLIBCXX_USE_NOEXCEPT 1456 : { return static_cast<unsigned long long>(0); } 1457 : 1458 : static _GLIBCXX_CONSTEXPR unsigned long long 1459 : quiet_NaN() _GLIBCXX_USE_NOEXCEPT 1460 : { return static_cast<unsigned long long>(0); } 1461 : 1462 : static _GLIBCXX_CONSTEXPR unsigned long long 1463 : signaling_NaN() _GLIBCXX_USE_NOEXCEPT 1464 : { return static_cast<unsigned long long>(0); } 1465 : 1466 : static _GLIBCXX_CONSTEXPR unsigned long long 1467 : denorm_min() _GLIBCXX_USE_NOEXCEPT 1468 : { return static_cast<unsigned long long>(0); } 1469 : 1470 : static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1471 : static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1472 : static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 1473 : 1474 : static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1475 : static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1476 : static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1477 : = round_toward_zero; 1478 : }; 1479 : 1480 : #define __INT_N(TYPE, BITSIZE, EXT, UEXT) \ 1481 : __extension__ \ 1482 : template<> \ 1483 : struct numeric_limits<TYPE> \ 1484 : { \ 1485 : static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; \ 1486 : \ 1487 : static _GLIBCXX_CONSTEXPR TYPE \ 1488 : min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min_b (TYPE, BITSIZE); } \ 1489 : \ 1490 : static _GLIBCXX_CONSTEXPR TYPE \ 1491 : max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max_b (TYPE, BITSIZE); } \ 1492 : \ 1493 : static _GLIBCXX_USE_CONSTEXPR int digits \ 1494 : = BITSIZE - 1; \ 1495 : static _GLIBCXX_USE_CONSTEXPR int digits10 \ 1496 : = (BITSIZE - 1) * 643L / 2136; \ 1497 : \ 1498 : static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; \ 1499 : static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; \ 1500 : static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; \ 1501 : static _GLIBCXX_USE_CONSTEXPR int radix = 2; \ 1502 : \ 1503 : static _GLIBCXX_CONSTEXPR TYPE \ 1504 : epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } \ 1505 : \ 1506 : static _GLIBCXX_CONSTEXPR TYPE \ 1507 : round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } \ 1508 : \ 1509 : EXT \ 1510 : \ 1511 : static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; \ 1512 : static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; \ 1513 : static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; \ 1514 : static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; \ 1515 : \ 1516 : static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; \ 1517 : static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; \ 1518 : static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; \ 1519 : static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm \ 1520 : = denorm_absent; \ 1521 : static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; \ 1522 : \ 1523 : static _GLIBCXX_CONSTEXPR TYPE \ 1524 : infinity() _GLIBCXX_USE_NOEXCEPT \ 1525 : { return static_cast<TYPE>(0); } \ 1526 : \ 1527 : static _GLIBCXX_CONSTEXPR TYPE \ 1528 : quiet_NaN() _GLIBCXX_USE_NOEXCEPT \ 1529 : { return static_cast<TYPE>(0); } \ 1530 : \ 1531 : static _GLIBCXX_CONSTEXPR TYPE \ 1532 : signaling_NaN() _GLIBCXX_USE_NOEXCEPT \ 1533 : { return static_cast<TYPE>(0); } \ 1534 : \ 1535 : static _GLIBCXX_CONSTEXPR TYPE \ 1536 : denorm_min() _GLIBCXX_USE_NOEXCEPT \ 1537 : { return static_cast<TYPE>(0); } \ 1538 : \ 1539 : static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; \ 1540 : static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; \ 1541 : static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; \ 1542 : \ 1543 : static _GLIBCXX_USE_CONSTEXPR bool traps \ 1544 : = __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 : \ 1550 : __extension__ \ 1551 : template<> \ 1552 : struct numeric_limits<unsigned TYPE> \ 1553 : { \ 1554 : static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; \ 1555 : \ 1556 : static _GLIBCXX_CONSTEXPR unsigned TYPE \ 1557 : min() _GLIBCXX_USE_NOEXCEPT { return 0; } \ 1558 : \ 1559 : static _GLIBCXX_CONSTEXPR unsigned TYPE \ 1560 : max() _GLIBCXX_USE_NOEXCEPT \ 1561 : { return __glibcxx_max_b (unsigned TYPE, BITSIZE); } \ 1562 : \ 1563 : UEXT \ 1564 : \ 1565 : static _GLIBCXX_USE_CONSTEXPR int digits \ 1566 : = BITSIZE; \ 1567 : static _GLIBCXX_USE_CONSTEXPR int digits10 \ 1568 : = BITSIZE * 643L / 2136; \ 1569 : static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; \ 1570 : static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; \ 1571 : static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; \ 1572 : static _GLIBCXX_USE_CONSTEXPR int radix = 2; \ 1573 : \ 1574 : static _GLIBCXX_CONSTEXPR unsigned TYPE \ 1575 : epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } \ 1576 : \ 1577 : static _GLIBCXX_CONSTEXPR unsigned TYPE \ 1578 : round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } \ 1579 : \ 1580 : static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; \ 1581 : static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; \ 1582 : static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; \ 1583 : static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; \ 1584 : \ 1585 : static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; \ 1586 : static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; \ 1587 : static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; \ 1588 : static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm \ 1589 : = denorm_absent; \ 1590 : static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; \ 1591 : \ 1592 : static _GLIBCXX_CONSTEXPR unsigned TYPE \ 1593 : infinity() _GLIBCXX_USE_NOEXCEPT \ 1594 : { return static_cast<unsigned TYPE>(0); } \ 1595 : \ 1596 : static _GLIBCXX_CONSTEXPR unsigned TYPE \ 1597 : quiet_NaN() _GLIBCXX_USE_NOEXCEPT \ 1598 : { return static_cast<unsigned TYPE>(0); } \ 1599 : \ 1600 : static _GLIBCXX_CONSTEXPR unsigned TYPE \ 1601 : signaling_NaN() _GLIBCXX_USE_NOEXCEPT \ 1602 : { return static_cast<unsigned TYPE>(0); } \ 1603 : \ 1604 : static _GLIBCXX_CONSTEXPR unsigned TYPE \ 1605 : denorm_min() _GLIBCXX_USE_NOEXCEPT \ 1606 : { return static_cast<unsigned TYPE>(0); } \ 1607 : \ 1608 : static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; \ 1609 : static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; \ 1610 : static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; \ 1611 : \ 1612 : static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; \ 1613 : static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; \ 1614 : static _GLIBCXX_USE_CONSTEXPR float_round_style round_style \ 1615 : = round_toward_zero; \ 1616 : }; 1617 : 1618 : #if __cplusplus >= 201103L 1619 : 1620 : #define __INT_N_201103(TYPE) \ 1621 : static constexpr TYPE \ 1622 : lowest() noexcept { return min(); } \ 1623 : static constexpr int max_digits10 = 0; 1624 : 1625 : #define __INT_N_U201103(TYPE) \ 1626 : static constexpr unsigned TYPE \ 1627 : lowest() noexcept { return min(); } \ 1628 : static constexpr int max_digits10 = 0; 1629 : 1630 : #else 1631 : #define __INT_N_201103(TYPE) 1632 : #define __INT_N_U201103(TYPE) 1633 : #endif 1634 : 1635 : #if !defined(__STRICT_ANSI__) 1636 : #ifdef __GLIBCXX_TYPE_INT_N_0 1637 : __INT_N(__GLIBCXX_TYPE_INT_N_0, __GLIBCXX_BITSIZE_INT_N_0, 1638 : __INT_N_201103 (__GLIBCXX_TYPE_INT_N_0), 1639 : __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_0)) 1640 : #endif 1641 : #ifdef __GLIBCXX_TYPE_INT_N_1 1642 : __INT_N (__GLIBCXX_TYPE_INT_N_1, __GLIBCXX_BITSIZE_INT_N_1, 1643 : __INT_N_201103 (__GLIBCXX_TYPE_INT_N_1), 1644 : __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_1)) 1645 : #endif 1646 : #ifdef __GLIBCXX_TYPE_INT_N_2 1647 : __INT_N (__GLIBCXX_TYPE_INT_N_2, __GLIBCXX_BITSIZE_INT_N_2, 1648 : __INT_N_201103 (__GLIBCXX_TYPE_INT_N_2), 1649 : __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_2)) 1650 : #endif 1651 : #ifdef __GLIBCXX_TYPE_INT_N_3 1652 : __INT_N (__GLIBCXX_TYPE_INT_N_3, __GLIBCXX_BITSIZE_INT_N_3, 1653 : __INT_N_201103 (__GLIBCXX_TYPE_INT_N_3), 1654 : __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_3)) 1655 : #endif 1656 : 1657 : #elif defined __STRICT_ANSI__ && defined __SIZEOF_INT128__ 1658 : __INT_N(__int128, 128, 1659 : __INT_N_201103 (__int128), 1660 : __INT_N_U201103 (__int128)) 1661 : #endif 1662 : 1663 : #undef __INT_N 1664 : #undef __INT_N_201103 1665 : #undef __INT_N_U201103 1666 : 1667 : 1668 : /// numeric_limits<float> specialization. 1669 : template<> 1670 : struct numeric_limits<float> 1671 : { 1672 : static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1673 : 1674 : static _GLIBCXX_CONSTEXPR float 1675 : min() _GLIBCXX_USE_NOEXCEPT { return __FLT_MIN__; } 1676 : 1677 : static _GLIBCXX_CONSTEXPR float 1678 : max() _GLIBCXX_USE_NOEXCEPT { return __FLT_MAX__; } 1679 : 1680 : #if __cplusplus >= 201103L 1681 : static constexpr float 1682 : lowest() noexcept { return -__FLT_MAX__; } 1683 : #endif 1684 : 1685 : static _GLIBCXX_USE_CONSTEXPR int digits = __FLT_MANT_DIG__; 1686 : static _GLIBCXX_USE_CONSTEXPR int digits10 = __FLT_DIG__; 1687 : #if __cplusplus >= 201103L 1688 : static constexpr int max_digits10 1689 : = __glibcxx_max_digits10 (__FLT_MANT_DIG__); 1690 : #endif 1691 : static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1692 : static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; 1693 : static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; 1694 : static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; 1695 : 1696 : static _GLIBCXX_CONSTEXPR float 1697 : epsilon() _GLIBCXX_USE_NOEXCEPT { return __FLT_EPSILON__; } 1698 : 1699 : static _GLIBCXX_CONSTEXPR float 1700 : round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5F; } 1701 : 1702 : static _GLIBCXX_USE_CONSTEXPR int min_exponent = __FLT_MIN_EXP__; 1703 : static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __FLT_MIN_10_EXP__; 1704 : static _GLIBCXX_USE_CONSTEXPR int max_exponent = __FLT_MAX_EXP__; 1705 : static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __FLT_MAX_10_EXP__; 1706 : 1707 : static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __FLT_HAS_INFINITY__; 1708 : static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__; 1709 : static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; 1710 : static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1711 : = bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent; 1712 : static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss 1713 : = __glibcxx_float_has_denorm_loss; 1714 : 1715 : static _GLIBCXX_CONSTEXPR float 1716 : infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_valf(); } 1717 : 1718 : static _GLIBCXX_CONSTEXPR float 1719 : quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanf(""); } 1720 : 1721 : static _GLIBCXX_CONSTEXPR float 1722 : signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansf(""); } 1723 : 1724 : static _GLIBCXX_CONSTEXPR float 1725 : denorm_min() _GLIBCXX_USE_NOEXCEPT { return __FLT_DENORM_MIN__; } 1726 : 1727 : static _GLIBCXX_USE_CONSTEXPR bool is_iec559 1728 : = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 1729 : static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1730 : static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1731 : 1732 : static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_float_traps; 1733 : static _GLIBCXX_USE_CONSTEXPR bool tinyness_before 1734 : = __glibcxx_float_tinyness_before; 1735 : static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1736 : = round_to_nearest; 1737 : }; 1738 : 1739 : #undef __glibcxx_float_has_denorm_loss 1740 : #undef __glibcxx_float_traps 1741 : #undef __glibcxx_float_tinyness_before 1742 : 1743 : /// numeric_limits<double> specialization. 1744 : template<> 1745 : struct numeric_limits<double> 1746 : { 1747 : static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1748 : 1749 : static _GLIBCXX_CONSTEXPR double 1750 : min() _GLIBCXX_USE_NOEXCEPT { return __DBL_MIN__; } 1751 : 1752 : static _GLIBCXX_CONSTEXPR double 1753 : max() _GLIBCXX_USE_NOEXCEPT { return __DBL_MAX__; } 1754 : 1755 : #if __cplusplus >= 201103L 1756 : static constexpr double 1757 70 : lowest() noexcept { return -__DBL_MAX__; } 1758 : #endif 1759 : 1760 : static _GLIBCXX_USE_CONSTEXPR int digits = __DBL_MANT_DIG__; 1761 : static _GLIBCXX_USE_CONSTEXPR int digits10 = __DBL_DIG__; 1762 : #if __cplusplus >= 201103L 1763 : static constexpr int max_digits10 1764 : = __glibcxx_max_digits10 (__DBL_MANT_DIG__); 1765 : #endif 1766 : static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1767 : static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; 1768 : static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; 1769 : static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; 1770 : 1771 : static _GLIBCXX_CONSTEXPR double 1772 : epsilon() _GLIBCXX_USE_NOEXCEPT { return __DBL_EPSILON__; } 1773 : 1774 : static _GLIBCXX_CONSTEXPR double 1775 : round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5; } 1776 : 1777 : static _GLIBCXX_USE_CONSTEXPR int min_exponent = __DBL_MIN_EXP__; 1778 : static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __DBL_MIN_10_EXP__; 1779 : static _GLIBCXX_USE_CONSTEXPR int max_exponent = __DBL_MAX_EXP__; 1780 : static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __DBL_MAX_10_EXP__; 1781 : 1782 : static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __DBL_HAS_INFINITY__; 1783 : static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__; 1784 : static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; 1785 : static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1786 : = bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent; 1787 : static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss 1788 : = __glibcxx_double_has_denorm_loss; 1789 : 1790 : static _GLIBCXX_CONSTEXPR double 1791 : infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_val(); } 1792 : 1793 : static _GLIBCXX_CONSTEXPR double 1794 : quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nan(""); } 1795 : 1796 : static _GLIBCXX_CONSTEXPR double 1797 : signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nans(""); } 1798 : 1799 : static _GLIBCXX_CONSTEXPR double 1800 : denorm_min() _GLIBCXX_USE_NOEXCEPT { return __DBL_DENORM_MIN__; } 1801 : 1802 : static _GLIBCXX_USE_CONSTEXPR bool is_iec559 1803 : = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 1804 : static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1805 : static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1806 : 1807 : static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_double_traps; 1808 : static _GLIBCXX_USE_CONSTEXPR bool tinyness_before 1809 : = __glibcxx_double_tinyness_before; 1810 : static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1811 : = round_to_nearest; 1812 : }; 1813 : 1814 : #undef __glibcxx_double_has_denorm_loss 1815 : #undef __glibcxx_double_traps 1816 : #undef __glibcxx_double_tinyness_before 1817 : 1818 : /// numeric_limits<long double> specialization. 1819 : template<> 1820 : struct numeric_limits<long double> 1821 : { 1822 : static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1823 : 1824 : static _GLIBCXX_CONSTEXPR long double 1825 : min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MIN__; } 1826 : 1827 : static _GLIBCXX_CONSTEXPR long double 1828 : max() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MAX__; } 1829 : 1830 : #if __cplusplus >= 201103L 1831 : static constexpr long double 1832 : lowest() noexcept { return -__LDBL_MAX__; } 1833 : #endif 1834 : 1835 : static _GLIBCXX_USE_CONSTEXPR int digits = __LDBL_MANT_DIG__; 1836 : static _GLIBCXX_USE_CONSTEXPR int digits10 = __LDBL_DIG__; 1837 : #if __cplusplus >= 201103L 1838 : static _GLIBCXX_USE_CONSTEXPR int max_digits10 1839 : = __glibcxx_max_digits10 (__LDBL_MANT_DIG__); 1840 : #endif 1841 : static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1842 : static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; 1843 : static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; 1844 : static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; 1845 : 1846 : static _GLIBCXX_CONSTEXPR long double 1847 : epsilon() _GLIBCXX_USE_NOEXCEPT { return __LDBL_EPSILON__; } 1848 : 1849 : static _GLIBCXX_CONSTEXPR long double 1850 : round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5L; } 1851 : 1852 : static _GLIBCXX_USE_CONSTEXPR int min_exponent = __LDBL_MIN_EXP__; 1853 : static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __LDBL_MIN_10_EXP__; 1854 : static _GLIBCXX_USE_CONSTEXPR int max_exponent = __LDBL_MAX_EXP__; 1855 : static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __LDBL_MAX_10_EXP__; 1856 : 1857 : static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __LDBL_HAS_INFINITY__; 1858 : static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__; 1859 : static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; 1860 : static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1861 : = bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent; 1862 : static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss 1863 : = __glibcxx_long_double_has_denorm_loss; 1864 : 1865 : static _GLIBCXX_CONSTEXPR long double 1866 : infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_vall(); } 1867 : 1868 : static _GLIBCXX_CONSTEXPR long double 1869 : quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanl(""); } 1870 : 1871 : static _GLIBCXX_CONSTEXPR long double 1872 : signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansl(""); } 1873 : 1874 : static _GLIBCXX_CONSTEXPR long double 1875 : denorm_min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_DENORM_MIN__; } 1876 : 1877 : static _GLIBCXX_USE_CONSTEXPR bool is_iec559 1878 : = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 1879 : static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1880 : static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1881 : 1882 : static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_long_double_traps; 1883 : static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = 1884 : __glibcxx_long_double_tinyness_before; 1885 : static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = 1886 : round_to_nearest; 1887 : }; 1888 : 1889 : #undef __glibcxx_long_double_has_denorm_loss 1890 : #undef __glibcxx_long_double_traps 1891 : #undef __glibcxx_long_double_tinyness_before 1892 : 1893 : #if __cplusplus > 202002L 1894 : 1895 : #define __glibcxx_concat3_(P,M,S) P ## M ## S 1896 : #define __glibcxx_concat3(P,M,S) __glibcxx_concat3_ (P,M,S) 1897 : 1898 : #define __glibcxx_float_n(BITSIZE) \ 1899 : __extension__ \ 1900 : template<> \ 1901 : struct numeric_limits<_Float##BITSIZE> \ 1902 : { \ 1903 : static constexpr bool is_specialized = true; \ 1904 : \ 1905 : static constexpr _Float##BITSIZE \ 1906 : min() noexcept \ 1907 : { return __glibcxx_concat3 (__FLT, BITSIZE, _MIN__); } \ 1908 : \ 1909 : static constexpr _Float##BITSIZE \ 1910 : max() noexcept \ 1911 : { return __glibcxx_concat3 (__FLT, BITSIZE, _MAX__); } \ 1912 : \ 1913 : static constexpr _Float##BITSIZE \ 1914 : lowest() noexcept \ 1915 : { return -__glibcxx_concat3 (__FLT, BITSIZE, _MAX__); } \ 1916 : \ 1917 : static constexpr int digits \ 1918 : = __glibcxx_concat3 (__FLT, BITSIZE, _MANT_DIG__); \ 1919 : static constexpr int digits10 \ 1920 : = __glibcxx_concat3 (__FLT, BITSIZE, _DIG__); \ 1921 : static constexpr int max_digits10 \ 1922 : = __glibcxx_max_digits10 (__glibcxx_concat3 (__FLT, BITSIZE, \ 1923 : _MANT_DIG__)); \ 1924 : static constexpr bool is_signed = true; \ 1925 : static constexpr bool is_integer = false; \ 1926 : static constexpr bool is_exact = false; \ 1927 : static constexpr int radix = __FLT_RADIX__; \ 1928 : \ 1929 : static constexpr _Float##BITSIZE \ 1930 : epsilon() noexcept \ 1931 : { return __glibcxx_concat3 (__FLT, BITSIZE, _EPSILON__); } \ 1932 : \ 1933 : static constexpr _Float##BITSIZE \ 1934 : round_error() noexcept { return 0.5F##BITSIZE; } \ 1935 : \ 1936 : static constexpr int min_exponent \ 1937 : = __glibcxx_concat3 (__FLT, BITSIZE, _MIN_EXP__); \ 1938 : static constexpr int min_exponent10 \ 1939 : = __glibcxx_concat3 (__FLT, BITSIZE, _MIN_10_EXP__); \ 1940 : static constexpr int max_exponent \ 1941 : = __glibcxx_concat3 (__FLT, BITSIZE, _MAX_EXP__); \ 1942 : static constexpr int max_exponent10 \ 1943 : = __glibcxx_concat3 (__FLT, BITSIZE, _MAX_10_EXP__); \ 1944 : \ 1945 : static constexpr bool has_infinity \ 1946 : = __glibcxx_concat3 (__FLT, BITSIZE, _HAS_INFINITY__); \ 1947 : static constexpr bool has_quiet_NaN \ 1948 : = __glibcxx_concat3 (__FLT, BITSIZE, _HAS_QUIET_NAN__); \ 1949 : static constexpr bool has_signaling_NaN \ 1950 : = has_quiet_NaN; \ 1951 : static constexpr float_denorm_style has_denorm \ 1952 : = bool(__glibcxx_concat3 (__FLT, BITSIZE, _HAS_DENORM__)) \ 1953 : ? denorm_present : denorm_absent; \ 1954 : static constexpr bool has_denorm_loss = false; \ 1955 : \ 1956 : static constexpr _Float##BITSIZE \ 1957 : infinity() noexcept \ 1958 : { return __builtin_huge_valf##BITSIZE(); } \ 1959 : \ 1960 : static constexpr _Float##BITSIZE \ 1961 : quiet_NaN() noexcept \ 1962 : { return __builtin_nanf##BITSIZE(""); } \ 1963 : \ 1964 : static constexpr _Float##BITSIZE \ 1965 : signaling_NaN() noexcept \ 1966 : { return __builtin_nansf##BITSIZE(""); } \ 1967 : \ 1968 : static constexpr _Float##BITSIZE \ 1969 : denorm_min() noexcept \ 1970 : { return __glibcxx_concat3 (__FLT, BITSIZE, _DENORM_MIN__); } \ 1971 : \ 1972 : static constexpr bool is_iec559 \ 1973 : = has_infinity && has_quiet_NaN && has_denorm == denorm_present;\ 1974 : static constexpr bool is_bounded = true; \ 1975 : static constexpr bool is_modulo = false; \ 1976 : \ 1977 : static constexpr bool traps = false; \ 1978 : static constexpr bool tinyness_before = false; \ 1979 : static constexpr float_round_style round_style \ 1980 : = round_to_nearest; \ 1981 : }; \ 1982 : 1983 : #ifdef __STDCPP_FLOAT16_T__ 1984 : __glibcxx_float_n(16) 1985 : #endif 1986 : #ifdef __STDCPP_FLOAT32_T__ 1987 : __glibcxx_float_n(32) 1988 : #endif 1989 : #ifdef __STDCPP_FLOAT64_T__ 1990 : __glibcxx_float_n(64) 1991 : #endif 1992 : #ifdef __STDCPP_FLOAT128_T__ 1993 : __glibcxx_float_n(128) 1994 : #endif 1995 : #undef __glibcxx_float_n 1996 : #undef __glibcxx_concat3 1997 : #undef __glibcxx_concat3_ 1998 : 1999 : #ifdef __STDCPP_BFLOAT16_T__ 2000 : __extension__ 2001 : template<> 2002 : struct numeric_limits<__gnu_cxx::__bfloat16_t> 2003 : { 2004 : static constexpr bool is_specialized = true; 2005 : 2006 : static constexpr __gnu_cxx::__bfloat16_t 2007 : min() noexcept 2008 : { return __BFLT16_MIN__; } 2009 : 2010 : static constexpr __gnu_cxx::__bfloat16_t 2011 : max() noexcept 2012 : { return __BFLT16_MAX__; } 2013 : 2014 : static constexpr __gnu_cxx::__bfloat16_t 2015 : lowest() noexcept 2016 : { return -__BFLT16_MAX__; } 2017 : 2018 : static constexpr int digits = __BFLT16_MANT_DIG__; 2019 : static constexpr int digits10 = __BFLT16_DIG__; 2020 : static constexpr int max_digits10 2021 : = __glibcxx_max_digits10 (__BFLT16_MANT_DIG__); 2022 : static constexpr bool is_signed = true; 2023 : static constexpr bool is_integer = false; 2024 : static constexpr bool is_exact = false; 2025 : static constexpr int radix = __FLT_RADIX__; 2026 : 2027 : static constexpr __gnu_cxx::__bfloat16_t 2028 : epsilon() noexcept 2029 : { return __BFLT16_EPSILON__; } 2030 : 2031 : static constexpr __gnu_cxx::__bfloat16_t 2032 : round_error() noexcept { return 0.5BF16; } 2033 : 2034 : static constexpr int min_exponent = __BFLT16_MIN_EXP__; 2035 : static constexpr int min_exponent10 = __BFLT16_MIN_10_EXP__; 2036 : static constexpr int max_exponent = __BFLT16_MAX_EXP__; 2037 : static constexpr int max_exponent10 = __BFLT16_MAX_10_EXP__; 2038 : 2039 : static constexpr bool has_infinity = __BFLT16_HAS_INFINITY__; 2040 : static constexpr bool has_quiet_NaN = __BFLT16_HAS_QUIET_NAN__; 2041 : static constexpr bool has_signaling_NaN = has_quiet_NaN; 2042 : static constexpr float_denorm_style has_denorm 2043 : = bool(__BFLT16_HAS_DENORM__) 2044 : ? denorm_present : denorm_absent; 2045 : static constexpr bool has_denorm_loss = false; 2046 : 2047 : static constexpr __gnu_cxx::__bfloat16_t 2048 : infinity() noexcept 2049 : { return __gnu_cxx::__bfloat16_t(__builtin_huge_valf()); } 2050 : 2051 : static constexpr __gnu_cxx::__bfloat16_t 2052 : quiet_NaN() noexcept 2053 : { return __gnu_cxx::__bfloat16_t(__builtin_nanf("")); } 2054 : 2055 : static constexpr __gnu_cxx::__bfloat16_t 2056 : signaling_NaN() noexcept 2057 : { return __builtin_nansf16b(""); } 2058 : 2059 : static constexpr __gnu_cxx::__bfloat16_t 2060 : denorm_min() noexcept 2061 : { return __BFLT16_DENORM_MIN__; } 2062 : 2063 : static constexpr bool is_iec559 2064 : = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 2065 : static constexpr bool is_bounded = true; 2066 : static constexpr bool is_modulo = false; 2067 : 2068 : static constexpr bool traps = false; 2069 : static constexpr bool tinyness_before = false; 2070 : static constexpr float_round_style round_style = round_to_nearest; 2071 : }; 2072 : #endif 2073 : 2074 : #endif 2075 : 2076 : _GLIBCXX_END_NAMESPACE_VERSION 2077 : } // namespace 2078 : 2079 : #undef __glibcxx_signed 2080 : #undef __glibcxx_min 2081 : #undef __glibcxx_max 2082 : #undef __glibcxx_digits 2083 : #undef __glibcxx_digits10 2084 : #undef __glibcxx_max_digits10 2085 : 2086 : #endif // _GLIBCXX_NUMERIC_LIMITS |
|
| Generated by: LCOV version 2.0-1 |
</html>