Networks, nodes, classes, distributions, solvers.

These modules provide the fundamental building blocks for creating and solving queueing models.

Network Models (matlab/src/lang/)

The lang module contains the core classes for building queueing network models.

Main Classes

Network - Main queueing network model container

Method	Description
Constructor
`model = Network(name)`	Create a new queueing network model
Static Factory Methods
`model = Network.cyclic(N, D, strategy, S)`	Generate cyclic queueing network
`model = Network.tandem(lambda, D, strategy)`	Generate tandem queueing network
`model = Network.cyclicPs(N, D)`	Create cyclic network with PS scheduling
`model = Network.cyclicFcfs(N, D, S)`	Create cyclic network with FCFS scheduling
`model = Network.tandemPs(lambda, D)`	Create tandem network with PS scheduling
`model = Network.tandemFcfs(lambda, D)`	Create tandem network with FCFS scheduling
Network Construction
`addNode(model, node)`	Add a node (Queue, Source, Sink, etc.) to the network
`addJobClass(model, classObj)`	Add a job class (OpenClass or ClosedClass)
`addLink(model, nodeA, nodeB)`	Create a link between two nodes
`addLinks(model, nodeList)`	Add multiple links from a node list
`addRegion(model, nodes)`	Create a finite capacity region over nodes
`addItemSet(model, itemSet)`	Add an item set for cache modeling
Routing
`link(model, P)`	Link nodes using routing probability matrix
`relink(model, P)`	Re-establish links using new routing matrix
`linkAndLog(model, nodes, classes, P, wantLogger, logPath)`	Link nodes with logging capability
`setRouting(model, nodeA, nodeB, jobclass, prob)`	Set routing probability from nodeA to nodeB for a job class
`serialRouting(model, nodes, ...)`	Create serial routing pattern through nodes
`initRoutingMatrix(model)`	Initialize routing probability matrix
`P = getRoutingMatrix(model, arvRates)`	Get routing matrix with optional arrival rates
`P = getLinkedRoutingMatrix(model)`	Get the currently linked routing matrix
`printRoutingMatrix(model, onlyclass)`	Print routing matrix to console
Query Methods - Nodes
`nodes = getNodes(model)`	Get all nodes in the network
`names = getNodeNames(model)`	Get names of all nodes
`types = getNodeTypes(model)`	Get types of all nodes
`node = getNodeByName(model, name)`	Get node by name
`node = getNodeByIndex(model, idx)`	Get node by index
`idx = getNodeIndex(model, name)`	Get index of a node by name
`M = getNumberOfNodes(model)`	Get total number of nodes
`nodes = getStatefulNodes(model)`	Get all stateful nodes
`names = getStatefulNodeNames(model)`	Get names of stateful nodes
`M = getNumberOfStatefulNodes(model)`	Get count of stateful nodes
`idx = getIndexStatefulNodes(model)`	Get indices of stateful nodes
`idx = getStatefulNodeIndex(model, name)`	Get index of stateful node
Query Methods - Stations
`names = getStationNames(model)`	Get names of all stations
`station = getStationByName(model, name)`	Get station by name
`station = getStationByIndex(model, idx)`	Get station by index
`idx = getStationIndex(model, name)`	Get index of a station
`M = getNumberOfStations(model)`	Get total number of stations
`idx = getStationIndexes(model)`	Get indices of all stations
`sched = getStationScheduling(model)`	Get scheduling strategies for all stations
`S = getStationServers(model)`	Get number of servers at each station
`S = getStatefulServers(model)`	Get server counts for stateful nodes
`idx = getIndexSourceStation(model)`	Get index of source station
`idx = getIndexSourceNode(model)`	Get index of source node
`idx = getIndexSinkNode(model)`	Get index of sink node
Query Methods - Classes
`classes = getClasses(model)`	Get all job classes
`names = getClassNames(model)`	Get names of all classes
`class = getClassByName(model, name)`	Get class by name
`class = getClassByIndex(model, idx)`	Get class by index
`idx = getClassIndex(model, name)`	Get index of a class
`R = getNumberOfClasses(model)`	Get total number of classes
`N = getNumberOfJobs(model)`	Get population vector for all classes
`refs = getReferenceStations(model)`	Get reference stations for classes
`refs = getReferenceClasses(model)`	Get reference classes
`idx = getIndexOpenClasses(model)`	Get indices of open classes
`idx = getIndexClosedClasses(model)`	Get indices of closed classes
`chain = getClassChain(model, className)`	Get chain for a class
`idx = getClassChainIndex(model, className)`	Get chain index for a class
Query Methods - Chains
`[chainTable, chainMatrix] = getChains(model, rt)`	Get chain table and matrix
`C = getNumberOfChains(model)`	Get number of chains in the model
`D = getDemandsChain(model)`	Get service demands by chain
Query Methods - Structure
`sn = getStruct(model, structType, wantState)`	Get internal data structure representation
`[M, R] = getSize(model)`	Get [M,R] where M=nodes, R=classes
`conn = getConnectionMatrix(model)`	Get node connection matrix
`[H, G] = getGraph(model)`	Get graph representation
`mask = getClassSwitchingMask(model)`	Get class switching mask
`fj = getForkJoins(model, rt)`	Get fork-join pairs
`ulf = getUsedLangFeatures(model)`	Get structure of used language features
Query Methods - Performance Handles
`[Q,U,R,T,A,W] = getAvgHandles(model)`	Get all average metric handles
`Q = getAvgQLenHandles(model)`	Get queue length handles
`U = getAvgUtilHandles(model)`	Get utilization handles
`R = getAvgRespTHandles(model)`	Get response time handles
`T = getAvgTputHandles(model)`	Get throughput handles
`A = getAvgArvRHandles(model)`	Get arrival rate handles
`W = getAvgResidTHandles(model)`	Get residence time handles
`[Qt,Ut,Tt] = getTranHandles(model)`	Get transient metric handles
Query Methods - Parameters
`[D, Z] = getDemands(model)`	Get service demands
`[lambda,D,N,Z,mu,S] = getProductFormParameters(model)`	Get product-form parameters
`params = getProductFormChainParameters(model)`	Get product-form parameters by chain
`ld = getLimitedLoadDependence(model)`	Get load-dependent scaling factors
`cd = getLimitedClassDependence(model)`	Get class-dependent scaling factors
`path = getLogPath(model)`	Get logging path
Query Methods - CTMC Analysis
`Q = getGenerator(model, ...)`	Get CTMC generator matrix (delegates to SolverCTMC)
`SS = getStateSpace(model, ...)`	Get state space (delegates to SolverCTMC)
`MCTMC = getCTMC(model, par1, par2)`	Get marked CTMC representation
`MCTMC = getMarkedCTMC(model, ...)`	Alias for getCTMC
Boolean Query Methods - Classes and Chains
`bool = hasOpenClasses(model)`	Check if model has open classes
`bool = hasClosedClasses(model)`	Check if model has closed classes
`bool = hasClassSwitching(model)`	Check if model has class switching
`bool = hasSingleChain(model)`	Check if single chain model
`bool = hasMultiChain(model)`	Check if multi-chain model
`bool = hasSingleClass(model)`	Check if single class model
`bool = hasMultiClass(model)`	Check if multi-class model
Boolean Query Methods - Nodes
`bool = hasFork(model)`	Check if model has fork nodes
`bool = hasJoin(model)`	Check if model has join nodes
`bool = hasMultiServer(model)`	Check for multi-server stations
Boolean Query Methods - Scheduling
`bool = hasFCFS(model)`	Check if model has FCFS scheduling
`bool = hasDPS(model)`	Check if model has DPS scheduling
`bool = hasGPS(model)`	Check if model has GPS scheduling
`bool = hasINF(model)`	Check if model has infinite server scheduling
`bool = hasPS(model)`	Check if model has PS scheduling
`bool = hasSIRO(model)`	Check if model has SIRO scheduling
`bool = hasHOL(model)`	Check if model has HOL scheduling
`bool = hasLCFS(model)`	Check if model has LCFS scheduling
`bool = hasLCFSPR(model)`	Check if model has LCFSPR scheduling
`bool = hasSEPT(model)`	Check if model has SEPT scheduling
`bool = hasLEPT(model)`	Check if model has LEPT scheduling
`bool = hasSJF(model)`	Check if model has SJF scheduling
`bool = hasLJF(model)`	Check if model has LJF scheduling
`bool = hasHomogeneousScheduling(model, strategy)`	Check for homogeneous scheduling
`bool = hasMultiClassFCFS(model)`	Check for multi-class FCFS
`bool = hasMultiClassHeterFCFS(model)`	Check for heterogeneous multi-class FCFS
Boolean Query Methods - Properties
`bool = hasInitState(model)`	Check if initial state is defined
`bool = hasProductFormSolution(model)`	Check if model has product-form solution
`bool = isMatlabNative(model)`	Returns true for MATLAB implementation
`bool = isJavaNative(model)`	Returns false for MATLAB implementation
`bool = isLimitedLoadDependent(model)`	Check for load dependence
`bool = isStateValid(model)`	Check if state is valid
State Initialization
`reset(model, resetState)`	Reset the model
`resetHandles(model)`	Reset performance metric handles
`resetModel(model, resetState)`	Reset model to initial state
`resetNetwork(model, deleteCSnodes)`	Reset network structure
`resetStruct(model)`	Reset internal data structure
`[state, priorStateSpace, stateSpace] = getState(model)`	Get current state
`initDefault(model, nodes)`	Initialize with default state
`initFromAvgTableQLen(model, AvgTable)`	Initialize from average queue length table
`initFromAvgQLen(model, AvgQLen)`	Initialize from average queue lengths
`initFromMarginal(model, n, options)`	Initialize from marginal distribution
`initFromMarginalAndRunning(model, n, s, options)`	Initialize from marginal and running jobs
`initFromMarginalAndStarted(model, n, s, options)`	Initialize from marginal and started jobs
`setInitialized(model, bool)`	Set initialization flag
Refresh Methods
`refreshStruct(model, hard)`	Refresh internal data structure
`refreshRates(model, statSet, classSet)`	Refresh service rates and SCVs
`refreshProcessPhases(model, statSet, classSet)`	Refresh process phases
`refreshProcessTypes(model)`	Refresh process types
`refreshRoutingMatrix(model, rates)`	Refresh routing matrix
`refreshLST(model, statSet, classSet)`	Refresh Laplace-Stieltjes transforms
`refreshSync(model)`	Refresh synchronization constraints
`refreshPriorities(model)`	Refresh class priorities
`refreshScheduling(model)`	Refresh scheduling strategies
`refreshProcesses(model, statSet, classSet)`	Refresh all processes
`refreshChains(model, propagate)`	Refresh chains and visits
`refreshCapacity(model)`	Refresh capacity constraints
`refreshLocalVars(model)`	Refresh local variables
Utility Methods
`setChecks(model, bool)`	Enable/disable consistency checks
`setUsedLangFeature(model, className)`	Mark a language feature as used
`setLogPath(model, logPath)`	Set path for logging
`sanitize(model)`	Sanitize model for consistency
`summary(model)`	Print model summary
`plot(model)`	Plot network graph
`view(model)`	View network in JSIM viewer
`jsimwView(model)`	View in JSIM What-If viewer
`jsimgView(model)`	View in JSIM Graphical viewer
`source = getSource(model)`	Get source node
`sink = getSink(model)`	Get sink node

