遗传算法求函数极值

智能优化算法第一次作业

--------------遗传算法洪文杰S151000853 问题：用遗传算法求解f(x)=xsin(10π*x)+2.0的最大值，x取[-1,2].

一、分析：遗传算法基本思路

二、实例简介

1. 产生初始种群

s1= 13 (01101)

s2= 24 (11000)

s3= 8 (01000)

s4= 19 (10011)

2. 计算适应度

假定适应度为f(s)=s^2 ，则

f (s1) = f(13) = 13^2 = 169 f (s2) = f(24) = 24^2 = 576 f (s3) = f(8) = 8^2 = 64

f (s4) = f(19) = 19^2 = 361

3. 选择

染色体的选择概率为：

染色体的累计概率为：

根据上面的式子，可得到：

例如设从区间［0, 1］中产生4个随机数: r1 = 0.450126, r2 = 0.110347 r3 = 0.572496, r4 = 0.98503

4. 交叉

基本遗传算法（SGA）中交叉算子采用单点交叉算子。单点交叉运算

5. 变异

6. 至下一代，适应度计算→选择→交叉→变异，直至满足终止条件

三、解决问题

四、实验结果

源代码：

/*问题：用遗传算法求解f(x)=xsin(10π*x)+2.0的最大值，x取[-1,2].*/ /*洪文杰2016-3-9. 智能优化算法第一次作业*/

#include

//#includ

#include

#include

#include

#include

using namespace std;

#define NUMBER 50//种群规模

#define GENE_NUMBER 10000//迭代次数

int Unit[NUMBER][30];//初始种群

int Unit_choose[NUMBER][30];//选择、交叉、变异后的种群

int Number[NUMBER];//被选择的个体编号

float Fitness[NUMBER];//适应度

float select_probability[NUMBER];//选择概率

float accumula_probability[NUMBER] ;//积累概率

float f_max=0.0;//最大值

float f_x=0.0;//最大值对应的自变量

int hwj_coding(int start,int end);//编码

void hwj_initial_population(int num);//产生初始种群

void hwj_fitness(int num);//适应度计算

void hwj_choose();//选择个体

int hwj_binary_search(int l, int r,float temp);//查找选择

//void hwj_N_M(int a[],int b[],int N, int M);//从M个数中选N个不一样的数void hwj_cross(int num,float cross);//交叉后的得到种群

void hwj_aberrance(int num,float aberrance);//变异后的得到的种群

void hwj_max(int num);//找到最适应的个体

int main(){

int strat,end;//区间

int Num;//编码大小

float cross=0.8;//交叉概率

float aberrance = 0.04;//变异概率

int key=1;

cout<<"请输入求解区间:"<

cin>>strat>>end;

Num=hwj_coding(strat,end);

cout<<"Num:"<

// cout<<"--------------------------1-----------------"<

hwj_initial_population(Num);

// cout<<"--------------------------2初始种群-----------------"<

for(int j=0;j

cout<

}

cout<

}

*/

while(key!=GENE_NUMBER){

hwj_fitness(Num);

// cout<<"--------------------------3适应度-----------------"<

// for(int i=0;i

// cout<

// }

hwj_choose();

// cout<<"--------------------------4被选择的个体-----------------"<

for(int j=0;j

cout<

}

cout<

}

*/

hwj_cross(Num,cross);

/* cout<<"--------------------------5交叉后的种群-----------------"<

for(int i=0;i

for(int j=0;j

cout<

}

cout<

}

*/

hwj_aberrance(Num,aberrance);

/* cout<<"--------------------------6变异后的种群-----------------"<

for(int i=0;i

for(int j=0;j

cout<

}

cout<

}

*/

key++;

hwj_max(Num);

}

cout<<"最大值是对应的x值是:"<

cout<

cout<<"最大值为:"<

return 0;

}

