270 lines
9.2 KiB
Plaintext
270 lines
9.2 KiB
Plaintext
/* boost random/shuffle_order.hpp header file
|
|
*
|
|
* Copyright Jens Maurer 2000-2001
|
|
* Copyright Steven Watanabe 2010
|
|
* Distributed under the Boost Software License, Version 1.0. (See
|
|
* accompanying file LICENSE_1_0.txt or copy at
|
|
* http://www.boost.org/LICENSE_1_0.txt)
|
|
*
|
|
* See http://www.boost.org for most recent version including documentation.
|
|
*
|
|
* $Id$
|
|
*
|
|
*/
|
|
|
|
#ifndef BOOST_RANDOM_SHUFFLE_ORDER_HPP
|
|
#define BOOST_RANDOM_SHUFFLE_ORDER_HPP
|
|
|
|
#include <iostream>
|
|
#include <algorithm> // std::copy
|
|
#include <cassert>
|
|
#include <boost/config.hpp>
|
|
#include <boost/limits.hpp>
|
|
#include <boost/static_assert.hpp>
|
|
#include <boost/cstdint.hpp>
|
|
#include <boost/random/detail/operators.hpp>
|
|
#include <boost/random/detail/seed.hpp>
|
|
#include <boost/random/detail/signed_unsigned_tools.hpp>
|
|
#include <boost/random/linear_congruential.hpp>
|
|
|
|
#include <boost/random/detail/disable_warnings.hpp>
|
|
|
|
namespace boost {
|
|
namespace random {
|
|
|
|
/**
|
|
* Instatiations of class template @c shuffle_order_engine model a
|
|
* \pseudo_random_number_generator. It mixes the output
|
|
* of some (usually \linear_congruential_engine)
|
|
* \uniform_random_number_generator to get better statistical properties.
|
|
* The algorithm is described in
|
|
*
|
|
* @blockquote
|
|
* "Improving a poor random number generator", Carter Bays
|
|
* and S.D. Durham, ACM Transactions on Mathematical Software,
|
|
* Vol 2, No. 1, March 1976, pp. 59-64.
|
|
* http://doi.acm.org/10.1145/355666.355670
|
|
* @endblockquote
|
|
*
|
|
* The output of the base generator is buffered in an array of
|
|
* length k. Every output X(n) has a second role: It gives an
|
|
* index into the array where X(n+1) will be retrieved. Used
|
|
* array elements are replaced with fresh output from the base
|
|
* generator.
|
|
*
|
|
* Template parameters are the base generator and the array
|
|
* length k, which should be around 100.
|
|
*/
|
|
template<class UniformRandomNumberGenerator, std::size_t k>
|
|
class shuffle_order_engine
|
|
{
|
|
public:
|
|
typedef UniformRandomNumberGenerator base_type;
|
|
typedef typename base_type::result_type result_type;
|
|
|
|
BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
|
|
BOOST_STATIC_CONSTANT(std::size_t, buffer_size = k);
|
|
BOOST_STATIC_CONSTANT(std::size_t, table_size = k);
|
|
|
|
BOOST_STATIC_ASSERT(std::numeric_limits<result_type>::is_integer);
|
|
BOOST_STATIC_ASSERT(k > 0);
|
|
|
|
/**
|
|
* Constructs a @c shuffle_order_engine by invoking the
|
|
* default constructor of the base generator.
|
|
*
|
|
* Complexity: Exactly k+1 invocations of the base generator.
|
|
*/
|
|
shuffle_order_engine() : _rng() { init(); }
|
|
/**
|
|
* Constructs a @c shuffle_output_engine by invoking the one-argument
|
|
* constructor of the base generator with the parameter seed.
|
|
*
|
|
* Complexity: Exactly k+1 invocations of the base generator.
|
|
*/
|
|
BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(shuffle_order_engine,
|
|
result_type, s)
|
|
{ _rng.seed(s); init(); }
|
|
BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(shuffle_order_engine, SeedSeq, seq)
|
|
{ _rng.seed(seq); init(); }
|
|
/**
|
|
* Constructs a @c shuffle_output_engine by using a copy
|
|
* of the provided generator.
|
|
*
|
|
* Precondition: The template argument UniformRandomNumberGenerator
|
|
* shall denote a CopyConstructible type.
|
|
*
|
|
* Complexity: Exactly k+1 invocations of the base generator.
|
|
*/
|
|
explicit shuffle_order_engine(const base_type & rng) : _rng(rng) { init(); }
|
|
|
|
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
|
|
explicit shuffle_order_engine(base_type&& rng) : _rng(rng) { init(); }
|
|
#endif
|
|
|
|
template<class It> shuffle_order_engine(It& first, It last)
|
|
: _rng(first, last) { init(); }
|
|
void seed() { _rng.seed(); init(); }
|
|
/**
|
|
* Invokes the one-argument seed method of the base generator
|
|
* with the parameter seed and re-initializes the internal buffer array.
|
|
*
|
|
* Complexity: Exactly k+1 invocations of the base generator.
|
|
*/
|
|
BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(shuffle_order_engine,
|
|
result_type, seed_arg)
|
|
{ _rng.seed(seed_arg); init(); }
|
|
/**
|
|
* Invokes the one-argument seed method of the base generator
|
|
* with the parameter seq and re-initializes the internal buffer array.
|
|
*
|
|
* Complexity: Exactly k+1 invocations of the base generator.
|
|
*/
|
|
BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(shuffle_order_engine, SeedSeq, seq)
|
|
{ _rng.seed(seq); init(); }
|
|
template<class It> void seed(It& first, It last)
|
|
{ _rng.seed(first, last); init(); }
|
|
|
|
const base_type& base() const { return _rng; }
|
|
|
|
result_type operator()() {
|
|
// calculating the range every time may seem wasteful. However, this
|
|
// makes the information locally available for the optimizer.
|
|
typedef typename boost::random::traits::make_unsigned<result_type>::type base_unsigned;
|
|
const base_unsigned brange =
|
|
detail::subtract<result_type>()((max)(), (min)());
|
|
const base_unsigned off =
|
|
detail::subtract<result_type>()(y, (min)());
|
|
|
|
base_unsigned j;
|
|
if(k == 1) {
|
|
j = 0;
|
|
} else if(brange < (std::numeric_limits<base_unsigned>::max)() / k) {
|
|
// try to do it in the native type if we know that it won't
|
|
// overflow
|
|
j = k * off / (brange + 1);
|
|
} else if(brange < (std::numeric_limits<uintmax_t>::max)() / k) {
|
|
// Otherwise try to use uint64_t
|
|
j = static_cast<base_unsigned>(
|
|
static_cast<uintmax_t>(off) * k /
|
|
(static_cast<uintmax_t>(brange) + 1));
|
|
} else {
|
|
boost::uintmax_t divisor =
|
|
static_cast<boost::uintmax_t>(brange) + 1;
|
|
j = static_cast<base_unsigned>(detail::muldiv(off, k, divisor));
|
|
}
|
|
// assert(0 <= j && j < k);
|
|
y = v[j];
|
|
v[j] = _rng();
|
|
return y;
|
|
}
|
|
|
|
/** Advances the generator by z steps. */
|
|
void discard(boost::uintmax_t z)
|
|
{
|
|
for(boost::uintmax_t j = 0; j < z; ++j) {
|
|
(*this)();
|
|
}
|
|
}
|
|
|
|
/** Fills a range with pseudo-random values. */
|
|
template<class Iter>
|
|
void generate(Iter first, Iter last)
|
|
{ detail::generate_from_int(*this, first, last); }
|
|
|
|
/** Returns the smallest value that the generator can produce. */
|
|
static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
|
|
{ return (base_type::min)(); }
|
|
/** Returns the largest value that the generator can produce. */
|
|
static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
|
|
{ return (base_type::max)(); }
|
|
|
|
/** Writes a @c shuffle_order_engine to a @c std::ostream. */
|
|
BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, shuffle_order_engine, s)
|
|
{
|
|
os << s._rng;
|
|
for(std::size_t i = 0; i < k; ++i)
|
|
os << ' ' << s.v[i];
|
|
os << ' ' << s.y;
|
|
return os;
|
|
}
|
|
|
|
/** Reads a @c shuffle_order_engine from a @c std::istream. */
|
|
BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, shuffle_order_engine, s)
|
|
{
|
|
is >> s._rng;
|
|
for(std::size_t i = 0; i < k; ++i)
|
|
is >> std::ws >> s.v[i];
|
|
is >> std::ws >> s.y;
|
|
return is;
|
|
}
|
|
|
|
/** Returns true if the two generators will produce identical sequences. */
|
|
BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(shuffle_order_engine, x, y)
|
|
{ return x._rng == y._rng && x.y == y.y && std::equal(x.v, x.v+k, y.v); }
|
|
/** Returns true if the two generators will produce different sequences. */
|
|
BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(shuffle_order_engine)
|
|
|
|
private:
|
|
|
|
/// \cond show_private
|
|
|
|
void init()
|
|
{
|
|
// we cannot use std::generate, because it uses pass-by-value for _rng
|
|
for(result_type * p = v; p != v+k; ++p)
|
|
*p = _rng();
|
|
y = _rng();
|
|
}
|
|
|
|
/// \endcond
|
|
|
|
base_type _rng;
|
|
result_type v[k];
|
|
result_type y;
|
|
};
|
|
|
|
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
|
|
// A definition is required even for integral static constants
|
|
template<class URNG, std::size_t k>
|
|
const bool shuffle_order_engine<URNG, k>::has_fixed_range;
|
|
template<class URNG, std::size_t k>
|
|
const std::size_t shuffle_order_engine<URNG, k>::table_size;
|
|
template<class URNG, std::size_t k>
|
|
const std::size_t shuffle_order_engine<URNG, k>::buffer_size;
|
|
#endif
|
|
|
|
/**
|
|
* According to Harry Erwin (private e-mail), the specialization
|
|
* @c kreutzer1986 was suggested in:
|
|
*
|
|
* @blockquote
|
|
* "System Simulation: Programming Styles and Languages (International
|
|
* Computer Science Series)", Wolfgang Kreutzer, Addison-Wesley, December 1986.
|
|
* @endblockquote
|
|
*/
|
|
typedef shuffle_order_engine<
|
|
linear_congruential_engine<uint32_t, 1366, 150889, 714025>,
|
|
97> kreutzer1986;
|
|
|
|
/**
|
|
* The specialization @c knuth_b is specified by the C++ standard.
|
|
* It is described in
|
|
*
|
|
* @blockquote
|
|
* "The Art of Computer Programming, Second Edition, Volume 2,
|
|
* Seminumerical Algorithms", Donald Knuth, Addison-Wesley, 1981.
|
|
* @endblockquote
|
|
*/
|
|
typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
|
|
|
|
} // namespace random
|
|
|
|
using random::kreutzer1986;
|
|
|
|
} // namespace boost
|
|
|
|
#include <boost/random/detail/enable_warnings.hpp>
|
|
|
|
#endif // BOOST_RANDOM_SHUFFLE_OUTPUT_HPP
|