xx1.cpp

一个遗传算法的程序

{
	int i;
	for(i=0;i<N2;i++)
		Ind[1].TwowayMutate(Ind[0],Sigma);
	for(i=0;i<N3;i++)
		Ind[1].TwowayUniformMutate(Ind[0]);
	Ind[1].AllGeneMutate(Ind[0],Sigma);
}

void Swap(CIndividual *p1,CIndividual *p2)
{
 CIndividual temp;
 temp=*p1;
 *p1=*p2;
 *p2=temp;
 }

void CPopulation::Evaluate(void)
{
	int i;
	for(i=N1;i<PopSize;i++)
	{
		Ind[i].Limit();
		Ind[i].Evaluate();
	}
}


//初始化每个个体
void CPopulation::Initialize(void)
{
	int i;
	for(i=0;i<PopSize;i++)
	{
		Ind[i].Initialize();
	    Ind[i].RandInd();
	}
	PreBest=-10e+10;
	PopState=1;
	Sigma=Sigma0;
	Generation=NoEvolveGen=0;
	for(i=0;i<PopSize;i++)
	{
		Ind[i].Evaluate();
	}
	Sort();
	Generation++;
}

void CPopulation::Reproduce(void)
{
	if(StopFlag)return;
	switch(ESType)
	{
	case 0:
	case 1:
		Fresh();
		Evaluate();
		Sort();
		break;
	case 2:
		FreshNew();
		break;
	default:
		break;
	}
	Generation++;
	NoEvolveGen++;
	if(Ind[0].Fitness-PreBest>Accuracy*.5)//Sigma*0.001)
	{
		PreBest=Ind[0].Fitness;
		NoEvolveGen=0;
		return;
	}
	if(NoEvolveGen>TuneInterval)
		if(ESType&&Sigma>SigmaMin)
		{
			Sigma=Sigma*SigmaCoe;
			NoEvolveGen=0;
			return;
		}
	if(Generation>MaxGeneration||NoEvolveGen>MaxNoEvolveGen)
	{
		//PopState=0; //停止进化标志
		AddOptima(Ind[0]);
		Initialize();
		return;
	}
	if(fabs(Optima-Ind[0].Fitness)<Accuracy||Ind[0].Fitness>Optima)
	{
		AddOptima(Ind[0]);//PopState=0; //停止进化标志
		Initialize();
		return;
	}
}

int CPopulation::AddOptima(CIndividual &ind)
{
	int i;
	double dis;
	if(OptimaNum==0)goto labeladd;
	i=ind.FindNearestInd(&OptimArray[0],OptimaNum);
	dis=ind.IndDistance(OptimArray[i]);
	if(dis<Radius)
	{
		if(dis>100*CPopulation::SigmaMin)
		{
			CNiche niche(ind,OptimArray[i]);
			double largefit,smallfit;
			largefit=ind.Fitness>OptimArray[i].Fitness?ind.Fitness:OptimArray[i].Fitness;
			smallfit=ind.Fitness<OptimArray[i].Fitness?ind.Fitness:OptimArray[i].Fitness;
			niche.TwoWayEvolve(MaxNoEvolveGen);
			if(smallfit-niche.Ind[3].Fitness>100*CPopulation::Accuracy)
			{
				
				goto labeladd;
			}
		}//if(smallfit-niche.Ind[3].Fitness>...
		NoNewOptima++;
		if(NoNewOptima>=MaxNoNewOptima)StopFlag=1;
		return StopFlag;
	}
labeladd:
	OptimArray[OptimaNum]=ind;
	NoNewOptima=0;
	OptimaNum++;
	SortOptima();
	if(OptimaNum>=MaxOptimaNum)
	{
		StopFlag=1;
		return StopFlag;
	}
	return StopFlag;
}
/*		CString str;
				str.Format("1 %lf,%lf,%lf,%lf",ind.Fitness,OptimArray[i].Fitness,
				niche.Ind[0].Fitness,niche.Ind[3].Fitness);
				AfxMessageBox(str);if(niche.Ind[0].Fitness>largefit)
		{
			OptimArray[i]=niche.Ind[0];
			CString str;
		str.Format("2 %lf,%lf,%lf,%lf",ind.Fitness,OptimArray[i].Fitness,
			niche.Ind[0].Fitness,niche.Ind[3].Fitness);
		AfxMessageBox(str);
			//return StopFlag;
		}*/

