seed.hpp

Go to the documentation of this file.

//============================================================================
// vSMC/include/vsmc/rng/seed.hpp
//----------------------------------------------------------------------------
//                         vSMC: Scalable Monte Carlo
//----------------------------------------------------------------------------
// Copyright (c) 2013,2014, Yan Zhou
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//   Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
//
//   Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//============================================================================

#ifndef VSMC_RNG_SEED_HPP
#define VSMC_RNG_SEED_HPP

#include <vsmc/rng/internal/common.hpp>

#define VSMC_STATIC_ASSERT_RNG_SEED_GENERATOR_RESULT_TYPE(T) \
    VSMC_STATIC_ASSERT((::vsmc::cxx11::is_unsigned<T>::value),               \
            USE_SeedGenerator_WITH_A_RESULT_TYPE_NOT_AN_UNSIGNED_INTEGER)

#define VSMC_RUNTIME_ASSERT_RNG_SEED_GENERATOR_MODULO(div, rem) \
    VSMC_RUNTIME_ASSERT((div > rem),                                         \
            ("**SeedGenerator::modulo** "                                    \
             "REMAINDER IS NOT SMALLER THAN THE DIVISOR"))

#define VSMC_RUNTIME_WARNING_RNG_SEED_GENERATOR_MODULO(div, rem) \
    VSMC_RUNTIME_WARNING((div == 1 && rem == 0),                             \
            ("**SeedGenerator::modulo** "                                    \
             "COUNTER TYPE SEED DOES NOT SUPPORT MODULO"))

#define VSMC_RUNTIME_ASSERT_RNG_SEED_MAX(seed_max) \
    VSMC_RUNTIME_ASSERT((seed_max > 1),                                      \
            ("**SeedGenerator::modulo** "                                    \
             "THE MAXIMUM OF THE INTERNAL SEED IS NO LARGER THAN 1"))

#ifndef VSMC_SEED_RESULT_TYPE
#define VSMC_SEED_RESULT_TYPE unsigned
#endif

namespace vsmc {

template <typename ID, typename ResultType = VSMC_SEED_RESULT_TYPE>
class SeedGenerator
{
    public :

    typedef ResultType result_type;
    typedef ResultType skip_type;

    static SeedGenerator<ID, ResultType> &instance ()
    {
        static SeedGenerator<ID, ResultType> seed;

        return seed;
    }

    result_type get () {skip(); return seed_ * divisor_ + remainder_;}

    void set (result_type seed) {seed_ = seed % seed_max_;}

    result_type seed () const {return seed_;}

    result_type seed_max () const {return seed_max_;}

    skip_type divisor () const {return divisor_;}

    skip_type remainder () const {return remainder_;}

    void modulo (skip_type div, skip_type rem)
    {
        VSMC_RUNTIME_ASSERT_RNG_SEED_GENERATOR_MODULO(div, rem);

        divisor_ = div;
        remainder_ = rem;
        seed_max_ = static_cast<skip_type>(~static_cast<skip_type>(0));
        seed_max_ -= seed_max_ % divisor_;
        seed_max_ /= divisor_;

        VSMC_RUNTIME_ASSERT_RNG_SEED_MAX(seed_max_);

        set(seed_);
    }

    void skip (skip_type steps)
    {
        result_type incr = steps % seed_max_;
        result_type diff = seed_max_ - seed_;
        seed_ = incr <= diff ? (seed_ + incr) : (incr - diff);
    }

    void skip () {seed_ = seed_ == seed_max_ ? 1 : (seed_ + 1);}

    template <typename CharT, typename Traits>
    friend inline std::basic_ostream<CharT, Traits> &operator<< (
            std::basic_ostream<CharT, Traits> &os,
            const SeedGenerator<ID, ResultType> &sg)
    {
        if (!os.good())
            return os;

        os << sg.seed_ << ' ';
        os << sg.divisor_ << ' ';
        os << sg.remainder_;

        return os;
    }

