mirror of https://github.com/GOSTSec/ccminer
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.
271 lines
9.0 KiB
271 lines
9.0 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 xor_combine_engine.h |
|
* \brief A pseudorandom number generator which produces pseudorandom |
|
* numbers from two integer base engines by merging their |
|
* pseudorandom numbers with bitwise exclusive-or. |
|
*/ |
|
|
|
#pragma once |
|
|
|
#include <thrust/detail/config.h> |
|
#include <thrust/detail/type_traits.h> |
|
#include <thrust/random/detail/xor_combine_engine_max.h> |
|
#include <thrust/random/detail/random_core_access.h> |
|
#include <iostream> |
|
#include <cstddef> // for size_t |
|
|
|
namespace thrust |
|
{ |
|
|
|
namespace random |
|
{ |
|
|
|
/*! \addtogroup random_number_engine_adaptors |
|
* \{ |
|
*/ |
|
|
|
/*! \class xor_combine_engine |
|
* \brief An \p xor_combine_engine adapts two existing base random number engines and |
|
* produces random values by combining the values produced by each. |
|
* |
|
* \tparam Engine1 The type of the first base random number engine to adapt. |
|
* \tparam s1 The size of the first shift to use in the generation algorithm. |
|
* \tparam Engine2 The type of the second base random number engine to adapt. |
|
* \tparam s2 The second of the second shift to use in the generation algorithm. Defaults to \c 0. |
|
* |
|
* The following code snippet shows an example of using an \p xor_combine_engine instance: |
|
* |
|
* \code |
|
* #include <thrust/random/linear_congruential_engine.h> |
|
* #include <thrust/random/xor_combine_engine.h> |
|
* #include <iostream> |
|
* |
|
* int main(void) |
|
* { |
|
* // create an xor_combine_engine from minstd_rand and minstd_rand0 |
|
* // use a shift of 0 for each |
|
* thrust::xor_combine_engine<thrust::minstd_rand,0,thrust::minstd_rand0,0> rng; |
|
* |
|
* // print a random number to standard output |
|
* std::cout << rng() << std::endl; |
|
* |
|
* return 0; |
|
* } |
|
* \endcode |
|
*/ |
|
template<typename Engine1, size_t s1, |
|
typename Engine2, size_t s2=0u> |
|
class xor_combine_engine |
|
{ |
|
public: |
|
// types |
|
|
|
/*! \typedef base1_type |
|
* \brief The type of the first adapted base random number engine. |
|
*/ |
|
typedef Engine1 base1_type; |
|
|
|
/*! \typedef base2_type |
|
* \brief The type of the second adapted base random number engine. |
|
*/ |
|
typedef Engine2 base2_type; |
|
|
|
/*! \typedef result_type |
|
* \brief The type of the unsigned integer produced by this \p xor_combine_engine. |
|
*/ |
|
typedef typename thrust::detail::eval_if< |
|
(sizeof(typename base2_type::result_type) > sizeof(typename base1_type::result_type)), |
|
thrust::detail::identity_<typename base2_type::result_type>, |
|
thrust::detail::identity_<typename base1_type::result_type> |
|
>::type result_type; |
|
|
|
/*! The size of the first shift used in the generation algorithm. |
|
*/ |
|
static const size_t shift1 = s1; |
|
|
|
/*! The size of the second shift used in the generation algorithm. |
|
*/ |
|
static const size_t shift2 = s2; |
|
|
|
/*! The smallest value this \p xor_combine_engine may potentially produce. |
|
*/ |
|
static const result_type min = 0; |
|
|
|
/*! The largest value this \p xor_combine_engine may potentially produce. |
|
*/ |
|
static const result_type max = |
|
detail::xor_combine_engine_max< |
|
Engine1, s1, Engine2, s2, result_type |
|
>::value; |
|
|
|
// constructors and seeding functions |
|
|
|
/*! This constructor constructs a new \p xor_combine_engine and constructs |
|
* its adapted engines using their null constructors. |
|
*/ |
|
__host__ __device__ |
|
xor_combine_engine(void); |
|
|
|
/*! This constructor constructs a new \p xor_combine_engine using |
|
* given \p base1_type and \p base2_type engines to initialize its adapted base engines. |
|
* |
|
* \param urng1 A \p base1_type to use to initialize this \p xor_combine_engine's |
|
* first adapted base engine. |
|
* \param urng2 A \p base2_type to use to initialize this \p xor_combine_engine's |
|
* first adapted base engine. |
|
*/ |
|
__host__ __device__ |
|
xor_combine_engine(const base1_type &urng1, const base2_type &urng2); |
|
|
|
/*! This constructor initializes a new \p xor_combine_engine with a given seed. |
|
* |
|
* \param s The seed used to intialize this \p xor_combine_engine's adapted base engines. |
|
*/ |
|
__host__ __device__ |
|
xor_combine_engine(result_type s); |
|
|
|
/*! This method initializes the state of this \p xor_combine_engine's adapted base engines |
|
* by using their \p default_seed values. |
|
*/ |
|
__host__ __device__ |
|
void seed(void); |
|
|
|
/*! This method initializes the state of this \p xor_combine_engine's adapted base engines |
|
* by using the given seed. |
|
* |
|
* \param s The seed with which to intialize this \p xor_combine_engine's adapted base engines. |
|
*/ |
|
__host__ __device__ |
|
void seed(result_type s); |
|
|
|
// generating functions |
|
|
|
/*! This member function produces a new random value and updates this \p xor_combine_engine's state. |
|
* \return A new random number. |
|
*/ |
|
__host__ __device__ |
|
result_type operator()(void); |
|
|
|
/*! This member function advances this \p xor_combine_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); |
|
|
|
// property functions |
|
|
|
/*! This member function returns a const reference to this \p xor_combine_engine's |
|
* first adapted base engine. |
|
* |
|
* \return A const reference to the first base engine this \p xor_combine_engine adapts. |
|
*/ |
|
__host__ __device__ |
|
const base1_type &base1(void) const; |
|
|
|
/*! This member function returns a const reference to this \p xor_combine_engine's |
|
* second adapted base engine. |
|
* |
|
* \return A const reference to the second base engine this \p xor_combine_engine adapts. |
|
*/ |
|
__host__ __device__ |
|
const base2_type &base2(void) const; |
|
|
|
/*! \cond |
|
*/ |
|
private: |
|
base1_type m_b1; |
|
base2_type m_b2; |
|
|
|
friend struct thrust::random::detail::random_core_access; |
|
|
|
__host__ __device__ |
|
bool equal(const xor_combine_engine &rhs) const; |
|
|
|
template<typename CharT, typename Traits> |
|
std::basic_istream<CharT,Traits>& stream_in(std::basic_istream<CharT,Traits> &is); |
|
|
|
template<typename CharT, typename Traits> |
|
std::basic_ostream<CharT,Traits>& stream_out(std::basic_ostream<CharT,Traits> &os) const; |
|
|
|
/*! \endcond |
|
*/ |
|
}; // end xor_combine_engine |
|
|
|
|
|
/*! This function checks two \p xor_combine_engines for equality. |
|
* \param lhs The first \p xor_combine_engine to test. |
|
* \param rhs The second \p xor_combine_engine to test. |
|
* \return \c true if \p lhs is equal to \p rhs; \c false, otherwise. |
|
*/ |
|
template<typename Engine1_, size_t s1_, typename Engine2_, size_t s2_> |
|
__host__ __device__ |
|
bool operator==(const xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &lhs, |
|
const xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &rhs); |
|
|
|
|
|
/*! This function checks two \p xor_combine_engines for inequality. |
|
* \param lhs The first \p xor_combine_engine to test. |
|
* \param rhs The second \p xor_combine_engine to test. |
|
* \return \c true if \p lhs is not equal to \p rhs; \c false, otherwise. |
|
*/ |
|
template<typename Engine1_, size_t s1_, typename Engine2_, size_t s2_> |
|
__host__ __device__ |
|
bool operator!=(const xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &lhs, |
|
const xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &rhs); |
|
|
|
|
|
/*! This function streams a xor_combine_engine to a \p std::basic_ostream. |
|
* \param os The \p basic_ostream to stream out to. |
|
* \param e The \p xor_combine_engine to stream out. |
|
* \return \p os |
|
*/ |
|
template<typename Engine1_, size_t s1_, typename Engine2_, size_t s2_, |
|
typename CharT, typename Traits> |
|
std::basic_ostream<CharT,Traits>& |
|
operator<<(std::basic_ostream<CharT,Traits> &os, |
|
const xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &e); |
|
|
|
|
|
/*! This function streams a xor_combine_engine in from a std::basic_istream. |
|
* \param is The \p basic_istream to stream from. |
|
* \param e The \p xor_combine_engine to stream in. |
|
* \return \p is |
|
*/ |
|
template<typename Engine1_, size_t s1_, typename Engine2_, size_t s2_, |
|
typename CharT, typename Traits> |
|
std::basic_istream<CharT,Traits>& |
|
operator>>(std::basic_istream<CharT,Traits> &is, |
|
xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &e); |
|
|
|
|
|
/*! \} // end random_number_engine_adaptors |
|
*/ |
|
|
|
|
|
} // end random |
|
|
|
// import names into thrust:: |
|
using random::xor_combine_engine; |
|
|
|
} // end thrust |
|
|
|
#include <thrust/random/detail/xor_combine_engine.inl> |
|
|
|
|