Serialized Form

Package it.univr.di.cstnu.algorithms

Class it.univr.di.cstnu.algorithms.AbstractCSTN.CSTNCheckStatus

class CSTNCheckStatus extends STN.STNCheckStatus implements Serializable

Serialized Fields

labeledValuePropagationCalls

int labeledValuePropagationCalls

Counters #applications of label propagation rule

potentialUpdate

int potentialUpdate

Counters #applications of potential update

r0calls

int r0calls

Counters #applications of r0 rule

r3calls

int r3calls

Counters #applications of r3 rule

Class it.univr.di.cstnu.algorithms.CSTNU.CSTNUCheckStatus

class CSTNUCheckStatus extends AbstractCSTN.CSTNCheckStatus implements Serializable

Serialized Fields

crossCaseRuleCalls

int crossCaseRuleCalls

Counters about the # of application of different rules.

letterRemovalRuleCalls

int letterRemovalRuleCalls

Counters about the # of application of different rules.

lowerCaseRuleCalls

int lowerCaseRuleCalls

Counters about the # of application of different rules.

zExclamationRuleCalls

int zExclamationRuleCalls

Counters about the # of application of different rules.

Class it.univr.di.cstnu.algorithms.OSTNU.OSTNUCheckStatus

class OSTNUCheckStatus extends AbstractCSTN.CSTNCheckStatus implements Serializable

Serialized Fields

crossCaseRuleCalls

int crossCaseRuleCalls

Counters about the # of application of different rules.

firstProposition

char firstProposition

First free proposition

letterRemovalRuleCalls

int letterRemovalRuleCalls

Counters about the # of application of different rules.

lowerCaseRuleCalls

int lowerCaseRuleCalls

Counters about the # of application of different rules.

negativeScenarios

LabeledIntMap negativeScenarios

Scenario containing negative cycle. I use LabeledIntTreeMap for maintaining the set minimal w.r.t. the length of label but without the simplification on (¬a, 0)(a,1)-->(empty,0)(a,1).
Don't access to this map directly, but use methods OSTNU.OSTNUCheckStatus.addNegativeScenario(Label), OSTNU.OSTNUCheckStatus.getNegativeScenarios(), OSTNU.OSTNUCheckStatus.isInNegativeScenarios(Label).

oracleRuleCalls

int oracleRuleCalls

Counters about the # of application of different rules.

propositionOfPair

it.unimi.dsi.fastutil.objects.Object2ObjectMap<LabeledNode,it.unimi.dsi.fastutil.objects.Object2CharMap<LabeledNode>> propositionOfPair

Map (Ctg,Node)-->proposition

upperCaseRuleCalls

int upperCaseRuleCalls

Counters about the # of application of different rules.

Class it.univr.di.cstnu.algorithms.PSTN.PSTNCheckStatus

class PSTNCheckStatus extends STN.STNCheckStatus implements Serializable

serialVersionUID:

1L

Serialized Fields

exitFlag

int exitFlag

xit flag of the minimization procedure.

probabilityMass

double probabilityMass

the conjuncted probability mass obtained setting the contingent bounds in PSTN.PSTNCheckStatus.approximatingSTNU.

srn

it.unimi.dsi.fastutil.objects.ObjectImmutableList<STNUEdge> srn

Possible semi-reducible negative cycle;

srncKind

STNU.STNUCheckStatus.SRNCKind srncKind

Kind of SRNC

Class it.univr.di.cstnu.algorithms.STN.STNCheckStatus

class STNCheckStatus extends Object implements Serializable

serialVersionUID:

2L

Serialized Fields

consistency

boolean consistency

Consistency status (it is assumed true at the initialization).

cycles

int cycles

Counters about the # of application of different rules.

executionTimeNS

long executionTimeNS

Execution time in nanoseconds.

finished

boolean finished

Becomes true if no rule can be applied anymore.

initialized

boolean initialized

Becomes true when all data structures have been initialized.

negativeCycle

