int main()
{
typedef qfcl::random::cpp_rand ENG;
typedef qfcl::random::normal_box_muller_polar<> DIST1;
typedef qfcl::random::normal_box_muller<> DIST2;
typedef qfcl::random::normal_inversion<> DIST3;
ENG eng;
DIST1 dist1;
DIST2 dist2;
DIST3 dist3;
qfcl::random::variate_generator< ENG, DIST1 > rng1(eng, dist1);
qfcl::random::variate_generator< ENG, DIST2 > rng2(eng, dist2);
qfcl::random::variate_generator< ENG, DIST3 > rng3(eng, dist3);
for (int i=0; i<10; ++i) {
std::cout << rng1() << " " << rng2() << " " << rng3() << std::endl;
}
return 0;
}
TEST(AESCTRDRNG, SeedConsistency)
{
AESCTRDRBG rng1("seed1", "seed1") ;
AESCTRDRBG rng2("seed1", "seed1") ;
AESCTRDRBG rng3("seed2", "seed1") ;
AESCTRDRBG rng4("seed1", "seed2") ;
AESCTRDRBG rng5("seed2", "seed2") ;
AESCTRDRBG rng6("seed2", "seed2") ;
std::vector<uint8_t> bits[6] ;
for(int r=0;r<5;r++)
{
std::vector<uint8_t> tmp ;
tmp = rng1.GetBits(128) ;
bits[0].insert(bits[0].end(), tmp.begin(), tmp.end()) ;
tmp = rng2.GetBits(128) ;
bits[1].insert(bits[1].end(), tmp.begin(), tmp.end()) ;
tmp = rng3.GetBits(128) ;
bits[2].insert(bits[2].end(), tmp.begin(), tmp.end()) ;
tmp = rng4.GetBits(128) ;
bits[3].insert(bits[3].end(), tmp.begin(), tmp.end()) ;
tmp = rng5.GetBits(128) ;
bits[4].insert(bits[4].end(), tmp.begin(), tmp.end()) ;
tmp = rng6.GetBits(128) ;
bits[5].insert(bits[5].end(), tmp.begin(), tmp.end()) ;
}
ASSERT_EQ(bits[0], bits[1]) ;
ASSERT_EQ(bits[4], bits[5]) ;
ASSERT_NE(bits[1], bits[2]) ;
ASSERT_NE(bits[1], bits[3]) ;
ASSERT_NE(bits[1], bits[4]) ;
ASSERT_NE(bits[2], bits[3]) ;
ASSERT_NE(bits[2], bits[4]) ;
ASSERT_NE(bits[3], bits[4]) ;
}
inline bool random_rng_d(std::size_t N, std::size_t M)
{
using result_type = typename RNGType::result_type;
mckl::UniformIntDistribution<std::size_t> rsize(0, N);
mckl::UniformBitsDistribution<std::uint16_t> ubits16;
mckl::UniformBitsDistribution<std::uint32_t> ubits32;
mckl::UniformBitsDistribution<std::uint64_t> ubits64;
RNGType rng;
bool pass = true;
RNGType rng1;
RNGType rng2;
mckl::Vector<result_type> r1;
mckl::Vector<result_type> r2;
mckl::Vector<std::uint16_t> u16_1;
mckl::Vector<std::uint16_t> u16_2;
mckl::Vector<std::uint32_t> u32_1;
mckl::Vector<std::uint32_t> u32_2;
mckl::Vector<std::uint64_t> u64_1;
mckl::Vector<std::uint64_t> u64_2;
r1.reserve(N);
r2.reserve(N);
u16_1.reserve(N);
u16_2.reserve(N);
u32_1.reserve(N);
u32_2.reserve(N);
u64_1.reserve(N);
u64_2.reserve(N);
for (std::size_t i = 0; i != M; ++i) {
std::size_t K = rsize(rng);
r1.resize(K);
r2.resize(K);
u16_1.resize(K);
u16_2.resize(K);
u32_1.resize(K);
u32_2.resize(K);
u64_1.resize(K);
u64_2.resize(K);
for (std::size_t j = 0; j != K; ++j) {
r1[j] = rng1();
}
mckl::rand(rng2, K, r2.data());
pass = pass && (r1 == r2 || rng != rng);
for (std::size_t j = 0; j != K; ++j) {
u16_1[j] = mckl::rand(rng1, ubits16);
}
mckl::rand(rng2, ubits16, K, u16_2.data());
pass = pass && (u16_1 == u16_2 || rng != rng);
for (std::size_t j = 0; j != K; ++j) {
u32_1[j] = mckl::rand(rng1, ubits32);
}
mckl::rand(rng2, ubits32, K, u32_2.data());
pass = pass && (u32_1 == u32_2 || rng != rng);
for (std::size_t j = 0; j != K; ++j) {
u64_1[j] = mckl::rand(rng1, ubits64);
}
mckl::rand(rng2, ubits64, K, u64_2.data());
pass = pass && (u64_1 == u64_2 || rng != rng);
rng1.discard(static_cast<unsigned>(K));
typename RNGType::result_type next = rng1();
for (std::size_t j = 0; j != K; ++j) {
rng2();
}
bool find = false;
for (std::size_t j = 0; j != 2; ++j) {
find = find || rng2() == next;
}
pass = pass && (find || rng != rng);
std::stringstream ss;
ss << rng;
mckl::rand(rng, K, r1.data());
ss >> rng;
mckl::rand(rng, K, r2.data());
pass = pass && (r1 == r2 || rng != rng);
RNGType tmp(rng);
mckl::rand(rng, K, r1.data());
mckl::rand(tmp, K, r2.data());
pass = pass && (r1 == r2 || rng != rng);
tmp = rng;
mckl::rand(rng, K, r1.data());
mckl::rand(tmp, K, r2.data());
pass = pass && (r1 == r2 || rng != rng);
}
return pass;
}
