// (c) Copyright 2010 Terry Golubiewski, all rights reserved.

#ifndef CARTESIAN_UNITS_H
#define CARTESIAN_UNITS_H
#pragma once

#include <cartesian/vector.h>

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

namespace cartesian {

template<class Units, int Dim, class Rep> inline
boost::units::quantity<Units, Rep> 
operator*(const boost::units::quantity<Units, vector<Dim, Rep> >& x,
          const boost::units::quantity<Units, vector<Dim, Rep> >& y)
{
  typedef boost::units::quantity<Units, Rep> return_type;
  return return_type::from_value(x.value() * y.value());
}

template<class Units, class Rep> inline
boost::units::quantity<Units, vector<3, Rep> > 
cross_product(const boost::units::quantity<Units, vector<3, Rep> >& x,
              const boost::units::quantity<Units, vector<3, Rep> >& y)
{
  typedef boost::units::quantity<Units, vector<3, Rep> > return_type;
  return return_type::from_value(cross_product(x.value(), y.value()));
}

template<class Units, int Dim, class Rep> inline
boost::units::quantity<Units, Rep>
abs(const boost::units::quantity<Units, vector<Dim, Rep> >& v)
  { return boost::units::quantity<Units, Rep>::from_value(abs(v.value())); }

template<class Units> inline
boost::units::quantity<Units>
abs(const boost::units::quantity<Units, vector2d>& v)
  { return boost::units::quantity<Units>::from_value(abs(v.value())); }

template<class Units> inline
boost::units::quantity<Units>
abs(const boost::units::quantity<Units, vector3d>& v)
  { return boost::units::quantity<Units>::from_value(abs(v.value())); }

template<class Units, int Dim, class Rep> inline
typename boost::units::power_typeof_helper<
    boost::units::quantity<Units, Rep>, boost::units::static_rational<2> >
::type abs_squared(const boost::units::quantity<Units, vector<Dim, Rep> >& v) {
  typedef typename boost::units::power_typeof_helper<
      quantity<Units, Rep>, boost::units::static_rational<2>
    >::type return_type;
  return return_type::from_value(abs_squared(v.value()));
} // abs_squared

template<class Units> inline
typename boost::units::power_typeof_helper<
    boost::units::quantity<Units>, boost::units::static_rational<2> >
::type abs_squared(const boost::units::quantity<Units, vector2d>& v) {
  typedef typename boost::units::power_typeof_helper<
      quantity<Units>, boost::units::static_rational<2> >::type return_type;
  return return_type::from_value(abs_squared(v.value()));
} // abs_squared

template<class Units> inline
typename boost::units::power_typeof_helper<
    boost::units::quantity<Units>, boost::units::static_rational<2> >
::type abs_squared(const boost::units::quantity<Units, vector3d>& v) {
  typedef typename boost::units::power_typeof_helper<
      quantity<Units>, boost::units::static_rational<2> >::type return_type;
  return return_type::from_value(abs_squared(v.value()));
} // abs_squared

} // cartesian

#endif