it.unimi.dsi.fastutil.objects.ObjectList<LabeledNode> negativeCycle

The list of LabeledNode representing a negative loop has been found (if the network is not consistent and the algorithm can build it).

negativeLoopNode

LabeledNode negativeLoopNode

The node with a negative loop in case that the graph is not consistent and the algorithm can determine only the node with negative loop.

note

String note

A possible note

partialExecutionTimeNS

long partialExecutionTimeNS

Another counter for storing an execution time of a part of the process. In nanoseconds.

propagationCalls

int propagationCalls

Number of propagations

stdDevExecutionTimeNS

long stdDevExecutionTimeNS

Standard Deviation of execution time if this last one is a mean. In nanoseconds.

stdDevPartialExecutionTimeNS

long stdDevPartialExecutionTimeNS

timeout

boolean timeout

Becomes true if check has been interrupted because a given time-out has occurred.

Class it.univr.di.cstnu.algorithms.STNU.STNUCheckStatus

class STNUCheckStatus extends STN.STNCheckStatus implements Serializable

serialVersionUID:

1L

Serialized Fields

checkAlgorithm

STNU.CheckAlgorithm checkAlgorithm

Which algorithm was used to check the network last time.

maxMinConstraint

int maxMinConstraint

maxMin constraint added;

negativeSTNUCycle

it.univr.di.cstnu.algorithms.STNU.STNUPath negativeSTNUCycle

Negative STNU cycle. This field may represent a simple negative cycle made of ordinary constraints or a semi-reducible negative cycle, i.e., a negative cycle also containing lower-case or upper-case edges.

srncKind

STNU.STNUCheckStatus.SRNCKind srncKind

Kind of SRNC

Exception Class it.univr.di.cstnu.algorithms.WellDefinitionException

class WellDefinitionException extends Exception implements Serializable

serialVersionUID:

2L

Serialized Fields

type

WellDefinitionException.Type type

Type of exception.

Package it.univr.di.cstnu.graph

Class it.univr.di.cstnu.graph.AbstractComponent

class AbstractComponent extends Object implements Serializable

serialVersionUID:

2L

Serialized Fields

inNegativeCycle

boolean inNegativeCycle

Both for nodes and edges, some algorithms can set this variable true if the component is in a negative cycle.

name

String name

Possible name

pcs

PropertyChangeSupport pcs

Since Java 9, Observable is no more supported. I decided to replace Observable using java.bean. PropertyChangeSupport allows to register listener indexed by a key (string) that represents the property. Then, when a property is changed, it is sufficient to call pcs.firePropertyChange("theProperty", old, val); A listener l of a property X must be registered as addObserver("X",l) A listener must be implement PropertyChangeListener.

Class it.univr.di.cstnu.graph.AbstractEdge

class AbstractEdge extends AbstractComponent implements Serializable

serialVersionUID:

1L

Serialized Fields

constraintType

Edge.ConstraintType constraintType

The type of the edge.

Class it.univr.di.cstnu.graph.AbstractNode

class AbstractNode extends AbstractComponent implements Serializable

serialVersionUID:

1L

Class it.univr.di.cstnu.graph.BasicCSTNUEdgePluggable

class BasicCSTNUEdgePluggable extends CSTNEdgePluggable implements Serializable

serialVersionUID:

3L

Serialized Fields

consideredUpperCaseValue

it.unimi.dsi.fastutil.objects.Object2IntMap<it.unimi.dsi.fastutil.objects.Object2ObjectMap.Entry<Label,ALabel>> consideredUpperCaseValue

The CSTNU controllability check algorithm needs to know if a labeled value has been already considered in the past in order to avoid to add it a second time.

upperCaseValue

LabeledALabelIntTreeMap upperCaseValue

Morris Upper case value augmented by a propositional label.
The name of node has to be equal to the original name. No case modifications are necessary!

Class it.univr.di.cstnu.graph.CSTNEdgePluggable

