G g;
D d;
const int N = 100;
- std::vector<Frequency> u(d.max()+1);
+ std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+ assert(u.max_size() > static_cast<unsigned long long>(d.max()));
for (int i = 0; i < N; ++i)
{
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
- u[v]++;
+ u[static_cast<std::size_t>(v)]++;
}
std::vector<double> prob = d.probabilities();
for (unsigned i = 0; i < u.size(); ++i)
double p0[] = {.3};
D d(p0, p0+1);
const int N = 100;
- std::vector<Frequency> u(d.max()+1);
+ std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+ assert(u.max_size() > static_cast<unsigned long long>(d.max()));
for (int i = 0; i < N; ++i)
{
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
- u[v]++;
+ u[static_cast<std::size_t>(v)]++;
}
std::vector<double> prob = d.probabilities();
for (unsigned i = 0; i < u.size(); ++i)
double p0[] = {.75, .25};
D d(p0, p0+2);
const int N = 1000000;
- std::vector<Frequency> u(d.max()+1);
+ std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+ assert(u.max_size() > static_cast<unsigned long long>(d.max()));
for (int i = 0; i < N; ++i)
{
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
- u[v]++;
+ u[static_cast<std::size_t>(v)]++;
}
std::vector<double> prob = d.probabilities();
for (unsigned i = 0; i < u.size(); ++i)
double p0[] = {0, 1};
D d(p0, p0+2);
const int N = 1000000;
- std::vector<Frequency> u(d.max()+1);
+ std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+ assert(u.max_size() > static_cast<unsigned long long>(d.max()));
for (int i = 0; i < N; ++i)
{
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
- u[v]++;
+ u[static_cast<std::size_t>(v)]++;
}
std::vector<double> prob = d.probabilities();
assert((double)u[0]/N == prob[0]);
double p0[] = {1, 0};
D d(p0, p0+2);
const int N = 1000000;
- std::vector<Frequency> u(d.max()+1);
+ std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+ assert(u.max_size() > static_cast<unsigned long long>(d.max()));
for (int i = 0; i < N; ++i)
{
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
- u[v]++;
+ u[static_cast<std::size_t>(v)]++;
}
std::vector<double> prob = d.probabilities();
assert((double)u[0]/N == prob[0]);
double p0[] = {.3, .1, .6};
D d(p0, p0+3);
const int N = 10000000;
- std::vector<Frequency> u(d.max()+1);
+ std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+ assert(u.max_size() > static_cast<unsigned long long>(d.max()));
for (int i = 0; i < N; ++i)
{
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
- u[v]++;
+ u[static_cast<std::size_t>(v)]++;
}
std::vector<double> prob = d.probabilities();
for (unsigned i = 0; i < u.size(); ++i)
double p0[] = {0, 25, 75};
D d(p0, p0+3);
const int N = 1000000;
- std::vector<Frequency> u(d.max()+1);
+ std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+ assert(u.max_size() > static_cast<unsigned long long>(d.max()));
for (int i = 0; i < N; ++i)
{
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
- u[v]++;
+ u[static_cast<std::size_t>(v)]++;
}
std::vector<double> prob = d.probabilities();
for (unsigned i = 0; i < u.size(); ++i)
double p0[] = {25, 0, 75};
D d(p0, p0+3);
const int N = 1000000;
- std::vector<Frequency> u(d.max()+1);
+ std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+ assert(u.max_size() > static_cast<unsigned long long>(d.max()));
for (int i = 0; i < N; ++i)
{
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
- u[v]++;
+ u[static_cast<std::size_t>(v)]++;
}
std::vector<double> prob = d.probabilities();
for (unsigned i = 0; i < u.size(); ++i)
double p0[] = {25, 75, 0};
D d(p0, p0+3);
const int N = 1000000;
- std::vector<Frequency> u(d.max()+1);
+ std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+ assert(u.max_size() > static_cast<unsigned long long>(d.max()));
for (int i = 0; i < N; ++i)
{
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
- u[v]++;
+ u[static_cast<std::size_t>(v)]++;
}
std::vector<double> prob = d.probabilities();
for (unsigned i = 0; i < u.size(); ++i)
double p0[] = {0, 0, 1};
D d(p0, p0+3);
const int N = 100;
- std::vector<Frequency> u(d.max()+1);
+ std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+ assert(u.max_size() > static_cast<unsigned long long>(d.max()));
for (int i = 0; i < N; ++i)
{
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
- u[v]++;
+ u[static_cast<std::size_t>(v)]++;
}
std::vector<double> prob = d.probabilities();
for (unsigned i = 0; i < u.size(); ++i)
double p0[] = {0, 1, 0};
D d(p0, p0+3);
const int N = 100;
- std::vector<Frequency> u(d.max()+1);
+ std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+ assert(u.max_size() > static_cast<unsigned long long>(d.max()));
for (int i = 0; i < N; ++i)
{
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
- u[v]++;
+ u[static_cast<std::size_t>(v)]++;
}
std::vector<double> prob = d.probabilities();
for (unsigned i = 0; i < u.size(); ++i)
double p0[] = {1, 0, 0};
D d(p0, p0+3);
const int N = 100;
- std::vector<Frequency> u(d.max()+1);
+ std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+ assert(u.max_size() > static_cast<unsigned long long>(d.max()));
for (int i = 0; i < N; ++i)
{
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
- u[v]++;
+ u[static_cast<std::size_t>(v)]++;
}
std::vector<double> prob = d.probabilities();
for (unsigned i = 0; i < u.size(); ++i)
double p0[] = {33, 0, 0, 67};
D d(p0, p0+3);
const int N = 1000000;
- std::vector<Frequency> u(d.max()+1);
+ std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+ assert(u.max_size() > static_cast<unsigned long long>(d.max()));
for (int i = 0; i < N; ++i)
{
typename D::result_type v = d(g);
assert(d.min() <= v && v <= d.max());
- u[v]++;
+ u[static_cast<std::size_t>(v)]++;
}
std::vector<double> prob = d.probabilities();
for (unsigned i = 0; i < u.size(); ++i)