gapop1.cpp

用VC++变得实数编码遗传算法,还挺不错的

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

#include "gapop1.h"
#include "stdio.h"
#include "stdlib.h"
#include "time.h"
#include "math.h"
#include "fstream.h"

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

gapop1::gapop1()
{

}

gapop1::gapop1(int pops,int maxg,double pc,double pm,int grn,double *hb,double*lb)
{
	if(pops<10) popsize=10;
	//else if(pops>150) popsize=150;
	else popsize=pops;
	//if(maxg<10) maxgen=10;
	//else if(maxg>1500) maxgen=1500;
	//else 
	maxgen=maxg;
	if(pc<0.1) pcross=0.1;
	else if(pc>1.0) pcross=1.0;
	else pcross=pc;
	if(pm<0.001) pmutation=0.001;
    else if(pm>1.0) pmutation=0.6;
	else pmutation=pm;
	if(grn>0&&grn<50) 	garealn=grn;
	else garealn=1;
	pophb=new double[garealn];
	poplb=new double[garealn];
	for(int i=0;i<garealn;i++)
	{
		pophb[i]=hb[i];poplb[i]=lb[i];
	}
	garealpop=new gareal[popsize];
	crossopt.opt1=0;crossopt.opt2=0;
	objopt1=1;
	mutopt.opt1=0;mutopt.opt2=0;
}

gapop1::gapop1(int pops,int maxg,double pc,double pm,int grn,double hb,double lb)
{
	if(pops<10) popsize=10;
	//else if(pops>150) popsize=150;
	else popsize=pops;
	//if(maxg<10) maxgen=10;
	//else if(maxg>1500) maxgen=1500;
	//else 
	maxgen=maxg;
	if(pc<0.1) pcross=0.1;
	else if(pc>1.0) pcross=1.0;
	else pcross=pc;
	if(pm<0.001) pmutation=0.001;
    else if(pm>1.0) pmutation=0.6;
	else pmutation=pm;
	if(grn>0&&grn<50) 	garealn=grn;
	else garealn=1;
	pophb=new double[garealn];
	poplb=new double[garealn];
	for(int i=0;i<garealn;i++)
	{
		pophb[i]=hb;poplb[i]=lb;
	}
	crossopt.opt1=0;crossopt.opt2=0;
	mutopt.opt1=0;mutopt.opt2=0;
	objopt1=1;
	garealpop=new gareal[popsize];	
}

gapop1::~gapop1()
{
	if(popsize>1) delete []garealpop;
//	if(ncross>0) delete []nc;
//	if(nmutation>1) delete []nm;
	if(garealn>1)
	{
		delete []pophb;
		delete []poplb;
	}
}

void gapop1::Popsize(int pops)
{
//   if(pops>=10&&pops<=150) popsize=pops;
//   else popsize=20;
   if(pops<10) popsize=10;
   else if(pops>150) popsize=150;
   else popsize=pops;
}

int gapop1::Popsize()
{
  return popsize;
}

void gapop1::Maxgen(int maxg)
{
//   if(mgn>=20&&mgn<=1500) maxgen=mgn;
//   else maxgen=50;
	if(maxg<20) maxgen=20;
	else if(maxg>1500) maxgen=1500;
	else maxgen=1500;
}

int gapop1::Maxgen()
{
  return maxgen;
}

int gapop1::Curgen()
{
  return curgen;
}

void gapop1::Curgen(int cgn)
{
	if(cgn>0) curgen=cgn;
}

void gapop1::Pcross(double pc)
{
//   if(pc>=0.1&&pc<=1.0) pcross=pc;
//   else pcross=0.2;
	if(pc<0.1) pcross=0.1;
	else if(pc>1.0) pcross=1.0;
	else pcross=pc;
}

double gapop1::Pcross()
{
  return pcross;
}

