diff options
Diffstat (limited to 'src/third_party/boost-1.56.0/boost/ratio/ratio.hpp')
| -rw-r--r-- | src/third_party/boost-1.56.0/boost/ratio/ratio.hpp | 293 |
1 files changed, 293 insertions, 0 deletions
diff --git a/src/third_party/boost-1.56.0/boost/ratio/ratio.hpp b/src/third_party/boost-1.56.0/boost/ratio/ratio.hpp new file mode 100644 index 00000000000..824cbf01733 --- /dev/null +++ b/src/third_party/boost-1.56.0/boost/ratio/ratio.hpp @@ -0,0 +1,293 @@ +// 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 |