guotao.cpp

郭涛算法 熟悉的朋友应该知道 演化计算相关

// GuoTao.cpp: implementation of the CGuoTao class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "GuoTao.h"

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

CGuoTao::CGuoTao():m_PopSize(60),m_Precision(1e-10)
                  ,m_MaxGeneration(5800),m_ParentNum(8)  //杂交个体数目
{
	m_VaryNum = CIndividual::VaryNum;
	m_ConFuncNum = CIndividual::ConFuncNum;
	m_LowerBound=new double[m_VaryNum];
	m_UpperBound=new double[m_VaryNum];
	m_Population=new CIndividual[m_PopSize];
	m_MateParam = new double[m_ParentNum];

	m_EvalutionNum = 0;

	m_MaxOrMin = -1;
}

CGuoTao::~CGuoTao()
{
	delete []m_LowerBound;
	delete []m_UpperBound;
	delete []m_Population;
	delete []m_MateParam;
}

//-----------------random number generator-----------------
double CGuoTao::RandDoubleValue(double low,double high)
{
	double  val;
	val=((double)(rand()%1000)/1000.0)*(high-low)+low;
	
	return val;
}

int CGuoTao::RandIntValue(int Nmem)
{
	int newval;
	newval=(int)(((rand()%1000)/1000.0)*Nmem);
	
	return newval;
}

void CGuoTao::InitPopulation()
{
	int i,j;
	double temp;				//临时保存产生的随机实数

	//---------------------自变量约束---------------------
for (i=0;i<m_VaryNum;i++)  //变量个数
{//可以改为从文件读取数据
	m_LowerBound[i]=0;   //各变量下界值
	m_UpperBound[i]=10;//个体中变量的取值范围
}
	//---------------------自变量约束---------------------

	srand(GetTickCount());		//包含在windows.h中

	temp = 0.0;
	for(i=0;i<m_VaryNum;i++)
	{
		for (j=0;j<m_PopSize;j++)
		{
			temp = RandDoubleValue(m_LowerBound[i],m_UpperBound[i]);
			m_Population[j].XVary[i] = temp;	 //XVary[i]:保存个体自变量值
			m_Population[j].Dev[i]=3.0;
		}
	}
}

void CGuoTao::CalculateFitness(CIndividual &Individual)
{
	double *x;	//临时存储函数中的变量

	x=new double[m_VaryNum];

	for (int i=0;i<m_VaryNum;i++)
	{
		x[i]=0.0;
	}

	for (i=0;i<m_VaryNum;i++)
	{
		x[i]=Individual.XVary[i];
	}

	double temp1 = 0.0;
	double temp2 = 0.0;
	//------------------计算目标函数适应度值------------------
Individual.value = 0.0;
temp1 = 0.0;
temp2 = 1.0;
double temp3 = 0.0;
for (i=0;i<m_VaryNum;i++)
{
	 temp1 += pow(cos(x[i]),4);
	 temp2 *= pow(cos(x[i]),2);
	 temp3 += (i+1)*x[i]*x[i];
}
Individual.value = (temp1-2*temp2)/sqrt(temp3);
	//------------------计算目标函数适应度值------------------

	Individual.fitness = m_MaxOrMin * Individual.value;	//value to fitness
	
	m_EvalutionNum++;

	delete []x;
}

void CGuoTao::CalculateConFitness(CIndividual &Individual)
{
	double *x;	//临时存储函数中的变量

	x=new double[m_VaryNum];

	for (int i=0;i<m_VaryNum;i++)
	{
		x[i]=0.0;
	}

	for (i=0;i<m_VaryNum;i++)
	{
		x[i]=Individual.XVary[i];
	}
	
	double temp1 = 0.0;
	double temp2 = 0.0;
	//------------------计算约束函数适应度值------------------
//Individual.con[0] = 100-pow(x[0]-5,2)-pow(x[1]-5,2);
temp1 = 1.0;
temp2 = 0.0;
for (i=0;i<m_VaryNum;i++)
{
	 temp1 *= x[i];
	 temp2 += x[i];
}
Individual.con[0] = 0.75-temp1;
Individual.con[1] = temp1-0.75*m_VaryNum;
	//------------------计算约束函数适应度值------------------

	Individual.conFitness = 0.0;
	for (i=0;i<m_ConFuncNum;i++)
	{
		if (Individual.con[i] <= 0.0)
		{
			Individual.con[i] = 0.0;
		}
		Individual.conFitness += Individual.con[i];
	}

	//判断个体是否在可行区域
	if (Individual.conFitness > 0)
	{
		Individual.feasible = 0;
	}
	else
		Individual.feasible = 1;

	delete []x;
}

