mirror/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout.git synced 2025-05-10 09:23:30 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

add random::result, random::next

Browse source
This commit is contained in:
bolero-MURAKAMI 2014-01-16 18:59:25 +09:00
parent 3879666b02
commit 769e18178a
23 changed files with 191 additions and 136 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -18,7 +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/random/result.hpp>
#include <sprout/workaround/detail/uniform_int_distribution.hpp>
namespace sprout {
@ -27,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, sprout::generators::generated_value(rnd)}};
return sprout::array<std::ptrdiff_t, 2>{{i0, sprout::random::result(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(
sprout::generators::next_generator(rnd)(),
sprout::generators::generated_value(rnd)
sprout::random::next(rnd)(),
sprout::random::result(rnd)
);
}
template<typename UniformRandomNumberGenerator>

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

@ -22,7 +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/random/result.hpp>
#include <sprout/workaround/detail/uniform_int_distribution.hpp>
namespace sprout {
@ -33,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, sprout::generators::generated_value(rnd)}},
sprout::generators::next_generator(rnd).engine()
sprout::array<std::ptrdiff_t, 2>{{i0, sprout::random::result(rnd)}},
sprout::random::next(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>(
sprout::generators::next_generator(rnd)(),
sprout::generators::generated_value(rnd)
sprout::random::next(rnd)(),
sprout::random::result(rnd)
);
}
template<typename UniformRandomNumberGenerator>

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

@ -21,7 +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/random/result.hpp>
#include <sprout/workaround/detail/uniform_int_distribution.hpp>
namespace sprout {
@ -33,11 +33,11 @@ namespace sprout {
return i < n - 1
? sprout::fixed::detail::make_shuffle_indexes_1(
n,
sprout::generators::next_generator(rnd)(),
sprout::fixed::swap_element(arr, arr.begin() + i, arr.begin() + sprout::generators::generated_value(rnd)),
sprout::random::next(rnd)(),
sprout::fixed::swap_element(arr, arr.begin() + i, arr.begin() + sprout::random::result(rnd)),
i + 1
)
: sprout::fixed::swap_element(arr, arr.begin() + i, arr.begin() + sprout::generators::generated_value(rnd))
: sprout::fixed::swap_element(arr, arr.begin() + i, arr.begin() + sprout::random::result(rnd))
;
}
template<std::size_t N, typename UniformRandomNumberGenerator>

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

@ -24,7 +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/random/result.hpp>
#include <sprout/workaround/detail/uniform_int_distribution.hpp>
namespace sprout {
@ -37,13 +37,13 @@ namespace sprout {
return i < n - 1
? sprout::fixed::detail::make_shuffle_result_indexes_1<UniformRandomNumberGenerator>(
n,
sprout::generators::next_generator(rnd)(),
sprout::fixed::swap_element(arr, arr.begin() + i, arr.begin() + sprout::generators::generated_value(rnd)),
sprout::random::next(rnd)(),
sprout::fixed::swap_element(arr, arr.begin() + i, arr.begin() + sprout::random::result(rnd)),
i + 1
)
: result_type(
sprout::fixed::swap_element(arr, arr.begin() + i, arr.begin() + sprout::generators::generated_value(rnd)),
sprout::generators::next_generator(rnd).engine()
sprout::fixed::swap_element(arr, arr.begin() + i, arr.begin() + sprout::random::result(rnd)),
sprout::random::next(rnd).engine()
)
;
}

10
sprout/random/additive_combine.hpp
View file

@ -15,7 +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/random/result.hpp>
#include <sprout/type_traits/enabler_if.hpp>
namespace sprout {
@ -53,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>(
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
sprout::random::result(rnd2) < sprout::random::result(rnd1)
? sprout::random::result(rnd1) - sprout::random::result(rnd2)
: sprout::random::result(rnd1) - sprout::random::result(rnd2) + base1_type::modulus - 1
,
additive_combine_engine(
sprout::generators::next_generator(rnd1), sprout::generators::next_generator(rnd2),
sprout::random::next(rnd1), sprout::random::next(rnd2),
private_construct_t()
)
);

8
sprout/random/bernoulli_distribution.hpp
View file

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

34
sprout/random/binomial_distribution.hpp
View file

@ -20,7 +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/random/result.hpp>
#include <sprout/assert.hpp>
#ifdef SPROUT_WORKAROUND_NOT_TERMINATE_RECURSIVE_CONSTEXPR_FUNCTION_TEMPLATE
# include <sprout/workaround/recursive_function_template.hpp>
@ -321,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, sprout::generators::next_generator(rnd).engine(), sprout::generators::generated_value(rnd));
return invert_1(t, p, sprout::random::next(rnd).engine(), sprout::random::result(rnd));
}
template<typename Engine>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, binomial_distribution>
@ -332,9 +332,9 @@ namespace sprout {
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 - sprout::generators::generated_value(rnd),
sprout::generators::next_generator(rnd).engine(),
sprout::generators::next_generator(rnd).distribution()
t - sprout::random::result(rnd),
sprout::random::next(rnd).engine(),
sprout::random::next(rnd).distribution()
);
}
template<typename Engine>
@ -488,11 +488,11 @@ namespace sprout {
generate_2(Random const& rnd, RealType v) const {
return v >= btrd_.v_r
? generate_3<D + 1>(
sprout::generators::next_generator(rnd).engine(), v,
sprout::generators::generated_value(rnd) - RealType(0.5)
sprout::random::next(rnd).engine(), v,
sprout::random::result(rnd) - RealType(0.5)
)
: generate_3<D + 1>(
sprout::generators::next_generator(rnd).engine(), sprout::generators::generated_value(rnd) * btrd_.v_r,
sprout::random::next(rnd).engine(), sprout::random::result(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))
)
;
@ -531,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>(sprout::generators::next_generator(rnd).engine(), sprout::generators::generated_value(rnd));
return generate_1<D + 1>(sprout::random::next(rnd).engine(), sprout::random::result(rnd));
}
template<int D, typename Engine, typename Random, SPROUT_RECURSIVE_FUNCTION_TEMPLATE_BREAK(D)>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, binomial_distribution>
@ -639,13 +639,13 @@ namespace sprout {
generate_2(Random const& rnd, RealType v) const {
return v >= btrd_.v_r
? generate_3(
sprout::generators::next_generator(rnd).engine(),
sprout::random::next(rnd).engine(),
v,
sprout::generators::generated_value(rnd) - RealType(0.5)
sprout::random::result(rnd) - RealType(0.5)
)
: generate_3(
sprout::generators::next_generator(rnd).engine(),
sprout::generators::generated_value(rnd) * btrd_.v_r,
sprout::random::next(rnd).engine(),
sprout::random::result(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))
)
;
@ -670,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(sprout::generators::next_generator(rnd).engine(), sprout::generators::generated_value(rnd));
return generate_1(sprout::random::next(rnd).engine(), sprout::random::result(rnd));
}
template<typename Engine>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, binomial_distribution>
@ -682,9 +682,9 @@ namespace sprout {
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 - sprout::generators::generated_value(rnd),
sprout::generators::next_generator(rnd).engine(),
sprout::generators::next_generator(rnd).distribution()
t - sprout::random::result(rnd),
sprout::random::next(rnd).engine(),
sprout::random::next(rnd).distribution()
);
}
template<typename Engine>

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

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

