/* boost random/uniform_01.hpp header file * * Copyright Jens Maurer 2000-2001 * Distributed under the Boost Software License, Version 1.0. (See * accompanying file LICENSE_1_0.txt or copy at * http://www.boost.org/LICENSE_1_0.txt) * * See http://www.boost.org for most recent version including documentation. * * $Id: uniform_01.hpp 60755 2010-03-22 00:45:06Z steven_watanabe $ * * Revision history * 2001-02-18 moved to individual header files */ #ifndef BOOST_RANDOM_UNIFORM_01_HPP #define BOOST_RANDOM_UNIFORM_01_HPP #include <iostream> #include <boost/config.hpp> #include <boost/limits.hpp> #include <boost/static_assert.hpp> #include <boost/random/detail/config.hpp> #include <boost/random/detail/pass_through_engine.hpp> #include <boost/random/detail/disable_warnings.hpp> namespace boost { #ifdef BOOST_RANDOM_DOXYGEN /** * The distribution function uniform_01 models a \random_distribution. * On each invocation, it returns a random floating-point value * uniformly distributed in the range [0..1). * * The template parameter RealType shall denote a float-like value type * with support for binary operators +, -, and /. * * Note: The current implementation is buggy, because it may not fill * all of the mantissa with random bits. I'm unsure how to fill a * (to-be-invented) @c boost::bigfloat class with random bits efficiently. * It's probably time for a traits class. */ template<class RealType = double> class uniform_01 { public: typedef RealType input_type; typedef RealType result_type; result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const; result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const; void reset(); template<class Engine> result_type operator()(Engine& eng); #ifndef BOOST_RANDOM_NO_STREAM_OPERATORS template<class CharT, class Traits> friend std::basic_ostream<CharT,Traits>& operator<<(std::basic_ostream<CharT,Traits>& os, const new_uniform_01&) { return os; } template<class CharT, class Traits> friend std::basic_istream<CharT,Traits>& operator>>(std::basic_istream<CharT,Traits>& is, new_uniform_01&) { return is; } #endif }; #else namespace detail { template<class RealType> class new_uniform_01 { public: typedef RealType input_type; typedef RealType result_type; // compiler-generated copy ctor and copy assignment are fine result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return result_type(0); } result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return result_type(1); } void reset() { } template<class Engine> result_type operator()(Engine& eng) { for (;;) { typedef typename Engine::result_type base_result; result_type factor = result_type(1) / (result_type((eng.max)()-(eng.min)()) + result_type(std::numeric_limits<base_result>::is_integer ? 1 : 0)); result_type result = result_type(eng() - (eng.min)()) * factor; if (result < result_type(1)) return result; } } #ifndef BOOST_RANDOM_NO_STREAM_OPERATORS template<class CharT, class Traits> friend std::basic_ostream<CharT,Traits>& operator<<(std::basic_ostream<CharT,Traits>& os, const new_uniform_01&) { return os; } template<class CharT, class Traits> friend std::basic_istream<CharT,Traits>& operator>>(std::basic_istream<CharT,Traits>& is, new_uniform_01&) { return is; } #endif }; template<class UniformRandomNumberGenerator, class RealType> class backward_compatible_uniform_01 { typedef boost::random::detail::ptr_helper<UniformRandomNumberGenerator> traits; typedef boost::random::detail::pass_through_engine<UniformRandomNumberGenerator> internal_engine_type; public: typedef UniformRandomNumberGenerator base_type; typedef RealType result_type; BOOST_STATIC_CONSTANT(bool, has_fixed_range = false); #if !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) && !(defined(BOOST_MSVC) && BOOST_MSVC <= 1300) BOOST_STATIC_ASSERT(!std::numeric_limits<RealType>::is_integer); #endif explicit backward_compatible_uniform_01(typename traits::rvalue_type rng) : _rng(rng), _factor(result_type(1) / (result_type((_rng.max)()-(_rng.min)()) + result_type(std::numeric_limits<base_result>::is_integer ? 1 : 0))) { } // compiler-generated copy ctor and copy assignment are fine result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return result_type(0); } result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return result_type(1); } typename traits::value_type& base() { return _rng.base(); } const typename traits::value_type& base() const { return _rng.base(); } void reset() { } result_type operator()() { for (;;) { result_type result = result_type(_rng() - (_rng.min)()) * _factor; if (result < result_type(1)) return result; } } #if !defined(BOOST_NO_OPERATORS_IN_NAMESPACE) && !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) template<class CharT, class Traits> friend std::basic_ostream<CharT,Traits>& operator<<(std::basic_ostream<CharT,Traits>& os, const backward_compatible_uniform_01& u) { os << u._rng; return os; } template<class CharT, class Traits> friend std::basic_istream<CharT,Traits>& operator>>(std::basic_istream<CharT,Traits>& is, backward_compatible_uniform_01& u) { is >> u._rng; return is; } #endif private: typedef typename internal_engine_type::result_type base_result; internal_engine_type _rng; result_type _factor; }; #ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION // A definition is required even for integral static constants template<class UniformRandomNumberGenerator, class RealType> const bool backward_compatible_uniform_01<UniformRandomNumberGenerator, RealType>::has_fixed_range; #endif template<class UniformRandomNumberGenerator> struct select_uniform_01 { template<class RealType> struct apply { typedef backward_compatible_uniform_01<UniformRandomNumberGenerator, RealType> type; }; }; template<> struct select_uniform_01<float> { template<class RealType> struct apply { typedef new_uniform_01<float> type; }; }; template<> struct select_uniform_01<double> { template<class RealType> struct apply { typedef new_uniform_01<double> type; }; }; template<> struct select_uniform_01<long double> { template<class RealType> struct apply { typedef new_uniform_01<long double> type; }; }; } // Because it is so commonly used: uniform distribution on the real [0..1) // range. This allows for specializations to avoid a costly int -> float // conversion plus float multiplication template<class UniformRandomNumberGenerator = double, class RealType = double> class uniform_01 : public detail::select_uniform_01<UniformRandomNumberGenerator>::BOOST_NESTED_TEMPLATE apply<RealType>::type { typedef typename detail::select_uniform_01<UniformRandomNumberGenerator>::BOOST_NESTED_TEMPLATE apply<RealType>::type impl_type; typedef boost::random::detail::ptr_helper<UniformRandomNumberGenerator> traits; public: uniform_01() {} explicit uniform_01(typename traits::rvalue_type rng) : impl_type(rng) { } #if !defined(BOOST_NO_OPERATORS_IN_NAMESPACE) && !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) template<class CharT, class Traits> friend std::basic_ostream<CharT,Traits>& operator<<(std::basic_ostream<CharT,Traits>& os, const uniform_01& u) { os << static_cast<const impl_type&>(u); return os; } template<class CharT, class Traits> friend std::basic_istream<CharT,Traits>& operator>>(std::basic_istream<CharT,Traits>& is, uniform_01& u) { is >> static_cast<impl_type&>(u); return is; } #endif }; #endif } // namespace boost #include <boost/random/detail/enable_warnings.hpp> #endif // BOOST_RANDOM_UNIFORM_01_HPP