matlab gatool 实例

kakaxi 2008-05-25

展开全文

遗传算法matlab代码

2008-02-11 16:13

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(tmpind)];
       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 F2 and F3
F1=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: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;
% 这里有待优化
for k=1:N
   FF4k=FF4rnd(:,k);
   for ite=1:11
       F0index=find(FF4k==ite);
       if ~isempty(F0index)
           tmpMat=F3(F0index);
           tmpSco=sum(tmpMat);
           ScoreBin(ite)=mod(tmpSco,300);
       end
   end
   Scorek(k)=sum(ScoreBin);
end
ScoreN=ScoreN-Scorek;

遗传算法程序 matlab

2006年12月09日星期六 20:53

遗传算法程序

本程序收集于网络，本人并未进行过运行，如有问题请与作者联系，如有侵权请告之

遗传算法程序:
说明: 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<UB):‘);
end
s=sprintf(‘程序运行需要约%.4f 秒钟时间,请稍等......‘,(eranum*popsize/1000));
disp(s);

global m n NewPop children1 children2 VarNum

bounds=[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,Trace
Trace=zeros(eranum,length(bits)+1);
i=1;
while i<=eranum
    for j=1:m
        value(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;
end
t=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)<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(‘程序运行耗时 %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 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

%解码

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 [selectpop]=NonlinearRankSelect(FUN,pop,bounds,bits)
global m n
selectpop=zeros(m,n);
fit=zeros(m,1);
for i=1:m
    fit(i)=feval(FUN(1,:),(b2f(pop(i,:),bounds,bits)));%以函数值为适应值做排名依据
end
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=cumsum(newfit);%计算各选择概率之和
rNums=sort(rand(m,1));
fitIn=1;newIn=1;
while newIn<=m
    if rNums(newIn)<newfit(fitIn)
        selectpop(newIn,:)=pop(fitIn,:);
        newIn=newIn+1;
    else
        fitIn=fitIn+1;
    end
end

%交叉操作
function [NewPop]=CrossOver(OldPop,pCross,opts)
%OldPop为父代种群，pcross为交叉概率
global m n NewPop
r=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)=[];
end
if length(y1)>=2
   for i=0:2:length(y1)-2
       if 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),:));
       end
   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,pMutation,VarNum)

global m n NewPop
r=rand(1,m);
position=find(r<=pMutation);
len=length(position);
if len>=1
   for i=1:len
       k=unidrnd(n,1,VarNum); %设置变异点数，一般设置1点
       for j=1:length(k)
           if OldPop(position(i),k(j))==1
              OldPop(position(i),k(j))=0;
           else
              OldPop(position(i),k(j))=1;
           end
       end
   end
end
NewPop=OldPop;

%倒位操作

function [NewPop]=Inversion(OldPop,pInversion)

global m n NewPop
NewPop=OldPop;
r=rand(1,m);
PopIn=find(r<=pInversion);
len=length(PopIn);
if len>=1
    for i=1:len
        d=sort(unidrnd(n,1,2));
        if d(1)~=1&d(2)~=n
           NewPop(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);
       end
   end
end

用遗传算法优化BP神经网络的Matlab编程实例

2007/04/28 23:09

此文章首次在simwe公开发表，属于GreenSim团队原创作品，转载请注明！
由于BP网络的权值优化是一个无约束优化问题，而且权值要采用实数编码，所以直接利用Matlab遗传算法工具箱。以下贴出的代码是为一个19输入变量，1个输出变量情况下的非线性回归而设计的，如果要应用于其它情况，只需改动编解码函数即可。

程序一：GA训练BP权值的主函数
function net=GABPNET(XX,YY)
%--------------------------------------------------------------------------
%   GABPNET.m
%   使用遗传算法对BP网络权值阈值进行优化，再用BP算法训练网络
%--------------------------------------------------------------------------
%数据归一化预处理
nntwarn off
XX=premnmx(XX);
YY=premnmx(YY);
%创建网络
net=newff(minmax(XX),[19,25,1],{‘tansig‘,‘tansig‘,‘purelin‘},‘trainlm‘);
%下面使用遗传算法对网络进行优化
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;%种群规模
initPpp=initializega(popu,aa,‘gabpEval‘);%初始化种群
gen=100;%遗传代数
%下面调用gaot工具箱，其中目标函数定义为gabpEval
[x,endPop,bPop,trace]=ga(aa,‘gabpEval‘,[],initPpp,[1e-6 1 1],‘maxGenTerm‘,gen,...
   ‘normGeomSelect‘,[0.09],[‘arithXover‘],[2],‘nonUnifMutation‘,[2 gen 3]);
