v4.12

date: 2024-03-08

Added the following classes:

• OSTNU: class to represent Simple Temporal Networks with Uncertainty and Oracles.

Updated the following classes:

• STNURTE: fixed minor bugs when executing networks having useless wait constraints involving contingent. timepoints.
• STNU: simplified some checks in applyMinDispatchableESTNU() methods. Added the original FD_STNU algorithm implementation. So, now there are two implementation of FD_STNU: FD_STNU (the original) and FD_STNU_IMPROVED (as the original, but it does not add waits that are more negative than the duration of the relative contingent link).

v4.11

date: 2024-02-14

Added the following classes:

• STNURTE: class for the implementation of a Real-Time Execution algorithm for STNUs.
• TimeInterval: utility class to represents a time interval where lower bound is guarantee to be ≤ upper bound.
• ActiveWaits: utility class to represents an active waits.

Updated the following classes:

• Class STNU: implemented the MinDispatchableESTNU algorithm. Changed the name to some methods. Fixed minor bugs.
• Class STN: fixed an annoying bug in GET_STRONG_CONNECTED_COMPONENTS and GET_STRONG_CONNECTED_COMPONENTS_HELPER methods. Changed the name to some methods.
• Class TNGraphMLReader.java: reads the name of the graph from the attributed Name in the document.
• Class TNGraph: addEdge throws an exception if the edge already exists. Returning a false was not sufficient to avoid some errors. Added methods makeNewEdge and getUniqueEdgeName.
• Class ExtendedPriorityQueue.java: renamed from MinPriorityQueue. Renamed some of its methods to represent a generic priority queue (min or max). Now, it depends on a better heap library.

v4.10

date: 2023-11-02

