粒子群算法(7)------粒子群算法局部版本的实现

最新推荐文章于 2023-05-11 10:44:58 发布

Deng笨蛋

最新推荐文章于 2023-05-11 10:44:58 发布

阅读量1k

点赞数

分类专栏：粒子群算法文章标签：粒子群算法粒子群

粒子群算法专栏收录该内容

9 篇文章 2 订阅

订阅专栏

最近要写篇与粒子群算法有关的文章，因此不得不实现粒子群算法的局部版本。粒子群算法局部版本的实现思想已经在粒子群算法(3)----标准的粒子群算法(局部版本)中已经讲述。主要分为3个函数。第一个函数为粒子群初始化函数LocalInitSwarm(SwarmSize......AdaptFunc)其主要作用是初始化粒子群的粒子，并设定粒子的速度、位置在一定的范围内。本函数所采用的数据结构如下所示：

表ParSwarm记录的是粒子的位置、速度与当前的适应度值，我们用W来表示位置，用V来代表速度，用F来代表当前的适应度值。在这里我们假设粒子个数为N，每个粒子的维数为D。

W_1,1	W_1,2	...	W_1,D	V_1,1	V_1,2	...	V_1,D-1	V_1,D	F₁	第1个粒子
W_2,1	W_2,2	...	W_2,D	V_2,1	V_2,2	...	V_2,D-1	V_2,D	F₂	第2个粒子
...	...	...	...	...	...	...	...	...	...	.......
W_N-1,1	W_N-1,2	...	W_N-1,D-1	V_N-1,1	V_N-1,2	...	V_N-1,D-1	V_N-1,D	F_N-1	第N-1个粒子
W_N,1	W_N,2	...	W_N,D	V_N,1	V_N,2	...	V_N,D-1	V_N,D	F_N	第N个粒子

表OptSwarm不但要记录自身历史最优解，还需要记录每个粒子邻域（采用环形邻域）的最优解，以及全部粒子搜索到的全局最优解。因此应该有2*N+1行，前SwarmSize行记录粒子自己历史最优解，后SwarmSize行记录邻域最优解。用Wg代表全局最优解，W.,1代表每个粒子的历史最优解。粒子群初始化阶段表OptSwarm的前N行与表ParSwarm中

的相同，而Wg的值为表ParSwarm中适应度值的最大值对应的行。

W1,1	Wj,2	...	Wj,D-1	Wj,D	第1个粒子的历史最优解
W2,1	Wk,2	...	Wk,D-1	Wk,D	第2个粒子的历史最优解
...	...	...	...	...	...
W(N-1),1	Wl,2	...	Wl,D-1	Wl,D	第N-1个粒子的历史最优解
W(N),1	Wm,2	...	Wm,D-1	Wm,D	第N个粒子的历史最优解
Wl,1	...	...	...	Wl,D	第一个粒子的邻域最优解
Wl,2	...	...	...	Wl,D	第二个粒子的邻域最优解
...	...	...	...	.....	....
Wl,N	...	...	...	...	第N个粒子的邻域最优解
Wg,1	Wg,2	...	Wg,D-1	Wg,D	全局粒子的历史最优解

根据这样的思想MATLAB代码如下：

