遗传算法十进制编码求函数极大值程序
利用遗传算法求函数的极大值
利用遗传算法求函数的极大值该函数有两个局部极大值点，分别是f (2.048,-2.048)=3897.7342和f (2.048,-2.048)=3905.9262，其中，后者为全局最大点。
可以分别用二进制编码和十进制编码遗传算法求函数极大值遗传算法二进制编码求函数极大值程序%Generic Algorithm for function f(x1,x2) optimumclear all;close all;%Parameters 参数Size=80; %群体大小G=100; %终止进化代数CodeL=10; %代码长度umax=2.048;umin=-2.048;E=round(rand(Size,2*CodeL)); %Initial Code 最初代码%Main Program 主程序for k=1:1:Gtime(k)=k;222212121(,)100()(1)2.048 2.048(1,2)i f x x x x x x i ⎧=-+-⎨-≤≤=⎩for s=1:1:Sizem=E(s,:);y1=0;y2=0; %X对应的十进制代码%Uncodingm1=m(1:1:CodeL);for i=1:1:CodeLy1=y1+m1(i)*2^(i-1); %将y1转换为十进制数endx1=(umax-umin)*y1/1023+umin;m2=m(CodeL+1:1:2*CodeL);for i=1:1:CodeLy2=y2+m2(i)*2^(i-1); %将y2转换为十进制数endx2=(umax-umin)*y2/1023+umin; %求x对应的十进制数F(s)=100*(x1^2-x2)^2+(1-x1)^2; %个体适应度函数endJi=1./F; %个体适应度函数的倒数%****** Step 1 : Evaluate BestJ ******BestJ(k)=min(Ji);fi=F; %Fitness Function 适应函数[Oderfi,Indexfi]=sort(fi); %Arranging fi small to biggerBestfi=Oderfi(Size); %Let Bestfi=max(fi)BestS=E(Indexfi(Size),:); %Let BestS=E(m), m is the Indexfi belong to max(fi) %最佳样本bfi(k)=Bestfi;%****** Step 2 : Select and Reproduct Operation******fi_sum=sum(fi);fi_Size=(Oderfi/fi_sum)*Size;fi_S=floor(fi_Size); %Selecting Bigger fi valuekk=1;for i=1:1:Sizefor j=1:1:fi_S(i) %Select and ReproduceTempE(kk,:)=E(Indexfi(i),:);kk=kk+1; %kk is used to reproduceendend%************ Step 3 : Crossover Operation ************pc=0.60; %交叉概率n=ceil(20*rand); %种群大小for i=1:2:(Size-1)temp=rand;if pc>temp %Crossover Conditionfor j=n:1:20TempE(i,j)=E(i+1,j); %交换E（i,j）和E(i+1,j)TempE(i+1,j)=E(i,j);endendendTempE(Size,:)=BestS;E=TempE;%************ Step 4: Mutation Operation ************** %pm=0.001; %变异概率%pm=0.001-[1:1:Size]*(0.001)/Size; %Bigger fi, smaller Pm %pm=0.0; %No mutationpm=0.1; %Big mutationfor i=1:1:Sizefor j=1:1:2*CodeLtemp=rand;if pm>temp %Mutation Conditionif TempE(i,j)==0TempE(i,j)=1;elseTempE(i,j)=0;endendendend%Guarantee TempPop(30,:) is the code belong to the best individual(max(fi)) TempE(Size,:)=BestS;E=TempE;endMax_Value=BestfiBestSx1x2figure(1);plot(time,BestJ); %目标函数和时间的坐标系xlabel('Times');ylabel('Best J');figure(2);plot(time,bfi);xlabel('times');ylabel('Best F');遗传算法十进制编码求函数极大值程序%Generic Algorithm for function f(x1,x2) optimumclear all;close all;%Parameters参数Size=80;G=100; %迭代次数CodeL=10; %编码长度umax=2.048;umin=-2.048;E=round(rand(Size,2*CodeL)); %Initial Code ？？？%Main Programfor k=1:1:Gtime(k)=k;for s=1:1:Sizem=E(s,:);y1=0;y2=0;%Uncodingm1=m(1:1:CodeL); %？？？for i=1:1:CodeLy1=y1+m1(i)*2^(i-1);endx1=(umax-umin)*y1/1023+umin;m2=m(CodeL+1:1:2*CodeL);for i=1:1:CodeLy2=y2+m2(i)*2^(i-1);endx2=(umax-umin)*y2/1023+umin;F(s)=100*(x1^2-x2)^2+(1-x1)^2;endJi=1./F;%****** Step 1 : Evaluate BestJ ****** BestJ(k)=min(Ji);fi=F; %Fitness Function[Oderfi,Indexfi]=sort(fi); %Arranging fi small to biggerBestfi=Oderfi(Size); %Let Bestfi=max(fi)BestS=E(Indexfi(Size),:); %Let BestS=E(m), m is the Indexfi belong to max(fi)bfi(k)=Bestfi;%****** Step 2 : Select and Reproduct Operation******fi_sum=sum(fi);fi_Size=(Oderfi/fi_sum)*Size;fi_S=floor(fi_Size); %Selecting Bigger fi valuekk=1;for i=1:1:Sizefor j=1:1:fi_S(i) %Select and ReproduceTempE(kk,:)=E(Indexfi(i),:);kk=kk+1; %kk is used to reproduceendend%************ Step 3 : Crossover Operation ************ pc=0.60;n=ceil(20*rand);for i=1:2:(Size-1)temp=rand;if pc>temp %Crossover Conditionfor j=n:1:20TempE(i,j)=E(i+1,j);TempE(i+1,j)=E(i,j);endendendTempE(Size,:)=BestS;E=TempE;%************ Step 4: Mutation Operation ************** %pm=0.001;%pm=0.001-[1:1:Size]*(0.001)/Size; %Bigger fi, smaller Pm%pm=0.0; %No mutationpm=0.1; %Big mutationfor i=1:1:Sizefor j=1:1:2*CodeLtemp=rand;if pm>temp %Mutation Conditionif TempE(i,j)==0TempE(i,j)=1;elseTempE(i,j)=0;endendendend%Guarantee TempPop(30,:) is the code belong to the best individual(max(fi)) TempE(Size,:)=BestS;E=TempE;endMax_Value=BestfiBestSx1x2figure(1);plot(time,BestJ);xlabel('Times');ylabel('Best J');figure(2);plot(time,bfi);xlabel('times');ylabel('Best F');思考：通过改变群体大小、终止进化代数G、交叉概率P c和变异概率P m，分析群体大小、终止进化代数、交叉概率和变异概率对优化效果的影响。
利用遗传算法求函数的极大值
利用遗传算法求函数的极大值遗传算法是一种通过模拟生物进化的方式来解决优化问题的算法。
它基于达尔文的演化论思想，通过不断演化和交叉变异，逐步优化解空间中的解向最优解靠拢。
在求解函数的极大值问题中，遗传算法可以通过优化染色体的基因序列来寻找最大值点。
遗传算法的基本流程如下：1.初始化种群：随机生成初始种群，每个个体都对应问题的一个可能解。
2.适应度评估：根据问题的具体要求，计算每个个体的适应度值，即目标函数值。
3.选择操作：根据适应度值选择一定数量的个体作为父代，用于进行交叉和变异操作。
4.交叉操作：从父代中选择两个个体，按照一定的交叉规则对其基因序列进行交叉生成子代。
5.变异操作：对子代的基因序列进行一定概率的变异操作，引入新的基因。
6.新一代种群形成：将父代和子代合并形成新一代种群。
7.终止条件判断：根据设定的终止条件判断是否停止算法。
8.若满足终止条件，输出结果；否则，转至步骤2在求解函数的极大值问题中，适应度评估的目标函数可以直接使用待求解函数的值。
下面以一个简单的函数f(x)=x^2为例，说明如何利用遗传算法求函数的极大值。
1.初始化种群：随机生成一定数量的个体，每个个体的基因序列代表一个可能的解，在本例中基因序列即为x的取值。
2.适应度评估：计算每个个体的适应度，即将基因序列代入目标函数得到函数值。
3.选择操作：根据适应度值选择一定数量的个体作为父代。
4.交叉操作：从父代中选择两个个体，按照一定的交叉规则对其基因序列进行交叉生成子代。
5.变异操作：对子代的基因序列进行一定概率的变异操作，引入新的基因。
6.新一代种群形成：将父代和子代合并形成新一代种群。
7.终止条件判断：根据设定的终止条件判断是否停止算法。
例如，可以设定迭代次数达到一定阈值或者适应度值足够接近最大值。
8.若满足终止条件，输出最优解的基因序列；否则，转至步骤2通过不断迭代上述步骤，遗传算法可以逐步逼近函数的极大值点。
在实际应用中，可以根据问题的具体特性和要求对交叉、变异概率等参数进行调整，以达到更好的求解效果。
遗传算法求函数最大值实验报告
遗传算法求函数最大值实验报告遗传算法是一种模拟自然界进化过程的优化算法，它通过模拟生物进化过程中的遗传、交叉和变异等机制，逐步优化解空间中的个体，以找到问题的最优解。
在本次实验中，我们利用遗传算法来求解一个函数的最大值。
下面我们将详细介绍实验的过程和结果。
首先，我们选择了一个简单的函数作为实验对象，即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]。
遗传算法用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。
编程实现利用遗传算法求解方程最值
编程实现利用遗传算法求解方程最值一．函数为：求函数y=x+3*sin(2*x)-7*cos(x) 在【-4 4】的最大值二．MATLAB 程序如下：1.主控制程序GA.m%求函数y=x+3*sin(2*x)-7*cos(x) 在【-4 4】的最大值%function main()clearclcpopsize=100chromlength=10pc=0.6pm=0.01%%pop=initpop(popsize,chromlength)for i=1:100[objvalue]=calobjvalue(pop)fitvalue=calfitvalue(objvalue)[newpop]=selection(pop,fitvalue)%选择操作[newpop]=crossover(pop,pc)%交叉操作[newpop]=mutation(pop,pm)%变异操作[bestindividaul,bestfit]=best(pop,fitvalue)%求出群体中适应值最大的个体及其适应值y(i)=max(bestfit)n(i)=ipop5=bestindividaulx(i)=decodechrom(pop5,1,chromlength)*8/1023-4pop=newpop;endx(i)y(i)fplot('x+3*sin(2*x)-7*cos(x)',[-4 4])grid onhold onplot(x,y,'r*')title('x+3*sin(2*x)-7*cos(x)的最大值')hold off2.子程序：初始化%初始化function pop=initpop(popsize,chromlength)pop=round(rand(popsize,chromlength)) %rand随机产生初始种群3. 子程序：计算目标函数%计算目标函数值function [objvalue]=calobjvalue(pop)temp1=decodechrom(pop,1,10)x=temp1*8/1023-4objvalue=x+3*sin(2*x)-7*cos(x)function pop2=decodechrom(pop,spoint,length)pop1=pop(:,spoint:spoint+length-1)pop2=decodebinary(pop1)function pop2=decodebinary(pop)[px,py]=size(pop)for i=1:pypop1(:,i)=2.^(py-1).*pop(:,i)py=py-1endpop2=sum(pop1,2)4. 子程序：选择操作%选择function [newpop]=selection(pop,fitvalue)totalfit=sum(fitvalue)fitvalue=fitvalue/totalfit%但个个体选择概率fitvalue=cumsum(fitvalue)[px,py]=size(pop)ms=sort(rand(px,1))fitin=1newin=1while newin<=pxif(ms(newin))<fitvalue(fitin)newpop(newin,:)=pop(fitin,:)newin=newin+1elsefitin=fitin+1endend5.子程序：交叉% 交叉function [newpop]=crossover(pop,pc)[px,py]=size(pop)newpop=ones(size(pop))for i=1:2:px-1if(rand<pc)cpoint=round(rand*py)newpop(i,:)=[pop(i,1:cpoint) pop(i+1,cpoint+1:py)]newpop(i+1,:)=[pop(i+1,1:cpoint) pop(i,cpoint+1:py)] elsenewpop(i,:)=pop(i,:)newpop(i+1,:)=pop(i+1,1)endend%6. 子程序：变异%变异function [newpop]=mutation(pop,pm)[px,py]=size(pop)newpop=ones(size(pop))for i=1:pxif(rand<pm)mpoint=round(rand*py)if mpoint<=0mpoint=1endnewpop(i,:)=pop(i,:)if any(newpop(i,mpoint))==0newpop(i,mpoint)=1elsenewpop(i,mpoint)=0endelsenewpop(i,:)=pop(i,:)endend7. 求出群体中适应值最大的个体及其适应值：%求出群体中最大适应值及其个体function [bestindividual,bestfit]=best(pop,fitvalue) [px,py]=size(pop)bestindividual=pop(1,:)bestfit=fitvalue(1)for i=2:pxif fitvalue(i)>bestfitbestindividual=pop(i,:)bestfit=fitvalue(i)endend三以上程序运行后的的结果如下图：（图）。
遗传算法求多元函数的极值
遗传算法求多元函数的极值
遗传算法是一种基于生物进化理论的优化算法，可以用来求解多元函数的极值。
下面介绍遗传算法求解多元函数极值的基本流程：
确定目标函数：首先需要确定待优化的目标函数，将其转化为一个优化问题。
确定变量范围和初始种群：对于每个变量，需要确定其可行域范围，并生成一个随机的初始种群。
适应度函数的定义：根据目标函数确定适应度函数，并将其作为评估个体优劣的标准。
选择操作：选择操作是遗传算法的核心，通过适应度函数选择个体，以保留优良个体。
遗传操作：包括交叉和变异两种操作。
交叉操作是指将两个个体的染色体部分进行交换，从而产生新个体；变异操作是指对某个个体的染色体部分进行随机变换，从而产生新个体。
繁殖新种群：通过选择和遗传操作，生成新的种群，并根据适应度函数进行排序。
判断停止条件：根据实际情况设定停止条件，如达到最大迭代次数、收敛到一定程度等。
输出结果：在满足停止条件后，输出当前最优解和最优适应度值。
需要注意的是，遗传算法求解多元函数极值需要根据实际情况调整参数和优化算法流程，以达到最优结果。
python实现遗传算法求函数最大值（人工智能作业）
python实现遗传算法求函数最⼤值（⼈⼯智能作业）题⽬：⽤遗传算法求函数f(a,b)=2a x sin(8PI x b) + b x cos(13PI x a)最⼤值，a:[-3,7]，b:[-4:10]实现步骤：初始化种群计算种群中每个个体的适应值淘汰部分个体（这⾥是求最⼤值，f值存在正值，所以淘汰所有负值）轮盘算法对种群进⾏选择进⾏交配、变异，交叉点、变异点随机分析：为了⽅便，先将⾃变量范围调整为[0,10]、[0,14]有两个变量，种群中每个个体⽤⼀个列表表⽰，两个列表项，每项是⼀个⼆进制字符串（分别由a、b转化⽽来）种群之间交配时需要确定交叉点，先将个体染⾊体中的两个⼆进制字符串拼接，再确定⼀个随机数作为交叉点为了程序的数据每⼀步都⽐较清晰正确，我在select、crossover、mutation之后分别都进⾏了⼀次适应值的重新计算具体代码：import mathimport randomdef sum(list):total = 0.0for line in list:total += linereturn totaldef rand(a, b):number = random.uniform(a,b)return math.floor(number*100)/100PI = math.pidef fitness(x1,x2):return 2*(x1-3)*math.sin(8*PI*x2)+(x2-4)*math.cos(13*PI*x1)def todecimal(str):parta = str[0:4]partb = str[4:]numerical = int(parta,2)partb = partb[::-1]for i in range(len(partb)):numerical += int(partb[i])*math.pow(0.5,(i+1))return numericaldef tobinarystring(numerical):numa = math.floor(numerical)numb = numerical - numabina = bin(numa)bina = bina[2:]result = "0"*(4-len(bina))result += binafor i in range(7):numb *= 2result += str(math.floor(numb))numb = numb - math.floor(numb)return resultclass Population:def __init__(self):self.pop_size = 500 # 设定种群个体数为500self.population = [[]] # 种群个体的⼆进制字符串集合，每个个体的字符串由⼀个列表组成[x1,x2]self.individual_fitness = [] # 种群个体的适应度集合self.chrom_length = 22 # ⼀个染⾊体22位self.results = [[]] # 记录每⼀代最优个体，是⼀个三元组(value,x1_str,x2_str)self.pc = 0.6 # 交配概率self.pm = 0.01 # 变异概率self.distribution = [] # ⽤于种群选择时的轮盘def initial(self):for i in range(self.pop_size):x1 = rand(0,10)x2 = rand(0,14)x1_str = tobinarystring(x1)x2_str = tobinarystring(x2)self.population.append([x1_str,x2_str]) # 添加⼀个个体fitness_value = fitness(x1,x2)self.individual_fitness.append(fitness_value) # 记录该个体的适应度self.population = self.population[1:]self.results = self.results[1:]def eliminate(self):for i in range(self.pop_size):if self.individual_fitness[i]<0:self.individual_fitness[i] = 0.0def getbest(self):"取得当前种群中的⼀个最有个体加⼊results集合"index = self.individual_fitness.index(max(self.individual_fitness))x1_str = self.population[index][0]x2_str = self.population[index][1]value = self.individual_fitness[index]self.results.append((value,x1_str,x2_str,))def select(self):"轮盘算法，⽤随机数做个体选择，选择之后会更新individual_fitness对应的数值""第⼀步先要初始化轮盘""选出新种群之后更新individual_fitness"total = sum(self.individual_fitness)begin = 0for i in range(self.pop_size):temp = self.individual_fitness[i]/total+beginself.distribution.append(temp)begin = tempnew_population = []new_individual_fitness = []for i in range(self.pop_size):num = random.random() # ⽣成⼀个0~1之间的浮点数j = 0for j in range(self.pop_size):if self.distribution[j]<num:continueelse:breakindex = j if j!=0 else (self.pop_size-1)new_population.append(self.population[index])new_individual_fitness.append(self.individual_fitness[index])self.population = new_populationself.individual_fitness = new_individual_fitnessdef crossover(self):"选择好新种群之后要进⾏交配""注意这只是⼀次种群交配，种群每⼀次交配过程，会让每两个相邻的染⾊体进⾏信息交配"for i in range(self.pop_size-1):if random.random()<self.pc:cross_position = random.randint(1,self.chrom_length-1)i_x1x2_str = self.population[i][0]+self.population[i][1] # 拼接起第i个染⾊体的两个⼆进制字符串i1_x1x2_str = self.population[i+1][0]+self.population[i+1][1] # 拼接起第i+1个染⾊体的两个⼆进制字符串 str1_part1 = i_x1x2_str[:cross_position]str1_part2 = i_x1x2_str[cross_position:]str2_part1 = i1_x1x2_str[:cross_position]str2_part2 = i1_x1x2_str[cross_position:]str1 = str1_part1+str2_part2str2 = str2_part1+str1_part2self.population[i] = [str1[:11],str1[11:]]self.population[i+1] = [str2[:11],str2[11:]]"然后更新individual_fitness"for i in range(self.pop_size):x1_str = self.population[i][0]x2_str = self.population[i][1]x1 = todecimal(x1_str)x2 = todecimal(x2_str)self.individual_fitness[i] = fitness(x1,x2)def mutation(self):"个体基因变异"for i in range(self.pop_size):if random.random()<self.pm:x1x2_str = self.population[i][0]+self.population[i][1]pos = random.randint(0,self.chrom_length-1)bit = "1" if x1x2_str[pos]=="0" else "0"x1x2_str = x1x2_str[:pos]+bit+x1x2_str[pos+1:]self.population[i][0] = x1x2_str[:11]self.population[i][1] = x1x2_str[11:]"然后更新individual_fitness"for i in range(self.pop_size):x1_str = self.population[i][0]x2_str = self.population[i][1]x1 = todecimal(x1_str)x2 = todecimal(x2_str)self.individual_fitness[i] = fitness(x1, x2)def solving(self,times):"进⾏times次数的整个种群交配变异""先获得初代的最优个体"self.getbest()for i in range(times):"每⼀代的染⾊体个体和适应值，需要先淘汰，然后选择，再交配、变异，最后获取最优个体。
遗传算法求函数极值
遗传算法求函数极值遗传算法是一种基于模拟生物进化过程的优化算法，它通过模拟生物的进化过程中的遗传、交叉和变异等操作，对问题的解空间进行，并到满足最优条件的解。
它被广泛应用于求解各种复杂问题，包括函数极值问题。
在使用遗传算法求函数极值的过程中，首先需要明确问题的目标函数。
目标函数是一个将自变量映射到一个实数值的函数，它描述了问题的优化目标。
例如，我们可以考虑一个简单的目标函数f(x)，其中x表示自变量，f(x)表示因变量。
遗传算法的基本流程如下：1.初始化种群：随机生成一组初始解，也就是种群。
种群中的每个个体都是一个可能的问题解，而个体中的染色体则表示了问题解的具体数值。
2.适应度评估：对于种群中的每个个体，通过计算目标函数的值，评估每个个体的适应度。
适应度越高的个体，越有可能成为下一代个体的基因。
3.选择操作：根据个体的适应度，选择一些个体作为下一代遗传操作的基因。
4.交叉操作：从选择出的个体中随机选择一对个体，进行交叉操作。
交叉操作通过交换两个个体的染色体信息，产生新的个体。
5.变异操作：对交叉操作生成的新个体进行变异操作。
变异操作通过改变个体染色体中的部分基因，引入新的解，以增加问题解的多样性。
6.新种群产生：基于交叉和变异操作，生成新的种群。
7.终止条件判断：如果满足终止条件（例如达到最大迭代次数、找到了满足要求的解等），则停止算法；否则，返回第2步。
通过以上步骤的循环迭代，遗传算法可以到问题的最优解，即函数的极值。
由于遗传算法充分利用了进化算法的生物特点，具有全局能力和自适应优化能力，因此在函数极值求解中得到了广泛的应用。
遗传算法的关键在于如何进行适应度评估、选择操作、交叉操作和变异操作。
适应度评估是指根据目标函数计算个体的适应度值，一般情况下适应度越高的个体越有可能成为下一代的基因。
选择操作可以采用轮盘赌选择、最优选择等方式，根据个体的适应度选择一定数量的个体进行交叉和变异。
交叉操作通过交换染色体信息，产生新的个体；变异操作通过改变个体染色体中的部分基因，引入新的解。
遗传算法求解函数极值C语言代码
#include "stdio.h"#include "stdlib.h"#include "conio.h"#include "math.h"#include "time.h"#define num_C 12 //个体的个数，前6位表示x1，后6位表示x2 #define N 100 //群体规模为100#define pc 0.9 //交叉概率为0.9#define pm 0.1 //变异概率为10%#define ps 0.6 //进行选择时保留的比例#define genmax 2000 //最大代数200int RandomInteger(int low,int high);void Initial_gen(struct unit group[N]);void Sort(struct unit group[N]);void Copy_unit(struct unit *p1,struct unit *p2);void Cross(struct unit *p3,struct unit *p4);void Varation(struct unit group[N],int i);void Evolution(struct unit group[N]);float Calculate_cost(struct unit *p);void Print_optimum(struct unit group[N],int k);/* 定义个体信息*/typedef struct unit{int path[num_C]; //每个个体的信息double cost; //个体代价值};struct unit group[N]; //种群变量groupint num_gen=0; //记录当前达到第几代int main(){int i,j;srand((int)time(NULL)); //初始化随机数发生器Initial_gen(group); //初始化种群Evolution(group); //进化：选择、交叉、变异getch();return 0;}/* 初始化种群*/void Initial_gen(struct unit group[N]){int i,j;struct unit *p;for(i=0;i<=N-1;i++) //初始化种群里的100个个体{p=&group[i]; //p指向种群的第i个个体for(j=0;j<12;j++){p->path[j]=RandomInteger(0,9); //end }Calculate_cost(p); //计算该种群的函数值}//end 初始化种群}/* 种群进化，进化代数由genmax决定*/void Evolution(struct unit group[N]){int i,j;int temp1,temp2,temp3,temp4,temp5;temp1=N*pc/2;temp2=N*(1-pc);temp3=N*(1-pc/2);temp4=N*(1-ps);temp5=N*ps;for(i=1;i<=genmax;i++){//选择for(j=0;j<=temp4-1;j++){ Copy_unit(&group[j],&group[j+temp5]); }//交叉for(j=0;j<=temp1-1;){Cross(&group[temp2+j],&group[temp3+j]);j+=2;}//变异Varation(group,i);}Sort(group);Print_optimum(group,i-1); //输出当代(第i-1代)种群}/* 交叉*/void Cross(struct unit *p3,struct unit *p4){int i,j,cross_point;int son1[num_C],son2[num_C];for(i=0;i<=num_C-1;i++) //初始化son1、son2{son1[i]=-1;son2[i]=-1;}cross_point=RandomInteger(1,num_C-1); //交叉位随机生成//交叉，生成子代//子代1//子代1前半部分直接从父代复制for(i=0;i<=cross_point-1;i++) son1[i]=p3->path[i];for(i=cross_point;i<=num_C-1;i++)for(j=0;j<=num_C-1;j++) //补全p1{son1[i]=p4->path[j];}//end 子代1//子代2//子代1后半部分直接从父代复制for(i=cross_point;i<=num_C-1;i++) son2[i]=p4->path[i];for(i=0;i<=cross_point-1;i++){for(j=0;j<=num_C-1;j++) //补全p1{son2[i]=p3->path[j];}}//end 子代2//end 交叉for(i=0;i<=num_C-1;i++){p3->path[i]=son1[i];p4->path[i]=son2[i];}Calculate_cost(p3); //计算子代p1的函数值Calculate_cost(p4); //计算子代p2的函数值}/* 变异*/void Varation(struct unit group[N],int flag_v){int flag,i,j,k,temp;struct unit *p;flag=RandomInteger(1,100);//在进化后期，增大变异概率if((!flag>(flag_v>100))?(5*100*pm):(100*pm)){i=RandomInteger(0,N-1); //确定发生变异的个体j=RandomInteger(0,num_C-1); //确定发生变异的位k=RandomInteger(0,num_C-1);p=&group[i]; //变异temp=p->path[j];p->path[j]=p->path[k];p->path[k]=temp;Calculate_cost(p); //重新计算变异后的函数值}}/* 将种群中个体按函数值从小到大排序*/void Sort(struct unit group[N]){int i,j;struct unit temp,*p1,*p2;for(j=1;j<=N-1;j++) //排序总共需进行N-1轮{for(i=1;i<=N-1;i++){p1=&group[i-1];p2=&group[i];if(p1->cost>p2->cost) //值大的往后排{Copy_unit(p1,&temp);Copy_unit(p2,p1);Copy_unit(&temp,p2);}}//end 一轮排序}//end 排序}/* 计算某个个体的函数值*/float Calculate_cost(struct unit *p){double x1,x2;x1=0;if(p->path[0]>5){x1=p->path[1]+p->path[2]*0.1+p->path[3]*0.01+p->path[4]*0.001+p->path[5]*0.0001;}else if(p->path[0]<6){x1=0-(p->path[1]+p->path[2]*0.1+p->path[3]*0.01+p->path[4]*0.001+p->path[5]*0.0001);}x2=0;if(p->path[6]>5){}else if(p->path[6]<6){x2=0-(p->path[7]+p->path[8]*0.1+p->path[9]*0.01+p->path[10]*0.001+p->path[11]*0.0001);}p->cost=20+x1*x1+x2*x2-10*(cos(2*3.14*x1)+cos(2*3.14*x2));return(p->cost);}/* 复制种群中的p1到p2中*/void Copy_unit(struct unit *p1,struct unit *p2){int i;for(i=0;i<=num_C-1;i++)p2->path[i]=p1->path[i];p2->cost=p1->cost;}/* 生成一个介于两整型数之间的随机整数*/int RandomInteger(int low,int high){int k;double d;k=rand();k=(k!=RAND_MAX)?k:(k-1); //RAND_MAX是VC中可表示的最大整型数d=(double)k/((double)(RAND_MAX));k=(int)(d*(high-low+1));return (low+k);}/* 输出当代种群中的最优个体*/void Print_optimum(struct unit group[N],int k){struct unit *p;double x1,x2;x1=x2=0;p=&group[0];if(p->path[0]>5){x1=p->path[1]+p->path[2]*0.1+p->path[3]*0.01+p->path[4]*0.001+p->path[5]*0.0001;}else if(p->path[0]<6){}x2=0;if(p->path[6]>5){x2=p->path[7]+p->path[8]*0.1+p->path[9]*0.01+p->path[10]*0.001+p->path[11]*0.0001;}else if(p->path[6]<6){x2=0-(p->path[7]+p->path[8]*0.1+p->path[9]*0.01+p->path[10]*0.001+p->path[11]*0.0001);}printf(" 当x1=%f x2=%f\n",x1,x2);printf(" 函数最小值为：%f \n",p->cost);}。
遗传算法求函数最大值
遗传算法求函数最大值
遗传算法是一种基于自然进化的搜索算法，它可以用来求解复杂的优化问题。
它的基本思想是模拟自然界中的进化过程，通过繁殖、变异和选择来改善解决方案。
遗传算法可以用
来求解函数最大值问题，它的基本步骤如下：
1. 初始化种群：首先，需要初始化一个种群，种群中的每个个体都是一个可能的解决方案，每个个体都有一个与之对应的适应度值。
2. 计算适应度：然后，需要计算每个个体的适应度值，适应度值越高，表明该个体越有可
能是最优解。
3. 选择：接下来，需要根据适应度值对种群中的个体进行选择，选择出适应度值较高的个体，以便在下一代中繁殖。
4. 交叉：然后，需要对选择出的个体进行交叉，以产生新的个体，新的个体具有父代个体
的特征。
5. 变异：最后，需要对新的个体进行变异，以产生新的特征，以提高搜索的效率。
通过上述步骤，可以不断迭代，直到找到最优解为止。
遗传算法可以用来求解函数最大值问题，它可以有效地搜索出最优解，而且可以在复杂的环境中取得良好的效果。
遗传算法求函数极值
智能优化算法第一次作业--------------遗传算法洪文杰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/;}。
遗传算法求函数最值
{
char chrom[30];//定义染色体长度数组，留有余地，真实长度由构造函数完成
double value; //函数值
double fitness; //适应度
};
class Genetic
{
public:
int popsize;//种群规模
int maxgeneration;//最大世代数
Genetic(int popsizeout,int maxgenerationout,double pcout,double pmout,double Xfirst,double Xend,int chromlengthout,int functionmode=1);//带参数的构造函数
~Genetic();//析构函数
void PerformEvolution(); //演示评价结果
void SelectOperator(); //比例选择算法
void CrossoverOperator(); //交叉算法
void MutationOperator();//变异算法
void OutputReport(); //数据输出
}
else
{
temp=0.0;
}
}
else if (functionmode==0)
{
if(population[i].value<cmax)
{
temp=cmax-population[i].value;
}
else{ temp=0.0;}
}
population[i].fitness=temp;
}
}
///////////////////////////////////////////////////////////////////////////////
遗传算法求解函数最大值
遗传算法求解函数最大值研究者们广泛使用各种数学方法来求解函数的最大值，其中遗传算法是一种有效的解决方案。
遗传算法是一种仿生算法，使用相似的进化过程来搜索函数的最大值，这种算法在解决复杂问题时尤其有效。
遗传算法的工作原理是利用遗传操作来进行搜索。
它的步骤大致如下：首先，从初始种群中随机选择一定数量的个体，并进行多次重复，对其属性进行多次迭代，形成较优个体。
然后，根据结果，重建种群，以提高适应度。
在这个过程中，种群中的属性将不断改变，个体之间会遗传和变异，从而改变函数的最大值。
当属性变化趋于稳定时，这种改变的步骤就会停止，最大值就得到了。
为了更好地理解遗传算法，我们先来看一个例子。
一维函数f(x)=x^2-2x+5可以用遗传算法来求最大值。
我们以染色体序列长度为10作为种群大小，创建初始种群，并在每一代经历重复，变异，选择和交叉过程之后，依次获得较优个体。
在这个过程中，染色体序列不断变异，最后形成二进制数f(x)的最大值，最终求得f(x)的最大值为9。
遗传算法具有很多优点，其中最重要的是，它可以解决最优化问题，而且能够在有限的时间里达到不错的效果。
此外，遗传算法不会受到维度或者变量数量的限制，而且它可以根据需要改变变量的组合，从而获得更好的运算结果。
最后，遗传算法也可以应用在实际工程中，这就是遗传算法求解函数最大值的重要应用之一。
总的来说，遗传算法是一种通用的解决方案，能有效地搜索函数的最大值。
虽然它具有很多优点，但也有一些限制。
例如，算法的效率跟种群的大小有关，种群大小越大，搜索效率就越低，而且有时它也会陷入局部最优解中，从而无法搜索到全局最优解。
遗传算法可以给出不错的搜索结果，可以有效地求解函数最大值，是一种普遍应用的有效搜索方法。
因此，在未来，它将继续受到研究者们的广泛关注，并为世人带来更多的益处。
遗传算法求取函数最大值
%Generic Algorithm for function f(x1,x2) optimum clear all; close all; %Parameters Size=80; G=100; CodeL=10; umax=2.048; umin=-2.048; E=round(rand(Size,2*CodeL)); fi_Size_sum=zeros(Size); %Main Program for k=1:1:G time(k)=k; for s=1:1:Size m=E(s,:); y1=0;y2=0; %Uncoding %将第一个参数的值解码并幅值为x1 %将第二个参数的值解码并幅值为x2 %计算函数值 End %Initial Code
%****** Step 2 : Select and Reproduct Operation****** %选择操作 提示：轮盘赌方式，先计算累计概率，产生随机数，判断随机数处于哪个范围，选取相应的个体
%************ Step 3***** pc=0.60; %交叉操作 提示：产生两个随机数a和b，其中a为小于20的整数，b用于比较，当pc大于b时，以a作为断点 进行交叉，交叉的方式为相邻两个个体进行交叉。
%************ Step 4: Mutation Operation ************** %pm=0.001; %pm=0.001-[1:1:Size]*(0.001)/Size; %Bigger fi, smaller Pm %pm=0.0; pm=0.1; %变异操作 提示：产生两个随机数，当pm大于随机数时，将该个体的0,1互换，即该个体所有基因都发生变 异。 以上三个操作均应在循环中进行，需要覆盖所有个体 %Guarantee TempPop(30,:) is the code belong to the best individual(max(fi)) TempE(Size,:)=BestS; E=TempE; end Max_Value=Bestfi BestS x1 x2 figure(1); plot(time,BestJ); xlabel('Times');ylabel('Best J'); figure(2); plot(time,bfi); xlabel('times');ylabel('Best F'); %No mutation %Big mutation
遗传算法求函数极大值
执行程序（函数不用输入）clcgenetic迭代收敛速度clcR = geneticplot(R.accuracy)查看函数图象，估计最好的点种子位置，函数的最大值seed = rand(5000,2)*10-5;plot3(seed(:,1),seed(:,2),DeJong1(seed),'.')max(DeJong1(seed))[~,ind]=max(DeJong1(seed))seed(ind,:)Genetic 求最小值function R = genetic()seed = rand(50,2)*10-5;Newseed = seed; stopK = 1;k=1;while(true)Dejed = DeJong1(seed); % 这一轮的种子的值。
[~, goodseed] = sort(Dejed);%降序排列,'descend'R.accuracy(k) = Dejed(goodseed(1));seed = seed(goodseed,:);seed(1,:),Dejed(goodseed(1))if k>1if R.accuracy(k-1) <= (R.Oldaccuracy(k)+0.000001); stopK=stopK+1; else stopK = 1; endendif stopK==5;break;endNewseed(1:10,:) = seed(1:10,:); %好种子保留Newseed(11:30,:) = [[seed(1:2:19,1),seed(2:2:20,2)];[seed(2:2:20,1),seed(1:2:19,2)]]; % 交叉Newseed(31:40,:) = seed(1:10,:) + rand(10,2)*0.1; %在好种上变异Newseed(41:50,:) = rand(10,2)*10-5; %补充新的种子seed = Newseed;endGenetic 求最大值function R = genetic()seed = rand(50,2)*10-5;Newseed = seed; stopK = 1;k=1;while(true)Dejed = DeJong1(seed); % 这一轮的种子的值。
遗传算法求方程最大值
/*
遗传算法应用举例————函数最大值问题的求解：f(x)=x*x(0<=x<=31)
课程名称：人工智能
专业：计算机软件理论
*/
class Chromosome //染色体类的定义
{
int geneString[]=new int[5];//基因位串
int fitness=0;//适应度
double chooseProbability=0.0;//选择概率
{
C1.fitness=fValue(C1.geneString)*fValue(C1.geneString);
C2.fitness=fValue(C2.geneString)*fValue(C2.geneString);
C3.fitness=fValue(C3.geneString)*fValue(C3.geneString);
Copy(C4,C2);
}
if(C3.chooseNumber==0)
{
System.out.println("C3要被淘汰");
if(C2.chooseNumber>1)
Copy(C2,C3);
if(C1.chooseNumber>1)
Copy(C1,C3);
if(C4.chooseNumber>1)
System.out.println(change(C1.geneString)+" "+fValue(C1.geneString)+" "+C1.fitness+" "+C1.chooseProbability+"
使用遗传算法求解函数最大值
使用遗传算法求解函数最大值遗传算法是一种基于自然选择和遗传机制的优化算法，常用于求解函数最大（或最小）值的问题。
它模拟了自然界中的进化过程，通过不断迭代的方式问题的解空间，最终找到最优解。
遗传算法的基本思想是通过模拟进化过程中的选择、交叉和变异等操作，逐步优化种群中的个体，并逐代演化出更好的解。
下面将详细介绍遗传算法的基本流程及其在求解函数最大值问题中的应用。
1.初始化种群：随机生成一组初始解作为种群的个体，代表问题的可能解。
个体可以表示为一组数据，如一个浮点数、二进制串或其他形式。
2.评估适应度：对每个个体进行适应度评估，即计算个体对应的目标函数值。
在函数最大值问题中，适应度值通常与目标函数值成正比，可以简单地将适应度设为目标函数值。
3.选择操作：根据个体的适应度值，利用选择算子选择一定数量的个体作为父代。
通常使用轮盘赌算法或排名选择算法来进行选择。
4.交叉操作：从父代中选取两个个体，利用交叉算子进行基因的交换，产生新的个体。
交叉操作旨在通过基因的组合，产生具有更好性能的个体。
5.变异操作：以一定的概率对新生成的个体进行变异，即改变个体中的一些基因，引入新的基因。
变异操作能够增加空间的多样性，防止算法陷入局部最优解。
6.评估适应度：对新生成的个体进行适应度评估。
7.更新种群：根据一定的策略，将新生成的个体替换原来的个体，生成新的种群。
8.终止条件判断：判断是否达到终止条件，如迭代次数达到预设值或找到满足一定条件的解。
9.返回结果：返回最优解，即具有最大适应度的个体。
通过以上步骤，遗传算法能够问题的解空间，并不断演化出适应度更高的个体，最终找到函数最大值的解。
在具体应用遗传算法求解函数最大值问题时，需要根据问题的特点灵活调整算法的参数和操作。
例如，选择算子的选择方式、交叉算子的选择方式、变异概率的设置等，都会对算法的性能产生影响。
此外，还需注意适应度函数的设计。
适应度函数应能准确地度量个体的好坏程度，并且在适应度计算过程中要避免一些问题，如数值溢出、计算复杂度过高等。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
遗传算法十进制编码求函数极大值程序%Generic Algorithm for function f(x1,x2) optimum
clear all;
close all;
Size=500;
CodeL=2;
MinX(1)=-2.048;
MaxX(1)=2.048;
MinX(2)=-2.048;
MaxX(2)=2.048;
E(:,1)=MinX(1)+(MaxX(1)-MinX(1))*rand(Size,1);
E(:,2)=MinX(2)+(MaxX(2)-MinX(2))*rand(Size,1);
G=200;
BsJ=0;
%*************** Start Running ***************
for kg=1:1:G
time(kg)=kg;
%****** Step 1 : Evaluate BestJ ******
for i=1:1:Size
xi=E(i,:);
x1=xi(1);
x2=xi(2);
F(i)=100*(x1^2-x2)^2+(1-x1)^2;
Ji=1./F;
BsJi(i)=min(Ji);
end
[OderJi,IndexJi]=sort(BsJi);
BestJ(kg)=OderJi(1);
BJ=BestJ(kg);
Ji=BsJi+1e-10; %Avoiding deviding zero
fi=F;
[Oderfi,Indexfi]=sort(fi); %Arranging fi small to bigger
Bestfi=Oderfi(Size); %Let Bestfi=max(fi)
BestS=E(Indexfi(Size),:); %Let BestS=E(m), m is the Indexfi belong to max(fi)
bfi(kg)=Bestfi;
kg
BestS
%****** Step 2 : Select and Reproduct Operation******
fi_sum=sum(fi);
fi_Size=(Oderfi/fi_sum)*Size;
fi_S=floor(fi_Size); % Selecting Bigger fi value
r=Size-sum(fi_S);
Rest=fi_Size-fi_S;
[RestValue,Index]=sort(Rest);
for i=Size:-1:Size-r+1
fi_S(Index(i))=fi_S(Index(i))+1; % Adding rest to equal Size end
k=1;
for i=Size:-1:1 % Select the Sizeth and Reproduce firstly
for j=1:1:fi_S(i)
TempE(k,:)=E(Indexfi(i),:); % Select and Reproduce
k=k+1; % k is used to reproduce end
end
%************ Step 3 : Crossover Operation ************
Pc=0.90;
for i=1:2:(Size-1)
temp=rand;
if Pc>temp %Crossover Condition
alfa=rand;
TempE(i,:)=alfa*E(i+1,:)+(1-alfa)*E(i,:);
TempE(i+1,:)=alfa*E(i,:)+(1-alfa)*E(i+1,:);
end
end
TempE(Size,:)=BestS;
E=TempE;
%************ Step 4: Mutation Operation **************
Pm=0.10-[1:1:Size]*(0.01)/Size; %Bigger fi,smaller Pm
Pm_rand=rand(Size,CodeL);
Mean=(MaxX + MinX)/2;
Dif=(MaxX-MinX);
for i=1:1:Size
for j=1:1:CodeL
if Pm(i)>Pm_rand(i,j) %Mutation Condition TempE(i,j)=Mean(j)+Dif(j)*(rand-0.5);
end
end
end
%Guarantee TempE(Size,:) belong to the best individual TempE(Size,:)=BestS;
E=TempE;
end
BestS
Bestfi
figure(1);
plot(time,BestJ,'k');
xlabel('Times');ylabel('Best J');
figure(2);
plot(time,bfi,'k');
xlabel('times');ylabel('Best F');。