hfc.m

研究基于遗传编程的可持续性进化算法的理论与方法

void main() //主函数
{
if(g->bAdaptiveHFC ==false){ //使用SHFC 静态输入阀值
for(i=0;i<mpop->size;i++){
sprintf(pnamebuf,"subpop[%d].admission_fitness",i+1);
param = get_parameter ( pnamebuf);
if ( param == NULL ){
subpop_admission_fitness.push_back(NEGATIVE_LARGE);
int level = locate_level(NEGATIVE_LARGE, *mpop->pHF);
if(level<0){
CLevel* pLevelObj = new CLevel(NEGATIVE_LARGE);
mpop->pHF->insert(mpop->pHF->begin(),pLevelObj);
}
}
else{
double fitness = atof(param);
subpop_admission_fitness.push_back(fitness);//
int level = locate_level(fitness, *mpop->pHF);
if(level<0){
if((*mpop->pHF).size()!=0){
vector<CLevel*>::iterator jk;
for(jk=(*mpop->pHF).end()-1;jk>=(*mpop->pHF).begin();jk--){
double fff = (*jk)->admission_fitness;
if( fitness > (*jk)->admission_fitness &&jk==mpop->pHF->end()-1){
mpop->pHF->push_back(new CLevel(fitness));
break;
}
else if(jk!=mpop->pHF->begin()){
if(fitness >(*(jk-1))->admission_fitness){
mpop->pHF->insert(jk,new CLevel(fitness));
break;
}
}
else{
mpop->pHF->insert(mpop->pHF->begin(),new CLevel(fitness));
}
}
}
else{
CLevel* pLevelObj = new CLevel(fitness);
mpop->pHF->insert(mpop->pHF->begin(),pLevelObj);
}
}
}
}
for (j=0;j<mpop->pHF->size();j++){
(*mpop->pHF)[j]->level= j;
}
for(i=0;i<mpop->size;i++){
int nlevel = mpop->pHF->size();
for(int level = 0;level<nlevel;level++){
individual a;
a.s_fitness = subpop_admission_fitness[i];
if(IsAdmitted(&a, level,mpop)){
(*mpop->pHF)[level]->subpop_list.push_back(i);
break;
}
}
}
}
//使用自适应的HFC算法，动态的改变输入阀值
else{
param = get_parameter ( "multiple.HFCPM.adaptive.adaptation_rate" );
if(param ==NULL){
mpop->pHF->adaptationRate = 0.8;
}
else{
mpop->pHF->adaptationRate = atof(param);
}
int levels;
int subpops = mpop->size;
param = get_parameter ( "multiple.HFCPM.adaptive.level" );
if(param == NULL){
levels = mpop->size;
for(int i=0;i<levels;i++){
CLevel* pLevel = new CLevel(NEGATIVE_LARGE);
pLevel->subpop_list.push_back(i);
mpop->pHF->insert(mpop->pHF->begin(),pLevel);
}
}
else{
levels = atof(param);
if(subpops<levels){
for(int i=0;i<subpops;i++){
CLevel* pLevel = new CLevel(NEGATIVE_LARGE);
pLevel->subpop_list.push_back(i);
mpop->pHF->insert(mpop->pHF->begin(),pLevel);
}
}
else{
for(int i=0;i<levels;i++){
CLevel* pLevel = new CLevel(NEGATIVE_LARGE);
mpop->pHF->insert(mpop->pHF->begin(),pLevel);
}
int surplusSubpops = subpops%levels;
int subpopOfEachLevel = subpops/levels;
int currentSubpop = subpops-1;
for(i=levels-1;i>=0;i--){
for(int j=0;j<subpopOfEachLevel;j++){
(*mpop->pHF)[i]->subpop_list.push_back(currentSubpop);
currentSubpop--;
}
if(surplusSubpops!=0){
(*mpop->pHF)[i]->subpop_list.push_back(currentSubpop);
currentSubpop--;
surplusSubpops--;
}
}
}
}
for (j=0;j<mpop->pHF->size();j++){
(*mpop->pHF)[j]->level= j;
}
}
for( i=0;i<subpop_admission_fitness.size();i++){
printf(" subpop %d = admission fit %f\n", i+1, subpop_admission_fitness[i]);
}
report_HFC_topology(mpop);
}
int app_build_function_sets ( void ) //设置维持GP树生长的函数集
{
function sets[] =
{ { f_Tree, NULL, NULL, 2, "Tree", FUNC_EXPR, -1, 0, OP_ROOT,
{OP_EDGE,OP_NODE,0,0,0,0} },
{ f_insertV, NULL, NULL, 5, "insV", FUNC_EXPR, -1, 1, OP_EDGE,
{OP_EDGE,OP_NODE,OP_EDGE,OP_REAL, OP_REAL,0} },
{ f_attachV, NULL, NULL, 5, "attV", FUNC_EXPR, -1, 5, OP_NODE,
{OP_NODE,OP_EDGE,OP_NODE,OP_REAL,OP_REAL,0} },
{ f_endV, NULL, NULL, 0, "endV", TERM_NORM, -1, 8,OP_NODE,
{0,0,0,0,0,0} },
{ f_endE, NULL, NULL, 0, "endE", TERM_NORM, -1, 9,OP_EDGE,
{0,0,0,0,0,0} },
{ NULL, f_erc_gen, f_erc_print,0, "erc", TERM_ERC, -1, 10,OP_REAL,
{0,0,0,0,0,0}},
{ f_add, NULL, NULL, 2, "+", FUNC_DATA, -1, 11,
OP_REAL, {OP_REAL,OP_REAL,0,0,0,0} },
{ f_sub, NULL, NULL, 2, "-", FUNC_DATA, -1, 12,OP_REAL,
{OP_REAL,OP_REAL,0,0,0,0} },
{ f_mul, NULL, NULL, 2, "*", FUNC_DATA, -1, 13,OP_REAL,
{OP_REAL,OP_REAL,0,0,0,0} },
{ f_div, NULL, NULL, 2, "/", FUNC_DATA, -1, 14,OP_REAL,
{OP_REAL,OP_REAL,0,0,0,0} },
};
fset.size = 10;
fset.cset = sets;
tree_map.fset=0;
tree_map.return_type=0;
tree_map.name = "TREE";
return function_sets_init ( &fset, 1, &tree_map, 1 );
}
void app_eval_fitnes_parameter ( individual *ind ) //评价个体适应度值
{
app_before_evaluate_individual();
globaldata* g = get_globaldata();
(*(FitnessMapping[g->current_population].app_eval_fitness))(ind);
app_end_of_evaluate_individual();
}
void app_eval_fitness_struct( individual *ind ) //评价结构适应度值
{
app_eval_fitness_parameter(ind);
}
double computefitness(CityRouterDef &router) //计算个体适应度值
{
double fitness=0.0;
if(router.size()==50)
for(vector<int>::iterator i=router.begin ();(i+1)!=router.end ();i++)
{
double distance=0.0;
double x=(double)(CityCoodinate[*i][0]-CityCoodinate[*(i+1)][0]);
double y=(double) (CityCoodinate[*i][1]-CityCoodinate[*(i+1)][1]);
distance=sqrt(x*x+y*y);
fitness=fitness+distance;
}
return fitness;
}
void InitializeEmbryo(Individual &ind) //初始化
{
for(int i=0;i<CityNumber;i++)
ind.CityRouter.push_back(i);
ind.setfitness(computefitness(ind.CityRouter));
}
int judgeLevel(Individual &ind,Population pop[Levels]) //判断个体等级
{
for(int i=Levels-1;i>=0;i--)
{
if(ind.getfitness ()<=pop[i].getAdmission ())
{
ind.setLevel(i);
return i;
}
}
return 0;
}
void app_end_of_breeding ( int gen, multipop *mpop ) //繁殖个体
{
return;
}
int app_create_output_streams ( void )
{
return 0;
}
int select_tournament ( sel_context *sc ) //个体竞争 锦标赛选择
{
int i, j, k;
tournament_data *td;
population *p;
td = (tournament_data *)(sc->data);
p = sc->p;
j = -1;
for ( i = 0; i < td->count; ++i )
{
k = random_int ( p->size );
if ( j == -1 || p->ind[k].a_fitness > p->ind[j].a_fitness )
j = k;
}
return j;
}
void Crossover ( int nMode ) //交叉
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
double fProbability = CROSSOVER_P; //交叉概率
std::vector<int> vecCrossoverIndexs;
//int nPopSize = vecPop.size();
double random;
for(int j=0;j<Levels;j++)
for(vector<int>::iterator i=population[j].PopIndex.begin();i!=population[j].PopIndex.end();i++)
{
random = ((double)(rand()%10000))/10000.0;
if( random < fProbability )
vecCrossoverIndexs.push_back( *i );
}
int CrossoverNumber = vecCrossoverIndexs.size();
if( CrossoverNumber%2 != 0 )
vecCrossoverIndexs.pop_back();
CrossoverNumber = vecCrossoverIndexs.size();
for(int i=0;i<CrossoverNumber;i=i+2)
{
int nFatherA = vecCrossoverIndexs[i];
int nFatherB = vecCrossoverIndexs[i+1];
CString strTemp1, strTemp2;
strTemp1 = FormRouterString( society[nFatherA].CityRouter );
strTemp2 = FormRouterString( society[nFatherB].CityRouter );
Crossover( nFatherA, nFatherB, nMode );
strTemp1 = FormRouterString( society[nFatherA].CityRouter );
strTemp2 = FormRouterString( society[nFatherB].CityRouter );
}
}
void Mutation ( int nMode ) //变异操作
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
double fProbability = MUTATION_P; //变异概率
std::vector<int> vecMutationIndexs;
//int nPopSize = vecPop.size();
double random;
for(int j=0;j<Levels;j++)
for(vector<int>::iterator i=population[j].PopIndex.begin();i!=population[j].PopIndex.end();i++)
{
random = ((double)(rand()%10000))/10000.0;
if( random < fProbability )
vecMutationIndexs.push_back( *i );
}
int MutationNumber = vecMutationIndexs.size();
for(int i=0;i<MutationNumber;i++ )
{
int randombegin;
int randomend;
while(1)
{
randombegin = rand()%(CityNumber-1);
randomend = rand()%(CityNumber-1);
if( randombegin < randomend )
break;
else if( randombegin > randomend )
{
std::swap( randombegin, randomend );
break;
}
}
std::random_shuffle( society[vecMutationIndexs[i]].CityRouter.m_CityRouter.begin()+randombegin,
society[vecMutationIndexs[i]].CityRouter.m_CityRouter.begin()+randomend );
society[vecMutationIndexs[i]].fitness =
CountTotalDistance( society[vecMutationIndexs[i]].CityRouter.m_CityRouter );
}
void read_gp_run_option() //选择要使用的进化算法
{
paramString = get_parameter ( "multiple.SHFCPM" );//使用静态的HFC算法
if(paramString==NULL)
g->bSUseHFC=false;
else{
      int i=atoi(paramString);
if(i!=0){
g->bUseHFC=true;
}
else
g->bUseSHFC=false;
}
if(g->bUseHFC==true){
paramString = get_parameter ( "multiple.HFCPM.adaptive" );//使用自适应的HFC算法
if(paramString==NULL)
g->bAdaptiveHFC=false;
else{
int i=atoi(paramString);
if(i!=0){
g->bAdaptiveHFC=true;
}
else
g->bAdaptiveHFC=false;
}
}
paramString = get_parameter ( "bUseSFS" );//使用SFS方法
if(paramString==NULL)
g->bUseSFS=false;
else{
int i=atoi(paramString);
if(i!=0){
g->bUseSFS=true;
}
else
g->bUseSFS=false;
}
}