All Classes and Interfaces
Class
Description
Information about an action in an RCAT model.
An Activity represents an individual processing step or service operation within a Task
in a layered queueing network.
A set of call targets dispatched as one group by a routing strategy.
A class modeling precedence relationships among activities
Constants for defining activity precedences in LayeredNetwork models
Optimize the activity-level think time of an LQN Activity (continuous).
Sampling method to approximate the permanent using Adaptive Partitioning (AdaPart).
Runs all advanced examples by invoking their main methods.
Loop-invariant context precomputed by
State.afterEventInit(jline.lang.NetworkStruct) for
State.afterEvent(jline.lang.NetworkStruct, int, jline.util.matrix.Matrix, jline.lang.constant.EventType, int, boolean).Event handler for stateful Fork nodes (FJ tag-augmented structs only,
see ModelAdapter.fjtag).
Event handler for Join stations on FJ tag-augmented structs (see
ModelAdapter.fjtag).
Result of a pass-and-swap transition: the new ordered list and the departing class.
Arrival of a REPLY signal class at the FCFS station that is holding a server for
the matching synchronous call.
Fork firing synchronization handler (FJ tag-augmented structs, see
ModelAdapter.fjtag).
Result container for global event processing in Stochastic Petri Net models.
AG is an alias for SolverAG (RCAT agent-decomposition solver).
The single definition of what one agent's answer is.
Model factory for AG, the agent-based solver, examples.
Examples demonstrating SolverAG, LINE's agent-based solver, and its INAP methods.
Execution backend of the reversed-rate fixed point.
Options of the agent-based (RCAT) solver.
Result of the agent-based (RCAT) solver.
The ag-worker wire protocol, encoder and decoder in one place.
Worker process for the AG solver's
cluster execution backend.Coordinator-side connection to one ag-worker process.
Main benchmark runner - runs all benchmark suites
Runs all examples by invoking BasicExamples and AdvancedExamples.
Top-level functions for AMAP2 gamma fitting.
Triple holder for adjustment results.
Amap2 Fit Gamma algorithms (documentation marker class).
Result of aoi_dist2ph conversion.
Marker for Aoi_result.kt.
Single-buffer AoI solver using Markovian Fluid Queues.
Result of Age of Information analysis for general queue types.
Extracted parameters for AoI analysis.
Result of Age of Information analysis for simple queue types.
Result of AoI topology validation.
An acyclic phase type distribution
Facade class for Acyclic Phase-Type (APH) functions.
Convolution patterns for APH simplification.
Absorbing Phase-type distribution fitting from MAP.
Absorbing Phase-type distribution trace-based fitting.
AUTO is an alias for SolverAUTO (Automatic solver selection).
Options specific to the AUTO solver
Handle for managing performance metrics organized by station and job class.
Abstract base class for representing average performance metrics tables.
BA is an alias for SolverBA (Bound Analysis solver).
Constants for specifying balking strategies (customer refusal to join queue).
Represents a balking threshold for queue-length based balking.
Common base class for matrix implementations, providing a unified interface
for both dense and sparse matrix operations.
Runs all basic examples by invoking their main methods.
Basic utility functions for the KPC-Toolbox.
Benchmark for Closed Queueing Networks with First-Come-First-Serve (FCFS) scheduling
All configurations (standard, hicv, multiserver, random mapping)
Benchmark for Closed Queueing Networks with Processor Sharing (PS) scheduling
Light load configuration
CQN PS1 Benchmarks - Population: N1=2, N2=4
CQN PS2 Benchmarks
CQN PS3 Benchmarks
CQN PS4 Benchmarks
Dedicated benchmark runner for CQN Repairmen (RM) models
Provides MATLAB-style formatted output
Template for CQN benchmark implementations
Benchmark for Fork-Join Closed Networks
Tests both homogeneous and heterogeneous configurations
Benchmark for Fork-Join networks with FCFS scheduling
Comprehensive benchmark suite with all configurations
Benchmark for Fork-Join Mixed Networks (combination of open and closed classes)
Tests both homogeneous and heterogeneous configurations
Benchmark for Fork-Join Nested Networks
Tests nested fork-join structures with closed, open, and mixed configurations
Benchmark for Fork-Join Open Networks
Tests both homogeneous and heterogeneous configurations
Benchmark for Fork-Join networks with PS scheduling
Comprehensive benchmark suite with all configurations
Template for Fork-Join benchmark implementations
Supports all configurations: sc, mc, mc2, mc3, mc4 with standard and high CV
LQN benchmark using Custom solver configurations with various parameters
Custom solver factory with configurable parameters
LQN benchmark using Default solver configuration
Default solver factory for LQN benchmarks
LQN benchmark using Fluid solver
Fluid solver factory for LQN benchmarks
LQN benchmark using LQNS solver (Layered Queueing Network Solver native)
Note: Uses JMT as a proxy since native LQNS is external
LQNS-style solver factory for LQN benchmarks
LQN benchmark using MVA solver (Mean Value Analysis)
MVA solver factory for LQN benchmarks
LQN benchmark using NC solver (Normalizing Constant)
NC solver factory for LQN benchmarks
LQN benchmark using SRVN solver (Stochastic Rendezvous Networks)
Note: Uses JMT as a proxy since native SRVN is external
SRVN-style solver factory for LQN benchmarks
Handles benchmark regression testing by storing and comparing against baseline scores
Container for benchmark results
Container for regression baseline data
Container for regression comparison results
Benchmark solver initialization utility
Utility functions for benchmarking
Benchmark for Mixed Queueing Networks with FCFS scheduling.
Benchmark for Mixed Queueing Networks with Processor Sharing (PS) scheduling.
Template for MQN (Mixed Queueing Network) benchmark implementations.
Benchmark for Open Queueing Networks with FCFS scheduling.
Benchmark for Open Queueing Networks with Processor Sharing (PS) scheduling.
Template for OQN (Open Queueing Network) benchmark implementations.
A Bernoulli distribution for modeling binary random variables.
Steady-state quantities of a state dependent Bernoulli server.
Implementation of Sum Product Algorithm (SPA) to approximate the Bethe permanent.
A Binomial distribution
Exact O(log n) solver for a single integer decision variable with monotone
feasibility (the standard sizing pattern), an alternative to differential
evolution.
A Batch Markovian Arrival Process (BMAP)
BMAP is a point process where arrivals occur in batches.
Result of BMAP/MAP/1 queue analysis.
Result of BMAP sampling containing inter-arrival time and batch size.
Bogacki-Shampine 3(2) embedded Runge-Kutta integrator, the method MATLAB's
ode23 implements.Budget constraint: total cost <= budget, cost from variable values.
Input buffer of a station
Build PH representation for 2-node Fork-Join job.
Busy period of a subnetwork, exactly and by simulation.
A cache node that implements cache replacement policies and class switching based on cache hits and misses.
One (item, list) pair that is size-feasible for the list but unreachable
because an intermediate list on the promotion path rejects the item.
Position-resolved mean-field miss rates for FIFO(m) caches.
Refined mean-field (1/N-accurate) miss rates for RANDOM(m) caches.
Position-resolved mean-field miss rates for strict FIFO(m) caches.
Result of cache_miss analysis.
Steady state of the RANDOM(m) multi-list mean field.
Expansion result.
Tree-based TTL cache analysis implementation for the LINE solver framework.
Cache ttl tree algorithms.
A key class for storing popularity distributions in a 2D coordinate system.
A deferred retrieval-system routing edge, injected into the routing matrix by
Network.link.
A class switcher section recording cache hits and misses
Position-resolved density-dependent population process (DDPP) mean field for
FIFO(m) cache replacement.
Result of cache_miss_fpi: global miss rate, per-user miss rates, per-item miss rates,
and per-item miss probabilities.
Transient refined-mean-field cache trajectory returned by
Cache_miss_rmf.cache_miss_rmf_tran(jline.util.matrix.Matrix, jline.util.matrix.Matrix, jline.util.matrix.Matrix[], double, int, double[]).Examples of caching models
Parameter container for cache nodes in queueing networks.
General position-resolved density-dependent population process (DDPP) mean
field for FIFO(m) / strict FIFO(m) caches honouring a per-item access graph.
Runnable examples for cache models with a retrieval system (delayed hits).
Builders for cache models that use a retrieval system (delayed hits).
Multi-list cache with RANDOM(m) replacement as a Density-Dependent Population Process (DDPP).
Result of dimension reduction.
Result of reduced system computation.
Result of cache_rrm_meanfield: the terminal occupancy of the RANDOM(m)
mean field, the global miss rate and the miss ratio.
Position-resolved density-dependent population process (DDPP) mean field for
strict FIFO(m) cache replacement.
A task that offers caching services
Transient refined-mean-field cache trajectory for a network, produced by
FluidCacheTran.python/examples/basic/cacheModel/: the replacement-policy comparison,
the refined mean-field cache, and the five retrieval systems (delayed hits).Constants for defining calls in LayeredNetwork models
Result class for CanonicalFromDPH2 containing both beta and B.
Result class for CdfFromTrace containing x and y arrays.
Examples demonstrating CDF (Cumulative Distribution Function) of response times.
Examples of response time distribution analysis.
python/examples/advanced/cdfRespT/: the response-time CDF, not the
mean.Peak of a class-dependence handle over the population lattice.
A class modelling a set of reachable classes for a given job (a chain)
Chain-aggregation strategy for
TransformSolve.Carries what the deaggregation needs from the aggregation.
Result container for characteristic maximum.
Optimize the priority of job classes.
Optimize the class-to-station mapping by rerouting a job class through a
selected candidate station and bypassing the others, preserving default
routing of every other class.
A node that switches the class of an incoming job based on a probability table
A job class switcher based on a static probability table
Class switching examples mirroring the example notebooks in classSwitching.
Examples of models with class switching
Matrix representation for job class switching probabilities in queueing networks.
Class where jobs perpetually loop without arriving or leaving (Closed class)
Closed queueing network examples mirroring the example notebooks in closedQN.
Examples of closed queueing networks
A closed signal class for modeling signals in closed queueing networks.
Builder for cluster models with helpers to compare dispatching/scheduling
policies and to sweep parameters.
Demonstrates cluster modelling APIs:
The static factories
Network.cluster*
The Cluster builder with comparison and sweep helpers
Server-cluster models built with the
Network.cluster(jline.util.matrix.Matrix, jline.util.matrix.Matrix, jline.lang.constant.SchedStrategy[], jline.util.matrix.Matrix, jline.lang.constant.RoutingStrategy) static factories.A Concentrated Matrix Exponential (CME) distribution.
Collects and aggregates metrics from SSA simulation for streaming to line-est.
A lightweight view into a column of a sparse matrix that doesn't copy data.
A matrix class for handling complex-valued matrices using separate real and imaginary components.
The few complex operations the transform layer needs.
Compute T-matrix using NARE (Nonsymmetric Algebraic Riccati Equation) method.
Result of computeT.
Conditioning event for sampled metrics.
Abstract base for line-opt constraints.
An abstract class for continuous distributions
Copyable interface allows to perform deep-copy of objects via the copy() method.
Data class for count statistics
A Coxian distribution with 2 phases.
A general Coxian distribution with n phases.
Formats CQN benchmark results in MATLAB-style output format
Benchmark result data structure
Accumulates benchmark results for batch formatting
Input class for ClassSwitcher function.
CTMC is an alias for SolverCTMC (Continuous Time Markov Chain solver).
Outcome of a BiCGSTAB solve.
Transient distribution of a fast adaptive uniformization sweep, together
with the diagnostics that make its error auditable.
Poisson weights on the Fox-Glynn truncation window.
Outcome of a GMRES solve.
Mean time to reach any state in a target set from each state of a CTMC.
Result of ctmc_multi computation.
Laplace-Stieltjes transform of the first passage time into a target state
set: L(s) = alpha (sI-S)^-1 s0 + atom.
Moments of order 1..nmax of the first passage time into a target state set.
Phase-type representation of the first passage time into a target STATE SET.
Cumulative distribution and density of the first passage time into a target
state set: F(t) = 1 - alpha exp(St) 1 and f(t) = alpha exp(St) s0.
CTMC random generator matrix construction.
Saddlepoint approximation of Pr{N(t)=k} for the counting process of a MAP.
Perron root of A(theta) with its first two derivatives in theta and the
amplitude of the Perron projection between pi0 and 1.
Result of a saddlepoint evaluation, one entry per (t,k) pair.
Solve reducible CTMCs via direct block decomposition on the generator matrix.
Result of full reducible CTMC solve.
Reachability-based CTMC state space generation for FJ tag-augmented
structs (ModelAdapter.fjtag).
CTMC State Space Generator for Reachability Analysis.
Sensitivity of the transient distribution of a CTMC to a scalar parameter.
Distribution and its sensitivity on the integrator's accepted grid.
Result of connected component analysis.
Result of CTMC solving.
The phase-type form of a first passage time into a target state set.
Result data class for CTMC SSG reachability analysis
Single entry point for the stationary distribution of a CTMC generated from a
NetworkStruct.
Examples demonstrating cyclic polling systems.
Examples of models with polling
Decomposition-aggregation driver for a CLOSED integrated cache-queueing model
whose Cache node has a delayed-hit retrieval system (Cache.setRetrievalSystem).
Network solver used for the aggregation step (mvald / ncld).
Generic damped successive-substitution driver for decomposition-aggregation
(DA) fixed-point iterations.
Convergence measure between the updated iterate and the baseline.
Driver options.
Final iterate, sweeps executed, and convergence flag.
One DA sweep from iterate x at sweep count it.
Pair returned by a sweep: updated iterate and comparison baseline.
Asymptotic-method superposition of independent flows with given rates and
squared coefficients of variation: returns the rate-weighted SCV mixture of
the merged flow (Whitt's QNA stationary-interval formula).
Differential-algebraic formulation of the min-normal closure, backing
options.method='dae'.Abstract base for line-opt decision variables.
Decomposes a joint optimization problem into per-variable-type subproblems
solved via Gauss-Seidel cycling with fixed-value propagation.
An infinite server station, i.e.
Runnable examples for cache models with a retrieval system that exhibit
delayed hits: while an item is being fetched by the retrieval system
after a miss, subsequent requests for the same item neither hit nor miss
outright but are delayed until the in-flight retrieval completes.
Base class for dense matrix implementations, containing the core data structure
and methods that directly manipulate the underlying dense matrix representation.
Departure disciplines for the depository of a queueing place (QPN semantics).
A Deterministic distribution taking a single constant value.
Deterministic (Semi-Markov) Process functions.
Self-contained port of scipy's
differential_evolution that reproduces
its trajectory bit-for-bit for a given integer seed, using
NumpyRandomState for all draws.Per-generation callback; return true to stop early.
Objective returning the (penalized) energy; may be
+inf.Diffusion approximation for closed multiclass BCMP networks.
A directed graph data structure with weighted edges represented as an adjacency matrix.
A special distribution to denote disabled service or arrival.
Class of jobs that perpetually loop at a given station
An abstract class for discrete distributions.
Discrete-time (slotted) examples, one per feature of the discrete-time
normalizing-constant route.
Discrete-time (slotted) model builders.
A class for discrete distributions specified from the probability mass function
A discrete distribution that samples uniformly among a set of elements.
Output section that routes jobs to nodes
An abstract class of a general distribution
Rate-scaled copies of a distribution, preserving its shape.
A Discrete Markovian Arrival Process (DMAP).
Discrete-time batch arrival streams: event rate, superposition, Bernoulli
splitting and order reduction.
Result of D/M/c queue analysis.
Docker primitives shared by the backends that legitimately ship an image: the
JMT backend (
imperialqore/jmt-rest) and the Sage symbolic engine
(imperialqore/line-sage-rest).Buzen-style recursions for the discrete-time closed cycle of Bernoulli
servers with state independent service probabilities.
Convolution over the discrete-time product form of a closed cycle of state
dependent Bernoulli servers.
Normalizing constants of a discrete-time closed cycle of state dependent
Bernoulli servers.
Normalizing constants of a discrete-time closed cycle of Bernoulli servers
with state independent service probabilities.
Exact discrete phase-type representation of a lattice-valued law.
Renewal DMAP of a discrete phase-type law, and its inverse.
Exact analysis of a state dependent Bernoulli server on a discrete time
scale.
Geo/Geo/1 discrete-time queueing system analysis.
Geo^X/Geo/1 discrete-time queueing system analysis.
Constants for specifying drop strategies at stations when capacity is exceeded.
Discrete-Time Markov Chain (DTMC) analysis functions.
DTMC random transition matrix generation.
Result class for DTMC solve reducible.
Stochastic complement together with the blocks it was built from.
Result class for DTMC uniformization analysis containing the probability vector and maximum iterations used.
Result of a discrete-time (slotted) single-server queue analysis.
Superclass for model elements
Empirical CDF for a distribution
A section that models enabling conditions in a stochastic Petri net transition
A model defined by a collection of sub-models
An Entry represents a service interface exposed by a Task in a layered queueing network.
Deprecated.
ENV is an alias for SolverENV (Ensemble environment solver).
Example demonstrating the node breakdown/repair API for random environments.
An environment model defined by a collection of network sub-models coupled with an environment transition rule
that selects the active sub-model.
Descriptor of a node breakdown/repair macro applied through
addNodeBreakdown / addNodeRepair.State-vector reset policy for the SolverENV state-vector analyzer
(options.method='statevec').
Twins for the random-environment examples the JAR did not carry.
Extended Renewal Continuous-time Hidden Markov Model (ER-CHMM) functions.
Result class for ER-CHMM EM fitting.
An Erlang-n distribution with n phases.
Options for ParamEstimator.
Result from evaluating a LINE network model via SolverAUTO, holding the
per-(station, class) performance metrics the optimizer reads.
Class abstracting an event within a Network model
A class storing events
A data structure acting as a key to the EventCache
Constants for specifying events
A filesystem path for a data file an example reads, wherever that example was loaded from.
Run one example by name, the way
line-examples runs one C++ example.An exponential distribution.
Expolynomial distribution with density f(x) = sum ci * x^ai * exp(-li*x).
Examples demonstrating Finite Capacity Region (FCR) usage.
Examples of models with Finite Capacity Regions (FCR).
Class representing the features of a particular solver
Aggregates a subnetwork into a load-dependent MAP flow-equivalent server that reproduces
mean, variability and burstiness of its output.
Recovers the per-station metrics of an aggregated subnetwork by conditioning on the
population held by the flow-equivalent server.
Integrates v*int_0^inf exp(T0 t) dt by the trapezoid rule.
Returns the population levels at which the inter-departure MAP is evaluated.
Builds the MAP (T0,T1) of the inter-departure times of a closed subnetwork made of one
MAP station and one MAP flow-equivalent server.
Monotone piecewise cubic Hermite interpolation.
Expands a MAP into the per-level processes of a load-dependent server.
Computes the first three moments, the lag-1 joint moment and the index of dispersion of
a MAP without forming (-T0)^-1.
Solves the reduced model made of a delay and a load-dependent MAP flow-equivalent server.
Deprecated.
Use jline.lang.ModelAdapter.aggregateFES() for public API
Per-population queue lengths and utilizations of the isolated subnetwork.
Wraps a flow-equivalent-server (FES) throughput table as a per-class
class-dependence function beta_{i,r}(n).
Information needed to deaggregate FES results back to original model.
The load-dependent MAP that replaces an aggregated subnetwork, with the descriptors it
was fitted from.
Metrics of the stations an aggregate stands for, recovered by conditioning on its
population.
Moments and index of dispersion of an inter-departure MAP.
System metrics of the closed model made of a delay and a MAP flow-equivalent server.
Options for Flow-Equivalent Server (FES) aggregation.
Result of Flow-Equivalent Server (FES) aggregation.
Evaluation function returning distance from Markovian representation.
Transformation function applied to a representation.
Output section that models the process of firing for a transition in a Stochastic Petri net model
Result container for Fork-Join bounds.
The lattice laws whose characteristic maximum is closed.
[mK, lo, hi] of fj_char_max_blom; the bracket is the standard normal one.
[MK, mK, exact] of fj_char_max_discrete.
[R, Q, X, U] of fj_amva.
[Q, y] of fj_qgb: the bounded queue lengths and the geometric ratios.
[R, exact] of fj_respt_closed.
[d, Edisp, Emax] of fj_delay_opt.
[Edisp, Emax, Emin] of fj_dispersion.
[mu1, mu2, q, kmin, kmax] of fj_cox_fit.
[Xmax, m1, c2] of fj_xmax_coxian.
Mean of the k-th smallest of n independent EXPONENTIAL branch completion times, i.e.
[C, I, Cend, E] of fj_dag_makespan.
Everything Green's cycle decomposition produces.
[Rreq, Rtask, Q, p] of fj_respt_bulk.
[R, rho] of fj_respt_nosplit.
[P, delay, Rtot] of fj_serialization.
[Lmax, Llp, Lfcfs, states, prob] of fj_tsm_capacity.
Completion time of a k-of-n (quorum) join over independent, not necessarily identically
distributed branches.
A discrete step function on a finite, increasing time grid.
ForkTail black-box tail-latency approximation for fork-join requests.
Fitted generalized-exponential parameters of one branch.
Mean and variance of a branch response time.
Tail latency of a k-of-n (quorum) fork-join request.
Result container for expected maximum of normal distribution.
Result container for expected maximum of Pareto distribution.
Arrival representation for FJ_codes.
FJ_codes utility helpers: the free functions of the FJ_codes port, collected
as static methods on a non-instantiable holder.
Solver-agnostic driver of the fork-join fixed point.
Outcome of the fixed point: the merged metrics and the retained state.
State the fixed point retains across calls, as MATLAB keeps on the solver.
The inner solve of one pass of the fixed point.
Information about detected Fork-Join topology.
Service representation for FJ_codes.
Service representation for 2-node FJ job.
A fork firing synchronization on an FJ tag-augmented struct (see
ModelAdapter.fjtag).
Fork-join TAG AUGMENTATION, the transform/lift pair shared by CTMC and SSA.
What the expand phase hands the lift phase.
The lifted metrics, in ORIGINAL class coordinates.
FLD is an alias for SolverFluid (Fluid/Mean-Field Approximation solver).
Result class for FluFluQueue containing ME distribution parameters
and computed performance measures.
Fluid is an alias for SolverFluid (Fluid/Mean-Field Approximation solver).
Transient refined-mean-field cache trajectory for an (open) integrated
cache-queueing network.
Moment closures of the fluid drift, backing
options.method='minnormal'
of SolverFluid.A vector of capacity shares together with its Jacobian, and the joint-closure
covariance Cov(S_j,N) and its Jacobian.
A closure value together with its first two derivatives with respect to the mean.
Detects a moment-closure trajectory that has left the model.
Whether
DaeAnalyzer can answer a model,
used by SolverFluid to try dae before dropping a declined
minnormal to a first-order method.Whether the fluid drift of a model should be built on the stochastic complement of its
INSTANTANEOUS coordinates (see
ImmediateElimination).Clamped piecewise-linear interpolation of a vector-valued trajectory.
Stationary covariance of the linear noise approximation.
The stationary covariance together with the diagnostics of the reduced solve.
Whether
MinNormalAnalyzer can answer a
model, used by the default method of SolverFluid to prefer
minnormal over matrix when it applies.Event-based representation of the fluid population process, as required by the
moment-closure methods of SolverFluid.
Non-homogeneous Poisson (NHPP) support for the fluid solver.
The fluid fixed point has no stationary linear noise approximation: the drift
Jacobian is not Hurwitz on the reachable subspace (balanced bottlenecks, a
saturated multiclass station, an overloaded open station).
Symbolic export of the mean-field ODE system integrated by SolverFluid.
Structural description of the exported ODE system.
Per-coordinate service share of the closing fluid ODE and its analytic
Jacobian.
Time-varying per-event rate multiplier of the closing fluid ODE.
An NHPP source intensity attached to a (station, class) of the sn index
space.
An explicit rate trajectory attached to a (station, class) of the sn
index space.
Refined mean field correction of a fluid fixed point (Gast, POMACS 2017).
The correction, plus what it took to compute it.
Result container for Fluid solver analysis of queueing networks.
Result class for FluidSolve.
Time-varying per-state rate multiplier of the matrix-method fluid ODE.
Small matrix helpers shared by the fluid-queue ports (diagonal extraction,
index-based submatrices, block assembly).
A node that forks an incoming job into a set of sibling tasks.
Output section that forks incoming jobs into sibling tasks
One variable-forking-level override.
Fork-join network examples mirroring the example notebooks in forkJoin.
Examples of fork-join queueing networks
Parameter container for fork nodes in queueing networks.
Function wrapper class, allowing us to add and multiply using the complex high-precision Apcomplex by overriding UnaryOperator.
Deprecated.
Use SetupTask, or a plain Task with setSetupTime() and setDelayOffTime().
Gallery of simple and classical queueing models
Register the model gallery as the
test_gallery_* parity twins.A Gamma distribution.
Result class for GeneralFluidSolve containing the parameters of the
matrix-exponentially distributed stationary distribution.
Result of generateService.
Observation epoch for a discrete-time Geo/Geo/1 queue.
Result of a discrete-time Geo/Geo/1 queue analysis.
A Geometric distribution.
Result of a discrete-time Geo^X/Geo/1 queue analysis.
Getting started examples
Twins for the
gettingstarted tutorials the JAR did not carry.Options for GIM1_R solver
Result of GIM1 Caudal computation.
Options for GIM1_pi solver.
Result container for G(K) bound factors.
Global constants for tolerances and solver configuration.
Global constants and settings for LINE solver.
Class representing a global synchronization event with active and passive participants
Method for solving G/M/1 type matrix equation.
A Gaussian Mixture Model (GMM) distribution.
Utility functions for Gaussian Mixture Model operations.
A lightweight directed-graph view of a
Network topology, returned by
Network.getGraph().A directed edge between two nodes for a given job class.
Enumeration of scheduling policies for heterogeneous multiserver queues.
Example demonstrating heterogeneous server support in LINE.
Heuristic approximation to the permanent of a positive matrix.
A processor that can run Tasks
Optimize the mean host demand of an LQN Activity (continuous).
Simple HTTP client for sending metrics to a receiver.
Sampling method to approximate the permanent using the Huber-Law bound.
A hyper-exponential distribution.
Fitting a hyperexponential to a long-tail distribution.
Outcome of one of the output-analysis hypothesis tests.
One row of the pre-computed CME parameter table.
An Immediate distribution that always samples 0.
Stochastic complementation of the IMMEDIATE coordinates of the fluid ODE.
Result of immediate elimination containing the reduced system, the surviving coordinates and
the two maps that carry per-event and per-coordinate quantities across the reduction.
Constants for specifying customer impatience types.
Result of the INAP/INAPplus fixed-point iteration.
IndexedMinHeap
A min-heap over a fixed set of integer keys 0..n-1, each associated
with a double priority.
Result of building the augmented fluid model for response time likelihood.
Gibbs Sampling demand estimation from trace data.
Variational inference for Markovian queueing networks, following I.
Java twin of the inference example scripts (matlab/examples/inference,
python/examples/inference, cpp/examples/inference).
LQN parameter identification via an Extended Kalman Filter.
Finite-difference sensitivity matrix H = dh/da together with h0 = h(a).
Options for LQN parameter identification via the Extended Kalman Filter
(
InferLqn).Observation model: solve the LQN and return its per-element average table.
Result of an LQN parameter identification run (
InferLqn).Kolmogorov-Smirnov tests for a non-homogeneous Poisson arrival process.
A service section with an infinite number of servers (pure delay).
Examples demonstrating initial state configurations in queueing networks.
Examples of model initialization
python/examples/advanced/initState/: the initial state a transient
starts from, and the priors that select it.Input section of a station
A caching service that gives access to items
A set of cacheable items
Register the example suite already in
jline.examples.java as parity twins.JMT is an alias for SolverJMT (Java Modelling Tools solver).
Backend dispatch for the JMT command line.
Unified I/O handler for JMT (Java Modelling Tools) files.
Configuration options for Java Modelling Tools (JMT) solver integration.
Result class for transient probability analysis of aggregated states.
Superclass representing a class of jobs
Enumeration of job class types in queueing network models.
Optimize the fixed circulating population of a closed class.
A node that reassembles a set of sibling tasks into the original parent job
Input section of a join node
Parameter container for join nodes in queueing networks.
Constants for specifying a join strategy
Data class for JSON-formatted test results.
Fluid and diffusion limits of the (MAP_t/Ph_t/inf)^N network of Y.
KPC-Toolbox fitting functions.
Numerical inversion of a Laplace transform.
Examples demonstrating layered queueing networks with contention queues (CQ).
Model definitions for Layered CQ (Contention Queue) examples.
Layered network examples mirroring the example notebooks in layeredModel.
Examples of layered networks
LayeredNetwork represents a layered queueing network (LQN) model for performance analysis
of distributed and multi-tiered software systems.
Element of a LayeredNetwork model
One admission constraint row declared by operand name.
One declared pool, its operands held by name until getStruct resolves them.
A generator object that generates layered queueing network models
based on user specification.
Layer-wise table of performance sensitivities of a layered network, one row per
(Layer, Station, JobClass).
Class summarizing the characteristics of a LayeredNetwork
A caller activity, the strategy, and the entries it dispatches over.
The resolved pool block of one server: compat(t, j) nonzero = pool t may serve operand j.
Result container for layered queueing network solver analysis.
Demonstrates JUNG visualization of LayeredNetwork models using the plot() method.
Result class for LCFS MVA algorithm.
LOAD CONCEALMENT as a model transformation, and the first ITERATED strategy
of
TransformSolve.Carries the concealment state across the sweep.
LDES is an alias for SolverLDES.
CLI for the standalone ldes.jar (LDES simulation engine).
Configuration options for the LDES solver.
Provides save/load functionality for LDES solver results to/from JSON format.
Demo of the LDES warm-start feature: an auxiliary solver is passed to SolverLDES
as an argument, its steady-state distribution is computed, and that distribution
decides the initial state of the simulation.
Level-Dependent Quasi-Birth-Death process solver.
Exact level-dependent QBD blocks of an M/PH/c queue.
The three block lists of a level-dependent QBD, in the order
Ldqbd takes them.Options for LDQBD solver.
Result of LDQBD solver containing rate matrices and stationary distribution.
Matrix-exponential building blocks of a first/second-order level-dependent
fluid queue, as produced by SecondOrderLevelDependentFluidSolve and consumed
by LevelDependentFluidStationary.
LINE solver - Java implementation equivalent to MATLAB LINE.m
Parameters for linear reduction models with phases.
Bibliographic references for the algorithms LINE uses.
One bibliographic reference and the part of the solution it covers.
The LineCLI class provides a command-line interface for configuring and running the LINE Solver.
Running progress log of a LINE solver run (the "solver console").
A client for sending layered network models to a Docker-based LINE server.
Interface between the optimizer and LINE's SolverAUTO.
LineExamples: run one reference example by name, out of the JAR.The exception every deliberate LINE diagnostic throws.
Environment check for the JAR, mirroring MATLAB's
lineInstall.Provides save/load functionality for LINE queueing network models to/from JSON format.
Runnable demonstrations of the line-opt optimization framework, mirroring the
scripts in
python/examples/opt/ and matlab/examples/opt/.Main line-opt solver.
Configuration options for
LineOptSolver, mirroring the option dict of
native-Python LineOptSolver.defaultOptions().Capture the result tables a run produces, with the solver that produced them.
A getter body, so a caller can wrap one in
LineResultRecorder.around(java.lang.Object, java.lang.String, jline.io.LineResultRecorder.Body<T>) in a single line.Session-level cooperative wall-clock budget (port of MATLAB
lineTimeoutExceeded's global-deadline form).
LineWebSocketClient is a WebSocket client used to communicate with the LINE Solver server.
LineWebSocketServer is a WebSocket server that receives client connections, processes incoming messages,
and interacts with the LINE Solver.
Output section of a Place in a Stochastic Petri net model
LN is an alias for SolverLN (Layered Network solver).
Result container for LayeredNetwork LDES simulation.
Transient average metrics of a layered network, assembled block-diagonally
across the ensemble layers by
SolverLN.getTranAvg().Examples demonstrating load-dependent queueing behavior.
Examples of models with load-dependent stations
A node that logs passage of jobs
Parameter container for logger nodes in queueing networks.
A Lognormal distribution.
A section that forwards jobs without introducing delays in a Log node
Exact normalization constant, carried load and blocking of a loss network by
the transform technique of Manjunath and Sikdar.
Monte Carlo importance-sampling summation for loss networks, after
Ross and Wang, "Monte Carlo Summation Applied to Product-Form Loss
Networks", Probability in the Engineering and Informational Sciences,
6 (1992), 323-348.
Exact analysis of a loss network by MDD-rec: the normalising constant is the
sum of a product form over the admissible set {n >= 0 : A n <= C}, which
is what a decision diagram holding that set computes in one memoised walk.
Carried load, blocking, log normalising constant and walk count.
Majumdar-Woodside robust box bounds on throughput for a layered queueing
network (LQN), computed on the processor-contention model.
Result holder.
Method of Layers on the SRVN decomposition of a layered queueing network whose entries carry no
activity graph.
Tuning of the outer fixed point.
The four (nidx) vectors in the column convention
SolverLN and LQNS report, so they
line up with LN(model).getAvgTable() cell for cell.Converts a LayeredNetwork (LQN) to a Network (QN) using REPLY signals.
Converts a LayeredNetwork (LQN) model to a UML sequence diagram.
Output format for the sequence diagram.
Options for sequence diagram export.
LayeredNetwork (LQN) support for line-opt.
Abstract base for LayeredNetwork (LQN) decision variables.
Phase-type composition of an LQN activity graph, the machinery behind
SolverLN method 'srvn.ph'.
Activity graph of one entry, as a workflow plus its execution counts.
LQNS is an alias for SolverLQNS (Layered Queueing Network Solver).
Extended LSODA solver that supports configurable maximum internal steps.
Functional interface for Laplace-Stieltjes Transform evaluation.
Model-to-Model transformation class for converting between different queueing network model formats.
M3A (Markovian Arrival Process with 3-moment Approximation) tool for MMAP compression.
Coxian parameters.
Erlang parameters.
Hyper-exponential parameters.
Phase-type parameters.
Compression method enumeration.
Options for M3A compression.
Options for M3A fitting algorithms.
Utility functions for M3A (Markovian Arrival Process with 3-moment Approximation) compression.
Functional interface for constraint functions used by COBYLA.
Functional interface for objective functions used by COBYLA.
Result for a specific K value
MAM is an alias for SolverMAM (Matrix Analytic Methods solver).
Background modulating chain of a mixed network: the continuous-time Markov
chain of the closed-class population vector, with the open classes present
only through the server capacity they leave free.
Solved background chain.
Lumps the background modulating chain onto the number of closed jobs held by
one station, giving the Markovian environment that the open classes at that
station see.
Lumped environment of one station.
Groups closed chains by similarity of their per-station SERVICE DEMAND, for
the aggregation
Solver_mam_bgchain applies to the chains it is not
carrying exactly.Open classes of one station, solved as a level-dependent QBD MODULATED by the
background chain: level = number of open jobs held by the station, phase =
(arrival MAP phase, environment state, service phase).
Solved open station.
Decides if a station matches the M/M/c/K assumptions.
Outcome of the M/M/c/K detection.
True if a process (D0, D1) is a renewal process.
Arrival-weighted phase-type mixture of the per-class service laws at a
station, as the service descriptor accepted by
Qsys_mapg1k and Qsys_mmapg1k.The mixture, kept as its two blocks plus the aggregated arrival process.
Finite-buffer marginal for MMAP[K]/PH[K]/1/FCFS.
Outcome of the finite-buffer truncation.
MAMAP 22 fit multiclass algorithms (documentation marker).
Result tuple holding G, U, Y matrices.
Triple of (fitted MMAP, feasible forward moments, feasible backward moments).
Markovian Arrival MAP with Marked arrivals MMAP-based fitting.
MAMAP 2m fit mmap algorithms.
Result from Fork-Join analysis.
Intermediate quantities of the matrix-analytic analysis of a single-queue
model, in addition to the mean performance measures returned by getAvg.
A Markovian Arrival Process
Andersen-Nielsen MAP fitting algorithm.
MAP Andersen-Nielsen fitting algorithms.
MAP arrival rate computation algorithms.
Sojourn time distribution of the MAP/M/1 processor-sharing queue.
MAP mean inter-arrival time computation algorithms.
Stateful sampler for a BMAP (Batch Markovian Arrival Process) that retains
the modulating phase between draws.
Stateful single-event MAP sampler that carries the modulating phase across calls.
MAP variance computation algorithms.
Fits a second-order MAP matching the first three moments and the asymptotic index of
dispersion.
Result of MAP/BMAP/1 queue analysis.
Complete catalog of MAP (Markovian Arrival Process) models migrated from MATLAB
Location: /home/gcasale/code/matlab/maps/
This class provides static methods to create all MAP and MMPP2 models from the maps directory
including those from .mat files and .m function files.
Options for MAP/D/c queue analysis.
Result of MAP/D/c queue analysis.
Result of MAP fitting.
Top-level functions for MAP-from-trace fitting.
MAP/M/1-PS Sojourn Time Distribution
Computes the complementary distribution function of sojourn time in a
MAP/M/1 processor-sharing queue using the algorithm from:
Masuyama, H., and Takine, T.
Options for MAP/MAP/1 queue analysis.
Result of MAP/MAP/1 queue analysis.
Options for MAP/M/c queue analysis.
Result of MAP/M/c queue analysis.
Horizontal-cut mean value analysis for a MAP server (SolverMVA method 'amva.mapqn').
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).
Implementation of bnd_linearreduction_new.mod linear program.
Implementation of bnd_mvaversion.mod linear program: the MAP-AMVA
optimization program of G.
Implementation of bnd_linearreduction_pf.mod linear program
This is the Product Form version without phases
Parameters for the Product Form linear reduction model
Implementation of bnd_quadraticreduction.mod linear program.
Implementation of bnd_quadraticreduction_delay.mod linear program.
Parameters for the quadratic reduction delay model.
Implementation of bnd_quadraticreduction_ld.mod linear program (load-dependent).
Parameters for the quadratic reduction load-dependent model.
Base class for representing MAPQN Linear Programming models
Smooth minimisation over a polytope, by proximal projected gradient with an
OSQP projection oracle.
Objective gradient at x, accumulated into gradOut (pre-zeroed by the caller).
Objective value at x.
Base class for MAPQN model parameters.
Factory class for creating Mapqn_parameters from NetworkStruct.
Quadratic-reduction (QR) utilization bounds for closed MAP queueing networks
under the blocking-after-service (BAS) protocol.
Parameters for QR Bounds BAS (Blocking After Service) model.
The assembled BAS constraint system, so a second objective can be
optimized over the SAME polytope without a second transcription of the
fifteen families.
Parameters for QR Bounds RSRD (Repetitive Service Random Destination) model.
Minimum-mutual-information, maximum-entropy and tree-reweighted (Bethe)
bounds on the BAS-blocking polytope, the JAR twin of MATLAB
qrf_bas_mmi.m / qrf_bas_mem.m / qrf_bas_bethe.m and of
native Python api/mapqn/qrf_bas_nlp.py.Solution returned by Mapqn LP solvers.
Markov-modulated image of a network with MAP/MMPP/MMAP arrival or service
processes as a queueing network in a random environment.
The environment image together with the shape of the transformation.
Result class for RandomMAP.
Time-inhomogeneous Markovian arrival process (MAP_t).
Capability type exposed so that model compilation can recognise a schedule-bearing
process by capability rather than by class name.
An abstract class for marked point processes
A Marked Markovian Arrival Process
A class for continuous time Markov chain where transitions are labeled
A Marked Markov-Modulated Poisson Process (M3PP)
A class for a discrete time Markov chain
Facade class for Markov Chain functions.
An abstract class for a Markovian distribution
Result class for ExtendToMarkovian.
An abstract class for a Markov-modulated point-process
A class for a continuous time Markov chain
Utility class for saving matrices and workspaces to MATLAB .mat files
using the MFL (MATLAB File Library) for Java.
Mathematical functions and utilities.
A sparse matrix data structure supporting linear algebra functions similar to those available in
MATLAB.
An ordered collection of Matrix objects that provides indexing and manipulation operations.
A (row, column, value) triple returned by
BaseMatrix.nonZeroIterator().A wrapper class that extends EJML's Equation functionality to work seamlessly with jline.util.matrix.Matrix objects.
Maximize a weighted combination of throughput, 1/response-time and
1/queue-length, subject to an optional budget constraint.
Result of M/D/c queue analysis via Crommelin's embedded DTMC.
Quasi-reduced ordered Multi-valued Decision Diagram.
Exact solve of a single-class closed exponential queueing network whose CTMC
state space (reachable occupancy vectors) is stored in a Multi-valued
Decision Diagram instead of an explicit state list.
Kronecker rate descriptor of a single-class closed queueing network.
Miner-Ciardo-Donatelli approximate stationary analysis.
Kronecker rate descriptor for shared-server stations with phase-type service.
Reachability set generation into a decision diagram.
MDD-rec: the normalising constant of a product-form model whose reachable set
is held in a decision diagram.
Result of the MDD-stored exact closed-network solve of
Mdd_closedqn.Kronecker rate descriptor of a structured model, the input of
Mdd_mcd.One event of the Kronecker rate descriptor.
A local rate matrix W_k^e of the Kronecker descriptor, held row-compressed.
Incremental triplet builder; duplicate entries are accumulated.
Knobs of the level iteration in
Mdd_mcd.Result of the Miner-Ciardo-Donatelli level aggregation.
Next-state function of a structured model, over local-index tuples.
Phase-type service law of one station, as a Markovian (D0,D1) pair.
Storage description of the set held in an
MDD.A Matrix Exponential (ME) distribution.
ME mean computation algorithms.
Matrix Exponential (ME) sampling by numerical inversion of the exact CDF.
Stateful ME sampler that builds the inverse-CDF table once and draws
independent variates from it.
ME squared coefficient of variation (SCV) computation algorithms.
ME variance computation algorithms.
Outcome of the density scan: whether a negative value was found, and where.
Result of the ME closed queueing network algorithm (Kouvatsos 1994,
Section 3.3).
Fits a matrix exponential to a given mean and squared coefficient of variation.
Solution of a censored GE/GE/c/K;N queue by entropy maximisation.
Hardware-aware, profiling-calibrated memory guard for
SolverCTMC.Result of a gate decision.
Result of the ME OQN algorithm with finite buffers.
Options for the ME OQN algorithm.
Result of the ME OQN algorithm.
Result class for MEFromMoments containing both alpha and A.
Classification of a solution method, as printed in the solver banner:
<accuracy>, <randomness> with accuracy in
{exact, approximate, bound} and randomness in {deterministic, randomized}.Constants for specifying a Metric
Constants for specifying a type of metric
MFQ (Markovian Fluid Queue) analyzer for single-queue open systems.
Discrete-time single-server queue with batch DMAP arrivals, DBMAP/DMAP/1.
Queue length, utilization, throughput, pmf and departure process.
Result of ETAQA computation containing aggregated probabilities.
Options for MG1_CR solver.
Result of MG1 Decay computation.
Method for solving M/G/1 type matrix equation.
Options for MG1_pi solver.
Result class for MGFromMoments containing both alpha and A.
Minimize infrastructure cost subject to service-level constraints.
Minimize the end-to-end (system) response time.
Second-order moment-closure fluid analysis, backing
options.method='minnormal'.Mixed queueing network examples mirroring the example notebooks in mixedQN.
Examples of mixed queueing networks
A Marked Markovian Arrival Process (MMAP)
MMAP is a point process where arrivals are categorized into K different types (marks).
Compresses an MMAP using various approximation methods.
MMAP compress algorithms.
MMAP arrival rate computation algorithms.
MMAP of the maximum of two independent marked arrival flows, as used to
synchronize sibling branches at a fork-join Join node.
Functional callback used internally for weight-combination enumeration.
Computes the steady-state probability vector for each class in an MMAP.
One marked draw: inter-arrival time plus the 1-based mark of the arrival.
Stateful sampler for an MMAP {D0, D1_agg, D11..D1K} (M3A layout) that
retains the modulating phase between draws, so successive calls
reproduce the inter-arrival autocorrelation (mirrors
Map_sample.MapSampler / BmapSampler).
Result of a fit: the MMAP and whether the closed form matched exactly.
Result of a fit: the marked MAP and whether the marking is feasible.
Options for MMAP[K]/PH[K]/1 queue analysis.
Result of MMAP[K]/PH[K]/1 queue analysis.
Top-level functions for MMAPPH1NPPR analysis.
A Markov-Modulated Deterministic Process (MMDP) for fluid queue modeling.
A 2-state Markov-Modulated Deterministic Process.
A Markovian-modulated Poisson Process with 2 states
Facade class for MMPP2 fitting functions.
Fits a MMPP(2) according to [Heffes and Lucantoni, 1986].
Fits a second-order Marked MMPP using optimization.
Mock OTLP gRPC receiver for testing streaming functionality.
Superclass representing a class of jobs
A mode event occurring in a Network.
Class representing a model supported by the library
Static class to transform and adapt models, providing functionality for:
- Creating tagged job models for response time analysis
- Fork-join network transformations (formerly from FJ.java)
- Model preprocessing and adaptation operations
Result of aggregating chains in a model
Deaggregation information for converting chain-level results back to class-level
Result of the FJ tag augmentation (fjtag).
Result of tagging a chain in a model
Helper class to analyze model characteristics for solver selection
Metadata container held by every
Model, twin of the untyped
attribute struct of matlab/src/lang/Model.m.Registry that maps model names to builder functions for unified cross-language testing.
Unified visualizer for both Network and LayeredNetwork models using the JUNG library.
Unified edge type enumeration covering both Network and LayeredNetwork relationships.
Unified wrapper class for graph edges representing relationships.
Unified wrapper class for graph vertices representing model elements.
Unified node type enumeration covering both Network and LayeredNetwork elements.
Modification mode for SN setter methods.
Binomial moments from factorial moments.
Binomial moments from negative-binomial moments.
Binomial moments from survival (tail) probabilities.
Binomial transform of a sequence.
Inverse binomial transform of a sequence.
Central moments from power (raw) moments.
Cumulants from power (raw) moments.
Factorial cumulants from factorial moments.
Factorial moments from binomial moments.
Factorial moments from factorial cumulants.
Factorial moments from power (raw) moments.
Factorial moments from upward-factorial moments.
Conversion matrix of one edge of the house of moments.
Factorial moments of a total count from the joint factorial moments of its
parts.
Joint binomial moments from joint factorial moments.
Joint binomial moments from joint negative-binomial moments.
Joint binomial moments from joint survival probabilities.
Joint central moments from joint power (raw) moments.
Joint central moments about a given mean vector.
Joint central moments from a joint survival array.
Joint cumulants from joint power (raw) moments.
Joint factorial cumulants from joint factorial moments.
Joint factorial moments from joint binomial moments.
Joint factorial moments from joint factorial cumulants.
Joint factorial moments from joint raw moments.
Joint factorial moments from joint upward-factorial moments.
Joint factorial moments of the per-class counts under multinomial marking.
Joint negative-binomial moments from joint binomial moments.
Joint negative-binomial moments from joint upward-factorial moments.
Joint power (raw) moments from joint central moments.
Joint power (raw) moments from joint cumulants.
Joint raw moments from joint factorial moments.
Joint raw moments from joint upward-factorial moments.
Joint survival probabilities from joint binomial moments.
Joint upward-factorial moments from joint factorial moments.
Joint upward-factorial moments from joint negative-binomial moments.
Joint upward-factorial moments from joint raw moments.
Separable joint moment conversion, applied dimension by dimension.
Triangle of the Lah numbers.
Negative-binomial moments from binomial moments.
Negative-binomial moments from upward-factorial moments.
Power (raw) moments from central moments.
Power (raw) moments from cumulants.
Power (raw) moments from factorial moments.
Power (raw) moments from upward-factorial moments.
Triangle of the signed Stirling numbers of the first kind.
Triangle of the Stirling numbers of the second kind.
Triangle of the Stirling cycle numbers.
Survival (tail) probabilities from binomial moments.
Mode product of a joint moment array with a conversion matrix.
Upward-factorial moments from factorial moments.
Upward-factorial moments from negative-binomial moments.
Upward-factorial moments from power (raw) moments.
Formats MQN benchmark results in MATLAB-style output format
Benchmark result data structure
Accumulates benchmark results for batch formatting
Bit-exact reimplementation of numpy's legacy MT19937 core, matching the
generator underlying
numpy.random.RandomState.Data structure for multiclass trace representation.
Bootstrap results container.
Trace statistics container.
Data holder representing a summary of multi-trace statistics.
The three multi-chain class-switching networks, transcribed for the JAVA row.
A multivariate normal (Gaussian) distribution.
Example demonstrating MultivariateNormal distribution usage.
MVA is an alias for SolverMVA (Mean Value Analysis solver).
Configuration options for Mean Value Analysis (MVA) solver.
Result container for Mean Value Analysis (MVA) solver computations.
Parameters for MVA version models.
Rectangle probability of a multivariate normal, the cell integral behind
SolverFluid.getProbAggr under the moment-closure methods.Implementation of the naive exact permanent computation.
A container for storing named parameters with string identifiers and object values.
NC is an alias for SolverNC (Normalizing Constant solver).
A queueing network model
TABLE OF CONTENTS:
1.
The answer of
Network.findBindingCapacity(): whether a buffer binds and,
when it does, which one.Result class for isRoutingErgodic method
Class for auxiliary information stored in Network objects
Table of detailed per-class cache performance metrics, one total row per cache
node and read class (List=0) plus, where available and the cache has more than
one list, one row per cache list (level).
Table of item-level cache occupancy, one row per Cache node, item and cache
list (level).
Table of the mean orbit length of every retrial station-class pair, with the
station population and the in-service population it decomposes into.
Table for displaying network performance metrics organized by station and job class.
Table of bound brackets produced by SolverBA, in the layout of
NetworkAvgTable.Stochastic network calculus: a delay quantile with a certified violation
probability, and what envelope propagation costs across a network.
Class representing an element within a Network object
A generator object that generates queueing network models
based on user specification.
Example demonstrating the NetworkGenerator class
Table of loss (drop) metrics for every station-class pair that receives
offered traffic: offered arrival rate (ArvR), carried throughput (Tput), loss
rate (ArvR - Tput, the rate of jobs dropped by finite capacity, blocking, or
reneging) and loss ratio (LossRate / ArvR).
Table of exact higher moments of the per-chain queue length, one row per
(Station, Chain).
Raw moment results behind
NetworkMomentTable, mirroring the mom
struct that MATLAB's getMomentTable returns as its second output.Raw moment results behind
NetworkMomentStationTable, mirroring the
mom struct that MATLAB's getMomentStationTable returns as its
second output.Table of exact higher moments of the TOTAL queue length, one row per station.
Table of exact higher moments of the per-class performance measures, one row per
(Station, JobClass).
Queueing network model without think time.
Triple of (probability, computation time, memory usage).
Table of tail QUANTILES produced by the SolverBA 'snc' family, in the layout
of
NetworkAvgTable.Table of exact analytic performance sensitivities, one row per (Station, JobClass).
Abstract base class for solvers applicable to queueing network models.
Fluent configurator returned by
NetworkSolver.options().Class summarizing the characteristics of a Network object
Queueing network model with think time.
Twins for the goldened networks the JAR's example gallery did not carry.
Demonstrates JUNG visualization of Network models using the plot() method.
A non-homogeneous Poisson process (NHPP) with a piecewise-constant intensity.
A piecewise-constant rate schedule: the parameterisation shared by every
schedule-bearing process.
Non-negative least squares solver implementing the Lawson-Hanson algorithm.
Superclass for a node element within a Network model
Auxiliary class for information stored within a Node object
Base class for node parameters in queueing network models.
Enumeration of node types available in queueing network models.
A normal (Gaussian) distribution.
Piecewise-linear Lyapunov UPPER bound on the steady-state queue lengths of a
multitype (deterministic-routing) multiclass Markovian queueing network,
valid for EVERY work-conserving Markovian policy.
Outcome of one solve.
First-order linear-programming relaxation of the achievable region of a
multiclass open Markovian queueing network.
Outcome of one solve.
Two-term heavy-usage asymptotic approximation for a closed queueing network with one
infinite-server (think) station and one discriminatory processor-sharing (DPS) station, after
J.A.
Mean queue lengths, sojourn times and throughputs, with the intermediate constants.
Near-immediate feedback elimination for the robust queueing network analyzer.
Time-varying open network of many-server fluid queues with abandonment.
Result of the network solve.
Selects how downstream blocking is aggregated for a station.
Selects how the load-dependent rate scale V1 is updated across populations.
Service-IDC handle whose per-queue evaluation time differs by queue.
Options for NSF_GHT solver.
Options for NSF_pi solver.
Bit-exact port of the subset of
numpy.random.RandomState consumed by
scipy's differential_evolution.Abstract base for line-opt objectives.
Specification of an observed LQN performance metric.
Kind of performance metric observed.
Functional interface for the ODE right-hand side: dy/dt = f(t, y).
A class of jobs that arrives from the external world to the Network and, after completion, leaves it
Open queueing network examples mirroring the example notebooks in openQN.
Open queueing network with a MAP_t arrival process and the Ko-Pender limits.
Examples of open queueing networks
Open queueing network with an NHPP (cyclic) arrival process.
An open signal class representing special customers in G-networks and related models.
Declarative specification of a queueing-network optimization problem: a LINE
model, decision variables, an objective, constraints, optional fixed
variables (for decomposition) and optional workload scenarios (for robust
optimization).
Result from a single optimization run.
Optimization utilities for inference algorithms.
Formats OQN benchmark results in MATLAB-style output format
Benchmark result data structure
Accumulates benchmark results for batch formatting
OTLP gRPC client for sending metrics to line-est receiver.
Output section of a node
Class modelling the output section of a Node
A generic pair container that holds two objects of potentially different types.
Service demand estimator for queueing network models.
Specification of a hidden LQN parameter to identify.
Kind of parameter being estimated.
A Pareto distribution
One point of a cost-performance tradeoff curve produced by
ParetoSweep.Epsilon-constraint sweep for bi-objective tradeoff analysis.
Maps an epsilon value to a constraint.
One runnable twin: the reference directory it came from, its name, its body.
A body that may fail the way a solver fails, i.e.
ParseOptPara - Utility class to parse optional parameters in QBD and related solvers.
Placement-order logic of a pass-and-swap (P&S) / order-independent network
with swap graph H.
Derive the GLOBAL placement-order DAG H of a closed two-station pass-and-swap
(P&S) tandem 1->2->1 directly from its swap graph, for use with
Pfqn_pas_is.A passage-time law on a time grid.
Per-source and initial-law-weighted passage-time moments.
Closed tandem of two pass-and-swap (PAS) queues, reproducing Figures 5 and 6
of Comte and Dorsman, "Pass-and-Swap Queues" (2021, arXiv:2009.12299).
Validate the CTMC (exact) and LDES (simulation) solvers on a CLOSED CYCLIC
network of two pass-and-swap (PAS / order-independent) queues against the
exact product-form brute-force normalizing constant.
Pass-and-swap (PAS) / order-independent queue examples.
The patience (time-to-abandon) law of a queue with customer abandonment,
in the three forms accepted by
Qsys_mgisrgi_whitt.How the abandonment rates are read off this law.
Result class for PdfFromTrace containing x and y arrays.
Implementation of the MATLAB perm.m permanent computation algorithm.
Example usage of the permanent computation algorithms.
Abstract base class for permanent computation solvers.
Preconditions and helpers shared by the approximate permanent engines.
Whether the fluid Petri route can answer this model, and why not.
The verdict and, when negative, the element that decides it.
The min-normal moment closures a Petri-net transition mode needs.
The result of the many-argument closure.
The conserved quantities, as equations:
u'D = 0 implies u'x is constant.Every finite place capacity as a linear row
A x <= b.The active set of the IMMEDIATE transitions, and the equations that pin their flows.
One pinning equation.
One transition mode as a reaction record: its input arcs and their weights,
its inhibitor arcs and their thresholds, its incidence column, and the firing
process that times it.
Fluid analysis of a stochastic Petri net.
What the Petri route computes that the station table has no column for.
Everything
PetriSolver.solve() returns.The closed enabling term of every transition mode, the rate of every event
column, and the drift Jacobian.
The enabling terms and their derivatives, for one iterate.
Event-based representation of the fluid marking process of a stochastic Petri
net.
Akyildiz-Bolch (A/B) linearizer method for closed product-form queueing networks.
Akyildiz-Bolch AMVA method for multi-server BCMP networks.
PFQN ab algorithms.
Adaptive Gauss-Hermite quadrature of the simplex factor of the McKenna-Mitra integral.
Mean busy period of order n for a subnetwork, after H.
Busy period of a subnetwork evaluated from point values of the normalizing
constant rather than from the whole population ladder.
Multichain generalization of
Pfqn_busyp.The load-dependent rate of one node, as a FUNCTION of the jobs it holds.
Perfect/approximate stationary state sampler for closed single-class
multiserver product-form networks.
Result holder mirroring the MATLAB [Q,X,T] return of pfqn_cftp.
Chow Second Approximation (SA) approximate MVA.
de Souza e Silva-Lavenberg-Muntz Clustering Approximation (CA).
Computes g(K) of a multichain closed product-form network with single-server
and (optionally) infinite-server queues by numerically inverting its
p-dimensional generating function (Choudhury, Leung and Whitt, 1995, eq.
Computes g(K) of a multichain closed product-form network with limited
load-dependent (LLD) stations and (optionally) infinite-server delay by
numerically inverting its p-dimensional generating function
(Bertozzi-McKenna eqs.
Accelerations and their parameters; the defaults are the paper's.
Computes G(N) of a closed product-form network made of an aggregated
infinite-server (delay) node and any number of LIMITED JOINT-DEPENDENT
stations.
Computes G(N) of a closed product-form network made of an aggregated
infinite-server (delay) node and any number of order-independent (OI) /
pass-and-swap stations with empty swap graph, by inverting
G(z) = exp(sum_r Z_r z_r) prod_i F_i(z), F_i(z) = sum_n Phi_i(n) z^n,
with Phi_i the v-weighted balanced-fairness balance function of station i,
mu_i(n) Phi_i(n) = sum_{r: n_r>0} v_{i,r} Phi_i(n - e_r).
Termination cutoff 1/(4000 + 16*sum(N)) of the Linearizer.
Triple of (A, B, DA) coefficient matrices.
Conway-Maxwell approximate MVA for multi-server queueing networks.
Exact passage-time density, distribution and moments along an OVERTAKE-FREE
PATH of a closed single-chain tree-like product-form network.
DAC (Distribution Analysis by Chain) method for closed product-form queueing
networks with single-server fixed-rate, infinite-server and queue-dependent
service centers.
de Souza e Silva-Muntz Improved Linearizer (IL).
Result of the DNC evaluation at a real population.
Result of the closed form, mirroring [lG, G, method, lossDigits].
Result of the closed form, mirroring [lG, G, method, lossDigits].
Signed log-sum-exp of S = sum_i s_i exp(l_i): log|S|, sign(S), digits lost.
The gld recursion over EXACT SYMBOLIC demands and rates.
The single-class gld recursion over EXACT SYMBOLIC demands and rates.
HST sensitivity coefficients and the constrained worst case.
Importance-sampling (IS) estimate of the normalizing constant of a closed
LOAD-INDEPENDENT product-form queueing network with M single-server queues of
per-class demand L and an aggregated delay of think time Z.
Joint probability of the per-station TOTAL queue lengths.
Result of a joint total-queue-length evaluation.
Mean Value Analysis for LCFS Queueing Networks.
Result for LCFS NC algorithm.
Bard Large Customer Population (LCP) approximate MVA.
Importance-sampling (IS) estimate of the normalizing constant of a closed
LOAD-DEPENDENT product-form queueing network.
Multi-server Krzesinski linearizer approximate MVA.
Linearizer++ algorithm for closed networks without think times.
Same recursion, same arithmetic and the same result as
Pfqn_gld, but
with the rate shift saturated at the limited load-dependence threshold, which
makes the recursion's state space finite and lets it be memoised.Same recursion, same arithmetic and bit-identical results to
Pfqn_gldsingle, but with the rate-offset axis truncated at the
limited load-dependence threshold instead of at the population.Eager Looping approximate MVA bounds.
Result of the Looping iteration.
Exact normalizing constant of a closed multiclass product-form network whose
state space carries arbitrary linear integer constraints.
Marie's iterative aggregation-decomposition (Marie 1979/1980) for closed
queueing networks with FCFS non-exponential (Coxian) service.
Markov chain Monte Carlo estimator of the class throughputs
X(r) = G(N-e_r)/G(N) and of the mean queue lengths Q(i,r) of a
CLOSED multiclass product-form (BCMP, no type changes) network, by the
REGULARIZATION algorithm ofCompute the normalizing constant of a repairmen model using Gauss-Laguerre integration.
Interval-valued mean performance measures.
The two names denote the SAME routine because the recursion evaluates the rate
handle at a full occupancy vector, mu_i(s_i + e_r) with s_i the shift (the
occupancy already committed at the bottom of station i), and never inspects the
structure of mu_i.
Mean-value analysis of a closed product-form queueing network composed of an
aggregated infinite-server (delay) node, any number of load-independent (LI)
single-server product-form queues, and any number of order-independent (OI) /
pass-and-swap stations with empty swap graph.
Exact marginal load-dependent MVA for a closed product-form network of
infinite-server (delay) and load-independent (single-server, product-form)
stations plus ANY number of order-independent (OI) stations.
Result: per-class throughput XN (R) and per-station queue-lengths QN (M x R).
Result: per-class throughput X, OI queue-lengths Qoi (K x R), LI queue-lengths
Qli (J x R), delay queue-length Qdelay (R).
Conditional waiting time profile of one SJN station at the target population.
Mean performance measures of the network.
Majumdar-Woodside robust box bounds on throughput for closed multiclass
queueing networks with mixed scheduling disciplines.
The two names denote the SAME routine because the balanced-fairness recursion
Phi_i(0) = 1, mu_i(n) Phi_i(n) = sum_{r: n_r>0} v_{i,r} Phi_i(n - e_r) never
inspects the structure of mu_i: it evaluates the handle at the full count
vector n.
Mean performance measures at a real-valued population.
Normalizing constant via the saddle-tilted Edgeworth (NRE) approximation.
MATLAB's
[lG,G,lGs,vsad]: the constant, the saddlepoint term on
its own and the tilt the expansion was taken about.Conditional mean number of in-service jobs per class at an OI station.
Hsieh-Lam Proportional Approximation Methods (PAMB/PAMI/PAMT).
Mitra-McKenna (JACM 33(3):568-592, 1986) load-dependent PANACEA: the
expansion coefficients A_n are linear combinations of partition functions of
a pseudonetwork whose load dependence is the phi(n) transform of the original
{f(n)}.
Importance-sampling (IS) estimate of the normalizing constant of a SINGLE
communicating class of a closed two-station pass-and-swap (P&S) /
order-independent (OI) tandem with swap graph H (Casale, Comte and Dorsman,
2026).
Result of
Pfqn_pas_is.pfqn_pas_is(int[], java.util.List<java.util.function.ToDoubleFunction<int[]>>, int[][], long, long, boolean): G, log G, and (2 x R) mean queue lengths.Permanent of a demand matrix, with optional column multiplicities.
QD-AMVA on a closed multiclass product-form network.
The fixed point
Pfqn_qdamva.pfqn_qdamva(jline.util.matrix.Matrix, jline.util.matrix.Matrix, jline.util.matrix.Matrix, jline.util.matrix.Matrix) reaches, and how many sweeps it took.QD-LIN: the Linearizer arm of AMVA-LD, on a plain demand matrix.
The fixed point
Pfqn_qdlin.pfqn_qdlin(jline.util.matrix.Matrix, jline.util.matrix.Matrix, jline.util.matrix.Matrix, jline.util.matrix.Matrix, jline.util.matrix.Matrix) reaches, and how many sweeps it took.Joint moments of the queue-length vector of a closed product-form network,
obtained from normalizing constants.
Schweitzer, Serazzi and Broglia, "A Queue-Shift Approximation Technique for
Product-Form Queueing Networks", Tools'98, LNCS 1469, pp.
Sojourn-time moments at the processor-sharing station of the closed
terminal-driven system of Mitra and Morrison (1983): a bank of terminals in
series with a single processor-sharing CPU, with class-dependent exponential
think times (mean
Z[r]) and class-dependent exponential service times
(mean S[r]), and N[r] jobs of class r cycling between the two.Result of the RGF recursion: the whole log-normalizing-constant sequence.
Harrison and Coury, "On the asymptotic behaviour of closed multiclass queueing
networks", Perf.
Normalizing constant and its logarithm.
Schmidt method for load-dependent MVA with multi-server stations.
Schmidt MVA algorithm for multi-class FCFS queueing networks.
Product-form state-dependent routing of Krzesinski (1987), "Multiclass
Queueing Networks with State-Dependent Routing", Performance Evaluation
7(2):125-143, the multiclass generalization of Towsley (1980), J.
Derived coefficients of an SDR structure, eqs.
Mean performance measures returned by
Pfqn_sdr.pfqn_sdr(jline.util.matrix.Matrix, jline.util.matrix.Matrix, jline.util.matrix.Matrix, jline.lang.StateDepRouting, jline.util.matrix.Matrix).Result of pfqn_sqni containing Q, U and X matrices.
Mean performance measures plus the arrival-instant queue lengths.
Lower Asymptotic Bound Approximation (ABA) for throughput in single-class networks.
Density, distribution and moments of a passage time along an overtake-free path.
PFQN mom algorithms (documentation marker).
PFQN nc algorithms (documentation marker).
PFQN procomom algorithms (documentation marker).
Sojourn-time moments at the processor-sharing station of the closed
terminal-driven system of Mitra and Morrison (1983).
Result class for pfqn_unique containing all output matrices and mapping information.
A general phase-type (PH) distribution
Result class for PH2From3Moments.
Result class for PH3From5Moments.
Result of PH/M/1 queue analysis.
Result of PH/M/c queue analysis.
Options for PH/PH/1 queue analysis.
Result of PH/PH/1 queue analysis.
Result class for PH representations containing alpha (initial vector) and A (generator matrix).
Time-inhomogeneous phase-type distribution (Ph_t).
Capability type exposed so that model compilation can recognise a schedule-bearing
process by capability rather than by class name.
Result of computePi.
A place within a stochastic Petri net / queueing Petri net model.
PNML (ISO/IEC 15909-2) place/transition nets, read and written.
A Poisson discrete distribution
State-space helpers for polling stations.
Exact mean waiting-time analysis for a symmetric decrementing (semiexhaustive)
polling system with Poisson arrivals and general service and switchover times.
Derived description of the polling controller at a station.
Result of a landing: the successor rows and the probability of each.
A service section that processes jobs using Polling scheduling
Enumeration of polling service types for polling scheduling strategy.
Data structure modeling a lattice used to describe a combination of job populations.
A pre-computed class dependence function beta_i(n) that stores function values
for all possible state combinations.
A pre-computed scalar rate function that stores function values for all
possible state combinations.
A pre-computed lookup table over per-class state vectors.
A preemptive service section that can interrupt lower priority jobs
to serve higher priority jobs.
The printing contract a parity twin keeps, the Java counterpart of
cpp/examples/examples_common.h.Priority queueing examples mirroring the example notebooks in prioModel.
Examples of queueing models with priorities
Prior distribution representing parameter uncertainty over alternative distributions.
A prior reduced to weighted alternatives, i.e.
Analysis result indicating priority configuration support level.
Result class for probability calculations in solvers.
An abstract class for stochastic processes
Alias for the Host class, i.e., a processor that can run Tasks
Optimize the multiplicity (core count) of an LQN Processor (integer).
Constants for specifying a point process type
Q_CT_MAP_M_C - Continuous-Time MAP/M/c Queue Analyzer.
Q_CT_MMAPK_PHK_1 - Continuous-Time MMAP[K]/PH[K]/1 Queue Analyzer.
Options for RAP/RAP/1 queue analysis
Result of RAP/RAP/1 queue analysis
Result containing QBD matrices for BMAP/BMAP/1 queue.
Invariant Subspace for Quasi-Birth-Death Markov Chains [Akar, Sohraby]
QBD R-matrix computation algorithms.
Result from simplified QBD CR solver (kept for backward compatibility).
Result class for qbd_rg containing R, G, B, L, F, U.
Mean queue length and throughput of the closed setup/delay-off queue.
Result of qbd_mapmap1 analysis.
The matrix-geometric tail of one open RCAT component with more than one phase
per level: pi_(n+1) = pi_n R, closed by the boundary equations of levels 0
and 1.
Writes a LINE Network model to JMT JSIMG format.
Converts a Queueing Network model to a Layered Queueing Network model.
Legacy entry point; the algorithm lives in
Da_traffic_superpos.QNS is an alias for SolverQNS (Queueing Network Solver).
QNSResult class stores the results from the QNS solver.
Quadratic Programming result containing solution and status.
Blocking parameters for the QRF (Quadratic Reduction Framework) bounds
qrf.bas and qrf.rsrd.Analyzes a BMAP/M/1 queue by the matrix-analytic (M/G/1-type) method.
Exact analysis of the Erlang A model M/M/s/r+M.
Truncated Gaussian approximation (TGA-G) for the G/GI/n+GI queue.
Steady state of the G/GI/s+GI fluid model.
Diffusion approximation for the G/GI/n/m queue.
Extremal two-moment bounds for the GI/GI/1 queue.
G/M/1 Queueing System Analysis.
The Gt/Mt/st+GI many-server fluid queue.
Conditional waiting-time moments of the Hl/Hn/1 Lindley recursion.
The MAP/G/1/K queue with tail drop: Markovian arrivals, an arbitrary service
law F, and a buffer of K packets counting the one in transmission.
Per-flow throughput and loss ratio of a FIFO buffer with tail drop fed by N
flows of arbitrary and mutually different statistical character.
The MAP/PH/c FCFS queue, solved exactly.
Two-moment approximation for the maximum of n iid non-negative variables.
Sojourn time distribution of the M/G/1 processor-sharing queue.
Service Laplace-Stieltjes transform, which must accept complex arguments.
Service density.
Analyzes an M/G/1 queue with SRPT (Shortest Remaining Processing Time)
scheduling using the Schrage-Miller class-conditional response-time formula.
Engineering solution of the call-center model M/GI/s/r+GI.
M/M/1 queueing system analysis.
Conditional waiting-time moments of the M/M/1 Lindley recursion.
Exact sojourn-time moments of the multiclass M/M/1-PS queue.
Conditional downstream waiting time in an M/M/1 tandem.
Exact per-class throughput and loss ratio of an MMAP[K]/G/1/K queue with tail
drop: marked Markovian arrivals, an arbitrary service law F common to all
classes, and a buffer of K packets counting the one in transmission.
The MMAP[K]/G[K]/1 FCFS queue: K customer types with class-dependent GENERAL
service, fed by a marked Markovian arrival process.
Fixed-point approximation for the M/M/c/c retrial queue.
Blocking probability, orbit-induced rate and iteration count.
Result container for the M/M/c/K metrics.
Halfin-Whitt QED approximation for the M/M/s queue, and the square-root
staffing rule that inverts it.
Exact time-varying analysis of the Mt/G/infinity queue.
Modified-offered-load and pointwise-stationary approximations for a
time-varying multiserver system.
Tandem network Lindley recursion on a sample path.
Tail bounds for a GI/Hn/1 -> ./Hn/1 tandem of two FCFS single servers.
Steady-state measures of a multiserver queue with customer abandonment, as
produced by
Qsys_mgisrgi_whitt and Qsys_erlanga.Result of the matrix-analytic (M/G/1-type) analysis of a BMAP/M/1 queue.
Steady state of the G/GI/s+GI fluid model, as produced by
Qsys_ggisgi_fluid.The single-station fluid limits: a Source -> Queue -> Sink model with one
class, answered by a closed-form fluid or Gaussian limit rather than by
integrating the network drift.
One conditional Lindley moment for exponential primitives.
Conditional waiting-time moments of one Lindley step.
Result of MAP/D/c queue analysis.
Return value of
Qsys_mapg1k_perflow, mirroring the MATLAB result
struct of qsys_mapg1k_perflow.m.Return value of
Qsys_mapg1k, mirroring the MATLAB result struct of
qsys_mapg1k.m field for field.Return value of qsys_mapphc, mirroring the MATLAB struct.
Result of MAP/PH type queue analysis.
Result of
Qsys_mg1_ps.qsys_mg1_ps(double, double[], double[][], double[], double[], double[], int): the sojourn time distribution of the
M/G/1 processor-sharing queue.Sojourn-time moments of the multiclass M/M/1-PS queue.
Return value of
Qsys_mmapg1k: the per-class throughputs and loss
ratios of an MMAP[K]/G/1/K buffer, mirroring the MATLAB result struct of
qsys_mmapg1k.m.Return value of qsys_mmapgk1, mirroring the MATLAB struct.
Time-varying measures of the Mt/G/infinity queue, as produced by
Qsys_mtginf.Result of BMAP/PH/N/N retrial queue analysis.
Service-time descriptor of the MAP/G/1/K family, the JAR form of the MATLAB
svc struct of qsys_mapg1k.m and of the C++
line::qsys::ServiceLaw.Which family the service law belongs to.
Conditional downstream waiting time in a two-station tandem.
Waiting times and epochs of a tandem sample path.
Tail bounds of a two-station tandem and the coefficients that produced them.
Trajectory of the Gt/Mt/st+GI many-server fluid queue, as produced by
Qsys_gtmtst_fluid.Holder for the stationary distribution of the quantity of work in a single
service stage, together with the grid it is reported on and the stationary
distribution of the number of requests in the system.
Helper class for returning four values.
Point estimate and confidence interval for a steady-state quantile.
Procedure constants of
Sim_fquest and Sim_firquest.A queueing station that processes jobs according to various scheduling strategies.
Result of
Queue.checkPermInvariance(double[], double).Top-level utilities for the queueing-network permanent computations.
Parameter container for queue nodes in queueing networks.
Quick test of benchmark package functionality
Examples demonstrating queueing networks in random environments.
Examples of models evolving in a random environment
Centralized random number generator management for reproducible, thread-safe random number generation.
Input buffer of a Source
A Rational Arrival Process (RAP) distribution.
Rational Arrival Process (RAP) sampling by conditional inversion.
Stateful RAP sampler that carries the conditional phase vector across
draws, so successive inter-event times are correlated as in the process.
One RCAT component: the (station, class) pair and the Markovian processes its
QBD is assembled from.
RCAT (Reversed Compound Agent Theorem) model representation.
Collection of stations with constraints on the number of admitted jobs
The last goldened examples the JAR carried no twin for.
Enumeration of removal policies for negative signals in G-networks.
REPL (Read-Eval-Print Loop) for LINE solver
Provides an interactive environment to define models and execute solvers
Constants for specifying a cache replacement strategy
A distribution that replays empirical data values from trace files.
Parameter container for replayer nodes in queueing networks.
Layout of, and accessors for, the synchronous-call (REPLY signal) blocked-server
block that a node carries in its local-variable state.
Layout of the reply block at one node.
Per-station response time constraint: RT <= maxValue.
Result class for CTMC Marginal Aggregated solver.
Container class for return types used throughout the LINE queueing network solver library.
Entry for the action map in snToAG.
Result class for afterEventHashedOrAdd method
Represents the return type for the cache gamma linear program computations.
Represents the return type for cache importance sampling method.
Deprecated.
Use cacheMissSpm instead
Represents the return type for cache miss rate computations with the SPM method.
Represents the return type for the cache MVA (Mean Value Analysis) computations.
Deprecated.
Use cacheSpm instead
Represents the return type for cache ray method.
Result type for the cache characteristic time (xi) fixed-point algorithm.
Unified result type for distribution computations in queueing network solvers.
Result type for event-based state space exploration functions.
Result class for getHashOrAdd method
Unified result type for linearizer approximation methods.
Constructs a lossnErlangFPReturn object with the specified queue-length, loss probability,
blocking probability, and iteration count.
Return type for the exact Manjunath-Sikdar transform of a loss network
(Lossn_manjunath), holding the carried load, the class blocking probabilities,
the log of the EXACT normalization constant, and the realised cost.
Return type for Monte Carlo importance-sampling summation of loss
networks (Lossn_mci), holding carried load, class blocking, the log
normalization constant, and delta-method confidence intervals.
Class representing the return type for the fitting of a 2-phase APH (Acyclic Phase-Type) distribution.
A class to represent the return type of the map2_fit_idc function, holding the
fitted MAP and the fallback taken when the four descriptors are not all matched.
A class to represent the return type of the map2_fit function, holding the transition matrices and possibly other fitting results.
Class representing the return type for fitting a mixture model to a MMAP.
Constructor initializing the sample data, number of types, and type indices.
Data structure to return the results of non-product-form queueing network approximation.
Result type for the Akyildiz-Bolch (A/B) linearizer method for load-dependent multi-server BCMP networks.
Data structure for storing results from the AMVA (Approximate Mean Value Analysis) method.
Data structure for storing results from the AMVA MS (Approximate Mean Value Analysis
Multiservice) method.
Result type for the Schmidt AMVA algorithm.
Data structure for storing results the COMOM method.
Data structure for storing results from the load-dependent COMOM method.
Data structure for storing results from the CoMoM multiserver method.
Function class for the integrand used in cubature calculations.
Data structure to hold the results of the DAC (Distribution Analysis by Chain)
method.
Data structure for storing linearizer estimtate results from a queueing network analysis.
Data structure for storing results from a FNC (Fitting Normalizing Constants) calculation.
Index key for caching intermediate results in the pfqn_gld (Generalized Local Balance) algorithm.
Result type for Harel et al.
Data structure to hold extended results from the MVA computation, particularly
focusing on error corrections.
Data structure for storing results from a fixed-point iteration method.
Data structure for storing results from a fixed-point iteration method with normalization.
Data structure for storing intermediate estimates from the linearizer method.
Data structure for storing estimated intermediate results from the MS linearizer method.
Result of the Manjunath-Sikdar transform for product-form queueing networks
(Pfqn_manjunath): the exact normalizing constant over a state space cut by
linear integer constraints, its logarithm, and the realised cost.
Return of
Pfqn_mcmc: the Chen-O'Cinneide
regularization estimates and their batch-means confidence intervals.Result type for the MVA (Mean Value Analysis) algorithm.
Result type for the MVAC (mean value analysis by chain) algorithm
(see
Pfqn_mvac).Result type for the MVAC extension to queue-length dependent centers
(see
Pfqn_mvacld).Extended result type for MVA with load-dependent stations and additional metrics.
Data structure for the normalizing constant of a mixed limited load-dependent network.
Data structure for storing sanitized input parameters for a normalizing constant calculation.
The SYMBOLIC normalizing constant: G as an exact rational function.
Return type for pfqn_oi_fnc: the OI functional-server (FNC) rate handle
muf(n), the FNC balance function Psi and rate mu tabulated as flat
column-major vectors over the population lattice, with the lattice shape.
Return type for pfqn_ncoi and pfqn_pas_nc: normalizing constant of a
closed order-independent (OI) / pass-and-swap + single-delay network,
with its natural log.
Data structure for storing results from the ProCoMoM method.
Data structure for storing results from the procomom2 method.
Joint queue-length moment arrays of a closed product-form network, as
returned by Pfqn_qlen_joint_moments.
Data structure for storing results from the RD method.
Result type for the Schmidt method for load-dependent MVA with multi-server stations.
Result type for exact analytic performance sensitivities of a closed
product-form network (see
Pfqn_sens).Result type for the effective-capacity terms of the mixed load-dependent
MVA together with their exact derivatives with respect to the open-class
load, computed by
Pfqn_sens_ldmx_ec.Result type for the approximate higher moments of the per-station total
queue lengths of a closed product-form network, computed by the
LINEARIZER-2 / LINEARIZER-3 algorithms of
Pfqn_sens_linearizer.Result type for the exact higher moments (up to order three) of the queue
lengths of each CLASS GROUP at each station of a closed product-form network,
computed by
Pfqn_sens_mom.Result type for the exact queue-length second moments of a closed
load-independent product-form network, computed by the MVA-like moment
recursion of
Pfqn_sens_mva.Result type for the exact queue-length second moments of a mixed
open/closed product-form network with limited load dependence, computed by
Pfqn_sens_mvaldmx.Result type for the exact moments of the sojourn time of a job at FCFS
multiserver centers of a closed product-form network, computed by
Pfqn_sens_respt.Unified result type for probability computations in queueing network solvers.
A class to store the results of queueing system analysis.
Return type for multi-class queueing system analysis with priorities.
Result class for reachableSpaceGenerator method
Unified result type for sampling and simulation in queueing network solvers.
A return type for the snDeaggregateChainResults method, encapsulating multiple chain-related matrix results.
A unified return type for demand-related methods, supporting both simple demands (D, Z)
and comprehensive chain demands with optional chain-specific parameters.
A unified return type for methods returning product form parameters.
Result type for the snToAG conversion.
Result class for SVD (Singular Value Decomposition)
Information about a valid retrial queue topology.
Retrial policies for an orbiting population.
Result: Z (latency), d (per-item delayed-hit count), phi, pi0 (each length n).
Result: pmiss (1 x n), phit (h x n), pdh ((r+1) x n).
Result: pmiss (1 x n), phit (h x n), pdh ((r+1) x n).
Exact MVA-style recursion for delayed-hit (list-based) cache metrics.
Mirrors the [pmiss, phit, pdh] return list of the MATLAB function.
Access-factor profile gamma_j(v) for v in [0,1]; returns a v.length x h matrix.
Expansion result.
Compute waiting time distribution for Fork-Join queue.
Result of returnWait
Factory for common reward function templates.
A
RewardFunction that also records what the reward measures.Structural kind of a reward.
Functional interface for defining reward functions on CTMC states.
Result class for CTMC reward computation via value iteration.
python/examples/advanced/rewardModel/: setReward and the
SolverCTMC reward surface, getAvgReward and getTranReward.Runge-Kutta-Fehlberg 4(5) adaptive ODE integrator.
Result returned by RKF45.integrate.
Integrated cache-queueing network analyzer using fluid approximation.
RODAS -- Rosenbrock method of order (3)4 for stiff and differential-algebraic
systems
M y' = f(x,y), including a SINGULAR mass matrix (index-1 DAE).CONTRO: the third-order interpolant RODAS carries over the step just
accepted.
df/dx, for a non-autonomous system.
The right hand side f(x,y).
df/dy.
The mass matrix.
The Fortran switches, with rodas.f's own defaults.
Where the integration ended, and what it cost.
Raised for an input rodas.f itself rejects before integrating.
Called after each accepted step when
iout != 0; negative stops.A node that routes jobs without imposing any delay
The repair side of routing reducibility: what to do once
Network.isRoutingErgodic() has said the routing is reducible.Network.RoutingErgodicityResult with the repairs attached, the
MATLAB getReducibilityInfo struct.Class representing a probabilistic routing matrix
Return value of
RoutingMatrix.rtnodes2rtorig(NetworkStruct), twin
of the MATLAB [rtorigcell, rtorig] pair.Optimize the routing probabilities of a job class from a source node to a
list of target nodes.
Enumeration of routing strategies that determine how jobs are dispatched to downstream stations.
A lightweight view into a row of a sparse matrix that doesn't copy data.
Implementation of Ryzer's algorithm to calculate the permanent.
Saddle-point (SPM) approximation of the permanent of a positive matrix.
SymEngine backed by the line-sage-rest service.Format of the sampled data.
Observed data for a metric.
Container for node state sampling results from SSA solver
Container for system-wide state sampling results from SSA solver
Result of build_SA.
Handles the generation and serialization of JMT (Java Modelling Tools) simulation models.
Server pools and job parallelism of a node, as the JMT Server section needs them.
Enumeration of scheduling strategies available at queueing stations.
Constants for specifying a scheduling strategy type at stations
Multi-center branches under Krzesinski (1987) state-dependent routing.
A general class modeling a node section
Class of jobs that perpetually loop at a given station
Analytic performance sensitivities for a product-form model, mirroring the
nested dict returned by native-Python
compute_model_sensitivities:
metric kind ('RespT'|'QLen'|'Tput'|'Util') -> metric key -> parameter
key -> d(metric)/d(parameter).Analytic performance sensitivities for a product-form model, mirroring
native-Python
compute_model_sensitivities.Exports a LayeredNetwork model as a UML sequence diagram using TikZ/pgf-umlsd.
Computes layout positions for UML sequence diagram elements.
Configuration options for UML sequence diagram visualization of LayeredNetwork models.
Traverses a LayeredNetwork model to extract interactions and fragments
for UML sequence diagram generation.
Represents a combined fragment (loop, par, alt) in the sequence diagram.
Represents a single interaction (message or activation) in the sequence diagram.
Interface used for routing functions
A service section that processes jobs
Optimize the number of servers at a station.
Represents a type of server within a heterogeneous multiserver queue.
A class for associating job classes, service strategies and distributions
A station with a service process
Parameter container for service nodes in queueing networks.
Optimize the exponential processing rate of a station for a job class.
A section offering a service
A station with a service process
Constants for specifying service strategies at stations
A section that forwards jobs without introducing delays in a service station
SetupTask is a Task whose servers are switched off while idle.
A server shared by multiple jobs simultaneously
A signal placeholder class that automatically resolves to OpenSignal or ClosedSignal.
Passive arrival of a G-network signal class at a station.
Enumeration of signal types for signal classes in queueing networks.
Fixed-sample-size quantile interval from independent replications, FIRQUEST.
Fixed-sample-size confidence interval for a steady-state quantile, FQUEST.
Shapiro-Wilk test for univariate normality, Royston's AS R94 algorithm.
Standardized time series areas of the batched quantile process.
Von Neumann ratio test for randomness of a sequence.
Normal and Student t quantiles used by the output-analysis routines.
Simplified LQN benchmark implementation
Custom solver factory for LQN benchmarks
Run-length planning for steady-state simulation.
An abstraction of the external world jobs in open classes depart to
Options shared by Pfqn_mvasjn and Pfqn_amvasjn.
Laplace-Stieltjes transform of the first passage time into a target state set
for a SEMI-MARKOV chain.
Moments of order 1..nmax of the first passage time into a target state set for
a SEMI-MARKOV chain with embedded transition matrix P.
Cumulative distribution and density of the SEMI-MARKOV first passage time, by
inverting
Smp_passage_lst through jline.api.lti.The arrival rate of a station-class pair AS A FUNCTION OF TIME.
lambda(t), with whether it actually varies and the cycle length.
Builds a fork-join synchronization map from LINE's sn structure.
Result of the fork-join synchronization scan.
Violation probability of a backlog level.
Violation probability of a delay target.
Min-plus convolution of two service envelopes (tandem concatenation).
MGF arrival envelope of a compound Poisson flow with Exp job sizes.
MGF arrival envelope of a MAP/MMPP flow with unit-size jobs.
MGF arrival envelope of a Poisson flow with unit-size jobs.
Deterministic token-bucket arrival envelope.
Leftover service envelope under blind (arbitrary) multiplexing.
Upper bound on the mean backlog, from integrating the backlog tail bound.
Upper bound on the mean delay, from integrating the delay tail bound.
Output (departure) arrival envelope of a flow leaving a server.
Backlog quantile at a prescribed violation probability.
Delay quantile at a prescribed violation probability.
MGF service envelope of an exponential server, in JOB units.
MGF service envelope of a constant-rate work-conserving server.
Minimizes a Chernoff bound over the free parameter theta.
An MGF envelope evaluated at a Chernoff parameter.
Total service rate of a station served by heterogeneous server pools with a
class-compatibility graph, and the peak that normalizes its utilization.
The value of a Chernoff bound together with the theta that attains it.
Whittle balance check for a globally state-dependent rate scaling.
Physical buffer size of a station, in jobs, the one in service included.
Finite-buffer blocking or loss anywhere in the network.
Detects whether a network has a bursty (non-renewal) external arrival process.
Detects routing that is not identical across job classes.
Legacy name of
SnHasProductFormNotHetFCFS, kept as a delegating
alias exactly as the python twin does: the pre-rework body here still
admitted LCFSPR and lacked the FCFS equal-service-means check, so it could
disagree with the predicate the AMVA dispatch actually uses.Checks if the network has a quorum (k-of-n) join.
True when some station schedules by non-preemptive shortest job next.
Aggregation of a class-indexed interlock matrix to the chain basis the MVA solvers work in.
Decides whether a model lives on a discrete (slotted) time scale.
Outcome of the test: the verdict, the slot length and why it failed.
The single-station M/M/1/K loss system.
Stochastic network model type classifier for open models.
Tests whether a process representation admits a phase-type reading.
Rate at which sibling tasks are discarded at each Join.
Number of sibling tasks a Join node waits for in a given class.
Number of sibling tasks forked per parent job on a fork-join pair.
Collects the (D0,D1) modulation records of every non-renewal arrival or
service process declared in the network.
One modulating process of the network.
NetworkStruct modification options (placeholder utility class).
Open-class contribution to an aggregate state probability at one station.
Patience (time-to-abandon) handles derived from a
NetworkStruct.The patience law of one station-class pair, in the forms the solvers consume.
Place throughput, arrival rate and response time in tokens.
Recovers per-mode transition firing rates from the Place throughputs.
Outcome of the recovery.
Stochastic network Print algorithms.
Stochastic Network Visit Ratio Calculator.
Convert LINE network structure to Agent (RCAT) format for SolverAG.
Stochastic network ToAG algorithms.
Per-station load-dependent rate scaling alpha(i,n) for the QRF bounds.
The scaling, the utilization normalizer, and why they may not exist.
Derives the QRF BAS blocking tables (f, MR, BB, MM, ZZ, MM1) from an sn.
The derived tables, or the reason they cannot be built.
Per-station occupancy bound F(i) for the QRF bounds.
Occupancy bounds, which of them bind, and why not when they cannot be built.
NetworkStruct Validation Utilities.
Exception thrown when validation fails during NetworkStruct modification.
Abstract base class for model solution algorithms and analysis tools.
Entry point of the agent-based (RCAT) solver.
Analyzer of the agent-based (RCAT) solver.
Port of
build_rcat in solver_ag.m: the network to its RCAT
components and actions.Handler for the solver_amva function.
Handler for the solver_amvald function
Piecewise-linear Lyapunov UPPER bound on the steady-state queue lengths of a
multitype open Markovian network, valid for EVERY work-conserving Markovian
policy.
Achievable-region LOWER bound on the mean response times of a multiclass
open Markovian network, valid for EVERY non-idling scheduling policy at
every station.
Stochastic network calculus UPPER bound on the mean response times and queue
lengths of a feed-forward open network, valid for EVERY work-conserving
scheduling policy at every station.
The per-pair envelopes the analyzer built, kept so that the quantile
accessors can read the tail without a second pass over the network.
Linear-programming bounds on the mean marking and the throughputs of a
stochastic timed Petri net.
Perfect-sampling steady-state analysis of closed single-class product-form
networks, the sampling alternative to CTMC state-space enumeration.
Metrics and sampled states returned by the perfect-sampling analyzer.
Reachability-based state space and per-action rate filters for models with
a finite capacity region (FCR) whose drop rule is WAITQ (waiting queue).
Result bundle: augmented spaces, the per-action rate filters, and the true-BAS
become-blocked arcs.
Stationary analysis by decision-diagram level aggregation.
Metrics and diagram description returned by the aggregation analyzer.
Parallel replication analyzer for LDES solver.
Top-level dispatcher for the MAM/MMAP fork-join decomposition.
Closed-network wrapper around
Solver_mam_basic_mmap_inner.MAM/MMAP fork-join decomposition algorithm parameterised by per-class arrival
rates LAMBDA.
Mixed-network solver that treats the CLOSED classes as a background
modulating chain and the OPEN classes as matrix-analytic queues driven by it.
Discrete-time (slotted) analysis of an open network whose interarrival and
service laws all live on the slot lattice.
Solver for single-class two-station queueing networks using a Level-Dependent QBD.
LD-QBD block construction, flattening and metric mapping.
Per-(station,class) mean metrics derived from a flat LD-QBD distribution.
Flattened generator together with the queue level of each flat state.
Block-tridiagonal LD-QBD representation plus the parameters the avg mapping needs.
MAP/BMAP/1 Queue Solver using GI/M/1 type analysis with ETAQA.
Exact fast-path for the finite-capacity M/M/c/K queue: a Source-Queue(-Sink)
model whose station has a finite total capacity, Poisson arrivals and a
shared exponential service rate.
FJ-aware traffic solver extending solver_mam_traffic with mmap_max
synchronization at join points.
SolverMVA method 'amva.mapqn': the horizontal-cut mean value analysis (Mapqn_amva) of a
closed multiclass model with one exponential delay station and one FCFS single-server
queue whose class-r service is a MAP.
Handler for the solver_mva function.
MVA Analyzer class for bounding methods.
MVA Analyzer class for non-rentrant caches
MVA analyzer for a CLOSED integrated cache-queueing model whose Cache node has a
delayed-hit retrieval system.
Marie's iterative aggregation-decomposition (Marie 1979/1980) for closed
networks with FCFS non-exponential (Coxian) service, wired as SolverMVA
method 'marie'.
M/G/1 queueing systems with SIZE-BASED scheduling: SRPT, PSJF, FB (LAS),
LRPT and SETF.
Approximate analysis of a delayed-hit (retrieval-system) cache via the FPI
algorithms Retrieval_fpi (hit/miss/delayed-hit) and Retrieval_fpi_latency
(expected latency Z).
Closed networks with non-preemptive shortest-job-next (SJF) stations, wired as a SolverMVA
dispatch path.
Summation method (SUM/ESUM) analyzer handler.
NC Analyzer class for solver_nc_cacheqn_analyzer.
NC analyzer for a CLOSED integrated cache-queueing model whose Cache node has a
delayed-hit retrieval system.
Exact normalizing constant solver for closed networks with Limited
class-dependent (cdscaling) service rates, using the multichain
convolution algorithm of Sauer (1983), Section 5.2.
Heavy-usage asymptotic analysis of the closed two-station network with one think
(infinite-server) station and one discriminatory processor-sharing station, by the
generating-function expansion of J.A.
Exact normalizing-constant analysis of a discrete-time (slotted) queueing
model, selected by
options.config.slotted.Classification of a model against the discrete-time product form.
Joint probability of the per-station TOTAL queue lengths.
Result of a joint total-queue-length evaluation.
Specialized NC solver for LCFS + LCFS-PR 2-station networks.
Exact normalizing-constant analysis of a closed queueing network that mixes
order-independent (OI) stations with ordinary BCMP product-form stations.
Importance-sampling (IS) normalizing-constant analysis of a closed two-station
pass-and-swap (P&S) tandem with a non-empty swap graph (Casale, Comte and
Dorsman, 2026).
Exact analysis of a delayed-hit (retrieval-system) cache via the product-form
algorithms Retrieval_nc (normalizing constant) and Retrieval_metrics (hit/miss/
delayed-hit).
Exact product-form analysis of a closed multiclass network with the
state-dependent routing of Krzesinski (1987), "Multiclass Queueing Networks
with State-Dependent Routing", Performance Evaluation 7(2):125-143.
Stationary analysis of a PRODUCT-FORM stochastic Petri net by MDD-rec: the
normalising constant is obtained from one memoised walk of the decision
diagram holding the reachable set, and every reported measure is a masked walk
of the same diagram.
Core handler for the QNS solver.
Analyzer for the QNS solver.
Robust Queueing Network Analyzer (RQNA) based on indices of dispersion.
Robust Queueing Network Analyzer (RQNA) of Robust Queueing Theory.
Handler for the Blocking-After-Service (BAS) approximate MVA method.
Top-level Java translation of Solver_ssj.kt.
Custom random variate generator for deterministic (constant) values.
Random variate generator for a geometric distribution supported on
{1,2,...}, i.e.
Agent-based (RCAT) solver.
Automatic solver selection for queueing network models.
A method name split into a selection intent, or a family plus its submethod.
Container for organized performance metric handles computed by queueing network solvers.
SolverBA is the dedicated bound-analysis solver for closed queueing networks.
Container for the {lower,upper} throughput/queue-length bracket of a
bound family.
One row of
SolverAUTO.findSolver(): 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.Solver for Continuous-Time Markov Chain (CTMC) analysis of queueing networks.
Result of
SolverCTMC.getCdfFirstPassT(jline.util.matrix.Matrix, jline.util.matrix.Matrix): the [F(t), t] curve plus the grid,
density and resolved state sets, the out struct of the reference.ENV - Ensemble environment solver for models immersed in a random environment.
Container class holding the generator matrices and related data structures
for both stage-specific and random environment transitions.
Result container for sample path analysis, containing metrics for each segment.
Data for a single segment in the sample path.
The solver-comparison examples of
matlab/examples/solvers.SolverFLD is an alias for SolverFluid (Fluid/Mean-Field Approximation solver).
FLD - Fluid/Mean-Field Approximation solver.
Solver interface to the Java Modelling Tools (JMT) simulation engine.
Solver for Layered Queueing Networks (LQN) using ensemble-based iterative methods.
State class for exporting/importing SolverLN solution state.
One two-station phLayers, and the caller classes that cycle through it.
Solver interface to the LQNS external tool for Layered Queueing Network analysis.
Enhanced LayeredNetworkAvgTable with detailed metrics support
Solver for Matrix Analytic Methods (MAM) applied to queueing networks.
SolverMVA implements Mean Value Analysis (MVA) for queueing networks.
Exact mean-value MVA for order-independent (OI) queueing networks.
Solver for Normalizing Constant (NC) method applied to closed queueing networks.
Configuration options for queueing network solvers.
Advanced configuration options for specialized solver features.
Configuration for ordinary differential equation solvers used in fluid analysis.
SolverQNS class implements a queueing network solver that wraps the external qnsolver tool.
Container for storing performance metrics computed by queueing network solvers.
Result returned by solver_ssa_nrm.
Constants for specifying a named solver
UQ solver for Bayesian-style parameter uncertainty analysis.
Empirical CDF representing a discrete posterior distribution.
Interval-valued metrics returned by
SolverUQ.getInterval().Table containing per-alternative posterior results.
Row in the posterior table.
Information about a detected Prior distribution.
Functional interface for creating solvers.
An abstraction of the external world jobs in open classes come from
Base class for sparse matrix implementations, containing the core data structure
and methods that directly manipulate the underlying sparse matrix representation.
Result of spectral decomposition.
Spline interpolation utility using Apache Commons Math3.
Convolution algorithm for the normalising constant of an S-invariant reachable
product-form stochastic Petri net.
Linear-programming bounds on the mean marking and the throughputs of a
stochastic timed Petri net.
The brackets, each a 2 x n array with row 0 the minimum.
One (transition, mode) pair over place-major levels.
Options of the relaxation.
Decision-diagram reachable set and Kronecker rate descriptor of a stochastic
Petri net, so that
Mdd_mcd can analyse it.Everything the caller needs alongside the descriptor.
One (transition, mode) pair of the net, in level coordinates.
Options of the translation.
Descriptor, diagram and metadata returned together.
Stationary measures of a product-form stochastic Petri net from the MDD-rec
masses.
The stationary measures of Sec.
Product form of a stochastic Petri net: decide whether one exists and derive
the per-level factors g_l that
Mdd_rec and
Spn_metrics take as input.Options of the product-form derivation.
The product form, and the certificate that it is one.
Enabling-degree distribution of one mode of a product-form stochastic Petri
net, by the masked MDD-rec recursion.
Unnormalised enabling-degree masses of one mode.
Minimal-support S-invariants (P-invariants) of a stochastic Petri net, and the
load vector V = S m0.
The invariant basis of a net, in place-level coordinates.
Result of constructSRK.
SSA is an alias for SolverSSA (Stochastic State-space Analysis solver).
Internal representation of a metric point from SSA simulation.
Configuration options for Stochastic Simulation Algorithm (SSA) solver.
Result container for Stochastic Simulation Algorithm (SSA) solver computations.
Class modeling the state of Stateful nodes
Result class for event handling methods
Topology and coefficients of the product-form state-dependent routing of
Krzesinski (1987), "Multiclass Queueing Networks with State-Dependent
Routing", Performance Evaluation 7(2):125-143, the multiclass generalization
of Towsley (1980), J.
Product-form state-dependent routing, Krzesinski (1987), Perform.
Examples demonstrating state-dependent routing in queueing networks.
Examples of models with state-dependent routing
A class switcher that depends on its local state
A stateful Fork used only on FJ tag-augmented model copies (see
ModelAdapter.fjtag).
A node that can have a state
A class switcher that does not have a local state
Examples demonstrating state probability computations in queueing networks.
Examples of state probability computations
Joint probability of the per-station TOTAL queue lengths, all classes summed
out, from
SolverNC.getProbSysMarg(Matrix).python/examples/advanced/stateProbabilities/: the four
state-probability queries, getProbAggr, getProb,
getProbSysAggr and getProbSys.A node where jobs can spend time stationing there
Optimize the number of identical copies (replicas) of a station.
A per-accepted-step stopping test for
LSODA.Stochastic Petri net examples mirroring the example notebooks in stochPetriNet.
Examples of stochastic Petri net models
Input buffer of a Place in a Stochatic Petri net model
Configuration options for SSA streaming to metrics receiver.
Streaming mode enumeration.
Transport type enumeration.
Standardized time series statistics of the batched quantile process.
A subproblem in a decomposition: a subset of variables to optimize while
others are held fixed.
Result from solving one subproblem in a decomposition workflow.
Summation method (SUM) for closed queueing networks, including the
extended SUM (ESUM) node functions for non-product-form networks with
generally distributed service times.
Result of the summation method.
Closing method for open and mixed non-product-form queueing networks
(Bolch et al., Sec.
Result of the closing method.
Examples demonstrating switchover times in queueing systems.
Examples of models with switchover times
The ordered variable set a family of
SymExpr values shares.Computer algebra operations LINE needs, as seen by the JAR.
Symbolic stationary distribution of a CTMC.
Symbolic analysis of a fluid vector field.
Exact parametric sensitivity, following Trivedi and Bobbio (2017), Sec.
Resolves the symbolic backend to use, and owns the container that serves it.
A rational function over Q in the variables of a
SymContext.A dense matrix whose entries are
SymExpr rational functions.A declaration of a synchronization on a NetworkEvent
End-to-end (chain-level) response time constraint: SysRespT <= maxValue.
A reward function backed by a lookup table over aggregated state vectors.
A Task represents a software component or process in a layered queueing network that can host
services (Entry objects) and runs on a Processor (Host).
Optimize the multiplicity (thread/instance count) of an LQN Task (integer).
Optimize the replication (fan-out replicas) of an LQN Task (integer).
Optimize the think time of an LQN Task (continuous).
Trajectory-based iteration (TBI) analyzer for the transient fluid solution.
Data class representing test results.
Deprecated.
Use RandomManager directly for new code.
Throughput constraint: Tput >= minValue.
Routes edges around nodes to achieve a planar graph layout.
Exports a queueing network model as a TikZ diagram.
Computes automatic layout for queueing network visualization.
Renders queueing network nodes as TikZ code.
Configuration options for TikZ network visualization.
Displays PDF files generated from TikZ diagrams using external viewers.
A service section of a Transition in a stochastic Petri net model
Constants for specifying timing strategies at Petri net transitions
Alias for the Replayer class
Single trace mean computation.
Single trace variance computation.
Summary statistics for a trace.
Method name table for
TransformSolve, mirroring MATLAB
matlab/src/solvers/TR/transform_method.m and python
transform_driver.transform_method.Solver-agnostic driver of a model TRANSFORMATION, the sibling of
FJFixedPoint.What a strategy's expand phase produces: the subproblems, plus whatever
state its lift needs.
One inner solve's answer, on all FOUR channels.
The inner solve, which the caller implements with its own solver class.
The lifted metrics, in ORIGINAL class and station coordinates.
What the driver answers with.
A transformation, as a pair of phases.
Similarity transformation mapping a closing vector to a vector of ones.
Step handler for capturing transient data during fluid solver ODE integration.
Container for transient QBD analysis results.
Transition as in a stochastic Petri net model
A generic triple container that holds three objects of potentially different types.
An undirected graph data structure with weighted edges represented as an adjacency matrix.
Executes unified cross-language tests from JSON definitions.
A continuous Uniform distribution
UQ is an alias for
SolverUQ (Bayesian-style parameter
uncertainty analysis).Utilization constraint: U <= maxValue.
Miscellaneous utilities
Container class for MAPE calculation results
Validation level for SN setter methods.
Options of
Infer_variational.Outcome of
Infer_variational.Inference problem handed to
Infer_variational.Enumeration for specifying solver verbosity levels.
Warm-start placement computation shared by the solvers that can start from
an auxiliary solver's steady-state solution (LDES, SSA, JMT, Fluid).
A Laguerre expansion: the exponential damping, the time scaling and the
coefficients they were computed at.
A Weibull distribution
Main workflow analyzer that coordinates pattern detection and optimization.
All detected patterns.
Node classification result.
Comprehensive workflow analysis result.
Workflow in matrix form.
Integration class connecting workflow analysis to the AUTO solver.
Automatic branch structure detector for workflow networks.
Branch pattern with probabilities.
Workflow Loop Pattern Detection.
Workflow pattern updater for simplifying and optimizing workflow networks.
Service parameters (phase-type distributions).
Updated workflow representation.
Automatic sequence structure detector for workflow networks.
Loader for WfCommons workflow JSON files.
Options for loading WfCommons workflow files.
Distribution type to use for task service times.
A computational workflow that can be converted to a phase-type distribution.
A node of the series-parallel decomposition.
The series-parallel decomposition of the precedence graph.
A computational activity in a Workflow.
Main facade for workflow management and optimization in LINE.
Comprehensive workflow analysis result.
Result from a decomposed workflow optimization: results from each subproblem
and overall fixed-point convergence info.
The
wf_* twins: a workflow reduced to one phase-type law.A Zipf-like probability distribution
Environmentinstead.