void gapop1::Pmutation(double pm)
{
//   if(pm>=0.001&&pm<=0.6) pmutation=pm;
//   else pmutation=0.05;//(double)
	if(pm<0.005) pmutation=0.005;
    else if(pm>0.6) pmutation=0.6;
	else pmutation=pm;
}
void gapop1::setcrossopt(int t1,int t2)
{
     gaopt copt1;
	 copt1.opt1=t1;
	 copt1.opt2=t2;
     setcrossopt(copt1);
}
void gapop1::setcrossopt(gaopt copt)
{   
    /*opt1=0-4 
	all-garealn r-rand rp-randpart
	0-all,1-r>0,2-rp>0,3-a+r0.5,4-a+rp0.5
    
	opt2=0-10 
	ac-arithmetic crossover bc-blend crossover fc-flat crossover r-rand
    0-ac,1-bc,2-fc,3-ac+bc0.5,4-ac+fc0.5,6-fc+bc0.5,7-ac+bc-r,8-ac+fc-r,9-bc+fc-r
	*/
    if(copt.opt1>=0&&copt.opt1<=4)
		crossopt.opt1=copt.opt1;
	else 
		crossopt.opt1=0;
    if(copt.opt2>=0&&copt.opt2<=9)
		crossopt.opt2=copt.opt2;
	else 
		crossopt.opt2=3;
}

void gapop1::setmutopt(int t1,int t2)
{
     gaopt mopt1;
	 mopt1.opt1=t1;
	 mopt1.opt2=t2;
     setmutopt(mopt1);
}

void gapop1::setmutopt(gaopt mopt)
{   
    /*opt1=0-5 
	all-garealn r-rand rp-randpart
	0-all,1-one,2-r>0,3-rp>0,4-a+r0.5,5-a+rp0.5
    
	opt2=0-10 
	nu-nonuniform u-uniform g-gaussian r-rand
    0-nu,1-u,2-g,3-u+nu0.5,4-g+nu0.5,5-u+g+nu0.33,6-g+nu-r,7-u+nu-r,8-g+u-r,9-nu+u+g-r
	*/
	if(mopt.opt1>=0&&mopt.opt1<=5)
		mutopt.opt1=mopt.opt1;
	else 
		mutopt.opt1=5;
    if(mopt.opt2>=0&&mopt.opt2<=9)
		mutopt.opt2=mopt.opt2;
	else 
		mutopt.opt2=3;
}
double gapop1::Pmutation()
{
  return pmutation;
}

int gapop1::Bestgen()
{
	return bestgen;
}

double gapop1::poprand()
{
	double r2;
	
	/*long r1=rand()*rand()%1000000;
	r2=double(r1*0.000001);*/
	int r1=rand()%10000;
	r2=double(r1*0.0001);
	return r2;
}

void gapop1::poprandn(int n,int ns,int *popn)
{
	int i,t,k;
	int *pt=new int[n];
	for(i=0;i<n;i++)
		pt[i]=i;
	for(i=0;i<ns;i++)
	{
		k=rand()%(n-i);
		t=pt[i];
		pt[i]=pt[i+k];
		pt[i+k]=t;
		popn[i]=pt[i];
	}
	delete [] pt;
}

int gapop1::Garealn()
{
	return garealn;
}

void gapop1::Garealn(int grn)
{
	if(grn>1) 
	{
		garealn=grn;
		pophb=new double[garealn];
		poplb=new double[garealn];
	}
	else garealn=1;
}

double gapop1::Pophb(int n)
{
    if(n>=0&&n<garealn&&garealn>1)
		return pophb[n];
	else if(garealn==1)
		return *pophb;
	else
		return 0.;

}

void gapop1::Pophb(int n,double hb1)
{
   if(n>=0&&n<garealn&&garealn>1)
		pophb[n]=hb1;
	else if(garealn==1)
		*pophb=hb1;
	else
		*pophb=1.0;
}

double gapop1::Poplb(int n)
{
    if(n>=0&&n<garealn&&garealn>1)
		return poplb[n];
	else if(garealn==1)
		return *poplb;
	else
		return 0.;

}

void gapop1::Poplb(int n,double lb1)
{
   if(n>=0&&n<garealn&&garealn>1)
		poplb[n]=lb1;
	else if(garealn==1)
		*poplb=lb1;
	else
		*pophb=1.0;
}

void gapop1::Pophlb(double hb1,double lb1)
{
	if(garealn>1)
	{
	   for(int i=0;i<garealn;i++)
	   {
		   pophb[i]=hb1;poplb[i]=lb1;
	   }
	}
	else
		*pophb=hb1;*poplb=lb1;
}

