• 元胞自动机交通流模拟matlab代码以及数据直接改用就可
• 元胞自动机交通流模型matlab代码，需要自行下载，亲测可用
• MATLAB 元胞自动机交通流双车道，包括脚本文件和函数文件
• 支持车道数量变化，有跟车换道模型，方便更改参数，可以用于元胞自动机的学习 支持车道数量变化，有跟车换道模型，方便更改参数，可以用于元胞自动机的学习
• 元胞自动机 交通流 matlab 包含了主程序，以及一些函数
• 元胞自动机交通流模型matlab代码，双车道模型，靠右行驶模型，代码很容易修改成其他相关模型。
• 基于matlab实现的元胞自动机模拟仿真实现的交通流源码，可用于研究交通堵塞和元胞自动机的学习
• 元胞自动机交通流模型 matlab 代码。 元胞自动机交通流模型matlab代码，双车道模型，靠右行驶模型，代码很容易修改成其他相关模型。 元胞自动机 交通流 matlab
• 元胞自动机NaSch模型MATLAB代码。交通流元胞自动机NaSch模型仿真,输出时空图 元胞自动机 MATLAB
• Matlab Traffic Flow Model based on Cellular Automata (CA)Matlab Traffic Flow Model based on Cellular Automata (CA).A cellular automaton (pl. cellular automata, abbrev. CA) is a discrete model studied ...

Matlab Traffic Flow Model based on Cellular Automata (CA)
Matlab Traffic Flow Model based on Cellular Automata (CA).
A cellular automaton (pl. cellular automata, abbrev. CA) is a discrete model studied in computability theory, mathematics, physics, complexity science, theoretical biology and microstructure modeling. Cellular automata are also called cellular spaces, tessellation automata, homogeneous structures, cellular structures, tessellation structures, and iterative arrays.[2]
A cellular automaton consists of a regular grid of cells, each in one of a finite number of states, such as on and off (in contrast to a coupled map lattice). The grid can be in any finite number of dimensions. For each cell, a set of cells called its neighborhood is defined relative to the specified cell. An initial state (time t=0) is selected by assigning a state for each cell. A new generation is created (advancing t by 1), according to some fixed rule (generally, a mathematical function) that determines the new state of each cell in terms of the current state of the cell and the states of the cells in its neighborhood. Typically, the rule for updating the state of cells is the same for each cell and does not change over time, and is applied to the whole grid simultaneously, though exceptions are known, such as the stochastic cellular automaton and asynchronous cellular automaton.
The concept was originally discovered in the 1940s by Stanislaw Ulam and John von Neumann while they were contemporaries at Los Alamos National Laboratory. While studied by some throughout the 1950s and 1960s, it was not until the 1970s and Conway's Game of Life, a two-dimensional cellular automaton, that interest in the subject expanded beyond academia. In the 1980s, Stephen Wolfram engaged in a systematic study of one-dimensional cellular automata, or what he calls elementary cellular automata; his research assistant Matthew Cook showed that one of these rules is Turing-complete. Wolfram published A New Kind of Science in 2002, claiming that cellular automata have applications in many fields of science. These include computer processors and cryptography.
The primary classifications of cellular automata as outlined by Wolfram are numbered one to four. They are, in order, automata in which patterns generally stabilize into homogenity, automata in which patterns evolve into mostly stable or oscillating structures, automata in which patterns evolve in a seemingly chaotic fashion, and automata in which patterns become extremely complex and may last for a long time, with stable local structures. This last class are thought to be computationally universal, or capable of simulating a Turing machine. Special types of cellular automata are those which are reversible, in which only a single configuration leads directly to a subsequent one, and totalistic, in which the future value of individual cells depend on the total value of a group of neighboring cells. Cellular automata can simulate a variety of real-world systems, including biological and chemical ones.
For traffic flow in a computer network see traffic flow (computer networking)
For traffic equations in a queueing network see traffic equations
In mathematics and civil engineering, traffic flow is the study of interactions between vehicles, drivers, and infrastructure (including highways, signage, and traffic control devices), with the aim of understanding and developing an optimal road network with efficient movement of traffic and minimal traffic congestion problems.

