exercise-3-5.hpp

Go to the documentation of this file.

// ===-- chapter-3/exercise-3-5.hpp ----------------------- -*- C++ -*- --=== //
#ifndef EXERCISE_3_5
#define EXERCISE_3_5
 
#include <boost/static_assert.hpp>
 
#include <boost/mpl/equal.hpp>
#include <boost/mpl/transform.hpp>
#include <boost/mpl/vector_c.hpp>
 
#include <boost/mpl/placeholders.hpp>
using namespace boost::mpl::placeholders;
 
 
namespace exercise_3_5 {
 
namespace section_3_1 {
 
// No units!
typedef boost::mpl::vector_c<int, 0, 0, 0, 0, 0, 0, 0> scalar;
 
// Simple dimensions
typedef boost::mpl::vector_c<int, 1, 0, 0, 0, 0, 0, 0> mass;
typedef boost::mpl::vector_c<int, 0, 1, 0, 0, 0, 0, 0> length;
typedef boost::mpl::vector_c<int, 0, 0, 1, 0, 0, 0, 0> time;
typedef boost::mpl::vector_c<int, 0, 0, 0, 1, 0, 0, 0> charge;
typedef boost::mpl::vector_c<int, 0, 0, 0, 0, 1, 0, 0> temperature;
typedef boost::mpl::vector_c<int, 0, 0, 0, 0, 0, 1, 0> intensity;
typedef boost::mpl::vector_c<int, 0, 0, 0, 0, 0, 0, 1> amount_of_substance;
 
// More complicated units
typedef boost::mpl::vector_c<int, 0, 1, -1, 0, 0, 0, 0> velocity;
typedef boost::mpl::vector_c<int, 0, 1, -2, 0, 0, 0, 0> acceleration;
typedef boost::mpl::vector_c<int, 1, 1, -1, 0, 0, 0, 0> momentum;
typedef boost::mpl::vector_c<int, 1, 1, -2, 0, 0, 0, 0> force;
 
template <typename T, typename Dimension>
class quantity
{
public:
    explicit quantity(T const x)
        : m_value(x) { }
 
    template <typename OtherDimension>
    quantity(quantity<T,OtherDimension> const& rhs)
        : m_value(rhs.value())
    {
        BOOST_STATIC_ASSERT(
            (boost::mpl::equal<Dimension,OtherDimension>::type::value));
    }
 
    T value() const { return m_value; }
 
private:
    T m_value;
};
 
// Exercise 3-5 requires the addition of D2, allowing the addition of
// equivalent matrices with non-directly-convertable types.
 
template <typename T, typename D1, typename D2>
quantity<T,D1> operator+(quantity<T,D1> const& x, quantity<T,D2> const& y)
{
    BOOST_STATIC_ASSERT((boost::mpl::equal<D1,D2>::type::value));
    return quantity<T,D1>(x.value() + y.value());
}
 
template <typename T, typename D1, typename D2>
quantity<T,D1> operator-(quantity<T,D1> const& x, quantity<T,D2> const& y)
{
    return quantity<T,D1>(x.value() - y.value());
}
 
// Exercise 3-5: Let's allow multiplication and division of quantities by
// processing their dimensions.
 
template<typename D1, typename D2>
struct divide_dimensions
    : boost::mpl::transform<D1,D2,boost::mpl::minus<_1,_2> > { };
 
template<typename D1, typename D2>
struct multiply_dimensions
    : boost::mpl::transform<D1,D2,boost::mpl::plus<_1,_2> > { };
 
template <typename T, typename D1, typename D2>
quantity<T, typename multiply_dimensions<D1,D2>::type>
operator*(quantity<T,D1> const& x, quantity<T,D2> const& y)
{
    return quantity<T, typename multiply_dimensions<D1,D2>::type>(
        x.value() * y.value());
}
 
template <typename T, typename D1, typename D2>
quantity<T, typename divide_dimensions<D1,D2>::type>
operator/(quantity<T,D1> const& x, quantity<T,D2> const& y)
{
    return quantity<T, typename divide_dimensions<D1,D2>::type>(
        x.value() / y.value());
}
 
} // namespace section_3_1
} // namespace exercise_3_5
 
#endif // EXERCISE_3_5