function [ParSwarm,OptSwarm]=LocalInitSwarm(SwarmSize,ParticleSize,ParticleScope,AdaptFunc)
%功能描述：局部版本的粒子群算法，初始化粒子群，限定粒子群的位置以及速度在指定的范围内
%[ParSwarm,OptSwarm,BadSwarm]=LocalInitSwarm(SwarmSize,ParticleSize,ParticleScope,AdaptFunc)
%
%输入参数：SwarmSize:种群大小的个数
%输入参数：ParticleSize：一个粒子的维数
%输入参数：ParticleScope:一个粒子在运算中各维的范围；
%         ParticleScope格式:
%           3维粒子的ParticleScope格式:
%                                   [x1Min,x1Max
%                                    x2Min,x2Max
%                                    x3Min,x3Max]
%
%输入参数：AdaptFunc：适应度函数
%
%输出：ParSwarm初始化的粒子群
%输出：OptSwarm粒子群当前最优解与每个粒子邻域的最优解，第一次初始化，邻域的区域为0，即为粒子本身
%
%用法 [ParSwarm,OptSwarm,BadSwarm]=LocalInitSwarm(SwarmSize,ParticleSize,ParticleScope,AdaptFunc);
%
%异常：首先保证该文件在Matlab的搜索路径中，然后查看相关的提示信息。
%
%编制人：XXX
%编制时间：2010.5.6
%参考文献：无
%

%容错控制
if nargin~=4
    error('输入的参数个数错误。')
end
if nargout<2
    error('输出的参数的个数太少，不能保证以后的运行。');
end

[row,colum]=size(ParticleSize);
if row>1||colum>1
    error('输入的粒子的维数错误，是一个1行1列的数据。');
end
[row,colum]=size(ParticleScope);
if row~=ParticleSize||colum~=2
    error('输入的粒子的维数范围错误。');
end

%初始化粒子群矩阵

%初始化粒子群矩阵，全部设为[0-1]随机数
%rand('state',0);
ParSwarm=rand(SwarmSize,2*ParticleSize+1);

%对粒子群中位置,速度的范围进行调节
for k=1:ParticleSize
    ParSwarm(:,k)=ParSwarm(:,k)*(ParticleScope(k,2)-ParticleScope(k,1))+ParticleScope(k,1);
    %调节速度，使速度与位置的范围一致
    ParSwarm(:,ParticleSize+k)=ParSwarm(:,ParticleSize+k)*(ParticleScope(k,2)-ParticleScope(k,1))+ParticleScope(k,1);
end
    
%对每一个粒子计算其适应度函数的值

for k=1:SwarmSize
    ParSwarm(k,2*ParticleSize+1)=AdaptFunc(ParSwarm(k,1:ParticleSize));
end

%初始化粒子群最优解矩阵,共SwarmSize*2行，其中前SwarmSize行记录粒子自己历史最优解，后SwarmSize行记录邻域最优解
OptSwarm=zeros(SwarmSize*2+1,ParticleSize);
%粒子群最优解矩阵全部设为零
OptSwarm(1:SwarmSize,:)=ParSwarm(1:SwarmSize,1:ParticleSize);
%计算粒子邻域为1的最优解
linyu=1;
    for row=1:SwarmSize
        if row-linyu>0&&row+linyu<=SwarmSize
            tempM =[ParSwarm(row-linyu:row-1,:);ParSwarm(row+1:row+linyu,:)];            
            [maxValue,linyurow]=max(tempM(:,2*ParticleSize+1));           
            OptSwarm(SwarmSize+row,:)=tempM(linyurow,1:ParticleSize);           
        else
            if row-linyu<=0
                %该行上面的部分突出了边界，下面绝对不会突破边界
                if row==1
                    tempM=[ParSwarm(SwarmSize+row-linyu:end,:);ParSwarm(row+1:row+linyu,:)];
                    [maxValue,linyurow]=max(tempM(:,2*ParticleSize+1));                     
                    OptSwarm(SwarmSize+row,:)=tempM(linyurow,1:ParticleSize);                   
                else
                    tempM=[ParSwarm(1:row-1,:);ParSwarm(SwarmSize+row-linyu:end,:);ParSwarm(row+1:row+linyu,:)];
                    [maxValue,linyurow]=max(tempM(:,2*ParticleSize+1));                    
                    OptSwarm(SwarmSize+row,:)=tempM(linyurow,1:ParticleSize);                  
                end
            else
                %该行下面的部分突出了边界，上面绝对不会突破边界
                if row==SwarmSize
                    tempM=[ParSwarm(SwarmSize-linyu:row-1,:);ParSwarm(1:linyu,:)];
                    [maxValue,linyurow]=max(tempM(:,2*ParticleSize+1));                     
                    OptSwarm(SwarmSize+row,:)=tempM(linyurow,1:ParticleSize);
                else
                    tempM=[ParSwarm(row-linyu:row-1,:);ParSwarm(row+1:end,:);ParSwarm(1:linyu-(SwarmSize-row),:)];  
                    [maxValue,linyurow]=max(tempM(:,2*ParticleSize+1));                    
                    OptSwarm(SwarmSize+row,:)=tempM(linyurow,1:ParticleSize);                    
                end
            end
        end
    end%for
