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/geometric_distribution.hpp 追加

Browse source 
distribution のストリーム入力のバグ修正
This commit is contained in:
bolero-MURAKAMI 2011-10-14 21:23:13 +09:00
parent 16dfd793ab
commit 7ae0072f2e
7 changed files with 259 additions and 14 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
sprout/random.hpp
View file

@ -10,6 +10,7 @@
#include <sprout/random/uniform_real_distribution.hpp>
#include <sprout/random/bernoulli_distribution.hpp>
#include <sprout/random/binomial_distribution.hpp>
#include <sprout/random/geometric_distribution.hpp>
#include <sprout/random/variate_generator.hpp>
#include <sprout/random/random_result.hpp>
#include <sprout/random/random_iterator.hpp>

15
sprout/random/bernoulli_distribution.hpp
View file

@ -16,8 +16,11 @@ namespace sprout {
typedef int input_type;
typedef bool result_type;
private:
static SPROUT_CONSTEXPR bool arg_check_nothrow(RealType p_arg) {
return p_arg >= 0 && p_arg <= 1;
}
static SPROUT_CONSTEXPR RealType arg_check(RealType p_arg) {
return p_arg >= 0 && p_arg <= 1
return arg_check_nothrow(p_arg)
? p_arg
: throw "assert(p_arg >= 0 && p_arg <= 1)"
;
@ -47,7 +50,15 @@ namespace sprout {
param_type const& rhs
)
{
return lhs >> rhs.p_;
RealType p;
if (lhs >> p) {
if (arg_check_nothrow(p)) {
rhs.p_ = p;
} else {
lhs.setstate(std::ios_base::failbit);
}
}
return lhs;
}
template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator<<(

20
sprout/random/binomial_distribution.hpp
View file

@ -1,6 +1,7 @@
#ifndef SPROUT_RANDOM_BINOMIAL_DISTRIBUTION_HPP
#define SPROUT_RANDOM_BINOMIAL_DISTRIBUTION_HPP
#include <cmath>
#include <iosfwd>
#include <istream>
#include <sprout/config.hpp>
@ -52,8 +53,11 @@ namespace sprout {
RealType u_rv_r;
};
private:
static SPROUT_CONSTEXPR bool arg_check_nothrow(IntType t_arg, RealType p_arg) {
return t_arg >= IntType(0) && RealType(0) <= p_arg && p_arg <= RealType(1);
}
static SPROUT_CONSTEXPR IntType arg_check(IntType t_arg, RealType p_arg) {
return t_arg >= IntType(0) && RealType(0) <= p_arg && p_arg <= RealType(1)
return arg_check_nothrow(t_arg, p_arg)
? t_arg
: throw "assert(t_arg >= IntType(0) && RealType(0) <= p_arg && p_arg <= RealType(1))"
;
@ -89,7 +93,17 @@ namespace sprout {
param_type const& rhs
)
{
return lhs >> rhs.t_ >> std::ws >> rhs.p_;
IntType t;
RealType p;
if (lhs >> t >> std::ws >> p) {
if (arg_check_nothrow(t, p)) {
rhs.t_ = t;
rhs.p_ = p;
} else {
lhs.setstate(std::ios_base::failbit);
}
}
return lhs;
}
template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator<<(
@ -397,7 +411,7 @@ namespace sprout {
)
{
param_type parm;
return lhs >> parm;
lhs >> parm;
param(parm);
return lhs;
}

180
sprout/random/geometric_distribution.hpp Normal file
View file

@ -0,0 +1,180 @@
#ifndef SPROUT_RANDOM_GEOMETRIC_DISTRIBUTION_HPP
#define SPROUT_RANDOM_GEOMETRIC_DISTRIBUTION_HPP
#include <cmath>
#include <ios>
#include <limits>
#include <sprout/config.hpp>
#include <sprout/random/random_result.hpp>
#include <sprout/random/uniform_01.hpp>
namespace sprout {
namespace detail {
template<typename T>
SPROUT_CONSTEXPR T floor(T x) {
return x >= T(0) ? std::floor(x) : -std::ceil(-x);
}
template<typename T>
SPROUT_CONSTEXPR T ceil(T x) {
return x >= T(0) ? std::ceil(x) : -std::floor(-x);
}
} // namespace detail
namespace random {
//
// geometric_distribution
//
template<typename IntType = int, typename RealType = double>
class geometric_distribution {
public:
typedef RealType input_type;
typedef IntType result_type;
private:
static SPROUT_CONSTEXPR bool arg_check_nothrow(RealType p_arg) {
return RealType(0) < p_arg && p_arg < RealType(1);
}
static SPROUT_CONSTEXPR RealType arg_check(RealType p_arg) {
return arg_check_nothrow(p_arg)
? p_arg
: throw "assert(RealType(0) < p_arg && p_arg < RealType(1))"
;
}
public:
//
// param_type
//
class param_type {
public:
typedef geometric_distribution distribution_type;
private:
RealType p_;
public:
SPROUT_CONSTEXPR param_type()
: p_(RealType(0.5))
{}
SPROUT_CONSTEXPR explicit param_type(RealType p_arg)
: p_(arg_check(p_arg))
{}
SPROUT_CONSTEXPR RealType p() const {
return p_;
}
template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator>>(
std::basic_istream<Elem, Traits>& lhs,
param_type const& rhs
)
{
RealType p;
if (lhs >> p) {
if (arg_check_nothrow(p)) {
rhs.p_ = p;
} else {
lhs.setstate(std::ios_base::failbit);
}
}
return lhs;
}
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.p_;
}
SPROUT_CONSTEXPR friend bool operator==(param_type const& lhs, param_type const& rhs) {
return lhs.p_ == rhs.p_;
}
SPROUT_CONSTEXPR friend bool operator!=(param_type const& lhs, param_type const& rhs) {
return !(lhs == rhs);
}
};
private:
public:
static SPROUT_CONSTEXPR RealType init_log_1mp(RealType p) {
using std::log;
return log(1 - p);
}
private:
public:
RealType p_;
RealType log_1mp_;
private:
template<typename Engine, typename Random>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, geometric_distribution> generate_1(Random const& rnd) const {
using std::log;
using std::floor;
return sprout::random::random_result<Engine, geometric_distribution>(
static_cast<IntType>(floor(log(RealType(1) - rnd.result()) / log_1mp_)),
rnd.engine(),
*this
);
}
template<typename Engine>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, geometric_distribution> generate(Engine const& eng) const {
return generate_1<Engine>(sprout::random::uniform_01<RealType>()(eng));
}
public:
SPROUT_CONSTEXPR geometric_distribution()
: p_(RealType(0.5))
, log_1mp_(init_log_1mp(RealType(0.5)))
{}
SPROUT_CONSTEXPR explicit geometric_distribution(RealType p_arg)
: p_(arg_check(p_arg))
, log_1mp_(init_log_1mp(p_arg))
{}
SPROUT_CONSTEXPR explicit geometric_distribution(param_type const& parm)
: p_(parm.p())
, log_1mp_(init_log_1mp(parm.p()))
{}
SPROUT_CONSTEXPR result_type p() const {
return p_;
}
SPROUT_CONSTEXPR result_type min() const {
return 0;
}
SPROUT_CONSTEXPR result_type max() const {
return std::numeric_limits<result_type>::max();
}
SPROUT_CONSTEXPR param_type param() const {
return param_type(p_);
}
void param(param_type const& parm) {
p_ = parm.p();
log_1mp_ = init_log_1mp(p_);
}
template<typename Engine>
SPROUT_CONSTEXPR sprout::random::random_result<Engine, geometric_distribution> operator()(Engine const& eng) const {
return generate(eng);
}
template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator>>(
std::basic_istream<Elem, Traits>& lhs,
geometric_distribution const& rhs
)
{
param_type parm;
lhs >> parm;
param(parm);
return lhs;
}
template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& lhs,
geometric_distribution const& rhs
)
{
return lhs << param();
}
SPROUT_CONSTEXPR friend bool operator==(geometric_distribution const& lhs, geometric_distribution const& rhs) {
return lhs.param() == rhs.param();
}
SPROUT_CONSTEXPR friend bool operator!=(geometric_distribution const& lhs, geometric_distribution const& rhs) {
return !(lhs == rhs);
}
};
} // namespace random
using sprout::random::geometric_distribution;
} // namespace sprout
#endif // #ifndef SPROUT_RANDOM_GEOMETRIC_DISTRIBUTION_HPP

19
sprout/random/uniform_int_distribution.hpp
View file

@ -390,8 +390,11 @@ namespace sprout {
typedef IntType input_type;
typedef IntType result_type;
private:
static SPROUT_CONSTEXPR bool arg_check_nothrow(IntType min_arg, IntType max_arg) {
return min_arg <= max_arg;
}
static SPROUT_CONSTEXPR IntType arg_check(IntType min_arg, IntType max_arg) {
return min_arg <= max_arg
return arg_check_nothrow(min_arg, max_arg)
? min_arg
: throw "assert(min_arg <= max_arg)"
;
@ -427,7 +430,17 @@ namespace sprout {
param_type const& rhs
)
{
return lhs >> rhs.min_ >> std::ws >> rhs.max_;
IntType min;
IntType max;
if (lhs >> min >> std::ws >> max) {
if (arg_check_nothrow(min, max)) {
rhs.min_ = min;
rhs.max_ = max;
} else {
lhs.setstate(std::ios_base::failbit);
}
}
return lhs;
}
template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator<<(
@ -499,7 +512,7 @@ namespace sprout {
)
{
param_type parm;
return lhs >> parm;
lhs >> parm;
param(parm);
return lhs;
}

19
sprout/random/uniform_real_distribution.hpp
View file

@ -182,8 +182,11 @@ namespace sprout {
typedef RealType input_type;
typedef RealType result_type;
private:
static SPROUT_CONSTEXPR bool arg_check_nothrow(RealType min_arg, RealType max_arg) {
return min_arg <= max_arg;
}
static SPROUT_CONSTEXPR RealType arg_check(RealType min_arg, RealType max_arg) {
return min_arg <= max_arg
return arg_check_nothrow(min_arg, max_arg)
? min_arg
: throw "assert(min_arg <= max_arg)"
;
@ -219,7 +222,17 @@ namespace sprout {
param_type const& rhs
)
{
return lhs >> rhs.min_ >> std::ws >> rhs.max_;
RealType min;
RealType max;
if (lhs >> min >> std::ws >> max) {
if (arg_check_nothrow(min, max)) {
rhs.min_ = min;
rhs.max_ = max;
} else {
lhs.setstate(std::ios_base::failbit);
}
}
return lhs;
}
template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator<<(
@ -291,7 +304,7 @@ namespace sprout {
)
{
param_type parm;
return lhs >> parm;
lhs >> parm;
param(parm);
return lhs;
}

19
sprout/random/uniform_smallint.hpp
View file

@ -20,8 +20,11 @@ namespace sprout {
typedef IntType input_type;
typedef IntType result_type;
private:
static SPROUT_CONSTEXPR bool arg_check_nothrow(IntType min_arg, IntType max_arg) {
return min_arg <= max_arg;
}
static SPROUT_CONSTEXPR IntType arg_check(IntType min_arg, IntType max_arg) {
return min_arg <= max_arg
return arg_check_nothrow(min_arg, max_arg)
? min_arg
: throw "assert(min_arg <= max_arg)"
;
@ -57,7 +60,17 @@ namespace sprout {
param_type const& rhs
)
{
return lhs >> rhs.min_ >> std::ws >> rhs.max_;
IntType min;
IntType max;
if (lhs >> min >> std::ws >> max) {
if (arg_check_nothrow(min, max)) {
rhs.min_ = min;
rhs.max_ = max;
} else {
lhs.setstate(std::ios_base::failbit);
}
}
return lhs;
}
template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator<<(
@ -227,7 +240,7 @@ namespace sprout {
)
{
param_type parm;
return lhs >> parm;
lhs >> parm;
param(parm);
return lhs;
}