展开全文
• 自己在Matlab里写的 基于元胞自动机原理对单双道交通流进行仿真 自己在Matlab里写的 基于元胞自动机原理对单双道交通流进行仿真
• 2017年B题代码，启动较慢，需要等待一两分钟，刷新有点瑕疵，pause可更改刷新速度。
• 元胞自动机 NaSch模型及其MATLAB代码 作业要求 根据前面的介绍对NaSch模型编程并进行数值模拟 模型参数取值Lroad=1000p=0.3Vmax=5 边界条件周期性边界 数据统计扔掉前50000个时间步对后50000个时间步进行统计,需给出...
• 元胞自动机(Cellular Automata)，简称CA，也有人译为细胞自动机、点格自动机、分子自动机或单元自动机)。是一时间和空间都离散的动力系统。散布在规则格网 (Lattice Grid)中的每一元胞(Cell)取有限的离散状态，遵循...
• 别看了没用，就是nacsh交通流代码，上传只是不舍得删，也为了自己方便找，不需要看，要看也是看有注释的版本
• 元胞自动机在数学模型中的应用，用matlab进行模拟
• 元胞自动机(cellular automata，CA) 是一种时间、空间、状态都离散，空间相互作用和时间因果关系为局部的网格动力学模型，具有模拟复杂系统时空演化过程的能力，上面是用MATLAB实现元胞自动机的讲解
• 环形交通流一维元胞自动机代码以及可视化，交通中NaSch模型
• 一、元胞自动机简介 1 元胞自动机发展历程 最初的元胞自动机是由冯 · 诺依曼在 1950 年代为模拟生物 细胞的自我复制而提出的. 但是并未受到学术界重视. 1970 年, 剑桥大学的约翰 · 何顿 · 康威设计了一个电脑游戏...
一、元胞自动机简介
1 元胞自动机发展历程 最初的元胞自动机是由冯 · 诺依曼在 1950 年代为模拟生物 细胞的自我复制而提出的. 但是并未受到学术界重视. 1970 年, 剑桥大学的约翰 · 何顿 · 康威设计了一个电脑游戏 “生命游戏” 后, 元胞自动机才吸引了科学家们的注意.
1983 年 S.Wolfram 发表了一系列论文. 对初等元胞机 256 种 规则所产生的模型进行了深入研究, 并用熵来描述其演化行 为, 将细胞自动机分为平稳型, 周期型, 混沌型和复杂型.
2 对元胞自动机的初步认识 元胞自动机（CA）是一种用来仿真局部规则和局部联系的方法。典型的元胞自动机是定义在网格上的，每一个点上的网格代表一个元胞与一种有限的状态。变化规则适用于每一个元胞并且同时进行。典型的变化规则，决定于元胞的状态，以及其（ 4 或 8 ）邻居的状态。
3 元胞的变化规则&元胞状态 典型的变化规则，决定于元胞的状态，以及其（ 4 或 8 ）邻居的状态。
4 元胞自动机的应用 元胞自动机已被应用于物理模拟，生物模拟等领域。
5 元胞自动机的matlab编程 结合以上，我们可以理解元胞自动机仿真需要理解三点。一是元胞，在matlab中可以理解为矩阵中的一点或多点组成的方形块，一般我们用矩阵中的一点代表一个元胞。二是变化规则，元胞的变化规则决定元胞下一刻的状态。三是元胞的状态，元胞的状态是自定义的，通常是对立的状态，比如生物的存活状态或死亡状态，红灯或绿灯，该点有障碍物或者没有障碍物等等。
6 一维元胞自动机——交通规则 定义： 6.1 元胞分布于一维线性网格上. 6.2 元胞仅具有车和空两种状态.  7 二维元胞自动机——生命游戏 定义： 7.1 元胞分布于二维方型网格上. 7.2 元胞仅具有生和死两种状态.  元胞状态由周围八邻居决定. 规则：  骷髅：死亡；笑脸：生存 周围有三个笑脸，则中间变为笑脸 少于两个笑脸或者多于三个，中间则变死亡。
8 什么是元胞自动机 离散的系统: 元胞是定义在有限的时间和空间上的, 并且元 胞的状态是有限. 动力学系统: 元胞自动机的举止行为具有动力学特征. 简单与复杂: 元胞自动机用简单规则控制相互作用的元胞 模拟复杂世界.
9 构成要素  （1）元胞 (Cell)  元胞是元胞自动机基本单元： 状态: 每一个元胞都有记忆贮存状态的功能. 离散: 简单情况下, 元胞只有两种可能状态; 较复杂情况下, 元胞具有多种状态. 更新: 元胞的状态都安照动力规则不断更新. （2）网格 (Lattice) 不同维网格  常用二维网格  （3）邻居 (Neighborhood)  （4）边界 (Boundary)  反射型：以自己作为边界的状态 吸收型：不管边界（车开到边界就消失）
（5）规则（状态转移函数） 定义：根据元胞当前状态及其邻居状况确定下一时刻该元胞状态的动力学函数, 简单讲, 就是一个状态转移函数. 分类 ： 总和型: 某元胞下时刻的状态取决于且仅取决于它所有邻居 的当前状态以及自身的当前状态. 合法型: 总和型规则属于合法型规则. 但如果把元胞自动机 的规则限制为总和型, 会使元胞自动机具有局限性. （6）森林火灾  绿色：树木；红色：火；黑色：空地。 三种状态循环转化： 树：周围有火或者被闪电击中就变成火。 空地：以概率p变为树木 理性分析：红为火；灰为空地；绿是树  元胞三种状态的密度和为1  火转化为空地的密度等于空地转换为树的密度（新长出来的树等于烧没的树）  f是闪电的概率:远远小于树生成的概率；T s m a x T_{smax}T smax ​是一大群树被火烧的时间尺度 程序实现 周期性边界条件 购进啊  其中的数字为编号 构建邻居矩阵  上面矩阵中的数字编号，对应原矩阵相同位置编号的上邻居编号，一 一对应 同样道理：  （7）交通概念 车距和密度  流量方程  守恒方程  时空轨迹（横轴是空间纵轴为时间）  红线横线与蓝色交点表示每个时间车的位置。 如果是竖线则表示车子在该位置对应的时间
宏观连续模型：  最常用的规则：  红色条表示速度是满的。
1 加速规则：不能超过v m a x （ 2 格 / s ） v_{max}（2格/s）v max（2格/s） 2 防止碰撞：不能超过车距
理论分析：  结果分析: 密度与流量  第一个图：横坐标是归一化后的密度，纵坐标是车流量。第二个图：理论值与CA的结果
结果分析: 时空轨迹  中间的深色区域是交通堵塞的区域。
二、部分源代码
clear;
figure('position',[50 132 900 400],'doublebuffer','on')
W = [];
for j=0:7;
B = 6+j; %number booths
L = 6; %number lanes in highway before and after plaza
T = 1; % # hrs to simulate
global plazalength;
plazalength = 101;
plaza = create_plaza(B,L);
set(gcf,'resize','off')
PLAZA=rot90(plaza);
PLAZAA=0.8*ones(40,101,3);
PLAZA(PLAZA==1)=2;
PLAZA(PLAZA==0)=1;
PLAZA(PLAZA==2)=0;
PLAZA(PLAZA~=0&PLAZA~=1)=0.8;
PLAZAA(20-ceil(B/2):21+ceil(B/2),:,1)=PLAZA;
PLAZAA(20-ceil(B/2):21+ceil(B/2),:,2)=PLAZA;
PLAZAA(20-ceil(B/2):21+ceil(B/2),:,3)=PLAZA;
H=image(PLAZAA);
axis off
entry_vector = create_entry(T,L);
waiting_time = 0;
output = 0;
for i = 1:T*1440
plaza = move_forward(plaza); %move cars forward
plaza = new_cars(B, L, plaza, entry_vector(1,i)); %allow new cars to enter
plaza = switch_lanes(plaza); %allow lane changes
waiting_time = waiting_time + compute_wait(plaza); %compute waiting time during timestep i
output = output + compute_output(plaza);
plaza = clear_boundary(plaza);
PLAZA=rot90(plaza);
PLAZA(PLAZA==1)=2;
PLAZA(PLAZA==0)=1;
PLAZA(PLAZA==2)=0;
PLAZA(PLAZA~=0&PLAZA~=1)=0.8;
PLAZAA(20-ceil(B/2):21+ceil(B/2),:,1)=PLAZA;
PLAZAA(20-ceil(B/2):21+ceil(B/2),:,2)=PLAZA;
PLAZAA(20-ceil(B/2):21+ceil(B/2),:,3)=PLAZA;
plaza50=PLAZAA(:,50,1);plaza50(plaza50==1)=0;PLAZAA(:,50,2)=plaza50;PLAZAA(:,50,3)=plaza50;
set(H,'CData',PLAZAA);
set(gcf,'position',[50 132 900 400])
pause(0.01)
end
plaza;
W=[W waiting_time]
end
function new = move_forward(old)
new = old; %create new plaza looking same as old
[L, W] = size(new); %get its dimensions
prob = .7;
delay = 3;
%%%DOWNSTREAM OF TOLL BOOTHS %%%
for i = (L-1):-1:((L - 1)/2 + 1)
for j = 1:W
if new(i,j) == 1
if new(i+1, j) ~= 0
new(i,j) = -2;
end
if new(i+1, j) == 0
if prob >= rand
new(i,j) = 0;
new(i+1, j) = 1;
end
end
end
end
end
%%AT TOLL BOOTHS %%
for i = (L-1)/2
for j = 1:W
if new(i,j) > 0
if new(i,j) == delay
new(i,j) = 0;
new(i+1,j) = 1;
end
if new(i,j) ~= delay
if new(i,j) ~= 0
new(i,j) = new(i,j) + 1;
end
end
end
end
end
%% UPSTREAM OF TOLL BOOTHS %%
for i = (L-1):-1:1
for j = 1:W
if new(i,j) == 1
if new(i+1, j) ~= 0
new(i,j) = -2;
end
if new(i+1, j) == 0
if prob >= rand
new(i,j) = 0;
new(i+1, j) = 1;
end
end
end
end
end
function plaza = clear_boundary(input)
plaza = input;
[a,b] = size(plaza);
for i = 1:b
if plaza(a,i) > 0
plaza(a,i) = 0;
end
end
function count = compute_output(plaza)
count = 0;
[a, b] = size(plaza);
for j = 1:b
count = count + (plaza(a,j) > 0);
end
function new = switch_lanes(old)
new = old;
prob = 0.8;
x = rand;
y = rand;
[L,W] = size(new);
for i = (L-1):-1:1
for j = 2:(W-1)
if new(i,j) == -2
if x < prob %chance turn will be made
if y > 0.5 %will attempt left
if new(i, j-1) == 0
new(i, j-1) = 1;
new(i, j) = 0;
elseif new(i, j+1) == 0
new(i, j+1) = 1;
new(i,j) = 0;
elseif new(i,j) == -2
new(i,j) = 1;
end
end
if y <= 0.5 %will attempt right
if new(i, j+1) == 0

