line::pfqn Namespace Reference

Namespaces
namespace	simplex

Classes
struct	AbAmvaResult
	Return value of pfqn_ab_amva, mirroring [QN,UN,RN,CN,XN,totiter]. More...
struct	AmvaResult
struct	BkLcResult
	Return value of pfqn_bklc. More...
struct	BkResult
	Return value of pfqn_bk, mirroring [G, lG, X, U, A, B]. More...
struct	BusyPeriodResult
	What pfqn_busyp returns: the durations and the two constant sequences. More...
struct	CbhBounds
	Return value of pfqn_cbh, mirroring [Xlo, Xhi]. More...
struct	CftpResult
	Return value of pfqn_cftp, mirroring [Q, X, T]. More...
struct	ClwOptions
	Optional lattice and aliasing parameters; empty means "use the CLW defaults". More...
struct	ClwResult
	Return value of pfqn_clw and pfqn_clw_lld, mirroring [G, lG]. More...
struct	ComomResult
struct	ComomRmResult
struct	CubResult
	Return value of pfqn_cub, mirroring [Gn, lGn]. More...
struct	CycletPathInfo
	One path's outcome: which route ran, and the network constant it used. More...
struct	CycletResult
	Density, distribution and moments of the passage time along a path. More...
struct	DacResult
	Return value of pfqn_dac, mirroring [Pjoint, states, XN, QN, UN, CN, pi]. More...
struct	DncResult
	Normalizing constant and throughput at a real-valued population. More...
struct	ExpandResult
	Return value of pfqn_expand, mirroring [QN_full,UN_full,CN_full]. More...
struct	ExplicitResult
	Return value of pfqn_explicit, mirroring [lG, G, method, lossDigits]. More...
struct	FncResult
	Return value of pfqn_fnc, mirroring [mu, c]. More...
struct	HarelBoundsResult
	Return value of pfqn_harel_bounds, mirroring Ret.pfqnHarelBounds. More...
struct	HstResult
	Everything the HST certificate reports about one station. More...
struct	KtResult
	Return value of pfqn_kt, mirroring [G, lG, X, Q]. More...
struct	LaplaceResult
	Return value of laplaceapprox, mirroring [I, H, logI]. More...
struct	LcfsMvaResult
struct	LcfsQnResult
struct	LdBcmpBound
	Return value of pfqn_ldbcmp, mirroring [Xlo, Rhi, Qhat]. More...
struct	LdmxEcResult
struct	LektResult
	Return value of pfqn_lekt, mirroring [Gn, lGn, route]. More...
struct	LeResult
	Return value of pfqn_le, mirroring [Gn, lGn]. More...
struct	LinearizerResult
	Return value of the Linearizer family, mirroring [Q,U,W,C,X,totiter]. More...
struct	LoopingBounds
	Return value of pfqn_looping: the throughput bracket plus its queue lengths. More...
struct	LsResult
	Return value of pfqn_ls, mirroring [Gn, lGn]. More...
struct	MarieCdScaling
	Class-dependent scaling of one station, tabulated on the integer population box. More...
struct	MarieCoxFit
	Coxian phase representation: phase rates and per-phase completion probabilities. More...
struct	MarieResult
	Result of pfqn_marie, mirroring the six MATLAB outputs. More...
struct	McmcResult
	Estimates of pfqn_mcmc together with their batch-means intervals. More...
struct	McubBounds
	Return value of pfqn_mcub, mirroring [Xub, Xlb]. More...
struct	MmintResult
	Return value of the McKenna-Mitra quadratures, mirroring [G, lG]. More...
struct	MomlinResult
	Return value of pfqn_momlin, mirroring [Q, X, U, R, QVar, QCov, dQ]. More...
struct	MvacldResult
	Return value of pfqn_mvacld, mirroring [XN, QN, UN, CN, pij]. More...
struct	MvacResult
	Return value of pfqn_mvac, mirroring [XN, QN, UN, CN]. More...
struct	MvaIntervalResult
	Every output of pfqn_mva_interval, each a [lower, upper] pair. More...
struct	MvaLdResult
	Result of pfqn_mvald, mirroring the seven MATLAB outputs. More...
struct	MvaoiMargResult
	Return value of pfqn_mvaoi_marg, mirroring [XN, QN]. More...
struct	MvaoiResult
	Return value of pfqn_mvaoi, mirroring [X, Qoi, Qli, Qdelay, Soi]. More...
struct	MvaResult
struct	MwrbbBounds
	Return value of pfqn_mwrbb, mirroring [Xlo, Xup, Wlo]. More...
struct	NcDispatchResult
struct	NcldmxResult
struct	NcldResult
struct	NcOptions
	The options fields compute_norm_const reads beyond the method itself. More...
struct	NcResult
	Return value of the normalizing-constant family, mirroring Ret.pfqnNc. More...
struct	NcSanitizeResult
struct	NintMvaResult
	Mean performance measures of pfqn_nintmva at the requested population. More...
struct	OiFncResult
	Return value of pfqn_oi_fnc, mirroring [muf, Psi, mu] flattened. More...
struct	OiInsvcResult
	Return value of pfqn_oi_insvc, mirroring [g, Xi, Phi]. More...
struct	PanaceaLdResult
	Return value of pfqn_panaceald, mirroring [Gn, lGn] plus why it declined. More...
struct	PanaceaResult
	Return value of pfqn_panacea, mirroring [Gn, lGn]. More...
struct	PasIsResult
	Return value of pfqn_pas_is / pfqn_oi_is, mirroring [G, lG, Q]. More...
struct	PasPlacement
	Result of pas_placement. More...
struct	PbhBounds
	Return value of pfqn_pbh, mirroring [Xlo, Xhi, Qlo, Qhi]. More...
struct	PfqnManjunathOptions
	Controls of pfqn_manjunath. More...
struct	PfqnManjunathResult
	Result of pfqn_manjunath. More...
struct	PfqnNreResult
	The reference's [lG,G,lGs,vsad]. More...
struct	Procomom2Result
	Return value of pfqn_procomom2, mirroring [pk, lG, G, T, F, B]. More...
struct	ProcomomResult
	Return value of pfqn_procomom, mirroring [Pr, Q]. More...
struct	PropfairResult
	Return value of pfqn_propfair, mirroring [G, lG, Xasy]. More...
struct	QdAmvaResult
	What pfqn_qdamva returns: the fixed point and how it was reached. More...
struct	QdLinResult
	What pfqn_qdlin returns: the fixed point and how it was reached. More...
struct	QlenJointMomentsResult
	Everything pfqn_qlen_joint_moments reports. More...
struct	RdResult
	Return value of pfqn_rd, mirroring [lGN, Cgamma]. More...
struct	ResptPsMomentsResult
	Sojourn-time moments at the PS station, per class. More...
struct	RgfmcResult
	Return value of pfqn_rgfmc, mirroring [G, lG]. More...
struct	RgfResult
	Return value of pfqn_rgf, mirroring [G, lG, lg]. More...
struct	ScbBounds
	Return value of pfqn_scb, mirroring [Xlo, Xhi, Ulo, Uhi]. More...
struct	SchmidtExtResult
	Return value of pfqn_schmidt_ext, mirroring [XN,QN,UN,CN]. More...
struct	SchmidtResult
	Return value of pfqn_schmidt, mirroring [XN,QN,UN,CN]. More...
struct	SdrCoeff
	Derived coefficients of an SDR structure, eqs. More...
struct	SdrResult
	Mean performance measures returned by pfqn_sdr. More...
struct	SdrStruct
	Topology and coefficients of a state-dependent routing subnetwork. More...
struct	SensLdmxEcResult
struct	SensLinearizerResult
struct	SensMomResult
struct	SensMvaldmxResult
struct	SensMvaResult
struct	SensParam
	One differentiation parameter. More...
struct	SensResptResult
struct	SensResult
struct	SibBounds
	Return value of pfqn_sib, mirroring [Xlo, Xhi, Wlo, Whi]. More...
struct	SjnOptions
	Options of the SJN solvers, the fields sjn_args fills in. More...
struct	SjnProfile
	The conditional waiting time profile at one SJN station, the reference's WX. More...
struct	SjnResult
	Return block of pfqn_mvasjn and pfqn_amvasjn. More...
class	SjnStarvationError
	The conditional waiting time equation has no solution at some population. More...
struct	SqniResult
	Return value of pfqn_sqni, mirroring [Q, U, X] for the single station. More...
struct	SsdBounds
struct	StdfResult
	Result of pfqn_stdf / pfqn_stdf_heur, mirroring the MATLAB cell array RD. More...
struct	UniqueResult
struct	WsResult
	What an approximate MVA sweep reports. More...

Typedefs
template<class T>
using	PasRateFun = std::function<T(const std::vector<int>&)>
	Total service rate of a queue on an ordered prefix of classes (1-based).
template<class T>
using	AghqResult = LeResult<T>
template<class T>
using	BktResult = KtResult<T>
	Return value of pfqn_bkt, mirroring [Gn, lGn] (X and Q are pfqn_kt's seeds).
template<class T>
using	BleResult = LeResult<T>
	Return value of pfqn_ble, mirroring [Gn, lGn].
template<class T>
using	CdScaling = std::function<std::vector<T>(const std::vector<T>&)>
	A per-station class-dependence callable: the population row -> 1 or R rates.
template<class T>
using	JdScaling = std::function<std::vector<T>(const std::vector<T>&)>
	A per-station joint-dependence callable: the population row -> 1 or R rates.
using	McRng = std::mt19937_64
	The generator type every Monte Carlo entry point in this tree accepts.
template<class T>
using	OiRate = std::function<T(const std::vector<int>&)>
	An OI station's total service rate as a function of the occupancy vector.
template<class T>
using	OiRateFun = std::function<T(const std::vector<int>&)>
	The OI rank rate of a station as a function of the per-class COUNT vector: the svcRateFun of an OI / P&S node.
using	PlacementOrder = std::vector<std::vector<int>>
	Placement order of one station: prec[i][j] != 0 iff class i must be placed before class j.
template<class T>
using	QlenJointLgSource
	Injected source of log G.

Enumerations
enum class	AbMarginalMethod { Ab , Scat }
	Which marginal-probability rule the multiserver correction uses. More...
enum class	SchedStrategy { PS , FCFS , INF }
	The three scheduling disciplines the AMVA and Schmidt recursions branch on. More...
enum class	AmvaSched { PS , FCFS , INF }
	Station scheduling as far as the AMVA formulas distinguish it. More...
enum class	CftpMethod { Cftp , Approx }
	Which sampler to run. More...
enum class	ChowVariant { Forward , Backward }
	Which finite difference of the LCP solution estimates the theta-terms. More...
enum class	ClustInner { Linearizer , ProportionalEstimation }
	Which algorithm runs inside a subnetwork. More...
enum class	LinearizerMxMethod { Lin , Gflin , Egflin }
	Which Linearizer variant solves the closed subnetwork. More...
enum class	MciVariant { Imci , Mci , Rm }
	The proposal-rate rules the reference selects between. More...
enum class	MwrbbSched {   Fifo = 0 , Ps = 1 , PrioNonPreemptive = 2 , PrioPreemptive = 3 ,   Aba = 4 }
	Station discipline codes, matching the MATLAB sched argument. More...
enum class	NcMethod {   Default , Adaptive , Ca , Exact ,   Recal , Mva , Comom , Clw ,   Cub , Gm , Kt , Bkt ,   Lekt , Bk , Bkue , Lc ,   LcUe , Le , Ble , Aghq ,   Ls , Is , Mci , Imci ,   Mcmc , Sampling , Mmint2 , Gleint ,   Pana , Propfair , Rgf , Divdiff ,   Ger }
	The methods this port dispatches, one per compute_norm_const case. More...
enum class	NcldMethod {   Default , Exact , Is , Clw ,   Panald , Rd , Nrp , Nrl ,   Nre , Comomld , Divdiff }
	The load-dependent methods this port dispatches. More...
enum class	PamVariant { Basic , Improved , Two }
	Which of the three proportional approximations to run. More...
enum class	QlenJointRoute { Auto , Tail , Pmf }
	Which survival-array identity is used. More...
enum class	ResptPsMethod { None , Exact , Asymptotic , Unavailable }
	Which route produced the moments of a given class. More...
enum class	ResptPsRoute { Auto , Exact , Asymptotic }
	Requested route. More...
enum class	WsScheme { Qli = 0 , Fli }
	Which arrival-queue correction the sweep applies. More...

Functions
template<class T>
T	cd_peak_scaling (const std::function< std::vector< T >(const std::vector< int > &)> &beta, const std::vector< int > &NK)
	Peak of a class-dependence handle over the reachable population lattice.
template<class T>
T	infradius_h (const std::vector< T > &x, const Matrix< T > &L, const std::vector< T > &N, const Matrix< T > &alpha)
	Logistic-substitution integrand (matlab/src/api/pfqn/infradius_h.m).
template<class T>
T	infradius_hnorm (const std::vector< T > &x, const Matrix< T > &L, const std::vector< T > &N, const Matrix< T > &alpha)
	Normal-CDF substitution integrand (matlab/src/api/pfqn/infradius_hnorm.m).
template<class T>
LaplaceResult< T >	laplaceapprox (const std::function< T(const std::vector< T > &)> &h, const std::vector< T > &x0)
	Laplace approximation of a multidimensional integral around a given point.
template<class T>
PasPlacement< T >	pas_placement (const Matrix< T > &H)
	Precedence closure of a swap graph.
template<class T>
Matrix< T >	pas_swap2order (const std::vector< Matrix< T > > &swap, const std::vector< PasRateFun< T > > &listRate, const std::vector< int > &N0=std::vector< int >())
	Placement-order DAG of a two-station pass-and-swap tandem.
template<class T>
AbAmvaResult< T >	pfqn_ab_amva (const Matrix< T > &S, const std::vector< int > &N, const Matrix< T > &v, const std::vector< int > &nservers, const std::vector< SchedStrategy > &sched, bool fcfsSchmidt, AbMarginalMethod method)
	Akyildiz-Bolch approximate MVA for multi-server BCMP networks.
template<class T>
AbAmvaResult< T >	pfqn_ab_amva (const Matrix< T > &S, const std::vector< int > &N, const Matrix< T > &v, const std::vector< int > &nservers, const std::vector< SchedStrategy > &sched)
	Reference defaults: no Schmidt FCFS wait, the AB marginal rule.
template<class T>
AghqResult< T >	pfqn_aghq (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z, std::size_t q)
template<class T>
AghqResult< T >	pfqn_aghq (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z)
template<class T>
AghqResult< T >	pfqn_aghq (const Matrix< T > &L, const std::vector< T > &N)
std::vector< int >	oner (const std::vector< int > &N, std::size_t r)
	matlab/src/util/oner.m: decrement position r of N, with r given 1-based and r == 0 meaning "leave N alone" (the s == 0 arm of every for s=0:R loop).
template<class T>
T	enorm (const Matrix< T > &A)
	matlab/src/util/enorm.m: Frobenius norm of a matrix.
template<class T>
double	enorm_diff (const Matrix< T > &A, const Matrix< T > &B)
	Frobenius norm of the difference of two equally shaped matrices, AS A DOUBLE.
template<class T>
std::vector< T >	sum_rows (const Matrix< T > &Z, std::size_t R)
	Sum the rows of a think-time matrix into a length-R vector, the sum(Z,1) that every AMVA entry point performs on its Z argument.
void	first_composition (std::vector< int > &n, int c)
	matlab/src/util/multichoose.m and sprod.m, as an in-place odometer: the compositions of c into R non-negative parts, i.e.
bool	next_composition (std::vector< int > &n)
template<class T>
T	num_multinomial (const std::vector< int > &m)
	Multinomial coefficient sum(m)!
template<class T>
AmvaResult< T >	pfqn_aql (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z, double tol=1e-7, std::size_t maxiter=1000)
	Aggregate Queue Length (AQL) approximate MVA.
template<class T>
AmvaResult< T >	pfqn_aql (const Matrix< T > &L, const std::vector< T > &N)
template<class T>
BkResult< T >	pfqn_bk (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z)
	Birman-Kogan saddle point normalizing constant with bottleneck detection.
double	bk_erfcx (double x)
	Scaled complementary error function exp(x^2)*erfc(x) for x >= 0.
template<class T>
BkResult< T >	pfqn_bkue (const std::vector< T > &L, const T &N, const T &Z)
	Birman-Kogan uniform (van der Waerden) expansion for a single chain.
template<class T>
BkLcResult< T >	pfqn_bklc (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z, const std::string &method="mva", double tol=1e-10, int maxiter=1000)
	Birman-Kogan load concealment algorithm (Algorithm 2).
template<class T>
T	pfqn_stirling_remainder (const T &n)
	s(N) = log(N!) - (N log N - N + log(2 pi N)/2), exactly, for N >= 1.
template<class T>
BktResult< T >	pfqn_bkt (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z)
	Knessl-Tier expansion with the Stirling-remainder correction (BKT).
template<class T>
BktResult< T >	pfqn_bkt (const Matrix< T > &L, const std::vector< T > &N)
template<class T>
BleResult< T >	pfqn_ble (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z)
	Logistic expansion estimate of the normalizing constant, bias-corrected.
template<class T>
BleResult< T >	pfqn_ble (const Matrix< T > &L, const std::vector< T > &N)
template<class T>
AmvaResult< T >	pfqn_bs (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z, const std::vector< AmvaSched > &type, double tol=1e-6, std::size_t maxiter=1000, const Matrix< T > &QN0=Matrix< T >())
	Bard-Schweitzer approximate MVA.
template<class T>
AmvaResult< T >	pfqn_bs (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z)
template<class T>
AmvaResult< T >	pfqn_bs (const Matrix< T > &L, const std::vector< T > &N)
template<class T, class RateSource>
BusyPeriodResult	pfqn_busyp (const std::vector< double > &alpha, const RateSource &mu, const Matrix< T > &P, double N, const std::vector< std::size_t > &subnet, const std::vector< std::size_t > &n, const std::vector< double > &gamma={}, double tol=PFQN_BUSYP_DEFAULT_TOL)
	Mean busy period of order n for the subnetwork.
template<class T>
std::vector< double >	pfqn_busyp_clw (const Matrix< T > &alpha, const Matrix< T > &mu, const std::vector< Matrix< T > > &P, const std::vector< double > &N, const std::vector< std::size_t > &subnet, const std::vector< std::size_t > &n, const Matrix< T > &gamma=Matrix< T >(), const std::vector< bool > &isdelay=std::vector< bool >(), const std::string &method="clw")
	Mean busy period of order n for the subnetwork, via NC point evaluations.
template<class T>
std::vector< double >	pfqn_busyp_multiclass (const Matrix< T > &alpha, const Matrix< T > &mu, const std::vector< Matrix< T > > &P, const std::vector< double > &N, const std::vector< std::size_t > &subnet, const std::vector< std::size_t > &n, const Matrix< T > &gamma=Matrix< T >(), const Matrix< T > &phi=Matrix< T >(), double tol=PFQN_BUSYP_DEFAULT_TOL, int jobclass=-1)
	Mean busy period of order n for the subnetwork, multichain.
template<class T>
NcResult< T >	pfqn_ca (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z)
	Convolution algorithm for the exact normalizing constant of a closed product-form network (Buzen 1973, Reiser-Kobayashi 1975).
template<class T>
NcResult< T >	pfqn_ca (const Matrix< T > &L, const std::vector< int > &N)
	Overload without think times.
template<class T>
CbhBounds< T >	pfqn_cbh (const std::vector< T > &L, int N, const T &Z, int level)
	Convolutional Bound Hierarchy (Dowdy, Eager, Gordon and Saxton 1984) on the throughput of a single-class closed product-form network.
template<class T>
CbhBounds< T >	pfqn_cbh (const std::vector< T > &L, int N, const T &Z)
template<class T>
std::vector< T >	pfqn_cdfun (const Matrix< T > &nvec, const std::vector< CdScaling< T > > &cdscaling, std::size_t classIdx)
	AMVA-QD class-dependence function.
template<class T>
std::vector< T >	pfqn_cdfun (const Matrix< T > &nvec, const std::vector< CdScaling< T > > &cdscaling)
	MATLAB default: classIdx = 1, i.e.
template<class T>
CftpResult< T >	pfqn_cftp (const std::vector< T > &L, int N, const std::vector< int > &S, std::size_t nsamples, CftpMethod method, McRng &rng)
	Perfect stationary state sampling for closed single-class multiserver product-form networks, by monotone Coupling From The Past.
template<class T>
CftpResult< T >	pfqn_cftp (const std::vector< T > &L, int N, McRng &rng)
	Reference defaults: single servers, one sample, exact CFTP.
template<class T>
AmvaResult< T >	pfqn_chow (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z, const std::vector< AmvaSched > &type, double tol=1e-6, std::size_t maxiter=1000, const Matrix< T > &QN0=Matrix< T >(), ChowVariant variant=ChowVariant::Forward)
	Chow Second Approximation (SA) approximate MVA.
template<class T>
AmvaResult< T >	pfqn_chow (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z)
template<class T>
AmvaResult< T >	pfqn_chow (const Matrix< T > &L, const std::vector< T > &N)
template<class T>
AmvaResult< T >	pfqn_clust (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z, const std::vector< std::vector< std::size_t > > &subnets, const std::vector< std::vector< std::size_t > > &localclasses, ClustInner inner=ClustInner::Linearizer, double tol=1e-6, std::size_t maxiter=1000)
	de Souza e Silva-Lavenberg-Muntz Clustering Approximation (CA).
template<class T>
AmvaResult< T >	pfqn_clust (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z)
template<class T>
AmvaResult< T >	pfqn_clust (const Matrix< T > &L, const std::vector< T > &N)
template<class T>
ClwResult< T >	pfqn_clw (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const std::vector< long > &m, const ClwOptions &opt)
	Choudhury-Leung-Whitt normalization constant by numerical inversion of the generating function (JACM 42(5):935-970, 1995), and its limited load-dependent extension through the per-center transforms of Bertozzi and McKenna (SIAM Review 35(2):239-268, 1993).
template<class T>
ClwResult< T >	pfqn_clw (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z)
	Overload with unit multiplicities and the CLW default parameters.
template<class T>
ClwResult< T >	pfqn_clw (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const std::vector< long > &m)
	Overload with the CLW default parameters.
template<class T>
ClwResult< T >	pfqn_clw_lld (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const Matrix< T > &mu, const ClwOptions &opt)
	Limited load-dependent form (matlab pfqn_clw_lld.m).
template<class T>
ClwResult< T >	pfqn_clw_lld (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const Matrix< T > &mu)
	Overload with the CLW default parameters.
template<class T>
ClwResult< T >	pfqn_clw_lld (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z)
	Overload with all queues load independent.
template<class T>
ClwResult< T >	pfqn_clwjd (const std::vector< T > &Z, const std::vector< int > &N, const std::vector< OiRate< T > > &mu, const Matrix< T > &visits, const Matrix< int > &lcut, const ClwOptions &opt)
	Normalizing constant of a closed network of LIMITED JOINT-DEPENDENT (LJD) stations plus one aggregated delay, by numerical inversion of the multichain generating function (Choudhury-Leung-Whitt, J.
template<class T>
ClwResult< T >	pfqn_clwjd (const std::vector< T > &Z, const std::vector< int > &N, const std::vector< OiRate< T > > &mu, const Matrix< T > &visits, const Matrix< int > &lcut)
	Overload with the CLW default parameters.
template<class T>
ClwResult< T >	pfqn_clwjd (const std::vector< T > &Z, const std::vector< int > &N, const std::vector< OiRate< T > > &mu, const Matrix< T > &visits)
	Overload with the all-N cutoff, i.e.
template<class T>
ClwResult< T >	pfqn_clwjd (const std::vector< T > &Z, const std::vector< int > &N, const std::vector< OiRate< T > > &mu)
	Overload with unit visits and the all-N cutoff.
template<class T>
ClwResult< T >	pfqn_clwoi (const std::vector< T > &Z, const std::vector< int > &N, const std::vector< OiRate< T > > &mu, const Matrix< T > &visits, const ClwOptions &opt)
	Normalizing constant of a closed network of ORDER-INDEPENDENT (OI) stations plus one aggregated delay, by numerical inversion of the multichain generating function (Choudhury-Leung-Whitt, J.
template<class T>
ClwResult< T >	pfqn_clwoi (const std::vector< T > &Z, const std::vector< int > &N, const std::vector< OiRate< T > > &mu, const Matrix< T > &visits)
	Overload with the CLW default parameters.
template<class T>
ClwResult< T >	pfqn_clwoi (const std::vector< T > &Z, const std::vector< int > &N, const std::vector< OiRate< T > > &mu)
	Overload with unit visits.
double	pfqn_cntol_total (double total_population)
	Termination cutoff at the given total population.
template<class T>
double	pfqn_cntol (const std::vector< T > &N)
	Termination cutoff at the given population vector.
double	pfqn_cntol (const std::vector< int > &N)
	Termination cutoff at the given integer population vector.
bool	is_cntol (double tol)
	True when tol is the sentinel requesting the Chandy-Neuse test.
std::vector< std::vector< int > >	multichoose_rows (int n, int k)
	All n-vectors of nonnegative integers summing to k, in MATLAB multichoose(n,k) order.
int	matchrow (const std::vector< std::vector< int > > &rows, const std::vector< int > &row)
	Position of row in rows, or -1 when absent.
void	sort_by_nnz_pos (std::vector< std::vector< int > > &I)
	MATLAB's sortbynnzpos: a stable bubble sort putting the rows with FEWER nonzeros first and, among rows with equally many, the row whose leftmost differing entry is nonzero first.
template<class T>
ComomResult< T >	pfqn_comom (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const T &atol)
	CoMoM on the general basis (matlab pfqn_comom.m).
template<class T>
ComomResult< T >	pfqn_comom (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z)
	Overload with the reference's default tolerance.
template<class T>
ComomResult< T >	pfqn_comomrm_orig (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const T &atol)
	Original CoMoM for the finite repairman model (matlab pfqn_comomrm_orig.m).
template<class T>
ComomResult< T >	pfqn_comomrm_orig (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z)
	Overload with the exact (zero-tolerance) tests.
template<class T>
ComomResult< T >	pfqn_comomrm (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, int m)
	CoMoM (class-oriented method of moments) for the finite repairman model: one queueing station of multiplicity m plus a delay.
template<class T>
ComomResult< T >	pfqn_comomrm (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z)
	Overload with the unit multiplicity default.
template<class T>
ComomRmResult< T >	pfqn_comomrm_ld (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const Matrix< T > &mu)
	CoMoM for the repairman model with an arbitrary LOAD-DEPENDENT rate lattice at the single queueing station.
template<class T>
ComomRmResult< T >	pfqn_comomrm_ms (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, int m, int S)
	CoMoM for the MULTISERVER repairman model: one queueing station with S servers (optionally replicated m times), plus a delay.
template<class T>
ComomRmResult< T >	pfqn_comomrm_ms (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, int S)
	Overload with the single-replica default.
template<class T>
NcResult< T >	pfqn_conv (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const std::vector< CdScaling< T > > &cdscaling)
	Multichain convolution algorithm with class-dependent service rates (Sauer 1983, "Computational Algorithms for State-Dependent Queueing Networks", ACM TOCS 1(1):67-92, Section 5.2).
template<class T>
NcResult< T >	pfqn_conv (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z)
	Overload with no class dependence, i.e.
template<class T>
NcResult< T >	pfqn_conv (const Matrix< T > &L, const std::vector< int > &N)
template<class T>
LinearizerResult< T >	pfqn_conwayms (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const std::vector< int > &nservers, const std::vector< SchedStrategy > &type, double tol, int maxiter, const Matrix< T > &QN0)
	Conway's multiserver Linearizer for chain-dependent FCFS queues (Conway 1989, "Fast Approximate Solution of Queueing Networks with Multi-Server Chain-Dependent FCFS Queues").
template<class T>
LinearizerResult< T >	pfqn_conwayms (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const std::vector< int > &nservers)
	MATLAB defaults: all stations FCFS, tol = 1e-8, maxiter = 1000.
template<class T>
std::vector< T >	grnmol (const std::function< T(const std::vector< T > &)> &f, std::size_t n, int s, const T &tol)
	Grundmann-Moeller rule of degrees 1, 3, ..., 2s+1 over the n-simplex with vertices the columns of the identity (MATLAB's grnmol on V = eye(n,n+1)).
template<class T>
CubResult< T >	pfqn_cub (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, int order, const T &atol)
	Normalizing constant by Grundmann-Moeller cubature over the simplex.
template<class T>
CubResult< T >	pfqn_cub (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z)
double	pfqn_cub_evals (int M, int order, double Zsum)
	Integrand-evaluation count of pfqn_cub, and the budget pfqn_nc prices it against.
double	pfqn_cub_evals (int M, int order)
	Zero think time, i.e.
CycletResult	pfqn_cyclet_ofree (const std::vector< double > &v, const std::vector< double > &mu, std::size_t N, const std::vector< std::vector< std::size_t > > &paths, const std::vector< double > &tset, const std::string &method="auto", std::size_t nmom=3, const std::vector< double > &pathprob={}, const std::string &lti_method="euler", double tol=1e-8)
	Exact passage-time density, CDF and moments along the overtake-free paths paths, mixed by pathprob.
template<class T>
DacResult< T >	pfqn_dac (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const Matrix< T > &mu)
	Distribution Analysis by Chain (de Souza e Silva, UCLA CSD-870023, 1987): the JOINT queue-length distribution of a closed product-form network with single-server, infinite-server and queue-dependent centers.
template<class T>
DacResult< T >	pfqn_dac (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z)
template<class T>
LinearizerResult< T >	pfqn_dmlin (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const std::vector< SchedStrategy > &type, double tol, int maxiter, const Matrix< T > &QN0, int npasses=3)
	de Souza e Silva-Muntz Improved Linearizer (IL).
template<class T>
LinearizerResult< T >	pfqn_dmlin (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z)
template<class T>
LinearizerResult< T >	pfqn_dmlin (const Matrix< T > &L, const std::vector< int > &N)
template<class T>
DncResult< T >	pfqn_dnc (const std::vector< T > &L, const T &N)
	Distinct-load Normalizing Constant (DNC) at a nonintegral population.
template<class T>
LinearizerResult< T >	pfqn_egflinearizer (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const std::vector< SchedStrategy > &type, double tol, int maxiter, const std::vector< T > &alpha, const Matrix< T > &QN0, int npasses=3)
	Extended generalized fixed-point Linearizer (De Souza e Silva and Muntz's generalization of Chandy and Neuse's Linearizer, with a per-class scaling exponent alpha_r).
template<class T>
LinearizerResult< T >	pfqn_egflinearizer (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const std::vector< T > &alpha)
	MATLAB defaults: tol = 1e-8, maxiter = 1000, no warm start.
template<class T>
ExpandResult< T >	pfqn_expand (const Matrix< T > &QN, const Matrix< T > &UN, const Matrix< T > &CN, const std::vector< std::size_t > &mapping)
	Expand per-station metrics from a reduced model back to the original station set.
template<class T>
ExplicitResult< T >	pfqn_explicit (const Matrix< T > &L, const std::vector< int > &N, double tol=std::numeric_limits< double >::epsilon(), const std::string &method="auto", double maxloss=std::numeric_limits< double >::infinity())
	Explicit closed-form normalizing constant of a multiclass closed network.
template<class T>
ExplicitResult< T >	pfqn_explicit_ld (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &mu, double tol=std::numeric_limits< double >::epsilon(), const std::string &method="auto", double maxloss=std::numeric_limits< double >::infinity())
	Explicit closed-form normalizing constant of a multiclass LIMITED LOAD-DEPENDENT network.
template<class T>
Matrix< T >	pfqn_fnc_at (const Matrix< T > &alpha, const std::vector< T > &c)
	Rates for a given offset vector c (the two-argument MATLAB branch).
template<class T>
FncResult< T >	pfqn_fnc (const Matrix< T > &alpha)
	Automatic offset search (the one-argument MATLAB branch).
template<class T>
FncResult< T >	pfqn_fnc (const Matrix< T > &alpha, const std::vector< T > &c)
template<class T>
NcResult< T >	pfqn_gerasimov (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, double tol=1e-12, std::size_t maxterms=200000)
	Exact normalizing constant of a closed multiclass product-form network by ITERATED RESIDUES of its rational generating function, one class at a time.
template<class T>
NcResult< T >	pfqn_gerasimov (const Matrix< T > &L, const std::vector< int > &N)
	Delay-free overload.
template<class T>
LinearizerResult< T >	pfqn_gflinearizer (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const std::vector< SchedStrategy > &type, double tol, int maxiter, const T &alpha, const Matrix< T > &QN0)
	Generalized fixed-point Linearizer with a single scaling exponent shared by every class (De Souza e Silva and Muntz).
template<class T>
LinearizerResult< T >	pfqn_gflinearizer (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const T &alpha)
template<class T>
NcResult< T >	pfqn_gld (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &mu)
	Exact normalizing constant of a closed product-form network whose stations may be load dependent (generalized Buzen, Reiser-Kobayashi 1975).
template<class T>
NcResult< T >	pfqn_gld (const Matrix< T > &L, const std::vector< int > &N)
	Overload with all rates equal to one, i.e.
template<class T>
NcResult< T >	pfqn_gldsingle (const Matrix< T > &L, int N, const Matrix< T > &mu)
	Exact normalizing constant of a SINGLE-CLASS closed network whose stations are load dependent.
template<class T>
T	pfqn_grnmol (const Matrix< T > &L, const std::vector< int > &N)
	Normalizing constant by the closed-form Grundmann-Moeller rule.
template<class T>
T	pfqn_harel_lb (const std::vector< T > &rho, int N, const T &Z)
	Lower bound alone.
template<class T>
T	pfqn_harel_lb (const std::vector< T > &rho, int N)
	Zero think time.
template<class T>
T	pfqn_harel_ub (const std::vector< T > &rho, int N, int n, const T &Z)
	Upper bound extrapolated from the exact throughput at population n.
template<class T>
T	pfqn_harel_ub (const std::vector< T > &rho, int N, int n)
	Zero think time.
template<class T>
HarelBoundsResult< T >	pfqn_harel_bounds (const std::vector< T > &rho, int N, const T &Z, int maxUB)
	Both bounds, plus the exact throughputs the upper bounds extrapolate from.
template<class T>
HarelBoundsResult< T >	pfqn_harel_bounds (const std::vector< T > &rho, int N)
	Zero think time, default extrapolation ceiling min(N, 7).
template<class T>
HstResult< T >	pfqn_hst (const std::vector< T > &L, int N, const T &Z, std::size_t ist)
	Operational sensitivity of throughput to homogeneous-service-time (HST) violations, and the constrained worst case (Suri 1983).
template<class T>
HstResult< T >	pfqn_hst (const std::vector< T > &L, int N, const T &Z)
	MATLAB default: the bottleneck station, argmax L.
template<class T>
HstResult< T >	pfqn_hst (const std::vector< T > &L, int N)
	MATLAB default: no think time and the bottleneck station.
template<class T>
NcResult< T >	pfqn_is (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, std::size_t samples, McRng &rng)
	Importance-sampling estimate of the normalizing constant of a closed LOAD-INDEPENDENT product-form network.
template<class T>
NcResult< T >	pfqn_is (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, McRng &rng)
	Reference default of 1e4 samples.
template<class T>
std::vector< T >	pfqn_jdfun (const Matrix< T > &nvec, const std::vector< JdScaling< T > > &jdscaling, std::size_t classIdx)
	AMVA joint-dependence function for non-product-form scaling.
template<class T>
std::vector< T >	pfqn_jdfun (const Matrix< T > &nvec, const std::vector< JdScaling< T > > &jdscaling)
	MATLAB default: classIdx = 1, i.e.
template<class T>
T	pfqn_joint (const Matrix< int > &n, const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const T &G)
	Joint probability of a PER-CLASS occupancy matrix.
template<class T>
T	pfqn_joint_total (const std::vector< int > &m, const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const T &G)
	Joint probability of the per-station TOTAL queue lengths.
template<class T>
T	pfqn_joint (const Matrix< int > &n, const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z)
	Overload computing G with pfqn_ca first, matching the reference's default.
template<class T>
T	pfqn_joint_total (const std::vector< int > &m, const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z)
template<class T>
T	pfqn_jointmarg (const std::vector< int > &n, const Matrix< T > &L, const std::vector< int > &N, const std::vector< std::size_t > &infset, const T &G, const std::string &engine="exact", std::uint64_t seed=0)
	Joint probability of the per-station TOTAL queue lengths.
template<class T>
T	pfqn_jointmarg (const std::vector< int > &n, const Matrix< T > &L, const std::vector< int > &N, const std::vector< std::size_t > &infset, const std::string &engine="exact", std::uint64_t seed=0)
	Overload computing G with pfqn_ca first, matching the reference's default.
template<class T>
KtResult< T >	pfqn_kt (const Matrix< T > &L0, const std::vector< T > &N0, const std::vector< T > &Z0)
	Knessl-Tier asymptotic expansion of the normalizing constant.
template<class T>
KtResult< T >	pfqn_kt (const Matrix< T > &L, const std::vector< T > &N)
template<class T>
T	finish_lap (const std::vector< T > &L, const std::vector< T > &N, const std::vector< T > &Z, const T &Ntot, const T &u0)
	Assembly of the expansion at the saddle point; defined below.
template<class T>
T	pfqn_lap (const std::vector< T > &L, const std::vector< T > &N, const std::vector< T > &Z)
	Laplace approximation of the normalizing constant of a repairman (single-queue, multiclass) model.
template<class T>
LcfsQnResult< T >	pfqn_lcfsqn_ca (const std::vector< T > &alpha, const std::vector< T > &beta, const std::vector< int > &N)
	Convolution algorithm for the two-station multiclass LCFS queueing network of Casale, "A family of multiclass LCFS queueing networks with order-dependent product-form solutions", QUESTA 2026.
template<class T>
LcfsMvaResult< T >	pfqn_lcfsqn_mva (const std::vector< T > &alpha, const std::vector< T > &beta, const std::vector< int > &N)
	Exact mean value analysis of the two-station multiclass LCFS network of Casale, QUESTA 2026 (station 1 LCFS, station 2 LCFS-PR).
template<class T>
T	pfqn_lcfsqn_nc (const std::vector< T > &alpha, const std::vector< T > &beta, const std::vector< int > &N)
	Normalizing constant of the two-station multiclass LCFS network as a sum of PERMANENTS, the closed form of Casale, QUESTA 2026.
template<class T>
AmvaResult< T >	pfqn_lcp (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z, const std::vector< AmvaSched > &type, double tol=1e-6, std::size_t maxiter=1000, const Matrix< T > &QN0=Matrix< T >())
	Bard Large Customer Population (LCP) approximate MVA.
template<class T>
AmvaResult< T >	pfqn_lcp (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z)
template<class T>
AmvaResult< T >	pfqn_lcp (const Matrix< T > &L, const std::vector< T > &N)
template<class T>
NcResult< T >	pfqn_ld_is (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const Matrix< T > &mu, std::size_t samples, McRng &rng)
	Importance-sampling estimate of the normalizing constant of a closed LOAD-DEPENDENT product-form network.
template<class T>
NcResult< T >	pfqn_ld_is (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const Matrix< T > &mu, McRng &rng)
	Reference default of 1e4 samples.
template<class T>
LdBcmpBound< T >	pfqn_ldbcmp (const std::vector< T > &L, const T &N, const T &Z, const std::vector< T > &c, const T &tol)
	Anselmi-Cremonesi (2008) lower throughput bound for a closed single-class BCMP network with load-dependent stations.
template<class T>
LdBcmpBound< T >	pfqn_ldbcmp (const std::vector< T > &L, const T &N, const T &Z)
template<class T>
LdmxEcResult< T >	pfqn_ldmx_ec (const std::vector< T > &lambda, const Matrix< T > &D, const Matrix< T > &mu)
	Bruell-Balbo-Afshari effective-capacity terms for a MIXED open/closed network with limited load dependence.
template<class T>
std::vector< T >	pfqn_le_fpi (const Matrix< T > &L, const std::vector< T > &N)
	Mode of the logistic-transformed integrand, Z = 0 case (pfqn_le_fpi).
template<class T>
void	pfqn_le_fpiZ (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z, std::vector< T > &u, T &v)
	Mode of the logistic-transformed integrand, Z > 0 case (pfqn_le_fpiZ).
template<class T>
Matrix< T >	pfqn_le_hessian (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &u0)
	Hessian of the Z = 0 logistic integrand at the mode ((M-1) x (M-1)).
template<class T>
Matrix< T >	pfqn_le_hessianZ (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z, const std::vector< T > &u, const T &v)
	Hessian of the Z > 0 logistic integrand at the mode (M x M).
template<class T>
LeResult< T >	pfqn_le (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z)
	Logistic expansion estimate of the normalizing constant.
template<class T>
LeResult< T >	pfqn_le (const Matrix< T > &L, const std::vector< T > &N)
template<class T>
std::string	pfqn_lekt_route (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z)
	"kt" when R <= M or a class self-loops, "le" otherwise.
template<class T>
LektResult< T >	pfqn_lekt (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z)
	The common corrected asymptotic expansion (LE-KT), computed on the cheaper side.
template<class T>
LektResult< T >	pfqn_lekt (const Matrix< T > &L, const std::vector< T > &N)
template<class T>
LinearizerResult< T >	pfqn_linearizer (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const std::vector< SchedStrategy > &type, double tol, int maxiter, const Matrix< T > &QN0)
	Chandy-Neuse Linearizer for single-server stations.
template<class T>
LinearizerResult< T >	pfqn_linearizer (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z)
template<class T>
LinearizerResult< T >	pfqn_linearizer (const Matrix< T > &L, const std::vector< int > &N)
template<class T>
LinearizerResult< T >	pfqn_linearizerms (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const std::vector< int > &nservers, const std::vector< SchedStrategy > &type, double tol, int maxiter, const Matrix< T > &QN0)
	Multiserver Linearizer (Krzesinski's Linearizer as described in Conway 1989, with De Souza e Silva and Muntz's presentation of the marginal-probability recursions).
template<class T>
LinearizerResult< T >	pfqn_linearizerms (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const std::vector< int > &nservers)
	MATLAB defaults: all stations PS, tol = 1e-8, maxiter = 1000, no warm start.
template<class T>
LinearizerResult< T >	pfqn_linearizermx (const std::vector< T > &lambda, const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const std::vector< int > &nservers, const std::vector< SchedStrategy > &type, double tol, int maxiter, LinearizerMxMethod method, const Matrix< T > &QN0)
	Linearizer for mixed open/closed queueing networks.
template<class T>
LinearizerResult< T >	pfqn_linearizermx (const std::vector< T > &lambda, const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const std::vector< int > &nservers, LinearizerMxMethod method=LinearizerMxMethod::Egflin)
	MATLAB defaults: all-PS, tol = 1e-8, maxiter = 1000, 'egflin', no warm start.
template<class T>
std::vector< T >	pfqn_lldfun (const std::vector< T > &n, const Matrix< T > &lldscaling, const std::vector< double > &nservers)
	AMVA-QD limited-load-dependence function.
template<class T>
std::vector< T >	pfqn_lldfun (const std::vector< T > &n, const Matrix< T > &lldscaling)
	Overload without the multiserver term, matching the two-argument MATLAB call.
template<class T>
NcResult< T >	pfqn_lldsingle (const Matrix< T > &L, int N, const Matrix< T > &mu)
	Exact normalizing constant of a SINGLE-CLASS closed network whose stations are LIMITED load dependent, i.e.
template<class T>
LoopingBounds< T >	pfqn_looping (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z, double tol=1e-6, std::size_t maxiter=1000)
	Eager Looping bounds for closed multiclass product-form networks.
template<class T>
LoopingBounds< T >	pfqn_looping (const Matrix< T > &L, const std::vector< T > &N)
template<class T>
LsResult< T >	pfqn_ls (const Matrix< T > &L0, const std::vector< T > &N, const std::vector< T > &Z, std::size_t I, McRng &rng)
	Logistic-sampling estimate of the normalizing constant of a closed product-form network.
template<class T>
LsResult< T >	pfqn_ls (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z, McRng &rng)
	Reference default of 1e5 samples.
template<class T>
PfqnManjunathResult< T >	pfqn_manjunath (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const Matrix< T > &A, const std::vector< long > &b, const std::string &sense, const PfqnManjunathOptions &options={})
	Exact normalizing constant of a closed multiclass product-form network whose state space carries arbitrary linear integer constraints (Manjunath-Sikdar).
template<class T>
PfqnManjunathResult< T >	pfqn_manjunath (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const PfqnManjunathOptions &options={})
	Overload without extra constraints: the plain closed-network constant.
template<class T>
PfqnManjunathResult< T >	pfqn_manjunath (const Matrix< T > &L, const std::vector< int > &N, const PfqnManjunathOptions &options={})
	Overload without think times or extra constraints.
template<class T>
MarieCoxFit< T >	marie_cox_fit (const T &mean, const T &scv)
	Closed-form Coxian fit of a mean and an SCV (matlab/src/lang/processes/Coxian.m, fitMeanAndSCV), with the branch thresholds at CoarseTol = 1e-3.
template<class T>
std::vector< T >	marie_cd_eval (const MarieCdScaling< T > &cd, const std::vector< T > &nv)
	Evaluate a class-dependent scaling at a real-valued population vector (cdscale_eval in the reference): the interpolated ratio, guarded against a non-positive or non-finite value and clamped to [1e-3, 1e3].
template<class T>
MarieResult< T >	pfqn_marie (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const Matrix< T > &scv, double tol, int maxiter, const std::vector< int > &nservers)
	Marie's method for a closed network with FCFS Coxian service.
template<class T>
MarieResult< T >	pfqn_marie (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const Matrix< T > &scv)
	Reference defaults: tol 1e-8, maxiter 1000, single server everywhere.
double	mc_uniform01 (McRng &g)
	Uniform deviate on [0,1) with 53 significant bits, as a double.
template<class T>
T	mc_uniform (McRng &g)
	The same deviate materialized in the working arithmetic.
std::uint64_t	mc_uniform_int (McRng &g, std::uint64_t n)
	Uniform integer on [0, n), unbiased by rejection.
double	mc_normal01 (McRng &g)
	Standard normal deviate by the Box-Muller transform.
double	mc_logmeanexp (const std::vector< double > &v)
	log(mean(exp(v))), computed by factoring out the maximum so that the exponentials stay in range.
template<class T>
T	mc_exp (double lv)
	exp of a log-domain value, materialized in the working arithmetic.
template<class T>
double	mc_log_factorial (long n)
	log(n!) for a non-negative integer n, the factln / gammaln(1+n) of the references, accumulated in the working arithmetic so the high-precision backends do not lose the digits a double lgamma would drop.
template<class T>
NcResult< T >	pfqn_mci (const Matrix< T > &D, const std::vector< int > &N, const std::vector< T > &Z, std::size_t samples, MciVariant variant, McRng &rng)
	Monte Carlo Integration estimate of the normalizing constant of a closed product-form network (Ross, Wang and Yao; MonteQueue 2.0).
template<class T>
NcResult< T >	pfqn_mci (const Matrix< T > &D, const std::vector< int > &N, const std::vector< T > &Z, McRng &rng)
	Reference defaults: 1e5 samples, the IMCI proposal.
template<class T>
McmcResult< T >	pfqn_mcmc (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const std::vector< double > &s, std::size_t samples, std::size_t nbatches, double burnin, McRng &rng)
	Chen-O'Cinneide REGULARIZATION: a Markov chain Monte Carlo estimator of the class throughputs X(r) = G(N-e_r)/G(N) and of the mean queue lengths Q(i,r) of a CLOSED multiclass product-form (BCMP, no type changes) network.
template<class T>
McubBounds< T >	pfqn_mcub (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z)
	Kerola's multiclass composite bound (Perf.
template<class T>
McubBounds< T >	pfqn_mcub (const Matrix< T > &L, const std::vector< T > &N)
template<class T>
MmintResult< T >	pfqn_mmint2 (const std::vector< T > &L, const std::vector< T > &N, const std::vector< T > &Z)
	Adaptive form (MATLAB pfqn_mmint2): Gauss-Kronrod on [0, 27.63] with absolute tolerance 1e-12.
template<class T>
MmintResult< T >	pfqn_mmint2_gausslegendre (const std::vector< T > &L, const std::vector< T > &N, const std::vector< T > &Z, int m, std::size_t nodecap)
	Gauss-Legendre form on [0, 1e6] (MATLAB pfqn_mmint2_gausslegendre).
template<class T>
MmintResult< T >	pfqn_mmint2_gausslegendre (const std::vector< T > &L, const std::vector< T > &N, const std::vector< T > &Z)
template<class T>
MmintResult< T >	pfqn_mmint2_gausslaguerre (const std::vector< T > &L, const std::vector< T > &N, const std::vector< T > &Z, int m, std::size_t npts)
	Gauss-Laguerre form (MATLAB pfqn_mmint2_gausslaguerre).
template<class T>
MmintResult< T >	pfqn_mmint2_gausslaguerre (const std::vector< T > &L, const std::vector< T > &N, const std::vector< T > &Z)
template<class T>
NcResult< T >	pfqn_mmsample2 (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, std::size_t samples, McRng &rng)
	Sampled McKenna-Mitra integral form of the normalizing constant of a repairman (single-queue plus delay) model.
template<class T>
NcResult< T >	pfqn_mmsample2 (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, McRng &rng)
	Reference call shape with an explicit grid size.
template<class T>
MomlinResult< T >	pfqn_momlin (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const T &tol, int maxiter)
	Moment linearizer: approximate first and second queue-length moments of a large closed product-form network.
template<class T>
MomlinResult< T >	pfqn_momlin (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z)
	Overload with the reference's defaults (tol 1e-8, maxiter 1000).
template<class T>
std::vector< T >	pfqn_mu_ms (int N, int m, int c)
	Aggregate load-dependent rate of m identical c-server FCFS stations.
template<class T>
Matrix< T >	pfqn_mushift (const Matrix< T > &mu, const std::vector< std::size_t > &iset)
	Shift the load-dependent service-rate lattice of selected stations.
template<class T>
Matrix< T >	pfqn_mushift (const Matrix< T > &mu, std::size_t i)
	Single-station overload, the form the reference is actually called with.
template<class T>
MvaResult< T >	pfqn_mva (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const std::vector< int > &mi)
	Exact Mean Value Analysis for closed product-form networks (Reiser and Lavenberg 1980).
template<class T>
MvaResult< T >	pfqn_mva_ilock (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const std::vector< int > &mi, const Matrix< T > &IL)
	Exact MVA recursion carrying the interlocked-flow correction.
template<class T>
MvaResult< T >	pfqn_mva (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z)
template<class T>
MvaResult< T >	pfqn_mva (const Matrix< T > &L, const std::vector< int > &N)
template<class T>
MvaIntervalResult< T >	pfqn_mva_interval (const Matrix< T > &L, int nlo, int nup, const T &zlo, const T &zup)
	Exact interval-valued MVA for single-class closed product-form networks.
template<class T>
MvacResult< T >	pfqn_mvac (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z)
	MVAC: exact mean value analysis BY CHAIN of a closed multichain product-form network (Conway, de Souza e Silva and Lavenberg, IEEE Trans.
template<class T>
MvacResult< T >	pfqn_mvac (const Matrix< T > &L, const std::vector< int > &N)
	Overload with the zero think-time default.
template<class T>
MvacldResult< T >	pfqn_mvacld (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const Matrix< T > &mu)
	MVAC for networks with queue-length dependent (QLD) service centers, the Section V extension of Conway, de Souza e Silva and Lavenberg (1989).
template<class T>
MvacldResult< T >	pfqn_mvacld (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z)
	Overload with the fixed-rate default.
template<class T>
MvaoiResult< T >	pfqn_mvajd (const std::vector< T > &Z, const std::vector< int > &N, const std::vector< std::function< T(const std::vector< int > &)> > &mu, const Matrix< T > &Dli, const Matrix< T > &visits, bool want_soi)
template<class T>
MvaoiResult< T >	pfqn_mvajd (const std::vector< T > &Z, const std::vector< int > &N, const std::vector< std::function< T(const std::vector< int > &)> > &mu, const Matrix< T > &Dli, const Matrix< T > &visits)
template<class T>
MvaoiResult< T >	pfqn_mvajd (const std::vector< T > &Z, const std::vector< int > &N, const std::vector< std::function< T(const std::vector< int > &)> > &mu, const Matrix< T > &Dli, bool want_soi)
template<class T>
MvaoiResult< T >	pfqn_mvajd (const std::vector< T > &Z, const std::vector< int > &N, const std::vector< std::function< T(const std::vector< int > &)> > &mu, const Matrix< T > &Dli)
bool	is_open_class (int n)
	True when the population entry denotes an open class.
template<class T>
MvaLdResult< T >	pfqn_mvald (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const Matrix< T > &mu, bool stabilize=true)
	Exact MVA for a closed network of load-dependent stations.
template<class T>
MvaResult< T >	pfqn_mvamx (const std::vector< T > &lambda, const Matrix< T > &D, const std::vector< int > &N, const Matrix< T > &Z, const std::vector< int > &mi)
	Exact MVA for a mixed open/closed network of single-server stations.
template<class T>
MvaResult< T >	pfqn_mvaldmx (const std::vector< T > &lambda, const Matrix< T > &D, const std::vector< int > &N, const Matrix< T > &Z, const Matrix< T > &mu)
	Exact MVA for mixed open/closed networks with limited load dependence.
template<class T>
MvaResult< T >	pfqn_mvaldms (const std::vector< T > &lambda, const Matrix< T > &D, const std::vector< int > &N, const Matrix< T > &Z, const std::vector< int > &S)
	Exact MVA for mixed open/closed networks with multiserver stations.
template<class T>
MvaResult< T >	pfqn_mvams (const std::vector< T > &lambda, const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const std::vector< int > &mi, const std::vector< int > &S)
	General-purpose exact MVA for mixed networks with multiserver stations.
template<class T>
MvaResult< T >	pfqn_mvams (const std::vector< T > &lambda, const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const std::vector< int > &S)
	Overload with unit multiplicities.
template<class T>
MvaResult< T >	pfqn_mvams (const std::vector< T > &lambda, const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z)
	Overload with unit multiplicities and a single server everywhere.
template<class T>
MvaResult< T >	pfqn_mvams_ilock (const std::vector< T > &lambda, const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const std::vector< int > &mi, const std::vector< int > &S, const Matrix< T > &IL)
	MVA entry point for models carrying the interlocked-flow correction.
template<class T>
MvaoiResult< T >	pfqn_mvaoi (const std::vector< T > &Z, const std::vector< int > &N, const std::vector< std::function< T(const std::vector< int > &)> > &mu, const Matrix< T > &Dli, const Matrix< T > &visits, bool want_soi)
	Mean-value analysis of a closed network with order-independent (OI) stations, the composition-dependent generalization of Conditional MVA.
template<class T>
MvaoiResult< T >	pfqn_mvaoi (const std::vector< T > &Z, const std::vector< int > &N, const std::vector< std::function< T(const std::vector< int > &)> > &mu, const Matrix< T > &Dli, bool want_soi)
	Overload with unit visits.
template<class T>
MvaoiResult< T >	pfqn_mvaoi (const std::vector< T > &Z, const std::vector< int > &N, const std::vector< std::function< T(const std::vector< int > &)> > &mu, const Matrix< T > &Dli, const Matrix< T > &visits)
	Overload without the in-service means.
template<class T>
MvaoiResult< T >	pfqn_mvaoi (const std::vector< T > &Z, const std::vector< int > &N, const std::vector< std::function< T(const std::vector< int > &)> > &mu, const Matrix< T > &Dli)
	Overload without the in-service means, unit visits.
template<class T>
MvaoiMargResult< T >	pfqn_mvaoi_marg (const Matrix< T > &D, const std::vector< int > &N, const std::vector< bool > &isDelay, const std::vector< std::function< T(const std::vector< int > &)> > &mu)
	Exact marginal load-dependent MVA for a closed network of delay, load-independent and ANY number of order-independent (OI) stations.
template<class T>
MwrbbBounds< T >	pfqn_mwrbb (const Matrix< T > &V, const Matrix< T > &S, const std::vector< T > &N, const std::vector< T > &Z, const std::vector< MwrbbSched > &sched, const std::vector< int > &prio)
	Majumdar-Woodside robust box bounds on the per-class throughput of a closed multiclass network with mixed scheduling disciplines (Perf.
template<class T>
MwrbbBounds< T >	pfqn_mwrbb (const Matrix< T > &V, const Matrix< T > &S, const std::vector< T > &N, const std::vector< T > &Z)
const char *	nc_method_name (NcMethod m)
NcMethod	nc_method_of (const std::string &s)
	Map a method name to its enum; throws UnsupportedError on an unknown one.
void	pfqn_nc_refuse (const std::string &method)
	Refuse a method in an arithmetic it has no meaning in.
template<class T>
NcDispatchResult< T >	pfqn_nc (const std::vector< T > &lambda, const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, NcMethod method, const T &atol, const NcOptions &nopt)
	Normalizing constant of a product-form queueing network: the dispatcher.
template<class T>
NcDispatchResult< T >	pfqn_nc (const std::vector< T > &lambda, const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, NcMethod method, const T &atol)
	Overload with the reference's default sample count, seed and tolerance.
template<class T>
NcDispatchResult< T >	pfqn_nc (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, NcMethod method)
	Overload with the exact (zero-tolerance) filters and no open classes.
template<class T>
NcSanitizeResult< T >	pfqn_nc_sanitize (const std::vector< T > &lambda, const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const T &atol)
	Preprocessing shared by the normalizing-constant solvers: drop the classes that cannot contribute, rescale the demands per class, and order the classes so that the zero-think-time ones come first.
template<class T>
NcSanitizeResult< T >	pfqn_nc_sanitize (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z)
	Overload with the exact (zero-tolerance) tests.
template<class T>
NcResult< T >	pfqn_ncjd (const std::vector< T > &Z, const std::vector< int > &N, const std::vector< OiRate< T > > &mu, const Matrix< T > &visits)
template<class T>
NcResult< T >	pfqn_ncjd (const std::vector< T > &Z, const std::vector< int > &N, const std::vector< OiRate< T > > &mu)
const char *	ncld_method_name (NcldMethod m)
NcldMethod	ncld_method_of (const std::string &s)
	Map a method name to its enum; throws UnsupportedError on an unknown one.
void	pfqn_ncld_refuse (const std::string &method)
	Refuse a load-dependent method in an arithmetic it has no meaning in.
template<class T>
NcldResult< T >	pfqn_ncld (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const Matrix< T > &mu, NcldMethod method, const T &atol, const NcOptions &nopt)
	Normalizing constant of a LOAD-DEPENDENT closed network: the dispatcher.
template<class T>
NcldResult< T >	pfqn_ncld (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const Matrix< T > &mu, NcldMethod method, const T &atol)
	Overload with the reference's default sample count, seed and tolerance.
template<class T>
NcldResult< T >	pfqn_ncld (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const Matrix< T > &mu)
	Overload with the exact (zero-tolerance) filters.
template<class T>
NcldmxResult< T >	pfqn_ncldmx (const std::vector< T > &lambda, const Matrix< T > &D, const std::vector< int > &N, const Matrix< T > &Z, const Matrix< T > &mu, NcldMethod method, const T &atol, const NcOptions &nopt)
	Normalizing constant of a MIXED open/closed network with limited load dependence.
template<class T>
NcldmxResult< T >	pfqn_ncldmx (const std::vector< T > &lambda, const Matrix< T > &D, const std::vector< int > &N, const Matrix< T > &Z, const Matrix< T > &mu)
	Overload with the exact (zero-tolerance) filters and default sampling options.
template<class T>
NcResult< T >	pfqn_ncoi (const std::vector< T > &Z, const std::vector< int > &N, const std::vector< OiRate< T > > &mu, const Matrix< T > &visits)
	Normalizing constant of a closed network of ORDER-INDEPENDENT (OI) / pass-and-swap stations with empty swap graph, plus one aggregated delay.
template<class T>
NcResult< T >	pfqn_ncoi (const std::vector< T > &Z, const std::vector< int > &N, const std::vector< OiRate< T > > &mu)
	Overload with unit visits.
template<class T>
NintMvaResult< T >	pfqn_nintmva (const std::vector< T > &L, const T &N, const T &Z)
	Mean value analysis at a nonintegral population (fractional-base aMVA).
template<class T>
NintMvaResult< T >	pfqn_nintmva (const std::vector< T > &L, const T &N)
	MATLAB default: no think time.
template<class T>
PfqnNreResult< T >	pfqn_nre_full (const Matrix< T > &L0, const std::vector< T > &N, const std::vector< T > &Z, const Matrix< T > &alpha0, const std::vector< T > &vfix)
	Saddle-tilted Edgeworth approximation of log G for a limited load-dependent model: the full form of the reference's outputs, named alike in the JAR and the native python port.
template<class T>
T	pfqn_nre (const Matrix< T > &L0, const std::vector< T > &N, const std::vector< T > &Z, const Matrix< T > &alpha0)
	Saddle-tilted Edgeworth approximation of log G for a limited load-dependent model.
template<class T>
T	pfqn_nrl (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z, const Matrix< T > &alpha)
	Norlund-Rice logit approximation of log G.
template<class T>
T	pfqn_nrp (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z, const Matrix< T > &alpha)
	Norlund-Rice probit approximation of log G.
template<class T>
OiFncResult< T >	pfqn_oi_fnc (const std::vector< T > &Phi, const std::vector< int > &N, const std::function< T(const std::vector< int > &)> &f)
	Order-independent (OI) functional server: the balance function Psi and the rate mu_f of an auxiliary station whose insertion turns the mean of a queue-dependent function into a ratio of normalizing constants.
template<class T>
OiFncResult< T >	pfqn_oi_fnc (const std::vector< T > &Phi, const std::vector< int > &N)
template<class T>
OiInsvcResult< T >	pfqn_oi_insvc (const std::function< T(const std::vector< int > &)> &oirate, const std::vector< int > &N)
	Conditional mean number of IN-SERVICE jobs per class at an order-independent station.
template<class T>
PasIsResult< T >	pfqn_oi_is (const std::vector< int > &N, const std::vector< OiRateFun< T > > &mu, std::size_t samples, McRng &rng, bool want_qlen=true)
	Importance-sampling estimate of the normalizing constant of a closed two-station order-independent (OI) tandem.
template<class T>
PasIsResult< T >	pfqn_oi_is (const std::vector< int > &N, const std::vector< OiRateFun< T > > &mu, McRng &rng, bool want_qlen=true)
	Reference default of 1e4 samples.
template<class T>
AmvaResult< T >	pfqn_pam (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z, PamVariant variant=PamVariant::Basic)
	Hsieh-Lam Proportional Approximation Methods (PAMB / PAMI / PAMT).
template<class T>
AmvaResult< T >	pfqn_pam (const Matrix< T > &L, const std::vector< T > &N)
template<class T>
PanaceaResult< T >	pfqn_panacea (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, int terms)
	PANACEA normal-usage asymptotic expansion of the normalizing constant (Ramakrishnan and Mitra, BSTJ 61(10):2849-2872, 1982).
template<class T>
PanaceaResult< T >	pfqn_panacea (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z)
template<class T>
PanaceaLdResult< T >	pfqn_panaceald (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const Matrix< T > &mu, int terms)
	PANACEA normal-usage asymptotic expansion for LOAD-DEPENDENT closed networks (Mitra and McKenna, JACM 33(3):568-592, 1986).
template<class T>
PanaceaLdResult< T >	pfqn_panaceald (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const Matrix< T > &mu)
	Overload at the reference's default of three terms.
Matrix< int >	pas_placement (const Matrix< int > &H)
	matlab/src/api/pfqn/pas_placement.m: transitive closure of the "must precede" relation.
template<class T>
PasIsResult< T >	pfqn_pas_is (const std::vector< int > &N, const std::vector< OiRateFun< T > > &mu, const Matrix< int > &H, std::size_t samples, McRng &rng, bool want_qlen=true)
	Importance-sampling estimate of the normalizing constant of a single communicating class of a cyclic two-station pass-and-swap (P&S) network with swap graph H.
template<class T>
PasIsResult< T >	pfqn_pas_is (const std::vector< int > &N, const std::vector< OiRateFun< T > > &mu, const Matrix< int > &H, McRng &rng, bool want_qlen=true)
	Reference default of 1e4 samples.
template<class T>
NcResult< T >	pfqn_pas_nc (const std::vector< T > &Z, const std::vector< int > &N, const std::vector< OiRate< T > > &mu, const std::vector< PlacementOrder > &prec)
	Normalizing constant G_C of one communicating class of a closed PASS-AND-SWAP (P&S) network, plus one aggregated delay.
template<class T>
NcResult< T >	pfqn_pas_nc (const std::vector< T > &Z, const std::vector< int > &N, const std::vector< OiRate< T > > &mu)
	Plain OI case (no placement order); prefer pfqn_ncoi, which is cheaper.
template<class T>
PbhBounds< T >	pfqn_pbh (const std::vector< T > &L, int N, const T &Z, int level)
	Performance Bound Hierarchy (Eager and Sevcik 1983, ACM TOCS 1(2):99-115) for single-class closed product-form networks, and the two iterative families that are defined in terms of it.
template<class T>
PbhBounds< T >	pfqn_pbh (const std::vector< T > &L, int N, const T &Z)
template<class T>
PbhBounds< T >	pfqn_pbk (const std::vector< T > &L, int N, const T &Z, int k)
	PB(k), the iterative Eager-Sevcik proportional bound.
template<class T>
PbhBounds< T >	pfqn_pbk (const std::vector< T > &L, int N, const T &Z)
template<class T>
PbhBounds< T >	pfqn_bjbk (const std::vector< T > &L, int N, const T &Z, int k)
	BJB(k), the iterative Balanced Job Bound.
template<class T>
PbhBounds< T >	pfqn_bjbk (const std::vector< T > &L, int N, const T &Z)
template<class T>
T	pfqn_perm (const Matrix< T > &A, const std::vector< int > &m)
	Permanent of a matrix with repeated columns, by Ryser's formula.
template<class T>
T	pfqn_pff_delay (const std::vector< T > &Z, const std::vector< int > &n)
	Product-form factor of a delay station.
template<class T>
ProcomomResult< T >	pfqn_procomom (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const T &atol)
	Marginal queue-length distributions of every station.
template<class T>
ProcomomResult< T >	pfqn_procomom (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z)
	Overload with the reference's default tolerance.
template<class T>
Procomom2Result< T >	pfqn_procomom2 (const std::vector< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const std::vector< T > &mu, int m)
	Queue-plus-delay marginal by the transfer-matrix form of ProCoMoM.
template<class T>
Procomom2Result< T >	pfqn_procomom2 (const std::vector< T > &L, const std::vector< int > &N, const std::vector< T > &Z)
	Overload with the load-independent, unit-multiplicity defaults.
template<class T>
PropfairResult< T >	pfqn_propfair (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z)
	Proportionally fair allocation estimate of the normalizing constant (Schweitzer 1979; Walton, "Proportional fairness and its relationship with multi-class queueing networks", 2009).
template<class T>
QdAmvaResult< T >	pfqn_qdamva (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z, const Matrix< T > &mu, const Matrix< T > &Q0, double tol=1e-6, std::size_t maxiter=10000)
	QD-AMVA: queue-dependent approximate mean value analysis.
template<class T>
QdLinResult< T >	pfqn_qdlin (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z, const Matrix< T > &mu, const std::vector< double > &nservers, double tol=1e-6, std::size_t maxiter=1000, double wtol=1e-4)
	QD-LIN: the Linearizer arm of AMVA-LD, on a plain demand matrix.
template<class T>
QdLinResult< T >	pfqn_qdlin (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z, double tol=1e-6, std::size_t maxiter=1000, double wtol=1e-4)
	Overload without a load-dependent lattice or explicit server counts.
template<class T>
QlenJointMomentsResult< T >	pfqn_qlen_joint_moments (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const std::vector< std::pair< std::size_t, std::size_t > > &pairs, QlenJointRoute route, const QlenJointLgSource< T > &lGsrc, NcMethod method, const NcOptions &nopt)
	Joint moments of the queue-length vector of a closed product-form network, obtained from normalizing constants.
template<class T>
QlenJointMomentsResult< T >	pfqn_qlen_joint_moments (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z)
	MATLAB defaults: every coordinate, the automatic route, no injected source.
template<class T>
QlenJointMomentsResult< T >	pfqn_qlen_joint_moments (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const std::vector< std::pair< std::size_t, std::size_t > > &pairs)
	MATLAB defaults with an explicit coordinate list.
template<class T>
AmvaResult< T >	pfqn_qsa (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z, const std::vector< AmvaSched > &type, double tol=1e-10, std::size_t maxiter=100, int levels=3)
	Queue-Shift Approximation (QSA) for closed product-form networks.
template<class T>
AmvaResult< T >	pfqn_qsa (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z)
template<class T>
AmvaResult< T >	pfqn_qsa (const Matrix< T > &L, const std::vector< T > &N)
template<class T>
T	pfqn_qzgblow (const std::vector< T > &L, const T &N, const T &Z, std::size_t i)
	Qgb = y/(1-y) - y^(N+1)/(1-y) with y = N L_i / (Z + sum(L) + Lmax N).
template<class T>
T	pfqn_qzgbup (const std::vector< T > &L, const T &N, const T &Z, std::size_t i)
	As the lower bound, with Y from the ABA upper bound and the sigma term.
template<class T>
RdResult< T >	pfqn_rd (const Matrix< T > &L0, const std::vector< int > &N, const Matrix< T > &Z, const Matrix< T > &mu0, double tol, NcMethod method)
	Reduction heuristic (RD) for the normalizing constant of a closed LOAD-DEPENDENT product-form network.
template<class T>
RdResult< T >	pfqn_rd (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const Matrix< T > &mu)
	Reference defaults: tol 1e-6, and the exact convolution for the reduced load-independent constant.
template<class T>
NcResult< T >	pfqn_recal (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const std::vector< int > &m0)
	RECAL (REcursive CALculation) for the exact normalizing constant of a closed product-form network (Conway and Georganas 1986).
template<class T>
NcResult< T >	pfqn_recal (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z)
	Overload with unit station multiplicities.
template<class T>
NcResult< T >	pfqn_recal (const Matrix< T > &L, const std::vector< int > &N)
	Overload without think times.
template<class T>
ResptPsMomentsResult< T >	pfqn_respt_ps_moments (const std::vector< T > &S, const std::vector< long > &N, const std::vector< T > &Z, ResptPsRoute route)
	Sojourn-time moments at the processor-sharing station of a closed terminal-driven system (Mitra and Morrison 1983).
template<class T>
ResptPsMomentsResult< T >	pfqn_respt_ps_moments (const std::vector< T > &S, const std::vector< long > &N, const std::vector< T > &Z)
	MATLAB default: the automatic route.
template<class T>
RgfResult< T >	pfqn_rgf (const std::vector< T > &L, int N, const T &Z)
	Recursion by Generating Functions (RGF) for the normalizing constant of a SINGLE-CLASS closed product-form network with replicated stations.
template<class T>
RgfResult< T >	pfqn_rgf (const std::vector< T > &L, int N)
	Overload without a delay.
template<class T>
RgfmcResult< T >	pfqn_rgfmc (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const T &tol, std::size_t maxterms, const T &maxcancel)
	Multiclass Recursion by Generating Functions (RGF), with think times.
template<class T>
RgfmcResult< T >	pfqn_rgfmc (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z)
	Overload with the reference defaults (tol 1e-12, 1e6 terms, 15 nats).
template<class T>
LinearizerResult< T >	pfqn_scat (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const std::vector< SchedStrategy > &type, double tol, int maxiter, const Matrix< T > &QN0)
	Neuse-Chandy SCAT (Self-Correcting Approximation Technique) approximate MVA.
template<class T>
LinearizerResult< T >	pfqn_scat (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z)
template<class T>
LinearizerResult< T >	pfqn_scat (const Matrix< T > &L, const std::vector< int > &N)
template<class T>
ScbBounds< T >	pfqn_scb (const std::vector< T > &L, long N)
	Bracket on the throughput and the per-device utilizations of the UNKNOWN multiclass system whose single-class counterpart has demands L at population N.
template<class T>
T	pfqn_scbgap (long N, long K, long r, bool undominated)
	Demand-free bound on the relative throughput error incurred when r of the N single-customer classes are merged into one class.
template<class T>
T	pfqn_scbgap (long N, long K)
	Full single-class aggregation: r = N, dominating classes allowed.
template<class T>
T	pfqn_usumbound (long R, long K, long N)
	Largest value the sum of device utilizations can take in any closed product-form network with R classes, K devices and N customers (Theorem 6): sum_k U_k,R <= (H-1) + (K-H+1)(N-H+1)/(K+N-2H+1), H = min(R,K).
template<class T>
long	pfqn_minclasses (const T &Usum, long K, long N)
	Smallest number of customer classes R consistent with an observed sum of device utilizations, by inverting the nondecreasing pfqn_usumbound.
template<class T>
SchmidtResult< T >	pfqn_schmidt (const Matrix< T > &D, const std::vector< int > &N, const Matrix< int > &S, const std::vector< SchedStrategy > &sched, const Matrix< T > &v)
	Schmidt's MVA for closed networks with general scheduling disciplines and class-dependent multiserver FCFS stations.
template<class T>
SchmidtResult< T >	pfqn_schmidt (const Matrix< T > &D, const std::vector< int > &N, const Matrix< int > &S, const std::vector< SchedStrategy > &sched)
	Unit visit ratios, the MATLAB default.
template<class T>
SchmidtExtResult< T >	pfqn_schmidt_ext (const Matrix< T > &D, const std::vector< int > &N, const Matrix< int > &S, const std::vector< SchedStrategy > &sched)
	Extended Schmidt MVA with queue-aware alpha corrections.
SdrCoeff	pfqn_sdrcoeff (const SdrStruct &sdr)
	Validates an SDR structure and returns its derived coefficients.
std::vector< double >	pfqn_sdrprob (const SdrCoeff &c, const std::vector< double > &n)
	SDR routing probabilities of eq.
double	pfqn_sdrped (const std::vector< double > &P)
	Probability of being denied entry and routed straight to the departure centre.
template<class T>
SdrResult< T >	pfqn_sdr (const Matrix< T > &S, const Matrix< T > &xi, const std::vector< std::size_t > &N, const SdrStruct &sdr, const Matrix< T > &alpha=Matrix< T >())
	Exact product form of eq.
template<class T>
SdrResult< T >	pfqn_sdrmva (const Matrix< T > &S, const Matrix< T > &xi, const std::vector< std::size_t > &N, const SdrStruct &sdr, const Matrix< T > &alpha=Matrix< T >())
	Section 4 mean value analysis and convolution.
template<class T>
Matrix< T >	pfqn_sdrvisits (const SdrStruct &sdr, const std::vector< Matrix< T > > &P)
	Coefficients xi of Section 3.2.
template<class T>
SensResult< T >	pfqn_sens_dmva (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const std::vector< int > &mi)
	Forward-mode differentiation of the exact MVA recursion.
template<class T>
SensResult< T >	pfqn_sens_comom (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z)
	CoMoM-backed kernel for the repairman model (M = 1).
template<class T>
SensResult< T >	pfqn_sens (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const std::vector< int > &mi)
	Exact analytic derivatives of the mean performance measures {X,Q,U,R} of a closed product-form (BCMP) network with respect to the demands L(i,r) and the think times Z(r).
template<class T>
SensResult< T >	pfqn_sens (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z)
	pfqn_sens with unit multiplicities.
template<class T>
SensLdmxEcResult< T >	pfqn_sens_ldmx_ec (const std::vector< T > &lambda, const Matrix< T > &D, const Matrix< T > &mu)
	Effective capacity terms of the mixed load-dependent MVA of Bruell-Balbo-Afshari, together with their exact derivatives with respect to the open-class load Lo(i) of each station.
template<class T>
SensLinearizerResult< T >	pfqn_sens_linearizer (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const T *tol, unsigned maxiter)
	Approximate moments E[Q_i], Var[Q_i], Cov[Q_i,Q_j], E[Q_i^2] and E[Q_i^3] of the per-station total queue lengths of a closed product-form network, by the LINEARIZER-2 / LINEARIZER-3 algorithms of Strelen (Performance Evaluation 11:127-142, 1990, Section 5).
template<class T>
SensLinearizerResult< T >	pfqn_sens_linearizer (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z)
	pfqn_sens_linearizer with the defaults of the reference.
template<class T>
SensMomResult< T >	pfqn_sens_mom (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const std::vector< int > &mi, const std::vector< int > &groups)
	Exact moments E[Q], Var[Q], E[Q^2] and E[Q^3] of the grouped queue lengths of a closed product-form network, by second-order differentiation of the MVA recursion.
template<class T>
SensMomResult< T >	pfqn_sens_mom (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z)
	pfqn_sens_mom with unit multiplicities and per-station totals.
std::vector< std::size_t >	sens_lattice_radix (const std::vector< int > &N)
	Radix weights of the MVA population lattice, class R-1 varying fastest.
std::vector< int >	sens_lattice_decode (std::size_t k, const std::vector< int > &N, const std::vector< std::size_t > &radix)
	Decode a lattice index back into a population vector.
template<class T>
SensMvaResult< T >	pfqn_sens_mva (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z, const std::vector< int > &mi)
	Exact per-station queue-length variances and covariances of a closed product-form network, by the MVA-like moment recursion of de Souza e Silva and Muntz (IEEE TC 37(9):1125-1129, 1988, Corollary 1).
template<class T>
SensMvaResult< T >	pfqn_sens_mva (const Matrix< T > &L, const std::vector< int > &N, const std::vector< T > &Z)
	pfqn_sens_mva with unit multiplicities.
template<class T>
SensMvaldmxResult< T >	pfqn_sens_mvaldmx (const std::vector< T > &lambda, const Matrix< T > &D, const std::vector< int > &N, const std::vector< T > &Z, const Matrix< T > &mu)
	Exact queue-length variances and covariances of a mixed open/closed product-form network with limited load dependence, the load-dependent and mixed counterpart of pfqn_sens_mva.
template<class T>
SensResptResult< T >	pfqn_sens_respt (const std::vector< T > &S, const Matrix< T > &V, const std::vector< int > &N, const std::vector< T > &Z, const std::vector< int > &b, int tmax)
	Exact raw moments E[W^t], t = 1..3, of the sojourn time of a job at an FCFS b-server center of a closed product-form network.
template<class T>
SensResptResult< T >	pfqn_sens_respt (const std::vector< T > &S, const Matrix< T > &V, const std::vector< int > &N, const std::vector< T > &Z)
	pfqn_sens_respt with single servers and moments up to order three.
template<class T>
SibBounds< T >	pfqn_sib (const std::vector< T > &L, int N, const T &Z, int level)
	Successively Improving Bounds (Srinivasan 1985/1987) on the cycle time and throughput of a single-class closed product-form network.
template<class T>
SibBounds< T >	pfqn_sib (const std::vector< T > &L, int N, const T &Z)
SjnResult	pfqn_mvasjn (const Matrix< double > &L, const std::vector< double > &N, const std::vector< double > &Z, const Matrix< double > &scv, const std::vector< std::size_t > &sjnset, const Matrix< double > &V, const SjnOptions &options)
	Exact-lattice MVA for closed networks with SJN stations, the unidirectional scheme of Kant 1992.
SjnResult	pfqn_amvasjn (const Matrix< double > &L, const std::vector< double > &N, const std::vector< double > &Z, const Matrix< double > &scv, const std::vector< std::size_t > &sjnset, const Matrix< double > &V, const SjnOptions &options)
	Schweitzer fixed point counterpart of pfqn_mvasjn.
template<class T>
SqniResult< T >	pfqn_sqni (const std::vector< T > &N, const std::vector< T > &L, const std::vector< T > &Z)
	Square-root non-iterative (SQNI) approximation for a single queueing station with per-class delay.
template<class T>
SsdBounds< T >	pfqn_ssd (const std::vector< T > &L, const T &N, const T &Z, const std::vector< T > &nservers)
	Server-Station Disaggregation bounds for a multiserver closed network (Dallery and Suri, SIGMETRICS 1986).
template<class T>
SsdBounds< T >	pfqn_ssd (const std::vector< T > &L, const T &N, const T &Z)
template<class T>
StdfResult< T >	pfqn_stdf (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const std::vector< int > &S, const std::vector< std::size_t > &fcfsNodes, const Matrix< T > &rates, const std::vector< T > &tset)
	Sojourn-time distribution at the listed FCFS stations.
template<class T>
StdfResult< T >	pfqn_stdf_heur (const Matrix< T > &L, const std::vector< int > &N, const Matrix< T > &Z, const std::vector< int > &S, const std::vector< std::size_t > &fcfsNodes, const Matrix< T > &rates, const std::vector< T > &tset)
	Heuristic sojourn-time distribution at the listed FCFS stations.
template<class T>
AmvaResult< T >	pfqn_tay (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z, double tol=1e-6, std::size_t maxiter=1000, const Matrix< T > &QN0=Matrix< T >())
	Tay's arrival-instant approximate MVA.
template<class T>
AmvaResult< T >	pfqn_tay (const Matrix< T > &L, const std::vector< T > &N)
template<class T>
UniqueResult< T >	pfqn_unique (const Matrix< T > &L, const Matrix< T > &mu, const Matrix< T > &gamma)
	Merge stations whose (L, mu, gamma) rows are exactly equal.
template<class T>
UniqueResult< T >	pfqn_unique (const Matrix< T > &L)
std::vector< int >	pfqn_combine_mi (const std::vector< int > &mi, const std::vector< std::size_t > &mapping, std::size_t M_unique)
	Fold a caller-supplied multiplicity vector along a consolidation mapping.
template<class T>
WsResult< T >	pfqn_wangsevcik (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z, WsScheme scheme, double tol=1e-6, std::size_t max_iter=1000)
	One approximate MVA sweep, by the chosen arrival-queue correction.
template<class T>
WsResult< T >	pfqn_qli (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z, double tol=1e-6, std::size_t max_iter=1000)
	Wang-Sevcik Queue-Line.
template<class T>
WsResult< T >	pfqn_fli (const Matrix< T > &L, const std::vector< T > &N, const std::vector< T > &Z, double tol=1e-6, std::size_t max_iter=1000)
	Wang-Sevcik Fraction-Line.
template<class T>
T	pfqn_xia (const std::vector< T > &L, int N, const std::vector< T > &s)
	Xia's asymptotic approximation of the normalizing constant of a load-dependent (multiserver) closed network.
template<class T>
T	pfqn_xzabalow (const std::vector< T > &L, const T &N, const T &Z)
	X >= N / (Z + N sum(L)), the ABA population bound.
template<class T>
T	pfqn_xzabaup (const std::vector< T > &L, const T &N, const T &Z)
	X <= min(1/Lmax, N/(sum(L)+Z)): capacity bound and population bound.
template<class T>
T	pfqn_xzgsblow (const std::vector< T > &L, const T &N, const T &Z)
	X = 2N / (R + sqrt(R^2 - 4 Z Lmax (N-1))), R from the geometric queue bound.
template<class T>
T	pfqn_xzgsbup (const std::vector< T > &L, const T &N, const T &Z)
	X = 2N / (R + sqrt(R^2 - 4 Z Lmax N)), R from the geometric queue bound.

Variables
constexpr double	PFQN_BUSYP_DEFAULT_TOL = 1e-12
	Default relative tolerance of the open-network tail truncation.
constexpr int	cftp_inf_servers = -1
	Sentinel for an infinite-server (delay) station, the reference's S = Inf.
constexpr long	CUB_V_STEPS = 10000
	The v-quadrature grid size of pfqn_cub; must match steps in pfqn_cub.h.
constexpr double	CUB_MAX_EVALS = 1e7
	GlobalConstants.CubMaxEvals: the integrand-evaluation budget above which pfqn_nc lowers the cubature order (and, at order 0, prefers le over cub).
constexpr int	kOpenClass = -1
	Population sentinel marking an open class, standing in for MATLAB's Inf.
constexpr std::size_t	MCMC_DEFAULT_BATCHES = 30
	Schmeiser (1982), the batch count used in the tables of the paper.
constexpr double	MCMC_DEFAULT_BURNIN = 0.1
	Warm-up fraction discarded before accumulation starts.
constexpr int	OPEN_CLASS = -1
	Marks an open (infinite-population) class in a population vector.
constexpr int	INF_SERVERS = -1
	Marks an infinite-server station in a server-count vector.
static const double	kStdfFineTol = 1e-8
	GlobalConstants.FineTol, as set by matlab/lineStart.m.

Typedef Documentation

AghqResult

template<class T>

using line::pfqn::AghqResult = LeResult<T>

Definition at line 56 of file pfqn_aghq.h.

BktResult

template<class T>

using line::pfqn::BktResult = KtResult<T>

Return value of pfqn_bkt, mirroring [Gn, lGn] (X and Q are pfqn_kt's seeds).

Definition at line 58 of file pfqn_bkt.h.

BleResult

template<class T>

using line::pfqn::BleResult = LeResult<T>

Return value of pfqn_ble, mirroring [Gn, lGn].

Definition at line 47 of file pfqn_ble.h.

CdScaling

template<class T>

using line::pfqn::CdScaling = std::function<std::vector<T>(const std::vector<T>&)>

A per-station class-dependence callable: the population row -> 1 or R rates.

Definition at line 45 of file pfqn_cdfun.h.

JdScaling

template<class T>

using line::pfqn::JdScaling = std::function<std::vector<T>(const std::vector<T>&)>

A per-station joint-dependence callable: the population row -> 1 or R rates.

Definition at line 48 of file pfqn_jdfun.h.

McRng

using line::pfqn::McRng = std::mt19937_64

The generator type every Monte Carlo entry point in this tree accepts.

Definition at line 62 of file pfqn_mc_common.h.

OiRate

template<class T>

using line::pfqn::OiRate = std::function<T(const std::vector<int>&)>

An OI station's total service rate as a function of the occupancy vector.

Definition at line 61 of file pfqn_ncoi.h.

OiRateFun

template<class T>

using line::pfqn::OiRateFun = std::function<T(const std::vector<int>&)>

The OI rank rate of a station as a function of the per-class COUNT vector: the svcRateFun of an OI / P&S node.

The argument is the (R) vector of job counts of the prefix, exactly the occ row the MATLAB handles receive. OI property P1 makes mu permutation-invariant, i.e. a function of the counts; it is NOT in general a function of the support alone (an INF station has mu(n) = sum_r n_r sigma_r).

Definition at line 79 of file pfqn_pas_is.h.

PasRateFun

template<class T>

using line::pfqn::PasRateFun = std::function<T(const std::vector<int>&)>

Total service rate of a queue on an ordered prefix of classes (1-based).

Definition at line 61 of file pas_swap2order.h.

PlacementOrder

using line::pfqn::PlacementOrder = std::vector<std::vector<int>>

Placement order of one station: prec[i][j] != 0 iff class i must be placed before class j.

This is the precedence closure of pas_placement, fed by the global DAG of pas_swap2order.

Definition at line 60 of file pfqn_pas_nc.h.

QlenJointLgSource

template<class T>

using line::pfqn::QlenJointLgSource

Initial value:

 
std::function<std::vector<double>(const Matrix<T>&, const std::vector<std::vector<int>>&)>

Injected source of log G.

Invoked ONCE per network as lGsrc(Lsub, pops), pops being a list of populations; it must return one value per population and may return NaN where it cannot serve, which is then filled in by pfqn_nc. The 'pmf' route queries the COMPLEMENTARY network, so a source must answer for whichever demand matrix it is handed.

Definition at line 121 of file pfqn_qlen_joint_moments.h.

Enumeration Type Documentation

AbMarginalMethod

enum class line::pfqn::AbMarginalMethod

strong

Which marginal-probability rule the multiserver correction uses.

Enumerator
Ab	the Akyildiz-Bolch weight function
Scat	two-point scatter around floor(Qtot)

Definition at line 84 of file pfqn_ab_amva.h.

AmvaSched

enum class line::pfqn::AmvaSched

strong

Station scheduling as far as the AMVA formulas distinguish it.

INF marks a delay centre; pfqn_bs only distinguishes FCFS, pfqn_qsa needs it.

Enumerator
PS
FCFS
INF

Definition at line 45 of file pfqn_bs.h.

CftpMethod

enum class line::pfqn::CftpMethod

strong

Which sampler to run.

Enumerator
Cftp	exact, monotone coupling from the past
Approx	the rapidly-mixing approximate sampler M_A

Definition at line 70 of file pfqn_cftp.h.

ChowVariant

enum class line::pfqn::ChowVariant

strong

Which finite difference of the LCP solution estimates the theta-terms.

Enumerator
Forward
Backward

Definition at line 46 of file pfqn_chow.h.

ClustInner

enum class line::pfqn::ClustInner

strong

Which algorithm runs inside a subnetwork.

Enumerator
Linearizer
ProportionalEstimation

Definition at line 61 of file pfqn_clust.h.

LinearizerMxMethod

enum class line::pfqn::LinearizerMxMethod

strong

Which Linearizer variant solves the closed subnetwork.

Enumerator
Lin
Gflin
Egflin

Definition at line 87 of file pfqn_linearizermx.h.

MciVariant

enum class line::pfqn::MciVariant

strong

The proposal-rate rules the reference selects between.

Enumerator
Imci	gamma = max(0.01, 1 - U), the MonteQueue 2.0 recommendation
Mci	gamma = 1/sqrt(max N) where U > 0.9, else 1 - U
Rm	repairman: a single station, rates from the balanced bound

Definition at line 76 of file pfqn_mci.h.

MwrbbSched

enum class line::pfqn::MwrbbSched

strong

Station discipline codes, matching the MATLAB sched argument.

Enumerator
Fifo
Ps
PrioNonPreemptive
PrioPreemptive
Aba

Definition at line 48 of file pfqn_mwrbb.h.

NcldMethod

enum class line::pfqn::NcldMethod

strong

The load-dependent methods this port dispatches.

Enumerator
Default
Exact
Is
Clw
Panald
Rd
Nrp
Nrl
Nre
Comomld
Divdiff

Definition at line 87 of file pfqn_ncld.h.

NcMethod

enum class line::pfqn::NcMethod

strong

The methods this port dispatches, one per compute_norm_const case.

Enumerator
Default
Adaptive	the reference groups 'adaptive' with 'default'
Ca
Exact
Recal
Mva
Comom
Clw
Cub
Gm	the reference's alias of 'cub'
Kt
Bkt	KT minus the exact Stirling remainder of each Laplaced class (BKT).
Lekt	the estimator Ble and Bkt both compute, on the cheaper side
Bk	Birman-Kogan saddle point with bottleneck detection.
Bkue	Birman-Kogan uniform (van der Waerden) expansion, single chain.
Lc	Birman-Kogan Algorithm 2, single chain subproblems by MVA.
LcUe	Algorithm 2 with the uniform expansion as the single chain solver.
Le
Ble	LE plus the empirical eps->0 correction.
Aghq	adaptive Gauss-Hermite over the simplex; q=1 is Le
Ls
Is
Mci
Imci
Mcmc	Chen-O'Cinneide regularization; supplies X and Q, never a constant.
Sampling
Mmint2
Gleint	the reference's alias of 'mmint2'
Pana
Propfair
Rgf	recursion by generating functions; residues beyond one class
Divdiff	divided-difference closed form; no think time, no load dependence
Ger	residue closed form; free in the eliminated class populations

Definition at line 101 of file pfqn_nc.h.

PamVariant

enum class line::pfqn::PamVariant

strong

Which of the three proportional approximations to run.

Enumerator
Basic
Improved
Two

Definition at line 46 of file pfqn_pam.h.

QlenJointRoute

enum class line::pfqn::QlenJointRoute

strong

Which survival-array identity is used.

Enumerator
Auto	tail for a single class, pmf otherwise
Tail	the geometric single-class identity
Pmf	the complementary-network joint law

Definition at line 86 of file pfqn_qlen_joint_moments.h.

ResptPsMethod

enum class line::pfqn::ResptPsMethod

strong

Which route produced the moments of a given class.

Enumerator
None	the class is unpopulated
Exact	Proposition 3, the linear solve.
Asymptotic	Proposition 6, the two-term expansion.
Unavailable	normal usage fails and the exact route was not affordable

Definition at line 75 of file pfqn_respt_ps_moments.h.

ResptPsRoute

enum class line::pfqn::ResptPsRoute

strong

Requested route.

Enumerator
Auto
Exact
Asymptotic

Definition at line 83 of file pfqn_respt_ps_moments.h.

SchedStrategy

enum class line::pfqn::SchedStrategy

strong

The three scheduling disciplines the AMVA and Schmidt recursions branch on.

Enumerator
PS
FCFS
INF

Definition at line 37 of file pfqn_amva_common.h.

WsScheme

enum class line::pfqn::WsScheme

strong

Which arrival-queue correction the sweep applies.

Enumerator
Qli
Fli

Definition at line 80 of file pfqn_wangsevcik.h.

Function Documentation

bk_erfcx()

double line::pfqn::bk_erfcx ( double x )

inline

Scaled complementary error function exp(x^2)*erfc(x) for x >= 0.

The direct product overflows past x ~ 26, where the asymptotic series is already exact to double precision.

Definition at line 405 of file pfqn_bk.h.

References bk_erfcx().

Referenced by bk_erfcx(), and pfqn_bkue().

cd_peak_scaling()

template<class T>

T line::pfqn::cd_peak_scaling	(	const std::function< std::vector< T >(const std::vector< int > &)> &	beta,
		const std::vector< int > &	NK )

Peak of a class-dependence handle over the reachable population lattice.

Parameters

beta	class-dependence handle, evaluated on a per-class count vector
NK	(R) per-class population bound

Definition at line 53 of file cd_peak_scaling.h.

References cd_peak_scaling(), line::InputError::InputError(), and line::next_pop().

Referenced by cd_peak_scaling(), and line::fes::fes_aggregate().

enorm()

template<class T>

T line::pfqn::enorm

(

const Matrix< T > &

A

)

matlab/src/util/enorm.m: Frobenius norm of a matrix.

Definition at line 56 of file pfqn_amva_common.h.

References line::Matrix< T >::cols(), enorm(), and line::Matrix< T >::rows().

Referenced by enorm().

enorm_diff()

template<class T>

double line::pfqn::enorm_diff	(	const Matrix< T > &	A,
		const Matrix< T > &	B )

Frobenius norm of the difference of two equally shaped matrices, AS A DOUBLE.

The only use of this quantity anywhere in the AMVA family is the stopping test enorm_diff(Q, Qlast) < tol, and tol is a double. Returning a double therefore loses nothing and buys the exact backend the whole family: sqrt is not an operation of the rational field, so a T-valued version cannot be instantiated there at all. The sum of squares is accumulated in T, exactly, and only the final square root drops to double, so for T == double the result is bit-identical to sqrt of the T-valued sum.

Definition at line 76 of file pfqn_amva_common.h.

References line::Matrix< T >::cols(), enorm_diff(), and line::Matrix< T >::rows().

Referenced by enorm_diff().

finish_lap()

template<class T>

T line::pfqn::finish_lap	(	const std::vector< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		const T &	Ntot,
		const T &	u0 )

Assembly of the expansion at the saddle point; defined below.

Definition at line 125 of file pfqn_lap.h.

References finish_lap(), and line::NumericError::NumericError().

Referenced by finish_lap(), and pfqn_lap().

first_composition()

void line::pfqn::first_composition ( std::vector< int > & n, int c )

inline

matlab/src/util/multichoose.m and sprod.m, as an in-place odometer: the compositions of c into R non-negative parts, i.e.

the vectors n with sum(n) == c. Start from first_composition and iterate until this returns false. The enumeration order differs from MATLAB's recursive one; every use site sums over the whole set, so only completeness matters.

Definition at line 108 of file pfqn_amva_common.h.

References first_composition().

Referenced by first_composition().

grnmol()

template<class T>

std::vector< T > line::pfqn::grnmol	(	const std::function< T(const std::vector< T > &)> &	f,
		std::size_t	n,
		int	s,
		const T &	tol )

Grundmann-Moeller rule of degrees 1, 3, ..., 2s+1 over the n-simplex with vertices the columns of the identity (MATLAB's grnmol on V = eye(n,n+1)).

Parameters

f	integrand, evaluated on the n free barycentric coordinates
n	simplex dimension
s	maximum rule order
tol	relative stopping tolerance between consecutive degrees

Returns

the successive estimates, the last of which is the answer

Definition at line 68 of file pfqn_cub.h.

References grnmol(), line::InputError::InputError(), line::num_abs(), line::num_factorial(), and line::num_pow_int().

Referenced by grnmol(), and pfqn_cub().

infradius_h()

template<class T>

T line::pfqn::infradius_h	(	const std::vector< T > &	x,
		const Matrix< T > &	L,
		const std::vector< T > &	N,
		const Matrix< T > &	alpha )

Logistic-substitution integrand (matlab/src/api/pfqn/infradius_h.m).

Parameters

x	point in R^R
L	(M x R) demands
N	(R) population
alpha	(M x Ntot) load-dependent rates

Definition at line 104 of file infradius_h.h.

References line::Matrix< T >::cols(), infradius_h(), line::InputError::InputError(), Lc, and line::Matrix< T >::rows().

Referenced by infradius_h().

infradius_hnorm()

template<class T>

T line::pfqn::infradius_hnorm	(	const std::vector< T > &	x,
		const Matrix< T > &	L,
		const std::vector< T > &	N,
		const Matrix< T > &	alpha )

Normal-CDF substitution integrand (matlab/src/api/pfqn/infradius_hnorm.m).

See the precision note above.

Definition at line 144 of file infradius_h.h.

References line::Matrix< T >::cols(), infradius_hnorm(), line::InputError::InputError(), Lc, and line::Matrix< T >::rows().

Referenced by infradius_hnorm().

is_cntol()

bool line::pfqn::is_cntol ( double tol )

inline

True when tol is the sentinel requesting the Chandy-Neuse test.

Definition at line 72 of file pfqn_cntol.h.

References is_cntol().

Referenced by is_cntol(), pfqn_bs(), and pfqn_egflinearizer().

is_open_class()

bool line::pfqn::is_open_class ( int n )

inline

True when the population entry denotes an open class.

Definition at line 83 of file pfqn_mvams.h.

References is_open_class().

Referenced by is_open_class(), pfqn_mvaldms(), pfqn_mvaldmx(), pfqn_mvams(), pfqn_mvams_ilock(), and pfqn_mvamx().

laplaceapprox()

template<class T>

LaplaceResult< T > line::pfqn::laplaceapprox	(	const std::function< T(const std::vector< T > &)> &	h,
		const std::vector< T > &	x0 )

Laplace approximation of a multidimensional integral around a given point.

Parameters

h	integrand, evaluated as a callable on a d-vector
x0	expansion point

Definition at line 106 of file laplaceapprox.h.

References line::pfqn::LaplaceResult< T >::detNegative, line::pfqn::LaplaceResult< T >::H, line::pfqn::LaplaceResult< T >::I, line::InputError::InputError(), laplaceapprox(), line::pfqn::LaplaceResult< T >::logI, line::num_abs(), line::num_pow_int(), and line::NumericError::NumericError().

Referenced by laplaceapprox().

marie_cd_eval()

template<class T>

std::vector< T > line::pfqn::marie_cd_eval	(	const MarieCdScaling< T > &	cd,
		const std::vector< T > &	nv )

Evaluate a class-dependent scaling at a real-valued population vector (cdscale_eval in the reference): the interpolated ratio, guarded against a non-positive or non-finite value and clamped to [1e-3, 1e3].

Definition at line 319 of file pfqn_marie.h.

References line::pfqn::MarieCdScaling< T >::identity(), marie_cd_eval(), line::pfqn::MarieCdScaling< T >::muCox, line::pfqn::MarieCdScaling< T >::muExp, and line::pfqn::MarieCdScaling< T >::N.

Referenced by marie_cd_eval().

marie_cox_fit()

template<class T>

MarieCoxFit< T > line::pfqn::marie_cox_fit	(	const T &	mean,
		const T &	scv )

Closed-form Coxian fit of a mean and an SCV (matlab/src/lang/processes/Coxian.m, fitMeanAndSCV), with the branch thresholds at CoarseTol = 1e-3.

Parameters

mean	strictly positive mean
scv	strictly positive squared coefficient of variation

Definition at line 120 of file pfqn_marie.h.

References line::InputError::InputError(), marie_cox_fit(), line::pfqn::MarieCoxFit< T >::mu, and line::pfqn::MarieCoxFit< T >::phi.

Referenced by marie_cox_fit(), and pfqn_marie().

matchrow()

int line::pfqn::matchrow ( const std::vector< std::vector< int > > & rows, const std::vector< int > & row )

inline

Position of row in rows, or -1 when absent.

MATLAB's matchrow checks the LAST row first and otherwise returns the first match; with the distinct row sets used here the two rules coincide, and the first-match rule is used.

Definition at line 74 of file pfqn_comb_common.h.

References matchrow().

Referenced by matchrow(), pfqn_comom(), and pfqn_procomom().

mc_exp()

template<class T>

T line::pfqn::mc_exp

(

double

lv

)

exp of a log-domain value, materialized in the working arithmetic.

Overflows to infinity in double exactly where the references do, and stays in range for the high-precision backends.

Definition at line 132 of file pfqn_mc_common.h.

References mc_exp().

Referenced by mc_exp(), pfqn_mci(), and pfqn_mmsample2().

mc_log_factorial()

template<class T>

double line::pfqn::mc_log_factorial

(

long

n

)

log(n!) for a non-negative integer n, the factln / gammaln(1+n) of the references, accumulated in the working arithmetic so the high-precision backends do not lose the digits a double lgamma would drop.

Definition at line 143 of file pfqn_mc_common.h.

References line::InputError::InputError(), mc_log_factorial(), and line::num_factorial().

Referenced by mc_log_factorial(), pfqn_mci(), and pfqn_mmsample2().

mc_logmeanexp()

double line::pfqn::mc_logmeanexp ( const std::vector< double > & v )

inline

log(mean(exp(v))), computed by factoring out the maximum so that the exponentials stay in range.

MATLAB's logmeanexp, which every estimator that averages log-weights calls.

Definition at line 115 of file pfqn_mc_common.h.

References mc_logmeanexp().

Referenced by mc_logmeanexp(), pfqn_ls(), and pfqn_mci().

mc_normal01()

double line::pfqn::mc_normal01 ( McRng & g )

inline

Standard normal deviate by the Box-Muller transform.

Two uniforms are drawn and only the cosine branch is kept, so the routine holds no state between calls: a generator handed to two different estimators cannot be cross-contaminated by a cached second variate.

Definition at line 101 of file pfqn_mc_common.h.

References mc_normal01(), and mc_uniform01().

Referenced by mc_normal01(), and pfqn_ls().

mc_uniform()

template<class T>

T line::pfqn::mc_uniform

(

McRng &

g

)

The same deviate materialized in the working arithmetic.

Definition at line 75 of file pfqn_mc_common.h.

References mc_uniform(), and mc_uniform01().

Referenced by line::mc::ctmc_simulate(), line::infer::infer_gibbs(), mc_uniform(), and line::ctmc::solver_ctmc_sample_sys().

mc_uniform01()

double line::pfqn::mc_uniform01 ( McRng & g )

inline

Uniform deviate on [0,1) with 53 significant bits, as a double.

The top 53 bits of one 64-bit draw are used, so exactly one generator step is consumed per deviate and the mapping is fully specified.

Definition at line 69 of file pfqn_mc_common.h.

References mc_uniform01().

Referenced by line::mam::map_sample(), mc_normal01(), mc_uniform(), mc_uniform01(), line::trace::mtrace_bootstrap(), line::mam::MeSampler< T >::next(), pfqn_cftp(), pfqn_mci(), pfqn_mcmc(), pfqn_mmsample2(), line::mam::randp(), and line::mam::rap_sample().

mc_uniform_int()

std::uint64_t line::pfqn::mc_uniform_int ( McRng & g, std::uint64_t n )

inline

Uniform integer on [0, n), unbiased by rejection.

Consumes one generator step per attempt; the rejection probability is below 2^-64 * n, so for the class counts these estimators use it never rejects in practice.

Definition at line 84 of file pfqn_mc_common.h.

References line::InputError::InputError(), and mc_uniform_int().

Referenced by mc_uniform_int(), pfqn_cftp(), pfqn_ld_is(), and pfqn_pas_is().

multichoose_rows()

std::vector< std::vector< int > > line::pfqn::multichoose_rows ( int n, int k )

inline

All n-vectors of nonnegative integers summing to k, in MATLAB multichoose(n,k) order.

Definition at line 44 of file pfqn_comb_common.h.

References line::InputError::InputError(), and multichoose_rows().

Referenced by line::qn::from_marg_node(), line::qn::from_marg_node_started(), multichoose_rows(), pfqn_mvaoi(), line::qn::space_closed_multi_cs(), and line::qn::space_closed_single().

nc_method_name()

const char * line::pfqn::nc_method_name ( NcMethod m )

inline

Definition at line 137 of file pfqn_nc.h.

References Adaptive, Aghq, Bk, Bkt, Bkue, Ble, Ca, Clw, Comom, Cub, Default, Divdiff, Exact, Ger, Gleint, Gm, Imci, Is, Kt, Lc, LcUe, Le, Lekt, Ls, Mci, Mcmc, Mmint2, Mva, nc_method_name(), Pana, Propfair, Recal, Rgf, and Sampling.

Referenced by nc_method_name(), and pfqn_nc().

nc_method_of()

NcMethod line::pfqn::nc_method_of ( const std::string & s )

inline

Map a method name to its enum; throws UnsupportedError on an unknown one.

Definition at line 177 of file pfqn_nc.h.

References Adaptive, Aghq, Bk, Bkt, Bkue, Ble, Ca, Clw, Comom, Cub, Default, Divdiff, Exact, Ger, Gleint, Gm, Imci, Is, Kt, Lc, LcUe, Le, Lekt, Ls, Mci, Mcmc, Mmint2, Mva, nc_method_of(), Pana, Propfair, Recal, Rgf, Sampling, and line::UnsupportedError::UnsupportedError().

Referenced by nc_method_of().

ncld_method_name()

const char * line::pfqn::ncld_method_name ( NcldMethod m )

inline

Definition at line 91 of file pfqn_ncld.h.

References Clw, Comomld, Default, Divdiff, Exact, Is, ncld_method_name(), Nre, Nrl, Nrp, Panald, and Rd.

Referenced by ncld_method_name(), and pfqn_ncld().

ncld_method_of()

NcldMethod line::pfqn::ncld_method_of ( const std::string & s )

inline

Map a method name to its enum; throws UnsupportedError on an unknown one.

Definition at line 109 of file pfqn_ncld.h.

References Clw, Comomld, Default, Divdiff, Exact, Is, ncld_method_of(), Nre, Nrl, Nrp, Panald, Rd, and line::UnsupportedError::UnsupportedError().

Referenced by ncld_method_of().

next_composition()

bool line::pfqn::next_composition ( std::vector< int > & n )

inline

Definition at line 113 of file pfqn_amva_common.h.

References next_composition().

Referenced by next_composition().

num_multinomial()

template<class T>

T line::pfqn::num_multinomial

(

const std::vector< int > &

m

)

Multinomial coefficient sum(m)!

/prod_i m_i!, exact in any arithmetic.

Definition at line 130 of file pfqn_amva_common.h.

References line::num_factorial(), and num_multinomial().

Referenced by num_multinomial().

oner()

std::vector< int > line::pfqn::oner ( const std::vector< int > & N, std::size_t r )

inline

matlab/src/util/oner.m: decrement position r of N, with r given 1-based and r == 0 meaning "leave N alone" (the s == 0 arm of every for s=0:R loop).

The result may go negative, exactly as in MATLAB; callers that cannot cope with a negative population guard it themselves, as the MATLAB ones do.

Definition at line 45 of file pfqn_amva_common.h.

References line::InputError::InputError(), and oner().

Referenced by oner(), pfqn_conwayms(), pfqn_dmlin(), pfqn_egflinearizer(), and pfqn_linearizerms().

pas_placement() [1/2]

Matrix< int > line::pfqn::pas_placement ( const Matrix< int > & H )

inline

matlab/src/api/pfqn/pas_placement.m: transitive closure of the "must precede" relation.

P(i,j) is true iff class i must be placed before class j. An empty or all-zero H yields the all-false closure, i.e. no constraint.

Definition at line 86 of file pfqn_pas_is.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), pas_placement(), and line::Matrix< T >::rows().

pas_placement() [2/2]

template<class T>

PasPlacement< T > line::pfqn::pas_placement

(

const Matrix< T > &

H

)

Precedence closure of a swap graph.

Parameters

H	(R x R) swap graph; H(b, a) nonzero forces b before a

Definition at line 80 of file pas_placement.h.

References line::Matrix< T >::cols(), line::InputError::InputError(), line::Matrix< T >::Matrix(), line::pfqn::PasPlacement< T >::P, pas_placement(), and line::Matrix< T >::rows().

Referenced by pas_placement(), pas_placement(), and pfqn_pas_is().

pas_swap2order()

template<class T>

Matrix< T > line::pfqn::pas_swap2order	(	const std::vector< Matrix< T > > &	swap,
		const std::vector< PasRateFun< T > > &	listRate,
		const std::vector< int > &	N0 = std::vector<int>() )

Placement-order DAG of a two-station pass-and-swap tandem.

Parameters

swap	one graph, applied to both queues, or one graph per queue; G(a, b) nonzero means class a chases class b
listRate	the two ordered service-rate functions, queue 1 then queue 2
N0	(R) minimal probing population; empty means one job per class

Returns

(R x R) H, with H(i, j) = 1 iff class i+1 must precede class j+1

Definition at line 117 of file pas_swap2order.h.

References line::InputError::InputError(), line::Matrix< T >::Matrix(), and pas_swap2order().

Referenced by pas_swap2order(), and line::nc::solver_nc_pas_is_analyzer().

pfqn_ab_amva() [1/2]

template<class T>

AbAmvaResult< T > line::pfqn::pfqn_ab_amva	(	const Matrix< T > &	S,
		const std::vector< int > &	N,
		const Matrix< T > &	v,
		const std::vector< int > &	nservers,
		const std::vector< SchedStrategy > &	sched )

Reference defaults: no Schmidt FCFS wait, the AB marginal rule.

Definition at line 457 of file pfqn_ab_amva.h.

References Ab, and pfqn_ab_amva().

pfqn_ab_amva() [2/2]

template<class T>

AbAmvaResult< T > line::pfqn::pfqn_ab_amva	(	const Matrix< T > &	S,
		const std::vector< int > &	N,
		const Matrix< T > &	v,
		const std::vector< int > &	nservers,
		const std::vector< SchedStrategy > &	sched,
		bool	fcfsSchmidt,
		AbMarginalMethod	method )

Akyildiz-Bolch approximate MVA for multi-server BCMP networks.

Parameters

S	(M x R) service demands
N	(R) population per class
v	(M x R) visit ratios
nservers	(M) server counts
sched	(M) scheduling discipline
fcfsSchmidt	use the Schmidt state-sum wait at FCFS stations
method	marginal-probability rule for the multiserver correction

Definition at line 380 of file pfqn_ab_amva.h.

References line::Matrix< T >::cols(), line::InputError::InputError(), pfqn_ab_amva(), line::pfqn::AbAmvaResult< T >::QN, and line::Matrix< T >::rows().

Referenced by pfqn_ab_amva(), pfqn_ab_amva(), and line::mva::solver_amva().

pfqn_aghq() [1/3]

template<class T>

AghqResult< T > line::pfqn::pfqn_aghq	(	const Matrix< T > &	L,
		const std::vector< T > &	N )

Definition at line 149 of file pfqn_aghq.h.

References pfqn_aghq().

pfqn_aghq() [2/3]

template<class T>

AghqResult< T > line::pfqn::pfqn_aghq	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z )

Definition at line 143 of file pfqn_aghq.h.

References pfqn_aghq().

pfqn_aghq() [3/3]

template<class T>

AghqResult< T > line::pfqn::pfqn_aghq	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		std::size_t	q )

Definition at line 59 of file pfqn_aghq.h.

References line::pfqn::simplex::Mode< T >::A, line::pfqn::simplex::aghq_rule(), line::Matrix< T >::cols(), line::pfqn::LeResult< T >::G, line::pfqn::simplex::Mode< T >::h0, line::InputError::InputError(), line::pfqn::simplex::Mode< T >::ld, line::pfqn::LeResult< T >::lG, pfqn_aghq(), pfqn_le(), pfqn_le_fpi(), pfqn_le_hessian(), line::pfqn::simplex::radial(), line::Matrix< T >::rows(), line::pfqn::simplex::simplex_mode(), line::pfqn::simplex::softmax_gauge(), line::pfqn::simplex::Mode< T >::x, and line::lang::GlobalConstants::Zero.

Referenced by pfqn_aghq(), pfqn_aghq(), pfqn_aghq(), and pfqn_nc().

pfqn_amvasjn()

SjnResult line::pfqn::pfqn_amvasjn ( const Matrix< double > & L, const std::vector< double > & N, const std::vector< double > & Z, const Matrix< double > & scv, const std::vector< std::size_t > & sjnset, const Matrix< double > & V, const SjnOptions & options )

inline

Schweitzer fixed point counterpart of pfqn_mvasjn.

The closure is applied to the SIZE-RESOLVED queue length lam_k W_k(x) f_k(x) rather than to its integral: removing one customer of class r scales the class-r density by (N_r-1)/N_r and leaves the other classes unchanged. Integrating over x recovers the usual Schweitzer rule, so the closure is the exact analogue of the one used at the ordinary stations. Cost per iteration is O(M R ns) against the prod(N+1) M R ns of the lattice, and the population may be arbitrarily large. What is given up is the population dependence of the SHAPE of W(x): its level may scale but its shape is fixed, whereas the true profile stiffens with the load. The error therefore concentrates at high utilization, where the SJN approximation is already weakest.

Definition at line 800 of file pfqn_sjn.h.

References line::pfqn::SjnResult::capped, line::pfqn::SjnResult::CN, line::pfqn::SjnResult::converged, line::pfqn::SjnResult::iter, pfqn_amvasjn(), pfqn_bs(), line::pfqn::AmvaResult< T >::QN, line::pfqn::SjnResult::QN, line::pfqn::AmvaResult< T >::RN, Tail, line::pfqn::AmvaResult< T >::UN, line::pfqn::SjnResult::UN, line::pfqn::SjnResult::WX, line::pfqn::AmvaResult< T >::XN, and line::pfqn::SjnResult::XN.

Referenced by pfqn_amvasjn(), and line::mva::solver_mva_sjn_analyzer().

pfqn_aql() [1/2]

template<class T>

AmvaResult< T > line::pfqn::pfqn_aql	(	const Matrix< T > &	L,
		const std::vector< T > &	N )

Definition at line 141 of file pfqn_aql.h.

References pfqn_aql().

pfqn_aql() [2/2]

template<class T>

AmvaResult< T > line::pfqn::pfqn_aql	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		double	tol = 1e-7,
		std::size_t	maxiter = 1000 )

Aggregate Queue Length (AQL) approximate MVA.

Parameters

L	(M x K) demands
N	(K) populations
Z	(K) think times, empty for none
tol	convergence tolerance
maxiter	iteration cap

Returns

the standard AMVA metrics; AN holds the arrival-instant aggregate queue lengths Q(k | N - e_s), which callers use for the arrival theorem diagnostics

Definition at line 51 of file pfqn_aql.h.

References line::Matrix< T >::cols(), line::pfqn::AmvaResult< T >::converged, line::InputError::InputError(), line::pfqn::AmvaResult< T >::iterations, line::Matrix< T >::Matrix(), pfqn_aql(), line::pfqn::AmvaResult< T >::QN, line::pfqn::AmvaResult< T >::RN, line::Matrix< T >::rows(), line::pfqn::AmvaResult< T >::UN, and line::pfqn::AmvaResult< T >::XN.

Referenced by pfqn_aql(), pfqn_aql(), pfqn_kt(), and line::mva::solver_amva().

pfqn_bjbk() [1/2]

template<class T>

PbhBounds< T > line::pfqn::pfqn_bjbk	(	const std::vector< T > &	L,
		int	N,
		const T &	Z )

Definition at line 167 of file pfqn_pbh.h.

References pfqn_bjbk(), and pfqn_pbh().

pfqn_bjbk() [2/2]

template<class T>

PbhBounds< T > line::pfqn::pfqn_bjbk	(	const std::vector< T > &	L,
		int	N,
		const T &	Z,
		int	k )

BJB(k), the iterative Balanced Job Bound.

Forwards to pfqn_pbh.

Definition at line 162 of file pfqn_pbh.h.

References pfqn_bjbk(), and pfqn_pbh().

Referenced by pfqn_bjbk(), pfqn_bjbk(), and line::ba::solver_ba_analyzer().

pfqn_bk()

template<class T>

BkResult< T > line::pfqn::pfqn_bk	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z )

Birman-Kogan saddle point normalizing constant with bottleneck detection.

Parameters

L	(M x R) service demands
N	(R) population
Z	(R) think times, may be empty

Definition at line 162 of file pfqn_bk.h.

References line::pfqn::BkResult< T >::A, line::pfqn::BkResult< T >::B, line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::pfqn::BkResult< T >::G, line::InputError::InputError(), line::pfqn::BkResult< T >::lG, line::lu_factor(), line::Matrix< T >::Matrix(), line::num_abs(), pfqn_bk(), line::Matrix< T >::rows(), line::solve(), line::pfqn::BkResult< T >::U, and line::pfqn::BkResult< T >::X.

Referenced by pfqn_bk(), pfqn_bklc(), pfqn_nc(), and line::tr::transform_solve_lc().

pfqn_bklc()

template<class T>

BkLcResult< T > line::pfqn::pfqn_bklc	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		const std::string &	method = "mva",
		double	tol = 1e-10,
		int	maxiter = 1000 )

Birman-Kogan load concealment algorithm (Algorithm 2).

Parameters

L	(M x R) service demands
N	(R) population
Z	(R) think times, may be empty
method	single chain solver, "mva" (default) or "ue"
tol	convergence tolerance on the throughputs
maxiter	maximum number of sweeps

Definition at line 578 of file pfqn_bk.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::pfqn::BkLcResult< T >::it, line::Matrix< T >::Matrix(), pfqn_bk(), pfqn_bklc(), pfqn_bkue(), pfqn_mva(), line::pfqn::BkLcResult< T >::Q, line::Matrix< T >::rows(), line::pfqn::BkLcResult< T >::U, line::pfqn::BkLcResult< T >::X, and line::pfqn::BkResult< T >::X.

Referenced by pfqn_bklc(), and pfqn_nc().

pfqn_bkt() [1/2]

template<class T>

BktResult< T > line::pfqn::pfqn_bkt	(	const Matrix< T > &	L,
		const std::vector< T > &	N )

Definition at line 109 of file pfqn_bkt.h.

References pfqn_bkt().

pfqn_bkt() [2/2]

template<class T>

BktResult< T > line::pfqn::pfqn_bkt	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z )

Knessl-Tier expansion with the Stirling-remainder correction (BKT).

Parameters

L	(M x R) demands,
N	(R) population,
Z	(R) think times (pass an empty vector or all zeros for the Z = 0 branch)

Definition at line 78 of file pfqn_bkt.h.

References line::Matrix< T >::cols(), line::pfqn::KtResult< T >::G, line::pfqn::KtResult< T >::lG, pfqn_bkt(), pfqn_kt(), pfqn_stirling_remainder(), and line::Matrix< T >::rows().

Referenced by pfqn_bkt(), pfqn_bkt(), pfqn_lekt(), and pfqn_nc().

pfqn_bkue()

template<class T>

BkResult< T > line::pfqn::pfqn_bkue	(	const std::vector< T > &	L,
		const T &	N,
		const T &	Z )

Birman-Kogan uniform (van der Waerden) expansion for a single chain.

Parameters

L	(M) service demands, single class
N	population
Z	think time

Definition at line 494 of file pfqn_bk.h.

References bk_erfcx(), line::pfqn::BkResult< T >::G, line::pfqn::BkResult< T >::lG, and pfqn_bkue().

Referenced by pfqn_bklc(), pfqn_bkue(), and pfqn_nc().

pfqn_ble() [1/2]

template<class T>

BleResult< T > line::pfqn::pfqn_ble	(	const Matrix< T > &	L,
		const std::vector< T > &	N )

Definition at line 87 of file pfqn_ble.h.

References pfqn_ble().

pfqn_ble() [2/2]

template<class T>

BleResult< T > line::pfqn::pfqn_ble	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z )

Logistic expansion estimate of the normalizing constant, bias-corrected.

Parameters

L	(M x R) demands,
N	(R) population,
Z	(R) think times (pass an empty vector or all zeros for the Z = 0 branch)

Definition at line 56 of file pfqn_ble.h.

References line::Matrix< T >::cols(), line::pfqn::LeResult< T >::G, line::pfqn::LeResult< T >::lG, pfqn_ble(), pfqn_le(), line::Matrix< T >::rows(), and line::lang::GlobalConstants::Zero.

Referenced by pfqn_ble(), pfqn_ble(), pfqn_lekt(), and pfqn_nc().

pfqn_bs() [1/3]

template<class T>

AmvaResult< T > line::pfqn::pfqn_bs	(	const Matrix< T > &	L,
		const std::vector< T > &	N )

Definition at line 184 of file pfqn_bs.h.

References pfqn_bs().

pfqn_bs() [2/3]

template<class T>

AmvaResult< T > line::pfqn::pfqn_bs	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z )

Definition at line 179 of file pfqn_bs.h.

References pfqn_bs().

pfqn_bs() [3/3]

template<class T>

AmvaResult< T > line::pfqn::pfqn_bs	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		const std::vector< AmvaSched > &	type,
		double	tol = 1e-6,
		std::size_t	maxiter = 1000,
		const Matrix< T > &	QN0 = Matrix<T>() )

Bard-Schweitzer approximate MVA.

Parameters

L	(M x R) demands
N	(R) populations
Z	(R) think times, empty for none
type	(M) per-station scheduling, empty for all PS
tol	convergence tolerance; NaN selects the published Linearizer termination test of Chandy and Neuse, Commun. ACM 25(2), 1982, i.e. the cutoff pfqn_cntol(N) applied to max_{i,r}|dQ(i,r)|/N_r instead of the relative-change metric used by default. This is the test LQNS runs, since it sets it in SchweitzerCommon.
maxiter	iteration cap
QN0	queue lengths that warm-start the iteration; empty for a cold start

Definition at line 73 of file pfqn_bs.h.

References line::Matrix< T >::cols(), line::pfqn::AmvaResult< T >::converged, FCFS, line::InputError::InputError(), is_cntol(), line::pfqn::AmvaResult< T >::iterations, line::Matrix< T >::Matrix(), line::NumericError::NumericError(), pfqn_bs(), pfqn_cntol(), line::pfqn::AmvaResult< T >::QN, line::pfqn::AmvaResult< T >::RN, line::Matrix< T >::rows(), line::pfqn::AmvaResult< T >::UN, and line::pfqn::AmvaResult< T >::XN.

Referenced by line::infer::gibbs_slice(), pfqn_amvasjn(), pfqn_bs(), pfqn_bs(), pfqn_bs(), pfqn_dmlin(), pfqn_egflinearizer(), pfqn_kt(), pfqn_linearizerms(), pfqn_mci(), and line::mva::solver_amva().

pfqn_busyp()

template<class T, class RateSource>

BusyPeriodResult line::pfqn::pfqn_busyp	(	const std::vector< double > &	alpha,
		const RateSource &	mu,
		const Matrix< T > &	P,
		double	N,
		const std::vector< std::size_t > &	subnet,
		const std::vector< std::size_t > &	n,
		const std::vector< double > &	gamma = {},
		double	tol = PFQN_BUSYP_DEFAULT_TOL )

Mean busy period of order n for the subnetwork.

Parameters

alpha	relative arrival rates, one per node
mu	load-dependent rates, either a (J x K) matrix mu(j,k-1) with k jobs at node j, or a callable mu(j, k) when the rates do not saturate (an infinite server)
P	(J x J) routing matrix
N	population, infinity for an open network
subnet	zero-based node indexes forming the subnetwork
n	busy period orders, 1 <= n <= N
gamma	external arrival rates, empty for a closed network
tol	relative tolerance of the open-network tail truncation

Definition at line 186 of file pfqn_busyp.h.

References pfqn_busyp().

Referenced by pfqn_busyp(), pfqn_busyp_multiclass(), and line::nc::solver_nc_busyp().

pfqn_busyp_clw()

template<class T>

std::vector< double > line::pfqn::pfqn_busyp_clw	(	const Matrix< T > &	alpha,
		const Matrix< T > &	mu,
		const std::vector< Matrix< T > > &	P,
		const std::vector< double > &	N,
		const std::vector< std::size_t > &	subnet,
		const std::vector< std::size_t > &	n,
		const Matrix< T > &	gamma = Matrix<T>(),
		const std::vector< bool > &	isdelay = std::vector<bool>(),
		const std::string &	method = "clw" )

Mean busy period of order n for the subnetwork, via NC point evaluations.

Parameters

alpha	(J x R) relative arrival rates, one column per chain
mu	(J x R) service rates, the chain-r rate at node j
P	routing matrices, one per chain (size 1 = shared by all chains)
N	population per chain, infinite entries for an open chain
subnet	zero-based node indexes forming the subnetwork
n	busy period orders, counting the jobs of every chain
gamma	(J x R) external arrival rates, empty for a closed network
isdelay	infinite-server nodes, empty meaning all single servers
method	method name of the normalizing-constant method ("clw")

Definition at line 213 of file pfqn_busyp_clw.h.

References line::Matrix< T >::cols(), line::InputError::InputError(), pfqn_busyp_clw(), and line::Matrix< T >::rows().

Referenced by pfqn_busyp_clw().

pfqn_busyp_multiclass()

template<class T>

std::vector< double > line::pfqn::pfqn_busyp_multiclass	(	const Matrix< T > &	alpha,
		const Matrix< T > &	mu,
		const std::vector< Matrix< T > > &	P,
		const std::vector< double > &	N,
		const std::vector< std::size_t > &	subnet,
		const std::vector< std::size_t > &	n,
		const Matrix< T > &	gamma = Matrix<T>(),
		const Matrix< T > &	phi = Matrix<T>(),
		double	tol = PFQN_BUSYP_DEFAULT_TOL,
		int	jobclass = -1 )

Mean busy period of order n for the subnetwork, multichain.

Parameters

alpha	(J x R) relative arrival rates, one column per chain
mu	(J x R) service rates, the chain-r rate at node j
P	routing matrices, one per chain (size 1 = shared by all chains)
N	population per chain, infinite entries for an open chain
subnet	zero-based node indexes forming the subnetwork
n	busy period orders, counting the jobs of every chain
gamma	(J x R) external arrival rates, empty for a closed network
phi	(J x K) dimensionless load-dependent scaling, empty = single server
tol	relative tolerance of the open-network tail truncation
jobclass	zero-based chain whose own jobs are counted, -1 for every chain

Definition at line 280 of file pfqn_busyp_multiclass.h.

References line::pfqn::BusyPeriodResult::b, line::Matrix< T >::cols(), line::InputError::InputError(), line::NumericError::NumericError(), pfqn_busyp(), PFQN_BUSYP_DEFAULT_TOL, pfqn_busyp_multiclass(), and line::Matrix< T >::rows().

Referenced by pfqn_busyp_multiclass().

pfqn_ca() [1/2]

template<class T>

NcResult< T > line::pfqn::pfqn_ca	(	const Matrix< T > &	L,
		const std::vector< int > &	N )

Overload without think times.

Definition at line 193 of file pfqn_ca.h.

References pfqn_ca().

pfqn_ca() [2/2]

template<class T>

NcResult< T > line::pfqn::pfqn_ca	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z )

Convolution algorithm for the exact normalizing constant of a closed product-form network (Buzen 1973, Reiser-Kobayashi 1975).

Parameters

L	(M x R) service demands, M queueing stations, R classes
N	(R) population per class
Z	(K x R) think times, summed over rows; may be empty

Definition at line 120 of file pfqn_ca.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), Ls, line::next_pop(), pfqn_ca(), line::plane_sizes(), line::pop_index(), line::population_count(), and line::Matrix< T >::rows().

Referenced by pfqn_ca(), pfqn_ca(), pfqn_comomrm_ld(), pfqn_joint(), pfqn_joint_total(), pfqn_jointmarg(), pfqn_nc(), pfqn_panacea(), and line::nc::solver_nc_jointmarg().

pfqn_cbh() [1/2]

template<class T>

CbhBounds< T > line::pfqn::pfqn_cbh	(	const std::vector< T > &	L,
		int	N,
		const T &	Z )

Definition at line 131 of file pfqn_cbh.h.

References pfqn_cbh().

pfqn_cbh() [2/2]

template<class T>

CbhBounds< T > line::pfqn::pfqn_cbh	(	const std::vector< T > &	L,
		int	N,
		const T &	Z,
		int	level )

Convolutional Bound Hierarchy (Dowdy, Eager, Gordon and Saxton 1984) on the throughput of a single-class closed product-form network.

Parameters

L	(M) per-station demands
N	population
Z	think time
level	number of exactly convolved stations, clamped to [1, M]

Definition at line 118 of file pfqn_cbh.h.

References line::InputError::InputError(), pfqn_cbh(), line::pfqn::CbhBounds< T >::Xhi, and line::pfqn::CbhBounds< T >::Xlo.

Referenced by pfqn_cbh(), pfqn_cbh(), and line::ba::solver_ba_analyzer().

pfqn_cdfun() [1/2]

template<class T>

std::vector< T > line::pfqn::pfqn_cdfun	(	const Matrix< T > &	nvec,
		const std::vector< CdScaling< T > > &	cdscaling )

MATLAB default: classIdx = 1, i.e.

the first class.

Definition at line 81 of file pfqn_cdfun.h.

References pfqn_cdfun().

pfqn_cdfun() [2/2]

template<class T>

std::vector< T > line::pfqn::pfqn_cdfun	(	const Matrix< T > &	nvec,
		const std::vector< CdScaling< T > > &	cdscaling,
		std::size_t	classIdx )

AMVA-QD class-dependence function.

Parameters

nvec	(M x R) per-station, per-class populations
cdscaling	(M) callables; entries may be empty for "no scaling"
classIdx	0-based class whose scaling is selected from a vector result

Returns

(M) reciprocals of the scalings

Definition at line 56 of file pfqn_cdfun.h.

References line::Matrix< T >::cols(), line::InputError::InputError(), line::NumericError::NumericError(), pfqn_cdfun(), and line::Matrix< T >::rows().

Referenced by pfqn_cdfun(), pfqn_cdfun(), and line::mva::solver_amvald().

pfqn_cftp() [1/2]

template<class T>

CftpResult< T > line::pfqn::pfqn_cftp	(	const std::vector< T > &	L,
		int	N,
		const std::vector< int > &	S,
		std::size_t	nsamples,
		CftpMethod	method,
		McRng &	rng )

Perfect stationary state sampling for closed single-class multiserver product-form networks, by monotone Coupling From The Past.

Parameters

L	(M) demands L_i = theta_i / mu_i, strictly positive
N	total closed population K
S	(M) servers per station; cftp_inf_servers for a delay. Empty for all single-server.
nsamples	number of independent draws
method	exact CFTP or the approximate sampler
rng	explicit generator, advanced by the call

Definition at line 144 of file pfqn_cftp.h.

References Cftp, cftp_inf_servers, line::pfqn::CftpResult< T >::horizon, line::InputError::InputError(), mc_uniform01(), mc_uniform_int(), pfqn_cftp(), line::pfqn::CftpResult< T >::Q, and line::pfqn::CftpResult< T >::X.

Referenced by pfqn_cftp(), pfqn_cftp(), and line::ctmc::solver_ctmc_cftp().

pfqn_cftp() [2/2]

template<class T>

CftpResult< T > line::pfqn::pfqn_cftp	(	const std::vector< T > &	L,
		int	N,
		McRng &	rng )

Reference defaults: single servers, one sample, exact CFTP.

Definition at line 243 of file pfqn_cftp.h.

References Cftp, and pfqn_cftp().

pfqn_chow() [1/3]

template<class T>

AmvaResult< T > line::pfqn::pfqn_chow	(	const Matrix< T > &	L,
		const std::vector< T > &	N )

Definition at line 182 of file pfqn_chow.h.

References pfqn_chow().

pfqn_chow() [2/3]

template<class T>

AmvaResult< T > line::pfqn::pfqn_chow	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z )

Definition at line 177 of file pfqn_chow.h.

References pfqn_chow().

pfqn_chow() [3/3]

template<class T>

AmvaResult< T > line::pfqn::pfqn_chow	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		const std::vector< AmvaSched > &	type,
		double	tol = 1e-6,
		std::size_t	maxiter = 1000,
		const Matrix< T > &	QN0 = Matrix<T>(),
		ChowVariant	variant = ChowVariant::Forward )

Chow Second Approximation (SA) approximate MVA.

Parameters

L	(M x R) demands
N	(R) populations
Z	(R) think times, empty for none
type	(M) per-station scheduling, empty for all PS
tol	convergence tolerance
maxiter	iteration cap
QN0	warm start for the inner LCP solves and the fixed point; may be empty
variant	estimator of the theta-terms

Definition at line 61 of file pfqn_chow.h.

References Backward, line::Matrix< T >::cols(), line::pfqn::AmvaResult< T >::converged, FCFS, Forward, line::InputError::InputError(), line::pfqn::AmvaResult< T >::iterations, line::Matrix< T >::Matrix(), line::NumericError::NumericError(), pfqn_chow(), pfqn_lcp(), line::pfqn::AmvaResult< T >::QN, line::pfqn::AmvaResult< T >::RN, line::Matrix< T >::rows(), line::pfqn::AmvaResult< T >::UN, and line::pfqn::AmvaResult< T >::XN.

Referenced by pfqn_chow(), pfqn_chow(), pfqn_chow(), and line::mva::solver_amva().

pfqn_clust() [1/3]

template<class T>

AmvaResult< T > line::pfqn::pfqn_clust	(	const Matrix< T > &	L,
		const std::vector< T > &	N )

Definition at line 390 of file pfqn_clust.h.

References pfqn_clust().

pfqn_clust() [2/3]

template<class T>

AmvaResult< T > line::pfqn::pfqn_clust	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z )

Definition at line 384 of file pfqn_clust.h.

References pfqn_clust().

pfqn_clust() [3/3]

template<class T>

AmvaResult< T > line::pfqn::pfqn_clust	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		const std::vector< std::vector< std::size_t > > &	subnets,
		const std::vector< std::vector< std::size_t > > &	localclasses,
		ClustInner	inner = ClustInner::Linearizer,
		double	tol = 1e-6,
		std::size_t	maxiter = 1000 )

de Souza e Silva-Lavenberg-Muntz Clustering Approximation (CA).

Parameters

L	(M x R) demands,
N	(R) populations,
Z	(R) think times
subnets	per subnetwork, the 0-based station indices it contains; empty for the automatic decomposition described above
localclasses	per subnetwork, the 0-based classes local to it; empty for the automatic decomposition
inner	algorithm run inside a subnetwork
tol	convergence tolerance
maxiter	outer-iteration cap

Definition at line 214 of file pfqn_clust.h.

References Basic, line::Matrix< T >::cols(), line::pfqn::AmvaResult< T >::converged, line::InputError::InputError(), line::pfqn::AmvaResult< T >::iterations, Linearizer, line::Matrix< T >::Matrix(), pfqn_clust(), pfqn_pam(), line::pfqn::AmvaResult< T >::QN, line::pfqn::AmvaResult< T >::RN, line::Matrix< T >::rows(), line::pfqn::AmvaResult< T >::UN, and line::pfqn::AmvaResult< T >::XN.

Referenced by pfqn_clust(), pfqn_clust(), pfqn_clust(), and line::mva::solver_amva().

pfqn_clw() [1/3]

template<class T>

ClwResult< T > line::pfqn::pfqn_clw	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z )

Overload with unit multiplicities and the CLW default parameters.

Definition at line 784 of file pfqn_clw.h.

References pfqn_clw().

pfqn_clw() [2/3]

template<class T>

ClwResult< T > line::pfqn::pfqn_clw	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const std::vector< long > &	m )

Overload with the CLW default parameters.

Definition at line 790 of file pfqn_clw.h.

References pfqn_clw().

pfqn_clw() [3/3]

template<class T>

ClwResult< T > line::pfqn::pfqn_clw	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const std::vector< long > &	m,
		const ClwOptions &	opt )

Choudhury-Leung-Whitt normalization constant by numerical inversion of the generating function (JACM 42(5):935-970, 1995), and its limited load-dependent extension through the per-center transforms of Bertozzi and McKenna (SIAM Review 35(2):239-268, 1993).

Parameters

L	(q' x p) single-server relative traffic intensities, L(i,j) = rho_{ji}
N	(p) closed-chain population vector
Z	(p) aggregate infinite-server relative intensities rho_{j0}
m	(q') queue multiplicities; empty for all ones
opt	lattice and aliasing parameters

Definition at line 608 of file pfqn_clw.h.

References line::Matrix< T >::cols(), line::pfqn::ClwResult< T >::G, line::InputError::InputError(), line::pfqn::ClwResult< T >::lG, line::NumericError::NumericError(), pfqn_clw(), and line::Matrix< T >::rows().

Referenced by pfqn_clw(), pfqn_clw(), pfqn_clw(), and pfqn_nc().

pfqn_clw_lld() [1/3]

template<class T>

ClwResult< T > line::pfqn::pfqn_clw_lld	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z )

Overload with all queues load independent.

Definition at line 971 of file pfqn_clw.h.

References pfqn_clw_lld().

pfqn_clw_lld() [2/3]

template<class T>

ClwResult< T > line::pfqn::pfqn_clw_lld	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const Matrix< T > &	mu )

Overload with the CLW default parameters.

Definition at line 964 of file pfqn_clw.h.

References pfqn_clw_lld().

pfqn_clw_lld() [3/3]

template<class T>

ClwResult< T > line::pfqn::pfqn_clw_lld	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const Matrix< T > &	mu,
		const ClwOptions &	opt )

Limited load-dependent form (matlab pfqn_clw_lld.m).

Parameters

L	(q' x p) relative traffic intensities
N	(p) populations
Z	(p) infinite-server intensities
mu	(q' x n) load-dependent rate scalings S_i(k); the last column is extended when fewer than sum(N) are supplied (the LLD assumption), and empty means all queues are load independent
opt	lattice and aliasing parameters

Definition at line 807 of file pfqn_clw.h.

References line::Matrix< T >::cols(), line::pfqn::ClwOptions::dimred, line::Matrix< T >::empty(), line::pfqn::ClwOptions::euler, line::pfqn::ClwResult< T >::G, line::InputError::InputError(), line::pfqn::ClwResult< T >::lG, line::NumericError::NumericError(), pfqn_clw_lld(), and line::Matrix< T >::rows().

Referenced by pfqn_clw_lld(), pfqn_clw_lld(), pfqn_clw_lld(), and pfqn_ncld().

pfqn_clwjd() [1/4]

template<class T>

ClwResult< T > line::pfqn::pfqn_clwjd	(	const std::vector< T > &	Z,
		const std::vector< int > &	N,
		const std::vector< OiRate< T > > &	mu )

Overload with unit visits and the all-N cutoff.

Definition at line 357 of file pfqn_clwjd.h.

References pfqn_clwjd().

pfqn_clwjd() [2/4]

template<class T>

ClwResult< T > line::pfqn::pfqn_clwjd	(	const std::vector< T > &	Z,
		const std::vector< int > &	N,
		const std::vector< OiRate< T > > &	mu,
		const Matrix< T > &	visits )

Overload with the all-N cutoff, i.e.

no truncation of the joint dependence.

Definition at line 350 of file pfqn_clwjd.h.

References pfqn_clwjd().

pfqn_clwjd() [3/4]

template<class T>

ClwResult< T > line::pfqn::pfqn_clwjd	(	const std::vector< T > &	Z,
		const std::vector< int > &	N,
		const std::vector< OiRate< T > > &	mu,
		const Matrix< T > &	visits,
		const Matrix< int > &	lcut )

Overload with the CLW default parameters.

Definition at line 342 of file pfqn_clwjd.h.

References pfqn_clwjd().

pfqn_clwjd() [4/4]

template<class T>

ClwResult< T > line::pfqn::pfqn_clwjd	(	const std::vector< T > &	Z,
		const std::vector< int > &	N,
		const std::vector< OiRate< T > > &	mu,
		const Matrix< T > &	visits,
		const Matrix< int > &	lcut,
		const ClwOptions &	opt )

Normalizing constant of a closed network of LIMITED JOINT-DEPENDENT (LJD) stations plus one aggregated delay, by numerical inversion of the multichain generating function (Choudhury-Leung-Whitt, J.

ACM 42(5):935-970, 1995).

Parameters

Z	(R) think-time demand of the aggregated delay node
N	(R) closed population, finite
mu	one rate handle per joint-dependent station; empty for a pure delay
visits	(M x R) per-station class visit ratios; empty for unit visits
lcut	(M x R) per-station per-class saturation cutoffs l_{i,r} >= 1, clipped to N_r (exact: a rate difference at n_r > N_r can only move coefficients with n_r > N_r); empty for the all-N cutoff
opt	lattice and aliasing parameters

Definition at line 137 of file pfqn_clwjd.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::pfqn::ClwResult< T >::G, line::InputError::InputError(), line::pfqn::ClwResult< T >::lG, line::NumericError::NumericError(), pfqn_clwjd(), and line::Matrix< T >::rows().

Referenced by pfqn_clwjd(), pfqn_clwjd(), pfqn_clwjd(), and pfqn_clwjd().

pfqn_clwoi() [1/3]

template<class T>

ClwResult< T > line::pfqn::pfqn_clwoi	(	const std::vector< T > &	Z,
		const std::vector< int > &	N,
		const std::vector< OiRate< T > > &	mu )

Overload with unit visits.

Definition at line 354 of file pfqn_clwoi.h.

References pfqn_clwoi().

pfqn_clwoi() [2/3]

template<class T>

ClwResult< T > line::pfqn::pfqn_clwoi	(	const std::vector< T > &	Z,
		const std::vector< int > &	N,
		const std::vector< OiRate< T > > &	mu,
		const Matrix< T > &	visits )

Overload with the CLW default parameters.

Definition at line 347 of file pfqn_clwoi.h.

References pfqn_clwoi().

pfqn_clwoi() [3/3]

template<class T>

ClwResult< T > line::pfqn::pfqn_clwoi	(	const std::vector< T > &	Z,
		const std::vector< int > &	N,
		const std::vector< OiRate< T > > &	mu,
		const Matrix< T > &	visits,
		const ClwOptions &	opt )

Normalizing constant of a closed network of ORDER-INDEPENDENT (OI) stations plus one aggregated delay, by numerical inversion of the multichain generating function (Choudhury-Leung-Whitt, J.

ACM 42(5):935-970, 1995).

Parameters

Z	(R) think-time demand of the aggregated delay node
N	(R) closed population, finite
mu	one rate handle per OI station, mapping a per-class count vector to the total service rate; must depend on the count vector only through its support. Empty for a pure delay network
visits	(M x R) per-station class visit ratios weighting the balance recursion; empty for unit visits
opt	lattice and aliasing parameters

Definition at line 180 of file pfqn_clwoi.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::pfqn::ClwResult< T >::G, line::InputError::InputError(), line::pfqn::ClwResult< T >::lG, line::NumericError::NumericError(), pfqn_clwoi(), and line::Matrix< T >::rows().

Referenced by pfqn_clwoi(), pfqn_clwoi(), and pfqn_clwoi().

pfqn_cntol() [1/2]

double line::pfqn::pfqn_cntol ( const std::vector< int > & N )

inline

Termination cutoff at the given integer population vector.

Definition at line 65 of file pfqn_cntol.h.

References pfqn_cntol(), and pfqn_cntol_total().

pfqn_cntol() [2/2]

template<class T>

double line::pfqn::pfqn_cntol

(

const std::vector< T > &

N

)

Termination cutoff at the given population vector.

Definition at line 58 of file pfqn_cntol.h.

References pfqn_cntol(), and pfqn_cntol_total().

Referenced by pfqn_bs(), pfqn_cntol(), and pfqn_cntol().

pfqn_cntol_total()

double line::pfqn::pfqn_cntol_total ( double total_population )

inline

Termination cutoff at the given total population.

Definition at line 52 of file pfqn_cntol.h.

References pfqn_cntol_total().

Referenced by pfqn_cntol(), pfqn_cntol(), and pfqn_cntol_total().

pfqn_combine_mi()

std::vector< int > line::pfqn::pfqn_combine_mi ( const std::vector< int > & mi, const std::vector< std::size_t > & mapping, std::size_t M_unique )

inline

Fold a caller-supplied multiplicity vector along a consolidation mapping.

Port of pfqn_combine_mi in jar/src/main/java/jline/api/pfqn/Pfqn_replicas.java, the third member of the replica trio alongside pfqn_unique and pfqn_expand. MATLAB has no counterpart.

When the caller already carries its own per-station multiplicities mi (a station standing for mi(i) identical replicas) and pfqn_unique then merges further stations, the two multiplicities must COMPOSE: the consolidated station g represents sum over the original stations mapped to g of mi(i). The result is therefore a SUM along the mapping, not a count of the group, which is what makes it different from the group sizes pfqn_unique itself returns.

Arithmetic: EXACT-CAPABLE. Integer addition only.

Parameters

mi	(M) multiplicity of each original station
mapping	(M) original station -> consolidated index, as pfqn_unique returns it
M_unique	number of consolidated stations

Returns

(M_unique) combined multiplicities

Definition at line 129 of file pfqn_unique.h.

References line::InputError::InputError(), and pfqn_combine_mi().

Referenced by pfqn_combine_mi().

pfqn_comom() [1/2]

template<class T>

ComomResult< T > line::pfqn::pfqn_comom	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z )

Overload with the reference's default tolerance.

Definition at line 272 of file pfqn_comom.h.

References pfqn_comom().

pfqn_comom() [2/2]

template<class T>

ComomResult< T > line::pfqn::pfqn_comom	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const T &	atol )

CoMoM on the general basis (matlab pfqn_comom.m).

Parameters

L	(1 x R) demands at the single queueing station
N	(R) populations
Z	(R) think times
atol	tolerance below which a demand counts as zero

Definition at line 108 of file pfqn_comom.h.

References line::pfqn::ComomResult< T >::basis, line::Matrix< T >::cols(), line::pfqn::ComomResult< T >::G, line::InputError::InputError(), line::pfqn::ComomResult< T >::lG, Ls, matchrow(), line::Matrix< T >::Matrix(), line::num_factorial(), line::num_pow_int(), line::NumericError::NumericError(), pfqn_comom(), line::Matrix< T >::rows(), and line::solve().

Referenced by pfqn_comom(), and pfqn_comom().

pfqn_comomrm() [1/2]

template<class T>

ComomResult< T > line::pfqn::pfqn_comomrm	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z )

Overload with the unit multiplicity default.

Definition at line 234 of file pfqn_comomrm.h.

References pfqn_comomrm().

pfqn_comomrm() [2/2]

template<class T>

ComomResult< T > line::pfqn::pfqn_comomrm	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		int	m )

CoMoM (class-oriented method of moments) for the finite repairman model: one queueing station of multiplicity m plus a delay.

Parameters

L	(1 x R) demands at the single queueing station
N	(R) populations
Z	(K x R) think times
m	multiplicity of the queueing station

Definition at line 85 of file pfqn_comomrm.h.

References line::pfqn::ComomResult< T >::basis, line::Matrix< T >::empty(), line::pfqn::ComomResult< T >::G, line::pfqn::NcSanitizeResult< T >::Gremaind, line::InputError::InputError(), line::pfqn::NcSanitizeResult< T >::L, line::pfqn::ComomResult< T >::lG, line::pfqn::NcSanitizeResult< T >::lGremaind, line::Matrix< T >::Matrix(), line::pfqn::NcSanitizeResult< T >::N, line::num_factorial(), pfqn_comomrm(), pfqn_nc_sanitize(), line::Matrix< T >::rows(), and line::pfqn::NcSanitizeResult< T >::Z.

Referenced by pfqn_comomrm(), pfqn_comomrm(), pfqn_nc(), and pfqn_sens_comom().

pfqn_comomrm_ld()

template<class T>

ComomRmResult< T > line::pfqn::pfqn_comomrm_ld	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const Matrix< T > &	mu )

CoMoM for the repairman model with an arbitrary LOAD-DEPENDENT rate lattice at the single queueing station.

Parameters

L	(M x R) demands
N	(R) populations
Z	(K x R) think times; empty or zero triggers delay detection on mu
mu	(M x >=Nt) load-dependent rate lattice

Definition at line 55 of file pfqn_comomrm_ld.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::pfqn::ComomRmResult< T >::G, line::pfqn::NcResult< T >::G, line::pfqn::NcSanitizeResult< T >::Gremaind, line::InputError::InputError(), line::pfqn::NcSanitizeResult< T >::L, line::pfqn::ComomRmResult< T >::lG, line::pfqn::NcResult< T >::lG, line::pfqn::NcSanitizeResult< T >::lGremaind, line::Matrix< T >::Matrix(), line::pfqn::NcSanitizeResult< T >::N, pfqn_ca(), pfqn_comomrm_ld(), pfqn_nc_sanitize(), line::pfqn::ComomRmResult< T >::prob, line::Matrix< T >::rows(), and line::pfqn::NcSanitizeResult< T >::Z.

Referenced by pfqn_comomrm_ld(), pfqn_ncld(), and pfqn_stdf_heur().

pfqn_comomrm_ms() [1/2]

template<class T>

ComomRmResult< T > line::pfqn::pfqn_comomrm_ms	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		int	m,
		int	S )

CoMoM for the MULTISERVER repairman model: one queueing station with S servers (optionally replicated m times), plus a delay.

Parameters

L	(1 x R) demands at the single queueing station
N	(R) populations
Z	(1 x R) think times
m	replication factor of the queueing station
S	number of servers per replica

Definition at line 140 of file pfqn_comomrm_ms.h.

References line::Matrix< T >::empty(), line::pfqn::ComomRmResult< T >::G, line::pfqn::NcSanitizeResult< T >::Gremaind, line::InputError::InputError(), line::pfqn::NcSanitizeResult< T >::L, line::pfqn::ComomRmResult< T >::lG, line::pfqn::NcSanitizeResult< T >::lGremaind, line::pfqn::NcSanitizeResult< T >::N, pfqn_comomrm_ms(), pfqn_mu_ms(), pfqn_nc_sanitize(), line::pfqn::ComomRmResult< T >::prob, line::Matrix< T >::rows(), and line::pfqn::NcSanitizeResult< T >::Z.

Referenced by pfqn_comomrm_ms(), and pfqn_comomrm_ms().

pfqn_comomrm_ms() [2/2]

template<class T>

ComomRmResult< T > line::pfqn::pfqn_comomrm_ms	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		int	S )

Overload with the single-replica default.

Definition at line 178 of file pfqn_comomrm_ms.h.

References pfqn_comomrm_ms().

pfqn_comomrm_orig() [1/2]

template<class T>

ComomResult< T > line::pfqn::pfqn_comomrm_orig	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z )

Overload with the exact (zero-tolerance) tests.

Definition at line 435 of file pfqn_comom.h.

References pfqn_comomrm_orig().

pfqn_comomrm_orig() [2/2]

template<class T>

ComomResult< T > line::pfqn::pfqn_comomrm_orig	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const T &	atol )

Original CoMoM for the finite repairman model (matlab pfqn_comomrm_orig.m).

Parameters

L	(1 x R) demands at the single queueing station
N	(R) populations
Z	(K x R) think times
atol	tolerance passed to pfqn_nc_sanitize

Definition at line 285 of file pfqn_comom.h.

References line::pfqn::ComomResult< T >::basis, line::Matrix< T >::empty(), line::pfqn::ComomResult< T >::G, line::pfqn::NcSanitizeResult< T >::Gremaind, line::InputError::InputError(), line::pfqn::NcSanitizeResult< T >::L, line::pfqn::ComomResult< T >::lG, line::pfqn::NcSanitizeResult< T >::lGremaind, line::lu_factor(), line::lu_solve(), line::Matrix< T >::Matrix(), line::pfqn::NcSanitizeResult< T >::N, line::num_factorial(), line::num_pow_int(), pfqn_comomrm_orig(), pfqn_nc_sanitize(), line::Matrix< T >::rows(), and line::pfqn::NcSanitizeResult< T >::Z.

Referenced by pfqn_comomrm_orig(), and pfqn_comomrm_orig().

pfqn_conv() [1/3]

template<class T>

NcResult< T > line::pfqn::pfqn_conv	(	const Matrix< T > &	L,
		const std::vector< int > &	N )

Definition at line 195 of file pfqn_conv.h.

References pfqn_conv().

pfqn_conv() [2/3]

template<class T>

NcResult< T > line::pfqn::pfqn_conv	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z )

Overload with no class dependence, i.e.

plain multichain convolution.

Definition at line 190 of file pfqn_conv.h.

References pfqn_conv().

pfqn_conv() [3/3]

template<class T>

NcResult< T > line::pfqn::pfqn_conv	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const std::vector< CdScaling< T > > &	cdscaling )

Multichain convolution algorithm with class-dependent service rates (Sauer 1983, "Computational Algorithms for State-Dependent Queueing Networks", ACM TOCS 1(1):67-92, Section 5.2).

Parameters

L	(M x R) service demands
N	(R) population per class, finite
Z	(K x R) think times, summed over rows; may be empty
cdscaling	(M) class-dependence callables; an empty entry marks a load-independent station. Pass an empty vector for none.

Definition at line 76 of file pfqn_conv.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), line::next_pop(), pfqn_conv(), line::plane_sizes(), line::pop_index(), line::population_count(), and line::Matrix< T >::rows().

Referenced by pfqn_conv(), pfqn_conv(), pfqn_conv(), and line::nc::solver_nc_conv().

pfqn_conwayms() [1/2]

template<class T>

LinearizerResult< T > line::pfqn::pfqn_conwayms	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const std::vector< int > &	nservers )

MATLAB defaults: all stations FCFS, tol = 1e-8, maxiter = 1000.

Definition at line 409 of file pfqn_conwayms.h.

References pfqn_conwayms().

pfqn_conwayms() [2/2]

template<class T>

LinearizerResult< T > line::pfqn::pfqn_conwayms	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const std::vector< int > &	nservers,
		const std::vector< SchedStrategy > &	type,
		double	tol,
		int	maxiter,
		const Matrix< T > &	QN0 )

Conway's multiserver Linearizer for chain-dependent FCFS queues (Conway 1989, "Fast Approximate Solution of Queueing Networks with Multi-Server Chain-Dependent FCFS Queues").

Parameters

L	(M x R) service demands
N	(R) population per class
Z	(K x R) think times, summed over rows; may be empty
nservers	(M) number of servers per station, at least one
type	(M) scheduling discipline; empty means all-FCFS, the MATLAB default for this routine
tol	convergence tolerance
maxiter	total inner-iteration budget
QN0	(M x R) warm start; empty for the default N/M

Definition at line 300 of file pfqn_conwayms.h.

References line::pfqn::LinearizerResult< T >::C, line::Matrix< T >::cols(), line::Matrix< T >::empty(), FCFS, line::InputError::InputError(), line::Matrix< T >::Matrix(), oner(), pfqn_conwayms(), line::pfqn::LinearizerResult< T >::Q, line::Matrix< T >::rows(), sum_rows(), line::pfqn::LinearizerResult< T >::totiter, line::pfqn::LinearizerResult< T >::U, line::pfqn::LinearizerResult< T >::W, and line::pfqn::LinearizerResult< T >::X.

Referenced by pfqn_conwayms(), pfqn_conwayms(), and line::mva::solver_amva().

pfqn_cub() [1/2]

template<class T>

CubResult< T > line::pfqn::pfqn_cub	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z )

Definition at line 219 of file pfqn_cub.h.

References pfqn_cub().

pfqn_cub() [2/2]

template<class T>

CubResult< T > line::pfqn::pfqn_cub	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		int	order,
		const T &	atol )

Normalizing constant by Grundmann-Moeller cubature over the simplex.

Parameters

L	(M x R) demands
N	(R) population
Z	(R) think times, empty or all zero for the exact branch
order	rule degree; the default ceil((sum N - 1)/2) makes the Z = 0 branch exact
atol	absolute tolerance, also the zero test on sum(Z)

Definition at line 131 of file pfqn_cub.h.

References line::Matrix< T >::cols(), line::pfqn::CubResult< T >::G, grnmol(), line::InputError::InputError(), line::pfqn::CubResult< T >::lG, line::num_pow_int(), pfqn_cub(), and line::Matrix< T >::rows().

Referenced by pfqn_cub(), pfqn_cub(), and pfqn_nc().

pfqn_cub_evals() [1/2]

double line::pfqn::pfqn_cub_evals ( int M, int order )

inline

Zero think time, i.e.

the bare simplex rule.

Definition at line 71 of file pfqn_cub_evals.h.

References pfqn_cub_evals().

pfqn_cub_evals() [2/2]

double line::pfqn::pfqn_cub_evals ( int M, int order, double Zsum )

inline

Integrand-evaluation count of pfqn_cub, and the budget pfqn_nc prices it against.

Parameters

M	number of queueing stations
order	Grundmann-Moeller degree
Zsum	total think time; a positive value costs the v-quadrature

Returns

number of integrand evaluations pfqn_cub performs

Definition at line 59 of file pfqn_cub_evals.h.

References CUB_V_STEPS, line::InputError::InputError(), line::nck(), and pfqn_cub_evals().

Referenced by pfqn_cub_evals(), pfqn_cub_evals(), and pfqn_nc().

pfqn_cyclet_ofree()

CycletResult line::pfqn::pfqn_cyclet_ofree ( const std::vector< double > & v, const std::vector< double > & mu, std::size_t N, const std::vector< std::vector< std::size_t > > & paths, const std::vector< double > & tset, const std::string & method = "auto", std::size_t nmom = 3, const std::vector< double > & pathprob = {}, const std::string & lti_method = "euler", double tol = 1e-8 )

inline

Exact passage-time density, CDF and moments along the overtake-free paths paths, mixed by pathprob.

Parameters

method

"auto" (default) uses "exact" when the path rates are separated and "lt" otherwise; "exact" is Theorem 2 in closed form and REQUIRES DISTINCT RATES on the path, since its partial fractions divide by prod_{i!=j}(mu_i - mu_j)

Definition at line 135 of file pfqn_cyclet_ofree.h.

References pfqn_cyclet_ofree().

Referenced by pfqn_cyclet_ofree().

pfqn_dac() [1/2]

template<class T>

DacResult< T > line::pfqn::pfqn_dac	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z )

Definition at line 306 of file pfqn_dac.h.

References pfqn_dac().

pfqn_dac() [2/2]

template<class T>

DacResult< T > line::pfqn::pfqn_dac	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const Matrix< T > &	mu )

Distribution Analysis by Chain (de Souza e Silva, UCLA CSD-870023, 1987): the JOINT queue-length distribution of a closed product-form network with single-server, infinite-server and queue-dependent centers.

Parameters

L	(M x R) demands
N	(R) population
Z	(R) think times; a non-zero total appends an IS center, so the states then have M+1 columns
mu	(M x Nt) load-dependent rates, empty for all ones

Definition at line 118 of file pfqn_dac.h.

References line::pfqn::DacResult< T >::CN, line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), line::Matrix< T >::Matrix(), line::NumericError::NumericError(), pfqn_dac(), line::pfqn::DacResult< T >::PI, line::pfqn::DacResult< T >::Pjoint, line::pfqn::DacResult< T >::QN, line::Matrix< T >::rows(), line::pfqn::DacResult< T >::states, line::pfqn::DacResult< T >::UN, and line::pfqn::DacResult< T >::XN.

Referenced by pfqn_dac(), and pfqn_dac().

pfqn_dmlin() [1/3]

template<class T>

LinearizerResult< T > line::pfqn::pfqn_dmlin	(	const Matrix< T > &	L,
		const std::vector< int > &	N )

Definition at line 246 of file pfqn_dmlin.h.

References pfqn_dmlin().

pfqn_dmlin() [2/3]

template<class T>

LinearizerResult< T > line::pfqn::pfqn_dmlin	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z )

Definition at line 241 of file pfqn_dmlin.h.

References pfqn_dmlin().

pfqn_dmlin() [3/3]

template<class T>

LinearizerResult< T > line::pfqn::pfqn_dmlin	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const std::vector< SchedStrategy > &	type,
		double	tol,
		int	maxiter,
		const Matrix< T > &	QN0,
		int	npasses = 3 )

de Souza e Silva-Muntz Improved Linearizer (IL).

Parameters

L	(M x R) service demands
N	(R) population per class
Z	(K x R) think times, summed over rows; may be empty
type	(M) scheduling discipline; accepted and unused, as in pfqn_linearizer, which treats every station as single-server PS
tol	convergence tolerance
maxiter	total inner-iteration budget
QN0	(M x R) warm start of the Bard-Schweitzer seed; may be empty
npasses	number of xi refresh passes (3, the Chandy-Neuse rule)

Definition at line 132 of file pfqn_dmlin.h.

References line::pfqn::LinearizerResult< T >::C, line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), line::Matrix< T >::Matrix(), oner(), pfqn_bs(), pfqn_dmlin(), line::pfqn::LinearizerResult< T >::Q, line::pfqn::AmvaResult< T >::QN, line::Matrix< T >::rows(), line::pfqn::LinearizerResult< T >::totiter, line::pfqn::LinearizerResult< T >::U, line::pfqn::LinearizerResult< T >::W, and line::pfqn::LinearizerResult< T >::X.

Referenced by pfqn_dmlin(), pfqn_dmlin(), pfqn_dmlin(), and line::mva::solver_amva().

pfqn_dnc()

template<class T>

DncResult< T > line::pfqn::pfqn_dnc	(	const std::vector< T > &	L,
		const T &	N )

Distinct-load Normalizing Constant (DNC) at a nonintegral population.

Parameters

L	(M) service demands of the queueing stations
N	population, real and nonnegative (may be fractional)

Definition at line 103 of file pfqn_dnc.h.

References line::pfqn::DncResult< T >::G, line::InputError::InputError(), line::pfqn::DncResult< T >::lG, line::NumericError::NumericError(), pfqn_dnc(), line::solve(), and line::pfqn::DncResult< T >::X.

Referenced by pfqn_dnc().

pfqn_egflinearizer() [1/2]

template<class T>

LinearizerResult< T > line::pfqn::pfqn_egflinearizer	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const std::vector< SchedStrategy > &	type,
		double	tol,
		int	maxiter,
		const std::vector< T > &	alpha,
		const Matrix< T > &	QN0,
		int	npasses = 3 )

Extended generalized fixed-point Linearizer (De Souza e Silva and Muntz's generalization of Chandy and Neuse's Linearizer, with a per-class scaling exponent alpha_r).

Parameters

L	(M x R) service demands
N	(R) population per class
Z	(K x R) think times, summed over rows; may be empty
type	(M) scheduling discipline; accepted for interface parity, but the reference recursion is discipline-independent
tol	convergence tolerance on the Frobenius norm of dQ; NaN selects the published Linearizer termination test of Chandy and Neuse, Commun. ACM 25(2), 1982, p.129, under which each Core call stops when max_{i,r}|dQ(i,r)|/N_r falls below pfqn_cntol evaluated at the population Core is running at
maxiter	total inner-iteration budget
alpha	(R) per-class scaling exponent
QN0	(M x R) warm start for the Bard-Schweitzer initialization
npasses	number of Delta refresh rounds; 3 is the Chandy-Neuse fixed rule, pfqn_scat passes 1

Definition at line 241 of file pfqn_egflinearizer.h.

References line::pfqn::LinearizerResult< T >::C, line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), is_cntol(), line::Matrix< T >::Matrix(), line::NumericError::NumericError(), oner(), pfqn_bs(), pfqn_egflinearizer(), line::pfqn::LinearizerResult< T >::Q, line::pfqn::AmvaResult< T >::QN, line::Matrix< T >::rows(), sum_rows(), line::pfqn::LinearizerResult< T >::totiter, line::pfqn::LinearizerResult< T >::U, line::pfqn::LinearizerResult< T >::W, and line::pfqn::LinearizerResult< T >::X.

Referenced by pfqn_egflinearizer(), pfqn_egflinearizer(), pfqn_gflinearizer(), pfqn_linearizer(), pfqn_linearizermx(), and pfqn_scat().

pfqn_egflinearizer() [2/2]

template<class T>

LinearizerResult< T > line::pfqn::pfqn_egflinearizer	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const std::vector< T > &	alpha )

MATLAB defaults: tol = 1e-8, maxiter = 1000, no warm start.

Definition at line 365 of file pfqn_egflinearizer.h.

References pfqn_egflinearizer().

pfqn_expand()

template<class T>

ExpandResult< T > line::pfqn::pfqn_expand	(	const Matrix< T > &	QN,
		const Matrix< T > &	UN,
		const Matrix< T > &	CN,
		const std::vector< std::size_t > &	mapping )

Expand per-station metrics from a reduced model back to the original station set.

Parameters

QN	(M' x R) reduced queue lengths
UN	(M' x R) reduced utilizations
CN	(M' x R) reduced residence times
mapping	(M) 0-based unique-station index per original station

Definition at line 52 of file pfqn_expand.h.

References line::pfqn::ExpandResult< T >::CN, line::Matrix< T >::cols(), line::InputError::InputError(), line::Matrix< T >::Matrix(), pfqn_expand(), line::pfqn::ExpandResult< T >::QN, line::Matrix< T >::rows(), and line::pfqn::ExpandResult< T >::UN.

Referenced by pfqn_expand().

pfqn_explicit()

template<class T>

ExplicitResult< T > line::pfqn::pfqn_explicit	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		double	tol = std::numeric_limits<double>::epsilon(),
		const std::string &	method = "auto",
		double	maxloss = std::numeric_limits<double>::infinity() )

Explicit closed-form normalizing constant of a multiclass closed network.

Parameters

L	(K x R) service demands of single-server load-independent queues
N	population per class
tol	relative tolerance declaring two induced demands redundant
method	"auto", "distinct" (force Eq. 15) or "repeated" (force Eq. 16)
maxloss	cancellation budget in decimal digits; a finite value turns the overrun into a silent REFUSAL (valid = false) for callers that hold a fallback, the default keeps the result whatever it costs

Definition at line 276 of file pfqn_explicit.h.

References line::Matrix< T >::cols(), line::pfqn::ExplicitResult< T >::G, line::InputError::InputError(), line::pfqn::ExplicitResult< T >::lG, line::pfqn::ExplicitResult< T >::lossDigits, line::pfqn::ExplicitResult< T >::method, pfqn_explicit(), line::Matrix< T >::rows(), and line::pfqn::ExplicitResult< T >::valid.

Referenced by pfqn_explicit(), and pfqn_nc().

pfqn_explicit_ld()

template<class T>

ExplicitResult< T > line::pfqn::pfqn_explicit_ld	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	mu,
		double	tol = std::numeric_limits<double>::epsilon(),
		const std::string &	method = "auto",
		double	maxloss = std::numeric_limits<double>::infinity() )

Explicit closed-form normalizing constant of a multiclass LIMITED LOAD-DEPENDENT network.

Parameters

L	(M x R) service demands
N	population per class
mu	(M x >= sum(N)) load-dependent rate lattice, alpha_i(j) = mu(i,j-1); an empty matrix means 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 overrun into a silent REFUSAL (valid = false) for callers that hold a fallback, the default keeps the result whatever it costs

Definition at line 178 of file pfqn_explicit_ld.h.

References line::Matrix< T >::cols(), line::pfqn::ExplicitResult< T >::G, line::InputError::InputError(), line::pfqn::ExplicitResult< T >::lG, line::pfqn::ExplicitResult< T >::lossDigits, line::pfqn::ExplicitResult< T >::method, pfqn_explicit_ld(), line::Matrix< T >::rows(), and line::pfqn::ExplicitResult< T >::valid.

Referenced by pfqn_explicit_ld(), and pfqn_ncld().

pfqn_fli()

template<class T>

WsResult< T > line::pfqn::pfqn_fli	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		double	tol = 1e-6,
		std::size_t	max_iter = 1000 )

Wang-Sevcik Fraction-Line.

Definition at line 210 of file pfqn_wangsevcik.h.

References Fli, pfqn_fli(), and pfqn_wangsevcik().

Referenced by pfqn_fli().

pfqn_fnc() [1/2]

template<class T>

FncResult< T > line::pfqn::pfqn_fnc

(

const Matrix< T > &

alpha

)

Automatic offset search (the one-argument MATLAB branch).

Definition at line 166 of file pfqn_fnc.h.

References line::pfqn::FncResult< T >::c, line::Matrix< T >::cols(), line::Matrix< T >::Matrix(), line::pfqn::FncResult< T >::mu, pfqn_fnc(), pfqn_fnc_at(), and line::Matrix< T >::rows().

Referenced by pfqn_fnc(), pfqn_fnc(), pfqn_ncldmx(), and line::nc::solver_ncld().

pfqn_fnc() [2/2]

template<class T>

FncResult< T > line::pfqn::pfqn_fnc	(	const Matrix< T > &	alpha,
		const std::vector< T > &	c )

Definition at line 193 of file pfqn_fnc.h.

References line::pfqn::FncResult< T >::c, line::pfqn::FncResult< T >::mu, pfqn_fnc(), and pfqn_fnc_at().

pfqn_fnc_at()

template<class T>

Matrix< T > line::pfqn::pfqn_fnc_at	(	const Matrix< T > &	alpha,
		const std::vector< T > &	c )

Rates for a given offset vector c (the two-argument MATLAB branch).

Definition at line 104 of file pfqn_fnc.h.

References line::Matrix< T >::cols(), line::InputError::InputError(), line::Matrix< T >::Matrix(), line::NumericError::NumericError(), pfqn_fnc_at(), and line::Matrix< T >::rows().

Referenced by pfqn_fnc(), pfqn_fnc(), and pfqn_fnc_at().

pfqn_gerasimov() [1/2]

template<class T>

NcResult< T > line::pfqn::pfqn_gerasimov	(	const Matrix< T > &	L,
		const std::vector< int > &	N )

Delay-free overload.

Definition at line 512 of file pfqn_gerasimov.h.

References pfqn_gerasimov().

pfqn_gerasimov() [2/2]

template<class T>

NcResult< T > line::pfqn::pfqn_gerasimov	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		double	tol = 1e-12,
		std::size_t	maxterms = 200000 )

Exact normalizing constant of a closed multiclass product-form network by ITERATED RESIDUES of its rational generating function, one class at a time.

Parameters

L	(M x R) service demands, M queueing stations, R classes
N	(R) population per class, nonnegative
Z	(K x R) think times, summed over rows; may be empty. A delay contributes the entire factor exp(sum_s Z_s u_s), handled exactly by convolving its Poisson coefficients into each elimination.
tol	relative tolerance for declaring two affine forms proportional, hence one pole rather than two. Ignored (taken as exactly zero) in the exact backend.
maxterms	cap on the residue terms carried between eliminations. Exceeding it is an error, not a truncation: a truncated residue sum is not a bound or an approximation of G, it is a wrong number.

Definition at line 408 of file pfqn_gerasimov.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), line::num_pow_int(), pfqn_gerasimov(), and line::Matrix< T >::rows().

Referenced by pfqn_gerasimov(), pfqn_gerasimov(), and pfqn_nc().

pfqn_gflinearizer() [1/2]

template<class T>

LinearizerResult< T > line::pfqn::pfqn_gflinearizer	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const std::vector< SchedStrategy > &	type,
		double	tol,
		int	maxiter,
		const T &	alpha,
		const Matrix< T > &	QN0 )

Generalized fixed-point Linearizer with a single scaling exponent shared by every class (De Souza e Silva and Muntz).

Parameters

alpha	scaling exponent shared by every class
L	(M x R) service demands
N	(R) population per class
Z	(K x R) think times
type	per-station scheduling strategy
tol	convergence tolerance
maxiter	iteration cap
QN0	queue lengths that warm-start the iteration; empty for a cold start

See also

pfqn_egflinearizer for the remaining arguments

Definition at line 52 of file pfqn_gflinearizer.h.

References pfqn_egflinearizer(), and pfqn_gflinearizer().

Referenced by pfqn_gflinearizer(), pfqn_gflinearizer(), and pfqn_linearizermx().

pfqn_gflinearizer() [2/2]

template<class T>

LinearizerResult< T > line::pfqn::pfqn_gflinearizer	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const T &	alpha )

Definition at line 62 of file pfqn_gflinearizer.h.

References pfqn_gflinearizer().

pfqn_gld() [1/2]

template<class T>

NcResult< T > line::pfqn::pfqn_gld	(	const Matrix< T > &	L,
		const std::vector< int > &	N )

Overload with all rates equal to one, i.e.

every station a single server.

Definition at line 295 of file pfqn_gld.h.

References pfqn_gld(), and line::Matrix< T >::rows().

pfqn_gld() [2/2]

template<class T>

NcResult< T > line::pfqn::pfqn_gld	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	mu )

Exact normalizing constant of a closed product-form network whose stations may be load dependent (generalized Buzen, Reiser-Kobayashi 1975).

Parameters

L	(M x R) service demands, M stations and R closed classes
N	(R) population per class
mu	(M x Nt') load-dependent service rates, Nt' >= sum(N); mu(i,k-1) is the rate of station i while it holds k jobs. A row of all ones is a single server, the row 1, 2, ..., Nt is an infinite server.

Exceptions

InputError

on a dimension mismatch, on a rate matrix with fewer columns than the total population, or on a zero rate (which would make the balance function undefined rather than infinite).

Definition at line 150 of file pfqn_gld.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), Ls, line::next_pop(), line::num_factorial(), line::num_pow_int(), pfqn_gld(), line::plane_sizes(), line::pop_index(), line::population_count(), and line::Matrix< T >::rows().

Referenced by pfqn_gld(), pfqn_gld(), pfqn_ncld(), and pfqn_nre_full().

pfqn_gldsingle()

template<class T>

NcResult< T > line::pfqn::pfqn_gldsingle	(	const Matrix< T > &	L,
		int	N,
		const Matrix< T > &	mu )

Exact normalizing constant of a SINGLE-CLASS closed network whose stations are load dependent.

Parameters

L	(M x 1) service demands, one class
N	population
mu	(M x >=N) load-dependent rates, mu(i,k) with k jobs at station i

Definition at line 72 of file pfqn_gldsingle.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), line::NumericError::NumericError(), pfqn_gldsingle(), and line::Matrix< T >::rows().

Referenced by pfqn_gldsingle().

pfqn_grnmol()

template<class T>

T line::pfqn::pfqn_grnmol	(	const Matrix< T > &	L,
		const std::vector< int > &	N )

Normalizing constant by the closed-form Grundmann-Moeller rule.

Parameters

L	(M x R) demands,
N	(R) population with an ODD total

Returns

the normalizing constant

Definition at line 87 of file pfqn_grnmol.h.

References line::Matrix< T >::cols(), line::InputError::InputError(), line::num_factorial(), line::num_pow_int(), pfqn_grnmol(), and line::Matrix< T >::rows().

Referenced by pfqn_grnmol().

pfqn_harel_bounds() [1/2]

template<class T>

HarelBoundsResult< T > line::pfqn::pfqn_harel_bounds	(	const std::vector< T > &	rho,
		int	N )

Zero think time, default extrapolation ceiling min(N, 7).

Definition at line 257 of file pfqn_harel_bounds.h.

References pfqn_harel_bounds().

pfqn_harel_bounds() [2/2]

template<class T>

HarelBoundsResult< T > line::pfqn::pfqn_harel_bounds	(	const std::vector< T > &	rho,
		int	N,
		const T &	Z,
		int	maxUB )

Both bounds, plus the exact throughputs the upper bounds extrapolate from.

Parameters

maxUB

largest extrapolation point; defaults to min(N, 7) when <= 0

Definition at line 219 of file pfqn_harel_bounds.h.

References line::InputError::InputError(), line::pfqn::HarelBoundsResult< T >::k, line::pfqn::HarelBoundsResult< T >::LB, line::pfqn::HarelBoundsResult< T >::maxUB, line::pfqn::HarelBoundsResult< T >::N, line::NumericError::NumericError(), pfqn_harel_bounds(), line::pfqn::HarelBoundsResult< T >::TH, and line::pfqn::HarelBoundsResult< T >::UB.

Referenced by pfqn_harel_bounds(), pfqn_harel_bounds(), and line::ba::solver_ba_analyzer().

pfqn_harel_lb() [1/2]

template<class T>

T line::pfqn::pfqn_harel_lb	(	const std::vector< T > &	rho,
		int	N )

Zero think time.

Definition at line 181 of file pfqn_harel_bounds.h.

References pfqn_harel_lb().

pfqn_harel_lb() [2/2]

template<class T>

T line::pfqn::pfqn_harel_lb	(	const std::vector< T > &	rho,
		int	N,
		const T &	Z )

Lower bound alone.

Parameters

rho	(k) relative utilizations, all strictly positive
N	population, at least 1
Z	think time; must be zero

Definition at line 171 of file pfqn_harel_bounds.h.

References line::InputError::InputError(), and pfqn_harel_lb().

Referenced by pfqn_harel_lb(), and pfqn_harel_lb().

pfqn_harel_ub() [1/2]

template<class T>

T line::pfqn::pfqn_harel_ub	(	const std::vector< T > &	rho,
		int	N,
		int	n )

Zero think time.

Definition at line 209 of file pfqn_harel_bounds.h.

References pfqn_harel_ub().

pfqn_harel_ub() [2/2]

template<class T>

T line::pfqn::pfqn_harel_ub	(	const std::vector< T > &	rho,
		int	N,
		int	n,
		const T &	Z )

Upper bound extrapolated from the exact throughput at population n.

Parameters

n	extrapolation point, 2 <= n <= min(N, 7)

Definition at line 191 of file pfqn_harel_bounds.h.

References line::InputError::InputError(), line::NumericError::NumericError(), and pfqn_harel_ub().

Referenced by pfqn_harel_ub(), and pfqn_harel_ub().

pfqn_hst() [1/3]

template<class T>

HstResult< T > line::pfqn::pfqn_hst	(	const std::vector< T > &	L,
		int	N )

MATLAB default: no think time and the bottleneck station.

Definition at line 193 of file pfqn_hst.h.

References pfqn_hst().

pfqn_hst() [2/3]

template<class T>

HstResult< T > line::pfqn::pfqn_hst	(	const std::vector< T > &	L,
		int	N,
		const T &	Z )

MATLAB default: the bottleneck station, argmax L.

Definition at line 183 of file pfqn_hst.h.

References line::InputError::InputError(), and pfqn_hst().

pfqn_hst() [3/3]

template<class T>

HstResult< T > line::pfqn::pfqn_hst	(	const std::vector< T > &	L,
		int	N,
		const T &	Z,
		std::size_t	ist )

Operational sensitivity of throughput to homogeneous-service-time (HST) violations, and the constrained worst case (Suri 1983).

Parameters

L	(M) service demands of the queueing stations
N	population, an integer of at least one job
Z	think time
ist	0-based station the HST perturbation is applied to

Definition at line 86 of file pfqn_hst.h.

References line::pfqn::HstResult< T >::astar, line::pfqn::HstResult< T >::c, line::InputError::InputError(), line::pfqn::RgfResult< T >::lg, line::pfqn::HstResult< T >::p, pfqn_hst(), pfqn_rgf(), line::pfqn::HstResult< T >::Pgeq, line::pfqn::HstResult< T >::Q, line::pfqn::HstResult< T >::station, line::pfqn::HstResult< T >::total, line::pfqn::HstResult< T >::U, line::pfqn::HstResult< T >::worst, and line::pfqn::HstResult< T >::X.

Referenced by pfqn_hst(), pfqn_hst(), and pfqn_hst().

pfqn_is() [1/2]

template<class T>

NcResult< T > line::pfqn::pfqn_is	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		McRng &	rng )

Reference default of 1e4 samples.

Definition at line 60 of file pfqn_is.h.

References pfqn_is().

pfqn_is() [2/2]

template<class T>

NcResult< T > line::pfqn::pfqn_is	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		std::size_t	samples,
		McRng &	rng )

Importance-sampling estimate of the normalizing constant of a closed LOAD-INDEPENDENT product-form network.

Parameters

L	(M x R) per-class demands at the M single-server queues
N	(R) closed population vector
Z	(R) aggregated think times; empty or all zero for no delay
samples	number of importance samples
rng	explicit generator, advanced by the call

Definition at line 50 of file pfqn_is.h.

References pfqn_is(), and pfqn_ld_is().

Referenced by pfqn_is(), pfqn_is(), and pfqn_nc().

pfqn_jdfun() [1/2]

template<class T>

std::vector< T > line::pfqn::pfqn_jdfun	(	const Matrix< T > &	nvec,
		const std::vector< JdScaling< T > > &	jdscaling )

MATLAB default: classIdx = 1, i.e.

the first class.

Definition at line 84 of file pfqn_jdfun.h.

References pfqn_jdfun().

pfqn_jdfun() [2/2]

template<class T>

std::vector< T > line::pfqn::pfqn_jdfun	(	const Matrix< T > &	nvec,
		const std::vector< JdScaling< T > > &	jdscaling,
		std::size_t	classIdx )

AMVA joint-dependence function for non-product-form scaling.

Parameters

nvec	(M x R) per-station, per-class populations
jdscaling	(M) callables; entries may be empty for "no scaling"
classIdx	0-based class whose scaling is selected from a vector result

Returns

(M) reciprocals of the scalings

Definition at line 59 of file pfqn_jdfun.h.

References line::Matrix< T >::cols(), line::InputError::InputError(), line::NumericError::NumericError(), pfqn_jdfun(), and line::Matrix< T >::rows().

Referenced by pfqn_jdfun(), pfqn_jdfun(), and line::mva::solver_amvald().

pfqn_joint() [1/2]

template<class T>

T line::pfqn::pfqn_joint	(	const Matrix< int > &	n,
		const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z )

Overload computing G with pfqn_ca first, matching the reference's default.

Definition at line 175 of file pfqn_joint.h.

References pfqn_ca(), and pfqn_joint().

pfqn_joint() [2/2]

template<class T>

T line::pfqn::pfqn_joint	(	const Matrix< int > &	n,
		const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const T &	G )

Joint probability of a PER-CLASS occupancy matrix.

Parameters

n	(M x R) per-station, per-class occupancy
L	(M x R) service demands
N	(R) populations
Z	(K x R) think times, summed over rows; may be empty
G	the normalizing constant G(N)

Definition at line 69 of file pfqn_joint.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), line::num_factorial(), line::num_pow_int(), line::NumericError::NumericError(), pfqn_joint(), and line::Matrix< T >::rows().

Referenced by pfqn_joint(), and pfqn_joint().

pfqn_joint_total() [1/2]

template<class T>

T line::pfqn::pfqn_joint_total	(	const std::vector< int > &	m,
		const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z )

Definition at line 181 of file pfqn_joint.h.

References pfqn_ca(), and pfqn_joint_total().

pfqn_joint_total() [2/2]

template<class T>

T line::pfqn::pfqn_joint_total	(	const std::vector< int > &	m,
		const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const T &	G )

Joint probability of the per-station TOTAL queue lengths.

Parameters

m	(M) per-station total occupancy; the delay takes the remainder
L	(M x R) service demands
N	(R) populations
Z	(K x R) think times, summed over rows; may be empty
G	the normalizing constant G(N)

Definition at line 132 of file pfqn_joint.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), line::NumericError::NumericError(), pfqn_joint_total(), pfqn_jointmarg(), and line::Matrix< T >::rows().

Referenced by pfqn_joint_total(), and pfqn_joint_total().

pfqn_jointmarg() [1/2]

template<class T>

T line::pfqn::pfqn_jointmarg	(	const std::vector< int > &	n,
		const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< std::size_t > &	infset,
		const std::string &	engine = "exact",
		std::uint64_t	seed = 0 )

Overload computing G with pfqn_ca first, matching the reference's default.

Definition at line 259 of file pfqn_jointmarg.h.

References line::Matrix< T >::cols(), line::Matrix< T >::Matrix(), pfqn_ca(), pfqn_jointmarg(), and line::Matrix< T >::rows().

pfqn_jointmarg() [2/2]

template<class T>

T line::pfqn::pfqn_jointmarg	(	const std::vector< int > &	n,
		const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< std::size_t > &	infset,
		const T &	G,
		const std::string &	engine = "exact",
		std::uint64_t	seed = 0 )

Joint probability of the per-station TOTAL queue lengths.

Parameters

n	(M) per-station total queue lengths, infinite servers included
L	(M x R) demand matrix, infinite-server rows included
N	(R) per-class populations
infset	rows of L that are infinite-server stations, 0-based
G	the normalizing constant G(N)
engine	"exact" (default), "spm", "bethe", "heur", "huberlaw" or "adapart". "spm" is the only engine that does NOT expand the matrix to order sum(N): it takes the row-replicated matrix with the class populations as column multiplicities, which is the regime its saddle-point expansion is asymptotically exact in, so its cost does not grow with the population and its relative error is O((R-1)/min(N)). Measured on a 3-station 2-class model, 12.8% at N = (1,1), 4.2% at (3,3), 2.1% at (6,6); it degrades the other way round, when the CLASS COUNT grows at fixed population (2.7% at R = 2, 21% at R = 7, both at N_r = 3), because R-1 is the dimension being expanded in. The bias is nearly constant across the lattice, so a caller that renormalizes a full sweep keeps far less of it: total variation distance 5.0e-3 at N = (1,1), 8.4e-4 at (3,3), 4.3e-4 at (5,5), better than "bethe" and "heur" at every population measured.
seed	seed of the two sampling engines

Definition at line 186 of file pfqn_jointmarg.h.

References line::Matrix< T >::cols(), line::InputError::InputError(), line::num_factorial(), line::NumericError::NumericError(), line::perm::perm_adapart(), line::perm::perm_bethe(), line::perm::perm_heur(), line::perm::perm_huberlaw(), line::perm::perm_spm(), pfqn_jointmarg(), pfqn_perm(), and line::Matrix< T >::rows().

Referenced by pfqn_joint_total(), pfqn_jointmarg(), pfqn_jointmarg(), and line::nc::solver_nc_jointmarg().

pfqn_kt() [1/2]

template<class T>

KtResult< T > line::pfqn::pfqn_kt	(	const Matrix< T > &	L,
		const std::vector< T > &	N )

Definition at line 318 of file pfqn_kt.h.

References pfqn_kt().

pfqn_kt() [2/2]

template<class T>

KtResult< T > line::pfqn::pfqn_kt	(	const Matrix< T > &	L0,
		const std::vector< T > &	N0,
		const std::vector< T > &	Z0 )

Knessl-Tier asymptotic expansion of the normalizing constant.

Parameters

L0	(M x R) demands
N0	(R) population
Z0	(R) think times

Definition at line 71 of file pfqn_kt.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::pfqn::KtResult< T >::G, line::InputError::InputError(), line::pfqn::KtResult< T >::lG, line::NumericError::NumericError(), pfqn_aql(), pfqn_bs(), pfqn_kt(), line::pfqn::KtResult< T >::Q, line::pfqn::AmvaResult< T >::QN, line::Matrix< T >::rows(), line::solve(), line::pfqn::KtResult< T >::X, and line::pfqn::AmvaResult< T >::XN.

Referenced by pfqn_bkt(), pfqn_kt(), pfqn_kt(), and pfqn_nc().

pfqn_lap()

template<class T>

T line::pfqn::pfqn_lap	(	const std::vector< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z )

Laplace approximation of the normalizing constant of a repairman (single-queue, multiclass) model.

Parameters

L	(R) per-class demand at the single station
N	(R) per-class population
Z	(R) per-class think time

Returns

log of the approximate normalizing constant

Definition at line 69 of file pfqn_lap.h.

References finish_lap(), line::InputError::InputError(), line::num_abs(), line::NumericError::NumericError(), and pfqn_lap().

Referenced by pfqn_lap().

pfqn_lcfsqn_ca()

template<class T>

LcfsQnResult< T > line::pfqn::pfqn_lcfsqn_ca	(	const std::vector< T > &	alpha,
		const std::vector< T > &	beta,
		const std::vector< int > &	N )

Convolution algorithm for the two-station multiclass LCFS queueing network of Casale, "A family of multiclass LCFS queueing networks with order-dependent product-form solutions", QUESTA 2026.

Parameters

alpha	(R) mean service times at the LCFS station
beta	(R) mean service times at the LCFS-PR station
N	(R) population per class

Definition at line 62 of file pfqn_lcfsqn_ca.h.

References line::InputError::InputError(), line::next_pop(), line::num_pow_int(), pfqn_lcfsqn_ca(), line::plane_sizes(), line::pop_index(), and line::population_count().

Referenced by pfqn_lcfsqn_ca(), and line::nc::solver_nc_lcfsqn().

pfqn_lcfsqn_mva()

template<class T>

LcfsMvaResult< T > line::pfqn::pfqn_lcfsqn_mva	(	const std::vector< T > &	alpha,
		const std::vector< T > &	beta,
		const std::vector< int > &	N )

Exact mean value analysis of the two-station multiclass LCFS network of Casale, QUESTA 2026 (station 1 LCFS, station 2 LCFS-PR).

Parameters

alpha	(R) mean service times at the LCFS station
beta	(R) mean service times at the LCFS-PR station
N	(R) population per class

Definition at line 81 of file pfqn_lcfsqn_mva.h.

References line::pfqn::LcfsMvaResult< T >::B, line::InputError::InputError(), line::Matrix< T >::Matrix(), line::next_pop(), line::num_pow_int(), line::NumericError::NumericError(), pfqn_lcfsqn_mva(), line::plane_sizes(), line::pop_index(), line::population_count(), line::pfqn::LcfsMvaResult< T >::Q, line::pfqn::LcfsMvaResult< T >::T_, and line::pfqn::LcfsMvaResult< T >::U.

Referenced by pfqn_lcfsqn_mva(), and line::mva::solver_mva_lcfsqn().

pfqn_lcfsqn_nc()

template<class T>

T line::pfqn::pfqn_lcfsqn_nc	(	const std::vector< T > &	alpha,
		const std::vector< T > &	beta,
		const std::vector< int > &	N )

Normalizing constant of the two-station multiclass LCFS network as a sum of PERMANENTS, the closed form of Casale, QUESTA 2026.

Parameters

alpha	(R) mean service times at the LCFS station
beta	(R) mean service times at the LCFS-PR station
N	(R) population per class

Definition at line 79 of file pfqn_lcfsqn_nc.h.

References line::InputError::InputError(), line::num_factorial(), line::num_pow_int(), pfqn_lcfsqn_nc(), and pfqn_perm().

Referenced by pfqn_lcfsqn_nc().

pfqn_lcp() [1/3]

template<class T>

AmvaResult< T > line::pfqn::pfqn_lcp	(	const Matrix< T > &	L,
		const std::vector< T > &	N )

Definition at line 154 of file pfqn_lcp.h.

References pfqn_lcp().

pfqn_lcp() [2/3]

template<class T>

AmvaResult< T > line::pfqn::pfqn_lcp	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z )

Definition at line 149 of file pfqn_lcp.h.

References pfqn_lcp().

pfqn_lcp() [3/3]

template<class T>

AmvaResult< T > line::pfqn::pfqn_lcp	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		const std::vector< AmvaSched > &	type,
		double	tol = 1e-6,
		std::size_t	maxiter = 1000,
		const Matrix< T > &	QN0 = Matrix<T>() )

Bard Large Customer Population (LCP) approximate MVA.

Parameters

L	(M x R) demands
N	(R) populations
Z	(R) think times, empty for none
type	(M) per-station scheduling, empty for all PS
tol	convergence tolerance
maxiter	iteration cap
QN0	queue lengths that warm-start the iteration; empty for a cold start

Definition at line 57 of file pfqn_lcp.h.

References line::Matrix< T >::cols(), line::pfqn::AmvaResult< T >::converged, FCFS, line::InputError::InputError(), line::pfqn::AmvaResult< T >::iterations, line::Matrix< T >::Matrix(), line::NumericError::NumericError(), pfqn_lcp(), line::pfqn::AmvaResult< T >::QN, line::pfqn::AmvaResult< T >::RN, line::Matrix< T >::rows(), line::pfqn::AmvaResult< T >::UN, and line::pfqn::AmvaResult< T >::XN.

Referenced by pfqn_chow(), pfqn_lcp(), pfqn_lcp(), pfqn_lcp(), and line::mva::solver_amva().

pfqn_ld_is() [1/2]

template<class T>

NcResult< T > line::pfqn::pfqn_ld_is	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const Matrix< T > &	mu,
		McRng &	rng )

Reference default of 1e4 samples.

Definition at line 176 of file pfqn_ld_is.h.

References pfqn_ld_is().

pfqn_ld_is() [2/2]

template<class T>

NcResult< T > line::pfqn::pfqn_ld_is	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const Matrix< T > &	mu,
		std::size_t	samples,
		McRng &	rng )

Importance-sampling estimate of the normalizing constant of a closed LOAD-DEPENDENT product-form network.

Parameters

L	(M x R) per-class demands at the M queueing stations
N	(R) closed population vector
Z	(R) aggregated think times; empty or all zero for no delay
mu	(M x k) load-dependent capacities, mu(i,k-1) with k jobs at station i; empty for the load-independent case mu = 1. A short row is extended with its last entry, as in the reference.
samples	number of importance samples
rng	explicit generator, advanced by the call

Definition at line 81 of file pfqn_ld_is.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), mc_uniform_int(), pfqn_ld_is(), and line::Matrix< T >::rows().

Referenced by pfqn_is(), pfqn_ld_is(), pfqn_ld_is(), and pfqn_ncld().

pfqn_ldbcmp() [1/2]

template<class T>

LdBcmpBound< T > line::pfqn::pfqn_ldbcmp	(	const std::vector< T > &	L,
		const T &	N,
		const T &	Z )

Definition at line 151 of file pfqn_ldbcmp.h.

References pfqn_ldbcmp().

pfqn_ldbcmp() [2/2]

template<class T>

LdBcmpBound< T > line::pfqn::pfqn_ldbcmp	(	const std::vector< T > &	L,
		const T &	N,
		const T &	Z,
		const std::vector< T > &	c,
		const T &	tol )

Anselmi-Cremonesi (2008) lower throughput bound for a closed single-class BCMP network with load-dependent stations.

Parameters

L	(M) limiting demands,
N	population,
Z	think time
c	(M) Heffes coefficients, empty for all fixed-rate stations
tol	relative fixed-point tolerance (MATLAB default 1e-10)

Definition at line 64 of file pfqn_ldbcmp.h.

References line::pfqn::LdBcmpBound< T >::applicable, line::InputError::InputError(), line::num_abs(), line::num_pow_int(), line::NumericError::NumericError(), pfqn_ldbcmp(), line::pfqn::LdBcmpBound< T >::Qhat, line::pfqn::LdBcmpBound< T >::Rhi, line::UnsupportedError::UnsupportedError(), and line::pfqn::LdBcmpBound< T >::Xlo.

Referenced by line::ba::method_degenerate(), pfqn_ldbcmp(), pfqn_ldbcmp(), and line::ba::solver_ba_analyzer().

pfqn_ldmx_ec()

template<class T>

LdmxEcResult< T > line::pfqn::pfqn_ldmx_ec	(	const std::vector< T > &	lambda,
		const Matrix< T > &	D,
		const Matrix< T > &	mu )

Bruell-Balbo-Afshari effective-capacity terms for a MIXED open/closed network with limited load dependence.

Parameters

lambda	(R) arrival rates, zero on the closed classes
D	(M x R) service demands
mu	(M x Nt) load-dependent rate lattice

Definition at line 70 of file pfqn_ldmx_ec.h.

References line::Matrix< T >::cols(), line::pfqn::LdmxEcResult< T >::E, line::pfqn::LdmxEcResult< T >::EC, line::pfqn::LdmxEcResult< T >::Eprime, line::InputError::InputError(), line::pfqn::LdmxEcResult< T >::Lo, line::Matrix< T >::Matrix(), line::num_pow_int(), line::NumericError::NumericError(), pfqn_ldmx_ec(), and line::Matrix< T >::rows().

Referenced by pfqn_ldmx_ec(), and pfqn_ncldmx().

pfqn_le() [1/2]

template<class T>

LeResult< T > line::pfqn::pfqn_le	(	const Matrix< T > &	L,
		const std::vector< T > &	N )

Definition at line 322 of file pfqn_le.h.

References pfqn_le().

pfqn_le() [2/2]

template<class T>

LeResult< T > line::pfqn::pfqn_le	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z )

Logistic expansion estimate of the normalizing constant.

Parameters

L	(M x R) demands,
N	(R) population,
Z	(R) think times (pass an empty vector or all zeros for the Z = 0 branch)

Definition at line 245 of file pfqn_le.h.

References line::Matrix< T >::cols(), line::pfqn::LeResult< T >::G, line::pfqn::LeResult< T >::lG, pfqn_le(), pfqn_le_fpi(), pfqn_le_fpiZ(), pfqn_le_hessian(), pfqn_le_hessianZ(), line::Matrix< T >::rows(), and line::lang::GlobalConstants::Zero.

Referenced by pfqn_aghq(), pfqn_ble(), pfqn_le(), pfqn_le(), and pfqn_nc().

pfqn_le_fpi()

template<class T>

std::vector< T > line::pfqn::pfqn_le_fpi	(	const Matrix< T > &	L,
		const std::vector< T > &	N )

Mode of the logistic-transformed integrand, Z = 0 case (pfqn_le_fpi).

Definition at line 59 of file pfqn_le.h.

References line::Matrix< T >::cols(), line::InputError::InputError(), line::num_abs(), pfqn_le_fpi(), and line::Matrix< T >::rows().

Referenced by pfqn_aghq(), pfqn_le(), pfqn_le_fpi(), and pfqn_ls().

pfqn_le_fpiZ()

template<class T>

void line::pfqn::pfqn_le_fpiZ	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		std::vector< T > &	u,
		T &	v )

Mode of the logistic-transformed integrand, Z > 0 case (pfqn_le_fpiZ).

Definition at line 91 of file pfqn_le.h.

References line::Matrix< T >::cols(), line::InputError::InputError(), line::num_abs(), pfqn_le_fpiZ(), and line::Matrix< T >::rows().

Referenced by pfqn_le(), pfqn_le_fpiZ(), pfqn_ls(), and line::pfqn::simplex::simplex_mode().

pfqn_le_hessian()

template<class T>

Matrix< T > line::pfqn::pfqn_le_hessian	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	u0 )

Hessian of the Z = 0 logistic integrand at the mode ((M-1) x (M-1)).

Definition at line 136 of file pfqn_le.h.

References line::Matrix< T >::cols(), line::InputError::InputError(), pfqn_le_hessian(), and line::Matrix< T >::rows().

Referenced by pfqn_aghq(), pfqn_le(), pfqn_le_hessian(), and pfqn_ls().

pfqn_le_hessianZ()

template<class T>

Matrix< T > line::pfqn::pfqn_le_hessianZ	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		const std::vector< T > &	u,
		const T &	v )

Hessian of the Z > 0 logistic integrand at the mode (M x M).

Definition at line 174 of file pfqn_le.h.

References line::Matrix< T >::cols(), pfqn_le_hessianZ(), and line::Matrix< T >::rows().

Referenced by pfqn_le(), pfqn_le_hessianZ(), and pfqn_ls().

pfqn_lekt() [1/2]

template<class T>

LektResult< T > line::pfqn::pfqn_lekt	(	const Matrix< T > &	L,
		const std::vector< T > &	N )

Definition at line 132 of file pfqn_lekt.h.

References pfqn_lekt().

pfqn_lekt() [2/2]

template<class T>

LektResult< T > line::pfqn::pfqn_lekt	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z )

The common corrected asymptotic expansion (LE-KT), computed on the cheaper side.

Parameters

L	(M x R) demands,
N	(R) population,
Z	(R) think times (pass an empty vector or all zeros for the Z = 0 branch)

Definition at line 87 of file pfqn_lekt.h.

References line::Matrix< T >::cols(), line::pfqn::KtResult< T >::G, line::pfqn::LektResult< T >::G, line::pfqn::LeResult< T >::G, line::pfqn::KtResult< T >::lG, line::pfqn::LektResult< T >::lG, line::pfqn::LeResult< T >::lG, pfqn_bkt(), pfqn_ble(), pfqn_lekt(), pfqn_lekt_route(), line::pfqn::LektResult< T >::route, line::Matrix< T >::rows(), and line::lang::GlobalConstants::Zero.

Referenced by pfqn_lekt(), pfqn_lekt(), and pfqn_nc().

pfqn_lekt_route()

template<class T>

std::string line::pfqn::pfqn_lekt_route	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z )

"kt" when R <= M or a class self-loops, "le" otherwise.

Definition at line 63 of file pfqn_lekt.h.

References line::Matrix< T >::cols(), pfqn_lekt_route(), and line::Matrix< T >::rows().

Referenced by pfqn_lekt(), and pfqn_lekt_route().

pfqn_linearizer() [1/3]

template<class T>

LinearizerResult< T > line::pfqn::pfqn_linearizer	(	const Matrix< T > &	L,
		const std::vector< int > &	N )

Definition at line 65 of file pfqn_linearizer.h.

References pfqn_linearizer().

pfqn_linearizer() [2/3]

template<class T>

LinearizerResult< T > line::pfqn::pfqn_linearizer	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z )

Definition at line 59 of file pfqn_linearizer.h.

References pfqn_linearizer().

pfqn_linearizer() [3/3]

template<class T>

LinearizerResult< T > line::pfqn::pfqn_linearizer	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const std::vector< SchedStrategy > &	type,
		double	tol,
		int	maxiter,
		const Matrix< T > &	QN0 )

Chandy-Neuse Linearizer for single-server stations.

Parameters

L	(M x R) service demands
N	(R) population per class
Z	(K x R) think times, summed over rows; may be empty
type	(M) scheduling discipline; carried, see pfqn_egflinearizer
tol	convergence tolerance
maxiter	total inner-iteration budget
QN0	(M x R) warm start; may be empty

Definition at line 49 of file pfqn_linearizer.h.

References pfqn_egflinearizer(), and pfqn_linearizer().

Referenced by pfqn_linearizer(), pfqn_linearizer(), pfqn_linearizer(), and pfqn_linearizermx().

pfqn_linearizerms() [1/2]

template<class T>

LinearizerResult< T > line::pfqn::pfqn_linearizerms	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const std::vector< int > &	nservers )

MATLAB defaults: all stations PS, tol = 1e-8, maxiter = 1000, no warm start.

Definition at line 426 of file pfqn_linearizerms.h.

References pfqn_linearizerms().

pfqn_linearizerms() [2/2]

template<class T>

LinearizerResult< T > line::pfqn::pfqn_linearizerms	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const std::vector< int > &	nservers,
		const std::vector< SchedStrategy > &	type,
		double	tol,
		int	maxiter,
		const Matrix< T > &	QN0 )

Multiserver Linearizer (Krzesinski's Linearizer as described in Conway 1989, with De Souza e Silva and Muntz's presentation of the marginal-probability recursions).

Parameters

L	(M x R) service demands
N	(R) population per class
Z	(K x R) think times, summed over rows; may be empty
nservers	(M) number of servers per station, at least one
type	(M) scheduling discipline; the FCFS arm is taken only if every station is FCFS, as in MATLAB
tol	convergence tolerance
maxiter	total inner-iteration budget
QN0	(M x R) warm start for the Bard-Schweitzer initialization

Definition at line 298 of file pfqn_linearizerms.h.

References line::pfqn::LinearizerResult< T >::C, line::Matrix< T >::cols(), line::Matrix< T >::empty(), FCFS, line::InputError::InputError(), line::Matrix< T >::Matrix(), oner(), pfqn_bs(), pfqn_linearizerms(), line::pfqn::LinearizerResult< T >::Q, line::pfqn::AmvaResult< T >::QN, line::Matrix< T >::rows(), sum_rows(), line::pfqn::LinearizerResult< T >::totiter, line::pfqn::LinearizerResult< T >::U, line::pfqn::LinearizerResult< T >::W, and line::pfqn::LinearizerResult< T >::X.

Referenced by pfqn_linearizerms(), pfqn_linearizerms(), and pfqn_linearizermx().

pfqn_linearizermx() [1/2]

template<class T>

LinearizerResult< T > line::pfqn::pfqn_linearizermx	(	const std::vector< T > &	lambda,
		const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const std::vector< int > &	nservers,
		const std::vector< SchedStrategy > &	type,
		double	tol,
		int	maxiter,
		LinearizerMxMethod	method,
		const Matrix< T > &	QN0 )

Linearizer for mixed open/closed queueing networks.

Parameters

lambda	(R) per-class arrival rate; must be zero on closed classes
L	(M x R) service demands
N	(R) population per class, kOpenClass for an open class
Z	(K x R) think times, summed over rows; may be empty
nservers	(M) servers per station; all-one selects the single-server branch, anything larger routes to pfqn_linearizerms
type	(M) scheduling discipline; empty means all-PS, as in MATLAB
tol	convergence tolerance
maxiter	total inner-iteration budget
method	Linearizer variant for the closed subnetwork
QN0	warm start, (M x R) or (M x closed count); may be empty

Definition at line 105 of file pfqn_linearizermx.h.

References line::pfqn::LinearizerResult< T >::C, line::Matrix< T >::cols(), Egflin, line::Matrix< T >::empty(), Gflin, line::InputError::InputError(), kOpenClass, Lin, line::Matrix< T >::Matrix(), line::NumericError::NumericError(), pfqn_egflinearizer(), pfqn_gflinearizer(), pfqn_linearizer(), pfqn_linearizerms(), pfqn_linearizermx(), line::pfqn::LinearizerResult< T >::Q, line::Matrix< T >::rows(), sum_rows(), line::pfqn::LinearizerResult< T >::totiter, line::pfqn::LinearizerResult< T >::U, line::pfqn::LinearizerResult< T >::W, and line::pfqn::LinearizerResult< T >::X.

Referenced by pfqn_linearizermx(), pfqn_linearizermx(), and line::mva::solver_amva().

pfqn_linearizermx() [2/2]

template<class T>

LinearizerResult< T > line::pfqn::pfqn_linearizermx	(	const std::vector< T > &	lambda,
		const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const std::vector< int > &	nservers,
		LinearizerMxMethod	method = LinearizerMxMethod::Egflin )

MATLAB defaults: all-PS, tol = 1e-8, maxiter = 1000, 'egflin', no warm start.

Definition at line 269 of file pfqn_linearizermx.h.

References Egflin, and pfqn_linearizermx().

pfqn_lldfun() [1/2]

template<class T>

std::vector< T > line::pfqn::pfqn_lldfun	(	const std::vector< T > &	n,
		const Matrix< T > &	lldscaling )

Overload without the multiserver term, matching the two-argument MATLAB call.

Definition at line 144 of file pfqn_lldfun.h.

References pfqn_lldfun().

pfqn_lldfun() [2/2]

template<class T>

std::vector< T > line::pfqn::pfqn_lldfun	(	const std::vector< T > &	n,
		const Matrix< T > &	lldscaling,
		const std::vector< double > &	nservers )

AMVA-QD limited-load-dependence function.

Parameters

n	(M) queue lengths, possibly fractional
lldscaling	(M x smax) rate lattice; empty for none
nservers	(M) server counts; a non-finite entry marks a delay station. Empty to skip the multiserver term entirely, which is what omitting the argument does in MATLAB.

Returns

(M) reciprocals of the effective rate multipliers

Definition at line 81 of file pfqn_lldfun.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), line::NumericError::NumericError(), pfqn_lldfun(), and line::Matrix< T >::rows().

Referenced by pfqn_lldfun(), pfqn_lldfun(), pfqn_qdamva(), and line::mva::solver_amvald().

pfqn_lldsingle()

template<class T>

NcResult< T > line::pfqn::pfqn_lldsingle	(	const Matrix< T > &	L,
		int	N,
		const Matrix< T > &	mu )

Exact normalizing constant of a SINGLE-CLASS closed network whose stations are LIMITED load dependent, i.e.

whose rate functions stay constant past a per-station threshold.

Parameters

L	(M x 1) service demands, one class
N	population
mu	(M x >=N) load-dependent rates, mu(i,k) with k jobs at station i

Definition at line 85 of file pfqn_lldsingle.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), line::NumericError::NumericError(), pfqn_lldsingle(), and line::Matrix< T >::rows().

Referenced by pfqn_lldsingle(), pfqn_ncld(), pfqn_nre_full(), and pfqn_rd().

pfqn_looping() [1/2]

template<class T>

LoopingBounds< T > line::pfqn::pfqn_looping	(	const Matrix< T > &	L,
		const std::vector< T > &	N )

Definition at line 237 of file pfqn_looping.h.

References pfqn_looping().

pfqn_looping() [2/2]

template<class T>

LoopingBounds< T > line::pfqn::pfqn_looping	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		double	tol = 1e-6,
		std::size_t	maxiter = 1000 )

Eager Looping bounds for closed multiclass product-form networks.

Parameters

L	(M x R) demands,
N	(R) populations,
Z	(R) think times (empty for none)
tol	convergence tolerance on the queue lengths
maxiter	iteration cap

Definition at line 74 of file pfqn_looping.h.

References line::Matrix< T >::cols(), line::pfqn::LoopingBounds< T >::converged, line::InputError::InputError(), line::pfqn::LoopingBounds< T >::iterations, line::Matrix< T >::Matrix(), line::NumericError::NumericError(), pfqn_looping(), line::pfqn::LoopingBounds< T >::Q, line::pfqn::LoopingBounds< T >::R, line::Matrix< T >::rows(), line::pfqn::LoopingBounds< T >::Xlo, and line::pfqn::LoopingBounds< T >::Xup.

Referenced by pfqn_looping(), pfqn_looping(), and line::ba::solver_ba_analyzer().

pfqn_ls() [1/2]

template<class T>

LsResult< T > line::pfqn::pfqn_ls	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		McRng &	rng )

Reference default of 1e5 samples.

Definition at line 301 of file pfqn_ls.h.

References pfqn_ls().

pfqn_ls() [2/2]

template<class T>

LsResult< T > line::pfqn::pfqn_ls	(	const Matrix< T > &	L0,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		std::size_t	I,
		McRng &	rng )

Logistic-sampling estimate of the normalizing constant of a closed product-form network.

Parameters

L0	(M x R) demands; rows whose total demand is below 1e-4 are dropped, as in the reference
N	(R) populations
Z	(R) think times; empty or all zero selects the Z = 0 branch
I	number of importance samples
rng	explicit generator, advanced by the call

Definition at line 118 of file pfqn_ls.h.

References Ca, line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::pfqn::LsResult< T >::G, line::InputError::InputError(), line::inverse(), line::pfqn::LsResult< T >::lG, mc_logmeanexp(), mc_normal01(), line::NumericError::NumericError(), pfqn_le_fpi(), pfqn_le_fpiZ(), pfqn_le_hessian(), pfqn_le_hessianZ(), pfqn_ls(), and line::Matrix< T >::rows().

Referenced by pfqn_ls(), pfqn_ls(), and pfqn_nc().

pfqn_manjunath() [1/3]

template<class T>

PfqnManjunathResult< T > line::pfqn::pfqn_manjunath	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const Matrix< T > &	A,
		const std::vector< long > &	b,
		const std::string &	sense,
		const PfqnManjunathOptions &	options = {} )

Exact normalizing constant of a closed multiclass product-form network whose state space carries arbitrary linear integer constraints (Manjunath-Sikdar).

Parameters

L	(M x R) service demands at the queueing stations; may be empty
N	(R) population per class
Z	(Mz x R) think times at the delay stations; may be empty
A	(J x (M+Mz)*R) extra constraint coefficients, nonnegative integers
b	(J) extra constraint right-hand sides, integers
sense	one character per row, 'E' (=), 'L' (<=) or 'G' (>); empty means all 'L'

Definition at line 386 of file pfqn_manjunath.h.

References pfqn_manjunath().

Referenced by pfqn_manjunath(), pfqn_manjunath(), and pfqn_manjunath().

pfqn_manjunath() [2/3]

template<class T>

PfqnManjunathResult< T > line::pfqn::pfqn_manjunath	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const PfqnManjunathOptions &	options = {} )

Overload without extra constraints: the plain closed-network constant.

Definition at line 580 of file pfqn_manjunath.h.

References pfqn_manjunath().

pfqn_manjunath() [3/3]

template<class T>

PfqnManjunathResult< T > line::pfqn::pfqn_manjunath	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const PfqnManjunathOptions &	options = {} )

Overload without think times or extra constraints.

Definition at line 588 of file pfqn_manjunath.h.

References pfqn_manjunath().

pfqn_marie() [1/2]

template<class T>

MarieResult< T > line::pfqn::pfqn_marie	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const Matrix< T > &	scv )

Reference defaults: tol 1e-8, maxiter 1000, single server everywhere.

Definition at line 756 of file pfqn_marie.h.

References pfqn_marie().

pfqn_marie() [2/2]

template<class T>

MarieResult< T > line::pfqn::pfqn_marie	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const Matrix< T > &	scv,
		double	tol,
		int	maxiter,
		const std::vector< int > &	nservers )

Marie's method for a closed network with FCFS Coxian service.

Parameters

L	(M x R) service demands, every entry strictly positive
N	(R) closed population vector
Z	(R) aggregated think times, one per class; may be empty
scv	(M x R) per-station per-class squared coefficients of variation; empty for all-exponential service
tol	convergence tolerance (reference default 1e-8)
maxiter	iteration cap (reference default 1000)
nservers	(M) server counts, single class only; empty for all single server. The reference does not support a multiserver multiclass isolation chain and neither does this port.

Definition at line 647 of file pfqn_marie.h.

References line::pfqn::MarieResult< T >::C, line::pfqn::MvaLdResult< T >::CN, line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), line::pfqn::MarieResult< T >::it, marie_cox_fit(), line::Matrix< T >::Matrix(), line::pfqn::MarieResult< T >::mu, line::num_abs(), pfqn_marie(), pfqn_mvald(), line::pfqn::MvaLdResult< T >::PI, line::pfqn::MarieResult< T >::Q, line::pfqn::MvaLdResult< T >::QN, line::Matrix< T >::rows(), line::pfqn::MarieResult< T >::U, line::pfqn::MvaLdResult< T >::UN, line::pfqn::MarieResult< T >::X, and line::pfqn::MvaLdResult< T >::XN.

Referenced by pfqn_marie(), pfqn_marie(), and line::mva::solver_mva_marie_analyzer().

pfqn_mci() [1/2]

template<class T>

NcResult< T > line::pfqn::pfqn_mci	(	const Matrix< T > &	D,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		McRng &	rng )

Reference defaults: 1e5 samples, the IMCI proposal.

Definition at line 216 of file pfqn_mci.h.

References Imci, and pfqn_mci().

pfqn_mci() [2/2]

template<class T>

NcResult< T > line::pfqn::pfqn_mci	(	const Matrix< T > &	D,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		std::size_t	samples,
		MciVariant	variant,
		McRng &	rng )

Monte Carlo Integration estimate of the normalizing constant of a closed product-form network (Ross, Wang and Yao; MonteQueue 2.0).

Parameters

D	(M x R) service demands
N	(R) population per class
Z	(R) think times; empty for none
samples	number of Monte Carlo samples
variant	proposal-rate rule
rng	explicit generator, advanced by the call

Definition at line 94 of file pfqn_mci.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), Imci, line::InputError::InputError(), mc_exp(), mc_log_factorial(), mc_logmeanexp(), mc_uniform01(), line::NumericError::NumericError(), pfqn_bs(), pfqn_mci(), Rm, line::Matrix< T >::rows(), line::UnsupportedError::UnsupportedError(), and line::pfqn::AmvaResult< T >::XN.

Referenced by pfqn_mci(), pfqn_mci(), and pfqn_nc().

pfqn_mcmc()

template<class T>

McmcResult< T > line::pfqn::pfqn_mcmc	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const std::vector< double > &	s,
		std::size_t	samples,
		std::size_t	nbatches,
		double	burnin,
		McRng &	rng )

Chen-O'Cinneide REGULARIZATION: a Markov chain Monte Carlo estimator of the class throughputs X(r) = G(N-e_r)/G(N) and of the mean queue lengths Q(i,r) of a CLOSED multiclass product-form (BCMP, no type changes) network.

Parameters

L	(M x R) per-class service demands at the M queueing stations
N	(R) closed population vector; finite and integer
Z	(R) aggregated think times; empty for a model with no delay
s	(M) servers per station, infinite for an infinite server; empty means all stations single-server
samples	service completions to simulate after warm-up
nbatches	batches the run is split into for the confidence intervals
burnin	warm-up fraction discarded before accumulation starts
rng	explicit generator, advanced by the call

Definition at line 158 of file pfqn_mcmc.h.

References line::pfqn::McmcResult< T >::batches, line::pfqn::McmcResult< T >::burnin, line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), line::Matrix< T >::Matrix(), mc_uniform01(), pfqn_mcmc(), line::pfqn::McmcResult< T >::Q, line::pfqn::McmcResult< T >::Qhi, line::pfqn::McmcResult< T >::Qlo, line::pfqn::McmcResult< T >::Qse, line::Matrix< T >::rows(), line::pfqn::McmcResult< T >::samples, line::pfqn::McmcResult< T >::X, line::pfqn::McmcResult< T >::Xhi, line::pfqn::McmcResult< T >::Xlo, and line::pfqn::McmcResult< T >::Xse.

Referenced by pfqn_mcmc(), and pfqn_nc().

pfqn_mcub() [1/2]

template<class T>

McubBounds< T > line::pfqn::pfqn_mcub	(	const Matrix< T > &	L,
		const std::vector< T > &	N )

Definition at line 101 of file pfqn_mcub.h.

References pfqn_mcub().

pfqn_mcub() [2/2]

template<class T>

McubBounds< T > line::pfqn::pfqn_mcub	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z )

Kerola's multiclass composite bound (Perf.

Eval. 6:1-9, eqs. 10-16) on the per-class throughput of a closed product-form network.

Parameters

L	(M x R) demands,
N	(R) population,
Z	(R) think times (empty for zero think time)

Definition at line 55 of file pfqn_mcub.h.

References line::Matrix< T >::cols(), line::InputError::InputError(), line::NumericError::NumericError(), pfqn_mcub(), line::Matrix< T >::rows(), line::pfqn::McubBounds< T >::Xlb, and line::pfqn::McubBounds< T >::Xub.

Referenced by pfqn_mcub(), pfqn_mcub(), and line::ba::solver_ba_analyzer().

pfqn_minclasses()

template<class T>

long line::pfqn::pfqn_minclasses	(	const T &	Usum,
		long	K,
		long	N )

Smallest number of customer classes R consistent with an observed sum of device utilizations, by inverting the nondecreasing pfqn_usumbound.

Only measured quantities are needed – the utilizations, the device count and the population – so the answer is available BEFORE any class-specific demand has been characterized. An upper bound on R is meaningless and none is returned.

The paper's example: K = 2, N = 3, Usum = 1.6 -> 2, a single class admitting at most 2N/(N+1) = 1.5.

Returns

least R in 1..N with pfqn_usumbound(R,K,N) >= Usum, or -1 where Usum exceeds min(N,K) and so is unattainable by ANY class structure. -1 is this port's integral encoding of the NaN MATLAB and Python return.

Definition at line 192 of file pfqn_scb.h.

References line::InputError::InputError(), pfqn_minclasses(), and pfqn_usumbound().

Referenced by pfqn_minclasses().

pfqn_mmint2()

template<class T>

MmintResult< T > line::pfqn::pfqn_mmint2	(	const std::vector< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z )

Adaptive form (MATLAB pfqn_mmint2): Gauss-Kronrod on [0, 27.63] with absolute tolerance 1e-12.

Parameters

L	(R) demand at the station,
N	(R) population,
Z	(R) think times

Definition at line 83 of file pfqn_mmint2.h.

References line::pfqn::MmintResult< T >::G, line::InputError::InputError(), line::pfqn::MmintResult< T >::lG, line::num_pow_int(), line::NumericError::NumericError(), and pfqn_mmint2().

Referenced by pfqn_mmint2().

pfqn_mmint2_gausslaguerre() [1/2]

template<class T>

MmintResult< T > line::pfqn::pfqn_mmint2_gausslaguerre	(	const std::vector< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z )

Definition at line 233 of file pfqn_mmint2.h.

References pfqn_mmint2_gausslaguerre().

pfqn_mmint2_gausslaguerre() [2/2]

template<class T>

MmintResult< T > line::pfqn::pfqn_mmint2_gausslaguerre	(	const std::vector< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		int	m,
		std::size_t	npts )

Gauss-Laguerre form (MATLAB pfqn_mmint2_gausslaguerre).

Parameters

npts	node count; MATLAB uses the length of its tabulated rule
L	(M) service demands
N	(1) population, single class
Z	(1) think time
m	multiplicity of the queueing station

Definition at line 197 of file pfqn_mmint2.h.

References line::pfqn::MmintResult< T >::G, line::InputError::InputError(), line::pfqn::MmintResult< T >::lG, and pfqn_mmint2_gausslaguerre().

Referenced by pfqn_mmint2_gausslaguerre(), and pfqn_mmint2_gausslaguerre().

pfqn_mmint2_gausslegendre() [1/2]

template<class T>

MmintResult< T > line::pfqn::pfqn_mmint2_gausslegendre	(	const std::vector< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z )

Definition at line 181 of file pfqn_mmint2.h.

References pfqn_mmint2_gausslegendre().

pfqn_mmint2_gausslegendre() [2/2]

template<class T>

MmintResult< T > line::pfqn::pfqn_mmint2_gausslegendre	(	const std::vector< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		int	m,
		std::size_t	nodecap )

Gauss-Legendre form on [0, 1e6] (MATLAB pfqn_mmint2_gausslegendre).

Parameters

m	station multiplicity, contributing the u^{m-1} factor
nodecap	size of the underlying tabulated rule, i.e. MATLAB's table length; the routine uses its first n nodes
L	(M) service demands
N	(1) population, single class
Z	(1) think time

Definition at line 135 of file pfqn_mmint2.h.

References line::pfqn::MmintResult< T >::G, line::InputError::InputError(), line::pfqn::MmintResult< T >::lG, and pfqn_mmint2_gausslegendre().

Referenced by pfqn_mmint2_gausslegendre(), pfqn_mmint2_gausslegendre(), and pfqn_nc().

pfqn_mmsample2() [1/2]

template<class T>

NcResult< T > line::pfqn::pfqn_mmsample2	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		McRng &	rng )

Reference call shape with an explicit grid size.

Definition at line 152 of file pfqn_mmsample2.h.

References pfqn_mmsample2().

pfqn_mmsample2() [2/2]

template<class T>

NcResult< T > line::pfqn::pfqn_mmsample2	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		std::size_t	samples,
		McRng &	rng )

Sampled McKenna-Mitra integral form of the normalizing constant of a repairman (single-queue plus delay) model.

Parameters

L	(M x R) demands; only row 0 is read, as in the reference
N	(R) population per class
Z	(R) think times
samples	grid size; half uniform on [0,1), half log-spaced on [1,1e5]
rng	explicit generator, advanced by the call

Definition at line 87 of file pfqn_mmsample2.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), mc_exp(), mc_log_factorial(), mc_uniform01(), line::NumericError::NumericError(), pfqn_mmsample2(), and line::Matrix< T >::rows().

Referenced by pfqn_mmsample2(), pfqn_mmsample2(), and pfqn_nc().

pfqn_momlin() [1/2]

template<class T>

MomlinResult< T > line::pfqn::pfqn_momlin	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z )

Overload with the reference's defaults (tol 1e-8, maxiter 1000).

Definition at line 212 of file pfqn_momlin.h.

References pfqn_momlin().

pfqn_momlin() [2/2]

template<class T>

MomlinResult< T > line::pfqn::pfqn_momlin	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const T &	tol,
		int	maxiter )

Moment linearizer: approximate first and second queue-length moments of a large closed product-form network.

Parameters

L	(M x R) demand matrix
N	(R) closed populations
Z	(R) think times
tol	convergence tolerance on the fixed points
maxiter	iteration cap

Definition at line 87 of file pfqn_momlin.h.

References line::Matrix< T >::cols(), line::pfqn::MomlinResult< T >::cov(), line::pfqn::MomlinResult< T >::dQ, line::InputError::InputError(), line::pfqn::MomlinResult< T >::M, line::Matrix< T >::Matrix(), line::num_abs(), line::NumericError::NumericError(), pfqn_momlin(), line::pfqn::MomlinResult< T >::Q, line::pfqn::MomlinResult< T >::QCov, line::pfqn::MomlinResult< T >::QVar, line::pfqn::MomlinResult< T >::R, line::pfqn::MomlinResult< T >::Rc, Rm, line::Matrix< T >::rows(), line::pfqn::MomlinResult< T >::U, and line::pfqn::MomlinResult< T >::X.

Referenced by pfqn_momlin(), and pfqn_momlin().

pfqn_mu_ms()

template<class T>

std::vector< T > line::pfqn::pfqn_mu_ms	(	int	N,
		int	m,
		int	c )

Aggregate load-dependent rate of m identical c-server FCFS stations.

Parameters

N	maximum population
m	number of identical stations
c	number of servers per station

Returns

(N) rates mu(1), ..., mu(N)

Definition at line 56 of file pfqn_mu_ms.h.

References line::InputError::InputError(), line::NumericError::NumericError(), and pfqn_mu_ms().

Referenced by pfqn_comomrm_ms(), pfqn_mu_ms(), and pfqn_stdf_heur().

pfqn_mushift() [1/2]

template<class T>

Matrix< T > line::pfqn::pfqn_mushift	(	const Matrix< T > &	mu,
		const std::vector< std::size_t > &	iset )

Shift the load-dependent service-rate lattice of selected stations.

Parameters

mu	(M x N) rate lattice, N >= 1
iset	0-based station indices to shift

Returns

(M x N-1) shifted lattice

Definition at line 54 of file pfqn_mushift.h.

References line::Matrix< T >::cols(), line::InputError::InputError(), pfqn_mushift(), and line::Matrix< T >::rows().

Referenced by pfqn_mushift(), pfqn_mushift(), pfqn_ncldmx(), and line::nc::solver_ncld().

pfqn_mushift() [2/2]

template<class T>

Matrix< T > line::pfqn::pfqn_mushift	(	const Matrix< T > &	mu,
		std::size_t	i )

Single-station overload, the form the reference is actually called with.

Definition at line 72 of file pfqn_mushift.h.

References pfqn_mushift().

pfqn_mva() [1/3]

template<class T>

MvaResult< T > line::pfqn::pfqn_mva	(	const Matrix< T > &	L,
		const std::vector< int > &	N )

Definition at line 320 of file pfqn_mva.h.

References pfqn_mva().

pfqn_mva() [2/3]

template<class T>

MvaResult< T > line::pfqn::pfqn_mva	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z )

Definition at line 315 of file pfqn_mva.h.

References pfqn_mva().

pfqn_mva() [3/3]

template<class T>

MvaResult< T > line::pfqn::pfqn_mva	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const std::vector< int > &	mi )

Exact Mean Value Analysis for closed product-form networks (Reiser and Lavenberg 1980).

Parameters

L	(M x R) service demands
N	(R) population per class
Z	(K x R) think times, summed over rows; empty for no delay
mi	(M) additive term of the residence-time recursion C(i,s)=L(i,s)*(mi[i]+Qarv), 1 for a queueing station; empty for all ones. THIS IS NOT A SERVER COUNT: mi[i]=c inflates the residence time by c rather than adding c servers. For multiserver stations call pfqn_mvams(lambda, L, N, Z, mi, S), which passes S to the load-dependent recursion with mu(i,n)=min(n,S(i)).

Standard arrival theorem. For the interlocked-flow correction of Franks (1999), Ch. 4, Eq. (4.7), call pfqn_mva_ilock instead.

Definition at line 71 of file pfqn_mva.h.

References line::pfqn::MvaResult< T >::CN, line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::pfqn::MvaResult< T >::G, line::InputError::InputError(), line::pfqn::MvaResult< T >::lG, line::Matrix< T >::Matrix(), line::next_pop(), line::NumericError::NumericError(), pfqn_mva(), line::plane_sizes(), line::pop_index(), line::population_count(), line::pfqn::MvaResult< T >::QN, line::Matrix< T >::rows(), line::pfqn::MvaResult< T >::UN, and line::pfqn::MvaResult< T >::XN.

Referenced by line::fes::fes_map_deaggregate(), pfqn_bklc(), pfqn_mva(), pfqn_mva(), pfqn_mva(), pfqn_mva_interval(), pfqn_mvams(), pfqn_mvamx(), pfqn_nc(), and pfqn_rd().

pfqn_mva_ilock()

template<class T>

MvaResult< T > line::pfqn::pfqn_mva_ilock	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const std::vector< int > &	mi,
		const Matrix< T > &	IL )

Exact MVA recursion carrying the interlocked-flow correction.

The correction replaces the arrival theorem term Q(n-1_s,i) by a per-class weighted sum, so the recursion has to carry per-class queue lengths that pfqn_mva does not need. Closed single-server models only.

The discounted arrival-instant queue is floored at the in-service component, as in lqns MVA::queueOnly_adjusted, so the correction damps itself out as a station saturates. That is a self-limiting guard, NOT a hard capacity test: sum_s XN[s]*L(i,s) <= mi[i] is still asserted nowhere. See git show 8bad654e7:_kb/log.md.

Parameters

L	(M x R) service demands
N	(R) population per class
Z	(K x R) think times, summed over rows; empty for no delay
mi	(M) additive term of the residence-time recursion C(i,s)=L(i,s)*(mi[i]+Qarv), 1 for a queueing station; empty for all ones. THIS IS NOT A SERVER COUNT: mi[i]=c inflates the residence time by c rather than adding c servers. For multiserver stations call pfqn_mvams(lambda, L, N, Z, mi, S), which passes S to the load-dependent recursion with mu(i,n)=min(n,S(i)).
IL	(R x R) interlock matrix of Franks (1999), Eq. (4.7): IL(r,s) is the share of the class-s queue that a class-r arrival cannot see, because that work was itself caused by the class-r request. Required. The model is outside product form under it, so G and lG are not meaningful and come back as one and zero.

Definition at line 204 of file pfqn_mva.h.

References line::pfqn::MvaResult< T >::CN, line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::pfqn::MvaResult< T >::G, line::InputError::InputError(), line::pfqn::MvaResult< T >::lG, line::Matrix< T >::Matrix(), line::next_pop(), line::NumericError::NumericError(), pfqn_mva_ilock(), line::plane_sizes(), line::pop_index(), line::population_count(), line::pfqn::MvaResult< T >::QN, line::Matrix< T >::rows(), line::pfqn::MvaResult< T >::UN, and line::pfqn::MvaResult< T >::XN.

Referenced by pfqn_mva_ilock(), and pfqn_mvams_ilock().

pfqn_mva_interval()

template<class T>

MvaIntervalResult< T > line::pfqn::pfqn_mva_interval	(	const Matrix< T > &	L,
		int	nlo,
		int	nup,
		const T &	zlo,
		const T &	zup )

Exact interval-valued MVA for single-class closed product-form networks.

Parameters

L	(M x 2) demand intervals, column 0 lower and column 1 upper.
nlo	lower population endpoint (integer, at least 1).
nup	upper population endpoint.
zlo	lower think-time endpoint.
zup	upper think-time endpoint.

Definition at line 80 of file pfqn_mva_interval.h.

References line::pfqn::MvaResult< T >::CN, line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), line::Matrix< T >::Matrix(), pfqn_mva(), pfqn_mva_interval(), line::pfqn::MvaIntervalResult< T >::Q, line::pfqn::MvaResult< T >::QN, line::pfqn::MvaIntervalResult< T >::Qtot_lo, line::pfqn::MvaIntervalResult< T >::Qtot_up, line::pfqn::MvaIntervalResult< T >::R, line::Matrix< T >::rows(), line::pfqn::MvaIntervalResult< T >::Rtot_lo, line::pfqn::MvaIntervalResult< T >::Rtot_up, line::pfqn::MvaIntervalResult< T >::U, line::pfqn::MvaIntervalResult< T >::Xlo, line::pfqn::MvaResult< T >::XN, line::pfqn::MvaIntervalResult< T >::Xup, and line::lang::GlobalConstants::Zero.

Referenced by pfqn_mva_interval(), and line::uq::uq_interval_by_mva().

pfqn_mvac() [1/2]

template<class T>

MvacResult< T > line::pfqn::pfqn_mvac	(	const Matrix< T > &	L,
		const std::vector< int > &	N )

Overload with the zero think-time default.

Definition at line 387 of file pfqn_mvac.h.

References line::Matrix< T >::cols(), and pfqn_mvac().

pfqn_mvac() [2/2]

template<class T>

MvacResult< T > line::pfqn::pfqn_mvac	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z )

MVAC: exact mean value analysis BY CHAIN of a closed multichain product-form network (Conway, de Souza e Silva and Lavenberg, IEEE Trans.

Computers 38(3):432-442, 1989).

Parameters

L	(M x R) demands of the single-server fixed-rate queues
N	(R) closed populations
Z	(Mz x R) demands of the infinite-server centers, one row per center

Definition at line 246 of file pfqn_mvac.h.

References line::pfqn::MvacResult< T >::C, line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), line::Matrix< T >::Matrix(), line::NumericError::NumericError(), pfqn_mvac(), line::pfqn::MvacResult< T >::Q, line::Matrix< T >::rows(), line::pfqn::MvacResult< T >::U, and line::pfqn::MvacResult< T >::X.

Referenced by pfqn_mvac(), pfqn_mvac(), and line::mva::solver_mvac_analyzer().

pfqn_mvacld() [1/2]

template<class T>

MvacldResult< T > line::pfqn::pfqn_mvacld	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z )

Overload with the fixed-rate default.

Definition at line 335 of file pfqn_mvacld.h.

References pfqn_mvacld().

pfqn_mvacld() [2/2]

template<class T>

MvacldResult< T > line::pfqn::pfqn_mvacld	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const Matrix< T > &	mu )

MVAC for networks with queue-length dependent (QLD) service centers, the Section V extension of Conway, de Souza e Silva and Lavenberg (1989).

Parameters

L	(M x R) demands of the queue-length dependent centers
N	(R) closed populations
Z	(Mz x R) demands of the infinite-server centers
mu	(M x n) load-dependent rates, mu(j, k-1) the total rate of center j with k jobs present; empty for the fixed-rate default

Definition at line 170 of file pfqn_mvacld.h.

References line::pfqn::MvacldResult< T >::C, line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), line::Matrix< T >::Matrix(), line::NumericError::NumericError(), pfqn_mvacld(), line::pfqn::MvacldResult< T >::pij, line::pfqn::MvacldResult< T >::Q, line::Matrix< T >::rows(), line::pfqn::MvacldResult< T >::U, and line::pfqn::MvacldResult< T >::X.

Referenced by pfqn_mvacld(), and pfqn_mvacld().

pfqn_mvajd() [1/4]

template<class T>

MvaoiResult< T > line::pfqn::pfqn_mvajd	(	const std::vector< T > &	Z,
		const std::vector< int > &	N,
		const std::vector< std::function< T(const std::vector< int > &)>	,
		&	mu,
		const Matrix< T > &	Dli )

See also

pfqn_mvaoi

Definition at line 62 of file pfqn_mvajd.h.

References pfqn_mvajd(), and pfqn_mvaoi().

pfqn_mvajd() [2/4]

template<class T>

MvaoiResult< T > line::pfqn::pfqn_mvajd	(	const std::vector< T > &	Z,
		const std::vector< int > &	N,
		const std::vector< std::function< T(const std::vector< int > &)>	,
		&	mu,
		const Matrix< T > &	Dli,
		bool	want_soi )

See also

pfqn_mvaoi

Definition at line 54 of file pfqn_mvajd.h.

References pfqn_mvajd(), and pfqn_mvaoi().

pfqn_mvajd() [3/4]

template<class T>

MvaoiResult< T > line::pfqn::pfqn_mvajd	(	const std::vector< T > &	Z,
		const std::vector< int > &	N,
		const std::vector< std::function< T(const std::vector< int > &)>	,
		&	mu,
		const Matrix< T > &	Dli,
		const Matrix< T > &	visits )

See also

pfqn_mvaoi

Definition at line 46 of file pfqn_mvajd.h.

References pfqn_mvajd(), and pfqn_mvaoi().

pfqn_mvajd() [4/4]

template<class T>

MvaoiResult< T > line::pfqn::pfqn_mvajd	(	const std::vector< T > &	Z,
		const std::vector< int > &	N,
		const std::vector< std::function< T(const std::vector< int > &)>	,
		&	mu,
		const Matrix< T > &	Dli,
		const Matrix< T > &	visits,
		bool	want_soi )

See also

pfqn_mvaoi

Definition at line 38 of file pfqn_mvajd.h.

References pfqn_mvajd(), and pfqn_mvaoi().

Referenced by pfqn_mvajd(), pfqn_mvajd(), pfqn_mvajd(), and pfqn_mvajd().

pfqn_mvald()

template<class T>

MvaLdResult< T > line::pfqn::pfqn_mvald	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const Matrix< T > &	mu,
		bool	stabilize = true )

Exact MVA for a closed network of load-dependent stations.

Port of matlab/src/api/pfqn/pfqn_mvald.m. The recursion over the population lattice is

W(i,r|n) = sum_{k=1}^{|n|} L(i,r)/mu(i,k) * k * pi(i,k-1|n - e_r) X(r|n) = n_r / (Z_r + sum_i W(i,r|n)) pi(i,k|n) = sum_r L(i,r)/mu(i,k) * X(r|n) * pi(i,k-1|n - e_r) pi(i,0|n) = 1 - sum_{k>=1} pi(i,k|n)

Parameters

L	(M x R) service demands
N	(R) population per class, all finite and non-negative
Z	(K x R) think times, summed over rows; may be empty
mu	(M x Nt') service rates, Nt' >= sum(N); mu(i,k-1) is the rate of station i while it holds k jobs
stabilize	when true (the MATLAB default) a marginal probability that comes out negative is clamped to the double epsilon rather than propagated. The clamp is a floating-point guard: in exact arithmetic pi(i,0|n) of a well-posed product-form model is non-negative and the branch is never taken. The clamp value is a dyadic rational, so it is representable without rounding in every supported arithmetic.

Definition at line 133 of file pfqn_mvams.h.

References line::pfqn::MvaLdResult< T >::CN, line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::pfqn::MvaLdResult< T >::G, line::InputError::InputError(), line::pfqn::MvaLdResult< T >::isNumStable, line::pfqn::MvaLdResult< T >::lG, line::Matrix< T >::Matrix(), line::next_pop(), line::NumericError::NumericError(), pfqn_mvald(), line::pfqn::MvaLdResult< T >::PI, line::plane_sizes(), line::pop_index(), line::population_count(), line::pfqn::MvaLdResult< T >::QN, line::Matrix< T >::rows(), line::pfqn::MvaLdResult< T >::UN, line::pfqn::MvaLdResult< T >::WN, and line::pfqn::MvaLdResult< T >::XN.

Referenced by pfqn_marie(), pfqn_mvald(), pfqn_mvams(), and pfqn_stdf_heur().

pfqn_mvaldms()

template<class T>

MvaResult< T > line::pfqn::pfqn_mvaldms	(	const std::vector< T > &	lambda,
		const Matrix< T > &	D,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const std::vector< int > &	S )

Exact MVA for mixed open/closed networks with multiserver stations.

Port of matlab/src/api/pfqn/pfqn_mvaldms.m: builds the multiserver rates mu(i,k) = min(k, S(i)), calls pfqn_mvaldmx and replaces its utilizations by the per-server utilization law U(i,r) = X(r) D(i,r) / S(i).

Parameters

S	(M) servers per station, INF_SERVERS for an infinite server
lambda	(R) arrival rates, zero on the closed classes
D	(M x R) service demands
N	(R) populations, negative on the open classes
Z	(K x R) think times

Definition at line 780 of file pfqn_mvams.h.

References INF_SERVERS, line::InputError::InputError(), is_open_class(), pfqn_mvaldms(), pfqn_mvaldmx(), line::Matrix< T >::rows(), line::pfqn::MvaResult< T >::UN, and line::pfqn::MvaResult< T >::XN.

Referenced by pfqn_mvaldms(), and pfqn_mvams().

pfqn_mvaldmx()

template<class T>

MvaResult< T > line::pfqn::pfqn_mvaldmx	(	const std::vector< T > &	lambda,
		const Matrix< T > &	D,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const Matrix< T > &	mu )

Exact MVA for mixed open/closed networks with limited load dependence.

Port of matlab/src/api/pfqn/pfqn_mvaldmx.m (Bruell, Balbo and Ashfari). The MATLAB signature carries a trailing server-count argument S that its body never reads; the port drops it, since pfqn_mvaldms is the caller that turns server counts into rates.

Parameters

lambda	(R) arrival rates, zero on closed classes
D	(M x R) service demands
N	(R) population, OPEN_CLASS on open classes
Z	(K x R) think times, summed over rows; may be empty
mu	(M x Nc') rates, Nc' >= the total closed population

Definition at line 573 of file pfqn_mvams.h.

References line::pfqn::MvaResult< T >::CN, line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::Matrix< T >::fill(), line::pfqn::MvaResult< T >::G, line::InputError::InputError(), is_open_class(), line::pfqn::MvaResult< T >::lG, line::Matrix< T >::Matrix(), line::next_pop(), line::NumericError::NumericError(), pfqn_mvaldmx(), line::plane_sizes(), line::pop_index(), line::population_count(), line::pfqn::MvaResult< T >::QN, line::Matrix< T >::rows(), line::pfqn::MvaResult< T >::UN, and line::pfqn::MvaResult< T >::XN.

Referenced by pfqn_mvaldms(), pfqn_mvaldmx(), and line::mva::solver_mvald().

pfqn_mvams() [1/3]

template<class T>

MvaResult< T > line::pfqn::pfqn_mvams	(	const std::vector< T > &	lambda,
		const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z )

Overload with unit multiplicities and a single server everywhere.

Definition at line 940 of file pfqn_mvams.h.

References pfqn_mvams().

pfqn_mvams() [2/3]

template<class T>

MvaResult< T > line::pfqn::pfqn_mvams	(	const std::vector< T > &	lambda,
		const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const std::vector< int > &	mi,
		const std::vector< int > &	S )

General-purpose exact MVA for mixed networks with multiserver stations.

Parameters

lambda	(R) arrival rates, zero on closed classes; may be empty when the model has no open class
L	(M x R) service demands
N	(R) population, OPEN_CLASS on open classes
Z	(K x R) think times, summed over rows; may be empty
mi	(M) station multiplicities; empty for all ones
S	(M) servers per station, INF_SERVERS for an infinite server; empty for all ones

The returned CN is the (M x R) per-station residence time of the pfqn_mva contract in every branch, and UN the (M x R) per-class utilization; see the contract notes at the top of this header for the two points at which that differs from MATLAB. In the mixed multiserver branch the normalizing constant is not available: G is 0 and lG is NaN, as in MATLAB.

Standard arrival theorem throughout. For the interlocked-flow correction of Franks (1999), Ch. 4, Eq. (4.7), call pfqn_mvams_ilock instead.

Definition at line 840 of file pfqn_mvams.h.

References line::pfqn::MvaResult< T >::CN, line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::pfqn::MvaLdResult< T >::G, line::pfqn::MvaResult< T >::G, INF_SERVERS, line::InputError::InputError(), is_open_class(), line::pfqn::MvaLdResult< T >::lG, line::pfqn::MvaResult< T >::lG, line::Matrix< T >::Matrix(), pfqn_mva(), pfqn_mvald(), pfqn_mvaldms(), pfqn_mvams(), pfqn_mvamx(), line::pfqn::MvaLdResult< T >::QN, line::pfqn::MvaResult< T >::QN, line::Matrix< T >::rows(), line::pfqn::MvaResult< T >::UN, line::pfqn::MvaLdResult< T >::XN, and line::pfqn::MvaResult< T >::XN.

Referenced by line::fes::fes_compute_metrics(), line::fes::fes_compute_throughputs(), pfqn_mvams(), pfqn_mvams(), pfqn_mvams(), and line::mva::solver_mva().

pfqn_mvams() [3/3]

template<class T>

MvaResult< T > line::pfqn::pfqn_mvams	(	const std::vector< T > &	lambda,
		const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const std::vector< int > &	S )

Overload with unit multiplicities.

Definition at line 933 of file pfqn_mvams.h.

References pfqn_mvams().

pfqn_mvams_ilock()

template<class T>

MvaResult< T > line::pfqn::pfqn_mvams_ilock	(	const std::vector< T > &	lambda,
		const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const std::vector< int > &	mi,
		const std::vector< int > &	S,
		const Matrix< T > &	IL )

MVA entry point for models carrying the interlocked-flow correction.

The interlock of Franks (1999), Ch. 4, Eq. (4.7) is defined only for closed single-server models, so that is the one shape accepted here; anything else is refused rather than served without the correction. Models with no interlock go to pfqn_mvams.

Parameters

IL	(R x R) interlock matrix, see pfqn_mva_ilock. Required.

Definition at line 956 of file pfqn_mvams.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), INF_SERVERS, line::InputError::InputError(), is_open_class(), pfqn_mva_ilock(), pfqn_mvams_ilock(), and line::Matrix< T >::rows().

Referenced by pfqn_mvams_ilock(), and line::mva::solver_mva().

pfqn_mvamx()

template<class T>

MvaResult< T > line::pfqn::pfqn_mvamx	(	const std::vector< T > &	lambda,
		const Matrix< T > &	D,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const std::vector< int > &	mi )

Exact MVA for a mixed open/closed network of single-server stations.

Port of matlab/src/api/pfqn/pfqn_mvamx.m. The open classes are absorbed by inflating the closed demands, D_c(i,r) / (1 - sum_{open} lambda D), after which the closed subnetwork is solved by pfqn_mva; the open metrics then follow from the closed queue lengths.

Parameters

lambda	(R) arrival rates, zero on closed classes
D	(M x R) service demands
N	(R) population, OPEN_CLASS on open classes
Z	(K x R) think times, summed over rows; may be empty
mi	(M) station multiplicities; empty for all ones

G and lG describe the closed subnetwork on the inflated demands, and are set to 0 and NaN respectively when there is no closed class, as in MATLAB.

Definition at line 311 of file pfqn_mvams.h.

References line::pfqn::MvaResult< T >::CN, line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::pfqn::MvaResult< T >::G, line::InputError::InputError(), is_open_class(), line::pfqn::MvaResult< T >::lG, line::Matrix< T >::Matrix(), line::NumericError::NumericError(), pfqn_mva(), pfqn_mvamx(), line::pfqn::MvaResult< T >::QN, line::Matrix< T >::rows(), line::pfqn::MvaResult< T >::UN, and line::pfqn::MvaResult< T >::XN.

Referenced by pfqn_mvams(), and pfqn_mvamx().

pfqn_mvaoi() [1/4]

template<class T>

MvaoiResult< T > line::pfqn::pfqn_mvaoi	(	const std::vector< T > &	Z,
		const std::vector< int > &	N,
		const std::vector< std::function< T(const std::vector< int > &)>	,
		&	mu,
		const Matrix< T > &	Dli )

Overload without the in-service means, unit visits.

Definition at line 451 of file pfqn_mvaoi.h.

References pfqn_mvaoi().

pfqn_mvaoi() [2/4]

template<class T>

MvaoiResult< T > line::pfqn::pfqn_mvaoi	(	const std::vector< T > &	Z,
		const std::vector< int > &	N,
		const std::vector< std::function< T(const std::vector< int > &)>	,
		&	mu,
		const Matrix< T > &	Dli,
		bool	want_soi )

Overload with unit visits.

Definition at line 435 of file pfqn_mvaoi.h.

References pfqn_mvaoi().

pfqn_mvaoi() [3/4]

template<class T>

MvaoiResult< T > line::pfqn::pfqn_mvaoi	(	const std::vector< T > &	Z,
		const std::vector< int > &	N,
		const std::vector< std::function< T(const std::vector< int > &)>	,
		&	mu,
		const Matrix< T > &	Dli,
		const Matrix< T > &	visits )

Overload without the in-service means.

Definition at line 443 of file pfqn_mvaoi.h.

References pfqn_mvaoi().

pfqn_mvaoi() [4/4]

template<class T>

MvaoiResult< T > line::pfqn::pfqn_mvaoi	(	const std::vector< T > &	Z,
		const std::vector< int > &	N,
		const std::vector< std::function< T(const std::vector< int > &)>	,
		&	mu,
		const Matrix< T > &	Dli,
		const Matrix< T > &	visits,
		bool	want_soi )

Mean-value analysis of a closed network with order-independent (OI) stations, the composition-dependent generalization of Conditional MVA.

Parameters

Z	(R) think-time demands of the aggregated delay node
N	(R) closed populations
mu	(K) OI rate handles; mu[i](n) is the total rate of station i at the per-class occupancy n
Dli	(J x R) demands of the load-independent single-server queues
visits	(K x R) per-OI-station class visit ratios v_{i,r}; they enter the class-r demand base case theta_{i,r}(N_r=1) = v_{i,r}/mu_i(...), the N_r >= 2 ratio case cancelling them. Empty for unit visits; ms-promoted stations pass ones, their visits already folded into the rate handle by the caller
want_soi	compute Soi (the reference's nargout >= 5 branch)

Definition at line 122 of file pfqn_mvaoi.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::pfqn::OiInsvcResult< T >::g, line::InputError::InputError(), line::Matrix< T >::Matrix(), multichoose_rows(), line::NumericError::NumericError(), pfqn_mvaoi(), pfqn_oi_insvc(), line::pfqn::MvaoiResult< T >::Qdelay, line::pfqn::MvaoiResult< T >::Qli, line::pfqn::MvaoiResult< T >::Qoi, line::Matrix< T >::rows(), line::pfqn::MvaoiResult< T >::Soi, and line::pfqn::MvaoiResult< T >::X.

Referenced by pfqn_mvajd(), pfqn_mvajd(), pfqn_mvajd(), pfqn_mvajd(), pfqn_mvaoi(), pfqn_mvaoi(), pfqn_mvaoi(), pfqn_mvaoi(), and line::mva::solver_mva_oi_analyzer().

pfqn_mvaoi_marg()

template<class T>

MvaoiMargResult< T > line::pfqn::pfqn_mvaoi_marg	(	const Matrix< T > &	D,
		const std::vector< int > &	N,
		const std::vector< bool > &	isDelay,
		const std::vector< std::function< T(const std::vector< int > &)>	,
		&	mu )

Exact marginal load-dependent MVA for a closed network of delay, load-independent and ANY number of order-independent (OI) stations.

Parameters

D	(M x R) per-class demands; the rows of OI stations are ignored
N	(R) closed populations
isDelay	(M) true for infinite-server stations
mu	(M) rate handles; callable only at the OI stations, and taking the MICROSTATE (see the header note), not the count vector

Definition at line 117 of file pfqn_mvaoi_marg.h.

References line::Matrix< T >::cols(), line::InputError::InputError(), line::Matrix< T >::Matrix(), line::num_abs(), pfqn_mvaoi_marg(), line::pfqn::MvaoiMargResult< T >::Q, line::Matrix< T >::rows(), and line::pfqn::MvaoiMargResult< T >::X.

Referenced by pfqn_mvaoi_marg().

pfqn_mvasjn()

SjnResult line::pfqn::pfqn_mvasjn ( const Matrix< double > & L, const std::vector< double > & N, const std::vector< double > & Z, const Matrix< double > & scv, const std::vector< std::size_t > & sjnset, const Matrix< double > & V, const SjnOptions & options )

inline

Exact-lattice MVA for closed networks with SJN stations, the unidirectional scheme of Kant 1992.

The recursion is explicit – W(.,n) needs only phi(.,n-1) – so the profile is carried alongside the population recursion and the whole lattice of prod(N+1) states is stepped through. Two multiclass readings of "shortest job" are selected by options.prio: POOLED (empty, the default) compares the jobs of every class by size directly and collapses to eq. (6) for a single class; PRIORITY (distinct levels, 1 = highest) is method A of eq. (21), SJN applying only within a class. Method B, which evaluates the denominator at the non-integral population n - Q(n), is not implemented in either codebase.

Parameters

L	(M x R) demands at the queueing stations
N	(R) populations
Z	(R) think times, empty for none
scv	(M x R) squared coefficients of variation, empty for ones
sjnset	0-based rows of L that schedule by SJN
V	(M x R) visit ratios, empty for ones
options	quadrature grid, tolerances and iteration caps of the recursion

Definition at line 641 of file pfqn_sjn.h.

References line::pfqn::SjnResult::CN, line::Matrix< T >::fill(), line::InputError::InputError(), pfqn_mvasjn(), line::pfqn::SjnResult::QN, line::pfqn::SjnStarvationError::SjnStarvationError(), line::pfqn::SjnResult::UN, line::pfqn::SjnResult::WX, and line::pfqn::SjnResult::XN.

Referenced by pfqn_mvasjn(), and line::mva::solver_mva_sjn_analyzer().

pfqn_mwrbb() [1/2]

template<class T>

MwrbbBounds< T > line::pfqn::pfqn_mwrbb	(	const Matrix< T > &	V,
		const Matrix< T > &	S,
		const std::vector< T > &	N,
		const std::vector< T > &	Z )

Definition at line 258 of file pfqn_mwrbb.h.

References pfqn_mwrbb().

pfqn_mwrbb() [2/2]

template<class T>

MwrbbBounds< T > line::pfqn::pfqn_mwrbb	(	const Matrix< T > &	V,
		const Matrix< T > &	S,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		const std::vector< MwrbbSched > &	sched,
		const std::vector< int > &	prio )

Majumdar-Woodside robust box bounds on the per-class throughput of a closed multiclass network with mixed scheduling disciplines (Perf.

Eval. 32 (1998) 101-136).

Parameters

V	(K x C) mean visits
S	(K x C) mean demand per visit
N	(C) population
Z	(C) think time, empty for zero
sched	(K) per-station discipline, empty for all FIFO
prio	(C) class priority, lower value = higher priority; empty for equal

Definition at line 161 of file pfqn_mwrbb.h.

References line::Matrix< T >::cols(), Fifo, line::InputError::InputError(), line::Matrix< T >::Matrix(), line::num_abs(), line::NumericError::NumericError(), pfqn_mwrbb(), PrioNonPreemptive, PrioPreemptive, line::Matrix< T >::rows(), line::pfqn::MwrbbBounds< T >::Wlo, line::pfqn::MwrbbBounds< T >::Xlo, and line::pfqn::MwrbbBounds< T >::Xup.

Referenced by line::lqn::lqn_boxbounds(), pfqn_mwrbb(), pfqn_mwrbb(), and line::ba::solver_ba_analyzer().

pfqn_nc() [1/3]

template<class T>

NcDispatchResult< T > line::pfqn::pfqn_nc	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		NcMethod	method )

Overload with the exact (zero-tolerance) filters and no open classes.

Definition at line 970 of file pfqn_nc.h.

References pfqn_nc().

pfqn_nc() [2/3]

template<class T>

NcDispatchResult< T > line::pfqn::pfqn_nc	(	const std::vector< T > &	lambda,
		const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		NcMethod	method,
		const T &	atol )

Overload with the reference's default sample count, seed and tolerance.

Definition at line 962 of file pfqn_nc.h.

References pfqn_nc().

pfqn_nc() [3/3]

template<class T>

NcDispatchResult< T > line::pfqn::pfqn_nc	(	const std::vector< T > &	lambda,
		const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		NcMethod	method,
		const T &	atol,
		const NcOptions &	nopt )

Normalizing constant of a product-form queueing network: the dispatcher.

Parameters

lambda	(R) arrival rates; zero on the closed classes, may be empty
L	(M x R) service demands
N	(R) populations; a NEGATIVE entry marks an open class
Z	(K x R) think times, summed over rows
method	requested algorithm
atol	threshold below which a demand counts as zero; 0 for exact
nopt	sample count, seed and tolerance the estimators read

Definition at line 276 of file pfqn_nc.h.

References Adaptive, Aghq, line::pfqn::NcOptions::aghq_nodes, Bk, Bkt, Bkue, Ble, Ca, Clw, line::Matrix< T >::cols(), Comom, Cub, CUB_MAX_EVALS, Default, Divdiff, line::Matrix< T >::empty(), Exact, line::pfqn::NcDispatchResult< T >::G, Ger, Gleint, Gm, Imci, line::InputError::InputError(), Is, Kt, Lc, LcUe, Le, Lekt, line::pfqn::ExplicitResult< T >::lG, line::pfqn::NcDispatchResult< T >::lG, line::pfqn::PanaceaResult< T >::lG, Ls, line::Matrix< T >::Matrix(), Mci, Mcmc, line::pfqn::NcOptions::mcmc_batches, line::pfqn::NcOptions::mcmc_burnin, line::pfqn::ExplicitResult< T >::method, line::pfqn::NcDispatchResult< T >::method, Mmint2, Mva, nc_method_name(), line::nck(), line::pfqn::PanaceaResult< T >::normalUsage, line::num_factorial(), line::num_pow_int(), Pana, pfqn_aghq(), pfqn_bk(), pfqn_bklc(), pfqn_bkt(), pfqn_bkue(), pfqn_ble(), pfqn_ca(), pfqn_clw(), pfqn_comomrm(), pfqn_cub(), pfqn_cub_evals(), pfqn_explicit(), pfqn_gerasimov(), pfqn_is(), pfqn_kt(), pfqn_le(), pfqn_lekt(), pfqn_ls(), pfqn_mci(), pfqn_mcmc(), pfqn_mmint2_gausslegendre(), pfqn_mmsample2(), pfqn_mva(), pfqn_nc(), pfqn_nc_refuse(), pfqn_panacea(), pfqn_propfair(), pfqn_recal(), pfqn_rgf(), pfqn_rgfmc(), Propfair, line::pfqn::BkLcResult< T >::Q, line::pfqn::NcDispatchResult< T >::Q, Recal, Rgf, line::Matrix< T >::rows(), line::pfqn::NcOptions::samples, Sampling, line::pfqn::NcOptions::seed, line::UnsupportedError::UnsupportedError(), line::pfqn::NcDispatchResult< T >::valid, line::pfqn::BkLcResult< T >::X, and line::pfqn::NcDispatchResult< T >::X.

Referenced by pfqn_nc(), pfqn_nc(), pfqn_nc(), pfqn_rd(), and line::nc::solver_nc().

pfqn_nc_refuse()

void line::pfqn::pfqn_nc_refuse ( const std::string & method )

inline

Refuse a method in an arithmetic it has no meaning in.

Kept as a function so the message is identical wherever it is raised.

Definition at line 233 of file pfqn_nc.h.

References pfqn_nc_refuse(), and line::UnsupportedError::UnsupportedError().

Referenced by pfqn_nc(), and pfqn_nc_refuse().

pfqn_nc_sanitize() [1/2]

template<class T>

NcSanitizeResult< T > line::pfqn::pfqn_nc_sanitize	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z )

Overload with the exact (zero-tolerance) tests.

Definition at line 194 of file pfqn_nc_sanitize.h.

References pfqn_nc_sanitize().

pfqn_nc_sanitize() [2/2]

template<class T>

NcSanitizeResult< T > line::pfqn::pfqn_nc_sanitize	(	const std::vector< T > &	lambda,
		const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const T &	atol )

Preprocessing shared by the normalizing-constant solvers: drop the classes that cannot contribute, rescale the demands per class, and order the classes so that the zero-think-time ones come first.

Parameters

lambda	(R) arrival rates; may be empty for a purely closed model
L	(M x R) service demands
N	(R) populations
Z	(K x R) think times; may be empty
atol	threshold below which a demand counts as zero; use 0 for exact

Definition at line 96 of file pfqn_nc_sanitize.h.

References line::pfqn::NcSanitizeResult< T >::classIndex, line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::pfqn::NcSanitizeResult< T >::Gremaind, line::InputError::InputError(), line::pfqn::NcSanitizeResult< T >::L, line::pfqn::NcSanitizeResult< T >::lambda, line::pfqn::NcSanitizeResult< T >::lGremaind, line::Matrix< T >::Matrix(), line::pfqn::NcSanitizeResult< T >::N, line::num_factorial(), line::num_pow_int(), pfqn_nc_sanitize(), line::Matrix< T >::rows(), and line::pfqn::NcSanitizeResult< T >::Z.

Referenced by pfqn_comomrm(), pfqn_comomrm_ld(), pfqn_comomrm_ms(), pfqn_comomrm_orig(), pfqn_nc_sanitize(), and pfqn_nc_sanitize().

pfqn_ncjd() [1/2]

template<class T>

NcResult< T > line::pfqn::pfqn_ncjd	(	const std::vector< T > &	Z,
		const std::vector< int > &	N,
		const std::vector< OiRate< T > > &	mu )

See also

pfqn_ncoi

Definition at line 45 of file pfqn_ncjd.h.

References pfqn_ncjd(), and pfqn_ncoi().

pfqn_ncjd() [2/2]

template<class T>

NcResult< T > line::pfqn::pfqn_ncjd	(	const std::vector< T > &	Z,
		const std::vector< int > &	N,
		const std::vector< OiRate< T > > &	mu,
		const Matrix< T > &	visits )

See also

pfqn_ncoi

Definition at line 38 of file pfqn_ncjd.h.

References pfqn_ncjd(), and pfqn_ncoi().

Referenced by pfqn_ncjd(), and pfqn_ncjd().

pfqn_ncld() [1/3]

template<class T>

NcldResult< T > line::pfqn::pfqn_ncld	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const Matrix< T > &	mu )

Overload with the exact (zero-tolerance) filters.

Definition at line 485 of file pfqn_ncld.h.

References Default, and pfqn_ncld().

pfqn_ncld() [2/3]

template<class T>

NcldResult< T > line::pfqn::pfqn_ncld	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const Matrix< T > &	mu,
		NcldMethod	method,
		const T &	atol )

Overload with the reference's default sample count, seed and tolerance.

Definition at line 478 of file pfqn_ncld.h.

References pfqn_ncld().

pfqn_ncld() [3/3]

template<class T>

NcldResult< T > line::pfqn::pfqn_ncld	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const Matrix< T > &	mu,
		NcldMethod	method,
		const T &	atol,
		const NcOptions &	nopt )

Normalizing constant of a LOAD-DEPENDENT closed network: the dispatcher.

Parameters

L	(M x R) service demands
N	(R) populations, finite and nonnegative
Z	(K x R) think times
mu	(M x >=Nt) load-dependent rate lattice
method	requested algorithm
atol	threshold below which a demand counts as zero; 0 for exact
nopt	sample count, seed and tolerance the log-domain ladder reads

Definition at line 153 of file pfqn_ncld.h.

References Clw, line::Matrix< T >::cols(), Comomld, Default, Divdiff, line::Matrix< T >::empty(), line::pfqn::NcldResult< T >::G, line::InputError::InputError(), Is, line::pfqn::ExplicitResult< T >::lG, line::pfqn::NcldResult< T >::lG, line::pfqn::PanaceaLdResult< T >::lG, line::pfqn::ExplicitResult< T >::lossDigits, line::pfqn::ExplicitResult< T >::method, line::pfqn::NcldResult< T >::method, ncld_method_name(), line::pfqn::PanaceaLdResult< T >::normalUsage, Nre, Nrl, Nrp, line::num_factorial(), line::num_pow_int(), line::NumericError::NumericError(), Panald, pfqn_clw_lld(), pfqn_comomrm_ld(), pfqn_explicit_ld(), pfqn_gld(), pfqn_ld_is(), pfqn_lldsingle(), pfqn_ncld(), pfqn_ncld_refuse(), pfqn_nre(), pfqn_nrl(), pfqn_nrp(), pfqn_panaceald(), pfqn_rd(), Rd, line::pfqn::PanaceaLdResult< T >::reason, line::Matrix< T >::rows(), line::pfqn::NcOptions::samples, line::pfqn::NcOptions::seed, line::UnsupportedError::UnsupportedError(), and line::pfqn::ExplicitResult< T >::valid.

Referenced by pfqn_ncld(), pfqn_ncld(), pfqn_ncld(), pfqn_ncldmx(), line::nc::solver_nc_getprob_marg(), line::nc::solver_nc_joint(), line::nc::solver_nc_jointaggr(), line::nc::solver_nc_marg(), line::nc::solver_nc_margaggr(), and line::nc::solver_ncld().

pfqn_ncld_refuse()

void line::pfqn::pfqn_ncld_refuse ( const std::string & method )

inline

Refuse a load-dependent method in an arithmetic it has no meaning in.

Definition at line 126 of file pfqn_ncld.h.

References pfqn_ncld_refuse(), and line::UnsupportedError::UnsupportedError().

Referenced by pfqn_ncld(), and pfqn_ncld_refuse().

pfqn_ncldmx() [1/2]

template<class T>

NcldmxResult< T > line::pfqn::pfqn_ncldmx	(	const std::vector< T > &	lambda,
		const Matrix< T > &	D,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const Matrix< T > &	mu )

Overload with the exact (zero-tolerance) filters and default sampling options.

Definition at line 378 of file pfqn_ncldmx.h.

References Default, and pfqn_ncldmx().

pfqn_ncldmx() [2/2]

template<class T>

NcldmxResult< T > line::pfqn::pfqn_ncldmx	(	const std::vector< T > &	lambda,
		const Matrix< T > &	D,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const Matrix< T > &	mu,
		NcldMethod	method,
		const T &	atol,
		const NcOptions &	nopt )

Normalizing constant of a MIXED open/closed network with limited load dependence.

Parameters

lambda	(R) arrival rates; must be zero on the closed classes
D	(M x R) service demands
N	(R) populations; a NEGATIVE entry marks an open class
Z	(K x R) think times of the closed classes
mu	(M x >=Kc) load-dependent rate lattice

Definition at line 180 of file pfqn_ncldmx.h.

References line::pfqn::FncResult< T >::c, line::Matrix< T >::cols(), line::pfqn::LdmxEcResult< T >::E, line::pfqn::LdmxEcResult< T >::EC, line::pfqn::NcldmxResult< T >::EC, line::Matrix< T >::empty(), line::pfqn::NcldmxResult< T >::G, line::pfqn::NcldmxResult< T >::Gopen, line::InputError::InputError(), line::pfqn::NcldmxResult< T >::lG, line::pfqn::NcldmxResult< T >::lGopen, line::Matrix< T >::Matrix(), line::pfqn::FncResult< T >::mu, line::NumericError::NumericError(), pfqn_fnc(), pfqn_ldmx_ec(), pfqn_mushift(), pfqn_ncld(), pfqn_ncldmx(), line::pfqn::NcldmxResult< T >::QN, line::Matrix< T >::rows(), and line::pfqn::NcldmxResult< T >::XN.

Referenced by pfqn_ncldmx(), pfqn_ncldmx(), and line::nc::solver_ncld().

pfqn_ncoi() [1/2]

template<class T>

NcResult< T > line::pfqn::pfqn_ncoi	(	const std::vector< T > &	Z,
		const std::vector< int > &	N,
		const std::vector< OiRate< T > > &	mu )

Overload with unit visits.

Definition at line 233 of file pfqn_ncoi.h.

References pfqn_ncoi().

pfqn_ncoi() [2/2]

template<class T>

NcResult< T > line::pfqn::pfqn_ncoi	(	const std::vector< T > &	Z,
		const std::vector< int > &	N,
		const std::vector< OiRate< T > > &	mu,
		const Matrix< T > &	visits )

Normalizing constant of a closed network of ORDER-INDEPENDENT (OI) / pass-and-swap stations with empty swap graph, plus one aggregated delay.

Parameters

Z	(R) think-time demand of the aggregated delay node
N	(R) closed population, finite
mu	(K) OI rate callables, one per station; may be empty
visits	(K x R) per-station class visit ratios weighting the balance recursion; empty for unit visits

Definition at line 153 of file pfqn_ncoi.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), line::num_factorial(), line::num_pow_int(), pfqn_ncoi(), and line::Matrix< T >::rows().

Referenced by pfqn_ncjd(), pfqn_ncjd(), pfqn_ncoi(), pfqn_ncoi(), and line::nc::solver_nc_oi_analyzer().

pfqn_nintmva() [1/2]

template<class T>

NintMvaResult< T > line::pfqn::pfqn_nintmva	(	const std::vector< T > &	L,
		const T &	N )

MATLAB default: no think time.

Definition at line 109 of file pfqn_nintmva.h.

References pfqn_nintmva().

pfqn_nintmva() [2/2]

template<class T>

NintMvaResult< T > line::pfqn::pfqn_nintmva	(	const std::vector< T > &	L,
		const T &	N,
		const T &	Z )

Mean value analysis at a nonintegral population (fractional-base aMVA).

Parameters

L	(M) service demands of the queueing stations
N	population, real and nonnegative (may be fractional)
Z	think time

Definition at line 71 of file pfqn_nintmva.h.

References line::InputError::InputError(), line::NumericError::NumericError(), pfqn_nintmva(), line::pfqn::NintMvaResult< T >::Q, line::pfqn::NintMvaResult< T >::R, line::pfqn::NintMvaResult< T >::U, and line::pfqn::NintMvaResult< T >::X.

Referenced by pfqn_nintmva(), and pfqn_nintmva().

pfqn_nre()

template<class T>

T line::pfqn::pfqn_nre	(	const Matrix< T > &	L0,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		const Matrix< T > &	alpha0 )

Saddle-tilted Edgeworth approximation of log G for a limited load-dependent model.

Parameters

L0	(M x R) demands
N	(R) population
Z	(R) think times, empty for zero
alpha0	(M x Ntot) load-dependent rates, empty for all ones

Definition at line 466 of file pfqn_nre.h.

References pfqn_nre(), and pfqn_nre_full().

Referenced by pfqn_ncld(), and pfqn_nre().

pfqn_nre_full()

template<class T>

PfqnNreResult< T > line::pfqn::pfqn_nre_full	(	const Matrix< T > &	L0,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		const Matrix< T > &	alpha0,
		const std::vector< T > &	vfix )

Saddle-tilted Edgeworth approximation of log G for a limited load-dependent model: the full form of the reference's outputs, named alike in the JAR and the native python port.

Parameters

L0	(M x R) demands
N	(R) population
Z	(R) think times, empty for zero
alpha0	(M x Ntot) load-dependent rates, empty for all ones
vfix	tilt to use instead of solving the saddle-point equation, empty for the standard estimator. Supplying the tilt obtained at a nearby population makes numerator and denominator of a ratio share one expansion point, the Tierney-Kadane arrangement.

Definition at line 214 of file pfqn_nre.h.

References line::Matrix< T >::cols(), line::InputError::InputError(), line::inverse(), line::NumericError::NumericError(), pfqn_gld(), pfqn_lldsingle(), pfqn_nre_full(), line::Matrix< T >::rows(), line::solve(), and line::UnsupportedError::UnsupportedError().

Referenced by pfqn_nre(), and pfqn_nre_full().

pfqn_nrl()

template<class T>

T line::pfqn::pfqn_nrl	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		const Matrix< T > &	alpha )

Norlund-Rice logit approximation of log G.

Parameters

L	(M x R) demands
N	(R) population
Z	(R) think times, empty for zero
alpha	(M x Ntot) load-dependent rates, empty for all ones

Definition at line 130 of file pfqn_nrl.h.

References pfqn_nrl().

Referenced by pfqn_ncld(), and pfqn_nrl().

pfqn_nrp()

template<class T>

T line::pfqn::pfqn_nrp	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		const Matrix< T > &	alpha )

Norlund-Rice probit approximation of log G.

Definition at line 140 of file pfqn_nrl.h.

References pfqn_nrp().

Referenced by pfqn_ncld(), and pfqn_nrp().

pfqn_oi_fnc() [1/2]

template<class T>

OiFncResult< T > line::pfqn::pfqn_oi_fnc	(	const std::vector< T > &	Phi,
		const std::vector< int > &	N )

Definition at line 150 of file pfqn_oi_fnc.h.

References pfqn_oi_fnc().

pfqn_oi_fnc() [2/2]

template<class T>

OiFncResult< T > line::pfqn::pfqn_oi_fnc	(	const std::vector< T > &	Phi,
		const std::vector< int > &	N,
		const std::function< T(const std::vector< int > &)> &	f )

Order-independent (OI) functional server: the balance function Psi and the rate mu_f of an auxiliary station whose insertion turns the mean of a queue-dependent function into a ratio of normalizing constants.

Parameters

Phi	balance function of the existing OI station, column-major over the lattice 0 <= n <= N (length prod(N+1))
N	(R) closed population vector
f	target queue-dependent function with f(0) = 0; empty for sum(n)

Definition at line 76 of file pfqn_oi_fnc.h.

References line::InputError::InputError(), line::pfqn::OiFncResult< T >::mu, pfqn_oi_fnc(), line::pfqn::OiFncResult< T >::Psi, and line::pfqn::OiFncResult< T >::stride.

Referenced by pfqn_oi_fnc(), pfqn_oi_fnc(), and line::nc::solver_nc_oi_analyzer().

pfqn_oi_insvc()

template<class T>

OiInsvcResult< T > line::pfqn::pfqn_oi_insvc	(	const std::function< T(const std::vector< int > &)> &	oirate,
		const std::vector< int > &	N )

Conditional mean number of IN-SERVICE jobs per class at an order-independent station.

Parameters

oirate	OI total service rate mu(n) for a per-class count vector
N	(R) closed population vector

Definition at line 68 of file pfqn_oi_insvc.h.

References line::pfqn::OiInsvcResult< T >::g, line::InputError::InputError(), line::Matrix< T >::Matrix(), pfqn_oi_insvc(), line::pfqn::OiInsvcResult< T >::Phi, line::pfqn::OiInsvcResult< T >::stride, and line::pfqn::OiInsvcResult< T >::Xi.

Referenced by pfqn_mvaoi(), pfqn_oi_insvc(), and line::nc::solver_nc_oi_analyzer().

pfqn_oi_is() [1/2]

template<class T>

PasIsResult< T > line::pfqn::pfqn_oi_is	(	const std::vector< int > &	N,
		const std::vector< OiRateFun< T > > &	mu,
		McRng &	rng,
		bool	want_qlen = true )

Reference default of 1e4 samples.

Definition at line 69 of file pfqn_oi_is.h.

References pfqn_oi_is().

pfqn_oi_is() [2/2]

template<class T>

PasIsResult< T > line::pfqn::pfqn_oi_is	(	const std::vector< int > &	N,
		const std::vector< OiRateFun< T > > &	mu,
		std::size_t	samples,
		McRng &	rng,
		bool	want_qlen = true )

Importance-sampling estimate of the normalizing constant of a closed two-station order-independent (OI) tandem.

Parameters

N	(R) closed population vector
mu	the two OI rank-rate functions, station 1 then station 2
samples	number of importance samples
rng	explicit generator, advanced by the call

Definition at line 56 of file pfqn_oi_is.h.

References line::InputError::InputError(), pfqn_oi_is(), and pfqn_pas_is().

Referenced by pfqn_oi_is(), and pfqn_oi_is().

pfqn_pam() [1/2]

template<class T>

AmvaResult< T > line::pfqn::pfqn_pam	(	const Matrix< T > &	L,
		const std::vector< T > &	N )

Definition at line 160 of file pfqn_pam.h.

References Basic, and pfqn_pam().

pfqn_pam() [2/2]

template<class T>

AmvaResult< T > line::pfqn::pfqn_pam	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		PamVariant	variant = PamVariant::Basic )

Hsieh-Lam Proportional Approximation Methods (PAMB / PAMI / PAMT).

Parameters

L	(M x R) demands,
N	(R) populations,
Z	(R) think times (empty for none),
variant	PAMB/PAMI/PAMT

Definition at line 55 of file pfqn_pam.h.

References Basic, line::Matrix< T >::cols(), line::pfqn::AmvaResult< T >::converged, line::InputError::InputError(), line::pfqn::AmvaResult< T >::iterations, line::Matrix< T >::Matrix(), pfqn_pam(), line::pfqn::AmvaResult< T >::QN, line::pfqn::AmvaResult< T >::RN, line::Matrix< T >::rows(), Two, line::pfqn::AmvaResult< T >::UN, and line::pfqn::AmvaResult< T >::XN.

Referenced by pfqn_clust(), pfqn_pam(), pfqn_pam(), and line::mva::solver_amva().

pfqn_panacea() [1/2]

template<class T>

PanaceaResult< T > line::pfqn::pfqn_panacea	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z )

Definition at line 188 of file pfqn_panacea.h.

References pfqn_panacea().

pfqn_panacea() [2/2]

template<class T>

PanaceaResult< T > line::pfqn::pfqn_panacea	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		int	terms )

PANACEA normal-usage asymptotic expansion of the normalizing constant (Ramakrishnan and Mitra, BSTJ 61(10):2849-2872, 1982).

Parameters

L	(M x R) demands
N	(R) population
Z	(R) think times; empty means MATLAB's 1e-8 placeholder
terms	1, 2 or 3

Definition at line 66 of file pfqn_panacea.h.

References line::Matrix< T >::cols(), line::pfqn::PanaceaResult< T >::G, line::InputError::InputError(), line::pfqn::PanaceaResult< T >::lG, line::pfqn::PanaceaResult< T >::normalUsage, line::NumericError::NumericError(), pfqn_ca(), pfqn_panacea(), and line::Matrix< T >::rows().

Referenced by pfqn_nc(), pfqn_panacea(), and pfqn_panacea().

pfqn_panaceald() [1/2]

template<class T>

PanaceaLdResult< T > line::pfqn::pfqn_panaceald	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const Matrix< T > &	mu )

Overload at the reference's default of three terms.

Definition at line 435 of file pfqn_panaceald.h.

References pfqn_panaceald().

pfqn_panaceald() [2/2]

template<class T>

PanaceaLdResult< T > line::pfqn::pfqn_panaceald	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const Matrix< T > &	mu,
		int	terms )

PANACEA normal-usage asymptotic expansion for LOAD-DEPENDENT closed networks (Mitra and McKenna, JACM 33(3):568-592, 1986).

Parameters

L	(M x R) demands; an infinite-server row is recognized by its rate lattice and folded into the think time
N	(R) population
Z	(R) think times, already summed over the delay rows; empty for none
mu	(M x >= sum N) load-dependent rates; empty means all ones, and a short lattice is extended with its last column
terms	1, 2 or 3 terms of the normal-usage series, as in pfqn_panacea

Definition at line 231 of file pfqn_panaceald.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::pfqn::PanaceaLdResult< T >::G, line::InputError::InputError(), line::pfqn::PanaceaLdResult< T >::lG, line::pfqn::PanaceaLdResult< T >::normalUsage, pfqn_panaceald(), line::pfqn::PanaceaLdResult< T >::reason, and line::Matrix< T >::rows().

Referenced by pfqn_ncld(), pfqn_panaceald(), and pfqn_panaceald().

pfqn_pas_is() [1/2]

template<class T>

PasIsResult< T > line::pfqn::pfqn_pas_is	(	const std::vector< int > &	N,
		const std::vector< OiRateFun< T > > &	mu,
		const Matrix< int > &	H,
		McRng &	rng,
		bool	want_qlen = true )

Reference default of 1e4 samples.

Definition at line 253 of file pfqn_pas_is.h.

References pfqn_pas_is().

pfqn_pas_is() [2/2]

template<class T>

PasIsResult< T > line::pfqn::pfqn_pas_is	(	const std::vector< int > &	N,
		const std::vector< OiRateFun< T > > &	mu,
		const Matrix< int > &	H,
		std::size_t	samples,
		McRng &	rng,
		bool	want_qlen = true )

Importance-sampling estimate of the normalizing constant of a single communicating class of a cyclic two-station pass-and-swap (P&S) network with swap graph H.

Templated port of matlab/src/api/pfqn/pfqn_pas_is.m together with its placement-order helper matlab/src/api/pfqn/pas_placement.m, cross-checked against jar/src/main/java/jline/api/pfqn/nc/Pfqn_pas_is.java.

Parameters

N	(R) closed population vector
mu	the two OI rank-rate functions, station 1 then station 2
H	(R x R) swap-graph adjacency; empty or all zero for pure OI
samples	number of importance samples
rng	explicit generator, advanced by the call
want_qlen	estimate the per-class queue lengths as well as the constant. False estimates ONLY G: the prefix-count matrix is neither allocated nor written and its coefficients are not accumulated, and Q comes back zero. The ordering is drawn from the same stream either way, so G is unchanged to the last bit – this is for the callers that want G(N - e_r) and read nothing else from it.

Definition at line 132 of file pfqn_pas_is.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::pfqn::PasIsResult< T >::G, line::InputError::InputError(), line::pfqn::PasIsResult< T >::lG, line::Matrix< T >::Matrix(), mc_uniform_int(), line::NumericError::NumericError(), pas_placement(), pfqn_pas_is(), line::pfqn::PasIsResult< T >::Q, and line::Matrix< T >::rows().

Referenced by pfqn_oi_is(), pfqn_pas_is(), pfqn_pas_is(), and line::nc::solver_nc_pas_is_analyzer().

pfqn_pas_nc() [1/2]

template<class T>

NcResult< T > line::pfqn::pfqn_pas_nc	(	const std::vector< T > &	Z,
		const std::vector< int > &	N,
		const std::vector< OiRate< T > > &	mu )

Plain OI case (no placement order); prefer pfqn_ncoi, which is cheaper.

Definition at line 191 of file pfqn_pas_nc.h.

References pfqn_pas_nc().

pfqn_pas_nc() [2/2]

template<class T>

NcResult< T > line::pfqn::pfqn_pas_nc	(	const std::vector< T > &	Z,
		const std::vector< int > &	N,
		const std::vector< OiRate< T > > &	mu,
		const std::vector< PlacementOrder > &	prec )

Normalizing constant G_C of one communicating class of a closed PASS-AND-SWAP (P&S) network, plus one aggregated delay.

Parameters

Z	(R) think-time demand of the aggregated delay node
N	(R) closed population, finite
mu	(M) P&S rate callables, one per station; may be empty
prec	(M) placement orders, one per station, each R x R with prec[m][i][j] != 0 iff class i must be placed before class j at station m. An empty vector, or an empty matrix for a station, means no order there, so G is the plain OI constant. NOTE the orientation: around a cycle each downstream station traverses its chain in the opposite direction, so downstream stations take the TRANSPOSE of the upstream order. Passing the same matrix to both stations of a cycle silently returns a smaller, wrong G.

Definition at line 154 of file pfqn_pas_nc.h.

References line::InputError::InputError(), and pfqn_pas_nc().

Referenced by pfqn_pas_nc(), and pfqn_pas_nc().

pfqn_pbh() [1/2]

template<class T>

PbhBounds< T > line::pfqn::pfqn_pbh	(	const std::vector< T > &	L,
		int	N,
		const T &	Z )

Definition at line 145 of file pfqn_pbh.h.

References pfqn_pbh().

pfqn_pbh() [2/2]

template<class T>

PbhBounds< T > line::pfqn::pfqn_pbh	(	const std::vector< T > &	L,
		int	N,
		const T &	Z,
		int	level )

Performance Bound Hierarchy (Eager and Sevcik 1983, ACM TOCS 1(2):99-115) for single-class closed product-form networks, and the two iterative families that are defined in terms of it.

Parameters

L	(M) per-station demands
N	population
Z	think time
level	hierarchy level >= 0, clamped to N

Definition at line 103 of file pfqn_pbh.h.

References line::InputError::InputError(), line::NumericError::NumericError(), pfqn_pbh(), line::pfqn::PbhBounds< T >::Qhi, line::pfqn::PbhBounds< T >::Qlo, line::pfqn::PbhBounds< T >::Xhi, and line::pfqn::PbhBounds< T >::Xlo.

Referenced by pfqn_bjbk(), pfqn_bjbk(), pfqn_pbh(), pfqn_pbh(), pfqn_pbk(), pfqn_pbk(), and line::ba::solver_ba_analyzer().

pfqn_pbk() [1/2]

template<class T>

PbhBounds< T > line::pfqn::pfqn_pbk	(	const std::vector< T > &	L,
		int	N,
		const T &	Z )

Definition at line 156 of file pfqn_pbh.h.

References pfqn_pbh(), and pfqn_pbk().

pfqn_pbk() [2/2]

template<class T>

PbhBounds< T > line::pfqn::pfqn_pbk	(	const std::vector< T > &	L,
		int	N,
		const T &	Z,
		int	k )

PB(k), the iterative Eager-Sevcik proportional bound.

Forwards to pfqn_pbh.

Definition at line 151 of file pfqn_pbh.h.

References pfqn_pbh(), and pfqn_pbk().

Referenced by pfqn_pbk(), pfqn_pbk(), and line::ba::solver_ba_analyzer().

pfqn_perm()

template<class T>

T line::pfqn::pfqn_perm	(	const Matrix< T > &	A,
		const std::vector< int > &	m )

Permanent of a matrix with repeated columns, by Ryser's formula.

Parameters

A	(n x R) matrix, column k standing for m_k identical columns
m	(R) column multiplicities, summing to n

Definition at line 52 of file pfqn_perm.h.

References line::Matrix< T >::cols(), line::InputError::InputError(), line::next_pop(), pfqn_perm(), and line::Matrix< T >::rows().

Referenced by pfqn_jointmarg(), pfqn_lcfsqn_nc(), pfqn_perm(), and line::nc::solver_nc_lcfsqn().

pfqn_pff_delay()

template<class T>

T line::pfqn::pfqn_pff_delay	(	const std::vector< T > &	Z,
		const std::vector< int > &	n )

Product-form factor of a delay station.

Parameters

Z	(R) think times of the delay station
n	(R) population of each class

Definition at line 51 of file pfqn_pff_delay.h.

References line::InputError::InputError(), and pfqn_pff_delay().

Referenced by pfqn_pff_delay().

pfqn_procomom() [1/2]

template<class T>

ProcomomResult< T > line::pfqn::pfqn_procomom	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z )

Overload with the reference's default tolerance.

Definition at line 297 of file pfqn_procomom.h.

References pfqn_procomom().

pfqn_procomom() [2/2]

template<class T>

ProcomomResult< T > line::pfqn::pfqn_procomom	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const T &	atol )

Marginal queue-length distributions of every station.

Parameters

L	(M x R) demand matrix
N	(R) populations
Z	(R) think times
atol	tolerance below which a class demand counts as zero

Definition at line 103 of file pfqn_procomom.h.

References line::Matrix< T >::cols(), line::InputError::InputError(), Ls, line::lstsq(), matchrow(), line::Matrix< T >::Matrix(), line::NumericError::NumericError(), pfqn_procomom(), line::pfqn::ProcomomResult< T >::Pr, line::pfqn::ProcomomResult< T >::Q, line::LstsqResult< T >::rankdef, line::pfqn::ProcomomResult< T >::rankdef, line::Matrix< T >::rows(), and line::LstsqResult< T >::x.

Referenced by pfqn_procomom(), pfqn_procomom(), and line::nc::solver_nc_getprob_marg().

pfqn_procomom2() [1/2]

template<class T>

Procomom2Result< T > line::pfqn::pfqn_procomom2	(	const std::vector< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z )

Overload with the load-independent, unit-multiplicity defaults.

Definition at line 410 of file pfqn_procomom.h.

References pfqn_procomom2().

pfqn_procomom2() [2/2]

template<class T>

Procomom2Result< T > line::pfqn::pfqn_procomom2	(	const std::vector< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const std::vector< T > &	mu,
		int	m )

Queue-plus-delay marginal by the transfer-matrix form of ProCoMoM.

Parameters

L	(R) demands at the single queueing station
N	(R) populations
Z	(R) think times
mu	(sumN) load-dependent rates of the queue, mu[n-1] with n jobs; empty for the load-independent default
m	multiplicity of the queueing station

Definition at line 324 of file pfqn_procomom.h.

References line::pfqn::Procomom2Result< T >::B, line::pfqn::Procomom2Result< T >::F, line::pfqn::Procomom2Result< T >::G, line::InputError::InputError(), line::pfqn::Procomom2Result< T >::lG, line::matmul(), line::num_factorial(), pfqn_procomom2(), line::pfqn::Procomom2Result< T >::pk, and line::pfqn::Procomom2Result< T >::Tr.

Referenced by pfqn_procomom2(), and pfqn_procomom2().

pfqn_propfair()

template<class T>

PropfairResult< T > line::pfqn::pfqn_propfair	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z )

Proportionally fair allocation estimate of the normalizing constant (Schweitzer 1979; Walton, "Proportional fairness and its relationship with multi-class queueing networks", 2009).

Parameters

L	(M x R) demands,
N	(R) population,
Z	(R) think times

Definition at line 80 of file pfqn_propfair.h.

References line::Matrix< T >::cols(), line::pfqn::PropfairResult< T >::G, line::InputError::InputError(), line::pfqn::PropfairResult< T >::lG, line::num_abs(), line::NumericError::NumericError(), pfqn_propfair(), line::Matrix< T >::rows(), line::solve(), and line::pfqn::PropfairResult< T >::Xasy.

Referenced by pfqn_nc(), and pfqn_propfair().

pfqn_qdamva()

template<class T>

QdAmvaResult< T > line::pfqn::pfqn_qdamva	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		const Matrix< T > &	mu,
		const Matrix< T > &	Q0,
		double	tol = 1e-6,
		std::size_t	maxiter = 10000 )

QD-AMVA: queue-dependent approximate mean value analysis.

Parameters

L	(M x R) service demand matrix.
N	(R) population vector, finite.
Z	(R) think time vector; empty means no think time.
mu	(M x smax) queue-dependent rate multipliers; empty means none.
Q0	(M x R) initial guess; empty means the reference's demand split.
tol	convergence tolerance on the queue lengths (default 1e-6).
maxiter	maximum number of iterations (default 10000).

Definition at line 89 of file pfqn_qdamva.h.

References line::Matrix< T >::cols(), line::InputError::InputError(), line::pfqn::QdAmvaResult< T >::iter, line::Matrix< T >::Matrix(), pfqn_lldfun(), pfqn_qdamva(), line::pfqn::QdAmvaResult< T >::Q, line::pfqn::QdAmvaResult< T >::R, line::Matrix< T >::rows(), line::pfqn::QdAmvaResult< T >::U, and line::pfqn::QdAmvaResult< T >::X.

Referenced by line::lqn::lqn_mol(), and pfqn_qdamva().

pfqn_qdlin() [1/2]

template<class T>

QdLinResult< T > line::pfqn::pfqn_qdlin	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		const Matrix< T > &	mu,
		const std::vector< double > &	nservers,
		double	tol = 1e-6,
		std::size_t	maxiter = 1000,
		double	wtol = 1e-4 )

QD-LIN: the Linearizer arm of AMVA-LD, on a plain demand matrix.

Parameters

L	(M x R) service demand matrix, queueing stations only.
N	(R) population vector, finite.
Z	(R) think time vector; a delay station carrying it is appended to the station list when any entry is positive, exactly as the equivalent Network would hold one. Empty means no think time.
mu	(M x smax) load-dependent rate multipliers, sn.lldscaling; empty means none.
nservers	(M) server counts; empty means one server everywhere.
tol	convergence tolerance on the queue lengths, LINE's iter_tol.
maxiter	iteration budget, LINE's iter_max. The outer sweep and each inner sweep are capped at sqrt(maxiter) and the total number of forward evaluations at min(maxiter, 10000).
wtol	floor on the AMVA wait factor, LINE's options.tol. A DIFFERENT knob from tol, with its own default: SolverMVA passes iter_tol to the fixed point but never sets options.tol, so the floor stays at the lineDefaults 1e-4 while the fixed point converges to 1e-6.

Definition at line 205 of file pfqn_qdlin.h.

References line::pfqn::QdLinResult< T >::C, line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), line::pfqn::QdLinResult< T >::iter, line::Matrix< T >::Matrix(), pfqn_qdlin(), line::pfqn::QdLinResult< T >::Q, line::pfqn::QdLinResult< T >::R, line::Matrix< T >::rows(), line::pfqn::QdLinResult< T >::U, and line::pfqn::QdLinResult< T >::X.

Referenced by pfqn_qdlin(), and pfqn_qdlin().

pfqn_qdlin() [2/2]

template<class T>

QdLinResult< T > line::pfqn::pfqn_qdlin	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		double	tol = 1e-6,
		std::size_t	maxiter = 1000,
		double	wtol = 1e-4 )

Overload without a load-dependent lattice or explicit server counts.

Definition at line 468 of file pfqn_qdlin.h.

References pfqn_qdlin().

pfqn_qlen_joint_moments() [1/3]

template<class T>

QlenJointMomentsResult< T > line::pfqn::pfqn_qlen_joint_moments	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z )

MATLAB defaults: every coordinate, the automatic route, no injected source.

Definition at line 463 of file pfqn_qlen_joint_moments.h.

References Auto, Exact, and pfqn_qlen_joint_moments().

pfqn_qlen_joint_moments() [2/3]

template<class T>

QlenJointMomentsResult< T > line::pfqn::pfqn_qlen_joint_moments	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const std::vector< std::pair< std::size_t, std::size_t > > &	pairs )

MATLAB defaults with an explicit coordinate list.

Definition at line 472 of file pfqn_qlen_joint_moments.h.

References Auto, Exact, and pfqn_qlen_joint_moments().

pfqn_qlen_joint_moments() [3/3]

template<class T>

QlenJointMomentsResult< T > line::pfqn::pfqn_qlen_joint_moments	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const std::vector< std::pair< std::size_t, std::size_t > > &	pairs,
		QlenJointRoute	route,
		const QlenJointLgSource< T > &	lGsrc,
		NcMethod	method,
		const NcOptions &	nopt )

Joint moments of the queue-length vector of a closed product-form network, obtained from normalizing constants.

Parameters

L	(M x R) demands of the QUEUEING stations; delay stations belong in Z, their marginals following a different law
N	(R) population vector
Z	(R) think times, zeros for none
pairs	0-based (station, class) coordinates, one per dimension of the returned arrays; empty for every class of every station
route	which survival identity to use
lGsrc	injected source of log G; empty to call pfqn_nc throughout
method	the normalizing-constant algorithm handed to pfqn_nc
nopt	sample count and seed the estimators read

Definition at line 217 of file pfqn_qlen_joint_moments.h.

References Auto, line::Matrix< T >::cols(), line::pfqn::QlenJointMomentsResult< T >::dims, line::InputError::InputError(), line::pfqn::QlenJointMomentsResult< T >::pairs, pfqn_qlen_joint_moments(), Pmf, line::pfqn::QlenJointMomentsResult< T >::route, line::Matrix< T >::rows(), and Tail.

Referenced by pfqn_qlen_joint_moments(), pfqn_qlen_joint_moments(), and pfqn_qlen_joint_moments().

pfqn_qli()

template<class T>

WsResult< T > line::pfqn::pfqn_qli	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		double	tol = 1e-6,
		std::size_t	max_iter = 1000 )

Wang-Sevcik Queue-Line.

Definition at line 203 of file pfqn_wangsevcik.h.

References pfqn_qli(), pfqn_wangsevcik(), and Qli.

Referenced by pfqn_qli().

pfqn_qsa() [1/3]

template<class T>

AmvaResult< T > line::pfqn::pfqn_qsa	(	const Matrix< T > &	L,
		const std::vector< T > &	N )

Definition at line 410 of file pfqn_qsa.h.

References pfqn_qsa().

pfqn_qsa() [2/3]

template<class T>

AmvaResult< T > line::pfqn::pfqn_qsa	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z )

Definition at line 405 of file pfqn_qsa.h.

References pfqn_qsa().

pfqn_qsa() [3/3]

template<class T>

AmvaResult< T > line::pfqn::pfqn_qsa	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		const std::vector< AmvaSched > &	type,
		double	tol = 1e-10,
		std::size_t	maxiter = 100,
		int	levels = 3 )

Queue-Shift Approximation (QSA) for closed product-form networks.

Parameters

L	(M x R) demands
N	(R) populations
Z	(R) think times, empty for none
type	(M) per-station scheduling; AmvaSched::INF marks a delay centre, whose demand enters the cycle time without a queueing term (the paper's DC set). Empty means every station queues.
tol	residual tolerance of the Newton iteration
maxiter	maximum Newton iterations
levels	2 for the two-level QSA of eq. (14), 3 for eq. (16)

Definition at line 221 of file pfqn_qsa.h.

References line::Matrix< T >::cols(), line::pfqn::AmvaResult< T >::converged, INF, line::InputError::InputError(), line::pfqn::AmvaResult< T >::iterations, line::Matrix< T >::Matrix(), pfqn_qsa(), line::pfqn::AmvaResult< T >::QN, line::pfqn::AmvaResult< T >::RN, line::Matrix< T >::rows(), line::solve(), line::pfqn::AmvaResult< T >::UN, and line::pfqn::AmvaResult< T >::XN.

Referenced by pfqn_qsa(), pfqn_qsa(), pfqn_qsa(), and line::mva::solver_amva().

pfqn_qzgblow()

template<class T>

T line::pfqn::pfqn_qzgblow	(	const std::vector< T > &	L,
		const T &	N,
		const T &	Z,
		std::size_t	i )

Qgb = y/(1-y) - y^(N+1)/(1-y) with y = N L_i / (Z + sum(L) + Lmax N).

Definition at line 33 of file pfqn_qzgblow.h.

References line::InputError::InputError(), line::num_pow_int(), line::NumericError::NumericError(), and pfqn_qzgblow().

Referenced by pfqn_qzgblow(), pfqn_xzgsblow(), and line::ba::solver_ba_analyzer().

pfqn_qzgbup()

template<class T>

T line::pfqn::pfqn_qzgbup	(	const std::vector< T > &	L,
		const T &	N,
		const T &	Z,
		std::size_t	i )

As the lower bound, with Y from the ABA upper bound and the sigma term.

Definition at line 34 of file pfqn_qzgbup.h.

References line::InputError::InputError(), line::num_pow_int(), pfqn_qzgbup(), and pfqn_xzabaup().

Referenced by pfqn_qzgbup(), pfqn_xzgsbup(), and line::ba::solver_ba_analyzer().

pfqn_rd() [1/2]

template<class T>

RdResult< T > line::pfqn::pfqn_rd	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const Matrix< T > &	mu )

Reference defaults: tol 1e-6, and the exact convolution for the reduced load-independent constant.

The reference sets options.method = 'default', whose multi-station branch in this tree dispatches to the cub / le family that is not ported; 'ca' is what MATLAB's 'default' itself selects for models of the size this heuristic targets, and it is exact.

Definition at line 253 of file pfqn_rd.h.

References Ca, and pfqn_rd().

pfqn_rd() [2/2]

template<class T>

RdResult< T > line::pfqn::pfqn_rd	(	const Matrix< T > &	L0,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const Matrix< T > &	mu0,
		double	tol,
		NcMethod	method )

Reduction heuristic (RD) for the normalizing constant of a closed LOAD-DEPENDENT product-form network.

Parameters

L0	(M x R) service demands
N	(R) population per class
Z	(K x R) think times, summed over rows; empty for none
mu0	(M x >= sum N) load-dependent rates
tol	tolerance used to locate the terminal rate (reference 1e-6)
method	the load-independent constant algorithm to reduce to

Definition at line 101 of file pfqn_rd.h.

References line::pfqn::RdResult< T >::Cgamma, line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::pfqn::NcResult< T >::G, line::InputError::InputError(), line::pfqn::NcResult< T >::lG, line::pfqn::RdResult< T >::lGN, line::num_abs(), line::NumericError::NumericError(), pfqn_lldsingle(), pfqn_mva(), pfqn_nc(), pfqn_rd(), line::Matrix< T >::rows(), and line::pfqn::MvaResult< T >::XN.

Referenced by pfqn_ncld(), pfqn_rd(), pfqn_rd(), and pfqn_stdf_heur().

pfqn_recal() [1/3]

template<class T>

NcResult< T > line::pfqn::pfqn_recal	(	const Matrix< T > &	L,
		const std::vector< int > &	N )

Overload without think times.

Definition at line 314 of file pfqn_recal.h.

References pfqn_recal().

pfqn_recal() [2/3]

template<class T>

NcResult< T > line::pfqn::pfqn_recal	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z )

Overload with unit station multiplicities.

Definition at line 308 of file pfqn_recal.h.

References pfqn_recal().

pfqn_recal() [3/3]

template<class T>

NcResult< T > line::pfqn::pfqn_recal	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const std::vector< int > &	m0 )

RECAL (REcursive CALculation) for the exact normalizing constant of a closed product-form network (Conway and Georganas 1986).

Parameters

L	(M x R) service demands, M queueing stations, R classes
N	(R) population per class, non-negative
Z	(K x R) think times, summed over rows; may be empty
m0	(M) station multiplicities, each at least one; empty for all ones

Definition at line 188 of file pfqn_recal.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), Lc, line::NumericError::NumericError(), pfqn_recal(), and line::Matrix< T >::rows().

Referenced by pfqn_nc(), pfqn_recal(), pfqn_recal(), and pfqn_recal().

pfqn_respt_ps_moments() [1/2]

template<class T>

ResptPsMomentsResult< T > line::pfqn::pfqn_respt_ps_moments	(	const std::vector< T > &	S,
		const std::vector< long > &	N,
		const std::vector< T > &	Z )

MATLAB default: the automatic route.

Definition at line 385 of file pfqn_respt_ps_moments.h.

References Auto, and pfqn_respt_ps_moments().

pfqn_respt_ps_moments() [2/2]

template<class T>

ResptPsMomentsResult< T > line::pfqn::pfqn_respt_ps_moments	(	const std::vector< T > &	S,
		const std::vector< long > &	N,
		const std::vector< T > &	Z,
		ResptPsRoute	route )

Sojourn-time moments at the processor-sharing station of a closed terminal-driven system (Mitra and Morrison 1983).

Parameters

S	(R) mean service times at the PS station, positive
N	(R) populations, non-negative integers
Z	(R) mean think times, positive where N > 0
route	which route to take

Definition at line 297 of file pfqn_respt_ps_moments.h.

References line::pfqn::ResptPsMomentsResult< T >::alpha, Asymptotic, Auto, line::pfqn::ResptPsMomentsResult< T >::c0, line::pfqn::ResptPsMomentsResult< T >::c1, Exact, line::pfqn::ResptPsMomentsResult< T >::expansionParam, line::InputError::InputError(), line::pfqn::ResptPsMomentsResult< T >::method, None, line::pfqn::ResptPsMomentsResult< T >::nstates, pfqn_respt_ps_moments(), Unavailable, line::pfqn::ResptPsMomentsResult< T >::W, and line::pfqn::ResptPsMomentsResult< T >::W2.

Referenced by pfqn_respt_ps_moments(), and pfqn_respt_ps_moments().

pfqn_rgf() [1/2]

template<class T>

RgfResult< T > line::pfqn::pfqn_rgf	(	const std::vector< T > &	L,
		int	N )

Overload without a delay.

Definition at line 158 of file pfqn_rgf.h.

References pfqn_rgf().

pfqn_rgf() [2/2]

template<class T>

RgfResult< T > line::pfqn::pfqn_rgf	(	const std::vector< T > &	L,
		int	N,
		const T &	Z )

Recursion by Generating Functions (RGF) for the normalizing constant of a SINGLE-CLASS closed product-form network with replicated stations.

Parameters

L	(M) service demands of the queueing stations
N	population, a nonnegative integer
Z	aggregate delay demand (think time); zero for none

Definition at line 91 of file pfqn_rgf.h.

References line::pfqn::RgfResult< T >::G, line::InputError::InputError(), line::pfqn::RgfResult< T >::lG, line::pfqn::RgfResult< T >::lg, and pfqn_rgf().

Referenced by pfqn_hst(), pfqn_nc(), pfqn_rgf(), pfqn_rgf(), and pfqn_rgfmc().

pfqn_rgfmc() [1/2]

template<class T>

RgfmcResult< T > line::pfqn::pfqn_rgfmc	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z )

Overload with the reference defaults (tol 1e-12, 1e6 terms, 15 nats).

Definition at line 584 of file pfqn_rgfmc.h.

References pfqn_rgfmc().

pfqn_rgfmc() [2/2]

template<class T>

RgfmcResult< T > line::pfqn::pfqn_rgfmc	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const T &	tol,
		std::size_t	maxterms,
		const T &	maxcancel )

Multiclass Recursion by Generating Functions (RGF), with think times.

Parameters

L	(M x R) service demands
N	(R) populations, nonnegative integers
Z	(R) think times
tol	relative tolerance for calling two affine forms proportional
maxterms	cap on residue terms carried between eliminations
maxcancel	nats of cancellation tolerated before refusing

Definition at line 465 of file pfqn_rgfmc.h.

References line::Matrix< T >::cols(), line::pfqn::RgfmcResult< T >::G, line::pfqn::RgfResult< T >::G, line::InputError::InputError(), line::pfqn::RgfmcResult< T >::lG, line::pfqn::RgfResult< T >::lG, Ls, pfqn_rgf(), pfqn_rgfmc(), and line::Matrix< T >::rows().

Referenced by pfqn_nc(), pfqn_rgfmc(), and pfqn_rgfmc().

pfqn_scat() [1/3]

template<class T>

LinearizerResult< T > line::pfqn::pfqn_scat	(	const Matrix< T > &	L,
		const std::vector< int > &	N )

Definition at line 85 of file pfqn_scat.h.

References pfqn_scat().

pfqn_scat() [2/3]

template<class T>

LinearizerResult< T > line::pfqn::pfqn_scat	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z )

Definition at line 80 of file pfqn_scat.h.

References pfqn_scat().

pfqn_scat() [3/3]

template<class T>

LinearizerResult< T > line::pfqn::pfqn_scat	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const std::vector< SchedStrategy > &	type,
		double	tol,
		int	maxiter,
		const Matrix< T > &	QN0 )

Neuse-Chandy SCAT (Self-Correcting Approximation Technique) approximate MVA.

Parameters

L	(M x R) service demands
N	(R) population per class
Z	(K x R) think times, summed over rows; may be empty
type	(M) scheduling discipline; carried, see pfqn_egflinearizer
tol	convergence tolerance
maxiter	total inner-iteration budget
QN0	(M x R) warm start; may be empty

Definition at line 71 of file pfqn_scat.h.

References pfqn_egflinearizer(), and pfqn_scat().

Referenced by pfqn_scat(), pfqn_scat(), pfqn_scat(), and line::mva::solver_amva().

pfqn_scb()

template<class T>

ScbBounds< T > line::pfqn::pfqn_scb	(	const std::vector< T > &	L,
		long	N )

Bracket on the throughput and the per-device utilizations of the UNKNOWN multiclass system whose single-class counterpart has demands L at population N.

Theorem 2 / Corollary 2: aggregating an R-class model into its single-class counterpart can only understate performance, U_k,1 <= U_k,R and X_1 <= X_R, and Corollary 1 makes the utilization ratio uniform, U_k,R/U_k,1 = X_R/X_1 for every k. Theorem 3 (their Expression 3) caps the relative throughput error at (m-1)/(N+m-1), m = min(N,K), independently of the demands. The single-server capacity U_k,R <= 1 caps the same ratio at 1/(X_1*max(L)), tight on the paper's own worst case, so both are applied.

Parameters

L	(K) demands of the queueing stations only; a delay station is not admitted, Theorem 3 resting on the delay-free balanced-network throughput N/((N+m-1)D)
N	population (N >= 1)

Definition at line 67 of file pfqn_scb.h.

References line::InputError::InputError(), pfqn_scb(), line::pfqn::ScbBounds< T >::Uhi, line::pfqn::ScbBounds< T >::Ulo, line::pfqn::ScbBounds< T >::Xhi, and line::pfqn::ScbBounds< T >::Xlo.

Referenced by pfqn_scb(), and line::ba::solver_ba_analyzer().

pfqn_scbgap() [1/2]

template<class T>

T line::pfqn::pfqn_scbgap	(	long	N,
		long	K )

Full single-class aggregation: r = N, dominating classes allowed.

Definition at line 155 of file pfqn_scb.h.

References pfqn_scbgap().

pfqn_scbgap() [2/2]

template<class T>

T line::pfqn::pfqn_scbgap	(	long	N,
		long	K,
		long	r,
		bool	undominated )

Demand-free bound on the relative throughput error incurred when r of the N single-customer classes are merged into one class.

With r = N this is the full single-class aggregation error of their Theorem 3, at most 50%; with r < N it is the partial-aggregation error of their Theorem 4. The bound never reads the demands, so it can be attached as a certified error bar to any result computed on merged chains.

General case, dominating classes allowed (Expression 4, and with r = N Expression 3): e = (min(r,K)-1)/(r+min(r,K)-1). Undominated case, every customer placing the same total demand (Theorem 5 and its comment (3), which lifts the N = R restriction): e = r(r-1)/(min(N,K)(2r-1)), valid for r <= K only, smaller than the general case by the factor r/min(N,K) and equal to it at r = K. THE DOMAIN IS NOT COSMETIC: Theorem 5 gives each of its R classes a dedicated device, so r never exceeds K there, and comment (3) states the generalization for r < K. Evaluated at r > K the expression climbs past the general bound and past the 50% cap of Theorem 3, i.e. it stops being a bound, so r > K is refused rather than returned.

Parameters

N	total customers, one per class
K	devices
r	classes merged into one (1 <= r <= N)
undominated	true for the tighter Theorem-5 form, valid only when every customer's total device demand is equal, and only for r <= K

Definition at line 135 of file pfqn_scb.h.

References line::InputError::InputError(), and pfqn_scbgap().

Referenced by pfqn_scbgap(), and pfqn_scbgap().

pfqn_schmidt() [1/2]

template<class T>

SchmidtResult< T > line::pfqn::pfqn_schmidt	(	const Matrix< T > &	D,
		const std::vector< int > &	N,
		const Matrix< int > &	S,
		const std::vector< SchedStrategy > &	sched )

Unit visit ratios, the MATLAB default.

Definition at line 321 of file pfqn_schmidt.h.

References pfqn_schmidt().

pfqn_schmidt() [2/2]

template<class T>

SchmidtResult< T > line::pfqn::pfqn_schmidt	(	const Matrix< T > &	D,
		const std::vector< int > &	N,
		const Matrix< int > &	S,
		const std::vector< SchedStrategy > &	sched,
		const Matrix< T > &	v )

Schmidt's MVA for closed networks with general scheduling disciplines and class-dependent multiserver FCFS stations.

Parameters

D	(M x R) service demands
N	(R) population per class
S	(M x R) or (M x 1) server counts
sched	(M) scheduling discipline per station
v	(M x R) visit ratios; empty for all ones

Definition at line 84 of file pfqn_schmidt.h.

References line::pfqn::SchmidtResult< T >::CN, line::Matrix< T >::cols(), line::Matrix< T >::empty(), FCFS, INF, line::InputError::InputError(), line::Matrix< T >::Matrix(), line::next_pop(), pfqn_schmidt(), line::plane_sizes(), line::pop_index(), line::population_count(), PS, line::pfqn::SchmidtResult< T >::QN, line::Matrix< T >::rows(), line::pfqn::SchmidtResult< T >::UN, and line::pfqn::SchmidtResult< T >::XN.

Referenced by pfqn_schmidt(), pfqn_schmidt(), pfqn_schmidt_ext(), and line::mva::solver_amva().

pfqn_schmidt_ext()

template<class T>

SchmidtExtResult< T > line::pfqn::pfqn_schmidt_ext	(	const Matrix< T > &	D,
		const std::vector< int > &	N,
		const Matrix< int > &	S,
		const std::vector< SchedStrategy > &	sched )

Extended Schmidt MVA with queue-aware alpha corrections.

Parameters

D	(M x R) service demands
N	(R) population per class
S	(M x 1) or (M x R) server counts; (M x 1) is required when any class-dependent FCFS multiserver station needs an alpha
sched	(M) scheduling discipline per station

Definition at line 150 of file pfqn_schmidt_ext.h.

References line::pfqn::SchmidtExtResult< T >::CN, line::Matrix< T >::cols(), line::Matrix< T >::empty(), FCFS, INF, line::InputError::InputError(), line::Matrix< T >::Matrix(), line::next_pop(), line::num_nck(), line::num_pow_int(), pfqn_schmidt(), pfqn_schmidt_ext(), line::plane_sizes(), line::pop_index(), line::population_count(), PS, line::pfqn::SchmidtExtResult< T >::QN, line::Matrix< T >::rows(), line::pfqn::SchmidtExtResult< T >::UN, and line::pfqn::SchmidtExtResult< T >::XN.

Referenced by pfqn_schmidt_ext(), and line::mva::solver_amva().

pfqn_sdr()

template<class T>

SdrResult< T > line::pfqn::pfqn_sdr	(	const Matrix< T > &	S,
		const Matrix< T > &	xi,
		const std::vector< std::size_t > &	N,
		const SdrStruct &	sdr,
		const Matrix< T > &	alpha = Matrix<T>() )

Exact product form of eq.

(16), by summation over the reachable state space.

P(n) is G^-1 times the product over centres of f_i(n_i), the product over levels of Omega_{t-1,t}(v_t)/Omega_tt(v_t), and the product over branches of Delta_tb(m_b), with f_i(n_i) = [n_i!/beta_i(n_i)] times the product over chains of gamma_ij^n_ij/n_ij! and gamma_ij = xi_ij/mu_ij.

General in the branch topology: a branch may hold several interconnected centres. Only the paper's Section 4 MVA and convolution algorithm, not ported here, is restricted to single-centre branches.

S and xi are required separately rather than as their product because under SDR the xi are not visit ratios, so the per-centre throughputs cannot be recovered from the demands alone.

Parameters

S	(M x J) mean service times 1/mu_ij
xi	(M x J) coefficients of Section 3.2, see pfqn_sdrvisits
N	(J) chain populations
sdr	the routing structure, in centre indices
alpha	(M x sum(N)) load-dependent rate scalings, alpha(i, k-1) = alpha_i(k); empty for a fixed-rate centre. Use k for an infinite server and min(k, c) for a c-server centre

Definition at line 304 of file pfqn_sdr.h.

References line::pfqn::SdrCoeff::B, line::pfqn::SdrStruct::branch, line::pfqn::SdrStruct::C, line::Matrix< T >::cols(), line::pfqn::SdrStruct::d, line::pfqn::SdrCoeff::Dprev, line::pfqn::SdrCoeff::Dtt, line::pfqn::SdrResult< T >::G, line::pfqn::SdrCoeff::inA, line::InputError::InputError(), line::pfqn::SdrStruct::level, line::Matrix< T >::Matrix(), pfqn_sdr(), pfqn_sdrcoeff(), line::pfqn::SdrResult< T >::QN, line::pfqn::SdrResult< T >::RN, line::Matrix< T >::rows(), line::pfqn::SdrCoeff::T, line::pfqn::SdrResult< T >::UN, and line::pfqn::SdrResult< T >::XN.

Referenced by pfqn_sdr(), and line::nc::solver_nc_sdr().

pfqn_sdrcoeff()

SdrCoeff line::pfqn::pfqn_sdrcoeff ( const SdrStruct & sdr )

inline

Validates an SDR structure and returns its derived coefficients.

The population bounds are consequences of the coefficients, not independent inputs: with C_t negative the routing enforces m_b <= d_tb/(-C_t) and v_t <= D_tt/(-C_t) by itself, because the cumulative Delta hits a zero factor exactly at the bound.

Definition at line 105 of file pfqn_sdr.h.

References line::pfqn::SdrCoeff::B, line::pfqn::SdrStruct::branch, line::pfqn::SdrStruct::C, line::Matrix< T >::cols(), line::pfqn::SdrStruct::d, line::pfqn::SdrStruct::departure, line::pfqn::SdrStruct::departureOf, line::pfqn::SdrCoeff::Dprev, line::pfqn::SdrCoeff::Dtt, line::pfqn::SdrStruct::entry, line::pfqn::SdrStruct::entryOf, line::pfqn::SdrCoeff::inA, line::InputError::InputError(), line::pfqn::SdrStruct::level, line::pfqn::SdrCoeff::mmax, pfqn_sdrcoeff(), line::Matrix< T >::rows(), line::pfqn::SdrCoeff::sdr, line::pfqn::SdrCoeff::T, and line::pfqn::SdrCoeff::vmax.

Referenced by pfqn_sdr(), pfqn_sdrcoeff(), pfqn_sdrmva(), pfqn_sdrvisits(), line::qn::rt_state(), and line::qn::Network< double >::set_state_dep_routing().

pfqn_sdrmva()

template<class T>

SdrResult< T > line::pfqn::pfqn_sdrmva	(	const Matrix< T > &	S,
		const Matrix< T > &	xi,
		const std::vector< std::size_t > &	N,
		const SdrStruct &	sdr,
		const Matrix< T > &	alpha = Matrix<T>() )

Section 4 mean value analysis and convolution.

Same inputs and outputs as pfqn_sdr, which evaluates eq. (16) exactly by state enumeration, so the two are directly comparable. This routine costs O(J T M (V_1...V_J)^2) rather than the size of the state space, at the price of two restrictions the paper itself imposes: every SDR branch must hold a single centre, and every C_t must be negative. A C_t other than -1 is rescaled internally, which leaves eqs. (10) and (16) unchanged because the level factors telescope.

Two formulas of Section 4 are corrected here, both verified against pfqn_sdr. The initialise step of 4.2.2 divides by T_j(V-1_j,V_T) where the convolution identity G(V)/G(V-1_j) = 1/T_j(V) gives T_j(V,V_T); this implementation forms G = g_mva Omega_{T-1,T}/Omega_TT directly instead. And 4.2.3's T_ij = xi_ij [d_1i - Q_i] T_j drops the state-dependent omega ratios of eq. (10); the exact identity is T_ij = xi_ij T_j(N,M) E_{N-1_j}[P_{e,e(i)}].

Unlike pfqn_sdr this routine divides by intermediate normalizing constants, so it needs a field with division but no transcendentals beyond the final logarithm of G.

Definition at line 552 of file pfqn_sdr.h.

References line::pfqn::SdrCoeff::B, line::pfqn::SdrStruct::branch, line::pfqn::SdrStruct::C, line::Matrix< T >::cols(), line::pfqn::SdrStruct::d, line::InputError::InputError(), line::pfqn::SdrStruct::level, pfqn_sdrcoeff(), pfqn_sdrmva(), Ps, line::Matrix< T >::rows(), line::pfqn::SdrCoeff::T, and line::UnsupportedError::UnsupportedError().

Referenced by pfqn_sdrmva(), and line::nc::solver_nc_sdr().

pfqn_sdrped()

double line::pfqn::pfqn_sdrped ( const std::vector< double > & P )

inline

Probability of being denied entry and routed straight to the departure centre.

Definition at line 239 of file pfqn_sdr.h.

References pfqn_sdrped().

Referenced by pfqn_sdrped(), and line::qn::rt_state().

pfqn_sdrprob()

std::vector< double > line::pfqn::pfqn_sdrprob ( const SdrCoeff & c, const std::vector< double > & n )

inline

SDR routing probabilities of eq.

(10).

Entry b of the result is the probability of proceeding from the entry centre e of Q(V,V) to the entry centre of branch b; entry 0 is zero because branch index 1 denotes the complement M-V. The residual mass 1 - sum is the probability of proceeding directly to the departure centre d, that is of being denied entry into Q(V,V) and returned to e, which the paper calls the busy form of waiting (Sec. 2.5).

The probabilities are chain independent: they read the total branch and subnetwork populations, not the per-chain ones. The chain-dependent form of eq. (1) has no published product form and is not implemented. A branch population beyond the bound SDR enforces itself is unreachable, and the probability returned there is zero.

Parameters

c	derived coefficients from pfqn_sdrcoeff
n	per-centre total populations, indexed as the structure is

Definition at line 207 of file pfqn_sdr.h.

References line::pfqn::SdrCoeff::B, line::pfqn::SdrStruct::branch, line::pfqn::SdrStruct::C, line::pfqn::SdrStruct::d, line::pfqn::SdrCoeff::Dprev, line::pfqn::SdrCoeff::Dtt, line::pfqn::SdrCoeff::inA, line::pfqn::SdrStruct::level, pfqn_sdrprob(), line::pfqn::SdrCoeff::sdr, and line::pfqn::SdrCoeff::T.

Referenced by pfqn_sdrprob(), and line::qn::rt_state().

pfqn_sdrvisits()

template<class T>

Matrix< T > line::pfqn::pfqn_sdrvisits	(	const SdrStruct &	sdr,
		const std::vector< Matrix< T > > &	P )

Coefficients xi of Section 3.2.

P holds one centre-by-centre state-independent routing matrix per chain. Three rules fix the coefficients: the complement M-V obeys the ordinary traffic equations with the whole SDR subnetwork collapsed into a single e -> d arc of probability one; every branch obeys its own traffic equations driven by an injection of xi_e at its entry centre; and xi_e is one.

The paper states xi_ij = xi_ej for the branch entry and departure centres and works out only single-centre branches. The traffic equations above are the reading that extends it: they return xi at the branch departure equal to xi_e because a customer leaves a branch only through it, and xi at the branch entry equal to xi_e whenever that centre takes no internal feedback. They have been checked against a brute-force CTMC on a branch that does take such feedback, where the literal rule fails.

These xi are NOT relative visit counts: the rate at which customers enter a branch is state dependent, so a ratio of two xi carries no flow meaning.

Definition at line 855 of file pfqn_sdr.h.

References Ab, line::pfqn::SdrCoeff::B, line::pfqn::SdrStruct::branch, line::pfqn::SdrStruct::departure, line::mc::dtmc_solve(), line::pfqn::SdrStruct::entry, line::pfqn::SdrStruct::entryOf, line::InputError::InputError(), pfqn_sdrcoeff(), pfqn_sdrvisits(), and line::solve().

Referenced by pfqn_sdrvisits(), and line::nc::solver_nc_sdr().

pfqn_sens() [1/2]

template<class T>

SensResult< T > line::pfqn::pfqn_sens	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z )

pfqn_sens with unit multiplicities.

Definition at line 402 of file pfqn_sens.h.

References pfqn_sens().

pfqn_sens() [2/2]

template<class T>

SensResult< T > line::pfqn::pfqn_sens	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const std::vector< int > &	mi )

Exact analytic derivatives of the mean performance measures {X,Q,U,R} of a closed product-form (BCMP) network with respect to the demands L(i,r) and the think times Z(r).

Parameters

L	(M x R) service demands
N	(R) population per class
Z	(R) think times, empty for none
mi	(M) station multiplicities, empty for all ones

Definition at line 348 of file pfqn_sens.h.

References line::pfqn::SensResult< T >::dQ, line::pfqn::SensResult< T >::params, pfqn_sens(), pfqn_sens_comom(), pfqn_sens_dmva(), pfqn_sens_mva(), line::pfqn::SensMvaResult< T >::QCov, line::pfqn::SensResult< T >::QCov, line::pfqn::SensMvaResult< T >::QCovAsym, line::pfqn::SensResult< T >::QCovAsym, line::pfqn::SensMvaResult< T >::QTotVar, line::pfqn::SensResult< T >::QTotVar, line::pfqn::SensMvaResult< T >::QVar, line::pfqn::SensResult< T >::QVar, and line::Matrix< T >::rows().

Referenced by line::opt::closed_sensitivities(), pfqn_sens(), pfqn_sens(), and line::sens::solver_sensitivity_table().

pfqn_sens_comom()

template<class T>

SensResult< T > line::pfqn::pfqn_sens_comom	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z )

CoMoM-backed kernel for the repairman model (M = 1).

Parameters are ordered L(0,0), ..., L(0,R-1), then Z(0), ..., Z(R-1), matching pfqn_sens_dmva at M = 1.

Definition at line 225 of file pfqn_sens.h.

References line::pfqn::SensResult< T >::CN, line::Matrix< T >::cols(), line::pfqn::SensResult< T >::dQ, line::pfqn::SensResult< T >::dR, line::pfqn::SensResult< T >::dU, line::pfqn::SensResult< T >::dX, Gm, line::InputError::InputError(), Ls, line::pfqn::SensResult< T >::params, pfqn_comomrm(), pfqn_sens_comom(), line::pfqn::SensResult< T >::QN, line::Matrix< T >::rows(), line::pfqn::SensResult< T >::UN, and line::pfqn::SensResult< T >::XN.

Referenced by pfqn_sens(), and pfqn_sens_comom().

pfqn_sens_dmva()

template<class T>

SensResult< T > line::pfqn::pfqn_sens_dmva	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const std::vector< int > &	mi )

Forward-mode differentiation of the exact MVA recursion.

Parameters are ordered L(0,0), L(0,1), ..., L(M-1,R-1), then Z(0), ..., Z(R-1).

Definition at line 112 of file pfqn_sens.h.

References line::pfqn::SensResult< T >::CN, line::Matrix< T >::cols(), line::pfqn::SensResult< T >::dQ, line::pfqn::SensResult< T >::dR, line::pfqn::SensResult< T >::dU, line::pfqn::SensResult< T >::dX, line::Matrix< T >::empty(), line::InputError::InputError(), line::pfqn::SensResult< T >::params, pfqn_sens_dmva(), line::population_count(), line::pfqn::SensResult< T >::QN, line::Matrix< T >::rows(), sens_lattice_decode(), sens_lattice_radix(), line::pfqn::SensResult< T >::UN, and line::pfqn::SensResult< T >::XN.

Referenced by pfqn_sens(), and pfqn_sens_dmva().

pfqn_sens_ldmx_ec()

template<class T>

SensLdmxEcResult< T > line::pfqn::pfqn_sens_ldmx_ec	(	const std::vector< T > &	lambda,
		const Matrix< T > &	D,
		const Matrix< T > &	mu )

Effective capacity terms of the mixed load-dependent MVA of Bruell-Balbo-Afshari, together with their exact derivatives with respect to the open-class load Lo(i) of each station.

Parameters

lambda	(R) arrival rates, zero on the closed classes
D	(M x R) service demands
mu	(M x Nt) load-dependent rate lattice, limited load dependence

Definition at line 67 of file pfqn_sens_ldmx_ec.h.

References line::Matrix< T >::cols(), line::pfqn::SensLdmxEcResult< T >::dE, line::pfqn::SensLdmxEcResult< T >::dEC, line::pfqn::SensLdmxEcResult< T >::dEprime, line::pfqn::SensLdmxEcResult< T >::E, line::pfqn::SensLdmxEcResult< T >::EC, line::pfqn::SensLdmxEcResult< T >::Eprime, line::InputError::InputError(), line::pfqn::SensLdmxEcResult< T >::Lo, line::Matrix< T >::Matrix(), line::num_pow_int(), line::NumericError::NumericError(), pfqn_sens_ldmx_ec(), and line::Matrix< T >::rows().

Referenced by pfqn_sens_ldmx_ec(), and pfqn_sens_mvaldmx().

pfqn_sens_linearizer() [1/2]

template<class T>

SensLinearizerResult< T > line::pfqn::pfqn_sens_linearizer	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z )

pfqn_sens_linearizer with the defaults of the reference.

Definition at line 402 of file pfqn_sens_linearizer.h.

References pfqn_sens_linearizer().

pfqn_sens_linearizer() [2/2]

template<class T>

SensLinearizerResult< T > line::pfqn::pfqn_sens_linearizer	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const T *	tol,
		unsigned	maxiter )

Approximate moments E[Q_i], Var[Q_i], Cov[Q_i,Q_j], E[Q_i^2] and E[Q_i^3] of the per-station total queue lengths of a closed product-form network, by the LINEARIZER-2 / LINEARIZER-3 algorithms of Strelen (Performance Evaluation 11:127-142, 1990, Section 5).

Parameters

L	(M x R) service demands
N	(R) population per class, closed only
Z	(R) think times, empty for none
tol	stopping tolerance on the mean queue lengths; null for the reference's own test 1/(4000 + 16 sum(n))
maxiter	maximum CORE iterations, 200 in the reference

Definition at line 264 of file pfqn_sens_linearizer.h.

References line::Matrix< T >::cols(), line::pfqn::SensLinearizerResult< T >::Cov, line::pfqn::SensLinearizerResult< T >::CovAsym, line::pfqn::SensLinearizerResult< T >::d2m, line::pfqn::SensLinearizerResult< T >::dm, line::Matrix< T >::empty(), line::InputError::InputError(), line::pfqn::SensLinearizerResult< T >::iter, line::pfqn::SensLinearizerResult< T >::m, line::pfqn::SensLinearizerResult< T >::M2, line::pfqn::SensLinearizerResult< T >::M3, line::Matrix< T >::Matrix(), line::num_abs(), pfqn_sens_linearizer(), line::pfqn::SensLinearizerResult< T >::QN, line::Matrix< T >::rows(), line::pfqn::SensLinearizerResult< T >::Skew, line::pfqn::SensLinearizerResult< T >::UN, line::pfqn::SensLinearizerResult< T >::Var, line::pfqn::SensLinearizerResult< T >::WN, and line::pfqn::SensLinearizerResult< T >::XN.

Referenced by pfqn_sens_linearizer(), and pfqn_sens_linearizer().

pfqn_sens_mom() [1/2]

template<class T>

SensMomResult< T > line::pfqn::pfqn_sens_mom	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z )

pfqn_sens_mom with unit multiplicities and per-station totals.

Definition at line 281 of file pfqn_sens_mom.h.

References pfqn_sens_mom().

pfqn_sens_mom() [2/2]

template<class T>

SensMomResult< T > line::pfqn::pfqn_sens_mom	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const std::vector< int > &	mi,
		const std::vector< int > &	groups )

Exact moments E[Q], Var[Q], E[Q^2] and E[Q^3] of the grouped queue lengths of a closed product-form network, by second-order differentiation of the MVA recursion.

Parameters

L	(M x R) service demands
N	(R) population per class, closed only
Z	(R) think times, empty for none
mi	(M) station multiplicities, empty for all ones
groups	(R) 0-based group label of each class; empty means one group holding every class, i.e. the per-station totals

Definition at line 86 of file pfqn_sens_mom.h.

References line::pfqn::SensMomResult< T >::CN, line::Matrix< T >::cols(), line::pfqn::SensMomResult< T >::Cov, line::pfqn::SensMomResult< T >::CovAsym, line::pfqn::SensMomResult< T >::d2m, line::pfqn::SensMomResult< T >::dm, line::Matrix< T >::empty(), line::Matrix< T >::fill(), line::InputError::InputError(), line::pfqn::SensMomResult< T >::m, line::pfqn::SensMomResult< T >::M2, line::pfqn::SensMomResult< T >::M3, line::Matrix< T >::Matrix(), line::num_abs(), pfqn_sens_mom(), line::population_count(), line::pfqn::SensMomResult< T >::QN, line::Matrix< T >::rows(), sens_lattice_decode(), sens_lattice_radix(), line::pfqn::SensMomResult< T >::Skew, line::pfqn::SensMomResult< T >::UN, line::pfqn::SensMomResult< T >::Var, and line::pfqn::SensMomResult< T >::XN.

Referenced by pfqn_sens_mom(), and pfqn_sens_mom().

pfqn_sens_mva() [1/2]

template<class T>

SensMvaResult< T > line::pfqn::pfqn_sens_mva	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z )

pfqn_sens_mva with unit multiplicities.

Definition at line 216 of file pfqn_sens_mva.h.

References pfqn_sens_mva().

pfqn_sens_mva() [2/2]

template<class T>

SensMvaResult< T > line::pfqn::pfqn_sens_mva	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const std::vector< int > &	mi )

Exact per-station queue-length variances and covariances of a closed product-form network, by the MVA-like moment recursion of de Souza e Silva and Muntz (IEEE TC 37(9):1125-1129, 1988, Corollary 1).

Parameters

L	(M x R) service demands
N	(R) population per class, closed only
Z	(R) think times, empty for none
mi	(M) station multiplicities, empty for all ones

Definition at line 97 of file pfqn_sens_mva.h.

References line::pfqn::SensMvaResult< T >::CN, line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), line::Matrix< T >::Matrix(), line::num_abs(), pfqn_sens_mva(), line::population_count(), line::pfqn::SensMvaResult< T >::QCov, line::pfqn::SensMvaResult< T >::QCovAsym, line::pfqn::SensMvaResult< T >::QN, line::pfqn::SensMvaResult< T >::QTotVar, line::pfqn::SensMvaResult< T >::QVar, line::Matrix< T >::rows(), sens_lattice_decode(), sens_lattice_radix(), line::pfqn::SensMvaResult< T >::UN, and line::pfqn::SensMvaResult< T >::XN.

Referenced by pfqn_sens(), pfqn_sens_mva(), and pfqn_sens_mva().

pfqn_sens_mvaldmx()

template<class T>

SensMvaldmxResult< T > line::pfqn::pfqn_sens_mvaldmx	(	const std::vector< T > &	lambda,
		const Matrix< T > &	D,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const Matrix< T > &	mu )

Exact queue-length variances and covariances of a mixed open/closed product-form network with limited load dependence, the load-dependent and mixed counterpart of pfqn_sens_mva.

Parameters

lambda	(R) arrival rates, zero on the closed classes
D	(M x R) service demands
N	(R) population, negative marks an open class (MATLAB uses Inf)
Z	(R) think times
mu	(M x >= sum of the closed populations) load-dependent rates

Definition at line 86 of file pfqn_sens_mvaldmx.h.

References line::pfqn::SensMvaldmxResult< T >::CN, line::Matrix< T >::cols(), line::pfqn::SensLdmxEcResult< T >::dEC, line::pfqn::SensLdmxEcResult< T >::E, line::pfqn::SensLdmxEcResult< T >::EC, line::pfqn::SensLdmxEcResult< T >::Eprime, line::InputError::InputError(), line::Matrix< T >::Matrix(), line::num_abs(), pfqn_sens_ldmx_ec(), pfqn_sens_mvaldmx(), line::plane_sizes(), line::population_count(), line::pfqn::SensMvaldmxResult< T >::QCov, line::pfqn::SensMvaldmxResult< T >::QCovAsym, line::pfqn::SensMvaldmxResult< T >::QCovFull, line::pfqn::SensMvaldmxResult< T >::QN, line::pfqn::SensMvaldmxResult< T >::QTotVar, line::pfqn::SensMvaldmxResult< T >::QVar, line::Matrix< T >::rows(), line::pfqn::SensMvaldmxResult< T >::UN, and line::pfqn::SensMvaldmxResult< T >::XN.

Referenced by pfqn_sens_mvaldmx().

pfqn_sens_respt() [1/2]

template<class T>

SensResptResult< T > line::pfqn::pfqn_sens_respt	(	const std::vector< T > &	S,
		const Matrix< T > &	V,
		const std::vector< int > &	N,
		const std::vector< T > &	Z )

pfqn_sens_respt with single servers and moments up to order three.

Definition at line 419 of file pfqn_sens_respt.h.

References pfqn_sens_respt().

pfqn_sens_respt() [2/2]

template<class T>

SensResptResult< T > line::pfqn::pfqn_sens_respt	(	const std::vector< T > &	S,
		const Matrix< T > &	V,
		const std::vector< int > &	N,
		const std::vector< T > &	Z,
		const std::vector< int > &	b,
		int	tmax )

Exact raw moments E[W^t], t = 1..3, of the sojourn time of a job at an FCFS b-server center of a closed product-form network.

Parameters

S	(M) service time of each station, common to all classes
V	(M x R) visit ratios; the demand is L(i,r) = S(i) V(i,r)
N	(R) population per class, closed only
Z	(R) think times, empty for none
b	(M) servers per station, empty for all ones
tmax	highest sojourn-time moment, 1..3

Definition at line 88 of file pfqn_sens_respt.h.

References line::Matrix< T >::cols(), line::Matrix< T >::fill(), line::InputError::InputError(), line::pfqn::SensResptResult< T >::m, line::Matrix< T >::Matrix(), line::num_factorial(), line::num_pow_int(), line::pfqn::SensResptResult< T >::p, pfqn_sens_respt(), line::population_count(), line::pfqn::SensResptResult< T >::QN, line::Matrix< T >::rows(), sens_lattice_decode(), sens_lattice_radix(), line::pfqn::SensResptResult< T >::UN, line::pfqn::SensResptResult< T >::Var, line::pfqn::SensResptResult< T >::W, line::pfqn::SensResptResult< T >::WM, line::pfqn::SensResptResult< T >::Wresid, line::pfqn::SensResptResult< T >::WSkew, line::pfqn::SensResptResult< T >::WVar, and line::pfqn::SensResptResult< T >::XN.

Referenced by pfqn_sens_respt(), and pfqn_sens_respt().

pfqn_sib() [1/2]

template<class T>

SibBounds< T > line::pfqn::pfqn_sib	(	const std::vector< T > &	L,
		int	N,
		const T &	Z )

Definition at line 210 of file pfqn_sib.h.

References pfqn_sib().

pfqn_sib() [2/2]

template<class T>

SibBounds< T > line::pfqn::pfqn_sib	(	const std::vector< T > &	L,
		int	N,
		const T &	Z,
		int	level )

Successively Improving Bounds (Srinivasan 1985/1987) on the cycle time and throughput of a single-class closed product-form network.

Parameters

L	(M) fixed-rate demands; delay demand is NOT accepted
N	population, at least 2
Z	think time, must be zero (see the header note)
level	bound level >= 1, default 3 at the convenience overload

Definition at line 84 of file pfqn_sib.h.

References line::InputError::InputError(), line::num_pow_int(), line::NumericError::NumericError(), pfqn_sib(), line::pfqn::SibBounds< T >::Whi, line::pfqn::SibBounds< T >::Wlo, line::pfqn::SibBounds< T >::Xhi, and line::pfqn::SibBounds< T >::Xlo.

Referenced by pfqn_sib(), pfqn_sib(), and line::ba::solver_ba_analyzer().

pfqn_sqni()

template<class T>

SqniResult< T > line::pfqn::pfqn_sqni	(	const std::vector< T > &	N,
		const std::vector< T > &	L,
		const std::vector< T > &	Z )

Square-root non-iterative (SQNI) approximation for a single queueing station with per-class delay.

Parameters

N	(R) population,
L	(R) demand at the station,
Z	(R) think times

Definition at line 57 of file pfqn_sqni.h.

References line::InputError::InputError(), line::NumericError::NumericError(), pfqn_sqni(), line::pfqn::SqniResult< T >::Q, line::pfqn::SqniResult< T >::U, and line::pfqn::SqniResult< T >::X.

Referenced by pfqn_sqni(), and line::mva::solver_amva().

pfqn_ssd() [1/2]

template<class T>

SsdBounds< T > line::pfqn::pfqn_ssd	(	const std::vector< T > &	L,
		const T &	N,
		const T &	Z )

Definition at line 102 of file pfqn_ssd.h.

References pfqn_ssd().

pfqn_ssd() [2/2]

template<class T>

SsdBounds< T > line::pfqn::pfqn_ssd	(	const std::vector< T > &	L,
		const T &	N,
		const T &	Z,
		const std::vector< T > &	nservers )

Server-Station Disaggregation bounds for a multiserver closed network (Dallery and Suri, SIGMETRICS 1986).

Parameters

L	demands,
N	population,
Z	think time,
nservers	per-station server counts (empty for all ones)

Definition at line 57 of file pfqn_ssd.h.

References line::InputError::InputError(), Kt, pfqn_ssd(), line::pfqn::SsdBounds< T >::Xhi, and line::pfqn::SsdBounds< T >::Xlo.

Referenced by pfqn_ssd(), pfqn_ssd(), and line::ba::solver_ba_analyzer().

pfqn_stdf()

template<class T>

StdfResult< T > line::pfqn::pfqn_stdf	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const std::vector< int > &	S,
		const std::vector< std::size_t > &	fcfsNodes,
		const Matrix< T > &	rates,
		const std::vector< T > &	tset )

Sojourn-time distribution at the listed FCFS stations.

Parameters

L	(M x R) service demands
N	(R) closed population vector
Z	(K x R) think times, summed over rows; may be empty
S	(M) server counts
fcfsNodes	0-based indices of the FCFS stations to analyze
rates	(M x R) service rates; the rates of an analyzed FCFS station must agree across classes to within FineTol
tset	evaluation times; a zero entry is replaced by FineTol

Definition at line 322 of file pfqn_stdf.h.

References line::Matrix< T >::cols(), line::InputError::InputError(), line::pfqn::StdfResult< T >::isNumStable, kStdfFineTol, pfqn_stdf(), line::pfqn::StdfResult< T >::RD, line::Matrix< T >::rows(), and line::pfqn::StdfResult< T >::tset.

Referenced by pfqn_stdf(), and line::nc::solver_nc_cdf_respt().

pfqn_stdf_heur()

template<class T>

StdfResult< T > line::pfqn::pfqn_stdf_heur	(	const Matrix< T > &	L,
		const std::vector< int > &	N,
		const Matrix< T > &	Z,
		const std::vector< int > &	S,
		const std::vector< std::size_t > &	fcfsNodes,
		const Matrix< T > &	rates,
		const std::vector< T > &	tset )

Heuristic sojourn-time distribution at the listed FCFS stations.

Arguments as pfqn_stdf, except that rates may differ across classes at an analyzed station: that is the point of the heuristic.

Definition at line 97 of file pfqn_stdf_heur.h.

References line::Matrix< T >::cols(), line::InputError::InputError(), line::pfqn::MvaLdResult< T >::isNumStable, line::pfqn::StdfResult< T >::isNumStable, kStdfFineTol, line::pfqn::MvaLdResult< T >::lG, line::mam::map_cdf(), line::mam::map_exponential_mean(), line::mam::map_sumind(), pfqn_comomrm_ld(), pfqn_mu_ms(), pfqn_mvald(), pfqn_rd(), pfqn_stdf_heur(), line::pfqn::MvaLdResult< T >::QN, line::pfqn::StdfResult< T >::RD, line::Matrix< T >::rows(), and line::pfqn::StdfResult< T >::tset.

Referenced by pfqn_stdf_heur(), and line::nc::solver_nc_cdf_respt().

pfqn_stirling_remainder()

template<class T>

T line::pfqn::pfqn_stirling_remainder

(

const T &

n

)

s(N) = log(N!) - (N log N - N + log(2 pi N)/2), exactly, for N >= 1.

Definition at line 62 of file pfqn_bkt.h.

References pfqn_stirling_remainder().

Referenced by pfqn_bkt(), and pfqn_stirling_remainder().

pfqn_tay() [1/2]

template<class T>

AmvaResult< T > line::pfqn::pfqn_tay	(	const Matrix< T > &	L,
		const std::vector< T > &	N )

Definition at line 233 of file pfqn_tay.h.

References pfqn_tay().

pfqn_tay() [2/2]

template<class T>

AmvaResult< T > line::pfqn::pfqn_tay	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		double	tol = 1e-6,
		std::size_t	maxiter = 1000,
		const Matrix< T > &	QN0 = Matrix<T>() )

Tay's arrival-instant approximate MVA.

Parameters

L	(M x R) demands
N	(R) populations
Z	(R) think times, empty for none
tol	absolute tolerance on the queue lengths
maxiter	iteration cap
QN0	(M x R) initial queue lengths, empty for uniform

AmvaResult::RN holds the residence times. The arrival-instant queue lengths QNarr(m,k,r) that the method is tabulated on are NOT returned: the reference exposes them as a sixth output for diagnostics only, and no caller in this port reads them. They are the auxiliary quantities of the approximation, not the model re-solved at N - e_r, which is the same object only for an exact solution.

Definition at line 83 of file pfqn_tay.h.

References line::Matrix< T >::cols(), line::pfqn::AmvaResult< T >::converged, line::InputError::InputError(), line::pfqn::AmvaResult< T >::iterations, line::Matrix< T >::Matrix(), line::NumericError::NumericError(), pfqn_tay(), line::pfqn::AmvaResult< T >::QN, line::pfqn::AmvaResult< T >::RN, line::Matrix< T >::rows(), line::solve(), line::pfqn::AmvaResult< T >::UN, and line::pfqn::AmvaResult< T >::XN.

Referenced by pfqn_tay(), pfqn_tay(), and line::mva::solver_amva().

pfqn_unique() [1/2]

template<class T>

UniqueResult< T > line::pfqn::pfqn_unique

(

const Matrix< T > &

L

)

Definition at line 101 of file pfqn_unique.h.

References pfqn_unique().

pfqn_unique() [2/2]

template<class T>

UniqueResult< T > line::pfqn::pfqn_unique	(	const Matrix< T > &	L,
		const Matrix< T > &	mu,
		const Matrix< T > &	gamma )

Merge stations whose (L, mu, gamma) rows are exactly equal.

Definition at line 47 of file pfqn_unique.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::pfqn::UniqueResult< T >::gamma, line::InputError::InputError(), line::pfqn::UniqueResult< T >::L, line::pfqn::UniqueResult< T >::mapping, line::Matrix< T >::Matrix(), line::pfqn::UniqueResult< T >::mi, line::pfqn::UniqueResult< T >::mu, pfqn_unique(), and line::Matrix< T >::rows().

Referenced by pfqn_unique(), and pfqn_unique().

pfqn_usumbound()

template<class T>

T line::pfqn::pfqn_usumbound	(	long	R,
		long	K,
		long	N )

Largest value the sum of device utilizations can take in any closed product-form network with R classes, K devices and N customers (Theorem 6): sum_k U_k,R <= (H-1) + (K-H+1)(N-H+1)/(K+N-2H+1), H = min(R,K).

Demand-free and nondecreasing in R, which is what makes it invertible into a lower bound on the number of necessary classes; see pfqn_minclasses. The paper's worked case is K = 2, N = 3, R = 1, giving 2N/(N+1) = 1.5.

Definition at line 168 of file pfqn_scb.h.

References line::InputError::InputError(), and pfqn_usumbound().

Referenced by pfqn_minclasses(), and pfqn_usumbound().

pfqn_wangsevcik()

template<class T>

WsResult< T > line::pfqn::pfqn_wangsevcik	(	const Matrix< T > &	L,
		const std::vector< T > &	N,
		const std::vector< T > &	Z,
		WsScheme	scheme,
		double	tol = 1e-6,
		std::size_t	max_iter = 1000 )

One approximate MVA sweep, by the chosen arrival-queue correction.

Parameters

L	(M x R) service demands
N	(R) class populations
Z	(R) think times; empty means none
tol	convergence tolerance on the queue lengths

Definition at line 110 of file pfqn_wangsevcik.h.

References line::pfqn::WsResult< T >::C, line::Matrix< T >::cols(), line::InputError::InputError(), line::pfqn::WsResult< T >::iterations, line::Matrix< T >::Matrix(), pfqn_wangsevcik(), line::pfqn::WsResult< T >::Q, Qli, line::pfqn::WsResult< T >::R, line::Matrix< T >::rows(), line::pfqn::WsResult< T >::U, and line::pfqn::WsResult< T >::X.

Referenced by pfqn_fli(), pfqn_qli(), and pfqn_wangsevcik().

pfqn_xia()

template<class T>

T line::pfqn::pfqn_xia	(	const std::vector< T > &	L,
		int	N,
		const std::vector< T > &	s )

Xia's asymptotic approximation of the normalizing constant of a load-dependent (multiserver) closed network.

Parameters

L	(M) service demands
N	population
s	(M) server counts

Returns

log of the approximate normalizing constant

Definition at line 90 of file pfqn_xia.h.

References line::InputError::InputError(), Ls, and pfqn_xia().

Referenced by pfqn_xia().

pfqn_xzabalow()

template<class T>

T line::pfqn::pfqn_xzabalow	(	const std::vector< T > &	L,
		const T &	N,
		const T &	Z )

X >= N / (Z + N sum(L)), the ABA population bound.

Definition at line 33 of file pfqn_xzabalow.h.

References line::InputError::InputError(), and pfqn_xzabalow().

Referenced by pfqn_xzabalow().

pfqn_xzabaup()

template<class T>

T line::pfqn::pfqn_xzabaup	(	const std::vector< T > &	L,
		const T &	N,
		const T &	Z )

X <= min(1/Lmax, N/(sum(L)+Z)): capacity bound and population bound.

Definition at line 33 of file pfqn_xzabaup.h.

References line::InputError::InputError(), and pfqn_xzabaup().

Referenced by pfqn_qzgbup(), and pfqn_xzabaup().

pfqn_xzgsblow()

template<class T>

T line::pfqn::pfqn_xzgsblow	(	const std::vector< T > &	L,
		const T &	N,
		const T &	Z )

X = 2N / (R + sqrt(R^2 - 4 Z Lmax (N-1))), R from the geometric queue bound.

Definition at line 34 of file pfqn_xzgsblow.h.

References pfqn_qzgblow(), and pfqn_xzgsblow().

Referenced by pfqn_xzgsblow(), and line::ba::solver_ba_analyzer().

pfqn_xzgsbup()

template<class T>

T line::pfqn::pfqn_xzgsbup	(	const std::vector< T > &	L,
		const T &	N,
		const T &	Z )

X = 2N / (R + sqrt(R^2 - 4 Z Lmax N)), R from the geometric queue bound.

Definition at line 34 of file pfqn_xzgsbup.h.

References pfqn_qzgbup(), and pfqn_xzgsbup().

Referenced by pfqn_xzgsbup(), and line::ba::solver_ba_analyzer().

sens_lattice_decode()

std::vector< int > line::pfqn::sens_lattice_decode ( std::size_t k, const std::vector< int > & N, const std::vector< std::size_t > & radix )

inline

Decode a lattice index back into a population vector.

Definition at line 65 of file pfqn_sens_mva.h.

References sens_lattice_decode().

Referenced by pfqn_sens_dmva(), pfqn_sens_mom(), pfqn_sens_mva(), pfqn_sens_respt(), and sens_lattice_decode().

sens_lattice_radix()

std::vector< std::size_t > line::pfqn::sens_lattice_radix ( const std::vector< int > & N )

inline

Radix weights of the MVA population lattice, class R-1 varying fastest.

This is the transpose of line::plane_sizes and matches the prods vector of pfqn_mva.m, whose lattice index the sensitivity routines must reproduce entry by entry so that their base measures agree with pfqn_mva's.

Definition at line 52 of file pfqn_sens_mva.h.

References sens_lattice_radix().

Referenced by pfqn_sens_dmva(), pfqn_sens_mom(), pfqn_sens_mva(), pfqn_sens_respt(), and sens_lattice_radix().

sort_by_nnz_pos()

void line::pfqn::sort_by_nnz_pos ( std::vector< std::vector< int > > & I )

inline

MATLAB's sortbynnzpos: a stable bubble sort putting the rows with FEWER nonzeros first and, among rows with equally many, the row whose leftmost differing entry is nonzero first.

Reproduced exactly, including the O(n^2) shape, because the resulting order is the basis layout that pfqn_comom and pfqn_procomom index into.

Definition at line 95 of file pfqn_comb_common.h.

References sort_by_nnz_pos().

Referenced by sort_by_nnz_pos().

sum_rows()

template<class T>

std::vector< T > line::pfqn::sum_rows	(	const Matrix< T > &	Z,
		std::size_t	R )

Sum the rows of a think-time matrix into a length-R vector, the sum(Z,1) that every AMVA entry point performs on its Z argument.

An empty Z gives the all-zero vector.

Definition at line 92 of file pfqn_amva_common.h.

References line::Matrix< T >::cols(), line::Matrix< T >::empty(), line::InputError::InputError(), line::Matrix< T >::rows(), and sum_rows().

Referenced by pfqn_conwayms(), pfqn_egflinearizer(), pfqn_linearizerms(), pfqn_linearizermx(), and sum_rows().

Variable Documentation

cftp_inf_servers

int line::pfqn::cftp_inf_servers = -1

constexpr

Sentinel for an infinite-server (delay) station, the reference's S = Inf.

Definition at line 67 of file pfqn_cftp.h.

Referenced by pfqn_cftp(), and line::ctmc::solver_ctmc_cftp().

CUB_MAX_EVALS

double line::pfqn::CUB_MAX_EVALS = 1e7

constexpr

GlobalConstants.CubMaxEvals: the integrand-evaluation budget above which pfqn_nc lowers the cubature order (and, at order 0, prefers le over cub).

Definition at line 48 of file pfqn_cub_evals.h.

Referenced by pfqn_nc().

CUB_V_STEPS

long line::pfqn::CUB_V_STEPS = 10000

constexpr

The v-quadrature grid size of pfqn_cub; must match steps in pfqn_cub.h.

Definition at line 42 of file pfqn_cub_evals.h.

Referenced by pfqn_cub_evals().

INF_SERVERS

int line::pfqn::INF_SERVERS = -1

constexpr

Marks an infinite-server station in a server-count vector.

Definition at line 80 of file pfqn_mvams.h.

Referenced by pfqn_mvaldms(), pfqn_mvams(), and pfqn_mvams_ilock().

kOpenClass

int line::pfqn::kOpenClass = -1

constexpr

Population sentinel marking an open class, standing in for MATLAB's Inf.

Definition at line 84 of file pfqn_linearizermx.h.

Referenced by pfqn_linearizermx(), and line::mva::solver_amva().

kStdfFineTol

const double line::pfqn::kStdfFineTol = 1e-8

static

GlobalConstants.FineTol, as set by matlab/lineStart.m.

Definition at line 88 of file pfqn_stdf.h.

Referenced by pfqn_stdf(), and pfqn_stdf_heur().

MCMC_DEFAULT_BATCHES

std::size_t line::pfqn::MCMC_DEFAULT_BATCHES = 30

inlineconstexpr

Schmeiser (1982), the batch count used in the tables of the paper.

Definition at line 137 of file pfqn_mcmc.h.

MCMC_DEFAULT_BURNIN

double line::pfqn::MCMC_DEFAULT_BURNIN = 0.1

inlineconstexpr

Warm-up fraction discarded before accumulation starts.

Definition at line 139 of file pfqn_mcmc.h.

OPEN_CLASS

int line::pfqn::OPEN_CLASS = -1

constexpr

Marks an open (infinite-population) class in a population vector.

Definition at line 77 of file pfqn_mvams.h.

Referenced by line::mva::solver_mva(), line::mva::solver_mvald(), and line::nc::solver_ncld().

PFQN_BUSYP_DEFAULT_TOL

double line::pfqn::PFQN_BUSYP_DEFAULT_TOL = 1e-12

inlineconstexpr

Default relative tolerance of the open-network tail truncation.

Definition at line 55 of file pfqn_busyp.h.

Referenced by pfqn_busyp_multiclass().