class CSTNEdgePluggable extends AbstractEdge implements Serializable

serialVersionUID:

6L

Serialized Fields

consideredLabeledValue

it.unimi.dsi.fastutil.objects.Object2IntMap<Label> consideredLabeledValue

Maintains log of labeled values that have been already inserted and, therefore, cannot be reinserted. This is used for speed-up the label management.

labeledValue

LabeledIntMap labeledValue

Labeled value.

labeledValueMapImpl

Class<? extends LabeledIntMap> labeledValueMapImpl

Labeled value class used in the class.

Class it.univr.di.cstnu.graph.CSTNPSUEdgePluggable

class CSTNPSUEdgePluggable extends BasicCSTNUEdgePluggable implements Serializable

serialVersionUID:

1L

Serialized Fields

consideredLowerCaseValue

it.unimi.dsi.fastutil.objects.Object2IntMap<it.unimi.dsi.fastutil.objects.Object2ObjectMap.Entry<Label,ALabel>> consideredLowerCaseValue

The CSTNU controllability check algorithm needs to know if a labeled value has been already considered in the past in order to avoid to add it a second time.

lowerCaseValues

LabeledALabelIntTreeMap lowerCaseValues

Morris Lower case value augmented by a propositional label.
The name of node has to be equal to the original name. No case modifications are necessary!

Class it.univr.di.cstnu.graph.CSTNUEdgePluggable

class CSTNUEdgePluggable extends BasicCSTNUEdgePluggable implements Serializable

serialVersionUID:

3L

Serialized Fields

lowerCaseValue

LabeledLowerCaseValue lowerCaseValue

Morris Lower case value augmented by a propositional label.

The name of node has to be equal to the original name. No case modifications are necessary!

Class it.univr.di.cstnu.graph.LabeledNode

class LabeledNode extends AbstractNode implements Serializable

serialVersionUID:

4L

Serialized Fields

after

LabeledNode after

Node in the double-link list used in subtreeDisassembly.

aLabel

ALabel aLabel

ALabel associated to this node. This field has the scope to speed up the DC checking since it represents the name of a contingent time point as ALabel instead of calculating it every time. Used in CSTNU.

before

LabeledNode before

Node in the double-link list used in subtreeDisassembly.

isContingent

boolean isContingent

Flag for contingent node. Used in STNU/CSTNU.

isParameter

boolean isParameter

Flag for parameter node. Used in PCSTNU.

label

Label label

Label associated to this node. Used in CSTNU/CSTN.

labeledPotential

LabeledALabelIntTreeMap labeledPotential

Labeled potential values. This map can also represent Upper-case labeled potentials. Used in HP20 and derived algorithms.

labeledPotentialCount

it.unimi.dsi.fastutil.objects.Object2IntMap<Label> labeledPotentialCount

Labeled potential count. This map counts how many values have been set for each label during a computation of any algorithm working with potential. Usually, in APSP or SSSP algorithms, when a value has been updated more than #nodes time, then there is a negative cycle.

labeledUpperPotential

LabeledALabelIntTreeMap labeledUpperPotential

Labeled upper potential values. This map can also represent Upper-case labeled potentials. Used in HP20 and derived algorithms.

logNormalDistributionParameter

LogNormalDistributionParameter logNormalDistributionParameter

LogNormalDistributionParameter used to represent the probability function of the duration of a contingent link. Since a probabilistic STN is approximated by a STNU, we prefer to maintain the representation of the network using the STNUEdges and to represent the location and std.dev of the probability distribution as a record in the contingent node.

potential

int potential

Potential value. Used in STN.

predecessor

LabeledNode predecessor

Predecessor of parent node. It is used for delimiting the subtree to disassemble. A node X_i is the predecessor of node X_j, i.e., X_i=p(X_j), if the distance or potential d(X_j) has been updated to d(x_i) + delta_{ij}

propositionObserved

char propositionObserved

Possible proposition observed. Used in CSTNU/CSTN.

status

