beta_dist.h

Go to the documentation of this file.

#ifndef BETA_DIST_H
#define BETA_DIST_H
 
#include "bitrl/bitrl_consts.h"
#include "bitrl/bitrl_types.h"
#include "bitrl/utils/maths/math_utils.h"
 
#include <boost/random/beta_distribution.hpp>
#include <cmath>
#include <type_traits>
#include <vector>
 
namespace bitrl
{
namespace utils::maths::stats
{
 
template <typename RealType = real_t> class BetaDist
{
public:
    static_assert(std::is_floating_point<RealType>::value, "Not a floating point type");
 
    typedef RealType result_type;
 
    explicit BetaDist(result_type alpha = 1.0, result_type std = 1.0);
 
    result_type pdf(result_type x) const;
 
    result_type sample() const;
 
    result_type sample(uint_t seed) const;
 
    std::vector<result_type> sample_many(uint_t size) const;
 
    std::vector<result_type> sample_many(uint_t size, uint_t seed) const;
 
    result_type mean() const { return dist_.alpha() / (dist_.alpha() + dist_.beta()); }
 
    result_type variance() const;
 
    result_type alpha() const { return dist_.alpha(); }
 
    result_type beta() const { return dist_.beta(); }
 
    void reset() { dist_.reset(); }
 
    void reset(result_type a, result_type b);
 
private:
    mutable boost::random::beta_distribution<RealType> dist_;
};
 
template <typename RealType>
BetaDist<RealType>::BetaDist(RealType alpha, RealType beta) : dist_(alpha, beta)
{
}
 
template <typename RealType> void BetaDist<RealType>::reset(result_type a, result_type b)
{
 
    dist_ = boost::random::beta_distribution<RealType>(a, b);
}
 
template <typename RealType> RealType BetaDist<RealType>::variance() const
{
    auto a = dist_.alpha();
    auto b = dist_.beta();
    return a * b / (utils::maths::sqr(a + b) * (a + b + 1));
}
 
template <typename RealType> RealType BetaDist<RealType>::sample() const
{
 
    std::random_device rd{};
    std::mt19937 gen{rd()};
    return dist_(gen);
}
 
template <typename RealType> RealType BetaDist<RealType>::sample(uint_t seed) const
{
 
    std::mt19937 gen{seed};
    return dist_(gen);
}
 
template <typename RealType>
std::vector<RealType> BetaDist<RealType>::sample_many(uint_t size) const
{
 
    std::vector<RealType> samples(size);
    std::random_device rd{};
    std::mt19937 gen{rd()};
 
    for (uint_t i = 0; i < size; ++i)
    {
        samples[i] = dist_(gen);
    }
 
    return samples;
}
 
template <typename RealType>
std::vector<RealType> BetaDist<RealType>::sample_many(uint_t size, uint_t seed) const
{
 
    std::vector<RealType> samples(size);
    std::mt19937 gen(seed);
 
    for (uint_t i = 0; i < size; ++i)
    {
        samples[i] = dist_(gen);
    }
 
    return samples;
}
 
template <typename RealType> RealType BetaDist<RealType>::pdf(RealType x) const
{
 
    auto alpha = dist_.alpha();
    auto beta = dist_.beta();
    auto beta_func = std::beta(alpha, beta);
    return std::pow(x, alpha - 1) * std::pow(1.0 - x, beta - 1.0) / beta_func;
}
 
}
} // namespace rlenvscpp
 
#endif