source: lemon-0.x/src/work/athos/xy/xy.h @ 207:9910d5a5be7f

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

*/
#ifndef HUGO_XY_H
#define HUGO_XY_H

#include <iostream>

namespace hugo {

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

      ///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)
  {
    ///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
  std::ostream& operator<<(std::ostream &os, xy<T> z)
  {
    os << "(" << z.x() << ", " << z.y() << ")";
    return os;
  }

} //namespace hugo

#endif //HUGO_XY_H