LabeledNode.Status status

Status used by algorithm SSSP_BFCT.

x

double x

Position Coordinates. It must be double even if it is not necessary for Jung library compatibility.

y

double y

Position Coordinates. It must be double even if it is not necessary for Jung library compatibility.

Class it.univr.di.cstnu.graph.OSTNUEdgePluggable

class OSTNUEdgePluggable extends CSTNUEdgePluggable implements Serializable

serialVersionUID:

1L

Class it.univr.di.cstnu.graph.STNEdgeInt

class STNEdgeInt extends AbstractEdge implements Serializable

serialVersionUID:

2L

Serialized Fields

value

int value

the value associated to the edge

Class it.univr.di.cstnu.graph.STNUEdge.CaseLabel

class CaseLabel extends it.unimi.dsi.fastutil.objects.ObjectBooleanImmutablePair<ALabelAlphabet.ALetter> implements Serializable

serialVersionUID:

1L

Class it.univr.di.cstnu.graph.STNUEdgeInt

class STNUEdgeInt extends STNEdgeInt implements Serializable

serialVersionUID:

4L

Serialized Fields

caseLabel

STNUEdge.CaseLabel caseLabel

The upper/lower case label.
The first component is the node label, the second specifies the nature: true for upper-case, false for lower-case.

labeledValue

int labeledValue

The labeled value associated to the edge when it is a contingent link or a wait constraint. Its value is Constants.INT_NULL when this edge is an ordinary one.

Class it.univr.di.cstnu.graph.TNGraph

class TNGraph extends edu.uci.ics.jung.graph.AbstractTypedGraph<LabeledNode,E extends Edge> implements Serializable

serialVersionUID:

1L

Serialized Fields

adjacency

E extends Edge[][] adjacency

The graph is represented by its adjacency matrix.

aLabelAlphabet

ALabelAlphabet aLabelAlphabet

Alphabet for A-Label

childrenOfObserver

Map<LabeledNode,Label> childrenOfObserver

Children of observation nodes

edge2index

it.unimi.dsi.fastutil.objects.Object2ObjectMap<String,TNGraph<E extends Edge>.it.univr.di.cstnu.graph.TNGraph.EdgeIndex> edge2index

Map (edge-->adjacency position)

edgeFactory

EdgeSupplier<E extends Edge> edgeFactory

Edge factory

index2node

it.unimi.dsi.fastutil.ints.Int2ObjectMap<LabeledNode> index2node

Map (adjacency row-->node)

inEdgesCache

Map<LabeledNode,it.unimi.dsi.fastutil.objects.ObjectList<it.unimi.dsi.fastutil.objects.ObjectObjectImmutablePair<E extends Edge,LabeledNode>>> inEdgesCache

Map (node) --> list of its (in-going edge, sourceNode). It works as cache.

inputFile

File inputFile

A possible input file containing this graph.

lowerCaseEdges

it.unimi.dsi.fastutil.objects.ObjectList<BasicCSTNUEdge> lowerCaseEdges

List of edges with lower case label set not empty

name

String name

Name

nodeFactory

LabeledNodeSupplier nodeFactory

Node factory

nodeName2index

it.unimi.dsi.fastutil.objects.Object2IntMap<String> nodeName2index

Map (node-->adjacency row)

observer2Z

it.unimi.dsi.fastutil.objects.ObjectList<E extends Edge> observer2Z

List of edges from observers to Z

order

int order

Current number of nodes;

outEdgesCache

Map<LabeledNode,it.unimi.dsi.fastutil.objects.ObjectList<it.unimi.dsi.fastutil.objects.ObjectObjectImmutablePair<E extends Edge,LabeledNode>>> outEdgesCache

Map (node) --> list of its (out-going edge, destinationNode). It works as cache.

proposition2Observer

it.unimi.dsi.fastutil.chars.Char2ObjectMap<LabeledNode> proposition2Observer

Map of (proposition-->Observer node).

type

TNGraph.NetworkType type

