MCKL
Monte Carlo Kernel Library
Classes | Namespaces | Macros | Typedefs | Functions
random/internal/common.hpp File Reference
#include <mckl/internal/common.hpp>

Go to the source code of this file.

Classes

class  mckl::ArcsineDistribution< RealType >
 Arcsine distribution. More...
 
class  mckl::BernoulliDistribution< IntType >
 Bernoulli distribution. More...
 
class  mckl::BetaDistribution< RealType >
 Beta distribution. More...
 
class  mckl::CauchyDistribution< RealType >
 Cauchy distribution. More...
 
class  mckl::ChiSquaredDistribution< RealType >
 The \(\chi^2\) distribution. More...
 
class  mckl::DirichletDistribution< RealType >
 
class  mckl::DiscreteDistribution< IntType >
 Draw a single sample given weights. More...
 
class  mckl::ExponentialDistribution< RealType >
 Exponential distribution. More...
 
class  mckl::ExtremeValueDistribution< RealType >
 Extreme value distribution. More...
 
class  mckl::FisherFDistribution< RealType >
 Fisher-F distribution. More...
 
class  mckl::GammaDistribution< RealType >
 Gamma distribution. More...
 
class  mckl::GeometricDistribution< IntType >
 Geometric distribution. More...
 
class  mckl::internal::DummyDistribution< DistributionType >
 
class  mckl::internal::DummyRNG
 
class  mckl::internal::IncrementBlockSI128< T, size_t, size_t, int >
 
class  mckl::internal::IncrementBlockSI256< T, size_t, size_t, int >
 
class  mckl::internal::IncrementBlockSI512< T, size_t, size_t, int >
 
class  mckl::LaplaceDistribution< RealType >
 Laplace distribution. More...
 
class  mckl::LevyDistribution< RealType >
 Levy distribution. More...
 
class  mckl::LogisticDistribution< RealType >
 Logistic distribution. More...
 
class  mckl::LognormalDistribution< RealType >
 Lognormal distribution. More...
 
class  mckl::NormalDistribution< RealType >
 Normal distribution. More...
 
class  mckl::NormalMVDistribution< RealType >
 Multivariate Normal distribution. More...
 
class  mckl::ParetoDistribution< RealType >
 Pareto distribution. More...
 
class  mckl::RayleighDistribution< RealType >
 Rayleigh distribution. More...
 
class  mckl::RNGTraits< RNGType >
 Traits of RNG engines. More...
 
class  mckl::SamplingDistribution< IntType >
 Drawing a subset without replacement. More...
 
class  mckl::SeedTrait< typename >
 
class  mckl::StableDistribution< RealType >
 Stable distribution. More...
 
class  mckl::StudentTDistribution< RealType >
 Student-t distribution. More...
 
class  mckl::U01CanonicalDistribution< RealType >
 Standard uniform distribution on [0, 1) More...
 
class  mckl::U01CCDistribution< RealType >
 Standard uniform distribution on [0, 1]. More...
 
class  mckl::U01CODistribution< RealType >
 Standard uniform distribution on [0, 1) More...
 
class  mckl::U01OCDistribution< RealType >
 Standard uniform distribution on (0, 1]. More...
 
class  mckl::U01OODistribution< RealType >
 Standard uniform distribution on (0, 1) More...
 
class  mckl::UniformBitsDistribution< UIntType >
 Uniform bits distribution. More...
 
class  mckl::UniformIntDistribution< IntType >
 Uniform integer distribution. More...
 
class  mckl::UniformRealDistribution< RealType >
 Uniform real distribution. More...
 
class  mckl::WeibullDistribution< RealType >
 Weibull distribution. More...
 

Namespaces

 mckl
 
 mckl::internal
 