Switched to Java 21. To Apple macOS users: it seems that OpenJdk 17 has some problems to run the TNEditor because of a missing system libraries. I recommend to use Temurin 21 (https://adoptium.net/): I tested it, and it works without problems.

• Class STN: method makeFastDispatchMinimization adds constraints from the source node to guarantee that the source node can reach any node.
• Class TNEditor: for STN instance, dispatchable version is determined using makeFastDispatchMinimization method.

v4.9

date: 2023-07-20

• Class AbstractCSTN: reset method does not remove the internal graph.
• Class PriorityQueue: added methods delete() and getElements().
• Class TNEditor: added Capture function for saving networks shown in the application as PNG images.
• Class FTNU: added a constructor that accepts an XML string describing the network.
• Class CSTNPSU: method getEMaxDistanceInContingencyGraph(contingencyGraph) replaced by getMaxPathContingencySpanInContingencyGraph(nodeName, contingencyGraph). Added method configureSubNetworks(subNetworks, n).
• Fixed different minor bugs.
• Codd cleaned in most of the classes.

v4.8

date: 2022-12-28

• Class CSTNPSU: added method getPrototypalLink() for determining Prototypal Link with contingency (PLC).
• Class FTNU: it is an alternative name for the class CSTNPSU.
• Cleaned the code of many classes.

v4.7

date: 2022-11-01

Added the new class PCSTNU, Parameterized CSTNU, for representing CSTNU having parameter time-points.

• Interface Node: added methods for checking if a node is a parameter one.
• Class AbstractNode: removed default methods because moved into Node interface.
• Class LabeledNode: added a new field for identify parameter time-points.
• Class TNGraph: added code for managing PCSTNU instances and improved some logging code.

Fixed some minor issues:

• Class AbstractCSTN: improved the determination of the max edge value.
• Class CSTNPSU: improved the determination of all constraints when the parameter propagationOnlyToZ is false.
• Class STN: removed a useless annotation.

v4.6

date: 2022-06-03

The project has been updated to run with Java 17. Moreover, from this release the source code is tested by spotbugs configured with maximum effort and minimal threshold parameters.

• Class STNUDensifier: improved allowing also the requirement of an exact number of edges (that can require to remove edges).
• Class STNU: Changed the name of fast dispatch algorithm.
• Class Checker: Made the long parameter specifications prefixed by --.
• Class STNURandomGenerator: Improved the documentation of the README.txt generated for describing a benchmark.

v4.5

date: 2022-03-30

• Class Checker: added two statistic indexes when STNU are checked.
• Class PriorityQueue: Map of entries is now realized by an open hash for a better performance. Removed throws of exceptions when it is not necessary.
• Class STN: Generalized all methods to accept edges that extend STNEdge. In this way some static methods can be used also by STNU class. Fixed a bug in getStrongComponents method.
• Class STNU: Added fastSTNUdispatchability method. Changed the name of method RUL2020 in RUL2021. Fixed some bugs about other methods. Improved the efficiency of some methods.
• Classes Component and AbstractComponent: removed color attribute because it is necessary to have lightweight components. All complementary attributes will be removed.
• Interface STNUEdge: Improved the representation of contingent/wait edges representing such data as object of the internal class ContingentCasePair.
• Class STNEdgeInt: Improved default constructor.
• Class STNUEdgeInt: Improved default constructor.
• Improved the representation of contingent/wait edges representing such data as object of the internal class ContingentCasePair.
• Class TNGraph: Changed internal maps representation. Added two caches for speed-up getInEdgesAndNodes and getOutEdgesAndNodes methods. For performance reasons, removed the removing observer instruction in the removeEdge method. Now, when an edge is removed from a graph, all its observing graphs are removed. It is not the correct behaviour, but removing only the correct graph requires too much time to the method of the library. In a next release such issue will be fixed. When a graph is created by a copy, its internal labelAlphabet is cloned.
• Class CSTNPSU: fixed a bug in the initAndCheck method that didn't allow the specification of guarded link with label in the external bounds.
• Class TNEditor: added visualization of cursor position coordinates.
• Class CSTNULabelEditingGraphMousePlugin: fixed the bug that made a contingent edge ordinary after an edit of its value.
• Class CSTNU: added a check to guarantee that an activation node is associated to only one contingent node.
• New class TNPredecessorGraph: Class for representing predecessor TNGraph in a very compact way.

v4.4

date: 2022-01-03

• Improved the parser of labeled value map/set.
• Class AbstractCSTN. Improved checkAndInit: all negative edges going to obs time-point are checked and cleaned.
• Class STN: improved all SSSP algorithms making each node reachable by Z in case of forward search. Fixed a bug in makeDispatchable() method: it didn't remove all dominated edges if their opposite were not present. Added methods getAccumumulateUndominateEdges and getFastDispatchMinimization, a faster method for determining the dispatchable version of a network.
• Class PriorityQueue: removed the ambiguous method value.
• Class TNGraph: introduced the unmodifiable(TNGraph) static method.
• Class ALabelAlphabet: added a new constructor.
• Class LabeledNode: started its re-factoring. Next releases will specialize such a class for optimizing its memory footprint.

v4.3

date: 2021-10-20

• Class LabeledNode: extended for Tarjan algorithm.
• Class STN: added BFCT (a.k.a. Tarjan algorithm) algorithm in STN class. Such an algorithm can return the negative cycle if the network is not consistent.
• Class NodePriorityHeap: renamed as PriorityQueue and made generic.
• Class LabeledNode: removed rendering code.
• Class NodeRendering: new class for customize rendering of LabeledNode in TNEditor.
• Class TNEditor: GUI cleaned a little bit.
• Removed the dependency on FreeHep library because FreeHep does not work with JRE > 8.
• Removed ‘normal’ and ‘constraint’ type for Edge in favor of requirement because in Temporal Networks requirement is more appropriate.
• Improved all documentation (now, there is only one README.md). Added BUILDING.md document that explains how to build a package and
• the preliminary steps to take before a commit (only for developers).

v4.2

date: 2021-10-07

• Fixed the main method of STN class: now it checks a given network.
• Fixed an initialisation error of graphic driver in TNEditor and improved Save dialog.

v4.1

date: 2021-08-17

• Program CSTNEditor is renamed as TNEditor.
• Removed all unnecessary exceptions.

v4.0

date: 2021-08-01

• Relevant change: the library is now a JVM 11 library, but it is still compatible with JVM 8.
• Improved Javadoc for almost the classes/methods.
• Fixed all spotbugs bugs/errors at level medium and max effort.

v3.6

date: 2021-06-20

• Fixed a weird bug in CSTNPotential class: the dynamicCheck() method worked right but, at the end, the edges in the checked graph were wrongly saved in reversed way.
• Refactored classes GraphMLReader and GraphMLWriter for making them more general. Now, GraphMLReader can build a TNGraph from a string representing it in GraphML format and GraphMLWriter can serialize a TNGraph in GraphML format.
• Class CSTNU: added the constructor CSTNU(String) for building an instance from a GraphML string.
• Class AbstractCSTN: added the method String getGCheckedAsGraphML().

v3.5

date: 2021-06-14

• Fixed a small bug on Dijkstra method in STN class.
• Class NodePriorityHeap refactored.

v3.4

date: 2021-06-03

• CSTNU Check propagates also the bounds of a contingent link as normal constraints in order to avoid that a contingent link can have upper case value different from the negated upper bound.
• Fixed a graphical interface initialization error.

v3.3

date: 2021-05-23

• CSTN(U)CheckStatus stores also the node having the negative loop when the network is NOT DC.
• All DC checking methods save the resulting graph into a file before returning the status of a check.
• Improved some Javadoc comments.

v3.2

date: 2021-01-14

• Fixed a coding error on saving network into file. From this release, the file encoding is UTF8 independently of the execution platform.
• Fixed an initialization error in CSTNU class.
• Fixed almost all Javadoc errors.

v3.1

date: 2020-12-28

• Some cleaning actions.
• Added copyright and licenses for publication on archive.softwareheritage.org.

v3.0

date: 2020-11-15

• STNU class added with different DC checking algorithms: Morris2016, RUL2018, and RUL2020 faster one.
• CSTNPSU class offers a DC check sound-and-complete that can also adjust guarded links to the right ranges for an execution.
• Fixed some minor bugs.

v2.11

date: 2020-02-02

• Graphical interface simplified.
• Now it is more intuitive to add/remove nodes/edges.
• CSTNPSU class offers a DC check sound-and-complete.

v2.10

date: 2020-02-02

• CSTN class restored to a previous algorithms.
• Removed the possibility to check without using unknown literals.
• This version considers the new rule and algorithm names published in a work presented at ICAPS 2020.
• CSTN class implements two DC checking algorithms. With option --limitedToZ, the algorithm is the one presented at IJCAI18 (algorithm HR_18). Without --limitedToZ, the algorithm is the one presented at ICAPS19 (algorithm HR_19). This last version is not efficient as IJCAI18 one.
• For a very efficient version, consider CSTNPotential class (reintroduced but in a new form) that makes DC checking assuming IR semantics and node without labels (algorithm HR_20).
• CSTNPotential class implements the new DC checking algorithm based on single-sink the shortest paths and potential R0 and potential R3 rules.
• For all objects containing a labeled values field, the default implementation class is LabeledIntTreeMap. For changing this default class, modify the field DEFAULT_LABELEDINTMAP_CLASS of LabeledIntMapSupplier and recompile sources.
• CSTNPSU class allows the representation and the verification of temporal constraints containing guarded links. The DC checking algorithm is sound but not complete. Moreover, the guarded link bounds are not guaranteed to be shrunk in the right way.

v2.00

date: 2019-11-07

• CSTN class implements 9Rule DC algorithm. Such algorithm consists in 3 rules (LP, R0, and R3*) for generating also -∞ value and 6 rules for managing -∞ values that are stored as potential values in nodes.
• Added CSTNSPFA class that implements the DC checking algorithm as single-sink BellmanFord one. Therefore, only node potential values are generated. This class uses only 3 rules.

v1.26.vassar

date: 2019-10-21

• Rewritten many classes for representing efficiently edges and graphs for STN networks.
• Removed class CSTNPotential (last svn-version 296).
• Added class STN & companions for some STN specific algorithms.

v1.26.0

date: 2019-03-23

• CSTNU class has a new field, contingentAlsoAsOrdinary, default false. When it is true, the DC checking method propagates contingent links also as ordinary constraints. This allows one to see some ordinary values more accurate.

v1.25.0

date: 2018-11-22

• Minor code optimization and minor bug fixes.
• From this release it is necessary to run the software using JRE 1.8.

v1.24.0

date: 2018-07-18

• CSTN class allows the DC checking without using unknown literals (that are necessary for the completeness): it just a tool for studying the necessity of unknown literals.
• Literal and Label class are now immutable.
• Minor code optimization.

v1.23.2

date: 2018-02-21

• Class CSTNU cleaned and optimized. From this release, its DC checking algorithm is sound-and-complete.
• Contingent link can have label even if it is not required for sound-and-completeness.
• Class CSTNPSU.java added.
• Sub-package ‘attic’ removed. (last svn revision 243).
• SVN version: 245.

v1.22.4

date: 2018-01-10

• Code cleaning

v1.22.3

date: 2017-12-14

• Class CSTNU optimized.
• Class CSTNURunningTime removed.
• Class CSTNRunningTime was renamed Checker.

v1.22.2

date: 2017-11-24

• Code optimization

v1.22.1

date: 2017-11-22

• The following classes have been renamed re-ordering inside terms:

1. CSTNEpsilon.java
2. CSTNEpsilon3R.java
3. CSTNEpsilon3RwoNodeLabels.java
4. CSTNEpsilonwoNodeLabels.java
5. CSTNIR.java
6. CSTNIR3R.java
7. CSTNIR3RwoNodeLabels.java
8. CSTNIRwoNodeLabels.java

v1.22.0

date: 2017-11-21

• Introduced new classes and renamed old ones. There are 13 classes for checking CSTN/CSTNU:

1. it.univr.di.algorithms.CSTN.java
2. it.univr.di.algorithms.CSTN2CSTN0.java
3. it.univr.di.algorithms.CSTN3RIR.java: as IR CSTN but DC checking uses only three rules.
4. it.univr.di.algorithms.CSTN3RwoNodeLabelEpsilon.java
5. it.univr.di.algorithms.CSTN3RwoNodeLabelIR.java
6. it.univr.di.algorithms.CSTNEpsilon.java
7. it.univr.di.algorithms.CSTNIR.java
8. it.univr.di.algorithms.CSTNU.java
9. it.univr.di.algorithms.CSTNU2CSTN.java
10. it.univr.di.algorithms.CSTNU2UppaalTiga.java
11. it.univr.di.algorithms.CSTNwoNodeLabel.java
12. it.univr.di.algorithms.CSTNwoNodeLabelEpsilon.java
13. it.univr.di.algorithms.CSTNwoNodeLabelIR.java

• Replaced Ω node with equivalent constraints in all CSTN classes.
• Removed Ω node from LabeledIntGraph and relative reader/writer.
• Improved CSTN Layout for laying out also nodes without explicit temporal relation with Z.
• Started classes re-factoring exploiting Java 8 new features.
• CSTNRunningTime and CSTNURunningTime made multi-thread.

v1.21.0

date: 2017-11-09

• Class CSTNUGraphMLReader is able to read CSTN files that do not contain meta information about UC and LC values.
• CSTNirRestricted renamed CSTNir3R.
• CSTNwoNodeLabel cleaned.
• Added classes CSTNirwoNodeLabel and CSTNir3RwoNodeLabel.
• Simplified CSTNRunningTime.

v1.20.0

date: 2017-11-03

• Jung-library has been upgraded to 2.1.1 version.
• Such update required an adaptation of all GUI classes of the package.
• CSTNU DC checking algorithm is now sound-and-complete.
• CSTNEditor allows now to view a graph in a bigger window and to save it as PDF or other graphical format. The export menu is accessible clicking the mouse inside the window containing the graph to export.
• There are now 6 classes for checking CSTN/CSTNU:

1. it.univr.di.algorithms.CSTN: it checks a CSTN instance assuming the standard semantics.
2. it.univr.di.algorithms.CSTNepsilon: it checks a CSTN instance assuming a not-zero reaction time (epsilon).
3. it.univr.di.algorithms.CSTNir: it checks a CSTN instance assuming instantaneous reactions.
4. it.univr.di.algorithms.CSTNirRestricted: as it.univr.di.algorithms.CSTNir but the used rules are 3 instead of 6. Such checking can be faster than it.univr.di.algorithms.CSTNir one.
5. it.univr.di.algorithms.CSTNU: it checks a CSTNU instance assuming instantaneous reactions.
6. it.univr.di.algorithms.CSTNwoNodeLabel: it checks a CSTN instance assuming the standard semantics. The instance is translated into an equivalent CSTN instance without node labels and, then, checked.

• GraphMLReader has been rewritten because based on Jung GraphMLReader2 that is not able to manage big attribute data.
• GraphMLReader has been renamed CSTNUGraphMLReader.
• GraphMLWriter has been renamed CSTNUGraphMLWriter.

v1.10.0

date: 2017-06-22

• Package reorganization.
• CSTNEditor cleaned and optimized.

v1.9.0

date: 2016-03-31

• Labels are represented in a more compact way.
• Labeled value sets requires less memory. It is still possible to choose which kind of representation to use for labeled value sets.

v1.8.0

date: 2016-02-24

• Graphs are represented by a new optimized class.

v1.7.9

date: 2015-11-26

• Added the new feature to CSTN DC-checking. Now DC-checking algorithm considers a user specified ‘reaction time’ ε (ε > 0) of the system during the checking of a network. A reaction time ε means that an engine that executes a CSTN reacts in at least ε time units to a setting of a truth-value to a proposition.

v1.7.8

date: 2015-10-28

• A new sanity check about the correctness of an input CSTNU added: each contingent time point has to have one incoming edge of type ‘contingent’ and one outgoing edge of type ‘contingent’ from/to the same node, representing the activation time point.

v1.7.7

date: 2015-10-22

• Fixed another issue with instantaneous reaction in CSTNU. Thanks to Dian Liu for his help in discovering such error.
• I repeat that, even in this release, it is better to set any timepoint—that depends on an observation timepoint or follows a contingent timepoint—to
• a not 0 distance from the considered observation timepoint or contingent one.

v1.7.6

date: 2015-09-30

• Fixed a subtle bug in the generation of new edges. Thanks to Dian Liu for his help in discovering such error.

v1.7.5

date: 2015-09-23

• Cleaned some log messages.
• We have discovered that instantaneous reaction feature requires a sharp adjustment in semantics of the network.
• We are currently working in the introduction of an ε-reaction (with ε ≥ 0) feature.
• In the meantime, for CSTN it is possible to DC check assuming instantaneous reaction (ε = 0)
• while for CSTNU it is only possible to DC check assuming non-instantaneous reaction (ε > 0).
• For now, it is better to set any timepoint—that depends on an observation timepoint or follows a contingent timepoint—to a not 0 distance from the
• considered observation timepoint or contingent one.

v1.7.4

date: 2015-09-13

• In this release, a more strict check of contingent links has been introduced. Bounds of a contingent link A==[x,y]==>B must observe the property 0<x<y<∞. Moreover, since for CSTNU instances it is not yet defined the concept of ' instantaneous reactions', it is not possible to define a CSTNU instance in which there exists a constraint like C–[0,0]–>B where B is contingent. This constraint requires that C has to be executed in at the same time of the contingent time point B, but this is not possible because B is decided by the environment and the runtime engine has to observe it before to execute standard node like C.

v1.7.3

date: 2015-09-10

• This release contains some minor bug fixes and a revision of public methods of class it.univr.di.cstnu.algorithms.CSTNU.
• Now, it is possible to check the controllability of a CSTN instance instantiating a CSTNU object and calling its dynamicControllabilityCheck(LabeledIntGraph) method.
• It is sufficient to create a LabeledIntGraph object representing a given CSTNU instance (in LabeledIntGraph class there is also a method for loading an instance from a file written in GraphML format), instantiate a CSTNU object and call its method dynamicControllabilityCheck(LabeledIntGraph) passing the created graph. Moreover, I add the class it.univr.di.cstnu.algorithms.CSTNURunningTime and the script CSTNURunningTime for checking a bundle of CSTNU instances obtaining also some execution time statistics.

v1.7.2

date: 2015-06-24

• This release contains some minor bug fixes and a README file explaining the proposed examples of CSTNU/CSTN instances.
• Thanks to Huan Wang for his comments.

v1.7.1

date: 2015-05-28

• This release contains a faster Dynamic Consistency check for CSTNs.
• The java class CSTN.java has been completely rewritten and almost optimised for a faster check.

v1.7.0

date: 2015-03-23

• This release is the first public release.