粒子群优化算法MATLAB代码

合集下载

粒子群_Matlab程序代码

粒子群优化算法(panicle swarm optimization ，PSO)是kennedy 和Eberhart 在研究鸟类和鱼类的群体行为基础上于1995年提出的一种群智能算法，其思想米源予人工生命和演化计算理论，模仿鸟群飞行觅食行为，通过鸟集体协作使群体达到最优。

1.粒子群算法的原理PSO 中，每个优化问题的解看作搜索空间中的一只鸟(即粒子)，所有的粒子都有一个被优化的函数决定的适应值，并且有一个速度决定它们飞翔的方向和速率，粒子们追随当前的最优粒子在解空间中搜索。

算法首先初始化一群随机粒子，然后通过迭代找到最优解。

在每一次迭代中，粒子通过跟踪两个“极值”即个体极值和全局极值来更新自己的速度与位置。

在D 维目标搜索空间中，由种群数为m 的粒子组成粒子群，其中第f 个粒子在第d 维的位置为Xid ，其飞行速度为Vid ，该粒子当前搜索到的最优位置为Pid(goodvalue)和整个粒子群当前的最优位置Pgd(bestvalue)。

每维的速度与位置更新公式如下112(1)()(1)()(1)id id id id id id v v c rand p x c rand g x ω+=⨯+⨯⨯-+⨯⨯-L 11(2)id id id x x v ++=+LW 为惯性权重，C1和C2为学习因子，rand （）——[0,1]范围内变化的随机数。

2.参数介绍与设置（1）ww 是保持粒子运动惯性的参数，能使种群扩展搜索空间，获得较好的求解效果。

较大的w 有利于群体在更大的范围内进行搜索。

而较小的w 能够保证群体收敛到最优位置，所以w 的选择及在迭代中的变化对搜索能力和跳出局优能力具有重要影响。

一般将w 设定为0.8左右。

（1）加速因子c1和c2c1和c2用于调整粒子自身经验和社会经验在其运动中的作用，表示将每个粒子拉向pbest 和gbest 位置的随机加速项的权重，低的值允许粒子在被拉回前可以在目标区域外徘徊, 而高的值则导致粒子突然冲向或越过目标区域。

粒子群算法matlab程序

粒子群算法matlab程序粒子群算法（PSO）是一种基于群体智能的求解优化问题的算法。

其通过模拟鸟群等大规模群体行为，实现全局搜索和基于群体协作的局部搜索。

在PSO中，通过一组粒子（每个粒子代表一个解）来搜索问题的解空间，在搜索过程中，粒子的位置表示该解在解空间中的位置，速度表示该解在该方向（即属性）上的变化速率，最终达到全局最优解或局部最优解。

PSO算法有着简单易懂、实现简便、计算速度快以及易于与其他算法结合等优点。

下面我将介绍一下如何使用matlab编写简单的粒子群算法程序。

程序主要分为以下步骤：1.初始化在程序开始之前需要对粒子进行初始化操作，其中需要确定粒子群的大小、每个粒子的位置、速度等初始参数。

2.计算适应值计算每个粒子的适应值，即根据当前位置计算该解的适应值。

适应值可以根据实际问题进行定义，如最小化目标函数或最大化收益等。

3.更新粒子速度和位置这一步是PSO算法的核心步骤，通过改变粒子的速度和位置来找到更优的解。

其核心公式为：v(t+1) = w * v(t) + c1 * rand() * (pbest - x(t)) + c2 * rand() * (gbest - x(t)) x(t+1) = x(t) + v(t+1)其中w是惯性权重，c1、c2是学习因子，pbest是该粒子的历史最优解，gbest 是当前全局最优解。

4.更新pbest和gbest在每次更新位置之后需要更新每个粒子自己的历史最优解以及全局最优解。

5.停止条件判断设定停止条件，如最小适应值误差、迭代次数、最大迭代次数等，如果达到了停止条件，则程序结束，输出全局最优解。

下面是一份简单的PSO算法的matlab代码：function [best_fit, best_x] = pso(func, dim, lb, ub, max_iter, swarm_size, w, c1, c2)%初始化粒子v = zeros(swarm_size, dim);x = repmat(lb, swarm_size, 1) + repmat(ub - lb, swarm_size, 1) .* rand(swarm_size, dim);pbest = x;[best_fit, best_idx] = min(func(x));gbest = x(best_idx,:);%开始迭代for iter = 1 : max_iter%更新速度和位置v = w * v + c1 * rand(swarm_size, dim) .* (pbest - x) + c2 * rand(swarm_size, dim) .* repmat(gbest, swarm_size, 1) - x;x = x + v;%边界处理x = max(x, repmat(lb, swarm_size, 1));x = min(x, repmat(ub, swarm_size, 1));%更新pbest和gbestidx = func(x) < func(pbest);pbest(idx,:) = x(idx,:);[min_fit, min_idx] = min(func(pbest));if min_fit < best_fitbest_fit = min_fit;best_x = pbest(min_idx,:);endendend在使用上述代码时，需要定义适应值函数（func）、解空间维度（dim）、每个维度的上界（ub）与下界（lb）、最大迭代次数（max_iter）、粒子群大小（swarm_size）、惯性权重（w）、学习因子（c1、c2）等参数。

pso算法matlab代码

pso算法matlab代码pso算法是一种优化算法，全称为粒子群优化算法（Particle Swarm Optimization）。

它模拟了鸟群或者鱼群的行为，通过不断地迭代寻找最优解。

在许多优化问题中，pso算法都有着良好的表现，特别是在连续空间的优化问题中。

在matlab中实现pso算法并不复杂，以下是一个简单的例子：```matlabfunction [best_pos, best_val] = pso_algorithm(fitness_func,num_particles, num_iterations, range)% 初始化粒子的位置和速度positions = rand(num_particles, length(range)) .* (range(2) - range(1)) + range(1);velocities = rand(num_particles, length(range)) .* (range(2) - range(1)) + range(1);% 初始化每个粒子的最佳位置和适应度值personal_best_pos = positions;personal_best_val = arrayfun(fitness_func, personal_best_pos);% 初始化全局最佳位置和适应度值[global_best_val, global_best_idx] = min(personal_best_val);global_best_pos = personal_best_pos(global_best_idx, :);% 开始迭代for iter = 1:num_iterations% 更新粒子的速度和位置inertia_weight = 0.9 - iter * (0.5 / num_iterations); % 慢慢减小惯性权重cognitive_weight = 2;social_weight = 2;r1 = rand(num_particles, length(range));r2 = rand(num_particles, length(range));velocities = inertia_weight .* velocities + ...cognitive_weight .* r1 .* (personal_best_pos - positions) + ...social_weight .* r2 .* (global_best_pos - positions);positions = positions + velocities;% 更新每个粒子的最佳位置和适应度值new_vals = arrayfun(fitness_func, positions);update_idx = new_vals < personal_best_val;personal_best_pos(update_idx, :) = positions(update_idx, :);personal_best_val(update_idx) = new_vals(update_idx);% 更新全局最佳位置和适应度值[min_val, min_idx] = min(personal_best_val);if min_val < global_best_valglobal_best_val = min_val;global_best_pos = personal_best_pos(min_idx, :);endendbest_pos = global_best_pos;best_val = global_best_val;end```上面的代码实现了一个简单的pso算法，其中`fitness_func`是待优化的目标函数，`num_particles`是粒子数量，`num_iterations`是迭代次数，`range`是变量的范围。

改进粒子群算法matlab代码

改进粒子群算法matlab代码粒子群算法是一种基于群体智能的优化算法，其主要思想是将优化问题转化为粒子在搜索空间中寻找最优解的过程。

粒子群算法的运作方式是通过定义一群随机粒子，并根据它们在搜索空间中的位置和速度，来引导粒子向着更好的解决方案进行搜索。

以下是改进版粒子群算法的MATLAB代码：%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 粒子群算法-改进版%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 初始化参数和粒子群function [gbest_x, gbest_y] = PSO(num_particles,max_iterations, f, lower_bound, upper_bound)% 定义粒子群基本参数w = 0.7; % 惯性权重c1 = 1.4; % 学习因子1c2 = 1.4; % 学习因子2% 初始化粒子位置和速度particles_position = unifrnd(lower_bound, upper_bound, [num_particles, 2]);particles_velocity = zeros(num_particles, 2);% 初始化个体最优解和全局最优解pbest_position = particles_position;pbest_value = zeros(num_particles, 1);for i = 1:num_particlespbest_value(i) = f(particles_position(i,:));end[global_min_value, global_min_index] = min(pbest_value); gbest_position = particles_position(global_min_index, :);gbest_value = global_min_value;% 迭代优化for iter = 1:max_iterationsfor i = 1:num_particles% 更新粒子速度particles_velocity(i,:) = w *particles_velocity(i,:) ...+ c1 * rand() * (pbest_position(i,:) -particles_position(i,:)) ...+ c2 * rand() * (gbest_position -particles_position(i,:));% 限制粒子速度范围particles_velocity(i,1) = max(particles_velocity(i,1), lower_bound);particles_velocity(i,1) = min(particles_velocity(i,1), upper_bound);particles_velocity(i,2) = max(particles_velocity(i,2), lower_bound);particles_velocity(i,2) = min(particles_velocity(i,2), upper_bound);% 更新粒子位置particles_position(i,:) = particles_position(i,:) + particles_velocity(i,:);% 限制粒子位置范围particles_position(i,1) = max(particles_position(i,1), lower_bound);particles_position(i,1) = min(particles_position(i,1),upper_bound);particles_position(i,2) = max(particles_position(i,2), lower_bound);particles_position(i,2) = min(particles_position(i,2), upper_bound);% 更新个体最优解temp_value = f(particles_position(i,:));if temp_value < pbest_value(i)pbest_value(i) = temp_value;pbest_position(i,:) = particles_position(i,:);endend% 更新全局最优解[temp_min_value, temp_min_index] = min(pbest_value);if temp_min_value < gbest_valuegbest_value = temp_min_value;gbest_position = pbest_position(temp_min_index,:);endend% 返回全局最优解gbest_x = gbest_position(1);gbest_y = gbest_position(2);end其中，num_particles为粒子数目，max_iterations为最大迭代次数，f为目标函数句柄，lower_bound和upper_bound为搜索空间的下界和上界。

粒子群算法的matlab代码实现

粒子群算法的matlab代码实现function swarmwarning off MATLAB:divideByZero%%% Script Particle Swarm Optimization%%% Author: Ivan Candelas del Toro%%% e-mail: ivanct@%%%%%% Control variables%%%%%global numberOfParticles;numberOfParticles = 40;global numberOfNeighbors;numberOfNeighbors = 4;maxIterations = 1000;%% Limites para cambio de localizaciónglobal deltaMin;deltaMin = -4.0;global deltaMax;deltaMax = 4.0;%% individuality and socialityiWeight = 2.0;iMin = 0.0;iMax = 1.0;sWeight = 2.0;sMin = 0.0;sMax = 1.0;%%%%%%%%%%%%% Related variables to the problem space solutions %%%%%%%%%%%initialFitness = -100000;targetFitness = 0;global dimensions;dimensions = 4;%%%% Program Startglobal particles;for p = 1:numberOfParticlesfor d = 1:dimensionsparticles(p).next(d) = randint(1,10); %%%%%%%%%%%%%%%%%particles(p).velocity(d) =randint(deltaMin,deltaMax); %%%%%%%%%%%particles(p).current(d) = particles(p).next(d);endparticles(p).bestSoFar = initialFitness;endfor p = 1:numberOfParticlesneighborVector = getNeighborIndexVector(p,numberOfNeighbors);for n = 1:numberOfNeighborsparticles(p).neighbor(n) = neighborVector(n);endenditerations = 0;ticwhile iterations <= maxIterationsfor p = 1:numberOfParticlesfor d = 1:dimensionsparticles(p).current(d) = particles(p).next(d);endfitness = test(p);if fitness > particles(p).bestSoFar;particles(p).bestSoFar = fitness;for d = 1:dimensionsparticles(p).best(d) = particles(p).current(d);endendif fitness == targetFitnessX=particles(p).current(1)Y=particles(p).current(2)Z=particles(p).current(3)W=particles(p).current(4)total_time=tocdisp('Success!!');returnendendfor p = 1:numberOfParticlesn = getNeighborIndexWithBestFitness(p);for d = 1:dimensionsiFactor = iWeight * randint(iMin,iMax); %%%%%%%%%%%%%%sFactor = sWeight * randint(sMin,sMax); %%%%%%%%%%%%%pDelta(d) = particles(p).best(d) - particles(p).current(d); nDelta(d) = particles(n).best(d) - particles(p).current(d);delta = (iFactor * pDelta(d)) + (sFactor * nDelta(d));delta = particles(p).velocity(d) + delta;particles(p).velocity(d) = constrict(delta);particles(p).next(d) = particles(p).current(d) +particles(p).velocity(d);endenditerations = iterations + 1enddisp('Failure');%%%%%%%%%%%%% Support Functions%%%%%%%%%%%%-------------function fitness = test(p)global particles;x = particles(p).current(1);y = particles(p).current(2);z = particles(p).current(3);w = particles(p).current(4);f = 5 * (x^2) + 2 * (y^3) - (z/w)^2 + 4;if ( x * y ) == 0n = 1;elsen = 0;endfitness = 0 - abs(f) - n;%%-------------function d = constrict(delta)global deltaMin;global deltaMax;if delta < deltaMind = deltaMin;returnendif delta > deltaMaxd = deltaMax;returnendd = delta;%%--------function p = getNeighborIndex(pindex,n)global numberOfParticles;global dimensions;global particles;dista=zeros(1,numberOfParticles);for i = 1:numberOfParticlessuma = 0;for d = 1:dimensionssuma = suma + (particles(pindex).current(d) - particles(i).current(d))^2;enddista(i)=sqrt(suma);end[X,I] = sort(dista);p = I(n);%%--------function p = getNeighborIndexVector(pindex,n) global numberOfParticles;global dimensions;global particles;dista=zeros(1,numberOfParticles);for i = 1:numberOfParticlessuma = 0;for d = 1:dimensionssuma = suma + (particles(pindex).current(d) - particles(i).current(d))^2;enddista(i)=sqrt(suma);end[X,I] = sort(dista);p = I(1:n);%%---------function p = getNeighborIndexWithBestFitness(pindex) global dimensions;global particles;global numberOfNeighbors;fit = zeros(1,4);for d = 1:numberOfNeighbors;fit(d) = test(particles(pindex).neighbor(d));end[X,I] = sort(fit);p = particles(pindex).neighbor(I(1));%%-------------%%return a random integer between min and max%function num = randint(min,max)array = min:max;index = mod(floor(rand(1)*1000),size(array,2))+1; num = array(index);。