    template <typename CharT, typename Traits>
    friend inline std::basic_istream<CharT, Traits> &operator>> (
            std::basic_istream<CharT, Traits> &is,
            SeedGenerator<ID, ResultType> &sg)
    {
        if (!is.good())
            return is;

        result_type s;
        skip_type div;
        skip_type rem;
        is >> std::ws >> s;
        is >> std::ws >> div;
        is >> std::ws >> rem;

        if (is.good()) {
            sg.modulo(div, rem);
            sg.set(s);
        }

        return is;
    }

    private :

    result_type seed_;
    result_type seed_max_;
    skip_type divisor_;
    skip_type remainder_;

    SeedGenerator () : seed_(0), seed_max_(0), divisor_(1), remainder_(0)
    {
        VSMC_STATIC_ASSERT_RNG_SEED_GENERATOR_RESULT_TYPE(ResultType);

        modulo(divisor_, remainder_);
    }

    SeedGenerator (const SeedGenerator<ID, ResultType> &);

    SeedGenerator<ID, ResultType> &operator= (
            const SeedGenerator<ID, ResultType> &);
}; // class SeedGenerator

template <typename ID, typename T, std::size_t K>
class SeedGenerator<ID, Array<T, K> >
{
    public :

    typedef Array<T, K> result_type;
    typedef T skip_type;

    static SeedGenerator<ID, Array<T, K> > &instance ()
    {
        static SeedGenerator<ID, Array<T, K> > seed;

        return seed;
    }

    result_type get () {skip(); return seed_;}

    void set (result_type seed) {seed_ = seed;}

    result_type seed () const {return seed_;}

    result_type seed_max () const {return seed_max_;}

    skip_type divisor () const {return divisor_;}

    skip_type remainder () const {return remainder_;}

    void modulo (skip_type div, skip_type rem)
    {
        VSMC_RUNTIME_WARNING_RNG_SEED_GENERATOR_MODULO(div, rem);

        divisor_ = div;
        remainder_ = rem;
        seed_max_.fill(static_cast<skip_type>(~static_cast<skip_type>(0)));

        set(seed_);
    }

    void skip (skip_type steps)
    {Counter<result_type>::increment(seed_, steps);}

    void skip () {Counter<result_type>::increment(seed_);}

    template <typename CharT, typename Traits>
    friend inline std::basic_ostream<CharT, Traits> &operator<< (
            std::basic_ostream<CharT, Traits> &os,
            const SeedGenerator<ID, Array<T, K> > &sg)
    {
        if (!os.good())
            return os;

        os << sg.seed_ << ' ';
        os << sg.divisor_ << ' ';
        os << sg.remainder_ << ' ';

        return os;
    }

    template <typename CharT, typename Traits>
    friend inline std::basic_istream<CharT, Traits> &operator>> (
            std::basic_istream<CharT, Traits> &is,
            SeedGenerator<ID, Array<T, K> > &sg)
    {
        if (!is.good())
            return is;

        result_type s;
        skip_type div;
        skip_type rem;
        is >> std::ws >> s;
        is >> std::ws >> div;
        is >> std::ws >> rem;

        if (is.good()) {
            sg.modulo(div, rem);
            sg.set(s);
        }

        return is;
    }

    private :

    result_type seed_;
    result_type seed_max_;
    skip_type divisor_;
    skip_type remainder_;

    SeedGenerator () : divisor_(1), remainder_(0)
    {
        VSMC_STATIC_ASSERT_RNG_SEED_GENERATOR_RESULT_TYPE(T);

        seed_.fill(0);
        seed_max_.fill(0);
        modulo(divisor_, remainder_);
    }

    SeedGenerator<ID, Array<T, K> > (const SeedGenerator<ID, Array<T, K> > &);

    SeedGenerator<ID, Array<T, K> > &operator= (
            const SeedGenerator<ID, Array<T, K> > &);
}; // class SeedGenerator

typedef SeedGenerator<NullType, VSMC_SEED_RESULT_TYPE> Seed;

} // namespace vsmc

#endif // VSMC_RNG_SEED_HPP