Type of network

Z

LabeledNode Z

Zero node. In temporal constraint network such node is the first node to execute.

Class it.univr.di.cstnu.graph.TNGraph.UnmodifiableTNGraph

class UnmodifiableTNGraph extends TNGraph<K extends Edge> implements Serializable

serialVersionUID:

2L

Package it.univr.di.cstnu.util

Class it.univr.di.cstnu.util.LogNormalDistributionParameter

class LogNormalDistributionParameter extends Object implements Serializable

Serialized Fields

location

double location

Considering the associated normal distribution, this is the mean μ of the normal distribution.

logNormalDistribution

org.apache.commons.math3.distribution.LogNormalDistribution logNormalDistribution

The pdf

scale

double scale

Considering the associated normal distribution, this is the std.dev. σ of the normal distribution.

shift

int shift

It is possible that the activation time point is shifted by a rigid distance. In such a case, the log-normal distribution of the contingent link is the same, but the sample values must be simply added to the shift to have a right value. It would be possible to adjust the location and scale of the log-normal distribution to incorporate such a shift, but we verified that such an adjustment introduce some approximation errors.

Class it.univr.di.cstnu.util.ObjectArrayFIFOSetQueue

class ObjectArrayFIFOSetQueue extends Object implements Serializable

serialVersionUID:

1L

Serialization Methods

readObject

private void readObject(ObjectInputStream s)
                 throws ClassNotFoundException,
IOException

Parameters:

s - input stream

Throws:

ClassNotFoundException - none

IOException - none

writeObject

private void writeObject(ObjectOutputStream s)
                  throws IOException

Parameters:

s - out stream

Throws:

IOException - none

Serialized Fields

backingArray

K[] backingArray

The backing array.

Class it.univr.di.cstnu.util.ObjectPair

class ObjectPair extends Object implements Serializable

serialVersionUID:

2L

Serialized Fields

first

T first

second

T second

Package it.univr.di.cstnu.visualization

Class it.univr.di.cstnu.visualization.TNEditor

class TNEditor extends JFrame implements Serializable

serialVersionUID:

3L

Serialized Fields

checkedGraph

TNGraph<? extends Edge> checkedGraph

TNGraph structures necessary to represent derived graph.

checkingAlgCSTNComboBox

JComboBox<AbstractCSTN.CheckAlgorithm> checkingAlgCSTNComboBox

Drop-down list for selecting CSTN CheckingAlgorithm

cleanResult

boolean cleanResult

Cleaned result. True to store a cleaned result

contingentAlsoAsOrdinary

boolean contingentAlsoAsOrdinary

True if contingent link as to be represented also as ordinary constraints.

controlSouthPanel

JPanel controlSouthPanel

cstn

CSTN cstn

CSTN checker

cstnCheckAlg

AbstractCSTN.CheckAlgorithm cstnCheckAlg

Which check alg for CSTN

cstnDCSemanticsComboBox

JComboBox<AbstractCSTN.DCSemantics> cstnDCSemanticsComboBox

semantic combo for CSTN

cstnpsu

CSTNPSU cstnpsu

CSTNPSU checker

cstnStatus

AbstractCSTN.CSTNCheckStatus cstnStatus

CSTN check status

cstnu

CSTNU cstnu

CSTNU checker

cstnu2cstn

CSTNU2CSTN cstnu2cstn

CSTNU2CSTN checker

cstnuStatus

CSTNU.CSTNUCheckStatus cstnuStatus

CSTNU check status

currentEdgeImpl

Class<? extends Edge> currentEdgeImpl

Current edge implementation class

currentTNGraphType

TNGraph.NetworkType currentTNGraphType

The kind of network the system is currently showing

cycle

int cycle

Number of cycles of CSTN(U) check step-by-step

dcCurrentSem

AbstractCSTN.DCSemantics dcCurrentSem

The current wanted semantics

defaultDir

String defaultDir

Default load/save directory