new(i, j-1) = 1;
new(i,j) = 0;
elseif new(i,j) == -2
new(i,j) = 1;
end
end
end
if x >= prob
new(i,j) = 1;
end
end
end
end

三、运行结果

四、matlab版本及参考文献
1 matlab版本 2014a
2 参考文献 [1] 包子阳,余继周,杨杉.智能优化算法及其MATLAB实例（第2版）[M].电子工业出版社，2016. [2]张岩,吴水根.MATLAB优化算法源代码[M].清华大学出版社，2017. [3]【数学建模】元胞自动机.博主：二进制 人工智能
展开全文
• 包括换道系统，跟驰系统等功能。功能比较齐全，但是大部分程序都是加密的，只能拿来用，不能作为学习资源参考
• 元胞自动机（CA）是一种用来仿真局部规则和局部联系的方法。典型的元胞自动机是定义在网格上的，每一个点上的网格代表一个元胞与一种有限的状态。变化规则适用于每一个元胞并且同时进行。典型的变化规则，决定于元胞...
一、元胞自动机简介
1 元胞自动机发展历程 最初的元胞自动机是由冯 · 诺依曼在 1950 年代为模拟生物 细胞的自我复制而提出的. 但是并未受到学术界重视. 1970 年, 剑桥大学的约翰 · 何顿 · 康威设计了一个电脑游戏 “生命游戏” 后, 元胞自动机才吸引了科学家们的注意.
1983 年 S.Wolfram 发表了一系列论文. 对初等元胞机 256 种 规则所产生的模型进行了深入研究, 并用熵来描述其演化行 为, 将细胞自动机分为平稳型, 周期型, 混沌型和复杂型.
2 对元胞自动机的初步认识 元胞自动机（CA）是一种用来仿真局部规则和局部联系的方法。典型的元胞自动机是定义在网格上的，每一个点上的网格代表一个元胞与一种有限的状态。变化规则适用于每一个元胞并且同时进行。典型的变化规则，决定于元胞的状态，以及其（ 4 或 8 ）邻居的状态。
3 元胞的变化规则&元胞状态 典型的变化规则，决定于元胞的状态，以及其（ 4 或 8 ）邻居的状态。
4 元胞自动机的应用 元胞自动机已被应用于物理模拟，生物模拟等领域。
5 元胞自动机的matlab编程 结合以上，我们可以理解元胞自动机仿真需要理解三点。一是元胞，在matlab中可以理解为矩阵中的一点或多点组成的方形块，一般我们用矩阵中的一点代表一个元胞。二是变化规则，元胞的变化规则决定元胞下一刻的状态。三是元胞的状态，元胞的状态是自定义的，通常是对立的状态，比如生物的存活状态或死亡状态，红灯或绿灯，该点有障碍物或者没有障碍物等等。
6 一维元胞自动机——交通规则 定义： 6.1 元胞分布于一维线性网格上. 6.2 元胞仅具有车和空两种状态.  7 二维元胞自动机——生命游戏 定义： 7.1 元胞分布于二维方型网格上. 7.2 元胞仅具有生和死两种状态.  元胞状态由周围八邻居决定. 规则：  骷髅：死亡；笑脸：生存 周围有三个笑脸，则中间变为笑脸 少于两个笑脸或者多于三个，中间则变死亡。
8 什么是元胞自动机 离散的系统: 元胞是定义在有限的时间和空间上的, 并且元 胞的状态是有限. 动力学系统: 元胞自动机的举止行为具有动力学特征. 简单与复杂: 元胞自动机用简单规则控制相互作用的元胞 模拟复杂世界.
9 构成要素  （1）元胞 (Cell)  元胞是元胞自动机基本单元： 状态: 每一个元胞都有记忆贮存状态的功能. 离散: 简单情况下, 元胞只有两种可能状态; 较复杂情况下, 元胞具有多种状态. 更新: 元胞的状态都安照动力规则不断更新. （2）网格 (Lattice) 不同维网格  常用二维网格  （3）邻居 (Neighborhood)  （4）边界 (Boundary)  反射型：以自己作为边界的状态 吸收型：不管边界（车开到边界就消失）
（5）规则（状态转移函数） 定义：根据元胞当前状态及其邻居状况确定下一时刻该元胞状态的动力学函数, 简单讲, 就是一个状态转移函数. 分类 ： 总和型: 某元胞下时刻的状态取决于且仅取决于它所有邻居 的当前状态以及自身的当前状态. 合法型: 总和型规则属于合法型规则. 但如果把元胞自动机 的规则限制为总和型, 会使元胞自动机具有局限性. （6）森林火灾  绿色：树木；红色：火；黑色：空地。 三种状态循环转化： 树：周围有火或者被闪电击中就变成火。 空地：以概率p变为树木 理性分析：红为火；灰为空地；绿是树  元胞三种状态的密度和为1  火转化为空地的密度等于空地转换为树的密度（新长出来的树等于烧没的树）  f是闪电的概率:远远小于树生成的概率；T s m a x T_{smax}T smax ​是一大群树被火烧的时间尺度 程序实现 周期性边界条件 购进啊  其中的数字为编号 构建邻居矩阵  上面矩阵中的数字编号，对应原矩阵相同位置编号的上邻居编号，一 一对应 同样道理：  （7）交通概念 车距和密度  流量方程  守恒方程  时空轨迹（横轴是空间纵轴为时间）  红线横线与蓝色交点表示每个时间车的位置。 如果是竖线则表示车子在该位置对应的时间
宏观连续模型：  最常用的规则：  红色条表示速度是满的。
1 加速规则：不能超过v m a x （ 2 格 / s ） v_{max}（2格/s）v max（2格/s） 2 防止碰撞：不能超过车距
理论分析：  结果分析: 密度与流量  第一个图：横坐标是归一化后的密度，纵坐标是车流量。第二个图：理论值与CA的结果
结果分析: 时空轨迹  中间的深色区域是交通堵塞的区域。
二、部分源代码
clear all;
clc;
W = 0;
% 每个格子的状态有三种：
% 用1表示车辆，0表示空位，-888表示不可进入区域
for j = 1
B = 6; %收费站的数量
L = 3; %车道数量
T = 23; % 更新时间为24毫秒
global plazalength;%定义全局变量，车道长度
plazalength = 20;
plaza = create_plaza(B,L);%表示元胞空间的状态矩阵
v=plaza;
%====================================================
h = show_plaza(plaza,B,NaN);                        %图像显示
%====================================================
num = 7;%绘图周期
entry_vector = create_entry(T,L);%表示车辆到来数的向量
entry_vector = create_temp_entry(num,30,30);
waiting_time = 0;%等待时间一开始为0
output = 0;
k=1;
%     total_wait = zeros((greenTime+redTime)*num,1);
total_entry = zeros(2*num,1);
total_ac = zeros(2*num,1);
total_traffic_capacity = zeros(2*num,1);
%     total_traffic_density = zeros((redTime+greenTime)*num,1);
cross_point = plazalength-4;
%     average_wait = zeros(2*num,1);
k=1;
for i = 1:5
%         waiting_time = 0;
%         output = 0;
entry = 0;
ac=0;
traffic_capacity = 0;
for xx=1:60
for cc = (plazalength-1):-1:1  %动力系统
for ccc = 2:7
if v(cc,ccc)==1 && rand>0.7
v(cc,ccc)=2;
else if v(cc,ccc)==2 && rand>0.8
v(cc,ccc)=3;
end
end
end
end
[plaza,v,acone] = move_forward(plaza,v); %前进规则
ac = ac + acone;
[plaza,v] = new_cars(plaza,xx,v); %将上面生成的车辆到来情况加到元胞空间矩阵中

