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;
}
/**** 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);
}
}
void NS_move(float* Matrix, float** ptrk, std::vector<Coordinates>& chain, std::vector<Coordinates>& chain_trial, std::vector<int*>& k_array, std::vector<int*>& p_array, std::vector<int>& ruffle, RandomLib::Random& r, Lattice lattice, int chain_length)
{
int rand, l;
int intersection = 1;
bool success = false;
std::vector<Coordinates>::const_iterator itc;
while (intersection == 1)
{
rand = r.Integer(2);
if (rand == 0)
{
success = bondrebridging_2D(ptrk, Matrix, chain, chain_trial, p_array, k_array, r, lattice, chain_length);
}
else
{
success = pullmove(Matrix, chain_trial, k_array, ruffle, r, lattice, chain_length);
}
if(success == false)
{
l = 0;
for(itc = chain_trial.begin(); itc != chain_trial.end(); ++itc)
{
chain_trial[l].reset_coordinates(Matrix, lattice, chain[l].get_x(), chain[l].get_y());
++l;
}
}
else
{
intersection = 0;
l = 0;
for(itc = chain.begin(); itc != chain.end(); ++itc)
{
chain[l].reset_coordinates(Matrix, lattice, chain_trial[l].get_x(), chain_trial[l].get_y());
++l;
}
}
l = 0;
for(itc = chain.begin(); itc != chain.end(); ++itc)
{
k_array[l] = chain_trial[l].get_ptrk();
p_array[l] = chain_trial[l].get_ptrp();
l++;
}
}
}
void potts_NestedSampling_Algorithm_2D(float** ptrMatrix, float* Matrix, std::vector<double>& coordinates, std::vector<double>& likelyhoods, std::vector<double>& postlikelyhoods, Lattice lattice, RandomLib::Random& r, double const J, double const h, double const label_coeff, int const K, int const max, int const mcycle)
{
int k, p, z, distance, iteration, K_iteration, oldSpin;
double H_tot, H_in, H_fin, H_tot_constraint, H_tot_trial;
initialise_likelyhoods(likelyhoods, K);
initialise_likelyhoods(postlikelyhoods, K);
initialise_coordinates(coordinates, lattice, K);
for(int i = 0; i < K; i++)
{
potts_generate_random_matrix_2D(Matrix, lattice, r, max);
H_tot = potts_total_hamiltonian_2D(ptrMatrix,lattice,J,h);
H_tot = label_likelyhood(H_tot, label_coeff, r);
likelyhoods.insert(likelyhoods.end(), H_tot);
add_coordinates(Matrix, coordinates, lattice);
}
std::cout<<"END OF INITIALISATION"<<std::endl;
std::cout<<"likelyhoods.size: "<<likelyhoods.size()<<std::endl;
std::cout<<"coordinates.size: "<<coordinates.size()<<std::endl;
bool LOOP = true;
std::vector<double>::iterator max_likelyhood;
while(LOOP == true)
{
max_likelyhood = std::max_element(likelyhoods.begin(),likelyhoods.end());
distance = std::distance(likelyhoods.begin(), max_likelyhood);
H_tot_constraint = likelyhoods.at(distance);
postlikelyhoods.insert(postlikelyhoods.end(), H_tot_constraint);
//std::cout<<"H_tot_constraint: "<<H_tot_constraint<<std::endl;
distance = get_randomlikelyhood_coordinates(Matrix, coordinates, likelyhoods, r, lattice);
H_tot = likelyhoods.at(distance);
K_iteration = 0;
for(z = 0; z < mcycle; z++)
{
Matrix_samplepoint_2D(lattice, r, &k, &p);
H_in = potts_nodal_hamiltonian_2D(ptrMatrix, p, lattice, J, h);
//flip spin
oldSpin = Matrix[k];
Matrix[k] = r.IntegerC(1, max);
H_fin = potts_nodal_hamiltonian_2D(ptrMatrix, p, lattice, J, h);
H_tot_trial = H_tot - H_in + H_fin;
H_tot_trial = label_likelyhood(H_tot_trial, label_coeff, r);
if (H_tot_trial < H_tot_constraint)
{
H_tot = H_tot_trial;
}
else
{
Matrix[k] = oldSpin;
}
if (z == mcycle - 1)
{
if (H_tot < H_tot_constraint)
{
replace_maxlikelyhood_coordinates(Matrix, coordinates, likelyhoods, lattice, H_tot);
break;
}
else
{
//std::cout<<"change"<<std::endl;
K_iteration = get_alternativelikelyhood_coordinates_random(Matrix, coordinates, likelyhoods,lattice, r, K, H_tot, K_iteration);
z = 0;
++K_iteration;
}
}
else if (K_iteration == K )
{
LOOP = false;
std::cout<<"Algorithm termination condition met"<<std::endl;
break;
}
}
}
}
void WangLandau_Algorithm_bean_2D(float** ptrMatrix, float* Matrix, std::vector<double>& Histogram, std::vector<double>& Histogram2, std::vector<double>& DOS, Lattice lattice, Bean bean, RandomLib::Random& r, double* ptrf, double const InitialDOS, double const end_f, double const average_frac, double const J, double const h, int const mcycle)
{
int k, p, z, g, average;
double H_tot_trial, H_in, H_fin, gE1, gE2;
int M = lattice.get_M();
int N = lattice.get_N();
double H_tot = ising_total_hamiltonian_2D(ptrMatrix,lattice,J,h);
initialiseHistogram_bean(Histogram, DOS);
initialiseHistogram_bean(Histogram2, DOS);
/*
std::cout<<"DEBUG3: DOS size: "<<DOS.size()<< std::endl;
std::cout<<"DEBUG3: Histogram size: "<<Histogram.size()<< std::endl;
*/
while(*ptrf >= end_f)
{
bool LOOP = true;
//std::cout<<"DEBUG Outer while loop"<<std::endl;
while(LOOP == true)
{
//std::cout<<"DEBUG inner while loop"<<std::endl;
for(z = 0; z < mcycle; z++)
{
//the inner loop is necessary for the preconditioning
//select random node on the lattice Matrix
Matrix_samplepoint_2D(lattice, r, &k, &p);
H_in = ising_nodal_hamiltonian_2D(ptrMatrix, p, lattice, J, h);
//flip spin
Matrix[k] = - Matrix[k];
H_fin = ising_nodal_hamiltonian_2D(ptrMatrix, p, lattice, J, h);
H_tot_trial = H_tot - H_in + H_fin;
gE1 = get_DOS_bean(DOS, bean, H_tot);
gE2 = get_DOS_bean(DOS, bean, H_tot_trial);
if(gE2 <= gE1)
{
H_tot = H_tot_trial;
update_DOS_bean(DOS, Histogram, Histogram2, bean, ptrf, H_tot, InitialDOS);
update_EnergyHistogram_bean(Histogram, bean, H_tot);
}
else if (r.Fixed() <= exp( gE1 - gE2 ) )
{
H_tot = H_tot_trial;
update_DOS_bean(DOS, Histogram, Histogram2, bean, ptrf, H_tot, InitialDOS);
update_EnergyHistogram_bean(Histogram, bean, H_tot);
}
else
{
Matrix[k] = - Matrix[k];
update_DOS_bean(DOS, Histogram, Histogram2, bean, ptrf, H_tot, InitialDOS);
update_EnergyHistogram_bean(Histogram, bean, H_tot);
}
}
average = average_EnergyHistogram_bean(Histogram, DOS, InitialDOS, end_f);
LOOP = termination_EnergyHistogram_bean(Histogram, DOS, InitialDOS, average, average_frac, end_f);
}
initialiseHistogram_bean(Histogram, DOS);
evolve_update_function_sqrt(ptrf);
}
}
template<> RandomLib::Random * Glue<RandomLib::Random>::usr_new(lua_State * L) {
RandomLib::Random *r = new RandomLib::Random();
r->Reseed();
return r;
}
int lua_random_reset(lua_State *L) {
RandomLib::Random *s = Glue<RandomLib::Random>::checkto(L, 1);
s->Reset();
return 0;
}
int lua_random_Float32(lua_State *L) {
RandomLib::Random *s = Glue<RandomLib::Random>::checkto(L, 1);
lua::push<double>(L, s->Fixed());
return 1;
}
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;
}
double Common::randN()
{
QMutexLocker lock(&rngLock);
return g_rand.FloatN();
}
