[numeric.limits] - C++20 → C++23

Files changed (1) hide show

tmp/tmp_pbwu7ut/{from.md → to.md} +30 -44

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

@@ -1,7 +1,9 @@
 ### Class template `numeric_limits` <a id="numeric.limits">[[numeric.limits]]</a>
 The `numeric_limits` class template provides a C++ program with
 information about various properties of the implementation’s
 representation of the arithmetic types.
 ``` cpp
@@ -29,12 +31,10 @@ namespace std {
     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 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(); }
@@ -51,12 +51,16 @@ namespace std {
 For all members declared `static` `constexpr` in the `numeric_limits`
 template, specializations shall define these values in such a way that
 they are usable as constant expressions.
-The default `numeric_limits<T>` template shall have all members, but
-with 0 or `false` values.
 Specializations shall be provided for each arithmetic type, both
 floating-point and integer, including `bool`. The member
 `is_specialized` shall be `true` for all such specializations of
 `numeric_limits`.
@@ -248,96 +252,82 @@ 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;
 ```
-Representation of positive infinity, if available.[^20]
 Meaningful for all specializations for which `has_infinity != false`.
 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 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 document, defines signed integer overflow to
 wrap. — *end example*]
@@ -347,27 +337,27 @@ Meaningful for all specializations.
 ``` cpp
 static constexpr bool traps;
 ```
 `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.[^27]
 Meaningful for all specializations.
 ``` cpp
 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` specializations <a id="numeric.special">[[numeric.special]]</a>
@@ -407,12 +397,10 @@ namespace std {
     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(); }
@@ -458,12 +446,10 @@ namespace std {
      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; }

 ### Class template `numeric_limits` <a id="numeric.limits">[[numeric.limits]]</a>
+#### General <a id="numeric.limits.general">[[numeric.limits.general]]</a>
 The `numeric_limits` class template provides a C++ program with
 information about various properties of the implementation’s
 representation of the arithmetic types.
 ``` cpp
     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(); }
 For all members declared `static` `constexpr` in the `numeric_limits`
 template, specializations shall define these values in such a way that
 they are usable as constant expressions.
+For the `numeric_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*]
 Specializations shall be provided for each arithmetic type, both
 floating-point and integer, including `bool`. The member
 `is_specialized` shall be `true` for all such specializations of
 `numeric_limits`.
 Meaningful for all floating-point types.
 Shall be `true` for all specializations in which `is_iec559 != false`.
 ``` cpp
 static constexpr T infinity() noexcept;
 ```
+Representation of positive infinity, if available.[^18]
 Meaningful for all specializations for which `has_infinity != false`.
 Required in specializations for which `is_iec559 != false`.
 ``` cpp
 static constexpr T quiet_NaN() noexcept;
 ```
+Representation of a quiet “Not a Number”, if available.[^19]
 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.[^20]
 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, if available.[^21]
+Otherwise, minimum positive normalized value.
 Meaningful for all floating-point types.
 ``` cpp
 static constexpr bool is_iec559;
 ```
+`true` if and only if the type adheres to ISO/IEC/IEEE 60559.[^22]
+[*Note 1*: 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*]
 Meaningful for all floating-point types.
 ``` cpp
 static constexpr bool is_bounded;
 ```
+`true` if the set of values representable by the type is finite.[^23]
+[*Note 2*: 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.[^24]
+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 document, defines signed integer overflow to
 wrap. — *end example*]
 ``` cpp
 static constexpr bool traps;
 ```
 `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.[^25]
 Meaningful for all specializations.
 ``` cpp
 static constexpr bool tinyness_before;
 ```
+`true` if tinyness is detected before rounding.[^26]
 Meaningful for all floating-point types.
 ``` cpp
 static constexpr float_round_style round_style;
 ```
+The rounding style for the type.[^27]
 Meaningful for all floating-point types. Specializations for integer
 types shall return `round_toward_zero`.
 #### `numeric_limits` specializations <a id="numeric.special">[[numeric.special]]</a>
     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 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; }

Diff to HTML by rtfpessoa