Vector.h

Go to the documentation of this file.

#ifndef _utl_Vector_h_
#define _utl_Vector_h_

#include <utl/BasicVector.h>
#include <utl/CoordinateSystem.h>


namespace utl {

  class Point;
  class AxialVector;


  class Vector : public VectorBase {

  public:
    Vector() : VectorBase() { }

    Vector(const double x, const double y, const double z,
           const CoordinateSystemPtr& theCoordinateSystem)
      : VectorBase(x, y, z, theCoordinateSystem)
    { }

    Vector(const double p1, const double p2, const double p3,
           const CoordinateSystemPtr& theCoordinateSystem,
           const CoordinateType& theType)
      : VectorBase(p1, p2, p3, theCoordinateSystem, theType)
    { }

    Vector operator-() const
    { return Vector(-fVector, fCoordinateSystem); }

    Vector& operator+=(const Vector& v)
    { v.TransformTo(fCoordinateSystem); fVector += v.fVector; return *this; }

    Vector& operator-=(const Vector& v)
    { v.TransformTo(fCoordinateSystem); fVector -= v.fVector; return *this; }

    double GetMag() const
    { return fVector.mag(); }

    double GetMag2() const
    { return fVector.mag2(); }

    void Normalize() { VectorBase::Normalize(); }

    explicit operator bool() const { return fVector.x() || fVector.y() || fVector.z(); }

  private:

    Vector(const VectorBase::DataType& theVector,
           const CoordinateSystemPtr& theCoordinateSystem)
      : VectorBase(theVector, theCoordinateSystem)
    { }

    friend class TransformationPolicy;

    friend class AxialVector;

    friend Vector operator+(const Vector& l, const Vector& r);
    friend Vector operator-(const Vector& l, const Vector& r);
    friend Vector operator*(const Vector& v, const double a);
    friend Vector operator*(const double a, const Vector& v);
    friend Vector operator/(const Vector& l, const double a);
    friend double operator*(const Vector& l, const Vector& r);

    friend Point operator+(const Point& l, const Vector& r);
    friend Point operator+(const Vector& l, const Point& r);
    friend Point operator-(const Point& l, const Vector& r);
    friend Vector operator-(const Point& l, const Point& r);

    friend Point& operator+=(Point& p, const Vector& v);
    friend Point& operator-=(Point& p, const Vector& v);

    friend AxialVector Cross(const Vector& l, const Vector& r);

  };


  inline
  Vector
  Normalized(const Vector& v)
  {
    Vector vv = v;
    vv.Normalize();
    return vv;
  }

}


#include <utl/OperationsVV.h>
#ifdef _utl_Point_h_
#  include <utl/OperationsPV.h>
#endif


#endif