186 changes: 98 additions & 88 deletions libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,26 +20,24 @@
#include <vector>
#include <cassert>

#include "test_macros.h"

template <class T>
inline
T
sqr(T x)
{
T sqr(T x) {
return x * x;
}

void
test1()
{
typedef std::binomial_distribution<> D;
template <class T>
void test1() {
typedef std::binomial_distribution<T> D;
typedef std::mt19937_64 G;
G g;
D d(5, .75);
const int N = 1000000;
std::vector<D::result_type> u;
std::vector<typename D::result_type> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
Expand Down Expand Up @@ -71,18 +69,17 @@ test1()
assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.04);
}

void
test2()
{
typedef std::binomial_distribution<> D;
template <class T>
void test2() {
typedef std::binomial_distribution<T> D;
typedef std::mt19937 G;
G g;
D d(30, .03125);
const int N = 100000;
std::vector<D::result_type> u;
std::vector<typename D::result_type> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
Expand Down Expand Up @@ -114,18 +111,17 @@ test2()
assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
}

void
test3()
{
typedef std::binomial_distribution<> D;
template <class T>
void test3() {
typedef std::binomial_distribution<T> D;
typedef std::mt19937 G;
G g;
D d(40, .25);
const int N = 100000;
std::vector<D::result_type> u;
std::vector<typename D::result_type> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
Expand Down Expand Up @@ -157,18 +153,17 @@ test3()
assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.3);
}

void
test4()
{
typedef std::binomial_distribution<> D;
template <class T>
void test4() {
typedef std::binomial_distribution<T> D;
typedef std::mt19937 G;
G g;
D d(40, 0);
const int N = 100000;
std::vector<D::result_type> u;
std::vector<typename D::result_type> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
Expand Down Expand Up @@ -207,18 +202,17 @@ test4()
(void)kurtosis; (void)x_kurtosis;
}

void
test5()
{
typedef std::binomial_distribution<> D;
template <class T>
void test5() {
typedef std::binomial_distribution<T> D;
typedef std::mt19937 G;
G g;
D d(40, 1);
const int N = 100000;
std::vector<D::result_type> u;
std::vector<typename D::result_type> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
Expand Down Expand Up @@ -257,18 +251,17 @@ test5()
(void)kurtosis; (void)x_kurtosis;
}

void
test6()
{
typedef std::binomial_distribution<> D;
template <class T>
void test6() {
typedef std::binomial_distribution<T> D;
typedef std::mt19937 G;
G g;
D d(400, 0.5);
D d(127, 0.5);
const int N = 100000;
std::vector<D::result_type> u;
std::vector<typename D::result_type> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
Expand Down Expand Up @@ -296,22 +289,21 @@ test6()
double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
assert(std::abs((mean - x_mean) / x_mean) < 0.01);
assert(std::abs((var - x_var) / x_var) < 0.01);
assert(std::abs(skew - x_skew) < 0.01);
assert(std::abs(skew - x_skew) < 0.02);
assert(std::abs(kurtosis - x_kurtosis) < 0.01);
}

void
test7()
{
typedef std::binomial_distribution<> D;
template <class T>
void test7() {
typedef std::binomial_distribution<T> D;
typedef std::mt19937 G;
G g;
D d(1, 0.5);
const int N = 100000;
std::vector<D::result_type> u;
std::vector<typename D::result_type> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
Expand Down Expand Up @@ -343,36 +335,35 @@ test7()
assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
}

void
test8()
{
template <class T>
void test8() {
const int N = 100000;
std::mt19937 gen1;
std::mt19937 gen2;

std::binomial_distribution<> dist1(5, 0.1);
std::binomial_distribution<unsigned> dist2(5, 0.1);
using UnsignedT = typename std::make_unsigned<T>::type;
std::binomial_distribution<T> dist1(5, 0.1);
std::binomial_distribution<UnsignedT> dist2(5, 0.1);

for(int i = 0; i < N; ++i) {
int r1 = dist1(gen1);
unsigned r2 = dist2(gen2);
for (int i = 0; i < N; ++i) {
T r1 = dist1(gen1);
UnsignedT r2 = dist2(gen2);
assert(r1 >= 0);
assert(static_cast<unsigned>(r1) == r2);
assert(static_cast<UnsignedT>(r1) == r2);
}
}

void
test9()
{
typedef std::binomial_distribution<> D;
template <class T>
void test9() {
typedef std::binomial_distribution<T> D;
typedef std::mt19937 G;
G g;
D d(0, 0.005);
const int N = 100000;
std::vector<D::result_type> u;
std::vector<typename D::result_type> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
Expand Down Expand Up @@ -411,18 +402,17 @@ test9()
(void)kurtosis; (void)x_kurtosis;
}

void
test10()
{
typedef std::binomial_distribution<> D;
template <class T>
void test10() {
typedef std::binomial_distribution<T> D;
typedef std::mt19937 G;
G g;
D d(0, 0);
const int N = 100000;
std::vector<D::result_type> u;
std::vector<typename D::result_type> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
Expand Down Expand Up @@ -461,18 +451,17 @@ test10()
(void)kurtosis; (void)x_kurtosis;
}

void
test11()
{
typedef std::binomial_distribution<> D;
template <class T>
void test11() {
typedef std::binomial_distribution<T> D;
typedef std::mt19937 G;
G g;
D d(0, 1);
const int N = 100000;
std::vector<D::result_type> u;
std::vector<typename D::result_type> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
Expand Down Expand Up @@ -511,19 +500,40 @@ test11()
(void)kurtosis; (void)x_kurtosis;
}

int main(int, char**)
{
test1();
test2();
test3();
test4();
test5();
test6();
test7();
test8();
test9();
test10();
test11();
template <class T>
void tests() {
test1<T>();
test2<T>();
test3<T>();
test4<T>();
test5<T>();
test6<T>();
test7<T>();
test8<T>();
test9<T>();
test10<T>();
test11<T>();
}

int main(int, char**) {
tests<short>();
tests<int>();
tests<long>();
tests<long long>();

tests<unsigned short>();
tests<unsigned int>();
tests<unsigned long>();
tests<unsigned long long>();

#if defined(_LIBCPP_VERSION) // extension
tests<int8_t>();
tests<uint8_t>();
#if !defined(TEST_HAS_NO_INT128)
tests<__int128_t>();
tests<__uint128_t>();
#endif
#endif

return 0;
}
112 changes: 63 additions & 49 deletions libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.geo/eval.pass.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -23,10 +23,7 @@
#include "test_macros.h"

template <class T>
inline
T
sqr(T x)
{
T sqr(T x) {
return x * x;
}

Expand All @@ -40,18 +37,17 @@ void test_small_inputs() {
}
}

void
test1()
{
typedef std::geometric_distribution<> D;
template <class T>
void test1() {
typedef std::geometric_distribution<T> D;
typedef std::mt19937 G;
G g;
D d(.03125);
const int N = 1000000;
std::vector<D::result_type> u;
std::vector<typename D::result_type> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
Expand Down Expand Up @@ -83,18 +79,17 @@ test1()
assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
}

void
test2()
{
typedef std::geometric_distribution<> D;
template <class T>
void test2() {
typedef std::geometric_distribution<T> D;
typedef std::mt19937 G;
G g;
D d(0.05);
const int N = 1000000;
std::vector<D::result_type> u;
std::vector<typename D::result_type> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
Expand Down Expand Up @@ -126,18 +121,17 @@ test2()
assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
}

void
test3()
{
typedef std::geometric_distribution<> D;
template <class T>
void test3() {
typedef std::geometric_distribution<T> D;
typedef std::minstd_rand G;
G g;
D d(.25);
const int N = 1000000;
std::vector<D::result_type> u;
std::vector<typename D::result_type> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
Expand Down Expand Up @@ -169,18 +163,17 @@ test3()
assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
}

void
test4()
{
typedef std::geometric_distribution<> D;
template <class T>
void test4() {
typedef std::geometric_distribution<T> D;
typedef std::mt19937 G;
G g;
D d(0.5);
const int N = 1000000;
std::vector<D::result_type> u;
std::vector<typename D::result_type> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
Expand Down Expand Up @@ -212,18 +205,17 @@ test4()
assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
}

void
test5()
{
typedef std::geometric_distribution<> D;
template <class T>
void test5() {
typedef std::geometric_distribution<T> D;
typedef std::mt19937 G;
G g;
D d(0.75);
const int N = 1000000;
std::vector<D::result_type> u;
std::vector<typename D::result_type> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
Expand Down Expand Up @@ -255,18 +247,17 @@ test5()
assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
}

void
test6()
{
typedef std::geometric_distribution<> D;
template <class T>
void test6() {
typedef std::geometric_distribution<T> D;
typedef std::mt19937 G;
G g;
D d(0.96875);
const int N = 1000000;
std::vector<D::result_type> u;
std::vector<typename D::result_type> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
Expand Down Expand Up @@ -298,15 +289,38 @@ test6()
assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
}

int main(int, char**)
{
test1();
test2();
test3();
test4();
test5();
test6();
template <class T>
void tests() {
test1<T>();
test2<T>();
test3<T>();
test4<T>();
test5<T>();
test6<T>();
}

int main(int, char**) {
test_small_inputs();

return 0;
tests<short>();
tests<int>();
tests<long>();
tests<long long>();

tests<unsigned short>();
tests<unsigned int>();
tests<unsigned long>();
tests<unsigned long long>();

#if defined(_LIBCPP_VERSION) // extension
// TODO: std::geometric_distribution currently doesn't work reliably with small types.
// tests<int8_t>();
// tests<uint8_t>();
#if !defined(TEST_HAS_NO_INT128)
tests<__int128_t>();
tests<__uint128_t>();
#endif
#endif

return 0;
}
115 changes: 65 additions & 50 deletions libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.negbin/eval.pass.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,26 +20,24 @@
#include <vector>
#include <cassert>

#include "test_macros.h"

template <class T>
inline
T
sqr(T x)
{
T sqr(T x) {
return x * x;
}

void
test1()
{
typedef std::negative_binomial_distribution<> D;
template <class T>
void test1() {
typedef std::negative_binomial_distribution<T> D;
typedef std::minstd_rand G;
G g;
D d(5, .25);
const int N = 1000000;
std::vector<D::result_type> u;
std::vector<typename D::result_type> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
Expand Down Expand Up @@ -71,18 +69,17 @@ test1()
assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
}

void
test2()
{
typedef std::negative_binomial_distribution<> D;
template <class T>
void test2() {
typedef std::negative_binomial_distribution<T> D;
typedef std::mt19937 G;
G g;
D d(30, .03125);
const int N = 1000000;
std::vector<D::result_type> u;
std::vector<typename D::result_type> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
Expand Down Expand Up @@ -114,18 +111,17 @@ test2()
assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
}

void
test3()
{
typedef std::negative_binomial_distribution<> D;
template <class T>
void test3() {
typedef std::negative_binomial_distribution<T> D;
typedef std::mt19937 G;
G g;
D d(40, .25);
const int N = 1000000;
std::vector<D::result_type> u;
std::vector<typename D::result_type> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
Expand Down Expand Up @@ -157,18 +153,17 @@ test3()
assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
}

void
test4()
{
typedef std::negative_binomial_distribution<> D;
template <class T>
void test4() {
typedef std::negative_binomial_distribution<T> D;
typedef std::mt19937 G;
G g;
D d(40, 1);
const int N = 1000;
std::vector<D::result_type> u;
std::vector<typename D::result_type> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
Expand Down Expand Up @@ -202,18 +197,17 @@ test4()
(void)kurtosis; (void)x_kurtosis;
}

void
test5()
{
typedef std::negative_binomial_distribution<> D;
template <class T>
void test5() {
typedef std::negative_binomial_distribution<T> D;
typedef std::mt19937 G;
G g;
D d(400, 0.5);
D d(127, 0.5);
const int N = 1000000;
std::vector<D::result_type> u;
std::vector<typename D::result_type> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
Expand Down Expand Up @@ -245,18 +239,17 @@ test5()
assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.05);
}

void
test6()
{
typedef std::negative_binomial_distribution<> D;
template <class T>
void test6() {
typedef std::negative_binomial_distribution<T> D;
typedef std::mt19937 G;
G g;
D d(1, 0.05);
const int N = 1000000;
std::vector<D::result_type> u;
std::vector<typename D::result_type> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
Expand Down Expand Up @@ -288,14 +281,36 @@ test6()
assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
}

int main(int, char**)
{
test1();
test2();
test3();
test4();
test5();
test6();
template <class T>
void tests() {
test1<T>();
test2<T>();
test3<T>();
test4<T>();
test5<T>();
test6<T>();
}

int main(int, char**) {
tests<short>();
tests<int>();
tests<long>();
tests<long long>();

tests<unsigned short>();
tests<unsigned int>();
tests<unsigned long>();
tests<unsigned long long>();

#if defined(_LIBCPP_VERSION) // extension
// TODO: std::negative_binomial_distribution currently doesn't work reliably with small types.
// tests<int8_t>();
// tests<uint8_t>();
#if !defined(TEST_HAS_NO_INT128)
tests<__int128_t>();
tests<__uint128_t>();
#endif
#endif

return 0;
return 0;
}
260 changes: 140 additions & 120 deletions libcxx/test/std/numerics/rand/rand.dist/rand.dist.pois/rand.dist.pois.poisson/eval.pass.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -23,11 +23,8 @@
#include "test_macros.h"

template <class T>
inline
T
sqr(T x)
{
return x * x;
T sqr(T x) {
return x * x;
}

void test_bad_ranges() {
Expand Down Expand Up @@ -91,126 +88,149 @@ void test_bad_ranges() {
}
}

int main(int, char**)
{
template <class T>
void tests() {
{
typedef std::poisson_distribution<T> D;
typedef std::minstd_rand G;
G g;
D d(2);
const int N = 100000;
std::vector<double> u;
for (int i = 0; i < N; ++i)
{
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
double var = 0;
double skew = 0;
double kurtosis = 0;
for (unsigned i = 0; i < u.size(); ++i)
{
double dbl = (u[i] - mean);
double d2 = sqr(dbl);
var += d2;
skew += dbl * d2;
kurtosis += d2 * d2;
}
var /= u.size();
double dev = std::sqrt(var);
skew /= u.size() * dev * var;
kurtosis /= u.size() * var * var;
kurtosis -= 3;
double x_mean = d.mean();
double x_var = d.mean();
double x_skew = 1 / std::sqrt(x_var);
double x_kurtosis = 1 / x_var;
assert(std::abs((mean - x_mean) / x_mean) < 0.01);
assert(std::abs((var - x_var) / x_var) < 0.01);
assert(std::abs((skew - x_skew) / x_skew) < 0.01);
assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
}
{
typedef std::poisson_distribution<T> D;
typedef std::minstd_rand G;
G g;
D d(0.75);
const int N = 100000;
std::vector<double> u;
for (int i = 0; i < N; ++i)
{
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
double var = 0;
double skew = 0;
double kurtosis = 0;
for (unsigned i = 0; i < u.size(); ++i)
{
typedef std::poisson_distribution<> D;
typedef std::minstd_rand G;
G g;
D d(2);
const int N = 100000;
std::vector<double> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
double var = 0;
double skew = 0;
double kurtosis = 0;
for (unsigned i = 0; i < u.size(); ++i)
{
double dbl = (u[i] - mean);
double d2 = sqr(dbl);
var += d2;
skew += dbl * d2;
kurtosis += d2 * d2;
}
var /= u.size();
double dev = std::sqrt(var);
skew /= u.size() * dev * var;
kurtosis /= u.size() * var * var;
kurtosis -= 3;
double x_mean = d.mean();
double x_var = d.mean();
double x_skew = 1 / std::sqrt(x_var);
double x_kurtosis = 1 / x_var;
assert(std::abs((mean - x_mean) / x_mean) < 0.01);
assert(std::abs((var - x_var) / x_var) < 0.01);
assert(std::abs((skew - x_skew) / x_skew) < 0.01);
assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
double dbl = (u[i] - mean);
double d2 = sqr(dbl);
var += d2;
skew += dbl * d2;
kurtosis += d2 * d2;
}
var /= u.size();
double dev = std::sqrt(var);
skew /= u.size() * dev * var;
kurtosis /= u.size() * var * var;
kurtosis -= 3;
double x_mean = d.mean();
double x_var = d.mean();
double x_skew = 1 / std::sqrt(x_var);
double x_kurtosis = 1 / x_var;
assert(std::abs((mean - x_mean) / x_mean) < 0.01);
assert(std::abs((var - x_var) / x_var) < 0.01);
assert(std::abs((skew - x_skew) / x_skew) < 0.01);
assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.04);
}
{
typedef std::poisson_distribution<T> D;
typedef std::mt19937 G;
G g;
D d(20);
const int N = 1000000;
std::vector<double> u;
for (int i = 0; i < N; ++i)
{
typedef std::poisson_distribution<> D;
typedef std::minstd_rand G;
G g;
D d(0.75);
const int N = 100000;
std::vector<double> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
double var = 0;
double skew = 0;
double kurtosis = 0;
for (unsigned i = 0; i < u.size(); ++i)
{
double dbl = (u[i] - mean);
double d2 = sqr(dbl);
var += d2;
skew += dbl * d2;
kurtosis += d2 * d2;
}
var /= u.size();
double dev = std::sqrt(var);
skew /= u.size() * dev * var;
kurtosis /= u.size() * var * var;
kurtosis -= 3;
double x_mean = d.mean();
double x_var = d.mean();
double x_skew = 1 / std::sqrt(x_var);
double x_kurtosis = 1 / x_var;
assert(std::abs((mean - x_mean) / x_mean) < 0.01);
assert(std::abs((var - x_var) / x_var) < 0.01);
assert(std::abs((skew - x_skew) / x_skew) < 0.01);
assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.04);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
double var = 0;
double skew = 0;
double kurtosis = 0;
for (unsigned i = 0; i < u.size(); ++i)
{
typedef std::poisson_distribution<> D;
typedef std::mt19937 G;
G g;
D d(20);
const int N = 1000000;
std::vector<double> u;
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u.push_back(v);
}
double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
double var = 0;
double skew = 0;
double kurtosis = 0;
for (unsigned i = 0; i < u.size(); ++i)
{
double dbl = (u[i] - mean);
double d2 = sqr(dbl);
var += d2;
skew += dbl * d2;
kurtosis += d2 * d2;
}
var /= u.size();
double dev = std::sqrt(var);
skew /= u.size() * dev * var;
kurtosis /= u.size() * var * var;
kurtosis -= 3;
double x_mean = d.mean();
double x_var = d.mean();
double x_skew = 1 / std::sqrt(x_var);
double x_kurtosis = 1 / x_var;
assert(std::abs((mean - x_mean) / x_mean) < 0.01);
assert(std::abs((var - x_var) / x_var) < 0.01);
assert(std::abs((skew - x_skew) / x_skew) < 0.01);
assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
double dbl = (u[i] - mean);
double d2 = sqr(dbl);
var += d2;
skew += dbl * d2;
kurtosis += d2 * d2;
}
var /= u.size();
double dev = std::sqrt(var);
skew /= u.size() * dev * var;
kurtosis /= u.size() * var * var;
kurtosis -= 3;
double x_mean = d.mean();
double x_var = d.mean();
double x_skew = 1 / std::sqrt(x_var);
double x_kurtosis = 1 / x_var;
assert(std::abs((mean - x_mean) / x_mean) < 0.01);
assert(std::abs((var - x_var) / x_var) < 0.01);
assert(std::abs((skew - x_skew) / x_skew) < 0.01);
assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
}
}

int main(int, char**) {
test_bad_ranges();

tests<short>();
tests<int>();
tests<long>();
tests<long long>();

tests<unsigned short>();
tests<unsigned int>();
tests<unsigned long>();
tests<unsigned long long>();

#if defined(_LIBCPP_VERSION) // extension
// TODO: std::poisson_distribution currently doesn't work reliably with small types.
// tests<int8_t>();
// tests<uint8_t>();
#if !defined(TEST_HAS_NO_INT128)
tests<__int128_t>();
tests<__uint128_t>();
#endif
#endif

test_bad_ranges();
return 0;
return 0;
}
128 changes: 75 additions & 53 deletions libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -21,72 +21,73 @@

#include "test_macros.h"

int main(int, char**)
{
template <class T>
void tests() {
typedef long long Frequency;
{
typedef std::discrete_distribution<> D;
typedef std::discrete_distribution<T> D;
typedef std::minstd_rand G;
G g;
D d;
const int N = 100;
std::vector<D::result_type> u(d.max()+1);
std::vector<Frequency> u(d.max()+1);
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u[v]++;
}
std::vector<double> prob = d.probabilities();
for (int i = 0; i <= d.max(); ++i)
for (unsigned i = 0; i < u.size(); ++i)
assert((double)u[i]/N == prob[i]);
}
{
typedef std::discrete_distribution<> D;
typedef std::discrete_distribution<T> D;
typedef std::minstd_rand G;
G g;
double p0[] = {.3};
D d(p0, p0+1);
const int N = 100;
std::vector<D::result_type> u(d.max()+1);
std::vector<Frequency> u(d.max()+1);
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u[v]++;
}
std::vector<double> prob = d.probabilities();
for (int i = 0; i <= d.max(); ++i)
for (unsigned i = 0; i < u.size(); ++i)
assert((double)u[i]/N == prob[i]);
}
{
typedef std::discrete_distribution<> D;
typedef std::discrete_distribution<T> D;
typedef std::minstd_rand G;
G g;
double p0[] = {.75, .25};
D d(p0, p0+2);
const int N = 1000000;
std::vector<D::result_type> u(d.max()+1);
std::vector<Frequency> u(d.max()+1);
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u[v]++;
}
std::vector<double> prob = d.probabilities();
for (int i = 0; i <= d.max(); ++i)
for (unsigned i = 0; i < u.size(); ++i)
assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
}
{
typedef std::discrete_distribution<> D;
typedef std::discrete_distribution<T> D;
typedef std::minstd_rand G;
G g;
double p0[] = {0, 1};
D d(p0, p0+2);
const int N = 1000000;
std::vector<D::result_type> u(d.max()+1);
std::vector<Frequency> u(d.max()+1);
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u[v]++;
}
Expand All @@ -95,16 +96,16 @@ int main(int, char**)
assert((double)u[1]/N == prob[1]);
}
{
typedef std::discrete_distribution<> D;
typedef std::discrete_distribution<T> D;
typedef std::minstd_rand G;
G g;
double p0[] = {1, 0};
D d(p0, p0+2);
const int N = 1000000;
std::vector<D::result_type> u(d.max()+1);
std::vector<Frequency> u(d.max()+1);
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u[v]++;
}
Expand All @@ -113,170 +114,191 @@ int main(int, char**)
assert((double)u[1]/N == prob[1]);
}
{
typedef std::discrete_distribution<> D;
typedef std::discrete_distribution<T> D;
typedef std::minstd_rand G;
G g;
double p0[] = {.3, .1, .6};
D d(p0, p0+3);
const int N = 10000000;
std::vector<D::result_type> u(d.max()+1);
std::vector<Frequency> u(d.max()+1);
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u[v]++;
}
std::vector<double> prob = d.probabilities();
for (int i = 0; i <= d.max(); ++i)
for (unsigned i = 0; i < u.size(); ++i)
assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
}
{
typedef std::discrete_distribution<> D;
typedef std::discrete_distribution<T> D;
typedef std::minstd_rand G;
G g;
double p0[] = {0, 25, 75};
D d(p0, p0+3);
const int N = 1000000;
std::vector<D::result_type> u(d.max()+1);
std::vector<Frequency> u(d.max()+1);
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u[v]++;
}
std::vector<double> prob = d.probabilities();
for (int i = 0; i <= d.max(); ++i)
for (unsigned i = 0; i < u.size(); ++i)
if (prob[i] != 0)
assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
else
assert(u[i] == 0);
}
{
typedef std::discrete_distribution<> D;
typedef std::discrete_distribution<T> D;
typedef std::minstd_rand G;
G g;
double p0[] = {25, 0, 75};
D d(p0, p0+3);
const int N = 1000000;
std::vector<D::result_type> u(d.max()+1);
std::vector<Frequency> u(d.max()+1);
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u[v]++;
}
std::vector<double> prob = d.probabilities();
for (int i = 0; i <= d.max(); ++i)
for (unsigned i = 0; i < u.size(); ++i)
if (prob[i] != 0)
assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
else
assert(u[i] == 0);
}
{
typedef std::discrete_distribution<> D;
typedef std::discrete_distribution<T> D;
typedef std::minstd_rand G;
G g;
double p0[] = {25, 75, 0};
D d(p0, p0+3);
const int N = 1000000;
std::vector<D::result_type> u(d.max()+1);
std::vector<Frequency> u(d.max()+1);
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u[v]++;
}
std::vector<double> prob = d.probabilities();
for (int i = 0; i <= d.max(); ++i)
for (unsigned i = 0; i < u.size(); ++i)
if (prob[i] != 0)
assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
else
assert(u[i] == 0);
}
{
typedef std::discrete_distribution<> D;
typedef std::discrete_distribution<T> D;
typedef std::minstd_rand G;
G g;
double p0[] = {0, 0, 1};
D d(p0, p0+3);
const int N = 100;
std::vector<D::result_type> u(d.max()+1);
std::vector<Frequency> u(d.max()+1);
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u[v]++;
}
std::vector<double> prob = d.probabilities();
for (int i = 0; i <= d.max(); ++i)
for (unsigned i = 0; i < u.size(); ++i)
if (prob[i] != 0)
assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
else
assert(u[i] == 0);
}
{
typedef std::discrete_distribution<> D;
typedef std::discrete_distribution<T> D;
typedef std::minstd_rand G;
G g;
double p0[] = {0, 1, 0};
D d(p0, p0+3);
const int N = 100;
std::vector<D::result_type> u(d.max()+1);
std::vector<Frequency> u(d.max()+1);
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u[v]++;
}
std::vector<double> prob = d.probabilities();
for (int i = 0; i <= d.max(); ++i)
for (unsigned i = 0; i < u.size(); ++i)
if (prob[i] != 0)
assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
else
assert(u[i] == 0);
}
{
typedef std::discrete_distribution<> D;
typedef std::discrete_distribution<T> D;
typedef std::minstd_rand G;
G g;
double p0[] = {1, 0, 0};
D d(p0, p0+3);
const int N = 100;
std::vector<D::result_type> u(d.max()+1);
std::vector<Frequency> u(d.max()+1);
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u[v]++;
}
std::vector<double> prob = d.probabilities();
for (int i = 0; i <= d.max(); ++i)
for (unsigned i = 0; i < u.size(); ++i)
if (prob[i] != 0)
assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
else
assert(u[i] == 0);
}
{
typedef std::discrete_distribution<> D;
typedef std::discrete_distribution<T> D;
typedef std::minstd_rand G;
G g;
double p0[] = {33, 0, 0, 67};
D d(p0, p0+3);
const int N = 1000000;
std::vector<D::result_type> u(d.max()+1);
std::vector<Frequency> u(d.max()+1);
for (int i = 0; i < N; ++i)
{
D::result_type v = d(g);
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
u[v]++;
}
std::vector<double> prob = d.probabilities();
for (int i = 0; i <= d.max(); ++i)
for (unsigned i = 0; i < u.size(); ++i)
if (prob[i] != 0)
assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
else
assert(u[i] == 0);
}
}

int main(int, char**) {
tests<short>();
tests<int>();
tests<long>();
tests<long long>();

tests<unsigned short>();
tests<unsigned int>();
tests<unsigned long>();
tests<unsigned long long>();

#if defined(_LIBCPP_VERSION) // extension
tests<int8_t>();
tests<uint8_t>();
#if !defined(TEST_HAS_NO_INT128)
tests<__int128_t>();
tests<__uint128_t>();
#endif
#endif

return 0;
return 0;
}
20 changes: 7 additions & 13 deletions libcxx/test/std/numerics/rand/rand.dist/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -32,14 +32,12 @@
#endif

template <class T>
T sqr(T x)
{
T sqr(T x) {
return x * x;
}

template <class ResultType, class EngineType>
void test_statistics(ResultType a, ResultType b)
{
void test_statistics(ResultType a, ResultType b) {
ASSERT_SAME_TYPE(typename std::uniform_int_distribution<ResultType>::result_type, ResultType);

EngineType g;
Expand Down Expand Up @@ -94,8 +92,7 @@ void test_statistics(ResultType a, ResultType b)
}

template <class ResultType, class EngineType>
void test_statistics()
{
void test_statistics() {
test_statistics<ResultType, EngineType>(0, std::numeric_limits<ResultType>::max());
}

Expand Down Expand Up @@ -125,13 +122,9 @@ int main(int, char**)

test_statistics<short, std::minstd_rand0>(SHRT_MIN, SHRT_MAX);

// http://eel.is/c++draft/rand.req#genl-1.5
// The effect of instantiating a template that has a parameter
// named IntType is undefined unless the corresponding template
// argument is cv-unqualified and is one of short, int, long,
// long long, unsigned short, unsigned int, unsigned long,
// or unsigned long long.
// (We support __int128 as an extension.)
#if defined(_LIBCPP_VERSION) // extension
test_statistics<int8_t, std::minstd_rand0>();
test_statistics<uint8_t, std::minstd_rand0>();

#if !defined(TEST_HAS_NO_INT128) && !defined(TEST_BUGGY_I128_FP)
test_statistics<__int128_t, std::minstd_rand0>();
Expand All @@ -141,6 +134,7 @@ int main(int, char**)
test_statistics<__int128_t, std::minstd_rand0>(0, UINT64_MAX);
test_statistics<__int128_t, std::minstd_rand0>(std::numeric_limits<__int128_t>::min(), std::numeric_limits<__int128_t>::max());
test_statistics<__uint128_t, std::minstd_rand0>(0, UINT64_MAX);
#endif
#endif

return 0;
Expand Down
3 changes: 0 additions & 3 deletions libcxx/utils/libcxx/test/params.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -166,9 +166,6 @@ def getStdFlag(cfg, std):
# to make it link against the static libc++experimental.lib.
# We can't check for the feature 'msvc' in available_features
# as those features are added after processing parameters.
#
# TODO: Switch to using the appropriate experimental compiler flag once
# all compilers we support implement that flag.
AddFeature('c++experimental'),
PrependLinkFlag(lambda cfg: '-llibc++experimental' if _isMSVC(cfg) else '-lc++experimental'),
AddCompileFlag('-D_LIBCPP_ENABLE_EXPERIMENTAL'),
Expand Down