random 修正

sprout/random/bernoulli_distribution.hpp

@@ -96,6 +96,9 @@ namespace sprout {
 			SPROUT_CONSTEXPR explicit bernoulli_distribution(RealType p_arg = RealType(0.5))
 				: p_(arg_check(p_arg))
 			{}
+			SPROUT_CONSTEXPR explicit bernoulli_distribution(param_type const& parm)
+				: p_(parm.p())
+			{}
 			SPROUT_CONSTEXPR RealType p() const {
 				return p_;
 			}

sprout/random/linear_congruential.hpp

@@ -29,14 +29,17 @@ namespace sprout {
 			static_assert(m == 0 || a < m, "m == 0 || a < m");
 			static_assert(m == 0 || c < m, "m == 0 || c < m");
 		private:
-			static SPROUT_CONSTEXPR IntType init_seed_3(IntType const& x0) {
+			static SPROUT_CONSTEXPR bool arg_check_nothrow(IntType const& x0) {
-				return x0 >= static_min() && x0 <= static_max()
+				return x0 >= static_min() && x0 <= static_max();
+			}
+			static SPROUT_CONSTEXPR IntType arg_check(IntType const& x0) {
+				return arg_check_nothrow(x0)
 					? 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);
+				return arg_check(increment == 0 && x0 == 0 ? 1 : x0);
 			}
 			static SPROUT_CONSTEXPR IntType init_seed_1(IntType const& x0) {
 				return init_seed_2(x0 <= 0 && x0 != 0 ? x0 + modulus : x0);
@@ -88,12 +91,12 @@ namespace sprout {
 			template<typename Elem, typename Traits>
 			friend std::basic_istream<Elem, Traits>& operator>>(
 				std::basic_istream<Elem, Traits>& lhs,
-				linear_congruential_engine const& rhs
+				linear_congruential_engine& rhs
 				)
 			{
 				IntType x;
 				if(lhs >> x) {
-					if(x >= min() && x <= max()) {
+					if(arg_check_nothrow(x)) {
 						rhs.x_ = x;
 					} else {
 						lhs.setstate(std::ios_base::failbit);
@@ -192,7 +195,7 @@ namespace sprout {
 			template<typename Elem, typename Traits>
 			friend std::basic_istream<Elem, Traits>& operator>>(
 				std::basic_istream<Elem, Traits>& lhs,
-				rand48 const& rhs
+				rand48& rhs
 				)
 			{
 				return lhs >> rhs.lcf_;

sprout/random/mersenne_twister.hpp

@@ -331,7 +331,7 @@ namespace sprout {
 					;
 			}
 			friend SPROUT_CONSTEXPR bool operator==(mersenne_twister_engine const& lhs, mersenne_twister_engine const& rhs) {
-				return lhs.i_ < lhs.i_
+				return lhs.i_ < rhs.i_
 					? lhs.equal_impl(rhs)
 					: rhs.equal_impl(lhs)
 					;
@@ -342,6 +342,18 @@ namespace sprout {
 			template<typename Elem, typename Traits>
 			friend std::basic_istream<Elem, Traits>& operator>>(
 				std::basic_istream<Elem, Traits>& lhs,
+				mersenne_twister_engine& rhs
+				)
+			{
+				for (std::size_t i = 0; i < state_size; ++i) {
+					lhs >> rhs.x_[i] >> std::ws;
+				}
+				rhs.i_ = state_size;
+				return lhs;
+			}
+			template<typename Elem, typename Traits>
+			friend std::basic_ostream<Elem, Traits>& operator<<(
+				std::basic_ostream<Elem, Traits>& lhs,
 				mersenne_twister_engine const& rhs
 				)
 			{
@@ -358,18 +370,6 @@ namespace sprout {
 				}
 				return lhs;
 			}
-			template<typename Elem, typename Traits>
-			friend std::basic_ostream<Elem, Traits>& operator<<(
-				std::basic_ostream<Elem, Traits>& lhs,
-				mersenne_twister_engine const& rhs
-				)
-			{
-				for (std::size_t i = 0; i < state_size; ++i) {
-					lhs >> rhs.x_[i] >> std::ws;
-				}
-				rhs.i_ = state_size;
-				return lhs;
-			}
 		};
 		template<typename UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f>
 		SPROUT_CONSTEXPR std::size_t sprout::random::mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>::word_size;

sprout/random/uniform_01.hpp

@@ -17,6 +17,37 @@ namespace sprout {
 		public:
 			typedef RealType input_type;
 			typedef RealType result_type;
+		public:
+			//
+			// param_type
+			//
+			class param_type {
+			public:
+				typedef uniform_01 distribution_type;
+			public:
+				template<typename Elem, typename Traits>
+				friend std::basic_ostream<Elem, Traits>& operator>>(
+					std::basic_istream<Elem, Traits>& lhs,
+					param_type const& rhs
+					)
+				{
+					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;
+				}
+				SPROUT_CONSTEXPR friend bool operator==(param_type const& lhs, param_type const& rhs) {
+					return true;
+				}
+				SPROUT_CONSTEXPR friend bool operator!=(param_type const& lhs, param_type const& rhs) {
+					return !(lhs == rhs);
+				}
+			};
 		private:
 			template<typename Engine>
 			SPROUT_CONSTEXPR sprout::random::random_result<Engine, uniform_01> generate_1(
@@ -50,12 +81,19 @@ namespace sprout {
 					);
 			}
 		public:
+			SPROUT_CONSTEXPR explicit uniform_01(param_type const& parm)
+			{}
 			SPROUT_CONSTEXPR result_type min() const {
 				return result_type(0);
 			}
 			SPROUT_CONSTEXPR result_type max() const {
 				return result_type(1);
 			}
+			SPROUT_CONSTEXPR param_type param() const {
+				return param_type();
+			}
+			void param(param_type const& parm) {
+			}
 			template<typename Engine>
 			SPROUT_CONSTEXPR sprout::random::random_result<Engine, uniform_01> operator()(Engine const& eng) const {
 				return generate(eng, eng());