derivedGraphBiggerViewer

JButton derivedGraphBiggerViewer

Button for derived network bigger viewer

edgesToCheck

AbstractCSTN.EdgesToCheck<? extends Edge> edgesToCheck

Edges to check in CSTN(U) check step-by-step

epsilonPanel

JPanel epsilonPanel

The epsilon panel

extraButtons

boolean extraButtons

Some buttons have meaning only for some contexts. The default is not to show.

graphInfoLabel

JLabel graphInfoLabel

The graph info label

inputGraph

TNGraph<? extends Edge> inputGraph

TNGraph structures necessary to represent input graph.

inputGraphBiggerViewer

JButton inputGraphBiggerViewer

Button for input network bigger viewer

layoutEditor

edu.uci.ics.jung.algorithms.layout.AbstractLayout<LabeledNode,? extends Edge> layoutEditor

Layout for input graph.

layoutToggleButton

JToggleButton layoutToggleButton

Button for re-layout input graph

layoutViewer

edu.uci.ics.jung.algorithms.layout.AbstractLayout<LabeledNode,? extends Edge> layoutViewer

Layout for derived graph.

mapInfoLabel

JLabel mapInfoLabel

modeBoxIndex

int modeBoxIndex

Position of the mode box for the main editor

modeBoxViewerIndex

int modeBoxViewerIndex

Position of the mode box for the viewer

oneStepBackGraph

TNGraph<? extends Edge> oneStepBackGraph

TNGraph structures necessary to represent an auxiliary graph.

onlyToZ

boolean onlyToZ

OnlyToZ says if the DC checking has to be made propagating constraints only to time-point Z

onlyToZCB

JCheckBox onlyToZCB

ostnu

OSTNU ostnu

OSTNU checker

ostnuStatus

OSTNU.OSTNUCheckStatus ostnuStatus

OSTNU check status

pcstnu

PCSTNU pcstnu

PCSTNU checker

preferredSize

Dimension preferredSize

the preferred sizes for the two views

reactionTime

int reactionTime

Reaction time for CSTN

rowForAppButtons

JPanel rowForAppButtons

rowForOSTNUButtons

JPanel rowForOSTNUButtons

rowForSTNButtons

JPanel rowForSTNButtons

rowForSTNUButtons

JPanel rowForSTNUButtons

saveTNResultButton

JButton saveTNResultButton

Result Save Button

stn

STN stn

STN checker

stnCheckAlg

STN.CheckAlgorithm stnCheckAlg

Which check alg to use for STN

stnStatus

STN.STNCheckStatus stnStatus

STN check status

stnu

STNU stnu

STNU checker

stnuCheckAlg

STNU.CheckAlgorithm stnuCheckAlg

Which check alg to use for STNU

stnuCheckAlgComboSelect

JComboBox<STNU.CheckAlgorithm> stnuCheckAlgComboSelect

Swing combo select for the stnuCheckAlg.

stnuStatus

STNU.STNUCheckStatus stnuStatus

STNU check status

validationPanelCSTN

org.netbeans.validation.api.ui.swing.ValidationPanel validationPanelCSTN

Validation panel for CSTN row

validationPanelCSTNPSU

org.netbeans.validation.api.ui.swing.ValidationPanel validationPanelCSTNPSU

Validation panel for CSTNPSU row

validationPanelCSTNU

org.netbeans.validation.api.ui.swing.ValidationPanel validationPanelCSTNU

Validation panel for CSTNU row

viewerMessageArea

JEditorPane viewerMessageArea

Message area above the derived (no input) graph.

vvEditor

edu.uci.ics.jung.visualization.VisualizationViewer<LabeledNode,? extends Edge> vvEditor

The BasicVisualizationServer<V,E> for input graph.

vvViewer

edu.uci.ics.jung.visualization.VisualizationViewer<LabeledNode,? extends Edge> vvViewer

The BasicVisualizationServer<V,E> for derived graph.

Package it.univr.di.labeledvalue

