yu.c

c语言的pso算法

/*该程序用PSO算法求解约束性优化问题， */ 
 
//库文件 
#include"stdio.h" 
#include"stdlib.h" 
#include"math.h" 

//随机数定义 ,r1 ~U(0,1)，r2 ~U(0,1)为两个相互独立的随机函数
#define rdint(i) (rand()%(int)(i)) 
#define rdft() (float)((double)rdint(16384)/(16383.0)) 
#define rnd(a,b) (rdint((int)(b)-(int)(a)+1)+(int)(a)) 
 
//宏定义 
#define POPSIZE 20 //粒子群规模
#define DIMENSION 2 //微粒的多维向量的维数为3
 
//全局变量定义 
float SHK=0.73;//收缩因子
float W=0.9; //权重
float C1=1.8; //c1、c2为加速常数，通常在0~2间取值。
float C2=1.8; 
float VMAX=2; /*为了减少在进化过程中，微粒离开搜索空间的可能性，vij通常限定于一定
			  范围内，即v∈[-vmax ,vmax]。如果问题的搜索空间限定在[-xmax ，xmax ]内，则可设定v =k·x ，
              0.1≤k≤1.0。*/ 
float XMIN=-2.0; //搜索空间限定,-2<x1,x2<2
float XMAX=2.0; 
float P[DIMENSION]; //全局最好位置，对应该Goldstein-Price函数最小值的x1,x2取值
float PBEST; //全局最佳适应值，对应该Goldstein-Price函数的函数最小值
 
struct individual //定义粒子属性
{ 
 float number[DIMENSION]; //个体当前位置
 float best[DIMENSION]; //个体最好位置
 float bestfitness; //个体最佳适应值
 float fitness; //个体当前适应值
 float speed[DIMENSION]; //个体当前速度
}individual[POPSIZE]; 
 
void initiate(void); 
void calculation(int number); 
void globalbest(int number); 
void localbest(int number); 
 
//程序初始化定义 
void initiate() 
{ 
 int i,j; 
 for(i=0;i<POPSIZE;i++) //对每个粒子的位置进行初始化
  for(j=0;j<DIMENSION;j++) 
   individual[i].number[j]=rdft()*(XMAX-XMIN)+XMIN; 
 for(i=0;i<POPSIZE;i++) //对每个粒子的速度进行初始化
  for(j=0;j<DIMENSION;j++) 
   individual[i].speed[j]=VMAX*rdft(); 
 for(i=0;i<POPSIZE;i++) //粒子初始化时，其初始化位置即设为个体最佳位置
  for(j=0;j<DIMENSION;j++) 
   individual[i].best[j]=individual[i].number[j]; 
 for(i=0;i<POPSIZE;i++) //计算每个粒子的当前适应值
  calculation(i); 
 for(i=0;i<POPSIZE;i++) //将每个粒子的当前适应值设为个体最佳适应值
  individual[i].bestfitness=individual[i].fitness; 
 globalbest(0); //求出初始化后，全局最佳适应值，全局最佳位置
} 
 
//微粒历史最优位置修改程序 
void localbest(int number) 
{ 
 int i; 
 if(individual[number].bestfitness>individual[number].fitness) 
  for(i=0;i<DIMENSION;i++) 
   individual[number].best[i]=individual[number].number[i]; 
 individual[number].bestfitness=individual[number].fitness; 
} 
 
//种群历史最优位置修改程序 
void globalbest(int number) 
{ 
 int i,j; 
 float s=0; 
 int flag=0; 
 if(number==0) //对初始化的种群修改最佳位置
 { 
  s=individual[0].fitness; 
  flag=0; 
  for(i=1;i<POPSIZE;i++) 
   if(individual[i].fitness<s) 
	   { 
    s=individual[i].fitness; 
    flag=i; 
   } 
  for(i=0;i<DIMENSION;i++) 
   P[i]=individual[flag].number[i]; 
  PBEST=individual[flag].fitness; 
 } 
 else //对进化后的种群修改最佳位置
 { 
  for(i=0;i<POPSIZE;i++) 
   if(individual[i].bestfitness<PBEST) 
   { 
    for(j=0;j<DIMENSION;j++) 
     P[j]=individual[i].best[j]; 
    PBEST=individual[i].bestfitness; 
   } 
 } 
} 
 
