Each member function defined in this subclause is signal-safe ([support.signal]).

static constexpr T min() noexcept;

For floating-point types with subnormal numbers, returns the minimum positive normalized value.

Meaningful for all specializations in which is_bounded != false, or is_bounded == false && is_signed == false.

static constexpr T max() noexcept;

Meaningful for all specializations in which is_bounded != false.

static constexpr T lowest() noexcept;

A finite value x such that there is no other finite value y where y < x.155

Meaningful for all specializations in which is_bounded != false.

static constexpr int digits;

Number of radix digits that can be represented without change.

For integer types, the number of non-sign bits in the representation.

For floating-point types, the number of radix digits in the significand.156

static constexpr int digits10;

Number of base 10 digits that can be represented without change.157

Meaningful for all specializations in which is_bounded != false.

static constexpr int max_digits10;

Number of base 10 digits required to ensure that values which differ are always differentiated.

Meaningful for all floating-point types.

static constexpr bool is_signed;

true if the type is signed.

Meaningful for all specializations.

static constexpr bool is_integer;

true if the type is integer.

Meaningful for all specializations.

static constexpr bool is_exact;

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.

Meaningful for all specializations.

static constexpr int radix;

For floating-point types, specifies the base or radix of the exponent representation (often 2).158

For integer types, specifies the base of the representation.159

Meaningful for all specializations.

static constexpr T epsilon() noexcept;

Machine epsilon: the difference between 1 and the least value greater than 1 that is representable.160

Meaningful for all floating-point types.

static constexpr T round_error() noexcept;

Measure of the maximum rounding error.161

static constexpr int min_exponent;

Minimum negative integer such that radix raised to the power of one less than that integer is a normalized floating-point number.162

Meaningful for all floating-point types.

static constexpr int min_exponent10;

Minimum negative integer such that 10 raised to that power is in the range of normalized floating-point numbers.163

Meaningful for all floating-point types.

static constexpr int max_exponent;

Maximum positive integer such that radix raised to the power one less than that integer is a representable finite floating-point number.164

Meaningful for all floating-point types.

static constexpr int max_exponent10;

Maximum positive integer such that 10 raised to that power is in the range of representable finite floating-point numbers.165

Meaningful for all floating-point types.

static constexpr bool has_infinity;

true if the type has a representation for positive infinity.

Meaningful for all floating-point types.

Shall be true for all specializations in which is_iec559 != false.

static constexpr bool has_quiet_NaN;

true if the type has a representation for a quiet (non-signaling) “Not a Number”.166

Meaningful for all floating-point types.

Shall be true for all specializations in which is_iec559 != false.

static constexpr bool has_signaling_NaN;

true if the type has a representation for a signaling “Not a Number”.167

Meaningful for all floating-point types.

Shall be true for all specializations in which is_iec559 != false.

static constexpr T infinity() noexcept;

Representation of positive infinity, if available.168

Meaningful for all specializations for which has_infinity != false.

Required in specializations for which is_iec559 != false.

static constexpr T quiet_NaN() noexcept;

Representation of a quiet “Not a Number”, if available.169

Meaningful for all specializations for which has_quiet_NaN != false.

Required in specializations for which is_iec559 != false.

static constexpr T signaling_NaN() noexcept;

Representation of a signaling “Not a Number”, if available.170

Meaningful for all specializations for which has_signaling_NaN != false.

Required in specializations for which is_iec559 != false.

static constexpr T denorm_min() noexcept;

Minimum positive subnormal value, if available.171

Otherwise, minimum positive normalized value.

Meaningful for all floating-point types.

static constexpr bool is_iec559;

true if and only if the type adheres to ISO/IEC 60559.172

Meaningful for all floating-point types.

static constexpr bool is_bounded;

true if the set of values representable by the type is finite.173

Meaningful for all specializations.

static constexpr bool is_modulo;

true if the type is modulo.174

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.

[Example 1:

is_modulo is false for signed integer types ([basic.fundamental]) unless an implementation, as an extension to this document, defines signed integer overflow to wrap.

— end example]

Meaningful for all specializations.

static constexpr bool traps;

true if, at the start of the program, there exists a value of the type that would cause an arithmetic operation using that value to trap.175

Meaningful for all specializations.

static constexpr bool tinyness_before;

true if tinyness is detected before rounding.176

Meaningful for all floating-point types.

static constexpr float_round_style round_style;

The rounding style for the type.177

Meaningful for all floating-point types.

Specializations for integer types shall return round_toward_zero.