int hwj_coding(int start,int end){//种群编码

float precision;

int temp=2;

int sum;

int N=1;

cout<<"请输入精度范围:"<

cin>>precision;

if(precision==0){

cout<<"对不起精度不能为零:"<

return 0;

}

else{

sum=(end-start)/precision;

cout<<"sum:"<

while(temp

temp*=2;

N++;

}

return N;

}

}

void hwj_initial_population(int num){//生成初始种群srand(time(NULL));

for(int i=0;i

for(int j=0;j

Unit[i][j]=rand()%2;

}

}

}

void hwj_fitness(int num){//计算适应度

float sum;

int temp;

for(int i=0;i

temp=1;

sum=0.0;

for(int j=num-1;j>=0;j--){

sum+=Unit[i][j]*temp;

temp*=2.0;

}

Fitness[i]=sum*3/(temp-1.0)-1.0;

// cout<

// cout<<"--------------+++++";

Fitness[i]=Fitness[i]*sin(10*3.1415926*Fitness[i])+2.0;

// cout<

}

}

int hwj_binary_search(int l,int r,float temp){

for(int i=0;i

if(temp<=accumula_probability[i]&&temp>accumula_probability[i-1]){

return i;

}

}

return -1;

}

void hwj_choose(){//选择个体

float sum=0.0;

float temp;

int i;

for(i=0;i

sum+=Fitness[i];

}

select_probability[0]=Fitness[0]/sum;

temp=accumula_probability[0]=select_probability[0];

for(i=1;i

select_probability[i]=Fitness[i]/sum;

temp+=select_probability[i];

accumula_probability[i]=temp;

// cout<

}

for(i=0;i

// srand(time(NULL));

temp=(rand()%1000000)/1000000.0;

// cout<

Number[i]=hwj_binary_search(0,NUMBER,temp);

// cout<

for(int j=0;j

Unit_choose[i][j]=Unit[Number[i]][j];

}

}

}

/*void hwj_N_M(int a[],int b[],int N,int M){//从M个数中选N个不一样的数int i=1;

srand(time(NULL));

a[0]=rand()%M;

b[a[0]]=1;

while(i!=N){

a[i]=rand()%M;

if(b[a[i]]==0){

i++;

b[a[i]]=1;

cout<

}

}

// cout<

}*/

void hwj_cross(int num,float cross){//交叉后的得到种群int num_cross=NUMBER*cross;

int k;//交叉点

int i , j;

if(num_cross%2!=0){

num_cross=num_cross+1;

}//需要交叉的个体数

int cro[NUMBER];//被交叉的个体编号

int temp[NUMBER];//是否交叉数组一览

for(i=0;i

cro[i]=-1;

temp[i]=0;

}

// hwj_N_M(cro,temp,num_cross,NUMBER);

srand(time(NULL));

cro[0]=rand()%NUMBER;

temp[cro[0]]=1;

i=1;

while(i!=num_cross){

cro[i]=rand()%NUMBER;

if(temp[cro[i]]==0){

temp[cro[i]]=1;

i++;

}

}

// for(int i=0;i

// cout<

// }

// cout<

for(i=0;i

srand(time(NULL));

k=rand()%num;

for(j=0;j

if(j<=k){

Unit[i][j]=Unit_choose[cro[num_cross-i]][j];

Unit[i+num_cross/2][j]=Unit_choose[cro[i]][j];

}

else{

Unit[i][j]=Unit_choose[cro[i]][j];

Unit[i+num_cross/2][j]=Unit_choose[cro[i]][j];

}

}

}

for(i=0;i

// cout<

if(temp[i]==0){

for(j=0;j

Unit[num_cross][j]=Unit_choose[i][j];

}

num_cross++;

}

}

}

void hwj_aberrance(int num,float aberrance){//变异后的得到的种群int num_aberrance=NUMBER*aberrance;//变异的个体数

int k;//变异点

int abe[NUMBER];//变异的个体编号

int temp[NUMBER];//是否变异数组一览

int i,j,p;

for(i=0;i

abe[i]=-1;

temp[i]=0;