Macros

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_0(Name, name, T)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_1(Name, name, T, T1, p1, v1)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_2( Name, name, T, T1, p1, v1, T2, p2, v2)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_4( Name, name, T, T1, p1, v1, T2, p2, v2, T3, p3, v3, T4, p4, v4)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_ASSERT_BLAS_TYPE(Name)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_ASSERT_INT_TYPE(Name, MinBits)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_ASSERT_REAL_TYPE(Name)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_ASSERT_REAL_TYPE(Name)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_ASSERT_UINT_TYPE(Name, MinBits)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_BATCH_0(Name, name, T)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_BATCH_1(Name, name, T, T1, p1)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_BATCH_2( Name, name, T, T1, p1, T2, p2)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_BATCH_4( Name, name, T, T1, p1, T2, p2, T3, p3, T4, p4)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_CONSTRUCTOR_0(Name, T)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_CONSTRUCTOR_1(Name, T, T1, p1, v1)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_CONSTRUCTOR_2( Name, T, T1, p1, v1, T2, p2, v2)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_CONSTRUCTOR_4( Name, T, T1, p1, v1, T2, p2, v2, T3, p3, v3, T4, p4, v4)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_MEMBER_0
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_MEMBER_1(T1, m1)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_MEMBER_2(T1, m1, T2, m2)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_OPERATOR(Name, name)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_0(Name, T)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_1( Name, name, T, T1, p1, v1)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_2( Name, name, T, T1, p1, v1, T2, p2, v2)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_4( Name, name, T, T1, p1, v1, T2, p2, v2, T3, p3, v3, T4, p4, v4)
 
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_RAND(Name, T)
 
#define MCKL_DEFINE_RANDOM_TEST_OPERATOR(ResultType)
 

Typedefs

template<typename RNGType >
using mckl::SeedType = typename SeedTrait< RNGType >::type
 

Functions

template<typename IntType , IntType D, typename RealType >
IntType mckl::internal::ftoi (RealType r)
 
template<typename IntType , typename RealType >
IntType mckl::internal::ftoi (RealType x, std::true_type)
 
template<typename IntType , typename RealType >
IntType mckl::internal::ftoi (RealType x, std::false_type)
 
template<typename IntType , typename RealType >
IntType mckl::internal::ftoi (RealType x)
 
void mckl::internal::group_np (double n, const Vector< double > &np_all, Vector< double > &np, std::size_t &kmin, std::size_t &kmax)
 
template<std::size_t N, typename ResultType >
std::size_t mckl::internal::permutation_imax (ResultType *r)
 
template<std::size_t T, typename ResultType >
std::size_t mckl::internal::permutation_index (ResultType *r)
 
template<std::size_t N, typename ResultType >
void mckl::internal::permutation_sort (ResultType *, std::size_t &, std::false_type)
 
template<std::size_t N, typename ResultType >
void mckl::internal::permutation_sort (ResultType *r, std::size_t &f, std::true_type)
 
template<typename RNGType >
RNGType::result_type mckl::rand (RNGType &rng)
 Generate random integers. More...
 
template<typename RNGType >
void mckl::rand (RNGType &rng, std::size_t n, typename RNGType::result_type *r)
 Generate random integers. More...
 
template<typename RNGType , typename DistributionType >
DistributionType::result_type mckl::rand (RNGType &rng, DistributionType &distribution)
 Generate distribution random variates. More...
 
template<typename RNGType , typename DistributionType >
void mckl::rand (RNGType &rng, DistributionType &distribution, std::size_t n, typename DistributionType::result_type *r)
 Generate distribution random variates. More...
 
template<std::size_t N, std::size_t D, std::size_t T>
std::size_t mckl::internal::serial_index (const std::size_t *, std::false_type)
 
template<std::size_t N, std::size_t D, std::size_t T>
std::size_t mckl::internal::serial_index (const std::size_t *s, std::true_type)
 
template<std::size_t D, std::size_t T, typename ResultType >
std::size_t mckl::internal::serial_index (const ResultType *r)
 

Macro Definition Documentation

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_0

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_0 (   Name,
  name,
  T 
)
Value:
MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_0(Name, T) \
MCKL_DEFINE_RANDOM_DISTRIBUTION_CONSTRUCTOR_0(Name, T) \
MCKL_DEFINE_RANDOM_DISTRIBUTION_OPERATOR(Name, name)
MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_0
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_0(Name, T)
Definition: random/internal/common.hpp:153

Definition at line 714 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_1

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_1 (   Name,
  name,
  T,
  T1,
  p1,
  v1 
)
Value:
MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_1(Name, name, T, T1, p1, v1) \
MCKL_DEFINE_RANDOM_DISTRIBUTION_CONSTRUCTOR_1(Name, T, T1, p1, v1) \
MCKL_DEFINE_RANDOM_DISTRIBUTION_OPERATOR(Name, name)
MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_1
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_1( Name, name, T, T1, p1, v1)
Definition: random/internal/common.hpp:189

