unsigned int som::train(bool autostop) { previous_weights = NULL; for (unsigned int epouch = 1; epouch < (epouchs + 1); epouch++) { /* Depression term of coupling */ local_radius = std::pow( ( params.init_radius * std::exp(-( (double) epouch / (double) epouchs)) ), 2); learn_rate = params.init_learn_rate * std::exp(-( (double) epouch / (double) epouchs)); /* Feature SOM 0003: Clear statistics */ if (autostop == true) { for (unsigned int i = 0; i < size; i++) { (*awards)[i] = 0; (*capture_objects)[i]->clear(); } } for (unsigned int i = 0; i < data->size(); i++) { /* Step 1: Competition */ unsigned int index_winner = competition(&(*data)[i]); /* Step 2: Adaptation */ adaptation(index_winner, &(*data)[i]); /* Update statistics */ if ( (autostop == true) || (epouch == (epouchs - 1)) ) { (*awards)[index_winner]++; (*capture_objects)[index_winner]->push_back(i); } } /* Feature SOM 0003: Check requirement of stopping */ if (autostop == true) { if (previous_weights == NULL) { previous_weights = new std::vector<std::vector<double> * >(size, NULL); unsigned int dimensions = (*weights)[0]->size(); for (unsigned int i = 0; i < weights->size(); i++) { (*previous_weights)[i] = new std::vector<double>(dimensions, 0.0); std::copy((*weights)[i]->begin(), (*weights)[i]->end(), (*previous_weights)[i]->begin()); } } else { double maximal_adaptation = calculate_maximal_adaptation(); if (maximal_adaptation < params.adaptation_threshold) { return epouch; } for (unsigned int i = 0; i < weights->size(); i++) { std::copy((*weights)[i]->begin(), (*weights)[i]->end(), (*previous_weights)[i]->begin()); } } } } return epouchs; }
static void adaptation_of_medias(axl_network *mysys) { int i, j; axl_mass_media *mm; for(i = 0; i < mysys->nmm; i++) { for(j = 0; j < mysys->mass_media[i].f; j++) { mm = &(mysys->mass_media[i]); adaptation(mm, *mysys, j); } } return; }
void function_minimizer::shmc_mcmc_routine(int nmcmc,int iseed0,double dscale, int restart_flag) { if (nmcmc<=0) { cerr << endl << "Error: Negative iterations for MCMC not meaningful" << endl; ad_exit(1); } uostream * pofs_psave=NULL; if (mcmc2_flag==1) { initial_params::restore_start_phase(); } initial_params::set_inactive_random_effects(); initial_params::set_active_random_effects(); int nvar_re=initial_params::nvarcalc(); int nvar=initial_params::nvarcalc(); // get the number of active parameters if (mcmc2_flag==0) { initial_params::set_inactive_random_effects(); nvar=initial_params::nvarcalc(); // get the number of active parameters } initial_params::restore_start_phase(); independent_variables parsave(1,nvar_re); // dvector x(1,nvar); // initial_params::xinit(x); // dvector pen_vector(1,nvar); // { // initial_params::reset(dvar_vector(x),pen_vector); // } initial_params::mc_phase=1; int old_Hybrid_bounded_flag=-1; int on,nopt = 0; //// ------------------------------ Parse input options // Step size. If not specified, will be adapted. If specified must be >0 // and will not be adapted. double eps=0.1; double _eps=-1.0; int useDA=1; // whether to adapt step size if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-hyeps",nopt))>-1) { if (!nopt) // not specified means to adapt, using function below to find reasonable one { cerr << "Warning: No step size given after -hyeps, ignoring" << endl; useDA=1; } else // read in specified value and do not adapt { istringstream ist(ad_comm::argv[on+1]); ist >> _eps; if (_eps<=0) { cerr << "Error: step size (-hyeps argument) needs positive number"; ad_exit(1); } else { eps=_eps; useDA=0; } } } // Chain number -- for console display purposes only int chain=1; if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-chain",nopt))>-1) { if (nopt) { int iii=atoi(ad_comm::argv[on+1]); if (iii <1) { cerr << "Error: chain must be >= 1" << endl; ad_exit(1); } else { chain=iii; } } } // Number of leapfrog steps. Defaults to 10. int L=10; if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-hynstep",nopt))>-1) { if (nopt) { int _L=atoi(ad_comm::argv[on+1]); if (_L < 1 ) { cerr << "Error: hynstep argument must be integer > 0 " << endl; ad_exit(1); } else { L=_L; } } } // Number of warmup samples if using adaptation of step size. Defaults to // half of iterations. int nwarmup= (int)nmcmc/2; if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-nwarmup",nopt))>-1) { if (nopt) { int iii=atoi(ad_comm::argv[on+1]); if (iii <=0 || iii > nmcmc) { cerr << "Error: nwarmup must be 0 < nwarmup < nmcmc" << endl; ad_exit(1); } else { nwarmup=iii; } } } // Target acceptance rate for step size adaptation. Must be // 0<adapt_delta<1. Defaults to 0.8. double adapt_delta=0.8; // target acceptance rate specified by the user if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-adapt_delta",nopt))>-1) { if (nopt) { istringstream ist(ad_comm::argv[on+1]); double _adapt_delta; ist >> _adapt_delta; if (_adapt_delta < 0 || _adapt_delta > 1 ) { cerr << "Error: adapt_delta must be between 0 and 1" " using default of 0.8" << endl; } else { adapt_delta=_adapt_delta; } } } // Use diagnoal covariance (identity mass matrix) int diag_option=0; if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-mcdiag"))>-1) { diag_option=1; cout << " Setting covariance matrix to diagonal with entries " << dscale << endl; } // Restart chain from previous run? int mcrestart_flag=option_match(ad_comm::argc,ad_comm::argv,"-mcr"); if(mcrestart_flag > -1){ cerr << endl << "Error: -mcr option not implemented for HMC" << endl; ad_exit(1); } if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-mcec"))>-1) { cerr << endl << "Error: -mcec option not yet implemented with HMC" << endl; ad_exit(1); // use_empirical_flag=1; // read_empirical_covariance_matrix(nvar,S,ad_comm::adprogram_name); } // Prepare the mass matrix for use. Depends on many factors below. dmatrix S(1,nvar,1,nvar); dvector old_scale(1,nvar); int old_nvar; // Need to grab old_scale values still, since it is scaled below read_covariance_matrix(S,nvar,old_Hybrid_bounded_flag,old_scale); if (diag_option) // set covariance to be diagonal { S.initialize(); for (int i=1;i<=nvar;i++) { S(i,i)=dscale; } } // How much to thin, for now fixed at 1. if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-mcsave"))>-1) { cerr << "Option -mcsave does not currently work with HMC -- every iteration is saved" << endl; ad_exit(1); } //// ------------------------------ End of input processing //// Setup more inputs and outputs pofs_psave= new uostream((char*)(ad_comm::adprogram_name + adstring(".psv"))); if (!pofs_psave|| !(*pofs_psave)) { cerr << "Error trying to open file" << ad_comm::adprogram_name + adstring(".psv") << endl; ad_exit(1); } if (mcrestart_flag == -1 ) { (*pofs_psave) << nvar; } // need to rescale the hessian // get the current scale dvector x0(1,nvar); dvector current_scale(1,nvar); initial_params::xinit(x0); int mctmp=initial_params::mc_phase; initial_params::mc_phase=0; initial_params::stddev_scale(current_scale,x0); initial_params::mc_phase=mctmp; // cout << "old scale=" << old_scale << endl; // cout << "current scale=" << current_scale << endl; // cout << "S before=" << S << endl; // I think this is only needed if mcmc2 is used?? // for (int i=1;i<=nvar;i++) // { // for (int j=1;j<=nvar;j++) // { // S(i,j)*=old_scale(i)*old_scale(j); // } // } if(diag_option){ for (int i=1;i<=nvar;i++) { for (int j=1;j<=nvar;j++) { S(i,j)*=current_scale(i)*current_scale(j); } } } // cout << "S after=" << S << endl; gradient_structure::set_NO_DERIVATIVES(); if (mcmc2_flag==0) { initial_params::set_inactive_random_effects(); } // Setup random number generator, based on seed passed int iseed=2197; if (iseed0) iseed=iseed0; random_number_generator rng(iseed); gradient_structure::set_YES_DERIVATIVES(); initial_params::xinit(x0); // Dual averaging components dvector epsvec(1,nmcmc+1), epsbar(1,nmcmc+1), Hbar(1,nmcmc+1); epsvec.initialize(); epsbar.initialize(); Hbar.initialize(); double time_warmup=0; double time_total=0; std::clock_t start = clock(); time_t now = time(0); tm* localtm = localtime(&now); cout << endl << "Starting static HMC for model '" << ad_comm::adprogram_name << "' at " << asctime(localtm); // write sampler parameters ofstream adaptation("adaptation.csv", ios::trunc); adaptation << "accept_stat__,stepsize__,int_time__,energy__,lp__" << endl; // Declare and initialize the variables needed for the algorithm dmatrix chd = choleski_decomp(S); // cholesky decomp of mass matrix dvector y(1,nvar); // unbounded parameters y.initialize(); // transformed params independent_variables z(1,nvar); z=chd*y; dvector gr(1,nvar); // gradients in unbounded space // Need to run this to fill gr with current gradients and initial NLL. double nllbegin=get_hybrid_monte_carlo_value(nvar,z,gr); if(std::isnan(nllbegin)){ cerr << "Starting MCMC trajectory at NaN -- something is wrong!" << endl; ad_exit(1); } // initial rotated gradient dvector gr2(1,nvar); gr2=gr*chd; dvector p(1,nvar); // momentum vector p.fill_randn(rng); // Copy initial value to parsave in case first trajectory rejected initial_params::copy_all_values(parsave,1.0); double iaccept=0.0; // The gradient and params at beginning of trajectory, in case rejected. dvector gr2begin(1,nvar); gr2begin=gr2; dvector ybegin(1,nvar); ybegin=y; double nll=nllbegin; // if(useDA){ // eps=find_reasonable_stepsize(nvar,y,p,chd); // epsvec(1)=eps; epsbar(1)=eps; Hbar(1)=0; // } double mu=log(10*eps); // Start of MCMC chain for (int is=1;is<=nmcmc;is++) { // Random momentum for next iteration, only affects Ham values p.fill_randn(rng); double H0=nll+0.5*norm2(p); // Generate trajectory int divergence=0; for (int i=1;i<=L;i++) { // leapfrog updates gr, p, y, and gr2 by reference nll=leapfrog(nvar, gr, chd, eps, p, y, gr2); // Break trajectory early if a divergence occurs to save computation if(std::isnan(nll)){ divergence=1; break; } } // end of trajectory // Test whether to accept the proposed state double Ham=nll+0.5*norm2(p); // Update Hamiltonian for proposed set double alpha=min(1.0, exp(H0-Ham)); // acceptance ratio double rr=randu(rng); // Runif(1) if (rr<alpha && !divergence){ // accept iaccept++; // Update for next iteration: params, Hamiltonian and gr2 ybegin=y; gr2begin=gr2; nllbegin=nll; initial_params::copy_all_values(parsave,1.0); } else { // Reject and don't update anything to reuse initials for next trajectory y=ybegin; gr2=gr2begin; nll=nllbegin; } // Save parameters to psv file, duplicated if rejected (*pofs_psave) << parsave; // Adaptation of step size (eps). if(useDA && is <= nwarmup){ eps=adapt_eps(is, eps, alpha, adapt_delta, mu, epsvec, epsbar, Hbar); } adaptation << alpha << "," << eps << "," << eps*L << "," << H0 << "," << -nll << endl; if(is ==nwarmup) time_warmup = ( std::clock()-start)/(double) CLOCKS_PER_SEC; print_mcmc_progress(is, nmcmc, nwarmup, chain); } // end of MCMC chain // This final ratio should closely match adapt_delta if(useDA){ cout << "Final acceptance ratio=" << iaccept/nmcmc << " and target is " << adapt_delta<<endl; cout << "Final step size=" << eps << "; after " << nwarmup << " warmup iterations"<< endl; } else { cout << "Final acceptance ratio=" << iaccept/nmcmc << endl; } time_total = ( std::clock() - start ) / (double) CLOCKS_PER_SEC; print_mcmc_timing(time_warmup, time_total); // I assume this closes the connection to the file?? if (pofs_psave) { delete pofs_psave; pofs_psave=NULL; } } // end of HMC function
int main(int argc, char *argv[]) { int step, ie, iside, i, j, k; double mflops, tmax, nelt_tot = 0.0; char Class; logical ifmortar = false, verified; double t2, trecs[t_last+1]; char *t_names[t_last+1]; //-------------------------------------------------------------------- // Initialize NUMA control //-------------------------------------------------------------------- numa_initialize_env(NUMA_MIGRATE_EXISTING); //--------------------------------------------------------------------- // Read input file (if it exists), else take // defaults from parameters //--------------------------------------------------------------------- FILE *fp; if ((fp = fopen("timer.flag", "r")) != NULL) { timeron = true; t_names[t_total] = "total"; t_names[t_init] = "init"; t_names[t_convect] = "convect"; t_names[t_transfb_c] = "transfb_c"; t_names[t_diffusion] = "diffusion"; t_names[t_transf] = "transf"; t_names[t_transfb] = "transfb"; t_names[t_adaptation] = "adaptation"; t_names[t_transf2] = "transf+b"; t_names[t_add2] = "add2"; fclose(fp); } else { timeron = false; } printf("\n\n NAS Parallel Benchmarks (NPB3.3-OMP-C) - UA Benchmark\n\n"); if ((fp = fopen("inputua.data", "r")) != NULL) { int result; printf(" Reading from input file inputua.data\n"); result = fscanf(fp, "%d", &fre); while (fgetc(fp) != '\n'); result = fscanf(fp, "%d", &niter); while (fgetc(fp) != '\n'); result = fscanf(fp, "%d", &nmxh); while (fgetc(fp) != '\n'); result = fscanf(fp, "%lf", &alpha); Class = 'U'; fclose(fp); } else { printf(" No input file inputua.data. Using compiled defaults\n"); fre = FRE_DEFAULT; niter = NITER_DEFAULT; nmxh = NMXH_DEFAULT; alpha = ALPHA_DEFAULT; Class = CLASS_DEFAULT; } dlmin = pow(0.5, REFINE_MAX); dtime = 0.04*dlmin; printf(" Levels of refinement: %8d\n", REFINE_MAX); printf(" Adaptation frequency: %8d\n", fre); printf(" Time steps: %8d dt: %15.6E\n", niter, dtime); printf(" CG iterations: %8d\n", nmxh); printf(" Heat source radius: %8.4f\n", alpha); printf(" Number of available threads: %8d\n", omp_get_max_threads()); printf("\n"); top_constants(); for (i = 1; i <= t_last; i++) { timer_clear(i); } if (timeron) timer_start(t_init); // set up initial mesh (single element) and solution (all zero) create_initial_grid(); r_init_omp((double *)ta1, ntot, 0.0); nr_init_omp((int *)sje, 4*6*nelt, -1); init_locks(); // compute tables of coefficients and weights coef(); geom1(); // compute the discrete laplacian operators setdef(); // prepare for the preconditioner setpcmo_pre(); // refine initial mesh and do some preliminary work time = 0.0; mortar(); prepwork(); adaptation(&ifmortar, 0); if (timeron) timer_stop(t_init); timer_clear(1); time = 0.0; for (step = 0; step <= niter; step++) { if (step == 1) { // reset the solution and start the timer, keep track of total no elms r_init((double *)ta1, ntot, 0.0); time = 0.0; nelt_tot = 0.0; for (i = 1; i <= t_last; i++) { if (i != t_init) timer_clear(i); } timer_start(1); } // advance the convection step convect(ifmortar); if (timeron) timer_start(t_transf2); // prepare the intital guess for cg transf(tmort, (double *)ta1); // compute residual for diffusion term based on intital guess // compute the left hand side of equation, lapacian t #pragma omp parallel default(shared) private(ie,k,j,i) { #pragma omp for for (ie = 0; ie < nelt; ie++) { laplacian(ta2[ie], ta1[ie], size_e[ie]); } // compute the residual #pragma omp for for (ie = 0; ie < nelt; ie++) { for (k = 0; k < LX1; k++) { for (j = 0; j < LX1; j++) { for (i = 0; i < LX1; i++) { trhs[ie][k][j][i] = trhs[ie][k][j][i] - ta2[ie][k][j][i]; } } } } } //end parallel // get the residual on mortar transfb(rmor, (double *)trhs); if (timeron) timer_stop(t_transf2); // apply boundary condition: zero out the residual on domain boundaries // apply boundary conidtion to trhs #pragma omp parallel for default(shared) private(ie,iside) for (ie = 0; ie < nelt; ie++) { for (iside = 0; iside < NSIDES; iside++) { if (cbc[ie][iside] == 0) { facev(trhs[ie], iside, 0.0); } } } // apply boundary condition to rmor col2(rmor, tmmor, nmor); // call the conjugate gradient iterative solver diffusion(ifmortar); // add convection and diffusion if (timeron) timer_start(t_add2); add2((double *)ta1, (double *)t, ntot); if (timeron) timer_stop(t_add2); // perform mesh adaptation time = time + dtime; if ((step != 0) && (step/fre*fre == step)) { if (step != niter) { adaptation(&ifmortar, step); } } else { ifmortar = false; } nelt_tot = nelt_tot + (double)(nelt); } timer_stop(1); tmax = timer_read(1); verify(&Class, &verified); // compute millions of collocation points advanced per second. // diffusion: nmxh advancements, convection: 1 advancement mflops = nelt_tot*(double)(LX1*LX1*LX1*(nmxh+1))/(tmax*1.e6); print_results("UA", Class, REFINE_MAX, 0, 0, niter, tmax, mflops, " coll. point advanced", verified, NPBVERSION, COMPILETIME, CS1, CS2, CS3, CS4, CS5, CS6, "(none)"); //--------------------------------------------------------------------- // More timers //--------------------------------------------------------------------- if (timeron) { for (i = 1; i <= t_last; i++) { trecs[i] = timer_read(i); } if (tmax == 0.0) tmax = 1.0; printf(" SECTION Time (secs)\n"); for (i = 1; i <= t_last; i++) { printf(" %-10s:%9.3f (%6.2f%%)\n", t_names[i], trecs[i], trecs[i]*100./tmax); if (i == t_transfb_c) { t2 = trecs[t_convect] - trecs[t_transfb_c]; printf(" --> %11s:%9.3f (%6.2f%%)\n", "sub-convect", t2, t2*100./tmax); } else if (i == t_transfb) { t2 = trecs[t_diffusion] - trecs[t_transf] - trecs[t_transfb]; printf(" --> %11s:%9.3f (%6.2f%%)\n", "sub-diffuse", t2, t2*100./tmax); } } } //-------------------------------------------------------------------- // Teardown NUMA control //-------------------------------------------------------------------- numa_shutdown(); return 0; }
bool yee_compare(CompareArgs &args) { if ((args.image_a_->get_width() != args.image_b_->get_width()) or (args.image_a_->get_height() != args.image_b_->get_height())) { args.error_string_ = "Image dimensions do not match\n"; return false; } const auto w = args.image_a_->get_width(); const auto h = args.image_a_->get_height(); const auto dim = w * h; auto identical = true; for (auto i = 0u; i < dim; i++) { if (args.image_a_->get(i) != args.image_b_->get(i)) { identical = false; break; } } if (identical) { args.error_string_ = "Images are binary identical\n"; return true; } // Assuming colorspaces are in Adobe RGB (1998) convert to XYZ. std::vector<float> a_lum(dim); std::vector<float> b_lum(dim); std::vector<float> a_a(dim); std::vector<float> b_a(dim); std::vector<float> a_b(dim); std::vector<float> b_b(dim); if (args.verbose_) { std::cout << "Converting RGB to XYZ\n"; } const auto gamma = args.gamma_; const auto luminance = args.luminance_; #pragma omp parallel for shared(args, a_lum, b_lum, a_a, a_b, b_a, b_b) for (auto y = 0; y < static_cast<ptrdiff_t>(h); y++) { for (auto x = 0u; x < w; x++) { const auto i = x + y * w; const auto a_color_r = powf(args.image_a_->get_red(i) / 255.0f, gamma); const auto a_color_g = powf(args.image_a_->get_green(i) / 255.0f, gamma); const auto a_color_b = powf(args.image_a_->get_blue(i) / 255.0f, gamma); float a_x; float a_y; float a_z; adobe_rgb_to_xyz(a_color_r, a_color_g, a_color_b, a_x, a_y, a_z); float l; xyz_to_lab(a_x, a_y, a_z, l, a_a[i], a_b[i]); const auto b_color_r = powf(args.image_b_->get_red(i) / 255.0f, gamma); const auto b_color_g = powf(args.image_b_->get_green(i) / 255.0f, gamma); const auto b_color_b = powf(args.image_b_->get_blue(i) / 255.0f, gamma); float b_x; float b_y; float b_z; adobe_rgb_to_xyz(b_color_r, b_color_g, b_color_b, b_x, b_y, b_z); xyz_to_lab(b_x, b_y, b_z, l, b_a[i], b_b[i]); a_lum[i] = a_y * luminance; b_lum[i] = b_y * luminance; } } if (args.verbose_) { std::cout << "Constructing Laplacian Pyramids\n"; } const LPyramid la(a_lum, w, h); const LPyramid lb(b_lum, w, h); const auto num_one_degree_pixels = to_degrees(2 * std::tan(args.field_of_view_ * to_radians(.5f))); const auto pixels_per_degree = w / num_one_degree_pixels; if (args.verbose_) { std::cout << "Performing test\n"; } const auto adaptation_level = adaptation(num_one_degree_pixels); float cpd[MAX_PYR_LEVELS]; cpd[0] = 0.5f * pixels_per_degree; for (auto i = 1u; i < MAX_PYR_LEVELS; i++) { cpd[i] = 0.5f * cpd[i - 1]; } const auto csf_max = csf(3.248f, 100.0f); static_assert(MAX_PYR_LEVELS > 2, "MAX_PYR_LEVELS must be greater than 2"); float f_freq[MAX_PYR_LEVELS - 2]; for (auto i = 0u; i < MAX_PYR_LEVELS - 2; i++) { f_freq[i] = csf_max / csf(cpd[i], 100.0f); } auto pixels_failed = 0u; auto error_sum = 0.; #pragma omp parallel for reduction(+ : pixels_failed, error_sum) \ shared(args, a_a, a_b, b_a, b_b, cpd, f_freq) for (auto y = 0; y < static_cast<ptrdiff_t>(h); y++) { for (auto x = 0u; x < w; x++) { const auto index = y * w + x; const auto adapt = std::max((la.get_value(x, y, adaptation_level) + lb.get_value(x, y, adaptation_level)) * 0.5f, 1e-5f); auto sum_contrast = 0.f; auto factor = 0.f; for (auto i = 0u; i < MAX_PYR_LEVELS - 2; i++) { const auto n1 = fabsf(la.get_value(x, y, i) - la.get_value(x, y, i + 1)); const auto n2 = fabsf(lb.get_value(x, y, i) - lb.get_value(x, y, i + 1)); const auto numerator = std::max(n1, n2); const auto d1 = fabsf(la.get_value(x, y, i + 2)); const auto d2 = fabsf(lb.get_value(x, y, i + 2)); const auto denominator = std::max(std::max(d1, d2), 1e-5f); const auto contrast = numerator / denominator; const auto f_mask = mask(contrast * csf(cpd[i], adapt)); factor += contrast * f_freq[i] * f_mask; sum_contrast += contrast; } sum_contrast = std::max(sum_contrast, 1e-5f); factor /= sum_contrast; factor = std::min(std::max(factor, 1.f), 10.f); const auto delta = fabsf(la.get_value(x, y, 0) - lb.get_value(x, y, 0)); error_sum += delta; auto pass = true; // pure luminance test if (delta > factor * tvi(adapt)) { pass = false; } if (not args.luminance_only_) { // CIE delta E test with modifications auto color_scale = args.color_factor_; // ramp down the color test in scotopic regions if (adapt < 10.0f) { // Don't do color test at all. color_scale = 0.0; } const auto da = a_a[index] - b_a[index]; const auto db = a_b[index] - b_b[index]; const auto delta_e = (da * da + db * db) * color_scale; error_sum += delta_e; if (delta_e > factor) { pass = false; } } if (not pass) { pixels_failed++; if (args.image_difference_) { args.image_difference_->set(255, 0, 0, 255, index); } } else { if (args.image_difference_) { args.image_difference_->set(0, 0, 0, 255, index); } } } } const auto error_sum_buff = std::to_string(error_sum) + " error sum\n"; const auto different = std::to_string(pixels_failed) + " pixels are different\n"; // Always output image difference if requested. if (args.image_difference_) { args.image_difference_->write_to_file(args.image_difference_->get_name()); args.error_string_ += "Wrote difference image to "; args.error_string_ += args.image_difference_->get_name(); args.error_string_ += "\n"; } if (pixels_failed < args.threshold_pixels_) { args.error_string_ = "Images are perceptually indistinguishable\n"; args.error_string_ += different; return true; } args.error_string_ = "Images are visibly different\n"; args.error_string_ += different; if (args.sum_errors_) { args.error_string_ += error_sum_buff; } return false; }
void evolution(axl_network *mysys, int steps, int seed) { int i, j, step; int n = mysys->nagents; int *neighbors; axl_mass_media *mm; double b_total; double random; neighbors = (int *)malloc(sizeof(int) * n); srand(seed); for(step = 0; step < steps; step++) { for(i = 0; i < n; i++) { if(mysys->agent[i].degree != 0) { j = rand() % mysys->agent[i].degree; neighbors[i] = mysys->agent[i].neighbors[j]; } else neighbors[i] = -(mysys->nmm) - 1; } if(mysys->nmm > 1) { b_total = 0.00; for(i = 0; i < mysys->nmm; i++) b_total += mysys->mass_media[i].b; if(b_total > 0.00) { select_mass_media_to_interact(*mysys, neighbors, rand()); adaptation_of_medias(mysys); } } else { for(i = 0; i < n; i++) { random = ((double)rand()) / RAND_MAX; if(random < mysys->mass_media[0].b) neighbors[i] = -1; } for(i = 0; i < mysys->mass_media[0].f; i++) { mm = &(mysys->mass_media[0]); adaptation(mm, *mysys, i); } } synchronous_updating(mysys, neighbors, rand()); if(mysys->noise > 0.00) noise(mysys, rand()); } free(neighbors); return; }