C:/nobackup/private/physical_svn/trunk/include/physical/detail/static_rational.hpp

Go to the documentation of this file.

// mcs::units - A C++ library for zero-overhead dimensional analysis and 
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2007 Matthias Christian Schabel
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_UNITS_STATIC_RATIONAL_HPP 
#define BOOST_UNITS_STATIC_RATIONAL_HPP


#include <boost/math/common_factor.hpp>

//#include <boost/units/operators.hpp>


namespace mcs {

namespace units { 

   
template<typename R> struct static_negate;

template<typename R1,typename R2> struct static_add;

template<typename R1,typename R2> struct static_subtract;

template<typename R1,typename R2> struct static_multiply;

template<typename R1,typename R2> struct static_divide;

template<typename R1,typename R2> struct static_power;


typedef long   integer_type;

template<integer_type Value>
struct static_abs
{
    BOOST_STATIC_CONSTANT(integer_type,value) = Value < 0 ? -Value : Value;
};


template<integer_type N,integer_type D = 1>
class static_rational
{
    private:
        static const integer_type   nabs = static_abs<N>::value,
                                    dabs = static_abs<D>::value;
        
        // need cast to signed because static_gcd returns unsigned long
        static const integer_type       den = 
            static_cast<integer_type>(boost::math::static_gcd<nabs,dabs>::value);
        
    public:   
        static const integer_type   Numerator = N/den,
                                    Denominator = D/den;
        
        typedef static_rational<N,D>    this_type;
        
                typedef static_rational<Numerator,Denominator>  type;
                                 
        static integer_type numerator()      { return Numerator; }
        static integer_type denominator()    { return Denominator; }
        
        static_rational() { }
        //~static_rational() { }
};

// prohibit zero denominator
template<integer_type N> class static_rational<N,0>;

// get decimal value of static_rational
#ifdef MCS_HAS_TYPEOF
template<class T,integer_type N,integer_type D>
typename divide_typeof_helper<T,T>::type 
value(const static_rational<N,D>& r)
{
    return T(N)/T(D);
}
#else
template<class T,integer_type N,integer_type D>
T value(const static_rational<N,D>& r)
{
        //return T(r.numerator())/T(r.denominator());
        return T(N)/T(D);
}
#endif

template<integer_type N,integer_type D> 
struct static_negate< static_rational<N,D> >    
{ 
    typedef typename static_rational<-N,D>::type    type; 
};

template<integer_type N1,integer_type D1,
         integer_type N2,integer_type D2> 
struct static_add< static_rational<N1,D1>,static_rational<N2,D2> >    
{ 
    typedef typename static_rational<N1*D2+N2*D1,D1*D2>::type    type; 
};

template<integer_type N1,integer_type D1,
         integer_type N2,integer_type D2> 
struct static_subtract< static_rational<N1,D1>,static_rational<N2,D2> >
{ 
    typedef typename static_rational<N1*D2-N2*D1,D1*D2>::type    type; 
};

template<integer_type N1,integer_type D1,
         integer_type N2,integer_type D2> 
struct static_multiply< static_rational<N1,D1>,static_rational<N2,D2> >    
{ 
    typedef typename static_rational<N1*N2,D1*D2>::type    type; 
};

template<integer_type N1,integer_type D1,
         integer_type N2,integer_type D2> 
struct static_divide< static_rational<N1,D1>,static_rational<N2,D2> >    
{ 
    typedef typename static_rational<N1*D2,D1*N2>::type    type; 
};


} // namespace units

} // namespace mcs

#endif // BOOST_UNITS_STATIC_RATIONAL_HPP

---

hosted on