⭐ 欢迎来到虫虫下载站！ | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站
📤 上传资源

📄 xx1.cpp

📁 一个遗传算法的程序
💻 CPP
📖 第 1 页 / 共 2 页
字号:
🔍
12 
// XX1.cpp: implementation of the XX1 class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "MyGA.h"
#include "XX1.h"
#include "stdlib.h"
#include "math.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
//  global variables
extern int VarNum;
extern char FirstFlag;
int CIndividual::FunSel=0;
int CIndividual::VarNum=1;
int CIndividual::MuteType=0;
int CIndividual::ReproduceType=0;
double CIndividual::Upper[];
double CIndividual::Lower[];
double CIndividual::Mu[];
double CIndividual::Sigma[];
long int CIndividual::FuncallCount=0;
double CIndividual::Tu=1;
double CIndividual::Tup=1;
CIndividual::CIndividual()
{

}

void CIndividual::Setup(int funsel,int varnum,int mutetype,int reproducetype)
{
	FunSel=funsel;VarNum=varnum;
	MuteType=mutetype;
	ReproduceType=reproducetype;
	Tu=1.0/sqrt(2.0*sqrt(VarNum));
	Tup=1.0/sqrt(2.0*VarNum);
}

void CIndividual::Setup(GAPARAMS &gapara)
{
	FunSel=gapara.iFunSel;
	VarNum=gapara.iVarNum;
	MuteType=gapara.iMuteType;
	ReproduceType=gapara.iReproduceType;
	Tu=1.0/sqrt(2.0*sqrt(VarNum));
	Tup=1.0/sqrt(2.0*VarNum);
	for(int i=0;i<VarNum;i++)
	{
		Mu[i]=0;
		Sigma[i]=gapara.dSigma0;
	}
}

//个体初始化
void CIndividual::Initialize(void)
{
	for(int i=0;i<VarNum;i++)
	{
//		Gene[i]=Randval(Lower[i],Upper[i]);
		Eta[i]=CPopulation::Sigma0;
	}
 }

//变量范围限定
void CIndividual::Limit(void)
{
 for(int i=0;i<VarNum;i++)
  {
   if(Gene[i]>Upper[i])Gene[i]=Upper[i];
   if(Gene[i]<Lower[i])Gene[i]=Lower[i];
   }
 }

void CIndividual::SetRange(double upper,double lower)
{
 for(int i=0;i<NVARS;i++)
  {
   Upper[i]=upper;
   Lower[i]=lower;
   }
}

void CIndividual::SetRange(double upper[],double lower[])
{
 for(int i=0;i<NVARS;i++)
  {
   Upper[i]=upper[i];
   Lower[i]=lower[i];
   }
}
//随机产生基因
void CIndividual::RandInd(void)
{
 int i;
 for(i=0;i<VarNum;i++)
   Gene[i]=Randval(Lower[i],Upper[i]);
 }


void CIndividual::GaussMutate(CIndividual &src,double sigma)
{
	int i;
	if(MuteType==1)
	{
		for(i=0;i<VarNum;i++)Gene[i]=src.Gene[i]+GaussX(0,sigma);
	}
	else
	{
		for(i=0;i<VarNum;i++)Gene[i]=src.Gene[i];
		i=rand()%VarNum;
		Gene[i]=src.Gene[i]+GaussX(0,sigma);
	}
 }


void CIndividual::CESGaussMutate(CIndividual &src)
{
	int i;
	double N01=GaussX(0,1);
	if(MuteType==1)
	{
		for(i=0;i<VarNum;i++)
		{
			Eta[i]=src.Eta[i]*exp(Tup*N01+Tu*GaussX(0,1));
			if(Eta[i]>CPopulation::Sigma0)Eta[i]=Eta[i]>CPopulation::Sigma0;
			else if(Eta[i]<CPopulation::SigmaMin)Eta[i]=CPopulation::SigmaMin;
			Gene[i]=src.Gene[i]+Eta[i]*GaussX(0,1);
		}
	}
	else
	{
		for(i=0;i<VarNum;i++){Gene[i]=src.Gene[i];Eta[i]=src.Eta[i];}
		i=rand()%VarNum;
		Eta[i]=src.Eta[i]*exp(Tup*N01+Tu*GaussX(0,1));
		if(Eta[i]>CPopulation::Sigma0)Eta[i]=Eta[i]>CPopulation::Sigma0;
		else if(Eta[i]<CPopulation::SigmaMin)Eta[i]=CPopulation::SigmaMin;
		Gene[i]=src.Gene[i]+Eta[i]*GaussX(0,1);
	}
 }