void gapop1::Pophlb(double *hb1,double *lb1)
{
	if(garealn>1)
	{
	   for(int i=0;i<garealn;i++)
	   {
		   pophb[i]=hb1[i];poplb[i]=lb1[i];
	   }
	}
	else
		pophb=hb1;poplb=lb1;
}

void gapop1::initgareal(int grn, double *hb, double *lb)
{
	if(grn>1) 	garealn=grn;
	else garealn=1;
	pophb=new double[garealn];
	poplb=new double[garealn];
	for(int i=0;i<garealn;i++)
	{
		pophb[i]=hb[i];poplb[i]=lb[i];
	}
}

void gapop1::initgareal(int grn, double hb, double lb)
{
	if(grn>1) 	garealn=grn;
	else garealn=1;
	pophb=new double[garealn];
	poplb=new double[garealn];
	for(int i=0;i<garealn;i++)
	{
		pophb[i]=hb;poplb[i]=lb;
	}
}

void gapop1::initpop(int pops,int maxg,double pc,double pm,int grn,double *hb,double *lb)
{
	if(pops<10) popsize=10;
	else if(pops>150) popsize=150;
	else popsize=pops;
	if(maxg<20) maxgen=20;
	else if(maxg>1500) maxgen=1500;
	else maxgen=maxg;
	if(pc<0.1) pcross=0.1;
	else if(pc>1.0) pcross=1.0;
	else pcross=pc;
	if(pm<0.005) pmutation=0.005;
    else if(pm>0.6) pmutation=0.6;
	else pmutation=pm;
	if(grn>0&&grn<50) 	garealn=grn;
	else garealn=1;
	pophb=new double[garealn];
	poplb=new double[garealn];
	for(int i=0;i<garealn;i++)
	{
		pophb[i]=hb[i];poplb[i]=lb[i];
	}
	garealpop=new gareal[popsize];
}

void gapop1::initpop(int pops,int maxg,double pc,double pm,int grn,double hb,double lb)
{
	if(pops<10) popsize=10;
	else if(pops>150) popsize=150;
	else popsize=pops;
	if(maxg<20) maxgen=20;
	else if(maxg>1500) maxgen=1500;
	else maxgen=maxg;
	if(pc<0.1) pcross=0.1;
	else if(pc>1.0) pcross=1.0;
	else pcross=pc;
	if(pm<0.005) pmutation=0.005;
    else if(pm>0.6) pmutation=0.6;
	else pmutation=pm;
	if(grn>0&&grn<50) 	garealn=grn;
	else garealn=1;
	pophb=new double[garealn];
	poplb=new double[garealn];
	for(int i=0;i<garealn;i++)
	{
		pophb[i]=hb;poplb[i]=lb;
	}
	garealpop=new gareal[popsize];
}

