int n_Genes=id.InumberofGenes; 
	
	double *fitness=new double[n_Objs];
	
	N_evals++;
	
	for(j=0;j<n_Objs;j++)   // calculate fitness value without noise
	{
		if (objID==7)
			fitness[j]=obj.problem7(id.Dgenes,n_Genes,j,N_evals,genNo);   
		else if (objID==8)
			fitness[j]=obj.problem8(id.Dgenes,n_Genes,j,N_evals,genNo);   
		else if(objID==9)
			fitness[j]=obj.problem9(id.Dgenes,n_Genes,j,N_evals,genNo); 
		else if(objID==10)
			fitness[j]=obj.problem10(id.Dgenes,n_Genes,j,N_evals,genNo); 
		else if(objID==11)
			fitness[j]=obj.problem11(id.Dgenes,n_Genes,j,N_evals,genNo); 
		else 
			fitness[j]=obj.problem12(id.Dgenes,n_Genes,j,N_evals,genNo); 
		
	}
	if (objID==9)
	{
		fitness[0]=-fitness[1];
	}
	id.set_Dfitness(fitness);
	if (fitness) {delete [] fitness; fitness=NULL;}
}

void operators_NSGA2::combination(population &Q, population &P)
{
	int size=P.pop_size;
	int i;
	for (i=size;i<2*size;i++)
	{
		Q.individuals[i]=P.individuals[i-size];
	}
}

void operators_NSGA2::Evolve(int population_size, int N_generation, int SEED, int n_Genes,int n_Objs,int *GSize,double *Ub,double *Lb)
{
	P.set_pop_size(population_size);     // parrent population: size N
	Q.set_pop_size(2*population_size);     // offspring population: size N
	
	int rk;    // to store rank maximum
	int *nrank=NULL;   // to store the total individuals belong to each rank
	int i,j;
	
	genNo=0;
	n_SEED=SEED;
	n_GEN=N_generation;
	rnd.setSeed(n_SEED);
	
	obj.cur_SEED =n_SEED;
	obj.al_pc =pc;obj.al_pm =pm;
	obj.peaksetting(n_Genes); 
	
	min_values= new double[n_Objs];
	max_values= new double[n_Objs];
	
	// intialize the population P
	initialize_population(n_Genes,n_Objs,GSize,Ub,Lb,P); 
	
	
	// print to file
	
	char *filename=new char[45];
	
	char *st_prob=new char[2];
	sprintf(st_prob,"%d_",objID);
	
	char *st_seed=new char[5];
	sprintf(st_seed,"%d_",n_SEED);
	
	char *st_pc=new char[5];
	sprintf(st_pc,"%1.2f_",pc);
	
	char *st_pm=new char[5];
	sprintf(st_pm,"%1.2f_",pm);
	
	strcpy(filename,".//data//");
	
	strcat(filename,st_prob);
	
	strcat(filename,st_pc);
	strcat(filename,st_pm);
	
	strcat(filename,st_seed);
	strcat(filename,"Pareto_NSGA2");
	
	
	strcat(filename,".txt");
	ofstream f1(filename);
	
	strcpy(filename,"best_");
	
	strcat(filename,st_prob);
	
	strcat(filename,st_pc);
	strcat(filename,st_pm);
	
	strcat(filename,st_seed);
	strcat(filename,".txt");
	
	ofstream f2(filename);
	// Main NSGA2 loop	
	
	while (genNo<=n_GEN)
	{
		
		cout << genNo<< endl;
		
		///////	// CREATE offspring Q from P /////////////////////////////////////////////
		
		// find max min between objective values /////////////////
		set_objectivevalue_maxmin(P,n_Objs); 
		
		
		P.rankingN(); 
		f1<< "1" << endl;
		
		
		f2 << setiosflags(ios::fixed|ios::showpoint) << setprecision(3) << global_max << "\t"
			<< setiosflags(ios::fixed|ios::showpoint) << setprecision(3) << P.diversity() << "\t";
		//	<< setiosflags(ios::fixed|ios::showpoint) << setprecision(3) << t          << "\t"
		//	<< setiosflags(ios::fixed|ios::showpoint) << setprecision(3) << t1         << "\t";
		P.print_ParetoOptimal_fn(genNo,f1,f2); 
		
		genNo++;
		if (genNo % 25 == 0) 
			
		{
			change_peaks();
			for (i=0;i<population_size;i++)
				if (objID<=9)
					re_evaluate(P.individuals[i]);
				else
					set_objectivevalue(P.individuals[i],P.individuals[i].Dgenes); 
				
				add_secondobjective(P,population_size);
		}
		// variation
		
		selection(Q,P);  // create mating pool Q
		crossover(Q);
		mutation(Q);
		add_secondobjective(Q,population_size);
		
		// combine P and Q -> R
		combination(Q,P); 	
		
		//////////// BUILD P(t+1) from different fronts, and assign to P for next generation
		
		set_objectivevalue_maxmin(Q,n_Objs);    // minmax values need to be recalculated after each generation
		
		
		Q.rankingN();
		
		rk=Q.rank_level;      // get max rank
		
		if (nrank) {delete [] nrank; nrank=NULL;}
		nrank = new int[rk];        
		
		for (i=0;i<rk;i++)       // initialize ranking array
			nrank[i]=0;
		
		for (i=0;i<2*population_size;i++)      // calaculate total individuals belong to each rank
			nrank[Q.individuals[i].rank]+=1; 
		
		int counter=0; // to track the index in F
		int current_count=0;    // to store the current size of P(t+1)
		
		for (i=0;i<rk;i++)
		{
			if (current_count>=population_size) break;
			
			counter=0;
			int counter1=current_count;
			if (!(current_count+nrank[i]<=population_size)) F.set_pop_size(nrank[i]);     // get each front into F
			
			for (j=0;j<2*population_size;j++)           
				if (Q.individuals[j].rank==i)
				{
					if (current_count+nrank[i]<=population_size)
						
					{
						P.individuals[counter1]=Q.individuals[j];
						counter1++;
					}
					else
					{
						F.individuals[counter]=Q.individuals[j];
						counter++;
					}
				}
				//..process F..................
				
				if (current_count+nrank[i]<=population_size)   //check the current P(t+1)'s size
				{
					// put the current F into P(t+1)
					//for(j=current_count;j<current_count+nrank[i];j++)
					//	P.individuals[j]=F.individuals[j-current_count];  
					current_count += nrank[i];
				}
				else
				{
					
					// to estimate the density of solutions srrounding a particular solution
					crowding_sort(F,TRUE);   
					
					int remain= population_size - current_count;
					for(j=current_count;j<current_count+remain;j++)
						P.individuals[j]=F.individuals[j-current_count];			
					current_count += remain;
				}
		}
	}
	
	f1.close();
	f2.close();
	obj.f1.close(); 
	delete [] st_prob;
	delete [] st_pm;
	delete [] st_pc;
	delete [] st_seed;
	delete [] max_values;
	delete [] min_values;	
	delete [] filename;
	if (nrank) {delete [] nrank; nrank=NULL;}    
}

