Package jline.solvers.nc

Class SolverNC

java.lang.Object
jline.solvers.Solver
jline.solvers.NetworkSolver
jline.solvers.nc.SolverNC
Direct Known Subclasses:
NC
public class SolverNC extends NetworkSolver
Solver for Normalizing Constant (NC) method applied to closed queueing networks.

SolverNC implements the normalizing constant approach for computing exact performance measures of closed product-form queueing networks. The normalizing constant G(N) represents the partition function that ensures steady-state probabilities sum to one.

Key NC solver capabilities:

  • Exact normalizing constant computation
  • Convolution algorithm implementation
  • Load-dependent service station support
  • Cache-enabled queueing network analysis
  • Joint and marginal probability computation
  • State probability aggregation methods

The solver supports various computation methods including standard convolution, tree convolution, and specialized algorithms for cache networks and load-dependent stations. Results include exact performance metrics and state probabilities.

Since:
1.0
See Also:

  • Constructor Details

  • Method Details

    • supportsExactSensitivity

      public boolean supportsExactSensitivity()
      The normalizing-constant solver is exact on the same product-form class that pfqn_sens differentiates, so getSensitivityTable uses the analytic branch.
      Overrides:
      supportsExactSensitivity in class NetworkSolver
      Returns:
      true

    • hasRetrievalCache

      public static boolean hasRetrievalCache(NetworkStruct sn)
      True if the model contains a Cache equipped with a delayed-hit retrieval system.

    • defaultOptions

      public static SolverOptions defaultOptions()

    • getFeatureSet

      public static FeatureSet getFeatureSet()
      Returns the feature set supported by the NC solver
      Returns:
      - the feature set supported by the NC solver

    • getProb

      public Double getProb(Node node, Matrix state)

    • getProbAggr

      public Double getProbAggr(Node node, Matrix state_a)
      Get aggregated probability for a specific node and state
      Parameters:
      node - The node to compute probability for
      state_a - The aggregated state (optional, uses current state if null)
      Returns:
      The aggregated probability value

    • getProbAggr

      public Double getProbAggr(Node node)
      Get aggregated probability for a specific node using current state
      Parameters:
      node - The node to compute probability for
      Returns:
      The aggregated probability value

    • getProbMarg

      public Ret.ProbabilityResult getProbMarg(int ist, int jobclass, Matrix state_m)
      Marginal queue-length distribution at a station, routing the CLI's (station, class) call to the exact procomom/enumeration path in getProbMarg(Node). The class index is not used: NC returns the per-station total-jobs marginal.
      Overrides:
      getProbMarg in class NetworkSolver
      Parameters:
      ist - station index
      jobclass - class index (unused; marginal is over total jobs)
      state_m - optional state (unused)
      Returns:
      the exact marginal probability distribution

    • getProbMarg

      public Ret.ProbabilityResult getProbMarg(Node node)

    • getProbNormConstAggr

      public Ret.ProbabilityResult getProbNormConstAggr()
      Get the log normalization constant for aggregated probabilities
      Overrides:
      getProbNormConstAggr in class NetworkSolver
      Returns:
      The log normalization constant
      Throws:
      IllegalAccessException - if analysis fails

    • getProbSys

      public Ret.ProbabilityResult getProbSys()
      Get system-wide joint probability
      Overrides:
      getProbSys in class NetworkSolver
      Returns:
      The joint probability value

    • getProbSysAggr

      public Ret.ProbabilityResult getProbSysAggr()
      Get aggregated system-wide joint probability
      Overrides:
      getProbSysAggr in class NetworkSolver
      Returns:
      The aggregated joint probability value

    • getStruct

      public NetworkStruct getStruct()

    • setStruct

      public void setStruct(NetworkStruct sn)

    • runAnalyzer

      public void runAnalyzer() throws IllegalAccessException
      Description copied from class: Solver
      Executes the solver algorithm to analyze the model. This abstract method must be implemented by concrete solver classes.
      Specified by:
      runAnalyzer in class Solver
      Throws:
      IllegalAccessException - if access to required resources is denied

    • getNormalizingConstant

      public SolverNC.NormalizingConstantResult getNormalizingConstant() throws IllegalAccessException
      Get the normalizing constant and its logarithm
      Returns:
      NormalizingConstantResult containing the normalizing constant and its logarithm
      Throws:
      IllegalAccessException - if analysis fails

    • listValidMethods

      public String[] listValidMethods()
      List all valid solution methods for this solver
      Returns:
      array of valid method names

    • meOpen

      public NCResult meOpen()
      Maximum Entropy algorithm for Open Queueing Networks. Applies the ME algorithm from Kouvatsos (1994) to the model. Only supports open queueing networks (no closed classes).
      Returns:
      NCResult containing ME algorithm results

    • memUnsupportedReason

      public String memUnsupportedReason(NetworkStruct sn)
      Returns null when the Maximum Entropy Method (Kouvatsos 1994) supports the features of the model described by sn (node types, class switching, scheduling, source presence); otherwise a message describing the first unsupported feature. Open/closed class membership is checked separately on the model; this overload assumes the open-network variant.

    • memUnsupportedReason

      public String memUnsupportedReason(NetworkStruct sn, boolean closed)
      Returns null when the Maximum Entropy Method (Kouvatsos 1994) supports the features of the model described by sn; otherwise a message describing the first unsupported feature. Open models (Section 3.2) allow Source, Queue, Delay and Sink nodes with GE/GE/1, GE/GE/c and GE/GE/inf building blocks; closed models (Section 3.3) allow Queue and Delay nodes with G/G/1 and G/G/inf building blocks only, so finite multiserver stations are rejected.

    • memUnsupportedReason

      public String memUnsupportedReason(NetworkStruct sn, boolean hasOpen, boolean hasClosed)
      Feature check for the Maximum Entropy Method given the class composition of the model: hasOpen/hasClosed flag the presence of open and closed classes (both true for mixed models). Returns null when supported, otherwise the first unsupported feature found.

    • meClosed

      public NCResult meClosed()
      Maximum Entropy algorithm for Closed Queueing Networks (Kouvatsos 1994, Section 3.3): pseudo-open decomposition followed by a convolution over the population lattice, iterated on the flow (work rate) equations.
      Returns:
      NCResult containing the closed ME algorithm results

    • meClosed

      public NCResult meClosed(MeOqnOptions meOptions)
      Maximum Entropy algorithm for Closed Queueing Networks with custom options (Kouvatsos 1994, Section 3.3).
      Parameters:
      meOptions - options for the ME algorithm
      Returns:
      NCResult containing the closed ME algorithm results

    • meMixed

      public NCResult meMixed()
      Maximum Entropy algorithm for Mixed Queueing Networks: composition of the open (Section 3.2) and closed (Section 3.3) algorithms with product-form-style conditioning.
      Returns:
      NCResult containing the mixed ME algorithm results

    • meMixed

      public NCResult meMixed(MeOqnOptions meOptions)
      Maximum Entropy algorithm for Mixed Queueing Networks with custom options.
      Parameters:
      meOptions - options for the ME algorithm
      Returns:
      NCResult containing the mixed ME algorithm results

    • meOpen

      public NCResult meOpen(MeOqnOptions meOptions)
      Maximum Entropy algorithm for Open Queueing Networks with custom options. Applies the ME algorithm from Kouvatsos (1994) to the model. Only supports open queueing networks (no closed classes).
      Parameters:
      meOptions - Options for the ME algorithm
      Returns:
      NCResult containing ME algorithm results

    • sample

      public Object sample(Node node, int numEvents)
      Sample node state trajectory
      Parameters:
      node - The node to sample
      numEvents - Number of samples to generate
      Returns:
      Sample result containing state trajectory

    • sample

      public Object sample(Node node)
      Sample node state trajectory with default number of samples
      Parameters:
      node - The node to sample
      Returns:
      Sample result containing state trajectory

    • supports

      public boolean supports(Network model)
      Checks whether the given model is supported by the NC solver
      Overrides:
      supports in class Solver
      Parameters:
      model - - the network model
      Returns:
      - true if the model is supported, false otherwise

    • resolveMethod

      public String resolveMethod(SolverOptions options)
      Feature-driven resolution of method='default': an open network with non-Markovian (non-unit SCV) variability within the MEM feature set is solved by the Maximum Entropy Method by default, since the normalizing-constant path would silently exponentialize it. Mirrors the dispatch in runAnalyzer and the MATLAB/Python SolverNC.resolveMethod.
      Overrides:
      resolveMethod in class Solver
      Parameters:
      options - the solver options
      Returns:
      the concrete method name

    • supportsModelMethod

      public String supportsModelMethod(String method)
      Method-aware gate. MEM (Kouvatsos maximum entropy) has structural applicability rules beyond a flat feature set (open-only, Source/Queue/ Delay/Sink, non-priority scheduling); delegate to memUnsupportedReason, which returns a precise reason (null when supported). All other NC methods use the coarse product-form feature gate.
      Overrides:
      supportsModelMethod in class Solver
      Parameters:
      method - the concrete method name
      Returns:
      empty string if supported, else the offending reason

    • isStochasticMethod

      public boolean isStochasticMethod(String method)
      NC is deterministic except for the Monte Carlo integration methods (mci/imci), logistic sampling (ls), and the sampling method, whose estimates depend on the random seed. Method names are tokenized so that runtime-resolved names such as "default/imci" and prefixed names such as "nc.ls" classify correctly.
      Overrides:
      isStochasticMethod in class Solver
      Parameters:
      method - the method name to classify
      Returns:
      true if the method returns stochastic estimates

    • supportsModel

      public static boolean supportsModel(Network model)
      Static method to check whether the given model is supported by the NC solver. This allows checking support without creating a solver instance.
      Parameters:
      model - - the network model
      Returns:
      - true if the model is supported, false otherwise

    • getCdfRespT

      public Matrix getCdfRespT(AvgHandle... R)
      Get cumulative distribution function of response times at FCFS and delay nodes
      Parameters:
      R - Optional response time handles (currently unused in this implementation)
      Returns:
      Response time distribution matrix for each node and class

    • getCdfRespT

      public Ret.DistributionResult getCdfRespT()
      Get cumulative distribution function of response times with default parameters
      Overrides:
      getCdfRespT in class NetworkSolver
      Returns:
      Response time distribution matrix for each node and class