faudes Namespace Reference


Detailed Description

libFAUDES resides within the namespace faudes.

Plugins may use the same namespace.


Classes

class  TaGenerator
 Model of the common five-tupel G := (X, Sigma, Delta, X_0, X_m). More...
class  GeneratorPool
 A Generator pool maintains a global generator context. More...
class  AttributeVoid
 Minimal Attribute. More...
class  AttributeFlags
 Boolean flags Attribute. More...
class  TBaseSet
 STL style set template. More...
class  AttributeCFlags
 Attribute class to model event controllability properties. More...
class  TcGenerator
 Generator with controllability attributes. More...
class  Exception
 Faudes exception class. More...
class  IndexSet
 Set of indices. More...
class  TaIndexSet
 Set of indices with attributes. More...
class  NameSet
 Set of indices with symbolic names. More...
class  TaNameSet
 Set of indices with symbolic names and attributes. More...
class  SymbolTable
 A SymbolTable associates sybolic names with indices. More...
class  Token
 Tokens model atomic data for stream IO. More...
class  TokenReader
 A TokenReader reads sequential tokens from a file or string. More...
class  TokenWriter
 A TokenWriter writes sequential tokens to a file, a string or stdout. More...
class  Transition
 Triple (X1,Ev,X2) to represent current state, event and next state. More...
class  TransSort
 Alternative ordering of Transitions. More...
class  TTransSet
 Set of Transitions. More...
class  TaTransSet
 Set of Transitions with attributes. More...
class  vGenerator
 Virtual version of a plain generator (ie no attributes). More...
class  Bisimulation
 This class implements the algorithms needed for the computation of the coarsest quasi-congruence (=Bisimulation) of a given generator. More...
struct  Partition
 This struct implements a coset (=equivalence class) as needed for the computation of the coarsest quasi-congruence on an automaton. More...

Typedefs

typedef TaGenerator< AttributeVoid,
AttributeVoid, AttributeVoid,
AttributeVoid
Generator
 Plain generator, typedef for generator with no attributes.
typedef unsigned long int fType
 Convenience typdef flag data.
typedef TcGenerator< AttributeVoid,
AttributeVoid, AttributeCFlags,
AttributeVoid
cGenerator
 Convenience typedef for std cGenerator.
typedef TaNameSet< AttributeCFlagscEventSet
 EventSet with controllablity properties.
typedef unsigned int Idx
 Type definition for index type.
typedef IndexSet StateSet
typedef NameSet EventSet
typedef TTransSet< TransSort::X1EvX2TransSet
 Type definition for default sorted TTransSet.
typedef TTransSet< TransSort::X1EvX2TransSetX1EvX2
 Type definition for default sorted TTransSet.
typedef TTransSet< TransSort::EvX1X2TransSetEvX1X2
 Type definition for ev, x1, x2 sorted TTransSet.
typedef TTransSet< TransSort::EvX2X1TransSetEvX2X1
 Type definition for ev, x2, x1 sorted TTransSet.
typedef TTransSet< TransSort::X2EvX1TransSetX2EvX1
 Type definition for x2, ev, x1 sorted TTransSet.
typedef TTransSet< TransSort::X2X1EvTransSetX2X1Ev
 Type definition for x2, x1, ev sorted TTransSet.
typedef TTransSet< TransSort::X1X2EvTransSetX1X2Ev
 Type definition for x1, x2, ev sorted TTransSet.

Functions

bool cIsControllable (const cGenerator &rPlantGen, const vGenerator &rSupCandGen)
 Controllability.
void cSupConNB (const cGenerator &rPlantGen, const vGenerator &rSpecGen, cGenerator &rResGen)
 Nonblocking Supremal Controllable Sublanguage.
void cSupCon (const cGenerator &rPlantGen, const vGenerator &rSpecGen, cGenerator &rResGen)
 Supremal Controllable Sublanguage.
void cParallel (const cGenerator &rGen1, const cGenerator &rGen2, cGenerator &rResGen)
 Parallel composition of accessible states of generators rGen1 and rGen2.
void cProject (const cGenerator &rGen, const EventSet &rProjectAlphabet, cGenerator &rResGen)
 Minimized (deterministic) projection.
std::string ToStringInteger (long int number)
 integer to string
std::string ToStringInteger16 (long int number)
 integer to string base 16
std::string ToStringFloat (double number)
 float to string
std::string ExpandString (const std::string &rString, unsigned int len)
 Fill string with spaces up to a given length if length of the string is smaller than given length parameter.
std::string CollapsString (const std::string &rString, unsigned int len=70)
 Limit length of string, return head and tail of string.
Idx ToIdx (const std::string &rString)
 Convert a string to Idx.
std::string FDVersionString ()
 Return FAUDES_VERSION as std::string.
std::string FDPluginsString ()
 Return FAUDES_PLUGINS as std::string.
std::string FDContributorsString ()
 Return contributors as std::string.
void ProcessDot (const std::string &rDotFile, const std::string &rOutFile, const std::string &rOutFormat="", const std::string &rDotExec="dot")
 convenience function: process dot file to graphics output.
std::string CreateTempFile (void)
 convenience function: create a temp file, length 0
bool RemoveFile (const std::string &rFileName)
 convenience function: delete file
StateSet LowExitStates (const vGenerator &rLowGen, const EventSet &rHighAlph, const std::map< Idx, StateSet > &rEntryStatesMap, const TransSetX2EvX1 &rLowRevTransRel, Idx highState)
 LowExitStates return-copy function:.
void LowExitStates (const EventSet &rHighAlph, const std::map< Idx, StateSet > &rEntryStatesMap, const TransSetX2EvX1 &rLowRevTransRel, Idx highState, StateSet &rLowExitStates)
 LowExitStates call-by-reference function:.
EventSet ReachableEvents (const vGenerator &rLowGen, const EventSet &rHighAlph, Idx lowState)
 ReachableEvents return-copy function:.
void ReachableEvents (const vGenerator &rLowGen, const EventSet &rHighAlph, Idx lowState, EventSet &rReachableEvents)
 ReachableEvents call-by-reference function:.
void LocalCoaccessibleReach (const TransSetX2EvX1 &rRevTransRel, const EventSet &rHighAlph, Idx lowState, StateSet &rCoaccessibleReach)
 Compute the coaccessible reach for a local automaton.
void LocalAccessibleReach (const vGenerator &rLowGen, const EventSet &rHighAlph, Idx lowState, StateSet &rAccessibleReach)
 Compute the accessible reach for a local automaton.
void Parallel (const vGenerator &rGen1, const vGenerator &rGen2, vGenerator &rResGen)
 Parallel composition.
void Parallel (const vGenerator &rGen1, const vGenerator &rGen2, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, vGenerator &rResGen)
 Parallel composition.
void SParallel (const vGenerator &rGen1, const vGenerator &rGen2, vGenerator &rResGen)
 Shared event parallel composition.
void SParallel (const vGenerator &rGen1, const vGenerator &rGen2, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, vGenerator &rResGen)
 Shared event parallel composition.
void SetComposedStateNames (const vGenerator &rGen1, const vGenerator &rGen2, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, vGenerator &rGen12)
 Helper: uses reverse composition map to track state names in a paralell composition.
void UniqueInit (vGenerator &rGen)
 Make initial states unique.
void Deterministic (const vGenerator &rGen, vGenerator &rResGen)
 Make generator deterministic.