粒子群算法解决VRP代码（matlab）

粒子群算法解决VRP代码（matlab）particle_swarm_optimization.m文件：function PSOforTSP%初始化Alpha=0.25; %个体经验保留概率Beta=0.25; %全局经验保留概率NC_max=100; %最大迭代次数m=80; %微粒数CityNum=14; %问题的规模（城市个数）[dislist,Clist]=tsp(CityNum);NC=1;%迭代计数器R_best=zeros(NC_max,CityNum); %各代最佳路线L_best=inf.*ones(NC_max,1);%各代最佳路线的长度L_ave=zeros(NC_max,1);%各代路线的平均长度%产生微粒的初始位置for i=1:mx(i,:)=randperm(CityNum);L(i)=CalDist(dislist,x(i,:));endp=x; %p为个体最好解pL=L;[L_best(1,1) n_best]=min(L);R_best(1,:)=x(n_best,:);L_ave(1,1)=mean(L);%初始交换序v=ones(CityNum-1,2,m)*(round(rand*(CityNum-1))+1);figure(1);while NC<=NC_max %停止条件之一：达到最大迭代次数for i=1:mxnew(i,:)=changeFun(x(i,:),v(:,:,i));A=changeNum(x(i,:),p(i,:));Arand=randFun(A,Alpha);xnew(i,:)=changeFun(xnew(i,:),Arand);B=changeNum(x(i,:),R_best(NC,:));Brand=randFun(B,Beta);xnew(i,:)=changeFun(xnew(i,:),Brand);v(:,:,i)=changeNum(x(i,:),xnew(i,:));L(i)=CalDist(dislist,xnew(i,:));if L(i)<pl(i)< p="">p(i,:)=xnew(i,:);pL(i)=L(i);endend[L_bestnew n_best]=min(L);R_bestnew=xnew(n_best,:);L_ave(NC+1,1)=mean(L);if L_bestnew<l_best(nc,1)< p="">L_best(NC+1,1)=L_bestnew;R_best(NC+1,:)=R_bestnew;elseL_best(NC+1,1)=L_best(NC,1);R_best(NC+1,:)=R_best(NC,:);endx=xnew;drawTSP10(Clist,R_best(NC,:),L_best(NC,1),NC,0); %pause;NC=NC+1;end%输出结果Pos=find(L_best==min(L_best));Shortest_Route=R_best(Pos(1),:);Shortest_Length=L_best(Pos(1)); figure(2);plot([L_best L_ave]);legend('最短距离','平均距离'); endfunction xnew=changeFun(x,C); changeLen=size(C,1);xnew=x;for i=1:changeLena=xnew(C(i,1));xnew(C(i,1))=xnew(C(i,2));xnew(C(i,2))=a;endendfunction C=changeNum(x,y); CityNum=size(x,2);C=ones(CityNum-1,2);for i=1:CityNum-1pos=find(x==y(i));C(i,:)=[i pos];x=changeFun(x,C(i,:));endendfunction v=randFun(v,w);randLen=size(v,1);for i=1:randLenif rand>wv(i,2)=v(i,1);endendendfunction F=CalDist(dislist,s)%计算回路路径距离DistanV=0;n=size(s,2);for i=1:(n-1)DistanV=DistanV+dislist(s(i),s(i+1));endDistanV=DistanV+dislist(s(n),s(1));F=DistanV;endfunction [DLn,cityn]=tsp(n)city14=[0 0;0.3 0.334;0.08 0.433;0.166 0.456;0.5 0.4439;0.2439 0.1463;0.1207 0.2293;0.2293 0.761;0.6171 0.9414;0.8732 0.6536;0.6878 0.5219;0.8488 0.3609;0.6683 0.2536;0.6195 0.2634];for i=1:14for j=1:14DL14(i,j)=((city14(i,1)-city14(j,1))^2+(city14(i,2)-city14(j,2))^2)^0.5;endendDLn=DL14;cityn=city14;enddrawTSP10.m文件：function m=drawTSP(Clist,BSF,bsf,p,f)CityNum=size(Clist,1);for i=1:CityNum-1plot([Clist(BSF(i),1),Clist(BSF(i+1),1)],[Clist(BSF(i),2),Clist(BSF(i +1),2)],'ms-','LineWidth',2,'MarkerEdgeColor','k','MarkerFaceColor','g');hold on;endaxis([0,1,0,1]);plot([Clist(BSF(CityNum),1),Clist(BSF(1),1)],[Clist(BSF(CityNu m),2),Clist(BSF(1), 2)],'ms-','LineWidth',2,'MarkerEdgeColor','k','MarkerFaceColor','g');title([num2str(CityNum),'城市TSP']);if f==0text(0.1,0.1,['第',int2str(p),' 步',' 最短距离为',num2str(bsf)]);elsetext(0.1,0.1,['最终搜索结果：最短距离',num2str(bsf)]);endhold off;pause(0.05);</l_best(nc,1)<></pl(i)<>。

粒子群算法 matlab源代码

