[Boost-commit] svn:boost r65195 - sandbox/chrono/boost/ratio

Subject: [Boost-commit] svn:boost r65195 - sandbox/chrono/boost/ratio
From: vicente.botet_at_[hidden]
Date: 2010-09-02 12:18:29

Author: viboes
Date: 2010-09-02 12:18:28 EDT (Thu, 02 Sep 2010)
New Revision: 65195
URL: http://svn.boost.org/trac/boost/changeset/65195

Log:
move ratio.hpp contents to ratio/ratio.hpp
Added:
   sandbox/chrono/boost/ratio/
   sandbox/chrono/boost/ratio/ratio.hpp   (contents, props changed)

Added: sandbox/chrono/boost/ratio/ratio.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/ratio/ratio.hpp	2010-09-02 12:18:28 EDT (Thu, 02 Sep 2010)
@@ -0,0 +1,613 @@
+//  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 Krügler,
+                   Anthony Williams.
+*/
+
+#ifndef BOOST_RATIO_RATIO__HPP
+#define BOOST_RATIO_RATIO_HPP
+
+#include <cstdlib>
+#include <climits>
+#include <limits>
+#include <boost/cstdint.hpp>
+#include <boost/type_traits.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_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_RATIO_NUMERATOR_IS_OUT_OF_RANGE "ratio numerator is out of range"
+#define BOOST_RATIO_RATIO_DIVIDE_BY_0 "ratio divide by 0"
+#define BOOST_RATIO_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)
+#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]
+#else
+#define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES)
+#endif
+
+#ifdef INTMAX_C
+#define BOOST_INTMAX_C(a) INTMAX_C(a)
+#else
+#define BOOST_INTMAX_C(a) a##LL
+#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.4 Compile-time rational arithmetic [ratio]                 //
+//                                                                            //
+//----------------------------------------------------------------------------//
+
+template <boost::intmax_t N, boost::intmax_t D = 1> class ratio;
+
+// 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;
+
+// ratio comparison
+template <class R1, class R2> struct ratio_equal;
+template <class R1, class R2> struct ratio_not_equal;
+template <class R1, class R2> struct ratio_less;
+template <class R1, class R2> struct ratio_less_equal;
+template <class R1, class R2> struct ratio_greater;
+template <class R1, class R2> struct ratio_greater_equal;
+
+// convenience SI typedefs
+typedef ratio<BOOST_INTMAX_C(1), BOOST_INTMAX_C(1000000000000000000)> atto;
+typedef ratio<BOOST_INTMAX_C(1),    BOOST_INTMAX_C(1000000000000000)> femto;
+typedef ratio<BOOST_INTMAX_C(1),       BOOST_INTMAX_C(1000000000000)> pico;
+typedef ratio<BOOST_INTMAX_C(1),          BOOST_INTMAX_C(1000000000)> nano;
+typedef ratio<BOOST_INTMAX_C(1),             BOOST_INTMAX_C(1000000)> micro;
+typedef ratio<BOOST_INTMAX_C(1),                BOOST_INTMAX_C(1000)> milli;
+typedef ratio<BOOST_INTMAX_C(1),                 BOOST_INTMAX_C(100)> centi;
+typedef ratio<BOOST_INTMAX_C(1),                  BOOST_INTMAX_C(10)> deci;
+typedef ratio<                 BOOST_INTMAX_C(10), BOOST_INTMAX_C(1)> deca;
+typedef ratio<                BOOST_INTMAX_C(100), BOOST_INTMAX_C(1)> hecto;
+typedef ratio<               BOOST_INTMAX_C(1000), BOOST_INTMAX_C(1)> kilo;
+typedef ratio<            BOOST_INTMAX_C(1000000), BOOST_INTMAX_C(1)> mega;
+typedef ratio<         BOOST_INTMAX_C(1000000000), BOOST_INTMAX_C(1)> giga;
+typedef ratio<      BOOST_INTMAX_C(1000000000000), BOOST_INTMAX_C(1)> tera;
+typedef ratio<   BOOST_INTMAX_C(1000000000000000), BOOST_INTMAX_C(1)> peta;
+typedef ratio<BOOST_INTMAX_C(1000000000000000000), BOOST_INTMAX_C(1)> exa;
+
+//----------------------------------------------------------------------------//
+//                                 helpers                                    //
+//----------------------------------------------------------------------------//
+
+namespace detail
+{
+
+  // static_gcd
+
+  template <boost::intmax_t X, boost::intmax_t Y>
+  struct static_gcd
+  {
+      static const boost::intmax_t value = static_gcd<Y, X % Y>::value;
+  };
+
+  template <boost::intmax_t X>
+  struct static_gcd<X, 0>
+  {
+      static const boost::intmax_t value = X;
+  };
+
+  // static_lcm
+
+  template <boost::intmax_t X, boost::intmax_t Y>
+  struct static_lcm
+  {
+      static const boost::intmax_t value = X / static_gcd<X, Y>::value * Y;
+  };
+
+  template <boost::intmax_t X>
+  struct static_abs
+  {
+      static const boost::intmax_t value = X < 0 ? -X : X;
+  };
+
+  template <boost::intmax_t X>
+  struct static_sign
+  {
+      static const boost::intmax_t value = X == 0 ? 0 : (X < 0 ? -1 : 1);
+  };
+
+  template <boost::intmax_t X, boost::intmax_t Y, boost::intmax_t = static_sign<Y>::value>
+  class ll_add;
+
+  template <boost::intmax_t X, boost::intmax_t Y>
+  class ll_add<X, Y, 1>
+  {
+      #if BOOST_RATIO_OLD_MIN_MAX
+      static const boost::intmax_t min =
+        (BOOST_INTMAX_C(1) << (sizeof(boost::intmax_t) * CHAR_BIT - 1)) + 1;
+      static const boost::intmax_t max = -min;
+      #else
+      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;
+      #endif
+
+      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 ll_add<X, Y, 0>
+  {
+  public:
+      static const boost::intmax_t value = X;
+  };
+
+  template <boost::intmax_t X, boost::intmax_t Y>
+  class ll_add<X, Y, -1>
+  {
+      #if BOOST_RATIO_OLD_MIN_MAX
+      static const boost::intmax_t min =
+        (BOOST_INTMAX_C(1) << (sizeof(boost::intmax_t) * CHAR_BIT - 1)) + 1;
+      static const boost::intmax_t max = -min;
+      #else
+      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;
+      #endif
+
+      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 = static_sign<Y>::value>
+  class ll_sub;
+
+  template <boost::intmax_t X, boost::intmax_t Y>
+  class ll_sub<X, Y, 1>
+  {
+      #if BOOST_RATIO_OLD_MIN_MAX
+      static const boost::intmax_t min =
+        (BOOST_INTMAX_C(1) << (sizeof(boost::intmax_t) * CHAR_BIT - 1)) + 1;
+      static const boost::intmax_t max = -min;
+      #else
+      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;
+      #endif
+
+      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 ll_sub<X, Y, 0>
+  {
+  public:
+      static const boost::intmax_t value = X;
+  };
+
+  template <boost::intmax_t X, boost::intmax_t Y>
+  class ll_sub<X, Y, -1>
+  {
+      #if BOOST_RATIO_OLD_MIN_MAX
+      static const boost::intmax_t min =
+        (BOOST_INTMAX_C(1) << (sizeof(boost::intmax_t) * CHAR_BIT - 1)) + 1;
+      static const boost::intmax_t max = -min;
+      #else
+      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;
+      #endif
+
+      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 ll_mul
+  {
+      static const boost::intmax_t nan =
+        (BOOST_INTMAX_C(1) << (sizeof(boost::intmax_t) * CHAR_BIT - 1));
+      #if BOOST_RATIO_OLD_MIN_MAX
+      static const boost::intmax_t min = nan + 1;
+      static const boost::intmax_t max = -min;
+      #else
+      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;
+      #endif
+
+      static const boost::intmax_t a_x = static_abs<X>::value;
+      static const boost::intmax_t a_y = static_abs<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 ll_mul<0, Y>
+  {
+  public:
+      static const boost::intmax_t value = 0;
+  };
+
+  template <boost::intmax_t X>
+  class ll_mul<X, 0>
+  {
+  public:
+      static const boost::intmax_t value = 0;
+  };
+
+  template <>
+  class ll_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 ll_div
+  {
+      static const boost::intmax_t nan = (1LL << (sizeof(boost::intmax_t) * CHAR_BIT - 1));
+      #if BOOST_RATIO_OLD_MIN_MAX
+      static const boost::intmax_t min = nan + 1;
+      static const boost::intmax_t max = -min;
+      #else
+      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;
+      #endif
+
+      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_RATIO_DIVIDE_BY_0, ());
+  public:
+      static const boost::intmax_t value = X / Y;
+  };
+
+  template <class T>
+    struct is_ratio : public boost::false_type {};
+  template <intmax_t N, intmax_t D>
+    struct is_ratio<ratio<N, D> > : public boost::true_type  {};
+  //template <class T>
+  //  struct is_ratio : is_ratio<typename remove_cv<T>::type> {};
+
+
+}  // namespace detail
+
+//----------------------------------------------------------------------------//
+//                                                                            //
+//                20.4.1 Class template ratio [ratio.ratio]                   //
+//                                                                            //
+//----------------------------------------------------------------------------//
+
+template <boost::intmax_t N, boost::intmax_t D>
+class ratio
+{
+    BOOST_RATIO_STATIC_ASSERT(boost::detail::static_abs<N>::value >= 0, BOOST_RATIO_RATIO_NUMERATOR_IS_OUT_OF_RANGE, ());
+    BOOST_RATIO_STATIC_ASSERT(boost::detail::static_abs<D>::value > 0, BOOST_RATIO_RATIO_DENOMINATOR_IS_OUT_OF_RANGE, ());
+    BOOST_RATIO_STATIC_ASSERT(D != 0, BOOST_RATIO_RATIO_DIVIDE_BY_0 , ());
+    static const boost::intmax_t m_na = boost::detail::static_abs<N>::value;
+    static const boost::intmax_t m_da = boost::detail::static_abs<D>::value;
+    static const boost::intmax_t m_s = boost::detail::static_sign<N>::value
+      * boost::detail::static_sign<D>::value;
+    static const boost::intmax_t m_gcd = boost::detail::static_gcd<m_na, m_da>::value;
+public:
+    static const boost::intmax_t num = m_s * m_na / m_gcd;
+    static const boost::intmax_t den = m_da / m_gcd;
+
+    ratio() {}
+
+    template <intmax_t _N2, 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 <intmax_t _N2, 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;}
+
+    typedef ratio<num, den> type;
+};
+
+//----------------------------------------------------------------------------//
+//                                                                            //
+//                             Implementation                                 //
+//                                                                            //
+//----------------------------------------------------------------------------//
+
+template <class R1, class R2>
+struct ratio_add
+{
+#if 0
+public:
+    //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.
+    typedef typename ratio<R1::num * R2::den + R2::num * R1::den,R1::den * R2::den>::type type;
+    // The preceding declaration doesn't works because of overflow on intmax_t.
+#else
+private:
+    static const boost::intmax_t gcd_n1_n2 = boost::detail::static_gcd<R1::num, R2::num>::value;
+    static const boost::intmax_t gcd_d1_d2 = boost::detail::static_gcd<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::detail::ll_add
+               <
+                   boost::detail::ll_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value,
+                   boost::detail::ll_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value
+               >::value,
+               R2::den
+           >
+       >::type type;
+#endif
+};
+
+template <class R1, class R2>
+struct ratio_subtract
+{
+#if 0
+public:
+    //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.
+    typedef typename ratio<R1::num * R2::den - R2::num * R1::den, R1::den * R2::den>::type type;
+    // The preceding declaration doesn't works because of overflow on intmax_t.
+#else
+private:
+    static const boost::intmax_t gcd_n1_n2 = boost::detail::static_gcd<R1::num, R2::num>::value;
+    static const boost::intmax_t gcd_d1_d2 = boost::detail::static_gcd<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::detail::ll_sub
+               <
+                   boost::detail::ll_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value,
+                   boost::detail::ll_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value
+               >::value,
+               R2::den
+           >
+       >::type type;
+#endif
+};
+
+template <class R1, class R2>
+struct ratio_multiply
+{
+#if 0
+public:
+    // The nested typedef type  shall be a synonym for ratio<R1::num * R2::den - R2::num * R1::den, R1::den * R2::den>::type.
+    typedef typename ratio<R1::num * R2::num, R1::den * R2::den>::type type;
+    // The preceding declaration doesn't works because of overflow on intmax_t.
+#else
+private:
+   static const boost::intmax_t gcd_n1_d2 = boost::detail::static_gcd<R1::num, R2::den>::value;
+   static const boost::intmax_t gcd_d1_n2 = boost::detail::static_gcd<R1::den, R2::num>::value;
+public:
+    typedef typename ratio
+       <
+           boost::detail::ll_mul<R1::num / gcd_n1_d2, R2::num / gcd_d1_n2>::value,
+           boost::detail::ll_mul<R2::den / gcd_n1_d2, R1::den / gcd_d1_n2>::value
+       >::type type;
+#endif
+};
+
+template <class R1, class R2>
+struct ratio_divide
+{
+#if 0
+public:
+    // The nested typedef type  shall be a synonym for ratio<R1::num * R2::den, R2::num * R1::den>::type.
+    typedef typename ratio<R1::num * R2::den, R1::den * R2::num>::type type;
+#else
+private:
+    static const boost::intmax_t gcd_n1_n2 = boost::detail::static_gcd<R1::num, R2::num>::value;
+    static const boost::intmax_t gcd_d1_d2 = boost::detail::static_gcd<R1::den, R2::den>::value;
+public:
+    typedef typename ratio
+       <
+           boost::detail::ll_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value,
+           boost::detail::ll_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value
+       >::type type;
+#endif
+};
+
+// 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
+
+
+//----------------------------------------------------------------------------//
+//                              more helpers                                  //
+//----------------------------------------------------------------------------//
+
+namespace detail
+{
+  // Protect against overflow, and still get the right answer as much as possible.
+  //   This just demonstrates for fun how far you can push things without hitting
+  //   overflow.  The obvious and simple implementation is conforming.
+
+  template <class R1, class R2, bool ok1, bool ok2>
+  struct ratio_less3 // true, true and false, false
+  {
+      static const bool value = ll_mul<R1::num,
+        R2::den>::value < ll_mul<R2::num, R1::den>::value;
+  };
+
+  template <class R1, class R2>
+  struct ratio_less3<R1, R2, true, false>
+  {
+      static const bool value = true;
+  };
+
+  template <class R1, class R2>
+  struct ratio_less3<R1, R2, false, true>
+  {
+      static const bool value = false;
+  };
+
+  template <class R1, class R2, bool = (R1::num < R1::den == R2::num < R2::den) >
+  struct ratio_less2  // N1 < D1 == N2 < D2
+  {
+      static const intmax_t max = -((1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1);
+      static const bool ok1 = R1::num <= max / R2::den;
+      static const bool ok2 = R2::num <= max / R1::den;
+      static const bool value = ratio_less3<R1, R2, ok1, ok2>::value;
+  };
+
+  template <class R1, class R2>
+  struct ratio_less2<R1, R2, false>  // N1 < D1 != N2 < D2
+  {
+      static const bool value = R1::num < R1::den;
+  };
+
+  template <class R1, class R2, bool = (R1::num < R1::den == R2::num < R2::den) >
+  struct ratio_less1  // N1 < D1 == N2 < D2
+  {
+      static const bool value = ratio_less2<ratio<R1::num, R2::num>,
+                                            ratio<R1::den, R2::den> >::value;
+  };
+
+  template <class R1, class R2>
+  struct ratio_less1<R1, R2, false>  // N1 < D1 != N2 < D2
+  {
+      static const bool value = R1::num < R1::den;
+  };
+
+  template <class R1, class R2, intmax_t S1 = static_sign<R1::num>::value,
+                                intmax_t S2 = static_sign<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;
+  };
+
+  template <class R1, class R2>
+  struct ratio_gcd
+  {
+    typedef ratio<boost::detail::static_gcd<R1::num, R2::num>::value,
+                  boost::detail::static_lcm<R1::den, R2::den>::value> type;
+  };
+}  // namespace detail
+
+//----------------------------------------------------------------------------//
+//                                                                            //
+//                           more implementation                              //
+//                                                                            //
+//----------------------------------------------------------------------------//
+
+template <class R1, class R2>
+struct ratio_less
+  : public boost::integral_constant<bool, boost::detail::ratio_less<R1, R2>::value> {};
+
+template <class R1, class R2>
+struct ratio_less_equal
+    : public boost::integral_constant<bool, !ratio_less<R2, R1>::value> {};
+
+template <class R1, class R2>
+struct ratio_greater
+    : public boost::integral_constant<bool, ratio_less<R2, R1>::value> {};
+
+template <class R1, class R2>
+struct ratio_greater_equal
+    : public boost::integral_constant<bool, !ratio_less<R1, R2>::value> {};
+
+}  // namespace boost
+
+#ifdef BOOST_RATIO_STATIC_ASSERT
+#undef BOOST_RATIO_STATIC_ASSERT
+#endif
+
+#endif  // BOOST_RATIO_HPP