[numeric.limits.members]

18.3.2.4 numeric_limits members [numeric.limits.members]

static constexpr T min() noexcept;

Minimum finite value.197

For floating types with denormalization, 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;

Maximum finite value.198

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.199

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 mantissa.200

static constexpr int digits10;

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

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 types, specifies the base or radix of the exponent representation (often 2).202

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

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.204

Meaningful for all floating point types.

static constexpr T round_error() noexcept;

Measure of the maximum rounding error.205

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.206

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.207

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.208

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.209

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.”210

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.”211

Meaningful for all floating point types.

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

static constexpr float_denorm_style has_denorm;

denorm_present if the type allows denormalized values (variable number of exponent bits)212, denorm_absent if the type does not allow denormalized values, and denorm_indeterminate if it is indeterminate at compile time whether the type allows denormalized values.

Meaningful for all floating point types.

static constexpr bool has_denorm_loss;

True if loss of accuracy is detected as a denormalization loss, rather than as an inexact result.213

static constexpr T infinity() noexcept;

Representation of positive infinity, if available.214

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.215

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.216

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 denormalized value.217

Meaningful for all floating point types.

In specializations for which has_denorm == false, returns the minimum positive normalized value.

static constexpr bool is_iec559;

True if and only if the type adheres to IEC 559 standard.218

Meaningful for all floating point types.

static constexpr bool is_bounded;

True if the set of values representable by the type is finite.219 [ Note: All fundamental types ([basic.fundamental]) are bounded. This member would be false for arbitrary precision types. — end note ]

Meaningful for all specializations.

static constexpr bool is_modulo;

True if the type is modulo.220 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.

Meaningful for all specializations.

static constexpr bool traps;

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

Meaningful for all specializations.

static constexpr bool tinyness_before;

true if tinyness is detected before rounding.222

Meaningful for all floating point types.

static constexpr float_round_style round_style;

The rounding style for the type.223

Meaningful for all floating point types. Specializations for integer types shall return round_toward_zero.

196)

Equivalent to CHAR_MIN, SHRT_MIN, FLT_MIN, DBL_MIN, etc.

197)

Equivalent to CHAR_MAX, SHRT_MAX, FLT_MAX, DBL_MAX, etc.

198)

lowest() is necessary because not all floating-point representations have a smallest (most negative) value that is the negative of the largest (most positive) finite value.

199)

Equivalent to FLT_MANT_DIG, DBL_MANT_DIG, LDBL_MANT_DIG.

200)

Equivalent to FLT_DIG, DBL_DIG, LDBL_DIG.

201)

Equivalent to FLT_RADIX.

202)

Distinguishes types with bases other than 2 (e.g. BCD).

203)

Equivalent to FLT_EPSILON, DBL_EPSILON, LDBL_EPSILON.

204)

Rounding error is described in ISO/IEC 10967-1 Language independent arithmetic - Part 1 Section 5.2.8 and Annex A Rationale Section A.5.2.8 - Rounding constants.

205)

Equivalent to FLT_MIN_EXP, DBL_MIN_EXP, LDBL_MIN_EXP.

206)

Equivalent to FLT_MIN_10_EXP, DBL_MIN_10_EXP, LDBL_MIN_10_EXP.

207)

Equivalent to FLT_MAX_EXP, DBL_MAX_EXP, LDBL_MAX_EXP.

208)

Equivalent to FLT_MAX_10_EXP, DBL_MAX_10_EXP, LDBL_MAX_10_EXP.

209)

Required by LIA-1.

210)

Required by LIA-1.