int mode_alg::run()
{
if ( !m_ppara )
return -1;
timer elapsed_t;
// retrieve algorithm parameters
int pop_size=m_ppara->get_pop_size();
int max_pop_size=2*pop_size;
int num_dims=m_ppara->get_dim();
int num_obj=m_ppara->get_obj_num();
int min_gen=m_ppara->get_max_gen();
double pr_val,f_val;
pr_val=m_ppara->get_pr();
f_val=m_ppara->get_f();
// my_sDE SPECIFIC
// jDE SPECIFIC
double f_low_bnd,f_up_bnd;
f_low_bnd=m_ppara->get_f_low_bnd();
f_up_bnd=m_ppara->get_f_up_bnd();
double tau_1,tau_2;
tau_1=m_ppara->get_tau_1();
tau_2=m_ppara->get_tau_2();
int out_interval=m_ppara->get_out_interval();
int trunc_type=m_ppara->get_trunc_type();
bool plot=m_ppara->get_plot_flag();
string plot_script=m_ppara->get_plot_script();
int m_cur_run;
int max_run=m_ppara->get_max_run();// run/trial number
// shared_ptr<progress_display> pprog_dis;// algorithm progress indicator from boost
// alloc_prog_indicator(pprog_dis);
// allocate original pop and trial pop
population pop(pop_size);
allocate_pop(pop,num_dims,stra_num,num_obj);
population trial_pop;
// generate algorithm statistics output file name
ofstream stat_file(m_com_out_path.stat_path.c_str());
// allocate stop condition object dynamically
alloc_stop_cond();
idx_array pop_idx(pop_size-1);
// random U(0,1) generator
uniform_01<> dist_01;
variate_generator<mt19937&, uniform_01<> > rnd_01(gen, dist_01);
// generator for random DIMENSION index
uniform_int<> dist_dim(0,num_dims-1);
variate_generator<mt19937&, uniform_int<> > rnd_dim_idx(gen, dist_dim);
individual trial_ind;
allocate_ind(trial_ind,num_dims,stra_num,num_obj);
// iteration start
for ( m_cur_run=0;m_cur_run<max_run;m_cur_run++ )
{
bool has_stag;
int stag_gen;
reset_run_stat();
m_de_stat.reset();
/*m_succ_f.clear();
m_succ_cr.clear();*/
int z;
// f,pr initialial value
for ( z=0;z<pop_size;z++ )
{
pop[z].stra[f].assign(1,f_val);
pop[z].stra[pr].assign(1,pr_val);
}
set_orig_pop(pop);
update_diversity(pop);
calc_de_para_stat(pop);
record_de_para_stat(m_cur_run);
print_run_times(stat_file,m_cur_run+1);
print_run_title(stat_file);
// output original population statistics
m_cur_gen=1;
stag_gen=0;
shared_ptr<ofstream> ppop_file;
shared_ptr<mutex> ppop_mut;
while ( false==(*m_pstop_cond) ) // for every iteration
{
m_de_stat.reset();
has_stag=true;
int rnd_dim;
double dim_mut_chance;
int i,j,k;
/*double f_i;
double pr_i;*/
if ( is_output_gen(m_cur_gen,out_interval) )
{
ppop_file=shared_ptr<ofstream>(new ofstream("Output//all_pop.out"));
ppop_mut=shared_ptr<mutex>((new mutex));
}
trial_pop.clear();
trial_pop.reserve(max_pop_size);// operator =
//// recalculate succ_f_mean and succ_f_sigma periodically
// if ( is_learn_gen(m_cur_gen,learn_p) )
//{
// int f_size=m_succ_f.size();
// int pr_size=m_succ_cr.size();
// if ( f_size && pr_size )
// calc_bi_norm_var(m_succ_f,m_succ_cr,m_bi_norm_var);
// else
// {
// }
// m_succ_f.clear();
// m_succ_cr.clear();
//}// if ( is_learn_gen(m_cur_gen,learn_p) )
for ( i=0;i<pop_size;i++ )
{
// generating three mutually different individual index using random shuffle
// initialize index vector
for ( k=0;k<pop_size-1;k++ )
{
if ( k<i )
pop_idx[k]=k;
else
pop_idx[k]=(k+1)%pop_size;// EXCLUDE i
}
random_shuffle(pop_idx.begin(),pop_idx.end());
int i1,i2,i3;
// int i4,i5;// i!=i1!=i2!=i3!=i4!=i5
i1=pop_idx[0];
i2=pop_idx[1];
i3=pop_idx[2];
/*i4=arc_idx[3];
i5=arc_idx[4];*/
//double pr_chance=rnd_01();
//if ( pr_chance<=tau_2 )
//{
// pr_i=rnd_01();
// trial_ind.stra[pr][0]=pr_i;
//}
//else
// pr_i=trial_ind.stra[pr][0];
//// scaling factor F self-adaptive update equation
//double f_chance=rnd_01();
//if ( f_chance<=tau_1 )
//{
// f_i=f_low_bnd+rnd_01()*f_up_bnd;
// trial_ind.stra[f][0]=f_i;
//}
//else
// f_i=trial_ind.stra[f][0];// keep unchanged at thsi iteration
rnd_dim=rnd_dim_idx();// choose a random dimension as the mutation target
for ( j=0;j<num_dims;j++ )
{
dim_mut_chance=rnd_01();
if ( rnd_dim==j || dim_mut_chance<=pr_val )
{
// insufficent elitist size,generate perturbation from current population rather than external elitist archive
trial_ind.x[j]=pop[i1].x[j]+f_val*(pop[i2].x[j]-pop[i3].x[j]);
//+f_i*(trial_pop[i4].x[j]-trial_pop[i5].x[j]);
// boundaries check
bound_check(trial_ind.x[j],pop[i].x[j],j);
}
else
trial_ind.x[j]=pop[i].x[j];
}// for every dimension
eval_ind(trial_ind,*m_pfunc,m_alg_stat);
int comp_res=check_dominance(trial_ind,pop[i]);
if ( worse!=comp_res )
{
if ( better==comp_res )
trial_pop.push_back(trial_ind);
else
{
trial_pop.push_back(trial_ind);
trial_pop.push_back(pop[i]);
}
}
else
trial_pop.push_back(pop[i]);
}// for every point
// evaluate pop
fill_nondominated_sort(trial_pop,pop,pop_size,trunc_type);
if ( is_output_gen(m_cur_gen,out_interval) )
{
update_search_radius();
update_diversity(pop);
calc_de_para_stat(pop);
record_gen_vals(m_alg_stat,m_cur_run);
record_de_para_stat(m_cur_run);
/*if ( run_once )
++(*pprog_dis);*/
// plot current population and external archive
output_collection(*ppop_file,pop.begin(),pop.end());
*ppop_file<<"\n"<<"\n";// output seperator
output_if(*ppop_file,pop.begin(),pop.end(),front_pred());
ppop_file->flush();
if ( plot )
thread(fwd_plot_fun,ppop_mut,m_cur_gen,
0,
0,is_final_out_gen(m_cur_gen,out_interval,min_gen),
plot_script);
// system("gnuplot plot_all_point_2d.p");
}
m_cur_gen++;
}// while single run termination criterion is not met
perf_indice p_ind,nsga2_p_ind;
d_mat best_pop;
copy_obj_if(pop.begin(),pop.end(),best_pop,front_pred());
d_mat nsga2_best_pop;
load_pop("nsga2_zdt3_best_pop.out",2,nsga2_best_pop);
zdt3_assess(nsga2_best_pop,1000,point(11,11),nsga2_p_ind);
cout<<"\n"
<<"nsga2 results:"
<<"\n"
<<"convergence metric gamma="<<nsga2_p_ind.gamma
<<"\n"
<<"frontier diversity metric delta="<<nsga2_p_ind.delta
<<"\n"
<<"dominance metric hyper-volume="<<nsga2_p_ind.hv
<<"\n";
zdt3_assess(best_pop,1000,point(11,11),p_ind);
cout<<"\n"
<<"outbound count="<<m_alg_stat.all_ob_num
<<"\n"
<<"population diversity="<<m_alg_stat.pos_diver
<<"\n"
<<"mean search radius="<<m_alg_stat.avg_radius
<<"\n"
<<"stagnation indicator stag_gen="<<stag_gen
<<"\n"
<<"convergence metric gamma="<<p_ind.gamma
<<"\n"
<<"frontier diversity metric delta="<<p_ind.delta
<<"\n"
<<"dominance metric hyper-volume="<<p_ind.hv
<<"\n";
// single run end
/*if ( !run_once )
++(*pprog_dis);*/
}// for every run
print_avg_gen(stat_file,m_alg_stat.run_avg_gen);
// stat and output average time per run by second
m_alg_stat.run_avg_time=elapsed_t.elapsed();
m_alg_stat.run_avg_time /= (max_run*1.0);
print_avg_time(stat_file,m_alg_stat.run_avg_time);
write_stat_vals();
cout<<endl;// flush cout output
return 0;
}// end function Run
int
main(int argc,char **argv)
{
int rv = 0,i = 0,j=0;
int datalen = sizeof(time_t) + 2*sizeof(uint32_t);
int c = 0;
char *ca[] = {"key.pub","key.prv","key.par"};
uint8_t *pmsg = NULL,*smsg = NULL;
uint8_t **msga = NULL,*pmsga = NULL;
//timing vars
clock_t cstart =0,cend=0;
struct timeval start,end;
int subtime = 0;
double totsubtime=0.0;
setup_params_t *setup = NULL;
ibe_keypair_t *ibk[MAXASPATHLEN]; //one key per as
ibe_signature_t *signature[MAXPFIXNUM]; //one aggregated signature per prefix
time_t tstamps[(MAXASPATHLEN+1)*MAXPFIXNUM];
time_t rsatstamps[(MAXASPATHLEN+1)*MAXPFIXNUM];
size_t vlen[MAXASPATHLEN +1];
//RSA
struct rsa_public_key **rsa_pub = NULL;
struct rsa_private_key **rsa_priv = NULL;
mpz_t *vsign = NULL;
long int nonces[MAXPFIXNUM*MAXPFIXLEN];
int rsadatalen =sizeof(time_t) + 2*sizeof(uint32_t)+ sizeof(long int) + sizeof(uint8_t) + sizeof(in_addr_t);
while ((c=getopt (argc,argv,"a:p:")) != -1) {
switch(c) {
case 'a':
aspathlen = strtol(optarg, NULL, 10);
if(aspathlen > MAXASPATHLEN) {
die("The specified aspathlen execeed MAXASPATHLEN(%d)\n",MAXASPATHLEN);
}
break;
case 'p':
pfixnum = strtol(optarg, NULL, 10);
if(pfixnum > MAXPFIXNUM) {
die("The specified pfixnum execeed MAXPFIXNUM(%d)\n",MAXPFIXNUM);
}
break;
default:
die("Invalid input option\n Aborting.\n");
}
}
rv = setup_load (ca[0],ca[1],ca[2],&setup);
if(rv < 0)
die("Cannot initialize setup\n Aborting. \n");
//initialize IBE structures
bzero(ibk,MAXASPATHLEN*sizeof(ibe_keypair_t *));
bzero(signature,MAXPFIXNUM*sizeof(ibe_signature_t *));
bzero(&tstamps,MAXASPATHLEN*MAXPFIXNUM * sizeof(time_t));
bzero(&rsatstamps,MAXASPATHLEN*MAXPFIXNUM * sizeof(time_t));
rv = create_aslist(&ibk[0],setup);
if(rv < 0)
die("create_aslist");
msga = (uint8_t **) malloc((MSG_NUM)* sizeof(uint8_t*));
if(!msga) {
die("malloc msga :: %s",strerror(errno));
}
for(i=0; i < MSG_NUM; i++) {
pmsga = (uint8_t * ) malloc(MAX_VRFY_LEN);
if(!pmsga) {
die("malloc msga[%d] :: %s",i,strerror(errno));
}
bzero(pmsga,MAX_VRFY_LEN);
msga[i] = pmsga;
}
vlen[0] = 9;
for(i = 1; i < (MSG_NUM);i++){
vlen[i] = datalen;
}
//initialize RSA structures
bzero(&nonces,MAXASPATHLEN*MAXPFIXNUM * sizeof(long int));
rsa_pub = (struct rsa_public_key **) malloc((MSG_NUM)* sizeof(struct rsa_public_key *));
rsa_priv = (struct rsa_private_key **)malloc((MSG_NUM) * sizeof(struct rsa_private_key *)) ;
if(!rsa_pub || ! rsa_priv)
die("init_rsa_array :: %s\n",strerror(errno));
init_rsa_array(rsa_pub,rsa_priv);
vsign = (mpz_t *) malloc(sizeof(mpz_t) * MSG_NUM * pfixnum);
if(!vsign)
die("init_rsa_sign() :: %s\n",strerror(errno));
//----------------- Timing goes here -----------------
//create the verification message
//aggregate the signature to assigned prefixes (by AS1)
//for AS2 to ASn-1
pmsg = smsg = &upvrfy[0];
//printf("#TEST SUMMARY\n");
//printf("#AS path length:%6d\n",aspathlen);
//printf("#Number of prefixes:%2d\n",pfixnum);
printf("%d %d ",aspathlen,pfixnum);
//printf("=======================================\n");
//printf("====== IBE SIGNATURE TIMING TEST ======\n");
//printf("=======================================\n");
//for each as
gettimeofday(&start,NULL);
//cstart = clock();
for(j = 0 ; j < (aspathlen-1); j++ ){
//for each prefix
for(i = 0; i < pfixlist->size; i++) {
//generate the current timestamp (for prefix + as couple)
tstamps[j*pfixnum + i] = time(NULL);
//update the verification message
memcpy(pmsg,&tstamps[j*pfixnum + i],sizeof(time_t));
pmsg+=sizeof(time_t);
memcpy(pmsg,&ibk[j]->id->asnum,sizeof(uint32_t));
//pmsg+=sizeof(ibk[j]->id->asnum);
pmsg+=sizeof(uint32_t);
memcpy(pmsg,&ibk[j+1]->id->asnum,sizeof(uint32_t));
//pmsg+=sizeof(ibk[j+1]->id->asnum);
pmsg+=sizeof(uint32_t);
//aggregate signature to prefixes
ibe_sign(pfixlist->pf_sign[i],ibk[j],(const uint8_t * )smsg,pmsg-smsg);
//printf(">> %d %d %d\n",tstamps[j*pfixnum + i],ibk[j]->id->asnum,ibk[j+1]->id->asnum);
//print_msg(smsg);
smsg = pmsg;
}
}
//cend = clock();
gettimeofday(&end,NULL);
print_avg_time(start,end,(aspathlen-1));
//print_time_clock(cstart,cend);
//printf("=======================================\n");
//printf("====== RSA SIGNATURE TIMING TEST ======\n");
//printf("=======================================\n");
//for each as
pmsg = smsg = &rsaupvrfy[0];
gettimeofday(&start,NULL);
//cstart = clock();
for(j = 0 ; j < (aspathlen-1); j++ ){
//for each prefix
for(i = 0; i < pfixlist->size; i++) {
//add some randomness
nonces[j*pfixnum +i] = random();
memcpy(pmsg,&nonces[j*pfixnum + i],sizeof(long int));
pmsg+=sizeof(long int);
//generate the current timestamp (for prefix + as couple)
rsatstamps[j*pfixnum + i] = time(NULL);
//update the verification message
memcpy(pmsg,&rsatstamps[j*pfixnum + i],sizeof(time_t));
pmsg+=sizeof(time_t);
memcpy(pmsg,&ibk[j]->id->asnum,sizeof(uint32_t));
pmsg+=sizeof(uint32_t);
memcpy(pmsg,&ibk[j+1]->id->asnum,sizeof(uint32_t));
pmsg+=sizeof(uint32_t);
memcpy(pmsg,&pfixlist->ina[i].s_addr,sizeof(in_addr_t));
pmsg+=sizeof(struct in_addr);
memcpy(pmsg,&pfixlist->netmask[i],sizeof(uint8_t));
pmsg+=sizeof(uint8_t);
//sign prefix
rsa_sign_msg(rsa_priv[j],vsign[j*pfixnum +i],(uint8_t * )smsg,pmsg-smsg);
smsg = pmsg;
}
}
//cend = clock();
gettimeofday(&end,NULL);
print_avg_time(start,end,(aspathlen-1));
//print_time(start,end);
//print_time_clock(cstart,cend);
//printf("==========================================\n");
//printf("====== IBE VERIFICATION TIMING TEST ======\n");
//printf("==========================================\n");
pmsg = smsg = &upvrfy[0];
gettimeofday(&start,NULL);
//cstart = clock();
//----------------- Timing goes here -----------------
for(i=0; i < pfixlist->size; i++) {
//build array of messages
build_msg_array(msga,smsg,tstamps,i,setup);
//verfy aggregated message
rv = ibe_vrfy(pfixlist->pf_sign[i],setup,(const uint8_t **)msga,vlen,&subtime);
if(rv != SIGN_VALID) printf("Invalid signature :( \n");;
//aggregate signature (by ASn)
smsg+=datalen;
totsubtime +=subtime;
}
//cend = clock();
gettimeofday(&end,NULL);
print_time_sub(start,end,totsubtime);
//print_time_clock(cstart,cend);
//printf("==========================================\n");
//printf("====== RSA VERIFICATION TIMING TEST ======\n");
//printf("==========================================\n");
//start = clock();
gettimeofday(&start,NULL);
//cstart = clock();
int z = 0;
while(z < 2) {
pmsg = smsg = &rsaupvrfy[0];
//----------------- Timing goes here -----------------
for(j = 0 ; j < (aspathlen-1); j++ ){
for(i=0; i < pfixlist->size; i++) {
//vrfy rsa signature
rv = rsa_vrfy_msg(rsa_pub[j],vsign[j*pfixnum +i],smsg,rsadatalen);
if(rv != SIGN_VALID) printf("Invalid signature :( \n");;
//go to next message
smsg+=rsadatalen;
}
}
z++;
}
//cend = clock();
gettimeofday(&end,NULL);
print_time(start,end);
//print_time_clock(cstart,cend);
printf("\n");
//cleanup
for(i = 0; i < MAXASPATHLEN ; i++) {
ibe_keypair_clear(ibk[i]);
}
for(i=0; i < MAXASPATHLEN; i++) {
if(msga[i])
free(msga[i]);
}
free(msga);
return 0;
}
int jde_alg::run()
{
if ( !m_ppara )
return -1;
timer elapsed_t;
// retrieve algorithm parameters
size_t pop_size=m_ppara->get_pop_size();
size_t num_dims=m_ppara->get_dim();
double vtr=m_ppara->get_vtr();
double f_low_bnd,f_up_bnd;
f_low_bnd=m_ppara->get_f_low_bnd();
f_up_bnd=m_ppara->get_f_up_bnd();
double tau_1,tau_2;
tau_1=m_ppara->get_tau_1();
tau_2=m_ppara->get_tau_2();
int m_cur_run;
int max_run=m_ppara->get_max_run();// run/trial number
// shared_ptr<progress_display> pprog_dis;// algorithm progress indicator from boost
// alloc_prog_indicator(pprog_dis);
// allocate original pop and trial pop
population pop(pop_size);
allocate_pop(pop,num_dims,stra_num);
population trial_pop(pop_size);
allocate_pop(trial_pop,num_dims,stra_num);
// generate algorithm statistics output file name
ofstream stat_file(m_com_out_path.stat_path.c_str());
// allocate stop condition object dynamically
alloc_stop_cond();
size_t shuffle_size=pop_size-1;
vector<int> vec_idx1(shuffle_size);
// random U(0,1) generator
uniform_01<> dist_01;
variate_generator<mt19937&, uniform_01<> > rnd_01(gen, dist_01);
// generator for random DIMENSION index
uniform_int<> dist_dim(0,num_dims-1);
variate_generator<mt19937&, uniform_int<> > rnd_dim_idx(gen, dist_dim);
// iteration start
for ( m_cur_run=0;m_cur_run<max_run;m_cur_run++ )
{
reset_run_stat();
m_de_stat.reset();
// jde SPECIFIC,initialize F value vector EVERY single run
size_t i;
for ( i=0;i<pop_size;i++ )
{
pop[i].stra[pr].assign(1,0.0);
pop[i].stra[f].assign(1,0.0);
}
set_orig_pop(pop);
update_diversity(pop);
calc_de_para_stat(pop);
record_de_para_stat(m_cur_run);
record_gen_vals(m_alg_stat,m_cur_run);
print_run_times(stat_file,m_cur_run+1);
print_run_title(stat_file);
// output original population statistics
print_gen_stat(stat_file,1,m_alg_stat);
m_cur_gen=1;
while ( false==(*m_pstop_cond) ) // for every iteration
{
m_de_stat.reset();
int rnd_dim;
double f_i;
double pr_i;
double dim_mut_chance;
size_t i,j,k;
trial_pop=pop;// operator =
for ( i=0;i<pop_size;i++ )
{
// generating three mutually different individual index other than i using random shuffle
// initialize index vector
for ( k=0;k<shuffle_size;k++ )
{
if ( k<i )
vec_idx1[k]=k;
else
// EXCLUDE i
vec_idx1[k]=(k+1)%pop_size;
}
// random shuffle
for ( k=0;k<shuffle_size;k++ )
{
// generator for random SHUFFLE VECTOR index
uniform_int<> dist_uni_shuf(k,shuffle_size-1);
variate_generator<mt19937&, uniform_int<> > rnd_shuf_idx(gen, dist_uni_shuf);
int idx_tmp=rnd_shuf_idx();
swap(vec_idx1[k],vec_idx1[idx_tmp]);
}
int i1,i2,i3;// i!=i1!=i2!=i3
i1=vec_idx1[0];
i2=vec_idx1[1];
i3=vec_idx1[2];
rnd_dim=rnd_dim_idx();
double pr_chance=rnd_01();
if ( pr_chance<=tau_2 )
{
pr_i=rnd_01();
trial_pop[i].stra[pr][0]=pr_i;
}
else
pr_i=trial_pop[i].stra[pr][0];
// scaling factor F self-adaptive update equation
double f_chance=rnd_01();
if ( f_chance<=tau_1 )
{
f_i=f_low_bnd+rnd_01()*f_up_bnd;
trial_pop[i].stra[f][0]=f_i;
}
else
f_i=trial_pop[i].stra[f][0];// keep unchanged at thsi iteration
for ( j=0;j<num_dims;j++ )
{
dim_mut_chance=rnd_01();
if ( rnd_dim==j || dim_mut_chance<=pr_i )
{
trial_pop[i].x[j]=trial_pop[i1].x[j]+f_i*(trial_pop[i2].x[j]-trial_pop[i3].x[j]);
// boundaries check
bound_check(trial_pop[i].x[j],j);
}
}// for every dimension
}// for every particle
// evaluate pop
eval_pop(trial_pop,*m_pfunc,m_alg_stat);
update_pop(pop,trial_pop);
stat_pop(pop,m_alg_stat);
update_search_radius();
update_diversity(pop);
calc_de_para_stat(pop);
record_de_para_stat(m_cur_run);
record_gen_vals(m_alg_stat,m_cur_run);
print_gen_stat(stat_file,m_cur_gen+1,m_alg_stat);
update_conv_stat(vtr);
/*if ( run_once )
++(*pprog_dis);*/
m_cur_gen++;
}// while single run stop_condition is false
// single run end
stat_run(pop,m_cur_run);// stat single run for algorithm analysis
if ( is_final_run(m_cur_run,max_run) )
print_run_stat(stat_file,m_alg_stat,max_run);
/*if ( !run_once )
++(*pprog_dis);*/
}// for every run
print_avg_gen(stat_file,m_alg_stat.run_avg_gen);
// stat and output average time per run by second
m_alg_stat.run_avg_time=elapsed_t.elapsed();
m_alg_stat.run_avg_time /= (max_run*1.0);
print_avg_time(stat_file,m_alg_stat.run_avg_time);
print_best_x(stat_file,m_alg_stat.bst_ind);
write_stat_vals();
cout<<endl;// flush cout output
return 0;
}// end function Run
int dgea_alg::run()
{
timer elapsed_t;
// retrieve algorithm parameters
size_t pop_size=m_ppara->get_pop_size();
size_t num_dims=m_ppara->get_dim();
double vtr=m_ppara->get_vtr();
double d_h=m_ppara->get_dh();
double d_l=m_ppara->get_dh();
int m_cur_run;
int max_run=m_ppara->get_max_run();
// run/trial number
//shared_ptr<progress_display> pprog_dis;
//// algorithm progress indicator from boost
//alloc_prog_indicator(pprog_dis);
// allocate pop
population pop(pop_size);
allocate_pop(pop,num_dims);
population child_pop(pop_size);
allocate_pop(child_pop,num_dims);
// generate algorithm statistics output file name
ofstream stat_file(m_com_out_path.stat_path.c_str());
// alloc stop condition
alloc_stop_cond();
for(m_cur_run=0; m_cur_run<max_run; ++m_cur_run)
{
reset_run_stat();
set_orig_pop(pop);
update_diversity(pop);
print_run_times(stat_file,m_cur_run+1);
print_run_title(stat_file);
// output original population statistics
print_gen_stat(stat_file,1,m_alg_stat);
record_gen_vals(m_alg_stat,m_cur_run);
m_cur_gen=1;
int mode=exploit;
while ( false==(*m_pstop_cond) ) // for every iteration
{
update_mode(mode,d_l,d_h);
gen_child(mode,pop,child_pop);
eval_pop(child_pop, *m_pfunc, m_alg_stat);
select(pop,child_pop);
stat_pop(pop, m_alg_stat);
update_search_radius();
update_diversity(pop);
print_gen_stat(stat_file,m_cur_gen+1,m_alg_stat);
record_gen_vals(m_alg_stat,m_cur_run);
update_conv_stat(vtr);
m_cur_gen++;
}// while single run termination criterion is not met
// single run end
stat_run(pop,m_cur_run);// stat single run for algorithm analysis
if ( is_final_run(m_cur_run,max_run) )
print_run_stat(stat_file,m_alg_stat,max_run);
/*if ( !run_once )
++(*pprog_dis); */
}
print_avg_gen(stat_file,m_alg_stat.run_avg_gen);
// stat and output average time per run by second
m_alg_stat.run_avg_time=elapsed_t.elapsed();
m_alg_stat.run_avg_time /= (max_run*1.0);
print_avg_time(stat_file,m_alg_stat.run_avg_time);
print_best_x(stat_file,m_alg_stat.bst_ind);
write_stat_vals();
cout<<endl;// flush cout output
return 0;
}// end function Run
