({{, (RefLink[QueueingProcess, paclet:ref/QueueingProcess])[λ,μ] 
represents an M/M/1 queue with arrival rate λ and service rate μ.}, {, (RefLink[QueueingProcess, paclet:ref/QueueingProcess])[λ,sdist]
represents an M/G/1 queue with arrival rate λ and service distribution sdist.}, {, (RefLink[QueueingProcess, paclet:ref/QueueingProcess])[adist,μ]
represents a G/M/1 queue with arrival distribution adist and service rate μ.}, {, (RefLink[QueueingProcess, paclet:ref/QueueingProcess])[adist,sdist]
represents a G/G/1 queue with arrival distribution adist and service distribution sdist.}, {, (RefLink[QueueingProcess, paclet:ref/QueueingProcess])[…,…,c]
represents a queueing process with c service channels.}, {, (RefLink[QueueingProcess, paclet:ref/QueueingProcess])[…,…,c,k]
represents a queueing process with system capacity k.}, {, (RefLink[QueueingProcess, paclet:ref/QueueingProcess])[…,…,c,k,(Subscript[x, 0])]
represents a queueing process with initial state (Subscript[x, 0]).}})

OpenersNotesSection(Spacer1)Details

(RefLink[QueueingProcess, paclet:ref/QueueingProcess]) is a continuous-time and discrete-state process.

(RefLink[QueueingProcess, paclet:ref/QueueingProcess]) at time t is the number of customers in the system at time t.

The times between arrivals are independent and follow the distribution adist, with λ indicating (RefLink[ExponentialDistribution, paclet:ref/ExponentialDistribution])[λ].

The times taken to serve customers are independent and follow the distribution sdist, with μ indicating (RefLink[ExponentialDistribution, paclet:ref/ExponentialDistribution])[μ].

(RefLink[QueueingProcess, paclet:ref/QueueingProcess]) allows c and k to be any positive integers. (Subscript[x, 0]) can be any non-negative integer and the distributions adist and sdist can be any continuous distributions with positive domain.

(RefLink[QueueingProcess, paclet:ref/QueueingProcess]) can be used with such functions as (RefLink[QueueProperties, paclet:ref/QueueProperties]), (RefLink[StationaryDistribution, paclet:ref/StationaryDistribution]), and (RefLink[RandomFunction, paclet:ref/RandomFunction]).

OpenersPrimaryExamplesSection(Spacer1)Examples  (62)

OpenersExampleSection0(Spacer1)Basic Examples  (2)

Simulate an M/M/1 queue where the state is the number of jobs in the system:

data=RandomFunction[QueueingProcess[3,5],{0,15}]

ListStepPlot[data,Filling->Axis]

Define an M/M/1 queue with arrival rate λ and service rate μ:

𝒬=QueueingProcess[λ,μ];

Queue properties:

QueueProperties[𝒬]

OpenersExampleSection1(Spacer1)Scope  (30)

Estimate process parameters:

𝒬=QueueingProcess[2,GammaDistribution[4,0.1]];

data=RandomFunction[𝒬,{0,10^4}];

FindProcessParameters[data,QueueingProcess[λ,GammaDistribution[α,β]]]

Steady-state distribution for a queue:

𝒟=StationaryDistribution[QueueingProcess[λ,ν]];

Find the probability that in the steady state the system size is greater than 2 and less than 7:

Probability[2<x<7,x\[Distributed]𝒟]

OpenersExampleSubsection0(Spacer1)M/M Queues  (14)

Define an M/M/1 queue:

𝒬=QueueingProcess[3,5.7];

Simulate the queue:

data=RandomFunction[𝒬,{0,50}];

ListLinePlot[data]

Queue properties:

QueueProperties[𝒬]

Mean queue system size for an M/M/1 queue:

𝒬=QueueingProcess[4,6];

QueueProperties[𝒬,"MeanSystemSize"]

Parameter estimation for an M/M/1 queue:

data=RandomFunction[QueueingProcess[4,7],{0,150}];

Obtain the estimated process:

EstimatedProcess[data,QueueingProcess[λ,μ]]

Find estimates for the process parameters:

FindProcessParameters[data,QueueingProcess[λ,μ]]

Parameter estimation with higher precision:

data=RandomFunction[QueueingProcess[5,11],{0,150},WorkingPrecision-> 20];

EstimatedProcess[data,QueueingProcess[λ,μ],WorkingPrecision->20]

FindProcessParameters[data,QueueingProcess[λ,μ],WorkingPrecision->20]

Estimate the arrival distribution:

data=RandomFunction[QueueingProcess[6,13],{0,150}];

FindProcessParameters[data,QueueingProcess[λ,13]]

Estimate the service distribution:

data=RandomFunction[QueueingProcess[6,13],{0,150}];

FindProcessParameters[data,QueueingProcess[6,μ]]

Simulate an M/M/1 queue with different arrival and service rates:

f[λ_,μ_]:=RandomFunction[QueueingProcess[λ,μ],{0,30}]["Path"]

Map[ListLinePlot[#,Filling-> Axis,FillingStyle-> LightOrange]&,{f[3,10],f[3,3],f[3,1]}]

Simulate an M/M/1 queue with a finite capacity:

data=RandomFunction[QueueingProcess[4,4.3,1,12],{0,400}]["Path"];

ListLinePlot[data,Filling->Axis,FillingStyle-> LightOrange]

Specify a nonzero initial state:

data=RandomFunction[QueueingProcess[2,3,1,∞,20],{0,50}];

ListPlot[data,Filling->Axis,FillingStyle-> LightOrange,PlotRange-> All]

Generate a sample path with default machine precision:

RandomFunction[QueueingProcess[3,7],{0,2}]["Path"]

A path with higher precision arrival and service event times:

RandomFunction[QueueingProcess[3,7],{0,4},WorkingPrecision-> 20]["Path"]

Slice distribution of an M/M/1 queue with inexact parameters:

𝒬=QueueingProcess[4.3,5];

PDF[𝒬[4],3]

DiscretePlot[PDF[𝒬[4],x],{x,0,10}]

Define an M/M/2 queue:

𝒬=QueueingProcess[λ,μ,2];

Compute measures of system performance in the steady state:

QueueProperties[𝒬]//FullSimplify

Define an M/M/2/5 queue:

𝒬=QueueingProcess[3,4,2,5];

QueueProperties[𝒬,"QueueDiagram"]

Mean system size for the queue in the steady state:

QueueProperties[𝒬,"MeanSystemSize"]

This is the same as the mean of the stationary distribution for the queue:

𝒟=StationaryDistribution[𝒬];

Mean[𝒟]

Steady-state PDF:

PDF[𝒟,x]

Probability that the system is not empty in the steady state:

NProbability[n>0,n \[Distributed]𝒟]

M/M/c queue with three servers:

𝒬=QueueingProcess[14,5.,3];

QueueProperties[𝒬,"QueueDiagram"]

Mean queue waiting time in the steady state:

QueueProperties[𝒬,"MeanQueueTime"]

Steady-state mean and variance:

𝒟=StationaryDistribution[𝒬];

{Mean[𝒟],Variance[𝒟]}

Probability density function for the slice distribution of an M/M/∞ queue:

𝒬=QueueingProcess[λ,μ,∞];

PDF[𝒬[t],x]

Sum[%,{x,0,∞}]

Mean of the distribution:

Mean[𝒬[t]]

Limit[%, t-> Infinity, Assumptions->λ>0&&μ>0]

QueueProperties[𝒬,"MeanSystemSize"]

There is zero waiting time in this queue:

QueueProperties[𝒬,"MeanQueueTime"]

QueueProperties[𝒬,"MeanQueueSize"]

OpenersExampleSubsection1(Spacer1)M/G Queues  (6)

Define an M/G/1 queue with Erlangian service distribution:

𝒬=QueueingProcess[λ,ErlangDistribution[k,k μ]];

Simulate the queue for numerical values of the distribution parameters:

data=RandomFunction[( 𝒬/.{λ->4,k-> 5,μ-> 17}),{0,10}]["Path"];

ListLinePlot[data]

Queue properties:

QueueProperties[𝒬]

Mean queue length for an M/G/1 queue:

𝒬=QueueingProcess[λ,ErlangDistribution[k,k s]];

QueueProperties[𝒬,"MeanQueueSize"]

Parameter estimation for an M/G/1 queue:

data=RandomFunction[QueueingProcess[1,GammaDistribution[1/2,1/3]],{0,10^3}];

Obtain the estimated process:

EstimatedProcess[data,QueueingProcess[λ,GammaDistribution[a,b]]]

Find estimates for the process parameters:

FindProcessParameters[data,QueueingProcess[λ,GammaDistribution[a,b]]]

Properties of an M/D/1 queue:

𝒟1=ProbabilityDistribution[DiracDelta[x-1/μ],{x,-∞,∞}, Assumptions-> μ>0];

QueueProperties[QueueingProcess[λ,𝒟1]]

M/G/1 queue with zero-inflated exponential service:

𝒟1=MixtureDistribution[{p,1-p},{ProbabilityDistribution[DiracDelta[x],{x,-∞,∞}],ExponentialDistribution[p]}];

𝒬=QueueingProcess[λ,𝒟1];

Mean and variance of service times:

{Mean[𝒟1],Variance[𝒟1]}

Mean waiting time for the queue:

mqt=QueueProperties[𝒬,"MeanQueueTime"]//Simplify

Express the mean waiting time in terms of the utilization factor:

ρ=QueueProperties[𝒬,"UtilizationFactor"]//Together

mqt==ρ/(p(1-ρ))//Simplify

M/G/1 queue with a spliced service distribution:

𝒟=SplicedDistribution[{1,1},{0,6/7,∞},{UniformDistribution[{0,6/7}],TruncatedDistribution[{4/5,3},ParetoDistribution[4/5,1.05]]}];

Plot[Evaluate@PDF[𝒟,x],{x,0,4},Filling-> Axis,Exclusions-> None,PlotRange-> All]

Steady-state performance measures:

QueueProperties[QueueingProcess[.2,𝒟]]

OpenersExampleSubsection2(Spacer1)G/M Queues  (3)

Define a G/M/1 queue with Erlangian arrival distribution:

𝒬=QueueingProcess[ErlangDistribution[2,6],10];

Simulate the queue:

data=RandomFunction[𝒬,{0,10}]["Path"];

ListLinePlot[data]

Queue properties:

QueueProperties[𝒬]

Mean system time for a G/M/1 queue:

𝒬=QueueingProcess[ErlangDistribution[2,14],8.];

QueueProperties[𝒬,"MeanSystemTime"]

Parameter estimation for a G/M/1 queue:

data=RandomFunction[QueueingProcess[GammaDistribution[1/2,1/3],7],{0,10^3}];

Obtain the estimated process:

EstimatedProcess[data,QueueingProcess[GammaDistribution[a,b],λ]]

Find estimates for the process parameters:

FindProcessParameters[data,QueueingProcess[GammaDistribution[a,b],λ]]

OpenersExampleSubsection3(Spacer1)Ph/Ph Queues  (3)

Define a Ph/Ph/1 queue with Erlangian arrival and service distributions:

𝒬=QueueingProcess[ErlangDistribution[2,5.],ErlangDistribution[7,35]];

Simulate the queue:

data=RandomFunction[𝒬,{0,20}]["Path"];

ListLinePlot[data]

Queue properties:

QueueProperties[𝒬]

Mean queue length for a Ph/Ph/1 queue:

𝒬=QueueingProcess[ErlangDistribution[3,0.6],HypoexponentialDistribution[{1,5,3}]];

QueueProperties[𝒬,"MeanQueueSize"]

Parameter estimation for a Ph/Ph/1 queue:

data=RandomFunction[QueueingProcess[HypoexponentialDistribution[{1,2}],ErlangDistribution[5,20.7]],{0,10^3}];

Obtain the estimated process:

EstimatedProcess[data,QueueingProcess[HypoexponentialDistribution[{λ1,2}],ErlangDistribution[5,m]]]

Find estimates for the process parameters:

FindProcessParameters[data,QueueingProcess[HypoexponentialDistribution[{λ1,2}],ErlangDistribution[5,m]]]

OpenersExampleSubsection4(Spacer1)G/G Queues  (2)

Define a G/G/1 queue:

𝒬=QueueingProcess[GammaDistribution[2,5],ParetoDistribution[4,43]];

Simulate the queue:

data=RandomFunction[𝒬,{0,70}]["Path"];

ListLinePlot[data]

QueueProperties[data]

Parameter estimation for a G/G/1 queue:

data=RandomFunction[QueueingProcess[GammaDistribution[2,1/3],ParetoDistribution[3,2]],{0,10^4}];

Obtain the estimated process:

EstimatedProcess[data,QueueingProcess[GammaDistribution[a,b],ParetoDistribution[3,α]]]

Find estimates for the process parameters:

FindProcessParameters[data,QueueingProcess[GammaDistribution[a,b],ParetoDistribution[3,α]]]

OpenersExampleSection3(Spacer1)Applications  (18)

OpenersExampleSubsection5(Spacer1)Customer Service Queues  (6)

The arrival pattern of cars to the M. M. One oil change center follows a Poisson process at the rate of four per hour. If the time taken to perform an oil change is exponentially distributed and requires an average of 12 minutes to carry out, find the probability of finding more than three cars waiting for the single available mechanic to service their car. Find the steady-state distribution for the oil change center:

𝒟=StationaryDistribution[QueueingProcess[4,5]];

The probability that there are more than three cars in the queue:

NProbability[x>3, x\[Distributed]𝒟]

Mean and variance for the number of cars in the system:

{Mean[𝒟],Variance[𝒟]}

Patients arrive at an eye clinic according to a Poisson process with a mean of six per hour. There are three doctors on duty and the testing times for patients are distributed exponentially with a mean of 20 minutes. Find the average number of people waiting, the average amount of time spent by a patient at the clinic, and the percentage of time when at least one doctor is idle:

eyeclinic=QueueingProcess[6.,3,3];

QueueProperties[eyeclinic,"QueueDiagram"]

The average number of people waiting:

QueueProperties[eyeclinic,"MeanQueueSize"]

Average time in minutes spent by a patient at the clinic:

QueueProperties[eyeclinic,"MeanSystemTime"]60

Percentage of time when at least one doctor is idle:

Probability[x<3,x\[Distributed]eyeclinic[∞]]100

Arrivals at the checkout counter of a store are observed to follow a Poisson process with a rate of eight customers per hour. The service times for customers follow an exponential distribution with a mean of four minutes. Simulate the queue for 30 minutes. Also find the mean and the variance for the steady-state queue at the checkout:

checkout=QueueingProcess[8,60/4];

Simulate for 30 minutes:

data=RandomFunction[checkout,{0,30}];

ListLinePlot[data["Path"]]

Steady-state mean and variance:

sproc=StationaryDistribution[checkout];

{Mean[sproc],Variance[sproc]}//N

Cars arrive at the drive-through window of a bank according to a Poisson process with a mean of 16 cars per hour. The service times follow an Erlang distribution with a mean of 5/2 minutes and a standard deviation of 5/4 minutes. Find the average waiting time until a customer reaches the window for service. The service distribution can be found using method of moments:

Solve[{Mean[ErlangDistribution[k,μ]]==5/2,StandardDeviation[ErlangDistribution[k,μ]]==5/4},{k,μ}]

The resulting drive-through process:

bankingProcess=QueueingProcess[16/60,ErlangDistribution[4,(8/5)]];

The average waiting time until the customer reaches the service window:

QueueProperties[bankingProcess,"MeanQueueTime"]//N

Arrivals to the takeout counter of a restaurant appear to follow a Poisson process with a mean of 10 per hour. Assuming that the service distribution is exponential, find the average rate at which a customer should be served so that the total time spent by a customer is less than 7.5 minutes:

restaurantCustomers=QueueingProcess[10,μ];

Find the mean system time:

mt=QueueProperties[restaurantCustomers,"MeanSystemTime"]

Find the service rate μ that ensures the average time spent is less than 7.5 minutes:

NSolve[mt==7.5, μ]

An estimated 65,000 videos are uploaded every 12 hours on a popular online video channel. Each uploaded video is converted from the MPEG to SWF format and is then available for viewing on the channel. Find the minimum conversion rate so that there are no more than 5 videos on average undergoing the conversion in the system:

UploadProcess=QueueingProcess[65000/(12*60),μ];

Minimum conversion rate per minute to ensure at most 5 videos in the system:

μ/.Solve[QueueProperties[UploadProcess,"MeanSystemSize"]==5,μ][[1]]//Ceiling

OpenersExampleSubsection6(Spacer1)Communication System Queues  (3)

A cable modem has a maximum transmission rate of 500,000 characters per second. Given that traffic arrives at the rate of 450,000 characters per second, compute the standard performance measures when the system is modeled as an M/M/1 queue:

cableModem=QueueingProcess[450000,500000];

Steady-state performance measures:

QueueProperties[cableModem]

A router receives packets from a group of users and transmits them over a single transmission line. Suppose that packets arrive according to a Poisson process at a rate of one packet every 4 milliseconds, and suppose that packet transmission times are exponentially distributed with mean 3 milliseconds. Find the mean number of packets in the system and the mean total delay in the system:

router=QueueingProcess[1/4,1/3];

QueueProperties[router,"QueueDiagram"]

The mean number of packets in the router:

QueueProperties[router,"MeanSystemSize"]

The mean total delay:

QueueProperties[router,"MeanSystemTime"]

Find the distribution of the number of packets that may be in the router at any time:

packets=StationaryDistribution[router];

DiscretePlot[PDF[packets,k],{k,0,10},ExtentSize->0.5]

Find the probability that there are more than five packets waiting for transmission in the router:

Probability[k>5,k\[Distributed]packets]

Subscribers connect to a university's online catalog at a rate of four subscribers per minute. Sessions have an average duration of 5 minutes. Find the probability that there are more than 25 users online:

catalog=QueueingProcess[4,1/5,∞];

The probability that there are more than 25 users online:

NProbability[n>25,n\[Distributed]StationaryDistribution[catalog]]

OpenersExampleSubsection7(Spacer1)Queueing Theory  (5)

Find the probability that there are at least k customers in a steady-state M/M/1 queue with Poisson arrival rate λ and service rate μ:

sizeDistribution=StationaryDistribution[QueueingProcess[λ,μ]];

Probability[n≥k,n\[Distributed]sizeDistribution, Assumptions->k∈Integers&&k>0]

Find an expression for the expected size of a non-empty queue, for a steady-state M/M/1 queueing process with arrival rate λ and service rate μ:

sizeDistribution=StationaryDistribution[QueueingProcess[λ,μ]];

Expectation[(n-1)\[Conditioned]n>1,n\[Distributed]sizeDistribution]

Compare the mean queue system size for the performance of two identical servers, each with its own separate queue, to the case when there is only a single queue in which to hold customers for both servers, assuming Poisson arrivals and exponential service times:

twoSingleServerQueues=QueueingProcess[λ,μ];

Column[Table[QueueProperties[twoSingleServerQueues,"QueueDiagram"],{2}]]

oneQueueTwoServers=QueueingProcess[2λ,μ,2];

QueueProperties[oneQueueTwoServers,"QueueDiagram"]

Compare mean system sizes:

ms1=2 QueueProperties[twoSingleServerQueues,"MeanSystemSize"]

ms2=QueueProperties[oneQueueTwoServers,"MeanSystemSize"]//FullSimplify

The ratio of system sizes indicates that a single queue will have a smaller system size:

ms1/ms2//Simplify

Derive the steady-state probabilities for an ample-server Markovian queueing process having arrival rate three and service rate five as the limit of the probabilities for the corresponding process with a finite number of servers:

finiteServers=QueueingProcess[3,5,c];

ampleServers=QueueingProcess[3,5,∞];

(RefLink[PDF, paclet:ref/PDF]) for the queue with finitely many servers:

PDF[StationaryDistribution[finiteServers],n]

Compute the limit as c approaches ∞:

Limit[%,c->∞]

(RefLink[PDF, paclet:ref/PDF]) for the queue with infinitely many servers:

PDF[StationaryDistribution[ampleServers],n]

Verify that this agrees with the limiting value as c approaches ∞:

%-%%//Simplify

Express the mean service time for an M/D/1 queue in terms of the parameters for an M/M/2 queue with the same arrival rate:

MM2Queue=QueueingProcess[λ,μ,2];

MD1Queue=QueueingProcess[λ,ProbabilityDistribution[
     DiracDelta[t-μ1],{t,-∞,∞},Assumptions->μ1 > 0]];

Mean service time for the M/D/1 queue:

μ1/.Solve[FullSimplify[QueueProperties[MM2Queue, "MeanSystemSize"]==
      QueueProperties[MD1Queue, "MeanSystemSize"]], μ1]

OpenersExampleSubsection8(Spacer1)Phase Type Queues  (4)

Trucks arrive at a storage facility according to an Erlang type-2 distribution with mean interarrival time of 30 minutes. The single attendant at the facility unloads them in a mean time of 25 minutes and the unloading times are exponentially distributed. Find the mean time for which trucks must wait in queue at the facility:

k=2;λ=60/30;μ=60/25;

unloadingProcess=QueueingProcess[ErlangDistribution[k,k λ],μ];

Mean queue waiting time for trucks:

QueueProperties[unloadingProcess,"MeanQueueTime"]

N[%]

Probability density function for the steady-state size distribution:

𝒟=StationaryDistribution[unloadingProcess];

pdf=PDF[𝒟,n]

DiscretePlot[pdf,{n,0,10},PlotRange->All,PlotMarkers->Automatic]

Messages arrive at a communication line according to a Poisson process, at an average rate of 1 message every 3 milliseconds. The transmission process can be represented by a two-phase hyperexponential distribution with phase probabilities 0.4 and 0.6. The average service times for the two phases are 4.8 milliseconds and 0.8 milliseconds, respectively. Find the mean number of messages and the mean time spent by a message in this communication system:

communicationSystem=QueueingProcess[1/3,HyperexponentialDistribution[{0.4,0.6},{1/4.8,1/0.8}]];

Mean number of messages in the steady state:

QueueProperties[communicationSystem,"MeanSystemSize"]

Mean time spent by a message in the system:

QueueProperties[communicationSystem,"MeanSystemTime"]

Cars arrive at the Super Car Wash according to a Poisson process with a mean interarrival time of 10 minutes. These cars are successively vacuumed, washed, and hand-dried, and the time to perform each of the three tasks is exponentially distributed with means of 1 minute, 3 minutes, and 1.5 minutes, respectively. Find the time that an arriving customer should expect to wait before vacuuming begins:

carWashProcess=QueueingProcess[1/10,HypoexponentialDistribution[{1/1,1/3,1/1.5}]];

Mean time that a customer must wait before vacuuming begins:

QueueProperties[carWashProcess,"MeanQueueTime"]//N

Compare with the value obtained from simulation:

QueueProperties[RandomFunction[carWashProcess,{0,10^4}],"MeanQueueTime"]//N

Messages arrive at a communication line according to a Poisson process, at an average rate of 1 message every 4 seconds. Five percent of the arriving messages require compression before they can be transmitted. The compression times follow an exponential distribution with a mean of 5 milliseconds while the message transmission times follow an exponential distribution with a mean of 3 milliseconds. Find the mean number of messages and the mean time spent by a message in this communication system:

communicationSystem=QueueingProcess[CoxianDistribution[{0.05},{1/4,1/5}],1/3];

Mean number of messages in the steady state:

QueueProperties[communicationSystem,"MeanSystemSize"]

Mean time spent by a message in the system:

QueueProperties[communicationSystem,"MeanSystemTime"]

OpenersExampleSection4(Spacer1)Properties & Relations  (10)

Giving arrival and service rates only is equivalent to specifying exponential distributions:

𝒬1=QueueingProcess[λ,μ];

𝒬2=QueueingProcess[ExponentialDistribution[λ],ExponentialDistribution[μ]];

Table[QueueProperties[𝒬1,s],{s,{"ArrivalDistribution","ServiceDistribution"}}]

Table[QueueProperties[𝒬2,s],{s,{"ArrivalDistribution","ServiceDistribution"}}]

Mean system size is the mean of the stationary distribution for a queue:

𝒬=QueueingProcess[λ,μ];

QueueProperties[𝒬,"MeanSystemSize"]//Together

Mean[StationaryDistribution[𝒬]]

The stationary (system size) distribution for an M/M/1 queue follows (RefLink[GeometricDistribution, paclet:ref/GeometricDistribution]):

𝒬=QueueingProcess[λ,μ];

PDF[StationaryDistribution[𝒬],n]

PDF[GeometricDistribution[1-(λ/μ)],n]

Steady-state performance measures obey Little's laws:

𝒬=QueueingProcess[λ,μ];

Relation between mean system size and mean system time L==λ W:

QueueProperties[𝒬,"MeanSystemSize"]==λ QueueProperties[𝒬,"MeanSystemTime"]

Relation between mean queue size and mean queue time (Subscript[L, q])==λ (Subscript[W, q]):

QueueProperties[𝒬,"MeanQueueSize"]==λ QueueProperties[𝒬,"MeanQueueTime"]

The stationary distribution for an M/M/c queue exists if the utilization factor is less than 1:

𝒬=QueueingProcess[λ,μ,c];

QueueProperties[𝒬,"UtilizationFactor"]<1

QueueProperties[𝒬,"StationarySystem"]

The loss probability for an M/M/c/c queue is given by (RefLink[ErlangB, paclet:ref/ErlangB]):

Probability[n==c, 
    n\[Distributed]StationaryDistribution[QueueingProcess[λ,μ,c,c]], 
    Assumptions->c∈Integers&&c>0]

ErlangB[c,λ/μ]

FullSimplify[%%-%,c∈Integers&&c>0]

The nonzero waiting probability for an M/M/c queue is given by (RefLink[ErlangC, paclet:ref/ErlangC]):

Probability[n≥c, 
    n\[Distributed]StationaryDistribution[QueueingProcess[λ,μ,c]],Assumptions->c∈Integers&&c>0]

ErlangC[c,λ/μ]

FullSimplify[%%-%,c>0&&0<λ/μ<c]

The mean queue length of an M/M/c queue is related to (RefLink[ErlangC, paclet:ref/ErlangC]):

QueueProperties[QueueingProcess[λ,μ,c],"MeanQueueSize"]==Block[{ρ=λ/μ/c},ρ/(1-ρ) ErlangC[c,λ/μ]]//FullSimplify[#,0<c&&0<λ/μ<c]&

A queueing network process with a single node is equivalent to a queueing process:

𝒩=QueueingNetworkProcess[{γ},{{p}},{μ},{1}];

Find the arrival rate for the equivalent queueing process:

λ=(λ1/.Solve[λ1==γ+λ1 p,λ1][[1]])

𝒬=QueueingProcess[λ,μ];

These have the same stationary distribution:

PDF[StationaryDistribution[𝒩],{k}]

PDF[StationaryDistribution[𝒬],k]

An M/D/1 queue is the limit of the corresponding M/(Subscript[E, k])/1 queue as k approaches ∞:

MD1Queue=QueueingProcess[λ,ProbabilityDistribution[
     DiracDelta[t-1/μ],{t,-∞,∞},Assumptions->μ > 0]];

MEk1Queue=QueueingProcess[λ,ErlangDistribution[k,k μ]];

Plot[Evaluate@Table[PDF[ErlangDistribution[k,3k],x],{k,r={30,100,800}}],{x,.1,.6},Filling->Axis,PlotRange-> All,PlotLegends->(Row[{"k = ", #}]&/@r)]

Hence the steady-state system sizes are the same for these queues in the limit as k->∞:

QueueProperties[MD1Queue, "MeanSystemSize"]//Simplify

Limit[QueueProperties[MEk1Queue,"MeanSystemSize"],k->∞ ]

OpenersExampleSection5(Spacer1)Possible Issues  (1)

Performance measures may be undefined for exact parameters:

𝒬=QueueingProcess[GammaDistribution[1,5],ParetoDistribution[4,43]];

QueueProperties[𝒬]

Use inexact input to obtain performance measures based on the estimates from simulation:

𝒬1=QueueingProcess[GammaDistribution[2,5.],ParetoDistribution[4,43.]];

QueueProperties[𝒬1]

OpenersExampleSection6(Spacer1)Neat Examples  (1)

Queue with a truncated service distribution:

𝒬=QueueingProcess[3, TruncatedDistribution[{0,1/7}, ExponentialDistribution[4]]];

Properties of the queue:

QueueProperties[𝒬]//Simplify

Compare with the untruncated queue:

𝒬1=QueueingProcess[3,4];

Table[QueueProperties[proc,"MeanSystemSize"],{proc,{𝒬,𝒬1}}]//N

SeedRandom[357];data=RandomFunction[𝒬, {0,300}];

SeedRandom[357];data1=RandomFunction[𝒬1, {0,300}];

ListPlot/@{data,data1}

({{DocumentationFooterIconsRelatedFunction.png, ({{See Also}, {(RefLink[QueueingNetworkProcess, paclet:ref/QueueingNetworkProcess])  ▪  (RefLink[StationaryDistribution, paclet:ref/StationaryDistribution])  ▪  (RefLink[QueueProperties, paclet:ref/QueueProperties])  ▪  (RefLink[ErlangC, paclet:ref/ErlangC])  ▪  (RefLink[ErlangB, paclet:ref/ErlangB])  ▪  (RefLink[RandomFunction, paclet:ref/RandomFunction])  ▪  (RefLink[EstimatedProcess, paclet:ref/EstimatedProcess])  ▪  (RefLink[ExponentialDistribution, paclet:ref/ExponentialDistribution])  ▪  (RefLink[ErlangDistribution, paclet:ref/ErlangDistribution])  ▪  (RefLink[HypoexponentialDistribution, paclet:ref/HypoexponentialDistribution])  ▪  (RefLink[HyperexponentialDistribution, paclet:ref/HyperexponentialDistribution])  ▪  (RefLink[CoxianDistribution, paclet:ref/CoxianDistribution])}})}})

({{DocumentationFooterIconsRelatedGuide.png, ({{Related Guides}, {▪(RefLinkPlain[Queueing Processes, paclet:guide/QueueingProcesses])}, {▪(RefLinkPlain[Finite Markov Processes, paclet:guide/MarkovProcesses])}, {▪(RefLinkPlain[Random Processes, paclet:guide/RandomProcesses])}, {▪(RefLinkPlain[Derived Random Processes, paclet:guide/DerivedRandomProcesses])}, {▪(RefLinkPlain[Systems Modeling, paclet:guide/SystemsModeling])}})}})