void CIndividual::TwowayMutate(CIndividual &src,double sigma)
{
	int i;
	double delt;
	for(i=0;i<VarNum;i++)Gene[i]=src.Gene[i];
	i=rand()%VarNum;
	delt=sigma*GaussX(0,1);//GaussX(Mu[i],sigma);
	double oldgene=Gene[i];
	Gene[i]=oldgene+delt;
	Evaluate();
/*	if(Fitness<=src.Fitness)
	{
		Gene[i]=oldgene-delt;
		Evaluate();
		if(Fitness<=src.Fitness)
		{
			Gene[i]=oldgene+delt/2;
			Evaluate();
			if(Fitness<=src.Fitness)
			{
				Gene[i]=oldgene-delt/2;
				Evaluate();
				if(Fitness<=src.Fitness)return;
				else 
				{
					Mu[i]=-delt/4;
					Sigma[i]*=0.75;
				}
			}
			else
			{
				Mu[i]=delt/4;
				Sigma[i]*=0.75;
			}

		}
		else
		{
			Mu[i]=-delt/2;
		}
	}
	else
	{
		Mu[i]=delt/2;
	}*/
	if(Fitness<src.Fitness)return;
	src.Fitness=Fitness;
	src.Gene[i]=Gene[i];
}

void CIndividual::AllGeneMutate(CIndividual &src,double sigma)
{
	for(int i=0;i<VarNum;i++)
	{
		Gene[i]=src.Gene[i]+GaussX(Mu[i],sigma);
	}
	Evaluate();
	if(Fitness>src.Fitness)
	{
		for(int i=0;i<VarNum;i++)
		{
			Gene[i]=src.Gene[i]+GaussX(Mu[i],sigma);
		}
		src.Fitness=Fitness;
	}
}


void CIndividual::TwowayUniformMutate(CIndividual &src)
{
	int i;
	for(i=0;i<VarNum;i++)Gene[i]=src.Gene[i];
	i=rand()%VarNum;
	Gene[i]=Randval(Lower[i],Upper[i]);
	Evaluate();
	if(Fitness<=src.Fitness)
	{
		Gene[i]=-Gene[i];
		Evaluate();
		if(Fitness<=src.Fitness)return;
	}
	src.Gene[i]=Gene[i];
	src.Fitness=Fitness;
}


void CIndividual::UniformMutate(CIndividual &src)
{
	int i;
	if(MuteType)
	{
		for(i=0;i<VarNum;i++)Gene[i]=Randval(Lower[i],Upper[i]);
	}
	else
	{
		for(i=0;i<VarNum;i++)Gene[i]=src.Gene[i];
		i=rand()%VarNum;
		Gene[i]=Randval(Lower[i],Upper[i]);
	}
}

void CIndividual::UniformMutate(CIndividual &src,double a[],double b[])
{
	int i;
	for(i=0;i<VarNum;i++)Gene[i]=src.Gene[i];
	i=rand()%VarNum;
	Gene[i]=Randval(a[i],b[i]);
}

double CIndividual::IndDistance(CIndividual &ind)
{
	double x,xx;
	xx=0;
	for(int i=0;i<VarNum;i++)
	{
		x=Gene[i]-ind.Gene[i];
		xx+=x*x;
	}
	return sqrt(xx);
}

//////////////////////////////////////////////////////////////////////
// CPopulation Class
//////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
int CPopulation::N1=2; 
int CPopulation::N2=8;
int CPopulation::N3=5;
int CPopulation::PopSize=15;
double CPopulation::Sigma0=1.0;
double CPopulation::SigmaMin=0.00001;
double CPopulation::SigmaCoe=0.5;
int CPopulation::TuneInterval=10;
long int CPopulation::MaxGeneration=10000000L;
long int CPopulation::MaxNoEvolveGen=5000;
double CPopulation::Optima=1.0e+10;
double CPopulation::Accuracy=1.0e-10;
int CPopulation::StopFlag=0;
int CPopulation::OptimaNum=0;
int CPopulation::MaxOptimaNum=100;
double CPopulation::Radius=1e-5;
int CPopulation::ESType=0;
COptimArray CPopulation::OptimArray;
int CPopulation::NoNewOptima=0;
int CPopulation::MaxNoNewOptima=100;
//种群构造函数
CPopulation::CPopulation()
{
    Ind=new CIndividual[PopSize];
}

