All Classes and Interfaces
Class
Description
Base class for the benchmark runners that measure the average execution time (and standard deviation) of STNU algorithms
on a given set of instances.
Functional contract used by
AbstractBenchmarkRunner.repeatMeasure(String, String, Supplier, AlgorithmExecutor) to execute one repetition of an algorithm.Represents a key composed by
(nodes, contingents) used to group the global statistics.Outcome of the repeated executions of an algorithm on a single network, collected by
AbstractBenchmarkRunner.repeatMeasure(String, String, Supplier, AlgorithmExecutor).Abstract component as a base class for nodes and edges.
Core class to represent and DC check Conditional Simple Temporal Network (CSTN) where the edge weights are signed integers.
Only for stating which kind of DC checking algorithms have been implemented so far.
Represents the status of a CSTN-checking algorithm during an execution.
Value for dcSemantics
A simple class to maintain the set of edges to check in the following phase.
Acts as a queue and a set.
Base class for implementing LabeledIntEdge.
Abstract class for
LabeledIntMap interface.Base class for implementing Node.
Active wait for a timepoint.
Simple class to represent a ALabel in the CSTNU framework.
An unmodifiable empty label.
Possible state of a
ALabelAlphabet.ALetter in an alphabetic label.A customizable alphabet, where elements are strings.
ALetter makes it simpler to check if a node name is appropriate.
Represents the common behavior of an edge that can have upper-case value(s) and a lower-case one.
An abstract implementation of BasicCSTNUEdge where the type to represent the labeled value set can be plugged during the creation.
Represents a pair (Label, String).
Standalone demo: loads a GraphML file (given on the command line) and shows it in a
JFrame, or builds a small built-in demo graph if no file is given.Unified mouse and keyboard interaction of the new editor (phase N3).
Simple class to determine the average execution time (and standard dev) of the (C)STN(U) DC checking algorithm on a given set of (C)STN(U)s.
Utility internal class to store #contingent, #nodes, and #propositions and allows the ordering among objects of this class.
A reproducible result of one temporal-network check: a
CheckOutcome.Kind.CONSISTENCY or
CheckOutcome.Kind.DYNAMIC_CONSISTENCY check of an STN/CSTN, a CheckOutcome.Kind.DYNAMIC_CONTROLLABILITY check
of an STNU/CSTNU, or an CheckOutcome.Kind.AGILE_CONTROLLABILITY check of an OSTNU.The mutually exclusive families of temporal-network checks.
A checkbox field for boolean node attributes (e.g. the "Parameter?"
A layout that places all nodes on a circle inscribed in
area,
equally spaced in angle, in the stable iteration order returned by
TemporalConstraintGraph.getVertices().A combo box field.
Result category of an
EditorCommand execution.Outcome of running an
EditorCommand through EditorController.execute(EditorCommand, LabeledNode).A compact formatter for
java.util.logging records.Component interface.
Some useful constants for the package.
Notification fired by
CanvasInteraction when the user triggers a context-menu request (right
button, or Control+click on macOS).Represents a Conditional Simple Temporal Network (CSTN), and it contains a method to check the dynamic consistency of the instance.
Simple class to represent and check Conditional Simple Temporal Network, assuming epsilon semantics and reducing an instance to an appropriate CSTN where DC checking is made, assuming instantaneous reaction semantics.
Represents the behavior of a CSTN edge.
An implementation of CSTNEdge where the kind of labeled value map can be configured at initialization (new) time.
Simple class to represent and check Conditional Simple Temporal Network (CSTN) where the edge weights are signed integers.
Simple class to represent and check Conditional Simple Temporal Network (CSTN) where the edge weights are signed integers.
Simple class to represent and check Conditional Simple Temporal Network (CSTN) where the edge weights are signed integers.
Simple class to represent and check Conditional Simple Temporal Network (CSTN) where the edge weights are signed integers.
Simple class to represent and check Conditional Simple Temporal Network (CSTN) where the edge weights are signed integers.
Simple class to represent and check Conditional Simple Temporal Network (CSTN) where the edge weights are signed integers.
Simple class to represent and check Conditional Simple Temporal Network (CSTN) where the edge weights are signed integers.
Simple class to represent and check Conditional Simple Temporal Network (CSTN) where the edge weights are signed integers.
Represents a Conditional Simple Temporal Network (CSTN), and it contains a method to check the dynamic consistency of the instance.
Represents and checks streamlined Conditional Simple Temporal Network with Partial Shrinkable Uncertainty (CSTNPSU).
Represents a prototypal link.
Represents the behavior of a CSTNPSU edge.
An implementation of CSTNPSUEdge.
Allows one to build random CSTN instances specifying:
Represents a Conditional Simple Temporal Network with Uncertainty (CSTNU).
A simple class to represent the status of the checking algorithm during an execution.
Simple class to represent and check Conditional Simple Temporal Network with Uncertainty (CSTNU), where the DC checking is done reducing the instance to an equivalent CSTN instance where the DC checking is done assuming instantaneous reaction.
Reads CSTNU instances and converts them into CSTNPSU (==FTNU) instances, transforming each contingent link into a guarded one.
Actor class that transforms a CSTNU instance into a UppaalTiga Time Game Automate schema.
Represents the behavior of a CSTNU edge.
An implementation of CSTNUEdge where the type to represent a labeled value set can be plugged during the creation.
A simple class is used to represent and check a Conditional Simple Temporal Network (CSTN) where the edge weights are signed integers.
Single source of truth for the implicit curvature applied to an edge — that is, the
curvature that an edge receives automatically, independently of the curvature explicitly set by the
user with
GraphCanvas.setCurvature(Edge, double).A source of explicit per-edge curvature factors that supplements the implicit antiparallel
curvature computed automatically by
VectorTraversal.Contains the static final boolean for enabling/disabling debug logging in all it.univr.di subpackages.
Default
GraphStyle implementation with a fixed color palette:
normal node: light blue fill, dark blue outline
contingent node: light orange fill
observer node: light green fill
selected node: yellow fill, thick outline
node in a negative cycle: red outline
requirement edge: dark gray, solid
contingent edge: dark orange, solid
derived/internal/qloopFinder edge: light gray
selected edge: bright blue
edge in a negative cycle: red
Represents (dense) temporal network graphs where nodes are
LabeledNode and edges are (an extension of)
Edge.Unmodifiable version of this graph.
Simple class to determine the average execution time (and standard dev) of the STN(U) dispatchability algorithms on a given set of STNUs.
A reproducible dispatchability representation derived from a network.
A stored representation is either dispatchable or minimal; absence is represented by
null.Root class for representing edges in the 'it.univr.di.cstnu package'.
Possible types of an edge.
Pure geometry for edges — no Swing dependencies, usable by SVG/TikZ exporters and testable
headlessly.
Result of a geometry computation for a single directed edge.
The explicit routing of an edge: a path from source to destination made of 0, 1 or 2
control points, expressed in coordinates relative to the source→destination chord.
A single control point of the route.
This supplier requires as E a class that implements
Edge interface and that
contains the following three constructors:
E(Class<?Declarative description of a check/transformation command offered by
EditorController
for a given network kind.Headless controller of the new editor: owns the
EditorDocument, the EditorSettings,
and the SelectionModel, and is the only class that runs checking commands.State of the document currently open in the new editor: the input network being edited, the
network kind, the associated file (if any), the dirty flag, and the derived (checked) network
produced by the last executed command.
Installs and persists the visual theme selected for the editor.
Available visual-theme modes.
Mutable container of the options that govern how
EditorController runs its checking
commands.Main editor view: a
JPanel containing the two graph canvases (input, editable, and derived,
navigable but not structurally editable), each wrapped in its own synchronized scrollbars, plus the
command bar, the settings controls, the layout combo, the message area, and the empty slot reserved
for the inspector panel.Maps a file's extension to the vector/raster export format used by the editor.
Number formatting shared by the textual exporters (SVG, TikZ): values are emitted with a bounded
number of decimal digits and no trailing zeros, always using
Locale.ROOT so that the output
never depends on the host locale (the decimal separator is always the dot).Options controlling a figure export.
Simple implementation of a priority queue where elements are T objects and priorities are integers.
The possible state of an element with respect to a
ExtendedPriorityQueue.Force-directed layout based on the Fruchterman–Reingold algorithm
(Fruchterman & Reingold, 1991, Graph Drawing by Force-directed Placement,
Software: Practice and Experience 21(11)).
The FTNU model was introduced as an evolution of the CSTNPSU one, having a simpler name and a DC checking algorithm able to determine the guarded bounds correctly.
Utility class containing some graph algorithm implementations.
The state of a node during a Bellman-Ford-Tarjan search, held in an array indexed by the dense node id of
the search and not in the node, so that two searches on the same graph cannot interfere.
Minimal base class for SCC searches that must traverse every listed arc.
A plain-text note placed on a temporal-constraint graph.
Swing component rendering a
TemporalConstraintGraph using pan/zoom
(ViewTransform), pluggable node positions (NodePositions), pluggable visual
style (GraphStyle) and an observable SelectionModel.This interface defines the methods for managing distances between nodes in a graph.
Implementation based on two nested hash maps.
The only place in the new editor authorized to name the concrete graph backends
(
DenseTCGraph, SparseTCGraph).A graph layout algorithm that assigns positions to the nodes of a
TemporalConstraintGraph within a rectangular area.Registry of the graph layouts available to the user interface.
Utility class for converting STNU file in GraphML format to Luke format.
Which graph an inspected element belongs to.
Visual style for nodes and edges drawn by
GraphCanvas.Inspector panel for editing the attributes of the currently selected node or edge.
Represents an immutable propositional label in the CSTN/CSTNU framework.
Allows managing conjoined upper-case values that are also associated with propositional labels.
A read-only view of a LabeledALabelIntTreeMap object.
Simple implementation of
LabeledIntMap interface.Simple class to represent a labeled value in the hierarchy.
A read-only view of an object
Realizes the map
Label-->intA read-only view of an object
Basic factory of LabeledIntMap objects.
Deprecated.
Deprecated.
Simple implementation of
LabeledIntMap interface.A read-only view of an object
Extends LabeledIntTreeMap, setting optimize field to false.
In this way, labeled values where labels are not shortened.
This class is useful for the OSTNUPluggableEdge class.
In this way, labeled values where labels are not shortened.
This class is useful for the OSTNUPluggableEdge class.
Represents an immutable Labeled Lower Case value.
LabeledNode class.
LabeledIntEdgePluggable supplier.
A compact editor for a list of labeled values — CSTN ordinary labeled values, and the unified
CSTNU/CSTNPSU upper/lower-case value table — with explicit Add/Remove buttons and in-place editing
of every row.
A mutation on the edge removing the row identified by its label text, delegated to the controller.
An in-place edit of one existing row, delegated to the controller as a single mutation (so the
dirty flag flips once per user action).
A mutation on the edge adding one (label, value) pair, delegated to the controller.
Signals that a mutation was silently rejected by the domain (min-merge: a stricter value already
present on the edge makes the new one redundant).
An immutable literal.
Log-normal distribution of the duration of a contingent link, held by the contingent time point.
Utility class for converting a (C)STN(U) file in Luke format to GraphML format.
Benchmark runner dedicated to the MDE algorithm (
applyMDE()) that transforms a DC STNU into its minimal
dispatchable form.Command-line bridge that reads a small MISTNU JSON representation, builds an STNU graph, runs the SRN-cycle
dynamic-controllability check, and emits a compact JSON result.
Computes a compact, deterministic fingerprint of the semantic content of a
TemporalConstraintGraph.Static registry of the temporal-network kinds managed by the new editor.
Static description of a network kind manageable by the editor.
Root class for representing nodes in it.univr.di.cstnu package.
Source of layout positions for nodes.
A type-specific array-based FIFO queue, supporting also dequeue operations.
An implementation of
Collection interface that stores exactly two objects and is immutable.Represent a minimal interface to an optimization engine that can solve non-linear optimization problems.
Records the result of a call to the
OptimizationEngine.nonLinearOptimization(double[], double[][], double[], double[], double[]) method.Represents a Simple Temporal Network with Uncertainty and Oracles (OSTNU).
A simple class to represent the status of the checking algorithm during an execution.
An implementation of OSTNUEdge where the labeled value set is not optimized for maintaining scenarios like ¬c,0, and c,1.
Allows one to build random OSTNU instances specifying:
number of wanted DC/NOT DC instances
And the following parameters that characterize each generated instance:
number nodes
number of contingent nodes
number of oracles
max weight for each edge
max weight for each contingent link (upper value)
max in-degree for each node
max out-degree for each node
probability to have an edge between any pair of nodes
Simple class that extends CSTNU for representing and managing 'parameter nodes'.
TEMPORARY benchmark runner dedicated to a focused study of the STNU dispatchability algorithms
applyMDE()
(MinDispESTNU), applyFD_STNUPlusMinimization() (SIMP-SEQ), and applyFD_STNUPlusMinimizationMinus()
(SIMP-SEQ-MINUS).One of the five selectable algorithms, with its CLI flag, its labels for the two output tables, and the mapping
from
PhaseStatsBenchmarkRunner.Slot to the phase name recorded by STNU.STNUPhaseStatistics.The six sub-problem "slots" of the dispatchability pipeline shared by all three algorithms.
Exports the rendering of a
GraphCanvas as a PNG file.A row of the inspector: a label, an editor component, and an inline error message that appears only when the field is invalid.
Simple class to represent a Probabilistic Simple Temporal Constraint Networks (PSTN), where the edge weights are signed integers.
Extends STNCheckStatus to represent the result of the approximating STNU.
A simple class to determine some statistics about the execution of PSTNs
The possible exit of an RTE
Maintains the map (contingent node, chosen duration of its contingent link), the number of chosen durations outside the bounds of the relative contingent link, and the conjunct probability mass of the contingent ranges with respect to the probability distribution functions of the contingent durations.
Simple class for making a meter in the console.
Observable set of selected nodes and edges.
JUNG-independent implementation of a temporal constraint graph, optimized for sparse temporal
constraint networks.
Determines the average execution time and some statistics of the STNU SRNCycleFinder on a given set of STNUs.
Represents a Simple Temporal Network (STN), and it contains some methods to manipulate and check an STN instance.
Implemented algorithms for STN.
Global time counter for
STN.getStrongConnectedComponents(LabeledNode)Represents the status of a checking algorithm during its execution and the final result of a check.
Represents the behavior of an STN edge.
Functional interface to retrieve the edge value of interest.
Implementation of STNEdge using an integer for weight.
Simple class to represent and consistency-check Simple Temporal Network with Uncertainty (STNU), where the edge weights are signed integers.
4-tuple to represent the negative distance between two activation nodes and the range in which such distance can be considered.
Possible DC checking algorithm
Helper record for
getPCinfo methodRepresents the immutable triple (sourceNode, weight, destinationNode) necessary for generating an STNUEdge.
Status for 1) negative nodes in Morris 2014 algorithm or 2) contingent edges in RUL2020.
Data structure for MDE algorithm to support backtracking from a contingent node in the LO-subgraph.
Reusable data structure for Step M4's modified
stnDisp.One entry of the pseudocode's
needStandIn[V] list (procedure processWaits, revision r5750 of
mdeStarPseudocode.tex): the diamond VACW that requires a stand-in edge leaving V,
together with the two independent "special" criteria that may have fired for it.Successor entry used by MDE Step M3 to record an arc of the reverse predecessor graph of the AllMax projection.
Sentinel used by Step M4 for
nnddt/nnddf: an ordinary edge, not a special stand-in edge,
terminates a non-negative suffix.Data returned by
STNU.mdeM4b4ManageRCsForStnDisp(MDELocalInfoM3, Instant).One entry of the pseudocode's
siVar[W] list: the stand-in edge (V, deltaVW, W) together with
the diamond it came from and its two special criteria.Data structure for RUL algorithm.
Data structure for RUL algorithm.
A simple class to represent the status of the checking algorithm during an execution.
Indicates which kind of edges determine a Semi-Reducible Negative Cycle (SRNC)
Represents some statistics about a Semi-Reducible Negative Cycle (SRNC)
Kinds of negative cycles
Represents a path of the STNU edge
Collects per-phase execution statistics (time and edge counts by category) for
STNU.applyMDE()
and STNU.applyFD_STNUPlusMinimization().One row of statistics for a single phase.
Loads STNU instances previously generated by
STNURandomGenerator using the
add4or6NestedDiamond method (a chain of nested diamonds V(i) -> C(i) <= A(i) -> W, closed by
a single Uxxx node) and adds, to each diamond of the chain, the one edge that is missing to turn its
wait into a semi-rigid cycle: an ordinary path from A(i) back to V(i) whose length equals the
magnitude of the wait generated by that diamond, so that the wait and the path form a tight cycle.A single tightening edge added to close one diamond's semi-rigid cycle.
A run that must not be saved.
A successful run: the graph passed in has been mutated in place (edges added, and possibly some negative
requirement edges relaxed to restore dynamic controllability) and every tight path has been verified.
Reads STNU instances and makes them denser, adding up to d (n (n-1)) edges, where n is the number of nodes and d the density.
Represents the behavior of an STNU edge.
A lower/upper-case label is represented as a pair: (node-name, flag).
Implements
STNUEdge interface using signed integer values.Allows one to build random STNU instances specifying:
number of wanted DC/NOT DC instances
And the following parameters that characterize each generated instance:
number nodes,
number of contingent nodes,
max weight for each edge,
max weight for each contingent link (upper value),
max in-degree for each node,
max out-degree for each node,
probability to have an edge between any pair of nodes.
A Real-Time Execution (RTE) algorithm is a scheduling algorithm that preserves maximum flexibility while requiring minimal computation.
Represents a contingent link
Strategy for choosing a node and an instant among a set of possible ones.
Node enabled in the given time window.
Node occurrence
(t, nodes).Node with its time window.
RTE Decision.
Class to represent the data for an execution of
STNURTE.rte(Strategy, Strategy).This interface allows the use of an enum of predefined strategies and the possibility of defining new ones.
An enum of predefined strategies allows the specification of a strategy as an input parameter.
An enum of predefined strategies allows the specification of a strategy as an input parameter.
Allows the specification of a predefined strategy as an input parameter.
Simple class to determine the average execution time (and standard deviation) of the RTE* STNU algorithm on a given set of STNUs.
The "Saved" layout: does not recompute positions; it leaves each node where
its stored coordinates say it is.
A
NodePositions implementation that reads/writes positions directly to the
LabeledNode itself (via LabeledNode.getX()/LabeledNode.setX(double) and
LabeledNode.getY()/LabeledNode.setY(double)).Emits a temporal graph as valid, well-formed SVG.
Command-line benchmark comparing
DenseTCGraph and SparseTCGraph through their common
TemporalConstraintGraph operations.Reads temporal-constraint graphs from GraphML without depending on JUNG.
Writes a temporal-constraint graph in GraphML without depending on JUNG.
Optimized representation of immutable predecessor graphs.
Computational API of a directed temporal-constraint graph.
An edge paired with the canonical vertex at the opposite end of a traversal.
Utility that copies a
TemporalConstraintGraph onto a graph of a possibly different
backend and a possibly different edge implementation, chosen by the caller.Logical type of temporal network, independent of its dense or sparse graph backend.
An interface for a graph representing predecessor relationships, typically
used in shortest-path algorithms.
A text editor field: validates the editor's text with
parser, commits the parsed value through applier, and converts the model value to display text with renderer.Emits a temporal graph as TikZ (PGF/TikZ LaTeX).
Represents a time interval where the lower bound is guaranteed to be ≤ the upper bound.
Thin
JFrame wrapper around EditorView.Destination of a single
VectorTraversal over a temporal graph.Single traversal of a
TemporalConstraintGraph that feeds geometry, style and labels to a
VectorSink.Affine pan+zoom transform between model and view coordinates.
Some common types of unsatisfied property for well-defined CSTN.
Kinds of possible errors in checking well-definition property.