boost/ratio/detail/overflow_helpers.hpp
// 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/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> #if !defined(BOOST_NO_STATIC_ASSERT) || !defined(BOOST_RATIO_USES_MPL_ASSERT) #define BOOST_RATIO_OVERFLOW_IN_ADD "overflow in ratio add" #define BOOST_RATIO_OVERFLOW_IN_SUB "overflow in ratio sub" #define BOOST_RATIO_OVERFLOW_IN_MUL "overflow in ratio mul" #define BOOST_RATIO_OVERFLOW_IN_DIV "overflow in ratio div" #define BOOST_RATIO_NUMERATOR_IS_OUT_OF_RANGE "ratio numerator is out of range" #define BOOST_RATIO_DIVIDE_BY_0 "ratio divide by 0" #define BOOST_RATIO_DENOMINATOR_IS_OUT_OF_RANGE "ratio denominator is out of range" #endif #ifndef BOOST_NO_STATIC_ASSERT #define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) static_assert(CND,MSG) #elif defined(BOOST_RATIO_USES_STATIC_ASSERT) #include <boost/static_assert.hpp> #define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) BOOST_STATIC_ASSERT(CND) #elif defined(BOOST_RATIO_USES_MPL_ASSERT) #include <boost/mpl/assert.hpp> #include <boost/mpl/bool.hpp> #define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) \ BOOST_MPL_ASSERT_MSG(boost::mpl::bool_< (CND) >::type::value, MSG, TYPES) #else //~ #elif defined(BOOST_RATIO_USES_ARRAY_ASSERT) #define BOOST_RATIO_CONCAT(A,B) A##B #define BOOST_RATIO_NAME(A,B) BOOST_RATIO_CONCAT(A,B) #define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) static char BOOST_RATIO_NAME(__boost_ratio_test_,__LINE__)[(CND)?1:-1] //~ #define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) #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 { //----------------------------------------------------------------------------// // 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