LayeredNetwork - Layered queueing network model for client-server systems

Method	Description
Constructor
`model = LayeredNetwork(name)`	Create a new layered queueing network
`model = LayeredNetwork(name, filename)`	Create and load from XML file
Static Methods
`model = LayeredNetwork.readXML(filename, verbose)`	Read model from XML file
`model = LayeredNetwork.load(filename, verbose)`	Load model from file (alias for readXML)
`model = LayeredNetwork.parseXML(filename, verbose)`	Parse XML file into LayeredNetwork
`model = LayeredNetwork.fromNetwork(network)`	Convert Network model to LayeredNetwork
Construction Methods
`proc = addProcessor(model, name)`	Add a processor (hardware) to the LQN
`task = addTask(model, name, mult, proc)`	Add a task (software component) running on processor
`entry = addEntry(model, task, name)`	Add an entry point (service interface) to task
`addPrecedence(model, entryA, entryB)`	Define call dependency between entries
Query Methods
`lqn = getStruct(model)`	Get LQN data structure
`E = getNumberOfLayers(model)`	Get number of layers
`E = getNumberOfModels(model)`	Get number of models in ensemble
`layers = getLayers(model)`	Get all layer models
`idx = getNodeIndex(model, node)`	Get index of a node
`node = getNodeByName(model, name)`	Get node by name
`[names,hosts,tasks,entries,acts] = getNodeNames(model)`	Get all node names
`ulf = getUsedLangFeatures(model)`	Get used language features per layer
Kotlin-Style Aliases
`idx = nodeIndex(model, node)`	Alias for getNodeIndex
`node = nodeByName(model, name)`	Alias for getNodeByName
`names = nodeNames(model)`	Alias for getNodeNames
`lqn = struct(model)`	Alias for getStruct
`E = numberOfLayers(model)`	Alias for getNumberOfLayers
`E = numberOfModels(model)`	Alias for getNumberOfModels
`layers = layers(model)`	Alias for getLayers
`ulf = usedLangFeatures(model)`	Alias for getUsedLangFeatures
Utility Methods
`reset(model, isHard)`	Reset the layered model
`sn = summary(model)`	Print model summary (returns sn structure)
`plot(model, showTaskGraph)`	Plot the layered network
`plotGraph(model, useNodes)`	Plot network graph
`plotGraphSimple(model, useNodes)`	Plot simplified graph
`plotTaskGraph(model, useNodes)`	Plot task graph
`view(model)`	View model in JLINE viewer
`writeXML(model, filename, useAbstractNames)`	Write model to XML file
`setUsedLangFeature(model, e, className)`	Mark a language feature as used in layer e
`initUsedFeatures(model)`	Initialize feature tracking

