std::__numeric_limits_base - Part of std::numeric_limits.

       Generated automatically by Doxygen for libstdc++ from the source code.

                                                    libstdc++                   std::__numeric_limits_base(3cxx)

       Part of std::numeric_limits.

       The static const members are usable as integral constant expressions.

       Note
           This is a separate class for purposes of efficiency; you should only access these members as part of
           an instantiation of the std::numeric_limits class.

constexprintstd::__numeric_limits_base::digits[static],[constexpr]
       The number of radix digits that be represented without change: for integer types, the number of non-sign
       bits in the mantissa; for floating types, the number of radix digits in the mantissa.

   constexprintstd::__numeric_limits_base::digits10[static],[constexpr]
       The number of base 10 digits that can be represented without change.

   constexprfloat_denorm_stylestd::__numeric_limits_base::has_denorm[static],[constexpr]
       See std::float_denorm_style for more information.

   constexprboolstd::__numeric_limits_base::has_denorm_loss[static],[constexpr]
       True if loss of accuracy is detected as a denormalization loss, rather than as an inexact result.

   constexprboolstd::__numeric_limits_base::has_infinity[static],[constexpr]
       True if the type has a representation for positive infinity.

   constexprboolstd::__numeric_limits_base::has_quiet_NaN[static],[constexpr]
       True if the type has a representation for a quiet (non-signaling) Not a Number.

   constexprboolstd::__numeric_limits_base::has_signaling_NaN[static],[constexpr]
       True if the type has a representation for a signaling Not a Number.

   constexprboolstd::__numeric_limits_base::is_bounded[static],[constexpr]
       True if the set of values representable by the type is finite. All built-in types are bounded, this
       member would be false for arbitrary precision types.

   constexprboolstd::__numeric_limits_base::is_exact[static],[constexpr]
       True if the type uses an exact representation. All integer types are exact, but not all exact types are
       integer. For example, rational and fixed-exponent representations are exact but not integer.

   constexprboolstd::__numeric_limits_base::is_iec559[static],[constexpr]
       True if-and-only-if the type adheres to the IEC 559 standard, also known as IEEE 754. (Only makes sense
       for floating point types.)

   constexprboolstd::__numeric_limits_base::is_integer[static],[constexpr]
       True if the type is integer.

   constexprboolstd::__numeric_limits_base::is_modulo[static],[constexpr]
       True if the type is modulo. A type is modulo if, for any operation involving +, -, or * on values of that
       type whose result would fall outside the range [min(),max()], the value returned differs from the true
       value by an integer multiple of max() - min() + 1. On most machines, this is false for floating types,
       true for unsigned integers, and true for signed integers. See PR22200 about signed integers.

   constexprboolstd::__numeric_limits_base::is_signed[static],[constexpr]
       True if the type is signed.

   constexprboolstd::__numeric_limits_base::is_specialized[static],[constexpr]
       This will be true for all fundamental types (which have specializations), and false for everything else.

   constexprintstd::__numeric_limits_base::max_digits10[static],[constexpr]
       The number of base 10 digits required to ensure that values which differ are always differentiated.

   constexprintstd::__numeric_limits_base::max_exponent[static],[constexpr]
       The maximum positive integer such that radix raised to the power of (one less than that integer) is a
       representable finite floating point number.

   constexprintstd::__numeric_limits_base::max_exponent10[static],[constexpr]
       The maximum positive integer such that 10 raised to that power is in the range of representable finite
       floating point numbers.

   constexprintstd::__numeric_limits_base::min_exponent[static],[constexpr]
       The minimum negative integer such that radix raised to the power of (one less than that integer) is a
       normalized floating point number.

   constexprintstd::__numeric_limits_base::min_exponent10[static],[constexpr]
       The minimum negative integer such that 10 raised to that power is in the range of normalized floating
       point numbers.

   constexprintstd::__numeric_limits_base::radix[static],[constexpr]
       For integer types, specifies the base of the representation. For floating types, specifies the base of
       the exponent representation.

   constexprfloat_round_stylestd::__numeric_limits_base::round_style[static],[constexpr]
       See std::float_round_style for more information. This is only meaningful for floating types; integer
       types will all be round_toward_zero.

   constexprboolstd::__numeric_limits_base::tinyness_before[static],[constexpr]
       True if tininess is detected before rounding. (see IEC 559)

   constexprboolstd::__numeric_limits_base::traps[static],[constexpr]
       True if trapping is implemented for this type.

       std::__numeric_limits_base - Part of std::numeric_limits.

       #include <limits>

       Inherited by std::numeric_limits<_Tp>.

   StaticPublicAttributesstatic constexpr int digitsstatic constexpr int digits10static constexpr float_denorm_stylehas_denormstatic constexpr bool has_denorm_lossstatic constexpr bool has_infinitystatic constexpr bool has_quiet_NaNstatic constexpr bool has_signaling_NaNstatic constexpr bool is_boundedstatic constexpr bool is_exactstatic constexpr bool is_iec559static constexpr bool is_integerstatic constexpr bool is_modulostatic constexpr bool is_signedstatic constexpr bool is_specializedstatic constexpr int max_digits10static constexpr int max_exponentstatic constexpr int max_exponent10static constexpr int min_exponentstatic constexpr int min_exponent10static constexpr int radixstatic constexpr float_round_styleround_stylestatic constexpr bool tinyness_beforestatic constexpr bool traps