v6.0

date: 2024-10-20

The update of the library fastutil to version 8.5.14 revealed a subtle weakness of all classes in the subpackage it.univr.di.labeledvalue and, as a consequence, in the subpackage it.univr.di.cstnu.graph. Therefore, it was necessary to adjust some methods in the classes of it.univr.di.labeledvalue and to reconsider the opportunity of some methods in interface it.univr.di.graph.CSTNEdge and all its derived interfaces.

While the modifications in it.univr.di.labeledvalue are conservative, the ones made in it.univr.di.cstnu.graph are not. In particular, from this version, it.univr.di.graph.CSTNEdge and its derived interfaces do not allow direct access to maps containing the labeled values of an edge and offer only one method, getLabeledValues(), to have a directed view of all the entries of the map. Such a method must be used only to scan all the entries in a fast and read-only mode because the validity of the returned set is guaranteed if and only if the corresponding map is not modified during the scan. Moreover, if any of the entries of the returned set is modified directly, the validity of the set of labeled values is not guaranteed.

All possible maps (labeled values, upper-case labeled values, lower-case labeled values, etc.) must be modified using the methods for adding/merging/removing labeled values present in the it.univr.di.graph.CSTNEdge and its derived interfaces.

If one needs to scan all labeled values of an edge to remove/modify some of them in a fast way, a safe way is:

1. retrieve the set of all the labels of the labeled values using the method getLabelsOfLabeledValues(),
2. scan such a set of labels
   1. retrieve each labeled value using the method getValue(Label label)
   2. modify/remove the labeled value using one of the methods mergeLabeledValue(Label l, int i), putLabeledValue(Label l, int i), or removeLabeledValue(Label l)

The same approach is valid for upper-case/lower-case labeled values using the corresponding methods.

v5.0

date: 2024-10-07

The dependency on the MatLab library present in version 4.13 was too strong. So, I decided to split the project into two projects. Such division affects only the use of the class PSTN.

• CSTNU Tool (this project). It is the core project and, limited to the class PSTN, it contains its definition and relative algorithms that cannot be used directly because the object instantiation requires an external actor class that implements the it.univr.di.cstnu.util.OptimizationEngine

• functional interface to be executed. CSTNU Tool project does not contain any implementation of the OptimizationEngine because I haven't found a full-fledged open-source implementation of a non-linear optimization problem solver.

• MatLabPlugin4CSTNUTool. It offers an implementation of the it.univr.di.cstnu.util.OptimizationEngine functional interface using the MatLab software. This plugin joined with the CSTNU Tool, allows one to create and use PSTN objects. Refer to the MatLabPlugin4CSTNUTool website to discover how to compile and use this plugin within this project.

Added the following classes:

• OptimizationEngine: a functional interface that represents a method for solving a non-linear optimization problem. Class PSTN depends on this interface. A possible implementation of this interface is offered in the project MatLabPlugin4CSTNUTool.

• LogNormalDistribution: represents log-normal distribution parameters. It was a subclass of PSTN.

Added 3 test files: notDC002.stnu, notDC020.stnu, and notDC033.stnu.

Removed the following classes:

• MatLabEngine: moved to MatLabPlugin4CSTNUTool
• PSTNTest: moved to MatLabPlugin4CSTNUTool
• PSTNBenchmarkRunner: moved to MatLabPlugin4CSTNUTool

Updated the following classes:

• STNUEdge, STNUEdgeInt: Method updateValue(int) cannot stay in interface STNUEdge, otherwise in class STNUEdgeInt the method is overridden by the method updateValue(int) of the superclass STNEdgeInt. Therefore, updateValue(int) was moved into STNUEdgeInt.

• STNURTE: parameters --env and --rted now accept values of StrategyEnum.

• LabeledNode, TNGraphMLReader, PSTN: the dependency on the class PSTN.LogNormalDistribution is now updated to class LogNormalDistribution.

• PSTN: the class's constructors require an object of type OptimizationEngine.

v4.13

date: 2024-07-09

Added the following classes:

