Index: boost/random/uniform_int.hpp =================================================================== --- boost/random/uniform_int.hpp (revision 43682) +++ boost/random/uniform_int.hpp (working copy) @@ -59,6 +59,49 @@ template result_type operator()(Engine& eng) { + return generate(eng, _min, _max, _range); + } + + template + result_type operator()(Engine& eng, result_type n) + { + assert(n > 0); + + if (n == 1) + { + return 0; + } + + return generate(eng, 0, n - 1, n - 1); + } + +#if !defined(BOOST_NO_OPERATORS_IN_NAMESPACE) && !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) + template + friend std::basic_ostream& + operator<<(std::basic_ostream& os, const uniform_int& ud) + { + os << ud._min << " " << ud._max; + return os; + } + + template + friend std::basic_istream& + operator>>(std::basic_istream& is, uniform_int& ud) + { +# if BOOST_WORKAROUND(_MSC_FULL_VER, BOOST_TESTED_AT(13102292)) && BOOST_MSVC == 1400 + return detail::extract_uniform_int(is, ud, ud.impl); +# else + is >> std::ws >> ud._min >> std::ws >> ud._max; + ud.init(); + return is; +# endif + } +#endif + +private: + template + static result_type generate(Engine& eng, result_type min_value, result_type max_value, range_type range) + { typedef typename Engine::result_type base_result; // ranges are always unsigned typedef typename random::detail::make_unsigned::type base_unsigned; @@ -66,25 +109,25 @@ const base_unsigned brange = random::detail::subtract()((eng.max)(), (eng.min)()); - if(_range == 0) { - return _min; - } else if(brange == _range) { + if(range == 0) { + return min_value; + } else if(brange == range) { // this will probably never happen in real life // basically nothing to do; just take care we don't overflow / underflow base_unsigned v = random::detail::subtract()(eng(), bmin); - return random::detail::add()(v, _min); - } else if(brange < _range) { + return random::detail::add()(v, min_value); + } else if(brange < range) { // use rejection method to handle things like 0..3 --> 0..4 for(;;) { // concatenate several invocations of the base RNG // take extra care to avoid overflows range_type limit; - if(_range == (std::numeric_limits::max)()) { - limit = _range/(range_type(brange)+1); - if(_range % range_type(brange)+1 == range_type(brange)) + if(range == (std::numeric_limits::max)()) { + limit = range/(range_type(brange)+1); + if(range % range_type(brange)+1 == range_type(brange)) ++limit; } else { - limit = (_range+1)/(range_type(brange)+1); + limit = (range+1)/(range_type(brange)+1); } // We consider "result" as expressed to base (brange+1): // For every power of (brange+1), we determine a random factor @@ -95,18 +138,18 @@ mult *= range_type(brange)+range_type(1); } if(mult == limit) - // _range+1 is an integer power of brange+1: no rejections required + // range+1 is an integer power of brange+1: no rejections required return result; - // _range/mult < brange+1 -> no endless loop - result += uniform_int(0, _range/mult)(eng) * mult; - if(result <= _range) - return random::detail::add()(result, _min); + // range/mult < brange+1 -> no endless loop + result += uniform_int(0, range/mult)(eng) * mult; + if(result <= range) + return random::detail::add()(result, min_value); } } else { // brange > range - if(brange / _range > 4 /* quantization_cutoff */ ) { + if(brange / range > 4 /* quantization_cutoff */ ) { // the new range is vastly smaller than the source range, // so quantization effects are not relevant - return boost::uniform_smallint(_min, _max)(eng); + return boost::uniform_smallint(min_value, max_value)(eng); } else { // use rejection method to handle cases like 0..5 -> 0..4 for(;;) { @@ -114,37 +157,13 @@ random::detail::subtract()(eng(), bmin); // result and range are non-negative, and result is possibly larger // than range, so the cast is safe - if(result <= static_cast(_range)) - return random::detail::add()(result, _min); + if(result <= static_cast(range)) + return random::detail::add()(result, min_value); } } } } -#if !defined(BOOST_NO_OPERATORS_IN_NAMESPACE) && !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) - template - friend std::basic_ostream& - operator<<(std::basic_ostream& os, const uniform_int& ud) - { - os << ud._min << " " << ud._max; - return os; - } - - template - friend std::basic_istream& - operator>>(std::basic_istream& is, uniform_int& ud) - { -# if BOOST_WORKAROUND(_MSC_FULL_VER, BOOST_TESTED_AT(13102292)) && BOOST_MSVC == 1400 - return detail::extract_uniform_int(is, ud, ud.impl); -# else - is >> std::ws >> ud._min >> std::ws >> ud._max; - ud.init(); - return is; -# endif - } -#endif - -private: void init() { _range = random::detail::subtract()(_max, _min); Index: libs/random/random_test.cpp =================================================================== --- libs/random/random_test.cpp (revision 43682) +++ libs/random/random_test.cpp (working copy) @@ -500,6 +500,72 @@ { } #endif +template +struct rand_for_random_shuffle +{ + explicit rand_for_random_shuffle(EngineT &engine) + : m_engine(engine) + { } + + template + IntT operator()(IntT upperBound) + { + assert(upperBound > 0); + + if (upperBound == 1) + { + return 0; + } + + typedef boost::uniform_int distribution_type; + typedef boost::variate_generator generator_type; + + return generator_type(m_engine, distribution_type(0, upperBound - 1))(); + } + + EngineT &m_engine; + +}; + +// Test that uniform_int<> can be used with std::random_shuffle +// Author: Jos Hickson +void test_random_shuffle() +{ + typedef boost::uniform_int<> distribution_type; + typedef boost::variate_generator generator_type; + + boost::mt19937 engine1(1234); + boost::mt19937 engine2(1234); + + rand_for_random_shuffle referenceRand(engine1); + + distribution_type dist(0,10); + generator_type testRand(engine2, dist); + + std::vector referenceVec; + + for (int i = 0; i < 200; ++i) + { + referenceVec.push_back(i); + } + + std::vector testVec(referenceVec); + + std::random_shuffle(referenceVec.begin(), referenceVec.end(), referenceRand); + std::random_shuffle(testVec.begin(), testVec.end(), testRand); + + typedef std::vector::iterator iter_type; + iter_type theEnd(referenceVec.end()); + + for (iter_type referenceIter(referenceVec.begin()), testIter(testVec.begin()); + referenceIter != theEnd; + ++referenceIter, ++testIter) + { + BOOST_CHECK_EQUAL(*referenceIter, *testIter); + } +} + + int test_main(int, char*[]) { @@ -528,6 +594,7 @@ << std::endl; test_overflow_range(); + test_random_shuffle(); return 0; #else