MATLAB code for machine learning--whale optimization algorithm based on mixed strategy improvement (6)

the code

Overall code naming: the following codes are in order

1、

clear;
clc;
%% A和a的变化图
dim = 1;
Max_iter = 500;
% figure;
for t = 1:Max_iter
    origin_a = 2-t*((2)/Max_iter);
    if t <= 0.5*Max_iter
        a = 1+cos(pi*t/Max_iter);
    else
        a = cos(pi*(t-0.5*Max_iter)/Max_iter);
    end
    
    A = 2*a*rand(1, dim)-a;

    plot(t, a, 'r.-', t, origin_a, 'k.-');
    hold on;
    plot(t, A, 'b.', 'MarkerSize', 16);
    hold on;
end
xlabel '迭代次数'; ylabel '参数取值';
legend('提出的a', '原始的a', 'A');

2、

function [fitnessgbest, gbest, BestCost] = ABC(X, N, MaxIt, lb, ub, dim, fobj)

%% 问题设定
VarSize = [1, dim];

%% ABC参数
nPop = N;                   % 蜂群大小
nOnlooker = nPop;        % 侦察蜂个数
L = round(0.6*dim*nPop); % 探索极值限制参数
a = 1;                              % 加速度系数上限

%% 初始化
% 产生初始种群
for i = 1:nPop
    fitness(i) = fobj(X(i, :));
end
[bestfitness, bestindex] = min(fitness);
gbest = X(bestindex, :);
fitnessgbest = bestfitness;
% 丢解计数器
C = zeros(nPop, 1);
% 保存最优函数值的数组
BestCost = zeros(MaxIt, 1);

%% ABC迭代
for it = 1:MaxIt
    % 引领蜂
    for i = 1:nPop
        % 随机选择不等于i的k
        K = [1:i-1 i+1:nPop];
        k = K(randi([1 numel(K)]));
        % 定义加速度系数
        phi = a*unifrnd(-1, +1, VarSize);
        % 新的蜜蜂位置
        newbee_X(i, :) = X(i, :)+phi.*(X(i, :)-X(k, :));
        % 边界处理
        newbee_X(i, :) = max(newbee_X(i, :), lb);
        newbee_X(i, :) = min(newbee_X(i, :), ub);
        % 新的蜜蜂函数值
        newbee_fitness(i) = fobj(newbee_X(i, :));
        % 比较
        if newbee_fitness(i) <= fitness(i)
            X(i, :) = newbee_X(i, :);
            fitness(i) = newbee_fitness(i);
        else
            C(i) = C(i)+1;
        end
    end
    % 计算适应度值和选择概率
    F = zeros(nPop, 1);
    MeanCost = mean(fitness);
    for i = 1:nPop
        % 将函数值转换为适应度
        if fitness(i) >= 0
            F(i) = 1/(1+fitness(i));
        else
            F(i) = 1+abs(fitness(i));
        end
    end
    P = F/sum(F);
    % 跟随蜂
    for m = 1:nOnlooker
        % 选择食物源
        i = RouletteWheelSelection(P);
        % 随机选择不等于i的k
        K = [1:i-1 i+1:nPop];
        k = K(randi([1 numel(K)]));
        % 定义加速度系数
        phi = a*unifrnd(-1, +1, VarSize);
        % 新的蜜蜂位置
        newbee_X(i, :) = X(i, :)+phi.*(X(i, :)-X(k, :));
        % 边界处理
        newbee_X(i, :) = max(newbee_X(i, :), lb);
        newbee_X(i, :) = min(newbee_X(i, :), ub);
        % 新的蜜蜂函数值
        newbee_fitness(i) = fobj(newbee_X(i, :));
        % 比较
        if newbee_fitness(i) <= fitness(i)
            X(i, :) = newbee_X(i, :);
            fitness(i) = newbee_fitness(i);
        else
            C(i) = C(i) + 1;
        end
    end
    % 侦察蜂
    for i = 1:nPop
        if C(i) >= L    % 超出探索极值参数
            maxPos = max(X(i, :));
            minPos = min(X(i, :));
            for j = 1:numel(X(i, :))
                X(i, j) = minPos+rand*(maxPos-minPos);
            end
            fitness(i) = fobj(X(i, :));
            C(i) = 0;
        end
    end
    % 更新每轮最优解
    for i = 1:nPop
        if fitness(i) <= fitnessgbest
            gbest = X(i, :);
            fitnessgbest = fitness(i);
        end
    end
    % 保存每轮最优解
    BestCost(it) = fitnessgbest;
    % 显示迭代信息
    disp(['ABC: At iteration ', num2str(it), ' ,the best fitness is ', num2str(BestCost(it))]);
end
    
% %% 结果显示
% figure;
% % plot(BestCost, 'LineWidth', 2);
% semilogy(BestCost, 'r', 'LineWidth', 2);
% xlabel('Iteration');
% ylabel('Best Cost');
% grid on;

3、

function [fmin, best_pos, Curve] = BOA(X, N, Max_iter, lb, ub, dim, fobj)

%% BOA参数
p = 0.8;                            % 开关概率
power_exponent = 0.1;
sensory_modality = 0.01;

for i = 1:N
    fitness(i) = fobj(X(i, :));
end

% 最优解
[fmin, I] = min(fitness);
best_pos = X(I, :);
S = X;