%相关参数的设置UB=600; %函数的上界LB=300; %函数的下界PopSize=40; %种群的大小Dim=10; %微粒的维数c1=2; %学习因子c2=2; %学习因子w_start=0.9;%惯性权重的开始值w_end=0.4;%惯性权重的最后值Vmax=100;%微粒的最大速度MaxIter=1500;%最大迭代次数Iter=0;%初始迭代次数%初始化群和速度X=rand(PopSize,Dim)*(UB-LB)+LB;%微粒位置随机初始化V=rand(PopSize,Dim);%微粒速度随机初始化；%测试函数：Griewank函数ind=repmat(1:Dim,PopSize,1);FX=sum(((X.^2)/4000)')'- prod(cos(X./sqrt(ind))')'+1;%设定当前位置为粒子的最好位置，并记录其最好值PBest=X;FPBest=FX;%找到初始微粒群体的最好微粒[Fgbest,r]=min(FX);CF=Fgbest;%记录当前全局最优值Best=X(r,:);%用于保存最优粒子的位置FBest=Fgbest;%循环while(Iter<=MaxIter)Iter=Iter+1;%更新惯性权重的值；w_now=((w_start-w_end)*(MaxIter-Iter)/MaxIter)+w_end;A=repmat(X(r,:),PopSize,1);%生成随机数R1=rand(PopSize,Dim);R2=rand(PopSize,Dim);%速度更新V=w_now*V+c1*R1.*(PBest-X)+c2*R2.*(A-X);%对进化后速度大于最大速度的微粒进行处理changeRows=V>Vmax;VStep(find(changeRows))=Vmax;%对进化后速度小雨最小速度的微粒进行处理changeRows=V<-Vmax;V(find(changeRows))=-Vmax;%微粒位置进行更新X=X+1.0*V;%重新计算新位置的适应度值ind=repmat(1:Dim,PopSize,1);FX=sum(((X.^2)/4000)')'- prod(cos(X./sqrt(ind))')'+1;%更新每个微粒的最好位置P=FX<FPBest;FPBest(find(P))=FX(find(P));%适应值更换PBest(find(P),:)=X(find(P),:)%粒子位置更换[Fgbest,g]=min(FPBest);%保存最好适应值if Fgbest<CF %如果本次适应值好于上次则保存[fBest,b]=min(FPBest);%最好适应值为fBestBest=PBest(b,:);%最好位置为BestendCF=Fgbest;%保留本次适应值准备与下次比较end %循环结束。

粒子群算法matlab(算法已经调试)

程序1当22111==c c ，5.12212==c c ，2.1=w 。

a)%主函数源程序（main.m ）%------基本粒子群算法（particle swarm optimization ）%------名称：基本粒子群算法%------初始格式化clear all ; %清除所有变量clc; %清屏format long ; %将数据显示为长整形科学计数%------给定初始条条件------------------N=40; %³初始化群体个数D=10; %初始化群体维数T=100; %初始化群体最迭代次数c11=2; %学习因子1c21=2; %学习因子2c12=1.5;c22=1.5;w=1.2; %惯性权重eps=10^(-6); %设置精度（在已知最小值的时候用） %------初始化种群个体（限定位置和速度）------------x=zeros(N,D);v=zeros(N,D);for i=1:Nfor j=1:Dx(i,j)=randn; %随机初始化位置v(i,j)=randn; %随机初始化速度endend%------显示群位置----------------------figure(1)for j=1:Dif (rem(D,2)>0)subplot((D+1)/2,2,j)elsesubplot(D/2,2,j)endplot(x(:,j),'b*');grid onxlabel('粒子')ylabel('初始位置')tInfo=strcat('第',char(j+48),'维');if(j>9)tInfo=strcat('第',char(floor(j/10)+48)，char(rem(j,10)+48),'维');endtitle(tInfo)end%------显示种群速度figure(2)for j=1:Dif(rem(D,2)>0)subplot((D+1)/2,2,j)elsesubplot(D/2,2,j)endplot(x(:,j),'b*');grid onxlabel('粒子')ylabel('初始速度')tInfo=strcat('第,char(j+48),'维');if(j>9)tInfo=strcat('第',char(floor(j/10)+48), char(rem(j,10)+48),'维);endtitle(tInfo)endfigure(3)%第一个图subplot(1,2,1)%------初始化种群个体（在此限定速度和位置）------------x1=x;v1=v;%------初始化个体最优位置和最优值---p1=x1;pbest1=ones(N,1);for i=1:Npbest1(i)=fitness(x1(i,:),D);end%------初始化全局最优位置和最优值---------------g1=1000*ones(1,D);gbest1=1000;for i=1:Nif(pbest1(i)<gbest1)g1=p1(i,:);gbest1=pbest1(i);endendgb1=ones(1,T);%-----浸入主循环，按照公式依次迭代直到满足精度或者迭代次数---for i=1:Tfor j=1:Nif (fitness(x1(j,:),D)<pbest1(j))p1(j,:)=x1(j,:);pbest1(j)=fitness(x1(j,:),D);endif(pbest1(j)<gbest1)g1=p1(j,:);gbest1=pbest1(j);endv1(j,:)=w*v1(j,:)+c11*rand*(p1(j,:)-x1(j,:))+c21*rand*(g1-x1(j,:));x1(j,:)=x1(j,:)+v1(j,:);endgb1(i)=gbest1;endplot(gb1)TempStr=sprintf('c1= %g ,c2=%g',c11,c21);title(TempStr);xlabel('迭代次数');ylabel('适应度值');%第二个图subplot(1,2,2)%-----初始化种群个体（在此限定速度和位置）------------x2=x;v2=v;%-----初始化种群个体最有位置和最优解-----------p2=x2;pbest2=ones(N,1);for i=1:Npbest2(i)=fitness(x2(i,:),D);end%-----初始化种全局最有位置和最优解------g2=1000*ones(1,D);gbest2=1000;for i=1:Nif(pbest2(i)<gbest2)g2=p2(i,:);gbest2=pbest2(i);endendgb2=ones(1,T);%------浸入主循环，按照公式依次迭代直到满足精度或者迭代次数---for i=1:Tfor j=1:Nif (fitness(x2(j,:),D)<pbest2(j))p2(j,:)=x2(j,:);pbest2(j)=fitness(x2(j,:),D);endif(pbest2(j)<gbest2)g2=p2(j,:);gbest2=pbest2(j);endv2(j,:)=w*v2(j,:)+c12*rand*(p2(j,:)-x2(j,:))+c22*rand*(g2-x2(j,:)); x2(j,:)=x2(j,:)+v2(j,:);endgb2(i)=gbest2;endplot(gb2)TempStr=sprintf('c1= %g ,c2=%g',c12,c22);title(TempStr);xlabel('迭代次数');ylabel('适应度值');b ）适应度函数%适应度函数（fitness.m ）function result=fitness(x,D)sum=0;for i=1:Dsum=sum+x(i)^2;endresult=sum;程序2当22111==c c 于2.1,2,02212===w c c 对比a)%主函数源程序（main.m ）%------基本粒子群算法（particle swarm optimization ）%------名称：基本粒子群算法%------初始格式化clear all ; %清除所有变量clc; %清屏format long ; %将数据显示为长整形科学计数%------给定初始条条件------------------N=40; %³初始化群体个数D=10; %初始化群体维数T=100; %初始化群体最迭代次数c11=2; %学习因子1c21=2; %学习因子2c12=0;c22=2;w=1.2; %惯性权重eps=10^(-6); %设置精度（在已知最小值的时候用）%------初始化种群个体（限定位置和速度）------------x=zeros(N,D);v=zeros(N,D);for i=1:Nfor j=1:Dx(i,j)=randn; %随机初始化位置v(i,j)=randn; %随机初始化速度endend%------显示群位置----------------------figure(1)for j=1:Dif(rem(D,2)>0)subplot((D+1)/2,2,j)elsesubplot(D/2,2,j)endplot(x(:,j),'b*');grid onxlabel('粒子')ylabel('初始位置')tInfo=strcat('第',char(j+48),'维');if(j>9)tInfo=strcat('第',char(floor(j/10)+48)，char(rem(j,10)+48),'维');endtitle(tInfo)end%------显示种群速度figure(2)for j=1:Dif(rem(D,2)>0)subplot((D+1)/2,2,j)elsesubplot(D/2,2,j)endplot(x(:,j),'b*');grid onxlabel('粒子')ylabel('初始速度')tInfo=strcat('第,char(j+48),'维');if(j>9)tInfo=strcat('第',char(floor(j/10)+48),char(rem(j,10)+48),'维);endtitle(tInfo)endfigure(3)%第一个图subplot(1,2,1)%------初始化种群个体（在此限定速度和位置）------------x1=x;v1=v;%------初始化个体最优位置和最优值---p1=x1;pbest1=ones(N,1);for i=1:Npbest1(i)=fitness(x1(i,:),D);end%------初始化全局最优位置和最优值---------------g1=1000*ones(1,D);gbest1=1000;for i=1:Nif(pbest1(i)<gbest1)g1=p1(i,:);gbest1=pbest1(i);endendgb1=ones(1,T);%-----浸入主循环，按照公式依次迭代直到满足精度或者迭代次数---for i=1:Tfor j=1:Nif (fitness(x1(j,:),D)<pbest1(j))p1(j,:)=x1(j,:);pbest1(j)=fitness(x1(j,:),D);endif(pbest1(j)<gbest1)g1=p1(j,:);gbest1=pbest1(j);endv1(j,:)=w*v1(j,:)+c11*rand*(p1(j,:)-x1(j,:))+c21*rand*(g1-x1(j,:));x1(j,:)=x1(j,:)+v1(j,:);endgb1(i)=gbest1;endplot(gb1)TempStr=sprintf('c1= %g ,c2=%g',c11,c21);title(TempStr);xlabel('迭代次数');ylabel('适应度值');%第二个图subplot(1,2,2)%-----初始化种群个体（在此限定速度和位置）------------x2=x;v2=v;%-----初始化种群个体最有位置和最优解-----------p2=x2;pbest2=ones(N,1);for i=1:Npbest2(i)=fitness(x2(i,:),D);end%-----初始化种全局最有位置和最优解------g2=1000*ones(1,D);gbest2=1000;for i=1:Nif(pbest2(i)<gbest2)g2=p2(i,:);gbest2=pbest2(i);endendgb2=ones(1,T);%------浸入主循环，按照公式依次迭代直到满足精度或者迭代次数---for i=1:Tfor j=1:Nif (fitness(x2(j,:),D)<pbest2(j))p2(j,:)=x2(j,:);pbest2(j)=fitness(x2(j,:),D);endif(pbest2(j)<gbest2)g2=p2(j,:);gbest2=pbest2(j);endv2(j,:)=w*v2(j,:)+c12*rand*(p2(j,:)-x2(j,:))+c22*rand*(g2-x2(j,:));x2(j,:)=x2(j,:)+v2(j,:);endgb2(i)=gbest2;endplot(gb2)TempStr=sprintf('c1= %g ,c2=%g',c12,c22);title(TempStr);xlabel('迭代次数');ylabel('适应度值');b）适应度函数%适应度函数（fitness.m）function result=fitness(x,D)sum=0;for i=1:Dsum=sum+x(i)^2;endresult=sum;程序3当2.1,22111===w c c 于2.1,0,22212===w c c 对比a)%主函数源程序（main.m ）%------基本粒子群算法（particle swarm optimization ） %------名称：基本粒子群算法%------初始格式化clear all ; %清除所有变量clc; %清屏format long ; %将数据显示为长整形科学计数 %------给定初始条条件------------------N=40; %³初始化群体个数D=10; %初始化群体维数T=100; %初始化群体最迭代次数c11=2; %学习因子1c21=2; %学习因子2c12=2;c22=0;w=1.2; %惯性权重eps=10^(-6); %设置精度（在已知最小值的时候用） %------初始化种群个体（限定位置和速度）------------x=zeros(N,D);v=zeros(N,D);for i=1:Nfor j=1:Dx(i,j)=randn; %随机初始化位置v(i,j)=randn; %随机初始化速度endend%------显示群位置----------------------figure(1)for j=1:Dif (rem(D,2)>0)subplot((D+1)/2,2,j)elsesubplot(D/2,2,j)endplot(x(:,j),'b*');grid onxlabel('粒子')ylabel('初始位置')tInfo=strcat('第',char(j+48),'维');if(j>9)tInfo=strcat('第',char(floor(j/10)+48)，char(rem(j,10)+48),'维');endtitle(tInfo)end%------显示种群速度figure(2)for j=1:Dif(rem(D,2)>0)subplot((D+1)/2,2,j)elsesubplot(D/2,2,j)endplot(x(:,j),'b*');grid onxlabel('粒子')ylabel('初始速度')tInfo=strcat('第,char(j+48),'维');if(j>9)tInfo=strcat('第',char(floor(j/10)+48), char(rem(j,10)+48),'维);endtitle(tInfo)endfigure(3)%第一个图subplot(1,2,1)%------初始化种群个体（在此限定速度和位置）------------x1=x;v1=v;%------初始化个体最优位置和最优值---p1=x1;pbest1=ones(N,1);for i=1:Npbest1(i)=fitness(x1(i,:),D);end%------初始化全局最优位置和最优值---------------g1=1000*ones(1,D);gbest1=1000;for i=1:Nif(pbest1(i)<gbest1)g1=p1(i,:);gbest1=pbest1(i);endendgb1=ones(1,T);%-----浸入主循环，按照公式依次迭代直到满足精度或者迭代次数---for i=1:Tfor j=1:Nif (fitness(x1(j,:),D)<pbest1(j))p1(j,:)=x1(j,:);pbest1(j)=fitness(x1(j,:),D);endif(pbest1(j)<gbest1)g1=p1(j,:);gbest1=pbest1(j);endv1(j,:)=w*v1(j,:)+c11*rand*(p1(j,:)-x1(j,:))+c21*rand*(g1-x1(j,:));x1(j,:)=x1(j,:)+v1(j,:);endgb1(i)=gbest1;endplot(gb1)TempStr=sprintf('c1= %g ,c2=%g',c11,c21);title(TempStr);xlabel('迭代次数');ylabel('适应度值');%第二个图subplot(1,2,2)%-----初始化种群个体（在此限定速度和位置）------------x2=x;v2=v;%-----初始化种群个体最有位置和最优解-----------p2=x2;pbest2=ones(N,1);for i=1:Npbest2(i)=fitness(x2(i,:),D);end%-----初始化种全局最有位置和最优解------g2=1000*ones(1,D);gbest2=1000;for i=1:Nif(pbest2(i)<gbest2)g2=p2(i,:);gbest2=pbest2(i);endendgb2=ones(1,T);%------浸入主循环，按照公式依次迭代直到满足精度或者迭代次数---for i=1:Tfor j=1:Nif (fitness(x2(j,:),D)<pbest2(j))p2(j,:)=x2(j,:);pbest2(j)=fitness(x2(j,:),D);endif(pbest2(j)<gbest2)g2=p2(j,:);gbest2=pbest2(j);endv2(j,:)=w*v2(j,:)+c12*rand*(p2(j,:)-x2(j,:))+c22*rand*(g2-x2(j,:)); x2(j,:)=x2(j,:)+v2(j,:);endgb2(i)=gbest2;endplot(gb2)TempStr=sprintf('c1= %g ,c2=%g',c12,c22);title(TempStr);xlabel('迭代次数');ylabel('适应度值');b ）适应度函数%适应度函数（fitness.m ）function result=fitness(x,D)sum=0;for i=1:Dsum=sum+x(i)^2;endresult=sum;程序4对21c c ≠，21w w ≠分别对其取值1.11=c ，22=c ，2.11=w ，5.12=w 测试函数。

pso算法 matlab程序

pso算法 matlab程序PSO（粒子群优化）算法是一种启发式优化算法，它模拟了鸟群或鱼群等生物群体的行为，通过个体之间的协作和信息共享来寻找最优解。

在MATLAB中，你可以使用以下代码实现一个简单的PSO算法：matlab.function [gbest, gbestval, fitcount] = pso(func, dim, bound, particle_num, maxgen, inertia, c1, c2)。

% 初始化粒子群。

particle = rand(particle_num, dim) . (bound(2)-bound(1)) + bound(1);velocity = zeros(particle_num, dim);pbest = particle;pbestval = feval(func, pbest');[gbestval, gbestid] = min(pbestval);gbest = pbest(gbestid, :);fitcount = 0;for i = 1:maxgen.% 更新粒子群。

r1 = rand(particle_num, dim);r2 = rand(particle_num, dim);velocity = inertia velocity + c1 r1 . (pbest particle) + c2 r2 . (repmat(gbest, particle_num, 1) particle);particle = particle + velocity;% 边界处理。

particle = max(particle, repmat(bound(1), particle_num, 1));particle = min(particle, repmat(bound(2), particle_num, 1));% 更新个体最优。

pso算法matlab代码

pso算法matlab代码粒子群优化算法（Particle Swarm Optimization，PSO）是一种基于群体智能的优化算法，其基本思想是通过模拟鸟群觅食行为来寻找最优解。

以下是一个简单的 MATLAB 代码示例，用于实现 PSO 算法：matlab复制代码% 定义问题参数n_particles = 100; % 粒子数量n_iterations = 100; % 迭代次数n_dimensions = 2; % 问题的维度lb = [-10-10]; % 问题的下界ub = [1010]; % 问题的上界c1 = 2; % 个体学习因子c2 = 2; % 社会学习因子% 初始化粒子群particles = lb + (ub-lb).*rand(n_particles,n_dimensions);velocities = zeros(n_particles, n_dimensions);p_best = particles;g_best = particles(1, :);g_best_fitness = inf;% 主循环for i = 1:n_iterations% 计算每个粒子的适应度值fitness = evaluate(particles); % 更新个体最优解for j = 1:n_particlesif fitness(j) < p_best(j, :)p_best(j, :) = particles(j, :); endend% 更新全局最优解for j = 1:n_particlesif fitness(j) < g_best_fitness g_best_fitness = fitness(j);g_best = particles(j, :);endend% 更新粒子速度和位置for j = 1:n_particlesr1 = rand(); % 个体学习因子随机数r2 = rand(); % 社会学习因子随机数velocities(j, :) = velocities(j, :) +c1*r1*(p_best(j, :) - particles(j, :)) + c2*r2*(g_best - particles(j, :));particles(j, :) = particles(j, :) + velocities(j, :);% 边界条件处理particles(j, :) = max(particles(j, :) , lb);particles(j, :) = min(particles(j, :) , ub);endend% 输出结果disp('全局最优解：');disp(g_best);disp('全局最优解的适应度值：');disp(g_best_fitness);其中，evaluate函数用于计算每个粒子的适应度值，需要根据具体问题进行定义。

粒子群Matlab程序代码

算法首先初始化一群随机粒子，然后通过迭代找到最优解。

在每一次迭代中，粒子通过跟踪两个“极值”即个体极值和全局极值来更新自己的速度与位置。

每维的速度与位置更新公式如下112(1)()(1)()(1)id id id id id id v v c rand p x c rand g x ω+=⨯+⨯⨯-+⨯⨯-11(2)id id id x x v ++=+W 为惯性权重，C1和C2为学习因子，rand （）——[0,1]范围内变化的随机数。

2.参数介绍与设置（1）ww 是保持粒子运动惯性的参数，能使种群扩展搜索空间，获得较好的求解效果。

较大的w 有利于群体在更大的范围内进行搜索。

而较小的w 能够保证群体收敛到最优位置，所以w 的选择及在迭代中的变化对搜索能力和跳出局优能力具有重要影响。

一般将w 设定为0.8左右。

粒子群算法matlab代码

一、粒子群主程序psize=20; %粒子个数的设置pd=12; %粒子的维数lz=zeros(psize,pd);for i=1:psize %随机生成粒子群，psize行pd列，pd维。

suiji=rand(1,pd);for j=1:pd/2if suiji(j)<0.5lz(i,j)=fix(unifrnd(0,100))*100;elselz(i,j)=fix(unifrnd(0,100)+1)*100;endendfor j=pd/2+1:1:pdif suiji(j)<0.5lz(i,j)=fix(unifrnd(0,45))/100;elselz(i,j)=fix(unifrnd(0,45)+1)/100;endendlz(i,1:pd/2)=sort(lz(i,1:pd/2));lz(i,pd/2+1:pd)=sort(lz(i,pd/2+1:pd));endlv=lz;goodvalue=lz; %每个粒子自己历史最好值初始化，psize行pd列。

vmax=20; %速度上限c1=2;c2=2; %学习因子w=0.729; %随机因子和惯性因子bestvalue=zeros(1,pd); %全局最好值初始化，1行pd列for j=1:pdbestvalue(1,j)=goodvalue(1,j);endfnew=zeros(1,psize);for j=1:psizefnew(j)=fpso(lz(1,:));endfold=fnew;flagstop=0; %终止标志k=0; %迭代次数记录f0=fpso(bestvalue); %适应值初始化while flagstop==0for i=1:psize %适应值比较，更新各自历史最好值（位置）fnew(i)=fpso(lz(i,:)); %记录每次每个粒子的适应值，便于以后设置终止条件if fnew(i)<fold(i)fold(i)=fnew(i); %fold记录每个粒子的最好历史值goodvalue(i,j)=lz(i,j);endendendfor i=1:psize%每个粒子历史最好值比较，更新全局最好值f1=fold(i);if f1<f0f0=f1;for j=1:pdbestvalue(1,j)=goodvalue(i,j);endendend%*********粒子趋一点终止条件*********%flagstop0=max(abs(fold)); %比较当次的所有粒子的适应值，flagstop1=min(abs(fold)); %若它们之间差别较小，则可以停止。

粒子群(pso)算法详解matlab代码

粒子群（pso）算法详解matlab代码(1)---- 一、粒子群算法的历史粒子群算法源于复杂适应系统（Complex Adaptive System,CAS）。

CAS理论于1994年正式提出，CAS中的成员称为主体。

比如研究鸟群系统，每个鸟在这个系统中就称为主体。

主体有适应性，它能够与环境及其他的主体进行交流，并且根据交流的过程“学习”或“积累经验”改变自身结构与行为。

整个系统的演变或进化包括：新层次的产生（小鸟的出生）；分化和多样性的出现（鸟群中的鸟分成许多小的群）；新的主题的出现（鸟寻找食物过程中，不断发现新的食物）。

所以CAS系统中的主体具有4个基本特点（这些特点是粒子群算法发展变化的依据）：首先，主体是主动的、活动的。

主体与环境及其他主体是相互影响、相互作用的，这种影响是系统发展变化的主要动力。

环境的影响是宏观的，主体之间的影响是微观的，宏观与微观要有机结合。

最后，整个系统可能还要受一些随机因素的影响。

粒子群算法就是对一个CAS系统－－－鸟群社会系统的研究得出的。

粒子群算法（ Particle Swarm Optimization, PSO）最早是由Eberhart和Kennedy于1995年提出，它的基本概念源于对鸟群觅食行为的研究。

设想这样一个场景:一群鸟在随机搜寻食物，在这个区域里只有一块食物，所有的鸟都不知道食物在哪里，但是它们知道当前的位置离食物还有多远。

那么找到食物的最优策略是什么呢?最简单有效的就是搜寻目前离食物最近的鸟的周围区域。

PSO算法就从这种生物种群行为特性中得到启发并用于求解优化问题。

在PSO 中，每个优化问题的潜在解都可以想象成d维搜索空间上的一个点，我们称之为“粒子”（Particle），所有的粒子都有一个被目标函数决定的适应值(Fitness Value )，每个粒子还有一个速度决定他们飞翔的方向和距离，然后粒子们就追随当前的最优粒子在解空间中搜索。

Reynolds对鸟群飞行的研究发现。

智能算法之粒子群优化算法-matlab程序-可运行

w = 0.8; % 惯性权重
c1 = 0.5; % 自我学习因子
c2 = 0.5; % 群体学习因子
for i = 1:d
x = limit(i, 1) + (limit(i, 2) - limit(i, 1)) * rand(N, d);%初始种群的位置
plot(x0, f(x0), 'b-', x, f(x), 'ro');title('状态位置变化')
pause(0.1)
iter = iter+1;
end
figure(3);plot(record);title('收敛过程')
x0 = 0 : 0.01 : 20;
d = 1; % 空间维数
ger = 100; % 最大迭代次数
limit = [0, 20]; % 设置位置参数限制
vlimit = [-1, 1]; % 设置速度限制
end
v = v * w + c1 * rand * (xm - x) + c2 * rand * (repmat(ym, N, 1) - x);% 速度更新
%Hale Waihona Puke 边界速度处理 v(v > vlimit(2)) = vlimit(2);
v(v < vlimit(1)) = vlimit(1);
while iter <= ger
fx = f(x) ; % 个体当前适应度
for i = 1:N
if fxm(i) < fx(i)
fxm(i) = fx(i); % 更新个体历史最佳适应度

多目标粒子群matlab代码

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 改进的多目标粒子群算法，包括多个测试函数% 对程序中的部分参数进行修改将更好地求解某些函数%ZDT1NP=cell(1,50);ZDT1FV=cell(1,50);ZDT1T=zeros(1,50);for i=1:50tic;%[np,nprule,dnp,fv,goals,pbest]=ParticleSwarmOpt('ZDT1',0.1,50,100,2.0,1.0,0.4,200,30,zer os(1,30),ones(1,30));%--ZDT1elapsedTime=toc;ZDT1NP(i)={np};ZDT1FV(i)={fv};ZDT1T(i)=elapsedTime;display(strcat('ZDT1',num2str(i)));endzdt1fv=cell2mat(ZDT1FV');zdt1fv=GetLeastFunctionValue(zdt1fv);ZDT2NP=cell(1,50);ZDT2FV=cell(1,50);ZDT2T=zeros(1,50);for i=1:50tic;%[np,nprule,dnp,fv,goals,pbest]=ParticleSwarmOpt('ZDT2',0.1,50,100,2.0,1.0,0.4,200,30,zer os(1,30),ones(1,30),[1,zeros(1,29)]);%--ZDT2elapsedTime=toc;ZDT2NP(i)={np};ZDT2FV(i)={fv};ZDT2T(i)=elapsedTime;display(strcat('ZDT2',num2str(i)));endzdt2fv=cell2mat(ZDT2FV');zdt2fv=GetLeastFunctionValue(zdt2fv); %%%%%%%%%%%%%%%%%%%%%%%%%%%5ZDT3NP=cell(1,50);ZDT3FV=cell(1,50);ZDT3T=zeros(1,50);for i=1:50tic;%[np,nprule,dnp,fv,goals,pbest]=ParticleSwarmOpt('ZDT3',0.1,50,100,2.0,1.0,0.4,400,30,zeros(1,30 ),ones(1,30));%--ZDT3elapsedTime=toc;ZDT3NP(i)={np};ZDT3FV(i)={fv};ZDT3T(i)=elapsedTime;display(strcat('ZDT3',num2str(i)));endzdt3fv=cell2mat(ZDT3FV');zdt3fv=GetLeastFunctionValue(zdt3fv);ZDT4NP=cell(1,50);ZDT4FV=cell(1,50);ZDT4T=zeros(1,50);for i=1:50tic;%[np,nprule,dnp,fv,goals]=ParticleSwarmOpt('ZDT4',0.1,50,100,2.0,1.0,0.4,200,10,[0,-5,-5,-5,-5,-5, -5,-5,-5,-5],[1,5,5,5,5,5,5,5,5,5],[1,0,0,0,0,0,0,0,0,0]);%--ZDT4elapsedTime=toc;ZDT4NP(i)={np};ZDT4FV(i)={fv};ZDT4T(i)=elapsedTime;display(strcat('ZDT4',num2str(i)));endzdt4fv=cell2mat(ZDT4FV');zdt4fv=GetLeastFunctionValue(zdt4fv); %%%%%%%%%%%%%%%%%%%%%%%%ZDT6NP=cell(1,50);ZDT6FV=cell(1,50);ZDT6T=zeros(1,50);for i=1:50tic;%[np,nprule,dnp,fv,goals,pbest]=ParticleSwarmOpt('ZDT6',0.1,50,100,2.0,1.0,0.4,200,10,zer os(1,10),ones(1,10));%--ZDT6elapsedTime=toc;ZDT6NP(i)={np};ZDT6FV(i)={fv};ZDT6T(i)=elapsedTime;display(strcat('ZDT6',num2str(i)));endzdt6fv=cell2mat(ZDT6FV');zdt6fv=GetLeastFunctionValue(zdt6fv);CTP1NP=cell(1,50);CTP1FV=cell(1,50);CTP1T=zeros(1,50);for i=1:50tic;[np,nprule,dnp,fv,goals,pbest]=ParticleSwarmOpt('CTP1',0.1,50,100,2.0,1.0,0.4,1500,5,[0,-5,-5,-5, -5],[1,5,5,5,5],[],struct('isfmopso',false,'istargetdis',false,'stopatborder',true));%--CTP1 elapsedTime=toc;CTP1NP(i)={np};CTP1FV(i)={fv};CTP1T(i)=elapsedTime;display(strcat('CTP1',num2str(i)));endctp1fv=cell2mat(CTP1FV');ctp1fv=GetLeastFunctionValue(ctp1fv);CTP1fmNP=cell(1,50);CTP1fmFV=cell(1,50);CTP1fmT=zeros(1,50);for i=1:50tic;[np,nprule,dnp,fv,goals,pbest]=ParticleSwarmOpt('CTP1',0.1,50,100,2.0,1.0,0.4,400,5,[0,-5,-5,-5,-5],[1,5,5,5,5],[0 0 0 0 0],struct('isfmopso',true,'istargetdis',false,'stopatborder',true));%--CTP1 elapsedTime=toc;CTP1fmNP(i)={np};CTP1fmFV(i)={fv};CTP1fmT(i)=elapsedTime;display(strcat('CTP1fm',num2str(i)));endctp1fmfv=cell2mat(CTP1fmFV');ctp1fmfv=GetLeastFunctionValue(ctp1fmfv);CTP2NP=cell(1,50);CTP2FV=cell(1,50);CTP2T=zeros(1,50);for i=1:50tic;[np,nprule,dnp,fv,goals,pbest]=ParticleSwarmOpt('CTP2',0.1,50,100,2.0,1.0,0.4,1500,5,[0,-5,-5,-5, -5],[1,5,5,5,5],[],struct('isfmopso',false,'istargetdis',false,'stopatborder',true));%--CTP2 elapsedTime=toc;CTP2NP(i)={np};CTP2FV(i)={fv};CTP2T(i)=elapsedTime;display(strcat('CTP2',num2str(i)));endctp2fv=cell2mat(CTP2FV');ctp2fv=GetLeastFunctionValue(ctp2fv);CTP2fmNP=cell(1,50);CTP2fmFV=cell(1,50);CTP2fmT=zeros(1,50);for i=1:50tic;[np,nprule,dnp,fv,goals,pbest]=ParticleSwarmOpt('CTP2',0.1,50,100,2.0,1.0,0.4,400,5,[0,-5,-5,-5,-5],[1,5,5,5,5],[0 0 0 0 0],struct('isfmopso',true,'istargetdis',false,'stopatborder',true));%--CTP2 elapsedTime=toc;CTP2fmNP(i)={np};CTP2fmFV(i)={fv};CTP2fmT(i)=elapsedTime;display(strcat('CTP2fm',num2str(i)));endctp2fmfv=cell2mat(CTP2fmFV');ctp2fmfv=GetLeastFunctionValue(ctp2fmfv);CTP3NP=cell(1,50);CTP3FV=cell(1,50);CTP3T=zeros(1,50);for i=1:50tic;[np,nprule,dnp,fv,goals,pbest]=ParticleSwarmOpt('CTP3',0.1,50,100,2.0,1.0,0.4,1400,5,[0,-5,-5,-5, -5],[1,5,5,5,5],[],struct('isfmopso',false,'istargetdis',false,'stopatborder',true));%--CTP3 elapsedTime=toc;CTP3NP(i)={np};CTP3FV(i)={fv};CTP3T(i)=elapsedTime;display(strcat('CTP3',num2str(i)));endctp3fv=cell2mat(CTP3FV');ctp3fv=GetLeastFunctionValue(ctp3fv);CTP3fmNP=cell(1,50);CTP3fmFV=cell(1,50);CTP3fmT=zeros(1,50);for i=1:50tic;[np,nprule,dnp,fv,goals,pbest]=ParticleSwarmOpt('CTP3',0.1,50,100,2.0,1.0,0.4,400,5,[0,-5,-5,-5,-5],[1,5,5,5,5],[0 0 0 0 0],struct('isfmopso',true,'istargetdis',false,'stopatborder',true));%--CTP3 elapsedTime=toc;CTP3fmNP(i)={np};CTP3fmFV(i)={fv};CTP3fmT(i)=elapsedTime;display(strcat('CTP3fm',num2str(i)));endctp3fmfv=cell2mat(CTP3fmFV');ctp3fmfv=GetLeastFunctionValue(ctp3fmfv);CTP4NP=cell(1,50);CTP4FV=cell(1,50);CTP4T=zeros(1,50);for i=1:50tic;[np,nprule,dnp,fv,goals,pbest]=ParticleSwarmOpt('CTP4',0.1,50,100,2.0,1.0,0.4,1400,5,[0,-5,-5,-5, -5],[1,5,5,5,5],[],struct('isfmopso',false,'istargetdis',false,'stopatborder',true));%--CTP4 elapsedTime=toc;CTP4NP(i)={np};CTP4FV(i)={fv};CTP4T(i)=elapsedTime;display(strcat('CTP4',num2str(i)));endctp4fv=cell2mat(CTP4FV');ctp4fv=GetLeastFunctionValue(ctp4fv);CTP4fmNP=cell(1,50);CTP4fmFV=cell(1,50);CTP4fmT=zeros(1,50);for i=1:50tic;[np,nprule,dnp,fv,goals,pbest]=ParticleSwarmOpt('CTP4',0.1,50,100,2.0,1.0,0.4,400,5,[0,-5,-5,-5,-5],[1,5,5,5,5],[0 0 1 0 0],struct('isfmopso',true,'istargetdis',false,'stopatborder',true));%--CTP4 elapsedTime=toc;CTP4fmNP(i)={np};CTP4fmFV(i)={fv};CTP4fmT(i)=elapsedTime;display(strcat('CTP4fm',num2str(i)));endctp4fmfv=cell2mat(CTP4fmFV');ctp4fmfv=GetLeastFunctionValue(ctp4fmfv);CTP5NP=cell(1,50);CTP5FV=cell(1,50);CTP5T=zeros(1,50);for i=1:50tic;%[np,nprule,dnp,fv,goals,pbest]=ParticleSwarmOpt('CTP5',0.1,50,100,2.0,1.0,0.4,200,5,[0,-5 ,-5,-5,-5],[1,5,5,5,5],[0 0 0 0 0]);%--CTP5elapsedTime=toc;CTP5NP(i)={np};CTP5FV(i)={fv};CTP5T(i)=elapsedTime;display(strcat('CTP5',num2str(i)));endctp5fv=cell2mat(CTP5FV');ctp5fv=GetLeastFunctionValue(ctp5fv);CTP6NP=cell(1,50);CTP6FV=cell(1,50);CTP6T=zeros(1,50);for i=1:50tic;%[np,nprule,dnp,fv,goals,pbest]=ParticleSwarmOpt('CTP6',0.1,50,100,2.0,1.0,0.4,400,5,[0,-5 ,-5,-5,-5],[1,5,5,5,5],[0 0 0 0 0]);%--CTP6elapsedTime=toc;CTP6NP(i)={np};CTP6FV(i)={fv};CTP6T(i)=elapsedTime;display(strcat('CTP6',num2str(i)));endctp6fv=cell2mat(CTP6FV');ctp6fv=GetLeastFunctionValue(ctp6fv);CTP7NP=cell(1,50);CTP7FV=cell(1,50);CTP7T=zeros(1,50);for i=1:50tic;%[np,nprule,dnp,fv,goals,pbest]=ParticleSwarmOpt('CTP7',0.1,50,100,2.0,1.0,0.4,1000,5,[0,-5,-5,-5,-5],[1,5,5,5,5],[1 0 0 0 0]);%--CTP7elapsedTime=toc;CTP7NP(i)={np};CTP7FV(i)={fv};CTP7T(i)=elapsedTime;display(strcat('CTP7',num2str(i)));endctp7fv=cell2mat(CTP7FV');ctp7fv=GetLeastFunctionValue(ctp7fv);CONSTRNP=cell(1,50);CONSTRFV=cell(1,50);CONSTRT=zeros(1,50);for i=1:50tic;%[np,nprule,dnp,fv,goals,pbest]=ParticleSwarmOpt('CTP8',0.1,50,100,2.0,1.0,0.4,200,2,[0.1, 0],[1,5]);%--CTP8,CONSTRelapsedTime=toc;CONSTRNP(i)={np};CONSTRFV(i)={fv};CONSTRT(i)=elapsedTime;display(strcat('CTP8',num2str(i)));endconstrfv=cell2mat(CONSTRFV');constrfv=GetLeastFunctionValue(constrfv);SRNNP=cell(1,50);SRNFV=cell(1,50);SRNT=zeros(1,50);for i=1:50tic;%[np,nprule,dnp,fv,goals,pbest]=ParticleSwarmOpt('CTP9',0.1,50,100,2.0,1.0,0.4,200,2,[-20, -20],[20,20]);%--CTP9,SRNelapsedTime=toc;SRNNP(i)={np};SRNFV(i)={fv};SRNT(i)=elapsedTime;display(strcat('CTP9',num2str(i)));endsrnfv=cell2mat(SRNFV');srnfv=GetLeastFunctionValue(srnfv);TNKNP=cell(1,50);TNKFV=cell(1,50);TNKT=zeros(1,50);for i=1:50tic;[np,nprule,dnp,fv,goals,pbest]=ParticleSwarmOpt('CTP10',0.1,50,100,2.0,1.0,0.4,1300,2,[0,0],[pi, pi],[],struct('isfmopso',false,'istargetdis',false,'stopatborder',false));%--CTP10,TNK elapsedTime=toc;TNKNP(i)={np};TNKFV(i)={fv};TNKT(i)=elapsedTime;display(strcat('CTP10',num2str(i)));endtnkfv=cell2mat(TNKFV');tnkfv=GetLeastFunctionValue(tnkfv);TNKfmNP=cell(1,50);TNKfmFV=cell(1,50);TNKfmT=zeros(1,50);for i=1:50tic;[np,nprule,dnp,fv,goals,pbest]=ParticleSwarmOpt('CTP10',0.1,50,100,2.0,1.0,0.4,300,2,[0,0],[pi,pi],[],struct('isfmopso',true,'istargetdis',false,'stopatborder',false));%--CTP10,TNK elapsedTime=toc;TNKfmNP(i)={np};TNKfmFV(i)={fv};TNKfmT(i)=elapsedTime;display(strcat('CTP10fm',num2str(i)));endtnkfmfv=cell2mat(TNKfmFV');tnkfmfv=GetLeastFunctionValue(tnkfmfv);BNHNP=cell(1,50);BNHFV=cell(1,50);BNHT=zeros(1,50);for i=1:50tic;%[np,nprule,dnp,fv,goals,pbest]=ParticleSwarmOpt('BNH',0.1,50,100,2.0,1.0,0.4,200,2,zeros (1,2),[5,3]);%--BNHelapsedTime=toc;BNHNP(i)={np};BNHFV(i)={fv};BNHT(i)=elapsedTime;display(strcat('BNH',num2str(i)));endbnhfv=cell2mat(BNHFV');bnhfv=GetLeastFunctionValue(bnhfv);OSYNP=cell(1,50);OSYFV=cell(1,50);OSYT=zeros(1,50);for i=1:50tic;[np,nprule,dnp,fv,goals,pbest]=ParticleSwarmOpt('OSY',0.1,50,100,2.0,1.0,0.4,1500,6,[0,0,1,0,1,0 ],[10,10,5,6,5,10],[],struct('isfmopso',false,'istargetdis',false,'stopatborder',true));%--OSY elapsedTime=toc;OSYNP(i)={np};OSYFV(i)={fv};OSYT(i)=elapsedTime;display(strcat('OSY',num2str(i)));endosyfv=cell2mat(OSYFV');osyfv=GetLeastFunctionValue(osyfv);OSYfmNP=cell(1,50);OSYfmFV=cell(1,50);OSYfmT=zeros(1,50);for i=1:50tic;[np,nprule,dnp,fv,goals,pbest]=ParticleSwarmOpt('OSY',0.1,50,100,2.0,1.0,0.4,500,6,[0,0,1,0,1,0], [10,10,5,6,5,10],[],struct('isfmopso',true,'istargetdis',false,'stopatborder',true));%--OSY elapsedTime=toc;OSYfmNP(i)={np};OSYfmFV(i)={fv};OSYfmT(i)=elapsedTime;display(strcat('OSYfm',num2str(i)));endosyfmfv=cell2mat(OSYfmFV');osyfmfv=GetLeastFunctionValue(osyfmfv);function [np,nprule,dnp,fv,goals,pbest] = ParticleSwarmOpt(funcname,unfitx,N,Nnp,cmax,cmin,w,M,D,lb,ub,x0,params)%待优化的目标函数:fitness%约束容忍度unfitx=0.01,逐步降到0%内部种群(粒子数目)：N%外部种群(非劣解集):Nnp%学习因子1:cmax%学习因子2:cmin%惯性权重:w%最大迭代次数：M%问题的维数：D%目标函数取最小值时的自变量值:xm%目标函数的最小值:fv%迭代次数:cvformat long;NP=[];%非劣解集Dnp=[];%非劣解集距离if nargin < 13params = struct('isfmopso',false,'istargetdis',false,'stopatborder',true);endif (nargin < 12 || isempty(x0))x0=lb+(ub-lb).*rand([1,D]);endT=size(fitness(x0,funcname),2);goals=zeros(M,N,T);%记下N个粒子M次迭代T维目标变化%----初始化种群的个体--------///////第1步///////////////////////////////////x(1,:)=x0;v(1,:)=(ub-lb).*rand([1,D])*0.5;for i=2:Nfor j=1:Dx(i,j)=lb(j)+(ub(j)-lb(j))*rand; %随机初始化位置v(i,j)=(ub(j)-lb(j))*rand*0.5; %随机初始化速度endend%----计算目标向量----------%---速度控制vmax=(ub-lb)*0.5;vmin= -vmax;%-----求出初始NP-----------////////第2步///////////////////////////////////NP(1,:)=x(1,:);%第一个默认加入NPNPRule=[0,0,0];%非劣解集参数Dnp(1,1)=0;for i=2:Nfaix = GetFai(x(i,:),funcname,params);if faix<=unfitx[NP,NPRule,Dnp] = compare(x(i,:),NP,NPRule,Dnp,Nnp,funcname,params);endend%-----初始自身最好位置------///////第3步////////////////////////////////////pbest = x;%自身最优解%-----在确定每个粒子所对就的目标方格-------//第4步///////////////////////////%------进入主要循环，按照公式依次迭代------------for t=1:Mif mod(t,100)==0unfitx = 0.01-0.01*(t+200)/M;if unfitx <0unfitx =0 ;end% [x,v,pbest,NP,NPRule,Dnp]=ReInit(x,v,pbest,NP,NPRule,Dnp,Nnp,D,lb,ub,unfitx);endc = cmax - (cmax - cmin)*t/M;w1=w-(w-0.3)*t/M;%c = cmax;%c = cmax - (cmax - cmin)*mod(t,51)/50;%w1=w-(w-0.3)*mod(t,51)/50;%-----获得全局最优-------/////第5步/////////////////////////////////////////%if mod(t,3)==1%[gbest,NPRule] = GetGlobalBest(NP,NPRule,Dnp);%endfor i=1:N%-------------------更新粒子的位置和速度----------////第6步//////////////////%v(i,:)=w*v(i,:)+cmin*rand*(pbest(i,:)-x(i,:))+cmax*rand*(gbest-x(i,:));%[gbest,NPRule] = GetGlobalBest2(x(i,:),NP,NPRule);%%%%%12-17[gbest,NPRule] = GetGlobalBest(NP,NPRule,Dnp);%w1=Inf;%while(w1>1.2 || w1<0)% w1=0.8+randn*0.8;%end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%模糊向导粒子群算法if(params.isfmopso)nploc=x(i,:);npruleloc=[0,0,0];dnploc(1,1)=0;tempv=zeros(10,D);tempx=zeros(10,D);for k=1:10tempv(k,:)=w1*v(i,:)+c*rand*(pbest(i,:)-x(i,:))+c*rand*(gbest-x(i,:));for j=1:Dif tempv(k,j)>vmax(j)tempv(k,j)=vmax(j);elseif tempv(k,j)<vmin(j)tempv(k,j)=vmin(j);endendtempx(k,:)=x(i,:)+tempv(k,:);faix = GetFai(x(i,:),funcname,params);if faix<=unfitx[nploc,npruleloc,dnploc] = compare(tempx(k,:),nploc,npruleloc,dnploc,10,funcname,params);endendnnx=size(nploc,1);seltemp=randi([1,nnx]);ttv=nploc(seltemp,:)-x(i,:);x(i,:)=nploc(seltemp,:);if sum(abs(ttv))>0v(i,:)=ttv;endelse%%%%%%%%%%%%%%%%%%%v(i,:)=w1*v(i,:)+c*rand*(pbest(i,:)-x(i,:))+c*rand*(gbest-x(i,:));for j=1:Dif v(i,j)>vmax(j)v(i,j)=vmax(j);elseif v(i,j)<vmin(j)v(i,j)=vmin(j);endendx(i,:)=x(i,:)+v(i,:);funcname=upper(funcname);if(strcmp(funcname(1:3),'CTP'))x(i,:)=x(i,:)+v(i,:);endend %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%-------------------采取措施，避免粒子飞出空间----------////第7步/////////////%速度位置钳制if(params.stopatborder)%粒子随机停留在边界for j=1:Dif x(i,j)>ub(j)if(randi([0,0],1)==0)x(i,j)=ub(j);v(i,j)=-v(i,j);else x(i,j)=lb(j)+(ub(j)-lb(j))*rand; %随机初始化位置v(i,j)=(ub(j)-lb(j))*rand*0.5;endendif x(i,j)<lb(j)if(randi([0,0],1)==0)x(i,j)=lb(j);v(i,j)=-v(i,j);elsex(i,j)=lb(j)+(ub(j)-lb(j))*rand; %随机初始化位置v(i,j)=(ub(j)-lb(j))*rand*0.5;endendendelse %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%for j=1:Dif x(i,j)>ub(j)%粒子飞出上边界x(i,j)=x(i,j)-v(i,j);v(i,j)=rand*(ub(j)-x(i,j));x(i,j)=x(i,j)+v(i,j);elseif x(i,j)<lb(j)%粒子飞出下边界x(i,j)=x(i,j)-v(i,j);v(i,j)=rand*(x(i,j)-lb(j));x(i,j)=x(i,j)-v(i,j);endendend %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%------------------每个粒子的目标向量-----------------//第8步///////////////goals(t,i,:)=fitness(x(i,:),funcname,params);%----------------调整自身---------------------------//第10步/////////////////domiRel = DominateRel(pbest(i,:),x(i,:),funcname,params);%x,y的支配关系if domiRel==1%pbest支配新解continue;elseif domiRel==-1%新解支配pbestpbest(i,:) = x(i,:);elseif(randi([0,1],1)==0)%新解与pbest互相不支配pbest(i,:) = x(i,:);end%-----------------对NP进行更新和维护-----------------//第9步////////////////faix = GetFai(x(i,:),funcname,params);if faix<=unfitx[NP,NPRule,Dnp] = compare(x(i,:),NP,NPRule,Dnp,Nnp,funcname,params);endendendendnp = NP;%非劣解nprule=NPRule;dnp = Dnp;%非劣解之间的距离r=size(np,1);fv=zeros(r,T);for i=1:rfv(i,:)=fitness(np(i,:),funcname,params);endend%%%%%%%%%%%%%%%--------------主函数结束--------------%%%%%%%%%%%%%%%%%function [np_out,nprule_out,dnp_out] = compare(x,np,nprule,dnp,nnp,funcname,params)%np:现有非劣解%x:需要比较的量Nnp = nnp;%非劣解集空间r=size(np,1);%非劣解的个数np_out=np;%非劣解复本nprule_out = nprule;dnp_out = dnp;%非劣解集点之间距离if r==0return;endfor i=r:-1:1domiRel=DominateRel(x,np(i,:),funcname,params);if domiRel==1 %NP(i)被x支配np_out(i,:)=[];%非劣解剔除该解nprule_out(i,:)=[];dnp_out(i,:)=[];if ~isempty(dnp_out)dnp_out(:,i)=[];endelseif domiRel==-1 %x被NP(i)支配,返回不再比较return;endendr1=size(np_out,1);%现有非劣解的行列np_out(r1+1,:)=x;%与所有非支配集粒子比较均占优或不可比较，则NP中加入x faix = GetFai(x,funcname,params);if faix > 0nprule_out(r1+1,:)=[0,faix,0];elsenprule_out(r1+1,:)=[0,0,0];endif r1==0dnp_out=0;endfor j=1:r1dnp_out(r1+1,j)=GetDistance(np_out(j,:),x,funcname,params);dnp_out(j,r1+1)=dnp_out(r1+1,j);endif r1>=Nnp %未达到非劣解种群极限%---------移除密集距离最小的一个-------densedis = GetDenseDis(dnp_out);n_min = find(min(densedis)==densedis);%找出密度距离最小的一个tempIndex = randi([1,length(n_min)],1);np_out(n_min(tempIndex),:)=[];%非劣解剔除该解nprule_out(n_min(tempIndex),:)=[];dnp_out(n_min(tempIndex),:)=[];if ~isempty(dnp_out)dnp_out(:,n_min(tempIndex))=[];endendend%%%%%%%%%%%%%%-----------将粒子维护到外部种群----------%%%%%%%%%%%%%%%%%function dis=GetDistance(x,y,funcname,params)%求两向量之间的距离if(params.istargetdis)gx=fitness(x,funcname);gy=fitness(y,funcname);gxy=(gx-gy).^2;dis=sqrt(sum(gxy(:)));elseg=x-y;dis=sum(sum(g.^2));endendfunction densedis = GetDenseDis(dnp)%密集距离[r,c] = size(dnp);densedis=zeros(1,r);for i=1:rfirstmin=Inf;%secondmin=Inf;for j=1:cif dnp(i,j)~=0 && dnp(i,j)<firstminfirstmin = dnp(i,j);end% if dnp(i,j)~=0 && dnp(i,j)~=firstmin && dnp(i,j)<secondmin% secondmin = dnp(i,j);% endend% densedis(i)=(firstmin+secondmin)/2;densedis(i)=firstmin;endendfunction sparedis = GetSpareDis(dnp)%稀疏距离[r,c] = size(dnp);sparedis=zeros(1,r);for i=1:rfirstmin=Inf;secondmin=Inf;for j=1:cif dnp(i,j)~=0 && dnp(i,j)<firstminfirstmin = dnp(i,j);endif dnp(i,j)~=0 && dnp(i,j)~=firstmin && dnp(i,j)<secondminsecondmin = dnp(i,j);endendsparedis(i)=(firstmin+secondmin)/2;endend%%%%%%%%%%%%%%%%%-----------密集(稀疏)距离------------%%%%%%%%%%%%%%%%%%%function v = DominateRel(x,y,funcname,params)%判断x与y支配关系,返回1表示x支配y，返回-1表示y支配x,返回0表示互不支配v=0;faix = GetFai(x,funcname,params);faiy = GetFai(y,funcname,params);if faix>faiyv=-1;elseif faiy>faixv=1;endif v~=0 %x、y构成违反约束支配关系return;endgx = fitness(x,funcname,params);%x的目标向量gy = fitness(y,funcname,params);%y的目标向量len = length(gx);if sum(gx<=gy)==len%x的所有目标都比y小，x支配yv=1;elseif sum(gx>=gy)==len%y的所有目标都比x小，y支配xv=-1;endend%%%%%%%%%%%%%%%%%---------比较两粒子的相互支配关系-----------%%%%%%%%%%%%%function [gbest,nprule_out] = GetGlobalBest2(x,np,nprule)%按照一定原则随机取一个全局最优r=size(np,2);%非劣解的行列,r:非劣解集个数，c：维数%假定x被非劣解集np支配IsDominated=true;Mdom=[];%支配x的集合for i=1:rdomiRel=DominateRel(np(i,:),x,funcname,params);if domiRel==1%np(i)支配xMdom=[Mdom,i];%记下其在非劣解集中的编号elseIsDominated=false;break;endendnprule_out=nprule;if IsDominated%x被支配,从x的支配集中选出一个作为全局最优intem=randi([1,length(Mdom)],1);gbest=np(Mdom(intem),:);nprule_out(Mdom(intem),1)=nprule_out(Mdom(intem),1)+1; else%x不被支配，从所有非劣解集中选出一个作为全局最优nr=size(np,1);intem=randi([1,nr],1);gbest=np(intem,:);nprule_out(intem,1)=nprule_out(intem,1)+1;endendfunction [gbest,nprule_out] = GetGlobalBest(np,nprule,dnp_out)%随机取一个全局最优r=size(np,1);%非劣解的行列nprule_out=nprule;intem=1;if(randi([0,3],1)==0)if r==1gbest = np(1,:);elsesparedis = GetSpareDis(dnp_out);%[max1,max2] = find(max(max(dnp_out))==dnp_out);%intem=max1(randi([1,length(max1)],1));n_max=find(max(sparedis)==sparedis);intem=n_max(randi([1,length(n_max)],1));gbest = np(intem,:);endelse%rr=randi([1,r],1);%随机取一个作为全局最优%gbest = np(rr,:);tt=find(min(nprule(:,1))==nprule(:,1));intem=tt(randi([1,length(tt)],1));gbest = np(intem,:);endnprule_out(intem,1)=nprule_out(intem,1)+1;end%%%%%%%%%%%%%%%%%%%----------从部种群中找到全局最优-------%%%%%%%%%%%%%%%function[x,v,pbest,NP,NPRule,Dnp]=ReInit(x,v,pbest,NP,NPRule,Dnp,Nnp,D,lb,ub,unfitx,funcname,para ms)for i=1:10for j=1:Dx(i,j)=(ub(j)-lb(j))*rand; %随机初始化位置v(i,j)=(ub(j)-lb(j))*rand*0.5; %随机初始化速度pbest(i,j)=x(i,j);endendfor i=1:10faix = GetFai(x(i,:),funcname,params);if faix<=unfitx[NP,NPRule,Dnp] = compare(x(i,:),NP,NPRule,Dnp,Nnp,funcname,params);endendend%%%%%%%%%%%%%%%%%%%----------重新初始化部分粒子-------%%%%%%%%%%%%%%%function fv=fitness(x,funcname,params)%获得多目标的目标向量fvfv=[];switch upper(funcname)%------DTLZ1%------ZDT1case 'ZDT1'n=length(x);gv=1+9*sum(x(2:n))/(n-1);fv(1)=x(1);fv(2)=gv*(1-sqrt(x(1)/gv));%------ZDT2case 'ZDT2'n=length(x);gv=1+9*sum(x(2:n))/(n-1);fv(1)=x(1);fv(2)=gv*(1-(x(1)/gv).^2);%------ZDT3case 'ZDT3'n=length(x);gv=1+9*sum(x(2:n).^2)/(n-1);fv(1)=x(1);fv(2)=gv*(1-sqrt(x(1)/gv)-(x(1)/gv)*sin(10*pi*x(1))); %------ZDT4case 'ZDT4'n=length(x);gv=1+10*(n-1)+sum(x(2:n).^2-10*cos(4*pi*x(2:n)));fv(1)=x(1);fv(2)=gv*(1-sqrt(x(1)./gv));%------ZDT5case 'ZDT5'%------ZDT4case 'ZDT6'n=length(x);gv=1+9*(sum(x(2:n))/(n-1)).^0.25;fv(1)=1-exp(-4*x(1))*sin(6*pi*x(1)).^6;fv(2)=gv*(1-(fv(1)/gv).^2);%------CTP1case 'CTP1'n=length(x);cx=41+sum(x(2:n).^2-10*cos(2*pi*x(2:n)));fv(1)=x(1);fv(2)=cx*exp(-fv(1)/cx);%------CTP2,CTP3,CTP4,CTP5,CTP6,CTP7case {'CTP2','CTP3','CTP4','CTP5','CTP6','CTP7'}n=length(x);cx=41+sum(x(2:n).^2-10*cos(2*pi*x(2:n)));fv(1)=x(1);fv(2)=cx*(1-fv(1)/cx);%------CTP8,CONSTRcase {'CTP8','CONSTR'}fv(1)=x(1);fv(2)=(1+x(2))/x(1);%------CTP9,SRNcase {'CTP9','SRN'}fv(1)=(x(1)-2)^2+(x(2)-1)^2+2;fv(2)=9*x(1)-(x(2)-1)^2;%------CTP10,TNK,MOP-C4case {'CTP10','TNK','MOP-C4'}fv(1)=x(1);fv(2)=x(2);%-------MOP-C1,BNHcase {'MOP-C1','BNH'}fv(1)=4*x(1)^2+4*x(2)^2;fv(2)=(x(1)-5)^2+(x(2)-5)^2;%------MOP-C2,OSYcase {'MOP-C2','OSY'}fv(1)=-(25*(x(1)-2)^2+(x(2)-2)^2+(x(3)-1)^2+(x(4)-4)^2+(x(5)-1)^2);fv(2)=x(1)^2+x(2)^2+x(3)^2+x(4)^2+x(5)^2+x(6)^2;%------MOP-C3case 'MOP-C3'fv(1)=(x(1)-2)^2/2+(x(2)+1)^2/13+3;fv(2)=(x(1)+x(2)-3)^2/175+(2*x(2)-x(1))^2/17-13;fv(3)=(3*x(1)-2*x(2)+4)^2/8+(x(1)-x(2)+1)^2/27+15;endendfunction fai = GetFai(x,funcname,params)%构造约束函数switch upper(funcname)%---DTLZ1,...,DTLZ4函数case {'DTLZ1','DTLZ2','DTLZ3','DTLZ4'}fai=0;%---ZDT1,...,ZDT6函数case {'ZDT1','ZDT2','ZDT3','ZDT4','ZDT5','ZDT6'}fai=0;%------CTP1case 'CTP1'n=length(x);cx=41+sum(x(2:n).^2-10*cos(2*pi*x(2:n)));f1=x(1); f2=cx*exp(-f1/cx);g1=0.858*exp(-0.541*f1)-f2;g2=0.728*exp(-0.295*f1)-f2;fai=max(g1,0)+max(g2,0);%------CTP2,CTP3,CTP4,CTP5,CTP6,CTP7case {'CTP2','CTP3','CTP4','CTP5','CTP6','CTP7'}navars=[-0.2*pi,0.2,10,1,6,1;-0.2*pi,0.1,10,1,0.5,1;-0.05*pi,40,5,1,6,0;-0.2*pi,0.1,10,2,0.5,1;-0.1*pi,40,0.5,1,2,-2;-0.2*pi,0.75,10,1,0.5,1;];i=str2double(funcname(4))-1;%%选择的是第几个测试函数sita=navars(i,1);a=navars(i,2);b=navars(i,3);c=navars(i,4);d=navars(i,5);e=navars(i,6);n=length(x);cx=41+sum(x(2:n).^2-10*cos(2*pi*x(2:n)));f1=x(1); f2=cx*(1-f1/cx);g=a*abs(sin(b*pi*(sin(sita)*(f2-e)+cos(sita)*f1)^c))^d-(cos(sita)*(f2-e)-sin(sita)*f1);fai=max(g,0);%------CTP8,CONSTRcase {'CTP8','CONSTR'}g1=6-x(2)-9*x(1);g2=1+x(2)-9*x(1);fai=max(g1,0)+max(g2,0);%------CTP9,SRNcase {'CTP9','SRN'}g1=x(1)^2+x(2)^2-255;g2=x(1)-3*x(2)+10;fai=max(g1,0)+max(g2,0);%------CTP10,TNK,MOP-C4case {'CTP10','TNK','MOP-C4'}g1=-x(1)^2-x(2)^2+1+0.1*cos(16*atan(x(1)/x(2)));g2=(x(1)-0.5)^2+(x(2)-0.5)^2-0.5;fai=max(g1,0)+max(g2,0);%-------MOP-C1,BNH函数case {'MOP-C1','BNH'}g1=(x(1)-5)^2+x(2)^2-25;g2=7.7-(x(1)-8)^2-(x(2)+3);fai=max(g1,0)+max(g2,0);%------MOP-C2,OSY函数case {'MOP-C2','OSY'}g1=2-x(1)-x(2); g2=-6+x(1)+x(2);g3=-2-x(1)+x(2); g4=-2+x(1)-3*x(2);g5=-4-(x(3)-3)^2+x(4); g6=4-(x(5)-3)^2-x(6);fai = max(g1,0)+max(g2,0)+max(g3,0)+max(g4,0)+max(g5,0)+max(g6,0);%------MOP-C3case 'MOP-C3'g1=x(2)+4*x(1)-4;g2=x(1)-x(2)-2;fai = max(g1,0)+max(g2,0);endendfunction fvout=GetLeastFunctionValue(fvin)%将外部种群中的非支配集剔除fvout=fvin;n=size(fvout,1);i=1;while(i<=n)j=i+1;isdominated=false;while(j<=n)a=fvout(i,:);b=fvout(j,:);if((a(1)<b(1)&&a(2)<=b(2))||(a(1)<=b(1)&&a(2)<b(2)))fvout(j,:)=[];n=n-1;elseif((b(1)<a(1)&&b(2)<=a(2))||(b(1)<=a(1)&&b(2)<a(2)))isdominated=true;endj=j+1;endendif isdominatedfvout(i,:)=[];n=n-1;elsei=i+1;endendendfunction [SP,SP1,MS,GD,GD2]=GetEvaluDis(funcname,NP,stdfv)%计算所有评价指标的值if(iscell(NP))n=length(NP);SP=Inf*ones(1,n);SP1=Inf*ones(1,n);MS=Inf*ones(1,n);GD=Inf*ones(1,n);GD2=Inf*ones(1,n);for i=1:nnp=cell2mat(NP(i));[sp,sp1]=Spacing(funcname,np);ms=MaximumSpread(funcname,np);gd=GenerationalDistance(funcname,np,stdfv);gd2=GenerationalDistance2(funcname,np);SP(i)=sp;SP1(i)=sp1;MS(i)=ms;GD(i)=gd;GD2(i)=gd2;endelse[SP,SP1]=Spacing(funcname,NP);MS=MaximumSpread(funcname,NP);GD=GenerationalDistance(funcname,NP,stdfv);GD2=GenerationalDistance2(funcname,NP);endendfunction [SP,SP1]=Spacing(funcname,np)%分散性(Spacing,SP)n=size(np,1);m=size(fitness(np(1,:),funcname),2);f=zeros(n,m);for i=1:nf(i,:)=fitness(np(i,:),funcname);endn=size(f,1);%n:解的个数；dd=ones(1,n)*Inf;d=zeros(1,n);for i=1:nk=0;for j=1:nif j==icontinue;endk=k+1;dd(i,k)=sum(abs(f(i,:)-f(j,:)));endd(i)=min(dd(i,:));enddaver=mean(d);SP=sqrt(sum((d-daver).^2)/n);SP1=sqrt(sum((d-daver).^2)/(n-1))/daver;endfunction D=MaximumSpread(funcname,np) %最大散布范围(Maximum Spread,MS)n=size(np,1);m=size(fitness(np(1,:),funcname),2);f=zeros(n,m);if(n==1)D=0;return;endfor i=1:nf(i,:)=fitness(np(i,:),funcname);endfmax=Inf*ones(1,m);fmin=-Inf*ones(1,m);switch upper(funcname)%------ZDT1,'ZDT2',ZDT4case {'ZDT1','ZDT2','ZDT4'}fmax=[1,1;];fmin=[0,0;];%------ZDT3case 'ZDT3'fmax=[0.851701065645526,1];fmin=[0,-0.761625883165305]; %------ZDT6case 'ZDT6'fmax=[1,0.921164494015440];fmin=[0.280776612246391,0];case 'CTP1'fmax=[1,1];fmin=[0,0.542143003351532];case 'CTP2'fmax=[0.985582138027326,1];fmin=[0,0.287445806007632];case 'CTP3'fmax=[0.971176296100037,1];fmin=[0,0.295146218332835];case 'CTP4'fmax=[1,1.044724051472542];fmin=[0,0];case 'CTP5'case 'CTP6'case 'CTP7'。

matlab智能算法代码

matlab智能算法代码MATLAB是一种功能强大的数值计算和科学编程软件，它提供了许多智能算法的实现。

下面是一些常见的智能算法及其在MATLAB中的代码示例：1. 遗传算法（Genetic Algorithm）：MATLAB中有一个专门的工具箱，称为Global Optimization Toolbox，其中包含了遗传算法的实现。

以下是一个简单的遗传算法示例代码：matlab.% 定义目标函数。

fitness = @(x) x^2;% 设置遗传算法参数。

options = gaoptimset('Display', 'iter','PopulationSize', 50);% 运行遗传算法。

[x, fval] = ga(fitness, 1, options);2. 粒子群优化算法（Particle Swarm Optimization）：MATLAB中也有一个工具箱，称为Global Optimization Toolbox，其中包含了粒子群优化算法的实现。

以下是一个简单的粒子群优化算法示例代码：matlab.% 定义目标函数。

fitness = @(x) x^2;% 设置粒子群优化算法参数。

options = optimoptions('particleswarm', 'Display','iter', 'SwarmSize', 50);% 运行粒子群优化算法。

[x, fval] = particleswarm(fitness, 1, [], [], options);3. 支持向量机（Support Vector Machine）：MATLAB中有一个机器学习工具箱，称为Statistics and Machine Learning Toolbox，其中包含了支持向量机的实现。

自适应粒子群优化算法matlab

自适应粒子群优化算法matlab自适应粒子群优化算法（Adaptive Particle Swarm Optimization, APSO）是一种基于群体智能的优化算法，它模拟了鸟群觅食的行为，通过不断迭代来搜索最优解。

本文将介绍APSO的原理和在MATLAB中的实现。

一、自适应粒子群优化算法原理自适应粒子群优化算法是一种启发式优化算法，它通过模拟鸟群觅食的行为来搜索最优解。

在APS0中，将解空间划分成一系列粒子，每个粒子表示一个解。

每个粒子都有自己的位置和速度，位置表示解的值，速度表示解的搜索方向和速度。

APS0的基本原理是通过不断更新粒子的速度和位置，使粒子在解空间中搜索最优解。

粒子的速度更新公式如下：v(t+1) = w * v(t) + c1 * rand() * (pbest(t) - x(t)) + c2 * rand() * (gbest(t) - x(t))其中，v(t+1)表示粒子在下一次迭代中的速度，w表示惯性权重，c1和c2分别表示粒子自身和全局最优解的学习因子，rand()为随机数函数，pbest(t)表示粒子自身的历史最优解，gbest(t)表示全局最优解，x(t)表示粒子当前的位置。

粒子的位置更新公式如下：x(t+1) = x(t) + v(t+1)通过不断迭代更新粒子的速度和位置，最终找到全局最优解。

二、在MATLAB中的实现在MATLAB中，可以使用以下步骤实现自适应粒子群优化算法：1. 初始化粒子群的位置和速度。

位置和速度可以随机生成或者根据问题的特点进行初始化。

2. 计算每个粒子的适应度值。

适应度值反映了解的优劣程度，可以根据问题的具体定义进行计算。

3. 更新每个粒子的个体最优解pbest和全局最优解gbest。

根据适应度值更新最优解。

4. 更新每个粒子的速度和位置。

根据速度更新公式更新粒子的速度和位置。

5. 判断终止条件。

可以设置迭代次数或者设定适应度值达到一定阈值时停止迭代。

PSOELM(粒子群优化极限学习机)MATLAB程序

clear all;clc;close allclear allclc%load pca1load pca2load pca4load pca3%c =566:984%plot(pca2)%plot(x,P11,x,pca11,'r')%plot(x,EP1,'b',x,EP2,'r',x,EP3,'k',x,EP4,'g') %P11=mapminmax(pca1',0,1);%P22=mapminmax(pca2',0,1);%P33=mapminmax(pca3',0,1);%P44=mapminmax(pca4',0,1);%EP1=EWMA(pca1(566:984)',0.2,18)%EP4=EWMA(pca4(772:984)',0.3,16)%EP2=EWMA(pca2(772:984)',0.3,16)%EP3=EWMA(pca3(691:984)',0.3,16)%plot(x,EP1,'b',x,EP2,'r',x,EP3,'k',x,EP4,'g') %P11=mapminmax(EP1,0,1);%P22=mapminmax(EP2,0,1);%P33=mapminmax(EP3,0,1);%P44=mapminmax(EP4,0,1);EP2=smooth(pca2(772:984))';EP4=smooth(pca4(772:984))';Q=zeros(150,64);%V=zeros(965,20);for j=1:64for i=1:150Q(i,j)=EP2(i+j-1);endendP1=Q;P2=(149:-1:0)';PP=[P1,P2];%..................制作测试集....................% M=zeros(150,64);for j=1:64for i=1:150M(i,j)=EP4(i+j-1);endendT1=M;T2=(149:-1:0)';TT=[T1,T2];clearvars -except PP TTX_data=PP;Y_data=TT;%data=load('Lorenz.txt%% 加载数据%x=xlsread('pso_elmdata.xls');%AllSamIn = x(1:29,1:2)';%AllSamOut = x(1:29,3)';%AllTestIn=x(30:36,1:2)';%AllTestOut=x(30:36,3)'; AllSamIn =PP(:,1:64)'; AllSamOut=PP(:,65)';AllTestIn=TT(:,1:64)';AllTestOut=TT(:,65)';%% 训练样本归一化global minAllSamOut;global maxAllSamOut;[AllSamInn,minAllSamIn,maxAllSamIn,AllSamOutn,minAllSamOut,maxAllSamOut] = premnmx(AllSamIn,AllSamOut);TrainSamIn=AllSamInn;TrainSamOut=AllSamOutn;global Ptrain;Ptrain = TrainSamIn;global Ttrain;Ttrain = TrainSamOut;%% 测试样本归一化global minAllTestOut;global maxAllTestOut;[AllTestInn,minAllTestIn,maxAllTestIn,AllTestOutn,minAllTestOut,maxAllTestOut] = premnmx(AllTestIn,AllTestOut);TestIn=AllTestInn;TestOut=AllTestOutn;global Ptest;Ptest = TestIn;global Ttest;Ttest = TestOut;%% 加载网络的初始变量global indim;indim=64;global hiddennum;hiddennum=65;global outdim;outdim=1;%% 加载PSO模型的相关参数vmax=0.7;minerr=0.0001;wmax=1.2;wmin=0.6;cmax=3;cmin=1;global itmax;itmax=150;c1=2;c2=2;for iter=1:itmaxW(iter)=wmax-((wmax-wmin)/itmax)*iter;end%for iter=1:itmax%c2(iter)=cmax-cmin-((cmax-cmin)/itmax/3)*iter;%end%c1=c2;a=-1;b=1;m=-1;n=1;global N;N=200;global D;D=(indim+1)*hiddennum+(hiddennum+1)*outdim;rand('state',sum(100*clock));X=a+(b-a)*rand(N,D,1);V=m+(n-m)*rand(N,D,1);global fvrec;MinFit=[];BestFit=[];%% PSO优化ELM模型过程1fitness=fitcal(X,indim,hiddennum,outdim,D,Ptrain,Ptest,Ttrain,Ttest,minAllSamOut,maxAllSa mOut);fvrec(:,1,1)=fitness(:,1,1);[C,I]=min(fitness(:,1,1));MinFit=[MinFit C];BestFit=[BestFit C];L(:,1,1)=fitness(:,1,1);B(1,1,1)=C;gbest(1,:,1)=X(I,:,1);for p=1:NG(p,:,1)=gbest(1,:,1);endfor i=1:N;pbest(i,:,1)=X(i,:,1);endV(:,:,2)=W(1)*V(:,:,1)+c1*rand*(pbest(:,:,1)-X(:,:,1))+c2*rand*(G(:,:,1)-X(:,:,1));for ni=1:Nfor di=1:Dif V(ni,di,2) > vmaxV(ni,di,2) = vmax;elseif V(ni,di,2) < -vmaxV(ni,di,2) = -vmax;elseV(ni,di,2) = V(ni,di,2);endendendX(:,:,2)=X(:,:,1)+V(:,:,2);for ni=1:Nfor di=1:Dif X(ni,di,2) > 1X(ni,di,2) = 1;elseif V(ni,di,2) < -1X(ni,di,2) = -1;elseX(ni,di,2) = X(ni,di,2);endendend%% PSO优化ELM模型过程2for j=2:itmaxdisp('Iteration and Current Best Fitness')disp(j-1)disp(B(1,1,j-1))fitness=fitcal(X,indim,hiddennum,outdim,D,Ptrain,Ptest,Ttrain,Ttest,minAllSamOut,maxAllSa mOut);fvrec(:,1,j)=fitness(:,1,j);[C,I]=min(fitness(:,1,j));MinFit=[MinFit C];BestFit=[BestFit min(MinFit)];L(:,1,j)=fitness(:,1,j);B(1,1,j)=C;gbest(1,:,j)=X(I,:,j);[C,I]=min(B(1,1,:));if B(1,1,j)<=Cgbest(1,:,j)=gbest(1,:,j);elsegbest(1,:,j)=gbest(1,:,I);endif C<=minerr, break, endif j>=itmax, break, endfor p=1:NG(p,:,j)=gbest(1,:,j);endfor i=1:N;[C,I]=min(L(i,1,:));if L(i,1,j)<=Cpbest(i,:,j)=X(i,:,j);elsepbest(i,:,j)=X(i,:,I);endendV(:,:,j+1)=W(j)*V(:,:,j)+c1*rand*(pbest(:,:,j)-X(:,:,j))+c2*rand*(G(:,:,j)-X(:,:,j));for ni=1:Nfor di=1:Dif V(ni,di,j+1)>vmaxV(ni,di,j+1)=vmax;elseif V(ni,di,j+1)<-vmaxV(ni,di,j+1)=-vmax;elseV(ni,di,j+1)=V(ni,di,j+1);endendendX(:,:,j+1)=X(:,:,j)+V(:,:,j+1);for ni=1:Nfor di=1:Dif X(ni,di,j+1) > 1X(ni,di,j+1) = 1;elseif V(ni,di,j+1) < -1X(ni,di,j+1) = -1;elseX(ni,di,j+1) = X(ni,di,j+1);endendendenddisp('Iteration and Current Best Fitness')disp(j)disp(B(1,1,j))disp('Global Best Fitness and Occurred Iteration')[C,I] = min(B(1,1,:))for t=1:hiddennumx2iw(t,:)=gbest(1,((t-1)*indim+1):t*indim,j);endfor r=1:outdimx2lw(r,:)=gbest(1,(indim*hiddennum+1):(indim*hiddennum+hiddennum),j);endx2b=gbest(1,((indim+1)*hiddennum+1):D,j);x2b1=x2b(1:hiddennum).';x2b2=x2b(hiddennum+1:hiddennum+outdim).';IWbest1=x2iw;IWbest2=x2lw;IBbest1=x2b1;IBbest2=x2b2;T_sim_test = ELMfun2(IWbest1,IBbest1,Ptrain,Ptest,Ttrain,Ttest,hiddennum,IWbest2,IBbest2); testsamout = postmnmx(T_sim_test,minAllTestOut,maxAllTestOut);realtesterr=mse(testsamout-AllTestOut);err1=norm(testsamout-AllTestOut);disp(['优化模型测试样本的仿真误差:',num2str(err1)])N = length(Ttest);R1 = (N*sum(T_sim_test.*Ttest)-sum(T_sim_test)*sum(Ttest))^2/((N*sum((T_sim_test).^2)-(sum(T_sim_test))^2)*(N*sum((Ttest).^2)-(sum(Ttest))^2));%% 不使用PSO优化ELM算法[IW,B,LW,TF,TYPE] = elmtrain2(Ptrain,Ttrain,65,'sig',0);T_sim_test1 = elmpredict(Ptest,IW,B,LW,TF,TYPE);testsamout2 = postmnmx(T_sim_test1,minAllTestOut,maxAllTestOut);realtesterr2=mse(testsamout2-AllTestOut);err2=norm(testsamout2-AllTestOut);R2 = (N*sum(T_sim_test1.*Ttest)-sum(T_sim_test1)*sum(Ttest))^2/((N*sum((T_sim_test1).^2)-(sum(T_sim_test1))^2)*(N*sum((Ttest).^2)-(sum(Ttest))^2));disp(['原始模型测试样本的仿真误差:',num2str(err2)])RMSE1=sqrt(mse(AllTestOut-testsamout2))%plot(1:150,AllTestOut,'r-*',1:150,testsamout2,'b:o');%% 输出参数图% PSO 优化迭代图%% 输出参数图% PSO 优化迭代图figure(1);P0 = plot(1:itmax,BestFit);grid onxlabel('PSO items');ylabel('MSE rate');%string = {'PSO-ELM模型100次迭代误差变化';['决定系数:R^2=' num2str(R1) ' ' ];['模型仿真均方误差:mse=' num2str(realtesterr) ' ']};%title(string)%bestErr=min(BestFit);%fprintf(['PSO-ELM模型:\n决定系数R^2=',num2str(R1),'\n模型仿真均方误差:mse=',num2str(realtesterr),'\n'])%set(P0,'LineWidth',1.5);% PSO与ELM结果比较图figure(2)plot(1:150,AllTestOut,'r-*',1:150,testsamout,'b:o');legend('真实值','PSO-ELM预测值')RMSE2=sqrt(mse(AllTestOut-testsamout))%,1:151,testsamout2,'y--*')%grid on%legend('真实值','PSO-ELM预测值','单纯ELM预测值')%xlabel('样本编号')%ylabel('样本数据分类号')。

pso粒子群优化算法matlab程序

clear all; clc; format long; %------给定初始化条件--------------------------------------------- c1=1.4962; %学习因子学习因子 1 c2=1.4962; %学习因子学习因子 2 w=0.7298; %惯性权重惯性权重MaxDT=1000; %最大迭代次数最大迭代次数D=10; %搜索空间维数（未知数个数）搜索空间维数（未知数个数）N=40; %初始化群体个体数目初始化群体个体数目eps=10^(-6); %设置精度(在已知最小值时候用) %------初始化种群的个体(可以在这里限定位置和速度的范围)----------- for i=1:N for j=1:D x(i,j)=randn; %随机初始化位置随机初始化位置v(i,j)=randn; %随机初始化速度随机初始化速度end end %------先计算各个粒子的适应度，并初始化先计算各个粒子的适应度，并初始化 Pi 和Pg--------------------- for i=1:N p(i)=ﬁtness(x(i,:),D); y(i,:)=x(i,:); end pg=x(1,:); %Pg 为全局最优为全局最优for i=2:N if ﬁtness(x(i,:),D)<ﬁtness(pg,D) pg=x(i,:); end end %------进入主要循环，按照公式依次迭代，直到满足精度要求----------- for t=1:MaxDT for i=1:N v(i,:)=w*v(i,:)+c1*rand*(y(i,:)-x(i,:))+c2*rand*(pg-x(i,:)); x(i,:)=x(i,:)+v(i,:); if ﬁtness(x(i,:),D)<p(i) p(i)=ﬁtness(x(i,:),D); y(i,:)=x(i,:); end if p(i)<ﬁtness(pg,D) pg=y(i,:); end end Pbest(t)=ﬁtness(pg,D); end %------最后给出计算结果最后给出计算结果disp('*************************************************************') disp('函数的全局最优位置为：') Solu on=pg' disp('最后得到的优化极值为：') Result=ﬁtness(pg,D) disp('*************************************************************') %------算法结束---DreamSun GL & HF---------------------------------- 适应度函数源程序（ﬁtness.m）func on result=ﬁtness(x,D) sum=0; for i=1:D sum=sum+x(i)^2; end result=sum; 。

带交叉因子的粒子群优化算法matlab源程序

带交叉因子的粒子群优化算法matlab源程序程序源代码:其中PSOGA.m文件,也就是主程序如下%格式标准化clear all;clc;format long;%初始化各个因子c1=1.4962; %学习因子c1c2=1.4962; %学习因子c2w=0.7298; %惯性权重wN=20; %粒子群规模D=6; %搜索空间维数(本程序适合3维及以上，不能求解1, 2维)eps=10^(-6); %满足条件限制的误差(在不知道最小值时候不用设置) MaxDT=500; %粒子群繁殖的代数%初始化粒子的速度和位置，数据结构用矩阵A表示for i=1:Nfor j=1:2*DA(i,j)=rand;endendfor i=1:Nfor j=2*D+1:3*DA(i,j)=A(i,j-2*D);endend%计算各个粒子的适应度for i=1:NA(i,3*D+1)=fitness(A(i,1:D),D);end%对粒子的适应度进行排序B=sortrows(A,3*D+1);%排序后适应度低的前面一半粒子直接进入下一代NextGeneration=zeros(N,3*D+1);for i=1:N/2for j=1:3*D+1NextGeneration(i,j)=B(i,j);endend%后一半粒子进行遗传选择和交叉操作for i=1:N/2for j=1:3*D+1Cross(i,j)=B(i+N/2,j);endend%产生一个随机的交叉位置for i=1:N/4Anumber=randperm(D-1);if Anumber(1)~=1position=Anumber(1);elseposition=Anumber(2);end%交叉进行for j=position:D-1temp=Cross(i,j);Cross(i,j)=Cross(N/2-i+1,j);Cross(N/2-i+1,j)=temp;endend%交叉结束，进行更新for i=1:N/2Cross(i,3*D+1)=fitness(Cross(i,1:D),D);if Cross(i,3*D+1)<B(i+N/2,3*D+1)for j=2*D+1:3*DCross(i,j)=Cross(i,j-2*D);endelsefor j=2*D+1:3*DCross(i,j)=B(i,j);endendend%下面选择最好的粒子N/2个进入下一代Pool=zeros(N,3*D+1);for i=1:N/2for j=1:3*D+1Pool(i,j)=B(i+N/2,j);endendfor i=1+N/2:Nfor j=1:3*D+1Pool(i,j)=Cross(i-N/2,j);endend%POOLX表示排序后的粒子选择池PoolX=sortrows(Pool,3*D+1);for i=1+N/2:Nfor j=1:3*D+1NextGeneration(i,j)=PoolX(i-N/2,j);endendPbest=NextGeneration(i,2*D+1:3*D);for i=2:Nif NextGeneration(i,3*D+1)<fitness(Pbest,D)Pbest=NextGeneration(i,2*D+1:3*D);endend%根据粒子群公式进行迭代(Stander PSO Step)%速度更新for i=1:Nfor j=D+1:2*DA(i,j)=w*NextGeneration(i,j)+c1*rand*(NextGeneration(i, j+D)-NextGeneration(i,j-D))+c2*rand*(Pbest(j-D)-NextGeneration(i,j-D));endend%位置更新for i=1:Nfor j=1:DA(i,j)=NextGeneration(i,j)+A(i,j+D);endA(i,3*D+1)=fitness(A(i,1:D),D);if A(i,3*D+1)<NextGeneration(i,3*D+1)for j=2*D+1:3*DA(i,j)=A(i,j-2*D);endelsefor j=2*D+1:3*DA(i,j)=NextGeneration(i,j-2*D);endendend%下面进入主要循环，循环到最大次数得到最优解和最小值%DDTime=1;for time=1:MaxDTB=sortrows(A,3*D+1);NextGeneration=zeros(N,3*D+1);for i=1:N/2for j=1:3*D+1NextGeneration(i,j)=B(i,j);endend%遗传选择交叉for j=1:3*D+1Cross(i,j)=B(i+N/2,j);endendfor i=1:N/4Anumber=randperm(D-1);if Anumber(1)~=1position=Anumber(1);elseposition=Anumber(2);endfor j=position:D-1temp=Cross(i,j);Cross(i,j)=Cross(N/2-i+1,j);Cross(N/2-i+1,j)=temp;endend%交叉结束，进行更新for i=1:N/2Cross(i,3*D+1)=fitness(Cross(i,1:D),D);if Cross(i,3*D+1)<B(i+N/2,3*D+1)for j=2*D+1:3*DCross(i,j)=Cross(i,j-2*D);endelsefor j=2*D+1:3*DCross(i,j)=B(i,j);endendend%下面选择最好的粒子N/2个进入下一代Pool=zeros(N,3*D+1);for j=1:3*D+1Pool(i,j)=B(i+N/2,j);endendfor i=1+N/2:Nfor j=1:3*D+1Pool(i,j)=Cross(i-N/2,j);endendPoolX=sortrows(Pool,3*D+1);for i=1+N/2:Nfor j=1:3*D+1NextGeneration(i,j)=PoolX(i-N/2,j);endendPbest=NextGeneration(i,2*D+1:3*D);for i=2:Nif NextGeneration(i,3*D+1)<fitness(Pbest,D)Pbest=NextGeneration(i,2*D+1:3*D);endend%根据粒子群公式进行迭代for i=1:Nfor j=D+1:2*DA(i,j)=w*NextGeneration(i,j)+c1*rand*(NextGene ration(i,j+D)-NextGeneration(i,j-D))+c2*rand*(Pbest(j-D)-NextGeneration(i,j-D));endendfor i=1:Nfor j=1:DA(i,j)=NextGeneration(i,j)+A(i,j+D);endA(i,3*D+1)=fitness(A(i,1:D),D);if A(i,3*D+1)<NextGeneration(i,3*D+1)for j=2*D+1:3*DA(i,j)=A(i,j-2*D);endelsefor j=2*D+1:3*DA(i,j)=NextGeneration(i,j-2*D);endendendPg(time)=fitness(Pbest,D);%DDTime=DDTime+1;%if fitness(Pbest,D)<eps%break;%endend%算法结束，得到的结果显示如下：disp('****************************************************') disp('最后得到的最优位置为：')X=Pbest'disp('得到的函数最小值为：')Minimize=fitness(Pbest,D)disp('****************************************************')%绘制进化代数和适应度关系曲线图xx=linspace(1,MaxDT,MaxDT);yy=Pg(xx);plot(xx,yy,'b-')hold ongrid ontitle('带交叉因子的粒子群优化算法进化代数与适应度值关系曲线图') legend('粒子适应度曲线走势'）。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

c1=1.4962; %学习因子1
c2=1.4962; %学习因子2
w=0.7298; %惯性权重
MaxDT=1000; %最大迭代次数
D=10; %搜索空间维数（未知数个数）
主函数源程序（main.m）
%------基本粒子群优化算法（Particle Swarm Optimization）-----------
%------名称：基本粒子群优化算法（PSO）
%------作用：求解优化问题
%------说明：全局性，并行性，高效的群体智能算法
v(i,j)=randn; %随机初始化速度
end
end
%------先计算各个粒子的适应度，并初始化Pi和Pg----------------------
for i=1:N
p(i)=fitness(x(i,:),D);
y(i,:)=x(i,:);
for t=1:MaxDT
for i=1:N
v(i,:)=w*v(i,:)+c1*rand*(y(i,:)-x(i,:))+c2*rand*(pg-x(i,:));
x(i,:)=x(i,:)+v(i,:);
if fitness(x(i,:),D)<p(i)
适应度函数源程序（fitness.m）
function result=fitness(x,D)
sum=0;
for i=1:D
sum=sum+x(i)^2;
end
result=sum;
%------初始格式化--------------------------------------------------
clear all;
clc;
format long;
%------给定初始化条件----------------------------------------------
disp('最后得到的优化极值为：')
Result=fitness(பைடு நூலகம்g,D)
disp('*************************************************************')
%------算法结束---DreamSun GL & HF-----------------------------------
p(i)=fitness(x(i,:),D);
y(i,:)=x(i,:);
end
if p(i)<fitness(pg,D)
pg=y(i,:);
end
end
%------作者：孙明杰（dreamsun2001@）
%------单位：中国矿业大学理学院计算数学硕2005
%------时间：2006年8月17日<CopyRight@dReAmsUn>
%------------------------------------------------------------------
Pbest(t)=fitness(pg,D);
end
%------最后给出计算结果
disp('*************************************************************')
disp('函数的全局最优位置为：')
Solution=pg'
end
pg=x(1,:); %Pg为全局最优
for i=2:N
if fitness(x(i,:),D)<fitness(pg,D)
pg=x(i,:);
end
end
%------进入主要循环，按照公式依次迭代，直到满足精度要求------------
这个程序就是最基本的粒子群优化算法程序，用Matlab实现，非常简单。只有几十行代码。正所谓一分钱一分货啊，优化效果不总是令人满意。我还有几个改进的粒子群优化算法版本，这一段时间会陆续发上来。
下面是主函数的源程序，优化函数则以m文件的形式放在fitness.m里面，对不同的优化函数只要修改fitness.m就可以了通用性很强。
N=40; %初始化群体个体数目
eps=10^(-6); %设置精度(在已知最小值时候用)
%------初始化种群的个体(可以在这里限定位置和速度的范围)------------
for i=1:N
for j=1:D
x(i,j)=randn; %随机初始化位置