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
|
/* boost random/detail/gray_coded_qrng.hpp header file
*
* Copyright Justinas Vygintas Daugmaudis 2010-2018
* 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)
*/
#ifndef BOOST_RANDOM_DETAIL_GRAY_CODED_QRNG_HPP
#define BOOST_RANDOM_DETAIL_GRAY_CODED_QRNG_HPP
#include <boost/random/detail/qrng_base.hpp>
#include <boost/multiprecision/integer.hpp> // lsb
#include <functional> // bit_xor
#include <boost/mpl/if.hpp>
#include <boost/integer/integer_mask.hpp>
//!\file
//!Describes the gray-coded quasi-random number generator base class template.
namespace boost {
namespace random {
namespace qrng_detail {
template<typename LatticeT>
class gray_coded_qrng
: public qrng_base<
gray_coded_qrng<LatticeT>
, LatticeT
, typename LatticeT::value_type
>
{
public:
typedef typename LatticeT::value_type result_type;
typedef result_type size_type;
private:
typedef gray_coded_qrng<LatticeT> self_t;
typedef qrng_base<self_t, LatticeT, size_type> base_t;
// The base needs to access modifying member f-ns, and we
// don't want these functions to be available for the public use
friend class qrng_base<self_t, LatticeT, size_type>;
// Respect lattice bit_count here
struct check_nothing {
inline static void bit_pos(unsigned) {}
inline static void code_size(size_type) {}
};
struct check_bit_range {
static void raise_bit_count() {
boost::throw_exception( std::range_error("gray_coded_qrng: bit_count") );
}
inline static void bit_pos(unsigned bit_pos) {
if (bit_pos >= LatticeT::bit_count)
raise_bit_count();
}
inline static void code_size(size_type code) {
if (code > (self_t::max)())
raise_bit_count();
}
};
// We only want to check whether bit pos is outside the range if given bit_count
// is narrower than the size_type, otherwise checks compile to nothing.
BOOST_STATIC_ASSERT(LatticeT::bit_count <= std::numeric_limits<size_type>::digits);
typedef typename mpl::if_c<
((LatticeT::bit_count) < std::numeric_limits<size_type>::digits)
, check_bit_range
, check_nothing
>::type check_bit_range_t;
public:
//!Returns: Tight lower bound on the set of values returned by operator().
//!
//!Throws: nothing.
static BOOST_CONSTEXPR result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
{ return 0; }
//!Returns: Tight upper bound on the set of values returned by operator().
//!
//!Throws: nothing.
static BOOST_CONSTEXPR result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
{ return low_bits_mask_t<LatticeT::bit_count>::sig_bits; }
explicit gray_coded_qrng(std::size_t dimension)
: base_t(dimension)
{}
// default copy c-tor is fine
// default assignment operator is fine
void seed()
{
set_zero_state();
update_quasi(0);
base_t::reset_seq(0);
}
void seed(const size_type init)
{
if (init != this->curr_seq())
{
// We don't want negative seeds.
check_seed_sign(init);
size_type seq_code = boost::next(init);
if (BOOST_UNLIKELY(!(init < seq_code)))
boost::throw_exception( std::range_error("gray_coded_qrng: seed") );
seq_code ^= (seq_code >> 1);
// Fail if we see that seq_code is outside bit range.
// We do that before we even touch engine state.
check_bit_range_t::code_size(seq_code);
set_zero_state();
for (unsigned r = 0; seq_code != 0; ++r, seq_code >>= 1)
{
if (seq_code & static_cast<size_type>(1))
update_quasi(r);
}
}
// Everything went well, set the new seq count
base_t::reset_seq(init);
}
private:
void compute_seq(size_type seq)
{
// Find the position of the least-significant zero in sequence count.
// This is the bit that changes in the Gray-code representation as
// the count is advanced.
// Xor'ing with max() has the effect of flipping all the bits in seq,
// except for the sign bit.
unsigned r = multiprecision::lsb(seq ^ (self_t::max)());
check_bit_range_t::bit_pos(r);
update_quasi(r);
}
void update_quasi(unsigned r)
{
// Calculate the next state.
std::transform(this->state_begin(), this->state_end(),
this->lattice.iter_at(r * this->dimension()), this->state_begin(),
std::bit_xor<result_type>());
}
void set_zero_state()
{
std::fill(this->state_begin(), this->state_end(), result_type /*zero*/ ());
}
};
} // namespace qrng_detail
} // namespace random
} // namespace boost
#endif // BOOST_RANDOM_DETAIL_GRAY_CODED_QRNG_HPP
|
