You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
230 lines
7.3 KiB
230 lines
7.3 KiB
/* |
|
* Copyright 2008-2012 NVIDIA Corporation |
|
* |
|
* Licensed under the Apache License, Version 2.0 (the "License"); |
|
* you may not use this file except in compliance with the License. |
|
* You may obtain a copy of the License at |
|
* |
|
* http://www.apache.org/licenses/LICENSE-2.0 |
|
* |
|
* Unless required by applicable law or agreed to in writing, software |
|
* distributed under the License is distributed on an "AS IS" BASIS, |
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
* See the License for the specific language governing permissions and |
|
* limitations under the License. |
|
*/ |
|
|
|
/*! \file linear_feedback_shift_engine.h |
|
* \brief A linear feedback shift pseudorandom number generator. |
|
*/ |
|
|
|
/* |
|
* Copyright Jens Maurer 2002 |
|
* |
|
* Distributed under the Boost Software License, Version 1.0. |
|
* (See accompanying NOTICE file for the complete license) |
|
* |
|
* For more information, see http://www.boost.org |
|
*/ |
|
|
|
#pragma once |
|
|
|
#include <thrust/detail/config.h> |
|
#include <thrust/random/detail/linear_feedback_shift_engine_wordmask.h> |
|
#include <iostream> |
|
#include <cstddef> // for size_t |
|
#include <thrust/random/detail/random_core_access.h> |
|
|
|
namespace thrust |
|
{ |
|
|
|
|
|
namespace random |
|
{ |
|
|
|
/*! \addtogroup random_number_engine_templates |
|
* \{ |
|
*/ |
|
|
|
/*! \class linear_feedback_shift_engine |
|
* \brief A \p linear_feedback_shift_engine random number engine produces |
|
* unsigned integer random values using a linear feedback shift random number |
|
* generation algorithm. |
|
* |
|
* \tparam UIntType The type of unsigned integer to produce. |
|
* \tparam w The word size of the produced values (<tt>w <= sizeof(UIntType)</tt>). |
|
* \tparam k The k parameter of Tausworthe's 1965 algorithm. |
|
* \tparam q The q exponent of Tausworthe's 1965 algorithm. |
|
* \tparam s The step size of Tausworthe's 1965 algorithm. |
|
* |
|
* \note linear_feedback_shift_engine is based on the Boost Template Library's linear_feedback_shift. |
|
*/ |
|
template<typename UIntType, size_t w, size_t k, size_t q, size_t s> |
|
class linear_feedback_shift_engine |
|
{ |
|
public: |
|
// types |
|
|
|
/*! \typedef result_type |
|
* \brief The type of the unsigned integer produced by this \p linear_feedback_shift_engine. |
|
*/ |
|
typedef UIntType result_type; |
|
|
|
// engine characteristics |
|
|
|
/*! The word size of the produced values. |
|
*/ |
|
static const size_t word_size = w; |
|
|
|
/*! A constant used in the generation algorithm. |
|
*/ |
|
static const size_t exponent1 = k; |
|
|
|
/*! A constant used in the generation algorithm. |
|
*/ |
|
static const size_t exponent2 = q; |
|
|
|
/*! The step size used in the generation algorithm. |
|
*/ |
|
static const size_t step_size = s; |
|
|
|
/*! \cond |
|
*/ |
|
private: |
|
static const result_type wordmask = |
|
detail::linear_feedback_shift_engine_wordmask< |
|
result_type, |
|
w |
|
>::value; |
|
/*! \endcond |
|
*/ |
|
|
|
public: |
|
|
|
/*! The smallest value this \p linear_feedback_shift_engine may potentially produce. |
|
*/ |
|
static const result_type min = 0; |
|
|
|
/*! The largest value this \p linear_feedback_shift_engine may potentially produce. |
|
*/ |
|
static const result_type max = wordmask; |
|
|
|
/*! The default seed of this \p linear_feedback_shift_engine. |
|
*/ |
|
static const result_type default_seed = 341u; |
|
|
|
// constructors and seeding functions |
|
|
|
/*! This constructor, which optionally accepts a seed, initializes a new |
|
* \p linear_feedback_shift_engine. |
|
* |
|
* \param value The seed used to intialize this \p linear_feedback_shift_engine's state. |
|
*/ |
|
__host__ __device__ |
|
explicit linear_feedback_shift_engine(result_type value = default_seed); |
|
|
|
/*! This method initializes this \p linear_feedback_shift_engine's state, and optionally accepts |
|
* a seed value. |
|
* |
|
* \param value The seed used to initializes this \p linear_feedback_shift_engine's state. |
|
*/ |
|
__host__ __device__ |
|
void seed(result_type value = default_seed); |
|
|
|
// generating functions |
|
|
|
/*! This member function produces a new random value and updates this \p linear_feedback_shift_engine's state. |
|
* \return A new random number. |
|
*/ |
|
__host__ __device__ |
|
result_type operator()(void); |
|
|
|
/*! This member function advances this \p linear_feedback_shift_engine's state a given number of times |
|
* and discards the results. |
|
* |
|
* \param z The number of random values to discard. |
|
* \note This function is provided because an implementation may be able to accelerate it. |
|
*/ |
|
__host__ __device__ |
|
void discard(unsigned long long z); |
|
|
|
/*! \cond |
|
*/ |
|
private: |
|
result_type m_value; |
|
|
|
friend struct thrust::random::detail::random_core_access; |
|
|
|
__host__ __device__ |
|
bool equal(const linear_feedback_shift_engine &rhs) const; |
|
|
|
template<typename CharT, typename Traits> |
|
std::basic_ostream<CharT,Traits>& stream_out(std::basic_ostream<CharT,Traits> &os) const; |
|
|
|
template<typename CharT, typename Traits> |
|
std::basic_istream<CharT,Traits>& stream_in(std::basic_istream<CharT,Traits> &is); |
|
|
|
/*! \endcond |
|
*/ |
|
}; // end linear_feedback_shift_engine |
|
|
|
|
|
/*! This function checks two \p linear_feedback_shift_engines for equality. |
|
* \param lhs The first \p linear_feedback_shift_engine to test. |
|
* \param rhs The second \p linear_feedback_shift_engine to test. |
|
* \return \c true if \p lhs is equal to \p rhs; \c false, otherwise. |
|
*/ |
|
template<typename UIntType_, size_t w_, size_t k_, size_t q_, size_t s_> |
|
__host__ __device__ |
|
bool operator==(const linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &lhs, |
|
const linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &rhs); |
|
|
|
|
|
/*! This function checks two \p linear_feedback_shift_engines for inequality. |
|
* \param lhs The first \p linear_feedback_shift_engine to test. |
|
* \param rhs The second \p linear_feedback_shift_engine to test. |
|
* \return \c true if \p lhs is not equal to \p rhs; \c false, otherwise. |
|
*/ |
|
template<typename UIntType_, size_t w_, size_t k_, size_t q_, size_t s_> |
|
__host__ __device__ |
|
bool operator!=(const linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &lhs, |
|
const linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &rhs); |
|
|
|
|
|
/*! This function streams a linear_feedback_shift_engine to a \p std::basic_ostream. |
|
* \param os The \p basic_ostream to stream out to. |
|
* \param e The \p linear_feedback_shift_engine to stream out. |
|
* \return \p os |
|
*/ |
|
template<typename UIntType_, size_t w_, size_t k_, size_t q_, size_t s_, |
|
typename CharT, typename Traits> |
|
std::basic_ostream<CharT,Traits>& |
|
operator<<(std::basic_ostream<CharT,Traits> &os, |
|
const linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &e); |
|
|
|
|
|
/*! This function streams a linear_feedback_shift_engine in from a std::basic_istream. |
|
* \param is The \p basic_istream to stream from. |
|
* \param e The \p linear_feedback_shift_engine to stream in. |
|
* \return \p is |
|
*/ |
|
template<typename UIntType_, size_t w_, size_t k_, size_t q_, size_t s_, |
|
typename CharT, typename Traits> |
|
std::basic_istream<CharT,Traits>& |
|
operator>>(std::basic_istream<CharT,Traits> &is, |
|
linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &e); |
|
|
|
|
|
/*! \} // end random_number_engine_templates |
|
*/ |
|
|
|
|
|
} // end random |
|
|
|
// import names into thrust:: |
|
using random::linear_feedback_shift_engine; |
|
|
|
} // end thrust |
|
|
|
#include <thrust/random/detail/linear_feedback_shift_engine.inl> |
|
|
|
|