%绘收敛曲线图
figure(1)
plot(trace(:,1),1./trace(:,3),‘r-‘);
hold on
plot(trace(:,1),1./trace(:,2),‘b-‘);
xlabel(‘Generation‘);
ylabel(‘Sum-Squared Error‘);
figure(2)
plot(trace(:,1),trace(:,3),‘r-‘);
hold on
plot(trace(:,1),trace(:,2),‘b-‘);
xlabel(‘Generation‘);
ylabel(‘Fittness‘);
%下面将初步得到的权值矩阵赋给尚未开始训练的BP网络
[W1,B1,W2,B2,P,T,A1,A2,SE,val]=gadecod(x);
net.LW{2,1}=W1;
net.LW{3,2}=W2;
net.b{2,1}=B1;
net.b{3,1}=B2;
XX=P;
YY=T;
%设置训练参数
net.trainParam.show=1;
net.trainParam.lr=1;
net.trainParam.epochs=50;
net.trainParam.goal=0.001;
%训练网络
net=train(net,XX,YY);

程序二：适应值函数
function [sol, val] = gabpEval(sol,options)
% val - the fittness of this individual
% sol - the individual, returned to allow for Lamarckian evolution
% options - [current_generation]
load data2
nntwarn off
XX=premnmx(XX);
YY=premnmx(YY);
P=XX;
T=YY;
R=size(P,1);
S2=size(T,1);
S1=25;%隐含层节点数
S=R*S1+S1*S2+S1+S2;%遗传算法编码长度
for i=1:S,
    x(i)=sol(i);
end;
[W1, B1, W2, B2, P, T, A1, A2, SE, val]=gadecod(x);

程序三：编解码函数
function [W1, B1, W2, B2, P, T, A1, A2, SE, val]=gadecod(x)
load data2
nntwarn off
XX=premnmx(XX);
YY=premnmx(YY);
P=XX;
T=YY;
R=size(P,1);
S2=size(T,1);
S1=25;%隐含层节点数
S=R*S1+S1*S2+S1+S2;%遗传算法编码长度
% 前R*S1个编码为W1
for i=1:S1,
     for k=1:R,
       W1(i,k)=x(R*(i-1)+k);
     end
end
% 接着的S1*S2个编码（即第R*S1个后的编码）为W2
for i=1:S2,
    for k=1:S1,
       W2(i,k)=x(S1*(i-1)+k+R*S1);
    end
end
% 接着的S1个编码（即第R*S1+S1*S2个后的编码）为B1
for i=1:S1,
    B1(i,1)=x((R*S1+S1*S2)+i);
end
% 接着的S2个编码（即第R*S1+S1*S2+S1个后的编码）为B2
for i=1:S2,
    B2(i,1)=x((R*S1+S1*S2+S1)+i);
end
% 计算S1与S2层的输出
A1=tansig(W1*P,B1);
A2=purelin(W2*A1,B2);
% 计算误差平方和
SE=sumsqr(T-A2);
val=1/SE; % 遗传算法的适应值

matlab遗传算法工具箱函数及实例讲解（转引）

2007-08-16 19:44

核心函数：
(1)function [pop]=initializega(num,bounds,eevalFN,eevalOps,options)--初始种群的生成函数
【输出参数】
pop--生成的初始种群
【输入参数】
num--种群中的个体数目
bounds--代表变量的上下界的矩阵
eevalFN--适应度函数
eevalOps--传递给适应度函数的参数
options--选择编码形式(浮点编码或是二进制编码)[precision F_or_B],如
precision--变量进行二进制编码时指定的精度
F_or_B--为1时选择浮点编码，否则为二进制编码,由precision指定精度)

(2)function [x,endPop,bPop,traceInfo] = ga(bounds,evalFN,evalOps,startPop,opts,...
termFN,termOps,selectFN,selectOps,xOverFNs,xOverOps,mutFNs,mutOps)--遗传算法函数
【输出参数】
x--求得的最优解
endPop--最终得到的种群
bPop--最优种群的一个搜索轨迹
【输入参数】
bounds--代表变量上下界的矩阵
evalFN--适应度函数
evalOps--传递给适应度函数的参数
startPop-初始种群
opts[epsilon prob_ops display]--opts(1:2)等同于initializega的options参数，第三个参数控制是否输出，一般为0。如[1e-6 1 0]
termFN--终止函数的名称,如[‘maxGenTerm‘]
termOps--传递个终止函数的参数,如[100]
selectFN--选择函数的名称,如[‘normGeomSelect‘]
selectOps--传递个选择函数的参数,如[0.08]
xOverFNs--交叉函数名称表，以空格分开，如[‘arithXover heuristicXover simpleXover‘]
xOverOps--传递给交叉函数的参数表，如[2 0;2 3;2 0]
mutFNs--变异函数表，如[‘boundaryMutation multiNonUnifMutation nonUnifMutation unifMutation‘]
mutOps--传递给交叉函数的参数表,如[4 0 0;6 100 3;4 100 3;4 0 0]

注意】matlab工具箱函数必须放在工作目录下
【问题】求f(x)=x+10*sin(5x)+7*cos(4x)的最大值，其中0<=x<=9
【分析】选择二进制编码，种群中的个体数目为10，二进制编码长度为20，交叉概率为0.95,变异概率为0.08
【程序清单】
%编写目标函数
function[sol,eval]=fitness(sol,options)
x=sol(1);
eval=x+10*sin(5*x)+7*cos(4*x);
%把上述函数存储为fitness.m文件并放在工作目录下

