MATLAB实现粒子群算法的进阶讲解(多维+约束条件)

MATLAB实现粒子群算法的进阶讲解(多维+约束条件)我们在之前的博客中,对粒子群算法的实现进行了讲解,主要讲解了粒子群算法的产生,实现步骤,并且通过代码来实现了当输入变量为n维向量时的粒子群算法。许多网友对之前的代码有些疑惑,并且提到了几个问题:1,对于之前的代码,觉得有些看不懂?2,如果输入变量不再是n维向量,而是n*n维的矩阵,甚至n*n*n…维的矩阵,该如何编写代码?3,如果目标函数存在约束条件,该如何编写代码?本节就基于之前博客的内容,出现的问题,以及这两天我的一些学习,来对上述问题进行一个解答。

大家好,又见面了,我是你们的朋友全栈君。

我们在之前的博客中,对粒子群算法的实现进行了讲解,主要讲解了粒子群算法的产生,实现步骤,并且通过代码来实现了当输入变量为n维向量时的粒子群算法。
许多网友对之前的代码有些疑惑,并且提到了几个问题:
1,对于之前的代码,觉得有些看不懂?
2,如果输入变量不再是n维向量,而是n*n维的矩阵,甚至n*n*n…维的矩阵,该如何编写代码?
3,如果目标函数存在约束条件,该如何编写代码?
本节就基于之前博客的内容,出现的问题,以及这两天我的一些学习,来对上述问题进行一个解答。

