The reneging route of solver_mam_retrial.m: the MAP/M/s+G queue whose waiting jobs abandon after a generally distributed patience, after O. More...

#include <cstddef>
#include <string>
#include <type_traits>
#include <vector>
#include "line/api/mam/map_cdf.h"
#include "line/api/mam/map_moment.h"
#include "line/api/mam/mfq_multiregime.h"
#include "line/lang/distribution.h"
#include "line/lang/qn/network_struct.h"
#include "line/solvers/mam/mam_types.h"
#include "line/solvers/mam/solver_mam_basic.h"
#include "line/util/error.h"
#include "line/util/expm.h"
#include "line/util/linalg.h"
#include "line/util/lu.h"
#include "line/util/matrix.h"

Include dependency graph for solver_mam_reneging.h:

Classes
struct	line::mam::MamRenegingInfo
	What mam_reneging_applicable.m returns: the station it found, or why it found none. More...
struct	line::mam::reneging_detail::RenegingMetrics
	The station metrics of the MAP/M/s+G queue. More...

Namespaces
namespace	line
	Conservation laws of a layered queueing network, enumerated from its structure.
namespace	line::mam
namespace	line::mam::reneging_detail

Functions
template<class T>
bool	line::mam::reneging_detail::declares (const qn::NetworkStruct< T > &L, std::size_t ist, std::size_t r)
	Does station ist (1-based) declare RENEGING for class r (1-based)?
template<class T>
const lang::Distrib< T > *	line::mam::reneging_detail::markovian_patience (const qn::NetworkStruct< T > &L, std::size_t ist, std::size_t r)
	The patience law at (ist, r) when it is a usable (D0, D1) pair; null otherwise.
template<class T>
Matrix< double >	line::mam::reneging_detail::to_double (const Matrix< T > &A)
	Matrix<T> to Matrix<double>.
void	line::mam::reneging_detail::add_block (Matrix< double > &A, std::size_t r0, std::size_t c0, const Matrix< double > &B, double scale)
RenegingMetrics	line::mam::reneging_detail::solve (const Matrix< double > &C, const Matrix< double > &D, double mu, int s, const Matrix< double > &P0, const Matrix< double > &P1, std::size_t Qz)
	solveReneging + convertPatienceToRegimes of solver_mam_retrial.m, as fixed in 2c0848d76f (stationary arrival rate, the regime grid, the QLen formula), in double.
template<class T>
bool	line::mam::mam_declares_reneging (const qn::NetworkStruct< T > &L)
	True when some station-class pair declares RENEGING, with or without a patience law this analyzer can read.
template<class T>
bool	line::mam::mam_has_reneging_patience (const qn::NetworkStruct< T > &L)
	mam_has_reneging_patience.m: RENEGING together with a usable patience law.
template<class T>
MamRenegingInfo	line::mam::mam_reneging_detect (const qn::NetworkStruct< T > &L)
	Port of mam_reneging_applicable.m: is this the MAP/M/s+G shape?
template<class T>
std::string	line::mam::mam_reneging_default_refusal (const qn::NetworkStruct< T > &L)
	The sentence supportsModelMethod('default') refuses a declared reneging with when the model is not the MAP/M/s+G shape, or combines it with setup/delay-off; empty otherwise.
template<class T>
mva::MvaSolution< T >	line::mam::solver_mam_reneging (const qn::NetworkStruct< T > &L, const MamOptions &opt, const MamRenegingInfo &info)
	The reneging route of solver_mam_retrial.m.

Detailed Description

The reneging route of solver_mam_retrial.m: the MAP/M/s+G queue whose waiting jobs abandon after a generally distributed patience, after O.

Gursoy, K. A. Mehr and N. Akar, "The MAP/M/s + G Call Center Model with Generally Distributed Patience Times". Gate: mam_reneging_applicable.m.

THE FLUID IS THE VIRTUAL WAITING TIME. The background chain is (busy servers, MAP phase), s+1 blocks of MAP phases; the last block has drift +1 and stands for the work an admitted arrival adds, every other block drift -1. The patience CDF is quantized into MamOptions::mapmsg_quantization regimes over [0, T], T the first mean * 1.25^k at which the CDF reaches 1 - 1e-4. An arrival that finds the virtual wait in regime k abandons with the patience CDF at the regime's representative wait (the midpoint, and T for the tail [T, inf)), which is the abandonment of a FCFS queue because the virtual wait IS the wait that arrival would see.

MATLAB solves the fluid queue with the MAPMsG library's MRMFQSolver; this port, like the JAR's, solves the same queue with mfq_multiregime (Kankaya and Akar, the method MRMFQSolver implements) and reads the per-regime state masses off its distribution function: the mass on regime d is P(X < B_d) - P(X <= B_{d-1}) and the atom at zero is P(X <= 0). On M/M/3+M, MAP/M/3+M and M/M/4+Erlang-2 this construction and the native-python MRMFQ port coincide to 1e-14.

THE PATIENCE MUST BE MARKOVIAN, and that is refused by name rather than fitted. The regime grid, the horizon and E[min(v, P)] are all read off a (D0, D1) pair. A Det, Gamma, Lognormal, Pareto, Uniform or Weibull patience carries none in the C++ model layer, and the JAR's refreshImpatience stores none either. MATLAB stores getProcess() for these laws, which is the raw parameter list and not a generator, and the reneging route then fails inside schur on NaN, so there is no reference behaviour to reproduce.

DOUBLE ONLY. mfq_multiregime is double only (an ordered real Schur form, LAPACK), so an exact or multiprecision instantiation refuses by name instead of carrying a double-accurate answer under a wider type.

Definition in file solver_mam_reneging.h.

Classes

Namespaces

Functions

Detailed Description