排队论经典程序MM1代码

合集下载

MM1模型

MM1模型

分组到达时间不是独立和指数分布的,而是一群一群地到达的(即分组有成群的特性)。

而用户发起访问某种网络资源的行为具有独立、随机的泊松特性,即会话到达过程仍服从泊松分布。

通常,网络性能评估的第一步是先进行理论上的评估,而这需要以一种较好的分析模型和分析方法为基础。

被广泛应用的排队论模型是用于分析网络性能最经典的理论之一。

其中,
M/M/1模型是分析分组交换网络性能的主要模型。

当使用M/M/1排队论模型分析网络性能时,
每个资源的利用率ρ=λ/μ,其中λ表示单位时间内到达的分组数,μ表示该资源单位时间内能够完成的分组数;每个处理中的平均分组数l=ρ/(1-ρ)= λ/(λ-μ);
平均系统时间S=1/(μ-λ);
每个处理的平均等待时间W=ρ/(μ-λ)
从这些计算各种性能指标的公可知,对结果影响最大的参数是分组平均到达率λ。

mm1n排队论模型参数

mm1n排队论模型参数

mm1n排队论模型参数
M/M/1 排队论模型是一种简单的排队系统模型,用于分析单一服务台、顾客到达服从泊松分布、服务时间服从指数分布的系统。

在M/M/1 模型中,有三个主要参数:
1. 到达率(λ):表示单位时间内到达系统的顾客数的期望值,服从参数为λ的泊松分布。

到达率决定了系统中的顾客数量变化速率。

2. 服务率(μ):表示单位时间内一个顾客被服务完成的期望值,服从参数为μ的指数分布。

服务率决定了系统中顾客等待服务的速度。

3. 顾客到达和服务时间是独立的:这个条件表明顾客的到达和服务的完成之间没有影响,使得模型更具有现实意义。

通过平衡方程法,可以对M/M/1 模型进行稳态分析,计算出以下几个重要性质:
1. 队长(Ls):表示系统中的顾客数(n)的期望值。

2. 排队长(Lq):表示系统中排队等待服务的顾客数(n)的期望值。

3. 逗留时间(Ws):指一个顾客在系统中的全部停留时间,为期望值。

4. 等待时间(Wq):指顾客在系统中等待服务的時間,为期望值。

了解这些参数后,可以对M/M/1 模型进行评估和优化,以提高系统的效率和服务质量。

M/M/1 模型虽然简单,但在实际应用中具有广泛的价值,如电话交换系统、计算机网络、银行窗口等。

掌握M/M/1 模型的基本原理和分析方法对于学习排队论和实际应用具有重要意义。

排队模型掌握mm1,mmc,mm1k ppt课件

排队模型掌握mm1,mmc,mm1k ppt课件
Ek——k阶爱尔朗分布
GI——一般相互独立的时间间隔分布
G——一般服务时间分布
四、排队模型的数量指标
1、平均队长(Ls): 指在系统中的顾客数(包括正被服务的顾客 和排队等待的顾客)的期望值。 2、平均排队长(Lq): 指系统中排队等候服务的顾客数的期望值。
Ls=Lq+正被服务的顾客数 3、平均逗留时间(Ws):指一个顾客在系统中的停留时间期望值。
4、平均等待时间(Wq):指一个顾客在系统中排队等待的时间的期望值。 Ws=Wq+服务时间
5、忙期:指从顾客到达空闲服务机构起到服务机构再次空闲止 这段时间长度,即服务机构连续繁忙的时间长度。
6、系统的状态概率[Pn( t )] :指系统中的顾客数为n的概率。
7、稳定状态:limPn(t)→Pn
四、排队模型的数量指标
排队模型
凯里学院 余英
模型要点
1、掌握排队模型的基本概念 2、了解常见的分布函数及生灭过程 3、掌握典型排队系统模型的结构及应用
排队模型的基本概念
一、引言 1、什么是排队模型(排队论)? 排队论是研究拥挤现象的一门学科。
它是在研究各种排队系统概率规律性的基础上, 解决有关排队系统的最优化设计(静态)和最 优控制(动态)问题。
的,它们之间可以是平行排列(并列)的,也可以 是前后排列(串列)的,也可以是混合的; b、服务时间可以是确定的,也可以是随机的,对于 后者要知道它的概率分布; c、服务时间可以是平稳的,也可以是非平稳的,我 们研究前者; d、对于等待制,服务规则又可以分为先到先服务 (FCFS),后到先服务(LCFS),随机服务和有 优先权的服务。
二、排队系统的特征及其组成
1、排队系统的特征即拥挤现象的共性 1)、有请求服务的人或物 2)、有为顾客服务的人或物 3)、具有随机性 4)、服务的数量超过服务机构的容量

may排队论--将MM1类型的理论和习题自己多看看

may排队论--将MM1类型的理论和习题自己多看看

P0
1
1 N1
1
2 3
1
2 3
6
0.356
e (1 PN ) (1 N P0 ) 4 1
2 3
5 0.356
3.808
L
(N 1)N1
2 3
(5 1)
2 3
6
2 0.577 1.423
1 1 N1
1
2 3
1
2 3
6
Lq
L e
1.423 3.808 6
顾客到达
进入队列
...
因队列满而离去
服务台
顾客接受服务后离去
...
系统的状态转移图
系统的状态概率平衡方程
对于状态0: … 对于状态k: … 对于状态N:
P0=P1 …
Pk-1+Pk+1=(+)Pk …
PN-1=PN
0<k<N
系统的状态概

Pk
Pk 1
k P0
k 1,2, , N

N
Pk 1
Sn t +t时刻
Pn(t t) Pn(t)(1t)(1 t) Pn1(t)t(1 t) Pn1(t)(1t)t o(t)
Pn
(t
t) t
Pn
(t)
Pn
(t
)(
)
Pn1(t
)
Pn1(t)
o(t) t
令t 0得:
dP0 (t)
dt dPn (t)
dt
P0 Pn
(t) P1(t) (t)( ) Pn1(t)
动态
即与特定顾 客特征选择
等待的 顾客数
协商
优先级

MM1排队系统仿真matlab实验报告

MM1排队系统仿真matlab实验报告

M/M/1排队系统实验报告一、实验目的本次实验要求实现M/M/1单窗口无限排队系统的系统仿真,利用事件调度法实现离散事件系统仿真,并统计平均队列长度以及平均等待时间等值,以与理论分析结果进行对比。

二、实验原理根据排队论的知识我们知道,排队系统的分类是根据该系统中的顾客到达模式、服务模式、服务员数量以及服务规则等因素决定的。

