//std::pair< individual_pointer , individual_pointer > operator()( environment_type * env, double f = 0.0 ) {
std::pair< IndividualPointer, IndividualPointer > operator()( EnvironmentPointer env, double f = 0.0 ) {
size_t i0 = gsl_ran_discrete( m_rng, m_lookup );
size_t i1 = ((gsl_rng_uniform(m_rng) <= f ) ? i0 : gsl_ran_discrete( m_rng, m_lookup ));
std::pair< IndividualPointer, IndividualPointer > res = std::make_pair( env->at(i0), env->at(i1));
return res;
}
void librdist_nonparametric(gsl_rng *rng, int argc, void *argv, int bufc, float *buf){
gsl_ran_discrete_t *g = (gsl_ran_discrete_t *)argv;
int i;
for(i = 0; i < bufc; i++){
buf[i] = (float)gsl_ran_discrete(rng, g);
}
}
MutationType *GenomicElementType::DrawMutationType(void) const
{
if (!lookup_mutation_type_)
EIDOS_TERMINATION << "ERROR (GenomicElementType::DrawMutationType): empty mutation type vector for genomic element type." << EidosTerminate();
return mutation_type_ptrs_[gsl_ran_discrete(EIDOS_GSL_RNG, lookup_mutation_type_)];
}
inline size_t
pick2(const gsl_rng *r, const size_t &p1, const double &f,
const diploid_t &, const gcont_t &, const mcont_t &) const
{
return ((f == 1.) || (f > 0. && gsl_rng_uniform(r) < f))
? p1
: gsl_ran_discrete(r, lookup.get());
}
double
test_discrete2 (void)
{
static double P[10]={ 1, 9, 3, 4, 5, 8, 6, 7, 2, 0 };
if (g2==NULL) {
g2 = gsl_ran_discrete_preproc(10,P);
}
return gsl_ran_discrete(r_global,g2);
}
double
test_discrete1 (void)
{
static double P[3]={0.59, 0.4, 0.01};
if (g1==NULL) {
g1 = gsl_ran_discrete_preproc(3,P);
}
return gsl_ran_discrete(r_global,g1);
}
// Generate a sample from the the pdf.
int pf_pdf_discrete_sample(pf_pdf_discrete_t *pdf)
{
int i;
i = gsl_ran_discrete(pdf->rng, pdf->ran);
assert(i >= 0 && i < pdf->prob_count);
return i;
}
double
test_discrete3 (void)
{
static double P[20];
if (g3 == NULL)
{ int i;
for (i=0; i<20; ++i) P[i]=1.0/20;
g3 = gsl_ran_discrete_preproc (20, P);
}
return gsl_ran_discrete (r_global, g3);
}
std::vector<intType> ran_mult_multinomial(const std::vector<uint64_t>& pop, intType sample_size, const gsl_rng* r, intType min_coverage = 0)
{
std::vector<intType> sample;
sample.resize(bins);
// 1.) first generate N_reads samples, not all of which will satisfy >= min_coverage
std::vector<double> p_PCR(pop.begin(), pop.end());
gsl_ran_multinomial(r, bins, sample_size, p_PCR.data(), sample.data());
uint64_t valid_samples = 0;
for (const auto& i : sample) {
if (i >= min_coverage) {
valid_samples += i;
}
}
// 2.) proceed to add remaining samples
if (valid_samples < sample_size) {
gsl_ran_discrete_t* categorical_distrib = gsl_ran_discrete_preproc(bins, p_PCR.data());
intType ind;
while (valid_samples < sample_size) {
ind = gsl_ran_discrete(r, categorical_distrib);
++sample[ind];
if (sample[ind] > min_coverage) {
++valid_samples;
}
else {
if (sample[ind] == min_coverage)
valid_samples += min_coverage;
}
}
gsl_ran_discrete_free(categorical_distrib);
}
return sample;
}
// Resample
void pmap_resample(pmap_t *self, int scan_count)
{
int i, n;
double e, p, norm=0.0;
gsl_ran_discrete_t *dist=NULL;
pmap_sample_t *oldset=NULL, *newset=NULL;
pmap_sample_t *old=NULL, *newsample=NULL;
double *sample_probs;
sample_probs = new double[self->samples_len];
// Work out old and new sample sets
oldset = self->samples + self->sample_set * self->samples_len;
newset = self->samples + ((self->sample_set + 1) % 2) * self->samples_len;
// Convert to probability
for (i = 0; i < self->samples_len; i++)
{
old = oldset + i;
e = old->w / self->num_ranges / scan_count;
p = exp(-e / (self->resample_s * self->resample_s));
norm += p;
sample_probs[i] = p;
}
// Normalize probabiities
for (i = 0; i < self->samples_len; i++)
{
sample_probs[i] /= norm;
#ifdef __QNXNTO__
assert(std::finite(sample_probs[i]));
#else
assert(finite(sample_probs[i]));
#endif
}
dist = gsl_ran_discrete_preproc(self->samples_len, sample_probs);
assert(dist);
// Create discrete distribution
for (i = 0; i < self->samples_len; i++)
{
assert(self);
assert(self->rng);
n = gsl_ran_discrete(self->rng, dist);
old = oldset + n;
newsample = newset + i;
newsample->w = 0.0;
newsample->err = old->err;
newsample->pose = old->pose;
memcpy(newsample->cells, old->cells, self->grid_size);
memcpy(newsample->poses, old->poses, self->traj_size);
}
gsl_ran_discrete_free(dist);
delete [] sample_probs;
self->sample_set = (self->sample_set + 1) % 2;
return;
}
size_t operator()() {
return gsl_ran_discrete( m_rng, m_lookup );
}
int main(int argc, char *argv[])
{
/*no_mc == #MC ODEs; tstep = time step */
int i, j, no_mc = 27;
double tstep=1;
int par_index, sim_index;
gsl_matrix *pars_mat;
int prior = 0;
if(prior==1) {
pars_mat = readMatrix("../data/prior.csv");
} else {
pars_mat = readMatrix("../data/post.csv");
}
gsl_matrix *sim_mat = readMatrix("../data/sim.csv");
double *par_wts, *sim_wts;
par_wts = calloc(sizeof(double), pars_mat->size1);
sim_wts = calloc(sizeof(double), sim_mat->size1);
double *sps, *pars, *sps_gil;
sps = malloc(no_mc*sizeof(double));
sps_gil = malloc(6*sizeof(double));
/*Add in (fixed) k1 and k2 to pars*/
pars = malloc((pars_mat->size2+1)*sizeof(double));
/*total g & i*/
pars[pars_mat->size2-1] = 10; pars[pars_mat->size2] = 2;
gsl_ran_discrete_t *sim_sample, *par_sample;
gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937);
gsl_rng_set (r, 1);
par_sample = gsl_ran_discrete_preproc(pars_mat->size1, (const double *) par_wts);
sim_sample = gsl_ran_discrete_preproc(sim_mat->size1, (const double *) sim_wts);
/* 1. Select parameters from post (select row)
2. Select time point of interest (select column)
3. Simulate from MC and Gillespie one time unit
4. Compare
5. Profit
*/
for(i=0; i<10000; i++) {
if(prior == 1) {
par_index = i;
} else {
par_index = gsl_ran_discrete(r, par_sample);
}
sim_index = gsl_ran_discrete(r, sim_sample);
/*Reset MC */
for(j=0; j<no_mc;j++) {
sps[j] = 0;
}
/* Sps order: rg, ri, g, i, G, I
column zero iteration number
*/
sps[0] = MGET(sim_mat, sim_index, 1);
sps[2] = MGET(sim_mat, sim_index, 2);
sps[5] = MGET(sim_mat, sim_index, 3);
sps[9] = MGET(sim_mat, sim_index, 4);
sps[14] = MGET(sim_mat, sim_index, 5);
sps[20] = MGET(sim_mat, sim_index, 6);
for(j=0; j<(pars_mat->size2-1); j++) {
pars[j] = MGET(pars_mat, par_index, j+1);
}
sps_gil[0] = sps[0]; sps_gil[1] = sps[2]; sps_gil[2] = sps[5];
sps_gil[3] = sps[9]; sps_gil[4] = sps[14]; sps_gil[5] = sps[20];
/* simulate from MC */
ode(pars, tstep, sps);
gillespie(sps_gil, pars, tstep, r);
printf("%f, %f, %f, %f, %f, %f, %d, %d\n",
(sps[0] - sps_gil[0])/(pow(sps[1], 0.5)),
(sps[2] - sps_gil[1])/(pow(sps[4], 0.5)),
(sps[5] - sps_gil[2])/(pow(sps[8], 0.5)),
(sps[9] - sps_gil[3])/(pow(sps[13], 0.5)),
(sps[14] - sps_gil[4])/(pow(sps[19], 0.5)),
(sps[20] - sps_gil[5])/(pow(sps[26], 0.5)),
par_index, sim_index
);
}
return(EXIT_SUCCESS);
}
void test(int max, int size) {
std::vector<double> a;
std::vector<int> b;
double d[size];
for(int i = 0; i<size; i++) {
a.push_back(1.0/size);
b.push_back(1);
d[i] = rand();;
}
//s += std::to_string(max);
//s += "\t";
s += std::to_string(size);
s += "\t";
int sum = 0;
std::cout << std::endl << "Max: " << max << ";\t Size: " << size << std::endl << std::endl;
boost::mt19937 gen;
const gsl_rng_type * T;
gsl_rng * r;
gsl_rng_env_setup();
T = gsl_rng_default;
r = gsl_rng_alloc(T);
RandomLib::Random r2;
sum = 0;
clock_t startTime = clock();
//RandomLib
sum = 0;
startTime = clock();
RandomLib::RandomSelect<int> sel(b.begin(), b.end());
s += std::to_string(clock() - startTime);
s += "\t";
std::cout << "\t RandomLib: " << std::endl << "\t\t Initiate: " << clock() - startTime << std::endl;
startTime = clock();
for(int i = 0; i < max; i++) {
sum += sel(r2);
}
s += std::to_string(clock() - startTime);
s += "\t";
std::cout << "\t\t Generate: " << clock() - startTime << std::endl << "\t\t Sum: " << sum << std::endl;
//gnu science
sum = 0;
startTime = clock();
gsl_ran_discrete_t * table = gsl_ran_discrete_preproc(size, d);
s += std::to_string(clock() - startTime);
s += "\t";
std::cout << "\t Gnu Science: " << std::endl << "\t\t Initiate: " << clock() - startTime << std::endl;
startTime = clock();
for(int i = 0; i < max; i++) {
sum += gsl_ran_discrete(r, table);
}
s += std::to_string(clock() - startTime);
s += "\t";
std::cout << "\t\t Generate: " << clock() - startTime << std::endl << "\t\t Sum: " << sum << std::endl;
gsl_rng_free(r);
//boost
sum = 0;
startTime = clock();
boost::random::discrete_distribution<> dist(a.begin(), a.end());
//boost::random::discrete_distribution<> dist(b, b+size);
s += std::to_string(clock() - startTime);
s += "\t";
std::cout << "\t Boost: " << std::endl << "\t\t Initiate: " << clock() - startTime << std::endl;
startTime = clock();
for(int i = 0; i < max; i++) {
sum += dist(gen);
}
s += std::to_string(clock() - startTime);
s += "\t";
std::cout << "\t\t Generate: " << clock() - startTime << std::endl << "\t\t Sum: " << sum << std::endl;
//std::dsicrete_distribution
sum = 0;
startTime = clock();
std::discrete_distribution<int> std_dist(b.begin(), b.end());
s += std::to_string(clock() - startTime);
s += "\t";
std::cout << "\t std::discrete_distribution: " << std::endl << "\t\t Initiate: " << clock() - startTime << std::endl;
startTime = clock();
for(int i = 0; i < max; i++) {
sum += std_dist(gen);
}
s += std::to_string(clock() - startTime);
s += "\t";
std::cout << "\t\t Generate: " << clock() - startTime << std::endl << "\t\t Sum: " << sum << std::endl;
/*
//table-lookup
sum = 0;
startTime = clock();
random_distribution q(a);
s += std::to_string(clock() - startTime);
s += "\t";
std::cout << "\t Method 1: " << std::endl << "\t\t Initiate: " << clock() - startTime << std::endl;
startTime = clock();
for(int i = 0; i < max; i++) {
sum += q.dist();
}
s += std::to_string(clock() - startTime);
s += "\t";
std::cout << "\t\t Generate: " << clock() - startTime << std::endl << "\t\t Sum: " << sum << std::endl;
//std::cout << "\t\t i0: " << q.i0 << "\t i1: " << q.i1 << "\t i2: " << q.i2 << "\t i3: " << q.i3 << std::endl;
//table-lookup + histogram
sum = 0;
startTime = clock();
random_distribution q2(a,2);
s += std::to_string(clock() - startTime);
s += "\t";
std::cout << "\t Method 2: " << std::endl << "\t\t Initiate: " << clock() - startTime << std::endl;
startTime = clock();
for(int i = 0; i < max; i++) {
sum += q2.dist2();
}
s += std::to_string(clock() - startTime);
s += "\t";
std::cout << "\t\t Generate: " << clock() - startTime << std::endl << "\t\t Sum: " << sum << std::endl;
//binary search
sum = 0;
startTime = clock();
random_distribution q3(a,3);
s += std::to_string(clock() - startTime);
s += "\t";
std::cout << "\t Method 3: " << std::endl << "\t\t Initiate: " << clock() - startTime << std::endl;
startTime = clock();
for(int i = 0; i < max; i++) {
sum += q3.dist3();
}
s += std::to_string(clock() - startTime);
s += "\t";
std::cout << "\t\t Generate: " << clock() - startTime << std::endl << "\t\t Sum: " << sum << std::endl;
*/
s += "\n";
}
//! \brief Pick parent one
inline size_t
pick1(const gsl_rng *r) const
{
return gsl_ran_discrete(r, lookup.get());
}
int main()
{
gsl_rng * r;
const gsl_rng_type * T;
gsl_rng_env_setup();
T = gsl_rng_default;
r = gsl_rng_alloc (T);
// printf ("generator type: %s\n", gsl_rng_name (r));
// printf ("seed = %lu\n", gsl_rng_default_seed);
// printf ("first value = %lu\n", gsl_rng_get (r));
// Step 1
int k = 3; // k is the # of communities
const double alpha = double (1.0) / k;
// printf ("k = %d and alpha = %f\n", k, alpha);
double eta = 1; // eta is the hidden variable of the Beta distribution
double comm_str [k];
for (uint32_t i = 0; i < k; ++i)
comm_str[i] = gsl_ran_beta(r, eta, eta);
// Step 2
int n = 10; // Number of nodes
double theta = 1; // Used for gsl_ran_dirichlet
double alpha_array [k]; // Array for gsl_ran_dirichlet
for (uint32_t i = 0; i < k; ++i)
alpha_array[i] = alpha;
double pi [n][k]; // Array to store pi
// Populate pi
for (uint32_t i = 0; i < n; ++i)
gsl_ran_dirichlet(r, k, alpha_array, pi[i]);
// // Convert to binary
// for (uint32_t i = 0; i < n; ++i){
// for (uint32_t j = 0; j < k ; ++j){
// if (pi[i][j] > 0.5){
// pi[i][j] = 1;
// }
// else{
// pi[i][j] = 0;
// }
// }
// }
// for (uint32_t i = 0; i < n; ++i){
// for (uint32_t j = 0; j < k ; ++j){
// printf("%d, %d, %f\n", i, j ,pi[i][j]);
// }
// }
// Step 4
double mean = 0.0; // Set mean
double var = 1; // Set var
double prob = 0.5; // Set probability for Bernoulli
// Save input values
std::ofstream inputs ("inputs.txt");
if (inputs.is_open()){
inputs << "k = " << k << "\n";
inputs << "alpha = " << alpha << "\n";
inputs << "eta = " << eta << "\n";
inputs << "mean = " << mean << "\n";
inputs << "var = " << var << "\n";
inputs << "prob = " << prob << "\n";
inputs << "comm_str = ";
for (uint32_t i = 0; i < k; ++i)
inputs << comm_str[i] << " ";
inputs << "\n" << "n = " << n << "\n" << "pi = " << "\n";
for (uint32_t i = 0; i < n; ++i){
for (uint32_t j = 0; j < k ; ++j){
inputs << pi[i][j] << "\t";
}
inputs << "\n";
}
inputs.close();
}
// Save attribute matrix
std::ofstream attributes ("attributes.txt");
if (attributes.is_open()){
for (uint32_t i = 0; i < n; ++i){
attributes << gsl_ran_gaussian(r, var) << "\t";
attributes << gsl_ran_gaussian(r, var) << "\t";
attributes << gsl_ran_bernoulli(r, prob) << "\t";
attributes << gsl_ran_bernoulli(r, prob) << "\t";
attributes << "\n";
}
attributes.close();
}
// Step 3
int num_edge = 20; // Define number of edges
double epsilon = 1e-30;
int adj_matrix [n][n];
// Populate adjancency matrix with 0s
for (uint32_t i = 0; i < n; ++i)
for (uint32_t j = 0; j < n ; ++j)
adj_matrix[i][j] = 0;
int count = 0;
while (count < num_edge){
// printf("count %d\n", count);
int a = gsl_rng_uniform_int(r, n);
int b = gsl_rng_uniform_int(r, n);
// printf("%d, %d\n", a, b);
if (a == b){
continue;
}
double a_probs [k];
double b_probs [k];
for (uint32_t i = 0; i < k; ++i){
a_probs[i] = pi[a][i];
b_probs[i] = pi[b][i];
}
int a_val = gsl_ran_discrete(r, gsl_ran_discrete_preproc(k, a_probs));
int b_val = gsl_ran_discrete(r, gsl_ran_discrete_preproc(k, b_probs));
if (a_val == b_val){
// printf("%d, %d\n", a_val, b_val);
int x = gsl_ran_bernoulli(r, comm_str[a_val]);
if (x == 1){
// printf("x = 1\n");
if (adj_matrix[a][b] == 0){
adj_matrix[a][b] = 1;
++count;
}
}
}
else{
int x = gsl_ran_bernoulli(r, epsilon);
if (x == 1){
// printf("x = 1\n");
if (adj_matrix[a][b] == 0){
adj_matrix[a][b] = 1;
++count;
}
}
}
// for (uint32_t j = 0; j < k ; ++j){
// if (std::pi[a][j] == pi[b][j]){
// int x = gsl_ran_bernoulli(r, comm_str[j]);
// // printf("Match 1 %d\n", x);
// if (x == 1){
// if (adj_matrix[a][b])
// continue;
// else
// adj_matrix[a][b] = 1;
// run_eps = 0;
// ++count;
// continue;
// }
// }
// if (run_eps == 1){
// int x = gsl_ran_bernoulli(r, epsilon);
// // printf("0 %d\n", x);
// if (x == 1){
// if (adj_matrix[a][b])
// continue;
// else
// adj_matrix[a][b] = 1;
// ++count;
// continue;
// }
// }
// }
}
std::ofstream matrix ("matrix.txt");
if (matrix.is_open()){
for (uint32_t i = 0; i < n; ++i){
for (uint32_t j = 0; j < n ; ++j){
if (adj_matrix [i][j])
matrix << i << "\t" << j << '\n';
}
}
matrix.close();
}
}
