Namespaces
namespace	gate_detail
namespace	smp_detail
namespace	ssg_detail

Classes
struct	BicgstabMultiResult
struct	BicgstabResult
struct	BlkDecompResult
struct	CourtoisResult
struct	CtmcCalibration
	The per-host power-law fit, the reference's calib struct. More...
struct	CtmcGateResult
	The gate verdict, plus the message the caller reports either way. More...
struct	CtmcPath
	One simulated sample path: the state visited at each step and its holding time. More...
struct	CtmcSizeOptions
	Options the estimator reads; only the cutoff matters. More...
struct	CtmcSsgOptions
	The reference's options read here: options.cutoff and the state cap. More...
struct	CtmcSsgResult
	The reference's [stateSpace, stateSpaceAggr, stateSpaceHashed, nodeStateSpace]. More...
struct	FauResult
struct	FoxGlynnResult
struct	GmresMultiResult
struct	GmresResult
struct	KmsResult
class	LcgUniform
	Deterministic uniform [0,1) source, so that a caller who does not have one still has no reason to reach for a global stream. More...
struct	MultiResult
struct	PassageCurve
	A passage-time law on a grid. More...
struct	PassageMoments
	Moments of a first passage time, [Mall, m] of the reference. More...
struct	PassagePh
	The phase-type form of a first passage time. More...
struct	PassageTaboo
	First passage into a target set B under a TABOO set C, [F, f, out] of ctmc_passage_taboo.m: the passage completes by entering B and is lost for good by entering C first. More...
struct	PassageTabooMoments
	Conditional moments under a taboo set, [mall, m, pB] of ctmc_passage_taboo_moments.m. More...
struct	PerronState
	Perron root of A(theta) with its first two derivatives and the amplitude. More...
struct	PseudoStochCompResult
	Blocks of the partition together with the pseudo complement over I. More...
struct	RandomizationResult
struct	ReducibleResult
struct	SaddlepointResult
	One entry per (t,k) pair. More...
struct	SccResult
struct	SmpStageCif
	What smp_stage_cif returns: C(h, j) = CIF_h(t_j) and Fhold[j]. More...
struct	SmpStageQuad
	What smp_stage_quad returns. More...
struct	StochCompResult
struct	TakahashiResult
struct	TimeAverageResult
struct	TransientResult
struct	TransientSensResult
struct	UniformizationResult
struct	WeakCompResult
	Number of weakly connected components and the per-node label (weaklyconncomp.m). More...

Enumerations
enum	SaddlepointMethod { SADDLEPOINT_DANIELS2 = 0 , SADDLEPOINT_DANIELS = 1 , SADDLEPOINT_PLAIN = 2 }
	Which term of the steepest-descent expansion to stop at. More...

Functions
template<class T>
BicgstabResult< T >	ctmc_bicgstab (const Matrix< T > &A, const std::vector< T > &b, double tol=1e-12, long maxit=0, const std::vector< T > &x0=std::vector< T >())
	Preconditioned stabilized biconjugate gradients, for the linear systems a generator produces.
template<class T>
BicgstabMultiResult< T >	ctmc_bicgstab_multi (const Matrix< T > &A, const Matrix< T > &B, double tol=1e-12, long maxit=0)
	Every column of B solved against the SAME equilibration, reordering and ILUT factorization, each column starting from the previous column's solution.
template<class T>
CourtoisResult< T >	ctmc_courtois (const Matrix< T > &Q, const std::vector< std::vector< std::size_t > > &MS, const T &q)
	Courtois decomposition of a nearly completely decomposable (NCD) CTMC.
template<class T>
CourtoisResult< T >	ctmc_courtois (const Matrix< T > &Q, const std::vector< std::vector< std::size_t > > &MS)
	Overload deriving the rate as MATLAB does, q = (21/20) max\|Qperm\|.
template<class T>
FauResult< T >	ctmc_fau (const std::vector< T > &pi0, const Matrix< T > &Q, const T &t, double epsilon=1e-6, double delta=1e-12, long maxsteps=-1)
	Transient distribution of a CTMC by fast adaptive uniformization.
template<class T>
FoxGlynnResult< T >	ctmc_foxglynn (const std::vector< T > &pi0, const Matrix< T > &Q, const T &t, double tol=1e-12, long maxiter=-1)
	Transient distribution of a CTMC by uniformization with Fox-Glynn Poisson weights.
template<class T>
GmresResult< T >	ctmc_gmres (const Matrix< T > &A, const std::vector< T > &b, double tol=1e-12, long restart=0, long maxit=0, const std::vector< T > &x0=std::vector< T >())
	Restarted GMRES with an ILUT preconditioner, for the linear systems a generator produces.
template<class T>
GmresMultiResult< T >	ctmc_gmres_multi (const Matrix< T > &A, const Matrix< T > &B, double tol=1e-12, long restart=0, long maxit=0)
	Restarted GMRES for a block of right-hand sides sharing one coefficient matrix.
template<class T>
bool	ctmc_isfeasible (const Matrix< T > &Q, const T &tol)
	True when Q is square, has nonnegative off-diagonals, nonpositive diagonal and zero row sums.
template<class T>
bool	ctmc_isfeasible (const Matrix< T > &Q)
	Default tolerance 1e-10, matching the MATLAB signature.
template<class T>
int	dtmc_isfeasible (const Matrix< T > &P)
	Largest precision level 1..15 at which P is stochastic, or 0 when none holds.
template<class T>
KmsResult< T >	ctmc_kms (const Matrix< T > &Q, const std::vector< std::vector< std::size_t > > &MS, std::size_t numSteps)
	Koury-McAllister-Stewart aggregation-disaggregation for a nearly completely decomposable CTMC.
double	ctmc_available_memory_bytes ()
	Available physical memory in bytes.
const CtmcCalibration &	ctmc_get_calibration (bool verbose=false)
	The reference's ctmc_get_calibration: the cached per-host fit, profiled once when the cache is missing or belongs to another machine, and the fallback coefficients when the profile fails.
CtmcGateResult	ctmc_memory_gate (double log_nstates, bool force=false, double safety_fraction=CTMC_DEFAULT_SAFETY_FRACTION, bool verbose=false)
	Decide whether a state space of log-size log_nstates can be solved here.
template<class T>
MultiResult< T >	ctmc_multi (const Matrix< T > &Q, const std::vector< std::vector< std::size_t > > &MS, const std::vector< std::vector< std::size_t > > &MSS, const T &q)
	Two-level multigrid aggregation-disaggregation for a nearly completely decomposable CTMC.
template<class T>
MultiResult< T >	ctmc_multi (const Matrix< T > &Q, const std::vector< std::vector< std::size_t > > &MS, const std::vector< std::vector< std::size_t > > &MSS)
	Overload deriving the rate as MATLAB does, q = (21/20) max\|Qperm\|.
template<class T>
PassagePh< T >	ctmc_passage_ph (const Matrix< T > &Q, const std::vector< T > &pi0, const std::vector< std::size_t > &target)
	Phase-type representation of the first passage time from pi0 into target.
template<class T>
std::vector< std::complex< double > >	ctmc_passage_lst (const Matrix< T > &Q, const std::vector< T > &pi0, const std::vector< std::size_t > &target, const std::vector< std::complex< double > > &s)
	L(s) = alpha (sI-S)^{-1} s0 + atom at the (complex) points s.
template<class T>
PassageMoments< T >	ctmc_passage_moments (const Matrix< T > &Q, const std::vector< T > &pi0, const std::vector< std::size_t > &target, std::size_t nmax=1)
	Moments of order 1..nmax of the first passage time into target.
template<class T>
std::vector< T >	ctmc_hitting_time (const Matrix< T > &Q, const std::vector< std::size_t > &target)
	Mean time to reach any state in target from each state of a CTMC.
template<class T>
PassageCurve< T >	ctmc_passage_time (const Matrix< T > &Q, const std::vector< T > &pi0, const std::vector< std::size_t > &target, const std::vector< double > &tset, const std::string &method="expm", const std::string &lti_method="euler")
	CDF and density of the first passage time on the grid tset: F(t) = 1 - alpha exp(St) 1 and f(t) = alpha exp(St) s0.
template<class T>
PassageTaboo< T >	ctmc_passage_taboo (const Matrix< T > &Q, const std::vector< T > &pi0, const std::vector< std::size_t > &target, const std::vector< std::size_t > &taboo, const std::vector< double > &tset=std::vector< double >(), const std::string &method="expm", const std::string &lti_method="euler")
	First passage into target under the taboo set taboo, the reference's ctmc_passage_taboo.
template<class T>
PassageTabooMoments< T >	ctmc_passage_taboo_moments (const Matrix< T > &Q, const std::vector< T > &pi0, const std::vector< std::size_t > &target, const std::vector< std::size_t > &taboo, std::size_t nmax=1)
	Moments of order 1..nmax of the first passage time into target, CONDITIONAL on entering it before taboo, the reference's ctmc_passage_taboo_moments:
template<class T>
PassageMoments< T >	smp_passage_moments (const Matrix< T > &P, const Matrix< T > &hmom, const std::vector< T > &pi0, const std::vector< std::size_t > &target, std::size_t nmax=1)
	Moments of the semi-Markov first passage time from the per-state holding moments m_i(r), Eq.
template<class T>
PassageMoments< T >	smp_passage_moments (const Matrix< T > &P, const std::vector< std::vector< std::vector< T > > > &hmom, const std::vector< T > &pi0, const std::vector< std::size_t > &target, std::size_t nmax=1)
	Moments of the semi-Markov first passage time from the PER-PAIR kernel moments, Eq.
template<class T>
std::vector< std::complex< double > >	smp_passage_lst (const Matrix< T > &P, const std::vector< std::function< std::complex< double >(std::complex< double >)> > &hlst, const std::vector< T > &pi0, const std::vector< std::size_t > &target, const std::vector< std::complex< double > > &s)
	L(s) of the semi-Markov first passage time, Eqs.
template<class T>
std::vector< std::complex< double > >	smp_passage_lst (const Matrix< T > &P, const std::vector< std::vector< std::function< std::complex< double >(std::complex< double >)> > > &hlst, const std::vector< T > &pi0, const std::vector< std::size_t > &target, const std::vector< std::complex< double > > &s)
	L(s) of the semi-Markov first passage time from the (n x n) KERNEL of transforms, the reference's non-perState branch of Eq.
template<class T>
PassageCurve< T >	smp_passage_time (const Matrix< T > &P, const std::vector< std::function< std::complex< double >(std::complex< double >)> > &hlst, const std::vector< T > &pi0, const std::vector< std::size_t > &target, const std::vector< double > &tset, const std::string &lti_method="euler")
	CDF and density of the semi-Markov first passage time, by inverting smp_passage_lst through api/lti.
template<class T>
PseudoStochCompResult< T >	ctmc_pseudostochcomp (const Matrix< T > &Q, const std::vector< std::size_t > &keep)
	Pseudo stochastic complement of a CTMC partition.
template<class T>
PseudoStochCompResult< T >	ctmc_pseudostochcomp (const Matrix< T > &Q)
	Default partition: the first ceil(n/2) states.
template<class T, class Gen>
Matrix< T >	ctmc_rand (std::size_t n, Gen &gen)
	Random infinitesimal generator of a CTMC.
template<class T>
T	ctmc_maxabs (const Matrix< T > &Q)
	Largest magnitude of any entry of Q; equals max_i \|q_ii\| for a generator.
template<class T>
RandomizationResult< T >	ctmc_randomization (const Matrix< T > &Q, const T &q)
	Uniformization (randomization) of a CTMC: the embedded DTMC P = I + Q/q.
template<class T>
RandomizationResult< T >	ctmc_randomization (const Matrix< T > &Q)
	Deterministic default rate (21/20) max\|Q\|; see the defect note above.
template<class T>
std::vector< T >	ctmc_relsolve (const Matrix< T > &Qin, std::size_t refstate)
	Stationary measure scaled so that entry refstate equals one.
template<class T>
std::vector< T >	ctmc_relsolve (const Matrix< T > &Q)
	Reference state 1 in the MATLAB numbering, i.e.
template<class T>
PerronState< T >	ctmc_saddlepoint_perron (const Matrix< T > &D0, const Matrix< T > &D1, const std::vector< T > &pi0, const T &th)
	Perron root of A(th) = D0 + exp(th)*D1 with deta, d2eta and the amplitude.
template<class T>
SaddlepointResult< T >	ctmc_saddlepoint (const Matrix< T > &D0, const Matrix< T > &D1, const std::vector< T > &t, const std::vector< long > &k, SaddlepointMethod method=SADDLEPOINT_DANIELS2, const std::vector< T > &pi0=std::vector< T >())
	Pr{N(t)=k} over arrays of horizons and counts.
template<class T>
T	ctmc_saddlepoint (const Matrix< T > &D0, const Matrix< T > &D1, const T &t, long k, SaddlepointMethod method=SADDLEPOINT_DANIELS2)
	Pr{N(t)=k} at a single (t,k), with the default method.
template<class T>
std::vector< T >	ctmc_sens (const Matrix< T > &Q, const Matrix< T > &dQ, const std::vector< T > &pi)
	Sensitivity of the steady-state distribution of a CTMC to a scalar parameter.
