diff options
author | Remko Tronçon <git@el-tramo.be> | 2012-12-23 13:16:26 (GMT) |
---|---|---|
committer | Remko Tronçon <git@el-tramo.be> | 2012-12-23 14:43:26 (GMT) |
commit | 491ddd570a752cf9bda85933bed0c6942e39b1f9 (patch) | |
tree | 10c25c1be8cc08d0497df1dccd56a10fbb30beee /3rdParty/Boost/src/boost/ratio/detail/overflow_helpers.hpp | |
parent | da7d7a0ca71b80281aa9ff2526290b61ccb0cc60 (diff) | |
download | swift-491ddd570a752cf9bda85933bed0c6942e39b1f9.zip swift-491ddd570a752cf9bda85933bed0c6942e39b1f9.tar.bz2 |
Update Boost to 1.52.0.
Change-Id: I1e56bea2600bf2ed9c5b3aba8c4f9d2a0f350e77
Diffstat (limited to '3rdParty/Boost/src/boost/ratio/detail/overflow_helpers.hpp')
-rw-r--r-- | 3rdParty/Boost/src/boost/ratio/detail/overflow_helpers.hpp | 367 |
1 files changed, 367 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/ratio/detail/overflow_helpers.hpp b/3rdParty/Boost/src/boost/ratio/detail/overflow_helpers.hpp new file mode 100644 index 0000000..0e292fa --- /dev/null +++ b/3rdParty/Boost/src/boost/ratio/detail/overflow_helpers.hpp @@ -0,0 +1,367 @@ +// 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_DETAIL_RATIO_OPERATIONS_HPP +#define BOOST_RATIO_DETAIL_RATIO_OPERATIONS_HPP + +#include <boost/ratio/config.hpp> +#include <boost/ratio/detail/mpl/abs.hpp> +#include <boost/ratio/detail/mpl/sign.hpp> +#include <cstdlib> +#include <climits> +#include <limits> +#include <boost/cstdint.hpp> +#include <boost/type_traits/integral_constant.hpp> +#include <boost/utility/enable_if.hpp> +#include <boost/integer_traits.hpp> + +// +// 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 +{ + +//----------------------------------------------------------------------------// +// helpers // +//----------------------------------------------------------------------------// + +namespace ratio_detail +{ + + template <boost::intmax_t X, boost::intmax_t Y, boost::intmax_t = mpl::sign_c<boost::intmax_t, Y>::value> + class br_add; + + template <boost::intmax_t X, boost::intmax_t Y> + class br_add<X, Y, 1> + { + static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min; + static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max; + + BOOST_RATIO_STATIC_ASSERT(X <= max - Y , BOOST_RATIO_OVERFLOW_IN_ADD, ()); + public: + static const boost::intmax_t value = X + Y; + }; + + template <boost::intmax_t X, boost::intmax_t Y> + class br_add<X, Y, 0> + { + public: + static const boost::intmax_t value = X; + }; + + template <boost::intmax_t X, boost::intmax_t Y> + class br_add<X, Y, -1> + { + static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min; + static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max; + + BOOST_RATIO_STATIC_ASSERT(min - Y <= X, BOOST_RATIO_OVERFLOW_IN_ADD, ()); + public: + static const boost::intmax_t value = X + Y; + }; + + template <boost::intmax_t X, boost::intmax_t Y, boost::intmax_t = mpl::sign_c<boost::intmax_t, Y>::value> + class br_sub; + + template <boost::intmax_t X, boost::intmax_t Y> + class br_sub<X, Y, 1> + { + static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min; + static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max; + + BOOST_RATIO_STATIC_ASSERT(min + Y <= X, BOOST_RATIO_OVERFLOW_IN_SUB, ()); + public: + static const boost::intmax_t value = X - Y; + }; + + template <boost::intmax_t X, boost::intmax_t Y> + class br_sub<X, Y, 0> + { + public: + static const boost::intmax_t value = X; + }; + + template <boost::intmax_t X, boost::intmax_t Y> + class br_sub<X, Y, -1> + { + static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min; + static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max; + + BOOST_RATIO_STATIC_ASSERT(X <= max + Y, BOOST_RATIO_OVERFLOW_IN_SUB, ()); + public: + static const boost::intmax_t value = X - Y; + }; + + template <boost::intmax_t X, boost::intmax_t Y> + class br_mul + { + static const boost::intmax_t nan = + (BOOST_RATIO_INTMAX_C(1) << (sizeof(boost::intmax_t) * CHAR_BIT - 1)); + static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min; + static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max; + + static const boost::intmax_t a_x = mpl::abs_c<boost::intmax_t, X>::value; + static const boost::intmax_t a_y = mpl::abs_c<boost::intmax_t, Y>::value; + + BOOST_RATIO_STATIC_ASSERT(X != nan, BOOST_RATIO_OVERFLOW_IN_MUL, ()); + BOOST_RATIO_STATIC_ASSERT(Y != nan, BOOST_RATIO_OVERFLOW_IN_MUL, ()); + BOOST_RATIO_STATIC_ASSERT(a_x <= max / a_y, BOOST_RATIO_OVERFLOW_IN_MUL, ()); + public: + static const boost::intmax_t value = X * Y; + }; + + template <boost::intmax_t Y> + class br_mul<0, Y> + { + public: + static const boost::intmax_t value = 0; + }; + + template <boost::intmax_t X> + class br_mul<X, 0> + { + public: + static const boost::intmax_t value = 0; + }; + + template <> + class br_mul<0, 0> + { + public: + static const boost::intmax_t value = 0; + }; + + // Not actually used but left here in case needed in future maintenance + template <boost::intmax_t X, boost::intmax_t Y> + class br_div + { + static const boost::intmax_t nan = (1LL << (sizeof(boost::intmax_t) * CHAR_BIT - 1)); + static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min; + static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max; + + BOOST_RATIO_STATIC_ASSERT(X != nan, BOOST_RATIO_OVERFLOW_IN_DIV, ()); + BOOST_RATIO_STATIC_ASSERT(Y != nan, BOOST_RATIO_OVERFLOW_IN_DIV, ()); + BOOST_RATIO_STATIC_ASSERT(Y != 0, BOOST_RATIO_DIVIDE_BY_0, ()); + public: + static const boost::intmax_t value = X / Y; + }; + + // ratio arithmetic + template <class R1, class R2> struct ratio_add; + template <class R1, class R2> struct ratio_subtract; + template <class R1, class R2> struct ratio_multiply; + template <class R1, class R2> struct ratio_divide; + + template <class R1, class R2> + struct ratio_add + { + //The nested typedef type shall be a synonym for ratio<T1, T2>::type where T1 has the value R1::num * + //R2::den + R2::num * R1::den and T2 has the value R1::den * R2::den. + // As the preceding doesn't works because of overflow on boost::intmax_t we need something more elaborated. + private: + static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value; + static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value; + public: + // No need to normalize as ratio_multiply is already normalized + typedef typename ratio_multiply + < + ratio<gcd_n1_n2, R1::den / gcd_d1_d2>, + ratio + < + boost::ratio_detail::br_add + < + boost::ratio_detail::br_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value, + boost::ratio_detail::br_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value + >::value, + R2::den + > + >::type type; + }; + template <class R, boost::intmax_t D> + struct ratio_add<R, ratio<0,D> > + { + typedef R type; + }; + + template <class R1, class R2> + struct ratio_subtract + { + //The nested typedef type shall be a synonym for ratio<T1, T2>::type where T1 has the value + // R1::num *R2::den - R2::num * R1::den and T2 has the value R1::den * R2::den. + // As the preceding doesn't works because of overflow on boost::intmax_t we need something more elaborated. + private: + static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value; + static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value; + public: + // No need to normalize as ratio_multiply is already normalized + typedef typename ratio_multiply + < + ratio<gcd_n1_n2, R1::den / gcd_d1_d2>, + ratio + < + boost::ratio_detail::br_sub + < + boost::ratio_detail::br_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value, + boost::ratio_detail::br_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value + >::value, + R2::den + > + >::type type; + }; + + template <class R, boost::intmax_t D> + struct ratio_subtract<R, ratio<0,D> > + { + typedef R type; + }; + + template <class R1, class R2> + struct ratio_multiply + { + // The nested typedef type shall be a synonym for ratio<R1::num * R2::den - R2::num * R1::den, R1::den * R2::den>::type. + // As the preceding doesn't works because of overflow on boost::intmax_t we need something more elaborated. + private: + static const boost::intmax_t gcd_n1_d2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::den>::value; + static const boost::intmax_t gcd_d1_n2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::num>::value; + public: + typedef typename ratio + < + boost::ratio_detail::br_mul<R1::num / gcd_n1_d2, R2::num / gcd_d1_n2>::value, + boost::ratio_detail::br_mul<R2::den / gcd_n1_d2, R1::den / gcd_d1_n2>::value + >::type type; + }; + + template <class R1, class R2> + struct ratio_divide + { + // The nested typedef type shall be a synonym for ratio<R1::num * R2::den, R2::num * R1::den>::type. + // As the preceding doesn't works because of overflow on boost::intmax_t we need something more elaborated. + private: + static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value; + static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value; + public: + typedef typename ratio + < + boost::ratio_detail::br_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value, + boost::ratio_detail::br_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value + >::type type; + }; + template <class R1, class R2> + struct is_evenly_divisible_by + { + private: + static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value; + static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value; + public: + typedef integral_constant<bool, + ((R2::num / gcd_n1_n2 ==1) && (R1::den / gcd_d1_d2)==1) + > type; + }; + + template <class T> + struct is_ratio : public boost::false_type + {}; + template <boost::intmax_t N, boost::intmax_t D> + struct is_ratio<ratio<N, D> > : public boost::true_type + {}; + + template <class R1, class R2, + boost::intmax_t Q1 = R1::num / R1::den, boost::intmax_t M1 = R1::num % R1::den, + boost::intmax_t Q2 = R2::num / R2::den, boost::intmax_t M2 = R2::num % R2::den> + struct ratio_less1 + { + static const bool value = Q1 < Q2; + }; + + template <class R1, class R2, boost::intmax_t Q> + struct ratio_less1<R1, R2, Q, 0, Q, 0> + { + static const bool value = false; + }; + + template <class R1, class R2, boost::intmax_t Q, boost::intmax_t M2> + struct ratio_less1<R1, R2, Q, 0, Q, M2> + { + static const bool value = true; + }; + + template <class R1, class R2, boost::intmax_t Q, boost::intmax_t M1> + struct ratio_less1<R1, R2, Q, M1, Q, 0> + { + static const bool value = false; + }; + + template <class R1, class R2, boost::intmax_t Q, boost::intmax_t M1, boost::intmax_t M2> + struct ratio_less1<R1, R2, Q, M1, Q, M2> + { + static const bool value = ratio_less1<ratio<R2::den, M2>, ratio<R1::den, M1> + >::value; + }; + + template < + class R1, + class R2, + boost::intmax_t S1 = mpl::sign_c<boost::intmax_t, R1::num>::value, + boost::intmax_t S2 = mpl::sign_c<boost::intmax_t, R2::num>::value +> + struct ratio_less + { + static const bool value = S1 < S2; + }; + + template <class R1, class R2> + struct ratio_less<R1, R2, 1LL, 1LL> + { + static const bool value = ratio_less1<R1, R2>::value; + }; + + template <class R1, class R2> + struct ratio_less<R1, R2, -1LL, -1LL> + { + static const bool value = ratio_less1<ratio<-R2::num, R2::den>, + ratio<-R1::num, R1::den> >::value; + }; + + +} // namespace ratio_detail + +} // namespace boost + +#endif // BOOST_RATIO_HPP |