%% 迭代
for t = 1:Max_iter
    for i = 1:N
        % 计算与目标函数相关的每只蝴蝶的香味
        Fnew = fobj(S(i, :));
        FP = (sensory_modality*(Fnew^power_exponent));
        
        % 全局或局部搜索
        if rand < p
            dis = rand * rand * best_pos - X(i, :);        % Eq. (2) in paper
            S(i, :) = X(i, :)+dis*FP;
        else
            % 在附近随机找蝴蝶
            epsilon = rand;
            JK = randperm(N);
            dis = epsilon*epsilon*X(JK(1), :)-X(JK(2), :);
            S(i, :) = X(i, :)+dis*FP;                             % Eq. (3) in paper
        end
        
        % 边界处理
        S(i, :) = simplebounds(S(i, :), lb, ub);
        
        % 新的个体适应度值
        Fnew = fobj(S(i, :));  % Fnew represents new fitness values
        
        % If fitness improves (better Xutions found), update then
        if Fnew <= fitness(i)
            X(i, :) = S(i, :);
            fitness(i) = Fnew;
        end
        
        % 更新当前全局最优解
        if Fnew <= fmin
            best_pos = S(i, :);
            fmin = Fnew;
        end
    end
    
    Curve(t) = fmin;
    
    % 更新感觉因子
    sensory_modality = sensory_modality_NEW(sensory_modality, Max_iter);
    
    disp(['BOA: At iteration ', num2str(t), ' ,the best fitness is ', num2str(Curve(t))]);
end

% Boundary constraints
function s=simplebounds(s,Lb,Ub)
% Apply the lower bound
ns_tmp=s;
I=ns_tmp<Lb;
ns_tmp(I)=Lb;

% Apply the upper bounds
J=ns_tmp>Ub;
ns_tmp(J)=Ub;
% Update this new move
s=ns_tmp;
end

function y=sensory_modality_NEW(x, Ngen)
y = x+(0.025/(x*Ngen));
end

end

4、

%_________________________________________________________________________%
%  Whale Optimization Algorithm (WOA) source codes demo 1.0               %
%                                                                         %
%  Developed in MATLAB R2011b(7.13)                                       %
%                                                                         %
%  Author and programmer: Seyedali Mirjalili                              %
%                                                                         %
%         e-Mail: ali.mirjalili@gmail.com                                 %
%                 seyedali.mirjalili@griffithuni.edu.au                   %
%                                                                         %
%       Homepage: http://www.alimirjalili.com                             %
%                                                                         %
%   Main paper: S. Mirjalili, A. Lewis                                    %
%               The Whale Optimization Algorithm,                         %
%               Advances in Engineering Software , in press,              %
%               DOI: http://dx.doi.org/10.1016/j.advengsoft.2016.01.008   %
%                                                                         %
%_________________________________________________________________________%

% This function draw the benchmark functions

function func_plot(func_name)

[lb,ub,dim,fobj]=Get_Functions_details(func_name);

switch func_name 
    case 'F1' 
        x=-100:2:100; y=x; %[-100,100]
        
    case 'F2' 
        x=-100:2:100; y=x; %[-10,10]
        
    case 'F3' 
        x=-100:2:100; y=x; %[-100,100]
        
    case 'F4' 
        x=-100:2:100; y=x; %[-100,100]
    case 'F5' 
        x=-200:2:200; y=x; %[-5,5]
    case 'F6' 
        x=-100:2:100; y=x; %[-100,100]
    case 'F7' 
        x=-1:0.03:1;  y=x  %[-1,1]
    case 'F8' 
        x=-500:10:500;y=x; %[-500,500]
    case 'F9' 
        x=-5:0.1:5;   y=x; %[-5,5]    
    case 'F10' 
        x=-20:0.5:20; y=x;%[-500,500]
    case 'F11' 
        x=-500:10:500; y=x;%[-0.5,0.5]
    case 'F12' 
        x=-10:0.1:10; y=x;%[-pi,pi]
    case 'F13' 
        x=-5:0.08:5; y=x;%[-3,1]
    case 'F14' 
        x=-100:2:100; y=x;%[-100,100]
    case 'F15' 
        x=-5:0.1:5; y=x;%[-5,5]
    case 'F16' 
        x=-1:0.01:1; y=x;%[-5,5]
    case 'F17' 
        x=-5:0.1:5; y=x;%[-5,5]
    case 'F18' 
        x=-5:0.06:5; y=x;%[-5,5]
    case 'F19' 
        x=-5:0.1:5; y=x;%[-5,5]
    case 'F20' 
        x=-5:0.1:5; y=x;%[-5,5]        
    case 'F21' 
        x=-5:0.1:5; y=x;%[-5,5]
    case 'F22' 
        x=-5:0.1:5; y=x;%[-5,5]     
    case 'F23' 
        x=-5:0.1:5; y=x;%[-5,5]  
end    

    

L=length(x);
f=[];

