[support.limits] - C++14 → C++17

Files changed (1) hide show

tmp/tmpe981amnl/{from.md → to.md} +219 -136

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

@@ -1,41 +1,25 @@
 ## Implementation properties <a id="support.limits">[[support.limits]]</a>
-### In general <a id="support.limits.general">[[support.limits.general]]</a>
-The headers `<limits>` ([[limits]]), `<climits>`, and `<cfloat>` (
-[[c.limits]]) supply characteristics of implementation-dependent
-arithmetic types ([[basic.fundamental]]).
-### Numeric limits <a id="limits">[[limits]]</a>
-#### Class template `numeric_limits` <a id="limits.numeric">[[limits.numeric]]</a>
-The `numeric_limits` class template provides a C++program with
-information about various properties of the implementation’s
-representation of the arithmetic types.
-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`.
-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.
-Non-arithmetic standard types, such as `complex<T>` ([[complex]]),
-shall not have specializations.
-#### Header `<limits>` synopsis <a id="limits.syn">[[limits.syn]]</a>
 ``` cpp
 namespace std {
- template<class T> class numeric_limits;
   enum float_round_style;
   enum float_denorm_style;
   template<> class numeric_limits<bool>;
   template<> class numeric_limits<char>;
   template<> class numeric_limits<signed char>;
   template<> class numeric_limits<unsigned char>;
@@ -56,11 +40,62 @@ namespace std {
   template<> class numeric_limits<double>;
   template<> class numeric_limits<long double>;
 }
 ```
-#### Class template `numeric_limits` <a id="numeric.limits">[[numeric.limits]]</a>
 ``` cpp
 namespace std {
   template<class T> class numeric_limits {
   public:
@@ -107,26 +142,41 @@ namespace std {
   template<class T> class numeric_limits<volatile T>;
   template<class T> class numeric_limits<const volatile T>;
 }
 ```
 The default `numeric_limits<T>` template shall have all members, but
 with 0 or `false` values.
 The value of each member of a specialization of `numeric_limits` on a
-*cv*-qualified type `cv T` shall be equal to the value of the
 corresponding member of the specialization on the unqualified type `T`.
 #### `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`.
@@ -153,11 +203,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;
 ```
@@ -171,33 +221,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.
@@ -217,11 +267,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;
 ```
@@ -230,89 +280,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;
 ```
@@ -324,65 +374,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;
@@ -397,94 +452,51 @@ 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`.
-#### Type `float_round_style` <a id="round.style">[[round.style]]</a>
-``` cpp
-namespace std {
-  enum float_round_style {
-    round_indeterminate       = -1,
-    round_toward_zero         =  0,
-    round_to_nearest          =  1,
-    round_toward_infinity     =  2,
-    round_toward_neg_infinity =  3
-  };
-}
-```
-The rounding mode for floating point arithmetic is characterized by the
-values:
-- `round_indeterminate` if the rounding style is indeterminable
-- `round_toward_zero` if the rounding style is toward zero
-- `round_to_nearest` if the rounding style is to the nearest
-  representable value
-- `round_toward_infinity` if the rounding style is toward infinity
-- `round_toward_neg_infinity` if the rounding style is toward negative
-  infinity
-#### Type `float_denorm_style` <a id="denorm.style">[[denorm.style]]</a>
-``` cpp
-namespace std {
-  enum float_denorm_style {
-    denorm_indeterminate = -1,
-    denorm_absent = 0,
-    denorm_present = 1
-  };
-}
-```
-The presence or absence of denormalization (variable number of exponent
-bits) is characterized by the values:
-- `denorm_indeterminate` if it cannot be determined whether or not the
-  type allows denormalized values
-- `denorm_absent` if the type does not allow denormalized values
-- `denorm_present` if the type does allow denormalized values
 #### `numeric_limits` specializations <a id="numeric.special">[[numeric.special]]</a>
 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 if `is_integer` is `false`). Any
 value that is not “meaningful” shall be set to 0 or `false`.
 ``` cpp
 namespace std {
   template<> class numeric_limits<float> {
   public:
     static constexpr bool is_specialized = true;
- inline static constexpr float min() noexcept { return 1.17549435E-38F; }
- inline static constexpr float max() noexcept { return 3.40282347E+38F; }
- inline 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;
- inline static constexpr float epsilon() noexcept     { return 1.19209290E-07F; }
- inline 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;
@@ -493,14 +505,14 @@ namespace std {
     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;
- inline static constexpr float infinity()      noexcept { return value; }
- inline static constexpr float quiet_NaN()     noexcept { return value; }
- inline static constexpr float signaling_NaN() noexcept { return value; }
- inline 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;
@@ -509,10 +521,12 @@ namespace std {
     static constexpr float_round_style round_style = round_to_nearest;
   };
 }
 ```
 The specialization for `bool` shall be provided as follows:
 ``` cpp
 namespace std {
    template<> class numeric_limits<bool> {
@@ -557,19 +571,88 @@ namespace std {
      static constexpr float_round_style round_style = round_toward_zero;
    };
 }
 ```
-### C library <a id="c.limits">[[c.limits]]</a>
-Table  [[tab:support.hdr.climits]] describes the header `<climits>`.
-The contents are the same as the Standard C library header `<limits.h>`.
-The types of the constants defined by macros in `<climits>` are not
-required to match the types to which the macros refer.
-Table  [[tab:support.hdr.cfloat]] describes the header `<cfloat>`.
-The contents are the same as the Standard C library header `<float.h>`.
-ISO C 7.1.5, 5.2.4.2.2, 5.2.4.2.1.

 ## Implementation properties <a id="support.limits">[[support.limits]]</a>
+### General <a id="support.limits.general">[[support.limits.general]]</a>
+The headers `<limits>` ([[limits.syn]]), `<climits>` (
+[[climits.syn]]), and `<cfloat>` ([[cfloat.syn]]) supply
+characteristics of implementation-dependent arithmetic types (
+[[basic.fundamental]]).
+### Header `<limits>` synopsis <a id="limits.syn">[[limits.syn]]</a>
 ``` cpp
 namespace std {
+ // [fp.style], floating-point type properties
   enum float_round_style;
   enum float_denorm_style;
+  // [numeric.limits], class template numeric_limits
+  template<class T> class numeric_limits;
   template<> class numeric_limits<bool>;
   template<> class numeric_limits<char>;
   template<> class numeric_limits<signed char>;
   template<> class numeric_limits<unsigned char>;
   template<> class numeric_limits<double>;
   template<> class numeric_limits<long double>;
 }
 ```
+### Floating-point type properties <a id="fp.style">[[fp.style]]</a>
+#### Type `float_round_style` <a id="round.style">[[round.style]]</a>
+``` cpp
+namespace std {
+  enum float_round_style {
+    round_indeterminate       = -1,
+    round_toward_zero         =  0,
+    round_to_nearest          =  1,
+    round_toward_infinity     =  2,
+    round_toward_neg_infinity =  3
+  };
+}
+```
+The rounding mode for floating-point arithmetic is characterized by the
+values:
+- `round_indeterminate` if the rounding style is indeterminable
+- `round_toward_zero` if the rounding style is toward zero
+- `round_to_nearest` if the rounding style is to the nearest
+  representable value
+- `round_toward_infinity` if the rounding style is toward infinity
+- `round_toward_neg_infinity` if the rounding style is toward negative
+  infinity
+#### Type `float_denorm_style` <a id="denorm.style">[[denorm.style]]</a>
+``` cpp
+namespace std {
+  enum float_denorm_style {
+    denorm_indeterminate = -1,
+    denorm_absent = 0,
+    denorm_present = 1
+  };
+}
+```
+The presence or absence of subnormal numbers (variable number of
+exponent bits) is characterized by the values:
+- `denorm_indeterminate` if it cannot be determined whether or not the
+  type allows subnormal values
+- `denorm_absent` if the type does not allow subnormal values
+- `denorm_present` if the type does allow subnormal values
+### 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
 namespace std {
   template<class T> class numeric_limits {
   public:
   template<class T> class numeric_limits<volatile T>;
   template<class T> class numeric_limits<const volatile 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.
 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`.
 The value of each member of a specialization of `numeric_limits` on a
+cv-qualified type `cv T` shall be equal to the value of the
 corresponding member of the specialization on the unqualified type `T`.
+Non-arithmetic standard types, such as `complex<T>` ([[complex]]),
+shall not have specializations.
 #### `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`.
 #### `numeric_limits` specializations <a id="numeric.special">[[numeric.special]]</a>
 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 if `is_integer` is `false`). Any
 value that is not “meaningful” shall be set to 0 or `false`.
+[*Example 1*:
 ``` cpp
 namespace std {
   template<> class numeric_limits<float> {
   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_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 float_round_style round_style = round_to_nearest;
   };
 }
 ```
+— *end example*]
 The specialization for `bool` shall be provided as follows:
 ``` cpp
 namespace std {
    template<> class numeric_limits<bool> {
      static constexpr float_round_style round_style = round_toward_zero;
    };
 }
 ```
+### Header `<climits>` synopsis <a id="climits.syn">[[climits.syn]]</a>
+``` cpp
+#define CHAR_BIT see below
+#define SCHAR_MIN see below
+#define SCHAR_MAX see below
+#define UCHAR_MAX see below
+#define CHAR_MIN see below
+#define CHAR_MAX see below
+#define MB_LEN_MAX see below
+#define SHRT_MIN see below
+#define SHRT_MAX see below
+#define USHRT_MAX see below
+#define INT_MIN see below
+#define INT_MAX see below
+#define UINT_MAX see below
+#define LONG_MIN see below
+#define LONG_MAX see below
+#define ULONG_MAX see below
+#define LLONG_MIN see below
+#define LLONG_MAX see below
+#define ULLONG_MAX see below
+```
+The header `<climits>` defines all macros the same as the C standard
+library header `<limits.h>`.
+[*Note 1*: The types of the constants defined by macros in `<climits>`
+are not required to match the types to which the macros
+refer. — *end note*]
+ISO C 5.2.4.2.1
+### Header `<cfloat>` synopsis <a id="cfloat.syn">[[cfloat.syn]]</a>
+``` cpp
+#define FLT_ROUNDS see below
+#define FLT_EVAL_METHOD see below
+#define FLT_HAS_SUBNORM see below
+#define DBL_HAS_SUBNORM see below
+#define LDBL_HAS_SUBNORM see below
+#define FLT_RADIX see below
+#define FLT_MANT_DIG see below
+#define DBL_MANT_DIG see below
+#define LDBL_MANT_DIG see below
+#define FLT_DECIMAL_DIG see below
+#define DBL_DECIMAL_DIG see below
+#define LDBL_DECIMAL_DIG see below
+#define DECIMAL_DIG see below
+#define FLT_DIG see below
+#define DBL_DIG see below
+#define LDBL_DIG see below
+#define FLT_MIN_EXP see below
+#define DBL_MIN_EXP see below
+#define LDBL_MIN_EXP see below
+#define FLT_MIN_10_EXP see below
+#define DBL_MIN_10_EXP see below
+#define LDBL_MIN_10_EXP see below
+#define FLT_MAX_EXP see below
+#define DBL_MAX_EXP see below
+#define LDBL_MAX_EXP see below
+#define FLT_MAX_10_EXP see below
+#define DBL_MAX_10_EXP see below
+#define LDBL_MAX_10_EXP see below
+#define FLT_MAX see below
+#define DBL_MAX see below
+#define LDBL_MAX see below
+#define FLT_EPSILON see below
+#define DBL_EPSILON see below
+#define LDBL_EPSILON see below
+#define FLT_MIN see below
+#define DBL_MIN see below
+#define LDBL_MIN see below
+#define FLT_TRUE_MIN see below
+#define DBL_TRUE_MIN see below
+#define LDBL_TRUE_MIN see below
+```
+The header `<cfloat>` defines all macros the same as the C standard
+library header `<float.h>`.
+ISO C 5.2.4.2.2

Diff to HTML by rtfpessoa