[maxValue,row]=max(ParSwarm(:,2*ParticleSize+1));
%寻找适应度函数值最大的解在矩阵中的位置(行数)
OptSwarm(SwarmSize*2+1,:)=ParSwarm(row,1:ParticleSize);

下面的函数LocalPsoProcessByCircle实现了局部版粒子群算法的单步更新位置速度的功能，其中把速度的范围限制在每维范围的0.5倍。这个跟以前的版本有些区别，经过试验效果还可以。

function [ParSwarm,OptSwarm]=LocalStepPsoByCircle(ParSwarm,OptSwarm,AdaptFunc,ParticleScope,MaxW,MinW,LoopCount,CurCount)
% 功能描述：局部版本：采用环形邻域的方法。基本的粒子群算法的单步更新位置,速度的算法
%
%[ParSwarm,OptSwarm]=LocalStepPsoByCircle(ParSwarm,OptSwarm,AdaptFunc,ParticleScope,MaxW,MinW,LoopCount,CurCount)
%
% 输入参数：ParSwarm:粒子群矩阵，包含粒子的位置，速度与当前的目标函数值
%输入参数：OptSwarm：包含粒子群个体最优解与全局最优解的矩阵
%输入参数：ParticleScope:一个粒子在运算中各维的范围；
% 输入参数：AdaptFunc：适应度函数
%输入参数：LoopCount：迭代的总次数
%输入参数：CurCount：当前迭代的次数
%
% 返回值：含意同输入的同名参数
%
%用法：[ParSwarm,OptSwarm]=LocalStepPsoByCircle(ParSwarm,OptSwarm,AdaptFunc,ParticleScope,MaxW,MinW,LoopCount,CurCount)
%
% 异常：首先保证该文件在Matlab的搜索路径中，然后查看相关的提示信息。
%
%编制人：XXX
%编制时间：2010.5.6
%参考文献：XXX
%参考文献：XXX
%
%修改记录
%----------------------------------------------------------------
%2010.5.6
%修改人：XXX
% 添加2*unifrnd(0,1).*SubTract1(row,:)中的unifrnd(0,1)随机数，使性能大为提高
%参照基于MATLAB的粒子群优化算法程序设计
%
% 总体评价：使用这个版本的调节系数，效果比较好
%

%容错控制
if nargin~=8
    error('输入的参数个数错误。')
end
if nargout~=2
    error('输出的个数太少，不能保证循环迭代。')
end

%开始单步更新的操作

%*********************************************
%***** 更改下面的代码，可以更改惯性因子的变化*****
%---------------------------------------------------------------------
% 线形递减策略
w=MaxW-CurCount*((MaxW-MinW)/LoopCount);
%---------------------------------------------------------------------
%w 固定不变策略
%w=0.7;
%---------------------------------------------------------------------
% 参考文献：陈贵敏，贾建援，韩琪，粒子群优化算法的惯性权值递减策略研究，西安交通大学学报，2006，1
%w 非线形递减，以凹函数递减
%w=(MaxW-MinW)*(CurCount/LoopCount)^2+(MinW-MaxW)*(2*CurCount/LoopCount)+MaxW;
%---------------------------------------------------------------------
%w 非线形递减，以凹函数递减
%w=MinW*(MaxW/MinW)^(1/(1+10*CurCount/LoopCount));
%*****更改上面的代码，可以更改惯性因子的变化*****
%*********************************************

