space_type.h

Go to the documentation of this file.

#ifndef SPACE_TYPE_H
#define SPACE_TYPE_H
 
#include "bitrl/bitrl_types.h"
#include <random>
#include <vector>
 
#include <type_traits>
 
namespace bitrl
{
namespace envs
{
 
template <uint_t s, uint_t e> struct ScalarDiscreteSpace
{
 
    typedef uint_t space_item_type;
 
    static constexpr IntegralRange<s, e> limits = IntegralRange<s, e>();
 
    static constexpr uint_t size = e - s ; //IntegralRange<s, e>::size;
 
    static space_item_type sample(bool use_end);
 
    static space_item_type sample(uint_t seed, bool use_end);
 
    static std::vector<space_item_type> sample(uint_t seed, uint_t size, bool use_end);
};
 
template <uint_t s, uint_t e>
typename ScalarDiscreteSpace<s, e>::space_item_type ScalarDiscreteSpace<s, e>::sample(bool use_end)
{
 
    auto E = IntegralRange<s, e>::E;
 
    if (!use_end)
    {
        E -= 1;
    }
 
    std::uniform_int_distribution<> dist(IntegralRange<s, e>::S, E);
    std::random_device rd;
    std::mt19937 gen(rd());
    return dist(gen);
}
 
template <uint_t s, uint_t e>
typename ScalarDiscreteSpace<s, e>::space_item_type ScalarDiscreteSpace<s, e>::sample(uint_t seed,
                                                                                      bool use_end)
{
 
    auto E = IntegralRange<s, e>::E;
 
    if (!use_end)
    {
        E -= 1;
    }
 
    std::uniform_int_distribution<> dist(IntegralRange<s, e>::S, E);
    std::mt19937 gen(seed);
    return dist(gen);
}
 
template <uint_t s, uint_t e>
std::vector<typename ScalarDiscreteSpace<s, e>::space_item_type>
ScalarDiscreteSpace<s, e>::sample(uint_t seed, uint_t size, bool use_end)
{
 
    auto E = IntegralRange<s, e>::E;
 
    if (!use_end)
    {
        E -= 1;
    }
 
    std::vector<typename ScalarDiscreteSpace<s, e>::space_item_type> vals_;
    vals_.reserve(size);
 
    std::uniform_int_distribution<> dist(IntegralRange<s, e>::S, E);
    std::mt19937 gen(seed);
    for (uint_t i = 0; i < size; ++i)
    {
        vals_.push_back(dist(gen));
    }
 
    return vals_;
}
 
template <uint_t Size> struct ContinuousScalareSpace
{
    typedef real_t space_item_type;
 
    static constexpr uint_t size = Size;
};
 
template <uint_t Size, typename T = real_t> struct ContinuousVectorSpace
{
    static_assert(std::is_floating_point_v<T> == true && "Floating point type is expected");
 
    static constexpr uint_t size = Size;
 
    typedef std::vector<T> space_item_type;
};
 
template <uint_t SpaceSize, typename T = uint_t> struct DiscreteVectorSpace
{
    static_assert(std::is_integral_v<T> == true && "Integral type is expected");
 
    typedef std::vector<T> space_item_type;
 
    static constexpr uint_t size = SpaceSize;
};
 
} // namespace envs
} // namespace bitrl
#endif