[time.duration] - C++14 → C++17

Files changed (1) hide show

tmp/tmpkknhaxxn/{from.md → to.md} +158 -91

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

@@ -8,119 +8,129 @@ as a rational constant using the template `ratio`.
 ``` cpp
 template <class Rep, class Period = ratio<1>>
 class duration {
 public:
- typedef Rep    rep;
- typedef Period period;
 private:
   rep rep_;  // exposition only
 public:
-  // [time.duration.cons], construct/copy/destroy:
   constexpr duration() = default;
   template <class Rep2>
       constexpr explicit duration(const Rep2& r);
   template <class Rep2, class Period2>
      constexpr duration(const duration<Rep2, Period2>& d);
   ~duration() = default;
   duration(const duration&) = default;
   duration& operator=(const duration&) = default;
-  // [time.duration.observer], observer:
   constexpr rep count() const;
-  // [time.duration.arithmetic], arithmetic:
-  constexpr duration operator+() const;
-  constexpr duration operator-() const;
-  duration& operator++();
-  duration  operator++(int);
-  duration& operator--();
-  duration  operator--(int);
-  duration& operator+=(const duration& d);
-  duration& operator-=(const duration& d);
-  duration& operator*=(const rep& rhs);
-  duration& operator/=(const rep& rhs);
-  duration& operator%=(const rep& rhs);
-  duration& operator%=(const duration& rhs);
-  // [time.duration.special], special values:
   static constexpr duration zero();
   static constexpr duration min();
   static constexpr duration max();
 };
 ```
-*Requires:* `Rep` shall be an arithmetic type or a class emulating an
-arithmetic type.
-*Remarks:* If `duration` is instantiated with a `duration` type for the
-template argument `Rep`, the program is ill-formed.
-*Remarks:* If `Period` is not a specialization of `ratio`, the program
-is ill-formed.
-*Remarks:* If `Period::num` is not positive, the program is ill-formed.
-*Requires:* Members of `duration` shall not throw exceptions other than
-those thrown by the indicated operations on their representations.
-*Remarks:* The defaulted copy constructor of duration shall be a
-`constexpr` function if and only if the required initialization of the
-member `rep_` for copy and move, respectively, would satisfy the
-requirements for a `constexpr` function.
 ``` cpp
 duration<long, ratio<60>> d0;       // holds a count of minutes using a long
 duration<long long, milli> d1;      // holds a count of milliseconds using a long long
 duration<double, ratio<1, 30>>  d2; // holds a count with a tick period of $\frac{1}{30}$ of a second
                                     // (30 Hz) using a double
 ```
 #### `duration` constructors <a id="time.duration.cons">[[time.duration.cons]]</a>
 ``` cpp
 template <class Rep2>
   constexpr explicit duration(const Rep2& r);
 ```
 *Remarks:* This constructor shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `rep` and
-- `treat_as_floating_point<rep>::value` is `true` or
-- `treat_as_floating_point<Rep2>::value` is `false`.
 ``` cpp
 duration<int, milli> d(3);          // OK
 duration<int, milli> d(3.5);        // error
 ```
 *Effects:* Constructs an object of type `duration`.
-`count() == static_cast<rep>(r)`.
 ``` cpp
 template <class Rep2, class Period2>
   constexpr duration(const duration<Rep2, Period2>& d);
 ```
 *Remarks:* This constructor shall not participate in overload resolution
 unless no overflow is induced in the conversion and
-`treat_as_floating_point<rep>::value` is `true` or both
 `ratio_divide<Period2, period>::den` is `1` and
-`treat_as_floating_point<Rep2>::value` is `false`. This requirement
-prevents implicit truncation error when converting between
-integral-based `duration` types. Such a construction could easily lead
-to confusion about the value of the `duration`.
 ``` cpp
 duration<int, milli> ms(3);
 duration<int, micro> us = ms;       // OK
 duration<int, milli> ms2 = us;      // error
 ```
 *Effects:* Constructs an object of type `duration`, constructing `rep_`
 from
 `duration_cast<duration>(d).count()`.
 #### `duration` observer <a id="time.duration.observer">[[time.duration.observer]]</a>
