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

📄 rtcgps.cpp

📁 基于GPS的多目标优化及动态多目标优化源代码 里面 包含MOP, DMOP的程序
💻 CPP
📖 第 1 页 / 共 4 页
字号:
🔍
1234 
	case 1: RunStep1();
		break;
	case 2: RunStep2();
		break;
	case 3: RunStep3();
		break;
	case 4: RunStep4();
		break;
	case 5:
		RunStep5();
		break;
	case 6:
		RunStep6();
		break;
	case 7:
		RunStep7();
		break;
		
	case 9: 
		ASSERT(PopTypeInitPolicy==1);
		RunStep9();
		break;
	default:
		MessageBox(NULL,"No Exist GeneratorPolicy!","Error ",MB_OK);
		exit(0);
	}
}

BOOL RTCGPS::ReplaceSolution(int Which, CSolution &m_temp)
{
	m_Pop[Which].Copy (&m_temp);
	return TRUE;
}

void RTCGPS::InitPopType()
{
	switch (PopTypeInitPolicy)
	{
	case 0: 
		PopTypeRandom();
		return;
	case 1: 
		PopTypeRegionLinear();
		return;
	default:
		MessageBox(NULL,"No Exist BetterPolicy!","Error ",MB_OK);
		exit(0);
	}
}

void RTCGPS::PopTypeRandom()
{
	for (int i=0;i<RTCGPS::PopSize ;i++)
	{
		m_Pop[i].type = CRandom::Random(0, CSolution::OBJectiveNum ); 
	}
}