int CIndividual::FindNearestInd(CIndividual ind[],int num)
{
	double dis,dismin=1e+10;	
	int i,nearesti=0;
	for(i=0;i<num;i++)
	{
		dis=IndDistance(ind[i]);
		if(dis>dismin)continue;
		nearesti=i;
		dismin=dis;
	}
	return nearesti;
}

void CPopulation::SortOptima(void)
{
	if(OptimaNum<2)return;
	int i,j,besti;
	double best;
	for(i=0;i<OptimaNum-1;i++)
	{
		best=OptimArray[i].Fitness;
		besti=i;
		for(j=i+1;j<OptimaNum;j++)
		{
			if(OptimArray[j].Fitness<best)continue;
			best=OptimArray[j].Fitness;
			besti=j;
		}
		Swap(&OptimArray[i],&OptimArray[besti]);
	}
}

CIndividual & CPopulation::GetBestInd(int num)
{
	if(num>=OptimaNum)num=OptimaNum-1;
	if(num<0)num=0;
	return OptimArray[num];
}

double CPopulation::GetOptima(int num)
{
	if(num>=OptimaNum)num=OptimaNum-1;
	if(num<0)num=0;
	return OptimArray[num].Fitness;
}


CNiche::CNiche(CIndividual &ind1,CIndividual &ind2)
{
	int i;
	for(i=0;i<VarNum;i++)
	{
		A[i]=ind1.Gene[i]<ind2.Gene[i]?ind1.Gene[i]:ind2.Gene[i];
		B[i]=ind1.Gene[i]>ind2.Gene[i]?ind1.Gene[i]:ind2.Gene[i];
	}
	if(ind1.Fitness>ind2.Fitness)
	{
		Ind[0]=ind1;
		Ind[3]=ind2;
	}
	else
	{
		Ind[0]=ind2;
		Ind[3]=ind1;
	}
}

void CNiche::TwoWayEvolve(long int maxgen)
{
	long int i;
	for(i=0;i<maxgen;i++)
	{
		Ind[1].UniformMutate(Ind[0],A,B);
		Ind[2].UniformMutate(Ind[3],A,B);
		Ind[1].Evaluate();
		Ind[2].Evaluate();
		Sort();
	}
}

void CNiche::Sort(void)
{
	int i,j,besti;
	double best;
	for(i=0;i<3;i++)  
	{
	   best=Ind[i].Fitness;
	   besti=i;
	   for(j=i+1;j<4;j++)
		{
		 if(Ind[j].Fitness<best)continue;
		 best=Ind[j].Fitness;
		 besti=j;
		 }
	   Swap(&Ind[i],&Ind[besti]);
	}
}


void Swap(double *x,double *y)
{
 double temp;
 temp=*x;
 *x=*y;
 *y=temp;
}

const double RandMax=RAND_MAX+1;
double Randval(double low,double high)
{
 double val,r1;
 r1=(double)(rand()+1)/RandMax;
 val=r1*(high-low)+low;
 return(val);
}
/*
double GaussX(double u,double sigma)
{
 double x1,x2,xx;
 x1=rand()/RAND_MAX;x2=rand()/RAND_MAX;
 xx=sqrt(-2*log(x1))*cos(2*Pi*x2);
 xx=u+sigma*xx;
 return xx;
}*/