10
sprout/random/generate_array.hpp
View file

@ -12,7 +12,7 @@
#include <sprout/config.hpp>
#include <sprout/array/array.hpp>
#include <sprout/utility/pair/pair.hpp>
#include <sprout/generator/functions.hpp>
#include <sprout/random/result.hpp>
#include <sprout/generator/results.hpp>
namespace sprout {
@ -44,8 +44,8 @@ namespace sprout {
typename sprout::generators::results::next_generator<RandomNumberGenerator const>::type
> const pair_type;
return pair_type{
sprout::array<typename RandomNumberGenerator::result_type, N>{{args..., sprout::generators::generated_value(rnd)}},
sprout::generators::next_generator(rnd)
sprout::array<typename RandomNumberGenerator::result_type, N>{{args..., sprout::random::result(rnd)}},
sprout::random::next(rnd)
};
}
template<std::size_t N, typename RandomNumberGenerator, typename Random, typename... Args>
@ -57,8 +57,8 @@ namespace sprout {
> const
>::type generate_array_impl(Random const& rnd, Args const&... args) {
return sprout::random::detail::generate_array_impl<N, RandomNumberGenerator>(
sprout::generators::next_generator(rnd)(),
args..., sprout::generators::generated_value(rnd)
sprout::random::next(rnd)(),
args..., sprout::random::result(rnd)
);
}
} // namespace detail

34
sprout/random/generate_canonical.hpp
View file

@ -18,7 +18,7 @@
#include <sprout/random/detail/const_mod.hpp>
#include <sprout/random/detail/signed_unsigned_tools.hpp>
#include <sprout/random/detail/generator_bits.hpp>
#include <sprout/generator/functions.hpp>
#include <sprout/random/result.hpp>
#include <sprout/utility/pair/pair.hpp>
#include HDR_ALGORITHM_MIN_MAX_SSCRISK_CEL_OR_SPROUT
@ -92,8 +92,8 @@ namespace sprout {
r, limit,
s + RealType(
sprout::random::detail::subtract<base_result>()(
sprout::generators::generated_value(rnd),
sprout::generators::next_generator(rnd).min()
sprout::random::result(rnd),
sprout::random::next(rnd).min()
)
) * mult,
mult * r,
@ -102,11 +102,11 @@ namespace sprout {
: pair_type(
(s + RealType(
sprout::random::detail::subtract<base_result>()(
sprout::generators::generated_value(rnd),
sprout::generators::next_generator(rnd).min()
sprout::random::result(rnd),
sprout::random::next(rnd).min()
)
) * mult) / (mult * r),
sprout::generators::next_generator(rnd)
sprout::random::next(rnd)
)
;
}
@ -119,8 +119,8 @@ namespace sprout {
r, limit,
RealType(
sprout::random::detail::subtract<base_result>()(
sprout::generators::generated_value(rnd),
sprout::generators::next_generator(rnd).min()
sprout::random::result(rnd),
sprout::random::next(rnd).min()
)
),
r,
@ -129,11 +129,11 @@ namespace sprout {
: pair_type(
RealType(
sprout::random::detail::subtract<base_result>()(
sprout::generators::generated_value(rnd),
sprout::generators::next_generator(rnd).min()
sprout::random::result(rnd),
sprout::random::next(rnd).min()
)
) / r,
sprout::generators::next_generator(rnd)
sprout::random::next(rnd)
)
;
}
@ -157,16 +157,16 @@ namespace sprout {
return mult * r < limit ? sprout::random::detail::generate_canonical_impl_0_1<RealType, bits, URNG>(
r, limit,
s + sprout::math::floor(
(RealType(sprout::generators::generated_value(rnd)) - RealType(sprout::generators::next_generator(rnd).min())) * r
(RealType(sprout::random::result(rnd)) - RealType(sprout::random::next(rnd).min())) * r
) * mult,
mult * r,
rnd()
)
: pair_type(
(s + sprout::math::floor(
(RealType(sprout::generators::generated_value(rnd)) - RealType(sprout::generators::next_generator(rnd).min())) * r
(RealType(sprout::random::result(rnd)) - RealType(sprout::random::next(rnd).min())) * r
) * mult) / (mult * r),
sprout::generators::next_generator(rnd)
sprout::random::next(rnd)
)
;
}
@ -176,13 +176,13 @@ namespace sprout {
typedef sprout::pair<RealType, URNG> const pair_type;
return r < limit ? sprout::random::detail::generate_canonical_impl_0_1<RealType, bits, URNG>(
r, limit,
RealType(sprout::generators::generated_value(rnd) - sprout::generators::next_generator(rnd).min()),
RealType(sprout::random::result(rnd) - sprout::random::next(rnd).min()),
r,
rnd()
)
: pair_type(
RealType(sprout::generators::generated_value(rnd) - sprout::generators::next_generator(rnd).min()) / r,
sprout::generators::next_generator(rnd)
RealType(sprout::random::result(rnd) - sprout::random::next(rnd).min()) / r,
sprout::random::next(rnd)
)
;
}

6
sprout/random/geometric_distribution.hpp
View file

@ -15,7 +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/random/result.hpp>
#include <sprout/assert.hpp>
namespace sprout {
@ -91,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) - sprout::generators::generated_value(rnd)) / log_1mp_)),
sprout::generators::next_generator(rnd).engine(),
static_cast<IntType>(sprout::math::floor(sprout::math::log(RealType(1) - sprout::random::result(rnd)) / log_1mp_)),
sprout::random::next(rnd).engine(),
*this
);
}

