King_DuckZ/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout synced 2024-11-12 21:09:01 +00:00
Code Issues Releases Wiki Activity

fix random generation implementation

Browse source
This commit is contained in:
bolero-MURAKAMI 2014-01-16 01:04:31 +09:00
parent 406a1ff789
commit 3879666b02
18 changed files with 140 additions and 110 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
sprout/algorithm/fixed/random_swap.hpp
View file

@ -18,6 +18,7 @@
#include <sprout/utility/pair/pair.hpp>
#include <sprout/algorithm/fixed/results.hpp>
#include <sprout/algorithm/fixed/swap_element.hpp>
#include <sprout/generator/functions.hpp>
#include <sprout/workaround/detail/uniform_int_distribution.hpp>
namespace sprout {
@ -26,14 +27,14 @@ namespace sprout {
template<typename Random>
inline SPROUT_CONSTEXPR sprout::array<std::ptrdiff_t, 2>
make_random_swap_indexes_2(Random const& rnd, std::ptrdiff_t i0) {
return sprout::array<std::ptrdiff_t, 2>{{i0, rnd.result()}};
return sprout::array<std::ptrdiff_t, 2>{{i0, sprout::generators::generated_value(rnd)}};
}
template<typename Random>
inline SPROUT_CONSTEXPR sprout::array<std::ptrdiff_t, 2>
make_random_swap_indexes_1(Random const& rnd) {
return sprout::fixed::detail::make_random_swap_indexes_2(
rnd(),
rnd.result()
sprout::generators::next_generator(rnd)(),
sprout::generators::generated_value(rnd)
);
}
template<typename UniformRandomNumberGenerator>

9
sprout/algorithm/fixed/random_swap_result.hpp
View file

@ -22,6 +22,7 @@
#include <sprout/utility/pair/access.hpp>
#include <sprout/algorithm/fixed/results.hpp>
#include <sprout/algorithm/fixed/swap_element.hpp>
#include <sprout/generator/functions.hpp>
#include <sprout/workaround/detail/uniform_int_distribution.hpp>
namespace sprout {
@ -32,16 +33,16 @@ namespace sprout {
make_random_swap_result_indexes_2(Random const& rnd, std::ptrdiff_t i0) {
typedef sprout::pair<sprout::array<std::ptrdiff_t, 2>, typename std::decay<UniformRandomNumberGenerator>::type> result_type;
return result_type(
sprout::array<std::ptrdiff_t, 2>{{i0, rnd.result()}},
rnd.engine()
sprout::array<std::ptrdiff_t, 2>{{i0, sprout::generators::generated_value(rnd)}},
sprout::generators::next_generator(rnd).engine()
);
}
template<typename UniformRandomNumberGenerator, typename Random>
inline SPROUT_CONSTEXPR sprout::pair<sprout::array<std::ptrdiff_t, 2>, typename std::decay<UniformRandomNumberGenerator>::type>
make_random_swap_result_indexes_1(Random const& rnd) {
return sprout::fixed::detail::make_random_swap_result_indexes_2<UniformRandomNumberGenerator>(
rnd(),
rnd.result()
sprout::generators::next_generator(rnd)(),
sprout::generators::generated_value(rnd)
);
}
template<typename UniformRandomNumberGenerator>

7
sprout/algorithm/fixed/shuffle.hpp
View file

@ -21,6 +21,7 @@
#include <sprout/algorithm/fixed/results.hpp>
#include <sprout/algorithm/fixed/swap_element.hpp>
#include <sprout/numeric/fixed/iota.hpp>
#include <sprout/generator/functions.hpp>
#include <sprout/workaround/detail/uniform_int_distribution.hpp>
namespace sprout {
@ -32,11 +33,11 @@ namespace sprout {
return i < n - 1
? sprout::fixed::detail::make_shuffle_indexes_1(
n,
rnd(),
sprout::fixed::swap_element(arr, arr.begin() + i, arr.begin() + rnd.result()),
sprout::generators::next_generator(rnd)(),
sprout::fixed::swap_element(arr, arr.begin() + i, arr.begin() + sprout::generators::generated_value(rnd)),
i + 1
)
: sprout::fixed::swap_element(arr, arr.begin() + i, arr.begin() + rnd.result())
: sprout::fixed::swap_element(arr, arr.begin() + i, arr.begin() + sprout::generators::generated_value(rnd))
;
}
template<std::size_t N, typename UniformRandomNumberGenerator>

9
sprout/algorithm/fixed/shuffle_result.hpp
View file

@ -24,6 +24,7 @@
#include <sprout/algorithm/fixed/results.hpp>
#include <sprout/algorithm/fixed/swap_element.hpp>
#include <sprout/numeric/fixed/iota.hpp>
#include <sprout/generator/functions.hpp>
#include <sprout/workaround/detail/uniform_int_distribution.hpp>
namespace sprout {
@ -36,13 +37,13 @@ namespace sprout {
return i < n - 1
? sprout::fixed::detail::make_shuffle_result_indexes_1<UniformRandomNumberGenerator>(
n,
rnd(),
sprout::fixed::swap_element(arr, arr.begin() + i, arr.begin() + rnd.result()),
sprout::generators::next_generator(rnd)(),
sprout::fixed::swap_element(arr, arr.begin() + i, arr.begin() + sprout::generators::generated_value(rnd)),
i + 1
)
: result_type(
sprout::fixed::swap_element(arr, arr.begin() + i, arr.begin() + rnd.result()),
rnd.engine()
sprout::fixed::swap_element(arr, arr.begin() + i, arr.begin() + sprout::generators::generated_value(rnd)),
sprout::generators::next_generator(rnd).engine()
)
;
}

9
sprout/random/additive_combine.hpp
View file

@ -15,6 +15,7 @@
#include <sprout/random/random_result.hpp>
#include <sprout/random/linear_congruential.hpp>
#include <sprout/random/type_traits.hpp>
#include <sprout/generator/functions.hpp>
#include <sprout/type_traits/enabler_if.hpp>
namespace sprout {
@ -52,12 +53,12 @@ namespace sprout {
template<typename Random1, typename Random2>
SPROUT_CONSTEXPR sprout::random::random_result<additive_combine_engine> generate(Random1 const& rnd1, Random2 const& rnd2) const {
return sprout::random::random_result<additive_combine_engine>(
rnd2.result() < rnd1.result()
? rnd1.result() - rnd2.result()
: rnd1.result() - rnd2.result() + base1_type::modulus - 1
sprout::generators::generated_value(rnd2) < sprout::generators::generated_value(rnd1)
? sprout::generators::generated_value(rnd1) - sprout::generators::generated_value(rnd2)
: sprout::generators::generated_value(rnd1) - sprout::generators::generated_value(rnd2) + base1_type::modulus - 1
,
additive_combine_engine(
rnd1.engine(), rnd2.engine(),
sprout::generators::next_generator(rnd1), sprout::generators::next_generator(rnd2),
private_construct_t()
)
);

7
sprout/random/bernoulli_distribution.hpp
View file

@ -11,6 +11,7 @@
#include <iosfwd>
#include <sprout/config.hpp>
#include <sprout/random/random_result.hpp>
#include <sprout/generator/functions.hpp>
#include <sprout/assert.hpp>
namespace sprout {
@ -82,8 +83,10 @@ namespace sprout {
) const
{
return sprout::random::random_result<Engine, bernoulli_distribution>(
RealType(rnd.result() - rnd.engine().min()) <= p_ * RealType(rnd.engine().max() - rnd.engine().min()),
rnd.engine(),
RealType(sprout::generators::generated_value(rnd) - sprout::generators::next_generator(rnd).min())
<= p_ * RealType(sprout::generators::next_generator(rnd).max() - sprout::generators::next_generator(rnd).min())
,
sprout::generators::next_generator(rnd),
*this
);
}

33
sprout/random/binomial_distribution.hpp
View file

@ -20,6 +20,7 @@
#include <sprout/math/floor.hpp>
#include <sprout/random/random_result.hpp>
#include <sprout/random/uniform_01.hpp>
#include <sprout/generator/functions.hpp>
#include <sprout/assert.hpp>
#ifdef SPROUT_WORKAROUND_NOT_TERMINATE_RECURSIVE_CONSTEXPR_FUNCTION_TEMPLATE
# include <sprout/workaround/recursive_function_template.hpp>
@ -320,7 +321,7 @@ namespace sprout {
template<typename Engine, typename Random>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, binomial_distribution>
invert_0(IntType t, RealType p, Random const& rnd) const {
return invert_1(t, p, rnd.engine(), rnd.result());
return invert_1(t, p, sprout::generators::next_generator(rnd).engine(), sprout::generators::generated_value(rnd));
}
template<typename Engine>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, binomial_distribution>
@ -330,7 +331,11 @@ namespace sprout {
template<typename Engine>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, binomial_distribution>
invert2_0(IntType t, sprout::random::random_result<Engine, binomial_distribution> const& rnd) const {
return sprout::random::random_result<Engine, binomial_distribution>(t - rnd.result(), rnd.engine(), rnd.distribution());
return sprout::random::random_result<Engine, binomial_distribution>(
t - sprout::generators::generated_value(rnd),
sprout::generators::next_generator(rnd).engine(),
sprout::generators::next_generator(rnd).distribution()
);
}
template<typename Engine>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, binomial_distribution>
@ -483,11 +488,11 @@ namespace sprout {
generate_2(Random const& rnd, RealType v) const {
return v >= btrd_.v_r
? generate_3<D + 1>(
rnd.engine(), v,
rnd.result() - RealType(0.5)
sprout::generators::next_generator(rnd).engine(), v,
sprout::generators::generated_value(rnd) - RealType(0.5)
)
: generate_3<D + 1>(
rnd.engine(), rnd.result() * btrd_.v_r,
sprout::generators::next_generator(rnd).engine(), sprout::generators::generated_value(rnd) * btrd_.v_r,
((v / btrd_.v_r - RealType(0.93)) < 0 ? RealType(-0.5) : RealType(0.5)) - (v / btrd_.v_r - RealType(0.93))
)
;
@ -526,7 +531,7 @@ namespace sprout {
template<int D, typename Engine, typename Random, SPROUT_RECURSIVE_FUNCTION_TEMPLATE_CONTINUE(D)>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, binomial_distribution>
generate_0(Random const& rnd) const {
return generate_1<D + 1>(rnd.engine(), rnd.result());
return generate_1<D + 1>(sprout::generators::next_generator(rnd).engine(), sprout::generators::generated_value(rnd));
}
template<int D, typename Engine, typename Random, SPROUT_RECURSIVE_FUNCTION_TEMPLATE_BREAK(D)>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, binomial_distribution>
@ -634,13 +639,13 @@ namespace sprout {
generate_2(Random const& rnd, RealType v) const {
return v >= btrd_.v_r
? generate_3(
rnd.engine(),
sprout::generators::next_generator(rnd).engine(),
v,
rnd.result() - RealType(0.5)
sprout::generators::generated_value(rnd) - RealType(0.5)
)
: generate_3(
rnd.engine(),
rnd.result() * btrd_.v_r,
sprout::generators::next_generator(rnd).engine(),
sprout::generators::generated_value(rnd) * btrd_.v_r,
((v / btrd_.v_r - RealType(0.93)) < 0 ? RealType(-0.5) : RealType(0.5)) - (v / btrd_.v_r - RealType(0.93))
)
;
@ -665,7 +670,7 @@ namespace sprout {
template<typename Engine, typename Random>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, binomial_distribution>
generate_0(Random const& rnd) const {
return generate_1(rnd.engine(), rnd.result());
return generate_1(sprout::generators::next_generator(rnd).engine(), sprout::generators::generated_value(rnd));
}
template<typename Engine>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, binomial_distribution>
@ -676,7 +681,11 @@ namespace sprout {
template<typename Engine>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, binomial_distribution>
generate2_0(IntType t, sprout::random::random_result<Engine, binomial_distribution> const& rnd) const {
return sprout::random::random_result<Engine, binomial_distribution>(t - rnd.result(), rnd.engine(), rnd.distribution());
return sprout::random::random_result<Engine, binomial_distribution>(
t - sprout::generators::generated_value(rnd),
sprout::generators::next_generator(rnd).engine(),
sprout::generators::next_generator(rnd).distribution()
);
}
template<typename Engine>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, binomial_distribution>

7
sprout/random/detail/uniform_int_float.hpp
View file

@ -14,13 +14,14 @@
#include <sprout/limits.hpp>
#include <sprout/random/random_result.hpp>
#include <sprout/random/detail/generator_bits.hpp>
#include <sprout/generator/functions.hpp>
#include <sprout/detail/integer.hpp>
#include HDR_ALGORITHM_MIN_MAX_SSCRISK_CEL_OR_SPROUT
namespace sprout {
namespace random {
namespace detail {
template<class URNG>
template<typename URNG>
class uniform_int_float {
public:
typedef URNG base_type;
@ -38,8 +39,8 @@ namespace sprout {
) const
{
return sprout::random::random_result<uniform_int_float>(
static_cast<result_type>(rnd.result() * (static_cast<base_result>(max()) + 1)),
uniform_int_float(rnd.engine())
static_cast<result_type>(sprout::generators::generated_value(rnd) * (static_cast<base_result>(max()) + 1)),
uniform_int_float(sprout::generators::next_generator(rnd))
);
}
public:

5
sprout/random/geometric_distribution.hpp
View file

@ -15,6 +15,7 @@
#include <sprout/math/floor.hpp>
#include <sprout/random/random_result.hpp>
#include <sprout/random/uniform_01.hpp>
#include <sprout/generator/functions.hpp>
#include <sprout/assert.hpp>
namespace sprout {
@ -90,8 +91,8 @@ namespace sprout {
template<typename Engine, typename Random>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, geometric_distribution> generate_1(Random const& rnd) const {
return sprout::random::random_result<Engine, geometric_distribution>(
static_cast<IntType>(sprout::math::floor(sprout::math::log(RealType(1) - rnd.result()) / log_1mp_)),
rnd.engine(),
static_cast<IntType>(sprout::math::floor(sprout::math::log(RealType(1) - sprout::generators::generated_value(rnd)) / log_1mp_)),
sprout::generators::next_generator(rnd).engine(),
*this
);
}

9
sprout/random/linear_congruential.hpp
View file

@ -17,6 +17,7 @@
#include <sprout/random/detail/seed_impl.hpp>
#include <sprout/random/random_result.hpp>
#include <sprout/random/type_traits.hpp>
#include <sprout/generator/functions.hpp>
#include <sprout/type_traits/enabler_if.hpp>
#include <sprout/math/greater_equal.hpp>
#include <sprout/assert.hpp>
@ -208,11 +209,11 @@ namespace sprout {
SPROUT_CONSTEXPR rand48(lcf_type const& lcf, private_construct_t)
: lcf_(lcf)
{}
template<typename LcfResult>
SPROUT_CONSTEXPR sprout::random::random_result<rand48> generate(LcfResult const& lcf_result) const {
template<typename EngineResult>
SPROUT_CONSTEXPR sprout::random::random_result<rand48> generate(EngineResult const& rnd) const {
return sprout::random::random_result<rand48>(
static_cast<result_type>(lcf_result.result()) >> 17,
rand48(lcf_result.engine(), private_construct_t())
static_cast<result_type>(sprout::generators::generated_value(rnd)) >> 17,
rand48(sprout::generators::next_generator(rnd), private_construct_t())
);
}
public:

7
sprout/random/normal_distribution.hpp
View file

@ -19,6 +19,7 @@
#include <sprout/math/sqrt.hpp>
#include <sprout/random/uniform_01.hpp>
#include <sprout/random/random_result.hpp>
#include <sprout/generator/functions.hpp>
#include <sprout/assert.hpp>
namespace sprout {
@ -140,14 +141,14 @@ namespace sprout {
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::math::log(result_type(1) - rnd.result())), true
sprout::generators::next_generator(rnd).engine(), r1, sprout::generators::generated_value(rnd),
sprout::sqrt(-result_type(2) * sprout::math::log(result_type(1) - sprout::generators::generated_value(rnd))), true
);
}
template<typename Engine, typename Random>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, normal_distribution>
generate_1(Random const& rnd) const {
return generate_1_1<Engine>(rnd.result(), rnd());
return generate_1_1<Engine>(sprout::generators::generated_value(rnd), sprout::generators::next_generator(rnd)());
}
template<typename Engine>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, normal_distribution>

41
sprout/random/shuffle_order.hpp
View file

@ -24,6 +24,7 @@
#include <sprout/random/detail/signed_unsigned_tools.hpp>
#include <sprout/random/type_traits.hpp>
#include <sprout/random/generate_array.hpp>
#include <sprout/generator/functions.hpp>
#include <sprout/type_traits/enabler_if.hpp>
#include <sprout/assert.hpp>
#include <sprout/workaround/recursive_function_template.hpp>
@ -79,53 +80,53 @@ namespace sprout {
return base_type::static_max();
}
private:
template<std::size_t M, typename Random, typename... Args, sprout::index_t... Indexes>
template<std::size_t M, typename EngineResult, typename... Args, sprout::index_t... Indexes>
static SPROUT_CONSTEXPR typename std::enable_if<
(M + sizeof...(Args) == k),
member_type
>::type init_member_4(sprout::index_tuple<Indexes...>, sprout::array<result_type, M> const& a, Random const& rnd, Args const&... args) {
>::type init_member_4(sprout::index_tuple<Indexes...>, sprout::array<result_type, M> const& a, EngineResult const& rnd, Args const&... args) {
return member_type{
rnd.engine(),
sprout::generators::next_generator(rnd),
sprout::array<result_type, k>{{a[Indexes]..., args...}},
rnd.result()
sprout::generators::generated_value(rnd)
};
}
template<std::size_t M, typename Random, typename... Args>
template<std::size_t M, typename EngineResult, typename... Args>
static SPROUT_CONSTEXPR typename std::enable_if<
(M + sizeof...(Args) == k),
member_type
>::type init_member_3(sprout::array<result_type, M> const& a, Random const& rnd, Args const&... args) {
>::type init_member_3(sprout::array<result_type, M> const& a, EngineResult const& rnd, Args const&... args) {
return init_member_4(sprout::make_index_tuple<M>::make(), a, rnd, args...);
}
template<std::size_t M, typename Random, typename... Args>
template<std::size_t M, typename EngineResult, typename... Args>
static SPROUT_CONSTEXPR typename std::enable_if<
(M + sizeof...(Args) < k),
member_type
>::type init_member_3(sprout::array<result_type, M> const& a, Random const& rnd, Args const&... args) {
return init_member_3(a, rnd(), args..., rnd.result());
>::type init_member_3(sprout::array<result_type, M> const& a, EngineResult const& rnd, Args const&... args) {
return init_member_3(a, sprout::generators::next_generator(rnd)(), args..., sprout::generators::generated_value(rnd));
}
template<typename Pair>
static SPROUT_CONSTEXPR member_type init_member_2(Pair const& p) {
return init_member_3(p.first, p.second());
}
template<typename Random, typename... Args>
template<typename EngineResult, typename... Args>
static SPROUT_CONSTEXPR typename std::enable_if<
(sizeof...(Args) == k),
member_type
>::type init_member_1(Random const& rnd, Args const&... args) {
>::type init_member_1(EngineResult const& rnd, Args const&... args) {
return member_type{
rnd.engine(),
sprout::generators::next_generator(rnd),
sprout::array<result_type, k>{{args...}},
rnd.result()
sprout::generators::generated_value(rnd)
};
}
template<typename Random, typename... Args>
template<typename EngineResult, typename... Args>
static SPROUT_CONSTEXPR typename std::enable_if<
(sizeof...(Args) < k),
member_type
>::type init_member_1(Random const& rnd, Args const&... args) {
return init_member_1(rnd(), args..., rnd.result());
>::type init_member_1(EngineResult const& rnd, Args const&... args) {
return init_member_1(sprout::generators::next_generator(rnd)(), args..., sprout::generators::generated_value(rnd));
}
static SPROUT_CONSTEXPR member_type init_member_0(base_type const& rng, std::true_type) {
return init_member_2(sprout::random::generate_array<k / 2>(rng));
@ -149,14 +150,14 @@ namespace sprout {
)
: member_type{rng, v, y}
{}
template<typename Random, typename BaseUnsigned>
template<typename EngineResult, typename BaseUnsigned>
SPROUT_CONSTEXPR sprout::random::random_result<shuffle_order_engine>
generate_1(Random const& rnd, BaseUnsigned j) const {
generate_1(EngineResult const& rnd, BaseUnsigned j) const {
return sprout::random::random_result<shuffle_order_engine>(
v_[j],
shuffle_order_engine(
rnd.engine(),
sprout::fixed::set(v_, j, rnd.result()),
sprout::generators::next_generator(rnd),
sprout::fixed::set(v_, j, sprout::generators::generated_value(rnd)),
v_[j],
private_construct_t()
)

9
sprout/random/uniform_01.hpp
View file

@ -13,6 +13,7 @@
#include <sprout/config.hpp>
#include <sprout/limits.hpp>
#include <sprout/random/random_result.hpp>
#include <sprout/generator/functions.hpp>
#ifdef SPROUT_WORKAROUND_NOT_TERMINATE_RECURSIVE_CONSTEXPR_FUNCTION_TEMPLATE
# include <sprout/workaround/recursive_function_template.hpp>
#endif
@ -65,7 +66,7 @@ namespace sprout {
generate_1(Engine const&, EngineResult const& rnd, result_type result) const {
return result < result_type(1)
? sprout::random::random_result<Engine, uniform_01>(result, rnd.engine(), *this)
: generate<D + 1>(rnd.engine(), rnd.engine()())
: generate<D + 1>(sprout::generators::next_generator(rnd), sprout::generators::next_generator(rnd)())
;
}
template<int D, typename Engine, typename EngineResult, SPROUT_RECURSIVE_FUNCTION_TEMPLATE_BREAK(D)>
@ -80,7 +81,7 @@ namespace sprout {
return generate_1<D + 1>(
eng,
rnd,
result_type(rnd.result() - eng.min()) * (
result_type(sprout::generators::generated_value(rnd) - eng.min()) * (
result_type(1) / (
result_type(eng.max() - eng.min()) + result_type(
sprout::numeric_limits<base_result>::is_integer ? 1 : 0
@ -100,7 +101,7 @@ namespace sprout {
generate_1(Engine const&, EngineResult const& rnd, result_type result) const {
return result < result_type(1)
? sprout::random::random_result<Engine, uniform_01>(result, rnd.engine(), *this)
: generate(rnd.engine(), rnd.engine()())
: generate(sprout::generators::next_generator(rnd), sprout::generators::next_generator(rnd)())
;
}
template<typename Engine, typename EngineResult>
@ -110,7 +111,7 @@ namespace sprout {
return generate_1(
eng,
rnd,
result_type(rnd.result() - eng.min()) * (
result_type(sprout::generators::generated_value(rnd) - eng.min()) * (
result_type(1) / (
result_type(eng.max() - eng.min()) + result_type(
sprout::numeric_limits<base_result>::is_integer ? 1 : 0

33
sprout/random/uniform_int_distribution.hpp
View file

@ -16,6 +16,7 @@
#include <sprout/random/detail/signed_unsigned_tools.hpp>
#include <sprout/random/detail/uniform_int_float.hpp>
#include <sprout/random/random_result.hpp>
#include <sprout/generator/functions.hpp>
#include <sprout/assert.hpp>
namespace sprout {
@ -182,9 +183,9 @@ namespace sprout {
)
{
return sprout::random::detail::generate_uniform_int_true_3_1_1<D + 1>(
rnd.engine(), min_value, range,
sprout::generators::next_generator(rnd), min_value, range,
bmin, brange, bucket_size,
sprout::random::detail::subtract<BaseResult>()(rnd.result(), bmin) / bucket_size
sprout::random::detail::subtract<BaseResult>()(sprout::generators::generated_value(rnd), bmin) / bucket_size
);
}
template<int D, typename EngineResult, typename T, typename RangeType, typename BaseResult, typename BaseUnsigned, SPROUT_RECURSIVE_FUNCTION_TEMPLATE_BREAK_DECL(D)>
@ -328,14 +329,14 @@ namespace sprout {
return mult * RangeType(brange) == range - mult + 1
? sprout::random::detail::generate_uniform_int_result<T, typename EngineResult::engine_type>{
static_cast<T>(
result + static_cast<RangeType>(sprout::random::detail::subtract<BaseResult>()(rnd.result(), bmin) * mult)
result + static_cast<RangeType>(sprout::random::detail::subtract<BaseResult>()(sprout::generators::generated_value(rnd), bmin) * mult)
),
rnd.engine()
sprout::generators::next_generator(rnd)
}
: sprout::random::detail::generate_uniform_int_true_2_1<D + 1>(
rnd.engine(), min_value, range,
sprout::generators::next_generator(rnd), min_value, range,
bmin, brange, limit,
result + static_cast<RangeType>(sprout::random::detail::subtract<BaseResult>()(rnd.result(), bmin) * mult),
result + static_cast<RangeType>(sprout::random::detail::subtract<BaseResult>()(sprout::generators::generated_value(rnd), bmin) * mult),
mult * (RangeType(brange) + RangeType(1))
)
;
@ -422,10 +423,10 @@ namespace sprout {
typedef typename std::make_unsigned<BaseResult>::type base_unsigned;
return sprout::random::detail::generate_uniform_int_result<T, typename EngineResult::engine_type>{
sprout::random::detail::add<base_unsigned, result_type>()(
base_unsigned(sprout::random::detail::subtract<BaseResult>()(rnd.result(), bmin)),
base_unsigned(sprout::random::detail::subtract<BaseResult>()(sprout::generators::generated_value(rnd), bmin)),
min_value
),
rnd.engine()
sprout::generators::next_generator(rnd)
};
}
template<int D, typename EngineResult, typename T, typename BaseResult, SPROUT_RECURSIVE_FUNCTION_TEMPLATE_BREAK(D)>
@ -556,9 +557,9 @@ namespace sprout {
)
{
return sprout::random::detail::generate_uniform_int_true_3_1_1(
rnd.engine(), min_value, range,
sprout::generators::next_generator(rnd), min_value, range,
bmin, brange, bucket_size,
sprout::random::detail::subtract<BaseResult>()(rnd.result(), bmin) / bucket_size
sprout::random::detail::subtract<BaseResult>()(sprout::generators::generated_value(rnd), bmin) / bucket_size
);
}
template<typename Engine, typename T, typename RangeType, typename BaseResult, typename BaseUnsigned>
@ -644,14 +645,14 @@ namespace sprout {
return mult * RangeType(brange) == range - mult + 1
? sprout::random::detail::generate_uniform_int_result<T, typename EngineResult::engine_type>{
static_cast<T>(
result + static_cast<RangeType>(sprout::random::detail::subtract<BaseResult>()(rnd.result(), bmin) * mult)
result + static_cast<RangeType>(sprout::random::detail::subtract<BaseResult>()(sprout::generators::generated_value(rnd), bmin) * mult)
),
rnd.engine()
sprout::generators::next_generator(rnd)
}
: sprout::random::detail::generate_uniform_int_true_2_1(
rnd.engine(), min_value, range,
sprout::generators::next_generator(rnd), min_value, range,
bmin, brange, limit,
result + static_cast<RangeType>(sprout::random::detail::subtract<BaseResult>()(rnd.result(), bmin) * mult),
result + static_cast<RangeType>(sprout::random::detail::subtract<BaseResult>()(sprout::generators::generated_value(rnd), bmin) * mult),
mult * (RangeType(brange) + RangeType(1))
)
;
@ -710,10 +711,10 @@ namespace sprout {
typedef typename std::make_unsigned<BaseResult>::type base_unsigned;
return sprout::random::detail::generate_uniform_int_result<T, typename EngineResult::engine_type>{
sprout::random::detail::add<base_unsigned, result_type>()(
base_unsigned(sprout::random::detail::subtract<BaseResult>()(rnd.result(), bmin)),
base_unsigned(sprout::random::detail::subtract<BaseResult>()(sprout::generators::generated_value(rnd), bmin)),
min_value
),
rnd.engine()
sprout::generators::next_generator(rnd)
};
}
template<typename Engine, typename T, typename RangeType, typename BaseResult, typename BaseUnsigned>

23
sprout/random/uniform_real_distribution.hpp
View file

@ -14,6 +14,7 @@
#include <sprout/config.hpp>
#include <sprout/random/detail/signed_unsigned_tools.hpp>
#include <sprout/random/random_result.hpp>
#include <sprout/generator/functions.hpp>
#include <sprout/assert.hpp>
namespace sprout {
@ -148,9 +149,10 @@ namespace sprout {
)
{
return sprout::random::detail::generate_uniform_real_false_2<D + 1>(
rnd.engine(),
sprout::generators::next_generator(rnd),
min_value, max_value,
static_cast<T>(rnd.result() - rnd.engine().min()), static_cast<T>(rnd.engine().max() - rnd.engine().min())
static_cast<T>(sprout::generators::generated_value(rnd) - sprout::generators::next_generator(rnd).min()),
static_cast<T>(sprout::generators::next_generator(rnd).max() - sprout::generators::next_generator(rnd).min())
);
}
template<int D, typename EngineResult, typename T, SPROUT_RECURSIVE_FUNCTION_TEMPLATE_BREAK_DECL(D)>
@ -232,10 +234,10 @@ namespace sprout {
{
typedef typename EngineResult::result_type base_result;
return sprout::random::detail::generate_uniform_real_true_2<D + 1>(
rnd.engine(),
sprout::generators::next_generator(rnd),
min_value, max_value,
static_cast<T>(sprout::random::detail::subtract<base_result>()(rnd.result(), rnd.engine().min())),
static_cast<T>(sprout::random::detail::subtract<base_result>()(rnd.engine().max(), rnd.engine().min())) + 1
static_cast<T>(sprout::random::detail::subtract<base_result>()(sprout::generators::generated_value(rnd), sprout::generators::next_generator(rnd).min())),
static_cast<T>(sprout::random::detail::subtract<base_result>()(sprout::generators::next_generator(rnd).max(), sprout::generators::next_generator(rnd).min())) + 1
);
}
template<int D, typename EngineResult, typename T, SPROUT_RECURSIVE_FUNCTION_TEMPLATE_BREAK_DECL(D)>
@ -291,9 +293,10 @@ namespace sprout {
)
{
return sprout::random::detail::generate_uniform_real_false_2(
rnd.engine(),
sprout::generators::next_generator(rnd),
min_value, max_value,
static_cast<T>(rnd.result() - rnd.engine().min()), static_cast<T>(rnd.engine().max() - rnd.engine().min())
static_cast<T>(sprout::generators::generated_value(rnd) - sprout::generators::next_generator(rnd).min()),
static_cast<T>(sprout::generators::next_generator(rnd).max() - sprout::generators::next_generator(rnd).min())
);
}
template<typename EngineResult, typename T>
@ -340,10 +343,10 @@ namespace sprout {
{
typedef typename EngineResult::result_type base_result;
return sprout::random::detail::generate_uniform_real_true_2(
rnd.engine(),
sprout::generators::next_generator(rnd),
min_value, max_value,
static_cast<T>(sprout::random::detail::subtract<base_result>()(rnd.result(), rnd.engine().min())),
static_cast<T>(sprout::random::detail::subtract<base_result>()(rnd.engine().max(), rnd.engine().min())) + 1
static_cast<T>(sprout::random::detail::subtract<base_result>()(sprout::generators::generated_value(rnd), sprout::generators::next_generator(rnd).min())),
static_cast<T>(sprout::random::detail::subtract<base_result>()(sprout::generators::next_generator(rnd).max(), sprout::generators::next_generator(rnd).min())) + 1
);
}
#endif

21
sprout/random/uniform_smallint.hpp
View file

@ -16,6 +16,7 @@
#include <sprout/random/detail/signed_unsigned_tools.hpp>
#include <sprout/random/random_result.hpp>
#include <sprout/random/uniform_01.hpp>
#include <sprout/generator/functions.hpp>
#include <sprout/assert.hpp>
namespace sprout {
@ -135,12 +136,12 @@ namespace sprout {
return range >= base_range
? sprout::random::random_result<Engine, uniform_smallint>(
sprout::random::detail::add<RangeType, result_type>()(static_cast<RangeType>(val), min_),
rnd.engine(),
sprout::generators::next_generator(rnd),
*this
)
: sprout::random::random_result<Engine, uniform_smallint>(
sprout::random::detail::add<RangeType, result_type>()(static_cast<RangeType>(val % (static_cast<BaseUnsigned>(range) + 1)), min_),
rnd.engine(),
sprout::generators::next_generator(rnd),
*this
)
;
@ -159,7 +160,7 @@ namespace sprout {
rnd,
range,
base_range,
BaseUnsigned(sprout::random::detail::subtract<base_result>()(rnd.result(), eng.min()))
BaseUnsigned(sprout::random::detail::subtract<base_result>()(sprout::generators::generated_value(rnd), eng.min()))
);
}
template<typename Engine>
@ -178,10 +179,10 @@ namespace sprout {
base_unsigned(sprout::random::detail::subtract<result_type>()(eng.max(), eng.min()))
);
}
template<typename Engine, typename RangeType>
template<typename Engine, typename Random, typename RangeType>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, uniform_smallint> generate_false_2(
Engine const&,
sprout::random::random_result<Engine, sprout::random::uniform_01<typename Engine::result_type> > const& rnd,
Random const& rnd,
RangeType range,
RangeType offset
) const
@ -189,20 +190,20 @@ namespace sprout {
return offset > range
? sprout::random::random_result<Engine, uniform_smallint>(
max_,
rnd.engine(),
sprout::generators::next_generator(rnd).engine(),
*this
)
: sprout::random::random_result<Engine, uniform_smallint>(
sprout::random::detail::add<RangeType, result_type>()(offset, min_),
rnd.engine(),
sprout::generators::next_generator(rnd).engine(),
*this
)
;
}
template<typename Engine, typename RangeType>
template<typename Engine, typename Random, typename RangeType>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, uniform_smallint> generate_false_1(
Engine const& eng,
sprout::random::random_result<Engine, sprout::random::uniform_01<typename Engine::result_type> > const& rnd,
Random const& rnd,
RangeType range
) const
{
@ -211,7 +212,7 @@ namespace sprout {
eng,
rnd,
static_cast<RangeType>(sprout::random::detail::subtract<result_type>()(max_, min_)),
static_cast<RangeType>(rnd.result() * (static_cast<base_result>(range) + 1))
static_cast<RangeType>(sprout::generators::generated_value(rnd) * (static_cast<base_result>(range) + 1))
);
}
template<class Engine>

9
sprout/random/xor_combine.hpp
View file

@ -13,6 +13,7 @@
#include <sprout/config.hpp>
#include <sprout/random/random_result.hpp>
#include <sprout/random/type_traits.hpp>
#include <sprout/generator/functions.hpp>
#include <sprout/type_traits/enabler_if.hpp>
#include HDR_ALGORITHM_MIN_MAX_SSCRISK_CEL_OR_SPROUT
@ -43,12 +44,12 @@ namespace sprout {
base1_type rng1_;
base2_type rng2_;
private:
template<typename Random1, typename Random2>
SPROUT_CONSTEXPR sprout::random::random_result<xor_combine_engine> generate(Random1 const& rnd1, Random2 const& rnd2) const {
template<typename EngineResult1, typename EngineResult2>
SPROUT_CONSTEXPR sprout::random::random_result<xor_combine_engine> generate(EngineResult1 const& rnd1, EngineResult2 const& rnd2) const {
return sprout::random::random_result<xor_combine_engine>(
(rnd1.result() << s1) ^ (rnd2.result() << s2),
(sprout::generators::generated_value(rnd1) << s1) ^ (sprout::generators::generated_value(rnd2) << s2),
xor_combine_engine(
rnd1.engine(), rnd2.engine()
sprout::generators::next_generator(rnd1), sprout::generators::next_generator(rnd2)
)
);
}

5
sprout/uuid/random_generator.hpp
View file

@ -16,6 +16,7 @@
#include <sprout/random/default_random_engine.hpp>
#include <sprout/random/uniform_int_distribution.hpp>
#include <sprout/random/variate_generator.hpp>
#include <sprout/generator/functions.hpp>
namespace sprout {
namespace uuids {
@ -58,14 +59,14 @@ namespace sprout {
sizeof...(Args) == 3,
result_type
>::type random_to_uuid(Random const& rnd, Args... args) const {
return random_to_uuid_1(args..., rnd.result());
return random_to_uuid_1(args..., sprout::generators::generated_value(rnd));
}
template<typename Random, typename... Args>
SPROUT_CONSTEXPR typename std::enable_if<
sizeof...(Args) != 3,
result_type
>::type random_to_uuid(Random const& rnd, Args... args) const {
return random_to_uuid(rnd(), args..., rnd.result());
return random_to_uuid(sprout::generators::next_generator(rnd)(), args..., sprout::generators::generated_value(rnd));
}
public:
SPROUT_CONSTEXPR basic_random_generator()