```
template <class Rep> struct treat_as_floating_point
: is_floating_point<Rep> { };
```

The duration template uses the treat_as_floating_point trait to
help determine if a duration object can be converted to another
duration with a different tick period. If
treat_as_floating_point<Rep>::value is true, then implicit conversions
are allowed among durations. Otherwise, the implicit convertibility
depends on the tick periods of the durations.
[ *Note:*
The intention of this trait is to indicate whether a given class behaves like a floating-point
type, and thus allows division of one value by another with acceptable loss of precision. If
treat_as_floating_point<Rep>::value is false, Rep will be treated as
if it behaved like an integral type for the purpose of these conversions.
* — end note* ]

```
template <class Rep>
struct duration_values {
public:
static constexpr Rep zero();
static constexpr Rep min();
static constexpr Rep max();
};
```

The duration template uses the duration_values trait to construct special values of the durations representation (Rep). This is done because the representation might be a class type with behavior which requires some other implementation to return these special values. In that case, the author of that class type should specialize duration_values to return the indicated values.

*Returns:* Rep(0). [ *Note:* Rep(0) is specified instead of
Rep() because Rep() may have some other meaning, such as an
uninitialized value. * — end note* ]

*Remark:* The value returned shall be the additive identity.

*Returns:* numeric_limits<Rep>::lowest().

*Remark:* The value returned shall compare less than or equal to zero().

*Returns:* numeric_limits<Rep>::max().

*Remark:* The value returned shall compare greater than zero().

```
template <class Rep1, class Period1, class Rep2, class Period2>
struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>> {
typedef chrono::duration<common_type_t<Rep1, Rep2>,
```

*see below*> type;
};

The period of the duration indicated by this specialization of
common_type shall be the greatest common divisor of Period1 and
Period2. [ *Note:* This can be computed by forming a ratio of the
greatest common divisor of Period1::num and Period2::num and the
least common multiple of Period1::den and Period2::den.
* — end note* ]

[ *Note:* The typedef name type is a synonym for the
duration with the largest tick period possible where both
duration arguments will convert to it without requiring a division
operation. The representation of this type is intended to be able to hold any
value resulting from this conversion with no truncation error, although
floating-point durations may have round-off errors. * — end note* ]

```
template <class Clock, class Duration1, class Duration2>
struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>> {
typedef chrono::time_point<Clock, common_type_t<Duration1, Duration2>> type;
};
```

The common type of two time_point types is a time_point with the same clock as the two types and the common type of their two durations.