spso1.cpp

曾建潮编写的微粒群算法的随机微粒群算法的源程序代码

//库文件
#include "stdafx.h"
#include"stdio.h"
#include"stdlib.h"
#include"time.h"
#include"math.h"
//随机数定义
#define rdint(i) (rand()%(int)(i))
#define rdft() (double)((double)rdint(16384)/(16383.0))
#define rnd(a,b) (rdint((int)(b)-(int)(a)+1)+(int)(a))
//宏定义
#define POPSIZE 20 //种群数
#define DIMENSION 2//维数
//全局变量定义
double W=0.0;
double C1=1.8;
double C2=1.8;
double VMAX=100.0;
double XMIN=-100.0;
double XMAX=100.0;
double P[DIMENSION];//种群最优微粒的每维数值
double PBEST;       //种群最优适应度
int kk;
struct indi
{
	double number[DIMENSION];//第i个微粒位置的每维数值
	double best[DIMENSION];  //第i个微粒位置的每维数值的最优值
	double bestfitness;      //第i个微粒的最优适应度
	double fitness;          //第i个微粒的当前适应度
	double speed[DIMENSION]; //第i个微粒速度的每维数值
}individual[POPSIZE];

void initiate(void);
void calculation(int num);
void globalbest(int count);
void localbest(int num);
void generate(int num);

void generate(int num)
{
	int j;
	for (j=0;j<DIMENSION;j++)
		individual[num].number[j]=rdft()*(XMAX-XMIN)+XMIN;
	calculation(num);
	individual[num].bestfitness=individual[num].fitness;
	for (j=0;j<DIMENSION;j++)
		individual[num].best[j]=individual[num].number[j];
}


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 num)//num表第num个微粒
{
	int i;
	if (individual[num].bestfitness>individual[num].fitness)
		for (i=0;i<DIMENSION;i++)
			individual[num].best[i]=individual[num].number[i];
	individual[num].bestfitness=individual[num].fitness;
}

//种群历史最优位置修改程序
void globalbest(int count)//count表第count代
{
	int i,j;
	double s=0;
	int flag=0;
	if (count==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)
{
	int i;
	double s=0.0,h=0.0,x,y,z;
/*	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;
    */

x=individual[num].number[0];
y=individual[num].number[1];
//z=x*x+y*y;
//z=5.0*sin(x*y)+x*x+y*y; 
//z=100*(x-y*y)*(x-y*y)+(1-y)*(1-y);
//z=x*x-0.4*cos(3*PI*x)+2*y*y-0.6*cos(4*PI*y)+1;
//z=5.0*sin(x*y)+x*x+y*y; 
z=0.5+(sin(sqrt(x*x+y*y))*sin(sqrt(x*x+y*y))-0.5)/((1+0.001*(x*x+y*y))*(1+0.001*(x*x+y*y)));
//z=(x*x-10*cos(2*PI*x)+10)+(y*y-10*cos(2*PI*y)+10);
//z=100*(x-y*y)*(x-y*y)+(1-y)*(1-y);
//z=x*x-0.4*cos(3*PI*x)+2*y*y-0.6*cos(4*PI*y);
//z=1.0/double(4000)*(x*x+y*y)-cos(x)*cos(y/sqrt(2))+1;
//z=x*x+y*y;
//z=(x*x-10*cos(2*PI*x)+10)+(y*y-10*cos(2*PI*y)+10);

//for(i=0;i<=2;i++)y1[i]=1+(x1[i]-1)/4;
//for(i=0;i<=1;i++)s=s+(y1[i]-1)*(y1[i]-1)*(1+10*sin(PI*y1[i+1])*sin(PI*y1[i+1]));
//z=s+sin(PI*y1[0])*sin(PI*y1[0])+(y1[2]-1)*(y1[2]-1);

//for(i=0;i<DIMENSION;i++)x1[i]=r[i];
//for(i=0;i<DIMENSION;i++)z=z+(x1[i]*x1[i]-10*cos(2*PI*x1[i])+10);

//for(i=0;i<DIMENSION-1;i++)z=z+100*(x1[i+1]-x1[i]*x1[i])*(x1[i+1]-x1[i]*x1[i])+(1-x1[i])*(1-x1[i]);




/*for(i=1;i<=5;i++)
	 {
	  s=s+i*cos((i-1)*x+i);
	  h=h+i*cos((i+1)*y+i);
	 }
     
     z=s*h+(x+1.42513)*(x+1.42513)+(y+0.80032)*(y+0.80032);
	 
*/


individual[num].fitness=z;
}

//主程序
void main()
{
	int i,j,k,t,total=0,flag=-1,fflag;
	double sum=0,ssum=0,temp[DIMENSION],s,maxfitness=-1000,minfitness=1000;
    
	kk=(unsigned)time(NULL);
    srand((unsigned)time(NULL)+kk++);
	
	for (j=0;j<50;j++)     //50次运行
	{
		initiate();
		for (i=0;i<500;i++)//500代运算
		{
			flag=-1;
			//寻找是否存在最优微粒
			for (k=0;k<POPSIZE;k++)
			{
				if ((individual[k].fitness==individual[k].bestfitness)&&(individual[k].fitness=PBEST))
				{
					flag=k;
					break;
				}
			}
			if (flag!=-1)
				generate(flag);
			for (k=0;k<POPSIZE;k++)
				if (k!=flag)
				{
					for (t=0;t<DIMENSION;t++)
					{
						individual[k].speed[t]=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);
					localbest(k);
				}
				globalbest(1);

			if (PBEST<0.00001)
			{
				total++;
				sum=sum+i;
				break;
			}
		}
		//printf("%d,%f\t",i,PBEST);
     ssum=ssum+PBEST;
    if(maxfitness<PBEST)maxfitness=PBEST;
    if(minfitness>PBEST)minfitness=PBEST;
        printf("%3d,%3d,%18.15f,%18.15f,%18.15f\n",j,i,P[0],P[1],PBEST);
	}
	printf("Total number is %d\n",total);
	printf("Sum is %f\n",sum);
	printf("Average is %f\n",sum/total);
	printf("aver=:%18.15f,min=%18.15f,max=%18.15f\n,total=%3d\n",ssum/100,minfitness,maxfitness,total);
}