Wolfram 语言与系统参考资料中心

QueueingNetworkProcess

QueueingNetworkProcess[γ,r,μ,c]

表示一个开放式 (Jackson) 排队网络过程，其中到达向量为 γ，路线概率矩阵为 r，服务向量为 μ，服务通道向量为 c.

QueueingNetworkProcess[γ,r,μ,c,k]

表示闭合 (Gordon–Newell)排队网络过程，系统中有k 个任务.

范例

打开所有单元关闭所有单元

基本范例 (2)

定义一个闭合排队网络过程：

Wolfram Language code:

γ = {0, 0, 0, 0};μ = {1, 0.7, 1, 2};
r = {{0, 0.5, 0.3, 0.2}, {1, 0, 0, 0}, {1, 0, 0, 0}, {1, 0, 0, 0}};
c = {1, 1, 1, 1};k = 7;

Wolfram Language code: 𝒩 = QueueingNetworkProcess[γ, r, μ, c, k];

对过程进行仿真：

Wolfram Language code: data = RandomFunction[𝒩, {0, 100}]

Wolfram Language code: ListStepPlot[data, Filling -> Axis]

定义一个开放式排队网络过程：

Wolfram Language code:

γ = {4, 5};μ = {8, 10};
r = {{0, 1 / 2}, {1 / 4, 0}};
c = {1, 1};

Wolfram Language code: 𝒩 = QueueingNetworkProcess[γ, r, μ, c];

网络中第一个节点的属性：

Wolfram Language code: QueueProperties[{𝒩, 1}]

范围 (10)

简单前馈网络 (2)

定义一个具有三个串联队列的网络：

Wolfram Language code:

γ = {3., 0, 0};μ = {4, 7, 8.2};
r = {{0, 1, 0}, {0, 0, 1}, {0, 0, 0}};
c = {1, 1, 1};

Wolfram Language code: 𝒩 = QueueingNetworkProcess[γ, r, μ, c];

网络的路线概率矩阵：

Wolfram Language code: r//MatrixForm

计算网络稳定状态的概率：

Wolfram Language code: Probability[x == 2 && y == 1 && z == 3, {x, y, z}𝒩[∞]]

使用 Burke 定理验证结果：

Wolfram Language code:

Probability[x == 2 && y == 1 && z == 3, {x, y, z}ProductDistribution[QueueingProcess[3, 4][∞], QueueingProcess[3, 7][∞], QueueingProcess[3, 8.2][∞]]]

网络中第一个节点的性能测量值：

Wolfram Language code: QueueProperties[{𝒩, 1}]

定义前馈队列网络：

Wolfram Language code:

γ = {3., 4, 0, 2, 1};μ = {4, 6, 8.2, 9, 11};
r = {{0, 0, 1, 0, 0}, {0, 0, 1, 0, 0}, {0, 0, 0, 0.3, 0.7}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}};
c = {1, 1, 1, 1, 1};

网络的路线概率矩阵不包含返回路线：

Wolfram Language code: r//MatrixForm

Wolfram Language code: 𝒩 = QueueingNetworkProcess[γ, r, μ, c];

计算网络稳定状态的概率：

Wolfram Language code: Probability[x1 == 1 && x2 == 1 && x3 == 0 && x4 == 0 && x5 == 2, {x1, x2, x3, x4, x5}𝒩[∞]]

使用泊松聚合和分解验证结果：

Wolfram Language code:

Probability[x1 == 1 && x2 == 1 && x3 == 0 && x4 == 0 && x5 == 2, {x1, x2, x3, x4, x5}ProductDistribution[QueueingProcess[3, 4][∞], QueueingProcess[4, 6][∞], QueueingProcess[3 + 4, 8.2][∞], QueueingProcess[7 * 0.3 + 2, 9][∞], QueueingProcess[7 * 0.7 + 1, 11][∞]]]

网络中第四个和第五个节点的性能测量值：

Wolfram Language code: Table[QueueProperties[{𝒩, i}], {i, {4, 5}}]

简单反馈网络 (3)

定义一个网络过程，它对应于反馈概率为 p 的队列:

Wolfram Language code: 𝒩 = QueueingNetworkProcess[{γ}, {{p}}, {μ}, {1}];

网络的稳定状态的 PDF：

