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

distribution 修正

Browse source
This commit is contained in:
bolero-MURAKAMI 2011-10-17 13:44:19 +09:00
parent 9255ad6808
commit 6e6c515704
7 changed files with 73 additions and 47 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
sprout/random/bernoulli_distribution.hpp
View file

@ -32,22 +32,26 @@ namespace sprout {
class param_type { class param_type {
public: public:
typedef bernoulli_distribution distribution_type; typedef bernoulli_distribution distribution_type;
private:
static SPROUT_CONSTEXPR bool arg_check_nothrow(RealType p_arg) {
return distribution_type::arg_check_nothrow(p_arg);
}
private: private:
RealType p_; RealType p_;
public: public:
SPROUT_CONSTEXPR param_type() SPROUT_CONSTEXPR param_type()
: p_(RealType(0.5)) : p_(RealType(0.5))
{} {}
SPROUT_CONSTEXPR explicit param_type(RealType p_arg = RealType(0.5)) SPROUT_CONSTEXPR explicit param_type(RealType p_arg)
: p_(arg_check(p_arg)) : p_(arg_check(p_arg))
{} {}
SPROUT_CONSTEXPR RealType p() const { SPROUT_CONSTEXPR RealType p() const {
return p_; return p_;
} }
template<typename Elem, typename Traits> template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator>>( friend std::basic_istream<Elem, Traits>& operator>>(
std::basic_istream<Elem, Traits>& lhs, std::basic_istream<Elem, Traits>& lhs,
param_type const& rhs param_type& rhs
) )
{ {
RealType p; RealType p;
@ -93,7 +97,7 @@ namespace sprout {
SPROUT_CONSTEXPR bernoulli_distribution() SPROUT_CONSTEXPR bernoulli_distribution()
: p_(RealType(0.5)) : p_(RealType(0.5))
{} {}
SPROUT_CONSTEXPR explicit bernoulli_distribution(RealType p_arg = RealType(0.5)) SPROUT_CONSTEXPR explicit bernoulli_distribution(RealType p_arg)
: p_(arg_check(p_arg)) : p_(arg_check(p_arg))
{} {}
SPROUT_CONSTEXPR explicit bernoulli_distribution(param_type const& parm) SPROUT_CONSTEXPR explicit bernoulli_distribution(param_type const& parm)
@ -122,14 +126,14 @@ namespace sprout {
; ;
} }
template<typename Elem, typename Traits> template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator>>( friend std::basic_istream<Elem, Traits>& operator>>(
std::basic_istream<Elem, Traits>& lhs, std::basic_istream<Elem, Traits>& lhs,
bernoulli_distribution const& rhs bernoulli_distribution& rhs
) )
{ {
param_type parm; param_type parm;
return lhs >> parm; return lhs >> parm;
param(parm); rhs.param(parm);
return lhs; return lhs;
} }
template<typename Elem, typename Traits> template<typename Elem, typename Traits>
@ -138,7 +142,7 @@ namespace sprout {
bernoulli_distribution const& rhs bernoulli_distribution const& rhs
) )
{ {
return lhs << param(); return lhs << rhs.param();
} }
SPROUT_CONSTEXPR friend bool operator==(bernoulli_distribution const& lhs, bernoulli_distribution const& rhs) { SPROUT_CONSTEXPR friend bool operator==(bernoulli_distribution const& lhs, bernoulli_distribution const& rhs) {
return lhs.param() == rhs.param(); return lhs.param() == rhs.param();

20
sprout/random/binomial_distribution.hpp
View file

@ -69,6 +69,10 @@ namespace sprout {
class param_type { class param_type {
public: public:
typedef binomial_distribution distribution_type; typedef binomial_distribution distribution_type;
private:
static SPROUT_CONSTEXPR bool arg_check_nothrow(IntType t_arg, RealType p_arg) {
return distribution_type::arg_check_nothrow(t_arg, p_arg);
}
private: private:
IntType t_; IntType t_;
RealType p_; RealType p_;
@ -88,9 +92,9 @@ namespace sprout {
return p_; return p_;
} }
template<typename Elem, typename Traits> template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator>>( friend std::basic_istream<Elem, Traits>& operator>>(
std::basic_istream<Elem, Traits>& lhs, std::basic_istream<Elem, Traits>& lhs,
param_type const& rhs param_type& rhs
) )
{ {
IntType t; IntType t;
@ -391,8 +395,8 @@ namespace sprout {
return param_type(t_, p_); return param_type(t_, p_);
} }
void param(param_type const& parm) { void param(param_type const& parm) {
t_ = parm.a(); t_ = parm.t();
p_ = parm.b(); p_ = parm.p();
init(); init();
} }
template<typename Engine> template<typename Engine>
@ -405,14 +409,14 @@ namespace sprout {
; ;
} }
template<typename Elem, typename Traits> template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator>>( friend std::basic_istream<Elem, Traits>& operator>>(
std::basic_istream<Elem, Traits>& lhs, std::basic_istream<Elem, Traits>& lhs,
binomial_distribution const& rhs binomial_distribution& rhs
) )
{ {
param_type parm; param_type parm;
lhs >> parm; lhs >> parm;
param(parm); rhs.param(parm);
return lhs; return lhs;
} }
template<typename Elem, typename Traits> template<typename Elem, typename Traits>
@ -421,7 +425,7 @@ namespace sprout {
binomial_distribution const& rhs binomial_distribution const& rhs
) )
{ {
return lhs << param(); return lhs << rhs.param();
} }
SPROUT_CONSTEXPR friend bool operator==(binomial_distribution const& lhs, binomial_distribution const& rhs) { SPROUT_CONSTEXPR friend bool operator==(binomial_distribution const& lhs, binomial_distribution const& rhs) {
return lhs.param() == rhs.param(); return lhs.param() == rhs.param();

16
sprout/random/geometric_distribution.hpp
View file

@ -45,6 +45,10 @@ namespace sprout {
class param_type { class param_type {
public: public:
typedef geometric_distribution distribution_type; typedef geometric_distribution distribution_type;
private:
static SPROUT_CONSTEXPR bool arg_check_nothrow(RealType p_arg) {
return distribution_type::arg_check_nothrow(p_arg);
}
private: private:
RealType p_; RealType p_;
public: public:
@ -58,9 +62,9 @@ namespace sprout {
return p_; return p_;
} }
template<typename Elem, typename Traits> template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator>>( friend std::basic_istream<Elem, Traits>& operator>>(
std::basic_istream<Elem, Traits>& lhs, std::basic_istream<Elem, Traits>& lhs,
param_type const& rhs param_type& rhs
) )
{ {
RealType p; RealType p;
@ -147,14 +151,14 @@ namespace sprout {
return generate(eng); return generate(eng);
} }
template<typename Elem, typename Traits> template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator>>( friend std::basic_istream<Elem, Traits>& operator>>(
std::basic_istream<Elem, Traits>& lhs, std::basic_istream<Elem, Traits>& lhs,
geometric_distribution const& rhs geometric_distribution& rhs
) )
{ {
param_type parm; param_type parm;
lhs >> parm; lhs >> parm;
param(parm); rhs.param(parm);
return lhs; return lhs;
} }
template<typename Elem, typename Traits> template<typename Elem, typename Traits>
@ -163,7 +167,7 @@ namespace sprout {
geometric_distribution const& rhs geometric_distribution const& rhs
) )
{ {
return lhs << param(); return lhs << rhs.param();
} }
SPROUT_CONSTEXPR friend bool operator==(geometric_distribution const& lhs, geometric_distribution const& rhs) { SPROUT_CONSTEXPR friend bool operator==(geometric_distribution const& lhs, geometric_distribution const& rhs) {
return lhs.param() == rhs.param(); return lhs.param() == rhs.param();

10
sprout/random/uniform_01.hpp
View file

@ -26,9 +26,9 @@ namespace sprout {
typedef uniform_01 distribution_type; typedef uniform_01 distribution_type;
public: public:
template<typename Elem, typename Traits> template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator>>( friend std::basic_istream<Elem, Traits>& operator>>(
std::basic_istream<Elem, Traits>& lhs, std::basic_istream<Elem, Traits>& lhs,
param_type const& rhs param_type& rhs
) )
{ {
return lhs; return lhs;
@ -81,6 +81,8 @@ namespace sprout {
); );
} }
public: public:
SPROUT_CONSTEXPR explicit uniform_01()
{}
SPROUT_CONSTEXPR explicit uniform_01(param_type const& parm) SPROUT_CONSTEXPR explicit uniform_01(param_type const& parm)
{} {}
SPROUT_CONSTEXPR result_type min() const { SPROUT_CONSTEXPR result_type min() const {
@ -99,9 +101,9 @@ namespace sprout {
return generate(eng, eng()); return generate(eng, eng());
} }
template<typename Elem, typename Traits> template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator>>( friend std::basic_istream<Elem, Traits>& operator>>(
std::basic_istream<Elem, Traits>& lhs, std::basic_istream<Elem, Traits>& lhs,
uniform_01 const& rhs uniform_01& rhs
) )
{ {
return lhs; return lhs;

18
sprout/random/uniform_int_distribution.hpp
View file

@ -406,6 +406,10 @@ namespace sprout {
class param_type { class param_type {
public: public:
typedef uniform_int_distribution distribution_type; typedef uniform_int_distribution distribution_type;
private:
static SPROUT_CONSTEXPR bool arg_check_nothrow(IntType min_arg, IntType max_arg) {
return distribution_type::arg_check_nothrow(min_arg, max_arg);
}
private: private:
IntType min_; IntType min_;
IntType max_; IntType max_;
@ -425,9 +429,9 @@ namespace sprout {
return max_; return max_;
} }
template<typename Elem, typename Traits> template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator>>( friend std::basic_istream<Elem, Traits>& operator>>(
std::basic_istream<Elem, Traits>& lhs, std::basic_istream<Elem, Traits>& lhs,
param_type const& rhs param_type& rhs
) )
{ {
IntType min; IntType min;
@ -478,7 +482,7 @@ namespace sprout {
: min_(arg_check(min_arg, max_arg)) : min_(arg_check(min_arg, max_arg))
, max_(max_arg) , max_(max_arg)
{} {}
explicit uniform_int_distribution(param_type const& parm) SPROUT_CONSTEXPR explicit uniform_int_distribution(param_type const& parm)
: min_(parm.a()) : min_(parm.a())
, max_(parm.b()) , max_(parm.b())
{} {}
@ -506,14 +510,14 @@ namespace sprout {
return generate<Engine>(sprout::random::detail::generate_uniform_int(eng, min_, max_)); return generate<Engine>(sprout::random::detail::generate_uniform_int(eng, min_, max_));
} }
template<typename Elem, typename Traits> template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator>>( friend std::basic_istream<Elem, Traits>& operator>>(
std::basic_istream<Elem, Traits>& lhs, std::basic_istream<Elem, Traits>& lhs,
uniform_int_distribution const& rhs uniform_int_distribution& rhs
) )
{ {
param_type parm; param_type parm;
lhs >> parm; lhs >> parm;
param(parm); rhs.param(parm);
return lhs; return lhs;
} }
template<typename Elem, typename Traits> template<typename Elem, typename Traits>
@ -522,7 +526,7 @@ namespace sprout {
uniform_int_distribution const& rhs uniform_int_distribution const& rhs
) )
{ {
return lhs << param(); return lhs << rhs.param();
} }
SPROUT_CONSTEXPR friend bool operator==(uniform_int_distribution const& lhs, uniform_int_distribution const& rhs) { SPROUT_CONSTEXPR friend bool operator==(uniform_int_distribution const& lhs, uniform_int_distribution const& rhs) {
return lhs.param() == rhs.param(); return lhs.param() == rhs.param();

18
sprout/random/uniform_real_distribution.hpp
View file

@ -198,6 +198,10 @@ namespace sprout {
class param_type { class param_type {
public: public:
typedef uniform_real_distribution distribution_type; typedef uniform_real_distribution distribution_type;
private:
static SPROUT_CONSTEXPR bool arg_check_nothrow(RealType min_arg, RealType max_arg) {
return distribution_type::arg_check_nothrow(min_arg, max_arg);
}
private: private:
RealType min_; RealType min_;
RealType max_; RealType max_;
@ -217,9 +221,9 @@ namespace sprout {
return max_; return max_;
} }
template<typename Elem, typename Traits> template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator>>( friend std::basic_istream<Elem, Traits>& operator>>(
std::basic_istream<Elem, Traits>& lhs, std::basic_istream<Elem, Traits>& lhs,
param_type const& rhs param_type& rhs
) )
{ {
RealType min; RealType min;
@ -270,7 +274,7 @@ namespace sprout {
: min_(arg_check(min_arg, max_arg)) : min_(arg_check(min_arg, max_arg))
, max_(max_arg) , max_(max_arg)
{} {}
explicit uniform_real_distribution(param_type const& parm) SPROUT_CONSTEXPR explicit uniform_real_distribution(param_type const& parm)
: min_(parm.a()) : min_(parm.a())
, max_(parm.b()) , max_(parm.b())
{} {}
@ -298,14 +302,14 @@ namespace sprout {
return generate<Engine>(sprout::random::detail::generate_uniform_real(eng, min_, max_)); return generate<Engine>(sprout::random::detail::generate_uniform_real(eng, min_, max_));
} }
template<typename Elem, typename Traits> template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator>>( friend std::basic_istream<Elem, Traits>& operator>>(
std::basic_istream<Elem, Traits>& lhs, std::basic_istream<Elem, Traits>& lhs,
uniform_real_distribution const& rhs uniform_real_distribution& rhs
) )
{ {
param_type parm; param_type parm;
lhs >> parm; lhs >> parm;
param(parm); rhs.param(parm);
return lhs; return lhs;
} }
template<typename Elem, typename Traits> template<typename Elem, typename Traits>
@ -314,7 +318,7 @@ namespace sprout {
uniform_real_distribution const& rhs uniform_real_distribution const& rhs
) )
{ {
return lhs << param(); return lhs << rhs.param();
} }
SPROUT_CONSTEXPR friend bool operator==(uniform_real_distribution const& lhs, uniform_real_distribution const& rhs) { SPROUT_CONSTEXPR friend bool operator==(uniform_real_distribution const& lhs, uniform_real_distribution const& rhs) {
return lhs.param() == rhs.param(); return lhs.param() == rhs.param();

18
sprout/random/uniform_smallint.hpp
View file

@ -36,6 +36,10 @@ namespace sprout {
class param_type { class param_type {
public: public:
typedef uniform_smallint distribution_type; typedef uniform_smallint distribution_type;
private:
static SPROUT_CONSTEXPR bool arg_check_nothrow(IntType min_arg, IntType max_arg) {
return distribution_type::arg_check_nothrow(min_arg, max_arg);
}
private: private:
IntType min_; IntType min_;
IntType max_; IntType max_;
@ -55,9 +59,9 @@ namespace sprout {
return max_; return max_;
} }
template<typename Elem, typename Traits> template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator>>( friend std::basic_istream<Elem, Traits>& operator>>(
std::basic_istream<Elem, Traits>& lhs, std::basic_istream<Elem, Traits>& lhs,
param_type const& rhs param_type& rhs
) )
{ {
IntType min; IntType min;
@ -205,7 +209,7 @@ namespace sprout {
: min_(arg_check(min_arg, max_arg)) : min_(arg_check(min_arg, max_arg))
, max_(max_arg) , max_(max_arg)
{} {}
explicit uniform_smallint(param_type const& parm) SPROUT_CONSTEXPR explicit uniform_smallint(param_type const& parm)
: min_(parm.a()) : min_(parm.a())
, max_(parm.b()) , max_(parm.b())
{} {}
@ -234,14 +238,14 @@ namespace sprout {
return generate(eng, typename std::is_integral<base_result>::type()); return generate(eng, typename std::is_integral<base_result>::type());
} }
template<typename Elem, typename Traits> template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator>>( friend std::basic_istream<Elem, Traits>& operator>>(
std::basic_istream<Elem, Traits>& lhs, std::basic_istream<Elem, Traits>& lhs,
uniform_smallint const& rhs uniform_smallint& rhs
) )
{ {
param_type parm; param_type parm;
lhs >> parm; lhs >> parm;
param(parm); rhs.param(parm);
return lhs; return lhs;
} }
template<typename Elem, typename Traits> template<typename Elem, typename Traits>
@ -250,7 +254,7 @@ namespace sprout {
uniform_smallint const& rhs uniform_smallint const& rhs
) )
{ {
return lhs << param(); return lhs << rhs.param();
} }
SPROUT_CONSTEXPR friend bool operator==(uniform_smallint const& lhs, uniform_smallint const& rhs) { SPROUT_CONSTEXPR friend bool operator==(uniform_smallint const& lhs, uniform_smallint const& rhs) {
return lhs.param() == rhs.param(); return lhs.param() == rhs.param();