// SimpleGA.cpp: implementation of the CSimpleGA class.
//
//////////////////////////////////////////////////////////////////////
#include "SimpleGA.h"
#include "ProjectHead.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CSimpleGA::CSimpleGA()
{
m_lMutationTimes=0; m_lMatingTimes=0;
m_dSumFitness=0.0;m_dMaxFitness=0.0;m_iMaxLocation=0;
m_count=0;
m_nowp=0;
m_position=0;
last_maxfitness=0.0;
}
/********************************************************/
/* MATING POOL INITIAL */
/* 交配池初始化函数 */
/*********************************************************/
void CSimpleGA::Initial(int pop_size,double mutation_p,double crossing_p)
{
int i;
m_iPopuSize=pop_size;
m_dMutationP=mutation_p;m_dCrossingP=crossing_p;
m_lpParents=(CGAUnite *)malloc(sizeof(CGAUnite)*m_iPopuSize);
if(m_lpParents==NULL)
{
cout<<"内存空间分配失败!"<<endl;
exit(0);
}
m_lpFilials=(CGAUnite *)malloc(sizeof(CGAUnite)*m_iPopuSize);
if(m_lpFilials==NULL)
{
cout<<"内存空间分配失败!"<<endl;
free(m_lpParents);
exit(0);
}
for(i=0;i<m_iPopuSize;i++)
{
m_lpParents[i].Initial();
m_lpParents[i].FitnessFunction();
m_lpFilials[i]=m_lpParents[i];
}
return;
}
/********************************************************/
/* STATISTIC FUNCTION */
/* 交配池统计函数 */
/*********************************************************/
CSimpleGA::Statistic()
{
int i,max_l;
double sum1,max_f;
sum1=0.0;max_f=0.0;max_l=0;
for(i=0;i<m_iPopuSize;i++)
{
sum1=sum1+m_lpParents[i].m_dFitness;
if(m_lpParents[i].m_dFitness>max_f)
{
max_f=m_lpParents[i].m_dFitness;
max_l=i;
}
}
m_dSumFitness=sum1;m_dMaxFitness=max_f;m_iMaxLocation=max_l;
m_dAverageFitness=sum1/(double)m_iPopuSize;
return 1;
}
/********************************************************/
/* SELECTION FUNCTION */
/* 个体选择函数 */
/*********************************************************/
int CSimpleGA::Selection()
{
double rand1,partsum;
int j;
partsum=0.0;j=0;
rand1=(double)rand()/(double)RAND_MAX;
rand1=rand1*fabs(m_dSumFitness);
while((partsum<rand1)&&(j<m_iPopuSize))
{ partsum=partsum+fabs(m_lpParents[j].m_dFitness);j++;}
return(j);
}
///////////////////////////////////////////////////////
// FLIP FUNCTION //
// FLIP 实验函数 //
///////////////////////////////////////////////////////
int CSimpleGA::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 CSimpleGA::Mutation(unsigned int loca)
{
int mutate;
mutate=Flip(m_dMutationP);
if(mutate==1)
{
m_lMutationTimes=m_lMutationTimes+1;
if(loca==1) loca=0;
else loca=1;
}
if(loca==1) return(1);
else return(0);
}
///////////////////////////////////////////////////////
// MATING FUNCTION //
// 杂交函数 //
///////////////////////////////////////////////////////
int CSimpleGA::Mating(unsigned int *parent1_chain1,unsigned int *parent1_chain2,
unsigned int *parent2_chain1,unsigned int *parent2_chain2,
int k5)
{
int j;
if(Flip(m_dCrossingP)==1)
{
m_lMatingTimes=m_lMatingTimes+1;
for(j=0;j<GEN_LENGTH;j++)
{
m_lpFilials[k5].m_uGenChainA[j]=Mutation(parent1_chain1[j]);
m_lpFilials[k5].m_uGenChainB[j]=Mutation(parent2_chain2[j]);
m_lpFilials[k5+1].m_uGenChainA[j]=Mutation(parent2_chain1[j]);
m_lpFilials[k5+1].m_uGenChainB[j]=Mutation(parent1_chain2[j]);
}
}
else
{
for(j=0;j<GEN_LENGTH;j++)
{
m_lpFilials[k5].m_uGenChainA[j]=Mutation(parent1_chain1[j]);
m_lpFilials[k5].m_uGenChainA[j]=Mutation(parent1_chain2[j]);
m_lpFilials[k5+1].m_uGenChainA[j]=Mutation(parent2_chain1[j]);
m_lpFilials[k5+1].m_uGenChainA[j]=Mutation(parent2_chain2[j]);
}
}
return(1);
}
/********************************************************/
/* GENERATION FUNCTION */
/* 子代产生函数 */
/*********************************************************/
void CSimpleGA::Generation(void)
{
unsigned int mate1,mate2;
int j;
j=0;
while(j<m_iPopuSize)
{
mate1=Selection();
mate2=Selection();
Mating(m_lpParents[mate1].m_uGenChainA,
m_lpParents[mate1].m_uGenChainB,
m_lpParents[mate2].m_uGenChainA,
m_lpParents[mate2].m_uGenChainB,j);
m_lpFilials[j].FitnessFunction();
m_lpFilials[j+1].FitnessFunction();
j=j+2;
}
return;
}
/********************************************************/
/* NEXT GENERATION */
/* 下一代子代产生的准备函数:父代、子代一致函数 */
/*********************************************************/
void CSimpleGA::NextGeneration()
{
int i;
for(i=0;i<m_iPopuSize;i++)
m_lpParents[i]=m_lpFilials[i];
return;
}
void CSimpleGA::ReportGeneration(void)
{
int i;
//cout<<endl;
m_position++;
if(m_dMaxFitness>last_maxfitness)
{
m_count=0;
m_nowp=m_position;
last_maxfitness=m_dMaxFitness;
}
else
m_count++;
cout<< "现在稳定在:";
cout<< m_nowp;
cout<<endl;
// cout<<"gen chain1: ";
// for(i=GEN_LENGTH-1;i>=0;i--)
// cout<<m_lpParents[m_iMaxLocation].m_uGenChainA[i];
// cout<<endl;
// cout<<"gen chain2: ";
// for(i=GEN_LENGTH-1;i>=0;i--)
// cout<<m_lpParents[m_iMaxLocation].m_uGenChainB[i];
// cout<<endl;
// cout<<"decode chain: ";
// for(i=GEN_LENGTH-1;i>=0;i--)
// cout<<m_lpParents[m_iMaxLocation].m_uDecodeChain[i];
// cout<<endl;
//
// cout<<"Parameters Are:"<<endl;
// for(i=N_PARAMETER-1;i>=0;i--)
// cout<<"x["<<i<<"]="<<m_lpParents[m_iMaxLocation].m_dDecValue[i]<<endl;
// cout<<"Max Population Location Is: "<<m_iMaxLocation<<endl;
// cout<<"Max Fitness="<<m_lpParents[m_iMaxLocation].m_dFitness<<endl;
cout<<"Max Fitness="<<m_dMaxFitness<<endl;
// cout<<"Average Fitness= "<<m_dAverageFitness<<endl;
// cout<<"Population MutationTimes Is: "<<m_lMutationTimes<<endl;
// cout<<"Population MatingTimes Is: "<<m_lMatingTimes<<endl;
// cout<<"Population Affinity Is: "<<m_dAffinity<<endl;
// cout<<"m_dCrossingP="<<m_dCrossingP<<"; "<<"m_dMutationP="<<m_dMutationP<<endl;
return;
}
void CSimpleGA::FreeSpace()
{
free(m_lpParents);
free(m_lpFilials);
return;
}
CSimpleGA::~CSimpleGA()
{
}
void CSimpleGA::CalcuAffinity()
{
double sum1,sum2;
int i,j,k;
sum2=0.0;
for(i=0;i<m_iPopuSize;i++)
{ sum1=0.0;
for(j=0;j<m_iPopuSize;j++)
{
if(i!=j)
{
for(k=0;k<GEN_LENGTH;k++)
{
if(m_lpParents[i].m_uDecodeChain[k]!=m_lpParents[j].m_uDecodeChain[k])
sum1=sum1+1.0;
}
}
}
sum2=sum2+sum1/(double)GEN_LENGTH/(double)m_iPopuSize;
}
m_dAffinity=sum2/(double)m_iPopuSize;
return;
}
int CSimpleGA::SaveDate(LPCTSTR filename,char if_rewrite)
{
FILE *fp;
if(if_rewrite=='r')
fp=fopen(filename,"w+b");
else
{
fp=fopen(filename,"r+b");
if(fp==NULL) fp=fopen(filename,"w+");
}
if(fp==NULL) return -1;
fseek(fp,0,SEEK_END);
fwrite(&m_dMaxFitne