mymain.cpp

一个遗传算法的程序

// MyMain.cpp: implementation of the MyMain class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "MyGA.h"
#include "MyMain.h"
#include <stdlib.h>
#include <math.h>
#include "XX1.h"
#include "Funs.h"
#include "MainFrm.h"
#include <sys/types.h> 
#include <sys/timeb.h>
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

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


void Report(FILE *fp);
char FirstFlag=1;
int VarNum;
extern GAPARAMS gGAParam;
extern CPopulation *g_pPop;
UINT GACalculate(LPVOID pParam)
{
	int i,popnum;
	int RepeatNum;
	popnum=gGAParam.iSubpopNum;
	CPopulation *pPop;
	VarNum=gGAParam.iVarNum;
	FirstFlag=1;
	CIndividual::SetRange(gGAParam.dUpper,gGAParam.dLower);
	long int lGeneration;
	bool ForcedStop=false;
	double OptimaNum=0,optima,funcall,tx;
	GARESULT gaResult;
	timeb mytime;
	CTime t0,t1;
	RepeatNum=0;
	gaResult.MeanFitness=gaResult.StdFitness=0;
	gaResult.MaxFitness=-1e10;gaResult.MinFitness=1e10;
	gaResult.MeanGeneration=gaResult.StdGeneration=0;
	gaResult.MaxGeneration=0;gaResult.MinGeneration=1e10;
	gaResult.MeanFunCall=gaResult.StdFunCall=0;
	gaResult.MaxFunCall=0;gaResult.MinFunCall=1e10;
	gaResult.MeanTime=gaResult.StdTime=0;
	gaResult.MaxTime=0;gaResult.MinTime=1e10;
	gaResult.any=0;
again:
	pPop=g_pPop;
	ftime(&mytime);
	srand(mytime.millitm);
	t0=CTime::GetCurrentTime();
	for(i=0;i<popnum;i++,pPop++)
	{
		pPop->Initialize();
	}
	CPopulation::InitializeAll();
	CIndividual::FuncallCount=0;
	lGeneration=0;
	do{
		pPop=g_pPop;
		for(i=0;i<popnum;i++,pPop++)
		{
			pPop->Reproduce();
		}
		if(lGeneration%gGAParam.iResultInterval==0)
		{
			gGAParam.bResultNotProcessed=TRUE;
			::PostMessage(gGAParam.hWnd,WM_GARESULT,
				 (WPARAM)lGeneration,(LPARAM)RepeatNum);
 	 		while(gGAParam.bResultNotProcessed);
		}
		if(lGeneration==gGAParam.lBreakPos)
		{
			gGAParam.bResultNotProcessed=TRUE;
			::PostMessage(gGAParam.hWnd,WM_GARESULT,
				 (WPARAM)lGeneration,(LPARAM)RepeatNum);
 	 		while(gGAParam.bResultNotProcessed);
			gGAParam.bResultNotProcessed=TRUE;
			::PostMessage(gGAParam.hWnd,WM_GAPAUSE,
				 (WPARAM)0,(LPARAM)0);
			while(gGAParam.bResultNotProcessed);
		}

		if(CPopulation::StopFlag)
		{
			CPopulation::SortOptima();
			gGAParam.bResultNotProcessed=TRUE;
			::PostMessage(gGAParam.hWnd,WM_GARESULT,
				 (WPARAM)lGeneration,(LPARAM)RepeatNum);
			while(gGAParam.bResultNotProcessed);
			RepeatNum++;
			OptimaNum+=CPopulation::OptimaNum;/**/
			break;
		}
		if(gGAParam.iSSW==0){ForcedStop=true;break;}
		lGeneration++;
	}while(1);
	optima=CPopulation::GetOptima(0);
	gaResult.MeanFitness+=optima;
	if(optima>10.0)gaResult.any++;
	gaResult.StdFitness+=optima*optima;
	gaResult.MaxFitness=gaResult.MaxFitness>optima?gaResult.MaxFitness:optima;
	gaResult.MinFitness=gaResult.MinFitness<optima?gaResult.MinFitness:optima;
	gaResult.MeanGeneration+=lGeneration;
	gaResult.StdGeneration+=lGeneration*lGeneration;
	gaResult.MaxGeneration=gaResult.MaxGeneration>lGeneration?
		gaResult.MaxGeneration:lGeneration;
	gaResult.MinGeneration=gaResult.MinGeneration<lGeneration?
		gaResult.MinGeneration:lGeneration;
	funcall=(double)CIndividual::FuncallCount;
	gaResult.MeanFunCall+=funcall;
	gaResult.StdFunCall+=funcall*funcall;
	gaResult.MaxFunCall=gaResult.MaxFunCall>funcall?
		gaResult.MaxFunCall:funcall;
	gaResult.MinFunCall=gaResult.MinFunCall<funcall?
		gaResult.MinFunCall:funcall;
	t1=CTime::GetCurrentTime();
	CTimeSpan tspan=t1-t0;
	tx=(double)tspan.GetTotalSeconds();
	gaResult.MeanTime+=tx;
	gaResult.StdTime+=tx*tx;
	gaResult.MaxTime=gaResult.MaxTime>tx?gaResult.MaxTime:tx;
	gaResult.MinTime=gaResult.MinTime<tx?gaResult.MinTime:tx;
	if(RepeatNum<gGAParam.iRepeatNumber&&!ForcedStop)goto again;
	gGAParam.iSSW=0;
	gGAParam.bResultNotProcessed=TRUE;
	gaResult.RepeatNum=RepeatNum;
	if(RepeatNum>0)
	{
		gaResult.AverageOptimaNum=OptimaNum/RepeatNum;
		StatisticProc(RepeatNum,gaResult.MeanFitness,
			gaResult.StdFitness,gaResult.StdFitness);
		StatisticProc(RepeatNum,gaResult.MeanGeneration,
			gaResult.StdGeneration,gaResult.StdGeneration);
		StatisticProc(RepeatNum,gaResult.MeanFunCall,
			gaResult.StdFunCall,gaResult.StdFunCall);
		StatisticProc(RepeatNum,gaResult.MeanTime,
			gaResult.StdTime,gaResult.StdTime);
	}
	::PostMessage(gGAParam.hWnd,WM_GAFINISHED,(WPARAM)RepeatNum,(LPARAM)&gaResult);
	while(gGAParam.bResultNotProcessed);
	return 0;
}

double CIndividual::Evaluate(void)
{
 double *px=Gene-1;// -1 is necessory因为在函数中使用x1,x2,...,xn
 FuncallCount++;
 switch(FunSel)
 {
  case 0:
	  Fitness=LeungF7(px);     //[0,3.14]
	  break;
  case 1:
	  Fitness=LeungF6(px);     //[-50,50]
	  break;
  case 2:
	  Fitness=SchafferF6(px);     //Schaffer F6
	  break;
  case 3:
	  Fitness=SchafferF7(px);     //Schaffer F7
	  break;
  case 4:
	  Fitness=ShubertFun(px);     //Shubert function
	  break;
  case 5:
	  Fitness=WxzFun1(px);        // Designed by wxz
	  break;
  case 6:
	  Fitness=BackStep(px);	   //Back Step Function1 modified by wxz
	  break;
  case 7:
	  Fitness=DeJongF2(px);       //De Jong F2 [-2.048,2.048]
	  break;
  case 8:
	  Fitness=DeJongF3(px);       //De Jong F3  [-5.12,5.12]
	  break;
  case 9:
	  Fitness=DeJongF4(px);       //De Jong F4  [-1.28,1.28]
	  break;
  case 10:
	  Fitness=MultiGoal1(px);     //Multi-goal [-2,2]
	  break;
  case 11:
	  Fitness=FoxHole(px);  //[-10,10]
	  break;
  case 12: //Ackley Function        [-20,30]
	  Fitness=AckleyFun(px);
	  break;
  case 13:  //Zhanglin1 [0,1]
	  Fitness=Zhanglin1(px);
	  break;
  case 14:  //Zhanglin2 [0,1]
	  Fitness=Zhanglin2(px);
	  break;
  case 15:  //Rosenbrock  [-5.12,5.12]
	  Fitness=Rosenbrock(px);
	  break;
  case 16:
	  Fitness=Rastrigin(px);
	  break;
  case 17:   //Gauss [-5.12,5.12]
	  Fitness=Gauss(px);
	  break;
  case 18:
	  Fitness=Wxz2(px); //by wxz, [-5.12,5.12]
	  break;
  case 19:
	  Fitness=Goldstein_Price(px);  //Goldstein_Price, [-2,2],Min=3
	  break;
  case 20:
	  Fitness=Branin_RCOS(px);  //Branin_RCOS,x1:[-5,10],x2:[0,15],Min=0.397887
	  break;
  case 21:
	  Fitness=BohachevskyF3(px);  // Bohachevsky F3[-50,50]
	  break;
  case 22:
	  Fitness=Colville(px);  //Coliville [-10,10],Min=0;
	  break;
  case 23:
	  Fitness=SolveEquation1(px);     //by wxz,[-Pi,Pi]
	  break;
  case 24:
	  Fitness=SolveEquation2(px);     //by wxz,[-Pi,Pi]
	  break;
  case 25:
	  Fitness=ThemoPowerPlant(px);
	  Gene[VarNum-1]=px[VarNum];
	  break;
  case 26:
	  Fitness=FletchPowellFun(px);
	  break;
  case 27:
	  Fitness=LiPengFun(px);  //x[1]>-3,x[2]<3
	  break;
  case 28:              //[0,10] and s.t.
	  Fitness=Example1(px);//KeaneBump(px);  //x[1]>-3,x[2]<3
	  break;

  case 29:      //[-512,511]
	  Fitness=SchwefelFun(px);
	  break;
  case 30:     //[-5.12,5.12]
	  Fitness=LeungF2(px);
	  break;
  case 31:   //[-600,600]
	  Fitness=LeungF4(px);
	  break;
  case 32:    //[-50,50]
	  Fitness=LeungF5(px);
	  break;
  case 33:    //[-5,5]
	  Fitness=LeungF9(Gene-1);
	  break;
  case 34:     //[-10,10]
	  Fitness=LeungF13(px);
	  break;
  case 35:    //[-100,100]
	  Fitness=LeungF14(px);
	  break;
  case 36:    //[-100,100]
	  Fitness=LeungF15(px);
	  break;
  case 37:
	  Fitness=ParaIden(px);
	  break;
  case 38:
	  Fitness=BackStepWxz(px);
	  break;
  case 39:
	  Fitness=MyRob1(px);
	  break;
  case 40:  //[-65.536,65.536]
	  Fitness=ShekelFoxholes(px);
	  break;
  case 41: //(0,1)
	  Fitness=LinFun(px);
	  break;
  default:  //[-1,2]
	  Fitness=Example1(px);
	  break;
  }
 return Fitness;
}