[numeric.limits.members] - C++14 → C++17

Files changed (1) hide show

tmp/tmpl1fw9do8/{from.md → to.md} +54 -46

tmp/tmpl1fw9do8/{from.md → to.md} RENAMED Viewed

@@ -1,14 +1,17 @@
 #### `numeric_limits` members <a id="numeric.limits.members">[[numeric.limits.members]]</a>
 ``` cpp
 static constexpr T min() noexcept;
 ```
 Minimum finite value.[^3]
-For floating types with denormalization, returns the minimum positive
 normalized value.
 Meaningful for all specializations in which `is_bounded != false`, or
 `is_bounded == false && is_signed == false`.
@@ -35,11 +38,11 @@ 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.[^6]
 ``` cpp
 static constexpr int digits10;
 ```
@@ -53,33 +56,33 @@ 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.
 ``` cpp
 static constexpr bool is_signed;
 ```
-True if the type is signed.
 Meaningful for all specializations.
 ``` cpp
 static constexpr bool is_integer;
 ```
-True if the type is integer.
 Meaningful for all specializations.
 ``` cpp
 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.
@@ -99,11 +102,11 @@ static constexpr T epsilon() noexcept;
 ```
 Machine epsilon: the difference between 1 and the least value greater
 than 1 that is representable.[^10]
-Meaningful for all floating point types.
 ``` cpp
 static constexpr T round_error() noexcept;
 ```
@@ -112,89 +115,89 @@ Measure of the maximum rounding error.[^11]
 ``` cpp
 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.[^12]
-Meaningful for all floating point types.
 ``` cpp
 static constexpr int  min_exponent10;
 ```
 Minimum negative integer such that 10 raised to that power is in the
-range of normalized floating point numbers.[^13]
-Meaningful for all floating point types.
 ``` cpp
 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.[^14]
-Meaningful for all floating point types.
 ``` cpp
 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.[^15]
-Meaningful for all floating point types.
 ``` cpp
 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`.
 ``` cpp
 static constexpr bool has_quiet_NaN;
 ```
-True if the type has a representation for a quiet (non-signaling) “Not a
-Number.”[^16]
-Meaningful for all floating point types.
 Shall be `true` for all specializations in which `is_iec559 != false`.
 ``` cpp
 static constexpr bool has_signaling_NaN;
 ```
-True if the type has a representation for a signaling “Not a
-Number.”[^17]
-Meaningful for all floating point types.
 Shall be `true` for all specializations in which `is_iec559 != false`.
 ``` cpp
 static constexpr float_denorm_style has_denorm;
 ```
-`denorm_present` if the type allows denormalized values (variable number
-of exponent bits)[^18], `denorm_absent` if the type does not allow
-denormalized values, and `denorm_indeterminate` if it is indeterminate
-at compile time whether the type allows denormalized values.
-Meaningful for all floating point types.
 ``` cpp
 static constexpr bool has_denorm_loss;
 ```
-True if loss of accuracy is detected as a denormalization loss, rather
 than as an inexact result.[^19]
 ``` cpp
 static constexpr T infinity() noexcept;
 ```
@@ -206,65 +209,70 @@ Required in specializations for which `is_iec559 != false`.
 ``` cpp
 static constexpr T quiet_NaN() noexcept;
 ```
-Representation of a quiet “Not a Number,” if available.[^21]
 Meaningful for all specializations for which `has_quiet_NaN != false`.
 Required in specializations for which `is_iec559 != false`.
 ``` cpp
 static constexpr T signaling_NaN() noexcept;
 ```
-Representation of a signaling “Not a Number,” if available.[^22]
 Meaningful for all specializations for which
 `has_signaling_NaN != false`. Required in specializations for which
 `is_iec559 != false`.
 ``` cpp
 static constexpr T denorm_min() noexcept;
 ```
-Minimum positive denormalized value.[^23]
-Meaningful for all floating point types.
 In specializations for which `has_denorm == false`, returns the minimum
 positive normalized value.
 ``` cpp
 static constexpr bool is_iec559;
 ```
-True if and only if the type adheres to IEC 559 standard.[^24]
-Meaningful for all floating point types.
 ``` cpp
 static constexpr bool is_bounded;
 ```
-True if the set of values representable by the type is finite.[^25] All
-fundamental types ([[basic.fundamental]]) are bounded. This member
-would be false for arbitrary precision types.
 Meaningful for all specializations.
 ``` cpp
 static constexpr bool is_modulo;
 ```
-True if the type is modulo.[^26] 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`.
-On most machines, this is `false` for floating types, `true` for
-unsigned integers, and `true` for signed integers.
 Meaningful for all specializations.
 ``` cpp
 static constexpr bool traps;
@@ -279,16 +287,16 @@ Meaningful for all specializations.
 static constexpr bool tinyness_before;
 ```
 `true` if tinyness is detected before rounding.[^28]
