Package jline.api.pfqn.ld

Class Pfqn_lld

java.lang.Object
jline.api.pfqn.ld.Pfqn_lld
public final class Pfqn_lld extends Object
Same recursion, same arithmetic and the same result as Pfqn_gld, but with the rate shift saturated at the limited load-dependence threshold, which makes the recursion's state space finite and lets it be memoised. This is what Pfqn_lldsingle does to Pfqn_gldsingle, one level up: there the rate offset is an index into a table, here it is the shift that Pfqn_mushift applies.

Pfqn_gld peels the last station and advances its rate lattice one job at a time, 

   g(m,n,j) = g(m-1,n,0) + sum_r L[m,r]/alpha_m(j+1) * g(m,n-e_r,j+1)
with j the number of shifts row m has taken, so that Pfqn_mushift's leading element is alpha_m(j+1). Once j >= s_m-1, where s_m is the population past which alpha_m stays constant, every remaining entry of the row is alpha_m(s_m) and a further shift LEAVES THE ROW UNCHANGED over the columns the recursion can still read. Saturating j at s_m-1 therefore returns the same value and makes the state (m, n, j) repeat, at which point one memo answers what Pfqn_gld recomputes down an exponential tree.

COST. The state space is M * prod_r(N_r+1) * max_k s_k, against Pfqn_gld's unmemoised recursion, which revisits the same states exponentially often. Without the saturation a memo would still be bounded, but by M * prod_r(N_r+1) * (|N|+1): the threshold is what replaces the population by the server count, exactly as in Pfqn_lldsingle.

Every terminal case of Pfqn_gld is delegated back to it on the materialised block, so the two agree to the last bit rather than to a tolerance.

  • Method Details

    • pfqn_lld

      public static Ret.pfqnNc pfqn_lld(Matrix L, Matrix N, Matrix mu, SolverOptions options)
      Normalizing constant of a multiclass limited load-dependent closed model.
      Parameters:
      L - demands at all stations
      N - number of jobs for each class
      mu - load-dependent scaling factors
      options - solver options
      Returns:
      normalizing constant (G) and its logarithm (lG)