您的当前位置：首页基础算法及MATLAB代码GJO,GWO,PSO,SCA,POA

基础算法及MATLAB代码GJO,GWO,PSO,SCA,POA

来源：易妖游戏网

金豺优化算法(GJO)

% 金豺优化算法（GJO）
function [Male_Jackal_score,Male_Jackal_pos,Convergence_curve]=GJO(SearchAgents_no,Max_iter,lb,ub,dim,fobj)
%% initialize Golden jackal pair
Male_Jackal_pos=zeros(1,dim);
Male_Jackal_score=inf; 
Female_Jackal_pos=zeros(1,dim);  
Female_Jackal_score=inf; 
 
 
%% 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)  
 
 
           % boundary checking
            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 Male Jackal 
            if fitness<Male_Jackal_score 
                Male_Jackal_score=fitness; 
                Male_Jackal_pos=Positions(i,:);
            end  
             if fitness>Male_Jackal_score && fitness<Female_Jackal_score 
                Female_Jackal_score=fitness; 
                Female_Jackal_pos=Positions(i,:);
            end
        end

灰狼算法（GWO）

 
 
%pop——种群数量
%dim——问题维度
%ub——变量上界，[1,dim]矩阵
%lb——变量下界，[1,dim]矩阵
%fobj——适应度函数（指针）
%MaxIter——最大迭代次数
%Best_Pos——x的最佳值
%Best_Score——最优适应度值
clc;
clear all;
close all;
pop=50;
dim=2;
ub=[10,10];
lb=[-10,-10];
MaxIter=100;
fobj=@(x)fitness(x);%设置适应度函数
[Best_Pos,Best_Score,IterCurve]=GWO(pop,dim,ub,lb,fobj,MaxIter);
%…………………………………………绘图…………………………………………
figure(1);
plot(IterCurve,'r-','linewidth',2);
grid on;
title('灰狼迭代曲线');
xlabel('迭代次数');
ylabel('适应度值');
%…………………………………… 结果显示……………………………………
disp(['求解得到的x1，x2是:',num2str(Best_Pos(1)),' ',num2str(Best_Pos(2))]);
disp(['最优解对应的函数:',num2str(Best_Score)]);
 
 
%种群初始化函数
function x=initialization(pop,ub,lb,dim)
for i=1:pop
    for j=1:dim
        x(i,j)=(ub(j)-lb(j))*rand()+lb(j);
    end
end
end
%狼群越界调整函数
function x=BoundrayCheck(x,ub,lb,dim)
for i=1:size(x,1)
    for j=1:dim
        if x(i,j)>ub(j)
            x(i,j)=ub(j);
        end
        if x(i,j)<lb(j)
            x(i,j)=lb(j);
        end
    end
end
end
 
%适应度函数，可根据自身需要调整
function [Fitness]=fitness(x)
    Fitness=sum(x.^2);
end
 
 
%…………………………………………灰狼算法主体………………………………………
function [Best_Pos,Best_Score,IterCurve]=GWO(pop,dim,ub,lb,fobj,MaxIter)
Alpha_Pos=zeros(1,dim);%初始化Alpha狼群
Alpha_Score=inf;
Beta_Pos=zeros(1,dim);%初始化Beta狼群
Beta_Score=inf;
Delta_Pos=zeros(1,dim);%初始化化Delta狼群
Delta_Score=inf;
 
x=initialization(pop,ub,lb,dim);%初始化种群
Fitness=zeros(1,pop);%初始化适应度函数
for i=1:pop
    Fitness(i)=fobj(x(i,:));
