vector2D.h

Go to the documentation of this file.

#ifndef _DLR_VECTOR2D_H_
#define _DLR_VECTOR2D_H_

#include <iostream>
#include <dlrCommon/exception.h>

namespace dlr {

  namespace numeric {
    
    class Vector2D {
    public:

      Vector2D()
        : m_x(0), m_y(0) {}
    

      Vector2D(double xCoord, double yCoord)
        : m_x(xCoord), m_y(yCoord) {}


      Vector2D(double xCoord, double yCoord, double alpha)
        : m_x(xCoord), m_y(yCoord) {this->normalize(alpha);}


      Vector2D(const Vector2D& vec)
        : m_x(vec.m_x), m_y(vec.m_y) {}


      ~Vector2D() {}


      inline Vector2D& clear() {
        m_x = 0.0; m_y = 0.0;
        return *this;
      }

      
      inline void setValue(double xCoord, double yCoord) {
        m_x = xCoord; m_y = yCoord;
      }


      inline void setValue(double xCoord, double yCoord, double alpha) {
        m_x = xCoord; m_y = yCoord; normalize(alpha);
      }


      inline double& x() {return m_x;}


      inline double x() const {return m_x;}

    
      inline double& y() {return m_y;}

    
      inline double y() const {return m_y;}
    

      Vector2D& operator=(const Vector2D& vec) {
        setValue(vec.m_x, vec.m_y); return *this; // Self-assignment OK.
      }


      inline double& operator[](size_t index) {
        if(index == 0) {return this->x();}
        return this->y();
      }

          
      inline double operator[](size_t index) const {
        if(index == 0) {return this->x();}
        return this->y();
      }
          
      Vector2D& operator*=(double scalar) {
        m_x *= scalar; m_y *= scalar; return *this;
      }


      Vector2D& operator/=(double scalar) {
        if (scalar == 0.0) {
          DLR_THROW(ValueException, "Vector2D::operator/=()",
                    "Bad scalar: Divide by Zero\n");
        }
        m_x /= scalar; m_y /= scalar; return *this;
      }


      Vector2D& operator+=(const Vector2D& vec) {
        m_x += vec.m_x; m_y += vec.m_y; return *this;
      }


      Vector2D& operator-=(const Vector2D& vec) {
        m_x -= vec.m_x; m_y -= vec.m_y; return *this;
      }


      Vector2D operator-() {
        return Vector2D(-m_x, -m_y);
      }
    
    private:
      // Private member functions.
      inline void normalize(double alpha) {
        if(alpha == 1.0) {return;}
        if(alpha == 0.0) {
          DLR_THROW(ValueException, "Vector2D::normalize()",
                    "Bad alpha (0.0).");
        }
        m_x /= alpha; m_y /= alpha;
        return;
      }

      // Private data members.
      double m_x;
      double m_y;
    }; // class Vector2D


    /* ============== Non-member function declarations ============== */
  
    Vector2D
    operator+(const Vector2D& vector0, const Vector2D& vector1);

    Vector2D
    operator-(const Vector2D& vector0, const Vector2D& vector1);
  
    Vector2D
    operator*(const Vector2D& vector0, const Vector2D& vector1);

    Vector2D
    operator/(const Vector2D& vector0, const Vector2D& vector1);

    Vector2D operator+(const Vector2D& vector0, double scalar0);

    Vector2D operator-(const Vector2D& vector0, double scalar0);

    Vector2D operator*(const Vector2D& vector0, double scalar0);

    Vector2D operator/(const Vector2D& vector0, double scalar0);

    bool operator==(const Vector2D& vector0, const Vector2D& vector1);

    bool operator!=(const Vector2D& vector0, const Vector2D& vector1);


    Vector2D operator+(double scalar0, const Vector2D& vector0);


    Vector2D operator*(double scalar0, const Vector2D& vector0);

  
    std::ostream& operator<<(std::ostream& stream, const Vector2D& vector0);

    std::istream& operator>>(std::istream& stream, Vector2D& vector0);

  } // namespace numeric

} // namespace dlr


/* ======= Declarations to maintain compatibility with legacy code. ======= */

namespace dlr {

  using numeric::Vector2D;

} // namespace dlr


/* ============ Definitions of inline & template functions ============ */

namespace dlr {

  namespace numeric {
    
    inline Vector2D operator+(double scalar0, const Vector2D& vector0)
    {
      return vector0 + scalar0;
    }
  
    inline Vector2D operator*(double scalar0, const Vector2D& vector0)
    {
      return vector0 * scalar0;
    }

  } // namespace numeric

} // namespace dlr

#endif // #ifndef _DLR_VECTOR2D_H_