dim.h

Go to the documentation of this file.

#pragma once
 
#include "base/src/base.h"
namespace itasca {
    class Accumulator3;
    class Accumulator2;
    class Accumulator;
}
 
#ifndef DIM
#  error DIM must be defined as 2 or 3 to compile this module.
#endif
 
#if DIM==2
template <class T>
class Vector : public Vector2<T> {
public:
    Vector() { }
    Vector(const Vector<T> &v) : Vector2<T>(v) { }
    Vector(const Vector2<T> &v) : Vector2<T>(v) { }
    explicit Vector(const T &t) : Vector2<T>(t) { }
};
template <class T>
class AVector : public AVector2<T> {
public:
    AVector() { }
    AVector(const AVector &av) : AVector2<T>(av) { }
    AVector(const AVector2<T> &av) : AVector2<T>(av) { }
};
template <class T>
class Extent : public Extent2<T> {
public:
    Extent() { }
    Extent(const Vector<T> &v11,const Vector<T> &v22) : Extent2<T>(v11,v22) { }
    Extent(const Extent &r) : Extent2<T>(r) { }
    Extent(const Extent2<T> &r) : Extent2<T>(r) { }
};
using DVect       = DVect2;       
using FVect       = FVect2;       
using IVect       = IVect2;       
using I64Vect     = I64Vect2;
using UVect       = UVect2;       
using U64Vect     = U64Vect2;
using DExtent     = DExtent2;     
using IExtent     = IExtent2;     
using DAVect      = DAVect2;      
using FAVect      = FAVect2;      
using Axes        = Axes2D;       
using CAxes       = CAxes2D;      
using Orientation = Orientation2; 
using Quat        = Quat2;        
using VAccum      = itasca::Accumulator2; 
using AVAccum     = itasca::Accumulator; 
inline DMatrix<2,2> toMatrixDIM(const SymTensor &s) { return toMatrix2(s); }    
 