% 得到粒子群群体大小以及一个粒子维数的信息
[ParRow,ParCol]=size(ParSwarm);

%得到粒子的维数
ParCol=(ParCol-1)/2;
SubTract1=OptSwarm(1:ParRow,:)-ParSwarm(:,1:ParCol);%粒子自身历史最优解位置减去粒子当前位置
SubTract2=OptSwarm(ParRow+1:end-1,:)-ParSwarm(:,1:ParCol);
%*********************************************
%***** 更改下面的代码，可以更改c1,c2的变化*****
c1=2.05;
c2=2.05;
%---------------------------------------------------------------------
%con=1;
%c1=4-exp(-con*abs(mean(ParSwarm(:,2*ParCol+1))-AdaptFunc(OptSwarm(ParRow+1,:))));
%c2=4-c1;
%----------------------------------------------------------------------
%***** 更改上面的代码，可以更改c1,c2的变化*****
%*********************************************
for row=1:ParRow   
   TempV=w.*ParSwarm(row,ParCol+1:2*ParCol)+c1*unifrnd(0,1).*SubTract1(row,:)+c2*unifrnd(0,1).*SubTract2(row,:);
   %限制速度的代码
   for h=1:ParCol
       if TempV(:,h)>ParticleScope(h,2)/2.0
           TempV(:,h)=ParticleScope(h,2)/2.0;
       end
       if TempV(:,h)<-ParticleScope(h,2)/2.0
           TempV(:,h)=(-ParticleScope(h,2)+1e-10)/2.0;
           %加1e-10防止适应度函数被零除
       end
   end  
   
   % 更新速度
   ParSwarm(row,ParCol+1:2*ParCol)=TempV;
   
   %*********************************************
   %***** 更改下面的代码，可以更改约束因子的变化*****
   %---------------------------------------------------------------------
   %a=1;
   %---------------------------------------------------------------------
   a=0.729;
   %***** 更改上面的代码，可以更改约束因子的变化*****
   %*********************************************
   
   % 限制位置的范围
   TempPos=ParSwarm(row,1:ParCol)+a*TempV;
   for h=1:ParCol
       if TempPos(:,h)>ParticleScope(h,2)
           TempPos(:,h)=ParticleScope(h,2);
       end
       if TempPos(:,h)<=ParticleScope(h,1)
           TempPos(:,h)=ParticleScope(h,1)+1e-10;           
       end
   end

   %更新位置 
   ParSwarm(row,1:ParCol)=TempPos;
   
   % 计算每个粒子的新的适应度值
   ParSwarm(row,2*ParCol+1)=AdaptFunc(ParSwarm(row,1:ParCol));
   if ParSwarm(row,2*ParCol+1)>AdaptFunc(OptSwarm(row,1:ParCol))
       OptSwarm(row,1:ParCol)=ParSwarm(row,1:ParCol);
   end
