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,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 toMatrix(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,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