遗传算法求函数极值
遗传算法求函数最大值实验报告
遗传算法求函数最大值实验报告遗传算法是一种模拟自然界进化过程的优化算法，它通过模拟生物进化过程中的遗传、交叉和变异等机制，逐步优化解空间中的个体，以找到问题的最优解。
在本次实验中，我们利用遗传算法来求解一个函数的最大值。
下面我们将详细介绍实验的过程和结果。
首先，我们选择了一个简单的函数作为实验对象，即f(x) = x^2，在x的范围为[-10, 10]。
我们的目标是找到使函数值最大的x。
首先，我们需要定义遗传算法中的基本元素，包括编码方式、适应度函数、选择策略、交叉和变异操作等。
在本实验中，我们选择二进制编码方式，将x的范围[-10, 10]离散化为10位的二进制编码。
适应度函数即为f(x) = x^2，它表示个体的适应度。
选择策略采用轮盘赌选择算法，交叉操作采用单点交叉，变异操作采用随机位变异。
接下来，我们需要初始化种群，并迭代进行交叉和变异操作，直到满足终止条件。
在每一代中，我们根据适应度函数对种群中的个体进行评估，并根据选择策略选择父代个体进行交叉和变异操作。
通过交叉和变异操作，产生新的子代个体，并替代原有种群中的个体。
在本次实验中，我们设置了100个个体的种群，并进行了100代的迭代。
实验结果显示，经过多次迭代，算法逐渐优化到了最优解。
最终找到了使函数值最大的x，即x=10，对应的函数值为100。
总结起来，本次实验利用遗传算法求解函数的最大值，展示了遗传算法在优化问题中的应用。
通过适当选择编码方式、适应度函数和操作策略，我们可以有效地找到问题的最优解。
在后续的研究中，我们可以进一步探索遗传算法在更复杂问题上的应用，并通过改进算法的参数和操作策略来提高算法的性能。
matlab遗传算法计算函数区间最大值和最小值
matlab遗传算法计算函数区间最大值和最小值下面是用matlab实现遗传算法计算函数区间最大值和最小值的示例代码：首先定义函数（此处以f(x)=x*sin(10*pi*x)+1为例）:matlabfunction y = myfun(x)y = x*sin(10*pi*x)+1;end然后设置遗传算法参数：matlaboptions = gaoptimset('Generations', 1000, 'PopulationSize', 50,'StallGenLimit', 200, 'TolCon', 1e-10);其中，Generations表示遗传算法的迭代次数，PopulationSize表示种群大小，StallGenLimit表示在连续多少代没有改变时停止迭代，TolCon表示收敛精度。
接着，编写遗传算法主函数：matlab[x, fval] = ga(@myfun, 1, [], [], [], [], -1, 2, [], [], options);其中，第一个参数为要优化的函数，第二个参数为变量维度，后面的参数为变量的取值范围。
最后，输出结果：matlabfprintf('Function maximum is %f\n',-fval);fprintf('Function minimum is %f\n',fval);其中，-fval表示函数最大值，fval表示函数最小值。
完整代码如下：matlabfunction y = myfun(x)y = x*sin(10*pi*x)+1;endoptions = gaoptimset('Generations', 1000, 'PopulationSize', 50, 'StallGenLimit', 200, 'TolCon', 1e-10);[x, fval] = ga(@myfun, 1, [], [], [], [], -1, 2, [], [], options);fprintf('Function maximum is %f\n',-fval);fprintf('Function minimum is %f\n',fval);参考资料：[1][2]。
实验五：遗传算法求解函数最值问题实验
EJdoublefitness(constCh^crrcscrcRc)
{
doublek,y;
decode(cx# y);
retiurnf(x, y)+5;
2•交叉操作
首先是根据交叉概率probCross选择要交叉的个体进行交叉
//根据交叉槪率进行交叉
for(inti=pre = -1;i<N; i++)
//根据变异概率迸行变异
for (inti=0;i<N; i++)
if(randQm61() < probMutation)
mutate(group[i]);
变异时先随机生成变异的位置，然后把改位的01值翻转。
//变异操作
Hvoidmutate(ChrcfnosomeS c)
{
//随机选行翻转
inti-rand()%len; c-g[i] =
//骑越
boolflag-令；
for(inti = j=0; i<1.亡n;i++)
swap(d.g[l]Jc2.g[i]);
if(i== crosspcint[j])
//妇杲若干个交叉点重合”则效果叠加 "偃数个交叉点效果瑁当于没有交叉点while(j<
flag = [flag;
3.变异操作
首先是根据变异概率probMutation选择要变异的个体
经过一定的进化之后得到最终种群，从中选择最优的个体即可得
到最终的结果。
//获取种群最优你
-intgetOptimal(Ch^crescr：-oup[mxn]doubled—double&』doubled\)
遗传算法求函数极大值(matlab实现)
遗传算法求函数最大值(matlab实现)一、题目：寻找f(x)=x2,,当x在0~31区间的最大值。
二、源程序：%遗传算法求解函数最大值%本程序用到了英国谢菲尔德大学(Sheffield)开发的工具箱GATBX，该工具箱比matlab自带的GATOOL使用更加灵活，但在编写程序方面稍微复杂一些Close all;Clear all;figure(1);fplot('variable*variable',[0,31]); %画出函数曲线%以下定义遗传算法参数GTSM=40; %定义个体数目ZDYCDS=20; %定义最大遗传代数EJZWS=5; %定义变量的二进制位数DG=0.9; %定义代沟trace=zeros(2, ZDYCDS); %最优结果的初始值FieldD=[5;-1;2;1;0;1;1]; %定义区域描述器的各个参数%以下为遗传算法基本操作部分，包括创建初始种群、复制、交叉和变异Chrom=crtbp(GTSM, EJZWS); %创建初始种群，即生成给定规模的二进制种群和结构gen=0; %定义代数计数器初始值variable=bs2rv(Chrom, FieldD); %对生成的初始种群进行十进制转换ObjV=variable*variable; %计算目标函数值f(x)=x2 while gen<ZDYCDS %进行循环控制，当当前代数小于定义的最大遗传代数时，继续循环，直至代数等于最大遗传代数FitnV=ranking(-ObjV); %分配适应度值SelCh=select('sus', Chrom, FitnV, DG); %选择，即对个体按照他们的适配值进行复制SelCh=recombin('xovsp', SelCh, 0.7); %交叉，即首先将复制产生的匹配池中的成员随机两两匹配，再进行交叉繁殖SelCh=mut(SelCh); %变异，以一个很小的概率随机地改变一个个体串位的值variable=bs2rv(SelCh, FieldD); %子代个体的十进制转换ObjVSel=variable*variable; %计算子代的目标函数值[Chrom ObjV]=reins(Chrom, SelCh, 1, 1, ObjV, ObjVSel);%再插入子代的新种群，其中Chrom为包含当前种群个体的矩阵，SelCh为包好当前种群后代的矩阵variable=bs2rv(Chrom, FieldD); %十进制转换gen=gen+1; %代数计数器增加%输出最优解及其序号，并在目标函数图像中标出，Y为最优解,I 为种群的%序号[Y, I]=max(ObjV);hold on; %求出其最大目标函数值plot(variable(I), Y, 'bo');trace(1, gen)=max(ObjV); %遗传算法性能跟踪trace(2, gen)=sum(ObjV)/length(ObjV);end%以下为结果显示部分，通过上面计算出的数值进行绘图variable=bs2rv(Chrom, FieldD); %最优个体进行十进制转换hold on, grid;plot(variable,ObjV,'b*'); %将结果画出三、运行结果：由图可见该函数为单调递增函数，即当X=31时，该取得最大值f(x)max=961。
matlab二元函数求极值 遗传所引发
Matlab二元函数求极值是一个常见的数学问题，而遗传算法作为一种优化方法，在解决这个问题上也发挥了重要作用。
在本文中，我将对matlab二元函数求极值和遗传算法的相互关系进行深度探讨，并共享我个人对这一主题的理解。
1. Matlab二元函数求极值的基本概念Matlab是一种用于数值计算和可视化的高级技术计算语言和交互式环境。
在数学建模和优化问题中，经常会遇到需要求解二元函数的极值的情况。
这就涉及到了寻找函数在给定范围内的最大值或最小值的问题。
通过利用Matlab中的优化工具箱和相关函数，我们可以高效地求解二元函数的极值点，从而得到函数在特定区域内的最优解。
2. 遗传算法在优化问题中的应用遗传算法是一种模拟自然选择与遗传机制的计算方法，常用于解决优化问题。
它通过模拟自然界中的进化过程，通过选择、交叉和变异等操作，逐步优化解的质量，最终找到问题的最优解。
在实际应用中，遗传算法被广泛应用于解决复杂的优化问题，包括函数极值求解、组合优化、参数优化等多个领域。
3. Matlab二元函数求极值中遗传算法的应用在Matlab中，我们可以利用遗传算法工具箱来解决二元函数的极值求解问题。
通过将二元函数极值求解问题转化为适应度函数的优化问题，我们可以使用Matlab中优化工具箱中的遗传算法求取最优解。
遗传算法能够在多样化的解空间中高效地搜索最优解，从而在众多解空间中找到最优的极值点。
4. 个人观点与理解我认为，Matlab二元函数求极值与遗传算法的结合，为解决复杂的优化问题提供了一种高效的方法。
遗传算法能够通过对解的多样性进行搜索，找到最优解的潜力非常大。
当我们将遗传算法与Matlab中强大的数值计算和优化工具箱相结合，就可以更快、更精确地求解二元函数的极值，从而解决实际问题中的优化难题。
在本文中，我对Matlab二元函数求极值和遗传算法的应用进行了探讨，并共享了个人观点和理解。
通过深入探讨这一主题，相信读者对于如何利用遗传算法来解决Matlab二元函数求极值问题会有更深入的理解。
遗传算法求函数极值
遗传算法求函数极值遗传算法是一种基于模拟生物进化过程的优化算法，它通过模拟生物的进化过程中的遗传、交叉和变异等操作，对问题的解空间进行，并到满足最优条件的解。
它被广泛应用于求解各种复杂问题，包括函数极值问题。
在使用遗传算法求函数极值的过程中，首先需要明确问题的目标函数。
目标函数是一个将自变量映射到一个实数值的函数，它描述了问题的优化目标。
例如，我们可以考虑一个简单的目标函数f(x)，其中x表示自变量，f(x)表示因变量。
遗传算法的基本流程如下：1.初始化种群：随机生成一组初始解，也就是种群。
种群中的每个个体都是一个可能的问题解，而个体中的染色体则表示了问题解的具体数值。
2.适应度评估：对于种群中的每个个体，通过计算目标函数的值，评估每个个体的适应度。
适应度越高的个体，越有可能成为下一代个体的基因。
3.选择操作：根据个体的适应度，选择一些个体作为下一代遗传操作的基因。
4.交叉操作：从选择出的个体中随机选择一对个体，进行交叉操作。
交叉操作通过交换两个个体的染色体信息，产生新的个体。
5.变异操作：对交叉操作生成的新个体进行变异操作。
变异操作通过改变个体染色体中的部分基因，引入新的解，以增加问题解的多样性。
6.新种群产生：基于交叉和变异操作，生成新的种群。
7.终止条件判断：如果满足终止条件（例如达到最大迭代次数、找到了满足要求的解等），则停止算法；否则，返回第2步。
通过以上步骤的循环迭代，遗传算法可以到问题的最优解，即函数的极值。
由于遗传算法充分利用了进化算法的生物特点，具有全局能力和自适应优化能力，因此在函数极值求解中得到了广泛的应用。
遗传算法的关键在于如何进行适应度评估、选择操作、交叉操作和变异操作。
适应度评估是指根据目标函数计算个体的适应度值，一般情况下适应度越高的个体越有可能成为下一代的基因。
选择操作可以采用轮盘赌选择、最优选择等方式，根据个体的适应度选择一定数量的个体进行交叉和变异。
交叉操作通过交换染色体信息，产生新的个体；变异操作通过改变个体染色体中的部分基因，引入新的解。
遗传算法计算函数最大值
遗传算法计算函数最大值遗传算法是一种模拟进化过程的优化算法，被广泛应用于求解函数最大值问题。
在遗传算法中，问题的解被表示为染色体的形式，每个染色体都是由一串基因组成。
每个基因可以看作是染色体中的一个变量值，它们合起来构成了一个可行解。
随着进化的进行，每个可行解都会被评估，评估函数即为目标函数，目标函数可以是我们需要求解的函数。
根据目标函数的评价结果，我们可以对染色体进行选择、交叉和变异，以产生新的一代染色体，进而继续进行优化。
遗传算法的核心是选择、交叉和变异这三个基本操作。
选择操作是指从当前种群中选择部分优秀的染色体作为父代，根据染色体的适应度值进行随机抽样。
交叉操作是指将两个父代染色体的一部分基因进行互换，产生新的子代染色体。
变异操作是指对子代染色体的某个基因进行随机改变，产生新的基因。
遗传算法具有很好的鲁棒性和适应性，能够应对大规模的优化问题。
它的优势在于不要求问题具有良好的可微性，也不需要先验知识，能够处理不确定的搜索空间和复杂的非线性函数。
在求解函数最大值问题时，我们需要首先定义一个适当的目标函数。
目标函数可以是实际应用中的函数，也可以是一些基本函数或常用函数。
常见的函数包括线性函数、二次函数、指数函数、对数函数、三角函数等。
以求解f(x)=-x^2+2x+6函数最大值为例，假设x的范围在[0,5]之间，则可定义目标函数如下：f(x)=-x^2+2x+6在遗传算法的优化过程中，我们需要确定初始种群、目标函数、选择、交叉和变异等相关参数。
初始种群可以采用随机生成的方式，或者根据某些规律生成；目标函数应该能够给出染色体的适应度值；选择操作可以根据适应度函数对染色体进行排序，或者采用轮盘赌的方式选择优秀染色体；交叉操作可以随机选取父代染色体的一部分基因进行交叉；变异操作可以按照一定概率随机对子代染色体的基因进行改变。
最终，经过多轮迭代，我们可以得到一组较优的染色体，以及它们所对应的函数最大值。
遗传算法求函数极值
智能优化算法第一次作业--------------遗传算法洪文杰S151000853 问题：用遗传算法求解f(x)=xsin(10π*x)+的最大值，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 = 64f (s4) = f(19) = 19^2 = 3613. 选择染色体的选择概率为：染色体的累计概率为：根据上面的式子，可得到：例如设从区间［0, 1］中产生4个随机数:r1 = , r2 =r3 = , r4 =4. 交叉基本遗传算法（SGA）中交叉算子采用单点交叉算子。
单点交叉运算5. 变异6. 至下一代，适应度计算→选择→交叉→变异，直至满足终止条件三、解决问题四、实验结果源代码：/*问题：用遗传算法求解f(x)=xsin(10π*x)+的最大值，x取[-1,2].*/ /*洪文杰2016-3-9. 智能优化算法第一次作业*/#include<iostream>//#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=;//最大值float f_x=;//最大值对应的自变量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=;//交叉概率float aberrance = ;//变异概率int key=1;cout<<"请输入求解区间:"<<endl;cin>>strat>>end;Num=hwj_coding(strat,end);cout<<"Num:"<<Num<<endl;// cout<<"--------------------------1-----------------"<<endl;hwj_initial_population(Num);// cout<<"--------------------------2初始种群-----------------"<<endl;/* for(int i=0;i<NUMBER;i++){for(int j=0;j<Num;j++){cout<<Unit[i][j]<<' ';}cout<<endl;}*/while(key!=GENE_NUMBER){hwj_fitness(Num);// cout<<"--------------------------3适应度-----------------"<<endl;// for(int i=0;i<NUMBER;i++){// cout<<Fitness[i]<<endl;// }hwj_choose();// cout<<"--------------------------4被选择的个体-----------------"<<endl; /* for(int i=0;i<NUMBER;i++){for(int j=0;j<Num;j++){cout<<Unit_choose[i][j]<<' ';}cout<<endl;}*/hwj_cross(Num,cross);/* cout<<"--------------------------5交叉后的种群-----------------"<<endl;for(int i=0;i<NUMBER;i++){for(int j=0;j<Num;j++){cout<<Unit[i][j]<<' ';}cout<<endl;}*/hwj_aberrance(Num,aberrance);/* cout<<"--------------------------6变异后的种群-----------------"<<endl;for(int i=0;i<NUMBER;i++){for(int j=0;j<Num;j++){cout<<Unit[i][j]<<' ';}cout<<endl;}*/key++;hwj_max(Num);}cout<<"最大值是对应的x值是:"<<endl;cout<<f_x<<endl;cout<<"最大值为:"<<f_max<<endl;return 0;}int hwj_coding(int start,int end){//种群编码float precision;int temp=2;int sum;int N=1;cout<<"请输入精度范围:"<<endl;cin>>precision;if(precision==0){cout<<"对不起精度不能为零:"<<endl;return 0;}else{sum=(end-start)/precision;cout<<"sum:"<<sum<<endl;while(temp<sum){temp*=2;N++;}return N;}}void hwj_initial_population(int num){//生成初始种群srand(time(NULL));for(int i=0;i<NUMBER;i++){for(int j=0;j<num;j++){Unit[i][j]=rand()%2;}}}void hwj_fitness(int num){//计算适应度float sum;int temp;temp=1;sum=;for(int j=num-1;j>=0;j--){sum+=Unit[i][j]*temp;temp*=;}Fitness[i]=sum*3/;// cout<<Fitness[i];// cout<<"--------------+++++";Fitness[i]=Fitness[i]*sin(10**Fitness[i])+;// cout<<Fitness[i]<<endl;}}int hwj_binary_search(int l,int r,float temp){for(int i=0;i<NUMBER;i++){if(temp<=accumula_probability[i]&&temp>accumula_probability[i-1]){ return i;}}return -1;}void hwj_choose(){//选择个体float sum=;float temp;int i;sum+=Fitness[i];}select_probability[0]=Fitness[0]/sum;temp=accumula_probability[0]=select_probability[0];for(i=1;i<NUMBER;i++){select_probability[i]=Fitness[i]/sum;temp+=select_probability[i];accumula_probability[i]=temp;// cout<<accumula_probability[i]<<endl;}for(i=0;i<NUMBER;i++){// srand(time(NULL));temp=(rand()%1000000)/;// cout<<temp;Number[i]=hwj_binary_search(0,NUMBER,temp);// cout<<Number[i]<<endl;for(int j=0;j<NUMBER;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<<a[i]<<endl;}}// cout<<a[i]<<' '<<b[a[i]]<<endl;}*/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<NUMBER;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<NUMBER;i++){// cout<<temp[i]<<" "<<cro[i]<<endl;// }// cout<<num_cross<<endl;for(i=0;i<num_cross/2;i++){srand(time(NULL));k=rand()%num;for(j=0;j<num;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<NUMBER;i++){// cout<<temp[i]<<endl;if(temp[i]==0){for(j=0;j<num;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<NUMBER;i++){abe[i]=-1;temp[i]=0;}// hwj_N_M(cro,temp,num_cross,NUMBER);srand(time(NULL));abe[0]=rand()%NUMBER;temp[abe[0]]=1;i=1;while(i!=num_aberrance){abe[i]=rand()%NUMBER;if(temp[abe[i]]==0){temp[abe[i]]=1;i++;}}for( i=0;i<NUMBER;i++){for( j=0;j<num_aberrance;j++){if(i==abe[j]){k=rand()%num;for( p=0;p<num;p++){if(p==k){if(Unit[i][p]==1){Unit[i][p]==0;}else{Unit[i][p]==1;}}}}}}}void hwj_max(int num){hwj_fitness(num);// float max=;int i;int temp=1;float sum=;int k;for(i=0;i<NUMBER;i++){// cout<<Fitness[i]<<endl;if(Fitness[i]>f_max){f_max=Fitness[i];k=i;}}for(int j=num-1;j>=0;j--){sum+=Unit[k][j]*temp;temp*=;}f_x=sum*3/;}。
遗传算法求解函数极值的应用
现 在 我们 用 遗 传 算 法 来 解 答 ：
１遗传 编 码
由 于 Ｘ 的 定 义 域 是ｆ １ １ 整 数 ，５ ２４， 以可 以用 ０。５ 的 １＜ ＾ 所 四 位 的二 进 制 来 表 示 此 问 题 如：０ ０表 示 Ｘ＝ １ １ ００ ０． １ １表示，
ｋ ｅｙ ｗｏｒ ｓ Ｇｅ ｅｉ ｇ ｒｔ ｍｓＣｏ ｉ ｇＣｈ ｉｅＨｙ ｒｄ； ｒａｉｎ ｄ ： ｎ ｔｃＡｌｏ ｉ ｈ ； ｄ ｎ ； ｏｃ ； ｂ ｉ Ｖａ ｉｃ ｏ
遗 传 算 法 （ｅ ｅ ｃａ ｏｉ ｍｓ 简 称 Ｇ 是 根 据 自然 ｇｎｔ ｌ ｒｈ ， ｉ ｇ ｔ Ａ） 界 的 “ 竞 天 择 ． 者 生 存 ” 象 而 提 出来 的 一 种 随 机 搜 物 适 现 索 算 法 ， 是 霍 兰 德 （ ｏｌ ｄ 于 １７ Ｈ ｌｎ ） ａ ９ ５年 在 他 的 著 作 《 ｄ ｐ ｏ ｎＮ ｔｒ ｎ ｒｆｉ ｙｔ ｓ 中 首 次 提 出 来 Ａ ａ ｔ ｎｉ ａ ａ ａｄ ａ ｉｃ ｌＳｓ ｍ ｝ ｉ ｕｌ ｔ ａ ｉ ｅ ｝ 的 此 算 法 将 优 化 问 题 看 作 是 自 然 界 中 生 物 的 进 化 过 程 ．通 过 模 拟 大 自然 中 生 物 进 化 过 程 中 的 遗 传 规 律 ， 来
关 键词 ： 遗传 算 法 ； 码 ； 编 选择 ； 交 ； 杂 变异
中图分 类号 ： Ｐ ８ Ｔ １
文献标识码 ： Ａ
文章编号 ：０ ９ ３ ４ （０ ７２ — ０ ０ — ２ １ ０ — ０ ４２ ０ ）１ ４ ８ ２ ０
ＺＨ Ｏ Ｕ ＺＨ ＡＮ Ｇ ｉ ｈ ｎ Ｌｉ Ｚｈ —ｓ ｕ
遗传算法求解函数最大值
遗传算法求解函数最大值研究者们广泛使用各种数学方法来求解函数的最大值，其中遗传算法是一种有效的解决方案。
遗传算法是一种仿生算法，使用相似的进化过程来搜索函数的最大值，这种算法在解决复杂问题时尤其有效。
遗传算法的工作原理是利用遗传操作来进行搜索。
它的步骤大致如下：首先，从初始种群中随机选择一定数量的个体，并进行多次重复，对其属性进行多次迭代，形成较优个体。
然后，根据结果，重建种群，以提高适应度。
在这个过程中，种群中的属性将不断改变，个体之间会遗传和变异，从而改变函数的最大值。
当属性变化趋于稳定时，这种改变的步骤就会停止，最大值就得到了。
为了更好地理解遗传算法，我们先来看一个例子。
一维函数f(x)=x^2-2x+5可以用遗传算法来求最大值。
我们以染色体序列长度为10作为种群大小，创建初始种群，并在每一代经历重复，变异，选择和交叉过程之后，依次获得较优个体。
在这个过程中，染色体序列不断变异，最后形成二进制数f(x)的最大值，最终求得f(x)的最大值为9。
遗传算法具有很多优点，其中最重要的是，它可以解决最优化问题，而且能够在有限的时间里达到不错的效果。
此外，遗传算法不会受到维度或者变量数量的限制，而且它可以根据需要改变变量的组合，从而获得更好的运算结果。
最后，遗传算法也可以应用在实际工程中，这就是遗传算法求解函数最大值的重要应用之一。
总的来说，遗传算法是一种通用的解决方案，能有效地搜索函数的最大值。
虽然它具有很多优点，但也有一些限制。
例如，算法的效率跟种群的大小有关，种群大小越大，搜索效率就越低，而且有时它也会陷入局部最优解中，从而无法搜索到全局最优解。
遗传算法可以给出不错的搜索结果，可以有效地求解函数最大值，是一种普遍应用的有效搜索方法。
因此，在未来，它将继续受到研究者们的广泛关注，并为世人带来更多的益处。
遗传算法求四元函数极值
遗传算法求四元函数极值遗传算法是一种启发式搜索算法，可以用来求解函数的极值问题。
对于四元函数，我们可以采用以下步骤来求解其极值：1.确定变量范围：对于四元函数，我们需要确定每个变量的取值范围。
2.初始化种群：以随机方式生成一组初始解作为种群的第一代。
3.评价适应度：根据目标函数的值，评价每个个体的适应度。
4.选择交叉操作：从种群中选择适应度较高的个体，并对它们进行交叉操作，生成新的个体。
5.变异操作：对于一部分个体，进行变异操作，以增加种群的多样性。
6.更新种群：将新生成的个体加入到种群中，并淘汰适应度较低的个体。
7.检查终止条件：如果达到了预设的终止条件，算法停止；否则，继续进行第3步。
可以通过多次迭代，不断优化种群中的个体，直到得到满意的极值或达到最大迭代次数为止。
对于四元函数极值问题，考虑以下四元函数：f(x1,x2,x3,x4)=x1^2+x2^2+x3^2+x4^2。
假设变量范围均在[-5,5]之间，则可以采用以下Python代码来实现遗传算法求解极值：``` python。
import numpy as np。
def fitness(x):。
return sum(x**2)。
def selection(population, fitness):。
idx = np.random.choice(len(population), size=len(population), replace=True, p=fitness/fitness.sum())。
return population[idx]。
def crossover(parents, p_crossover=0.9):。
offspring = np.empty_like(parents)。
for i in range(len(parents)//2):。
p1, p2 = parents[2*i], parents[2*i+1]。
if np.random.rand() < p_crossover:。
实验五：遗传算法求解函数最值问题实验
实验五：遗传算法求解函数最值问题实验一、实验目的使用遗传算法求解函数在及y的最大值。
二、实验内容使用遗传算法进行求解，篇末所附源代码中带有算法的详细注释。
算法中涉及不同的参数，参数的取值需要根据实际情况进行设定，下面运行时将给出不同参数的结果对比。
定义整体算法的结束条件为，当种群进化次数达到maxGeneration时停止，此时种群中的最优解即作为算法的最终输出。
设种群规模为N，首先是随机产生N个个体，实验中定义了类型Chromosome表示一个个体，并且在默认构造函数中即进行了随机的操作。
然后程序进行若干次的迭代，在每次迭代过程中，进行选择、交叉及变异三个操作。
1.选择操作首先计算当前每个个体的适应度函数值，这里的适应度函数即为所要求的优化函数，然后归一化求得每个个体选中的概率，然后用轮盘赌的方法以允许重复的方式选择选择N个个体，即为选择之后的群体。
但实验时发现结果不好，经过仔细研究之后发现，这里在x、y 取某些值的时候，目标函数计算出来的适应值可能会出现负值，这时如果按照把每个个体的适应值除以适应值的总和的进行归一化的话会出现问题，因为个体可能出现负值，总和也可能出现负值，如果归一化的时候除以了一个负值，选择时就会选择一些不良的个体，对实验结果造成影响。
对于这个问题，我把适应度函数定为目标函数的函数值加一个正数，保证得到的适应值为正数，然后再进行一般的归一化和选择的操作。
实验结果表明，之前的实验结果很不稳定，修正后的结果比较稳定，趋于最大值。
2.交叉操作首先是根据交叉概率probCross选择要交叉的个体进行交叉。
这里根据交叉参数crossnum进行多点交叉，首先随机生成交叉点位置，允许交叉点重合，两个重合的交叉点效果互相抵消，相当于没有交叉点，然后根据交叉点进行交叉操作，得到新的个体。
3.变异操作首先是根据变异概率probMutation选择要变异的个体。
变异时先随机生成变异的位置，然后把改位的01值翻转。
极大值的计算方法
极大值的计算方法在数学中，极大值是一个与函数相关的概念，它指的是函数取得最大值的点。
求函数的极大值是数学中常见的问题之一，在不同的领域，极大值计算方法也不尽相同。
本文将介绍几种常见的极大值计算方法。
一、导数法在一元函数中，求解极值可以利用导数的概念。
如果函数在某个点处导数为零，那么这个点可能是极值点。
具体来说，如果函数在某点处导数为零，而在该点的左侧导数为正，右侧导数为负，那么这个点就是函数的局部最大值。
反之，如果函数在某点处导数为零，而在该点的左侧导数为负，右侧导数为正，那么这个点就是函数的局部最小值。
但是，需要注意的是，导数为零并不总是意味着极值存在。
事实上，一些特殊的函数在某些情况下也会出现导数为零而不是极值的问题。
因此，我们需要结合具体情况进行分析。
二、二分查找法在一些具有单峰函数性质的问题中，可以使用二分查找法求解极值。
单峰函数是指函数有一个唯一的极大值或极小值，且以此为分割点两侧函数值呈单调性变化。
对于这种函数，我们可以采用二分查找法来逼近极值。
具体做法是：先随机选择一个起点，然后计算其一侧的函数值。
如果这一侧的函数值递减，那么极值可能存在于这一侧。
此时，再从这一侧中间随机选取一个点，重复进行计算比较，直到一个足够小的精度范围内得到极值点。
三、梯度下降法梯度下降法是一种常用的优化算法，也可以用来寻找函数的极值点。
其基本思路是通过不断迭代，在每次迭代的过程中向函数值降低的方向移动，直到收敛到极值点。
具体实现时，需要先选定一个起始点，然后计算该点处函数的梯度（即函数对各个自变量的偏导数向量）。
按照负梯度的方向更新自变量，得到相邻的一个点。
不断重复这个过程，直到收敛到某个点或达到最大迭代次数。
四、蒙特卡洛法蒙特卡洛法是一种随机化的算法，可以应用于一些难以直接求解的问题中。
在极值计算中，我们可以使用蒙特卡洛法模拟函数值的随机取样，通过统计这些样本中的最大值来估计极值点。
具体做法是：根据一定的概率分布生成随机点，然后计算这些点的函数值。
求极值的若干方法
求极值的若干方法一、导数法导数法是求函数极值最常用的方法之一、通过计算函数的导数并将其置为0，可以找到函数的驻点。
驻点即为函数可能的极值点。
对驻点进行二阶导数测试，如果二阶导数为正则为极小值点，如果二阶导数为负则为极大值点。
二、边界点法对于定义在一定范围内的函数，其极值点可能出现在这个范围的边界上。
因此，通过计算函数在边界点处的值，并与内部驻点的值进行比较，可以得到函数的极值。
三、拉格朗日乘数法拉格朗日乘数法适用于带有约束条件的优化问题。
对于求解函数在约束条件下的极值问题，通过引入拉格朗日乘数，将约束条件加入到目标函数中，然后对引入的约束条件和目标函数进行求导，可以得到关于约束条件和目标函数的一组方程，通过求解这组方程可以得到极值点。
四、牛顿法牛顿法是一种迭代法，通过不断地进行线性逼近来逐步逼近极值点。
该方法通过迭代逼近函数的根，利用函数的一阶导数和二阶导数进行求解。
通过不断迭代，可以逐步逼近极值点。
五、切线法切线法是一种简单但有效的求解极值的方法。
切线法基于函数在极值点处的切线垂直于函数曲线的性质。
首先选择一个初始点，然后沿着函数曲线进行迭代，在每一步迭代中，找到当前点处的切线，然后将切线与坐标轴相交的点作为下一步的迭代点，直至找到极值点。
六、割线法割线法是一种介于切线法和牛顿法之间的方法。
该方法适用于函数的导数不能很容易地求解的情况。
割线法通过选择两个初始点，然后计算这两个点处的斜率，使用割线的性质来逼近极值点。
通过不断迭代计算新的割线与x轴相交的点，可以逐步逼近极值点。
七、二分法二分法适用于具有单调性的函数的极值求解。
该方法通过选择一个区间，然后将其一分为二，比较中点和两个区间端点处函数的值，缩小区间范围，直至找到极值点。
八、遗传算法遗传算法是一种模拟进化过程的优化算法，常用于求解复杂问题中的极值。
该方法模拟生物进化的过程，通过随机生成一组初始解，然后通过交叉、变异等操作对解进行改进和演化，最终得到一个相对较优的解。
二进制编码遗传算法求函数极大值
二进制编码遗传算法求函数极大值二进制编码遗传算法是一种用于求解函数极大值的优化方法。
通过将函数的自变量编码为二进制字符串，然后利用遗传算法进行搜索，以找到函数的极大值。
下面是详细步骤：1. 确定问题：首先，明确需要求解的函数以及自变量的取值范围。
例如，假设我们要寻找函数f(x) = x^2 + 3x - 2在[0, 10]范围内的最大值。
2. 二进制编码：将自变量x的取值范围划分为若干个区间，然后用二进制字符串表示每个区间。
例如，如果将区间[0, 10]划分为5个区间，那么二进制编码的长度为log2(5) = 3。
3. 构建初始种群：根据二进制编码规则，生成一定数量的初始个体。
每个个体表示一个可能的解。
例如，生成10个个体。
4. 评估适应度：将每个个体解码为自变量x，计算对应的函数值f(x)。
然后，根据函数值计算每个个体的适应度。
适应度越高，表示个体对应的解越有可能为极大值。
5. 选择操作：采用轮盘赌选择法等策略，从当前种群中选择一部分优秀个体作为父代，用于产生下一代。
6. 交叉操作：对选定的父代个体进行交叉，生成一定数量的子代。
交叉操作可以采用单点交叉、多点交叉等方法。
7. 变异操作：对子代个体进行变异，即随机改变某些位上的二进制值。
变异操作有助于保持种群的多样性。
8. 更新种群：根据新的个体适应度重新构建种群。
9. 终止条件：当满足终止条件（如达到最大遗传代数、找到满足精度要求的极大值等）时，算法结束。
10. 结果输出：输出找到的极大值以及对应的自变量值。
通过以上步骤，二进制编码遗传算法可以用于求解函数的极大值。
需要注意的是，二进制编码遗传算法的性能受到种群数量、编码长度、交叉率、变异率等因素的影响，需要根据实际情况调整参数。
遗传算法求多元函数的极值
遗传算法求多元函数的极值
遗传算法是一种基于生物进化理论的优化算法，可以用来求解多元函数的极值。
下面介绍遗传算法求解多元函数极值的基本流程：
确定目标函数：首先需要确定待优化的目标函数，将其转化为一个优化问题。
确定变量范围和初始种群：对于每个变量，需要确定其可行域范围，并生成一个随机的初始种群。
适应度函数的定义：根据目标函数确定适应度函数，并将其作为评估个体优劣的标准。
选择操作：选择操作是遗传算法的核心，通过适应度函数选择个体，以保留优良个体。
遗传操作：包括交叉和变异两种操作。
交叉操作是指将两个个体的染色体部分进行交换，从而产生新个体；变异操作是指对某个个体的染色体部分进行随机变换，从而产生新个体。
繁殖新种群：通过选择和遗传操作，生成新的种群，并根据适应度函数进行排序。
判断停止条件：根据实际情况设定停止条件，如达到最大迭代次数、收敛到一定程度等。
输出结果：在满足停止条件后，输出当前最优解和最优适应度值。
需要注意的是，遗传算法求解多元函数极值需要根据实际情况调整参数和优化算法流程，以达到最优结果。
神经网络遗传算法函数极值寻优-非线性函数极值
%% 清空环境变量clccleartic%% 训练数据预测数据提取及归一化%下载输入输出数据load data input output%从1到2000间随机排序k=rand(1,4000);[m,n]=sort(k);%找出训练数据和预测数据input_train=input(n(1:3900),:)';output_train=output(n(1:3900),:)';input_test=input(n(3901:4000),:)';output_test=output(n(3901:4000),:)';%选连样本输入输出数据归一化[inputn,inputps]=mapminmax(input_train); [outputn,outputps]=mapminmax(output_train);%% BP网络训练% %初始化网络结构net=newff(inputn,outputn,5);net.trainParam.epochs=100;net.trainParam.lr=0.1;net.trainParam.goal=0.0000004;%网络训练net=train(net,inputn,outputn);%% BP网络预测%预测数据归一化inputn_test=mapminmax('apply',input_test,inputps);%网络预测输出an=sim(net,inputn_test);%网络输出反归一化BPoutput=mapminmax('reverse',an,outputps);%% 结果分析figure(1)plot(BPoutput,':og')hold onplot(output_test,'-*');legend('预测输出','期望输出','fontsize',12)title('BP网络预测输出','fontsize',12)xlabel('样本','fontsize',12)ylabel('输出','fontsize',12)print -dtiff -r600 4-3%预测误差error=BPoutput-output_test;figure(2)plot(error,'-*')title('神经网络预测误差')figure(3)plot((output_test-BPoutput)./BPoutput,'-*');title('神经网络预测误差百分比')errorsum=sum(abs(error))tocsave data net inputps outputps%%Codefunction ret=Code(lenchrom,bound)%本函数将变量编码成染色体，用于随机初始化一个种群% lenchrom input : 染色体长度% bound input : 变量的取值范围% ret output: 染色体的编码值flag=0;while flag==0pick=rand(1,length(lenchrom));ret=bound(:,1)'+(bound(:,2)-bound(:,1))'.*pick; %线性插值，编码结果以实数向量存入ret 中flag=test(lenchrom,bound,ret); %检验染色体的可行性end%%Crossfunction ret=Cross(pcross,lenchrom,chrom,sizepop,bound)%本函数完成交叉操作% pcorss input : 交叉概率% lenchrom input : 染色体的长度% chrom input : 染色体群% sizepop input : 种群规模% ret output : 交叉后的染色体for i=1:sizepop %每一轮for循环中，可能会进行一次交叉操作，染色体是随机选择的，交叉位置也是随机选择的，%但该轮for循环中是否进行交叉操作则由交叉概率决定（continue控制）% 随机选择两个染色体进行交叉pick=rand(1,2);while prod(pick)==0pick=rand(1,2);endindex=ceil(pick.*sizepop);% 交叉概率决定是否进行交叉pick=rand;while pick==0pick=rand;endif pick>pcrosscontinue;endflag=0;while flag==0% 随机选择交叉位pick=rand;while pick==0pick=rand;endpos=ceil(pick.*sum(lenchrom)); %随机选择进行交叉的位置，即选择第几个变量进行交叉，注意：两个染色体交叉的位置相同pick=rand; %交叉开始v1=chrom(index(1),pos);v2=chrom(index(2),pos);chrom(index(1),pos)=pick*v2+(1-pick)*v1;chrom(index(2),pos)=pick*v1+(1-pick)*v2; %交叉结束flag1=test(lenchrom,bound,chrom(index(1),:)); %检验染色体1的可行性flag2=test(lenchrom,bound,chrom(index(2),:)); %检验染色体2的可行性if flag1*flag2==0flag=0;else flag=1;end %如果两个染色体不是都可行，则重新交叉endendret=chrom;。
利用遗传算法求函数的极小值
1、利用遗传算法求出下面函数的极小值：z=2-exp[-(x2+y2)], x,y∈[-5,+5]对于此函数，求某一极值、或说最值时，由于x、y定义域与系数相同，x与y相对于z 来说是地位等同的，因此可以转换成求该函数极值：；继而转换成了一种单变量函数。
函数的实现：（1）ga_main脚本文件% GA main program% Edited by Bian Xuezi% n ---- 种群规模% ger ---- 迭代次数% pc ---- 交叉概率% pm ---- 变异概率% v ---- 初始种群（规模为n）% f ---- 目标函数值% fit ---- 适应度向量% vx ---- 最优适应度值向量% vmfit ---- 平均适应度值向量clear all;close all;clc;tic;n=20;ger=100;pc=0.70;pm=0.009;% 生成初始种群v=init_population(n,20);[N,L]=size(v);disp(sprintf('Number of generations:%d',ger)); disp(sprintf('Population size:%d',N));disp(sprintf('Crossover probability:%.3f',pc)); disp(sprintf('Mutation probability:%.3f',pm)); % 待优化问题xmin=-5;ymin=-5;xmax=5;ymax=5;f='-2+exp(-x.^2-y.^2)';%初始化sol=0.1;vmfit=[];it=1;vx=[];%C=[];% 计算适应度，并画出图形x=decode(v(:,1:10),xmin,xmax);y=decode(v(:,11:20),ymin,ymax);fit=eval(f);figure(1);[X,Y]=meshgrid(-5:0.1:5,-5:0.1:5);Z=-2+exp(-X.^2-Y.^2);mesh(X,Y,Z);grid on;hold on;plot3(x,y,fit,'k*');title('染色体的初始位置');xlabel('x');ylabel('y');zlabel('f(x,y)');% 开始进化while it<=ger%Reproduction(Bi-classist Selection) vtemp=roulette(v,fit);%Crossoverv=crossover(vtemp,pc);%MutationM=rand(N,L)<=pm;%M(1,:)=zeros(1,L);v=v-2.*(v.*M)+M;%Resultsx=decode(v(:,1:10),xmin,xmax);y=decode(v(:,11:20),ymin,ymax);fit=eval(f);[sol,indb]=max(fit);v(1,:)=v(indb,:);media=mean(fit);vx=[vx sol];vmfit=[vmfit media];it=it+1;end%%%% 最后的结果disp(sprintf('\n')); %空一行% 显示最优解及最优值disp(sprintf('Maximum found[x,f(x)]:[%.4f,%.4f,%.4f]',x(indb),y(indb),sol)); % 图形显示最优结果figure(2);[X,Y]=meshgrid(-5:0.1:5,-5:0.1:5);Z=-2+exp(-X.^2-Y.^2);mesh(X,Y,Z);grid on;hold on;plot3(x,y,fit,'k*');title('染色体的最终位置');xlabel('x');ylabel('y');zlabel('f(x,y)');% 图形显示最优及平均函数值变化趋势figure(3);plot(vx);%title('最优,平均函数值变化趋势'); xlabel('Generations');ylabel('f(x,y)');hold on;plot(vmfit,'r');hold off;runtime=toc（2）Crossover函数%Crossoverfunction v=crossover(vtemp,pc) [N,L]=size(vtemp);C(:,1)=rand(N,1)<=pc;I=find(C(:,1)==1);I';j=1;for i=1:2:size(I)if i>=size(I)break;endsite=fix(1+L*rand(1));temp=vtemp(I(i,1),:);vtemp(I(i,1),site:end)=vtemp(I(i+1,1),site:end); vtemp(I(i+1,1),site:end)=temp(:,site:end);%j=j+2;endv=vtemp;（3）decode函数%Decodify bitstringsfunction x=decode(v,min,max)% x ----真实值% v ----待解码的已编码的0-1串v=fliplr(v);[s,c]=size(v);aux=0:1:c-1 ;%21;aux=ones(s(1),1)*aux;x1=sum((v.*2.^aux)');x=min+(max-min)*x1./(2^c-1); % ; （4）init_population函数function v=init_population(n1,s1)v=round(rand(n1,s1));（5）roulette函数function vtemp=roulette(v,fit)N=size(v);fitmin=abs(min(fit));fit=fitmin+fit;%fitS=sum(fit);for i=1:NSI=S*rand(1);for j=1:Nif SI<=sum(fit(1:j))vtemp(i,:)=v(j,:);breakendendend。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
智能优化算法第一次作业--------------遗传算法洪文杰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 = 64f (s4) = f(19) = 19^2 = 3613. 选择染色体的选择概率为：染色体的累计概率为：根据上面的式子，可得到：例如设从区间［0, 1］中产生4个随机数: r1 = 0.450126, r2 = 0.110347 r3 = 0.572496, r4 = 0.985034. 交叉基本遗传算法（SGA）中交叉算子采用单点交叉算子。
单点交叉运算5. 变异6. 至下一代，适应度计算→选择→交叉→变异，直至满足终止条件三、解决问题四、实验结果源代码：/*问题：用遗传算法求解f(x)=xsin(10π*x)+2.0的最大值，x取[-1,2].*/ /*洪文杰2016-3-9. 智能优化算法第一次作业*/#include<iostream>//#includ<stdio.h>#include<stdlib.h>#include<math.h>#include<time.h>#include<float.h>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<<"请输入求解区间:"<<endl;cin>>strat>>end;Num=hwj_coding(strat,end);cout<<"Num:"<<Num<<endl;// cout<<"--------------------------1-----------------"<<endl;hwj_initial_population(Num);// cout<<"--------------------------2初始种群-----------------"<<endl; /* for(int i=0;i<NUMBER;i++){for(int j=0;j<Num;j++){cout<<Unit[i][j]<<' ';}cout<<endl;}*/while(key!=GENE_NUMBER){hwj_fitness(Num);// cout<<"--------------------------3适应度-----------------"<<endl;// for(int i=0;i<NUMBER;i++){// cout<<Fitness[i]<<endl;// }hwj_choose();// cout<<"--------------------------4被选择的个体-----------------"<<endl; /* for(int i=0;i<NUMBER;i++){for(int j=0;j<Num;j++){cout<<Unit_choose[i][j]<<' ';}cout<<endl;}*/hwj_cross(Num,cross);/* cout<<"--------------------------5交叉后的种群-----------------"<<endl;for(int i=0;i<NUMBER;i++){for(int j=0;j<Num;j++){cout<<Unit[i][j]<<' ';}cout<<endl;}*/hwj_aberrance(Num,aberrance);/* cout<<"--------------------------6变异后的种群-----------------"<<endl;for(int i=0;i<NUMBER;i++){for(int j=0;j<Num;j++){cout<<Unit[i][j]<<' ';}cout<<endl;}*/key++;hwj_max(Num);}cout<<"最大值是对应的x值是:"<<endl;cout<<f_x<<endl;cout<<"最大值为:"<<f_max<<endl;return 0;}int hwj_coding(int start,int end){//种群编码float precision;int temp=2;int sum;int N=1;cout<<"请输入精度范围:"<<endl;cin>>precision;if(precision==0){cout<<"对不起精度不能为零:"<<endl;return 0;}else{sum=(end-start)/precision;cout<<"sum:"<<sum<<endl;while(temp<sum){temp*=2;N++;}return N;}}void hwj_initial_population(int num){//生成初始种群srand(time(NULL));for(int i=0;i<NUMBER;i++){for(int j=0;j<num;j++){Unit[i][j]=rand()%2;}}}void hwj_fitness(int num){//计算适应度float sum;int temp;for(int i=0;i<NUMBER;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<<Fitness[i];// cout<<"--------------+++++";Fitness[i]=Fitness[i]*sin(10*3.1415926*Fitness[i])+2.0;// cout<<Fitness[i]<<endl;}}int hwj_binary_search(int l,int r,float temp){for(int i=0;i<NUMBER;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<NUMBER;i++){sum+=Fitness[i];}select_probability[0]=Fitness[0]/sum;temp=accumula_probability[0]=select_probability[0];for(i=1;i<NUMBER;i++){select_probability[i]=Fitness[i]/sum;temp+=select_probability[i];accumula_probability[i]=temp;// cout<<accumula_probability[i]<<endl;}for(i=0;i<NUMBER;i++){// srand(time(NULL));temp=(rand()%1000000)/1000000.0;// cout<<temp;Number[i]=hwj_binary_search(0,NUMBER,temp);// cout<<Number[i]<<endl;for(int j=0;j<NUMBER;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<<a[i]<<endl;}}// cout<<a[i]<<' '<<b[a[i]]<<endl;}*/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<NUMBER;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<NUMBER;i++){// cout<<temp[i]<<" "<<cro[i]<<endl;// }// cout<<num_cross<<endl;for(i=0;i<num_cross/2;i++){srand(time(NULL));k=rand()%num;for(j=0;j<num;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<NUMBER;i++){// cout<<temp[i]<<endl;if(temp[i]==0){for(j=0;j<num;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<NUMBER;i++){abe[i]=-1;temp[i]=0;}// hwj_N_M(cro,temp,num_cross,NUMBER);srand(time(NULL));abe[0]=rand()%NUMBER;temp[abe[0]]=1;i=1;while(i!=num_aberrance){abe[i]=rand()%NUMBER;if(temp[abe[i]]==0){temp[abe[i]]=1;i++;}}for( i=0;i<NUMBER;i++){for( j=0;j<num_aberrance;j++){if(i==abe[j]){k=rand()%num;for( p=0;p<num;p++){if(p==k){if(Unit[i][p]==1){Unit[i][p]==0;}else{Unit[i][p]==1;}}}}}}}void hwj_max(int num){hwj_fitness(num);// float max=0.0;int i;int temp=1;float sum=0.0;int k;for(i=0;i<NUMBER;i++){// cout<<Fitness[i]<<endl;if(Fitness[i]>f_max){f_max=Fitness[i];k=i;}}for(int j=num-1;j>=0;j--){sum+=Unit[k][j]*temp;temp*=2.0;}f_x=sum*3/(temp-1.0)-1.0;}。