精华内容
下载资源
问答
  • 支持车道数量变化,有跟车换道模型,方便更改参数,可以用于元胞自动机的学习 支持车道数量变化,有跟车换道模型,方便更改参数,可以用于元胞自动机的学习
  • 元胞自动机交通流模拟matlab代码以及数据直接改用就可
  • 元胞自动机(cellular automata,CA) 是一种时间、空间、状态都离散,空间相互作用和时间因果关系为局部的网格动力学模型,具有模拟复杂系统时空演化过程的能力,上面是用MATLAB实现元胞自动机的讲解
  • 2017年B题代码,启动较慢,需要等待一两分钟,刷新有点瑕疵,pause可更改刷新速度。
  • MATLAB 元胞自动机交通流双车道,包括脚本文件和函数文件
  • 元胞自动机交通流模型matlab代码,需要自行下载,亲测可用
  • 基于matlab实现的元胞自动机模拟仿真实现的交通流源码,可用于研究交通堵塞和元胞自动机的学习
  • 包括换道系统,跟驰系统等功能。功能比较齐全,但是大部分程序都是加密的,只能拿来用,不能作为学习资源参考
  • 元胞自动机 NaSch模型及其MATLAB代码 作业要求 根据前面的介绍对NaSch模型编程并进行数值模拟 模型参数取值Lroad=1000p=0.3Vmax=5 边界条件周期性边界 数据统计扔掉前50000个时间步对后50000个时间步进行统计,需给出...
  • 元胞自动机在数学模型中的应用,用matlab进行模拟
  • 元胞自动机(Cellular Automata),简称CA,也有人译为细胞自动机、点格自动机、分子自动机或单元自动机)。是一时间和空间都离散的动力系统。散布在规则格网 (Lattice Grid)中的每一元胞(Cell)取有限的离散状态,遵循...
  • 元胞自动机交通流模型 matlab 代码。 元胞自动机交通流模型matlab代码,双车道模型,靠右行驶模型,代码很容易修改成其他相关模型。 元胞自动机 交通流 matlab
  • 元胞自动机(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]【数学建模】元胞自动机.博主:二进制 人工智能

    展开全文
  • 元胞自动机交通流模型代码(matlab代码)

    千次下载 热门讨论 2015-01-09 13:39:13
    元胞自动机交通流模型matlab代码,双车道模型,靠右行驶模型,代码很容易修改成其他相关模型。
  • 自己在Matlab里写的 基于元胞自动机原理对单双道交通流进行仿真 自己在Matlab里写的 基于元胞自动机原理对单双道交通流进行仿真
  • 元胞自动机NaSch模型MATLAB代码。交通流元胞自动机NaSch模型仿真,输出时空图 元胞自动机 MATLAB
  • 美国数学建模2009年A篇优秀论文,附带MATLAB源程序,解决了于环岛问题的仿真问题! MATLAB解决。 MCM-2009a题论文 答案.rar
  • 环形交通流一维元胞自动机代码以及可视化,交通中NaSch模型
  • 压缩包里含一份介绍元胞自动机及其在交通流问题中应用的PDF, PDF中涉及的大部分图像在文件夹Figure中, PDF中涉及的代码在文件夹Code中. 此外还有一份50页左右的关于使用Matlab中Simulink仿真交通流问题的学术论文.
  • 一、元胞自动机简介 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的结果

    结果分析: 时空轨迹
    在这里插入图片描述
    中间的深色区域是交通堵塞的区域。

    二、部分源代码

    %% lzu
    close all ; clear all ;clc
    
    a=rand(200,50);                                  %生成元胞自动机的大小(2005020050列
    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
    a_down_d=[down_d(end,:);down_d(1:end-1,:)];               % alread_down_directly
    a_up_d=[up_d(2:end,:);up_d(1,:)];                           % alread_down_directly(是假的还要考虑碰头的中间隔一个得情况)
    %% 两个粒子对头时中间空一个(定义往下走的占了这个空格)
    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 包含了主程序,以及一些函数
  • Matlab里写的 基于元胞自动机原理对单道交通流进行仿真

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 182
精华内容 72
关键字:

元胞自动机matlab交通流

matlab 订阅