RandomEngine.h

Go to the documentation of this file.

#ifndef SIMPT_MATH_RANDOM_ENGINE_H_INCLUDED
#define SIMPT_MATH_RANDOM_ENGINE_H_INCLUDED
/*
 * Copyright 2011-2016 Universiteit Antwerpen
 *
 * Licensed under the EUPL, Version 1.1 or  as soon they will be approved by
 * the European Commission - subsequent versions of the EUPL (the "Licence");
 * You may not use this work except in compliance with the Licence.
 * You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl5
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the Licence is distributed on an "AS IS" basis,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the Licence for the specific language governing
 * permissions and limitations under the Licence.
 */
#include "RandomEngineType.h"

#include <trng/lcg64_shift.hpp>
#include <trng/lcg64.hpp>
#include <trng/mrg2.hpp>
#include <trng/mrg3.hpp>
#include <trng/yarn2.hpp>
#include <trng/yarn3.hpp>
#include <boost/property_tree/ptree.hpp>
#include <functional>
#include <string>
#include <vector>

namespace SimPT_Sim {

class RandomEngine
{
public:
        RandomEngine();

        RandomEngineType::Info GetInfo() const;

        template<typename D>
        std::function<typename D::result_type()> GetGenerator(const D& d, int i = 0)
        {
                using namespace RandomEngineType;

                std::function<typename D::result_type()>  gen;
                switch (m_type_id) {
                case TypeId::lcg64 :
                        gen = std::bind(d, std::ref(m_lcg64[i])); break;
                case TypeId::lcg64_shift  :
                        gen = std::bind(d, std::ref(m_lcg64_shift[i])); break;
                case TypeId::mrg2 :
                        gen = std::bind(d, std::ref(m_mrg2[i])); break;
                case TypeId::mrg3 :
                        gen = std::bind(d, std::ref(m_mrg3[i])); break;
                case TypeId::yarn2 :
                        gen = std::bind(d, std::ref(m_yarn2[i])); break;
                case TypeId::yarn3 :
                        gen = std::bind(d, std::ref(m_yarn3[i])); break;
                }
                return gen;
        }

        bool Reinitialize();

        bool Reinitialize(const boost::property_tree::ptree& ptree);

private:
        void SetState(unsigned long);

        void SetState(const std::string& state);

        unsigned long               m_seed;    
        RandomEngineType::TypeId    m_type_id; 

private:
        std::vector<trng::lcg64>             m_lcg64;
        std::vector<trng::lcg64_shift>       m_lcg64_shift;
        std::vector<trng::mrg2>              m_mrg2;
        std::vector<trng::mrg3>              m_mrg3;
        std::vector<trng::yarn2>             m_yarn2;
        std::vector<trng::yarn3>             m_yarn3;
};

} // namespace

#endif // end-of-include-guard