Ensemble - Collection of network models for ensemble analysis

Class	Description
Ensemble	Collection of network models for ensemble analysis
NetworkStruct	Internal structure representation of a network
RoutingMatrix	Defines customer routing between nodes

Node Classes (matlab/src/lang/nodes/)

Source - Arrival point for open classes (generates customers)

Method	Description
Constructor
`source = Source(model, name)`	Create a source node
Arrival Configuration
`setArrival(source, jobclass, distribution)`	Set arrival process for a job class
`distrib = getArrivalProcess(source, oclass)`	Get arrival process for a class

Queue - Service station with waiting buffer (supports FCFS, LCFS, PS, etc.)

Method	Description
Constructor
`queue = Queue(model, name, schedStrategy)`	Create queue with scheduling strategy (FCFS, LCFS, PS, etc.)
Service Configuration
`setService(queue, jobclass, distribution)`	Set service time distribution for a job class
`setService(queue, jobclass, distribution, weight)`	Set service distribution with weight parameter
`distrib = getService(queue, jobclass)`	Get service distribution for a class
Server Configuration
`setNumberOfServers(queue, numServers)`	Set number of parallel servers
`setNumServers(queue, numServers)`	Alternative method to set number of servers
Scheduling Parameters
`setStrategyParam(queue, jobclass, weight)`	Set scheduling strategy parameter for class
Load and Class Dependence
`setLoadDependence(queue, alpha)`	Set load-dependent service (PS, FCFS only)
`setClassDependence(queue, beta)`	Set class-dependent service (PS, FCFS only)
Polling Configuration (POLLING strategy)
`setPollingType(queue, rule, par)`	Set polling rule and parameter
`setSwitchover(queue, jobclass, soTime)`	Set switchover time for POLLING
`setSwitchover(queue, jobclass_from, jobclass_to, soTime)`	Set general switchover between classes
Delay-Off Configuration
`setDelayOff(queue, jobclass, setupTime, delayoffTime)`	Set setup and delay-off times

