Package jline.io

Class Ret

  • All Implemented Interfaces:
    
public class Ret

    Container class for return types used throughout the LINE queueing network solver library.

    This class provides a centralized collection of data structures used as return types from various queueing network analysis algorithms. Each inner class represents a specific return type tailored to the output requirements of different solvers and methods.

    The return types are organized into several categories:

    • MVA (Mean Value Analysis) variants: pfqnMVA, pfqnMVALD, pfqnMVALDMX, etc.
    • Normalizing constant methods: pfqnNc, pfqnNcXQ, pfqnNcComplex, etc.
    • Approximation methods: pfqnAMVA, LinearizerResult, etc.
    • Cache analysis: cacheMVA, cacheXiFp, cacheGamma, etc.
    • Distribution fitting: mamAPH2Fit, mamMMAPMixtureFit, etc.
    • Sampling and simulation: ctmcSimulation, SampleResult, etc.
    • Solver results: DistributionResult, ProbabilityResult, etc.

    These return types enable type-safe communication between different components of the solver library and provide clear interfaces for algorithm outputs.

    Since:

    1.0

    • Nested Class Summary

      Nested Classes 
      Modifier and Type Class Description
      public class Ret.EventResult

      Result type for event-based state space exploration functions.

      This class encapsulates the output of afterEvent* functions which compute the possible states reachable after an event occurs in the queueing network, along with the rates and probabilities of transitions.
      public class Ret.pfqnGldIndex

      Index key for caching intermediate results in the pfqn_gld (Generalized Local Balance) algorithm.

      This class provides a three-dimensional index (a, b, c) used as a key for storing and retrieving intermediate values computed during the generalized local balance algorithm for product-form queueing networks.
      public class Ret.pfqnMVA

      Result type for the MVA (Mean Value Analysis) algorithm.

      This class encapsulates the key performance metrics computed by the MVA algorithm for product-form queueing networks. MVA is an iterative algorithm that computes steady-state performance measures without explicitly solving the underlying Markov chain.
      public class Ret.pfqnMVALDMX

      Extended result type for MVA with load-dependent stations and additional metrics.

      This class extends the basic MVA results with additional information needed for load-dependent queueing stations, including state-dependent service rates and probability distributions over the number of customers at each station.
      public class Ret.pfqnMVALDMXEC

      Data structure to hold extended results from the MVA computation, particularly focusing on error corrections. It includes the matrices EC, E, Eprime, and Lo.
      public class Ret.pfqnMVALD

      Data structure for storing results from an MVA computation using the LD method. Contains performance metrics such as throughput (X), queue length (Q), utilization (U), response time (R), a list of logarithmic normalization constants (lG), a numerical stability flag (isNumStable), and a probability matrix (pi).
      public class Ret.pfqnAMVAMS

      Data structure for storing results from the AMVA MS (Approximate Mean Value Analysis Multiservice) method. Includes queue length (Q), utilization (U), response time (R), a matrix of class-think times (C), throughput (X), and the total number of iterations (totiter).
      public class Ret.LinearizerResult

      Unified result type for linearizer approximation methods.

      The linearizer is an iterative approximation technique for solving queueing networks with non-product-form features. This class provides a flexible structure that accommodates results from different linearizer variants including:

      • Basic linearizer with queue lengths and waiting times
      • Multi-server linearizer with blocking probabilities
      • Forward MVA linearizer without iteration counts

      Fields may be null depending on the specific linearizer variant used.
      public class Ret.pfqnLinearizerMSEstimate

      Data structure for storing estimated intermediate results from the MS linearizer method. Includes arrays of matrices for queue length estimates (Q_1), probabilities (P_1), and a matrix of blocking probabilities (PB_1).
      public class Ret.pfqnAMVA

      Data structure for storing results from the AMVA (Approximate Mean Value Analysis) method. Contains queue length (Q), utilization (U), response time (R), throughput (T), a matrix for class-think times (C), throughput (X), and the total number of iterations (totiter).
      public class Ret.pfqnLinearizerEstimate

      Data structure for storing intermediate estimates from the linearizer method. Contains arrays of matrices for queue length estimates (Q_1) and a matrix for the throughput estimates (T_1).
      public class Ret.pfqnLeFpi

      Data structure for storing results from a fixed-point iteration method. Contains a matrix of utilization (u) and a matrix of differences (d).
      public class Ret.pfqnLeFpiZ

      Data structure for storing results from a fixed-point iteration method with normalization. Contains a matrix of utilization (u), a normalization constant (v), and a matrix of differences (d).
      public class Ret.pfqnComomrm

      Data structure for storing results the COMOM method. Contains a logarithmic normalization constant (lG) and a basis matrix (lGbasis).
      public class Ret.pfqnNcSanitize

      Data structure for storing sanitized input parameters for a normalizing constant calculation. Includes arrival rates (lambda), service demand matrix (L), population vector (N), think times (Z), and a logarithmic remainder (lGremaind).
      public class Ret.pfqnNcXQ

      Data structure for storing results from a normalizing constant calculation involving throughputs and queue lengths. Contains normalization constants (G, lG), throughput (X), queue length (Q), and method description.
      public class Ret.pfqnNc

      Result type for normalizing constant computations in product-form queueing networks.

      The normalizing constant G(N) is a fundamental quantity in product-form queueing network analysis. It appears in the denominator of the steady-state probability distribution and is used to compute performance measures.

      This class stores both the normalizing constant G and its natural logarithm lG to handle numerical issues with very large or small values.
      public class Ret.pfqnRd

      Data structure for storing results from the RD method. Contains a logarithmic normalization constant (lG) and an optional coefficient (Cgamma).
      public class Ret.pfqnNcComplex

      Data structure for storing complex results from a normalizing constant calculation. Contains complex normalization constants (G, lG) and an optional method description.
      public class Ret.pfqnFnc

      Data structure for storing results from a FNC (Fitting Normalizing Constants) calculation. Contains matrices of mean service rates (mu) and coefficient of variation (c).
      public class Ret.pfqnCUB

      Function class for the integrand used in cubature calculations. This function calculates the integrand value given a vector of inputs, based on the service demand matrix (L), total population (Nt), and a vector of coefficients (beta).
      public class Ret.pfqnComomrmLd

      Data structure for storing results from the load-dependent COMOM method. Contains a normalization constant (GN), a logarithmic normalization constant (lG), and a matrix of probabilities (prob).
      public class Ret.pfqnProcomom2

      Data structure for storing results from the procomom2 method. Contains marginal state probabilities (pk), logarithmic normalization constant (lG), normalization constant (G), transition matrices (T), and auxiliary matrices (F, B).
      public class Ret.pfqnEstimate

      Data structure for storing linearizer estimtate results from a queueing network analysis. Contains queue length (Q), wait time (W), throughput (X), probability matrices (P, PB), and the number of iterations performed (iter).
      public class Ret.cacheMissSpm

      Represents the return type for cache miss rate computations with the SPM method. This class encapsulates various metrics related to the cache miss rates and probabilities.
      public class Ret.cacheMissRayInt
      public class Ret.cacheXiFp

      Result type for the cache characteristic time (xi) fixed-point algorithm.

      This algorithm computes the characteristic times (xi) for cache replacement policies using a fixed-point iteration. The characteristic time represents the average time between consecutive misses for each item in the cache.

      The results include:

      • xi: Characteristic times for each item
      • pi0: Steady-state probability that each item is not in cache
      • pij: Joint probabilities for cache states
      • it: Number of iterations until convergence
      public class Ret.cacheGamma

      Represents the return type for the cache gamma linear program computations. This class encapsulates the computed gamma matrix along with the number of users, items, and levels.
      public class Ret.cacheMVA

      Represents the return type for the cache MVA (Mean Value Analysis) computations. This class encapsulates the results including various probability matrices and other related metrics.
      public class Ret.cacheSpm

      Represents the return type for cache ray method. This class encapsulates the results including the partition function (Z), its logarithm (lZ), and the xi terms.
      public class Ret.cacheRayInt
      public class Ret.FJAuxClassKey
      public class Ret.FJsortForks
      public class Ret.FJApprox
      public class Ret.lossnErlangFP

      Constructs a lossnErlangFPReturn object with the specified queue-length, loss probability, blocking probability, and iteration count.
      public class Ret.mamAPH2Fit

      Class representing the return type for the fitting of a 2-phase APH (Acyclic Phase-Type) distribution.
      public class Ret.mamMMAPSample

      Constructor initializing the sample data, number of types, and type indices.
      public class Ret.mamMMAPMixtureFit

      Class representing the return type for fitting a mixture model to a MMAP.
      public class Ret.ctmcSimulation
      public class Ret.npfqnNonexpApprox

      Data structure to return the results of non-product-form queueing network approximation.
      public class Ret.qsys

      A class to store the results of queueing system analysis.
      public class Ret.snGetDemands

      A unified return type for demand-related methods, supporting both simple demands (D, Z) and comprehensive chain demands with optional chain-specific parameters.
      public class Ret.snGetProductFormParams

      A unified return type for methods returning product form parameters. Supports both class-level and chain-level product form parameters.
      public class Ret.snDeaggregateChainResults

      A return type for the snDeaggregateChainResults method, encapsulating multiple chain-related matrix results.
      public class Ret.mamMAPFitReturn

      A class to represent the return type of the map2_fit function, holding the transition matrices and possibly other fitting results.
      public class Ret.Eigs
      public class Ret.SpectralDecomposition
      public class Ret.getHashOrAddResult

      Result class for getHashOrAdd method
      public class Ret.afterEventHashedOrAddResult

      Result class for afterEventHashedOrAdd method
      public class Ret.reachableSpaceGeneratorResult

      Result class for reachableSpaceGenerator method
      public class Ret.DistributionResult

      Unified result type for distribution computations in queueing network solvers.

      This class provides a standardized interface for returning cumulative distribution functions (CDFs) from various distribution analyses including:

      • Response time distributions
      • Passage time distributions
      • Queue length distributions
      • Transient distributions at specific time points

      The CDF data is organized as a 2D structure indexed by [station][class], where each element contains a matrix of [quantile, value] pairs representing the empirical CDF.
      public class Ret.ProbabilityResult

      Unified result type for probability computations in queueing network solvers.

      This class provides a standardized interface for returning probability values from various probability analyses including:

      • State probabilities (marginal or joint)
      • Normalizing constants
      • Aggregated state probabilities
      • Node-specific marginal probabilities

      The result can represent scalar probabilities, probability vectors, or probability matrices depending on the specific analysis performed.
      public class Ret.SampleResult

      Unified result type for sampling and simulation in queueing network solvers.

      This class provides a standardized interface for returning sampled trajectories from various sampling methods including:

      • Discrete-event simulation
      • Perfect sampling
      • Time-averaged sampling
      • Single-node or system-wide sampling

      The state trajectory can be either a single matrix (for node-specific sampling) or a list of matrices (for system-wide sampling), allowing flexible representation of different sampling scenarios.
      public class Ret.pfqnMom

      Result type for the Method of Moments (MoM) exact algorithm.

      The Method of Moments is an exact algorithm for computing the normalizing constant and performance measures in product-form queueing networks. Unlike floating-point algorithms, MoM uses exact rational arithmetic (BigFraction) to avoid numerical errors, making it suitable for networks with extreme parameter values or when exact results are required.

      The algorithm computes normalizing constants recursively and derives performance measures (throughputs and queue lengths) from these constants.
      public class Ret.pfqnAB

      Result type for the Akyildiz-Bolch (A/B) linearizer method for load-dependent multi-server BCMP networks.

      This class encapsulates the output of the pfqn_ab function which implements the Akyildiz-Bolch linearizer approach for analyzing multi-server queueing networks with processor sharing (PS) scheduling. The method uses weight functions and marginal probability estimation for iterative convergence.
      public class Ret.pfqnSchmidt

      Result type for the Schmidt method for load-dependent MVA with multi-server stations.

      This class encapsulates the output of the pfqn_schmidt function which implements the Schmidt population recursion algorithm for analyzing closed queueing networks with load-dependent service and multi-server stations. Supports INF, PS, and FCFS scheduling strategies with both single and multi-server configurations.

    • Field Summary

      Fields 
      Modifier and Type Field Description

    • Constructor Summary

      Constructors 
      Constructor Description
      Ret()

    • Enum Constant Summary

      Enum Constants 
      Enum Constant Description

    • Method Summary

      Modifier and Type Method Description

      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

    • Constructor Detail

      • Ret

        Ret()

    • Method Detail