目录
[17、选择性搜索算法(Selective Search)](#17、选择性搜索算法(Selective Search))
[18、麻雀搜索算法（Sparrow Search Algorithm，SSA）](#18、麻雀搜索算法（Sparrow Search Algorithm，SSA）)
篇幅过长就不解释原理了
1、GA遗传算法
%遗传算法 %
%_________________________________________________________________________%
function [Best_score,Best_pos,curve]=GA(pop,Max_iter,lb,ub,dim,fobj)
%% 参数初始化
popsize=pop; %种群规模
lenchrom=dim; %变量字串长度
fun = fobj; %适应度函数
pc=0.8; %设置交叉概率
pm=0.05; %设置变异概率
if(max(size(ub)) == 1)
ub = ub.*ones(dim,1);
lb = lb.*ones(dim,1);
end
maxgen=Max_iter; % 进化次数
%种群
bound=[lb,ub]; %变量范围
%% 产生初始粒子和速度
for i=1:popsize
%随机产生一个种群
GApop(i,:)=Code(lenchrom,bound); %随机产生个体
%计算适应度
[fitness(i)]=fun(GApop(i,:)); %染色体的适应度
end
%找最好的染色体
[bestfitness bestindex]=min(fitness);
zbest=GApop(bestindex,:); %全局最佳
gbest=GApop; %个体最佳
fitnessgbest=fitness; %个体最佳适应度值
fitnesszbest=bestfitness; %全局最佳适应度值
%% 迭代寻优
for i=1:maxgen
% disp(['第',num2str(i),'次迭代'])
%种群更新 GA选择更新
GApop=Select2(GApop,fitness,popsize);
% 交叉操作 GA
GApop=Cross(pc,lenchrom,GApop,popsize,bound);
% 变异操作 GA变异
GApop=Mutation(pm,lenchrom,GApop,popsize,[i maxgen],bound);
pop=GApop;
for j=1:popsize
%适应度值
[fitness(j)]=fun(pop(j,:));
%个体最优更新
if fitness(j) < fitnessgbest(j)
gbest(j,:) = pop(j,:);
fitnessgbest(j) = fitness(j);
end
%群体最优更新
if fitness(j) < fitnesszbest
zbest = pop(j,:);
fitnesszbest = fitness(j);
end
end
curve(i)=fitnesszbest;
end
Best_score = fitnesszbest;
Best_pos = zbest;
end
%% 选择函数
function ret=Select2(individuals,fitness,sizepop)
% 本函数对每一代种群中的染色体进行选择，以进行后面的交叉和变异
% individuals input : 种群信息
% fitness input : 适应度
% sizepop input : 种群规模
% opts input : 选择方法的选择
% ret output : 经过选择后的种群
fitness= 1./(fitness);
sumfitness=sum(fitness);
sumf=fitness./sumfitness;
index=[];
for i=1:sizepop %转sizepop次轮盘
pick=rand;
while pick==0
pick=rand;
end
for j=1:sizepop
pick=pick-sumf(j);
if pick<0
index=[index j];
break; %寻找落入的区间，此次转轮盘选中了染色体i，注意：在转sizepop次轮盘的过程中，有可能会重复选择某些染色体
end
end
end
individualsTemp=individuals(index,:);
fitnessTemp=fitness(index);
if(size(individualsTemp,1) == 0)
ret=individuals;
else
ret=individualsTemp;
end
end
%% 交叉函数
function ret=Mutation(pmutation,lenchrom,chrom,sizepop,pop,bound)
% 本函数完成变异操作
% pcorss input : 变异概率
% lenchrom input : 染色体长度
% chrom input : 染色体群
% sizepop input : 种群规模
% pop input : 当前种群的进化代数和最大的进化代数信息
% ret output : 变异后的染色体
for i=1:sizepop
% 随机选择一个染色体进行变异
pick=rand;
while pick==0
pick=rand;
end
index=ceil(pick*sizepop);
% 变异概率决定该轮循环是否进行变异
pick=rand;
if pick>pmutation
continue;
end
flag=0;
while flag==0
% 变异位置
pick=rand;
while pick==0
pick=rand;
end
pos=ceil(pick*sum(lenchrom)); %随机选择了染色体变异的位置，即选择了第pos个变量进行变异
if pos<=0
pos = 1;
end
if pos>size(bound,1)
pos = size(bound,1);
end
v=chrom(i,pos);
v1=v-bound(pos,1);
v2=bound(pos,2)-v;
pick=rand; %变异开始
if pick>0.5
delta=v2*(1-pick^((1-pop(1)/pop(2))^2));
chrom(i,pos)=v+delta;
else
delta=v1*(1-pick^((1-pop(1)/pop(2))^2));
chrom(i,pos)=v-delta;
end %变异结束
flag=test(lenchrom,bound,chrom(i,:)); %检验染色体的可行性
end
end
ret=chrom;
end
%% 变异函数
function ret=Cross(pcross,lenchrom,chrom,sizepop,bound)
%本函数完成交叉操作
% pcorss input : 交叉概率
% lenchrom input : 染色体的长度
% chrom input : 染色体群
% sizepop input : 种群规模
% ret output : 交叉后的染色体
for i=1:sizepop
% 随机选择两个染色体进行交叉
pick=rand(1,2);
while prod(pick)==0
pick=rand(1,2);
end
index=ceil(pick.*sizepop);
% 交叉概率决定是否进行交叉
pick=rand;
while pick==0
pick=rand;
end
if pick>pcross
continue;
end
flag=0;
while flag==0
% 随机选择交叉位置
pick=rand;
while pick==0
pick=rand;
end
pos=ceil(pick.*sum(lenchrom)); %随机选择进行交叉的位置，即选择第几个变量进行交叉，注意：两个染色体交叉的位置相同
pick=rand; %交叉开始
v1=chrom(index(1),pos);
v2=chrom(index(2),pos);
chrom(index(1),pos)=pick*v2+(1-pick)*v1;
chrom(index(2),pos)=pick*v1+(1-pick)*v2; %交叉结束
flag1=test(lenchrom,bound,chrom(index(1),:)); %检验染色体1的可行性
flag2=test(lenchrom,bound,chrom(index(2),:)); %检验染色体2的可行性
if flag1*flag2==0
flag=0;
else flag=1;
end %如果两个染色体不是都可行，则重新交叉
end
end
ret=chrom;
end
%% 判断是否在范围内
function flag=test(lenchrom,bound,code)
% lenchrom input : 染色体长度
% bound input : 变量的取值范围
% code output: 染色体的编码值
flag=1;
[n,m]=size(code);
for i=1:n
if code(i)<bound(i,1) || code(i)>bound(i,2)
flag=0;
end
end
end
%% 编码函数
function ret=Code(lenchrom,bound)
%本函数将变量编码成染色体，用于随机初始化一个种群
% lenchrom input : 染色体长度
% bound input : 变量的取值范围
% ret output: 染色体的编码值
flag=0;
while flag==0
pick=rand(1,lenchrom);
ret=bound(:,1)'+(bound(:,2)-bound(:,1))'.*pick; %线性插值
flag=test(lenchrom,bound,ret); %检验染色体的可行性
end
end
2、鲸鱼算法
function [lb,ub,dim,fobj] = Get_Functions_details(F)
switch F
case 'F1'
fobj = @F1;
lb=-50;
ub=50;
dim=10;
case 'F2'
fobj = @F2;
lb=-10;
ub=10;
dim=30;
case 'F3'
fobj = @F3;
lb=-65.536;
ub=65.536;
dim=2;
case 'F4'
fobj = @F4;
lb=-100;
ub=100;
dim=30;
case 'F5'
fobj = @F5;
lb=-30;
ub=30;
dim=30;
case 'F6'
fobj = @F6;
lb=-5;
ub=20;
dim=2;
case 'F7' %加了约束项的，罚函数
fobj = @F7;
lb=-100;
ub=100;
dim=30;
case 'F8' %加了约束项的，罚函数
fobj = @F8;
lb=[0,0,0];
ub=[1,1,1];
dim=3;
case 'F9' %加了约束项的，罚函数
fobj = @F9;
lb=[0,0,0];
ub=2.*[1,1,1];
dim=3;
end
end
% F1
function o = F1(x)
o=sum(-x.*sin(sqrt(abs(x))));
end
% F2
function o = F2(x)
o=sum(abs(x))+prod(abs(x));
end
% F3
function o = F3(x)
aS=[-32 -16 0 16 32 -32 -16 0 16 32 -32 -16 0 16 32 -32 -16 0 16 32 -32 -16 0 16 32;,...
-32 -32 -32 -32 -32 -16 -16 -16 -16 -16 0 0 0 0 0 16 16 16 16 16 32 32 32 32 32];
for j=1:25
bS(j)=sum((x'-aS(:,j)).^6);
end
o=(1/500+sum(1./([1:25]+bS))).^(-1);
end
% F4
function o = F4(x)
o=max(abs(x));
end
% F5
function o = F5(x)
dim=size(x,2);
o=sum(100*(x(2:dim)-(x(1:dim-1).^2)).^2+(x(1:dim-1)-1).^2);
end
% F6
function o = F6(x)
o=(x(2)-(x(1)^2)*5.1/(4*(pi^2))+5/pi*x(1)-6)^2+10*(1-1/(8*pi))*cos(x(1))+10;
end
function o = F7(x)
o=sum(abs((x+.5)).^2);
%加个约束，罚函数，
alpha=10000;
%不等式约束
g1=(x(1)+x(2)^2-x(3)>0)*(x(1)+x(2)^2-x(3))^2*alpha;
g2=(x(6)^3+x(7)^2+x(8)^3>0)*(x(6)^3+x(7)^2+x(8)^3)^2*alpha;
o=o+g1+g2;
end
function o = F8(x)
o1=-(x(1)^2-x(2)^2+x(2)*x(3)); %原始目标函数值
%加个约束，罚函数，不满足约束进行惩罚
alpha=10000;
%不等式约束 要化成小于等于
c(1)=2*x(1)+x(2)+3*x(3)-6;
c(2)=x(1)^2+x(1)*x(2)+x(3)*x(2)-x(2)-6;
%等式约束
ceq=0;
% ceq(1)=x(1)+x(3)-1;
o=o1+alpha*sum((c>0).*c.^2)+alpha*sum(ceq.^2);
end
function o = F9(x)
o1=-x(1)-2*x(2)+3*x(3); %原始目标函数值
%加个约束，罚函数，不满足约束进行惩罚
alpha=10000;
%不等式约束 要化成小于等于
c(1)=-x(1)-x(2)+3;
c(2)=-x(3)-x(2)+3;
%等式约束
ceq(1)=x(1)+x(3)-4;
% ceq(1)=x(1)+x(3)-1;
o=o1+alpha*sum((c>0).*c.^2)+alpha*sum(ceq.^2);
end
3、蝗虫优化算法
% The Grasshopper Optimization Algorithm
function [TargetFitness,TargetPosition,Convergence_curve,Trajectories,fitness_history, position_history]=GOA(N, Max_iter, lb,ub, dim, fobj)
% disp('GOA is now estimating the global optimum for your problem....')
flag=0;
if size(ub,1)==1
ub=ones(dim,1).*ub;
lb=ones(dim,1).*lb;
end
if (rem(dim,2)~=0) % this algorithm should be run with a even number of variables. This line is to handle odd number of variables
dim = dim+1;
ub(dim)=100;
lb(dim)=100;
% ub = [ub,100];
% lb = [lb,-100];
flag=1;
end
%Initialize the population of grasshoppers
GrassHopperPositions=initialization(N,dim,ub,lb);
GrassHopperFitness = zeros(1,N);
fitness_history=zeros(N,Max_iter);
position_history=zeros(N,Max_iter,dim);
Convergence_curve=zeros(1,Max_iter);
Trajectories=zeros(N,Max_iter);
cMax=1;
cMin=0.00004;
%Calculate the fitness of initial grasshoppers
for i=1:size(GrassHopperPositions,1)
if flag == 1
GrassHopperFitness(1,i)=fobj(GrassHopperPositions(i,1:end-1));
else
GrassHopperFitness(1,i)=fobj(GrassHopperPositions(i,:));
end
fitness_history(i,1)=GrassHopperFitness(1,i);
position_history(i,1,:)=GrassHopperPositions(i,:);
Trajectories(:,1)=GrassHopperPositions(:,1);
end
[sorted_fitness,sorted_indexes]=sort(GrassHopperFitness);
% Find the best grasshopper (target) in the first population
for newindex=1:N
Sorted_grasshopper(newindex,:)=GrassHopperPositions(sorted_indexes(newindex),:);
end
TargetPosition=Sorted_grasshopper(1,:);
TargetFitness=sorted_fitness(1);
% Main loop
l=2; % Start from the second iteration since the first iteration was dedicated to calculating the fitness of antlions
while l<Max_iter+1
c=cMax-l*((cMax-cMin)/Max_iter); % Eq. (2.8) in the paper
for i=1:size(GrassHopperPositions,1)
temp= GrassHopperPositions';
for k=1:2:dim
S_i=zeros(2,1);
for j=1:N
if i~=j
Dist=distance(temp(k:k+1,j), temp(k:k+1,i)); % Calculate the distance between two grasshoppers
r_ij_vec=(temp(k:k+1,j)-temp(k:k+1,i))/(Dist+eps); % xj-xi/dij in Eq. (2.7)
xj_xi=2+rem(Dist,2); % |xjd - xid| in Eq. (2.7)
s_ij=((ub(k:k+1) - lb(k:k+1))*c/2)*S_func(xj_xi).*r_ij_vec; % The first part inside the big bracket in Eq. (2.7)
S_i=S_i+s_ij;
end
end
S_i_total(k:k+1, :) = S_i;
end
X_new = c * S_i_total'+ (TargetPosition); % Eq. (2.7) in the paper
GrassHopperPositions_temp(i,:)=X_new';
end
% GrassHopperPositions
GrassHopperPositions=GrassHopperPositions_temp;
for i=1:size(GrassHopperPositions,1)
% Relocate grasshoppers that go outside the search space
Tp=GrassHopperPositions(i,:)>ub';Tm=GrassHopperPositions(i,:)<lb';GrassHopperPositions(i,:)=(GrassHopperPositions(i,:).*(~(Tp+Tm)))+ub'.*Tp+lb'.*Tm;
% Calculating the objective values for all grasshoppers
if flag == 1
GrassHopperFitness(1,i)=fobj(GrassHopperPositions(i,1:end-1));
else
GrassHopperFitness(1,i)=fobj(GrassHopperPositions(i,:));
end
fitness_history(i,l)=GrassHopperFitness(1,i);
position_history(i,l,:)=GrassHopperPositions(i,:);
Trajectories(:,l)=GrassHopperPositions(:,1);
% Update the target
if GrassHopperFitness(1,i)<TargetFitness
TargetPosition=GrassHopperPositions(i,:);
TargetFitness=GrassHopperFitness(1,i);
end
end
Convergence_curve(l)=TargetFitness;
% disp(['In iteration #', num2str(l), ' , target''s objective = ', num2str(TargetFitness)])
l = l + 1;
end
if (flag==1)
TargetPosition = TargetPosition(1:dim-1);
end
end
%%
function d = distance(a,b)
d=sqrt((a(1)-b(1))^2+(a(2)-b(2))^2);
end
%%
function [X]=initialization(N,dim,up,down)
if size(up,1)==1
X=rand(N,dim).*(up-down)+down;
end
if size(up,1)>1
for i=1:dim
high=up(i);low=down(i);
X(:,i)=rand(1,N).*(high-low)+low;
end
end
end
%%
function o=S_func(r)
f=0.5;
l=1.5;
o=f*exp(-r/l)-exp(-r); % Eq. (2.3) in the paper
end
4、人工大猩猩部队优化算法
function [Silverback_Score,Silverback,convergence_curve]=GTO(pop_size,max_iter,lower_bound,upper_bound,variables_no,fobj)
% initialize Silverback
Silverback=[];
Silverback_Score=inf;
%Initialize the first random population of Gorilla
X=initialization(pop_size,variables_no,upper_bound,lower_bound);
convergence_curve=zeros(max_iter,1);
for i=1:pop_size
Pop_Fit(i)=fobj(X(i,:));%#ok
if Pop_Fit(i)<Silverback_Score
Silverback_Score=Pop_Fit(i);
Silverback=X(i,:);
end
end
GX=X(:,:);
lb=ones(1,variables_no).*lower_bound;
ub=ones(1,variables_no).*upper_bound;
%% Controlling parameter
p=0.03;
Beta=3;
w=0.8;
%%Main loop
for It=1:max_iter
a=(cos(2*rand)+1)*(1-It/max_iter);
C=a*(2*rand-1);
%% Exploration:
for i=1:pop_size
if rand<p
GX(i,:) =(ub-lb)*rand+lb;
else
if rand>=0.5
Z = unifrnd(-a,a,1,variables_no);
H=Z.*X(i,:);
GX(i,:)=(rand-a)*X(randi([1,pop_size]),:)+C.*H;
else
GX(i,:)=X(i,:)-C.*(C*(X(i,:)- GX(randi([1,pop_size]),:))+rand*(X(i,:)-GX(randi([1,pop_size]),:))); %ok ok
end
end
end
GX = boundaryCheck(GX, lower_bound, upper_bound);
% Group formation operation
for i=1:pop_size
New_Fit= fobj(GX(i,:));
if New_Fit<Pop_Fit(i)
Pop_Fit(i)=New_Fit;
X(i,:)=GX(i,:);
end
if New_Fit<Silverback_Score
Silverback_Score=New_Fit;
Silverback=GX(i,:);
end
end
%% Exploitation:
for i=1:pop_size
if a>=w
g=2^C;
delta= (abs(mean(GX)).^g).^(1/g);
GX(i,:)=C*delta.*(X(i,:)-Silverback)+X(i,:);
else
if rand>=0.5
h=randn(1,variables_no);
else
h=randn(1,1);
end
r1=rand;
GX(i,:)= Silverback-(Silverback*(2*r1-1)-X(i,:)*(2*r1-1)).*(Beta*h);
end
end
GX = boundaryCheck(GX, lower_bound, upper_bound);
% Group formation operation
for i=1:pop_size
New_Fit= fobj(GX(i,:));
if New_Fit<Pop_Fit(i)
Pop_Fit(i)=New_Fit;
X(i,:)=GX(i,:);
end
if New_Fit<Silverback_Score
Silverback_Score=New_Fit;
Silverback=GX(i,:);
end
end
convergence_curve(It)=Silverback_Score;
% fprintf("In Iteration %d, best estimation of the global optimum is %4.4f \n ", It,Silverback_Score );
end
end
%%
function [ X ]=initialization(N,dim,ub,lb)
Boundary_no= size(ub,2); % numnber of boundaries
% If the boundaries of all variables are equal and user enter a signle
% number for both ub and lb
if Boundary_no==1
X=rand(N,dim).*(ub-lb)+lb;
end
% If each variable has a different lb and ub
if Boundary_no>1
for i=1:dim
ub_i=ub(i);
lb_i=lb(i);
X(:,i)=rand(N,1).*(ub_i-lb_i)+lb_i;
end
end
end
%%
function [ X ] = boundaryCheck(X, lb, ub)
for i=1:size(X,1)
FU=X(i,:)>ub;
FL=X(i,:)<lb;
X(i,:)=(X(i,:).*(~(FU+FL)))+ub.*FU+lb.*FL;
end
end
5、灰狼优化算法
% Grey Wolf Optimizer
function [Alpha_score,Alpha_pos,Convergence_curve]=GWO(SearchAgents_no,Max_iter,lb,ub,dim,fobj)
% initialize alpha, beta, and delta_pos
Alpha_pos=zeros(1,dim);
Alpha_score=inf; %change this to -inf for maximization problems
Beta_pos=zeros(1,dim);
Beta_score=inf; %change this to -inf for maximization problems
Delta_pos=zeros(1,dim);
Delta_score=inf; %change this to -inf for maximization problems
%Initialize the positions of search agents
Positions=initialization(SearchAgents_no,dim,ub,lb);
Convergence_curve=zeros(1,Max_iter);
l=0;% Loop counter
% Main loop
while l<Max_iter
for i=1:size(Positions,1)
% Return back the search agents that go beyond the boundaries of the search space
Flag4ub=Positions(i,:)>ub;
Flag4lb=Positions(i,:)<lb;
Positions(i,:)=(Positions(i,:).*(~(Flag4ub+Flag4lb)))+ub.*Flag4ub+lb.*Flag4lb;
% Calculate objective function for each search agent
fitness=fobj(Positions(i,:));
% Update Alpha, Beta, and Delta
if fitness<Alpha_score
Alpha_score=fitness; % Update alpha
Alpha_pos=Positions(i,:);
end
if fitness>Alpha_score && fitness<Beta_score
Beta_score=fitness; % Update beta
Beta_pos=Positions(i,:);
end
if fitness>Alpha_score && fitness>Beta_score && fitness<Delta_score
Delta_score=fitness; % Update delta
Delta_pos=Positions(i,:);
end
end
a=2-l*((2)/Max_iter); % a decreases linearly fron 2 to 0
% Update the Position of search agents including omegas
for i=1:size(Positions,1)
for j=1:size(Positions,2)
r1=rand(); % r1 is a random number in [0,1]
r2=rand(); % r2 is a random number in [0,1]
A1=2*a*r1-a; % Equation (3.3)
C1=2*r2; % Equation (3.4)
D_alpha=abs(C1*Alpha_pos(j)-Positions(i,j)); % Equation (3.5)-part 1
X1=Alpha_pos(j)-A1*D_alpha; % Equation (3.6)-part 1
r1=rand();
r2=rand();
A2=2*a*r1-a; % Equation (3.3)
C2=2*r2; % Equation (3.4)
D_beta=abs(C2*Beta_pos(j)-Positions(i,j)); % Equation (3.5)-part 2
X2=Beta_pos(j)-A2*D_beta; % Equation (3.6)-part 2
r1=rand();
r2=rand();
A3=2*a*r1-a; % Equation (3.3)
C3=2*r2; % Equation (3.4)
D_delta=abs(C3*Delta_pos(j)-Positions(i,j)); % Equation (3.5)-part 3
X3=Delta_pos(j)-A3*D_delta; % Equation (3.5)-part 3
Positions(i,j)=(X1+X2+X3)/3;% Equation (3.7)
end
end
l=l+1;
Convergence_curve(l)=Alpha_score;
end
%%
function Positions=initialization(SearchAgents_no,dim,ub,lb)
Boundary_no= size(ub,2); % numnber of boundaries
% If the boundaries of all variables are equal and user enter a signle
% number for both ub and lb
if Boundary_no==1
Positions=rand(SearchAgents_no,dim).*(ub-lb)+lb;
end
% If each variable has a different lb and ub
if Boundary_no>1
for i=1:dim
ub_i=ub(i);
lb_i=lb(i);
Positions(:,i)=rand(SearchAgents_no,1).*(ub_i-lb_i)+lb_i;
end
end
6、基于改进蝗虫优化算法
function [TargetFitness,TargetPosition,Convergence_curve,Trajectories,fitness_history, position_history]=IGOA(N, Max_iter, lb,ub, dim, fobj)
% tic
% disp('GOA is now estimating the global optimum for your problem....')
flag=0;
if size(ub,2)==1
ub=ones(dim,1)*ub;
lb=ones(dim,1)*lb;
else
ub=ub';
lb=lb';
end
if (rem(dim,2)~=0) % this algorithm should be run with a even number of variables. This line is to handle odd number of variables
dim = dim+1;
% ub = [ub'; 100];
% lb = [lb'; -100];
ub(dim)=100;
lb(dim)=-100;
flag=1;
end
%Initialize the population of grasshoppers
GrassHopperPositions=initialization(N,dim,ub,lb);
GrassHopperFitness = zeros(1,N);
fitness_history=zeros(N,Max_iter);
position_history=zeros(N,Max_iter,dim);
Convergence_curve=zeros(1,Max_iter);
Trajectories=zeros(N,Max_iter);
cMax=1;
cMin=0.00004;
%Calculate the fitness of initial grasshoppers
for i=1:size(GrassHopperPositions,1)
if flag == 1
GrassHopperFitness(1,i)=fobj(GrassHopperPositions(i,1:end-1));
else
GrassHopperFitness(1,i)=fobj(GrassHopperPositions(i,:));
end
fitness_history(i,1)=GrassHopperFitness(1,i);
position_history(i,1,:)=GrassHopperPositions(i,:);
Trajectories(:,1)=GrassHopperPositions(:,1);
end
[sorted_fitness,sorted_indexes]=sort(GrassHopperFitness);
% Find the best grasshopper (target) in the first population
for newindex=1:N
Sorted_grasshopper(newindex,:)=GrassHopperPositions(sorted_indexes(newindex),:);
end
TargetPosition=Sorted_grasshopper(1,:);
TargetFitness=sorted_fitness(1);
% Main loop
l=2; % Start from the second iteration since the first iteration was dedicated to calculating the fitness of antlions
while l<Max_iter+1
c=cMax-l*((cMax-cMin)/Max_iter); % Eq. (2.8) in the paper
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
for i=1:size(GrassHopperPositions,1)
temp= GrassHopperPositions';
% for k=1:2:dim
S_i=zeros(dim,1);
for j=1:N
if i~=j
Dist=distance(temp(:,j), temp(:,i)); % Calculate the distance between two grasshoppers
r_ij_vec=(temp(:,j)-temp(:,i))/(Dist+eps); % xj-xi/dij in Eq. (2.7)
xj_xi=2+rem(Dist,2); % |xjd - xid| in Eq. (2.7)
s_ij=((ub - lb).*c/2).*S_func(xj_xi).*r_ij_vec; % The first part inside the big bracket in Eq. (2.7)
S_i=S_i+s_ij;
end
end
S_i_total = S_i;
% end
X_new = c * S_i_total'+ (TargetPosition); % Eq. (2.7) in the paper
GrassHopperPositions_temp(i,:)=X_new';
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% GrassHopperPositions
GrassHopperPositions=GrassHopperPositions_temp;
for i=1:size(GrassHopperPositions,1)
% Relocate grasshoppers that go outside the search space
Tp=GrassHopperPositions(i,:)>ub';Tm=GrassHopperPositions(i,:)<lb';GrassHopperPositions(i,:)=(GrassHopperPositions(i,:).*(~(Tp+Tm)))+ub'.*Tp+lb'.*Tm;
% Calculating the objective values for all grasshoppers
if flag == 1
GrassHopperFitness(1,i)=fobj(GrassHopperPositions(i,1:end-1));
else
GrassHopperFitness(1,i)=fobj(GrassHopperPositions(i,:));
end
fitness_history(i,l)=GrassHopperFitness(1,i);
position_history(i,l,:)=GrassHopperPositions(i,:);
Trajectories(:,l)=GrassHopperPositions(:,1);
% Update the target
if GrassHopperFitness(1,i)<TargetFitness
TargetPosition=GrassHopperPositions(i,:);
TargetFitness=GrassHopperFitness(1,i);
end
end
Convergence_curve(l)=TargetFitness;
% disp(['In iteration #', num2str(l), ' , target''s objective = ', num2str(TargetFitness)])
l = l + 1;
end
if (flag==1)
TargetPosition = TargetPosition(1:dim-1);
end
% time=toc
end
%%
function d = distance(a,b)
% DISTANCE - computes Euclidean distance matrix
%
% E = distance(A,B)
%
% A - (DxM) matrix
% B - (DxN) matrix
%
% Returns:
% E - (MxN) Euclidean distances between vectors in A and B
%
%
% Description :
% This fully vectorized (VERY FAST!) m-file computes the
% Euclidean distance between two vectors by:
%
% ||A-B|| = sqrt ( ||A||^2 + ||B||^2 - 2*A.B )
%
% Example :
% A = rand(400,100); B = rand(400,200);
% d = distance(A,B);
% Author : Roland Bunschoten
% University of Amsterdam
% Intelligent Autonomous Systems (IAS) group
% Kruislaan 403 1098 SJ Amsterdam
% tel.(+31)20-5257524
% bunschot@wins.uva.nl
% Last Rev : Oct 29 16:35:48 MET DST 1999
% Tested : PC Matlab v5.2 and Solaris Matlab v5.3
% Thanx : Nikos Vlassis
% Copyright notice: You are free to modify, extend and distribute
% this code granted that the author of the original code is
% mentioned as the original author of the code.
if (nargin ~= 2)
error('Not enough input arguments');
end
if (size(a,1) ~= size(b,1))
error('A and B should be of same dimensionality');
end
aa=sum(a.*a,1); bb=sum(b.*b,1); ab=a'*b;
d = sqrt(abs(repmat(aa',[1 size(bb,2)]) + repmat(bb,[size(aa,2) 1]) - 2*ab));
end
%%
function [X]=initialization(N,dim,up,down)
if size(up,1)==1
X=rand(N,dim).*(up-down)+down;
end
if size(up,1)>1
for i=1:dim
high=up(i);low=down(i);
X(:,i)=rand(1,N).*(high-low)+low;
end
end
end
%%
function o=S_func(r)
f=0.5;
l=1.5;
o=f*exp(-r/l)-exp(-r); % Eq. (2.3) in the paper
end
7、改进的灰狼算法
% Improved Grey Wolf Optimizer (I-GWO)
function [Alpha_score,Alpha_pos,Convergence_curve]=IGWO(N,Max_iter,lb,ub,dim,fobj)
lu = [lb .* ones(1, dim); ub .* ones(1, dim)];
% Initialize alpha, beta, and delta positions
Alpha_pos=zeros(1,dim);
Alpha_score=inf; %change this to -inf for maximization problems
Beta_pos=zeros(1,dim);
Beta_score=inf; %change this to -inf for maximization problems
Delta_pos=zeros(1,dim);
Delta_score=inf; %change this to -inf for maximization problems
% Initialize the positions of wolves
Positions=initialization(N,dim,ub,lb);
Positions = boundConstraint (Positions, Positions, lu);
% Calculate objective function for each wolf
for i=1:size(Positions,1)
Fit(i) = fobj(Positions(i,:));
end
% Personal best fitness and position obtained by each wolf
pBestScore = Fit;
pBest = Positions;
neighbor = zeros(N,N);
Convergence_curve=zeros(1,Max_iter);
iter = 0;% Loop counter
%% Main loop
while iter < Max_iter
for i=1:size(Positions,1)
fitness = Fit(i);
% Update Alpha, Beta, and Delta
if fitness<Alpha_score
Alpha_score=fitness; % Update alpha
Alpha_pos=Positions(i,:);
end
if fitness>Alpha_score && fitness<Beta_score
Beta_score=fitness; % Update beta
Beta_pos=Positions(i,:);
end
if fitness>Alpha_score && fitness>Beta_score && fitness<Delta_score
Delta_score=fitness; % Update delta
Delta_pos=Positions(i,:);
end
end
%% Calculate the candiadate position Xi-GWO
a=2-iter*((2)/Max_iter); % a decreases linearly from 2 to 0
% Update the Position of search agents including omegas
for i=1:size(Positions,1)
for j=1:size(Positions,2)
r1=rand(); % r1 is a random number in [0,1]
r2=rand(); % r2 is a random number in [0,1]
A1=2*a*r1-a; % Equation (3.3)
C1=2*r2; % Equation (3.4)
D_alpha=abs(C1*Alpha_pos(j)-Positions(i,j)); % Equation (3.5)-part 1
X1=Alpha_pos(j)-A1*D_alpha; % Equation (3.6)-part 1
r1=rand();
r2=rand();
A2=2*a*r1-a; % Equation (3.3)
C2=2*r2; % Equation (3.4)
D_beta=abs(C2*Beta_pos(j)-Positions(i,j)); % Equation (3.5)-part 2
X2=Beta_pos(j)-A2*D_beta; % Equation (3.6)-part 2
r1=rand();
r2=rand();
A3=2*a*r1-a; % Equation (3.3)
C3=2*r2; % Equation (3.4)
D_delta=abs(C3*Delta_pos(j)-Positions(i,j)); % Equation (3.5)-part 3
X3=Delta_pos(j)-A3*D_delta; % Equation (3.5)-part 3
X_GWO(i,j)=(X1+X2+X3)/3; % Equation (3.7)
end
X_GWO(i,:) = boundConstraint(X_GWO(i,:), Positions(i,:), lu);
Fit_GWO(i) = fobj(X_GWO(i,:));
end
%% Calculate the candiadate position Xi-DLH
radius = pdist2(Positions, X_GWO, 'euclidean'); % Equation (10)
dist_Position = squareform(pdist(Positions));
r1 = randperm(N,N);
for t=1:N
neighbor(t,:) = (dist_Position(t,:)<=radius(t,t));
[~,Idx] = find(neighbor(t,:)==1); % Equation (11)
random_Idx_neighbor = randi(size(Idx,2),1,dim);
for d=1:dim
X_DLH(t,d) = Positions(t,d) + rand .*(Positions(Idx(random_Idx_neighbor(d)),d)...
- Positions(r1(t),d)); % Equation (12)
end
X_DLH(t,:) = boundConstraint(X_DLH(t,:), Positions(t,:), lu);
Fit_DLH(t) = fobj(X_DLH(t,:));
end
%% Selection
tmp = Fit_GWO < Fit_DLH; % Equation (13)
tmp_rep = repmat(tmp',1,dim);
tmpFit = tmp .* Fit_GWO + (1-tmp) .* Fit_DLH;
tmpPositions = tmp_rep .* X_GWO + (1-tmp_rep) .* X_DLH;
%% Updating
tmp = pBestScore <= tmpFit; % Equation (13)
tmp_rep = repmat(tmp',1,dim);
pBestScore = tmp .* pBestScore + (1-tmp) .* tmpFit;
pBest = tmp_rep .* pBest + (1-tmp_rep) .* tmpPositions;
Fit = pBestScore;
Positions = pBest;
%%
iter = iter+1;
neighbor = zeros(N,N);
Convergence_curve(iter) = Alpha_score;
end
end
function Positions=initialization(SearchAgents_no,dim,ub,lb)
Boundary_no= size(ub,2); % numnber of boundaries
% If the boundaries of all variables are equal and user enter a signle
% number for both ub and lb
if Boundary_no==1
Positions=rand(SearchAgents_no,dim).*(ub-lb)+lb;
end
% If each variable has a different lb and ub
if Boundary_no>1
for i=1:dim
ub_i=ub(i);
lb_i=lb(i);
Positions(:,i)=rand(SearchAgents_no,1).*(ub_i-lb_i)+lb_i;
end
end
end
%This function is used for L-SHADE bound checking
function vi = boundConstraint (vi, pop, lu)
% if the boundary constraint is violated, set the value to be the middle
% of the previous value and the bound
%
[NP, D] = size(pop); % the population size and the problem's dimension
%% check the lower bound
xl = repmat(lu(1, :), NP, 1);
pos = vi < xl;
vi(pos) = (pop(pos) + xl(pos)) / 2;
%% check the upper bound
xu = repmat(lu(2, :), NP, 1);
pos = vi > xu;
vi(pos) = (pop(pos) + xu(pos)) / 2;
end
8、飞蛾火焰优化算法
% To run MFO: [Best_score,Best_pos,cg_curve]=MFO(SearchAgents_no,Max_iteration,lb,ub,dim,fobj)
%______________________________________________________________________________________________
function [Best_flame_score,Best_flame_pos,Convergence_curve]=MFO(N,Max_iteration,lb,ub,dim,fobj)
% display('MFO is optimizing your problem');
%Initialize the positions of moths
Moth_pos=initialization(N,dim,ub,lb);
Convergence_curve=zeros(1,Max_iteration);
Iteration=1;
% Main loop
while Iteration<Max_iteration+1
% Number of flames Eq. (3.14) in the paper
Flame_no=round(N-Iteration*((N-1)/Max_iteration));
for i=1:size(Moth_pos,1)
% Check if moths go out of the search spaceand bring it back
Flag4ub=Moth_pos(i,:)>ub;
Flag4lb=Moth_pos(i,:)<lb;
Moth_pos(i,:)=(Moth_pos(i,:).*(~(Flag4ub+Flag4lb)))+ub.*Flag4ub+lb.*Flag4lb;
% Calculate the fitness of moths
Moth_fitness(1,i)=fobj(Moth_pos(i,:));
end
if Iteration==1
% Sort the first population of moths
[fitness_sorted I]=sort(Moth_fitness);
sorted_population=Moth_pos(I,:);
% Update the flames
best_flames=sorted_population;
best_flame_fitness=fitness_sorted;
else
% Sort the moths
double_population=[previous_population;best_flames];
double_fitness=[previous_fitness best_flame_fitness];
[double_fitness_sorted I]=sort(double_fitness);
double_sorted_population=double_population(I,:);
fitness_sorted=double_fitness_sorted(1:N);
sorted_population=double_sorted_population(1:N,:);
% Update the flames
best_flames=sorted_population;
best_flame_fitness=fitness_sorted;
end
% Update the position best flame obtained so far
Best_flame_score=fitness_sorted(1);
Best_flame_pos=sorted_population(1,:);
previous_population=Moth_pos;
previous_fitness=Moth_fitness;
% a linearly dicreases from -1 to -2 to calculate t in Eq. (3.12)
a=-1+Iteration*((-1)/Max_iteration);
for i=1:size(Moth_pos,1)
for j=1:size(Moth_pos,2)
if i<=Flame_no % Update the position of the moth with respect to its corresponsing flame
% D in Eq. (3.13)
distance_to_flame=abs(sorted_population(i,j)-Moth_pos(i,j));
b=1;
t=(a-1)*rand+1;
% Eq. (3.12)
Moth_pos(i,j)=distance_to_flame*exp(b.*t).*cos(t.*2*pi)+sorted_population(i,j);
end
if i>Flame_no % Upaate the position of the moth with respct to one flame
% Eq. (3.13)
distance_to_flame=abs(sorted_population(i,j)-Moth_pos(i,j));
b=1;
t=(a-1)*rand+1;
% Eq. (3.12)
Moth_pos(i,j)=distance_to_flame*exp(b.*t).*cos(t.*2*pi)+sorted_population(Flame_no,j);
end
end
end
Convergence_curve(Iteration)=Best_flame_score;
% Display the iteration and best optimum obtained so far
% if mod(Iteration,50)==0
% display(['At iteration ', num2str(Iteration), ' the best fitness is ', num2str(Best_flame_score)]);
% end
Iteration=Iteration+1;
end
end
function X=initialization(SearchAgents_no,dim,ub,lb)
Boundary_no= size(ub,2); % numnber of boundaries
% If the boundaries of all variables are equal and user enter a signle
% number for both ub and lb
if Boundary_no==1
X=rand(SearchAgents_no,dim).*(ub-lb)+lb;
end
% If each variable has a different lb and ub
if Boundary_no>1
for i=1:dim
ub_i=ub(i);
lb_i=lb(i);
X(:,i)=rand(SearchAgents_no,1).*(ub_i-lb_i)+lb_i;
end
end
end
9、多元宇宙优化算法
% To run MVO: [Best_score,Best_pos,cg_curve]=MVO(Universes_no,Max_iteration,lb,ub,dim,fobj)
%__________________________________________
function [Best_universe_Inflation_rate,Best_universe,Convergence_curve]=MVO(N,Max_time,lb,ub,dim,fobj)
%Two variables for saving the position and inflation rate (fitness) of the best universe
Best_universe=zeros(1,dim);
Best_universe_Inflation_rate=inf;
%Initialize the positions of universes
Universes=initialization(N,dim,ub,lb);
%Minimum and maximum of Wormhole Existence Probability (min and max in
% Eq.(3.3) in the paper
WEP_Max=1;
WEP_Min=0.2;
Convergence_curve=zeros(1,Max_time);
%Iteration(time) counter
Time=1;
%Main loop
while Time<Max_time+1
%Eq. (3.3) in the paper
WEP=WEP_Min+Time*((WEP_Max-WEP_Min)/Max_time);
%Travelling Distance Rate (Formula): Eq. (3.4) in the paper
TDR=1-((Time)^(1/6)/(Max_time)^(1/6));
%Inflation rates (I) (fitness values)
Inflation_rates=zeros(1,size(Universes,1));
for i=1:size(Universes,1)
%Boundary checking (to bring back the universes inside search
% space if they go beyoud the boundaries
Flag4ub=Universes(i,:)>ub;
Flag4lb=Universes(i,:)<lb;
Universes(i,:)=(Universes(i,:).*(~(Flag4ub+Flag4lb)))+ub.*Flag4ub+lb.*Flag4lb;
%Calculate the inflation rate (fitness) of universes
Inflation_rates(1,i)=fobj(Universes(i,:));
%Elitism
if Inflation_rates(1,i)<Best_universe_Inflation_rate
Best_universe_Inflation_rate=Inflation_rates(1,i);
Best_universe=Universes(i,:);
end
end
[sorted_Inflation_rates,sorted_indexes]=sort(Inflation_rates);
for newindex=1:N
Sorted_universes(newindex,:)=Universes(sorted_indexes(newindex),:);
end
%Normaized inflation rates (NI in Eq. (3.1) in the paper)
normalized_sorted_Inflation_rates=normr(sorted_Inflation_rates);
Universes(1,:)= Sorted_universes(1,:);
%Update the Position of universes
for i=2:size(Universes,1)%Starting from 2 since the firt one is the elite
Back_hole_index=i;
for j=1:size(Universes,2)
r1=rand();
if r1<normalized_sorted_Inflation_rates(i)
White_hole_index=RouletteWheelSelection(-sorted_Inflation_rates);% for maximization problem -sorted_Inflation_rates should be written as sorted_Inflation_rates
if White_hole_index==-1
White_hole_index=1;
end
%Eq. (3.1) in the paper
Universes(Back_hole_index,j)=Sorted_universes(White_hole_index,j);
end
if (size(lb,2)==1)
%Eq. (3.2) in the paper if the boundaries are all the same
r2=rand();
if r2<WEP
r3=rand();
if r3<0.5
Universes(i,j)=Best_universe(1,j)+TDR*((ub-lb)*rand+lb);
end
if r3>0.5
Universes(i,j)=Best_universe(1,j)-TDR*((ub-lb)*rand+lb);
end
end
end
if (size(lb,2)~=1)
%Eq. (3.2) in the paper if the upper and lower bounds are
%different for each variables
r2=rand();
if r2<WEP
r3=rand();
if r3<0.5
Universes(i,j)=Best_universe(1,j)+TDR*((ub(j)-lb(j))*rand+lb(j));
end
if r3>0.5
Universes(i,j)=Best_universe(1,j)-TDR*((ub(j)-lb(j))*rand+lb(j));
end
end
end
end
end
%Update the convergence curve
Convergence_curve(Time)=Best_universe_Inflation_rate;
%Print the best universe details after every 50 iterations
% if mod(Time,50)==0
% display(['At iteration ', num2str(Time), ' the best universes fitness is ', num2str(Best_universe_Inflation_rate)]);
% end
Time=Time+1;
end
end
%%
function X=initialization(SearchAgents_no,dim,ub,lb)
Boundary_no= size(ub,2); % numnber of boundaries
% If the boundaries of all variables are equal and user enter a signle
% number for both ub and lb
if Boundary_no==1
X=rand(SearchAgents_no,dim).*(ub-lb)+lb;
end
% If each variable has a different lb and ub
if Boundary_no>1
for i=1:dim
ub_i=ub(i);
lb_i=lb(i);
X(:,i)=rand(SearchAgents_no,1).*(ub_i-lb_i)+lb_i;
end
end
end
%%
function choice = RouletteWheelSelection(weights)
accumulation = cumsum(weights);
p = rand() * accumulation(end);
chosen_index = -1;
for index = 1 : length(accumulation)
if (accumulation(index) > p)
chosen_index = index;
break;
end
end
choice = chosen_index;
end
11、北方苍鹰优化算法
% " Optimizer"
%%
function [Score,Best_pos,NGO_curve]=NGO(Search_Agents,Max_iterations,Lowerbound,Upperbound,dimensions,objective)
tic
% disp('PLEASE WAIT, The program is running.')
Lowerbound=ones(1,dimensions).*(Lowerbound); % Lower limit for variables
Upperbound=ones(1,dimensions).*(Upperbound); % Upper limit for variables
X=[];
X_new=[];
fit=[];
fit_new=[];
NGO_curve=zeros(1,Max_iterations);
%%
for i=1:dimensions
X(:,i) = Lowerbound(i)+rand(Search_Agents,1).*(Upperbound(i) -Lowerbound(i)); % Initial population
end
for i =1:Search_Agents
L=X(i,:);
fit(i)=objective(L); % Fitness evaluation (Explained at the top of the page. )
end
for t=1:Max_iterations % algorithm iteration
%% update: BEST proposed solution
[best , blocation]=min(fit);
if t==1
xbest=X(blocation,:); % Optimal location
fbest=best; % The optimization objective function
elseif best<fbest
fbest=best;
xbest=X(blocation,:);
end
%% UPDATE Northern goshawks based on PHASE1 and PHASE2
for i=1:Search_Agents
%% Phase 1: Exploration
I=round(1+rand);
k=randperm(Search_Agents,1);
P=X(k,:); % Eq. (3)
F_P=fit(k);
if fit(i)> F_P
X_new(i,:)=X(i,:)+rand(1,dimensions) .* (P-I.*X(i,:)); % Eq. (4)
else
X_new(i,:)=X(i,:)+rand(1,dimensions) .* (X(i,:)-P); % Eq. (4)
end
X_new(i,:) = max(X_new(i,:),Lowerbound);X_new(i,:) = min(X_new(i,:),Upperbound);
% update position based on Eq (5)
L=X_new(i,:);
fit_new(i)=objective(L);
if(fit_new(i)<fit(i))
X(i,:) = X_new(i,:);
fit(i) = fit_new(i);
end
%% END PHASE 1
%% PHASE 2 Exploitation
R=0.02*(1-t/Max_iterations);% Eq.(6)
X_new(i,:)= X(i,:)+ (-R+2*R*rand(1,dimensions)).*X(i,:);% Eq.(7)
X_new(i,:) = max(X_new(i,:),Lowerbound);X_new(i,:) = min(X_new(i,:),Upperbound);
% update position based on Eq (8)
L=X_new(i,:);
fit_new(i)=objective(L);
if(fit_new(i)<fit(i))
X(i,:) = X_new(i,:);
fit(i) = fit_new(i);
end
%% END PHASE 2
end% end for i=1:N
%%
%% SAVE BEST SCORE
best_so_far(t)=fbest; % save best solution so far
average(t) = mean (fit);
Score=fbest;
Best_pos=xbest;
NGO_curve(t)=Score;
end
%%
end
12、鹈鹕优化算法(POA)
%%% Designed and Developed by Pavel Trojovský and Mohammad Dehghani %%%
function[Best_score,Best_pos,POA_curve]=POA(SearchAgents,Max_iterations,lowerbound,upperbound,dimension,fitness)
lowerbound=ones(1,dimension).*(lowerbound); % Lower limit for variables
upperbound=ones(1,dimension).*(upperbound); % Upper limit for variables
%% INITIALIZATION
for i=1:dimension
X(:,i) = lowerbound(i)+rand(SearchAgents,1).*(upperbound(i) - lowerbound(i)); % Initial population
end
for i =1:SearchAgents
L=X(i,:);
fit(i)=fitness(L);
end
%%
for t=1:Max_iterations
%% update the best condidate solution
[best , location]=min(fit);
if t==1
Xbest=X(location,:); % Optimal location
fbest=best; % The optimization objective function
elseif best<fbest
fbest=best;
Xbest=X(location,:);
end
%% UPDATE location of food
X_FOOD=[];
k=randperm(SearchAgents,1);
X_FOOD=X(k,:);
F_FOOD=fit(k);
%%
for i=1:SearchAgents
%% PHASE 1: Moving towards prey (exploration phase)
I=round(1+rand(1,1));
if fit(i)> F_FOOD
X_new=X(i,:)+ rand(1,1).*(X_FOOD-I.* X(i,:)); %Eq(4)
else
X_new=X(i,:)+ rand(1,1).*(X(i,:)-1.*X_FOOD); %Eq(4)
end
X_new= max(X_new,lowerbound);X_new = min(X_new,upperbound);
% Updating X_i using (5)
f_new = fitness(X_new);
if f_new <= fit (i)
X(i,:) = X_new;
fit (i)=f_new;
end
%% END PHASE 1: Moving towards prey (exploration phase)
%% PHASE 2: Winging on the water surface (exploitation phase)
X_new=X(i,:)+0.2*(1-t/Max_iterations).*(2*rand(1,dimension)-1).*X(i,:);% Eq(6)
X_new= max(X_new,lowerbound);X_new = min(X_new,upperbound);
% Updating X_i using (7)
f_new = fitness(X_new);
if f_new <= fit (i)
X(i,:) = X_new;
fit (i)=f_new;
end
%% END PHASE 2: Winging on the water surface (exploitation phase)
end
best_so_far(t)=fbest;
average(t) = mean (fit);
end
Best_score=fbest;
Best_pos=Xbest;
POA_curve=best_so_far;
end
%%
13、量子群算法
%% 基础粒子群优化算法
function [gBestScore,gBest,cg_curve]=PSO(N,Max_iteration,lb,ub,dim,fobj)
%PSO Infotmation
% if(max(size(ub)) == 1)
ub = ub.*ones(1,dim);
lb = lb.*ones(1,dim);
% end
Vmax=6;
noP=N;
wMax=0.9;
wMin=0.6;
c1=2;
c2=2;
% Initializations
iter=Max_iteration;
vel=zeros(noP,dim);
pBestScore=zeros(noP);
pBest=zeros(noP,dim);
gBest=zeros(1,dim);
cg_curve=zeros(1,iter);
vel=zeros(N,dim);
pos=zeros(N,dim);
%Initialization
for i=1:size(pos,1)
for j=1:size(pos,2)
pos(i,j)=(ub(j)-lb(j))*rand()+lb(j);
vel(i,j)=0.3*rand();
end
end
for i=1:noP
pBestScore(i)=inf;
end
% Initialize gBestScore for a minimization problem
gBestScore=inf;
for l=1:iter
% Return back the particles that go beyond the boundaries of the search
% space
Flag4ub=pos(i,:)>ub;
Flag4lb=pos(i,:)<lb;
pos(i,:)=(pos(i,:).*(~(Flag4ub+Flag4lb)))+ub.*Flag4ub+lb.*Flag4lb;
for i=1:size(pos,1)
%Calculate objective function for each particle
fitness=fobj(pos(i,:));
if(pBestScore(i)>fitness)
pBestScore(i)=fitness;
pBest(i,:)=pos(i,:);
end
if(gBestScore>fitness)
gBestScore=fitness;
gBest=pos(i,:);
end
end
%Update the W of PSO
w=wMax-l*((wMax-wMin)/iter);
%Update the Velocity and Position of particles
for i=1:size(pos,1)
for j=1:size(pos,2)
vel(i,j)=w*vel(i,j)+c1*rand()*(pBest(i,j)-pos(i,j))+c2*rand()*(gBest(j)-pos(i,j));
if(vel(i,j)>Vmax)
vel(i,j)=Vmax;
end
if(vel(i,j)<-Vmax)
vel(i,j)=-Vmax;
end
pos(i,j)=pos(i,j)+vel(i,j);
end
end
cg_curve(l)=gBestScore;
end
end
14、模拟退火
%% 模拟退火算法
function [Best_score,Best_pos,curve]=SA(Mmax,l,u,dim,fobj)
%function [x0,f0]=sim_anl(f,x0,l,u,Mmax,TolFun)
% 输入:
% fobj = 适应度函数
% x0 = 输入种群
% l = 种群下边界
% u = 种群上边界
% Mmax = 最大温度
% TolFun = 优化变化容忍度
%
%
% 输出:
% x0 = 输出优化后的种群
% f0 = 输出优化后的种群的适应度值
TolFun = 10E-10;%模拟退火容忍度
x0 = (u-l).*rand(1,dim)+l;%随机初始化模拟退火;
f = fobj;%适应度函数
x=x0;
fx=feval(f,x);%计算适应度值
f0=fx;
count = 1;%用于记录收敛曲线标记
%模拟退火主要步骤
for m=1:Mmax
T=m/Mmax; %温度
mu=10^(T*1000);
%For each temperature we take 100 test points to simulate reach termal
for k=0:100
dx=mu_inv(2*rand(1,dim)-1,mu).*(u-l);
x1=x+dx;
%边界处理防止越界
x1=(x1 < l).*l+(l <= x1).*(x1 <= u).*x1+(u < x1).*u;
%计算当前位置适应度值和适应度值偏差
fx1=feval(f,x1);df=fx1-fx;
% 如果df<0则接受该解，如果大于0 则利用Metropolis准则进行判断是否接受
if (df < 0 || rand < exp(-T*df/(abs(fx)+eps)/TolFun))==1
x=x1;fx=fx1;
end
%判断当前解是否更优，更优则更新.
if fx1 < f0 ==1
x0=x1;f0=fx1;
end
end
curve(count) = f0;
count = count+1;
end
Best_pos = x0;
Best_score = f0;
end
function x=mu_inv(y,mu)
%模拟退火产生新位置偏差
x=(((1+mu).^abs(y)-1)/mu).*sign(y);
end
15、正弦余弦算法
% To run SCA: [Best_score,Best_pos,cg_curve]=SCA(SearchAgents_no,Max_iteration,lb,ub,dim,fobj)
%______________________________________________________________________________________________
function [Destination_fitness,Destination_position,Convergence_curve]=SCA(N,Max_iteration,lb,ub,dim,fobj)
% display('SCA is optimizing your problem');
%Initialize the set of random solutions
X=initialization(N,dim,ub,lb);
Destination_position=zeros(1,dim);
Destination_fitness=inf;
Convergence_curve=zeros(1,Max_iteration);
Objective_values = zeros(1,size(X,1));
% Calculate the fitness of the first set and find the best one
for i=1:size(X,1)
Objective_values(1,i)=fobj(X(i,:));
if i==1
Destination_position=X(i,:);
Destination_fitness=Objective_values(1,i);
elseif Objective_values(1,i)<Destination_fitness
Destination_position=X(i,:);
Destination_fitness=Objective_values(1,i);
end
All_objective_values(1,i)=Objective_values(1,i);
end
%Main loop
t=2; % start from the second iteration since the first iteration was dedicated to calculating the fitness
while t<=Max_iteration
% Eq. (3.4)
a = 2;
Max_iteration = Max_iteration;
r1=a-t*((a)/Max_iteration); % r1 decreases linearly from a to 0
% Update the position of solutions with respect to destination
for i=1:size(X,1) % in i-th solution
for j=1:size(X,2) % in j-th dimension
% Update r2, r3, and r4 for Eq. (3.3)
r2=(2*pi)*rand();
r3=2*rand;
r4=rand();
% Eq. (3.3)
if r4<0.5
% Eq. (3.1)
X(i,j)= X(i,j)+(r1*sin(r2)*abs(r3*Destination_position(j)-X(i,j)));
else
% Eq. (3.2)
X(i,j)= X(i,j)+(r1*cos(r2)*abs(r3*Destination_position(j)-X(i,j)));
end
end
end
for i=1:size(X,1)
% Check if solutions go outside the search spaceand bring them back
Flag4ub=X(i,:)>ub;
Flag4lb=X(i,:)<lb;
X(i,:)=(X(i,:).*(~(Flag4ub+Flag4lb)))+ub.*Flag4ub+lb.*Flag4lb;
% Calculate the objective values
Objective_values(1,i)=fobj(X(i,:));
% Update the destination if there is a better solution
if Objective_values(1,i)<Destination_fitness
Destination_position=X(i,:);
Destination_fitness=Objective_values(1,i);
end
end
Convergence_curve(t)=Destination_fitness;
% Display the iteration and best optimum obtained so far
% if mod(t,50)==0
% display(['At iteration ', num2str(t), ' the optimum is ', num2str(Destination_fitness)]);
% end
% Increase the iteration counter
t=t+1;
end
end
%%
function X=initialization(SearchAgents_no,dim,ub,lb)
Boundary_no= size(ub,2); % numnber of boundaries
% If the boundaries of all variables are equal and user enter a signle
% number for both ub and lb
if Boundary_no==1
X=rand(SearchAgents_no,dim).*(ub-lb)+lb;
end
% If each variable has a different lb and ub
if Boundary_no>1
for i=1:dim
ub_i=ub(i);
lb_i=lb(i);
X(:,i)=rand(SearchAgents_no,1).*(ub_i-lb_i)+lb_i;
end
end
end
16、蛇优化(SO)算法
function [fval,Xfood,gbest_t] = SO(N,T, lb,ub,dim,fobj)
%initial
vec_flag=[1,-1];
Threshold=0.25;
Thresold2= 0.6;
C1=0.5;
C2=.05;
C3=2;
if length(lb)<2
X=lb+rand(N,dim)*(ub-lb);
else
X=repmat(lb,N,1)+rand(N,dim).*repmat((ub-lb),N,1);
end
for i=1:N
fitness(i)=fobj(X(i,:));
end
[GYbest, gbest] = min(fitness);
Xfood = X(gbest,:);
%Diving the swarm into two equal groups males and females
Nm=round(N/2);%eq.(2&3)
Nf=N-Nm;
Xm=X(1:Nm,:);
Xf=X(Nm+1:N,:);
fitness_m=fitness(1:Nm);
fitness_f=fitness(Nm+1:N);
[fitnessBest_m, gbest1] = min(fitness_m);
Xbest_m = Xm(gbest1,:);
[fitnessBest_f, gbest2] = min(fitness_f);
Xbest_f = Xf(gbest2,:);
for t = 1:T
Temp=exp(-((t)/T)); %eq.(4)
Q=C1*exp(((t-T)/(T)));%eq.(5)
if Q>1 Q=1; end
% Exploration Phase (no Food)
if Q<Threshold
for i=1:Nm
for j=1:1:dim
rand_leader_index = floor(Nm*rand()+1);
X_randm = Xm(rand_leader_index, :);
flag_index = floor(2*rand()+1);
Flag=vec_flag(flag_index);
Am=exp(-fitness_m(rand_leader_index)/(fitness_m(i)+eps));%eq.(7)
Xnewm(i,j)=X_randm(j)+Flag*C2*Am*((ub(1)-lb(1))*rand+lb(1));%eq.(6)
end
end
for i=1:Nf
for j=1:1:dim
rand_leader_index = floor(Nf*rand()+1);
X_randf = Xf(rand_leader_index, :);
flag_index = floor(2*rand()+1);
Flag=vec_flag(flag_index);
Af=exp(-fitness_f(rand_leader_index)/(fitness_f(i)+eps));%eq.(9)
Xnewf(i,j)=X_randf(j)+Flag*C2*Af*((ub(1)-lb(1))*rand+lb(1));%eq.(8)
end
end
else %Exploitation Phase (Food Exists)
if Temp>Thresold2 %hot
for i=1:Nm
flag_index = floor(2*rand()+1);
Flag=vec_flag(flag_index);
for j=1:1:dim
Xnewm(i,j)=Xfood(j)+C3*Flag*Temp*rand*(Xfood(j)-Xm(i,j));%eq.(10)
end
end
for i=1:Nf
flag_index = floor(2*rand()+1);
Flag=vec_flag(flag_index);
for j=1:1:dim
Xnewf(i,j)=Xfood(j)+Flag*C3*Temp*rand*(Xfood(j)-Xf(i,j));%eq.(10)
end
end
else %cold
if rand>0.6 %fight
for i=1:Nm
for j=1:1:dim
FM=exp(-(fitnessBest_f)/(fitness_m(i)+eps));%eq.(13)
Xnewm(i,j)=Xm(i,j) +C3*FM*rand*(Q*Xbest_f(j)-Xm(i,j));%eq.(11)
end
end
for i=1:Nf
for j=1:1:dim
FF=exp(-(fitnessBest_m)/(fitness_f(i)+eps));%eq.(14)
Xnewf(i,j)=Xf(i,j)+C3*FF*rand*(Q*Xbest_m(j)-Xf(i,j));%eq.(12)
end
end
else%mating
for i=1:Nm
for j=1:1:dim
Mm=exp(-fitness_f(i)/(fitness_m(i)+eps));%eq.(17)
Xnewm(i,j)=Xm(i,j) +C3*rand*Mm*(Q*Xf(i,j)-Xm(i,j));%eq.(15
end
end
for i=1:Nf
for j=1:1:dim
Mf=exp(-fitness_m(i)/(fitness_f(i)+eps));%eq.(18)
Xnewf(i,j)=Xf(i,j) +C3*rand*Mf*(Q*Xm(i,j)-Xf(i,j));%eq.(16)
end
end
flag_index = floor(2*rand()+1);
egg=vec_flag(flag_index);
if egg==1;
[GYworst, gworst] = max(fitness_m);
Xnewm(gworst,:)=lb+rand*(ub-lb);%eq.(19)
[GYworst, gworst] = max(fitness_f);
Xnewf(gworst,:)=lb+rand*(ub-lb);%eq.(20)
end
end
end
end
for j=1:Nm
Flag4ub=Xnewm(j,:)>ub;
Flag4lb=Xnewm(j,:)<lb;
Xnewm(j,:)=(Xnewm(j,:).*(~(Flag4ub+Flag4lb)))+ub.*Flag4ub+lb.*Flag4lb;
y = fobj(Xnewm(j,:));
if y<fitness_m(j)
fitness_m(j)=y;
Xm(j,:)= Xnewm(j,:);
end
end
[Ybest1,gbest1] = min(fitness_m);
for j=1:Nf
Flag4ub=Xnewf(j,:)>ub;
Flag4lb=Xnewf(j,:)<lb;
Xnewf(j,:)=(Xnewf(j,:).*(~(Flag4ub+Flag4lb)))+ub.*Flag4ub+lb.*Flag4lb;
y = fobj(Xnewf(j,:));
if y<fitness_f(j)
fitness_f(j)=y;
Xf(j,:)= Xnewf(j,:);
end
end
[Ybest2,gbest2] = min(fitness_f);
if Ybest1<fitnessBest_m
Xbest_m = Xm(gbest1,:);
fitnessBest_m=Ybest1;
end
if Ybest2<fitnessBest_f
Xbest_f = Xf(gbest2,:);
fitnessBest_f=Ybest2;
end
if Ybest1<Ybest2
gbest_t(t)=min(Ybest1);
else
gbest_t(t)=min(Ybest2);
end
if fitnessBest_m<fitnessBest_f
GYbest=fitnessBest_m;
Xfood=Xbest_m;
else
GYbest=fitnessBest_f;
Xfood=Xbest_f;
end
end
fval = GYbest;
end
17、选择性搜索算法(Selective Search)
function [FoodFitness,FoodPosition,Convergence_curve]=SS(N,Max_iter,lb,ub,dim,fobj)
%Initialize the positions of salps
SalpPositions=initialization(N,dim,ub,lb);
if size(ub,2)==1
ub=ones(dim,1)*ub;
lb=ones(dim,1)*lb;
else
ub=ub';
lb=lb';
end
Convergence_curve = zeros(1,Max_iter);
FoodPosition=zeros(1,dim);
FoodFitness=inf;
%calculate the fitness of initial salps
for i=1:size(SalpPositions,1)
SalpFitness(1,i)=fobj(SalpPositions(i,:));
end
[sorted_salps_fitness,sorted_indexes]=sort(SalpFitness);
for newindex=1:N
Sorted_salps(newindex,:)=SalpPositions(sorted_indexes(newindex),:);
end
FoodPosition=Sorted_salps(1,:);
FoodFitness=sorted_salps_fitness(1);
%Main loop
l=2; % start from the second iteration since the first iteration was dedicated to calculating the fitness of salps
while l<Max_iter+1
c1 = 2*exp(-(4*l/Max_iter)^2); % Eq. (3.2) in the paper
for i=1:size(SalpPositions,1)
SalpPositions= SalpPositions';
if i<=N/2
for j=1:1:dim
c2=rand();
c3=rand();
%%%%%%%%%%%%% % Eq. (3.1) in the paper %%%%%%%%%%%%%%
if c3<0.5
SalpPositions(j,i)=FoodPosition(j)+c1*((ub(j)-lb(j))*c2+lb(j));
else
SalpPositions(j,i)=FoodPosition(j)-c1*((ub(j)-lb(j))*c2+lb(j));
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
end
elseif i>N/2 && i<N+1
point1=SalpPositions(:,i-1);
point2=SalpPositions(:,i);
SalpPositions(:,i)=(point2+point1)/2; % % Eq. (3.4) in the paper
end
SalpPositions= SalpPositions';
end
for i=1:size(SalpPositions,1)
Tp=SalpPositions(i,:)>ub';Tm=SalpPositions(i,:)<lb';
SalpPositions(i,:)=(SalpPositions(i,:).*(~(Tp+Tm)))+ub'.*Tp+lb'.*Tm;
SalpFitness(1,i)=fobj(SalpPositions(i,:));
if SalpFitness(1,i)<FoodFitness
FoodPosition=SalpPositions(i,:);
FoodFitness=SalpFitness(1,i);
end
end
Convergence_curve(l)=FoodFitness;
l = l + 1;
end
end
%%
function X=initialization(SearchAgents_no,dim,ub,lb)
Boundary_no= size(ub,2); % numnber of boundaries
% If the boundaries of all variables are equal and user enter a signle
% number for both ub and lb
if Boundary_no==1
X=rand(SearchAgents_no,dim).*(ub-lb)+lb;
end
% If each variable has a different lb and ub
if Boundary_no>1
for i=1:dim
ub_i=ub(i);
lb_i=lb(i);
X(:,i)=rand(SearchAgents_no,1).*(ub_i-lb_i)+lb_i;
end
end
end
18、麻雀搜索算法（Sparrow Search Algorithm，SSA）
function [fMin , bestX,Convergence_curve ] = SSA(pop, M,c,d,dim,fobj )
P_percent = 0.2; % The population size of producers accounts for "P_percent" percent of the total population size
%生产者占所有种群的0.2
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
pNum = round( pop * P_percent ); % The population size of the producers
%生产者数量取整
lb= c.*ones( 1,dim ); % Lower limit/bounds/ a vector 约束上限
ub= d.*ones( 1,dim ); % Upper limit/bounds/ a vector 约束下限
%Initialization
for i = 1 : pop
x( i, : ) = lb + (ub - lb) .* rand( 1, dim ); %随机初始化n个种群
fit( i ) = fobj( x( i, : ) ) ; %计算所有群体的适应情况，如果求最小值的,越小代表适应度越好
end
% 以下找到最小值对应的麻雀群
pFit = fit;
pX = x; % The individual's best position corresponding to the pFit
[ fMin, bestI ] = min( fit ); % fMin denotes the global optimum fitness value
bestX = x( bestI, : ); % bestX denotes the global optimum position corresponding to fMin
% Start updating the solutions.
for t = 1 : M
[ ans, sortIndex ] = sort( pFit );% Sort.
[fmax,B]=max( pFit );
worse= x(B,:); %找到最差的个体
r2=rand(1); %产生随机数 感觉没有啥科学依据，就是随机数
%大概意思就是在0.8概率内原来种群乘一个小于1的数，种群整体数值缩小了
%大概意思就是在0.2概率内原来种群乘一个小于1的数，种群整体数值+1
%变化后种群的数值还是要限制在约束里面
%对前pNum适应度最好的进行变化 ，即生产者进行变化，可见生产者是挑最好的
if(r2<0.8)
for i = 1 : pNum % Equation (3)
r1=rand(1);
x( sortIndex( i ), : ) = pX( sortIndex( i ), : )*exp(-(i)/(r1*M)); %将种群按适应度排序后更新
x( sortIndex( i ), : ) = Bounds( x( sortIndex( i ), : ), lb, ub ); %将种群限制在约束范围内
fit( sortIndex( i ) ) = fobj( x( sortIndex( i ), : ) );
end
else
for i = 1 : pNum
x( sortIndex( i ), : ) = pX( sortIndex( i ), : )+randn(1)*ones(1,dim);
x( sortIndex( i ), : ) = Bounds( x( sortIndex( i ), : ), lb, ub );
fit( sortIndex( i ) ) = fobj( x( sortIndex( i ), : ) );
end
end
%把经过变化后最好的种群记录下来
[ fMMin, bestII ] = min( fit );
bestXX = x( bestII, : );
%下面是乞讨者
for i = ( pNum + 1 ) : pop % Equation (4)
A=floor(rand(1,dim)*2)*2-1; %产生1和-1的随机数
if( i>(pop/2))
%如果i>种群的一半，代表遍历到适应度靠后的一段，代表这些序列的种群可能在挨饿
x( sortIndex(i ), : )=randn(1)*exp((worse-pX( sortIndex( i ), : ))/(i)^2);
%适应度不好的，即靠后的麻雀乘了一个大于1的数，向外拓展
else
x( sortIndex( i ), : )=bestXX+(abs(( pX( sortIndex( i ), : )-bestXX)))*(A'*(A*A')^(-1))*ones(1,dim);
%这是适应度出去介于生产者之后，又在种群的前半段的,去竞争生产者的食物，在前面最好种群的基础上
%再进行变化一次，在原来的基础上减一些值或者加一些值
end
x( sortIndex( i ), : ) = Bounds( x( sortIndex( i ), : ), lb, ub ); %更新后种群的限制在变量范围
fit( sortIndex( i ) ) = fobj( x( sortIndex( i ), : ) ); %更新过后重新计算适应度
end
%在全部种群中找可以意识到危险的麻雀
c=randperm(numel(sortIndex));
b=sortIndex(c(1:20));
for j = 1 : length(b) % Equation (5)
if( pFit( sortIndex( b(j) ) )>(fMin) )
%如果适应度比最开始最小适应度差的话，就在原来的最好种群上增长一部分值
x( sortIndex( b(j) ), : )=bestX+(randn(1,dim)).*(abs(( pX( sortIndex( b(j) ), : ) -bestX)));
else
%如果适应度达到开始最小的适应度值，就在原来的最好种群上随机增长或减小一部分
x( sortIndex( b(j) ), : ) =pX( sortIndex( b(j) ), : )+(2*rand(1)-1)*(abs(pX( sortIndex( b(j) ), : )-worse))/ ( pFit( sortIndex( b(j) ) )-fmax+1e-50);
end
x( sortIndex(b(j) ), : ) = Bounds( x( sortIndex(b(j) ), : ), lb, ub );
fit( sortIndex( b(j) ) ) = fobj( x( sortIndex( b(j) ), : ) );
end
for i = 1 : pop
%如果哪个种群适应度好了，就把变化的替换掉原来的种群
if ( fit( i ) < pFit( i ) )
pFit( i ) = fit( i );
pX( i, : ) = x( i, : );
end
if( pFit( i ) < fMin ) %最优值以及最优值位置看是否变化
fMin= pFit( i );
bestX = pX( i, : );
end
end
Convergence_curve(t)=fMin;
end
% Application of simple limits/bounds
function s = Bounds( s, Lb, Ub)
% Apply the lower bound vector
temp = s;
I = temp < Lb;
temp(I) = Lb(I);
% Apply the upper bound vector
J = temp > Ub;
temp(J) = Ub(J);
% Update this new move
s = temp;
%---------------------------------------------------------------------------------------------------------------------------
19、鲸鱼优化算法
% The Whale Optimization Algorithm
function [Leader_score,Leader_pos,Convergence_curve]=WOA(SearchAgents_no,Max_iter,lb,ub,dim,fobj)
% initialize position vector and score for the leader
Leader_pos=zeros(1,dim);
Leader_score=inf; %change this to -inf for maximization problems
%Initialize the positions of search agents
Positions=initialization(SearchAgents_no,dim,ub,lb);
Convergence_curve=zeros(1,Max_iter);
t=0;% Loop counter
% Main loop
while t<Max_iter
for i=1:size(Positions,1)
% Return back the search agents that go beyond the boundaries of the search space
Flag4ub=Positions(i,:)>ub;
Flag4lb=Positions(i,:)<lb;
Positions(i,:)=(Positions(i,:).*(~(Flag4ub+Flag4lb)))+ub.*Flag4ub+lb.*Flag4lb;
% Calculate objective function for each search agent
fitness=fobj(Positions(i,:));
% Update the leader
if fitness<Leader_score % Change this to > for maximization problem
Leader_score=fitness; % Update alpha
Leader_pos=Positions(i,:);
end
end
a=2-t*((2)/Max_iter); % a decreases linearly fron 2 to 0 in Eq. (2.3)
% a2 linearly dicreases from -1 to -2 to calculate t in Eq. (3.12)
a2=-1+t*((-1)/Max_iter);
% Update the Position of search agents
for i=1:size(Positions,1)
r1=rand(); % r1 is a random number in [0,1]
r2=rand(); % r2 is a random number in [0,1]
A=2*a*r1-a; % Eq. (2.3) in the paper
C=2*r2; % Eq. (2.4) in the paper
b=1; % parameters in Eq. (2.5)
l=(a2-1)*rand+1; % parameters in Eq. (2.5)
p = rand(); % p in Eq. (2.6)
for j=1:size(Positions,2)
if p<0.5
if abs(A)>=1
rand_leader_index = floor(SearchAgents_no*rand()+1);
X_rand = Positions(rand_leader_index, :);
D_X_rand=abs(C*X_rand(j)-Positions(i,j)); % Eq. (2.7)
Positions(i,j)=X_rand(j)-A*D_X_rand; % Eq. (2.8)
elseif abs(A)<1
D_Leader=abs(C*Leader_pos(j)-Positions(i,j)); % Eq. (2.1)
Positions(i,j)=Leader_pos(j)-A*D_Leader; % Eq. (2.2)
end
elseif p>=0.5
distance2Leader=abs(Leader_pos(j)-Positions(i,j));
% Eq. (2.5)
Positions(i,j)=distance2Leader*exp(b.*l).*cos(l.*2*pi)+Leader_pos(j);
end
end
end
t=t+1;
Convergence_curve(t)=Leader_score;
[t Leader_score];
end
function Positions=initialization(SearchAgents_no,dim,ub,lb)
Boundary_no= size(ub,2); % numnber of boundaries
% If the boundaries of all variables are equal and user enter a signle
% number for both ub and lb
if Boundary_no==1
Positions=rand(SearchAgents_no,dim).*(ub-lb)+lb;
end
% If each variable has a different lb and ub
if Boundary_no>1
for i=1:dim
ub_i=ub(i);
lb_i=lb(i);
Positions(:,i)=rand(SearchAgents_no,1).*(ub_i-lb_i)+lb_i;
end
end
20、白鲨优化算法
function [fmin0,gbest,ccurve]=WSO(whiteSharks,itemax,lb,ub,dim,fobj)
%% Convergence curve
ccurve=zeros(1,itemax);
%%% Show the convergence curve
% figure (1);
% set(gcf,'color','w');
% hold on
% xlabel('Iteration','interpreter','latex','FontName','Times','fontsize',10)
% ylabel('fitness value','interpreter','latex','FontName','Times','fontsize',10);
% grid;
%% Start the WSO Algorithm
% Generation of initial solutions
WSO_Positions=initialization(whiteSharks,dim,ub,lb);% Initial population
% initial velocity
v=0.0*WSO_Positions;
%% Evaluate the fitness of the initial population
fit=zeros(whiteSharks,1);
for i=1:whiteSharks
fit(i,1)=fobj(WSO_Positions(i,:));
end
%% Initalize the parameters of WSO
fitness=fit; % Initial fitness of the random positions of the WSO
[fmin0,index]=min(fit);
wbest = WSO_Positions; % Best position initialization
gbest = WSO_Positions(index,:); % initial global position
%% WSO Parameters
fmax=0.75; % Maximum frequency of the wavy motion
fmin=0.07; % Minimum frequency of the wavy motion
tau=4.11;
mu=2/abs(2-tau-sqrt(tau^2-4*tau));
pmin=0.5;
pmax=1.5;
a0=6.250;
a1=100;
a2=0.0005;
%% Start the iterative process of WSO
for ite=1:itemax
mv=1/(a0+exp((itemax/2.0-ite)/a1));
s_s=abs((1-exp(-a2*ite/itemax))) ;
p1=pmax+(pmax-pmin)*exp(-(4*ite/itemax)^2);
p2=pmin+(pmax-pmin)*exp(-(4*ite/itemax)^2);
%% Update the speed of the white sharks in water
nu=floor((whiteSharks).*rand(1,whiteSharks))+1;
for i=1:size(WSO_Positions,1)
rmin=1; rmax=3.0;
rr=rmin+rand()*(rmax-rmin);
wr=abs(((2*rand()) - (1*rand()+rand()))/rr);
v(i,:)= mu*v(i,:) + wr *(wbest(nu(i),:)-WSO_Positions(i,:));
%% or
% v(i,:)= mu*(v(i,:)+ p1*(gbest-WSO_Positions(i,:))*rand+....
% + p2*(wbest(nu(i),:)-WSO_Positions(i,:))*rand);
end
%% Update the white shark position
for i=1:size(WSO_Positions,1)
f =fmin+(fmax-fmin)/(fmax+fmin);
a=sign(WSO_Positions(i,:)-ub)>0;
b=sign(WSO_Positions(i,:)-lb)<0;
wo=xor(a,b);
% locate the prey based on its sensing (sound, waves)
if rand<mv
WSO_Positions(i,:)= WSO_Positions(i,:).*(~wo) + (ub.*a+lb.*b); % random allocation
else
WSO_Positions(i,:) = WSO_Positions(i,:)+ v(i,:)/f; % based on the wavy motion
end
end
%% Update the position of white sharks consides_sng fishing school
for i=1:size(WSO_Positions,1)
for j=1:size(WSO_Positions,2)
if rand<s_s
Dist=abs(rand*(gbest(j)-1*WSO_Positions(i,j)));
if(i==1)
WSO_Positions(i,j)=gbest(j)+rand*Dist*sign(rand-0.5);
else
WSO_Pos(i,j)= gbest(j)+rand*Dist*sign(rand-0.5);
WSO_Positions(i,j)=(WSO_Pos(i,j)+WSO_Positions(i-1,j))/2*rand;
end
end
end
end
%
%% Update global, best and new positions
for i=1:whiteSharks
% Handling boundary violations
if WSO_Positions(i,:)>=lb & WSO_Positions(i,:)<=ub%
% Find the fitness
fit(i)=fobj(WSO_Positions(i,:));
% Evaluate the fitness
if fit(i)<fitness(i)
wbest(i,:) = WSO_Positions(i,:); % Update the best positions
fitness(i)=fit(i); % Update the fitness
end
%% Finding out the best positions
if (fitness(i)<fmin0)
fmin0=fitness(i);
gbest = wbest(index,:); % Update the global best positions
end
end
end
%% Obtain the results
% outmsg = ['Iteration# ', num2str(ite) , ' Fitness= ' , num2str(fmin0)];
% disp(outmsg);
%
% ccurve(ite)=fmin0; % Best found value until iteration ite
%
% if ite>2
% line([ite-1 ite], [ccurve(ite-1) ccurve(ite)],'Color','b');
% title({'Convergence characteristic curve'},'interpreter','latex','FontName','Times','fontsize',12);
% xlabel('Iteration');
% ylabel('Best score obtained so far');
% drawnow
% end
end
end
function pos=initialization(whiteSharks,dim,ub_,lb_)
% number of boundaries
BoundNo= size(ub_,1);
% If the boundaries of all variables are equal and user enters one number for both ub_ and lb_
if BoundNo==1
pos=rand(whiteSharks,dim).*(ub_-lb_)+lb_;
end
% If each variable has different ub_ and lb_
if BoundNo>1
for i=1:dim
ubi=ub_(i);
lbi=lb_(i);
pos(:,i)=rand(whiteSharks,1).*(ubi-lbi)+lbi;
end
end
end