distribution.h

Go to the documentation of this file.

#ifndef FPMAS_RANDOM_DISTRIBUTION_H
#define FPMAS_RANDOM_DISTRIBUTION_H
 
#include <random>
#include "fpmas/api/random/distribution.h"
 
namespace fpmas { namespace random {
 
    template<typename Distribution_t>
    class Distribution : public api::random::Distribution<typename Distribution_t::result_type> {
        private:
            Distribution_t distrib;
 
        public:
            typedef typename Distribution_t::result_type result_type;
 
            template<typename... Args>
                Distribution(Args... args) : distrib(args...) {}
 
            template<typename Generator_t>
                result_type operator()(Generator_t& generator) {
                    return distrib(generator);
                }
 
            result_type min() const override {
                return distrib.min();
            }
 
            result_type max() const override {
                return distrib.max();
            }
    };
 
    template<typename IntType = int>
        using UniformIntDistribution = Distribution<std::uniform_int_distribution<IntType>>;
 
    template<typename FloatType = double>
        using UniformRealDistribution = Distribution<std::uniform_real_distribution<FloatType>>;
 
    typedef Distribution<std::bernoulli_distribution> BernoulliDistribution;
 
    template<typename IntType = unsigned int>
        using BinomialDistribution = Distribution<std::binomial_distribution<IntType>>;
 
    template<typename FloatType = double>
        using NormalDistribution = Distribution<std::normal_distribution<FloatType>>;
 
    template<typename IntType = int>
        using PoissonDistribution = Distribution<std::poisson_distribution<IntType>>;
 
    template<typename IntType = std::size_t>
        class DiscreteDistribution : public Distribution<std::discrete_distribution<IntType>> {
            public:
                using Distribution<std::discrete_distribution<IntType>>::Distribution;
 
                template<typename Container>
                    DiscreteDistribution(const Container& c)
                    : DiscreteDistribution(c.begin(), c.end()) {
                    }
        };
 
    template<typename T>
    class ConstantDistribution : public api::random::Distribution<T> {
        private:
            T value;
 
        public:
            typedef T result_type;
 
            ConstantDistribution(const T& value) : value(value) {}
 
            template<typename Generator_t>
                result_type operator()(Generator_t&) {
                    return value;
                }
 
            result_type min() const override {
                return value;
            }
 
            result_type max() const override {
                return value;
            }
    };
}}
 
#endif