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.
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.
Debug test for BAS blocking in closed queueing networks.
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
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.
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.
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 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.
Examples of caching models
Parameter container for cache nodes in queueing networks.
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
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.
A class modelling a set of reachable classes for a given job (a chain)
Result container for characteristic maximum.
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.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.
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).
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.
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
An infinite server station, i.e.
Base class for dense matrix implementations, containing the core data structure
and methods that directly manipulate the underlying dense matrix representation.
A Deterministic distribution taking a single constant value.
Deterministic (Semi-Markov) Process functions.
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
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.
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.
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.
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
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.
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.
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).
Result container for Fluid solver analysis of queueing networks.
Result class for FluidSolve.
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.
A Geometric distribution.
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.
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.
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.
Result of building the augmented fluid model for response time likelihood.
Gibbs Sampling demand estimation from trace data.
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.
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
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.
Level-Dependent Quasi-Birth-Death process solver.
Options for LDQBD solver.
Result of LDQBD solver containing rate matrices and stationary distribution.
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.
Provides save/load functionality for LINE queueing network models to/from JSON format.
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.
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
Converts a LayeredNetwork (LQN) to a Network (QN).
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).
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.
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.
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 wrapper class that extends EJML's Equation functionality to work seamlessly with jline.util.matrix.Matrix objects.
Result of M/D/c queue analysis via Crommelin's embedded DTMC.
A Matrix Exponential (ME) distribution.
ME mean computation algorithms.
ME sampling algorithms using inverse CDF interpolation.
ME squared coefficient of variation (SCV) computation algorithms.
ME variance computation algorithms.
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.
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.
Functional callback used internally for weight-combination enumeration.
Computes the steady-state probability vector for each class in an MMAP.
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 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.
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.
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 for displaying network performance metrics organized by station and job class.
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
Queueing network model without think time.
Triple of (probability, computation time, memory usage).
Abstract base class for solvers applicable to queueing network models.
Class summarizing the characteristics of a Network object
Queueing network model with think time.
Demonstrates JUNG visualization of Network models using the plot() method.
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.
Options for NSF_GHT solver.
Options for NSF_pi solver.
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
An open signal class representing special customers in G-networks and related models.
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.
A Pareto distribution
ParseOptPara - Utility class to parse optional parameters in QBD and related solvers.
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.
Triple of (A, B, DA) coefficient matrices.
Conway-Maxwell approximate MVA for multi-server queueing networks.
Mean Value Analysis for LCFS Queueing Networks.
Result for LCFS NC algorithm.
Multi-server Krzesinski linearizer approximate MVA.
Linearizer++ algorithm for closed networks without think times.
Compute the normalizing constant of a repairmen model using Gauss-Laguerre integration.
Method of Moments (MOM) solver for product-form queueing networks.
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 queueing station within a Network model
A Poisson discrete distribution
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.
Posterior is an alias for
SolverPosterior (Bayesian-style parameter
uncertainty analysis).A pre-computed class dependence function that stores function values for all possible
state combinations.
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.
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.
G/M/1 Queueing System Analysis.
M/M/1 queueing system analysis.
Result of MAP/D/c queue analysis.
Result of MAP/PH type queue analysis.
Result of BMAP/PH/N/N retrial queue analysis.
Helper class for returning four values.
A queueing station that processes jobs according to various scheduling strategies.
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.
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.
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.
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 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 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.
Data structure for storing results from an MVA computation using the LD method.
Extended result type for MVA with load-dependent stations and additional metrics.
Data structure to hold extended results from the MVA computation, particularly
focusing on error corrections.
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 storing sanitized input parameters for a normalizing constant calculation.
Data structure for storing results from a normalizing constant calculation involving throughputs and
queue lengths.
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.
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.
Compute waiting time distribution for Fork-Join queue.
Result of returnWait
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
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
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
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.
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.
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
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
Parallel replication analyzer for LDES solver.
RCAT-based solver for SolverMAM.
Solver for single-class closed queueing networks using Level-Dependent QBD.
MAP/BMAP/1 Queue Solver using GI/M/1 type analysis with ETAQA.
Handler for the solver_mva function.
MVA Analyzer class for bounding methods.
MVA Analyzer class for non-rentrant caches
NC Analyzer class for solver_nc_cacheqn_analyzer.
Exact normalizing constant solver for closed networks with Limited
Joint Class Dependence (LJCD) service rates, using the multichain
convolution algorithm of Sauer (1983), Section 5.2.
Specialized NC solver for LCFS + LCFS-PR 2-station networks.
Core handler for the QNS solver.
Analyzer for the QNS solver.
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.
Automatic solver selection for queueing network models.
Container for organized performance metric handles computed by queueing network solvers.
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.
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.
Posterior 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.
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
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 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
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.
Examples demonstrating switchover times in queueing systems.
Examples of models with switchover times
A declaration of a synchronization on a NetworkEvent
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).
Data class representing test results.
Deprecated.
Use RandomManager directly for new code.
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.
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
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
Miscellaneous utilities
Container class for MAPE calculation results
Validation level for SN setter methods.
Enumeration for specifying solver verbosity levels.
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.
A Zipf-like probability distribution
Environmentinstead.