void CPopulation::Setup(int mu,int lamda,int kap,double sigma0,double sigmamin,
						double sigmacoe,
		int tuneinterval,long int maxgen,long int maxnoevgen,double optima,
		double accuracy,double radius,int maxoptimanum,int nonewnum,int estype)
{
	PopSize=mu+lamda+kap;
	if(PopSize>MAXPOPSIZE){
		PopSize=MAXPOPSIZE;
		N1=1;N2=MAXPOPSIZE/2;N3=N2-1;}
	else {
		N1=mu;N2=lamda;N3=kap;}
	Sigma0=sigma0;SigmaMin=sigmamin;SigmaCoe=sigmacoe;TuneInterval=tuneinterval;
	MaxGeneration=maxgen;MaxNoEvolveGen=maxnoevgen;
	Optima=optima;
	Accuracy=accuracy;
	StopFlag=0;
	OptimArray.RemoveAll();
	OptimArray.SetSize(maxoptimanum);
	Radius=radius;
	MaxOptimaNum=maxoptimanum;
	OptimaNum=0;
	MaxNoNewOptima=nonewnum;
	ESType=estype;
}

void CPopulation::Setup(GAPARAMS &gapara)
{
	PopSize=gapara.iMu+gapara.iLumda+gapara.iKapa;
	if(PopSize>MAXPOPSIZE)
	{
		PopSize=MAXPOPSIZE;
		N1=1;N2=MAXPOPSIZE/2;N3=N2-1;
	}
	else {
		N1=gapara.iMu;N2=gapara.iLumda;N3=gapara.iKapa;}
	Sigma0=gapara.dSigma0;SigmaMin=gapara.dMinSigma;
	SigmaCoe=gapara.dSigmaCoe;TuneInterval=gapara.iTuneInterval;
	MaxGeneration=gapara.lMaxGeneration;MaxNoEvolveGen=gapara.lMaxNoEvolveGen;
	Optima=gapara.dOptima;
	Accuracy=gapara.dAccuracy;
	Radius=gapara.dSubpopRadius;
	MaxOptimaNum=gapara.iMaxOptimaNum;
	MaxNoNewOptima=gapara.iNoNewNum;
	ESType=gapara.iESType;
	StopFlag=0;
	OptimArray.RemoveAll();
	OptimArray.SetSize(MaxOptimaNum);
}

void CPopulation::Modify(GAPARAMS &gapara)
{
	Sigma0=gapara.dSigma0;SigmaMin=gapara.dMinSigma;
	SigmaCoe=gapara.dSigmaCoe;TuneInterval=gapara.iTuneInterval;
	MaxGeneration=gapara.lMaxGeneration;MaxNoEvolveGen=gapara.lMaxNoEvolveGen;
	Optima=gapara.dOptima;
	Accuracy=gapara.dAccuracy;
	Radius=gapara.dSubpopRadius;
	MaxOptimaNum=gapara.iMaxOptimaNum;
	MaxNoNewOptima=gapara.iNoNewNum;
	ESType=gapara.iESType;
	CIndividual::MuteType=gapara.iMuteType;
}

void CPopulation::InitializeAll(void)
{
	OptimaNum=0;
	StopFlag=0;
	NoNewOptima=0;
}


//按适应值排序
void CPopulation::Sort(void)
{
	int i,j,besti;
	double best;
	for(i=0;i<N1;i++)  //only the first N1
	{
	   best=Ind[i].Fitness;
	   besti=i;
	   for(j=i+1;j<PopSize;j++)
		{
		 if(Ind[j].Fitness<best)continue;
		 best=Ind[j].Fitness;
		 besti=j;
		 }
	   Swap(&Ind[i],&Ind[besti]);
	}
}

//种群更新
void CPopulation::Fresh(void)
{
 	int i,nx;
	if(ESType==0)  //CES
	{
		if(CIndividual::ReproduceType==0)  //精英繁殖
		{
			for(i=0;i<N2;i++) //Gauss变异
				Ind[N1+i].CESGaussMutate(Ind[0]);
			nx=N1+N2;
			for(i=0;i<N3;i++)  //均匀变异
				Ind[nx+i].UniformMutate(Ind[0]);
		}
		else  //共同繁殖
		{
			for(i=0;i<N2;i++) //Gauss变异
				Ind[N1+i].CESGaussMutate(Ind[i%N1]);
			nx=N1+N2;
			for(i=0;i<N3;i++)  //均匀变异
				Ind[nx+i].UniformMutate(Ind[i%N1]);
		}
	}
	else  //改进的ES
	{
		if(CIndividual::ReproduceType==0)  //精英繁殖
		{
			for(i=0;i<N2;i++) //Gauss变异
				Ind[N1+i].GaussMutate(Ind[0],Sigma);
			nx=N1+N2;
			for(i=0;i<N3;i++)  //均匀变异
				Ind[nx+i].UniformMutate(Ind[0]);
		}
		else  //共同繁殖
		{
			for(i=0;i<N2;i++) //Gauss变异
				Ind[N1+i].GaussMutate(Ind[i%N1],Sigma);
			nx=N1+N2;
			for(i=0;i<N3;i++)  //均匀变异
				Ind[nx+i].UniformMutate(Ind[i%N1]);
		}
	}
 }


void CPopulation::FreshNew()
12

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -