17 Language support library [support]

17.3 Implementation properties [support.limits]

17.3.5 Class template numeric_limits [numeric.limits]

17.3.5.2 numeric_limits members [numeric.limits.members]

1
#
Each member function defined in this subclause is signal-safe ([support.signal]).
[Note 1: 
The arithmetic specification described in ISO/IEC 10967-1:2012 is commonly termed LIA-1.
— end note]
🔗
static constexpr T min() noexcept;
2
#
Minimum finite value.165
3
#
For floating-point 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.166
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.167
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 significand.168
🔗
static constexpr int digits10;
12
#
Number of base 10 digits that can be represented without change.169
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-point types, specifies the base or radix of the exponent representation (often 2).170
23
#
For integer types, specifies the base of the representation.171
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.172
26
#
Meaningful for all floating-point types.
🔗
static constexpr T round_error() noexcept;
27
#
Measure of the maximum rounding error.173
🔗
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.174
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.175
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.176
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.177
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”.178
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”.179
43
#
Meaningful for all floating-point types.
44
#
Shall be true for all specializations in which is_iec559 != false.
🔗
static constexpr T infinity() noexcept;
45
#
Representation of positive infinity, if available.180
46
#
Meaningful for all specializations for which has_infinity != false.
Required in specializations for which is_iec559 != false.
🔗
static constexpr T quiet_NaN() noexcept;
47
#
Representation of a quiet “Not a Number”, if available.181
48
#
Meaningful for all specializations for which has_quiet_NaN != false.
Required in specializations for which is_iec559 != false.
🔗
static constexpr T signaling_NaN() noexcept;
49
#
Representation of a signaling “Not a Number”, if available.182
50
#
Meaningful for all specializations for which has_signaling_NaN != false.
Required in specializations for which is_iec559 != false.
🔗
static constexpr T denorm_min() noexcept;
51
#
Minimum positive subnormal value, if available.183
Otherwise, minimum positive normalized value.
52
#
Meaningful for all floating-point types.
🔗
static constexpr bool is_iec559;
53
#
true if and only if the type adheres to ISO/IEC 60559.184
[Note 2: 
The value is true for any of the types float16_t, float32_t, float64_t, or float128_t, if present ([basic.extended.fp]).
— end note]
54
#
Meaningful for all floating-point types.
🔗
static constexpr bool is_bounded;
55
#
true if the set of values representable by the type is finite.185
[Note 3: 
All fundamental types ([basic.fundamental]) are bounded.
This member would be false for arbitrary precision types.
— end note]
56
#
Meaningful for all specializations.
🔗
static constexpr bool is_modulo;
57
#
true if the type is modulo.186
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.
58
#
[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]
59
#
Meaningful for all specializations.
🔗
static constexpr bool traps;
60
#
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.187
61
#
Meaningful for all specializations.
🔗
static constexpr bool tinyness_before;
62
#
true if tinyness is detected before rounding.188
63
#
Meaningful for all floating-point types.
🔗
static constexpr float_round_style round_style;
64
#
The rounding style for the type.189
65
#
Meaningful for all floating-point types.
Specializations for integer types shall return round_toward_zero.
165)165)
Equivalent to CHAR_MIN, SHRT_MIN, FLT_MIN, DBL_MIN, etc.
166)166)
Equivalent to CHAR_MAX, SHRT_MAX, FLT_MAX, DBL_MAX, etc.
167)167)
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.
168)168)
Equivalent to FLT_MANT_DIG, DBL_MANT_DIG, LDBL_MANT_DIG.
169)169)
Equivalent to FLT_DIG, DBL_DIG, LDBL_DIG.
170)170)
Equivalent to FLT_RADIX.
171)171)
Distinguishes types with bases other than 2 (e.g., BCD).
172)172)
Equivalent to FLT_EPSILON, DBL_EPSILON, LDBL_EPSILON.
173)173)
Rounding error is described in ISO/IEC 10967-1:2012 Section 5.2.4 and Annex C Rationale Section C.5.2.4 — Rounding and rounding constants.
174)174)
Equivalent to FLT_MIN_EXP, DBL_MIN_EXP, LDBL_MIN_EXP.
175)175)
Equivalent to FLT_MIN_10_EXP, DBL_MIN_10_EXP, LDBL_MIN_10_EXP.
176)176)
Equivalent to FLT_MAX_EXP, DBL_MAX_EXP, LDBL_MAX_EXP.
177)177)
Equivalent to FLT_MAX_10_EXP, DBL_MAX_10_EXP, LDBL_MAX_10_EXP.
178)178)
Required by ISO/IEC 10967-1:2012.
179)179)
Required by ISO/IEC 10967-1:2012.
180)180)
Required by ISO/IEC 10967-1:2012.
181)181)
Required by ISO/IEC 10967-1:2012.
182)182)
Required by ISO/IEC 10967-1:2012.
183)183)
Required by ISO/IEC 10967-1:2012.
184)184)
ISO/IEC 60559:2020 is the same as IEEE 754-2019.
185)185)
Required by ISO/IEC 10967-1:2012.
186)186)
Required by ISO/IEC 10967-1:2012.
187)187)
Required by ISO/IEC 10967-1:2012.
188)188)
Refer to ISO/IEC 60559.
Required by ISO/IEC 10967-1:2012.
189)189)
Equivalent to FLT_ROUNDS.
Required by ISO/IEC 10967-1:2012.