@@ -132,94 +142,94 @@ constexpr rep count() const;
 *Returns:* `rep_`.
 #### `duration` arithmetic <a id="time.duration.arithmetic">[[time.duration.arithmetic]]</a>
 ``` cpp
-constexpr duration operator+() const;
 ```
-*Returns:* `*this`.
 ``` cpp
-constexpr duration operator-() const;
 ```
-*Returns:* `duration(-rep_);`.
 ``` cpp
-duration& operator++();
 ```
-*Effects:* `++rep_`.
 *Returns:* `*this`.
 ``` cpp
-duration operator++(int);
 ```
-*Returns:* `duration(rep_++);`.
 ``` cpp
-duration& operator--();
 ```
-*Effects:* `-``-``rep_`.
 *Returns:* `*this`.
 ``` cpp
-duration operator--(int);
 ```
-*Returns:* `duration(rep_--);`.
 ``` cpp
-duration& operator+=(const duration& d);
 ```
-*Effects:* `rep_ += d.count()`.
 *Returns:* `*this`.
 ``` cpp
-duration& operator-=(const duration& d);
 ```
-*Effects:* `rep_ -= d.count()`.
 *Returns:* `*this`.
 ``` cpp
-duration& operator*=(const rep& rhs);
 ```
-*Effects:* `rep_ *= rhs`.
 *Returns:* `*this`.
 ``` cpp
-duration& operator/=(const rep& rhs);
 ```
-*Effects:* `rep_ /= rhs`.
 *Returns:* `*this`.
 ``` cpp
-duration& operator%=(const rep& rhs);
 ```
-*Effects:* `rep_ %= rhs`.
 *Returns:* `*this`.
 ``` cpp
-duration& operator%=(const duration& rhs);
 ```
-*Effects:* `rep_ %= rhs.count()`.
 *Returns:* `*this`.
 #### `duration` special values <a id="time.duration.special">[[time.duration.special]]</a>
@@ -250,30 +260,30 @@ type of the function. `CR(A,B)` represents `common_type_t<A, B>`.
 template <class Rep1, class Period1, class Rep2, class Period2>
   constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
   operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
-*Returns:* CD(CD(lhs).count() + CD(rhs).count()).
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
   constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
   operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
-*Returns:* CD(CD(lhs).count() - CD(rhs).count()).
 ``` cpp
 template <class Rep1, class Period, class Rep2>
   constexpr duration<common_type_t<Rep1, Rep2>, Period>
   operator*(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)`.
-*Returns:* CD(CD(d).count() \* s).
 ``` cpp
 template <class Rep1, class Rep2, class Period>
   constexpr duration<common_type_t<Rep1, Rep2>, Period>
   operator*(const Rep1& s, const duration<Rep2, Period>& d);
@@ -290,13 +300,13 @@ template <class Rep1, class Period, class Rep2>
   operator/(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)` and `Rep2`
-is not an instantiation of `duration`.
-*Returns:* CD(CD(d).count() / s).
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
   constexpr common_type_t<Rep1, Rep2>
   operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
@@ -310,66 +320,72 @@ template <class Rep1, class Period, class Rep2>
   operator%(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)` and `Rep2`
-is not an instantiation of `duration`.
-*Returns:* CD(CD(d).count() % s).
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
   constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
   operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
-*Returns:* CD(CD(lhs).count() % CD(rhs).count()).
 #### `duration` comparisons <a id="time.duration.comparisons">[[time.duration.comparisons]]</a>
 In the function descriptions that follow, `CT` represents
 `common_type_t<A, B>`, where `A` and `B` are the types of the two
 arguments to the function.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
-*Returns:* `CT(lhs).count() == CT(rhs).count()`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `!(lhs == rhs)`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr bool operator<(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
-*Returns:* `CT(lhs).count() < CT(rhs).count()`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `!(rhs < lhs)`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr bool operator>(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `rhs < lhs`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `!(lhs < rhs)`.
 #### `duration_cast` <a id="time.duration.cast">[[time.duration.cast]]</a>
@@ -378,15 +394,15 @@ template <class Rep1, class Period1, class Rep2, class Period2>
 template <class ToDuration, class Rep, class Period>
   constexpr ToDuration duration_cast(const duration<Rep, Period>& d);
 ```
 *Remarks:* This function shall not participate in overload resolution
