vlVector.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1992-2025 MAK Technologies, Inc
** All rights reserved.
*********************************************************************/

#pragma once


#include <vlutil/vlMachineTypes.h>
#include <vlutil/vlNetTypes.h>
#include <vlutil/vlString.h>
#include <matrix/vlMath.h>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <sstream>

#ifdef DtUSE_UTILITIES_NAMESPACE
namespace DtUSE_UTILITIES_NAMESPACE
{
#endif


enum DtVectorOffset
{
   DtX,
   DtY,
   DtZ
};

class DtDcm;

template <typename T>
class DtVectorT
{
public:
   inline DtVectorT<T> ();

   inline DtVectorT<T>( const T& x, const T& y, const T& z);

   inline ~DtVectorT<T>();

   inline DtVectorT<T>(const DtVectorT<T>& vec);

   inline DtVectorT<T>& operator=(const DtVectorT<T>& vec);

   inline void setToZero();

   inline void get(T& x, T& y, T& z) const;

   inline void setAll(const T&x, const T&y, const T&z);

   inline const T& x() const;
   inline void setX(const T& x);

   inline const T& y() const;
   inline void setY(const T& y);

   inline const T& z() const;
   inline void setZ(const T& z);

   inline T& operator[](int ind);

   inline T operator[](int ind) const;

   inline T& operator[](DtVectorOffset ind);

   inline T operator[](DtVectorOffset ind) const;

   inline int operator==(const DtVectorT<T>& vec) const;

   inline int operator!=(const DtVectorT<T>& vec) const;

   inline DtString string() const;

   inline double magnitudeSquared() const;

   inline void normalize();

   inline bool isNormalized() const;


   inline bool magnitudeIsZero() const;

   inline bool magnitudeIsZero(double tolerance) const;

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

public:


   inline operator T* ();
   inline operator const T* () const;

protected:

   T myRep[3];
};

class DtVector64; //Forward declaration for conversions

// Specifically instantiate 32 bit vector.
// in C++11 we could just typedef and export, but
// this is not compatible with older versions.
class DT_DLL_MATRIX DtVector32 : public DtVectorT < float >
{
public:
   inline DtVector32();

   inline DtVector32(const float& x, const float& y, const float& z);

   inline ~DtVector32();

   inline DtVector32(const DtVector32& vec);
   inline DtVector32(const DtVectorT < float >& vec);

   inline DtVector32& operator=(const DtVector32& vec);
   inline DtVector32& operator=(const DtVectorT < float >& vec);

   inline DtVector32 crossProduct(const DtVector32& v) const;

#ifdef DtEXPLICIT_VECTOR_CONVERSION
   inline DtVector32& operator= (const DtVector64& vec);
   inline DtVector32(const DtVector64& vec);
#endif

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

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

   float dotProduct(const DtVector32& v) const;

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

public:
   
   static const DtVector32& zero();

   static const DtVector32& i();

   static const DtVector32& j();

   static const DtVector32& k();

   static const DtVector32& ones();
};

// Specifically instantiate 64 bit vector.
// in C++11 we could just typedef and export, but
// this is not compatible with older versions.
class DT_DLL_MATRIX DtVector64 : public DtVectorT < double >
{
public:
   inline DtVector64();

   inline DtVector64(const double& x, const double& y, const double& z);

   inline ~DtVector64();

   inline DtVector64(const DtVector64& vec);
   inline DtVector64(const DtVectorT < double >& vec);

   inline DtVector64& operator=(const DtVector64& vec);
   inline DtVector64& operator=(const DtVectorT < double >& vec);

   inline DtVector64 crossProduct(const DtVector64& v) const;

#ifdef DtIMPLICIT_VECTOR_CONVERSION
   inline DtVector64& operator= (const DtVector32& vec);
   inline DtVector64(const DtVector32& vec);
#endif

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

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

   double dotProduct(const DtVector64& v) const;

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


public:

   static const DtVector64& zero();

   static const DtVector64& i();

   static const DtVector64& j();

   static const DtVector64& k();

   static const DtVector64& ones();
};

//Helper typedefs
typedef DtVector64 DtVector;
typedef const DtVector &DtConstVector;
typedef const DtVector32 &DtConstVector32;
typedef DtVector &DtVectorRef;
typedef DtVector32 &DtVectorRef32;

typedef double DtThreeIndex[3][3][3];
typedef double (*DtThreeIndexPtr)[3][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 DtVector32 operator+(const DtVector32& v1, const DtVector32 &v2);
DT_DLL_MATRIX DtVector operator+(const DtVector32& v1, const DtVector &v2);
DT_DLL_MATRIX DtVector operator+(const DtVector& v1, const DtVector32 &v2);

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

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

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

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

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

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

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

DT_DLL_MATRIX double    DtVecInfNorm(const DtVector& v1);
DT_DLL_MATRIX double    DtVecInfNorm(const DtVector32& v1);

DT_DLL_MATRIX void      DtVecInit(DtVector& v); 
DT_DLL_MATRIX void      DtVecInit(DtVector32& v); 

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

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

DT_DLL_MATRIX int      DtVecCheck(const DtVector& v);  
DT_DLL_MATRIX int      DtVecCheck(const DtVector32& v);  

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

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

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

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

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

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

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

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

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

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

DT_DLL_MATRIX DtVector64 DtVector32To64(const DtVector32& v32);
DT_DLL_MATRIX DtVector32 DtVector64To32(const DtVector64& v32);


class DT_DLL_MATRIX  DtNetVector32
{
public:
   DtNetVector32();
   DtNetVector32(const DtVector32 &vec);
   DtVector32 operator=(const DtVector32 &vec);
   operator DtVector32() 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];
};

template <typename T> std::ostream & operator << (std::ostream &str, const DtVectorT<T> &vec)
{
   vec.printDataToStream(str);
   return str;
};


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

#ifdef DtUSE_UTILITIES_NAMESPACE
}
#endif