for i=1:L
    for j=1:L
        if strcmp(func_name,'F15')==0 && strcmp(func_name,'F19')==0 && strcmp(func_name,'F20')==0 && strcmp(func_name,'F21')==0 && strcmp(func_name,'F22')==0 && strcmp(func_name,'F23')==0
            f(i,j)=fobj([x(i),y(j)]);
        end
        if strcmp(func_name,'F15')==1
            f(i,j)=fobj([x(i),y(j),0,0]);
        end
        if strcmp(func_name,'F19')==1
            f(i,j)=fobj([x(i),y(j),0]);
        end
        if strcmp(func_name,'F20')==1
            f(i,j)=fobj([x(i),y(j),0,0,0,0]);
        end       
        if strcmp(func_name,'F21')==1 || strcmp(func_name,'F22')==1 ||strcmp(func_name,'F23')==1
            f(i,j)=fobj([x(i),y(j),0,0]);
        end          
    end
end

surfc(x,y,f,'LineStyle','none');

end

5、

function G = Gconstant(iteration, max_it)
%% 计算引力常数（公式13）
alfa = 30;
G0 = 100;
G = G0*exp(-alfa*iteration/max_it);    % 公式28

6、

function [lb,ub,dim,fobj] = Get_Functions_details(F)


switch F
    case 'F1'
        fobj = @F1;
        lb=-100;
        ub=100;
        dim=30;
        
    case 'F2'
        fobj = @F2;
        lb=-10;
        ub=10;
        dim=30;
        
    case 'F3'
        fobj = @F3;
        lb=-100;
        ub=100;
        dim=30;
        
    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=-100;
        ub=100;
        dim=30;
        
    case 'F7'
        fobj = @F7;
        lb=-1.28;
        ub=1.28;
        dim=30;
        
    case 'F8'
        fobj = @F8;
        lb=-500;
        ub=500;
        dim=30;
        
    case 'F9'
        fobj = @F9;
        lb=-5.12;
        ub=5.12;
        dim=30;
        
    case 'F10'
        fobj = @F10;
        lb=-32;
        ub=32;
        dim=30;
        
    case 'F11'
        fobj = @F11;
        lb=-600;
        ub=600;
        dim=30;
        
    case 'F12'
        fobj = @F12;
        lb=-50;
        ub=50;
        dim=30;
        
    case 'F13'
        fobj = @F13;
        lb=-50;
        ub=50;
        dim=30;
        
    case 'F14'
        fobj = @F14;
        lb=-65.536;
        ub=65.536;
        dim=2;
        
    case 'F15'
        fobj = @F15;
        lb=-5;
        ub=5;
        dim=4;
        
    case 'F16'
        fobj = @F16;
        lb=-5;
        ub=5;
        dim=2;
        
    case 'F17'
        fobj = @F17;
        lb=[-5,0];
        ub=[10,15];
        dim=2;
        
    case 'F18'
        fobj = @F18;
        lb=-2;
        ub=2;
        dim=2;
        
    case 'F19'
        fobj = @F19;
        lb=0;
        ub=1;
        dim=3;
        
    case 'F20'
        fobj = @F20;
        lb=0;
        ub=1;
        dim=6;     
        
    case 'F21'
        fobj = @F21;
        lb=0;
        ub=10;
        dim=4;    
        
    case 'F22'
        fobj = @F22;
        lb=0;
        ub=10;
        dim=4;    
        
    case 'F23'
        fobj = @F23;
        lb=0;
        ub=10;
        dim=4;            
end

end

% F1

function o = F1(x)
o=sum(x.^2);
end

% F2

function o = F2(x)
o=sum(abs(x))+prod(abs(x));
end

% F3

function o = F3(x)
dim=size(x,2);
o=0;
for i=1:dim
    o=o+sum(x(1:i))^2;
end
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=sum(abs((x+.5)).^2);
end

% F7

function o = F7(x)
dim=size(x,2);
o=sum([1:dim].*(x.^4))+rand;
end

% F8

function o = F8(x)
o=sum(-x.*sin(sqrt(abs(x))));
end

% F9

function o = F9(x)
dim=size(x,2);
o=sum(x.^2-10*cos(2*pi.*x))+10*dim;
end

% F10

function o = F10(x)
dim=size(x,2);
o=-20*exp(-.2*sqrt(sum(x.^2)/dim))-exp(sum(cos(2*pi.*x))/dim)+20+exp(1);
end

% F11

function o = F11(x)
dim=size(x,2);
o=sum(x.^2)/4000-prod(cos(x./sqrt([1:dim])))+1;
end

% F12

function o = F12(x)
dim=size(x,2);
o=(pi/dim)*(10*((sin(pi*(1+(x(1)+1)/4)))^2)+sum((((x(1:dim-1)+1)./4).^2).*...
(1+10.*((sin(pi.*(1+(x(2:dim)+1)./4)))).^2))+((x(dim)+1)/4)^2)+sum(Ufun(x,10,100,4));
end

% F13

function o = F13(x)
dim=size(x,2);
o=.1*((sin(3*pi*x(1)))^2+sum((x(1:dim-1)-1).^2.*(1+(sin(3.*pi.*x(2:dim))).^2))+...
((x(dim)-1)^2)*(1+(sin(2*pi*x(dim)))^2))+sum(Ufun(x,5,100,4));
end

% F14