-unless `ToDuration` is an instantiation of `duration`.
 *Returns:* Let `CF` be
 `ratio_divide<Period, typename ToDuration::period>`, and `CR` be
-`common_type<` `typename ToDuration::rep, Rep, intmax_t>::type.`
 - If `CF::num == 1` and `CF::den == 1`, returns
   ``` cpp
   ToDuration(static_cast<typename ToDuration::rep>(d.count()))
   ```
@@ -404,42 +420,81 @@ unless `ToDuration` is an instantiation of `duration`.
   ``` cpp
   ToDuration(static_cast<typename ToDuration::rep>(
     static_cast<CR>(d.count()) * static_cast<CR>(CF::num) / static_cast<CR>(CF::den)))
   ```
-*Notes:* This function does not use any implicit conversions; all
 conversions are done with `static_cast`. It avoids multiplications and
 divisions when it is known at compile time that one or more arguments
 is 1. Intermediate computations are carried out in the widest
 representation and only converted to the destination representation at
-the final step.
 #### Suffixes for duration literals <a id="time.duration.literals">[[time.duration.literals]]</a>
 This section describes literal suffixes for constructing duration
 literals. The suffixes `h`, `min`, `s`, `ms`, `us`, `ns` denote duration
 values of the corresponding types `hours`, `minutes`, `seconds`,
 `milliseconds`, `microseconds`, and `nanoseconds` respectively if they
 are applied to integral literals.
-If any of these suffixes are applied to a floating point literal the
-result is a `chrono::duration` literal with an unspecified floating
-point representation.
 If any of these suffixes are applied to an integer literal and the
 resulting `chrono::duration` value cannot be represented in the result
 type because of overflow, the program is ill-formed.
 The following code shows some duration literals.
 ``` cpp
 using namespace std::chrono_literals;
 auto constexpr aday=24h;
 auto constexpr lesson=45min;
 auto constexpr halfanhour=0.5h;
 ```
 ``` cpp
 constexpr chrono::hours                                 operator""h(unsigned long long hours);
 constexpr chrono::duration<unspecified, ratio<3600, 1>> operator""h(long double hours);
 ```
