/var/lib/jenkins/jobs/Skylark/workspace/utility/randgen.hpp

Go to the documentation of this file.

#ifndef RANDGEN_HPP
#define RANDGEN_HPP

#include <sstream>

#include <Random123/threefry.h>
#include <Random123/MicroURNG.hpp>

namespace skylark { namespace utility {


template <typename Distribution>
struct random_samples_array_t {

public:

    typedef typename Distribution::result_type value_type;

    typedef r123::Threefry4x64 RNG_t;
    typedef RNG_t::ctr_type ctr_t;
    typedef RNG_t::key_type key_t;
    typedef r123::MicroURNG<RNG_t> URNG_t;

    /*
     * Helper routine for handling array initializer in pre C++11 compilers
     */
    static key_t _seed_to_key(int seed) {
        key_t key;
        for(int i = 1; i < 4; i++)
            key.v[i] =  static_cast<key_t::value_type>(0);
        key.v[0] = static_cast<key_t::value_type>(seed);
        return key;
    }

    random_samples_array_t() :
        _base(0), _size(0), _key(_seed_to_key(0)), _distribution() {

    }

    random_samples_array_t(size_t base, size_t size, int seed,
        Distribution& distribution)
        : _base(base), _size(size),
          _key(_seed_to_key(seed)),
          _distribution(distribution) {
        if(std::numeric_limits<size_t>::max() - base < size - 1) {
            std::ostringstream msg;
            msg << "Unsupported operation:\n";
            msg << "The random number generator stream cannot supply the ";
            msg << "requested number of samples without being exhausted\n";
            SKYLARK_THROW_EXCEPTION (
                base::random123_exception()
                << base::error_msg(msg.str()) );
        }
        _distribution.reset();
    }

    random_samples_array_t(const random_samples_array_t& other) :
        _base(other._base), _size(other._size), _key(other._key),
        _distribution(other._distribution) {

    }

    random_samples_array_t& operator=(const random_samples_array_t& other) {
        _base = other._base;
        _size = other._size;
        _key = other._key;
        _distribution = other._distribution;
        return *this;
    }

    value_type operator[](size_t index) const {
        // Could be more specific exception std::out_of_range
        if( index >= _size ) {
            std::ostringstream msg;
            msg << "Index is out of bounds:\n";
            msg << "index = " << index << " not in expected ";
            msg << "[0, " << _size << ") range\n";
            SKYLARK_THROW_EXCEPTION (
                base::random123_exception()
                << base::error_msg(msg.str()) );
        }
        ctr_t ctr;
        for(int i = 1; i < 4; i++)
            ctr.v[i] = static_cast<ctr_t::value_type>(0);
        ctr.v[0] = static_cast<ctr_t::value_type>(_base + index);
        URNG_t urng(ctr, _key);
        Distribution cloned_distribution = _distribution;
        return cloned_distribution(urng);
    }

private:
    size_t _base;
    size_t _size;
    key_t _key;
    Distribution _distribution;
};


struct random_array_t {

public:
    typedef r123::Threefry4x64 RNG_t;
    typedef RNG_t::ctr_type ctr_t;
    typedef RNG_t::key_type key_t;
    typedef r123::MicroURNG<RNG_t> URNG_t;

    /*
     * Helper routine for handling array initializer in pre C++11 compilers
     */
    static key_t _seed_to_key(int seed) {
        key_t key;
        for(int i = 1; i < 4; i++)
            key.v[i] =  static_cast<key_t::value_type>(0);
        key.v[0] = static_cast<key_t::value_type>(seed);
        return key;
    }

    random_array_t(size_t base, size_t size, int seed)
        : _base(base), _size(size), _key(_seed_to_key(seed)) {
        if(std::numeric_limits<size_t>::max() - base + 1 < size) {
            std::ostringstream msg;
            msg << "Usupported operation:\n";
            msg << "The random number generator stream cannot supply the ";
            msg << "requested number of samples without being exhausted\n";
            SKYLARK_THROW_EXCEPTION (
                base::random123_exception()
                << base::error_msg(msg.str()) );
        }
    }

    int operator[](size_t index) const {
        // Could be more specific exception std::out_of_range
        if( index >= _size ) {
            std::ostringstream msg;
            msg << "Index is out of bounds:\n";
            msg << "index = " << index << " not in expected ";
            msg << "[0, " << _size << ") range\n";
            SKYLARK_THROW_EXCEPTION (
                base::random123_exception()
                << base::error_msg(msg.str()) );
        }
        ctr_t ctr;
        for(int i = 1; i < 4; i++)
            ctr.v[i] = static_cast<ctr_t::value_type>(0);
        ctr.v[0] = static_cast<ctr_t::value_type>(_base + index);
        URNG_t urng(ctr, _key);
        return urng();
    }

private:
    const size_t _base;
    const size_t _size;
    const key_t _key;
};

} } 
#endif // RANDGEN_HPP