#  ifndef TWOD
#      define TWOD        
#  endif
#  define DIMSTR "2d"     
#  define CDIMSTR "2D"    
static constexpr const char *dimstr = "2d";
static constexpr const char *cdimstr = "2D";
#  undef itascaxd
#  define itascaxd itasca2d  
#  define DIMRET(x,y) x
template <class T> inline const Vector2<T> & toVect(const Vector2<T> &in) { return toVect2(in); }  
template <class T> inline Vector<T>          toVect(const Vector3<T> &in) { return toVect2(in); }  
template <class T> inline Vector<T>          toVect(const AVector2<T> &) { return Vector2<T>(0); } 
template <class T> inline AVector<T>         toAVect(const AVector2<T> &in) { return in; } 
template <class T> inline AVector<T>         toAVect(const AVector3<T> &in) { return AVector2<T>(in.z()); } 
template <class T> inline AVector<T>         toAVect(const Vector2<T> &) { return AVector2<T>(0.0); } 
template <class T> inline AVector<T>         toAVect(const Vector3<T> &in) { return AVector2<T>(in.z()); } 
template <class T> inline const Extent<T> &  toExtent(const Extent2<T> &t) { return t; } 
template <class T> inline Extent<T>          toExtent(const Extent3<T> &t) { return Extent2<T>(t.x1(),t.x2(),t.y1(),t.y2()); } 
template <class T> inline IVect toIVect(const Vector2<T> &in) { IVect iv(to<int32>(in.x()),to<int32>(in.y()));  return iv; } 
template <class T> inline FVect toFVect(const Vector2<T> &in) { FVect fv(to<float>(in.x()),to<float>(in.y()));  return fv; } 
template <class T> inline DVect toDVect(const Vector2<T> &in) { DVect dv(to<double>(in.x()),to<double>(in.y()));  return dv; } 
template <class T> inline DVect toDVect(const Vector3<T> &in) { DVect dv(to<double>(in.x()),to<double>(in.y()));  return dv; } 
template <class T,unsigned SX>
Vector2<T> toVector(const VMatrix<T,SX> &m,unsigned start) { Vector2<T> ret(m(start),m(start+1));  return ret; }
inline constexpr DMatrix<2,2> toMatrix(const SymTensor &s) { return toMatrix2(s); }
inline DSymMatrix<2> toSymMatrix(const SymTensor &s) { return toSymMatrix2(s); }
template <class T,class U> inline constexpr const T &dimval(const T &val2,const U &) { return val2; }  
static const unsigned int totdof = 3;
#else // DIM==3
template <class T>
class Vector : public Vector3<T> {
public:
    Vector() { }
    Vector(const Vector<T> &v) : Vector3<T>(v) { }
    Vector(const Vector3<T> &v) : Vector3<T>(v) { }
    Vector(const T &x,const T &y,const T &z) : Vector3<T>(x,y,z) { }
    explicit Vector(const T &t) : Vector3<T>(t) { }
};
template <class T>
class AVector : public AVector3<T> {
public:
    AVector() { }
    AVector(const AVector &av) : AVector3<T>(av) { }
    AVector(const AVector3<T> &av) : AVector3<T>(av) { }
};
template <class T>
class Extent : public Extent3<T> {
public:
    Extent() { }
    Extent(const Vector<T> &v11,const Vector<T> &v22) : Extent3<T>(v11,v22) { }
    Extent(const Extent &r) : Extent3<T>(r) { }
    Extent(const Extent3<T> &r) : Extent3<T>(r) { }
};
using DVect       = DVect3;       
using FVect       = FVect3;       
using IVect       = IVect3;       
using I64Vect     = I64Vect3;
using UVect       = UVect3;       
using U64Vect     = U64Vect3;
using DExtent     = DExtent3;     
using IExtent     = IExtent3;     
using DAVect      = DAVect3;      
using FAVect      = FAVect3;      
using Axes        = Axes3D;       
using CAxes       = CAxes3D;      
using Orientation = Orientation3; 
using Quat        = Quat3;        
using VAccum      = itasca::Accumulator3; 
using AVAccum     = itasca::Accumulator3; 
inline DMatrix<3,3> toMatrixDIM(const SymTensor &s) { return toMatrix3(s); }    
#  ifndef THREED
#      define THREED 
#  endif
#  define DIMSTR "3d"  
#  define CDIMSTR "3D"  
static constexpr const char *dimstr = "3d";
static constexpr const char *cdimstr = "3D";
#  undef itascaxd
#  define itascaxd itasca3d 
#  define DIMRET(x,y) y     
template <class T> inline Vector3<T>         toVect(const Vector2<T> &in) { return toVect3(in); }   
template <class T> inline const Vector3<T> & toVect(const Vector3<T> &in) { return in; }   
template <class T> inline Vector3<T>         toVect(const AVector2<T> &in) { return Vector3<T>(0,0,in.z()); } 
template <class T> inline AVector3<T>        toAVect(const AVector2<T> &in) { return AVector3<T>(in); } 
template <class T> inline const AVector3<T> &toAVect(const AVector3<T> &in) { return in; } 
template <class T> inline AVector3<T>        toAVect(const Vector2<T> &in) { return AVector3<T>(in.x(),in.y(),0.0); } 
template <class T> inline AVector3<T>        toAVect(const Vector3<T> &in) { return AVector3<T>(in.x(),in.y(),in.z()); } 
template <class T> inline Extent<T>          toExtent(const Extent2<T> &t) { return Extent3<T>(t.x1(),t.x2(),t.y1(),t.y2(),0,1); } 
template <class T> inline Extent<T>          toExtent(const Extent3<T> &t) { return t; } 
template <class T> inline IVect              toIVect(const Vector3<T> &in) { IVect iv(to<int32>(in.x()),to<int32>(in.y()),to<int32>(in.z()));  return iv; } 
template <class T> inline FVect              toFVect(const Vector3<T> &in) { FVect fv(to<float>(in.x()),to<float>(in.y()),to<float>(in.z()));  return fv; } 
template <class T> inline DVect              toDVect(const Vector3<T> &in) { DVect dv(to<double>(in.x()),to<double>(in.y()),to<double>(in.z()));  return dv; } 
template <class T,unsigned SX>
Vector3<T> toVector(const VMatrix<T,SX> &m,unsigned start) { Vector3<T> ret(m(start),m(start+1),m(start+2));  return ret; }
inline constexpr DMatrix<3,3> toMatrix(const SymTensor &s) { return toMatrix3(s); }
inline DSymMatrix<3> toSymMatrix(const SymTensor &s) { return toSymMatrix3(s); }
template <class T,class U>
inline constexpr const U &dimval(const T &,const U &val3) { return val3; } 
static const unsigned int totdof = 6;
#endif
 
static constexpr uint32 dim = DIM;              
static constexpr bool   is2D = dimval(true,false);  
static constexpr bool   is3D = dimval(false,true);  
static constexpr uint32 adof = dimval(1,3); // Number of angular DOF
static constexpr uint32 tdof = dimval(2,3); // Number of translational DOF
 
// EoF