Delay - Infinite-server station (think time/delay station)

Method	Description
Constructor
`delay = Delay(model, name)`	Create delay (infinite server) node
Service Configuration
`setService(delay, jobclass, distribution)`	Set delay time distribution for a job class
`setService(delay, jobclass, distribution, weight)`	Set service distribution with weight
`distrib = getService(delay, jobclass)`	Get service distribution for a class

Sink - Departure point for open classes (absorbs customers)

Method	Description
Constructor
`sink = Sink(model, name)`	Create a sink node
Utility Methods
`sections = getSections(sink)`	Get node sections

Other Node Types

Class	Description
Router	Routing node for complex routing decisions
Fork	Splits a job into parallel tasks
Join	Merges parallel tasks back into a single job
Cache	Content caching station with replacement policies
ClassSwitch	Node that changes job class probabilistically
Logger	Records job traces for analysis
Place	Petri net place (for generalized stochastic Petri nets)
Transition	Petri net transition (for generalized stochastic Petri nets)

Job Class Classes

OpenClass - Job class with external arrivals (open workload)

Method	Description
Constructor
`jobclass = OpenClass(model, name)`	Create an open job class
`jobclass = OpenClass(model, name, priority)`	Create open class with priority level
Configuration
`setReferenceStation(jobclass, source)`	Set reference station (must be a Source)

ClosedClass - Job class with fixed population (closed workload)

Method	Description
Constructor
`jobclass = ClosedClass(model, name, population, refNode)`	Create closed class with fixed population
`jobclass = ClosedClass(model, name, population, refNode, priority)`	Create closed class with priority
Configuration
`setReferenceStation(jobclass, refNode)`	Set reference station
Utility
`summary(jobclass)`	Print class summary with population

Other Job Class Types

Class	Description
SelfLoopingClass	Special class for self-looping behavior
DisabledClass	Placeholder for disabled class

Support Classes

Class	Description
Chain	Group of related job classes forming a Markov chain
Element	Base class for model elements
NetworkElement	Base class for network-specific elements
Event	Represents discrete events in the model
ModeEvent	Mode-specific event representation
Mode	Operating mode for multi-mode models
Env	Random environment definition
GlobalConstants	Global configuration constants

Solvers (matlab/src/solvers/)

The solvers module provides various analytical and simulation-based solvers.

Base Solver Classes and Common Methods

All solver classes inherit from NetworkSolver and provide these common methods:

