parswarm.cpp

标准的粒子群优化算法,visual c++.net环境下编写的代码,有助于学习和理解粒子群算法

#include "StdAfx.h"
#include ".\parswarm.h"

#include <stdlib.h>
#include <time.h>
#include <math.h>
#include "particle.h"

/*CParSwarm::CParSwarm(void)
{
}

CParSwarm::~CParSwarm(void)
{
}*/

CParSwarm::CParSwarm()
{
	Particle = 0;
	PNum = 0;
	GBestIndex = 0;
	PosUp = 0;
	PosDown = 0;
	W = 1;
	C1 = 2;
	C2 = 2;
	Com = 0;
}
CParSwarm::CParSwarm(int dim, int num)
{
	Particle = new CParticle[num];
	for(int i=0; i<num; i++) 
		Particle[i].SetDim(dim);

	PNum = num;
	GBestIndex = 0;
	PosUp = new double[dim];
	PosDown = new double[dim];
	Vmax = new double[dim];
	W = 1;
	C1 = 2;
	C2 = 2;
	Com = 0;
}

//析构函数
CParSwarm::~CParSwarm()
{
	if(Particle) delete []Particle;
	if(PosUp) delete []PosUp;
	if(PosDown) delete []PosDown;
	if(Vmax) delete []Vmax;
}
//设置坐标上界
void CParSwarm::SetPosUp(double *up)
{
	if(!Particle) 
		return;
	for(int i=0; i<Particle[0].Dim; i++)
		PosUp[i] = up[i];
}
//设置坐标下界
void CParSwarm::SetPosDown(double *d)
{
	if(!Particle) 
		return;
	for(int i=0; i<Particle[0].Dim;i++)
		PosDown[i] = d[i];
}
//设置最大速度
void CParSwarm::SetVmax(double *max)
{
	if(!Particle) 
		return;
	for(int i=0; i<Particle[0].Dim;i++)
		Vmax[i] = max[i];
}
void CParSwarm::SetVmax(double p)
{
	if(!Particle) 
		return;
	for(int i=0; i<Particle[0].Dim; i++)
		Vmax[i] = (PosUp[i]-PosDown[i])*p;
}

//初始化群体
void CParSwarm::Initialize()
{
	if(!Particle) 
		return;
	static int kk=(unsigned)time(NULL);
	srand( (unsigned)time(NULL)+kk++ );
	GBestIndex = 0;
	for(int i=0; i<PNum; i++)
	{
		for(int j=0; j<Particle[i].Dim; j++)
		{
			Particle[i].Pos[j] = rand()/(double)RAND_MAX*(PosUp[j]-PosDown[j])+PosDown[j];			//初始化坐标
			Particle[i].PosBest[j] = Particle[i].Pos[j];
			Particle[i].Vel[j] = rand()/(double)RAND_MAX*Vmax[j]-Vmax[j]/2;					//初始化速度
		}
		Particle[i].Fitness = GetFit(Particle[i]);												//计算该微粒适合度
		Particle[i].FitBest = Particle[i].Fitness;												//设最优适合度初值
		if(Particle[i].Fitness>Particle[GBestIndex].Fitness) 
			GBestIndex = i;																	//查找群体最优微粒
	}
}

//计算群体各个微粒适合度
void CParSwarm::CalFit()
{
	if(!Particle) 
		return;
	for(int i=0; i<PNum; i++)
		Particle[i].Fitness = GetFit(Particle[i]);
}

