120 lines
3.6 KiB
Plaintext
120 lines
3.6 KiB
Plaintext
//---------------------------------------------------------------------------//
|
|
// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com>
|
|
//
|
|
// 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://boostorg.github.com/compute for more information.
|
|
//---------------------------------------------------------------------------//
|
|
|
|
#ifndef BOOST_COMPUTE_RANDOM_UNIFORM_INT_DISTRIBUTION_HPP
|
|
#define BOOST_COMPUTE_RANDOM_UNIFORM_INT_DISTRIBUTION_HPP
|
|
|
|
#include <limits>
|
|
|
|
#include <boost/type_traits.hpp>
|
|
#include <boost/static_assert.hpp>
|
|
|
|
#include <boost/compute/command_queue.hpp>
|
|
#include <boost/compute/container/vector.hpp>
|
|
#include <boost/compute/function.hpp>
|
|
#include <boost/compute/types/fundamental.hpp>
|
|
#include <boost/compute/algorithm/copy_if.hpp>
|
|
#include <boost/compute/algorithm/transform.hpp>
|
|
|
|
namespace boost {
|
|
namespace compute {
|
|
|
|
/// \class uniform_int_distribution
|
|
/// \brief Produces uniformily distributed random integers
|
|
///
|
|
/// The following example shows how to setup a uniform int distribution to
|
|
/// produce random integers 0 and 1.
|
|
///
|
|
/// \snippet test/test_uniform_int_distribution.cpp generate
|
|
///
|
|
template<class IntType = uint_>
|
|
class uniform_int_distribution
|
|
{
|
|
public:
|
|
typedef IntType result_type;
|
|
|
|
/// Creates a new uniform distribution producing numbers in the range
|
|
/// [\p a, \p b].
|
|
explicit uniform_int_distribution(IntType a = 0,
|
|
IntType b = (std::numeric_limits<IntType>::max)())
|
|
: m_a(a),
|
|
m_b(b)
|
|
{
|
|
}
|
|
|
|
/// Destroys the uniform_int_distribution object.
|
|
~uniform_int_distribution()
|
|
{
|
|
}
|
|
|
|
/// Returns the minimum value of the distribution.
|
|
result_type a() const
|
|
{
|
|
return m_a;
|
|
}
|
|
|
|
/// Returns the maximum value of the distribution.
|
|
result_type b() const
|
|
{
|
|
return m_b;
|
|
}
|
|
|
|
/// Generates uniformily distributed integers and stores
|
|
/// them to the range [\p first, \p last).
|
|
template<class OutputIterator, class Generator>
|
|
void generate(OutputIterator first,
|
|
OutputIterator last,
|
|
Generator &generator,
|
|
command_queue &queue)
|
|
{
|
|
size_t size = std::distance(first, last);
|
|
typedef typename Generator::result_type g_result_type;
|
|
|
|
vector<g_result_type> tmp(size, queue.get_context());
|
|
vector<g_result_type> tmp2(size, queue.get_context());
|
|
|
|
uint_ bound = ((uint_(-1))/(m_b-m_a+1))*(m_b-m_a+1);
|
|
|
|
buffer_iterator<g_result_type> tmp2_iter;
|
|
|
|
while(size>0)
|
|
{
|
|
generator.generate(tmp.begin(), tmp.begin() + size, queue);
|
|
tmp2_iter = copy_if(tmp.begin(), tmp.begin() + size, tmp2.begin(),
|
|
_1 <= bound, queue);
|
|
size = std::distance(tmp2_iter, tmp2.end());
|
|
}
|
|
|
|
BOOST_COMPUTE_FUNCTION(IntType, scale_random, (const g_result_type x),
|
|
{
|
|
return LO + (x % (HI-LO+1));
|
|
});
|
|
|
|
scale_random.define("LO", boost::lexical_cast<std::string>(m_a));
|
|
scale_random.define("HI", boost::lexical_cast<std::string>(m_b));
|
|
|
|
transform(tmp2.begin(), tmp2.end(), first, scale_random, queue);
|
|
}
|
|
|
|
private:
|
|
IntType m_a;
|
|
IntType m_b;
|
|
|
|
BOOST_STATIC_ASSERT_MSG(
|
|
boost::is_integral<IntType>::value,
|
|
"Template argument must be integral"
|
|
);
|
|
};
|
|
|
|
} // end compute namespace
|
|
} // end boost namespace
|
|
|
|
#endif // BOOST_COMPUTE_RANDOM_UNIFORM_INT_DISTRIBUTION_HPP
|