gt_class.cpp

一个郭涛算法类

//带约束条件的郭涛算法2
//此程序来自网络，自己加以修改
//作者：武汉大学硕士

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <windows.h>

#define GANVARS 1  //函数维数
#define GA_popsize 100  //种群数 n
#define GA_selectsize 10//种群中挑出来的个数m
#define GA_maxgen  4000 //最大循环次数

class GT   //class begin
{
public:
FILE *fp;
int GA_worstIndex,GA_bestIndex;
double GA_pop[GA_popsize+1][GANVARS];
double lowBound[GANVARS],upperBound[GANVARS];
double GA_fitness[GA_popsize+1];
double Hx[GA_popsize+1];   //约束条件的适应值

/************************************************/
GT(void)  
{
int i,j;

if((fp=fopen("guotaoout.txt","w"))==NULL)
{
	printf("\nCannot open input file\n");
	exit(1);
}

for(i=0;i<GANVARS;i++)//设置边界
{lowBound[i]=-10;
upperBound[i]=10;
}

srand(GetTickCount());//初始种子

for(i=0;i<GANVARS;i++)//初始基因
{
	for(j=0;j<GA_popsize;j++)  
	{
		GA_pop[j][i]=randval(lowBound[i],upperBound[i]);
	}
} 

    	GA_worstIndex=0;
   	GA_bestIndex=0;

   	 for(i=0;i<GA_popsize;i++)
    	{
       		GA_fitness[i]=GA_evaluate(i);
			Hx[i]=GA_Hx(i);
	       	if( better(GA_worstIndex,i))
		   {
			   GA_worstIndex=i;
		   }
       		if(better(i,GA_bestIndex))
	   	  {
			   GA_bestIndex=i;
	  	  } 
    	}
    fprintf(fp,"\n初始种群：\n");
    for(i=1;i<=GA_popsize;i++)	//文件输出初始种群
	{     	

   		fprintf(fp,"\n %d",i);
   		for(j=0;j<GANVARS;j++)
   		{
	   		fprintf(fp,"\t%8.4f",GA_pop[i-1][j]);   
   		}
	}
};


/********************************************************/
void  GA_crossover()       
{
    int i,j,temp,MatePool[GA_popsize];
    double MateParam[GA_selectsize];//保存相成系数
    int validChild;
    double mbl2,mbl3,t;
    double sumA,tmpMin,tmpMax,MaxA,MinA;
    MinA=-0.5;
    MaxA=1.5;
    int oldrd;
    validChild=0;

    for(i=0;i<GA_popsize;i++)
         MatePool[i]=i;

    for(;validChild==0;)
	{
		for(i=0;i<GA_selectsize;i++)  //选择GA_selectsize个体，保存在MatePool[0,GA_selectsize-1]数组中。
		{
		    oldrd=rabdi(GA_popsize-i);
		    j=i+oldrd;
		    temp=MatePool[i];
		    MatePool[i]=MatePool[j];
		    MatePool[j]=temp;
			
	    }
	    sumA=0.0;
	    for(i=0;i<=GA_selectsize-2;i++)		//产生GA_selectsize个系数[-0.5,1.5]，GA_selectsize个系数之和等于1。这个方法相当巧妙。
		{
			double mt1;
		    mt1=GA_selectsize-i+1;
		    tmpMin=1-sumA-MaxA*mt1;
		    tmpMax=1-sumA-MinA*mt1;
		    if(tmpMin<MinA)
			     tmpMin=MinA;
		    if(tmpMax>MaxA)
			     tmpMax=MaxA;
		    MateParam[i]=randval(tmpMin,tmpMax);
		    sumA=sumA+MateParam[i];
		}
	    MateParam[GA_selectsize-1]=1-sumA;
	    validChild=1;
	    for(i=0;i<GANVARS;i++)				//个体存入GA_pop[GA_popsize]中，如果产生的个体是非法值，两种选择：1：再进行循环；2：要拉回边界。
		{
			GA_pop[GA_popsize][i]=0;
			for(j=0;j<GA_selectsize;j++)
			{  
				GA_pop[GA_popsize][i]+=GA_pop[MatePool[j]][i]*MateParam[j]; 
			}		
			t=GA_pop[GA_popsize][i];
			
			
			mbl2=lowBound[i];
			mbl3=upperBound[i];
			//再进行循环
			/*if(t<mbl2||t>mbl3)
				{
					validChild=0;
					break;
				}
			  //再进行循环
			*/
			//  这里是拉回边界。
			if(t<mbl2) GA_pop[GA_popsize][i]=mbl2;
			if(t>mbl3) GA_pop[GA_popsize][i]=mbl3;
			
		}
	}//end for(;validChild==0;)
GA_fitness[GA_popsize]=GA_evaluate(GA_popsize);
Hx[GA_popsize]=GA_Hx(GA_popsize);
};


/********************************************************/
double GA_evaluate(int GT_mem)						//记算公式的值
{
int i;
double temp=0;
	
	
		for(i=1;i<=5;i++)
		{
			temp=temp+i*cos(  (i+1) * GA_pop[GT_mem][0]+ i  );
		}
	
return temp;
}

double GA_Hx(int GA_mem)  //求Hx[]
{
//需要添加代码；
double sum=0;
double temp1=1;
double temp2=0;
int i;
for(i=0;i<GANVARS;i++) temp1*=GA_pop[GA_mem][i];
for(i=0;i<GANVARS;i++) temp2+=GA_pop[GA_mem][i];

if(  (-temp1+0.75)>0  )
	sum=sum-temp1+0.75;

if(   (temp2-(7.5*GANVARS)) >0)
	sum=sum+temp2-(7.5*GANVARS);

return 0;
};

/*****************************************************/
int better(int GA_mem1,int GA_mem2)
{
double  t1,t2;
t1=GA_fitness[GA_mem1];
t2=GA_fitness[GA_mem2];

if(Hx[GA_mem1]<Hx[GA_mem2])	 return (1);
else 
	if( fabs( Hx[GA_mem1]-Hx[GA_mem2] ) <=0.00000001 ) 
	{
		if(t1<t2) return (1);
		else	return(0);
	}
	else
	{
		return 0;
	}
};


/*****************************************************/
void GA()
{

    int i,j,bl;
    int gen=1;
    double mt1,mt2;

	
    fprintf(fp,"\n\n运行情况：\n");
    bl=1;
    while( bl && gen<=GA_maxgen )
	{
		GA_crossover();
  
		if(better(GA_popsize,GA_worstIndex))//如果产生的个体比最差的好，代数就加一。 否则就继续GA_crossover。
		{
			for(i=0;i<GANVARS;i++)
				GA_pop[GA_worstIndex][i]=GA_pop[GA_popsize][i];
	   	        GA_fitness[GA_worstIndex]=GA_fitness[GA_popsize];
			Hx[GA_worstIndex]=Hx[GA_popsize];

	        if(better(GA_popsize,GA_bestIndex))    //比最好的还好。
			{   GA_bestIndex=GA_worstIndex;   }

	        GA_worstIndex=0;
	        for(i=1;i<GA_popsize;i++)
			{
				if(better(GA_worstIndex,i))			 GA_worstIndex=i;   
				
			}

            mt1=GA_fitness[GA_worstIndex];
            mt2=GA_fitness[GA_bestIndex];

            if( (fabs(mt1-mt2)) <= 0.000000000001  &&  Hx[GA_worstIndex]== Hx[GA_bestIndex]  &&   Hx[GA_bestIndex]==0)
                bl=0;
            else 
                bl=1;  
			
    		printf("\ngen= %d\tThe best value is:\t%.4f\n",gen,GA_fitness[GA_bestIndex]);		//屏幕输出
   				
			fprintf(fp,"\ngen=%d\tBest value: \t%8.4f\tThe parameter:",gen,GA_fitness[GA_bestIndex]);//文件输出
   			for(j=0;j<GANVARS;j++)
   			{
	   				fprintf(fp,"\t%8.4f",GA_pop[i][j]);   
   			}
		
			

		
			gen++;
		}
	
	}
	fprintf(fp,"\n\nThe last genes:\n\n");
	for(i=1;i<=GA_popsize;i++)	//文件输出最后种群
	{     	

   		fprintf(fp,"\n %d",i);
   		for(j=0;j<GANVARS;j++)
   		{
	   		fprintf(fp,"\t%.10f",GA_pop[i-1][j]);   
   		}
		fprintf(fp,"\tThe value: %.10f",GA_fitness[i]);
	}
};

/************************************************/
~GT() //析构函数
{
fclose(fp);
}
/************************************************/
double randval(double low,double high) //[low,high]
{
double  val;
val=((double)(rand()%1000)/999.0)*(high-low)+low;
return (val);
};
/************************************************/ 
int rabdi( int Nmem)   //[0,Nmem-1]，因为有截断误差
{
int newval;
newval=(int)(((rand()%1000)/1000.0)*Nmem);
return(newval);
};
};//class GT end;



void main(void)
{

GT gtexam;
gtexam.GA();

}