pso.cpp

粒子群算法与遗传算法用于优化的问题求解,可以解决一些

			maxfitness=0.0;
			for(int b=0;b<popsize;b++)
			{
				sumfitness+=midpop[b].fitness;
				if(midpop[b].fitness>maxfitness)		//记录最大适应度值
					maxfitness=midpop[b].fitness;
			}
			avefitness=sumfitness/popsize;	//计算平均适应度值

			//对P中个体进行变异算子操作
			rnd_change=rnd(1,popsize-1);//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!0 to 1
			while((change_num<=Pm*popsize)&&(Pm<=0.5))	//当变异概率未达到Pm时，且Pm小于0.5时
			{
				midfitness=midpop[rnd_change].fitness;	
				change(&(midpop[rnd_change]));		//对染色体进行变异算子操作
				fitness(&(midpop[rnd_change]));		//计算新染色体的适应度值

				for(int k=0;k<chromo_length;k++)		//将新染色体放入下一步操作中
				{
					newpop[rnd_change].chromosome[k]=midpop[rnd_change].chromosome[k];
					newpop[rnd_change].fitness=midpop[rnd_change].fitness;
				}

				change_num++;
				midpop[rnd_change].fitness=65535;	//将该染色体登记，避免重复它来变异

				sumfitness=sumfitness-midfitness+newpop[rnd_change].fitness;//计算新的适应度和
				avefitness=sumfitness/popsize;//计算新的适应度平均值
				if(newpop[rnd_change].fitness>maxfitness)//调整适应度最大值
					maxfitness=newpop[rnd_change].fitness;

				if(avefitness/maxfitness>0.6)	//自适应函数
					Pm=Pm*(1/(1-avefitness/maxfitness));

				do			//选择另一个染色体进行变异算子操作
				{
					rnd_change=rnd(1,popsize-1);//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!0 to 1
				}
				while(midpop[rnd_change].fitness==65535);
			}

			for(int t=0;t<popsize;t++)		//将未进行变异算子的其他染色体全部进入下一步操作
				if(midpop[t].fitness!=65535)
				{
					for(int u=0;u<chromo_length;u++)
						newpop[t].chromosome[u]=midpop[t].chromosome[u];
					newpop[t].fitness=midpop[t].fitness;
				}
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
			//temper->fitness=65535;
			for(int d=0;d<popsize;d++)
			{
				if(newpop[d].fitness<optimal_indivi->fitness)	//将最优染色体找出来并保存起来
				{
					for(int f=0;f<chromo_length;f++)
						optimal_indivi->chromosome[f]=newpop[d].chromosome[f];
					optimal_indivi->fitness=newpop[d].fitness;
					best_cycle=cycle;
					best_gen=gen;
					time_best=(double)clock();
				}
			}
			//将本代最佳染色体放在新一代的第0个上
			for(int f=0;f<chromo_length;f++)
				oldpop[0].chromosome[f]=optimal_indivi->chromosome[f];
		    	oldpop[0].fitness=optimal_indivi->fitness;

			//计算最佳染色体是否已经连续100次相同
			if(optimal_indivi->fitness< cur_bestfitness)
			{
				cur_bestfitness=optimal_indivi->fitness;
				already_optimal=0;
			}
		    else  if  (optimal_indivi->fitness==cur_bestfitness) 
			{	
				already_optimal++;
		           	
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!end
			//如果连续100次相同 则开始新的一周期
			    if(already_optimal>=100)
				{
cout<<"第"<<cycle<<"次GA"<<"收敛于第"<<gen<<"代,适用度为:"<<optimal_indivi->fitness<<",连续"<<already_optimal<<"代结果一致"<<endl;
								
					break;
				}
			}
			         else 
                already_optimal=0;

			//计算所有染色体的适应度之和
		sumfitness=0.0;
		for(int a=0;a<popsize;a++)
			sumfitness+=newpop[a].fitness;

			//轮盘赌，选择N－1个染色体进入下一代
			for(int c=1;c<popsize;c++)
			{	
				select_num=select();
				for(int d=0;d<chromo_length;d++)
					oldpop[c].chromosome[d]=newpop[select_num].chromosome[d];
				oldpop[c].fitness=newpop[select_num].fitness;
			}
		}
		
		outfile<<"第"<<cycle<<"周期为:\n";
	outfilezz<<"第"<<cycle<<"周期为:\n";

			
	     	output(&(oldpop[0]));
		
		//对新的一个周期，除最佳染色体外，其余赋予随机值
		for(int j=1;j<popsize;j++)//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1 to 0
		{
			h=0;
			for(int i=0;i<sequence_number;i++)
			{	
				for(int k=0;k<chromosize-(sequence_length[i]-min_sequence_length);k++)       
					oldpop[j].chromosome[k+h]=rnd(0,sequence_length[i]);//给染色体赋予随机序列					
				h+=chromosize-(sequence_length[i]-min_sequence_length);			
			}	
			fitness(&(oldpop[j]));		//计算初始种群的适应度
		}
		already_optimal=0;//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!漏了
		cur_bestfitness=65535;//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!漏了
		//outfile<<endl;	
	}

	outfile<<"最佳";
	output(optimal_indivi);
	outfile<<"出现的周期为:"<<best_cycle<<"  出现在该周期的代数为:"<<best_gen<<endl;
	outfile<<"出现最佳的时间为:"<<(time_best-time1)<<"毫秒.\n";
	
	outfilezz<<"最佳";
	
	outfilezz<<"出现的周期为:"<<best_cycle<<"  出现在该周期的代数为:"<<best_gen<<endl;
	outfilezz<<"出现最佳的时间为:"<<(time_best-time1)<<"毫秒.\n";

	
	
	
	//freeall();

	time2=(double)clock();
	outfile<<"程序运行时间为:"<<(time2-time1)<<"毫秒.\n";
	
	outfilezz<<"程序运行时间为:"<<(time2-time1)<<"毫秒.\n";

	
	
	cout<<"遗传算法结束,生成最佳染色体。。继续pso算法。。"<<endl;
	outfile<<"遗传算法结束,生成最佳染色体。。继续pso算法。。"<<endl;