Method	Description
Constructor
`solver = SolverXXX(model)`	Create solver instance for a model
`solver = SolverXXX(model, options)`	Create solver with custom options
Analysis Execution
`results = solve(solver)`	Run the solver and return results structure
`[runtime, analyzer] = runAnalyzer(solver, options)`	Run solver analysis with detailed output
Average Performance Metrics
`[QN,UN,RN,TN,AN,WN] = getAvg(solver)`	Get average performance metrics
`[QN,UN,RN,TN,AN,WN] = getAvg(solver, Q,U,R,T)`	Get specified average metrics using handles
`AvgTable = getAvgTable(solver)`	Get results as formatted table
`[QNc,UNc,RNc,TNc] = getAvgChain(solver)`	Get chain-level average metrics
`[CNc,XNc] = getAvgSys(solver)`	Get system-level averages
`[QN,UN,RN,TN,AN,WN] = getAvgNode(solver)`	Get node-level averages
`QN = getAvgQLenChain(solver)`	Get chain queue lengths
`UN = getAvgUtilChain(solver)`	Get chain utilizations
`RN = getAvgRespTChain(solver)`	Get chain response times
`TN = getAvgTputChain(solver)`	Get chain throughputs
`AN = getAvgArvRChain(solver)`	Get chain arrival rates
`RN = getAvgSysRespT(solver)`	Get system response time
`TN = getAvgSysTput(solver)`	Get system throughput
Transient Metrics (solver-dependent)
`[QNt,UNt,TNt] = getTranAvg(solver, Qt,Ut,Tt)`	Get transient average metrics
`[Pi_t, SSnode] = getTranProb(solver, node)`	Get transient node probabilities
`[Pi_t, SSnode_a] = getTranProbAggr(solver, node)`	Get transient aggregated node probabilities
`[Pi_t, SSsys] = getTranProbSys(solver)`	Get transient system probabilities
`[Pi_t, SSsysa] = getTranProbSysAggr(solver)`	Get transient aggregated system probabilities
`RD = getTranCdfRespT(solver, R)`	Get transient response time CDF
`RD = getTranCdfPassT(solver, R)`	Get transient passage time CDF
State Probabilities (solver-dependent)
`Pnir = getProb(solver, node, state)`	Get state probabilities at node
`Pnir = getProbAggr(solver, node, state_a)`	Get aggregated state probabilities
`Pn = getProbSys(solver)`	Get system-wide state probabilities
`Pn = getProbSysAggr(solver)`	Get aggregated system probabilities
`lNormConst = getProbNormConstAggr(solver)`	Get log normalizing constant
Distributions (solver-dependent)
`RD = getCdfRespT(solver, R)`	Get response time CDF
`RD = getCdfSysRespT(solver)`	Get system response time CDF
Sampling (solver-dependent)
`tstate = sample(solver, node, numSamples)`	Sample node state trajectory
`tstate = sampleAggr(solver, node, numSamples)`	Sample aggregated node state
`tstate = sampleSys(solver, numSamples)`	Sample system state trajectory
`tstate = sampleSysAggr(solver, numSamples)`	Sample aggregated system state
Query Methods
`sn = getStruct(solver)`	Get model data structure
`name = getName(solver)`	Get solver name
Kotlin-Style Aliases (from EnsembleSolver)
`s = solver(obj, e)`	Alias for getSolver - get solver for stage e
`it = iteration(obj)`	Alias for getIteration - get current iteration
`E = numberOfModels(obj)`	Alias for getNumberOfModels
`avg = ensembleAvg(obj)`	Alias for getEnsembleAvg
`tables = ensembleAvgTables(obj)`	Alias for getEnsembleAvgTables
`methods = listValidMethods(solver)`	Get list of valid solution methods
`options = getOptions(solver)`	Get current solver options
Control Methods
`reset(solver)`	Reset solver state
`setOptions(solver, options)`	Set solver options
`setChecks(solver, bool)`	Enable/disable consistency checks
Static Methods
`featSupported = SolverXXX.getFeatureSet()`	Get supported model features
`[bool, featSupported] = SolverXXX.supports(model)`	Check if model is supported
`options = SolverXXX.defaultOptions()`	Get default solver options

Kotlin-Style Aliases (for get* methods)

AvgTable = avgTable(solver)

Alias for getAvgTable

AvgTable = avgSysTable(solver)

Alias for getAvgSysTable

AvgTable = avgNodeTable(solver)

Alias for getAvgNodeTable

AvgTable = avgChainTable(solver)

Alias for getAvgChainTable

[QNc,UNc,RNc,TNc] = avgChain(solver)

Alias for getAvgChain

[CNc,XNc] = avgSys(solver)

Alias for getAvgSys

[QN,UN,RN,TN,AN,WN] = avgNode(solver)

Alias for getAvgNode

RN = avgSysRespT(solver)

Alias for getAvgSysRespT

