random.h

Go to the documentation of this file.

 
 
#ifndef CHEBYSHEV_RANDOM_H
#define CHEBYSHEV_RANDOM_H
 
#include <cstdint>
#include <cstdlib>
#include <cmath>
#include <mutex>
 
 
#include "../core/common.h"
 
 
#ifndef CH_CUSTOM_RND
 
#include <random>
using random_engine = std::mt19937;
 
#endif
 
 
namespace chebyshev {
 
namespace random {
 
 
    struct random_source {
        
    private:
        
        random_engine rnd;
 
        uint64_t seed {0};
 
    public:
 
        random_source(uint64_t seed) {
            this->seed = seed;
            rnd = random_engine(seed);
        }
 
 
        uint64_t get_seed() {
            return seed;
        }
 
 
        inline uint64_t natural() {
            return rnd();
        }
 
 
        inline real_t uniform(real_t a, real_t b) {
 
            const uint64_t max = uint64_t(1) << 31;
            const real_t u = (natural() % max) / prec_t(max);
            
            return u * (b - a) + a;
        }
 
 
        template<typename Vector>
        inline Vector& uniform(Vector& x, real_t a, real_t b) {
 
            for (auto& x_i : x)
                x_i = uniform(a, b);
        
            return x;
        }
 
 
        template<typename Vector>
        inline Vector& uniform(Vector& x, const std::vector<prec::interval> intervals) {
 
            if(x.size() != intervals.size()) {
                throw std::runtime_error(
                    "Vector and domain size mismatch in chebyshev::uniform"
                );
            }
 
            for (unsigned int i = 0; i < x.size(); ++i)
                x[i] = uniform(intervals[i].a, intervals[i].b);
        
            return x;
        }
 
 
        inline real_t gaussian(real_t mean, real_t sigma) {
 
            const real_t x = uniform(0.0, 1.0);
            const real_t y = uniform(0.0, 1.0);
 
            const real_t v = std::sqrt(-2 * std::log(x));
            const real_t u = v * std::cos(2 * PI_CONST * y);
 
            return mean + sigma * u;
        }
 
 
        template<typename Vector>
        inline Vector& gaussian(Vector& x, real_t mean, real_t sigma) {
 
            for (auto& x_i : x)
                x_i = gaussian(mean, sigma);
        
            return x;
        }
 
 
        inline std::string string(size_t length) {
 
            std::string str;
            str.resize(length);
 
            for (unsigned int i = 0; i < length; ++i)
                str[i] = '!' + (char) (natural() % 95);
 
            return str;
        }
 
 
        inline std::string string(size_t length, std::string alphabet) {
 
            if(!alphabet.size()) {
                throw std::runtime_error(
                    "alphabet in chebyshev::random::string cannot be empty."
                );
            }
 
            std::string str;
            str.resize(length);
 
            for (unsigned int i = 0; i < length; ++i)
                str[i] = alphabet[natural() % alphabet.size()];
 
            return str;
        }
 
 
        inline std::string string(size_t length, std::vector<char> alphabet) {
 
            if(!alphabet.size()) {
                throw std::runtime_error(
                    "alphabet in chebyshev::random::string cannot be empty."
                );
            }
 
            std::string str;
            str.resize(length);
 
            for (unsigned int i = 0; i < length; ++i)
                str[i] = alphabet[natural() % alphabet.size()];
 
            return str;
        }
 
 
        template<typename T>
        inline std::vector<T> string(size_t length, std::vector<T> alphabet) {
 
            if(!alphabet.size()) {
                throw std::runtime_error(
                    "alphabet in chebyshev::random::string cannot be empty."
                );
            }
 
            std::vector<T> str;
            str.resize(length);
 
            for (unsigned int i = 0; i < length; ++i)
                str[i] = alphabet[natural() % alphabet.size()];
 
            return str;
        }
 
    };
 
 
    struct random_settings { };
 
 
    class random_context {
    private:
 
        random_engine rnd;
 
        std::mutex rndMutex;
 
    public:
 
        random_settings settings;
 
            inline void setup(uint64_t seed = 0) {
        
            if(seed == 0) {
                std::random_device entropy;
                seed = entropy();
            }
 
            // Initialize the random source
            rnd = random_engine(seed);
        }
 
 
        inline void terminate() { }
 
 
        random_context(uint64_t seed = 0) {
            setup(seed);
        }
 
        random_context(const random_context& other) {
 
            rnd = other.rnd;
            settings = other.settings;
        }
 
 
        inline random_context& operator=(const random_context& other) {
 
            rnd = other.rnd;
            settings = other.settings;
            return *this;
        }
 
 
        inline random_source get_rnd() {
 
            std::lock_guard<std::mutex> lock(rndMutex);
            return random_source(rnd());
        }
        
    };
 
}}
 
#endif