[plaza,v] = switch_lanes(plaza,v); %换道规则
%                 %交叉路口来的车辆
%                 [plaza,flag] = newCross_cas(plaza,cross_point);
%计算这个时间步长元胞空间的车辆逗留时间
%waiting_time = waiting_time + compute_wait(plaza); %进行求和求总的时间
%output = output + compute_output(plaza);%每辆车的平均费时，计算离开收费站的总车辆数
%===============================================
h = show_plaza(plaza,B,h);                     %更新图像
drawnow
%===============================================
[plaza,v,flag] = clear_boundary(plaza,v);%移除离开系统的车辆，即将元胞空间中最后一行大于0的设为0
entry = entry + flag;

%                  if plaza((plazalength+1)/2,2) == 1
%                      traffic_capacity = traffic_capacity+1;
%                 end
%                  total_traffic_density(k) = size(find(plaza((plazalength+1)/4:(plazalength+1)/2-1,:)>0),1);
%                 total_wait(k) = waiting_time;
k = k+1;
pause(0.1);
end
% %         total_wait(i) = waiting_time;
%         average_wait(i) = waiting_time/greenTime;
total_entry(i) = entry;
total_ac(i) = ac;
%         total_traffic_capacity(i) = traffic_capacity;
%
%
end
show_plaza(plaza,B,h);
%     W(j+1) = waiting_time/output;
%     xlabel({strcat('B = ',num2str(B)), ...
%         strcat('mean cost time = ', num2str(round(W(j+1))))})
%     count = 1;
%     average_traffic_density = zeros(2*num,1);
%     for i=1:num
%         average_traffic_density(count) = sum(total_traffic_density((i-1)*(greenTime+redTime)+1:(i-1)*(greenTime+redTime)+greenTime));
%         count = count+1;
%         average_traffic_density(count) = sum(total_traffic_density((i-1)*(greenTime+redTime)+1+greenTime:(i-1)*(greenTime+redTime)+greenTime+redTime));
%         count = count+1;
%     end
function [plaza,v] = switch_lanes(plaza,v)
%换道规则，当车的前面位置被别的车辆占据时，该车考虑换道
%这种车辆在前进规则中状态已经被标记为-2，车辆以prob进行换道
prob = 0.8;
[L,W] = size(plaza);
for i = (L-1):-1:1
for j = 2:(W-1)
if plaza(i,j) == -2
if rand < prob %概率满足，换道
if rand>0.5
if plaza(i, j+1) == 0
plaza(i,j+1) = 1;
plaza(i,j) = 0;
v(i,j+1) = v(i,j);
v(i,j) = 0;
elseif plaza(i, j-1) == 0
plaza(i, j-1) = 1;
plaza(i,j) = 0;
v(i,j-1) = v(i,j);
v(i,j) = 0;
else
plaza(i,j) = 1;
end
else
if plaza(i, j-1) == 0
plaza(i, j-1) = 1;
plaza(i,j) = 0;
v(i,j-1) = v(i,j);
v(i,j) = 0;
elseif plaza(i, j+1) == 0
plaza(i,j+1) = 1;
plaza(i,j) = 0;
v(i,j+1) = v(i,j);
v(i,j) = 0;
else
plaza(i,j) = 1;
end
end
else
plaza(i,j) = 1;
end
end
end
end