1、 顾客到达模式设到达过程是一个参数为λ的Poisson 过程,则长度为t 的时间内到达k 个呼叫的概率 服从Poisson 分布,即etkk k t t p λλ-=!)()(,⋅⋅⋅⋅⋅⋅⋅⋅⋅=,2,1,0k ,其中λ>0为一常数,表示了平均到达率或Poisson 呼叫流的强度。

2、 服务模式设每个呼叫的持续时间为i τ,服从参数为μ的负指数分布,即其分布函数为{}1,0t P X t e t μ-<=-≥3、 服务规则先进先服务的规则(FIFO ) 4、 理论分析结果在该M/M/1系统中,设λρμ=,则稳态时的平均等待队长为1Q ρλρ=-,顾客的平均等待时间为T ρμλ=-。

三、实验内容M/M/1排队系统:实现了当顾客到达分布服从负指数分布,系统服务时间也服从负指数分布,单服务台系统,单队排队,按FIFO (先入先出队列)方式服务。

四、采用的语言MatLab 语言源代码:clear; clc;%M/M/1排队系统仿真SimTotal=input('请输入仿真顾客总数SimTotal='); %仿真顾客总数;Lambda=0.4; %到达率Lambda;Mu=0.9; %服务率Mu;t_Arrive=zeros(1,SimTotal);t_Leave=zeros(1,SimTotal);ArriveNum=zeros(1,SimTotal);LeaveNum=zeros(1,SimTotal);Interval_Arrive=-log(rand(1,SimTotal))/Lambda;%到达时间间隔Interval_Serve=-log(rand(1,SimTotal))/Mu;%服务时间t_Arrive(1)=Interval_Arrive(1);%顾客到达时间ArriveNum(1)=1;for i=2:SimTotalt_Arrive(i)=t_Arrive(i-1)+Interval_Arrive(i);ArriveNum(i)=i;endt_Leave(1)=t_Arrive(1)+Interval_Serve(1);%顾客离开时间LeaveNum(1)=1;for i=2:SimTotalif t_Leave(i-1)<t_Arrive(i)t_Leave(i)=t_Arrive(i)+Interval_Serve(i);elset_Leave(i)=t_Leave(i-1)+Interval_Serve(i);endLeaveNum(i)=i;endt_Wait=t_Leave-t_Arrive; %各顾客在系统中的等待时间t_Wait_avg=mean(t_Wait);t_Queue=t_Wait-Interval_Serve;%各顾客在系统中的排队时间t_Queue_avg=mean(t_Queue);Timepoint=[t_Arrive,t_Leave];%系统中顾客数随时间的变化Timepoint=sort(Timepoint);ArriveFlag=zeros(size(Timepoint));%到达时间标志CusNum=zeros(size(Timepoint));temp=2;CusNum(1)=1;for i=2:length(Timepoint)if (temp<=length(t_Arrive))&&(Timepoint(i)==t_Arrive(temp)) CusNum(i)=CusNum(i-1)+1;temp=temp+1;ArriveFlag(i)=1;CusNum(i)=CusNum(i-1)-1;endend%系统中平均顾客数计算Time_interval=zeros(size(Timepoint));Time_interval(1)=t_Arrive(1);for i=2:length(Timepoint)Time_interval(i)=Timepoint(i)-Timepoint(i-1);endCusNum_fromStart=[0 CusNum];CusNum_avg=sum(CusNum_fromStart.*[Time_interval 0] )/Timepoint(end);QueLength=zeros(size(CusNum));for i=1:length(CusNum)if CusNum(i)>=2QueLength(i)=CusNum(i)-1;elseQueLength(i)=0;endendQueLength_avg=sum([0 QueLength].*[Time_interval 0] )/Timepoint(end);%系统平均等待队长%仿真图figure(1);set(1,'position',[0,0,1000,700]);subplot(2,2,1);title('各顾客到达时间和离去时间');stairs([0 ArriveNum],[0 t_Arrive],'b');hold on;stairs([0 LeaveNum],[0 t_Leave],'y');legend('到达时间','离去时间');hold off;subplot(2,2,2);stairs(Timepoint,CusNum,'b')title('系统等待队长分布');xlabel('时间');ylabel('队长');subplot(2,2,3);title('各顾客在系统中的排队时间和等待时间');stairs([0 ArriveNum],[0 t_Queue],'b');stairs([0 LeaveNum],[0 t_Wait],'y');hold off;legend('排队时间','等待时间');%仿真值与理论值比较disp(['理论平均等待时间t_Wait_avg=',num2str(1/(Mu-Lambda))]);disp(['理论平均排队时间t_Wait_avg=',num2str(Lambda/(Mu*(Mu-Lambda)))]);disp(['理论系统中平均顾客数=',num2str(Lambda/(Mu-Lambda))]);disp(['理论系统中平均等待队长=',num2str(Lambda*Lambda/(Mu*(Mu-Lambda)))]);disp(['仿真平均等待时间t_Wait_avg=',num2str(t_Wait_avg)])disp(['仿真平均排队时间t_Queue_avg=',num2str(t_Queue_avg)])disp(['仿真系统中平均顾客数=',num2str(CusNum_avg)]);disp(['仿真系统中平均等待队长=',num2str(QueLength_avg)]);五、数据结构1.仿真设计算法(主要函数)利用负指数分布与泊松过程的关系,产生符合泊松过程的顾客流,产生符合负指数分布的随机变量作为每个顾客的服务时间:Interval_Arrive=-log(rand(1,SimTotal))/Lambda;%到达时间间隔,结果与调用exprnd(1/Lambda,m)函数产生的结果相同Interval_Serve=-log(rand(1,SimTotal))/Mu;%服务时间间隔t_Arrive(1)=Interval_Arrive(1);%顾客到达时间时间计算t_Wait=t_Leave-t_Arrive; %各顾客在系统中的等待时间t_Queue=t_Wait-Interval_Serve; %各顾客在系统中的排队时间由事件来触发仿真时钟的不断推进。

排队模型(掌握mm1,mmc,mm1k)

排队模型(掌握mm1,mmc,mm1k)

Pn(t+Δt)= Pn(t)(1-λΔt )+Pn-1(t)λΔt+ o(Δt) [Pn(t+Δt)-Pn(t)]/Δt =-λPn(t)+λPn-1(t)+[o(Δt)]/Δt
令Δt0
d Pn(t)/dt= -λPn(t) +λPn-1(t)
Pn(0)=0
(n1)
d P0(t)/dt= -λP0(t)
T= v1+v2+...+ vk 服从k阶爱尔朗分布。
五、常见的分布函数及生灭过程
5、生灭过程 定义:设{N(t),t≥0}为一随机过程,若N(t)的概
率分布具有以下性质: a、假设N(t)=n,则从时刻t起到下一个顾客到达时刻 止的时间服从参数为λn的负指数分布,n=0,1,2,… b、假设假设N(t)=n,则从时刻t起到下一个顾客离 去时刻止的时间服从参数为μn的负指数分布, n=0,1,2,… c、同一时刻时只有一个顾客到达或离去。 则称{N(t),t≥0}为一个生灭过程。


n-1
pn =λn-1pn-1/μn+(μn-1pn-1- pn-2λn-2)/μn
=p0λn-2λn-1…λ0/(μnμn-1…μ1)
n
p3 =λnpn/μn+1+(μnpn- pn-1λn-1)/μn+1
=p0λnλn-1…λ0/(μn+1μn…μ1)
五、常见的分布函数及生灭过程

cn
n 1 n2...0 n n1...0
平均服务率: 41/127=0.32(人/分钟)
六、典型排队系统模型的结构及应用
M/M/C等待制排队模型研究要点: a、系统意义 b、状态转移速度图与状态转移速度矩阵 c、状态概率方程 d、系统的基本数量指标

完整版MM1排队系统仿真matlab实验报告

完整版MM1排队系统仿真matlab实验报告

M/M/1排队系统实验报告一、实验目的本次实验要求实现M/M/1单窗口无限排队系统的系统仿真,利用事件调度 法实现离散事件系统仿真,并统计平均队列长度以及平均等待时间等值, 以与理论分析结果进行对比。

二、实验原理根据排队论的知识我们知道,排队系统的分类是根据该系统中的顾客到达模 式、服务模式、服务员数量以及服务规则等因素决定的。

1、 顾客到达模式设到达过程是一个参数为的Poisson 过程,则长度为t 的时间内到达k 个呼常数,表示了平均到达率或Poisson 呼叫流的强度。

2、 服务模式设每个呼叫的持续时间为「,服从参数为的负指数分布,即其分布函数为P{X t} 1 e t ,t 03、 服务规则 先进先服务的规则(FIFO4、理论分析结果Q -在该M/M/1系统中,设,则稳态时的平均等待队长为1,顾客T --------的平均等待时间为 。

三、 实验内容M/M/ 1排队系统:实现了当顾客到达分布服从负指数分布,系统服务时间也服从负指数分布,单服务台系统,单队排队,按 FIFO (先入先出队列)方式服务。

四、 采用的语言MatLab 语言源代码:clear; clc;叫的概率 服从Poisson 分布,即Pk ⑴(t)k t k! e k 0,1,2,,其中 >0为一%M/M/1排队系统仿真SimTotal=input(' 请输入仿真顾客总数SimTotal='); % 仿真顾客总数;Lambda=0.4; % 到达率Lambda;Mu=0.9; % 服务率Mu;t_Arrive=zeros(1,SimTotal);t_Leave=zeros(1,SimTotal);ArriveNum=zeros(1,SimTotal);LeaveNum=zeros(1,SimTotal);Interval_Arrive=-log(rand(1,SimTotal))/Lambda;% 到达时间间隔Interval_Serve=-log(rand(1,SimTotal))/Mu;% 服务时间t_Arrive(1)=Interval_Arrive(1);% 顾客到达时间ArriveNum(1)=1;for i=2:SimTotalt_Arrive(i)=t_Arrive(i-1)+Interval_Arrive(i);ArriveNum(i)=i;endt_Leave(1)=t_Arrive(1)+Interval_Serve(1);% 顾客离开时间LeaveNum(1)=1;for i=2:SimTotalif t_Leave(i-1)<t_Arrive(i)t_Leave(i)=t_Arrive(i)+Interval_Serve(i);elset_Leave(i)=t_Leave(i-1)+Interval_Serve(i);endLeaveNum(i)=i;endt_Wait=t_Leave-t_Arrive; % 各顾客在系统中的等待时间t_Wait_avg=mean(t_Wait);t_Queue=t_Wait-Interval_Serve;% 各顾客在系统中的排队时间t_Queue_avg=mean(t_Queue);Timepoint=[t_Arrive,t_Leave];% 系统中顾客数随时间的变化Timepoint=sort(Timepoint);ArriveFlag=zeros(size(Timepoint));% 到达时间标志CusNum=zeros(size(Timepoint));temp=2;CusNum(1)=1;for i=2:length(Timepoint)if (temp<=length(t_Arrive))&&(Timepoint(i)==t_Arrive(temp))CusNum(i)=CusNum(i-1)+1;temp=temp+1;ArriveFlag(i)=1;elseCusNum(i)=CusNum(i-1)-1;endend%系统中平均顾客数计算Time_interval=zeros(size(Timepoint));Time_interval(1)=t_Arrive(1);for i=2:length(Timepoint)Time_interval(i)=Timepoint(i)-Timepoint(i-1);endCusNum_fromStart=[0 CusNum];CusNum_avg=sum(CusNum_fromStart.*[Time_interval 0] )/Timepoint(end);QueLength=zeros(size(CusNum));for i=1:length(CusNum) if CusNum(i)>=2QueLength(i)=CusNum(i)-1;elseQueLength(i)=0;endendQueLength_avg=sum([0 QueLength].*[Time_interval 0] )/Timepoint(end);% 长系统平均等待队%仿真图figure(1); set(1,'position',[0,0,1000,700]);subplot(2,2,1);title(' 各顾客到达时间和离去时间'); stairs([0 ArriveNum],[0 t_Arrive],'b');hold on;stairs([0 LeaveNum],[0 t_Leave],'y'); legend(' 到达时间',' 离去时间'); hold off;subplot(2,2,2); stairs(Timepoint,CusNum,'b') title(' 系统等待队长分布');xlabel(' 时间');ylabel(' 队长');subplot(2,2,3);title(' 各顾客在系统中的排队时间和等待时间'); stairs([0 ArriveNum],[0 t_Queue],'b');hold on;stairs([0 LeaveNum],[0 t_Wait],'y');hold off; legend(' 排队时间',' 等待时间');%仿真值与理论值比较disp([' 理论平均等待时间t_Wait_avg=',num2str(1/(Mu-Lambda))]);disp([' 理论平均排队时间t_Wait_avg=',num2str(Lambda/(Mu*(Mu-Lambda)))]); disp([' 理论系统中平均顾客数=',num2str(Lambda/(Mu-Lambda))]);disp([' 理论系统中平均等待队长=',num2str(Lambda*Lambda/(Mu*(Mu-Lambda)))]);disp([' 仿真平均等待时间t_Wait_avg=',num2str(t_Wait_avg)])disp([' 仿真平均排队时间t_Queue_avg=',num2str(t_Queue_avg)]) disp([' 仿真系统中平均顾客数=',num2str(CusNum_avg)]);disp([' 仿真系统中平均等待队长=',num2str(QueLength_avg)]);五、数据结构1. 仿真设计算法(主要函数)利用负指数分布与泊松过程的关系,产生符合泊松过程的顾客流,产生符合负指数分布的随机变量作为每个顾客的服务时间:Interval_Arrive=-log(rand(1,SimTotal))/Lambda; %到达时间间隔,结果与调用exprnd(1/Lambda, m)函数产生的结果相同In terval_Serve=-log(ra nd(1,SimTotal))/Mu; %服务时间间隔t_Arrive(1)=Interval_Arrive(1); %顾客到达时间时间计算t_Wait=t_Leave-t_Arrive; %各顾客在系统中的等待时间t_Queue=t_Wait-Interval_Serve; %各顾客在系统中的排队时间由事件来触发仿真时钟的不断推进。

排队论经典程序MM1代码

排队论经典程序MM1代码

修理店仿真报告一.问题:①修理店空闲的概率;②店内有三个顾客的概率;③店内至少有一个顾客的概率;④在店内顾客的平均数;⑤顾客在店内的平均逗留时间;⑥顾客必须在店内消耗15分钟以上的概率。

二.求解问题的方法:①修理店空闲的概率:(sim_time-area_server_status) / sim_time);②店内有三个顾客的概率:area_3_in_q/sim_time);③店内至少有一个顾客的概率:abv_1/sim_time);④在店内顾客的平均数:area_num_in_h/sim_time);⑤顾客在店内的平均逗留时间:(total_of_delays+total_of_server)/ num_custs_delayed );⑥顾客必须在店内消耗15分钟以上概率:abv_15/num_custs_delayed);三。