• PSTN: Probabilistic Simple Temporal Network. A specialized version of STNU where each contingent link duration can be described by a log-normal probability distribution Since the networks are represented as distance graphs, the edges associated with a contingent link of a PSTN are still represented as upper-case and lower-case edges. This representation is also useful because the DC checking/execution of a PSTN is done considering its correlated STNU. Hence, the log-normal distribution parameters are stored in the contingent node as field PSTN.LogNormalDistributionParameter logNormalDistributionParameter. Determining an approximating (correlated) STNU of a PSTN requires solving a non-linear optimization problem. In this release, such a problem is solved using MatLab's fmincon function. Therefore, if it is required to use the PSTN class, executing the library offering access to a MatLab-licensed engine is necessary. The core MatLab engine must be extended with the modules “Optimization Toolbox” and “Statistics and Machine Learning Toolbox” (thanks to Kim van den Houten and Léon Planken for clarification). For macOS systems, where usually the MatLab is installed in /Applications/MATLAB_R2024a.app/, it is sufficient to add -Djava.library.path=/Applications/MATLAB_R2024a.app/bin/maca64 to the java command.

Updated the following classes:

• LabeledNode: added a field to represent log-normal parameters for contingent duration in contingent links of a PSTN. Such a field is significant and considered only on contingent nodes of a PSTN. See the description of PSTN.
• ALabel: added method getALetter()
• ExtendedPriorityQueue: added method getFirstPriority()
• STN: made serializable.
• STNU: added the method applySRNCycleFinder() that can be called CheckAlgorithm.SRNCycleFinder during the DC checking phase. This method returns detailed info of the possible semi-negative cycle found during a check. Such info is inside the object STNUCheckStatus returned by dynamicControllabilityCheck(CheckAlgorithm. SRNCycleFinder).
• STNURTE: added the possibility of specifying an execution strategy as a parameter. Some standard execution strategies are given in the enum STNURTE.StrategyEnum. Thanks to Kim van den Houten and Léon Planken for the first implementation of such an idea.
• TNGraph, TNGraphReader, and TNGraphWriter expanded to manage PSTN.

v4.12

date: 2024-03-08

Added the following classes:

• OSTNU: class representing 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 implementations 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 implementing a Real-Time Execution algorithm for STNUs.
• TimeInterval: utility class represents a time interval where the lower bound is guaranteed to be ≤ upper bound.
• ActiveWaits: utility class to represent an active wait.

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 running the TNEditor because of missing system libraries. I recommend using 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 instances, the dispatchable version is determined using the makeFastDispatchMinimization method.

v4.9

date: 2023-07-20

• Class AbstractCSTN: the 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). I added the 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 (Flexible Temporal Network with Uncertainty): it is an alternative name for the class CSTNPSU.
• Cleaned the code of many classes.

v4.7

date: 2022-11-01

I added the new class PCSTNU (Parameterized CSTNU) to represent CSTNU with parameter timepoints.

• 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: A new field was added to identify parameter timepoints.
• 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: A useless annotation was removed.

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 the requirement of an exact number of edges (that can require removing edges).
• Class STNU: Changed the name of the fast dispatch algorithm.
• Class Checker: Made the long parameter specifications prefixed by --.
• Class STNURandomGenerator: Improved the documentation of the README.txt generated to describe a benchmark.

v4.5

date: 2022-03-30

• Class Checker: Two statistic indexes are added when STNU is checked.
• Class PriorityQueue: An open hash now realizes the map of entries for 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 also be used by the STNU class. I fixed a bug in the getStrongComponents method.
• Class STNU: Added fastSTNUdispatchability method. Changed the name of method RUL2020 to RUL2021. Fixed some bugs about other methods. Improved the efficiency of some methods.
• Classes Component and AbstractComponent: removed the 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 an 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 an object of the internal class ContingentCasePair.
• Class TNGraph: Changed internal maps representation. Added two caches for speed-up getInEdgesAndNodes and getOutEdgesAndNodes methods. The removing observer instruction in the removeEdge method is removed for performance reasons. Now, when an edge is removed from a graph, all its observing graphs are removed. It is not the correct behavior, but removing only the correct graph requires too much time for the library method. In a future release, such an issue will be fixed. The copy constructor of a graph clones the internal labelAlphabet such that labelAlphabet are not more shared by different graphs.
• Class CSTNPSU: fixed a bug in the initAndCheck method that didn't allow the specification of a guarded link with a 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: A check was added to guarantee that an activation node is associated with only one contingent node.
• New class TNPredecessorGraph: Class for representing predecessor TNGraph very compactly.

