1// ratio.hpp ---------------------------------------------------------------//
2
3// Copyright 2008 Howard Hinnant
4// Copyright 2008 Beman Dawes
5// Copyright 2009 Vicente J. Botet Escriba
6
7// Distributed under the Boost Software License, Version 1.0.
8// See http://www.boost.org/LICENSE_1_0.txt
9
10/*
11
12This code was derived by Beman Dawes from Howard Hinnant's time2_demo prototype.
13Many thanks to Howard for making his code available under the Boost license.
14The original code was modified to conform to Boost conventions and to section
1520.4 Compile-time rational arithmetic [ratio], of the C++ committee working
16paper N2798.
17See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf.
18
19time2_demo contained this comment:
20
21 Much thanks to Andrei Alexandrescu,
22 Walter Brown,
23 Peter Dimov,
24 Jeff Garland,
25 Terry Golubiewski,
26 Daniel Krugler,
27 Anthony Williams.
28*/
29
30// The way overflow is managed for ratio_less is taken from llvm/libcxx/include/ratio
31
32#ifndef BOOST_RATIO_RATIO_HPP
33#define BOOST_RATIO_RATIO_HPP
34
35#include <boost/ratio/config.hpp>
36#include <boost/ratio/detail/mpl/abs.hpp>
37#include <boost/ratio/detail/mpl/sign.hpp>
38#include <boost/ratio/detail/mpl/gcd.hpp>
39#include <boost/ratio/detail/mpl/lcm.hpp>
40#include <cstdlib>
41#include <climits>
42#include <limits>
43#include <boost/cstdint.hpp>
44#include <boost/type_traits/integral_constant.hpp>
45#include <boost/core/enable_if.hpp>
46#include <boost/integer_traits.hpp>
47#include <boost/ratio/ratio_fwd.hpp>
48#include <boost/ratio/detail/overflow_helpers.hpp>
49#ifdef BOOST_RATIO_EXTENSIONS
50#include <boost/rational.hpp>
51#include <boost/ratio/mpl/rational_c_tag.hpp>
52#endif
53
54//
55// We simply cannot include this header on gcc without getting copious warnings of the kind:
56//
57// boost/integer.hpp:77:30: warning: use of C99 long long integer constant
58//
59// And yet there is no other reasonable implementation, so we declare this a system header
60// to suppress these warnings.
61//
62#if defined(__GNUC__) && (__GNUC__ >= 4)
63#pragma GCC system_header
64#endif
65
66namespace boost
67{
68
69
70//----------------------------------------------------------------------------//
71// //
72// 20.6.1 Class template ratio [ratio.ratio] //
73// //
74//----------------------------------------------------------------------------//
75
76template <boost::intmax_t N, boost::intmax_t D>
77class ratio
78{
79 static const boost::intmax_t ABS_N = mpl::abs_c<boost::intmax_t, N>::value;
80 static const boost::intmax_t ABS_D = mpl::abs_c<boost::intmax_t, D>::value;
81 BOOST_RATIO_STATIC_ASSERT(ABS_N >= 0, BOOST_RATIO_NUMERATOR_IS_OUT_OF_RANGE, ());
82 BOOST_RATIO_STATIC_ASSERT(ABS_D > 0, BOOST_RATIO_DENOMINATOR_IS_OUT_OF_RANGE, ());
83 BOOST_RATIO_STATIC_ASSERT(D != 0, BOOST_RATIO_DIVIDE_BY_0 , ());
84 static const boost::intmax_t SIGN_N = mpl::sign_c<boost::intmax_t,N>::value
85 * mpl::sign_c<boost::intmax_t,D>::value;
86 static const boost::intmax_t GCD = mpl::gcd_c<boost::intmax_t, ABS_N, ABS_D>::value;
87public:
88 BOOST_STATIC_CONSTEXPR boost::intmax_t num = SIGN_N * ABS_N / GCD;
89 BOOST_STATIC_CONSTEXPR boost::intmax_t den = ABS_D / GCD;
90
91#ifdef BOOST_RATIO_EXTENSIONS
92 typedef mpl::rational_c_tag tag;
93 typedef boost::rational<boost::intmax_t> value_type;
94 typedef boost::intmax_t num_type;
95 typedef boost::intmax_t den_type;
96 ratio()
97 {}
98 template <boost::intmax_t _N2, boost::intmax_t _D2>
99 ratio(const ratio<_N2, _D2>&,
100 typename enable_if_c
101 <
102 (ratio<_N2, _D2>::num == num &&
103 ratio<_N2, _D2>::den == den)
104 >::type* = 0)
105 {}
106
107 template <boost::intmax_t _N2, boost::intmax_t _D2>
108 typename enable_if_c
109 <
110 (ratio<_N2, _D2>::num == num &&
111 ratio<_N2, _D2>::den == den),
112 ratio&
113 >::type
114 operator=(const ratio<_N2, _D2>&) {return *this;}
115
116 static value_type value() {return value_type(num,den);}
117 value_type operator()() const {return value();}
118#endif
119 typedef ratio<num, den> type;
120};
121
122#if defined(BOOST_NO_CXX11_CONSTEXPR)
123template <boost::intmax_t N, boost::intmax_t D>
124const boost::intmax_t ratio<N, D>::num;
125template <boost::intmax_t N, boost::intmax_t D>
126const boost::intmax_t ratio<N, D>::den;
127#endif
128
129//----------------------------------------------------------------------------//
130// //
131// 20.6.2 Arithmetic on ratio types [ratio.arithmetic] //
132// //
133//----------------------------------------------------------------------------//
134
135template <class R1, class R2>
136struct ratio_add
137: boost::ratio_detail::ratio_add<R1, R2>::type
138{
139};
140
141template <class R1, class R2>
142struct ratio_subtract
143: boost::ratio_detail::ratio_subtract<R1, R2>::type
144{
145};
146
147template <class R1, class R2>
148struct ratio_multiply
149: boost::ratio_detail::ratio_multiply<R1, R2>::type
150{
151};
152
153template <class R1, class R2>
154struct ratio_divide
155: boost::ratio_detail::ratio_divide<R1, R2>::type
156{
157};
158
159//----------------------------------------------------------------------------//
160// //
161// 20.6.3 Comparision of ratio types [ratio.comparison] //
162// //
163//----------------------------------------------------------------------------//
164
165// ratio_equal
166
167template <class R1, class R2>
168struct ratio_equal
169 : public boost::integral_constant<bool,
170 (R1::num == R2::num && R1::den == R2::den)>
171{};
172
173template <class R1, class R2>
174struct ratio_not_equal
175 : public boost::integral_constant<bool, !ratio_equal<R1, R2>::value>
176{};
177
178// ratio_less
179
180template <class R1, class R2>
181struct ratio_less
182 : boost::integral_constant<bool, boost::ratio_detail::ratio_less<R1, R2>::value>
183{};
184
185template <class R1, class R2>
186struct ratio_less_equal
187 : boost::integral_constant<bool, !ratio_less<R2, R1>::value>
188{};
189
190template <class R1, class R2>
191struct ratio_greater
192 : boost::integral_constant<bool, ratio_less<R2, R1>::value>
193{};
194
195template <class R1, class R2>
196struct ratio_greater_equal
197 : boost::integral_constant<bool, !ratio_less<R1, R2>::value>
198{};
199
200template <class R1, class R2>
201struct ratio_gcd :
202 ratio<mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value,
203 mpl::lcm_c<boost::intmax_t, R1::den, R2::den>::value>::type
204{
205};
206
207 //----------------------------------------------------------------------------//
208 // //
209 // More arithmetic on ratio types [ratio.arithmetic] //
210 // //
211 //----------------------------------------------------------------------------//
212
213#ifdef BOOST_RATIO_EXTENSIONS
214template <class R>
215struct ratio_negate
216 : ratio<-R::num, R::den>::type
217{
218};
219template <class R>
220struct ratio_abs
221 : ratio<mpl::abs_c<boost::intmax_t, R::num>::value, R::den>::type
222{
223};
224template <class R>
225struct ratio_sign
226 : mpl::sign_c<boost::intmax_t, R::num>
227{
228};
229
230template <class R>
231struct ratio_inverse
232 : ratio<R::den, R::num>::type
233{
234};
235
236
237template <class R1, class R2>
238struct ratio_lcm :
239 ratio<mpl::lcm_c<boost::intmax_t, R1::num, R2::num>::value,
240 mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value>::type
241{
242};
243
244template <class R1, class R2>
245struct ratio_modulo :
246 ratio<(R1::num * R2::den) % (R2::num * R1::den), R1::den * R2::den>::type
247{
248};
249
250namespace detail {
251 template <class R1, class R2, bool r1ltr2>
252 struct ratio_min : R1 {};
253 template <class R1, class R2>
254 struct ratio_min<R1,R2,false> : R2 {};
255
256 template <class R1, class R2, bool r1ltr2>
257 struct ratio_max : R2 {};
258 template <class R1, class R2>
259 struct ratio_max<R1,R2,false> : R1 {};
260}
261
262template <class R1, class R2>
263struct ratio_min : detail::ratio_min<R1, R2, ratio_less<R1,R2>::value>::type
264{
265};
266
267template <class R1, class R2>
268struct ratio_max : detail::ratio_max<R1, R2, ratio_less<R1,R2>::value>::type
269{
270};
271
272template<typename R, int p>
273struct ratio_power :
274 ratio_multiply<
275 typename ratio_power<R, p%2>::type,
276 typename ratio_power<typename ratio_multiply<R, R>::type, p/2>::type
277 >::type
278{};
279
280template<typename R>
281struct ratio_power<R, 0> : ratio<1>::type {};
282
283template<typename R>
284struct ratio_power<R, 1> : R {};
285
286template<typename R>
287struct ratio_power<R, -1> : ratio_divide<ratio<1>, R>::type {};
288
289#endif
290} // namespace boost
291
292
293#endif // BOOST_RATIO_RATIO_HPP
294