37#ifndef _GLIBCXX_NUMERIC_LIMITS
38#define _GLIBCXX_NUMERIC_LIMITS 1
41#pragma GCC system_header
44#pragma GCC diagnostic push
45#pragma GCC diagnostic ignored "-Wpedantic"
46#pragma GCC diagnostic ignored "-Wlong-long"
47#pragma GCC diagnostic ignored "-Wc++23-extensions"
86#ifndef __glibcxx_integral_traps
87# define __glibcxx_integral_traps true
95#ifndef __glibcxx_float_has_denorm_loss
96# define __glibcxx_float_has_denorm_loss false
98#ifndef __glibcxx_float_traps
99# define __glibcxx_float_traps false
101#ifndef __glibcxx_float_tinyness_before
102# define __glibcxx_float_tinyness_before false
109#ifndef __glibcxx_double_has_denorm_loss
110# define __glibcxx_double_has_denorm_loss false
112#ifndef __glibcxx_double_traps
113# define __glibcxx_double_traps false
115#ifndef __glibcxx_double_tinyness_before
116# define __glibcxx_double_tinyness_before false
123#ifndef __glibcxx_long_double_has_denorm_loss
124# define __glibcxx_long_double_has_denorm_loss false
126#ifndef __glibcxx_long_double_traps
127# define __glibcxx_long_double_traps false
129#ifndef __glibcxx_long_double_tinyness_before
130# define __glibcxx_long_double_tinyness_before false
135#define __glibcxx_signed_b(T,B) ((T)(-1) < 0)
137#define __glibcxx_min_b(T,B) \
138 (__glibcxx_signed_b (T,B) ? -__glibcxx_max_b (T,B) - 1 : (T)0)
140#define __glibcxx_max_b(T,B) \
141 (__glibcxx_signed_b (T,B) ? \
142 (((((T)1 << (__glibcxx_digits_b (T,B) - 1)) - 1) << 1) + 1) : ~(T)0)
144#define __glibcxx_digits_b(T,B) \
145 (B - __glibcxx_signed_b (T,B))
148#define __glibcxx_digits10_b(T,B) \
149 (__glibcxx_digits_b (T,B) * 643L / 2136)
151#define __glibcxx_signed(T) \
152 __glibcxx_signed_b (T, sizeof(T) * __CHAR_BIT__)
153#define __glibcxx_min(T) \
154 __glibcxx_min_b (T, sizeof(T) * __CHAR_BIT__)
155#define __glibcxx_max(T) \
156 __glibcxx_max_b (T, sizeof(T) * __CHAR_BIT__)
157#define __glibcxx_digits(T) \
158 __glibcxx_digits_b (T, sizeof(T) * __CHAR_BIT__)
159#define __glibcxx_digits10(T) \
160 __glibcxx_digits10_b (T, sizeof(T) * __CHAR_BIT__)
162#define __glibcxx_max_digits10(T) \
163 (2 + (T) * 643L / 2136)
165namespace std _GLIBCXX_VISIBILITY(default)
167_GLIBCXX_BEGIN_NAMESPACE_VERSION
218 static _GLIBCXX_USE_CONSTEXPR
int digits = 0;
223#if __cplusplus >= 201103L
238 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
false;
242 static _GLIBCXX_USE_CONSTEXPR
int radix = 0;
298 static _GLIBCXX_USE_CONSTEXPR
bool traps =
false;
318 template<
typename _Tp>
323 static _GLIBCXX_CONSTEXPR _Tp
324 min() _GLIBCXX_USE_NOEXCEPT {
return _Tp(); }
327 static _GLIBCXX_CONSTEXPR _Tp
328 max() _GLIBCXX_USE_NOEXCEPT {
return _Tp(); }
330#if __cplusplus >= 201103L
339 static _GLIBCXX_CONSTEXPR _Tp
340 epsilon() _GLIBCXX_USE_NOEXCEPT {
return _Tp(); }
343 static _GLIBCXX_CONSTEXPR _Tp
347 static _GLIBCXX_CONSTEXPR _Tp
352 static _GLIBCXX_CONSTEXPR _Tp
357 static _GLIBCXX_CONSTEXPR _Tp
363 static _GLIBCXX_CONSTEXPR _Tp
370 template<
typename _Tp>
371 struct numeric_limits<const _Tp>
372 :
public numeric_limits<_Tp> { };
374 template<
typename _Tp>
378 template<
typename _Tp>
393 static _GLIBCXX_USE_CONSTEXPR
bool is_specialized =
true;
395 static _GLIBCXX_CONSTEXPR
bool
396 min() _GLIBCXX_USE_NOEXCEPT {
return false; }
398 static _GLIBCXX_CONSTEXPR
bool
399 max() _GLIBCXX_USE_NOEXCEPT {
return true; }
401#if __cplusplus >= 201103L
402 static constexpr bool
405 static _GLIBCXX_USE_CONSTEXPR
int digits = 1;
406 static _GLIBCXX_USE_CONSTEXPR
int digits10 = 0;
407#if __cplusplus >= 201103L
408 static constexpr int max_digits10 = 0;
410 static _GLIBCXX_USE_CONSTEXPR
bool is_signed =
false;
411 static _GLIBCXX_USE_CONSTEXPR
bool is_integer =
true;
412 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
true;
413 static _GLIBCXX_USE_CONSTEXPR
int radix = 2;
415 static _GLIBCXX_CONSTEXPR
bool
416 epsilon() _GLIBCXX_USE_NOEXCEPT {
return false; }
418 static _GLIBCXX_CONSTEXPR
bool
419 round_error() _GLIBCXX_USE_NOEXCEPT {
return false; }
421 static _GLIBCXX_USE_CONSTEXPR
int min_exponent = 0;
422 static _GLIBCXX_USE_CONSTEXPR
int min_exponent10 = 0;
423 static _GLIBCXX_USE_CONSTEXPR
int max_exponent = 0;
424 static _GLIBCXX_USE_CONSTEXPR
int max_exponent10 = 0;
426 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
427 static _GLIBCXX_USE_CONSTEXPR
bool has_quiet_NaN =
false;
428 static _GLIBCXX_USE_CONSTEXPR
bool has_signaling_NaN =
false;
431 static _GLIBCXX_USE_CONSTEXPR
bool has_denorm_loss =
false;
433 static _GLIBCXX_CONSTEXPR
bool
434 infinity() _GLIBCXX_USE_NOEXCEPT {
return false; }
436 static _GLIBCXX_CONSTEXPR
bool
437 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return false; }
439 static _GLIBCXX_CONSTEXPR
bool
442 static _GLIBCXX_CONSTEXPR
bool
443 denorm_min() _GLIBCXX_USE_NOEXCEPT {
return false; }
445 static _GLIBCXX_USE_CONSTEXPR
bool is_iec559 =
false;
446 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
447 static _GLIBCXX_USE_CONSTEXPR
bool is_modulo =
false;
452 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
453 static _GLIBCXX_USE_CONSTEXPR
bool tinyness_before =
false;
462 static _GLIBCXX_USE_CONSTEXPR
bool is_specialized =
true;
464 static _GLIBCXX_CONSTEXPR
char
465 min() _GLIBCXX_USE_NOEXCEPT {
return __glibcxx_min(
char); }
467 static _GLIBCXX_CONSTEXPR
char
468 max() _GLIBCXX_USE_NOEXCEPT {
return __glibcxx_max(
char); }
470#if __cplusplus >= 201103L
471 static constexpr char
475 static _GLIBCXX_USE_CONSTEXPR
int digits = __glibcxx_digits (
char);
476 static _GLIBCXX_USE_CONSTEXPR
int digits10 = __glibcxx_digits10 (
char);
477#if __cplusplus >= 201103L
478 static constexpr int max_digits10 = 0;
480 static _GLIBCXX_USE_CONSTEXPR
bool is_signed = __glibcxx_signed (
char);
481 static _GLIBCXX_USE_CONSTEXPR
bool is_integer =
true;
482 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
true;
483 static _GLIBCXX_USE_CONSTEXPR
int radix = 2;
485 static _GLIBCXX_CONSTEXPR
char
486 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
488 static _GLIBCXX_CONSTEXPR
char
491 static _GLIBCXX_USE_CONSTEXPR
int min_exponent = 0;
492 static _GLIBCXX_USE_CONSTEXPR
int min_exponent10 = 0;
493 static _GLIBCXX_USE_CONSTEXPR
int max_exponent = 0;
494 static _GLIBCXX_USE_CONSTEXPR
int max_exponent10 = 0;
496 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
497 static _GLIBCXX_USE_CONSTEXPR
bool has_quiet_NaN =
false;
498 static _GLIBCXX_USE_CONSTEXPR
bool has_signaling_NaN =
false;
501 static _GLIBCXX_USE_CONSTEXPR
bool has_denorm_loss =
false;
503 static _GLIBCXX_CONSTEXPR
504 char infinity() _GLIBCXX_USE_NOEXCEPT {
return char(); }
506 static _GLIBCXX_CONSTEXPR
char
507 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return char(); }
509 static _GLIBCXX_CONSTEXPR
char
512 static _GLIBCXX_CONSTEXPR
char
513 denorm_min() _GLIBCXX_USE_NOEXCEPT {
return static_cast<char>(0); }
515 static _GLIBCXX_USE_CONSTEXPR
bool is_iec559 =
false;
516 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
517 static _GLIBCXX_USE_CONSTEXPR
bool is_modulo = !is_signed;
519 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
520 static _GLIBCXX_USE_CONSTEXPR
bool tinyness_before =
false;
529 static _GLIBCXX_USE_CONSTEXPR
bool is_specialized =
true;
531 static _GLIBCXX_CONSTEXPR
signed char
532 min() _GLIBCXX_USE_NOEXCEPT {
return -__SCHAR_MAX__ - 1; }
534 static _GLIBCXX_CONSTEXPR
signed char
535 max() _GLIBCXX_USE_NOEXCEPT {
return __SCHAR_MAX__; }
537#if __cplusplus >= 201103L
538 static constexpr signed char
542 static _GLIBCXX_USE_CONSTEXPR
int digits = __glibcxx_digits (
signed char);
543 static _GLIBCXX_USE_CONSTEXPR
int digits10
544 = __glibcxx_digits10 (
signed char);
545#if __cplusplus >= 201103L
546 static constexpr int max_digits10 = 0;
548 static _GLIBCXX_USE_CONSTEXPR
bool is_signed =
true;
549 static _GLIBCXX_USE_CONSTEXPR
bool is_integer =
true;
550 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
true;
551 static _GLIBCXX_USE_CONSTEXPR
int radix = 2;
553 static _GLIBCXX_CONSTEXPR
signed char
554 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
556 static _GLIBCXX_CONSTEXPR
signed char
559 static _GLIBCXX_USE_CONSTEXPR
int min_exponent = 0;
560 static _GLIBCXX_USE_CONSTEXPR
int min_exponent10 = 0;
561 static _GLIBCXX_USE_CONSTEXPR
int max_exponent = 0;
562 static _GLIBCXX_USE_CONSTEXPR
int max_exponent10 = 0;
564 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
565 static _GLIBCXX_USE_CONSTEXPR
bool has_quiet_NaN =
false;
566 static _GLIBCXX_USE_CONSTEXPR
bool has_signaling_NaN =
false;
569 static _GLIBCXX_USE_CONSTEXPR
bool has_denorm_loss =
false;
571 static _GLIBCXX_CONSTEXPR
signed char
572 infinity() _GLIBCXX_USE_NOEXCEPT {
return static_cast<signed char>(0); }
574 static _GLIBCXX_CONSTEXPR
signed char
575 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return static_cast<signed char>(0); }
577 static _GLIBCXX_CONSTEXPR
signed char
579 {
return static_cast<signed char>(0); }
581 static _GLIBCXX_CONSTEXPR
signed char
583 {
return static_cast<signed char>(0); }
585 static _GLIBCXX_USE_CONSTEXPR
bool is_iec559 =
false;
586 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
587 static _GLIBCXX_USE_CONSTEXPR
bool is_modulo =
false;
589 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
590 static _GLIBCXX_USE_CONSTEXPR
bool tinyness_before =
false;
599 static _GLIBCXX_USE_CONSTEXPR
bool is_specialized =
true;
601 static _GLIBCXX_CONSTEXPR
unsigned char
602 min() _GLIBCXX_USE_NOEXCEPT {
return 0; }
604 static _GLIBCXX_CONSTEXPR
unsigned char
605 max() _GLIBCXX_USE_NOEXCEPT {
return __SCHAR_MAX__ * 2U + 1; }
607#if __cplusplus >= 201103L
608 static constexpr unsigned char
612 static _GLIBCXX_USE_CONSTEXPR
int digits
613 = __glibcxx_digits (
unsigned char);
614 static _GLIBCXX_USE_CONSTEXPR
int digits10
615 = __glibcxx_digits10 (
unsigned char);
616#if __cplusplus >= 201103L
617 static constexpr int max_digits10 = 0;
619 static _GLIBCXX_USE_CONSTEXPR
bool is_signed =
false;
620 static _GLIBCXX_USE_CONSTEXPR
bool is_integer =
true;
621 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
true;
622 static _GLIBCXX_USE_CONSTEXPR
int radix = 2;
624 static _GLIBCXX_CONSTEXPR
unsigned char
625 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
627 static _GLIBCXX_CONSTEXPR
unsigned char
630 static _GLIBCXX_USE_CONSTEXPR
int min_exponent = 0;
631 static _GLIBCXX_USE_CONSTEXPR
int min_exponent10 = 0;
632 static _GLIBCXX_USE_CONSTEXPR
int max_exponent = 0;
633 static _GLIBCXX_USE_CONSTEXPR
int max_exponent10 = 0;
635 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
636 static _GLIBCXX_USE_CONSTEXPR
bool has_quiet_NaN =
false;
637 static _GLIBCXX_USE_CONSTEXPR
bool has_signaling_NaN =
false;
640 static _GLIBCXX_USE_CONSTEXPR
bool has_denorm_loss =
false;
642 static _GLIBCXX_CONSTEXPR
unsigned char
644 {
return static_cast<unsigned char>(0); }
646 static _GLIBCXX_CONSTEXPR
unsigned char
648 {
return static_cast<unsigned char>(0); }
650 static _GLIBCXX_CONSTEXPR
unsigned char
652 {
return static_cast<unsigned char>(0); }
654 static _GLIBCXX_CONSTEXPR
unsigned char
656 {
return static_cast<unsigned char>(0); }
658 static _GLIBCXX_USE_CONSTEXPR
bool is_iec559 =
false;
659 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
660 static _GLIBCXX_USE_CONSTEXPR
bool is_modulo =
true;
662 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
663 static _GLIBCXX_USE_CONSTEXPR
bool tinyness_before =
false;
672 static _GLIBCXX_USE_CONSTEXPR
bool is_specialized =
true;
674 static _GLIBCXX_CONSTEXPR
wchar_t
675 min() _GLIBCXX_USE_NOEXCEPT {
return __glibcxx_min (
wchar_t); }
677 static _GLIBCXX_CONSTEXPR
wchar_t
678 max() _GLIBCXX_USE_NOEXCEPT {
return __glibcxx_max (
wchar_t); }
680#if __cplusplus >= 201103L
681 static constexpr wchar_t
685 static _GLIBCXX_USE_CONSTEXPR
int digits = __glibcxx_digits (
wchar_t);
686 static _GLIBCXX_USE_CONSTEXPR
int digits10
687 = __glibcxx_digits10 (
wchar_t);
688#if __cplusplus >= 201103L
689 static constexpr int max_digits10 = 0;
691 static _GLIBCXX_USE_CONSTEXPR
bool is_signed = __glibcxx_signed (
wchar_t);
692 static _GLIBCXX_USE_CONSTEXPR
bool is_integer =
true;
693 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
true;
694 static _GLIBCXX_USE_CONSTEXPR
int radix = 2;
696 static _GLIBCXX_CONSTEXPR
wchar_t
697 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
699 static _GLIBCXX_CONSTEXPR
wchar_t
702 static _GLIBCXX_USE_CONSTEXPR
int min_exponent = 0;
703 static _GLIBCXX_USE_CONSTEXPR
int min_exponent10 = 0;
704 static _GLIBCXX_USE_CONSTEXPR
int max_exponent = 0;
705 static _GLIBCXX_USE_CONSTEXPR
int max_exponent10 = 0;
707 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
708 static _GLIBCXX_USE_CONSTEXPR
bool has_quiet_NaN =
false;
709 static _GLIBCXX_USE_CONSTEXPR
bool has_signaling_NaN =
false;
712 static _GLIBCXX_USE_CONSTEXPR
bool has_denorm_loss =
false;
714 static _GLIBCXX_CONSTEXPR
wchar_t
715 infinity() _GLIBCXX_USE_NOEXCEPT {
return wchar_t(); }
717 static _GLIBCXX_CONSTEXPR
wchar_t
718 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return wchar_t(); }
720 static _GLIBCXX_CONSTEXPR
wchar_t
723 static _GLIBCXX_CONSTEXPR
wchar_t
724 denorm_min() _GLIBCXX_USE_NOEXCEPT {
return wchar_t(); }
726 static _GLIBCXX_USE_CONSTEXPR
bool is_iec559 =
false;
727 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
728 static _GLIBCXX_USE_CONSTEXPR
bool is_modulo = !is_signed;
730 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
731 static _GLIBCXX_USE_CONSTEXPR
bool tinyness_before =
false;
736#if _GLIBCXX_USE_CHAR8_T
743 static _GLIBCXX_CONSTEXPR
char8_t
744 min() _GLIBCXX_USE_NOEXCEPT {
return __glibcxx_min (
char8_t); }
746 static _GLIBCXX_CONSTEXPR
char8_t
747 max() _GLIBCXX_USE_NOEXCEPT {
return __glibcxx_max (
char8_t); }
749 static _GLIBCXX_CONSTEXPR
char8_t
750 lowest() _GLIBCXX_USE_NOEXCEPT {
return min(); }
752 static _GLIBCXX_USE_CONSTEXPR
int digits = __glibcxx_digits (
char8_t);
753 static _GLIBCXX_USE_CONSTEXPR
int digits10 = __glibcxx_digits10 (
char8_t);
755 static _GLIBCXX_USE_CONSTEXPR
bool is_signed = __glibcxx_signed (
char8_t);
756 static _GLIBCXX_USE_CONSTEXPR
bool is_integer =
true;
757 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
true;
758 static _GLIBCXX_USE_CONSTEXPR
int radix = 2;
760 static _GLIBCXX_CONSTEXPR
char8_t
761 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
763 static _GLIBCXX_CONSTEXPR
char8_t
771 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
778 static _GLIBCXX_CONSTEXPR
char8_t
779 infinity() _GLIBCXX_USE_NOEXCEPT {
return char8_t(); }
781 static _GLIBCXX_CONSTEXPR
char8_t
782 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return char8_t(); }
784 static _GLIBCXX_CONSTEXPR
char8_t
787 static _GLIBCXX_CONSTEXPR
char8_t
788 denorm_min() _GLIBCXX_USE_NOEXCEPT {
return char8_t(); }
790 static _GLIBCXX_USE_CONSTEXPR
bool is_iec559 =
false;
791 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
794 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
801#if __cplusplus >= 201103L
806 static constexpr bool is_specialized =
true;
808 static constexpr char16_t
809 min()
noexcept {
return __glibcxx_min (
char16_t); }
811 static constexpr char16_t
812 max()
noexcept {
return __glibcxx_max (
char16_t); }
814 static constexpr char16_t
817 static constexpr int digits = __glibcxx_digits (
char16_t);
818 static constexpr int digits10 = __glibcxx_digits10 (
char16_t);
819 static constexpr int max_digits10 = 0;
820 static constexpr bool is_signed = __glibcxx_signed (
char16_t);
821 static constexpr bool is_integer =
true;
822 static constexpr bool is_exact =
true;
823 static constexpr int radix = 2;
825 static constexpr char16_t
826 epsilon()
noexcept {
return 0; }
828 static constexpr char16_t
831 static constexpr int min_exponent = 0;
832 static constexpr int min_exponent10 = 0;
833 static constexpr int max_exponent = 0;
834 static constexpr int max_exponent10 = 0;
836 static constexpr bool has_infinity =
false;
837 static constexpr bool has_quiet_NaN =
false;
838 static constexpr bool has_signaling_NaN =
false;
840 static constexpr bool has_denorm_loss =
false;
842 static constexpr char16_t
843 infinity()
noexcept {
return char16_t(); }
845 static constexpr char16_t
846 quiet_NaN()
noexcept {
return char16_t(); }
848 static constexpr char16_t
851 static constexpr char16_t
854 static constexpr bool is_iec559 =
false;
855 static constexpr bool is_bounded =
true;
856 static constexpr bool is_modulo = !is_signed;
858 static constexpr bool traps = __glibcxx_integral_traps;
859 static constexpr bool tinyness_before =
false;
867 static constexpr bool is_specialized =
true;
869 static constexpr char32_t
870 min()
noexcept {
return __glibcxx_min (
char32_t); }
872 static constexpr char32_t
873 max()
noexcept {
return __glibcxx_max (
char32_t); }
875 static constexpr char32_t
878 static constexpr int digits = __glibcxx_digits (
char32_t);
879 static constexpr int digits10 = __glibcxx_digits10 (
char32_t);
880 static constexpr int max_digits10 = 0;
881 static constexpr bool is_signed = __glibcxx_signed (
char32_t);
882 static constexpr bool is_integer =
true;
883 static constexpr bool is_exact =
true;
884 static constexpr int radix = 2;
886 static constexpr char32_t
887 epsilon()
noexcept {
return 0; }
889 static constexpr char32_t
892 static constexpr int min_exponent = 0;
893 static constexpr int min_exponent10 = 0;
894 static constexpr int max_exponent = 0;
895 static constexpr int max_exponent10 = 0;
897 static constexpr bool has_infinity =
false;
898 static constexpr bool has_quiet_NaN =
false;
899 static constexpr bool has_signaling_NaN =
false;
901 static constexpr bool has_denorm_loss =
false;
903 static constexpr char32_t
904 infinity()
noexcept {
return char32_t(); }
906 static constexpr char32_t
907 quiet_NaN()
noexcept {
return char32_t(); }
909 static constexpr char32_t
912 static constexpr char32_t
915 static constexpr bool is_iec559 =
false;
916 static constexpr bool is_bounded =
true;
917 static constexpr bool is_modulo = !is_signed;
919 static constexpr bool traps = __glibcxx_integral_traps;
920 static constexpr bool tinyness_before =
false;
929 static _GLIBCXX_USE_CONSTEXPR
bool is_specialized =
true;
931 static _GLIBCXX_CONSTEXPR
short
932 min() _GLIBCXX_USE_NOEXCEPT {
return -__SHRT_MAX__ - 1; }
934 static _GLIBCXX_CONSTEXPR
short
935 max() _GLIBCXX_USE_NOEXCEPT {
return __SHRT_MAX__; }
937#if __cplusplus >= 201103L
938 static constexpr short
942 static _GLIBCXX_USE_CONSTEXPR
int digits = __glibcxx_digits (
short);
943 static _GLIBCXX_USE_CONSTEXPR
int digits10 = __glibcxx_digits10 (
short);
944#if __cplusplus >= 201103L
945 static constexpr int max_digits10 = 0;
947 static _GLIBCXX_USE_CONSTEXPR
bool is_signed =
true;
948 static _GLIBCXX_USE_CONSTEXPR
bool is_integer =
true;
949 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
true;
950 static _GLIBCXX_USE_CONSTEXPR
int radix = 2;
952 static _GLIBCXX_CONSTEXPR
short
953 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
955 static _GLIBCXX_CONSTEXPR
short
958 static _GLIBCXX_USE_CONSTEXPR
int min_exponent = 0;
959 static _GLIBCXX_USE_CONSTEXPR
int min_exponent10 = 0;
960 static _GLIBCXX_USE_CONSTEXPR
int max_exponent = 0;
961 static _GLIBCXX_USE_CONSTEXPR
int max_exponent10 = 0;
963 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
964 static _GLIBCXX_USE_CONSTEXPR
bool has_quiet_NaN =
false;
965 static _GLIBCXX_USE_CONSTEXPR
bool has_signaling_NaN =
false;
968 static _GLIBCXX_USE_CONSTEXPR
bool has_denorm_loss =
false;
970 static _GLIBCXX_CONSTEXPR
short
971 infinity() _GLIBCXX_USE_NOEXCEPT {
return short(); }
973 static _GLIBCXX_CONSTEXPR
short
974 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return short(); }
976 static _GLIBCXX_CONSTEXPR
short
979 static _GLIBCXX_CONSTEXPR
short
980 denorm_min() _GLIBCXX_USE_NOEXCEPT {
return short(); }
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 =
false;
986 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
987 static _GLIBCXX_USE_CONSTEXPR
bool tinyness_before =
false;
996 static _GLIBCXX_USE_CONSTEXPR
bool is_specialized =
true;
998 static _GLIBCXX_CONSTEXPR
unsigned short
999 min() _GLIBCXX_USE_NOEXCEPT {
return 0; }
1001 static _GLIBCXX_CONSTEXPR
unsigned short
1002 max() _GLIBCXX_USE_NOEXCEPT {
return __SHRT_MAX__ * 2U + 1; }
1004#if __cplusplus >= 201103L
1005 static constexpr unsigned short
1009 static _GLIBCXX_USE_CONSTEXPR
int digits
1010 = __glibcxx_digits (
unsigned short);
1011 static _GLIBCXX_USE_CONSTEXPR
int digits10
1012 = __glibcxx_digits10 (
unsigned short);
1013#if __cplusplus >= 201103L
1014 static constexpr int max_digits10 = 0;
1016 static _GLIBCXX_USE_CONSTEXPR
bool is_signed =
false;
1017 static _GLIBCXX_USE_CONSTEXPR
bool is_integer =
true;
1018 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
true;
1019 static _GLIBCXX_USE_CONSTEXPR
int radix = 2;
1021 static _GLIBCXX_CONSTEXPR
unsigned short
1022 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
1024 static _GLIBCXX_CONSTEXPR
unsigned short
1027 static _GLIBCXX_USE_CONSTEXPR
int min_exponent = 0;
1028 static _GLIBCXX_USE_CONSTEXPR
int min_exponent10 = 0;
1029 static _GLIBCXX_USE_CONSTEXPR
int max_exponent = 0;
1030 static _GLIBCXX_USE_CONSTEXPR
int max_exponent10 = 0;
1032 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
1033 static _GLIBCXX_USE_CONSTEXPR
bool has_quiet_NaN =
false;
1034 static _GLIBCXX_USE_CONSTEXPR
bool has_signaling_NaN =
false;
1037 static _GLIBCXX_USE_CONSTEXPR
bool has_denorm_loss =
false;
1039 static _GLIBCXX_CONSTEXPR
unsigned short
1041 {
return static_cast<unsigned short>(0); }
1043 static _GLIBCXX_CONSTEXPR
unsigned short
1045 {
return static_cast<unsigned short>(0); }
1047 static _GLIBCXX_CONSTEXPR
unsigned short
1049 {
return static_cast<unsigned short>(0); }
1051 static _GLIBCXX_CONSTEXPR
unsigned short
1053 {
return static_cast<unsigned short>(0); }
1055 static _GLIBCXX_USE_CONSTEXPR
bool is_iec559 =
false;
1056 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
1057 static _GLIBCXX_USE_CONSTEXPR
bool is_modulo =
true;
1059 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
1060 static _GLIBCXX_USE_CONSTEXPR
bool tinyness_before =
false;
1069 static _GLIBCXX_USE_CONSTEXPR
bool is_specialized =
true;
1071 static _GLIBCXX_CONSTEXPR
int
1072 min() _GLIBCXX_USE_NOEXCEPT {
return -__INT_MAX__ - 1; }
1074 static _GLIBCXX_CONSTEXPR
int
1075 max() _GLIBCXX_USE_NOEXCEPT {
return __INT_MAX__; }
1077#if __cplusplus >= 201103L
1078 static constexpr int
1082 static _GLIBCXX_USE_CONSTEXPR
int digits = __glibcxx_digits (
int);
1083 static _GLIBCXX_USE_CONSTEXPR
int digits10 = __glibcxx_digits10 (
int);
1084#if __cplusplus >= 201103L
1085 static constexpr int max_digits10 = 0;
1087 static _GLIBCXX_USE_CONSTEXPR
bool is_signed =
true;
1088 static _GLIBCXX_USE_CONSTEXPR
bool is_integer =
true;
1089 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
true;
1090 static _GLIBCXX_USE_CONSTEXPR
int radix = 2;
1092 static _GLIBCXX_CONSTEXPR
int
1093 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
1095 static _GLIBCXX_CONSTEXPR
int
1098 static _GLIBCXX_USE_CONSTEXPR
int min_exponent = 0;
1099 static _GLIBCXX_USE_CONSTEXPR
int min_exponent10 = 0;
1100 static _GLIBCXX_USE_CONSTEXPR
int max_exponent = 0;
1101 static _GLIBCXX_USE_CONSTEXPR
int max_exponent10 = 0;
1103 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
1104 static _GLIBCXX_USE_CONSTEXPR
bool has_quiet_NaN =
false;
1105 static _GLIBCXX_USE_CONSTEXPR
bool has_signaling_NaN =
false;
1108 static _GLIBCXX_USE_CONSTEXPR
bool has_denorm_loss =
false;
1110 static _GLIBCXX_CONSTEXPR
int
1111 infinity() _GLIBCXX_USE_NOEXCEPT {
return static_cast<int>(0); }
1113 static _GLIBCXX_CONSTEXPR
int
1114 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return static_cast<int>(0); }
1116 static _GLIBCXX_CONSTEXPR
int
1117 signaling_NaN() _GLIBCXX_USE_NOEXCEPT {
return static_cast<int>(0); }
1119 static _GLIBCXX_CONSTEXPR
int
1120 denorm_min() _GLIBCXX_USE_NOEXCEPT {
return static_cast<int>(0); }
1122 static _GLIBCXX_USE_CONSTEXPR
bool is_iec559 =
false;
1123 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
1124 static _GLIBCXX_USE_CONSTEXPR
bool is_modulo =
false;
1126 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
1127 static _GLIBCXX_USE_CONSTEXPR
bool tinyness_before =
false;
1136 static _GLIBCXX_USE_CONSTEXPR
bool is_specialized =
true;
1138 static _GLIBCXX_CONSTEXPR
unsigned int
1139 min() _GLIBCXX_USE_NOEXCEPT {
return 0; }
1141 static _GLIBCXX_CONSTEXPR
unsigned int
1142 max() _GLIBCXX_USE_NOEXCEPT {
return __INT_MAX__ * 2U + 1; }
1144#if __cplusplus >= 201103L
1145 static constexpr unsigned int
1149 static _GLIBCXX_USE_CONSTEXPR
int digits
1150 = __glibcxx_digits (
unsigned int);
1151 static _GLIBCXX_USE_CONSTEXPR
int digits10
1152 = __glibcxx_digits10 (
unsigned int);
1153#if __cplusplus >= 201103L
1154 static constexpr int max_digits10 = 0;
1156 static _GLIBCXX_USE_CONSTEXPR
bool is_signed =
false;
1157 static _GLIBCXX_USE_CONSTEXPR
bool is_integer =
true;
1158 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
true;
1159 static _GLIBCXX_USE_CONSTEXPR
int radix = 2;
1161 static _GLIBCXX_CONSTEXPR
unsigned int
1162 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
1164 static _GLIBCXX_CONSTEXPR
unsigned int
1167 static _GLIBCXX_USE_CONSTEXPR
int min_exponent = 0;
1168 static _GLIBCXX_USE_CONSTEXPR
int min_exponent10 = 0;
1169 static _GLIBCXX_USE_CONSTEXPR
int max_exponent = 0;
1170 static _GLIBCXX_USE_CONSTEXPR
int max_exponent10 = 0;
1172 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
1173 static _GLIBCXX_USE_CONSTEXPR
bool has_quiet_NaN =
false;
1174 static _GLIBCXX_USE_CONSTEXPR
bool has_signaling_NaN =
false;
1177 static _GLIBCXX_USE_CONSTEXPR
bool has_denorm_loss =
false;
1179 static _GLIBCXX_CONSTEXPR
unsigned int
1180 infinity() _GLIBCXX_USE_NOEXCEPT {
return static_cast<unsigned int>(0); }
1182 static _GLIBCXX_CONSTEXPR
unsigned int
1184 {
return static_cast<unsigned int>(0); }
1186 static _GLIBCXX_CONSTEXPR
unsigned int
1188 {
return static_cast<unsigned int>(0); }
1190 static _GLIBCXX_CONSTEXPR
unsigned int
1192 {
return static_cast<unsigned int>(0); }
1194 static _GLIBCXX_USE_CONSTEXPR
bool is_iec559 =
false;
1195 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
1196 static _GLIBCXX_USE_CONSTEXPR
bool is_modulo =
true;
1198 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
1199 static _GLIBCXX_USE_CONSTEXPR
bool tinyness_before =
false;
1208 static _GLIBCXX_USE_CONSTEXPR
bool is_specialized =
true;
1210 static _GLIBCXX_CONSTEXPR
long
1211 min() _GLIBCXX_USE_NOEXCEPT {
return -__LONG_MAX__ - 1; }
1213 static _GLIBCXX_CONSTEXPR
long
1214 max() _GLIBCXX_USE_NOEXCEPT {
return __LONG_MAX__; }
1216#if __cplusplus >= 201103L
1217 static constexpr long
1221 static _GLIBCXX_USE_CONSTEXPR
int digits = __glibcxx_digits (
long);
1222 static _GLIBCXX_USE_CONSTEXPR
int digits10 = __glibcxx_digits10 (
long);
1223#if __cplusplus >= 201103L
1224 static constexpr int max_digits10 = 0;
1226 static _GLIBCXX_USE_CONSTEXPR
bool is_signed =
true;
1227 static _GLIBCXX_USE_CONSTEXPR
bool is_integer =
true;
1228 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
true;
1229 static _GLIBCXX_USE_CONSTEXPR
int radix = 2;
1231 static _GLIBCXX_CONSTEXPR
long
1232 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
1234 static _GLIBCXX_CONSTEXPR
long
1237 static _GLIBCXX_USE_CONSTEXPR
int min_exponent = 0;
1238 static _GLIBCXX_USE_CONSTEXPR
int min_exponent10 = 0;
1239 static _GLIBCXX_USE_CONSTEXPR
int max_exponent = 0;
1240 static _GLIBCXX_USE_CONSTEXPR
int max_exponent10 = 0;
1242 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
1243 static _GLIBCXX_USE_CONSTEXPR
bool has_quiet_NaN =
false;
1244 static _GLIBCXX_USE_CONSTEXPR
bool has_signaling_NaN =
false;
1247 static _GLIBCXX_USE_CONSTEXPR
bool has_denorm_loss =
false;
1249 static _GLIBCXX_CONSTEXPR
long
1250 infinity() _GLIBCXX_USE_NOEXCEPT {
return static_cast<long>(0); }
1252 static _GLIBCXX_CONSTEXPR
long
1253 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return static_cast<long>(0); }
1255 static _GLIBCXX_CONSTEXPR
long
1256 signaling_NaN() _GLIBCXX_USE_NOEXCEPT {
return static_cast<long>(0); }
1258 static _GLIBCXX_CONSTEXPR
long
1259 denorm_min() _GLIBCXX_USE_NOEXCEPT {
return static_cast<long>(0); }
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 =
false;
1265 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
1266 static _GLIBCXX_USE_CONSTEXPR
bool tinyness_before =
false;
1275 static _GLIBCXX_USE_CONSTEXPR
bool is_specialized =
true;
1277 static _GLIBCXX_CONSTEXPR
unsigned long
1278 min() _GLIBCXX_USE_NOEXCEPT {
return 0; }
1280 static _GLIBCXX_CONSTEXPR
unsigned long
1281 max() _GLIBCXX_USE_NOEXCEPT {
return __LONG_MAX__ * 2UL + 1; }
1283#if __cplusplus >= 201103L
1284 static constexpr unsigned long
1288 static _GLIBCXX_USE_CONSTEXPR
int digits
1289 = __glibcxx_digits (
unsigned long);
1290 static _GLIBCXX_USE_CONSTEXPR
int digits10
1291 = __glibcxx_digits10 (
unsigned long);
1292#if __cplusplus >= 201103L
1293 static constexpr int max_digits10 = 0;
1295 static _GLIBCXX_USE_CONSTEXPR
bool is_signed =
false;
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;
1300 static _GLIBCXX_CONSTEXPR
unsigned long
1301 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
1303 static _GLIBCXX_CONSTEXPR
unsigned long
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;
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;
1316 static _GLIBCXX_USE_CONSTEXPR
bool has_denorm_loss =
false;
1318 static _GLIBCXX_CONSTEXPR
unsigned long
1320 {
return static_cast<unsigned long>(0); }
1322 static _GLIBCXX_CONSTEXPR
unsigned long
1324 {
return static_cast<unsigned long>(0); }
1326 static _GLIBCXX_CONSTEXPR
unsigned long
1328 {
return static_cast<unsigned long>(0); }
1330 static _GLIBCXX_CONSTEXPR
unsigned long
1332 {
return static_cast<unsigned long>(0); }
1334 static _GLIBCXX_USE_CONSTEXPR
bool is_iec559 =
false;
1335 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
1336 static _GLIBCXX_USE_CONSTEXPR
bool is_modulo =
true;
1338 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
1339 static _GLIBCXX_USE_CONSTEXPR
bool tinyness_before =
false;
1348 static _GLIBCXX_USE_CONSTEXPR
bool is_specialized =
true;
1350 static _GLIBCXX_CONSTEXPR
long long
1351 min() _GLIBCXX_USE_NOEXCEPT {
return -__LONG_LONG_MAX__ - 1; }
1353 static _GLIBCXX_CONSTEXPR
long long
1354 max() _GLIBCXX_USE_NOEXCEPT {
return __LONG_LONG_MAX__; }
1356#if __cplusplus >= 201103L
1357 static constexpr long long
1361 static _GLIBCXX_USE_CONSTEXPR
int digits
1362 = __glibcxx_digits (
long long);
1363 static _GLIBCXX_USE_CONSTEXPR
int digits10
1364 = __glibcxx_digits10 (
long long);
1365#if __cplusplus >= 201103L
1366 static constexpr int max_digits10 = 0;
1368 static _GLIBCXX_USE_CONSTEXPR
bool is_signed =
true;
1369 static _GLIBCXX_USE_CONSTEXPR
bool is_integer =
true;
1370 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
true;
1371 static _GLIBCXX_USE_CONSTEXPR
int radix = 2;
1373 static _GLIBCXX_CONSTEXPR
long long
1374 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
1376 static _GLIBCXX_CONSTEXPR
long long
1379 static _GLIBCXX_USE_CONSTEXPR
int min_exponent = 0;
1380 static _GLIBCXX_USE_CONSTEXPR
int min_exponent10 = 0;
1381 static _GLIBCXX_USE_CONSTEXPR
int max_exponent = 0;
1382 static _GLIBCXX_USE_CONSTEXPR
int max_exponent10 = 0;
1384 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
1385 static _GLIBCXX_USE_CONSTEXPR
bool has_quiet_NaN =
false;
1386 static _GLIBCXX_USE_CONSTEXPR
bool has_signaling_NaN =
false;
1389 static _GLIBCXX_USE_CONSTEXPR
bool has_denorm_loss =
false;
1391 static _GLIBCXX_CONSTEXPR
long long
1392 infinity() _GLIBCXX_USE_NOEXCEPT {
return static_cast<long long>(0); }
1394 static _GLIBCXX_CONSTEXPR
long long
1395 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return static_cast<long long>(0); }
1397 static _GLIBCXX_CONSTEXPR
long long
1399 {
return static_cast<long long>(0); }
1401 static _GLIBCXX_CONSTEXPR
long long
1402 denorm_min() _GLIBCXX_USE_NOEXCEPT {
return static_cast<long long>(0); }
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 =
false;
1408 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
1409 static _GLIBCXX_USE_CONSTEXPR
bool tinyness_before =
false;
1418 static _GLIBCXX_USE_CONSTEXPR
bool is_specialized =
true;
1420 static _GLIBCXX_CONSTEXPR
unsigned long long
1421 min() _GLIBCXX_USE_NOEXCEPT {
return 0; }
1423 static _GLIBCXX_CONSTEXPR
unsigned long long
1424 max() _GLIBCXX_USE_NOEXCEPT {
return __LONG_LONG_MAX__ * 2ULL + 1; }
1426#if __cplusplus >= 201103L
1427 static constexpr unsigned long long
1431 static _GLIBCXX_USE_CONSTEXPR
int digits
1432 = __glibcxx_digits (
unsigned long long);
1433 static _GLIBCXX_USE_CONSTEXPR
int digits10
1434 = __glibcxx_digits10 (
unsigned long long);
1435#if __cplusplus >= 201103L
1436 static constexpr int max_digits10 = 0;
1438 static _GLIBCXX_USE_CONSTEXPR
bool is_signed =
false;
1439 static _GLIBCXX_USE_CONSTEXPR
bool is_integer =
true;
1440 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
true;
1441 static _GLIBCXX_USE_CONSTEXPR
int radix = 2;
1443 static _GLIBCXX_CONSTEXPR
unsigned long long
1444 epsilon() _GLIBCXX_USE_NOEXCEPT {
return 0; }
1446 static _GLIBCXX_CONSTEXPR
unsigned long long
1449 static _GLIBCXX_USE_CONSTEXPR
int min_exponent = 0;
1450 static _GLIBCXX_USE_CONSTEXPR
int min_exponent10 = 0;
1451 static _GLIBCXX_USE_CONSTEXPR
int max_exponent = 0;
1452 static _GLIBCXX_USE_CONSTEXPR
int max_exponent10 = 0;
1454 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity =
false;
1455 static _GLIBCXX_USE_CONSTEXPR
bool has_quiet_NaN =
false;
1456 static _GLIBCXX_USE_CONSTEXPR
bool has_signaling_NaN =
false;
1459 static _GLIBCXX_USE_CONSTEXPR
bool has_denorm_loss =
false;
1461 static _GLIBCXX_CONSTEXPR
unsigned long long
1463 {
return static_cast<unsigned long long>(0); }
1465 static _GLIBCXX_CONSTEXPR
unsigned long long
1467 {
return static_cast<unsigned long long>(0); }
1469 static _GLIBCXX_CONSTEXPR
unsigned long long
1471 {
return static_cast<unsigned long long>(0); }
1473 static _GLIBCXX_CONSTEXPR
unsigned long long
1475 {
return static_cast<unsigned long long>(0); }
1477 static _GLIBCXX_USE_CONSTEXPR
bool is_iec559 =
false;
1478 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
1479 static _GLIBCXX_USE_CONSTEXPR
bool is_modulo =
true;
1481 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_integral_traps;
1482 static _GLIBCXX_USE_CONSTEXPR
bool tinyness_before =
false;
1487#define __INT_N(TYPE, BITSIZE, EXT, UEXT) \
1490 struct numeric_limits<TYPE> \
1492 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; \
1494 static _GLIBCXX_CONSTEXPR TYPE \
1495 min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min_b (TYPE, BITSIZE); } \
1497 static _GLIBCXX_CONSTEXPR TYPE \
1498 max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max_b (TYPE, BITSIZE); } \
1500 static _GLIBCXX_USE_CONSTEXPR int digits \
1502 static _GLIBCXX_USE_CONSTEXPR int digits10 \
1503 = (BITSIZE - 1) * 643L / 2136; \
1505 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; \
1506 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; \
1507 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; \
1508 static _GLIBCXX_USE_CONSTEXPR int radix = 2; \
1510 static _GLIBCXX_CONSTEXPR TYPE \
1511 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1513 static _GLIBCXX_CONSTEXPR TYPE \
1514 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1518 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; \
1519 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; \
1520 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; \
1521 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; \
1523 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; \
1524 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; \
1525 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; \
1526 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm \
1528 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; \
1530 static _GLIBCXX_CONSTEXPR TYPE \
1531 infinity() _GLIBCXX_USE_NOEXCEPT \
1532 { return static_cast<TYPE>(0); } \
1534 static _GLIBCXX_CONSTEXPR TYPE \
1535 quiet_NaN() _GLIBCXX_USE_NOEXCEPT \
1536 { return static_cast<TYPE>(0); } \
1538 static _GLIBCXX_CONSTEXPR TYPE \
1539 signaling_NaN() _GLIBCXX_USE_NOEXCEPT \
1540 { return static_cast<TYPE>(0); } \
1542 static _GLIBCXX_CONSTEXPR TYPE \
1543 denorm_min() _GLIBCXX_USE_NOEXCEPT \
1544 { return static_cast<TYPE>(0); } \
1546 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; \
1547 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; \
1548 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; \
1550 static _GLIBCXX_USE_CONSTEXPR bool traps \
1551 = __glibcxx_integral_traps; \
1552 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; \
1553 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style \
1554 = round_toward_zero; \
1559 struct numeric_limits<unsigned TYPE> \
1561 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; \
1563 static _GLIBCXX_CONSTEXPR unsigned TYPE \
1564 min() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1566 static _GLIBCXX_CONSTEXPR unsigned TYPE \
1567 max() _GLIBCXX_USE_NOEXCEPT \
1568 { return __glibcxx_max_b (unsigned TYPE, BITSIZE); } \
1572 static _GLIBCXX_USE_CONSTEXPR int digits \
1574 static _GLIBCXX_USE_CONSTEXPR int digits10 \
1575 = BITSIZE * 643L / 2136; \
1576 static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; \
1577 static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; \
1578 static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; \
1579 static _GLIBCXX_USE_CONSTEXPR int radix = 2; \
1581 static _GLIBCXX_CONSTEXPR unsigned TYPE \
1582 epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1584 static _GLIBCXX_CONSTEXPR unsigned TYPE \
1585 round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } \
1587 static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; \
1588 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; \
1589 static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; \
1590 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; \
1592 static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; \
1593 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; \
1594 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; \
1595 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm \
1597 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; \
1599 static _GLIBCXX_CONSTEXPR unsigned TYPE \
1600 infinity() _GLIBCXX_USE_NOEXCEPT \
1601 { return static_cast<unsigned TYPE>(0); } \
1603 static _GLIBCXX_CONSTEXPR unsigned TYPE \
1604 quiet_NaN() _GLIBCXX_USE_NOEXCEPT \
1605 { return static_cast<unsigned TYPE>(0); } \
1607 static _GLIBCXX_CONSTEXPR unsigned TYPE \
1608 signaling_NaN() _GLIBCXX_USE_NOEXCEPT \
1609 { return static_cast<unsigned TYPE>(0); } \
1611 static _GLIBCXX_CONSTEXPR unsigned TYPE \
1612 denorm_min() _GLIBCXX_USE_NOEXCEPT \
1613 { return static_cast<unsigned TYPE>(0); } \
1615 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; \
1616 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; \
1617 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; \
1619 static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; \
1620 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; \
1621 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style \
1622 = round_toward_zero; \
1625#if __cplusplus >= 201103L
1627#define __INT_N_201103(TYPE) \
1628 static constexpr TYPE \
1629 lowest() noexcept { return min(); } \
1630 static constexpr int max_digits10 = 0;
1632#define __INT_N_U201103(TYPE) \
1633 static constexpr unsigned TYPE \
1634 lowest() noexcept { return min(); } \
1635 static constexpr int max_digits10 = 0;
1638#define __INT_N_201103(TYPE)
1639#define __INT_N_U201103(TYPE)
1642#if !defined(__STRICT_ANSI__)
1643#ifdef __GLIBCXX_TYPE_INT_N_0
1644 __INT_N(__GLIBCXX_TYPE_INT_N_0, __GLIBCXX_BITSIZE_INT_N_0,
1645 __INT_N_201103 (__GLIBCXX_TYPE_INT_N_0),
1646 __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_0))
1648#ifdef __GLIBCXX_TYPE_INT_N_1
1649 __INT_N (__GLIBCXX_TYPE_INT_N_1, __GLIBCXX_BITSIZE_INT_N_1,
1650 __INT_N_201103 (__GLIBCXX_TYPE_INT_N_1),
1651 __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_1))
1653#ifdef __GLIBCXX_TYPE_INT_N_2
1654 __INT_N (__GLIBCXX_TYPE_INT_N_2, __GLIBCXX_BITSIZE_INT_N_2,
1655 __INT_N_201103 (__GLIBCXX_TYPE_INT_N_2),
1656 __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_2))
1658#ifdef __GLIBCXX_TYPE_INT_N_3
1659 __INT_N (__GLIBCXX_TYPE_INT_N_3, __GLIBCXX_BITSIZE_INT_N_3,
1660 __INT_N_201103 (__GLIBCXX_TYPE_INT_N_3),
1661 __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_3))
1664#elif defined __STRICT_ANSI__ && defined __SIZEOF_INT128__
1665 __INT_N(__int128, 128,
1666 __INT_N_201103 (__int128),
1667 __INT_N_U201103 (__int128))
1671#undef __INT_N_201103
1672#undef __INT_N_U201103
1679 static _GLIBCXX_USE_CONSTEXPR
bool is_specialized =
true;
1681 static _GLIBCXX_CONSTEXPR
float
1682 min() _GLIBCXX_USE_NOEXCEPT {
return __FLT_MIN__; }
1684 static _GLIBCXX_CONSTEXPR
float
1685 max() _GLIBCXX_USE_NOEXCEPT {
return __FLT_MAX__; }
1687#if __cplusplus >= 201103L
1688 static constexpr float
1689 lowest()
noexcept {
return -__FLT_MAX__; }
1692 static _GLIBCXX_USE_CONSTEXPR
int digits = __FLT_MANT_DIG__;
1693 static _GLIBCXX_USE_CONSTEXPR
int digits10 = __FLT_DIG__;
1694#if __cplusplus >= 201103L
1695 static constexpr int max_digits10
1696 = __glibcxx_max_digits10 (__FLT_MANT_DIG__);
1698 static _GLIBCXX_USE_CONSTEXPR
bool is_signed =
true;
1699 static _GLIBCXX_USE_CONSTEXPR
bool is_integer =
false;
1700 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
false;
1701 static _GLIBCXX_USE_CONSTEXPR
int radix = __FLT_RADIX__;
1703 static _GLIBCXX_CONSTEXPR
float
1704 epsilon() _GLIBCXX_USE_NOEXCEPT {
return __FLT_EPSILON__; }
1706 static _GLIBCXX_CONSTEXPR
float
1707 round_error() _GLIBCXX_USE_NOEXCEPT {
return 0.5F; }
1709 static _GLIBCXX_USE_CONSTEXPR
int min_exponent = __FLT_MIN_EXP__;
1710 static _GLIBCXX_USE_CONSTEXPR
int min_exponent10 = __FLT_MIN_10_EXP__;
1711 static _GLIBCXX_USE_CONSTEXPR
int max_exponent = __FLT_MAX_EXP__;
1712 static _GLIBCXX_USE_CONSTEXPR
int max_exponent10 = __FLT_MAX_10_EXP__;
1714 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity = __FLT_HAS_INFINITY__;
1715 static _GLIBCXX_USE_CONSTEXPR
bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__;
1716 static _GLIBCXX_USE_CONSTEXPR
bool has_signaling_NaN = has_quiet_NaN;
1719 static _GLIBCXX_USE_CONSTEXPR
bool has_denorm_loss
1720 = __glibcxx_float_has_denorm_loss;
1722 static _GLIBCXX_CONSTEXPR
float
1723 infinity() _GLIBCXX_USE_NOEXCEPT {
return __builtin_huge_valf(); }
1725 static _GLIBCXX_CONSTEXPR
float
1726 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return __builtin_nanf(
""); }
1728 static _GLIBCXX_CONSTEXPR
float
1729 signaling_NaN() _GLIBCXX_USE_NOEXCEPT {
return __builtin_nansf(
""); }
1731 static _GLIBCXX_CONSTEXPR
float
1732 denorm_min() _GLIBCXX_USE_NOEXCEPT {
return __FLT_DENORM_MIN__; }
1734 static _GLIBCXX_USE_CONSTEXPR
bool is_iec559
1736 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
1737 static _GLIBCXX_USE_CONSTEXPR
bool is_modulo =
false;
1739 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_float_traps;
1740 static _GLIBCXX_USE_CONSTEXPR
bool tinyness_before
1741 = __glibcxx_float_tinyness_before;
1746#undef __glibcxx_float_has_denorm_loss
1747#undef __glibcxx_float_traps
1748#undef __glibcxx_float_tinyness_before
1754 static _GLIBCXX_USE_CONSTEXPR
bool is_specialized =
true;
1756 static _GLIBCXX_CONSTEXPR
double
1757 min() _GLIBCXX_USE_NOEXCEPT {
return __DBL_MIN__; }
1759 static _GLIBCXX_CONSTEXPR
double
1760 max() _GLIBCXX_USE_NOEXCEPT {
return __DBL_MAX__; }
1762#if __cplusplus >= 201103L
1763 static constexpr double
1764 lowest()
noexcept {
return -__DBL_MAX__; }
1767 static _GLIBCXX_USE_CONSTEXPR
int digits = __DBL_MANT_DIG__;
1768 static _GLIBCXX_USE_CONSTEXPR
int digits10 = __DBL_DIG__;
1769#if __cplusplus >= 201103L
1770 static constexpr int max_digits10
1771 = __glibcxx_max_digits10 (__DBL_MANT_DIG__);
1773 static _GLIBCXX_USE_CONSTEXPR
bool is_signed =
true;
1774 static _GLIBCXX_USE_CONSTEXPR
bool is_integer =
false;
1775 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
false;
1776 static _GLIBCXX_USE_CONSTEXPR
int radix = __FLT_RADIX__;
1778 static _GLIBCXX_CONSTEXPR
double
1779 epsilon() _GLIBCXX_USE_NOEXCEPT {
return __DBL_EPSILON__; }
1781 static _GLIBCXX_CONSTEXPR
double
1782 round_error() _GLIBCXX_USE_NOEXCEPT {
return 0.5; }
1784 static _GLIBCXX_USE_CONSTEXPR
int min_exponent = __DBL_MIN_EXP__;
1785 static _GLIBCXX_USE_CONSTEXPR
int min_exponent10 = __DBL_MIN_10_EXP__;
1786 static _GLIBCXX_USE_CONSTEXPR
int max_exponent = __DBL_MAX_EXP__;
1787 static _GLIBCXX_USE_CONSTEXPR
int max_exponent10 = __DBL_MAX_10_EXP__;
1789 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity = __DBL_HAS_INFINITY__;
1790 static _GLIBCXX_USE_CONSTEXPR
bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__;
1791 static _GLIBCXX_USE_CONSTEXPR
bool has_signaling_NaN = has_quiet_NaN;
1794 static _GLIBCXX_USE_CONSTEXPR
bool has_denorm_loss
1795 = __glibcxx_double_has_denorm_loss;
1797 static _GLIBCXX_CONSTEXPR
double
1798 infinity() _GLIBCXX_USE_NOEXCEPT {
return __builtin_huge_val(); }
1800 static _GLIBCXX_CONSTEXPR
double
1801 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return __builtin_nan(
""); }
1803 static _GLIBCXX_CONSTEXPR
double
1804 signaling_NaN() _GLIBCXX_USE_NOEXCEPT {
return __builtin_nans(
""); }
1806 static _GLIBCXX_CONSTEXPR
double
1807 denorm_min() _GLIBCXX_USE_NOEXCEPT {
return __DBL_DENORM_MIN__; }
1809 static _GLIBCXX_USE_CONSTEXPR
bool is_iec559
1811 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
1812 static _GLIBCXX_USE_CONSTEXPR
bool is_modulo =
false;
1814 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_double_traps;
1815 static _GLIBCXX_USE_CONSTEXPR
bool tinyness_before
1816 = __glibcxx_double_tinyness_before;
1821#undef __glibcxx_double_has_denorm_loss
1822#undef __glibcxx_double_traps
1823#undef __glibcxx_double_tinyness_before
1829 static _GLIBCXX_USE_CONSTEXPR
bool is_specialized =
true;
1831 static _GLIBCXX_CONSTEXPR
long double
1832 min() _GLIBCXX_USE_NOEXCEPT {
return __LDBL_MIN__; }
1834 static _GLIBCXX_CONSTEXPR
long double
1835 max() _GLIBCXX_USE_NOEXCEPT {
return __LDBL_MAX__; }
1837#if __cplusplus >= 201103L
1838 static constexpr long double
1839 lowest()
noexcept {
return -__LDBL_MAX__; }
1842 static _GLIBCXX_USE_CONSTEXPR
int digits = __LDBL_MANT_DIG__;
1843 static _GLIBCXX_USE_CONSTEXPR
int digits10 = __LDBL_DIG__;
1844#if __cplusplus >= 201103L
1845 static _GLIBCXX_USE_CONSTEXPR
int max_digits10
1846 = __glibcxx_max_digits10 (__LDBL_MANT_DIG__);
1848 static _GLIBCXX_USE_CONSTEXPR
bool is_signed =
true;
1849 static _GLIBCXX_USE_CONSTEXPR
bool is_integer =
false;
1850 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
false;
1851 static _GLIBCXX_USE_CONSTEXPR
int radix = __FLT_RADIX__;
1853 static _GLIBCXX_CONSTEXPR
long double
1854 epsilon() _GLIBCXX_USE_NOEXCEPT {
return __LDBL_EPSILON__; }
1856 static _GLIBCXX_CONSTEXPR
long double
1857 round_error() _GLIBCXX_USE_NOEXCEPT {
return 0.5L; }
1859 static _GLIBCXX_USE_CONSTEXPR
int min_exponent = __LDBL_MIN_EXP__;
1860 static _GLIBCXX_USE_CONSTEXPR
int min_exponent10 = __LDBL_MIN_10_EXP__;
1861 static _GLIBCXX_USE_CONSTEXPR
int max_exponent = __LDBL_MAX_EXP__;
1862 static _GLIBCXX_USE_CONSTEXPR
int max_exponent10 = __LDBL_MAX_10_EXP__;
1864 static _GLIBCXX_USE_CONSTEXPR
bool has_infinity = __LDBL_HAS_INFINITY__;
1865 static _GLIBCXX_USE_CONSTEXPR
bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__;
1866 static _GLIBCXX_USE_CONSTEXPR
bool has_signaling_NaN = has_quiet_NaN;
1869 static _GLIBCXX_USE_CONSTEXPR
bool has_denorm_loss
1870 = __glibcxx_long_double_has_denorm_loss;
1872 static _GLIBCXX_CONSTEXPR
long double
1873 infinity() _GLIBCXX_USE_NOEXCEPT {
return __builtin_huge_vall(); }
1875 static _GLIBCXX_CONSTEXPR
long double
1876 quiet_NaN() _GLIBCXX_USE_NOEXCEPT {
return __builtin_nanl(
""); }
1878 static _GLIBCXX_CONSTEXPR
long double
1879 signaling_NaN() _GLIBCXX_USE_NOEXCEPT {
return __builtin_nansl(
""); }
1881 static _GLIBCXX_CONSTEXPR
long double
1882 denorm_min() _GLIBCXX_USE_NOEXCEPT {
return __LDBL_DENORM_MIN__; }
1884 static _GLIBCXX_USE_CONSTEXPR
bool is_iec559
1886 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
1887 static _GLIBCXX_USE_CONSTEXPR
bool is_modulo =
false;
1889 static _GLIBCXX_USE_CONSTEXPR
bool traps = __glibcxx_long_double_traps;
1890 static _GLIBCXX_USE_CONSTEXPR
bool tinyness_before =
1891 __glibcxx_long_double_tinyness_before;
1896#undef __glibcxx_long_double_has_denorm_loss
1897#undef __glibcxx_long_double_traps
1898#undef __glibcxx_long_double_tinyness_before
1900#define __glibcxx_concat3_(P,M,S) P ## M ## S
1901#define __glibcxx_concat3(P,M,S) __glibcxx_concat3_ (P,M,S)
1903#if __cplusplus >= 201103L
1904# define __max_digits10 max_digits10
1907#define __glibcxx_float_n(BITSIZE) \
1910 struct numeric_limits<_Float##BITSIZE> \
1912 static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; \
1914 static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1915 min() _GLIBCXX_USE_NOEXCEPT \
1916 { return __glibcxx_concat3 (__FLT, BITSIZE, _MIN__); } \
1918 static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1919 max() _GLIBCXX_USE_NOEXCEPT \
1920 { return __glibcxx_concat3 (__FLT, BITSIZE, _MAX__); } \
1922 static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1923 lowest() _GLIBCXX_USE_NOEXCEPT \
1924 { return -__glibcxx_concat3 (__FLT, BITSIZE, _MAX__); } \
1926 static _GLIBCXX_USE_CONSTEXPR int digits \
1927 = __glibcxx_concat3 (__FLT, BITSIZE, _MANT_DIG__); \
1928 static _GLIBCXX_USE_CONSTEXPR int digits10 \
1929 = __glibcxx_concat3 (__FLT, BITSIZE, _DIG__); \
1930 static _GLIBCXX_USE_CONSTEXPR int __max_digits10 \
1931 = __glibcxx_max_digits10 (__glibcxx_concat3 (__FLT, BITSIZE, \
1933 static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; \
1934 static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; \
1935 static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; \
1936 static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; \
1938 static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1939 epsilon() _GLIBCXX_USE_NOEXCEPT \
1940 { return __glibcxx_concat3 (__FLT, BITSIZE, _EPSILON__); } \
1942 static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1943 round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5F##BITSIZE; } \
1945 static _GLIBCXX_USE_CONSTEXPR int min_exponent \
1946 = __glibcxx_concat3 (__FLT, BITSIZE, _MIN_EXP__); \
1947 static _GLIBCXX_USE_CONSTEXPR int min_exponent10 \
1948 = __glibcxx_concat3 (__FLT, BITSIZE, _MIN_10_EXP__); \
1949 static _GLIBCXX_USE_CONSTEXPR int max_exponent \
1950 = __glibcxx_concat3 (__FLT, BITSIZE, _MAX_EXP__); \
1951 static _GLIBCXX_USE_CONSTEXPR int max_exponent10 \
1952 = __glibcxx_concat3 (__FLT, BITSIZE, _MAX_10_EXP__); \
1954 static _GLIBCXX_USE_CONSTEXPR bool has_infinity \
1955 = __glibcxx_concat3 (__FLT, BITSIZE, _HAS_INFINITY__); \
1956 static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN \
1957 = __glibcxx_concat3 (__FLT, BITSIZE, _HAS_QUIET_NAN__); \
1958 static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN \
1960 static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm \
1961 = bool(__glibcxx_concat3 (__FLT, BITSIZE, _HAS_DENORM__)) \
1962 ? denorm_present : denorm_absent; \
1963 static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; \
1965 static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1966 infinity() _GLIBCXX_USE_NOEXCEPT \
1967 { return __builtin_huge_valf##BITSIZE(); } \
1969 static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1970 quiet_NaN() _GLIBCXX_USE_NOEXCEPT \
1971 { return __builtin_nanf##BITSIZE(""); } \
1973 static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1974 signaling_NaN() _GLIBCXX_USE_NOEXCEPT \
1975 { return __builtin_nansf##BITSIZE(""); } \
1977 static _GLIBCXX_CONSTEXPR _Float##BITSIZE \
1978 denorm_min() _GLIBCXX_USE_NOEXCEPT \
1979 { return __glibcxx_concat3 (__FLT, BITSIZE, _DENORM_MIN__); } \
1981 static _GLIBCXX_USE_CONSTEXPR bool is_iec559 \
1982 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;\
1983 static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; \
1984 static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; \
1986 static _GLIBCXX_USE_CONSTEXPR bool traps = false; \
1987 static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; \
1988 static _GLIBCXX_USE_CONSTEXPR float_round_style round_style \
1989 = round_to_nearest; \
1992#ifdef __STDCPP_FLOAT16_T__
1993__glibcxx_float_n(16)
1996__glibcxx_float_n(32)
1999__glibcxx_float_n(64)
2001#ifdef __FLT128_DIG__
2002__glibcxx_float_n(128)
2004#undef __glibcxx_float_n
2005#undef __glibcxx_concat3
2006#undef __glibcxx_concat3_
2008#if __cplusplus >= 201103L
2009# undef __max_digits10
2012#ifdef __STDCPP_BFLOAT16_T__
2019 static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2020 min() _GLIBCXX_USE_NOEXCEPT
2021 {
return __BFLT16_MIN__; }
2023 static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2024 max() _GLIBCXX_USE_NOEXCEPT
2025 {
return __BFLT16_MAX__; }
2027 static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2028 lowest() _GLIBCXX_USE_NOEXCEPT
2029 {
return -__BFLT16_MAX__; }
2031 static _GLIBCXX_USE_CONSTEXPR
int digits = __BFLT16_MANT_DIG__;
2032 static _GLIBCXX_USE_CONSTEXPR
int digits10 = __BFLT16_DIG__;
2033#if __cplusplus >= 201103L
2035 = __glibcxx_max_digits10 (__BFLT16_MANT_DIG__);
2037 static _GLIBCXX_USE_CONSTEXPR
bool is_signed =
true;
2038 static _GLIBCXX_USE_CONSTEXPR
bool is_integer =
false;
2039 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
false;
2040 static _GLIBCXX_USE_CONSTEXPR
int radix = __FLT_RADIX__;
2042 static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2043 epsilon() _GLIBCXX_USE_NOEXCEPT
2044 {
return __BFLT16_EPSILON__; }
2046 static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2047 round_error() _GLIBCXX_USE_NOEXCEPT {
return 0.5BF16; }
2049 static _GLIBCXX_USE_CONSTEXPR
int min_exponent = __BFLT16_MIN_EXP__;
2050 static _GLIBCXX_USE_CONSTEXPR
int min_exponent10 = __BFLT16_MIN_10_EXP__;
2051 static _GLIBCXX_USE_CONSTEXPR
int max_exponent = __BFLT16_MAX_EXP__;
2052 static _GLIBCXX_USE_CONSTEXPR
int max_exponent10 = __BFLT16_MAX_10_EXP__;
2055 = __BFLT16_HAS_INFINITY__;
2057 = __BFLT16_HAS_QUIET_NAN__;
2063 static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2065 {
return __gnu_cxx::__bfloat16_t(__builtin_huge_valf()); }
2067 static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2069 {
return __gnu_cxx::__bfloat16_t(__builtin_nanf(
"")); }
2071 static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2073 {
return __builtin_nansf16b(
""); }
2075 static _GLIBCXX_CONSTEXPR __gnu_cxx::__bfloat16_t
2077 {
return __BFLT16_DENORM_MIN__; }
2079 static _GLIBCXX_USE_CONSTEXPR
bool is_iec559
2081 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
2082 static _GLIBCXX_USE_CONSTEXPR
bool is_modulo =
false;
2084 static _GLIBCXX_USE_CONSTEXPR
bool traps =
false;
2091#if defined(_GLIBCXX_USE_FLOAT128)
2093#if ! defined(__STRICT_ANSI__) || defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
2100 static _GLIBCXX_CONSTEXPR __float128
2101 min() _GLIBCXX_USE_NOEXCEPT
2103#ifdef __STRICT_ANSI__
2105 return double(9.3132257461547852e-10) * _S_1pm16352();
2107 return __extension__ 0x1.0p-16382Q;
2111 static _GLIBCXX_CONSTEXPR __float128
2112 max() _GLIBCXX_USE_NOEXCEPT
2114#ifdef __STRICT_ANSI__
2117 return (__float128(
double(3.4028236692093843e+38))
2118 +
double(3.7778931862957153e+22) +
double(8.35584e+6))
2121 return __extension__ 0x1.ffffffffffffffffffffffffffffp+16383Q;
2125 static _GLIBCXX_CONSTEXPR __float128
2126 lowest() _GLIBCXX_USE_NOEXCEPT
2129 static _GLIBCXX_USE_CONSTEXPR
int digits = 113;
2130 static _GLIBCXX_USE_CONSTEXPR
int digits10 = 33;
2131#if __cplusplus >= 201103L
2134 static _GLIBCXX_USE_CONSTEXPR
bool is_signed =
true;
2135 static _GLIBCXX_USE_CONSTEXPR
bool is_integer =
false;
2136 static _GLIBCXX_USE_CONSTEXPR
bool is_exact =
false;
2137 static _GLIBCXX_USE_CONSTEXPR
int radix = __FLT_RADIX__;
2139 static _GLIBCXX_CONSTEXPR __float128
2140 epsilon() _GLIBCXX_USE_NOEXCEPT
2141 {
return double(1.9259299443872359e-34); }
2143 static _GLIBCXX_CONSTEXPR __float128
2144 round_error() _GLIBCXX_USE_NOEXCEPT {
return 0.5; }
2146 static _GLIBCXX_USE_CONSTEXPR
int min_exponent = -16381;
2148 static _GLIBCXX_USE_CONSTEXPR
int max_exponent = 16384;
2153#if __has_builtin(__builtin_nansq) \
2154 || (__has_builtin(__builtin_bit_cast) && __has_builtin(__builtin_nansf128))
2163 static _GLIBCXX_CONSTEXPR __float128
2165 {
return __builtin_huge_val(); }
2167 static _GLIBCXX_CONSTEXPR __float128
2169 {
return __builtin_nan(
""); }
2171 static _GLIBCXX_CONSTEXPR __float128
2174#if __has_builtin(__builtin_nansq)
2175 return __builtin_nansq(
"");
2176#elif __has_builtin(__builtin_bit_cast) && __has_builtin(__builtin_nansf128)
2177 return __builtin_bit_cast(__float128, __builtin_nansf128(
""));
2183 static _GLIBCXX_CONSTEXPR __float128
2186#if defined(__STRICT_ANSI__) || defined(__INTEL_COMPILER)
2188 return double(1.7936620343357659e-43) * _S_1pm16352();
2190 return __extension__ 0x1.0p-16494Q;
2195 static _GLIBCXX_USE_CONSTEXPR
bool is_bounded =
true;
2196 static _GLIBCXX_USE_CONSTEXPR
bool is_modulo =
false;
2198 static _GLIBCXX_USE_CONSTEXPR
bool traps =
false;
2203#if defined(__STRICT_ANSI__) || defined(__INTEL_COMPILER)
2205 static _GLIBCXX_CONSTEXPR __float128
2206 _S_4p(__float128 __v) _GLIBCXX_USE_NOEXCEPT
2207 {
return __v * __v * __v * __v; }
2209 static _GLIBCXX_CONSTEXPR __float128
2210 _S_1pm4088() _GLIBCXX_USE_NOEXCEPT
2211 {
return _S_4p(
double(2.2250738585072014e-308)); }
2213 static _GLIBCXX_CONSTEXPR __float128
2214 _S_1pm16352() _GLIBCXX_USE_NOEXCEPT
2215 {
return _S_4p(_S_1pm4088()); }
2217 static _GLIBCXX_CONSTEXPR __float128
2218 _S_1p4064() _GLIBCXX_USE_NOEXCEPT
2219 {
return _S_4p(
double(7.0222388080559215e+305)); }
2221 static _GLIBCXX_CONSTEXPR __float128
2222 _S_1p16256() _GLIBCXX_USE_NOEXCEPT
2223 {
return _S_4p(_S_1p4064()); }
2229_GLIBCXX_END_NAMESPACE_VERSION
2232#undef __glibcxx_signed
2235#undef __glibcxx_digits
2236#undef __glibcxx_digits10
2237#undef __glibcxx_max_digits10
2239#pragma GCC diagnostic pop
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