bitrl_types.h

Go to the documentation of this file.

#ifndef RLENVS_TYPES_V2_H
#define RLENVS_TYPES_V2_H
 
//#include "bitrl/bitrl_config.h"
#include "Eigen/Core"
 
#include <cstddef>
#include <ostream>
#include <string>
#include <vector>
 
namespace bitrl
{
 
typedef double real_t;
 
typedef float float_t;
 
typedef int int_t;
 
typedef long int lint_t;
 
typedef std::size_t uint_t;
 
template <typename T> using DynMat = Eigen::MatrixX<T>;
 
template <typename T, uint_t N> using SquareMat = Eigen::Matrix<T, N, N>;
 
template <typename T, uint_t N, uint_t M> using Mat = Eigen::Matrix<T, N, M>;
 
using RealMat3d = Eigen::Matrix3<real_t>;
 
using FloatMat3d = Eigen::Matrix3<float_t>;
 
template <typename T> using DynVec = Eigen::RowVectorX<T>;
 
using FloatVec = DynVec<float_t>;
 
using RealVec = DynVec<real_t>;
 
using STD_FloatVec = std::vector<float_t>;
 
using STD_RealVec = std::vector<real_t>;
 
template <typename T> using ColVec = Eigen::VectorX<T>;
 
using RealColVec = ColVec<real_t>;
 
using FoatColVec = ColVec<float_t>;
 
using RealColVec3d = Eigen::Vector3d;
 
using FloatColVec3d = Eigen::Vector3f;
 
template <uint_t s, uint_t e> struct IntegralRange
{
    typedef uint_t value_type;
    static constexpr uint_t S = s;
    static constexpr uint_t E = e;
    static constexpr uint_t size = e - s;
};
 
template <real_t s, real_t e> struct RealRange
{
    typedef real_t value_type;
    static constexpr real_t S = s;
    static constexpr real_t E = e;
    static constexpr real_t size = e - s;
};
 
struct Null
{
};
 
enum class DeviceType
{
    INVALID_TYPE = 0,
    CPU = 1,
    GPU = 2
};
 
inline std::ostream &operator<<(std::ostream &out, const Null &)
{
 
    out << "null";
    return out;
}
 
} // namespace bitrl
 
#endif // TYPES_H