/**

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