for i = (L-1):-1:1
for j = 2:(W-1)
if plaza(i,j) == -3 && rand >0.5
if plaza(i, j+1) == 0 && j~=W-1
plaza(i,j+1) = 1;
plaza(i,j) = 0;
v(i,j+1) = v(i,j);
v(i,j) = 0;
else
plaza(i,j) = 1;
end
end
end
end

for i = (L-1):-1:1
if plaza(i,5) == -4
if rand < 0.2
if plaza(i, 6) == 0
plaza(i,6) = 1;
plaza(i,5) = 0;
v(i,6) = v(i,5);
v(i,5) = 0;
else
plaza(i,5) = 1;
end
else
plaza(i,5) = 1;
end
end
end


三、运行结果

四、matlab版本及参考文献
1 matlab版本 2014a
2 参考文献 [1] 包子阳,余继周,杨杉.智能优化算法及其MATLAB实例（第2版）[M].电子工业出版社，2016. [2]张岩,吴水根.MATLAB优化算法源代码[M].清华大学出版社，2017. [3]【数学建模】元胞自动机.博主：二进制 人工智能
展开全文
• 本程序根据1992年Nagel和Schreckenberg发表的交通流论文，利用matlab编写。采用周期性边界条件，答案在array矩阵中，希望有所帮助
• 元胞自动机（CA）是一种用来仿真局部规则和局部联系的方法。典型的元胞自动机是定义在网格上的，每一个点上的网格代表一个元胞与一种有限的状态。变化规则适用于每一个元胞并且同时进行。典型的变化规则，决定于元胞...
一、元胞自动机简介
1 元胞自动机发展历程 最初的元胞自动机是由冯 · 诺依曼在 1950 年代为模拟生物 细胞的自我复制而提出的. 但是并未受到学术界重视. 1970 年, 剑桥大学的约翰 · 何顿 · 康威设计了一个电脑游戏 “生命游戏” 后, 元胞自动机才吸引了科学家们的注意.
1983 年 S.Wolfram 发表了一系列论文. 对初等元胞机 256 种 规则所产生的模型进行了深入研究, 并用熵来描述其演化行 为, 将细胞自动机分为平稳型, 周期型, 混沌型和复杂型.
2 对元胞自动机的初步认识 元胞自动机（CA）是一种用来仿真局部规则和局部联系的方法。典型的元胞自动机是定义在网格上的，每一个点上的网格代表一个元胞与一种有限的状态。变化规则适用于每一个元胞并且同时进行。典型的变化规则，决定于元胞的状态，以及其（ 4 或 8 ）邻居的状态。
3 元胞的变化规则&元胞状态 典型的变化规则，决定于元胞的状态，以及其（ 4 或 8 ）邻居的状态。
4 元胞自动机的应用 元胞自动机已被应用于物理模拟，生物模拟等领域。
5 元胞自动机的matlab编程 结合以上，我们可以理解元胞自动机仿真需要理解三点。一是元胞，在matlab中可以理解为矩阵中的一点或多点组成的方形块，一般我们用矩阵中的一点代表一个元胞。二是变化规则，元胞的变化规则决定元胞下一刻的状态。三是元胞的状态，元胞的状态是自定义的，通常是对立的状态，比如生物的存活状态或死亡状态，红灯或绿灯，该点有障碍物或者没有障碍物等等。
6 一维元胞自动机——交通规则 定义： 6.1 元胞分布于一维线性网格上. 6.2 元胞仅具有车和空两种状态.  7 二维元胞自动机——生命游戏 定义： 7.1 元胞分布于二维方型网格上. 7.2 元胞仅具有生和死两种状态.  元胞状态由周围八邻居决定. 规则：  骷髅：死亡；笑脸：生存 周围有三个笑脸，则中间变为笑脸 少于两个笑脸或者多于三个，中间则变死亡。
8 什么是元胞自动机 离散的系统: 元胞是定义在有限的时间和空间上的, 并且元 胞的状态是有限. 动力学系统: 元胞自动机的举止行为具有动力学特征. 简单与复杂: 元胞自动机用简单规则控制相互作用的元胞 模拟复杂世界.
9 构成要素  （1）元胞 (Cell)  元胞是元胞自动机基本单元： 状态: 每一个元胞都有记忆贮存状态的功能. 离散: 简单情况下, 元胞只有两种可能状态; 较复杂情况下, 元胞具有多种状态. 更新: 元胞的状态都安照动力规则不断更新. （2）网格 (Lattice) 不同维网格  常用二维网格  （3）邻居 (Neighborhood)  （4）边界 (Boundary)  反射型：以自己作为边界的状态 吸收型：不管边界（车开到边界就消失）
（5）规则（状态转移函数） 定义：根据元胞当前状态及其邻居状况确定下一时刻该元胞状态的动力学函数, 简单讲, 就是一个状态转移函数. 分类 ： 总和型: 某元胞下时刻的状态取决于且仅取决于它所有邻居 的当前状态以及自身的当前状态. 合法型: 总和型规则属于合法型规则. 但如果把元胞自动机 的规则限制为总和型, 会使元胞自动机具有局限性. （6）森林火灾  绿色：树木；红色：火；黑色：空地。 三种状态循环转化： 树：周围有火或者被闪电击中就变成火。 空地：以概率p变为树木 理性分析：红为火；灰为空地；绿是树  元胞三种状态的密度和为1  火转化为空地的密度等于空地转换为树的密度（新长出来的树等于烧没的树）  f是闪电的概率:远远小于树生成的概率；T s m a x T_{smax}T smax ​是一大群树被火烧的时间尺度 程序实现 周期性边界条件 购进啊  其中的数字为编号 构建邻居矩阵  上面矩阵中的数字编号，对应原矩阵相同位置编号的上邻居编号，一 一对应 同样道理：  （7）交通概念 车距和密度  流量方程  守恒方程  时空轨迹（横轴是空间纵轴为时间）  红线横线与蓝色交点表示每个时间车的位置。 如果是竖线则表示车子在该位置对应的时间
宏观连续模型：  最常用的规则：  红色条表示速度是满的。
1 加速规则：不能超过v m a x （ 2 格 / s ） v_{max}（2格/s）v max（2格/s） 2 防止碰撞：不能超过车距
理论分析：  结果分析: 密度与流量  第一个图：横坐标是归一化后的密度，纵坐标是车流量。第二个图：理论值与CA的结果
结果分析: 时空轨迹  中间的深色区域是交通堵塞的区域。
二、部分源代码
%% lzu
close all ; clear all ;clc

