[support.limits] (original) (raw)
17.3.5.1 numeric_limits members [numeric.limits.members]
Each member function defined in this subclause is signal-safe.
static constexpr T min() noexcept;
For floating-point types with subnormal numbers, returns the minimum positive normalized value.
Meaningful for all specializations in whichis_bounded != false, oris_bounded == false && is_signed == false.
static constexpr T max() noexcept;
Meaningful for all specializations in whichis_bounded != false.
static constexpr T lowest() noexcept;
A finite value x such that there is no other finite value y where y < x.186
Meaningful for all specializations in which is_bounded != false.
static constexpr int digits;
Number ofradixdigits 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.187
static constexpr int digits10;
Number of base 10 digits that can be represented without change.188
Meaningful for all specializations in whichis_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).189
For integer types, specifies the base of the representation.190
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.191
Meaningful for all floating-point types.
static constexpr T round_error() noexcept;
Measure of the maximum rounding error.192
static constexpr int min_exponent;
Minimum negative integer such thatradixraised to the power of one less than that integer is a normalized floating-point number.193
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.194
Meaningful for all floating-point types.
static constexpr int max_exponent;
Maximum positive integer such thatradixraised to the power one less than that integer is a representable finite floating-point number.195
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.196
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 betruefor all specializations in whichis_iec559 != false.
static constexpr bool has_quiet_NaN;
true if the type has a representation for a quiet (non-signaling) “Not a Number”.197
Meaningful for all floating-point types.
Shall betruefor all specializations in whichis_iec559 != false.
static constexpr bool has_signaling_NaN;
true if the type has a representation for a signaling “Not a Number”.198
Meaningful for all floating-point types.
Shall betruefor all specializations in whichis_iec559 != false.
static constexpr float_denorm_style has_denorm;
denorm_presentif the type allows subnormal values (variable number of exponent bits)199,denorm_absentif the type does not allow subnormal values, anddenorm_indeterminateif it is indeterminate at compile time whether the type allows subnormal 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.200
static constexpr T infinity() noexcept;
Representation of positive infinity, if available.201
Meaningful for all specializations for whichhas_infinity != false.
Required in specializations for whichis_iec559 != false.
static constexpr T quiet_NaN() noexcept;
Representation of a quiet “Not a Number”, if available.202
Meaningful for all specializations for whichhas_quiet_NaN != false.
Required in specializations for whichis_iec559 != false.
static constexpr T signaling_NaN() noexcept;
Representation of a signaling “Not a Number”, if available.203
Meaningful for all specializations for whichhas_signaling_NaN != false.
Required in specializations for whichis_iec559 != false.
static constexpr T denorm_min() noexcept;
Minimum positive subnormal value.204
Meaningful for all floating-point types.
In specializations for whichhas_denorm == false, returns the minimum positive normalized value.
static constexpr bool is_iec559;
true if and only if the type adheres to ISO/IEC/IEEE 60559.205
Meaningful for all floating-point types.
static constexpr bool is_bounded;
true if the set of values representable by the type is finite.206
[ Note
:
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.207
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
:
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;
trueif, at the start of the program, there exists a value of the type that would cause an arithmetic operation using that value to trap.208
Meaningful for all specializations.
static constexpr bool tinyness_before;
trueif tinyness is detected before rounding.209
Meaningful for all floating-point types.
static constexpr float_round_style round_style;
The rounding style for the type.210
Meaningful for all floating-point types.
Specializations for integer types shall returnround_toward_zero.
17.3.5.2 numeric_limits specializations [numeric.special]
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_integerisfalse).
Any value that is not “meaningful” shall be set to 0 orfalse.
[ Example
:
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_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
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
]
The specialization forboolshall 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 float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = 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;}; }