/**

 2 dimensional vector (plainvector) implementation

 */

 #ifndef HUGO_XY_H

 #define HUGO_XY_H

 #include <iostream>

 using namespace std;

 template<typename T>

 class xy {

   T _x,_y;

 public:

   ///Default constructor: both coordinates become 0

   xy() { _x=_y=0; }

   ///Constructing from coordinates

   xy(T a, T b) { _x=a; _y=b; }

   ///Gives back the x coordinate

   T x(){

     return _x;

   };

   ///Gives back the y coordinate

   T y(){

     return _y;

   };

   ///Gives back the square of the norm of the vector

   T normSquare(){

     return _x*_x+_y*_y;

   };

   ///Increments the left hand side by u

   xy<T>& operator +=(const xy<T>& u){

     _x += u._x;

     _y += u._y;

     return *this;

   };

   ///Decrements the left hand side by u

   xy<T>& operator -=(const xy<T>& u){

     _x -= u._x;

     _y -= u._y;

     return *this;

   };

   ///Multiplying the left hand side with a scalar

   xy<T>& operator *=(const T &u){

     _x *= u;

     _y *= u;

     return *this;

   };

   ///Returns the scalar product of two vectors

   T operator *(const xy<T>& u){

     return _x*u._x+_y*u._y;

   };

   ///Returns the sum of two vectors

   xy<T> operator+(const xy<T> &u) const {

     xy<T> b=*this;

     return b+=u;

   };

   ///Returns the difference of two vectors

   xy<T> operator-(const xy<T> &u) const {

     xy<T> b=*this;

     return b-=u;

   };

   ///Returns a vector multiplied by a scalar

   xy<T> operator*(const T &u) const {

     xy<T> b=*this;

     return b*=u;

   };

   ///Testing equality

   bool operator==(const xy<T> &u){

     return (_x==u._x) && (_y==u._y);

   };

   ///Testing inequality

   bool operator!=(xy u){

     return  (_x!=u._x) || (_y!=u._y);

   };

 };

 ///Reading a plainvector from a stream

 template<typename T>

 inline

 istream& operator>>(istream &is, xy<T> &z)

 {

   ///This is not the best solution here: I didn't know how to solve this with friend functions

   T a,b;

   is >> a >> b;

   xy<T> buf(a,b);

   z=buf;

   return is;

 }

 ///Outputting a plainvector to a stream

 template<typename T>

 inline

 ostream& operator<<(ostream &os, xy<T> z)

 {

 	os << "(" << z.x() << ", " << z.y() << ")";

 	return os;

 }

 #endif //HUGO_XY_H