Each member function defined in this subclause is signal-safe ([csignal.syn]).
static constexpr T min() noexcept;
For floating types with subnormal numbers, 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;
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.190
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.191
static constexpr int digits10;
Number of base 10 digits that can be represented without change.192
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).193
For integer types, specifies the base of the representation.194
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.195
Meaningful for all floating-point types.
static constexpr T round_error() noexcept;
Measure of the maximum rounding error.196
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.197
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.198
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.199
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.200
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”.201
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”.202
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 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.
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.204
static constexpr T infinity() noexcept;
Representation of positive infinity, if available.205
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.206
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.207
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 subnormal value.208
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 ISO/IEC/IEEE 60559.209
Meaningful for all floating-point types.
static constexpr bool is_bounded;
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 ]
Meaningful for all specializations.
static constexpr bool is_modulo;
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.
[ 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 ]
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.212
Meaningful for all specializations.
static constexpr bool tinyness_before;
true if tinyness is detected before rounding.213
Meaningful for all floating-point types.
static constexpr float_round_style round_style;
The rounding style for the type.214
Meaningful for all floating-point types. Specializations for integer types shall return round_toward_zero.
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4