#include <cstdlib>
#include <iostream>
#include <sstream>
#include <string>
#include <typeinfo>
#include <vector>

#include <boost/mpl/list.hpp>
#include <boost/mpl/size.hpp>

#include <mcs/units/dimension.hpp>
#include <mcs/units/static_rational.hpp>

template<class T>
void write_typeid()
{
    std::system((std::string("c++filt ")+
                 std::string(typeid(T).name())).c_str());
    std::cout << std::endl;
}

template<class T>
void write_typeid(const T&)
{
    write_typeid<T>();
}

struct t1 { };
struct t2 { };
struct t3 { };
struct t4 { };

using namespace mcs;
using namespace mcs::units;

int main()
{
    typedef Rational<1>     r1;
    typedef Rational<2>     r2;
    typedef Rational<3>     r3;
    typedef Rational<-3>    rm3;
    
    typedef boost::mpl::list<dim<t1,r1>,
                             dim<t2,r1>,
                             dim<t3,r1>,
                             dim<t2,r2>,
                             dim<t3,r1>,
                             dim<t2,r3>,
                             dim<t4,r3> >    l1;
    typedef boost::mpl::list<dim<t3,r2>,
                             dim<t1,r2>,
                             dim<t2,r1>,
                             dim<t4,rm3> >   l2;
    typedef boost::mpl::list<dim<t1,r1>,
                             dim<t1,r1>,
                             dim<t1,r1>,
                             dim<t1,rm3> >    l3;   
    
    long    sz = boost::mpl::size<l1>::value;
    
    typedef Negate<l2>::type         n1;
    write_typeid<n1>();
    
    typedef Add<l2,l2>::type         a1;
    write_typeid<a1>();
    
    typedef Subtract<l2,l2>::type    s1;
    write_typeid<s1>();
    
    typedef Multiply<l1,l2>::type    m1;
    write_typeid<m1>();
    
    typedef Divide<l1,l2>::type      d1;
    write_typeid<d1>();
    
    typedef Power<l1,Rational<2,3> >::type    pw1;
    write_typeid<pw1>();
    
    typedef Root<pw1,Rational<2,3> >::type    rt1;
    write_typeid<rt1>();
    
    typedef reduce_dimension<l3>::type   rd1;
    write_typeid<rd1>();
    
    BOOST_STATIC_ASSERT((boost::is_same<
                                        rd1,
                                        dimensionless_type
                                       >::value == true));
        
    return 0;
}