📄 population.h
字号:
// population.h: interface for the population class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_POPULATION_H__EBC520C7_10A5_11D4_BAC1_9349EAE2243A__INCLUDED_)
#define AFX_POPULATION_H__EBC520C7_10A5_11D4_BAC1_9349EAE2243A__INCLUDED_
#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000
/////////////////////////////////////////////////////////////////////////
#include <stdlib.h>
#include <time.h>
#define GEN_LENGTH 8 //基因串长度
#define N_PARAMETER 1 //代表参数的个数
#define CODE_LENGTH 8 //每个参数基因编码长度
#define P_MUTATION 0.001 //变异率
#define P_MATING 0.5 //杂交率
///////////////////////////////////////////////////////
// INDIVIDUAL POPULAION CALSS //
// 个体类定义 //
///////////////////////////////////////////////////////
class population
{
public:
double fitness;//适应度
unsigned int gen_chain1[GEN_LENGTH],gen_chain2[GEN_LENGTH];//双链基因
unsigned int decode_chain[GEN_LENGTH];//译码基因
double x[N_PARAMETER];//参数实际值
public:
population();
void initial(void);//个体初始化函数
void fitness_function(void);//适应度函数
void decode(void);//译码函数
virtual ~population();
};
population::population()
{
}
/********************************************************/
/* POPULATION INITIAL */
/* 个体初始化函数 */
/*********************************************************/
void population::initial(void)
{
int i;
unsigned int k;
for(i=0;i<GEN_LENGTH;i++)
{
if((rand()*2/RAND_MAX)>=1) k=1;
else k=0;
gen_chain1[i]=k;
}
for(i=0;i<GEN_LENGTH;i++)
{
if((rand()*2/RAND_MAX)>=1) k=1;
else k=0;
gen_chain2[i]=k;
}
return;
}
/********************************************************/
/* GENE DECODE */
/* 基因译码函数 */
/*********************************************************/
void population::decode()
{ long sum1,sum2,sum_all;
int i,j,begin_l,end_l;
for(j=0;j<N_PARAMETER;j++)
{ sum2=1;sum1=0;sum_all=0;
begin_l=j*CODE_LENGTH;end_l=(j+1)*CODE_LENGTH;
for(i=begin_l;i<end_l;i++)
{
if(gen_chain1[i]==gen_chain2[i])
{ decode_chain[i]=0; sum1=sum1;}
if(gen_chain1[i]!=gen_chain2[i])
{decode_chain[i]=1;sum1=sum1+sum2;}
sum_all=sum_all+sum2;
sum2=sum2*2;
}
x[j]=(double)((double)sum1/(double)sum_all);
}
return;
}
/********************************************************/
/* FITNESS FUNCATION */
/* 适应度函数 */
/*********************************************************/
void population::fitness_function()
{
decode();
fitness=x[0]*x[0];
return;
}
population::~population()
{
}
///////////////////////////////////
// WAREHOUSE CLASS DEFINE //
// 优良基因仓库类定义 //
////////////////////////////////////
class warehouse
{
public:
double average_fitness;//优良基因平均适应度
int warehouse_size;//基因库个体总数
int now_size;//基因库现在库存量
population *pop;//优良个体基因
warehouse();
void initial(int size1);//基因库初始化函数
int add_individual(population pop1);//基因库内增加个体函数
void statistic(void);//基因库内统计函数
~warehouse();
};
warehouse::warehouse()
{
now_size=0;warehouse_size=0;
}
/********************************************************/
/* WAREHOUSE INITIAL */
/* 基因库初始化函数 */
/*********************************************************/
void warehouse::initial(int size1)
{
warehouse_size=size1;
pop=(population *)malloc(sizeof(population)*size1);
if(pop==NULL) {cout<<"内存分配失败！"<<endl;exit(0);}
return;
}
/********************************************************/
/* STATISTIC FUCATION */
/* 基因库统计函数 */
/*********************************************************/
void warehouse::statistic()
{int i;
double sum1;
sum1=0.0;
if(now_size!=0)
{ for(i=0;i<now_size;i++) sum1=sum1+pop[i].fitness;
average_fitness=sum1/(double)now_size;
}
else
average_fitness=0.0;
return;
}
/********************************************************/
/* ADD INDIVIDUAL */
/* 基因库增加基因函数 */
/*********************************************************/
int warehouse::add_individual(population pop1)
{ int i;
if(now_size<warehouse_size)
{
pop[now_size]=pop1;
now_size++;
}
else
{
for(i=0;i<warehouse_size;i++)
{
if(pop1.fitness>pop[i].fitness) pop[i]=pop1;
}
}
return(1);
}
warehouse::~warehouse()
{
}
///////////////////////////////////////////////////////
// MATING POOL CLASS //
// 交配池类定义 //
///////////////////////////////////////////////////////
class mating_pool
{
public:
int pool_size;//交配池中个体总数
population *parent_pop,*filial_pop;//父代个体，子代个体
double sumfitness;//交配池中个体适应度总和
long int n_mating,n_mutation;//交配池中个体交配、变异次数统计
double max_fitness;//最大适应度
double average_fitness;//平均适应度
int max_location;//最大适应度个体位置
warehouse gene_base;//优良基因仓库
mating_pool();
void initial(int pop_size);//初始化交配池函数
void statistic();//交配池中个体统计函数
int selection();//交配池中个体选择函数
int flip(double probability);//FLIP实验函数
int mutation(unsigned int loca);//变异函数
int mating(unsigned int *parent1_chain1,unsigned int *parent1_chain2,
unsigned int *parent2_chain1,unsigned int *parent2_chain2,
int k5);//交配函数
void generation(void);//代进化函数
void next_generation(void);//父代、子代一致函数
void report_generation(void);//一代个体报告函数
void initial_gene_base(int size1);//优良基因库初始化函数
void retain_good_gene(void);//优良基因保存函数
void recall_good_gene(int size1);//优良基因输出函数
~mating_pool();
};
mating_pool::mating_pool()
{
n_mutation=0;n_mating=0;
sumfitness=0.0;max_fitness=0.0;max_location=0;
}
/********************************************************/
/* MATING POOL INITIAL */
/* 交配池初始化函数 */
/*********************************************************/
void mating_pool::initial(int pop_size)
{
int i;
pool_size=pop_size;
parent_pop=(population *)malloc(sizeof(population)*pool_size);
if(parent_pop==NULL) {cout<<"内存空间分配失败！"<<endl;exit(0);}
filial_pop=(population *)malloc(sizeof(population)*pool_size);
if(filial_pop==NULL) {cout<<"内存空间分配失败！"<<endl;exit(0);}
for(i=0;i<pool_size;i++)
{
parent_pop[i].initial();
parent_pop[i].fitness_function();
filial_pop[i]=parent_pop[i];
}
return;
}
/********************************************************/
/* STATISTIC FUNCTION */
/* 交配池统计函数 */
/*********************************************************/
void mating_pool::statistic()
{int i,max_l;
double sum1,max_f;
sum1=0.0;max_f=0.0;max_l=0;
for(i=0;i<pool_size;i++)
{
sum1=sum1+parent_pop[i].fitness;
if(parent_pop[i].fitness>max_f)
{
max_f=parent_pop[i].fitness;
max_l=i;
}
}
sumfitness=sum1;max_fitness=max_f;max_location=max_l;
average_fitness=sumfitness/pool_size;
return;
}
/********************************************************/
/* SELECTION FUNCTION */
/* 个体选择函数 */
/*********************************************************/
int mating_pool::selection()
{ double rand1,partsum;
int j;
partsum=0.0;j=0;
rand1=(double)rand()/(double)RAND_MAX;
rand1=rand1*sumfitness;
while((partsum<rand1)&&(j<pool_size))
{ partsum=partsum+parent_pop[j].fitness;j++;}
return(j);
}
///////////////////////////////////////////////////////
// FLIP FUNCTION //
// FLIP 实验函数 //
///////////////////////////////////////////////////////
int mating_pool::flip(double probability)
{ double probability_f;
// srand((unsigned)time(NULL));
probability_f=(double)rand()/(double)(RAND_MAX);
if ( probability_f<=probability) return(1);
else return(0);
}
///////////////////////////////////////////////////////
// MUTATION FUNCTION //
// 变异函数 //
///////////////////////////////////////////////////////
int mating_pool::mutation(unsigned int loca)
{ int mutate;
mutate=flip(P_MUTATION);
if(mutate==1)
{ n_mutation=n_mutation+1;
if(loca==1) loca=0;
else loca=1;
}
if(loca==1) return(1);
else return(0);
}
///////////////////////////////////////////////////////
// MATING FUNCTION //
// 杂交函数 //
///////////////////////////////////////////////////////
int mating_pool::mating(unsigned int *parent1_chain1,unsigned int *parent1_chain2,
unsigned int *parent2_chain1,unsigned int *parent2_chain2,
int k5)
{ int j;
if(flip(P_MATING)==1)
{ n_mating=n_mating+1;
for(j=0;j<GEN_LENGTH;j++)
{
filial_pop[k5].gen_chain1[j]=mutation(parent1_chain1[j]);
filial_pop[k5].gen_chain2[j]=mutation(parent2_chain2[j]);
filial_pop[k5+1].gen_chain1[j]=mutation(parent2_chain1[j]);
filial_pop[k5+1].gen_chain2[j]=mutation(parent1_chain2[j]);
}
}
else{
for(j=0;j<GEN_LENGTH;j++)
{ filial_pop[k5].gen_chain1[j]=mutation(parent1_chain1[j]);
filial_pop[k5].gen_chain2[j]=mutation(parent1_chain2[j]);
filial_pop[k5+1].gen_chain1[j]=mutation(parent2_chain1[j]);
filial_pop[k5+1].gen_chain2[j]=mutation(parent2_chain2[j]);
}
}
return(1);
}
/********************************************************/
/* GENERATION FUNCTION */
/* 子代产生函数 */
/*********************************************************/
void mating_pool::generation(void)
{ unsigned int mate1,mate2;
int j;
j=0;
while(j<pool_size)
{ mate1=selection();mate2=selection();
mating(parent_pop[mate1].gen_chain1,parent_pop[mate1].gen_chain2,
parent_pop[mate2].gen_chain1,parent_pop[mate2].gen_chain2,
j);
filial_pop[j].fitness_function();
filial_pop[j+1].fitness_function();
j=j+2;
}
return;
}
/********************************************************/
/* NEXT GENERATION */
/* 下一代子代产生的准备函数：父代、子代一致函数 */
/*********************************************************/
void mating_pool::next_generation()
{int i;
for(i=0;i<pool_size;i++) parent_pop[i]=filial_pop[i];
return;
}
void mating_pool::report_generation(void)
{
int i;
cout<<"gen chain1: ";
for(i=GEN_LENGTH-1;i>=0;i--)
cout<<parent_pop[max_location].gen_chain1[i];
cout<<endl;
cout<<"gen chain2: ";
for(i=GEN_LENGTH-1;i>=0;i--)
cout<<parent_pop[max_location].gen_chain2[i];
cout<<endl;
cout<<"decode chain: ";
for(i=GEN_LENGTH-1;i>=0;i--)
cout<<parent_pop[max_location].decode_chain[i];
cout<<endl;
cout<<"Parameters Are:"<<endl;
for(i=N_PARAMETER-1;i>=0;i--)
cout<<"x["<<i<<"]="<<parent_pop[max_location].x[i]<<endl;
cout<<"Max Population Location Is: "<<max_location<<endl;
cout<<"Max Fitness="<<parent_pop[max_location].fitness<<endl;
cout<<"Max Fitness="<<max_fitness<<endl;
cout<<"Average Fitness= "<<average_fitness<<endl;
return;
}
/********************************************************/
/* INITIAL WAREHOUSE */
/* 基因仓库初始化函数 */
/*********************************************************/
void mating_pool::initial_gene_base(int size1)
{
gene_base.initial(size1);
return;
}
/********************************************************/
/* RETAIN GOOD GENE */
/* 优良基因保存函数 */
/*********************************************************/
void mating_pool::retain_good_gene(void)
{int i;
gene_base.add_individual(parent_pop[max_location]);
for(i=0;i<pool_size;i++)
{
if(parent_pop[i].fitness>average_fitness)
gene_base.add_individual(parent_pop[i]);
}
return;
}
/********************************************************/
/* RECALL GOOD GENE */
/* 优良基因输出函数 */
/*********************************************************/
void mating_pool::recall_good_gene(int size1)
{
int i,j;
j=0;
for(i=0;i<pool_size;i++)
{
if(parent_pop[i].fitness<gene_base.pop[j].fitness)
{ parent_pop[i]=gene_base.pop[i];
j++;
}
if(j>=size1) break;
}
return;
}
mating_pool::~mating_pool()
{
}
#endif // !defined(AFX_POPULATION_H__EBC520C7_10A5_11D4_BAC1_9349EAE2243A__INCLUDED_)
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -