简易遗传算法(浮点数编码)

#include<stdio.h>
#include<stdlib.h> 
#include<math.h>
#include<time.h> 

#define M 80				//种群数量
#define XMIN -1				//下限
#define XMAX 2				//上限
#define PI 3.1415926
#define PC 0.8				//交叉概率
#define PM 0.18				//变异概率
#define PA 0.01				//交叉因子

struct Node
{
	double Pmember;
	double Myfitness;		//Myfitness是适应度
	double Myfitsum;		//Myfitsum是适应度占总体适应度的百分比，然后从第一个个体往后累加，主要用于选择操作
	double Myfitave;
}Nownode[M],Nextnode[M];	//本代群体和下一代群体

int nodeindex[M];			//交叉时随机配对，存放配对的群体下标
int T=0;

double fx(double x)			//根据x计算fx
{
	double y;
	y=x*sin(10*PI*x)+2;
	//y=100-(x-5)*(x-5);
	return y;
}

int calfitness()			//计算适应度值
{
	int i;
	double minfitness,maxfitness,avefitness=0;
	double C=1.7,a,b;
	double temp;
	minfitness=Nownode[0].Myfitness=fx(Nownode[0].Pmember);
	maxfitness=minfitness;
	avefitness=maxfitness;
	for(i=1;i<M;i++)
	{	
		Nownode[i].Myfitness=fx(Nownode[i].Pmember);
		avefitness+=Nownode[i].Myfitness;
		if(minfitness>Nownode[i].Myfitness)
		{
			minfitness=Nownode[i].Myfitness;
		}
		if(maxfitness<Nownode[i].Myfitness)
		{
			maxfitness=Nownode[i].Myfitness;
		}
	}
	
	if(minfitness<0)//如果有负的适应度值，就把所以的适应度都加上一个数，使适应度全都为正数
	{
		temp=minfitness;
		Nownode[0].Myfitness+=-temp;
		avefitness=Nownode[0].Myfitness;
		maxfitness=Nownode[0].Myfitness;
		minfitness=Nownode[0].Myfitness;
		for(i=1;i<M;i++)
		{
			Nownode[i].Myfitness+=-temp;
			avefitness+=Nownode[i].Myfitness;
			if(minfitness>Nownode[i].Myfitness)
			{
				minfitness=Nownode[i].Myfitness;
			}
			if(maxfitness<Nownode[i].Myfitness)
			{
				maxfitness=Nownode[i].Myfitness;
			}	
		}
	}

	//适应度线性变换
	avefitness=avefitness/M;//计算平均适应度
	if(minfitness>(C*avefitness-maxfitness)/(C-1))
	{
		a=(C-1)*avefitness/(maxfitness-avefitness);
		b=(maxfitness-C*avefitness)*avefitness/(maxfitness-avefitness);
	}
	else
	{
		a=avefitness/(avefitness-minfitness);
		b=minfitness*avefitness/(avefitness-minfitness);
	}
	for(i=0;i<M;i++)
	{
		Nownode[i].Myfitness=a*Nownode[i].Myfitness+b;
	}



	Nownode[0].Myfitsum=Nownode[0].Myfitness;
	for(i=1;i<M;i++)
	{
		Nownode[i].Myfitsum=Nownode[i].Myfitness+Nownode[i-1].Myfitsum;//每一个Myfitsum都是自己的适应度加上前一个的Myfitsum
	}

	for(i=0;i<M;i++)
	{
		Nownode[i].Myfitave=Nownode[M-1].Myfitsum/M;
	}
	

	for(i=0;i<M;i++)
	{
		Nownode[i].Myfitsum=Nownode[i].Myfitsum/Nownode[M-1].Myfitsum;//每一个Myfitsum除以所有适应度之和，使Myfitsum为0~1之间
	}
	return 0;
}

double randn()		//产生XMIN到XMAX之间的随机数
{
	return XMIN+1.0*rand()/RAND_MAX*(XMAX-XMIN);
}

