NSGAII别人的源程序.docx

NSGAII别人的源程序.docx

《NSGAII别人的源程序.docx》由会员分享，可在线阅读，更多相关《NSGAII别人的源程序.docx（15页珍藏版）》请在冰豆网上搜索。

NSGAII别人的源程序

#include

#include

#include

#include

#include

#include

#defineD10//基因维数

#definepopsize100//种群大小

#definegenetic2000//繁衍代数

#defineURAND（rand（）/（RAND_MAX+1.0））

#defineepx3.1415926#defineU_S20

intrand_int（intlow,inthight）;

doublerand_real（doublelow,doublehigh）;

intcmp1（constvoid*a,constvoid*b）;

intcmp2（constvoid*a,constvoid*b）;

intcmp3（constvoid*a,constvoid*b）;

inttemp1[popsize];intmark[popsize];

usingnamespacestd;classindivial{

public:

doublex[D];

intdomi[2*popsize],np,is_domied;//支配集合

voidinition（）;

intrank;

doublecrowding;

doublefintness[2];

voidfitness_count（）;

};indivialF[2*popsize][2*popsize];

classpopulation

{

public:

population（）;

indivialP[popsize];//当代

indivialQ[popsize];//产生的子代

indivialR[2*popsize];

intR_num;

voidset_p_q（）;

intP_num;

intQ_num;

voidnodominata_sort（）;//非支配排序

intlen[2*popsize];

intlen_f;

voidcrowding_distance（inti）;

voidsorts（inti）;

voidmake_new_pop（）;

voidfast_sort_nondominate（）;

voidcal（）;

intm_choice（inta,intb）;

};

boolis_dominated（constindivial&a,constindivial&b）;

intmain（）{

FILE*p;

p=fopen（"d:

\\1.txt","w+"）;

srand（（unsignedint）（time（0）））;

populationpop;

pop.cal（）;

inti;

cout<

intj;

for（i=0;i

{

fprintf（p,"第%d个个体\n",i）;

fprintf（p,"%f%f\n",pop.P[i].fintness[0],pop.P[i].fintness[1]）;

for（j=0;j

fprintf（p,"%e",pop.P[i].x[j]）;

fprintf（p,"\n"）;

}

fclose（p）;

return1;

}

voidindivial:

:

inition（）

{

inti;

for（i=0;i

x[i]=rand_real（0.0,1.0）;

}

population:

:

population（）

{

inti;

for（i=0;i

{

P[i].inition（）;

}

for（i=0;i

{

P[i].fitness_count（）;

}

P_num=popsize;

Q_num=0;

R_num=0;

}

voidpopulation:

:

make_new_pop（）

{

inti,j,x,y,t1,t2,t3;

doubles,u,b;

memset（mark,0,sizeof（mark））;

t3=0;

while（t3

{

while（t1=t2=rand_int（0,popsize-1）,mark[t1]）;

while（t1==t2||mark[t2]）

{t2=rand_int（0,popsize-1）;

}

t1=m_choice（t1,t2）;

temp1[t3++]=t1;

mark[t1]=1;

//printf（"__%d___",t1）;

}

//printf（"_______________%d__",t3）;

for（i=0;i

{

s=rand_real（0.0,1.0）;

if（s<=0.9）

{

for（j=0;j

{

u=rand_real（（0.0+1e-6）,（1.0-1e-6））;

if（u<=0.5）

{

b=pow（2*u,1.0/21）;

}

else

{

b=1.0/pow（2*（1-u）,1.0/21）;

}

x=y=rand_int（0,popsize/2-1）;

while（x==y）

y=rand_int（0,popsize/2-1）;

Q[i].x[j]=1.0/2*（（1-b）*P[temp1[x]].x[j]+（1+b）*P[temp1[y]].x[j]）;

if（Q[i].x[j]<0）

Q[i].x[j]=1e-6;

elseif（Q[i].x[j]>1）

Q[i].x[j]=1.0-（1e-6）;

if（i+1

{

Q[i+1].x[j]=1.0/2*（（1+b）*P[temp1[x]].x[j]+（1-b）*P[temp1[y]].x[j]）;

if（Q[i+1].x[j]<=0）

Q[i+1].x[j]=1e-6;

elseif（Q[i+1].x[j]>1）

Q[i+1].x[j]=（1-1e-6）;

}

}

i++;

}

else

{

for（j=0;j

{

x=rand_int（0,popsize/2-1）;

u=rand_real（0.0+（1e-6）,1.0-（1e-6））;

if（u<0.5）

{

u=pow（2*u,1.0/21）-1;

}

else

{

u=1-pow（2*（1-u）,1.0/21）;

}

Q[i].x[j]=P[temp1[x]].x[j]+（1.0-0.0）*u;

if（Q[i].x[j]<0）

Q[i].x[j]=1e-6;

elseif（Q[i].x[j]>1）

Q[i].x[j]=1-（1e-6）;

}

}

}

Q_num=popsize;

for（i=0;i

{

Q[i].fitness_count（）;

}

}

voidindivial:

:

fitness_count（）

{

fintness[0]=x[0];

inti;

doubleg=1,sum=0;

for（i=1;i

{

sum+=x[i];

}

sum=9*（sum/（D-1））;

g+=sum;

fintness[1]=g*（1-sqrt（x[0]/g））;

}