initPop=initializega(10,[0 9],‘fitness‘);%生成初始种群，大小为10
[x endPop,bPop,trace]=ga([0 9],‘fitness‘,[],initPop,[1e-6 1 1],‘maxGenTerm‘,25,‘normGeomSelect‘,...
[0.08],[‘arithXover‘],[2],‘nonUnifMutation‘,[2 25 3]) %25次遗传迭代

运算借过为：x =
7.8562 24.8553(当x为7.8562时，f（x）取最大值24.8553)

注：遗传算法一般用来取得近似最优解，而不是最优解。

遗传算法实例2

【问题】在－5<=Xi<=5,i=1,2区间内，求解
f(x1,x2)=-20*exp(-0.2*sqrt(0.5*(x1.^2+x2.^2)))-exp(0.5*(cos(2*pi*x1)+cos(2*pi*x2)))+22.71282的最小值。
【分析】种群大小10，最大代数1000，变异率0.1,交叉率0.3
【程序清单】
％源函数的matlab代码
function [eval]=f(sol)
numv=size(sol,2);
x=sol(1:numv);
eval=-20*exp(-0.2*sqrt(sum(x.^2)/numv)))-exp(sum(cos(2*pi*x))/numv)+22.71282;
%适应度函数的matlab代码
function [sol,eval]=fitness(sol,options)
numv=size(sol,2)-1;
x=sol(1:numv);
eval=f(x);
eval=-eval;
%遗传算法的matlab代码
bounds=ones(2,1)*[-5 5];
[p,endPop,bestSols,trace]=ga(bounds,‘fitness‘)

注：前两个文件存储为m文件并放在工作目录下，运行结果为
p =
0.0000 -0.0000 0.0055

大家可以直接绘出f(x)的图形来大概看看f（x）的最值是多少，也可是使用优化函数来验证。matlab命令行执行命令：
fplot(‘x+10*sin(5*x)+7*cos(4*x)‘,[0,9])

evalops是传递给适应度函数的参数，opts是二进制编码的精度，termops是选择maxGenTerm结束函数时传递个maxGenTerm的参数，即遗传代数。xoverops是传递给交叉函数的参数。mutops是传递给变异函数的参数。

一个动态遗传算法代码 matlab的

2008-03-19 17:11

%IAGA
function best=ga
clear
MAX_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_gen
    fitness=fit(popus,RANGE);       %求适应度
    f=fitness.f;
    picked=choose(popus,fitness);   %选择
    popus=intercross(popus,picked); %杂交
    popus=aberrance(popus,picked); %变异
    if max(f)>best.max_f
        advance_k=advance_k+1;
        x_better(advance_k)=fitness.x;
        best.max_f=max(f);
        best.popus=popus;
        best.x=fitness.x;
    end
    if mod(advance_k,SPEEDUP_INTER)==0
        RANGE=minmax(x_better);

        RANGE

        advance=0;
    end
end
return;
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:M
    x=0;
    for n=1:N
        x=x+popus(m,n)*(2^(n-1));
    end
    x=x*((B-A)/(2^N))+A;
    for k=1:5
        f(m,1)=f(m,1)-(k*sin((k+1)*x+k));
    end
end
f_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:M
    x=find(f==f_t(k));%降序排列的个体序号
    d_order(k)=x(1);
end
for m=1:M
    popus_t(m,:)=popus(d_order(m),:);
end
popus=popus_t;
f=f_t;

p=f_std./sum(f_std); %选择概率
c_p=cumsum(p)‘; %累积概率

for cn=1:choose_N
    picked(cn,1)=roulette(c_p); %轮盘赌
    picked(cn,2)=roulette(c_p); %轮盘赌
    popus=intercross(popus,picked(cn,:));%杂交
end
popus=aberrance(popus,picked);%变异
return;

function popus=intercross(popus,picked) %杂交
[M_p,N_p]=size(picked);
[M,N]=size(popus);
for cn=1:M_p
    p(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;
end
return;
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_p
    if U(2)>=P_a        %如果大于变异概率，就不变异
        continue;
    end
    if U(1)>=0.5
        a=picked(kp,1);
    else
        a=picked(kp,2);
    end
    p(1)=ceil(rand*N);%生成变异位置
    p(2)=ceil(rand*N);
    if popus(a,p(1))==1%0 1变换
        popus(a,p(1))=0;
    else
        popus(a,p(1))=1;
    end
    if popus(a,p(2))==1
        popus(a,p(2))=0;
    else
        popus(a,p(2))=1;
    end
end
return;

function picked=roulette(c_p) %轮盘赌
[M,N]=size(c_p);
M=max([M N]);
U=rand;
if U<c_p(1)
    picked=1;
    return;
end
for m=1:(M-1)
    if U>c_p(m) & U<c_p(m+1)
        picked=m+1;
        break;
    end
end

全方位的两点杂交、两点变异的改进的加速遗传算法（IAGA）