void operators_NSGA2::setAge()
{
	
}

// just for second objective of objectives <=9
void operators_NSGA2::re_evaluate(individual &id)
{
	int n_Genes=id.InumberofGenes; 
	double fitness;//=new double[n_Objs];
	
	N_evals++;
	
	if (objID==7)
		fitness=obj.problem7(id.Dgenes,n_Genes,1,N_evals,genNo);   
	else if (objID==8)
		fitness=obj.problem8(id.Dgenes,n_Genes,1,N_evals,genNo);   
	else
	{
		
		fitness=obj.problem9(id.Dgenes,n_Genes,1,N_evals,genNo);   
	}
	id.DfitnessC[1]=fitness;
	id.DfitnessN[1]=fitness;
	
}

// for objectives: 10,11,12 only
void operators_NSGA2::add_secondobjective(population &pop, int pop_size)
{
	if (objID<10) return;
	
	int i,j, i_best=0;
	double f_best=D_MAX;
	double f_min, f_arg=0;
	
	double dis;
	
	for (i=0;i<pop_size;i++)
	{
		i_best=0;f_best=D_MAX; f_min=D_MAX; f_arg=0;
		for (j=0;j<pop_size;j++)
		{
			if ((pop.individuals[j].DfitnessN[1]<f_best ) && (i!=j))
			{
				i_best=j;f_best=pop.individuals[j].DfitnessN[1];
			}
			
			dis=eDistance(pop.individuals[i],pop.individuals[j]); 
			f_arg += dis;
			
			if ((f_min>dis)&&(dis!=0)) f_min=dis;
			
		}
		
		if(f_min==D_MAX) f_min=0;
		
		f_arg=f_arg/pop_size;
		
		if (objID==10)   // smallest distance to the neighbors
		{
			
			pop.individuals[i].DfitnessC[0]=-f_min;
			pop.individuals[i].DfitnessN[0]=-f_min;
		}
		else if (objID==11) //averaged distance to the neighbors
		{
			pop.individuals[i].DfitnessC[0]=-f_arg;
			pop.individuals[i].DfitnessN[0]=-f_arg;
		}
		else   // objID==12
		{
			pop.individuals[i].DfitnessC[0]=-eDistance(pop.individuals[i],pop.individuals[i_best]);
			pop.individuals[i].DfitnessN[0]=pop.individuals[i].DfitnessC[0];
		}
	}
	
}
double operators_NSGA2::eDistance(individual &id1, individual &id2)
{
	int i,NObjs=id1.InumberofObjs;
	double temp=0;
	for (i=0;i<NObjs;i++)
		temp+=pow((id1.Dgenes[i]-id2.Dgenes[i]),2) ;
	return sqrt(temp);
}

void operators_NSGA2::init(double _pc, double _pm, int ObjID)
{
	pc=_pc;pm=_pm;obj.setObjID(ObjID);
	objID=ObjID;
	max_values=NULL;
	min_values=NULL;
	N_evals=0;
}