TN = avgSysTput(solver)

Alias for getAvgSysTput

AN = avgArvRChain(solver)

Alias for getAvgArvRChain

QN = avgQLenChain(solver)

Alias for getAvgQLenChain

UN = avgUtilChain(solver)

Alias for getAvgUtilChain

RN = avgRespTChain(solver)

Alias for getAvgRespTChain

TN = avgTputChain(solver)

Alias for getAvgTputChain

QN = avgQLen(solver)

Alias for getAvgQLen

UN = avgUtil(solver)

Alias for getAvgUtil

RN = avgRespT(solver)

Alias for getAvgRespT

TN = avgTput(solver)

Alias for getAvgTput

AN = avgArvR(solver)

Alias for getAvgArvR

[QNt,UNt,TNt] = tranAvg(solver, Qt,Ut,Tt)

Alias for getTranAvg

RD = cdfRespT(solver, R)

Alias for getCdfRespT

Pnir = prob(solver, node, state)

Alias for getProb

Pnir = probAggr(solver, node, state_a)

Alias for getProbAggr

Pn = probSys(solver)

Alias for getProbSys

Pn = probSysAggr(solver)

Alias for getProbSysAggr

lNormConst = probNormConstAggr(solver)

Alias for getProbNormConstAggr

[Q,U,R,T,A,W] = avgHandles(solver)

Alias for getAvgHandles

[Qt,Ut,Tt] = tranHandles(solver)

Alias for getTranHandles Solver Options

Class	Description
SolverOptions	Configuration options for solvers (method, tolerance, iterations, etc.)
SolverFeatureSet	Describes features supported by a solver

Analytical Solvers

SolverMVA - Mean Value Analysis (MVA/)

Method	Description
Valid Methods
'default', 'mva', 'exact', 'amva', 'qna', 'qdlin', 'amva.qdlin', 'bs', 'amva.bs', 'sqni', 'qd', 'amva.qd', 'qli', 'amva.qli', 'fli', 'amva.fli', 'lin', 'egflin', 'gflin', 'amva.lin', 'mm1', 'mmk', 'mg1', 'mgi1', 'gm1', 'gig1', 'gig1.kingman', 'gigk', 'gigk.kingman_approx', 'gig1.gelenbe', 'gig1.heyman', 'gig1.kimura', 'gig1.allen', 'gig1.kobayashi', 'gig1.klb', 'gig1.marchal', plus bounds methods
Description
Exact solver for product-form networks, approximate solver for non-product-form. Supports closed, open, and mixed models with various scheduling disciplines.

SolverCTMC - Continuous-Time Markov Chain (CTMC/)

Method	Description
Additional Methods
`[infGen, eventFilt, synchInfo] = getGenerator(solver, options)`	Get infinitesimal generator matrix
`[infGen, eventFilt, synchInfo] = getInfGen(solver, options)`	Get infinitesimal generator (alias)
`[infGen, eventFilt, synchInfo, SS, SSnode] = getSymbolicGenerator(solver, invertSymbol, primeNumbers)`	Get symbolic generator with state space
`[SS, SSnode] = getStateSpace(solver, options)`	Get state space representation
`SSa = getStateSpaceAggr(solver)`	Get aggregated state space
`MCTMC = getMarkedCTMC(solver, options)`	Get marked CTMC object
Kotlin-Style Aliases
`SS = stateSpace(solver, options)`	Alias for getStateSpace
`Q = generator(solver, options)`	Alias for getGenerator
Valid Methods
'default', 'gpu'
Description
State-space enumeration solver. Exact for models with finite state space. Supports arbitrary service distributions and scheduling.

SolverFluid - Fluid/Mean-Field Approximation (Fluid/)

Method	Description
Valid Methods
'default', 'softmin', 'statedep', 'closing', 'matrix'
Description
ODE-based fluid approximation for large-scale models. Efficient for models with large populations.

SolverMAM - Matrix-Analytic Methods (MAM/)

Method	Description
Valid Methods
'default', 'dec.source', 'dec.mmap', 'dec.poisson', 'mna'
Description
Matrix-analytic methods for models with phase-type distributions and Markovian arrival processes.

SolverNC - Normalizing Constant (NC/)

Method	Description
Additional Methods
`[normConst, lNormConst] = getNormalizingConstant(solver)`	Get normalizing constant
Valid Methods
'default', 'exact', 'imci', 'ls', 'le', 'mmint2', 'gleint', 'panacea', 'ca', 'kt', 'sampling', 'propfair', 'comom', 'cub', 'rd', 'nrp', 'nrl', 'gm'
Description
Normalizing constant computation for closed product-form networks. Multiple exact and approximate algorithms.

SolverSSA - Stochastic Simulation Algorithm (SSA/)