int initpopulation()	//初始化种群
{
	int i;
	for(i=0;i<M;i++)
	{
		Nownode[i].Pmember=randn();
	}
	calfitness();		//计算适应度
	return 0;
}

int assignment(struct Node *node1,struct Node *node2)//把node2的值赋值给node1
{
	node1->Pmember=node2->Pmember;
	node1->Myfitness=node2->Myfitness;
	node1->Myfitsum=node2->Myfitsum;
	node1->Myfitave=node2->Myfitave;
	return 0;
}

int copypopulation()		//复制操作
{
	int i,num=0;
	double temp;
	while(num<M)
	{
		temp=1.0*rand()/RAND_MAX;
		for(i=1;i<M;i++)
		{
			if(temp<=Nownode[0].Myfitsum)
			{
				assignment(&Nextnode[num++],&Nownode[0]);//把第一个个体复制到下一代
				break;
			}
			if(temp>=Nownode[i-1].Myfitsum&&temp<=Nownode[i].Myfitsum)//把第i个个体复制到下一代
			{
				assignment(&Nextnode[num++],&Nownode[i]);
				break;
			}
		}
	}
	for(i=0;i<M;i++)
	{
		assignment(&Nownode[i],&Nextnode[i]);	//更新本代个体
	}
	calfitness();		//计算适应度
	return 0;
}

int isrepeat(int temp,int n)	//产生随机下标判断是否重复
{
	int i;
	for(i=0;i<n;i++)
	{
		if(nodeindex[i]==temp)
			return 1;
	}
	return 0;
}

int crossover()
{
	int i,temp;
	double temp_pc;
	for(i=0;i<M;i++)		//产生交叉点的下标
	{
		do {
			temp=rand()%M;
		} while(isrepeat(temp,i));
		nodeindex[i]=temp;
	}
	for(i=0;i<M;i=i+2)
	{
		temp_pc=1.0*rand()/RAND_MAX;	//如果满足交叉的条件，就开始交叉
		if(temp_pc<=PC)
		{
			Nownode[nodeindex[i]].Pmember=PA*Nownode[nodeindex[i+1]].Pmember+(1-PA)*Nownode[nodeindex[i]].Pmember;
			Nownode[nodeindex[i+1]].Pmember=PA*Nownode[nodeindex[i]].Pmember+(1-PA)*Nownode[nodeindex[i+1]].Pmember;
			
		}	
	}
	calfitness();		//计算适应度
	return 0;
}


int mutation()			//变异操作
{
	int i,temp;
	double k=0.8,temp_pm;
	for(i=0;i<M;i++)
	{
		temp_pm=1.0*rand()/RAND_MAX;
		if(temp_pm<=PM)	//如果满足变异条件，就开始变异
		{
			temp=rand()%2;
			if(temp==0)
			{
				Nownode[i].Pmember=Nownode[i].Pmember+k*(XMAX-Nownode[i].Pmember)*1.0*rand()/RAND_MAX;
			}
			else
			{
				Nownode[i].Pmember=Nownode[i].Pmember-k*(Nownode[i].Pmember-XMIN)*1.0*rand()/RAND_MAX;
			}
		}
	}
	calfitness();	//计算适应度
	return 0;
}
int findmaxfit()//找到适应度最大的个体
{
	int i,index=0;
	double temp=0;
	for(i=0;i<M;i++)
	{
		if(temp<Nownode[i].Myfitness)
		{
			index=i;
			temp=Nownode[i].Myfitness;
		}
	}
	return index;
}

int main()
{
	int i=0,index;
	int num=0,num1=0,num2=0;
	srand(time(NULL));
	while(num++<1000)
	{
		T=0;
		initpopulation();
		while(T++<200)
		{
			copypopulation();
			crossover();
			mutation();
		}
		index=findmaxfit();
		if(fabs(Nownode[index].Pmember-1.85)<=0.1)
		{
			num1++;
		}
		else
		{
			num2++;
		}
	}
	printf("正确的次数有%d次\n",num1);
	printf("错误的次数有%d次\n",num2);
	return 0;
}