# doc-cache created by Octave 4.4.0
# name: cache
# type: cell
# rows: 3
# columns: 101
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
ctmc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1586
 -- Function File: P = ctmc (Q)
 -- Function File: P = ctmc (Q, T. P0)

     Compute stationary or transient state occupancy probabilities for a
     continuous-time Markov chain.

     With a single argument, compute the stationary state occupancy
     probabilitiesr P(1), ..., P(N) for a continuous-time Markov chain
     with state space {1, 2, ..., N} and N \times N infinitesimal
     generator matrix Q.  With three arguments, compute the state
     occupancy probabilities P(1), ..., P(N) that the system is in state
     i at time T, given initial state occupancy probabilities P0(1),
     ..., P0(N) at time 0.

     *INPUTS*

     'Q(i,j)'
          Infinitesimal generator matrix.  Q is a N \times N square
          matrix where 'Q(i,j)' is the transition rate from state i to
          state j, for 1 <= i \neq j <= N. Q must satisfy the property
          that \sum_{j=1}^N Q_{i, j} = 0

     'T'
          Time at which to compute the transient probability (t >= 0).
          If omitted, the function computes the steady state occupancy
          probability vector.

     'P0(i)'
          probability that the system is in state i at time 0.

     *OUTPUTS*

     'P(i)'
          If this function is invoked with a single argument, 'P(i)' is
          the steady-state probability that the system is in state i, i
          = 1, ..., N. If this function is invoked with three arguments,
          'P(i)' is the probability that the system is in state i at
          time T, given the initial occupancy probabilities P0(1), ...,
          P0(N).

     See also: dtmc.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute stationary or transient state occupancy probabilities for a
continuous-t



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
ctmc_bd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 126
 -- Function File: Q = ctmc_bd (B, D)

     This function is deprecated.  Please use 'ctmcbd' instead.

     See also: ctmcbd.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
ctmc_check_Q


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 116
 -- Function File: [RESULT ERR] = ctmc_check_Q (Q)

     This function is deprecated.  Please use 'ctmcchkQ' instead


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
ctmc_exps


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 176
 -- Function File: L = ctmc_exps (Q, T, P )
 -- Function File: L = ctmc_exps (Q, P)

     This function is deprecated.  Please use 'ctmcexps' instead.

     See also: ctmcexps.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
ctmc_fpt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 168
 -- Function File: M = ctmc_fpt (Q)
 -- Function File: M = ctmc_fpt (Q, I, J)

     This function is deprecated.  Please use 'ctmcfpt' instead.

     See also: ctmcfpt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
ctmc_mtta


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 132
 -- Function File: T = ctmc_mtta (Q, P)

     This function is deprecated.  Please use 'ctmcmtta' instead.

     See also: ctmcmtta.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
ctmc_taexps


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 183
 -- Function File: M = ctmc_taexps (Q, T, P)
 -- Function File: M = ctmc_taexps (Q, P)

     This function is deprecated.  Please use 'ctmctaexps' instead.

     See also: ctmctaexps.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
ctmcbd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1178
 -- Function File: Q = ctmcbd (B, D)

     Returns the infinitesimal generator matrix Q for a continuous
     birth-death process over the state space {1, 2, ..., N}.  'B(i)' is
     the transition rate from state i to i+1, and 'D(i)' is the
     transition rate from state i+1 to state i, i=1, 2, ..., N-1.

     Matrix \bf Q is therefore defined as:

           /                                                          \
           | -b(1)     b(1)                                           |
           |  d(1) -(d(1)+b(2))     b(2)                              |
           |           d(2)     -(d(2)+b(3))        b(3)              |
           |                                                          |
           |                ...           ...          ...            |
           |                                                          |
           |                       d(N-2)    -(d(N-2)+b(N-1))  b(N-1) |
           |                                       d(N-1)     -d(N-1) |
           \                                                          /

     where \lambda_i and \mu_i are the birth and death rates,
     respectively.

     See also: dtmcbd.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Returns the infinitesimal generator matrix Q for a continuous
birth-death proces



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
ctmcchkQ


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 273
 -- Function File: [RESULT ERR] = ctmcchkQ (Q)

     If Q is a valid infinitesimal generator matrix, return the size
     (number of rows or columns) of Q.  If Q is not an infinitesimal
     generator matrix, set RESULT to zero, and ERR to an appropriate
     error string.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
If Q is a valid infinitesimal generator matrix, return the size (number
of rows 



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
ctmcexps


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1239
 -- Function File: L = ctmcexps (Q, T, P )
 -- Function File: L = ctmcexps (Q, P)

     With three arguments, compute the expected times 'L(i)' spent in
     each state i during the time interval [0,t], assuming that the
     initial occupancy vector is P.  With two arguments, compute the
     expected time 'L(i)' spent in each transient state i until
     absorption.

     *INPUTS*

     'Q(i,j)'
          N \times N infinitesimal generator matrix.  'Q(i,j)' is the
          transition rate from state i to state j, 1 <= i \neq j <= N.
          The matrix Q must also satisfy the condition \sum_{j=1}^N
          Q_{ij} = 0.

     'T'
          If given, compute the expected sojourn times in [0,t]

     'P(i)'
          Initial occupancy probability vector; 'P(i)' is the
          probability the system is in state i at time 0, i = 1, ..., N

     *OUTPUTS*

     'L(i)'
          If this function is called with three arguments, 'L(i)' is the
          expected time spent in state i during the interval [0,t].  If
          this function is called with two arguments 'L(i)' is the
          expected time spent in transient state i until absorption; if
          state i is absorbing, 'L(i)' is zero.

     See also: dtmcexps.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
With three arguments, compute the expected times 'L(i)' spent in each
state i du



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
ctmcfpt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 832
 -- Function File: M = ctmcfpt (Q)
 -- Function File: M = ctmcfpt (Q, I, J)

     Compute mean first passage times for an irreducible continuous-time
     Markov chain.

     *INPUTS*

     'Q(i,j)'
          Infinitesimal generator matrix.  Q is a N \times N square
          matrix where 'Q(i,j)' is the transition rate from state i to
          state j, for 1 <= i \neq j <= N. Transition rates must be
          nonnegative, and \sum_{j=1}^N Q_{i j} = 0

     'I'
          Initial state.

     'J'
          Destination state.

     *OUTPUTS*

     'M(i,j)'
          average time before state J is visited for the first time,
          starting from state I.  We let 'M(i,i) = 0'.

     'm'
          M is the average time before state J is visited for the first
          time, starting from state I.

     See also: dtmcfpt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute mean first passage times for an irreducible continuous-time
Markov chain



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
ctmcmtta


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 820
 -- Function File: T = ctmcmtta (Q, P)

     Compute the Mean-Time to Absorption (MTTA) of the CTMC described by
     the infinitesimal generator matrix Q, starting from initial
     occupancy probabilities P.  If there are no absorbing states, this
     function fails with an error.

     *INPUTS*

     'Q(i,j)'
          N \times N infinitesimal generator matrix.  'Q(i,j)' is the
          transition rate from state i to state j, i \neq j.  The matrix
          Q must satisfy the condition \sum_{j=1}^N Q_{i j} = 0

     'P(i)'
          probability that the system is in state i at time 0, for each
          i=1, ..., N

     *OUTPUTS*

     'T'
          Mean time to absorption of the process represented by matrix
          Q.  If there are no absorbing states, this function fails.

     See also: dtmcmtta.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute the Mean-Time to Absorption (MTTA) of the CTMC described by the
infinite



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
ctmctaexps


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1248
 -- Function File: M = ctmctaexps (Q, T, P0)
 -- Function File: M = ctmctaexps (Q, P0)

     Compute the _time-averaged sojourn time_ 'M(i)', defined as the
     fraction of the time interval [0,t] (or until absorption) spent in
     state i, assuming that the state occupancy probabilities at time 0
     are P.

     *INPUTS*

     'Q(i,j)'
          Infinitesimal generator matrix.  'Q(i,j)' is the transition
          rate from state i to state j, 1 <= i \neq j <= N. The matrix Q
          must also satisfy the condition \sum_{j=1}^N Q_{ij} = 0

     'T'
          Time.  If omitted, the results are computed until absorption.

     'P0(i)'
          initial state occupancy probabilities.  'P0(i)' is the
          probability that the system is in state i at time 0, i = 1,
          ..., N

     *OUTPUTS*

     'M(i)'
          When called with three arguments, 'M(i)' is the expected
          fraction of the interval [0,t] spent in state i assuming that
          the state occupancy probability at time zero is P.  When
          called with two arguments, 'M(i)' is the expected fraction of
          time until absorption spent in state i; in this case the mean
          time to absorption is 'sum(M)'.

     See also: dtmctaexps.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute the _time-averaged sojourn time_ 'M(i)', defined as the fraction
of the 



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
dtmc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1546
 -- Function File: P = dtmc (P)
 -- Function File: P = dtmc (P, N, P0)

     Compute stationary or transient state occupancy probabilities for a
     discrete-time Markov chain.

     With a single argument, compute the stationary state occupancy
     probabilities 'P(1), ..., P(N)' for a discrete-time Markov chain
     with state space {1, 2, ..., N} and with N \times N transition
     matrix P.  With three arguments, compute the transient state
     occupancy probabilities 'P(1), ..., P(N)' that the system is in
     state i after N steps, given initial occupancy probabilities P0(1),
     ..., P0(N).

     *INPUTS*

     'P(i,j)'
          transition probability from state i to state j.  P must be an
          N \times N irreducible stochastic matrix, which means that the
          sum of each row must be 1 (\sum_{j=1}^N P_{i, j} = 1), and the
          rank of P must be N.

     'N'
          Number of transitions after which compute the state occupancy
          probabilities (scalar, n >= 0)

     'P0(i)'
          probability that at step 0 the system is in state i (vector of
          length N).

     *OUTPUTS*

     'P(i)'
          If this function is called with a single argument, 'P(i)' is
          the steady-state probability that the system is in state i.
          If this function is called with three arguments, 'P(i)' is the
          probability that the system is in state i after N transitions,
          given the initial probabilities 'P0(i)' that the initial state
          is i.

     See also: ctmc.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute stationary or transient state occupancy probabilities for a
discrete-tim



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
dtmc_bd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 126
 -- Function File: P = dtmc_bd (B, D)

     This function is deprecated.  Please use 'dtmcbd' instead.

     See also: dtmcbd.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
dtmc_check_P


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 138
 -- Function File: [R ERR] = dtmc_check_P (P)

     This function is deprecated.  Please use 'dtmcchkP' instead.

     See also: dtmcchkP.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
dtmc_exps


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 177
 -- Function File: L = dtmc_exps (P, N, P0)
 -- Function File: L = dtmc_exps (P, P0)

     This function is deprecated.  Please use 'dtmcexps' instead.

     See also: dtmcexps.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
dtmc_fpt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 126
 -- Function File: M = dtmc_fpt (P)

     This function is deprecated.  Please use 'dtmcfpt' instead.

     See also: ctmcfpt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
dtmc_is_irreducible


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 143
 -- Function File: [R S] = dtmc_is_irreducible (P)

     This function is deprecated.  Please use 'dtmcisir' instead.

     See also: dtmcisir.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
dtmc_mtta


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 182
 -- Function File: [T N B] = dtmc_mtta (P)
 -- Function File: [T N B] = dtmc_mtta (P, P0)

     This function is deprecated.  Please use 'dtmcmtta' instead.

     See also: ctmcmtta.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
dtmc_taexps


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 174
 -- Function File: L = dtmc_taexps (P, N, P0)
 -- Function File: L = dtmc_taexps (P, P0)

     This function is deprecated.  Please use 'dtmctaexps' instead.

     'dtmcexps'


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
dtmcbd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1220
 -- Function File: P = dtmcbd (B, D)

     Returns the transition probability matrix P for a discrete
     birth-death process over state space 1, 2, ..., N. 'B(i)' is the
     transition probability from state i to i+1, and 'D(i)' is the
     transition probability from state i+1 to state i, i=1, 2, ..., N-1.

     Matrix \bf P is therefore defined as:

           /                                                             \
           | 1-b(1)     b(1)                                             |
           |  d(1)  (1-d(1)-b(2))     b(2)                               |
           |            d(2)      (1-d(2)-b(3))     b(3)                 |
           |                                                             |
           |                 ...           ...          ...              |
           |                                                             |
           |                         d(N-2)   (1-d(N-2)-b(N-1))  b(N-1)  |
           |                                        d(N-1)      1-d(N-1) |
           \                                                             /

     where \lambda_i and \mu_i are the birth and death probabilities,
     respectively.

     See also: ctmcbd.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Returns the transition probability matrix P for a discrete birth-death
process o



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
dtmcchkP


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 288
 -- Function File: [R ERR] = dtmcchkP (P)

     Check whether P is a valid transition probability matrix.

     If P is valid, R is the size (number of rows or columns) of P.  If
     P is not a transition probability matrix, R is set to zero, and ERR
     to an appropriate error string.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
Check whether P is a valid transition probability matrix.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
dtmcexps


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1084
 -- Function File: L = dtmcexps (P, N, P0)
 -- Function File: L = dtmcexps (P, P0)

     Compute the expected number of visits to each state during the
     first N transitions, or until abrosption.

     *INPUTS*

     'P(i,j)'
          N \times N transition matrix.  'P(i,j)' is the transition
          probability from state i to state j.

     'N'
          Number of steps during which the expected number of visits are
          computed (N >= 0).  If 'N=0', returns P0.  If 'N > 0', returns
          the expected number of visits after exactly N transitions.

     'P0(i)'
          Initial state occupancy probabilities; 'P0(i)' is the
          probability that the system is in state i at step 0.

     *OUTPUTS*

     'L(i)'
          When called with two arguments, 'L(i)' is the expected number
          of visits to transient state i before absorption.  When called
          with three arguments, 'L(i)' is the expected number of visits
          to state i during the first N transitions, given initial
          occupancy probability P0.

     See also: ctmcexps.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute the expected number of visits to each state during the first N
transitio



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
dtmcfpt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 820
 -- Function File: M = dtmcfpt (P)

     Compute mean first passage times and mean recurrence times for an
     irreducible discrete-time Markov chain over the state space {, 1,
     ..., N}.

     *INPUTS*

     'P(i,j)'
          transition probability from state i to state j.  P must be an
          irreducible stochastic matrix, which means that the sum of
          each row must be 1 (\sum_{j=1}^N P_{i j} = 1), and the rank of
          P must be N.

     *OUTPUTS*

     'M(i,j)'
          For all 1 <= i \neq j <= N, 'M(i,j)' is the average number of
          transitions before state J is entered for the first time,
          starting from state I.  'M(i,i)' is the _mean recurrence time_
          of state i, and represents the average time needed to return
          to state I.

     See also: ctmcfpt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute mean first passage times and mean recurrence times for an
irreducible di



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
dtmcisir


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 661
 -- Function File: [R S] = dtmcisir (P)

     Check if P is irreducible, and identify Strongly Connected
     Components (SCC) in the transition graph of the DTMC with
     transition matrix P.

     *INPUTS*

     'P(i,j)'
          transition probability from state i to state j.  P must be an
          N \times N stochastic matrix.

     *OUTPUTS*

     'R'
          1 if P irreducible, 0 otherwise.

     'S(i)'
          strongly connected component (SCC) that state i belongs to.
          SCCs are numbered 1, 2, ....  If the graph is strongly
          connected, then there is a single SCC and the predicate 'all(s
          == 1)' evaluates to true.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Check if P is irreducible, and identify Strongly Connected Components
