Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## pipe.modules.classification
Class Classification

    java.lang.Object
      pipe.modules.classification.Classification

All Implemented Interfaces:
  Module

Direct Known Subclasses:
  GSPN

    public class Classification

extends java.lang.Object
implements Module

Classification class implements petri net classification

Constructor Summary
`Classification()`

Method Summary
`protected boolean` | `extendedFreeChoiceNet(DataLayer pnmlData)` Extended free choice net detection
`protected boolean` | `extendedSimpleNet(DataLayer pnmlData)` Extended simple net (ESPL-net) detection
`protected boolean` | `freeChoiceNet(DataLayer pnmlData)` Free choice net detection
`java.lang.String` | `getName()`
`protected boolean` | `intersectionBetweenSets(int[] setOne, int[] setTwo)`
`protected boolean` | `markedGraph(DataLayer pnmlData)` Marked graph detection
`void` | `run(DataLayer pnmlData)`
`protected boolean` | `simpleNet(DataLayer pnmlData)` Simple net (SPL-net) detection
`protected boolean` | `stateMachine(DataLayer pnmlData)` State machine detection

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### Classification

    public Classification()

Method Detail

### run

    public void run(DataLayer pnmlData)

  Specified by:
    `run` in interface `Module`

### getName

    public java.lang.String getName()

  Specified by:
    `getName` in interface `Module`

### stateMachine

    protected boolean stateMachine(DataLayer pnmlData)

  State machine detection

  Returns:
    true iff all transitions have at most one input or output SM iff ∀ t ∈ T: |•t| = |t•| ≤ 1

         P - T - P
         P - T - P   true (one input/output each)

         P - T - P
               \     false (>1 output)
                 P

         P - T - P
           /         false (>1 input)
         P

### markedGraph

    protected boolean markedGraph(DataLayer pnmlData)

  Marked graph detection

  Returns:
    true iff all places have at most one input or output MG iff ∀ p ∈ P: |•p| = |t•| ≤ 1

         T - P - T
         T - P - T   true (one input/output each)

         T - P - T
               \     false (>1 output)
                 T

         T - P - T
           /         false (>1 input)
         T

### freeChoiceNet

    protected boolean freeChoiceNet(DataLayer pnmlData)

  Free choice net detection

  Returns:
    true iff no places' outputs go to the same transition, unless those places both have only one output FC-net iff ∀ p, p′ ∈ P: p ≠ p′ ⇒ (p•∩p′• = 0 or |p•| = |p′•| ≤ 1)

         P - T
         P - T       true (no common outputs)
           \
             T

         P - T
           /         true (common outputs but both have only one output)
         P

         P - T
           X
         P - T       false (common outputs, both have >1 output)

         P - T
           /
         P - T       false (common outputs but one has >1 output)

### extendedFreeChoiceNet

    protected boolean extendedFreeChoiceNet(DataLayer pnmlData)

  Extended free choice net detection

  Returns:
    true iff no places' outputs go to the same transition, unless both places outputs are identical EFC-net iff ∀ p, p′ ∈ P: p ≠ p′ ⇒ (p•∩p′• = 0 or p• = p′•)

         P - T
         P - T       Yes (no common outputs)
           \
             T

         P - T
           /
         P - T       No (common outputs, outputs not identical)

         P - T
           X
         P - T       Yes (common outputs identical) *** only addition to normal free choice net

         P - T       Yes (common outputs identical)
           /
         P

### simpleNet

    protected boolean simpleNet(DataLayer pnmlData)

  Simple net (SPL-net) detection

  Returns:
    true iff no places' outputs go to the same transition, unless one of the places only has one output SPL-net iff ∀ p, p′ ∈ P: p ≠ p′ ⇒ (p•∩p′• = 0 or |p•| ≤ 1 or |p′•| ≤ 1)

         P - T
         P - T       true (no common outputs)
           \
             T

         P - T
           /         true (common outputs, both only have one)
         P

         P - T
           /         true (common outputs, one place has only one)
         P - T

         P - T
           X         false (common outputs, neither has only one)
         P - T

         P - T
           \
             T       false (common outputs, neither has only one)
           /
         P - T

### extendedSimpleNet

    protected boolean extendedSimpleNet(DataLayer pnmlData)

  Extended simple net (ESPL-net) detection

  Returns:
    true iff no places' outputs go to the same transition, unless one of the places' outputs is a subset of or equal to the other's ESPL-net iff ∀ p, p′ ∈ P: p ≠ p′ ⇒ (p•∩p′• = 0 or p• ⊆ p′• or p′• ⊆ p•)

         P - T
         P - T       Yes (no common outputs)
           \
             T

         P - T
           /
         P - T       Yes (common outputs, first place's outputs is subset of second)

         P - T
           X
         P - T       Yes (common outputs, identical)

         P - T       Yes (common outputs, identical)
           /
         P

         P - T
           \
             T       false (common outputs, neither is subset of other)
           /
         P - T

             T
           /
         P - T       true (common outputs, second's is subset of first's)
           X
         P - T

### intersectionBetweenSets

    protected boolean intersectionBetweenSets(int[] setOne,
                                              int[] setTwo)

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD