Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 12345]

Nline	Conservation laws of a layered queueing network, enumerated from its structure
Nag
CAgOptions
CAgResult	What the RCAT analyzer returns beyond the metrics
CAgWirePayload	One agent's static description, in the wire form the worker expects
CAgWorkerPool	The connections to every configured worker, plus the agent partition
Naoi
CAoiLstResult	[meanAoI, lstAoI, peakAoI], mirroring jline.api.aoi.AoiLstResult
CAoiPh	The (alpha, T) PH pair produced by aoi_dist2ph
CAoiResult	[meanAoI, varAoI, peakAoI], mirroring jline.api.aoi.AoiResult
Napi
Nlqn
CDistrib
CEntryWorkflow	Activity graph of one entry, as a workflow plus its execution counts
CGlobalConstants	The MATLAB GlobalConstants, as reported by lineStart at its defaults
CPhLaw	A phase-type law as the composition rules pass it around
CPrecedence	One precedence of the activity graph
CSPTree	The flat series-parallel tree
CWorkflow
CArrivalRateFun	Lambda(t), with whether it actually varies and the cycle length
CCacheActualProb	The converged cache split, per ORIGINAL class of one Cache node
CChainAggregationDeagg	Everything needed to map a chain-level result back onto the classes
CChainAggregationResult	What sn_aggregate_chains returns
CDiscreteTimeInfo	Which laws the model carries, and why it was refused when it was
CDiscreteTimeOptions	How the caller may override the automatic decision
CFjSpnStructure	What the auxiliary construction found, for one class
CFluidRtLikelihood	What the fluid likelihood call reports
CMinpsClassTrace	One class's raw trace: when its jobs arrived, and how long they took
CMinpsSetup	The prepared sample set, plus what the preparation had to decide
CMlpsSample	One observation: a response time, the tagged class, and the arrival state
CNonmarkovOptions	options.config.nonmkv and friends
COpenProbTerm	The log contribution, and whether the state carries any mass at all
CPatienceHandles	The patience law of one station-class pair, in the forms the solvers consume
CSnContractField	One NetworkStruct field; kinds and shapes are comma-separated
CSnFieldView	The view of one field
CSnFieldViews	The view of a whole struct: its dimensions and one view per contract field, by MATLAB name
CSnFluidVerdict	The verdict of sn_fluid_refusal: ok when no rule is broken, else the reason
CSnMapModulation	One modulating process: which station and classes it drives, and its blocks
CSnPnAvgRates	What sn_pn_avg_rates rewrites in place; empty tables are left empty
CSnPnFiringRates	What sn_pn_firing_rates returns; x empty means "no answer", as in the reference
CSnRtOrig	What sn_rtnodes_to_rtorig returns: the flat matrix and its per-class-pair blocks
CSnRtStations	What sn_rt_stations returns: the complemented routing and the station visits
CZeroCapacity	What sn_zero_capacity reports
Nautosolver
CAutoChoice	What a ranking resolved to, and what it had to skip to get there
CAutoEnvChoice
CAutoLayeredChoice
CAutoToken	resolveMethodToken, minus the unqualified-algorithm-name arm
CAutoTraits	The structural traits the rankings are keyed on
CResolvedVerdict	NetworkSolver.supportsResolvedMethod's answer: the gate on the resolved name
CSolverCandidate	One row of auto_find_solver: a (family, method) pair this model can be asked for, whether it runs, what kind of answer it returns and which measures it can report
Nba
CBaBounds	Port of SolverBA.getBounds: the {lower,upper} bracket of a family
CBaOptions	The options SolverBA reads
CQrfParams	options.config.qrf_params, the blocking tables the BAS and RS-RD arms need
CBaSolution	Class-level results, the [Q,U,R,T,C,X] of solver_ba_analyzer
CGlobalConstants	The MATLAB GlobalConstants, as reported by lineStart at its defaults
CSncEnvelopes	The per-pair envelopes the analyzer built, keyed by (station, class)
CSncPercentiles	The response-time and queue-length QUANTILES of the 'snc' family
Ncache
CCacheBlockedPair	One (item, list, blocking list) triple, all 0-based
CCacheGammaGraphResult	Return value of cache_gamma, mirroring the JAR's Ret.cacheGamma
CCacheGammaResult	Return value of cache_gamma_lp, mirroring [gamma,u,n,h]
CCacheIsResult
CCacheLrumMapLevelStats	Per-item level statistics, MATLAB's [prob, occ, hitfrac]
CCacheMissIsResult
CCacheMissResult	Return value of cache_miss, mirroring [M,MU,MI,pi0]
CCacheMissRmfResult	Return value of cache_miss_rmf, mirroring [M,MU,MI,pi0,tout,pi0_t,MU_t,xtraj]
CCacheMissSpmResult	Return value of cache_miss_spm, mirroring [M,MU,MI,pi0,lE]
CCacheMvaMissResult	Return value of cache_mva_miss, mirroring [M,Mk]
CCacheMvaResult	Return value of cache_mva, mirroring [pi,pi0,pij,x,u,E]
CCacheRmfExpansionTransient	Result of cache_miss_rmf_expansion_transient
CCacheRrmMeanfieldResult	Return value of cache_rrm_meanfield
CCacheSojournClock	A phase-type clock: dphi/dt = phi A, phi(t0) = phi0, density phi c
CCacheSojournResult	A sojourn average: xbar (empty when wtot is not positive), clock mass, per-user miss rate
CCacheSpmResult	Return value of cache_spm, mirroring [Z,lZ,xi]
CCacheSpmSizeResult	Outcome of the expansion
CCacheTtlLrumMapResult	Request-weighted and time-stationary level probabilities
CCacheXiFpResult	Return value of cache_xi_fp, mirroring [xi,pi0,pij,it]
Ncli
CRequest	One invocation: the argument vector, plus what a pipe would have carried
CResponse	What one invocation produced
Nctmc
CCdfCurve	A CDF as the reference returns it: the value at each point of the time grid
CCtmcAnySolution	A CTMC solve routed to whichever path the model's region rules require
CCtmcAvg	The mean performance metrics a stationary vector maps to
CCtmcChainSolution
CCtmcChainTransientSolution
CCtmcFirstPassage	The answer of @@SolverCTMC/getCdfFirstPassT.m: the [F(t), t] curve with its grid, density and resolved state sets
CCtmcFirstPassageMoments	The answer of @@SolverCTMC/getFirstPassTMoments.m
CCtmcGenerator	[infGen, eventFilt, ev] of @@SolverCTMC/getGenerator.m
CCtmcMddSolution	What one mdd solve produces beside the means, i.e
CCtmcOptions	The SolverCTMC knobs this port honours
CCtmcRateSched	One entry of options.config.rate_sched: the rate of (station, class) follows the piecewise-linear schedule (tgrid, rates) over a transient
CCtmcResult	The generator, the state space it is indexed by, and the event rates
CCtmcReward	What the reward analyzer produces, per declared reward
CCtmcSamplePath	One sampled trajectory of the chain
CCtmcSens	What one sensitivity computation returns
CCtmcSensParam	The scalar parameter a sensitivity is taken with respect to
CCtmcSensRank	One row of the ranking table
CCtmcSolution	Everything one CTMC solve produces
CCtmcStateSpace	[stateSpace, localStateSpace] of @@SolverCTMC/getStateSpace.m
CCtmcStationaryResult
CCtmcSymbolicGenerator	The outputs of @@SolverCTMC/getSymbolicGenerator
CCtmcSymbolicOptions	Backend selection, mirroring options.config.symbolic and its timeout
CCtmcSymbolicSolution	What @@SolverCTMC/getSymbolicSolution.m returns, plus the engine that answered
CCtmcTranProb	The time-dependent answer of one getTranProb* query
CCtmcTransient	What one transient CTMC solve produces
CEventOutcome	What one event produces at one node: the successor rows, their rates and their probabilities, all three the same length
CGlobalConstants	The MATLAB GlobalConstants, as reported by lineStart at its defaults
CNetState	One network state: the per-stateful-node local rows it is composed of
CNetworkStruct	A network plus its refreshed NetworkStruct
CJoinDecl	The DECLARED join rule of a Join node, by 1-based node index
CReward	sn.reward: the user-declared reward functions, MATLAB's model.setReward(name, fn)
CRegion	FINITE CAPACITY REGIONS, MATLAB's refreshRegions output
CPasParam	The pass-and-swap / order-independent parameters of a PAS station, keyed by station index (Dorsman and Gardner 2024, Sect
CPollingParam	The polling controller of a POLLING station, keyed by station index
CSync	One synchronization: an ACTIVE event and the PASSIVE event it drives
CWaitqResult	The chain the WAITQ walk produces, alongside the FIFOs its states carry
CWaitqSolution	A solved WAITQ model: the usual CTMC solution, plus what the FIFOs hold
CWaitqState	One augmented state: the network state, plus the token FIFO of every region
Nda
CCacheIsolateResult	Return value of da_cache_isolate, mirroring [gamma,lambda_cache,Rcost]
CCacheParam	The fields of sn.nodeparam{cache} that da_cache_isolate reads
CCacheqnInfo	The converged isolated-cache inputs, kept for per-item occupancy reporting
CCacheqnResult
CCacheqnRetrievalResult	What the delayed-hit decomposition returns
CFpiOptions	Options mirroring the fields MATLAB reads off the options struct
CFpiResult
Ndpfqn
CDtNcResult	Constants of the state independent cycle, in one common scale
CDtNcLdResult	Constants of the state dependent cycle, in one common scale
Ndqsys
CBernoulli1InfiniteResult	The reference's unbounded-buffer branch (L = Inf), bernoulli1_infinite: the Geo/Geo/1 closed form under the LAS-DA convention, with the queue-length laws returned as functions of n as the reference returns handles
CBernoulli1Result	Steady-state quantities of a finite-buffer Bernoulli server
CGeoGeo1Result
CGeoXGeo1Result
Nenv
CEnvAnalyzerSolution	What the ENV entry reports: the environment-blended metrics, and the whole result of whichever coupling produced them
CEnvArc	One arc of the environment process
CEnvCompression	Everything applyCompression computes, plus the compressed environment
CEnvCompressOptions	The knobs applyCompression reads out of options.config
CEnvDecomp	What SolverENV.ctmc_decompose returns: [p, eps, epsMax, q]
CEnvGenerator	The outputs of getGenerator, in the reference's order
CEnvironment
CReliability	getReliabilityTable: MTTF, MTTR, MTBF and availability of an environment built out of node breakdowns
CStageRow	getStageTable: one row per stage
CEnvLimitSolution	What a limit solve reports
CEnvMeanfieldSolution	A mean-field solve, with the compression that produced it
CEnvOptions	Options of SolverENV
CEnvSolution	What SolverENV reports
CEnvStage	One stage: a name, a category, and the model in force while it lasts
CEnvStageAvg	What one stage solve reports back to the limits
CEnvStageEvent	One environment transition event, the reference's Event(STAGE, node, NaN, NaN, [e,h])
CEnvStatevecOptions	Options of the state-vector coupling
CEnvStatevecSolution	What the state-vector coupling reports
CNodeFailure	Environment.nodeFailures{k}: the declarative record of one node breakdown
CSolverEnv	The environment solver
CSolverEnvLimit	The limit solver
CCacheAccum	The RATE accumulator behind the cache blend, SolverENV.accumCacheMetric
CSolverEnvStatevec	The state-vector environment solver
Nfes
CFesAggregateResult	What fes_aggregate returns
CFesConditionalMetrics	The per-population tables the conditional sum is taken over
CFesDeaggInfo	Everything needed to map an FES result back onto the original model
CFesIsolated	Demands and visit ratios of the isolated subnetwork
CFesMapAggregateResult	The load-dependent MAP that replaces a subnetwork, with its descriptors
CFesMapDeaggregateResult	Per-station metrics an aggregate stands for
CFesMapMoments	Descriptors a MAP(2) is fitted against
CFesMapSolveResult	System metrics of the delay plus flow-equivalent server model
CFesOptions	options of the reference; the solver field is implied by the convolution
CFesValidateResult	The reference's (isValid, errorMsg) pair
Nfj
CFJAmvaResult	[R, Q, X, U] of fj_amva
CFJBoundsResult	[Rmax, Rmin] of fj_bounds: pessimistic and optimistic response-time bounds
CFJCharMaxBlomResult	[mK, lo, hi] of fj_char_max_blom; lo and hi are NaN below K = 5
CFJCharMaxDiscreteResult	[MK, mK, exact] of fj_char_max_discrete
CFJCharMaxResult	[MK, mK] of fj_char_max: characteristic maximum and its threshold
CFjCodesGenService	generateService.m: the service process seen by a tagged job
CFjCodesPercentiles	One line of mainFJ's output cell: the percentiles of a K-node queue
CFjCodesPi	What computePi.m returns
CFjCodesRT2	What returnRT2.m produces, plus the waiting-time law it discards
CFjCodesSA	build_SA.m: the level-constant generator and the head-of-line jump
CFjCodesServiceH	build_Service_h.m: the two-subtask phase process of one fork-join job
CFjCodesSRK	constructSRK.m: the extended generator and the busy/idle projectors
CFjCodesT	What computeT.m returns
CFjCodesWait	What returnWait.m returns: the waiting time as a phase-type law
CFJCoxFitResult	[mu1, mu2, q, kmin, kmax] of fj_cox_fit
CFJDagMakespanResult	[C, I, Cend, E] of fj_dag_makespan
CFJDelayOptResult	[d, Edisp, Emax] of fj_delay_opt
CFJDispersionResult	[Edisp, Emax, Emin] of fj_dispersion
CFjDist	Descriptor of an arrival or a service process
CFJGKBoundResult	All four G(K) factors of fj_gk_bound in its 'all' mode
CFJIsmGreenResult	Everything Green's cycle decomposition produces
CFJOrderStatResult	[F_Yk, E_Yk] of fj_order_stat
CFJQgbResult	[Q, y] of fj_qgb: the bounded queue lengths and the geometric ratios
CFJQuorumMomentsResult	[m, v] of fj_quorum_moments: mean and variance of the k-of-n join time
CFJResptBulkResult	[Rreq, Rtask, Q, p] of fj_respt_bulk
CFJResptClosedResult	[R, exact] of fj_respt_closed
CFJResptNosplitResult	[R, rho] of fj_respt_nosplit
CFJSerializationResult	[P, delay, Rtot] of fj_serialization
CFJTsmCapacityResult	[Lmax, Llp, Lfcfs, states, prob] of fj_tsm_capacity
CFJXmaxApproxResult	[Xmax, GK] of fj_xmax_approx
CFJXmaxCoxianResult	[Xmax, m1, c2] of fj_xmax_coxian
CFJXmaxHzResult	[Xmax, resid] of fj_xmax_hz
CFJXmaxNormalResult	[Xmax, Vmax] of fj_xmax_normal
CFJXmaxParetoResult	[Xmax, MK] of fj_xmax_pareto
CForkTailResult	Mirrors MATLAB's [xp, alpha, beta] return list
CLqnBranchView	The four LayeredNetworkStruct fields fj_branch_members reads
CMg1ResptMoments	Mirrors MATLAB's [ET, VT] return list
Nfluid
Npetri
CMinMulti	The result of the many-argument closure
CPetriConservation	The conserved quantities of a net, as equations
CPetriConstraints	Every finite place capacity as a linear row A x <= b, and the two bounds of every fluid place
CPetriImmediate	The active set of the immediate modes and the equations pinning their flows
CRow
CPetriMode	One firing mode of one transition, with its arcs and its firing process
CPetriOptions	Tuning of the outer solve
CPetriReport	What the Petri route computes that the station table has no column for
CFluid	MATLAB moments.petri.fluid: per fluid place its name, reported level and level variance, its unthrottled mean drift, the variance rate of its net inflow (filled only by the diffusion refinement), the bound it is held at (+1 capacity, -1 empty, 0 none), and the fluid_boundary mode in force
CPetriSolution	Everything solver_fluid_petri returns
CPetriTerms	The assembled drift terms of a net
CPetriTheta	The closed enabling term of every mode and its derivative
CPetriVerdict	Whether the fluid Petri route can answer this model, and why not
CAoiMe	A matrix-exponential age law: P(age > t) = g exp(A t) h
CAoiParams	The (tau, T) / (sigma, S) pairs and the preemption probability
CAoiSolution	Both age laws of one system, with the policy parameter that produced them
CAoiTopology	What the AoI gate found, when it matches
CClosureValue	A closure's value and its first two derivatives with respect to the first mean
CDiffusionOptions	Controls of the Euler-Maruyama trajectory
CDiffusionResult	Steady-state averages of the diffusion trajectory
CExpansionWeight	How much of the second-order correction the series admits, and d tau / d ratio
CFluidAoiResult	What the AoI branch of mfq returns: the age laws and the metrics beside them
CFluidCacheqnSolution	What the steady analyzer returns: the fluid metrics plus the converged split
CFluidCacheqnTranCache	One cache's transient, the per-cache slice of the reference's 3-D outputs
CFluidClosure	The second moment the drift closes its non-linear terms with, i.e
CFluidDaeConservation	Population conservation, one row per CLOSED chain, in state space
CFluidDaeConstraints	Finite capacity regions as linear admission constraints on the fluid state
CFluidDaeGates	Which events each cap throttles, and what happens to the mass it stops
CFluidDaeLegs	The two legs of every event under the active caps, and the waiting rooms
CFluidDaeNewtonInfo	What the Newton reports about where it stopped
CFluidDaeOptions	Options that only the DAE route reads
CFluidDaeStaging	The waiting room outside a capped region, as fluid coordinates
CFluidDaeSwitch	What a hybrid transient did, beside the trajectory
CFluidDaeSystem	Everything the residual needs, gathered so the Newton can stay generic
CFluidEvent	One event of the drift
CFluidImmediateMatrix	What the matrix-level elimination produced
CFluidImmediateResult	What an elimination attempt produced
CFluidJacobian	The four outputs of @@SolverFLD/getJacobian
CFluidKpTransient	The transient the covariance equation produces, i.e
CFluidLayout	Where each (station, class) block sits in the state vector
CFluidLyapunovInfo	The reference's MException('LINE:FluidNonHyperbolic'), as a type
CFluidMatrixSystem	The assembled matrix-form drift and the maps that read metrics off it
CFluidMfqAdmits	Verdict of fluid_mfq_admits
CFluidMomentReport	The second-order results of the moment-closure methods, i.e
CFluidMomentTerms	Port of fluid_moment_terms.m: the event representation of the fluid population process, plus the drift, rate and Jacobian handles the covariance equation needs
CFluidNonHyperbolicError	Raised when the moment closure cannot serve this model: the linearization at the fixed point is not hyperbolic, or the drift has left the simplex
CFluidOdeSystem	The assembled drift: the layout, the events, and the per-station schedule
CFluidOptions	Controls, defaulting to SolverOptions('Fluid') in the reference
CRateSched	options.config.rate_sched: explicit per-(station, class) rate trajectories, the third source solver_fluid_ratemult composes
CFluidPassage	The response-time CDF of one (station, class), sampled on a grid
CFluidRateMult	Port of solver_fluid_ratemult.m's output: a per-event MULTIPLIER on a time grid, evaluated by fluid_interpcols
CFluidRefineInfo	What fluid_refine_meanfield reports about the correction it computed
CFluidSingleQueue	The single-queue topology the reference reads, in 0-based indices
CFluidSolution	What the analyzer returns, in the same shape as the MVA solver's result
CFluidStateDepSystem	Everything the state-dependent drifts read, lowered once to doubles
CFluidStiffOptions	Controls for the stiff arm
CFluidSymbolicDrift	The drift as expression strings, one per state variable, plus their names
CFluidSymbolicJacobian	What @@SolverFLD/getJacobian returns: d f_i / d x_j as expression strings
CFluidSymbolicOptions	Backend selection, mirroring options.config.symbolic and its timeout
CFluidSymSystem	The symbolic system, in whichever of the two forms the method implies
CFluidTranPoint	One point of a transient trajectory: the metrics at time t
CKpBlock	One (station, class) block of the Ko-Pender state vector
CKpEvent
CMfqPrioResult	Per-class metrics of the priority queue, indexed by class
CMfqResult	The metrics mfq reports for its single queue
CMfqTopology	What the single-queue gate found, when it matches
CShareValue	A share closure's value and Jacobian, and the joint-closure covariance
CSymFactor	The state-dependent factor attached to one event's driving variable
CTbiOptions	Controls of the time-based iteration, mirroring options.config.tbi_*
Ngen
CLayeredNetworkGenerator	A random lqn::LqnBuilder<T> source, configured once and then drawn from
CMatlabRng	One MATLAB global random stream, as left by rng(seed)
CNetworkGenerator	A random qn::Network<T> source, configured once and then drawn from
CRange	A closed interval the generator samples from
Nhttp
CHttpError	Transport-level failure: unresolvable host, refused connection, timeout
CResponse	An HTTP response, with the body already de-chunked
CUrl	The pieces of an http:// URL this client needs
Ninfer
CConditionEvent
CEkfOptions	MATLAB's OPTIONS struct, with the same defaults infer_lqn_optget supplies
CEkfResult	MATLAB's [ahat, info] return list
CEstimatorOptions
CGibbsOptions	MATLAB's hard-coded budgets, exposed with their MATLAB values as defaults
CGibbsSlice	The deterministic content of one coordinate update
CGibbsStateProbs	The empirical state distribution built from the traces
CGibbsTrace	One class's trace
CInferLqnOptions	MATLAB's OPTIONS struct for infer_lqn, with the same defaults the infer_lqn_optget calls supply
CInferLqnResult	MATLAB's INFO struct: the EKF result plus what the driver constructed
CJacobianResult	Mirrors the [H, h0] return list of the MATLAB function
CLqnMetrics	Per-element metric vectors, each aligned with the element name list
CLqnObsSpec	One row of MATLAB's OBSSPEC struct array
CLqnParamSpec	One row of MATLAB's PARAMSPEC struct array
CNhppKsResult	Outcome of the KS test
CParamEstimator
CSampledMetric
CSmpArc	One fitted transition
CSmpEnvOptions	Options of infer_smp_env
CSmpFit	What infer_smp returns
CSmpHazard	Both hazard functions of one transition, rows aligned with the instants asked for
CSmpNelsonAalen	One Nelson-Aalen estimate, on the distinct event times of its transition
CSmpOptions	Options of infer_smp, the reference's name/value pairs
CVariationalOptions	Options of infer_variational; a negative box means "derive a default"
CVariationalResult	Outcome of infer_variational
CVariationalSpec	Inference problem handed to infer_variational
Nio
Ncode_gen_detail
CProcSpec	One (station, class) process, reduced to what QN2MATLAB / QN2JAVA decide on
CRoute	The (k, c, i, m, p) of every positive sn.rtnodes entry, in QN2MATLAB's loop order, 0-based
Njmva_detail
CElement
CCitation	One bibliography entry
CDistrib
CExactValue	An exact scalar as it crosses to a host without a rational type: the two decimal integer strings, plus the double a host can use directly
CJmtDistView	The (D0, D1) pair a JMT MAP or phase-type parameter block is built from, plus the moments the analytic families are reconstructed from
CJmtSections	The three JMT section class names of a node: input, server, output
CJmtWriteOptions	The simulation controls the JSIM header carries, MATLAB's JMTIO properties
CJmtWriter	The writer itself
CMap2RenvInfo	The INFO output of map2renv: how the stage set was assembled
CPasSaturation	The per-class saturation cutoffs of a count-indexed rate table
CQnModel
CTikzEdgeRouter
CTikzGraph	Nodes in model order plus sn.connmatrix over them
CTikzLayout	Node positions in cm, indexed like TikzGraph::nodes, and the layers that produced them
CTikzNode	One node as the TikZ exporter sees it
CTikzOptions	Layout and rendering options of the network TikZ exporter (TikZOptions)
CTikzPoint	A waypoint in cm
CTikzViewResult	What tikz_view produced
CWfCommonsOptions	The loader options; the defaults are the reference's parseOptions
Njmt
CJmtEvent	One logged event: when, of which kind, in which class, for which job
CJmtLogFile	One arrival or departure CSV file, as three parallel columns
CJmtMeasure	One <measure> of a JMT result document, by its attributes
CJmtNodeTrace	The per-class queue-length trajectory of one node, plus its event stream
CJmtOptions	The options of one JMT solve, SolverOptions('JMT') restricted to what is read
CJmtProbAggr	What jmt_prob_aggr reports: the system probability and the per-station ones
CJmtReplication	Transient averages over independent replications, on one time grid
CJmtResult	The result of a JMT solve: the shared AvgResult plus what only JMT reports
CJmtSysTrace	The system trajectory: one per-class block per station, on a common grid
Nlang
Nprocesses
CMarkovChainModel	A user-supplied chain: a MarkovProcess when discrete is false, else a MarkovChain
CProbStateResult	What getProbState returns: the probability and the two determinants behind it
CTransientAtResult	What the CTMC transient returns: the law at t and the truncation it used
CTimeAverageOut	What timeAverage returns
CAggregateResult	What aggregate returns: the approximate law and the two NCD indices
CStochCompOut	What stochCompFull returns for a CTMC; a DTMC fills the same blocks from P
CChainPath	A sampled path: the states visited, with their holding times for a CTMC
CDistrib
CGlobalConstants	The MATLAB GlobalConstants, as reported by lineStart at its defaults
CPriorDesign	A Prior reduced to alternatives and weights; the output of prior_discretize
CPriorRng	The uniform stream the Monte Carlo design draws from
CPriorSpec	A LINE Distribution, as the model layer and sn carry it
Nldes
Nengine
CAccum	The running per-(station, class) integrals and tallies
CBpTarget	One measured target: a station set, optionally filtered to one class
CBusyPeriods	The busy-period tracker of one run
CCacheState	Live state of one Cache node
CHeldRequest	A request parked while its item was being fetched
CConvergence	Convergence-based stopping: batch the four metrics and stop once EVERY active (station, class) pair has reached the requested relative precision
CEvent	One scheduled event
CEventLater	Later-is-greater, so the priority queue pops the earliest event
CJob	A job held by a station
CLnCacheAccess	One ItemEntry read: its driver activity, its item law and its two branches
CLnCacheState	Live content of one replica of a cache task, LNCacheState of the Java engine
CLnCustomer	A reference-task customer: it thinks, then starts an invocation
CLnEntryCdf	One entry's empirical response-time CDF: F[j] = P(R <= t[j])
CLnEvent	One scheduled event of the layered engine
CLnEventLater
CLnInv	One invocation of an entry: what a call or a reference cycle starts
CLnJoin	Progress of one AND join within one invocation, JoinProgress of the Java engine
CLnLine	One LINE of execution: a point in the activity graph of one invocation
CLnResult	The layered result: per element, the mean measures
CObservations	The event-spaced observation series MSER-5 and the CI both read
CPsJob	A job being served by a sharing discipline, with the work it still owes
CRegion	One finite capacity region, resolved to what the event loop needs
CRng	The engine's randomness, in the SHAPE the Java engine uses it
CRouteDest	One destination NODE of a (node, class) pair, with the class it switches to
CRouteEntry	One routing alternative out of a (node, class) pair
CSampler	One variate generator, holding whatever state its family needs
CSpnMode	One mode of a transition, resolved to what the event loop needs
CSpnTransition	One Transition node
CStationState	One station's mutable state
CBalkRule	Balking: the (min, max, probability) triples an arrival consults
CStatTriple	Grand mean, standard error and degrees of freedom of a batch-means estimate
CTruncation	Where the warmup ended, and whether a truncation was applied at all
CWaitCmp	The waiting-room order of a buffered discipline
CLdesCacheMetrics	Per-cache hit/miss/latency, as the cacheMetrics block carries them
CLdesOptions	The knobs of one LDES run
CLdesResult	One ldes-result document, parsed
CBusyPeriodTarget	One measured busy period target (–busyperiod): a station, a station-class pair, or a declared station set
CLdesRunner	One runner: the argv prefix that runs the engine, and the name of its image
CLdesStateQuery	One constraint of a joint-state query: a station and the per-class job counts it is required to hold
Nln
Nzc_detail
CZeroCapacity
CDistrib
CGlobalConstants	The MATLAB GlobalConstants, as reported by lineStart at its defaults
CLayerResult	Per-layer results of one iteration, the [QN,UN,RN,TN,AN,WN] of getAvg
CLnCdf	A CDF sampled on a grid, the [F, t] pair MATLAB's evalCDF returns
CLnInterlockChoice	The interlock tracking method a run will use, and why it differs from the request
CLnLayerBlocks	LayeredNetwork.layerBlocks: where each layer's block sits in the aggregate
CLnOptions	Options of SolverLN
CLnSensTable	GetSensitivityTable of the ensemble: the layer tables under a Layer column
CRow
CLnSolution	The LQN-level answer, indexed by element 1..nidx
CLnStochConfig	options.config.stochiter_* of SolverOptions.m, with its defaults
CLnStochController	Convergence controller for an ensemble whose layers are solved by a NOISY method (simulation, or Monte Carlo normalizing constants)
CLnTranLayer	One layer's block of the layered transient
CLnTranSolution	The layered transient: one block per layer, plus how it was produced
CLnZeroCapacity	The structural answer of ln_zero_capacity; see the file header
CLqnCallGroup	One routed call group: an activity, the strategy that picks among its targets, and the target ENTRIES in declaration order
CLqnStruct
COvertakeCtmcState	Stationary law of the three-state overtaking chain, in its own order
CSolverLN
Nlossn
CErlangFpResult
CLossnManjunathOptions	Controls of lossn_manjunath
CLossnManjunathResult	Result of lossn_manjunath
CLossnMciOptions	Options of lossn_mci, MATLAB's options struct
CLossnMciResult	Result of lossn_mci
CLossnRecResult	Carried load, blocking, log normalising constant and walk count
Nlp
CLpSolution
CLpModel	Sparse LP in the natural form, with per-variable bounds
Nlqn
Nnlp_detail
CLldEvalError	An evaluation failure, carrying the python exception name the message reports
CLldSyntaxError	A parse failure: the text is not an expression of the grammar
CLldExpr	An lld expression, parsed once and evaluated over std::complex<double>
CForkBlock	One AND-fork/join block, in absolute LQN indices
Nsrvn_detail
CTok
CVal	A number as written: its source spelling and its value
CCall
CWork	An entry phase or an activity: the s, c, f, Z, M values and the calls
CProc
CGroup
CTask
CEntry
CConn
CActs
CModel
CParser
Nsrvn_out
CCallRow
CElement
CTaskRef
CBoolGraph	A boolean sparse relation over element indices, e.g
CDistrib
CLqnBalanceEquations	The relation set of one layered model
CLqnBoxBounds	What lqn_boxbounds returns, in the layout of the reference's out struct
CLqnBuilder
CLqnCallGroup	One routed call group: an activity, the strategy that picks among its targets, and the target ENTRIES in declaration order
CLqnModel	The intermediate model, and the second stage that flattens it
CLqnMolInfo	Everything lqn_mol reports beyond the four measure vectors
CLqnMolOptions	Tuning of the outer fixed point
CLqnMolResult	The four (nidx+1) vectors in the column convention SolverLN and LQNS report, so they line up with LN(model).getAvgTable cell for cell
CLqnPrecedence	One activity precedence of a task, with its activities resolved to indices
CLqnRefCall	One row of calls: the reference's [cidx, fromPos, toPos, aidx, vCall]
CLqnRefGroup	One group, the reference's R(g): the DAG below one REF task
CLqnRefRoutes	What lqn_ref_routes returns: the groups, or a non-empty why and no groups
CLqnRelation	One conservation law, as an aggregation over a node's structural neighbours
CLqnSolution	The iterates of a solved layered model, indexed by ABSOLUTE element index
CLqnStruct
CLqnWriteReport	What the schema could not carry, one human-readable line per loss
CNlpLld	A declared queue-dependent rate multiplier of one station: an expression in n, or a tabulated lldscaling row, which is refused because its interpolant has a corner at every knot
CNlpOptions	Options of the program: python export_nlp(lld=, alpha=, fork=)
CNlpProgram	The program of one layered model
CBil
CNlt
CMnl
CSweep
CNlpRate	The queue-dependent rate of one station, r(n) = softmin(n, m) [* lld(n)], or n at a delay
CNlpSolveResult	What NlpProgram::solve returns: python's Result
CServerPools	Heterogeneous server pools declared on a layer server, the twin of the nservertypes / servertypenames / serverspertype / servercompat / heterorates block a Network carries in sn.nodeparam{i}
CSparseGraph	A sparse square matrix over element indices, held as a dense vector of rows with an explicit nonzero list per row
Nlqns
CLqnsOptions	Knobs of the wrapper, the subset of SolverOptions that reaches lqns
CLqnsRawAvg	Everything the .lqxo carries, indexed as the struct is
CLqnsSolution	The six measures, on the element index space, with a defined mask each
CQnsOptions	SolverLQNS.defaultOptions on a flat Network plus the knobs the JMVA document carries
CSolverLQNS	The layered model solved by lqns or lqsim
Nlsn
CMultiplicity	A multiplicity, possibly infinite; MATLAB's mult(i) = Inf
CLsnInput	The plain-data fields of a layered software network read by the algorithm
Nlti
CWeeksParams	A Laguerre expansion: the damping, the scaling and the coefficients
Nmam
Niltcme
CCmeEntry	One CME entry, carrying only the fields matlab_ilt reads
Nreneging_detail
CRenegingMetrics	The station metrics of the MAP/M/s+G queue
CAmap2AdjustGammaResult	Result of amap2_adjust_gamma
CAmap2FitGammaResult	Result of amap2_fit_gamma
CAph2AdjustOptResult	Result of an optimization-based APH(2) moment adjustment
CAph2AdjustResult	Result of aph2_adjust
CAph2FitResult	Result of aph2_fit
CAphFitResult	Result of aph_fit
CAphPair	A matrix-exponential law in (alpha, S) form: initial vector and subgenerator
CBgchainCtmc	The solved background modulating chain
CBgchainEnv	The environment one station sees: the background chain lumped onto its occupancy
CBgchainStation	What one modulated station QBD returns
CBmapMap1Blocks	The level blocks of solver_mam_bmap_map_1.m
CBmapQueueResult	What both reference files return once the ETAQA solve has run
CCmeRepresentation	The unit-mean (alpha, A) form of a CME, with the SCV it attains
CCQbdFundMat	G and R of a QBD whose local block is complex
CDmap	A discrete-time MAP: substochastic D0 (no arrival) and D1 (one arrival)
CDph	A discrete phase-type law: initial row vector alpha and transient A
CDtQueueResult	Outcome of a slotted station solve
CFjSyncMap	sn_build_fj_sync_map: which incoming flows at a Join must be synchronized
CFluidFundamental	Psi, K and U of a fluid queue with drifts normalized to +-1
CFluidPrioOptions	Which measures to compute, and the numerical options
CFluidPrioResult	One entry per analyzed class, in the order given by FluidPrioOptions::classes
CGeneralFluidSolution	Stationary matrix-exponential solution of a general Markovian fluid model
CGlobalConstants	The MATLAB GlobalConstants, as reported by lineStart at its defaults
CHyperexpLongtailOptions	The reference's name-value options: k, c1, b, decade, points (empty = unset)
CHyperexpLongtailResult	Outcome of the long-tail hyperexponential fit
CHyperParams	Rates and branch probabilities of a hyperexponential given as a MAP
CLdqbdAvg	Per-(station,class) means read off an arbitrary distribution over the LD-QBD
CLdqbdBlocks	The LD-QBD blocks and parameters, the reference's optional eighth output
CLdqbdFlat	The flat generator of an LD-QBD, with the level each flat state belongs to
CLdqbdMphcBlocks	The three block lists of a level-dependent QBD, as ldqbd takes them
CLdqbdPi	Stationary distribution of a level-dependent QBD, per level and per phase
CLdqbdResult	R and the stationary distribution together (ldqbd.m)
CLdqbdSolution	What the analyzer returns: the metrics plus the blocks it built them from
CLevelDependentFluidBlocks	The matrix-exponential building blocks of a multi-regime fluid queue, the output of mfq_ld_solve
CLibQbdProcess	A QBD's level blocks, as libQBD's QBD class holds them
CM3pp22FitcCovResult	Result of the covariance-matching M3PP(2, 2) fits
CM3pp22InterleaveResult	Result of m3pp22_interleave_fitc
CM3pp2mFitcApproxResult	Result of the optimization-based M3PP(2, m) fits
CM3pp2mFitcResult	Result of m3pp2m_fitc
CM3pp2mFitcTraceResult	Result of m3pp2m_fitc_trace
CM3ppSuperposResult	Result of the superposition fits
CMamap22FitResult	The fitted MAMAP(2,2), what it achieved, and whether the fit was exact
CMamap22FsFitResult	The forward-plus-sigma result; warning carries the reference's diagnostic
CMamap2mCoefficients	The three coefficient tables of one canonical form
CMamap2mFitResult	The fitted MAMAP and the moments it achieved
CMamFjInfo	What fj_is_homogeneous.m returns: the fork-join pair, or why there is none
CMamFjParams	What fj_extract_params.m returns: one arrival and one service per class
CMamOptions	The options SolverMAM reads
CMamRenegingInfo	What mam_reneging_applicable.m returns: the station it found, or why it found none
CMamRetrialConfig	The knobs solver_mam_retrial.m reads from options.config and from model fields the C++ NetworkStruct does not carry
CMamRetrialInfo	What qsys_is_retrial.m returns: the station it found, or why it found none
CMamSolution	What the MAM dispatch returns: the metrics plus the algorithm that ran
CMamSyncParams	What qsys_mgck_sync needs, read off the model by mam_sync_refusal
CMap	A MAP as the pair of matrices (D0, D1)
CMap2FitIdcResult	The fitted process and which of the reference's five outcomes produced it
CMap2FitResult	Result of map2_fit: the MAP plus the reference's ERR code
CMap2mmppResult	Result of map2mmpp
CMapAnfitResult	What map_anfit returns: the fitted MAP and the ladder it was built on
CMapBmap1Blocks	The level blocks of solver_mam_map_bmap_1.m
CMapGammaResult	Result of map_gamma, mirroring the MATLAB [GAMMA, RHO0] pair
CMaph2mFitResult	The fitted MAPH and the backward moments it actually achieved
CMapM1psResult	What the two MAP/M/1-PS sojourn entry points return
CMapMap1Exact	Result of the fast path; ok false means the model is not in its regime
CMapOptimDist	What an optimizing distance fit returns
CMeRepresentation	A matrix-exponential or phase-type representation (alpha, A)
CMeSampler	Stateful ME sampler holding the inversion table
CMmap	An MMAP: the underlying MAP plus the per-class arrival matrices
CMmapDecConfig	The options.config fields the MMAP decomposition reads on top of MamOptions
CMmapKFitResult	A marked MAP and whether the marking system was solved exactly
CMmckDetection	What mam_detect_mmck returns; muRate is meaningful only when isMmck
CMmpp2FitcApproxResult	Result of mmpp2_fitc_approx
CMmpp2FitcResult	Result of mmpp2_fitc
CMmpp2FitResult	Result of the (mean, scv, skew)-parameterized MMPP(2) fits
CMnaConfig	The options.config fields the two MNA analyzers read
CMultiRegimeResult	Return value of mfq_multiregime: one row of N per-state values per point
CPhService	One class's phase-type service law, He's (sigma_k, S_k)
CPhType	A phase-type representation (alpha, T) of a MAP's inter-arrival time
CPrioQueueOptions	Options shared by both priority analyzers (the BUTools 'erlMaxOrder' and 'prec')
CProbTable	The joint (level, phase) table getProb returns: rows levels, cols phases
CQbdBmapBmap1Blocks	The level blocks assembled by qbd_bmapbmap1
CQbdFundMat	G and R together, as returned by qbd_fundmat
CQbdMapMap1Blocks	The four level blocks of the MAP/MAP/1 QBD
CQbdMapMap1Result	Result of qbd_mapmap1, mirroring the MATLAB return list
CQbdRapRap1Result	Everything qbd_raprap1 returns
CQbdRapResult	Everything qbd_rap returns
CQbdRg	R, G and the level blocks of a MAP/MAP/1 queue (qbd_rg.m)
CRespTCdf	One class's response-time CDF, the reference's RD{station, class} = [F, X]
CSampleTrace	The state a sampled inter-arrival began and ended in
CSetupDelayoffClosed	Mean queue length and throughput of the CLOSED setup/delay-off queue
CSetupDelayoffMMk	Mean number present and throughput of the setup/delayed-off pool
CStDistrPh	A phase-type law (alpha, A) as BUTools' 'stDistrPH' returns it
CTaylorSeriesResult	What the adaptive Taylor series returns: the reference grid and its laws
CTrafficConfig	The fields of options.config the traffic step reads
CTranCurve	One station-class transient curve, the reference's [metric, time] pair
CTranResult	What getTranAvg returns: queue length, utilization and throughput curves
CTransientQbd	The piecewise QBD blocks, 1-based exactly as the reference's cell arrays
Nmapqn
CLrMvaIndex	Variable layout: UN, then QN, then B, in the reference's declaration order
CLrMvaParams	Parameters of the MVA-shaped LR bound, mirroring the reference's params
CLrPfParams	Product-form parameters of the LR bound, mirroring MATLAB's params
CLrPfResult	Return value of mapqn_bnd_lr_pf, mirroring the MATLAB result struct
CMapqnAmvaResult	X: class throughputs; Qq: mean queue lengths at the MAP station (job in service included); U: busy probability per class, X E[S]; ES: mean service times; pi: joint phase law at N (class R fastest)
CMapqnBndLrMvaResult	Result of an MVA-shaped LR bound solve
CMapqnBndLrResult	Result of a general LR bound solve
CMapqnBndQrResult	Result of a general QR bound solve
CMapqnP1Index	Variable layout of the p1-level models
CMapqnParams	Parameters of a MAP queueing network for the QR bounds
CMapqnQrResult	Result of a QR bound solve
CMapqnSolution	Objective value and the name-keyed variable table of one bound program
CP2Index	Flat index of the joint variable p2(j,nj,k,i,ni,h)
CQrBasIndex	Variable layout: p2(j,nj,kj,i,ni,hi,m) then e(i,ki)
CQrBasParams	Parameters of the BAS bound, mirroring the reference's params
CQrBasResult	Result of a BAS bound solve
CQrfAffine	An affine residual map recovered as (A, b) with fn(x) = A x - b
CQrfConstraints	The two constraint blocks: g(x) <= 0 and h(x) = 0
CQrfMetrics	The utilizations and queue lengths read off an optimal pair tensor
CQrfRates	The transition rates the constraint inventory reads
CQrfReduced	The equality block with its dependent rows dropped
CQrfVars	The unflattened decision vector: the pair tensor and the effective rates
CQrRsrdIndex	Variable layout: p2(j,nj,kj,i,ni,hi), then U(i,k,n) and Ueff(i,k,n) for n >= 1, then pb(i)
CQrRsrdParams	Parameters of the RS-RD bound, mirroring the reference's params
CQrRsrdResult	Result of an RS-RD bound solve
Nmc
CBicgstabMultiResult
CBicgstabResult
CBlkDecompResult
CCourtoisResult
CCtmcCalibration	The per-host power-law fit, the reference's calib struct
CCtmcGateResult	The gate verdict, plus the message the caller reports either way
CCtmcPath	One simulated sample path: the state visited at each step and its holding time
CCtmcSizeOptions	Options the estimator reads; only the cutoff matters
CCtmcSsgOptions	The reference's options read here: options.cutoff and the state cap
CCtmcSsgResult	The reference's [stateSpace, stateSpaceAggr, stateSpaceHashed, nodeStateSpace]
CFauResult
CFoxGlynnResult
CGmresMultiResult
CGmresResult
CKmsResult
CLcgUniform	Deterministic uniform [0,1) source, so that a caller who does not have one still has no reason to reach for a global stream
CMultiResult
CPassageCurve	A passage-time law on a grid
CPassageMoments	Moments of a first passage time, [Mall, m] of the reference
CPassagePh	The phase-type form of a first passage time
CPassageTaboo	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
CPassageTabooMoments	Conditional moments under a taboo set, [mall, m, pB] of ctmc_passage_taboo_moments.m
CPerronState	Perron root of A(theta) with its first two derivatives and the amplitude
CPseudoStochCompResult	Blocks of the partition together with the pseudo complement over I
CRandomizationResult
CReducibleResult
CSaddlepointResult	One entry per (t,k) pair
CSccResult
CSmpStageCif	What smp_stage_cif returns: C(h, j) = CIF_h(t_j) and Fhold[j]
CSmpStageQuad	What smp_stage_quad returns
CStochCompResult
CTakahashiResult
CTimeAverageResult
CTransientResult
CTransientSensResult
CUniformizationResult
CWeakCompResult	Number of weakly connected components and the per-node label (weaklyconncomp.m)
Nmdd
CMDD	The diagram: insert / member / index / enumerate / cardinality
CMddClosedQnResult	Result of the MDD-stored exact closed-network solve
CMddDescriptor	Kronecker rate descriptor of a structured model, the input of mdd_mcd
CMddEvent	One event of the Kronecker rate descriptor
CMddLocalMatrix	A local rate matrix W_k^e of the Kronecker descriptor, held row-compressed
CBuilder	Incremental triplet builder; duplicate entries are accumulated
CMddMcdOptions	Knobs of the level iteration in mdd_mcd
CMddMcdResult	Result of the Miner-Ciardo-Donatelli level aggregation
CMddServiceLaw	Phase-type service law of one station, as a Markovian (D0,D1) pair
CMddStats	Storage description of the set held in an MDD
CMddStruct	Plain-array export of an MDD, the input contract of mdd_mcd
Nme
CGegecnResult	What me_gegecn returns: the law and the four means read off it
CMeBlkOptions	Controls of the blocking fixed point, me_oqn_blk's options struct
CMeBlkResult	What me_oqn_blk returns, per station
CMeOptions	Iteration control, mirroring the MATLAB options struct
CMeResult	Mean-value results shared by the open, closed and mixed algorithms
Nmmdp
CMmdpPair	The (Q, R) pair of an MMDP
Nmoment
CMomentTensor	Joint moment array of size (n_1+1)x...x(n_d+1), stored column major
Nmva
CAggrResult	Port of @@SolverMVA/getProbAggr.m: P(n1 jobs of class 1, n2 of class 2, ...) at station ist for the model's state, a scalar in [0,1] with its log
CAvgResult	The metrics getAvg returns, after filtering
CCacheResult	What the cache analyzer reports beyond the [Q,U,R,T] block
CChainDemands	The chain-level view of a layer, as sn_get_demands_chain returns it
CClassResults	Class-level results, as sn_deaggregate_chain_results returns them
CDispatchResult	What the dispatch returns: the metrics plus the algorithm that produced them
CDistrib
CFjInnerD0	One nested fork walked by fj_find_paths: the second output inner of findPathsCS
CFjMmt	The transformed layer and the bookkeeping the fixed point needs to drive it and to merge its results back
CForkRec	One record per Fork of the base layer, ascending in node index
CFjSectionAcc	fjR of fjFixedPoint.m: the order-statistic sojourn d0 the fixed point charges each fork-join section, per (fork node, ORIGINAL class), overwritten on every pass so the converged one wins
CGlobalConstants	The MATLAB GlobalConstants, as reported by lineStart at its defaults
CMargResult	A marginal distribution and its logarithm, over the states asked for
CMvaCacheqnCacheOutputs	The cache half of the reference's return list: the (ncaches x nclasses) hit and miss split, plus the per-item occupancy the reference writes straight onto each Cache node with setResultItemProb
CMvaCacheqnRetrievalSolution	What the closed delayed-hit analyzer returns
CMvaOptions	The options SolverMVA reads
CMvaRetrievalCacheOutputs	The cache half of the reference's return list: hitprob, missprob, delayedprob, latency, hitproblist and itemprob of solver_mva_retrieval_analyzer.m
CMvaSolution	Class-level results, the [Q,U,R,T,C,X] of the MATLAB analyzers
CPfChainParams	Product-form chain parameters, the split into queueing and delay stations
CSjnAnalyzerResult	What the analyzer returns, the reference's metrics plus its actualmethod
Nnc
CCdfRespTResult	The response-time distributions, station by class
CDtModel	Classification of a model against the discrete-time product form
CGlobalConstants	The MATLAB GlobalConstants, as reported by lineStart at its defaults
CMemSupport	The verdict of solver_nc_mem_supports
CNcCacheMiss	Miss rates of one isolated cache and what produced them; see nc_cache_missrate
CNcCacheqnRetrievalSolution	What the closed delayed-hit analyzer returns
CNcCacheqnSolution	What the integrated analyzer returns: the metrics plus the converged split
CNcCacheSolution	What the cache analyzer returns beyond the usual metric table
CNcCftpAvg	The means of one cftp solve, before the SolverNC metric filter
CNcCftpOptions	The knobs of one perfect-sampling run
CNcCftpSolution	What one cftp solve produces beside the means
CNcLossnSolution	What the loss-network analyzer returns beyond the usual metric table
CNcMargResult	What the marginal analyzers return: one probability per station
CNcQueueLengthDist	The marginal queue-length distribution and its logarithm
CNcRetrievalSolution	What the delayed-hit analyzer returns beyond the metric table
CNcSolution	The [Q,U,R,T,C,X,lG] of the reference, plus the algorithm that ran
CNcSolverOptions	Controls, defaulting to SolverOptions('NC') in the reference
CNcSpnSolution	The product-form solve, with the certificate that produced it
CPfParams	The [lambda,D,N,Z,mu,S,V] of the reference
Nnpfqn
CBndBgt
CBndBpt
CDpsMorrisonResult	Mean queue lengths, sojourn times and throughputs, with Morrison's intermediate constants
CFeedbackElimResult	Outcome of the feedback elimination
CMergeConfig	MATLAB's config struct
CNonexpApproxResult	Return value, mirroring MATLAB's [ST,gamma,nservers,rho,scva,scvs,eta]
CSqdOptions	The four option switches of the reference, with its defaults
CSqdResult	Return value of npfqn_sqd, mirroring [X, Q, U, R]
CTrafficIdcContext	Context returned by npfqn_traffic_idc, mirroring the MATLAB ctx struct
CTrafficIdcCorrections	Toggle for the two correction terms, mirroring MATLAB's corrections
CTrafficRqt
Nopt
Nde
CDifferentialEvolution
CDifferentialEvolutionResult
CMT19937
CNumpyRandomState
CActivityThinkTime
CBisectionSolver
CBudgetConstraint
CClassPriority
CClassServiceMapping
CConstraint
CDecisionVariable
CDecompositionWorkflow
CEvaluationResult
CHostDemand
CJobPopulation
CLayerSensitivity
CLineEvaluator
CLineOptSolver
CLineOptSolverOptions
CMaximizePerformance
CMinimizeCost
CMinimizeSystemResponseTime
CObjective
COptimizationProblem
COptimizationResult
CParetoPoint
CParetoSweep
CProcessorMultiplicity
CResponseTimeConstraint
CRoutingProbabilities
CScenario
CSensitivityData
CServerAllocation
CServiceRate
CStationReplicas
CSubProblem
CSubProblemResult
CSystemResponseTimeConstraint
CTaskMultiplicity
CTaskReplication
CTaskThinkTime
CThroughputConstraint
CUtilizationConstraint
CWorkflowResult
Nperm
CAdaPartSampler	Adaptive partitioning (AdaPart) sampler for the permanent
CHuberLawSampler	Huber-Law acceptance-rejection sampler for the permanent
CPermSpmResult	Outcome of the saddle-point expansion: the estimate and what produced it
Npfqn
Nsimplex
CRadial	Log J(c) and the moments of the tilted law of the radius
CMode	Mode, curvature and log-integrand at the mode of the simplex factor
CAbAmvaResult	Return value of pfqn_ab_amva, mirroring [QN,UN,RN,CN,XN,totiter]
CAmvaResult
CBkLcResult	Return value of pfqn_bklc
CBkResult	Return value of pfqn_bk, mirroring [G, lG, X, U, A, B]
CBusyPeriodResult	What pfqn_busyp returns: the durations and the two constant sequences
CCbhBounds	Return value of pfqn_cbh, mirroring [Xlo, Xhi]
CCftpResult	Return value of pfqn_cftp, mirroring [Q, X, T]
CClwOptions	Optional lattice and aliasing parameters; empty means "use the CLW defaults"
CClwResult	Return value of pfqn_clw and pfqn_clw_lld, mirroring [G, lG]
CComomResult
CComomRmResult
CCubResult	Return value of pfqn_cub, mirroring [Gn, lGn]
CCycletPathInfo	One path's outcome: which route ran, and the network constant it used
CCycletResult	Density, distribution and moments of the passage time along a path
CDacResult	Return value of pfqn_dac, mirroring [Pjoint, states, XN, QN, UN, CN, pi]
CDivdiffLdResult	Return value of pfqn_divdiff_ld, mirroring [lG, G, lossDigits]
CDncResult	Normalizing constant and throughput at a real-valued population
CExpandResult	Return value of pfqn_expand, mirroring [QN_full,UN_full,CN_full]
CExplicitResult	Return value of pfqn_explicit, mirroring [lG, G, method, lossDigits]
CFncResult	Return value of pfqn_fnc, mirroring [mu, c]
CHarelBoundsResult	Return value of pfqn_harel_bounds, mirroring Ret.pfqnHarelBounds
CHstResult	Everything the HST certificate reports about one station
CKtResult	Return value of pfqn_kt, mirroring [G, lG, X, Q]
CLaplaceResult	Return value of laplaceapprox, mirroring [I, H, logI]
CLcfsMvaResult
CLcfsQnResult
CLdBcmpBound	Return value of pfqn_ldbcmp, mirroring [Xlo, Rhi, Qhat]
CLdmxEcResult
CLektResult	Return value of pfqn_lekt, mirroring [Gn, lGn, route]
CLeResult	Return value of pfqn_le, mirroring [Gn, lGn]
CLinearizerResult	Return value of the Linearizer family, mirroring [Q,U,W,C,X,totiter]
CLldResult	Return value of pfqn_lld, mirroring [G, lG, s]
CLoopingBounds	Return value of pfqn_looping: the throughput bracket plus its queue lengths
CLsResult	Return value of pfqn_ls, mirroring [Gn, lGn]
CMarieCdScaling	Class-dependent scaling of one station, tabulated on the integer population box
CMarieCoxFit	Coxian phase representation: phase rates and per-phase completion probabilities
CMarieResult	Result of pfqn_marie, mirroring the six MATLAB outputs
CMcmcResult	Estimates of pfqn_mcmc together with their batch-means intervals
CMcubBounds	Return value of pfqn_mcub, mirroring [Xub, Xlb]
CMmintResult	Return value of the McKenna-Mitra quadratures, mirroring [G, lG]
CMomlinResult	Return value of pfqn_momlin, mirroring [Q, X, U, R, QVar, QCov, dQ]
CMvabloResult	Return value of pfqn_mvablo, mirroring [X,Q,U,R,BT,iter,converged]; vectors are (M)
CMvacldResult	Return value of pfqn_mvacld, mirroring [XN, QN, UN, CN, pij]
CMvacResult	Return value of pfqn_mvac, mirroring [XN, QN, UN, CN]
CMvaIntervalResult	Every output of pfqn_mva_interval, each a [lower, upper] pair
CMvaLdResult	Result of pfqn_mvald, mirroring the seven MATLAB outputs
CMvaoiMargResult	Return value of pfqn_mvaoi_marg, mirroring [XN, QN]
CMvaoiResult	Return value of pfqn_mvaoi, mirroring [X, Qoi, Qli, Qdelay, Soi]
CMvaResult
CMwrbbBounds	Return value of pfqn_mwrbb, mirroring [Xlo, Xup, Wlo]
CNcDispatchResult
CNcldmxResult
CNcldResult
CNcOptions	The options fields compute_norm_const reads beyond the method itself
CNcResult	Return value of the normalizing-constant family, mirroring Ret.pfqnNc
CNcSanitizeResult
CNintMvaResult	Mean performance measures of pfqn_nintmva at the requested population
COiFncResult	Return value of pfqn_oi_fnc, mirroring [muf, Psi, mu] flattened
COiInsvcResult	Return value of pfqn_oi_insvc, mirroring [g, Xi, Phi]
CPanaceaLdResult	Return value of pfqn_panaceald, mirroring [Gn, lGn] plus why it declined
CPanaceaResult	Return value of pfqn_panacea, mirroring [Gn, lGn]
CPasIsResult	Return value of pfqn_pas_is / pfqn_oi_is, mirroring [G, lG, Q]
CPasPlacement	Result of pas_placement
CPbhBounds	Return value of pfqn_pbh, mirroring [Xlo, Xhi, Qlo, Qhi]
CPfqnManjunathOptions	Controls of pfqn_manjunath
CPfqnManjunathResult	Result of pfqn_manjunath
CPfqnNreResult	The reference's [lG,G,lGs,vsad]
CProcomom2Result	Return value of pfqn_procomom2, mirroring [pk, lG, G, T, F, B]
CProcomomResult	Return value of pfqn_procomom, mirroring [Pr, Q]
CPropfairResult	Return value of pfqn_propfair, mirroring [G, lG, Xasy]
CQdAmvaResult	What pfqn_qdamva returns: the fixed point and how it was reached
CQdLinResult	What pfqn_qdlin returns: the fixed point and how it was reached
CQlenJointMomentsResult	Everything pfqn_qlen_joint_moments reports
CRdResult	Return value of pfqn_rd, mirroring [lGN, Cgamma]
CResptPsMomentsResult	Sojourn-time moments at the PS station, per class
CRgfmcResult	Return value of pfqn_rgfmc, mirroring [G, lG]
CRgfResult	Return value of pfqn_rgf, mirroring [G, lG, lg]
CScbBounds	Return value of pfqn_scb, mirroring [Xlo, Xhi, Ulo, Uhi]
CSchmidtExtResult	Return value of pfqn_schmidt_ext, mirroring [XN,QN,UN,CN]
CSchmidtResult	Return value of pfqn_schmidt, mirroring [XN,QN,UN,CN]
CSdrCoeff	Derived coefficients of an SDR structure, eqs
CSdrResult	Mean performance measures returned by pfqn_sdr
CSdrStruct	Topology and coefficients of a state-dependent routing subnetwork
CSensLdmxEcResult
CSensLinearizerResult
CSensMomResult
CSensMvaldmxResult
CSensMvaResult
CSensParam	One differentiation parameter
CSensResptResult
CSensResult
CSibBounds	Return value of pfqn_sib, mirroring [Xlo, Xhi, Wlo, Whi]
CSjnOptions	Options of the SJN solvers, the fields sjn_args fills in
CSjnProfile	The conditional waiting time profile at one SJN station, the reference's WX
CSjnResult	Return block of pfqn_mvasjn and pfqn_amvasjn
CSjnStarvationError	The conditional waiting time equation has no solution at some population
CSqniResult	Return value of pfqn_sqni, mirroring [Q, U, X] for the single station
CSsdBounds
CStdfResult	Result of pfqn_stdf / pfqn_stdf_heur, mirroring the MATLAB cell array RD
CUniqueResult
CWsResult	What an approximate MVA sweep reports
Npolling
CPollingMoments	Per-queue first two moments of the arrival, service and switchover processes, the reduced form both formulas consume
Nqn
Npool_detail
CPoolStart	One successor of a pooled service start: the buffer, the servers, its weight and the class started
CBreakdownParam	Server breakdown and repair of a station whose server fails and is repaired
CCacheParam	The parameters of a Cache node, MATLAB's sn.nodeparam{ind} for a Cache
CPopularity	The popularity LAW each class declared, beside the pmf it expands to
CCtmcMapc	CTMC pair form of a MAP service at an FCFS station, written by ctmc::ctmc_mapc on the solver's private copy of the struct (MATLAB sn.ctmcmapc{ist,r})
CCtmcPool	CTMC bookkeeping of a heterogeneous-server station, written by ctmc::ctmc_pools on the solver's private copy of the struct (MATLAB sn.nodeparam{ind}.ctmcpool)
CDistrib
CEventOutcome	What one event produces at one node: the successor rows, their rates and their probabilities, all three the same length
CFeatureSet	A subset of the registry: MATLAB's SolverFeatureSet, whose list is a flag per field
CFjJoinParam	sn.nodeparam{j}.fj: what a Join node needs to fire on identity
CFjSync	One fork firing synchronization: sn.fjsync{k}
CFjTagged	The augmented struct and everything needed to read its results back
CForkParam	Variable forking levels, the twin of MATLAB sn.nodeparam{f}.fanOutLink / .fanOutProb / .fanOutDist
CGlobalConstants	The MATLAB GlobalConstants, as reported by lineStart at its defaults
CGlobalOutcome	What one global event produces: a whole network state per outcome
CGlobalSync	A GLOBAL synchronization: an SPN mode event and the place arcs it drives
CJobClass	One job class of the network
CLayer	A layer network: everything a NetworkStruct holds, plus the LQN back-mapping
CMarginal	What State.toMarginal returns for one station and one state row
CModeEvent	One half of a GLOBAL synchronization: a mode event at a node
CNetState	One network state: the per-stateful-node local rows it is composed of
CNetwork	A queueing network under construction
CNetworkStruct	A network plus its refreshed NetworkStruct
CJoinDecl	The DECLARED join rule of a Join node, by 1-based node index
CReward	sn.reward: the user-declared reward functions, MATLAB's model.setReward(name, fn)
CRegion	FINITE CAPACITY REGIONS, MATLAB's refreshRegions output
CPasParam	The pass-and-swap / order-independent parameters of a PAS station, keyed by station index (Dorsman and Gardner 2024, Sect
CPollingParam	The polling controller of a POLLING station, keyed by station index
CNodeDef	A node of the network
CLoggerParam	A Logger node's trace configuration, MATLAB's Logger properties and sn.nodeparam{ind} for a Logger
CPollingInfo	Port of State.pollingInfo: the derived description of a polling controller
CPrioPop	The population the *PRIO disciplines actually share the server among
CReplyBlockInfo	Where node ind keeps its reply-block counters inside the local vars
CRetrialParam	The parameters of a retrial station: MATLAB sn.retrialProc and friends
CRoutingMatrix	The routing matrix a model script fills in, MATLAB's P cell array
CKey
CRowLayout	How a station's state row splits into [buffer | server | local vars]
CSetupDelayOffParam	Setup and delay-off of a station that powers down when it falls idle
CStation	One station of the network
CBalkingThreshold	One balking threshold: with min_jobs <= n <= max_jobs at the station, an arriving job of the class refuses to join with probability
CBalkingParam	Per class; strategy == NONE is a class that declares no balking
CServerType	A heterogeneous server pool: count servers that serve only compatible classes, each with its own service law
CSupportResult	The outcome of the gate: the verdict, the offending features, the message
CSync	One synchronization: an ACTIVE event and the PASSIVE event it drives
CSyncEvent	One half of a synchronization: an event at a node, in a class
CTaggedChain	The tagged model and the class bookkeeping a caller needs to read it back
CTransitionParam	The parameters of a Transition node: MATLAB sn.nodeparam{ind} for an SPN transition, as refreshPetriNetNodes.m writes them
CFluidArc	One fluid arc of a mode: node is the 1-based fluid place, value a rate or an impulse
CFluidGuard	A fluid guard: the mode is enabled only while level(node) >= thr (sgn = +1) or <= thr (sgn = -1)
CFluidDep	A fluid rate dependence: the firing rate is multiplied by fun(level(node))
CFluidFlowDep	A marking-dependent fluid flow (setFluidFlowDependence): the flow of the mode on fluid place node is multiplied by fun(M)
Nqsys
Nmgck_sync_detail
CTriplets	A sparse transition list, summed into a dense matrix as MATLAB's sparse() does
CBmapM1Result	Everything qsys_bmapm1 returns, mirroring the MATLAB result struct
CBmapPhNnRetrialOptions	Options of qsys_bmapphnn_retrial (the name-value pairs of the .m file)
CBmapPhNnRetrialResult	Result of qsys_bmapphnn_retrial
CDmcResult
CGig1ExtremalResult	The bounds, all as TIMES IN QUEUE: add 1/mu for a response time
CGig1RqResult
CGigkRqtResult
CLdpsWorkloadResult	Return value of qsys_ldps_workload, mirroring the three MATLAB outputs
CLindleyResult	Mirrors the struct MATLAB returns from qsys_mm1_lindley
CMapD1Result	Return value of qsys_mapd1, mirroring the MATLAB result struct
CMapDcResult	Return value of qsys_mapdc, mirroring the MATLAB result struct
CMapG1kPerflowResult	Return value of qsys_mapg1k_perflow, mirroring the MATLAB result struct
CMapG1kResult	Return value of qsys_mapg1k, mirroring the MATLAB result struct
CMapG1Result	Result of qsys_mapg1
CMapMap1Result	Return value of the MAP/MAP/1 family (qsys_mapmap1, qsys_mapph1, qsys_phph1), carrying the same quantities as the MATLAB result struct
CMapMcResult	Return value of qsys_mapmc and qsys_mapm1, mirroring the MATLAB struct
CMapPhcResult	Return value of qsys_mapphc, mirroring the MATLAB struct
CMaximaResult	Two-moment description of a maximum
CMDcCrommelinResult
CMg1DisciplineResult
CMg1kLossMgsResult
CMg1kLossResult
CMg1PrioResult
CMg1PsOptions	Options of qsys_mg1_ps, mirroring the reference's name-value pairs
CMg1PsResult	Everything qsys_mg1_ps returns
CMgckSyncResult	Return value of qsys_mgck_sync, mirroring the MATLAB result struct
CMginfResult	Return value of qsys_mginf, mirroring MATLAB's [L,Lq,W,Wq,p0,pk]
CMgisrgiOptions	Options of qsys_mgisrgi_whitt, all with the MATLAB defaults
CMm1DpsResult
CMm1kLossResult
CMm1PsResult	Mirrors MATLAB's [W, W2, alpha] return list
CMm1TandemLindleyResult	Mirrors the struct MATLAB returns from qsys_mm1_tandem_lindley
CMmapG1kResult	Return value of qsys_mmapg1k, mirroring the MATLAB result struct
CMmapGk1Result	Return value of qsys_mmapgk1, mirroring the MATLAB struct
CMmapGk1Service	One marked type's service law, in any of the three forms the reference accepts: a Distribution object, a (D0, D1) MAP pair, or a transform struct
CMmapGk1Transform	A service law given by its transform, the reference's struct form struct('lst', @(s) ..., 'moments', [m1 m2 ...]): the LST at a complex argument and its raw moments, of which at least numWMoms + 1 are needed
CMmapMap1Result	Return value of qsys_mmapmap1, mirroring the MATLAB struct
CMmccRetrialFpResult	Return value of qsys_mmcc_retrial_fp, mirroring the three MATLAB outputs
CMmckResult
CMxM1Result
CNpfqnTvFluidResult	Result of the network solve
CPatience	The patience (time-to-abandon) law, in the three forms the algorithm accepts
CPhM1Result
CPhMcResult
CQsysAbandonResult	Steady-state measures of a multiserver queue with customer abandonment
CQsysFluidAbandonResult	Steady state of the G/GI/s+GI fluid model
CQsysGgnmResult	Steady-state measures of the G/GI/n/m diffusion approximation
CQsysMolResult	MOL and PSA measures of a time-varying multiserver system
CQsysMtginfResult	Time-varying measures of the Mt/G/infinity queue
CQsysQedResult	QED measures of the M/M/s queue
CQsysQedStaffingResult	Outcome of the square-root staffing rule
CQsysResult	Return value of the qsys family, mirroring MATLAB's [W,rhohat] and the JAR's Ret.qsys
CQsysTgaResult	Steady-state measures of the G/GI/n+GI truncated Gaussian approximation
CQsysTvFluidResult	Trajectory of the Gt/Mt/st+GI fluid queue; every vector is on the time grid
CServiceLaw	Service-time descriptor, the C++ form of the MATLAB svc struct
CSvclawCoeffsResult	Outputs [cn, Smean] of qsys_svclaw_coeffs.m, plus the truncation residual
CTandemLindleyResult	Mirrors the struct MATLAB returns from qsys_tandem_lindley
CTandemUbResult	Mirrors the struct MATLAB returns from qsys_tandem_ub_ciucu
CTvFluidOptions	Options of qsys_gtmtst_fluid, all with the MATLAB defaults
CWorkloadServiceLaw	The three things Cohen's formula needs from the required-service-time law: its mean, its squared coefficient of variation, and its CDF
Nreg
CArgs	Named-argument reader over the parsed JSON object
CArithSpec	The arithmetic a call runs at: Real also carries the precision tier
CEncodeScalar
CEncodeScalar< double >
CEncodeScalar< Rational >
CEncodeScalar< Real< D > >
CNumFromDecimal
CNumFromDecimal< double >
CNumFromDecimal< Rational >
CNumFromDecimal< Real< D > >
Nretrieval
CFpiOptions	Options mirroring the trailing (max_iter, tol) arguments of the MATLAB function
CRetrievalFpiLatencyResult	Mirrors the [Z, d, phi, pi0] return list of the MATLAB function
CRetrievalFpiResult	Mirrors the [pmiss, phit, pdh] return list, plus the iteration diagnostics
CRetrievalInputs	The [m, lambda, gamma, eta, alpha/T (station), R] the retrieval algorithms read
CRetrievalMetricsResult	Mirrors the [pmiss, phit, pdh] return list of the MATLAB function
CRetrievalMvaResult	Mirrors the [pmiss, phit, pdh] return list of the MATLAB function
CRetrievalRayintResult	Outcome of the expansion
CRetrievalStationPH	Phase-type service of every item at one retrieval station
Nrng
CSeedHash	Splitmix64 keyed by (run seed, stream offset): where every LDES stream's seeds come from
CMrg32k3a	SSJ's umontreal.ssj.rng.MRG32k3a, state and all
CJavaRandom	java.util.Random, the 48-bit LCG of the Java Language Specification
Nsens
CSensOptions	The name-value contract of getSensitivityTable
CSensRow	One (station, class) row of the table
CSensTable	What the table carries, plus the branch that produced it
Nsim
CAsymVarResult	Second-order description of a steady-state estimator
CQuestInterval	A confidence interval, asymmetric about the point estimate in general
CQuestOptions	Procedure constants shared by sim_fquest and sim_firquest
CQuestResult	Point estimate and interval delivered by the QUEST procedures
CRunLengthPlan	The plan of sim_runlength_plan: what the run should have been
CRunLengthResult	Outcome of the run-length plan
CShapiroWilkResult	Outcome of the Shapiro-Wilk normality test
CStsQuantileStats	Batched-quantile statistics of one sample path
CVonNeumannResult	Outcome of the von Neumann randomness test
Nsmc
Nrr_detail
CDisp	The displacement representation B = L(b) + L(c1) L(Z r1)' + L(c2) L(Z r2)' of the Ramaswami-reduction matrix, with L(x) the block lower-triangular Toeplitz matrix whose first block column is x (N*m x m) and Z the block down-shift
CDrift	The drift of an M/G/1-type sequence, and the invariant vector it uses
CShiftResult	What MG1_Shifts returns: the shifted sequence and the drift it measured
CMg1CrOptions	Options of MG1_CR, with the reference's defaults
CMg1FiOptions	Options of MG1_FI, with the reference's defaults
CMg1NiOptions	Options of MG1_NI, with the reference's defaults
CMg1RrOptions	Options of MG1_RR, with the reference's defaults
CMg1IsOptions	Options of MG1_IS, with the reference's defaults
Nsn
CQrfAlpha	The scaling, the utilization normalizer, and why they may not exist
CQrfBlocking	The derived blocking tables, in the reference's 1-based queue indexing
CQrfCapacity	Per-station occupancy bounds, and which of them bind
CRoutingErgodicityInfo	The reducibility structure of a routing matrix, the MATLAB info struct
CScheduleNominal	What sn_schedule_nominal returns, in the reference's own output order
Nsnc
CEnv	The pair (sigma, rho) of an envelope evaluated at one theta
CSncResult	A bound together with the theta that attains it
Nsolvers
CCacheMetrics	Every Cache node of the model, in node order; empty on a model with none
CCacheNodeMetrics	One Cache node's measured behaviour
CChainResult	The station- or node-level table aggregated by chain
CConfigKey	One options.config key; an empty placement means "not implemented there"
CDefaultCdfCurve	One [F(t), t] curve of the base-class response-time CDF fallback
CFjMetrics	self.result.FJ: one row per Fork/Join pair, one column per class
CMapEnvConfig	The caller-facing map_env knobs, options.config.map_env and friends
CMapEnvDecision	What the gate decided, and what it decided it about
CNodeMetrics	The station table scattered to the NODE index space, plus the two flow columns the reference recomputes there
CSysResult	@@NetworkSolver/getAvgSys: one response time and one throughput per chain
Nspn
CSpnEnabling	Unnormalised enabling-degree masses of one mode
CSpnInfo	Everything the caller needs alongside the descriptor
CSpnInvariants	The invariant basis of a net, in PLACE-LEVEL coordinates: one level per (place, class) pair, place-major, level l = pp * nclasses + k for place pp and class k (both 0-based), exactly the (pp - 1) * R + k layout of the reference
CSpnLpBounds	The brackets; each vector pair holds the minimum then the maximum
CSpnLpMode	One (transition, mode) pair over place levels
CSpnLpOptions	Options of the relaxation
CSpnMetrics	The stationary measures of Sec
CSpnMode	One (transition, mode) pair of the net, in level coordinates
CSpnOptions	Options of the translation
CSpnPfOptions	Options of the product-form derivation
CSpnPfResult	The product form, and the certificate that it is one
CSpnResult	Descriptor, diagram and metadata returned together
Nssa
Nmlmc_detail
CEngine
CEnabledEvent	One transition the enabled scan found: where it goes, and at what rate
CMlmcCompiled
CMlmcOptions
CMlmcProblem	Generic fixed-increment jump process
CMlmcResult
CNrmEngine	The NRM engine: the reaction network built from sn, and the sample path
CNrmSpaceEngine	The aggregate NRM engine of solver_ssa_nrm_space.m
CNrmSpaceState	One state of the aggregate chain: the (node, class) populations, and the ordered buffer contents of every buffered node
CNrmSpnEngine	The SPN Next-Reaction-Method engine, solver_ssa_nrm_spn of the reference
CSsaCacheRatio	What the cache write-back of solver_ssa_analyzer_serial.m produces (and the NRM's)
CSsaEventCache	EventCache: the per-state enabled-event memo of the serial SSA engine
CSsaEventKey	The memoization key: the argument list of after_event, in fields
CSsaNrmSpaceOptions	The knobs the space variant reads
CSsaNrmSpaceRun	What solver_ssa_nrm_space.m returns, plus what makes it a measurement
CSsaNrmSpaceSolution	The metric table, the table it came from, and the stream that produced it
CSsaOptions	Controls, defaulting to SolverOptions('SSA') in the reference
CSsaParallelOptions	The replicated engine's knobs: the serial engine's, plus the two the reference reads from options.config on this path
CSsaParallelSolution	What the replicated analyzer returns
CSsaProbReport	The four probabilities -a prob reports, over one requested state
CSsaProbResult	One probability query: the estimate, and whether the state occurred at all
CSsaReachability	Port of solver_ssa_reachability.m's return: [SSq, SSh, sn.space]
CSsaRng	The uniform source, MATLAB's rand
CSsaSamplePath	One trajectory, in the shape the reference's sampleSys returns it
CSsaSerialEngine	The serial engine: the sample path of solver_ssa.m's main loop
CSsaSerialOptions	The serial engine's knobs: SsaOptions plus the three the serial path reads and the NRM has no use for
CSsaSerialRun	One sample path, in the shape solver_ssa.m returns it
CSsaSerialSolution	The serial analyzer's return: the metric table, the path, and the stream
CSsaSolution	What the analyzer returns, in the same shape as the MVA and fluid results
Nsum
CClosingOptions	Closing controls; Kclosed is the population given to the open classes
CServers	Number of servers of a station; MATLAB's mi(i) = Inf becomes infinite
CSumClosedResult	Mirrors the [XN, QN, UN, RN, it] return list of the MATLAB function
CSumClosingResult	Mirrors the [XN, QN, UN, RN, TN, it] return list of the MATLAB function
CSumOptions	Convergence controls, mirroring the trailing (tol, maxiter) arguments
Nsym
CCtmcMeasure	One weighted sum of the stationary distribution, or a ratio of two
CCtmcMeasures	Stationary distribution together with the measures taken from it
CCtmcSolution	Symbolic stationary distribution of a CTMC
CFluidODEs	Symbolic analysis of a fluid vector field
CPassage	First passage time transform and moments
CRatioSpec	A ratio of two measures, by their index into the weight block
CSageRestEngine	Client of the line-sage-rest service
CSymEngine	A computer algebra backend
CSymEngineError	The symbolic backend is unreachable, or rejected the request
CSymSensitivity	Exact parametric sensitivity, following Trivedi and Bobbio (2017), Sec
Ntrace
CMtraceBootstrapResult	Lower and upper BCa endpoints of each descriptor, and the point estimate
CMtraceCountResult	Return value of mtrace_count
CMtraceCountsResult	Return value of mtrace_iat2counts
CMtraceCrossMomentResult	Return value of mtrace_cross_moment
CMtraceJointResult	Return value of mtrace_joint
CMtraceMeanResult	Return value of mtrace_mean
CMtraceMergeResult	Return value of mtrace_merge, mirroring [T, L]
CMtraceSplitResult	Return value of mtrace_split
CMtraceSummary	Return value of mtrace_summary
CTraceBicovResult	Return value of trace_bicov, mirroring [BiCov, BiCovLags]
CTraceBinsResult	Return value of trace_iat2bins, mirroring [C, bC]
CTraceGammaResult	Return value of trace_gamma, mirroring [GAMMA, RHO0, RESIDUALS]
CTraceIdiResult	Return value of trace_idi, mirroring [IDIk, support]
CTracePmfResult	Return value of trace_pmf, mirroring [pmf, px]
CTraceSummary	Return value of trace_summary
Nuq
CPriorSite	Where a Prior sits in the model, MATLAB's priorInfo entry
CSolverUq	The ensemble surface of UQ: @UQ's EnsembleSolver implementation
CUqDesignPoint	One design point: a concrete distribution for every Prior, and its weight
CUqEmpiricalCdf	The weighted empirical law of a metric, sorted ascending; MATLAB's EmpiricalCDF
CUqInterval	UQ.getInterval: the RANGE of every metric over the support of the Priors
CUqMoments	The weighted mean and variance of a metric over the design
CUqOptions	UQ.defaultOptions plus the stream the Monte Carlo design draws from
CUqSolution	What solver_uq_run_analyzer returns
CUqStageOptions	The inner solver's knobs, carried through untranslated
Nutil
CLineConsole
CRun	RAII guard: opens a run on construction, closes it on scope exit
CQuiet	RAII guard that suppresses structure-compile detail while it lives
COwnModelCompile	Lift the compile detail rule while the run compiles its OWN model
CProcResult	Outcome of a captured command
CSha256	Incremental SHA-256
CTempDir
Nwf
CBenchmarkRow	One row of the benchmark table
CBranchAlternative	One alternative of a branch: the node and its probability
CBranchDiversity	Mirrors the Java calculateBranchDiversity map
CBranchPattern	Mirrors the Java BranchPattern
CBranchStats	Mirrors the Java getBranchStats map
CComplexityReport	The complexity report, one band per pattern family plus the overall score
CDetectedPatterns	Everything the four detectors found
CExpectedIterations	1/(1-p), with the p >= 1 divergence reported rather than encoded
CExtendedSolverRecommendation	What the recommendation returns: the choice and why
CLoopStats	Mirrors the Java getLoopStats map
COptimizationInsights	The advisory text the reference's getOptimizationInsights assembles
CParallelStats	Mirrors the Java getParallelStats map
CPatternComplexityEntry	Per-pattern-family complexity, one entry of the report's patternComplexity
CSequenceStats	Mirrors the Java getSequenceStats map
CServiceParameters	A phase-type-shaped service law: entry vector and transient generator
CUpdatedWorkflow	The collapsed link matrix and the service law of every surviving node
CUpdateStats	Statistics of one update pass; the Java getUpdateStats map
CWfModelFacts	The four model facts the base recommendation reads, i.e
CWorkflowAnalysis	What analyze_workflow returns
CWorkflowAnalysisResult	Everything analyze_workflow_full returns, i.e
CWorkflowComplexity	The reference's complexity map, for either the original or the collapsed graph
CWorkflowFeatures	The flat feature vector the recommendation reads
CWorkflowPerformanceMetrics	The four efficiency scores plus the two headline numbers
CWorkflowRepresentation	The workflow in matrix form: the reference's WorkflowRepresentation
CWorkflowStatistics	The statistics block of WorkflowAnalysis
CWorkflowValidation	What validate_workflow reports
Nwfn
CCaseMetrics	Case-level metrics of get_case_metrics
CResources
CTasks	RespT at its station for the fork-join target, InService tokens for the SPN one
CPlaces	Mean tokens per place, SPN target only
CCycleTimeAnalysis	The full single-case analysis of get_cycle_time_analysis
CFirings
CPlaceTime
CElementRef	A place, a transition, or the name of either, where an argument may be any of them
CResourceLoads	The table of get_resource_loads
CSoundnessReport
CWFNArc
CWFNPlace
CWFNResource
CWFNTransition
CWorkflowNet
Nworkflow
CDistrib
CGlobalConstants	The MATLAB GlobalConstants, as reported by lineStart at its defaults
CPhLaw	A phase-type law as the composition rules pass it around
CPrecedence	One precedence of the activity graph
CSPNode
CSPTree	The flat series-parallel tree
CWorkflow
CWorkflowActivity	A computational activity
Nws
CWsError	Transport-level failure: the port is taken, the peer vanished, a bad frame
CServer	A listening socket; one connection is served at a time
Nxml
CElement
CApiEntry
CAugLagOptions	Tuning of the outer multiplier iteration
CAugLagResult	Outcome of a constrained solve
CAutoCandidate	One row of SolverAUTO::find_solver: a (family, method) pair and whether this model can run it
CAvgChain	getAvgChain(): the station x chain matrices, @NetworkSolver/getAvgChain.m's outputs
CAvgChainTable	getAvgChainTable: the station table aggregated by CHAIN, one row per (station, chain), row-major over (station, chain) and with no row filter, as @NetworkSolver/getAvgChainTable.m
CAvgFJTable	getAvgFJTable(): one row per (Fork/Join pair, class) with a nonzero metric, the fork-join SECTION metrics of fjFixedPoint.m (MVA, NC, Fluid), JMT and LDES
CAvgMetricTable	getAvgQLenTable(), getAvgUtilTable(), getAvgRespTTable(), getAvgTputTable(): the Station and JobClass columns of getAvgTable with ONE metric column, row for row, as getAvgMetricTable.m builds them
CAvgSysTable	getAvgSysTable(): one row per CHAIN, the cycle time and the completing throughput at the chain's reference station, as @NetworkSolver/getAvgSysTable.m reports them
CAvgTable	getAvgTable, one row per (station, class) that carries a metric
CBound	Box constraint on one variable
CBoundsTable	SolverBA(model, method).getBoundsTable()
CCache	Cache(model, name, params)
CCdfCurve	One response-time CDF curve: F the CDF value, t the time it is reached
CClassSwitch	ClassSwitch(model, name, C)
CClosedClass	ClosedClass(model, name, njobs, refstat, prio)
CDelay	Delay(model, name): the infinite-server station
CError	Base error for the multiprecision C++ port
CErrorKind	The <kind> part of a LINE:<category>:<kind> identifier (see _kb/17-error-vocabulary.md): an identifier such as Cache, SchedStrategy_PS, NonConvergence or Method
CExternalError	A tool, binary, service or bridge LINE depends on is missing or failed: LINE:external:<kind>
CFirstPassage	getCdfFirstPassT(A, B, C, tset): the curve, the reach probabilities and the resolved sets
CFirstPassageMoments	getFirstPassTMoments(A, B, nmax, C): [m, mall, p] with the resolved sets
CFork	Fork(model, name)
CInputError	Malformed or inconsistent input (dimensions, negative populations, ...): LINE:input:<kind>
CInternalError	An invariant LINE should guarantee was violated, i.e
CJobClass	A job class: the index it was given, and the model that owns it
CJoin	Join(model, name, fork)
CLevmarOptions	Tuning of the Levenberg-Marquardt iteration
CLevmarResult	Outcome of a least-squares solve
CLsodaOptions	Integration controls
CLsodaSolution	Result of an integration, mirroring OdeSolution in ode.h
CLsodaStepper	One internal step at a time: ODEPACK's itask = 2
CLstsqResult	Outcome of lstsq: the solution and whether the system was rank deficient
CMatrix
CMatrixView
CNelderMeadOptions	Tuning of the simplex iteration
CNelderMeadResult	Outcome of a simplex minimization
CNetworkSolver	The shared surface of every solver, Python's NetworkSolver
CNoConstraints	A constraint map that returns no constraints; the default for h or g
CNode	A node of the model: the index it was given, and the model that owns it
Cnum_traits
Cnum_traits< Complex >
Cnum_traits< double >
Cnum_traits< Rational >
Cnum_traits< Real< D > >
CNumericError	The algorithm cannot produce a trustworthy answer on this instance: LINE:numerical:<kind>
COdeOptions	Integration controls
COdeSolution	Result of an integration
COpenClass	OpenClass(model, name, prio)
Cpivot_mag	The ordered type the pivot search compares in
Cpivot_mag< std::complex< R > >	Partial pivoting compares moduli, since the complex field is unordered
CPlace	Place(model, name): a Petri-net place
CQueue	Queue(model, name, strategy)
CRealSchur	Real Schur factorization A = Z T Z^T, with Z orthogonal and T upper quasi-triangular: 1 x 1 diagonal blocks for real eigenvalues and 2 x 2 blocks for complex conjugate pairs
CRootResult	Outcome of a scalar solve
CRouter	Router(model, name): a stateless routing node
CSamplePath	sampleSysAggr / sampleAggr: ONE simulated trajectory, not a mean
CSelfLoopingClass	SelfLoopingClass(model, name, njobs, refstat, prio)
CSink	Sink(model, name): the external departure node, which holds no jobs
CSolverAUTO	SolverAUTO (aliases AUTO, SolverAuto, LINE): the solver that picks a solver, a port of matlab/src/solvers/AUTO/@SolverAUTO on a flat Network
CSolverBA	SolverBA: the bounding solver, whose result is a bounds table
CSolverCTMC	SolverCTMC: the average table plus the chain it was computed from
CSolverFLD	SolverFLD: the fluid solver, which also answers a transient
CSolverJMT	SolverJMT: the Java Modelling Tools client, which also answers a transient, a response-time law, a state probability and a trajectory
CSolverLDES	SolverLDES: the discrete-event simulator, which also answers the empirical response-time law
CSolverOptions	The knobs a solver reads; a negative or empty field keeps the engine default
CSource	Source(model, name): the external arrival station
CStateView	One CTMC state as a state-set predicate sees it, the reference's RewardState: the AGGREGATE row of state_space_aggr(), per-(station, class) job counts in (ist-1)*K + k order
CStation	A node that holds jobs and serves them: MATLAB's Station
CSvdFactors	A = U diag(s) Vt, with U (m x m), s of length min(m,n) and Vt (n x n)
CSylvesterFactor	The Kronecker operator of a FIXED (A,B) pair, factorized once
CSymbolicSolution	getSymbolicSolution: the stationary law as a function of the rate symbols
CTranAvg	getTranAvg: the transient mean queue length per (station, class)
CTransition	Transition(model, name): a Petri-net transition, with its modes declared after it as MATLAB, the JAR and Python declare theirs
CUnsupportedError	A refusal: the feature, method or analysis is not covered: LINE:unsupported:<kind>
CFdCapture	Redirect a file descriptor into a temporary file for a scope, and give back what was written to it