#ifndef _XYZ_TYPE_H
#define _XYZ_TYPE_H

#include <ostream>
#include <iomanip>
#include <boost/lambda/lambda.hpp>

template<typename T>
struct xyz_type
{ 
  T x;
  T y;
  T z;

  xyz_type(void) : x(T()), y(T()), z(T()) 
  { }

  xyz_type(const T& val) : x(val), y(val), z(val) 
  { }
      
  xyz_type(const T& xx, const T& yy, const T& zz) : 
    x(xx), y(yy), z(zz) 
  { }

  xyz_type& operator=(const xyz_type other) 
  {
    this->x = other.x;
    this->y = other.y; 
    this->z = other.z;
    return *this;
  }

  xyz_type& operator=(const T& val) 
  {
    this->x = this->y = this->z = val;
    return *this;
  }
};

template <typename T>
inline std::ostream& operator<<(std::ostream& s, const xyz_type<T>& val)
{
  return s << std::setprecision(9) << std::setw(15) << val.x << "  " 
	   << std::setw(15) << val.y << "  " << std::setw(15) << val.z;
}

template <typename T>
inline xyz_type<T> operator+(const xyz_type<T>& u, const xyz_type<T>& v)
{
  return (xyz_type<T>(u.x + v.x, u.y + v.y, u.z + v.z));
}

template <typename T>
inline xyz_type<T> operator-(const xyz_type<T>& u, const xyz_type<T>& v)
{
  return (xyz_type<T>(u.x - v.x, u.y - v.y, u.z - v.z));
}

template <typename T>
inline xyz_type<T> operator+(const xyz_type<T>& u, const T& v)
{
  return (xyz_type<T>(u.x + v, u.y + v, u.z + v));
}

template <typename T>
inline xyz_type<T> operator*(const xyz_type<T>& u, const xyz_type<T>& v)
{
  return (xyz_type<T>(u.x * v.x, u.y * v.y, u.z * v.z));
}

template <typename T>
inline xyz_type<T> operator*(const T& u, const xyz_type<T>& v)
{
  return (xyz_type<T>(u * v.x, u * v.y, u * v.z));
}

template <typename T>
inline xyz_type<T> operator*(const xyz_type<T>& u, const T& v)
{
  return (xyz_type<T>(u.x * v, u.y * v, u.z * v));
}

template <typename T>
inline xyz_type<T> operator/(const xyz_type<T>& u, const xyz_type<T>& v)
{
  return (xyz_type<T>(u.x / v.x, u.y / v.y, u.z / v.z));
}


template <typename T>
inline xyz_type<T> operator/(const xyz_type<T>& u, const T& v)
{
  return (xyz_type<T>(u.x / v, u.y / v, u.z / v));
}

template <class T>
inline bool operator==(const xyz_type<T>& u, const xyz_type<T>& v)
{ 
  return(u.x == v.x && u.y == v.y && u.z == v.z);
}

template <class T>
inline bool operator<(const xyz_type<T>& u, const xyz_type<T>& v)
{ 
  return(u.x < v.x || (!(u.x < v.x) &&
	 (u.y < v.y || (!(v.y < u.y) && u.z < v.z))));
}

template <class T>
inline bool operator!=(const xyz_type<T>& x, const xyz_type<T>& y)
{
  return(!(x == y));
}

template <class T>
inline bool operator>(const xyz_type<T>& x, const xyz_type<T>& y)
{
  return(y < x);
}


template <class T>
inline bool operator<=(const xyz_type<T>& x, const xyz_type<T>& y)
{
  return(!(y < x));
}


template <class T>
inline bool operator>=(const xyz_type<T>& x, const xyz_type<T>& y)
{
  return(!(x < y));
}

//Boost-Fu to make the above operators work with lambda transparently (no return type specification)
namespace boost {
  namespace lambda {
    template<class Act, class T>
      struct plain_return_type_2<arithmetic_action<Act>, xyz_type<T>, xyz_type<T> > 
      {
	typedef xyz_type<T> type;
      };

  template<class Act, class T>
    struct plain_return_type_2<arithmetic_action<Act>, T, xyz_type<T> > 
    {
      typedef xyz_type<T> type;
    };
  }
}

#endif