v4.4

date: 2022-01-03

• Improved the parser of labeled value map/set.
• Class AbstractCSTN. Improved checkAndInit: all negative edges going to an 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 the makeDispatchable() method: it didn't remove all dominated edges if their opposites were absent. 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: A new constructor was added.
• Class LabeledNode: started its re-factoring. Next releases will specialize such a class to optimize 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 inconsistent.
• Class NodePriorityHeap: renamed as PriorityQueue and made generic.
• Class LabeledNode: removed rendering code.
• Class NodeRendering: new class to customize the rendering of LabeledNode in TNEditor.
• Class TNEditor: GUI cleaned a little bit.
• Removed the dependency on the FreeHep library because FreeHep does not work with JRE > 8.
• Removed ‘normal’ and ‘constraint’ types 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 the STN class: now it checks a given network.
• Fixed an initialization error of the graphic driver in TNEditor and improved the 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 is still compatible with JVM 8.
• Improved Javadoc for almost all the classes/methods.
• Fixed all spotbugs bugs/errors at medium-level and max effort.

v3.6

date: 2021-06-20

• Fixed a weird bug in the CSTNPotential class: the dynamicCheck() method worked right, but, in the end, the edges in the checked graph were wrongly saved in a reversed way.
• Refactored classes GraphMLReader and GraphMLWriter to make 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 the Dijkstra method in the STN class.
• Class NodePriorityHeap refactored.

v3.4

date: 2021-06-03

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

v3.3

date: 2021-05-23

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

v3.2

date: 2021-01-14

• Fixed a coding error when saving a network into a file. From this release, the file encoding is UTF8, independent of the execution platform.
• Fixed an initialization error in the 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 previous algorithms.
• Removed the possibility of checking 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 the 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. To change to this default class, I modified the field DEFAULT_LABELEDINTMAP_CLASS of LabeledIntMapSupplier and recompiled 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 correctly.

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 six rules for managing -∞ values stored as potential values in nodes.
• Added CSTNSPFA class that implements the DC checking algorithm as a single-sink BellmanFord one. Therefore, only node potential values are generated. This class uses only three rules.

v1.26.vassar

date: 2019-10-21

• Rewritten many classes to represent edges and graphs for STN networks efficiently.
• 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 true, the DC checking method also propagates contingent links as ordinary constraints. This allows one to see some ordinary values more accurately.

v1.25.0

date: 2018-11-22

• Minor code optimization and minor bug fixes.
• From this release, the software must be run using JRE 1.8.

v1.24.0

date: 2018-07-18

• CSTN class allows the DC checking without using unknown literals (necessary for completeness): it is just a tool for studying the necessity of unknown literals.
• Literal and Label classes 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 a 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 nodes without explicit temporal relation with Z.
• Started classes re-factoring and exploiting Java 8's new features.
• CSTNRunningTime and CSTNURunningTime made multi-thread.

v1.21.0

date: 2017-11-09

• Class CSTNUGraphMLReader can 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 an update required an adaptation of all GUI classes of the package.
• CSTNU DC checking algorithm is now sound-and-complete.
• CSTNEditor now allows you to view a graph in a bigger window and save it as a PDF or other graphical format. The export menu is accessible by clicking the mouse inside the window containing the graph to export.
• There are now six 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 three instead of 6. Such checking can be faster than the 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 cannot 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 require less memory. Choosing which representation to use for labeled value sets is still possible.

v1.8.0

date: 2016-02-24

• A new optimized class represents graphs.

v1.7.9

date: 2015-11-26

• Added the new feature to CSTN DC-checking. Now, the 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 an 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 an error.

v1.7.5

date: 2015-09-23

• Cleaned some log messages.
• We have discovered that the instantaneous reaction feature requires a sharp adjustment in the network semantics.
• We are currently working on introducing 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 check DC 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 be executed simultaneously as the contingent time point B, but this is impossible because the environment decides B, and the runtime engine must observe it before executing a 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 by 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), instantiating a CSTNU object and calling 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 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 optimized for a faster check.

v1.7.0

date: 2015-03-23

• This release is the first public release.