[ratio] - C++14 → C++17

Files changed (1) hide show

tmp/tmp9g06esl3/{from.md → to.md} +63 -49

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

@@ -31,31 +31,44 @@ namespace std {
   template <class R1, class R2> struct ratio_less;
   template <class R1, class R2> struct ratio_less_equal;
   template <class R1, class R2> struct ratio_greater;
   template <class R1, class R2> struct ratio_greater_equal;
   // [ratio.si], convenience SI typedefs
- typedef ratio<1, 1'000'000'000'000'000'000'000'000> yocto;  // see below
- typedef ratio<1,     1'000'000'000'000'000'000'000> zepto;  // see below
- typedef ratio<1,         1'000'000'000'000'000'000> atto;
- typedef ratio<1,             1'000'000'000'000'000> femto;
- typedef ratio<1,                 1'000'000'000'000> pico;
- typedef ratio<1,                     1'000'000'000> nano;
- typedef ratio<1,                         1'000'000> micro;
- typedef ratio<1,                             1'000> milli;
- typedef ratio<1,                               100> centi;
- typedef ratio<1,                                10> deci;
- typedef ratio<                               10, 1> deca;
- typedef ratio<                              100, 1> hecto;
- typedef ratio<                            1'000, 1> kilo;
- typedef ratio<                        1'000'000, 1> mega;
- typedef ratio<                    1'000'000'000, 1> giga;
- typedef ratio<                1'000'000'000'000, 1> tera;
- typedef ratio<            1'000'000'000'000'000, 1> peta;
- typedef ratio<        1'000'000'000'000'000'000, 1> exa;
- typedef ratio<    1'000'000'000'000'000'000'000, 1> zetta;  // see below
- typedef ratio<1'000'000'000'000'000'000'000'000, 1> yotta;  // see below
 }
 ```
 ### Class template `ratio` <a id="ratio.ratio">[[ratio.ratio]]</a>
@@ -64,21 +77,23 @@ namespace std {
   template <intmax_t N, intmax_t D = 1>
   class ratio {
   public:
     static constexpr intmax_t num;
     static constexpr intmax_t den;
- typedef ratio<num, den> type;
   };
 }
 ```
 If the template argument `D` is zero or the absolute values of either of
 the template arguments `N` and `D` is not representable by type
-`intmax_t`, the program is ill-formed. These rules ensure that infinite
-ratios are avoided and that for any negative input, there exists a
-representable value of its absolute value which is positive. In a two’s
-complement representation, this excludes the most negative value.
 The static data members `num` and `den` shall have the following values,
 where `gcd` represents the greatest common divisor of the absolute
 values of `N` and `D`:
@@ -111,10 +126,12 @@ yields correct values of `U` and `V`.
 |                          | `R2::num * R1::den`   |                     |
 | `ratio_multiply<R1, R2>` | `R1::num * R2::num`   | `R1::den * R2::den` |
 | `ratio_divide<R1, R2>`   | `R1::num * R2::den`   | `R1::den * R2::num` |
 ``` cpp
 static_assert(ratio_add<ratio<1, 3>, ratio<1, 6>>::num == 1, "1/3+1/6 == 1/2");
 static_assert(ratio_add<ratio<1, 3>, ratio<1, 6>>::den == 2, "1/3+1/6 == 1/2");
 static_assert(ratio_multiply<ratio<1, 3>, ratio<3, 2>>::num == 1, "1/3*3/2 == 1/2");
 static_assert(ratio_multiply<ratio<1, 3>, ratio<3, 2>>::den == 2, "1/3*3/2 == 1/2");
@@ -128,55 +145,52 @@ static_assert(ratio_multiply<ratio<1,INT_MAX>, ratio<INT_MAX,2>>::num == 1,
   "1/MAX * MAX/2 == 1/2");
 static_assert(ratio_multiply<ratio<1, INT_MAX>, ratio<INT_MAX, 2>>::den == 2,
   "1/MAX * MAX/2 == 1/2");
 ```
 ### Comparison of `ratio`s <a id="ratio.comparison">[[ratio.comparison]]</a>
 ``` cpp
-template <class R1, class R2> struct ratio_equal
-  : integral_constant<bool, see below> { };
 ```