void Deterministic (const vGenerator &rGen, std::map< Idx, StateSet > &rEntryStatesMap, vGenerator &rResGen)
 Make generator deterministic.
void Deterministic (const vGenerator &rGen, std::vector< StateSet > &rPowerStates, std::vector< Idx > &rDetStates, vGenerator &rResGen)
 Make generator deterministic.
void ProjectNonDet (vGenerator &rGen, const EventSet &rProjectAlphabet)
 Language projection.
void Project (const vGenerator &rGen, const EventSet &rProjectAlphabet, vGenerator &rResGen)
 Minimized deterministic projection.
void Project (const vGenerator &rGen, const EventSet &rProjectAlphabet, std::map< Idx, StateSet > &rEntryStatesMap, vGenerator &rResGen)
 Minimized Deterministic projection.
void InvProject (vGenerator &rGen, const EventSet &rProjectAlphabet)
 Inverse projection.
void CreateEntryStatesMap (const std::map< StateSet, Idx > &rRevEntryStatesMap, std::map< Idx, StateSet > &rEntryStatesMap)
void LanguageUnionNonDet (const vGenerator &rGen1, const vGenerator &rGen2, vGenerator &rResGen)
 Language union, nondeterministic version: This function performs the union of two languages marked by two generators; the resulting generator marks the resulting language.
void LanguageUnion (const vGenerator &rGen1, const vGenerator &rGen2, vGenerator &rResGen)
 Language union, deterministic version: This function performs the union of two languages marked by two generators; the resulting generator marks the resulting language.
void LanguageIntersection (const vGenerator &rGen1, const vGenerator &rGen2, vGenerator &rResGen)
 Language intersection: This function performs the intersection of two languages marked by two generators; the resulting generator marks the resulting language.
bool EmptyLanguageIntersection (const vGenerator &rGen1, const vGenerator &rGen2)
 Empty language intersection: This function checks if the intersection of two languages marked by two generators is empty that is the two languages are disjoint.
bool LanguageDisjoint (const vGenerator &rGen1, const vGenerator &rGen2)
 Disjoint: This function checks if the intersection of two languages marked by two generators is empty, ie the two languages are disjoint.
void Automaton (vGenerator &rGen, const EventSet &rAlphabet)
 Automaton wrt alphabet: Convert a generator marking the language Lm into a formal automaton recognizing Lm with a dump state representing Sigma*-PrefixClosure(Lm).
void Automaton (vGenerator &rGen)
 Automaton wrt generator alphabet: Convert a generator marking the language Lm into a formal automaton recognizing Lm with a dump state representing Sigma*-PrefixClosure(Lm).
void LanguageComplement (vGenerator &rGen, const EventSet &rAlphabet)
 Language complement wrt alphabet: Convert generator marking the language Lm into generator marking the language complement of Lm which is defined as Sigma*-Lm.
void LanguageComplement (vGenerator &rGen)
 Language complement wrt generator alphabet: Convert generator marking the language Lm into generator marking the language complement of Lm which is defined as Sigma*-Lm.
void LanguageConcatenateNonDet (const vGenerator &rGen1, const vGenerator &rGen2, vGenerator &rResGen)
 Language Concatenation, nondeterministic version: With the languages Lm1 and Lm2 marked by rGen1 and rGen2, respectively, the result rResGen marks the concatenation LmRes=Lm1Lm2.
void LanguageConcatenate (const vGenerator &rGen1, const vGenerator &rGen2, vGenerator &rResGen)
 Language Concatenation, deterministic version: With the languages Lm1 and Lm2 marked by rGen1 and rGen2, respectively, the result rResGen marks the concatenation LmRes=Lm1Lm2.
void FullLanguage (const EventSet &rAlphabet, vGenerator &rResGen)
 Full Language: Construct generator generating and marking full language Sigma* from alphabet Sigma.
void AlphabetLanguage (const EventSet &rAlphabet, vGenerator &rResGen)
 Alphabet Language: Construct generator generating and marking an alphabet as languages, that is L(G)=Lm(G)=Sigma.
void EmptyStringLanguage (const EventSet &rAlphabet, vGenerator &rResGen)
 Empty string language: Construct generator generating and marking the empty string, that is L(G)=Lm(G)={epsilon}.
void EmptyLanguage (const EventSet &rAlphabet, vGenerator &rResGen)
 Empty language: Construct generator generating and marking the empty language, that is L(G)=Lm(G)={}.
bool EmptyLanguage (const vGenerator &rGen)
 Empty language: Tests if the language marked by rGen is empty, that is if Lm(G)={}.
bool LanguageInclusion (const vGenerator &rGen1, const vGenerator &rGen2)
 Language inclusion: Test if language Lm1 marked by rGen1 is included in language Lm2 marked by rGen2.
bool LanguageEquality (const vGenerator &rGen1, const vGenerator &rGen2)
 Language equality: Test if the language Lm1 marked by rGen1 equals the language Lm2 marked by rGen2.
void KleeneClosure (vGenerator &rGen)
 Kleene Closure: This function computes the Kleene Closure ( ()* - operator) of the language marked by rGen.
void KleeneClosureNonDet (vGenerator &rGen)
 Kleene Closure, nondeterministic version: This function computes the Kleene Closure ( ()* - operator) of the language marked by rGen.
void PrefixClosure (vGenerator &rGen)
 Prefix Closure: This function computes the prefix closure the language Lm marked by rGen.
void SelfLoop (vGenerator &rGen, const EventSet &rAlphabet)
 SelfLoop: This function selfoops all states of rGen with the events from rAlphabet.
void SelfLoopMarkedStates (vGenerator &rGen, const EventSet &rAlphabet)
 SelfLoopMarkedStates: This function selfoops all marked states of rGen with the events from rAlphabet.
void SelfLoop (vGenerator &rGen, const EventSet &rAlphabet, const StateSet &rStates)
 SelfLoop: This function selfoops the states rStates of rGen with the events from rAlphabet.
void StateMin (vGenerator &rGen, vGenerator &rResGen)
 State set minimization.
void StateMin (vGenerator &rGen, vGenerator &rResGen, std::vector< StateSet > &rSubsets, std::vector< Idx > &rNewIndices)
 State set minimization.
bool IsControllableUnchecked (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen, StateSet &rCriticalStates)
 Controllability (internal function).
bool SupConUnchecked (const vGenerator &rPlantGen, const EventSet &rCAlph, vGenerator &rSupCandGen)
 Supremal Controllable Sublangauge (internal function).
void SupconParallel (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, vGenerator &rResGen)
 Parallel composition optimized for the purpose of SupCon (internal function).
void SupConNBUnchecked (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, vGenerator &rResGen)
 Nonblocking Supremal Controllable Sublanguage (internal function).
void ControlProblemConsistencyCheck (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen)
 Consistency check for controlproblem input data.
bool IsControllable (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSupCandGen)
 Test controllability.
bool IsControllable (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSupCandGen, StateSet &rCriticalStates)
 Test controllability.
void SupConNB (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen, vGenerator &rResGen)
 Nonblocking Supremal Controllable Sublanguage.
void SupConNBNonDet (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, Generator rDetPlantGen, Generator rDetSpecGen, std::map< Idx, StateSet > &rPowerStatesPlant, std::map< Idx, StateSet > &rPowerStatesSpec, bool &rDetPlantBool, bool &rDetSpecBool, vGenerator &rResGen)
 Nonblocking Supremal Controllable Sublanguage.
