random.h

Go to the documentation of this file.

 
 
#ifndef CHEBYSHEV_RANDOM_H
#define CHEBYSHEV_RANDOM_H
 
#include <cstdlib>
#include <cmath>
#include "../core/common.h"
 
 
namespace chebyshev {
 
    namespace random {
 
 
        struct random_settings {
            
            uint64_t seed = 0;
 
        } settings;
 
 
        inline void setup(uint64_t seed = 0) {
 
            if(seed == 0)
                seed = time(nullptr);
 
            settings.seed = seed;
            srand(settings.seed);
        }
 
 
        inline uint64_t natural() {
            return rand();
        }
 
 
        inline long double uniform(long double a, long double b) {
            return (rand() / (long double) RAND_MAX) * (b - a) + a;
        }
 
 
        template<typename Vector>
        inline Vector& sample_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::sample_uniform");
 
            for (int i = 0; i < x.size(); ++i)
                x[i] = uniform(intervals[i].a, intervals[i].b);
        
            return x;
        }
 
 
        inline long double gaussian(long double m, long double s) {
 
            const long double x = uniform(0.0, 1.0);
            const long double y = uniform(0.0, 1.0);
 
            const long double v = std::sqrt(-2 * std::log(x));
            const long double u = v * std::cos(2 * PI_CONST * y);
 
            return m + s * u;
        }
 
 
        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;
        }
 
    }
}
 
#endif