/* $Id: vector.hpp,v 1.19 2005/11/20 16:15:28 pohlt Exp $ */

#ifndef _VECTOR_HPP_
#define _VECTOR_HPP_

/**********************************************************/

#include "global.hpp"
#include "serialize.hpp"
#include <cmath>

/**********************************************************/

template<class T> class VectorTemplate {
	public:
		T x, y;
		VectorTemplate<T> ( const T initX = 0, const T initY = 0 ): x (initX), y (initY) {}
		VectorTemplate<T>& set( const T initX, const T initY ) {x = initX; y = initY; return *this;}
		VectorTemplate<T>& setAngle( const T angle, const T length ) {x = length * COS_REAL( angle );
		                                                              y = length * SIN_REAL( angle );
		                                                              return *this;}
		bool operator==( const VectorTemplate<T>& a ) { return x == a.x && y == a.y; }
		VectorTemplate<T>& operator+=( const VectorTemplate<T>& a ) {x += a.x; y += a.y; return *this;}
		VectorTemplate<T>& operator-=( const VectorTemplate<T>& a ) {x -= a.x; y -= a.y; return *this;}
		VectorTemplate<T>& operator*=( const T a ) {x *= a; y *= a; return *this;}
		VectorTemplate<T>& operator/=( const T a ) {x /= a; y /= a; return *this;}
		VectorTemplate<T> operator+( const VectorTemplate<T>& b ) const {return VectorTemplate<T>( x+b.x, y+b.y );}
		VectorTemplate<T> operator-( const VectorTemplate<T>& b ) const {return VectorTemplate<T>( x-b.x, y-b.y );}
		VectorTemplate<T> operator-( void ) const {return VectorTemplate<T>( -x, -y );}
		VectorTemplate<T> operator*( const T a ) const {return VectorTemplate<T>( x*a, y*a );}
		VectorTemplate<T> operator/( const T a ) const {return VectorTemplate<T>( x/a, y/a );}
		T operator*( const VectorTemplate<T>& b ) const {return x*b.x + y*b.y;}
		T abs2() const {return (x*x + y*y);}
		T abs() const {return SQRT_REAL( this->abs2() );}
		VectorTemplate<T> getNorm() const {VectorTemplate<T> aux( *this ); aux /= this->abs(); return aux;}
		VectorTemplate<T>& normalize() {(*this) /= this->abs(); return *this;}
		VectorTemplate<int> getIntVector() const;
};

template<class T> VectorTemplate<T> elementProd( const VectorTemplate<T>& a,
                                                 const VectorTemplate<T>& b ) {
	return VectorTemplate<T>( a.x*b.x, a.y*b.y );
}


// A specialization of the Serialize class for Vectors

template <class T>
class Serialize<VectorTemplate<T> > {
	public:
		static Uint32 sizeOf( VectorTemplate<T> item ) {
			return 2 * Serialize<T>::sizeOf();
		}
		static Uint32 sizeOf() {
			return 2 * Serialize<T>::sizeOf();
		}
		
		/* This method serializes one data value stored in item into the
		 * memory starting at buffer
		 */
		static void serialize( VectorTemplate<T> item, Uint8*& buffer ) {
			Serialize<T>::serialize( item.x, buffer );
			Serialize<T>::serialize( item.y, buffer );
		}
		
		/* This method serializes numberItems data values stored consecutively
		 * in the array item into the memory starting at buffer
		 */
		static void serialize( int numberItems, VectorTemplate<T>* item, Uint8*& buffer ) {
			for (int i = 0; i < numberItems; i++) {
				serialize( item[i], buffer );
			}
		}
		
		/* This method deserializes one data value to be stored in item from the
		 * memory starting at buffer
		 */
		static void deserialize( Uint8*& buffer, VectorTemplate<T>& item ) {
			Serialize<T>::deserialize( buffer, item.x );
			Serialize<T>::deserialize( buffer, item.y );
		}
		
		/* This method deserializes numberItems data values to be stored consecutively
		 * in the array item from the memory starting at buffer
		 */
		static void deserialize( int numberItems, Uint8*& buffer, VectorTemplate<T>* item ) {
			for ( int i = 0; i < numberItems; i++) {
				deserialize( buffer, item[i] );
			}
		}
};

/**********************************************************/

typedef VectorTemplate<real> Vector;
typedef VectorTemplate<int> IntVector;

/**********************************************************/

template<> inline IntVector Vector::getIntVector() const {
	return IntVector( ROUND( x ), ROUND( y ) );
}

/**********************************************************/

template<> inline IntVector IntVector::getIntVector() const {
	return *this;
}

/**********************************************************/

inline Vector operator+( const Vector& a, const IntVector& b ) {
	return Vector( a.x + b.x, a.y + b.y );
}

/**********************************************************/

inline Vector operator-( const Vector& a, const IntVector& b ) {
	return Vector( a.x + b.x, a.y + b.y );
}

/**********************************************************/

inline Vector operator+( const IntVector& a, const Vector& b ) {
	return Vector( a.x + b.x, a.y + b.y );
}

/**********************************************************/

inline Vector operator-( const IntVector& a, const Vector& b ) {
	return Vector( a.x + b.x, a.y + b.y );
}

/**********************************************************/

#endif // _VECTOR_HPP_