double GaussX(double u,double sigma)
{
 double t,rndx1,r1,r2;
 static double rndx2;
 static int flag=1;
 if(flag)
 {
	 r1=(double)(rand()+1)/RandMax;
	 r2=(double)(rand()+1)/RandMax;
	 rndx1=sqrt(-2*log(r1));
	 t=2*Pi*r2;
	 rndx2=rndx1*sin(t);
	 flag=0;
	 return u+sigma*rndx1*cos(t);
 }
 else
 {
	 flag=1;
	 return u+sigma*rndx2;
 }
}




#include<stdio.h>
int GetGAPara(GAPARAMS &gaParams)
{
	FILE *fp;
	if((fp=fopen("Gadataw.txt","r"))==NULL)
	{
		gaParams.iMu=2;
		gaParams.iLumda=8;gaParams.iKapa=15;
		gaParams.iTuneInterval=1000;
		gaParams.iSaveType=0;
		gaParams.iResultInterval=1000;
		gaParams.lMaxGeneration=10000;
		gaParams.iFunSel=0;
		gaParams.iVarNum=2;
		gaParams.dLower=0.0;
		gaParams.dUpper=10.0;
		gaParams.dOptima=0.0;
		gaParams.dAccuracy=0.00001;
		gaParams.iESType=0;
		gaParams.lMonteCarloNum=10000;
		SaveGAPara(gaParams);
	}
	else
	{
		fscanf(fp,"%d %d %d\n",&gaParams.iMu,&gaParams.iLumda,&gaParams.iKapa);
		fscanf(fp,"%d %d\n",&gaParams.iTuneInterval,&gaParams.iSaveType);
		fscanf(fp,"%d %ld\n",&gaParams.iResultInterval,&gaParams.lMaxGeneration);
		fscanf(fp,"%d %d\n",&gaParams.iFunSel,&gaParams.iVarNum);
		fscanf(fp,"%lf %lf %lf %le\n",&gaParams.dLower,&gaParams.dUpper,
			&gaParams.dOptima,&gaParams.dAccuracy);
		fscanf(fp,"%d\n",&gaParams.iRepeatNumber);
		fscanf(fp,"%lf %le %lf\n",&gaParams.dSigma0,&gaParams.dMinSigma,&gaParams.dSigmaCoe);
		fscanf(fp,"%ld %ld\n",&gaParams.lMaxGeneration,&gaParams.lMaxNoEvolveGen);
		fscanf(fp,"%d %d %d %ld\n",&gaParams.iSubpopNum,&gaParams.iMaxOptimaNum,
			&gaParams.iNoNewNum,&gaParams.lMaxFunCall);
		fscanf(fp,"%lf\n",&gaParams.dSubpopRadius);
		fscanf(fp,"%d %d %d\n",&gaParams.iMuteType,&gaParams.iReproduceType,&gaParams.iESType);
		fscanf(fp,"%ld %d\n",&gaParams.lMonteCarloNum,&gaParams.bMonteCarloSave);
	}
	gaParams.lBreakPos=(long)1e10;
	fclose(fp);
	return 0;
}

int SaveGAPara(GAPARAMS &gaParams)
{
	FILE *fp;
	fp=fopen("Gadataw.txt","w");
	fprintf(fp,"%d %d %d\n",gaParams.iMu,gaParams.iLumda,gaParams.iKapa);
	fprintf(fp,"%d %d\n",gaParams.iTuneInterval,gaParams.iSaveType);
	fprintf(fp,"%d %ld\n",gaParams.iResultInterval,gaParams.lMaxGeneration);
	fprintf(fp,"%d %d\n",gaParams.iFunSel,gaParams.iVarNum);
	fprintf(fp,"%lf %lf %lf %le\n",gaParams.dLower,gaParams.dUpper,
			gaParams.dOptima,gaParams.dAccuracy);
	fprintf(fp,"%d\n",gaParams.iRepeatNumber);
	fprintf(fp,"%lf %le %lf\n",gaParams.dSigma0,gaParams.dMinSigma,gaParams.dSigmaCoe);
	fprintf(fp,"%ld %ld\n",gaParams.lMaxGeneration,gaParams.lMaxNoEvolveGen);
	fprintf(fp,"%d %d %d %ld\n",gaParams.iSubpopNum,gaParams.iMaxOptimaNum,
		gaParams.iNoNewNum,gaParams.lMaxFunCall);
	fprintf(fp,"%lf\n",gaParams.dSubpopRadius);
	fprintf(fp,"%d %d %d\n",gaParams.iMuteType,gaParams.iReproduceType,gaParams.iESType);
	fprintf(fp,"%ld %d\n",gaParams.lMonteCarloNum,gaParams.bMonteCarloSave);
	fclose(fp);
	return 0;
}

