1.cpp

自己编写的粒子群优化算法

#include<iostream>
#include<ctime>
#include<vector>
#include<cmath>
using namespace std;


const int particle_num = 20;          // 粒子群的数目
const double c1 = 2;                // 学习因子1
const double c2 = 2;               // 学习因子2
int iteration = 2000;         // 迭代次数
double w1 = 1.0;              // 惯性系数
double Xup[] = {100,100};           // 坐标上限
double Xdown[]={-100,-100};         // 坐标下限
const int dim = 2;                      // 定义维数
double speedup[] = {40,40};          // 速度上限
double speeddown[]={-40,-40};        // 速度下限


typedef struct particle        // 定义粒子
{
	double fitness;          // 粒子的适应度
	double x[dim];            // 粒子的坐标数组
	double v[dim];           // 粒子的速度数组
}particle;

particle bird[particle_num];       // 定义种群
particle pbest[particle_num];      // 局部最优极值数组
int  globle_best;              // 保存全局最优的序号



// 计算适应度
void countfitness()
{
	double x,y,z,k,t;
	for(int i = 0; i < particle_num; i++)
	{
		 x = bird[i].x[0];
		 y = bird[i].x[1];
		 z = x*x+y*y;
		 t = sin(sqrt(z));
		 k = 1+0.001*z;
		 bird[i].fitness = (t*t-0.5)/(k*k);
	}
}

 // 寻找全局最优解，保存其序号
int globlebest()        
{
	double best = pbest[0].fitness;
	int index = 0;
	for(int i = 1; i < particle_num; i++)
	{
		if(pbest[i].fitness < best)
		{
			best = pbest[i].fitness;
			index = i;
		}
	}
	return index;
}

// 产生0-1之间的随即数
inline double randnum()          
{
	return 1.0*rand()/RAND_MAX;
}




void initparticle()             // 初始化种群
{	
	int i,j;
	for(i = 0; i < particle_num; i++)  // 初始化粒子坐标
	{
		for(j = 0; j < dim; j++)
			bird[i].x[j] = Xdown[j]+(Xup[j]-Xdown[j])*randnum();
	}
	
	for(i = 0; i < particle_num; i++) // 初始化粒子速度
	{
		for(j = 0; j < dim; j++)
			bird[i].v[j] = (randnum()*speedup[j])-speedup[j]/2;
	}

	countfitness();  // 计算适应度

	for(i = 0; i < particle_num; i++)  // 初始化局部最优
	{
		pbest[i].fitness = bird[i].fitness;
		for(j = 0; j < dim; j++)
		{
			pbest[i].x[j] = bird[i].x[j];
			pbest[i].v[j] = bird[i].v[j];
		}
	}
	globle_best = globlebest();  // 初始化全局最优
}


int main()
{
	srand((unsigned)time(NULL));
	initparticle();
	int i,j,k;
	for(i = 0; i < particle_num; i++)
		cout<<bird[i].fitness<<" "<<bird[i].x[0]<<" "<<bird[i].x[1]<<endl;
	cout<<"*************************"<<endl;
	while(iteration--)
	{
		for(i = 0; i < particle_num; i++)
		{
			for(j = 0; j < dim; j++)
			{
				if(iteration < 1500) // 加上这一句确实带来改观，能够进一步避免其陷入局部最优值
					w1 = 1.0;
				else
					w1 = 0.8;
				bird[i].v[j] = w1*(bird[i].v[j])+
					c1*randnum()*(pbest[i].x[j]-bird[i].x[j])+
					c2*randnum()*(pbest[globle_best].x[j]-bird[i].x[j]);
				
			}
			for(j = 0; j < dim; j++)
			{
				if(bird[i].v[j] > speedup[j]) bird[i].v[j] = speedup[j];
				if(bird[i].v[j] < speeddown[j]) bird[i].v[j] = speeddown[j]; 
			}
			for(j = 0; j < dim; j++)
			{
				bird[i].x[j] += bird[i].v[j];
				if(bird[i].x[j] > Xup[j]) bird[i].x[j] = Xup[j];
				if(bird[i].x[j] < Xdown[j]) bird[i].x[j] = Xdown[j];
			}

		}
		countfitness();
		// 更新局部极值
		for(j = 0; j < particle_num; j++)
		{
			if(bird[j].fitness < pbest[j].fitness)
			{
				pbest[j].fitness = bird[j].fitness;
				for(k = 0; k < dim; k++)
				{
					pbest[j].x[k] = bird[j].x[k];
					pbest[j].v[k] = bird[j].v[k];
				}
			}  
		}
		// 更新全局最优值
		globle_best = globlebest();
	}
	cout<<pbest[globle_best].fitness<<" "<<pbest[globle_best].x[0]<<" "
		<<pbest[globle_best].x[1]<<endl;
	return 0;

}