//微粒飞翔,产生新一代微粒
void CParSwarm::ParticleFly()
{
	static double FitBak[100];
	if(!Particle)
		return;

	static int tt=(unsigned)time(NULL);
	srand( (unsigned)time(NULL)+tt++ );
	//整个群体飞向新的位置
	for(int i=0; i<PNum; i++)
	{
		for(int j=0; j<Particle[i].Dim; j++)
			Particle[i].Vel[j] = W*Particle[i].Vel[j]+				// (FitBak[i]-Particle[i].Fit)+//修改速度
				rand()/(double)RAND_MAX*C1*(Particle[i].PosBest[j]-Particle[i].Pos[j])+
				rand()/(double)RAND_MAX*C2*(Particle[GBestIndex].PosBest[j]-Particle[i].Pos[j]);
		for(j=0; j<Particle[i].Dim; j++)											//检查速度最大值
		{
			if(Particle[i].Vel[j]>Vmax[j]) 
				Particle[i].Vel[j] = Vmax[j];
			if(Particle[i].Vel[j]<-Vmax[j])
				Particle[i].Vel[j] = -Vmax[j];
		}
		for(j=0; j<Particle[i].Dim; j++)
		{
			Particle[i].Pos[j] += Particle[i].Vel[j];									//修改坐标
			if(Particle[i].Pos[j]>PosUp[j]) 
				Particle[i].Pos[j]=PosUp[j];					//保护
			if(Particle[i].Pos[j]<PosDown[j]) 
				Particle[i].Pos[j]=PosDown[j];
		}
	}
	//计算各微粒适合度
	CalFit();
	for(i=0; i<PNum; i++) 
		FitBak[i] = Particle[i].Fitness;
	//设置新的个体最好位置
	for(i=0; i<PNum; i++)
		if(Particle[i].Fitness >= Particle[i].FitBest)
		{
			Particle[i].FitBest = Particle[i].Fitness;
			for(int j=0; j<Particle[i].Dim; j++)
				Particle[i].PosBest[j] = Particle[i].Pos[j];
		}
	//设置新的最优个体
	GBestIndex = 0;
	for(i=0; i<PNum; i++)
		if(Particle[i].FitBest>=Particle[GBestIndex].FitBest && i!=GBestIndex) 
			GBestIndex = i;
}

//运行群粒算法
CParticle& CParSwarm::Run(int n)
{
	Initialize();
	double *opt_p = new double[Particle[0].Dim];								//通讯用数组，最优点坐标
	double **opt_a = new double*[PNum];											//通讯用数组，所有点坐标
	for(int i=0; i<n; i++)
	{
		ParticleFly();
		if(Com)																		//通讯函数存在，完成通讯
		{
			for(int k=0; k<Particle[0].Dim; k++) 
				opt_p[k]=Particle[GBestIndex].PosBest[k];									//拷贝最优点坐标
			for(k=0; k<PNum; k++) 
				opt_a[k] = Particle[k].Pos;												//指向所有点坐标
			if(!Com(Particle[GBestIndex].FitBest,opt_p,opt_a,GBestIndex)) 
				break;
		}
	}
	delete []opt_p;
	delete []opt_a;
	return Particle[GBestIndex];
}
CParticle& CParSwarm::Run(double fit)
{
	double *opt_p = new double[Particle[0].Dim];									//通讯用数组，最优点坐标
	double **opt_a = new double*[PNum];												//通讯用数组，所有点坐标
	Initialize();
	do
	{
		ParticleFly();
		if(Com)																		//通讯函数存在，完成通讯
		{
			for(int k=0; k<Particle[0].Dim; k++) 
				opt_p[k]=Particle[GBestIndex].PosBest[k];								//拷贝最优点坐标
			for(k=0; k<PNum; k++)
				opt_a[k] = Particle[k].Pos;							//指向所有点坐标
			if( !Com( Particle[GBestIndex].FitBest,opt_p,opt_a,GBestIndex ) )
				break;
		}
	}while( Particle[GBestIndex].FitBest < fit );

	delete []opt_p;
	delete []opt_a;
	return Particle[GBestIndex];
}

//返回最佳个体
double CParSwarm::GetBest(double *r)
{
	for(int i=0; i<Particle[GBestIndex].Dim; i++)
		r[i] = Particle[GBestIndex].PosBest[i];
	return 
		Particle[GBestIndex].FitBest;
}