-If `R1::num == R2::num` and `R1::den == R2::den`, `ratio_equal<R1, R2>`
-shall be derived from
-`integral_constant<bool, true>`; otherwise it shall be derived from
-`integral_constant<bool, false>`.
 ``` cpp
-template <class R1, class R2> struct ratio_not_equal
-  : integral_constant<bool, !ratio_equal<R1, R2>::value> { };
 ```
 ``` cpp
-template <class R1, class R2> struct ratio_less
-  : integral_constant<bool, see below> { };
 ```
-If `R1::num * R2::den < R2::num * R1::den`, `ratio_less<R1, R2>` shall
-be derived from `integral_constant<bool, true>`; otherwise it shall be
-derived from `integral_constant<bool, false>`. Implementations may use
-other algorithms to compute this relationship to avoid overflow. If
-overflow occurs, the program is ill-formed.
 ``` cpp
-template <class R1, class R2> struct ratio_less_equal
-  : integral_constant<bool, !ratio_less<R2, R1>::value> { };
 ```
 ``` cpp
-template <class R1, class R2> struct ratio_greater
-  : integral_constant<bool, ratio_less<R2, R1>::value> { };
 ```
 ``` cpp
-template <class R1, class R2> struct ratio_greater_equal
-  : integral_constant<bool, !ratio_less<R1, R2>::value> { };
 ```
 ### SI types for `ratio` <a id="ratio.si">[[ratio.si]]</a>
-For each of the typedefs `yocto`, `zepto`, `zetta`, and `yotta`, if both
-of the constants used in its specification are representable by
 `intmax_t`, the typedef shall be defined; if either of the constants is
 not representable by `intmax_t`, the typedef shall not be defined.

   template <class R1, class R2> struct ratio_less;
   template <class R1, class R2> struct ratio_less_equal;
   template <class R1, class R2> struct ratio_greater;
   template <class R1, class R2> struct ratio_greater_equal;
+  template <class R1, class R2>
+    inline constexpr bool ratio_equal_v = ratio_equal<R1, R2>::value;
+  template <class R1, class R2>
+    inline constexpr bool ratio_not_equal_v = ratio_not_equal<R1, R2>::value;
+  template <class R1, class R2>
+    inline constexpr bool ratio_less_v = ratio_less<R1, R2>::value;
+  template <class R1, class R2>
+    inline constexpr bool ratio_less_equal_v = ratio_less_equal<R1, R2>::value;
+  template <class R1, class R2>
+    inline constexpr bool ratio_greater_v = ratio_greater<R1, R2>::value;
+  template <class R1, class R2>
+    inline constexpr bool ratio_greater_equal_v = ratio_greater_equal<R1, R2>::value;
   // [ratio.si], convenience SI typedefs
+ using yocto = ratio<1, 1'000'000'000'000'000'000'000'000>;  // see below
+ using zepto = ratio<1,     1'000'000'000'000'000'000'000>;  // see below
+ using atto  = ratio<1,         1'000'000'000'000'000'000>;
+ using femto = ratio<1,             1'000'000'000'000'000>;
+ using pico  = ratio<1,                 1'000'000'000'000>;
+ using nano  = ratio<1,                     1'000'000'000>;
+ using micro = ratio<1,                         1'000'000>;
+ using milli = ratio<1,                             1'000>;
+ using centi = ratio<1,                               100>;
+ using deci  = ratio<1,                                10>;
+ using deca  = ratio<                               10, 1>;
+ using hecto = ratio<                              100, 1>;
+ using kilo  = ratio<                            1'000, 1>;
+ using mega  = ratio<                        1'000'000, 1>;
+ using giga  = ratio<                    1'000'000'000, 1>;
+ using tera  = ratio<                1'000'000'000'000, 1>;
+ using peta  = ratio<            1'000'000'000'000'000, 1>;
+ using exa   = ratio<        1'000'000'000'000'000'000, 1>;
+ using zetta = ratio<    1'000'000'000'000'000'000'000, 1>;  // see below
+ using yotta = ratio<1'000'000'000'000'000'000'000'000, 1>;  // see below
 }
 ```
 ### Class template `ratio` <a id="ratio.ratio">[[ratio.ratio]]</a>
   template <intmax_t N, intmax_t D = 1>
   class ratio {
   public:
     static constexpr intmax_t num;
     static constexpr intmax_t den;
+ using type = ratio<num, den>;
   };
 }
 ```
 If the template argument `D` is zero or the absolute values of either of
 the template arguments `N` and `D` is not representable by type
