📄 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 16 //基因串长度
#define N_PARAMETER 1 //代表参数的个数
#define CODE_LENGTH 16 //每个参数基因编码长度
#define P_MUTATION 0.001 //变异率
#define P_MATING 0.7 //杂交率
///////////////////////////////////////////////////////
// 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 */
/* 基因译码函数 */
/*********************************************************/
/*
比如两条基因分别为 10001000 00001000 ，然后做异或操作，同则为0，不同则为1，
则上式解码出来应该是127。
这是一个解码操作，两条基因异或出来就是参数的实际值。
上式然后再除255，就是真实的参数值，既是0.48.
*/
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; //交配池中个体总数nnnnnnnnn
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 + -