/**** GLOBAL ****/
void Common::seedRNG() {
QMutexLocker lock(&rngLock);
static bool seeded = false;
if (!seeded) {
srand(0); // We seed with 0 instead of time(NULL) to have reproducible randomness
seeded = true;
g_rand.Reseed(0);
}
}
int lua_random_seed(lua_State *L) {
RandomLib::Random *s = Glue<RandomLib::Random>::checkto(L, 1);
if(lua::is<RandomLib::RandomSeed::seed_type>(L, 2)) {
RandomLib::RandomSeed::seed_type seed = lua::to<RandomLib::RandomSeed::seed_type>(L, 2);
s->Reseed(seed);
}
else {
luaL_error(L, "Random.seed: invalid arguments");
}
return 0;
}
int main(int, char**) {
RandomLib::Random r; r.Reseed();
#if HAVE_LAMBDA
std::cout << "Illustrate calling STL routines with lambda expressions\n";
#else
std::cout << "Illustrate calling STL routines without lambda expressions\n";
#endif
std::cout << "Using " << r.Name() << "\n"
<< "with seed " << r.SeedString() << "\n\n";
std::vector<unsigned> c(10); // Fill with unsigned in [0, 2^32)
#if HAVE_LAMBDA
std::generate(c.begin(), c.end(),
[&r]() throw() -> unsigned { return r(); });
#else
std::generate<std::vector<unsigned>::iterator, RandomLib::Random&>
(c.begin(), c.end(), r);
#endif
std::vector<double> b(10); // Fill with normal deviates
#if HAVE_LAMBDA
RandomLib::NormalDistribution<> nf;
std::generate(b.begin(), b.end(),
[&r, &nf]() throw() -> double
{ return nf(r,0.0,2.0); });
#else
std::generate(b.begin(), b.end(), RandomNormal<>(r,0.0,2.0));
#endif
std::vector<int> a(20); // How to shuffle large vectors
#if HAVE_LAMBDA
int i = 0;
std::generate(a.begin(), a.end(),
[&i]() throw() -> int { return i++; });
std::random_shuffle(a.begin(), a.end(),
[&r](unsigned long long n) throw() -> unsigned long long
{ return r.Integer<unsigned long long>(n); });
#else
for (size_t i = 0; i < a.size(); ++i) a[i] = int(i);
RandomInt<unsigned long long> shuffler(r);
std::random_shuffle(a.begin(), a.end(), shuffler);
#endif
return 0;
}
template<> RandomLib::Random * Glue<RandomLib::Random>::usr_new(lua_State * L) {
RandomLib::Random *r = new RandomLib::Random();
r->Reseed();
return r;
}
int lua_random_reseed(lua_State *L) {
RandomLib::Random *s = Glue<RandomLib::Random>::checkto(L, 1);
s->Reseed();
return 0;
}
void sar(char *argv[], unsigned int seed)
{
RandomLib::Random rng;
rng.Reseed();
// List of variables for run conditions:
const int num_species = 50;
const int num_patches = 300;
const int num_step = 5000;
const int search_radius = 5;
// Species characteristics:
const double d = 0.5; // Species mean dispersal distance (shapes dispersal kernel): 1/d
const double m = 0.1; // Disturbance probability (disturbance kills individual)
const double niche_min = 0.1; // Competitive strength of empty cells
const double emi_from_out = 0.001; // Seed bank
array2Ddouble E;
array2Dint occupied;
array2Dint disturbance_counter;
SetArraySize2d(E, num_patches, num_patches);
SetArraySize2d(occupied, num_patches, num_patches);
SetArraySize2d(disturbance_counter, num_patches, num_patches);
// List of global species characteristic parameters (read in from file or defined in main function):
double *h = new double[num_species];
double *u = new double[num_species];
double *c = new double[num_species];
double *sigma = new double[num_species];
// read in species characteristics from file
char buffer[100];
sprintf(buffer, "%s_st.txt", argv[1]);
std::ifstream input_traits(buffer);
for (int i = 0; i < num_species; ++i)
{
input_traits >> sigma[i]; // Niche width
input_traits >> h[i]; // Performance at niche optimum (height, y at maximum)
input_traits >> c[i]; // Seed production
input_traits >> u[i]; // Resource at niche optimum (location, x at maximum)
}
input_traits.close();
sprintf(buffer, "%s_species.txt", argv[1]);
std::ifstream input_species(buffer);
{
int i = 0, j = 0;
while (!input_species.eof())
{
input_species >> i;
input_species >> j;
input_species >> E[i][j];
input_species >> occupied[i][j];
input_species >> disturbance_counter[i][j];
}
}
input_species.close();
for (int block = 0; block < 1; ++block)
{
sprintf(buffer, "%s_dest%d.txt", argv[1], block);
std::ifstream input_dest(buffer);
for (int i = 0; i < num_patches; ++i)
{
for (int j = 0; j < num_patches; ++j)
{
disturbance_counter[i][j] = 0;
// occupied[i][j] = 0;
}
}
// Removed the input_dest as a matrix and replaced by a list (see next loop).
// for (int i = 0; i < num_patches; ++i)
// {
// for (int j = 0; j < num_patches; ++j)
// {
// input_dest >> E[i][j];
// }
// }
// The input file is now x,y,E with 90000 lines
{
int i = 0, j = 0;
while (!input_dest.eof())
{
input_dest >> i;
input_dest >> j;
input_dest >> E[i][j];
}
}
input_dest.close();
// for (int x = 0; x < num_patches; x++)
// {
// for (int y = 0; y < num_patches; y++)
// {
// const int s = (int)(rng.Fixed() * num_species); // Select a species at random
// occupied[x][y] = NICHE_F(h[s], u[s], E[x][y], sigma[s]) < niche_min ? EMPTY : s;
// }
// }
double all_possible_seeds = 0;
for (int dx = -search_radius; dx <= search_radius; dx++)
{
for (int dy = -search_radius; dy <= search_radius; dy++)
{
if ((dx != 0) || (dy != 0))
{
all_possible_seeds += exp(-d * sqrt(dx * dx + dy * dy));
}
}
}
all_possible_seeds += emi_from_out * num_species;
for (int t = 0; t < num_step; ++t)
{
for (int cell = 0; cell < num_patches * num_patches; cell++)
{
const int x = (int)(rng.Fixed() * num_patches);
const int y = (int)(rng.Fixed() * num_patches);
if(rng.Fixed() < m)
{
occupied[x][y] = EMPTY;
++disturbance_counter[x][y]; // BR
}
double Niche_res = niche_min;
if (occupied[x][y] != EMPTY)
{
int i = occupied[x][y];
Niche_res = NICHE_F(h[i], u[i], E[x][y], sigma[i]);
}
std::vector<double> Seed(num_species, 0.0);
const int dx_min = (x - search_radius < 0) ? -x : -search_radius;
const int dx_max = (x + search_radius >= num_patches) ? num_patches - 1 - x : search_radius;
const int dy_min = (y - search_radius < 0) ? -y : -search_radius;
const int dy_max = (y + search_radius >= num_patches) ? num_patches - 1 - y : search_radius;
assert(x + dx_min >= 0 && x + dx_max < num_patches);
assert(y + dy_min >= 0 && y + dy_max < num_patches);
for (int dx = dx_min; dx <= dx_max; ++dx)
{
for (int dy = dy_min; dy <= dy_max; ++dy)
{
if (((dx != 0) || (dy != 0)) && (occupied[x + dx][y + dy] != EMPTY))
{
int i = occupied[x + dx][y + dy];
if (NICHE_F(h[i], u[i], E[x][y], sigma[i]) > Niche_res)
{
Seed[i] += c[i] * (exp(-d * sqrt(dx * dx + dy * dy)));
}
}
}
}
double all_seeds = 0.0;
for (int i = 0; i < num_species; ++i)
{
if (NICHE_F(h[i], u[i], E[x][y], sigma[i]) > Niche_res)
{
Seed[i] += emi_from_out;
}
all_seeds += Seed[i];
}
bool total_colon = false;
if (all_seeds / all_possible_seeds > rng.Fixed())
{
total_colon = true;
}
std::vector<double> Prob_recruit(num_species, 0.0);
if (total_colon == true)
{
//Prob_recruit[0] = Colon[0]/double(total_colon);
Prob_recruit[0] = Seed[0] / all_seeds;
for (int i = 1; i < num_species; ++i)
{
Prob_recruit[i] = Seed[i] / all_seeds + Prob_recruit[i-1];
}
occupied[x][y] = EMPTY;
double randnumb = rng.Fixed();
for (int i = 0; i < num_species; i++)
{
if (randnumb < Prob_recruit[i])
{
assert(NICHE_F(h[i], u[i], E[x][y], sigma[i]) > niche_min);
occupied[x][y] = i;
break;
}
}
}
} // ends loop over cells
} // ends loop t
sprintf(buffer, "%s_out200_%d.txt", argv[1], block);
std::ofstream out(buffer);
for (int x = 0; x < num_patches; ++x)
{
for (int y = 0; y < num_patches; ++y)
{
out << x << " " << y << " " << E[x][y] << " " << occupied[x][y] << " " << disturbance_counter[x][y] << "\n";
}
}
out.close();
}
}
int main(int, char**) {
// Create r with a random seed
RandomLib::Random r; r.Reseed();
std::cout << "Using " << r.Name() << "\n"
<< "with seed " << r.SeedString() << "\n\n";
{
std::cout
<< "Sampling exactly from the normal distribution. First number is\n"
<< "in binary with ... indicating an infinite sequence of random\n"
<< "bits. Second number gives the corresponding interval. Third\n"
<< "number is the result of filling in the missing bits and rounding\n"
<< "exactly to the nearest representable double.\n";
const int bits = 1;
RandomLib::ExactNormal<bits> ndist;
long long num = 20000000ll;
long long bitcount = 0;
int numprint = 16;
for (long long i = 0; i < num; ++i) {
long long k = r.Count();
RandomLib::RandomNumber<bits> x = ndist(r); // Sample
bitcount += r.Count() - k;
if (i < numprint) {
std::pair<double, double> z = x.Range();
std::cout << x << " = " // Print in binary with ellipsis
<< "(" << z.first << "," << z.second << ")"; // Print range
double v = x.Value<double>(r); // Round exactly to nearest double
std::cout << " = " << v << "\n";
} else if (i == numprint)
std::cout << std::flush;
}
std::cout
<< "Number of bits needed to obtain the binary representation averaged\n"
<< "over " << num << " samples = " << bitcount/double(num) << "\n\n";
}
{
std::cout
<< "Sampling exactly from exp(-x). First number is in binary with\n"
<< "... indicating an infinite sequence of random bits. Second\n"
<< "number gives the corresponding interval. Third number is the\n"
<< "result of filling in the missing bits and rounding exactly to\n"
<< "the nearest representable double.\n";
const int bits = 1;
RandomLib::ExactExponential<bits> edist;
long long num = 50000000ll;
long long bitcount = 0;
int numprint = 16;
for (long long i = 0; i < num; ++i) {
long long k = r.Count();
RandomLib::RandomNumber<bits> x = edist(r); // Sample
bitcount += r.Count() - k;
if (i < numprint) {
std::pair<double, double> z = x.Range();
std::cout << x << " = " // Print in binary with ellipsis
<< "(" << z.first << "," << z.second << ")"; // Print range
double v = x.Value<double>(r); // Round exactly to nearest double
std::cout << " = " << v << "\n";
} else if (i == numprint)
std::cout << std::flush;
}
std::cout
<< "Number of bits needed to obtain the binary representation averaged\n"
<< "over " << num << " samples = " << bitcount/double(num) << "\n\n";
}
{
std::cout
<< "Sampling exactly from the discrete normal distribution with\n"
<< "sigma = 7 and mu = 1/2.\n";
RandomLib::DiscreteNormal<int> gdist(7,1,1,2);
long long num = 50000000ll;
long long count = r.Count();
int numprint = 16;
for (long long i = 0; i < num; ++i) {
int k = gdist(r); // Sample
if (i < numprint)
std::cout << k << " ";
else if (i == numprint)
std::cout << std::endl;
}
count = r.Count() - count;
std::cout
<< "Number of random variates needed averaged\n"
<< "over " << num << " samples = " << count/double(num) << "\n\n";
}
{
std::cout
<< "Sampling exactly from the discrete normal distribution with\n"
<< "sigma = 1024 and mu = 1/7. First result printed is a uniform\n"
<< "range (with covers a power of two). The second number is the\n"
<< "result of sampling additional bits within that range to obtain\n"
<< "a definite result.\n";
RandomLib::DiscreteNormalAlt<int,1> gdist(1024,1,1,7);
long long num = 20000000ll;
long long count = r.Count();
long long entropy = 0;
int numprint = 16;
for (long long i = 0; i < num; ++i) {
RandomLib::UniformInteger<int,1> u = gdist(r);
entropy += u.Entropy();
if (i < numprint)
std::cout << u << " = ";
int k = u(r);
if (i < numprint)
std::cout << k << "\n";
else if (i == numprint)
std::cout << std::flush;
}
count = r.Count() - count;
std::cout
<< "Number of random bits needed for full result (for range) averaged\n"
<< "over " << num << " samples = " << count/double(num) << " ("
<< (count - entropy)/double(num) << ")\n\n";
}
{
std::cout
<< "Random bits with 1 occurring with probability 1/pi exactly:\n";
long long num = 100000000ll;
int numprint = 72;
RandomLib::InversePiProb pp;
long long nbits = 0;
long long k = r.Count();
for (long long i = 0; i < num; ++i) {
bool b = pp(r);
nbits += int(b);
if (i < numprint) std::cout << int(b);
else if (i == numprint) std::cout << "..." << std::flush;
}
std::cout << "\n";
std::cout << "Frequency of 1 averaged over " << num << " samples = 1/"
<< double(num)/nbits << "\n"
<< "bits/sample = " << (r.Count() - k)/double(num) << "\n\n";
}
{
std::cout
<< "Random bits with 1 occurring with probability 1/e exactly:\n";
long long num = 200000000ll;
int numprint = 72;
RandomLib::InverseEProb ep;
long long nbits = 0;
long long k = r.Count();
for (long long i = 0; i < num; ++i) {
bool b = ep(r);
nbits += int(b);
if (i < numprint) std::cout << int(b);
else if (i == numprint) std::cout << "..." << std::flush;
}
std::cout << "\n";
std::cout << "Frequency of 1 averaged over " << num << " samples = 1/"
<< double(num)/nbits << "\n"
<< "bits/sample = " << (r.Count() - k)/double(num) << "\n";
}
return 0;
}