Definition at line 719 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_2

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_2 (   Name,
  name,
  T,
  T1,
  p1,
  v1,
  T2,
  p2,
  v2 
)
Value:
MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_2( \
Name, name, T, T1, p1, v1, T2, p2, v2) \
MCKL_DEFINE_RANDOM_DISTRIBUTION_CONSTRUCTOR_2( \
Name, T, T1, p1, v1, T2, p2, v2) \
MCKL_DEFINE_RANDOM_DISTRIBUTION_OPERATOR(Name, name)
MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_2
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_2( Name, name, T, T1, p1, v1, T2, p2, v2)
Definition: random/internal/common.hpp:265

Definition at line 724 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_4

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_4 (   Name,
  name,
  T,
  T1,
  p1,
  v1,
  T2,
  p2,
  v2,
  T3,
  p3,
  v3,
  T4,
  p4,
  v4 
)
Value:
MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_4( \
Name, name, T, T1, p1, v1, T2, p2, v2, T3, p3, v3, T4, p4, v4) \
MCKL_DEFINE_RANDOM_DISTRIBUTION_CONSTRUCTOR_4( \
Name, T, T1, p1, v1, T2, p2, v2, T3, p3, v3, T4, p4, v4) \
MCKL_DEFINE_RANDOM_DISTRIBUTION_OPERATOR(Name, name)
MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_4
#define MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_4( Name, name, T, T1, p1, v1, T2, p2, v2, T3, p3, v3, T4, p4, v4)
Definition: random/internal/common.hpp:350

Definition at line 732 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_ASSERT_BLAS_TYPE

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_ASSERT_BLAS_TYPE (   Name)
Value:
static_assert(::mckl::internal::is_blas_floating_point<RealType>::value, \
"**" #Name \
"Distribution** used with RealType other than float or double");
mckl::internal::is_blas_floating_point
std::integral_constant< bool, std::is_same< typename std::remove_cv< T >::type, float >::value||std::is_same< typename std::remove_cv< T >::type, double >::value > is_blas_floating_point
Definition: traits.hpp:180

Definition at line 42 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_ASSERT_INT_TYPE

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_ASSERT_INT_TYPE (   Name,
  MinBits 
)
Value:
static_assert(std::is_integral<IntType>::value, \
"**" #Name \
"Distribution** used with IntType other than integer types"); \
static_assert(CHAR_BIT * sizeof(IntType) >= MinBits, \
"**" #Name "Distribution** used with IntType smaller than " #MinBits \
" bits");

Definition at line 47 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_ASSERT_REAL_TYPE [1/2]

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_ASSERT_REAL_TYPE (   Name)
Value:
static_assert(std::is_floating_point<RealType>::value, \
"**" #Name \
"Distribution** used with RealType other than floating point types");

Definition at line 64 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_ASSERT_REAL_TYPE [2/2]

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_ASSERT_REAL_TYPE (   Name)
Value:
static_assert(std::is_floating_point<RealType>::value, \
"**" #Name \
"Distribution** used with RealType other than floating point types");

Definition at line 64 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_ASSERT_UINT_TYPE

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_ASSERT_UINT_TYPE (   Name,
  MinBits 
)
Value:
static_assert(std::is_unsigned<UIntType>::value, \
"**" #Name \
"Distribution** used with UIntType other than unsigned integer " \
"types"); \
static_assert(std::numeric_limits<UIntType>::digits >= MinBits, \
"**" #Name "Distribution** used with IntType smaller than " #MinBits \
" bits");

Definition at line 55 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_BATCH_0

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_BATCH_0 (   Name,
  name,
  T 
)
Value:
template <typename T, typename RNGType> \
inline void name##_distribution(RNGType &rng, std::size_t n, T *r) \
{ \
const std::size_t K = BufferSize<T>::value; \
const std::size_t M = n / K; \
const std::size_t L = n % K; \
for (std::size_t i = 0; i != M; ++i, r += K) \
::mckl::internal::name##_distribution_impl<K>(rng, K, r); \
::mckl::internal::name##_distribution_impl<K>(rng, L, r); \
} \
\
template <typename T, typename RNGType> \
inline void name##_distribution(RNGType &rng, std::size_t N, T *r, \
const typename Name##Distribution<T>::param_type &) \
{ \
name##_distribution(rng, N, r); \
}

