cppdraft_translate/cppdraft/numeric/limits.md

[numeric.limits]

17 Language support library [support]

17.3 Implementation properties [support.limits]

17.3.5 Class template numeric_limits [numeric.limits]

17.3.5.1 General [numeric.limits.general]

1

#

Thenumeric_limits class template provides a C++ program with information about various properties of the implementation's representation of the arithmetic types.

🔗

namespace std {template class numeric_limits {public:static constexpr bool is_specialized = false; static constexpr T min() noexcept { return T(); }static constexpr T max() noexcept { return T(); }static constexpr T lowest() noexcept { return T(); }static constexpr int digits = 0; static constexpr int digits10 = 0; static constexpr int max_digits10 = 0; static constexpr bool is_signed = false; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 0; static constexpr T epsilon() noexcept { return T(); }static constexpr T round_error() noexcept { return T(); }static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr T infinity() noexcept { return T(); }static constexpr T quiet_NaN() noexcept { return T(); }static constexpr T signaling_NaN() noexcept { return T(); }static constexpr T denorm_min() noexcept { return T(); }static constexpr bool is_iec559 = false; static constexpr bool is_bounded = false; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; };}

2

#

For all members declaredstatic constexpr in thenumeric_limits template, specializations shall define these values in such a way that they are usable as constant expressions.

3

#

For thenumeric_limits primary template, all data members are value-initialized and all member functions return a value-initialized object.

[Note 1:

This means all members have zero or false values unless numeric_limits is specialized for a type.

— end note]

4

#

Specializations shall be provided for each arithmetic type, both floating-point and integer, includingbool.

The memberis_specialized shall betrue for all such specializations ofnumeric_limits.

5

#

The value of each member of a specialization ofnumeric_limits on a cv-qualified typecv T shall be equal to the value of the corresponding member of the specialization on the unqualified type T.

6

#

Non-arithmetic standard types, such ascomplex, shall not have specializations.

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

3

#

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

4

#

Meaningful for all specializations in whichis_bounded != false, oris_bounded == false && is_signed == false.

🔗

static constexpr T max() noexcept;

5

#

Maximum finite value.162

6

#

Meaningful for all specializations in whichis_bounded != false.

🔗

static constexpr T lowest() noexcept;

7

#

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

8

#

Meaningful for all specializations in which is_bounded != false.

🔗

static constexpr int digits;

9

#

Number ofradix 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.164

🔗

static constexpr int digits10;

12

#

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

13

#

Meaningful for all specializations in whichis_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).166

23

#

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

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

26

#

Meaningful for all floating-point types.

🔗

static constexpr T round_error() noexcept;

27

#

Measure of the maximum rounding error.169

🔗

static constexpr int min_exponent;

28

#

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

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

31

#

Meaningful for all floating-point types.

🔗

static constexpr int max_exponent;

32

#

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

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

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 betrue for all specializations in whichis_iec559 != false.

🔗

static constexpr bool has_quiet_NaN;

39

#

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

40

#

Meaningful for all floating-point types.

41

#

Shall betrue for all specializations in whichis_iec559 != false.

🔗

static constexpr bool has_signaling_NaN;

42

#

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

43

#

Meaningful for all floating-point types.

44

#

Shall betrue for all specializations in whichis_iec559 != false.

🔗

static constexpr T infinity() noexcept;

45

#

Representation of positive infinity, if available.176

46

#

Meaningful for all specializations for whichhas_infinity != false.

Required in specializations for whichis_iec559 != false.

🔗

static constexpr T quiet_NaN() noexcept;

47

#

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

48

#

Meaningful for all specializations for whichhas_quiet_NaN != false.

Required in specializations for whichis_iec559 != false.

🔗

static constexpr T signaling_NaN() noexcept;

49

#

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

50

#

Meaningful for all specializations for whichhas_signaling_NaN != false.

Required in specializations for whichis_iec559 != false.

🔗

static constexpr T denorm_min() noexcept;

51

#

Minimum positive subnormal value, if available.179

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

