vlVector.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
*********************************************************************/

#ifndef DtVector_H_
#define DtVector_H_


#include <vlutil/vlMachineTypes.h>
#include <vlutil/vlNetTypes.h>
#include <vlutil/vlString.h>
#include <iosfwd>

#ifdef DtUSE_UTILITIES_NAMESPACE
namespace DtUSE_UTILITIES_NAMESPACE
{
#endif


enum DtVectorOffset
{
   DtX,
   DtY,
   DtZ
};

class DtDcm;
class DtVector;

typedef const DtVector &DtConstVector;
typedef DtVector &DtVectorRef;
typedef double DtThreeIndex[3][3][3];
typedef double (*DtThreeIndexPtr)[3][3];

//Helper typedefs - all vectors are double vectors, regardless of encoding
typedef DtVector DtVector32;
typedef DtVector DtVector64;

class DT_DLL_MATRIX DtVector
{
public:

   DtVector ();

   DtVector( const double& x, const double& y, const double& z);

   ~DtVector();

   DtVector(const DtVector& vec);

   DtVector& operator=(const DtVector& vec);

   void setToZero();


   const double& x() const;
   void setX(const double& x);


   const double& y() const;
   void setY(const double& y);


   const double& z() const;
   void setZ(const double& z);

   DtVector &operator+=(const DtVector &other);

   DtVector &operator-=(const DtVector &other);


   double& operator[](int ind);

   double operator[](int ind) const;

   double& operator[](DtVectorOffset ind);

   double operator[](DtVectorOffset ind) const;

   int operator==(const DtVector& vec) const;

   int operator!=(const DtVector& vec) const;

   DtString string() const;

   double magnitudeSquared() const;

   void normalize();

   bool isNormalized() const;

   DtVector crossProduct(const DtVector& v) const;

   double dotProduct(const DtVector& v) const;

   bool approxEq(const DtVector& v, const double& tolerance) const;

   bool magnitudeIsZero() const;

   bool magnitudeIsZero(double tolerance) const;

   std::ostream &printDataToStream(std::ostream &str) const;

public:


   operator double* ();
   operator const double* () const;

public:


   static const DtVector& zero();

   static const DtVector& i();

   static const DtVector& j();

   static const DtVector& k();

   static const DtVector& ones();


protected:

   double myRep[3];


};

//
// Vector routines.
//

#define DtSetVec(v, x, y, z)    v[DtX]=x;v[DtY]=y;v[DtZ]=z;

extern DT_DLL_MATRIX DtThreeIndex   DtLevi_Civita;

DT_DLL_MATRIX DtVector operator+(const DtVector& v1, const DtVector &v2);

DT_DLL_MATRIX DtVector operator-(const DtVector& v1, const DtVector &v2);

DT_DLL_MATRIX void      DtVecScale(const DtVector& v, double scale_factor, DtVector& result);

DT_DLL_MATRIX void      DtVecNeg(const DtVector& v1, DtVector& result); 

DT_DLL_MATRIX double    DtVecCosProd(const DtVector& v1, const DtVector& v2);

DT_DLL_MATRIX double     DtVecBoxProd(const DtVector& v1, const DtVector& v2, const DtVector& v3); 

DT_DLL_MATRIX void      DtVecDcmMul(const DtVector& v, const DtDcm& m, DtVector& result);

DT_DLL_MATRIX void      DtVV_Product(const DtVector& a,const DtVector& b, DtDcm& ans);

DT_DLL_MATRIX double    DtVecInfNorm(const DtVector& v1);

DT_DLL_MATRIX void      DtVecInit(DtVector& v); 

DT_DLL_MATRIX DtVector  DtLerpVector(DtVector va, DtVector vb, double t);

DT_DLL_MATRIX void      DtVecCopy(const DtVector& from, DtVector& to);

DT_DLL_MATRIX int      DtVecCheck(const DtVector& v);   

DT_DLL_MATRIX void      DtVecNormalize(const DtVector& v, DtVector& result);

DT_DLL_MATRIX void      DtVecCrossProd(const DtVector& v1, const DtVector& v2, DtVector& result);

DT_DLL_MATRIX double    DtVecDotProd(const DtVector& v1, const DtVector& v2);

DT_DLL_MATRIX void      DtVecDump(const char *str, const DtVector& v);

DT_DLL_MATRIX void      DtVecSub(const DtVector& v1, const DtVector& v2, DtVector& result);

DT_DLL_MATRIX void      DtVecAdd(const DtVector& v1, const DtVector& v2, DtVector& result);

DT_DLL_MATRIX DtVector DtVelocityFromAToB(const DtVector& a, 
   const DtVector& b, double time);

DT_DLL_MATRIX double DtHeadingFromAToB(const DtVector& a, const DtVector& b);

/* ||p1-p2||_{2} */
DT_DLL_MATRIX double DtDistance(const DtVector& p1, const DtVector& p2);  

DT_DLL_MATRIX double DtDistSqr(const DtVector& p1, const DtVector& p2);


class DT_DLL_MATRIX  DtNetVector32
{
public:
   DtNetVector32();
   DtNetVector32(const DtVector &vec);
   DtVector operator=(const DtVector &vec);
   operator DtVector() const;
   DtNetFloat32 &operator[](int i);
   DtNetFloat32 operator[](int i) const;
private:
   DtNetFloat32 rep[3];
};  

class DT_DLL_MATRIX DtNetVector64
{
public:
   DtNetVector64();
   DtNetVector64(const DtVector &vec);
   DtVector operator=(const DtVector &vec);
   operator DtVector() const;
   DtNetFloat64 &operator[](int i);
   DtNetFloat64 operator[](int i) const;
private:
   DtNetFloat64 rep[3];
};

DT_DLL_MATRIX std::ostream & operator << (std::ostream &str, const DtVector &vec);


#define vlVector_inl
#include "vlVector.inl"
#undef vlVector_inl

#ifdef DtUSE_UTILITIES_NAMESPACE
}
#endif

#endif