//适应值函数计算程序 
void calculation(int num) 
{ //计算编号为“nmu”的粒子的当前适应值
 int i; 
 float s=0.0,h=0.0; 
 s=pow(individual[num].number[0]+individual[num].number[1]+1.0,2.0)*(19.0-14.0*individual[num].number[0]+3.0*pow(individual[num].number[0],2.0)-14.0*individual[num].number[1]+6.0*individual[num].number[0]*individual[num].number[1]+3.0*pow(individual[num].number[1],2.0))+1.0; 
 h=30.0+pow(2.0*individual[num].number[0]-3.0*individual[num].number[1],2.0)*(18.0-32.0*individual[num].number[0]+12.0*pow(individual[num].number[0],2.0)+48.0*individual[num].number[1]-36.0*individual[num].number[0]*individual[num].number[1]+27.0*pow(individual[num].number[1],2.0)
); 
 individual[num].fitness=s*h; 
} 
 
//主程序 
main() 
{ 
 int i,j,k,t,total=0; 
 float sum=0,Total_fit=0; 
 for(j=0;j<100;j++) //进行100次的试验
 { 
  initiate(); //将粒子群初始化
      for(i=0;i<1000;i++) //一次优化过程中最大的迭代次数是1000
  { 
   W=0.9-i*0.5/1000; /*设置权重，将W设定为随着进化而线性减少，这样使粒子在前期有较高的探索能力以得到合适的种子，而在后期有较高的开发能力以加快收敛速度*/
   if((PBEST-3.0)<0.0001) 
   { 
    total++; //统计试验成功（即达到迭代终止条件）的次数，total<=100.
    sum=sum+i; //统计每次试验（共100次）之后所进行的总的迭代次数。
	Total_fit=Total_fit+PBEST; 
    break; //当全局最佳适应值PBEST达到迭代终止条件时跳出循环。
   } 
   else 
   { 
    for(k=0;k<POPSIZE;k++) 
    { 
     for(t=0;t<DIMENSION;t++) 
     {  //一次迭代过程，根据进化方程进行优化
		 individual[k].speed[t]=SHK*(W*individual[k].speed[t]+C1*rdft()*(individual[k].best[t]-individual[k].number[t]))+C2*rdft()*(P[t]-individual[k].number[t]); 
		 if(individual[k].speed[t]>VMAX) 
			 individual[k].speed[t]=VMAX; 
		 individual[k].number[t]=individual[k].number[t]+individual[k].speed[t]; 
		 if(individual[k].number[t]<XMIN) 
			 individual[k].number[t]=2*XMIN-individual[k].number[t]; 
		 if(individual[k].number[t]>XMAX) 
			 individual[k].number[t]=2*XMAX-individual[k].number[t]; 
	 } 
	 calculation(k); //一个粒子一次进化结束后，计算该粒子的适应值individual[num].fitness
     localbest(k); //一个粒子一次进化结束后，计算该粒子个体最佳适应值individual[number].bestfitness
	} 
	globalbest(1); //所以粒子进行一次进化后，计算全局最佳适应值PBEST
   } 
  } 
	  
		  printf("迭代次数：%d,   函数最佳适应值：%f\n",i,PBEST); //一次试验结束后后，计算迭代次数i和最小值PBEST
 } 
  printf("\n试验成功概率：%d(共100次)\n",total); 
  printf("总的迭代次数：%f\n",sum); 
  printf("平均迭代次数=总的迭代次数/试验成功次数=%f\n",sum/total); 
  printf("总的最佳适应值之和：%f\n",Total_fit);
  printf("平均最佳适应值=总的适应值之和/试验成功次数=%f\n",Total_fit/total);
}