doublerand_real（doublelow,doublehigh）

{

doubleh;

h=（high-low）*URAND+low+0.001;

if（h>=high）

h=high-0.001;

returnh;

}

voidpopulation:

:

set_p_q（）

{

R_num=0;

Q_num=popsize;

inti;

for（i=0;i

{

R[R_num++]=P[i];

}

for（i=0;i

{

R[R_num++]=Q[i];

}

for（i=0;i<2*popsize;i++）

{

R[i].fitness_count（）;

}

}

voidpopulation:

:

nodominata_sort（）

{

inti,j,k;

indivialH[2*popsize];

inth_len=0;

for（i=0;i<2*popsize;i++）

{

R[i].np=0;

R[i].is_domied=0;

len[i]=0;

}

for（i=0;i<2*popsize;i++）

{

for（j=0;j<2*popsize;j++）

{

if（i!

=j）

{

if（is_dominated（R[i],R[j]））

{

R[i].domi[R[i].is_domied++]=j;

}

elseif（is_dominated（R[j],R[i]））

R[i].np+=1;

}

}

if（R[i].np==0）

{

len_f=1;

F[0][len[0]++]=R[i];

}

}

i=0;

while（len[i]!

=0）

{

h_len=0;

for（j=0;j

{

for（k=0;k

{

R[F[i][j].domi[k]].np--;

if（R[F[i][j].domi[k]].np==0）

{

H[h_len++]=R[F[i][j].domi[k]];

R[F[i][j].domi[k]].rank=i+1;

}

}

}

i++;

len[i]=h_len;

if（h_len!

=0）

{

len_f++;

for（j=0;j

{

F[i][j]=H[j];

}

}

}

}

boolis_dominated（constindivial&a,constindivial&b）

{

if（（a.fintness[0]<=b.fintness[0]）&&（a.fintness[1]<=b.fintness[1]））

{

if（（a.fintness[0]==b.fintness[0]）&&（a.fintness[1]==b.fintness[1]））

returnfalse;

returntrue;

}

elsereturnfalse;

}

voidpopulation:

:

crowding_distance（inti）

{

intn=len[i];

doublem_max,m_min;

intj;

for（j=0;j

{

F[i][j].crowding=0;

}

F[i][0].crowding=F[i][n-1].crowding=0xffffff;

qsort（F[i],n,sizeof（indivial）,cmp1）;

m_max=-0xfffff;

m_min=0xfffff;

for（j=0;j

{

if（m_max

m_max=F[i][j].fintness[0];

if（m_min>F[i][j].fintness[0]）

m_min=F[i][j].fintness[0];

}

for（j=1;j

{

F[i][j].crowding=F[i][j].crowding+（F[i+1][j].fintness[0]-F[i][j-1].fintness[0]）/（m_max-m_min）;

}

F[i][0].crowding=F[i][n-1].crowding=0xffffff;

qsort（F[i],n,sizeof（indivial）,cmp2）;

m_max=-0xfffff;

m_min=0xfffff;

for（j=0;j

{

if（m_max

m_max=F[i][j].fintness[1];

if（m_min>F[i][j].fintness[1]）

m_min=F[i][j].fintness[1];

}

for（j=2;j

{

F[i][j].crowding=F[i][j].crowding+（F[i+1][j].fintness[1]-F[i][j-1].fintness[1]）/（m_max-m_min）;

}

}

intcmp1（constvoid*a,constvoid*b）

{

constindivial*e=（constindivial*）a;

constindivial*f=（constindivial*）b;

if（e->fintness[0]==f->fintness[0]）

return0;

elseif（e->fintness[0]fintness[0]）

return-1;

elsereturn1;

}

intcmp2（constvoid*a,constvoid*b）

{

constindivial*e=（constindivial*）a;

constindivial*f=（constindivial*）b;

if（e->fintness[1]==f->fintness[1]）

return0;

elseif（e->fintness[1]fintness[1]）

return-1;

elsereturn1;

}

voidpopulation:

:

sorts（inti）

{

intn;

n=len[i];

qsort（F[i],n,sizeof（indivial）,cmp3）;

}

intcmp3（constvoid*a,constvoid*b）

{

constindivial*e=（constindivial*）a;

constindivial*f=（constindivial*）b;

if（e->crowding==f->crowding）

return0;

elseif（e->crowdingcrowding）

return1;

elsereturn-1;

}

intrand_int（intlow,inthight）

{

returnint（（hight-low+1）*URAND）+low;

}

voidpopulation:

:

cal（）

{

ints;

inti,j;

s=genetic;

make_new_pop（）;

while（s--）

{

printf（"第%d\n",s）;

set_p_q（）;

nodominata_sort（）;

P_num=0;

i=0;

while（P_num+len[i]<=popsize）

{

crowding_distance（i）;

for（j=0;j

{

P[P_num++]=F[i][j];

}

i++;

if（i>=len_f）break;

}

if（i

{

crowding_distance（i）;

sorts（i）;

}

for（j=0;j

{

P[P_num++]=F[i][j];

}

make_new_pop（）;

}printf（"S"）;

}

intpopulation:

:

m_choice（inta,intb）

{if（P[a].rank

returna;

elseif（P[a].rank==P[b].rank）

{

if（P[a].crowding>P[b].crowding）

returna;

elsereturnb;

}

returnb;

}