2 //===---------------------------- ratio -----------------------------------===//
4 // The LLVM Compiler Infrastructure
6 // This file is dual licensed under the MIT and the University of Illinois Open
7 // Source Licenses. See LICENSE.TXT for details.
9 //===----------------------------------------------------------------------===//
20 template <intmax_t N, intmax_t D = 1>
24 static const intmax_t num;
25 static const intmax_t den;
26 typedef ratio<num, den> type;
30 template <class R1, class R2> using ratio_add = ...;
31 template <class R1, class R2> using ratio_subtract = ...;
32 template <class R1, class R2> using ratio_multiply = ...;
33 template <class R1, class R2> using ratio_divide = ...;
36 template <class R1, class R2> struct ratio_equal;
37 template <class R1, class R2> struct ratio_not_equal;
38 template <class R1, class R2> struct ratio_less;
39 template <class R1, class R2> struct ratio_less_equal;
40 template <class R1, class R2> struct ratio_greater;
41 template <class R1, class R2> struct ratio_greater_equal;
43 // convenience SI typedefs
44 typedef ratio<1, 1000000000000000000000000> yocto; // not supported
45 typedef ratio<1, 1000000000000000000000> zepto; // not supported
46 typedef ratio<1, 1000000000000000000> atto;
47 typedef ratio<1, 1000000000000000> femto;
48 typedef ratio<1, 1000000000000> pico;
49 typedef ratio<1, 1000000000> nano;
50 typedef ratio<1, 1000000> micro;
51 typedef ratio<1, 1000> milli;
52 typedef ratio<1, 100> centi;
53 typedef ratio<1, 10> deci;
54 typedef ratio< 10, 1> deca;
55 typedef ratio< 100, 1> hecto;
56 typedef ratio< 1000, 1> kilo;
57 typedef ratio< 1000000, 1> mega;
58 typedef ratio< 1000000000, 1> giga;
59 typedef ratio< 1000000000000, 1> tera;
60 typedef ratio< 1000000000000000, 1> peta;
61 typedef ratio< 1000000000000000000, 1> exa;
62 typedef ratio< 1000000000000000000000, 1> zetta; // not supported
63 typedef ratio<1000000000000000000000000, 1> yotta; // not supported
71 #include <type_traits>
73 #include <__undef_min_max>
75 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
76 #pragma GCC system_header
79 _LIBCPP_BEGIN_NAMESPACE_STD
83 template <intmax_t _Xp, intmax_t _Yp>
86 static const intmax_t value = __static_gcd<_Yp, _Xp % _Yp>::value;
89 template <intmax_t _Xp>
90 struct __static_gcd<_Xp, 0>
92 static const intmax_t value = _Xp;
96 struct __static_gcd<0, 0>
98 static const intmax_t value = 1;
103 template <intmax_t _Xp, intmax_t _Yp>
106 static const intmax_t value = _Xp / __static_gcd<_Xp, _Yp>::value * _Yp;
109 template <intmax_t _Xp>
112 static const intmax_t value = _Xp < 0 ? -_Xp : _Xp;
115 template <intmax_t _Xp>
118 static const intmax_t value = _Xp == 0 ? 0 : (_Xp < 0 ? -1 : 1);
121 template <intmax_t _Xp, intmax_t _Yp, intmax_t = __static_sign<_Yp>::value>
124 template <intmax_t _Xp, intmax_t _Yp>
125 class __ll_add<_Xp, _Yp, 1>
127 static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
128 static const intmax_t max = -min;
130 static_assert(_Xp <= max - _Yp, "overflow in __ll_add");
132 static const intmax_t value = _Xp + _Yp;
135 template <intmax_t _Xp, intmax_t _Yp>
136 class __ll_add<_Xp, _Yp, 0>
139 static const intmax_t value = _Xp;
142 template <intmax_t _Xp, intmax_t _Yp>
143 class __ll_add<_Xp, _Yp, -1>
145 static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
146 static const intmax_t max = -min;
148 static_assert(min - _Yp <= _Xp, "overflow in __ll_add");
150 static const intmax_t value = _Xp + _Yp;
153 template <intmax_t _Xp, intmax_t _Yp, intmax_t = __static_sign<_Yp>::value>
156 template <intmax_t _Xp, intmax_t _Yp>
157 class __ll_sub<_Xp, _Yp, 1>
159 static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
160 static const intmax_t max = -min;
162 static_assert(min + _Yp <= _Xp, "overflow in __ll_sub");
164 static const intmax_t value = _Xp - _Yp;
167 template <intmax_t _Xp, intmax_t _Yp>
168 class __ll_sub<_Xp, _Yp, 0>
171 static const intmax_t value = _Xp;
174 template <intmax_t _Xp, intmax_t _Yp>
175 class __ll_sub<_Xp, _Yp, -1>
177 static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
178 static const intmax_t max = -min;
180 static_assert(_Xp <= max + _Yp, "overflow in __ll_sub");
182 static const intmax_t value = _Xp - _Yp;
185 template <intmax_t _Xp, intmax_t _Yp>
188 static const intmax_t nan = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1));
189 static const intmax_t min = nan + 1;
190 static const intmax_t max = -min;
191 static const intmax_t __a_x = __static_abs<_Xp>::value;
192 static const intmax_t __a_y = __static_abs<_Yp>::value;
194 static_assert(_Xp != nan && _Yp != nan && __a_x <= max / __a_y, "overflow in __ll_mul");
196 static const intmax_t value = _Xp * _Yp;
199 template <intmax_t _Yp>
200 class __ll_mul<0, _Yp>
203 static const intmax_t value = 0;
206 template <intmax_t _Xp>
207 class __ll_mul<_Xp, 0>
210 static const intmax_t value = 0;
217 static const intmax_t value = 0;
220 // Not actually used but left here in case needed in future maintenance
221 template <intmax_t _Xp, intmax_t _Yp>
224 static const intmax_t nan = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1));
225 static const intmax_t min = nan + 1;
226 static const intmax_t max = -min;
228 static_assert(_Xp != nan && _Yp != nan && _Yp != 0, "overflow in __ll_div");
230 static const intmax_t value = _Xp / _Yp;
233 template <intmax_t _Num, intmax_t _Den = 1>
234 class _LIBCPP_TYPE_VIS_ONLY ratio
236 static_assert(__static_abs<_Num>::value >= 0, "ratio numerator is out of range");
237 static_assert(_Den != 0, "ratio divide by 0");
238 static_assert(__static_abs<_Den>::value > 0, "ratio denominator is out of range");
239 static const intmax_t __na = __static_abs<_Num>::value;
240 static const intmax_t __da = __static_abs<_Den>::value;
241 static const intmax_t __s = __static_sign<_Num>::value * __static_sign<_Den>::value;
242 static const intmax_t __gcd = __static_gcd<__na, __da>::value;
244 static const intmax_t num = __s * __na / __gcd;
245 static const intmax_t den = __da / __gcd;
247 typedef ratio<num, den> type;
250 template <intmax_t _Num, intmax_t _Den> const intmax_t ratio<_Num, _Den>::num;
251 template <intmax_t _Num, intmax_t _Den> const intmax_t ratio<_Num, _Den>::den;
253 template <class _Tp> struct __is_ratio : false_type {};
254 template <intmax_t _Num, intmax_t _Den> struct __is_ratio<ratio<_Num, _Den> > : true_type {};
256 typedef ratio<1LL, 1000000000000000000LL> atto;
257 typedef ratio<1LL, 1000000000000000LL> femto;
258 typedef ratio<1LL, 1000000000000LL> pico;
259 typedef ratio<1LL, 1000000000LL> nano;
260 typedef ratio<1LL, 1000000LL> micro;
261 typedef ratio<1LL, 1000LL> milli;
262 typedef ratio<1LL, 100LL> centi;
263 typedef ratio<1LL, 10LL> deci;
264 typedef ratio< 10LL, 1LL> deca;
265 typedef ratio< 100LL, 1LL> hecto;
266 typedef ratio< 1000LL, 1LL> kilo;
267 typedef ratio< 1000000LL, 1LL> mega;
268 typedef ratio< 1000000000LL, 1LL> giga;
269 typedef ratio< 1000000000000LL, 1LL> tera;
270 typedef ratio< 1000000000000000LL, 1LL> peta;
271 typedef ratio<1000000000000000000LL, 1LL> exa;
273 template <class _R1, class _R2>
274 struct __ratio_multiply
277 static const intmax_t __gcd_n1_d2 = __static_gcd<_R1::num, _R2::den>::value;
278 static const intmax_t __gcd_d1_n2 = __static_gcd<_R1::den, _R2::num>::value;
280 typedef typename ratio
282 __ll_mul<_R1::num / __gcd_n1_d2, _R2::num / __gcd_d1_n2>::value,
283 __ll_mul<_R2::den / __gcd_n1_d2, _R1::den / __gcd_d1_n2>::value
287 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
289 template <class _R1, class _R2> using ratio_multiply
290 = typename __ratio_multiply<_R1, _R2>::type;
292 #else // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
294 template <class _R1, class _R2>
295 struct _LIBCPP_TYPE_VIS_ONLY ratio_multiply
296 : public __ratio_multiply<_R1, _R2>::type {};
298 #endif // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
300 template <class _R1, class _R2>
301 struct __ratio_divide
304 static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
305 static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
307 typedef typename ratio
309 __ll_mul<_R1::num / __gcd_n1_n2, _R2::den / __gcd_d1_d2>::value,
310 __ll_mul<_R2::num / __gcd_n1_n2, _R1::den / __gcd_d1_d2>::value
314 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
316 template <class _R1, class _R2> using ratio_divide
317 = typename __ratio_divide<_R1, _R2>::type;
319 #else // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
321 template <class _R1, class _R2>
322 struct _LIBCPP_TYPE_VIS_ONLY ratio_divide
323 : public __ratio_divide<_R1, _R2>::type {};
325 #endif // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
327 template <class _R1, class _R2>
331 static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
332 static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
334 typedef typename ratio_multiply
336 ratio<__gcd_n1_n2, _R1::den / __gcd_d1_d2>,
341 __ll_mul<_R1::num / __gcd_n1_n2, _R2::den / __gcd_d1_d2>::value,
342 __ll_mul<_R2::num / __gcd_n1_n2, _R1::den / __gcd_d1_d2>::value
349 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
351 template <class _R1, class _R2> using ratio_add
352 = typename __ratio_add<_R1, _R2>::type;
354 #else // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
356 template <class _R1, class _R2>
357 struct _LIBCPP_TYPE_VIS_ONLY ratio_add
358 : public __ratio_add<_R1, _R2>::type {};
360 #endif // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
362 template <class _R1, class _R2>
363 struct __ratio_subtract
366 static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
367 static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
369 typedef typename ratio_multiply
371 ratio<__gcd_n1_n2, _R1::den / __gcd_d1_d2>,
376 __ll_mul<_R1::num / __gcd_n1_n2, _R2::den / __gcd_d1_d2>::value,
377 __ll_mul<_R2::num / __gcd_n1_n2, _R1::den / __gcd_d1_d2>::value
384 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
386 template <class _R1, class _R2> using ratio_subtract
387 = typename __ratio_subtract<_R1, _R2>::type;
389 #else // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
391 template <class _R1, class _R2>
392 struct _LIBCPP_TYPE_VIS_ONLY ratio_subtract
393 : public __ratio_subtract<_R1, _R2>::type {};
395 #endif // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
399 template <class _R1, class _R2>
400 struct _LIBCPP_TYPE_VIS_ONLY ratio_equal
401 : public integral_constant<bool, _R1::num == _R2::num && _R1::den == _R2::den> {};
403 template <class _R1, class _R2>
404 struct _LIBCPP_TYPE_VIS_ONLY ratio_not_equal
405 : public integral_constant<bool, !ratio_equal<_R1, _R2>::value> {};
409 template <class _R1, class _R2, bool _Odd = false,
410 intmax_t _Q1 = _R1::num / _R1::den, intmax_t _M1 = _R1::num % _R1::den,
411 intmax_t _Q2 = _R2::num / _R2::den, intmax_t _M2 = _R2::num % _R2::den>
414 static const bool value = _Odd ? _Q2 < _Q1 : _Q1 < _Q2;
417 template <class _R1, class _R2, bool _Odd, intmax_t _Qp>
418 struct __ratio_less1<_R1, _R2, _Odd, _Qp, 0, _Qp, 0>
420 static const bool value = false;
423 template <class _R1, class _R2, bool _Odd, intmax_t _Qp, intmax_t _M2>
424 struct __ratio_less1<_R1, _R2, _Odd, _Qp, 0, _Qp, _M2>
426 static const bool value = !_Odd;
429 template <class _R1, class _R2, bool _Odd, intmax_t _Qp, intmax_t _M1>
430 struct __ratio_less1<_R1, _R2, _Odd, _Qp, _M1, _Qp, 0>
432 static const bool value = _Odd;
435 template <class _R1, class _R2, bool _Odd, intmax_t _Qp, intmax_t _M1,
437 struct __ratio_less1<_R1, _R2, _Odd, _Qp, _M1, _Qp, _M2>
439 static const bool value = __ratio_less1<ratio<_R1::den, _M1>,
440 ratio<_R2::den, _M2>, !_Odd>::value;
443 template <class _R1, class _R2, intmax_t _S1 = __static_sign<_R1::num>::value,
444 intmax_t _S2 = __static_sign<_R2::num>::value>
447 static const bool value = _S1 < _S2;
450 template <class _R1, class _R2>
451 struct __ratio_less<_R1, _R2, 1LL, 1LL>
453 static const bool value = __ratio_less1<_R1, _R2>::value;
456 template <class _R1, class _R2>
457 struct __ratio_less<_R1, _R2, -1LL, -1LL>
459 static const bool value = __ratio_less1<ratio<-_R2::num, _R2::den>, ratio<-_R1::num, _R1::den> >::value;
462 template <class _R1, class _R2>
463 struct _LIBCPP_TYPE_VIS_ONLY ratio_less
464 : public integral_constant<bool, __ratio_less<_R1, _R2>::value> {};
466 template <class _R1, class _R2>
467 struct _LIBCPP_TYPE_VIS_ONLY ratio_less_equal
468 : public integral_constant<bool, !ratio_less<_R2, _R1>::value> {};
470 template <class _R1, class _R2>
471 struct _LIBCPP_TYPE_VIS_ONLY ratio_greater
472 : public integral_constant<bool, ratio_less<_R2, _R1>::value> {};
474 template <class _R1, class _R2>
475 struct _LIBCPP_TYPE_VIS_ONLY ratio_greater_equal
476 : public integral_constant<bool, !ratio_less<_R1, _R2>::value> {};
478 template <class _R1, class _R2>
481 typedef ratio<__static_gcd<_R1::num, _R2::num>::value,
482 __static_lcm<_R1::den, _R2::den>::value> type;
485 _LIBCPP_END_NAMESPACE_STD
487 #endif // _LIBCPP_RATIO