void RTCGPS::PopTypeRegionLinear()
{	
	for (int i=0;i<RTCGPS::PopSize ;i++)
	{
		m_Pop[i].type = i*(CSolution::OBJectiveNum+1)/RTCGPS::PopSize ;
		
		/***********************************************/
		/***********************************************/
		/***********************************************/
		/***********************************************/
		// initializing the sortnodes for DGPS 
		this->SetFitness(m_Pop[i]);
		m_Elist.AddSolution(m_Pop[i]);
		m_Selct[i].Index =i;
        m_Selct[i].Type =m_Pop[i].type;
		m_Selct[i].SelctValue =0;
        m_Selct[i].Activity =0;
        m_Selct[i].Momentum =0;
	}
}
void RTCGPS::OnEnvironmentChanged()
{
	switch (ProblemType)
	{
		/// 0 : DMOP
	case 0:
		DMOP_OnEnvironmentChanged();
		break;
		/// 1: MOP
	case 1:
		MOP_OnEnvironmentChanged();
		break;
	default:
		MessageBox(NULL,"No Right Environment Processor!","Error ",MB_OK);
		exit(0);
	}
}
void RTCGPS::DMOP_OnEnvironmentChanged()
{
	/************************************************************************/
	/* 首先,打印出变化前的信息                                              */
	/************************************************************************/
	EnvironmentChangedTimes++;
	FILE *fp;
	sprintf(FileName,"%s_%04d.txt\0",ProblemName,EnvironmentChangedTimes);
	fp = fopen(FileName,"w+t");
	for (int i=0;i<m_Elist.ElitistSpace.GetSize();i++)
	{   
		CSolution *p_temp = (CSolution *)m_Elist.ElitistSpace.GetAt(i);
        if(p_temp->Distance <1) continue;
		//打印 目标
		for (int j=0;j<CSolution::OBJectiveNum;j++)
			fprintf(fp,"%0.7f	",p_temp->Objective[j]); 
		fprintf(fp,"\n");
	   }
	////打印基因
	/*	fprintf(fp,"************************************************\n");
	fprintf(fp,"************************************************\n");
	fprintf(fp,"************************************************\n");
	for (i=0;i<m_Elist.ElitistSpace.GetSize();i++)
	{   
	CSolution *p_temp = (CSolution *)m_Elist.ElitistSpace.GetAt(i);
	if(p_temp->Distance <1) continue;
	//打印 目标
	for (int j=0;j<CSolution::GetGeneLength();j++)
	fprintf(fp,"%0.7f	",p_temp->Gene[j]); 
	fprintf(fp,"\n");
	   }
	*/	fclose(fp);   
	PrintPopulation();
	/************************************************************************/
	/* 对种群进行更新,保留一部分当前的好解,其余的随机从精英空间中抽取       */
	/************************************************************************/
	//计算精英空间中的个体数
	int SpaceSize =0;
	for (i=1; i<m_Elist.ElitistSpace.GetSize();i++)
	{
		if ( ((CSolution *)m_Elist.ElitistSpace[i])->Distance > 900)
			SpaceSize++;
	}
	
	//计算应当有多少个个体需要从精英空间中抽取
	double ReplNum=  (double)SpaceSize*PopSize/(double)(SpaceSize+ PopSize) ;
    int BaseNum = (int)floor(ReplNum);
	int Remain = ReplNum - BaseNum;
	if (CRandom::Random(0,1)< Remain){
		BaseNum ++;
	}
	//从精英空间中抽取个体
	int AllSpaceSize = 	m_Elist.ElitistSpace.GetSize();
	for (int cnt =0;cnt< BaseNum;cnt++)
	{
		int Index =CRandom::Random(0,AllSpaceSize-1);
		while (((CSolution *)m_Elist.ElitistSpace[Index])->Distance < 900)
		{
            Index =(Index +1) %AllSpaceSize;
		}
		m_Pop[cnt].Copy((CSolution*)m_Elist.ElitistSpace[Index]);
	}
	switch(AlgorithmPolicy) {
	case 1 :
		/************************************************************************/
		/* 超变异处理  并使用delta变异                                          */
		/************************************************************************/
		for(i=0;i< PopSize;i++){
			if (HyperMutationRate > CRandom::Random(0.0,1.0)) {
				HyperDeltaMutate(i);
			}
		}
		break;
	case 2:
		/************************************************************************/
		/* 超变异处理  并使用随机变异                                           */
		/************************************************************************/
		for(i=0;i< PopSize;i++){
			if (HyperMutationRate > CRandom::Random(0.0,1.0)) {
				RandomMutate(i);
			}
		}
		break;
	default:
		/************************************************************************/
		/* 没有实现的算法策略                                                   */
		/************************************************************************/
		MessageBox(NULL,"没有实现的算法策略!","错误!",MB_OK);
		exit(0);
		break;
	}
	
	if (ElitistPolicy==1)
	{
		/************************************************************************/
		/* 重写精英空间，并对种群全部进行重新评价                               */
		/************************************************************************/	
		for(i=0;i< m_Elist.ElitistSpace.GetSize();i++){
			this->SetFitness(*(CSolution*)m_Elist.ElitistSpace[i]);
			( (CSolution*)m_Elist.ElitistSpace[i])->Distance =0;
		}
		m_Elist.RefreshAll();
	}
	
	if (ElitistPolicy==2)
	{
		for(i=0;i< m_Elist.ElitistSpace.GetSize();i++){
			( (CSolution*)m_Elist.ElitistSpace[i])->Distance =0;
		}
	}
	
	for(i=0;i< PopSize;i++){
		this->SetFitness(m_Pop[i]);
	}
}



void RTCGPS::MOP_OnEnvironmentChanged()
{
	/************************************************************************/
	/* 首先,打印出变化前的信息                                              */
	/************************************************************************/
	EnvironmentChangedTimes++;
	FILE *fp;
	sprintf(FileName,"%s_%04d.txt\0",ProblemName,EnvironmentChangedTimes);
	fp = fopen(FileName,"w+t");
	for (int i=0;i<m_Elist.ElitistSpace.GetSize();i++)
	{   
		CSolution *p_temp = (CSolution *)m_Elist.ElitistSpace.GetAt(i);
        if(p_temp->Distance <1) continue;
		//打印 目标
		for (int j=0;j<CSolution::OBJectiveNum;j++)
			fprintf(fp,"%0.7f	",p_temp->Objective[j]); 
		fprintf(fp,"\n");
	   }
	////打印基因
	/*	fprintf(fp,"************************************************\n");
	fprintf(fp,"************************************************\n");
	fprintf(fp,"************************************************\n");
	for (i=0;i<m_Elist.ElitistSpace.GetSize();i++)
	{   
	CSolution *p_temp = (CSolution *)m_Elist.ElitistSpace.GetAt(i);
	if(p_temp->Distance <1) continue;
	//打印 目标
	for (int j=0;j<CSolution::GetGeneLength();j++)
	fprintf(fp,"%0.7f	",p_temp->Gene[j]); 
	fprintf(fp,"\n");
	   }
	*/	fclose(fp);   
	PrintPopulation();
}


