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