37#ifndef _GLIBCXX_NUMERIC_LIMITS
38#define _GLIBCXX_NUMERIC_LIMITS 1
40#pragma GCC system_header
79#ifndef __glibcxx_integral_traps
80# define __glibcxx_integral_traps true
88#ifndef __glibcxx_float_has_denorm_loss
89# define __glibcxx_float_has_denorm_loss false
91#ifndef __glibcxx_float_traps
92# define __glibcxx_float_traps false
94#ifndef __glibcxx_float_tinyness_before
95# define __glibcxx_float_tinyness_before false
102#ifndef __glibcxx_double_has_denorm_loss
103# define __glibcxx_double_has_denorm_loss false
105#ifndef __glibcxx_double_traps
106# define __glibcxx_double_traps false
108#ifndef __glibcxx_double_tinyness_before
109# define __glibcxx_double_tinyness_before false
116#ifndef __glibcxx_long_double_has_denorm_loss
117# define __glibcxx_long_double_has_denorm_loss false
119#ifndef __glibcxx_long_double_traps
120# define __glibcxx_long_double_traps false
122#ifndef __glibcxx_long_double_tinyness_before
123# define __glibcxx_long_double_tinyness_before false
128#define __glibcxx_signed_b(T,B) ((T)(-1) < 0)
130#define __glibcxx_min_b(T,B) \
131 (__glibcxx_signed_b (T,B) ? -__glibcxx_max_b (T,B) - 1 : (T)0)
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)
137#define __glibcxx_digits_b(T,B) \
138 (B - __glibcxx_signed_b (T,B))
141#define __glibcxx_digits10_b(T,B) \
142 (__glibcxx_digits_b (T,B) * 643L / 2136)
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__)
155#define __glibcxx_max_digits10(T) \
156 (2 + (T) * 643L / 2136)
158namespace std _GLIBCXX_VISIBILITY(default)
160_GLIBCXX_BEGIN_NAMESPACE_VERSION
211 static _GLIBCXX_USE_CONSTEXPR
int digits = 0;
216#if __cplusplus >= 201103L
231 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
false;
235 static _GLIBCXX_USE_CONSTEXPR
int radix = 0;
291 static _GLIBCXX_USE_CONSTEXPR
bool traps =
false;
311 template<
typename _Tp>
316 static _GLIBCXX_CONSTEXPR _Tp
317 min() _GLIBCXX_USE_NOEXCEPT {
return _Tp(); }
320 static _GLIBCXX_CONSTEXPR _Tp
321 max() _GLIBCXX_USE_NOEXCEPT {
return _Tp(); }
323#if __cplusplus >= 201103L
332 static _GLIBCXX_CONSTEXPR _Tp
333 epsilon() _GLIBCXX_USE_NOEXCEPT {
return _Tp(); }
336 static _GLIBCXX_CONSTEXPR _Tp
340 static _GLIBCXX_CONSTEXPR _Tp
345 static _GLIBCXX_CONSTEXPR _Tp
350 static _GLIBCXX_CONSTEXPR _Tp
356 static _GLIBCXX_CONSTEXPR _Tp
363 template<
typename _Tp>
364 struct numeric_limits<const _Tp>
365 :
public numeric_limits<_Tp> { };
367 template<
typename _Tp>
368 struct numeric_limits<volatile _Tp>
369 :
public numeric_limits<_Tp> { };
371 template<
typename _Tp>
372 struct numeric_limits<const volatile _Tp>
373 :
public numeric_limits<_Tp> { };
388 static _GLIBCXX_CONSTEXPR
bool
389 min() _GLIBCXX_USE_NOEXCEPT {
return false; }
391 static _GLIBCXX_CONSTEXPR
bool
392 max() _GLIBCXX_USE_NOEXCEPT {
return true; }
394#if __cplusplus >= 201103L
395 static constexpr bool
398 static _GLIBCXX_USE_CONSTEXPR
int digits = 1;
399 static _GLIBCXX_USE_CONSTEXPR
int digits10 = 0;
400#if __cplusplus >= 201103L
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;
408 static _GLIBCXX_CONSTEXPR
bool
409 epsilon() _GLIBCXX_USE_NOEXCEPT {
return false; }
411 static _GLIBCXX_CONSTEXPR
bool
412 round_error() _GLIBCXX_USE_NOEXCEPT {
return false; }
419 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
426 static _GLIBCXX_CONSTEXPR
bool
427 infinity() _GLIBCXX_USE_NOEXCEPT {
return false; }
429 static _GLIBCXX_CONSTEXPR
bool
430 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return false; }
432 static _GLIBCXX_CONSTEXPR
bool
435 static _GLIBCXX_CONSTEXPR
bool
436 denorm_min() _GLIBCXX_USE_NOEXCEPT {
return false; }
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;
445 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
457 static _GLIBCXX_CONSTEXPR
char
458 min() _GLIBCXX_USE_NOEXCEPT {
return __glibcxx_min(
char); }
460 static _GLIBCXX_CONSTEXPR
char
461 max() _GLIBCXX_USE_NOEXCEPT {
return __glibcxx_max(
char); }
463#if __cplusplus >= 201103L
464 static constexpr char
468 static _GLIBCXX_USE_CONSTEXPR
int digits = __glibcxx_digits (
char);
469 static _GLIBCXX_USE_CONSTEXPR
int digits10 = __glibcxx_digits10 (
char);
470#if __cplusplus >= 201103L
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;
478 static _GLIBCXX_CONSTEXPR
char
479 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
481 static _GLIBCXX_CONSTEXPR
char
489 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
496 static _GLIBCXX_CONSTEXPR
497 char infinity() _GLIBCXX_USE_NOEXCEPT {
return char(); }
499 static _GLIBCXX_CONSTEXPR
char
500 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return char(); }
502 static _GLIBCXX_CONSTEXPR
char
505 static _GLIBCXX_CONSTEXPR
char
506 denorm_min() _GLIBCXX_USE_NOEXCEPT {
return static_cast<char>(0); }
508 static _GLIBCXX_USE_CONSTEXPR
bool is_iec559 =
false;
509 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
512 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
524 static _GLIBCXX_CONSTEXPR
signed char
525 min() _GLIBCXX_USE_NOEXCEPT {
return -__SCHAR_MAX__ - 1; }
527 static _GLIBCXX_CONSTEXPR
signed char
528 max() _GLIBCXX_USE_NOEXCEPT {
return __SCHAR_MAX__; }
530#if __cplusplus >= 201103L
531 static constexpr signed char
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
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;
546 static _GLIBCXX_CONSTEXPR
signed char
547 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
549 static _GLIBCXX_CONSTEXPR
signed char
557 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
564 static _GLIBCXX_CONSTEXPR
signed char
565 infinity() _GLIBCXX_USE_NOEXCEPT {
return static_cast<signed char>(0); }
567 static _GLIBCXX_CONSTEXPR
signed char
568 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return static_cast<signed char>(0); }
570 static _GLIBCXX_CONSTEXPR
signed char
572 {
return static_cast<signed char>(0); }
574 static _GLIBCXX_CONSTEXPR
signed char
576 {
return static_cast<signed char>(0); }
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;
582 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
594 static _GLIBCXX_CONSTEXPR
unsigned char
595 min() _GLIBCXX_USE_NOEXCEPT {
return 0; }
597 static _GLIBCXX_CONSTEXPR
unsigned char
598 max() _GLIBCXX_USE_NOEXCEPT {
return __SCHAR_MAX__ * 2U + 1; }
600#if __cplusplus >= 201103L
601 static constexpr unsigned char
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
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;
617 static _GLIBCXX_CONSTEXPR
unsigned char
618 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
620 static _GLIBCXX_CONSTEXPR
unsigned char
628 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
635 static _GLIBCXX_CONSTEXPR
unsigned char
637 {
return static_cast<unsigned char>(0); }
639 static _GLIBCXX_CONSTEXPR
unsigned char
641 {
return static_cast<unsigned char>(0); }
643 static _GLIBCXX_CONSTEXPR
unsigned char
645 {
return static_cast<unsigned char>(0); }
647 static _GLIBCXX_CONSTEXPR
unsigned char
649 {
return static_cast<unsigned char>(0); }
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;
655 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
667 static _GLIBCXX_CONSTEXPR
wchar_t
668 min() _GLIBCXX_USE_NOEXCEPT {
return __glibcxx_min (
wchar_t); }
670 static _GLIBCXX_CONSTEXPR
wchar_t
671 max() _GLIBCXX_USE_NOEXCEPT {
return __glibcxx_max (
wchar_t); }
673#if __cplusplus >= 201103L
674 static constexpr wchar_t
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
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;
689 static _GLIBCXX_CONSTEXPR
wchar_t
690 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
692 static _GLIBCXX_CONSTEXPR
wchar_t
700 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
707 static _GLIBCXX_CONSTEXPR
wchar_t
708 infinity() _GLIBCXX_USE_NOEXCEPT {
return wchar_t(); }
710 static _GLIBCXX_CONSTEXPR
wchar_t
711 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return wchar_t(); }
713 static _GLIBCXX_CONSTEXPR
wchar_t
716 static _GLIBCXX_CONSTEXPR
wchar_t
717 denorm_min() _GLIBCXX_USE_NOEXCEPT {
return wchar_t(); }
719 static _GLIBCXX_USE_CONSTEXPR
bool is_iec559 =
false;
720 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
723 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
729#if _GLIBCXX_USE_CHAR8_T
736 static _GLIBCXX_CONSTEXPR
char8_t
737 min() _GLIBCXX_USE_NOEXCEPT {
return __glibcxx_min (
char8_t); }
739 static _GLIBCXX_CONSTEXPR
char8_t
740 max() _GLIBCXX_USE_NOEXCEPT {
return __glibcxx_max (
char8_t); }
742 static _GLIBCXX_CONSTEXPR
char8_t
743 lowest() _GLIBCXX_USE_NOEXCEPT {
return min(); }
745 static _GLIBCXX_USE_CONSTEXPR
int digits = __glibcxx_digits (
char8_t);
746 static _GLIBCXX_USE_CONSTEXPR
int digits10 = __glibcxx_digits10 (
char8_t);
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;
753 static _GLIBCXX_CONSTEXPR
char8_t
754 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
756 static _GLIBCXX_CONSTEXPR
char8_t
764 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
771 static _GLIBCXX_CONSTEXPR
char8_t
772 infinity() _GLIBCXX_USE_NOEXCEPT {
return char8_t(); }
774 static _GLIBCXX_CONSTEXPR
char8_t
775 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return char8_t(); }
777 static _GLIBCXX_CONSTEXPR
char8_t
780 static _GLIBCXX_CONSTEXPR
char8_t
781 denorm_min() _GLIBCXX_USE_NOEXCEPT {
return char8_t(); }
783 static _GLIBCXX_USE_CONSTEXPR
bool is_iec559 =
false;
784 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
787 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
794#if __cplusplus >= 201103L
801 static constexpr char16_t
802 min()
noexcept {
return __glibcxx_min (
char16_t); }
804 static constexpr char16_t
805 max()
noexcept {
return __glibcxx_max (
char16_t); }
807 static constexpr char16_t
810 static constexpr int digits = __glibcxx_digits (
char16_t);
811 static constexpr int digits10 = __glibcxx_digits10 (
char16_t);
813 static constexpr bool is_signed = __glibcxx_signed (
char16_t);
815 static constexpr bool is_exact =
true;
816 static constexpr int radix = 2;
818 static constexpr char16_t
819 epsilon()
noexcept {
return 0; }
821 static constexpr char16_t
835 static constexpr char16_t
836 infinity()
noexcept {
return char16_t(); }
838 static constexpr char16_t
839 quiet_NaN()
noexcept {
return char16_t(); }
841 static constexpr char16_t
844 static constexpr char16_t
851 static constexpr bool traps = __glibcxx_integral_traps;
862 static constexpr char32_t
863 min()
noexcept {
return __glibcxx_min (
char32_t); }
865 static constexpr char32_t
866 max()
noexcept {
return __glibcxx_max (
char32_t); }
868 static constexpr char32_t
871 static constexpr int digits = __glibcxx_digits (
char32_t);
872 static constexpr int digits10 = __glibcxx_digits10 (
char32_t);
874 static constexpr bool is_signed = __glibcxx_signed (
char32_t);
876 static constexpr bool is_exact =
true;
877 static constexpr int radix = 2;
879 static constexpr char32_t
880 epsilon()
noexcept {
return 0; }
882 static constexpr char32_t
896 static constexpr char32_t
897 infinity()
noexcept {
return char32_t(); }
899 static constexpr char32_t
900 quiet_NaN()
noexcept {
return char32_t(); }
902 static constexpr char32_t
905 static constexpr char32_t
912 static constexpr bool traps = __glibcxx_integral_traps;
924 static _GLIBCXX_CONSTEXPR
short
925 min() _GLIBCXX_USE_NOEXCEPT {
return -__SHRT_MAX__ - 1; }
927 static _GLIBCXX_CONSTEXPR
short
928 max() _GLIBCXX_USE_NOEXCEPT {
return __SHRT_MAX__; }
930#if __cplusplus >= 201103L
931 static constexpr short
935 static _GLIBCXX_USE_CONSTEXPR
int digits = __glibcxx_digits (
short);
936 static _GLIBCXX_USE_CONSTEXPR
int digits10 = __glibcxx_digits10 (
short);
937#if __cplusplus >= 201103L
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;
945 static _GLIBCXX_CONSTEXPR
short
946 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
948 static _GLIBCXX_CONSTEXPR
short
956 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
963 static _GLIBCXX_CONSTEXPR
short
964 infinity() _GLIBCXX_USE_NOEXCEPT {
return short(); }
966 static _GLIBCXX_CONSTEXPR
short
967 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return short(); }
969 static _GLIBCXX_CONSTEXPR
short
972 static _GLIBCXX_CONSTEXPR
short
973 denorm_min() _GLIBCXX_USE_NOEXCEPT {
return short(); }
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;
979 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
991 static _GLIBCXX_CONSTEXPR
unsigned short
992 min() _GLIBCXX_USE_NOEXCEPT {
return 0; }
994 static _GLIBCXX_CONSTEXPR
unsigned short
995 max() _GLIBCXX_USE_NOEXCEPT {
return __SHRT_MAX__ * 2U + 1; }
997#if __cplusplus >= 201103L
998 static constexpr unsigned short
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
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;
1014 static _GLIBCXX_CONSTEXPR
unsigned short
1015 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
1017 static _GLIBCXX_CONSTEXPR
unsigned short
1025 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
1032 static _GLIBCXX_CONSTEXPR
unsigned short
1034 {
return static_cast<unsigned short>(0); }
1036 static _GLIBCXX_CONSTEXPR
unsigned short
1038 {
return static_cast<unsigned short>(0); }
1040 static _GLIBCXX_CONSTEXPR
unsigned short
1042 {
return static_cast<unsigned short>(0); }
1044 static _GLIBCXX_CONSTEXPR
unsigned short
1046 {
return static_cast<unsigned short>(0); }
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;
1052 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
1064 static _GLIBCXX_CONSTEXPR
int
1065 min() _GLIBCXX_USE_NOEXCEPT {
return -__INT_MAX__ - 1; }
1067 static _GLIBCXX_CONSTEXPR
int
1068 max() _GLIBCXX_USE_NOEXCEPT {
return __INT_MAX__; }
1070#if __cplusplus >= 201103L
1071 static constexpr int
1075 static _GLIBCXX_USE_CONSTEXPR
int digits = __glibcxx_digits (
int);
1076 static _GLIBCXX_USE_CONSTEXPR
int digits10 = __glibcxx_digits10 (
int);
1077#if __cplusplus >= 201103L
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;
1085 static _GLIBCXX_CONSTEXPR
int
1086 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
1088 static _GLIBCXX_CONSTEXPR
int
1096 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
1103 static _GLIBCXX_CONSTEXPR
int
1104 infinity() _GLIBCXX_USE_NOEXCEPT {
return static_cast<int>(0); }
1106 static _GLIBCXX_CONSTEXPR
int
1107 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return static_cast<int>(0); }
1109 static _GLIBCXX_CONSTEXPR
int
1110 signaling_NaN() _GLIBCXX_USE_NOEXCEPT {
return static_cast<int>(0); }
1112 static _GLIBCXX_CONSTEXPR
int
1113 denorm_min() _GLIBCXX_USE_NOEXCEPT {
return static_cast<int>(0); }
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;
1119 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
1131 static _GLIBCXX_CONSTEXPR
unsigned int
1132 min() _GLIBCXX_USE_NOEXCEPT {
return 0; }
1134 static _GLIBCXX_CONSTEXPR
unsigned int
1135 max() _GLIBCXX_USE_NOEXCEPT {
return __INT_MAX__ * 2U + 1; }
1137#if __cplusplus >= 201103L
1138 static constexpr unsigned int
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
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;
1154 static _GLIBCXX_CONSTEXPR
unsigned int
1155 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
1157 static _GLIBCXX_CONSTEXPR
unsigned int
1165 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
1172 static _GLIBCXX_CONSTEXPR
unsigned int
1173 infinity() _GLIBCXX_USE_NOEXCEPT {
return static_cast<unsigned int>(0); }
1175 static _GLIBCXX_CONSTEXPR
unsigned int
1177 {
return static_cast<unsigned int>(0); }
1179 static _GLIBCXX_CONSTEXPR
unsigned int
1181 {
return static_cast<unsigned int>(0); }
1183 static _GLIBCXX_CONSTEXPR
unsigned int
1185 {
return static_cast<unsigned int>(0); }
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;
1191 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
1203 static _GLIBCXX_CONSTEXPR
long
1204 min() _GLIBCXX_USE_NOEXCEPT {
return -__LONG_MAX__ - 1; }
1206 static _GLIBCXX_CONSTEXPR
long
1207 max() _GLIBCXX_USE_NOEXCEPT {
return __LONG_MAX__; }
1209#if __cplusplus >= 201103L
1210 static constexpr long
1214 static _GLIBCXX_USE_CONSTEXPR
int digits = __glibcxx_digits (
long);
1215 static _GLIBCXX_USE_CONSTEXPR
int digits10 = __glibcxx_digits10 (
long);
1216#if __cplusplus >= 201103L
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;
1224 static _GLIBCXX_CONSTEXPR
long
1225 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
1227 static _GLIBCXX_CONSTEXPR
long
1235 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
1242 static _GLIBCXX_CONSTEXPR
long
1243 infinity() _GLIBCXX_USE_NOEXCEPT {
return static_cast<long>(0); }
1245 static _GLIBCXX_CONSTEXPR
long
1246 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return static_cast<long>(0); }
1248 static _GLIBCXX_CONSTEXPR
long
1249 signaling_NaN() _GLIBCXX_USE_NOEXCEPT {
return static_cast<long>(0); }
1251 static _GLIBCXX_CONSTEXPR
long
1252 denorm_min() _GLIBCXX_USE_NOEXCEPT {
return static_cast<long>(0); }
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;
1258 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
1270 static _GLIBCXX_CONSTEXPR
unsigned long
1271 min() _GLIBCXX_USE_NOEXCEPT {
return 0; }
1273 static _GLIBCXX_CONSTEXPR
unsigned long
1274 max() _GLIBCXX_USE_NOEXCEPT {
return __LONG_MAX__ * 2UL + 1; }
1276#if __cplusplus >= 201103L
1277 static constexpr unsigned long
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
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;
1293 static _GLIBCXX_CONSTEXPR
unsigned long
1294 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
1296 static _GLIBCXX_CONSTEXPR
unsigned long
1304 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
1311 static _GLIBCXX_CONSTEXPR
unsigned long
1313 {
return static_cast<unsigned long>(0); }
1315 static _GLIBCXX_CONSTEXPR
unsigned long
1317 {
return static_cast<unsigned long>(0); }
1319 static _GLIBCXX_CONSTEXPR
unsigned long
1321 {
return static_cast<unsigned long>(0); }
1323 static _GLIBCXX_CONSTEXPR
unsigned long
1325 {
return static_cast<unsigned long>(0); }
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;
1331 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
1343 static _GLIBCXX_CONSTEXPR
long long
1344 min() _GLIBCXX_USE_NOEXCEPT {
return -__LONG_LONG_MAX__ - 1; }
1346 static _GLIBCXX_CONSTEXPR
long long
1347 max() _GLIBCXX_USE_NOEXCEPT {
return __LONG_LONG_MAX__; }
1349#if __cplusplus >= 201103L
1350 static constexpr long long
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
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;
1366 static _GLIBCXX_CONSTEXPR
long long
1367 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
1369 static _GLIBCXX_CONSTEXPR
long long
1377 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
1384 static _GLIBCXX_CONSTEXPR
long long
1385 infinity() _GLIBCXX_USE_NOEXCEPT {
return static_cast<long long>(0); }
1387 static _GLIBCXX_CONSTEXPR
long long
1388 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return static_cast<long long>(0); }
1390 static _GLIBCXX_CONSTEXPR
long long
1392 {
return static_cast<long long>(0); }
1394 static _GLIBCXX_CONSTEXPR
long long
1395 denorm_min() _GLIBCXX_USE_NOEXCEPT {
return static_cast<long long>(0); }
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;
1401 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
1413 static _GLIBCXX_CONSTEXPR
unsigned long long
1414 min() _GLIBCXX_USE_NOEXCEPT {
return 0; }
1416 static _GLIBCXX_CONSTEXPR
unsigned long long
1417 max() _GLIBCXX_USE_NOEXCEPT {
return __LONG_LONG_MAX__ * 2ULL + 1; }
1419#if __cplusplus >= 201103L
1420 static constexpr unsigned long long
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
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;
1436 static _GLIBCXX_CONSTEXPR
unsigned long long
1437 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
1439 static _GLIBCXX_CONSTEXPR
unsigned long long
1447 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
1454 static _GLIBCXX_CONSTEXPR
unsigned long long
1456 {
return static_cast<unsigned long long>(0); }
1458 static _GLIBCXX_CONSTEXPR
unsigned long long
1460 {
return static_cast<unsigned long long>(0); }
1462 static _GLIBCXX_CONSTEXPR
unsigned long long
1464 {
return static_cast<unsigned long long>(0); }
1466 static _GLIBCXX_CONSTEXPR
unsigned long long
1468 {
return static_cast<unsigned long long>(0); }
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;
1474 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
1480#define __INT_N(TYPE, BITSIZE, EXT, UEXT) \
1483 struct numeric_limits<TYPE> \
1485 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; \
1487 static _GLIBCXX_CONSTEXPR TYPE \
1488 min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min_b (TYPE, BITSIZE); } \
1490 static _GLIBCXX_CONSTEXPR TYPE \
1491 max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max_b (TYPE, BITSIZE); } \
1493 static _GLIBCXX_USE_CONSTEXPR int digits \
1495 static _GLIBCXX_USE_CONSTEXPR int digits10 \
1496 = (BITSIZE - 1) * 643L / 2136; \
1498 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; \
1499 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; \
1500 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; \
1501 static _GLIBCXX_USE_CONSTEXPR int radix = 2; \
1503 static _GLIBCXX_CONSTEXPR TYPE \
1504 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1506 static _GLIBCXX_CONSTEXPR TYPE \
1507 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1511 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; \
1512 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; \
1513 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; \
1514 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; \
1516 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; \
1517 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; \
1518 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; \
1519 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm \
1521 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; \
1523 static _GLIBCXX_CONSTEXPR TYPE \
1524 infinity() _GLIBCXX_USE_NOEXCEPT \
1525 { return static_cast<TYPE>(0); } \
1527 static _GLIBCXX_CONSTEXPR TYPE \
1528 quiet_NaN() _GLIBCXX_USE_NOEXCEPT \
1529 { return static_cast<TYPE>(0); } \
1531 static _GLIBCXX_CONSTEXPR TYPE \
1532 signaling_NaN() _GLIBCXX_USE_NOEXCEPT \
1533 { return static_cast<TYPE>(0); } \
1535 static _GLIBCXX_CONSTEXPR TYPE \
1536 denorm_min() _GLIBCXX_USE_NOEXCEPT \
1537 { return static_cast<TYPE>(0); } \
1539 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; \
1540 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; \
1541 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; \
1543 static _GLIBCXX_USE_CONSTEXPR bool traps \
1544 = __glibcxx_integral_traps; \
1545 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; \
1546 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style \
1547 = round_toward_zero; \
1552 struct numeric_limits<unsigned TYPE> \
1554 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; \
1556 static _GLIBCXX_CONSTEXPR unsigned TYPE \
1557 min() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1559 static _GLIBCXX_CONSTEXPR unsigned TYPE \
1560 max() _GLIBCXX_USE_NOEXCEPT \
1561 { return __glibcxx_max_b (unsigned TYPE, BITSIZE); } \
1565 static _GLIBCXX_USE_CONSTEXPR int digits \
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; \
1574 static _GLIBCXX_CONSTEXPR unsigned TYPE \
1575 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1577 static _GLIBCXX_CONSTEXPR unsigned TYPE \
1578 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } \
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; \
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 \
1590 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; \
1592 static _GLIBCXX_CONSTEXPR unsigned TYPE \
1593 infinity() _GLIBCXX_USE_NOEXCEPT \
1594 { return static_cast<unsigned TYPE>(0); } \
1596 static _GLIBCXX_CONSTEXPR unsigned TYPE \
1597 quiet_NaN() _GLIBCXX_USE_NOEXCEPT \
1598 { return static_cast<unsigned TYPE>(0); } \
1600 static _GLIBCXX_CONSTEXPR unsigned TYPE \
1601 signaling_NaN() _GLIBCXX_USE_NOEXCEPT \
1602 { return static_cast<unsigned TYPE>(0); } \
1604 static _GLIBCXX_CONSTEXPR unsigned TYPE \
1605 denorm_min() _GLIBCXX_USE_NOEXCEPT \
1606 { return static_cast<unsigned TYPE>(0); } \
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; \
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; \
1618#if __cplusplus >= 201103L
1620#define __INT_N_201103(TYPE) \
1621 static constexpr TYPE \
1622 lowest() noexcept { return min(); } \
1623 static constexpr int max_digits10 = 0;
1625#define __INT_N_U201103(TYPE) \
1626 static constexpr unsigned TYPE \
1627 lowest() noexcept { return min(); } \
1628 static constexpr int max_digits10 = 0;
1631#define __INT_N_201103(TYPE)
1632#define __INT_N_U201103(TYPE)
1635#if !defined(__STRICT_ANSI__)
1636#ifdef __GLIBCXX_TYPE_INT_N_0
1637 __INT_N(__GLIBCXX_TYPE_INT_N_0, __GLIBCXX_BITSIZE_INT_N_0,
1638 __INT_N_201103 (__GLIBCXX_TYPE_INT_N_0),
1639 __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_0))
1641#ifdef __GLIBCXX_TYPE_INT_N_1
1642 __INT_N (__GLIBCXX_TYPE_INT_N_1, __GLIBCXX_BITSIZE_INT_N_1,
1643 __INT_N_201103 (__GLIBCXX_TYPE_INT_N_1),
1644 __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_1))
1646#ifdef __GLIBCXX_TYPE_INT_N_2
1647 __INT_N (__GLIBCXX_TYPE_INT_N_2, __GLIBCXX_BITSIZE_INT_N_2,
1648 __INT_N_201103 (__GLIBCXX_TYPE_INT_N_2),
1649 __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_2))
1651#ifdef __GLIBCXX_TYPE_INT_N_3
1652 __INT_N (__GLIBCXX_TYPE_INT_N_3, __GLIBCXX_BITSIZE_INT_N_3,
1653 __INT_N_201103 (__GLIBCXX_TYPE_INT_N_3),
1654 __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_3))
1657#elif defined __STRICT_ANSI__ && defined __SIZEOF_INT128__
1658 __INT_N(__int128, 128,
1659 __INT_N_201103 (__int128),
1660 __INT_N_U201103 (__int128))
1664#undef __INT_N_201103
1665#undef __INT_N_U201103
1674 static _GLIBCXX_CONSTEXPR
float
1675 min() _GLIBCXX_USE_NOEXCEPT {
return __FLT_MIN__; }
1677 static _GLIBCXX_CONSTEXPR
float
1678 max() _GLIBCXX_USE_NOEXCEPT {
return __FLT_MAX__; }
1680#if __cplusplus >= 201103L
1681 static constexpr float
1682 lowest()
noexcept {
return -__FLT_MAX__; }
1685 static _GLIBCXX_USE_CONSTEXPR
int digits = __FLT_MANT_DIG__;
1686 static _GLIBCXX_USE_CONSTEXPR
int digits10 = __FLT_DIG__;
1687#if __cplusplus >= 201103L
1689 = __glibcxx_max_digits10 (__FLT_MANT_DIG__);
1691 static _GLIBCXX_USE_CONSTEXPR
bool is_signed =
true;
1692 static _GLIBCXX_USE_CONSTEXPR
bool is_integer =
false;
1693 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
false;
1694 static _GLIBCXX_USE_CONSTEXPR
int radix = __FLT_RADIX__;
1696 static _GLIBCXX_CONSTEXPR
float
1697 epsilon() _GLIBCXX_USE_NOEXCEPT {
return __FLT_EPSILON__; }
1699 static _GLIBCXX_CONSTEXPR
float
1700 round_error() _GLIBCXX_USE_NOEXCEPT {
return 0.5F; }
1702 static _GLIBCXX_USE_CONSTEXPR
int min_exponent = __FLT_MIN_EXP__;
1703 static _GLIBCXX_USE_CONSTEXPR
int min_exponent10 = __FLT_MIN_10_EXP__;
1704 static _GLIBCXX_USE_CONSTEXPR
int max_exponent = __FLT_MAX_EXP__;
1705 static _GLIBCXX_USE_CONSTEXPR
int max_exponent10 = __FLT_MAX_10_EXP__;
1707 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity = __FLT_HAS_INFINITY__;
1708 static _GLIBCXX_USE_CONSTEXPR
bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__;
1713 = __glibcxx_float_has_denorm_loss;
1715 static _GLIBCXX_CONSTEXPR
float
1716 infinity() _GLIBCXX_USE_NOEXCEPT {
return __builtin_huge_valf(); }
1718 static _GLIBCXX_CONSTEXPR
float
1719 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return __builtin_nanf(
""); }
1721 static _GLIBCXX_CONSTEXPR
float
1722 signaling_NaN() _GLIBCXX_USE_NOEXCEPT {
return __builtin_nansf(
""); }
1724 static _GLIBCXX_CONSTEXPR
float
1725 denorm_min() _GLIBCXX_USE_NOEXCEPT {
return __FLT_DENORM_MIN__; }
1727 static _GLIBCXX_USE_CONSTEXPR
bool is_iec559
1729 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
1730 static _GLIBCXX_USE_CONSTEXPR
bool is_modulo =
false;
1732 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_float_traps;
1734 = __glibcxx_float_tinyness_before;
1739#undef __glibcxx_float_has_denorm_loss
1740#undef __glibcxx_float_traps
1741#undef __glibcxx_float_tinyness_before
1749 static _GLIBCXX_CONSTEXPR
double
1750 min() _GLIBCXX_USE_NOEXCEPT {
return __DBL_MIN__; }
1752 static _GLIBCXX_CONSTEXPR
double
1753 max() _GLIBCXX_USE_NOEXCEPT {
return __DBL_MAX__; }
1755#if __cplusplus >= 201103L
1756 static constexpr double
1757 lowest()
noexcept {
return -__DBL_MAX__; }
1760 static _GLIBCXX_USE_CONSTEXPR
int digits = __DBL_MANT_DIG__;
1761 static _GLIBCXX_USE_CONSTEXPR
int digits10 = __DBL_DIG__;
1762#if __cplusplus >= 201103L
1764 = __glibcxx_max_digits10 (__DBL_MANT_DIG__);
1766 static _GLIBCXX_USE_CONSTEXPR
bool is_signed =
true;
1767 static _GLIBCXX_USE_CONSTEXPR
bool is_integer =
false;
1768 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
false;
1769 static _GLIBCXX_USE_CONSTEXPR
int radix = __FLT_RADIX__;
1771 static _GLIBCXX_CONSTEXPR
double
1772 epsilon() _GLIBCXX_USE_NOEXCEPT {
return __DBL_EPSILON__; }
1774 static _GLIBCXX_CONSTEXPR
double
1775 round_error() _GLIBCXX_USE_NOEXCEPT {
return 0.5; }
1777 static _GLIBCXX_USE_CONSTEXPR
int min_exponent = __DBL_MIN_EXP__;
1778 static _GLIBCXX_USE_CONSTEXPR
int min_exponent10 = __DBL_MIN_10_EXP__;
1779 static _GLIBCXX_USE_CONSTEXPR
int max_exponent = __DBL_MAX_EXP__;
1780 static _GLIBCXX_USE_CONSTEXPR
int max_exponent10 = __DBL_MAX_10_EXP__;
1782 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity = __DBL_HAS_INFINITY__;
1783 static _GLIBCXX_USE_CONSTEXPR
bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__;
1788 = __glibcxx_double_has_denorm_loss;
1790 static _GLIBCXX_CONSTEXPR
double
1791 infinity() _GLIBCXX_USE_NOEXCEPT {
return __builtin_huge_val(); }
1793 static _GLIBCXX_CONSTEXPR
double
1794 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return __builtin_nan(
""); }
1796 static _GLIBCXX_CONSTEXPR
double
1797 signaling_NaN() _GLIBCXX_USE_NOEXCEPT {
return __builtin_nans(
""); }
1799 static _GLIBCXX_CONSTEXPR
double
1800 denorm_min() _GLIBCXX_USE_NOEXCEPT {
return __DBL_DENORM_MIN__; }
1802 static _GLIBCXX_USE_CONSTEXPR
bool is_iec559
1804 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
1805 static _GLIBCXX_USE_CONSTEXPR
bool is_modulo =
false;
1807 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_double_traps;
1809 = __glibcxx_double_tinyness_before;
1814#undef __glibcxx_double_has_denorm_loss
1815#undef __glibcxx_double_traps
1816#undef __glibcxx_double_tinyness_before
1824 static _GLIBCXX_CONSTEXPR
long double
1825 min() _GLIBCXX_USE_NOEXCEPT {
return __LDBL_MIN__; }
1827 static _GLIBCXX_CONSTEXPR
long double
1828 max() _GLIBCXX_USE_NOEXCEPT {
return __LDBL_MAX__; }
1830#if __cplusplus >= 201103L
1831 static constexpr long double
1832 lowest()
noexcept {
return -__LDBL_MAX__; }
1835 static _GLIBCXX_USE_CONSTEXPR
int digits = __LDBL_MANT_DIG__;
1836 static _GLIBCXX_USE_CONSTEXPR
int digits10 = __LDBL_DIG__;
1837#if __cplusplus >= 201103L
1839 = __glibcxx_max_digits10 (__LDBL_MANT_DIG__);
1841 static _GLIBCXX_USE_CONSTEXPR
bool is_signed =
true;
1842 static _GLIBCXX_USE_CONSTEXPR
bool is_integer =
false;
1843 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
false;
1844 static _GLIBCXX_USE_CONSTEXPR
int radix = __FLT_RADIX__;
1846 static _GLIBCXX_CONSTEXPR
long double
1847 epsilon() _GLIBCXX_USE_NOEXCEPT {
return __LDBL_EPSILON__; }
1849 static _GLIBCXX_CONSTEXPR
long double
1850 round_error() _GLIBCXX_USE_NOEXCEPT {
return 0.5L; }
1852 static _GLIBCXX_USE_CONSTEXPR
int min_exponent = __LDBL_MIN_EXP__;
1853 static _GLIBCXX_USE_CONSTEXPR
int min_exponent10 = __LDBL_MIN_10_EXP__;
1854 static _GLIBCXX_USE_CONSTEXPR
int max_exponent = __LDBL_MAX_EXP__;
1855 static _GLIBCXX_USE_CONSTEXPR
int max_exponent10 = __LDBL_MAX_10_EXP__;
1857 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity = __LDBL_HAS_INFINITY__;
1858 static _GLIBCXX_USE_CONSTEXPR
bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__;
1863 = __glibcxx_long_double_has_denorm_loss;
1865 static _GLIBCXX_CONSTEXPR
long double
1866 infinity() _GLIBCXX_USE_NOEXCEPT {
return __builtin_huge_vall(); }
1868 static _GLIBCXX_CONSTEXPR
long double
1869 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return __builtin_nanl(
""); }
1871 static _GLIBCXX_CONSTEXPR
long double
1872 signaling_NaN() _GLIBCXX_USE_NOEXCEPT {
return __builtin_nansl(
""); }
1874 static _GLIBCXX_CONSTEXPR
long double
1875 denorm_min() _GLIBCXX_USE_NOEXCEPT {
return __LDBL_DENORM_MIN__; }
1877 static _GLIBCXX_USE_CONSTEXPR
bool is_iec559
1879 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
1880 static _GLIBCXX_USE_CONSTEXPR
bool is_modulo =
false;
1882 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_long_double_traps;
1884 __glibcxx_long_double_tinyness_before;
1889#undef __glibcxx_long_double_has_denorm_loss
1890#undef __glibcxx_long_double_traps
1891#undef __glibcxx_long_double_tinyness_before
1893#define __glibcxx_concat3_(P,M,S) P ## M ## S
1894#define __glibcxx_concat3(P,M,S) __glibcxx_concat3_ (P,M,S)
1896#if __cplusplus >= 201103L
1897# define __max_digits10 max_digits10
1900#define __glibcxx_float_n(BITSIZE) \
1903 struct numeric_limits<_Float##BITSIZE> \
1905 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; \
1907 static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1908 min() _GLIBCXX_USE_NOEXCEPT \
1909 { return __glibcxx_concat3 (__FLT, BITSIZE, _MIN__); } \
1911 static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1912 max() _GLIBCXX_USE_NOEXCEPT \
1913 { return __glibcxx_concat3 (__FLT, BITSIZE, _MAX__); } \
1915 static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1916 lowest() _GLIBCXX_USE_NOEXCEPT \
1917 { return -__glibcxx_concat3 (__FLT, BITSIZE, _MAX__); } \
1919 static _GLIBCXX_USE_CONSTEXPR int digits \
1920 = __glibcxx_concat3 (__FLT, BITSIZE, _MANT_DIG__); \
1921 static _GLIBCXX_USE_CONSTEXPR int digits10 \
1922 = __glibcxx_concat3 (__FLT, BITSIZE, _DIG__); \
1923 static _GLIBCXX_USE_CONSTEXPR int __max_digits10 \
1924 = __glibcxx_max_digits10 (__glibcxx_concat3 (__FLT, BITSIZE, \
1926 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; \
1927 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; \
1928 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; \
1929 static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; \
1931 static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1932 epsilon() _GLIBCXX_USE_NOEXCEPT \
1933 { return __glibcxx_concat3 (__FLT, BITSIZE, _EPSILON__); } \
1935 static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1936 round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5F##BITSIZE; } \
1938 static _GLIBCXX_USE_CONSTEXPR int min_exponent \
1939 = __glibcxx_concat3 (__FLT, BITSIZE, _MIN_EXP__); \
1940 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 \
1941 = __glibcxx_concat3 (__FLT, BITSIZE, _MIN_10_EXP__); \
1942 static _GLIBCXX_USE_CONSTEXPR int max_exponent \
1943 = __glibcxx_concat3 (__FLT, BITSIZE, _MAX_EXP__); \
1944 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 \
1945 = __glibcxx_concat3 (__FLT, BITSIZE, _MAX_10_EXP__); \
1947 static _GLIBCXX_USE_CONSTEXPR bool has_infinity \
1948 = __glibcxx_concat3 (__FLT, BITSIZE, _HAS_INFINITY__); \
1949 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN \
1950 = __glibcxx_concat3 (__FLT, BITSIZE, _HAS_QUIET_NAN__); \
1951 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN \
1953 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm \
1954 = bool(__glibcxx_concat3 (__FLT, BITSIZE, _HAS_DENORM__)) \
1955 ? denorm_present : denorm_absent; \
1956 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; \
1958 static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1959 infinity() _GLIBCXX_USE_NOEXCEPT \
1960 { return __builtin_huge_valf##BITSIZE(); } \
1962 static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1963 quiet_NaN() _GLIBCXX_USE_NOEXCEPT \
1964 { return __builtin_nanf##BITSIZE(""); } \
1966 static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1967 signaling_NaN() _GLIBCXX_USE_NOEXCEPT \
1968 { return __builtin_nansf##BITSIZE(""); } \
1970 static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1971 denorm_min() _GLIBCXX_USE_NOEXCEPT \
1972 { return __glibcxx_concat3 (__FLT, BITSIZE, _DENORM_MIN__); } \
1974 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 \
1975 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;\
1976 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; \
1977 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; \
1979 static _GLIBCXX_USE_CONSTEXPR bool traps = false; \
1980 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; \
1981 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style \
1982 = round_to_nearest; \
1985#ifdef __STDCPP_FLOAT16_T__
1986__glibcxx_float_n(16)
1989__glibcxx_float_n(32)
1992__glibcxx_float_n(64)
1994#ifdef __FLT128_DIG__
1995__glibcxx_float_n(128)
1997#undef __glibcxx_float_n
1998#undef __glibcxx_concat3
1999#undef __glibcxx_concat3_
2001#if __cplusplus >= 201103L
2002# undef __max_digits10
2005#ifdef __STDCPP_BFLOAT16_T__
2012 static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2013 min() _GLIBCXX_USE_NOEXCEPT
2014 {
return __BFLT16_MIN__; }
2016 static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2017 max() _GLIBCXX_USE_NOEXCEPT
2018 {
return __BFLT16_MAX__; }
2020 static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2021 lowest() _GLIBCXX_USE_NOEXCEPT
2022 {
return -__BFLT16_MAX__; }
2024 static _GLIBCXX_USE_CONSTEXPR
int digits = __BFLT16_MANT_DIG__;
2025 static _GLIBCXX_USE_CONSTEXPR
int digits10 = __BFLT16_DIG__;
2026#if __cplusplus >= 201103L
2028 = __glibcxx_max_digits10 (__BFLT16_MANT_DIG__);
2030 static _GLIBCXX_USE_CONSTEXPR
bool is_signed =
true;
2031 static _GLIBCXX_USE_CONSTEXPR
bool is_integer =
false;
2032 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
false;
2033 static _GLIBCXX_USE_CONSTEXPR
int radix = __FLT_RADIX__;
2035 static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2036 epsilon() _GLIBCXX_USE_NOEXCEPT
2037 {
return __BFLT16_EPSILON__; }
2039 static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2040 round_error() _GLIBCXX_USE_NOEXCEPT {
return 0.5BF16; }
2042 static _GLIBCXX_USE_CONSTEXPR
int min_exponent = __BFLT16_MIN_EXP__;
2043 static _GLIBCXX_USE_CONSTEXPR
int min_exponent10 = __BFLT16_MIN_10_EXP__;
2044 static _GLIBCXX_USE_CONSTEXPR
int max_exponent = __BFLT16_MAX_EXP__;
2045 static _GLIBCXX_USE_CONSTEXPR
int max_exponent10 = __BFLT16_MAX_10_EXP__;
2048 = __BFLT16_HAS_INFINITY__;
2050 = __BFLT16_HAS_QUIET_NAN__;
2056 static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2058 {
return __gnu_cxx::__bfloat16_t(__builtin_huge_valf()); }
2060 static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2062 {
return __gnu_cxx::__bfloat16_t(__builtin_nanf(
"")); }
2064 static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2066 {
return __builtin_nansf16b(
""); }
2068 static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2070 {
return __BFLT16_DENORM_MIN__; }
2072 static _GLIBCXX_USE_CONSTEXPR
bool is_iec559
2074 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
2075 static _GLIBCXX_USE_CONSTEXPR
bool is_modulo =
false;
2077 static _GLIBCXX_USE_CONSTEXPR
bool traps =
false;
2084#if defined(_GLIBCXX_USE_FLOAT128)
2086#if ! defined(__STRICT_ANSI__) || defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
2089 struct numeric_limits<__float128>
2093 static _GLIBCXX_CONSTEXPR __float128
2094 min() _GLIBCXX_USE_NOEXCEPT
2096#ifdef __STRICT_ANSI__
2098 return double(9.3132257461547852e-10) * _S_1pm16352();
2100 return __extension__ 0x1.0p-16382Q;
2104 static _GLIBCXX_CONSTEXPR __float128
2105 max() _GLIBCXX_USE_NOEXCEPT
2107#ifdef __STRICT_ANSI__
2110 return (__float128(
double(3.4028236692093843e+38))
2111 +
double(3.7778931862957153e+22) +
double(8.35584e+6))
2114 return __extension__ 0x1.ffffffffffffffffffffffffffffp+16383Q;
2118 static _GLIBCXX_CONSTEXPR __float128
2119 lowest() _GLIBCXX_USE_NOEXCEPT
2122 static _GLIBCXX_USE_CONSTEXPR
int digits = 113;
2123 static _GLIBCXX_USE_CONSTEXPR
int digits10 = 33;
2124#if __cplusplus >= 201103L
2127 static _GLIBCXX_USE_CONSTEXPR
bool is_signed =
true;
2128 static _GLIBCXX_USE_CONSTEXPR
bool is_integer =
false;
2129 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
false;
2130 static _GLIBCXX_USE_CONSTEXPR
int radix = __FLT_RADIX__;
2132 static _GLIBCXX_CONSTEXPR __float128
2133 epsilon() _GLIBCXX_USE_NOEXCEPT
2134 {
return double(1.9259299443872359e-34); }
2136 static _GLIBCXX_CONSTEXPR __float128
2137 round_error() _GLIBCXX_USE_NOEXCEPT {
return 0.5; }
2139 static _GLIBCXX_USE_CONSTEXPR
int min_exponent = -16381;
2141 static _GLIBCXX_USE_CONSTEXPR
int max_exponent = 16384;
2146#if __has_builtin(__builtin_nansq) \
2147 || (__has_builtin(__builtin_bit_cast) && __has_builtin(__builtin_nansf128))
2156 static _GLIBCXX_CONSTEXPR __float128
2158 {
return __builtin_huge_val(); }
2160 static _GLIBCXX_CONSTEXPR __float128
2162 {
return __builtin_nan(
""); }
2164 static _GLIBCXX_CONSTEXPR __float128
2167#if __has_builtin(__builtin_nansq)
2168 return __builtin_nansq(
"");
2169#elif __has_builtin(__builtin_bit_cast) && __has_builtin(__builtin_nansf128)
2170 return __builtin_bit_cast(__float128, __builtin_nansf128(
""));
2176 static _GLIBCXX_CONSTEXPR __float128
2179#if defined(__STRICT_ANSI__) || defined(__INTEL_COMPILER)
2181 return double(1.7936620343357659e-43) * _S_1pm16352();
2183 return __extension__ 0x1.0p-16494Q;
2188 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
2189 static _GLIBCXX_USE_CONSTEXPR
bool is_modulo =
false;
2191 static _GLIBCXX_USE_CONSTEXPR
bool traps =
false;
2196#if defined(__STRICT_ANSI__) || defined(__INTEL_COMPILER)
2198 static _GLIBCXX_CONSTEXPR __float128
2199 _S_4p(__float128 __v) _GLIBCXX_USE_NOEXCEPT
2200 {
return __v * __v * __v * __v; }
2202 static _GLIBCXX_CONSTEXPR __float128
2203 _S_1pm4088() _GLIBCXX_USE_NOEXCEPT
2204 {
return _S_4p(
double(2.2250738585072014e-308)); }
2206 static _GLIBCXX_CONSTEXPR __float128
2207 _S_1pm16352() _GLIBCXX_USE_NOEXCEPT
2208 {
return _S_4p(_S_1pm4088()); }
2210 static _GLIBCXX_CONSTEXPR __float128
2211 _S_1p4064() _GLIBCXX_USE_NOEXCEPT
2212 {
return _S_4p(
double(7.0222388080559215e+305)); }
2214 static _GLIBCXX_CONSTEXPR __float128
2215 _S_1p16256() _GLIBCXX_USE_NOEXCEPT
2216 {
return _S_4p(_S_1p4064()); }
2222_GLIBCXX_END_NAMESPACE_VERSION
2225#undef __glibcxx_signed
2228#undef __glibcxx_digits
2229#undef __glibcxx_digits10
2230#undef __glibcxx_max_digits10
ISO C++ entities toplevel namespace is std.
float_round_style
Describes the rounding style for floating-point types.
@ round_toward_zero
To zero.
@ round_toward_infinity
To infinity.
@ round_to_nearest
To the nearest representable value.
@ round_toward_neg_infinity
To negative infinity.
@ round_indeterminate
Intermediate.
float_denorm_style
Describes the denormalization for floating-point types.
@ denorm_present
The type allows denormalized values.
@ denorm_indeterminate
Indeterminate at compile time whether denormalized values are allowed.
@ denorm_absent
The type does not allow denormalized values.
GNU extensions for public use.
Part of std::numeric_limits.
static constexpr bool is_modulo
static constexpr bool has_quiet_NaN
static constexpr bool is_integer
static constexpr int max_digits10
static constexpr int min_exponent
static constexpr int digits
static constexpr bool is_bounded
static constexpr bool has_denorm_loss
static constexpr bool is_iec559
static constexpr bool is_exact
static constexpr bool traps
static constexpr bool has_signaling_NaN
static constexpr bool is_specialized
static constexpr int max_exponent
static constexpr bool is_signed
static constexpr int digits10
static constexpr int min_exponent10
static constexpr bool tinyness_before
static constexpr float_round_style round_style
static constexpr bool has_infinity
static constexpr int radix
static constexpr int max_exponent10
static constexpr float_denorm_style has_denorm
Properties of fundamental types.
static constexpr _Tp max() noexcept
static constexpr _Tp epsilon() noexcept
static constexpr _Tp quiet_NaN() noexcept
static constexpr _Tp lowest() noexcept
static constexpr _Tp min() noexcept
static constexpr _Tp denorm_min() noexcept
static constexpr _Tp infinity() noexcept
static constexpr _Tp round_error() noexcept
static constexpr _Tp signaling_NaN() noexcept