自己整理的免疫粒子群
主程序
clc,clear all
%x0是实际历史值xi是第i个模型的预测值
x0=[70.85 77.24 95.01 104.21 126.21 162.16 181.87 208.69 249.1 284.58 308.64 347.98 391.14 357.85 391];
x1=[49.88173533 71.63236016 94.03370049 117.1052239 140.8669802 165.3396192 190.5444085 216.5032518 243.2387084 270.7740121 299.1330921 328.3405934 358.4218983 389.4031485 421.3112676 454.173985 488.0198594 522.878304 558.7796121 595.7549829];
x2=[60.01016113 76.10944484 94.49650013 115.0755036 137.6869075 162.1176384 188.1133812 215.3917219 243.6550883 272.602662 301.9406972 331.3909296 360.6969676 389.6287258 417.9850746 445.5949498 472.3172008 498.0394562 522.6762743 546.166811];
x3=[0 71.86833333 73.95333333 91.33023333 106.9033083 132.1767678 173.0582892 204.2885634 236.0459494 279.1341887 321.3735579 351.5482749 389.5071338 433.8132273 411.257009 420.9037015 443.8386884 466.7531147 489.6469804 512.5202855];
x4=[77.45757537 88.89806415 102.0283139 117.0979023 134.3932698 154.2431643 177.0248894 203.1714768 233.1799168 267.6206052 307.1481855 352.513992 404.5803309 464.3368714 532.9194566 488.7048 545.7204 609.3878 680.4831 759.8729];
x5=[64.17580153 78.19792903 94.66891931 113.7469689 135.4890095 159.8134908 186.471067 215.0325768 244.9023823 275.3602161 305.6270871 334.9432586 362.6422181 388.2059391 411.2928907 431.738244 449.5322593 464.7859927 477.6932533 488.4954288];
x6=[70.85 93.62944046 107.1906862 122.205429 138.839847 157.2792305 177.7301809 200.4230632 225.6147406 253.5916237 284.67307 319.2151759 357.6150041 400.3152975 447.8097359 500.6487975 559.4462948 624.8866628 697.7330858 778.8365593];
x7=[0 70.85 74.684 87.4547 99.91232 119.603345 151.4165462 179.7979256 209.9832882 248.90372 289.2803967 323.0779326 361.9433113 405.6266488 405.7536858 421.3946022 444.5598984 467.7251946 490.8904907 514.0557869];
n=length(x0);
f=[x0;x1(1,1:n);x2(1,1:n);x3(1,1:n);x4(1,1:n);x5(1,1:n);x6(1,1:n);x7(1,1:n)];
[a,b]=size(f);
F=0;%M表示有M个粒子 输入值 整数值
w=PSO_Standgaijin(400,7,[0 1;0 1;0 1;0 1;0 1;0 1;0 1],0,0,200,0); % 跑一万次与%%%声明
n=length(w);
F=0;
for t=1:b %k表示有k个预测值
A=0;
for i=1:a-1
A=A+w(i)*f(i+1,t); %x(j,i)输入的向量元素表示第j个粒子的第i个分量 x是矩阵
end
e(t)=(f(1,t)-A)/f(1,t);
F=F+abs(e(t)); %f(1,t）是历史真实值 F(j)是输出 表示第j个粒子的适应度，是一个向量
end
MAPE=F/b;
%预测值
for t=1:b+5
predict(t)= w(1:n-1)*[x1(t),x2(t),x3(t),x4(t),x5(t),x6(t),x7(t)]';
end
%%%声明：这是本人结合网络上提供的一些源码经过修改 并得到验证的PSO代码
%PSO标准算法 其中w c1 c2 a可以改变
%包含初始化函数 迭代函数 还有总体的PSO算法函数
function [Result,OnLine,OffLine,MinMaxMeanAdapt]=PSO_Standgaijin(SwarmSize,ParticleSize,ParticleScope,IsStep,IsDraw,LoopCount,IsPlot)
%function [Result,OnLine,OffLine,MinMaxMeanAdapt]=PSO_Stand(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
%返回值：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，以得到性能评估数据
%修改人：Jeary
%修改时间：2012.12.12
%参考文献：XXX.
%容错控制
if nargin<3
%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<4
%if nargin<7
IsPlot=1;
LoopCount=100;
IsStep=0;
IsDraw=0;
%elseif nargin<8
elseif nargin<5
IsPlot=1;
IsDraw=0;
LoopCount=100;
%elseif nargin<9
elseif nargin<6
LoopCount=100;
IsPlot=1;
%elseif nargin<10
elseif nargin<7
IsPlot=1;
end
%控制是否显示2维以下粒子维数的寻找最优的过程
%if IsDraw~=0
%DrawObjGraphic(ParticleSize,ParticleScope,AdaptFunc);
%end
%初始化种群
%[ParSwarm,OptSwarm]=InitFunc(SwarmSize,ParticleSize,ParticleScope,AdaptFunc);
[ParSwarm,OptSwarm]=InitSwarm1(SwarmSize,ParticleSize,ParticleScope);
%在测试函数图形上绘制初始化群的位置
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),'r.','markersize',8);%绘制3D图形
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);
[ParSwarm,OptSwarm,row,TempV]=BaseStepPsogaijin1(ParSwarm,OptSwarm,ParticleScope,0.95,0.4,LoopCount,k);
good=zeros(size(ParSwarm));
%在目标函数的图形上绘制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),'r.','markersize',8);
end
end
end
XResult=OptSwarm(SwarmSize+1,1:ParticleSize);%存取本次迭代得到的全局最优值
YResult=AdaptFunc(XResult); %计算全局最优值对应的粒子的适应度值
if IsStep~=0
%XResult=OptSwarm(SwarmSize+1,1:ParticleSize);
%YResult=AdaptFunc(XResult);
str=sprintf('%g 步迭代的最优目标函数值 %g',k,YResult);
disp(str);
disp('下次迭代，按任意键继续');
pause
end
% [ParSwarm1,OptSwarm1]=InitSwarm1(SwarmSize,ParticleSize,ParticleScope);
%记录每一步的平均适应度
MeanAdapt(1,k)=mean(ParSwarm(:,2*ParticleSize+1));%mean函数为取有效值函数
delta(1,k)=abs(YResult-MeanAdapt(1,k));
[ParRow,ParCol]=size(ParSwarm);
for i=1:ParRow
if (ParSwarm(i,2*ParticleSize+1)>MeanAdapt(1,k))
good(i,:)=ParSwarm(i,:);
end
end
FAVG(1,k)=mean(good(:,2*ParticleSize+1));
%for循环结束标志
[ParSwarm,OptSwarm]=BaseStepPsogaijin2(FAVG,MeanAdapt,delta,ParSwarm,OptSwarm,ParticleScope,k);
%随机生成新的粒子
[ParSwarm1,OptSwarm1]=InitSwarm1(SwarmSize,ParticleSize,ParticleScope);
%构造概率函数
chromosomeGroup=[ParSwarm;ParSwarm1];
[a,b]=size(chromosomeGroup);
p=chromosomeProbabilitygaijin1(chromosomeGroup);
ParSwarm3=selecteChromosome2(chromosomeGroup,p); % ParSwarm3 修改为 ParSwarm
%随机选取一个粒子进行接种并实验它的适应度函数是否比以前的 好
ParSwarm4=immunitygaijin(ParSwarm3,OptSwarm);
[row,column]=size(ParSwarm4);
for j=1:row
ParSwarm4(j,column)=Adaptfunc(ParSwarm4(j,1:(column-1)/2));
if(ParSwarm4(j,column)<ParSwarm3(j,column))
ParSwarm3(j,1:(column-1)/2)=ParSwarm4(j,1:(column-1)/2);
ParSwarm3(j,1:column)= ParSwarm4(j,1:column);
end
end
ParSwarm=ParSwarm3;
%在目标函数的图形上绘制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),'r.','markersize',8);
end
end
end
% 用概率选择出的粒子数必须保证和OptSwarm的行数少1
ParCol=(ParCol-1)/2;
[minValue,row1]=min(ParSwarm(:,2*ParCol+1));
if AdaptFunc(ParSwarm(row1,1:ParCol))<AdaptFunc(OptSwarm(ParRow+1,:))
OptSwarm(ParRow+1,:)=ParSwarm(row1,1:ParCol);
end
XResult=OptSwarm(SwarmSize+1,1:ParticleSize);%存取本次迭代得到的全局最优值
YResult=AdaptFunc(XResult); %计算全局最优值对应的粒子的适应度值
if IsStep~=0
%XResult=OptSwarm(SwarmSize+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));%mean函数为取有效值函数
end
%记录最小与最大的平均适应度
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
%绘制离线性能与在线性能曲线
%subplot(m,n,p);%将图形窗口分成m行n列的子窗口，序号为p的子窗口为当前窗口
if 1==IsPlot
subplot(1,2,1);
%figure
hold on
title('离线性能曲线图')
xlabel('迭代次数');
ylabel('离线性能');
grid on
plot(OffLine);
subplot(1,2,2);
%figure
hold on
title('在线性能曲线图')
xlabel('迭代次数');
ylabel('在线性能');
grid on
plot(OnLine);
end
%记录本次迭代得到的最优值 适应度值
XResult=OptSwarm(SwarmSize+1,1:ParticleSize);
YResult=AdaptFunc(XResult);
Result=[XResult,YResult];
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%初始化粒子群函数
function [ParSwarm,OptSwarm]=InitSwarm1(SwarmSize,ParticleSize,ParticleScope)
%function [ParSwarm,OptSwarm]=InitSwarm(SwarmSize,ParticleSize,ParticleScope,AdaptFunc)
%功能描述：初始化粒子群，限定粒子群的位置以及速度在指定的范围内
%[ParSwarm,OptSwarm,BadSwarm]=InitSwarm(SwarmSize,ParticleSize,ParticleScope,AdaptFunc)
%
%输入参数：SwarmSize:种群大小的个数 这里取20
%输入参数：ParticleSize：一个粒子的维数 这里取7
%输入参数：ParticleScope:一个粒子在运算中各维的范围；
% ParticleScope格式:
% 3维粒子的ParticleScope格式:
% [x1Min,x1Max
% x2Min,x2Max
% x3Min,x3Max]
%
%输入参数：AdaptFunc：适应度函数
%输出：ParSwarm初始化的粒子群
%输出：OptSwarm粒子群当前最优解与全局最优解
%
%用法[ParSwarm,OptSwarm,BadSwarm]=InitSwarm(SwarmSize,ParticleSize,ParticleScope,AdaptFunc);
%
%异常：首先保证该文件在Matlab的搜索路径中，然后查看相关的提示信息。
%
%编制人：Jeary
%编制时间：2010.12.11
%参考文献：网上资源-粒子群算法详解MATLAB
%
%容错控制 nargin和nargout表示该函数的输入\输出个数
%if nargin~=4
if nargin~=3
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
%初始化粒子群最优解矩阵
OptSwarm=zeros(SwarmSize+1,ParticleSize);
%粒子群最优解矩阵全部设为零
[minValue,row]=min(ParSwarm(:,2*ParticleSize+1));
%寻找适应度函数值最大的解在矩阵中的位置(行数)
OptSwarm=ParSwarm(1:SwarmSize,1:ParticleSize);
OptSwarm(SwarmSize+1,:)=ParSwarm(row,1:ParticleSize);%将适应度值最大的粒子的位置最为全局粒子的最优值
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%基本的粒子群算法的单步更新位置,速度的算法函数
function [ParSwarm,OptSwarm,row,TempV]=BaseStepPsogaijin1(ParSwarm,OptSwarm,ParticleScope,MaxW,MinW,LoopCount,CurCount)
%function [ParSwarm,OptSwarm]=BaseStepPso(ParSwarm,OptSwarm,AdaptFunc,ParticleScope,MaxW,MinW,LoopCount,CurCount)
%功能描述：全局版本：基本的粒子群算法的单步更新位置,速度的算法
%[ParSwarm,OptSwarm]=BaseStepPso(ParSwarm,OptSwarm,AdaptFunc,ParticleScope,MaxW,MinW,LoopCount,CurCount)
%输入参数：ParSwarm:粒子群矩阵，包含粒子的位置，速度与当前的目标函数值
%输入参数：OptSwarm：包含粒子群个体最优解与全局最优解的矩阵
%输入参数：ParticleScope:一个粒子在运算中各维的范围；
%输入参数：AdaptFunc：适应度函数
%输入参数：AdaptFunc：适应度函数
%输入参数：MaxW MinW：惯性权重(系数)的最大值与最小值
%输入参数：CurCount：当前迭代的次数
%返回值：含意同输入的同名参数
%用法：[ParSwarm,OptSwarm]=BaseStepPso(ParSwarm,OptSwarm,AdaptFunc,ParticleScope,MaxW,MinW,LoopCount,CurCount)
%
%异常：首先保证该文件在Matlab的搜索路径中，然后查看相关的提示信息。
%
%编制人：XXX
%编制时间：2007.3.27
%参考文献：XXX
%修改记录
%2010.12.12
%修改人：Jeary
% 添加2*unifrnd(0,1).*SubTract1(row,:)中的unifrnd(0,1)随机数，使性能大为提高
%参照基于MATLAB的粒子群优化算法程序设计
%
% 总体评价：使用这个版本的调节系数，效果比较好
%
%容错控制
%if nargin~=8 %输入容错
if nargin~=7 %输入容错
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);%求解出历史最优值与当前位置的差值
%*********************************************
%*****更改下面的代码，可以更改c1,c2的变化*****
c1=2;
c2=2;
%---------------------------------------------------------------------
%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
SubTract2=OptSwarm(ParRow+1,:)-ParSwarm(row,1:ParCol);%计算出全局最优值与当前该粒子位置的差值
%速度更新公式
TempV=w.*ParSwarm(row,ParCol+1:2*ParCol)+c1*unifrnd(0,1).*SubTract1(row,:)+c2*unifrnd(0,1).*SubTract2;
%限制速度的代码
for h=1:ParCol
if TempV(:,h)<ParticleScope(h,2)
TempV(:,h)=ParticleScope(h,2);
end
if TempV(:,h)>-ParticleScope(h,2)
TempV(:,h)=-ParticleScope(h,2)+1e-10;%加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;%加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
[minValue,row]=min(ParSwarm(:,2*ParCol+1));
if AdaptFunc(ParSwarm(row,1:ParCol))<AdaptFunc(OptSwarm(ParRow+1,:))
OptSwarm(ParRow+1,:)=ParSwarm(row,1:ParCol);
end
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%基本的粒子群算法的单步更新位置,速度的算法函数
function [ParSwarm,OptSwarm]=BaseStepPsogaijin2(FAVG,MeanAdapt,delta,ParSwarm,OptSwarm,ParticleScope,k)
%function [ParSwarm,OptSwarm]=BaseStepPso(ParSwarm,OptSwarm,AdaptFunc,ParticleScope,MaxW,MinW,LoopCount,CurCount)
%功能描述：全局版本：基本的粒子群算法的单步更新位置,速度的算法
%[ParSwarm,OptSwarm]=BaseStepPso(ParSwarm,OptSwarm,AdaptFunc,ParticleScope,MaxW,MinW,LoopCount,CurCount)
%输入参数：ParSwarm:粒子群矩阵，包含粒子的位置，速度与当前的目标函数值
%输入参数：OptSwarm：包含粒子群个体最优解与全局最优解的矩阵
%输入参数：ParticleScope:一个粒子在运算中各维的范围；
%输入参数：AdaptFunc：适应度函数
%输入参数：AdaptFunc：适应度函数
%输入参数：MaxW MinW：惯性权重(系数)的最大值与最小值
%输入参数：CurCount：当前迭代的次数
%返回值：含意同输入的同名参数
%用法：[ParSwarm,OptSwarm]=BaseStepPso(ParSwarm,OptSwarm,AdaptFunc,ParticleScope,MaxW,MinW,LoopCount,CurCount)
%
%异常：首先保证该文件在Matlab的搜索路径中，然后查看相关的提示信息。
%
%编制人：XXX
%编制时间：2007.3.27
%参考文献：XXX
%修改记录
%2010.12.12
%修改人：Jeary
% 添加2*unifrnd(0,1).*SubTract1(row,:)中的unifrnd(0,1)随机数，使性能大为提高
%参照基于MATLAB的粒子群优化算法程序设计
%
% 总体评价：使用这个版本的调节系数，效果比较好
[ParRow,ParCol]=size(ParSwarm);
%得到粒子的维数
b=ParCol;
ParCol=(ParCol-1)/2;
k1=4;
k2=4;
for i=1:ParRow
if(ParSwarm(i,b)>FAVG(1,k))
delta1(i)=abs(ParSwarm(i,b)-FAVG(1,k));
TempV=(1-0.5*delta1(i)/delta(1,k))*ParSwarm(i,ParCol+1:2*ParCol);
for h=1:ParCol
if TempV(:,h)<ParticleScope(h,2)
TempV(:,h)=ParticleScope(h,2);
end
if TempV(:,h)>-ParticleScope(h,2)
TempV(:,h)=-ParticleScope(h,2)+1e-10;%加1e-10防止适应度函数被零除
end
end
%更新该粒子速度值
ParSwarm(i,ParCol+1:2*ParCol)=TempV;
%*****更改下面的代码，可以更改约束因子的变化*****
%---------------------------------------------------------------------
%a=1;%约束因子
%---------------------------------------------------------------------
a=0.729;%约束因子
%*****更改上面的代码，可以更改约束因子的变化*****
%*********************************************
%位置更新公式
TempPos=ParSwarm(i,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;%加1e-10防止适应度函数被零除
end
end
%更新该粒子位置值
ParSwarm(i,1:ParCol)=TempPos;
%计算每个粒子的新的适应度值
ParSwarm(i,2*ParCol+1)=AdaptFunc(ParSwarm(i,1:ParCol));
if ParSwarm(i,2*ParCol+1)<AdaptFunc(OptSwarm(i,1:ParCol))
OptSwarm(i,1:ParCol)=ParSwarm(i,1:ParCol);
end
end
if(ParSwarm(i,b)<MeanAdapt(1,k))
TempV=(1.5-1/(1+k1*exp(-k2*delta(1,k))))*ParSwarm(i,ParCol+1:2*ParCol);
for h=1:ParCol
if TempV(:,h)<ParticleScope(h,2)
TempV(:,h)=ParticleScope(h,2);
end
if TempV(:,h)>-ParticleScope(h,2)
TempV(:,h)=-ParticleScope(h,2)+1e-10;%加1e-10防止适应度函数被零除
end
end
%更新该粒子速度值
ParSwarm(i,ParCol+1:2*ParCol)=TempV;
%*****更改下面的代码，可以更改约束因子的变化*****
%---------------------------------------------------------------------
%a=1;%约束因子
%---------------------------------------------------------------------
a=0.729;%约束因子
%*****更改上面的代码，可以更改约束因子的变化*****
%*********************************************
%位置更新公式
TempPos=ParSwarm(i,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;%加1e-10防止适应度函数被零除
end
end
%更新该粒子位置值
ParSwarm(i,1:ParCol)=TempPos;
%计算每个粒子的新的适应度值
ParSwarm(i,2*ParCol+1)=AdaptFunc(ParSwarm(i,1:ParCol));
if ParSwarm(i,2*ParCol+1)<AdaptFunc(OptSwarm(i,1:ParCol))
OptSwarm(i,1:ParCol)=ParSwarm(i,1:ParCol);
end
end
end
%寻找适应度函数值最大的解在矩阵中的位置(行数)，进行全局最优值的改变
[minValue,row]=min(ParSwarm(:,2*ParCol+1));
if AdaptFunc(ParSwarm(row,1:ParCol))<AdaptFunc(OptSwarm(ParRow+1,:))
OptSwarm(ParRow+1,:)=ParSwarm(row,1:ParCol);
end
end
function ParSwarm3=selecteChromosome2( chromosomeGroup,p )
%UNTITLED5 Summary of this function goes here
% Detailed explanation goes here
n=length(p); %进行比较的相邻元素对的数目
flag=1; %交换标志
while flag
flag=0;
for i=1:n-1
if p(i+1)<p(i)
%swap(A(i),A(i+1));
temp=p(i);
p(i)=p(i+1);
p(i+1)=temp;
flag=1;
end
end
n=n-1;
end
for i=1:n/2;
ParSwarm3(i,:)=chromosomeGroup(i,:);
end
end
%为粒子定义概率函数，好的粒子概率高，坏染色体概率低
function p=chromosomeProbabilitygaijin1(chromosomeGroup)
[a,b]=size(chromosomeGroup);
b=(b-1)/2;
for i=1:a
for j=1:a
D(i,j)=sum(abs(chromosomeGroup(i,1:b)-chromosomeGroup(j,1:b)));
end
end
sd=0;
for i=1:a
d(i)=sum(D(i,:));
sd=sd+d(i);
end
for i=1:a
p(i)=d(i)/sd;
end
end
% 接种疫苗
function ParSwarm4=immunitygaijin(ParSwarm,OptSwarm)
%ParSwarm3 粒子群正常迭代产生的新粒子和随机产生的新的粒子
%OptSwarm 历史粒子群本身的最优解和全局最优解
%OptSwarm 适应度函数
ParSwarm4=zeros(size(ParSwarm));
[chromosomeGroupSum,chromosomelength]=size(ParSwarm);
%chromosomeGroupSum 用来接种的粒子群总个数
%chromosomelength 每个粒子的维数，列向量的个数
[row,column]=size(OptSwarm);
N=(column-1)/2; %N是可以调节的 这里取N是每个粒子位置向量个数的一半
q=chromosomeGroupSum; %q也是可以调节的，它表示每个粒子用来接种向量元素的个数。
delta=0;
for j=1:q
heatDot(j)=fix(rand(1)*chromosomeGroupSum)+1; %随机产生一个用来接种的粒子
bestDot(j)=fix(rand(1)*(N-1))+1; %随机产生用最优解的那个分量和接种粒子相应的分量进行替换
ParSwarm4(heatDot(j),bestDot(j))=OptSwarm(row,bestDot(j));
for i=1:N-1
delta=delta+ParSwarm4(heatDot(j),i);
end
ParSwarm4(heatDot(j),N)=1-delta;
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%适应度函数
function y=AdaptFunc(input_args)
%Griewan函数
%输入x,给出相应的y值,在x=(0,0,…,0)处有全局极小点0.
%编制人：Jeary
%编制日期：2010.12.12
x=input_args;
[row,col]=size(x);
if row>1
error('适应度函数：输入的参数错误');
end
x0=[70.85 77.24 95.01 104.21 126.21 162.16 181.87 208.69 249.1 284.58 308.64 347.98 391.14 357.85 391];
x1=[49.88173533 71.63236016 94.03370049 117.1052239 140.8669802 165.3396192 190.5444085 216.5032518 243.2387084 270.7740121 299.1330921 328.3405934 358.4218983 389.4031485 421.3112676 454.173985 488.0198594 522.878304 558.7796121 595.7549829];
x2=[60.01016113 76.10944484 94.49650013 115.0755036 137.6869075 162.1176384 188.1133812 215.3917219 243.6550883 272.602662 301.9406972 331.3909296 360.6969676 389.6287258 417.9850746 445.5949498 472.3172008 498.0394562 522.6762743 546.166811];
x3=[71.86833333 73.95333333 91.33023333 106.9033083 132.1767678 173.0582892 204.2885634 236.0459494 279.1341887 321.3735579 351.5482749 389.5071338 433.8132273 411.257009 420.9037015 443.8386884 466.7531147 489.6469804 512.5202855];
x4=[77.45757537 88.89806415 102.0283139 117.0979023 134.3932698 154.2431643 177.0248894 203.1714768 233.1799168 267.6206052 307.1481855 352.513992 404.5803309 464.3368714 532.9194566 488.7048 545.7204 609.3878 680.4831 759.8729];
x5=[64.17580153 78.19792903 94.66891931 113.7469689 135.4890095 159.8134908 186.471067 215.0325768 244.9023823 275.3602161 305.6270871 334.9432586 362.6422181 388.2059391 411.2928907 431.738244 449.5322593 464.7859927 477.6932533 488.4954288];
x6=[70.85 93.62944046 107.1906862 122.205429 138.839847 157.2792305 177.7301809 200.4230632 225.6147406 253.5916237 284.67307 319.2151759 357.6150041 400.3152975 447.8097359 500.6487975 559.4462948 624.8866628 697.7330858 778.8365593];
x7=[70.85 74.684 87.4547 99.91232 119.603345 151.4165462 179.7979256 209.9832882 248.90372 289.2803967 323.0779326 361.9433113 405.6266488 405.7536858 421.3946022 444.5598984 467.7251946 490.8904907 514.0557869];
n=length(x0);
f=[x0;x1(1,1:n);x2(1,1:n);x3(1,1:n);x4(1,1:n);x5(1,1:n);x6(1,1:n);x7(1,1:n)];
[a,b]=size(f);
F=0;%M表示有M个粒子 输入值 整数值
for t=1:b %k表示有k个预测值
A=0;
for i=1:a-1
A=A+x(i)*f(i+1,t); %x(j,i)输入的向量元素表示第j个粒子的第i个分量 x是矩阵
end
F=F+(f(1,t)-A)^2; %f(1,t）是历史真实值 F(j)是输出 表示第j个粒子的适应度，是一个向量
end
y=F;
end