outfilezz<<"遗传算法结束,生成最佳染色体。。继续pso算法。。"<<endl;





}
void pso()
{
		double	timezz1=(double)clock();
	double timez1;	
		
	int besti;
	double minfitness=60000;
	int already_optimal=0;


outfilezz<<"pso次数"<<"  代数"<<"  适用值 "<<"  发的时间"<<endl;

	
// for(int q=0;q<2;q++)	
 	for(int q=0;q<Numofpso;q++)
	{
		initpop();
//cout<<"zzz运行周期为："<<q<<endl;
  /*if(q==0)
{
	for(int d=0;d<popsize;d++)
			{
				if(oldpop[d].fitness<optimal_indivi->fitness)	//将最优染色体找出来并保存起来
				{
					for(int f=0;f<chromo_length;f++)
						optimal_indivi->chromosome[f]=oldpop[d].chromosome[f];
					optimal_indivi->fitness=oldpop[d].fitness;
					
				}
			}

}*/


//for(gen = 0 ; gen<2;gen++)
	for(gen = 0 ; gen<EG;gen++)
		{

cout<<"zzz运行周期为："<<q<<" 运行代为："<<gen<<endl;
			//w = (float)((1.0 - gen*0.6)/EG);
			w = 2 * randomperc();
			//w = 2 ;
			minfitness=60000;

	
			for(int j = 0 ; j < chromo_length; j++)
			{   
				pz->chromosome[j]=0;
	for(int i = 0 ; i < popsize ; i++)
				{
  pz->chromosome[j]=pz->chromosome[j]+oldpop[i].chromosome[j];

				}
   pz->chromosome[j]=pz->chromosome[j]/popsize;


			}





       for(int i = 0 ; i < popsize ; i++)
			{
				for(int j = 0 ; j < chromo_length; j++)
				{
	oldpopz3[i].speed[j] = w * oldpop[i].speed[j] + 
	c1*randomperc()*(oldpop[i].lbestp[j] - oldpop[i].chromosome[j]) + 
	c2*randomperc()*(optimal_indivi->chromosome[j] - oldpop[i].chromosome[j]); 
					while(oldpopz3[i].speed[j] > maxv)
					{
						oldpopz3[i].speed[j] -= maxv;
						//cout<<i<<","<<j<<" , "<<oldpop[i].speed[j]<<endl;
					}
					while(oldpopz3[i].speed[j] < -maxv)
					{
						oldpopz3[i].speed[j] +=  maxv;
						//cout<<i<<","<<j<<" , "<<oldpop[i].speed[j]<<endl;
					}
					oldpopz3[i].chromosome[j] = oldpop[i].chromosome[j] + (int)oldpopz3[i].speed[j];		
					if(oldpopz3[i].chromosome[j] < minx)
					{
						oldpopz3[i].chromosome[j] = 2*minx - oldpopz3[i].chromosome[j];
						//cout<<oldpop[i].chromosome[j]<<endl;
					}
					if(oldpopz3[i].chromosome[j] > maxx)
					{
						oldpopz3[i].chromosome[j] = 2*maxx - oldpopz3[i].chromosome[j] ;
						//cout<<oldpop[i].chromosome[j]<<endl;
					}
								
				
				}
			fitness(&oldpopz3[i]);
	


          for(int k = 0 ; k < chromo_length ; k++)
		  {
			oldpop[i].chromosome[k] =oldpopz3[i].chromosome[k];
		 	oldpop[i].speed[k] =oldpopz3[i].speed[k] ;
		       
		  }
			oldpop[i].fitness=oldpopz3[i].fitness;



			if(oldpop[i].fitness < oldpop[i].lbestfit)
			{
				for(int j = 0 ; j < chromo_length ; j++)
					oldpop[i].lbestp[j] = oldpop[i].chromosome[j] ;
				oldpop[i].lbestfit = oldpop[i].fitness;
			}

			if(oldpop[i].fitness < minfitness)
			{
				besti=i;
				minfitness=oldpop[i].fitness;
			}
		}

		if(oldpop[besti].fitness < optimal_indivi->fitness)
			{
				for(int j = 0 ; j < chromo_length ; j++)
				{
					optimal_indivi->chromosome[j] = oldpop[besti].chromosome[j] ;
					optimal_indivi->speed[j] = oldpop[besti].speed[j];
				}
				optimal_indivi->fitness  = oldpop[besti].fitness;
				best_gen = gen ;

timez1=(double)clock();

outfile<<"第"<<q<<"次pso"<<"第"<<best_gen<<"代最好的染色体为："<<endl;


outfilezz<<"      "<<q<<"   "<<best_gen<<"   "<<optimal_indivi->fitness<<"    "<<timez1-timezz1<<endl;
	


cout<<"出现新个体在第"<<q<<"次pso"<<"第"<<best_gen<<"代 "<<"适用度为:"<<optimal_indivi->fitness<<endl;

				output(optimal_indivi);
				already_optimal = 0 ;
			}
		else if(oldpop[besti].fitness == optimal_indivi->fitness)
			{
				already_optimal++;
			//	cout<<gen<<"   "<<already_optimal<<endl;
			//	output(optimal_indivi);
				if (already_optimal >= 100)
				{
cout<<"第"<<q<<"次pso"<<"收敛于第"<<gen<<"代，连续"<<already_optimal<<"代结果一致"<<",适用值为:"<<optimal_indivi->fitness<<endl;
					goto stop;
				}
			}
		else
			already_optimal = 0 ;
		}
	stop:
	already_optimal = 0 ;
	}
}

void main()
{
	double time1,time2;//time_best;
	int already_optimal=0;		//最佳染色体出现了几代相同了
	time1=(double)clock();		//程序开始的时间
	begin();
	GA();
	cout<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"<<endl;
pso();
	outfile<<"最佳";
	output(optimal_indivi);
	//outfile<<"收敛于第"<<gen<<"代，连续"<<gen-best_gen<<"代结果一致"<<endl;
	//outfile<<"出现的周期为:"<<best_cycle<<"  出现在该周期的代数为:"<<best_gen<<endl;
	freeall();
	time2=(double)clock();
	outfile<<"程序运行时间为:"<<(time2-time1)<<"毫秒.\n";
	cout<<"pso结束"<<endl;
}