(SCC) in t



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
dtmcmtta


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2067
 -- Function File: [T N B] = dtmcmtta (P)
 -- Function File: [T N B] = dtmcmtta (P, P0)

     Compute the expected number of steps before absorption for a DTMC
     with state space {1, 2, ... N} and transition probability matrix P.

     *INPUTS*

     'P(i,j)'
          N \times N transition probability matrix.  'P(i,j)' is the
          transition probability from state i to state j.

     'P0(i)'
          Initial state occupancy probabilities (vector of length N).

     *OUTPUTS*

     'T'
     'T(i)'
          When called with a single argument, T is a vector of length N
          such that 'T(i)' is the expected number of steps before being
          absorbed in any absorbing state, starting from state i; if i
          is absorbing, 'T(i) = 0'.  When called with two arguments, T
          is a scalar, and represents the expected number of steps
          before absorption, starting from the initial state occupancy
          probability P0.

     'N(i)'
     'N(i,j)'
          When called with a single argument, N is the N \times N
          fundamental matrix for P.  'N(i,j)' is the expected number of
          visits to transient state J before absorption, if it is
          started in transient state I.  The initial state is counted if
          i = j.  When called with two arguments, N is a vector of size
          N such that 'N(j)' is the expected number of visits to
          transient state J before absorption, given initial state
          occupancy probability P0.

     'B(i)'
     'B(i,j)'
          When called with a single argument, B is a N \times N matrix
          where 'B(i,j)' is the probability of being absorbed in state
          j, starting from transient state i; if j is not absorbing,
          'B(i,j) = 0'; if i is absorbing, 'B(i,i) = 1' and 'B(i,j) = 0'
          for all j \neq j.  When called with two arguments, B is a
          vector of size N where 'B(j)' is the probability of being
          absorbed in state J, given initial state occupancy
          probabilities P0.

     See also: ctmcmtta.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute the expected number of steps before absorption for a DTMC with
state spa



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
dtmctaexps


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1062
 -- Function File: M = dtmctaexps (P, N, P0)
 -- Function File: M = dtmctaexps (P, P0)

     Compute the _time-averaged sojourn times_ 'M(i)', defined as the
     fraction of time spent in state i during the first steps {0, 1,
     ..., n} (or until absorption), assuming that the state occupancy
     probabilities at time 0 are P0.

     *INPUTS*

     'P(i,j)'
          N \times N transition probability matrix.

     ''
          Number of transitions during which the time-averaged expected
          sojourn times are computed (N >= 0).  if N = 0, returns P0.

     'P0(i)'
          Initial state occupancy probabilities.

     *OUTPUTS*

     'M(i)'
          If this function is called with three arguments, 'M(i)' is the
          expected fraction of steps {0, 1, ..., n} spent in state i,
          assuming that the state occupancy probabilities at time zero
          are P0.  If this function is called with two arguments, 'M(i)'
          is the expected fraction of steps spent in state i until
          absorption.

     See also: ctmctaexps.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute the _time-averaged sojourn times_ 'M(i)', defined as the
fraction of tim



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
engset


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 948
 -- Function File: B = engset (A, M, N)

     Compute the Engset blocking probability P_b(A, m, n) for a system
     with a finite population of n users, m identical servers, no queue,
     individual service rate \mu, individual arrival rate \lambda (i.e.,
     the time until a user tries to request service is exponentially
     distributed with mean 1 / \lambda), and offered load A = \lambda /
     \mu.

     *INPUTS*

     A
          Offered load, defined as A = \lambda / \mu where \lambda is
          the mean arrival rate and \mu the mean service rate of each
          individual server (real, A > 0).

     M
          Number of identical servers (integer, m >= 1).  Default m = 1

     N
          Number of requests (integer, n >= 1).  Default n = 1

     *OUTPUTS*

     B
          The value P_b(A, m, n)

     A, M or n can be vectors, and in this case, the results will be
     vectors as well.

     See also: erlangb, erlangc.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute the Engset blocking probability P_b(A, m, n) for a system with a
finite 



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
erlangb


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 738
 -- Function File: B = erlangb (A, M)

     Compute the value of the Erlang-B formula E_B(A, m) giving the
     probability that an open system with m identical servers, arrival
     rate \lambda, individual service rate \mu and offered load A =
     \lambda / \mu has all servers busy.

     *INPUTS*

     A
          Offered load, defined as A = \lambda / \mu where \lambda is
          the mean arrival rate and \mu the mean service rate of each
          individual server (real, A > 0).

     M
          Number of identical servers (integer, m >= 1).  Default m = 1

     *OUTPUTS*

     B
          The value E_B(A, m)

     A or M can be vectors, and in this case, the results will be
     vectors as well.

     See also: qsmmm.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute the value of the Erlang-B formula E_B(A, m) giving the
probability that 



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
erlangc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 718
 -- Function File: C = erlangc (A, M)

     Compute the steady-state probability E_C(A, m) that an open
     queueing system with m identical servers, infinite wating space,
     arrival rate \lambda, individual service rate \mu and offered load
     A = \lambda / \mu has all the servers busy.

     *INPUTS*

     A OFFERED LOAD. A = \LAMBDA / \MU WHERE
          \lambda is the mean arrival rate and \mu the mean service rate
          of each individual server (real, 0 < A < m).

     M NUMBER OF IDENTICAL SERVERS (INTEGER, M >= 1).
          Default m = 1

     *OUTPUTS*

     B THE VALUE E_C(A, M)

     A or M can be vectors, and in this case, the results will be
     vectors as well.

     See also: qsmmm.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute the steady-state probability E_C(A, m) that an open queueing
system with



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
population_mix


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 147
 -- Function File: pop_mix = population_mix (K, N)

     This function is deprecated.  Please use 'qncmpopmix' instead.

     See also: qncmpopmix.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
qnammm


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 142
 -- Function File: [U, R, Q, X] = qnammm (LAMBDA, MU)

     This function is deprecated.  Please use 'qsammm' instead.

     See also: qsammm.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
qnclosed


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1291
 -- Function File: [U, R, Q, X] = qnclosed (N, S, V, ...)

     This function computes steady-state performance measures of closed
     queueing networks using the Mean Value Analysis (MVA) algorithm.
     The qneneing network is allowed to contain fixed-capacity centers,
     delay centers or general load-dependent centers.  Multiple request
     classes are supported.

     This function dispatches the computation to one of 'qncsemva',
     'qncsmvald' or 'qncmmva'.

        * If N is a scalar, the network is assumed to have a single
          class of requests; in this case, the exact MVA algorithm is
          used to analyze the network.  If S is a vector, then 'S(k)' is
          the average service time of center k, and this function calls
          'qncsmva' which supports load-independent service centers.  If
          S is a matrix, 'S(k,i)' is the average service time at center
          k when i=1, ..., N jobs are present; in this case, the network
          is analyzed with the 'qncmmvald' function.

        * If N is a vector, the network is assumed to have multiple
          classes of requests, and is analyzed using the exact
          multiclass MVA algorithm as implemented in the 'qncmmva'
          function.

     See also: qncsmva, qncsmvald, qncmmva.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This function computes steady-state performance measures of closed
queueing netw



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
qnclosedab


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 148
 -- Function File: [XL, XU, RL, RU] = qnclosedab (N, ...)

     This function is deprecated.  Please use 'qncsaba' instead.

     See also: qncsaba.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
qnclosedbsb


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 150
 -- Function File: [XL, XU, RL, RU] = qnclosedbsb (N, ... )

     This function is deprecated.  Please use 'qncsbsb' instead.

     See also: qncsbsb.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
qnclosedgb


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 147
 -- Function File: [XL, XU, QL, QU] = qnclosedgb (N, D, Z)

     This function is deprecated.  Please use 'qncsgb' instead.

     See also: qncsgb.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
qnclosedmultimva


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 466
 -- Function File: [U, R, Q, X] = qnclosedmultimva (N, S )
 -- Function File: [U, R, Q, X] = qnclosedmultimva (N, S, V)
 -- Function File: [U, R, Q, X] = qnclosedmultimva (N, S, V, M)
 -- Function File: [U, R, Q, X] = qnclosedmultimva (N, S, V, M, Z)
 -- Function File: [U, R, Q, X] = qnclosedmultimva (N, S, P)
 -- Function File: [U, R, Q, X] = qnclosedmultimva (N, S, P, M)

     This function is deprecated.  Please use 'qncmmva' instead.

     See also: qncmmva.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
