1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
|
/* boost random/discard_block.hpp header file
*
* Copyright Jens Maurer 2002
* 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$
*
* Revision history
* 2001-03-02 created
*/
#ifndef BOOST_RANDOM_DISCARD_BLOCK_HPP
#define BOOST_RANDOM_DISCARD_BLOCK_HPP
#include <iostream>
#include <boost/config.hpp>
#include <boost/cstdint.hpp>
#include <boost/limits.hpp>
#include <boost/static_assert.hpp>
#include <boost/random/detail/config.hpp>
#include <boost/random/detail/seed.hpp>
#include <boost/random/detail/seed_impl.hpp>
namespace boost {
namespace random {
/**
* The class template \discard_block_engine is a model of
* \pseudo_random_number_generator. It modifies
* another generator by discarding parts of its output.
* Out of every block of @c p results, the first @c r
* will be returned and the rest discarded.
*
* Requires: 0 < p <= r
*/
template<class UniformRandomNumberGenerator, std::size_t p, std::size_t r>
class discard_block_engine
{
typedef typename detail::seed_type<
typename UniformRandomNumberGenerator::result_type>::type seed_type;
public:
typedef UniformRandomNumberGenerator base_type;
typedef typename base_type::result_type result_type;
BOOST_STATIC_CONSTANT(std::size_t, block_size = p);
BOOST_STATIC_CONSTANT(std::size_t, used_block = r);
BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
BOOST_STATIC_CONSTANT(std::size_t, total_block = p);
BOOST_STATIC_CONSTANT(std::size_t, returned_block = r);
BOOST_STATIC_ASSERT(total_block >= returned_block);
/** Uses the default seed for the base generator. */
discard_block_engine() : _rng(), _n(0) { }
/** Constructs a new \discard_block_engine with a copy of rng. */
explicit discard_block_engine(const base_type & rng) : _rng(rng), _n(0) { }
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
/** Constructs a new \discard_block_engine with rng. */
explicit discard_block_engine(base_type && rng) : _rng(rng), _n(0) { }
#endif
/**
* Creates a new \discard_block_engine and seeds the underlying
* generator with @c value
*/
BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(discard_block_engine,
seed_type, value)
{ _rng.seed(value); _n = 0; }
/**
* Creates a new \discard_block_engine and seeds the underlying
* generator with @c seq
*/
BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(discard_block_engine, SeedSeq, seq)
{ _rng.seed(seq); _n = 0; }
/**
* Creates a new \discard_block_engine and seeds the underlying
* generator with first and last.
*/
template<class It> discard_block_engine(It& first, It last)
: _rng(first, last), _n(0) { }
/** default seeds the underlying generator. */
void seed() { _rng.seed(); _n = 0; }
/** Seeds the underlying generator with s. */
BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(discard_block_engine, seed_type, s)
{ _rng.seed(s); _n = 0; }
/** Seeds the underlying generator with seq. */
BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(discard_block_engine, SeedSeq, seq)
{ _rng.seed(seq); _n = 0; }
/** Seeds the underlying generator with first and last. */
template<class It> void seed(It& first, It last)
{ _rng.seed(first, last); _n = 0; }
/** Returns the underlying engine. */
const base_type& base() const { return _rng; }
/** Returns the next value of the generator. */
result_type operator()()
{
if(_n >= returned_block) {
// discard values of random number generator
// Don't use discard, since we still need to
// be somewhat compatible with TR1.
// _rng.discard(total_block - _n);
for(std::size_t i = 0; i < total_block - _n; ++i) {
_rng();
}
_n = 0;
}
++_n;
return _rng();
}
void discard(boost::uintmax_t z)
{
for(boost::uintmax_t j = 0; j < z; ++j) {
(*this)();
}
}
template<class It>
void generate(It first, It last)
{ detail::generate(*this, first, last); }
/**
* Returns the smallest value that the generator can produce.
* This is the same as the minimum of the underlying generator.
*/
static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
{ return (base_type::min)(); }
/**
* Returns the largest value that the generator can produce.
* This is the same as the maximum of the underlying generator.
*/
static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
{ return (base_type::max)(); }
#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
/** Writes a \discard_block_engine to a @c std::ostream. */
template<class CharT, class Traits>
friend std::basic_ostream<CharT,Traits>&
operator<<(std::basic_ostream<CharT,Traits>& os,
const discard_block_engine& s)
{
os << s._rng << ' ' << s._n;
return os;
}
/** Reads a \discard_block_engine from a @c std::istream. */
template<class CharT, class Traits>
friend std::basic_istream<CharT,Traits>&
operator>>(std::basic_istream<CharT,Traits>& is, discard_block_engine& s)
{
is >> s._rng >> std::ws >> s._n;
return is;
}
#endif
/** Returns true if the two generators will produce identical sequences. */
friend bool operator==(const discard_block_engine& x,
const discard_block_engine& y)
{ return x._rng == y._rng && x._n == y._n; }
/** Returns true if the two generators will produce different sequences. */
friend bool operator!=(const discard_block_engine& x,
const discard_block_engine& y)
{ return !(x == y); }
private:
base_type _rng;
std::size_t _n;
};
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
// A definition is required even for integral static constants
template<class URNG, std::size_t p, std::size_t r>
const bool discard_block_engine<URNG, p, r>::has_fixed_range;
template<class URNG, std::size_t p, std::size_t r>
const std::size_t discard_block_engine<URNG, p, r>::total_block;
template<class URNG, std::size_t p, std::size_t r>
const std::size_t discard_block_engine<URNG, p, r>::returned_block;
template<class URNG, std::size_t p, std::size_t r>
const std::size_t discard_block_engine<URNG, p, r>::block_size;
template<class URNG, std::size_t p, std::size_t r>
const std::size_t discard_block_engine<URNG, p, r>::used_block;
#endif
/// \cond \show_deprecated
template<class URNG, int p, int r>
class discard_block : public discard_block_engine<URNG, p, r>
{
typedef discard_block_engine<URNG, p, r> base_t;
public:
typedef typename base_t::result_type result_type;
discard_block() {}
template<class T>
discard_block(T& arg) : base_t(arg) {}
template<class T>
discard_block(const T& arg) : base_t(arg) {}
template<class It>
discard_block(It& first, It last) : base_t(first, last) {}
result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
{ return (this->base().min)(); }
result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
{ return (this->base().max)(); }
};
/// \endcond
namespace detail {
template<class Engine>
struct generator_bits;
template<class URNG, std::size_t p, std::size_t r>
struct generator_bits<discard_block_engine<URNG, p, r> > {
static std::size_t value() { return generator_bits<URNG>::value(); }
};
template<class URNG, int p, int r>
struct generator_bits<discard_block<URNG, p, r> > {
static std::size_t value() { return generator_bits<URNG>::value(); }
};
}
} // namespace random
} // namespace boost
#endif // BOOST_RANDOM_DISCARD_BLOCK_HPP
|
