pso.cpp

蚁群算法解决车辆最优路径问题

// Pso.cpp: implementation of the Pso class.
//
//////////////////////////////////////////////////////////////////////
#include "time.h"
#include <stdlib.h>
#include "Pso.h"
#include "Particle.h"
#include <math.h>
#include <stdio.h>
#include <iostream.h>
#include <fstream.h>
//add dll;
//#include <StdAfx.h>

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

Pso::Pso()
{

}

Pso::~Pso()
{
	delete []particle;
	particle = NULL;
}

Pso::Pso(int dim, int num)
{
	pNum = num;
	particle = new Particle[pNum];
	for(int i=0; i<pNum; i++) 
	particle[i].SetDim(dim);

	gBestIndex = 0;
	bestIter = 0;
//	w = 1;
//	c1 = 2;
//	c2 = 2;
//	vDown = 1; 
//	vUp = 1;
//	xDown = 1; 
//	xUp = 1;
}

Pso::SetwMax(double ww)
{
	wMax = ww;
}

Pso::SetwMin(double ww)
{
	wMin = ww;
}

Pso::SetiterMax(int max)
{
	iterMax = max;
}

Pso::Setc1(double c)
{
	c1 = c;
}

Pso::Setc2(double c)
{
	c2 = c;
}

Pso::SetvDowm(double max)
{
	vDown = max;
}

Pso::SetvUp(double max)
{
	vUp = max;
}

Pso::SetxDown(int max)
{
	xDown = max;
}

Pso::SetxUp(int max)
{
	xUp = max;
}

extern double data[1][8];
extern int vehicleNum;
extern int pDim;

void Pso::Initialize()
{
	if(particle==NULL) 
	return;

	srand( (unsigned)time( NULL ) );
	for(int i=0; i<pNum; i++)
	{
		double *quantity;
		quantity = new double[vehicleNum];

        //初始化x,并检查是否满足约束;
		do 
		{
			for(int q=0; q<vehicleNum; q++ )
				quantity[q] = 0;

			for(int j=0; j<particle[i].pDim; j++)
			{
				int min = 1;
				int max = vehicleNum;
				particle[i].x[j] = ((int)rand()) % (max + 1- min) + min;
				int choice = int(particle[i].x[j]);
				switch(choice)
				{
					case 1: quantity[0] = quantity[0] + data[2][j];break;
					case 2: quantity[1] = quantity[1] + data[2][j];break;
				}
			}
		} while(quantity[0]>1||quantity[1]>1);
        			
		delete []quantity;
		quantity = NULL;

/*
start:	do 
		{	
			for(int q=0; q<vehicleNum; q++ )
				quantity[q] = 0;
			
			int total =0;
			int total0 = 0;
			int total1 = 0;

			for(int j=0; j<particle[i].pDim; j++)
			{
				int min = 1;
				int max = vehicleNum;
again:			particle[i].x[j] =((rand() % (int)(((max) + 1) - (min))) + (min));
				if(total>=2)
					goto start;//这里可以导致内存泄漏!!!
				int choice = int(particle[i].x[j]);
				switch(choice)
				{
					case 1: if(quantity[0]+data[1][j]>8)//改动2
							{
								total0 = total0 + 1;
								if(total0==1)
									total = total +1;		
						        goto again;
							}
							quantity[0] = quantity[0] + data[1][j];
							srand(rand());							
						    break;
					case 2: if(quantity[1]+data[1][j]>8)//改动3
							{
								total1 = total1 + 1;
								if(total1==1)
								    total = total +1;		
						        goto again;
							}
						    quantity[1] = quantity[1] + data[1][j];
						    srand(rand());							
						    break;

					default:break;	
				}
			}
      		
		}while(quantity[0]>8||quantity[1]>8);//该实验是一辆车8吨上限，改动1
*/    

/*		particle[i].x[0] = 1;
		particle[i].x[1] = 2;
		particle[i].x[2] = 2;
		particle[i].x[3] = 2;
		particle[i].x[4] = 2;
		particle[i].x[5] = 3;
		particle[i].x[6] = 3;
*/
		//初始化位置;
/*		for(int j=0; j<particle[i].pDim; j++)
		{
			int min = 1;
			int max = vehicleNum;
			particle[i].x[j] = ((int)rand()) % (max + 1- min) + min;
		}
*/
		//初始化速度;
		for(int j=0; j<particle[i].pDim; j++)
		{
			particle[i].xBest[j] = particle[i].x[j];
			int min = -(vehicleNum-1);
			int max = vehicleNum-1;
			particle[i].v[j] =((rand() % (int)(((max) + 1) - (min))) + (min));
		}

		Particle& p=particle[i];
		particle[i].fitness = GetFit_all(p);//particle[i]); //计算该微粒适合度
		particle[i].fitnessBest = particle[i].fitness; //设最优适合度初值

		//subResultBest;
		for(int total_num=0; total_num<vehicleNum*pDim; total_num++)
		     particle[i].subResultBest[total_num] = particle[i].subResult[total_num];

		if(particle[i].fitness < particle[gBestIndex].fitness) 
		gBestIndex = i;//查找群体最优微粒

	}
}