@@ -451,19 +506,19 @@ constexpr chrono::duration<unspecified, ratio<60,1>> operator "" min(long double
 ```
 *Returns:* A `duration` literal representing `minutes` minutes.
 ``` cpp
-constexpr chrono::seconds operator "" s(unsigned long long sec);
 constexpr chrono::duration<unspecified> operator""s(long double sec);
 ```
 *Returns:* A `duration` literal representing `sec` seconds.
-The same suffix `s` is used for `basic_string` but there is no conflict,
-since duration suffixes apply to numbers and string literal suffixes
-apply to character array literals.
 ``` cpp
 constexpr chrono::milliseconds                 operator""ms(unsigned long long msec);
 constexpr chrono::duration<unspecified, milli> operator""ms(long double msec);
 ```
@@ -482,5 +537,17 @@ constexpr chrono::nanoseconds                  operator "" ns(unsigned long long
 constexpr chrono::duration<unspecified, nano> operator""ns(long double nsec);
 ```
 *Returns:* A `duration` literal representing `nsec` nanoseconds.

 ``` cpp
 template <class Rep, class Period = ratio<1>>
 class duration {
 public:
+ using rep    = Rep;
+ using period = typename Period::type;
 private:
   rep rep_;  // exposition only
 public:
+  // [time.duration.cons], construct/copy/destroy
   constexpr duration() = default;
   template <class Rep2>
       constexpr explicit duration(const Rep2& r);
   template <class Rep2, class Period2>
      constexpr duration(const duration<Rep2, Period2>& d);
   ~duration() = default;
   duration(const duration&) = default;
   duration& operator=(const duration&) = default;
+  // [time.duration.observer], observer
   constexpr rep count() const;
+  // [time.duration.arithmetic], arithmetic
+  constexpr common_type_t<duration> operator+() const;
+  constexpr common_type_t<duration> operator-() const;
+ constexpr duration& operator++();
+ constexpr duration  operator++(int);
+ constexpr duration& operator--();
+ constexpr duration  operator--(int);
+ constexpr duration& operator+=(const duration& d);
+ constexpr duration& operator-=(const duration& d);
+ constexpr duration& operator*=(const rep& rhs);
+ constexpr duration& operator/=(const rep& rhs);
+ constexpr duration& operator%=(const rep& rhs);
+ constexpr duration& operator%=(const duration& rhs);
+  // [time.duration.special], special values
   static constexpr duration zero();
   static constexpr duration min();
   static constexpr duration max();
 };
 ```
+`Rep` shall be an arithmetic type or a class emulating an arithmetic
+type. If `duration` is instantiated with a `duration` type as the
+argument for the template parameter `Rep`, the program is ill-formed.
+If `Period` is not a specialization of `ratio`, the program is
+ill-formed. If `Period::num` is not positive, the program is ill-formed.
+Members of `duration` shall not throw exceptions other than those thrown
+by the indicated operations on their representations.
+The defaulted copy constructor of duration shall be a constexpr function
+if and only if the required initialization of the member `rep_` for copy
+and move, respectively, would satisfy the requirements for a constexpr
+function.
+[*Example 1*:
 ``` cpp
 duration<long, ratio<60>> d0;       // holds a count of minutes using a long
 duration<long long, milli> d1;      // holds a count of milliseconds using a long long
 duration<double, ratio<1, 30>>  d2; // holds a count with a tick period of $\frac{1}{30}$ of a second
                                     // (30 Hz) using a double
 ```
+— *end example*]
 #### `duration` constructors <a id="time.duration.cons">[[time.duration.cons]]</a>
 ``` cpp
 template <class Rep2>
   constexpr explicit duration(const Rep2& r);
 ```
 *Remarks:* This constructor shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `rep` and
+- `treat_as_floating_point_v<rep>` is `true` or
+- `treat_as_floating_point_v<Rep2>` is `false`.
+[*Example 1*:
 ``` cpp
 duration<int, milli> d(3);          // OK
 duration<int, milli> d(3.5);        // error
 ```
+— *end example*]
 *Effects:* Constructs an object of type `duration`.
+*Postconditions:* `count() == static_cast<rep>(r)`.
 ``` cpp
 template <class Rep2, class Period2>
   constexpr duration(const duration<Rep2, Period2>& d);
 ```
 *Remarks:* This constructor shall not participate in overload resolution
 unless no overflow is induced in the conversion and
+`treat_as_floating_point_v<rep>` is `true` or both
 `ratio_divide<Period2, period>::den` is `1` and
+`treat_as_floating_point_v<Rep2>` is `false`.
+[*Note 1*: This requirement prevents implicit truncation error when
+converting between integral-based `duration` types. Such a construction
+could easily lead to confusion about the value of the
+`duration`. — *end note*]
+[*Example 2*:
 ``` cpp
 duration<int, milli> ms(3);
 duration<int, micro> us = ms;       // OK
 duration<int, milli> ms2 = us;      // error
 ```
+— *end example*]
 *Effects:* Constructs an object of type `duration`, constructing `rep_`
 from
 `duration_cast<duration>(d).count()`.
 #### `duration` observer <a id="time.duration.observer">[[time.duration.observer]]</a>
 *Returns:* `rep_`.
 #### `duration` arithmetic <a id="time.duration.arithmetic">[[time.duration.arithmetic]]</a>
 ``` cpp
+constexpr common_type_t<duration> operator+() const;
 ```
+*Returns:* `common_type_t<duration>(*this)`.
 ``` cpp
+constexpr common_type_t<duration> operator-() const;
 ```
+*Returns:* `common_type_t<duration>(-rep_)`.
 ``` cpp
+constexpr duration& operator++();
 ```
+*Effects:* As if by `++rep_`.
 *Returns:* `*this`.
 ``` cpp
+constexpr duration operator++(int);
 ```
+*Returns:* `duration(rep_++)`.
 ``` cpp
+constexpr duration& operator--();
 ```
+*Effects:* As if by `–rep_`.
 *Returns:* `*this`.
 ``` cpp
+constexpr duration operator--(int);
 ```
+*Returns:* `duration(rep_--)`.
 ``` cpp
+constexpr duration& operator+=(const duration& d);
 ```
+*Effects:* As if by: `rep_ += d.count();`
 *Returns:* `*this`.
 ``` cpp
+constexpr duration& operator-=(const duration& d);
 ```
+*Effects:* As if by: `rep_ -= d.count();`
 *Returns:* `*this`.
 ``` cpp
+constexpr duration& operator*=(const rep& rhs);
 ```
+*Effects:* As if by: `rep_ *= rhs;`
 *Returns:* `*this`.
 ``` cpp
+constexpr duration& operator/=(const rep& rhs);
 ```
+*Effects:* As if by: `rep_ /= rhs;`
 *Returns:* `*this`.
 ``` cpp
+constexpr duration& operator%=(const rep& rhs);
 ```
+*Effects:* As if by: `rep_ %= rhs;`
 *Returns:* `*this`.
 ``` cpp
+constexpr duration& operator%=(const duration& rhs);
 ```
+*Effects:* As if by: `rep_ %= rhs.count();`
 *Returns:* `*this`.
 #### `duration` special values <a id="time.duration.special">[[time.duration.special]]</a>
 template <class Rep1, class Period1, class Rep2, class Period2>
   constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
   operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
+*Returns:* `CD(CD(lhs).count() + CD(rhs).count())`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
   constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
   operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
+*Returns:* `CD(CD(lhs).count() - CD(rhs).count())`.
 ``` cpp
 template <class Rep1, class Period, class Rep2>
   constexpr duration<common_type_t<Rep1, Rep2>, Period>
   operator*(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)`.
+*Returns:* `CD(CD(d).count() * s)`.
 ``` cpp
 template <class Rep1, class Rep2, class Period>
   constexpr duration<common_type_t<Rep1, Rep2>, Period>
   operator*(const Rep1& s, const duration<Rep2, Period>& d);
   operator/(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)` and `Rep2`
+is not a specialization of `duration`.
+*Returns:* `CD(CD(d).count() / s)`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
   constexpr common_type_t<Rep1, Rep2>
   operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
   operator%(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)` and `Rep2`
+is not a specialization of `duration`.
+*Returns:* `CD(CD(d).count() % s)`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
   constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
   operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
+*Returns:* `CD(CD(lhs).count() % CD(rhs).count())`.
 #### `duration` comparisons <a id="time.duration.comparisons">[[time.duration.comparisons]]</a>
 In the function descriptions that follow, `CT` represents
 `common_type_t<A, B>`, where `A` and `B` are the types of the two
 arguments to the function.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
+  constexpr bool operator==(const duration<Rep1, Period1>& lhs,
+                            const duration<Rep2, Period2>& rhs);
 ```
+*Returns:* *`CT`*`(lhs).count() == `*`CT`*`(rhs).count()`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
+  constexpr bool operator!=(const duration<Rep1, Period1>& lhs,
+                            const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `!(lhs == rhs)`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
+  constexpr bool operator<(const duration<Rep1, Period1>& lhs,
+                           const duration<Rep2, Period2>& rhs);
 ```
+*Returns:* *`CT`*`(lhs).count() < `*`CT`*`(rhs).count()`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
+  constexpr bool operator<=(const duration<Rep1, Period1>& lhs,
+                            const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `!(rhs < lhs)`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
+  constexpr bool operator>(const duration<Rep1, Period1>& lhs,
+                           const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `rhs < lhs`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
+  constexpr bool operator>=(const duration<Rep1, Period1>& lhs,
+                            const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `!(lhs < rhs)`.
 #### `duration_cast` <a id="time.duration.cast">[[time.duration.cast]]</a>
 template <class ToDuration, class Rep, class Period>
   constexpr ToDuration duration_cast(const duration<Rep, Period>& d);
 ```
 *Remarks:* This function shall not participate in overload resolution
+unless `ToDuration` is a specialization of `duration`.
 *Returns:* Let `CF` be
 `ratio_divide<Period, typename ToDuration::period>`, and `CR` be
+`common_type<` `typename ToDuration::rep, Rep, intmax_t>::type`.
 - If `CF::num == 1` and `CF::den == 1`, returns
   ``` cpp
   ToDuration(static_cast<typename ToDuration::rep>(d.count()))
   ```
   ``` cpp
   ToDuration(static_cast<typename ToDuration::rep>(
     static_cast<CR>(d.count()) * static_cast<CR>(CF::num) / static_cast<CR>(CF::den)))
   ```
+[*Note 1*: This function does not use any implicit conversions; all
 conversions are done with `static_cast`. It avoids multiplications and
 divisions when it is known at compile time that one or more arguments
 is 1. Intermediate computations are carried out in the widest
 representation and only converted to the destination representation at
+the final step. — *end note*]
+``` cpp
+template <class ToDuration, class Rep, class Period>
+  constexpr ToDuration floor(const duration<Rep, Period>& d);
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `ToDuration` is a specialization of `duration`.
+*Returns:* The greatest result `t` representable in `ToDuration` for
+which `t <= d`.
+``` cpp
+template <class ToDuration, class Rep, class Period>
+  constexpr ToDuration ceil(const duration<Rep, Period>& d);
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `ToDuration` is a specialization of `duration`.
+*Returns:* The least result `t` representable in `ToDuration` for which
+`t >= d`.
+``` cpp
+template <class ToDuration, class Rep, class Period>
+  constexpr ToDuration round(const duration<Rep, Period>& d);
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `ToDuration` is a specialization of `duration`, and
+`treat_as_floating_point_v<typename ToDuration::rep>` is `false`.
+*Returns:* The value of `ToDuration` that is closest to `d`. If there
+are two closest values, then return the value `t` for which
+`t % 2 == 0`.
 #### Suffixes for duration literals <a id="time.duration.literals">[[time.duration.literals]]</a>
 This section describes literal suffixes for constructing duration
 literals. The suffixes `h`, `min`, `s`, `ms`, `us`, `ns` denote duration
 values of the corresponding types `hours`, `minutes`, `seconds`,
 `milliseconds`, `microseconds`, and `nanoseconds` respectively if they
 are applied to integral literals.
+If any of these suffixes are applied to a floating-point literal the
+result is a `chrono::duration` literal with an unspecified
+floating-point representation.
 If any of these suffixes are applied to an integer literal and the
 resulting `chrono::duration` value cannot be represented in the result
 type because of overflow, the program is ill-formed.
+[*Example 1*:
 The following code shows some duration literals.
 ``` cpp
 using namespace std::chrono_literals;
 auto constexpr aday=24h;
 auto constexpr lesson=45min;
 auto constexpr halfanhour=0.5h;
 ```
+— *end example*]
 ``` cpp
 constexpr chrono::hours                                 operator""h(unsigned long long hours);
 constexpr chrono::duration<unspecified, ratio<3600, 1>> operator""h(long double hours);
 ```
 ```
 *Returns:* A `duration` literal representing `minutes` minutes.
 ``` cpp
+constexpr chrono::seconds  \itcorr             operator""s(unsigned long long sec);
 constexpr chrono::duration<unspecified> operator""s(long double sec);
 ```
 *Returns:* A `duration` literal representing `sec` seconds.
+[*Note 1*: The same suffix `s` is used for `basic_string` but there is
+no conflict, since duration suffixes apply to numbers and string literal
+suffixes apply to character array literals. — *end note*]
 ``` cpp
 constexpr chrono::milliseconds                 operator""ms(unsigned long long msec);
 constexpr chrono::duration<unspecified, milli> operator""ms(long double msec);
 ```
 constexpr chrono::duration<unspecified, nano> operator""ns(long double nsec);
 ```
 *Returns:* A `duration` literal representing `nsec` nanoseconds.
+#### `duration` algorithms <a id="time.duration.alg">[[time.duration.alg]]</a>
+``` cpp
+template <class Rep, class Period>
+  constexpr duration<Rep, Period> abs(duration<Rep, Period> d);
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `numeric_limits<Rep>::is_signed` is `true`.
+*Returns:* If `d >= d.zero()`, return `d`, otherwise return `-d`.

Diff to HTML by rtfpessoa