void CGuoTao::CalculatePopFitness()
{
	for (int i=0;i<m_PopSize;i++)
	{
		CalculateFitness(m_Population[i]);
		if( m_ConFuncNum != 0)
		{
			CalculateConFitness(m_Population[i]);
		}
	}
}

bool CGuoTao::Better(CIndividual &Individual1,CIndividual &Individual2)
{
	if (Individual1.conFitness < Individual2.conFitness)
	{
		return true;
	}
	else if (Individual1.conFitness > Individual2.conFitness)
	{
		return false;
	}
	else if((Individual1.conFitness == Individual2.conFitness)
		&& (Individual1.fitness < Individual2.fitness))
	{
		return true;
	}
	else
	{
		return false;
	}
}

void CGuoTao::FindBestAndWorst()
{
	int i;

	//找出最好个体
	m_BestIndex=0;
	for (i=1;i<m_PopSize;i++)
	{
		if(Better(m_Population[i],m_Population[m_BestIndex]))
		{
			m_BestIndex=i;
		}
	}
	m_BestIndividual=m_Population[m_BestIndex];

	//找出最坏个体
	m_WorstIndex=0;
	for (i=1;i<m_PopSize;i++)
	{
		if(Better(m_Population[m_WorstIndex],m_Population[i]))
		{
			m_WorstIndex=i;
		}
	}
	m_WorstIndividual=m_Population[m_WorstIndex];
}

void CGuoTao::FindBestFitnessIndv()
{
	int i;
	int index = 0;

	for (i=0;i<m_PopSize;i++)
	{
		if (m_Population[i].fitness < m_Population[index].fitness)
		{
			index = i;
		}
	}
	m_IndvFitness = m_Population[index];
}

void CGuoTao::FindBestConFitnessIndv()
{
	int i;
	int index = 0;

	for (i=0;i<m_PopSize;i++)
	{
		if (m_Population[i].conFitness < m_Population[index].conFitness)
		{
			index = i;
		}
	}
	m_IndvConfitness = m_Population[index];
}

void CGuoTao::Cteate_a()
{
	double sumA,tmpMin,tmpMax,MaxA,MinA;
	
	MinA=-0.5;
    MaxA=1.5;
    for (int i=0;i<m_ParentNum;i++)
	{
		m_MateParam[i] = 0.0;
	}

	sumA=0.0;
	for(i=0;i<=m_ParentNum-2;i++)
	{
		double mt1;
		mt1=m_ParentNum-i+1;
		tmpMin=1-sumA-MaxA*mt1;
		tmpMax=1-sumA-MinA*mt1;
		if(tmpMin<MinA)
			tmpMin=MinA;
		if(tmpMax>MaxA)
			tmpMax=MaxA;
		 m_MateParam[i]=RandDoubleValue(tmpMin,tmpMax);
		 sumA=sumA+m_MateParam[i];
	}
	m_MateParam[m_ParentNum-1]=1-sumA;
}