Method	Description
Additional Methods
`[runtime, tranSysState, tranSync] = run(solver, options)`	Run stochastic simulation
Valid Methods
'default', 'ssa', 'serial', 'para', 'parallel', 'nrm'
Description
Gillespie-style stochastic simulation. Supports all model features, provides trajectory sampling.

SolverAuto - Automatic solver selection (AUTO/)

Method	Description
Additional Methods
`chooseSolver(solver, method)`	Choose appropriate solver based on model
`chooseSolverAI(solver, method)`	AI-based solver selection
`chooseSolverHeur(solver, method)`	Heuristic solver selection
`chooseAvgSolverAI(solver)`	AI-based choice for Avg methods
`chooseAvgSolverHeur(solver)`	Heuristic choice for Avg methods
`delegate(solver, method, nretout, varargin)`	Delegate method to chosen solver
Description
Automatically selects the best solver for a given model and metric. Delegates all performance metric methods to the chosen solver.

External Solver Wrappers

SolverJMT - Java Modelling Tools (JMT/)

Method	Description
Configuration
`setJMTJarPath(solver, path)`	Set path to JMT.jar
`path = getJMTJarPath(solver)`	Get JMT.jar path
`path = getFilePath(solver)`	Get file path for JMT files
`filename = getFileName(solver)`	Get filename for JMT files
Analysis
`[result, parsed] = getResults(solver)`	Get simulation results
`result = getResultsJSIM(solver)`	Get JSIM simulation results
`result = getResultsJMVA(solver)`	Get JMVA analytical results
File I/O
`writeJSIM(solver, sn, outputFileName)`	Write JSIM model file
`writeJMVA(solver, sn, outputFileName, options)`	Write JMVA model file
Viewing
`jsimwView(solver, options)`	View in JSIM What-If viewer
`jsimgView(solver, options)`	View in JSIM graphical viewer
Static Methods
`bool = SolverJMT.isAvailable()`	Check if JMT is available
`SolverJMT.jsimgOpen(filename)`	Open file in JSIM graphical mode
`SolverJMT.jsimwOpen(filename)`	Open file in JSIM What-If mode
`parseLogs(solver, model, isNodeLogged, metric)`	Parse JMT log files
`parseTranState(solver, fileArv, fileDep, nodePreload)`	Parse transient state data
`parseTranRespT(solver, fileArv, fileDep)`	Parse transient response time data
Valid Methods
'default', 'jsim', 'jmva', 'jmva.amva', 'jmva.mva', 'jmva.recal', 'jmva.comom', 'jmva.chow', 'jmva.bs', 'jmva.aql', 'jmva.lin', 'jmva.dmlin'
Description
Wrapper for Java Modelling Tools solvers. Provides both simulation (JSIM) and analytical (JMVA) capabilities.

SolverLQNS - Layered Queueing Network Solver (LQNS/)

Method	Description
Analysis
`AvgTable = getAvgTable(solver)`	Get metrics table for layered model
`[result, iterations] = parseXMLResults(solver, filename)`	Parse LQNS XML results
`savedfname = plot(solver, model)`	Plot layered model
Static Methods
`bool = SolverLQNS.isAvailable()`	Check if LQNS is available on system path
Valid Methods
'default', 'lqns', 'srvn', 'exactmva', 'srvn.exactmva', 'sim', 'lqsim', 'lqnsdefault'
Description
Wrapper for Layered Queueing Network Solver. Supports both analytical and simulation methods for LQN models.

SolverQNS - QNS Solver (LQNS/)

Method	Description
Analysis
`runtime = run(solver)`	Run QNS solver
Static Methods
`bool = SolverQNS.isAvailable()`	Check if QNS is available
Valid Methods
'default', 'conway', 'rolia', 'zhou', 'suri', 'reiser', 'schmidt'
Description
Wrapper for QNS queueing network solver. Multiple approximation algorithms available.

Composite Model Solvers

SolverLN - Layered Network Decomposition (LN/)

Method	Description
Constructor
`solver = SolverLN(lqnmodel, solverFactory, options)`	Create layered network solver with factory for per-layer solvers
Analysis
`[QN,UN,RN,TN,AN,WN] = getEnsembleAvg(solver)`	Get layer-averaged metrics
`[AvgTable,QT,UT,RT,WT,AT,TT] = getAvgTable(solver, useLQNSNaming)`	Get metrics table with optional LQN naming
`cdfRespT = getCdfRespT(solver)`	Get entry response time CDFs
`[QNlqn_t, UNlqn_t, TNlqn_t] = getTranAvg(solver)`	Get transient layer averages
Layer Management
`svcmatrix = getEntryServiceMatrix(solver)`	Get entry service matrix
Kotlin-Style Aliases (from EnsembleSolver)
`s = solver(obj, e)`	Alias for getSolver - get solver for layer e
`it = iteration(obj)`	Alias for getIteration - get current iteration
`E = numberOfModels(obj)`	Alias for getNumberOfModels
`avg = ensembleAvg(obj)`	Alias for getEnsembleAvg
`tables = ensembleAvgTables(obj)`	Alias for getEnsembleAvgTables
Valid Methods
'default', 'moment3'
Description
Layered network decomposition solver. Iteratively solves each layer using specified per-layer solver.

