//Ê (C) 2003 Matthias Christian Schabel. Permission to copy, use, modify, sell and
//Ê distribute this software is granted provided this copyright notice appears
//Ê in all copies.  This software is provided "as is" without express or implied
//Ê warranty, and with no claim as to its suitability for any purpose.  Any use of 
//  this library or any part thereof in a commerical product must be acknowledged
//  in the copyright of that product.  

#ifndef MCS_STATIC_RATIONAL_HPP
#define MCS_STATIC_RATIONAL_HPP

#include <string>

#include <boost/math/common_factor.hpp>

namespace mcs {

namespace units { 

// compile time absolute value
template<long Value>
struct static_abs
{
    BOOST_STATIC_CONSTANT(long,value)
     = Value < 0 ? -Value : Value;
};

// generic compile time arithmetic operators 
template<typename R> struct Negate;
template<typename R1,typename R2> struct Add;
template<typename R1,typename R2> struct Subtract;
template<typename R1,typename R2> struct Multiply;
template<typename R1,typename R2> struct Divide;
template<typename R1,typename R2> struct Power;
template<typename R1,typename R2> struct Root;

// compile time rational number
template<long N,long D = 1>
struct Rational
{
	static const long           nabs = static_abs<N>::value,
                                dabs = static_abs<D>::value;
                                
	static const unsigned long	nden = 
	                                boost::math::static_gcd<nabs,dabs>::value,
                                dden = 
                                    boost::math::static_gcd<nabs,dabs>::value;
                                
    // need cast to signed because static_gcd returns unsigned long
    static const long    Numerator = N/static_cast<long>(nden),
                         Denominator = D/static_cast<long>(dden);
    
    static long numerator()      { return Numerator; }
    static long denominator()    { return Denominator; }
    
    Rational() { }
};

// prohibit zero denominator
template<long N> struct Rational<N,0>;

// get decimal value of Rational
template<class T,long N,long D>
T value(const Rational<N,D>& r)
{
    return static_cast<T>(r.numerator())/static_cast<T>(r.denominator());
}

// reduce rational type to lowest common denominator
template<long N,long D>
struct ReduceRational
{
    typedef Rational<N,D>                                          arg_type;
    typedef Rational<arg_type::Numerator,arg_type::Denominator>    type;
};

// negate rational number
template<long N,long D> 
struct Negate< Rational<N,D> >    
{ 
    typedef typename ReduceRational<-N,D>::type    type; 
};

// add rational numbers
template<long N1,long D1,long N2,long D2> 
struct Add< Rational<N1,D1>,Rational<N2,D2> >    
{ 
    typedef typename ReduceRational<N1*D2+N2*D1,D1*D2>::type    type; 
};

// subtract rational numbers
template<long N1,long D1,long N2,long D2> 
struct Subtract< Rational<N1,D1>,Rational<N2,D2> >
{ 
    typedef typename ReduceRational<N1*D2-N2*D1,D1*D2>::type    type; 
};

// multiply rational numbers
template<long N,long D,long M> 
struct Multiply< Rational<N,D>,Rational<M> >    
{ 
    typedef typename ReduceRational<N*M,D>::type    type; 
};

template<long N1,long D1,long N2,long D2> 
struct Multiply< Rational<N1,D1>,Rational<N2,D2> >    
{ 
    typedef typename ReduceRational<N1*N2,D1*D2>::type    type; 
};

// divide rational numbers
template<long N,long D,long M> 
struct Divide< Rational<N,D>,Rational<M> >    
{
    typedef typename ReduceRational<N,D*M>::type    type; 
};

template<long N1,long D1,long N2,long D2> 
struct Divide< Rational<N1,D1>,Rational<N2,D2> >    
{ 
    typedef typename ReduceRational<N1*D2,D1*N2>::type    type; 
};

} // namespace units

} // namespace mcs

#endif // MCS_STATIC_RATIONAL_HPP