void SupCon (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen, vGenerator &rResGen)
 Supremal Controllable Sublanguage.
void SupCon (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, vGenerator &rResGen)
 Supremal Controllable Sublanguage.
void TraverseUncontrollableBackwards (const EventSet &rCAlph, TransSetX2EvX1 &rtransrel, StateSet &rCriticalStates, Idx current)
 Helper function for IsControllable.
void calcBisimulation (Generator &rGenOrig, map< Idx, Idx > &rMapStateToPartition, Generator &rGenPart, vector< Idx > &rNewPartitions)
 Computation of a bisimulation over a given generator.
void calcBisimulation (Generator &rGenOrig, map< Idx, Idx > &rMapStateToPartition, vector< Idx > &rNewPartitions)
 Computation of a bisimulation over a given generator.
bool MutualControllability (const cGenerator &rGen1, const cGenerator &rGen2)
 Verification of mutual controllability.
bool MutualControllability (const cGenerator &rGen1, const cGenerator &rGen2, StateSet &rForbidden1, StateSet &rForbidden2)
 Verification of mutual controllability.
void calcAbstAlphObs (cGenerator &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
 Lm-observer computation.
void calcAbstAlphObs (vGenerator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
 Lm-observer computation.
void calcAbstAlphObs (vGenerator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans)
 Lm-observer computation.
void calculateDynamicSystemObs (const vGenerator &rGen, EventSet &rHighAlph, vGenerator &rGenDyn)
 Computation of the dynamic system for an Lm-observer.
void calcAbstAlphObsOCC (cGenerator &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
 Lm-observer computation including output control consistency (OCC).
void calcAbstAlphObsOCC (vGenerator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans)
 Lm-observer computation including output control consistency (OCC).
void calculateDynamicSystemObsOCC (const vGenerator &rGen, EventSet &rControllableEvents, EventSet &rHighAlph, vGenerator &rGenDyn)
 Computation of the dynamic system for an Lm-observer that also fulfills output control consistency (OCC).
void forwardReachabilityObs (const vGenerator &rGen, const EventSet &rHighAlph, Idx lowState, Idx mLabel, vGenerator &rGenDyn)
 Forward reachability algorithm to determine locally reachable marked states.
void backwardReachabilityObsOCC (const TransSetX2EvX1 &rTransSetX2EvX1, const EventSet &rControllableEvents, const EventSet &rHighAlphabet, Idx exitState, Idx currentState, bool controllablePath, map< Idx, map< Idx, bool > > &rExitLocalStatesMap, StateSet &rDoneStates)
 Backward reachability algorithm for the dynamic system compuptation that fulfills the observer and output control consistency (OCC) condition.
void calcAbstAlphObsLCC (cGenerator &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
 Lm-observer computation including local control consistency (LCC).
void calcAbstAlphObsLCC (vGenerator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans)
 Lm-observer computation including local control consistency (LCC).
void calculateDynamicSystemObsLCC (const vGenerator &rGen, EventSet &rControllableEvents, EventSet &rHighAlph, vGenerator &rGenDyn)
 Computation of the dynamic system for an Lm-observer that also fulfills local control consistency (LCC).
void backwardReachabilityObsLCC (const TransSetX2EvX1 &rTransSetX2EvX1, const EventSet &rControllableEvents, const EventSet &rHighAlphabet, Idx exitState, Idx currentState, bool controllablePath, map< Idx, map< Idx, bool > > &rExitLocalStatesMap, StateSet &rDoneStates)
 Backward reachability algorithm for the dynamic system compuptation that fulfills the observer and local control consistency (LCC) condition.
bool relabel (vGenerator &rGenRelabel, EventSet &rControllableEvents, EventSet &rHighAlph, vector< Idx > &rNewPartitions, map< Idx, Idx > &rMapStateToPartition, map< Transition, Transition > &rMapChangedTransReverse, map< Transition, Idx > &rMapChangedTrans, map< Idx, EventSet > &rMapRelabeledEvents)
 Relabeling algorithm for the computation of an Lm-observer.
void insertRelabeledEvents (cGenerator &rGenPlant, const map< Idx, set< Idx > > &rMapRelabeledEvents, cEventSet &rNewEvents)
 Convenience function for relabeling events in a given generator.
void insertRelabeledEvents (cGenerator &rGenPlant, const map< Idx, set< Idx > > &rMapRelabeledEvents)
 Convenience function for relabeling events in a given generator.
bool IsObs (const Generator &rLowGen, const EventSet &rHighAlph)
 Verification of the observer property.
bool IsOCC (const cGenerator &rLowGen, const EventSet &rHighAlph)
 Verification of output control consistency (OCC).
bool IsOCC (const Generator &rLowGen, const EventSet &rControllableEvents, const EventSet &rHighAlph)
 Verification of output control consistency (OCC).
bool backwardVerificationOCC (const Generator &rLowGen, const EventSet &rControllableEvents, const EventSet &rHighAlph, Idx currentState)
 Function that supports the verification of output control consistency (OCC).
bool IsLCC (const cGenerator &rLowGen, const EventSet &rHighAlph)
 Verification of local control consistency (LCC).
bool IsLCC (const Generator &rLowGen, const EventSet &rControllableEvents, const EventSet &rHighAlph)
 Verification of local control consistency (LCC).
void backwardVerificationLCC (const TransSetX2EvX1 &rTransSetX2EvX1, const EventSet &rControllableEvents, const EventSet &rHighAlph, Idx exitState, Idx currentState, bool controllablePath, map< Idx, bool > &rLocalStatesMap, StateSet &rDoneStates)
 Function that supports the verification of local control consistency (LCC).


Typedef Documentation

typedef TaNameSet<AttributeCFlags> faudes::cEventSet
 

EventSet with controllablity properties.

Definition at line 639 of file cgenerator.h.

typedef TcGenerator<AttributeVoid, AttributeVoid, AttributeCFlags,AttributeVoid> faudes::cGenerator
 

Convenience typedef for std cGenerator.

Definition at line 636 of file cgenerator.h.

typedef unsigned long int faudes::fType
 

Convenience typdef flag data.

Definition at line 104 of file attributes.h.

typedef unsigned int faudes::Idx
 

Type definition for index type.

Definition at line 41 of file definitions.h.


Function Documentation

void faudes::backwardReachabilityObsLCC const TransSetX2EvX1 rTransSetX2EvX1,
const EventSet rControllableEvents,
const EventSet rHighAlphabet,
Idx  exitState,
Idx  currentState,
bool  controllablePath,
map< Idx, map< Idx, bool > > &  rExitLocalStatesMap,
StateSet rDoneStates
 

Backward reachability algorithm for the dynamic system compuptation that fulfills the observer and local control consistency (LCC) condition.

This recursive function is called by calculateDynamicSystemObsLCC(const vGenerator& rGen, EventSet& rControllableEvents, EventSet& rHighAlph, vGenerator& rGenDyn). It evaluates a backward local reachability procedure to support the computation of a dynamic system for computing a natural projection that is an Lm-observer and LCC.

There are no restrictions on parameters.

Parameters:
rTransSetX2EvX1 TransSet sorted by X2-Ev-X1
rControllableEvents Set of controllable events
rHighAlphabet Abstraction alphabet
exitState Index of the exit state under investigation
currentState Index of the current state under investigation
controllablePath Boolean value that is false if the current path is uncontrollable and true otherwise
rExitLocalStatesMap Map from the current exit state to its local predecessor states
rDoneStates States that have already been investigated

Definition at line 706 of file op_observercomputation.cpp.

void faudes::backwardReachabilityObsOCC const TransSetX2EvX1 rTransSetX2EvX1,
const EventSet rControllableEvents,
const EventSet rHighAlphabet,
Idx  exitState,
Idx  currentState,
bool  controllablePath,
map< Idx, map< Idx, bool > > &  rExitLocalStatesMap,
StateSet rDoneStates
 

Backward reachability algorithm for the dynamic system compuptation that fulfills the observer and output control consistency (OCC) condition.

This recursive function is called by calculateDynamicSystemObsOCC(const vGenerator& rGen, EventSet& rControllableEvents, EventSet& rHighAlph, vGenerator& rGenDyn). It evaluates a backward local reachability procedure to support the computation of a dynamic system for computing a natural projection that is an Lm-observer and OCC.

There are no restrictions on parameters.

Parameters:
rTransSetX2EvX1 TransSet sorted by X2-Ev-X1
rControllableEvents Set of controllable events
rHighAlphabet Abstraction alphabet
exitState Index of the exit state under investigation
currentState Index of the current state under investigation
controllablePath Boolean value that is false if the current path is uncontrollable and true otherwise
rExitLocalStatesMap Map from the current exit state to its local predecessor states
rDoneStates States that have already been investigated

Definition at line 488 of file op_observercomputation.cpp.

void faudes::backwardVerificationLCC const TransSetX2EvX1 rTransSetX2EvX1,
const EventSet rControllableEvents,
const EventSet rHighAlph,
Idx  exitState,
Idx  currentState,
bool  controllablePath,
map< Idx, bool > &  rLocalStatesMap,
StateSet rDoneStates
 

Function that supports the verification of local control consistency (LCC).

This function performs a recursive backward reachability to find if from a state where an uncontrollable high-level event is possible, another state is only reachable by local strings that contaion at least one controllable event. If this is the case, LCC is violated.

Parameters:
rTransSetX2EvX1 reverse transition relation of the input generator
rControllableEvents set of controllable events
rHighAlph High level alphabet
exitState start state for backward reachability
currentState current state for backward reachability
controllablePath false if at least one uncontrollable path to the currentState exists
rLocalStatesMap map for states and their controllability property
rDoneStates states that have already been visited

Definition at line 183 of file op_obserververification.cpp.

bool faudes::backwardVerificationOCC const Generator rLowGen,
const EventSet rControllableEvents,
const EventSet rHighAlph,
Idx  currentState
 

Function that supports the verification of output control consistency (OCC).

This function performs a backward reachability to find if an uncontrollable high-level event is preemted by an uncontrollable low-level event. If this is the case, OCC is violated.

Parameters:
rLowGen Input generator
rControllableEvents set of controllable events
rHighAlph High level alphabet
currentState start state for backward reachability
Returns:
true if no controllable low-level event has been found

Definition at line 97 of file op_obserververification.cpp.

void faudes::calcAbstAlphObs vGenerator rGenObs,
EventSet rControllableEvents,
EventSet rHighAlph,
EventSet rNewHighAlph,
map< Transition, Idx > &  rMapChangedTrans
 

Lm-observer computation.

This function is called by void calcAbstAlphObs(vGenerator& rGenObs, EventSet& rControllableEvents, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx, set<Idx> >& rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an Lm-observer for the language marked by the resulting generator. This function evaluates the observer algorithm as described in K. C. Wong and W. M. Wonham, "On the Computation of Observers in Discrete Event Systems," Discrete Event Dynamic Systems, vol. 14, no. 1, pp. 55-107, 2004.

The alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs. rGenObs must be a deterministic generator. There are no further restrictions on parameters.

Parameters:
rGenObs Low-level generator. It is modified by the algorithm by relabeling transitions and events
rControllableEvents Set of controllable events
rHighAlph Initial abstraction alphabet
rNewHighAlph Modified abstraction alphabet such that the abstraction is an Lm-observer
rMapChangedTrans Maps the original relabeled transitions to the new events

Definition at line 71 of file op_observercomputation.cpp.

void faudes::calcAbstAlphObs vGenerator rGenObs,
EventSet rControllableEvents,
EventSet rHighAlph,
EventSet rNewHighAlph,
map< Idx, set< Idx > > &  rMapRelabeledEvents
 

Lm-observer computation.

This function is called by calcAbstAlphObs(cGenerator& rGenObs, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx, set<Idx> >& rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an Lm-observer for the language marked by the resulting generator. This function evaluates the observer algorithm as described in K. C. Wong and W. M. Wonham, "On the Computation of Observers in Discrete Event Systems," Discrete Event Dynamic Systems, vol. 14, no. 1, pp. 55-107, 2004.

the alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs rGenObs must be a deterministic generator no further restrictions on parameters.

Parameters:
rGenObs Low-level generator. It is modified by the algorithm by relabeling transitions and events
rControllableEvents Set of controllable events
rHighAlph Initial abstraction alphabet
rNewHighAlph Modified abstraction alphabet such that the abstraction is an Lm-observer
rMapRelabeledEvents Maps the original events to sets of newly introduced events (accumulatoive, call clear before)

Definition at line 48 of file op_observercomputation.cpp.

void faudes::calcAbstAlphObsLCC vGenerator rGenObs,
EventSet rControllableEvents,
EventSet rHighAlph,
EventSet rNewHighAlph,
map< Transition, Idx > &  rMapChangedTrans
 

Lm-observer computation including local control consistency (LCC).

This function is called by calcAbstAlphObsLCC(cGenerator& rGenObs, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx,set<Idx > > & rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an Lm-observer for the language marked by the resulting generator and at the same time fulfills the local control consistency condition (LCC). This function evaluates the observer algorithm as described in K. C. Wong and W. M. Wonham, "On the Computation of Observers in Discrete Event Systems," Discrete Event Dynamic Systems, vol. 14, no. 1, pp. 55-107, 2004. with an extension to LCC as indicated in K. Schmidt and C. Breindl, "On Maximal Permissiveness of Hierarchical and Modular Supervisory Control Approaches for Discrete Event Systems," Workshop on Discrete Event Systems, 2008.

The alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs. rGenObs must be a deterministic generator. There are no further restrictions on parameters.

Parameters:
rGenObs Low-level generator. It is modified by the algorithm by relabeling transitions and events
rControllableEvents Set of controllable events
rHighAlph Initial abstraction alphabet
rNewHighAlph Modified abstraction alphabet such that the abstraction is an Lm-observer
rMapChangedTrans Maps the original relabeled transitions to the new events

Definition at line 554 of file op_observercomputation.cpp.

void faudes::calcAbstAlphObsOCC vGenerator rGenObs,
EventSet rControllableEvents,
EventSet rHighAlph,
EventSet rNewHighAlph,
map< Transition, Idx > &  rMapChangedTrans
 

Lm-observer computation including output control consistency (OCC).

This function is called by calcAbstAlphObsOCC(cGenerator& rGenObs, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx,set<Idx > > & rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an Lm-observer for the language marked by the resulting generator and at the same time fulfills the output control consistency condition (OCC). This function evaluates the observer algorithm as described in K. C. Wong and W. M. Wonham, "On the Computation of Observers in Discrete Event Systems," Discrete Event Dynamic Systems, vol. 14, no. 1, pp. 55-107, 2004. with an extension to OCC as indicated in K. Schmidt and C. Breindl, "On Maximal Permissiveness of Hierarchical and Modular Supervisory Control Approaches for Discrete Event Systems," Workshop on Discrete Event Systems, 2008.

The alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs. rGenObs must be a deterministic generator. There are no further restrictions on parameters.

Parameters:
rGenObs Low-level generator. It is modified by the algorithm by relabeling transitions and events
rControllableEvents Set of controllable events
rHighAlph Initial abstraction alphabet
rNewHighAlph Modified abstraction alphabet such that the abstraction is an Lm-observer
rMapChangedTrans Maps the original relabeled transitions to the new events

Definition at line 288 of file op_observercomputation.cpp.

void faudes::calculateDynamicSystemObs const vGenerator rGen,
EventSet rHighAlph,
vGenerator rGenDyn
 

Computation of the dynamic system for an Lm-observer.

This function computes the dynamic system that is needed for evaluating the observer algorithm.

The alphabet rHighAlph has to be a subset of the alphabet of rGen. rGen must be a deterministic generator. There are no further restrictions on parameters.

Parameters:
rGen Generator for which the dynamic system is computed
rHighAlph Abstraction alphabet
rGenDyn Generator representing the dynamic system

Definition at line 118 of file op_observercomputation.cpp.

void faudes::calculateDynamicSystemObsLCC const vGenerator rGen,
EventSet rControllableEvents,
EventSet rHighAlph,
vGenerator rGenDyn
 

Computation of the dynamic system for an Lm-observer that also fulfills local control consistency (LCC).

This function computes the dynamic system that is needed for evaluating the observer algorithm with the additional LCC condition.

The alphabet rHighAlph has to be a subset of the alphabet of rGen. rGen must be a deterministic generator. There are no further restrictions on parameters.

Parameters:
rGen Generator for which the dynamic system is computed
rControllableEvents Set of controllable events
rHighAlph Abstraction alphabet
rGenDyn Generator representing the dynamic system

Definition at line 601 of file op_observercomputation.cpp.

void faudes::calculateDynamicSystemObsOCC const vGenerator rGen,
EventSet rControllableEvents,
EventSet rHighAlph,
vGenerator rGenDyn
 

Computation of the dynamic system for an Lm-observer that also fulfills output control consistency (OCC).

This function computes the dynamic system that is needed for evaluating the observer algorithm with the additional OCC condition.

The alphabet rHighAlph has to be a subset of the alphabet of rGen. rGen must be a deterministic generator. There are no further restrictions on parameters.

Parameters:
rGen Generator for which the dynamic system is computed
rControllableEvents Set of controllable events
rHighAlph Abstraction alphabet
rGenDyn Generator representing the dynamic system

Definition at line 335 of file op_observercomputation.cpp.

bool faudes::cIsControllable const cGenerator rPlantGen,
const vGenerator &  rSupCandGen
 

Controllability.

Tests whether the candidate supervisor h is controllable w.r.t. the plant g; see IsControllable

Parameters:
rPlantGen Plant g generator
rSupCandGen Supervisor candidate h generator
Exceptions:
Exception Alphabets of generators don't match (id 500) Plant generator nondeterministic (id 501) Specification generator nondeterministic (id 503) Plant & Spec generator nondeterministic (id 504)
Returns:
true / false

Definition at line 29 of file cgenfunct.cpp.

std::string faudes::CollapsString const std::string &  rString,
unsigned int  len = 70
 

Limit length of string, return head and tail of string.

Parameters:
rString string
len Maximum number of charakters in string (approx)
Returns:
Collapsed string

Definition at line 77 of file helper.cpp.

void faudes::ControlProblemConsistencyCheck const vGenerator &  rPlantGen,
const EventSet rCAlph,
const vGenerator &  rSpecGen
 

Consistency check for controlproblem input data.

Tests whether alphabets match and generators are deterministic.

Parameters:
rPlantGen Plant generator
rCAlph Controllable events
rSpecGen Specification generator
Exceptions:
Exception 
  • lphabets of generators don't match (id 100)
  • plant generator nondeterministic (id 201)
  • specification generator nondeterministic (id 203)
  • plant and spec generator nondeterministic (id 204)

Definition at line 532 of file supcon.cpp.

void faudes::cParallel const cGenerator rGen1,
const cGenerator rGen2,
cGenerator rResGen
 

Parallel composition of accessible states of generators rGen1 and rGen2.

This version will set the resulting generators controllability attributes to represent the union of controllable events of the arguments. When FAUDES_CHECKD is defined, consistency of controllability flags in the argiments is tested.

Computes symbolic state names in rResGen, if symbolic state names are enabled in rGen1 and rGen2 and rResGen

Parameters:
rGen1 First generator
rGen2 Second generator
rResGen Reference to resulting parallel composition generator

Definition at line 93 of file cgenfunct.cpp.

void faudes::cProject const cGenerator rGen,
const EventSet rProjectAlphabet,
cGenerator rResGen
 

Minimized (deterministic) projection.

Calls projectnondet, determine and statemin. This version passes on controllability attributes from the argument.

Parameters:
rGen Reference to generator
rProjectAlphabet Projection alphabet
rResGen Reference to resulting deterministic generator

Definition at line 134 of file cgenfunct.cpp.

void faudes::CreateEntryStatesMap const std::map< StateSet, Idx > &  rRevEntryStatesMap,
std::map< Idx, StateSet > &  rEntryStatesMap
 

Definition at line 523 of file project.cpp.

std::string faudes::CreateTempFile void   ) 
 

convenience function: create a temp file, length 0

Returns:
name of temp file

Definition at line 172 of file helper.cpp.

void faudes::cSupCon const cGenerator rPlantGen,
const vGenerator &  rSpecGen,
cGenerator rResGen
 

Supremal Controllable Sublanguage.

Finds the "largest" sublanguage of h for that language of g is controllable with respect to h. Note that the language of h is not rtequired to be a a sublanguage of g, but both languages must share the same alphabet.

See "C.G CASSANDRAS AND S. LAFORTUNE. Introduction to Discrete Event Systems. Kluwer, 1999." for base algorithm.

This version creates a "reverse composition map" given as reference parameter.

Parameters:
rPlantGen Plant Generator
rSpecGen Specification Generator
rResGen Reference to resulting Generator, the minimal restrictive supervisor
Exceptions:
Exception Alphabets of generators don't match (id 100) plant nondeterministic (id 201) spec nondeterministic (id 203) plant and spec nondeterministic (id 204)

Definition at line 66 of file cgenfunct.cpp.

void faudes::cSupConNB const cGenerator rPlantGen,
const vGenerator &  rSpecGen,
cGenerator rResGen
 

Nonblocking Supremal Controllable Sublanguage.

Computes the supremal sublanguage of the specification h that is controllable w.r.t. the plant g. The result is given as a trim deterministic generator that may be used to supervise g in order to enforce h.

See "C.G CASSANDRAS AND S. LAFORTUNE. Introduction to Discrete Event Systems. Kluwer, 1999." for base algorithm.

This implementation does not require h to be a sublanguage of g. However, both generators must be deterministic and share the same alphabet. Controllable events are extracted from the plant parameter, and copied to the result.

Parameters:
rPlantGen Plant cGenerator
rSpecGen Specification Generator
rResGen Reference to resulting Generator, the minimal restrictive nonblocking supervisor
Exceptions:
Exception Alphabets of generators don't match (id 100) plant nondeterministic (id 201) spec nondeterministic (id 203) plant and spec nondeterministic (id 204)

Definition at line 39 of file cgenfunct.cpp.

void faudes::Deterministic const vGenerator &  rGen,
std::vector< StateSet > &  rPowerStates,
std::vector< Idx > &  rDetStates,
vGenerator &  rResGen
 

Make generator deterministic.

Constructs a deterministic generator while preserving the generated and marked languages. See Deterministic(const vGenerator&,vGenerator& rResGen) for the intended api. This version provides as second and third parameters the correspondence betwwen new states and the original state sets. in vectors

Parameters:
rGen Reference to generator
rPowerStates Vector that holds the power states
rDetStates Vector that holds the corresponding deterministic states
rResGen Reference to resulting deterministic generator

Definition at line 90 of file project.cpp.

void faudes::Deterministic const vGenerator &  rGen,
std::map< Idx, StateSet > &  rEntryStatesMap,
vGenerator &  rResGen
 

Make generator deterministic.

Constructs a deterministic generator while preserving the generated and marked languages. See Deterministic(const vGenerator&,vGenerator& rResGen) for the intended api. This version provides as a second parameter the resulting map from new states to their respective original state set. It is used as a so called "entry state map" for deterministic projected generators.

Parameters:
rGen Reference to generator
rEntryStatesMap Entry state map
rResGen Reference to resulting deterministic generator

Definition at line 72 of file project.cpp.

std::string faudes::ExpandString const std::string &  rString,
unsigned int  len
 

Fill string with spaces up to a given length if length of the string is smaller than given length parameter.

Parameters:
rString string
len Minimum number of charakters in string
Returns:
Expanded string

Definition at line 66 of file helper.cpp.

std::string faudes::FDContributorsString  ) 
 

Return contributors as std::string.

Returns:
std::string

Definition at line 109 of file helper.cpp.

std::string faudes::FDPluginsString  ) 
 

Return FAUDES_PLUGINS as std::string.

Returns:
std::string with FAUDES_VERSION

Definition at line 104 of file helper.cpp.

std::string faudes::FDVersionString  ) 
 

Return FAUDES_VERSION as std::string.

Returns:
std::string with FAUDES_VERSION

Definition at line 99 of file helper.cpp.

void faudes::forwardReachabilityObs const vGenerator rGen,
const EventSet rHighAlph,
Idx  lowState,
Idx  mLabel,
vGenerator rGenDyn
 

Forward reachability algorithm to determine locally reachable marked states.

This function is called by calculateDynamicSystemObsOCC(const vGenerator& rGen, EventSet& rControllableEvents, EventSet& rHighAlph, vGenerator& rGenDyn); It inserts transitions with a certain "mLabel" into the dynamic system by employing forward reachability.

There are no restrictions on parameters.

Parameters:
rGen Generator for which the dynamic system is computed
rHighAlph Abstraction alphabet
lowState Start state for forward reachability
mLabel Event label for transitions to marked states
rGenDyn Generator representing the dynamic system

Definition at line 441 of file op_observercomputation.cpp.

void faudes::insertRelabeledEvents cGenerator rGenPlant,
const map< Idx, set< Idx > > &  rMapRelabeledEvents
 

Convenience function for relabeling events in a given generator.

This function inserts new events and respective transitions given by a relableing map into a given generator. The function is used to adjust plant components to the rtelableing from another plant component.

There are no restrictions on parameters.

Parameters:
rGenPlant Plant component automaton
rMapRelabeledEvents maps the original events to sets of newly introduced events

Definition at line 1152 of file op_observercomputation.cpp.

void faudes::insertRelabeledEvents cGenerator rGenPlant,
const map< Idx, set< Idx > > &  rMapRelabeledEvents,
cEventSet rNewEvents
 

Convenience function for relabeling events in a given generator.

This function inserts new events and respective transitions given by a relableing map into a given generator. The function is used to adjust plant components to the rtelableing from another plant component.

There are no restrictions on parameters.

Parameters:
rGenPlant Plant component automaton
rMapRelabeledEvents Maps the original events to sets of newly introduced events
rNewEvents returns the newly inserted events (accumulative, call clear before)

Definition at line 1130 of file op_observercomputation.cpp.

void faudes::InvProject vGenerator &  rGen,
const EventSet rProjectAlphabet
 

Inverse projection.

This adds selfloop transition at every state for all missing events.

Parameters:
rGen Reference to generator
rProjectAlphabet Alphabet for inverse projection

Definition at line 500 of file project.cpp.

bool faudes::IsControllableUnchecked const vGenerator &  rPlantGen,
const EventSet rCAlph,
const vGenerator &  rSpecGen,
StateSet rCriticalStates
 

Controllability (internal function).

Checks if language of specification h is controllable with respect to language of generator g. Only for deterministic plant + spec.

Controllable event set has to be given as parameter. Returns the set of critical states as last parameter.

Parameters:
rPlantGen Plant generator
rCAlph Controllable events
rSpecGen Specification generator
rCriticalStates Set of critical states
Exceptions:
Exception 
  • alphabets of generators don't match (id 100)
  • plant generator nondeterministic (id 201)
  • specification generator nondeterministic (id 203)
  • plant & spec generator nondeterministic (id 204)
Returns:
true / false

Definition at line 42 of file supcon.cpp.

bool faudes::IsLCC const Generator rLowGen,
const EventSet rControllableEvents,
const EventSet rHighAlph
 

Verification of local control consistency (LCC).

For verifying if a natural projection fulfills the local control consistency condition, a backward reachability is conducted. If starting from a state, where an uncontrollable high-level event is feasible, at least one local state cannot be reached by an uncontrollable path, LCC is violated.

Parameters:
rLowGen Input generator
rControllableEvents set of controllable events
rHighAlph High level alphabet
Returns:
true if LCC holds

Definition at line 141 of file op_obserververification.cpp.

bool faudes::IsOCC const Generator rLowGen,
const EventSet rControllableEvents,
const EventSet rHighAlph
 

Verification of output control consistency (OCC).

For verifying if a natural projection fulfills the output control consistency condition, a backward reachability is conducted. If starting from a state, where an uncontrollable high-level event is feasible, a controllable event can be reached on a local backward path, OCC is violated.

Parameters:
rLowGen Input generator
rControllableEvents set of controllable events
rHighAlph High level alphabet
Returns:
true if OCC holds

Definition at line 70 of file op_obserververification.cpp.

void faudes::LocalAccessibleReach const vGenerator &  rLowGen,
const EventSet rHighAlph,
Idx  lowState,
StateSet rAccessibleReach
 

Compute the accessible reach for a local automaton.

Parameters:
rLowGen Low level generator
rHighAlph High level alphabet
lowState Low level entry state
rAccessibleReach Result

Definition at line 161 of file localgen.cpp.

void faudes::LocalCoaccessibleReach const TransSetX2EvX1 rRevTransRel,
const EventSet rHighAlph,
Idx  lowState,
StateSet rCoaccessibleReach
 

Compute the coaccessible reach for a local automaton.

Parameters:
rRevTransRel Reverse sorted transition relation
rHighAlph High level alphabet
lowState Low level exit state
rCoaccessibleReach Result

Definition at line 129 of file localgen.cpp.

void faudes::LowExitStates const EventSet rHighAlph,
const std::map< Idx, StateSet > &  rEntryStatesMap,
const TransSetX2EvX1 rLowRevTransRel,
Idx  highState,
StateSet rLowExitStates
 

LowExitStates call-by-reference function:.

Compute the low level exit states for a corresponding hi level state

Parameters:
rHighAlph High level events
rEntryStatesMap Entry states map (see CreateEntryStatesMap(resmap))
rLowRevTransRel Reverse sorted low level transition relation
highState Hi level state for which to compute low level exit states
rLowExitStates Reference to StateSet for low level exit states (result)
Exceptions:
Exception Hi level state not found in entry states map (with FAUDES_CHECKED)

Definition at line 40 of file localgen.cpp.

StateSet faudes::LowExitStates const vGenerator &  rLowGen,
const EventSet rHighAlph,
const std::map< Idx, StateSet > &  rEntryStatesMap,
const TransSetX2EvX1 rLowRevTransRel,
Idx  highState
 

LowExitStates return-copy function:.

Wrapper for the corresponding call-by-reference function. Creates new StateSet, calls function and returns StateSet containing low level exit states.

Parameters:
rLowGen Low level generator (just needed for determining statetable)
rHighAlph High level events
rEntryStatesMap Entry states map (see CreateEntryStatesMap(resmap))
rLowRevTransRel Reverse sorted low level transition relation
highState Hi level state for which to compute low level exit states
Exceptions:
Exception Hi level state not found in entry states map (with FAUDES_CHECKED) (id 502)

Definition at line 27 of file localgen.cpp.

bool faudes::MutualControllability const cGenerator rGen1,
const cGenerator rGen2,
StateSet rForbidden1,
StateSet rForbidden2
 

Verification of mutual controllability.

This function checks if two generators are mutually controllable w.r.t. each other. Additionally, this function provides the states where mutual controllability fails in case the condition is violated.

Parameters:
rGen1 Generator 1
rGen2 Generator 2
rForbidden1 Forbidden states in Generator 1
rForbidden2 Forbidden states in Generator 2
Returns:
True if mutual controllability is fulfilled

Definition at line 43 of file op_mc.cpp.

void faudes::Parallel const vGenerator &  rGen1,
const vGenerator &  rGen2,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
vGenerator &  rResGen
 

Parallel composition.

See Parallel(const vGenerator&, const vGenerator&, vGenerator&). This version fills given reverse composition map to map pairs of old states to new states.

Parameters:
rGen1 First generator
rGen2 Second generator
rReverseCompositionMap Reverse composition map (map< pair<Idx,Idx>, Idx>)
rResGen Reference to resulting parallel composition generator

Definition at line 51 of file parallel.cpp.

void faudes::ProcessDot const std::string &  rDotFile,
const std::string &  rOutFile,
const std::string &  rOutFormat = "",
const std::string &  rDotExec = "dot"
 

convenience function: process dot file to graphics output.

If no output format is given, try to guess from filename extension.

Parameters:
rDotFile name of dot file
rOutFile name of graphics file
rOutFormat graphics format eg "png", "jpg"
rDotExec path/name of executable
Exceptions:
Exception 
  • error in systemcall (id 3)
  • unkown format (id 3)

Definition at line 117 of file helper.cpp.

void faudes::Project const vGenerator &  rGen,
const EventSet rProjectAlphabet,
std::map< Idx, StateSet > &  rEntryStatesMap,
vGenerator &  rResGen
 

Minimized Deterministic projection.

Projects the generated and marked languages to a subalphabet of the original alphabet, and subsequently calls Deterministic and StateMin to construct a deterministic minimal realisation of the result. The input generator does not need to be deterministic.

Parameters:
rGen Reference to generator
rProjectAlphabet Projection alphabet
rEntryStatesMap Reference to entry states map, see Deterministic(..) (result)
rResGen Reference to resulting deterministic generator (result)

Definition at line 459 of file project.cpp.

void faudes::ReachableEvents const vGenerator &  rLowGen,
const EventSet rHighAlph,
Idx  lowState,
EventSet rReachableEvents
 

ReachableEvents call-by-reference function:.

Compute the set of hi level events which can be reached from a low level state. Resulting set will be cleared first.

Parameters:
rLowGen Low level generator
rHighAlph High level alphabet
lowState Low level state
rReachableEvents Reference to EventSet which will contain the reachable high level events (result)

Definition at line 88 of file localgen.cpp.

EventSet faudes::ReachableEvents const vGenerator &  rLowGen,
const EventSet rHighAlph,
Idx  lowState
 

ReachableEvents return-copy function:.

Wrapper for the corresponding call-by-reference function. Creates new EventSet, calls function and returns EventSet containing the reachable hi level events.

Parameters:
rLowGen Low level generator
rHighAlph High level alphabet
lowState Low level state

Definition at line 76 of file localgen.cpp.

bool faudes::relabel vGenerator rGenRelabel,
EventSet rControllableEvents,
EventSet rHighAlph,
vector< Idx > &  rNewPartitions,
map< Idx, Idx > &  rMapStateToPartition,
map< Transition, Transition > &  rMapChangedTransReverse,
map< Transition, Idx > &  rMapChangedTrans,
map< Idx, EventSet > &  rMapRelabeledEvents
 

Relabeling algorithm for the computation of an Lm-observer.

This function checks the termination criterion of the observer algorithm. If required, transitions of the input generator are relabeled.

The alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenRelabel. There are no further restrictions on parameters.

Parameters:
rGenRelabel Generator whose transitions are modified
rControllableEvents Set of controllable events
rHighAlph Abstraction alphabet
rNewPartitions Vector containing the indices of the equivalence classes that partition the state space of rGenRelabel
rMapStateToPartition Maps each state of rGenRelabel to an equivalence class that must also be contained in rNewPartitions
rMapChangedTransReverse Maps the relabeled transitions to the original transitions
rMapChangedTrans Maps the the modified original transitions to its new events
rMapRelabeledEvents Maps the original events to the set of new events they were relabeled with

Definition at line 745 of file op_observercomputation.cpp.

bool faudes::RemoveFile const std::string &  rFileName  ) 
 

convenience function: delete file

Parameters:
rFileName name of file to delete

Definition at line 188 of file helper.cpp.

void faudes::SetComposedStateNames const vGenerator &  rGen1,
const vGenerator &  rGen2,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
vGenerator &  rGen12
 

Helper: uses reverse composition map to track state names in a paralell composition.

Purely cosmetic.

Parameters:
rGen1 First generator
rGen2 Second generator
rReverseCompositionMap Reverse composition map (map< pair<Idx,Idx>, Idx>)
rGen12 Reference to resulting parallel composition generator

Definition at line 340 of file parallel.cpp.

void faudes::SParallel const vGenerator &  rGen1,
const vGenerator &  rGen2,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
vGenerator &  rResGen
 

Shared event parallel composition.

See SParallel(const vGenerator&, const vGenerator&, vGenerator&). This version fills given reverse composition map to map pairs of old states to new states.

Parameters:
rGen1 First generator
rGen2 Second generator
rReverseCompositionMap Reverse composition map (map< pair<Idx,Idx>, Idx>)
rResGen Reference to resulting parallel composition generator

Definition at line 227 of file parallel.cpp.

void faudes::StateMin vGenerator &  rGen,
vGenerator &  rResGen,
std::vector< StateSet > &  rSubsets,
std::vector< Idx > &  rNewIndices
 

State set minimization.

This function implements the (n*log n) set partitioning algorithm by John E. Hopcroft. Given generator will be made accessible before computing minimized generator. See also StateMin(vGenerator&,vGenerator&).

Parameters:
rGen Generator
rResGen Minimized generator (result)
rSubsets Vector of subsets that will be constructed during running the algorithm (optional parameter)
rNewIndices Vector of new state indices corresponding to the subsets (optional parameter)
Exceptions:
Exception Input automaton nondeterministic (id 101)

Definition at line 37 of file statemin.cpp.

void faudes::SupCon const vGenerator &  rPlantGen,
const EventSet rCAlph,
const vGenerator &  rSpecGen,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
vGenerator &  rResGen
 

Supremal Controllable Sublanguage.

Only for deterministic plant + spec. Throws exception if plant or spec is nondeterministic.

Real SupCon function

Finds the "largest" sublanguage of h for that language of g is controllable with respect to h. Note that the language of h is not rtequired to be a a sublanguage of g, but both languages must share the same alphabet.

See "C.G CASSANDRAS AND S. LAFORTUNE. Introduction to Discrete Event Systems. Kluwer, 1999." for base algorithm.

This version creates a "reverse composition map" given as reference parameter.

Parameters:
rPlantGen Plant Generator
rCAlph Controllable events
rSpecGen Specification Generator
rReverseCompositionMap std::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function
rResGen Reference to resulting Generator, the minimal restrictive supervisor
Exceptions:
Exception 
  • alphabets of generators don't match (id 100)
  • plant nondeterministic (id 201)
  • spec nondeterministic (id 203)
  • plant and spec nondeterministic (id 204)

Definition at line 734 of file supcon.cpp.

void faudes::SupConNBNonDet const vGenerator &  rPlantGen,
const EventSet rCAlph,
const vGenerator &  rSpecGen,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
Generator  rDetPlantGen,
Generator  rDetSpecGen,
std::map< Idx, StateSet > &  rPowerStatesPlant,
std::map< Idx, StateSet > &  rPowerStatesSpec,
bool &  rDetPlantBool,
bool &  rDetSpecBool,
vGenerator &  rResGen
 

Nonblocking Supremal Controllable Sublanguage.

For deterministic and nondeterministic plant or spec.

  • If rPlantGen is deterministic, rDetPlantGen will be unchanged. rDetPlantBool will be set to false.

  • If rSpecGen is deterministic, rDetSpecGen will be unchanged rDetSpecBool will be set to false

  • If rPlantGen is nondeterministic, rDetPlantGen will contain deterministic plant generator. rDetPlantBool will be set to true. rPowerStatesPlant will contain the mapping of deterministic states to subsets of nondeterministic states

  • If rSpecGen is nondeterministic, rDetPlantGen will contain deterministic spec generator. rDetSpecBool will be set to true. rPowerStatesSpec will contain the mapping of deterministic states to subsets of nondeterministic states

Finds the "largest" sublanguage of h for that language of g is controllable with respect to h. Differing from theory the marked language of h may not be a sublanguage of g but both must share the same alphabet.

See "C.G CASSANDRAS AND S. LAFORTUNE. Introduction to Discrete Event Systems. Kluwer, 1999." for base algorithm.

This version creates a "reverse composition map" given as reference parameter.

Parameters:
rPlantGen Plant Generator
rCAlph Controllable events
rSpecGen Specification Generator
rReverseCompositionMap std::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function
rDetPlantGen Deterministic plant generator (if rPlantGen is nondeterministic)
rDetSpecGen Deterministic spec generator (if rSpecGen is nondeterministic)
rPowerStatesPlant Mapping of deterministic states to set of nondeterministic states
rPowerStatesSpec Mapping of deterministic states to set of nondeterministic states
rDetPlantBool true if rPlantGen is deterministic, false if not
rDetSpecBool true if rSpecGen is deterministic, false if not
rResGen Reference to resulting Generator, the minimal restrictive nonblocking supervisor
Exceptions:
Exception Alphabets of generators don't match (id 500)

Definition at line 647 of file supcon.cpp.

void faudes::SupConNBUnchecked const vGenerator &  rPlantGen,
const EventSet rCAlph,
const vGenerator &  rSpecGen,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
vGenerator &  rResGen
 

Nonblocking Supremal Controllable Sublanguage (internal function).

This version of SupConNB creates a "reverse composition map" given as reference parameter. It is used by the user function to set up descriptive state names of the supervisor.

Parameters:
rPlantGen Plant Generator
rCAlph Controllable events
rSpecGen Specification Generator
rReverseCompositionMap std::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function
rResGen Reference to resulting cGenerator, the minimal restrictive nonblocking supervisor
Exceptions:
Exception 
  • alphabets of generators don't match (id 100)
  • plant nondeterministic (id 201)
  • spec nondeterministic (id 203)
  • plant and spec nondeterministic (id 204)

Definition at line 480 of file supcon.cpp.

void faudes::SupconParallel const vGenerator &  rPlantGen,
const EventSet rCAlph,
const vGenerator &  rSpecGen,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
vGenerator &  rResGen
 

Parallel composition optimized for the purpose of SupCon (internal function).

Composition stops at transition paths that violate the specification by uncontrollable plant transitions.

Parameters:
rPlantGen Plant Generator
rCAlph Uncontrollable Events
rSpecGen Specification Generator
rReverseCompositionMap std::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function
rResGen Reference to resulting Generator, the less restrictive supervisor

Definition at line 263 of file supcon.cpp.

bool faudes::SupConUnchecked const vGenerator &  rPlantGen,
const EventSet rCAlph,
vGenerator &  rSupCandGen
 

Supremal Controllable Sublangauge (internal function).

Calls IsControllable to indetify "critical" states in the supervisor candidate. Then deletes critical states from the candidate supervisor in order to achieve controllability.

In general, the result is blocking.

Parameters:
rPlantGen Plant generator
rCAlph Controllable events
rSupCandGen Supervisor candidate generator
Returns:
True if no state has been deleted. Else false.

Definition at line 224 of file supcon.cpp.

Idx faudes::ToIdx const std::string &  rString  ) 
 

Convert a string to Idx.

Parameters:
rString string to convert
Returns:
Idx
Exceptions:
Idx overflow (id 600)

Definition at line 86 of file helper.cpp.

std::string faudes::ToStringFloat double  number  ) 
 

float to string

Parameters:
number double
Returns:
string

Definition at line 54 of file helper.cpp.

std::string faudes::ToStringInteger long int  number  ) 
 

integer to string

Parameters:
number integer
Returns:
string

Definition at line 35 of file helper.cpp.

std::string faudes::ToStringInteger16 long int  number  ) 
 

integer to string base 16

Parameters:
number integer
Returns:
string

Definition at line 44 of file helper.cpp.

void faudes::TraverseUncontrollableBackwards const EventSet rCAlph,
TransSetX2EvX1 rtransrel,
StateSet rCriticalStates,
Idx  current
 

Helper function for IsControllable.

The state given as "current" is considered critical. Itself and all uncontrollable predecessor states are added to the set "rCriticalStates".

Parameters:
rCAlph Set of controllable events
rtransrel Reverse sorted transition relation
rCriticalStates Set of critical states in composition generator
current Current state

Definition at line 777 of file supcon.cpp.


Generated on Fri May 9 11:26:48 2008 for libFAUDES 2.09b by  doxygen 1.4.4