function o = F14(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

% F15

function o = F15(x)
aK=[.1957 .1947 .1735 .16 .0844 .0627 .0456 .0342 .0323 .0235 .0246];
bK=[.25 .5 1 2 4 6 8 10 12 14 16];bK=1./bK;
o=sum((aK-((x(1).*(bK.^2+x(2).*bK))./(bK.^2+x(3).*bK+x(4)))).^2);
end

% F16

function o = F16(x)
o=4*(x(1)^2)-2.1*(x(1)^4)+(x(1)^6)/3+x(1)*x(2)-4*(x(2)^2)+4*(x(2)^4);
end

% F17

function o = F17(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

% F18

function o = F18(x)
o=(1+(x(1)+x(2)+1)^2*(19-14*x(1)+3*(x(1)^2)-14*x(2)+6*x(1)*x(2)+3*x(2)^2))*...
    (30+(2*x(1)-3*x(2))^2*(18-32*x(1)+12*(x(1)^2)+48*x(2)-36*x(1)*x(2)+27*(x(2)^2)));
end

% F19

function o = F19(x)
aH=[3 10 30;.1 10 35;3 10 30;.1 10 35];cH=[1 1.2 3 3.2];
pH=[.3689 .117 .2673;.4699 .4387 .747;.1091 .8732 .5547;.03815 .5743 .8828];
o=0;
for i=1:4
    o=o-cH(i)*exp(-(sum(aH(i,:).*((x-pH(i,:)).^2))));
end
end

% F20

function o = F20(x)
aH=[10 3 17 3.5 1.7 8;.05 10 17 .1 8 14;3 3.5 1.7 10 17 8;17 8 .05 10 .1 14];
cH=[1 1.2 3 3.2];
pH=[.1312 .1696 .5569 .0124 .8283 .5886;.2329 .4135 .8307 .3736 .1004 .9991;...
.2348 .1415 .3522 .2883 .3047 .6650;.4047 .8828 .8732 .5743 .1091 .0381];
o=0;
for i=1:4
    o=o-cH(i)*exp(-(sum(aH(i,:).*((x-pH(i,:)).^2))));
end
end

% F21

function o = F21(x)
aSH=[4 4 4 4;1 1 1 1;8 8 8 8;6 6 6 6;3 7 3 7;2 9 2 9;5 5 3 3;8 1 8 1;6 2 6 2;7 3.6 7 3.6];
cSH=[.1 .2 .2 .4 .4 .6 .3 .7 .5 .5];

o=0;
for i=1:5
    o=o-((x-aSH(i,:))*(x-aSH(i,:))'+cSH(i))^(-1);
end
end

% F22

function o = F22(x)
aSH=[4 4 4 4;1 1 1 1;8 8 8 8;6 6 6 6;3 7 3 7;2 9 2 9;5 5 3 3;8 1 8 1;6 2 6 2;7 3.6 7 3.6];
cSH=[.1 .2 .2 .4 .4 .6 .3 .7 .5 .5];

o=0;
for i=1:7
    o=o-((x-aSH(i,:))*(x-aSH(i,:))'+cSH(i))^(-1);
end
end

% F23

function o = F23(x)
aSH=[4 4 4 4;1 1 1 1;8 8 8 8;6 6 6 6;3 7 3 7;2 9 2 9;5 5 3 3;8 1 8 1;6 2 6 2;7 3.6 7 3.6];
cSH=[.1 .2 .2 .4 .4 .6 .3 .7 .5 .5];

o=0;
for i=1:10
    o=o-((x-aSH(i,:))*(x-aSH(i,:))'+cSH(i))^(-1);
end
end

function o=Ufun(x,a,k,m)
o=k.*((x-a).^m).*(x>a)+k.*((-x-a).^m).*(x<(-a));
end

7、

%% This function calculates the accelaration of each agent in gravitational field. eq.7-10,21.
function a = Gfield(M, X, G, Rnorm, Rpower, ElitistCheck, iteration, max_it)
%% 计算了重力场中每个个体的加速度
[N, dim] = size(X);
final_per = 2;     % 在上一次迭代中，只有2%的个体对其他个体施加力。

% 总的力计算
if ElitistCheck == 1
    kbest = final_per+(1-iteration/max_it)*(100-final_per);   % 公式21的kbest
    kbest = round(N*kbest/100);
else
    kbest = N;         % 公式9
end
[Ms, ds] = sort(M, 'descend');

for i = 1:N
    E(i, :) = zeros(1, dim);
    for ii = 1:kbest
        j = ds(ii);
        if j ~= i
            R = norm(X(i, :)-X(j, :), Rnorm);    % 欧几里德距离
            for k = 1:dim
                E(i, k) = E(i, k)+rand*(M(j))*((X(j, k)-X(i, k))/(R^Rpower+eps));
                % 注意，Mp(i)/Mi(i)=1
            end
        end
    end
end

% 加速度
a = E.*G;          % 注意，Mp(i)/Mi(i)=1

8、

%% Gravitational Search Algorithm.
function [Fbest, Lbest, Curve] = GSA(X, N, Max_iter, lb, ub, dim, fobj)
%V:   速度.
%a:   加速度.
%M:   质量.  Ma=Mp=Mi=M;
%dim: 测试函数的维数.
%N:   种群规模.
%X:   种群位置.
%R:   搜索空间中代理之间的距离.
%[low-up]: 搜索空间的允许范围.
%Rnorm:  公式8中的标准值.
%Rpower: 式7中R的幂.

Rnorm = 2;
ElitistCheck = 1; 
Rpower = 1;
% 初始化进化曲线
Curve = zeros(1, Max_iter);

V = zeros(N, dim);

%% 迭代寻优
for iter = 1:Max_iter
    for i = 1:N
        % 边界处理
        Flag4ub = X(i, :) > ub;
        Flag4lb = X(i, :) < lb;
        X(i, :) = (X(i, :).*(~(Flag4ub+Flag4lb)))+ub.*Flag4ub+lb.*Flag4lb;
        % 计算适应度值
        fitness(i) = fobj(X(i, :));
    end
    % 计算最小的适应度值
    [best, best_X]=min(fitness);
    if iter == 1
        Fbest = best;
        Lbest=X(best_X, :);
    end
    if best < Fbest
        Fbest = best;
        Lbest=X(best_X, :);
    end
    
    Curve(iter) = Fbest;
    
    % 根据公式14-20计算M
    [M] = massCalculation(fitness);
    
    % 根据公式13计算引力常数
    G = Gconstant(iter, Max_iter);
    
    % 计算根据公式7-10,21计算重力场中的加速度
    a = Gfield(M, X, G, Rnorm, Rpower, ElitistCheck, iter, Max_iter);
    
    % 根据公式11-12进行个体的位置移动
    [X, V] = move(X, a, V);
    
    disp(['GSA: At iteration ', num2str(iter), ' ,the best fitness is ', num2str(Fbest)]);
end %iter

9、

function [Alpha_score, Alpha_pos, Convergence_curve] = GWO(Positions, N, Max_iter, lb, ub, dim, fobj)
%% 灰狼优化算法
% 初始化alpha, beta和delta_pos
Alpha_pos = zeros(1, dim);
Alpha_score = inf;  % 将此更改为-inf以解决最大化问题
Beta_pos = zeros(1,dim);
Beta_score = inf;    % 将此更改为-inf以解决最大化问题
Delta_pos = zeros(1,dim);
Delta_score = inf;   % 将此更改为-inf以解决最大化问题
% 初始化种群位置
Convergence_curve = zeros(1, Max_iter);  % 收敛曲线
l = 0;    % 循环计数器
% 主要循环
while l < Max_iter
    for i = 1:N
        % 边界处理
        Flag4ub = Positions(i, :)>ub;
        Flag4lb = Positions(i, :)<lb;
        Positions(i, :) = (Positions(i, :).*(~(Flag4ub+Flag4lb)))+ub.*Flag4ub+lb.*Flag4lb;
%         Positions(i, :) = max(Positions(i, :), lb);
%         Positions(i, :) = min(Positions(i, :), ub);
        % 计算每个种群的目标函数
        fitness = fobj(Positions(i, :));
        % 更新Alpha, Beta和Delta
        if fitness < Alpha_score
            Alpha_score = fitness;        % 更新alpha
            Alpha_pos = Positions(i, :);
        end
        if fitness > Alpha_score && fitness < Beta_score
            Beta_score = fitness;           % 更新beta
            Beta_pos = Positions(i, :);
        end
        if fitness > Alpha_score && fitness > Beta_score && fitness < Delta_score
            Delta_score = fitness;          % 更新delta
            Delta_pos = Positions(i, :);
        end
    end
    a = 2-l*((2)/Max_iter);      % a从2线性减小到0    
    % 更新包括omegas在内的种群的位置
    for i = 1:N
        for j = 1:dim
            r1 = rand();             % r1是[0,1]中的随机数
            r2 = rand();             % r2是[0,1]中的随机数
            
            A1 = 2*a*r1-a;        % 公式（4）
            C1 = 2*r2;               % 公式（5）
            
            D_alpha = abs(C1*Alpha_pos(j)-Positions(i, j));  % 公式（6）-第一部分
            X1 = Alpha_pos(j)-A1*D_alpha;   % 公式 (7)-第一部分
            
            r1 = rand();
            r2 = rand();
            
            A2 = 2*a*r1-a;         % 公式（4）
            C2 = 2*r2;                % 公式（5）
            
            D_beta = abs(C2*Beta_pos(j)-Positions(i, j));   % 公式（6）-第二部分
            X2 = Beta_pos(j)-A2*D_beta;       % 公式 (7)-第二部分
            
            r1 = rand();
            r2 = rand();
            
            A3 = 2*a*r1-a;        % 公式 (4)
            C3 = 2*r2;               % 公式 (5)
            
            D_delta = abs(C3*Delta_pos(j)-Positions(i, j)); % 公式（6）-第三部分
            X3 = Delta_pos(j)-A3*D_delta;      % 公式 (7)-第三部分
            
            Positions(i, j)=(X1+X2+X3)/3;       % 公式 (8)
        end
    end
    l = l+1;
    Convergence_curve(l) = Alpha_score;
    disp(['GWO: At iteration ', num2str(l), ' ,the best fitness is ', num2str(Alpha_score)]);
end

10、

% This function initialize the first population of search agents
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

11、

function [M] = massCalculation(fit)
%% 计算每个个体的质量（公式14-20）
Fmax = max(fit);
Fmin = min(fit);
Fmean = mean(fit);
[i, N] = size(fit);

if Fmax == Fmin
    M = ones(N, 1);
else
    
best = Fmin; worst = Fmax;              %eq.17-18.

M = (fit-worst)./(best-worst);          %eq.15,  
end

M=M./sum(M);                    %eq. 16.

12、

% GSA code v1.1.
% Generated by Esmat Rashedi, 2010. 
% "	E. Rashedi, H. Nezamabadi-pour and S. Saryazdi,
%揋SA: A Gravitational Search Algorithm�, Information sciences, vol. 179,
%no. 13, pp. 2232-2248, 2009."
%
%This function updates the velocity and position of agents.
function [X,V]=move(X,a,V)

%movement.
[N,dim]=size(X);
V=rand(N,dim).*V+a; %eq. 11.
X=X+V; %eq. 12.

13、

function [Leader_score, Leader_pos, Curve] = MSWOA(X, N, Max_iter, lb, ub, dim, fobj)

%% MSWOA参数
limit = 10;
p = sobolset(dim);
% 计算适应度值
for i = 1:N
    X(i, :) = p(i, :).*(ub-lb)+lb;
    fitness(i) = fobj(X(i, :));
end
% 初始化领导者的位置和适应度值
[bestfitness, bestindex] = min(fitness);
Leader_pos = X(bestindex, :);
Leader_score = bestfitness; 
% 初始化进化曲线
Curve = zeros(1, Max_iter);
t = 0;       % 迭代次数计数器
count = 0;

%% 迭代寻优
while t < Max_iter    
    % 计数超过limit阈值
    if count > limit
        % 对最优个体进行柯西变异
        X_new = Leader_pos.*(1+trnd(1, 1, dim));
        % 更新
        fit = fobj(X_new);
        if fit < Leader_score
            Leader_pos = X_new;
            Leader_score = fit;
            X(bestindex, :) = X_new;
            fitness(i) = fit;
        end
    end
%     a=2-t*((2)/Max_iter);    % 式（2.3）中，a从2线性减小到0
    % 非线性时变因子
    if t <= 0.5*Max_iter
        a = 1+cos(pi*t/Max_iter);
    else
        a = cos(pi*(t-0.5*Max_iter)/Max_iter);
    end
    % 自适应权值
    w = 2/pi*tan(t/Max_iter);
    a2=-1+t*((-1)/Max_iter);  % a2从-1到-2线性递减，用以计算公式（3.12）中的t 
    % 更新种群位置
    for i = 1:N
        r1 = rand();    % r1是[0,1]中的随机数
        r2 = rand();    % r2是[0,1]中的随机数
        
        A = 2*a*r1-a;       % 公式(2.3) 
        C = 2*r2;             % 公式(2.4) 
        
        b = 1;                         % 公式(2.5)里的参数
        l = (a2-1)*rand+1;       %  公式(2.5)里的参数
        
        p = rand();        % 公式(2.6)里的p
        
        for j = 1:dim
            if p < 0.5
                if abs(A) >= 1
                    %% 随机性学习策略
                    % 随机选择不等于i的k
                    K = [1:i-1 i+1:N];
                    k = K(randi([1 numel(K)]));
                    % 学习产生新个体
                    if fitness(k) < fitness(i)
                        X_new = X(i, :)+rand*(X(i, :)-X(k, :));
                    else
                        X_new = X(i, :)+rand*(X(k, :)-X(i, :));
                    end
                    % 判断随机学习产生的新个体是否优于当前个体
                    fit = fobj(X_new);
                    if fit < fitness(i)
                        X(i, :) = X_new;
                        fitness(i) = fit;
                    end
                    % 更新个体位置
                    rand_leader_index = floor(N*rand()+1);
                    X_rand = X(rand_leader_index, :);
                    D_X_rand = abs(C*X_rand(j)-X(i,j));          % 公式(2.7)
                    X(i, j) = w*X_rand(j)-A*D_X_rand;                % 公式(2.8)
                elseif abs(A) < 1
                    D_Leader = abs(C*Leader_pos(j)-X(i, j));     % 公式(2.1)
                    X(i, j) = w*Leader_pos(j)-A*D_Leader;               % 公式(2.2)
                end
            else
                distance2Leader = abs(Leader_pos(j)-X(i, j));
                % 公式(2.5)
                X(i, j) = distance2Leader*exp(b.*l).*cos(l.*2*pi)+(1-w)*Leader_pos(j);
            end
        end
    end
    for i = 1:N
        % 边界处理
        Flag4ub = X(i, :) > ub;
        Flag4lb = X(i, :) < lb;
        X(i, :) = (X(i, :).*(~(Flag4ub+Flag4lb)))+ub.*Flag4ub+lb.*Flag4lb;
        % 计算适应度
        fitness(i) = fobj(X(i, :));
    end
    % 记录上一次的最优解
    Last_Leader_score = Leader_score;
    % 初始化领导者的位置和适应度值
    [bestfitness, bestindex] = min(fitness);
    if bestfitness < Leader_score
        Leader_pos = X(bestindex, :);
        Leader_score = bestfitness;
    end
    if Leader_score == Last_Leader_score
        count = count+1;        % 无变化计数加1
    else
        count = 0;                   % 有变化计数赋为0
    end
    t = t+1;
    Curve(t) = Leader_score;
    
    disp(['MSWOA: At iteration ', num2str(t), ' ,the best fitness is ', num2str(Leader_score)]);
end

14、

function [fitnessgbest, gbest, zz] = PSO(X, N, maxgen, lb, ub, dim, fobj)

%% 参数初始化
c1 = 2;                           % 社会认知参数
c2 = 2;                           % 自我认知参数
Vmax = 2;                      % 最大速度
Vmin = -2;                      % 最小速度
ub = 100;                 % 位置最大值
lb = -100;                   % 位置最小值
Wmax = 0.8; Wmin = 0.2;
V = rand(N, dim).*(Vmax-Vmin)+Vmin;
for i = 1:N
    fitness(i) = fobj(X(i, :));
end
%% 
[bestfitness, bestindex] = min(fitness);
gbest = X(bestindex, :);                      % 群体最优极值
zbest = X;                         % 个体最优极值
fitnessgbest = bestfitness;     % 种群最优适应度值
fitnesszbest = fitness;           % 个体最优适应度值

%% 初始结果显示
disp(['初始位置：' , num2str(gbest)]);
disp(['初始函数值：', num2str(fitnessgbest)]);

%% 迭代寻优
for i = 1:maxgen
    W = Wmax-((Wmax-Wmin)/maxgen)*i;
    for j=1:N
        % 速度更新
        V(j, :) = W*V(j, :) + c1*rand*(zbest(j, :) - X(j, :)) + c2*rand*(gbest - X(j, :));
        V(j,find(V(j,:)>Vmax)) = Vmax;
        V(j,find(V(j,:)<Vmin)) = Vmin;
        
        % 种群更新
        X(j,:) = X(j,:) + V(j,:);
        X(j,find(X(j,:)>ub)) = ub;
        X(j,find(X(j,:)<lb)) = lb;
        
        % 适应度值更新
        fitness(j) = fobj(X(j,:));
    end
    %% 个体和群体极值更新
    for j = 1:N
        % 个体最优更新
        if fitness(j) < fitnesszbest(j)
            zbest(j,:) = X(j,:);
            fitnesszbest(j) = fitness(j);
        end
        
        % 群体最优更新
        if fitness(j) < fitnessgbest
            gbest = X(j,:);
            fitnessgbest = fitness(j);
        end
    end
    %% 每一代群体最优值存入zz数组
    zz(i) = fitnessgbest;
    
    disp(['PSO: At iteration ', num2str(i), ' ,the best fitness is ', num2str(zz(i))]);
end
% %% 最终结果显示
% disp(['最终位置：' , num2str(gbest)]);
% disp(['最终函数值：', num2str(zz(end))]);
% %% 绘图
% figure;
% plot(zz, 'r', 'lineWidth', 2);          %  画出迭代图
% xlabel('迭代次数', 'fontsize', 12);
% ylabel('目标函数值', 'fontsize', 12);

15、

function i = RouletteWheelSelection(P)
    r = rand;
    C = cumsum(P);
    i = find(r <= C, 1, 'first');
end

16、

function [Leader_score, Leader_pos, Curve] = WOA(Positions, N, Max_iter, lb, ub, dim, fobj)
%% The Whale Optimization Algorithm
% 计算适应度值
for i = 1:N
    fitness(i) = fobj(Positions(i, :));
end
% 初始化领导者的位置和适应度值
[bestfitness, bestindex] = min(fitness);
Leader_pos = Positions(bestindex, :);
Leader_score = bestfitness; 
% 初始化进化曲线
Curve = zeros(1, Max_iter);
t = 0;       % 迭代次数计数器

%% 迭代寻优
while t < Max_iter    
    a=2-t*((2)/Max_iter);    % 式（2.3）中，a从2线性减小到0
    a2=-1+t*((-1)/Max_iter);  % a2从-1到-2线性递减，用以计算公式（3.12）中的t 
    % 更新种群位置
    for i = 1:N
        r1 = rand();    % r1是[0,1]中的随机数
        r2 = rand();    % r2是[0,1]中的随机数
        
        A = 2*a*r1-a;       % 公式(2.3) 
        C = 2*r2;             % 公式(2.4) 
        
        b = 1;                         % 公式(2.5)里的参数
        l = (a2-1)*rand+1;       %  公式(2.5)里的参数
        
        p = rand();        % 公式(2.6)里的p
        
        for j = 1:dim
            if p < 0.5
                if abs(A) >= 1
                    rand_leader_index = floor(N*rand()+1);
                    X_rand = Positions(rand_leader_index, :);
                    D_X_rand = abs(C*X_rand(j)-Positions(i,j));          % 公式(2.7)
                    Positions(i, j) = X_rand(j)-A*D_X_rand;                % 公式(2.8)
                elseif abs(A) < 1
                    D_Leader = abs(C*Leader_pos(j)-Positions(i, j));     % 公式(2.1)
                    Positions(i, j) = Leader_pos(j)-A*D_Leader;               % 公式(2.2)
                end
            else
                distance2Leader = abs(Leader_pos(j)-Positions(i, j));
                % 公式(2.5)
                Positions(i, j) = distance2Leader*exp(b.*l).*cos(l.*2*pi)+Leader_pos(j);
            end
        end
    end
    for i = 1:N
        % 边界处理
        Flag4ub = Positions(i, :) > ub;
        Flag4lb = Positions(i, :) < lb;
        Positions(i, :) = (Positions(i, :).*(~(Flag4ub+Flag4lb)))+ub.*Flag4ub+lb.*Flag4lb;
        % 计算适应度
        fitness(i) = fobj(Positions(i, :));
    end
    % 初始化领导者的位置和适应度值
    [bestfitness, bestindex] = min(fitness);
    if bestfitness < Leader_score
        Leader_pos = Positions(bestindex, :);
        Leader_score = bestfitness;
    end
    t = t+1;
    Curve(t) = Leader_score;
    
    disp(['WOA: At iteration ', num2str(t), ' ,the best fitness is ', num2str(Leader_score)]);
end

17、

%% 清除环境变量
clear 
clc

%% 参数设置
N = 30;             % 种群规模
Function_name = 'F4';       % 从F1到F23的测试函数的名称（本文中的表1、2、3）
Max_iteration = 500;         % 最大迭代次数
% 加载所选基准函数的详细信息
[lb, ub, dim, fobj] = Get_Functions_details(Function_name);
% 初始化种群位置
X = initialization(N, dim, ub, lb);

[MSWOA_Best_score, MSWOA_Best_pos, MSWOA_Curve] = MSWOA(X, N, Max_iteration, lb, ub, dim, fobj);
[WOA_Best_score, WOA_Best_pos, WOA_Curve] = WOA(X, N, Max_iteration, lb, ub, dim, fobj);
[BOA_Best_score, BOA_Best_pos, BOA_Curve] = BOA(X, N, Max_iteration, lb, ub, dim, fobj);
[GWO_Best_score, GWO_Best_pos, GWO_Curve] = GWO(X, N, Max_iteration, lb, ub, dim, fobj);
[GSA_Best_score, GSA_Best_pos, GSA_Curve] = GSA(X, N, Max_iteration, lb, ub, dim, fobj);
[PSO_Best_score, PSO_Best_pos, PSO_Curve] = PSO(X, N, Max_iteration, lb, ub, dim, fobj);
[ABC_Best_score, ABC_Best_pos, ABC_Curve] = ABC(X, N, Max_iteration, lb, ub, dim, fobj);

%% 画图
% 1、画出所选基准函数的三维立体图形
figure;
func_plot(Function_name);
title(Function_name)
xlabel('x_1');
ylabel('x_2');
zlabel([Function_name,'( x_1 , x_2 )'])

% 2、画出目标函数值变化曲线图
figure;
t = 1:Max_iteration;
plot(t, MSWOA_Curve, 'r^-', t, WOA_Curve, 'ko-', t, BOA_Curve, 'bd-', t, GWO_Curve, 'cs-', ...
    t, GSA_Curve, 'mp-', t, PSO_Curve, 'k*-', t, ABC_Curve, 'gh-', ...
    'linewidth', 1.5, 'MarkerSize', 8, 'MarkerIndices', 1:50:Max_iteration);
title(Function_name)
xlabel('迭代次数');
ylabel('适应度值');
axis fill
grid on
box on
legend('MSWOA', 'WOA', 'BOA', 'GWO', 'GSA', 'PSO', 'ABC');
% h1 = axes('position', [0.4 0.3 0.2 0.3]);
% axis(h1);
% s = t(1:50);
% plot(h1, s, MSWOA_Curve(s), 'r^-', s, WOA_Curve(s), 'ko-', s, BOA_Curve(s), 'bd-', s, GWO_Curve(s), 'cs-', ...
%     s, GSA_Curve(s), 'mp-', s, PSO_Curve(s), 'k*-', s, ABC_Curve(s), 'gh-', ...
%     'linewidth', 1, 'MarkerSize', 6, 'MarkerIndices', 1:10:50);

%% 显示结果
disp(['MSWOA得到的最佳位置为 : ', num2str(MSWOA_Best_pos)]);
disp(['MSWOA得到的目标函数的最佳值为 : ', num2str(MSWOA_Best_score)]);
disp(['WOA得到的最佳位置为 : ', num2str(WOA_Best_pos)]);
disp(['WOA得到的目标函数的最佳值为 : ', num2str(WOA_Best_score)]);
disp(['BOA得到的最佳位置为 : ', num2str(BOA_Best_pos)]);
disp(['BOA得到的目标函数的最佳值为 : ', num2str(BOA_Best_score)]);
disp(['GWO得到的最佳位置为 : ', num2str(GWO_Best_pos)]);
disp(['GWO得到的目标函数的最佳值为 : ', num2str(GWO_Best_score)]);
disp(['GSA得到的最佳位置为 : ', num2str(GSA_Best_pos)]);
disp(['GSA得到的目标函数的最佳值为 : ', num2str(GSA_Best_score)]);
disp(['PSO得到的最佳位置为 : ', num2str(PSO_Best_pos)]);
disp(['PSO得到的目标函数的最佳值为 : ', num2str(PSO_Best_score)]);
disp(['ABC得到的最佳位置为 : ', num2str(ABC_Best_pos)]);
disp(['ABC得到的目标函数的最佳值为 : ', num2str(ABC_Best_score)]);

18、

clc;
clear;

%% 随机序列和Sobol序列对比
dim = 30;           % 维度
N = 500;
% Sobol序列
p = sobolset(dim);
for i = 1:N
    X(i, :) = p(i, :);
end
figure;
plot(X(:, 1), X(:, 2), 'b.', 'MarkerSize', 16);
xlabel '个体第一维度数值'; ylabel '个体第二维度数值';
title 'Sobol序列生成散点图';
% 随机序列
Y = rand(N, dim);
figure;
plot(Y(:, 1), Y(:, 2), 'b.', 'MarkerSize', 16);
xlabel '个体第一维度数值'; ylabel '个体第二维度数值';
title '随机生成个体散点图';

result