Random.hpp

Go to the documentation of this file.

// @formatter:off
//
// Balau core C++ library
//
// Copyright (C) 2008 Bora Software (contact@borasoftware.com)
//
// Licensed under the Boost Software License - Version 1.0 - August 17th, 2003.
// See the LICENSE file for the full license text.
//


#ifndef COM_BORA_SOFTWARE__BALAU_UTIL__RANDOM
#define COM_BORA_SOFTWARE__BALAU_UTIL__RANDOM

#include <Balau/Util/Impl/RandomImpl.hpp>

namespace Balau::Util {


template <typename T, typename D> class RandomNumberGenerator final {
    public: RandomNumberGenerator(T lower, T upper)
        : generator(std::random_device()())
        , distribution(D(lower, Impl::inclusivise(upper))) {}

    public: RandomNumberGenerator(T lower, T upper, unsigned int seed)
        : generator(seed)
        , distribution(D(lower, Impl::inclusivise(upper))) {}

    public: T operator () () {
        return distribution(generator);
    }


    public: RandomNumberGenerator(const RandomNumberGenerator & copy) = delete;
    public: RandomNumberGenerator & operator = (const RandomNumberGenerator & copy) = delete;

    private: std::mt19937 generator;
    private: D distribution;
};


using UniformDouble = RandomNumberGenerator<double, std::uniform_real_distribution<double>>;

using UniformFloat = RandomNumberGenerator<float, std::uniform_real_distribution<float>>;

using UniformInt32 = RandomNumberGenerator<int, std::uniform_int_distribution<int>>;

using UniformInt64 = RandomNumberGenerator<long, std::uniform_int_distribution<long>>;

using UniformUInt32 = RandomNumberGenerator<unsigned int, std::uniform_int_distribution<unsigned int>>;

using UniformUInt64 = RandomNumberGenerator<unsigned long long, std::uniform_int_distribution<unsigned long long>>;


using NormalDouble = RandomNumberGenerator<double, std::normal_distribution<double>>;

using NormalFloat = RandomNumberGenerator<float, std::normal_distribution<float>>;


template <typename T> using UniformReal = RandomNumberGenerator<T, std::uniform_real_distribution<T>>;

template <typename T> using UniformInt = RandomNumberGenerator<T, std::uniform_int_distribution<T>>;

template <typename T> using Normal = RandomNumberGenerator<T, std::normal_distribution<T>>;

template <typename T> using LogNormal = RandomNumberGenerator<T, std::lognormal_distribution<T>>;

template <typename T> using Gamma = RandomNumberGenerator<T, std::gamma_distribution<T>>;

template <typename T> using ChiSquared = RandomNumberGenerator<T, std::chi_squared_distribution<T>>;

template <typename T> using Cauchy = RandomNumberGenerator<T, std::cauchy_distribution<T>>;

template <typename T> using FisherF = RandomNumberGenerator<T, std::fisher_f_distribution<T>>;

template <typename T> using StudentT = RandomNumberGenerator<T, std::student_t_distribution<T>>;

template <typename T> using Binomial = RandomNumberGenerator<T, std::binomial_distribution<T>>;

template <typename T> using Geometric = RandomNumberGenerator<T, std::geometric_distribution<T>>;

template <typename T> using NegativeBinomial = RandomNumberGenerator<T, std::negative_binomial_distribution<T>>;

template <typename T> using Poisson = RandomNumberGenerator<T, std::poisson_distribution<T>>;

template <typename T> using Exponential = RandomNumberGenerator<T, std::exponential_distribution<T>>;

template <typename T> using Weibull = RandomNumberGenerator<T, std::weibull_distribution<T>>;

template <typename T> using ExtremeValue = RandomNumberGenerator<T, std::extreme_value_distribution<T>>;

template <typename T> using Discrete = RandomNumberGenerator<T, std::discrete_distribution<T>>;

template <typename T> using PiecewiseConstant = RandomNumberGenerator<T, std::piecewise_constant_distribution<T>>;

template <typename T> using PiecewiseLinear = RandomNumberGenerator<T, std::piecewise_linear_distribution<T>>;

} // namespace Balau::Util

#endif // COM_BORA_SOFTWARE__BALAU_UTIL__RANDOM