Class it.univr.di.labeledvalue.AbstractLabeledIntMap

class AbstractLabeledIntMap extends Object implements Serializable

serialVersionUID:

1L

Serialized Fields

count

int count

The number of elements in the map

optimize

boolean optimize

Optimize In same applications it is important to maintain ¬C,0 and C,1. The optimization would reduce them to ⊡,0 and C,1. So, set false optimized to maintain ¬C,0 and C,1. Default is true.

Class it.univr.di.labeledvalue.ALabel

class ALabel extends Object implements Serializable

serialVersionUID:

1L

Serialized Fields

alphabet

ALabelAlphabet alphabet

Alphabet to map the name into A-letter

bit0

long bit0

One long has 64 bits.
Each position is associated to a A-Letter.

 Status of i-th A-Letter
              bit0[i]
 not present          0
 present              1
 

cacheOfSize

byte cacheOfSize

Number of A-letters in the label Value -1 means that the size has to be calculated!

maxIndex

byte maxIndex

Index of the last significant A-Letter of label. On 2016-03-30 I showed by SizeofUtilTest.java that using byte it is possible to define also 'size' field without incrementing the memory footprint of the object.

Class it.univr.di.labeledvalue.ALabel.EmptyLabel

class EmptyLabel extends ALabel implements Serializable

serialVersionUID:

1L

Class it.univr.di.labeledvalue.ALabelAlphabet

class ALabelAlphabet extends Object implements Serializable

serialVersionUID:

1L

Serialized Fields

size

byte size

The number of valid entries in ALabelAlphabet.value.

value

ALabelAlphabet.ALetter[] value

The a-letters of this alphabet.
Such array does not contain holes.

value2int

it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap<ALabelAlphabet.ALetter> value2int

In order to speed up the #index method, a map int2Aletter is maintained.

Class it.univr.di.labeledvalue.ALabelAlphabet.ALetter

class ALetter extends Object implements Serializable

serialVersionUID:

1L

Serialized Fields

name

String name

Class it.univr.di.labeledvalue.Constants

class Constants extends Object implements Serializable

serialVersionUID:

2L

Class it.univr.di.labeledvalue.Label

class Label extends Object implements Serializable

serialVersionUID:

1L

Serialized Fields

bit0

int bit0

Using two ints, it is possible to represent 4 states for each position.
Each position is associated to a proposition.

 Status of i-th literal
              bit1[i] bit0[i]
 not present          0   0
 straight             0   1
 negated              1   0
 unknown              1   1
 

bit1

int bit1

Using two ints, it is possible to represent 4 states for each position.
Each position is associated to a proposition.

 Status of i-th literal
              bit1[i] bit0[i]
 not present          0   0
 straight             0   1
 negated              1   0
 unknown              1   1
 

count

byte count

Number of literals in the label Value -1 means that the size has to be calculated!

maxIndex

byte maxIndex

Index of the highest-order ("leftmost") literal of label w.r.t. lexicographical order. On 2016-03-30 I showed by SizeofUtilTest.java that using byte it is possible to define also 'size' field without incrementing the memory footprint of the object.

Class it.univr.di.labeledvalue.LabeledALabelIntTreeMap

class LabeledALabelIntTreeMap extends Object implements Serializable

serialVersionUID:

3L

Serialized Fields

count

int count

Number of elements

labeledValueMapImpl

Class<? extends LabeledIntMap> labeledValueMapImpl

Labeled value class used in the class.

map

it.unimi.dsi.fastutil.objects.Object2ObjectRBTreeMap<ALabel,LabeledIntMap> map

Data structure.

1. A Upper/Lower Case value is a pair (nodeName, value) where nodeName is a name of a node and can be written either in all UPPER case or in all lower case. Such kind of constraint has been introduced by Morris Muscettola 2005.
2. A labeled Upper/Lower Case value is a pair (nodeName, (proposition_label, value)), where proposition_label represents scenario where value holds. Such kind of constraint has been introduced by Hunsberger, Combi, and Posenato in 2012.
3. Each proposition_label is a conjunction of literals, i.e., of type Label.
4. Since there may be more pairs with the same 'nodeName', a labeled Upper/Lower Case value is as a map of (nodeName, LabeledIntMap).
   See LabeledIntMap.
