#ifndef BOOST_UTILITY_RATIO_HPP_INCLUDED_19JUN08
#define BOOST_UTILITY_RATIO_HPP_INCLUDED_19JUN08

#include <boost/mpl/long.hpp>
#include <boost/mpl/divides.hpp>
#include <boost/mpl/equal_to.hpp>
#include <boost/static_assert.hpp>
#include <boost/mpl/comparison.hpp>
#include <boost/mpl/arithmetic.hpp>
#include <boost/mpl/integral_c.hpp>
#include <boost/math/common_factor.hpp>
#include <boost/type_traits/integral_constant.hpp>
///////////////////////////////////////////////////////////
#include "abs.hpp"
#include "sign.hpp"
//#include "intmax_t_gcd.hpp"

namespace boost { namespace utility {

  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<1, 1000000000000000000000000> yocto;  // conditionally supported
  //typedef ratio<1,    1000000000000000000000> zepto;  // conditionally supported
  //typedef ratio<1,       1000000000000000000> atto;
  //typedef ratio<1,          1000000000000000> femto;
  //typedef ratio<1,             1000000000000> pico;
  typedef ratio<1,                1000000000> nano;
  typedef ratio<1,                   1000000> micro;
  typedef ratio<1,                      1000> milli;
  typedef ratio<1,                       100> centi;
  typedef ratio<1,                        10> deci;
  typedef ratio<                       10, 1> deca;
  typedef ratio<                      100, 1> hecto;
  typedef ratio<                     1000, 1> kilo;
  typedef ratio<                  1000000, 1> mega;
  typedef ratio<               1000000000, 1> giga;
  //typedef ratio<            1000000000000, 1> tera;
  //typedef ratio<         1000000000000000, 1> peta;
  //typedef ratio<      1000000000000000000, 1> exa;
  //typedef ratio<   1000000000000000000000, 1> zetta;  // conditionally supported
  //typedef ratio<1000000000000000000000000, 1> yotta;  // conditionally supported

///////////////////////////////////////////////////////////

#define DIVIDE_BY_ZERO_ERROR 0

  // ratio.ratio

  template<boost::intmax_t N, boost::intmax_t D>
  class ratio
  {
    // Print a diagnostic if trying to divide by zero
    BOOST_STATIC_ASSERT(( D != 0 ));

    typedef
    boost::integral_constant<
        boost::intmax_t
      , boost::math::static_gcd<N,D>::value
    >
    gcd_type; // so we only instantiate it once
   
  public:
  
    // numerator
    BOOST_STATIC_CONSTANT(
        boost::intmax_t
      , num = (boost::mpl::divides<
                   boost::integral_constant<
                       boost::intmax_t
                     , temp::sign<N>::value * temp::sign<D>::value * temp::abs<N>::value
                   >
                 , gcd_type>::type::value)
    );
  
    // denominator
    BOOST_STATIC_CONSTANT(
        boost::intmax_t
      , den = (boost::mpl::divides<
                    boost::integral_constant<
                        boost::intmax_t
                      , temp::abs<D>::value
                    >
                  , gcd_type>::type::value)
    );
  };

  // ratio.arithmetic

  template<class R1, class R2>
  struct ratio_add
  {
    typedef ratio<R1::num * R2::den + R2::num * R1::den, R1::den * R2::den> type;
  };

  template<class R1, class R2>
  struct ratio_subtract
  {
    typedef ratio<R1::num * R2::den - R2::num * R1::den, R1::den * R2::den> type;
  };

  template<class R1, class R2>
  struct ratio_multiply
  {
    typedef ratio<R1::num * R2::num, R1::den * R2::den> type;
  };

  template<class R1, class R2>
  struct ratio_divide
  {
    typedef ratio<R1::num * R2::den, R1::den * R2::num> type;
  };

  // ratio.comparison

  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_less
  : public boost::integral_constant<
               bool
             , (R1::num * R2::den < R2::num * R1::den) // **FIXME** this is a bit dumb
           >
  {};

  template <class R1, class R2> struct ratio_not_equal
  : public boost::integral_constant<bool, !ratio_equal<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 utility
} // namespace boost

#endif // BOOST_UTILITY_RATIO_HPP_INCLUDED_19JUN08