end
%for循环结束
%确定邻域的范围
linyurange=fix(ParRow/2);
%确定当前迭代的邻域范围
jiange=ceil(LoopCount/linyurange);
linyu=ceil(CurCount/jiange);
    for row=1:ParRow
        if row-linyu>0&&row+linyu<=ParRow
            tempM =[ParSwarm(row-linyu:row-1,:);ParSwarm(row+1:row+linyu,:)];
            
            [maxValue,linyurow]=max(tempM(:,2*ParCol+1));
            if maxValue>AdaptFunc(OptSwarm(ParRow+row,:))
                OptSwarm(ParRow+row,:)=tempM(linyurow,1:ParCol);
            end
        else
            if row-linyu<=0
                %该行上面的部分突出了边界，下面绝对不会突破边界
                if row==1
                    tempM=[ParSwarm(ParRow+row-linyu:end,:);ParSwarm(row+1:row+linyu,:)];
                    [maxValue,linyurow]=max(tempM(:,2*ParCol+1));
                     if maxValue>AdaptFunc(OptSwarm(ParRow+row,:))
                        OptSwarm(ParRow+row,:)=tempM(linyurow,1:ParCol);
                     end
                else
                    tempM=[ParSwarm(1:row-1,:);ParSwarm(ParRow+row-linyu:end,:);ParSwarm(row+1:row+linyu,:)];
                    [maxValue,linyurow]=max(tempM(:,2*ParCol+1));
                     if maxValue>AdaptFunc(OptSwarm(ParRow+row,:))
                        OptSwarm(ParRow+row,:)=tempM(linyurow,1:ParCol);
                     end
                end
            else
                %该行下面的部分突出了边界，上面绝对不会突破边界
                if row==ParRow
                    tempM=[ParSwarm(ParRow-linyu:row-1,:);ParSwarm(1:linyu,:)];
                    [maxValue,linyurow]=max(tempM(:,2*ParCol+1));
                     if maxValue>AdaptFunc(OptSwarm(ParRow+row,:))
                        OptSwarm(ParRow+row,:)=tempM(linyurow,1:ParCol);
                     end
                else
                    tempM=[ParSwarm(row-linyu:row-1,:);ParSwarm(row+1:end,:);ParSwarm(1:linyu-(ParRow-row),:)];  
                    [maxValue,linyurow]=max(tempM(:,2*ParCol+1));
                     if maxValue>AdaptFunc(OptSwarm(ParRow+row,:))
                        OptSwarm(ParRow+row,:)=tempM(linyurow,1:ParCol);
                     end
                end
            end
        end
    end%for
    %寻找适应度函数值最大的解在矩阵中的位置(行数)，进行全局最优的改变 
[maxValue,row]=max(ParSwarm(:,2*ParCol+1));
if AdaptFunc(ParSwarm(row,1:ParCol))>AdaptFunc(OptSwarm(ParRow*2+1,:))
    OptSwarm(ParRow*2+1,:)=ParSwarm(row,1:ParCol);
end

这两个函数给出以后，需要一个函数来把这两个函数组装起来，以此实现一个完整的粒子群算法，这个函数就是LocalPsoProcessByCircle

function [Result,OnLine,OffLine,MinMaxMeanAdapt,BestofStep]=LocalPsoProcessByCircle(SwarmSize,ParticleSize,ParticleScope,InitFunc,StepFindFunc,AdaptFunc,IsStep,IsDraw,LoopCount,IsPlot)
% 功能描述：一个循环n次的局部PSO算法完整过程，返回这次运行的最小与最大的平均适应度,以及在线性能与离线性能
%[Result,OnLine,OffLine,MinMaxMeanAdapt]=PsoProcess(SwarmSize,ParticleSize,ParticleScope,InitFunc,StepFindFunc,AdaptFunc,IsStep,IsDraw,LoopCount,IsPlot)
% 输入参数：SwarmSize:种群大小的个数
%输入参数：ParticleSize：一个粒子的维数
%输入参数：ParticleScope:一个粒子在运算中各维的范围；
%         ParticleScope格式:
%           3维粒子的ParticleScope格式:
%                                   [x1Min,x1Max
%                                    x2Min,x2Max
%                                    x3Min,x3Max]
%
% 输入参数:InitFunc:初始化粒子群函数
%输入参数:StepFindFunc:单步更新速度，位置函数
%输入参数：AdaptFunc：适应度函数
%输入参数：IsStep：是否每次迭代暂停；IsStep＝0，不暂停，否则暂停。缺省不暂停
%输入参数：IsDraw：是否图形化迭代过程；IsDraw＝0，不图形化迭代过程，否则，图形化表示。缺省不图形化表示
%输入参数：LoopCount：迭代的次数；缺省迭代100次
%输入参数：IsPlot：控制是否绘制在线性能与离线性能的图形表示；IsPlot=0,不显示；
%                 IsPlot=1；显示图形结果。缺省IsPlot=1
%
%返回值：BestofStep:每次迭代，全局最优值.
% 返回值：Result为经过迭代后得到的最优解
%返回值：OnLine为在线性能的数据
%返回值：OffLine为离线性能的数据
% 返回值：MinMaxMeanAdapt为本次完整迭代得到的最小与最大的平均适应度
%
%用法[Result,OnLine,OffLine,MinMaxMeanAdapt]=PsoProcess(SwarmSize,ParticleSize,ParticleScope,InitFunc,StepFindFunc,AdaptFunc,IsStep,IsDraw,LoopCount,IsPlot);
%
%异常：首先保证该文件在Matlab的搜索路径中，然后查看相关的提示信息。
%
%编制人：XXX
% 编制时间：2007.3.26
%参考文献：XXXXX%

