mirror of
https://github.com/bolero-MURAKAMI/Sprout
synced 2025-08-03 12:49:50 +00:00
fix coding-stype
This commit is contained in:
bolero-MURAKAMI
parent
2012838899
commit
df3023db30
196 changed files with 2510 additions and 3945 deletions
|
|
@ -38,7 +38,9 @@ namespace sprout {
|
|||
static SPROUT_CONSTEXPR IntType arg_check(IntType const& x0) {
|
||||
return arg_check_nothrow(x0)
|
||||
? x0
|
||||
: throw std::invalid_argument("inversive_congruential_engine<>: invalid argument (x0 >= static_min() && x0 <= static_max())")
|
||||
: throw std::invalid_argument(
|
||||
"inversive_congruential_engine<>: invalid argument (x0 >= static_min() && x0 <= static_max())"
|
||||
)
|
||||
;
|
||||
}
|
||||
static SPROUT_CONSTEXPR IntType init_seed_2(IntType const& x0) {
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ namespace sprout {
|
|||
Engine const& engine, Distribution const& distribution,
|
||||
typename sprout::generator_iterator<typename std::remove_reference<decltype(distribution(engine))>::type>::difference_type count = -1
|
||||
)
|
||||
-> sprout::generator_iterator<typename std::remove_reference<decltype(distribution(engine))>::type>
|
||||
-> sprout::generator_iterator<typename std::remove_reference<decltype(distribution(engine))>::type>
|
||||
{
|
||||
return sprout::generator_iterator<typename std::remove_reference<decltype(distribution(engine))>::type>(distribution(engine), count);
|
||||
}
|
||||
|
|
@ -30,7 +30,7 @@ namespace sprout {
|
|||
Engine const& engine,
|
||||
typename sprout::generator_iterator<typename std::remove_reference<decltype(engine())>::type>::difference_type count = -1
|
||||
)
|
||||
-> sprout::generator_iterator<typename std::remove_reference<decltype(engine())>::type>
|
||||
-> sprout::generator_iterator<typename std::remove_reference<decltype(engine())>::type>
|
||||
{
|
||||
return sprout::generator_iterator<typename std::remove_reference<decltype(engine())>::type>(engine(), count);
|
||||
}
|
||||
|
|
@ -44,14 +44,14 @@ namespace sprout {
|
|||
>
|
||||
inline SPROUT_CONSTEXPR auto
|
||||
end(Engine const& engine, Distribution const& distribution)
|
||||
-> sprout::generator_iterator<typename std::remove_reference<decltype(distribution(engine))>::type>
|
||||
-> sprout::generator_iterator<typename std::remove_reference<decltype(distribution(engine))>::type>
|
||||
{
|
||||
return sprout::generator_iterator<typename std::remove_reference<decltype(distribution(engine))>::type>();
|
||||
}
|
||||
template<typename Engine>
|
||||
inline SPROUT_CONSTEXPR auto
|
||||
end(Engine const& engine)
|
||||
-> sprout::generator_iterator<typename std::remove_reference<decltype(engine())>::type>
|
||||
-> sprout::generator_iterator<typename std::remove_reference<decltype(engine())>::type>
|
||||
{
|
||||
return sprout::generator_iterator<typename std::remove_reference<decltype(engine())>::type>();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,7 +15,11 @@ namespace sprout {
|
|||
//
|
||||
// mersenne_twister_engine
|
||||
//
|
||||
template<typename UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f>
|
||||
template<
|
||||
typename UIntType,
|
||||
std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d,
|
||||
std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f
|
||||
>
|
||||
class mersenne_twister_engine {
|
||||
public:
|
||||
typedef UIntType result_type;
|
||||
|
|
@ -79,41 +83,55 @@ namespace sprout {
|
|||
: x_(x)
|
||||
, i_(i)
|
||||
{}
|
||||
SPROUT_CONSTEXPR UIntType rewind_find_1(UIntType const* last, std::size_t size, std::size_t index) const {
|
||||
SPROUT_CONSTEXPR UIntType
|
||||
rewind_find_1(UIntType const* last, std::size_t size, std::size_t index) const {
|
||||
return index < n - size
|
||||
? x_[index]
|
||||
: *(last - (n - 1 - index))
|
||||
;
|
||||
}
|
||||
SPROUT_CONSTEXPR UIntType rewind_find(UIntType const* last, std::size_t size, std::size_t i) const {
|
||||
SPROUT_CONSTEXPR UIntType
|
||||
rewind_find(UIntType const* last, std::size_t size, std::size_t i) const {
|
||||
return rewind_find_1(last, size, (i + n - size + n - 1) % n);
|
||||
}
|
||||
template<typename... Args>
|
||||
SPROUT_CONSTEXPR typename std::enable_if<
|
||||
sizeof...(Args) == n,
|
||||
sprout::array<UIntType, n>
|
||||
>::type rewind_finish_1(sprout::array<UIntType, n> const& data, Args const&... args) const {
|
||||
>::type
|
||||
rewind_finish_1(sprout::array<UIntType, n> const& data, Args const&... args) const {
|
||||
return sprout::array<UIntType, n>{{args...}};
|
||||
}
|
||||
template<typename... Args>
|
||||
SPROUT_CONSTEXPR typename std::enable_if<
|
||||
sizeof...(Args) < n,
|
||||
sprout::array<UIntType, n>
|
||||
>::type rewind_finish_1(sprout::array<UIntType, n> const& data, Args const&... args) const {
|
||||
>::type
|
||||
rewind_finish_1(sprout::array<UIntType, n> const& data, Args const&... args) const {
|
||||
return rewind_finish_1(data, args..., data[sizeof...(args)]);
|
||||
}
|
||||
template<typename... Args>
|
||||
SPROUT_CONSTEXPR typename std::enable_if<
|
||||
sizeof...(Args) == n,
|
||||
sprout::array<UIntType, n>
|
||||
>::type rewind_finish(sprout::array<UIntType, n> const& data, UIntType const* last, std::size_t z, std::size_t i, Args const&... args) const {
|
||||
>::type
|
||||
rewind_finish(
|
||||
sprout::array<UIntType, n> const& data, UIntType const* last, std::size_t z, std::size_t i,
|
||||
Args const&... args
|
||||
) const
|
||||
{
|
||||
return sprout::array<UIntType, n>{{args...}};
|
||||
}
|
||||
template<typename... Args>
|
||||
SPROUT_CONSTEXPR typename std::enable_if<
|
||||
sizeof...(Args) < n,
|
||||
sprout::array<UIntType, n>
|
||||
>::type rewind_finish(sprout::array<UIntType, n> const& data, UIntType const* last, std::size_t z, std::size_t i, Args const&... args) const {
|
||||
>::type
|
||||
rewind_finish(
|
||||
sprout::array<UIntType, n> const& data, UIntType const* last, std::size_t z, std::size_t i,
|
||||
Args const&... args
|
||||
) const
|
||||
{
|
||||
return &data[0] + i == last - z
|
||||
? rewind_finish_1(data, data[i], args...)
|
||||
: rewind_finish(data, last, z, i + 1, data[i], args...)
|
||||
|
|
@ -123,21 +141,26 @@ namespace sprout {
|
|||
SPROUT_CONSTEXPR typename std::enable_if<
|
||||
sizeof...(Args) == n,
|
||||
sprout::array<UIntType, n>
|
||||
>::type rewind_4(sprout::array<UIntType, n> const& data, UIntType const* last, std::size_t z, UIntType y0, UIntType y1, std::size_t i, Args const&... args) const {
|
||||
>::type
|
||||
rewind_4(
|
||||
sprout::array<UIntType, n> const& data, UIntType const* last, std::size_t z, UIntType y0, UIntType y1, std::size_t i,
|
||||
Args const&... args
|
||||
) const
|
||||
{
|
||||
return sprout::array<UIntType, n>{{args...}};
|
||||
}
|
||||
template<typename... Args>
|
||||
SPROUT_CONSTEXPR typename std::enable_if<
|
||||
sizeof...(Args) < n,
|
||||
sprout::array<UIntType, n>
|
||||
>::type rewind_4(sprout::array<UIntType, n> const& data, UIntType const* last, std::size_t z, UIntType y0, UIntType y1, std::size_t i, Args const&... args) const {
|
||||
>::type
|
||||
rewind_4(
|
||||
sprout::array<UIntType, n> const& data, UIntType const* last, std::size_t z, UIntType y0, UIntType y1, std::size_t i,
|
||||
Args const&... args
|
||||
) const
|
||||
{
|
||||
return rewind_2(
|
||||
data,
|
||||
last,
|
||||
z,
|
||||
y1,
|
||||
i,
|
||||
(y0 & upper_mask) | (y1 & lower_mask),
|
||||
data, last, z, y1, i, (y0 & upper_mask) | (y1 & lower_mask),
|
||||
args...
|
||||
);
|
||||
}
|
||||
|
|
@ -145,19 +168,26 @@ namespace sprout {
|
|||
SPROUT_CONSTEXPR typename std::enable_if<
|
||||
sizeof...(Args) == n,
|
||||
sprout::array<UIntType, n>
|
||||
>::type rewind_3(sprout::array<UIntType, n> const& data, UIntType const* last, std::size_t z, UIntType y0, UIntType y1, std::size_t i, Args const&... args) const {
|
||||
>::type
|
||||
rewind_3(
|
||||
sprout::array<UIntType, n> const& data, UIntType const* last, std::size_t z, UIntType y0, UIntType y1, std::size_t i,
|
||||
Args const&... args
|
||||
) const
|
||||
{
|
||||
return sprout::array<UIntType, n>{{args...}};
|
||||
}
|
||||
template<typename... Args>
|
||||
SPROUT_CONSTEXPR typename std::enable_if<
|
||||
sizeof...(Args) < n,
|
||||
sprout::array<UIntType, n>
|
||||
>::type rewind_3(sprout::array<UIntType, n> const& data, UIntType const* last, std::size_t z, UIntType y0, UIntType y1, std::size_t i, Args const&... args) const {
|
||||
>::type
|
||||
rewind_3(
|
||||
sprout::array<UIntType, n> const& data, UIntType const* last, std::size_t z, UIntType y0, UIntType y1, std::size_t i,
|
||||
Args const&... args
|
||||
) const
|
||||
{
|
||||
return rewind_4(
|
||||
data,
|
||||
last,
|
||||
z,
|
||||
y0,
|
||||
data, last, z, y0,
|
||||
y1 & (static_cast<UIntType>(1) << (w - 1))
|
||||
? ((y1 ^ a) << 1) | 1
|
||||
: y1 << 1
|
||||
|
|
@ -170,20 +200,31 @@ namespace sprout {
|
|||
SPROUT_CONSTEXPR typename std::enable_if<
|
||||
sizeof...(Args) == n,
|
||||
sprout::array<UIntType, n>
|
||||
>::type rewind_2(sprout::array<UIntType, n> const& data, UIntType const* last, std::size_t z, UIntType y0, std::size_t i, Args const&... args) const {
|
||||
>::type
|
||||
rewind_2(
|
||||
sprout::array<UIntType, n> const& data, UIntType const* last, std::size_t z, UIntType y0, std::size_t i,
|
||||
Args const&... args
|
||||
) const
|
||||
{
|
||||
return sprout::array<UIntType, n>{{args...}};
|
||||
}
|
||||
template<typename... Args>
|
||||
SPROUT_CONSTEXPR typename std::enable_if<
|
||||
sizeof...(Args) < n,
|
||||
sprout::array<UIntType, n>
|
||||
>::type rewind_2(sprout::array<UIntType, n> const& data, UIntType const* last, std::size_t z, UIntType y0, std::size_t i, Args const&... args) const {
|
||||
>::type
|
||||
rewind_2(
|
||||
sprout::array<UIntType, n> const& data, UIntType const* last, std::size_t z, UIntType y0, std::size_t i,
|
||||
Args const&... args
|
||||
) const
|
||||
{
|
||||
return i < z
|
||||
? rewind_3(data, last, z, y0, rewind_find(last, i, m - 1) ^ rewind_find(last, i, n - 1), i, args...)
|
||||
: rewind_finish(data, last, z, 0, args...)
|
||||
;
|
||||
}
|
||||
SPROUT_CONSTEXPR sprout::array<UIntType, n> rewind_1(sprout::array<UIntType, n> const& data, UIntType const* last, std::size_t z, UIntType y0) const {
|
||||
SPROUT_CONSTEXPR sprout::array<UIntType, n>
|
||||
rewind_1(sprout::array<UIntType, n> const& data, UIntType const* last, std::size_t z, UIntType y0) const {
|
||||
return rewind_2(
|
||||
data,
|
||||
last,
|
||||
|
|
@ -195,10 +236,12 @@ namespace sprout {
|
|||
0
|
||||
);
|
||||
}
|
||||
SPROUT_CONSTEXPR sprout::array<UIntType, n> rewind(sprout::array<UIntType, n> const& data, UIntType const* last, std::size_t z) const {
|
||||
SPROUT_CONSTEXPR sprout::array<UIntType, n>
|
||||
rewind(sprout::array<UIntType, n> const& data, UIntType const* last, std::size_t z) const {
|
||||
return rewind_1(data, last, z, x_[m - 1] ^ x_[n - 1]);
|
||||
}
|
||||
SPROUT_CONSTEXPR bool equal_impl_2(mersenne_twister_engine const& other, sprout::array<UIntType, n> back, std::size_t offset, std::size_t i = 0) const {
|
||||
SPROUT_CONSTEXPR bool
|
||||
equal_impl_2(mersenne_twister_engine const& other, sprout::array<UIntType, n> back, std::size_t offset, std::size_t i = 0) const {
|
||||
return i < offset
|
||||
? back[i + n - offset] != other.x_[i]
|
||||
? false
|
||||
|
|
@ -206,7 +249,8 @@ namespace sprout {
|
|||
: true
|
||||
;
|
||||
}
|
||||
SPROUT_CONSTEXPR bool equal_impl_1(mersenne_twister_engine const& other, sprout::array<UIntType, n> back, std::size_t offset, std::size_t i = 0) const {
|
||||
SPROUT_CONSTEXPR bool
|
||||
equal_impl_1(mersenne_twister_engine const& other, sprout::array<UIntType, n> back, std::size_t offset, std::size_t i = 0) const {
|
||||
return i + offset < n
|
||||
? x_[i] != other.x_[i + offset]
|
||||
? false
|
||||
|
|
@ -214,7 +258,8 @@ namespace sprout {
|
|||
: equal_impl_2(other, rewind(back, &back[n - 1], offset), offset)
|
||||
;
|
||||
}
|
||||
SPROUT_CONSTEXPR bool equal_impl(mersenne_twister_engine const& other) const {
|
||||
SPROUT_CONSTEXPR bool
|
||||
equal_impl(mersenne_twister_engine const& other) const {
|
||||
return equal_impl_1(other, sprout::array<UIntType, n>(), other.i_ - i_);
|
||||
}
|
||||
SPROUT_CONSTEXPR UIntType generate_impl_4(UIntType z) const {
|
||||
|
|
@ -245,7 +290,9 @@ namespace sprout {
|
|||
template<typename... Args>
|
||||
SPROUT_CONSTEXPR mersenne_twister_engine twist_5(Args const&... args) const {
|
||||
return mersenne_twister_engine(
|
||||
sprout::array<UIntType, n>{{args..., x_[m - 1] ^ ((x_[n - 1] & upper_mask) | (x_[0] & lower_mask) >> 1) ^ ((x_[0] & 1) * a)}},
|
||||
sprout::array<UIntType, n>{{
|
||||
args..., x_[m - 1] ^ ((x_[n - 1] & upper_mask) | (x_[0] & lower_mask) >> 1) ^ ((x_[0] & 1) * a)
|
||||
}},
|
||||
0,
|
||||
private_constructor_tag()
|
||||
);
|
||||
|
|
@ -262,7 +309,9 @@ namespace sprout {
|
|||
sizeof...(Args) < n - 1,
|
||||
mersenne_twister_engine
|
||||
>::type twist_4(std::size_t i, Args const&... args) const {
|
||||
return twist_4(i + 1, args..., x_[i - (n - m)] ^ ((x_[i] & upper_mask) | (x_[i + 1] & lower_mask) >> 1) ^ ((x_[i + 1] & 1) * a));
|
||||
return twist_4(
|
||||
i + 1, args..., x_[i - (n - m)] ^ ((x_[i] & upper_mask) | (x_[i + 1] & lower_mask) >> 1) ^ ((x_[i + 1] & 1) * a)
|
||||
);
|
||||
}
|
||||
template<typename... Args>
|
||||
SPROUT_CONSTEXPR typename std::enable_if<
|
||||
|
|
@ -276,7 +325,9 @@ namespace sprout {
|
|||
sizeof...(Args) < n - 1 - unroll_extra2,
|
||||
mersenne_twister_engine
|
||||
>::type twist_3(std::size_t i, Args const&... args) const {
|
||||
return twist_3(i + 1, args..., x_[i - (n - m)] ^ ((x_[i] & upper_mask) | (x_[i + 1] & lower_mask) >> 1) ^ ((x_[i + 1] & 1) * a));
|
||||
return twist_3(
|
||||
i + 1, args..., x_[i - (n - m)] ^ ((x_[i] & upper_mask) | (x_[i + 1] & lower_mask) >> 1) ^ ((x_[i + 1] & 1) * a)
|
||||
);
|
||||
}
|
||||
template<typename... Args>
|
||||
SPROUT_CONSTEXPR typename std::enable_if<
|
||||
|
|
@ -290,7 +341,9 @@ namespace sprout {
|
|||
sizeof...(Args) < n - m,
|
||||
mersenne_twister_engine
|
||||
>::type twist_2(std::size_t i, Args const&... args) const {
|
||||
return twist_2(i + 1, args..., x_[i + m] ^ ((x_[i] & upper_mask) | (x_[i + 1] & lower_mask) >> 1) ^ ((x_[i + 1] & 1) * a));
|
||||
return twist_2(
|
||||
i + 1, args..., x_[i + m] ^ ((x_[i] & upper_mask) | (x_[i + 1] & lower_mask) >> 1) ^ ((x_[i + 1] & 1) * a)
|
||||
);
|
||||
}
|
||||
template<typename... Args>
|
||||
SPROUT_CONSTEXPR typename std::enable_if<
|
||||
|
|
@ -304,7 +357,9 @@ namespace sprout {
|
|||
sizeof...(Args) < n - m - unroll_extra1,
|
||||
mersenne_twister_engine
|
||||
>::type twist_1(std::size_t i, Args const&... args) const {
|
||||
return twist_1(i + 1, args..., x_[i + m] ^ ((x_[i] & upper_mask) | (x_[i + 1] & lower_mask) >> 1) ^ ((x_[i + 1] & 1) * a));
|
||||
return twist_1(
|
||||
i + 1, args..., x_[i + m] ^ ((x_[i] & upper_mask) | (x_[i + 1] & lower_mask) >> 1) ^ ((x_[i + 1] & 1) * a)
|
||||
);
|
||||
}
|
||||
SPROUT_CONSTEXPR mersenne_twister_engine twist() const {
|
||||
return twist_1(0);
|
||||
|
|
@ -371,34 +426,118 @@ namespace sprout {
|
|||
return lhs;
|
||||
}
|
||||
};
|
||||
template<typename UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f>
|
||||
SPROUT_CONSTEXPR_OR_CONST std::size_t sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::word_size;
|
||||
template<typename UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f>
|
||||
SPROUT_CONSTEXPR_OR_CONST std::size_t sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::state_size;
|
||||
template<typename UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f>
|
||||
SPROUT_CONSTEXPR_OR_CONST std::size_t sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::shift_size;
|
||||
template<typename UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f>
|
||||
SPROUT_CONSTEXPR_OR_CONST std::size_t sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::mask_bits;
|
||||
template<typename UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f>
|
||||
SPROUT_CONSTEXPR_OR_CONST UIntType sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::xor_mask;
|
||||
template<typename UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f>
|
||||
SPROUT_CONSTEXPR_OR_CONST std::size_t sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::tempering_u;
|
||||
template<typename UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f>
|
||||
SPROUT_CONSTEXPR_OR_CONST UIntType sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::tempering_d;
|
||||
template<typename UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f>
|
||||
SPROUT_CONSTEXPR_OR_CONST std::size_t sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::tempering_s;
|
||||
template<typename UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f>
|
||||
SPROUT_CONSTEXPR_OR_CONST UIntType sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::tempering_b;
|
||||
template<typename UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f>
|
||||
SPROUT_CONSTEXPR_OR_CONST std::size_t sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::tempering_t;
|
||||
template<typename UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f>
|
||||
SPROUT_CONSTEXPR_OR_CONST UIntType sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::tempering_c;
|
||||
template<typename UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f>
|
||||
SPROUT_CONSTEXPR_OR_CONST std::size_t sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::tempering_l;
|
||||
template<typename UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f>
|
||||
SPROUT_CONSTEXPR_OR_CONST UIntType sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::initialization_multiplier;
|
||||
template<typename UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f>
|
||||
SPROUT_CONSTEXPR_OR_CONST UIntType sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::default_seed;
|
||||
template<
|
||||
typename UIntType,
|
||||
std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d,
|
||||
std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f
|
||||
>
|
||||
SPROUT_CONSTEXPR_OR_CONST std::size_t
|
||||
sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::word_size
|
||||
;
|
||||
template<
|
||||
typename UIntType,
|
||||
std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d,
|
||||
std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f
|
||||
>
|
||||
SPROUT_CONSTEXPR_OR_CONST std::size_t
|
||||
sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::state_size
|
||||
;
|
||||
template<
|
||||
typename UIntType,
|
||||
std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d,
|
||||
std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f
|
||||
>
|
||||
SPROUT_CONSTEXPR_OR_CONST std::size_t
|
||||
sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::shift_size
|
||||
;
|
||||
template<
|
||||
typename UIntType,
|
||||
std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d,
|
||||
std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f
|
||||
>
|
||||
SPROUT_CONSTEXPR_OR_CONST std::size_t
|
||||
sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::mask_bits
|
||||
;
|
||||
template<
|
||||
typename UIntType,
|
||||
std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d,
|
||||
std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f
|
||||
>
|
||||
SPROUT_CONSTEXPR_OR_CONST UIntType
|
||||
sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::xor_mask
|
||||
;
|
||||
template<
|
||||
typename UIntType,
|
||||
std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d,
|
||||
std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f
|
||||
>
|
||||
SPROUT_CONSTEXPR_OR_CONST std::size_t
|
||||
sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::tempering_u
|
||||
;
|
||||
template<
|
||||
typename UIntType,
|
||||
std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d,
|
||||
std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f
|
||||
>
|
||||
SPROUT_CONSTEXPR_OR_CONST UIntType
|
||||
sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::tempering_d
|
||||
;
|
||||
template<
|
||||
typename UIntType,
|
||||
std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d,
|
||||
std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f
|
||||
>
|
||||
SPROUT_CONSTEXPR_OR_CONST std::size_t
|
||||
sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::tempering_s
|
||||
;
|
||||
template<
|
||||
typename UIntType,
|
||||
std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d,
|
||||
std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f
|
||||
>
|
||||
SPROUT_CONSTEXPR_OR_CONST UIntType
|
||||
sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::tempering_b
|
||||
;
|
||||
template<
|
||||
typename UIntType,
|
||||
std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d,
|
||||
std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f
|
||||
>
|
||||
SPROUT_CONSTEXPR_OR_CONST std::size_t
|
||||
sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::tempering_t
|
||||
;
|
||||
template<
|
||||
typename UIntType,
|
||||
std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d,
|
||||
std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f
|
||||
>
|
||||
SPROUT_CONSTEXPR_OR_CONST UIntType
|
||||
sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::tempering_c
|
||||
;
|
||||
template<
|
||||
typename UIntType,
|
||||
std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d,
|
||||
std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f
|
||||
>
|
||||
SPROUT_CONSTEXPR_OR_CONST std::size_t
|
||||
sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::tempering_l
|
||||
;
|
||||
template<
|
||||
typename UIntType,
|
||||
std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d,
|
||||
std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f
|
||||
>
|
||||
SPROUT_CONSTEXPR_OR_CONST UIntType
|
||||
sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::initialization_multiplier
|
||||
;
|
||||
template<
|
||||
typename UIntType,
|
||||
std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d,
|
||||
std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f
|
||||
>
|
||||
SPROUT_CONSTEXPR_OR_CONST UIntType
|
||||
sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::default_seed
|
||||
;
|
||||
|
||||
//
|
||||
// mt11213b
|
||||
|
|
|
|||
|
|
@ -107,12 +107,8 @@ namespace sprout {
|
|||
bool valid_;
|
||||
private:
|
||||
SPROUT_CONSTEXPR normal_distribution(
|
||||
RealType mean,
|
||||
RealType sigma,
|
||||
RealType r1,
|
||||
RealType r2,
|
||||
RealType cached_rho,
|
||||
bool valid,
|
||||
RealType mean, RealType sigma, RealType r1, RealType r2,
|
||||
RealType cached_rho, bool valid,
|
||||
private_constructor_tag
|
||||
)
|
||||
: mean_(mean)
|
||||
|
|
@ -123,7 +119,8 @@ namespace sprout {
|
|||
, valid_(valid)
|
||||
{}
|
||||
template<typename Engine>
|
||||
SPROUT_CONSTEXPR sprout::random::random_result<Engine, normal_distribution> generate_2(Engine const& eng, RealType r1, RealType r2, RealType cached_rho, bool valid) const {
|
||||
SPROUT_CONSTEXPR sprout::random::random_result<Engine, normal_distribution>
|
||||
generate_2(Engine const& eng, RealType r1, RealType r2, RealType cached_rho, bool valid) const {
|
||||
return sprout::random::random_result<Engine, normal_distribution>(
|
||||
cached_rho
|
||||
* (valid
|
||||
|
|
@ -144,15 +141,21 @@ namespace sprout {
|
|||
);
|
||||
}
|
||||
template<typename Engine, typename Random>
|
||||
SPROUT_CONSTEXPR sprout::random::random_result<Engine, normal_distribution> generate_1_1(RealType r1, Random const& rnd) const {
|
||||
return generate_2(rnd.engine(), r1, rnd.result(), sprout::sqrt(-result_type(2) * sprout::log(result_type(1) - rnd.result())), true);
|
||||
SPROUT_CONSTEXPR sprout::random::random_result<Engine, normal_distribution>
|
||||
generate_1_1(RealType r1, Random const& rnd) const {
|
||||
return generate_2(
|
||||
rnd.engine(), r1, rnd.result(),
|
||||
sprout::sqrt(-result_type(2) * sprout::log(result_type(1) - rnd.result())), true
|
||||
);
|
||||
}
|
||||
template<typename Engine, typename Random>
|
||||
SPROUT_CONSTEXPR sprout::random::random_result<Engine, normal_distribution> generate_1(Random const& rnd) const {
|
||||
SPROUT_CONSTEXPR sprout::random::random_result<Engine, normal_distribution>
|
||||
generate_1(Random const& rnd) const {
|
||||
return generate_1_1<Engine>(rnd.result(), rnd());
|
||||
}
|
||||
template<typename Engine>
|
||||
SPROUT_CONSTEXPR sprout::random::random_result<Engine, normal_distribution> generate(Engine const& eng) const {
|
||||
SPROUT_CONSTEXPR sprout::random::random_result<Engine, normal_distribution>
|
||||
generate(Engine const& eng) const {
|
||||
return !valid_
|
||||
? generate_1<Engine>(sprout::random::uniform_01<RealType>()(eng))
|
||||
: generate_2(eng, r1_, r2_, cached_rho_, false)
|
||||
|
|
@ -236,7 +239,11 @@ namespace sprout {
|
|||
return lhs << rhs.param() << " " << rhs.valid_ << " " << rhs.cached_rho_ << " " << rhs.r1_ << " " << rhs.r2_;
|
||||
}
|
||||
friend SPROUT_CONSTEXPR bool operator==(normal_distribution const& lhs, normal_distribution const& rhs) {
|
||||
return lhs.param() == rhs.param() && lhs.valid_ == rhs.valid_ && lhs.cached_rho_ == rhs.cached_rho_ && lhs.r1_ == rhs.r1_ && lhs.r2_ == rhs.r2_;
|
||||
return lhs.param() == rhs.param()
|
||||
&& lhs.valid_ == rhs.valid_
|
||||
&& lhs.cached_rho_ == rhs.cached_rho_
|
||||
&& lhs.r1_ == rhs.r1_ && lhs.r2_ == rhs.r2_
|
||||
;
|
||||
}
|
||||
friend SPROUT_CONSTEXPR bool operator!=(normal_distribution const& lhs, normal_distribution const& rhs) {
|
||||
return !(lhs == rhs);
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@
|
|||
#include <type_traits>
|
||||
#include <sprout/config.hpp>
|
||||
#include <sprout/iterator/next.hpp>
|
||||
#include <sprout/utility/swap.hpp>
|
||||
|
||||
namespace sprout {
|
||||
namespace random {
|
||||
|
|
@ -109,11 +110,16 @@ namespace sprout {
|
|||
SPROUT_CONSTEXPR result_type max() const {
|
||||
return distribution_.max();
|
||||
}
|
||||
void swap(random_result& other) {
|
||||
using std::swap;
|
||||
swap(result_, other.result_);
|
||||
swap(engine_, other.engine_);
|
||||
swap(distribution_, other.distribution_);
|
||||
void swap(random_result& other)
|
||||
SPROUT_NOEXCEPT_EXPR(
|
||||
SPROUT_NOEXCEPT_EXPR(sprout::swap(result_, other.result_))
|
||||
&& SPROUT_NOEXCEPT_EXPR(sprout::swap(engine_, other.engine_))
|
||||
&& SPROUT_NOEXCEPT_EXPR(sprout::swap(distribution_, other.distribution_))
|
||||
)
|
||||
{
|
||||
sprout::swap(result_, other.result_);
|
||||
sprout::swap(engine_, other.engine_);
|
||||
sprout::swap(distribution_, other.distribution_);
|
||||
}
|
||||
friend SPROUT_CONSTEXPR bool operator==(random_result const& lhs, random_result const& rhs) {
|
||||
return lhs.result_ == rhs.result_
|
||||
|
|
@ -231,10 +237,14 @@ namespace sprout {
|
|||
friend SPROUT_CONSTEXPR bool operator!=(random_result const& lhs, random_result const& rhs) {
|
||||
return !(lhs == rhs);
|
||||
}
|
||||
void swap(random_result& other) {
|
||||
using std::swap;
|
||||
swap(result_, other.result_);
|
||||
swap(engine_, other.engine_);
|
||||
void swap(random_result& other)
|
||||
SPROUT_NOEXCEPT_EXPR(
|
||||
SPROUT_NOEXCEPT_EXPR(sprout::swap(result_, other.result_))
|
||||
&& SPROUT_NOEXCEPT_EXPR(sprout::swap(engine_, other.engine_))
|
||||
)
|
||||
{
|
||||
sprout::swap(result_, other.result_);
|
||||
sprout::swap(engine_, other.engine_);
|
||||
}
|
||||
SPROUT_CONSTEXPR reference operator*() const {
|
||||
return result_;
|
||||
|
|
@ -259,10 +269,9 @@ namespace sprout {
|
|||
// swap
|
||||
//
|
||||
template<typename Engine, typename Distribution>
|
||||
void swap(
|
||||
sprout::random::random_result<Engine, Distribution>& lhs,
|
||||
sprout::random::random_result<Engine, Distribution>& rhs
|
||||
)
|
||||
inline void
|
||||
swap(sprout::random::random_result<Engine, Distribution>& lhs, sprout::random::random_result<Engine, Distribution>& rhs)
|
||||
SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(lhs.swap(rhs)))
|
||||
{
|
||||
lhs.swap(rhs);
|
||||
}
|
||||
|
|
@ -271,7 +280,7 @@ namespace sprout {
|
|||
// iterator_next
|
||||
//
|
||||
template<typename Engine, typename Distribution>
|
||||
SPROUT_CONSTEXPR sprout::random::random_result<Engine, Distribution>
|
||||
inline SPROUT_CONSTEXPR sprout::random::random_result<Engine, Distribution>
|
||||
iterator_next(sprout::random::random_result<Engine, Distribution> const& it) {
|
||||
return it();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -22,30 +22,19 @@ namespace sprout {
|
|||
};
|
||||
|
||||
template<typename Engine, typename T>
|
||||
SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine> generate_uniform_int(
|
||||
Engine const& eng,
|
||||
T min_value,
|
||||
T max_value,
|
||||
std::true_type
|
||||
SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine>
|
||||
generate_uniform_int(Engine const& eng, T min_value, T max_value, std::true_type);
|
||||
template<typename Engine, typename T, typename RangeType, typename BaseResult, typename BaseUnsigned>
|
||||
inline SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine>
|
||||
generate_uniform_int_true_3_1(
|
||||
sprout::random::random_result<Engine> const& rnd, T min_value, RangeType range,
|
||||
BaseResult bmin, BaseUnsigned brange, BaseUnsigned bucket_size
|
||||
);
|
||||
template<typename Engine, typename T, typename RangeType, typename BaseResult, typename BaseUnsigned>
|
||||
SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine> generate_uniform_int_true_3_1(
|
||||
sprout::random::random_result<Engine> const& rnd,
|
||||
T min_value,
|
||||
RangeType range,
|
||||
BaseResult bmin,
|
||||
BaseUnsigned brange,
|
||||
BaseUnsigned bucket_size
|
||||
);
|
||||
template<typename Engine, typename T, typename RangeType, typename BaseResult, typename BaseUnsigned>
|
||||
SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine> generate_uniform_int_true_3_1_1(
|
||||
Engine const& eng,
|
||||
T min_value,
|
||||
RangeType range,
|
||||
BaseResult bmin,
|
||||
BaseUnsigned brange,
|
||||
BaseUnsigned bucket_size,
|
||||
BaseUnsigned result
|
||||
inline SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine>
|
||||
generate_uniform_int_true_3_1_1(
|
||||
Engine const& eng, T min_value, RangeType range,
|
||||
BaseResult bmin, BaseUnsigned brange, BaseUnsigned bucket_size, BaseUnsigned result
|
||||
)
|
||||
{
|
||||
typedef T result_type;
|
||||
|
|
@ -55,50 +44,34 @@ namespace sprout {
|
|||
eng
|
||||
}
|
||||
: generate_uniform_int_true_3_1(
|
||||
eng(),
|
||||
min_value,
|
||||
range,
|
||||
bmin,
|
||||
brange,
|
||||
bucket_size
|
||||
eng(), min_value, range,
|
||||
bmin, brange, bucket_size
|
||||
)
|
||||
;
|
||||
}
|
||||
template<typename Engine, typename T, typename RangeType, typename BaseResult, typename BaseUnsigned>
|
||||
SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine> generate_uniform_int_true_3_1(
|
||||
sprout::random::random_result<Engine> const& rnd,
|
||||
T min_value,
|
||||
RangeType range,
|
||||
BaseResult bmin,
|
||||
BaseUnsigned brange,
|
||||
BaseUnsigned bucket_size
|
||||
inline SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine>
|
||||
generate_uniform_int_true_3_1(
|
||||
sprout::random::random_result<Engine> const& rnd, T min_value, RangeType range,
|
||||
BaseResult bmin, BaseUnsigned brange, BaseUnsigned bucket_size
|
||||
)
|
||||
{
|
||||
return sprout::random::detail::generate_uniform_int_true_3_1_1(
|
||||
rnd.engine(),
|
||||
min_value,
|
||||
range,
|
||||
bmin,
|
||||
brange,
|
||||
bucket_size,
|
||||
rnd.engine(), min_value, range,
|
||||
bmin, brange, bucket_size,
|
||||
sprout::random::detail::subtract<BaseResult>()(rnd.result(), bmin) / bucket_size
|
||||
);
|
||||
}
|
||||
template<typename Engine, typename T, typename RangeType, typename BaseResult, typename BaseUnsigned>
|
||||
SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine> generate_uniform_int_true_3(
|
||||
Engine const& eng,
|
||||
T min_value,
|
||||
RangeType range,
|
||||
BaseResult bmin,
|
||||
BaseUnsigned brange
|
||||
inline SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine>
|
||||
generate_uniform_int_true_3(
|
||||
Engine const& eng, T min_value, RangeType range,
|
||||
BaseResult bmin, BaseUnsigned brange
|
||||
)
|
||||
{
|
||||
return sprout::random::detail::generate_uniform_int_true_3_1(
|
||||
eng(),
|
||||
min_value,
|
||||
range,
|
||||
bmin,
|
||||
brange,
|
||||
eng(), min_value, range,
|
||||
bmin, brange,
|
||||
brange == std::numeric_limits<BaseUnsigned>::max()
|
||||
? brange / (static_cast<BaseUnsigned>(range) + 1) + (
|
||||
brange % (static_cast<BaseUnsigned>(range) + 1) == static_cast<BaseUnsigned>(range) ? 1 : 0
|
||||
|
|
@ -107,22 +80,16 @@ namespace sprout {
|
|||
);
|
||||
}
|
||||
template<typename Engine, typename T, typename RangeType, typename BaseResult, typename BaseUnsigned>
|
||||
SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine> generate_uniform_int_true_2(
|
||||
Engine const& eng,
|
||||
T min_value,
|
||||
RangeType range,
|
||||
BaseResult bmin,
|
||||
BaseUnsigned brange
|
||||
SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine>
|
||||
generate_uniform_int_true_2(
|
||||
Engine const& eng, T min_value, RangeType range,
|
||||
BaseResult bmin, BaseUnsigned brange
|
||||
);
|
||||
template<typename Engine, typename T, typename RangeType, typename BaseResult, typename BaseUnsigned>
|
||||
SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine> generate_uniform_int_true_2_4(
|
||||
Engine const& eng,
|
||||
T min_value,
|
||||
RangeType range,
|
||||
BaseResult bmin,
|
||||
BaseUnsigned brange,
|
||||
RangeType result,
|
||||
RangeType result_increment
|
||||
inline SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine>
|
||||
generate_uniform_int_true_2_4(
|
||||
Engine const& eng, T min_value, RangeType range,
|
||||
BaseResult bmin, BaseUnsigned brange, RangeType result, RangeType result_increment
|
||||
)
|
||||
{
|
||||
typedef T result_type;
|
||||
|
|
@ -135,74 +102,44 @@ namespace sprout {
|
|||
;
|
||||
}
|
||||
template<typename Engine, typename T, typename RangeType, typename BaseResult, typename BaseUnsigned>
|
||||
SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine> generate_uniform_int_true_2_3(
|
||||
Engine const& eng,
|
||||
T min_value,
|
||||
RangeType range,
|
||||
BaseResult bmin,
|
||||
BaseUnsigned brange,
|
||||
RangeType result,
|
||||
RangeType mult,
|
||||
RangeType result_increment
|
||||
inline SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine>
|
||||
generate_uniform_int_true_2_3(
|
||||
Engine const& eng, T min_value, RangeType range,
|
||||
BaseResult bmin, BaseUnsigned brange, RangeType result, RangeType mult, RangeType result_increment
|
||||
)
|
||||
{
|
||||
return std::numeric_limits<RangeType>::max() / mult < result_increment
|
||||
? sprout::random::detail::generate_uniform_int_true_2(eng, min_value, range, bmin, brange)
|
||||
: generate_uniform_int_true_2_4(
|
||||
eng,
|
||||
min_value,
|
||||
range,
|
||||
bmin,
|
||||
brange,
|
||||
result + (result_increment * mult),
|
||||
result_increment * mult
|
||||
eng, min_value, range,
|
||||
bmin, brange, result + (result_increment * mult), result_increment * mult
|
||||
)
|
||||
;
|
||||
}
|
||||
template<typename Engine, typename T, typename RangeType, typename BaseResult, typename BaseUnsigned, typename Result>
|
||||
SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine> generate_uniform_int_true_2_2(
|
||||
Engine const& eng,
|
||||
T min_value,
|
||||
RangeType range,
|
||||
BaseResult bmin,
|
||||
BaseUnsigned brange,
|
||||
RangeType result,
|
||||
RangeType mult,
|
||||
Result const& result_increment_base
|
||||
inline SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine>
|
||||
generate_uniform_int_true_2_2(
|
||||
Engine const& eng, T min_value, RangeType range,
|
||||
BaseResult bmin, BaseUnsigned brange, RangeType result, RangeType mult, Result const& result_increment_base
|
||||
)
|
||||
{
|
||||
return sprout::random::detail::generate_uniform_int_true_2_3(
|
||||
result_increment_base.engine,
|
||||
min_value,
|
||||
range,
|
||||
bmin,
|
||||
brange,
|
||||
result,
|
||||
mult,
|
||||
result_increment_base.result
|
||||
result_increment_base.engine, min_value, range,
|
||||
bmin, brange, result, mult, result_increment_base.result
|
||||
);
|
||||
}
|
||||
template<typename Engine, typename T, typename RangeType, typename BaseResult, typename BaseUnsigned>
|
||||
SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine> generate_uniform_int_true_2_1(
|
||||
Engine const& eng,
|
||||
T min_value,
|
||||
RangeType range,
|
||||
BaseResult bmin,
|
||||
BaseUnsigned brange,
|
||||
RangeType limit,
|
||||
RangeType result = RangeType(0),
|
||||
RangeType mult = RangeType(1)
|
||||
inline SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine>
|
||||
generate_uniform_int_true_2_1(
|
||||
Engine const& eng, T min_value, RangeType range,
|
||||
BaseResult bmin, BaseUnsigned brange, RangeType limit,
|
||||
RangeType result = RangeType(0), RangeType mult = RangeType(1)
|
||||
);
|
||||
template<typename Engine, typename T, typename RangeType, typename BaseResult, typename BaseUnsigned>
|
||||
SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine> generate_uniform_int_true_2_1_1(
|
||||
sprout::random::random_result<Engine> const& rnd,
|
||||
T min_value,
|
||||
RangeType range,
|
||||
BaseResult bmin,
|
||||
BaseUnsigned brange,
|
||||
RangeType limit,
|
||||
RangeType result,
|
||||
RangeType mult
|
||||
inline SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine>
|
||||
generate_uniform_int_true_2_1_1(
|
||||
sprout::random::random_result<Engine> const& rnd, T min_value, RangeType range,
|
||||
BaseResult bmin, BaseUnsigned brange, RangeType limit, RangeType result, RangeType mult
|
||||
)
|
||||
{
|
||||
return mult * RangeType(brange) == range - mult + 1
|
||||
|
|
@ -213,48 +150,31 @@ namespace sprout {
|
|||
rnd.engine()
|
||||
}
|
||||
: sprout::random::detail::generate_uniform_int_true_2_1(
|
||||
rnd.engine(),
|
||||
min_value,
|
||||
range,
|
||||
bmin,
|
||||
brange,
|
||||
limit,
|
||||
rnd.engine(), min_value, range,
|
||||
bmin, brange, limit,
|
||||
result + static_cast<RangeType>(sprout::random::detail::subtract<BaseResult>()(rnd.result(), bmin) * mult),
|
||||
mult * (RangeType(brange) + RangeType(1))
|
||||
)
|
||||
;
|
||||
}
|
||||
template<typename Engine, typename T, typename RangeType, typename BaseResult, typename BaseUnsigned>
|
||||
SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine> generate_uniform_int_true_2_1(
|
||||
Engine const& eng,
|
||||
T min_value,
|
||||
RangeType range,
|
||||
BaseResult bmin,
|
||||
BaseUnsigned brange,
|
||||
RangeType limit,
|
||||
RangeType result,
|
||||
RangeType mult
|
||||
inline SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine>
|
||||
generate_uniform_int_true_2_1(
|
||||
Engine const& eng, T min_value, RangeType range,
|
||||
BaseResult bmin, BaseUnsigned brange, RangeType limit,
|
||||
RangeType result, RangeType mult
|
||||
)
|
||||
{
|
||||
return mult <= limit
|
||||
? generate_uniform_int_true_2_1_1(
|
||||
eng(),
|
||||
min_value,
|
||||
range,
|
||||
bmin,
|
||||
brange,
|
||||
limit,
|
||||
result,
|
||||
mult
|
||||
eng(), min_value, range,
|
||||
bmin, brange, limit,
|
||||
result, mult
|
||||
)
|
||||
: sprout::random::detail::generate_uniform_int_true_2_2(
|
||||
eng,
|
||||
min_value,
|
||||
range,
|
||||
bmin,
|
||||
brange,
|
||||
result,
|
||||
mult,
|
||||
eng, min_value, range,
|
||||
bmin, brange,
|
||||
result, mult,
|
||||
sprout::random::detail::generate_uniform_int(
|
||||
eng,
|
||||
static_cast<RangeType>(0),
|
||||
|
|
@ -265,20 +185,15 @@ namespace sprout {
|
|||
;
|
||||
}
|
||||
template<typename Engine, typename T, typename RangeType, typename BaseResult, typename BaseUnsigned>
|
||||
SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine> generate_uniform_int_true_2(
|
||||
Engine const& eng,
|
||||
T min_value,
|
||||
RangeType range,
|
||||
BaseResult bmin,
|
||||
BaseUnsigned brange
|
||||
inline SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine>
|
||||
generate_uniform_int_true_2(
|
||||
Engine const& eng, T min_value, RangeType range,
|
||||
BaseResult bmin, BaseUnsigned brange
|
||||
)
|
||||
{
|
||||
return sprout::random::detail::generate_uniform_int_true_2_1(
|
||||
eng,
|
||||
min_value,
|
||||
range,
|
||||
bmin,
|
||||
brange,
|
||||
eng, min_value, range,
|
||||
bmin, brange,
|
||||
range == std::numeric_limits<RangeType>::max()
|
||||
? range / (RangeType(brange) + 1) + (
|
||||
range % (RangeType(brange) + 1) == RangeType(brange) ? 1 : 0
|
||||
|
|
@ -287,10 +202,9 @@ namespace sprout {
|
|||
);
|
||||
}
|
||||
template<typename Engine, typename T, typename BaseResult>
|
||||
SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine> generate_uniform_int_true_1_1(
|
||||
sprout::random::random_result<Engine> const& rnd,
|
||||
T min_value,
|
||||
BaseResult bmin
|
||||
inline SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine>
|
||||
generate_uniform_int_true_1_1(
|
||||
sprout::random::random_result<Engine> const& rnd, T min_value, BaseResult bmin
|
||||
)
|
||||
{
|
||||
typedef T result_type;
|
||||
|
|
@ -304,13 +218,10 @@ namespace sprout {
|
|||
};
|
||||
}
|
||||
template<typename Engine, typename T, typename RangeType, typename BaseResult, typename BaseUnsigned>
|
||||
SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine> generate_uniform_int_true_1(
|
||||
Engine const& eng,
|
||||
T min_value,
|
||||
T max_value,
|
||||
RangeType range,
|
||||
BaseResult bmin,
|
||||
BaseUnsigned brange
|
||||
inline SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine>
|
||||
generate_uniform_int_true_1(
|
||||
Engine const& eng, T min_value, T max_value, RangeType range,
|
||||
BaseResult bmin, BaseUnsigned brange
|
||||
)
|
||||
{
|
||||
return range == 0 ? sprout::random::detail::generate_uniform_int_result<T, Engine>{min_value, eng}
|
||||
|
|
@ -320,11 +231,9 @@ namespace sprout {
|
|||
;
|
||||
}
|
||||
template<typename Engine, typename T>
|
||||
SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine> generate_uniform_int(
|
||||
Engine const& eng,
|
||||
T min_value,
|
||||
T max_value,
|
||||
std::true_type
|
||||
inline SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine>
|
||||
generate_uniform_int(
|
||||
Engine const& eng, T min_value, T max_value, std::true_type
|
||||
)
|
||||
{
|
||||
typedef T result_type;
|
||||
|
|
@ -332,52 +241,41 @@ namespace sprout {
|
|||
typedef typename Engine::result_type base_result;
|
||||
typedef typename std::make_unsigned<base_result>::type base_unsigned;
|
||||
return sprout::random::detail::generate_uniform_int_true_1(
|
||||
eng,
|
||||
min_value,
|
||||
max_value,
|
||||
eng, min_value, max_value,
|
||||
range_type(sprout::random::detail::subtract<result_type>()(max_value, min_value)),
|
||||
base_result(eng.min()),
|
||||
base_unsigned(sprout::random::detail::subtract<base_result>()(eng.max(), eng.min()))
|
||||
);
|
||||
}
|
||||
template<typename Engine, typename T, typename Result>
|
||||
SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine> generate_uniform_int_false_1(
|
||||
Result const& rnd
|
||||
)
|
||||
{
|
||||
inline SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine>
|
||||
generate_uniform_int_false_1(Result const& rnd) {
|
||||
return sprout::random::detail::generate_uniform_int_result<T, Engine>{
|
||||
rnd.result,
|
||||
rnd.engine.base()
|
||||
rnd.result, rnd.engine.base()
|
||||
};
|
||||
}
|
||||
template<typename Engine, typename T>
|
||||
SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine> generate_uniform_int(
|
||||
Engine const& eng,
|
||||
T min_value,
|
||||
T max_value,
|
||||
std::false_type
|
||||
inline SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine>
|
||||
generate_uniform_int(
|
||||
Engine const& eng, T min_value, T max_value, std::false_type
|
||||
)
|
||||
{
|
||||
return generate_uniform_int_false_1<Engine, T>(
|
||||
sprout::random::detail::generate_uniform_int(
|
||||
sprout::random::detail::uniform_int_float<Engine>(eng),
|
||||
min_value,
|
||||
max_value,
|
||||
min_value, max_value,
|
||||
std::true_type()
|
||||
)
|
||||
);
|
||||
}
|
||||
template<typename Engine, typename T>
|
||||
SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine> generate_uniform_int(
|
||||
Engine const& eng,
|
||||
T min_value,
|
||||
T max_value
|
||||
inline SPROUT_CONSTEXPR sprout::random::detail::generate_uniform_int_result<T, Engine>
|
||||
generate_uniform_int(
|
||||
Engine const& eng, T min_value, T max_value
|
||||
)
|
||||
{
|
||||
return sprout::random::detail::generate_uniform_int(
|
||||
eng,
|
||||
min_value,
|
||||
max_value,
|
||||
eng, min_value, max_value,
|
||||
std::is_integral<typename Engine::result_type>()
|
||||
);
|
||||
}
|
||||
|
|
@ -395,8 +293,7 @@ namespace sprout {
|
|||
return min_arg <= max_arg;
|
||||
}
|
||||
static SPROUT_CONSTEXPR IntType arg_check(IntType min_arg, IntType max_arg) {
|
||||
return arg_check_nothrow(min_arg, max_arg)
|
||||
? min_arg
|
||||
return arg_check_nothrow(min_arg, max_arg) ? min_arg
|
||||
: throw std::invalid_argument("uniform_int_distribution<>: invalid argument (min_arg <= max_arg)")
|
||||
;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,7 +13,8 @@ namespace sprout {
|
|||
// make_seed
|
||||
//
|
||||
template<typename T>
|
||||
SPROUT_CONSTEXPR std::size_t make_seed(T const& v) {
|
||||
SPROUT_CONSTEXPR std::size_t
|
||||
make_seed(T const& v) {
|
||||
return sprout::to_hash(v);
|
||||
}
|
||||
|
||||
|
|
@ -22,14 +23,16 @@ namespace sprout {
|
|||
SPROUT_CONSTEXPR typename std::enable_if<
|
||||
sizeof...(Args) + 1 == N,
|
||||
sprout::array<std::size_t, N>
|
||||
>::type make_seed_seq_impl(T const& v, std::size_t seed, Args const&... args) {
|
||||
>::type
|
||||
make_seed_seq_impl(T const& v, std::size_t seed, Args const&... args) {
|
||||
return sprout::array<std::size_t, N>{{args..., seed}};
|
||||
}
|
||||
template<std::size_t N, typename T, typename... Args>
|
||||
SPROUT_CONSTEXPR typename std::enable_if<
|
||||
sizeof...(Args) + 1 != N,
|
||||
sprout::array<std::size_t, N>
|
||||
>::type make_seed_seq_impl(T const& v, std::size_t seed, Args const&... args) {
|
||||
>::type
|
||||
make_seed_seq_impl(T const& v, std::size_t seed, Args const&... args) {
|
||||
return sprout::detail::make_seed_seq_impl<N>(v, sprout::hash_combine(seed, v), args..., seed);
|
||||
}
|
||||
} // namespace detail
|
||||
|
|
@ -37,7 +40,8 @@ namespace sprout {
|
|||
// make_seed_seq
|
||||
//
|
||||
template<std::size_t N, typename T>
|
||||
SPROUT_CONSTEXPR sprout::array<std::size_t, N> make_seed_seq(T const& v) {
|
||||
SPROUT_CONSTEXPR sprout::array<std::size_t, N>
|
||||
make_seed_seq(T const& v) {
|
||||
return sprout::detail::make_seed_seq_impl<N>(v, sprout::to_hash(v));
|
||||
}
|
||||
} // namespace sprout
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue