标准遗传算法-c++源程序.doc

(完整word)标准遗传算法 c++源程序
#include〈stdio.h>
#include<stdlib.h>
＃include<time.h>
#include<fstream。h〉
#include<windows。h〉

＃define POPSIZE 500
＃define MAXIMIZATION 1
＃define MINIMIZATION 2

＃define random(x） （rand(）%（x））

#define Cmax 100 /＊最大值函数适应度的设置*/
#define Cmin 0 /*最小值函数适应度的设置*/
＃define LENGTH1 10
#define LENGTH2 10
#define CHROMLENGTH LENGTH1+LENGTH2
int FunctionMode=MAXIMIZATION;
/*optimization type即函数类型，是求最大值函数还是最小值函数＊/
int a=100；
int PopSize=80;
int MaxGeneration=200;
double Pc=0。6;
double Pm=0.001;

struct individual
｛
char chrom[CHROMLENGTH+1］;
double value;
double fitness；
｝；

int generation；
int best_index；
int worst_index；
struct individual bestindividual;
struct individual worstindividual；
struct individual currentbest；
struct individual population[POPSIZE］；

void GenerateInitialPopulation(void)；
void GenerateNextPopulation（void）；
void EvaluatePopulation(void）;
long DecodeChromosome（char *,int,int);
void CaculateObjectValue（void）；
void CaculateFitnessValue(void）；
void FindBestAndWorstIndividual（void）;
void PerformEvolution（void）；
void SelectionOperator(void);
void CrossoverOperator(void)；
void MutationOperator（void）;
void OutputTextReport(void）;

void main（）
｛
srand(（unsigned）time(NULL)）; //随时间而改变随机数
generation=0;
GenerateInitialPopulation（）；
EvaluatePopulation（);
while（generation<MaxGeneration)
｛
generation++;
GenerateNextPopulation（）；
EvaluatePopulation（);
PerformEvolution(）;
OutputTextReport（）；
}
}

void GenerateInitialPopulation（void)
{
int i,j;
for（i=0；i〈PopSize；i++）
{
for(j=0;j<CHROMLENGTH;j++）
｛
population[i］.chrom［j]=(random（10）<5)?'1':’0';
｝
population［i].chrom[CHROMLENGTH］=’\0';
}
}

void GenerateNextPopulation（void）
{
SelectionOperator（）;
CrossoverOperator();
MutationOperator（）；
｝

void EvaluatePopulation（void）
｛
CaculateObjectValue（)；
CaculateFitnessValue（）；
FindBestAndWorstIndividual（);
}

long DecodeChromosome（char *string,int point，int length）
{
int i；
long decimal=0;
char ＊pointer；
for（i=0，pointer=string+point；i<length；i++，pointer++)
{
decimal+=（＊pointer—'0')<〈（length—1—i）；
}
return(decimal）；
}

void CaculateObjectValue（void)
{
int i；
long temp1，temp2；
double x1，x2;
for（i=0；i<PopSize；i++)
｛
temp1=DecodeChromosome(population［i］。chrom,0,LENGTH1）;
temp2=DecodeChromosome(population［i］.chrom,LENGTH1,LENGTH2);
x1=4.096*temp1/1023。0-2。048；
x2=4.096*temp2/1023。0—2。048;
population[i］。value=100*(x1＊x1—x2)＊（x1*x1-x2）+(1—x1)*(1-x1)；
｝
｝

void CaculateFitnessValue(void）
｛
int i;
double temp;
for(i=0;i<PopSize；i++）
{
if(FunctionMode==MAXIMIZATION）
{
if((population［i］.value+Cmin)>0。0）
｛
temp=Cmin+population[i］。value；
｝
else temp=0.0；
｝
if(FunctionMode==MINIMIZATION）
｛
if（population[i］。value〈Cmax）
｛
temp=Cmax-population[i]。value;
｝
else temp=0.0；
｝
population［i］.fitness=temp;
｝
｝

void FindBestAndWorstIndividual(void)
｛
int i；
double sum=0。0；
bestindividual=population[0]；
worstindividual=population［0］;
for(i=1;i〈PopSize;i++)
{
if(population［i]。fitness〉bestindividual。fitness)
{
bestindividual=population[i］；
best_index=i；
}
if(population[i]。fitness〈worstindividual.fitness）
{
worstindividual=population[i]；
worst_index=i;
}
sum+=population[i]。fitness；
}
if(generation==0） currentbest=bestindividual；
else
{
if(bestindividual。fitness>currentbest。fitness) currentbest=bestindividual；
}
}

void PerformEvolution(void)
{
if（bestindividual。fitness>currentbest.fitness) currentbest=population[best_index］;
else population[worst_index]=currentbest;
｝

void SelectionOperator（void)
{
int i,index；
double p；
double sum=0。0；
double cfitness［POPSIZE］;
struct individual newpopulation[POPSIZE]；
for(i=0;i<PopSize；i++) sum+=population［i］。fitness;
for（i=0;i〈PopSize；i++) cfitness［i］=population[i]。fitness/sum;
for(i=1；i<PopSize;i++) cfitness[i]=cfitness[i-1］+cfitness[i];
for（i=0；i〈PopSize；i++)
｛
p=(rand(））/（double)（RAND_MAX）；；
index=0;
while(p>cfitness[index]） index++；
newpopulation[i］=population[index］；
}
for（i=0；i〈PopSize；i++) population［i］=newpopulation[i］；
｝

void CrossoverOperator（void)
{
int i，j；
int index[POPSIZE];
int point,temp;
double p；
char ch；
for(i=0;i〈PopSize；i++) index［i]=i;
for(i=0；i<PopSize;i++)
{
point=random（PopSize-i);/＊random(PopSize-1）=rand()％(PopSize—1)＊/
temp=index［i];
index[i］=index［point+i];
index［point+i]=temp；
}
/＊循环实现种群内随机两两交换打乱种群顺序*/
for(i=0；i〈PopSize；i+=2)
｛
p=（rand()）/（double）（RAND_MAX);;
if（p〈Pc）
｛
point=rand()％(CHROMLENGTH-1）+1；//random(CHROMLENGTH-1）+1；
for(j=point;j<CHROMLENGTH;j++）
｛
ch=population[index［i]]。chrom［j］;
population[index[i]].chrom［j］=population[index［i+1]]。chrom[j]；
population[index［i+1]].chrom[j]=ch;
｝
｝
}
}

void MutationOperator（void）
{
int i,j;
double p；
for（i=0;i〈PopSize；i++）
｛
for(j=0;j〈CHROMLENGTH；j++)
{
p=(rand（））/(double）(RAND_MAX）;；
if(p〈Pm)
{
population［i］。chrom[j]=（population[i]。chrom[j]=='0’）？'1’：'0’;

}
}
｝
｝

void OutputTextReport（void）
｛
int i=0；
double average;
fstream kan_table;
kan_table。open(”f：\\kan_table。txt”，ios:：app｜ios：：out）；
double sum；
sum=0。0；
for（i=0;i<PopSize;i++)
sum+=population[i］.value；
average=sum/PopSize;
kan_table〈<”gen=”〈〈generation〈〈"，”；
kan_table〈〈"ave=”<〈average<〈”，”；
kan_table<<”"<<currentbest.value〈〈","；
kan_table<<endl；
printf(”gen=％d,ave=％f，best=%f，"，generation，average,currentbest。value)；
printf(”chromosome=”);
for（i=0；i〈CHROMLENGTH;i++）
printf（”％c”，currentbest.chrom［i］）；
printf(”\n”)；
｝