qnclosedmultimvaapprox


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 490
 -- Function File: [U, R, Q, X] = qnclosedmultimvaapprox (N, S, V)
 -- Function File: [U, R, Q, X] = qnclosedmultimvaapprox (N, S, V, M)
 -- Function File: [U, R, Q, X] = qnclosedmultimvaapprox (N, S, V, M, Z)
 -- Function File: [U, R, Q, X] = qnclosedmultimvaapprox (N, S, V, M, Z,
          TOL)
 -- Function File: [U, R, Q, X] = qnclosedmultimvaapprox (N, S, V, M, Z,
          TOL, ITER_MAX)

     This function is deprecated.  Please use 'qncmmvaap' instead.

     See also: qncmmvaap.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
qnclosedpb


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 205
 -- Function File: [XL, XU, RL, RU] = qnclosedpb (N, D )
 -- Function File: [XL, XU, RL, RU] = qnclosedpb (N, D, Z )

     This function is deprecated.  Please use 'qncspb' instead.

     See also: qncspb.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
qnclosedsinglemva


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 294
 -- Function File: [U, R, Q, X, G] = qnclosedsinglemva (N, S, V)
 -- Function File: [U, R, Q, X, G] = qnclosedsinglemva (N, S, V, M)
 -- Function File: [U, R, Q, X, G] = qnclosedsinglemva (N, S, V, M, Z)

     This function is deprecated.  Please use 'qncsmva' instead.

     See also: qncsmva.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
qnclosedsinglemvaapprox


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 505
 -- Function File: [U, R, Q, X] = qnclosedsinglemvaapprox (N, S, V)
 -- Function File: [U, R, Q, X] = qnclosedsinglemvaapprox (N, S, V, M)
 -- Function File: [U, R, Q, X] = qnclosedsinglemvaapprox (N, S, V, M,
          Z)
 -- Function File: [U, R, Q, X] = qnclosedsinglemvaapprox (N, S, V, M,
          Z, TOL)
 -- Function File: [U, R, Q, X] = qnclosedsinglemvaapprox (N, S, V, M,
          Z, TOL, ITER_MAX)

     This function is deprecated.  Please use 'qncsmvaap' instead.

     See also: qncsmvaap.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
qnclosedsinglemvald


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 225
 -- Function File: [U, R, Q, X] = qnclosedsinglemvald (N, S, V)
 -- Function File: [U, R, Q, X] = qnclosedsinglemvald (N, S, V, Z)

     This function is deprecated.  Please use 'qncsmvald' instead.

     See also: qncsmvald.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
