You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
293 lines
8.7 KiB
293 lines
8.7 KiB
// ratio.hpp ---------------------------------------------------------------// |
|
|
|
// Copyright 2008 Howard Hinnant |
|
// Copyright 2008 Beman Dawes |
|
// Copyright 2009 Vicente J. Botet Escriba |
|
|
|
// Distributed under the Boost Software License, Version 1.0. |
|
// See http://www.boost.org/LICENSE_1_0.txt |
|
|
|
/* |
|
|
|
This code was derived by Beman Dawes from Howard Hinnant's time2_demo prototype. |
|
Many thanks to Howard for making his code available under the Boost license. |
|
The original code was modified to conform to Boost conventions and to section |
|
20.4 Compile-time rational arithmetic [ratio], of the C++ committee working |
|
paper N2798. |
|
See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf. |
|
|
|
time2_demo contained this comment: |
|
|
|
Much thanks to Andrei Alexandrescu, |
|
Walter Brown, |
|
Peter Dimov, |
|
Jeff Garland, |
|
Terry Golubiewski, |
|
Daniel Krugler, |
|
Anthony Williams. |
|
*/ |
|
|
|
// The way overflow is managed for ratio_less is taken from llvm/libcxx/include/ratio |
|
|
|
#ifndef BOOST_RATIO_RATIO_HPP |
|
#define BOOST_RATIO_RATIO_HPP |
|
|
|
#include <boost/ratio/config.hpp> |
|
#include <boost/ratio/detail/mpl/abs.hpp> |
|
#include <boost/ratio/detail/mpl/sign.hpp> |
|
#include <boost/ratio/detail/mpl/gcd.hpp> |
|
#include <boost/ratio/detail/mpl/lcm.hpp> |
|
#include <cstdlib> |
|
#include <climits> |
|
#include <limits> |
|
#include <boost/cstdint.hpp> |
|
#include <boost/type_traits/integral_constant.hpp> |
|
#include <boost/core/enable_if.hpp> |
|
#include <boost/integer_traits.hpp> |
|
#include <boost/ratio/ratio_fwd.hpp> |
|
#include <boost/ratio/detail/overflow_helpers.hpp> |
|
#ifdef BOOST_RATIO_EXTENSIONS |
|
#include <boost/rational.hpp> |
|
#include <boost/ratio/mpl/rational_c_tag.hpp> |
|
#endif |
|
|
|
// |
|
// We simply cannot include this header on gcc without getting copious warnings of the kind: |
|
// |
|
// boost/integer.hpp:77:30: warning: use of C99 long long integer constant |
|
// |
|
// And yet there is no other reasonable implementation, so we declare this a system header |
|
// to suppress these warnings. |
|
// |
|
#if defined(__GNUC__) && (__GNUC__ >= 4) |
|
#pragma GCC system_header |
|
#endif |
|
|
|
namespace boost |
|
{ |
|
|
|
|
|
//----------------------------------------------------------------------------// |
|
// // |
|
// 20.6.1 Class template ratio [ratio.ratio] // |
|
// // |
|
//----------------------------------------------------------------------------// |
|
|
|
template <boost::intmax_t N, boost::intmax_t D> |
|
class ratio |
|
{ |
|
static const boost::intmax_t ABS_N = mpl::abs_c<boost::intmax_t, N>::value; |
|
static const boost::intmax_t ABS_D = mpl::abs_c<boost::intmax_t, D>::value; |
|
BOOST_RATIO_STATIC_ASSERT(ABS_N >= 0, BOOST_RATIO_NUMERATOR_IS_OUT_OF_RANGE, ()); |
|
BOOST_RATIO_STATIC_ASSERT(ABS_D > 0, BOOST_RATIO_DENOMINATOR_IS_OUT_OF_RANGE, ()); |
|
BOOST_RATIO_STATIC_ASSERT(D != 0, BOOST_RATIO_DIVIDE_BY_0 , ()); |
|
static const boost::intmax_t SIGN_N = mpl::sign_c<boost::intmax_t,N>::value |
|
* mpl::sign_c<boost::intmax_t,D>::value; |
|
static const boost::intmax_t GCD = mpl::gcd_c<boost::intmax_t, ABS_N, ABS_D>::value; |
|
public: |
|
BOOST_STATIC_CONSTEXPR boost::intmax_t num = SIGN_N * ABS_N / GCD; |
|
BOOST_STATIC_CONSTEXPR boost::intmax_t den = ABS_D / GCD; |
|
|
|
#ifdef BOOST_RATIO_EXTENSIONS |
|
typedef mpl::rational_c_tag tag; |
|
typedef boost::rational<boost::intmax_t> value_type; |
|
typedef boost::intmax_t num_type; |
|
typedef boost::intmax_t den_type; |
|
ratio() |
|
{} |
|
template <boost::intmax_t _N2, boost::intmax_t _D2> |
|
ratio(const ratio<_N2, _D2>&, |
|
typename enable_if_c |
|
< |
|
(ratio<_N2, _D2>::num == num && |
|
ratio<_N2, _D2>::den == den) |
|
>::type* = 0) |
|
{} |
|
|
|
template <boost::intmax_t _N2, boost::intmax_t _D2> |
|
typename enable_if_c |
|
< |
|
(ratio<_N2, _D2>::num == num && |
|
ratio<_N2, _D2>::den == den), |
|
ratio& |
|
>::type |
|
operator=(const ratio<_N2, _D2>&) {return *this;} |
|
|
|
static value_type value() {return value_type(num,den);} |
|
value_type operator()() const {return value();} |
|
#endif |
|
typedef ratio<num, den> type; |
|
}; |
|
|
|
#if defined(BOOST_NO_CXX11_CONSTEXPR) |
|
template <boost::intmax_t N, boost::intmax_t D> |
|
const boost::intmax_t ratio<N, D>::num; |
|
template <boost::intmax_t N, boost::intmax_t D> |
|
const boost::intmax_t ratio<N, D>::den; |
|
#endif |
|
|
|
//----------------------------------------------------------------------------// |
|
// // |
|
// 20.6.2 Arithmetic on ratio types [ratio.arithmetic] // |
|
// // |
|
//----------------------------------------------------------------------------// |
|
|
|
template <class R1, class R2> |
|
struct ratio_add |
|
: boost::ratio_detail::ratio_add<R1, R2>::type |
|
{ |
|
}; |
|
|
|
template <class R1, class R2> |
|
struct ratio_subtract |
|
: boost::ratio_detail::ratio_subtract<R1, R2>::type |
|
{ |
|
}; |
|
|
|
template <class R1, class R2> |
|
struct ratio_multiply |
|
: boost::ratio_detail::ratio_multiply<R1, R2>::type |
|
{ |
|
}; |
|
|
|
template <class R1, class R2> |
|
struct ratio_divide |
|
: boost::ratio_detail::ratio_divide<R1, R2>::type |
|
{ |
|
}; |
|
|
|
//----------------------------------------------------------------------------// |
|
// // |
|
// 20.6.3 Comparision of ratio types [ratio.comparison] // |
|
// // |
|
//----------------------------------------------------------------------------// |
|
|
|
// ratio_equal |
|
|
|
template <class R1, class R2> |
|
struct ratio_equal |
|
: public boost::integral_constant<bool, |
|
(R1::num == R2::num && R1::den == R2::den)> |
|
{}; |
|
|
|
template <class R1, class R2> |
|
struct ratio_not_equal |
|
: public boost::integral_constant<bool, !ratio_equal<R1, R2>::value> |
|
{}; |
|
|
|
// ratio_less |
|
|
|
template <class R1, class R2> |
|
struct ratio_less |
|
: boost::integral_constant<bool, boost::ratio_detail::ratio_less<R1, R2>::value> |
|
{}; |
|
|
|
template <class R1, class R2> |
|
struct ratio_less_equal |
|
: boost::integral_constant<bool, !ratio_less<R2, R1>::value> |
|
{}; |
|
|
|
template <class R1, class R2> |
|
struct ratio_greater |
|
: boost::integral_constant<bool, ratio_less<R2, R1>::value> |
|
{}; |
|
|
|
template <class R1, class R2> |
|
struct ratio_greater_equal |
|
: boost::integral_constant<bool, !ratio_less<R1, R2>::value> |
|
{}; |
|
|
|
template <class R1, class R2> |
|
struct ratio_gcd : |
|
ratio<mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value, |
|
mpl::lcm_c<boost::intmax_t, R1::den, R2::den>::value>::type |
|
{ |
|
}; |
|
|
|
//----------------------------------------------------------------------------// |
|
// // |
|
// More arithmetic on ratio types [ratio.arithmetic] // |
|
// // |
|
//----------------------------------------------------------------------------// |
|
|
|
#ifdef BOOST_RATIO_EXTENSIONS |
|
template <class R> |
|
struct ratio_negate |
|
: ratio<-R::num, R::den>::type |
|
{ |
|
}; |
|
template <class R> |
|
struct ratio_abs |
|
: ratio<mpl::abs_c<boost::intmax_t, R::num>::value, R::den>::type |
|
{ |
|
}; |
|
template <class R> |
|
struct ratio_sign |
|
: mpl::sign_c<boost::intmax_t, R::num> |
|
{ |
|
}; |
|
|
|
template <class R> |
|
struct ratio_inverse |
|
: ratio<R::den, R::num>::type |
|
{ |
|
}; |
|
|
|
|
|
template <class R1, class R2> |
|
struct ratio_lcm : |
|
ratio<mpl::lcm_c<boost::intmax_t, R1::num, R2::num>::value, |
|
mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value>::type |
|
{ |
|
}; |
|
|
|
template <class R1, class R2> |
|
struct ratio_modulo : |
|
ratio<(R1::num * R2::den) % (R2::num * R1::den), R1::den * R2::den>::type |
|
{ |
|
}; |
|
|
|
namespace detail { |
|
template <class R1, class R2, bool r1ltr2> |
|
struct ratio_min : R1 {}; |
|
template <class R1, class R2> |
|
struct ratio_min<R1,R2,false> : R2 {}; |
|
|
|
template <class R1, class R2, bool r1ltr2> |
|
struct ratio_max : R2 {}; |
|
template <class R1, class R2> |
|
struct ratio_max<R1,R2,false> : R1 {}; |
|
} |
|
|
|
template <class R1, class R2> |
|
struct ratio_min : detail::ratio_min<R1, R2, ratio_less<R1,R2>::value>::type |
|
{ |
|
}; |
|
|
|
template <class R1, class R2> |
|
struct ratio_max : detail::ratio_max<R1, R2, ratio_less<R1,R2>::value>::type |
|
{ |
|
}; |
|
|
|
template<typename R, int p> |
|
struct ratio_power : |
|
ratio_multiply< |
|
typename ratio_power<R, p%2>::type, |
|
typename ratio_power<typename ratio_multiply<R, R>::type, p/2>::type |
|
>::type |
|
{}; |
|
|
|
template<typename R> |
|
struct ratio_power<R, 0> : ratio<1>::type {}; |
|
|
|
template<typename R> |
|
struct ratio_power<R, 1> : R {}; |
|
|
|
template<typename R> |
|
struct ratio_power<R, -1> : ratio_divide<ratio<1>, R>::type {}; |
|
|
|
#endif |
|
} // namespace boost |
|
|
|
|
|
#endif // BOOST_RATIO_RATIO_HPP
|
|
|