5. In 2017-10, nodeName has been substituted by Alabel. ALabel represent the name of a node or a conjunction of node names.
   Such modification has been introduced because CSTNU DC checking algorithm requires such kind of values.

Class it.univr.di.labeledvalue.LabeledALabelIntTreeMap.LabeledALabelIntTreeMapView

class LabeledALabelIntTreeMapView extends LabeledALabelIntTreeMap implements Serializable

serialVersionUID:

1L

Class it.univr.di.labeledvalue.LabeledIntHierarchyMap

class LabeledIntHierarchyMap extends AbstractLabeledIntMap implements Serializable

serialVersionUID:

3L

Serialized Fields

putHistory

String putHistory

Just for debugging

root

LabeledIntHierarchyMap.HierarchyNode root

Root of hierarchy Design choice: the set of labeled values of this map is organized as a double linked hierarchy of labeled values. A labeled value (label, value) is father of another labeled value (label1, value1) if label1 subsumes label and value1 < value.

wellFormatCheck

boolean wellFormatCheck

Just to force the control that, after each put, the format of hierarchy is still valid. Don't set true in a production program!

Class it.univr.di.labeledvalue.LabeledIntHierarchyMap.LabeledIntHierarchyMapView

class LabeledIntHierarchyMapView extends LabeledIntHierarchyMap implements Serializable

serialVersionUID:

1L

Class it.univr.di.labeledvalue.LabeledIntSimpleMap

class LabeledIntSimpleMap extends AbstractLabeledIntMap implements Serializable

serialVersionUID:

2L

Serialized Fields

mainMap

it.unimi.dsi.fastutil.objects.Object2IntMap<Label> mainMap

Deprecated.

Map of label

updateCount

it.unimi.dsi.fastutil.objects.Object2IntMap<Label> updateCount

Deprecated.

Counter of labeled value updates.

Class it.univr.di.labeledvalue.LabeledIntSimpleMap.LabeledIntNotMinMapView

class LabeledIntNotMinMapView extends LabeledIntSimpleMap implements Serializable

serialVersionUID:

1L

Class it.univr.di.labeledvalue.LabeledIntTreeMap

class LabeledIntTreeMap extends AbstractLabeledIntMap implements Serializable

serialVersionUID:

2L

Serialized Fields

base

char[] base

Set of propositions forming a base for the labels of the map.

mainInt2SetMap

it.unimi.dsi.fastutil.ints.Int2ObjectArrayMap<it.unimi.dsi.fastutil.objects.Object2IntMap<Label>> mainInt2SetMap

Design choice: the set of labeled values of this map is organized as a collection of sets each containing labels of the same length. This allows the label minimization task to be performed in a more systematic and efficient way. The efficiency has been proved comparing this implementation with one in which the map has been realized with a standard map and the minimization task determines the same length labels every time it needs it.

Class it.univr.di.labeledvalue.LabeledIntTreeMap.LabeledIntTreeMapView

class LabeledIntTreeMapView extends LabeledIntTreeMap implements Serializable

serialVersionUID:

1L

Class it.univr.di.labeledvalue.LabeledIntTreeSimpleMap

class LabeledIntTreeSimpleMap extends LabeledIntTreeMap implements Serializable

Class it.univr.di.labeledvalue.LabeledLowerCaseValue

class LabeledLowerCaseValue extends Object implements Serializable

serialVersionUID:

1L

Serialized Fields

hashCode

int hashCode

cached hash code

label

Label label

nodeName

ALabel nodeName

Even if this field could be just a ALetter, it is an ALabel because the comparison between ALabels is faster than ALetter and ALabel.

value

int value