Wolfram Language code: 𝒟 = StationaryDistribution[𝒩];

Wolfram Language code: PDF[𝒟, {n}]

Wolfram Language code: Sum[%, {n, 0, ∞}]

性能测量值：

Wolfram Language code: QueueProperties[{𝒩, 1}]//Simplify

具有两个彼此反馈的节点的网络：

Wolfram Language code:

γ = {4, 7};μ = {9, 14};
r = {{0, 1 / 3}, {1 / 8, 0}};
c = {1, 1};

Wolfram Language code: 𝒩 = QueueingNetworkProcess[γ, r, μ, c];

网络的路线概率矩阵：

Wolfram Language code: r//MatrixForm

平均系统规模：

Wolfram Language code: Total[Table[QueueProperties[{𝒩, i}, "MeanSystemSize"], {i, 2}]]//N

系统中所花的平均时间：

Wolfram Language code: % / Total[γ]//N

定义一个具有三个节点的周期队列：

Wolfram Language code:

γ = {0, 0, 0};μ = {2.5, 1.1, 4.5};
r = {{0, 1, 0}, {0, 0, 1}, {1, 0, 0}};
c = {1, 2, 1};k = 9;

Wolfram Language code: 𝒩 = QueueingNetworkProcess[γ, r, μ, c, k];

网络的路线概率矩阵：

Wolfram Language code: r//MatrixForm

模拟网络：

Wolfram Language code: data = RandomFunction[𝒩, {0, 40}]["Path"];

Wolfram Language code:

Table[ListLinePlot[Table[{data[[i, 1]], data[[i, 2, j]]}, {i, Length[data]}], Filling -> Axis, FillingStyle -> LightRed, ImageSize -> 135], {j, 3}]

Jackson 网络 (2)

定义一个开放式队列网络：

Wolfram Language code:

γ = {3, 6};μ = {7, 17};
r = {{1 / 6., 1 / 9}, {1 / 4, 1 / 8}};
c = {1, 1};

Wolfram Language code: 𝒩 = QueueingNetworkProcess[γ, r, μ, c];

模拟网络：

Wolfram Language code: data = RandomFunction[𝒩, {0, 100}]["Path"];

绘制网络中节点处的模拟数值：

Wolfram Language code:

Table[ListLinePlot[Table[{data[[i, 1]], data[[i, 2, j]]}, {i, Length[data]}], Filling -> Axis, FillingStyle -> LightRed], {j, 2}]

网络中节点处的性能测量值：

Wolfram Language code: Table[QueueProperties[{𝒩, i}], {i, 2}]

开放式网络的平稳分布：

Wolfram Language code:

γ = {1, 5};μ = {3, 8};
r = {{1 / 4, 1 / 9}, {1 / 8, 0}};
c = {1, 1};

Wolfram Language code: 𝒩 = QueueingNetworkProcess[γ, r, μ, c];

Wolfram Language code: 𝒟 = StationaryDistribution[𝒩];

概率密度函数：

Wolfram Language code: PDF[𝒟, {m, n}]

Wolfram Language code: Sum[%, {m, 0, ∞}, {n, 0, ∞}]