SolverEnv - Random Environment Solver (ENV/)

Method	Description
Constructor
`solver = SolverEnv(renv, solverFactory, options)`	Create environment solver with factory for stage solvers
Analysis
`[QN,UN,RN,TN,AN,WN] = getEnsembleAvg(solver)`	Get environment-averaged metrics
`AvgTable = getAvgTable(solver, keepDisabled)`	Get metrics table
`envsn = getStruct(solver)`	Get environment structures (cell array)
`[renvInfGen, stageInfGen, ...] = getGenerator(solver)`	Get random environment generator
Description
Solver for models in random environments. Computes weighted averages across environment stages.

LINE - Unified solver interface

Method	Description
LINE	Unified solver interface that delegates to appropriate solver

Distributions (matlab/src/lang/processes/)

The processes module provides probability distributions for service and arrival processes.

Base Distribution Classes

Class	Description
Distribution	Abstract base class for all distributions
ContinuousDistribution	Base class for continuous distributions
DiscreteDistribution	Base class for discrete distributions
Markovian	Marker interface for Markovian (memoryless) distributions
Process	Base class for stochastic processes

Continuous Distributions

Class	Parameters	Description
Exp	(rate)	Exponential distribution - memoryless, fundamental for queueing
Det	(value)	Deterministic (constant) distribution
Erlang	(k, rate)	Erlang distribution - sum of k exponentials
Gamma	(shape, scale)	Gamma distribution - generalization of Erlang
HyperExp	(p, rates)	Hyperexponential - mixture of exponentials
Lognormal	(mu, sigma)	Log-normal distribution
Pareto	(shape, scale)	Pareto (power-law) distribution
Uniform	(min, max)	Continuous uniform distribution
Weibull	(shape, scale)	Weibull distribution

Phase-Type Distributions

Class	Parameters	Description
APH	(alpha, T)	Acyclic Phase-Type distribution
Coxian	(mu, phi)	Coxian distribution (sequential phases)
Cox2	(mu1, mu2, phi1)	Two-phase Coxian distribution
PH	(alpha, T)	General Phase-Type distribution

Markovian Arrival Processes

Class	Parameters	Description
MAP	(D0, D1)	Markovian Arrival Process
MarkedMAP	(D0, D1, ...)	Marked Markovian Arrival Process
MMPP2	(lambda0, lambda1, sigma0, sigma1)	Two-state Markov-Modulated Poisson Process
MarkedMMPP	(D0, D1, ...)	Marked Markov-Modulated Poisson Process
MarkovModulated	-	Base for Markov-modulated processes
MarkovProcess	-	General Markov process
MarkovChain	-	Discrete/continuous-time Markov chain

Discrete Distributions

Class	Parameters	Description
Bernoulli	(p)	Bernoulli distribution (success/failure)
Binomial	(n, p)	Binomial distribution
DiscreteUniform	(min, max)	Discrete uniform distribution
Geometric	(p)	Geometric distribution
Poisson	(rate)	Poisson distribution
Zipf	(s, N)	Zipf distribution (power-law for ranks)
DiscreteSampler	(p, x)	Empirical discrete distribution from samples

Special Distributions

Class	Parameters	Description
Disabled	-	Placeholder for disabled process
Immediate	-	Zero-time (instantaneous) distribution
Replayer	(filename)	Replays events from a trace file
Trace	(filename)	Generic trace representation
EmpiricalCDF	(c, x)	Empirical CDF from data

Layered Networks (matlab/src/lang/layered/)

The layered module provides support for layered queueing networks (LQNs).

Main Classes

Class	Description
LayeredNetwork	Container for layered queueing network models
LayeredNetworkElement	Base class for LQN elements
LayeredNetworkStruct	Internal structure representation

Network Elements

Class	Description
Processor	Hardware resource (CPU, disk, etc.)
Host	Alias for Processor
Task	Software component running on a processor
Entry	Service interface of a task
Activity	Unit of work within an entry
ActivityPrecedence	Control flow between activities

Cache Tasks

Class	Description
CacheTask	Task with caching behavior
FunctionTask	Task defined by a function
ItemEntry	Entry for cache item access