qncmaba


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1606
 -- Function File: [XL, XU, RL, RU] = qncmaba (N, D)
 -- Function File: [XL, XU, RL, RU] = qncmaba (N, S, V)
 -- Function File: [XL, XU, RL, RU] = qncmaba (N, S, V, M)
 -- Function File: [XL, XU, RL, RU] = qncmaba (N, S, V, M, Z)

     Compute Asymptotic Bounds for closed, multiclass networks with K
     service centers and C customer classes.  Single-server and
     infinite-server nodes are supported.  Multiple-server nodes and
     general load-dependent servers are not supported.

     *INPUTS*

     'N(c)'
          number of class c requests in the system (vector of length C,
          'N(c) >= 0').

     'D(c, k)'
          class c service demand at center k (C \times K matrix, 'D(c,k)
          >= 0').

     'S(c, k)'
          mean service time of class c requests at center k (C \times K
          matrix, 'S(c,k) >= 0').

     'V(c,k)'
          average number of visits of class c requests to center k (C
          \times K matrix, 'V(c,k) >= 0').

     'M(k)'
          number of servers at center k (if M is a scalar, all centers
          have that number of servers).  If 'M(k) < 1', center k is a
          delay center (IS); if 'M(k) = 1', center k is a M/M/1-FCFS
          server.  This function does not support multiple-server nodes.
          Default is 1.

     'Z(c)'
          class c external delay (vector of length C, 'Z(c) >= 0').
          Default is 0.

     *OUTPUTS*

     'XL(c)'
     'XU(c)'
          Lower and upper bounds for class c throughput.

     'RL(c)'
     'RU(c)'
          Lower and upper bounds for class c response time.

     See also: qncsaba.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute Asymptotic Bounds for closed, multiclass networks with K service
centers



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
qncmbsb


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 999
 -- Function File: [XL, XU, RL, RU] = qncmbsb (N, D)
 -- Function File: [XL, XU, RL, RU] = qncmbsb (N, S, V)

     Compute Balanced System Bounds for closed, multiclass networks with
     K service centers and C customer classes.  Only single-server nodes
     are supported.

     *INPUTS*

     'N(c)'
          number of class c requests in the system (vector of length C).

     'D(c, k)'
          class c service demand at center k (C \times K matrix, 'D(c,k)
          >= 0').

     'S(c, k)'
          mean service time of class c requests at center k (C \times K
          matrix, 'S(c,k) >= 0').

     'V(c,k)'
          average number of visits of class c requests to center k (C
          \times K matrix, 'V(c,k) >= 0').

     *OUTPUTS*

     'XL(c)'
     'XU(c)'
          Lower and upper class c throughput bounds (vector of length
          C).

     'RL(c)'
     'RU(c)'
          Lower and upper class c response time bounds (vector of length
          C).

     See also: qncsbsb.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute Balanced System Bounds for closed, multiclass networks with K
service ce



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
qncmcb


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1042
 -- Function File: [XL, XU, RL, RU] = qncmcb (N, D)
 -- Function File: [XL, XU, RL, RU] = qncmcb (N, S, V)

     Composite Bound (CB) on throughput and response time for closed
     multiclass networks.

     This function implements the Composite Bound Method described in T.
     Kerola, 'The Composite Bound Method (CBM) for Computing Throughput
     Bounds in Multiple Class Environments', Technical Report
     CSD-TR-475, Purdue University, march 13, 1984 (revised august 27,
     1984).

     *INPUTS*

     'N(c)'
          number of class c requests in the system.

     'D(c, k)'
          class c service demand at center k ('S(c,k) >= 0').

     'S(c, k)'
          mean service time of class c requests at center k ('S(c,k) >=
          0').

     'V(c,k)'
          average number of visits of class c requests to center k
          ('V(c,k) >= 0').

     *OUTPUTS*

     'XL(c)'
     'XU(c)'
          Lower and upper class c throughput bounds.

     'RL(c)'
     'RU(c)'
          Lower and upper class c response time bounds.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Composite Bound (CB) on throughput and response time for closed
multiclass netwo



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
qncmmva


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5681
 -- Function File: [U, R, Q, X] = qncmmva (N, S )
 -- Function File: [U, R, Q, X] = qncmmva (N, S, V)
 -- Function File: [U, R, Q, X] = qncmmva (N, S, V, M)
 -- Function File: [U, R, Q, X] = qncmmva (N, S, V, M, Z)
 -- Function File: [U, R, Q, X] = qncmmva (N, S, P)
 -- Function File: [U, R, Q, X] = qncmmva (N, S, P, R)
 -- Function File: [U, R, Q, X] = qncmmva (N, S, P, R, M)

     Compute steady-state performance measures for closed, multiclass
     queueing networks using the Mean Value Analysys (MVA) algorithm.

     Queueing policies at service centers can be any of the following:

     *FCFS*
          (First-Come-First-Served) customers are served in order of
          arrival; multiple servers are allowed.  For this kind of
          queueing discipline, average service times must be
          class-independent.

     *PS*
          (Processor Sharing) customers are served in parallel by a
          single server, each customer receiving an equal share of the
          service rate.

     *LCFS-PR*
          (Last-Come-First-Served, Preemptive Resume) customers are
          served in reverse order of arrival by a single server and the
          last arrival preempts the customer in service who will later
          resume service at the point of interruption.

     *IS*
          (Infinite Server) customers are delayed independently of other
          customers at the service center (there is effectively an
          infinite number of servers).

          Note: If this function is called specifying the visit ratios
          V, then class switching is *not* allowed.

          If this function is called specifying the routing probability
          matrix P, then class switching *is* allowed; however, in this
          case all nodes are restricted to be fixed rate servers or
          delay centers: multiple-server and general load-dependent
          centers are not supported.

     *INPUTS*

     'N(c)'
          number of class c requests; 'N(c) >= 0'.  If class c has no
          requests ('N(c) == 0'), then for all K, this function returns
          'U(c,k) = R(c,k) = Q(c,k) = X(c,k) = 0'

     'S(c,k)'
          mean service time for class c requests at center k ('S(c,k) >=
          0').  If the service time at center k is class-dependent, then
          center k is assumed to be of type -/G/1-PS (Processor
          Sharing).  If center k is a FCFS node ('M(k)>1'), then the
          service times *must* be class-independent, i.e., all classes
          *must* have the same service time.

     'V(c,k)'
          average number of visits of class c requests at center k;
          'V(c,k) >= 0', default is 1.  *If you pass this argument,
          class switching is not allowed*

     'P(r,i,s,j)'
          probability that a class r request completing service at
          center i is routed to center j as a class s request; the
          reference stations for each class are specified with the
          paramter R.  *If you pass argument P, class switching is
          allowed*; however, you can not specify any external delay
          (i.e., Z must be zero) and all servers must be fixed-rate or
          infinite-server nodes ('M(k) <= 1' for all k).

     'R(c)'
          reference station for class c.  If omitted, station 1 is the
          reference station for all classes.  See 'qncmvisits'.

     'M(k)'
          If 'M(k)<1', then center k is assumed to be a delay center (IS
          node -/G/\infty).  If 'M(k)==1', then service center k is a
          regular queueing center (M/M/1-FCFS, -/G/1-LCFS-PR or
          -/G/1-PS). Finally, if 'M(k)>1', center k is a M/M/m-FCFS
          center with 'M(k)' identical servers.  Default is 'M(k)=1' for
          each k.

     'Z(c)'
          class c external delay (think time); 'Z(c) >= 0'.  Default is
          0.  This parameter can not be used if you pass a routing
          matrix as the second parameter of 'qncmmva'.

     *OUTPUTS*

     'U(c,k)'
          If k is a FCFS, LCFS-PR or PS node ('M(k) >= 1'), then
          'U(c,k)' is the class c utilization at center k, 0 <= U(c,k)
          <= 1.  If k is an IS node, then 'U(c,k)' is the class c
          _traffic intensity_ at center k, defined as 'U(c,k) =
          X(c,k)*S(c,k)'.  In this case the value of 'U(c,k)' may be
          greater than one.

     'R(c,k)'
          class c response time at center k.  The class c _residence
          time_ at center k is 'R(c,k) * C(c,k)'.  The total class c
          system response time is 'dot(R, V, 2)'.

     'Q(c,k)'
          average number of class c requests at center k.  The total
          number of requests at center k is 'sum(Q(:,k))'.  The total
          number of class c requests in the system is 'sum(Q(c,:))'.

     'X(c,k)'
          class c throughput at center k.  The class c throughput can be
          computed as 'X(c,1) / V(c,1)'.

          Note on numerical stability: In presence of load-dependent
          servers (e.g., if 'M(i)>1' for some i), the MVA algorithm is
          known to be numerically unstable.  Generally this problem
          shows up as negative values for the computed response times or
          utilizations.  This is not a problem with the 'queueing'
          package, but with the MVA algorithm; as such, there is no
          known workaround at the moment (aoart from using a different
          solution technique, if available).  This function prints a
          warning if it detects numerical problems; you can disable the
          warning with the command 'warning("off",
          "qn:numerical-instability")'.

     See also: qnclosed, qncmmvaapprox, qncmvisits.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute steady-state performance measures for closed, multiclass
queueing networ



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
qncmmvaap


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2788
 -- Function File: [U, R, Q, X] = qncmmvaap (N, S, V)
 -- Function File: [U, R, Q, X] = qncmmvaap (N, S, V, M)
 -- Function File: [U, R, Q, X] = qncmmvaap (N, S, V, M, Z)
 -- Function File: [U, R, Q, X] = qncmmvaap (N, S, V, M, Z, TOL)
 -- Function File: [U, R, Q, X] = qncmmvaap (N, S, V, M, Z, TOL,
          ITER_MAX)

     Approximate Mean Value Analysis (MVA) for closed, multiclass
     queueing networks with K service centers and C customer classes.

     This implementation uses Bard and Schweitzer approximation.  It is
     based on the assumption that the queue length at service center k
     with population set {\bf N}-{\bf 1}_c is approximately equal to the
     queue length with population set \bf N, times (n-1)/n:

           Q_i(N-1c) ~ (n-1)/n Q_i(N)

     where \bf N is a valid population mix, {\bf N}-{\bf 1}_c is the
     population mix \bf N with one class c customer removed, and n =
     \sum_c N_c is the total number of requests.

     This implementation works for networks with infinite server (IS)
     and single-server nodes only.

     *INPUTS*

     'N(c)'
          number of class c requests in the system ('N(c) >= 0').

     'S(c,k)'
          mean service time for class c customers at center k ('S(c,k)
          >= 0').

     'V(c,k)'
          average number of visits of class c requests to center k
          ('V(c,k) >= 0').

     'M(k)'
          number of servers at center k.  If 'M(k) < 1', then the
          service center k is assumed to be a delay center (IS). If
          'M(k) == 1', service center k is a regular queueing center
          (FCFS, LCFS-PR or PS) with a single server node.  If omitted,
          each service center has a single server.  Note that multiple
          server nodes are not supported.

     'Z(c)'
          class c external delay ('Z >= 0').  Default is 0.

     'TOL'
          Stopping tolerance ('TOL>0').  The algorithm stops if the
          queue length computed on two subsequent iterations are less
          than TOL.  Default is 10^{-5}.

     'ITER_MAX'
          Maximum number of iterations ('ITER_MAX>0'.  The function
          aborts if convergenge is not reached within the maximum number
          of iterations.  Default is 100.

     *OUTPUTS*

     'U(c,k)'
          If k is a FCFS, LCFS-PR or PS node, then 'U(c,k)' is the
          utilization of class c requests on service center k.  If k is
          an IS node, then 'U(c,k)' is the class c _traffic intensity_
          at device k, defined as 'U(c,k) = X(c)*S(c,k)'

     'R(c,k)'
          response time of class c requests at service center k.

     'Q(c,k)'
          average number of class c requests at service center k.

     'X(c,k)'
          class c throughput at service center k.

     See also: qncmmva.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Approximate Mean Value Analysis (MVA) for closed, multiclass queueing
networks w



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
qncmnpop


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 588
 -- Function File: H = qncmnpop (N)

     Given a network with C customer classes, this function computes the
     number of k-mixes 'H(r,k)' that can be constructed by the
     multiclass MVA algorithm by allocating k customers to the first r
     classes.

     *INPUTS*

     'N(c)'
          number of class-c requests in the system.  The total number of
          requests in the network is 'sum(N)'.

     *OUTPUTS*

     'H(r,k)'
          is the number of k mixes that can be constructed allocating k
          customers to the first r classes.

     See also: qncmmva,qncmpopmix.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Given a network with C customer classes, this function computes the
number of k-



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
qncmpopmix


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 955
 -- Function File: pop_mix = qncmpopmix (K, N)

     Return the set of population mixes for a closed multiclass queueing
     network with exactly K customers.  Specifically, given a closed
     multiclass QN with C customer classes, where there are 'N(c)' class
     c requests, a k-mix MIX is a C-dimensional vector with the
     following properties:

           all( mix >= 0 );
           all( mix <= N );
           sum( mix ) == k;

     POP_MIX is a matrix with C columns, such that each row represents a
     valid mix.

     *INPUTS*

     'K'
          Size of the requested mix (scalar, 'K >= 0').

     'N(c)'
          number of class c requests ('K <= sum(N)').

     *OUTPUTS*

     'POP_MIX(i,c)'
          number of class c requests in the i-th population mix.  The
          number of mixes is 'rows(POP_MIX)'.

     If you are interested in the number of k-mixes only, you can use
     the funcion 'qnmvapop'.

     See also: qncmnpop.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Return the set of population mixes for a closed multiclass queueing
network with



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
qncmva


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 207
 -- Function File: [U, R, Q, X] = qncmva (N, S, SLD, V)
 -- Function File: [U, R, Q, X] = qncmva (N, S, SLD, V, Z)

     This function is deprecated.  Please use 'qncscmva' instead.

     See also: qncscmva.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
qncmvisits


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1293
 -- Function File: [V CH] = qncmvisits (P)
 -- Function File: [V CH] = qncmvisits (P, R)

     Compute the average number of visits to the service centers of a
     closed multiclass network with K service centers and C customer
     classes.

     *INPUTS*

     'P(r,i,s,j)'
          probability that a class r request which completed service at
          center i is routed to center j as a class s request.  Class
          switching is allowed.

     'R(c)'
          index of class c reference station, r(c) \in {1, ..., K}, 1 <=
          c <= C. The class c visit count to server 'R(c)' ('V(c,r(c))')
          is conventionally set to 1.  The reference station serves two
          purposes: (i) its throughput is assumed to be the system
          throughput, and (ii) a job returning to the reference station
          is assumed to have completed one cycle.  Default is to
          consider station 1 as the reference station for all classes.

     *OUTPUTS*

     'V(c,i)'
          number of visits of class c requests at center i.

     'CH(c)'
          chain number that class c belongs to.  Different classes can
          belong to the same chain.  Chains are numbered sequentially
          starting from 1 (1, 2, ...).  The total number of chains is
          'max(CH)'.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute the average number of visits to the service centers of a closed
multicla



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
qnconvolution


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 217
 -- Function File: [U, R, Q, X, G] = qnconvolution (N, S, V)
 -- Function File: [U, R, Q, X, G] = qnconvolution (N, S, V, M)

     This function is deprecated.  Please use 'qncsconv' instead.

     See also: qncsconv.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
qnconvolutionld


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 159
 -- Function File: [U, R, Q, X, G] = qnconvolutionld (N, S, V)

     This function is deprecated.  Please use 'qncsconvld' instead.

     See also: qncsconvld.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
qncsaba


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1401
 -- Function File: [XL, XU, RL, RU] = qncsaba (N, D)
 -- Function File: [XL, XU, RL, RU] = qncsaba (N, S, V)
 -- Function File: [XL, XU, RL, RU] = qncsaba (N, S, V, M)
 -- Function File: [XL, XU, RL, RU] = qncsaba (N, S, V, M, Z)

     Compute Asymptotic Bounds for the system throughput and response
     time of closed, single-class networks with K service centers.

     Single-server and infinite-server nodes are supported.
     Multiple-server nodes and general load-dependent servers are not
     supported.

     *INPUTS*

     'N'
          number of requests in the system (scalar, 'N>0').

     'D(k)'
          service demand at center k ('D(k) >= 0').

     'S(k)'
          mean service time at center k ('S(k) >= 0').

     'V(k)'
          average number of visits to center k ('V(k) >= 0').

     'M(k)'
          number of servers at center k (if M is a scalar, all centers
          have that number of servers).  If 'M(k) < 1', center k is a
          delay center (IS); if 'M(k) = 1', center k is a M/M/1-FCFS
          server.  This function does not support multiple-server nodes.
          Default is 1.

     'Z'
          External delay (scalar, 'Z >= 0').  Default is 0.

     *OUTPUTS*

     'XL'
     'XU'
          Lower and upper bounds on the system throughput.

     'RL'
     'RU'
          Lower and upper bounds on the system response time.

     See also: qncmaba.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute Asymptotic Bounds for the system throughput and response time of
closed,



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
qncsbsb


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1168
 -- Function File: [XL, XU, RL, RU] = qncsbsb (N, D)
 -- Function File: [XL, XU, RL, RU] = qncsbsb (N, S, V)
 -- Function File: [XL, XU, RL, RU] = qncsbsb (N, S, V, M)
 -- Function File: [XL, XU, RL, RU] = qncsbsb (N, S, V, M, Z)

     Compute Balanced System Bounds on system throughput and response
     time for closed, single-class networks with K service centers.

     *INPUTS*

     'N'
          number of requests in the system (scalar, 'N >= 0').

     'D(k)'
          service demand at center k ('D(k) >= 0').

     'S(k)'
          mean service time at center k ('S(k) >= 0').

     'V(k)'
          average number of visits to center k ('V(k) >= 0').  Default
          is 1.

     'M(k)'
          number of servers at center k.  This function supports 'M(k) =
          1' only (single-eserver FCFS nodes); this parameter is only
          for compatibility with 'qncsaba'.  Default is 1.

     'Z'
          External delay ('Z >= 0').  Default is 0.

     *OUTPUTS*

     'XL'
     'XU'
          Lower and upper bound on the system throughput.

     'RL'
     'RU'
          Lower and upper bound on the system response time.

     See also: qncmbsb.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute Balanced System Bounds on system throughput and response time
for closed



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
qncscmva


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1494
 -- Function File: [U, R, Q, X] = qncscmva (N, S, SLD, V)
 -- Function File: [U, R, Q, X] = qncscmva (N, S, SLD, V, Z)

     Conditional MVA (CMVA) algorithm, a numerically stable variant of
     MVA. This function supports a network of M >= 1 service centers and
     a single delay center.  Servers 1, ..., M-1 are load-independent;
     server M is load-dependent.

     *INPUTS*

     'N'
          Number of requests in the system, 'N >= 0'.  If 'N == 0', this
          function returns 'U = R = Q = X = 0'

     'S(k)'
          mean service time on server k = 1, ..., M-1 ('S(k) > 0').  If
          there are no fixed-rate servers, then 'S = []'

     'SLD(n)'
          inverse service rate at server M (the load-dependent server)
          when there are n requests, n=1, ..., N. 'SLD(n) = ' 1 /
          \mu(n).

     'V(k)'
          average number of visits to service center k=1, ..., M, where
          'V(k) >= 0'.  'V(1:M-1)' are the visit rates to the fixed rate
          servers; 'V(M)' is the visit rate to the load dependent
          server.

     'Z'
          External delay for customers ('Z >= 0').  Default is 0.

     *OUTPUTS*

     'U(k)'
          center k utilization (k=1, ..., M)

     'R(k)'
          response time of center k (k=1, ..., M). The system response
          time RSYS can be computed as 'RSYS = N/XSYS - Z'

     'Q(k)'
          average number of requests at center k (k=1, ..., M).

     'X(k)'
          center k throughput (k=1, ..., M).


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 70
Conditional MVA (CMVA) algorithm, a numerically stable variant of MVA.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
qncsconv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1395
 -- Function File: [U, R, Q, X, G] = qncsconv (N, S, V)
 -- Function File: [U, R, Q, X, G] = qncsconv (N, S, V, M)

     Analyze product-form, single class closed networks with K service
     centers using the convolution algorithm.

     Load-independent service centers, multiple servers (M/M/m queues)
     and IS nodes are supported.  For general load-dependent service
     centers, use 'qncsconvld' instead.

     *INPUTS*

     'N'
          Number of requests in the system ('N>0').

     'S(k)'
          average service time on center k ('S(k) >= 0').

     'V(k)'
          visit count of service center k ('V(k) >= 0').

     'M(k)'
          number of servers at center k.  If 'M(k) < 1', center k is a
          delay center (IS); if 'M(k) >= 1', center k it is a regular
          M/M/m queueing center with 'M(k)' identical servers.  Default
          is 'M(k) = 1' for all k.

     *OUTPUT*

     'U(k)'
          center k utilization.  For IS nodes, 'U(k)' is the _traffic
          intensity_ 'X(k) * S(k)'.

     'R(k)'
          average response time of center k.

     'Q(k)'
          average number of customers at center k.

     'X(k)'
          throughput of center k.

     'G(n)'
          Vector of normalization constants.  'G(n+1)' contains the
          value of the normalization constant with n requests G(n), n=0,
          ..., N.

     See also: qncsconvld.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Analyze product-form, single class closed networks with K service
centers using 



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
qncsconvld


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1363
 -- Function File: [U, R, Q, X, G] = qncsconvld (N, S, V)

     Convolution algorithm for product-form, single-class closed
     queueing networks with K general load-dependent service centers.

     This function computes steady-state performance measures for
     single-class, closed networks with load-dependent service centers
     using the convolution algorithm; the normalization constants are
     also computed.  The normalization constants are returned as vector
     'G=[G(1), ..., G(N+1)]' where 'G(i+1)' is the value of G(i).

     *INPUTS*

     'N'
          Number of requests in the system ('N>0').

     'S(k,n)'
          mean service time at center k where there are n requests, 1 <=
          n <= N. 'S(k,n)' = 1 / \mu_{k,n}, where \mu_{k,n} is the
          service rate of center k when there are n requests.

     'V(k)'
          visit count of service center k ('V(k) >= 0').  The length of
          V is the number of servers K in the network.

     *OUTPUT*

     'U(k)'
          center k utilization.

     'R(k)'
          average response time at center k.

     'Q(k)'
          average number of requests in center k.

     'X(k)'
          center k throughput.

     'G(n)'
          Normalization constants (vector).  'G(n+1)' corresponds to
          G(n), as array indexes in Octave start from 1.

     See also: qncsconv.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Convolution algorithm for product-form, single-class closed queueing
networks wi



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
qncsgb


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1599
 -- Function File: [XL, XU, RL, RU, QL, QU] = qncsgb (N, D)
 -- Function File: [XL, XU, RL, RU, QL, QU] = qncsgb (N, S, V)
 -- Function File: [XL, XU, RL, RU, QL, QU] = qncsgb (N, S, V, M)
 -- Function File: [XL, XU, RL, RU, QL, QU] = qncsgb (N, S, V, M, Z)

     Compute Geometric Bounds (GB) on system throughput, system response
     time and server queue lenghts for closed, single-class networks
     with K service centers and N requests.

     *INPUTS*

     'N'
          number of requests in the system (scalar, 'N > 0').

     'D(k)'
          service demand of service center k (vector of length K, 'D(k)
          >= 0').

     'S(k)'
          mean service time at center k (vector of length K, 'S(k) >=
          0').

     'V(k)'
          visit ratio to center k (vector of length K, 'V(k) >= 0').

     'M(k)'
          number of servers at center k.  This function only supports
          M/M/1 queues, therefore M must be 'ones(size(S))'.

     'Z'
          external delay (think time, 'Z >= 0', scalar).  Default is 0.

     *OUTPUTS*

     'XL'
     'XU'
          Lower and upper bound on the system throughput.  If 'Z>0',
          these bounds are computed using _Geometric Square-root Bounds_
          (GSB). If 'Z==0', these bounds are computed using _Geometric
          Bounds_ (GB)

     'RL'
     'RU'
          Lower and upper bound on the system response time.  These
          bounds are derived from XL and XU using Little's Law: 'RL = N
          / XU - Z', 'RU = N / XL - Z'

     'QL(k)'
     'QU(k)'
          lower and upper bounds of center K queue length.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute Geometric Bounds (GB) on system throughput, system response time
and ser



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
qncsmva


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3401
 -- Function File: [U, R, Q, X, G] = qncsmva (N, S, V)
 -- Function File: [U, R, Q, X, G] = qncsmva (N, S, V, M)
 -- Function File: [U, R, Q, X, G] = qncsmva (N, S, V, M, Z)

     Analyze closed, single class queueing networks using the exact Mean
     Value Analysis (MVA) algorithm.

     The following queueing disciplines are supported: FCFS, LCFS-PR, PS
     and IS (Infinite Server).  This function supports fixed-rate
     service centers or multiple server nodes.  For general
     load-dependent service centers, use the function 'qncsmvald'
     instead.

     Additionally, the normalization constant G(n), n=0, ..., N is
     computed; G(n) can be used in conjunction with the BCMP theorem to
     compute steady-state probabilities.

     *INPUTS*

     'N'
          Population size (number of requests in the system, 'N >= 0').
          If 'N == 0', this function returns 'U = R = Q = X = 0'

     'S(k)'
          mean service time at center k ('S(k) >= 0').

     'V(k)'
          average number of visits to service center k ('V(k) >= 0').

     'Z'
          External delay for customers ('Z >= 0').  Default is 0.

     'M(k)'
          number of servers at center k (if M is a scalar, all centers
          have that number of servers).  If 'M(k) < 1', center k is a
          delay center (IS); otherwise it is a regular queueing center
          (FCFS, LCFS-PR or PS) with 'M(k)' servers.  Default is 'M(k) =
          1' for all k (each service center has a single server).

     *OUTPUTS*

     'U(k)'
          If k is a FCFS, LCFS-PR or PS node ('M(k) >= 1'), then 'U(k)'
          is the utilization of center k, 0 <= U(k) <= 1.  If k is an IS
          node ('M(k) < 1'), then 'U(k)' is the _traffic intensity_
          defined as 'X(k)*S(k)'.  In this case the value of 'U(k)' may
          be greater than one.

     'R(k)'
          center k response time.  The _Residence Time_ at center k is
          'R(k) * V(k)'.  The system response time RSYS can be computed
          either as 'RSYS = N/XSYS - Z' or as 'RSYS = dot(R,V)'

     'Q(k)'
          average number of requests at center k.  The number of
          requests in the system can be computed either as 'sum(Q)', or
          using the formula 'N-XSYS*Z'.

     'X(k)'
          center K throughput.  The system throughput XSYS can be
          computed as 'XSYS = X(1) / V(1)'

     'G(n)'
          Normalization constants.  'G(n+1)' contains the value of the
          normalization constant G(n), n=0, ..., N as array indexes in
          Octave start from 1.  G(n) can be used in conjunction with the
          BCMP theorem to compute steady-state probabilities.

          Note on numerical stability: In presence of load-dependent
          servers (i.e., if 'M(k)>1' for some k), the MVA algorithm is
          known to be numerically unstable.  Generally the issue
          manifests itself as negative values for the response times or
          utilizations.  This is not a problem of the 'queueing'
          toolbox, but of the MVA algorithm, and therefore has currently
          no known workaround (apart from using a different solution
          technique, if available).  This function prints a warning if
          numerical problems are detected; the warning can be disabled
          with the command 'warning("off", "qn:numerical-instability")'.

     See also: qncsmvald,qncscmva.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Analyze closed, single class queueing networks using the exact Mean
Value Analys



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
qncsmvaap


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2638
 -- Function File: [U, R, Q, X] = qncsmvaap (N, S, V)
 -- Function File: [U, R, Q, X] = qncsmvaap (N, S, V, M)
 -- Function File: [U, R, Q, X] = qncsmvaap (N, S, V, M, Z)
 -- Function File: [U, R, Q, X] = qncsmvaap (N, S, V, M, Z, TOL)
 -- Function File: [U, R, Q, X] = qncsmvaap (N, S, V, M, Z, TOL,
          ITER_MAX)

     Analyze closed, single class queueing networks using the
     Approximate Mean Value Analysis (MVA) algorithm.  This function is
     based on approximating the number of customers seen at center k
     when a new request arrives as Q_k(N) \times (N-1)/N. This function
     only handles single-server and delay centers; if your network
     contains general load-dependent service centers, use the function
     'qncsmvald' instead.

     *INPUTS*

     'N'
          Population size (number of requests in the system, 'N > 0').

     'S(k)'
          mean service time on server k ('S(k)>0').

     'V(k)'
          average number of visits to service center k ('V(k) >= 0').

     'M(k)'
          number of servers at center k (if M is a scalar, all centers
          have that number of servers).  If 'M(k) < 1', center k is a
          delay center (IS); if 'M(k) == 1', center k is a regular
          queueing center (FCFS, LCFS-PR or PS) with one server
          (default).  This function does not support multiple server
          nodes ('M(k) > 1').

     'Z'
          External delay for customers ('Z >= 0').  Default is 0.

     'TOL'
          Stopping tolerance.  The algorithm stops when the maximum
          relative difference between the new and old value of the queue
          lengths Q becomes less than the tolerance.  Default is
          10^{-5}.

     'ITER_MAX'
          Maximum number of iterations ('ITER_MAX>0'.  The function
          aborts if convergenge is not reached within the maximum number
          of iterations.  Default is 100.

     *OUTPUTS*

     'U(k)'
          If k is a FCFS, LCFS-PR or PS node ('M(k) == 1'), then 'U(k)'
          is the utilization of center k.  If k is an IS node ('M(k) <
          1'), then 'U(k)' is the _traffic intensity_ defined as
          'X(k)*S(k)'.

     'R(k)'
          response time at center k.  The system response time RSYS can
          be computed as 'RSYS = N/XSYS - Z'

     'Q(k)'
          average number of requests at center k.  The number of
          requests in the system can be computed either as 'sum(Q)', or
          using the formula 'N-XSYS*Z'.

     'X(k)'
          center k throughput.  The system throughput XSYS can be
          computed as 'XSYS = X(1) / V(1)'

     See also: qncsmva,qncsmvald.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Analyze closed, single class queueing networks using the Approximate
Mean Value 



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
qncsmvablo


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1033
 -- Function File: [U, R, Q, X] = qncsmvablo (N, S, M, P )

     Approximate MVA algorithm for closed queueing networks with
     blocking.

     *INPUTS*

     'N'
          number of requests in the system.  N must be strictly greater
          than zero, and less than the overall network capacity: '0 < N
          < sum(M)'.

     'S(k)'
          average service time on server k ('S(k) > 0').

     'M(k)'
          capacity of center k.  The capacity is the maximum number of
          requests in a service center, including the request in service
          ('M(k) >= 1').

     'P(i,j)'
          probability that a request which completes service at server i
          will be transferred to server j.

     *OUTPUTS*

     'U(k)'
          center k utilization.

     'R(k)'
          average response time of service center k.

     'Q(k)'
          average number of requests in service center k (including the
          request in service).

     'X(k)'
          center k throughput.

     See also: qnopen, qnclosed.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 69
Approximate MVA algorithm for closed queueing networks with blocking.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
qncsmvald


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1668
 -- Function File: [U, R, Q, X] = qncsmvald (N, S, V)
 -- Function File: [U, R, Q, X] = qncsmvald (N, S, V, Z)

     Mean Value Analysis algorithm for closed, single class queueing
     networks with K service centers and load-dependent service times.
     This function supports FCFS, LCFS-PR, PS and IS nodes.  For
     networks with only fixed-rate centers and multiple-server nodes,
     the function 'qncsmva' is more efficient.

     *INPUTS*

     'N'
          Population size (number of requests in the system, 'N >= 0').
          If 'N == 0', this function returns 'U = R = Q = X = 0'

     'S(k,n)'
          mean service time at center k where there are n requests, 1 <=
          n <= N. 'S(k,n)' = 1 / \mu_{k}(n), where \mu_{k}(n) is the
          service rate of center k when there are n requests.

     'V(k)'
          average number of visits to service center k ('V(k) >= 0').

     'Z'
          external delay ("think time", 'Z >= 0'); default 0.

     *OUTPUTS*

     'U(k)'
          utilization of service center k.  The utilization is defined
          as the probability that service center k is not empty, that
          is, U_k = 1-\pi_k(0) where \pi_k(0) is the steady-state
          probability that there are 0 jobs at service center k.

     'R(k)'
          response time on service center k.

     'Q(k)'
          average number of requests in service center k.

     'X(k)'
          throughput of service center k.

          Note: In presence of load-dependent servers, the MVA algorithm
          is known to be numerically unstable.  Generally the problem
          manifests itself as negative response times or utilization.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Mean Value Analysis algorithm for closed, single class queueing networks
with K 



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
qncspb


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1072
 -- Function File: [XL, XU, RL, RU] = qncspb (N, D )
 -- Function File: [XL, XU, RL, RU] = qncspb (N, S, V )
 -- Function File: [XL, XU, RL, RU] = qncspb (N, S, V, M )
 -- Function File: [XL, XU, RL, RU] = qncspb (N, S, V, M, Z )

     Compute PB Bounds (C. H. Hsieh and S. Lam, 1987) for single-class,
     closed networks with K service centers.

     *INPUTS*

     ''
          number of requests in the system (scalar, 'N > 0').

     'D(k)'
          service demand of service center k ('D(k) >= 0').

     'S(k)'
          mean service time at center k ('S(k) >= 0').

     'V(k)'
          visit ratio to center k ('V(k) >= 0').

     'M(k)'
          number of servers at center k.  This function only supports
          M/M/1 queues, therefore M must be 'ones(size(S))'.

     'Z'
          external delay (think time, 'Z >= 0').  Default 0.

     *OUTPUTS*

     'XL'
     'XU'
          Lower and upper bounds on the system throughput.

     'RL'
     'RU'
          Lower and upper bounds on the system response time.

     See also: qncsaba, qbcsbsb, qncsgb.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
Compute PB Bounds (C.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
qncsvisits


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 951
 -- Function File: V = qncsvisits (P)
 -- Function File: V = qncsvisits (P, R)

     Compute the mean number of visits to the service centers of a
     single class, closed network with K service centers.

     *INPUTS*

     'P(i,j)'
          probability that a request which completed service at center i
          is routed to center j (K \times K matrix).  For closed
          networks it must hold that 'sum(P,2)==1'.  The routing graph
          must be strongly connected, meaning that each node must be
          reachable from every other node.

     'R'
          Index of the reference station, r \in {1, ..., K}; Default
          'R=1'.  The traffic equations are solved by imposing the
          condition 'V(r) = 1'.  A request returning to the reference
          station completes its activity cycle.

     *OUTPUTS*

     'V(k)'
          average number of visits to service center k, assuming r as
          the reference station.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute the mean number of visits to the service centers of a single
class, clos



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
qnjackson


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 262
 -- Function File: [U, R, Q, X] = qnjackson (LAMBDA, S, P )
 -- Function File: [U, R, Q, X] = qnjackson (LAMBDA, S, P, M )
 -- Function File: PR = qnjackson (LAMBDA, S, P, M, K)

     This function is deprecated.  Please use 'qnos' instead.

     See also: qnos.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
qnmarkov


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3621
 -- Function File: [U, R, Q, X] = qnmarkov (LAMBDA, S, C, P)
 -- Function File: [U, R, Q, X] = qnmarkov (LAMBDA, S, C, P, M)
 -- Function File: [U, R, Q, X] = qnmarkov (N, S, C, P)
 -- Function File: [U, R, Q, X] = qnmarkov (N, S, C, P, M)

     Compute utilization, response time, average queue length and
     throughput for open or closed queueing networks with finite
     capacity.  Blocking type is Repetitive-Service (RS). This function
     explicitly generates and solve the underlying Markov chain, and
     thus might require a large amount of memory.

     More specifically, networks which can me analyzed by this function
     have the following properties:

        * There exists only a single class of customers.

        * The network has K service centers.  Center k has m_k > 0
          servers, and has a total (finite) capacity of C_k \geq m_k
          which includes both buffer space and servers.  The buffer
          space at service center k is therefore C_k - m_k.

        * The network can be open, with external arrival rate to center
          k equal to \lambda_k, or closed with fixed population size N.
          For closed networks, the population size N must be strictly
          less than the network capacity: N < \sum_i C_i.

        * Average service times are load-independent.

        * P_{i, j} is the probability that requests completing execution
          at center i are transferred to center j, i \neq j.  For open
          networks, a request may leave the system from any node i with
          probability 1-\sum_j P_{i, j}.

        * Blocking type is Repetitive-Service (RS). Service center j is
          _saturated_ if the number of requests is equal to its capacity
          C_j.  Under the RS blocking discipline, a request completing
          service at center i which is being transferred to a saturated
          server j is put back at the end of the queue of i and will
          receive service again.  Center i then processes the next
          request in queue.  External arrivals to a saturated servers
          are dropped.

     *INPUTS*

     'LAMBDA(k)'
     'N'
          If the first argument is a vector LAMBDA, it is considered to
          be the external arrival rate 'LAMBDA(k) >= 0' to service
          center k of an open network.  If the first argument is a
          scalar, it is considered as the population size N of a closed
          network; in this case N must be strictly less than the network
          capacity: 'N < sum(C)'.

     'S(k)'
          average service time at service center k

     'C(k)'
          capacity of service center k.  The capacity includes both the
          buffer and server space 'M(k)'.  Thus the buffer space is
          'C(k)-M(k)'.

     'P(i,j)'
          transition probability from service center i to service center
          j.

     'M(k)'
          number of servers at service center k.  Note that 'M(k) >=
          C(k)' for each K.  If M is omitted, all service centers are
          assumed to have a single server ('M(k) = 1' for all k).

     *OUTPUTS*

     'U(k)'
          center k utilization.

     'R(k)'
          response time on service center k.

     'Q(k)'
          average number of customers in the service center k,
          _including_ the request in service.

     'X(k)'
          throughput of service center k.

          Note: The space complexity of this implementation is
          O(\prod_{k=1}^K (C_k + 1)^2).  The time complexity is
          dominated by the time needed to solve a linear system with
          \prod_{k=1}^K (C_k + 1) unknowns.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute utilization, response time, average queue length and throughput
for open



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
qnmg1


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 151
 -- Function File: [U, R, Q, X, P0] = qnmg1 (LAMBDA, XAVG, X2ND)

     This function is deprecated.  Please use 'qsmg1' instead.

     See also: qsmg1.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
qnmh1


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 150
 -- Function File: [U, R, Q, X, P0] = qnmh1 (LAMBDA, MU, ALPHA)

     This function is deprecated.  Please use 'qsmh1' instead.

     See also: qsmh1.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
qnmix


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2066
 -- Function File: [U, R, Q, X] = qnmix (LAMBDA, N, S, V, M)

     Mean Value Analysis for mixed queueing networks.  The network
     consists of K service centers (single-server or delay centers) and
     C independent customer chains.  Both open and closed chains are
     possible.  LAMBDA is the vector of per-chain arrival rates (open
     classes); N is the vector of populations for closed chains.

          Note: In this implementation class switching is *not* allowed.
          Each customer class _must_ correspond to an independent chain.

     If the network is made of open or closed classes only, then this
     function calls 'qnom' or 'qncmmva' respectively, and prints a
     warning message.

     *INPUTS*

     'LAMBDA(c)'
     'N(c)'
          For each customer chain c:

             * if c is a closed chain, then 'N(c)>0' is the number of
               class c requests and 'LAMBDA(c)' must be zero;

             * If c is an open chain, 'LAMBDA(c)>0' is the arrival rate
               of class c requests and 'N(c)' must be zero;

          In other words, for each class c the following must hold:

                (LAMBDA(c)>0 && N(c)==0) || (LAMBDA(c)==0 && N(c)>0)

     'S(c,k)'
          mean class c service time at center k, 'S(c,k) >= 0'.  For
          FCFS nodes, service times must be class-independent.

     'V(c,k)'
          average number of visits of class c customers to center k
          ('V(c,k) >= 0').

     'M(k)'
          number of servers at center k.  Only single-server ('M(k)==1')
          or IS (Infinite Server) nodes ('M(k)<1') are supported.  If
          omitted, each center is assumed to be of type M/M/1-FCFS.
          Queueing discipline for single-server nodes can be FCFS, PS or
          LCFS-PR.

     *OUTPUTS*

     'U(c,k)'
          class c utilization at center k.

     'R(c,k)'
          class c response time at center k.

     'Q(c,k)'
          average number of class c requests at center k.

     'X(c,k)'
          class c throughput at center k.

     See also: qncmmva, qncm.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Mean Value Analysis for mixed queueing networks.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
qnmknode


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1743
 -- Function File: Q = qnmknode ("M/M/M-FCFS", S)
 -- Function File: Q = qnmknode ("M/M/M-FCFS", S, M)
 -- Function File: Q = qnmknode ("M/M/1-LCFS-PR", S)
 -- Function File: Q = qnmknode ("-/G/1-PS", S)
 -- Function File: Q = qnmknode ("-/G/1-PS", S, S2)
 -- Function File: Q = qnmknode ("-/G/INF", S)
 -- Function File: Q = qnmknode ("-/G/INF", S, S2)

     Creates a node; this function can be used together with 'qnsolve'.
     It is possible to create either single-class nodes (where there is
     only one customer class), or multiple-class nodes (where the
     service time is given per-class).  Furthermore, it is possible to
     specify load-dependent service times.  String literals are
     case-insensitive, so for example "-/G/INF", "-/G/INF" and "-/G/INF"
     are all equivalent.

     *INPUTS*

     S
          Mean service time.

             * If S is a scalar, it is assumed to be a load-independent,
               class-independent service time.

             * If S is a column vector, then 'S(c)' is assumed to the
               the load-independent service time for class c customers.

             * If S is a row vector, then 'S(n)' is assumed to be the
               class-independent service time at the node, when there
               are n requests.

             * Finally, if S is a two-dimensional matrix, then 'S(c,n)'
               is assumed to be the class c service time when there are
               n requests at the node.

     M
          Number of identical servers at the node.  Default is 'M=1'.

     S2
          Squared coefficient of variation for the service time.
          Default is 1.0.

     The returned struct Q should be considered opaque to the client.

     See also: qnsolve.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
Creates a node; this function can be used together with 'qnsolve'.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
qnmm1


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 143
 -- Function File: [U, R, Q, X, P0] = qnmm1 (LAMBDA, MU)

     This function is deprecated.  Please use 'qsmm1' instead.

     See also: qsmm1.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
qnmm1k


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 146
 -- Function File: [U, R, Q, X, P0, PK] = qnmm1k (LAMBDA, MU, K)

     This function is deprecated.  Use 'qsmm1k' instead.

     See also: qsmm1k.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
qnmminf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 149
 -- Function File: [U, R, Q, X, P0] = qnmminf (LAMBDA, MU)

     This function is deprecated.  Please use 'qsmminf' instead.

     See also: qsmminf.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
qnmmm


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 211
 -- Function File: [U, R, Q, X, P0, PM] = qnmmm (LAMBDA, MU)
 -- Function File: [U, R, Q, X, P0, PM] = qnmmm (LAMBDA, MU, M)

     This function is deprecated.  Please use 'qsmmm' instead.

     See also: qsmmm.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
qnmmmk


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 156
 -- Function File: [U, R, Q, X, P0, PK] = qnmmmk (LAMBDA, MU, M, K)

     This function is deprecated.  Please use 'qsmmmk' instead.

     See also: qsmmmk.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
qnmvablo


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 152
 -- Function File: [U, R, Q, X] = qnmvablo (N, S, M, P)

     This function is deprecated.  Please use 'qncsmvablo' instead.

     See also: qncsmvablo.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
qnmvapop


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 128
 -- Function File: H = qnmvapop (N)

     This function is deprecated.  Please use 'qncmnpop' instead.

     See also: qncmnpop.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
qnom


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2986
 -- Function File: [U, R, Q, X] = qnom (LAMBDA, S, V)
 -- Function File: [U, R, Q, X] = qnom (LAMBDA, S, V, M)
 -- Function File: [U, R, Q, X] = qnom (LAMBDA, S, P)
 -- Function File: [U, R, Q, X] = qnom (LAMBDA, S, P, M)

     Exact analysis of open, multiple-class BCMP networks.  The network
     can be made of _single-server_ queueing centers (FCFS, LCFS-PR or
     PS) or delay centers (IS). This function assumes a network with K
     service centers and C customer classes.

          Note: If this function is called specifying the visit ratios
          V, class switching is *not* allowed.  If this function is
          called specifying the routing probability matrix P, then class
          switching *is* allowed; however, in this case all nodes are
          restricted to be fixed rate servers or delay centers:
          multiple-server and general load-dependent centers are not
          supported.  Note that the meaning of parameter LAMBDA is
          different from one case to the other (see below).

     *INPUTS*

     'LAMBDA(c)'
          If this function is invoked as 'qnom(lambda, S, V, ...)', then
          'LAMBDA(c)' is the external arrival rate of class c customers
          ('LAMBDA(c) >= 0').  If this function is invoked as
          'qnom(lambda, S, P, ...)', then 'LAMBDA(c,k)' is the external
          arrival rate of class c customers at center k ('LAMBDA(c,k) >=
          0').

     'S(c,k)'
          mean service time of class c customers on the service center k
          ('S(c,k)>0').  For FCFS nodes, mean service times must be
          class-independent.

     'V(c,k)'
          visit ratio of class c customers to service center k ('V(c,k)
          >= 0 ').  *If you pass this argument, class switching is not
          allowed*

     'P(r,i,s,j)'
          probability that a class r job completing service at center i
          is routed to center j as a class s job.  *If you pass argument
          P, class switching is allowed*; however, all servers must be
          fixed-rate or infinite-server nodes ('M(k) <= 1' for all k).

     'M(k)'
          number of servers at center k.  If 'M(k) < 1', enter k is a
          delay center (IS); otherwise it is a regular queueing center
          with 'M(k)' servers.  Default is 'M(k) = 1' for all k.

     *OUTPUTS*

     'U(c,k)'
          If k is a queueing center, then 'U(c,k)' is the class c
          utilization of center k.  If k is an IS node, then 'U(c,k)' is
          the class c _traffic intensity_ defined as 'X(c,k)*S(c,k)'.

     'R(c,k)'
          class c response time at center k.  The system response time
          for class c requests can be computed as 'dot(R, V, 2)'.

     'Q(c,k)'
          average number of class c requests at center k.  The average
          number of class c requests in the system QC can be computed as
          'Qc = sum(Q, 2)'

     'X(c,k)'
          class c throughput at center k.

     See also: qnopen,qnos,qnomvisits.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Exact analysis of open, multiple-class BCMP networks.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
qnomaba


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1199
 -- Function File: [XL, XU, RL, RU] = qnomaba (LAMBDA, D)
 -- Function File: [XL, XU, RL, RL] = qnomaba (LAMBDA, S, V)

     Compute Asymptotic Bounds for open, multiclass networks with K
     service centers and C customer classes.

     *INPUTS*

     'LAMBDA(c)'
          class c arrival rate to the system (vector of length C,
          'LAMBDA(c) > 0').

     'D(c, k)'
          class c service demand at center k (C \times K matrix, 'D(c,
          k) >= 0').

     'S(c, k)'
          mean service time of class c requests at center k (C \times K
          matrix, 'S(c, k) >= 0').

     'V(c, k)'
          mean number of visits of class c requests at center k (C
          \times K matrix, 'V(c, k) >= 0').

     *OUTPUTS*

     'XL(c)'
     'XU(c)'
          lower and upper bounds of class c throughput.  'XL(c)' is
          always 0 since there can be no lower bound on the throughput
          of open networks (vector of length C).

     'RL(c)'
     'RU(c)'
          lower and upper bounds of class c response time.  'RU(c)' is
          always '+inf' since there can be no upper bound on the
          response time of open networks (vector of length C).

     See also: qnombsb.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute Asymptotic Bounds for open, multiclass networks with K service
centers a



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
qnomvisits


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 562
 -- Function File: V = qnomvisits (P, LAMBDA)

     Compute the visit ratios to the service centers of an open
     multiclass network with K service centers and C customer classes.

     *INPUTS*

     'P(r,i,s,j)'
          probability that a class r request which completed service at
          center i is routed to center j as a class s request.  Class
          switching is supported.

     'LAMBDA(r,i)'
          external arrival rate of class r requests to center i.

     *OUTPUTS*

     'V(r,i)'
          visit ratio of class r requests at center i.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute the visit ratios to the service centers of an open multiclass
network wi



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
qnopen


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 440
 -- Function File: [U, R, Q, X] = qnopen (LAMBDA, S, V, ...)

     Compute utilization, response time, average number of requests in
     the system, and throughput for open queueing networks.  If LAMBDA
     is a scalar, the network is considered a single-class QN and is
     solved using 'qnopensingle'.  If LAMBDA is a vector, the network is
     considered as a multiclass QN and solved using 'qnopenmulti'.

     See also: qnos, qnom.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute utilization, response time, average number of requests in the
system, an



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
qnopenab


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 152
 -- Function File: [XL, XU, RL, RU] = qnopenab (LAMBDA, ... )

     This function is deprecated.  Please use 'qnosaba' instead.

     See also: qnosaba.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
qnopenbsb


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 148
 -- Function File: [XU, RL, RU] = qnopenbsb (LAMBDA, ...)

     This function is deprecated.  Please use 'qnosbsb' instead.

     See also: qnosbsb.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
qnopenmulti


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 209
 -- Function File: [U, R, Q, X] = qnopenmulti (LAMBDA, S, V)
 -- Function File: [U, R, Q, X] = qnopenmulti (LAMBDA, S, V, M)

     This function is deprecated.  Please use 'qnom' instead.

     See also: qnom.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
qnopensingle


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 211
 -- Function File: [U, R, Q, X] = qnopensingle (LAMBDA, S, V)
 -- Function File: [U, R, Q, X] = qnopensingle (LAMBDA, S, V, M)

     This function is deprecated.  Please use 'qnos' instead.

     See also: qnos.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
This function is deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
qnos


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1480
 -- Function File: [U, R, Q, X] = qnos (LAMBDA, S, V)
 -- Function File: [U, R, Q, X] = qnos (LAMBDA, S, V, M)

     Analyze open, single class BCMP queueing networks with K service
     centers.

     This function works for a subset of BCMP single-class open networks
     satisfying the following properties:

        * The allowed service disciplines at network nodes are: FCFS,
          PS, LCFS-PR, IS (infinite server);

        * Service times are exponentially distributed and
          load-independent;

        * Center k can consist of 'M(k) >= 1' identical servers.

        * Routing is load-independent

     *INPUTS*

     'LAMBDA'
          Overall external arrival rate ('LAMBDA>0').

     'S(k)'
          average service time at center k ('S(k)>0').

     'V(k)'
          average number of visits to center k ('V(k) >= 0').

     'M(k)'
          number of servers at center i.  If 'M(k) < 1', enter k is a
          delay center (IS); otherwise it is a regular queueing center
          with 'M(k)' servers.  Default is 'M(k) = 1' for all k.

     *OUTPUTS*

     'U(k)'
          If k is a queueing center, 'U(k)' is the utilization of center
          k.  If k is an IS node, then 'U(k)' is the _traffic intensity_
          defined as 'X(k)*S(k)'.

     'R(k)'
          center k average response time.

     'Q(k)'
          average number of requests at center k.

     'X(k)'
          center k throughput.

     See also: qnopen,qnclosed,qnosvisits.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 73
Analyze open, single class BCMP queueing networks with K service
centers.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
qnosaba


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1263
 -- Function File: [XL, XU, RL, RU] = qnosaba (LAMBDA, D)
 -- Function File: [XL, XU, RL, RU] = qnosaba (LAMBDA, S, V)
 -- Function File: [XL, XU, RL, RU] = qnosaba (LAMBDA, S, V, M)

     Compute Asymptotic Bounds for open, single-class networks with K
     service centers.

     *INPUTS*

     'LAMBDA'
          Arrival rate of requests (scalar, 'LAMBDA >= 0').

     'D(k)'
          service demand at center k.  (vector of length K, 'D(k) >=
          0').

     'S(k)'
          mean service time at center k.  (vector of length K, 'S(k) >=
          0').

     'V(k)'
          mean number of visits to center k.  (vector of length K, 'V(k)
          >= 0').

     'M(k)'
          number of servers at center k.  This function only supports
          M/M/1 queues, therefore M must be 'ones(size(S))'.

     *OUTPUTS*

     'XL'
     'XU'
          Lower and upper bounds on the system throughput.  XL is always
          set to 0 since there can be no lower bound on the throughput
          of open networks (scalar).

     'RL'
     'RU'
          Lower and upper bounds on the system response time.  RU is
          always set to '+inf' since there can be no upper bound on the
          throughput of open networks (scalar).

     See also: qnomaba.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute Asymptotic Bounds for open, single-class networks with K service
centers



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
qnosbsb


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 971
 -- Function File: [XL, XU, RL, RU] = qnosbsb (LAMBDA, D)
 -- Function File: [XL, XU, RL, RU] = qnosbsb (LAMBDA, S, V)

     Compute Balanced System Bounds for single-class, open networks with
     K service centers.

     *INPUTS*

     'LAMBDA'
          overall arrival rate to the system (scalar, 'LAMBDA >= 0').

     'D(k)'
          service demand at center k ('D(k) >= 0').

     'S(k)'
          service time at center k ('S(k) >= 0').

     'V(k)'
          mean number of visits at center k ('V(k) >= 0').

     'M(k)'
          number of servers at center k.  This function only supports
          M/M/1 queues, therefore M must be 'ones(size(S))'.

     *OUTPUTS*

     'XL'
     'XU'
          Lower and upper bounds on the system throughput.  XL is always
          set to 0, since there can be no lower bound on open networks
          throughput.

     'RL'
     'RU'
          Lower and upper bounds on the system response time.

     See also: qnosaba.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute Balanced System Bounds for single-class, open networks with K
service ce



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
qnosvisits


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 483
 -- Function File: V = qnosvisits (P, LAMBDA)

     Compute the average number of visits to the service centers of a
     single class open Queueing Network with K service centers.

     *INPUTS*

     'P(i,j)'
          is the probability that a request which completed service at
          center i is routed to center j (K \times K matrix).

     'LAMBDA(k)'
          external arrival rate to center k.

     *OUTPUTS*

     'V(k)'
          average number of visits to server k.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute the average number of visits to the service centers of a single
class op



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
qnsolve


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2442
 -- Function File: [U, R, Q, X] = qnsolve ("CLOSED", N, QQ, V)
 -- Function File: [U, R, Q, X] = qnsolve ("CLOSED", N, QQ, V, Z)
 -- Function File: [U, R, Q, X] = qnsolve ("OPEN", LAMBDA, QQ, V)
 -- Function File: [U, R, Q, X] = qnsolve ("MIXED", LAMBDA, N, QQ, V)

     High-level function for analyzing QN models.

        * For *closed* networks, the following server types are
          supported: M/M/m-FCFS, -/G/\infty, -/G/1-LCFS-PR, -/G/1-PS and
          load-dependent variants.

        * For *open* networks, the following server types are supported:
          M/M/m-FCFS, -/G/\infty and -/G/1-PS. General load-dependent
          nodes are _not_ supported.  Multiclass open networks do not
          support multiple server M/M/m nodes, but only single server
          M/M/1-FCFS.

        * For *mixed* networks, the following server types are
          supported: M/M/1-FCFS, -/G/\infty and -/G/1-PS. General
          load-dependent nodes are _not_ supported.

     *INPUTS*

     'N'
     'N(c)'
          Number of requests in the system for closed networks.  For
          single-class networks, N must be a scalar.  For multiclass
          networks, 'N(c)' is the population size of closed class c.

     'LAMBDA'
     'LAMBDA(c)'
          External arrival rate (scalar) for open networks.  For
          single-class networks, LAMBDA must be a scalar.  For
          multiclass networks, 'LAMBDA(c)' is the class c overall
          arrival rate.

     'QQ{i}'
          List of queues in the network.  This must be a cell array with
          N elements, such that 'QQ{i}' is a struct produced by the
          'qnmknode' function.

     'Z'
          External delay ("think time") for closed networks.  Default 0.

     *OUTPUTS*

     'U(k)'
          If k is a FCFS node, then 'U(k)' is the utilization of service
          center k.  If k is an IS node, then 'U(k)' is the _traffic
          intensity_ defined as 'X(k)*S(k)'.

     'R(k)'
          average response time of service center k.

     'Q(k)'
          average number of customers in service center k.

     'X(k)'
          throughput of service center k.

     Note that for multiclass networks, the computed results are
     per-class utilization, response time, number of customers and
     throughput: 'U(c,k)', 'R(c,k)', 'Q(c,k)', 'X(c,k)'.

     String literals are case-insensitive, so "CLOSED", "CLOSED" and
     "CLOSED" are all equivalent.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
High-level function for analyzing QN models.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
qnvisits


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2077
 -- Function File: [V CH] = qnvisits (P)
 -- Function File: V = qnvisits (P, LAMBDA)

     Compute the average number of visits to the service centers of a
     single class, open or closed Queueing Network with N service
     centers.

     This function is deprecated.  Please use one of 'qncsvisits',
     'qncmvisits', 'qnosvisits' or 'qnomvisits' instead.

     *INPUTS*

     'P(i,j)'
     'P(r,i,s,j)'
          Routing probability matrix.  For single class networks,
          'P(i,j)' is the probability that a request which completed
          service at center i is routed to center j.  For closed
          networks it must hold that 'sum(P,2)==1'.  The routing graph
          myst be strongly connected, meaning that it must be possible
          to eventually reach each node starting from each node.  For
          multiple class networks, 'P(r,i,s,j)' is the probability that
          a class r request which completed service at center i is
          routed to center j as a class s request.  Class switching is
          supported.

     'LAMBDA(i)'
     'LAMBDA(r,i)'
          (open networks only) vector of external arrivals.  For single
          class networks, 'LAMBDA(i)' is the external arrival rate to
          center i.  For multiple class networks, 'LAMBDA(r,i)' is the
          arrival rate of class r requests to center i.  If this
          function is called with a single argument, the network is
          assumed to be closed.

     *OUTPUTS*

     'V(i)'
     'V(r,i)'
          For single class networks, 'V(i)' is the average number of
          visits to server i, assuming center 1 as the reference station
          (i.e., 'V(1) = 1').  For multiple class networks, 'V(r,i)' is
          the number of visits of class r requests at center i.

     'CH(c)'
          (For closed networks only).  'CH(c)' is the chain number that
          class c belongs to.  Different classes can belong to the same
          chain.  Chains are numbered sequentially starting from 1 (1,
          2, ...).  The total number of chains is 'max(CH)'.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute the average number of visits to the service centers of a single
class, o



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
qsammm


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1000
 -- Function File: [U, R, Q, X] = qsammm (LAMBDA, MU)

     Compute _approximate_ utilization, response time, average number of
     requests in service and throughput for an asymmetric M/M/m queue.
     In this system there are m different servers connected to a single
     queue.  Each server has its own (possibly different) service rate.
     If there is more than one server available, requests are routed to
     a randomly-chosen one.

     *INPUTS*

     LAMBDA
          Arrival rate ('LAMBDA>0').

     MU
          'MU(i)' is the service rate of server i, 1 <= i <= m.  The
          system must be ergodic ('LAMBDA < sum(MU)').

     *OUTPUTS*

     U
          Approximate service center utilization, U = \lambda / ( \sum_i
          \mu_i ).

     R
          Approximate service center response time

     Q
          Approximate number of requests in the system

     X
          Approximate system throughput.  If the system is ergodic, 'X =
          LAMBDA'

     See also: qsmmm.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute _approximate_ utilization, response time, average number of
requests in 



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
qsmg1


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 983
 -- Function File: [U, R, Q, X, P0] = qsmg1 (LAMBDA, XAVG, X2ND)

     Compute utilization, response time, average number of requests and
     throughput for a M/G/1 system.  The service time distribution is
     described by its mean XAVG, and by its second moment X2ND.  The
     computations are based on results from L. Kleinrock, 'Queuing
     Systems', Wiley, Vol 2, and Pollaczek-Khinchine formula.

     *INPUTS*

     LAMBDA
          Arrival rate.

     XAVG
          Average service time

     X2ND
          Second moment of service time distribution

     *OUTPUTS*

     U
          Service center utilization

     R
          Service center response time

     Q
          Average number of requests in the system

     X
          Service center throughput

     P0
          probability that there is not any request at system

     LAMBDA, XAVG, T2ND can be vectors of the same size.  In this case,
     the results will be vectors as well.

     See also: qsmh1.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute utilization, response time, average number of requests and
throughput fo



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
qsmh1


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1146
 -- Function File: [U, R, Q, X, P0] = qsmh1 (LAMBDA, MU, ALPHA)

     Compute utilization, response time, average number of requests and
     throughput for a M/H_m/1 system.  In this system, the customer
     service times have hyper-exponential distribution:

                  ___ m
                  \
           B(x) =  >  alpha(j) * (1-exp(-mu(j)*x))   x>0
                  /__
                      j=1

     where \alpha_j is the probability that the request is served at
     phase j, in which case the average service rate is \mu_j.  After
     completing service at phase j, for some j, the request exits the
     system.

     *INPUTS*

     LAMBDA
          Arrival rate.

     MU
          'MU(j)' is the phase j service rate.  The total number of
          phases m is 'length(MU)'.

     ALPHA
          'ALPHA(j)' is the probability that a request is served at
          phase j.  ALPHA must have the same size as MU.

     *OUTPUTS*

     U
          Service center utilization

     R
          Service center response time

     Q
          Average number of requests in the system

     X
          Service center throughput


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute utilization, response time, average number of requests and
throughput fo



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
qsmm1


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 796
 -- Function File: [U, R, Q, X, P0] = qsmm1 (LAMBDA, MU)

     Compute utilization, response time, average number of requests and
     throughput for a M/M/1 queue.

     *INPUTS*

     LAMBDA
          Arrival rate ('LAMBDA >= 0').

     MU
          Service rate ('MU > LAMBDA').

     *OUTPUTS*

     U
          Server utilization

     R
          Server response time

     Q
          Average number of requests in the system

     X
          Server throughput.  If the system is ergodic ('MU > LAMBDA'),
          we always have 'X = LAMBDA'

     P0
          Steady-state probability that there are no requests in the
          system.

     LAMBDA and MU can be vectors of the same size.  In this case, the
     results will be vectors as well.

     See also: qsmmm, qsmminf, qsmmmk.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute utilization, response time, average number of requests and
throughput fo



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
qsmm1k


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1135
 -- Function File: [U, R, Q, X, P0, PK] = qsmm1k (LAMBDA, MU, K)

     Compute utilization, response time, average number of requests and
     throughput for a M/M/1/K finite capacity system.  In a M/M/1/K
     queue there is a single server; the maximum number of requests in
     the system is K, and the maximum queue length is K-1.

     *INPUTS*

     LAMBDA
          Arrival rate ('LAMBDA>0').

     MU
          Service rate ('MU>0').

     K
          Maximum number of requests allowed in the system ('K >= 1').

     *OUTPUTS*

     U
          Service center utilization, which is defined as 'U = 1-P0'

     R
          Service center response time

     Q
          Average number of requests in the system

     X
          Service center throughput

     P0
          Steady-state probability that there are no requests in the
          system

     PK
          Steady-state probability that there are K requests in the
          system (i.e., that the system is full)

     LAMBDA, MU and K can be vectors of the same size.  In this case,
     the results will be vectors as well.

     See also: qsmm1,qsmminf,qsmmm.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute utilization, response time, average number of requests and
throughput fo



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
qsmminf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1123
 -- Function File: [U, R, Q, X, P0] = qsmminf (LAMBDA, MU)

     Compute utilization, response time, average number of requests and
     throughput for a M/M/\infty queue.

     The M/M/\infty system has an infinite number of identical servers;
     this kind of system is always stable for every arrival and service
     rates.

     *INPUTS*

     LAMBDA
          Arrival rate ('LAMBDA>0').

     MU
          Service rate ('MU>0').

     *OUTPUTS*

     U
          Traffic intensity (defined as \lambda/\mu).  Note that this is
          different from the utilization, which in the case of
          M/M/\infty centers is always zero.

     R
          Service center response time.

     Q
          Average number of requests in the system (which is equal to
          the traffic intensity \lambda/\mu).

     X
          Throughput (which is always equal to 'X = LAMBDA').

     P0
          Steady-state probability that there are no requests in the
          system

     LAMBDA and MU can be vectors of the same size.  In this case, the
     results will be vectors as well.

     See also: qsmm1,qsmmm,qsmmmk.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute utilization, response time, average number of requests and
throughput fo



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
qsmmm


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1192
 -- Function File: [U, R, Q, X, P0, PM] = qsmmm (LAMBDA, MU)
 -- Function File: [U, R, Q, X, P0, PM] = qsmmm (LAMBDA, MU, M)

     Compute utilization, response time, average number of requests in
     service and throughput for a M/M/m queue, a queueing system with m
     identical servers connected to a single FCFS queue.

     *INPUTS*

     LAMBDA
          Arrival rate ('LAMBDA>0').

     MU
          Service rate ('MU>LAMBDA').

     M
          Number of servers ('M >= 1').  If omitted, it is assumed
          'M=1'.

     *OUTPUTS*

     U
          Service center utilization, U = \lambda / (m \mu).

     R
          Service center response time

     Q
          Average number of requests in the system

     X
          Service center throughput.  If the system is ergodic, we will
          always have 'X = LAMBDA'

     P0
          Steady-state probability that there are 0 requests in the
          system

     PM
          Steady-state probability that an arriving request has to wait
          in the queue

     LAMBDA, MU and M can be vectors of the same size.  In this case,
     the results will be vectors as well.

     See also: erlangc,qsmm1,qsmminf,qsmmmk.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute utilization, response time, average number of requests in
service and th



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
qsmmmk


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1369
 -- Function File: [U, R, Q, X, P0, PK] = qsmmmk (LAMBDA, MU, M, K)

     Compute utilization, response time, average number of requests and
     throughput for a M/M/m/K finite capacity system.  In a M/M/m/K
     system there are m \geq 1 identical service centers sharing a
     fixed-capacity queue.  At any time, at most K >= m requests can be
     in the system.  The maximum queue length is K-m.  This function
     generates and solves the underlying CTMC.

     *INPUTS*

     LAMBDA
          Arrival rate ('LAMBDA>0').

     MU
          Service rate ('MU>0').

     M
          Number of servers ('M >= 1').

     K
          Maximum number of requests allowed in the system, including
          those inside the service centers ('K >= M').

     *OUTPUTS*

     U
          Service center utilization

     R
          Service center response time

     Q
          Average number of requests in the system

     X
          Service center throughput

     P0
          Steady-state probability that there are no requests in the
          system.

     PK
          Steady-state probability that there are K requests in the
          system (i.e., probability that the system is full).

     LAMBDA, MU, M and K can be either scalars, or vectors of the same
     size.  In this case, the results will be vectors as well.

     See also: qsmm1,qsmminf,qsmmm.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute utilization, response time, average number of requests and
throughput fo





