1// The template and inlines for the numeric_limits classes. -*- C++ -*- 2 3// Copyright (C) 1999-2018 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 378 // _GLIBCXX_RESOLVE_LIB_DEFECTS 379 // 184. numeric_limits<bool> wording problems 380 381 /// numeric_limits<bool> specialization. 382 template<> 383 struct numeric_limits<bool> 384 { 385 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 386 387 static _GLIBCXX_CONSTEXPR bool 388 min() _GLIBCXX_USE_NOEXCEPT { return false; } 389 390 static _GLIBCXX_CONSTEXPR bool 391 max() _GLIBCXX_USE_NOEXCEPT { return true; } 392 393#if __cplusplus >= 201103L 394 static constexpr bool 395 lowest() noexcept { return min(); } 396#endif 397 static _GLIBCXX_USE_CONSTEXPR int digits = 1; 398 static _GLIBCXX_USE_CONSTEXPR int digits10 = 0; 399#if __cplusplus >= 201103L 400 static constexpr int max_digits10 = 0; 401#endif 402 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 403 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 404 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 405 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 406 407 static _GLIBCXX_CONSTEXPR bool 408 epsilon() _GLIBCXX_USE_NOEXCEPT { return false; } 409 410 static _GLIBCXX_CONSTEXPR bool 411 round_error() _GLIBCXX_USE_NOEXCEPT { return false; } 412 413 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 414 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 415 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 416 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 417 418 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 419 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 420 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 421 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 422 = denorm_absent; 423 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 424 425 static _GLIBCXX_CONSTEXPR bool 426 infinity() _GLIBCXX_USE_NOEXCEPT { return false; } 427 428 static _GLIBCXX_CONSTEXPR bool 429 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return false; } 430 431 static _GLIBCXX_CONSTEXPR bool 432 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return false; } 433 434 static _GLIBCXX_CONSTEXPR bool 435 denorm_min() _GLIBCXX_USE_NOEXCEPT { return false; } 436 437 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 438 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 439 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 440 441 // It is not clear what it means for a boolean type to trap. 442 // This is a DR on the LWG issue list. Here, I use integer 443 // promotion semantics. 444 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 445 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 446 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 447 = round_toward_zero; 448 }; 449 450 /// numeric_limits<char> specialization. 451 template<> 452 struct numeric_limits<char> 453 { 454 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 455 456 static _GLIBCXX_CONSTEXPR char 457 min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min(char); } 458 459 static _GLIBCXX_CONSTEXPR char 460 max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max(char); } 461 462#if __cplusplus >= 201103L 463 static constexpr char 464 lowest() noexcept { return min(); } 465#endif 466 467 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char); 468 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (char); 469#if __cplusplus >= 201103L 470 static constexpr int max_digits10 = 0; 471#endif 472 static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (char); 473 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 474 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 475 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 476 477 static _GLIBCXX_CONSTEXPR char 478 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 479 480 static _GLIBCXX_CONSTEXPR char 481 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 482 483 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 484 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 485 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 486 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 487 488 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 489 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 490 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 491 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 492 = denorm_absent; 493 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 494 495 static _GLIBCXX_CONSTEXPR 496 char infinity() _GLIBCXX_USE_NOEXCEPT { return char(); } 497 498 static _GLIBCXX_CONSTEXPR char 499 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); } 500 501 static _GLIBCXX_CONSTEXPR char 502 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); } 503 504 static _GLIBCXX_CONSTEXPR char 505 denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<char>(0); } 506 507 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 508 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 509 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed; 510 511 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 512 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 513 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 514 = round_toward_zero; 515 }; 516 517 /// numeric_limits<signed char> specialization. 518 template<> 519 struct numeric_limits<signed char> 520 { 521 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 522 523 static _GLIBCXX_CONSTEXPR signed char 524 min() _GLIBCXX_USE_NOEXCEPT { return -__SCHAR_MAX__ - 1; } 525 526 static _GLIBCXX_CONSTEXPR signed char 527 max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__; } 528 529#if __cplusplus >= 201103L 530 static constexpr signed char 531 lowest() noexcept { return min(); } 532#endif 533 534 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (signed char); 535 static _GLIBCXX_USE_CONSTEXPR int digits10 536 = __glibcxx_digits10 (signed char); 537#if __cplusplus >= 201103L 538 static constexpr int max_digits10 = 0; 539#endif 540 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 541 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 542 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 543 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 544 545 static _GLIBCXX_CONSTEXPR signed char 546 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 547 548 static _GLIBCXX_CONSTEXPR signed char 549 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 550 551 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 552 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 553 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 554 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 555 556 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 557 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 558 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 559 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 560 = denorm_absent; 561 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 562 563 static _GLIBCXX_CONSTEXPR signed char 564 infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); } 565 566 static _GLIBCXX_CONSTEXPR signed char 567 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<signed char>(0); } 568 569 static _GLIBCXX_CONSTEXPR signed char 570 signaling_NaN() _GLIBCXX_USE_NOEXCEPT 571 { return static_cast<signed char>(0); } 572 573 static _GLIBCXX_CONSTEXPR signed char 574 denorm_min() _GLIBCXX_USE_NOEXCEPT 575 { return static_cast<signed char>(0); } 576 577 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 578 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 579 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 580 581 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 582 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 583 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 584 = round_toward_zero; 585 }; 586 587 /// numeric_limits<unsigned char> specialization. 588 template<> 589 struct numeric_limits<unsigned char> 590 { 591 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 592 593 static _GLIBCXX_CONSTEXPR unsigned char 594 min() _GLIBCXX_USE_NOEXCEPT { return 0; } 595 596 static _GLIBCXX_CONSTEXPR unsigned char 597 max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__ * 2U + 1; } 598 599#if __cplusplus >= 201103L 600 static constexpr unsigned char 601 lowest() noexcept { return min(); } 602#endif 603 604 static _GLIBCXX_USE_CONSTEXPR int digits 605 = __glibcxx_digits (unsigned char); 606 static _GLIBCXX_USE_CONSTEXPR int digits10 607 = __glibcxx_digits10 (unsigned char); 608#if __cplusplus >= 201103L 609 static constexpr int max_digits10 = 0; 610#endif 611 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 612 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 613 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 614 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 615 616 static _GLIBCXX_CONSTEXPR unsigned char 617 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 618 619 static _GLIBCXX_CONSTEXPR unsigned char 620 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 621 622 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 623 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 624 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 625 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 626 627 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 628 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 629 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 630 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 631 = denorm_absent; 632 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 633 634 static _GLIBCXX_CONSTEXPR unsigned char 635 infinity() _GLIBCXX_USE_NOEXCEPT 636 { return static_cast<unsigned char>(0); } 637 638 static _GLIBCXX_CONSTEXPR unsigned char 639 quiet_NaN() _GLIBCXX_USE_NOEXCEPT 640 { return static_cast<unsigned char>(0); } 641 642 static _GLIBCXX_CONSTEXPR unsigned char 643 signaling_NaN() _GLIBCXX_USE_NOEXCEPT 644 { return static_cast<unsigned char>(0); } 645 646 static _GLIBCXX_CONSTEXPR unsigned char 647 denorm_min() _GLIBCXX_USE_NOEXCEPT 648 { return static_cast<unsigned char>(0); } 649 650 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 651 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 652 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 653 654 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 655 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 656 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 657 = round_toward_zero; 658 }; 659 660 /// numeric_limits<wchar_t> specialization. 661 template<> 662 struct numeric_limits<wchar_t> 663 { 664 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 665 666 static _GLIBCXX_CONSTEXPR wchar_t 667 min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (wchar_t); } 668 669 static _GLIBCXX_CONSTEXPR wchar_t 670 max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (wchar_t); } 671 672#if __cplusplus >= 201103L 673 static constexpr wchar_t 674 lowest() noexcept { return min(); } 675#endif 676 677 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (wchar_t); 678 static _GLIBCXX_USE_CONSTEXPR int digits10 679 = __glibcxx_digits10 (wchar_t); 680#if __cplusplus >= 201103L 681 static constexpr int max_digits10 = 0; 682#endif 683 static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (wchar_t); 684 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 685 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 686 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 687 688 static _GLIBCXX_CONSTEXPR wchar_t 689 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 690 691 static _GLIBCXX_CONSTEXPR wchar_t 692 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 693 694 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 695 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 696 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 697 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 698 699 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 700 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 701 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 702 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 703 = denorm_absent; 704 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 705 706 static _GLIBCXX_CONSTEXPR wchar_t 707 infinity() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } 708 709 static _GLIBCXX_CONSTEXPR wchar_t 710 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } 711 712 static _GLIBCXX_CONSTEXPR wchar_t 713 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } 714 715 static _GLIBCXX_CONSTEXPR wchar_t 716 denorm_min() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } 717 718 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 719 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 720 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed; 721 722 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 723 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 724 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 725 = round_toward_zero; 726 }; 727 728#if __cplusplus >= 201103L 729 /// numeric_limits<char16_t> specialization. 730 template<> 731 struct numeric_limits<char16_t> 732 { 733 static constexpr bool is_specialized = true; 734 735 static constexpr char16_t 736 min() noexcept { return __glibcxx_min (char16_t); } 737 738 static constexpr char16_t 739 max() noexcept { return __glibcxx_max (char16_t); } 740 741 static constexpr char16_t 742 lowest() noexcept { return min(); } 743 744 static constexpr int digits = __glibcxx_digits (char16_t); 745 static constexpr int digits10 = __glibcxx_digits10 (char16_t); 746 static constexpr int max_digits10 = 0; 747 static constexpr bool is_signed = __glibcxx_signed (char16_t); 748 static constexpr bool is_integer = true; 749 static constexpr bool is_exact = true; 750 static constexpr int radix = 2; 751 752 static constexpr char16_t 753 epsilon() noexcept { return 0; } 754 755 static constexpr char16_t 756 round_error() noexcept { return 0; } 757 758 static constexpr int min_exponent = 0; 759 static constexpr int min_exponent10 = 0; 760 static constexpr int max_exponent = 0; 761 static constexpr int max_exponent10 = 0; 762 763 static constexpr bool has_infinity = false; 764 static constexpr bool has_quiet_NaN = false; 765 static constexpr bool has_signaling_NaN = false; 766 static constexpr float_denorm_style has_denorm = denorm_absent; 767 static constexpr bool has_denorm_loss = false; 768 769 static constexpr char16_t 770 infinity() noexcept { return char16_t(); } 771 772 static constexpr char16_t 773 quiet_NaN() noexcept { return char16_t(); } 774 775 static constexpr char16_t 776 signaling_NaN() noexcept { return char16_t(); } 777 778 static constexpr char16_t 779 denorm_min() noexcept { return char16_t(); } 780 781 static constexpr bool is_iec559 = false; 782 static constexpr bool is_bounded = true; 783 static constexpr bool is_modulo = !is_signed; 784 785 static constexpr bool traps = __glibcxx_integral_traps; 786 static constexpr bool tinyness_before = false; 787 static constexpr float_round_style round_style = round_toward_zero; 788 }; 789 790 /// numeric_limits<char32_t> specialization. 791 template<> 792 struct numeric_limits<char32_t> 793 { 794 static constexpr bool is_specialized = true; 795 796 static constexpr char32_t 797 min() noexcept { return __glibcxx_min (char32_t); } 798 799 static constexpr char32_t 800 max() noexcept { return __glibcxx_max (char32_t); } 801 802 static constexpr char32_t 803 lowest() noexcept { return min(); } 804 805 static constexpr int digits = __glibcxx_digits (char32_t); 806 static constexpr int digits10 = __glibcxx_digits10 (char32_t); 807 static constexpr int max_digits10 = 0; 808 static constexpr bool is_signed = __glibcxx_signed (char32_t); 809 static constexpr bool is_integer = true; 810 static constexpr bool is_exact = true; 811 static constexpr int radix = 2; 812 813 static constexpr char32_t 814 epsilon() noexcept { return 0; } 815 816 static constexpr char32_t 817 round_error() noexcept { return 0; } 818 819 static constexpr int min_exponent = 0; 820 static constexpr int min_exponent10 = 0; 821 static constexpr int max_exponent = 0; 822 static constexpr int max_exponent10 = 0; 823 824 static constexpr bool has_infinity = false; 825 static constexpr bool has_quiet_NaN = false; 826 static constexpr bool has_signaling_NaN = false; 827 static constexpr float_denorm_style has_denorm = denorm_absent; 828 static constexpr bool has_denorm_loss = false; 829 830 static constexpr char32_t 831 infinity() noexcept { return char32_t(); } 832 833 static constexpr char32_t 834 quiet_NaN() noexcept { return char32_t(); } 835 836 static constexpr char32_t 837 signaling_NaN() noexcept { return char32_t(); } 838 839 static constexpr char32_t 840 denorm_min() noexcept { return char32_t(); } 841 842 static constexpr bool is_iec559 = false; 843 static constexpr bool is_bounded = true; 844 static constexpr bool is_modulo = !is_signed; 845 846 static constexpr bool traps = __glibcxx_integral_traps; 847 static constexpr bool tinyness_before = false; 848 static constexpr float_round_style round_style = round_toward_zero; 849 }; 850#endif 851 852 /// numeric_limits<short> specialization. 853 template<> 854 struct numeric_limits<short> 855 { 856 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 857 858 static _GLIBCXX_CONSTEXPR short 859 min() _GLIBCXX_USE_NOEXCEPT { return -__SHRT_MAX__ - 1; } 860 861 static _GLIBCXX_CONSTEXPR short 862 max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__; } 863 864#if __cplusplus >= 201103L 865 static constexpr short 866 lowest() noexcept { return min(); } 867#endif 868 869 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (short); 870 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (short); 871#if __cplusplus >= 201103L 872 static constexpr int max_digits10 = 0; 873#endif 874 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 875 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 876 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 877 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 878 879 static _GLIBCXX_CONSTEXPR short 880 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 881 882 static _GLIBCXX_CONSTEXPR short 883 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 884 885 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 886 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 887 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 888 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 889 890 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 891 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 892 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 893 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 894 = denorm_absent; 895 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 896 897 static _GLIBCXX_CONSTEXPR short 898 infinity() _GLIBCXX_USE_NOEXCEPT { return short(); } 899 900 static _GLIBCXX_CONSTEXPR short 901 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); } 902 903 static _GLIBCXX_CONSTEXPR short 904 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); } 905 906 static _GLIBCXX_CONSTEXPR short 907 denorm_min() _GLIBCXX_USE_NOEXCEPT { return short(); } 908 909 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 910 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 911 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 912 913 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 914 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 915 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 916 = round_toward_zero; 917 }; 918 919 /// numeric_limits<unsigned short> specialization. 920 template<> 921 struct numeric_limits<unsigned short> 922 { 923 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 924 925 static _GLIBCXX_CONSTEXPR unsigned short 926 min() _GLIBCXX_USE_NOEXCEPT { return 0; } 927 928 static _GLIBCXX_CONSTEXPR unsigned short 929 max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__ * 2U + 1; } 930 931#if __cplusplus >= 201103L 932 static constexpr unsigned short 933 lowest() noexcept { return min(); } 934#endif 935 936 static _GLIBCXX_USE_CONSTEXPR int digits 937 = __glibcxx_digits (unsigned short); 938 static _GLIBCXX_USE_CONSTEXPR int digits10 939 = __glibcxx_digits10 (unsigned short); 940#if __cplusplus >= 201103L 941 static constexpr int max_digits10 = 0; 942#endif 943 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 944 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 945 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 946 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 947 948 static _GLIBCXX_CONSTEXPR unsigned short 949 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 950 951 static _GLIBCXX_CONSTEXPR unsigned short 952 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 953 954 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 955 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 956 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 957 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 958 959 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 960 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 961 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 962 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 963 = denorm_absent; 964 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 965 966 static _GLIBCXX_CONSTEXPR unsigned short 967 infinity() _GLIBCXX_USE_NOEXCEPT 968 { return static_cast<unsigned short>(0); } 969 970 static _GLIBCXX_CONSTEXPR unsigned short 971 quiet_NaN() _GLIBCXX_USE_NOEXCEPT 972 { return static_cast<unsigned short>(0); } 973 974 static _GLIBCXX_CONSTEXPR unsigned short 975 signaling_NaN() _GLIBCXX_USE_NOEXCEPT 976 { return static_cast<unsigned short>(0); } 977 978 static _GLIBCXX_CONSTEXPR unsigned short 979 denorm_min() _GLIBCXX_USE_NOEXCEPT 980 { return static_cast<unsigned short>(0); } 981 982 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 983 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 984 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 985 986 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 987 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 988 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 989 = round_toward_zero; 990 }; 991 992 /// numeric_limits<int> specialization. 993 template<> 994 struct numeric_limits<int> 995 { 996 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 997 998 static _GLIBCXX_CONSTEXPR int 999 min() _GLIBCXX_USE_NOEXCEPT { return -__INT_MAX__ - 1; } 1000 1001 static _GLIBCXX_CONSTEXPR int 1002 max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__; } 1003 1004#if __cplusplus >= 201103L 1005 static constexpr int 1006 lowest() noexcept { return min(); } 1007#endif 1008 1009 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (int); 1010 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (int); 1011#if __cplusplus >= 201103L 1012 static constexpr int max_digits10 = 0; 1013#endif 1014 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1015 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1016 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1017 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1018 1019 static _GLIBCXX_CONSTEXPR int 1020 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 1021 1022 static _GLIBCXX_CONSTEXPR int 1023 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 1024 1025 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1026 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1027 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1028 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1029 1030 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1031 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1032 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1033 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1034 = denorm_absent; 1035 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1036 1037 static _GLIBCXX_CONSTEXPR int 1038 infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); } 1039 1040 static _GLIBCXX_CONSTEXPR int 1041 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); } 1042 1043 static _GLIBCXX_CONSTEXPR int 1044 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); } 1045 1046 static _GLIBCXX_CONSTEXPR int 1047 denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<int>(0); } 1048 1049 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1050 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1051 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1052 1053 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1054 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1055 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1056 = round_toward_zero; 1057 }; 1058 1059 /// numeric_limits<unsigned int> specialization. 1060 template<> 1061 struct numeric_limits<unsigned int> 1062 { 1063 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1064 1065 static _GLIBCXX_CONSTEXPR unsigned int 1066 min() _GLIBCXX_USE_NOEXCEPT { return 0; } 1067 1068 static _GLIBCXX_CONSTEXPR unsigned int 1069 max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__ * 2U + 1; } 1070 1071#if __cplusplus >= 201103L 1072 static constexpr unsigned int 1073 lowest() noexcept { return min(); } 1074#endif 1075 1076 static _GLIBCXX_USE_CONSTEXPR int digits 1077 = __glibcxx_digits (unsigned int); 1078 static _GLIBCXX_USE_CONSTEXPR int digits10 1079 = __glibcxx_digits10 (unsigned int); 1080#if __cplusplus >= 201103L 1081 static constexpr int max_digits10 = 0; 1082#endif 1083 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 1084 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1085 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1086 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1087 1088 static _GLIBCXX_CONSTEXPR unsigned int 1089 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 1090 1091 static _GLIBCXX_CONSTEXPR unsigned int 1092 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 1093 1094 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1095 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1096 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1097 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1098 1099 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1100 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1101 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1102 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1103 = denorm_absent; 1104 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1105 1106 static _GLIBCXX_CONSTEXPR unsigned int 1107 infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<unsigned int>(0); } 1108 1109 static _GLIBCXX_CONSTEXPR unsigned int 1110 quiet_NaN() _GLIBCXX_USE_NOEXCEPT 1111 { return static_cast<unsigned int>(0); } 1112 1113 static _GLIBCXX_CONSTEXPR unsigned int 1114 signaling_NaN() _GLIBCXX_USE_NOEXCEPT 1115 { return static_cast<unsigned int>(0); } 1116 1117 static _GLIBCXX_CONSTEXPR unsigned int 1118 denorm_min() _GLIBCXX_USE_NOEXCEPT 1119 { return static_cast<unsigned int>(0); } 1120 1121 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1122 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1123 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 1124 1125 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1126 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1127 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1128 = round_toward_zero; 1129 }; 1130 1131 /// numeric_limits<long> specialization. 1132 template<> 1133 struct numeric_limits<long> 1134 { 1135 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1136 1137 static _GLIBCXX_CONSTEXPR long 1138 min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_MAX__ - 1; } 1139 1140 static _GLIBCXX_CONSTEXPR long 1141 max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__; } 1142 1143#if __cplusplus >= 201103L 1144 static constexpr long 1145 lowest() noexcept { return min(); } 1146#endif 1147 1148 static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (long); 1149 static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (long); 1150#if __cplusplus >= 201103L 1151 static constexpr int max_digits10 = 0; 1152#endif 1153 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1154 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1155 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1156 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1157 1158 static _GLIBCXX_CONSTEXPR long 1159 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 1160 1161 static _GLIBCXX_CONSTEXPR long 1162 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 1163 1164 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1165 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1166 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1167 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1168 1169 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1170 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1171 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1172 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1173 = denorm_absent; 1174 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1175 1176 static _GLIBCXX_CONSTEXPR long 1177 infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); } 1178 1179 static _GLIBCXX_CONSTEXPR long 1180 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); } 1181 1182 static _GLIBCXX_CONSTEXPR long 1183 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); } 1184 1185 static _GLIBCXX_CONSTEXPR long 1186 denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long>(0); } 1187 1188 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1189 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1190 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1191 1192 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1193 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1194 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1195 = round_toward_zero; 1196 }; 1197 1198 /// numeric_limits<unsigned long> specialization. 1199 template<> 1200 struct numeric_limits<unsigned long> 1201 { 1202 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1203 1204 static _GLIBCXX_CONSTEXPR unsigned long 1205 min() _GLIBCXX_USE_NOEXCEPT { return 0; } 1206 1207 static _GLIBCXX_CONSTEXPR unsigned long 1208 max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__ * 2UL + 1; } 1209 1210#if __cplusplus >= 201103L 1211 static constexpr unsigned long 1212 lowest() noexcept { return min(); } 1213#endif 1214 1215 static _GLIBCXX_USE_CONSTEXPR int digits 1216 = __glibcxx_digits (unsigned long); 1217 static _GLIBCXX_USE_CONSTEXPR int digits10 1218 = __glibcxx_digits10 (unsigned long); 1219#if __cplusplus >= 201103L 1220 static constexpr int max_digits10 = 0; 1221#endif 1222 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 1223 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1224 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1225 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1226 1227 static _GLIBCXX_CONSTEXPR unsigned long 1228 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 1229 1230 static _GLIBCXX_CONSTEXPR unsigned long 1231 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 1232 1233 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1234 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1235 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1236 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1237 1238 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1239 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1240 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1241 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1242 = denorm_absent; 1243 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1244 1245 static _GLIBCXX_CONSTEXPR unsigned long 1246 infinity() _GLIBCXX_USE_NOEXCEPT 1247 { return static_cast<unsigned long>(0); } 1248 1249 static _GLIBCXX_CONSTEXPR unsigned long 1250 quiet_NaN() _GLIBCXX_USE_NOEXCEPT 1251 { return static_cast<unsigned long>(0); } 1252 1253 static _GLIBCXX_CONSTEXPR unsigned long 1254 signaling_NaN() _GLIBCXX_USE_NOEXCEPT 1255 { return static_cast<unsigned long>(0); } 1256 1257 static _GLIBCXX_CONSTEXPR unsigned long 1258 denorm_min() _GLIBCXX_USE_NOEXCEPT 1259 { return static_cast<unsigned long>(0); } 1260 1261 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1262 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1263 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 1264 1265 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1266 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1267 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1268 = round_toward_zero; 1269 }; 1270 1271 /// numeric_limits<long long> specialization. 1272 template<> 1273 struct numeric_limits<long long> 1274 { 1275 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1276 1277 static _GLIBCXX_CONSTEXPR long long 1278 min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_LONG_MAX__ - 1; } 1279 1280 static _GLIBCXX_CONSTEXPR long long 1281 max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__; } 1282 1283#if __cplusplus >= 201103L 1284 static constexpr long long 1285 lowest() noexcept { return min(); } 1286#endif 1287 1288 static _GLIBCXX_USE_CONSTEXPR int digits 1289 = __glibcxx_digits (long long); 1290 static _GLIBCXX_USE_CONSTEXPR int digits10 1291 = __glibcxx_digits10 (long long); 1292#if __cplusplus >= 201103L 1293 static constexpr int max_digits10 = 0; 1294#endif 1295 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1296 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1297 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1298 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1299 1300 static _GLIBCXX_CONSTEXPR long long 1301 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 1302 1303 static _GLIBCXX_CONSTEXPR long long 1304 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 1305 1306 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1307 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1308 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1309 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1310 1311 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1312 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1313 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1314 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1315 = denorm_absent; 1316 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1317 1318 static _GLIBCXX_CONSTEXPR long long 1319 infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); } 1320 1321 static _GLIBCXX_CONSTEXPR long long 1322 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); } 1323 1324 static _GLIBCXX_CONSTEXPR long long 1325 signaling_NaN() _GLIBCXX_USE_NOEXCEPT 1326 { return static_cast<long long>(0); } 1327 1328 static _GLIBCXX_CONSTEXPR long long 1329 denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<long long>(0); } 1330 1331 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1332 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1333 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1334 1335 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1336 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1337 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1338 = round_toward_zero; 1339 }; 1340 1341 /// numeric_limits<unsigned long long> specialization. 1342 template<> 1343 struct numeric_limits<unsigned long long> 1344 { 1345 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1346 1347 static _GLIBCXX_CONSTEXPR unsigned long long 1348 min() _GLIBCXX_USE_NOEXCEPT { return 0; } 1349 1350 static _GLIBCXX_CONSTEXPR unsigned long long 1351 max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__ * 2ULL + 1; } 1352 1353#if __cplusplus >= 201103L 1354 static constexpr unsigned long long 1355 lowest() noexcept { return min(); } 1356#endif 1357 1358 static _GLIBCXX_USE_CONSTEXPR int digits 1359 = __glibcxx_digits (unsigned long long); 1360 static _GLIBCXX_USE_CONSTEXPR int digits10 1361 = __glibcxx_digits10 (unsigned long long); 1362#if __cplusplus >= 201103L 1363 static constexpr int max_digits10 = 0; 1364#endif 1365 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; 1366 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; 1367 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; 1368 static _GLIBCXX_USE_CONSTEXPR int radix = 2; 1369 1370 static _GLIBCXX_CONSTEXPR unsigned long long 1371 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } 1372 1373 static _GLIBCXX_CONSTEXPR unsigned long long 1374 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } 1375 1376 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; 1377 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; 1378 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; 1379 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; 1380 1381 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; 1382 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; 1383 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; 1384 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1385 = denorm_absent; 1386 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; 1387 1388 static _GLIBCXX_CONSTEXPR unsigned long long 1389 infinity() _GLIBCXX_USE_NOEXCEPT 1390 { return static_cast<unsigned long long>(0); } 1391 1392 static _GLIBCXX_CONSTEXPR unsigned long long 1393 quiet_NaN() _GLIBCXX_USE_NOEXCEPT 1394 { return static_cast<unsigned long long>(0); } 1395 1396 static _GLIBCXX_CONSTEXPR unsigned long long 1397 signaling_NaN() _GLIBCXX_USE_NOEXCEPT 1398 { return static_cast<unsigned long long>(0); } 1399 1400 static _GLIBCXX_CONSTEXPR unsigned long long 1401 denorm_min() _GLIBCXX_USE_NOEXCEPT 1402 { return static_cast<unsigned long long>(0); } 1403 1404 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; 1405 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1406 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; 1407 1408 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; 1409 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; 1410 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1411 = round_toward_zero; 1412 }; 1413 1414#if !defined(__STRICT_ANSI__) 1415 1416#define __INT_N(TYPE, BITSIZE, EXT, UEXT) \ 1417 template<> \ 1418 struct numeric_limits<TYPE> \ 1419 { \ 1420 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; \ 1421 \ 1422 static _GLIBCXX_CONSTEXPR TYPE \ 1423 min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min_b (TYPE, BITSIZE); } \ 1424 \ 1425 static _GLIBCXX_CONSTEXPR TYPE \ 1426 max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max_b (TYPE, BITSIZE); } \ 1427 \ 1428 static _GLIBCXX_USE_CONSTEXPR int digits \ 1429 = BITSIZE - 1; \ 1430 static _GLIBCXX_USE_CONSTEXPR int digits10 \ 1431 = (BITSIZE - 1) * 643L / 2136; \ 1432 \ 1433 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; \ 1434 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; \ 1435 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; \ 1436 static _GLIBCXX_USE_CONSTEXPR int radix = 2; \ 1437 \ 1438 static _GLIBCXX_CONSTEXPR TYPE \ 1439 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } \ 1440 \ 1441 static _GLIBCXX_CONSTEXPR TYPE \ 1442 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } \ 1443 \ 1444 EXT \ 1445 \ 1446 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; \ 1447 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; \ 1448 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; \ 1449 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; \ 1450 \ 1451 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; \ 1452 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; \ 1453 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; \ 1454 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm \ 1455 = denorm_absent; \ 1456 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; \ 1457 \ 1458 static _GLIBCXX_CONSTEXPR TYPE \ 1459 infinity() _GLIBCXX_USE_NOEXCEPT \ 1460 { return static_cast<TYPE>(0); } \ 1461 \ 1462 static _GLIBCXX_CONSTEXPR TYPE \ 1463 quiet_NaN() _GLIBCXX_USE_NOEXCEPT \ 1464 { return static_cast<TYPE>(0); } \ 1465 \ 1466 static _GLIBCXX_CONSTEXPR TYPE \ 1467 signaling_NaN() _GLIBCXX_USE_NOEXCEPT \ 1468 { return static_cast<TYPE>(0); } \ 1469 \ 1470 static _GLIBCXX_CONSTEXPR TYPE \ 1471 denorm_min() _GLIBCXX_USE_NOEXCEPT \ 1472 { return static_cast<TYPE>(0); } \ 1473 \ 1474 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; \ 1475 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; \ 1476 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; \ 1477 \ 1478 static _GLIBCXX_USE_CONSTEXPR bool traps \ 1479 = __glibcxx_integral_traps; \ 1480 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; \ 1481 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style \ 1482 = round_toward_zero; \ 1483 }; \ 1484 \ 1485 template<> \ 1486 struct numeric_limits<unsigned TYPE> \ 1487 { \ 1488 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; \ 1489 \ 1490 static _GLIBCXX_CONSTEXPR unsigned TYPE \ 1491 min() _GLIBCXX_USE_NOEXCEPT { return 0; } \ 1492 \ 1493 static _GLIBCXX_CONSTEXPR unsigned TYPE \ 1494 max() _GLIBCXX_USE_NOEXCEPT \ 1495 { return __glibcxx_max_b (unsigned TYPE, BITSIZE); } \ 1496 \ 1497 UEXT \ 1498 \ 1499 static _GLIBCXX_USE_CONSTEXPR int digits \ 1500 = BITSIZE; \ 1501 static _GLIBCXX_USE_CONSTEXPR int digits10 \ 1502 = BITSIZE * 643L / 2136; \ 1503 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; \ 1504 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; \ 1505 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; \ 1506 static _GLIBCXX_USE_CONSTEXPR int radix = 2; \ 1507 \ 1508 static _GLIBCXX_CONSTEXPR unsigned TYPE \ 1509 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } \ 1510 \ 1511 static _GLIBCXX_CONSTEXPR unsigned TYPE \ 1512 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } \ 1513 \ 1514 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; \ 1515 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; \ 1516 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; \ 1517 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; \ 1518 \ 1519 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; \ 1520 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; \ 1521 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; \ 1522 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm \ 1523 = denorm_absent; \ 1524 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; \ 1525 \ 1526 static _GLIBCXX_CONSTEXPR unsigned TYPE \ 1527 infinity() _GLIBCXX_USE_NOEXCEPT \ 1528 { return static_cast<unsigned TYPE>(0); } \ 1529 \ 1530 static _GLIBCXX_CONSTEXPR unsigned TYPE \ 1531 quiet_NaN() _GLIBCXX_USE_NOEXCEPT \ 1532 { return static_cast<unsigned TYPE>(0); } \ 1533 \ 1534 static _GLIBCXX_CONSTEXPR unsigned TYPE \ 1535 signaling_NaN() _GLIBCXX_USE_NOEXCEPT \ 1536 { return static_cast<unsigned TYPE>(0); } \ 1537 \ 1538 static _GLIBCXX_CONSTEXPR unsigned TYPE \ 1539 denorm_min() _GLIBCXX_USE_NOEXCEPT \ 1540 { return static_cast<unsigned TYPE>(0); } \ 1541 \ 1542 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; \ 1543 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; \ 1544 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; \ 1545 \ 1546 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; \ 1547 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; \ 1548 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style \ 1549 = round_toward_zero; \ 1550 }; 1551 1552#if __cplusplus >= 201103L 1553 1554#define __INT_N_201103(TYPE) \ 1555 static constexpr TYPE \ 1556 lowest() noexcept { return min(); } \ 1557 static constexpr int max_digits10 = 0; 1558 1559#define __INT_N_U201103(TYPE) \ 1560 static constexpr unsigned TYPE \ 1561 lowest() noexcept { return min(); } \ 1562 static constexpr int max_digits10 = 0; 1563 1564#else 1565#define __INT_N_201103(TYPE) 1566#define __INT_N_U201103(TYPE) 1567#endif 1568 1569#ifdef __GLIBCXX_TYPE_INT_N_0 1570 __INT_N(__GLIBCXX_TYPE_INT_N_0, __GLIBCXX_BITSIZE_INT_N_0, 1571 __INT_N_201103 (__GLIBCXX_TYPE_INT_N_0), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_0)) 1572#endif 1573#ifdef __GLIBCXX_TYPE_INT_N_1 1574 __INT_N (__GLIBCXX_TYPE_INT_N_1, __GLIBCXX_BITSIZE_INT_N_1, 1575 __INT_N_201103 (__GLIBCXX_TYPE_INT_N_1), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_1)) 1576#endif 1577#ifdef __GLIBCXX_TYPE_INT_N_2 1578 __INT_N (__GLIBCXX_TYPE_INT_N_2, __GLIBCXX_BITSIZE_INT_N_2, 1579 __INT_N_201103 (__GLIBCXX_TYPE_INT_N_2), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_2)) 1580#endif 1581#ifdef __GLIBCXX_TYPE_INT_N_3 1582 __INT_N (__GLIBCXX_TYPE_INT_N_3, __GLIBCXX_BITSIZE_INT_N_3, 1583 __INT_N_201103 (__GLIBCXX_TYPE_INT_N_3), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_3)) 1584#endif 1585 1586#undef __INT_N 1587#undef __INT_N_201103 1588#undef __INT_N_U201103 1589 1590#endif 1591 1592 /// numeric_limits<float> specialization. 1593 template<> 1594 struct numeric_limits<float> 1595 { 1596 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1597 1598 static _GLIBCXX_CONSTEXPR float 1599 min() _GLIBCXX_USE_NOEXCEPT { return __FLT_MIN__; } 1600 1601 static _GLIBCXX_CONSTEXPR float 1602 max() _GLIBCXX_USE_NOEXCEPT { return __FLT_MAX__; } 1603 1604#if __cplusplus >= 201103L 1605 static constexpr float 1606 lowest() noexcept { return -__FLT_MAX__; } 1607#endif 1608 1609 static _GLIBCXX_USE_CONSTEXPR int digits = __FLT_MANT_DIG__; 1610 static _GLIBCXX_USE_CONSTEXPR int digits10 = __FLT_DIG__; 1611#if __cplusplus >= 201103L 1612 static constexpr int max_digits10 1613 = __glibcxx_max_digits10 (__FLT_MANT_DIG__); 1614#endif 1615 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1616 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; 1617 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; 1618 static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; 1619 1620 static _GLIBCXX_CONSTEXPR float 1621 epsilon() _GLIBCXX_USE_NOEXCEPT { return __FLT_EPSILON__; } 1622 1623 static _GLIBCXX_CONSTEXPR float 1624 round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5F; } 1625 1626 static _GLIBCXX_USE_CONSTEXPR int min_exponent = __FLT_MIN_EXP__; 1627 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __FLT_MIN_10_EXP__; 1628 static _GLIBCXX_USE_CONSTEXPR int max_exponent = __FLT_MAX_EXP__; 1629 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __FLT_MAX_10_EXP__; 1630 1631 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __FLT_HAS_INFINITY__; 1632 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__; 1633 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; 1634 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1635 = bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent; 1636 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss 1637 = __glibcxx_float_has_denorm_loss; 1638 1639 static _GLIBCXX_CONSTEXPR float 1640 infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_valf(); } 1641 1642 static _GLIBCXX_CONSTEXPR float 1643 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanf(""); } 1644 1645 static _GLIBCXX_CONSTEXPR float 1646 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansf(""); } 1647 1648 static _GLIBCXX_CONSTEXPR float 1649 denorm_min() _GLIBCXX_USE_NOEXCEPT { return __FLT_DENORM_MIN__; } 1650 1651 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 1652 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 1653 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1654 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1655 1656 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_float_traps; 1657 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before 1658 = __glibcxx_float_tinyness_before; 1659 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1660 = round_to_nearest; 1661 }; 1662 1663#undef __glibcxx_float_has_denorm_loss 1664#undef __glibcxx_float_traps 1665#undef __glibcxx_float_tinyness_before 1666 1667 /// numeric_limits<double> specialization. 1668 template<> 1669 struct numeric_limits<double> 1670 { 1671 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1672 1673 static _GLIBCXX_CONSTEXPR double 1674 min() _GLIBCXX_USE_NOEXCEPT { return __DBL_MIN__; } 1675 1676 static _GLIBCXX_CONSTEXPR double 1677 max() _GLIBCXX_USE_NOEXCEPT { return __DBL_MAX__; } 1678 1679#if __cplusplus >= 201103L 1680 static constexpr double 1681 lowest() noexcept { return -__DBL_MAX__; } 1682#endif 1683 1684 static _GLIBCXX_USE_CONSTEXPR int digits = __DBL_MANT_DIG__; 1685 static _GLIBCXX_USE_CONSTEXPR int digits10 = __DBL_DIG__; 1686#if __cplusplus >= 201103L 1687 static constexpr int max_digits10 1688 = __glibcxx_max_digits10 (__DBL_MANT_DIG__); 1689#endif 1690 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1691 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; 1692 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; 1693 static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; 1694 1695 static _GLIBCXX_CONSTEXPR double 1696 epsilon() _GLIBCXX_USE_NOEXCEPT { return __DBL_EPSILON__; } 1697 1698 static _GLIBCXX_CONSTEXPR double 1699 round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5; } 1700 1701 static _GLIBCXX_USE_CONSTEXPR int min_exponent = __DBL_MIN_EXP__; 1702 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __DBL_MIN_10_EXP__; 1703 static _GLIBCXX_USE_CONSTEXPR int max_exponent = __DBL_MAX_EXP__; 1704 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __DBL_MAX_10_EXP__; 1705 1706 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __DBL_HAS_INFINITY__; 1707 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__; 1708 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; 1709 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1710 = bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent; 1711 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss 1712 = __glibcxx_double_has_denorm_loss; 1713 1714 static _GLIBCXX_CONSTEXPR double 1715 infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_val(); } 1716 1717 static _GLIBCXX_CONSTEXPR double 1718 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nan(""); } 1719 1720 static _GLIBCXX_CONSTEXPR double 1721 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nans(""); } 1722 1723 static _GLIBCXX_CONSTEXPR double 1724 denorm_min() _GLIBCXX_USE_NOEXCEPT { return __DBL_DENORM_MIN__; } 1725 1726 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 1727 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 1728 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1729 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1730 1731 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_double_traps; 1732 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before 1733 = __glibcxx_double_tinyness_before; 1734 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 1735 = round_to_nearest; 1736 }; 1737 1738#undef __glibcxx_double_has_denorm_loss 1739#undef __glibcxx_double_traps 1740#undef __glibcxx_double_tinyness_before 1741 1742 /// numeric_limits<long double> specialization. 1743 template<> 1744 struct numeric_limits<long double> 1745 { 1746 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; 1747 1748 static _GLIBCXX_CONSTEXPR long double 1749 min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MIN__; } 1750 1751 static _GLIBCXX_CONSTEXPR long double 1752 max() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MAX__; } 1753 1754#if __cplusplus >= 201103L 1755 static constexpr long double 1756 lowest() noexcept { return -__LDBL_MAX__; } 1757#endif 1758 1759 static _GLIBCXX_USE_CONSTEXPR int digits = __LDBL_MANT_DIG__; 1760 static _GLIBCXX_USE_CONSTEXPR int digits10 = __LDBL_DIG__; 1761#if __cplusplus >= 201103L 1762 static _GLIBCXX_USE_CONSTEXPR int max_digits10 1763 = __glibcxx_max_digits10 (__LDBL_MANT_DIG__); 1764#endif 1765 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; 1766 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; 1767 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; 1768 static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; 1769 1770 static _GLIBCXX_CONSTEXPR long double 1771 epsilon() _GLIBCXX_USE_NOEXCEPT { return __LDBL_EPSILON__; } 1772 1773 static _GLIBCXX_CONSTEXPR long double 1774 round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5L; } 1775 1776 static _GLIBCXX_USE_CONSTEXPR int min_exponent = __LDBL_MIN_EXP__; 1777 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __LDBL_MIN_10_EXP__; 1778 static _GLIBCXX_USE_CONSTEXPR int max_exponent = __LDBL_MAX_EXP__; 1779 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __LDBL_MAX_10_EXP__; 1780 1781 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __LDBL_HAS_INFINITY__; 1782 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__; 1783 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; 1784 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 1785 = bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent; 1786 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss 1787 = __glibcxx_long_double_has_denorm_loss; 1788 1789 static _GLIBCXX_CONSTEXPR long double 1790 infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_vall(); } 1791 1792 static _GLIBCXX_CONSTEXPR long double 1793 quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanl(""); } 1794 1795 static _GLIBCXX_CONSTEXPR long double 1796 signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansl(""); } 1797 1798 static _GLIBCXX_CONSTEXPR long double 1799 denorm_min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_DENORM_MIN__; } 1800 1801 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 1802 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 1803 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; 1804 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; 1805 1806 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_long_double_traps; 1807 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = 1808 __glibcxx_long_double_tinyness_before; 1809 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = 1810 round_to_nearest; 1811 }; 1812 1813#undef __glibcxx_long_double_has_denorm_loss 1814#undef __glibcxx_long_double_traps 1815#undef __glibcxx_long_double_tinyness_before 1816 1817_GLIBCXX_END_NAMESPACE_VERSION 1818} // namespace 1819 1820#undef __glibcxx_signed 1821#undef __glibcxx_min 1822#undef __glibcxx_max 1823#undef __glibcxx_digits 1824#undef __glibcxx_digits10 1825#undef __glibcxx_max_digits10 1826 1827#endif // _GLIBCXX_NUMERIC_LIMITS 1828