/*
 *  vectors.h
 */

template<class C> class Vect
{
  public:
    C x, y, z;
	Vect();
	Vect(C a);
	Vect(C a, C b, C c);
	Vect<C>& operator+=(Vect<C> v);
	Vect<C>& operator-=(Vect<C> v);
	Vect<C>& operator+=(C a);
	Vect<C>& operator-=(C a);
	Vect<C>& operator*=(C a);
	Vect<C>& operator/=(C a);
	Vect<C> operator-();
	bool operator>(Vect<C> v);
	bool operator<(Vect<C> v);
	C length();
	Vect<C> normalize();
	void self_normalize();
	Vect<C> rotate_x(C a);
	Vect<C> rotate_y(C a);
	Vect<C> rotate_z(C a);
};
template<class C> Vect<C>::Vect() { x = 0; y = 0; z = 0; }
template<class C> Vect<C>::Vect(C a) { x = a; y = a; z = a; }
template<class C> Vect<C>::Vect(C a, C b, C c) { x = a; y = b; z = c; }
template<class C> Vect<C>& Vect<C>::operator+=(Vect<C> v) { x += v.x; y += v.y; z += v.z; return *this; }
template<class C> Vect<C>& Vect<C>::operator-=(Vect<C> v) { x -= v.x; y -= v.y; z -= v.z; return *this; }
template<class C> Vect<C>& Vect<C>::operator+=(C a) { x += a; y += a; z += a; return *this; }
template<class C> Vect<C>& Vect<C>::operator-=(C a) { x -= a; y -= a; z -= a; return *this; }
template<class C> Vect<C>& Vect<C>::operator*=(C a) { x *= a; y *= a; z *= a; return *this; }
template<class C> Vect<C>& Vect<C>::operator/=(C a) { x /= a; y /= a; z /= a; return *this; }
template<class C> Vect<C> Vect<C>::operator-()
{
  Vect<C> result;
  result.x = -this->x;
  result.y = -this->y;
  result.z = -this->z;
  return result;
}
template<class C> bool Vect<C>::operator>(Vect<C> v) { return (x > v.x && y > v.y && z > v.z); }
template<class C> bool Vect<C>::operator<(Vect<C> v) { return (x < v.x && y < v.y && z < v.z); }
template<class C> C Vect<C>::length() { return sqrt(x*x + y*y + z*z); }
template<class C> Vect<C> Vect<C>::normalize()
{
  Vect<C> result;
  result.x = x/this->length();
  result.y = y/this->length();
  result.z = z/this->length();
  return result;
}
template<class C> void Vect<C>::self_normalize()
{
  C len = this->length();
  x /= len;
  y /= len;
  z /= len;
}

// temporary rotation methods until I get transforms sorted out
template<class C> Vect<C> Vect<C>::rotate_x(C a)
{
  Vect<C> result;
  result.x = x;
  result.y = y*cos(a) - z*sin(a);
  result.z = y*sin(a) + z*cos(a);
  return result;
}
template<class C> Vect<C> Vect<C>::rotate_y(C a)
{
  Vect<C> result;
  result.x = x*cos(a) + z*sin(a);
  result.y = y;
  result.z = -x*sin(a) + z*cos(a);
  return result;
}
template<class C> Vect<C> Vect<C>::rotate_z(C a)
{
  Vect<C> result;
  result.x = x*cos(a) - y*sin(a);
  result.y = x*sin(a) + y*cos(a);
  result.z = z;
  return result;
}

template<class C> Vect<C> operator+(Vect<C> a, Vect<C> b) { Vect<C> result = a; return result += b; }
template<class C> Vect<C> operator-(Vect<C> a, Vect<C> b) { Vect<C> result = a; return result -= b; }
template<class C> Vect<C> operator+(Vect<C> a, C b) { Vect<C> result = a; return result += b; }
template<class C> Vect<C> operator-(Vect<C> a, C b) { Vect<C> result = a; return result -= b; }
template<class C> Vect<C> operator*(Vect<C> a, C b) { Vect<C> result = a; return result *= b; }
template<class C> Vect<C> operator*(C b, Vect<C> a) { Vect<C> result = a; return result *= b; }
template<class C> Vect<C> operator/(Vect<C> a, C b) { Vect<C> result = a; return result /= b; }

template<class C> Vect<C> normalize(Vect<C> a) { Vect<C> result = a; return a.normalize(); }
template<class C> C dot(Vect<C> a, Vect<C> b) { return a.x*b.x + a.y*b.y + a.z*b.z; }
template<class C> Vect<C> cross(Vect<C> a, Vect<C> b)
{
  Vect<C> result;
  result.x = a.y*b.z - a.z*b.y;
  result.y = a.z*b.x - a.x*b.z;
  result.z = a.x*b.y - a.y*b.x;
  return result;
}