Package jline.api

Class PFQN

java.lang.Object
jline.api.PFQN
public class PFQN extends Object
APIs for evaluating Product-Form Queueing Networks.

  • Constructor Details

    • PFQN

      public PFQN()

  • Method Details

    • pfqn_recal

      public static Ret.pfqnNc pfqn_recal(Matrix L, Matrix N)
      RECAL method to compute the normalizing constant of a load-independent closed queueing network model
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Returns:
      normalizing constant (G), its logarithm (lG))

    • pfqn_recal

      public static Ret.pfqnNc pfqn_recal(Matrix L, Matrix N, Matrix Z)
      RECAL method to compute the normalizing constant of a load-independent closed queueing network model
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think time for each class
      Returns:
      normalizing constant (G), its logarithm (lG))

    • pfqn_recal

      public static Ret.pfqnNc pfqn_recal(Matrix L, Matrix N, Matrix Z, Matrix m0)
      RECAL method to compute the normalizing constant of a load-independent closed queueing network model
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think time for each class
      m0 - - vector with multiplicities of each station
      Returns:
      normalizing constant (G), its logarithm (lG))

    • pfqn_nc

      public static Ret.pfqnNcXQ pfqn_nc(Matrix lambda, Matrix L, Matrix N, Matrix Z, SolverOptions options)
      Main method to compute the normalizing constant of a load-independent model
      Parameters:
      lambda - - arrival rate of open classes
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think time for each class
      options - - solver options
      Returns:
      normalizing constant, its logarithm, and mean performance metrics computed as a by-product

    • pfqn_cub

      public static Ret.pfqnNc pfqn_cub(Matrix L, Matrix N, Matrix Z)
      Cubature method to compute the normalizing constant of a load-independent closed queueing network model
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think time for each class
      Returns:
      normalizing constant, its logarithm, and mean performance metrics computed as a by-product

    • pfqn_cub

      public static Ret.pfqnNc pfqn_cub(Matrix L, Matrix N, Matrix Z, int order, double atol)
      Cubature method to compute the normalizing constant of a load-independent closed queueing network model
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think time for each class
      order - - cubature order ( ceil((|N|-1)/2) or above is exact)
      atol - - numerical tolerance for simplex quadrature
      Returns:
      normalizing constant, its logarithm, and mean performance metrics computed as a by-product

    • pfqn_ncld

      public static Ret.pfqnNc pfqn_ncld(Matrix L, Matrix N, Matrix Z, Matrix mu, SolverOptions options)
      Main method to compute the normalizing constant of a load-dependent model
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think time for each class
      mu - - load-dependent scalings
      options - - solver options
      Returns:
      normalizing constant and its logarithm

    • pfqn_gld

      public static Ret.pfqnNc pfqn_gld(Matrix L, Matrix N, Matrix mu, SolverOptions options)
      Compute the normalizing constant of a single-class load-dependent closed queueing network model
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      mu - - load-depedent scalings
      options - - solver options
      Returns:
      normalizing constant and its logarithm

    • pfqn_gld_complex

      public static Ret.pfqnNcComplex pfqn_gld_complex(ComplexMatrix L, Matrix N, Matrix mu, SolverOptions options)
      Compute the normalizing constant of a single-class load-dependent closed queueing network model with complex demands.
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      mu - - load-depedent scalings
      options - - solver options
      Returns:
      normalizing constant and its logarithm

    • pfqn_mushift

      public static Matrix pfqn_mushift(Matrix mu, int k)
      Shifts a load-dependent scaling vector by one position
      Parameters:
      mu - - load-dependent scalings
      Returns:
      normalizing constant and its logarithm

    • compute_norm_const

      public static Ret.pfqnNcXQ compute_norm_const(Matrix L, Matrix N, Matrix Z, SolverOptions options)
      Run a normalizing constant solution method in a load-independent model
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think time for each class
      options - - solver options
      Returns:
      normalizing constant, its logarithm, and mean performance metrics computed as a by-product

    • pfqn_comomrm_ld

      public static Ret.pfqnComomrmLd pfqn_comomrm_ld(Matrix L, Matrix N, Matrix Z, Matrix mu, SolverOptions options)
      Run the COMOM normalizing constant solution method on a repairman model
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think time for each class
      mu - - load-depedent scalings
      options - - solver options
      Returns:
      normalizing constant and its logarithm

    • compute_norm_const_ld

      public static Ret.pfqnNc compute_norm_const_ld(Matrix L, Matrix N, Matrix Z, Matrix mu, SolverOptions options)
      Run a normalizing constant solution method in a load-dependent model
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think time for each class
      mu - - load-depedent scalings
      options - - solver options
      Returns:
      normalizing constant and its logarithm

    • pfqn_fnc

      public static Ret.pfqnFnc pfqn_fnc(Matrix alpha)
      Compute scaling factor of a load-dependent functional server use to calculate the mean
      Parameters:
      alpha - - load-dependent scalings
      Returns:
      functional server scalings

    • pfqn_fnc

      public static Ret.pfqnFnc pfqn_fnc(Matrix alpha, Matrix c)
      Compute scaling factor of a load-dependent functional server use to calculate the mean instantiated with scaling constant c.
      Parameters:
      alpha - - load-dependent scalings
      Returns:
      functional server scalings

    • pfqn_panacea

      public static Ret.pfqnNc pfqn_panacea(Matrix L, Matrix N, Matrix Z)
      Compute the PANACEA approximation
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think time for each class
      Returns:
      normalizing constant and its logarithm

    • pfqn_panacea

      public static Ret.pfqnNc pfqn_panacea(Matrix L, Matrix N, Matrix Z, SolverOptions options)
      Compute the PANACEA approximation
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think time for each class
      options - - solver options
      Returns:
      normalizing constant and its logarithm

    • pfqn_pff_delay

      public static double pfqn_pff_delay(Matrix Z, Matrix n)
      Compute the product-form factor relatively to a Delay station
      Parameters:
      Z - - think times at the Delay station
      n - - number of jobs for each class
      Returns:
      product of terms Z[k]^n[k]/n[k]! for all classes k

    • pfqn_ca

      public static Ret.pfqnNc pfqn_ca(Matrix L, Matrix N)
      Compute the normalizing constant using the convolution algorithm
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Returns:
      normalizing constant and its logarithm

    • pfqn_ca

      public static Ret.pfqnNc pfqn_ca(Matrix L, Matrix N, Matrix Z)
      Compute the normalizing constant using the convolution algorithm
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think times
      Returns:
      normalizing constant and its logarithm

    • pfqn_mmint2_gausslegendre

      public static Ret.pfqnNc pfqn_mmint2_gausslegendre(Matrix L, Matrix N, Matrix Z, Integer m)
      Compute the normalizing constant of a repairmen model using Gauss-Legendre integration
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think times
      Returns:
      normalizing constant and its logarithm

    • pfqn_le_hessianZ

      protected static Matrix pfqn_le_hessianZ(Matrix L, Matrix N, Matrix Z, Matrix u, double v)
      Auxiliary function to compute the Hessian used in the logistic expansion method in models with delays
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think times
      u - - term appearing in the integrand
      v - - term appearing in the integrand
      Returns:
      Hessian matrix

    • pfqn_le_hessian

      protected static Matrix pfqn_le_hessian(Matrix L, Matrix N, Matrix u0)
      Auxiliary function to compute the Hessian used in the logistic expansion method
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      u0 - - term appearing in the integrand
      Returns:
      normalizing constant and its logarithm

    • pfqn_le_fpi

      protected static Ret.pfqnLeFpi pfqn_le_fpi(Matrix L, Matrix N)
      Fixed-point iteration used in the logistic expansion method
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Returns:
      fixed point

    • pfqn_le_fpiZ

      protected static Ret.pfqnLeFpiZ pfqn_le_fpiZ(Matrix L, Matrix N, Matrix Z)
      Fixed-point iteration used in the logistic expansion method in models with delays
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think time for each class
      Returns:
      fixed point

    • pfqn_le

      public static Ret.pfqnNc pfqn_le(Matrix L, Matrix N, Matrix Z)
      Logistic expansion method to compute the normalizing constant
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think time for each class
      Returns:
      normalizing constant and its logarithm

    • pfqn_ls

      public static Ret.pfqnNc pfqn_ls(Matrix L, Matrix N, Matrix Z, long I)
      Logistic sampling method to compute the normalizing constant
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think time for each class
      I - - number of samples
      Returns:
      normalizing constant and its logarithm

    • pfqn_ls

      public static Ret.pfqnNc pfqn_ls(Matrix L, Matrix N, Matrix Z, long I, long seed)
      Logistic sampling method to compute the normalizing constant
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think time for each class
      I - - number of samples
      seed - - random number generation seed
      Returns:
      normalizing constant and its logarithm

    • pfqn_ls_helper

      protected static double pfqn_ls_helper(double[] x, int K, int M, double eta, double eN, Matrix L, Matrix N, Matrix Z)
      Auxiliary function used in the logistic sampling method

    • pfqn_nc_sanitize

      public static Ret.pfqnNcSanitize pfqn_nc_sanitize(Matrix lambda, Matrix L, Matrix N, Matrix Z, double atol)
      Sanitizes product-form model parameters to avoid degeneracies
      Parameters:
      lambda - - arrival rates for open classes
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think time for each class
      atol - - absolute numerical tolerance
      Returns:
      sanitized parameters

    • pfqn_aql

      public static Ret.pfqnAMVA pfqn_aql(Matrix L, Matrix N, Matrix Z)
      AQL approximate MVA for a closed queueing network model.
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think time for each class
      Returns:
      approximate performance metrics

    • pfqn_aql

      public static Ret.pfqnAMVA pfqn_aql(Matrix L, Matrix N, Matrix Z, int maxiter)
      AQL approximate MVA for a closed queueing network model.
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think time for each class
      maxiter - - maximum number of iterations
      Returns:
      approximate performance metrics

    • pfqn_aql

      public static Ret.pfqnAMVA pfqn_aql(Matrix L, Matrix N, Matrix Z, double tol, int maxiter)
      AQL approximate MVA for a closed queueing network model.
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think time for each class
      tol - - maximum iteration tolerance
      maxiter - - maximum number of iterations
      Returns:
      approximate performance metrics

    • pfqn_kt

      public static Ret.pfqnNc pfqn_kt(Matrix L, Matrix N, Matrix Z)
      Knessl-Tier asymptotic expansion of the normalizing constant using the ray method.
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think time for each class
      Returns:
      normalizing constant (G) and its logarithm (lG)

    • pfqn_comomrm

      public static Ret.pfqnComomrm pfqn_comomrm(Matrix L, Matrix N, Matrix Z, Integer m, double atol)
      Compute the normalizing constant of a repairmen model using COMOM
      Parameters:
      L - - demands at all stations
      N - - number of jobs for each class
      Z - - think time for each class
      m - - multiplicy of queueing station
      atol - - absolute numerical tolerance
      Returns:
      sanitized parameters

    • pfqn_gldsingle

      public static Ret.pfqnNc pfqn_gldsingle(Matrix L, Matrix N, Matrix mu, SolverOptions options)
      Auxiliary function used by pfqn_gld to computer the normalizing constant in a single-class load-dependent 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)

    • pfqn_gldsingle_complex

      public static Ret.pfqnNcComplex pfqn_gldsingle_complex(ComplexMatrix L, Matrix N, Matrix mu, SolverOptions options)
      Auxiliary function used by pfqn_gld to computer the normalizing constant in a single-class load-dependent model with complex demands.
      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)

    • pfqn_propfair

      public static Ret.pfqnNcXQ pfqn_propfair(Matrix L, Matrix N, Matrix Z)

    • pfqn_mmsample2

      public static Ret.pfqnNc pfqn_mmsample2(Matrix L, Matrix N, Matrix Z, int samples)

    • pfqn_mmint2

      public static Ret.pfqnNc pfqn_mmint2(Matrix L, Matrix N, Matrix Z)

    • pfqn_mci

      public static Ret.pfqnNc pfqn_mci(Matrix D, Matrix N, Matrix Z, int I, String variant)

    • pfqn_conwayms

      public static Ret.pfqnAMVAMS pfqn_conwayms(Matrix L, Matrix N, Matrix Z, int[] nservers)

    • pfqn_conwayms

      public static Ret.pfqnAMVAMS pfqn_conwayms(Matrix L, Matrix N, Matrix Z)

    • pfqn_conwayms

      public static Ret.pfqnAMVAMS pfqn_conwayms(Matrix L, Matrix N, Matrix Z, int[] nservers, SchedStrategy[] type, double tol, int maxiter)

    • pfqn_conwayms_core

      public static Ret.pfqnCore pfqn_conwayms_core(Matrix L, int M, int R, Matrix N_1, Matrix Z, int[] nservers, Matrix Q, Matrix P, Matrix PB, MatrixCell Delta, SchedStrategy[] type, double tol, int maxiter)

    • pfqn_conwayms_estimate

      public static Ret.pfqnEstimate pfqn_conwayms_estimate(int M, int R, Matrix N_1, int[] nservers, Matrix Q, Matrix P, Matrix PB, MatrixCell Delta, Matrix W)

    • pfqn_conwayms_forwardmva

      public static Ret.pfqnForwardMVA pfqn_conwayms_forwardmva(Matrix L, int M, int R, Matrix N_1, Matrix Z, int[] nservers, SchedStrategy[] type, MatrixCell Q_1, MatrixCell P_1, Matrix PB_1, Matrix T_1)

    • pfqn_lldfun

      public static Matrix pfqn_lldfun(Matrix n, Matrix lldscaling, Matrix nservers)
      Evaluate limited-load dependent (LLD) function
      Parameters:
      n - Queue-length values. The values can be continuous.
      lldscaling - If not null, then the LLD function uses lldscaling to interpolate continuous values of n
      nservers - If not null, then the LLD function is set to be for a multi-server with nserver stations
      Returns:
      Interpolated LLD function values

    • pfqn_cdfun

      public static Matrix pfqn_cdfun(Matrix nvec, Map<Station,SerializableFunction<Matrix,Double>> cdscaling, List<Station> stations)
      Evaluate class-dependent (CD) scaling function
      Parameters:
      nvec - Per-class queue-length values. The values can be continuous.
      cdscaling - CD function
      stations - Station objects
      Returns:

    • pfqn_mva

      public static Ret.pfqnMVA pfqn_mva(Matrix L, Matrix N, Matrix Z)

    • pfqn_mva

      public static Ret.pfqnMVA pfqn_mva(Matrix L, Matrix N, Matrix Z, Matrix mi)
      Mean Value Analysis (MVA) Algorithm for closed Product-Form Queueing Networks. Exact solution is computed for several performance measures.
      Parameters:
      L - - service demand matrix
      N - - population vector
      Z - - think times
      mi - - multiplicity vector
      Returns:
      - mean value of the computed performance measures, including residence times, throughputs, number of jobs at a specific node, and utilizations.

    • pfqn_xzgsbup

      public static double pfqn_xzgsbup(Matrix L, double N, double Z)
      Computes the upper Geometric Square-Root Bound (GSB) for the throughput of the given closed single-class queueing networks
      Parameters:
      L - - service demand matrix
      N - - population
      Z - - think time
      Returns:
      - the upper GSB for the throughput

    • pfqn_qzgbup

      public static double pfqn_qzgbup(Matrix L, double N, double Z, int i)
      Computes the upper Geometric Bound (GB) for the queue length of the given closed single-class queueing networks
      Parameters:
      L - - service demand matrix
      N - - population
      Z - - think time
      i - - station index
      Returns:
      - the upper GB for the queue length

    • pfqn_xzabaup

      public static double pfqn_xzabaup(Matrix L, double N, double Z)
      Computes the upper ABA for the throughput of the given closed single-class queueing networks
      Parameters:
      L - - service demand matrix
      N - - population
      Z - - think time
      Returns:
      - the upper ABA for the throughput

    • pfqn_xzabalow

      public static double pfqn_xzabalow(Matrix L, double N, double Z)
      Computes the low ABA for the throughput of the given closed single-class queueing networks
      Parameters:
      L - - service demand matrix
      N - - population
      Z - - think time
      Returns:
      - the upper ABA for the throughput

    • pfqn_xzgsblow

      public static double pfqn_xzgsblow(Matrix L, double N, double Z)
      Computes the lower Geometric Square-Root Bound (GSB) for the throughput of the given closed single-class queueing networks
      Parameters:
      L - - service demand matrix
      N - - population
      Z - - think time
      Returns:
      - the lower GSB for the throughput

    • pfqn_qzgblow

      public static double pfqn_qzgblow(Matrix L, double N, double Z, int i)
      Computes the lower Geometric Bound (GB) for the queue length of the given closed single-class queueing networks
      Parameters:
      L - - service demand matrix
      N - - population
      Z - - think time
      i - - station index
      Returns:
      - the lower GB for the queue length

    • pfqn_mvams

      public static Ret.pfqnMVA pfqn_mvams(Matrix lambda, Matrix L, Matrix N, Matrix Z, Matrix mi, Matrix S)
      General purpose script to handle mixed Query Networks with multiserver nodes.
      Parameters:
      lambda - - arrival rates
      L - - service demand matrix
      N - - population vector
      Z - - think time matrix
      mi - - multiplicity vector
      S - - server count for each station
      Returns:
      - performance measures of the mixed query network.

    • pfqn_mvamx

      public static Ret.pfqnMVA pfqn_mvamx(Matrix lambda, Matrix D, Matrix N, Matrix Z, Matrix mi)
      Mean Value Analysis (MVA) method for open and mixed queueing networks with no multi-server nodes.
      Parameters:
      lambda - - arrival rates
      D - - service demand matrix
      N - - population vector
      Z - - think times
      mi - - multiplicity vector
      Returns:
      - the performance measures for the given network.

    • pfqn_mvaldms

      public static Ret.pfqnMVA pfqn_mvaldms(Matrix lambda, Matrix D, Matrix N, Matrix Z, Matrix S)
      Wrapper for pfqn_mvaldmx that adjusts utilizations to account for multiservers
      Parameters:
      lambda - - arrival rates
      D - - service demand matrix
      N - - population vector
      Z - - think times
      S - - servers at each station
      Returns:
      - the performance measures for the given network.

    • pfqn_mvaldmx

      public static Ret.pfqnMVALDMX pfqn_mvaldmx(Matrix lambda, Matrix D, Matrix N, Matrix Z, Matrix mu, Matrix S)
      Mean Value Analysis (MVA) method for mixed queueing networks with load-dependent nodes.
      Parameters:
      lambda - - arrival rates
      D - - service demand matrix
      N - - population vector
      Z - - think times
      mu - - load dependent rates
      S - - number of servers at each station
      Returns:
      - the performance measures for the given network.

    • pfqn_mvaldmx_ec

      protected static Ret.pfqnMVALDMXEC pfqn_mvaldmx_ec(Matrix lambda, Matrix D, Matrix mu)
      Auxiliary function used by pfqn_mvaldmx to compute the EC terms

    • pfqn_mvald

      public static Ret.pfqnMVALD pfqn_mvald(Matrix L, Matrix N, Matrix Z, Matrix mu)
      Mean Value Analysis (MVA) method for closed networks with load dependent service and stabilization

    • pfqn_mvald

      public static Ret.pfqnMVALD pfqn_mvald(Matrix L, Matrix N, Matrix Z, Matrix mu, boolean stabilize)
      Mean Value Analysis (MVA) method for closed networks with load dependent service
      Parameters:
      L - - service demand matrix
      N - - population vector
      Z - - think times
      mu - - load dependent service rate. mu[i][j] - load dependent service rate of the ith node when there are j jobs in it
      stabilize - - whether to stabilize the probabilities or not (ensures that probabilities do not become negative)
      Returns:
      - performance measures for the closed network.

    • pfqn_linearizerms

      public static Ret.pfqnAMVAMS pfqn_linearizerms(Matrix L, Matrix N, Matrix Z, Matrix nservers)
      Multiserver version of Krzesinski's Linearizer

    • pfqn_linearizerms

      public static Ret.pfqnAMVAMS pfqn_linearizerms(Matrix L, Matrix N, Matrix Z, Matrix nservers, Matrix type)
      Multiserver version of Krzesinski's Linearizer

    • pfqn_linearizerms

      public static Ret.pfqnAMVAMS pfqn_linearizerms(Matrix L, Matrix N, Matrix Z, Matrix nservers, Matrix type, double tol)
      Multiserver version of Krzesinski's Linearizer

    • pfqn_linearizerms

      public static Ret.pfqnAMVAMS pfqn_linearizerms(Matrix L, Matrix N, Matrix Z, Matrix nservers, Matrix type, double tol, int maxiter)
      Multiserver version of Krzesinski's Linearizer as described in Conway 1989, Fast Approximate Solution of Queueing Networks with Multi-Server Chain- Dependent FCFS Queues. Minor adjustments based on De Souza-Muntz's description of the algorithm.
      Parameters:
      L - - service demand matrix
      N - - population vector
      Z - - think times
      nservers - - number of servers at each station
      type - - scheduling discipline at each station
      tol - - max tolerance admitted between successive iterations
      maxiter - - maximum number of iterations
      Returns:
      - the performance measures of the network.

    • linearizerms_core

      protected static Ret.pfqnLinearizerMSCore linearizerms_core(Matrix L, int M, int R, Matrix N_1, Matrix Z, Matrix nservers, Matrix Q, Matrix P, Matrix PB, Matrix[] Delta, Matrix type, double tol, int maxiter)

    • linearizerms_estimate

      protected static Ret.pfqnLinearizerMSEstimate linearizerms_estimate(int M, int R, Matrix N_1, Matrix nservers, Matrix Q, Matrix P, Matrix PB, Matrix[] Delta)

    • linearizerms_forwardMVA

      protected static Ret.pfqnLinearizerMSForwardMVA linearizerms_forwardMVA(Matrix L, int M, int R, Matrix N_1, Matrix Z, Matrix nservers, Matrix type, Matrix[] Q_1, Matrix[] P_1, Matrix PB_1)

    • pfqn_bs

      public static Ret.pfqnAMVA pfqn_bs(Matrix L, Matrix N)
      Bard-Schweitzer approximate mean value analysis algorithm

    • pfqn_bs

      public static Ret.pfqnAMVA pfqn_bs(Matrix L, Matrix N, Matrix Z)
      Bard-Schweitzer approximate mean value analysis algorithm

    • pfqn_bs

      public static Ret.pfqnAMVA pfqn_bs(Matrix L, Matrix N, Matrix Z, double tol)
      Bard-Schweitzer approximate mean value analysis algorithm

    • pfqn_bs

      public static Ret.pfqnAMVA pfqn_bs(Matrix L, Matrix N, Matrix Z, double tol, int maxiter)
      Bard-Schweitzer approximate mean value analysis algorithm

    • pfqn_bs

      public static Ret.pfqnAMVA pfqn_bs(Matrix L, Matrix N, Matrix Z, double tol, int maxiter, Matrix QN0)
      Bard-Schweitzer approximate mean value analysis algorithm

    • pfqn_bs

      public static Ret.pfqnAMVA pfqn_bs(Matrix L, Matrix N, Matrix Z, double tol, int maxiter, Matrix QN0, SchedStrategy[] type)
      Bard-Schweitzer approximate mean value analysis algorithm
      Parameters:
      L - - the service demand matrix
      N - - the population vector
      Z - - the think times vector
      tol - - max tolerance admitted between successive iterations
      maxiter - - maximum number of iterations
      QN0 - - original queue lengths
      type - - scheduling disciplines at each station
      Returns:
      - the performance metrics for this network.

    • pfqn_linearizer

      public static Ret.pfqnAMVA pfqn_linearizer(Matrix L, Matrix N, Matrix Z, SchedStrategy[] type)
      Linearizer approximate mean value analysis algorithm

    • pfqn_linearizer

      public static Ret.pfqnAMVA pfqn_linearizer(Matrix L, Matrix N, Matrix Z, SchedStrategy[] type, double tol)
      Linearizer approximate mean value analysis algorithm

    • pfqn_linearizer

      public static Ret.pfqnAMVA pfqn_linearizer(Matrix L, Matrix N, Matrix Z, SchedStrategy[] type, double tol, int maxiter)
      Linearizer approximate mean value analysis algorithm
      Parameters:
      L - - the service demand matrix
      N - - the population vector
      Z - - the think times
      type - - the types of the scheduling disciplines at each station
      tol - - max tolerance admitted between successive iterations
      maxiter - - maximum number of iterations
      Returns:
      - the performance measures for the given network

    • pfqn_gflinearizer

      public static Ret.pfqnAMVA pfqn_gflinearizer(Matrix L, Matrix N, Matrix Z, SchedStrategy[] type, double tol, int maxiter, double alpha)

    • pfqn_egflinearizer

      public static Ret.pfqnAMVA pfqn_egflinearizer(Matrix L, Matrix N, Matrix Z, SchedStrategy[] type, double tol, int maxiter, Matrix alpha)
      Extended general form linearizer approximate mean value analysis algorithm. This method performs approximate mean value analysis using an extended general form linearizer approach.
      Parameters:
      L - - the service demand matrix, where rows represent stations and columns represent classes
      N - - the population vector indicating the number of requests for each class
      Z - - the think times, representing the average time between completion of one service request and the beginning of the next
      type - - the types of scheduling disciplines (e.g., FCFS, PS) used at each station
      tol - - the maximum tolerance admitted between successive iterations, used for convergence checking
      maxiter - - the maximum number of iterations allowed in the algorithm
      alpha - - matrix of alphas, which provides weightings or adjustments for each class in the linearizer
      Returns:
      - a pfqnAMVA object containing the computed performance measures: queue lengths, utilizations, response times, and throughput rates

    • egflinearizer_core

      protected static Ret.pfqnLinearizerCore egflinearizer_core(Matrix L, int M, int R, Matrix N_1, Matrix Z, Matrix Q, Matrix[] Delta, SchedStrategy[] type, double tol, int maxiter, Matrix alpha)
      Core method for the extended general form linearizer. This method is responsible for iterating the linearizer steps, adjusting the queue length estimates, and checking for convergence.
      Parameters:
      L - - the service demand matrix
      M - - the number of stations
      R - - the number of classes
      N_1 - - adjusted population vector
      Z - - the think times
      Q - - current queue length estimates
      Delta - - array of matrices representing adjustments for the linearizer
      type - - scheduling disciplines at each station
      tol - - convergence tolerance
      maxiter - - maximum number of iterations
      alpha - - matrix of alpha values for adjustments
      Returns:
      - a pfqnLinearizerCore object containing the updated queue lengths, response times, throughputs, and iteration count

    • egflinearizer_estimate

      protected static Ret.pfqnLinearizerEstimate egflinearizer_estimate(Matrix L, int M, int R, Matrix N_1, Matrix Z, Matrix Q, Matrix[] Delta, Matrix W, Matrix alpha)
      Estimate method for the extended general form linearizer. This method computes the intermediate estimates of the queue lengths and response times.
      Parameters:
      L - - the service demand matrix
      M - - the number of stations
      R - - the number of classes
      N_1 - - adjusted population vector
      Z - - the think times
      Q - - current queue length estimates
      Delta - - array of matrices representing adjustments for the linearizer
      W - - response time matrix
      alpha - - matrix of alpha values for adjustments
      Returns:
      - a pfqnLinearizerEstimate object containing the intermediate queue length estimates

    • egflinearizer_forwardMVA

      protected static Ret.pfqnLinearizerForwardMVA egflinearizer_forwardMVA(Matrix L, int M, int R, SchedStrategy[] type, Matrix N_1, Matrix Z, Matrix[] Q_1)
      Forward Mean Value Analysis method for the extended general form linearizer. This method computes the response times, throughputs, and queue lengths using the mean value analysis technique.
      Parameters:
      L - - the service demand matrix
      M - - the number of stations
      R - - the number of classes
      type - - scheduling disciplines at each station
      N_1 - - adjusted population vector
      Z - - the think times
      Q_1 - - intermediate queue length estimates
      Returns:
      - a pfqnLinearizerForwardMVA object containing the computed queue lengths, response times, and throughputs

    • pfqn_linearizermx

      public static Ret.pfqnAMVA pfqn_linearizermx(Matrix lambda, Matrix L, Matrix N, Matrix Z, Matrix nservers, SchedStrategy[] type, double tol, int maxiter, String method)
      Linearizer method for mixed models with multi-server stations
      Parameters:
      lambda - - arrival rate of open classes
      L - - the service demand matrix
      N - - the population vector
      Z - - the think times vector
      nservers - - number of servers at the stations
      type - - scheduling strategy type
      tol - - max tolerance admitted between successive iterations
      maxiter - - maximum number of iterations
      method - - solution method
      Returns:
      - the performance metrics for this network

    • pfqn_rd

      public static Ret.pfqnRd pfqn_rd(Matrix L, Matrix N, Matrix Z, Matrix mu, SolverOptions options)

    • pfqn_nrp

      public static double pfqn_nrp(Matrix L, Matrix N, Matrix Z, Matrix alpha, SolverOptions options)

    • pfqn_nrl

      public static double pfqn_nrl(Matrix L, Matrix N, Matrix Z, Matrix alpha, SolverOptions options)

    • pfqn_xia

      public static double pfqn_xia(Matrix L, int N, Matrix s, SolverOptions options)

    • pfqn_nca

      public static Matrix pfqn_nca(Matrix L, int N, Matrix alpha)

    • pfqn_mu_ms

      public static Matrix pfqn_mu_ms(int N, int m, int c)

    • pfqn_mu_ms_gnaux

      public static double pfqn_mu_ms_gnaux(int n, int m, int c, Matrix g)