pso.cpp

粒子群算法

#include <iostream>
using namespace std;
#include<fstream>
#include<cstdlib>
#include <cmath>
#include<ctime>

#include "pso.h"

particle::particle()
{
    position = NULL;
	speed = NULL;
	dim = 0;
	maxSpeed = 0.0;
	minPositionBoundary = 0.0;
	maxPositionBoundary = 0.0;
	fit = 0.0;
	localBestFit = 0.0;
	localBestPosition = NULL;
}

particle::~particle()
{
   if(!position)
	   delete position;
   if(!speed)
	   delete speed;
   if(!localBestPosition)
	   delete localBestPosition;
}

void particle::setPositionBoubdary(double min,double max)
{
   minPositionBoundary = min;
   maxPositionBoundary = max;
}

void particle::setDim(int m)
{
   dim = m;
}

void particle::setMaxSpeed(double mp)
{
    maxSpeed = mp;
}
void particle::getFit(void)
{
   fit = - 5 * position[2] * position[2] + 3 * position[2]+ 5;// sin(position[2]);
}

bool particle::isBeyondMaxSpeed(double sp)
{
	return sp > maxSpeed ? true : false;
}

bool particle::isBeyondMaxPositionBoundary(double mp)
{
	return mp > maxPositionBoundary ? true : false;
}

bool particle::isUnderMinPositionBoundary(double mp)
{
	return mp < minPositionBoundary ? true : false;
}

void particle::setlocalBestPosition(void)
{
	if(fit > localBestFit)
	{
		localBestFit = fit;
        for(int i = 0;i < dim;i++)
		   localBestPosition[i] = position[i];
	}
}
/////////////////////////////////////////////////////

pso::pso()
{
    pa = NULL;
	parNum = 0;
	w = 0.0;
	selfInertia = 0.0;
	targetInertia = 0.0;
	gobalBestFit = 0.0;
	gobalBestPosition = NULL;
}

pso::~pso()
{
    if(!pa)
		delete pa;
	if(!gobalBestPosition)
		delete gobalBestPosition;
}
void pso::setParNum(int pn)
{
    parNum = pn;
}
void pso::setW(double a)
{
    w = a;
}

void pso::setSelfInertia(double si)
{
	selfInertia = si;
}

void pso::setTargetInertia(double ti)
{
    targetInertia = ti;
}

void pso::initPso(void)
{

	setParNum(100);
    setW(1.0);
    setSelfInertia(2.0);
    setTargetInertia(2.0);
    
    pa = new particle[parNum];
    gobalBestPosition = new double[pa[0].dim];

	static bool  flag = true;
	if(flag)
	{
		srand((unsigned int)time(NULL));
		flag = false;
	}
	
    for(int i = 0;i < parNum;i++)
	{
		pa[i].setDim(3);
		pa[i].setMaxSpeed(0.2);
		pa[i].setPositionBoubdary(-20,20);
		pa[i].position =  new double[pa[i].dim];
		pa[i].localBestPosition = new double[pa[i].dim];
		pa[i].speed = new double[pa[i].dim];
		for(int j = 0;j < pa[i].dim;j++)
		{
			pa[i].localBestPosition[j] = pa[i].position[j] = 
				pa[i].minPositionBoundary + double(rand() % RAND_MAX) / double(RAND_MAX) 
				*  (pa[i].maxPositionBoundary - pa[i].minPositionBoundary);
			pa[i].speed[j] = 0.0 - pa[i].maxSpeed + 
				    double(rand() % RAND_MAX) / double(RAND_MAX) * 2 * pa[i].maxSpeed;
		}
		
		pa[i].getFit();
		pa[i].localBestFit = pa[i].fit;
	}
	gobalBestFit = pa[0].localBestFit;
	for(int i = 0;i < parNum;i++)
	{
		if( pa[i].localBestFit > gobalBestFit)
		{
			gobalBestFit = pa[i].localBestFit;
			for(int j = 0;j < pa[i].dim;j++)
				gobalBestPosition[j] = pa[i].localBestPosition[j]; 
		}
		
	}
}


void pso::calculatePso(void)
{
	
	initPso();
	for(int k = 0;k < 500;k++)
	{
		for(int i = 0;i < parNum;i++)
		{
			for(int j = 0;j < pa[i].dim;j++)
			{
				pa[i].speed[j] = w * pa[i].speed[j] + 
					rand()/(double)RAND_MAX * selfInertia  * (pa[i].localBestPosition[j] - pa[i].position[j]) +
					rand()/(double)RAND_MAX * targetInertia * (gobalBestPosition[j] - pa[i].position[j]);
                
				if(pa[i].speed[j] > pa[i].maxSpeed)
					pa[i].speed[j] = pa[i].maxSpeed;
				if(pa[i].speed[j] < 0.0 - pa[i].maxSpeed)
					pa[i].speed[j] = 0.0 - pa[i].maxSpeed;

				pa[i].position[j] = pa[i].position[j] + pa[i].speed[j];

				if(pa[i].position[j] > pa[i].maxPositionBoundary)
					pa[i].position[j] = pa[i].maxPositionBoundary;
				if( pa[i].position[j] < pa[i].minPositionBoundary)
					pa[i].position[j] = pa[i].minPositionBoundary;
				
			}
			pa[i].getFit();
			pa[i].setlocalBestPosition();
			if(pa[i].localBestFit > gobalBestFit)
			{
				gobalBestFit = pa[i].localBestFit;
				for(int j = 0;j < pa[i].dim;j++)
				{
					gobalBestPosition[j] = pa[i].localBestPosition[j];
				}
			}
		}
		output();
		w = 0.9 - k / double(500) * 0.5;
		
	}
}

void pso::output(void)
{
	cout<<"w:"<<w<<"  ";
	cout<<"x:"<<gobalBestPosition[0]<<"  "
		<<"y:"<<gobalBestPosition[1]<<"  "
		<<"z:"<<gobalBestPosition[2]<<"  ";
	cout<<"fit:"<<gobalBestFit<<endl;
	cout<<"------------------------------------------------------"<<endl;
}