1// The template and inlines for the numeric_limits classes. -*- C++ -*- 2 3// Copyright (C) 1999-2019 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 158namespace 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 min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_MAX__ - 1; } 1205 1206 static _GLIBCXX_CONSTEXPR long 1207 max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__; } 1208 1209#if __cplusplus >= 201103L 1210 static constexpr long 1211 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 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#if !defined(__STRICT_ANSI__) 1481 1482#define __INT_N(TYPE, BITSIZE, EXT, UEXT) \ 1483 template<> \ 1484 struct numeric_limits<TYPE> \ 1485 { \ 1486 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; \ 1487 \ 1488 static _GLIBCXX_CONSTEXPR TYPE \ 1489 min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min_b (TYPE, BITSIZE); } \ 1490 \ 1491 static _GLIBCXX_CONSTEXPR TYPE \ 1492 max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max_b (TYPE, BITSIZE); } \ 1493 \ 1494 static _GLIBCXX_USE_CONSTEXPR int digits \ 1495 = BITSIZE - 1; \ 1496 static _GLIBCXX_USE_CONSTEXPR int digits10 \ 1497 = (BITSIZE - 1) * 643L / 2136; \ 1498 \ 1499 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; \ 1500 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; \ 1501 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; \ 1502 static _GLIBCXX_USE_CONSTEXPR int radix = 2; \ 1503 \ 1504 static _GLIBCXX_CONSTEXPR TYPE \ 1505 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } \ 1506 \ 1507 static _GLIBCXX_CONSTEXPR TYPE \ 1508 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } \ 1509 \ 1510 EXT \ 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 TYPE \ 1525 infinity() _GLIBCXX_USE_NOEXCEPT \ 1526 { return static_cast<TYPE>(0); } \ 1527 \ 1528 static _GLIBCXX_CONSTEXPR TYPE \ 1529 quiet_NaN() _GLIBCXX_USE_NOEXCEPT \ 1530 { return static_cast<TYPE>(0); } \ 1531 \ 1532 static _GLIBCXX_CONSTEXPR TYPE \ 1533 signaling_NaN() _GLIBCXX_USE_NOEXCEPT \ 1534 { return static_cast<TYPE>(0); } \ 1535 \ 1536 static _GLIBCXX_CONSTEXPR TYPE \ 1537 denorm_min() _GLIBCXX_USE_NOEXCEPT \ 1538 { return static_cast<TYPE>(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 = false; \ 1543 \ 1544 static _GLIBCXX_USE_CONSTEXPR bool traps \ 1545 = __glibcxx_integral_traps; \ 1546 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; \ 1547 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style \ 1548 = round_toward_zero; \ 1549 }; \ 1550 \ 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#ifdef __GLIBCXX_TYPE_INT_N_0 1636 __INT_N(__GLIBCXX_TYPE_INT_N_0, __GLIBCXX_BITSIZE_INT_N_0, 1637 __INT_N_201103 (__GLIBCXX_TYPE_INT_N_0), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_0)) 1638#endif 1639#ifdef __GLIBCXX_TYPE_INT_N_1 1640 __INT_N (__GLIBCXX_TYPE_INT_N_1, __GLIBCXX_BITSIZE_INT_N_1, 1641 __INT_N_201103 (__GLIBCXX_TYPE_INT_N_1), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_1)) 1642#endif 1643#ifdef __GLIBCXX_TYPE_INT_N_2 1644 __INT_N (__GLIBCXX_TYPE_INT_N_2, __GLIBCXX_BITSIZE_INT_N_2, 1645 __INT_N_201103 (__GLIBCXX_TYPE_INT_N_2), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_2)) 1646#endif 1647#ifdef __GLIBCXX_TYPE_INT_N_3 1648 __INT_N (__GLIBCXX_TYPE_INT_N_3, __GLIBCXX_BITSIZE_INT_N_3, 1649 __INT_N_201103 (__GLIBCXX_TYPE_INT_N_3), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_3)) 1650#endif 1651 1652#undef __INT_N 1653#undef __INT_N_201103 1654#undef __INT_N_U201103 1655 1656#endif 1657 1658 /// numeric_limits<float> specialization. 1659 template<> 1660 struct numeric_limits<float> 1661 { 1662 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1663 1664 static _GLIBCXX_CONSTEXPR float 1665 min() _GLIBCXX_USE_NOEXCEPT { return __FLT_MIN__; } 1666 1667 static _GLIBCXX_CONSTEXPR float 1668 max() _GLIBCXX_USE_NOEXCEPT { return __FLT_MAX__; } 1669 1670#if __cplusplus >= 201103L 1671 static constexpr float 1672 lowest() noexcept { return -__FLT_MAX__; } 1673#endif 1674 1675 static _GLIBCXX_USE_CONSTEXPR int digits = __FLT_MANT_DIG__; 1676 static _GLIBCXX_USE_CONSTEXPR int digits10 = __FLT_DIG__; 1677#if __cplusplus >= 201103L 1678 static constexpr int max_digits10 1679 = __glibcxx_max_digits10 (__FLT_MANT_DIG__); 1680#endif 1681 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1682 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; 1683 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; 1684 static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; 1685 1686 static _GLIBCXX_CONSTEXPR float 1687 epsilon() _GLIBCXX_USE_NOEXCEPT { return __FLT_EPSILON__; } 1688 1689 static _GLIBCXX_CONSTEXPR float 1690 round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5F; } 1691 1692 static _GLIBCXX_USE_CONSTEXPR int min_exponent = __FLT_MIN_EXP__; 1693 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __FLT_MIN_10_EXP__; 1694 static _GLIBCXX_USE_CONSTEXPR int max_exponent = __FLT_MAX_EXP__; 1695 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __FLT_MAX_10_EXP__; 1696 1697 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __FLT_HAS_INFINITY__; 1698 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__; 1699 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; 1700 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1701 = bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent; 1702 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss 1703 = __glibcxx_float_has_denorm_loss; 1704 1705 static _GLIBCXX_CONSTEXPR float 1706 infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_valf(); } 1707 1708 static _GLIBCXX_CONSTEXPR float 1709 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanf(""); } 1710 1711 static _GLIBCXX_CONSTEXPR float 1712 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansf(""); } 1713 1714 static _GLIBCXX_CONSTEXPR float 1715 denorm_min() _GLIBCXX_USE_NOEXCEPT { return __FLT_DENORM_MIN__; } 1716 1717 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 1718 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 1719 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1720 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1721 1722 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_float_traps; 1723 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before 1724 = __glibcxx_float_tinyness_before; 1725 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1726 = round_to_nearest; 1727 }; 1728 1729#undef __glibcxx_float_has_denorm_loss 1730#undef __glibcxx_float_traps 1731#undef __glibcxx_float_tinyness_before 1732 1733 /// numeric_limits<double> specialization. 1734 template<> 1735 struct numeric_limits<double> 1736 { 1737 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1738 1739 static _GLIBCXX_CONSTEXPR double 1740 min() _GLIBCXX_USE_NOEXCEPT { return __DBL_MIN__; } 1741 1742 static _GLIBCXX_CONSTEXPR double 1743 max() _GLIBCXX_USE_NOEXCEPT { return __DBL_MAX__; } 1744 1745#if __cplusplus >= 201103L 1746 static constexpr double 1747 lowest() noexcept { return -__DBL_MAX__; } 1748#endif 1749 1750 static _GLIBCXX_USE_CONSTEXPR int digits = __DBL_MANT_DIG__; 1751 static _GLIBCXX_USE_CONSTEXPR int digits10 = __DBL_DIG__; 1752#if __cplusplus >= 201103L 1753 static constexpr int max_digits10 1754 = __glibcxx_max_digits10 (__DBL_MANT_DIG__); 1755#endif 1756 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1757 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; 1758 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; 1759 static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; 1760 1761 static _GLIBCXX_CONSTEXPR double 1762 epsilon() _GLIBCXX_USE_NOEXCEPT { return __DBL_EPSILON__; } 1763 1764 static _GLIBCXX_CONSTEXPR double 1765 round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5; } 1766 1767 static _GLIBCXX_USE_CONSTEXPR int min_exponent = __DBL_MIN_EXP__; 1768 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __DBL_MIN_10_EXP__; 1769 static _GLIBCXX_USE_CONSTEXPR int max_exponent = __DBL_MAX_EXP__; 1770 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __DBL_MAX_10_EXP__; 1771 1772 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __DBL_HAS_INFINITY__; 1773 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__; 1774 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; 1775 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1776 = bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent; 1777 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss 1778 = __glibcxx_double_has_denorm_loss; 1779 1780 static _GLIBCXX_CONSTEXPR double 1781 infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_val(); } 1782 1783 static _GLIBCXX_CONSTEXPR double 1784 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nan(""); } 1785 1786 static _GLIBCXX_CONSTEXPR double 1787 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nans(""); } 1788 1789 static _GLIBCXX_CONSTEXPR double 1790 denorm_min() _GLIBCXX_USE_NOEXCEPT { return __DBL_DENORM_MIN__; } 1791 1792 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 1793 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 1794 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1795 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1796 1797 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_double_traps; 1798 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before 1799 = __glibcxx_double_tinyness_before; 1800 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1801 = round_to_nearest; 1802 }; 1803 1804#undef __glibcxx_double_has_denorm_loss 1805#undef __glibcxx_double_traps 1806#undef __glibcxx_double_tinyness_before 1807 1808 /// numeric_limits<long double> specialization. 1809 template<> 1810 struct numeric_limits<long double> 1811 { 1812 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1813 1814 static _GLIBCXX_CONSTEXPR long double 1815 min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MIN__; } 1816 1817 static _GLIBCXX_CONSTEXPR long double 1818 max() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MAX__; } 1819 1820#if __cplusplus >= 201103L 1821 static constexpr long double 1822 lowest() noexcept { return -__LDBL_MAX__; } 1823#endif 1824 1825 static _GLIBCXX_USE_CONSTEXPR int digits = __LDBL_MANT_DIG__; 1826 static _GLIBCXX_USE_CONSTEXPR int digits10 = __LDBL_DIG__; 1827#if __cplusplus >= 201103L 1828 static _GLIBCXX_USE_CONSTEXPR int max_digits10 1829 = __glibcxx_max_digits10 (__LDBL_MANT_DIG__); 1830#endif 1831 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1832 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; 1833 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; 1834 static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; 1835 1836 static _GLIBCXX_CONSTEXPR long double 1837 epsilon() _GLIBCXX_USE_NOEXCEPT { return __LDBL_EPSILON__; } 1838 1839 static _GLIBCXX_CONSTEXPR long double 1840 round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5L; } 1841 1842 static _GLIBCXX_USE_CONSTEXPR int min_exponent = __LDBL_MIN_EXP__; 1843 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __LDBL_MIN_10_EXP__; 1844 static _GLIBCXX_USE_CONSTEXPR int max_exponent = __LDBL_MAX_EXP__; 1845 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __LDBL_MAX_10_EXP__; 1846 1847 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __LDBL_HAS_INFINITY__; 1848 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__; 1849 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; 1850 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1851 = bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent; 1852 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss 1853 = __glibcxx_long_double_has_denorm_loss; 1854 1855 static _GLIBCXX_CONSTEXPR long double 1856 infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_vall(); } 1857 1858 static _GLIBCXX_CONSTEXPR long double 1859 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanl(""); } 1860 1861 static _GLIBCXX_CONSTEXPR long double 1862 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansl(""); } 1863 1864 static _GLIBCXX_CONSTEXPR long double 1865 denorm_min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_DENORM_MIN__; } 1866 1867 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 1868 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 1869 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1870 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1871 1872 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_long_double_traps; 1873 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = 1874 __glibcxx_long_double_tinyness_before; 1875 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = 1876 round_to_nearest; 1877 }; 1878 1879#undef __glibcxx_long_double_has_denorm_loss 1880#undef __glibcxx_long_double_traps 1881#undef __glibcxx_long_double_tinyness_before 1882 1883_GLIBCXX_END_NAMESPACE_VERSION 1884} // namespace 1885 1886#undef __glibcxx_signed 1887#undef __glibcxx_min 1888#undef __glibcxx_max 1889#undef __glibcxx_digits 1890#undef __glibcxx_digits10 1891#undef __glibcxx_max_digits10 1892 1893#endif // _GLIBCXX_NUMERIC_LIMITS 1894