std::numeric_limits< _Tp > - Properties of fundamental types.

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

                                                    libstdc++                   std::numeric_limits<_Tp>(3cxx)

template<typename_Tp>
       struct std::numeric_limits< _Tp >"Properties of fundamental types.

       This class allows a program to obtain information about the representation of a fundamental type on a
       given platform. For non-fundamental types, the functions will return 0 and the data members will all be
       false.

constexprintstd::__numeric_limits_base::digits[static],[constexpr],[inherited]
       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],[inherited]
       The number of base 10 digits that can be represented without change.

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

   constexprboolstd::__numeric_limits_base::has_denorm_loss[static],[constexpr],[inherited]
       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],[inherited]
       True if the type has a representation for positive infinity.

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

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

   constexprboolstd::__numeric_limits_base::is_bounded[static],[constexpr],[inherited]
       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],[inherited]
       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],[inherited]
       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],[inherited]
       True if the type is integer.

   constexprboolstd::__numeric_limits_base::is_modulo[static],[constexpr],[inherited]
       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],[inherited]
       True if the type is signed.

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

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

   constexprintstd::__numeric_limits_base::max_exponent[static],[constexpr],[inherited]
       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],[inherited]
       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],[inherited]
       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],[inherited]
       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],[inherited]
       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],[inherited]
       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],[inherited]
       True if tininess is detected before rounding. (see IEC 559)

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

template<typename_Tp>staticconstexpr_Tpstd::numeric_limits<_Tp>::denorm_min()[inline],[static],[constexpr],[noexcept]
       The minimum positive denormalized value. For types where has_denorm is false, this is the minimum
       positive normalized value.

   template<typename_Tp>staticconstexpr_Tpstd::numeric_limits<_Tp>::epsilon()[inline],[static],[constexpr],[noexcept]
       The machineepsilon: the difference between 1 and the least value greater than 1 that is representable.

       Referenced by std::generate_canonical(), std::binomial_distribution<_IntType>::operator()(),
       std::poisson_distribution<_IntType>::operator()(), and std::operator<<().

   template<typename_Tp>staticconstexpr_Tpstd::numeric_limits<_Tp>::infinity()[inline],[static],[constexpr],[noexcept]
       The representation of positive infinity, if has_infinity.

   template<typename_Tp>staticconstexpr_Tpstd::numeric_limits<_Tp>::lowest()[inline],[static],[constexpr],[noexcept]
       A finite value x such that there is no other finite value y where y < x.

       Referenced by std::normal_distribution<_RealType>::min(), std::cauchy_distribution<_RealType>::min(),
       std::student_t_distribution<_RealType>::min(), and std::extreme_value_distribution<_RealType>::min().

   template<typename_Tp>staticconstexpr_Tpstd::numeric_limits<_Tp>::max()[inline],[static],[constexpr],[noexcept]
       The maximum finite value.

       Referenced by std::normal_distribution<_RealType>::max(), std::lognormal_distribution<_RealType>::max(), std::gamma_distribution<_RealType>::max(), std::chi_squared_distribution<_RealType>::max(),
       std::cauchy_distribution<_RealType>::max(), std::fisher_f_distribution<_RealType>::max(),
       std::student_t_distribution<_RealType>::max(), std::bernoulli_distribution::max(),
       std::geometric_distribution<_IntType>::max(), std::negative_binomial_distribution<_IntType>::max(),
       std::poisson_distribution<_IntType>::max(), std::exponential_distribution<_RealType>::max(),
       std::weibull_distribution<_RealType>::max(), std::extreme_value_distribution<_RealType>::max(),
       std::independent_bits_engine<_RandomNumberEngine,__w,_UIntType>::operator()(),
       std::binomial_distribution<_IntType>::operator()(), std::poisson_distribution<_IntType>::operator()(), and std::operator<<().

   template<typename_Tp>staticconstexpr_Tpstd::numeric_limits<_Tp>::min()[inline],[static],[constexpr],[noexcept]
       The minimum finite value, or for floating types with denormalization, the minimum positive normalized
       value.

       Referenced by std::bernoulli_distribution::min().

   template<typename_Tp>staticconstexpr_Tpstd::numeric_limits<_Tp>::quiet_NaN()[inline],[static],[constexpr],[noexcept]
       The representation of a quiet Not a Number, if has_quiet_NaN.

   template<typename_Tp>staticconstexpr_Tpstd::numeric_limits<_Tp>::round_error()[inline],[static],[constexpr],[noexcept]
       The maximum rounding error measurement (see LIA-1).

   template<typename_Tp>staticconstexpr_Tpstd::numeric_limits<_Tp>::signaling_NaN()[inline],[static],[constexpr],[noexcept]
       The representation of a signaling Not a Number, if has_signaling_NaN.

       std::numeric_limits< _Tp > - Properties of fundamental types.

       #include <limits>

       Inherits std::__numeric_limits_base.

       Inherited by std::numeric_limits< const _Tp >, std::numeric_limits< const volatile _Tp >, and
       std::numeric_limits< volatile _Tp >.

   StaticPublicMemberFunctionsstatic constexpr _Tp denorm_min () noexcept
       static constexpr _Tp epsilon () noexcept
       static constexpr _Tp infinity () noexcept
       static constexpr _Tp lowest () noexcept
       static constexpr _Tp max () noexcept
       static constexpr _Tp min () noexcept
       static constexpr _Tp quiet_NaN () noexcept
       static constexpr _Tp round_error () noexcept
       static constexpr _Tp signaling_NaN () noexcept

   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