+`intmax_t`, the program is ill-formed.
+[*Note 1*: These rules ensure that infinite ratios are avoided and that
+for any negative input, there exists a representable value of its
+absolute value which is positive. In a two’s complement representation,
+this excludes the most negative value. — *end note*]
 The static data members `num` and `den` shall have the following values,
 where `gcd` represents the greatest common divisor of the absolute
 values of `N` and `D`:
 |                          | `R2::num * R1::den`   |                     |
 | `ratio_multiply<R1, R2>` | `R1::num * R2::num`   | `R1::den * R2::den` |
 | `ratio_divide<R1, R2>`   | `R1::num * R2::den`   | `R1::den * R2::num` |
+[*Example 1*:
 ``` cpp
 static_assert(ratio_add<ratio<1, 3>, ratio<1, 6>>::num == 1, "1/3+1/6 == 1/2");
 static_assert(ratio_add<ratio<1, 3>, ratio<1, 6>>::den == 2, "1/3+1/6 == 1/2");
 static_assert(ratio_multiply<ratio<1, 3>, ratio<3, 2>>::num == 1, "1/3*3/2 == 1/2");
 static_assert(ratio_multiply<ratio<1, 3>, ratio<3, 2>>::den == 2, "1/3*3/2 == 1/2");
   "1/MAX * MAX/2 == 1/2");
 static_assert(ratio_multiply<ratio<1, INT_MAX>, ratio<INT_MAX, 2>>::den == 2,
   "1/MAX * MAX/2 == 1/2");
 ```
+— *end example*]
 ### Comparison of `ratio`s <a id="ratio.comparison">[[ratio.comparison]]</a>
 ``` cpp
+template <class R1, class R2>
+ struct ratio_equal : bool_constant<R1::num == R2::num && R1::den == R2::den> { };
 ```
 ``` cpp
+template <class R1, class R2>
+ struct ratio_not_equal : bool_constant<!ratio_equal_v<R1, R2>> { };
 ```
 ``` cpp
+template <class R1, class R2>
+ struct ratio_less : bool_constant<see below> { };
 ```
+If `R1::num` × `R2::den` is less than `R2::num` × `R1::den`,
+`ratio_less<R1, R2>` shall be derived from `bool_constant<true>`;
+otherwise it shall be derived from `bool_constant<false>`.
+Implementations may use other algorithms to compute this relationship to
+avoid overflow. If overflow occurs, the program is ill-formed.
 ``` cpp
+template <class R1, class R2>
+ struct ratio_less_equal : bool_constant<!ratio_less_v<R2, R1>> { };
 ```
 ``` cpp
+template <class R1, class R2>
+ struct ratio_greater : bool_constant<ratio_less_v<R2, R1>> { };
 ```
 ``` cpp
+template <class R1, class R2>
+ struct ratio_greater_equal : bool_constant<!ratio_less_v<R1, R2>> { };
 ```
 ### SI types for `ratio` <a id="ratio.si">[[ratio.si]]</a>
+For each of the *typedef-name*s `yocto`, `zepto`, `zetta`, and `yotta`,
+if both of the constants used in its specification are representable by
 `intmax_t`, the typedef shall be defined; if either of the constants is
 not representable by `intmax_t`, the typedef shall not be defined.

Diff to HTML by rtfpessoa