精华内容
下载资源
问答
  • 粒子群优化算法(PSO)

    万次阅读 多人点赞 2018-06-04 20:07:09
    粒子群优化算法(Partical Swarm Optimization PSO),粒子群中的每一个粒子都代表一个问题的可能解,通过粒子个体的简单行为,群体内的信息交互实现问题求解的智能性。由于PSO操作简单、收敛速度快,...

     

     

    %% 最近写的粒子群的论文,再重新巩固一下 推荐一个优化算法代码网址:http://www.Hvass-Labs.org/

    1   研究背景

    粒子群算法的发展过程。粒子群优化算法(Partical Swarm Optimization PSO),粒子群中的每一个粒子都代表一个问题的可能解,通过粒子个体的简单行为,群体内的信息交互实现问题求解的智能性。由于PSO操作简单、收敛速度快,因此在函数优化、 图像处理、大地测量等众多领域都得到了广泛的应用。 随着应用范围的扩大,PSO算法存在早熟收敛、维数灾难、易于陷入局部极值等问题需要解决,主要有以下几种发展方向。

    (1)调整PSO的参数来平衡算法的全局探测和局部开采能力。如Shi和Eberhart对PSO算法的速度项引入了惯性权重,并依据迭代进程及粒子飞行情况对惯性权重进行线性(或非线性)的动态调整,以平衡搜索的全局性和收敛速度。2009年张玮等在对标准粒子群算法位置期望及方差进行稳定性分析的基础上,研究了加速因子对位置期望及方差的影响,得出了一组较好的加速因子取值。

    (2)设计不同类型的拓扑结构,改变粒子学习模式,从而提高种群的多样性,Kennedy等人研究了不同的拓扑结构对SPSO性能的影响。针对SPSO存在易早熟收敛,寻优精度不高的缺点,于2003年提出了一种更为明晰的粒子群算法的形式:骨干粒子群算法(Bare Bones PSO,BBPSO)。

    (3)将PSO和其他优化算法(或策略)相结合,形成混合PSO算法。如曾毅等将模式搜索算法嵌入到PSO算法中,实现了模式搜索算法的局部搜索能力与PSO算法的全局寻优能力的优势互补。

    (4)采用小生境技术。小生境是模拟生态平衡的一种仿生技术,适用于多峰函数和多目标函数的优化问题。例如,在PSO算法中,通过构造小生境拓扑,将种群分成若干个子种群,动态地形成相对独立的搜索空间,实现对多个极值区域的同步搜索,从而可以避免算法在求解多峰函数优化问题时出现早熟收敛现象。 Parsopoulos提出一种基于“分而治之”思想的多种群PSO算法,其核心思想是将高维的目标函数分解成多个低维函数,然后每个低维的子函数由一个子粒子群进行优化,该算法对高维问题的求解提供了一个较好的思路。

    不同的发展方向代表不同的应用领域,有的需要不断进行全局探测,有的需要提高寻优精度,有的需要全局搜索和局部搜索相互之间的平衡,还有的需要对高维问题进行求解。这些方向没有谁好谁坏的可比性,只有针对不同领域的不同问题求解时选择最合适的方法的区别。

    2   相关模型和思想

    粒子群算法( Particle Swarm Optimization, PSO)最早是由Eberhart和Kennedy于1995年提出,它的基本概念源于对鸟群觅食行为的研究。设想这样一个场景:一群鸟在随机搜寻食物,在这个区域里只有一块食物,所有的鸟都不知道食物在哪里,但是它们知道当前的位置离食物还有多远。最简单有效的策略?寻找鸟群中离食物最近的个体来进行搜素。PSO算法就从这种生物种群行为特性中得到启发并用于求解优化问题。

    用一种粒子来模拟上述的鸟类个体,每个粒子可视为N维搜索空间中的一个搜索个体,粒子的当前位置即为对应优化问题的一个候选解,粒子的飞行过程即为该个体的搜索过程.粒子的飞行速度可根据粒子历史最优位置和种群历史最优位置进行动态调整.粒子仅具有两个属性:速度和位置,速度代表移动的快慢,位置代表移动的方向。每个粒子单独搜寻的最优解叫做个体极值,粒子群中最优的个体极值作为当前全局最优解。不断迭代,更新速度和位置。最终得到满足终止条件的最优解。

    算法流程如下:

     1、初始化

    首先,我们设置最大迭代次数,目标函数的自变量个数,粒子的最大速度,位置信息为整个搜索空间,我们在速度区间和搜索空间上随机初始化速度和位置,设置粒子群规模为M,每个粒子随机初始化一个飞翔速度。

    2、 个体极值与全局最优解

    定义适应度函数,个体极值为每个粒子找到的最优解,从这些最优解找到一个全局值,叫做本次全局最优解。与历史全局最优比较,进行更新。

    3、 更新速度和位置的公式

     

     

    4、 终止条件

    (1)达到设定迭代次数;(2)代数之间的差值满足最小界限

     

    以上就是最基本的一个标准PSO算法流程。和其它群智能算法一样,PSO算法在优化过程中,种群的多样性和算法的收敛速度之间始终存在着矛盾.对标准PSO算法的改进,无论是参数的选取、小生境技术的采用或是其他技术与PSO的融合,其目的都是希望在加强算法局部搜索能力的同时,保持种群的多样性,防止算法在快速收敛的同时出现早熟收敛。

    3   总结与应用

    首先总结一下PSO算法的一些优点:(1)它是一类不确定算法。不确定性体现了自然界生物的生物机制,并且在求解某些特定问题方面优于确定性算法。(2)是一类概率型的全局优化算法。非确定算法的优点在于算法能有更多机会求解全局最优解。(3)不依赖于优化问题本身的严格数学性质。(4)是一种基于多个智能体的仿生优化算法。粒子群算法中的各个智能体之间通过相互协作来更好的适应环境,表现出与环境交互的能力.(5)具有本质并行性。包括内在并行性和内含并行性。(6)具有突出性。粒子群算法总目标的完成是在多个智能体个体行为的运动过程中突现出来的。(7)具有自组织和进化性以及记忆功能,所有粒子都保存优解的相关知识。(8)都具有稳健性。稳健性是指在不同条件和环境下算法的实用性和有效性,但是现在粒子群算法的数学理论基础还不够牢固,算法的收敛性还需要讨论。

    从中可以看出PSO具有很大的发展价值和发展空间,算法能够用于多个领域并创造价值,在群智能算法中具有重要的地位,同时也能够在相关产业创造价值,发挥作用。下面结合相关产业具体分析一下。

    计算智能的算法,往往结合大数据平台,包括GPU运算,并行计算,HPC,多模式结合等手段,来完成更加复杂多变的业务需求。

    下面具体分析在产业中的作用(1)模式识别和图像处理。PSO算法已在图像分割、图像配准、图像融合、图像识别、图像压缩和图像合成等方面发挥作用。(2)神经网络训练。PSO算法可完成人工神经网络中的连接权值的训练、结构设计、学习规则调整、特征选择、连接权值的初始化和规则提取等。但是速度没有梯度下降优化的好,需要较大的计算资源。一般都算不动。(3)电力系统设计,例如:日本的Fuji电力公司的研究人员将电力企业某个著名的RPVC(Reactive Power and Voltage Control)问题简化为函数的最小值问题,并使用改进的PSO算法进行优化求解。(4)半导体器件综合,半导体器件综合是在给定的搜索空间内根据期望得到的器件特性来得到相应的设计参数。(5)还有其他的一些相关产业。包括自动目标检测、生物信号识别、决策调度、系统识别以及游戏训练等方面也取得了一定的研究成果。

    算法实现:

    clc
    clear 
    close all
    E=0.000001;
    maxnum=800;%最大迭代次数
    narvs=2;%目标函数的自变量个数
    particlesize=50;%粒子群规模
    c1=2;%每个粒子的个体学习因子,加速度常数
    c2=2;%每个粒子的社会学习因子,加速度常数
    w=0.6;%惯性因子
    vmax=5;%粒子的最大飞翔速度
    v=2*rand(particlesize,narvs);%粒子飞翔速度
    x=-300+600*rand(particlesize,narvs);%粒子所在位置
    %定义适应度函数
    fitness=inline('(x(1)^2+x(2)^2)/10000','x');
    for i=1:particlesize
    	f(i)=fitness(x(i,:));	
    end
    personalbest_x=x;
    personalbest_faval=f;
    [globalbest_faval,i]=min(personalbest_faval);
    globalbest_x=personalbest_x(i,:); 
    k=1;
    while (k<=maxnum)
    	for i=1:particlesize
    			f(i)=fitness(x(i,:));
    		if f(i)<personalbest_faval(i)
    			personalbest_faval(i)=f(i);
    			personalbest_x(i,:)=x(i,:);
    		end
    	end
    	[globalbest_faval,i]=min(personalbest_faval);
    	globalbest_x=personalbest_x(i,:);
    	for i=1:particlesize
    		v(i,:)=w*v(i,:)+c1*rand*(personalbest_x(i,:)-x(i,:))...
    			+c2*rand*(globalbest_x-x(i,:));
    		for j=1:narvs
    			if v(i,j)>vmax
    				v(i,j)=vmax;
    			elseif v(i,j)<-vmax
    				v(i,j)=-vmax;
                end
    		end
    		x(i,:)=x(i,:)+v(i,:);
    
        end
        ff(k)=globalbest_faval;
        if globalbest_faval<E
            break
        end
    %       figure(1)
    %       for i= 1:particlesize
    %       plot(x(i,1),x(i,2),'*')
    %       end
    	k=k+1;
    end
    xbest=globalbest_x;
    
    figure(2)
    set(gcf,'color','white');
    plot(1:length(ff),ff)

     

    算法结果:

     

    展开全文
  • MATLAB 粒子群算法,例题与常用模版

    万次阅读 多人点赞 2018-09-06 18:09:18
    MATLAB 粒子群算法 本文学习自:Particle Swarm Optimization in MATLAB - Yarpiz Video Tutorial 与《精通MATLAB智能算法》 1. 简介: Particle Swarm Optimization ,粒子群优化算法,常用来找到方程...

    本文学习自:Particle Swarm Optimization in MATLAB - Yarpiz Video Tutorial 与《精通MATLAB智能算法》

    1. 简介:

    Particle Swarm Optimization ,粒子群优化算法,常用来找到方程的最优解。

    2. 算法概述:

    每次搜寻都会根据自身经验(自身历史搜寻的最优地点)和种群交流(种群历史搜寻的最优地点)调整自身搜寻方向速度

    3. 算法优势:

    • 相较于传统算法计算速度非常快,全局搜索能力也很强;
    • PSO对于种群大小不十分敏感,所以初始种群往往设为500-1000,不同初值速度影响也不大;
    • 粒子群算法适用于连续函数极值问题,对于非线性、多峰问题均有较强的全局搜索能力。

    4. 算法基本原理

    一个形象的例子:

    A与B两个小粒子初始时在河的两侧,他们想要找到河最深处。如果A某时刻所在位置的深度比B的浅,A就会像B的方向走,反之亦然。 当A到达Global Minimum(全局最小值)时,B会一直向着A前进,直到在optimum solution(全剧最优解)处汇合。
    在这里插入图片描述

    4.1 概述

    从上面的示例中我们得到两个准则,也可以说是每个粒子的必要特性:

    1. Communication : 彼此互相通知
    2. Learning : 不停地学习以达最优解

    数量众多的粒子通过相互的交流与学习,全部粒子最终将汇聚到一点,即问题的解。粒子间相互交流与学习的过程用数学或计算机语言描述为迭代

    迭代的意义在于不断寻找更优的值,从理论上来说,如果我们掌握了一种可以不停寻找到更优解答的方法,通过不停的迭代,我们就能够找到最优的答案

    Learning the concept of better is the main problem that an optimizer should solve. Then an optimizer learns the concept of better, it is able to solve any kind of optimuzation.Because the solution of optimization problem is to find the best one . So if we know what is the better, we actually can discover the concept of best.

    4.2 粒子的基本信息

    回顾粒子群算法概述:
    每次搜寻都会根据自身经验(自身历史搜寻的最优地点)和种群交流(种群历史搜寻的最优地点)调整自身搜寻方向和速度

    我们首先聚焦与粒子本身,或许全部粒子研究起来很复杂,但单个粒子的属性是很简单的。

    首先,每个粒子包含两个基本信息,Position(位置) & Velocity(速度)。
    在粒子群算法的每次迭代中,每个粒子的位置和速度都会更新。

    • 我们用Xi(t)\vec {X_i(t)}记录位置
    • Vi(t)\vec { V_i (t)}记录方向与速度
      在这里插入图片描述
    4.3 粒子的个体极值与全局极值

    回顾粒子群算法概述:
    每次搜寻都会根据自身经验(自身历史搜寻的最优地点)种群交流(种群历史搜寻的最优地点)调整自身搜寻方向和速度。

    仅有上述位置与速度两个信息还不够,我们之前提到过,每一个粒子是会学习的。 每个粒子还拥有下面两个信息(每个信息都是一个向量):

    • 每一个粒子有它自己的记忆,会记住自己的best position , best experience,即个体极值 (personal best), 标记为Pi(t)\vec { P_i (t)}

    • 当前时刻全局的最优解,即全局极值(Common best experience among the members),标记为 gi(t)\vec { g_i (t)}

      总结:PSO初始化为一群随机粒子,然后通过迭代找到最优解。在每一次迭代过程中,粒子通过跟踪两个极值来更新自己,一个是粒子本身所找到的最优解,这个解称为个体极值Pi(t)\vec { P_i (t)};另一个极值是整个种群目前找到的最优解,这个极值是全局极值 gi(t)\vec { g_i (t)}

    在这里插入图片描述

    4.4 找到新位置

    根据平行四边形法则,已知个体极值与整体极值,有了新时刻的速度Vi(t+1)\vec {V_i}(t+1) ,会得到新的位置Xi(t+1)\vec {X_i}(t+1)

    在这里插入图片描述

    状态转移方程:

    vij(t+1)=wvij(t)+c1r1(pij(t)xij(t))+c2r2(gj(t)xij(t))(4-1)\vec {v_{ij}}(t+1) = w\vec{v_{i j}} (t) + c_1r_1(p_{ij} (t) - \vec{x_{ij}}(t))+c_2r_2(g_j(t)-\vec{x_{ij}}(t)) \tag{4-1}

    xij(t+1)=xij(t)+vij(t+1)(4-2)\vec {x_{ij}}(t+1) = \vec{x_{ij}}(t)+\vec{v_{ij}}(t+1) \tag{4-2}

    其中,c1,c2c_1,c_2为学习因子,也称加速常数(acceleration constant);

    r1,r2r_1,r_2,[0,1]范围内的均匀随机数。

    式(1)右边由三部分组成:

    • 第一部分为“惯性(inertia)”或“动量(MOMENTUM)”部分,反映了粒子的运动习惯,代表粒子有维持自己先前速度的趋势。
    • 第二部分为“认知(cognition)”部分,反映了粒子对自身历史经验的记忆,代表粒子由向自身历史最佳位置逼近的趋势。
    • 第三部分为“社会(social)”部分,反映了粒子间协同合作与知识共享的群体历史经验,代表粒子有向群体或领域历史最佳位置逼近的趋势。

    5. 算法的运行参数

    PSO算法一个最大的优点是不需要调节太多的参数,但是算法中少数几个参数却直接影响着算法的性能和收敛性。

    基本粒子群算法有下述7个运行参数需要提前设定:

    1. rr:粒子群算法的种子数,对粒子群算法中种子数值可以随机生成也可以固定位一个初始的数值,要求能涵盖目标函数的范围内。
    2. mm:粒子群群体大小,即群体中所含个体的数量,一般取为20~40。在变两年比较多的时候可以取100以上较大的数。
    3. maxdmax_d:一般为最大迭代次数以最小误差的要求满足的。粒子群算法的最大迭代次数,也是终止条件数。
    4. r1,r2r_1,r_2:两个在[0,1]之间变化的加速度权重系数随机产生。
    5. c1,c2c_1,c_2:加速常数,取随机2左右的值。
    6. ww:惯性权重产生的。
    7. vk,xkv_k,x_k:一个粒子的速度和位移数值,用粒子群算法迭代出每一组的数值。

    6. 算法的基本流程

    1. 初始化粒子群,包括群体规模N,每个粒子的位置xix_i和速度viv_i
    2. 计算吗每一个粒子的适应度值Fit[i]Fit[i]
    3. 计算每个粒子,用它的适应度值Fit[i]Fit[i]和个体极值pbest(i)p_{best}(i)比较,如果Fit[i]>pbest(i)Fit[i]>p_{best}(i),则用Fit[i]Fit[i]替换掉pbest(i)p_{best}(i)
    4. 计算每个粒子,用它的适应度值Fit[i]Fit[i]和全局极值gbest(i)g_{best}(i)比较,如果Fit[i]>gbest(i)Fit[i]>g_{best}(i),则用Fit[i]Fit[i]替换掉gbest(i)g_{best}(i)
    5. 根据式(4-1)和式(4-2)更新粒子的位置xix_i和速度viv_i
    6. 如果满足结束条件(误差足够好或到达最大循环次数)退出,否则返回步骤2.

    7. 手动实现PSO

    function[xm,fv] = PSO(fitness,N,c1,c2,w,M,D)
    % c1,c2:学习因子
    % w:惯性权重
    % M:最大迭代次数
    % D:搜索空间维数
    % N:初始化群体个体数目
    
    
    % 初始化种群的个体(可以在这里限定位置和速度的范围)
    format long;
    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) = fitness(x(i,:));
        y(i,:) = x(i,:);
    end 
    pg = x(N,:);  % pg为全局最优
    for i=1:(N-1)
        if(fitness(x(i,:))<fitness(pg))
            pg = x(i,:);
        end
    end
    
    
    % 进入主要循环,按照公式依次迭代,直到满足精度要求
    for t=1:M
        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,:)) < p(i)
                p(i)=fitness(x(i,:));
                y(i,:)=x(i,:);
            end
            if p(i) < fitness(pg)
                pg=y(i,:);
            end
        end
        Pbest(t)=fitness(pg);
    end
    
    
    % 输出结果
    disp('目标函数取最小值时的自变量:')
    xm=pg';
    disp('目标函数的最小值为:')
    fv=fitness(pg);
    
    例1:求解下列函数的最小值:

    f(x)=i=130xi2+xi6f(x) = \sum^{30}_{i=1}x_i^2+x_i-6

    function F=fitness(x)
    F = 0;
    for i = 1:30
        F = F+x(i)^2+x(i)-6;
    end
    

    输入:

    x = zeros(1,30);
    [xm1,fv1] = PSO(@fitness,50,1.5,2.5,0.5,100,30)
    

    后记:拜托 还有人问显示fitness未定义怎么办,找不到输出结果怎么办?? 软件入门都没搞定就不要急于求成好吗?
    补入门知识:把手动实现PSO的代码保存为PSO.m,把function F=fitness(x)和后面4行代码保存为fitness.m。 然后再在命令行输入内容。

    9. 自适应权重法

    function[xm,fv] = PSO_adaptation(fitness,N,c1,c2,wmax,wmin,M,D)
    % c1,c2:学习因子
    % wmax:惯性权重最大值
    % wmin:惯性权重最小值
    % M:最大迭代次数
    % D:搜索空间维数
    % N:初始化群体个体数目
    
    
    % 初始化种群的个体(可以在这里限定位置和速度的范围)
    for i = 1:N
        for j=1:D
            x(i,j) = randn; % 随机初始化位置
            v(i,j) = randn; % 随即初始化速度
        end
    end
    
    
    %先计算各个粒子的适应度,并初始化个体最优解pi和整体最优解pg %
    %初始化pi %
    for i = 1:N
        p(i) = fitness(x(i,:)) ;
        y(i,:) = x(i,:) ;
    end
    %初始化pg %
    pg = x(N,:) ;
    %得到初始的全局最优pg %
    for i = 1:(N-1)
        if fitness(x(i,:)) < fitness(pg)
            pg = x(i,:) ;
        end
    end
     
    %主循环函数,进行迭代,直到达到精度的要求 %
    for t = 1:M
        for j = 1:N
            fv(j) = fitness(x(j,:)) ;
        end
        fvag = sum(fv)/N ;
        fmin = min(fv);
        for i = 1:N    %更新函数,其中v是速度向量,x为位置,i为迭代特征
            if fv(i) <= fvag
                w = wmin+(fv(i)-fmin)*(wmax-wmin)/(fvag-fmin) ;   %依据早熟收敛程度和适应度值进行调整
            else
                w = wmax ;
            end
            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,:)) < p(i)
                p(i) = fitness(x(i,:)) ;
                y(i,:) = x(i,:) ;
            end
            if p(i) < fitness(pg)
                pg = y(i,:) ;
            end
        end
         Pbest(t) = fitness(pg) ;
    end
     
    %给出最后的计算结果 %
    xm = pg' ;
    fv = fitness(pg) ;
     
    plot(Pbest)
    xlabel('进化次数') ;
    ylabel('适应度值') ;
    

    例2:用自适应权重法求解函数

    y=((sin(x12+x22))2cos(x12+x22)+1)((1+0.1×(x12+x22))2)0.7\large{y = \frac {((sin(x_1^2+x_2^2))^2-cos(x_1^2+x_2^2)+1)} {((1+0.1\times (x_1^2+x_2^2))^2)-0.7}}

    其中,粒子数为50,学习因子均为2,惯性权重取值[0.6,0.8],迭代步数为100.

    建立目标函数:

    function y = AdaptFunc(x)
        y = ((sin(x(1)^2+x(2)^2))^2-cos(x(1)^2+x(2)^2)+1)/((1+0.1*(x(1)^2+x(2)^2))^2)-0.7;
    end
    

    运行:

    [xm,fv] = PSO_adaptation(@AdaptFunc,50,2,2,0.8,0.6,100,2)
    

    在这里插入图片描述

    10.线性递减权重法

     function [ xm,fv ] = PSO_lin(fitness,N,c1,c2,wmax,wmin,M,D)
    format long ;
    %给定初始化条件
    % fitness:适应度函数
    % N:       初始化种群数目
    % c1:      个体最优化学习因子
    % c2:      整体最优化学习因子
    % wmax:    惯性权重最大值
    % wmin:    惯性权重最小值
    % M:       最大迭代次数      
    % D:       搜索空间的维数
    % xm:      最佳个体
    % fv:      适应度值
     
    %初始化种群个体%
    for i = 1:N
        for j = 1:D
            x(i,j) = randn ;  %随机初始化位置
            v(i,j) = randn ;  %随机初始化速度
        end
    end
     
    %先计算各个粒子的适应度,并初始化个体最优解pi和整体最优解pg %
    %初始化pi %
    for i = 1:N
        p(i) = fitness(x(i,:)) ;
        y(i,:) = x(i,:) ;
    end
    %初始化pg %
    pg = x(N,:) ;
    %得到初始的全局最优pg %
    for i = 1:(N-1)
        if fitness(x(i,:)) < fitness(pg)
            pg = x(i,:) ;
        end
    end
     
    %主循环函数,进行迭代,直到达到精度的要求 %
    for t = 1:M
        for i = 1:N    %更新函数,其中v是速度向量,x为位置,i为迭代特征
            w = wmax-(t-1)*(wmax-wmin)/(M-1)
            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,:)) < p(i)
                p(i) = fitness(x(i,:)) ;
                y(i,:) = x(i,:) ;
            end
            if p(i) < fitness(pg)
                pg = y(i,:) ;
            end
        end
        Pbest(t) = fitness(pg) ;
    end
     
    %给出最后的计算结果 %
    xm = pg' ;
    fv = fitness(pg) ;
    

    11. 基于杂交(遗传算法)的算法

     function [ xm,fv ] = PSO_breed(fitness,N,c1,c2,w,bc,bs,M,D)
    format long ;
    %给定初始化条件
    % fitness:适应度函数
    % N:       初始化种群数目
    % c1:      个体最优化学习因子
    % c2:      整体最优化学习因子
    % w:       惯性权重
    % bc:      杂交概率
    % bs:      杂交池的大小比率
    % M:       最大迭代次数      
    % D:       搜索空间的维数
    % xm:      最佳个体
    % fv:      适应度值
     
    %初始化种群个体%
    for i = 1:N
        for j = 1:D
            x(i,j) = randn ;  %随机初始化位置
            v(i,j) = randn ;  %随机初始化速度
        end
    end
     
    %先计算各个粒子的适应度,并初始化个体最优解pi和整体最优解pg %
    %初始化pi %
    for i = 1:N
        p(i) = fitness(x(i,:)) ;
        y(i,:) = x(i,:) ;
    end
    %初始化pg %
    pg = x(N,:) ;
    %得到初始的全局最优pg %
    for i = 1:(N-1)
        if fitness(x(i,:)) < fitness(pg)
            pg = x(i,:) ;
        end
    end
     
    %主循环函数,进行迭代,直到达到精度的要求 %
    for t = 1:M
        for i = 1:N    %更新函数,其中v是速度向量,x为位置,i为迭代特征
            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,:)) < p(i)
                p(i) = fitness(x(i,:)) ;
                y(i,:) = x(i,:) ;
            end
            if p(i) < fitness(pg)
                pg = y(i,:) ;
            end
            r1 = rand() ;
            if r1 < bc
                numPool = round(bs*N) ;    %杂交池中随机选取numPool个种群%
                PoolX = x(1:numPool,:) ;   %杂交池中的初始杂交父辈位置%
                PoolVX = v(1:numPool,:) ;  %杂交池中的初始杂交父辈速度%
                for i = 1:numPool
                    seed1 = floor(rand()*(numPool-1))+1 ;   %得到速度和位置的初始种子%
                    seed2 = floor(rand()*(numPool-1))+1 ;
                    pb = rand() ;
                    childxl(i,:) = pb*PoolX(seed1,:)+(1-pb)*PoolX(seed2,:) ;   %子代的速度和位置计算
                    childvl(i,:) = (pb*PoolVX(seed1,:)+pb*PoolVX(seed2,:))*norm(pb*PoolVX(seed1,:))/norm(pb*PoolVX(seed1,:)+pb*PoolVX(seed2,:)) ;
                end
                x(1:numPool,:) = childxl ;
                v(1:numPool,:) = childvl ;
            end
        end
    end
     
    %给出最后的计算结果 %
    xm = pg' ;
    fv = fitness(pg) ;
    

    12. 基于自然选择

     function [xm,fv]=PSO_nature(fitness,N,c1,c2,w,M,D)
    % fitness:待优化的目标函数;
    % N:粒子数目;
    % c1:学习因子1;
    % c2:学习因子2;
    % w:惯性权重;
    % M:最大迭代次数;
    % D:自变量的个数;
    % xm:目标函数取最小值时的自变量值;
    % fv:目标函数的最小值。
    format long;
    for i=1:N
        for j=1:D
            x(i,j)=randn;   %随机初始化位置
            v(i,j)=randn;   %随机初始化速度
        end
    end
    for i=1:N
        p(i)=fitness(x(i,:));
        y(i,:)=x(i,:);
    end
    pg=x(N,:);    %pg为全局最优
    for i=1:(N-1)
        if fitness(x(i,:))
            pg=x(i,:);
        end
    end
    for t=1:M
        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,:);
            fx(i)=fitness(x(i,:));
            if fx(i)
                p(i)=fx(i);
                y(i,:)=x(i,:);
            end
            if p(i)
                pg=y(i,:);
            end
        end
        [sortf,sortx]=sort(fx);     %将所有的粒子按适应值排序
        exIndex=round((N-1)/2);
        x(sortx((N-exIndex+1):N))=x(sortx(1:exIndex));%将最好的一半粒子的位置替换掉最差的一半
        v(sortx((N-exIndex+1):N))=v(sortx(1:exIndex));%将最好的一半粒子的速度替换掉最差的一半
    end
    xm=pg';
    fv=fitness(pg);
    

    13.基于模拟退火

    function [xm,fv]=PSO_lamda(fitness,N,c1,c2,lamda,M,D)
    % fitness:待优化的目标函数;
    % N:粒子数目;
    % c1:学习因子1;
    % c2:学习因子2;
    % lamda:退火常数;
    % M:最大迭代次数;
    % D:自变量的个数;
    % xm:目标函数取最小值时的自变量值;
    % fv:目标函数的最小值。
    format long;
    for i=1:N
        for j=1:D
            x(i,j)=randn;   %随机初始化位置
            v(i,j)=randn;   %随机初始化速度
        end
    end
    for i=1:N
        p(i)=fitness(x(i,:));
        y(i,:)=x(i,:);
    end
    pg=x(N,:);    %pg为全局最优
    for i=1:(N-1)
        if fitness(x(i,:))
            pg=x(i,:);
        end
    end
    T=-fitness(pg)/log(0.2);    %初始温度
    for t=1:M
        groupFit=fitness(pg);
        for i=1:N           %当前温度下各个pi的适应值
            Tfit(i)=exp(-(p(i)-groupFit)/T);
        end
        SumTfit=sum(Tfit);
        Tfit=Tfit/SumTfit;
        pBet=rand();
        for i=1:N   %用轮盘赌策略确定全局最优的某个替代值
            ComFit(i)=sum(Tfit(1:i));
            if pBet<=ComFit(i)
                pg_plus=x(i,:);
                break;
            end
        end
        C=c1+c2;
       ksi=2/abs(2-C-sqrt(C^2-4*C));  %速度压缩因子
       for i=1:N
           v(i,:)=ksi*(v(i,:)+c1*rand*(y(i,:)-x(i,:))+c2*rand*(pg_plus-x(i,:)));
           x(i,:)=x(i,:)+v(i,:);
           if fitness(x(i,:))
               p(i)=fitness(x(i,:));
               y(i,:)=x(i,:);
           end
           if p(i)
               pg=y(i,:);
           end
       end
       T=T*lamda;
       Pbest(t) = fitness(pg) ;
    end   
    xm=pg';
    fv=fitness(pg);
    

    14. MATLAB粒子群工具箱

    添加工具箱的具体步骤就不在这里说了,网上有很多。

    例3:计算如下函数的最小值:

    z=0.4(x2)2+0.3(y4)20.7,x[40,40],y[40,40]z = 0.4*(x-2)^2 + 0.3 * (y-4)^2 -0.7, x\in[-40,40] , y\in[-40,40]

    • 定义待优化的MATLAB代码:

      function z = pso_func(in)
      n = size(in);
      x = in(:,1);
      y = in(:,2);
      nx = n(1);
      for i=1:nx
          temp = 0.4*(x(i)-2)^2+0.3*(y(i)-4)^2-0.7;
          z(i,:) = temp;
      end
      
    • 调用PSO算法的核心函数:pso_Trelea_vectorized

      clear
      clc
      x_range = [-40,40];
      y_range = [-40,40];
      range = [x_range;y_range];
      Max_V = 0.2*(range(:,2)-range(:,1));
      n = 2;
      pso_Trelea_vectorized('pso_func',n,Max_V,range)
      

    执行即可得到答案。

    在PSO算法函数pso_Trelea_vectorized173行中,PSO参数设置如下:

    Pdef = [100 2000 24 2 2 0.9 0.4 1500 1e-25 250 NaN 0 1];
    
    • 100:MATLAB命令窗口进行显示的间隔数
    • 2000:最大迭代次数
    • 24:初始化种子数,种子数越多,越有可能收敛到全局最优值,但算法收敛速度慢
    • 2:算法的加速度参数,分别影响局部最优值和全局最优值,一般不需要修改
    • 0.9和0.4为初始时刻和收敛时刻的加权值,一般不需要修改
    • 1500:迭代次数超过此值时,加权值取其最小
    • 1e-25:算法终止条件之一,当两次迭代中对应的种群最优值小于此阈值时,算法停止
    • 250:算法终止条件之一,取NaN时表示为非约束下的优化问题(即没有附加约束方程)
    • 0:制定采用何种PSO类型,0表示通常的PSO算法
    • 1:说明是否指定种子,0表示随机产生种子,1表示用户自行产生种子
    展开全文
  • 最优化算法之粒子群算法(PSO)

    万次阅读 多人点赞 2018-08-03 10:26:45
    一、粒子群算法的概念   粒子群优化算法(PSO:Particle swarm optimization) 是一种进化计算技术(evolutionary computation)。源于对鸟群捕食的行为研究。粒子群优化算法的基本思想:是通过群体中个体之间的...

    一、粒子群算法的概念

      粒子群优化算法(PSO:Particle swarm optimization) 是一种进化计算技术(evolutionary computation)。源于对鸟群捕食的行为研究。粒子群优化算法的基本思想:是通过群体中个体之间的协作和信息共享来寻找最优解.
      PSO的优势:在于简单容易实现并且没有许多参数的调节。目前已被广泛应用于函数优化、神经网络训练、模糊系统控制以及其他遗传算法的应用领域。

    二、粒子群算法分析

    1、基本思想

      粒子群算法通过设计一种无质量的粒子来模拟鸟群中的鸟,粒子仅具有两个属性:速度和位置,速度代表移动的快慢,位置代表移动的方向。每个粒子在搜索空间中单独的搜寻最优解,并将其记为当前个体极值,并将个体极值与整个粒子群里的其他粒子共享,找到最优的那个个体极值作为整个粒子群的当前全局最优解,粒子群中的所有粒子根据自己找到的当前个体极值和整个粒子群共享的当前全局最优解来调整自己的速度和位置。下面的动图很形象地展示了PSO算法的过程:
    这里写图片描述

    2、更新规则

      PSO初始化为一群随机粒子(随机解)。然后通过迭代找到最优解。在每一次的迭代中,粒子通过跟踪两个“极值”(pbest,gbest)来更新自己。在找到这两个最优值后,粒子通过下面的公式来更新自己的速度和位置。
    这里写图片描述
    公式(1)的第一部分称为【记忆项】,表示上次速度大小和方向的影响;公式(1)的第二部分称为【自身认知项】,是从当前点指向粒子自身最好点的一个矢量,表示粒子的动作来源于自己经验的部分;公式(1)的第三部分称为【群体认知项】,是一个从当前点指向种群最好点的矢量,反映了粒子间的协同合作和知识共享。粒子就是通过自己的经验和同伴中最好的经验来决定下一步的运动。以上面两个公式为基础,形成了PSO的标准形式
    这里写图片描述
    公式(2)和 公式(3)被视为标准PSO算法

    3、PSO算法的流程和伪代码

    这里写图片描述

    4、PSO算法举例

    这里写图片描述
    这里写图片描述

    5、PSO算法的demo

    #include <iostream>
    #include <vector>
    #include <cmath>
    #include <map>
    #include <algorithm>
    #include <random>
    #include <ctime>
    #include <Eigen/Dense>
    using namespace Eigen;
    using namespace std;
    
    const int dim = 1;//维数
    const int p_num = 10;//粒子数量
    const int iters = 100;//迭代次数
    const int inf = 999999;//极大值
    const double pi = 3.1415;
    //定义粒子的位置和速度的范围
    const double v_max = 4;
    const double v_min = -2;
    const double pos_max = 2;
    const double pos_min = -1;
    //定义位置向量和速度向量
    vector<double> pos;
    vector<double> spd;
    //定义粒子的历史最优位置和全局最优位置
    vector<double> p_best;
    double g_best;
    //使用eigen库定义函数值矩阵和位置矩阵
    Matrix<double, iters, p_num> f_test;
    Matrix<double, iters, p_num> pos_mat;
    
    //定义适应度函数
    double fun_test(double x)
    {
        double res = x * x + 1;
        return res;
    }
    
    //初始化粒子群的位置和速度
    void init()
    {
        //矩阵中所有元素初始化为极大值
        f_test.fill(inf);
        pos_mat.fill(inf);
        //生成范围随机数
        static std::mt19937 rng;
        static std::uniform_real_distribution<double> distribution1(-1, 2);
        static std::uniform_real_distribution<double> distribution2(-2, 4);
        for (int i = 0; i < p_num; ++i)
        {
            pos.push_back(distribution1(rng));
            spd.push_back(distribution2(rng));
        }
        vector<double> vec;
        for (int i = 0; i < p_num; ++i)
        {
            auto temp = fun_test(pos[i]);//计算函数值
            //初始化函数值矩阵和位置矩阵
            f_test(0, i) = temp;
            pos_mat(0, i) = pos[i];
            p_best.push_back(pos[i]);//初始化粒子的历史最优位置
        }
        std::ptrdiff_t minRow, minCol;
        f_test.row(0).minCoeff(&minRow, &minCol);//返回函数值矩阵第一行中极小值对应的位置
        g_best = pos_mat(minRow, minCol);//初始化全局最优位置
    }
    
    void PSO()
    {
        static std::mt19937 rng;
        static std::uniform_real_distribution<double> distribution(0, 1);
        for (int step = 1; step < iters; ++step)
        {
            for (int i = 0; i < p_num; ++i)
            {
                //更新速度向量和位置向量
                spd[i] = 0.5 * spd[i] + 2 * distribution(rng) * (p_best[i] - pos[i]) +
                    2 * distribution(rng) * (g_best - pos[i]);
                pos[i] = pos[i] + spd[i];
                //如果越界则取边界值
                if (spd[i] < -2 || spd[i] > 4)
                    spd[i] = 4;
                if (pos[i] < -1 || pos[i] > 2)
                    pos[i] = -1;
                //更新位置矩阵
                pos_mat(step, i) = pos[i];
            }
            //更新函数值矩阵
            for (int i = 0; i < p_num; ++i)
            {
                auto temp = fun_test(pos[i]);
                f_test(step, i) = temp;
            }
            for (int i = 0; i < p_num; ++i)
            {
                MatrixXd temp_test;
                temp_test = f_test.col(i);//取函数值矩阵的每一列
                std::ptrdiff_t minRow, minCol;
                temp_test.minCoeff(&minRow, &minCol);//获取每一列的极小值对应的位置
                p_best[i] = pos_mat(minRow, i);//获取每一列的极小值,即每个粒子的历史最优位置
            }
            g_best = *min_element(p_best.begin(), p_best.end());//获取全局最优位置
        }
        cout << fun_test(g_best);
    }
    
    int main()
    {
        init();
        PSO();
        system("pause");
        return 0;
    }

    参考:https://blog.csdn.net/myarrow/article/details/51507671
    https://blog.csdn.net/google19890102/article/details/30044945
    https://wenku.baidu.com/view/65c600b9294ac850ad02de80d4d8d15abe230048.html
    https://blog.csdn.net/darin1997/article/details/80675933

    展开全文
  • <div class='particle-network-animation'></div>
  • 粒子滤波代码

    千次下载 热门讨论 2014-11-15 12:00:39
    压缩包中有三个粒子滤波的演示程序,一个滤波,一个目标跟踪,一个机器人定位。关于效果,大家可以先看看http://blog.csdn.net/heyijia0327/article/details/41142679。再决定是否下载。
  • Cesium粒子系统、火焰效果、喷泉效果 前言 Cesium中可以使用粒子系统来实现现实生活中的一些效果,比如喷泉、火焰等效果 实现效果 实现思路 通过Cesium自带的粒子系统实现 关键代码 // 火焰粒子标绘类 import ...

    Cesium粒子系统、火焰效果、喷泉效果

    前言

    Cesium中可以使用粒子系统来实现现实生活中的一些效果,比如喷泉、火焰等效果。

    实现效果

    在这里插入图片描述

    实现思路

    通过Cesium自带的粒子系统实现

    关键代码

    // 火焰粒子标绘类
    import ParticlePlotBase from "../PlotBase"
    import PlotTypes from "../PlotTypes"
    
    export default class FirePlot extends ParticlePlotBase {
        constructor(viewer, geoFeature) {
            super(viewer, geoFeature);
    
            this.properties.plotType = PlotTypes.FIRE;
            this.properties.plotName = "火焰";
            this.style = geoFeature.properties.style || this.getDefaultStyle();
            this.properties.style = this.style;
            this.init();
        }
    
        init() {
            //需要一个entity提供位置信息
            this.entity = this.viewer.entities.add({
                position: this.position,
            });
            this.particleSystem = this.createParticleSystem();
            this.viewer.scene.primitives.add(this.particleSystem);
            this.addEvent();
        }
    
        //添加事件
        addEvent() {
            this.emitterModelMatrix = new Cesium.Matrix4();
            this.translation = new Cesium.Cartesian3();
            this.rotation = new Cesium.Quaternion();
            this.hpr = new Cesium.HeadingPitchRoll();
            this.trs = new Cesium.TranslationRotationScale();
            this.viewer.scene.preUpdate.addEventListener(this.preUpdateEvent, this);
        }
    
        removeEvent() {
            this.viewer.scene.preUpdate.removeEventListener(this.preUpdateEvent, this);
            this.emitterModelMatrix = undefined;
            this.translation = undefined;
            this.rotation = undefined;
            this.hpr = undefined;
            this.trs = undefined;
        }
    
        //场景渲染事件
        preUpdateEvent(scene, time) {
            this.particleSystem.modelMatrix = this.entity.computeModelMatrix(time, new Cesium.Matrix4());
            this.hpr = Cesium.HeadingPitchRoll.fromDegrees(0.0, 0.0, 0.0, this.hpr);
            this.trs.translation = Cesium.Cartesian3.fromElements(0, 0, 0, this.translation);
            this.trs.rotation = Cesium.Quaternion.fromHeadingPitchRoll(this.hpr, this.rotation);
            this.particleSystem.emitterModelMatrix = Cesium.Matrix4.fromTranslationRotationScale(this.trs, this.emitterModelMatrix);
        }
    
        //创建粒子对象
        createParticleSystem() {
            return new Cesium.ParticleSystem({
                image: this.style.fireImage,
                startColor: new Cesium.Color(1, 1, 1, 1),
                endColor: new Cesium.Color(0.5, 0, 0, 0),
    
                startScale: this.style.startScale,
                endScale: this.style.endScale,
                minimumParticleLife: this.style.minimumParticleLife,
                maximumParticleLife: this.style.maximumParticleLife,
                minimumSpeed: this.style.minimumSpeed,
                maximumSpeed: this.style.maximumSpeed,
                imageSize: new Cesium.Cartesian2(this.style.particleSize, this.style.particleSize),
                emissionRate: this.style.emissionRate,
    
                lifetime: 16.0,
                loop: true,
                emitter: new Cesium.ConeEmitter(Cesium.Math.toRadians(45.0)),
                sizeInMeters: true,
            });
        }
    
        //移除
        remove() {
            this.removeEvent(); //清除事件
            this.viewer.scene.primitives.remove(this.particleSystem); //删除粒子对象
            this.viewer.entities.remove(this.entity); //删除entity
        }
    
        updateStyle() {
            this.particleSystem.startScale = this.style.startScale;
            this.particleSystem.endScale = this.style.endScale;
            this.particleSystem.minimumParticleLife = this.style.minimumParticleLife;
            this.particleSystem.maximumParticleLife = this.style.maximumParticleLife;
            this.particleSystem.minimumSpeed = this.style.minimumSpeed;
            this.particleSystem.maximumSpeed = this.style.maximumSpeed;
            this.particleSystem.imageSize = new Cesium.Cartesian2(this.style.particleSize, this.style.particleSize);
            this.particleSystem.emissionRate = this.style.emissionRate;
        }
    
        //默认样式信息
        getDefaultStyle() {
            return {
                fireImage: "../../../static/images/effects/fire.png",
                startScale: 3,
                endScale: 1.5,
                minimumParticleLife: 1.5,
                maximumParticleLife: 1.8,
                minimumSpeed: 7,
                maximumSpeed: 9,
                particleSize: 2,
                emissionRate: 200,
            }
        }
    }
    
    // 喷泉粒子标绘类
    import ParticlePlotBase from "../PlotBase"
    import PlotTypes from "../PlotTypes"
    
    export default class FountainPlot extends ParticlePlotBase {
        constructor(viewer, geoFeature) {
            super(viewer, geoFeature);
            this.properties.plotType = PlotTypes.FOUNTAIN;
            this.properties.plotName = "火焰";
            this.style = geoFeature.properties.style || this.getDefaultStyle();
            this.properties.style = this.style;
            this.init();
        }
    
        init() {
            //需要一个entity提供位置信息
            this.entity = this.viewer.entities.add({
                position: this.position,
            });
            this.particleSystem = this.createParticleSystem();
            this.viewer.scene.primitives.add(this.particleSystem);
            this.addEvent();
        }
    
        //添加事件
        addEvent() {
            this.emitterModelMatrix = new Cesium.Matrix4();
            this.translation = new Cesium.Cartesian3();
            this.rotation = new Cesium.Quaternion();
            this.hpr = new Cesium.HeadingPitchRoll();
            this.trs = new Cesium.TranslationRotationScale();
            this.viewer.scene.preUpdate.addEventListener(this.preUpdateEvent, this);
        }
    
        removeEvent() {
            this.viewer.scene.preUpdate.removeEventListener(this.preUpdateEvent, this);
            this.emitterModelMatrix = undefined;
            this.translation = undefined;
            this.rotation = undefined;
            this.hpr = undefined;
            this.trs = undefined;
        }
    
        //场景渲染事件
        preUpdateEvent(scene, time) {
            this.particleSystem.modelMatrix = this.entity.computeModelMatrix(time, new Cesium.Matrix4());
            this.hpr = Cesium.HeadingPitchRoll.fromDegrees(0.0, 0.0, 0.0, this.hpr);
            this.trs.translation = Cesium.Cartesian3.fromElements(0, 0, 0, this.translation);
            this.trs.rotation = Cesium.Quaternion.fromHeadingPitchRoll(this.hpr, this.rotation);
            this.particleSystem.emitterModelMatrix = Cesium.Matrix4.fromTranslationRotationScale(this.trs, this.emitterModelMatrix);
        }
    
        //创建粒子对象
        createParticleSystem() {
            this.gravityScratch = new Cesium.Cartesian3();
            return new Cesium.ParticleSystem({
                image: this.style.fountainImage,
                startColor: new Cesium.Color(1, 1, 1, 0.6),
                endColor: new Cesium.Color(0.80, 0.86, 1, 0.4),
                startScale: this.style.startScale,
                endScale: this.style.endScale,
                minimumParticleLife: this.style.minimumParticleLife,
                maximumParticleLife: this.style.maximumParticleLife,
                minimumSpeed: this.style.minimumSpeed,
                maximumSpeed: this.style.maximumSpeed,
                imageSize: new Cesium.Cartesian2(this.style.particleSize, this.style.particleSize),
                emissionRate: this.style.emissionRate,
                lifetime: 16.0,
                //粒子发射器
                emitter: new Cesium.CircleEmitter(0.2),
                updateCallback: (p, dt) => {
                    return this.applyGravity(p, dt);
                },
                sizeInMeters: true,
                performance: false,
            });
        }
    
        applyGravity(p, dt) {
            // We need to compute a local up vector for each particle in geocentric space. 
            Cesium.Cartesian3.normalize(p.position, this.gravityScratch);
            Cesium.Cartesian3.multiplyByScalar(this.gravityScratch, this.style.gravity * dt, this.gravityScratch);
            p.velocity = Cesium.Cartesian3.add(p.velocity, this.gravityScratch, p.velocity);
        }
    
        updateStyle() {
    
        }
    
        //移除
        remove() {
            this.removeEvent(); //清除事件
            this.viewer.scene.primitives.remove(this.particleSystem); //删除粒子对象
            this.viewer.entities.remove(this.entity); //删除entity
        }
    
        //默认样式信息
        getDefaultStyle() {
            return {
                fountainImage: "../../../static/images/effects/fountain.png",
                emissionRate: 40.0,
                gravity: -3.5,
                minimumParticleLife: 6,
                maximumParticleLife: 7,
                minimumSpeed: 9,
                maximumSpeed: 9.5,
                startScale: 1,
                endScale: 7,
                particleSize: 1,
            }
        }
    }
    

    详情参见 Cesium实战专栏

    展开全文
  • 粒子群优化中的粒子模拟

    千次阅读 2020-12-04 11:14:04
    通过此代码,可以在“粒子群优化”中直观地查看粒子的运动。 代码获取
  • 粒子滤波推导pdf

    热门讨论 2017-12-28 15:57:23
    粒子滤波推导的博客的pdf版,详细推导了粒子滤波的由来,并且有例程代码。
  • 粒子滤波

    千次阅读 2019-01-23 15:37:16
    1. 简介 粒子滤波是一种滤波算法。 基本原理:随机选取预测域的 ...此算法存在的问题是:粒子数量越多,计算越精确,但计算量也会增加,且随着迭代,有些粒子权重变得很小,导致粒子枯竭。 滤波算法 适用范围 ...
  • threejs粒子粒子系统

    2019-10-16 11:27:06
    粒子粒子系统1. 粒子的创建2. 粒子系统3. 用HTML5画布格式化粒子(1) 在CanvasRenderer类里使用HTML5画布(2) 在WebGLRenderer中使用HTML5画布4. 使用纹理格式化粒子(1) 单个材质(雨滴为例)(2) 多个材质...
  • 粒子群算法

    2016-12-02 16:38:22
    粒子群算法:java和matlab实现
  • 粒子系统

    千次阅读 2015-02-07 13:49:52
    Cocos2d-x引擎中就为我们提供了强大的粒子系统,以下是粒子系统的继承关系图: 粒子属性 一个强大的粒子系统它必然具备了多种多样的属性,这样才能配置出多样的粒子。下面就来看看粒子系统的
  • 量子粒子群算法与基础粒子群算法matlab程序,里面包含注释及matlab程序,可以运行。其中pdf文件为量子粒子群算法讲解
  • 粒子效果

    2020-03-11 14:44:37
    粒子效果 1.基本概念: Duration:粒子发射器,发射粒子的时间。单位为S(秒)。 Looping:是否开启。如果开启了循环,Duration值只要大于最小值0.10即可。 Prewarm:是否开启预热。只有在开启的循环的时候,预热才有...
  • 粒子动画

    千次阅读 2019-05-17 10:27:12
    比起不做而后悔,不如做了再后悔 ——《游戏人生》平常咱们常见的特效: 诸如此类。今天将学习一种特殊的特效——“粒子...粒子系统粒子系统是众多粒子的集合。一般具有具有粒子的更新,显示,销毁及其创建粒子
  • window.addEventListener("load", init); function init() { let rot = 0; // 角度 const renderer = new THREE.WebGLRenderer({ canvas: document.getElementById("canvas"), alpha: true ...
  • 本文提供粒子群算法简介和一个算法举例,提供粒子群算法仿真PID的M文件代码及simulink仿真。另外,本文还提供了一种动态simulink仿真方法,可以让M文件和simulink文件之间互相交换数据,实现仿真与程序的反馈,增加...
  • android粒子爆炸

    2015-12-04 11:54:55
    #简介 最近在闲逛的时候,发现了一款**粒子爆炸特效**的控件,觉得比较有意思,效果也不错。 但是代码不好扩展,也就是说如果要提供不同的爆炸效果,需要修改的地方比较多。于是我对源代码进行了一些**重构**,将...
  • 粒子群算法【标准粒子群】

    千次阅读 2019-05-07 22:47:32
    主要介绍粒子群算法基本原理,对标准粒子群算法的MATLAB实现进行了阐述,提出了个人观点。
  • 文章目录一、前言二、最终效果三、制作过程1、导入血管模型2、血管Shader3、血管材质球4、添加碰撞体5、药水粒子四、测试效果五、结束语 一、前言 点关注不迷路,持续输出Unity干货文章。 嗨,大家好,我是新发。 ...
  • 粒子群算法详解

    万次阅读 多人点赞 2016-12-02 16:44:35
    粒子群算法(particleswarm optimization,PSO)由Kennedy和Eberhart在1995年提出,该算法对于Hepper的模拟鸟群(鱼群)的模型进行修正,以使粒子能够飞向解空间,并在最好解处降落,从而得到了粒子群优化算法。...
  • 粒子群算法的matlab实现(一)

    万次阅读 多人点赞 2017-07-04 15:45:39
    粒子群算法(Particle Swarm Optimization,PSO)是20世纪90年代兴起的一门学科,因其概念简明、实现方便、收敛速度快而为人所知。粒子群算法的基本思想是模拟鸟群随机搜寻食物的捕食行为,鸟群通过自身经验和种群...
  • 粒子以及粒子间相互作用

    千次阅读 2017-12-28 22:27:56
    严格地说,基本粒子是不能再分解为任何组成部分的粒子。在这一定义下,只有夸克和轻子两种基本粒子。但是,虽然质子和中子由夸克组成,这两类重子都不可能分解为它们的夸克成分,因为独立的夸克是不能存在的。所以,...
  • 粒子裂变

    千次阅读 2017-11-19 17:29:26
    每秒钟内一个α粒子可以产生3个β粒子,而一个β粒子可以产生1个α粒子和2个β粒子。若在t=0时刻反应堆中有一个α粒子,求t时刻反应堆中分别有多 少个α粒子和β粒子。 二、源代码 #include int main(){ int t,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 85,953
精华内容 34,381
关键字:

粒子