遗传算法求解函数最大值
用遗传算法求解Rosenbrock函数最优解实验报告
华中师范大学计算机科学系实验报告书实验题目：用遗传算法求解Rosenbrock函数的最大值问题课程名称：智能计算主讲教师：***辅导教师：课程编号：班级：2011级实验时间：2011.11用遗传算法求解Rosenbrock函数最大值问题摘要：本文利用遗传算法研究了求解Rosenbrock函数的最大值问题．在较多的计算机模拟实验结果中表明，用遗传算法可以有效地解决这一问题．文中分析了一种基于遗传算法对Rosenbrock函数最大值问题的求解，得到了适于解决此问题的合理的遗传操作，从而为有效地解决最速下降法所不能实现的某一类函数代化问题提供了一种新的途径．通过对基于遗传算法对Rosenbrock函数最大值问题的求解，进一步理解遗传算法对解决此类问题的思想。
关键词：遗传算法，Rosenbrock函数，函数优化，最速下降法。
Abstract：This paper deals with the maximum of Rosenbrock s function based ongenetic algorithms. The simulated results show that the problem can be solved effectivelyusing genetic algorithms. The influence of some rnodified genetic algorithms on searchspeed is also examined. Some genetic operations suitable to the optimization technique areobtained, therefore, a novel way of solving a class of optimizations of functions that cannot be realized using the method of steepest descent is proposed.Through dealing with the maximum of Rosenbrock s function based ongenetic algorithms，a better understanding of the genetic algorithm to solve such problems thinking.Keyword：ongenetic algorithms，Rosenbrock function，function optimization，Steepest descent method绪论：无约束的函数优化是应用范围广泛的一类函数优化问题，随着对这类问题逐渐深入的研究，到目前为止，人们已经提出了许多无约束最优化的方法，例如：导数的梯度法，牛顿法，共轭梯度法等多种方法。
遗传算法求函数最大值实验报告
遗传算法求函数最大值实验报告遗传算法是一种模拟自然界进化过程的优化算法，它通过模拟生物进化过程中的遗传、交叉和变异等机制，逐步优化解空间中的个体，以找到问题的最优解。
在本次实验中，我们利用遗传算法来求解一个函数的最大值。
下面我们将详细介绍实验的过程和结果。
首先，我们选择了一个简单的函数作为实验对象，即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\)
遗传算法求解函数最大值
S9 李麒星用遗传算法通过复制交叉过程循环求解函数f(x)=x^2在[0,31]区间上的最大值点x。
代码如下：using System;using ;using ;namespace Project2{class Class1{public int ff(int a){return a * a;}public int Max(int[] args){int s = 0;int m = args[0];for (int i = 0; i < ; i++){if (m < args[i]){m = args[i];s = i;}}return s;}public int Min(int[] args){int s = 0;int m = args[0];for (int i = 0; i < ; i++){if (m > args[i]){m = args[i];s = i;}}return s;}static void Main(String[] args)S9 李麒星{string[] A = new string[4];A[0] = "01101";A[1] = "11000";A[2] = "01000";A[3] = "10011";Class1 cl = new Class1();Random a = new Random();int[] x = new int[4];ubstring(k1);ubstring(k2);string s3 = A[3 - max].Substring(k1);string s4 = A[3 - min].Substring(k2);A[max] = A[max].Substring(0, k1) + s3;A[min] = A[min].Substring(0, k2) + s4;A[3 - max] = A[3 - max].Substring(0,k1) + s1; A[3 - min] = A[3 - min].Substring(0,k2) + s2; }elseif ((max > min) && (min + 1 ==max))ubstring(k1);ubstring(k2);string s3 = A[3].Substring(k1);string s4 = A[0].Substring(k2);A[max] = A[max].Substring(0,k1) + s3;A[min] = A[min].Substring(0,k2) + s4;A[3] = A[3].Substring(0,k1) + s1;A[3] = A[3].Substring(0,k2) + s2;S9 李麒星}elseif ((max < min) && (min == max +1))ubstring(k1);ubstring(k2);string s3 = A[0].Substring(k1);string s4 = A[3].Substring(k2);A[max] = A[max].Substring(0,k1) + s3; A[min] = A[min].Substring(0,k2) + s4; A[0] = A[0].Substring(0,k1) + s1;A[3] = A[3].Substring(0,k2) + s2;}elseif ((max > min) && (max ==min +3))ubstring(k1);ubstring(k2);string s3 = A[2].Substring(k1);string s4 = A[1].Substring(k2);A[max] = A[max].Substring(0,k1) + s3; A[min] = A[min].Substring(0,k2) + s4; A[2] = A[2].Substring(0,k1) + s1;A[1] = A[1].Substring(0,k2) + s2;}elseif ((max < min) && ( min==max +3 ))ubstring(k1);ubstring(k2);string s3 = A[1].Substring(k1);string s4 = A[2].Substring(k2);A[max] = A[max].Substring(0,k1) + s3;A[min] = A[min].Substring(0,k2) + s4;A[1] = A[1].Substring(0,k1) + s1; S9 李麒星A[1] = A[1].Substring(0,k2) + s2; }}("最大值是={0}", t1); }}}输出如下：S9 李麒星结论：由图可知每次循环结果不唯一。
遗传算法计算函数最大值
遗传算法计算函数最大值遗传算法是一种模拟进化过程的优化算法，被广泛应用于求解函数最大值问题。
在遗传算法中，问题的解被表示为染色体的形式，每个染色体都是由一串基因组成。
每个基因可以看作是染色体中的一个变量值，它们合起来构成了一个可行解。
随着进化的进行，每个可行解都会被评估，评估函数即为目标函数，目标函数可以是我们需要求解的函数。
根据目标函数的评价结果，我们可以对染色体进行选择、交叉和变异，以产生新的一代染色体，进而继续进行优化。
遗传算法的核心是选择、交叉和变异这三个基本操作。
选择操作是指从当前种群中选择部分优秀的染色体作为父代，根据染色体的适应度值进行随机抽样。
交叉操作是指将两个父代染色体的一部分基因进行互换，产生新的子代染色体。
变异操作是指对子代染色体的某个基因进行随机改变，产生新的基因。
遗传算法具有很好的鲁棒性和适应性，能够应对大规模的优化问题。
它的优势在于不要求问题具有良好的可微性，也不需要先验知识，能够处理不确定的搜索空间和复杂的非线性函数。
在求解函数最大值问题时，我们需要首先定义一个适当的目标函数。
目标函数可以是实际应用中的函数，也可以是一些基本函数或常用函数。
常见的函数包括线性函数、二次函数、指数函数、对数函数、三角函数等。
以求解f(x)=-x^2+2x+6函数最大值为例，假设x的范围在[0,5]之间，则可定义目标函数如下：f(x)=-x^2+2x+6在遗传算法的优化过程中，我们需要确定初始种群、目标函数、选择、交叉和变异等相关参数。
初始种群可以采用随机生成的方式，或者根据某些规律生成；目标函数应该能够给出染色体的适应度值；选择操作可以根据适应度函数对染色体进行排序，或者采用轮盘赌的方式选择优秀染色体；交叉操作可以随机选取父代染色体的一部分基因进行交叉；变异操作可以按照一定概率随机对子代染色体的基因进行改变。
最终，经过多轮迭代，我们可以得到一组较优的染色体，以及它们所对应的函数最大值。
遗传算法求函数最大值
遗传算法求函数最大值
遗传算法是一种基于自然进化的搜索算法，它可以用来求解复杂的优化问题。
它的基本思想是模拟自然界中的进化过程，通过繁殖、变异和选择来改善解决方案。
遗传算法可以用
来求解函数最大值问题，它的基本步骤如下：
1. 初始化种群：首先，需要初始化一个种群，种群中的每个个体都是一个可能的解决方案，每个个体都有一个与之对应的适应度值。
2. 计算适应度：然后，需要计算每个个体的适应度值，适应度值越高，表明该个体越有可
能是最优解。
3. 选择：接下来，需要根据适应度值对种群中的个体进行选择，选择出适应度值较高的个体，以便在下一代中繁殖。
4. 交叉：然后，需要对选择出的个体进行交叉，以产生新的个体，新的个体具有父代个体
的特征。
5. 变异：最后，需要对新的个体进行变异，以产生新的特征，以提高搜索的效率。
通过上述步骤，可以不断迭代，直到找到最优解为止。
遗传算法可以用来求解函数最大值问题，它可以有效地搜索出最优解，而且可以在复杂的环境中取得良好的效果。
基于遗传算法求函数最大值
土豆学习小组基于遗传算法求函数最大值先给出实例：设函数为：]7,1[,10)3sin()5cos()(∈+−=x x x x f ，取种群大小20，搜索精度0.0001，交叉概率0.6，变异概率0.1，遗传20代。
下面根据这个例子来叙述如何通过遗传算法来计算最大值。
遗传算法的概念和相关知识可以去网上查看，这里主要介绍和程序相关的知识。
遗传算法的流程图如下：遗传算法流程图种群的产生一般由随机数产生固定长度的01序列，可以理解成染色体，例如：1111010011100001011000，这表示一个单独个体的染色体，那么结合这个例子就是产生20个这样的染色体。
种群适应度估计，因为是求最大值，所以适应度可以通过求函数值来确定，函数值越大，越适合生存。
选择，这是一个自然选择的过程，这里用轮盘赌选择法，土豆学习小组轮盘赌选择法交叉用单点交叉：单点交叉变异的形式如下：变异当然变异的概率相对较低。
注意：选择和交叉方法还很多，也比这来的有效，只是这种方法较为简单，易于程序实现。
MATLAB命令窗口：>>[xv,fv]=GA(@fitness,1,7,20,20,0.6,0.1,0.0001)xv=3.6723土豆学习小组fv=11.8830函数图形结果基本符合。
函数文件1：fitness.m用于存放需要求的函数function F=fitness(x)F=cos(5*x)-sin(3*x)+10;函数文件2：GA.m遗传算法文件function[xv,fv]=GA(fitness,a,b,NP,NG,pc,pm,eps) %上限a%下限b%种群大小：NP%遗传代数：NG%交叉概率：pc%变异概率：pm%离散精度：eps%第一步产生初始种群x，产生之前需要根据离散精度确定串长L L=ceil(log2((b-a)/eps));x=Initial(L,NP);for i=1:NPxdec(i)=dec(a,b,x(i,:),L);end%第二步选择交叉变异要循环好几代for i=1:NG%选择轮盘赌选择法fx=fitness(xdec);%适应度fxp=fx/sum(fx);%选择概率fxa(1)=fxp(1);%累计概率土豆学习小组for j=2:NPfxa(j)=fxa(j-1)+fxp(j);end%开始选择父体sat=rand();for k=1:NPif sat<=fxa(k)father=k;break;endend%随机选取母体mother=ceil(rand()*NP);nx=x;%单点交叉cutp=ceil(rand()*L);r1=rand();if r1<=pcnx(i,1:cutp)=x(father,1:cutp);nx(i,cutp+1:L)=x(mother,cutp+1:L);r2=rand();%是否变异if r2<pmcum=ceil(rand()*L);nx(i,cum)=~nx(i,cum);endendx=nx;for i=1:NPxdec(i)=dec(a,b,x(i,:),L);end%选择较好的子代fv=-inf;for i=1:NPfitx=fitness(dec(a,b,x(i,:),L));if fitx>fvfv=fitx;xv=dec(a,b,x(i,:),L);endendend土豆学习小组%种群初始化函数function t=Initial(L,NP)t=zeros(NP,L);for i=1:NPfor j=1:Ltemp=rand();t(i,j)=round(temp);endend%解码函数转换成十进制function d=dec(a,b,num,L)i=L-1:-1:0;dd=sum((2.^i).*num);d=a+dd*(b-a)/(2^L-1);其中：dec函数将某个个体转换到【1,7】之间的数000000000000=1；111111111111=7；。
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):"每⼀代的染⾊体个体和适应值，需要先淘汰，然后选择，再交配、变异，最后获取最优个体。
遗传算法求解实例
yjl.m :简单一元函数优化实例，利用遗传算法计算下面函数的最大值f (x) =xsin( 10 二* x) 2.0，x • [-1,2]选择二进制编码，种群中个体数目为40,每个种群的长度为20，使用代沟为0.9,最大遗传代数为25len lbub scale lbin译码矩阵结构: FieldD code译码矩阵说明:len -包含在Chrom中的每个子串的长度，注意sum(len)=length(Chrom);lb、ub -行向量，分别指明每个变量使用的上界和下界；code -二进制行向量，指明子串是怎样编码的，code(i)=1为标准二进制编码，code(i)=0则为格雷编码；scale -二进制行向量，指明每个子串是否使用对数或算术刻度，scale(i)=0为算术刻度，scale(i)=1则为对数刻度；lbin、ubin -二进制行向量，指明表示范围中是否包含每个边界，选择lbin=0或ubin=0,表示从范围中去掉边界；lbin=1或ubin=1则表示范围中包含边界；注：增加第22 行：variable=bs2rv(Chrom, FieldD);否则提示第26 行plot(variable(l), Y, 'bo');中variable(I)越界yj2.m :目标函数是De Jong函数，是一个连续、凸起的单峰函数，它的M文件objfun1包含在GA工具箱软件中，De Jong函数的表达式为：n2f (x) = ' X j , 一512 乞X j E 512i d这里n是定义问题维数的一个值，本例中选取n=20，求解min f (x)，程序主要变量：NIND (个体的数量)：=40;MAXGEN (最大遗传代数)：=500；NVAR (变量维数)：=20 ；PRECI (每个变量使用多少位来表示)：=20；GGAP (代沟)：=0.9注：函数objfun1.m 中switch改为switch1，否则提示出错，因为switch为matlab保留字，下同！yj3.m :多元多峰函数的优化实例，Shubert函数表达式如下，求min f (x)【shubert.m 】f(x 「X 2)= 7 i cos[( i T)*X t i]*7 i cos[( i ■ 1) * x 2 - i] ,- 10 乞 X t , x 2 乞 10i丄i注：第10行各变量的上下限改为[-10;10]，原来为[-3;3];第25行改为：[Y, l]=min(ObjV);原来为[Y, I]=min(ObjVSel);以此将染色体的个 体值与shubert()函数值对应起来， 原表达式不具有 shubert()函数自变量和应变量的对应关系yj4.m :收获系统最优控制，收获系统(Harvest)是一个一阶的离散方程，表达式为x(k T) = a*x(k) - u (k) , k =1, 2,…，N-s.t. x(0)为初始条件x(k)三R 为状态变量u(k 厂R ■为控制输入变量精确优化解:用遗传算法对此问题求解， x(0) =100 , > -1.1，控制步骤N=20 ,决策变量u (k) 个数 NVAR=20, u(k) •二[0,200 ]注：第 20行语句原为：Chrom=crtrp(NIND,FieldDD);改为：Chrom=crtrp(SUBPOP*NIND,FieldDD);运行提示：Warning: File: D:\MA TLAB6p5\toolbox\gatbx\CRTRP .M Line: 34 Column: 19 Variable 'nargin' has bee n previously used as a function n ame. (Type "warni ngoff MATLAB:mir_warni ng_variable_used_as_fu nctio n"tosuppress this warnin g.)yj5.m :装载系统的最优问题，装载系统是一个二维系统，表达式如下X 1 ( k ' 1) = X 2 (k)丄 丄1x 2(k -1) =2 * x 2 (k) —X t (k)^u(k)N目标函数： 1Nf (x,u) - -X t (N 1)u (k)2N k 亠N _1理论最优解： min f (x, u) = _ 1 ■_ - — k 23 6N 2 N k 二目标函数: Nf(x,u)工 J u(k)k40.4 20x( N ) - x(0)k =1, 2,…，Nmax f (x)=Nx(0)(a -1) ~N 」 a (a -1)用遗传算法对此问题求解，x(0) =[0 0],控制步骤N=20,决策变量u(k)个数NVAR=20 , u(k)三[0,10]注：增加第32-35行语句，功能为实现每隔MIGGEN=20代，以迁移率MIGR=0.2在子种群之间迁移个体，增加这几行语句之前求得目标函数最小值为-0.1538，增加这几行语句之后求得目标函数最小值为-0.1544，目标函数理论最优值为-0.1544.yj6.m :离散二次线性系统最优控制问题，其一维二阶线性系统表达式如下：x(k 1)=a*x(k) b*u(k) , k =1, 2,…，N目标函数：N2 2 2f(x,u) =q*x(n 亠1)亠二[s * x( k)亠r*u(k)]k z1参数设置：求min f (x, u)yj7.m :目标分配问题描述为：m个地空导弹火力单元对n批空袭目标进行目标分配。
遗传算法求解函数最大值
遗传算法求解函数最大值研究者们广泛使用各种数学方法来求解函数的最大值，其中遗传算法是一种有效的解决方案。
遗传算法是一种仿生算法，使用相似的进化过程来搜索函数的最大值，这种算法在解决复杂问题时尤其有效。
遗传算法的工作原理是利用遗传操作来进行搜索。
它的步骤大致如下：首先，从初始种群中随机选择一定数量的个体，并进行多次重复，对其属性进行多次迭代，形成较优个体。
然后，根据结果，重建种群，以提高适应度。
在这个过程中，种群中的属性将不断改变，个体之间会遗传和变异，从而改变函数的最大值。
当属性变化趋于稳定时，这种改变的步骤就会停止，最大值就得到了。
为了更好地理解遗传算法，我们先来看一个例子。
一维函数f(x)=x^2-2x+5可以用遗传算法来求最大值。
我们以染色体序列长度为10作为种群大小，创建初始种群，并在每一代经历重复，变异，选择和交叉过程之后，依次获得较优个体。
在这个过程中，染色体序列不断变异，最后形成二进制数f(x)的最大值，最终求得f(x)的最大值为9。
遗传算法具有很多优点，其中最重要的是，它可以解决最优化问题，而且能够在有限的时间里达到不错的效果。
此外，遗传算法不会受到维度或者变量数量的限制，而且它可以根据需要改变变量的组合，从而获得更好的运算结果。
最后，遗传算法也可以应用在实际工程中，这就是遗传算法求解函数最大值的重要应用之一。
总的来说，遗传算法是一种通用的解决方案，能有效地搜索函数的最大值。
虽然它具有很多优点，但也有一些限制。
例如，算法的效率跟种群的大小有关，种群大小越大，搜索效率就越低，而且有时它也会陷入局部最优解中，从而无法搜索到全局最优解。
遗传算法可以给出不错的搜索结果，可以有效地求解函数最大值，是一种普遍应用的有效搜索方法。
因此，在未来，它将继续受到研究者们的广泛关注，并为世人带来更多的益处。
遗传算法求解函数最大值(matlab)
遗传算法求解函数F(x1，x2)=100*(x1^2-x2)^2+(1-x1)^2;的最大值(MATLAB)%Generic Algorithm for function f(x1,x2) optimum （最大值）clear all;close all;%ParametersSize=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+1);%****** 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 value (取整)kk=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');轐行绒果Map_Falue =3.9059e+ 03BestS =0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 Р0ɸ1 =-2&0480x2 =-2.0080。
遗传算法求解函数最大值最小值
遗传算法是一种模拟自然选择和遗传机制的优化搜索算法，它能够通过模拟生物进化的过程来寻找最优解。
在数学和计算领域，遗传算法被广泛应用于求解函数的最大值和最小值问题。
1. 遗传算法的基本原理遗传算法是一种基于裙体的优化算法，它模拟了自然界中的优胜劣汰和随机性变异的过程。
其基本原理包括遗传、变异、选择和适应度评价。
1.1 遗传：遗传算法通过模拟生物的交配过程来产生新的个体，其中将两个个体的染色体交叉并产生新的后代。
1.2 变异：遗传算法引入随机性的变异操作，以增加搜索空间的多样性，使算法不至于陷入局部最优解。
1.3 选择：个体的适应度评价后，根据一定的选择策略选择出部分个体作为下一代的种裙，通常适应度高的个体有更大的概率被选择。
1.4 适应度评价：遗传算法通过适应度函数对个体进行评价，以确定个体在种裙中的适应度。
适应度函数通常是需要优化的函数。
2. 遗传算法在求解函数最大值和最小值问题中的应用遗传算法作为一种全局搜索算法，具有寻找函数最大值和最小值的能力。
对于一个给定的函数，遗传算法能够在较短的时间内找到该函数的全局最优解。
2.1 函数最大值求解：对于函数的最大值求解问题，可以将函数的负值作为适应度函数，通过遗传算法来求解负值最小化的问题，从而达到求解函数最大值的目的。
2.2 函数最小值求解：对于函数的最小值求解问题，则可以直接将函数的值作为适应度函数，通过遗传算法来求解函数最小值问题。
3. 遗传算法在实际应用中的优势遗传算法作为一种全局搜索算法，在求解函数最大值和最小值问题中具有以下优势：3.1 并行性：遗传算法能够并行处理多个个体，从而加速搜索过程，尤其适合于复杂的高维优化问题。
3.2 全局搜索能力：遗传算法不容易陷入局部最优解，能够在较短的时间内找到函数的全局最优解。
3.3 适应性强：遗传算法能够适应不同类型的函数和问题，具有较强的通用性。
4. 遗传算法在求解函数最大值和最小值问题中的应用实例以下是一些实际应用中遗传算法在求解函数最大值和最小值问题中的应用实例：4.1 Rosenbrock函数最小值求解：Rosenbrock函数是一个经典的优化测试函数，遗传算法在求解Rosenbrock函数的最小值时具有良好的表现。
matlab遗传算法求解二元函数最大值
遗传算法是一种模拟自然选择与遗传机制的优化算法，它具有全局寻优能力强、适用范围广等优点。
结合Matlab强大的数学计算能力，可以使用遗传算法求解二元函数的最大值，本文将对此进行详细讨论。
二、遗传算法概述遗传算法是一种基于生物进化的优化算法，它的基本思想是模拟自然界中生物的繁殖、变异、适应过程。
通过适应度函数对个体进行评估，然后通过选择、交叉和变异等操作产生新的个体，以达到寻优目的。
遗传算法具有全局寻优、适用范围广等优点，被广泛应用于解决数值优化问题。
三、Matlab中遗传算法的实现在Matlab中，可以使用遗传算法工具箱（GATool）来求解二元函数的最大值。
首先需要定义适应度函数、种裙大小、交叉概率、变异概率等参数，然后通过GATool提供的函数进行遗传算法的求解过程。
四、遗传算法求解二元函数最大值的步骤1. 定义适应度函数：在Matlab中，可以使用function关键字定义适应度函数，例如：```matlabfunction y = fitnessFunction(x)y = -x(1)^2 - x(2)^2;```2. 设置遗传算法参数：定义种裙大小、交叉概率、变异概率等参数，例如：```matlaboptions = gaoptimset('PopulationSize', 50,'CrossoverFraction', 0.8, 'Mutation', {mutationuniform, 0.1});```3. 调用遗传算法求解：使用Matlab提供的遗传算法函数对二元函数进行最大值求解，例如：```matlab[x, fval] = ga(fitnessFunction, 2, [], [], [], [], [-10, -10], [10, 10], [], options);```五、案例分析以二元函数f(x) = -x1^2 - x2^2为例，通过以上步骤在Matlab中进行遗传算法求解，可以得到最大值点为(0, 0)，最大值为0。
实验五：遗传算法求解函数最值问题实验
实验五：遗传算法求解函数最值问题实验一、实验目的使用遗传算法求解函数在及y的最大值。
二、实验内容使用遗传算法进行求解，篇末所附源代码中带有算法的详细注释。
算法中涉及不同的参数，参数的取值需要根据实际情况进行设定，下面运行时将给出不同参数的结果对比。
定义整体算法的结束条件为，当种群进化次数达到maxGeneration时停止，此时种群中的最优解即作为算法的最终输出。
设种群规模为N，首先是随机产生N个个体，实验中定义了类型Chromosome表示一个个体，并且在默认构造函数中即进行了随机的操作。
然后程序进行若干次的迭代，在每次迭代过程中，进行选择、交叉及变异三个操作。
1.选择操作首先计算当前每个个体的适应度函数值，这里的适应度函数即为所要求的优化函数，然后归一化求得每个个体选中的概率，然后用轮盘赌的方法以允许重复的方式选择选择N个个体，即为选择之后的群体。
但实验时发现结果不好，经过仔细研究之后发现，这里在x、y 取某些值的时候，目标函数计算出来的适应值可能会出现负值，这时如果按照把每个个体的适应值除以适应值的总和的进行归一化的话会出现问题，因为个体可能出现负值，总和也可能出现负值，如果归一化的时候除以了一个负值，选择时就会选择一些不良的个体，对实验结果造成影响。
对于这个问题，我把适应度函数定为目标函数的函数值加一个正数，保证得到的适应值为正数，然后再进行一般的归一化和选择的操作。
实验结果表明，之前的实验结果很不稳定，修正后的结果比较稳定，趋于最大值。
2.交叉操作首先是根据交叉概率probCross选择要交叉的个体进行交叉。
这里根据交叉参数crossnum进行多点交叉，首先随机生成交叉点位置，允许交叉点重合，两个重合的交叉点效果互相抵消，相当于没有交叉点，然后根据交叉点进行交叉操作，得到新的个体。
3.变异操作首先是根据变异概率probMutation选择要变异的个体。
变异时先随机生成变异的位置，然后把改位的01值翻转。
遗传算法求取函数最大值
%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
二进制编码遗传算法求函数极大值
二进制编码遗传算法求函数极大值二进制编码遗传算法是一种用于求解函数极大值的优化方法。
通过将函数的自变量编码为二进制字符串，然后利用遗传算法进行搜索，以找到函数的极大值。
下面是详细步骤：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. 结果输出：输出找到的极大值以及对应的自变量值。
通过以上步骤，二进制编码遗传算法可以用于求解函数的极大值。
需要注意的是，二进制编码遗传算法的性能受到种群数量、编码长度、交叉率、变异率等因素的影响，需要根据实际情况调整参数。
使用遗传算法求解函数最大值
使用遗传算法求解函数最大值遗传算法是一种基于自然选择和遗传机制的优化算法，常用于求解函数最大（或最小）值的问题。
它模拟了自然界中的进化过程，通过不断迭代的方式问题的解空间，最终找到最优解。
遗传算法的基本思想是通过模拟进化过程中的选择、交叉和变异等操作，逐步优化种群中的个体，并逐代演化出更好的解。
下面将详细介绍遗传算法的基本流程及其在求解函数最大值问题中的应用。
1.初始化种群：随机生成一组初始解作为种群的个体，代表问题的可能解。
个体可以表示为一组数据，如一个浮点数、二进制串或其他形式。
2.评估适应度：对每个个体进行适应度评估，即计算个体对应的目标函数值。
在函数最大值问题中，适应度值通常与目标函数值成正比，可以简单地将适应度设为目标函数值。
3.选择操作：根据个体的适应度值，利用选择算子选择一定数量的个体作为父代。
通常使用轮盘赌算法或排名选择算法来进行选择。
4.交叉操作：从父代中选取两个个体，利用交叉算子进行基因的交换，产生新的个体。
交叉操作旨在通过基因的组合，产生具有更好性能的个体。
5.变异操作：以一定的概率对新生成的个体进行变异，即改变个体中的一些基因，引入新的基因。
变异操作能够增加空间的多样性，防止算法陷入局部最优解。
6.评估适应度：对新生成的个体进行适应度评估。
7.更新种群：根据一定的策略，将新生成的个体替换原来的个体，生成新的种群。
8.终止条件判断：判断是否达到终止条件，如迭代次数达到预设值或找到满足一定条件的解。
9.返回结果：返回最优解，即具有最大适应度的个体。
通过以上步骤，遗传算法能够问题的解空间，并不断演化出适应度更高的个体，最终找到函数最大值的解。
在具体应用遗传算法求解函数最大值问题时，需要根据问题的特点灵活调整算法的参数和操作。
例如，选择算子的选择方式、交叉算子的选择方式、变异概率的设置等，都会对算法的性能产生影响。
此外，还需注意适应度函数的设计。
适应度函数应能准确地度量个体的好坏程度，并且在适应度计算过程中要避免一些问题，如数值溢出、计算复杂度过高等。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
人工智能遗传算法函数优化目录1引言 (3)1.1 摘要 (3)1.2 背景 (3)2 实验过程 (4)2.1 程序目标 (4)2.2 实验原理及步骤 (4)2.3程序 (5)2.3.1程序理解： (5)2.3.3调试程序： (5)2.4 实验总结 (18)1引言1.1 摘要函数优化是遗传算法的经典应用领域，也是对遗传算法进行性能评价的常用算例。
本文将用一个详细的例子来说明用遗传算法解一个简单参数优化问题的过程。
这里求解的是一个函数的最大值的问题。
1.2 背景遗传算法采纳自然进化模型。
通过保持一个潜在解的群体执行了多方向的搜索并支持这些方向上的信息构成和交换。
群体经过一个模拟进化的过程：在每一代，相对“好”的解产生，相对“差”的解死亡。
为区别不同解，我们使用了一个目标（评价）函数，它起着一个环境的作用。
选择是用来确定管理费用或交叉个体，以及被选个体将产生多少个代个体。
杂交组合了两个亲代染色体的特征，并通过交换父代相应的片断形成了两个相似的后代。
杂交算子的意图是在不同潜在解之间进行信息交换。
变异是通过用一个等于变异率的概率随机地改变被选择染色体上的一个或多个基因。
变异算子的意图是向群体引入一些额外的变化性。
运用遗传算法解题必经的五个步骤：1．对问题潜在解的遗传表达。
2．产生潜在解初始群体的方法。
3．起环境作用的用“适应值”评价解的适应程度的评价函数。
4．改变后代组成的各种遗传算子。
5．遗传算法所使用的各种参数：群体规模、应用遗传算子的概率等。
2 实验过程2.1 程序目标在实验过程中，我们应用遗传算法来模拟一个函数优化的问题。
程序所要解决的问题是求f(x1,x2)=21.5+x1*sin(4pi*x1)+x2*sin(20pi*x2)的最大值，其中-3.0≤x1≤12.1及4.1≤x2≤5.8。
2.2 实验原理及步骤1 ）首先确立变量x1的定义域长度为15.1；所要求的小数点以后第四位精度意味着区间[-3.0, 12.1]应该至少被分成15.1*10000个等距区间，即染色体的第一部分需要18位；自变量x2域长度为 1.7，精度要求区间[4.1, 5.8]应该至少被分成1.7*10000个等距区间，即染色体的第二部分需要15位。
所以染色体总长度为33位。
用遗传算法的优化函数f,产生了一个有pop_size = 20个染色体的群体。
所有染色体的33位都是随机初始化。
对每个染色体进行解码并计算解码后的（x1,x2）的适应函数值，eval(vi) (i=1,..,pop_size) = f(x1,x2)。
2）为选择过程建立一个轮盘。
计算群体的总适应值F，并计算每个染色体vi (i=1,..,pop_size)的选择概率pi:pi = eval(vi) / F 和累积概率qi: qi = p1 + .. + pi.3）转动轮盘20次，每次为新群体选择一单个染色体。
生成一个区间[0,1]里的20个数的一个随机序列。
如果一个随机数位于qi于q(i+1)之间，则q(i+1)被选择。
4）对新群体中的个体应用杂交算子。
杂交概率pc = 0.25，所以预计染色体中平均有25%将经历杂交。
杂交按照下面的方法进行：对新群体中的每个染色体，产生在区间[0,1]里的随机数r,并从随机序列中选出r<0.25的染色体进行杂交。
5）对被选择的染色体随机进行配对。
并从区间[1,32]里产生一个随机整数pos。
数字pos表示杂交点的位置。
6）算子变异。
在一位一位基础上执行。
变异概率pm = 0.01,所以我们预计平均将有1%的位经历变异。
整个群体共有m*pop_size = 660位，可以预计平均每代有6.6次变异。
因为每一位都有均等的机会被变异，所以对群体中的每一位可以产生区间[0,1]里的一个随机数r,如果r<0.01,则变异此位。
7）由上面得到最新的向量群体。
对每个染色体进行解码，并计算解码后的(x1,x2)的适应函数值。
选出最好染色体的评价值。
8）准备再一次运行选择过程，继续进行迭代计算，应用遗传算子及评价下一代。
2.3程序2.3.1程序理解：初始化函数：在变量限定的范围内初始化遗传因子的值。
从gadata.txt'这个文件中读取每个变量的上下边界，并且在这个范围内随机初始化产生染色体中的值。
随机值生成函数：多次用到此函数。
评价函数：函数需要用户自己定义一个数学函数式。
population[mem].fitness = 21.5+x[1]*sin(4.0*PI*x[1])+x[2]*sin(20.0*PI*x[2]);记录最优个体（取优函数）：前一代的最优成员被存储在数组的最后。
但如果现今这一代的最优成员并没有上一代的好（值小于），则后者（上一代的最优值）会取代本代中最差的成员。
如果当前代的最优值大于上一代的，则将当前代的最优值拷贝出来，否则则用上一代的最优值取代当前代的最差值。
确保我们始终取到最适合的那个值。
选择函数：为的是解决优化模型中的最大问题，确保最优秀的成员始终存活下来。
杂交函数：void Xover(int one, int two)对选择出来的双亲进行杂交。
变异：void mutate(void)某个被选择出来的要进行变异的因子，将会被一个取值范围内的随机量所代替。
报告函数：void report(void)用来报告演算程序的进展。
输入output文件里的数据以逗号相隔。
2.3.3调试程序：写好程序之后，就可以进行调试了。
当在gadat.txt里输入3 5；6 9；7 8；1 6四组数据时，在”galog.txt”文件中可以看到输出的结果。
现附上迭代500次的结果：1, 32.922158615, 23.048467665, 5.9266975712, 32.922158615, 25.219353332, 4.7481252773, 32.922158615, 25.602532313, 4.4710821274, 32.922158615, 26.483624415, 4.7128737915, 34.004917169, 27.171438656, 4.4017050266, 34.004917169, 27.632563061, 4.3429457467, 34.004917169, 28.507499261, 4.1029910808, 34.295500976, 28.367508993, 4.4348759249, 34.295500976, 28.713407029, 3.942327273 。
494, 34.295500976, 34.295500976, 0.000000664495, 34.295500976, 34.295500976, 0.000000664496, 34.295500976, 34.295500976, 0.000000664497, 34.295500976, 34.295500976, 0.000000664498, 34.295500976, 34.295500976, 0.000000664499, 34.295500976, 34.295500976, 0.000000664500, 34.295500976, 34.295500976, 0.000000664Simulation completedvar(0) = 4.654000000var(1) = 8.721000000var(2) = 7.609000000var(3) = 5.980000000Best fitness = 34.295500976附源代码：#include <stdio.h>#include <stdlib.h>#include <math.h>#define TRUE 1#define FALSE 0#define PMUTATION 0.001 #define MAXGENS 500#define POPSIZE 100#define NV ARS 4#define PXOVER 0.8int generation;int cur_best;FILE *galog;FILE *output;struct genotype{double gene[NV ARS];double fitness;double upper[NV ARS];double lower[NV ARS];double rfitness;double cfitness;};struct genotype population[POPSIZE+1]; struct genotype newpopulation[POPSIZE+1]; void initialize(void);double randval(double, double);void evaluate(void);void keep_the_best(void);void elitist(void);void select(void);void crossover(void);void Xover(int,int);void swap(double *, double *);void mutate(void);void report(void);void initialize(void){FILE *infile;int i, j;double lbound, ubound;if ((infile = fopen("gadata.txt","r"))==NULL) {fprintf(galog,"\nCannot open input file!\n");exit(1);}remove("output.dat");for (i = 0; i < NV ARS; i++){fscanf(infile, "%lf",&lbound);fscanf(infile, "%lf",&ubound);for (j = 0; j < POPSIZE; j++){population[j].fitness = 0;population[j].rfitness = 0;population[j].cfitness = 0;population[j].lower[i] = lbound;population[j].upper[i] = ubound;population[j].gene[i] = randval(population[j].lower[i],population[j].upper[i]);}}fclose(infile);}double randval(double low, double high){double val;val = ((double)(rand()%1000)/1000.0)*(high - low) + low;return(val);}void evaluate(void){if ((output = fopen("output.dat","a"))==NULL){exit(1);}int mem;int i;double x[NV ARS+1];double PI = 3.141593;for (mem = 0; mem < POPSIZE; mem++){for (i = 0; i < NV ARS; i++)x[i+1] = population[mem].gene[i];population[mem].fitness = 21.5+x[1]*sin(4.0*PI*x[1])+x[2]*sin(20.0*PI*x[2]);if (population[mem].fitness <40 && population[mem].fitness>35){fprintf(output, "\n%5d, %6.9f, %6.9f, %6.9f ", generation,x[1],x[2],population[mem].fitness);}}fclose(output);}void keep_the_best(){int mem;int i;cur_best = 0;for (mem = 0; mem < POPSIZE; mem++){if (population[mem].fitness > population[POPSIZE].fitness){cur_best = mem;population[POPSIZE].fitness = population[mem].fitness;}}for (i = 0; i < NV ARS; i++)population[POPSIZE].gene[i] = population[cur_best].gene[i]; }void elitist(){int i;double best, worst;int best_mem, worst_mem;best = population[0].fitness;worst = population[0].fitness;for (i = 0; i < POPSIZE - 1; ++i){if(population[i].fitness > population[i+1].fitness){if (population[i].fitness >= best){best = population[i].fitness;best_mem = i;}if (population[i+1].fitness <= worst){worst = population[i+1].fitness;worst_mem = i + 1;}}else{if (population[i].fitness <= worst){worst = population[i].fitness;worst_mem = i;}if (population[i+1].fitness >= best){best = population[i+1].fitness;best_mem = i + 1;}}}if (best >= population[POPSIZE].fitness){for (i = 0; i < NV ARS; i++)population[POPSIZE].gene[i] = population[best_mem].gene[i];population[POPSIZE].fitness = population[best_mem].fitness;}else{for (i = 0; i < NV ARS; i++)population[worst_mem].gene[i] = population[POPSIZE].gene[i];population[worst_mem].fitness = population[POPSIZE].fitness;}}void select(void){int mem, i, j, k;double sum = 0;double p;for (mem = 0; mem < POPSIZE; mem++){sum += population[mem].fitness;}for (mem = 0; mem < POPSIZE; mem++){population[mem].rfitness = population[mem].fitness/sum;}population[0].cfitness = population[0].rfitness;for (mem = 1; mem < POPSIZE; mem++){population[mem].cfitness = population[mem-1].cfitness +population[mem].rfitness;}for (i = 0; i < POPSIZE; i++){p = rand()%1000/1000.0;if (p < population[0].cfitness)newpopulation[i] = population[0];else{for (j = 0; j < POPSIZE;j++)if (p >= population[j].cfitness &&p<population[j+1].cfitness)newpopulation[i] = population[j+1];}}for (i = 0; i < POPSIZE; i++)population[i] = newpopulation[i];}void crossover(void){int i, mem, one;int first = 0;double x;for (mem = 0; mem < POPSIZE; ++mem){x = rand()%1000/1000.0;if (x < PXOVER){++first;if (first % 2 == 0)Xover(one, mem);elseone = mem;}}}void Xover(int one, int two){int i;int point;if(NV ARS > 1){if(NV ARS == 2)point = 1;elsepoint = (rand() % (NV ARS - 1)) + 1;for (i = 0; i < point; i++)swap(&population[one].gene[i], &population[two].gene[i]);}}void swap(double *x, double *y){double temp;temp = *x;*x = *y;*y = temp;}void mutate(void){int i, j;double lbound, hbound;double x;for (i = 0; i < POPSIZE; i++)for (j = 0; j < NV ARS; j++){x = rand()%1000/1000.0;if (x < PMUTATION){lbound = population[i].lower[j];hbound = population[i].upper[j];population[i].gene[j] = randval(lbound, hbound);}}}void report(void){int i;double best_val;double avg;double stddev;double sum_square;double square_sum;double sum;sum = 0.0;sum_square = 0.0;for (i = 0; i < POPSIZE; i++){sum += population[i].fitness;sum_square += population[i].fitness * population[i].fitness;}avg = sum/(double)POPSIZE;square_sum = avg * avg * POPSIZE;stddev = sqrt((sum_square - square_sum)/(POPSIZE - 1));best_val = population[POPSIZE].fitness;fprintf(galog, "\n%5d, %6.9f, %6.9f, %6.9f ", generation, best_val, avg, stddev);printf( "\n%5d, %6.9f, %6.9f, %6.9f ", generation, best_val, avg, stddev);}void main(void){int i;if ((galog = fopen("galog.txt","w"))==NULL){exit(1);}generation = 0;fprintf(galog, "\n generation best average standard \n");printf( "\n generation best average standard \n");fprintf(galog, " number value fitness deviation \n");printf(" number value fitness deviation \n");initialize();evaluate();keep_the_best();while(generation<MAXGENS){generation++;select();crossover();mutate();report();evaluate();elitist();}fprintf(galog,"\n\n Simulation completed\n");printf("\n\n Simulation completed\n");fprintf(galog,"\n\n Simulation completed\n");printf("\n\n Simulation completed\n");for (i = 0; i < NV ARS; i++){fprintf (galog,"\n var(%d) = %3.9f",i,population[POPSIZE].gene[i]);printf ("\n var(%d) = %3.9f",i,population[POPSIZE].gene[i]);}fprintf(galog,"\n\n Best fitness = %3.9f",population[POPSIZE].fitness); fclose(galog);printf("\n\n Best fitness = %3.9f",population[POPSIZE].fitness);printf("\n OK\n");}2.4 实验总结通过这次实验，我发现了遗传算法在某些方面的巨大优势和强大功能；它能够非常快地解决一些非常复杂的问题。