求解过程中计算统计量的方法:①area_server_status += server_status * time_since_last_event;②//店内有三个顾客的概率if(server_status == BUSY)//服务台忙,则有队列中有两个顾客if(num_in_q == 2)area_3_in_q += time_since_last_event;③//店内至少有一个顾客的概率if(server_status == BUSY) //服务台忙,则店内至少有一个顾客abv_1 += time_since_last_event;④//在店内顾客的平均数if(server_status == BUSY) //服务台忙,总的顾客数为排队顾客数加一area_num_in_h += (num_in_q+1) * time_since_last_event;⑤total_of_server += time_next_event[2]-sim_time;//总的服务时间加一个服务时间为新的服务总时间delay = sim_time - time_arrival[1];//排队时间=当前时间-这个人来的时间total_of_delays += delay;⑥//离开时总的消耗时间大于15,必须在店内消耗15分钟以上的顾客数加一if((delay+time_next_event[2]-sim_time)>15)abv_15++;//到达时总的服务时间大于15,必须在店内消耗15分钟以上的顾客数加一if((time_next_event[2]-sim_time)>15)abv_15++;程序代码:/* External definitions for single-server queueing system. */#include <stdio.h>#include <math.h>/*#include "lcgrand.h" Header file for random-number generator. */#define Q_LIMIT 100 /* Limit on queue length.队伍最长100人*/ #define BUSY 1 /* Mnemonics for server's being busy 忙碌状态*/#define IDLE 0 /* and idle.空闲状态*/int next_event_type, //下一个事件类型num_custs_delayed, //已模拟的顾客数num_delays_required, //模拟的顾客数num_events,//事件数num_in_q, //队列中的顾客数server_status;//服务状态float area_num_in_q,//有顾客的时间area_server_status,//总的服务时间mean_interarrival,//平均顾客到达时间间隔mean_service,//平均服务时间sim_time, //模拟时间time_arrival[Q_LIMIT + 1], //到来的时间time_last_event, //上一个事件的时间time_next_event[3],//下一个事件的时间total_of_delays; //总的排队时间//////////////////////////////////////////////////////////////////////////////////////添加的变量float abv_15, //15分钟以上的顾客数量total_of_server, //所有顾客的总的服务时间area_3_in_q, //有3个顾客的时间abv_1, //至少有一个顾客的时间area_num_in_h; //顾客总数////////////////////////////////////////////////////////////////////////////////////FILE *infile, *outfile;/* The following 3 declarations are for use of the random-number generatorlcgrand and the associated functions lcgrandst and lcgrandgt for seed management. This file (named lcgrand.h) should be included in anyprogramusing these functions by executing #include "lcgrand.h"before referencing the functions. */float lcgrand(int stream);void lcgrandst(long zset, int stream); long lcgrandgt(int stream);void initialize(void);void timing(void);void arrive(void);void depart(void);void report(void);void update_time_avg_stats(void); float expon(float mean);main() /* Main function. */{/* Open input and output files. */infile = fopen("mm1.in", "r");outfile = fopen("mm1.out", "w");/* Specify the number of events for the timing function. */num_events = 2;//两种事件/* Read input parameters. */fscanf(infile, "%f %f %d", &mean_interarrival, &mean_service, &num_delays_required);/* Write report heading and input parameters. 输出*/fprintf(outfile, "Single-server queueing system\n\n");fprintf(outfile, "Mean interarrival time%11.3f minutes\n\n",mean_interarrival);fprintf(outfile, "Mean service time%16.3f minutes\n\n", mean_service);fprintf(outfile, "Number of customers%14d\n\n", num_delays_required);/* Initialize the simulation.初始化仿真*/initialize();//初始化/* Run the simulation while more delays are still needed.没服务完,仿真继续*/while (num_custs_delayed < num_delays_required) {//当已服务顾客数小于1000时/* Determine the next event. 确定下一事件*/timing();/* Update time-average statistical accumulators.时间记录更新*/update_time_avg_stats();/* Invoke the appropriate event function. 根据事件的不同,调用不同的函数*/switch (next_event_type) {case 1:arrive();//到达break;case 2:depart();//离开break;}}/* Invoke the report generator and end the simulation. */ report();fclose(infile);fclose(outfile);return 0;}void initialize(void) /* Initialization function. */{/* Initialize the simulation clock. 仿真时间置为0*/sim_time = 0.0;/* Initialize the state variables.最开始状态初始化*/server_status = IDLE;//服务空闲num_in_q = 0; //队伍里无人排队time_last_event = 0.0; //上一个事件的时间,最开始肯定是0开始/* Initialize the statistical counters. */num_custs_delayed = 0; //已经服务的人数total_of_delays = 0.0;//总的排队时间area_num_in_q = 0.0;//有顾客的时间area_server_status = 0.0;//总的服务时间///////////////////////////////////////////////////////////////////////////////////添加的变量的初始化area_3_in_q = 0.0;//有3个顾客的时间abv_1 = 0.0;//有顾客的时间area_num_in_h = 0.0;//顾客的总数total_of_server = 0.0;//所有顾客的所有的服务的时间abv_15 = 0.0;//消耗15分钟以上的顾客数//////////////////////////////////////////////////////////////////////////////////* Initialize event list. 初始化事件列表Since no customers are present, the departure(service completion) event is eliminated from consideration. 无顾客存在和离开*/time_next_event[1] = sim_time + expon(mean_interarrival);//下一事件是来的时间time_next_event[2] = 1.0e+30; //下一事件是离开的时间}void timing(void) /* Timing function. */{int i;float min_time_next_event = 1.0e+29; //像指针一样的对于当前服务的人来说下一个事件的时间next_event_type = 0;/* Determine the event type of the next event to occur.接下来将要发生的事件的类型*/for (i = 1; i <= num_events; ++i)if (time_next_event[i] < min_time_next_event) {//下一事件是来的时间跟离开时间比较min_time_next_event = time_next_event[i];next_event_type = i;}/* Check to see whether the event list is empty. */if (next_event_type == 0) {/* The event list is empty, so stop the simulation. 无事件,停止仿真过程*/fprintf(outfile, "\nEvent list empty at time %f", sim_time);exit(1);}/* The event list is not empty, so advance the simulation clock. 有事件,进行仿真过程*/sim_time = min_time_next_event; //仿真的时间就是当前事件的时间}void arrive(void) /* Arrival event function. */{float delay;/* Schedule next arrival.计划下一次的到来*/time_next_event[1] = sim_time + expon(mean_interarrival);/* Check to see whether server is busy. 检测是否在服务状态*/if (server_status == BUSY) {/* Server is busy, so increment number of customers in queue. 在服务则排队多一人*/++num_in_q;/* Check to see whether an overflow condition exists. 检测人数是否超出*/if (num_in_q > Q_LIMIT) {/* The queue has overflowed, so stop the simulation. */fprintf(outfile, "\nOverflow of the array time_arrival at");fprintf(outfile, " time %f", sim_time);exit(2);}/* There is still room in the queue, so store the time of arrival of thearriving customer at the (new) end of time_arrival. 队列中仍有空间时,记录新到达的时间*/time_arrival[num_in_q] = sim_time;//在这个时间的时候有这么多的排队人数,用于计算3顾客的问题}else { //服务空闲的状况/* Server is idle, so arriving customer has a delay of zero. (Thefollowing two statements are for program clarity and do not affectthe results of the simulation.) */delay = 0.0;total_of_delays += delay; //总的排队时间/* Increment the number of customers delayed, and make server busy. */++num_custs_delayed; //已经模拟的顾客数加1server_status = BUSY; //人到来,服务开始/* Schedule a departure (service completion). 服务完成*/time_next_event[2] = sim_time + expon(mean_service);//这个人离开的时间为现在时间+服务时间///////////////////////////////////////////////////////////////////////////////////总的服务时间加上当前服务时间,更新总的服务时间total_of_server += time_next_event[2]-sim_time;//总的服务时间加一个服务时间为新的服务总时间//总的服务时间大于15,必须在店内消耗15分钟以上的顾客数加一if((time_next_event[2]-sim_time)>15)//如果这个人服务时间超过15分钟则耗费15分钟人数加1abv_15++;/////////////////////////////////////////////////////////////////////////////////}}void depart(void) /* Departure event function. 讨论离开事件*/{int i;float delay;/* Check to see whether the queue is empty.检测队列是否为空*/if (num_in_q == 0) {/* The queue is empty so make the server idle and eliminate the departure (service completion) event from consideration. 队列空,服务空闲*/server_status = IDLE;time_next_event[2] = 1.0e+30; //离开的时间无限大(无人离开)}else {/* The queue is nonempty, so decrement the number of customers inqueue. 有人离开,队列人数减少*/--num_in_q;/* Compute the delay of the customer who is beginning serviceand updatethe total delay accumulator. */delay = sim_time - time_arrival[1];//排队时间=当前时间-这个人来的时间total_of_delays += delay;/* Increment the number of customers delayed, and schedule departure.已经服务人数+1 */++num_custs_delayed; //服务人数加1time_next_event[2] = sim_time + expon(mean_service);//当前接受服务的人的离开时间///////////////////////////////////////////////////////////////////////////////////总的服务时间加上当前服务时间,更新总的服务时间total_of_server += time_next_event[2]-sim_time;//总的消耗时间大于15,必须在店内消耗15分钟以上的顾客数加一if((delay+time_next_event[2]-sim_time)>15)abv_15++;//////////////////////////////////////////////////////////////////////////////////* Move each customer in queue (if any) up one place.有人离开,队列前移*/for (i = 1; i <= num_in_q; ++i)time_arrival[i] = time_arrival[i + 1];//人的到达时间也前移}}void report(void) /* Report generator function. */{/* Compute and write estimates of desired measures of performance. */fprintf(outfile, "\n\nAverage delay in queue%11.3f minutes\n\n",total_of_delays / num_custs_delayed);fprintf(outfile, "Average number in queue%10.3f\n\n",area_num_in_q / sim_time);fprintf(outfile, "Server utilization%15.3f\n\n",area_server_status / sim_time);fprintf(outfile, "Time simulation ended%12.3f minutes", sim_time);printf("统计量:\n");//////////////////////////////////////////////////////////////////////////总时间减去服务台忙的时间除以总时间,得到服务台空闲的概率printf("①修理店空闲的概率:%24.3f\n",(sim_time-area_server_status) / sim_time);printf("②店内有三个顾客的概率:%20.3f\n",area_3_in_q/sim_time);printf("③店内至少有一个顾客的概率:%16.3f\n",abv_1/sim_time);printf("④在店内顾客的平均数:%22.3f\n",area_num_in_h/sim_time);printf("⑤顾客在店内的平均逗留时间:%16.3f\n",(total_of_delays+total_of_server)/ num_custs_delayed );printf("⑥顾客必须在店内消耗15分钟以上概率:%8.3f\n\n", abv_15/num_custs_delayed);printf("仿真时间:%12.3f minutes\n\n", sim_time);//////////////////////////////////////////////////////////////////////}void update_time_avg_stats(void) /* Update area accumulators fortime-averagestatistics.更新时间平均时间统计*/{float time_since_last_event;/* Compute time since last event, and update last-event-time marker.上个事件到现在的时间并更新最后事件的标记*/time_since_last_event = sim_time - time_last_event;//两个事件的时间差time_last_event = sim_time;/* Update area under number-in-queue function. 有顾客的时间=队列中的人数*时间差*/area_num_in_q += num_in_q * time_since_last_event;/* Update area under server-busy indicator function. 总的服务时间=所有时间差相加*/area_server_status += server_status * time_since_last_event;///////////////////////////////////////////////////////////////////////////////////店内有三个顾客的概率if(server_status == BUSY) //服务台忙,则有队列中有两个顾客if(num_in_q == 2)area_3_in_q += time_since_last_event;//if(server_status == IDLE) //服务台空闲,则有队列中有三个顾客// if(num_in_q == 3)// area_3_in_q += time_since_last_event;//店内至少有一个顾客的概率if(server_status == BUSY) //服务台忙,则店内至少有一个顾客abv_1 += time_since_last_event;//if(server_status == IDLE) //服务台空闲,则有队列中至少有一个顾客// if(num_in_q>0)// abv_1 += time_since_last_event;//在店内顾客的平均数if(server_status == BUSY) //服务台忙,总的顾客数为排队顾客数加一area_num_in_h += (num_in_q+1) * time_since_last_event;//if(server_status == IDLE) //服务台空闲,总的顾客数为排队顾客数// area_num_in_h += num_in_q * time_since_last_event;/////////////////////////////////////////////////////////////////////////////////}float expon(float mean) /* Exponential variate generation function. */ {/* Return an exponential random variate with mean "mean". */return -mean * log(lcgrand(10));//自己学号的后两位}/* Prime modulus multiplicative linear congruential generator Z[i] = (630360016 * Z[i-1]) (mod(pow(2,31) - 1)), based on Marse and Roberts'portable FORTRAN random-number generator UNIRAN. Multiple(100) streams aresupported, with seeds spaced 100,000 apart. Throughout, input argument"stream" must be an int giving the desired stream number. The header filelcgrand.h must be included in the calling program (#include "lcgrand.h")before using these functions.Usage: (Three functions)1. To obtain the next U(0,1) random number from stream "stream," executeu = lcgrand(stream);where lcgrand is a float function. The float variable u will contain thenext random number.2. To set the seed for stream "stream" to a desired value zset, executelcgrandst(zset, stream);where lcgrandst is a void function and zset must be a long set to thedesired seed, a number between 1 and 2147483646 (inclusive). Defaultseeds for all 100 streams are given in the code.3. To get the current (most recently used) integer in the sequence beinggenerated for stream "stream" into the long variable zget, execute zget = lcgrandgt(stream);where lcgrandgt is a long function. *//* Define the constants. */#define MODLUS 2147483647#define MULT1 24112#define MULT2 26143/* Set the default seeds for all 100 streams. */static long zrng[] ={ 1,1973272912, 281629770, 20006270,1280689831,2096730329,1933576050,913566091, 246780520,1363774876, 604901985,1511192140,1259851944,824064364, 150493284, 242708531, 75253171,1964472944,1202299975,233217322,1911216000, 726370533, 403498145, 993232223,1103205531,762430696,1922803170,1385516923, 76271663, 413682397, 726466604,336157058,1432650381,1120463904, 595778810, 877722890,1046574445,68911991,2088367019, 748545416, 622401386,2122378830, 640690903,1774806513,2132545692,2079249579, 78130110, 852776735,1187867272,1351423507,1645973084,1997049139, 922510944,2045512870, 898585771,243649545,1004818771, 773686062, 403188473, 372279877,1901633463,498067494,2087759558, 493157915, 597104727,1530940798,1814496276,536444882,1663153658, 855503735, 67784357,1432404475, 619691088,119025595, 880802310, 176192644,1116780070, 277854671,1366580350,1142483975,2026948561,1053920743,786262391,1792203830,1494667770,1923011392,1433700034,1244184613,1147297105,539712780,1545929719,190641742,1645390429, 264907697, 620389253,1502074852, 927711160,364849192,2049576050, 638580085, 547070247 };/* Generate the next random number. */float lcgrand(int stream){long zi, lowprd, hi31;zi = zrng[stream];lowprd = (zi & 65535) * MULT1;hi31 = (zi >> 16) * MULT1 + (lowprd >> 16);zi = ((lowprd & 65535) - MODLUS) +((hi31 & 32767) << 16) + (hi31 >> 15);if (zi < 0) zi += MODLUS;lowprd = (zi & 65535) * MULT2;hi31 = (zi >> 16) * MULT2 + (lowprd >> 16);zi = ((lowprd & 65535) - MODLUS) +((hi31 & 32767) << 16) + (hi31 >> 15);if (zi < 0) zi += MODLUS;zrng[stream] = zi;return (zi >> 7 | 1) / 16777216.0;}void lcgrandst (long zset, int stream) /* Set the current zrng for stream"stream" to zset. */ {zrng[stream] = zset;}long lcgrandgt (int stream) /* Return the current zrng for stream "stream". */{return zrng[stream];}。

北邮通信网mm1级联排队系统MATLAB代码

