random.h

#ifndef PIXLED_FUNCTIONNAL_RANDOM_H
#define PIXLED_FUNCTIONNAL_RANDOM_H
 
#include <random>
#include <unordered_map>
 
#include "../function.h"
 
namespace pixled {
    typedef std::minstd_rand random_engine;
}
 
namespace pixled { namespace random {
    class RandomEngineConfig {
        protected:
            time period;
            unsigned long seed;
 
        public:
            RandomEngineConfig(time period)
                : period(period) {
                    std::random_device rd_seeder;
                    std::uniform_int_distribution<unsigned long> rd_seed;
                    seed = rd_seed(rd_seeder);
                }
            RandomEngineConfig(time period, unsigned long seed)
                : period(period), seed(seed) {}
    };
 
    class RandomT : public base::Function<random_engine>, RandomEngineConfig {
        private:
            mutable time current_period = 0;
            mutable random_engine rd {this->seed};
        public:
            using RandomEngineConfig::RandomEngineConfig;
 
            random_engine operator()(led l, time t) const override;
 
            RandomT* copy() const override {
                return new RandomT(period, seed);
            }
    };
 
    class RandomXYT : public base::Function<random_engine>, RandomEngineConfig {
        private:
            mutable time current_period = 0;
            mutable random_engine rd_seeder {this->seed};
            mutable std::uniform_int_distribution<unsigned long> rd_seed;
            mutable std::unordered_map<index_t, random_engine> rds;
        public:
            using RandomEngineConfig::RandomEngineConfig;
 
            /*
             * f = period 
             */
            random_engine operator()(led l, time t) const override;
 
            RandomXYT* copy() const override {
                return new RandomXYT(period, seed);
            }
    };
 
    template<typename R>
        class UniformDistribution :
            public Function<UniformDistribution<R>, R, R, R, random_engine> {
                public:
                    using Function<UniformDistribution<R>, R, R, R, random_engine>::Function;
 
                    /*
                     * f1 = min
                     * f2 = max
                     * f3 = random engine
                     */
                    R operator()(led l, time t) const override {
                        std::uniform_real_distribution<float> random_real (
                                this->template call<0>(l, t), this->template call<1>(l, t)
                                );
                        auto engine = this->template call<2>(l, t);
                        return random_real(engine);
                    }
            };
    template<typename R>
    class NormalDistribution : public Function<NormalDistribution<R>, R, float, float, random_engine> {
        public:
            using Function<NormalDistribution<R>, R, float, float, std::minstd_rand>::Function;
 
            /*
             * f1 = min
             * f2 = max
             * f3 = random engine
             */
            R operator()(led l, time t) const override {
                std::normal_distribution<float> random_real (
                        this->template call<0>(l, t), this->template call<1>(l, t)
                        );
                auto engine = this->template call<2>(l, t);
                return random_real(engine);
            }
    };
}}
#endif