end
[SortFitness,IndexSort]=sort(Fitness);
Alpha_Pos=x(IndexSort(1),:);
Alpha_Score=SortFitness(1);
Beta_Pos=x(IndexSort(2),:);
Beta_Score=SortFitness(2);
Delta_Pos=x(IndexSort(3),:);
Delta_Score=SortFitness(3);
Group_Best_Pos=Alpha_Pos;
Group_Best_Score=Alpha_Score;
for t=1:MaxIter
    a=2-t*((2)/MaxIter);%线性调整a的值
    for i=1:pop
        for j=1:dim
            %根据Alpha狼群更新位置X1
            r1=rand;
            r2=rand;
            A1=2*a*r1-a;%计算A1
            C1=2*r2;%计算C1
            D_Alpha=abs(C1*Alpha_Pos(j)-x(i,j));%计算种群中其它狼只与Alpha狼群的距离
            X1=Alpha_Pos(j)-A1*D_Alpha;%更新X1
            
            %根据Beta狼群更新位置X2
            r1=rand;
            r2=rand;
            A2=2*a*r1-a;%计算A2
            C2=2*r2;%计算C2
            D_Beta=abs(C2*Beta_Pos(j)-x(i,j));%计算种群中其它狼只与Beta狼群的距离
            X2=Beta_Pos(j)-A2*D_Beta;%更新X2
            
             %根据Delta狼群更新位置X3
            r1=rand;
            r2=rand;
            A3=2*a*r1-a;
            C3=2*r2;
            D_Delta=abs(C3*Delta_Pos(j)-x(i,j));%计算种群中其它狼只与BDelta狼群的距离
            X3=Delta_Pos(j)-A3*D_Delta;%更新X3
            
            x(i,j)=(X1+X2+X3)/3;%更新后的狼只位置
        end
    end
  x=BoundrayCheck(x,ub,lb,dim);%狼只越界调整
  for i=1:pop
      Fitness(i)=fobj(x(i,:));
      if Fitness(i)<Alpha_Score%替换Aplha狼
          Alpha_Score=Fitness(i);
          Alpha_Pos=x(i,:);
      end
      if Fitness(i)>Alpha_Score&&Fitness(i)<Beta_Score%替换Beta狼
          Beta_Score=Fitness(i);
          Beta_Pos=x(i,:);
      end
      if Fitness(i)>Alpha_Score&&Fitness(i)>Beta_Score&&Fitness(i)<Delta_Score%替换Delta狼
          Delta_Score=Fitness(i);
          Delta_Pos=x(i,:);
      end
  end
  Group_Best_Pos=Alpha_Pos;
  Group_Best_Score=Alpha_Score;
  IterCurve(t)=Group_Best_Score;
end
  Best_Pos=Group_Best_Pos;
  Best_Score=Group_Best_Score;
end

粒子群算法（PSO）

%pop——种群数量
%dim——问题维度
%ub——变量上界，[1,dim]矩阵
%lb——变量下界，[1,dim]矩阵
%fobj——适应度函数（指针）
%MaxIter——最大迭代次数
%Best_Pos——x的最佳值
%Best_Score——最优适应度
 
 
clc;
clear all;
close all;
pop=50;
dim=2;
ub=[10,10];
lb=[-10,-10];
vmax=[2,2];
vmin=[-2,-2];
maxIter=100;
fobj=@(X)fun(X);
[Best_Pos,Best_fitness,IterCurve]=pso(pop,dim,ub,lb,fobj,vmax,vmin,maxIter);
figure
plot(IterCurve,'r','linewidth',2);
grid on;
disp(['求解得到的x1，x2是:',num2str(Best_Pos(1)),' ',num2str(Best_Pos(2))]);
disp(['最优解对应的函数:',num2str(Best_fitness)]);
 
 
 
 
 
function [X]=initialization(pop,ub,lb,dim)
    for i=1:pop
        for j=1:dim
            X(i,j)=(ub(j)-lb(j))*rand()+lb(j);%在限定的  
        end 
    end
end
 
function fitness=fun(x)
    fitness=sum(x.^2);
end
 
function [X]=BoundaryCheck(X,ub,lb,dim)
    for i=1:dim
        if X(i)>ub(i)
            X(i)=ub(i);
        end
        if X(i)<lb(i)
            X(i)=lb(i);
        end
    end
end
 
function [Best_Pos,Best_fitness,IterCurve]=pso(pop,dim,ub,lb,fobj,vmax,vmin,maxIter)
c1=2.0;
c2=2.0;
V=initialization(pop,vmax,vmin,dim);
X=initialization(pop,ub,lb,dim);
fitness=zeros(1,pop);
for i=1:pop
    fitness(i)=fobj(X(i,:));