上一讲博客链接在此:(https://blog.csdn.net/DBLLLLLLLL/article/details/82965722)

1.自变量为2维向量的粒子群算法

首先还是从最简单的开始,关于自变量为2维的粒子群算法,其代码的实现过程可以参考上一讲的博客,这里我对于该代码进行了一些改进。主要改进就是增加了一个自适应变异机制,即每次算法计算周期,都有一定的概率随机改变某一个个体的数值,从而提高了整个粒子群的寻优能力。关于这个能力,感兴趣的人可以尝试将代码中的自适应变异的代码段注释掉,观察结果,可以有更直观的感受。

%% 清空环境
clc;clear all;close all;
%% 目标函数
%  下面这个函数叫做Schaffer函数,最小值在(0,0)处,为0
fun= @(a,b)(0.5+(sin(sqrt(a.^2+b.^2)).^2-0.5)./((1+0.001.*(a.^2+b.^2)).^2));
%  绘图函数,可舍弃
figure(1);
[x0_1, x0_2]=meshgrid(-5:0.1:5);
y0=fun(x0_1,x0_2);
mesh(x0_1, x0_2, y0);
hold on;
%% 设置种群参数
%   需要自行配置
sizepop = 500;                         % 初始种群个数
dim = 2;                           % 空间维数
ger = 300;                       % 最大迭代次数     
xlimit = [ -5,5 ; -5 ,5 ];        % 设置位置参数限制(矩阵的形式可以多维)
vlimit = [ -1.5,1.5 ; -1.5,1.5]; % 设置速度限制
c_1 = 0.8;                       % 惯性权重
c_2 = 0.5;                       % 自我学习因子
c_3 = 0.5;                       % 群体学习因子 
%% 生成初始种群
%  首先随机生成初始种群位置
%  然后随机生成初始种群速度
%  然后初始化个体历史最佳位置,以及个体历史最佳适应度
%  然后初始化群体历史最佳位置,以及群体历史最佳适应度
%  绘图(可舍弃)
 for i = 1:dim
    pop_x(i,:) = xlimit(i, 1) + (xlimit(i, 2) - xlimit(i, 1)) * rand(1, sizepop);%初始种群的位置
end    
pop_v = rand(dim, sizepop);                   % 初始种群的速度
gbest = pop_x;                                % 每个个体的历史最佳位置
fitness_gbest = fun(pop_x(1,:),pop_x(2,:));   % 每个个体的历史最佳适应度
zbest = pop_x(:,1);                          % 种群的历史最佳位置
fitness_zbest = fitness_gbest(1);             % 种群的历史最佳适应度
for j=1:sizepop
    if fitness_gbest(j) < fitness_zbest       % 如果求最小值,则为<; 如果求最大值,则为>; 
        zbest = pop_x(:,j);
        fitness_zbest=fitness_gbest(j);
    end
end

plot3(gbest(1,:),gbest(2,:),fun(gbest(1,:),gbest(2,:)), 'ro');title('初始状态图');
hold on;
figure(2);
mesh(x0_1, x0_2, y0);
hold on;
plot3(gbest(1,:),gbest(2,:),fun(gbest(1,:),gbest(2,:)), 'ro');
hold on;

%% 粒子群迭代
%    更新速度并对速度进行边界处理    
%    更新位置并对位置进行边界处理
%    进行自适应变异
%    计算新种群各个个体位置的适应度
%    新适应度与个体历史最佳适应度做比较
%    个体历史最佳适应度与种群历史最佳适应度做比较
%    再次循环或结束

iter = 1;                        %迭代次数
times = 1;                       %用于显示,可舍弃
record = zeros(ger, 1);          % 记录器
while iter <= ger
    
    %    更新速度并对速度进行边界处理 
    pop_v =  c_1 * pop_v  + c_2 * rand *(gbest - pop_x) + c_3 * rand *(repmat(zbest, 1, sizepop) - pop_x);% 速度更新
    for i=1:dim 
        for j=1:sizepop
            if  pop_v(i,j)>vlimit(i,2)
                pop_v(i,j)=vlimit(i,2);
            end
            if  pop_v(i,j) < vlimit(i,1)
                pop_v(i,j)=vlimit(i,1);
            end
        end
    end 
    
    %    更新位置并对位置进行边界处理
    pop_x = pop_x + pop_v;% 位置更新
    % 边界位置处理
    for i=1:dim 
        for j=1:sizepop
            if  pop_x(i,j)>xlimit(i,2)
                pop_x(i,j)=xlimit(i,2);
            end
            if  pop_x(i,j) < xlimit(i,1)
                pop_x(i,j)=xlimit(i,1);
            end
        end
    end
    
    %    自适应变异
    for j=1:sizepop
        if rand > 0.85
            i=ceil(dim*rand);
            pop_x(i,j)=xlimit(i, 1) + (xlimit(i, 2) - xlimit(i, 1)) * rand;
        end
    end
    
    %    计算新种群各个个体位置的适应度
    fitness_pop = fun(pop_x(1,:),pop_x(2,:)) ; % 当前所有个体的适应度
    
    %    新适应度与个体历史最佳适应度做比较
    for j = 1:sizepop      
        if fitness_pop(j) < fitness_gbest(j)       % 如果求最小值,则为<; 如果求最大值,则为>; 
            gbest(:,j) = pop_x(:,j);               % 更新个体历史最佳位置            
            fitness_gbest(j) = fitness_pop(j);     % 更新个体历史最佳适应度
        end 
    end
    
    %    个体历史最佳适应度与种群历史最佳适应度做比较
    for j = 1:sizepop  
        if fitness_gbest(j) < fitness_zbest        % 如果求最小值,则为<; 如果求最大值,则为>; 
            zbest = gbest(:,j);                    % 更新群体历史最佳位置  
            fitness_zbest=fitness_gbest(j);        % 更新群体历史最佳适应度  
        end
    end
    
    record(iter) = fitness_zbest;%最大值记录
    
    if times >= 10        %显示函数 可以舍去
        cla;
        mesh(x0_1, x0_2, y0);
        plot3(pop_x(1,:),pop_x(2,:),fun(pop_x(1,:),pop_x(2,:)), 'ro');title('状态位置变化');
        pause(0.5);
        times=0;
    end
    
    iter = iter+1;
    times=times+1;        %显示函数 可以舍去
end
%% 迭代结果输出

figure(3);plot(record);title('收敛过程')
figure(4);
mesh(x0_1, x0_2, y0);
hold on;
plot3(pop_x(1,:),pop_x(2,:),fun(pop_x(1,:),pop_x(2,:)), 'ro');title('最终状态图');

disp(['最优值:',num2str(fitness_zbest)]);
disp('变量取值:');
disp(zbest);

2.自变量为n维向量的粒子群算法

根据自变量为2位的粒子群算法的代码,我们可以很容易就类比出来自变量为n维的粒子群算法的代码。这里很多人对于这个类比过程不太擅长,那我把已经写好的5维的代码发出来供大家参考。

%% 清空环境
clc;clear all;close all;
%% 目标函数
%    下列函数为Rastrigin函数,是一个多峰值的函数,在0向量处取得全局最小值0
fun= @(X)(sum((X.^2-10*cos(2*pi*X)+10),1));

%% 设置种群参数
%   需要自行配置
sizepop = 500;                    % 初始种群个数
dim = 5;                          % 空间维数
ger = 200;                       % 最大迭代次数     
xlimit_max = 5.12*ones(dim,1);    % 设置位置参数限制(矩阵的形式可以多维)
xlimit_min = -5.12*ones(dim,1);
vlimit_max = 1*ones(dim,1);       % 设置速度限制
vlimit_min = -1*ones(dim,1);
c_1 = 0.8;                        % 惯性权重
c_2 = 0.5;                        % 自我学习因子
c_3 = 0.5;                        % 群体学习因子 

%% 生成初始种群
%  首先随机生成初始种群位置
%  然后随机生成初始种群速度
%  然后初始化个体历史最佳位置,以及个体历史最佳适应度
%  然后初始化群体历史最佳位置,以及群体历史最佳适应度
for i=1:dim
    for j=1:sizepop
        pop_x(i,j) = xlimit_min(i)+(xlimit_max(i) - xlimit_min(i))*rand;
        pop_v(i,j) = vlimit_min(i)+(vlimit_max(i) - vlimit_min(i))*rand;  % 初始种群的速度
    end
end    
gbest = pop_x;                                % 每个个体的历史最佳位置
fitness_gbest = fun(pop_x);                   % 每个个体的历史最佳适应度
zbest = pop_x(:,1);                           % 种群的历史最佳位置
fitness_zbest = fitness_gbest(1);             % 种群的历史最佳适应度
for j=1:sizepop
    if fitness_gbest(j) < fitness_zbest       % 如果求最小值,则为<; 如果求最大值,则为>; 
        zbest = pop_x(:,j);
        fitness_zbest=fitness_gbest(j);
    end
end


%% 粒子群迭代
%    更新速度并对速度进行边界处理    
%    更新位置并对位置进行边界处理
%    进行自适应变异
%    计算新种群各个个体位置的适应度
%    新适应度与个体历史最佳适应度做比较
%    个体历史最佳适应度与种群历史最佳适应度做比较
%    再次循环或结束

iter = 1;                        %迭代次数
record = zeros(ger, 1);          % 记录器
while iter <= ger
    for j=1:sizepop
        %    更新速度并对速度进行边界处理 
        pop_v(:,j)= c_1 * pop_v(:,j) + c_2*rand*(gbest(:,j)-pop_x(:,j))+c_3*rand*(zbest-pop_x(:,j));% 速度更新
        for i=1:dim
            if  pop_v(i,j) > vlimit_max(i)
                pop_v(i,j) = vlimit_max(i);
            end
            if  pop_v(i,j) < vlimit_min(i)
                pop_v(i,j) = vlimit_min(i);
            end
        end
        
        %    更新位置并对位置进行边界处理
        pop_x(:,j) = pop_x(:,j) + pop_v(:,j);% 位置更新
        for i=1:dim
            if  pop_x(i,j) > xlimit_max(i)
                pop_x(i,j) = xlimit_max(i);
            end
            if  pop_x(i,j) < xlimit_min(i)
                pop_x(i,j) = xlimit_min(i);
            end
        end
        
        %    进行自适应变异
        if rand > 0.85
            i=ceil(dim*rand);
            pop_x(i,j)=xlimit_min(i) + (xlimit_max(i) - xlimit_min(i)) * rand;
        end
  
        %    计算新种群各个个体位置的适应度

        fitness_pop(j) = fun(pop_x(:,j));                      % 当前个体的适应度

        
        %    新适应度与个体历史最佳适应度做比较
        if fitness_pop(j) < fitness_gbest(j)       % 如果求最小值,则为<; 如果求最大值,则为>; 
            gbest(:,j) = pop_x(:,j);               % 更新个体历史最佳位置            
            fitness_gbest(j) = fitness_pop(j);     % 更新个体历史最佳适应度
        end   
        
        %    个体历史最佳适应度与种群历史最佳适应度做比较
        if fitness_gbest(j) < fitness_zbest        % 如果求最小值,则为<; 如果求最大值,则为>; 
            zbest = gbest(:,j);                    % 更新群体历史最佳位置  
            fitness_zbest=fitness_gbest(j);        % 更新群体历史最佳适应度  
        end    
    end
    
    record(iter) = fitness_zbest;%最大值记录
    
    iter = iter+1;

end
%% 迭代结果输出

plot(record);title('收敛过程')
disp(['最优值:',num2str(fitness_zbest)]);
disp('变量取值:');
disp(zbest);

3.自变量为n维向量且存在约束条件的粒子群算法

解决了输入为n维向量的粒子群算法的代码,接下来我们来看,当存在约束条件时,如何构造这个算法。这里采用的思想是,对每一个粒子进行判断,判断该粒子的取值是否满足约束条件,如果满足,则进行正常的适应度计算,如果不满足,则将该粒子的适应度直接赋值为一个很大的数(求最小值时赋值成大数,求最大值时应该赋值成小数)。具体代码实现如下:

%% 清空环境
clc;clear all;close all;
%% 目标函数
%    下列函数为:
%    y=0.072*x1+0.063*x2+0.057*x3+0.05*x4+0.032*x5+0.0442*x6+0.0675*x7+7
%    约束条件为:
%    0.072*x1+0.063*x2+0.057*x3+0.05*x4+0.032*x5+0.0442*x6+0.0675*x7<=264.4
%    128*x1+78.1*x2+64.1*x3+43*x4+58.1*x5+36.9*x6+50.5*x7<=67919
a=[0.072,0.063,0.057,0.05,0.032,0.0442,0.0675];
b=[0.072,0.063,0.057,0.005,0.032,0.0442,0.0675];
c=[128,78.1,64.1,43,58.1,36.9,50.5];
fun= @(X)(a*X+7);
cons1= @(X)(b*X<=264.4);
cons2= @(X)(c*X>=-20);
%% 设置种群参数
%   需要自行配置
sizepop = 500;                         % 初始种群个数
dim = 7;                           % 空间维数
ger = 500;                       % 最大迭代次数    
xlimit_max = 50*ones(dim,1);     % 设置位置参数限制(矩阵的形式可以多维)
xlimit_min = -50*ones(dim,1);
vlimit_max = 1*ones(dim,1);      % 设置速度限制
vlimit_min = -1*ones(dim,1);
c_1 = 0.8;                       % 惯性权重
c_2 = 0.5;                       % 自我学习因子
c_3 = 0.5;                       % 群体学习因子 

%% 生成初始种群
%  首先随机生成初始种群位置
%  然后随机生成初始种群速度
%  然后初始化个体历史最佳位置,以及个体历史最佳适应度
%  然后初始化群体历史最佳位置,以及群体历史最佳适应度
for i=1:dim
    for j=1:sizepop
        pop_x(i,j) = xlimit_min(i)+(xlimit_max(i) - xlimit_min(i))*rand;  % 初始种群的位置
        pop_v(i,j) = vlimit_min(i)+(vlimit_max(i) - vlimit_min(i))*rand;  % 初始种群的速度
    end
end                 
gbest = pop_x;                                % 每个个体的历史最佳位置
for j=1:sizepop
    if cons1(pop_x(:,j))
        if cons2(pop_x(:,j))
            fitness_gbest(j) = fun(pop_x(:,j));                      % 每个个体的历史最佳适应度
        else
            fitness_gbest(j) = 10^10; 
        end
    else
        fitness_gbest(j) = 10^10; 
    end  
end                  
zbest = pop_x(:,1);                           % 种群的历史最佳位置
fitness_zbest = fitness_gbest(1);             % 种群的历史最佳适应度
for j=1:sizepop
    if fitness_gbest(j) < fitness_zbest       % 如果求最小值,则为<; 如果求最大值,则为>; 
        zbest = pop_x(:,j);
        fitness_zbest=fitness_gbest(j);
    end
end


%% 粒子群迭代
%    更新速度并对速度进行边界处理    
%    更新位置并对位置进行边界处理
%    进行自适应变异
%    进行约束条件判断并计算新种群各个个体位置的适应度
%    新适应度与个体历史最佳适应度做比较
%    个体历史最佳适应度与种群历史最佳适应度做比较
%    再次循环或结束

iter = 1;                        %迭代次数
record = zeros(ger, 1);          % 记录器
while iter <= ger
    for j=1:sizepop
        %    更新速度并对速度进行边界处理 
        pop_v(:,j)= c_1 * pop_v(:,j) + c_2*rand*(gbest(:,j)-pop_x(:,j))+c_3*rand*(zbest-pop_x(:,j));% 速度更新
        for i=1:dim
            if  pop_v(i,j) > vlimit_max(i)
                pop_v(i,j) = vlimit_max(i);
            end
            if  pop_v(i,j) < vlimit_min(i)
                pop_v(i,j) = vlimit_min(i);
            end
        end
        
        %    更新位置并对位置进行边界处理
        pop_x(:,j) = pop_x(:,j) + pop_v(:,j);% 位置更新
        for i=1:dim
            if  pop_x(i,j) > xlimit_max(i)
                pop_x(i,j) = xlimit_max(i);
            end
            if  pop_x(i,j) < xlimit_min(i)
                pop_x(i,j) = xlimit_min(i);
            end
        end
        
        %    进行自适应变异
        if rand > 0.85
            i=ceil(dim*rand);
            pop_x(i,j)=xlimit_min(i) + (xlimit_max(i) - xlimit_min(i)) * rand;
        end
  
        %    进行约束条件判断并计算新种群各个个体位置的适应度
        if cons1(pop_x(:,j))
            if cons2(pop_x(:,j))
                fitness_pop(j) = fun(pop_x(:,j));                      % 当前个体的适应度
            else
                fitness_pop(j) = 10^10; 
            end
        else
            fitness_pop(j) = 10^10; 
        end
        
        %    新适应度与个体历史最佳适应度做比较
        if fitness_pop(j) < fitness_gbest(j)       % 如果求最小值,则为<; 如果求最大值,则为>; 
            gbest(:,j) = pop_x(:,j);               % 更新个体历史最佳位置            
            fitness_gbest(j) = fitness_pop(j);     % 更新个体历史最佳适应度
        end   
        
        %    个体历史最佳适应度与种群历史最佳适应度做比较
        if fitness_gbest(j) < fitness_zbest        % 如果求最小值,则为<; 如果求最大值,则为>; 
            zbest = gbest(:,j);                    % 更新群体历史最佳位置  
            fitness_zbest=fitness_gbest(j);        % 更新群体历史最佳适应度  
        end    
    end
    
    record(iter) = fitness_zbest;%最大值记录
    
    iter = iter+1;

end
%% 迭代结果输出

plot(record);title('收敛过程')
disp(['最优值:',num2str(fitness_zbest)]);
disp('变量取值:');
disp(zbest);

4.自变量为n*n维矩阵且存在约束条件的粒子群算法

有些网友说,自己所要解决的情况,输入变量不仅仅是一个n维的向量,而是一个n*n维的矩阵,甚至n*n*n*…维的空间矩阵。想要采用粒子群算法,该如何实现呢?
其实每一个n*n维矩阵,可以看成是n维向量,每个向量的元素又是一个向量,这样不断嵌套得到的。因此总的来说,整个代码的框架并没有太大的变化,仅仅是将原来的计算多嵌套几层就好。
代码如下:

%% 清空环境
clc;clear all;close all;
%% 目标函数
%    该函数的变量是一个3*4的矩阵形式的变量
%    cons1=@(X)(1);表示无约束条件
%    cons1=@(X)(sum(sum(X))>=0);可以尝试添加约束条件
a=[2.5,4.5,-2];
b=[2;4.2;4;-4];
c=[1,2,3,4;-4,-3,-2,-1;1,3,2,4];
fun= @(X)(sum(sum(c.*X.^2))+a*X*b);
cons1=@(X)(sum(sum(X))>=0);    
%% 设置种群参数
%   需要自行配置
%   下文中所有出现dim2,或者:的地方,都需要根据实际的矩阵维度来进行更改
sizepop = 500;                         % 初始种群个数
dim1 = 3;                           % 空间维数
dim2 = 4;
ger = 500;                       % 最大迭代次数    
xlimit_max = 50*ones(dim1,dim2,1);     % 设置位置参数限制(矩阵的形式可以多维)
xlimit_min = -50*ones(dim1,dim2,1);
vlimit_max = 1*ones(dim1,dim2,1);      % 设置速度限制
vlimit_min = -1*ones(dim1,dim2,1);
c_1 = 0.8;                       % 惯性权重
c_2 = 0.5;                       % 自我学习因子
c_3 = 0.5;                       % 群体学习因子 

%% 生成初始种群
%  首先随机生成初始种群位置
%  然后随机生成初始种群速度
%  然后初始化个体历史最佳位置,以及个体历史最佳适应度
%  然后初始化群体历史最佳位置,以及群体历史最佳适应度
for i_1=1:dim1
    for i_2=1:dim2      
        for j=1:sizepop
            pop_x(i_1,i_2,j) = xlimit_min(i_1,i_2)+(xlimit_max(i_1,i_2) - xlimit_min(i_1,i_2))*rand;  % 初始种群的位置
            pop_v(i_1,i_2,j) = vlimit_min(i_1,i_2)+(vlimit_max(i_1,i_2) - vlimit_min(i_1,i_2))*rand;  % 初始种群的速度
        end
    end
end                 
gbest = pop_x;                                % 每个个体的历史最佳位置
for j=1:sizepop                               % 每个个体的历史最佳适应度
    if cons1(pop_x(:,:,j))                      % 约束条件       
        fitness_gbest(j)=fun(pop_x(:,:,j));                    
    else
        fitness_gbest(j) = 10^10; 
    end  
end   
zbest = pop_x(:,:,1);                           % 种群的历史最佳位置
fitness_zbest = fitness_gbest(1);             % 种群的历史最佳适应度
for j=1:sizepop
    if fitness_gbest(j) < fitness_zbest       % 如果求最小值,则为<; 如果求最大值,则为>; 
        zbest = pop_x(:,:,j);
        fitness_zbest=fitness_gbest(j);
    end
end


%% 粒子群迭代
%    更新速度并对速度进行边界处理    
%    更新位置并对位置进行边界处理
%    进行自适应变异
%    进行约束条件判断并计算新种群各个个体位置的适应度
%    新适应度与个体历史最佳适应度做比较
%    个体历史最佳适应度与种群历史最佳适应度做比较
%    再次循环或结束

iter = 1;                        %迭代次数
record = zeros(ger, 1);          % 记录器
while iter <= ger
    for j=1:sizepop
        %    更新速度并对速度进行边界处理 
        pop_v(:,:,j)= c_1 * pop_v(:,:,j) + c_2*rand*(gbest(:,:,j)-pop_x(:,:,j))+c_3*rand*(zbest-pop_x(:,:,j));% 速度更新
        for i_1=1:dim1
            for i_2=1:dim2
                if  pop_v(i_1,i_2,j) > vlimit_max(i_1,i_2)
                    pop_v(i_1,i_2,j) = vlimit_max(i_1,i_2);
                end
                if  pop_v(i_1,i_2,j) < vlimit_min(i_1,i_2)
                    pop_v(i_1,i_2,j) = vlimit_min(i_1,i_2);
                end                
            end
        end
        
        %    更新位置并对位置进行边界处理
        pop_x(:,:,j) = pop_x(:,:,j) + pop_v(:,:,j);% 位置更新
        for i_1=1:dim1
            for i_2=1:dim2
                if  pop_x(i_1,i_2,j) > xlimit_max(i_1,i_2)
                    pop_x(i_1,i_2,j) = xlimit_max(i_1,i_2);
                end
                if  pop_x(i_1,i_2,j) < xlimit_min(i_1,i_2)
                    pop_x(i_1,i_2,j) = xlimit_min(i_1,i_2);
                end
            end
        end
        
        %    进行自适应变异
        if rand > 0.85
            i_1=ceil(dim1*rand);
            i_2=ceil(dim2*rand);
            pop_x(i_1,i_2,j)=xlimit_min(i_1,i_2) + (xlimit_max(i_1,i_2) - xlimit_min(i_1,i_2)) * rand;
        end
      
  
        %    进行约束条件判断并计算新种群各个个体位置的适应度
        if cons1(pop_x(:,:,j))                                       % 约束条件
            fitness_pop(j) = fun(pop_x(:,:,j));                      % 当前个体的适应度
        else
            fitness_pop(j) = 10^10; 
        end
        
        %    新适应度与个体历史最佳适应度做比较
        if fitness_pop(j) < fitness_gbest(j)       % 如果求最小值,则为<; 如果求最大值,则为>; 
            gbest(:,:,j) = pop_x(:,:,j);               % 更新个体历史最佳位置            
            fitness_gbest(j) = fitness_pop(j);     % 更新个体历史最佳适应度
        end   
        
        %    个体历史最佳适应度与种群历史最佳适应度做比较
        if fitness_gbest(j) < fitness_zbest        % 如果求最小值,则为<; 如果求最大值,则为>; 
            zbest = gbest(:,:,j);                    % 更新群体历史最佳位置  
            fitness_zbest=fitness_gbest(j);        % 更新群体历史最佳适应度  
        end    
    end
    
    record(iter) = fitness_zbest;%最大值记录
    
    iter = iter+1;

end
%% 迭代结果输出

plot(record);title('收敛过程')
disp(['最优值:',num2str(fitness_zbest)]);
disp('变量取值:');
disp(zbest);
版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/133327.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

  • Java面试之Web「建议收藏」

    Java面试之Web「建议收藏」Java面试之Web

  • Petshop4.0下载及安装图解教程[通俗易懂]

    Petshop4.0下载及安装图解教程[通俗易懂]前面简单介绍了petshop4.0以及SQL2005的安装图解,那么下面我们就来介绍下petshop4.0的下载和petshop4.0的安装petshop4.0下载petshop4.0下载地址:http://download.microsoft.com/download/8/0/1/801ff297-aea6-46b9-8e11-810df5df1032/Microsoft%20.NET%20Pet%20Shop%204.0.msi这个是官方的下载地址,要怎么下载应…

  • 软件架构模式和设计模式的区别_几种常见软件架构

    软件架构模式和设计模式的区别_几种常见软件架构什么是架构?  软件体系结构通常被称为架构,指可以预制和可重构的软件框架结构。架构尚处在发展期,对于其定义,学术界尚未形成一个统一的意见,而不同角度的视点也会造成软件体系结构的不同理解,以下是一些主流的标准观点。ANSI/IEEE610.12-1990软件工程标准词汇对于体系结构定义是:“体系架构是以构件、构件之间的关系、构件与环境之间的关系为内容的某一系统的基本组织结构以及知道上

    2022年10月18日
  • DOS攻击手段_ddos攻击原理与防御方法

    DOS攻击手段_ddos攻击原理与防御方法DDoS介绍DDoS是英文DistributedDenialofService的缩写,意即“分布式拒绝服务”,那么什么又是拒绝服务(DenialofService)呢?可以这么理解,凡是能导致合法用户不能够访问正常网络服务的行为都算是拒绝服务攻击。也就是说拒绝服务攻击的目的非常明确,就是要阻止合法用户对正常网络资源的访问,从而达成攻击者不可告人的目的。分布式拒绝服务攻击一旦被实施,攻击网络包就会从很多DOS攻击源(俗称肉鸡)犹如洪水般涌向受害主机,从而把合法用户的网络包淹没,导致合法用户无法正

  • Java文件路径/服务器路径的获取

    Java文件路径/服务器路径的获取Java文件路径获取几种获取方式getResourceAsStream()返回的是inputstreamgetResource()返回:URLClass.getResource(“”)   返回的是当前Class这个类所在包开始的为置Class.getResource(“/”)返回的是classpath的位置getClassLoader().getResour

  • Try catch如何使用[通俗易懂]

    Try catch如何使用[通俗易懂]trycatch适用场合:一、兼容性浏览器的兼容性是程序员很头痛的事儿,往往一些出错会让我们查找许久,在使用trycatch能更好的解决兼容性出错的问题:由于不同浏览器报错提示也不尽相同,通过使用trycatch捕获的浏览器的报错提示,来判断用户使用的浏览器,然后做出对应的解决方法;那么,你如果用if,就只能反馈真或假,而不能直接抛出浏览器的报错内容。二、防止阻塞trycatch用…

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号