pso.cpp

标准pso算法

//class' method implement

#include <cstdlib>
#include <ctime>
#include <cmath>
#include <iostream.h>
#include "pso.h"

//粒子类的方法实现 
PARTICLE::PARTICLE()                           //空构造函数
{
  X = 0; 
  V = 0;
  pbest = 0; 
  Dim = 0;
}

PARTICLE::PARTICLE(int n)                      //维数为参数的构造函数
{
	Dim = n;
	X = new double[Dim];
	V = new double[Dim];
	pbest = new double[Dim];
}

PARTICLE::~PARTICLE()
{
   if(Dim)
     {
		delete []X;
		delete []V;
		delete []pbest;
	 }
}
                                              
void PARTICLE::SetDim(int d)
{
	if(X)                                     //若原先不为空，先释放空间 
	  delete []X;
	if(V) 
	  delete []V;
	if(pbest) 
	  delete []pbest;
	  
	Dim = d;
	X = new double[Dim];
	V = new double[Dim];
	pbest = new double[Dim];
}

//PSO类的方法实现 
PSO::PSO()
{
	Particle = 0;
	PNum = 0;
	GBestIndex = 0;
    Xmax = 0;
	W = 0;
	C1 = 0;
	C2 = 0;
	
}

PSO::PSO(int dim, int m_num)                 //m_num为种群规模 
{
	Particle = new PARTICLE[m_num];
	
	for(int i = 0; i < m_num; i++) 
	   Particle[i].SetDim(dim);
	
	PNum = m_num;
	GBestIndex = 0;
    Xmax = 0;
	Vmax = 0;
	W = 0.729;
	C1 = 1.494;
	C2 = 1.494;
}
                                               //析构函数
PSO::~PSO()
{
   if(Particle) 
	  delete []Particle;
}

void PSO::Initialize()
{
  if(!Particle) 
	   return;
  static int k = (int)time(NULL);	   
  srand((unsigned)time(NULL)+ k++ );
  GBestIndex = 0;	   
	   
  for(int i = 0; i< PNum; i++)
   {
     for(int j = 0; j < Particle[i].Dim; j++)
      {
		Particle[i].X[j] = rand()/(double)RAND_MAX*Xmax*2 - Xmax;   
		Particle[i].pbest[j] = Particle[i].X[j];
		
		Particle[i].V[j] = rand()/(double)RAND_MAX*Vmax*2 - Vmax;     
      }
      
		Particle[i].Fit = GetFit(Particle[i]);                               
		Particle[i].BestFit = Particle[i].Fit;  
		                                 
		if(Particle[i].Fit>Particle[GBestIndex].Fit) 
		  GBestIndex = i;	  
    }  
}

void PSO::ParticleFly()
{	
    static long int k = ((unsigned)time(NULL));	
	srand((unsigned)time(NULL) + k++);
	 
	for(int i = 0; i < PNum; i++)
	{
	   for(int j = 0; j < Particle[i].Dim; j++)
	   {                                              
			Particle[i].V[j] = W*Particle[i].V[j] +    
				(rand()/(double)RAND_MAX)*C1*(Particle[i].pbest[j] - Particle[i].X[j])+
				(rand()/(double)RAND_MAX)*C2*(Particle[GBestIndex].pbest[j] - Particle[i].X[j]);
				
		    if(Particle[i].V[j] > Vmax) 
		      Particle[i].V[j] = Vmax*rand()/RAND_MAX;
            if(Particle[i].V[j] < -Vmax) 
              Particle[i].V[j] = -Vmax*rand()/RAND_MAX;
   
	       Particle[i].X[j] += Particle[i].V[j];  
		              
		   if(Particle[i].X[j] > Xmax) 
              Particle[i].X[j] = Xmax;                      
    	   if(Particle[i].X[j] < -Xmax) 
              Particle[i].X[j] = -Xmax;
    	}
    }
			  		 
   for(int i = 0; i < PNum; i++)
	 {
 	   
	   Particle[i].Fit = GetFit(Particle[i]);                                   //更新粒子适应度 
	  
       if(Particle[i].Fit < Particle[i].BestFit)
	   {
		Particle[i].BestFit = Particle[i].Fit;
		
		for(int j = 0; j < Particle[i].Dim; j++)
		  
		   Particle[i].pbest[j] = Particle[i].X[j];
	   }
    }  
      
    GBestIndex = 0; 
	for(int i = 0; i < PNum; i++)                                               //更新global最优个体 
		if(Particle[i].BestFit < Particle[GBestIndex].BestFit) 
		    GBestIndex = i;
		    
}

//运行群粒算法
PARTICLE& PSO::Run(int n)
{
  Initialize();
	          	
  for(int i = 0; i < n; i++)
	 ParticleFly();
     
    return Particle[GBestIndex];
}

double PSO::GetFit(PARTICLE &p)                                                 
{
   	double f1 = 0.0;
	
 /*	for(int i = 0; i < p.Dim; ++i)
       f1 += p.X[i]*p.X[i];
     */  
     
  /* */for (int i = 0; i < p.Dim; ++i)            //Rastrigrin
	 f1 += p.X[i]*p.X[i] - 10*cos(2*3.1415926*p.X[i]) + 10;  
	     
   return f1;
}