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
/* -------------------------------------------------------------------------------
* NSGA2
* ---------------------------------------------------------------------------- */
int nsga2(int nvar, int ncon, int nobj, double f[], double x[], double g[],
int nfeval, double xl[], double xu[], int popsize, int ngen,
double pcross_real, double pmut_real, double eta_c, double eta_m,
double pcross_bin, double pmut_bin, int printout, double seed)
{
/* declaration of local variables and structures */
int i, j;
int nreal, nbin, *nbits, bitlength;
double *min_realvar, *max_realvar;
double *min_binvar, *max_binvar;
int *nbinmut, *nrealmut, *nbincross, *nrealcross;
Global global;
population *parent_pop;
population *child_pop;
population *mixed_pop;
// "random" numbers seed
if (seed==0)
{
// use of clock to generate "random" seed
time_t seconds;
seconds=time(NULL);
seed=seconds;
}
// Files
FILE *fpt1;
FILE *fpt2;
FILE *fpt3;
FILE *fpt4;
FILE *fpt5;
FILE *fpt6;
if (printout >= 1)
{
fpt1 = fopen("nsga2_initial_pop.out","w");
fpt2 = fopen("nsga2_final_pop.out","w");
fpt3 = fopen("nsga2_best_pop.out","w");
if (printout == 2)
{
fpt4 = fopen("nsga2_all_pop.out","w");
}
fpt5 = fopen("nsga2_params.out","w");
fpt6 = fopen("nsga2_run.out","w");
fprintf(fpt1,"# This file contains the data of initial population\n");
fprintf(fpt2,"# This file contains the data of final population\n");
fprintf(fpt3,"# This file contains the data of final feasible population (if found)\n");
if (printout == 2)
{
fprintf(fpt4,"# This file contains the data of all generations\n");
}
fprintf(fpt5,"# This file contains information about inputs as read by the program\n");
fprintf(fpt6,"# This file contains runtime information\n");
}
// Input Handling
nreal = nvar; // number of real variables
nbin = 0; // number of binary variables
min_realvar = (double *)malloc(nreal*sizeof(double));
max_realvar = (double *)malloc(nreal*sizeof(double));
j = 0;
for (i=0; i<nvar; i++)
{
min_realvar[j] = xl[i];
max_realvar[j] = xu[i];
j += 1;
}
if (nbin != 0)
{
nbits = (int *)malloc(nbin*sizeof(int));
min_binvar = (double *)malloc(nbin*sizeof(double));
max_binvar = (double *)malloc(nbin*sizeof(double));
}
bitlength = 0;
if (nbin!=0)
{
for (i=0; i<nbin; i++)
{
bitlength += nbits[i];
}
}
// Performing Initialization
if (printout >= 1)
{
fprintf(fpt5,"\n Population size = %d",popsize);
fprintf(fpt5,"\n Number of generations = %d",ngen);
fprintf(fpt5,"\n Number of objective functions = %d",nobj);
fprintf(fpt5,"\n Number of constraints = %d",ncon);
fprintf(fpt5,"\n Number of variables = %d",nvar);
fprintf(fpt5,"\n Number of real variables = %d",nreal);
if (nreal!=0)
{
for (i=0; i<nreal; i++)
{
fprintf(fpt5,"\n Lower limit of real variable %d = %e",i+1,min_realvar[i]);
fprintf(fpt5,"\n Upper limit of real variable %d = %e",i+1,max_realvar[i]);
}
fprintf(fpt5,"\n Probability of crossover of real variable = %e",pcross_real);
fprintf(fpt5,"\n Probability of mutation of real variable = %e",pmut_real);
fprintf(fpt5,"\n Distribution index for crossover = %e",eta_c);
fprintf(fpt5,"\n Distribution index for mutation = %e",eta_m);
}
fprintf(fpt5,"\n Number of binary variables = %d",nbin);
if (nbin!=0)
{
for (i=0; i<nbin; i++)
{
fprintf(fpt5,"\n Number of bits for binary variable %d = %d",i+1,nbits[i]);
fprintf(fpt5,"\n Lower limit of binary variable %d = %e",i+1,min_binvar[i]);
fprintf(fpt5,"\n Upper limit of binary variable %d = %e",i+1,max_binvar[i]);
}
fprintf(fpt5,"\n Probability of crossover of binary variable = %e",pcross_bin);
fprintf(fpt5,"\n Probability of mutation of binary variable = %e",pmut_bin);
}
fprintf(fpt5,"\n Seed for random number generator = %e",seed);
fprintf(fpt1,"# of objectives = %d, # of constraints = %d, # of real_var = %d, # of bits of bin_var = %d, constr_violation, rank, crowding_distance\n",nobj,ncon,nreal,bitlength);
fprintf(fpt2,"# of objectives = %d, # of constraints = %d, # of real_var = %d, # of bits of bin_var = %d, constr_violation, rank, crowding_distance\n",nobj,ncon,nreal,bitlength);
fprintf(fpt3,"# of objectives = %d, # of constraints = %d, # of real_var = %d, # of bits of bin_var = %d, constr_violation, rank, crowding_distance\n",nobj,ncon,nreal,bitlength);
if (printout == 2)
{
fprintf(fpt4,"# of objectives = %d, # of constraints = %d, # of real_var = %d, # of bits of bin_var = %d, constr_violation, rank, crowding_distance\n",nobj,ncon,nreal,bitlength);
}
}
//
global.nreal = nreal;
global.nbin = nbin;
global.nobj = nobj;
global.ncon = ncon;
global.popsize = popsize;
global.pcross_real = pcross_real;
global.pcross_bin = pcross_bin;
global.pmut_real = pmut_real;
global.pmut_bin = pmut_bin;
global.eta_c = eta_c;
global.eta_m = eta_m;
global.ngen = ngen;
global.nbits = nbits;
global.min_realvar = min_realvar;
global.max_realvar = max_realvar;
global.min_binvar = min_binvar;
global.max_binvar = max_binvar;
global.bitlength = bitlength;
//
nbinmut = 0;
nrealmut = 0;
nbincross = 0;
nrealcross = 0;
parent_pop = (population *)malloc(sizeof(population));
child_pop = (population *)malloc(sizeof(population));
mixed_pop = (population *)malloc(sizeof(population));
allocate_memory_pop (parent_pop, popsize, global);
allocate_memory_pop (child_pop, popsize, global);
allocate_memory_pop (mixed_pop, 2*popsize, global);
randomize();
initialize_pop (parent_pop, global);
// First Generation
if (printout >= 1)
{
fprintf(fpt6,"\n\n Initialization done, now performing first generation");
}
decode_pop(parent_pop, global);
evaluate_pop(parent_pop, global);
assign_rank_and_crowding_distance (parent_pop, global);
if (printout >= 1)
{
report_pop (parent_pop, fpt1, global);
if (printout == 2)
{
fprintf(fpt4,"# gen = 1\n");
report_pop(parent_pop,fpt4, global);
}
fprintf(fpt6,"\n gen = 1");
fflush(fpt1);
fflush(fpt2);
fflush(fpt3);
if (printout == 2)
{
fflush(fpt4);
}
fflush(fpt5);
fflush(fpt6);
}
fflush(stdout);
// Iterate Generations
for (i=2; i<=ngen; i++)
{
selection(parent_pop, child_pop, global, nrealcross, nbincross);
mutation_pop(child_pop, global, nrealmut, nbinmut);
decode_pop(child_pop, global);
evaluate_pop(child_pop, global);
merge (parent_pop, child_pop, mixed_pop, global);
fill_nondominated_sort (mixed_pop, parent_pop, global);
/* Comment following three lines if information for all
generations is not desired, it will speed up the execution */
if (printout >= 1)
{
if (printout == 2)
{
fprintf(fpt4,"# gen = %i\n",i);
report_pop(parent_pop,fpt4, global);
fflush(fpt4);
}
fprintf(fpt6,"\n gen = %i",i);
fflush(fpt6);
}
}
// Output
if (printout >= 1)
{
fprintf(fpt6,"\n Generations finished");
report_pop(parent_pop,fpt2, global);
report_feasible(parent_pop,fpt3, global);
if (nreal!=0)
{
fprintf(fpt5,"\n Number of crossover of real variable = %i",nrealcross);
fprintf(fpt5,"\n Number of mutation of real variable = %i",nrealmut);
}
if (nbin!=0)
{
fprintf(fpt5,"\n Number of crossover of binary variable = %i",nbincross);
fprintf(fpt5,"\n Number of mutation of binary variable = %i",nbinmut);
}
fflush(stdout);
fflush(fpt1);
fflush(fpt2);
fflush(fpt3);
if (printout == 2)
{
fflush(fpt4);
}
fflush(fpt5);
fflush(fpt6);
fclose(fpt1);
fclose(fpt2);
fclose(fpt3);
if (printout == 2)
{
fclose(fpt4);
}
fclose(fpt5);
}
//
for (i=0; i<popsize; i++)
{
if (parent_pop->ind[i].constr_violation == 0.0 && parent_pop->ind[i].rank==1)
{
for (j=0; j<nobj; j++)
{
f[j] = parent_pop->ind[i].obj[j];
}
if (ncon!=0)
{
for (j=0; j<ncon; j++)
{
g[j] = parent_pop->ind[i].constr[j];
}
}
if (nreal!=0)
{
for (j=0; j<nreal; j++)
{
x[j] = parent_pop->ind[i].xreal[j];
}
}
break;
}
}
//
if (nreal!=0)
{
free (min_realvar);
free (max_realvar);
}
if (nbin!=0)
{
free (min_binvar);
free (max_binvar);
free (nbits);
}
deallocate_memory_pop (parent_pop, popsize, global);
deallocate_memory_pop (child_pop, popsize, global);
deallocate_memory_pop (mixed_pop, 2*popsize, global);
free (parent_pop);
free (child_pop);
free (mixed_pop);
//
if (printout >= 1)
{
fprintf(fpt6,"\n Routine successfully exited \n");
fflush(fpt6);
fclose(fpt6);
}
return (0);
}
int maintest (int argc, char **argv)
{
int i;
FILE *fpt1;
FILE *fpt2;
FILE *fpt3;
FILE *fpt4;
FILE *fpt5;
population *parent_pop;
population *child_pop;
population *mixed_pop;
int gnuplt= 1;
if (argc<2)
{
printf("\n Usage ./nsga2r random_seed \n");
exit(1);
}
seed = (double)atof(argv[1]);
if (seed<=0.0 || seed>=1.0)
{
printf("\n Entered seed value is wrong, seed value must be in (0,1) \n");
exit(1);
}
fpt1 = fopen("initial_pop.out","w");
fpt2 = fopen("final_pop.out","w");
fpt3 = fopen("best_pop.out","w");
fpt4 = fopen("all_pop.out","w");
fpt5 = fopen("params.out","w");
fprintf(fpt1,"# This file contains the data of initial population\n");
fprintf(fpt2,"# This file contains the data of final population\n");
fprintf(fpt3,"# This file contains the data of final feasible population (if found)\n");
fprintf(fpt4,"# This file contains the data of all generations\n");
fprintf(fpt5,"# This file contains information about inputs as read by the program\n");
if(argc > 2) {
char *in_file_name = argv[2];
if (read_inputParam_from_file(in_file_name) < 0) exit(1);
gnuplt = 0;
}
else
if (read_inputParam() < 0) exit(1);
printf("\n Input data successfully entered, now performing initialization \n");
fprintf(fpt5,"\n Population size = %d",popsize);
fprintf(fpt5,"\n Number of generations = %d",ngen);
fprintf(fpt5,"\n Number of objective functions = %d",nobj);
fprintf(fpt5,"\n Number of constraints = %d",ncon);
fprintf(fpt5,"\n Number of real variables = %d",nreal);
if (nreal!=0)
{
for (i=0; i<nreal; i++)
{
fprintf(fpt5,"\n Lower limit of real variable %d = %e",i+1,min_realvar[i]);
fprintf(fpt5,"\n Upper limit of real variable %d = %e",i+1,max_realvar[i]);
}
fprintf(fpt5,"\n Probability of crossover of real variable = %e",pcross_real);
fprintf(fpt5,"\n Probability of mutation of real variable = %e",pmut_real);
fprintf(fpt5,"\n Distribution index for crossover = %e",eta_c);
fprintf(fpt5,"\n Distribution index for mutation = %e",eta_m);
}
fprintf(fpt5,"\n Number of binary variables = %d",nbin);
if (nbin!=0)
{
for (i=0; i<nbin; i++)
{
fprintf(fpt5,"\n Number of bits for binary variable %d = %d",i+1,nbits[i]);
fprintf(fpt5,"\n Lower limit of binary variable %d = %e",i+1,min_binvar[i]);
fprintf(fpt5,"\n Upper limit of binary variable %d = %e",i+1,max_binvar[i]);
}
fprintf(fpt5,"\n Probability of crossover of binary variable = %e",pcross_bin);
fprintf(fpt5,"\n Probability of mutation of binary variable = %e",pmut_bin);
}
fprintf(fpt5,"\n Seed for random number generator = %e",seed);
bitlength = 0;
if (nbin!=0)
{
for (i=0; i<nbin; i++)
{
bitlength += nbits[i];
}
}
fprintf(fpt1,"# of objectives = %d, # of constraints = %d, # of real_var = %d, # of bits of bin_var = %d, constr_violation, rank, crowding_distance\n",nobj,ncon,nreal,bitlength);
fprintf(fpt2,"# of objectives = %d, # of constraints = %d, # of real_var = %d, # of bits of bin_var = %d, constr_violation, rank, crowding_distance\n",nobj,ncon,nreal,bitlength);
fprintf(fpt3,"# of objectives = %d, # of constraints = %d, # of real_var = %d, # of bits of bin_var = %d, constr_violation, rank, crowding_distance\n",nobj,ncon,nreal,bitlength);
fprintf(fpt4,"# of objectives = %d, # of constraints = %d, # of real_var = %d, # of bits of bin_var = %d, constr_violation, rank, crowding_distance\n",nobj,ncon,nreal,bitlength);
nbinmut = 0;
nrealmut = 0;
nbincross = 0;
nrealcross = 0;
parent_pop = (population *)malloc(sizeof(population));
child_pop = (population *)malloc(sizeof(population));
mixed_pop = (population *)malloc(sizeof(population));
allocate_memory_pop (parent_pop, popsize);
allocate_memory_pop (child_pop, popsize);
allocate_memory_pop (mixed_pop, 2*popsize);
randomize();
initialize_pop (parent_pop);
printf("\n Initialization done, now performing first generation");
decode_pop(parent_pop);
evaluate_pop (parent_pop);
assign_rank_and_crowding_distance (parent_pop);
report_pop (parent_pop, fpt1);
fprintf(fpt4,"# gen = 1\n");
report_pop(parent_pop,fpt4);
printf("\n gen = 1");
fflush(stdout);
if (choice!=0) {
if(gnuplt) onthefly_display (parent_pop,gp,1);
else display (parent_pop,1);
}
fflush(fpt1);
fflush(fpt2);
fflush(fpt3);
fflush(fpt4);
fflush(fpt5);
_sleep(1);
for (i=2; i<=ngen; i++)
{
selection (parent_pop, child_pop);
mutation_pop (child_pop);
decode_pop(child_pop);
evaluate_pop(child_pop);
merge (parent_pop, child_pop, mixed_pop);
fill_nondominated_sort (mixed_pop, parent_pop);
/* Comment following four lines if information for all
generations is not desired, it will speed up the execution */
fprintf(fpt4,"# gen = %d\n",i);
report_pop(parent_pop,fpt4);
fflush(fpt4);
if (choice!=0) {
if(gnuplt) onthefly_display (parent_pop,gp,i);
else display (parent_pop,i);
}
printf("\n gen = %d",i);
}
printf("\n Generations finished, now reporting solutions");
report_pop(parent_pop,fpt2);
report_feasible(parent_pop,fpt3);
if (nreal!=0)
{
fprintf(fpt5,"\n Number of crossover of real variable = %d",nrealcross);
fprintf(fpt5,"\n Number of mutation of real variable = %d",nrealmut);
}
if (nbin!=0)
{
fprintf(fpt5,"\n Number of crossover of binary variable = %d",nbincross);
fprintf(fpt5,"\n Number of mutation of binary variable = %d",nbinmut);
}
fflush(stdout);
fflush(fpt1);
fflush(fpt2);
fflush(fpt3);
fflush(fpt4);
fflush(fpt5);
fclose(fpt1);
fclose(fpt2);
fclose(fpt3);
fclose(fpt4);
fclose(fpt5);
if (choice!=0 && gnuplt)
{
_pclose(gp);
}
if (nreal!=0)
{
free (min_realvar);
free (max_realvar);
}
if (nbin!=0)
{
free (min_binvar);
free (max_binvar);
free (nbits);
}
deallocate_memory_pop (parent_pop, popsize);
deallocate_memory_pop (child_pop, popsize);
deallocate_memory_pop (mixed_pop, 2*popsize);
free (parent_pop);
free (child_pop);
free (mixed_pop);
printf("\n Routine successfully exited \n");
return (0);
}
int main (int argc, char **argv)
{
int i;
FILE *fpt1;
FILE *fpt2;
FILE *fpt3;
FILE *fpt4;
FILE *fpt5;
population *parent_pop;
population *child_pop;
population *mixed_pop;
fpt1 = fopen("output/initial_pop.out","w");
fpt2 = fopen("output/final_pop.out","w");
fpt3 = fopen("output/best_pop.out","w");
fpt4 = fopen("output/all_pop.out","w");
fpt5 = fopen("output/params.out","w");
fprintf(fpt1,"# This file contains the data of initial population\n");
fprintf(fpt2,"# This file contains the data of final population\n");
fprintf(fpt3,"# This file contains the data of final feasible population (if found)\n");
fprintf(fpt4,"# This file contains the data of all generations\n");
fprintf(fpt5,"# This file contains information about inputs as read by the program\n");
// 读取执行参数
read_run_param();
if (seed<=0.0 || seed>=1.0)
{
printf("\n Entered seed value is wrong, seed value must be in (0,1) \n");
exit(1);
}
// printf("\n Enter the problem relevant and algorithm relevant parameters ... ");
// printf("\n Enter the population size (a multiple of 4) : ");
// scanf("%d",&popsize);
if (popsize<4 || (popsize%4)!= 0)
{
printf("\n population size read is : %d",popsize);
printf("\n Wrong population size entered, hence exiting \n");
exit (1);
}
// printf("\n Enter the number of generations : ");
// scanf("%d",&ngen);
if (ngen<1)
{
printf("\n number of generations read is : %d",ngen);
printf("\n Wrong nuber of generations entered, hence exiting \n");
exit (1);
}
// printf("\n Enter the number of objectives : ");
// scanf("%d",&nobj);
if (nobj<1)
{
printf("\n number of objectives entered is : %d",nobj);
printf("\n Wrong number of objectives entered, hence exiting \n");
exit (1);
}
// printf("\n Enter the number of constraints : ");
// scanf("%d",&ncon);
if (ncon<0)
{
printf("\n number of constraints entered is : %d",ncon);
printf("\n Wrong number of constraints enetered, hence exiting \n");
exit (1);
}
// printf("\n Enter the number of real variables : ");
// scanf("%d",&nreal);
if (nreal<0)
{
printf("\n number of real variables entered is : %d",nreal);
printf("\n Wrong number of variables entered, hence exiting \n");
exit (1);
}
if (nreal != 0)
{
min_realvar = (double *)malloc(nreal*sizeof(double));
max_realvar = (double *)malloc(nreal*sizeof(double));
for (i=0; i<nreal; i++)
{
// printf ("\n Enter the lower limit of real variable %d : ",i+1);
// scanf ("%lf",&min_realvar[i]);
// printf ("\n Enter the upper limit of real variable %d : ",i+1);
// scanf ("%lf",&max_realvar[i]);
max_realvar[i] = 1;
min_realvar[i] = 0;
if (max_realvar[i] <= min_realvar[i])
{
printf("\n Wrong limits entered for the min and max bounds of real variable, hence exiting \n");
exit(1);
}
}
// printf ("\n Enter the probability of crossover of real variable (0.6-1.0) : ");
// scanf ("%lf",&pcross_real);
if (pcross_real<0.0 || pcross_real>1.0)
{
printf("\n Probability of crossover entered is : %e",pcross_real);
printf("\n Entered value of probability of crossover of real variables is out of bounds, hence exiting \n");
exit (1);
}
// printf ("\n Enter the probablity of mutation of real variables (1/nreal) : ");
// scanf ("%lf",&pmut_real);
if (pmut_real<0.0 || pmut_real>1.0)
{
printf("\n Probability of mutation entered is : %e",pmut_real);
printf("\n Entered value of probability of mutation of real variables is out of bounds, hence exiting \n");
exit (1);
}
// printf ("\n Enter the value of distribution index for crossover (5-20): ");
// scanf ("%lf",&eta_c);
if (eta_c<=0)
{
printf("\n The value entered is : %e",eta_c);
printf("\n Wrong value of distribution index for crossover entered, hence exiting \n");
exit (1);
}
// printf ("\n Enter the value of distribution index for mutation (5-50): ");
// scanf ("%lf",&eta_m);
if (eta_m<=0)
{
printf("\n The value entered is : %e",eta_m);
printf("\n Wrong value of distribution index for mutation entered, hence exiting \n");
exit (1);
}
}
// printf("\n Enter the number of binary variables : ");
// scanf("%d",&nbin);
if (nbin<0)
{
printf ("\n number of binary variables entered is : %d",nbin);
printf ("\n Wrong number of binary variables entered, hence exiting \n");
exit(1);
}
if (nbin != 0)
{
nbits = (int *)malloc(nbin*sizeof(int));
min_binvar = (double *)malloc(nbin*sizeof(double));
max_binvar = (double *)malloc(nbin*sizeof(double));
for (i=0; i<nbin; i++)
{
// printf ("\n Enter the number of bits for binary variable %d : ",i+1);
// scanf ("%d",&nbits[i]);
if (nbits[i] < 1)
{
printf("\n Wrong number of bits for binary variable entered, hence exiting");
exit(1);
}
// printf ("\n Enter the lower limit of binary variable %d : ",i+1);
// scanf ("%lf",&min_binvar[i]);
// printf ("\n Enter the upper limit of binary variable %d : ",i+1);
// scanf ("%lf",&max_binvar[i]);
max_binvar[i] = 1;
min_binvar[i] = 0;
if (max_binvar[i] <= min_binvar[i])
{
printf("\n Wrong limits entered for the min and max bounds of binary variable entered, hence exiting \n");
exit(1);
}
}
// printf ("\n Enter the probability of crossover of binary variable (0.6-1.0): ");
// scanf ("%lf",&pcross_bin);
pcross_bin = 0.8;
if (pcross_bin<0.0 || pcross_bin>1.0)
{
printf("\n Probability of crossover entered is : %e",pcross_bin);
printf("\n Entered value of probability of crossover of binary variables is out of bounds, hence exiting \n");
exit (1);
}
// printf ("\n Enter the probability of mutation of binary variables (1/nbits): ");
// scanf ("%lf",&pmut_bin);
pmut_bin = 0.02;
if (pmut_bin<0.0 || pmut_bin>1.0)
{
printf("\n Probability of mutation entered is : %e",pmut_bin);
printf("\n Entered value of probability of mutation of binary variables is out of bounds, hence exiting \n");
exit (1);
}
}
if (nreal==0 && nbin==0)
{
printf("\n Number of real as well as binary variables, both are zero, hence exiting \n");
exit(1);
}
choice=0;
printf(" Input data successfully entered, now performing initialization \n");
fprintf(fpt5,"\n Population size = %d",popsize);
fprintf(fpt5,"\n Number of generations = %d",ngen);
fprintf(fpt5,"\n Number of objective functions = %d",nobj);
fprintf(fpt5,"\n Number of constraints = %d",ncon);
fprintf(fpt5,"\n Number of real variables = %d",nreal);
if (nreal!=0)
{
for (i=0; i<nreal; i++)
{
fprintf(fpt5,"\n Lower limit of real variable %d = %e",i+1,min_realvar[i]);
fprintf(fpt5,"\n Upper limit of real variable %d = %e",i+1,max_realvar[i]);
}
fprintf(fpt5,"\n Probability of crossover of real variable = %e",pcross_real);
fprintf(fpt5,"\n Probability of mutation of real variable = %e",pmut_real);
fprintf(fpt5,"\n Distribution index for crossover = %e",eta_c);
fprintf(fpt5,"\n Distribution index for mutation = %e",eta_m);
}
fprintf(fpt5,"\n Number of binary variables = %d",nbin);
if (nbin!=0)
{
for (i=0; i<nbin; i++)
{
fprintf(fpt5,"\n Number of bits for binary variable %d = %d",i+1,nbits[i]);
fprintf(fpt5,"\n Lower limit of binary variable %d = %e",i+1,min_binvar[i]);
fprintf(fpt5,"\n Upper limit of binary variable %d = %e",i+1,max_binvar[i]);
}
fprintf(fpt5,"\n Probability of crossover of binary variable = %e",pcross_bin);
fprintf(fpt5,"\n Probability of mutation of binary variable = %e",pmut_bin);
}
fprintf(fpt5,"\n Seed for random number generator = %e",seed);
bitlength = 0;
if (nbin!=0)
{
for (i=0; i<nbin; i++)
{
bitlength += nbits[i];
}
}
fprintf(fpt1,"# of objectives = %d, # of constraints = %d, # of real_var = %d, # of bits of bin_var = %d, constr_violation, rank, crowding_distance\n",nobj,ncon,nreal,bitlength);
fprintf(fpt2,"# of objectives = %d, # of constraints = %d, # of real_var = %d, # of bits of bin_var = %d, constr_violation, rank, crowding_distance\n",nobj,ncon,nreal,bitlength);
fprintf(fpt3,"# of objectives = %d, # of constraints = %d, # of real_var = %d, # of bits of bin_var = %d, constr_violation, rank, crowding_distance\n",nobj,ncon,nreal,bitlength);
fprintf(fpt4,"# of objectives = %d, # of constraints = %d, # of real_var = %d, # of bits of bin_var = %d, constr_violation, rank, crowding_distance\n",nobj,ncon,nreal,bitlength);
nbinmut = 0;
nrealmut = 0;
nbincross = 0;
nrealcross = 0;
// 读取问题参数
read_prob_param();
// 根据参数申请空间
allocate_prob();
// 输入问题
input_prob();
parent_pop = (population *)malloc(sizeof(population));
child_pop = (population *)malloc(sizeof(population));
mixed_pop = (population *)malloc(sizeof(population));
allocate_memory_pop (parent_pop, popsize);
allocate_memory_pop (child_pop, popsize);
allocate_memory_pop (mixed_pop, 2*popsize);
randomize();
initialize_pop (parent_pop);
printf(" Initialization done, now performing first generation\n");
decode_pop(parent_pop);
evaluate_pop (parent_pop);
assign_rank_and_crowding_distance (parent_pop);
report_pop (parent_pop, fpt1);
fprintf(fpt4,"# gen = 1\n");
report_pop(parent_pop,fpt4);
printf("gen = 1\n");
fflush(stdout);
fflush(fpt1);
fflush(fpt2);
fflush(fpt3);
fflush(fpt4);
fflush(fpt5);
//sleep(1);
for (i=2; i<=ngen; i++)
{
selection (parent_pop, child_pop);
mutation_pop (child_pop);
decode_pop(child_pop);
evaluate_pop(child_pop);
merge (parent_pop, child_pop, mixed_pop);
fill_nondominated_sort (mixed_pop, parent_pop);
/* Comment following four lines if information for all
generations is not desired, it will speed up the execution */
fprintf(fpt4,"# gen = %d\n",i);
report_pop(parent_pop,fpt4);
fflush(fpt4);
printf("gen = %d\n",i);
}
printf(" Generations finished, now reporting solutions\n");
report_pop(parent_pop,fpt2);
report_feasible(parent_pop,fpt3);
// 输出 task
FILE *fpt_task;
fpt_task = fopen("output/task_pop.out", "w");
report_pop_task(parent_pop, fpt_task);
fclose(fpt_task);
if (nreal!=0)
{
fprintf(fpt5,"\n Number of crossover of real variable = %d",nrealcross);
fprintf(fpt5,"\n Number of mutation of real variable = %d",nrealmut);
}
if (nbin!=0)
{
fprintf(fpt5,"\n Number of crossover of binary variable = %d",nbincross);
fprintf(fpt5,"\n Number of mutation of binary variable = %d",nbinmut);
}
fflush(stdout);
fflush(fpt1);
fflush(fpt2);
fflush(fpt3);
fflush(fpt4);
fflush(fpt5);
fclose(fpt1);
fclose(fpt2);
fclose(fpt3);
fclose(fpt4);
fclose(fpt5);
if (nreal!=0)
{
free (min_realvar);
free (max_realvar);
}
if (nbin!=0)
{
free (min_binvar);
free (max_binvar);
free (nbits);
}
deallocate_memory_pop (parent_pop, popsize);
deallocate_memory_pop (child_pop, popsize);
deallocate_memory_pop (mixed_pop, 2*popsize);
free (parent_pop);
free (child_pop);
free (mixed_pop);
// 释放问题申请的空间
deallocate_prob();
printf(" Routine successfully exited \n");
return (0);
}
