vector3D.h

Go to the documentation of this file.

#ifndef _DLR_VECTOR3D_H_
#define _DLR_VECTOR3D_H_

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

namespace dlr {

  namespace numeric {
    
    class Vector3D {
    public:
      Vector3D()
        : m_x(0), m_y(0), m_z(0) {}

      Vector3D(double xCoord, double yCoord, double zCoord)
        : m_x(xCoord), m_y(yCoord), m_z(zCoord) {}

      Vector3D(double xCoord, double yCoord, double zCoord, double alpha)
        : m_x(xCoord), m_y(yCoord), m_z(zCoord) {this->normalize(alpha);}
    
      Vector3D(const Vector3D& source)
        : m_x(source.m_x), m_y(source.m_y), m_z(source.m_z) {}


      ~Vector3D() {}

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

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

      inline void setValue(double xCoord, double yCoord, double zCoord,
                           double alpha) {
        m_x = xCoord; m_y = yCoord; m_z = zCoord; 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;}
    
      inline double& z() {return m_z;}

      inline double z() const {return m_z;}

      Vector3D& operator=(const Vector3D& source) {
        setValue(source.m_x, source.m_y, source.m_z); return *this;
      }

      inline double& operator[](size_t index) {
        switch(index) {
        case 0: return this->x(); break;
        case 1: return this->y(); break;
        }
        return this->z();
      }
          
      inline double operator[](size_t index) const {
        switch(index) {
        case 0: return this->x(); break;
        case 1: return this->y(); break;
        }
        return this->z();
      }
          
      Vector3D& operator*=(double scalar) {
        m_x *= scalar; m_y *= scalar; m_z *= scalar; return *this;
      }

      Vector3D& operator/=(double scalar) {
        if (scalar == 0) {
          DLR_THROW(ValueException, "Vector3D::operator/=(double)",
                    "Can't divide by zero.");
        }
        m_x /= scalar; m_y /= scalar; m_z /= scalar; return *this;
      }

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

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

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

      // Private data members.
      double m_x;
      double m_y;
      double m_z;
    }; // class Vector3D


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

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

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

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

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

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

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

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

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


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


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


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


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

  } // namespace numeric

} // namespace dlr


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

namespace dlr {

  using numeric::Vector3D;

} // namespace dlr

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

namespace dlr {

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

  } // namespace numeric

} // namespace dlr

#endif // #ifndef _DLR_VECTOR3D_H_