matlab遗传算法程序
用MATLAB实现遗传算法程序
用MATLAB实现遗传算法程序一、本文概述遗传算法（Genetic Algorithms，GA）是一种模拟自然界生物进化过程的优化搜索算法，它通过模拟自然选择和遗传学机制，如选择、交叉、变异等，来寻找问题的最优解。
由于其全局搜索能力强、鲁棒性好以及易于实现并行化等优点，遗传算法在多个领域得到了广泛的应用，包括函数优化、机器学习、神经网络训练、组合优化等。
本文旨在介绍如何使用MATLAB实现遗传算法程序。
MATLAB作为一种强大的数学计算和编程工具，具有直观易用的图形界面和丰富的函数库，非常适合用于遗传算法的实现。
我们将从基本的遗传算法原理出发，逐步介绍如何在MATLAB中编写遗传算法程序，包括如何定义问题、编码、初始化种群、选择操作、交叉操作和变异操作等。
通过本文的学习，读者将能够掌握遗传算法的基本原理和MATLAB编程技巧，学会如何使用MATLAB实现遗传算法程序，并能够在实际问题中应用遗传算法求解最优解。
二、遗传算法基础遗传算法（Genetic Algorithm，GA）是一种模拟自然选择和遗传学机制的优化搜索算法。
它借鉴了生物进化中的遗传、交叉、变异等机制，通过模拟这些自然过程来寻找问题的最优解。
遗传算法的核心思想是将问题的解表示为“染色体”，即一组编码，然后通过模拟自然选择、交叉和变异等过程，逐步迭代搜索出最优解。
在遗传算法中，通常将问题的解表示为一个二进制字符串，每个字符串代表一个个体（Individual）。
每个个体都有一定的适应度（Fitness），适应度越高的个体在下一代中生存下来的概率越大。
通过选择（Selection）、交叉（Crossover）和变异（Mutation）等操作，生成新一代的个体，并重复这一过程，直到找到满足条件的最优解或达到预定的迭代次数。
选择操作是根据个体的适应度，选择出适应度较高的个体作为父母，参与下一代的生成。
常见的选择算法有轮盘赌选择（Roulette Wheel Selection）、锦标赛选择（Tournament Selection）等。
matlab遗传算法 算例
下面是一个使用MATLAB实现的基本遗传算法算例。
本例用于解决简单的优化问题：寻找函数f(x) = x^2在[-10,10]范围内的最小值。
```matlab定义问题参数PopSize = 100; 种群数量Genes = -10:0.1:10; 基因范围FitnessFunc = @(x) -x.^2; 适应度函数(这里为了方便，使用了-x^2，即求最大值，实际应用中应改为-f(x))MaxGen = 50; 最大迭代次数初始化种群Pop = zeros(PopSize, length(Genes));for i = 1:PopSizePop(i,:) = rand(1,length(Genes))*2*Genes - Genes; 随机产生初始种群end开始迭代for gen = 1:MaxGen计算当前种群适应度Fitness = FitnessFunc(Pop);[BestFit, Index] = max(Fitness); 找到最佳适应度BestFitPos = Pop(Index,:); 找到最佳适应度对应的基因选择（轮盘赌选择）NewPop = zeros(PopSize, length(Genes));SumFitness = sum(Fitness);RandomFitness = rand(PopSize,1)*SumFitness; 随机生成每个个体的"随机适应度"for i = 1:PopSize[~, Index] = min(RandomFitness); 用随机适应度进行选择（越小被选中概率越大）NewPop(i,:) = Pop(Index,:); 将选择出的个体放入新种群RandomFitness(Index) = SumFitness; 将已选择的个体的随机适应度设为最大值，避免重复选择end交叉（杂交）for i = 1:PopSize/2随机选择两个父代个体Parent1 = NewPop(randi([1 PopSize]),:);Parent2 = NewPop(randi([1 PopSize]),:);生成新个体Child1 = (Parent1 + Parent2)/2; 中间值交叉Child2 = Parent1 + (Parent2 - Parent1)*rand; 一点交叉将新个体加入新种群NewPop((i-1)*2+1,:) = Child1;NewPop((i-1)*2+2,:) = Child2;end变异for i = 1:PopSizeif rand < 0.01 变异概率为0.01随机选择一个基因进行变异（取反）GeneIdx = randi(length(Genes));NewPop(i,GeneIdx) = ~NewPop(i,GeneIdx);endend更新种群Pop = NewPop;end输出结果BestFit = FitnessFunc(BestFitPos);fprintf('Best fitness: f\n', BestFit);fprintf('Best position: s\n', num2str(BestFitPos));```这个例子比较简单，只用了基本的遗传算法操作：选择、交叉和变异。
遗传算法及其MATLAB程序
遗传算法及其MATLAB实现主要内容遗传算法简介遗传算法的MATLAB实现应用举例一、遗传算法简介遗传算法（Genetic Algorithm,GA）最先是由美国Mic-hgan大学的John Holland于1975年提出的。
遗传算法是模拟达尔文的遗传选择和自然淘汰的生物进化过程的计算模型。
它的思想源于生物遗传学和适者生存的自然规律，是具有“生存+检测”的迭代过程的搜索算法。
遗传算法以一种群体中的所有个体为对象，并利用随机化技术指导对一个被编码的参数空间进行高效搜索。
其中，选择、交叉和变异构成了遗传算法的遗传操作；参数编码、初始群体的设定、适应度函数的设计、遗传操作设计、控制参数设定等5个要素组成了遗传算法的核心内容。
遗传算法的基本步骤：遗传算法是一种基于生物自然选择与遗传机理的随机搜索算法，与传统搜索算法不同，遗传算法从一组随机产生的称为“种群(Population)”的初始解开始搜索过程。
种群中的每个个体是问题的一个解，称为“染色体(chromos ome)”。
染色体是一串符号，比如一个二进制字符串。
这些染色体在后续迭代中不断进化，称为遗传。
在每一代中用“适值(fitness)”来测量染色体的好坏，生成的下一代染色体称为后代（offspring）。
后代是由前一代染色体通过交叉(crossover)或者变异（mutation）运算形成的。
在新一代形成过程中，根据适度的大小选择部分后代，淘汰部分后代。
从而保持种群大小是常数。
适值高的染色体被选中的概率较高，这样经过若干代之后，算法收敛于最好的染色体，它很可能就是问题的最优解或次优解。
主要步骤如下所示：(1)编码：GA在进行搜索之前先将解空间的解数据表示成遗传空间的基因型串结构数据，这些串结构数据的不同组合便构成了不同的点。
(2)初始群体的生成：随机产生N个初始串结构数据，每个串结构数据称为一个个体，N个个体构成了—个群体。
GA以这N个串结构数据作为初始点开始迭代。
2020年遗传算法matlab程序实例精编版
%-----------------------------------------------%---------------------------------------------------遗传算法程序（一）:说明: fga.m 为遗传算法的主程序; 采用二进制Gray编码,采用基于轮盘赌法的非线性排名选择, 均匀交叉,变异操作,而且还引入了倒位操作!function [BestPop,Trace]=fga(FUN,LB,UB,eranum,popsize,pCross,pMutation,pInversion,options) % [BestPop,Trace]=fmaxga(FUN,LB,UB,eranum,popsize,pcross,pmutation)% Finds a maximum of a function of several variables.% fmaxga solves problems of the form:% max F(X) subject to: LB <= X <= UB% BestPop - 最优的群体即为最优的染色体群% Trace - 最佳染色体所对应的目标函数值% FUN - 目标函数% LB - 自变量下限% UB - 自变量上限% eranum - 种群的代数,取100--1000(默认200)% popsize - 每一代种群的规模；此可取50--200(默认100)% pcross - 交叉概率,一般取0.5--0.85之间较好(默认0.8)% pmutation - 初始变异概率,一般取0.05-0.2之间较好(默认0.1)% pInversion - 倒位概率,一般取0.05－0.3之间较好(默认0.2)% options - 1*2矩阵,options(1)=0二进制编码(默认0),option(1)~=0十进制编%码,option(2)设定求解精度(默认1e-4)%% ------------------------------------------------------------------------T1=clock;if nargin<3, error('FMAXGA requires at least three input arguments'); endif nargin==3, eranum=200;popsize=100;pCross=0.8;pMutation=0.1;pInversion=0.15;options=[0 1e-4];endif nargin==4, popsize=100;pCross=0.8;pMutation=0.1;pInversion=0.15;options=[0 1e-4];endif nargin==5, pCross=0.8;pMutation=0.1;pInversion=0.15;options=[0 1e-4];endif nargin==6, pMutation=0.1;pInversion=0.15;options=[0 1e-4];endif nargin==7, pInversion=0.15;options=[0 1e-4];endif find((LB-UB)>0)error('数据输入错误,请重新输入(LB<UB):');ends=sprintf('程序运行需要约%.4f 秒钟时间,请稍等......',(eranum*popsize/1000));disp(s);global m n NewPop children1 children2 VarNumbounds=[LB;UB]';bits=[];VarNum=size(bounds,1);precision=options(2);%由求解精度确定二进制编码长度bits=ceil(log2((bounds(:,2)-bounds(:,1))' ./ precision));%由设定精度划分区间[Pop]=InitPopGray(popsize,bits);%初始化种群[m,n]=size(Pop);NewPop=zeros(m,n);children1=zeros(1,n);children2=zeros(1,n);pm0=pMutation;BestPop=zeros(eranum,n);%分配初始解空间BestPop,TraceTrace=zeros(eranum,length(bits)+1);i=1;while i<=eranumfor j=1:mvalue(j)=feval(FUN(1,:),(b2f(Pop(j,:),bounds,bits)));%计算适应度end[MaxValue,Index]=max(value);BestPop(i,:)=Pop(Index,:);Trace(i,1)=MaxValue;Trace(i,(2:length(bits)+1))=b2f(BestPop(i,:),bounds,bits);[selectpop]=NonlinearRankSelect(FUN,Pop,bounds,bits);%非线性排名选择[CrossOverPop]=CrossOver(selectpop,pCross,round(unidrnd(eranum-i)/eranum));%采用多点交叉和均匀交叉，且逐步增大均匀交叉的概率%round(unidrnd(eranum-i)/eranum)[MutationPop]=Mutation(CrossOverPop,pMutation,VarNum);%变异[InversionPop]=Inversion(MutationPop,pInversion);%倒位Pop=InversionPop;%更新pMutation=pm0+(i^4)*(pCross/3-pm0)/(eranum^4);%随着种群向前进化，逐步增大变异率至1/2交叉率p(i)=pMutation;i=i+1;endt=1:eranum;plot(t,Trace(:,1)');title('函数优化的遗传算法');xlabel('进化世代数(eranum)');ylabel('每一代最优适应度(maxfitness)');[MaxFval,I]=max(Trace(:,1));X=Trace(I,(2:length(bits)+1));hold on; plot(I,MaxFval,'*');text(I+5,MaxFval,['FMAX=' num2str(MaxFval)]);str1=sprintf ('进化到%d 代,自变量为%s 时,得本次求解的最优值%f\n对应染色体是：%s',I,num2str(X),MaxFval,num2str(BestPop(I,:)));disp(str1);%figure(2);plot(t,p);%绘制变异值增大过程T2=clock;elapsed_time=T2-T1;if elapsed_time(6)<0elapsed_time(6)=elapsed_time(6)+60; elapsed_time(5)=elapsed_time(5)-1;endif elapsed_time(5)<0elapsed_time(5)=elapsed_time(5)+60;elapsed_time(4)=elapsed_time(4)-1;end %像这种程序当然不考虑运行上小时啦str2=sprintf('程序运行耗时%d 小时%d 分钟%.4f 秒',elapsed_time(4),elapsed_time(5),elapsed_time(6));disp(str2);%初始化种群%采用二进制Gray编码,其目的是为了克服二进制编码的Hamming悬崖缺点function [initpop]=InitPopGray(popsize,bits)len=sum(bits);initpop=zeros(popsize,len);%The whole zero encoding individualfor i=2:popsize-1pop=round(rand(1,len));pop=mod(([0 pop]+[pop 0]),2);%i=1时,b(1)=a(1);i>1时,b(i)=mod(a(i-1)+a(i),2)%其中原二进制串:a(1)a(2)...a(n),Gray串:b(1)b(2)...b(n)initpop(i,:)=pop(1:end-1);endinitpop(popsize,:)=ones(1,len);%The whole one encoding individual%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%解码function [fval] = b2f(bval,bounds,bits)% fval - 表征各变量的十进制数% bval - 表征各变量的二进制编码串% bounds - 各变量的取值范围% bits - 各变量的二进制编码长度scale=(bounds(:,2)-bounds(:,1))'./(2.^bits-1); %The range of the variablesnumV=size(bounds,1);cs=[0 cumsum(bits)];for i=1:numVa=bval((cs(i)+1):cs(i+1));fval(i)=sum(2.^(size(a,2)-1:-1:0).*a)*scale(i)+bounds(i,1);end%选择操作%采用基于轮盘赌法的非线性排名选择%各个体成员按适应值从大到小分配选择概率：%P(i)=(q/1-(1-q)^n)*(1-q)^i, 其中P(0)>P(1)>...>P(n), sum(P(i))=1function [selectpop]=NonlinearRankSelect(FUN,pop,bounds,bits)global m nselectpop=zeros(m,n);fit=zeros(m,1);for i=1:mfit(i)=feval(FUN(1,:),(b2f(pop(i,:),bounds,bits)));%以函数值为适应值做排名依据endselectprob=fit/sum(fit);%计算各个体相对适应度(0,1)q=max(selectprob);%选择最优的概率x=zeros(m,2);x(:,1)=[m:-1:1]';[y x(:,2)]=sort(selectprob);r=q/(1-(1-q)^m);%标准分布基值newfit(x(:,2))=r*(1-q).^(x(:,1)-1);%生成选择概率newfit=cumsum(newfit);%计算各选择概率之和rNums=sort(rand(m,1));fitIn=1;newIn=1;while newIn<=mif rNums(newIn)<newfit(fitIn)selectpop(newIn,:)=pop(fitIn,:);newIn=newIn+1;elsefitIn=fitIn+1;endend%交叉操作function [NewPop]=CrossOver(OldPop,pCross,opts)%OldPop为父代种群，pcross为交叉概率global m n NewPopr=rand(1,m);y1=find(r<pCross);y2=find(r>=pCross);len=length(y1);if len>2&mod(len,2)==1%如果用来进行交叉的染色体的条数为奇数，将其调整为偶数y2(length(y2)+1)=y1(len);y1(len)=[];endif length(y1)>=2for i=0:2:length(y1)-2if opts==0[NewPop(y1(i+1),:),NewPop(y1(i+2),:)]=EqualCrossOver(OldPop(y1(i+1),:),OldPop(y1(i+2),:));else[NewPop(y1(i+1),:),NewPop(y1(i+2),:)]=MultiPointCross(OldPop(y1(i+1),:),OldPop(y1(i+2),:));endendendNewPop(y2,:)=OldPop(y2,:);%采用均匀交叉function [children1,children2]=EqualCrossOver(parent1,parent2)global n children1 children2hidecode=round(rand(1,n));%随机生成掩码crossposition=find(hidecode==1);holdposition=find(hidecode==0);children1(crossposition)=parent1(crossposition);%掩码为1，父1为子1提供基因children1(holdposition)=parent2(holdposition);%掩码为0，父2为子1提供基因children2(crossposition)=parent2(crossposition);%掩码为1，父2为子2提供基因children2(holdposition)=parent1(holdposition);%掩码为0，父1为子2提供基因%采用多点交叉，交叉点数由变量数决定function [Children1,Children2]=MultiPointCross(Parent1,Parent2)global n Children1 Children2 VarNumChildren1=Parent1;Children2=Parent2;Points=sort(unidrnd(n,1,2*VarNum));for i=1:VarNumChildren1(Points(2*i-1):Points(2*i))=Parent2(Points(2*i-1):Points(2*i));Children2(Points(2*i-1):Points(2*i))=Parent1(Points(2*i-1):Points(2*i));end%变异操作function [NewPop]=Mutation(OldPop,pMutation,VarNum)global m n NewPopr=rand(1,m);position=find(r<=pMutation);len=length(position);if len>=1for i=1:lenk=unidrnd(n,1,VarNum); %设置变异点数，一般设置1点for j=1:length(k)if OldPop(position(i),k(j))==1OldPop(position(i),k(j))=0;elseOldPop(position(i),k(j))=1;endendendendNewPop=OldPop;%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%倒位操作function [NewPop]=Inversion(OldPop,pInversion)global m n NewPopNewPop=OldPop;r=rand(1,m);PopIn=find(r<=pInversion);len=length(PopIn);if len>=1for i=1:lend=sort(unidrnd(n,1,2));if d(1)~=1&d(2)~=nNewPop(PopIn(i),1:d(1)-1)=OldPop(PopIn(i),1:d(1)-1);NewPop(PopIn(i),d(1):d(2))=OldPop(PopIn(i),d(2):-1:d(1));NewPop(PopIn(i),d(2)+1:n)=OldPop(PopIn(i),d(2)+1:n);endendend遗传算法程序（二）:function youhuafunD=code;N=50; % Tunablemaxgen=50; % Tunablecrossrate=0.5; %Tunablemuterate=0.08; %Tunablegeneration=1;num = length(D);fatherrand=randint(num,N,3);score = zeros(maxgen,N);while generation<=maxgenind=randperm(N-2)+2; % 随机配对交叉A=fatherrand(:,ind(1:(N-2)/2));B=fatherrand(:,ind((N-2)/2+1:end));% 多点交叉rnd=rand(num,(N-2)/2);ind=rnd tmp=A(ind);A(ind)=B(ind);B(ind)=tmp;% % 两点交叉% for kk=1:(N-2)/2% rndtmp=randint(1,1,num)+1;% tmp=A(1:rndtmp,kk);% A(1:rndtmp,kk)=B(1:rndtmp,kk);% B(1:rndtmp,kk)=tmp;% endfatherrand=[fatherrand(:,1:2),A,B];% 变异rnd=rand(num,N);ind=rnd [m,n]=size(ind);tmp=randint(m,n,2)+1;tmp(:,1:2)=0;fatherrand=tmp+fatherrand;fatherrand=mod(fatherrand,3);% fatherrand(ind)=tmp;%评价、选择scoreN=scorefun(fatherrand,D);% 求得N个个体的评价函数score(generation,:)=scoreN;[scoreSort,scoreind]=sort(scoreN);sumscore=cumsum(scoreSort);sumscore=sumscore./sumscore(end);childind(1:2)=scoreind(end-1:end);for k=3:Ntmprnd=rand;tmpind=tmprnd difind=[0,diff(tmpind)];if ~any(difind)difind(1)=1;endchildind(k)=scoreind(logical(difind));endfatherrand=fatherrand(:,childind);generation=generation+1;end% scoremaxV=max(score,[],2);minV=11*300-maxV;plot(minV,'*');title('各代的目标函数值');F4=D(:,4);FF4=F4-fatherrand(:,1);FF4=max(FF4,1);D(:,5)=FF4;save DData Dfunction D=codeload youhua.mat% properties F2 and F3F1=A(:,1);F2=A(:,2);F3=A(:,3);if (max(F2)>1450)||(min(F2)<=900)error('DATA property F2 exceed it''s range (900,1450]')end% get group property F1 of data, according to F2 valueF4=zeros(size(F1));for ite=11:-1:1index=find(F2<=900+ite*50);F4(index)=ite;endD=[F1,F2,F3,F4];function ScoreN=scorefun(fatherrand,D)F3=D(:,3);F4=D(:,4);N=size(fatherrand,2);FF4=F4*ones(1,N);FF4rnd=FF4-fatherrand;FF4rnd=max(FF4rnd,1);ScoreN=ones(1,N)*300*11;% 这里有待优化for k=1:NFF4k=FF4rnd(:,k);for ite=1:11F0index=find(FF4k==ite);if ~isempty(F0index)tmpMat=F3(F0index);tmpSco=sum(tmpMat);ScoreBin(ite)=mod(tmpSco,300);endendScorek(k)=sum(ScoreBin);endScoreN=ScoreN-Scorek;%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%遗传算法程序（三）：%IAGAfunction best=gaclearMAX_gen=200; %最大迭代步数best.max_f=0; %当前最大的适应度STOP_f=14.5; %停止循环的适应度RANGE=[0 255]; %初始取值范围[0 255]SPEEDUP_INTER=5; %进入加速迭代的间隔advance_k=0; %优化的次数popus=init; %初始化for gen=1:MAX_genfitness=fit(popus,RANGE); %求适应度f=fitness.f;picked=choose(popus,fitness); %选择popus=intercross(popus,picked); %杂交popus=aberrance(popus,picked); %变异if max(f)>best.max_fadvance_k=advance_k+1;x_better(advance_k)=fitness.x;best.max_f=max(f);best.popus=popus;best.x=fitness.x;endif mod(advance_k,SPEEDUP_INTER)==0RANGE=minmax(x_better);RANGEadvance=0;endendreturn;function popus=init%初始化M=50;%种群个体数目N=30;%编码长度popus=round(rand(M,N));return;function fitness=fit(popus,RANGE)%求适应度[M,N]=size(popus);fitness=zeros(M,1);%适应度f=zeros(M,1);%函数值A=RANGE(1);B=RANGE(2);%初始取值范围[0 255]for m=1:Mx=0;for n=1:Nx=x+popus(m,n)*(2^(n-1));endx=x*((B-A)/(2^N))+A;for k=1:5f(m,1)=f(m,1)-(k*sin((k+1)*x+k));endendf_std=(f-min(f))./(max(f)-min(f));%函数值标准化fitness.f=f;fitness.f_std=f_std;fitness.x=x;return;function picked=choose(popus,fitness)%选择f=fitness.f;f_std=fitness.f_std;[M,N]=size(popus);choose_N=3; %选择choose_N对双亲picked=zeros(choose_N,2); %记录选择好的双亲p=zeros(M,1); %选择概率d_order=zeros(M,1);%把父代个体按适应度从大到小排序f_t=sort(f,'descend');%将适应度按降序排列for k=1:Mx=find(f==f_t(k));%降序排列的个体序号d_order(k)=x(1);endfor m=1:Mpopus_t(m,:)=popus(d_order(m),:);endpopus=popus_t;f=f_t;p=f_std./sum(f_std); %选择概率c_p=cumsum(p)'; %累积概率for cn=1:choose_Npicked(cn,1)=roulette(c_p); %轮盘赌picked(cn,2)=roulette(c_p); %轮盘赌popus=intercross(popus,picked(cn,:));%杂交endpopus=aberrance(popus,picked);%变异return;function popus=intercross(popus,picked) %杂交[M_p,N_p]=size(picked);[M,N]=size(popus);for cn=1:M_pp(1)=ceil(rand*N);%生成杂交位置p(2)=ceil(rand*N);p=sort(p);t=popus(picked(cn,1),p(1):p(2));popus(picked(cn,1),p(1):p(2))=popus(picked(cn,2),p(1):p(2));popus(picked(cn,2),p(1):p(2))=t;endreturn;function popus=aberrance(popus,picked) %变异P_a=0.05;%变异概率[M,N]=size(popus);[M_p,N_p]=size(picked);U=rand(1,2);for kp=1:M_pif U(2)>=P_a %如果大于变异概率，就不变异continue;endif U(1)>=0.5a=picked(kp,1);elsea=picked(kp,2);endp(1)=ceil(rand*N);%生成变异位置p(2)=ceil(rand*N);if popus(a,p(1))==1%0 1变换popus(a,p(1))=0;elsepopus(a,p(1))=1;endif popus(a,p(2))==1popus(a,p(2))=0;elsepopus(a,p(2))=1;endendreturn;function picked=roulette(c_p) %轮盘赌[M,N]=size(c_p);M=max([M N]);U=rand;if U<c_p(1)picked=1;return;endfor m=1:(M-1)if U>c_p(m) & U<c_p(m+1)picked=m+1;break;endend全方位的两点杂交、两点变异的改进的加速遗传算法（IAGA）%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%。
遗传算法用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的实现。
车间调度问题是一个经典的组合优化问题，它是指在给定一系列任务和一台机器的情况下，如何安排任务的执行顺序，以便最小化任务的完成时间或最大化任务的完成效率。
这个问题通常是NP困难问题，因此传统的优化算法往往难以找到全局最优解。
遗传算法能够解决车间调度问题，其基本思想是通过模拟生物进化的过程，不断演化和改进任务的调度顺序，以找到最优解。
具体步骤如下：1. 初始种群的生成：生成一批初始调度方案，每个方案都表示为一个染色体，一般采用随机生成的方式。
2. 个体适应度的计算：根据染色体中任务的执行顺序，计算每个调度方案的适应度值，一般使用任务完成时间作为适应度度量。
3. 选择操作：根据个体的适应度，采用选择策略选择一部分优秀个体作为父代。
4. 交叉操作：对选中的个体进行交叉操作，生成新的子代个体。
5. 变异操作：对子代个体进行变异操作，引入随机性，增加搜索空间的广度。
6. 替换操作：用新的个体替换原来的个体，形成新一代的种群。
7. 迭代过程：重复执行选择、交叉、变异和替换操作，直到达到预定的终止条件。
下面给出基于MATLAB的实现示例：matlabfunction [best_solution, best_fitness] =genetic_algorithm(num_generations, population_size) % 初始化种群population = generate_population(population_size);for generation = 1:num_generations% 计算适应度fitness = calculate_fitness(population);% 选择操作selected_population = selection(population, fitness);% 交叉操作crossed_population = crossover(selected_population);% 变异操作mutated_population = mutation(crossed_population);% 替换操作population = replace(population, selected_population, mutated_population);end% 找到最优解[~, index] = max(fitness);best_solution = population(index,:);best_fitness = fitness(index);endfunction population = generate_population(population_size) % 根据问题的具体要求，生成初始种群population = randi([1, num_tasks], [population_size, num_tasks]); endfunction fitness = calculate_fitness(population)% 根据任务执行顺序，计算每个调度方案的适应度% 这里以任务完成时间作为适应度度量fitness = zeros(size(population, 1), 1);for i = 1:size(population, 1)solution = population(i,:);% 计算任务完成时间completion_time = calculate_completion_time(solution);% 适应度为任务完成时间的倒数fitness(i) = 1 / completion_time;endendfunction selected_population = selection(population, fitness) % 根据适应度值选择父代个体% 这里采用轮盘赌选择策略selected_population = zeros(size(population));for i = 1:size(population, 1)% 计算选择概率prob = fitness / sum(fitness);% 轮盘赌选择selected_population(i,:) = population(find(rand <= cumsum(prob), 1),:);endendfunction crossed_population = crossover(selected_population) % 对选中的个体进行交叉操作% 这里采用单点交叉crossed_population = zeros(size(selected_population));for i = 1:size(selected_population, 1) / 2parent1 = selected_population(2*i-1,:);parent2 = selected_population(2*i,:);% 随机选择交叉点crossover_point = randi([1, size(parent1,2)]);% 交叉操作crossed_population(2*i-1,:) = [parent1(1:crossover_point), parent2(crossover_point+1:end)];crossed_population(2*i,:) = [parent2(1:crossover_point), parent1(crossover_point+1:end)];endendfunction mutated_population = mutation(crossed_population) % 对子代个体进行变异操作% 这里采用单点变异mutated_population = crossed_population;for i = 1:size(mutated_population, 1)individual = mutated_population(i,:);% 随机选择变异点mutation_point = randi([1, size(individual,2)]);% 变异操作mutated_population(i,mutation_point) = randi([1, num_tasks]);endendfunction new_population = replace(population, selected_population, mutated_population)% 根据选择、交叉和变异得到的个体替换原来的个体new_population = mutated_population;for i = 1:size(population, 1)if ismember(population(i,:), selected_population, 'rows')% 保留选择得到的个体continue;else% 随机选择一个父代个体进行替换index = randi([1, size(selected_population,1)]);new_population(i,:) = selected_population(index,:);endendend该示例代码实现了车间调度问题的遗传算法求解过程，具体实现了种群的初始化、适应度计算、选择、交叉、变异和替换等操作。
遗传算法MATLAB完整代码（不用工具箱）
遗传算法MATLAB完整代码（不用工具箱）遗传算法解决简单问题%主程序：用遗传算法求解y=200*exp(-0.05*x).*sin(x)在区间[-2,2]上的最大值clc;clear all;close all;global BitLengthglobal boundsbeginglobal boundsendbounds=[-2,2];precision=0.0001;boundsbegin=bounds(:,1);boundsend=bounds(:,2);%计算如果满足求解精度至少需要多长的染色体BitLength=ceil(log2((boundsend-boundsbegin)'./precision));popsize=50; %初始种群大小Generationmax=12; %最大代数pcrossover=0.90; %交配概率pmutation=0.09; %变异概率%产生初始种群population=round(rand(popsize,BitLength));%计算适应度，返回适应度Fitvalue和累计概率cumsump[Fitvalue,cumsump]=fitnessfun(population);Generation=1;while Generation<generationmax+1< p="">for j=1:2:popsize%选择操作seln=selection(population,cumsump);%交叉操作scro=crossover(population,seln,pcrossover);scnew(j,:)=scro(1,:);scnew(j+1,:)=scro(2,:);%变异操作smnew(j,:)=mutation(scnew(j,:),pmutation);smnew(j+1,:)=mutation(scnew(j+1,:),pmutation);endpopulation=scnew; %产生了新的种群%计算新种群的适应度[Fitvalue,cumsump]=fitnessfun(population);%记录当前代最好的适应度和平均适应度[fmax,nmax]=max(Fitvalue);fmean=mean(Fitvalue);ymax(Generation)=fmax;ymean(Generation)=fmean;%记录当前代的最佳染色体个体x=transform2to10(population(nmax,:));%自变量取值范围是[-2,2],需要把经过遗传运算的最佳染色体整合到[-2,2]区间xx=boundsbegin+x*(boundsend-boundsbegin)/(power((boundsend),BitLength)-1);xmax(Generation)=xx;Generation=Generation+1;endGeneration=Generation-1;Bestpopulation=xx;Besttargetfunvalue=targetfun(xx);%绘制经过遗传运算后的适应度曲线。
遗传算法MATLAB程序设计
摘自Matlab在数学建模中的应用，北航出版社，2011.44.2遗传算法MATLAB程序设计4.2.1程序设计流程及参数选取4.2.1.1遗传算法程序设计伪代码BEGINt = 0 ; %Generations NO.初始化P(t) ; %Initial Population or Chromosomes计算P(t) 的适应值;while (不满足停止准则) dobegint = t+1 ;从P(t-1)中选择P(t) ; % Selection重组P(t) ; % Crossover and Mutation计算P(t) 的适应值;endEND4.2.1.2遗传算法的参数设计原则在单纯的遗传算法当中，也并不总是收敛，即使在单峰或单调也是如此。
这是因为种群的进化能力已经基本丧失，种群早熟。
为了避免种群的早熟，参数的设计一般遵从以下原则[5]：（1）种群的规模：当群体规模太小时，很明显会出现近亲交配，产生病态基因。
而且造成有效等位基因先天缺乏，即使采用较大概率的变异算子，生成具有竞争力高阶模式的可能性仍很小，况且大概率变异算子对已有模式的破坏作用极大。
同时遗传算子存在随机误差（模式采样误差），妨碍小群体中有效模式的正确传播，使得种群进化不能按照模式定理产生所预测的期望数量；种群规模太大，结果难以收敛且浪费资源，稳健性下降。
种群规模的一个建议值为0~100。
（2）变异概率：当变异概率太小时，种群的多样性下降太快，容易导致有效基因的迅速丢失且不容易修补；当变异概率太大时，尽管种群的多样性可以得到保证，但是高阶模式被破坏的概率也随之增大。
变异概率一般取0.0001~0.2。
（3）交配概率：交配是生成新种群最重要的手段。
与变异概率类似，交配概率太大容易破坏已有的有利模式，随机性增大，容易错失最优个体；交配概率太小不能有效更新种群。
交配概率一般取0.4~0.99。
（4）进化代数：进化代数太小，算法不容易收敛，种群还没有成熟；代数太大，算法已经熟练或者种群过于早熟不可能再收敛，继续进化没有意义，只会增加时间开支和资源浪费。
遗传算法matlab程序代码
遗传算法matlab程序代码遗传算法是一种优化算法，用于在给定的搜索空间中寻找最优解。
在Matlab中，可以通过以下代码编写一个基本的遗传算法：% 初始种群大小Npop = 100;% 搜索空间维度ndim = 2;% 最大迭代次数imax = 100;% 初始化种群pop = rand(Npop, ndim);% 最小化目标函数fun = @(x) sum(x.^2);for i = 1:imax% 计算适应度函数fit = 1./fun(pop);% 选择操作[fitSort, fitIndex] = sort(fit, 'descend');pop = pop(fitIndex(1:Npop), :);% 染色体交叉操作popNew = zeros(Npop, ndim);for j = 1:Npopparent1Index = randi([1, Npop]);parent2Index = randi([1, Npop]);parent1 = pop(parent1Index, :);parent2 = pop(parent2Index, :);crossIndex = randi([1, ndim-1]);popNew(j,:) = [parent1(1:crossIndex),parent2(crossIndex+1:end)];end% 染色体突变操作for j = 1:NpopmutIndex = randi([1, ndim]);mutScale = randn();popNew(j, mutIndex) = popNew(j, mutIndex) + mutScale;end% 更新种群pop = [pop; popNew];end% 返回最优解[resultFit, resultIndex] = max(fit);result = pop(resultIndex, :);以上代码实现了一个简单的遗传算法，用于最小化目标函数x1^2 + x2^2。
遗传算法matlab函数的源程序
end
end
end
%确定下一代父代个体
%确定实际子代个体数值
chi_fact=zeros(x_num,chi_num*3);
for j=1:x_num
chi_fact(j,:)=x_range(j,1)+(x_range(j,2)-x_range(j,1))*chi(j,:);
par=chi(:,chi_ada_no(1:par_num));
end ');
par_fac_exc(:,1)=x_range(:,1)+(x_range(:,2)-x_range(:,1)).*par(:,1);%父代个体最优函数值
par_fun_exc=fun(par_fac_exc);
%输出父代样本实际值
par_fact=zeros(x_num,par_num);
for i=1:x_num
par_fact(i,:)=x_range(i,1)+(x_range(i,2)-x_range(i,1))*par(i,:);
if chi_ran(3)<0.5
chi(j,i)=chi_ran(1)*par(j,chi_sel1)+(1-chi_ran(1))*par(j,chi_sel2);
else
chi(j,i)=chi_ran(2)*par(j,chi_sel1)+(1-chi_ran(2))*par(j,chi_sel2);
%例子2：
%fun=@(x) sum(x.*x-cos(18*x))+5;
%x_range=[-1,1;-1,1;-1,1;-1,1;-1,1];
遗传算法的MATLAB实现实例
遗传算法（Genetic Algorithm）的MATLAB应用实例To use Optimization Toolbox software, you need to1 Define your objective function in the MATLAB language, as a function file or anonymous function.2 Define your constraint(s) as a separate file or anonymous function.首先建立目标函数的M文件；例1：如目标函数 min 100（ ）+ ;Function File for Objective FunctionA function file is a text file containing MATLAB commands with the extension .m. Create a new function file in any text editor, or use the built-in MATLAB Editor as follows:（1）At the command line enter:edit (想要建立的.m文件的文件名)The MATLAB Editor opens.（2） In the editor enter:function f = rosenbrock(x)f = 100*(x(2) - x(1)^2)^2 + (1 - x(1))^2;（3） Save the file by selecting File > Save.把M文件保存在MATLAB默认的工作目录中；在命令行中输入命令：cd ，就可以得到MATLAB默认的工作目录。
To check that the M-file returns the correct value, enter rosenbrock ([1 1])ans =注释：如果想建立rosenbrock.m文件，那么步骤1变为edit rosenbrock。
遗传算法在matlab中的实现
遗传算法是一种模拟自然选择与遗传机制的优化算法，它模拟了生物进化的过程，通过优化个体的基因型来达到解决问题的目的。
在工程和科学领域，遗传算法被广泛应用于求解优化问题、寻找最优解、参数优化等领域。
而MATLAB作为一款强大的科学计算软件，拥有丰富的工具箱和编程接口，为实现遗传算法提供了便利。
下面将通过以下步骤介绍如何在MATLAB中实现遗传算法：1. 引入遗传算法工具箱需要在MATLAB环境中引入遗传算法工具箱。
在MATLAB命令窗口输入"ver"，可以查看当前已安装的工具箱。
如果遗传算法工具箱未安装，可以使用MATLAB提供的工具箱管理界面进行安装。
2. 定义优化问题在实现遗传算法前，需要清楚地定义优化问题：包括问题的目标函数、约束条件等。
在MATLAB中，可以通过定义一个函数来表示目标函数，并且可以采用匿名函数的形式来灵活定义。
对于约束条件，也需要进行明确定义，以便在遗传算法中进行约束处理。
3. 设置遗传算法参数在实现遗传算法时，需要对遗传算法的参数进行设置，包括种群大小、交叉概率、变异概率、迭代次数等。
这些参数的设置将会直接影响遗传算法的收敛速度和优化效果。
在MATLAB中，可以通过设置遗传算法工具箱中的相关函数来完成参数的设置。
4. 编写遗传算法主程序编写遗传算法的主程序，主要包括对适应度函数的计算、选择、交叉、变异等操作。
在MATLAB中，可以利用遗传算法工具箱提供的相关函数来实现这些操作，简化了遗传算法的实现过程。
5. 运行遗传算法将编写好的遗传算法主程序在MATLAB环境中运行，并观察优化结果。
在运行过程中，可以对结果进行实时监测和分析，以便对遗传算法的参数进行调整和优化。
通过以上步骤，可以在MATLAB中实现遗传算法，并应用于实际的优化问题与工程应用中。
遗传算法的实现将大大提高问题的求解效率与精度，为工程领域带来更多的便利与可能性。
总结：遗传算法在MATLAB中的实现涉及到了引入遗传算法工具箱、定义优化问题、设置算法参数、编写主程序和运行算法等步骤。
遗传算法matlab代码
function youhuafunD=code;N=50; % Tunablemaxgen=50; % Tunablecrossrate=0.5; %Tunablemuterate=0.08; %Tunablegeneration=1;num = length(D);fatherrand=randint(num,N,3);score = zeros(maxgen,N);while generation<=maxgenind=randperm(N-2)+2; % 随机配对交叉A=fatherrand(:,ind(1:(N-2)/2));B=fatherrand(:,ind((N-2)/2+1:end));% 多点交叉rnd=rand(num,(N-2)/2);ind=rnd tmp=A(ind);A(ind)=B(ind);B(ind)=tmp;% % 两点交叉% for kk=1:(N-2)/2% rndtmp=randint(1,1,num)+1;% tmp=A(1:rndtmp,kk);% A(1:rndtmp,kk)=B(1:rndtmp,kk);% B(1:rndtmp,kk)=tmp;% endfatherrand=[fatherrand(:,1:2),A,B];% 变异rnd=rand(num,N);ind=rnd [m,n]=size(ind);tmp=randint(m,n,2)+1;tmp(:,1:2)=0;fatherrand=tmp+fatherrand;fatherrand=mod(fatherrand,3);% fatherrand(ind)=tmp;%评价、选择scoreN=scorefun(fatherrand,D);% 求得N个个体的评价函数score(generation,:)=scoreN;[scoreSort,scoreind]=sort(scoreN);sumscore=cumsum(scoreSort);sumscore=sumscore./sumscore(end);childind(1:2)=scoreind(end-1:end);for k=3:Ntmprnd=rand;tmpind=tmprnd difind=[0,diff(tmpind)];if ~any(difind)difind(1)=1;endchildind(k)=scoreind(logical(difind));endfatherrand=fatherrand(:,childind);generation=generation+1;end% scoremaxV=max(score,[],2);minV=11*300-maxV;plot(minV,'*');title('各代的目标函数值');F4=D(:,4);FF4=F4-fatherrand(:,1);FF4=max(FF4,1);D(:,5)=FF4;save DData Dfunction D=codeload youhua.mat% properties F2 and F3F1=A(:,1);F2=A(:,2);F3=A(:,3);if (max(F2)>1450)||(min(F2)<=900)error('DATA property F2 exceed it''s range (900,1450]') end% get group property F1 of data, according to F2 value F4=zeros(size(F1));for ite=11:-1:1index=find(F2<=900+ite*50);F4(index)=ite;endD=[F1,F2,F3,F4];function ScoreN=scorefun(fatherrand,D)F3=D(:,3);F4=D(:,4);N=size(fatherrand,2);FF4=F4*ones(1,N);FF4rnd=FF4-fatherrand;FF4rnd=max(FF4rnd,1);ScoreN=ones(1,N)*300*11;% 这里有待优化for k=1:NFF4k=FF4rnd(:,k);for ite=1:11F0index=find(FF4k==ite);if ~isempty(F0index)tmpMat=F3(F0index);tmpSco=sum(tmpMat);ScoreBin(ite)=mod(tmpSco,300);endendScorek(k)=sum(ScoreBin);endScoreN=ScoreN-Scorek;遗传算法实例:% 下面举例说明遗传算法%% 求下列函数的最大值%% f(x)=10*sin(5x)+7*cos(4x) x∈[0,10] %% 将x 的值用一个10位的二值形式表示为二值问题，一个10位的二值数提供的分辨率是每为(10-0)/(2^10-1)≈0.01 。
遗传算法matlab代码
遗传算法matlab代码以下是一个简单的遗传算法的MATLAB 代码示例：matlab复制代码% 遗传算法参数设置pop_size = 50; % 种群大小num_vars = 10; % 变量数目num_generations = 100; % 进化的代数mutation_rate = 0.01; % 变异率crossover_rate = 0.8; % 交叉率% 初始化种群population = rand(pop_size, num_vars);% 开始进化for i = 1:num_generations% 计算适应度fitness = evaluate_fitness(population);% 选择操作selected_population = selection(population, fitness);% 交叉操作offspring_population = crossover(selected_population,crossover_rate);% 变异操作mutated_population = mutation(offspring_population,mutation_rate);% 生成新种群population = [selected_population; mutated_population];end% 选择最优解best_solution = population(find(fitness == max(fitness)), :);% 适应度函数function f = evaluate_fitness(population)f = zeros(size(population));for i = 1:size(population, 1)f(i) = sum(population(i, :));endend% 选择函数function selected_population = selection(population, fitness)% 轮盘赌选择total_fitness = sum(fitness);probabilities = fitness / total_fitness;selected_indices = zeros(pop_size, 1);for i = 1:pop_sizer = rand();cumulative_probabilities = cumsum(probabilities);for j = 1:pop_sizeif r <= cumulative_probabilities(j)selected_indices(i) = j;break;endendendselected_population = population(selected_indices, :);end% 交叉函数function offspring_population = crossover(parental_population, crossover_rate)offspring_population = zeros(size(parental_population));num_crossovers = ceil(size(parental_population, 1) *crossover_rate);crossover_indices = randperm(size(parental_population, 1),num_crossovers);以下是另一个一个简单的遗传算法的MATLAB 代码示例：matlab复制代码% 初始化种群population = rand(nPopulation, nGenes);% 进化迭代for iGeneration = 1:nGeneration% 计算适应度fitness = evaluateFitness(population);% 选择父代parentIdx = selection(fitness);parent = population(parentIdx, :);% 交叉产生子代child = crossover(parent);% 变异子代child = mutation(child);% 更新种群population = [parent; child];end% 评估最优解bestFitness = -Inf;for i = 1:nPopulationf = evaluateFitness(population(i, :));if f > bestFitnessbestFitness = f;bestIndividual = population(i, :);endend% 可视化结果plotFitness(fitness);其中，nPopulation和nGenes分别是种群大小和基因数；nGeneration是迭代次数；evaluateFitness函数用于计算个体的适应度；selection函数用于选择父代；crossover函数用于交叉产生子代；mutation函数用于变异子代。
(完整版)遗传算法matlab实现源程序
附页：一．遗传算法源程序：clc; clear;population;％评价目标函数值for uim=1：popsizevector=population(uim,:）；obj(uim）=hanshu(hromlength，vector，phen);end％obj%min（obj）clear uim;objmin=min（obj）;for sequ=1：popsizeif obj(sequ）==objminopti=population（sequ,：)；endendclear sequ；fmax=22000；%==for gen=1：maxgen%选择操作%将求最小值的函数转化为适应度函数for indivi=1：popsizeobj1（indivi)=1/obj（indivi)；endclear indivi；％适应度函数累加总合total=0;for indivi=1：popsizetotal=total+obj1(indivi)；endclear indivi;%每条染色体被选中的几率for indivi=1:popsizefitness1（indivi）=obj1(indivi）/total；endclear indivi;%各条染色体被选中的范围for indivi=1：popsizefitness(indivi)=0；for j=1:indivifitness(indivi）=fitness(indivi)+fitness1(j）；endendclear j；fitness;%选择适应度高的个体for ranseti=1：popsizeran=rand；while (ran>1|｜ran<0)ran=rand;endran;if ran〈=fitness(1）newpopulation(ranseti,：)=population(1，:）;elsefor fet=2:popsizeif (ran〉fitness(fet—1))&&(ran<=fitness(fet)）newpopulation(ranseti，：)=population(fet，：)；endendendendclear ran;newpopulation；％交叉for int=1:2：popsize-1popmoth=newpopulation（int,：）；popfath=newpopulation（int+1，:）；popcross(int，:）=popmoth；popcross（int+1，：)=popfath；randnum=rand；if(randnum〈 P>cpoint1=round（rand＊hromlength）；cpoint2=round(rand*hromlength)；while （cpoint2==cpoint1）cpoint2=round（rand*hromlength);endif cpoint1>cpoint2tem=cpoint1；cpoint1=cpoint2；cpoint2=tem;endcpoint1；cpoint2;for term=cpoint1+1:cpoint2for ss=1:hromlengthif popcross(int，ss)==popfath（term）tem1=popcross（int,ss)；popcross（int，ss）=popcross(int,term);popcross(int,term）=tem1；endendclear tem1；endfor term=cpoint1+1：cpoint2for ss=1：hromlengthif popcross(int+1，ss)==popmoth（term)tem1=popcross（int+1,ss）;popcross（int+1,ss)=popcross（int+1,term）;popcross（int+1,term）=tem1;endendclear tem1；endendclear term;endclear randnum;popcross;%变异操作newpop=popcross；for int=1:popsizerandnum=rand;if randnumcpoint12=round（rand*hromlength)；cpoint22=round(rand*hromlength)；if （cpoint12==0）cpoint12=1；endif (cpoint22==0）cpoint22=1;endwhile (cpoint22==cpoint12)cpoint22=round（rand＊hromlength)；if cpoint22==0;cpoint22=1;endendtemp=newpop(int，cpoint12）；newpop(int,cpoint12)=newpop(int,cpoint22)；newpop(int,cpoint22)=temp;。
matlab遗传算法程序
% Optimizing a function using Simple Genetic Algorithm with elitist% preserved%bval=father,newbval=child,bvalxx=fatherbest,q=Nsclc;clear all;format long;%设定数据显示格式%初始化参数T=100;%仿真代数%N=80;% 群体规模N=50;nc=44;nm=15;nb=4;%较差变异个数%pm=0.05;pc=0.8;%交叉变异概率%umax=2.048;umin=-2.048;%参数取值范围xmax=10;xmin=-10;L=16;%单个参数字串长度，总编码长度2Lfather=round(rand(N,2*L));%初始种群，，取整为最近整数0或1，生成N*2L矩阵的随机数bestvalue=-inf;%最优适应度初值，负无穷大%迭代开始for k=1:T%解码，计算适应度for i=1:Ny1=0;y2=0;for j=1:1:Ly1=y1+father(i,L-j+1)*2^(j-1);endx1=(xmax-xmin)*y1/(2^L-1)+xmin;for j=1:1:Ly2=y2+father(i,2*L-j+1)*2^(j-1);endx2=(xmax-xmin)*y2/(2^L-1)+xmin;%obj(i)=100*(x1*x1-x2).^2+(1-x1).^2; %目标函数obj(i)=sin(x1)/x1*sin(x2)/x2;%obj(i)=0.9*exp(-((x1+5).^2+(x2+5).^2)/10)+0.99996*exp(-((x1-5).^2+(x2-5).^2)/20); %obj(i)=0.99996*exp(-((x1-5).^2+(x2-5).^2)/20);xx(i,:)=[x1,x2];%矩阵第i行赋值为x1，x2endfunc=obj;%目标函数转换为适应度函数p=func./sum(func);Ns=cumsum(p);%累加[fmax,indmax]=max(func);%求当代最佳个体，最大值返回给fmax，其索引给indmaxif fmax>=bestvaluebestvalue=fmax;%到目前为止最优适应度值fatherbest=father(indmax,:);%到目前为止最佳位串optimal=xx(indmax,:);%到目前为止最优参数endbestfit(k)=bestvalue; % 存储每代的最优适应度%%%%遗传操作开始% 轮盘赌选择for i=1:N-1r=rand;for j=1:Nif r<=Ns(j)child(i,:)=father(j,:);break;endendendchild(N,:)=fatherbest;%最优保留father=child;%单点交叉for i=1:2:(N-1)cc=rand;pc=nc/N;if cc<pcpoint=L/2;tmp1=father(i,:);father(i,point+1:L)=father(i+1,point+1:L);father(i+1,point+1:L)=tmp1(1,point+1:L);father(i,point+L+1:2*L)=father(i+1,point+L+1:2*L); father(i+1,point+L+1:2*L)=tmp1(1,point+L+1:2*L); endendfather(N,:)=fatherbest;%最优保留%位点变异pm=nb*nm/(2*N);tmp2=rand(N,2*L)<pm;%N行tmp2(N,:)=zeros(1,2*L);%最后一行不变异，强制赋0father(tmp2)=1-father(tmp2);end% 输出plot(bestfit,'-o');% 绘制最优适应度进化曲线xlabel('代数T');ylabel('最优值');title('nc=44 nm=15');grid on;bestvalue %输出最优适应度值optimal %输出最优参数她含着笑，切着冰屑悉索的萝卜，她含着笑，用手掏着猪吃的麦糟，她含着笑，扇着炖肉的炉子的火，她含着笑，背了团箕到广场上去晒好那些大豆和小麦，大堰河，为了生活，在她流尽了她的乳液之后，她就用抱过我的两臂，劳动了。
遗传算法matlab实现
MATLAB程序实现初始化：%初始化种群%pop_size: 种群大小%chromo_size: 染色体长度functioninitilize(pop_size, chromo_size)global pop;fori=1:pop_sizefor j=1:chromo_sizepop(i,j) = round(rand);endendcleari;clear j;计算适应度：（该函数应该根据具体问题进行修改，这里优化的函数是前述的一维函数）%计算种群个体适应度，对不同的优化目标，此处需要改写%pop_size: 种群大小%chromo_size: 染色体长度function fitness(pop_size, chromo_size)globalfitness_value;global pop;global G;fori=1:pop_sizefitness_value(i) = 0.;endfori=1:pop_sizefor j=1:chromo_sizeif pop(i,j) == 1fitness_value(i) = fitness_value(i)+2^(j-1);endendfitness_value(i) = -1+fitness_value(i)*(3.-(-1.))/(2^chromo_size-1);fitness_value(i) = -(fitness_value(i)-1).^2+4;endcleari;clear j;对个体按照适应度大小进行排序：%对个体按适应度大小进行排序，并且保存最佳个体%pop_size: 种群大小%chromo_size: 染色体长度function rank(pop_size, chromo_size)globalfitness_value;globalfitness_table;globalfitness_avg;globalbest_fitness;globalbest_individual;globalbest_generation;global pop;global G;fori=1:pop_sizefitness_table(i) = 0.;endmin = 1;temp = 1;temp1(chromo_size)=0;fori=1:pop_sizemin = i;for j = i+1:pop_sizeiffitness_value(j)<fitness_value(min);min = j;endendif min~=itemp = fitness_value(i);fitness_value(i) = fitness_value(min);fitness_value(min) = temp;for k = 1:chromo_sizetemp1(k) = pop(i,k);pop(i,k) = pop(min,k);pop(min,k) = temp1(k);endendendfori=1:pop_sizeifi==1fitness_table(i) = fitness_table(i) + fitness_value(i); elsefitness_table(i) = fitness_table(i-1) + fitness_value(i); endendfitness_tablefitness_avg(G) = fitness_table(pop_size)/pop_size;iffitness_value(pop_size) >best_fitnessbest_fitness = fitness_value(pop_size);best_generation = G;for j=1:chromo_sizebest_individual(j) = pop(pop_size,j);endendcleari;clear j;clear k;clear min;clear temp;clear temp1;选择操作：%轮盘赌选择操作%pop_size: 种群大小%chromo_size: 染色体长度%cross_rate: 是否精英选择function selection(pop_size, chromo_size, elitism) global pop;globalfitness_table;fori=1:pop_sizer = rand * fitness_table(pop_size);first = 1;last = pop_size;mid = round((last+first)/2);idx = -1;while (first <= last) && (idx == -1)if r >fitness_table(mid)first = mid;elseif r <fitness_table(mid) last = mid;elseidx = mid;break;endmid = round((last+first)/2); if (last - first) == 1idx = last;break;endendfor j=1:chromo_sizepop_new(i,j)=pop(idx,j); endendif elitismp = pop_size-1;elsep = pop_size;endfori=1:pfor j=1:chromo_sizepop(i,j) = pop_new(i,j); endendcleari;clear j;clearpop_new;clear first;clear last;clearidx;clear mid;交叉操作：%单点交叉操作%pop_size: 种群大小%chromo_size: 染色体长度%cross_rate: 交叉概率function crossover(pop_size, chromo_size, cross_rate) global pop;fori=1:2:pop_sizeif(rand <cross_rate)cross_pos = round(rand * chromo_size);if or (cross_pos == 0, cross_pos == 1)continue;endfor j=cross_pos:chromo_sizetemp = pop(i,j);pop(i,j) = pop(i+1,j);pop(i+1,j) = temp;endendendcleari;clear j;clear temp;clearcross_pos;变异操作：%单点变异操作%pop_size: 种群大小%chromo_size: 染色体长度%cross_rate: 变异概率function mutation(pop_size, chromo_size, mutate_rate) global pop;fori=1:pop_sizeif rand <mutate_ratemutate_pos = round(rand*chromo_size);ifmutate_pos == 0continue;endpop(i,mutate_pos) = 1 - pop(i, mutate_pos);endendcleari;clearmutate_pos;打印算法迭代过程：%打印算法迭代过程%generation_size: 迭代次数functionplotGA(generation_size)globalfitness_avg;x = 1:1:generation_size;y = fitness_avg;plot(x,y)算法主函数：%遗传算法主函数%pop_size: 输入种群大小%chromo_size: 输入染色体长度%generation_size: 输入迭代次数%cross_rate: 输入交叉概率%cross_rate: 输入变异概率%elitism: 输入是否精英选择%m: 输出最佳个体%n: 输出最佳适应度%p: 输出最佳个体出现代%q: 输出最佳个体自变量值function [m,n,p,q] = GeneticAlgorithm(pop_size, chromo_size, generation_size, cross_rate, mutate_rate, elitism)global G ; %当前代globalfitness_value;%当前代适应度矩阵globalbest_fitness;%历代最佳适应值globalfitness_avg;%历代平均适应值矩阵globalbest_individual;%历代最佳个体globalbest_generation;%最佳个体出现代fitness_avg = zeros(generation_size,1);disp"hhee"fitness_value(pop_size) = 0.;best_fitness = 0.;best_generation = 0;initilize(pop_size, chromo_size);%初始化for G=1:generation_sizefitness(pop_size, chromo_size); %计算适应度rank(pop_size, chromo_size); %对个体按适应度大小进行排序selection(pop_size, chromo_size, elitism);%选择操作crossover(pop_size, chromo_size, cross_rate);%交叉操作mutation(pop_size, chromo_size, mutate_rate);%变异操作endplotGA(generation_size);%打印算法迭代过程m = best_individual;%获得最佳个体n = best_fitness;%获得最佳适应度p = best_generation;%获得最佳个体出现代%获得最佳个体变量值，对不同的优化目标，此处需要改写q = 0.;for j=1:chromo_sizeifbest_individual(j) == 1q = q+2^(j-1);endendq = -1+q*(3.-(-1.))/(2^chromo_size-1);cleari;clear j;2. 案例研究对上一节中的函数进行优化，设置遗传算法相关参数，程序如下functionrun_ga()elitism = true;%选择精英操作pop_size = 20;%种群大小chromo_size = 16;%染色体大小generation_size = 200;%迭代次数cross_rate = 0.6;%交叉概率mutate_rate = 0.01;%变异概率[m,n,p,q] = GeneticAlgorithm(pop_size, chromo_size, generation_size, cross_rate, mutate_rate,elitism);disp"最优个体"mdisp"最优适应度"ndisp"最优个体对应自变量值"qdisp"得到最优结果的代数" pclear;结果如下："最优个体"m =1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 "最优适应度"n =4.0000"最优个体对应自变量值" q =1.0000"得到最优结果的代数"p =74此结果非常准确。
遗传算法matlab程序代码
function [R,Rlength]= GA_TSP(xyCity,dCity,Population,nPopulation,pCrossover,percent,pMutation,generation,nR,rr,rang eCity,rR,moffspring,record,pi,Shock,maxShock)clear allA=load('d.txt');AxyCity=[A(1,:);A(2,:)]; %x,y为各地点坐标xyCityfigure(1)grid onhold onscatter(xyCity(1,:),xyCity(2,:),'b+')grid onnCity=50;nCityfor i=1:nCity %计算城市间距离for j=1:nCitydCity(i,j)=abs(xyCity(1,i)-xyCity(1,j))+abs(xyCity(2,i)-xyCity(2,j));endend %计算城市间距离xyCity; %显示城市坐标dCity %显示城市距离矩阵%初始种群k=input('取点操作结束'); %取点时对操作保护disp('-------------------')nPopulation=input('种群个体数量：'); %输入种群个体数量if size(nPopulation,1)==0nPopulation=50; %默认值endfor i=1:nPopulationPopulation(i,:)=randperm(nCity-1); %产生随机个体endPopulation %显示初始种群pCrossover=input('交叉概率：'); %输入交叉概率percent=input('交叉部分占整体的百分比：'); %输入交叉比率pMutation=input('突变概率：'); %输入突变概率nRemain=input('最优个体保留最大数量：');pi(1)=input('选择操作最优个体被保护概率：');%输入最优个体被保护概率pi(2)=input('交叉操作最优个体被保护概率：');pi(3)=input('突变操作最优个体被保护概率：');maxShock=input('最大突变概率：');if size(pCrossover,1)==0pCrossover=0.85;endif size(percent,1)==0percent=0.5;endif size(pMutation,1)==0pMutation=0.05;endShock=0;rr=0;Rlength=0;counter1=0;counter2=0;R=zeros(1,nCity-1);[newPopulation,R,Rlength,counter2,rr]=select(Population,nPopulation,nCity,dCity,Rlength,R,coun ter2,pi,nRemain);R0=R;record(1,:)=R;rR(1)=Rlength;Rlength0=Rlength;generation=input('算法终止条件A.最多迭代次数：');%输入算法终止条件if size(generation,1)==0generation=200;endnR=input('算法终止条件B.最短路径连续保持不变代数：');if size(nR,1)==0nR=10;endwhile counter1<generation&counter2<nRif counter2<nR*1/5Shock=0;elseif counter2<nR*2/5Shock=maxShock*1/4-pMutation;elseif counter2<nR*3/5Shock=maxShock*2/4-pMutation;elseif counter2<nR*4/5Shock=maxShock*3/4-pMutation;elseShock=maxShock-pMutation;endcounter1newPopulationoffspring=crossover(newPopulation,nCity,pCrossover,percent,nPopulation,rr,pi,nRemain);offspringmoffspring=Mutation(offspring,nCity,pMutation,nPopulation,rr,pi,nRemain,Shock);[newPopulation,R,Rlength,counter2,rr]=select(moffspring,nPopulation,nCity,dCity,Rlength,R,coun ter2,pi,nRemain);counter1=counter1+1;rR(counter1+1)=Rlength;record(counter1+1,:)=R;endR0;Rlength0;R;Rlength;minR=min(rR);disp('最短路经出现代数:')rr=find(rR==minR)disp('最短路经:')record(rr,:);mR=record(rr(1,1),:)disp('终止条件一:')counter1disp('终止条件二:')counter2disp('最短路经长度:')minRdisp('最初路经长度:')rR(1)figure(2)plotaiwa(xyCity,mR,nCity)figure(3)i=1:counter1+1;plot(i,rR(i))grid onfunction[newPopulation,R,Rlength,counter2,rr]=select(Population,nPopulation,nCity,dCity,Rlength,R,coun ter2,pi,nRemain)Distance=zeros(nPopulation,1); %零化路径长度Fitness=zeros(nPopulation,1); %零化适应概率Sum=0; %路径长度for i=1:nPopulation %计算个体路径长度for j=1:nCity-2Distance(i)=Distance(i)+dCity(Population(i,j),Population(i,j+1));end %对路径长度调整，增加起始点到路径首尾点的距离Distance(i)=Distance(i)+dCity(Population(i,1),nCity)+dCity(Population(i,nCity-1),nCity);Sum=Sum+Distance(i); %累计总路径长度end %计算个体路径长度if Rlength==min(Distance)counter2=counter2+1;elsecounter2=0;endRlength=min(Distance); %更新最短路径长度Rlength;rr=find(Distance==Rlength);R=Population(rr(1,1),:); %更新最短路径for i=1:nPopulationFitness(i)=(max(Distance)-Distance(i)+0.001)/(nPopulation*(max(Distance)+0.001)-Sum); %适应概率=个体/总和。
matlab遗传算法设计
matlab遗传算法设计在MATLAB中设计遗传算法需要遵循以下步骤：1.定义问题参数：首先，你需要定义问题的参数，包括适应度函数、种群大小、交叉概率、变异概率和迭代次数等。
2.初始化种群：根据问题的参数，初始化一个种群，通常可以使用随机数生成器来生成初始解。
3.评估适应度：对于每个个体，计算其适应度值，这通常是通过将个体作为输入参数传递给适应度函数来完成的。
4.选择操作：根据适应度值，选择出适应度较高的个体，用于下一代种群的生成。
5.交叉操作：随机选择两个个体进行交叉操作，生成新的个体。
6.变异操作：对新的个体进行变异操作，以增加种群的多样性。
7.迭代更新：重复上述步骤，直到达到预设的迭代次数或满足终止条件。
8.输出结果：输出最终的种群中最优的个体作为问题的解。
下面是一个简单的MATLAB遗传算法示例代码：matlab复制代码% 遗传算法参数设置popSize = 100; % 种群大小crossoverRate = 0.8; % 交叉概率mutationRate = 0.01; % 变异概率maxGeneration = 100; % 最大迭代次数% 初始化种群pop = round(rand(popSize,1)); % 生成初始种群% 适应度函数（这里假设我们要最小化的目标函数是 x^2）fitnessFunction = @(x) x.^2;% 迭代更新种群for generation = 1:maxGeneration% 评估适应度fitness = fitnessFunction(pop);% 选择操作[newPop,~] = rouletteWheelSelection(pop,fitness);% 交叉操作newPop = crossover(newPop, crossoverRate);% 变异操作newPop = mutation(newPop, mutationRate);% 更新种群pop = newPop;end% 输出最优解[~, bestIndex] = min(fitness);bestSolution = pop(bestIndex);fprintf('最优解：%d\n', bestSolution);在这个示例中，我们使用了轮盘赌选择、均匀交叉和均匀变异等遗传算法的操作。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
matlab遗传算法程序共13个.m文件。
1、B2F.mfunction [B,len,v]=B2F(sol,bounds)%[B,len]=B2F(x,bounds) 二进制编码函数%x 编码向量如x=[6 8 9];%bounds 边界约束ru如bounds=[4 8 ;3 11;6 12;]; %B 二进制编码串%编码长度L由bounds(2)-bounds(1)决定%以上为例:% 编码长度向量L=[4 8 6]编成二进制L=[11 1000 110],则len=[2 4 3] % 计算B=x-bound(1)=[2 5 3]编成二进制B=[10 0101 011]n=length(sol);len=[];B=[];v=[];L=bounds(:,2)-bounds(:,1);L=de2bi(L);for i=1:nlen(i)=length(L(i,:));endv=sol-bounds(:,1)';for i=1:nB=[B de2bi(v(i),len(i))];end2、changes.mfunction [pops]=changes(cpop,bounds,len,p)%基因突变函数%function [pops]=changes(pop,bounds,len,p)%pop 种群数目%bounds 边界约束%len 每个变量的编码长度% 如len为[4 3 3];表示有三个变量，第一个变量的二进制编码长度为4,依次类推%p 突变概率%pops 返回突变后的基因%p1 基因突变数目if isempty(p)p=0.01;end[n,m]=size(cpop);pop=cpop;p1=round(sum(len)*n*p);k=0;q=[];v=[];while(k<p1)k=k+1;q(k)=round(rand*(sum(len)*n-1))+1;for i=1:k-1if q(k)==q(i)q(k)=[];k=k-1;endendendfor i=1:n[B(i,:),len]=B2F(pop(i,:),bounds);endv=reshape(B,1,n*sum(len));for i=1:p1if v(q(i))==0v(q(i))=1;elsev(q(i))=0;endendv=reshape(v,n,sum(len));for i=1:npop(i,:)=F2B(v(i,:),bounds,len);endpops=popcpop3、cross.mfunction [cpop ,len,v]=cross(child,bounds,CP)%交叉函数，采取点交叉%[newpop ,len]=cross(child,bounds,CP)%child 复制后的种群%bounds 边界约束%CP 交叉概率%newpop 交叉后的新种群%len 每个变量的编码长度% 如len返回为[4 3 3];表示有三个变量，第一个变量的二进制编码长度为4,依次类推if isempty(CP)CP=0.25;end[n ,m]=size(child);B=[];len=[];t=[];mychild=child(:,1:end-1);v=[];p=rand(1,n);k=1;for i=1:nif p(i)<CPv(k)=i;k=k+1;endendif (rem(k,2)==0)temp=v(k-1);while (temp==v(k-1))temp=round(rand*(n-1))+1;endv(k)=temp;k=k+1;endif isempty(v)[B(i,:),len]=B2F(mychild(1,:),bounds);B=[];elsefor i=1:k-1[B(i,:),len]=B2F(mychild(v(i),:),bounds);endfor i=1:2:k-2p2=round(rand*sum(len)-1)+1;t=zeros(1,p2);t(i,:)=B(i,1:p2);B(i,1:p2)=B(i+1,1:p2);B(i+1,1:p2)=t(i,:);endfor i=1:k-1mychild(v(i),:)=F2B(B(i,:),bounds,len);endendcpop=mychild;4、de2bi.mfunction b = de2bi(d, n, p)%function b = de2bi(d, n, p)%DE2BI 转换10进制数为二进制数。
% B = DE2BI(D) 转换正整数向量D成二进制矩阵B。
% 二进制矩阵B的每一行表示十进制向量D中相应的数。
% B = DE2BI(D, N) 转换正整数向量D成二进制矩阵B，% 但指定B的列数为N。
% B = DE2BI(D, N, P) 转换正整数向量D成p进制矩阵B。
% p进制矩阵B的每一行表示十进制向量D中相应的数。
d = d(:);len_d = length(d);if min(d) < 0, error('Cannot convert a negative number');elseif ~isempty(find(d==inf)),error('Input must not be Inf.');elseif find(d ~= floor(d)),error('Input must be an integer.');end;if nargin < 2,tmp = max(d); b1 = [];while tmp > 0b1 = [b1 rem(tmp, 2)];tmp = floor(tmp/2);end;n = length(b1);end;if nargin < 3,p = 2;end;b = zeros(len_d, n);for i = 1 : len_dj = 1;tmp = d(i);while (j <= n) & (tmp > 0)b(i, j) = rem(tmp, p);tmp = floor(tmp/p);j = j + 1;end;end;5、F2B.mfunction [pops,len]=F2B(x,bounds,len)%二进制编码转化为十进制%[pops]=F2B(x,bounds,len)%x 二进制串如x=[0 1 1 0 0 1 0 1 0 1 0 1] %len 二进制串的分段len=[3 4 5]%bounds 边界约束%pops 十进制n=length(x);m=length(len);q=[];for i=1:mq(i)=sum(len(1:i));endq=[0 q];for j=1:mpops(j)=bounds(j,1);p=[];p=x(q(j)+1:q(j+1));L1=q(j+1)-q(j);for k=1:L1pops(j)=pops(j)+p(k)*2^(k-1);endend6、f553.mfunction [sol,eval]=f553(sol,options)m(1)=sol(1);m(2)=sol(2);m(3)=sol(3);%失效概率矩阵q=[0.01 0.05 0.10 0.18;0.08 0.02 0.15 0.12;0.04 0.05 0.20 0.10];%约束条件g1=51-(m(1)+3).^2+m(2).^2+m(3).^2;g2=20*sum(m+exp(-m))-120;g3=20*sum(m.*exp(-m/4))-65;%计算加惩罚项的适值if ((g1>=0)&(g2>=0)&(g3>=0))multi=1;for i=1:3summ=0;for j=2:4summ=summ+q(i,j).^(m(i)+1);endmulti=multi*(1-(1-(1-q(i,1)).^(m(i)+1))-summ); endeval=multi;else%取M=500eval=-500;end7、ga.mfunction [f,x]=myga(num,bounds,Myfun,N,CP,P)%[f,x]=ga(num,bounds,fun,N,CP,P)%该遗传算法适用于：% 目标函数为求最大值，且解非负整数解%bounds 边界约束%Myfun 为目标函数%num 初始种群数%N 最大迭代次数%CP 交叉概率%P 突变概率%f 目标最优解%x 最优解向量m=nargin;if m<6disp('-_- 错误!')disp('>> 输入变量太少')disp('>> 按回车键查看帮助')pausehelp gaf='-_- ';x='没有规矩不成方圆';break;endpop=INTinti(num,bounds);fmax=pop(:,end);endpop=pop;n=size(endpop,2);k=0;x=[];f=zeros(1,num);while(k<N)pop=mutation(endpop);[cpop ,len,v]=cross(pop,bounds,CP);[pops]=changes(cpop,bounds,len,P);break;for i=1:numsol=pops(i,:);[f(i)]=Myfun(sol);if fmax(i)<f(i)fmax(i)=f(i);endpop(i,1:end-1)=pops(i,:);endendendpop(:,end)=fmax(:);k=k+1;end[f,ii]=max(fmax);x=endpop(ii,1:end-1);8、gaDemo1Eeval.mfunction [sol, eval] =gaDemo1Eeval(sol,options) x=sol(1);eval = x + 10*sin(5*x)+7*cos(4*x);%参数说明%eval：个体的适应度；%sol：当前个体，n+1个元素的行向量。
9、INTinti.mfunction [pop]=INTinti(num,bounds)%[pop]=INTinti(num,bounds)%inti 编码函数%num 种群数%bounds 边界约束n=size(bounds,1);L=bounds(:,2)-bounds(:,1);p=rand(num,n);for i=1:nump(i,:)=round(p(i,:).*L');pop(i,:)= p(i,:)+bounds(:,1)';f(i)=myfun(pop(i,:));endpop=[pop f'];10、mutation.mfunction [child]=mutation(pop)%复制函数，采取小盘轮转法%[child]=mutation(pop)%mutation 编码%pop 初始种群%child 返回复制后的种群%pop(:,end) 适值度[n,m]=size(pop);f=pop(:,end);value=sum(f);for i=1:np(i)=f(i)/value;q(i)=sum(p(1:i));endt=rand(1,n);for j=1:nfor k=1:nif t(j)<q(k)v(j)=k;breakendendendi=1:n;child(i,:)=pop(v(i),:);11、myfun.mfunction [f]=myfun(sol,bnd)x=sol;n=length(x);f=0;for i=1:nf=f+x(i)*i;end12、myga.mfunction [f,x]=myga(num,bounds,N,CP,P)%[f,x]=ga(num,bounds,fun,N,CP,P)%[f,x]=myga([],bounds,[],[],[])%该遗传算法适用于：% 目标函数为求最大值，且解非负整数解%bounds 边界约束%Myfun 为目标函数%num 初始种群数%N 最大迭代次数%CP 交叉概率%P 突变概率%f 目标最优解%x 最优解向量m=nargin;if m<5disp('-_- 错误!')disp('>> 输入变量太少')disp('>> 按回车键查看帮助')pausehelp gaf='-_- ';x='没有规矩不成方圆';break;endif isempty(CP)CP=0.25;endif isempty(P)P=0.01;endif isempty(N)N=1000;endif any(bounds(:,1))<0disp('-_- 错误!')disp('>> 按回车键查看帮助')pausehelp gaf='-_- ';x='没有规矩不成方圆';break;endif isempty(num)num=100;endpop=INTinti(num,bounds);fmax=pop(:,end);endpop=pop;n=size(endpop,2);count=0;x=[];f=zeros(1,num);while(count<N)pop=mutation(endpop);[cpop ,len,v]=cross(pop,bounds,CP);[pops]=changes(cpop,bounds,len,P);for i=1:numsol=pops(i,:);[f(i)]=Myfun(sol);%惩罚策略for jj=1:length(sol)if sol(jj)<bounds(jj,1)f(i)=-inf;endif sol(jj)>bounds(jj,2)f(i)=-inf;endendif fmax(i)<f(i)fmax(i)=f(i);endpop(i,1:end-1)=pops(i,:);endendendpop(:,end)=fmax(:);count=count+1;% [f,ii]=max(fmax);% x=endpop(ii,1:end-1);end[f,ii]=max(fmax);x=endpop(ii,1:end-1);13、xcross.mfunction [newpop ,len]=xcross(child,bounds,CP) mychild=child(:,1:end-1);[B(1,:),len]=B2F(mychild(1,:),bounds);newpop=B(1,:);。