a=rand(200,50);                                  %生成元胞自动机的大小（200，50）200行50列
m=find(a<0.1); n=find(a>0.9);                  %向上，向下的各占10%
aa=zeros(size(a));aa(m)=1;up=aa;
bb=zeros(size(a));bb(n)=3;down=bb;               %初始化元胞  up，down
clear a* m n bb
% 生成 up down
N=nnz(up)+nnz(down);

%%  循环开始的地方
for t=1:10000

up1=[up(2:end,:);up(1,:)];                       %向上走的向上一步，探探前面有没有路  %向下走的不动
c=up+down;
jud=up1+down;
%% 找出相碰处的两种表示
w_z1=find(jud==4);w_z1=w_z1';                                      % 一维位置(都是先下的所在)
[w_zx1,w_zy1]=find(jud==4);a=[w_zx1,w_zy1]';w_zx=w_zx1';w_zy=w_zy1';
%w_z2=[w_zx;w_zy];
clear w_zx1 w_zy1 a                                                % 二维位置
%% 找出相碰的人后面的粒子数
down_z_g=zeros(size(down));
for i=1:length(w_z1)
d_b(i)=0;
x=cutx(w_zx(i));y=w_zy(i);
down_z_g(andx(x),y)=3;
while down(x,y)==3
down_z_g(x,y)=3;
d_b(i)=d_b(i)+1;
x=cutx(x);
end
end
clear x y i
up_z_g=zeros(size(up));
for i=1:length(w_z1)
u_b(i)=0;
x=andx(andx(w_zx(i)));y=w_zy(i);
up_z_g(cutx(x),y)=1;
while up(x,y)==1
up_z_g(x,y)=1;
u_b(i)=u_b(i)+1;
x=andx(x);
end
end
clear x y i
% u_b  向下走的后面跟的个数
% d_b  向上走的后面跟的个数
%[w_z1;w_zx; w_zy ;u_b ;d_b]
%% 找出拐的那串粒子
%% 找出直走的（不包含相碰的后面跟的）
down_d=down;
for i=1:length(w_z1)
x=w_zx(i);y=w_zy(i);
for j=0:d_b(i)
down_d(x,y)=0;
x=cutx(x);
end
end                                                 % down_d (down_directly)直接向下走的粒子
clear x y i j
up_d=up;
for i=1:length(w_z1)
x=andx(w_zx(i));y=w_zy(i);
for j=0:u_b(i)
up_d(x,y)=0;
x=andx(x);
end
end                                                  % up_d (up_directly)直接向上走的粒子
clear x y i j
%f=nnz(up_d)+length(w_zx)+sum(u_b)-nnz(up)
%g=nnz(down_d)+length(w_zy)+sum(d_b)-nnz(down)
%end
%% 两个粒子对头时中间空一个（定义往下走的占了这个空格）
judge=a_down_d+a_up_d;
[ww_zx,ww_zy]=find(judge==4);
for i=1:length(ww_zx)
x=ww_zx(i);y=ww_zy(i);
judge(x,y)=3;
x=andx(x);
while judge(x,y)==1
x=andx(x);
end
judge(x,y)=1;
end
clear i
% judge 里面存放的是 alread 走了的粒子（上下粒子都走了一步）
r_down_d=zeros(size(down)); r_down_d(find(judge==3))=3;      % r_down_d 里面放的是真的直走|了|的
r_up_d=zeros(size(up)); r_up_d(find(judge==1))=1;
%pp=nnz(find(judge==3))+nnz(find(judge==1))-nnz(judge);
%% 找出拐弯的（也包含它后面跟的）(把拐的写进去)
%% 先做向下
n=0;      %拐的串中直走的
down_g=zeros(size(down));
for i=1:length(w_z1)
x=w_zx(i);y=w_zy(i);
up_z_gg=up_z_g; up_z_gg(:,y)=0;
down_z_gg=down_z_g; down_z_gg(:,y)=0;
for j=0:d_b(i)
cc=judge+down_g+up_z_gg+down_z_gg;
if j==0
if y>=2&&y<=49&&cc(x,y+1)==0&&cc(x,y-1)==0&&cc(cutx(x),y-1)==0&&cc(cutx(x),y+1)==0
down_g(x,y+randint*2-1)=3;
elseif y>=2&&y<=49&&cc(x,y+1)==0&&cc(cutx(x),y+1)==0
down_g(x,y+1)=3;
elseif y>=2&&y<=49&&cc(x,y-1)==0&&cc(cutx(x),y-1)==0
down_g(x,y-1)=3;
elseif y==1&&cc(x,y+1)==0&&cc(cutx(x),y+1)==0
down_g(x,y+1)=3;
elseif y==50&&cc(x,y-1)==0&&cc(cutx(x),y-1)==0
down_g(x,y-1)=3;
else
down_g(x,y)=3;
end
end


三、运行结果

四、matlab版本及参考文献
1 matlab版本 2014a
2 参考文献 [1] 包子阳,余继周,杨杉.智能优化算法及其MATLAB实例（第2版）[M].电子工业出版社，2016. [2]张岩,吴水根.MATLAB优化算法源代码[M].清华大学出版社，2017. [3]【数学建模】元胞自动机.博主：二进制 人工智能
展开全文
• Matlab元胞自动机】元胞自动机交通流仿真【含源码 827期】 二、matlab版本及参考文献 1 matlab版本 2014a 2 参考文献 [1]张金珠,任泽民,赵亚伟.基于元胞自动机的开放型城市街区交通流模拟[J]. 河北工业大学学报. ...

...

matlab 订阅