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 the 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
          Counts the # of applications of different rules.
        • letterRemovalRuleCalls
          int letterRemovalRuleCalls
          Counts the # of applications of different rules.
        • lowerCaseRuleCalls
          int lowerCaseRuleCalls
          Counts the # of applications of different rules.
        • zExclamationRuleCalls
          int zExclamationRuleCalls
          Counts the # of applications of different rules.
    • Class it.univr.di.cstnu.algorithms.OSTNU.OSTNUCheckStatus

      class OSTNUCheckStatus extends AbstractCSTN.CSTNCheckStatus implements Serializable
      • Serialized Fields

        • crossCaseRuleCalls
          int crossCaseRuleCalls
          Counts the # of applications of different rules.
        • firstProposition
          char firstProposition
          First free proposition
        • letterRemovalRuleCalls
          int letterRemovalRuleCalls
          Counts the # of applications of different rules.
        • lowerCaseRuleCalls
          int lowerCaseRuleCalls
          Counts the # of applications of different rules.
        • negativeScenarios
          LabeledIntMap negativeScenarios
          Scenario containing a negative cycle.
          I use LabeledIntTreeMap for maintaining the set minimally with respect to the length of the label, but without the simplification on (¬a, 0)(a,1)-->(empty,0)(a,1).
          Don't access this map directly, but use methods OSTNU.OSTNUCheckStatus.addNegativeScenario(Label), OSTNU.OSTNUCheckStatus.getNegativeScenarios(), OSTNU.OSTNUCheckStatus.isInNegativeScenarios(Label).
        • oracleRuleCalls
          int oracleRuleCalls
          Counts the # of applications of different rules.
        • proposition2Pair
          it.unimi.dsi.fastutil.chars.Char2ObjectMap<ObjectPair<LabeledNode>> proposition2Pair
          Map (proposition)-->(ctg,node)
        • propositionOfPair
          it.unimi.dsi.fastutil.objects.Object2ObjectMap<LabeledNode,it.unimi.dsi.fastutil.objects.Object2CharMap<LabeledNode>> propositionOfPair
          Map (Ctg, Node)-->proposition
        • upperCaseRuleCalls
          int upperCaseRuleCalls
          Counts the # of applications 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 by 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
          Counts the # of applications 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, the algorithm can build it).
        • negativeLoopNode
          LabeledNode negativeLoopNode
          The node with a negative loop when the graph is not consistent, and the algorithm can determine only the node with a negative loop.
        • note
          String note
          A possible note
        • partialExecutionTimeNS
          long partialExecutionTimeNS
          Another counter for storing the 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 the 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
          The algorithm was used to check the network last time.
        • maxMinConstraint
          int maxMinConstraint
          maxMin constraint added;
        • negativeSTNUCycle
          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 contains 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
  • 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 to true if the component is in a negative cycle.
        • name
          String name
          Possible name
        • pcs
          PropertyChangeSupport pcs
          Since Java 9, Observable has no longer been supported. I decided to replace Observable using java.bean.PropertyChangeSupport allows the registration of listeners indexed by a key (string) that represents the property. Then, when a property is changed, it is enough 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
    • Class it.univr.di.cstnu.graph.AbstractNode

      class AbstractNode extends AbstractComponent implements Serializable
      serialVersionUID:
      2L
    • 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 already been considered in the past to avoid adding it a second time.
        • upperCaseValue
          LabeledALabelIntTreeMap upperCaseValue
          Morris Upper case value augmented by a propositional label.

          The name of the 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 the log of labeled values that have already been inserted and, therefore, cannot be reinserted. This is used to 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 already been considered in the past to avoid adding it a second time.
        • lowerCaseValues
          LabeledALabelIntTreeMap lowerCaseValues
          Morris Lower case value augmented by a propositional label.

          The name of the 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 the 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-linked list used in subtreeDisassembly.
        • aLabel
          ALabel aLabel
          ALabel associated with 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-linked list used in subtreeDisassembly.
        • isContingent
          boolean isContingent
          Flag for the contingent node. Used in STNU/CSTNU.
        • isParameter
          boolean isParameter
          Flag for parameter node. Used in PCSTNU.
        • label
          Label label
          Label associated with 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 is used to represent the probability function of the contingent-link duration. Since a probabilistic STN is approximated by an STNU, we prefer to maintain the representation of the network using the STNUEdges and to represent the location and standard deviation of the probability distribution as a record in the contingent node.
        • potential
          int potential
          Potential value. Used in STN.
        • predecessor
          LabeledNode predecessor
          Predecessor of the 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 with 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 with the edge when it is a contingent link or a wait constraint. Its value is Constants.INT_NULL when this edge is ordinary.
    • 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)` pairs. It works as a cache.
        • inputFile
          File inputFile
          A possible input file containing this graph.
        • lowerCaseEdges
          it.unimi.dsi.fastutil.objects.ObjectList<BasicCSTNUEdge> lowerCaseEdges
          List of edges with their 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 `(outgoing edge, destinationNode)` pairs. It works as a 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 a temporal constraint network, such a 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 standard deviation σ of the normal distribution.
        • shift
          int shift
          It is possible that a rigid distance shifts the activation time point. 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 the right value. It would be possible to adjust the location and scale of the log-normal distribution to incorporate such a shift. Still, we verified that such an adjustment introduces some approximation errors.
    • Class it.univr.di.cstnu.util.ObjectArrayFIFOSetQueue

      class ObjectArrayFIFOSetQueue extends Object implements Serializable
      serialVersionUID:
      1L
    • 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
          Necessary TNGraph structure to represent the derived graph.
        • checkingAlgCSTNComboBox
          JComboBox<AbstractCSTN.CheckAlgorithm> checkingAlgCSTNComboBox
          Drop-down list for selecting CSTN Checking Algorithm
        • cleanResult
          boolean cleanResult
          Cleaned result. True to store a cleaned result
        • contingentAlsoAsOrdinary
          boolean contingentAlsoAsOrdinary
          True if the contingent link is also to be represented as ordinary constraints.
        • controlSouthPanel
          JPanel controlSouthPanel
        • cstn
          CSTN cstn
          CSTN checker
        • cstnCheckAlg
          AbstractCSTN.CheckAlgorithm cstnCheckAlg
          Which check algorithm 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 a bigger derived-network 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 in some contexts. The default is not to show.
        • graphInfoLabel
          JLabel graphInfoLabel
          The graph info label
        • inputGraph
          TNGraph<? extends Edge> inputGraph
          Necessary TNGraph structure to represent the input graph.
        • inputGraphBiggerViewer
          JButton inputGraphBiggerViewer
          Button for a bigger input-network viewer
        • layoutEditor
          edu.uci.ics.jung.algorithms.layout.AbstractLayout<LabeledNode,? extends Edge> layoutEditor
          Layout for the 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
          Necessary TNGraph structure 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 algorithm to use for STN
        • stnStatus
          STN.STNCheckStatus stnStatus
          STN check status
        • stnu
          STNU stnu
          STNU checker
        • stnuCheckAlg
          STNU.CheckAlgorithm stnuCheckAlg
          Which check algorithm 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 some 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'. The 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 an ALetter
        • bit0
          long bit0
          One long has 64 bits.
          Each position is associated with an ALetter.
           Status of the i-th ALetter
                        bit0[i]
           not present          0
           present              1
           
        • cacheOfSize
          byte cacheOfSize
          The number of ALetters in the label Value -1 means that the size has to be calculated!
        • maxIndex
          byte maxIndex
          Index of the last significant ALetter of the label.

          On 2016-03-30, I showed by SizeofUtilTest.java that using byte, it is also possible to define the '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 ALetters of this alphabet.
          Such an array does not contain holes.
        • value2int
          it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap<ALabelAlphabet.ALetter> value2int
          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

    • 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 four states for each position.

          Each position is associated with a proposition.

           Status of the 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 four states for each position.

          Each position is associated with a proposition.

           Status of the i-th literal
                        bit1[i] bit0[i]
           not present          0   0
           straight             0   1
           negated              1   0
           unknown              1   1
           
        • count
          byte count
          The 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 the label with respect to lexicographical order.

          On 2016-03-30, I showed by SizeofUtilTest.java that using byte, it is also possible to define a '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. An Upper/Lower Case value is a pair (nodeName, value) where nodeName is the name of a node and can be written either in all UPPER case or in all lower case. Morris & Muscettola 2005 have introduced such a constraint.
          2. A labeled Upper/Lower Case value is a pair (nodeName, (proposition_label, value)), where proposition_label represents a scenario where the value holds. Such a constraint was 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 represented as a map of (nodeName, LabeledIntMap).
            See LabeledIntMap.
          5. In 2017-10, `nodeName` was substituted by ALabel. ALabel represents the name of a node or a conjunction of node names.
            Such a modification has been introduced because the CSTNU DC checking algorithm requires such 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 the 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
          A 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 more systematically and efficiently. The efficiency has been proved by 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 them.
    • 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 an ALetter, it is an ALabel because the comparison between ALabels is faster than ALetter and ALabel.
        • value
          int value