//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(); } }