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 class modeling precedence relationships among activities
Constants for defining activity precedences in LayeredNetwork models
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.
Fork firing synchronization handler (FJ tag-augmented structs, see
ModelAdapter.fjtag).
Result container for global event processing in Stochastic Petri Net models.
Model factory for MAM (RCAT/INAP method) examples.
Examples demonstrating MAM with RCAT/INAP method for agent-based analysis.
Main benchmark runner - runs all benchmark suites
Runs all examples by invoking BasicExamples and AdvancedExamples.
Top-level functions for AMAP2 gamma fitting (ported from Kotlin).
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.
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
Formats benchmark results in MATLAB-style tables
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.
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.
Budget constraint: total cost <= budget, cost from variable values.
Input buffer of a station
Build PH representation for 2-node Fork-Join job.
A cache node that implements cache replacement policies and class switching based on cache hits and misses.
Refined mean-field (1/N-accurate) miss rates for RANDOM(m) caches.
Result of cache_miss analysis.
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
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.
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.
A task that offers caching services
Transient refined-mean-field cache trajectory for a network, produced by
FluidCacheTran.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.
Peak of a class-dependence handle over the population lattice.
A class modelling a set of reachable classes for a given job (a chain)
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 Kotlin 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 Kotlin 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.
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).
Poisson weights on the Fox-Glynn truncation window.
Outcome of a GMRES solve.
Result of ctmc_multi computation.
CTMC random generator matrix construction.
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.
Result of connected component analysis.
Result of CTMC solving.
Result data class for CTMC SSG reachability analysis
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).
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.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.
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).
Result of D/M/c queue 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.
Result class for DTMC uniformization analysis containing the probability vector and maximum iterations used.
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').
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
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
Deprecated.
Use jline.lang.ModelAdapter.aggregateFES() for public API
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.
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.
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.
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 translated from FJUtils.kt's top-level functions.
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).
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.
Clamped piecewise-linear interpolation of a vector-valued trajectory.
Non-homogeneous Poisson (NHPP) support for the fluid solver.
Symbolic export of the mean-field ODE system integrated by SolverFluid.
Structural description of the exported ODE system.
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.
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
Fork-join network examples mirroring the Kotlin 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 Task directly with setSetupTime() and setDelayOffTime() methods.
Gallery of simple and classical queueing models
A Gamma distribution.
Result class for GeneralFluidSolve containing the parameters of the
matrix-exponentially distributed stationary distribution.
Container for a sampled event from the general RL environment.
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
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
Simple HTTP client for sending metrics to a receiver.
Sampling method to approximate the permanent using the Huber-Law bound.
A hyper-exponential distribution.
One row of the pre-computed CME parameter table.
An Immediate distribution that always samples 0.
Eliminates immediate transitions from Fluid ODE system using stochastic complementation
to reduce stiffness and improve performance
Result of immediate elimination containing reduced system and state mapping
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.
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).A service section with an infinite number of servers (pure delay).
Examples demonstrating initial state configurations in queueing networks.
Examples of model initialization
Input section of a station
A caching service that gives access to items
A set of cacheable items
JMT is an alias for SolverJMT (Java Modelling Tools solver).
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.
KPC-Toolbox fitting functions.
Examples demonstrating layered queueing networks with contention queues (CQ).
Model definitions for Layered CQ (Contention Queue) examples.
Layered network examples mirroring the Kotlin 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
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
Result container for layered queueing network solver analysis.
Demonstrates JUNG visualization of LayeredNetwork models using the plot() method.
Result class for LCFS MVA algorithm.
LDES is an alias for SolverLDES (Discrete Event Simulation solver).
CLI for the standalone ldes.jar (LINE Discrete Event Simulator).
Configuration options for LINE Discrete Event Simulator (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.
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/Kotlin implementation equivalent to MATLAB LINE.m
Parameters for linear reduction models with phases.
Container for the linear system matrices used in MOM solver
The LineCLI class provides a command-line interface for configuring and running the LINE Solver.
A client for sending layered network models to a Docker-based LINE server.
Interface between the optimizer and LINE's SolverAUTO.
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().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
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.
Majumdar-Woodside robust box bounds on throughput for a layered queueing
network (LQN), computed on the processor-contention model.
Result holder.
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.
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).
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.
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.
A Markovian Arrival Process
Andersen-Nielsen MAP fitting algorithm.
MAP Andersen-Nielsen fitting algorithms.
MAP arrival rate computation algorithms.
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.
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 (ported from Kotlin).
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.
Implementation of bnd_linearreduction_new.mod linear program.
Implementation of bnd_mvaversion.mod linear program.
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
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.
Parameters for QR Bounds RSRD (Repetitive Service Random Destination) model.
Solution returned by Mapqn LP solvers.
Transforms a queueing network with MMPP2 service into a random environment model.
Result class for RandomMAP.
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.
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).
Hardware-aware, profiling-calibrated memory guard for
SolverCTMC.Result of a gate decision.
Options for the ME OQN algorithm.
Result of the ME OQN algorithm.
Result class for MEFromMoments containing both alpha and A.
Constants for specifying a Metric
Constants for specifying a type of metric
MFQ (Markovian Fluid Queue) analyzer for single-queue open systems.
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.
Mixed queueing network examples mirroring the Kotlin 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).
Options for MMAP[K]/PH[K]/1 queue analysis.
Result of MMAP[K]/PH[K]/1 queue analysis.
Top-level functions for MMAPPH1NPPR analysis (ported from Kotlin).
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 HTTP receiver for testing streaming functionality.
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
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 transform of a sequence.
Inverse binomial transform of a sequence.
Central moments from power (raw) moments.
Factorial moments from binomial moments.
Factorial moments from power (raw) moments.
Factorial moments from upward-factorial moments.
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 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.
Upward-factorial moments from factorial moments.
Upward-factorial moments from negative-binomial moments.
Upward-factorial moments from power (raw) moments.
Result container for MOM solver computations.
MOM-specific utility functions for combinatorial operations
Complements the existing jline.util.Maths class
Formats MQN benchmark results in MATLAB-style output format
Benchmark result data structure
Accumulates benchmark results for batch formatting
Mutual information for discrete variables.
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.
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.
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.
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 for displaying network performance metrics organized by station and job class.
Table of bound brackets produced by SolverBA, in the layout of
NetworkAvgTable.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 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 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.
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.
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 Kotlin notebooks in openQN.
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.
ParseOptPara - Utility class to parse optional parameters in QBD and related solvers.
Placement-order logic of a pass-and-swap (Pinvalid input: '&S') / order-independent network
with swap graph H.
Derive the GLOBAL placement-order DAG H of a closed two-station pass-and-swap
(Pinvalid input: '&S') tandem 1->2->1 directly from its swap graph, for use with
Pfqn_pas_is.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.
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.
Akyildiz-Bolch (A/B) linearizer method for closed product-form queueing networks.
Akyildiz-Bolch AMVA method for multi-server BCMP networks.
PFQN ab algorithms.
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.
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.
Triple of (A, B, DA) coefficient matrices.
Conway-Maxwell approximate MVA for multi-server queueing networks.
DAC (Distribution Analysis by Chain) method for closed product-form queueing
networks with single-server fixed-rate, infinite-server and queue-dependent
service centers.
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.
Mean Value Analysis for LCFS Queueing Networks.
Result for LCFS NC algorithm.
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.
Marie's iterative aggregation-decomposition (Marie 1979/1980) for closed
queueing networks with FCFS non-exponential (Coxian) service.
Compute the normalizing constant of a repairmen model using Gauss-Laguerre integration.
Method of Moments (MOM) solver for product-form queueing networks.
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).
Majumdar-Woodside robust box bounds on throughput for closed multiclass
queueing networks with mixed scheduling disciplines.
Conditional mean number of in-service jobs per class at an OI station.
Importance-sampling (IS) estimate of the normalizing constant of a SINGLE
communicating class of a closed two-station pass-and-swap (Pinvalid input: '&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.Schmidt method for load-dependent MVA with multi-server stations.
Schmidt MVA algorithm for multi-class FCFS queueing networks.
Result of pfqn_sqni containing Q, U and X matrices.
Lower Asymptotic Bound Approximation (ABA) for throughput in single-class networks.
PFQN mom algorithms (documentation marker).
PFQN nc algorithms (documentation marker).
PFQN procomom algorithms (documentation marker).
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).
Result of computePi.
A place within a stochastic Petri net / queueing Petri net model.
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.
Priority queueing examples mirroring the Kotlin notebooks in prioModel.
Examples of queueing models with priorities
Prior distribution representing parameter uncertainty over alternative distributions.
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
Constants for specifying a point process type
Utility class for calling Python scripts from Java
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.
Result of qbd_mapmap1 analysis.
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.
Geo/Geo/1 discrete-time queueing system analysis.
Geo^X/Geo/1 discrete-time queueing system analysis.
G/M/1 Queueing System Analysis.
Analyzes an M/G/1 queue with SRPT (Shortest Remaining Processing Time)
scheduling using the Schrage-Miller class-conditional response-time formula.
M/M/1 queueing system analysis.
Result container for the M/M/c/K metrics.
Result of MAP/D/c queue analysis.
Result of MAP/PH type queue analysis.
Result of BMAP/PH/N/N retrial queue analysis.
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.
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.
RCAT (Reversed Compound Agent Theorem) model representation.
Collection of stations with constraints on the number of admitted jobs
Data structure representing a finite capacity region with all its constraints and properties.
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.
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 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 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 type for the Method of Moments (MoM) exact algorithm.
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.
Result type for normalizing constant computations in product-form queueing networks.
Data structure for storing complex results from a normalizing constant calculation.
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.
Data structure for storing results from a normalizing constant calculation involving throughputs and
queue lengths.
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_oi_nc: normalizing constant G(N) of a closed
order-independent (OI) + 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.
Data structure for storing results from the Queue-Dependent (QD) approximate MVA method.
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.
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).
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.
Runge-Kutta-Fehlberg 4(5) adaptive ODE integrator.
Result returned by RKF45.integrate.
RL environment for queueing network routing decisions.
General RL environment for queueing network control decisions.
TD learning agent for queueing network routing decisions.
General TD learning agent for queueing network control.
Integrated cache-queueing network analyzer using fluid approximation.
A node that routes jobs without imposing any delay
Class representing a probabilistic routing matrix
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.
Format of the sampled data.
Observed data for a metric.
Container for a sampled event from the RL environment.
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.
Enumeration of scheduling strategies available at queueing stations.
Constants for specifying a scheduling strategy type at stations
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
Constructs the linear system matrices for the MOM solver.
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.
Simplified LQN benchmark implementation
Custom solver factory for LQN benchmarks
An abstraction of the external world jobs in open classes depart to
Builds a fork-join synchronization map from LINE's sn structure.
Result of the fork-join synchronization scan.
Detects whether a network has a bursty (non-renewal) external arrival process.
Stochastic network model type classifier for open models.
NetworkStruct modification options (placeholder utility class).
Stochastic network Print algorithms.
Stochastic Network Visit Ratio Calculator.
Convert LINE network structure to Agent (RCAT) format for SolverAG.
Stochastic network ToAG algorithms.
NetworkStruct Validation Utilities.
Exception thrown when validation fails during NetworkStruct modification.
Abstract base class for model solution algorithms and analysis tools.
Handler for the solver_amva function.
Handler for the solver_amvald function
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 plus the per-action rate filters.
Parallel replication analyzer for LDES solver.
RCAT-based solver for SolverMAM.
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.
Solver for single-class closed queueing networks using Level-Dependent QBD.
LD-QBD block exposure, flattening and metric mapping for the SolverENV
state-vector analyzer's MAM backend.
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.
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'.
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).
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.
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 (Pinvalid input: '&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).
Core handler for the QNS solver.
Analyzer for the QNS solver.
Robust Queueing Network Analyzer (RQNA) based on indices of dispersion.
Handler for the Blocking-After-Service (BAS) approximate MVA method.
Kotlin migration of solver_ssa_reachability.m
Computes the reachable state space for SSA analysis
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.
Automatic solver selection for queueing network models.
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.
Solver for Continuous-Time Markov Chain (CTMC) analysis of queueing networks.
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.
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.
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.
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.
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
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
A node where jobs can spend time stationing there
Optimize the number of identical copies (replicas) of a station.
Stochastic Petri net examples mirroring the Kotlin 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.
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
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).
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.
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.
JUnit5 test suite for unified cross-language tests.
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.
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 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 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.
A Zipf-like probability distribution
Environmentinstead.