北邮通信网mm1级联排队系统MATLAB代码
Num_a(i)>=2
QueLength_a(i)=CusNum_a(i)-1;%某事件时间断点系统内排队长
else
QueLength_a(i)=0;
end
end
QueLength_avg_a=sum([0 QueLength_a].*[Time_interval_a 0])/Timepoint_a(end);%系统平均等待队长
Time_interval_b(i)=Timepoint_b(i)-Timepoint_b(i-1);
end
CusNum_fromStart_b=[0 CusNum_b];
CusNum_avg_b=sum(CusNum_fromStart_b.*[Time_interval_b 0])/Timepoint_b(end);
for i=2:Simtotal
Interval_Arrive_b(i)=t_Leave_a(i)-t_Leave_a(i-1)
end
Interval_Serve_b=exprnd(1/Mu_b,1,Simtotal);
for i=1:Simtotal
t_Arrive_b(i)=t_Leave_a(i);
LeaveNum_b=zeros(1,Simtotal);
Interval_Arrive_b=zeros(1,Simtotal);
Interval_Arrive_a=exprnd(1/Lambda,1,Simtotal);%产生泊松流
Interval_Serve_a=exprnd(1/Mu_a,1,Simtotal);
else
CusNum_b(i)=CusNum_b(i-1)-1;

MM1排队系统仿真matlab实验报告

MM1排队系统仿真matlab实验报告

M/M/1排队系统实验报告一、实验目的本次实验要求实现M/M/1单窗口无限排队系统的系统仿真,利用事件调度法实现离散事件系统仿真,并统计平均队列长度以及平均等待时间等值,以与理论分析结果进行对比。

二、实验原理根据排队论的知识我们知道,排队系统的分类是根据该系统中的顾客到达模式、服务模式、服务员数量以及服务规则等因素决定的。

