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

random 更新

Browse source
This commit is contained in:
bolero-MURAKAMI 2011-09-29 22:46:32 +09:00
parent 305ae86d92
commit 4a345e8259
6 changed files with 544 additions and 8 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
sprout/random.hpp
View file

@ -1,7 +1,12 @@
#ifndef SPROUT_RANDOM_HPP
#define SPROUT_RANDOM_HPP
#include <sprout/config.hpp>
#include <sprout/random/random_result.hpp>
#include <sprout/random/linear_congruential.hpp>
#include <sprout/random/uniform_smallint.hpp>
#include <sprout/random/uniform_01.hpp>
#endif // #ifndef SPROUT_RANDOM_HPP

63
sprout/random/detail/signed_unsigned_tools.hpp Normal file
View file

@ -0,0 +1,63 @@
#ifndef SPROUT_RANDOM_DETAIL_SIGNED_UNSIGNED_TOOLS_HPP
#define SPROUT_RANDOM_DETAIL_SIGNED_UNSIGNED_TOOLS_HPP
#include <limits>
#include <type_traits>
#include <sprout/config.hpp>
namespace sprout {
namespace random {
namespace detail {
template<typename T, bool B = std::numeric_limits<T>::is_signed>
struct subtract {};
template<typename T>
struct subtract<T, false> {
public:
typedef T result_type;
public:
SPROUT_CONSTEXPR result_type operator()(T x, T y) const {
return x - y;
}
};
template<typename T>
struct subtract<T, true> {
public:
typedef typename std::make_unsigned<T>::type result_type;
public:
SPROUT_CONSTEXPR result_type operator()(T x, T y) const {
return y >= 0 ? result_type(x) - result_type(y)
: x >= 0 ? result_type(x) + result_type(-(y + 1)) + 1
: result_type(x - y)
;
}
};
template<typename T1, typename T2, bool B = std::numeric_limits<T2>::is_signed>
struct add {};
template<typename T1, typename T2>
struct add<T1, T2, false> {
public:
typedef T2 result_type;
public:
SPROUT_CONSTEXPR result_type operator()(T1 x, T2 y) const {
return T2(x) + y;
}
};
template<typename T1, typename T2>
struct add<T1, T2, true> {
public:
typedef T2 result_type;
public:
SPROUT_CONSTEXPR result_type operator()(T1 x, T2 y) const {
return y >= 0 ? T2(x) + y
: x >= T1(-(y + 1)) ? T2(x - T1(-(y + 1)) - 1)
: T2(x) + y
;
}
};
} // namespace detail
} // namespace random
} // namespace sprout
#endif // SPROUT_RANDOM_DETAIL_SIGNED_UNSIGNED_TOOLS_HPP

21
sprout/random/linear_congruential.hpp
View file