6
sprout/random/linear_congruential.hpp
View file

@ -17,7 +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/random/result.hpp>
#include <sprout/type_traits/enabler_if.hpp>
#include <sprout/math/greater_equal.hpp>
#include <sprout/assert.hpp>
@ -212,8 +212,8 @@ namespace sprout {
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>(sprout::generators::generated_value(rnd)) >> 17,
rand48(sprout::generators::next_generator(rnd), private_construct_t())
static_cast<result_type>(sprout::random::result(rnd)) >> 17,
rand48(sprout::random::next(rnd), private_construct_t())
);
}
public:

8
sprout/random/normal_distribution.hpp
View file

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

12
sprout/random/random_result.hpp
View file

@ -98,6 +98,12 @@ namespace sprout {
SPROUT_CONSTEXPR result_type const& result() const SPROUT_NOEXCEPT {
return result_;
}
SPROUT_CXX14_CONSTEXPR generator_type& next() SPROUT_NOEXCEPT {
return generator_;
}
SPROUT_CONSTEXPR generator_type const& next() const SPROUT_NOEXCEPT {
return generator_;
}
SPROUT_CXX14_CONSTEXPR engine_type& engine() SPROUT_NOEXCEPT {
return generator_.engine();
}
@ -225,6 +231,12 @@ namespace sprout {
SPROUT_CONSTEXPR result_type const& result() const SPROUT_NOEXCEPT {
return result_;
}
SPROUT_CXX14_CONSTEXPR generator_type& next() SPROUT_NOEXCEPT {
return generator_;
}
SPROUT_CONSTEXPR generator_type const& next() const SPROUT_NOEXCEPT {
return generator_;
}
SPROUT_CXX14_CONSTEXPR engine_type& engine() SPROUT_NOEXCEPT {
return generator_;
}

42
sprout/random/result.hpp Normal file
View file

@ -0,0 +1,42 @@
/*=============================================================================
Copyright (c) 2011-2014 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
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 SPROUT_RANDOM_RESULT_HPP
#define SPROUT_RANDOM_RESULT_HPP
#include <utility>
#include <sprout/config.hpp>
#include <sprout/generator/functions.hpp>
#include <sprout/utility/forward.hpp>
namespace sprout {
namespace random {
//
// result
//
template<typename T>
inline SPROUT_CONSTEXPR decltype(sprout::generators::generated_value(std::declval<T>()))
result(T&& t)
SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(sprout::generators::generated_value(std::declval<T>())))
{
return sprout::generators::generated_value(sprout::forward<T>(t));
}
//
// next
//
template<typename T>
inline SPROUT_CONSTEXPR decltype(sprout::generators::next_generator(std::declval<T>()))
next(T&& t)
SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(sprout::generators::next_generator(std::declval<T>())))
{
return sprout::generators::next_generator(sprout::forward<T>(t));
}
} // namespace random
} // namespace sprout
#endif // #ifndef SPROUT_RANDOM_RESULT_HPP

18
sprout/random/shuffle_order.hpp
View file

@ -24,7 +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/random/result.hpp>
#include <sprout/type_traits/enabler_if.hpp>
#include <sprout/assert.hpp>
#include <sprout/workaround/recursive_function_template.hpp>
@ -86,9 +86,9 @@ namespace sprout {
member_type
>::type init_member_4(sprout::index_tuple<Indexes...>, sprout::array<result_type, M> const& a, EngineResult const& rnd, Args const&... args) {
return member_type{
sprout::generators::next_generator(rnd),
sprout::random::next(rnd),
sprout::array<result_type, k>{{a[Indexes]..., args...}},
sprout::generators::generated_value(rnd)
sprout::random::result(rnd)
};
}
template<std::size_t M, typename EngineResult, typename... Args>
@ -103,7 +103,7 @@ namespace sprout {
(M + sizeof...(Args) < k),
member_type
>::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));
return init_member_3(a, sprout::random::next(rnd)(), args..., sprout::random::result(rnd));
}
template<typename Pair>
static SPROUT_CONSTEXPR member_type init_member_2(Pair const& p) {
@ -116,9 +116,9 @@ namespace sprout {
member_type
>::type init_member_1(EngineResult const& rnd, Args const&... args) {
return member_type{
sprout::generators::next_generator(rnd),
sprout::random::next(rnd),
sprout::array<result_type, k>{{args...}},
sprout::generators::generated_value(rnd)
sprout::random::result(rnd)
};
}
template<typename EngineResult, typename... Args>
@ -126,7 +126,7 @@ namespace sprout {
(sizeof...(Args) < k),
member_type
>::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));
return init_member_1(sprout::random::next(rnd)(), args..., sprout::random::result(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));
@ -156,8 +156,8 @@ namespace sprout {
return sprout::random::random_result<shuffle_order_engine>(
v_[j],
shuffle_order_engine(
sprout::generators::next_generator(rnd),
sprout::fixed::set(v_, j, sprout::generators::generated_value(rnd)),
sprout::random::next(rnd),
sprout::fixed::set(v_, j, sprout::random::result(rnd)),
v_[j],
private_construct_t()
)

10
sprout/random/uniform_01.hpp
View file

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

34
sprout/random/uniform_int_distribution.hpp
View file

@ -16,7 +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/random/result.hpp>
#include <sprout/assert.hpp>
namespace sprout {
@ -183,9 +183,9 @@ namespace sprout {
)
{
return sprout::random::detail::generate_uniform_int_true_3_1_1<D + 1>(
sprout::generators::next_generator(rnd), min_value, range,
sprout::random::next(rnd), min_value, range,
bmin, brange, bucket_size,
sprout::random::detail::subtract<BaseResult>()(sprout::generators::generated_value(rnd), bmin) / bucket_size
sprout::random::detail::subtract<BaseResult>()(sprout::random::result(rnd), bmin) / bucket_size
);
}
template<int D, typename EngineResult, typename T, typename RangeType, typename BaseResult, typename BaseUnsigned, SPROUT_RECURSIVE_FUNCTION_TEMPLATE_BREAK_DECL(D)>
@ -329,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>()(sprout::generators::generated_value(rnd), bmin) * mult)
result + static_cast<RangeType>(sprout::random::detail::subtract<BaseResult>()(sprout::random::result(rnd), bmin) * mult)
),
sprout::generators::next_generator(rnd)
sprout::random::next(rnd)
}
: sprout::random::detail::generate_uniform_int_true_2_1<D + 1>(
sprout::generators::next_generator(rnd), min_value, range,
sprout::random::next(rnd), min_value, range,
bmin, brange, limit,
result + static_cast<RangeType>(sprout::random::detail::subtract<BaseResult>()(sprout::generators::generated_value(rnd), bmin) * mult),
result + static_cast<RangeType>(sprout::random::detail::subtract<BaseResult>()(sprout::random::result(rnd), bmin) * mult),
mult * (RangeType(brange) + RangeType(1))
)
;
@ -423,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>()(sprout::generators::generated_value(rnd), bmin)),
base_unsigned(sprout::random::detail::subtract<BaseResult>()(sprout::random::result(rnd), bmin)),
min_value
),
sprout::generators::next_generator(rnd)
sprout::random::next(rnd)
};
}
template<int D, typename EngineResult, typename T, typename BaseResult, SPROUT_RECURSIVE_FUNCTION_TEMPLATE_BREAK(D)>
@ -557,9 +557,9 @@ namespace sprout {
)
{
return sprout::random::detail::generate_uniform_int_true_3_1_1(
sprout::generators::next_generator(rnd), min_value, range,
sprout::random::next(rnd), min_value, range,
bmin, brange, bucket_size,
sprout::random::detail::subtract<BaseResult>()(sprout::generators::generated_value(rnd), bmin) / bucket_size
sprout::random::detail::subtract<BaseResult>()(sprout::random::result(rnd), bmin) / bucket_size
);
}
template<typename Engine, typename T, typename RangeType, typename BaseResult, typename BaseUnsigned>
@ -645,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>()(sprout::generators::generated_value(rnd), bmin) * mult)
result + static_cast<RangeType>(sprout::random::detail::subtract<BaseResult>()(sprout::random::result(rnd), bmin) * mult)
),
sprout::generators::next_generator(rnd)
sprout::random::next(rnd)
}
: sprout::random::detail::generate_uniform_int_true_2_1(
sprout::generators::next_generator(rnd), min_value, range,
sprout::random::next(rnd), min_value, range,
bmin, brange, limit,
result + static_cast<RangeType>(sprout::random::detail::subtract<BaseResult>()(sprout::generators::generated_value(rnd), bmin) * mult),
result + static_cast<RangeType>(sprout::random::detail::subtract<BaseResult>()(sprout::random::result(rnd), bmin) * mult),
mult * (RangeType(brange) + RangeType(1))
)
;
@ -711,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>()(sprout::generators::generated_value(rnd), bmin)),
base_unsigned(sprout::random::detail::subtract<BaseResult>()(sprout::random::result(rnd), bmin)),
min_value
),
sprout::generators::next_generator(rnd)
sprout::random::next(rnd)
};
}
template<typename Engine, typename T, typename RangeType, typename BaseResult, typename BaseUnsigned>

26
sprout/random/uniform_real_distribution.hpp
View file

@ -14,7 +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/random/result.hpp>
#include <sprout/assert.hpp>
namespace sprout {
@ -149,10 +149,10 @@ namespace sprout {
)
{
return sprout::random::detail::generate_uniform_real_false_2<D + 1>(
sprout::generators::next_generator(rnd),
sprout::random::next(rnd),
min_value, max_value,
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())
static_cast<T>(sprout::random::result(rnd) - sprout::random::next(rnd).min()),
static_cast<T>(sprout::random::next(rnd).max() - sprout::random::next(rnd).min())
);
}
template<int D, typename EngineResult, typename T, SPROUT_RECURSIVE_FUNCTION_TEMPLATE_BREAK_DECL(D)>
@ -234,10 +234,10 @@ namespace sprout {
{
typedef typename EngineResult::result_type base_result;
return sprout::random::detail::generate_uniform_real_true_2<D + 1>(
sprout::generators::next_generator(rnd),
sprout::random::next(rnd),
min_value, max_value,
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
static_cast<T>(sprout::random::detail::subtract<base_result>()(sprout::random::result(rnd), sprout::random::next(rnd).min())),
static_cast<T>(sprout::random::detail::subtract<base_result>()(sprout::random::next(rnd).max(), sprout::random::next(rnd).min())) + 1
);
}
template<int D, typename EngineResult, typename T, SPROUT_RECURSIVE_FUNCTION_TEMPLATE_BREAK_DECL(D)>
@ -293,10 +293,10 @@ namespace sprout {
)
{
return sprout::random::detail::generate_uniform_real_false_2(
sprout::generators::next_generator(rnd),
sprout::random::next(rnd),
min_value, max_value,
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())
static_cast<T>(sprout::random::result(rnd) - sprout::random::next(rnd).min()),
static_cast<T>(sprout::random::next(rnd).max() - sprout::random::next(rnd).min())
);
}
template<typename EngineResult, typename T>
@ -343,10 +343,10 @@ namespace sprout {
{
typedef typename EngineResult::result_type base_result;
return sprout::random::detail::generate_uniform_real_true_2(
sprout::generators::next_generator(rnd),
sprout::random::next(rnd),
min_value, max_value,
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
static_cast<T>(sprout::random::detail::subtract<base_result>()(sprout::random::result(rnd), sprout::random::next(rnd).min())),
static_cast<T>(sprout::random::detail::subtract<base_result>()(sprout::random::next(rnd).max(), sprout::random::next(rnd).min())) + 1
);
}
#endif

14
sprout/random/uniform_smallint.hpp
View file

@ -16,7 +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/random/result.hpp>
#include <sprout/assert.hpp>
namespace sprout {
@ -136,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_),
sprout::generators::next_generator(rnd),
sprout::random::next(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_),
sprout::generators::next_generator(rnd),
sprout::random::next(rnd),
*this
)
;
@ -160,7 +160,7 @@ namespace sprout {
rnd,
range,
base_range,
BaseUnsigned(sprout::random::detail::subtract<base_result>()(sprout::generators::generated_value(rnd), eng.min()))
BaseUnsigned(sprout::random::detail::subtract<base_result>()(sprout::random::result(rnd), eng.min()))
);
}
template<typename Engine>
@ -190,12 +190,12 @@ namespace sprout {
return offset > range
? sprout::random::random_result<Engine, uniform_smallint>(
max_,
sprout::generators::next_generator(rnd).engine(),
sprout::random::next(rnd).engine(),
*this
)
: sprout::random::random_result<Engine, uniform_smallint>(
sprout::random::detail::add<RangeType, result_type>()(offset, min_),
sprout::generators::next_generator(rnd).engine(),
sprout::random::next(rnd).engine(),
*this
)
;
@ -212,7 +212,7 @@ namespace sprout {
eng,
rnd,
static_cast<RangeType>(sprout::random::detail::subtract<result_type>()(max_, min_)),
static_cast<RangeType>(sprout::generators::generated_value(rnd) * (static_cast<base_result>(range) + 1))
static_cast<RangeType>(sprout::random::result(rnd) * (static_cast<base_result>(range) + 1))
);
}
template<class Engine>

1
sprout/random/utility.hpp
View file

@ -16,5 +16,6 @@
#include <sprout/random/generate_array.hpp>
#include <sprout/random/iterator.hpp>
#include <sprout/random/range.hpp>
#include <sprout/random/result.hpp>
#endif // #ifndef SPROUT_RANDOM_UTILITY_HPP

6
sprout/random/xor_combine.hpp
View file

@ -13,7 +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/random/result.hpp>
#include <sprout/type_traits/enabler_if.hpp>
#include HDR_ALGORITHM_MIN_MAX_SSCRISK_CEL_OR_SPROUT
@ -47,9 +47,9 @@ namespace sprout {
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>(
(sprout::generators::generated_value(rnd1) << s1) ^ (sprout::generators::generated_value(rnd2) << s2),
(sprout::random::result(rnd1) << s1) ^ (sprout::random::result(rnd2) << s2),
xor_combine_engine(
sprout::generators::next_generator(rnd1), sprout::generators::next_generator(rnd2)
sprout::random::next(rnd1), sprout::random::next(rnd2)
)
);
}

6
sprout/uuid/random_generator.hpp
View file

@ -16,7 +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>
#include <sprout/random/result.hpp>
namespace sprout {
namespace uuids {
@ -59,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..., sprout::generators::generated_value(rnd));
return random_to_uuid_1(args..., sprout::random::result(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(sprout::generators::next_generator(rnd)(), args..., sprout::generators::generated_value(rnd));
return random_to_uuid(sprout::random::next(rnd)(), args..., sprout::random::result(rnd));
}
public:
SPROUT_CONSTEXPR basic_random_generator()