粒子群算法源程序
混沌粒子群优化算法C源程序
chaos(ps,psbest,d,xmax,xmin);
}
cout<<"收敛结果是"<<psbest<<endl;
}
#define M 20 //粒子的个数
#define D 500 //迭代次数
#define rmax RAND_MAX
typedef struct particle //粒子的结构(包含n维的位置x，速度v,最优位置p,适应度pbest)
{
double x[N];
if((pts[i].x[j]>xmax[j])||(pts[i].x[j]<xmin[j]))
pts[i].x[j]=(xmax[j]-xmin[j])*(double)rand()/(double)RAND_MAX+xmin[j];
}
if(f(pts[i].x)>pts[i].pbest)
for(int i=0;(i<D)&&(psbest<fmin);i++)
{
update(pts,ps,psbest,k,xmax,xmin,vmax,vmin); //更新粒子群
p=1-1/(1+log(k));
if(p>=((double)rand()/(double)RAND_MAX)) //满足混沌搜索的条件
#include<iostream.h>
#include <math.h>
#include<stdlib.h>
python粒子群算法案例
python粒子群算法案例一、引言粒子群优化（ParticleSwarmOptimization，PSO）是一种基于群体智能的优化算法，广泛应用于各种优化问题。
本案例将介绍如何使用Python实现PSO算法，并通过一个具体案例展示其应用效果。
二、算法原理PSO算法是一种模拟鸟群觅食行为的优化算法，通过模拟鸟群觅食过程中的群体行为，寻找最优解。
在PSO算法中，每个优化问题可以被看作是一个搜索空间中的粒子，每个粒子都有一个当前位置和速度，以及一个最优解（即历史最佳位置）。
通过不断迭代，粒子们会逐渐找到最优解。
三、Python实现以下是一个简单的Python实现PSO算法的代码示例：```pythonimportnumpyasnpclassParticle:def__init__(self,dim,minx,maxx):self.position=np.random.uniform(low=minx,high=maxx,size=dim)self.velocity=np.random.uniform(low=-0.1,high=0.1,size=dim)self.best_position=np.copy(self.position)self.best_score=-1#初始最佳位置没有分数classPSO:def__init__(self,dim,n_particles,minx,maxx,inertia,c1,c2):self.particles=[Particle(dim,minx,maxx)for_inrange(n_particles)]self.global_best_position=np.random.uniform(low=minx,high=maxx,size =dim)self.global_best_score=-1#初始全局最佳位置没有分数self.inertia=inertiaself.c1=c1self.c2=c2defupdate_velocity(self,score):forparticleinself.particles:particle.velocity=self.inertia*particle.velocity+self.c1*np.random. rand(particle.position.size)*(score-particle.best_score)+self.c2*np.random.rand(particle.position.size)*(np. random.rand(particle.position.size)-0.5)returnself.particlesdefupdate_position(self):forparticleinself.particles:particle.position=particle.position+self.update_velocity(particle) ```四、案例应用假设我们有一个函数f(x)=x^2，需要找到最小值点。
粒子群算法源程序
粒子群算法源程序二维粒子群matlab源程序%function [pso F] = pso_2D()% FUNCTION PSO --------USE Particle Swarm OptimizationAlgorithm% global present;% close all;clc;clear all;pop_size = 10; % pop_size 种群大小 ///粒子数量 part_size = 2; % part_size 粒子大小 ///粒子的维数 gbest = zeros(1,part_size+1); % gbest 当前搜索到的最小的值 max_gen = 200; % max_gen 最大迭代次数%best=zeros(part_size,pop_size*part_size);%xuanregion=zeros(part_size,2); % 设定搜索空间范围->解空间 region=10*[-3,3;-3,3;-3,3;-3,3;-3,3;-3,3;-3,3;-3,3;-3,3;-3,3]; %每一维设定不同范围(称之为解空间，不是可行域空间)rand('state',sum(100*clock)); % 重置随机数发生器状态 %当前种群的信息矩阵，逐代进化的群体 % 当前位置,随机初始化 % 一个10*3的随机的矩阵(初始化所有粒子的所有维数的位置值)，其中最后一列为arr_present = ini_pos(pop_size,part_size);% 初始化当前速度% 一个10*2的随机的矩阵(初始化所有粒子的所有维数的速度值)v=ini_v(pop_size,part_size);%不是当前种群，可看作是一个外部的记忆体，存储每个粒子历史最优值(2维数值):根据适应度更新～%注意:pbest数组10*3 最后一列保存的是适应度pbest = zeros(pop_size,part_size+1); % pbest:粒子以前搜索到的最优值，最后一列包括这些值的适应度% 1*80 保存每代的最优值best_record = zeros(part_size+1,max_gen); % best_record数组:记录每一代的最好的粒子的适应度w_max = 0.9; % w_max权系数最大值w_min = 0.2; % w_min权系数最小值v_max = 2; % 最大速度,为粒子的范围宽度c1 = 2; % 学习因子1c2 = 2; % 学习因子2% ————————————————————————% 计算原始种群的适应度,及初始化% ————————————————————————% 注意:传入的第一个参数是当前的粒子群体，ini_fit函数计算每个粒子的适应度% arr_present(:,end)是最后一列，保存每个粒子的适应值，是这样的～xuan arr_present(:,end)= ini_fit( arr_present, pop_size, part_size );% 数组赋值，初始化每个粒子个体的历史最优值，以后会更新的 pbest = arr_present; % 初始化各个粒子最优值% 找到当前群体中适应度最小的(在最后一列中寻找)，best_value % 改为max，表示关联度最大[best_value best_index] = max(arr_present(:,end)); %初始化全局最优，即适应度为全局最小的值，根据需要也可以选取为最大值% 唯一的全局最优值，是当前代所有粒子中最好的一个 gbest =arr_present(best_index,:);% 因为是多目标，因此这个-----------------% 只是示意性的画出3维的%x=[-3:0.01:3];%y=[-3:0.01:3];%[X,Y]=meshgrid(x,y);%Z1=(-10)*exp((-0.2)*sqrt(X^2+Y^2));%Z2=(abs(X))^0.8+abs(Y)^0.8+5*sin(X^3)+5*sin(Y^3);%z1=@(x,y)(-10)*exp((-0.2)*sqrt(x^2+y^2));%z2=@(x,y)(abs(x))^0.8+abs(y)^0.8+5*sin(x^3)+5*sin(y^3);%ezmeshc(z1);grid on;%ezmeshc(z2);grid on;%开始进化，直到最大代数截至for i=1:max_gen%grid on;%三维图象 %多维图象是画不出来的%ezmesh(z),hold on,grid on;%画出粒子群%plot3(arr_present(:,1),arr_present(:,2),arr_present(:,3),'*'),h old off;%drawnow%flush%pause(0.01);w = w_max-(w_max-w_min)*i/max_gen; % 线形递减权重% 当前进化代数:对于每个粒子进行更新和评价----->>>>>>>for j=1:pop_sizev(j,:) =w.*v(j,:)+c1.*rand.*(pbest(j,1:part_size)-arr_present(j,1:part_size ))...+c2.*rand.*(gbest(1:part_size)-arr_present(j,1:part_size)); % 粒子速度更新 (a)% 判断v的大小，限制v的绝对值小于20———————————————————for k=1:part_sizeif abs(v(j,k))>20rand('state',sum(100*clock));v(j,k)=20*rand();endend%前几列是位置信息arr_present(j,1:part_size) =arr_present(j,1:part_size)+v(j,1:part_size);% 粒子位置更新(b) %最后一列是适应度arr_present(j,end) =fitness(part_size,arr_present(j,1:part_size)); % 适应度更新 (保存至最后一列)% 适应度评价与可行域限制if(arr_present(j,end)>pbest(j,end))&(Region_in(arr_present(j,:),regi on)) % 根据条件更新pbest,如果是最小的值为小于号,相反则为大于号pbest(j,:) = arr_present(j,:); % 更新个体的历史极值endend% 以下更新全局的极值[best best_index] = max(arr_present(:,end)); % 如果是最小的值为min,相反则为maxif best>gbest(end) & ( Region_in(arr_present(best_index,:),region) ) % 如果当前最好的结果比以前的好，则更新最优值gbest,如果是最小的值为小于号,相反则为大于号gbest = arr_present(best_index,:); % 全局的极值end%------------混沌---------------------------------xlhd = gbest(1:part_size);if(1)for p=1:25 %次数%1生成cxl=rand(1,part_size);for j=1:part_sizeif cxl(j)==0cxl(j)=0.1;endif cxl(j)==0.25cxl(j)=0.26;endif cxl(j)==0.5cxl(j)=0.51;endif cxl(j)==0.75cxl(j)=0.76;endif cxl(j)==1cxl(j)=0.9;endend%2映射al=-30;bl=30;rxl=al+(bl-al)*cxl;%3搜索bate = 0.1;xlhd=xlhd+bate*rxl;if fitness(part_size,xlhd)>gbest(end) gbest(1:part_size)=xlhd;gbest(end)=fitness(part_size,xlhd);end%4更新for j=1:part_sizecxl(j)=4*cxl(j)*(1-cxl(j));endendend%-------------混沌-------------------------------- %当前代的最优粒子的适应度(取自)保存best_record(:,i) = gbest; % gbest:一个行向量 end pso = gbest; % 最优个体display(gbest);figure;plot(best_record(end,:));% 最优解与代数的进化关系图best=zeros(part_size,max_gen); for i=1:part_size-1 best(i,:)=best_record(i,:);endpareto1= zeros(1,max_gen);pareto2= zeros(1,max_gen);for i=1:max_genpareto1(i)=f1(part_size, best(:,i) );pareto2(i)=f2(part_size, best(:,i) ); endfigure;i=1:max_gen;%plot(i,pareto1(i),'r*',i,pareto2(i),'g*');plot(pareto1(i),pareto2(i),'r+'); xlabel('f1');ylabel('f2');title('Pareto曲线');%figure;%plot(,f2(best_record),);% movie2avi(F,'pso_2D1.avi','compression','MSVC');%子函数%------------------------------------------------------------------------- %------------------------------------------------------------------------- %返回随机的位置function ini_present=ini_pos(pop_size,part_size)ini_present = 10*3*rand(pop_size,part_size+1); %初始化当前粒子位置,使其随机的分布在工作空间%返回一个随机的矩阵，10*(2+1)，最后一列将用来保存适应度%返回随机的速度function ini_velocity=ini_v(pop_size,part_size)ini_velocity =20*(rand(pop_size,part_size)); %初始化当前粒子速度,使其随机的分布在速度范围内%判断是否处于范围内function flag = Region_in(pos_present,region)[m n]=size(pos_present); % 1*11 n返回解的维数10 flag=1;for j=1:n-1flag = flag & ( pos_present(1,j)>=region(j,1) ) &( pos_present(1,j)<=region(j,2) );end%初始化适应度function arr_fitness = ini_fit(pos_present,pop_size,part_size) for k=1:pop_sizearr_fitness(k,1) =fitness(part_size,pos_present(k,1:part_size)); %计算原始种群的适应度end%***************************************************************************% 计算适应度%***************************************************************************function fit = fitness(n,xp)%需要求极值的函数,本例即peaks函数%y0=[-85.4974,-29.9217]; % 注意:这是基准序列，也就是单个最优的极值y0=[-9.9907,-7.7507];%y0=[-39.6162,-18.4561];% y0=[-86.8312,-29.9217];y1=[f1(n,xp),f2(n,xp)]; % n为粒子维数fit=graydegree(2,y0,y1); % 关联度在某种意义上就是适应度%目标函数1function r=f1(n,x)r=0;for i=1:n-1r=r+(-10)*exp((-0.2)*sqrt(x(i)^2+x(i+1)^2)); end%目标函数2function r=f2(n,x)r=0;for i=1:nr=r+(abs(x(i)))^0.8+5*sin(x(i)^3);end%约束函数1function r=g1(n,x)r=0;for i=1:nr=0;end%约束函数2function r=g2(n,x)r=0;for i=1:nr=0;end% 灰色关联度计算函数 ( 越大相似性越好 )% tn目标函数个数 x0基准序列(一组值) x1贷检(一组值) function gama = graydegree( tn,y0,y1 )gama=0;rou =0.5;kesa= zeros(tn,1);m1= abs(y0(1)-y1(1)) ; m2= abs(y0(1)-y1(1)) ; for i=1:tnif( abs(y0(i)-y1(i))>m2 ) %------------------应该取大于呢还是小于m2= abs(y0(i)-y1(i));endendfor i=1:tnkesa(i) = ( m1+rou*m2)/( abs(y0(i)-y1(i)) +rou*m2 );gama = gama + kesa(i); endgama = gama/tn;% 可行解的判决函数 gn为约束条件的个数(暂时未用) n为解(粒子)的维数function bool = feasible( x,n ) r=0;%for i=1:gnr=max( 0, g1(n,x), g2(n,x) );%判断约束条件%endif(r>0)bool=0; %不可行解elsebool=1; %可行解endPSO粒子群算法解决旅行商问题的MATLAB源码PSO粒子群算法解决旅行商问题的MATLAB源码 %粒子群算法求解旅行商问题% By lReijclose all;clear all;PopSize=500;%种群大小CityNum = 14;%城市数OldBestFitness=0;%旧的最优适应度值Iteration=0;%迭代次数MaxIteration =2000;%最大迭代次数IsStop=0;%程序停止标志Num=0;%取得相同适应度值的迭代次数c1=0.5;%认知系数c2=0.7;%社会学习系数w=0.96-Iteration/MaxIteration;%惯性系数,随迭代次数增加而递减%节点坐标node=[16.47 96.10; 16.47 94.44; 20.09 92.54; 22.39 93.37; 25.2397.24;...22.00 96.05; 20.47 97.02; 17.20 96.29; 16.30 97.38; 14.05 98.12;...16.53 97.38; 21.52 95.59; 19.41 97.13; 20.09 94.55];%初始化各粒子，即产生路径种群Group=ones(CityNum,PopSize);for i=1:PopSizeGroup(:,i)=randperm(CityNum)';endGroup=Arrange(Group);%初始化粒子速度(即交换序)Velocity =zeros(CityNum,PopSize); for i=1:PopSizeVelocity(:,i)=round(rand(1,CityNum)'*CityNum); %round取整end%计算每个城市之间的距离CityBetweenDistance=zeros(CityNum,CityNum); for i=1:CityNumfor j=1:CityNumCityBetweenDistance(i,j)=sqrt((node(i,1)-node(j,1))^2+(node(i,2)-node(j,2))^2);endend%计算每条路径的距离for i=1:PopSizeEachPathDis(i) = PathDistance(Group(:,i)',CityBetweenDistance);endIndivdualBest=Group;%记录各粒子的个体极值点位置,即个体找到的最短路径IndivdualBestFitness=EachPathDis;%记录最佳适应度值,即个体找到的最短路径的长度 [GlobalBestFitness,index]=min(EachPathDis);%找出全局最优值和相应序号%初始随机解figure;subplot(2,2,1);PathPlot(node,CityNum,index,IndivdualBest); title('随机解');%寻优while(IsStop == 0) & (Iteration < MaxIteration)%迭代次数递增Iteration = Iteration +1;%更新全局极值点位置,这里指路径for i=1:PopSizeGlobalBest(:,i) = Group(:,index);end%求pij-xij ,pgj-xij交换序，并以概率c1，c2的保留交换序pij_xij=GenerateChangeNums(Group,IndivdualBest);pij_xij=HoldByOdds(pij_xij,c1);pgj_xij=GenerateChangeNums(Group,GlobalBest);pgj_xij=HoldByOdds(pgj_xij,c2);%以概率w保留上一代交换序Velocity=HoldByOdds(Velocity,w);Group = PathExchange(Group,Velocity); %根据交换序进行路径交换Group = PathExchange(Group,pij_xij);Group = PathExchange(Group,pgj_xij);for i = 1:PopSize % 更新各路径总距离EachPathDis(i) = PathDistance(Group(:,i)',CityBetweenDistance);endIsChange = EachPathDis<IndivdualBestFitness;%更新后的距离优于更新前的，记录序号IndivdualBest(:, find(IsChange)) = Group(:, find(IsChange));%更新个体最佳路径IndivdualBestFitness = IndivdualBestFitness.*( ~IsChange) + EachPathDis.*IsChange;%更新个体最佳路径距离[GlobalBestFitness, index] = min(EachPathDis);%更新全局最佳路径,记录相应的序号if GlobalBestFitness==OldBestFitness %比较更新前和更新后的适应度值;Num=Num+1; %相等时记录加一;elseOldBestFitness=GlobalBestFitness;%不相等时更新适应度值，并记录清零;Num=0;endif Num >= 20 %多次迭代的适应度值相近时程序停止IsStop=1;endBestFitness(Iteration) =GlobalBestFitness;%每一代的最优适应度end%最优解subplot(2,2,2);PathPlot(node,CityNum,index,IndivdualBest);title('优化解');%进化曲线subplot(2,2,3);plot((1:Iteration),BestFitness(1:Iteration));grid on;title('进化曲线');%最小路径值GlobalBestFitnessfunction Group=Arrange(Group)[x y]=size(Group);[NO1,index]=min(Group',[],2); %找到最小值1for i=1:ypop=Group(:,i);temp1=pop([1: index(i)-1]);temp2=pop([index(i): x]);Group(:,i)=[temp2' temp1']';endfunction ChangeNums=GenerateChangeNums(Group,BestVar);[x y]=size(Group);ChangeNums=zeros(x,y);for i=1:ypop=BestVar(:,i);%从BestVar取出一个顺序pop1=Group(:,i);%从粒子群中取出对应的顺序for j=1:x %从BestVar的顺序中取出一个序号NoFromBestVar=pop(j);for k=1:x %从对应的粒子顺序中取出一个序号NoFromGroup=pop1(k);if (NoFromBestVar==NoFromGroup) && (j~=k) %两序号同且不在同一位置ChangeNums(j,i)=k; %交换子pop1(k)=pop1(j);pop1(j)=NoFromGroup;endendendendfunction Hold=HoldByOdds(Hold,Odds) [x,y]=size(Hold);for i=1:xfor j=1:yif rand>OddsHold(i,j)=0;endendendfunction SumDistance=PathDistance(path,CityBetweenDistance)L=length(path); %path为一个循环的节点顺序SumDistance=0;for i=1:L-1SumDistance=SumDistance+CityBetweenDistance(path(i),path(i+1));endSumDistance=SumDistance+CityBetweenDistance(path(1),path(L)); %加上首尾节点的距离function Group=PathExchange(Group,Index)[x y]=size(Group);for i=1:ya=Index(:,i); %取出其中一组交换序pop=Group(:,i); %取出对应的粒子for j=1:x %取出其中一个交换算子作交换if a(j)~=0pop1=pop(j);pop(j)=pop(a(j));pop(a(j))=pop1;endendGroup(:,i)=pop;endfunction PathPlot(node,CityNum,index,EachBest);for i=1:CityNumNowBest(i,:)=node((EachBest(i,index)),:);endNowBest(CityNum+1,:)=NowBest(1,:); plot(node(:,1),node(:,2),'*'); line(NowBest(:,1),NowBest(:,2)); grid on;。
Python代码实现粒子群算法图文详解
Python代码实现粒⼦群算法图⽂详解⽬录1.引⾔2.算法的具体描述：2.1原理2.2标准粒⼦群算法流程3.代码案例3.1问题3.2绘图3.3计算适应度3.4更新速度3.5更新粒⼦位置3.6主要算法过程结果总结1.引⾔粒⼦群优化算法起源于对鸟群觅⾷活动的分析。
鸟群在觅⾷的时候通常会毫⽆征兆的聚拢，分散，以及改变飞⾏的轨迹，但是在不同个体之间会⼗分默契的保持距离。
所以粒⼦群优化算法模拟鸟类觅⾷的过程，将待求解问题的搜索空间看作是鸟类飞⾏的空间，将每只鸟抽象成⼀个没有质量和⼤⼩的粒⼦，⽤这个粒⼦来表⽰待求解问题的⼀个可⾏解。
所以，寻找最优解的过程就相当于鸟类觅⾷的过程。
粒⼦群算法也是基于种群以及进化的概念，通过个体间的竞争与协作，实现复杂空间最优解的求解。
但是与遗传算法不同的是，他不会对每个个体进⾏“交叉”，“变异”等操作，⽽实以⼀定的规则，更新每个粒⼦的速度以及位置，使得每⼀个粒⼦向⾃⾝历史最佳位置以及全局历史最佳位置进⾏移动，从⽽实现整个种群向着最优的⽅向进化。
2.算法的具体描述：2.1原理在粒⼦群优化算法中，粒⼦之间通过信息共享机制，获得其它粒⼦的发现与飞⾏经历。
粒⼦群算法中的信息共享机制实际上是⼀种合作共⽣的⾏为，在搜索最优解的过程中，每个粒⼦能够对⾃⼰经过的最佳的历史位置进⾏记忆，同时，每个粒⼦的⾏为有会受到群体中其他例⼦的影响，所以在搜索最优解的过程中，粒⼦的⾏为既受其他粒⼦的影响，有受到⾃⾝经验的指导。
粒⼦群优化算法对于鸟群的模拟是按照如下的模式进⾏的：假设⼀群鸟在空中搜索⾷物，所有鸟知道⾃⼰当前距离⾷物有多远（这⾥的远近会⽤⼀个值来衡量，适应度值），那么每只鸟最简单的搜索策略就是寻找距离⽬前距离⾷物最近的鸟的周围空间。
因此，在粒⼦群算法中，每个粒⼦都相当于⼀只鸟，每个粒⼦有⼀个适应度值，还有⼀个速度决定他们的飞⾏的距离与⽅向。
所有的粒⼦追随当前最优的粒⼦在解空间中搜索。
每搜索⼀次，最优的粒⼦会发⽣变化，其他的粒⼦⼜会追随新的最优粒⼦进⾏搜索，如此反复迭代。
粒子群算法 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 %循环结束。
基于粒子群优化 算法的计算卸载源代码
基于粒子群优化算法的计算卸载源代码计算卸载是一种将计算任务从本地设备转移到云端或其他远程计算资源的技术。
通过将计算任务卸载到云端，可以利用云端的强大计算能力和资源来完成计算任务，从而减轻本地设备的计算负担，提高计算效率和性能。
粒子群优化（Particle Swarm Optimization, PSO）算法是一种启发式全局优化算法，它模拟了鸟群或鱼群的社会行为。
在 PSO 算法中，每个粒子代表一个潜在的解，粒子在搜索空间中飞行，并根据自身的经验和群体的经验来调整自己的位置和速度，以寻找最优解。
以下是一个基于 PSO 算法的计算卸载源代码示例，这个示例是一个简单的 PSO 算法实现，用于寻找函数的最优解：```pythonimport random# 目标函数def objective_function(x):return x[0]**2 + x[1]**2# PSO 算法实现def pso(objective_func, lb, ub, dim, n_particles, max_iter):# 初始化粒子的位置和速度particles_pos = [random.uniform(lb, ub) for _ in range(n_particles)]particles_vel = [random.uniform(-0.1, 0.1) for _ in range(n_particles * dim)] # 初始化每个粒子的最佳位置和全局最佳位置personal_best_pos = [particle_pos[i] for i in range(n_particles)]personal_best_val = [objective_func(personal_best_pos[i]) for i in range(n_particles)]global_best_val = min(personal_best_val)global_best_pos = personal_best_pos[personal_best_val.index(global_best_val)]# 惯性权重w = 0.5# 个体经验的学习因子c1 = 2# 社会经验的学习因子c2 = 2for i in range(max_iter):for j in range(n_particles):# 更新速度inertia = w * particles_vel[j]cognitive = c1 * random.random() * (personal_best_pos[j] - particles_pos[j]) social = c2 * random.random() * (global_best_pos - particles_pos[j])particles_vel[j] = inertia + cognitive + social# 更新位置particles_pos[j] += particles_vel[j]# 更新个人最佳位置和全局最佳位置personal_best_val[j] = objective_func(personal_best_pos[j])if personal_best_val[j] < global_best_val:global_best_val = personal_best_val[j]global_best_pos = personal_best_pos[j]return global_best_pos# 示例用法lb = [-10, -10]ub = [10, 10]dim = 2n_particles = 10max_iter = 100best_pos = pso(objective_function, lb, ub, dim, n_particles, max_iter)print("最佳位置:", best_pos)print("最佳解:", objective_function(best_pos))```在这个示例中，我们定义了一个目标函数`objective_function`，它是一个简单的二次函数，代表了计算任务的负载。
6种粒子群算法程序
6种粒子群算法程序程序1当c\\ = c i\ = 2 , c n = c22 = 1.5 , w = 1.2 oa)*主函数源程序(main.m)%------ 基本粒子群算法(particle swarm optimization)%------ 名称：基本粒子群算法%------ 初始格式化clear all; %清除所有变量C1C；%清屏format long; %将数据显示为长整形科学计数%……给定初始条条件............N=40; D=10; T=100; cl1=2;%3初始化群体个数%初始化群体维数%初始化群体最迭代次数%学习因子1c21=2;cl2=1.5;c22=1.5;w=L2; eps=10A(-6);%学习因子2%惯性权重%设置精度（在已知最小值的时候用）%……初始化种群个体（限定位置和速度）x=zeros(N,D);v=zeros(N,D); for i=l:Nfor j=l:Dx(lj)=randn; %随机初始化位置v(ij)=randn; %随机初始化速度end end%……显示群位置............... flgure(l)for j=l:Dif(rem(D,2)>0)subplot((D+l)/2,2J)elsesubplot(D/2,2,j)endplot(x(:,j)；b*');grid on xlabelC 粒子■) ylabel(*初始位置J tlnfo=strcat(f第*har(j+48)J 维J;tlnfo=strcat(,M \cha r(floor(j/l 0)+48), char(rem(j,l 0)+48),'维')；endtitle(tlnfo)end%-一-显示种群速度figure ⑵for j=l:Dif(rem(D^2)>0) subplot((D+l)/2,2J)elsesubplot(D/2,2J)endplot(x(:,j)；b*');gricl on xlabelC 粒子') ylabel(,初始速度J tlnfo=strcatf 第,char(j+48),'维')；if(j>9)tlnfo=strcat(* 第“har(floor(j/l())+48)9 char(rem(j,l 0)+48),'维)；endtitle(tlnfo)endfigure ⑶%第一个图su bp lot( 1,2,1)%……初始化种群个体(在此限定速度和位置) .........xl=x;vl=v;%……初始化个体最优位置和最优值…pl=xl;pbestl=ones(NJ);for i=l:Npbestl (i)=fitness(x 1 (i,: ),D);end%……初始化全局最优位置和最优值 .........gl=l000*ones(l ,D);gbestl=1000;for i=l:Nlf(pbestl(i)<gbest 1)gl=pl(i,:);gbestl=pbestl(i);endendgbl=ones(l,T);%浸入主循环，按照公式依次迭代直到满足精度或者迭代次数…for i=l:Tfor J=1:NIf (fltness(xl(J,:),D)<pbestl(J))pl(J,:)=xl(|,:);pbestl (J)=fitness(x 1Q，: ),D);endlf(pbest 1 (])<gbest 1)gl=pl(j,:); gbestl=pbestl(J);endvl(j,:)=w*vl(J,:)+cll*rand*(pl(J,:)-xl(j,:))+c21*rand*(gl-xl(J,:));xl(J,:)=xl(J,:)+vl(j,:);endgbl(i)=gbestl;endplot(gbl)T empSt r=sprl ntf(• c 1 = %g ,c2=%g\cll,c21);title(TempStr);xiabelC迭代次数)；ylabelC适应度值J;%第二个图subplot(l，2,2)%••…初始化种群个体(在此限定速度和位置) .........x2=x;v2=v;%••…初始化种群个体最有位置和最优解 .......p2=x2;pbest2=ones(N,l);for i=l:Npbest2(i)=fltness(x2(i,: ),D);end%••…初始化种全局最有位置和最优解……g2=1000*ones(l ,D);gbest2=1000;for i=X:Nif(pbest2(i)<gbest2)g2=p2(i,:);gbest2=pbest2(i);endendgb2=ones(l,T);%……浸入主循环，按照公式依次迭代直到满足精度或者迭代次数…for i=l:Tfor j=l:Nif (fitness(x2(J,:),D)<pbest2 ⑴)p2(J,:)=x2(j,:); pbest2(j)=fitness(x2(J,:),D);endif(pbest2(J)<gbest2)g2=p2(j,:);gbest2=pbest2(J);endV2(jv)=w*v2(j,:)+cl2*rand*(p2(j,:)-x2(j,:))+c22*rand*(g2-x2(j,:));x2(J,:)=x2(j,:)+v2(j,：)；endgb2(i)=gbest2;endplot(gb2)TempStr=sprlntf(t cl= %g ,c2=%g\cl2,c22);title(TempStr);xiabclC迭代次数)；ylabelC适应度值J;b)适应度函数%适应度函数(fitness.m)function result=fitness(x,D)sum=0;for i=l:Dsiim=sum+x(i)A2;endresult=sum;程序2当C11 =C2l =2 于C]2 =0,Cj2 = 2,w= 1.2 对比a)%主函数源程序(main.m)% ... 基本粒子群算法(particle swarm optimization)%……名称：基本粒子群算法%……初始格式化clear all; %清除所有变量clc; %清屏format long; %将数据显示为长整形科学计数cl2=0;c22=2;w=1.2; %惯性权重eps=10A(-6); %设置精度(在已知最小值的时候用) %……初始化种群个体(限定位置和速度) .........x=zeros(N,D);v=zeros(N,D);for i=l:Nfor j=l:Dx(lj)=randn; %随机初始化位置v(ij)=randn; %随机初始化速度endend%……显示群位置 ..............figure(l)for j=l:Dif(rem(D,2)>0)subplot((D+1 )/2,2 J)elsesubplot(D/2,2J)endplot(x(:J)/b*t);grid onxlabelC 粒子JylabelC初始位置JtInFo=strcatC 第’,char(j+48)，1维f);if(j>9)tlnfo=strcat(f \char(floor(j/10)+48) t char(rem(j,10)+48),'维')；endtitle(tlnfo)end%……显示种群速度flgure(2)for j=l:Dif(rem(D,2)>0)subplot((D+l)/2^2J)elsesubplot(D/2,2J)endplot(x(:J)/b*t);grid onxlabelC 粒子JylabelC初始速度Jtlnfo=strcat(v第,char(j+48)，'维')；if(j>9)tlnfo=strcat(,M t?char(floor(J/10)+48), char(rem(JJ0)+48)/ 维)；encltitle(tlnfo)endfigure(3)%第一个图subplot(1^24)%……初始化种群个体(在此限定速度和位置)xl=x;vl=v;%……初始化个体最优位置和最优值…pl=xl;pbestl=ones(N,l);for i=l:Npbestl (i)=fitness(xl(i,:),D);end%……初始化全局最优位置和最优值 .........gl=l000*ones(l Q);gbestl=1000;for i=l:Nif(pbestl(i)<gbestl)gl=pl(i,:); gbestl=pbestl(i); endendgbl=ones(l,T);%••…浸入主循环，按照公式依次迭代直到满足精度或者迭代次数…for i=l:Tfor J=1:Nif (fitness(xl(J^:),D)<pbestl(J))pl(j,:)=xl(j,:);pbest 1 (J)=fitness(x 1 (J),D);endlf(pbestl (J )<gbest 1)gi=pia,：)；gbestl=pbestl(j);endvl(J,:)=w*vl(J5:)+cll*ran(l*(pl(J,:)-xl(j,:))+c21*rand*(gl-xl(j,:));xl(j,:)=xl(J,:)+vl(j,:);endgbl(i)=gbestl;endplot(gbl)TempStr=sprlntf(,cl= %g 5c2=%g\cll,c21);title(TempStr);xlabef迭代次数)；ylabelC适应度值J;%第二个图subplot( 1,2,2)%••…初始化种群个体(在此限定速度和位置) .........x2=x;v2=v;%-•…初始化种群个体最有位置和最优解 .......p2=x2;pbest2=ones(N,l);for i=l:Npbest2 ⑴=fltness(x2(i,:),D);end%-•…初始化种全局最有位置和最优解……g2=1000*ones(l Q);gbest2=1000;for i=l:Nif(pbest2(i)<gbest2)g2=p2(i,:); gbest2=pbest2(i);endendgb2=ones(l,T);%……浸入主循环，按照公式依次迭代宜到满足精度或者迭代次数…for i=l:Tfor j=l: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);endv2Q,:)=w*v2(J,:)+cl2*rand*(p2(j,:)-x2(j,:))+c22*rand*(g2-x2(J,:));x2(J,:)=x2(j,:)+v2(j,：)；endgb2(i)=gbest2;endplot(gb2)TempStr=sprlntf(,cl= %g ,c2=%f ,cl2,c22);title(TempStr);xlabef迭代次数)；ylabelC适应度值J;b)适应度函数%适应度函数(fitness.ni)function result=fitness(x,D)sum=0;for i=l:Dsiim=sum+x(i)A2;end result=sum;程序3当 5 =c 2\ =2,闪=1.2于“2 = 2,C 22 =0,w = 1.2 对比a) %主函数源程序(main.m)% ... 基本粒子群算法(particle swarm optimization )%……名称：基本粒子群算法%……初始格式化clear all;clc;format long; %……给定初始条条件 ........... N=40;D=10;T=100; cl1=2;c21=2;cl2=2;%，初始化群体个数 %初始化群体维数 %初始化群体最迭代次数 %学习因子1 %学习因子2c22=0;w=L2; eps=10A (-6);%惯性权重 %设置精度(在已知最小值的时候用) %……初始化种群个体(限定位置和速度)x=zeros(N,D); v=zeros(N,D);for i=l:Nfor j=l:Dx(ij)=randn; %随机初始化位置 v(ij)=randn; %随机初始化速度 end end%……显示群位置 ..............flgure(l)for J=1:Dif(rem(D,2)>0)subplot((D+l)/2^2J)elsesubplot(D/2,2J)%清除所有变量 %清屏 %将数据显示为长整形科学计数plot(x(:J)/b*,);grid onxlabelC 粒子JylabelC初始位置Jtlnfo=strcat(f第；char(j+48),维J; if(j>9)tlnfo=strcat(,第；char(floor(j/10)+48), char(rem(ja0)+48)；维J;encltitle(tlnfo)end%……显示种群速度flgure(2)for j=l:Dif(rem(D^2)>0)su bplot((D+1 )/2,2 J)elsesubplot(D/2,2J)endplot(x(: J;grid onxlabelC 粒子JylabelC初始速度') tInfo=strcatC 第,charQ+48),1维J; if(j>9)tlnfo=strcat(,第；chai*(floor(j/10)+48)， char(rem(J40)+48)/ 维)；end title(tlnfo)endflgure(3)%第一个图subplot(l929l)%……初始化种群个体(在此限定速度和位置) .........xl=x;vl=v;%……初始化个体最优位置和最优值…pl=xl;pbestl=ones(NJ);for i=l:Nend%……初始化全局最优位置和最优值 .........gl=l000*ones(l ,D);gbestl=1000;for i=l:Nlf(pbestl(i)<gbest 1)gl=pl(i,:);gbestl=pbestl(i);endendgbl=ones(l,T);%浸入主循环，按照公式依次迭代直到满足精度或者迭代次数…for i=l:Tfor J=1:NIf (fltness(xl(J,:),D)<pbestl(J))pl(J,:)=xl(|,:);pbestl (J)=fitness(x 1Q，: ),D);endlf(pbest 1 (])<gbest 1)gl=pl(j,:); gbestl=pbestl(J);endvl(j,:)=w*vl(J,:)+cll*rand*(pl(J,:)-xl(j,:))+c21*rand*(gl-xl(J,:));xl(J,:)=xl(J,:)+vl(j,:);endgbl(i)=gbestl;endplot(gbl)T empSt r=sprl ntf(• c 1 = %g ,c2=%g\cll,c21);title(TempStr);xiabelC迭代次数)；ylabelC适应度值J;%第二个图subplot(l，2,2)%••…初始化种群个体(在此限定速度和位置) .........x2=x;v2=v;%••…初始化种群个体最有位置和最优解 .......p2=x2;pbest2=ones(N,l);for i=l:Npbest2(i)=fltness(x2(i,: ),D);end%••…初始化种全局最有位置和最优解……g2=1000*ones(l ,D);gbest2=1000;for i=X:Nif(pbest2(i)<gbest2)g2=p2(i,:);gbest2=pbest2(i);endendgb2=ones(l,T);%……浸入主循环，按照公式依次迭代直到满足精度或者迭代次数…for i=l:Tfor j=l:Nif (fitness(x2(J,:),D)<pbest2 ⑴)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,:)+cl2*rand*(p2(J,:)-x2(J,:))+c22*rand*(g2-x2(j,:));x2(J,:)=x2(j,:)+v2(j,：)；endgb2(i)=gbest2;endplot(gb2)TempStr=sprlntf(f cl= %g ,c2=%g\cl2,c22);title(TempStr);xiabclC迭代次数)；ylabelC适应度值J;b)适应度函数%适应度函数(fitness.m)function result=fitness(x,D)sum=0;for i=l:Dsiim=sum+x(i)A2;endresult=sum;程序4对c2, W2分别对其取值Cj =1.1, c2 =2, w, =1.2, w2 =1.5测试函数。
基本粒子群算法
简单的基本粒子群算法#include <stdio.h>#include <stdlib.h>#include <time.h>#include <math.h>#define randf (double)(rand()%10000)/10000 using namespace std;const int dim = 30; // 粒子维数const int num = 100; // 粒子群中粒子的个数. const int c1 = 2; // 学习因子1const int c2 = 2; // 学习因子2const int w = 0.9; // 惯性权重因子double Xmax = 500;double Xmin = -500;double Vmax = 50;double Vmin = -50;double gbest_f; // 全局最优适应值.double gbest[dim]; // 全局最优位置.struct particle // 粒子结构.{double f;double pbest_f;double pbest[dim];double X[dim];double V[dim];} swarm[num]; // 粒子群定义.double fitness(); // 计算粒子适应度.void check(); // 检查粒子的速度和范围是否越界. void initial(); // 粒子群的随机初始化void fly(); // 粒子飞翔.double fitness ( double X[] ){double sum = 0;for ( int i = 0 ; i < dim ; i ++ ){double t = X[i];if ( t < 0 )t *= -1;sum += -1*X[i]*sin(sqrt(t));}return sum;}void check(int index){for ( int i = 0 ; i < dim ; i ++ ){if ( swarm[index].X[i] > Xmax )swarm[index].X[i] = Xmax;if ( swarm[index].X[i] < Xmin )swarm[index].X[i] = Xmin;if ( swarm[index].V[i] > Vmax )swarm[index].V[i] = Vmax;if ( swarm[index].V[i] < Vmin )swarm[index].V[i] = Vmin;}}void initial(){double interval0 = Xmax-Xmin;double interval1 = Vmax-Vmin;for ( int i = 0 ; i < num ; i ++ ){particle * p = &swarm[i];for ( int j = 0 ; j < dim ; j ++ ){p->X[j] = interval0 * randf + Xmin;p->V[j] = interval1 * randf + Vmin;}check(i);p->f = fitness(p->X);p->pbest_f = p->f;for ( int j = 0 ; j < dim ; j ++ )p->pbest[j] = p->X[j];}gbest_f = swarm[0].pbest_f;for ( int j = 0 ; j < dim ; j ++ )gbest[j] = swarm[0].X[j];}void fly (){int i,j;for ( i = 0 ; i < num ; i ++ ){particle * p = &swarm[i];for ( j = 0 ; j < dim ; j ++ ){p->V[j] = w*p->V[j] + c1*randf*( p->pbest[j]- p->X[j]) + c2*randf*(gbest[j]-p->X[j]);p->X[j] = p->V[j] + p->X[j];}check(i);p->f = fitness(p->X);if ( p->f < p->pbest_f ){p->pbest_f = p->f;for ( j = 0 ; j < dim ; j ++ )p->pbest[j] = p->X[j];}if ( p->f < gbest_f ){gbest_f = p->f;for ( j = 0 ; j < dim ; j ++ )gbest[j] = p->X[j];}}}int main() {srand((unsigned)time(NULL));initial();for ( int i = 0 ; i < 50000 ; i ++ )fly();double a = fitness(gbest);printf("%lf",a);return 0;}。
粒子群算法(PSO)源代码
粒子群算法（PSO）源代码%%#################################################################### %%#### Particle swarm optimization%%#### With linkage operator%%#### Deepak devicharan july 2003%%#################################################################### %%## to apply this to different equations do the following%%## generate initial particles in a search space close to actual soln%%## fool around with no of iterations, no of particles, learning rates%%## for a truly generic PSO do the following%%## increase the number of particles , increase the variance%%## i.e let the particles cover a larger area of the search space%%## then fool around as always with the above thins%declare the parameters of the optimizationmax_iterations = 1000;no_of_particles = 50;dimensions = 1;delta_min = -0.003;delta_max = 0.003;c1 = 1.3;c2 = 1.3;%initialise the particles and teir velocity componentsfor count_x = 1:no_of_particlesfor count_y = 1:dimensionsparticle_position(count_x,count_y) = rand*10;particle_velocity(count_x,count_y) = rand;p_best(count_x,count_y) = particle_position(count_x,count_y);endend%initialize the p_best_fitness arrayfor count = 1:no_of_particlesp_best_fitness(count) = -1000;end%particle_position%particle_velocity%main particle swrm routinefor count = 1:max_iterations%find the fitness of each particle%change fitness function as per equation requiresd and dimensionsfor count_x = 1:no_of_particles%x = particle_position(count_x,1);%y = particle_position(count_x,2);%z = particle_position(count_x,3);%soln = x^2 - 3*y*x + z;%x = particle_position(count_x);%soln = x^2-2*x+1;x = particle_position(count_x);soln = x-7;if soln~=0current_fitness(count_x) = 1/abs(soln);elsecurrent_fitness =1000;endend%decide on p_best etc for each particlefor count_x = 1:no_of_particlesif current_fitness(count_x) > p_best_fitness(count_x)p_best_fitness(count_x) = current_fitness(count_x);for count_y = 1:dimensionsp_best(count_x,count_y) = particle_position(count_x,count_y);endendend%decide on the global best among all the particles[g_best_val,g_best_index] = max(current_fitness);%g_best contains the position of teh global bestfor count_y = 1:dimensionsg_best(count_y) = particle_position(g_best_index,count_y);end%update the position and velocity compponentsfor count_x = 1:no_of_particlesfor count_y = 1:dimensionsp_current(count_y) = particle_position(count_x,count_y);endfor count_y = 1:dimensionsparticle_velocity(count_y) = particle_velocity(count_y) + c1*rand*(p_best(count_y)-p_current(count_y)) + c2*rand*(g_best(count_y)-p_current(count_y)); particle_positon(count_x,count_y) = p_current(count_y) +particle_velocity(count_y);endendendg_bestcurrent_fitness(g_best_index)clear all, clc % pso exampleiter = 1000; % number of algorithm iterationsnp = 2; % number of model parametersns = 10; % number of sets of model parametersWmax = 0.9; % maximum inertial weightWmin = 0.4; % minimum inertial weightc1 = 2.0; % parameter in PSO methodologyc2 = 2.0; % parameter in PSO methodologyPmax = [10 10]; % maximum model parameter valuePmin = [-10 -10]; % minimum model parameter valueVmax = [1 1]; % maximum change in model parameterVmin = [-1 -1]; % minimum change in model parametermodelparameters(1:np,1:ns) = 0; % set all model parameter estimates for all model parameter sets to zeromodelparameterchanges(1:np,1:ns) = 0; % set all change in model parameter estimates for all model parameter sets to zerobestmodelparameters(1:np,1:ns) = 0; % set best model parameter estimates for all model parameter sets to zerosetbestcostfunction(1:ns) = 1e6; % set best cost function of each model parameter set to a large numberglobalbestparameters(1:np) = 0; % set best model parameter values for all model parameter sets to zerobestparameters = globalbestparameters'; % best model parameter values for all model parameter sets (to plot)globalbestcostfunction = 1e6; % set best cost function for all model parameter sets to a large numberi = 0; % indicates ith algorithm iterationj = 0; % indicates jth set of model parametersk = 0; % indicates kth model parameterfor k = 1:np % initializationfor j = 1:nsmodelparameters(k,j) = (Pmax(k)-Pmin(k))*rand(1) + Pmin(k); % randomly distribute model parametersmodelparameterchanges(k,j) = (Vmax(k)-Vmin(k))*rand(1) + Vmin(k); % randomly distribute change in model parametersendendfor i = 2:iterfor j = 1:nsx = modelparameters(:,j);% calculate cost functioncostfunction = 105*(x(2)-x(1)^2)^2 + (1-x(1))^2;if costfunction < setbestcostfunction(j) % best cost function for jth set of model parameters bestmodelparameters(:,j) = modelparameters(:,j);setbestcostfunction(j) = costfunction;endif costfunction < globalbestcostfunction % best cost function for all sets of model parameters globalbestparameters = modelparameters(:,j);bestparameters(:,i) = globalbestparameters;globalbestcostfunction(i) = costfunction;elsebestparameters(:,i) = bestparameters(:,i-1);globalbestcostfunction(i) = globalbestcostfunction(i-1);endendW = Wmax - i*(Wmax-Wmin)/iter; % compute inertial weightfor j = 1:ns % update change in model parameters and model parametersfor k = 1:npmodelparameterchanges(k,j) = W*modelparameterchanges(k,j) + c1*rand(1)*(bestmodelparameters(k,j)-modelparameters(k,j))...+ c2*rand(1)*(globalbestparameters(k) - modelparameters(k,j));if modelparameterchanges(k,j) < -Vmax(k), modelparameters(k,j) = modelparameters(k,j) - Vmax(k); endif modelparameterchanges(k,j) > Vmax(k), modelparameters(k,j) = modelparameters(k,j) + Vmax(k); endif modelparameterchanges(k,j) > -Vmax(k) & modelparameterchanges(k,j) < Vmax(k), modelparameters(k,j) = modelparameters(k,j) + modelparameterchanges(k,j); end if modelparameters(k,j) < Pmin(k), modelparameters(k,j) = Pmin(k); endif modelparameters(k,j) > Pmax(k), modelparameters(k,j) = Pmax(k); endendendiendbp = bestparameters; index = linspace(1,iter,iter);figure; semilogy(globalbestcostfunction,'k');set(gca,'FontName','Arial','Fontsize',14); axis tight;xlabel('iteration'); ylabel('cost function');figure; q = plot(index,bp(1,,'k-',index,bp(2,,'k:');set(gca,'FontName','Arial','Fontsize',14); axis tight;legend(q,'x_1','x_2'); xlabel('iteration'); ylabel('parameter')。
粒子群算法的C语言实现
粒子群算法的C语言实现#include"stdio.h"#include"stdlib.h"#include"time.h"#include"math.h"const int NUM=40;//粒子数const int DIM=30;//维数const double c1=1.8;//参数const double c2=1.8;//参数double xmin=-100.0;//位置下限double xmax=100.0;//位置上限double gbestx[DIM];//全局最优位置double gbestf;//全局最优适应度struct particle {//定义一个粒子double x[DIM];//当前位置矢量double bestx[DIM];//历史最优位置double f;//当前适应度double bestf;//历史最优适应度}swarm[NUM];//定义粒子群#define randf ((rand()%10000+rand()%10000*10000)/100000000.0) //产生-1随机浮点数double f1(double x[]) {//测试函数：超球函数float z=0;for(int i=0;i<DIM;i++)z+=(x[i])*(x[i]);return z;}void main() {for(int i=0; i<DIM; i++)//初始化全局最优gbestx[i]=randf*(xmax-xmin)+xmin;gbestf=100000000000000.0;for(int i=0; i<NUM; i++) {//初始化粒子群particle* p1=&swarm[i];for(int j=0; j<DIM; j++)p1->x[j]=randf*(xmax-xmin)+xmin;p1->f=f1(p1->x);p1->bestf=100000000000000.0;}for(int t=0; t<5000; t++) {for(int i=0; i<NUM; i++) {particle* p1=&swarm[i];for(int j=0; j<DIM; j++)//进化方程p1->x[j]+=c1*randf*(p1->bestx[j]-p1->x [j])+c2*randf*(gbestx[j]-p1->x[j]);p1->f=f1(p1->x);if(p1->f<p1->bestf) {//改变历史最优for(int j=0;j<DIM;j++)p1->bestx[j]=p1->x[j];p1->bestf=p1->f;}if(p1->f<gbestf) {//改变全局最优for(int j=0;j<DIM;j++)gbestx[j]=p1->x[j];for(int j=0; j<DIM; j++)//把当前全局最优的粒子随机放到另一位置p1->x[j]=randf*(xmax-xmin)+xmi n;gbestf=p1->f;}}}printf("%g\n", gbestf);。
c语言实现的粒子群算法代码及解释
//粒子群PSO算法#include<stdio.h>#include<math.h>#include<time.h>#include<stdlib.h>#define PI 3.141592653589 /* */#define P_num 200 //粒子数目#define dim 50#define low -100 //搜索域范围#define high 100#define iter_num 1000#define V_max 20 //速度范围#define c1 2#define c2 2#define w 0.5#define alp 1double particle[P_num][dim]; //个体集合double particle_loc_best[P_num][dim]; //每个个体局部最优向量double particle_loc_fit[P_num]; //个体的局部最优适应度,有局部最优向量计算而来double particle_glo_best[dim]; //全局最优向量double gfit; //全局最优适应度,有全局最优向量计算而来double particle_v[P_num][dim]; //记录每个个体的当前代速度向量double particle_fit[P_num]; //记录每个粒子的当前代适应度double Sphere(double a[]){int i;double sum=0.0;for(i=0; i<dim; i++){sum+=a[i]*a[i];}return sum;}double Rosenbrock(double a[]){int i;double sum=0.0;for(i=0;i<dim-1; i++){sum+= 100*(a[i+1]-a[i]*a[i])*(a[i+1]-a[i]*a[i])+(a[i]-1)*(a[i]-1);return sum;}double Rastrigin(double a[]){int i;double sum=0.0;for(i=0;i<dim;i++){sum+=a[i]*a[i]-10.0*cos(2*PI*a[i])+10.0;}return sum;}double fitness(double a[]) //适应度函数{return Rastrigin(a);}void initial(){int i,j;for(i=0; i<P_num; i++) //随即生成粒子{for(j=0; j<dim; j++){particle[i][j] = low+(high-low)*1.0*rand()/RAND_MAX; //初始化群体particle_loc_best[i][j] = particle[i][j]; //将当前最优结果写入局部最优集合particle_v[i][j] = -V_max+2*V_max*1.0*rand()/RAND_MAX; //速度}}for(i=0; i<P_num; i++) //计算每个粒子的适应度{particle_fit[i] = fitness(particle[i]);particle_loc_fit[i] = particle_fit[i];}gfit = particle_loc_fit[0]; //找出全局最优j=0;for(i=1; i<P_num; i++){if(particle_loc_fit[i]<gfit){gfit = particle_loc_fit[i];j = i;}for(i=0; i<dim; i++) //更新全局最优向量{particle_glo_best[i] = particle_loc_best[j][i];}}void renew_particle(){int i,j;for(i=0; i<P_num; i++) //更新个体位置生成位置{for(j=0; j<dim; j++){particle[i][j] += alp*particle_v[i][j];if(particle[i][j] > high){parti cle[i][j] = high;}if(particle[i][j] < low){particle[i][j] = low;}}}}void renew_var(){int i, j;for(i=0; i<P_num; i++) //计算每个粒子的适应度{particle_fit[i] = fitness(particle[i]);if(particle_fit[i] < particle_loc_fit[i]) //更新个体局部最优值{particle_loc_fit[i] = particle_fit[i];for(j=0; j<dim; j++) // 更新局部最优向量{particle_loc_best[i][j] = particle[i][j];}}}for(i=0,j=-1; i<P_num; i++) //更新全局变量{if(particle_loc_fit[i]<gfit){gfit = particle_loc_fit[i];j = i;}}if(j != -1){for(i=0; i<dim; i++) //更新全局最优向量{particle_glo_best[i] = particle_loc_best[j][i];}}for(i=0; i<P_num; i++) //更新个体速度{for(j=0; j<dim; j++){particle_v[i][j]=w*particle_v[i][j]+c1*1.0*rand()/RAND_MAX*(particle_loc_best[i][j]-particle[i][j])+c2*1.0*rand()/RAND_MAX*(particle_glo_best[j]-particle[i][j]);if(particle_v[i][j] > V_max){particle_v[i][j] = V_max;}if(particle_v[i][j] < -V_max){particle_v[i][j] = -V_max;}}}}int main(){freopen("result.txt","a+",stdout);int i=0;srand((unsigned)time(NULL));initial();while(i < iter_num){renew_particle();renew_var();i++;}printf("粒子个数:%d\n",P_num);printf("维度为:%d\n",dim);printf("最优值为%.10lf\n", gfit);return 0; }。
粒子群算法（C语言版本）
粒子群算法（C语言版本）粒子群算法// PSO.cpp : Defines the entry point for the console application. //#include "stdafx.h"#include"stdio.h"#include"stdlib.h"#include"time.h"#include"math.h"#define rdint(i) (rand()%(int)(i))/*随机数的定义*/#define rdft() (double)((double)rdint(16384)/(16383.0))#define rnd(a,b) (rdint((int)(b)-(int)(a)+1)+(int)(a))#define POPSIZE 20#define DIMENSION1 2 /* 目标函数中所含变量x的个数*/ #define DIMENSION2 6 //约束条件的个数double W=1.0;double C1=1.8;double C2=1.8;double VMAX=3.0;double XMIN=2.0;double XMAX=4.0;double P[DIMENSION1];double PBEST;double H,K;double g[DIMENSION2];//约束条件的值struct indi{double number[DIMENSION1];double best[DIMENSION1];double bestfitness;double fitness;double speed[DIMENSION1];}individual[POPSIZE];void initiate(void);void calculation(int number);void globalbest(int number);void localbest(int number);void judge(int num);void judge(int num){/* 6个约束条件*/g[0]=4*individual[num].number[0]-individual[num].number[1];g[1]=individual[num].number[1]-10*individual[num].number[0];g[2]=-2*K*individual[num].number[1]+3*3.14*pow(individual[num].nu mber[0],3);g[3]=-50*K*individual[num].number[1]+75*3.14*pow(individual[num]. number[0],3); g[4]=-H+3.98*individual[num].number[1];g[5]=3*pow(individual[num].number[1],3)-2000*pow(individual[num].number[0],4); }void initiate(){int i,j;for(i=0;i<popsize;i++)< p="">{do{for(j=0;j<dimension1;j++)< p="">individual[i].number[j]=rdft()*(XMAX-XMIN)+XMIN;judge(i);}while(g[0]<=0 && g[1]<=0 && g[2]<=0 && g[3]<=0 && g[4]<=0 && g[5]<=0);}//如果不在可行域就对这个粒子重新进行初始化for(i=0;i<popsize;i++)< p="">for(j=0;j<dimension1;j++)< p="">individual[i].speed[j]=VMAX*rdft();for(i=0;i<popsize;i++)< p="">for(j=0;j<dimension1;j++)< p="">individual[i].best[j]=individual[i].number[j];for(i=0;i<popsize;i++)< p="">calculation(i);for(i=0;i<popsize;i++)< p="">individual[i].bestfitness=individual[i].fitness;globalbest(0);}void localbest(int number){int i;judge(number);//进行判断，如果不在可行域内就不对粒子的历史最优值进行更新 bool bTrue=g[0]<=0 && g[1]<=0 && g[2]<=0 && g[3]<=0 && g[4]<=0 && g[5]<=0; if(individual[number].bestfitness>individual[number].fitness&& bTrue){for(i=0;i<dimension1;i++)< p="">individual[number].best[i]=individual[number].number[i];individual[number].bestfitness=individual[number].fitness; }}void globalbest(int number){int i,j;double s=0;int flag=0;if(number==0){s=individual[0].fitness;flag=0;for(i=1;i<popsize;i++)< p="">if(individual[i].fitness<s)< p="">{s=individual[i].fitness;flag=i;}for(i=0;i<dimension1;i++)< p="">P[i]=individual[flag].number[i];PBEST=individual[flag].fitness;}else{for(i=0;i<popsize;i++)< p="">{if(individual[i].bestfitness<pbest)< p="">{for(j=0;j<dimension1;j++)< p="">P[j]=individual[i].best[j];PBEST=individual[i].bestfitness;}}}}void calculation(int num){K=(4*individual[num].number[1]-individual[num].number[0])/4*(individual[num].number[1] -individual[num].number[0])+0.615*individual[num].number[0]/individual[num].number [1];H=(2000*pow(individual[num].number[0],5)/pow(individual [num].number[1],3))+1.5*indivi dual[num].number[0] +75*3.14*pow(individual[num].number[0],3)/(4*K);//L=2000*3.14*pow(individual[num].number[0],4)/pow(indi vidual[num].number[1],2)+1.5* 3.14*individual[num].number[1];individual[num].fitness=0.25*3.14*pow(individual[num].nu mber[1],2)*H;}void main(void){int i,j,k,t,total=0;double sum=0;// srand(time(NULL));for(j=0;j<10;j++){initiate();for(i=0;i<5000;i++){W=1.0-i*0.6/4999;if((PBEST-67997.0)<0.1){total++;sum=sum+i;break;}else{for(k=0;k<popsize;k++)< p="">{for(t=0;t<dimension1;t++)< p="">{individual[k].speed[t]=W*individual[k].speed[t]+C1*rdft()*(i ndividual[k].best[t]-individual [k].number[t])+C2*rdft()*(P[t]-individual[k].number[t]);if(individual[k].speed[t]>VMAX)individual[k].speed[t]=VMAX;individual[k].number[t]=individual[k].number[t]+individual[ k].speed[t];if(individual[k].number[t]<xmin)< p="">individual[k].number[t]=2*XMIN-individual[k].number[t];if(individual[k].number[t]>XMAX)individual[k].number[t]=fmod(individual[k].number[t],(XMA X-XMIN))+XMIN;}calculation(k);localbest(k);}globalbest(1);}}// printf("%3d,%f/n",i,PBEST);}printf("T otal number is %d/n",total);printf("Sum is %f/n",sum);printf("Average is %f/n",sum/total); printf("%f/n",PBEST); getchar();}</xmin)<></dimension1;t++)<></popsize;k++)<></dimension1;j++)<></pbest)<></popsize;i++)<></dimension1;i++)<></s)<></popsize;i++)<></dimension1;i++)<></popsize;i++)<></popsize;i++)<></dimension1;j++)<></popsize;i++)<></dimension1;j++)<></popsize;i++)<></dimension1;j++)<></popsize;i++)<>。
粒子群算法原文及解释
粒子群算法原文及解释粒子群优化算法（Particle Swarm Optimization，PSO）是一种模拟鸟群、鱼群等动物社会行为的优化算法。
通过模拟鸟群、鱼群等动物群体中的个体行为，粒子群优化算法能够有效地求解各种优化问题。
本文将从算法原理、算法流程、参数设置、优化问题、实现方式、改进策略、应用领域和性能评价等方面对粒子群优化算法进行详细的介绍。
一、算法原理粒子群优化算法基于群体智能理论，通过模拟鸟群、鱼群等动物群体中的个体行为来寻找最优解。
每个个体被称为一个粒子，它通过跟踪其自身的最优位置和群体的最优位置来更新自己的速度和位置。
粒子的速度和位置更新公式如下：v[i][j] = w * v[i][j] + c1 * rand() * (pbest[i][j] - x[i][j]) + c2 * rand() * (gbest - x[i][j])x[i][j] = x[i][j] + v[i][j]其中，v[i][j]表示粒子i在第j维上的速度，x[i][j]表示粒子i 在第j维上的位置，pbest[i][j]表示粒子i的个体最优位置，gbest 表示全局最优位置，w表示惯性权重，c1和c2表示加速因子，rand()表示随机函数。
二、算法流程粒子群优化算法的基本流程如下：1. 初始化粒子群，随机生成粒子的初始位置和初始速度。
2. 计算每个粒子的适应度值，记录粒子的个体最优位置和全局最优位置。
3. 根据粒子的适应度值更新粒子的速度和位置。
4. 重复步骤2和步骤3，直到满足终止条件（如达到预设的最大迭代次数或全局最优解的变化小于预设阈值）。
三、参数设置粒子群优化算法的参数包括惯性权重w、加速因子c1和c2等。
这些参数对算法的性能和收敛速度有着重要的影响，需要根据具体问题进行调整和优化。
通常需要通过实验来找到合适的参数设置。
四、优化问题粒子群优化算法适用于求解连续的、离散的优化问题。
对于不同的优化问题，需要根据问题的特性和要求来设计合适的粒子和适应度函数。
粒子群优化算法的工作原理和算法流程
粒子群优化算法的工作原理和算法流程下载温馨提示:该文档是我店铺精心编制而成，希望大家下载以后，能够帮助大家解决实际的问题。
文档下载后可定制随意修改，请根据实际需要进行相应的调整和使用，谢谢!并且，本店铺为大家提供各种各样类型的实用资料，如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等，如想了解不同资料格式和写法，敬请关注!Download tips: This document is carefully compiled by theeditor.I hope that after you download them,they can help yousolve practical problems. The document can be customized andmodified after downloading,please adjust and use it according toactual needs, thank you!In addition, our shop provides you with various types ofpractical materials,such as educational essays, diaryappreciation,sentence excerpts,ancient poems,classic articles,topic composition,work summary,word parsing,copy excerpts,other materials and so on,want to know different data formats andwriting methods,please pay attention!粒子群优化算法：工作原理与算法流程详解粒子群优化算法（Particle Swarm Optimization，PSO）是一种基于群体智能的全局优化算法，由Eberhart和Kennedy在1995年提出。
粒子群算法代码实现
粒子群算法代码实现以下是粒子群算法的Python 代码实现，该算法用于解决一个优化问题。
假设我们要最小化函数f(x)，其中x 是一个向量。
import random# 优化问题的目标函数def f(x):return x[0]2 + x[1]2# 粒子群算法的实现class ParticleSwarmOptimization:def __init__(self, num_particles, num_dimensions):self.num_particles = num_particlesself.num_dimensions = num_dimensionsself.max_velocity = 2self.inertia_weight = 0.9self.cognitive_weight = 1.5self.social_weight = 1.5self.iterations = 100self.best_position = Noneself.best_fitness = float('inf')self.particles = []for i in range(num_particles):position = [random.uniform(-10, 10) for d inrange(num_dimensions)]velocity = [random.uniform(-self.max_velocity,self.max_velocity) for d in range(num_dimensions)]particle = {'position': position, 'velocity': velocity,'personal_best_position': position, 'personal_best_fitness': float('inf')} self.particles.append(particle)def optimize(self):for iter in range(self.iterations):for particle in self.particles:fitness = f(particle['position'])if fitness < particle['personal_best_fitness']:particle['personal_best_position'] =particle['position']particle['personal_best_fitness'] = fitnessif fitness < self.best_fitness:self.best_position = particle['position']self.best_fitness = fitnessfor particle in self.particles:for d in range(self.num_dimensions):r1 = random.uniform(0, 1)r2 = random.uniform(0, 1)velocity_component_cognitive =self.cognitive_weight * r1 * (particle['personal_best_position'][d] - particle['position'][d])velocity_component_social = self.social_weight * r2 * (self.best_position[d] - particle['position'][d])velocity_component_inertia = self.inertia_weight * particle['velocity'][d]velocity = velocity_component_inertia +velocity_component_cognitive + velocity_component_socialif velocity > self.max_velocity:velocity = self.max_velocityif velocity < -self.max_velocity:velocity = -self.max_velocityparticle['velocity'][d] = velocityfor d in range(self.num_dimensions):particle['position'][d] += particle['velocity'][d]# 测试代码pso = ParticleSwarmOptimization(num_particles=10,num_dimensions=2)pso.optimize()print('Best position:', pso.best_position)print('Best fitness:', pso.best_fitness)以上代码使用了一个简单的函数f(x) = x[0]^2 + x[1]^2 作为目标函数。
粒子群算法python代码
粒子群算法python代码粒子群算法在python中的实现代码为：pythonimport randomclass Particle:def __init__(self, bounds):self.position = [random.uniform(bounds[i][0], bounds[i][1]) for i in range(len(bounds))]self.velocity = [random.uniform(-1, 1) for _ inrange(len(bounds))]self.best_position = self.position.copy()self.bounds = boundsdef update_velocity(self, global_best_position, w=0.5, c1=0.5,c2=0.5):for i in range(len(self.velocity)):r1 = random.random()r2 = random.random()cognitive = c1 * r1 * (self.best_position[i] - self.position[i])social = c2 * r2 * (global_best_position[i] - self.position[i])self.velocity[i] = w * self.velocity[i] + cognitive + socialdef update_position(self):self.position = [self.position[i] + self.velocity[i] for i inrange(len(self.position))]for i in range(len(self.position)):if self.position[i] < self.bounds[i][0]:self.position[i] = self.bounds[i][0]elif self.position[i] > self.bounds[i][1]:self.position[i] = self.bounds[i][1]if self.cost() < self.cost(self.best_position):self.best_position = self.position.copy()def cost(self, x=None):if x is None:x = self.position# 计算目标函数值的代码class PSO:def __init__(self, bounds, num_particles=30, max_iter=100): self.bounds = boundsself.num_particles = num_particlesself.max_iter = max_iterself.global_best_position = Noneself.global_best_cost = float('inf')self.particles = [Particle(bounds) for _ in range(num_particles)]def optimize(self):for _ in range(self.max_iter):for particle in self.particles:cost = particle.cost()if cost < self.global_best_cost:self.global_best_cost = costself.global_best_position = particle.position.copy()for particle in self.particles:particle.update_velocity(self.global_best_position)particle.update_position()return self.global_best_position, self.global_best_cost其中，Particle类代表一个粒子，包含了当前的位置、速度、最佳位置和搜索空间的边界信息；PSO类代表整个粒子群算法的实现，包含了搜索空间的边界信息、粒子数量和最大迭代次数等参数，以及全局最优解的位置和目标函数值。
粒子群算法程序
#include<iostream>#include <fstream>#include<cmath>#include <ctime>#include <string>#include <iomanip>#include <cstdlib>using namespace std;#include "ran_number.h"const double pi=3.1415926;const int num=60; //粒子群规模const int T=2000;//最大迭代次数//*******适应度函数********//double func(double x){double f = x*sin(10*x*pi)+2.0;f=1.0/f;return f;}//---------------------主程序----------------------//void main (int argc, char* argv[]){double ran; // 随机变量RandomNumber rand;double c1=2.05, c2=2.05; //学习因子double d1=0.2,d2=0.7; //控制因子double ws=0.9, we=0.4; //最大最小惯性权重double x_down=-1.0, x_up=2.0; // 粒子空间上下界double w; //惯性权重int m=2; //迭代次数double Vmax; //粒子最大速度double x[num]; //粒子位置(控制参数) double v[num]; //粒子速度double g[num]; //粒子适应度double pbest[num]; //粒子个体最好值double pbest_x[num]; //粒子个体最好位置double gbest ; //粒子群体最好值double gbest_x; //粒子群体最好位置Vmax = (x_up-x_down)/8;//------------ 初始化粒子群：位置、速度、个体最优值及群体最优值---------- // for( int i=0; i< num; i++ ){pbest[i]=0.0;ran = rand.fRandom();x[i] = x_down + ( x_up - x_down ) * ran; //初始化粒子v[i] = Vmax * ( 2*ran - 1 ); //初始化粒子速度pbest[i] = func(x[i]);pbest_x[i] = x[i];}gbest=pbest[0];gbest_x=x[0];//-----------------第一次迭代得到的群体最优----------------------//for ( i=0; i<num; i++) // for 粒子数循环{if ( pbest[i] < gbest ){gbest = pbest[i];gbest_x =pbest_x[i];}}//---------------- 共T 次迭代过程---------------------//while( m <= T ) //迭代次数循环{w = (ws-we-d1) * exp(1/(1+d2*(m-1)/T)); //惯性权重// cout << " m= " << m << "; w= " << w << endl;for ( i=0; i<num; i++ ) // 粒子数循环{g[i] = 0.0;ran = rand.fRandom();v[i] = w * v[i] + c1 * ran * ( pbest_x[i] - x[i] ) + c2 * ran * ( gbest_x - x[i] );x[i] += v[i];if( x[i] < x_down ) { x[i] = x_down;}// cout << "到下界" << endl; }if(x[i] > x_up ) { x[i] = x_up; }//cout << " m= " << m << "到上界" << endl; }g[i] = func(x[i]);if( pbest[i] > g[i] ){pbest[i] = g[i];pbest_x[i] = x[i];}if( pbest[i] < gbest ){gbest = pbest[i];gbest_x = pbest_x[i];cout << " 第" << m << " 次迭代的gbest= " << gbest << " gbest_x = " << gbest_x << endl; //输出第m次迭代的群体最优值及最优位置}} //end form = m + 1;}//end for whilecout << " gbest= " << gbest << " gbest_x = " << gbest_x << endl;}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
二维粒子群matlab源程序%function [pso F] = pso_2D()% FUNCTION PSO --------USE Particle Swarm Optimization Algorithm% global present;% close all;clc;clear all;pop_size = 10; % pop_size 种群大小 ///粒子数量part_size = 2; % part_size 粒子大小 ///粒子的维数gbest = zeros(1,part_size+1); % gbest 当前搜索到的最小的值max_gen = 200; % max_gen 最大迭代次数%best=zeros(part_size,pop_size*part_size);%xuanregion=zeros(part_size,2); % 设定搜索空间范围->解空间region=10*[-3,3;-3,3;-3,3;-3,3;-3,3;-3,3;-3,3;-3,3;-3,3;-3,3]; % 每一维设定不同范围(称之为解空间，不是可行域空间）rand('state',sum(100*clock)); % 重置随机数发生器状态%当前种群的信息矩阵，逐代进化的群体 % 当前位置,随机初始化% 一个10*3的随机的矩阵（初始化所有粒子的所有维数的位置值），其中最后一列为arr_present = ini_pos(pop_size,part_size);% 初始化当前速度% 一个10*2的随机的矩阵（初始化所有粒子的所有维数的速度值）v=ini_v(pop_size,part_size);%不是当前种群，可看作是一个外部的记忆体，存储每个粒子历史最优值（2维数值）：根据适应度更新！%注意：pbest数组10*3 最后一列保存的是适应度pbest = zeros(pop_size,part_size+1); % pbest：粒子以前搜索到的最优值，最后一列包括这些值的适应度% 1*80 保存每代的最优值best_record = zeros(part_size+1,max_gen); % best_record 数组：记录每一代的最好的粒子的适应度w_max = 0.9; % w_max权系数最大值w_min = 0.2; % w_min权系数最小值v_max = 2; % 最大速度,为粒子的范围宽度c1 = 2; % 学习因子1c2 = 2; % 学习因子2% ————————————————————————% 计算原始种群的适应度,及初始化% ————————————————————————% 注意：传入的第一个参数是当前的粒子群体，ini_fit函数计算每个粒子的适应度% arr_present(:,end)是最后一列，保存每个粒子的适应值，是这样的！xuan arr_present(:,end)= ini_fit( arr_present, pop_size, part_size );% 数组赋值，初始化每个粒子个体的历史最优值，以后会更新的pbest = arr_present; % 初始化各个粒子最优值% 找到当前群体中适应度最小的（在最后一列中寻找），best_value% 改为max，表示关联度最大[best_value best_index] = max(arr_present(:,end)); %初始化全局最优，即适应度为全局最小的值，根据需要也可以选取为最大值% 唯一的全局最优值，是当前代所有粒子中最好的一个gbest = arr_present(best_index,:);% 因为是多目标，因此这个-----------------% 只是示意性的画出3维的%x=[-3:0.01:3];%y=[-3:0.01:3];%[X,Y]=meshgrid(x,y);%Z1=(-10)*exp((-0.2)*sqrt(X^2+Y^2));%Z2=(abs(X))^0.8+abs(Y)^0.8+5*sin(X^3)+5*sin(Y^3);%z1=@(x,y)(-10)*exp((-0.2)*sqrt(x^2+y^2));%z2=@(x,y)(abs(x))^0.8+abs(y)^0.8+5*sin(x^3)+5*sin(y^3); %ezmeshc(z1);grid on;%ezmeshc(z2);grid on;%开始进化，直到最大代数截至for i=1:max_gen%grid on;%三维图象 %多维图象是画不出来的%ezmesh(z),hold on,grid on;%画出粒子群%plot3(arr_present(:,1),arr_present(:,2),arr_present(:,3),'*'),h old off;%drawnow%flush%pause(0.01);w = w_max-(w_max-w_min)*i/max_gen; % 线形递减权重% 当前进化代数：对于每个粒子进行更新和评价----->>>>>>>for j=1:pop_sizev(j,:) =w.*v(j,:)+c1.*rand.*(pbest(j,1:part_size)-arr_present(j,1:part_size ))...+c2.*rand.*(gbest(1:part_size)-arr_present(j,1:part_size )); % 粒子速度更新 (a)% 判断v的大小，限制v的绝对值小于20———————————————————for k=1:part_sizeif abs(v(j,k))>20rand('state',sum(100*clock));v(j,k)=20*rand();endend%前几列是位置信息arr_present(j,1:part_size) =arr_present(j,1:part_size)+v(j,1:part_size);% 粒子位置更新(b)%最后一列是适应度arr_present(j,end) =fitness(part_size,arr_present(j,1:part_size)); % 适应度更新（保存至最后一列）% 适应度评价与可行域限制if(arr_present(j,end)>pbest(j,end))&(Region_in(arr_present(j,:),regi on)) % 根据条件更新pbest,如果是最小的值为小于号,相反则为大于号 pbest(j,:) = arr_present(j,:); % 更新个体的历史极值 endend% 以下更新全局的极值[best best_index] = max(arr_present(:,end)); % 如果是最小的值为min,相反则为maxif best>gbest(end) &( Region_in(arr_present(best_index,:),region) ) % 如果当前最好的结果比以前的好，则更新最优值gbest,如果是最小的值为小于号,相反则为大于号gbest = arr_present(best_index,:); % 全局的极值end%------------混沌---------------------------------xlhd = gbest(1:part_size);if(1)for p=1:25 %次数%1生成cxl=rand(1,part_size);for j=1:part_sizeif cxl(j)==0cxl(j)=0.1;endif cxl(j)==0.25cxl(j)=0.26;endif cxl(j)==0.5cxl(j)=0.51;endif cxl(j)==0.75cxl(j)=0.76;endif cxl(j)==1cxl(j)=0.9;endend%2映射al=-30;bl=30;rxl=al+(bl-al)*cxl;%3搜索bate = 0.1;xlhd=xlhd+bate*rxl;if fitness(part_size,xlhd)>gbest(end)gbest(1:part_size)=xlhd;gbest(end)=fitness(part_size,xlhd);end%4更新for j=1:part_sizecxl(j)=4*cxl(j)*(1-cxl(j));endendend%-------------混沌--------------------------------%当前代的最优粒子的适应度（取自）保存best_record(:,i) = gbest; % gbest：一个行向量endpso = gbest; % 最优个体display(gbest);figure;plot(best_record(end,:));% 最优解与代数的进化关系图best=zeros(part_size,max_gen);for i=1:part_size-1best(i,:)=best_record(i,:);endpareto1= zeros(1,max_gen);pareto2= zeros(1,max_gen);for i=1:max_genpareto1(i)=f1(part_size, best(:,i) );pareto2(i)=f2(part_size, best(:,i) );endfigure;i=1:max_gen;%plot(i,pareto1(i),'r*',i,pareto2(i),'g*');plot(pareto1(i),pareto2(i),'r+');xlabel('f1');ylabel('f2');title('Pareto曲线');%figure;%plot(,f2(best_record),);% movie2avi(F,'pso_2D1.avi','compression','MSVC');%子函数%------------------------------------------------------------------------- %------------------------------------------------------------------------- %返回随机的位置function ini_present=ini_pos(pop_size,part_size)ini_present = 10*3*rand(pop_size,part_size+1); %初始化当前粒子位置,使其随机的分布在工作空间%返回一个随机的矩阵，10*（2+1），最后一列将用来保存适应度%返回随机的速度function ini_velocity=ini_v(pop_size,part_size)ini_velocity =20*(rand(pop_size,part_size)); %初始化当前粒子速度,使其随机的分布在速度范围内%判断是否处于范围内function flag = Region_in(pos_present,region)[m n]=size(pos_present); % 1*11 n返回解的维数10flag=1;for j=1:n-1flag = flag & ( pos_present(1,j)>=region(j,1) ) &( pos_present(1,j)<=region(j,2) );end%初始化适应度function arr_fitness = ini_fit(pos_present,pop_size,part_size)for k=1:pop_sizearr_fitness(k,1) =fitness(part_size,pos_present(k,1:part_size)); %计算原始种群的适应度%**************************************************** ***********************% 计算适应度%**************************************************** ***********************function fit = fitness(n,xp)%需要求极值的函数,本例即peaks函数%y0=[-85.4974,-29.9217]; % 注意：这是基准序列，也就是单个最优的极值y0=[-9.9907,-7.7507];%y0=[-39.6162,-18.4561];% y0=[-86.8312,-29.9217];y1=[f1(n,xp),f2(n,xp)]; % n为粒子维数fit=graydegree(2,y0,y1); % 关联度在某种意义上就是适应度%目标函数1function r=f1(n,x)r=0;for i=1:n-1r=r+(-10)*exp((-0.2)*sqrt(x(i)^2+x(i+1)^2));end%目标函数2function r=f2(n,x)r=0;for i=1:nr=r+(abs(x(i)))^0.8+5*sin(x(i)^3);%约束函数1function r=g1(n,x)r=0;for i=1:nr=0;end%约束函数2function r=g2(n,x)r=0;for i=1:nr=0;end% 灰色关联度计算函数 ( 越大相似性越好 )% tn目标函数个数x0基准序列（一组值）x1贷检（一组值）function gama = graydegree( tn,y0,y1 )gama=0;rou =0.5;kesa= zeros(tn,1);m1= abs(y0(1)-y1(1)) ;m2= abs(y0(1)-y1(1)) ;for i=1:tnif( abs(y0(i)-y1(i))>m2 ) %------------------应该取大于呢还是小于 m2= abs(y0(i)-y1(i));endendfor i=1:tnkesa(i) = ( m1+rou*m2)/( abs(y0(i)-y1(i)) +rou*m2 );gama = gama + kesa(i);endgama = gama/tn;% 可行解的判决函数 gn为约束条件的个数(暂时未用) n为解（粒子）的维数function bool = feasible( x,n )r=0;%for i=1:gnr=max( 0, g1(n,x), g2(n,x) );%判断约束条件%endif(r>0)bool=0; %不可行解elsebool=1; %可行解endPSO粒子群算法解决旅行商问题的MATLAB源码PSO粒子群算法解决旅行商问题的MATLAB源码%粒子群算法求解旅行商问题% By lReijclose all;clear all;PopSize=500;%种群大小CityNum = 14;%城市数OldBestFitness=0;%旧的最优适应度值Iteration=0;%迭代次数MaxIteration =2000;%最大迭代次数IsStop=0;%程序停止标志Num=0;%取得相同适应度值的迭代次数c1=0.5;%认知系数c2=0.7;%社会学习系数w=0.96-Iteration/MaxIteration;%惯性系数,随迭代次数增加而递减%节点坐标node=[16.47 96.10; 16.47 94.44; 20.09 92.54; 22.39 93.37; 25.23 97.24;...22.00 96.05; 20.47 97.02; 17.20 96.29; 16.30 97.38; 14.05 98.12;...16.53 97.38; 21.52 95.59; 19.41 97.13; 20.09 94.55];%初始化各粒子，即产生路径种群Group=ones(CityNum,PopSize);for i=1:PopSizeGroup(:,i)=randperm(CityNum)';endGroup=Arrange(Group);%初始化粒子速度（即交换序）Velocity =zeros(CityNum,PopSize);for i=1:PopSizeVelocity(:,i)=round(rand(1,CityNum)'*CityNum); %round取整end%计算每个城市之间的距离CityBetweenDistance=zeros(CityNum,CityNum);for i=1:CityNumfor j=1:CityNumCityBetweenDistance(i,j)=sqrt((node(i,1)-node(j,1))^2+(node(i,2)-node(j,2))^2);endend%计算每条路径的距离for i=1:PopSizeEachPathDis(i) = PathDistance(Group(:,i)',CityBetweenDistance);endIndivdualBest=Group;%记录各粒子的个体极值点位置,即个体找到的最短路径IndivdualBestFitness=EachPathDis;%记录最佳适应度值,即个体找到的最短路径的长度[GlobalBestFitness,index]=min(EachPathDis);%找出全局最优值和相应序号%初始随机解figure;subplot(2,2,1);PathPlot(node,CityNum,index,IndivdualBest);title('随机解');%寻优while(IsStop == 0) & (Iteration < MaxIteration)%迭代次数递增Iteration = Iteration +1;%更新全局极值点位置,这里指路径for i=1:PopSizeGlobalBest(:,i) = Group(:,index);end%求pij-xij ,pgj-xij交换序，并以概率c1，c2的保留交换序pij_xij=GenerateChangeNums(Group,IndivdualBest);pij_xij=HoldByOdds(pij_xij,c1);pgj_xij=GenerateChangeNums(Group,GlobalBest);pgj_xij=HoldByOdds(pgj_xij,c2);%以概率w保留上一代交换序Velocity=HoldByOdds(Velocity,w);Group = PathExchange(Group,Velocity); %根据交换序进行路径交换Group = PathExchange(Group,pij_xij);Group = PathExchange(Group,pgj_xij);for i = 1:PopSize % 更新各路径总距离EachPathDis(i) = PathDistance(Group(:,i)',CityBetweenDistance);endIsChange = EachPathDis<IndivdualBestFitness;%更新后的距离优于更新前的，记录序号IndivdualBest(:, find(IsChange)) = Group(:, find(IsChange));%更新个体最佳路径IndivdualBestFitness = IndivdualBestFitness.*( ~IsChange) + EachPathDis.*IsChange;%更新个体最佳路径距离[GlobalBestFitness, index] = min(EachPathDis);%更新全局最佳路径,记录相应的序号if GlobalBestFitness==OldBestFitness %比较更新前和更新后的适应度值;Num=Num+1; %相等时记录加一;elseOldBestFitness=GlobalBestFitness;%不相等时更新适应度值，并记录清零;Num=0;endif Num >= 20 %多次迭代的适应度值相近时程序停止IsStop=1;endBestFitness(Iteration) =GlobalBestFitness;%每一代的最优适应度end%最优解subplot(2,2,2);PathPlot(node,CityNum,index,IndivdualBest);title('优化解');%进化曲线subplot(2,2,3);plot((1:Iteration),BestFitness(1:Iteration));grid on;title('进化曲线');%最小路径值GlobalBestFitnessfunction Group=Arrange(Group)[x y]=size(Group);[NO1,index]=min(Group',[],2); %找到最小值1for i=1:ypop=Group(:,i);temp1=pop([1: index(i)-1]);temp2=pop([index(i): x]);Group(:,i)=[temp2' temp1']';endfunction ChangeNums=GenerateChangeNums(Group,BestVar);[x y]=size(Group);ChangeNums=zeros(x,y);for i=1:ypop=BestVar(:,i);%从BestVar取出一个顺序pop1=Group(:,i);%从粒子群中取出对应的顺序for j=1:x %从BestVar的顺序中取出一个序号NoFromBestVar=pop(j);for k=1:x %从对应的粒子顺序中取出一个序号NoFromGroup=pop1(k);if (NoFromBestVar==NoFromGroup) && (j~=k) %两序号同且不在同一位置ChangeNums(j,i)=k; %交换子pop1(k)=pop1(j);pop1(j)=NoFromGroup;endendendendfunction Hold=HoldByOdds(Hold,Odds)[x,y]=size(Hold);for i=1:xfor j=1:yif rand>OddsHold(i,j)=0;endendendfunction SumDistance=PathDistance(path,CityBetweenDistance)L=length(path); %path为一个循环的节点顺序SumDistance=0;for i=1:L-1SumDistance=SumDistance+CityBetweenDistance(path(i),path(i+1));endSumDistance=SumDistance+CityBetweenDistance(path(1),path(L)); %加上首尾节点的距离function Group=PathExchange(Group,Index)[x y]=size(Group);for i=1:ya=Index(:,i); %取出其中一组交换序pop=Group(:,i); %取出对应的粒子for j=1:x %取出其中一个交换算子作交换if a(j)~=0pop1=pop(j);pop(j)=pop(a(j));pop(a(j))=pop1;endendGroup(:,i)=pop;endfunction PathPlot(node,CityNum,index,EachBest);for i=1:CityNumNowBest(i,:)=node((EachBest(i,index)),:);endNowBest(CityNum+1,:)=NowBest(1,:);plot(node(:,1),node(:,2),'*');line(NowBest(:,1),NowBest(:,2));grid on;。