void Pso::CalFit_all()
{
    if(particle==NULL) 
		return;
    
	//计算每个粒子的fitness
    for(int i=0; i<pNum; i++)
		particle[i].fitness = GetFit_all(particle[i]);
}

double Pso::GetBest(double *r)
{
	//出错的是i的问题,总之注意i,j等的用法,最好不用;
	for(int particle_number=0; particle_number<particle->pDim; particle_number++)
		r[particle_number] = particle[gBestIndex].xBest[particle_number];//方便放结果;
	return particle[gBestIndex].fitnessBest;
}

extern int pDim;
Pso::GetSubResult(double *r)
{
	for(int i=0; i<vehicleNum*pDim; i++)
		r[i] = particle[gBestIndex].subResultBest[i];
}

void Pso::ParticleFly()
{
	int i,j;
	if(particle==NULL)
		return;
	
	//整个群体飞向新的位置
	for(i=0; i<pNum; i++)
	{
		//修改w
		w = wMax - ((wMax-wMin)/iterMax)*iter;
		//修改速度
		for(j=0; j<particle[i].pDim; j++)
		particle[i].v[j] = w*particle[i].v[j]+
						   	rand()/(double)RAND_MAX*c1*(particle[i].xBest[j]-particle[i].x[j])+
							rand()/(double)RAND_MAX*c2*(particle[gBestIndex].xBest[j]-particle[i].x[j]);

		//检查速度最大值,这里有问题;
		for(j=0; j<particle[i].pDim; j++) 
		{
			if(particle[i].v[j]>vUp) 
				particle[i].v[j] = vUp;
			if(particle[i].v[j]<vDown) 
				particle[i].v[j] = vDown;
		}

		for(j=0; j<particle[i].pDim; j++)
		{
			particle[i].x[j] += particle[i].v[j];//修改坐标
			particle[i].x[j] = ceil(particle[i].x[j]);//取整
			if(particle[i].x[j]>xUp) 
				particle[i].x[j] = xUp;//保护
			if(particle[i].x[j]<xDown) 
				particle[i].x[j]=xDown;
		}
	}
	
	//计算各微粒适合度
	CalFit_all();
	
	//设置新的个体最好位置
	for(i=0; i<pNum; i++)
	if(particle[i].fitness < particle[i].fitnessBest)
	{
		particle[i].fitnessBest = particle[i].fitness;
		for(int j=0; j<particle[i].pDim; j++)
		    particle[i].xBest[j] = particle[i].x[j];
        
		//设置subResultBest;
		for(j=0; j<vehicleNum*pDim; j++)
		     particle[i].subResultBest[j] = particle[i].subResult[j];

	}
	
	//设置新的最优个体
	for(i=0; i<pNum; i++)
	{
		if(particle[i].fitnessBest < particle[gBestIndex].fitnessBest && i!=gBestIndex) 
		{
			gBestIndex = i;
			bestIter = iter;
		}
	}
	
}

Pso::Run(int runNum)
{
	Initialize();

	for(int run_num=0; run_num<runNum; run_num++)
	{
		iter = run_num + 1;
		ParticleFly();
		
		//每次迭代的结果显示;
		double *Result;
		Result = new double[particle->pDim];

		double *sub_Result_Best;
		sub_Result_Best = new double [vehicleNum*pDim];
		GetSubResult(sub_Result_Best);

		cout << GetBest(Result) << endl;
		for(int i=0; i<particle->pDim; i++)
			cout << Result[i] <<" ";
		cout <<endl;
    
		//每次迭代的子结果显示;
		for (int j=0; j<particle->pDim*vehicleNum; j++) 
		{
			cout << particle[gBestIndex].subResultBest[j] << " ";
			if((j+1)%(particle->pDim)==0)
				cout <<endl;
		}
        cout <<endl;

		//file
/*		ofstream myf("f:\\ally.txt",ios::ate);
	    myf << iter << "  "<<GetBest(Result) << endl
			<< Result[0]<<" "<<Result[1]<<" "<<Result[2]<<" "<<Result[3]<<" "<<Result[4]<<" "<<Result[5]<<" "<<Result[6]<<" "<<Result[7]<<endl
			<< sub_Result_Best[0]<<" "<<sub_Result_Best[1]<<" "<<sub_Result_Best[2]<<" "<<sub_Result_Best[3]<<" "<<sub_Result_Best[4]<<" "<<sub_Result_Best[5]<<" "<<sub_Result_Best[6]<<" "<<sub_Result_Best[7]<<endl
			<< sub_Result_Best[8]<<" "<<sub_Result_Best[9]<<" "<<sub_Result_Best[10]<<" "<<sub_Result_Best[11]<<" "<<sub_Result_Best[12]<<" "<<sub_Result_Best[13]<<" "<<sub_Result_Best[14]<<" "<<sub_Result_Best[15]<<endl
			<< sub_Result_Best[16]<<" "<<sub_Result_Best[17]<<" "<<sub_Result_Best[18]<<" "<<sub_Result_Best[19]<<" "<<sub_Result_Best[20]<<" "<<sub_Result_Best[21]<<" "<<sub_Result_Best[22]<<" "<<sub_Result_Best[23]<<endl
			<<endl;
*/
		delete []Result;
		Result = NULL;
	}


}