1、 顾客到达模式设到达过程是一个参数为λ的Poisson 过程,则长度为t 的时间内到达k 个呼叫的概率 服从Poisson 分布,即etkk k t t p λλ-=!)()(,⋅⋅⋅⋅⋅⋅⋅⋅⋅=,2,1,0k ,其中λ>0为一常数,表示了平均到达率或Poisson 呼叫流的强度。

2、 服务模式设每个呼叫的持续时间为i τ,服从参数为μ的负指数分布,即其分布函数为{}1,0t P X t e t μ-<=-≥3、 服务规则先进先服务的规则(FIFO ) 4、 理论分析结果在该M/M/1系统中,设λρμ=,则稳态时的平均等待队长为1Q ρλρ=-,顾客的平均等待时间为T ρμλ=-。

三、实验内容M/M/1排队系统:实现了当顾客到达分布服从负指数分布,系统服务时间也服从负指数分布,单服务台系统,单队排队,按FIFO (先入先出队列)方式服务。

四、采用的语言MatLab 语言 源代码:clear; clc;%M/M/1排队系统仿真SimTotal=input('请输入仿真顾客总数SimTotal='); %仿真顾客总数;Lambda=0.4; %到达率Lambda;Mu=0.9; %服务率Mu;t_Arrive=zeros(1,SimTotal);t_Leave=zeros(1,SimTotal);ArriveNum=zeros(1,SimTotal);LeaveNum=zeros(1,SimTotal);Interval_Arrive=-log(rand(1,SimTotal))/Lambda;%到达时间间隔Interval_Serve=-log(rand(1,SimTotal))/Mu;%服务时间t_Arrive(1)=Interval_Arrive(1);%顾客到达时间ArriveNum(1)=1;for i=2:SimTotalt_Arrive(i)=t_Arrive(i-1)+Interval_Arrive(i);ArriveNum(i)=i;endt_Leave(1)=t_Arrive(1)+Interval_Serve(1);%顾客离开时间LeaveNum(1)=1;for i=2:SimTotalif t_Leave(i-1)<t_Arrive(i)t_Leave(i)=t_Arrive(i)+Interval_Serve(i);elset_Leave(i)=t_Leave(i-1)+Interval_Serve(i);endLeaveNum(i)=i;endt_Wait=t_Leave-t_Arrive; %各顾客在系统中的等待时间t_Wait_avg=mean(t_Wait);t_Queue=t_Wait-Interval_Serve;%各顾客在系统中的排队时间t_Queue_avg=mean(t_Queue);Timepoint=[t_Arrive,t_Leave];%系统中顾客数随时间的变化Timepoint=sort(Timepoint);ArriveFlag=zeros(size(Timepoint));%到达时间标志CusNum=zeros(size(Timepoint));temp=2;CusNum(1)=1;for i=2:length(Timepoint)if (temp<=length(t_Arrive))&&(Timepoint(i)==t_Arrive(temp)) CusNum(i)=CusNum(i-1)+1;temp=temp+1;ArriveFlag(i)=1;CusNum(i)=CusNum(i-1)-1;endend%系统中平均顾客数计算Time_interval=zeros(size(Timepoint));Time_interval(1)=t_Arrive(1);for i=2:length(Timepoint)Time_interval(i)=Timepoint(i)-Timepoint(i-1);endCusNum_fromStart=[0 CusNum];CusNum_avg=sum(CusNum_fromStart.*[Time_interval 0] )/Timepoint(end);QueLength=zeros(size(CusNum));for i=1:length(CusNum)if CusNum(i)>=2QueLength(i)=CusNum(i)-1;elseQueLength(i)=0;endendQueLength_avg=sum([0 QueLength].*[Time_interval 0] )/Timepoint(end);%系统平均等待队长%仿真图figure(1);set(1,'position',[0,0,1000,700]);subplot(2,2,1);title('各顾客到达时间和离去时间');stairs([0 ArriveNum],[0 t_Arrive],'b');hold on;stairs([0 LeaveNum],[0 t_Leave],'y');legend('到达时间','离去时间');hold off;subplot(2,2,2);stairs(Timepoint,CusNum,'b')title('系统等待队长分布');xlabel('时间');ylabel('队长');subplot(2,2,3);title('各顾客在系统中的排队时间和等待时间');stairs([0 ArriveNum],[0 t_Queue],'b');stairs([0 LeaveNum],[0 t_Wait],'y');hold off;legend('排队时间','等待时间');%仿真值与理论值比较disp(['理论平均等待时间t_Wait_avg=',num2str(1/(Mu-Lambda))]);disp(['理论平均排队时间t_Wait_avg=',num2str(Lambda/(Mu*(Mu-Lambda)))]);disp(['理论系统中平均顾客数=',num2str(Lambda/(Mu-Lambda))]);disp(['理论系统中平均等待队长=',num2str(Lambda*Lambda/(Mu*(Mu-Lambda)))]);disp(['仿真平均等待时间t_Wait_avg=',num2str(t_Wait_avg)])disp(['仿真平均排队时间t_Queue_avg=',num2str(t_Queue_avg)])disp(['仿真系统中平均顾客数=',num2str(CusNum_avg)]);disp(['仿真系统中平均等待队长=',num2str(QueLength_avg)]);五、数据结构1.仿真设计算法(主要函数)利用负指数分布与泊松过程的关系,产生符合泊松过程的顾客流,产生符合负指数分布的随机变量作为每个顾客的服务时间:Interval_Arrive=-log(rand(1,SimTotal))/Lambda;%到达时间间隔,结果与调用exprnd(1/Lambda,m)函数产生的结果相同Interval_Serve=-log(rand(1,SimTotal))/Mu;%服务时间间隔t_Arrive(1)=Interval_Arrive(1);%顾客到达时间时间计算t_Wait=t_Leave-t_Arrive;%各顾客在系统中的等待时间t_Queue=t_Wait-Interval_Serve; %各顾客在系统中的排队时间由事件来触发仿真时钟的不断推进。

通信网络实验一MM1排队系统

通信网络实验一MM1排队系统

实验一:M/M/1排队系统一、实验目的M/M/1是最简单的排队系统,其假设到达过程是一个参数为λ的Poisson 过程,服务时间是参数为μ的负指数分布,只有一个服务窗口,等待的位置有无穷多个,排队的方式是FIFO 。

M/M/1排队系统的稳态分布、平均队列长度,等待时间的分布以及平均等待时间,可通过泊松过程、负指数分布、生灭过程以及Little 公式等进行理论上的分析与求解。

二、实验原理根据排队论的知识我们知道,排队系统的分类是根据该系统中的顾客到达模式、服务模式、服务员数量以及服务规则等因素决定的。

1、 顾客到达模式设到达过程是一个参数为λ的Poisson 过程,则长度为t 的时间内到达k 个呼叫的概率)(t P k 服从Poisson 分布,即etk k k t t p λλ-=!)()(,⋅⋅⋅⋅⋅⋅⋅⋅⋅=,2,1,0k ,其中λ>0为一常数,表示了平均到达率或Poisson 呼叫流的强度。

2、 服务模式设每个呼叫的持续时间为i τ,服从参数为μ的负指数分布,即其分布函数为{}1,0t P X t e t μ-<=-≥3、 服务规则先进先服务的规则(FIFO ) 4、 理论分析结果在该M/M/1系统中,设λρμ=,则稳态时的平均等待队长为1Q ρλρ=-,顾客的平均等待时间为T ρμλ=-。

三、 实验内容 1、 采用语言MATLAB 语言,其源代码如下: %总仿真时间Total_time = 30;%队列最大长度N = 10;%到达率与服务率lambda = 0.8;mu = 5;%平均到达时间与平均服务时间arr_mean = 1/lambda;ser_mean = 1/mu;%可能到达的最大顾客数(round:四舍五入求整数)arr_num = round(Total_time*lambda*2);%顾客事件表初始化events = [];%按负指数分布产生各顾客达到时间间隔events(1,:) = exprnd(arr_mean,1,arr_num);%各顾客的到达时刻等于时间间隔的累积和events(1,:) = cumsum(events(1,:));%按负指数分布产生各顾客服务时间events(2,:) = exprnd(ser_mean,1,arr_num);%计算仿真顾客个数,即到达时刻在仿真时间内的顾客数len_sim = sum(events(1,:)<= Total_time);%*****************************************% 计算第1 个顾客的信息%*****************************************%第1 个顾客进入系统后直接接受服务,无需等待events(3,1) = 0;%其离开时刻等于其到达时刻与服务时间之和events(4,1) = events(1,1)+events(2,1);%其肯定被系统接纳,此时系统内共有1 个顾客,故标志位%置1events(5,1) = 1;%其进入系统后,系统内已有成员序号为1member = [1];%*****************************************% 计算第i 个顾客的信息%*****************************************for i = 2:arr_num%如果第i 个顾客的到达时间超过了仿真时间,则跳出循环if events(1,i)>Total_timebreak;%如果第i 个顾客的到达时间未超过仿真时间,则计算在其%到达时刻系统中已有的顾客个数else number = sum(events(4,member) > events(1,i)); %如果系统已满,则系统拒绝第i 个顾客,其标志位置0if number >= N+1events(5,i) = 0;%如果系统为空,则第i 个顾客直接接受服务else if number == 0%其等待时间为0events(3,i) = 0;%其离开时刻等于到达时刻与服务时间之和events(4,i) = events(1,i)+events(2,i);%其标志位置1events(5,i) = 1;member = [member,i];%如果系统有顾客正在接受服务,且系统等待队列未满,则%第i 个顾客进入系统else len_mem = length(member);%其等待时间等于队列中前一个顾客的离开时刻减去其到%达时刻events(3,i)=events(4,member(len_mem))-events(1,i);%其离开时刻等于队列中前一个顾客的离开时刻加上其服%务时间events(4,i)=events(4,member(len_mem))+events(2,i);%标识位表示其进入系统后,系统内共有的顾客数events(5,i) = number+1;member = [member,i];endendendend%仿真结束时,进入系统的总顾客数len_mem = length(member);%*****************************************% 输出结果%*****************************************%绘制在仿真时间内,进入系统的所有顾客的到达时刻和离%开时刻曲线图(stairs:绘制二维阶梯图)stairs([0 events(1,member)],0:len_mem);hold on;stairs([0 events(4,member)],0:len_mem,'.-r');legend(' 到达时间',' 离开时间');hold off;grid on;%绘制在仿真时间内,进入系统的所有顾客的停留时间和等%待时间曲线图(plot:绘制二维线性图)figure;plot(1:len_mem,events(3,member),'r-*',1:len_mem,events(2,member)+events(3,m ember),'k-');legend(' 等待时间',' 停留时间');grid on;四、数据结构1、主要函数%可能到达的最大顾客数(round:四舍五入求整数)arr_num = round(Total_time*lambda*2);%顾客事件表初始化events = [];%按负指数分布产生各顾客达到时间间隔events(1,:) = exprnd(arr_mean,1,arr_num);%各顾客的到达时刻等于时间间隔的累积和events(1,:) = cumsum(events(1,:));%按负指数分布产生各顾客服务时间events(2,:) = exprnd(ser_mean,1,arr_num);%计算仿真顾客个数,即到达时刻在仿真时间内的顾客数len_sim = sum(events(1,:)<= Total_time);%如果系统有顾客正在接受服务,且系统等待队列未满,则%第i 个顾客进入系统else len_mem = length(member);%其等待时间等于队列中前一个顾客的离开时刻减去其到%达时刻events(3,i)=events(4,member(len_mem))-events(1,i);%其离开时刻等于队列中前一个顾客的离开时刻加上其服%务时间events(4,i)=events(4,member(len_mem))+events(2,i);%标识位表示其进入系统后,系统内共有的顾客数events(5,i) = number+1;member = [member,i];%开时刻曲线图(stairs:绘制二维阶梯图)stairs([0 events(1,member)],0:len_mem);2、算法的流程图开始输入仿真人数计算第i个顾客离开时间是否接纳?计算第i个顾客的等待时间标志位+1是否时间越界?输出结果结束五、仿真结果分析六、遇到的问题和解决方法七、实验心得通过这次实验,我们再一次复习了M/M/1的简单排队系统以及MATLAB 的使用,同时对Mat Lab编程语言更加熟悉,并了解到仿真在通信网中的重要作用。

D1、MD1、MM1排队性能讲解

D1、MD1、MM1排队性能讲解

通信网仿真与NS仿真器大作业——D/D/1、M/D/1、M/M/1排队性能分析姓名:黄颢学号:1011010303班级:通信三班2012年2月一、总体目标获得D/D/1、M/M/1、M/D/1等不同排队系统的吞吐量与流入负载的变化关系。

二、任务分配:针对本次作业,将本组所有成员分成三个小组:第一小组的主要任务是负责D/D/1、M/M/1、M/D/1等不同排队系统业务源的生成。

第二小组的主要任务是在第一小组工作的基础上对模拟环境所生成的数据进行记录并做后续的数据处理。

第三小组的主要任务是在前两个小组的任务完成之后,进一步讨论实验结果,并在最后撰写实验报告。

三、实验环境Unbuntu平台下的NS、Gnuplot。

其中Ubuntu的版本为11.10、NS的版本为2.34、Gnuplot 的版本为4.4。

四、D/D/1、M/D/1、M/M/1排队系统的概述排队论(queuing theory), 或称随机服务系统理论, 是通过对服务对象到来及服务时间的统计研究,得出这些数量指标(等待时间、排队长度、忙期长短等)的统计规律,然后根据这些规律来改进服务系统的结构或重新组织被服务对象,使得服务系统既能满足服务对象的需要,又能使机构的费用最经济或某些指标最优。

排队模型的表示方法:M= 指数分布 D= 确定型分布M/M/1:数据进入队列的概率服从泊松分布,数据离开队列的概率亦服从泊松分布,且只有一个队列。

由随机过程知识可知数据到达的时间间隔服从指数分布,数据离开队列的时间间隔也是服从指数分布的,而在在队列处理能力一定的基础上,数据离开队列的时间间隔与其大小有正比关系,故可将M/M/1的生成转化为生成一个这样的节点:1、其发送数据的时间间隔服从指数分布,在程序中设其参数为λ;2、其发送的数据大小也服从指数分布,在程序中设其参数为μ。

D/D/1:即数据进入队列和离开队列的概率是固定的,由M/M/1的节点生成可知,D/D/1的生成转化为这样一个节点:1、其发送数据的时间间隔固定;2、其发送的数据大小也固定,为方便比较其间隔时间和大小也用λ和μ来表示。

排队模型(matlab代码)

排队模型(matlab代码)

function out=MMSmteam(s,m,mu1,mu2,T)%M/M/S/m排队模型%s——修理工个数%m——机器源数%T——时间终止点%mu1——机器离开-到达时间服从指数分布%mu2——修理时间服从指数分布%事件表:% p_s——修理工空闲概率% arrive_time——机器到达事件% leave_time——机器离开事件%mintime——事件表中的最近事件%current_time——当前时间%L——队长%tt——时间序列%LL——队长序列%c——机器到达时间序列%b——修理开始时间序列%e——机器离开时间序列%a_count——到达机器数%b_count——修理机器数%e_count——损失机器数%初始化arrive_time=exprnd(mu1,1,m);arrive_time=sort(arrive_time);leave_time=[];current_time=0;L=0;LL=[L];tt=[current_time];c=[];b=[];e=[];a_count=0;%循环while min([arrive_time,leave_time])<Tcurrent_time=min([arrive_time,leave_time]);tt=[tt,current_time]; %记录时间序列if current_time==min(arrive_time) %机器到达子过程arrive_time(1)=[]; % 从事件表中抹去机器到达事件a_count=a_count+1; %累加到达机器数if L<s %有空闲修理工L=L+1; %更新队长c=[c,current_time];%记录机器到达时间序列b=[b,current_time];%记录修理开始时间序列leave_time=[leave_time,current_time+exprnd(mu2)];%产生新的机器离开事件leave_time=sort(leave_time);%离开事件表排序else %无空闲修理工L=L+1; %更新队长c=[c,current_time];%记录机器到达时间序列endelse %机器离开子过程leave_time(1)=[];%从事件表中抹去机器离开事件arrive_time=[arrive_time,current_time+exprnd(mu1)];arrive_time=sort(arrive_time);%到达事件表排序e=[e,current_time];%记录机器离开时间序列if L>s %有机器等待L=L-1; %更新队长b=[b,current_time];%记录修理开始时间序列leave_time=[leave_time,current_time+exprnd(mu2)];%产生新的机器离开事件leave_time=sort(leave_time);%离开事件表排序else %无机器等待L=L-1; %更新队长endendLL=[LL,L]; %记录队长序列endWs=sum(e-c(1:length(e)))/length(e);Wq=sum(b-c(1:length(b)))/length(b);Wb=sum(e-b(1:length(e)))/length(e);Ls=sum(diff([tt,T]).*LL)/T;Lq=sum(diff([tt,T]).*max(LL-s,0))/T;p_s=1.0/(factorial(m)/factorial(m).*(mu2/mu1)^0+factorial(m)/factorial(m-1).*(mu2/mu1)^1+fact orial(m-2)/factorial(m-1).*(mu2/mu1)^2+factorial(m)/factorial(m-2).*(mu2/mu1)^2+factorial(m)/ factorial(m-4).*(mu2/mu1)^4+factorial(m)/factorial(m-5).*(mu2/mu1)^5);fprintf('修理工空闲概率:%d\n',p_s)%修理工空闲概率fprintf('到达机器数:%d\n',a_count)%到达机器数fprintf('平均逗留时间:%f\n',sum(e-c(1:length(e)))/length(e))%平均逗留时间fprintf('平均等待时间:%f\n',sum(b-c(1:length(b)))/length(b))%平均等待时间fprintf('平均修理时间:%f\n',sum(e-b(1:length(e)))/length(e))%平均修理时间fprintf('平均队长:%f\n',sum(diff([tt,T]).*LL)/T)%平均队长fprintf('平均等待队长:%f\n',sum(diff([tt,T]).*max(LL-s,0))/T)%平均等待队长for i=0:mp(i+1)=sum((LL==i).*diff([tt,T]))/T;%队长为i的概率fprintf('队长为%d的概率:%f\n',i,p(i+1));fprintf('机器不能马上得到修理的概率:%f\n',1-sum(p(1:s)))%机器不能马上得到修理的概率out=[Ws,Wq,Wb,Ls,Lq,p];function out=MMSkteam(s,k,mu1,mu2,T)%多服务台%s——服务台个数%k——最大顾客等待数%T——时间终止点%mu1——到达时间间隔服从指数分布%mu2——服务时间服从指数分布%事件表:% arrive_time——顾客到达事件% leave_time——顾客离开事件%mintime——事件表中的最近事件%current_time——当前时间%L——队长%tt——时间序列%LL——队长序列%c——顾客到达时间序列%b——服务开始时间序列%e——顾客离开时间序列%a_count——到达顾客数%b_count——服务顾客数%e_count——损失顾客数%初始化arrive_time=exprnd(mu1);leave_time=[];current_time=0;L=0;LL=[L];tt=[current_time];c=[];b=[];e=[];a_count=0;b_count=0;e_count=0;while min([arrive_time,leave_time])<Tcurrent_time=min([arrive_time,leave_time]);tt=[tt,current_time]; %记录时间序列if current_time==arrive_time %顾客到达子过程arrive_time=arrive_time+exprnd(mu1); % 刷新顾客到达事件a_count=a_count+1; %累加到达顾客数if L<s %有空闲服务台L=L+1; %更新队长b_count=b_count+1;%累加服务顾客数c=[c,current_time];%记录顾客到达时间序列b=[b,current_time];%记录服务开始时间序列leave_time=[leave_time,current_time+exprnd(mu2)];%产生新的顾客离开事件leave_time=sort(leave_time);%离开事件表排序elseif L<s+k %有空闲等待位L=L+1; %更新队长b_count=b_count+1;%累加服务顾客数c=[c,current_time];%记录顾客到达时间序列else %顾客损失e_count=e_count+1;%累加损失顾客数endelse %顾客离开子过程leave_time(1)=[];%从事件表中抹去顾客离开事件e=[e,current_time];%记录顾客离开时间序列if L>s %有顾客等待L=L-1; %更新队长b=[b,current_time];%记录服务开始时间序列leave_time=[leave_time,current_time+exprnd(mu2)];leave_time=sort(leave_time);%离开事件表排序else %无顾客等待L=L-1; %更新队长endendLL=[LL,L]; %记录队长序列endWs=sum(e-c(1:length(e)))/length(e);Wq=sum(b-c(1:length(b)))/length(b);Wb=sum(e-b(1:length(e)))/length(e);Ls=sum(diff([tt,T]).*LL)/T;Lq=sum(diff([tt,T]).*max(LL-s,0))/T;fprintf('到达顾客数:%d\n',a_count)%到达顾客数fprintf('服务顾客数:%d\n',b_count)%服务顾客数fprintf('损失顾客数:%d\n',e_count)%损失顾客数fprintf('平均逗留时间:%f\n',Ws)%平均逗留时间fprintf('平均等待时间:%f\n',Wq)%平均等待时间fprintf('平均服务时间:%f\n',Wb)%平均服务时间fprintf('平均队长:%f\n',Ls)%平均队长fprintf('平均等待队长:%f\n',Lq)%平均等待队长if k~=inffor i=0:s+kp(i+1)=sum((LL==i).*diff([tt,T]))/T;%队长为i的概率fprintf('队长为%d的概率:%f\n',i,p(i+1));endelsefor i=0:3*sp(i+1)=sum((LL==i).*diff([tt,T]))/T;%队长为i的概率fprintf('队长为%d的概率:%f\n',i,p(i+1));endendfprintf('顾客不能马上得到服务的概率:%f\n',1-sum(p(1:s)))%顾客不能马上得到服务的概率out=[Ws,Wq,Wb,Ls,Lq,p];。

排队论算法matlab代码

排队论算法matlab代码
events = [];
%按负指数分布产生各顾客达到时间间隔
events(1,:) = exprnd(arr_mean,1,arr_num);
%各顾客的到达时刻等于时间间隔的累积和
events(1,:) = cumsum(events(1,:));
%按负指数分布产生各顾客服务时间
out=[Ws,Wq,Wb,Ls,Lq,p];
演示代码
clear
clc
%*****************************************
%初始化顾客源
%*****************************************
%总仿真时间
Total_time = 10;
leave_time=sort(leave_time);%离开事1; %更新队长
end
end
LL=[LL,L]; %记录队长序列
步骤:
(1)确定问题是否属于排队论领域
(2)确定修理工个数s
(3)确定机器源数m
(4)找到时间终止点T
(5)带入模型即可
function out=MMSmteam(s,m,mu1,mu2,T)
%M/M/S/m排队模型
%s——修理工个数
%m——机器源数
%T——时间终止点
%mu1——机器离开-到达时间服从指数分布
%队列最大长度
N = 10000000000;
%到达率与服务率
lambda = 10;
mu = 6;
%平均到达时间与平均服务时间
arr_mean = 1/lambda;
ser_mean = 1/mu;

排队问题程序

排队问题程序

function[maxque,mwait_t,mstay_t,queue_l,use_rate]=MM1queue(mean_arr,mean_lea,peo_num)status=zeros(3,peo_num);%用一个3行矩阵表示每个顾客的状态;%到达时间间隔,服务时间,等待时间;status(1,=exprnd(mean_arr,1,peo_num);%随机生成各顾客的到达间隔;status(2,=exprnd(mean_lea,1,peo_num);%随机生成各顾客的服务时间;for i=2:peo_numif status(1,i)<=status(2,i-1)+status(3,i-1)status(3,i)=status(2,i-1)+status(3,i-1)-status(1,i);elsestatus(3,i)=0;end;%对状态进行更新;end;arr_time=cumsum(status(1,);status(1,:)=arr_time;lea_time=sum(status);stairs([0 arr_time],0:peo_num);%绘出各顾客的到达时间图;hold on;stairs([0 lea_time],0:peo_num,'r');%绘出各顾客的离去时间图;legend('Arrive curve','leave curve',0)hold offfigure;plot(1:peo_num,status(3,:),'r:',1:peo_num,status(2,:)+status(3,:),'k-');%绘出每个顾客的等待时间和停留时间;legend('Wait Time','Stay Time',0);n1=1;n2=1;mstay_t=(sum(status(2,:))+sum(status(3,:)))/peo_num;mwait_t=mean(status(3,:));%求平均停留时间和等待时间;queue_num=zeros(1,2*peo_num+1);queue_time=zeros(1,2*peo_num+1);n3=1;%while循环求每个时间队列的长度;while n1<=peo_numif arr_time(n1)<lea_time(n2)queue_num(1,n3)=n1-n2+1;queue_time(1,n3)=arr_time(n1);n1=n1+1;elsequeue_num(1,n3)=n1-n2-1;queue_time(1,n3)=lea_time(n2);n2=n2+1;end;end;while n2<=peo_numn3=n3+1;queue_num(1,n3)=peo_num-n2;queue_time(1,n3)=lea_time(n2);n2=n2+1;end;figure;stairs(queue_time,queue_num,'k');%绘出队列长度的时间变化曲线, stairs 是Matlab的函数legend('Queue Length Curve',0);temp=diff(queue_time);overtime=max(queue_time);queue_l=sum(temp.*queue_num(22*peo_num+1)))/overtime;use_rate=sum(temp(find(queue_num)))/overtime;maxque=max(queue_num); % 最大队长%然后在Matlab命令窗口中输入命令即可,如:[maxque,mwait_t,mstay_t,queue_l,use_rate]=mm1queue(0.5,0.4,200),其中0.5表示平均来到时间间隔,%0.4表示平均离开时间,200为人数注意以下几点:1.首先因为M/M/1中,各个实体的到达时间和服务时间相互独立,所以才能首先把每个实体的这两个时间,根据所给的参数产生模拟的随机数来。

MM1排队系统仿真matlab实验报告

MM1排队系统仿真matlab实验报告

M/M/1排队系统实验报告一、实验目的本次实验要求实现M/M/1单窗口无限排队系统的系统仿真,利用事件调度法实现离散事件系统仿真,并统计平均队列长度以及平均等待时间等值,以与理论分析结果进行对比。

二、实验原理根据排队论的知识我们知道,排队系统的分类是根据该系统中的顾客到达模式、服务模式、服务员数量以及服务规则等因素决定的。

1、 顾客到达模式设到达过程是一个参数为λ的Poisson 过程,则长度为t 的时间内到达k 个呼叫的概率 服从Poisson 分布,即e t kk k t t p λλ-=!)()(,⋅⋅⋅⋅⋅⋅⋅⋅⋅=,2,1,0k ,其中λ>0为一常数,表示了平均到达率或Poisson 呼叫流的强度。

2、 服务模式设每个呼叫的持续时间为i τ,服从参数为μ的负指数分布,即其分布函数为{}1,0t P X t e t μ-<=-≥3、 服务规则先进先服务的规则(FIFO )4、 理论分析结果在该M/M/1系统中,设λρμ=,则稳态时的平均等待队长为1Q ρλρ=-,顾客的平均等待时间为T ρμλ=-。

三、实验内容M/M/1排队系统:实现了当顾客到达分布服从负指数分布,系统服务时间也服从负指数分布,单服务台系统,单队排队,按FIFO (先入先出队列)方式服务。

四、采用的语言MatLab 语言源代码:clear;clc;%M/M/1排队系统仿真SimTotal=input('请输入仿真顾客总数SimTotal='); %仿真顾客总数;Lambda=0.4; %到达率Lambda;Mu=0.9; %服务率Mu;t_Arrive=zeros(1,SimTotal);t_Leave=zeros(1,SimTotal);ArriveNum=zeros(1,SimTotal);LeaveNum=zeros(1,SimTotal);Interval_Arrive=-log(rand(1,SimTotal))/Lambda;%到达时间间隔Interval_Serve=-log(rand(1,SimTotal))/Mu;%服务时间t_Arrive(1)=Interval_Arrive(1);%顾客到达时间ArriveNum(1)=1;for i=2:SimTotalt_Arrive(i)=t_Arrive(i-1)+Interval_Arrive(i);ArriveNum(i)=i;endt_Leave(1)=t_Arrive(1)+Interval_Serve(1);%顾客离开时间LeaveNum(1)=1;for i=2:SimTotalif t_Leave(i-1)<t_Arrive(i)t_Leave(i)=t_Arrive(i)+Interval_Serve(i);elset_Leave(i)=t_Leave(i-1)+Interval_Serve(i);endLeaveNum(i)=i;endt_Wait=t_Leave-t_Arrive; %各顾客在系统中的等待时间t_Wait_avg=mean(t_Wait);t_Queue=t_Wait-Interval_Serve;%各顾客在系统中的排队时间t_Queue_avg=mean(t_Queue);Timepoint=[t_Arrive,t_Leave];%系统中顾客数随时间的变化Timepoint=sort(Timepoint);ArriveFlag=zeros(size(Timepoint));%到达时间标志CusNum=zeros(size(Timepoint));temp=2;CusNum(1)=1;for i=2:length(Timepoint)if (temp<=length(t_Arrive))&&(Timepoint(i)==t_Arrive(temp)) CusNum(i)=CusNum(i-1)+1;temp=temp+1;ArriveFlag(i)=1;CusNum(i)=CusNum(i-1)-1;endend%系统中平均顾客数计算Time_interval=zeros(size(Timepoint));Time_interval(1)=t_Arrive(1);for i=2:length(Timepoint)Time_interval(i)=Timepoint(i)-Timepoint(i-1);endCusNum_fromStart=[0 CusNum];CusNum_avg=sum(CusNum_fromStart.*[Time_interval 0] )/Timepoint(end);QueLength=zeros(size(CusNum));for i=1:length(CusNum)if CusNum(i)>=2QueLength(i)=CusNum(i)-1;elseQueLength(i)=0;endendQueLength_avg=sum([0 QueLength].*[Time_interval 0] )/Timepoint(end);%系统平均等待队长%仿真图figure(1);set(1,'position',[0,0,1000,700]);subplot(2,2,1);title('各顾客到达时间和离去时间');stairs([0 ArriveNum],[0 t_Arrive],'b');hold on;stairs([0 LeaveNum],[0 t_Leave],'y');legend('到达时间','离去时间');hold off;subplot(2,2,2);stairs(Timepoint,CusNum,'b')title('系统等待队长分布');xlabel('时间');ylabel('队长');subplot(2,2,3);title('各顾客在系统中的排队时间和等待时间');stairs([0 ArriveNum],[0 t_Queue],'b');stairs([0 LeaveNum],[0 t_Wait],'y');hold off;legend('排队时间','等待时间');%仿真值与理论值比较disp(['理论平均等待时间t_Wait_avg=',num2str(1/(Mu-Lambda))]);disp(['理论平均排队时间t_Wait_avg=',num2str(Lambda/(Mu*(Mu-Lambda)))]);disp(['理论系统中平均顾客数=',num2str(Lambda/(Mu-Lambda))]);disp(['理论系统中平均等待队长=',num2str(Lambda*Lambda/(Mu*(Mu-Lambda)))]);disp(['仿真平均等待时间t_Wait_avg=',num2str(t_Wait_avg)])disp(['仿真平均排队时间t_Queue_avg=',num2str(t_Queue_avg)])disp(['仿真系统中平均顾客数=',num2str(CusNum_avg)]);disp(['仿真系统中平均等待队长=',num2str(QueLength_avg)]);五、数据结构1.仿真设计算法(主要函数)利用负指数分布与泊松过程的关系,产生符合泊松过程的顾客流,产生符合负指数分布的随机变量作为每个顾客的服务时间:Interval_Arrive=-log(rand(1,SimTotal))/Lambda;%到达时间间隔,结果与调用exprnd(1/Lambda,m)函数产生的结果相同Interval_Serve=-log(rand(1,SimTotal))/Mu;%服务时间间隔t_Arrive(1)=Interval_Arrive(1);%顾客到达时间时间计算t_Wait=t_Leave-t_Arrive;%各顾客在系统中的等待时间t_Queue=t_Wait-Interval_Serve; %各顾客在系统中的排队时间由事件来触发仿真时钟的不断推进。

排队模型(掌握mm1,mmc,mm1k)

排队模型(掌握mm1,mmc,mm1k)
排队模型
凯里学院 余英
精选2021版课件
1
模型要点
1、掌握排队模型的基本概念 2、了解常见的分布函数及生灭过程 3、掌握典型排队系统模型的结构及应用
精选2021版课件
2
排队模型的基本概念
一、引言 1、什么是排队模型(排队论)? 排队论是研究拥挤现象的一门学科。
它是在研究各种排队系统概率规律性的基础上, 解决有关排队系统的最优化设计(静态)和最 优控制(动态)问题。
19 72 4 8 1 29 106 1 3 1 39 135 2 4 10
20 80 3 1 0 30 109 2 5 0 40 139 4 3 8
21 81 2 2 2 31 114 1 2 0 41 142 1
9
22 83 3 3 2 32 116 8 1 0
精选2021版课件
20
到达间隔分布表
1)、输入过程(顾客到达的方式)
a、顾客的总体(顾客源)的组成可能是有限的,也 可能是无限的;
b、顾客相继到达的时间间隔可以是确定的,也可以 是随机的,对于随机的情形,要知道单位时间内的 顾客到达数或相继到达的间隔时间的概率分布;
c 、输入过程可以是平稳的(描述相继到达的间隔时 间分布和所含参数(如期望值、方差等)都是与时 间无关的),否则成为非平稳的,我们研究平稳的。
到达间隔 次 (分钟) 数
1
6
2
10
3
8
4
6
5
3
6
2
7
2
8
1
9
1
10以上 1
合计 40
服务时间分布表
服务时间 次 (分钟) 数
1
10
2
10

排队论代码

排队论代码

1.排队论import java.util.Arrays;import java.util.Random;import java.util.Scanner;class MM1{/** MM1所具有的函数有以下几个:* MM1:构造函数,知道langda和miu以及number仿真总人数就可以进行仿真* Produce:通过负指数分布landa的值产生到达人群的时间间隔,计算得出时间点(泊松分布是产生人群,与到达人群是无关的)* Leave:通过负指数分布miu的值计算服务时间,队列时间以及等待时间* Print_need:打印出所需要的平均逗留时间,平均队列时间,平均服务时间与平均队长(这是仿真模型,打印出来的是仿真结果)* Print_people:打印出编号为x的人的到达时间,队列时间,服务时间与离开时间* Print_time:打印出时间为T时的队列人数,此时的平均服务时间,到达该窗口的累计人数,当前窗口人数*/double in;//in为langda,一秒钟到来了几个人double out;//out为miu,人离开的速率,完成速率double[ ] arrive_time;//到达时间间隔double[ ] arrivetime;//顾客到达时间double[ ] serve_time;//服务时间double[ ] leave_time;//离开时间double[ ] wait_time;//等待(在服务窗的总时间)时间double[ ] queue_time;//排队时间MM1(double in,double out,int number){arrive_time=new double[number];//到达时间间隔arrivetime=new double[number];//顾客到达时间serve_time=new double[number];//服务时间leave_time=new double[number];//顾客离开时间wait_time=new double[number];//等待时间,(在服务窗的总时间)queue_time=new double[number];//排队时间this.in=in;this.out=out;}void Produce(int number){for(int i=0;i<number;i++){Random random=new java.util.Random();// 定义随机类double result=random.nextDouble();// 返回0到1之间的小数arrive_time[i]=Math.log(result)*-1/in;//负指数分布函数产生到达时间间隔}arrivetime[0]=arrive_time[0];for(int i=1;i<number;i++){arrivetime[i]=arrivetime[i-1]+arrive_time[i];//通过到达时间间隔计算出到达时间}}void Leave(int number){for(int i=0;i<number;i++){Random random=new java.util.Random();// 定义随机类double result=random.nextDouble();// 返回0到1之间的小数if(result<0) result*=-1;serve_time[i]=Math.log(result)*-1/out;}leave_time[0]=serve_time[0]+arrivetime[0];/** 离开时间的计算方法:* 如果前面那个人的离开时间大于我,我的离开时间等于他的离开时间加上我的服务时间* 如果前面那个人的离开时间小于我,我的离开时间等于我的到达时间加上我的服务时间*/for(int i=1;i<number;i++){if(leave_time[i-1]<arrivetime[i])leave_time[i]=arrivetime[i]+serve_time[i];elseleave_time[i]=leave_time[i-1]+serve_time[i];}for(int i=0;i<number;i++){queue_time[i]=leave_time[i]-arrivetime[i]-serve_time[i];//队列时间的计算wait_time[i]=leave_time[i]-arrivetime[i];//等待时间的计算}}void Print_people_x(int x)//x是编号{System.out.println("第"+x+"个人的数据如下:");System.out.println("到达时间:"+arrivetime[x]);System.out.println("队列时间:"+queue_time[x]);System.out.println("服务时间:"+serve_time[x]);System.out.println("离开时间:"+leave_time[x]);}void Print_need(int x)//x是规模{double[] line_wait;//当前队长(包括正在服务的)double sum_wait=0,sum_queue=0,sum_serve=0,sum_line=0;for(int i=0;i<x;i++){sum_wait+=wait_time[i];sum_queue+=queue_time[i];sum_serve+=serve_time[i];}sum_wait/=x;sum_queue/=x;sum_serve/=x;System.out.println("平均逗留时间为:"+sum_wait);System.out.println("平均队列时间为:"+sum_queue);System.out.println("平均服务时间为:"+sum_serve);double last_time=leave_time[x-1];line_wait=new double[(int)last_time+1];int time=0;for(time=0;time<last_time;time++){for(int i=0;i<x;i++){if(time>arrivetime[i]&&time<leave_time[i]){line_wait[time]++;}}sum_line+=line_wait[time];}sum_line/=time;System.out.println("平均队长为:"+sum_line);}void Print_time(double time,int number){int queue_people=0;int arrive_people=0;int leave_people=0;double servertime=0;for(int i=0;i<number;i++){if(arrivetime[i]<time&&leave_time[i]>time)queue_people++;if(arrivetime[i]<time)arrive_people++;if(leave_time[i]<time)leave_people++;}servertime=(time-arrive_time[0])/(leave_people+1);System.out.println("第"+time+"时间的数据如下:");System.out.println("此时队列人数有:"+queue_people);System.out.println("此时的平均服务时间"+servertime);System.out.println("到达该窗口累计人数:"+arrive_people);System.out.println("离开此窗口的累计人数:"+leave_people);}}class MMN extends MM1{int N;MMN(double in, double out, int number,int N) {super(in, out, number);this.N=N;// TODO Auto-generated constructor stub}void Leave(int number){for(int i=0;i<number;i++){Random random=new java.util.Random();// 定义随机类double result=random.nextDouble();// 返回0到1之间的小数if(result<0) result*=-1;serve_time[i]=Math.log(result)*-1/out;}double[]leave_x=new double[N];for(int i=0;i<N;i++){leave_time[i]=serve_time[i]+arrivetime[i];leave_x[i]=leave_time[i];}for(int i=N;i<number;i++){Arrays.sort(leave_x);if(leave_x[0]<arrivetime[i])//到达时间比最小的都大时{leave_time[i]=arrivetime[i]+serve_time[i];leave_x[0]=leave_time[i];}else if(leave_x[0]>arrivetime[i]){leave_time[i]=leave_x[0]+serve_time[i];leave_x[0]=leave_time[i];}}for(int i=0;i<number;i++){queue_time[i]=leave_time[i]-arrivetime[i]-serve_time[i];wait_time[i]=leave_time[i]-arrivetime[i];}}}public class Queue {public static void main(String[] args) {// TODO Auto-generated method stubint number=10000;int flag=0;while(flag!=5){System.out.println("济民宝宝为郭阳小姐姐服务:");System.out.println("本系统提供如下服务:");System.out.println("1.提供Print_need的测试样例,输入1回车可见(具体代码见Queue类的注释1部分)");System.out.println("2.提供Print_time的测试样例,输入2回车可见(具体代码见Queue类的注释2部分)");System.out.println("3.提供Print_people的测试样例,输入3回车可见(具体代码见Queue类的注释3部分)");System.out.println("4.提供排队论仿真模型(可自行输入输出),输入4回车可见(具体代码见Queue类的注释4部分)");System.out.println("5.结束");Scanner in =new Scanner(System.in);flag=in.nextInt();/** 注释1* 函数的具体功能见MM1类的注释* 包含MM1和MM3的Print_need*/if(flag==1){System.out.println("这是一个测试类:测试数据集为10000,langda=0.2,miu=0.5的MM1模型");MM1 test1=new MM1(0.2,0.5,number);test1.Produce(number);test1.Leave(number);test1.Print_need(number);System.out.println("\n--------------OvO华丽的分割线QAQ-------------\n");System.out.println("这是一个测试类:测试数据集为10000,langda=0.2,miu=0.5的MM3模型");MMN test2=new MMN(0.2,0.5,number,3);test2.Produce(number);test2.Leave(number);test2.Print_need(number);}/** 注释2* 包含MM1和MM3的Print_time*/if(flag==2){System.out.println("这是一个测试类:测试数据集为10000,langda=0.2,miu=0.5的MM1模型");MM1 test1=new MM1(0.2,0.5,number);double time=100.0;test1.Produce(number);test1.Leave(number);test1.Print_time(time, number);System.out.println("\n--------------OvO华丽的分割线QAQ-------------\n");System.out.println("这是一个测试类:测试数据集为10000,langda=0.2,miu=0.5的MM3模型");MMN test2=new MMN(0.2,0.5,number,3);test2.Produce(number);test2.Leave(number);test2.Print_time(time, number);}/** 注释3* 包含MM1和MM3的Print_people*/if(flag==3){System.out.println("这是一个测试类:测试数据集为10000,langda=0.2,miu=0.5的MM1模型");MM1 test1=new MM1(0.2,0.5,number);double time=100.0;test1.Produce(number);test1.Leave(number);test1.Print_people_x(100);System.out.println("\n--------------OvO华丽的分割线QAQ-------------\n");System.out.println("这是一个测试类:测试数据集为10000,langda=0.2,miu=0.5的MM3模型");MMN test2=new MMN(0.2,0.5,number,3);test2.Produce(number);test2.Leave(number);test2.Print_time(time, number);test2.Print_people_x(100);}/** 注释4* 自选输入输出*/if(flag==4){System.out.println("请选择你想模拟的是MM1还是MMN");System.out.println("MM1的话输入1换行,MMN的话输入2换行");Scanner one=new Scanner(System.in);int flag_one=one.nextInt();System.out.println("请输入langda:");double langda=one.nextDouble();System.out.println("请输入miu:");double miu=one.nextDouble();System.out.println("请输入仿真数量集:");number=one.nextInt();System.out.println("请输入你想仿真的方法:");System.out.println("1.Print_need,输入1回车");System.out.println("2.Print_people,输入2回车");System.out.println("3.Print_time,输入3回车");int method=one.nextInt();if(flag_one==1){MM1 test1=new MM1(langda,miu,number);test1.Produce(number);test1.Leave(number);switch(method){case 1:test1.Print_need(number);break;case 2:System.out.println("请输入你想print_people的编号(不能大于你给的数据集):");int people=one.nextInt();test1.Print_people_x(people);break;case 3:System.out.println("请输入你想print_time的时间(不能大于你给的数据集的最后一个人的离开时间):");double time_one=one.nextDouble();test1.Print_time(time_one, number);break;}System.out.println("\n--------------OvO华丽的分割线QAQ-------------\n");}else if(flag_one==2){System.out.println("请输入你想输入的窗口数");int window_number=one.nextInt();MMN test1=new MMN(langda,miu,number,window_number);test1.Produce(number);test1.Leave(number);switch(method){case 1:test1.Print_need(number);break;case 2:System.out.println("请输入你想print_people的编号(不能大于你给的数据集):");int people=one.nextInt();test1.Print_people_x(people);break;case 3:System.out.println("请输入你想print_time的时间(不能大于你给的数据集的最后一个人的离开时间):");double time_one=one.nextDouble();test1.Print_time(time_one, number);break;}}}System.out.println("5秒后返回主菜单");for(int i=0;i<3;i++)System.out.println();//清屏try {Thread.sleep(5000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}}2.生物群的竞争排斥模型function dx=fun(t,x,r1,r2,n1,n2,s1,s2)r1=0.3;r2=4.7;n1=419059;n2=419059;s1=1;s2=1;dx=[r1*x(1)*(1-x(1)/n1-s1*x(2)/n2);r2*x(2)*(1-s2*x(1)/n1-x(2)/n2)];h=10;%所取时间点间隔ts=[0:h:60];%时间区间x0=[0,2.3];%初始条件opt=odeset('reltol',1e-6,'abstol',1e-9);%相对误差1e-6,绝对误差1e-9[t,x]=ode45(@fun,ts,x0,opt);%使用5级4阶龙格—库塔公式计算plot(t,x(:,1),'r',t,x(:,2),'b','LineWidth',2),grid;pause;plot(x(:,1),x(:,2),'LineWidth',2),grid %作相轨线。

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

修理店仿真报告一.问题:①修理店空闲的概率;②店有三个顾客的概率;③店至少有一个顾客的概率;④在店顾客的平均数;⑤顾客在店的平均逗留时间;⑥顾客必须在店消耗15分钟以上的概率。

二.求解问题的方法:①修理店空闲的概率:(sim_time-area_server_status) / sim_time);②店有三个顾客的概率:area_3_in_q/sim_time);③店至少有一个顾客的概率:abv_1/sim_time);④在店顾客的平均数:area_num_in_h/sim_time);⑤顾客在店的平均逗留时间:(total_of_delays+total_of_server)/num_custs_delayed );⑥顾客必须在店消耗15分钟以上概率:abv_15/num_custs_delayed);三。

