From 8b357a75dad6dc4e5a2b293d0b61317bf0282aa7 Mon Sep 17 00:00:00 2001
From: bolero-MURAKAMI <bolero.murakami@gmail.com>
Date: Fri, 30 Sep 2011 00:06:24 +0900
Subject: [PATCH] =?UTF-8?q?variate=5Fgenerator=20=E8=BF=BD=E5=8A=A0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 sprout/random.hpp                   |  1 +
 sprout/random/detail/ptr_helper.hpp | 73 +++++++++++++++++++++++++
 sprout/random/variate_generator.hpp | 84 +++++++++++++++++++++++++++++
 3 files changed, 158 insertions(+)
 create mode 100644 sprout/random/detail/ptr_helper.hpp
 create mode 100644 sprout/random/variate_generator.hpp

diff --git a/sprout/random.hpp b/sprout/random.hpp
index 1a6a9396..5dd09c66 100644
--- a/sprout/random.hpp
+++ b/sprout/random.hpp
@@ -6,6 +6,7 @@
 #include <sprout/random/linear_congruential.hpp>
 #include <sprout/random/uniform_smallint.hpp>
 #include <sprout/random/uniform_01.hpp>
+#include <sprout/random/variate_generator.hpp>
 
 #endif // #ifndef SPROUT_RANDOM_HPP
 
diff --git a/sprout/random/detail/ptr_helper.hpp b/sprout/random/detail/ptr_helper.hpp
new file mode 100644
index 00000000..bfc9469b
--- /dev/null
+++ b/sprout/random/detail/ptr_helper.hpp
@@ -0,0 +1,73 @@
+#ifndef SPROUT_RANDOM_DETAIL_PTR_HELPER_HPP
+#define SPROUT_RANDOM_DETAIL_PTR_HELPER_HPP
+
+#include <sprout/config.hpp>
+
+namespace sprout {
+	namespace random {
+		namespace detail {
+			template<typename T>
+			struct ptr_helper {
+				typedef T value_type;
+				typedef T& reference_type;
+				typedef T const& const_reference_type;
+				typedef T const& rvalue_type;
+				static reference_type ref(T& r) {
+					return r;
+				}
+				static SPROUT_CONSTEXPR const_reference_type ref(T const& r) {
+					return r;
+				}
+			};
+			template<typename T>
+			struct ptr_helper<T&> {
+				typedef T value_type;
+				typedef T& reference_type;
+				typedef T const& const_reference_type;
+				typedef T& rvalue_type;
+				static reference_type ref(T& r) {
+					return r;
+				}
+				static SPROUT_CONSTEXPR const_reference_type ref(T const& r) {
+					return r;
+				}
+			};
+			template<typename T>
+			struct ptr_helper<T const&> {
+				typedef T value_type;
+				typedef T const& reference_type;
+				typedef T const& const_reference_type;
+				typedef T const& rvalue_type;
+				static SPROUT_CONSTEXPR const_reference_type ref(T const& r) {
+					return r;
+				}
+			};
+			template<typename T>
+			struct ptr_helper<T*> {
+				typedef T value_type;
+				typedef T& reference_type;
+				typedef T const& const_reference_type;
+				typedef T* rvalue_type;
+				static reference_type ref(T* p) {
+					return *p;
+				}
+				static SPROUT_CONSTEXPR const_reference_type ref(T const* p) {
+					return *p;
+				}
+			};
+			template<typename T>
+			struct ptr_helper<T const*> {
+				typedef T value_type;
+				typedef T const& reference_type;
+				typedef T const& const_reference_type;
+				typedef T const* rvalue_type;
+				static SPROUT_CONSTEXPR const_reference_type ref(T const* p) {
+					return *p;
+				}
+			};
+		}	// namespace detail
+	}	// namespace random
+}	// namespace sprout
+
+#endif // #ifndef SPROUT_RANDOM_DETAIL_PTR_HELPER_HPP
+
diff --git a/sprout/random/variate_generator.hpp b/sprout/random/variate_generator.hpp
new file mode 100644
index 00000000..3e4ccc99
--- /dev/null
+++ b/sprout/random/variate_generator.hpp
@@ -0,0 +1,84 @@
+#ifndef SPROUT_RANDOM_VARIATE_GENERATOR_HPP
+#define SPROUT_RANDOM_VARIATE_GENERATOR_HPP
+
+#include <type_traits>
+#include <sprout/config.hpp>
+#include <sprout/detail/if.hpp>
+#include <sprout/random/detail/ptr_helper.hpp>
+#include <sprout/random/random_result.hpp>
+
+namespace sprout {
+	namespace random {
+		//
+		// variate_generator
+		//
+		template<typename Engine, typename Distribution>
+		class variate_generator {
+		private:
+			typedef sprout::random::detail::ptr_helper<Engine> engine_helper_type;
+			typedef sprout::random::detail::ptr_helper<Distribution> distribution_helper_type;
+		public:
+			typedef typename engine_helper_type::value_type engine_value_type;
+			typedef typename distribution_helper_type::value_type distribution_value_type;
+			typedef typename engine_helper_type::reference_type engine_reference_type;
+			typedef typename distribution_helper_type::reference_type distribution_reference_type;
+			typedef typename engine_helper_type::const_reference_type engine_const_reference_type;
+			typedef typename distribution_helper_type::const_reference_type distribution_const_reference_type;
+			typedef typename engine_helper_type::rvalue_type engine_param_type;
+			typedef typename distribution_helper_type::rvalue_type distribution_param_type;
+		public:
+			typedef Engine engine_type;
+			typedef Distribution distribution_type;
+			typedef typename distribution_value_type::result_type result_type;
+		private:
+			engine_type engine_;
+			distribution_type distribution_;
+		public:
+			SPROUT_CONSTEXPR variate_generator(
+				engine_param_type engine,
+				distribution_param_type distribution
+				)
+				: engine_(engine)
+				, distribution_(distribution)
+			{}
+			SPROUT_CONSTEXPR sprout::random::random_result<engine_value_type, distribution_value_type> operator()() const {
+				return distribution_(engine_);
+			}
+			engine_reference_type engine() {
+				return engine_helper_type::ref(engine_);
+			}
+			SPROUT_CONSTEXPR engine_const_reference_type engine() const {
+				return engine_helper_type::ref(engine_);
+			}
+			distribution_reference_type distribution() {
+				return distribution_helper_type::ref(distribution_);
+			}
+			SPROUT_CONSTEXPR distribution_const_reference_type distribution() const {
+				return distribution_helper_type::ref(distribution_);
+			}
+			SPROUT_CONSTEXPR result_type min() const {
+				return distribution_.min();
+			}
+			SPROUT_CONSTEXPR result_type max() const {
+				return distribution_.max();
+			}
+		};
+
+		//
+		// combine
+		//
+		template<typename Engine, typename Distribution>
+		SPROUT_CONSTEXPR sprout::random::variate_generator<Engine const&, Distribution const&> combine(
+			Engine const& engine,
+			Distribution const& distribution
+			)
+		{
+			return sprout::random::variate_generator<Engine const&, Distribution const&>(engine, distribution);
+		}
+	}	// namespace random
+
+	using sprout::random::variate_generator;
+}	// namespace sprout
+
+#endif // #ifndef SPROUT_RANDOM_VARIATE_GENERATOR_HPP
+