NAME

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

SYNOPSIS

       #include <limits>

       Inherited by std::numeric_limits< _Tp >.

   Static Public Attributes
       static constexpr int digits
       static constexpr int digits10
       static constexpr float_denorm_style has_denorm
       static constexpr bool has_denorm_loss
       static constexpr bool has_infinity
       static constexpr bool has_quiet_NaN
       static constexpr bool has_signaling_NaN
       static constexpr bool is_bounded
       static constexpr bool is_exact
       static constexpr bool is_iec559
       static constexpr bool is_integer
       static constexpr bool is_modulo
       static constexpr bool is_signed
       static constexpr bool is_specialized
       static constexpr int max_digits10
       static constexpr int max_exponent
       static constexpr int max_exponent10
       static constexpr int min_exponent
       static constexpr int min_exponent10
       static constexpr int radix
       static constexpr float_round_style round_style
       static constexpr bool tinyness_before
       static constexpr bool traps

Detailed Description

       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.

Member Data Documentation

   constexpr int std::__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.

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

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

   constexpr bool std::__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.

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

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

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

   constexpr bool std::__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.

   constexpr bool std::__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.

   constexpr bool std::__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.)

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

   constexpr bool std::__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.

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

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

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

   constexpr int std::__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.

   constexpr int std::__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.

   constexpr int std::__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.

   constexpr int std::__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.

   constexpr int std::__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.

   constexpr float_round_style std::__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.

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

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

Author

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

                                            libstdc++            std::__numeric_limits_base(3cxx)