end
pBest=X;
pBestFitness=fitness;
[~,index]=min(fitness);
gBestFitness=fitness(index);
gBest=X(index,:);
Xnew=X;
fitnessNew=fitness;
for t=1:maxIter
    for i=1:pop
        r1=rand(1,dim);
        r2=rand(1:dim);
        V(i,:)=V(i,:)+c1.*r1.*(pBest(i,:)-X(i,:))+c2.*r2.*(gBest-X(i,:));
        V(i,:)=BoundaryCheck(V(i,:),vmax,vmin,dim);
        Xnew(i,:)=X(i,:)+V(i,:);
        fitnessNew(i)=fobj(Xnew(1,:));
        if fitnessNew(i)<pBestFitness(i)
            pBest(i,:)=Xnew(i,:);
            pBestFitness(i)=fitnessNew(i);
        end
        if fitnessNew(i)<gBestFitness
            gBestFitness=fitnessNew(i);
            gBest=Xnew(i,:);
        end
    end
    X=Xnew;
    fitness=fitnessNew;
    Best_Pos=gBest;
    Best_fitness=gBestFitness;
    IterCurve(t)=gBestFitness;
end
end

正余弦优化算法（SCA）

 
 
%pop——种群数量
%dim——问题维度
%ub——变量上界，[1,dim]矩阵
%lb——变量下界，[1,dim]矩阵
%fobj——适应度函数（指针）
%MaxIter——最大迭代次数
%Best_Pos——x的最佳值
%Best_Score——最优适应度值
clc;
clear all;
close all;
pop=50;
dim=2;
ub=[10,10];
lb=[-10,-10];
MaxIter=100;
fobj=@(x)fitness(x);%设置适应度函数
[Best_Pos,Best_Score,IterCurve]=SCA(pop,dim,ub,lb,fobj,MaxIter);
%…………………………………………绘图…………………………………………
figure(1);
plot(IterCurve,'r-','linewidth',2);
grid on;
title('正余弦算法迭代曲线');
xlabel('迭代次数');
ylabel('适应度值');
%…………………………………… 结果显示……………………………………
disp(['求解得到的x1，x2是:',num2str(Best_Pos(1)),' ',num2str(Best_Pos(2))]);
disp(['最优解对应的函数:',num2str(Best_Score)]);
 
 
%种群初始化函数
function x=initialization(pop,ub,lb,dim)
for i=1:pop
    for j=1:dim
        x(i,j)=(ub(j)-lb(j))*rand()+lb(j);
    end
end
end
%种群越界调整函数
function x=BoundrayCheck(x,ub,lb,dim)
for i=1:size(x,1)
    for j=1:dim
        if x(i,j)>ub(j)
            x(i,j)=ub(j);
        end
        if x(i,j)<lb(j)
            x(i,j)=lb(j);
        end
    end
end
end
 
%适应度函数，可根据自身需要调整
function [Fitness]=fitness(x)
    Fitness=sum(x.^2);
end
 
%…………………………………………正余弦算法主体………………………………………
function [Best_Pos,Best_Score,IterCurve]=SCA(pop,dim,ub,lb,fobj,MaxIter)
  a=2;
  x=initialization(pop,ub,lb,dim);%种群初始化
  Fitness=zeros(1,pop);%适应度值初始化
  for i=1:pop
      Fitness(i)=fobj(x(i,:));%计算适应度值
  end
  [SortFitness,Index]=sort(Fitness);
  Global_Best_Pos=x(Index(1),:);
  Global_Best_Score=SortFitness(1);
  for t=1:MaxIter
      r1=a-t*(a/MaxIter);%计算r1
      for i=1:pop
          for j=1:dim
              r2=rand()*(2*pi);
              r3=2*rand();
              r4=rand();
              if(r4<0.5)
                  x(i,j)=x(i,j)+(r1*sin(r2)*abs(r3*Global_Best_Pos(j)-x(i,j)));%采用正弦更新位置
              else
                  x(i,j)=x(i,j)+(r1*cos(r2)*abs(r3*Global_Best_Pos(j)-x(i,j)));%采用余弦更新位置
              end%结束if
          end%结束j循环
          x(i,:)=BoundrayCheck(x(i,:),ub,lb,dim);
      end%结束i循环
      for i=1:pop
           Fitness(i)=fobj(x(i,:));
           if Fitness(i)<Global_Best_Pos
              Global_Best_Score=Fitness(i);
              Global_Best_Pos=x(i,:);
          end%结束if
      end%结束i循环
      IterCurve(t)=Global_Best_Score;
  end%结束t循环
  Best_Pos=Global_Best_Pos;
  Best_Score=Global_Best_Score;
