自适应遗传算法代码.docx
《自适应遗传算法代码.docx》由会员分享，可在线阅读，更多相关《自适应遗传算法代码.docx（30页珍藏版）》请在冰豆网上搜索。
自适应遗传算法代码
/**********************************************************************/
/*基于基本遗传算法的自适应遗传优化算法函数最优化SGA_AUTO.C*/
/*AFunctionOptimizerusingSimpleGeneticAlgorithm*/
/*developedfromthePascalSGAcodepresentedbyDavidE.Goldberg*/
/*华南理工大学电子与信息学院苏勇2004年4月*/
/**********************************************************************/
#include
#include
/*全局变量*/
structindividual/*个体*/
{
unsigned*chrom;/*染色体*/
doublefitness;/*个体适应度*/
doublevarible;/*个体对应的变量值*/
intxsite;/*交叉位置*/
intparent[2];/*父个体*/
int*utility;/*特定数据指针变量*/
};
structbestever/*最佳个体*/
{
unsigned*chrom;/*最佳个体染色体*/
doublefitness;/*最佳个体适应度*/
doublevarible;/*最佳个体对应的变量值*/
intgeneration;/*最佳个体生成代*/
};
structindividual*oldpop;/*当前代种群*/
structindividual*newpop;/*新一代种群*/
structbesteverbestfit;/*最佳个体*/
doublesumfitness;/*种群中个体适应度累计*/
doublemax;/*种群中个体最大适应度*/
doubleavg;/*种群中个体平均适应度*/
doublemin;/*种群中个体最小适应度*/
floatpcross;/*交叉概率*/
floatpmutation;/*变异概率*/
intpopsize;/*种群大小*/
intlchrom;/*染色体长度*/
intchromsize;/*存储一染色体所需字节数*/
intgen;/*当前世代数*/
intmaxgen;/*最大世代数*/
intrun;/*当前运行次数*/
intmaxruns;/*总运行次数*/
intprintstrings;/*输出染色体编码的判断，0--不输出,1--输出*/
intnmutation;/*当前代变异发生次数*/
intncross;/*当前代交叉发生次数*/
floatpc1;
floatpc2;
floatpm1;
floatpm2;
inttemp_mate1;
inttemp_mate2;
/*随机数发生器使用的静态变量*/
staticdoubleoldrand[55];
staticintjrand;
staticdoublerndx2;
staticintrndcalcflag;
/*输出文件指针*/
FILE*outfp;
/*函数定义*/
voidadvance_random（）;
intflip（float）;rnd（int,int）;
voidrandomize（）;
doublerandomnormaldeviate（）;
floatrandomperc（）,rndreal（float,float）;
voidwarmup_random（float）;
voidinitialize（）,initdata（）,initpop（）;
voidinitreport（）,generation（）,initmalloc（）;
voidfreeall（）,nomemory（char*）,report（）;
voidwritepop（）,writechrom（unsigned*）;
voidpreselect（）;
voidstatistics（structindividual*）;
voidtitle（）,repchar（FILE*,char*,int）;
voidskip（FILE*,int）;
intselect（）;
voidobjfunc（structindividual*）;
intcrossover（unsigned*,unsigned*,unsigned*,unsigned*）;
voidmutation（unsigned*）;
voidinitialize（）/*遗传算法初始化*/
{
/*键盘输入遗传算法参数*/
initdata（）;
/*确定染色体的字节长度*/
chromsize=（lchrom/（8*sizeof（unsigned）））;
if（lchrom%（8*sizeof（unsigned）））chromsize++;
/*分配给全局数据结构空间*/
initmalloc（）;
/*初始化随机数发生器*/
randomize（）;
/*初始化全局计数变量和一些数值*/
nmutation=0;
ncross=0;
bestfit.fitness=0.0;
bestfit.generation=0;
/*初始化种群，并统计计算结果*/
initpop（）;
statistics（oldpop）;
initreport（）;
}
voidinitdata（）/*遗传算法参数输入*/
{
charanswer[2];
popsize=30;
if（（popsize%2）!
=0）
{
fprintf（outfp,"种群大小已设置为偶数\n"）;
popsize++;
};
lchrom=22;
printstrings=1;
maxgen=150;
pcross=0.8;
pc1=0.8;
pc2=0.6;
pmutation=0.05;
pm1=0.05;
pm2=0.005;
}
voidinitpop（）/*随机初始化种群*/
{
intj,j1,k,stop;
unsignedmask=1;
for（j=0;j{
for（k=0;k{
oldpop[j].chrom[k]=0;
if（k==（chromsize-1））
stop=lchrom-（k*（8*sizeof（unsigned）））;
else
stop=8*sizeof（unsigned）;
for（j1=1;j1<=stop;j1++）
{
oldpop[j].chrom[k]=oldpop[j].chrom[k]<<1;
if（flip（0.5））
oldpop[j].chrom[k]=oldpop[j].chrom[k]|mask;
}
}
oldpop[j].parent[0]=0;/*初始父个体信息*/
oldpop[j].parent[1]=0;
oldpop[j].xsite=0;
objfunc（&（oldpop[j]））;/*计算初始适应度*/
}
}
voidinitreport（）/*初始参数输出*/
{
voidskip（）;
skip（outfp,1）;
fprintf（outfp,"基本遗传算法参数\n"）;
fprintf（outfp,"-------------------------------------------------\n"）;
fprintf（outfp,"种群大小（popsize）=%d\n",popsize）;
fprintf（outfp,"染色体长度（lchrom）=%d\n",lchrom）;
fprintf（outfp,"最大进化代数（maxgen）=%d\n",maxgen）;
fprintf（outfp,"交叉概率（pcross）=%f\n",pcross）;
fprintf（outfp,"变异概率（pmutation）=%f\n",pmutation）;
fprintf（outfp,"-------------------------------------------------\n"）;
skip（outfp,1）;
fflush（outfp）;
}
voidgeneration（）
{
intmate1,mate2,jcross,j=0;
/*每代运算前进行预选*/
preselect（）;
/*选择,交叉,变异*/
do
{
/*挑选交叉配对*/
mate1=select（）;
temp_mate1=mate1;
mate2=select（）;
temp_mate2=mate2;
/*交叉和变异*/
jcross=crossover（oldpop[mate1].chrom,oldpop[mate2].chrom,newpop[j].chrom,newpop[j+1].chrom）;
/*自适应变异概率*/
if（gen!
=0）
{
if（newpop[j].fitness>=avg）
pmutation=pm1-（pm1-pm2）*（max-newpop[j].fitness）/（max-avg）;
else
pmutation=pm1;
}
mutation（newpop[j].chrom）;
if（gen!
=0）
{
if（newpop[j+1].fitness>=avg）
pmutation=pm1-（pm1-pm2）*（max-newpop[j+1].fitness）/（max-avg）;
else
pmutation=pm1;
}
mutation（newpop[j+1].chrom）;
/*解码,计算适应度*/
objfunc（&（newpop[j]））;
/*记录亲子关系和交叉位置*/
newpop[j].parent[0]=mate1+1;
newpop[j].xsite=jcross;
newpop[j].parent[1]=mate2+1;
objfunc（&（newpop[j+1]））;
newpop[j+1].parent[0]=mate1+1;
newpop[j+1].xsite=jcross;
newpop[j+1].parent[1]=mate2+1;
j=j+2;
}
while（j<（popsize-1））;
}
voidinitmalloc（）/*为全局数据变量分配空间*/
{
unsignednbytes;
char*malloc（）;
intj;
/*分配给当前代和新一代种群内存空间*/
nbytes=popsize*sizeof（structindividual）;
if（（oldpop=（structindividual*）malloc（nbytes））==NULL）
nomemory（"oldpop"）;
if（（newpop=（structindividual*）malloc（nbytes））==NULL）
nomemory（"newpop"）;
/*分配给染色体内存空间*/
nbytes=chromsize*sizeof（unsigned）;
for（j=0;j{
if（（oldpop[j].chrom=（unsigned*）malloc（nbytes））==NULL）
nomemory（"oldpopchromosomes"）;
if（（newpop[j].chrom=（unsigned*）malloc（nbytes））==NULL）
nomemory（"newpopchromosomes"）;
}
if（（bestfit.chrom=（unsigned*）malloc（nbytes））==NULL）
nomemory（"bestfitchromosome"）;
}
voidfreeall（）/*释放内存空间*/
{
inti;
for（i=0;i{
free（oldpop[i].chrom）;
free（newpop[i].chrom）;
}
free（oldpop）;
free（newpop）;
free（bestfit.chrom）;
}
voidnomemory（string）/*内存不足，退出*/
char*string;
{
fprintf（outfp,"malloc:
outofmemorymaking%s!
!
\n",string）;
exit（-1）;
}
voidreport（）/*输出种群统计结果*/
{
voidrepchar（）,skip（）;
voidwritepop（）,writestats（）;
repchar（outfp,"-",80）;
skip（outfp,1）;
if（printstrings==1）
{
repchar（outfp,"",（（80-17）/2））;
fprintf（outfp,"模拟计算统计报告\n"）;
fprintf（outfp,"世代数%3d",gen）;
repchar（outfp,"",（80-28））;
fprintf（outfp,"世代数%3d\n",（gen+1））;
fprintf（outfp,"个体染色体编码"）;
repchar（outfp,"",lchrom-5）;
fprintf（outfp,"适应度父个体交叉位置"）;
fprintf（outfp,"染色体编码"）;
repchar（outfp,"",lchrom-5）;
fprintf（outfp,"适应度\n"）;
repchar（outfp,"-",80）;
skip（outfp,1）;
writepop（outfp）;
repchar（outfp,"-",80）;
skip（outfp,1）;
}
fprintf（outfp,"第%d代统计:
\n",gen）;
fprintf（outfp,"总交叉操作次数=%d,总变异操作数=%d\n",ncross,nmutation）;
fprintf（outfp,"最小适应度：
%f最大适应度：
%f平均适应度%f\n",min,max,avg）;
fprintf（outfp,"迄今发现最佳个体=>所在代数：
%d",bestfit.generation）;
fprintf（outfp,"适应度：
%f染色体：
",bestfit.fitness）;
writechrom（（&bestfit）->chrom）;
fprintf（outfp,"对应的变量值:
%f",bestfit.varible）;
skip（outfp,1）;
repchar（outfp,"-",80）;
skip（outfp,1）;
}
voidwritepop（）
{
structindividual*pind;
intj;
for（j=0;j{
fprintf（outfp,"%3d）",j+1）;
/*当前代个体*/
pind=&（oldpop[j]）;
writechrom（pind->chrom）;
fprintf（outfp,"%8f|",pind->fitness）;
/*新一代个体*/
pind=&（newpop[j]）;
fprintf（outfp,"（%2d,%2d）%2d",
pind->parent[0],pind->parent[1],pind->xsite）;
writechrom（pind->chrom）;
fprintf（outfp,"%8f\n",pind->fitness）;
}
}
voidwritechrom（chrom）/*输出染色体编码*/
unsigned*chrom;
{
intj,k,stop;
unsignedmask=1,tmp;
for（k=0;k{
tmp=chrom[k];
if（k==（chromsize-1））
stop=lchrom-（k*（8*sizeof（unsigned）））;
else
stop=8*sizeof（unsigned）;
for（j=0;j{
if（tmp&mask）
fprintf（outfp,"1"）;
else
fprintf（outfp,"0"）;
tmp=tmp>>1;
}
}
}
voidpreselect（）
{
intj;
sumfitness=0;
for（j=0;j}
intselect（）/*轮盘赌选择*/
{
externfloatrandomperc（）;
floatsum,pick;
inti;
pick=randomperc（）;
sum=0;
if（sumfitness!
=0）
{
for（i=0;（sumsum+=oldpop[i].fitness/sumfitness;
}
else
i=rnd（1,popsize）;
return（i-1）;
}
voidstatistics（pop）/*计算种群统计数据*/
structindividual*pop;
{
inti,j;
sumfitness=0.0;
min=pop[0].fitness;
max=pop[0].fitness;
/*计算最大、最小和累计适应度*/
for（j=0;j{
sumfitness=sumfitness+pop[j].fitness;
if（pop[j].fitness>max）max=pop[j].fitness;
if（pop[j].fitness/*newglobalbest-fitindividual*/
if（pop[j].fitness>bestfit.fitness）
{
for（i=0;ibestfit.chrom[i]=pop[j].chrom[i];
bestfit.fitness=pop[j].fitness;
bestfit.varible=pop[j].varible;
bestfit.generation=gen;
}
}
/*计算平均适应度*/
avg=sumfitness/popsize;
}
voidtitle（）
{
printf（"SGAOptimizerJean.Timex\n"）;
}
voidrepchar（outfp,ch,repcount）
FILE*outfp;
char*ch;
intrepcount;
{
intj;
for（j=1;j<=repcount;j++）fprintf（outfp,"%s",ch）;
}
voidskip（outfp,skipcount）
FILE*outfp;
intskipcount;
{
intj;
for（j=1;j<=skipcount;j++）fprintf（outfp,"\n"）;
}
voidobjfunc（critter）/*计算适应度函数值*/
structindividual*critter;
{
unsignedmask=1;
unsignedbitpos;
unsignedtp;
doublepow（）,bitpow;
intj,k,stop;
critter->varible=0.0;
for（k=0;k{
if（k==（chromsize-1））
stop=lchrom-（k*（8*sizeof（unsigned）））;
else
stop=8*sizeof（unsigned）;
tp=critter->chrom[k];
for（j=0;j{
bitpos=j+（8*sizeof（unsigned））*k;
if（（tp&mask）==1）
{
bitpow=pow（2.0,（double）bitpos）;
critter->varible=critter->varible+bitpow;
}
tp=tp>>1;
}
}
critter->varible=-1+critter->varible*3/（pow（2.0,（double）lchrom）-1）;
升级会员 