[Note 2:

The value is true for any of the typesfloat16_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.181

[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.182

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

61

#

Meaningful for all specializations.

🔗

static constexpr bool tinyness_before;

62

#

true if tinyness is detected before rounding.184

63

#

Meaningful for all floating-point types.

🔗

static constexpr float_round_style round_style;

64

#

The rounding style for the type.185

65

#

Meaningful for all floating-point types.

Specializations for integer types shall returnround_toward_zero.

161)161)

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

162)162)

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

163)163)

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.

164)164)

Equivalent to FLT_MANT_DIG, DBL_MANT_DIG,LDBL_MANT_DIG.

165)165)

Equivalent to FLT_DIG, DBL_DIG,LDBL_DIG.

166)166)

Equivalent to FLT_RADIX.

167)167)

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

168)168)

Equivalent to FLT_EPSILON, DBL_EPSILON, LDBL_EPSILON.

169)169)

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.

170)170)

Equivalent to FLT_MIN_EXP, DBL_MIN_EXP,LDBL_MIN_EXP.

171)171)

Equivalent toFLT_MIN_10_EXP, DBL_MIN_10_EXP, LDBL_MIN_10_EXP.

172)172)

Equivalent to FLT_MAX_EXP,DBL_MAX_EXP, LDBL_MAX_EXP.

173)173)

Equivalent toFLT_MAX_10_EXP, DBL_MAX_10_EXP, LDBL_MAX_10_EXP.

174)174)

Required by ISO/IEC 10967-1:2012.

175)175)

Required by ISO/IEC 10967-1:2012.

176)176)

Required by ISO/IEC 10967-1:2012.

177)177)

Required by ISO/IEC 10967-1:2012.

178)178)

Required by ISO/IEC 10967-1:2012.

179)179)

Required by ISO/IEC 10967-1:2012.

180)180)

ISO/IEC 60559:2020 is the same as IEEE 754-2019.

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)

Refer to ISO/IEC 60559.

Required by ISO/IEC 10967-1:2012.

185)185)

Equivalent to FLT_ROUNDS.

Required by ISO/IEC 10967-1:2012.

17.3.5.3 numeric_limits specializations [numeric.special]

1

#

All members shall be provided for all specializations.

However, many values are only required to be meaningful under certain conditions (for example,epsilon() is only meaningful ifis_integer isfalse).

Any value that is not “meaningful” shall be set to 0 orfalse.

2

#

[Example 1: namespace std {template<> class numeric_limits {public:static constexpr bool is_specialized = true; static constexpr float min() noexcept { return 1.17549435E-38F; }static constexpr float max() noexcept { return 3.40282347E+38F; }static constexpr float lowest() noexcept { return -3.40282347E+38F; }static constexpr int digits = 24; static constexpr int digits10 = 6; static constexpr int max_digits10 = 9; static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static constexpr float epsilon() noexcept { return 1.19209290E-07F; }static constexpr float round_error() noexcept { return 0.5F; }static constexpr int min_exponent = -125; static constexpr int min_exponent10 = - 37; static constexpr int max_exponent = +128; static constexpr int max_exponent10 = + 38; static constexpr bool has_infinity = true; static constexpr bool has_quiet_NaN = true; static constexpr bool has_signaling_NaN = true; static constexpr float infinity() noexcept { return value; }static constexpr float quiet_NaN() noexcept { return value; }static constexpr float signaling_NaN() noexcept { return value; }static constexpr float denorm_min() noexcept { return min(); }static constexpr bool is_iec559 = true; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = true; static constexpr float_round_style round_style = round_to_nearest; };} — end example]

3

#

The specialization forbool shall be provided as follows:

🔗

namespace std {template<> class numeric_limits {public:static constexpr bool is_specialized = true; static constexpr bool min() noexcept { return false; }static constexpr bool max() noexcept { return true; }static constexpr bool lowest() noexcept { return false; }static constexpr int digits = 1; static constexpr int digits10 = 0; static constexpr int max_digits10 = 0; static constexpr bool is_signed = false; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr bool epsilon() noexcept { return 0; }static constexpr bool round_error() noexcept { return 0; }static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr bool infinity() noexcept { return 0; }static constexpr bool quiet_NaN() noexcept { return 0; }static constexpr bool signaling_NaN() noexcept { return 0; }static constexpr bool denorm_min() noexcept { return 0; }static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; };}