/** * @brief Swap a ranges order */ void SwapRange (const Matrix<size_t>& sol, Matrix<size_t>& nsol) { size_t i, x, y, pos, nr = numel(sol); // copy the current solution nsol = sol; // pick two places do not touch start x = gsl_rng_uniform_int (m_rng, nr-1) + 1; y = gsl_rng_uniform_int (m_rng, nr-1) + 1; // Swap if (y < x) { pos = x; x = y; y = pos; } else if (x == y) return; // Create a temporary array that holds all the values between place1 and place2 size_t len = y - x + 1; container<size_t> cut (len); i = len; while (i--) nsol[x+len-1-i] = sol[x+i]; }
pcat_knob_value_ random_knob_value_uniform( pcat_knob k, gsl_rng *r ) { pcat_knob_value_ v; switch ( k->kind ) { case PCAT_KNOBK_DISCRETE: { if( k->_.d.range < 1000000 ) { unsigned long int i = gsl_rng_uniform_int( r, (unsigned long int)k->_.d.range ); v.d = i + k->_.d.min; return v; } assert( FALSE ); } case PCAT_KNOBK_CONTINUOUS: { v.c = k->_.c.range * gsl_rng_uniform( r ) + k->_.c.min; return v; } case PCAT_KNOBK_UNORDERED: { v.u = (uint8_t)gsl_rng_uniform_int( r, (unsigned long int)k->_.u._->option_count ); return v; } default: assert( FALSE ); } }
void mutate (evolve_int_chrom_t *chrom) { size_t point = gsl_rng_uniform_int (rng, chrom->size - 1); while (!chrom->vector[point]) /* chrom->vector[point] != 1 */ point = gsl_rng_uniform_int (rng, chrom->size - 1); chrom->vector[point] = 0; }
/* Erdos-Renyi : G(n,M) */ igraph_t *ggen_generate_erdos_gnm(gsl_rng *r, unsigned long n, unsigned long m) { igraph_matrix_t adj; igraph_t *g = NULL; int err; unsigned long i,j; unsigned long added_edges = 0; ggen_error_start_stack(); if(r == NULL) GGEN_SET_ERRNO(GGEN_EINVAL); if(m > (n*(n-1)/2)) GGEN_SET_ERRNO(GGEN_EINVAL); g = malloc(sizeof(igraph_t)); GGEN_CHECK_ALLOC(g); GGEN_FINALLY3(free,g,1); if(m == 0 || n <= 1) { GGEN_CHECK_IGRAPH(igraph_empty(g,n,1)); goto end; } if(m == (n*(n-1))/2) { GGEN_CHECK_IGRAPH(igraph_full_citation(g,n,1)); goto end; } GGEN_CHECK_IGRAPH(igraph_matrix_init(&adj,n,n)); GGEN_FINALLY(igraph_matrix_destroy,&adj); igraph_matrix_null(&adj); while(added_edges < m) { GGEN_CHECK_GSL_DO(i = gsl_rng_uniform_int(r,n)); GGEN_CHECK_GSL_DO(j = gsl_rng_uniform_int(r,n)); if(i < j && igraph_matrix_e(&adj,i,j) == 0) { igraph_matrix_set(&adj,i,j,1); added_edges++; } } GGEN_CHECK_IGRAPH(igraph_adjacency(g,&adj,IGRAPH_ADJ_DIRECTED)); end: ggen_error_clean(1); return g; ggen_error_label: return NULL; }
void IsingModel2dDipole::metropolis_mirror() { // vertical or horizontal mirroring? bool mode = gsl_rng_uniform_int( rng, 2 ); unsigned int fmline = gsl_rng_uniform_int( rng, size - 1 ) + 1; unsigned int fmcol = gsl_rng_uniform_int( rng, size - 1 ) + 1; if ( mode ) { // mirroring: horizontal for ( unsigned int l = fmline; l < size; l++ ) { for ( unsigned int c = 0; c < size; c++ ) { spin[l][c].flip(); } } } else { // mirroring: vertical for ( unsigned int c = fmcol; c < size; c++ ) { for ( unsigned int l = 0; l < size; l++ ) { spin[l][c].flip(); } } } // energy difference double deltaH = H() - H_memory; if ( deltaH > 0 ) { // accept the new state? if ( gsl_rng_uniform( rng ) > exp( - deltaH / T ) ) { // new state rejected ... reverting! if ( mode ) { // mirroring: horizontal for ( unsigned int l = fmline; l < size; l++ ) { for ( unsigned int c = 0; c < size; c++ ) { spin[l][c].flip(); } } } else { // mirroring: vertical for ( unsigned int c = fmcol; c < size; c++ ) { for ( unsigned int l = 0; l < size; l++ ) { spin[l][c].flip(); } } } return; } } H_memory += deltaH; }
//********************************************************************** //********************************************************************** ///a function that chooses two edgess at random that if they are swaped we avoid multipledges or selfedges. /// we try to choose a second link E times. if we dont find it we return a 0 int choose_2_edges_random(GRAPH* G,int *pos_r,int *pos_s,gsl_rng* randgsl){ int j,rand1,rand2=0,r1,r2,s1,s2,correct,tries; rand1 = gsl_rng_uniform_int(randgsl,G->E); ///we choose an edges at random r1 = G->edge[rand1].s; r2 = G->edge[rand1].d; if(r1==r2){printf("there is a selflink!!!\n");fflush(stdout);} correct=0; ///in order to be able to enter into the loop tries = 0; ///a variable that controls how many times we have tried to choose another link while(!correct && tries < G->E){///we choose a second edges at random with some constrains rand2 = gsl_rng_uniform_int(randgsl,G->E); s1 = G->edge[rand2].s; s2 = G->edge[rand2].d; if(s1==s2){printf("there is a selflink!!!\n");fflush(stdout);} correct=1; /// we assume that it is correct if(s1==r1 || s1==r2 || s2==r1 || s2==r2)correct=0; /// we look if all the for nodes are different else { for(j=0;j<G->node[s1].k;++j){ if(G->node[s1].out[j]==r2) correct=0; /// we look if the node s1 is not already connected with r2 to avoid a multiple link } for(j=0;j<G->node[r1].k;++j){ if(G->node[r1].out[j]==s2) correct=0; /// we look if the node r1 is not already connected with s2 to avoid a multiple link } } tries++; } *pos_r = rand1; *pos_s = rand2; if(tries == G->E) return 0; ///we could not fins a proper pair of links we return a 0. else return 1; }
void MoleculePopulateProcess::populateUniformSparse(Species* aSpecies) { Comp* aComp(aSpecies->getComp()); if(!aSpecies->getIsPopulated()) { if(UniformRadiusX == 1 && UniformRadiusY == 1 && UniformRadiusZ == 1 && !OriginX && !OriginY && !OriginZ) { unsigned int aSize(aSpecies->getPopulateMoleculeSize()); int availableVoxelSize(aComp->coords.size()); for(unsigned int j(0); j != aSize; ++j) { Voxel* aVoxel; do { aVoxel = theSpatiocyteStepper->coord2voxel( aComp->coords[gsl_rng_uniform_int( getStepper()->getRng(), availableVoxelSize)]); } while(aVoxel->id != aComp->vacantID); aSpecies->addMolecule(aVoxel); } } else { populateUniformRanged(aSpecies); } aSpecies->setIsPopulated(); } }
void do_balanced_multi_tree_inference(FILE *logfp, mcmc_t *mcmc, node_t **subtrees, node_t **wholetrees, gslws_t *wses, sampman_t *sms, ubertree_t *ut, int burnin, int samples, int lag) { int i, j; /* Burn in */ for(i=0; i<burnin; i++) balanced_multi_tree_mcmc_iteration(logfp, mcmc, subtrees, wses); /* Take samples */ for(i=0; i<samples; i++) { if(gsl_rng_uniform_int(mcmc->r, 10000) >= 9999) { /* Random restart! */ random_restart(mcmc); compute_balanced_multi_tree_probabilities(mcmc, subtrees, wses); for(j=0; j<burnin; j++) balanced_multi_tree_mcmc_iteration(logfp, mcmc, subtrees, wses); } for(j=0; j<lag; j++) { balanced_multi_tree_mcmc_iteration(logfp, mcmc, subtrees, wses); } build_q(mcmc); for(j=0; j<NUM_TREES; j++) { upwards_belprop(logfp, wholetrees[j], mcmc->Q, &wses[j]); process_sample(&sms[j], mcmc, &wses[j], wholetrees[j]); } if(ut != NULL) update_ubertree(ut, wholetrees, mcmc->Q, &wses[0]); } }
/* l is a degree number, between 1 and the degree of the polynomial associated with the dimension being initialized */ static int sobol_init_direction(gsl_rng *r, int l) { /* See Peter Jaeckel, Monte Carlo Methods in Finance, Wiley 2002, p86. */ int wkl = gsl_rng_uniform_int(r, 1<<l) | 1; return wkl; }
void population::evolve(int gen) { //Wright-Fisher Model - Population size is held constant. Parental genotypes are chosen randomly. for (int j=0; j<gen; j++){ vector<genome> newPop (N); avgFit = 0; for(int i=0; i<N; i++) { if (r == 1) { newPop[i] = progeny(selectParents()); avgFit += newPop[i].get_fit(); } else if ((r != 0) && gsl_rng_uniform(rng) <= r) { newPop[i] = progeny(selectParents()); avgFit += newPop[i].get_fit(); } else { if (neutral) {newPop[i] = pop[(int)gsl_rng_uniform_int(rng,N)];} else { double fit_rand = selective_weight[N-1]*gsl_rng_uniform(rng); newPop[i] = pop[binarySearch_int(selective_weight, 0, N-1, fit_rand)]; avgFit += newPop[i].get_fit(); } } } avgFit/= N; pop = newPop; gen_pop++; update_weights(); //updateBlockSizes(); if (!neutral) {update_selection_weights();} } update_weights(); updateBlockSizes(); //if (WRITEHIST) {writeBlockHist();} }
// len is number of edges, void update_allele(dBNode** allele, int len, int colour, int covg, int eff_read_len) { const gsl_rng_type * T; gsl_rng * r; gsl_rng_env_setup(); T = gsl_rng_default; r = gsl_rng_alloc (T); int i; //add covg number of reads, placing them randomly on the allele for (i = 0; i < covg; i++) { int u=0; while (u==0) { u = gsl_rng_uniform_int(r,len); } //now add coverage: int j; for (j=u; (j<u+eff_read_len) && (j<len); j++) { db_node_increment_coverage(allele[j], colour); } } gsl_rng_free (r); }
void do_single_tree_inference(FILE *logfp, mcmc_t *mcmc, node_t *tree, gslws_t *ws, sampman_t *sm, int burnin, int samples, int lag) { int i, j; /* Burn in */ for(i=0; i<burnin; i++) single_tree_mcmc_iteration(logfp, mcmc, tree, ws); /* Take samples */ for(i=0; i<samples; i++) { if(gsl_rng_uniform_int(mcmc->r, 10000) >= 9999) { /* Random restart! */ random_restart(mcmc); compute_single_tree_probabilities(mcmc, tree, ws); for(j=0; j<burnin; j++) single_tree_mcmc_iteration(logfp, mcmc, tree, ws); } for(j=0; j<lag; j++) { single_tree_mcmc_iteration(logfp, mcmc, tree, ws); } build_q(mcmc); upwards_belprop(logfp, tree, mcmc->Q, ws); /* Record sample */ process_sample(sm, mcmc, ws, tree); } /* Do computations for Q matrices sampled from the pior * and log stuff so we can do importance sampling for * marginal likelihood later */ for(i=0; i<samples; i++) { draw_proposal_from_prior(mcmc, ws); mcmc->log_prior = get_log_prior(mcmc->stabs_dash, mcmc->trans_dash); mcmc->log_lh = get_model_loglh(tree, mcmc->Q_dash, ws); mcmc->log_poster = mcmc->log_prior + mcmc->log_lh; process_prior_sample(sm, mcmc, ws); } }
//function to test the fourier transform, output is written to the error stream int hypercube_lowd::test() { int tp, sign; double res; cerr <<"hypercube_lowd::test()...\n"; for (int i=0; i<100; i++) { res=0; //draw a random integer tp=gsl_rng_uniform_int(rng,1<<dim); for (int c=0; c<(1<<dim); c++) //assemble the function value from its spins, go over all coeffcients, index c { sign=1; for (int k=0; k<dim; k++) { if (!(tp&(1<<k)) && (c&(1<<k))) //determine the sign the coeff enters { sign*=-1; //multiply by minus one, every time a bit is not set although it the contribution depends on the bit } } res+=sign*coeff[c]; //add the coeff with the correct sign } cerr <<setw(15)<<func[tp]<<setw(15)<<res<<setw(15)<<func[tp]-res<<endl; //output result, function value and difference, the latter should be zero } cerr <<"done\n"; return 0; }
std::map<STM::ParName, double> Metropolis::do_sample(int n, bool saveDeviance) // n is the number of samples to take // returns a map of acceptance rates keyed by parameter name { // shuffle the order of parameters std::vector<STM::ParName> parNames (parameters.active_names()); std::random_shuffle(parNames.begin(), parNames.end(), [this](int n){ return gsl_rng_uniform_int(rng.get(), n); }); std::map<STM::ParName, int> numAccepted; for(const auto & par : parNames) numAccepted[par] = 0; for(int i = 0; i < n; i++) { for(int j = 0; j < thinSize; j++) { // step through each parameter for(const auto & par : parNames) { STM::ParPair proposal = propose_parameter(par); numAccepted[par] += select_parameter(proposal); } } parameters.increment(); currentSamples.push_back(parameters.current_state()); if(saveDeviance) sampleDeviance.push_back(std::pair<double, int>(-2 * currentLL, 1)); // if desired, some debugging output if(outputLevel >= EngineOutputLevel::Verbose) { std::cerr << " iteration " << parameters.iteration() - 1 << " posterior probability: " << currentPosteriorProb << " likelihood: " << currentLL << "\n"; if(outputLevel >= EngineOutputLevel::ExtraVerbose) { std::ios_base::fmtflags oldflags = std::cerr.flags(); std::streamsize oldprecision = std::cerr.precision(); std::cerr << std::fixed << std::setprecision(3) << " "; STM::ParMap st = parameters.current_state(); int coln = 0; for(auto pa : st) { std::cerr << std::setw(6) << pa.first << std::setw(8) << pa.second; if(++coln >= 7) { std::cerr << "\n "; coln = 0; } } std::cerr << std::endl; std::cerr.flags (oldflags); std::cerr.precision (oldprecision); } } } std::map<STM::ParName, double> acceptanceRates; for(const auto & par : parNames) acceptanceRates[par] = double(numAccepted[par]) / (n*thinSize); return acceptanceRates; }
void rng_parallel_state_test (const gsl_rng_type * T) { unsigned long int test_a[N], test_b[N]; unsigned long int test_c[N], test_d[N]; double test_e[N], test_f[N]; int i; gsl_rng *r1 = gsl_rng_alloc (T); gsl_rng *r2 = gsl_rng_alloc (T); for (i = 0; i < N; ++i) { gsl_rng_get (r1); /* throw away N iterations */ } gsl_rng_memcpy (r2, r1); /* save the intermediate state */ for (i = 0; i < N; ++i) { /* check that there is no hidden state intermixed between r1 and r2 */ test_a[i] = gsl_rng_get (r1); test_b[i] = gsl_rng_get (r2); test_c[i] = gsl_rng_uniform_int (r1, 1234); test_d[i] = gsl_rng_uniform_int (r2, 1234); test_e[i] = gsl_rng_uniform (r1); test_f[i] = gsl_rng_uniform (r2); } { int status = 0; for (i = 0; i < N; ++i) { status |= (test_b[i] != test_a[i]); status |= (test_c[i] != test_d[i]); status |= (test_e[i] != test_f[i]); } /*gsl_test (status, "%s, parallel random number state * consistency",*/ /*gsl_rng_name (r1));*/ } gsl_rng_free (r1); gsl_rng_free (r2); }
int random_int(int a, int b) { init_rand(); #ifdef HAVE_LIBGSL return ((int) gsl_rng_uniform_int(rng, b-a+1)) + a; #else return a + rand() % (b-a+1); #endif }
static VALUE rb_gsl_rng_uniform_int(VALUE obj, VALUE n) { gsl_rng *r = NULL; unsigned long int nn; nn = NUM2UINT(n); Data_Get_Struct(obj, gsl_rng, r); return UINT2NUM(gsl_rng_uniform_int(r, nn)); }
/* We will use a 30-bit random prime, so that all operations can be represented with 32-bit integers, since the alphabet ACGT can be represented with 2 bits. */ static uint32_t random_prime(gsl_rng* generator) { uint32_t p = 0; do { p = 2 * gsl_rng_uniform_int(generator, 1 << 29) + 1; } while (p < (1 << 16) || !primep(p)); assert(p < (1<<30)); return p; }
virtual void fire() { int col(gsl_rng_uniform_int(getStepper()->getRng(), theComp->maxCol-theComp->minCol-4)); col += theComp->minCol; theSpatiocyteStepper->growCompartment(theComp, Axis, col); theTime += theStepInterval; thePriorityQueue->moveTop(); }
int Unifrnd_Int(int range) { #if EXTLIB_EXIST(GSL) gsl_rng_init(); return gsl_rng_uniform_int(Random_Generator, range); #else return genrand_int32() % (range + 1); #endif }
void IsingModel2dDipole::metropolis_blockflip() { // generate coordinates of the block unsigned int temp; unsigned int l1 = gsl_rng_uniform_int( rng, size ); unsigned int l2 = gsl_rng_uniform_int( rng, size ); if ( l1 > l2 ) { temp = l1; l1 = l2; l2 = temp; } unsigned int c1 = gsl_rng_uniform_int( rng, size ); unsigned int c2 = gsl_rng_uniform_int( rng, size ); if ( c1 > c2 ) { temp = c1; c1 = c2; c2 = temp; } // flip the block for ( unsigned int l = l1; l <= l2; l++ ) { for ( unsigned int c = c1; c <= c2; c++ ) { spin[l][c].flip(); } } // energy difference double deltaH = H() - H_memory; if ( deltaH > 0 ) { // accept the new state? if ( gsl_rng_uniform( rng ) > exp( - deltaH / T ) ) { // new state rejected ... reverting! for ( unsigned int l = l1; l <= l2; l++ ) { for ( unsigned int c = c1; c <= c2; c++ ) { spin[l][c].flip(); } } return; } } H_memory += deltaH; }
int randint(int n) { /* * returns a random integer in [0,n-1] */ if (n <= 0) debug("invalid input to randint"); unsigned long int r; r = gsl_rng_uniform_int(RANDOM_NUMBER, (int)n); if (r > INT_MAX) debug("problem in randint"); return (int)r; }
void Roulette_wheel::select_ind( int *mum ){ *mum = gsl_rng_uniform_int (GSL_randon_generator::r_rand, num_tot_solutions ); double reference = gsl_rng_uniform(GSL_randon_generator::r_rand) * wheel[num_tot_solutions-1]; for (int selected = num_solutions_truncated; selected < num_tot_solutions; selected++ ){ if(reference < wheel[selected] ){ *mum = rank[selected]; break; } } }
int GlmTest::resampSmryCase(glm *model, gsl_matrix *bT, GrpMat *GrpXs, gsl_matrix *bO, unsigned int i ) { gsl_set_error_handler_off(); int status, isValid=TRUE; unsigned int j, k, id; gsl_vector_view yj, oj, xj; gsl_matrix *tXX = NULL; unsigned int nRows=tm->nRows, nParam=tm->nParam; if (bootID == NULL) { tXX = gsl_matrix_alloc(nParam, nParam); while (isValid==TRUE) { // if all isSingular==TRUE if (tm->reprand!=TRUE) GetRNGstate(); for (j=0; j<nRows; j++) { // resample Y, X, offsets accordingly if (tm->reprand==TRUE) id = (unsigned int) gsl_rng_uniform_int(rnd, nRows); else id = (unsigned int) nRows * Rf_runif(0, 1); xj = gsl_matrix_row(model->Xref, id); gsl_matrix_set_row(GrpXs[0].matrix, j, &xj.vector); yj = gsl_matrix_row(model->Yref, id); gsl_matrix_set_row(bT, j, &yj.vector); oj = gsl_matrix_row(model->Eta, id); gsl_matrix_set_row(bO, j, &oj.vector); } if (tm->reprand!=TRUE) PutRNGstate(); gsl_matrix_set_identity(tXX); gsl_blas_dsyrk(CblasLower,CblasTrans,1.0,GrpXs[0].matrix,0.0,tXX); status=gsl_linalg_cholesky_decomp(tXX); if (status!=GSL_EDOM) break; // if (calcDet(tXX)>eps) break; } for (k=2; k<nParam+2; k++) subX2(GrpXs[0].matrix, k-2, GrpXs[k].matrix); } else { for (j=0; j<nRows; j++) { id = (unsigned int) gsl_matrix_get(bootID, i, j); // resample Y and X and offset yj=gsl_matrix_row(model->Yref, id); gsl_matrix_set_row (bT, j, &yj.vector); oj = gsl_matrix_row(model->Eta, id); gsl_matrix_set_row(bO, j, &oj.vector); xj = gsl_matrix_row(model->Xref, id); gsl_matrix_set_row(GrpXs[0].matrix, j, &xj.vector); } for (k=2; k<nParam+2; k++) subX2(GrpXs[0].matrix, k-2, GrpXs[k].matrix); } gsl_matrix_free(tXX); return SUCCESS; }
pair<int,int> population::selectParents(){ //Parents are selected at random from population pair<int,int> ancestors; if (neutral) { //Neutral Evolution ancestors.first = (int)gsl_rng_uniform_int(rng,N); ancestors.second = (int)gsl_rng_uniform_int(rng,N); } else { //Selection! double fit_rand1 = selective_weight[N-1]*gsl_rng_uniform(rng); double fit_rand2 = selective_weight[N-1]*gsl_rng_uniform(rng); ancestors.first = binarySearch_int(selective_weight, 0, N-1, fit_rand1); ancestors.second = binarySearch_int(selective_weight, 0, N-1, fit_rand2); } //Recursive definition to ensure unique parents. if (ancestors.second == ancestors.first) { return selectParents(); } else { return ancestors; } }
/* Samples either one change point or one probability */ void sampleMixed(const gsl_rng *r, parameters* p, int nPar, intparameters *ip, int nIPar) { static int hello=1; double pr=gsl_rng_uniform(r); int moveK=pr<mixingRatio; const int *CDFdata=getData(), nCDFdata=getNdata(); if(hello) fprintf(OUT, "sampleMixed()...\n"), hello=0; /* Set proposed changepoint locations and probabilities to current values.*/ resetProposals(p, nPar, ip, nIPar); /* Assuming there is NO changepoint */ if(nIPar<=0) moveK=0; if(moveK) { double pJump=0.1; /* Which k shall be moved? */ int indK=gsl_rng_uniform_int(r, nIPar); int kDown=(indK-1>=0)?getIntParameter(ip,indK-1):0; int kUp=(indK+1<nIPar)?getIntParameter(ip,indK+1):getNdata(); int kNew; int succ0, succ1; int fail0, fail1; double p0, p1; setIntMin(ip, indK, kDown); setIntMax(ip, indK, kUp); if(gsl_rng_uniform(r)>=pJump) { /*Move only one parameter by width */ proposeIntConstrainedAB(r, ip, indK, 1); } else { proposeIntShiftInterval(r, ip, indK, 1); } /* Update probabilities */ kNew=getIntProposal(ip,indK); succ0=succInterval(CDFdata, kDown, kNew); succ1=succInterval(CDFdata, kNew, kUp); fail0=kNew-kDown-succ0; fail1=kUp-kNew-succ1; p0=gsl_ran_beta(r, succ0, fail0); p1=gsl_ran_beta(r, succ1,fail1); setProposal(p, indK, p0); setProposal(p, indK+1, p1); } else { sampleProbabilities(r, CDFdata, nCDFdata, p, nPar, ip, nIPar); } }
/* Randomly assigns all spins */ void init ( int ** F, int L, gsl_rng * r ) { int i,j; /* Visit each position (i,j) in the lattice */ for (i=0;i<L;i++) { for (j=0;j<L;j++) { /* 2*x-1, where x is randomly 0,1 */ F[i][j]=2*(int)gsl_rng_uniform_int(r,2)-1; } } }
void run_lasso_computation(ProblemData<L, D> &inst, std::vector<D> &h_Li, int omp_threads, D sigma, int N, int blockReduction, std::vector<gsl_rng *>& rs, ofstream& experimentLogFile,int multiply=100) { omp_set_num_threads(omp_threads); init_random_seeds(rs); L n = inst.n; L m = inst.m; std::vector<D> residuals(m); Losses<L, D, square_loss_traits>::bulkIterations(inst, residuals); D fvalInit = Losses<L, D, square_loss_traits>::compute_fast_objective(inst, residuals); double totalRunningTime = 0; double iterations = 0; L perPartIterations =multiply* n / blockReduction; double additional = perPartIterations / (0.0 + n); D fval = fvalInit; // store initial objective value experimentLogFile << setprecision(16) << omp_threads << "," << n << "," << m << "," << sigma << "," << totalRunningTime << "," << iterations << "," << fval << endl; //iterate for (int totalIt = 0; totalIt < N; totalIt++) { double startTime = gettime_(); #pragma omp parallel for for (L it = 0; it < perPartIterations; it++) { // one step of the algorithm unsigned long int idx = gsl_rng_uniform_int(gsl_rng_r, n); Losses<L, D, square_loss_traits>::do_single_iteration_parallel(inst, idx, residuals, inst.x, h_Li); } double endTime = gettime_(); iterations += additional; totalRunningTime += endTime - startTime; // recompute residuals - this step is not necessary but if accumulation of rounding errors occurs it is useful if (totalIt % 3 == 0) { Losses<L, D, square_loss_traits>::bulkIterations(inst, residuals); } fval = Losses<L, D, square_loss_traits>::compute_fast_objective(inst, residuals); int nnz = 0; #pragma omp parallel for reduction(+:nnz) for (L i = 0; i < n; i++) if (inst.x[i] != 0) nnz++; cout << omp_threads << "," << n << "," << m << "," << sigma << "," << totalRunningTime << "," << iterations << "," << setprecision(15)<<fval << "," << nnz << endl; experimentLogFile << setprecision(16) << omp_threads << "," << n << "," << m << "," << sigma << "," << totalRunningTime << "," << iterations << "," << setprecision(15)<<fval << "," << nnz << endl; } }
apop_data * apop_bootstrap_cov_base(apop_data * data, apop_model *model, gsl_rng *rng, int iterations, char keep_boots, char ignore_nans, apop_data **boot_store){ #endif Get_vmsizes(data); //vsize, msize1, msize2 apop_model *e = apop_model_copy(model); apop_data *subset = apop_data_copy(data); apop_data *array_of_boots = NULL, *summary; //prevent and infinite regression of covariance calculation. Apop_model_add_group(e, apop_parts_wanted); //default wants for nothing. size_t i, nan_draws=0; apop_name *tmpnames = (data && data->names) ? data->names : NULL; //save on some copying below. if (data && data->names) data->names = NULL; int height = GSL_MAX(msize1, GSL_MAX(vsize, (data?(*data->textsize):0))); for (i=0; i<iterations && nan_draws < iterations; i++){ for (size_t j=0; j< height; j++){ //create the data set size_t randrow = gsl_rng_uniform_int(rng, height); apop_data_memcpy(Apop_r(subset, j), Apop_r(data, randrow)); } //get the parameter estimates. apop_model *est = apop_estimate(subset, e); gsl_vector *estp = apop_data_pack(est->parameters); if (!gsl_isnan(apop_sum(estp))){ if (i==0){ array_of_boots = apop_data_alloc(iterations, estp->size); apop_name_stack(array_of_boots->names, est->parameters->names, 'c', 'v'); apop_name_stack(array_of_boots->names, est->parameters->names, 'c', 'c'); apop_name_stack(array_of_boots->names, est->parameters->names, 'c', 'r'); } gsl_matrix_set_row(array_of_boots->matrix, i, estp); } else if (ignore_nans=='y'){ i--; nan_draws++; } apop_model_free(est); gsl_vector_free(estp); } if(data) data->names = tmpnames; apop_data_free(subset); apop_model_free(e); int set_error=0; Apop_stopif(i == 0 && nan_draws == iterations, apop_return_data_error(N), 1, "I ran into %i NaNs and no not-NaN estimations, and so stopped. " , iterations); Apop_stopif(nan_draws == iterations, set_error++; apop_matrix_realloc(array_of_boots->matrix, i, array_of_boots->matrix->size2), 1, "I ran into %i NaNs, and so stopped. Returning results based " "on %zu bootstrap iterations.", iterations, i); summary = apop_data_covariance(array_of_boots); if (boot_store) *boot_store = array_of_boots; else apop_data_free(array_of_boots); if (set_error) summary->error = 'N'; return summary; }
void IsingMatrix::flip() { int i = gsl_rng_uniform_int(rnd,s); iold = i; Eold = E; Mold = M; matrix[i] *= -1; E -= 2*matrix[i]*(J*(matrix[PlusX(i)]+matrix[MinusX(i)]+matrix[PlusY(i)]+matrix[MinusY(i)])+H); M += 2*matrix[i]; }