void CGuoTao::GuoTao()
{
	int i,j;
	int *MatePool;
    double low,up;
	
	MatePool = new int[m_ParentNum];

    for(i=0;i<m_ParentNum;i++)
	{
		MatePool[i]=i;
	}

	//generate the mate pool
	i =0;
	while ( i < m_ParentNum )
	{
		MatePool[i] = RandIntValue(m_PopSize-i);
		j = 0;
		while ( j < i )
		{
			while ( MatePool[i] == MatePool[j])
			{
				MatePool[i] = RandIntValue(m_PopSize-i);
			}
			j++;
		}
		i++;
	}
	MatePool[m_ParentNum-1] = m_BestIndex;

	//generate the mate parameter
	Cteate_a();

	//generate the offspring using the multi-parent crossover
	for(i=0;i<m_VaryNum;i++)
	{
		//Cteate_a();
		m_tmpIndividual.XVary[i] = 0.0;
		for(j=0;j<m_ParentNum;j++)
		{
			m_tmpIndividual.XVary[i] += m_MateParam[j]*m_Population[MatePool[j]].XVary[i];
		}
		
	    low = m_LowerBound[i];
		up  = m_UpperBound[i];

		if (m_tmpIndividual.XVary[i] < low)
		{
			m_tmpIndividual.XVary[i] = low+RandDoubleValue(0,1)*(up-low);
		}
		if (m_tmpIndividual.XVary[i] > up)
		{
			m_tmpIndividual.XVary[i] = up-RandDoubleValue(0,1)*(up-low);
		}
	}

	//calculate the fitness of the offspring
	CalculateFitness(m_tmpIndividual);
	if (m_ConFuncNum != 0)
	{
		CalculateConFitness(m_tmpIndividual);
	}
}

void CGuoTao::Display(int generation)
{
	if(generation%1==0)  //while(generation<m_MaxGeneration)?
	{
		//当前最好个体输出到屏幕
		cout<<setw(5)<<generation;
		cout<<setw(8)<<m_EvalutionNum;

		//显示约束函数的值
		if (m_ConFuncNum != 0)
		{
			cout<<setw(15)<<m_BestIndividual.conFitness;
 
		}
		cout.precision(10);					//设置输出精度
		cout<<setw(20)<<m_BestIndividual.value<<endl;
	}
}

void CGuoTao::Report(int generation,ofstream &ResultFile)
{
	if(generation%1==0)
	{
		//当前最好个体输出到文件
		ResultFile<<setw(5)<<generation;
		ResultFile<<setw(8)<<m_EvalutionNum;
		ResultFile.precision(10);			//设置输出精度
		ResultFile<<setw(20)<<m_BestIndividual.value<<endl;
	}
}

void CGuoTao::RunGT()
{
	ofstream ResultFile("result.txt");
	ResultFile<<setw(5)<<"Gene";
	ResultFile<<setw(8)<<"Num";
	ResultFile.precision(10);
	ResultFile<<setw(20)<<"Value"<<endl;

	srand((unsigned)time(0));

	InitPopulation();
	CalculatePopFitness();
	FindBestAndWorst();

	int generation = 0;		//当前演化代数
	while ((generation < m_MaxGeneration) && 
		(fabs(m_BestIndividual.fitness - m_WorstIndividual.fitness) > m_Precision))
	{
		generation++;
		if (generation > m_MaxGeneration)
		{
			break;
		}
		if (fabs(m_BestIndividual.fitness - m_WorstIndividual.fitness) < m_Precision)
		{
			break;
		}

		for (int i=0;i<m_PopSize;i++)  //popsize:群体大小
		{
			GuoTao();

			if (Better(m_tmpIndividual,m_WorstIndividual))
			{
				m_Population[m_WorstIndex] = m_tmpIndividual;
			}
			if (Better(m_tmpIndividual,m_BestIndividual))
			{
				m_Population[m_BestIndex] = m_tmpIndividual;
			}

			FindBestAndWorst();
		}
	
//		GuoTao();
//
//		if (Better(m_tmpIndividual,m_WorstIndividual))
//		{
//			m_Population[m_WorstIndex] = m_tmpIndividual;
//		}
//		if (Better(m_tmpIndividual,m_BestIndividual))
//		{
//			m_Population[m_BestIndex] = m_tmpIndividual;
//		}
//
//		FindBestAndWorst();

		Display(generation);
		Report(generation,ResultFile);
	}
		
	ResultFile.close();
}