求解过程中计算统计量的方法:①area_server_status += server_status * time_since_last_event;②//店有三个顾客的概率if(server_status == BUSY)//服务台忙,则有队列中有两个顾客if(num_in_q == 2)area_3_in_q += time_since_last_event;③//店至少有一个顾客的概率if(server_status == BUSY) //服务台忙,则店至少有一个顾客abv_1 += time_since_last_event;④//在店顾客的平均数if(server_status == BUSY) //服务台忙,总的顾客数为排队顾客数加一area_num_in_h += (num_in_q+1) * time_since_last_event;⑤total_of_server += time_next_event[2]-sim_time;//总的服务时间加一个服务时间为新的服务总时间delay = sim_time - time_arrival[1];//排队时间=当前时间-这个人来的时间total_of_delays += delay;⑥//离开时总的消耗时间大于15,必须在店消耗15分钟以上的顾客数加一if((delay+time_next_event[2]-sim_time)>15)abv_15++;//到达时总的服务时间大于15,必须在店消耗15分钟以上的顾客数加一if((time_next_event[2]-sim_time)>15)abv_15++;程序代码:/* External definitions for single-server queueing system. */#include <stdio.h>#include <math.h>/*#include "lcgrand.h" Header file for random-number generator. */#define Q_LIMIT 100 /* Limit on queue length.队伍最长100人*/#define BUSY 1 /* Mnemonics for server's being busy 忙碌状态*/#define IDLE 0 /* and idle.空闲状态*/int next_event_type, //下一个事件类型num_custs_delayed, //已模拟的顾客数num_delays_required, //模拟的顾客数num_events,//事件数num_in_q, //队列中的顾客数server_status;//服务状态float area_num_in_q,//有顾客的时间area_server_status,//总的服务时间mean_interarrival,//平均顾客到达时间间隔mean_service,//平均服务时间sim_time, //模拟时间time_arrival[Q_LIMIT + 1], //到来的时间time_last_event, //上一个事件的时间time_next_event[3],//下一个事件的时间total_of_delays; //总的排队时间///////////////////////////////////////////////////////////////////// /////////////////添加的变量float abv_15, //15分钟以上的顾客数量total_of_server, //所有顾客的总的服务时间area_3_in_q, //有3个顾客的时间abv_1, //至少有一个顾客的时间area_num_in_h; //顾客总数///////////////////////////////////////////////////////////////////// ///////////////FILE *infile, *outfile;/* The following 3 declarations are for use of the random-number generatorlcgrand and the associated functions lcgrandst and lcgrandgt for seedmanagement. This file (named lcgrand.h) should be included in any programusing these functions by executing#include "lcgrand.h"before referencing the functions. */float lcgrand(int stream);void lcgrandst(long zset, int stream);long lcgrandgt(int stream);void initialize(void);void timing(void);void arrive(void);void depart(void);void report(void);void update_time_avg_stats(void);float expon(float mean);main() /* Main function. */{/* Open input and output files. */infile = fopen("mm1.in", "r");outfile = fopen("mm1.out", "w");/* Specify the number of events for the timing function. */ num_events = 2;//两种事件/* Read input parameters. */fscanf(infile, "%f %f %d", &mean_interarrival, &mean_service,&num_delays_required);/* Write report heading and input parameters. 输出*/fprintf(outfile, "Single-server queueing system\n\n");fprintf(outfile, "Mean interarrival time%11.3f minutes\n\n",mean_interarrival);fprintf(outfile, "Mean time%16.3f minutes\n\n", mean_service);fprintf(outfile, "Number of customers%14d\n\n", num_delays_required);/* Initialize the simulation.初始化仿真*/initialize();//初始化/* Run the simulation while more delays are still needed.没服务完,仿真继续*/while (num_custs_delayed < num_delays_required) {//当已服务顾客数小于1000时/* Determine the next event. 确定下一事件*/timing();/* Update time-average statistical accumulators.时间记录更新*/update_time_avg_stats();/* Invoke the appropriate event function. 根据事件的不同,调用不同的函数*/switch (next_event_type) {case 1:arrive();//到达break;case 2:depart();//离开break;}}/* Invoke the report generator and end the simulation. */ report();fclose(infile);fclose(outfile);return 0;}void initialize(void) /* Initialization function. */{/* Initialize the simulation clock. 仿真时间置为0*/sim_time = 0.0;/* Initialize the state variables.最开始状态初始化*/server_status = IDLE;//服务空闲num_in_q = 0; //队伍里无人排队time_last_event = 0.0; //上一个事件的时间,最开始肯定是0开始/* Initialize the statistical counters. */num_custs_delayed = 0; //已经服务的人数total_of_delays = 0.0;//总的排队时间area_num_in_q = 0.0;//有顾客的时间area_server_status = 0.0;//总的服务时间///////////////////////////////////////////////////////////////////// //////////////添加的变量的初始化area_3_in_q = 0.0;//有3个顾客的时间abv_1 = 0.0;//有顾客的时间area_num_in_h = 0.0;//顾客的总数total_of_server = 0.0;//所有顾客的所有的服务的时间abv_15 = 0.0;//消耗15分钟以上的顾客数///////////////////////////////////////////////////////////////////// /////////////* Initialize event list. 初始化事件列表Since no customers are present, the departure(service completion) event is eliminated from consideration. 无顾客存在和离开*/time_next_event[1] = sim_time + expon(mean_interarrival);//下一事件是来的时间time_next_event[2] = 1.0e+30; //下一事件是离开的时间}void timing(void) /* Timing function. */{int i;float min_time_next_event = 1.0e+29; //像指针一样的对于当前服务的人来说下一个事件的时间next_event_type = 0;/* Determine the event type of the next event to occur.接下来将要发生的事件的类型*/for (i = 1; i <= num_events; ++i)if (time_next_event[i] < min_time_next_event) {//下一事件是来的时间跟离开时间比较min_time_next_event = time_next_event[i];next_event_type = i;}/* Check to see whether the event list is empty. */if (next_event_type == 0) {/* The event list is empty, so stop the simulation. 无事件,停止仿真过程*/fprintf(outfile, "\nEvent list empty at time %f", sim_time);exit(1);}/* The event list is not empty, so advance the simulation clock. 有事件,进行仿真过程*/sim_time = min_time_next_event; //仿真的时间就是当前事件的时间}void arrive(void) /* Arrival event function. */{float delay;/* Schedule next arrival.计划下一次的到来*/time_next_event[1] = sim_time + expon(mean_interarrival);/* Check to see whether server is busy. 检测是否在服务状态*/if (server_status == BUSY) {/* Server is busy, so increment number of customers in queue. 在服务则排队多一人*/++num_in_q;/* Check to see whether an overflow condition exists. 检测人数是否超出*/if (num_in_q > Q_LIMIT) {/* The queue has overflowed, so stop the simulation. */fprintf(outfile, "\nOverflow of the array time_arrival at");fprintf(outfile, " time %f", sim_time);exit(2);}/* There is still room in the queue, so store the time of arrival of thearriving customer at the (new) end of time_arrival. 队列中仍有空间时,记录新到达的时间*/time_arrival[num_in_q] = sim_time;//在这个时间的时候有这么多的排队人数,用于计算3顾客的问题}else { //服务空闲的状况/* Server is idle, so arriving customer has a delay of zero. (Thefollowing two statements are for program clarity and do not affectthe results of the simulation.) */delay = 0.0;total_of_delays += delay; //总的排队时间/* Increment the number of customers delayed, and make server busy. */++num_custs_delayed; //已经模拟的顾客数加1server_status = BUSY; //人到来,服务开始/* Schedule a departure (service completion). 服务完成*/time_next_event[2] = sim_time + expon(mean_service);//这个人离开的时间为现在时间+服务时间///////////////////////////////////////////////////////////////////// //////////////总的服务时间加上当前服务时间,更新总的服务时间total_of_server += time_next_event[2]-sim_time;//总的服务时间加一个服务时间为新的服务总时间//总的服务时间大于15,必须在店消耗15分钟以上的顾客数加一if((time_next_event[2]-sim_time)>15)//如果这个人服务时间超过15分钟则耗费15分钟人数加1abv_15++;///////////////////////////////////////////////////////////////////// ////////////}}void depart(void) /* Departure event function. 讨论离开事件{int i;float delay;/* Check to see whether the queue is empty.检测队列是否为空*/if (num_in_q == 0) {/* The queue is empty so make the server idle and eliminate thedeparture (service completion) event from consideration. 队列空,服务空闲*/server_status = IDLE;time_next_event[2] = 1.0e+30; //离开的时间无限大(无人离开)}else {/* The queue is nonempty, so decrement the number of customers inqueue. 有人离开,队列人数减少*/--num_in_q;/* Compute the delay of the customer who is beginning and updatethe total delay accumulator. */delay = sim_time - time_arrival[1];//排队时间=当前时间-这个人来的时间total_of_delays += delay;/* Increment the number of customers delayed, and schedule departure.已经服务人数+1 */++num_custs_delayed; //服务人数加1time_next_event[2] = sim_time + expon(mean_service);//当前接受服务的人的离开时间///////////////////////////////////////////////////////////////////////////////////总的服务时间加上当前服务时间,更新总的服务时间total_of_server += time_next_event[2]-sim_time;//总的消耗时间大于15,必须在店消耗15分钟以上的顾客数加一if((delay+time_next_event[2]-sim_time)>15)abv_15++;///////////////////////////////////////////////////////////////////// /////////////* Move each customer in queue (if any) up one place.有人离开,队列前移*/for (i = 1; i <= num_in_q; ++i)time_arrival[i] = time_arrival[i + 1];//人的到达时间也前移}}void report(void) /* Report generator function. */{/* Compute and write estimates of desired measures ofperformance. */fprintf(outfile, "\n\nAverage delay in queue%11.3f minutes\n\n",total_of_delays / num_custs_delayed);fprintf(outfile, "Average number in queue%10.3f\n\n",area_num_in_q / sim_time);fprintf(outfile, "Server utilization%15.3f\n\n",area_server_status / sim_time);fprintf(outfile, "Time simulation ended%12.3f minutes", sim_time);printf("统计量:\n");///////////////////////////////////////////////////////////////////// /////总时间减去服务台忙的时间除以总时间,得到服务台空闲的概率printf("①修理店空闲的概率:%24.3f\n",(sim_time-area_server_status) / sim_time);printf("②店有三个顾客的概率:%20.3f\n",area_3_in_q/sim_time);printf("③店至少有一个顾客的概率:%16.3f\n",abv_1/sim_time);printf("④在店顾客的平均数:%22.3f\n",area_num_in_h/sim_time);printf("⑤顾客在店的平均逗留时间:%16.3f\n",(total_of_delays+total_of_server)/num_custs_delayed );printf("⑥顾客必须在店消耗15分钟以上概率:%8.3f\n\n", abv_15/num_custs_delayed);printf("仿真时间:%12.3f minutes\n\n", sim_time);///////////////////////////////////////////////////////////////////// /}void update_time_avg_stats(void) /* Update area accumulators for time-averagestatistics.更新时间平均时间统计*/{float time_since_last_event;/* Compute time since last event, and update last-event-time marker.上个事件到现在的时间并更新最后事件的time_since_last_event = sim_time - time_last_event;//两个事件的时间差time_last_event = sim_time;/* Update area under number-in-queue function. 有顾客的时间=队列中的人数*时间差*/area_num_in_q += num_in_q * time_since_last_event;/* Update area under server-busy indicator function. 总的服务时间=所有时间差相加*/area_server_status += server_status * time_since_last_event;///////////////////////////////////////////////////////////////////// //////////////店有三个顾客的概率if(server_status == BUSY) //服务台忙,则有队列中有if(num_in_q == 2)area_3_in_q += time_since_last_event;//if(server_status == IDLE) //服务台空闲,则有队列中有三个顾客// if(num_in_q == 3)// area_3_in_q += time_since_last_event;//店至少有一个顾客的概率if(server_status == BUSY) //服务台忙,则店至少有一个顾客abv_1 += time_since_last_event;//if(server_status == IDLE) //服务台空闲,则有队列中至少有一个顾客// if(num_in_q>0)// abv_1 += time_since_last_event;//在店顾客的平均数if(server_status == BUSY) //服务台忙,总的顾客数为排队顾客数加一area_num_in_h += (num_in_q+1) * time_since_last_event;//if(server_status == IDLE) //服务台空闲,总的顾客数为排队顾客数// area_num_in_h += num_in_q * time_since_last_event; ///////////////////////////////////////////////////////////////////// ////////////}float expon(float mean) /* Exponential variate generation function. */{/* Return an exponential random variate with mean "mean". */return -mean * log(lcgrand(10));//自己学号的后两位}/* Prime modulus multiplicative linear congruential generator Z[i] = (630360016 * Z[i-1]) (mod(pow(2,31) - 1)), based on Marse and Roberts'portable FORTRAN random-number generator UNIRAN.Multiple (100) streams aresupported, with seeds spaced 100,000 apart. Throughout, input argument"stream" must be an int giving the desired stream number. The header filelcgrand.h must be included in the calling program (#include "lcgrand.h")before using these functions.Usage: (Three functions)1. To obtain the next U(0,1) random number from stream "stream," executeu = lcgrand(stream);where lcgrand is a float function. The float variable u will contain thenext random number.2. To set the seed for stream "stream" to a desired value zset, executelcgrandst(zset, stream);where lcgrandst is a void function and zset must be along set to thedesired seed, a number between 1 and 2147483646 (inclusive). Defaultseeds for all 100 streams are given in the code.3. To get the current (most recently used) integer in the sequence beinggenerated for stream "stream" into the long variable zget, executezget = lcgrandgt(stream);where lcgrandgt is a long function. *//* Define the constants. */#define MODLUS 2147483647#define MULT1 24112#define MULT2 26143/* Set the default seeds for all 100 streams. */static long zrng[] ={ 1,1973272912, 281629770, 20006270,1280689831,2096730329,1933576050, 913566091, 246780520,1363774876, 604901985,1511192140,1259851944,824064364, 150493284, 242708531, 75253171,1964472944,1202299975,233217322,1911216000, 726370533, 403498145, 993232223,1103205531,762430696,1922803170,1385516923, 76271663, 413682397, 726466604,336157058,1432650381,1120463904, 595778810, 877722890,1046574445,68911991,2088367019, 748545416, 622401386,2122378830, 640690903,1774806513,2132545692,2079249579, 78130110, 852776735,1187867272,1351423507,1645973084,1997049139,922510944,2045512870, 898585771,243649545,1004818771, 773686062, 403188473, 372279877,1901633463,498067494,2087759558, 493157915, 597104727,1530940798,1814496276,536444882,1663153658, 855503735, 67784357,1432404475, 619691088,119025595, 880802310, 176192644,1116780070, 277854671,1366580350,1142483975,2026948561,1053920743,786262391,1792203830,1494667770,1923011392,1433700034,1244184613,1147297105, 539712780,1545929719,190641742,1645390429, 264907697, 620389253,1502074852, 927711160,364849192,2049576050, 638580085, 547070247 };/* Generate the next random number. */float lcgrand(int stream){long zi, lowprd, hi31;zi = zrng[stream];lowprd = (zi & 65535) * MULT1;hi31 = (zi >> 16) * MULT1 + (lowprd >> 16);zi = ((lowprd & 65535) - MODLUS) +((hi31 & 32767) << 16) + (hi31 >> 15);if (zi < 0) zi += MODLUS;lowprd = (zi & 65535) * MULT2;hi31 = (zi >> 16) * MULT2 + (lowprd >> 16);zi = ((lowprd & 65535) - MODLUS) +((hi31 & 32767) << 16) + (hi31 >> 15);if (zi < 0) zi += MODLUS;zrng[stream] = zi;return (zi >> 7 | 1) / 16777216.0;}void lcgrandst (long zset, int stream) /* Set the current zrng for stream"stream" to zset. */{zrng[stream] = zset;}long lcgrandgt (int stream) /* Return the current zrng forstream "stream". */ {return zrng[stream]; }。

相关文档
最新文档