基本遗传算法的C源程序docWord下载.docx
《基本遗传算法的C源程序docWord下载.docx》由会员分享，可在线阅读，更多相关《基本遗传算法的C源程序docWord下载.docx（21页珍藏版）》请在冰豆网上搜索。
/*种群中个体最大适应度*/
doubleavg;
/*种群中个体平均适应度*/
doublemin;
/*种群中个体最小适应度*/
floatpcross;
/*交叉概率*/
floatpmutation;
/*变异概率*/
intpopsize;
/*种群大小*/
intlchrom;
/*染色体长度*/
intchromsize;
/*存储一染色体所需字节数*/
intgen;
/*当前世代数*/
intmaxgen;
/*最大世代数*/
intrun;
/*当前运行次数*/
intmaxruns;
/*总运行次数*/
intprintstrings;
/*输出染色体编码的判断，0--不输出,1--输出*/
intnmutation;
/*当前代变异发生次数*/
intncross;
/*当前代交叉发生次数*/
/*随机数发生器使用的静态变量*/
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];
setcolor（9）;
disp_hz16（"
种群大小（20-100）：
"
100,150,20）;
gscanf（320,150,9,15,4,"
%d"
&
popsize）;
if（（popsize%2）!
=0）
fprintf（outfp,"
种群大小已设置为偶数\n"
）;
popsize++;
染色体长度（8-40）：
100,180,20）;
gscanf（320,180,9,15,4,"
lchrom）;
是否输出染色体编码（y/n）：
100,210,20）;
printstrings=1;
gscanf（320,210,9,15,4,"
%s"
answer）;
if（strncmp（answer,"
n"
1）==0）printstrings=0;
最大世代数（100-300）：
100,240,20）;
gscanf（320,240,9,15,4,"
maxgen）;
交叉率（0.2-0.9）：
100,270,20）;
gscanf（320,270,9,15,5,"
%f"
pcross）;
变异率（0.01-0.1）：
100,300,20）;
gscanf（320,300,9,15,5,"
pmutation）;
voidinitpop（）/*随机初始化种群*/
intj,j1,k,stop;
unsignedmask=1;
for（j=0;
j<
popsize;
j++）
for（k=0;
k<
chromsize;
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"
-------------------------------------------------\n"
种群大小（popsize）=%d\n"
popsize）;
染色体长度（lchrom）=%d\n"
lchrom）;
最大进化代数（maxgen）=%d\n"
maxgen）;
交叉概率（pcross）=%f\n"
pcross）;
变异概率（pmutation）=%f\n"
pmutation）;
fflush（outfp）;
voidgeneration（）
intmate1,mate2,jcross,j=0;
/*每代运算前进行预选*/
preselect（）;
/*选择,交叉,变异*/
do
/*挑选交叉配对*/
mate1=select（）;
mate2=select（）;
/*交叉和变异*/
jcross=crossover（oldpop[mate1].chrom,oldpop[mate2].chrom,newpop[j].chrom,newpop[j+1].chrom）;
mutation（newpop[j].chrom）;
mutation（newpop[j+1].chrom）;
/*解码,计算适应度*/
（newpop[j]））;
/*记录亲子关系和交叉位置*/
newpop[j].parent[0]=mate1+1;
newpop[j].xsite=jcross;
newpop[j].parent[1]=mate2+1;
（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）
newpop"
/*分配给染色体内存空间*/
nbytes=chromsize*sizeof（unsigned）;
if（（oldpop[j].chrom=（unsigned*）malloc（nbytes））==NULL）
oldpopchromosomes"
if（（newpop[j].chrom=（unsigned*）malloc（nbytes））==NULL）
newpopchromosomes"
if（（bestfit.chrom=（unsigned*）malloc（nbytes））==NULL）
bestfitchromosome"
voidfreeall（）/*释放内存空间*/
inti;
for（i=0;
i<
i++）
free（oldpop[i].chrom）;
free（newpop[i].chrom）;
free（oldpop）;
free（newpop）;
free（bestfit.chrom）;
voidnomemory（string）/*内存不足，退出*/
char*string;
malloc:
outofmemorymaking%s!
!
\n"
string）;
exit（-1）;
voidreport（）/*输出种群统计结果*/
voidrepchar（）,skip（）;
voidwritepop（）,writestats（）;
repchar（outfp,"
-"
80）;
if（printstrings==1）
"
（（80-17）/2））;
模拟计算统计报告\n"
世代数%3d"
gen）;
（80-28））;
世代数%3d\n"
（gen+1））;
个体染色体编码"
lchrom-5）;
适应度父个体交叉位置"
染色体编码"
适应度\n"
writepop（outfp）;
第%d代统计:
\n"
gen）;
总交叉操作次数=%d,总变异操作数=%d\n"
ncross,nmutation）;
最小适应度：
%f最大适应度：
%f平均适应度%f\n"
min,max,avg）;
迄今发现最佳个体=>
所在代数：
%d"
bestfit.generation）;
适应度：
%f染色体：
bestfit.fitness）;
writechrom（（&
bestfit）->
chrom）;
对应的变量值:
%f"
bestfit.varible）;
voidwritepop（）
structindividual*pind;
for（j=0;
j{
%3d）"
j+1）;
/*当前代个体*/
pind=&
（oldpop[j]）;
writechrom（pind->
%8f|"
pind->
fitness）;
/*新一代个体*/
（newpop[j]）;
（%2d,%2d）%2d"
pind->
parent[0],pind->
parent[1],pind->
xsite）;
%8f\n"
voidwritechrom（chrom）/*输出染色体编码*/
intj,k,stop;
unsignedmask=1,tmp;
tmp=chrom[k];
stop;
if（tmp&
mask）
1"
0"
tmp=tmp>
>
voidpreselect（）
sumfitness=0;
j++）sumfitness+=oldpop[j].fitness;
intselect（）/*轮盘赌选择*/
externfloatrandomperc（）;
floatsum,pick;
pick=randomperc（）;
sum=0;
if（sumfitness!
（sum<
pick）&
&
（i<
popsize）;
sum+=oldpop[i].fitness/sumfitness;
i=rnd（1,popsize）;
return（i-1）;
voidstatistics（pop）/*计算种群统计数据*/
structindividual*pop;
inti,j;
sumfitness=0.0;
min=pop[0].fitness;
max=pop[0].fitness;
/*计算最大、最小和累计适应度*/
sumfitness=sumfitness+pop[j].fitness;
if（pop[j].fitness>
max）max=pop[j].fitness;
if（pop[j].fitness<
min）min=pop[j].fitness;
/*newglobalbest-fitindividual*/
bestfit.fitness）
bestfit.chrom[i]=pop[j].chrom[i];
bestfit.fitness=pop[j].fitness;
bestfit.varible=pop[j].varible;
bestfit.generation=gen;
/*计算平均适应度*/
avg=sumfitness/popsize;
voidtitle（）
settextstyle（0,0,4）;
gprintf（110,15,4,0,"
SGAOptimizer"
disp_hz24（"
基本遗传算法"
220,60,25）;
voidrepchar（outfp,ch,repcount）
FILE*outfp;
char*ch;
intrepcount;
for（j=1;
=repcount;
j++）fprintf（outfp,"
ch）;
voidskip（outfp,skipcount）
intskipcount;
=skipcount;
voidobjfunc（critter）/*计算适应度函数值*/
structindividual*critter;
unsignedmask=1;
unsignedbitpos;
unsignedtp;
doublepow（）,bitpow;
critter->
varible=0.0;
stop=lchrom-（k*（8*sizeof（unsigned）））;
tp=critter->
chrom[k];
bitpos=j+（8*sizeof（unsigned））*k;
if（（tp&
mask）==1）
升级会员 