当前位置：文档库 › 遗传算法Matlab源代码

遗传算法Matlab源代码

function [X,MaxFval,BestPop,Trace]=fga(FUN,bounds,MaxEranum,PopSize,options,pCross,pMutation,pInversion)

% [X,MaxFval,BestPop,Trace]=fga(FUN,bounds,MaxEranum,PopSize,options,pCross,pMutation,pInversion)

% Finds a maximum of a function of several variables.

% fga solves problems of the form:

% max F(X) subject to: LB <= X <= UB (LB=bounds(:,1),UB=bounds(:,2))

% X - 最优个体对应自变量值

% MaxFval - 最优个体对应函数值

% BestPop - 最优的群体即为最优的染色体群

% Trace - 每代最佳个体所对应的目标函数值

% FUN - 目标函数

% bounds - 自变量范围

% MaxEranum - 种群的代数,取50--500(默认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<2, error('FMAXGA requires at least three input arguments'); end

if nargin==2, MaxEranum=150;PopSize=100;options=[1 1e-4];pCross=0.85;pMutation=0.1;pInversion=0.25;end

if nargin==3, PopSize=100;options=[1 1e-4];pCross=0.85;pMutation=0.1;pInversion=0.25;end

if nargin==4, options=[1 1e-4];pCross=0.85;pMutation=0.1;pInversion=0.25;end

if nargin==5, pCross=0.85;pMutation=0.1;pInversion=0.25;end

if nargin==6, pMutation=0.1;pInversion=0.25;end

if nargin==7, pInversion=0.25;end

if (options(1)==0|options(1)==1)&find((bounds(:,1)-bounds(:,2))>0)

error('数据输入错误,请重新输入:');

end

% 定义全局变量

global m n NewPop children1 children2 VarNum

% 初始化种群和变量

precision = options(2);

bits = ceil(log2((bounds(:,2)-bounds(:,1))' ./ precision));%由设定精度划分区间

VarNum = size(bounds,1);

[Pop] = InitPop(PopSize,bounds,bits,options);%初始化种群

[m,n] = size(Pop);

fit = zeros(1,m);

NewPop = zeros(m,n);

children1 = zeros(1,n);

children2 = zeros(1,n);

pm0 = pMutation;

BestPop = zeros(MaxEranum,n);%分配初始解空间BestPop,Trace

Trace = zeros(1,MaxEranum);

Lb = ones(PopSize,1)*bounds(:,1)';

Ub = ones(PopSize,1)*bounds(:,2)';

%二进制编码采用多点交叉和均匀交叉，并逐步增大均匀交叉概率

%浮点编码采用离散交叉（前期）、算术交叉（中期）、AEA重组（后期）

OptsCrossOver = [ones(1,MaxEranum)*options(1);...

round(unidrnd(2*(MaxEranum-[1:MaxEranum]))/MaxEranum)]';

%浮点编码时采用两种自适应变异和一种随机变异（自适应变异发生概率为随机变异发生的2倍）

OptsMutation = [ones(1,MaxEranum)*options(1);unidrnd(5,1,MaxEranum)]';

if options(1)==3

D=zeros(n);

CityPosition=bounds;

D = sqrt((CityPosition(:, ones(1,n)) - CityPosition(:, ones(1,n))').^2 +...

(CityPosition(:,2*ones(1,n)) - CityPosition(:,2*ones(1,n))').^2 );

end

%==========================================================================

% 进化主程序%

%==========================================================================

eranum = 1;

H=waitbar(0,'Please wait...');

while(eranum<=MaxEranum)

for j=1:m

if options(1)==1

%eval(['[fit(j)]=' FUN '(Pop(j,:));']);%但执行字符串速度比直接计算函数值慢

fit(j)=feval(FUN,Pop(j,:));%计算适应度

elseif options(1)==0

%eval(['[fit(j)]=' FUN '(b2f(Pop(j,:),bounds,bits));']);

fit(j)=feval(FUN,(b2f(Pop(j,:),bounds,bits)));

else

fit(j)=-feval(FUN,Pop(j,:),D);

end

[Maxfit,fitIn]=max(fit);%得到每一代最大适应值

Meanfit(eranum)=mean(fit);

BestPop(eranum,:)=Pop(fitIn,:);

Trace(eranum)=Maxfit;

if options(1)==1

Pop=(Pop-Lb)./(Ub-Lb);%将定义域映射到[0,1]：[Lb,Ub]-->[0,1] ,Pop-->(Pop-Lb)./(Ub-Lb) end

switch round(unifrnd(0,eranum/MaxEranum))%进化前期尽量使用实行锦标赛选择，后期逐步增大非线性排名选择case {0}

[selectpop]=TournamentSelect(Pop,fit,bits);%锦标赛选择

case {1}

[selectpop]=NonlinearRankSelect(Pop,fit,bits);%非线性排名选择

end

[CrossOverPop]=CrossOver(selectpop,pCross,OptsCrossOver(eranum,:));%交叉

[MutationPop]=Mutation(CrossOverPop,fit,pMutation,VarNum,OptsMutation(eranum,:)); %变异[InversionPop]=Inversion(MutationPop,pInversion);%倒位

%更新种群

if options(1)==1

Pop=Lb+InversionPop.*(Ub-Lb);%还原Pop

else

Pop=InversionPop;

end

pMutation=pm0+(eranum^3)*(pCross/2-pm0)/(eranum^4); %逐步增大变异率至1/2交叉率percent=num2str(round(100*eranum/MaxEranum));

waitbar(eranum/MaxEranum,H,['Evolution complete ',percent,'%']);

eranum=eranum+1;

end

close(H);

% 格式化输出进化结果和解的变化情况

t=1:MaxEranum;

plot(t,Trace,t,Meanfit);

legend('解的变化','种群的变化');

title('函数优化的遗传算法');

xlabel('进化世代数');

ylabel('每一代最优适应度');

[MaxFval,MaxFvalIn]=max(Trace);

if options(1)==1|options(1)==3

X=BestPop(MaxFvalIn,:);

elseif options(1)==0

X=b2f(BestPop(MaxFvalIn,:),bounds,bits);

end

hold on;

plot(MaxFvalIn,MaxFval,'*');

text(MaxFvalIn+5,MaxFval,['FMAX=' num2str(MaxFval)]);

str1=sprintf(' Best generation:\n %d\n\n Best X:\n %s\n\n MaxFval\n %f\n',...

MaxFvalIn,num2str(X),MaxFval);

disp(str1);

% -计时

T2=clock;

elapsed_time=T2-T1;

if elapsed_time(6)<0

elapsed_time(6)=elapsed_time(6)+60; elapsed_time(5)=elapsed_time(5)-1;

end

if elapsed_time(5)<0

elapsed_time(5)=elapsed_time(5)+60;elapsed_time(4)=elapsed_time(4)-1;

end

str2=sprintf('elapsed_time\n %d (h) %d (m) %.4f (s)',elapsed_time(4),elapsed_time(5),elapsed_time(6)); disp(str2);

%========================================================================== % 遗传操作子程序%

%==========================================================================

% -- 初始化种群--

% 采用浮点编码和二进制Gray编码(为了克服二进制编码的Hamming悬崖缺点)

function [initpop]=InitPop(popsize,bounds,bits,options)

numVars=size(bounds,1);%变量数目

rang=(bounds(:,2)-bounds(:,1))';%变量范围

if options(1)==1

initpop=zeros(popsize,numVars);

initpop=(ones(popsize,1)*rang).*(rand(popsize,numVars))+(ones(popsize,1)*bounds(:,1)');

elseif options(1)==0

precision=options(2);%由求解精度确定二进制编码长度

len=sum(bits);

initpop=zeros(popsize,len);%The whole zero encoding individual

for i=2:popsize-1

pop=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);

end

initpop(popsize,:)=ones(1,len);%The whole one encoding individual

else

for i=1:popsize

initpop(i,:)=randperm(numVars);%为Tsp问题初始化种群

end

% -- 二进制串解码--

function [fval] = b2f(bval,bounds,bits)

% fval - 表征各变量的十进制数

% bval - 表征各变量的二进制编码串

% bounds - 各变量的取值范围

% bits - 各变量的二进制编码长度

scale=(bounds(:,2)-bounds(:,1))'./(2.^bits-1); %The range of the variables

numV=size(bounds,1);

cs=[0 cumsum(bits)];

for i=1:numV

a=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))=1

function [NewPop]=NonlinearRankSelect(OldPop,fit,bits)

global m n NewPop

fit=fit';

selectprob=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=[0 cumsum(newfit)];%计算各选择概率之和

rNums=rand(m,1);

newIn=1;

while(newIn<=m)

NewPop(newIn,:)=OldPop(length(find(rNums(newIn)>newfit)),:);

newIn=newIn+1;

end

% -- 锦标赛选择(含精英选择) --

function [NewPop]=TournamentSelect(OldPop,fit,bits)

global m n NewPop

num=floor(m./2.^(1:10));

num(find(num==0))=[];

L=length(num);

a=sum(num);

b=m-a;

PopIn=1;

while(PopIn<=L)

r=unidrnd(m,num(PopIn),2^PopIn);

[LocalMaxfit,In]=max(fit(r),[],2);

SelectIn=r((In-1)*num(PopIn)+[1:num(PopIn)]');

NewPop(sum(num(1:PopIn))-num(PopIn)+1:sum(num(1:PopIn)),:)=OldPop(SelectIn,:);

PopIn=PopIn+1;

r=[];In=[];LocalMaxfit=[];

end

if b>1

NewPop((sum(num)+1):(sum(num)+b-1),:)=OldPop(unidrnd(m,1,b-1),:);

end

[GlobalMaxfit,I]=max(fit);%保留每一代中最佳个体

NewPop(end,:)=OldPop(I,:);

% -- 交叉操作--

function [NewPop]=CrossOver(OldPop,pCross,opts)

global m n NewPop

r=rand(1,m);

y1=find(r

y2=find(r>=pCross);

len=length(y1);

if len==1|(len>2&mod(len,2)==1)%如果用来进行交叉的染色体的条数为奇数，将其调整为偶数y2(length(y2)+1)=y1(len);

y1(len)=[];

end

i=0;

if length(y1)>=2

if opts(1)==1%浮点编码交叉

while(i<=length(y1)-2)

NewPop(y1(i+1),:)=OldPop(y1(i+1),:);

NewPop(y1(i+2),:)=OldPop(y1(i+2),:);

if opts(2)==0&n>1%discret crossover

Points=sort(unidrnd(n,1,2));

NewPop(y1(i+1),Points(1):Points(2))=OldPop(y1(i+2),Points(1):Points(2));

NewPop(y1(i+2),Points(1):Points(2))=OldPop(y1(i+1),Points(1):Points(2));

elseif opts(2)==1%arithmetical crossover

Points=round(unifrnd(0,pCross,1,n));

CrossPoints=find(Points==1);

r=rand(1,length(CrossPoints));

NewPop(y1(i+1),CrossPoints)=r.*OldPop(y1(i+1),CrossPoints)+(1-r).*OldPop(y1(i+2),CrossPoints);

NewPop(y1(i+2),CrossPoints)=r.*OldPop(y1(i+2),CrossPoints)+(1-r).*OldPop(y1(i+1),CrossPoints);

else %AEA recombination

Points=round(unifrnd(0,pCross,1,n));

CrossPoints=find(Points==1);

v=unidrnd(4,1,2);

NewPop(y1(i+1),CrossPoints)=(floor(10^v(1)*OldPop(y1(i+1),CrossPoints))+...

10^v(1)*OldPop(y1(i+2),CrossPoints)-floor(10^v(1)*OldPop(y1(i+2),CrossPoints)))/10^v(1);

NewPop(y1(i+2),CrossPoints)=(floor(10^v(2)*OldPop(y1(i+2),CrossPoints))+...

10^v(2)*OldPop(y1(i+1),CrossPoints)-floor(10^v(2)*OldPop(y1(i+1),CrossPoints)))/10^v(2);

end

i=i+2;

end

elseif opts(1)==0%二进制编码交叉

while(i<=length(y1)-2)

if opts(2)==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),:));

end

i=i+2;

end

else %Tsp问题次序杂交

for i=0:2:length(y1)-2

xPoints=sort(unidrnd(n,1,2));

NewPop([y1(i+1) y1(i+2)],xPoints(1):xPoints(2))=OldPop([y1(i+2) y1(i+1)],xPoints(1):xPoints(2));

%NewPop(y1(i+2),xPoints(1):xPoints(2))=OldPop(y1(i+1),xPoints(1):xPoints(2));

temp=[OldPop(y1(i+1),xPoints(2)+1:n) OldPop(y1(i+1),1:xPoints(2))];

for del1i=xPoints(1):xPoints(2)

temp(find(temp==OldPop(y1(i+2),del1i)))=[];

end

NewPop(y1(i+1),(xPoints(2)+1):n)=temp(1:(n-xPoints(2)));

NewPop(y1(i+1),1:(xPoints(1)-1))=temp((n-xPoints(2)+1):end);

temp=[OldPop(y1(i+2),xPoints(2)+1:n) OldPop(y1(i+2),1:xPoints(2))];

for del2i=xPoints(1):xPoints(2)

temp(find(temp==OldPop(y1(i+1),del2i)))=[];

end

NewPop(y1(i+2),(xPoints(2)+1):n)=temp(1:(n-xPoints(2)));

NewPop(y1(i+2),1:(xPoints(1)-1))=temp((n-xPoints(2)+1):end);

end

NewPop(y2,:)=OldPop(y2,:);

% -二进制串均匀交叉算子

function [children1,children2]=EqualCrossOver(parent1,parent2)

global n children1 children2

hidecode=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 VarNum

Children1=Parent1;

Children2=Parent2;

Points=sort(unidrnd(n,1,2*VarNum));

for i=1:VarNum

Children1(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,fit,pMutation,VarNum,opts)

global m n NewPop

NewPop=OldPop;

r=rand(1,m);

MutIn=find(r<=pMutation);

L=length(MutIn);

i=1;

if opts(1)==1%浮点变异

maxfit=max(fit);

upfit=maxfit+0.05*abs(maxfit);

if opts(2)==1|opts(2)==3

while(i<=L)%自适应变异（自增或自减）

Point=unidrnd(n);

T=(1-fit(MutIn(i))/upfit)^2;

q=abs(1-rand^T);

%if q>1%按严格数学推理来说，这段程序是不能缺少的

% q=1

%end

p=OldPop(MutIn(i),Point)*(1-q);

if unidrnd(2)==1

NewPop(MutIn(i),Point)=p+q;

else

NewPop(MutIn(i),Point)=p;

end

i=i+1;

end

elseif opts(2)==2|opts(2)==4%AEA变异（任意变量的某一位变异）

while(i<=L)

Point=unidrnd(n);

T=(1-abs(upfit-fit(MutIn(i)))/upfit)^2;

v=1+unidrnd(1+ceil(10*T));

%v=1+unidrnd(5+ceil(10*eranum/MaxEranum));

q=mod(floor(OldPop(MutIn(i),Point)*10^v),10);

NewPop(MutIn(i),Point)=OldPop(MutIn(i),Point)-(q-unidrnd(9))/10^v;

i=i+1;

end

else

while(i<=L)

Point=unidrnd(n);

if round(rand)

NewPop(MutIn(i),Point)=OldPop(MutIn(i),Point)*(1-rand);

else

NewPop(MutIn(i),Point)=OldPop(MutIn(i),Point)+(1-OldPop(MutIn(i),Point))*rand;

end

i=i+1;

end

elseif opts(1)==0%二进制串变异

if L>=1

while i<=L

k=unidrnd(n,1,VarNum); %设置变异点数(=变量数)

for j=1:length(k)

if NewPop(MutIn(i),k(j))==1

NewPop(MutIn(i),k(j))=0;

else

NewPop(MutIn(i),k(j))=1;

end

i=i+1;

end

else%Tsp变异

if opts(2)==1|opts(2)==2|opts(2)==3|opts(2)==4

numMut=ceil(pMutation*m);

r=unidrnd(m,numMut,2);

[LocalMinfit,In]=min(fit(r),[],2);

SelectIn=r((In-1)*numMut+[1:numMut]');

while(i<=numMut)

mPoints=sort(unidrnd(n,1,2));

if mPoints(1)~=mPoints(2)

NewPop(SelectIn(i),1:mPoints(1)-1)=OldPop(SelectIn(i),1:mPoints(1)-1);

NewPop(SelectIn(i),mPoints(1):mPoints(2)-1)=OldPop(SelectIn(i),mPoints(1)+1:mPoints(2));

NewPop(SelectIn(i),mPoints(2))=OldPop(SelectIn(i),mPoints(1));

NewPop(SelectIn(i),mPoints(2)+1:n)=OldPop(SelectIn(i),mPoints(2)+1:n);

else

NewPop(SelectIn(i),:)=OldPop(SelectIn(i),:);

end

i=i+1;

end

else

r=rand(1,m);

MutIn=find(r<=pMutation);

L=length(MutIn);

while i<=L

mPoints=sort(unidrnd(n,1,2));

rIn=randperm(mPoints(2)-mPoints(1)+1);

NewPop(MutIn(i),mPoints(1):mPoints(2))=OldPop(MutIn(i),mPoints(1)+rIn-1);

i=i+1;

end

% -- 倒位操作--

function [NewPop]=Inversion(OldPop,pInversion)

global m n NewPop

NewPop=OldPop;

r=rand(1,m);

PopIn=find(r<=pInversion);

len=length(PopIn);

i=1;

if len>=1

while(i<=len)

d=sort(unidrnd(n,1,2));

NewPop(PopIn(i),d(1):d(2))=OldPop(PopIn(i),d(2):-1:d(1));

i=i+1;

end

遗传算法经典MATLAB代码

遗传算法实例: 也是自己找来的，原代码有少许错误，本人都已更正了，调试运行都通过了的。对于初学者，尤其是还没有编程经验的非常有用的一个文件遗传算法实例 % 下面举例说明遗传算法% % 求下列函数的最大值% % f(x)=10*sin(5x)+7*cos(4x) x∈[0,10]% % 将x 的值用一个10位的二值形式表示为二值问题，一个10位的二值数提供的分辨率是每为(10-0)/(2^10-1)≈。% % 将变量域[0,10] 离散化为二值域[0,1023], x=0+10*b/1023, 其中 b 是[0,1023] 中的一个二值数。% % % %--------------------------------------------------------------------------------------------------------------% %--------------------------------------------------------------------------------------------------------------% % 编程

%----------------------------------------------- % 初始化(编码) % 函数的功能是实现群体的初始化，popsize表示群体的大小，chromlength 表示染色体的长度(二值数的长度)， % 长度大小取决于变量的二进制编码的长度(在本例中取10位)。 %遗传算法子程序 %Name: %初始化 function pop=initpop(popsize,chromlength) pop=round(rand(popsize,chromlength)); % rand随机产生每个单元为{0,1} 行数为popsize，列数为chromlength的矩阵， % roud对矩阵的每个单元进行圆整。这样产生的初始种群。 % 计算目标函数值 % 将二进制数转化为十进制数(1) %遗传算法子程序 %Name: %产生[2^n 2^(n-1) ... 1] 的行向量，然后求和，将二进制转化为十进制

遗传算法MATLAB完整代码(不用工具箱)

遗传算法解决简单问题 %主程序：用遗传算法求解y=200*exp(-0.05*x).*sin(x)在区间[-2,2]上的最大值clc; clear all; close all; global BitLength global boundsbegin global boundsend bounds=[-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

MATLAB课程遗传算法实验报告及源代码

硕士生考查课程考试试卷考试科目：考生姓名：考生学号：学院：专业：考生成绩：任课老师(签名) 考试日期：年月日午时至时

《MATLAB 教程》试题： A 、利用MATLA B 设计遗传算法程序，寻找下图11个端点最短路径，其中没有连接端点表示没有路径。要求设计遗传算法对该问题求解。 a e h k B 、设计遗传算法求解f (x)极小值，具体表达式如下： 321231(,,)5.12 5.12,1,2,3i i i f x x x x x i =?=???-≤≤=? ∑ 要求必须使用m 函数方式设计程序。 C 、利用MATLAB 编程实现：三名商人各带一个随从乘船渡河，一只小船只能容纳二人，由他们自己划行，随从们密约，在河的任一岸，一旦随从的人数比商人多，就杀人越货，但是如何乘船渡河的大权掌握在商人手中，商人们怎样才能安全渡河？ D 、结合自己的研究方向选择合适的问题，利用MATLAB 进行实验。以上四题任选一题进行实验，并写出实验报告。

选择题目： B 、设计遗传算法求解f (x)极小值，具体表达式如下： 321231(,,)5.12 5.12,1,2,3i i i f x x x x x i =?=???-≤≤=? ∑ 要求必须使用m 函数方式设计程序。一、问题分析（10分）这是一个简单的三元函数求最小值的函数优化问题，可以利用遗传算法来指导性搜索最小值。实验要求必须以matlab 为工具，利用遗传算法对问题进行求解。在本实验中，要求我们用M 函数自行设计遗传算法，通过遗传算法基本原理，选择、交叉、变异等操作进行指导性邻域搜索，得到最优解。二、实验原理与数学模型（20分）（1）试验原理：用遗传算法求解函数优化问题，遗传算法是模拟生物在自然环境下的遗传和进化过程而形成的一种自适应全局优化概率搜索方法。其采纳了自然进化模型，从代表问题可能潜在解集的一个种群开始，种群由经过基因编码的一定数目的个体组成。每个个体实际上是染色体带有特征的实体；初始种群产生后，按照适者生存和优胜劣汰的原理，逐代演化产生出越来越好的解：在每一代，概据问题域中个体的适应度大小挑选个体；并借助遗传算子进行组合交叉和主客观变异，产生出代表新的解集的种群。这一过程循环执行，直到满足优化准则为止。最后，末代个体经解码，生成近似最优解。基于种群进化机制的遗传算法如同自然界进化一样，后生代种群比前生代更加适应于环境，通过逐代进化，逼近最优解。遗传算法是一种现代智能算法，实际上它的功能十分强大，能够用于求解一些难以用常规数学手段进行求解的问题，尤其适用于求解多目标、多约束，且目标函数形式非常复杂的优化问题。但是遗传算法也有一些缺点，最为关键的一点，即没有任何理论能够证明遗传算法一定能够找到最优解，算法主要是根据概率论的思想来寻找最优解。因此，遗传算法所得到的解只是一个近似解，而不一定是最优解。（2）数学模型对于求解该问题遗传算法的构造过程：（1）确定决策变量和约束条件；

遗传算法Matlab程序

% f(x)=11*sin(6x)+7*cos(5x),0<=x<=2*pi; %%初始化参数 L=16;%编码为16位二进制数 N=32;%初始种群规模 M=48;%M个中间体，运用算子选择出M/2对母体，进行交叉；对M个中间体进行变异 T=100;%进化代数 Pc=0.8;%交叉概率 Pm=0.03;%%变异概率 %%将十进制编码成16位的二进制，再将16位的二进制转成格雷码 for i=1:1:N x1(1,i)= rand()*2*pi; x2(1,i)= uint16(x1(1,i)/(2*pi)*65535); grayCode(i,:)=num2gray(x2(1,i),L); end %% 开始遗传算子操作 for t=1:1:T y1=11*sin(6*x1)+7*cos(5*x1); for i=1:1:M/2 [a,b]=min(y1);%找到y1中的最小值a，及其对应的编号b grayCodeNew(i,:)=grayCode(b,:);%将找到的最小数放到grayCodeNew中grayCodeNew(i+M/2,:)=grayCode(b,:);%与上面相同就可以有M/2对格雷码可以作为母体y1(1,b)=inf;%用来排除已找到的最小值 end for i=1:1:M/2 p=unidrnd(L);%生成一个大于零小于L的数，用于下面进行交叉的位置if rand()

遗传算法经典MATLAB代码资料讲解

遗传算法经典学习Matlab代码遗传算法实例: 也是自己找来的，原代码有少许错误，本人都已更正了，调试运行都通过了的。对于初学者，尤其是还没有编程经验的非常有用的一个文件遗传算法实例 % 下面举例说明遗传算法% % 求下列函数的最大值% % f(x)=10*sin(5x)+7*cos(4x) x∈[0,10]% % 将x 的值用一个10位的二值形式表示为二值问题，一个10位的二值数提供的分辨率是每为(10-0)/(2^10-1)≈0.01。% % 将变量域[0,10] 离散化为二值域[0,1023], x=0+10*b/1023, 其中 b 是[0,1023] 中的一个二值数。% % % %--------------------------------------------------------------------------------------------------------------% %--------------------------------------------------------------------------------------------------------------% % 编程 %----------------------------------------------- % 2.1初始化(编码) % initpop.m函数的功能是实现群体的初始化，popsize表示群体的大小，chromlength表示染色体的长度(二值数的长度)，

% 长度大小取决于变量的二进制编码的长度(在本例中取10位)。 %遗传算法子程序 %Name: initpop.m %初始化 function pop=initpop(popsize,chromlength) pop=round(rand(popsize,chromlength)); % rand随机产生每个单元为{0,1} 行数为popsize，列数为chromlength的矩阵， % roud对矩阵的每个单元进行圆整。这样产生的初始种群。 % 2.2 计算目标函数值 % 2.2.1 将二进制数转化为十进制数(1) %遗传算法子程序 %Name: decodebinary.m %产生[2^n 2^(n-1) ... 1] 的行向量，然后求和，将二进制转化为十进制 function pop2=decodebinary(pop) [px,py]=size(pop); %求pop行和列数 for i=1:py pop1(:,i)=2.^(py-i).*pop(:,i); end pop2=sum(pop1,2); %求pop1的每行之和 % 2.2.2 将二进制编码转化为十进制数(2) % decodechrom.m函数的功能是将染色体(或二进制编码)转换为十进制，参数spoint表示待解码的二进制串的起始位置

基于遗传算法的matlab源代码

function youhuafun D=code; N=50;%Tunable maxgen=50;%Tunable crossrate=0.5;%Tunable muterate=0.08;%Tunable generation=1; num=length(D); fatherrand=randint(num,N,3); score=zeros(maxgen,N); while generation<=maxgen ind=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; %end fatherrand=[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:N tmprnd=rand; tmpind=tmprnd difind=[0,diff(t mpind)]; if~any(difind) difind(1)=1; end childind(k)=scoreind(logical(difind)); end fatherrand=fatherrand(:,childind); generation=generation+1; end %score maxV=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 D function D=code load youhua.mat %properties F2and F3 F1=A(:,1); F2=A(:,2); F3=A(:,3); if(max(F2)>1450)||(min(F2)<=900) error('DATA property F2exceed it''s range (900,1450]') end %get group property F1of data,according to F2value F4=zeros(size(F1)); for ite=11:-1:1 index=find(F2<=900+ite*50); F4(index)=ite; end D=[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; %这里有待优化

遗传算法的MATLAB程序实例

遗传算法的程序实例如求下列函数的最大值 f(x)=10*sin(5x)+7*cos(4x) x∈[0,10] 一、初始化(编码) initpop.m函数的功能是实现群体的初始化，popsize表示群体的大小，chromlength表示染色体的长度(二值数的长度)，长度大小取决于变量的二进制编码的长度(在本例中取10位)。代码: %Name: initpop.m %初始化 function pop=initpop(popsize,chromlength) pop=round(rand(popsize,chromlength)); % rand随机产生每个单元为 {0,1} 行数为popsize，列数为chromlength的矩阵， % roud对矩阵的每个单元进行圆整。这样产生的初始种群。二、计算目标函数值 1、将二进制数转化为十进制数(1) 代码: %Name: decodebinary.m %产生 [2^n 2^(n-1) ... 1] 的行向量，然后求和，将二进制转化为十进制 function pop2=decodebinary(pop) [px,py]=size(pop); %求pop行和例数 for i=1:py pop1(:,i)=2.^(py-1).*pop(:,i); py=py-1; end pop2=sum(pop1,2); %求pop1的每行之和 2、将二进制编码转化为十进制数(2) decodechrom.m函数的功能是将染色体(或二进制编码)转换为十进制，参数spoint表示待解码的二进制串的起始位置。(对于多个变量而言，如有两个变量，采用20为表示，每个变量10为，则第一个变量从1开始，另一个变量从11开始。本例为1)，参数1ength表示所截取的长度（本例为10）。代码: %Name: decodechrom.m %将二进制编码转换成十进制 function pop2=decodechrom(pop,spoint,length) pop1=pop(:,spoint:spoint+length-1); pop2=decodebinary(pop1); 3、计算目标函数值 calobjvalue.m函数的功能是实现目标函数的计算，其公式采用本文示例仿真，可根据不同优化问题予以修改。

基于遗传算法的BP神经网络MATLAB代码

用遗传算法优化BP神经网络的Matlab编程实例（转）由于BP网络的权值优化是一个无约束优化问题，而且权值要采用实数编码，所以直接利用Matlab遗传算法工具箱。以下贴出的代码是为一个19输入变量，1个输出变量情况下的非线性回归而设计的，如果要应用于其它情况，只需改动编解码函数即可。程序一：GA训练BP权值的主函数 function net=GABPNET(XX,YY) %-------------------------------------------------------------------------- % GABPNET.m % 使用遗传算法对BP网络权值阈值进行优化，再用BP算法训练网络 %-------------------------------------------------------------------------- %数据归一化预处理 nntwarn off XX=[1:19;2:20;3:21;4:22]'; YY=[1:4]; XX=premnmx(XX); YY=premnmx(YY); YY %创建网络 net=newff(minmax(XX),[19,25,1],{'tansig','tansig','purelin'},'tra inlm'); %下面使用遗传算法对网络进行优化 P=XX; T=YY; R=size(P,1); S2=size(T,1); S1=25;%隐含层节点数 S=R*S1+S1*S2+S1+S2;%遗传算法编码长度 aa=ones(S,1)*[-1,1]; popu=50;%种群规模 save data2 XX YY % 是将 xx,yy 二个变数的数值存入 data2 这个MAT-file，initPpp=initializega(popu,aa,'gabpEval');%初始化种群 gen=100;%遗传代数

三个遗传算法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'); end if nargin==3, eranum=200;popsize=100;pCross=0.8;pMutation=0.1;pInversion=0.15;options=[0 1e-4];end if nargin==4, popsize=100;pCross=0.8;pMutation=0.1;pInversion=0.15;options=[0 1e-4];end if nargin==5, pCross=0.8;pMutation=0.1;pInversion=0.15;options=[0 1e-4];end if nargin==6, pMutation=0.1;pInversion=0.15;options=[0 1e-4];end if nargin==7, pInversion=0.15;options=[0 1e-4];end if find((LB-UB)>0) error('数据输入错误,请重新输入(LB

遗传算法求函数极大值(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

matlab遗传算法程序

matlab遗传算法程序共13个.m文件。 1、B2F.m function [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:n len(i)=length(L(i,:)); end v=sol-bounds(:,1)'; for i=1:n B=[B de2bi(v(i),len(i))]; end

2、changes.m function [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

遗传算法的原理及MATLAB程序实现

1 遗传算法的原理 1.1 遗传算法的基本思想遗传算法（genetic algorithms，GA）是一种基于自然选择和基因遗传学原理，借鉴了生物进化优胜劣汰的自然选择机理和生物界繁衍进化的基因重组、突变的遗传机制的全局自适应概率搜索算法。遗传算法是从一组随机产生的初始解（种群）开始，这个种群由经过基因编码的一定数量的个体组成，每个个体实际上是染色体带有特征的实体。染色体作为遗传物质的主要载体，其内部表现（即基因型）是某种基因组合，它决定了个体的外部表现。因此，从一开始就需要实现从表现型到基因型的映射，即编码工作。初始种群产生后，按照优胜劣汰的原理，逐代演化产生出越来越好的近似解。在每一代，根据问题域中个体的适应度大小选择个体，并借助于自然遗传学的遗传算子进行组合交叉和变异，产生出代表新的解集的种群。这个过程将导致种群像自然进化一样，后代种群比前代更加适应环境，末代种群中的最优个体经过解码，可以作为问题近似最优解。计算开始时，将实际问题的变量进行编码形成染色体，随机产生一定数目的个体，即种群，并计算每个个体的适应度值，然后通过终止条件判断该初始解是否是最优解，若是则停止计算输出结果，若不是则通过遗传算子操作产生新的一代种群，回到计算群体中每个个体的适应度值的部分，然后转到终止条件判断。这一过程循环执行，直到满足优化准则，最终产生问题的最优解。图1-1给出了遗传算法的基本过程。 1.2 遗传算法的特点 1.2.1 遗传算法的优点遗传算法具有十分强的鲁棒性，比起传统优化方法，遗传算法有如下优点： 1. 遗传算法以控制变量的编码作为运算对象。传统的优化算法往往直接利用控制变量的实际值的本身来进行优化运算，但遗传算法不是直接以控制变量的值，而是以控制变量的特定形式的编码为运算对象。这种对控制变量的编码处理方式，可以模仿自然界中生物的遗传和进化等机理，也使得我们可以方便地处理各种变量和应用遗传操作算子。 2. 遗传算法具有内在的本质并行性。它的并行性表现在两个方面，一是遗传

Matlab环境下的遗传算法程序设计及优化问题求解

本栏目责任编辑：谢媛媛开发研究与设计技术遗传算法（ＧＡ）是借鉴生物界自然选择和群体进化机制而形成的一种全局寻优算法，其本质上是一种基于概率的随机搜索算法。与其它的优化算法相比较，遗传算法具有以下优点：（１）通用性；（２）并行性；（３）简单性和可操作性；（４）稳定性和全局性。１遗传算法概述在遗传算法中，首先将空间问题中的决策变量通过一定的编码表示成遗传空间的一个个体，它是一个基因型串结构数据；然后将目标函数转换成适应度值，用来评价每个个体的优劣，并将其作为遗传操作的依据。遗传操作包括三个算子：选择、重组和变异。选择是从当前群体中选择适应值高的个体以生成交配池的过程，交配池是当前代与下一代之间的中间群体。选择算子的作用是用来提高群体的平均适应度值。重组算子的作用是将原有的优良基因遗传给下一代个体，并生成包含更复杂基因的新个体，它先从交配池中的个体随机配对，然后将两两配对的个体按一定方式相互交换部分基因。变异算子是对个体的某一个或几位按某一较小的概率进行反转其二进制字符，模拟自然界的基因突变现象。遗传算法的基本程序实现流程如下：（１）先确定待优化的参数大致范围，然后对搜索空间进行编码；（２）随机产生包含各个个体的初始种群；（３）将种群中各个个体解码成对应的参数值，用解码后的参数求代价函数和适应度函数，运用适应度函数评估检测各个个体适应度；（４）对收敛条件进行判断，如果已经找到最佳个体，则停止，否则继续进行遗传操作；（５）进行选择操作，让适应度大的个体在种群中占有较大的比例，一些适应度较小的个体将会被淘汰；（６）随机交叉，两个个体按一定的交叉概率进行交叉操作，并产生两个新的子个体；（７）按照一定的变异概率变异，使个体的某个或某些位的性质发生改变；（８）重复步骤（３）至（７），直至参数收敛达到预定的指标。使用遗传算法需要确定的运行参数有：编码串长度、交叉和变异概率、种群规模。编码串长度由问题的所要求的精度来决定。交叉概率控制着交叉操作的频率，交叉操作是遗传算法中产生新个体的主要方法，所以交叉概率通常应取较大值，但如果交叉概率太大的话又可能反过来会破坏群体的优良模式，一般取０．４－０．９９。变异概率也是影响新个体产生的一个因素，如果变异概率太小，则产生新个体较少；如果变异概率太大，则又会使遗传算法变成随机搜索，为保证个体变异后与其父体不会产生太大的差异，通常取变异概率为０．０００１－０．１以保证种群发展的稳定性。种群规模太大时，计算量会很大，使遗传算法的运行效率降低，种群规模太小时，可以提高遗传算法的运行速度，但却种群的多样性却降低了，有可能找不出最优解，通常取种群数目２０－１００。从理论上讲，不存在一组适用于所有问题的最佳参数值，随着问题参数的变化，有效问参数的差异往往是十分显著的。２用Ｍａｔｌａｂ语言来实现遗传算法Ｍａｔｌａｂ是一个高性能的计算软件，配备有功能强大的数学函数支持库，适用范围大，编程效率高，语句简单，功能齐备，是世界上顶级的计算与仿真程序软件。利用Ｍａｔｌａｂ来编写遗传算法程序简单而且易于操作。２．１编码编码就是把一个问题的可行解从其解空间转换到遗传算法能够处理的搜索空间的转化方法，编码形式决定了重组算子的操作。遗传算法是对编码后的个体作选择与交叉运算，然后通过这些反复运算达到优化目标。遗传算法首要的问题是通过编码将决策变量表示成串结构数据。我们常用的是二进制编码，即用二进制数构成的符号串来表示每个个体。通常根据搜索精度（ｓｃａ＿ｖａｒ）、决策变量上界（ｒａｎｇｅ（２））的和下界（ｒａｎｇｅ（１））来确定各个二进制字符串的长度（ｂｉｔ＿ｎ），搜索精度为ｓｃａ＿ｖａｒ＝（ｒａｎｇｅ（２）－ｒａｎｇｅ（１））．／（２＾ｂｉｔ＿ｎ—１），然后再随机产生一个的初始种群（ｂｅ＿ｇｅｎ），其规模为ｐｏｐｕｓｉｚｅ。下面用ｅｎｃｏｄｉｎｇ函数来实现编码和产生初始的种群：ｆｕｎｃｔｉｏｎ［ｂｅ＿ｇｅｎ，ｂｉｔ＿ｎ］＝ｅｎｃｏｄｉｎｇ（ｓｃａ＿ｖａｒ，ｒａｎｇｅ（１），ｒａｎｇｅ（２），ｐｏｐｕｓｉｚｅ）ｂｉｔ＿ｎ＝ｃｅｉｌ（ｌｏｇ２（（ｒａｎｇｅ（２）－ｒａｎｇｅ（１））．／ｓｃａ＿ｖａｒ））；ｂｅ＿ｇｅｎ＝ｒａｎｄｉｎｔ（ｐｏｐｕｓｉｚｅ，ｓｕｍ（ｂｉｔ＿ｎ））；２．２译码决策变量经过编码之后，各个个体构成的种群ｂｅ＿ｇｅｎ要通过解码才能转换成原问题空间的决策变量构成的种群ｖｇｅｎ，这样才收稿日期：２００６－０１－０５作者简介：梁科（１９８１－），硕士研究生，研究方向：智能计算与优化方法；夏定纯（１９６３－），教授，研究方向：人工智能，计算机在线检测。 Matlab 环境下的遗传算法程序设计及优化问题求解梁科，夏定纯（武汉科技学院计算机科学学院，湖北武汉４３００７３）摘要：本文介绍了遗传算法的流程及几个算子，给出了在ｍａｔｌａｂ语言环境下实现编码、译码、选择、重组和变异各算子的编程方法，最后用一个实例来说明遗传算法在寻找全局最优解中的应用。关键词：遗传算法；ｍａｔｌａｂ；程序设计中图分类号：ＴＰ３１２文献标识码：Ａ文章编号：１００９－３０４４（２００７）０４－１１０４９－０３ＧｅｎｅｔｉｃＡｌｇｏｒｉｔｈｍＰｒｏｇｒａｍｍｉｎｇＢｙＭａｔｌａｂＡｎｄＯｐｔｉｍｉｚｉｎｇＰｒｏｂｌｅｍＳｏｌｖｉｎｇＬＩＡＮＧＫｅ，ＸＩＡＤｉｎｇ－ｃｈｕｎ（ＤｅｐａｒｔｍｅｎｔｏｆＣｏｍｐｕｔｅｒｓｃｉｅｎｃｅ，ＷｕｈａｎＵｎｉｖｅｒｓｉｔｙｏｆＳｃｉｅｎｃｅ＆Ｅｎｇｉｎｅｅｒｉｎｇ，Ｗｕｈａｎ４３００７３，Ｃｈｉｎａ）Ａｂｓｔｒａｃｔ：Ｔｈｅｓｅｖｅｒａｌｆａｃｔｏｒｓｏｆｇｅｎｅｔｉｃａｌｇｏｒｉｔｈｍｈａｖｅｂｅｅｎｐｒｅｓｅｎｔｅｄｉｎｔｈｉｓｐａｐｅｒ，ａｎｄｔｈｅｐｒｏｇｒａｍｍｉｎｇｏｆｅｎｃｏｄｉｎｇ、ｄｅｃｏｄｉｎｇ、ｃｈｏｉｃｅ、ｃｒｏｓｓｏｖｅｒａｎｄｍｕｔａｔｉｏｎｏｆｍａｔｌａｂｈａｖｅｂｅｅｎｇｉｖｅｎ，ｆｉｎａｌｌｙ，ａｆｕｎｃｔｉｏｎｏｐｔｉｍｉｚｉｎｇｐｒｏｂｌｅｍｈａｓｂｅｅｎｐｒｅｓｅｎｔｅｄｔｏｄｅｍｏｎｓｔｒａｔｅｄｔｈｅａｐｐｌｉｃａｔｉｏｎａｂｏｕｔｇｌｏｂａｌｏｐｔｉｍｉｚｉｎｇｏｆｇｅｎｅｔｉｃａｌｇｏｒｉｔｈｍ．Ｋｅｙｗｏｒｄｓ：ＧＡ；ｍａｔｌａｂ；ｐｒｏｇｒａｍｍｉｎｇ１０４９

遗传算法的MATLAB程序实例讲解学习

遗传算法的M A T L A B 程序实例

遗传算法GA的MATLAB代码

MATLAB实现算法代码：GA（遗传算法）——整数编码 function [BestGene,aa] = GA(MaxGeneration,GeneSize,GeneNum,pcross,pmute,minGene,maxGene) Parent = Init(GeneSize,GeneNum,minGene,maxGene); [BestGene,Parent] = KeepBest(Parent); aa = []; for i = 1:MaxGeneration [i 1/value(BestGene)] Child = chose(Parent); Child = cross(Child,pcross); Child = mute(Child,pmute,maxGene); [BestGene,Parent] = KeepBest(Child); aa = [aa;value(BestGene)]; end function GeneInit = Init(GeneSize,GeneNum,minGene,maxGene) GeneInit = []; for i = 1:GeneSize x = []; x = ceil(rand(1,GeneNum).*(maxGene-minGene)) + minGene; GeneInit = [GeneInit;x]; end GeneInit = [GeneInit;x]; function Child = chose(Parent) GeneSize = size(Parent,1); for i = 1:GeneSize x = Parent(i,:); val(i) = value(x); end ValSum = sum(val); val = val / ValSum; for i = 2:GeneSize val(i) = val(i) + val(i-1); end for i = 1:GeneSize randval = rand; if randval <= val(1) Child(i,:) = Parent(1,:); end for j = 2:GeneSize if randval > val(j-1) && randval <= val(j)