bool RTCGPS::CheckSentinel(CSolution &tSentinel)
{
	
    CSolution m_tmp;
	m_tmp.Init();
	m_tmp.Copy(&tSentinel);
	SetFitness(tSentinel);
	for (int i=0; i< CSolution::OBJectiveNum;i++)
	{
		if (fabs(m_tmp.Objective[i] - tSentinel.Objective[i])> 0.00000001) 
			return true;
	}
	return false;
	/*
	if (fabs(m_tmp.Objective[0]-tSentinel.Objective[0]) > 0.000001)
	return TRUE;
    else    return FALSE;
	*/
}


CSolution* RTCGPS::CrossoverNeighbor(int Host, CSolution *pOutSolution)
{
	pOutSolution->Copy(&m_Pop[Host]);
	int GeneSize = CSolution::GetGeneLength();
	double tt= CRandom::Random(CrossoverLowerLimit, CrossoverUpperLimit);
    double tt2= CRandom::Random(CrossoverLowerLimit, CrossoverUpperLimit);
	//EDIT HERE
	//当多个种群的时候，似乎需要改动
    //EDIT HERE
	int other =(Host+1) % PopSize;
	for (int i=0;i< GeneSize;i++)
	{
		pOutSolution->Gene[i]= tt * m_Pop[Host].Gene[i] +(1-tt)*m_Pop[other].Gene[i];
	}
	return pOutSolution;
}

CSolution* RTCGPS::CrossoverRandom(int Host, CSolution *pOutSolution)
{
	pOutSolution->Copy(&m_Pop[Host]);
	int GeneSize = CSolution::GetGeneLength();
	double tt= CRandom::Random(CrossoverLowerLimit, CrossoverUpperLimit);
	int other = CRandom::Random(0,PopSize -1);
	for (int i=0;i< GeneSize;i++)
	{
		pOutSolution->Gene[i]= tt * m_Pop[Host].Gene[i] +(1-tt)*m_Pop[other].Gene[i];
	}
	return pOutSolution;
}

void RTCGPS::RunStep1()
{
	   CSolution m_temp(TRUE);
	   BOOL IsParetoPoint;
	   BOOL isBetter ;
	   int iCount;
	   for (iCount=0;iCount< RTCGPS::PopSize ;iCount++)
	   {
//		   if (CRandom::Random(0.0,1.0) < 0.05)
//		   {
//			   RandomMutate(iCount);
//    		   SetFitness(m_temp);
// 	    	   SaveBest(&m_temp);
//			   continue;
//		   }
		   Mutation(iCount,&m_temp);		   
		   SetFitness(m_temp);
		   SaveBest(&m_temp);
		   IsParetoPoint = m_Elist.AddSolution(m_temp);
		   isBetter =Better(m_temp,m_Pop[iCount],m_Pop[iCount].type );
		   if (IsParetoPoint) 
		   {
			   if(m_Pop[iCount].type ==CSolution::OBJectiveNum )
			   {
			   if ( WSMBetter(&m_temp,&m_Pop[iCount]) ) 
			   {
				   ReplaceSolution(iCount,m_temp);
				   continue;
			   }
			   }
			   
		   }
		   if (isBetter)  
		   {
			   ReplaceSolution(iCount,m_temp);
			   continue;
		   }
		   
		   if ( CRandom::Random(0.0,1.0) < 0.9)
			   CrossoverNeighbor(iCount,&m_temp);
		   else
			   Crossover(&m_Pop[iCount], &BestSolutions[CRandom::Random(0,m_Pop[iCount].type)], & m_temp);
		   SetFitness(m_temp);
		   SaveBest(&m_temp);
		   IsParetoPoint = m_Elist.AddSolution(m_temp);
		   isBetter =Better(m_temp,m_Pop[iCount],m_Pop[iCount].type );
           if (IsParetoPoint) 
		   {
			   //			   if(m_Pop[iCount].type ==CSolution::OBJectiveNum )
			   //			   {
			   if ( WSMBetter(&m_temp,&m_Pop[iCount]) ) 
			   {
				   ReplaceSolution(iCount,m_temp);
				   continue;
			   }
			   //			   }
		   }
		   if (isBetter )  
		   {
			   ReplaceSolution(iCount,m_temp);
			   continue;
		   }
	   }
} 