template<class T>
std::vector< T >	ctmc_sens (const Matrix< T > &Q, const Matrix< T > &dQ)
	Overload computing the steady-state vector itself, as MATLAB does.
template<class T>
std::vector< T >	ctmc_simulate_reference_initial_law (const std::vector< T > &pi0)
	The initial-state law that ctmc_simulate.m actually realizes for a given pi0, as opposed to pi0 itself.
template<class T>
CtmcPath< T >	ctmc_simulate (const Matrix< T > &Q, const std::vector< T > &pi0, std::size_t n, pfqn::McRng &rng)
	Simulate n steps of the CTMC with generator Q.
template<class T>
Matrix< T >	ctmc_makeinfgen (const Matrix< T > &Q)
	Set the diagonal so that every row sums to zero (ctmc_makeinfgen).
template<class T>
std::vector< T >	ctmc_solve (const Matrix< T > &Qin)
	Steady-state distribution of a continuous-time Markov chain.
template<class T>
ReducibleResult< T >	ctmc_solve_reducible (const Matrix< T > &Q, const std::vector< T > &pi0, double zeroColTol=1e-12)
	Limiting distribution of a CTMC whose generator may be reducible.
template<class T>
ReducibleResult< T >	ctmc_solve_reducible (const Matrix< T > &Q, double zeroColTol=1e-12)
	Overload without an initial vector.
template<class T>
BlkDecompResult< T >	ctmc_solve_reducible_blkdecomp (const Matrix< T > &Qin, const std::vector< T > &pin, double reachTol=1e-15, double zeroColTol=1e-12)
	Limiting distribution of a reducible CTMC by direct block decomposition of the generator.
template<class T>
BlkDecompResult< T >	ctmc_solve_reducible_blkdecomp (const Matrix< T > &Q, double reachTol=1e-15, double zeroColTol=1e-12)
	Overload without an initial vector.
template<class T>
CtmcSsgResult< T >	ctmc_ssg (const qn::NetworkStruct< T > &sn, const CtmcSsgOptions &options=CtmcSsgOptions(), const std::vector< qn::FjSync< T > > &fjsync=std::vector< qn::FjSync< T > >())
	Port of ctmc_ssg: the FULL state space of the network.
template<class T>
CtmcSsgResult< T >	ctmc_ssg_reachability (const qn::NetworkStruct< T > &sn, const CtmcSsgOptions &options=CtmcSsgOptions(), const std::vector< qn::FjSync< T > > &fjsync=std::vector< qn::FjSync< T > >())
	Port of ctmc_ssg_reachability: the REACHABLE state space, walked from the model's initial state over the synchronizations refresh_sync and refresh_global_sync build.
double	log_ordered_joint (const std::vector< std::vector< int > > &caps_per, const std::vector< double > &cap_tot, const std::vector< int > &nj_u, const std::vector< std::size_t > &b_unit_of, const std::vector< double > &m_rem_u, const std::vector< std::vector< double > > &log_ph_per={}, const std::vector< std::vector< int > > &lev_per={})
	Log count of (placement, ordering) configurations over ALL order-preserving stations at once, POPULATION CONSERVED.
template<class T>
double	ctmc_state_space_logsize (const qn::NetworkStruct< T > &sn, const CtmcSizeOptions &opt=CtmcSizeOptions())
	Worst-case log state-space size of sn.
template<class T>
Matrix< T >	dtmc_stmonotone (const Matrix< T > &P)
template<class T>
Matrix< T >	ctmc_stmonotone (const Matrix< T > &Q)
	Stochastically monotone upper bound of a Markov chain.
template<class T>
TakahashiResult< T >	ctmc_takahashi (const Matrix< T > &Q, const std::vector< std::vector< std::size_t > > &MS, std::size_t numSteps, double massTol=1e-14)
	Takahashi's aggregation-disaggregation for a nearly completely decomposable CTMC.
template<class T>
bool	ctmc_testpf_kolmogorov (const Matrix< T > &Qin)
	Kolmogorov reversibility criterion, used as a product-form test.
template<class T>
Matrix< T >	ctmc_timereverse (const Matrix< T > &Q)
	Generator of the time-reversed CTMC.
template<class T>
Matrix< T >	dtmc_timereverse (const Matrix< T > &P)
	Transition matrix of the time-reversed DTMC.
template<class T>
TransientResult< T >	ctmc_transient (const Matrix< T > &Q, const std::vector< T > &pi0, const T &t0, const T &t1, double rtol=1e-3, double atol=1e-6, bool stiff=false)
	Transient distribution of a CTMC over a time interval, by integrating the forward equations d pi/dt = pi Q.
template<class T>
TransientResult< T >	ctmc_transient (const Matrix< T > &Q, const T &t0, const T &t1, double rtol=1e-3, double atol=1e-6)
	Overload starting from the uniform distribution, as MATLAB's short forms do.
template<class T>
TransientResult< T >	ctmc_transient_on_grid (const Matrix< T > &Q, const TransientResult< T > &r, const std::vector< T > &grid)
	Resample an adaptive transient onto the uniform grid t0 : dt : t1.
template<class T>
TransientResult< T >	ctmc_transient_on_grid (const Matrix< T > &Q, const TransientResult< T > &r, const T &t0, const T &t1, const T &dt)
template<class T>
TransientSensResult< T >	ctmc_transient_sens (const Matrix< T > &Q, const Matrix< T > &dQ, const std::vector< T > &pi0, const T &t0, const T &t1, double rtol=1e-3, double atol=1e-6)
	Sensitivity of the transient distribution of a CTMC to a scalar parameter.
template<class T>
TransientSensResult< T >	ctmc_transient_sens (const Matrix< T > &Q, const Matrix< T > &dQ, const T &t0, const T &t1, double rtol=1e-3, double atol=1e-6)
	Overload starting from the uniform distribution, as MATLAB's short forms do.
