pso.cpp

标准的粒子群算法的c++版本 根据《微粒群算法》中的c程序自己实现得到的

#include <iostream>
using namespace std;

//随机数定义
#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 pi 3.1415926
#define popsize 20
#define dimension 2

float w=1.0;
float c1=1.8;
float c2=1.8;
float vmax=2;
float xmax[dimension];
float xmin[dimension];

float p[dimension];
float pBest;

struct node{
	float number[dimension];
	float fitness;
	float best[dimension];
	float bestFitness;
	float speed[dimension];
};

node individual[popsize];

void calculation(int i){
	//方程式
	individual[i].fitness=100*(individual[i].number[1]-individual[i].number[0]*individual[i].number[0])
		*(individual[i].number[1]-individual[i].number[0]*individual[i].number[0])
		+(individual[i].number[0]-1)*(individual[i].number[0]-1);
}

void globalBest(int i){
	float s=0;
	int flag=0;

	if(i == 0){
		s=individual[0].fitness;
		flag=0;
		for(int j=1; j<popsize; j++){
			if(s < individual[j].fitness){
				s=individual[j].fitness;
				flag=i;
			}
		}
		for(j=0; j<dimension; j++){
			p[j]=individual[flag].number[dimension];
		}
		pBest=individual[flag].fitness;
	}

	else{
		for(int j=0; j<popsize; j++){
			if(individual[j].fitness < pBest){
				for(int k=0; k<dimension; k++){
					p[k]=individual[j].number[k];
				}
				pBest=individual[j].fitness;
			}
		}
	}

}

void localBest(int i){
	if(individual[i].bestFitness>individual[i].fitness){
		for(int j=0; j<dimension; j++){
			individual[i].best[j]=individual[i].number[j];
		}
		individual[i].bestFitness=individual[i].fitness;
	}
}

void initiate(){
	//初始化个体坐标		
	for(int i=0; i<popsize; i++){
		for(int j=0; j<dimension; j++){
			individual[i].number[j] = rdft()*(xmax[j]-xmin[j]) + xmin[j];
		}
	}
	//初始化个体速度	
	for(i=0; i<popsize; i++){
		for(int j=0; j<dimension; j++){
			individual[i].speed[j]=vmax*rdft();
		}
	}
	//初始化个体最优位置
	for(i=0; i<popsize; i++){
		for(int j=0; j<dimension; j++){
			individual[i].best[j] = individual[i].number[j];
		}
	}
	//初始化个体适应值和最优适应值
	for(i=0; i<popsize; i++){
		calculation(i);
		individual[i].bestFitness = individual[i].fitness;
	}
	//
	globalBest(0);
}

int main(){
	xmin[0]=15;
	xmax[0]=30;
	xmin[1]=15;
	xmax[1]=30;
	
	int total=0;
	float sum=0;
	for(int j=0; j<50; j++){
		initiate();
		for(int i=0; i<500; i++){
			w=1.0-i*0.6/499;
			if(pBest-0<0.0001){
				total++;
				sum+=i;
				break;
			}

			else{
				for(int k=0; k<popsize; k++){
					for(int 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].speed[t];
						if(individual[k].number[t]>xmax[t])
							individual[k].number[t]=2*xmax[t]-individual[k].number[t];
						if(individual[k].number[t]<xmin[t])
							individual[k].number[t]=2*xmin[t]-individual[k].number[t];
					}
					calculation(k);
					localBest(k);
				}
				globalBest(1);
			}			
		}
		cout<<pBest<<endl;
	}
	cout<<"Total number is: "<<total<<endl;
	cout<<"Sum is: "<<sum<<endl;
	cout<<"Average is: "<<sum/total<<endl;

	return 0;
}