void RTCGPS::RunStep7()
{
	   //PSO METHOD
	   CSolution m_temp(TRUE);
	   BOOL IsParetoPoint;
	   BOOL isBetter ;
	   int iCount;
	   ///Obtain the Best Solutions
       for (iCount=0;iCount< RTCGPS::PopSize ;iCount++)
	   {
		   for (int icnt2=0;icnt2 < CSolution::OBJectiveNum+1;icnt2++)
		   {
			   if (Better(m_Pop[iCount],BestSolutions[icnt2], icnt2) )
			   {
				   BestSolutions[icnt2].Copy(&m_Pop[iCount]);
			   }
		   }
	   }
	   
	   
	   
	   for (iCount=0;iCount< RTCGPS::PopSize-1 ;iCount++)
	   {
		   //		   CrossoverNeighbor(iCount,&m_temp);
           CSolution * Ind1;
           CSolution * Ind2;
		   if (Better(m_Pop[iCount],m_Pop[iCount+1], m_Pop[iCount].type) )
           {
			   Ind1 = &m_Pop[iCount];                  
			   Ind2 =&m_Pop[iCount +1];                  
		   }
		   else
		   {
			   Ind2 = &m_Pop[iCount];                  
			   Ind1 = &m_Pop[iCount+1];                  
		   }
		   
		   for (int iGene=0;iGene< CSolution::GetGeneLength();iGene++)
		   {
			   m_temp.Gene[iGene]=0;
			   double bco= CRandom::Random(-0.1,0.4);
               double gco= CRandom::Random(-0.1,0.4);
			   m_temp.Gene[iGene] = Ind2->Gene[iGene] + bco * ( BestSolutions->Gene[iGene] - Ind1->Gene[iGene]) + gco * (Ind1->Gene[iGene] - Ind2->Gene[iGene]);
		   }
		   SetFitness(m_temp);
		   IsParetoPoint = m_Elist.AddSolution(m_temp);
		   isBetter =Better(m_temp,m_Pop[iCount],m_Pop[iCount].type );
           if (isBetter)  
		   {
			   ReplaceSolution(iCount,m_temp);
			   continue;
		   }
           if (IsParetoPoint) 
		   {
			   double f1 =(m_temp.Objective[CSolution::OBJectiveNum]);
			   //			   f1+=  m_temp.Objective[m_Pop[iCount].type];
               double f2 = (m_Pop[iCount].Objective[CSolution::OBJectiveNum]);
			   //			   f2+= m_Pop[iCount].Objective[m_Pop[iCount].type];
			   if ( f1 < f2 ) 
			   {
				   ReplaceSolution(iCount,m_temp);
				   continue;
			   }	
		   }
	   }
	   
}

void RTCGPS::RunStep2()
{
	   CSolution m_temp(TRUE);
	   BOOL IsParetoPoint;
	   for (int iCount=0;iCount< RTCGPS::PopSize ;iCount++)
	   {
           Mutation(iCount,&m_temp);
		   SetFitness(m_temp);
		   IsParetoPoint = m_Elist.AddSolution(m_temp);
		   BOOL isBetter =Better(m_temp,m_Pop[iCount],m_Pop[iCount].type );
1234

⌨️ 快捷键说明

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