Package jline.api.dpfqn

Class Dpfqn_nc

java.lang.Object
jline.api.dpfqn.Dpfqn_nc
public final class Dpfqn_nc extends Object
Buzen-style recursions for the discrete-time closed cycle of Bernoulli servers with state independent service probabilities.

Port of matlab/src/api/dpfqn/dpfqn_nc.m. With q_j = 1 - p_j the queue length vector has the product form of Daduna (2001), corollary 3.4,

   pi(n_1,...,n_J) = prod_j (q_j/p_j)^n_j (1/q_j)^{1{n_j>0}} / G(N,J)

whose extra factor on the busy nodes is what separates it from the continuous-time Gordon-Newell form: a homogeneous cycle is uniform on the state space in continuous time and is not here. G obeys proposition 3.18,

   G(k,j) = G(k,j-1) + (q_j/p_j) G(k-1,j) + G(k-1,j-1)

with G(0,j) = 1 and G(k,0) = 0 for k >= 1. Unlike the continuous-time convolution algorithm this recursion is not invariant to the numbering of the nodes. The arrival constants obey proposition 3.19,

   G1(k,J) = G(k-1,J-1) + (q_J/p_J) G1(k-1,J),   k >= 3

with G1(1,J) = 1 and G1(2,J) = q_1/p_1 + sum_{j>=2} 1/p_j. By lemma 7.3 the arrival constant is the same at every node, so one family suffices, and three consequences are what the discrete-time analyzer consumes:

   throughput per slot   X   = G1(N,J) / G(N,J)   (equal at every node)
   utilization           U_j = X / p_j
   tail probability      P(X_j >= k)
                         = (q_j/p_j)^k (1/q_j) G1(N-k+1,J) / G(N,J)

The last identity is corollary 3.20(a) with its index corrected: as printed there the right-hand side evaluates to P(X_j >= k+1). Corollary 3.20(c), which transfers the tail from node 1 to node j, holds for k >= 1 only; at k = 0 both tails are 1 while the stated ratio is q_1/q_j.

See Also:

  • Method Details

    • dpfqn_nc

      public static DpfqnNcResult dpfqn_nc(double[] p, int N)
      Parameters:
      p - per-slot service completion probabilities p_j in (0,1)
      N - number of customers cycling in the J nodes
      Returns:
      the time-stationary and arrival normalizing constants