Package jline.api.pfqn.ld

Class Pfqn_explicit_ld

java.lang.Object
jline.api.pfqn.ld.Pfqn_explicit_ld
public final class Pfqn_explicit_ld extends Object

  • Method Details

    • pfqn_explicit_ld

      public static Pfqn_explicit_ld.Result pfqn_explicit_ld(Matrix L, Matrix N, Matrix mu, double tol, String method, double maxloss)
      Explicit closed-form normalizing constant of a multiclass limited load-dependent network.

      Load-dependent counterpart of Pfqn_explicit. It evaluates the same divided-difference form of Casale (SIGMETRICS 2017), Corollary 3.2, 

         G(N) = sum_{0<=t<=N} (-1)^(|N|-|t|)/(N_1!...N_R!) prod_r C(N_r,t_r) h_t(|N|)
      but substitutes for the single-class constant h_t(|N|) the LIMITED LOAD-DEPENDENT closed form of Casale, Harrison and Ong (Perform. Eval. 2021), Theorem 1, Eq. (8), 
         h_theta(N) = sum_{0<=v<s} g_sigma(N-|v|) prod_k phi_k(v_k)
   phi_k(v_k) = theta_k^v_k / prod_{t=1..v_k} alpha_k(t) * (1 - alpha_k(v_k)/alpha_k(s_k))
      at the induced demands theta_k(t) = sum_r t_r L(k,r). Here alpha_k(.) = mu(k,.) is the load-dependent scaling of station k, s_k the population past which it stays constant, sigma_k = theta_k/alpha_k(s_k) the SCALED demands, and g_sigma the FIXED-RATE single-class constant at those scaled demands, which is exactly what Pfqn_explicit evaluates in closed form (Eqs. 15 and 16). The result is therefore explicit throughout, with no recursion over population.

      Two conventions of Theorem 1 are not those of the equilibrium distribution and are easy to get wrong. alpha_k(0) is taken as ZERO inside the bracket of phi_k, so that phi_k(0) = 1, even though the state probabilities use alpha_k(0) = 1; and g_sigma(n) = 0 for n < 0, which caps the outer sum at |v| <= |N|. With alpha_k(n) = min(n,s_k) the expression collapses to Gordon's multi-server formula, Oper. Res. 38(5), 1990, Eq. (29), but unlike that one it needs neither a multi-server shape nor distinct scaled demands.

      LIMITED LOAD DEPENDENCE. Theorem 1 holds for any s_k with alpha_k(n) = alpha_k(s_k) for all n >= s_k, and a LARGER s_k is always admissible, so s_k is detected here as the smallest index whose value the tail of mu(k,:) repeats to within tol. A station whose rates never settle (an infinite server, mu(k,n) = n) gets s_k = |N|, which is still exact: populations above |N| do not occur, so redefining alpha_k there changes nothing. It is merely expensive, since the inner sum costs prod_k s_k terms, capped by |v| <= |N|. Think time is not admissible: a delay would have to enter g_sigma, whose closed form covers queues only.

      NUMERICS. Both sums alternate in sign with terms far larger than the result, so they are evaluated as signed log-sum-exps. phi_k is sign-definite when alpha_k increases, as a multi-server station does, and changes sign where alpha_k decreases, so a decreasing rate function costs digits in the inner sum too.

      SINGLE CLASS. At R=1 the divided difference is the identity, since h_theta(N) is homogeneous of degree N in theta exactly as in the fixed-rate case, so the outer sum is skipped and Theorem 1 is evaluated once at theta = L.

      Parameters:
      L - service demand matrix (M x R)
      N - population vector (1 x R)
      mu - load-dependent rate matrix (M x sum(N)), alpha_i(j) = mu(i,j-1); null for all ones
      tol - relative tolerance declaring two scaled demands redundant, and the rate tail constant
      method - "auto", "distinct" (force Eq. 15) or "repeated" (force Eq. 16)
      maxloss - cancellation budget in decimal digits; a finite value turns the warnings into a silent REFUSAL (lG = NaN) once the budget is exceeded, for callers that hold a fallback; Double.POSITIVE_INFINITY keeps the warnings
      Returns:
      the constant, its logarithm, the expression used and the digits lost

    • pfqn_explicit_ld

      public static Pfqn_explicit_ld.Result pfqn_explicit_ld(Matrix L, Matrix N, Matrix mu)
      Overload with the documented defaults: machine precision, "auto", no budget.