// -*- c++ -*-
/**
2 dimensional vector (plainvector) implementation

*/
#ifndef HUGO_XY_H
#define HUGO_XY_H

#include <iostream>

namespace hugo {

  template<typename T>
    class xy {

    public:

      T x,y;     
      
      ///Default constructor: both coordinates become 0
      xy() : x(0), y(0) {}

      ///Constructing the instance from coordinates
      xy(T a, T b) : x(a), y(a) { }


      ///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;
      };

      ///Dividing the left hand side by 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;
      };

      ///Returns a vector divided 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
  std::istream& operator>>(std::istream &is, xy<T> &z)
  {

    is >> z.x >> z.y;
    return is;
  }

  ///Outputting a plainvector to a stream
  template<typename T>
  inline
  std::ostream& operator<<(std::ostream &os, xy<T> z)
  {
    os << "(" << z.x << ", " << z.y << ")";
    return os;
  }

} //namespace hugo

#endif //HUGO_XY_H