%修改记录：
%添加MinMaxMeanAdapt，以得到性能评估数据
%修改人：XXX
%修改时间：2007.3.27
%参考文献：XXX.

%容错控制
if nargin<4
    error(' 输入的参数个数错误。')
end

[row,colum]=size(ParticleSize);
if row>1||colum>1
    error('输入的粒子的维数错误，是一个1行1列的数据。');
end
[row,colum]=size(ParticleScope);
if row~=ParticleSize||colum~=2
    error('输入的粒子的维数范围错误。 ');
end

%设置缺省值
if nargin<7
    IsPlot=1;
    LoopCount=100;
    IsStep=0;
    IsDraw=0;
end
if nargin<8
    IsPlot=1;
    IsDraw=0;
    LoopCount=100;
end
if nargin<9
    LoopCount=100;
    IsPlot=1;
end
if nargin<10
    IsPlot=1;
end

%控制是否显示2维以下粒子维数的寻找最优的过程
if IsDraw~=0 
    figure
    clf
    %DrawObjGraphic(ParticleSize,ParticleScope,AdaptFunc);
    DrawObjGraphic();
    view(0,90);
end

%初始化种群       
[ParSwarm,OptSwarm]=InitFunc(SwarmSize,ParticleSize,ParticleScope,AdaptFunc);

% 在<a href="http://lib.csdn.net/base/softwaretest" class='replace_word' title="软件测试知识库" target='_blank' style='color:#df3434; font-weight:bold;'>测试</a>函数图形上绘制初始化群的位置
if IsDraw~=0
    if 1==ParticleSize
        for ParSwarmRow=1:SwarmSize
            plot([ParSwarm(ParSwarmRow,1),ParSwarm(ParSwarmRow,1)],[ParSwarm(ParSwarmRow,3),0],'r*-','markersize',8);
            text(ParSwarm(ParSwarmRow,1),ParSwarm(ParSwarmRow,3),num2str(ParSwarmRow));
        end
    end

    if 2==ParticleSize
        for ParSwarmRow=1:SwarmSize
            hold on
            stem3(ParSwarm(ParSwarmRow,1),ParSwarm(ParSwarmRow,2),ParSwarm(ParSwarmRow,5),'white*','markersize',8);
        end         
    end
end
    
%暂停让抓图
if IsStep~=0
    disp(' 开始迭代，按任意键：')
    pause
end

