GOSTCoin CUDA miner project, compatible with most nvidia cards, containing only gostd algo
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

/*
* 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>