Definition at line 69 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_BATCH_1

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_BATCH_1 (   Name,
  name,
  T,
  T1,
  p1 
)
Value:
template <typename T, typename RNGType> \
inline void name##_distribution(RNGType &rng, std::size_t N, T *r, T1 p1) \
{ \
const std::size_t K = BufferSize<T>::value; \
const std::size_t M = N / K; \
const std::size_t L = N % K; \
for (std::size_t i = 0; i != M; ++i, r += K) \
::mckl::internal::name##_distribution_impl<K>(rng, K, r, p1); \
::mckl::internal::name##_distribution_impl<K>(rng, L, r, p1); \
} \
\
template <typename T, typename RNGType> \
inline void name##_distribution(RNGType &rng, std::size_t N, T *r, \
const typename Name##Distribution<T>::param_type &param) \
{ \
name##_distribution(rng, N, r, param.p1()); \
}

Definition at line 88 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_BATCH_2

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_BATCH_2 (   Name,
  name,
  T,
  T1,
  p1,
  T2,
  p2 
)
Value:
template <typename T, typename RNGType> \
inline void name##_distribution( \
RNGType &rng, std::size_t N, T *r, T1 p1, T2 p2) \
{ \
const std::size_t K = BufferSize<T>::value; \
const std::size_t M = N / K; \
const std::size_t L = N % K; \
for (std::size_t i = 0; i != M; ++i, r += K) \
::mckl::internal::name##_distribution_impl<K>(rng, K, r, p1, p2); \
::mckl::internal::name##_distribution_impl<K>(rng, L, r, p1, p2); \
} \
\
template <typename T, typename RNGType> \
inline void name##_distribution(RNGType &rng, std::size_t N, T *r, \
const typename Name##Distribution<T>::param_type &param) \
{ \
name##_distribution(rng, N, r, param.p1(), param.p2()); \
}

Definition at line 107 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_BATCH_4

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_BATCH_4 (   Name,
  name,
  T,
  T1,
  p1,
  T2,
  p2,
  T3,
  p3,
  T4,
  p4 
)
Value:
template <typename T, typename RNGType> \
inline void name##_distribution( \
RNGType &rng, std::size_t N, T *r, T1 p1, T2 p2, T3 p3, T4 p4) \
{ \
const std::size_t K = BufferSize<T>::value; \
const std::size_t M = N / K; \
const std::size_t L = N % K; \
for (std::size_t i = 0; i != M; ++i, r += K) { \
::mckl::internal::name##_distribution_impl<K>( \
rng, K, r, p1, p2, p3, p4); \
} \
::mckl::internal::name##_distribution_impl<K>( \
rng, L, r, p1, p2, p3, p4); \
} \
\
template <typename T, typename RNGType> \
inline void name##_distribution(RNGType &rng, std::size_t N, T *r, \
const typename Name##Distribution<T>::param_type &param) \
{ \
name##_distribution( \
rng, N, r, param.p1(), param.p2(), param.p3(), param.p4()); \
}

Definition at line 128 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_CONSTRUCTOR_0

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_CONSTRUCTOR_0 (   Name,
  T 
)
Value:
public: \
using result_type = T; \
using distribution_type = Name##Distribution<T>; \
\
Name##Distribution() = default; \
explicit Name##Distribution(const param_type &) { reset(); } \
explicit Name##Distribution(param_type &&) { reset(); }

Definition at line 453 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_CONSTRUCTOR_1

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_CONSTRUCTOR_1 (   Name,
  T,
  T1,
  p1,
  v1 
)
Value:
public: \
using result_type = T; \
using distribution_type = Name##Distribution<T>; \
\
explicit Name##Distribution(T1 p1 = v1) : param_(p1) { reset(); } \
\
explicit Name##Distribution(const param_type &param) : param_(param) \
{ \
reset(); \
} \
\
explicit Name##Distribution(param_type &&param) \
: param_(std::move(param)) \
{ \
reset(); \
} \
\
T1 p1() const { return param_.p1(); }

Definition at line 462 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_CONSTRUCTOR_2

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_CONSTRUCTOR_2 (   Name,
  T,
  T1,
  p1,
  v1,
  T2,
  p2,
  v2 
)
Value:
public: \
using result_type = T; \
using distribution_type = Name##Distribution<T>; \
\
explicit Name##Distribution(T1 p1 = v1, T2 p2 = v2) : param_(p1, p2) \
{ \
reset(); \
} \
\
explicit Name##Distribution(const param_type &param) : param_(param) \
{ \
reset(); \
} \
\
explicit Name##Distribution(param_type &&param) \
: param_(std::move(param)) \
{ \
reset(); \
} \
\
T1 p1() const { return param_.p1(); } \
T2 p2() const { return param_.p2(); }