%开始更新算法的调用
for k=1:LoopCount
    %显示迭代的次数：
    disp('----------------------------------------------------------')
    TempStr=sprintf(' 第 %g 次迭代',k);
    disp(TempStr);
    disp('----------------------------------------------------------')
    
    % 调用一步迭代的算法
    [ParSwarm,OptSwarm]=StepFindFunc(ParSwarm,OptSwarm,AdaptFunc,ParticleScope,0.95,0.4,LoopCount,k);
    
    % 在目标函数的图形上绘制2维以下的粒子的新位置
    if IsDraw~=0
        if 1==ParticleSize
            for ParSwarmRow=1:SwarmSize
                plot([ParSwarm(ParSwarmRow,1),ParSwarm(ParSwarmRow,1)],[ParSwarm(ParSwarmRow,3),0],'r*-','markersize',8);
                text(ParSwarm(ParSwarmRow,1),ParSwarm(ParSwarmRow,3),num2str(ParSwarmRow));
            end
        end

        if 2==ParticleSize
            for ParSwarmRow=1:SwarmSize
                stem3(ParSwarm(ParSwarmRow,1),ParSwarm(ParSwarmRow,2),ParSwarm(ParSwarmRow,5),'white.','markersize',8);
            end
        end
    end
    
    XResult=OptSwarm(SwarmSize*2+1,1:ParticleSize);
    YResult=AdaptFunc(XResult);    
    if IsStep~=0
        XResult=OptSwarm(SwarmSize*2+1,1:ParticleSize);
        YResult=AdaptFunc(XResult);    
        str=sprintf('%g步迭代的最优目标函数值%g',k,YResult);
        disp(str);
        disp(' 下次迭代，按任意键继续');
        pause
    end
    
    %记录每一步的平均适应度
    MeanAdapt(1,k)=mean(ParSwarm(:,2*ParticleSize+1));
    BestofStep(1,k)=YResult;
end
%for循环结束标志

%记录最小与最大的平均适应度
MinMaxMeanAdapt=[min(MeanAdapt),max(MeanAdapt)];
% 计算离线与在线性能
for k=1:LoopCount
    OnLine(1,k)=sum(MeanAdapt(1,1:k))/k;
    OffLine(1,k)=max(MeanAdapt(1,1:k));
end

for k=1:LoopCount
    OffLine(1,k)=sum(OffLine(1,1:k))/k;
end

%绘制离线性能与在线性能曲线
if 1==IsPlot
    figure
    hold on
    title('离线性能曲线图')
    xlabel(' 迭代次数');
    ylabel('离线性能');
    grid on
    plot(OffLine);

    figure
    hold on
    title(' 在线性能曲线图')
    xlabel('迭代次数');
    ylabel('在线性能');
    grid on
    plot(OnLine);
end

%记录本次迭代得到的最优结果
XResult=OptSwarm(SwarmSize*2+1,1:ParticleSize);
YResult=AdaptFunc(XResult);
Result=[XResult,YResult];

这里给出一个使用的例子代码，并分别解释各参数的含义：

%粒子的维数限制范围
Scope=[
        -10 10;
        -10 10;
        -10 10;
        -10 10;
        -10 10;
        -10 10;
        -10 10;
        -10 10;
        -10 10;
        -10 10];
%粒子群种群规模
qun=20;
%粒子的维数
lizi=10;
[Result,OnLine,OffLine,MinMaxMeanAdapt,BestofStep]=LocalPsoProcessByCircle(qun,lizi,Scope,@LocalInitSwarm,@LocalStepPsoByCircle,@Rastrigin,1,0,1000,1);

在上面的代码中函数 LocalPsoProcessByCircle 中的qun代表粒子群的规模为20个，lizi代表每个粒子的维数为10，Scope是粒子的每一维的范围，同时也是速度的范围的二倍，@localinitswarm 是初始化函数的句柄，@localsteppsobycircle是单步更新的函数句柄，@Rastrigin是适应度评价函数的句柄，1000代表真个算法循环1000次终止，其他参数参见说明文档。

补充一点：上面主函数中给出的适应度函数可以参考粒子群算法(6)-----几个适应度评价函数或者自己写。

附注：本文为转载文章，欢迎交流。

原文出处：http://blog.csdn.net/niuyongjie/article/details/5601882

作者：niuyongjie