template<class T>
UniformizationResult< T >	ctmc_uniformization (const std::vector< T > &pi0, const Matrix< T > &Q, const T &t, double tol=1e-12, long maxiter=-1)
	Transient distribution of a CTMC by uniformization (Jensen's method), and the time-averaged distribution over [0, t].
template<class T>
TimeAverageResult< T >	ctmc_timeaverage (const std::vector< T > &pi0, const Matrix< T > &Q, const T &t, double tol=1e-12, long maxiter=-1)
	Time-averaged distribution (1/t) int_0^t pi(u) du, plus pi(t) itself.
template<class T>
Matrix< T >	dtmc_makestochastic (const Matrix< T > &Pin)
	Normalize a non-negative matrix into a stochastic transition matrix.
template<class T, class Gen>
Matrix< T >	dtmc_rand (std::size_t n, Gen &gen)
	Random stochastic matrix, the uniformization of a random generator.
template<class T, class Gen>
std::vector< std::size_t >	dtmc_simulate (const Matrix< T > &P, const std::vector< T > &pi0, std::size_t n, Gen &gen)
	Sample path of a DTMC, n states starting from pi0.
template<class T>
WeakCompResult< T >	weaklyconncomp (const Matrix< T > &G)
	Weakly connected components of the graph whose adjacency is the support of G.
template<class T>
std::vector< T >	dtmc_solve (const Matrix< T > &P)
	Stationary distribution of a stochastic matrix P.
template<class T>
StochCompResult< T >	ctmc_stochcomp (const Matrix< T > &Q, const std::vector< std::size_t > &I)
template<class T>
StochCompResult< T >	ctmc_stochcomp (const Matrix< T > &Q)
	Default subset: the first ceil(n/2) states, as in MATLAB.
template<class T>
ReducibleResult< T >	dtmc_solve_reducible (const Matrix< T > &P, const std::vector< T > &pin, double zeroColTol=1e-12)
	Limiting distribution of a discrete-time Markov chain whose transition matrix may be reducible.
template<class T>
ReducibleResult< T >	dtmc_solve_reducible (const Matrix< T > &P, double zeroColTol=1e-12)
	Overload without an initial vector.
template<class T>
Matrix< T >	dtmc_stochcomp (const Matrix< T > &P, const std::vector< std::size_t > &keep)
	Stochastic complement of a DTMC partition, a port of matlab/lib/kpctoolbox/mc/dtmc_stochcomp.m.
template<class T>
Matrix< T >	dtmc_transient (const Matrix< T > &P, const std::vector< T > &pi0, std::size_t steps)
	Trajectory of the law over steps transitions, row k holding pi0 P^k.
template<class T>
Matrix< T >	dtmc_transient (const Matrix< T > &P)
	Uniform initial law and one step, matching the one-argument MATLAB call.
template<class T>
std::vector< T >	dtmc_hitting_time (const Matrix< T > &P, const std::vector< std::size_t > &target)
	Expected number of steps to reach the target set, zero on the target set itself.
template<class T>
UniformizationResult< T >	dtmc_uniformization (const std::vector< T > &pi0, const Matrix< T > &P, const T &t, double tol=1e-12, long maxiter=-1)
	Transient law of a DTMC through the uniformized generator of P.
template<class T>
SmpStageCif	smp_stage_cif (const std::vector< lang::Distrib< T > > &arcs, const std::vector< double > &probs, const std::vector< double > &t)
	CIF and holding-time CDF of a stage at the ascending instants t.
template<class T>
SmpStageQuad	smp_stage_quad (const std::vector< lang::Distrib< T > > &arcs, const std::vector< double > &probs)
template<class T>
SccResult	stronglyconncomp (const Matrix< T > &A)
	Strongly connected components of a directed graph, and which of them are recurrent (closed under the successor relation).
template<class T>
T	tx_exp (const T &x)
	exp/log/isfinite through ADL, the idiom the rest of api/mc uses: using std::exp then an unqualified call, so a Real<D> or Rational picks up its own overload.
template<class T>
T	tx_log (const T &x)
template<class T>
bool	tx_finite (const T &x)

Variables
constexpr long	FAU_MAX_STEPS = 1000000
	Default cap on birth steps, so a pathological horizon reports truncation.
constexpr std::size_t	GMRES_MIN_STATES = 6000
	Order above which the direct sparse factorization is abandoned in favour of the Krylov path.
constexpr double	CTMC_BYTES_PER_NZ = 16.0
	8 bytes of value plus 8 amortized for the index, per stored nonzero.
constexpr double	CTMC_DEFAULT_SAFETY_FRACTION = 0.6
	Fraction of available memory the solver may target.
constexpr double	CTMC_FALLBACK_ALPHA = CTMC_BYTES_PER_NZ * 8.0
	Fallback power-law coefficients, identical to MATLAB and Python.
constexpr double	CTMC_FALLBACK_BETA = 1.3
constexpr double	CTMC_FALLBACK_AVAIL_BYTES = 1.0 * 1024.0 * 1024.0 * 1024.0
	Conservative available-memory default when the host probe fails.
constexpr int	CTMC_CALIB_G1 = 40
	The two lattice sides the reference profiles (G1, G2 of ctmc_get_calibration).
constexpr int	CTMC_CALIB_G2 = 80
static const double	CTMC_SADDLEPOINT_K2_MIN = 5.0
	Below this value of K2 = teta''(theta) the expansion is out of its regime.
constexpr double	kOrderGridMax = 1.0e6
	Largest (m_1..m_K) box the exact ordered-buffer DP will walk.

Enumeration Type Documentation

◆ SaddlepointMethod

enum line::mc::SaddlepointMethod

Which term of the steepest-descent expansion to stop at.

Enumerator
SADDLEPOINT_DANIELS2	second order, error O(1/K2^2) – the DEFAULT
SADDLEPOINT_DANIELS	first order with the Perron amplitude, O(1/K2)
SADDLEPOINT_PLAIN	bare first order, amplitude set to 1

Definition at line 98 of file ctmc_saddlepoint.h.

Function Documentation

◆ ctmc_available_memory_bytes()

double line::mc::ctmc_available_memory_bytes ( )

inline

Available physical memory in bytes.

Never throws: a probe failure returns the conservative fallback, because a gate that cannot measure the host must not thereby become permissive.

Definition at line 102 of file ctmc_memory_gate.h.

References ctmc_available_memory_bytes(), and CTMC_FALLBACK_AVAIL_BYTES.

Referenced by ctmc_available_memory_bytes(), and ctmc_memory_gate().

◆ ctmc_bicgstab()

template<class T>

BicgstabResult< T > line::mc::ctmc_bicgstab	(	const Matrix< T > &	A,
		const std::vector< T > &	b,
		double	tol = 1e-12,
		long	maxit = 0,
		const std::vector< T > &	x0 = std::vector<T>() )

Preconditioned stabilized biconjugate gradients, for the linear systems a generator produces.

Parameters

A	coefficient matrix, already assembled
b	right-hand side
tol	relative residual tolerance (default 1e-12)
maxit	complete iterations; <= 0 selects min(n, 200)
x0	initial guess; empty selects the uniform vector ones(n)/n

Definition at line 234 of file ctmc_bicgstab.h.

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

Referenced by ctmc_bicgstab(), ctmc_solve(), ctmc_solve_reducible_blkdecomp(), and ctmc_takahashi().

◆ ctmc_bicgstab_multi()

template<class T>

BicgstabMultiResult< T > line::mc::ctmc_bicgstab_multi	(	const Matrix< T > &	A,
		const Matrix< T > &	B,
		double	tol = 1e-12,
		long	maxit = 0 )

Every column of B solved against the SAME equilibration, reordering and ILUT factorization, each column starting from the previous column's solution.

FLAG is zero only when every column converged; on any other value the result matrix is empty and the caller must fall back, a partially converged block leaving the fallback ambiguous.

Parameters

A	coefficient matrix
B	right-hand sides, one per column
tol	relative residual tolerance (default 1e-12)
maxit	complete iterations per column; <= 0 selects min(n, 200)

Definition at line 264 of file ctmc_bicgstab.h.

References line::Matrix< T >::cols(), ctmc_bicgstab_multi(), line::mc::BicgstabMultiResult< T >::flag, line::mc::BicgstabResult< T >::flag, line::InputError::InputError(), line::Matrix< T >::Matrix(), line::Matrix< T >::rows(), line::mc::BicgstabMultiResult< T >::X, and line::mc::BicgstabResult< T >::x.

Referenced by ctmc_bicgstab_multi().

◆ ctmc_courtois() [1/2]

template<class T>

CourtoisResult< T > line::mc::ctmc_courtois	(	const Matrix< T > &	Q,
		const std::vector< std::vector< std::size_t > > &	MS )

Overload deriving the rate as MATLAB does, q = (21/20) max|Qperm|.

Definition at line 516 of file ctmc_courtois.h.

References ctmc_courtois().

◆ ctmc_courtois() [2/2]

template<class T>

CourtoisResult< T > line::mc::ctmc_courtois	(	const Matrix< T > &	Q,
		const std::vector< std::vector< std::size_t > > &	MS,
		const T &	q )

Courtois decomposition of a nearly completely decomposable (NCD) CTMC.

Parameters

Q	generator
MS	macro-states, MS[i] listing the states of macro-state i; the sets must partition 0..n-1
q	uniformization rate

Definition at line 482 of file ctmc_courtois.h.

Referenced by line::lang::processes::aggregate(), ctmc_courtois(), ctmc_courtois(), ctmc_multi(), and line::env::env_ctmc_decompose().

◆ ctmc_fau()

template<class T>

FauResult< T > line::mc::ctmc_fau	(	const std::vector< T > &	pi0,
		const Matrix< T > &	Q,
		const T &	t,
		double	epsilon = 1e-6,
		double	delta = 1e-12,
		long	maxsteps = -1 )

Transient distribution of a CTMC by fast adaptive uniformization.

Parameters

pi0	initial distribution (row vector)
Q	generator
t	time horizon, t >= 0
epsilon	birth-process truncation tolerance (MATLAB default 1e-6)
delta	occupancy threshold below which a state is dropped (default 1e-12)
maxsteps	cap on birth steps; <= 0 for the default cap

Definition at line 256 of file ctmc_fau.h.

Referenced by ctmc_fau().

◆ ctmc_foxglynn()

template<class T>

FoxGlynnResult< T > line::mc::ctmc_foxglynn	(	const std::vector< T > &	pi0,
		const Matrix< T > &	Q,
		const T &	t,
		double	tol = 1e-12,
		long	maxiter = -1 )

Transient distribution of a CTMC by uniformization with Fox-Glynn Poisson weights.

Parameters

pi0	initial distribution (row vector)
Q	generator
t	time horizon
tol	total Poisson tail mass discarded (MATLAB default 1e-12)
maxiter	cap on the right truncation point; <= 0 leaves it uncapped

Definition at line 172 of file ctmc_foxglynn.h.

References line::Matrix< T >::cols(), ctmc_foxglynn(), line::InputError::InputError(), line::mc::FoxGlynnResult< T >::left, line::num_abs(), line::mc::FoxGlynnResult< T >::pi, line::mc::FoxGlynnResult< T >::right, line::Matrix< T >::rows(), and line::mc::FoxGlynnResult< T >::w.

Referenced by line::lang::processes::chain_transient_at(), and ctmc_foxglynn().

◆ ctmc_get_calibration()

const CtmcCalibration & line::mc::ctmc_get_calibration ( bool verbose = false )

inline

The reference's ctmc_get_calibration: the cached per-host fit, profiled once when the cache is missing or belongs to another machine, and the fallback coefficients when the profile fails.

Definition at line 224 of file ctmc_memory_gate.h.

References line::mc::CtmcCalibration::alpha_mem, line::mc::CtmcCalibration::alpha_t, line::mc::CtmcCalibration::beta_mem, line::mc::CtmcCalibration::beta_t, line::mc::gate_detail::cache_file(), CTMC_BYTES_PER_NZ, CTMC_CALIB_G1, CTMC_CALIB_G2, CTMC_FALLBACK_ALPHA, CTMC_FALLBACK_BETA, ctmc_get_calibration(), line::mc::gate_detail::fit_power_law(), line::mc::gate_detail::machine_signature(), line::mc::gate_detail::now_posix(), line::NumericError::NumericError(), line::mc::gate_detail::profile_point(), line::mc::CtmcCalibration::sig, and line::mc::CtmcCalibration::timestamp.

Referenced by ctmc_get_calibration(), and ctmc_memory_gate().

◆ ctmc_gmres()

template<class T>

GmresResult< T > line::mc::ctmc_gmres	(	const Matrix< T > &	A,
		const std::vector< T > &	b,
		double	tol = 1e-12,
		long	restart = 0,
		long	maxit = 0,
		const std::vector< T > &	x0 = std::vector<T>() )

Restarted GMRES with an ILUT preconditioner, for the linear systems a generator produces.

Parameters

A	coefficient matrix, already assembled
b	right-hand side
tol	relative residual tolerance (default 1e-12)
restart	restart length; <= 0 selects min(n, 50)
maxit	outer cycles; <= 0 selects ceil(n / restart)
x0	initial guess; empty selects the uniform vector ones(n)/n

Definition at line 653 of file ctmc_gmres.h.

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

Referenced by ctmc_gmres(), ctmc_solve(), ctmc_solve_reducible_blkdecomp(), and ctmc_takahashi().

◆ ctmc_gmres_multi()

template<class T>

GmresMultiResult< T > line::mc::ctmc_gmres_multi	(	const Matrix< T > &	A,
		const Matrix< T > &	B,
		double	tol = 1e-12,
		long	restart = 0,
		long	maxit = 0 )

Restarted GMRES for a block of right-hand sides sharing one coefficient matrix.

Parameters

A	coefficient matrix
B	right-hand sides, one per column
tol	relative residual tolerance (default 1e-12)
restart	restart length; <= 0 selects min(n, 50)
maxit	outer cycles; <= 0 selects ceil(n / restart)

Definition at line 59 of file ctmc_gmres_multi.h.

References line::Matrix< T >::cols(), ctmc_gmres_multi(), line::mc::GmresMultiResult< T >::flag, line::mc::GmresResult< T >::flag, line::InputError::InputError(), line::Matrix< T >::Matrix(), line::Matrix< T >::rows(), line::mc::GmresMultiResult< T >::X, and line::mc::GmresResult< T >::x.

Referenced by ctmc_gmres_multi().

◆ ctmc_hitting_time()

template<class T>

std::vector< T > line::mc::ctmc_hitting_time	(	const Matrix< T > &	Q,
		const std::vector< std::size_t > &	target )

Mean time to reach any state in target from each state of a CTMC.

Continuous-time twin of dtmc_hitting_time and the first-moment special case of ctmc_passage_moments: (-S) h = 1 on the non-target block, where dtmc_hitting_time solves (I - P_NT) h = 1. Unreachable states give infinity.

Definition at line 390 of file ctmc_passage.h.

References ctmc_hitting_time(), ctmc_passage_moments(), line::mc::PassageMoments< T >::mall, and line::Matrix< T >::rows().

Referenced by ctmc_hitting_time(), and line::lang::processes::hitting_time().

◆ ctmc_isfeasible() [1/2]

template<class T>

bool line::mc::ctmc_isfeasible ( const Matrix< T > & Q )

Default tolerance 1e-10, matching the MATLAB signature.

Definition at line 52 of file ctmc_isfeasible.h.

References ctmc_isfeasible().

◆ ctmc_isfeasible() [2/2]

template<class T>

bool line::mc::ctmc_isfeasible	(	const Matrix< T > &	Q,
		const T &	tol )

True when Q is square, has nonnegative off-diagonals, nonpositive diagonal and zero row sums.

Definition at line 35 of file ctmc_isfeasible.h.

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

Referenced by ctmc_isfeasible(), ctmc_isfeasible(), and line::lang::processes::is_feasible().

◆ ctmc_kms()

template<class T>

KmsResult< T > line::mc::ctmc_kms	(	const Matrix< T > &	Q,
		const std::vector< std::vector< std::size_t > > &	MS,
		std::size_t	numSteps )

Koury-McAllister-Stewart aggregation-disaggregation for a nearly completely decomposable CTMC.

Parameters

Q	generator
MS	macro-states partitioning 0..n-1
numSteps	number of aggregation-disaggregation sweeps

Definition at line 100 of file ctmc_kms.h.

References line::Matrix< T >::cols(), ctmc_kms(), dtmc_solve(), line::mc::KmsResult< T >::eps, line::mc::KmsResult< T >::epsMAX, line::InputError::InputError(), line::NumericError::NumericError(), line::mc::KmsResult< T >::p, line::mc::KmsResult< T >::p_1, line::mc::KmsResult< T >::pcourt, line::mc::KmsResult< T >::Qperm, and line::Matrix< T >::rows().

Referenced by line::lang::processes::aggregate(), ctmc_kms(), and line::env::env_ctmc_decompose().

◆ ctmc_makeinfgen()

template<class T>

Matrix< T > line::mc::ctmc_makeinfgen ( const Matrix< T > & Q )

Set the diagonal so that every row sums to zero (ctmc_makeinfgen).

Any pre-existing diagonal entry is discarded, as in MATLAB.

Definition at line 58 of file ctmc_solve.h.

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

Referenced by ctmc_makeinfgen(), ctmc_rand(), ctmc_relsolve(), ctmc_solve(), ctmc_solve_reducible_blkdecomp(), ctmc_stmonotone(), line::ctmc::ctmc_symbolic_generator(), ctmc_testpf_kolmogorov(), dtmc_uniformization(), line::env::env_compress(), line::mam::mam_bgchain_ctmc(), line::mdd::mdd_closedqn(), line::lang::processes::MarkovChainModel< T >::process(), and line::ag::solver_ag().

◆ ctmc_maxabs()

template<class T>

T line::mc::ctmc_maxabs ( const Matrix< T > & Q )

Largest magnitude of any entry of Q; equals max_i |q_ii| for a generator.

Definition at line 48 of file ctmc_randomization.h.

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

Referenced by ctmc_maxabs(), ctmc_randomization(), ctmc_stmonotone(), and ctmc_takahashi().

◆ ctmc_memory_gate()

CtmcGateResult line::mc::ctmc_memory_gate	(	double	log_nstates,
		bool	force = false,
		double	safety_fraction = CTMC_DEFAULT_SAFETY_FRACTION,
		bool	verbose = false )

inline

Decide whether a state space of log-size log_nstates can be solved here.

Parameters

log_nstates	natural log of the worst-case state count
force	true downgrades a refusal to a warning
safety_fraction	fraction of available memory the solve may target
verbose	print the calibration and the forced / near-budget notes, the reference's third argument (last here so the existing three-argument callers keep their meaning)

Definition at line 314 of file ctmc_memory_gate.h.

References line::mc::CtmcCalibration::alpha_mem, line::mc::CtmcCalibration::beta_mem, line::mc::CtmcGateResult::budget_gb, ctmc_available_memory_bytes(), CTMC_DEFAULT_SAFETY_FRACTION, ctmc_get_calibration(), ctmc_memory_gate(), line::mc::CtmcGateResult::message, line::mc::CtmcGateResult::ok, and line::mc::CtmcGateResult::predicted_gb.

Referenced by ctmc_memory_gate(), and line::ctmc::solve_struct().

◆ ctmc_multi() [1/2]

template<class T>

MultiResult< T > line::mc::ctmc_multi	(	const Matrix< T > &	Q,
		const std::vector< std::vector< std::size_t > > &	MS,
		const std::vector< std::vector< std::size_t > > &	MSS )

Overload deriving the rate as MATLAB does, q = (21/20) max|Qperm|.

Definition at line 93 of file ctmc_multi.h.

References ctmc_multi().

◆ ctmc_multi() [2/2]

template<class T>

MultiResult< T > line::mc::ctmc_multi	(	const Matrix< T > &	Q,
		const std::vector< std::vector< std::size_t > > &	MS,
		const std::vector< std::vector< std::size_t > > &	MSS,
		const T &	q )

Two-level multigrid aggregation-disaggregation for a nearly completely decomposable CTMC.

Parameters

Q	generator
MS	macro-states partitioning 0..n-1
MSS	macro-macro-states partitioning 0..\|MS\|-1, the coarse partition
q	uniformization rate for the fine level

Definition at line 61 of file ctmc_multi.h.

References line::Matrix< T >::cols(), ctmc_courtois(), ctmc_multi(), line::mc::MultiResult< T >::eps, line::mc::MultiResult< T >::epsMAX, line::InputError::InputError(), line::mc::MultiResult< T >::p, line::mc::MultiResult< T >::pcourt, line::mc::MultiResult< T >::Qperm, and line::Matrix< T >::rows().

Referenced by line::lang::processes::aggregate_multi(), ctmc_multi(), ctmc_multi(), and line::env::env_ctmc_decompose().

◆ ctmc_passage_lst()

template<class T>

std::vector< std::complex< double > > line::mc::ctmc_passage_lst	(	const Matrix< T > &	Q,
		const std::vector< T > &	pi0,
		const std::vector< std::size_t > &	target,
		const std::vector< std::complex< double > > &	s )

L(s) = alpha (sI-S)^{-1} s0 + atom at the (complex) points s.

Eqs. 1-2: one linear system per value of s.

ONE SOLVE PER s, NOT PER (s,t) PAIR. The saving over a dense matrix exponential is that the solves are sparse, so this route reaches chains a dense expm cannot hold. It is NOT a saving in the number of time points: every Abate-Whitt inverter places its nodes at s = beta/t, so a grid of T points costs T*|beta| solves.

Definition at line 272 of file ctmc_passage.h.

References line::mc::PassagePh< T >::alpha, line::mc::PassagePh< T >::atom, ctmc_passage_lst(), ctmc_passage_ph(), line::mc::PassagePh< T >::S, and line::mc::PassagePh< T >::s0.

Referenced by ctmc_passage_lst(), and ctmc_passage_time().

◆ ctmc_passage_moments()

template<class T>

PassageMoments< T > line::mc::ctmc_passage_moments	(	const Matrix< T > &	Q,
		const std::vector< T > &	pi0,
		const std::vector< std::size_t > &	target,
		std::size_t	nmax = 1 )

Moments of order 1..nmax of the first passage time into target.

This is Eq. 3, -q_ii M_i(n) = sum_{k not in B} q_ik M_k(n) + n M_i(n-1), i.e. (-S) M(n) = n M(n-1) with M(0) = 1: nmax linear solves and no transform inversion at all. The equivalent closed form n! alpha (-S)^{-n} 1 is NOT how it is evaluated – forming the inverse of the sub-generator destroys the sparsity the recursion preserves.

Definition at line 306 of file ctmc_passage.h.

References line::mc::PassagePh< T >::alpha, ctmc_passage_moments(), ctmc_passage_ph(), line::InputError::InputError(), line::mc::PassagePh< T >::keep, line::mc::PassageMoments< T >::m, line::mc::PassageMoments< T >::mall, line::Matrix< T >::Matrix(), line::Matrix< T >::rows(), line::mc::PassagePh< T >::S, and line::solve().

Referenced by line::ctmc::ctmc_firstpasst_moments(), ctmc_hitting_time(), and ctmc_passage_moments().

◆ ctmc_passage_ph()

template<class T>

PassagePh< T > line::mc::ctmc_passage_ph	(	const Matrix< T > &	Q,
		const std::vector< T > &	pi0,
		const std::vector< std::size_t > &	target )

Phase-type representation of the first passage time from pi0 into target.

Parameters

pi0	empty selects the conditional stationary law on the complement
target	0-based state indices (1-based in the MATLAB reference)

Definition at line 199 of file ctmc_passage.h.

References line::mc::PassagePh< T >::alpha, line::mc::PassagePh< T >::atom, line::Matrix< T >::cols(), ctmc_passage_ph(), ctmc_solve(), line::InputError::InputError(), line::mc::PassagePh< T >::keep, line::Matrix< T >::Matrix(), line::Matrix< T >::rows(), line::mc::PassagePh< T >::S, and line::mc::PassagePh< T >::s0.

Referenced by ctmc_passage_lst(), ctmc_passage_moments(), ctmc_passage_ph(), and ctmc_passage_time().

◆ ctmc_passage_taboo()

template<class T>

PassageTaboo< T > line::mc::ctmc_passage_taboo	(	const Matrix< T > &	Q,
		const std::vector< T > &	pi0,
		const std::vector< std::size_t > &	target,
		const std::vector< std::size_t > &	taboo,
		const std::vector< double > &	tset = std::vector<double>(),
		const std::string &	method = "expm",
		const std::string &	lti_method = "euler" )

First passage into target under the taboo set taboo, the reference's ctmc_passage_taboo.

F is the DEFECTIVE distribution

F(t) = Pr{ B is entered by time t, and C is not entered before B }
     = atom + alpha (-S)^{-1} (I - exp(St)) sB

on the grid tset, and f its density alpha exp(St) sB; F tends to reachprob < 1 rather than to one. In temporal-logic terms this is the time-bounded until Pr{ not C U<=t B }.

The ultimate probabilities come from the exit-probability matrix X of ctmc_stochcomp, so they are one linear solve and need no time grid. An empty tset computes only those; an infinite entry returns reachprob and a negative one zero. With an empty taboo, F equals the CDF of ctmc_passage_time.

Parameters

pi0	empty selects the conditional stationary law on the complement of B
target	0-based state indices of B (1-based in the MATLAB reference)
taboo	0-based state indices of C; a state also in B counts as B
method	"expm" (default) or "lt", as in ctmc_passage_time

Reference: C. Baier, B. Haverkort, H. Hermanns, J.-P. Katoen, "Model-checking algorithms for continuous-time Markov chains", IEEE TSE 29(6), 2003.

Definition at line 751 of file ctmc_passage.h.

Referenced by line::ctmc::ctmc_cdf_firstpasst(), line::ctmc::ctmc_firstpasst_moments(), and ctmc_passage_taboo().

◆ ctmc_passage_taboo_moments()

template<class T>

PassageTabooMoments< T > line::mc::ctmc_passage_taboo_moments	(	const Matrix< T > &	Q,
		const std::vector< T > &	pi0,
		const std::vector< std::size_t > &	target,
		const std::vector< std::size_t > &	taboo,
		std::size_t	nmax = 1 )

Moments of order 1..nmax of the first passage time into target, CONDITIONAL on entering it before taboo, the reference's ctmc_passage_taboo_moments:

E[T^k | B before C] = k! alpha (-S)^{-(k+1)} sB / Pr{B before C}

evaluated as (-S) y_k = k y_(k-1) from y_0 = pB, one solve per order on one factorization, with S, pB and the partition of ctmc_passage_taboo.

mall is zero on B and NaN where B cannot be entered before C, since the conditional moment is then undefined; m is NaN when B is never entered first. With an empty taboo and B entered surely, the moments equal those of ctmc_passage_moments.

Definition at line 886 of file ctmc_passage.h.

References line::mc::PassageTaboo< T >::alpha, line::mc::PassageTaboo< T >::atom, ctmc_passage_taboo_moments(), line::InputError::InputError(), line::mc::PassageTaboo< T >::keep, line::lu_factor(), line::lu_solve(), line::mc::PassageTabooMoments< T >::m, line::mc::PassageTabooMoments< T >::mall, line::Matrix< T >::Matrix(), line::mc::PassageTaboo< T >::pB, line::mc::PassageTabooMoments< T >::pB, line::Matrix< T >::rows(), line::mc::PassageTaboo< T >::S, and line::mc::PassageTaboo< T >::target.

Referenced by line::ctmc::ctmc_firstpasst_moments(), and ctmc_passage_taboo_moments().

◆ ctmc_passage_time()

template<class T>

PassageCurve< T > line::mc::ctmc_passage_time	(	const Matrix< T > &	Q,
		const std::vector< T > &	pi0,
		const std::vector< std::size_t > &	target,
		const std::vector< double > &	tset,
		const std::string &	method = "expm",
		const std::string &	lti_method = "euler" )

CDF and density of the first passage time on the grid tset: F(t) = 1 - alpha exp(St) 1 and f(t) = alpha exp(St) s0.

method is "expm" (default) or "lt". The transform route exists for chains whose non-target block is too large for a dense exp(St), not because it needs fewer time points; on a small chain "expm" is both faster and more accurate, which is why it is the default.

Definition at line 420 of file ctmc_passage.h.

References line::mc::PassagePh< T >::alpha, line::mc::PassageCurve< T >::atom, line::mc::PassagePh< T >::atom, ctmc_passage_lst(), ctmc_passage_ph(), ctmc_passage_time(), line::expm(), line::mc::PassageCurve< T >::F, line::mc::PassageCurve< T >::f, line::InputError::InputError(), line::lti::laplace_invert_cdf(), line::lti::laplace_invert_pdf(), line::lti::laplace_method(), line::mc::PassagePh< T >::S, line::mc::PassagePh< T >::s0, and line::mc::PassageCurve< T >::t.

Referenced by line::ctmc::ctmc_cdf_firstpasst(), and ctmc_passage_time().

◆ ctmc_pseudostochcomp() [1/2]

template<class T>

PseudoStochCompResult< T > line::mc::ctmc_pseudostochcomp ( const Matrix< T > & Q )

Default partition: the first ceil(n/2) states.

Definition at line 126 of file ctmc_pseudostochcomp.h.

References ctmc_pseudostochcomp().

◆ ctmc_pseudostochcomp() [2/2]

template<class T>

PseudoStochCompResult< T > line::mc::ctmc_pseudostochcomp	(	const Matrix< T > &	Q,
		const std::vector< std::size_t > &	keep )

Pseudo stochastic complement of a CTMC partition.

Parameters

Q	(n x n) generator
keep	0-based indices of the retained set I; empty selects the first ceil(n/2) states

Definition at line 61 of file ctmc_pseudostochcomp.h.

References line::Matrix< T >::cols(), ctmc_pseudostochcomp(), ctmc_solve(), line::InputError::InputError(), line::Matrix< T >::Matrix(), line::NumericError::NumericError(), line::mc::PseudoStochCompResult< T >::Q11, line::mc::PseudoStochCompResult< T >::Q12, line::mc::PseudoStochCompResult< T >::Q21, line::mc::PseudoStochCompResult< T >::Q22, line::Matrix< T >::rows(), line::mc::PseudoStochCompResult< T >::S, and line::mc::PseudoStochCompResult< T >::Tm.

Referenced by ctmc_pseudostochcomp(), and ctmc_pseudostochcomp().

◆ ctmc_rand()

template<class T, class Gen>

Matrix< T > line::mc::ctmc_rand	(	std::size_t	n,
		Gen &	gen )

Random infinitesimal generator of a CTMC.

Parameters

n	order of the generator
gen	callable returning a uniform variate in [0,1); n*n draws are made

Definition at line 71 of file ctmc_rand.h.

References ctmc_makeinfgen(), ctmc_rand(), and line::InputError::InputError().

Referenced by ctmc_rand(), dtmc_rand(), and line::lang::processes::rand_process().

◆ ctmc_randomization() [1/2]

template<class T>

RandomizationResult< T > line::mc::ctmc_randomization ( const Matrix< T > & Q )

Deterministic default rate (21/20) max|Q|; see the defect note above.

Definition at line 84 of file ctmc_randomization.h.

References ctmc_maxabs(), and ctmc_randomization().

◆ ctmc_randomization() [2/2]

template<class T>

RandomizationResult< T > line::mc::ctmc_randomization	(	const Matrix< T > &	Q,
		const T &	q )

Uniformization (randomization) of a CTMC: the embedded DTMC P = I + Q/q.

Parameters

Q	generator
q	uniformization rate, which must satisfy q >= max_i \|q_ii\|

Definition at line 66 of file ctmc_randomization.h.

References line::Matrix< T >::cols(), ctmc_randomization(), dtmc_makestochastic(), line::InputError::InputError(), line::mc::RandomizationResult< T >::P, and line::Matrix< T >::rows().

Referenced by ctmc_randomization(), ctmc_randomization(), ctmc_solve_reducible(), ctmc_stmonotone(), ctmc_takahashi(), and dtmc_rand().

◆ ctmc_relsolve() [1/2]

template<class T>

std::vector< T > line::mc::ctmc_relsolve ( const Matrix< T > & Q )

Reference state 1 in the MATLAB numbering, i.e.

index 0 here.

Definition at line 82 of file ctmc_relsolve.h.

References ctmc_relsolve().

◆ ctmc_relsolve() [2/2]

template<class T>

std::vector< T > line::mc::ctmc_relsolve	(	const Matrix< T > &	Qin,
		std::size_t	refstate )

Stationary measure scaled so that entry refstate equals one.

Definition at line 39 of file ctmc_relsolve.h.

References line::Matrix< T >::cols(), ctmc_makeinfgen(), ctmc_relsolve(), ctmc_solve(), line::InputError::InputError(), line::Matrix< T >::rows(), and line::solve().

Referenced by ctmc_relsolve(), ctmc_relsolve(), and line::lang::processes::solve_relative().

◆ ctmc_saddlepoint() [1/2]

template<class T>

SaddlepointResult< T > line::mc::ctmc_saddlepoint	(	const Matrix< T > &	D0,
		const Matrix< T > &	D1,
		const std::vector< T > &	t,
		const std::vector< long > &	k,
		SaddlepointMethod	method = SADDLEPOINT_DANIELS2,
		const std::vector< T > &	pi0 = std::vector<T>() )

inline

Pr{N(t)=k} over arrays of horizons and counts.

Parameters

D0	generator of the phase process with the counted transitions removed
D1	rates of the counted transitions; D0+D1 must be an irreducible generator
t	time horizons; length 1 broadcasts against k
k	event counts; length 1 broadcasts against t
method	SADDLEPOINT_DANIELS2 (the default), SADDLEPOINT_DANIELS or SADDLEPOINT_PLAIN
pi0	initial phase distribution; empty selects the stationary distribution of D0+D1

Definition at line 359 of file ctmc_saddlepoint.h.

Referenced by ctmc_saddlepoint(), and ctmc_saddlepoint().

◆ ctmc_saddlepoint() [2/2]

template<class T>

T line::mc::ctmc_saddlepoint	(	const Matrix< T > &	D0,
		const Matrix< T > &	D1,
		const T &	t,
		long	k,
		SaddlepointMethod	method = SADDLEPOINT_DANIELS2 )

inline

Pr{N(t)=k} at a single (t,k), with the default method.

Definition at line 549 of file ctmc_saddlepoint.h.

References ctmc_saddlepoint(), and SADDLEPOINT_DANIELS2.

◆ ctmc_saddlepoint_perron()

template<class T>

PerronState< T > line::mc::ctmc_saddlepoint_perron	(	const Matrix< T > &	D0,
		const Matrix< T > &	D1,
		const std::vector< T > &	pi0,
		const T &	th )

inline

Perron root of A(th) = D0 + exp(th)*D1 with deta, d2eta and the amplitude.

Only EIGENVALUES are taken from the eigensolver; the Perron vectors come from bordered solves, the idiom ctmc_solve already uses. That keeps all four codebases on ONE algorithm: eig.h exposes values only, and the JAR's commons-math hands back Schur blocks rather than eigenvectors as soon as a complex pair appears, so neither can supply a left eigenvector.

Definition at line 189 of file ctmc_saddlepoint.h.

References line::mc::PerronState< T >::ampl, ctmc_saddlepoint_perron(), line::mc::PerronState< T >::d2eta, line::mc::PerronState< T >::deta, line::eig_values(), line::mc::PerronState< T >::eta, line::Matrix< T >::rows(), and tx_exp().

Referenced by ctmc_saddlepoint(), and ctmc_saddlepoint_perron().

◆ ctmc_sens() [1/2]

template<class T>

std::vector< T > line::mc::ctmc_sens	(	const Matrix< T > &	Q,
		const Matrix< T > &	dQ )

Overload computing the steady-state vector itself, as MATLAB does.

Definition at line 80 of file ctmc_sens.h.

References ctmc_sens(), and ctmc_solve().

◆ ctmc_sens() [2/2]

template<class T>

std::vector< T > line::mc::ctmc_sens	(	const Matrix< T > &	Q,
		const Matrix< T > &	dQ,
		const std::vector< T > &	pi )

Sensitivity of the steady-state distribution of a CTMC to a scalar parameter.

Parameters

Q	generator
dQ	derivative of the generator with respect to theta, same size
pi	steady-state distribution; must sum to one

Returns: dpi/dtheta as a row vector of length n, summing to zero

Definition at line 52 of file ctmc_sens.h.

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

Referenced by line::lang::processes::chain_sens(), ctmc_sens(), ctmc_sens(), and line::ctmc::solver_ctmc_sensitivity().

◆ ctmc_simulate()

template<class T>

CtmcPath< T > line::mc::ctmc_simulate	(	const Matrix< T > &	Q,
		const std::vector< T > &	pi0,
		std::size_t	n,
		pfqn::McRng &	rng )

Simulate n steps of the CTMC with generator Q.

Parameters

Q	(m x m) generator, negative diagonal and zero row sums
pi0	initial distribution; empty draws it uniformly at random and normalizes, as the reference does
n	number of steps
rng	generator, advanced by the call

Definition at line 158 of file ctmc_simulate.h.

References line::Matrix< T >::cols(), ctmc_simulate(), line::InputError::InputError(), line::pfqn::mc_uniform(), line::NumericError::NumericError(), line::Matrix< T >::rows(), line::mc::CtmcPath< T >::sojourn, and line::mc::CtmcPath< T >::states.

Referenced by line::lang::processes::chain_sample(), and ctmc_simulate().

◆ ctmc_simulate_reference_initial_law()

template<class T>

std::vector< T > line::mc::ctmc_simulate_reference_initial_law ( const std::vector< T > & pi0 )

The initial-state law that ctmc_simulate.m actually realizes for a given pi0, as opposed to pi0 itself.

Provided so a caller can measure the reference defect documented above rather than take it on trust; it is not used by the simulation.

Definition at line 109 of file ctmc_simulate.h.

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

Referenced by ctmc_simulate_reference_initial_law().

◆ ctmc_solve()

template<class T>

std::vector< T > line::mc::ctmc_solve ( const Matrix< T > & Qin )

Steady-state distribution of a continuous-time Markov chain.

Parameters

Qin	generator; the diagonal is recomputed, so an off-diagonal rate matrix is accepted directly

Returns: stationary distribution as a row vector of length n, summing to one

Definition at line 122 of file ctmc_solve.h.

References line::Matrix< T >::cols(), ctmc_bicgstab(), ctmc_gmres(), ctmc_makeinfgen(), ctmc_solve(), line::mc::BicgstabResult< T >::flag, line::mc::GmresResult< T >::flag, GMRES_MIN_STATES, line::InputError::InputError(), line::NumericError::NumericError(), line::Matrix< T >::rows(), line::solve(), line::mc::BicgstabResult< T >::x, and line::mc::GmresResult< T >::x.

Referenced by ctmc_passage_ph(), ctmc_pseudostochcomp(), ctmc_relsolve(), ctmc_saddlepoint(), ctmc_sens(), ctmc_solve(), ctmc_solve_reducible_blkdecomp(), ctmc_timereverse(), dtmc_solve(), line::fes::fes_map_moments(), line::fes::fes_map_solve(), line::fj::fj_respt_bulk(), line::mam::mam_bgchain_ctmc(), line::mam::map_prob(), line::mdd::mdd_closedqn(), line::mam::mfq_fluflu_sojourn(), line::mam::mfq_prio_queue(), line::mmdp::mmdp_mean_rate(), line::mmdp::mmdp_scv(), line::mam::qbd_setupdelayoff_closed(), line::qsys::qsys_bmapm1(), line::ctmc::solver_ctmc_chain(), and line::spn::spn_pf().

◆ ctmc_solve_reducible() [1/2]

template<class T>

ReducibleResult< T > line::mc::ctmc_solve_reducible	(	const Matrix< T > &	Q,
		const std::vector< T > &	pi0,
		double	zeroColTol = 1e-12 )

Limiting distribution of a CTMC whose generator may be reducible.

Parameters

Q	generator
pi0	initial distribution; empty to let the routine pick one
zeroColTol	column-sum threshold below which a state counts as unreachable

Definition at line 47 of file ctmc_solve_reducible.h.

References line::Matrix< T >::cols(), ctmc_randomization(), ctmc_solve_reducible(), dtmc_solve_reducible(), line::InputError::InputError(), and line::Matrix< T >::rows().

Referenced by line::lang::processes::chain_solve(), ctmc_solve_reducible(), ctmc_solve_reducible(), line::env::Environment< T >::init(), and line::ctmc::solver_ctmc_chain().

◆ ctmc_solve_reducible() [2/2]

template<class T>

ReducibleResult< T > line::mc::ctmc_solve_reducible	(	const Matrix< T > &	Q,
		double	zeroColTol = 1e-12 )

Overload without an initial vector.

Definition at line 56 of file ctmc_solve_reducible.h.

References ctmc_solve_reducible().

◆ ctmc_solve_reducible_blkdecomp() [1/2]

template<class T>

BlkDecompResult< T > line::mc::ctmc_solve_reducible_blkdecomp	(	const Matrix< T > &	Q,
		double	reachTol = 1e-15,
		double	zeroColTol = 1e-12 )

Overload without an initial vector.

Definition at line 277 of file ctmc_solve_reducible_blkdecomp.h.

References ctmc_solve_reducible_blkdecomp().

◆ ctmc_solve_reducible_blkdecomp() [2/2]

template<class T>

BlkDecompResult< T > line::mc::ctmc_solve_reducible_blkdecomp	(	const Matrix< T > &	Qin,
		const std::vector< T > &	pin,
		double	reachTol = 1e-15,
		double	zeroColTol = 1e-12 )

Limiting distribution of a reducible CTMC by direct block decomposition of the generator.

Parameters

Qin	generator; the diagonal is recomputed
pin	initial distribution; empty if not available
reachTol	probability below which a recurrent class counts as unreached
zeroColTol	column-sum threshold for a state with no incoming rate

Definition at line 75 of file ctmc_solve_reducible_blkdecomp.h.

References line::lang::GlobalConstants::ArcTol, line::Matrix< T >::cols(), ctmc_bicgstab(), ctmc_gmres(), ctmc_makeinfgen(), ctmc_solve(), ctmc_solve_reducible_blkdecomp(), line::mc::BicgstabResult< T >::flag, line::mc::GmresResult< T >::flag, GMRES_MIN_STATES, line::InputError::InputError(), line::mc::BlkDecompResult< T >::isrec, line::lu_factor(), line::lu_solve(), line::Matrix< T >::Matrix(), line::mc::SccResult::members, line::num_abs(), line::NumericError::NumericError(), line::mc::SccResult::numSCC(), line::mc::BlkDecompResult< T >::pi, line::mc::BlkDecompResult< T >::pi0, line::mc::BlkDecompResult< T >::pis, line::mc::SccResult::recurrent, line::Matrix< T >::rows(), line::mc::BlkDecompResult< T >::scc, line::mc::SccResult::scc, stronglyconncomp(), line::mc::BicgstabResult< T >::x, and line::mc::GmresResult< T >::x.

Referenced by ctmc_solve_reducible_blkdecomp(), ctmc_solve_reducible_blkdecomp(), and line::ctmc::ctmc_stationary().

◆ ctmc_ssg()

template<class T>

CtmcSsgResult< T > line::mc::ctmc_ssg	(	const qn::NetworkStruct< T > &	sn,
		const CtmcSsgOptions &	options = CtmcSsgOptions(),
		const std::vector< qn::FjSync< T > > &	fjsync = std::vector<qn::FjSync<T>>() )

Port of ctmc_ssg: the FULL state space of the network.

Parameters

sn	the refreshed network struct
options	the cutoff of the open classes and the state cap
fjsync	the fork firing list; a non-empty one is refused, as the reference refuses a model with sn.fjsync

Definition at line 154 of file ctmc_ssg.h.

References line::mc::ssg_detail::assemble(), ctmc_ssg(), line::mc::ssg_detail::cutoff_or_closed(), line::qn::space_generator(), and line::UnsupportedError::UnsupportedError().

Referenced by ctmc_ssg().

◆ ctmc_ssg_reachability()

template<class T>

CtmcSsgResult< T > line::mc::ctmc_ssg_reachability	(	const qn::NetworkStruct< T > &	sn,
		const CtmcSsgOptions &	options = CtmcSsgOptions(),
		const std::vector< qn::FjSync< T > > &	fjsync = std::vector<qn::FjSync<T>>() )

Port of ctmc_ssg_reachability: the REACHABLE state space, walked from the model's initial state over the synchronizations refresh_sync and refresh_global_sync build.

Parameters

sn	the refreshed network struct
options	the cutoff of the open classes and the state cap
fjsync	the fork firing list of a fork-join model, empty otherwise

Definition at line 178 of file ctmc_ssg.h.

References line::mc::ssg_detail::assemble(), ctmc_ssg_reachability(), line::mc::ssg_detail::cutoff_or_closed(), line::ctmc::reachable_space_generator(), line::qn::refresh_global_sync(), line::qn::refresh_sync(), and line::UnsupportedError::UnsupportedError().

Referenced by ctmc_ssg_reachability().

◆ ctmc_state_space_logsize()

template<class T>

double line::mc::ctmc_state_space_logsize	(	const qn::NetworkStruct< T > &	sn,
		const CtmcSizeOptions &	opt = CtmcSizeOptions() )

Worst-case log state-space size of sn.

Parameters

sn	the struct, ideally after sn_nonmarkov_toph, since a non-Markovian service becomes phases the raw struct does not carry

Returns: natural log of the worst-case state count

Definition at line 207 of file ctmc_state_space_logsize.h.

References line::lang::Cache, ctmc_state_space_logsize(), line::qn::CacheParam< T >::itemcap, kOrderGridMax, log_ordered_joint(), line::qn::CacheParam< T >::nitems, line::lang::Place, and line::qn::CacheParam< T >::retrieval_capacity.

Referenced by line::autosolver::auto_ctmc_state_space_logsize(), ctmc_state_space_logsize(), and line::ctmc::solve_struct().

◆ ctmc_stmonotone()

template<class T>

Matrix< T > line::mc::ctmc_stmonotone ( const Matrix< T > & Q )

Stochastically monotone upper bound of a Markov chain.

Parameters

Q	(n x n) generator

Returns: the generator of the st-monotone upper bound of Q

Definition at line 81 of file ctmc_stmonotone.h.

References ctmc_makeinfgen(), ctmc_maxabs(), ctmc_randomization(), ctmc_stmonotone(), and dtmc_stmonotone().

Referenced by ctmc_stmonotone().

◆ ctmc_stochcomp() [1/2]

template<class T>

StochCompResult< T > line::mc::ctmc_stochcomp ( const Matrix< T > & Q )

Default subset: the first ceil(n/2) states, as in MATLAB.

Definition at line 223 of file dtmc_solve.h.

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

◆ ctmc_stochcomp() [2/2]

template<class T>

StochCompResult< T > line::mc::ctmc_stochcomp	(	const Matrix< T > &	Q,
		const std::vector< std::size_t > &	I )

Parameters

Q	generator
I	state subset to keep; defaults to the first ceil(n/2) states

Definition at line 158 of file dtmc_solve.h.

References line::Matrix< T >::cols(), ctmc_stochcomp(), line::InputError::InputError(), line::lu_factor(), line::lu_solve(), line::Matrix< T >::Matrix(), line::mc::StochCompResult< T >::Q11, line::mc::StochCompResult< T >::Q12, line::mc::StochCompResult< T >::Q21, line::mc::StochCompResult< T >::Q22, line::Matrix< T >::rows(), line::mc::StochCompResult< T >::S, line::mc::StochCompResult< T >::T12, and line::mc::StochCompResult< T >::X.

Referenced by line::ctmc::ctmc_eliminate_vanishing(), ctmc_stochcomp(), ctmc_stochcomp(), line::fluid::fluid_eliminate_immediate_matrix(), and line::lang::processes::stoch_comp_full().

◆ ctmc_takahashi()

template<class T>

TakahashiResult< T > line::mc::ctmc_takahashi	(	const Matrix< T > &	Q,
		const std::vector< std::vector< std::size_t > > &	MS,
		std::size_t	numSteps,
		double	massTol = 1e-14 )

Takahashi's aggregation-disaggregation for a nearly completely decomposable CTMC.

Parameters

Q	generator
MS	macro-states partitioning 0..n-1
numSteps	number of aggregation-disaggregation sweeps
massTol	macro-state mass below which its contribution is dropped

Definition at line 83 of file ctmc_takahashi.h.

References line::Matrix< T >::cols(), ctmc_bicgstab(), ctmc_gmres(), ctmc_maxabs(), ctmc_randomization(), ctmc_takahashi(), dtmc_solve(), line::mc::TakahashiResult< T >::eps, line::mc::TakahashiResult< T >::epsMAX, line::mc::BicgstabResult< T >::flag, line::mc::GmresResult< T >::flag, GMRES_MIN_STATES, line::InputError::InputError(), line::NumericError::NumericError(), line::mc::TakahashiResult< T >::p, line::mc::TakahashiResult< T >::p_1, line::mc::TakahashiResult< T >::pcourt, line::mc::TakahashiResult< T >::Qperm, line::Matrix< T >::rows(), line::solve(), line::mc::BicgstabResult< T >::x, and line::mc::GmresResult< T >::x.

Referenced by line::lang::processes::aggregate(), ctmc_takahashi(), and line::env::env_ctmc_decompose().

◆ ctmc_testpf_kolmogorov()

template<class T>

bool line::mc::ctmc_testpf_kolmogorov ( const Matrix< T > & Qin )

Kolmogorov reversibility criterion, used as a product-form test.

Parameters

Qin	generator of an irreducible CTMC

Returns: true when Kolmogorov's criterion holds on every simple cycle

Definition at line 84 of file ctmc_testpf_kolmogorov.h.

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

Referenced by ctmc_testpf_kolmogorov().

◆ ctmc_timeaverage()

template<class T>

TimeAverageResult< T > line::mc::ctmc_timeaverage	(	const std::vector< T > &	pi0,
		const Matrix< T > &	Q,
		const T &	t,
		double	tol = 1e-12,
		long	maxiter = -1 )

Time-averaged distribution (1/t) int_0^t pi(u) du, plus pi(t) itself.

Port of ctmc_timeaverage.m, which accumulates the Poisson survival weights max(1 - W_j, 0) rather than integrating pi(u) numerically.

Definition at line 175 of file ctmc_uniformization.h.

References line::Matrix< T >::cols(), ctmc_timeaverage(), line::InputError::InputError(), line::mc::TimeAverageResult< T >::kmax, line::mc::TimeAverageResult< T >::piExit, line::mc::TimeAverageResult< T >::piTimeAvg, and line::Matrix< T >::rows().

Referenced by ctmc_timeaverage(), and line::lang::processes::time_average().

◆ ctmc_timereverse()

template<class T>

Matrix< T > line::mc::ctmc_timereverse ( const Matrix< T > & Q )

Generator of the time-reversed CTMC.

Definition at line 37 of file ctmc_timereverse.h.

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

Referenced by ctmc_timereverse(), and line::lang::processes::to_time_reversed().

◆ ctmc_transient() [1/2]

template<class T>

TransientResult< T > line::mc::ctmc_transient	(	const Matrix< T > &	Q,
		const std::vector< T > &	pi0,
		const T &	t0,
		const T &	t1,
		double	rtol = 1e-3,
		double	atol = 1e-6,
		bool	stiff = false )

Transient distribution of a CTMC over a time interval, by integrating the forward equations d pi/dt = pi Q.

Templated port of matlab/src/api/mc/ctmc_transient.m (and the richer kpctoolbox copy).

Parameters

Q	generator
pi0	initial distribution (row vector)
t0	initial time
t1	final time
rtol	relative tolerance of the integrator (MATLAB RelTol, 1e-3)
atol	absolute tolerance of the integrator (MATLAB AbsTol, 1e-6)
stiff	the reference's useStiff (default false): true integrates with the stiff Rosenbrock method where MATLAB uses ode15s

Definition at line 206 of file ctmc_transient.h.

References line::OdeOptions< T >::atol, line::Matrix< T >::cols(), ctmc_transient(), line::InputError::InputError(), line::Matrix< T >::Matrix(), line::ode_rosenbrock4(), line::mc::TransientResult< T >::pi, line::Matrix< T >::rows(), line::OdeOptions< T >::rtol, line::mc::TransientResult< T >::t, line::OdeSolution< T >::t, and line::OdeSolution< T >::y.

Referenced by ctmc_transient(), ctmc_transient(), line::ctmc::solver_ctmc_chain_transient(), and line::ctmc::solver_ctmc_transient_analyzer().

◆ ctmc_transient() [2/2]

template<class T>

TransientResult< T > line::mc::ctmc_transient	(	const Matrix< T > &	Q,
		const T &	t0,
		const T &	t1,
		double	rtol = 1e-3,
		double	atol = 1e-6 )

Overload starting from the uniform distribution, as MATLAB's short forms do.

The initial time stays explicit: an overload taking (Q, pi0, t1) would be ambiguous with the four-argument form at T = double, since the tolerances are doubles too.

Definition at line 266 of file ctmc_transient.h.

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

◆ ctmc_transient_on_grid() [1/2]

template<class T>

TransientResult< T > line::mc::ctmc_transient_on_grid	(	const Matrix< T > &	Q,
		const TransientResult< T > &	r,
		const std::vector< T > &	grid )

Resample an adaptive transient onto the uniform grid t0 : dt : t1.

The same resampling onto an ARBITRARY grid, which a uniform step cannot express.

options.timestep of the reference. ctmc_transient.m passes the grid STRAIGHT INTO ode23 as its tspan, and MATLAB's integrator then reports the solution at exactly those points by evaluating its own dense output – it does not change the steps it takes, only where it reports them. This does the same thing explicitly: the adaptive solve is untouched, and the answer at a grid point is the cubic Hermite interpolant of the bracketing pair.

THE DERIVATIVES ARE EXACT AND NOT DIFFERENCED. d pi/dt = pi Q holds at every stored point, so the Hermite data is the solution and its true derivative rather than a secant estimate; that is what makes this the same order as ode23's own dense output instead of a linear interpolation dressed up as one.

t1 IS ALWAYS THE LAST POINT even when the step does not divide the horizon, as ctmc_transient.m appends it: a transient reported to 9.9 when 10 was asked for is a different answer, not a rounded one.

A caller that integrates a quantity AGAINST the trajectory needs the points its integrand asks for, not the points the step controller happened to stop at: the environment coupling forms a Riemann-Stieltjes sum of each stage's transient against the holding-time CDF, and the grid that resolves that CDF (refine_grid, 90% of its points under 5*E[S]) is not uniform. Resampling here rather than re-integrating keeps ONE integration behind every grid.

LINEAR, NOT HERMITE, AND DELIBERATELY THE LESS ACCURATE CHOICE. Every codebase resamples here rather than re-integrating, but MATLAB's refineForCdf_, the JAR's CdfGrid.on and native python all interpolate LINEARLY, and this port used a cubic Hermite built from the exact derivative y' = yQ. That is the better interpolant and it is what made renv_threestages_repairmen read Queue1 QLen 0.83092 where the other three read 0.83053: a 4.7e-4 disagreement that is entirely the difference between the two quadratures, on a row whose gate is 3.2e-4. Parity measures whether the codebases give the SAME answer, so the interpolant is aligned rather than the golden rebased onto the more accurate one. Changed 2026-08-13 on the user's decision; if this is ever revisited, note that the metrics read off pi(t) are LINEAR functionals of it, so interpolating pi linearly and interpolating each metric linearly are the same operation – which is why matching the reference here is enough to match it in every measure.

Definition at line 340 of file ctmc_transient.h.

References ctmc_transient_on_grid(), line::Matrix< T >::Matrix(), line::mc::TransientResult< T >::pi, line::Matrix< T >::rows(), and line::mc::TransientResult< T >::t.

Referenced by ctmc_transient_on_grid(), ctmc_transient_on_grid(), and line::ctmc::solver_ctmc_transient_analyzer().

◆ ctmc_transient_on_grid() [2/2]

template<class T>

TransientResult< T > line::mc::ctmc_transient_on_grid	(	const Matrix< T > &	Q,
		const TransientResult< T > &	r,
		const T &	t0,
		const T &	t1,
		const T &	dt )

Definition at line 298 of file ctmc_transient.h.

References ctmc_transient_on_grid(), line::InputError::InputError(), and line::mc::TransientResult< T >::t.

◆ ctmc_transient_sens() [1/2]

template<class T>

TransientSensResult< T > line::mc::ctmc_transient_sens	(	const Matrix< T > &	Q,
		const Matrix< T > &	dQ,
		const std::vector< T > &	pi0,
		const T &	t0,
		const T &	t1,
		double	rtol = 1e-3,
		double	atol = 1e-6 )

Sensitivity of the transient distribution of a CTMC to a scalar parameter.

Parameters

Q	generator
dQ	derivative of the generator with respect to theta, same size
pi0	initial distribution (row vector)
t0	initial time
t1	final time
rtol	relative tolerance of the ODE integrator
atol	absolute tolerance of the ODE integrator

Definition at line 59 of file ctmc_transient_sens.h.

References line::Matrix< T >::cols(), ctmc_transient_sens(), line::InputError::InputError(), line::Matrix< T >::Matrix(), line::Matrix< T >::rows(), and line::mc::TransientSensResult< T >::t.

Referenced by ctmc_transient_sens(), and ctmc_transient_sens().

◆ ctmc_transient_sens() [2/2]

template<class T>

TransientSensResult< T > line::mc::ctmc_transient_sens	(	const Matrix< T > &	Q,
		const Matrix< T > &	dQ,
		const T &	t0,
		const T &	t1,
		double	rtol = 1e-3,
		double	atol = 1e-6 )

Overload starting from the uniform distribution, as MATLAB's short forms do.

Definition at line 105 of file ctmc_transient_sens.h.

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

◆ ctmc_uniformization()

template<class T>

UniformizationResult< T > line::mc::ctmc_uniformization	(	const std::vector< T > &	pi0,
		const Matrix< T > &	Q,
		const T &	t,
		double	tol = 1e-12,
		long	maxiter = -1 )

Transient distribution of a CTMC by uniformization (Jensen's method), and the time-averaged distribution over [0, t].

Parameters

pi0	initial distribution (row vector)
Q	generator
t	time horizon
tol	Poisson-tail truncation tolerance (MATLAB default 1e-12)
maxiter	iteration cap, <= 0 for the MATLAB heuristic

Definition at line 124 of file ctmc_uniformization.h.

References line::Matrix< T >::cols(), ctmc_uniformization(), line::InputError::InputError(), line::mc::UniformizationResult< T >::kmax, line::mc::UniformizationResult< T >::pi, and line::Matrix< T >::rows().

Referenced by line::lang::processes::chain_transient_at(), ctmc_uniformization(), and dtmc_uniformization().

◆ dtmc_hitting_time()

template<class T>

std::vector< T > line::mc::dtmc_hitting_time	(	const Matrix< T > &	P,
		const std::vector< std::size_t > &	target )

Expected number of steps to reach the target set, zero on the target set itself.

Definition at line 72 of file dtmc_transient.h.

References dtmc_hitting_time(), line::InputError::InputError(), and line::solve().

Referenced by dtmc_hitting_time(), and line::lang::processes::hitting_time().

◆ dtmc_isfeasible()

template<class T>

int line::mc::dtmc_isfeasible ( const Matrix< T > & P )

Largest precision level 1..15 at which P is stochastic, or 0 when none holds.

Definition at line 58 of file ctmc_isfeasible.h.

References dtmc_isfeasible().

Referenced by dtmc_isfeasible(), and line::lang::processes::is_feasible().

◆ dtmc_makestochastic()

template<class T>

Matrix< T > line::mc::dtmc_makestochastic ( const Matrix< T > & Pin )

Normalize a non-negative matrix into a stochastic transition matrix.

Parameters

Pin	matrix with non-negative entries

Returns: row-stochastic matrix of the same size

Definition at line 44 of file dtmc_makestochastic.h.

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

Referenced by line::lang::processes::MarkovChainModel< T >::chain(), ctmc_randomization(), dtmc_makestochastic(), and dtmc_solve_reducible().

◆ dtmc_rand()

template<class T, class Gen>

Matrix< T > line::mc::dtmc_rand	(	std::size_t	n,
		Gen &	gen )

Random stochastic matrix, the uniformization of a random generator.

Definition at line 45 of file dtmc_rand.h.

References ctmc_rand(), ctmc_randomization(), and dtmc_rand().

Referenced by dtmc_rand(), and line::lang::processes::rand_chain().

◆ dtmc_simulate()

template<class T, class Gen>

std::vector< std::size_t > line::mc::dtmc_simulate	(	const Matrix< T > &	P,
		const std::vector< T > &	pi0,
		std::size_t	n,
		Gen &	gen )

Sample path of a DTMC, n states starting from pi0.

An absorbing state ends the path early, exactly as the reference does: it returns the prefix rather than padding, so the returned length is at most n.

Definition at line 56 of file dtmc_rand.h.

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

Referenced by line::lang::processes::chain_sample(), and dtmc_simulate().

◆ dtmc_solve()

template<class T>

std::vector< T > line::mc::dtmc_solve ( const Matrix< T > & P )

Stationary distribution of a stochastic matrix P.

Definition at line 106 of file dtmc_solve.h.

References ctmc_solve(), dtmc_solve(), and line::InputError::InputError().

Referenced by line::cache::cache_lrum_map_levelstats(), line::qn::NetworkStruct< T >::chain_visits(), ctmc_courtois(), ctmc_kms(), ctmc_takahashi(), line::mam::dmap_compress_batch(), line::mam::dmap_lambda_batch(), line::mam::dmap_pie(), line::lang::dmap_refresh_moments(), dtmc_solve(), dtmc_solve_reducible(), dtmc_timereverse(), line::mam::mg1_dt_pi(), line::pfqn::pfqn_sdrvisits(), line::mam::ph2hyper(), line::mam::q_dt_map_map_1(), line::qsys::qsys_bmapm1(), line::qsys::qsys_mapg1k(), line::qsys::qsys_mg1k_loss(), line::ctmc::solver_ctmc_chain(), and line::qn::NetworkStruct< T >::visits_from_block().

◆ dtmc_solve_reducible() [1/2]

template<class T>

ReducibleResult< T > line::mc::dtmc_solve_reducible	(	const Matrix< T > &	P,
		const std::vector< T > &	pin,
		double	zeroColTol = 1e-12 )

Limiting distribution of a discrete-time Markov chain whose transition matrix may be reducible.

Parameters

P	transition matrix, possibly reducible
pin	initial distribution; empty to let the routine pick one
zeroColTol	column-sum threshold below which a state is treated as having no incoming mass (MATLAB 1e-12)

Definition at line 155 of file dtmc_solve_reducible.h.

References dtmc_makestochastic(), dtmc_solve(), dtmc_solve_reducible(), line::InputError::InputError(), line::mc::ReducibleResult< T >::isrec, line::Matrix< T >::Matrix(), line::mc::SccResult::members, line::mc::SccResult::numSCC(), line::mc::ReducibleResult< T >::pi, line::mc::ReducibleResult< T >::pi0, line::mc::ReducibleResult< T >::pil, line::mc::ReducibleResult< T >::pis, line::mc::ReducibleResult< T >::Pl, line::mc::SccResult::recurrent, line::mc::ReducibleResult< T >::scc, line::mc::SccResult::scc, and stronglyconncomp().

Referenced by line::lang::processes::chain_solve(), line::qn::NetworkStruct< T >::chain_visits(), ctmc_solve_reducible(), dtmc_solve_reducible(), dtmc_solve_reducible(), line::ctmc::solver_ctmc_chain(), and line::qn::NetworkStruct< T >::visits_from_block().

◆ dtmc_solve_reducible() [2/2]

template<class T>

ReducibleResult< T > line::mc::dtmc_solve_reducible	(	const Matrix< T > &	P,
		double	zeroColTol = 1e-12 )

Overload without an initial vector.

Definition at line 273 of file dtmc_solve_reducible.h.

References dtmc_solve_reducible().

◆ dtmc_stmonotone()

template<class T>

Matrix< T > line::mc::dtmc_stmonotone ( const Matrix< T > & P )

Parameters

P	(n x n) row-stochastic transition matrix

Returns: the st-monotone upper bound of P, itself row-stochastic

Definition at line 48 of file ctmc_stmonotone.h.

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

Referenced by ctmc_stmonotone(), and dtmc_stmonotone().

◆ dtmc_stochcomp()

template<class T>

Matrix< T > line::mc::dtmc_stochcomp	(	const Matrix< T > &	P,
		const std::vector< std::size_t > &	keep )

Stochastic complement of a DTMC partition, a port of matlab/lib/kpctoolbox/mc/dtmc_stochcomp.m.

Parameters

P	(n x n) row-stochastic transition matrix
keep	the 0-based indices of the states to retain (the set I)

Returns: the (|I| x |I|) stochastic complement S over the retained states, in the order given by keep

Definition at line 49 of file dtmc_stochcomp.h.

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

Referenced by line::qn::NetworkStruct< T >::da_recompute_visits_from_rtnodes(), dtmc_stochcomp(), line::fes::fes_aggregate(), line::fluid::fluid_diffusion(), line::fluid::fluid_matrix_system(), line::fluid::fluid_ode_system(), line::api::sn_rt_stations(), line::api::sn_rtnodes_to_rtorig(), line::mam::solver_mam_traffic(), line::mam::solver_mam_traffic_mmap(), line::ssa::ssa_mlmc_problem(), and line::lang::processes::stoch_comp_full().

◆ dtmc_timereverse()

template<class T>

Matrix< T > line::mc::dtmc_timereverse ( const Matrix< T > & P )

Transition matrix of the time-reversed DTMC.

Definition at line 49 of file ctmc_timereverse.h.

References dtmc_solve(), dtmc_timereverse(), and line::InputError::InputError().

Referenced by dtmc_timereverse(), and line::lang::processes::to_time_reversed().

◆ dtmc_transient() [1/2]

template<class T>

Matrix< T > line::mc::dtmc_transient ( const Matrix< T > & P )

Uniform initial law and one step, matching the one-argument MATLAB call.

Definition at line 66 of file dtmc_transient.h.

References dtmc_transient().

◆ dtmc_transient() [2/2]

template<class T>

Matrix< T > line::mc::dtmc_transient	(	const Matrix< T > &	P,
		const std::vector< T > &	pi0,
		std::size_t	steps )

Trajectory of the law over steps transitions, row k holding pi0 P^k.

Definition at line 45 of file dtmc_transient.h.

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

Referenced by line::lang::processes::chain_transient_steps(), dtmc_transient(), and dtmc_transient().

◆ dtmc_uniformization()

template<class T>

UniformizationResult< T > line::mc::dtmc_uniformization	(	const std::vector< T > &	pi0,
		const Matrix< T > &	P,
		const T &	t,
		double	tol = 1e-12,
		long	maxiter = -1 )

Transient law of a DTMC through the uniformized generator of P.

Definition at line 136 of file dtmc_transient.h.

References ctmc_makeinfgen(), ctmc_uniformization(), and dtmc_uniformization().

Referenced by line::lang::processes::chain_transient_unif(), and dtmc_uniformization().

◆ log_ordered_joint()

double line::mc::log_ordered_joint	(	const std::vector< std::vector< int > > &	caps_per,
		const std::vector< double > &	cap_tot,
		const std::vector< int > &	nj_u,
		const std::vector< std::size_t > &	b_unit_of,
		const std::vector< double > &	m_rem_u,
		const std::vector< std::vector< double > > &	log_ph_per = {},
		const std::vector< std::vector< int > > &	lev_per = {} )

inline

Log count of (placement, ordering) configurations over ALL order-preserving stations at once, POPULATION CONSERVED.

caps_per[a][k] bounds buffered class k at ordered station a, cap_tot[a] bounds the buffer TOTAL there (a finite station capacity is a slot count, not a per-class bound).

The DP state is the population still to place per POPULATION UNIT, not per class: nj_u[u] is unit u's population, b_unit_of[k] the unit of buffered class k, and unit u spreads what the ordered stations leave over m_rem_u[u] share (station, class) slots. A unit is one class, or a closed chain whose jobs switch class, whose N jobs may then take any class mix at a station.

Cutoff truncates an OPEN class's population in the network exactly as the plain stars-and-bars term treats it, so open classes are conserved too.

Definition at line 71 of file ctmc_state_space_logsize.h.

References log_ordered_joint().

Referenced by ctmc_state_space_logsize(), and log_ordered_joint().

◆ smp_passage_lst() [1/2]

template<class T>

std::vector< std::complex< double > > line::mc::smp_passage_lst	(	const Matrix< T > &	P,
		const std::vector< std::function< std::complex< double >(std::complex< double >)>	,
		&	hlst,
		const std::vector< T > &	pi0,
		const std::vector< std::size_t > &	target,
		const std::vector< std::complex< double > > &	s )

L(s) of the semi-Markov first passage time, Eqs.

4-5:

L_i(s) = sum_{k not in B} r*_ik(s) L_k(s) + sum_{k in B} r*_ik(s),

so (I - R*_AA(s)) L_A(s) = R*_AB(s) 1, one linear system per value of s.

Parameters

hlst	per-state sojourn transforms h_i(s), so r_ik(s) = P(i,k) h*_i(s) and the complex numbers stay on the DIAGONAL of the system

Definition at line 1146 of file ctmc_passage.h.

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

Referenced by smp_passage_lst(), smp_passage_lst(), and smp_passage_time().

◆ smp_passage_lst() [2/2]

template<class T>

std::vector< std::complex< double > > line::mc::smp_passage_lst	(	const Matrix< T > &	P,
		const std::vector< std::vector< std::function< std::complex< double >(std::complex< double >)> >	,
		&	hlst,
		const std::vector< T > &	pi0,
		const std::vector< std::size_t > &	target,
		const std::vector< std::complex< double > > &	s )

L(s) of the semi-Markov first passage time from the (n x n) KERNEL of transforms, the reference's non-perState branch of Eq.

5: hlst[i][k] is r*_ik(s), the transform of the sojourn in i jointly with the next state being k (so it already carries P(i,k)); an empty entry is zero. Then

(I - R*_AA(s)) L_A(s) = R*_AB(s) 1,

with R*(s) the matrix of those transforms, and P is read only for its size.

Parameters

hlst	(nstates x nstates) table of transforms, empty where the kernel has no mass

Definition at line 1204 of file ctmc_passage.h.

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

◆ smp_passage_moments() [1/2]

template<class T>

PassageMoments< T > line::mc::smp_passage_moments	(	const Matrix< T > &	P,
		const Matrix< T > &	hmom,
		const std::vector< T > &	pi0,
		const std::vector< std::size_t > &	target,
		std::size_t	nmax = 1 )

Moments of the semi-Markov first passage time from the per-state holding moments m_i(r), Eq.

7 with the u_i(r) recurrence of Eq. 8:

u_i(r) = -sum_{j=1..r} C(r,j) m_i(j) u_i(r-j),   u_i(0) = 1,

which are the derivatives at the origin of 1/h*_i(s). Cheaper than Eq. 6 because it needs no per-pair moments.

Parameters

hmom	(nstates x nmax): hmom(i,r-1) is the r-th moment of the sojourn in state i

Definition at line 955 of file ctmc_passage.h.

References line::Matrix< T >::cols(), line::InputError::InputError(), line::mc::PassageMoments< T >::m, line::mc::PassageMoments< T >::mall, line::Matrix< T >::Matrix(), line::Matrix< T >::rows(), smp_passage_moments(), and line::solve().

Referenced by smp_passage_moments(), and smp_passage_moments().

◆ smp_passage_moments() [2/2]

template<class T>

PassageMoments< T > line::mc::smp_passage_moments	(	const Matrix< T > &	P,
		const std::vector< std::vector< std::vector< T > > > &	hmom,
		const std::vector< T > &	pi0,
		const std::vector< std::size_t > &	target,
		std::size_t	nmax = 1 )

Moments of the semi-Markov first passage time from the PER-PAIR kernel moments, Eq.

6: hmom[i][k] holds the moments of the sojourn in state i when the next state is k (an empty entry is a zero vector), so the recursion runs over the kernel r_ik(t) = P(i,k) h_ik(t) directly,

M_i(q) = sum_{k not in B} sum_{r=1..q} C(q,r) m_ik(r) M_k(q-r)
       + sum_{k in B} m_ik(q),        M_k(0) = 1.

This is the reference's iscell(hmom) branch; the (nstates x nmax) matrix form above is its else branch.

Parameters

hmom	(nstates x nstates) table of moment vectors; hmom[i][k][r-1] is the r-th moment of the sojourn in i given the next state k, and the entries are expected to already carry the P(i,k) weight, as in the reference

Definition at line 1053 of file ctmc_passage.h.

References line::InputError::InputError(), line::mc::PassageMoments< T >::m, line::mc::PassageMoments< T >::mall, line::Matrix< T >::Matrix(), smp_passage_moments(), and line::solve().

◆ smp_passage_time()

template<class T>

PassageCurve< T > line::mc::smp_passage_time	(	const Matrix< T > &	P,
		const std::vector< std::function< std::complex< double >(std::complex< double >)>	,
		&	hlst,
		const std::vector< T > &	pi0,
		const std::vector< std::size_t > &	target,
		const std::vector< double > &	tset,
		const std::string &	lti_method = "euler" )

CDF and density of the semi-Markov first passage time, by inverting smp_passage_lst through api/lti.

There is no matrix-exponential route here: a semi-Markov chain has no generator to exponentiate, which is exactly the case uniformization does not reach and the transform does.

lti_method defaults to "euler" RATHER THAN "weeks". Semi-Markov passage densities are the case Sec. 4.2 singles out as slow-converging for a Laguerre series, and laplace_weeks_scaling then refuses by name rather than returning noise.

Definition at line 1269 of file ctmc_passage.h.

References line::mc::PassageCurve< T >::atom, line::mc::PassageCurve< T >::F, line::mc::PassageCurve< T >::f, line::lti::laplace_invert_cdf(), line::lti::laplace_invert_pdf(), line::lti::laplace_method(), smp_passage_lst(), smp_passage_time(), and line::mc::PassageCurve< T >::t.

Referenced by smp_passage_time().

◆ smp_stage_cif()

template<class T>

SmpStageCif line::mc::smp_stage_cif	(	const std::vector< lang::Distrib< T > > &	arcs,
		const std::vector< double > &	probs,
		const std::vector< double > &	t )

CIF and holding-time CDF of a stage at the ascending instants t.

arcs[h] is the law of the transition to stage h, DISABLED where there is none; probs is empty for competing arcs, or holds the E kernel probabilities.

Definition at line 91 of file smp_stage_cif.h.

References line::mc::SmpStageCif::C, line::mc::smp_detail::cdf_row(), line::mc::SmpStageCif::Fhold, line::InputError::InputError(), line::mc::smp_detail::linspace(), and smp_stage_cif().

Referenced by line::env::Environment< T >::hold_time_cdf(), line::infer::infer_smp_hazard(), smp_stage_cif(), and smp_stage_quad().

◆ smp_stage_quad()

template<class T>

SmpStageQuad line::mc::smp_stage_quad	(	const std::vector< lang::Distrib< T > > &	arcs,
		const std::vector< double > &	probs )

Definition at line 50 of file smp_stage_quad.h.

References line::mc::SmpStageCif::C, line::lang::dist_cdf(), line::mc::SmpStageCif::Fhold, line::InputError::InputError(), line::mc::smp_detail::linspace(), line::mc::SmpStageQuad::m, line::mc::SmpStageQuad::P, line::lang::process_to_text(), smp_stage_cif(), smp_stage_quad(), and line::mc::SmpStageQuad::U.

Referenced by line::infer::infer_smp(), line::infer::infer_smp_hazard(), line::env::Environment< T >::init(), and smp_stage_quad().

◆ stronglyconncomp()

template<class T>

SccResult line::mc::stronglyconncomp ( const Matrix< T > & A )

Strongly connected components of a directed graph, and which of them are recurrent (closed under the successor relation).

Parameters

A	adjacency matrix; an edge i -> j exists iff A(i,j) is non-zero

Definition at line 63 of file stronglyconncomp.h.

References line::Matrix< T >::cols(), line::InputError::InputError(), line::mc::SccResult::members, line::mc::SccResult::recurrent, line::Matrix< T >::rows(), line::mc::SccResult::scc, and stronglyconncomp().

Referenced by line::qn::NetworkStruct< T >::chain_visits(), ctmc_solve_reducible_blkdecomp(), dtmc_solve_reducible(), line::sn::sn_is_routing_ergodic(), and stronglyconncomp().

◆ tx_exp()

template<class T>

T line::mc::detail::tx_exp ( const T & x )

inline

exp/log/isfinite through ADL, the idiom the rest of api/mc uses: using std::exp then an unqualified call, so a Real<D> or Rational picks up its own overload.

num_traits carries no transcendental entry points.

Definition at line 112 of file ctmc_saddlepoint.h.

References tx_exp().

Referenced by ctmc_saddlepoint(), ctmc_saddlepoint_perron(), and tx_exp().

◆ tx_finite()

template<class T>

bool line::mc::detail::tx_finite ( const T & x )

inline

Definition at line 124 of file ctmc_saddlepoint.h.

References tx_finite().

Referenced by tx_finite().

◆ tx_log()

template<class T>

T line::mc::detail::tx_log ( const T & x )

inline

Definition at line 118 of file ctmc_saddlepoint.h.

References tx_log().

Referenced by ctmc_saddlepoint(), and tx_log().

◆ weaklyconncomp()

template<class T>

WeakCompResult< T > line::mc::weaklyconncomp ( const Matrix< T > & G )

Weakly connected components of the graph whose adjacency is the support of G.

Definition at line 121 of file dtmc_rand.h.

References line::mc::WeakCompResult< T >::comp, line::mc::WeakCompResult< T >::count, line::Matrix< T >::rows(), and weaklyconncomp().

Referenced by weaklyconncomp().

Variable Documentation

◆ CTMC_BYTES_PER_NZ

double line::mc::CTMC_BYTES_PER_NZ = 16.0

constexpr

8 bytes of value plus 8 amortized for the index, per stored nonzero.

Definition at line 66 of file ctmc_memory_gate.h.

Referenced by ctmc_get_calibration().

◆ CTMC_CALIB_G1

int line::mc::CTMC_CALIB_G1 = 40

constexpr

The two lattice sides the reference profiles (G1, G2 of ctmc_get_calibration).

Definition at line 75 of file ctmc_memory_gate.h.

Referenced by ctmc_get_calibration().

◆ CTMC_CALIB_G2

int line::mc::CTMC_CALIB_G2 = 80

constexpr

Definition at line 76 of file ctmc_memory_gate.h.

Referenced by ctmc_get_calibration().

◆ CTMC_DEFAULT_SAFETY_FRACTION

double line::mc::CTMC_DEFAULT_SAFETY_FRACTION = 0.6

constexpr

Fraction of available memory the solver may target.

Definition at line 68 of file ctmc_memory_gate.h.

Referenced by ctmc_memory_gate().

◆ CTMC_FALLBACK_ALPHA

double line::mc::CTMC_FALLBACK_ALPHA = CTMC_BYTES_PER_NZ * 8.0

constexpr

Fallback power-law coefficients, identical to MATLAB and Python.

Definition at line 70 of file ctmc_memory_gate.h.

Referenced by ctmc_get_calibration().

◆ CTMC_FALLBACK_AVAIL_BYTES

double line::mc::CTMC_FALLBACK_AVAIL_BYTES = 1.0 * 1024.0 * 1024.0 * 1024.0

constexpr

Conservative available-memory default when the host probe fails.

Definition at line 73 of file ctmc_memory_gate.h.

Referenced by ctmc_available_memory_bytes().

◆ CTMC_FALLBACK_BETA

double line::mc::CTMC_FALLBACK_BETA = 1.3

constexpr

Definition at line 71 of file ctmc_memory_gate.h.

Referenced by ctmc_get_calibration().

◆ CTMC_SADDLEPOINT_K2_MIN

const double line::mc::CTMC_SADDLEPOINT_K2_MIN = 5.0

static

Below this value of K2 = t*eta''(theta*) the expansion is out of its regime.

Do NOT threshold on lambda*t: for Erlang(r) the count variance rate is lambda/r, so K2 = lambda*t/r, and lambda*t over-warns on Poisson-like processes while under-warning on low-variability ones.

Definition at line 95 of file ctmc_saddlepoint.h.

Referenced by ctmc_saddlepoint().

◆ FAU_MAX_STEPS

long line::mc::FAU_MAX_STEPS = 1000000

constexpr

Default cap on birth steps, so a pathological horizon reports truncation.

Definition at line 69 of file ctmc_fau.h.

Referenced by ctmc_fau().

◆ GMRES_MIN_STATES

std::size_t line::mc::GMRES_MIN_STATES = 6000

constexpr

Order above which the direct sparse factorization is abandoned in favour of the Krylov path.

The same number the other three codebases use (ctmc_solve.m, Ctmc_solve.GMRES_MIN_STATES, ctmc.py), so a model switches methods at the same size in all four.

Definition at line 75 of file ctmc_gmres.h.

Referenced by ctmc_solve(), ctmc_solve_reducible_blkdecomp(), and ctmc_takahashi().

◆ kOrderGridMax

double line::mc::kOrderGridMax = 1.0e6

inlineconstexpr

Largest (m_1..m_K) box the exact ordered-buffer DP will walk.

Definition at line 54 of file ctmc_state_space_logsize.h.

Referenced by ctmc_state_space_logsize().

Namespaces

Classes

Enumerations

Functions

Variables

Enumeration Type Documentation

◆ SaddlepointMethod

Function Documentation

◆ ctmc_available_memory_bytes()

◆ ctmc_bicgstab()

◆ ctmc_bicgstab_multi()

◆ ctmc_courtois() [1/2]

◆ ctmc_courtois() [2/2]

◆ ctmc_fau()

◆ ctmc_foxglynn()

◆ ctmc_get_calibration()

◆ ctmc_gmres()

◆ ctmc_gmres_multi()

◆ ctmc_hitting_time()

◆ ctmc_isfeasible() [1/2]

◆ ctmc_isfeasible() [2/2]

◆ ctmc_kms()

◆ ctmc_makeinfgen()

◆ ctmc_maxabs()

◆ ctmc_memory_gate()

◆ ctmc_multi() [1/2]

◆ ctmc_multi() [2/2]

◆ ctmc_passage_lst()

◆ ctmc_passage_moments()

◆ ctmc_passage_ph()

◆ ctmc_passage_taboo()

◆ ctmc_passage_taboo_moments()

◆ ctmc_passage_time()

◆ ctmc_pseudostochcomp() [1/2]

◆ ctmc_pseudostochcomp() [2/2]

◆ ctmc_rand()

◆ ctmc_randomization() [1/2]

◆ ctmc_randomization() [2/2]

◆ ctmc_relsolve() [1/2]

◆ ctmc_relsolve() [2/2]

◆ ctmc_saddlepoint() [1/2]

◆ ctmc_saddlepoint() [2/2]

◆ ctmc_saddlepoint_perron()

◆ ctmc_sens() [1/2]

◆ ctmc_sens() [2/2]

◆ ctmc_simulate()

◆ ctmc_simulate_reference_initial_law()

◆ ctmc_solve()

◆ ctmc_solve_reducible() [1/2]

◆ ctmc_solve_reducible() [2/2]

◆ ctmc_solve_reducible_blkdecomp() [1/2]

◆ ctmc_solve_reducible_blkdecomp() [2/2]

◆ ctmc_ssg()

◆ ctmc_ssg_reachability()

◆ ctmc_state_space_logsize()

◆ ctmc_stmonotone()

◆ ctmc_stochcomp() [1/2]

◆ ctmc_stochcomp() [2/2]

◆ ctmc_takahashi()

◆ ctmc_testpf_kolmogorov()

◆ ctmc_timeaverage()

◆ ctmc_timereverse()

◆ ctmc_transient() [1/2]

◆ ctmc_transient() [2/2]

◆ ctmc_transient_on_grid() [1/2]

◆ ctmc_transient_on_grid() [2/2]

◆ ctmc_transient_sens() [1/2]

◆ ctmc_transient_sens() [2/2]

◆ ctmc_uniformization()

◆ dtmc_hitting_time()

◆ dtmc_isfeasible()

◆ dtmc_makestochastic()

◆ dtmc_rand()

◆ dtmc_simulate()

◆ dtmc_solve()

◆ dtmc_solve_reducible() [1/2]

◆ dtmc_solve_reducible() [2/2]

◆ dtmc_stmonotone()

◆ dtmc_stochcomp()

◆ dtmc_timereverse()