Definition at line 482 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_CONSTRUCTOR_4

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_CONSTRUCTOR_4 (   Name,
  T,
  T1,
  p1,
  v1,
  T2,
  p2,
  v2,
  T3,
  p3,
  v3,
  T4,
  p4,
  v4 
)
Value:
public: \
using result_type = T; \
using distribution_type = Name##Distribution<T>; \
\
explicit Name##Distribution( \
T1 p1 = v1, T2 p2 = v2, T3 p3 = v3, T4 p4 = v4) \
: param_(p1, p2, p3, p4) \
{ \
reset(); \
} \
\
explicit Name##Distribution(const param_type &param) : param_(param) \
{ \
reset(); \
} \
\
explicit Name##Distribution(param_type &&param) \
: param_(std::move(param)) \
{ \
reset(); \
} \
\
T1 p1() const { return param_.p1(); } \
T2 p2() const { return param_.p2(); } \
T3 p3() const { return param_.p3(); } \
T4 p4() const { return param_.p4(); }

Definition at line 507 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_MEMBER_0

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_MEMBER_0
Value:
private: \
bool is_equal(const distribution_type &) const { return true; } \
\
template <typename CharT, typename Traits> \
void ostream(std::basic_ostream<CharT, Traits> &) const \
{ \
} \
\
template <typename CharT, typename Traits> \
void istream(std::basic_istream<CharT, Traits> &) \
{ \
}
mckl::internal::ostream
std::basic_ostream< CharT, Traits > & ostream(std::basic_ostream< CharT, Traits > &os, const std::array< T, N > &ary)
Definition: iostream.hpp:46
mckl::is_equal
bool is_equal(const float &v1, const float &v2)
Definition: is_equal.hpp:41
mckl::internal::istream
std::basic_istream< CharT, Traits > & istream(std::basic_istream< CharT, Traits > &is, std::array< T, N > &ary)
Definition: iostream.hpp:66

Definition at line 536 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_MEMBER_1

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_MEMBER_1 (   T1,
  m1 
)

Definition at line 550 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_MEMBER_2

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_MEMBER_2 (   T1,
  m1,
  T2,
  m2 
)

Definition at line 583 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_OPERATOR

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_OPERATOR (   Name,
  name 
)

Definition at line 623 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_0

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_0 (   Name,
  T 
)

Definition at line 153 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_1

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_1 (   Name,
  name,
  T,
  T1,
  p1,
  v1 
)

Definition at line 189 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_2

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_2 (   Name,
  name,
  T,
  T1,
  p1,
  v1,
  T2,
  p2,
  v2 
)

Definition at line 265 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_4

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_PARAM_TYPE_4 (   Name,
  name,
  T,
  T1,
  p1,
  v1,
  T2,
  p2,
  v2,
  T3,
  p3,
  v3,
  T4,
  p4,
  v4 
)

Definition at line 350 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_DISTRIBUTION_RAND

#define MCKL_DEFINE_RANDOM_DISTRIBUTION_RAND (   Name,
  T 
)
Value:
template <typename T, typename RNGType> \
inline void rand(RNGType &rng, Name##Distribution<T> &distribution, \
std::size_t N, T *r) \
{ \
distribution(rng, N, r); \
}
mckl::rand
void rand(RNGType &rng, DistributionType &distribution, std::size_t n, typename DistributionType::result_type *r)
Generate distribution random variates.
Definition: random/internal/common.hpp:996

Definition at line 706 of file random/internal/common.hpp.

◆ MCKL_DEFINE_RANDOM_TEST_OPERATOR

#define MCKL_DEFINE_RANDOM_TEST_OPERATOR (   ResultType)
Value:
template <typename DistributionType> \
ResultType operator()(DistributionType &&distribution) \
{ \
::mckl::internal::DummyRNG rng; \
::mckl::internal::DummyDistribution<DistributionType> dist( \
distribution); \
\
return operator()(rng, dist); \
}

Definition at line 740 of file random/internal/common.hpp.

Generated by   doxygen 1.8.13