void gapop1::init1()
{
	double t,*pop;
	int i,*popn;
    gareal *gatemp;
	pop=new double[popsize];
	popn=new int[popsize];
	/*ncross=(int)(pcross*popsize+1)/2;
	if(ncross*2>popsize) ncross-=popsize%2;
	nc=new int[ncross*2];

	nmutation=int(ceil(pmutation*popsize));
    nm=new int[nmutation];*/

//	garealpop=new gareal[popsize];
//	cout<<"init 0 \n";
	curgen=0;
	na=0;
	printf("gen%d***************************\n",curgen);
	for(i=0;i<popsize;i++)
	{
		garealpop[i].nReal(garealn);
		for(int j=0;j<garealn;j++)
		{
			t=poplb[j]+poprand()*(pophb[j]-poplb[j]);
			//t=poplb[j]+poprand()*(0.5-0.0);
			garealpop[i].vecReal(j,t);
		}
		//objfunc(garealpop[i]);
		//pop[i]=garealpop[i].Fitness();
	}
//		cout<<"init 1 \n";
	popsort(pop,popsize,popn);
    /*for(i=0;i<popsize;i++) cout<<pop[i]<<"\t";
		cout<<"init 2 \n";
	cout<<garealpop[0];
    cout<<popn[0]<<endl;
	i=popn[0];
    cout<<garealpop[i];*/
    //objfunc(garealpop,popsize);
    gatemp=new gareal[popsize];
	for(i=0;i<popsize;i++) //popcopy(garealpop[popn[i]],gatemp[i]);
		gatemp[i]=garealpop[popn[i]];
	/*{
		//gatemp=garealpop[i];
        bestgareal=garealpop[i];
        //garealpop[i]=garealpop[popn[i]];
		//popcopy(garealpop[popn[i]],garealpop[i]);
		//garealpop[popn[i]]=gatemp;
		//popcopy(bestgareal,garealpop[popn[i]]);
		//popcopy(gatemp,garealpop[popn[i]]);
	}*/
    bestgareal=garealpop[popn[0]];
	curbestgareal=bestgareal;
	bestgen=curgen;
	delete [] garealpop;
	garealpop=gatemp;	
    delete []pop;
	delete []popn;
}
void gapop1::init()
{
	double t,*popfit;
	int i,*popn;
    gareal *gatemp;
	popfit=new double[popsize];
	popn=new int[popsize];
	curgen=0;
	na=0;
	printf("gen%d***************************\n",curgen);
    //
	for(i=0;i<popsize;i++)
	{
		garealpop[i].nReal(garealn);
		for(int j=0;j<garealn;j++)
		{
			t=poplb[j]+poprand()*(pophb[j]-poplb[j]);
			//t=poplb[j]+poprand()*(0.5-0.0);
			garealpop[i].vecReal(j,t);
		}
		//pop[i]=garealpop[i].Fitness();
	}
  
    /*for(i=0;i<popsize;i++) cout<<pop[i]<<"\t";
		cout<<"init 2 \n";
	cout<<garealpop[0];
    cout<<popn[0]<<endl;
	i=popn[0];
    cout<<garealpop[i];*/
   
	objfunc(garealpop,popsize);//

	for(i=0;i<popsize;i++) popfit[i]=garealpop[i].Fitness(); //

	popsort(popfit,popsize,popn);//
	gatemp=new gareal[popsize];
	for(i=0;i<popsize;i++) //popcopy(garealpop[popn[i]],gatemp[i]);
		gatemp[i]=garealpop[popn[i]];

	bestgareal=garealpop[popn[0]];
	curbestgareal=bestgareal;
	bestgen=curgen;
	delete [] garealpop;
	garealpop=gatemp;	
    delete []popfit;
	delete []popn;
}
void gapop1::objfunc(gareal &ga1)
{
	int i,n1,valid,state;
//	FILE *output;
	double *x,s,ss,t1,t2,s1,s2;
	double *pler,*plel,*per,*pel;
	int ne,nle;
//	float t;
	//static int na;
	int a[2][25];
	ga1.State(0);
	n1=ga1.nReal();
	x=new double[n1];
	for(i=0;i<n1;i++) x[i]=ga1.vecReal(i);
	t1=x[0];t2=x[1];
	s=0.0;ss=0.0;
	s1=0.;s2=0.;
	valid=1; state=0;
    //na=0;
   
	switch(testf)
	{
	case 1:s1=1+(t1+t2+1)*(t1+t2+1)*(19-14*t1+3*t1*t1-14*t2+6*t1*t2+3*t2*t2); //-2<=x(i)<=2
		s2=30+(2*t1-3*t2)*(2*t1-3*t2)*(18-32*t1+12*t1*t1+48*t2-36*t1*t2+27*t2*t2);
		s=s1*s2; 
		ss=s;
		break;
		// min=3 x=0 -1 f1 
    case 2:
		s1=(4-2.1*t1*t1+t1*t1*t1*t1/3)*t1*t1;//[-3 x 3 ] [-2 y 2]
		s2=t1*t2+(-4+4*t2*t2)*t2*t2;
		s=s1+s2; ss=s;//s=-s;
		break;
		//min=-1.031628 x= 0.898 -07126 f2 
    case 3:
		for(i=0;i<n1;i++) //-5.12<=x(i)<=5.12 n=3
			s+=x[i]*x[i]; 
		ss=s;
		break;
		//min=0 x=0 0 0 f3
    case 4:
		s1=100*(t1*t1-t2)*(t1*t1-t2);//-2.048<=x(i)<=2.048
		s2=(1-t1)*(1-t1);
		s=s1+s2; 
		ss=s;
		break;