@ -6,6 +6,7 @@
#include <ios>
#include <sprout/config.hpp>
#include <sprout/random/detail/const_mod.hpp>
#include <sprout/random/random_result.hpp>
namespace sprout {
namespace random {
@ -29,9 +30,10 @@ namespace sprout {
static_assert(m == 0 || c < m, "m == 0 || c < m");
private:
static SPROUT_CONSTEXPR IntType init_seed_3(IntType const& x0) {
//static_assert(x0 >= static_min(), "x0 >= static_min()");
//static_assert(x0 <= static_max(), "x0 <= static_max()");
return x0;
return x0 >= static_min() && x0 <= static_max()
? x0
: throw "assert(x0 >= static_min() && x0 <= static_max())"
;
}
static SPROUT_CONSTEXPR IntType init_seed_2(IntType const& x0) {
return init_seed_3(increment == 0 && x0 == 0 ? 1 : x0);
@ -55,6 +57,12 @@ namespace sprout {
SPROUT_CONSTEXPR linear_congruential_engine(IntType const& x, private_constructor_tag)
: x_(x)
{}
SPROUT_CONSTEXPR sprout::random::random_result<linear_congruential_engine> generate(result_type result) const {
return sprout::random::random_result<linear_congruential_engine>(
result,
linear_congruential_engine(result, private_constructor_tag())
);
}
public:
SPROUT_CONSTEXPR linear_congruential_engine()
: x_(init_seed(default_seed))
@ -68,11 +76,8 @@ namespace sprout {
SPROUT_CONSTEXPR result_type max() const {
return static_max();
}
SPROUT_CONSTEXPR result_type operator()() const {
return sprout::random::detail::const_mod<IntType, m>::mult_add(a, x_, c);
}
SPROUT_CONSTEXPR linear_congruential_engine next() const {
return linear_congruential_engine(operator()(), private_constructor_tag());
SPROUT_CONSTEXPR sprout::random::random_result<linear_congruential_engine> operator()() const {
return generate(sprout::random::detail::const_mod<IntType, m>::mult_add(a, x_, c));
}
friend SPROUT_CONSTEXPR bool operator==(linear_congruential_engine const& lhs, linear_congruential_engine const& rhs) {
return lhs.x_ == rhs.x_;

127
sprout/random/random_result.hpp Normal file
View file

@ -0,0 +1,127 @@
#ifndef SPROUT_RANDOM_RANDOM_RESULT_HPP
#define SPROUT_RANDOM_RANDOM_RESULT_HPP
#include <type_traits>
#include <sprout/config.hpp>
namespace sprout {
namespace random {
//
// random_result
//
template<typename Engine, typename Distribution = void, typename Enable = void>
class random_result;
template<typename Engine, typename Distribution>
class random_result<
Engine,
Distribution,
typename std::enable_if<!std::is_same<Distribution, void>::value>::type
> {
public:
typedef Engine engine_type;
typedef Distribution distribution_type;
typedef typename distribution_type::result_type result_type;
private:
result_type result_;
engine_type engine_;
distribution_type distribution_;
public:
SPROUT_CONSTEXPR random_result(
result_type result,
engine_type const& engine,
distribution_type const& distribution
)
: result_(result)
, engine_(engine)
, distribution_(distribution)
{}
SPROUT_CONSTEXPR operator result_type() const {
return result_;
}
SPROUT_CONSTEXPR result_type operator*() const {
return result_;
}
SPROUT_CONSTEXPR random_result operator()() const {
return distribution_(engine_);
}
result_type& result() {
return result_;
}
SPROUT_CONSTEXPR result_type const& result() const {
return result_;
}
engine_type& engine() {
return engine_;
}
SPROUT_CONSTEXPR engine_type const& engine() const {
return engine_;
}
distribution_type& distribution() {
return distribution_;
}
SPROUT_CONSTEXPR distribution_type const& distribution() const {
return distribution_;
}
SPROUT_CONSTEXPR result_type min() const {
return distribution_.min();
}
SPROUT_CONSTEXPR result_type max() const {
return distribution_.max();
}
};
template<typename Engine, typename Distribution>
class random_result<
Engine,
Distribution,
typename std::enable_if<std::is_same<Distribution, void>::value>::type
> {
public:
typedef Engine engine_type;
typedef typename engine_type::result_type result_type;
private:
result_type result_;
engine_type engine_;
public:
SPROUT_CONSTEXPR random_result(
result_type result,
engine_type const& engine
)
: result_(result)
, engine_(engine)
{}
SPROUT_CONSTEXPR operator result_type() const {
return result_;
}
SPROUT_CONSTEXPR result_type operator*() const {
return result_;
}
SPROUT_CONSTEXPR random_result operator()() const {
return engine_();
}
result_type& result() {
return result_;
}
SPROUT_CONSTEXPR result_type const& result() const {
return result_;
}
engine_type& engine() {
return engine_;
}
SPROUT_CONSTEXPR engine_type const& engine() const {
return engine_;
}
SPROUT_CONSTEXPR result_type min() const {
return engine_.min();
}
SPROUT_CONSTEXPR result_type max() const {
return engine_.max();
}
};
} // namespace random
using sprout::random::random_result;
} // namespace sprout
#endif // #ifndef SPROUT_RANDOM_RANDOM_RESULT_HPP

91
sprout/random/uniform_01.hpp Normal file
View file

@ -0,0 +1,91 @@
#ifndef SPROUT_RANDOM_UNIFORM_01_HPP
#define SPROUT_RANDOM_UNIFORM_01_HPP
#include <iosfwd>
#include <limits>
#include <sprout/config.hpp>
#include <sprout/random/random_result.hpp>
namespace sprout {
namespace random {
//
// uniform_01
//
template<typename RealType = double>
class uniform_01 {
public:
typedef RealType input_type;
typedef RealType result_type;
private:
template<typename Engine>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, uniform_01> generate_1(
Engine const& eng,
sprout::random::random_result<Engine> const& rnd,
result_type result
) const
{
return result < result_type(1)
? sprout::random::random_result<Engine, uniform_01>(result, rnd.engine(), *this)
: operator()(rnd.engine())
;
}
template<typename Engine>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, uniform_01> generate(
Engine const& eng,
sprout::random::random_result<Engine> const& rnd
) const
{
typedef typename Engine::result_type base_result;
return generate_1(
eng,
rnd,
result_type(rnd.result() - eng.min()) * (
result_type(1) / (
result_type(eng.max() - eng.min()) + result_type(
std::numeric_limits<base_result>::is_integer ? 1 : 0
)
)
)
);
}
public:
SPROUT_CONSTEXPR result_type min() const {
return result_type(0);
}
SPROUT_CONSTEXPR result_type max() const {
return result_type(1);
}
template<typename Engine>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, uniform_01> operator()(Engine const& eng) const {
return generate(eng, eng());
}
template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator>>(
std::basic_istream<Elem, Traits>& lhs,
uniform_01 const& rhs
)
{
return lhs;
}
template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& lhs,
uniform_01 const& rhs
)
{
return lhs;
}
SPROUT_CONSTEXPR friend bool operator==(uniform_01 const& lhs, uniform_01 const& rhs) {
return true;
}
SPROUT_CONSTEXPR friend bool operator!=(uniform_01 const& lhs, uniform_01 const& rhs) {
return !(lhs == rhs);
}
};
} // namespace random
using sprout::random::uniform_01;
} // namespace sprout
#endif // #ifndef SPROUT_RANDOM_UNIFORM_01_HPP

245
sprout/random/uniform_smallint.hpp Normal file
View file

@ -0,0 +1,245 @@
#ifndef SPROUT_RANDOM_UNIFORM_SMALLINT_HPP
#define SPROUT_RANDOM_UNIFORM_SMALLINT_HPP
#include <iosfwd>
#include <istream>
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/random/detail/signed_unsigned_tools.hpp>
#include <sprout/random/random_result.hpp>
#include <sprout/random/uniform_01.hpp>
namespace sprout {
namespace random {
//
// uniform_smallint
//
template<typename IntType = int>
class uniform_smallint {
public:
typedef IntType input_type;
typedef IntType result_type;
public:
//
// param_type
//
class param_type {
public:
typedef uniform_smallint distribution_type;
private:
static SPROUT_CONSTEXPR IntType arg_check(IntType min_arg, IntType max_arg) {
return min_arg <= max_arg
? min_arg
: throw "assert(min_arg <= max_arg)"
;
}
private:
IntType min_;
IntType max_;
public:
SPROUT_CONSTEXPR param_type(IntType min_arg = 0, IntType max_arg = 9)
: min_(arg_check(min_arg, max_arg))
, max_(max_arg)
{}
SPROUT_CONSTEXPR IntType a() const {
return min_;
}
SPROUT_CONSTEXPR IntType b() const {
return max_;
}
template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator>>(
std::basic_istream<Elem, Traits>& lhs,
param_type const& rhs
)
{
return lhs >> rhs.min_ >> std::ws >> rhs.max_;
}
template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& lhs,
param_type const& rhs
)
{
return lhs << rhs.min_ << " " << rhs.max_;
}
SPROUT_CONSTEXPR friend bool operator==(param_type const& lhs, param_type const& rhs) {
return lhs.min_ == rhs.min_ && lhs.max_ == rhs.max_;
}
SPROUT_CONSTEXPR friend bool operator!=(param_type const& lhs, param_type const& rhs) {
return !(lhs == rhs);
}
};
private:
result_type min_;
result_type max_;
private:
template<typename Engine, typename RangeType, typename BaseUnsigned>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, uniform_smallint> generate_true_2(
Engine const& eng,
sprout::random::random_result<Engine> const& rnd,
RangeType range,
BaseUnsigned base_range,
BaseUnsigned val
) const
{
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(),
*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(),
*this
)
;
}
template<typename Engine, typename RangeType, typename BaseUnsigned>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, uniform_smallint> generate_true_1(
Engine const& eng,
sprout::random::random_result<Engine> const& rnd,
RangeType range,
BaseUnsigned base_range
) const
{
typedef typename Engine::result_type base_result;
return generate_true_2(
eng,
rnd,
range,
base_range,
BaseUnsigned(sprout::random::detail::subtract<base_result>()(rnd.result(), eng.min()))
);
}
template<typename Engine>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, uniform_smallint> generate(
Engine const& eng,
std::true_type
) const
{
typedef typename Engine::result_type base_result;
typedef typename std::make_unsigned<base_result>::type base_unsigned;
typedef typename std::make_unsigned<result_type>::type range_type;
return generate_true_1(
eng,
eng(),
range_type(sprout::random::detail::subtract<result_type>()(max_, min_)),
base_unsigned(sprout::random::detail::subtract<result_type>()(eng.max(), eng.min()))
);
}
template<typename Engine, typename RangeType>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, uniform_smallint> generate_false_2(
Engine const& eng,
sprout::random::random_result<Engine, sprout::random::uniform_01<typename Engine::result_type> > const& rnd,
RangeType range,
RangeType offset
) const
{
return offset > range
? sprout::random::random_result<Engine, uniform_smallint>(
max_,
rnd.engine(),
*this
)
: sprout::random::random_result<Engine, uniform_smallint>(
sprout::random::detail::add<RangeType, result_type>()(offset , min_),
rnd.engine(),
*this
)
;
}
template<typename Engine, 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,
RangeType range
) const
{
typedef typename Engine::result_type base_result;
return generate_false_2(
eng,
rnd,
RangeType(sprout::random::detail::subtract<result_type>()(max_, min_)),
RangeType(static_cast<RangeType>(rnd.result() * (static_cast<base_result>(range) + 1)))
);
}
template<class Engine>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, uniform_smallint> generate(
Engine const& eng,
std::false_type
) const
{
typedef typename Engine::result_type base_result;
typedef typename std::make_unsigned<result_type>::type range_type;
return generate_false_1(
eng,
sprout::random::uniform_01<base_result>()(eng),
range_type(sprout::random::detail::subtract<result_type>()(max_, min_))
);
}
public:
SPROUT_CONSTEXPR explicit uniform_smallint(IntType min_arg = 0, IntType max_arg = 9)
: min_(min_arg), max_(max_arg)
{}
explicit uniform_smallint(param_type const& parm)
: min_(parm.a()), max_(parm.b())
{}
SPROUT_CONSTEXPR result_type a() const {
return min_;
}
SPROUT_CONSTEXPR result_type b() const {
return max_;
}
SPROUT_CONSTEXPR result_type min() const {
return min_;
}
SPROUT_CONSTEXPR result_type max() const {
return max_;
}
SPROUT_CONSTEXPR param_type param() const {
return param_type(min_, max_);
}
void param(param_type const& parm) {
min_ = parm.a();
max_ = parm.b();
}
template<typename Engine>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, uniform_smallint> operator()(Engine const& eng) const {
typedef typename Engine::result_type base_result;
return generate(eng, typename std::is_integral<base_result>::type());
}
template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator>>(
std::basic_istream<Elem, Traits>& lhs,
uniform_smallint const& rhs
)
{
param_type parm;
return lhs >> parm;
param(parm);
return lhs;
}
template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& lhs,
uniform_smallint const& rhs
)
{
return lhs << param();
}
SPROUT_CONSTEXPR friend bool operator==(uniform_smallint const& lhs, uniform_smallint const& rhs) {
return lhs.param() == rhs.param();
}
SPROUT_CONSTEXPR friend bool operator!=(uniform_smallint const& lhs, uniform_smallint const& rhs) {
return !(lhs == rhs);
}
};
} // namespace random
using sprout::random::uniform_smallint;
} // namespace sprout
#endif // #ifndef SPROUT_RANDOM_UNIFORM_SMALLINT_HPP