21 Language support library [language.support]

21.3 Implementation properties [support.limits]

21.3.4 Class template numeric_­limits [numeric.limits]

21.3.4.1 numeric_­limits members [numeric.limits.members]

1
#

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

static constexpr T min() noexcept;

2
#

Minimum finite value.188

3
#

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

4
#

Meaningful for all specializations in which is_­bounded != false, or is_­bounded == false && is_­signed == false.

static constexpr T max() noexcept;
5
#

Maximum finite value.189

6
#

Meaningful for all specializations in which is_­bounded != false.

static constexpr T lowest() noexcept;

7
#

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

8
#

Meaningful for all specializations in which is_­bounded != false.

static constexpr int digits;

9
#

Number of radix digits that can be represented without change.

10
#

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

11
#

For floating-point types, the number of radix digits in the mantissa.191

static constexpr int digits10;

12
#

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

13
#

Meaningful for all specializations in which is_­bounded != false.

static constexpr int max_digits10;

14
#

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

15
#

Meaningful for all floating-point types.

static constexpr bool is_signed;

16
#

true if the type is signed.

17
#

Meaningful for all specializations.

static constexpr bool is_integer;

18
#

true if the type is integer.

19
#

Meaningful for all specializations.

static constexpr bool is_exact;

20
#

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.

21
#

Meaningful for all specializations.

static constexpr int radix;

22
#

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

23
#

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

24
#

Meaningful for all specializations.

static constexpr T epsilon() noexcept;

25
#

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

26
#

Meaningful for all floating-point types.

static constexpr T round_error() noexcept;

27
#

Measure of the maximum rounding error.196

static constexpr int min_exponent;

28
#

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

29
#

Meaningful for all floating-point types.

static constexpr int min_exponent10;

30
#

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

31
#

Meaningful for all floating-point types.

static constexpr int max_exponent;

32
#

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

33
#

Meaningful for all floating-point types.

static constexpr int max_exponent10;

34
#

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

35
#

Meaningful for all floating-point types.

static constexpr bool has_infinity;

36
#

true if the type has a representation for positive infinity.

37
#

Meaningful for all floating-point types.

38
#

Shall be true for all specializations in which is_­iec559 != false.

static constexpr bool has_quiet_NaN;

39
#

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

40
#

Meaningful for all floating-point types.

41
#

Shall be true for all specializations in which is_­iec559 != false.

static constexpr bool has_signaling_NaN;

42
#

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

43
#

Meaningful for all floating-point types.

44
#

Shall be true for all specializations in which is_­iec559 != false.

static constexpr float_denorm_style has_denorm;

45
#

denorm_­present if the type allows subnormal values (variable number of exponent bits)203, denorm_­absent if the type does not allow subnormal values, and denorm_­indeterminate if it is indeterminate at compile time whether the type allows subnormal values.

46
#

Meaningful for all floating-point types.

static constexpr bool has_denorm_loss;

47
#

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

static constexpr T infinity() noexcept;

48
#

Representation of positive infinity, if available.205

49
#

Meaningful for all specializations for which has_­infinity != false. Required in specializations for which is_­iec559 != false.

static constexpr T quiet_NaN() noexcept;

50
#

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

51
#

Meaningful for all specializations for which has_­quiet_­NaN != false. Required in specializations for which is_­iec559 != false.

static constexpr T signaling_NaN() noexcept;

52
#

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

53
#

Meaningful for all specializations for which has_­signaling_­NaN != false. Required in specializations for which is_­iec559 != false.

static constexpr T denorm_min() noexcept;

54
#

Minimum positive subnormal value.208

55
#

Meaningful for all floating-point types.

56
#

In specializations for which has_­denorm == false, returns the minimum positive normalized value.

static constexpr bool is_iec559;

57
#

true if and only if the type adheres to ISO/IEC/IEEE 60559.209

58
#

Meaningful for all floating-point types.

static constexpr bool is_bounded;

59
#

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

60
#

Meaningful for all specializations.

static constexpr bool is_modulo;

61
#

true if the type is modulo.211 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.

62
#

[ Example: is_­modulo is false for signed integer types ([basic.fundamental]) unless an implementation, as an extension to this International Standard, defines signed integer overflow to wrap.  — end example ]

63
#

Meaningful for all specializations.

static constexpr bool traps;

64
#

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

65
#

Meaningful for all specializations.

static constexpr bool tinyness_before;

66
#

true if tinyness is detected before rounding.213

67
#

Meaningful for all floating-point types.

static constexpr float_round_style round_style;

68
#

The rounding style for the type.214

69
#

Meaningful for all floating-point types. Specializations for integer types shall return round_­toward_­zero.

188)

Equivalent to CHAR_­MIN, SHRT_­MIN, FLT_­MIN, DBL_­MIN, etc.

189)

Equivalent to CHAR_­MAX, SHRT_­MAX, FLT_­MAX, DBL_­MAX, etc.

190)

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.

191)

Equivalent to FLT_­MANT_­DIG, DBL_­MANT_­DIG, LDBL_­MANT_­DIG.

192)

Equivalent to FLT_­DIG, DBL_­DIG, LDBL_­DIG.

193)

Equivalent to FLT_­RADIX.

194)

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

195)

Equivalent to FLT_­EPSILON, DBL_­EPSILON, LDBL_­EPSILON.

196)

Rounding error is described in LIA-1 Section 5.2.4 and Annex C Rationale Section C.5.2.4 — Rounding and rounding constants.

197)

Equivalent to FLT_­MIN_­EXP, DBL_­MIN_­EXP, LDBL_­MIN_­EXP.

198)

Equivalent to FLT_­MIN_­10_­EXP, DBL_­MIN_­10_­EXP, LDBL_­MIN_­10_­EXP.

199)

Equivalent to FLT_­MAX_­EXP, DBL_­MAX_­EXP, LDBL_­MAX_­EXP.

200)

Equivalent to FLT_­MAX_­10_­EXP, DBL_­MAX_­10_­EXP, LDBL_­MAX_­10_­EXP.

201)

Required by LIA-1.

202)

Required by LIA-1.

203)

Required by LIA-1.

204)

See ISO/IEC/IEEE 60559.

205)

Required by LIA-1.

206)

Required by LIA-1.

207)

Required by LIA-1.

208)

Required by LIA-1.

209)

ISO/IEC/IEEE 60559:2011 is the same as IEEE 754-2008.

210)

Required by LIA-1.

211)

Required by LIA-1.

212)

Required by LIA-1.

213)

Refer to ISO/IEC/IEEE 60559. Required by LIA-1.

214)

Equivalent to FLT_­ROUNDS. Required by LIA-1.