end

萤火虫算法（FA）

 
 
%pop——种群数量
%dim——问题维度
%ub——变量上界，[1,dim]矩阵
%lb——变量下界，[1,dim]矩阵
%fobj——适应度函数（指针）
%MaxIter——最大迭代次数
%Best_Pos——x的最佳值
%Best_Score——最优适应度值
clc;
clear all;
close all;
pop=50;
dim=2;
ub=[10,10];
lb=[-10,-10];
MaxIter=100;
fobj=@(x)fitness(x);%设置适应度函数
[Best_Pos,Best_Score,IterCurve]=FA(pop,dim,ub,lb,fobj,MaxIter);
%…………………………………………绘图…………………………………………
figure(1);
plot(IterCurve,'r-','linewidth',2);
grid on;
title('萤火虫算法迭代曲线');
xlabel('迭代次数');
ylabel('适应度值');
%…………………………………… 结果显示……………………………………
disp(['求解得到的x1，x2是:',num2str(Best_Pos(1)),' ',num2str(Best_Pos(2))]);
disp(['最优解对应的函数:',num2str(Best_Score)]);
 
 
%种群初始化函数
function x=initialization(pop,ub,lb,dim)
for i=1:pop
    for j=1:dim
        x(i,j)=(ub(j)-lb(j))*rand()+lb(j);
    end
end
end
%种群越界调整函数
function x=BoundrayCheck(x,ub,lb,dim)
for i=1:size(x,1)
    for j=1:dim
        if x(i,j)>ub(j)
            x(i,j)=ub(j);
        end
        if x(i,j)<lb(j)
            x(i,j)=lb(j);
        end
    end
end
end
 
%适应度函数，可根据自身需要调整
function [Fitness]=fitness(x)
    Fitness=sum(x.^2);
end
 
%…………………………………………萤火虫算法主体………………………………………
function [Best_Pos,Best_Score,IterCurve]=FA(pop,dim,ub,lb,fobj,MaxIter)
  beta0=2;%最大吸引度β0
  gamma=1;%光吸收强度系数γ
  alpha=0.2;%步长因子
  dmax=norm(ub-lb);%返回上下界的2范数，用于后面的距离归一化计算
  x=initialization(pop,ub,lb,dim);%种群初始化
  Fitness=zeros(1,pop);%适应度值初始化
  for i=1:pop
      Fitness(i)=fobj(x(i,:));%计算适应度值
  end
  [~,Index]=min(Fitness);%寻找适应度值最小的位置
  Global_Best_Pos=x(Index,:);
  Global_Best_Score=Fitness(Index);
  x_new=x;%用于记录新位置
  for t=1:MaxIter
      for i=1:pop
          for j=1:dim
              if Fitness(j)<Fitness(i)
                  r_ij=norm(x(i,:)-x(j,:))./dmax;%计算2范数，即距离
                  beta=beta0*exp(-gamma*r_ij^2);
                  Pos_new=x(i,:)+beta*(x(j,:)-x(i,:))+alpha.*rand(1,dim);
                  Pos_new=BoundrayCheck(Pos_new,ub,lb,dim);
                  Fitness_new=fobj(Pos_new);
                  if Fitness_new<Fitness(i)
                      x_new(i,:)=Pos_new;
                      Fitness(i)=Fitness_new;
                      if Fitness_new<Global_Best_Score
                          Global_Best_Score=Fitness_new;
                          Global_Best_Pos=Pos_new;
                      end
                  end
              end
          end%结束j循环
      end%结束i循环
      x_double=[x;x_new];%将更新后的x_new和历史的x合并组成2*pop只萤火虫
      for i=1:2*pop
          Fitness_double(i)=fobj(x_double(i,:));
      end
      [~,SortIndex]=sort(Fitness_double);%适应度重新排序
      for k=1:pop  %选取适应度靠前的pop只萤火虫，作为下次循环的种群
          x(k,:)=x_double(SortIndex(k),:);
      end%结束k循环
      IterCurve(t)=Global_Best_Score;
  end%结束t循环
  Best_Pos=Global_Best_Pos;
  Best_Score=Global_Best_Score;
end

因篇幅问题不能全部显示，请点此查看更多更全内容

查看全文