-Meaningful for all floating point types.
 ``` cpp
 static constexpr float_round_style round_style;
 ```
 The rounding style for the type.[^29]
-Meaningful for all floating point types. Specializations for integer
 types shall return `round_toward_zero`.

 #### `numeric_limits` members <a id="numeric.limits.members">[[numeric.limits.members]]</a>
+Each member function defined in this subclause is signal-safe (
+[[csignal.syn]]).
 ``` cpp
 static constexpr T min() noexcept;
 ```
 Minimum finite value.[^3]
+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`.
 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.[^6]
 ``` cpp
 static constexpr int digits10;
 ```
 ```
 Number of base 10 digits required to ensure that values which differ are
 always differentiated.
+Meaningful for all floating-point types.
 ``` cpp
 static constexpr bool is_signed;
 ```
+`true` if the type is signed.
 Meaningful for all specializations.
 ``` cpp
 static constexpr bool is_integer;
 ```
+`true` if the type is integer.
 Meaningful for all specializations.
 ``` cpp
 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.
 ```
 Machine epsilon: the difference between 1 and the least value greater
 than 1 that is representable.[^10]
+Meaningful for all floating-point types.
 ``` cpp
 static constexpr T round_error() noexcept;
 ```
 ``` cpp
 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.[^12]
+Meaningful for all floating-point types.
 ``` cpp
 static constexpr int  min_exponent10;
 ```
 Minimum negative integer such that 10 raised to that power is in the
+range of normalized floating-point numbers.[^13]
+Meaningful for all floating-point types.
 ``` cpp
 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.[^14]
+Meaningful for all floating-point types.
 ``` cpp
 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.[^15]
+Meaningful for all floating-point types.
 ``` cpp
 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`.
 ``` cpp
 static constexpr bool has_quiet_NaN;
 ```
+`true` if the type has a representation for a quiet (non-signaling) “Not
+a Number”.[^16]
+Meaningful for all floating-point types.
 Shall be `true` for all specializations in which `is_iec559 != false`.
 ``` cpp
 static constexpr bool has_signaling_NaN;
 ```
+`true` if the type has a representation for a signaling “Not a
+Number”.[^17]
+Meaningful for all floating-point types.
 Shall be `true` for all specializations in which `is_iec559 != false`.
 ``` cpp
 static constexpr float_denorm_style has_denorm;
 ```
+`denorm_present` if the type allows subnormal values (variable number of
+exponent bits)[^18], `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.
 ``` cpp
 static constexpr bool has_denorm_loss;
 ```
+`true` if loss of accuracy is detected as a denormalization loss, rather
 than as an inexact result.[^19]
 ``` cpp
 static constexpr T infinity() noexcept;
 ```
 ``` cpp
 static constexpr T quiet_NaN() noexcept;
 ```
+Representation of a quiet “Not a Number”, if available.[^21]
 Meaningful for all specializations for which `has_quiet_NaN != false`.
 Required in specializations for which `is_iec559 != false`.
 ``` cpp
 static constexpr T signaling_NaN() noexcept;
 ```
+Representation of a signaling “Not a Number”, if available.[^22]
 Meaningful for all specializations for which
 `has_signaling_NaN != false`. Required in specializations for which
 `is_iec559 != false`.
 ``` cpp
 static constexpr T denorm_min() noexcept;
 ```
+Minimum positive subnormal value.[^23]
+Meaningful for all floating-point types.
 In specializations for which `has_denorm == false`, returns the minimum
 positive normalized value.
 ``` cpp
 static constexpr bool is_iec559;
 ```
+`true` if and only if the type adheres to ISO/IEC/IEEE 60559.[^24]
+Meaningful for all floating-point types.
 ``` cpp
 static constexpr bool is_bounded;
 ```
+`true` if the set of values representable by the type is finite.[^25]
+[*Note 1*: All fundamental types ([[basic.fundamental]]) are bounded.
+This member would be `false` for arbitrary precision
+types. — *end note*]
 Meaningful for all specializations.
 ``` cpp
 static constexpr bool is_modulo;
 ```
+`true` if the type is modulo.[^26] 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 1*: `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.
 ``` cpp
 static constexpr bool traps;
 static constexpr bool tinyness_before;
 ```
 `true` if tinyness is detected before rounding.[^28]
+Meaningful for all floating-point types.
 ``` cpp
 static constexpr float_round_style round_style;
 ```
 The rounding style for the type.[^29]
+Meaningful for all floating-point types. Specializations for integer
 types shall return `round_toward_zero`.

Diff to HTML by rtfpessoa