void StatisticProc(int n,double &aver,double aver2,double &std)
{
	if(n<=1){std=0.0;return;}
	aver=aver/n;
	aver2=aver2/n;
	std=sqrt(fabs(aver2-aver*aver));
//	std=sqrt((aver2-n*aver*aver)/(n-1));
}


UINT MonteCarloCal(LPVOID pParam)
{
	extern CPopulation *g_pPop;
	if(g_pPop==NULL)return 0;
	GAPARAMS *pGAParam=(GAPARAMS*)pParam;
	long  num=pGAParam->lMonteCarloNum;
	int mutetemp=CIndividual::MuteType;
	CIndividual id;
	CIndividual &rid=g_pPop->Ind[0];
	double fit,fit0=rid.Fitness;
	double s0,soe,smin;
	s0=CPopulation::Sigma0;
	soe=CPopulation::SigmaCoe;
	smin=CPopulation::SigmaMin*soe;
	long i,ENum[4];
	double fitx[4],av[4];//CES单基因、全基因，改进ES单基因、全基因
	MCRESULT res;
	res.pd=fitx;res.pl=ENum;res.pav=av;res.Sigma=s0;
	while(s0>smin)
	{	
		for(i=0;i<4;i++){ENum[i]=0;fitx[i]=0;av[i]=0;}
		CIndividual::MuteType=0;
		for(i=0;i<num;i++)  //改进ES单基因
		{
			id.GaussMutate(rid,s0);
			fit=id.Evaluate();
			if(fit>fit0){ENum[2]++;fitx[2]+=fit-fit0;}
		}
		for(i=0;i<num;i++)//CES单基因
		{
			id.CESGaussMutate(rid);
			fit=id.Evaluate();
			if(fit>fit0){ENum[0]++;fitx[0]+=fit-fit0;}
		}
		CIndividual::MuteType=1;
		for(i=0;i<num;i++)  //改进ES全基因
		{
			id.GaussMutate(rid,s0);
			fit=id.Evaluate();
			if(fit>fit0){ENum[3]++;fitx[3]+=fit-fit0;}
		}
		for(i=0;i<num;i++)//CES全基因
		{
			id.CESGaussMutate(rid);
			fit=id.Evaluate();
			if(fit>fit0){ENum[1]++;fitx[1]+=fit-fit0;}
		}
		if(ENum[0]>0)av[0]=fitx[0]/ENum[0];
		if(ENum[1]>0)av[1]=fitx[1]/ENum[1];
		if(ENum[2]>0)av[2]=fitx[2]/ENum[2];
		if(ENum[3]>0)av[3]=fitx[3]/ENum[3];
		pGAParam->bResultNotProcessed=TRUE;
		::PostMessage(pGAParam->hWnd,WM_MCRESULT,(WPARAM)&res,0);
		while(pGAParam->bResultNotProcessed);
		if(pGAParam->iSSW!=3)break;
		s0*=soe;
		res.Sigma=s0;
	}
	CIndividual::MuteType=mutetemp;
	pGAParam->bResultNotProcessed=TRUE;
	::PostMessage(pGAParam->hWnd,WM_MCFINISHED,(WPARAM)&res,0);
	while(pGAParam->bResultNotProcessed);
	return 0;
}