Wolfram Language code: DiscretePlot3D[PDF[𝒟, {m, n}]//Evaluate, {m, 0, 4}, {n, 0, 4}, ExtentSize -> 0.5, PlotRange -> All]

累积分布函数：

Wolfram Language code: CDF[𝒟, {m, n}]

Wolfram Language code: DiscretePlot3D[CDF[𝒟, {m, n}]//Evaluate, {m, 0, 35}, {n, 0, 35}, ExtentSize -> Right, PlotRange -> {0, 1.05}]

均值和方差：

Wolfram Language code: Mean[𝒟]

Wolfram Language code: Table[QueueProperties[{𝒩, i}, "MeanSystemSize"], {i, 2}]

Wolfram Language code: Variance[𝒟]

Wolfram Language code: Table[Variance[MarginalDistribution[𝒟, i]], {i, 2}]

概率和期望：

Wolfram Language code: NProbability[m + n < 7, {m, n}𝒟]

Wolfram Language code: Expectation[m ^ 3 + n ^ 2, {m, n}𝒟]

Gordon–Newell 网络 (3)

定义一个闭合的排队网络：

Wolfram Language code:

γ = {0, 0, 0};μ = {1.3, 4, 5};
r = {{0, 0.2, 0.8}, {0, 0, 1}, {0.3, 0.7, 0}};
c = {1, 2, 1};k = 10;

Wolfram Language code: 𝒩 = QueueingNetworkProcess[γ, r, μ, c, k];

从网络外没有到达：

Wolfram Language code: γ

网络中第二个节点的属性：

Wolfram Language code: QueueProperties[{𝒩, 2}]

模拟网络：

Wolfram Language code: data = RandomFunction[𝒩, {0, 100}]["Path"];

绘制网络中前两个节点的模拟数值：

Wolfram Language code:

Table[ListLinePlot[Table[{data[[i, 1]], data[[i, 2, j]]}, {i, Length[data]}], Filling -> Axis, FillingStyle -> LightRed], {j, 2}]

具有七个节点的闭合网络：

Wolfram Language code:

γ = {0, 0, 0, 0, 0, 0, 0};μ = {85, 85, 120, 120, 70, 20, 20};
r = {{1 / 3, 1 / 4, 0, 1 / 4, 0, 1 / 6, 0}, 
	{1 / 3, 1 / 4, 0, 1 / 4, 1 / 6, 0, 0}, 
	{0, 0, 1 / 3, 1 / 3, 1 / 3, 0, 0}, 
	{1 / 3, 0, 1 / 3, 0, 1 / 3, 0, 0}, 
	{0, 0, 0, 5 / 6, 0, 0, 1 / 6}, 
	{1 / 6, 1 / 6, 1 / 6, 1 / 6, 1 / 6, 1 / 6, 0}, 
	{0, 1 / 6, 1 / 6, 1 / 6, 1 / 6, 1 / 6, 1 / 6}};
c = {1, 1, 1, 1, 1, 1, 1};k = 35;

Wolfram Language code: 𝒩 = QueueingNetworkProcess[γ, r, μ, c, k];

网络中每个节点处的稳态性能测量值：

Wolfram Language code: Table[QueueProperties[{𝒩, i}, "MeanSystemSize"], {i, 7}]//N

Wolfram Language code: Table[QueueProperties[{𝒩, i}, "MeanSystemTime"], {i, 7}]//N

Wolfram Language code: Table[QueueProperties[{𝒩, i}, "MeanQueueSize"], {i, 7}]//N

Wolfram Language code: Table[QueueProperties[{𝒩, i}, "MeanQueueTime"], {i, 7}]//N

闭合网络的平稳分布：

Wolfram Language code:

γ = {0, 0, 0};μ = {3, 4, 8};
r = {{0, 1, 0}, {0, 0, 1}, {1, 0, 0}};
c = {1, 1, 1};k = 2;

Wolfram Language code: 𝒩 = QueueingNetworkProcess[γ, r, μ, c, k];

Wolfram Language code: 𝒟 = StationaryDistribution[𝒩];

概率密度函数：

Wolfram Language code: PDF[𝒟, {m, n, p}]

Wolfram Language code: Sum[%, {m, 0, ∞}, {n, 0, ∞}, {p, 0, ∞}]

均值和方差：

Wolfram Language code: Mean[𝒟]

Wolfram Language code: Table[QueueProperties[{𝒩, i}, "MeanSystemSize"], {i, 3}]

Wolfram Language code: Variance[𝒟]

概率和期望：

Wolfram Language code: Probability[m + n > p, {m, n, p}𝒟]

Wolfram Language code: Expectation[m + n + p, {m, n, p}𝒟]

Wolfram Language code: Expectation[m ^ 3 + n ^ 2 + p, {m, n, p}𝒟]

应用 (12)

机器维修 (3)

电子产品制造商使用五个机器人制造电路板. 机器人出故障的时间服从均值为30个小时的指数分布. 该公司有两名修理工可以维修机器人，修理时间服从均值为3小时的指数分布. 求在给定时间，通过使用具有两个状态（“可运作”和“坏掉”）的队列网络，可运作的机器人的平均数目：

Wolfram Language code:

γ = {0, 0};μ = {1 / 30, 1 / 3};
r = {{0, 1}, {1, 0}};
c = {5, 2};k = 5;

Wolfram Language code: maintenanceNetwork = QueueingNetworkProcess[γ, r, μ, c, k];

可运作机器人的平均数目：

Wolfram Language code: QueueProperties[{maintenanceNetwork, 1}, "MeanSystemSize"]//N

工厂中的两个机器需要在任何时候都可以运作. 机器根据平均失效率的指数分布出故障. 在出故障时，机器有的概率被单个维修人员局部修好，该人员的工作服从参数为的指数分布. 在概率下，机器必须被一个专家修好，该专家的工作服从参数为的指数分布. 也存在的概率，机器在完成局部维修后还需要专家维修. 通过使用状态为 "working"（可运作）、"locallyRepairable"（局部可维修）和 "specialistRepairable"（专家可维修）的排队网络，求两个机器都运作的时间的百分比：

Wolfram Language code:

γ = {0, 0, 0};μ = {1, 1, 3};
r = {{0, 3 / 4, 1 / 4}, {2 / 3, 0, 1 / 3}, {1, 0, 0}};
c = {2, 1, 1};k = 2;

Wolfram Language code: repairNetwork = QueueingNetworkProcess[γ, r, μ, c, k];

大约 23% 的时间两个机器都可以运作：

Wolfram Language code: PDF[repairNetwork[∞], {2, 0, 0}]//N

大量机器共享的修理厂有两个连续的修理站，修理速率分别为每小时1个和每小时两个. 机器的累积故障率是每小时0.5. 求修理厂的两个修理站都是闲置状态的概率：

Wolfram Language code:

γ = {0.5, 0};μ = {1, 2};
r = {{0, 1}, {0, 0}};
c = {1, 1};

Wolfram Language code: serviceNetwork = QueueingNetworkProcess[γ, r, μ, c];

两个服务站都空闲的概率：

Wolfram Language code: PDF[serviceNetwork[∞], {0, 0}]

机器经历两个修理阶段的平均修理时间：

Wolfram Language code: QueueProperties[{serviceNetwork, 1}, "MeanSystemTime"] + QueueProperties[{serviceNetwork, 2}, "MeanSystemTime"]

计算机系统 (4)

在三个路由器组成的串联网络中，数据包以每秒100个数据包的速率到达. 三个路由器的服务速率分别是每秒250个数据包、150个以及200个. 求在串联网络下，三个路由器每个都有两个数据包到达的概率：

Wolfram Language code:

γ = {100, 0, 0};μ = {250, 150, 200};
r = {{0, 1, 0}, {0, 0, 1}, {0, 0, 0}};
c = {1, 1, 1};

Wolfram Language code: routerProcess = QueueingNetworkProcess[γ, r, μ, c];

在三个路由器中每一个都有两个数据包的概率：

Wolfram Language code: 𝒟 = StationaryDistribution[routerProcess];

Wolfram Language code: PDF[𝒟, {2, 2, 2}]

Wolfram Language code: N[%]

使用 Probability 获取相同结果:

Wolfram Language code: Probability[x == 2 && y == 2 && z == 2, {x, y, z}𝒟]//N

求网络中有三个数据包的概率：

Wolfram Language code: Probability[x + y + z == 3, {x, y, z}𝒟]//N

在三个节点的中央服务器系统中，有10个请求在循环. 中央服务器（节点1）以概率 0.3 和 0.7 发送请求给剩下的两个节点. 这三个节点的指数服务时间分别为 1、2 和 0.8. 求在这个由服务器组成的闭合式网络中的瓶颈装置：

Wolfram Language code:

γ = {0, 0, 0};μ = {1, 1 / 2, 1 / 0.8};
r = {{0, 0.3, 0.7}, {1, 0, 0}, {1, 0, 0}};
c = {1, 1, 1};k = 10;

Wolfram Language code: serverNetwork = QueueingNetworkProcess[γ, r, μ, c, k];

第一个节点是瓶颈装置：

Wolfram Language code: Table[QueueProperties[{serverNetwork, i}, "MeanSystemTime"], {i, 3}]

Wolfram Language code: Table[QueueProperties[{serverNetwork, i}, "MeanSystemSize"], {i, 3}]

在三个节点的中央服务器系统中，有10个请求在循环. 中央服务器（节点1）以概率 0.3 和 0.5 发送请求给剩下的两个节点. 额外的请求只到达中央服务器，并且服从速率为 0.15 的泊松过程，而这三个节点的指数服务时间分别为 1、2 和 0.8. 求在这个由服务器组成的开放式网络中的瓶颈装置：

Wolfram Language code:

γ = {0.15, 0, 0};μ = {1, 1 / 2, 1 / 0.8};
r = {{0, 0.3, 0.5}, {1, 0, 0}, {1, 0, 0}};
c = {1, 1, 1};

Wolfram Language code: serverNetwork = QueueingNetworkProcess[γ, r, μ, c];

第一个节点（中央服务器）是瓶颈装置：

Wolfram Language code: Table[QueueProperties[{serverNetwork, i}, "MeanSystemTime"], {i, 3}]

Wolfram Language code: Table[QueueProperties[{serverNetwork, i}, "MeanSystemSize"], {i, 3}]

新程序以速率 γ 的泊松过程到达 CPU. 程序在 CPU 中花的执行时间服从均值为 1/μ 1 的指数分布. 在该阶段，程序执行或者以概率 p 完成，或者以概率 1-p 需要从二级存储获取额外的信息. 从二级存储获取信息要求的时间服从均值为 1/μ 2 的指数分布. 求每个程序在系统中所花的平均时间：

Wolfram Language code: cpuProcess = QueueingNetworkProcess[{γ, 0}, {{0, 1 - p}, {1, 0}}, {μ1, μ2}, {1, 1}];

使用 Little 定理，这是程序所使用的平均时间：

Wolfram Language code:

(QueueProperties[{cpuProcess, 1}, "MeanSystemSize"] + QueueProperties[{cpuProcess, 2}, "MeanSystemSize"]) / γ//FullSimplify

客户服务 (1)

客户以每小时40个的平均速率的泊松过程到达超市. 他们在收银台付款前平均花小时来装满购物车. 付款时间服从平均4分钟的指数分布. 求在任何给定时间商店内客户的平均数目：

Wolfram Language code:

γ = {40, 0};μ = {4 / 3, 60 / 4};
r = {{0, 1}, {0, 0}};
c = {∞, 4};

Wolfram Language code: shoppingProcess = QueueingNetworkProcess[γ, r, μ, c];

商店中客户的平均数目：

Wolfram Language code: QueueProperties[{shoppingProcess, 1}, "MeanSystemSize"] + QueueProperties[{shoppingProcess, 2}, "MeanSystemSize"]//N

通讯网络 (2)

一个发射器有发送消息的两种许可证. 只要发射器有一个许可证，它就以指数速率 λ 生成消息. 消息到达发送系统，并且以指数速率 μ 发送. 只要消息到达发送系统的另一端，对应的许可证以指数速率 μ 发送回发射器. 求网络的稳定状态概率质量函数：

Wolfram Language code:

γ = {0, 0, 0};s = {λ, μ, μ};
r = {{0, 1, 0}, {0, 0, 1}, {1, 0, 0}};
c = {1, 1, 1};k = 2;

Wolfram Language code: transmissionProcess = QueueingNetworkProcess[γ, r, s, c, k];

网络的稳定状态分布：

Wolfram Language code: 𝒟 = StationaryDistribution[transmissionProcess];

网络的稳定状态 pmf：

Wolfram Language code: PDF[𝒟, {m, n, p}]

发射器上没有消息的概率：

Wolfram Language code: Probability[m == 0, {m, n, p}𝒟]

下面显示在保险公司的电话系统. 电话以 800 号码呼进（黑色）并且然后被转给索赔（红色）或者保单服务（蓝色）：

Wolfram Language code:

Graph[{1 -> 2, 1 -> 3, Table[2 -> i, {i, 4, 6}], Table[3 -> j, {j, 7, 13}], 2 -> 3, 3 -> 2}//Flatten, VertexStyle -> Evaluate[{1 -> Black, 2 -> Red, 3 -> Blue, Table[j -> Green, {j, 4, 6}], Table[j -> Orange, {j, 7, 13}]}//Flatten], VertexSize  -> Large, PlotTheme -> "DiagramBlock", ImageSize -> 300]

从外部到三个节点的到达速率：

Wolfram Language code: γ = {35, 0, 0};

在三个节点上的服务速率：

Wolfram Language code: μ = {120, 10, 3};

网络的路线概率矩阵：

Wolfram Language code: MatrixForm[r = {{0, 0.55, 0.45}, {0, 0, 0.02}, {0, 0.01, 0}}]

图表显示服务通道向量如下所示：

Wolfram Language code: c = {1, 3, 7};

因此，这个开放式网络如下：

Wolfram Language code: 𝒩 = QueueingNetworkProcess[γ, r, μ, c];

与三个节点处的平均队列长度比较：

Wolfram Language code: Table[QueueProperties[{𝒩, i}, "MeanQueueSize"], {i, 3}]

在系统中每个客户所花的总平均时间大约是17分钟：

Wolfram Language code: (Underoverscript[∑, i, 3]QueueProperties[{𝒩, i}, "MeanSystemSize"]) / 35

Wolfram Language code: % 60

机场候机楼 (1)

乘客到达机场，并且走到航站楼的四个值机柜台之一. 接下来，他们进行安检，最后他们从航站楼的三个登机口之一登机：

Wolfram Language code:

Graph[{1 -> 5, 2 -> 5, 3 -> 5, 4 -> 5, 5 -> 6, 5 -> 7, 5 -> 8}, VertexStyle -> {1 -> Blue, 2 -> Blue, 3 -> Blue, 4 -> Blue, 5 -> Orange, 6 -> Red, 7 -> Red, 8 -> Red}, VertexSize  -> 0.1, ImageSize -> 300]

航站楼网络由下面描述：

Wolfram Language code:

proc = QueueingNetworkProcess[{300., 400, 200, 250, 0, 0, 0, 0}, {{0, 0, 0, 0, 1, 0, 0, 0}, {0, 0, 0, 0, 1, 0, 0, 0}, {0, 0, 0, 0, 1, 0, 0, 0}, {0, 0, 0, 0, 1, 0, 0, 0}, {0, 0, 0, 0, 0, 3. / 10, 5. / 10, 2 / 10}, {0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0}}, {400, 500, 700, 300, 1200, 350, 450, 400}, {1, 1, 1, 1, 1, 1, 1, 1}];

研究安检和三号登机口的客流量：

Wolfram Language code: {QueueProperties[{proc, 5}], QueueProperties[{proc, 8}]}

物流网络 (1)

某制造业物流由一个工厂、三个仓库和六个店铺组成：

Wolfram Language code:

Graph[{12, 13, 14, 25, 26, 37, 38, 49, 410}, 
	VertexShape -> {1 -> [image], 2 -> [image], 3 -> [image], 4 -> [image], 5 -> [image], 6 -> [image], 7 -> [image], 8 -> [image], 9 -> [image], 10 -> [image]}, VertexSize -> 0.8]

网络的到达、服务和路径信息是：

Wolfram Language code: γ = {13., 0, 0, 0, 0, 0, 0, 0, 0, 0};

Wolfram Language code: μ = {14, 10, 11.2, 5, 14, 12.8, 13.4, 17.2, 15.9, 18.1};

Wolfram Language code: c = Table[1, {10}];

Wolfram Language code:

r = (|   |     |     |     |     |     |     |     |     |     |
| - | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 0.5 | 0.2 | 0.3 | 0   | 0   | 0   | 0   | 0   | 0   |
| 0 | 0   | 0   | 0   | 0.8 | 0.2 | 0   | 0   | 0   | 0   |
| 0 | 0   | 0   | 0   | 0   | 0   | 0.4 | 0.6 | 0   | 0   |
| 0 | 0   | 0   | 0   | 0   | 0   | 0   | 0   | 0.3 | 0.7 |
| 0 | 0   | 0   | 0   | 0   | 0   | 0   | 0   | 0   | 0   |
| 0 | 0   | 0   | 0   | 0   | 0   | 0   | 0   | 0   | 0   |
| 0 | 0   | 0   | 0   | 0   | 0   | 0   | 0   | 0   | 0   |
| 0 | 0   | 0   | 0   | 0   | 0   | 0   | 0   | 0   | 0   |
| 0 | 0   | 0   | 0   | 0   | 0   | 0   | 0   | 0   | 0   |
| 0 | 0   | 0   | 0   | 0   | 0   | 0   | 0   | 0   | 0   |);

Wolfram Language code: 𝒩 = QueueingNetworkProcess[γ, r, μ, c];

比较第一个和第二个仓库的客流量值：

Wolfram Language code: Row[Table[QueueProperties[{𝒩, i}], {i, {2, 3}}]]

属性和关系 (3)

具有单个节点的排队网络过程等价于排队过程：

Wolfram Language code: 𝒩 = QueueingNetworkProcess[{γ}, {{p}}, {μ}, {1}];

求等价排队过程的到达率：

Wolfram Language code: λ = (λ1 /. Solve[λ1 == γ + λ1 p, λ1][[1]])

Wolfram Language code: 𝒬 = QueueingProcess[λ, μ];

这些具有相同的平稳分布：

Wolfram Language code: PDF[StationaryDistribution[𝒩], {k}]

Wolfram Language code: PDF[StationaryDistribution[𝒬], k]

定义具有两个串联队列的网络：

Wolfram Language code:

γ = {α, 0};μ = {a, b};
r = {{0, 1}, {0, 0}};
c = {1, 1};

Wolfram Language code: 𝒩 = QueueingNetworkProcess[γ, r, μ, c];

网络的稳定状态的 PDF：

Wolfram Language code: 𝒟 = StationaryDistribution[𝒩];

Wolfram Language code: pdf1 = PDF[𝒟, {x, y}]

使用单个排队过程的乘积，获取相同结果：

Wolfram Language code: 𝒬1 = QueueingProcess[α, a];

Wolfram Language code: 𝒬2 = QueueingProcess[α, b];

Wolfram Language code: pdf2 = PDF[ProductDistribution[StationaryDistribution[𝒬1], StationaryDistribution[𝒬2]], {x, y}]

Wolfram Language code: pdf1 == pdf2

零外部到达向量 γ 对应于闭合排队网络：

Wolfram Language code:

γ = {0, 0};μ = {5, 1.7};
r = {{0.1, 0.9}, {0.8, 0.2}};
c = {1, 1};k = 7;

Wolfram Language code: 𝒩 = QueueingNetworkProcess[γ, r, μ, c, k];

系统中总恰好有七个任务：

Wolfram Language code: data = RandomFunction[𝒩, {0, 5}]["Path"][[All, 2]]

Wolfram Language code: Total[data, {-1}]

巧妙范例 (1)

定义一个闭合的排队网络：

Wolfram Language code:

γ = {0, 0, 0, 0};r = {{0, 0.5, 0.3, 0.2}, {1, 0, 0, 0}, {1, 0, 0, 0}, {1, 0, 0, 0}};μ = {1, 0.5, 1, 2};c = {1, 1, 1, 1};k = 7;

Wolfram Language code: 𝒩 = QueueingNetworkProcess[γ, r, μ, c, k];

对网络生成随机数据：

Wolfram Language code: data = RandomFunction[𝒩, {0, 10 ^ 4}];

比较实际属性值和从模拟得到的数值：

Wolfram Language code: {QueueProperties[{𝒩, 2}], QueueProperties[{data, 2}]}

Top

更多学习资源

技术支持

数据科学、金融与商业

工程

科学与技术

教育科技

教育举措

开始

提高你的技能

与我们合作

成人教育计划

青少年教育计划

欢迎阅读

QueueingNetworkProcess

更多信息

范例

基本范例 (2)

范围 (10)

简单前馈网络 (2)

简单反馈网络 (3)

Jackson 网络 (2)

Gordon–Newell 网络 (3)

应用 (12)

机器维修 (3)

计算机系统 (4)

客户服务 (1)

通讯网络 (2)

机场候机楼 (1)

物流网络 (1)

属性和关系 (3)

巧妙范例 (1)

文本

CMS

APA

BibTeX

BibLaTeX

QueueingNetworkProcess

更多信息

范例

基本范例 (2)

范围 (10)

简单前馈网络 (2)

简单反馈网络 (3)

Jackson 网络 (2)

Gordon–Newell 网络 (3)

应用 (12)

机器维修 (3)

计算机系统 (4)

客户服务 (1)

通讯网络 (2)

机场候机楼 (1)

物流网络 (1)

属性和关系 (3)

巧妙范例 (1)

参见

相关指南

历史

文本

CMS

APA

BibTeX

BibLaTeX