faudes Namespace Reference

libFAUDES resides within the namespace faudes. More...

Classes

class  TaBaseSet
 Set with nontrivial attributes. More...
class  TaGenerator
 Generator with specified attribute types. More...
class  AttributeVoid
 Minimal Attribute. More...
class  AttributeFlags
 Boolean flags Attribute. More...
class  TBaseSet
 STL style set template. More...
class  vBaseVector
 Vector bass class. More...
class  TBaseVector
 Vector template. More...
class  AttributeCFlags
 Attribute class to model event controllability properties. More...
class  TcGenerator
 Compatibility: pre 2.20b used cEventSet as C++ class name. More...
class  Integer
 Elementary type. More...
class  String
 Elementary type. More...
class  Boolean
 Elementary type. More...
class  Exception
 Faudes exception class. More...
class  Parameter
 Structure to model a parameter type within the Signature of a Function. More...
class  Signature
 Signature of a Function. More...
class  FunctionDefinition
 A FunctionDefinition defines the interface to a faudes-function. More...
class  Function
 A faudes-function hosts parameter values of some faudes type and provides a method to perform an operation on the specified paramters, e.g. More...
class  vGenerator
 Base class of all FAUDES generators. More...
class  SccFilter
 Filter for strictly connected components (SCC) search/compute routines. More...
class  ConsoleOut
 Console Out. More...
class  ObjectCount
 Debugging counter. 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  OPState
class  ProductCompositionMap
 Rti-wrapper for composition maps. More...
struct  TGraph
 A graph is modelled as a map from vertex-labels to nodes. More...
struct  TNode
 A node represents the edges related to one individual vertex. More...
struct  node_entry_t
 A node-entry represents one edge. More...
struct  graph_iterator_t
 An iterators over the map of all nodes is interpreted as a state incl. More...
struct  node_iterator_t
 An iterator over the set of edges related to one vertex is interpreted as a transition. More...
struct  TGraph< Idx, Idx >
 Specialisation of the graph template to provide convenience methods addressing the intended ussage. More...
class  TypeRegistry
 The TypeRegistry registers faudes-types. More...
class  AutoRegisterType
 Auto register faudes-type with specified type name. More...
class  AutoRegisterXElementTag
class  FunctionRegistry
 The FunctionRegistry registers faudes-functions. More...
class  SymbolSet
 Set of symbols. 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  Type
 Base class of all libFAUDES objects that participate in the run-time interface. More...
class  Documentation
 faudes type implementation macros, overall, debug version More...
class  TypeDefinition
 A TypeDefinition defines a faudes-type in that it specifies a faudes-type name to identify the type and a method NewObject() to instantiate objects of the respective type. More...
class  SNOState
struct  ReductionStateInfo
 Data structure for identifying states in the same coset for supervisor reduction. More...
class  MCtrlPattern
class  OPSState
class  Bisimulation
 This class implements the algorithms needed for the computation of the coarsest quasi-congruence (=Bisimulation) of a given generator. More...
class  EventRelabelMap
 Rti convenience wrapper for relabeling maps. More...
struct  Partition
 This struct implements a coset (=equivalence class) as needed for the computation of the coarsest quasi-congruence on an automaton. More...
class  AttributeDiagnoserState
 Implements state estimates for the current status of the generator. More...
class  AttributeFailureEvents
 Stores the failure and indicator events for a particular failure type. More...
class  AttributeFailureTypeMap
 Partitions the failure and indicator events. More...
class  DiagLabelSet
 Implements the label representation for state estimates. More...
struct  CoVerifierState
class  TdiagGenerator
 Provides the structure and methods to build and handle diagnosers. More...
struct  VerifierState
class  HioEventFlags
 Event attributes for hierarchical discrete event systems with inputs and outputs. More...
class  HioStateFlags
 State attributes for hierarchical discrete event systems with inputs and outputs. More...
class  THioConstraint
 Generator with I/O-constraint attributes. More...
class  THioController
 Generator with I/O-controller attributes. More...
class  THioEnvironment
 Generator with I/O-environment attributes. More...
class  HioModule
 Recurring structure in hierarchies designed according to the I/O based DES framework. More...
class  THioPlant
 Generator with I/O-plant attributes. More...
class  AttributeIosEvent
 Attributes for events in DES with in- and outputs. More...
class  AttributeIosState
 Attributes for states in DESs with in- and outputs. More...
class  TioGenerator
 Generator with I/O-system attributes. More...
class  AttributeColoredState
 State attributes for multitasking automata. More...
class  ColorSet
 Container for colors: this is a NameSet with its own static symboltable. More...
class  TmtcGenerator
 Allows to create colored marking generators (CMGs) as the common five tupel consisting of alphabet, stateset, transition relation, initial states, marked states, and attributes for state and event properties. More...
class  adjlist
class  AttributePushdownState
 State attribute with substates. More...
class  AttributePushdownTransition
class  AttributePushdownGlobal
 Global attribute with stack alphabet and stack bottom. More...
class  StackSymbolSet
 Container class to model a set of stack symbols. More...
class  StackSymbol
 Deprecated, do not use! More...
class  AttributeGotoTransition
 Event attribute with grammar symbols. More...
class  AttributeGotoState
 State attribute with configuration set. More...
class  GotoMachine
 Simple generator for parsing with goto tables. More...
class  TgotoGenerator
 Generator for parsing with goto tables. More...
class  GrammarSymbol
 Grammar Symbol. More...
class  Terminal
 Terminal. More...
class  Nonterminal
 Nonterminals are constructed from two states and a stack symbol or one state and a stack symbol. More...
struct  GsVectorComparator
struct  GsComparator
class  GrammarProduction
 Grammar Production. More...
class  Grammar
 Grammar. More...
class  LangK
 This class is used to find all words that can be found when traversing a maximum of k transitions of a given generator. More...
class  MergeAbstract
 Abstract interface class for all kinds of items which can comprise a new state. More...
class  MergeStates
 Merge class which contains only states. More...
class  MergeStateAnnotation
 Merge class which contains one state and a string annotation. More...
class  MergeStateEvent
 Merge class which contains one state and one event. More...
class  MergeStateSplit
 Merge class which contains one state, one stack symbol and a string annotation. More...
class  MergeTransition
 Merge class which contains one transition. More...
class  Lr1Configuration
 Lr1 Configuration. More...
struct  ConfigSetComparator
struct  ConfigGsPairComparator
class  Lr1ParserActionElement
 Lr1ParserActionElement. More...
class  Lr1ParserAction
 Lr1ParserAction. More...
class  Lr1Parser
 Lr1Parser. More...
class  TpdGenerator
 Generator with push down extensions. More...
class  AttributeTimedTrans
 Transition Attribute with guard and resets. More...
class  AttributeTimedState
 State attribute with invariant. More...
class  AttributeTimedGlobal
 Globat attribute with clockset. More...
class  TtGenerator
 Generator with timing extensions. More...
class  ClockSet
 Container class to model a set of clocks. More...
class  ElemConstraint
 Model of an elementary clock constraint formula. More...
class  TimeConstraint
 A TimeConstraint is a set of elementary clock constraints. More...
class  tpTime
 Type to represent time. More...
class  TimeInterval
 Model of a time interval. More...
class  DiscreteDensityFunction
 Density Function. More...
class  SampledDensityFunction
class  DeviceExecutor
 Executer with IO device to handle external/physical events. More...
struct  TimedEvent
 Global Tyoedefs. More...
class  Executor
 An Executor is a timed generator that maintains a current state. More...
class  LoggingExecutor
 Executor with logging facilities. More...
class  ParallelExecutor
 Synchronized parallel execution of TimedGenerators. More...
class  ProposingExecutor
 Executer that proposes which transition to execute. More...
class  SimEventCondition
 Defining data of event based simulation condition. More...
class  SimStateCondition
 Defining data of state based simulation condition. More...
class  AttributeSimCondition
 Attribute for a simulation condition. More...
class  SimConditionSet
 Set of simulation named conditions. More...
class  SimPriorityEventAttribute
 Defining data to prioritise events. More...
class  SimStochasticEventAttribute
 Defining data of stochastic behaviour. More...
class  SimEventAttribute
 Attribute for an event in the context of simulation. More...
class  AttributeSignalOutput
 Configuration of a signal based output mapping. More...
class  AttributeSignalInput
 Configuration of a signal based input mapping. More...
class  AttributeSignalEvent
 Configuration of a signal based input or output. More...
class  sDevice
 An sDevice implements signal based semantics for faudes events. More...
class  SimplenetAddress
 Simplenet node address. More...
class  AttributeSimplenetOutput
 Configuration of a network output mapping. More...
class  AttributeSimplenetInput
 Configuration of a network input mapping. More...
class  AttributeSimplenetEvent
 Configuration of a networked input or output. More...
class  nDevice
 An nDevice implements networked IO via a simple TCP/IP protocol. More...
class  AttributeDeviceEvent
 Attribute for the configuration of a input or output mapping. More...
class  vDevice
 Virtual base class to define the interface for event io. More...
class  xDevice
 Container of devices. More...
struct  swig_cast_info
struct  swig_type_info
struct  swig_lua_userdata
class  LuaFunctionDefinition
 A LuaFunctionDefinition is derived from FunctionDefinition to define a faudes-function by a Lua script. More...
class  LuaState
 Wrapper class to maintain a Lua state. More...
class  LuaFunction
 A LuaFunction is a faudes-function that executes a luafaudes script. More...

Typedefs

typedef unsigned long int fType
 Convenience typdef flag data.
typedef TaNameSet
< AttributeCFlags
Alphabet
 Convenience typedef for event sets with controllability attributes.
typedef TBaseVector< AlphabetAlphaberVector
 Convenience typedef.
typedef TcGenerator
< AttributeVoid, AttributeVoid,
AttributeCFlags, AttributeVoid
System
 Convenience typedef for std System.
typedef TBaseVector< SystemSystemVector
 Convenience typedef for vectors of systems.
typedef uint32_t Idx
 Type definition for index type (allways 32bit).
typedef long int Int
 Type definition for integer type (let target system decide, minimum 32bit).
typedef double Float
 Type definition for real type (use C std double, must at least represent Int).
typedef TBaseVector< IntegerIntegerVector
typedef vGenerator Generator
 Plain generator, api typedef for generator with no attributes.
typedef TBaseVector< GeneratorGeneratorVector
 Convenience typedef for vectors og generators.
typedef IndexSet StateSet
typedef TBaseVector< IndexSetIndexSetVector
 Convenience typedef for vectors og generators.
typedef NameSet EventSet
 Convenience typedef for plain event sets.
typedef TBaseVector< EventSetEventSetVector
typedef TNode< Idx, IdxNode
typedef TGraph< Idx, IdxGraph
typedef TTransSet
< TransSort::X1EvX2
TransSet
 Type definition for default sorted TTransSet.
typedef TTransSet
< TransSort::X1EvX2
TransSetX1EvX2
 Type definition for default sorted TTransSet.
typedef TTransSet
< TransSort::EvX1X2
TransSetEvX1X2
 Type definition for ev, x1, x2 sorted TTransSet.
typedef TTransSet
< TransSort::EvX2X1
TransSetEvX2X1
 Type definition for ev, x2, x1 sorted TTransSet.
typedef TTransSet
< TransSort::X2EvX1
TransSetX2EvX1
 Type definition for x2, ev, x1 sorted TTransSet.
typedef TTransSet
< TransSort::X2X1Ev
TransSetX2X1Ev
 Type definition for x2, x1, ev sorted TTransSet.
typedef TTransSet
< TransSort::X1X2Ev
TransSetX1X2Ev
 Type definition for x1, x2, ev sorted TTransSet.
typedef TdiagGenerator
< AttributeFailureTypeMap,
AttributeDiagnoserState,
AttributeCFlags, AttributeVoid
Diagnoser
typedef THioConstraint
< AttributeVoid, HioStateFlags,
HioEventFlags, AttributeVoid
HioConstraint
typedef THioController
< AttributeVoid, HioStateFlags,
HioEventFlags, AttributeVoid
HioController
typedef THioEnvironment
< AttributeVoid, HioStateFlags,
HioEventFlags, AttributeVoid
HioEnvironment
typedef THioPlant
< AttributeVoid, HioStateFlags,
HioEventFlags, AttributeVoid
HioPlant
typedef TaNameSet
< AttributeIosEvent
IosEventSet
typedef TaIndexSet
< AttributeIosState
IosStateSet
typedef TioGenerator
< AttributeVoid,
AttributeIosState,
AttributeIosEvent,
AttributeVoid
IoSystem
typedef TmtcGenerator
< AttributeVoid,
AttributeColoredState,
AttributeCFlags, AttributeVoid
MtcSystem
typedef std::set< std::pair
< std::vector< Idx >
, std::vector< Idx > > > 
PopPushSet
 Transition attribute with pop and push.
typedef unsigned int uint
typedef TgotoGenerator
< AttributeVoid,
AttributeGotoState,
AttributeVoid,
AttributeGotoTransition
GotoGenerator
 Convenience typedef for std GotoGenerator.
typedef std::tr1::shared_ptr
< GrammarSymbol
GrammarSymbolPtr
typedef std::tr1::shared_ptr
< const GrammarSymbol
ConstGrammarSymbolPtr
typedef std::tr1::shared_ptr
< Nonterminal
NonterminalPtr
typedef std::tr1::shared_ptr
< const Nonterminal
ConstNonterminalPtr
typedef std::tr1::shared_ptr
< Terminal
TerminalPtr
typedef std::tr1::shared_ptr
< const Terminal
ConstTerminalPtr
typedef std::vector
< GrammarSymbolPtr
GrammarSymbolVector
typedef std::set
< GrammarSymbolPtr,
GsComparator
GrammarSymbolSet
typedef std::set
< GrammarSymbolVector,
GsVectorComparator
GrammarSymbolWordSet
typedef std::map
< GrammarSymbolVector,
std::set< Terminal >
, GsVectorComparator
GrammarSymbolWordMap
typedef std::set< std::set
< Lr1Configuration >
, ConfigSetComparator
Lr1ConfigurationSetSet
typedef std::pair< std::set
< Lr1Configuration >
, GrammarSymbolPtr
ConfigSetGsPair
typedef std::vector< std::set
< Lr1Configuration > > 
ConfigSetVector
typedef std::map
< ConfigSetGsPair, std::set
< Lr1Configuration >
, ConfigGsPairComparator
LrmTransitionMap
typedef std::set
< ConfigSetGsPair,
ConfigGsPairComparator
ConfigSetGsPairSet
typedef TpdGenerator
< AttributePushdownGlobal,
AttributePushdownState,
AttributeCFlags,
AttributePushdownTransition
PushdownGenerator
 Convenience typedef for std PushdownGenerator.
typedef TaTransSet
< AttributePushdownTransition
PdTransSet
typedef TtGenerator
< AttributeTimedGlobal,
AttributeTimedState,
AttributeCFlags,
AttributeTimedTrans
TimedGenerator
 Convenience typedef for std TimedGenerator.
typedef void vDevice
 Dummy typedef in the absence of the IO Device plugin.
typedef TaNameSet
< SimEventAttribute
sEventSet
 Typedef for events with simulation attributes.
typedef void *(* swig_converter_func )(void *, int *)
typedef struct swig_type_info *(* swig_dycast_func )(void **)
typedef struct
faudes::swig_cast_info 
swig_cast_info
typedef struct
faudes::swig_type_info 
swig_type_info

Enumerations

enum  VerifierStateLabel { NORMAL, CONFUSED, BLOCK }

Functions

template<class T , class Cmp >
void SetUnion (const TBaseSet< T, Cmp > &rSetA, const TBaseSet< T, Cmp > &rSetB, TBaseSet< T, Cmp > &rRes)
template<class T , class Cmp >
void SetIntersection (const TBaseSet< T, Cmp > &rSetA, const TBaseSet< T, Cmp > &rSetB, TBaseSet< T, Cmp > &rRes)
template<class T , class Cmp >
void SetDifference (const TBaseSet< T, Cmp > &rSetA, const TBaseSet< T, Cmp > &rSetB, TBaseSet< T, Cmp > &rRes)
template<class T , class Cmp >
bool SetEquality (const TBaseSet< T, Cmp > &rSetA, const TBaseSet< T, Cmp > &rSetB)
template<class T , class Cmp >
bool SetInclusion (const TBaseSet< T, Cmp > &rSetA, const TBaseSet< T, Cmp > &rSetB)
void UniqueInit (Generator &rGen)
 Make initial states unique.
void UniqueInit (const Generator &rGen, Generator &rResGen)
 Make initial states unique.
void Deterministic (const Generator &rGen, Generator &rResGen)
 Make generator deterministic.
void aDeterministic (const Generator &rGen, Generator &rResGen)
 Make generator deterministic.
void Deterministic (const Generator &rGen, std::map< Idx, StateSet > &rEntryStatesMap, Generator &rResGen)
 Make generator deterministic.
void Deterministic (const Generator &rGen, std::vector< StateSet > &rPowerStates, std::vector< Idx > &rDetStates, Generator &rResGen)
 Make generator deterministic.
long int IntegerSum (const Integer &arg1, const Integer &arg2)
long int IntegerSum (const IntegerVector &intvect)
bool IsAccessible (const vGenerator &rGen)
 RTI wrapper function.
bool IsCoaccessible (const vGenerator &rGen)
 RTI wrapper function.
bool IsTrim (const vGenerator &rGen)
 RTI wrapper function.
bool IsOmegaTrim (const vGenerator &rGen)
 RTI wrapper function.
bool IsComplete (const vGenerator &rGen)
 RTI wrapper function.
bool IsComplete (const vGenerator &rGen, const StateSet &rStateSet)
bool IsComplete (const vGenerator &rGen, const EventSet &rSigmaO)
 RTI wrapper function.
bool IsDeterministic (const vGenerator &rGen)
 RTI wrapper function.
void Accessible (vGenerator &rGen)
 RTI wrapper function.
void Accessible (const vGenerator &rGen, vGenerator &rRes)
 RTI wrapper function.
void Coaccessible (vGenerator &rGen)
 RTI wrapper function.
void Coaccessible (const vGenerator &rGen, vGenerator &rRes)
 RTI wrapper function.
void Complete (vGenerator &rGen)
 RTI wrapper function.
void Complete (const vGenerator &rGen, vGenerator &rRes)
 RTI wrapper function.
void Complete (vGenerator &rGen, const EventSet &rSigmaO)
 RTI wrapper function.
void Complete (const vGenerator &rGen, const EventSet &rSigmaO, vGenerator &rRes)
 RTI wrapper function.
void Trim (vGenerator &rGen)
 RTI wrapper function.
void Trim (const vGenerator &rGen, vGenerator &rRes)
 RTI wrapper function.
void OmegaTrim (vGenerator &rGen)
 RTI wrapper function.
void OmegaTrim (const vGenerator &rGen, vGenerator &rRes)
 RTI wrapper function.
void MarkAllStates (vGenerator &rGen)
 RTI wrapper function.
void AlphabetExtract (const vGenerator &rGen, EventSet &rRes)
 RTI wrapper function.
void SetIntersection (const GeneratorVector &rGenVec, EventSet &rRes)
 RTI convenience function.
void SetUnion (const GeneratorVector &rGenVec, EventSet &rRes)
 RTI convenience function.
void SetIntersection (const vGenerator &rGenA, const vGenerator &rGenB, EventSet &rRes)
 RTI convenience function.
void SetUnion (const vGenerator &rGenA, const vGenerator &rGenB, EventSet &rRes)
 RTI convenience function.
void SetDifference (const vGenerator &rGenA, const vGenerator &rGenB, EventSet &rRes)
 RTI convenience function.
void SearchScc (const Idx vState, int &vRcount, const Generator &rGen, const SccFilter &rFilter, StateSet &rTodo, std::stack< Idx > &rStack, StateSet &rStackStates, std::map< const Idx, int > &rDfn, std::map< const Idx, int > &rLowLnk, std::list< StateSet > &rSccList, StateSet &rRoots)
 Search for strongly connected components (SCC).
bool ComputeScc (const Generator &rGen, const SccFilter &rFilter, std::list< StateSet > &rSccList, StateSet &rRoots)
 Compute strongly connected components (SCC).
bool ComputeScc (const Generator &rGen, std::list< StateSet > &rSccList, StateSet &rRoots)
 Compute strongly connected components (SCC).
bool ComputeScc (const Generator &rGen, const SccFilter &rFilter, Idx q0, StateSet &rScc)
 Compute strongly connected component (SCC).
bool ComputeScc (const Generator &rGen, const SccFilter &rFilter, StateSet &rScc)
 Compute one strongly connected components (SCC).
bool HasScc (const Generator &rGen, const SccFilter &rFilter)
 Test for strongly connected components (SCC).
bool ComputeNextScc (const Generator &rGen, SccFilter &rFilter, StateSet &rScc)
 Compute next SCC.
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=FD_MAXCONTAINERNAME)
 Limit length of string, return head and tail of string.
Idx ToIdx (const std::string &rString)
 Convert a string to Idx.
std::string StringSubstitute (const std::string &rString, const std::string &rFrom, const std::string &rTo)
 Substitute in string.
std::string VersionString ()
 Return FAUDES_VERSION as std::string.
std::string PluginsString ()
 Return FAUDES_PLUGINS as std::string.
std::string ContributorsString ()
 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)
 Create a temp file, length 0.
bool RemoveFile (const std::string &rFileName)
 Delete a file.
std::string ExtractDirectory (const std::string &rFullPath)
 Extract directory from full path.
std::string ExtractFilename (const std::string &rFullName)
 Extract file name from full path.
std::string ExtractBasename (const std::string &rFullName)
 Extract file name from full path.
std::string ExtractExtension (const std::string &rFullName)
 Extract file name from full path.
std::string PrependDirectory (const std::string &rDirectory, const std::string &rFileName)
 Construct full path from directory and filename.
bool DirectoryExists (const std::string &rDirectory)
 Test existence of directory.
std::set< std::string > ReadDirectory (const std::string &rDirectory)
 Read the contents of the specified directors.
bool FileExists (const std::string &rFilename)
 Test existence of file.
bool FileDelete (const std::string &rFilename)
 Delete file.
bool FileCopy (const std::string &rFromFile, const std::string &rToFile)
 Copy file.
void ExitFunction (void)
std::string TestProtocol (const std::string &rSource)
 Test Protocol.
void TestProtocol (const std::string &rMessage, const Type &rData, bool core=false)
 Test Protocol.
void TestProtocol (const std::string &rMessage, bool data)
 Test Protocol.
void TestProtocol (const std::string &rMessage, long int data)
 Test Protocol.
void TestProtocol (const std::string &rMessage, const std::string &data)
 Test Protocol.
bool TestProtocol (void)
 Test Protocol.
void LoopCallback (bool pBreak(void))
void LoopCallback (void)
 Algorithm loop callback.
const std::string & PathSeparator (void)
 Std dir-separator.
void LoopCallback (bool(*pBreakFnct)(void))
 Algorithm loop callback.
StateSet LowExitStates (const Generator &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 Generator &rLowGen, const EventSet &rHighAlph, Idx lowState)
 ReachableEvents return-copy function:
void ReachableEvents (const Generator &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 Generator &rLowGen, const EventSet &rHighAlph, Idx lowState, StateSet &rAccessibleReach)
 Compute the accessible reach for a local automaton.
void aOmegaProduct (const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
 Product composition for Buechi automata.
void OmegaProduct (const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
 Product composition for Buechi automata.
void aOmegaParallel (const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
 Parallel composition with relaxed acceptance condition.
void OmegaParallel (const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
 Parallel composition with relaxed acceptance condition.
void OmegaClosure (Generator &rGen)
 Topological closure.
bool IsOmegaClosed (const Generator &rGen)
 Test for topologically closed omega language.
void Parallel (const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
 Parallel composition.
void aParallel (const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
 Parallel composition.
void aParallel (const GeneratorVector &rGenVec, Generator &rResGen)
 Parallel composition.
void aParallel (const Generator &rGen1, const Generator &rGen2, ProductCompositionMap &rCompositionMap, Generator &rResGen)
 Parallel composition.
void Parallel (const Generator &rGen1, const Generator &rGen2, ProductCompositionMap &rCompositionMap, Generator &rResGen)
 Parallel composition.
void Parallel (const Generator &rGen1, const Generator &rGen2, ProductCompositionMap &rCompositionMap, StateSet &rMark1, StateSet &rMark2, Generator &rResGen)
 Parallel composition.
void Parallel (const Generator &rGen1, const Generator &rGen2, std::map< std::pair< Idx, Idx >, Idx > &rCompositionMap, Generator &rResGen)
 Parallel composition.
void Product (const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
 Product composition.
void aProduct (const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
 Product composition.
void aProduct (const Generator &rGen1, const Generator &rGen2, ProductCompositionMap &rCompositionMap, Generator &rResGen)
 Product composition.
void Product (const Generator &rGen1, const Generator &rGen2, std::map< std::pair< Idx, Idx >, Idx > &rCompositionMap, StateSet &rMark1, StateSet &rMark2, Generator &rResGen)
 Product composition.
void Product (const Generator &rGen1, const Generator &rGen2, std::map< std::pair< Idx, Idx >, Idx > &rCompositionMap, Generator &rResGen)
 Product composition.
void SetComposedStateNames (const Generator &rGen1, const Generator &rGen2, const std::map< std::pair< Idx, Idx >, Idx > &rCompositionMap, Generator &rGen12)
 Helper: uses composition map to track state names in a paralell composition.
void CompositionMap1 (const std::map< std::pair< Idx, Idx >, Idx > &rCompositionMap, std::map< Idx, Idx > &rCompositionMap1)
void CompositionMap2 (const std::map< std::pair< Idx, Idx >, Idx > &rCompositionMap, std::map< Idx, Idx > &rCompositionMap2)
void ProjectNonDet_opitz (Generator &rGen, const EventSet &rProjectAlphabet)
void ProjectNonDet_ref (Generator &rGen, const EventSet &rProjectAlphabet)
void ProjectNonDet_graph (Generator &rGen, const EventSet &rProjectAlphabet)
void ProjectNonDet_simple (Generator &rGen, const EventSet &rProjectAlphabet)
void ProjectNonDet_barthel (Generator &rGen, const EventSet &rProjectAlphabet)
void ProjectNonDet_fbr (Generator &rGen, const EventSet &rProjectAlphabet)
void ProjectNonDet_scc (Generator &rGen, const EventSet &rProjectAlphabet)
void ProjectNonDet (Generator &rGen, const EventSet &rProjectAlphabet)
 Language projection.
void ProjectNonDetScc (Generator &rGen, const EventSet &rProjectAlphabet)
 Language projection.
void Project (const Generator &rGen, const EventSet &rProjectAlphabet, Generator &rResGen)
 Deterministic projection.
void aProjectNonDet (Generator &rGen, const EventSet &rProjectAlphabet)
 Language projection.
void aProject (const Generator &rGen, const EventSet &rProjectAlphabet, Generator &rResGen)
 Deterministic projection.
void Project (const Generator &rGen, const EventSet &rProjectAlphabet, std::map< Idx, StateSet > &rEntryStatesMap, Generator &rResGen)
 Deterministic projection.
void InvProject (Generator &rGen, const EventSet &rProjectAlphabet)
 Inverse projection.
void aInvProject (Generator &rGen, const EventSet &rProjectAlphabet)
 Inverse projection.
void aInvProject (const Generator &rGen, const EventSet &rProjectAlphabet, Generator &rResGen)
 Inverse projection.
void CreateEntryStatesMap (const std::map< StateSet, Idx > &rRevEntryStatesMap, std::map< Idx, StateSet > &rEntryStatesMap)
void LoadRegistry (const std::string &rPath="")
 Load all registered types and functions.
void SaveRegistry (const std::string &rPath="")
 Dump all registered types and functions.
void ClearRegistry (void)
 Clear all registry.
TypeNewFaudesObject (const std::string &rTypeName)
 Instantiate faudes typed objects by type name.
FunctionNewFaudesFunction (const std::string &rFunctName)
 Instantiate faudes function objects by function name.
const std::string & FaudesTypeName (const Type &rObject)
 Query type name.
bool FaudesTypeTest (const std::string &rTypeName, const Type &rObject)
 Test type compatibility.
const std::string & FaudesFunctionName (const Function &rObject)
const std::string & FaudesFunctionName (const Type &rObject)
 Query function name.
void LanguageUnionNonDet (const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
 Language union, nondeterministic version.
void LanguageUnion (const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
 Language union, deterministic version.
void LanguageUnion (const GeneratorVector &rGenVec, Generator &rResGen)
 Language union.
void LanguageIntersection (const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
 Language intersection.
void LanguageIntersection (const GeneratorVector &rGenVec, Generator &rResGen)
 Language intersection.
bool EmptyLanguageIntersection (const Generator &rGen1, const Generator &rGen2)
 Test for empty language intersection (same as Disjoind()).
bool LanguageDisjoint (const Generator &rGen1, const Generator &rGen2)
 Test whether two languages are disjoint.
void Automaton (Generator &rGen, const EventSet &rAlphabet)
 Convert generator to automaton wrt specified alphabet.
void Automaton (Generator &rGen)
 Convert generator to automaton.
void LanguageComplement (Generator &rGen, const EventSet &rAlphabet)
 Language complement wrt specified alphabet.
void LanguageComplement (Generator &rGen)
 Language complement.
void LanguageComplement (const Generator &rGen, Generator &rRes)
 Language Complement (uniform API wrapper).
void LanguageComplement (const Generator &rGen, const EventSet &rSigma, Generator &rRes)
 Language Complement (uniform API wrapper).
void LanguageDifference (const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
 Language difference (set-theoretic difference).
void LanguageConcatenateNonDet (const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
 Language concatenation, nondeterministic version.
void LanguageConcatenate (const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
 Language concatenation, deterministic version.
void FullLanguage (const EventSet &rAlphabet, Generator &rResGen)
 Full Language, L(G)=Lm(G)=Sigma*.
void AlphabetLanguage (const EventSet &rAlphabet, Generator &rResGen)
 Alphabet Language, L(G)=Lm(G)=Sigma.
void EmptyStringLanguage (const EventSet &rAlphabet, Generator &rResGen)
 Empty string language, L(G)=Lm(G)={epsilon}.
void EmptyLanguage (const EventSet &rAlphabet, Generator &rResGen)
 Empty language Lm(G)={}.
bool IsEmptyLanguage (const Generator &rGen)
 Test for Empty language Lm(G)=={}.
bool LanguageInclusion (const Generator &rGen1, const Generator &rGen2)
 Test language inclusion, Lm1<=Lm2.
bool LanguageEquality (const Generator &rGen1, const Generator &rGen2)
 Language equality, Lm1==Lm2.
void KleeneClosure (Generator &rGen)
 Kleene Closure.
void KleeneClosure (const Generator &rGen, Generator &rResGen)
 Kleene Closure.
void KleeneClosureNonDet (Generator &rGen)
 Kleene Closure, nondeterministic version.
void PrefixClosure (Generator &rGen)
 Prefix Closure.
bool IsPrefixClosed (const Generator &rGen)
 Test for prefix closed marked language.
bool IsNonblocking (const Generator &rGen)
 Test for nonblocking generator.
bool IsNonblocking (const Generator &rGen1, const Generator &rGen2)
 Test for nonblocking marked languages.
void SelfLoop (Generator &rGen, const EventSet &rAlphabet)
 Self-loop all states.
void SelfLoopMarkedStates (Generator &rGen, const EventSet &rAlphabet)
 Self-loop all marked states.
void SelfLoop (Generator &rGen, const EventSet &rAlphabet, const StateSet &rStates)
 Self-loop specified states.
void StateMin (const Generator &rGen, Generator &rResGen)
 State set minimization.
void aStateMin (const Generator &rGen, Generator &rResGen)
 State set minimization.
void aStateMin (Generator &rGen)
 State set minimization.
void StateMin (Generator &rGen, Generator &rResGen)
 State set minimization.
void StateMin (Generator &rGen, Generator &rResGen, std::vector< StateSet > &rSubsets, std::vector< Idx > &rNewIndices)
 State set minimization.
bool IsRelativelyMarked (const Generator &rGenPlant, const Generator &rGenCand)
 Test for relative marking.
bool IsRelativelyPrefixClosed (const Generator &rGenPlant, const Generator &rGenCand)
 Test for relative prefix-closedness.
void SupRelativelyPrefixClosed (const Generator &rPlantGen, const Generator &rSpecGen, Generator &rResGen)
 Supremal Relatively Closed Sublanguage.
void SupRelativelyPrefixClosedUnchecked (const Generator &rPlantGen, const Generator &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rCompositionMap, Generator &rResGen)
 Supremal Relatively Closed Sublanguage (internal function).
bool IsRelativelyOmegaMarked (const Generator &rGenPlant, const Generator &rGenCand)
 Test for relative marking, omega langauges.
bool IsRelativelyOmegaClosed (const Generator &rGenPlant, const Generator &rGenCand)
 Test for relative closedness, omega languages.
bool IsRelativelyOmegaClosedUnchecked (const Generator &rGenPlant, const Generator &rGenCand)
 Test for relative closedness, omega languages.
void SupConClosedUnchecked (const Generator &rPlantGen, const EventSet &rCAlph, Generator &rSupCandGen)
 Supremal Controllable Sublangauge (internal function).
bool IsControllableUnchecked (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, StateSet &rCriticalStates)
 Controllability (internal function).
void SupConProduct (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, Generator &rResGen)
 Parallel composition optimized for the purpose of SupCon (internal function).
void SupConNBUnchecked (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, Generator &rResGen)
 Nonblocking Supremal Controllable Sublanguage (internal function).
void ControlProblemConsistencyCheck (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen)
 Consistency check for controlproblem input data.
void ControlProblemConsistencyCheck (const Generator &rPlantGen, const EventSet &rCAlph, const EventSet &rOAlph, const Generator &rSpecGen)
 Consistency check for controlproblem input data.
bool IsControllable (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSupCandGen)
 Test controllability.
bool IsControllable (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSupCandGen, StateSet &rCriticalStates)
 Test controllability.
void SupConNB (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, Generator &rResGen)
 Nonblocking Supremal Controllable Sublanguage.
void SupConClosed (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, Generator &rResGen)
 Supremal Controllable and Closed Sublanguage.
void SupConClosed (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, Generator &rResGen)
 Supremal Controllable and Closed Sublanguage.
void TraverseUncontrollableBackwards (const EventSet &rCAlph, TransSetX2EvX1 &rtransrel, StateSet &rCriticalStates, Idx current)
 Helper function for IsControllable.
bool IsControllable (const System &rPlantGen, const Generator &rSupCandGen)
 Test controllability.
void SupConNB (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen)
 Nonblocking Supremal Controllable Sublanguage.
void SupConClosed (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen)
 Supremal Controllable and Closed Sublanguage.
void NormalityConsistencyCheck (const Generator &rL, const EventSet &rOAlph, const Generator &rK)
 NormalityConsistencyCheck: Consistency check for normality input data.
bool IsNormal (const Generator &rL, const EventSet &rOAlph, const Generator &rK)
 IsNormal: checks normality of a language K generated by rK wrt a language L generated by rL and the subset of observable events rOAlph.
bool IsNormal (const System &rPlantGen, const Generator &rSupCandGen)
 IsNormal wrapper.
void ConcatenateFullLanguage (Generator &rGen)
 ConcatenateFullLanguage: concatenate Sigma* to language marked by rGen.
bool SupNorm (const Generator &rL, const EventSet &rOAlph, const Generator &rK, Generator &rResult)
 SupNorm: compute supremal normal sublanguage.
bool SupNormClosed (const Generator &rL, const EventSet &rOAlph, const Generator &rK, Generator &rResult)
 SupNormClosed - compute supremal normal and closed sublanguage.
void SupConNormClosed (const Generator &rL, const EventSet &rCAlph, const EventSet &rOAlph, const Generator &rK, Generator &rResult)
 SupConNormClosed: compute supremal controllable, normal and closed sublanguage.
void SupConNormNB (const Generator &rL, const EventSet &rCAlph, const EventSet &rOAlph, const Generator &rK, Generator &rResult)
 SupConNormNB: compute supremal controllable and normal sublanguage.
bool SupPrefixClosed (const Generator &rK, Generator &rResult)
 SupPrefixClosed: supremal closed sublanguage of K by cancelling all tranistions leading to a non-marked state.
void SupConNormClosedUnchecked (const Generator &rPlantGen, const EventSet &rCAlph, const EventSet &rOAlph, Generator &rObserverGen, Generator &rSupCandGen)
 Supremal Normal Controllable Sublangauge (internal function).
void SupNorm (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen)
 rti wrapper
void SupNormClosed (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen)
 rti wrapper
void SupConNormClosed (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen)
 rti wrapper
void SupConNormNB (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen)
 rti wrapper
bool SupReduce (const System &rPlantGen, const System &rSupGen, System &rReducedSup)
 Supervisor Reduction algorithm.
bool CheckMergibility (Idx stateI, Idx stateJ, std::vector< std::set< Idx > > &rWaitList, Idx cNode, const System &rSupGen, const std::map< Idx, ReductionStateInfo > &rSupStateInfo, const std::map< Idx, Idx > &rState2Class, const std::vector< StateSet > &rClass2States)
 Supervisor Reduction mergibility algorithm.
void SupTconUnchecked (const Generator &rPlantGen, const EventSet &rCAlph, const EventSet &rFAlph, const EventSet &rPAlph, const EventSet &rCPAlph, Generator &rSupCandGen)
void SupTconNBUnchecked (const Generator &rPlantGen, const EventSet &rCAlph, const EventSet &rFAlph, const EventSet &rPAlph, const Generator &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rCompositionMap, Generator &rResGen)
void SupTconNB (const Generator &rPlantGen, const EventSet &rCAlph, const EventSet &rFAlph, const EventSet &rPAlph, const Generator &rSpecGen, Generator &rResGen)
 Nonblocking Supremal TDES-Controllable Sublanguage.
void SupTconNB (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen)
 Nonblocking Supremal TDES-Controllable Sublanguage.
bool IsOmegaControllable (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSupCandGen)
 Test omega controllability.
bool IsOmegaControllable (const System &rPlantGen, const Generator &rSupCandGen)
 Test omega-controllability.
void SupConCmplClosed (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, Generator &rResGen)
 Supremal controllable and complete sublanguage.
void SupConCmplClosed (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen)
 Supremal controllable and complete sublanguage.
void SupConCmplNB (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, Generator &rResGen)
 Supremal controllable and complete sublanguage.
void SupConCmplNB (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen)
 Supremal controllable and complete sublanguage.
void SupConNormCmplNB (const Generator &rPlantGen, const EventSet &rCAlph, const EventSet &rOAlph, const Generator &rSpecGen, Generator &rResGen)
 Supremal controllable, normal and complete sublanguage.
void SupConNormCmplNB (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen)
 rti wrapper
bool OmegaControlledLiveness (Generator &rSupCandGen, const EventSet &rCAlph, const StateSet &rPlantMarking)
bool OmegaControlledLiveness (Generator &rSupCandGen, const EventSet &rCAlph, const StateSet &rPlantMarking, std::map< Idx, EventSet > &rFeedbackMap)
bool OmegaControlledLiveness (Generator &rSupCandGen, const EventSet &rCAlph, const StateSet &rPlantMarking, std::map< Idx, Idx > &rControllerStatesMap, std::map< Idx, EventSet > &rFeedbackMap)
void OmegaSupConProduct (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, std::map< OPSState, Idx > &rProductCompositionMap, Generator &rResGen)
void OmegaSupConNBUnchecked (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, StateSet &rPlantMarking, Generator &rResGen)
void OmegaSupConNormNBUnchecked (const Generator &rPlantGen, const EventSet &rCAlph, const EventSet &rOAlph, const Generator &rSpecGen, StateSet &rPlantMarking, std::map< Idx, Idx > &rObserverStateMap, std::map< Idx, EventSet > &rFeedbackMap, Generator &rResGen)
void OmegaSupConNB (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, Generator &rResGen)
 Omega-synthesis.
void OmegaSupConNB (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen)
 Omega-synthesis.
void OmegaConNB (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, Generator &rResGen)
 Omega-synthesis.
void OmegaConNB (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen)
 Omega-synthesis.
void OmegaSupConNormNB (const Generator &rPlantGen, const EventSet &rOAlph, const EventSet &rCAlph, const Generator &rSpecGen, Generator &rResGen)
 Omega-synthesis for partial observation (experimental!).
void OmegaSupConNormNB (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen)
 Omega-synthesis for partial observation.
void OmegaConNormNB (const Generator &rPlantGen, const EventSet &rOAlph, const EventSet &rCAlph, const Generator &rSpecGen, Generator &rResGen)
 Omega-synthesis for partial observation (experimental!).
void OmegaConNormNB (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen)
 Omega-synthesis for partial observation (experimental!).
void calcBisimulation (Generator &rGenOrig, map< Idx, Idx > &rMapStateToPartition, Generator &rGenPart, vector< Idx > &rNewPartitions)
void calcBisimulation (Generator &rGenOrig, map< Idx, Idx > &rMapStateToPartition, vector< Idx > &rNewPartitions)
void calcBisimulation (Generator &rGenOrig, std::map< Idx, Idx > &rMapStateToPartition, Generator &rGenPart, std::vector< Idx > &rNewPartitions)
 Computation of a bisimulation over a given generator.
void calcBisimulation (Generator &rGenOrig, std::map< Idx, Idx > &rMapStateToPartition, std::vector< Idx > &rNewPartitions)
 Computation of a bisimulation over a given generator.
bool IsMutuallyControllable (const System &rGen1, const System &rGen2)
 Verification of mutual controllability.
bool IsMutuallyControllable (const System &rGen1, const System &rGen2, StateSet &rForbidden1, StateSet &rForbidden2)
 Verification of mutual controllability.
void IsMutuallyControllable (const System &rGen1, const System &rGen2, bool &rRes)
 RTI wrapper.
void calculateDynamicSystemClosedObs (const Generator &rGen, EventSet &rHighAlph, Generator &rGenDyn)
 Computation of the dynamic system for Delta_sigma (reachable states after the occurrence of one high-level event).
void calculateDynamicSystemObs (const Generator &rGen, EventSet &rHighAlph, Generator &rGenDyn)
 Computation of the dynamic system for Delta_obs (local reachability of a marked state).
void calculateDynamicSystemMSA (const Generator &rGen, EventSet &rHighAlph, Generator &rGenDyn)
 Computation of the dynamic system for Delta_msa (local fulfillment of the msa-observer property).
bool recursiveCheckMSAForward (const Generator &rGen, const EventSet &rHighAlph, Idx currentState, StateSet &rDoneStates)
 Check if the msa-observer conditions is fulfilled for a given state.
bool recursiveCheckMSABackward (const Generator &rGen, const TransSetX2EvX1 &rRevTransSet, const EventSet &rHighAlph, Idx currentState, StateSet &rDoneStates)
 Check if the msa-observer conditions is fulfilled for a given state.
void calculateDynamicSystemLCC (const Generator &rGen, const EventSet &rControllableEvents, const EventSet &rHighAlph, Generator &rGenDyn)
 Computation of the dynamic system for Delta_lcc (fulfillment of the local control consistency property).
void recursiveCheckLCC (const TransSetX2EvX1 &rRevTransSet, const EventSet &rControllableEvents, const EventSet &rHighAlph, Idx currentState, StateSet &rDoneStates)
 Find states that fulfill the lcc condition.
Idx calcClosedObserver (const Generator &rGenObs, EventSet &rHighAlph)
 L(G)-observer computation by adding events to the high-level alphabet.
Int calcNaturalObserver (const Generator &rGenObs, EventSet &rHighAlph)
 Lm(G)-observer computation by adding events to the high-level alphabet.
Int calcNaturalObserverLCC (const Generator &rGen, const EventSet &rControllableEvents, EventSet &rHighAlph)
 Lm(G)-observer computation including local control consistency (LCC) by adding events to the high-level alphabet.
Int calcMSAObserver (const Generator &rGen, EventSet &rHighAlph)
 MSA-observer computation by adding events to the high-level alphabet.
Int calcMSAObserverLCC (const Generator &rGen, const EventSet &rControllableEvents, EventSet &rHighAlph)
 MSA-observer computation including local control consistency (LCC) by adding events to the high-level alphabet.
void ExtendHighAlphabet (const Generator &rGen, EventSet &rHighAlph, map< Idx, Idx > &rMapStateToPartition)
bool CheckSplit (const Generator &rGen, const EventSet &rSplitAlphabet, const vector< pair< StateSet, Idx > > &rNondeterministicStates, Idx entryState)
void calcAbstAlphClosed (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
void calcAbstAlphClosed (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
void calcAbstAlphClosed (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans)
void calcAbstAlphObs (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
void calcAbstAlphObs (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
void calcAbstAlphObs (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans)
void calcAbstAlphMSA (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
void calcAbstAlphMSA (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
void calcAbstAlphMSA (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans)
void backwardReachabilityObsOCC (const TransSetX2EvX1 &rTransSetX2EvX1, const EventSet &rControllableEvents, const EventSet &rHighAlph, Idx exitState, Idx currentState, bool controllablePath, map< Idx, map< Idx, bool > > &rExitLocalStatesMap, StateSet &rDoneStates)
void calcAbstAlphObsLCC (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
void calcAbstAlphObsLCC (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans)
void calcAbstAlphMSALCC (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
void calcAbstAlphMSALCC (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans)
bool relabel (Generator &rGenRelabel, EventSet &rControllableEvents, EventSet &rHighAlph, vector< Idx > &rNewPartitions, map< Idx, Idx > &rMapStateToPartition, map< Transition, Transition > &rMapChangedTransReverse, map< Transition, Idx > &rMapChangedTrans, map< Idx, EventSet > &rMapRelabeledEvents)
void insertRelabeledEvents (System &rGenPlant, const map< Idx, set< Idx > > &rMapRelabeledEvents, Alphabet &rNewEvents)
void insertRelabeledEvents (Generator &rGenPlant, const map< Idx, set< Idx > > &rMapRelabeledEvents, EventSet &rNewEvents)
void insertRelabeledEvents (System &rGenPlant, const map< Idx, set< Idx > > &rMapRelabeledEvents)
void insertRelabeledEvents (Generator &rGenPlant, const map< Idx, set< Idx > > &rMapRelabeledEvents)
void calcAbstAlphObs (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, EventRelabelMap &rMapRelabeledEvents)
 Rti convenience wrapper.
void insertRelabeledEvents (Generator &rGenPlant, const EventRelabelMap &rMapRelabeledEvents, EventSet &rNewEvents)
 Rti convenience wrapper.
void insertRelabeledEvents (Generator &rGenPlant, const EventRelabelMap &rMapRelabeledEvents)
 Rti convenience wrapper.
void ExtendHighAlphabet (const Generator &rGenObs, EventSet &rHighAlph, std::map< Idx, Idx > &rMapStateToPartition)
 Extension of the high-level alphabet to achieve the Lm-observer property.
bool CheckSplit (const Generator &rGenObs, const EventSet &rSplitAlphabet, const std::vector< std::pair< StateSet, Idx > > &rNondeterministicStates, Idx entryState)
 Check if the current alphabet splits all local automata with nondeterminims or unobservable transitions.
void calcAbstAlphClosed (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 L(G)-observer computation.
void calcAbstAlphClosed (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 L(G)-observer computation.
void calcAbstAlphClosed (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans)
 L(G)-observer computation.
void calcAbstAlphObs (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 Lm-observer computation.
void calcAbstAlphObs (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 Lm-observer computation.
void calcAbstAlphObs (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans)
 Lm-observer computation.
void calcAbstAlphMSA (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 MSA-observer computation.
void calcAbstAlphMSA (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 MSA-observer computation.
void calcAbstAlphMSA (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans)
 MSA-observer computation.
void calcAbstAlphObsLCC (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 Lm-observer computation including output control consistency (OCC).
void calcAbstAlphObsLCC (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans)
 Lm-observer computation including local control consistency (LCC).
void calcAbstAlphMSALCC (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 MSA-observer computation including local control consistency (LCC).
void calcAbstAlphMSALCC (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans)
 MSA-observer computation including local control consistency (LCC).
bool relabel (Generator &rGenRelabel, EventSet &rControllableEvents, EventSet &rHighAlph, std::vector< Idx > &rNewPartitions, std::map< Idx, Idx > &rMapStateToPartition, std::map< Transition, Transition > &rMapChangedTransReverse, std::map< Transition, Idx > &rMapChangedTrans, std::map< Idx, EventSet > &rMapRelabeledEvents)
 Relabeling algorithm for the computation of an Lm-observer.
void insertRelabeledEvents (System &rGenPlant, const std::map< Idx, std::set< Idx > > &rMapRelabeledEvents, Alphabet &rNewEvents)
 Convenience function for relabeling events in a given generator.
void insertRelabeledEvents (Generator &rGenPlant, const std::map< Idx, std::set< Idx > > &rMapRelabeledEvents, EventSet &rNewEvents)
 Convenience function for relabeling events in a given generator.
void insertRelabeledEvents (System &rGenPlant, const std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 Convenience function for relabeling events in a given generator.
void insertRelabeledEvents (Generator &rGenPlant, const std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 Convenience function for relabeling events in a given generator.
bool IsObs (const Generator &rLowGen, const EventSet &rHighAlph)
 Verification of the natural observer property.
bool IsMSA (const Generator &rLowGen, const EventSet &rHighAlph)
 Verification of the MSA observer property.
bool IsOCC (const System &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 System &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, std::map< Idx, bool > &rLocalStatesMap, StateSet &rDoneStates)
 Function that supports the verification of local control consistency (LCC).
bool LocalObservationConsistency (const System &rPlantGen, const System &rSpecGen, const EventSet &rHighAlph, const EventSet &rObsAlph)
 Supervisor Reduction algorithm.
bool IsCoDiagnosable (const System &rGen, const Generator &rSpec, const vector< const EventSet * > &rAlphabets, std::string &rReportString)
bool DecentralizedDiagnoser (const System &rGen, const Generator &rSpec, const std::vector< const EventSet * > &rAlphabets, std::vector< Diagnoser * > &rDiags, std::string &rReportString)
 Computes decentralized diagnosers for multiple local sites.
bool IsCoDiagnosable (const System &rGen, const Generator &rSpec, const EventSetVector &rAlphabets)
 Function definition for run-time interface.
bool DecentralizedDiagnoser (const System &rGen, const Generator &rSpec, const EventSetVector &rAlphabets, GeneratorVector &rDiags)
 Function definition for run-time interface.
void DecentralizedModularDiagnoser (const SystemVector &rGens, const Generator &rSpec, GeneratorVector &rDiags)
 Function definition for run-time interface.
void cParallel (const std::vector< const System * > &rGens, System &rResGen)
 Parallel composition of multiple generators.
bool IsEventDiagnosable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, string &rReportString)
bool IsEventDiagnosable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap)
 Function definition for run-time interface.
bool IsIndicatorEventDiagnosable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, string &rReportString)
bool IsIndicatorEventDiagnosable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap)
 Function definition for run-time interface.
bool MeetsDiagnosabilityAssumptions (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, string &rReportString)
void ConvertParallelCompositionMap (const map< pair< Idx, Idx >, Idx > &rReverseCompositionMap, map< Idx, pair< Idx, Idx > > &rCompositionMap)
bool IsLive (const System &rGen, string &rReport)
bool CycleOfUnobsEvents (const System &rGen, string &rReport)
bool FailuresUnobservable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, string &rReport)
bool ExistsCycle (const System &rGen, string &rReport)
bool ExistsCycleSearch (const System &rGen, StateSet &rTodo, Idx currState, StateSet statesOnPath, string &rReport)
void CycleStartStates (const System &rGen, StateSet &rCycleOrigins)
 Find all start/end states of cycles of unobservable events in a generator.
void CycleStartStatesSearch (const System &rGen, StateSet &rTodo, Idx currState, StateSet statesOnPath, StateSet &rCycleOriginStates)
 Auxiliary function for CycleStartStates().
bool ExistsViolatingCyclesInGd (System &rGd, const Diagnoser &rGobs, map< pair< Idx, Idx >, Idx > &rReverseCompositionMap, const string &rFailureType, string &rReportString)
void ComputeGobs (const System &rOrigGen, const string &rFailureType, const EventSet &rFailureEvents, Diagnoser &rGobs)
void ComputeGobs (const System &rOrigGen, const AttributeFailureTypeMap &rAttrFTMap, Diagnoser &rGobs)
 Compute G_o for a given generator with a given failure partition (according to Jiang).
void ComputeGd (const Diagnoser &rGobs, map< pair< Idx, Idx >, Idx > &rReverseCompositionMap, System &rGd)
void TrimNonIndicatorTracesOfGd (System &rGd, const Diagnoser &rGobs, const Idx rFailureType, const EventSet &rIndicatorEvents, const map< pair< Idx, Idx >, Idx > &rReverseCompositionMap)
void TrimNonIndicatorTracesOfGdRecursive (System &rGd, const Diagnoser &rGobs, const Idx rFailureType, const EventSet &rIndicatorEvents, map< Idx, pair< Idx, Idx > > &rCompositionMap, Idx state, StateSet &rStatesDone)
void ComputeReachability (const System &rGen, const EventSet &rUnobsEvents, const EventSet &rFailures, Idx State, const AttributeFailureTypeMap &rAttrFTMap, map< Idx, multimap< Idx, DiagLabelSet > > &rReachabilityMap)
void ComputeReachabilityRecursive (const System &rGen, const EventSet &rUnobsEvents, const EventSet &rFailures, Idx State, const AttributeFailureTypeMap &rAttrFTMap, map< Idx, multimap< Idx, DiagLabelSet > > &rReachabilityMap, const DiagLabelSet FToccurred)
TransSet ActiveBackwardTransSet (const System &rGen, Idx state)
 Obtain all transitions from other states into a given state of a generator.
void EventDiagnoser (const System &rOrigGen, const map< string, EventSet > &rFailureTypeMap, Diagnoser &rDiagGen)
void LabelPropagation (const DiagLabelSet &lastLabel, const DiagLabelSet &failureTypes, DiagLabelSet &newLabel)
 Generate a new label.
void LabelCorrection (const multimap< Idx, DiagLabelSet > &mm, AttributeDiagnoserState &attr)
void ConvertParallelCompositionMap (const std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, std::map< Idx, std::pair< Idx, Idx > > &rCompositionMap)
 Convert the reverse composition map of Parallel() by switching first and second entry.
bool IsLive (const System &rGen, std::string &rReport)
 Test if a generator is live.
bool CycleOfUnobsEvents (const System &rGen, std::string &rReport)
 Test if there exist any cycles of unobservable events in a generator.
bool FailuresUnobservable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, std::string &rReport)
 Check if all failure events are unobservable events in a generator's alphabet.
bool ExistsCycle (const System &rGen, std::string &rReport)
 Test if there exist any cycles in a generator.
bool ExistsCycleSearch (const System &rGen, StateSet &rTodo, Idx currState, StateSet statesOnPath, std::string &rReport)
 Auxiliary function for ExistsCycle(const System&, std::string&).
bool ExistsViolatingCyclesInGd (System &rGd, const Diagnoser &rGobs, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, const std::string &rFailureType, std::string &rReportString)
 Remove states with same failure labels from rGd and from rReverseCompositionMap and perform cycle detection.
void ComputeGobs (const System &rOrigGen, const std::string &rFailureType, const EventSet &rFailureEvents, Diagnoser &rGobs)
 Compute G_o for a single failure type of a generator.
void ComputeGd (const Diagnoser &rGobs, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, System &rGd)
 Compute the diagnosability testing generator G_d as a parallel composition of G_o with itself (according to Jiang).
void TrimNonIndicatorTracesOfGd (System &rGd, const Diagnoser &rGobs, const Idx rFailureType, const EventSet &rIndicatorEvents, const std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap)
 Extract all traces of a generator G_d that start with an indicator event that follows a failure event of a certain failure type.
void TrimNonIndicatorTracesOfGdRecursive (System &rGd, const Diagnoser &rGobs, const Idx rFailureType, const EventSet &rIndicatorEvents, std::map< Idx, std::pair< Idx, Idx > > &rCompositionMap, Idx state, StateSet &rStatesDone)
 Auxiliary function for TrimNonIndicatorTracesOfGd().
void ComputeReachability (const System &rGen, const EventSet &rUnobsEvents, const EventSet &rFailures, Idx State, const AttributeFailureTypeMap &rAttrFTMap, std::map< Idx, std::multimap< Idx, DiagLabelSet > > &rReachabilityMap)
 Compute the reachability from a given generator state through a trace that consists of arbitrarily many unobservable events followed by one observable event.
void ComputeReachabilityRecursive (const System &rGen, const EventSet &rUnobsEvents, const EventSet &rFailures, Idx State, const AttributeFailureTypeMap &rAttrFTMap, std::map< Idx, std::multimap< Idx, DiagLabelSet > > &rReachabilityMap, const DiagLabelSet FToccurred)
 Auxiliary function for ComputeReachability(const System&, const EventSet&, const EventSet&, Idx, const AttributeFailureTypeMap&, std::map<Idx,std::multimap<Idx,DiagLabelSet>>&).
void EventDiagnoser (const System &rOrigGen, const std::map< std::string, EventSet > &rFailureTypeMap, Diagnoser &rDiagGen)
 Compute a standard diagnoser from an input generator and a failure partition.
void LabelCorrection (const std::multimap< Idx, DiagLabelSet > &mm, AttributeDiagnoserState &attr)
 Perform label correction on propagated failure type labels.
bool IsLanguageDiagnosable (const System &rGen, const System &rSpec)
 Function definition for run-time interface.
void ComputeGobs (const System &rGenMarkedNonSpecBehaviour, Diagnoser &rGobs)
 Compute G_o for a generator that marks the faulty behaviour of a plant.
void ComputeReachability (const System &rGen, const EventSet &rUnobsEvents, Idx State, map< Idx, multimap< Idx, DiagLabelSet > > &rReachabilityMap)
void ComputeReachabilityRecursive (const System &rGen, const EventSet &rUnobsEvents, Idx State, StateSet done, map< Idx, multimap< Idx, DiagLabelSet > > &rReachabilityMap)
bool IsLanguageDiagnosable (const System &rGen, const System rSpec, std::string &rReportString)
 Test function to verify language-diagnosability.
bool rec_ComputeLoopPreservingObserver (const System &rGen, const EventSet &rInitialHighAlph, EventSet &rHighAlph, const std::vector< Idx > &rDdffVector, Idx numberEvents, Idx currentNumberEvents, Idx currentLocation, EventSet chosenEvents)
 rec_ComputeLoopPreservingObserver(rGen, rInitialHighAlph, rHighAlph, rDdffVector, numberEvents, currentNumberEvents, currentLocation, hosenEvents)
void ComputeReachability (const System &rGen, const EventSet &rUnobsEvents, Idx State, std::map< Idx, std::multimap< Idx, DiagLabelSet > > &rReachabilityMap)
 Compute the reachability from a state of a generator that marks its faulty behaviour.
void ComputeReachabilityRecursive (const System &rGen, const EventSet &rUnobsEvents, Idx State, StateSet done, std::map< Idx, std::multimap< Idx, DiagLabelSet > > &rReachabilityMap)
 Auxiliary function for ComputeReachability(const System&, const EventSet&, Idx State, std::map<Idx,std::multimap< Idx,DiagLabelSet> >&).
bool IsModularDiagnosable (const SystemVector &rGsubs, const GeneratorVector &rKsubs, string &rReportString)
bool IsModularDiagnosable (const vector< const System * > &rGSubs, const vector< const Generator * > &rKSubs, std::string &rReportString)
bool ModularDiagnoser (const SystemVector &rGsubs, const GeneratorVector &rKsubs, GeneratorVector &rDiagSubs, string &rReportString)
bool ModularDiagnoser (const std::vector< const System * > &rGsubs, const std::vector< const Generator * > &rKsubs, std::vector< Diagnoser * > &rDiagsubs, std::string &rReportString)
 Checks modular diagnosability for a system G (which consists of the subsystems rGsubs) with respect to the specification K (consisting of local specifications rKsubs) and the local abstraction alphabets rHighAlphSubs.
bool IsModularDiagnosable (const SystemVector &rGsubs, const GeneratorVector &rKsubs)
 Function definition for run-time interface.
bool ModularDiagnoser (const SystemVector &rGsubs, const GeneratorVector &rKsubs, GeneratorVector &rDiagsubs)
 Function definition for run-time interface.
void cParallel (const vector< System > &rGens, System &rResGen)
bool IsModularDiagnosable (const std::vector< const System * > &rGsubs, const std::vector< const Generator * > &rKsubs, std::string &rReportString)
 Checks modular diagnosability for a system G (which consists of the subsystems rGsubs) with respect to the specification K (consisting of local specifications rKsubs) and the local abstraction alphabets rHighAlphSubs.
void cParallel (const std::vector< System > &rGens, System &rResGen)
 Parallel composition of multiple generators.
bool IsHioConstraintForm (HioConstraint &rHioConstraint, StateSet &rQY, StateSet &rQU, EventSet &rErrEvSet, TransSet &rErrTrSet, StateSet &rErrStSet, std::string &rReportStr)
 IsHioConstraintForm: check if rHioConstraint is in I/O-constraint form and assign state attributes.
bool IsHioConstraintForm (HioConstraint &rHioConstraint, std::string &rReportStr)
 IsHioConstraintForm: check if rHioConstraint is in I/O-constraint form and assign state attributes.
bool IsHioConstraintForm (HioConstraint &rHioConstraint)
 IsHioConstraintForm: check if rHioConstraint is in I/O-constraint form and assign state attributes.
void HioStatePartition (HioConstraint &rConstraint)
 Function definition for run-time interface.
bool IsHioControllerForm (HioController &rHioController, StateSet &rQUc, StateSet &rQYP, StateSet &rQUp, StateSet &rQYcUp, EventSet &rErrEvSet, TransSet &rErrTrSet, StateSet &rErrStSet, std::string &rReportStr)
 IsHioControllerForm: check if rHioController is in I/O-controller form and assign state attributes.
bool IsHioControllerForm (HioController &rHioController, std::string &rReportStr)
 IsHioControllerForm: check if rHioController is in I/O-controller form and assign state attributes.
bool IsHioControllerForm (HioController &rHioController)
 IsHioControllerForm: check if rHioController is in I/O-controller form and assign state attributes.
void HioStatePartition (HioController &rController)
 Function definition for run-time interface.
bool IsHioEnvironmentForm (HioEnvironment &rHioEnvironment, StateSet &rQYe, StateSet &rQUe, StateSet &rQUl, StateSet &rQYlUe, EventSet &rErrEvSet, TransSet &rErrTrSet, StateSet &rErrStSet, std::string &rReportStr)
 IsHioEnvironmentForm: check if rHioEnvironment is in I/O-environment form and assign state attributes.
bool IsHioEnvironmentForm (HioEnvironment &rHioEnvironment, std::string &rReportStr)
 IsHioEnvironmentForm: check if rHioEnvironment is in I/O-environment form and assign state attributes.
bool IsHioEnvironmentForm (HioEnvironment &rHioEnvironment)
 IsHioEnvironmentForm: check if rHioEnvironment is in I/O-environment form and assign state attributes.
void HioStatePartition (HioEnvironment &rEnvironment)
 Function definition for run-time interface.
bool SupNormSP (Generator &rL, const EventSet &rOAlph, const Generator &rK, Generator &rResult)
bool CompleteSynth (const Generator &rPlant, const EventSet rCAlph, const Generator &rSpec, Generator &rClosedLoop)
 CompleteSynth: compute supremal complete and controllable (and closed) sublanguage.
bool NormalCompleteSynth (Generator &rPlant, const EventSet &rCAlph, const EventSet &rOAlph, const Generator &rSpec, Generator &rClosedLoop)
 NormalCompleteSynth: compute normal, complete and controllable (and closed) sublanguage.
bool NormalCompleteSynthNB (Generator &rPlant, const EventSet &rCAlph, const EventSet &rOAlph, const Generator &rSpec, Generator &rClosedLoop)
 NormalCompleteSynthNB: compute normal, complete, controllable and nonblocking sublanguage.
Generator HioSortCL (const EventSet &rYc, const EventSet &rUc, const EventSet &rYp, const EventSet &rUp, const EventSet &rYe, const EventSet &rUe)
 IoSortCL: returns IO-sorting structure required for closed loops.
void HioFreeInput (const Generator &rGen, const EventSet &rInput, const EventSet &rOutput, Generator &rResGen, const std::string &rErrState1, const std::string &rErrState2, Idx &rErrState1Idx, Idx &rErrState2Idx)
 HioFreeInput: extend generator by obviously missing input transitions.
void HioFreeInput (const Generator &rGen, const EventSet &rInput, const EventSet &rOutput, Generator &rResGen, const std::string &rErrState1, const std::string &rErrState2)
 HioFreeInput: extend generator by obviously missing input transitions.
void HioFreeInput (const Generator &rGen, const EventSet &rInput, const EventSet &rOutput, Generator &rResGen)
 HioFreeInput: extend generator by obviously missing input transitions.
void HioFreeInput (const HioPlant &rPlant, HioPlant &rResPlant)
 HioFreeInput: extend HioPlant by obviously missing input transitions.
void HioFreeInput (const HioController &rController, HioController &rResController)
 HioFreeInput: extend HioController by obviously missing input transitions.
void HioFreeInput (const HioEnvironment &rEnvironment, HioEnvironment &rResEnvironment)
 HioFreeInput: extend HioEnvironment by obviously missing input transitions.
void HioFreeInput (const HioConstraint &rConstraint, HioConstraint &rResConstraint)
 HioFreeInput: extend HioConstraint by obviously missing input transitions.
void HioFreeInput (HioPlant &rPlant)
 HioFreeInput: convenience interface to faudes::HioFreeInput(const HioPlant&, HioPlant).
void HioFreeInput (HioController &rController)
 HioFreeInput: convenience interface to faudes::HioFreeInput(const HioController&, HioController).
void HioFreeInput (HioEnvironment &rEnvironment)
 HioFreeInput: convenience interface to faudes::HioFreeInput(const HioEnvironment&, HioEnvironment).
void HioFreeInput (HioConstraint &rConstraint)
 HioFreeInput: convenience interface to faudes::HioFreeInput(const HioConstraint&, HioConstraint).
void MarkHioShuffle (const Generator &rGen1, const Generator &rGen2, const std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, Generator &rShuffle)
 MarkHioShuffle: marking rule for HioShuffle() in case of marked parameters rGen1 and rGen2 - UNDER CONSTRUCTION.
void MarkAlternationAB (const EventSet rAset, const EventSet rBset, Generator &rAltAB)
 MarkAlternationAB: returns Generator marking the alternation of Aset-transitions with Bset-transitions.
void HioShuffleUnchecked (const Generator &rPlantA, const Generator &rPlantB, const EventSet &rYp, const EventSet &rUp, const EventSet &rYe, const EventSet &rUe, Generator &rIOShuffAB)
 HioShuffleUnchecked: IO-shuffle of rPlantA and rPlantB according to definition, no parameter check.
void HioShuffle (const Generator &rPlantA, const Generator &rPlantB, const EventSet &rYp, const EventSet &rUp, const EventSet &rYe, const EventSet &rUe, Generator &rIOShuffAB)
 HioShuffle: IO-shuffle of rPlantA and rPlantB according to definition.
void HioShuffle (const HioPlant &rPlantA, const HioPlant &rPlantB, HioPlant &rIOShuffAB)
 HioShuffle: IO-shuffle of rPlantA and rPlantB according to definition.
void CheapAltAnB (const EventSet rAset, const EventSet rBset, const int Depth, Generator &rAltAnB)
 CheapAltAnB: returns Generator of the following specification: "After a maximum of n (=depth) pairs of A-transitions, a B-transition has to occur!".
void CheapAltAB (const EventSet rAset, const EventSet rBset, const int Depth, Generator &rAltAB)
 CheapAltAB: returns Generator of the following specification: "After a maximum of n (=depth) pairs of A-transitions, a B-transition has to occur and vice-versa!".
void HioShuffleTU (const Generator &rPlantA, const Generator &rPlantB, const EventSet &rYp, const EventSet &rUp, const EventSet &rYe, const EventSet &rUe, const int Depth, Generator &rIOShuffAB)
 HioShuffleTU: IO-shuffle of rPlantA and rPlantB according to definition with additional forced alternation of depth Depth (see CheapAltAB()) between A- and B-events.
void SearchYclessScc (const Idx state, int &rcount,const Generator &rGen, const EventSet &rYc, const bool UnMarkedOnly, StateSet &rNewStates, std::stack< Idx > &rSTACK, StateSet &rStackStates, std::map< const Idx, int > &rDFN, std::map< const Idx, int > &rLOWLINK, std::set< StateSet > &rSccSet, StateSet &rRoots)
 SearchYclessSCC: Search for strongly connected ycless components (YC-less SCC's).
bool YclessScc (const Generator &rGen, const EventSet &rYc, std::set< StateSet > &rSccSet, StateSet &rRoots)
 YclessSCC: Search for strongly connected ycless components (YC-less SCC's) - convenience api.
bool YclessUnmarkedScc (const Generator &rGen, const EventSet &rYc, std::set< StateSet > &rSccSet, StateSet &rRoots)
 YclessUnmarkedSCC: Search for strongly connected ycless components (YC-less SCC's) consisting of unmarked states only.
bool YclessScc (const Generator &rGen, const EventSet &rYc, std::set< StateSet > &rSccSet)
bool IsYcLive (const Generator &rGen, const EventSet &rYc)
 IsYcLive: This function checks if generator is Yc-live.
void WriteStateSets (const std::set< StateSet > &rStateSets)
 WriteStateSets: Write set of StateSet's to console (indeces).
void WriteStateSets (const Generator &rGen, const std::set< StateSet > &rStateSets)
 WriteStateSets: Write set of StateSet's to console (symbolic state names taken from rGen).
void SccEntries (const Generator &rGen, const std::set< StateSet > &rSccSet, StateSet &rEntryStates, TransSetX2EvX1 &rEntryTransSet)
 SCCEntries: figure entry states and entry transitions of strongly connected components rSccSet of rGen.
void CloneScc (Generator &rGen, const StateSet &rScc, std::set< StateSet > &rSccSet, const Idx EntryState, StateSet &rEntryStates, TransSetX2EvX1 &rEntryTransSet)
 cloneSCC: makes a copy (clone) of strongly connected component (rSCC) of the generator and moves all transitions leading to some entry state EntryState of this SCC to the copy of EntryState.
void CloneUnMarkedScc (Generator &rGen, const StateSet &rScc, const Idx EntryState, const StateSet &rEntryStates, TransSetX2EvX1 &rEntryTransSet)
 CloneUnMarkedSCC: makes a copy (clone) of strongly connected unmarked component (rSCC) of rGen.
void YcAcyclic (const Generator &rGen, const EventSet &rYc, Generator &rResGen)
 YcAcyclic: Computes the supremal(?) Yc-acyclic sublanguage of L(Gen).
void ConstrSynth_Beta (Generator &rPlant, const EventSet &rYp, const EventSet &rUp, const Generator &rLocConstr, Generator &rOpConstraint)
 ConstrSynth_Beta: compute operator constraint Sp for plant under environment constraint Sl such that plant is complete & Yp-live wrt both constraints - Beta Version.
void HioSynthUnchecked (const Generator &rPlant, const Generator &rSpec, const Generator &rConstr, const Generator &rLocConstr, const EventSet &rYc, const EventSet &rUc, const EventSet &rYp, const EventSet &rUp, const EventSet &rYel, const EventSet &rUel, Generator &rController)
 HioSynthUnchecked: I/O controller synthesis procedure, no parameter check.
void HioSynth (const Generator &rPlant, const Generator &rSpec, const Generator &rConstr, const Generator &rLocConstr, const EventSet &rYc, const EventSet &rUc, const EventSet &rYp, const EventSet &rUp, const EventSet &rYel, const EventSet &rUel, Generator &rController)
 HioSynthUnchecked: I/O controller synthesis procedure.
void HioSynthMonolithic (const HioPlant &rPlant, const HioPlant &rSpec, const HioConstraint &rSc, const HioConstraint &rSp, const HioConstraint &rSe, HioController &rController)
 HioSynthMonolithic: I/O controller synthesis procedure for monolithic plant.
void HioSynthHierarchical (const HioPlant &rHioShuffle, const HioEnvironment &rEnvironment, const HioPlant &rSpec, const Generator &rIntConstr, const HioConstraint &rSc, const HioConstraint &rSl, HioController &rController)
 HioSynthHierarchical: I/O controller synthesis procedure for I/O-shuffle of i plants and their interaction via an I/O environment.
void HioShuffle_Musunoi (const HioPlant &rPlantA, const HioPlant &rPlantB, int depth, Generator &rIOShuffAB)
void HioSynth_Musunoi (const Generator &rPlant, const HioPlant &rSpec, const Generator &rConstr, const Generator &rLocConstr, const EventSet &rYp, const EventSet &rUp, Generator &rController)
bool YclessSCC (const Generator &rGen, const EventSet &rYc, std::set< StateSet > &rSccSet)
 YclessSCC: Search for strongly connected ycless components (YC-less SCC's) - convenience api.
void AdjustHioController (const HioController &rHioController, const HioModule *rHioModule1, const HioModule *rHioModule2, HioController &rResEnv)
void GroupHioModules (const std::vector< HioModule * > &rChildren, HioModule &rParentModule)
 GroupHioModules: This function groups two or more HioModules to a new HioModule.
void CreateSpec (int mType[5], HioPlant &rHioSpec, Generator &constrP, Generator &constrE)
 This function creates new specification given by the type ("xxxxx") Note: The core of this function is a template specification model (SpecCB12.gen).
void CreateConstraint (int mType[5], Generator &constrP, Generator &constrE)
 This function creates constraints which describe the condition of completeness and Yp-liveness of a Specification.
bool IsHioPlantForm (HioPlant &rHioPlant, StateSet &rQYpYe, StateSet &rQUp, StateSet &rQUe, EventSet &rErrEvSet, TransSet &rErrTrSet, StateSet &rErrStSet, std::string &rReportStr)
 IsHioPlantForm: check if rHioPlant is in I/O-plant form and assign state attributes.
bool IsHioPlantForm (HioPlant &rHioPlant, std::string &rReportStr)
 IsHioPlantForm: check if rHioPlant is in I/O-plant form and assign state attributes.
bool IsHioPlantForm (HioPlant &rHioPlant)
 IsHioPlantForm: check if rHioPlant is in I/O-plant form and assign state attributes.
void HioStatePartition (HioPlant &rPlant)
 Function definition for run-time interface.
bool IsIoSystem (const IoSystem &rIoSystem, StateSet &rQU, StateSet &rQY, StateSet &rQErr)
 Test whether the system satisfies basic I/O conditions.
bool IsIoSystem (IoSystem &rIoSystem)
 Test whether the system satisfies the IO conditions.
void IoStatePartition (IoSystem &rIoSystem)
 Construct io state partition.
bool IsInputLocallyFree (IoSystem &rIoSystem)
 Test whether the system has a locally free input.
bool IsInputLocallyFree (const IoSystem &rIoSystem, StateSet &rQErr)
 Test whether the system has a locally free input.
bool IsInputOmegaFree (IoSystem &rIoSystem)
 Test whether the system behaviour has exhibits a free input.
bool IsInputOmegaFree (const IoSystem &rIoSystem, StateSet &rQErr)
 Test whether the system behaviour exhibits a free input.
void IoFreeInput (IoSystem &rIoSystem)
 Enable all input events for each input state.
void IoFreeInput (Generator &rIoSystem, const EventSet &rUAlph)
 Enable all input events for each input state.
void RemoveIoDummyStates (IoSystem &rIoSystem)
 Remove dummy states.
void IoSynthesisNB (const IoSystem &rPlant, const Generator &rSpec, IoSystem &rSup)
 IO system synthesis.
void IoSynthesis (const IoSystem &rPlant, const Generator &rSpec, IoSystem &rSup)
 IO system synthesis.
bool IsStronglyCoaccessible (const MtcSystem &rGen)
 RTI wrapper function.
bool IsStronglyTrim (const MtcSystem &rGen)
 RTI wrapper function.
void StronglyCoaccessible (MtcSystem &rGen)
 RTI wrapper function.
void StronglyCoaccessible (const MtcSystem &rGen, MtcSystem &rRes)
 RTI wrapper function.
void StronglyTrim (MtcSystem &rGen)
 RTI wrapper function.
void StronglyTrim (const MtcSystem &rGen, MtcSystem &rRes)
 RTI wrapper function.
Idx calcNaturalObserver (const MtcSystem &rGen, EventSet &rHighAlph)
 Calculate a colored natural observer by extending a given high-level alphabet.
void calcAbstAlphObs (MtcSystem &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
void calcAbstAlphObs (MtcSystem &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
void calcAbstAlphObs (MtcSystem &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans)
void calculateDynamicSystemObs (const MtcSystem &rGen, EventSet &rHighAlph, Generator &rGenDyn)
 Computation of the dynamic system for an Lm-observer.
void calcAbstAlphObs (MtcSystem &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 Lm-observer computation.
void calcAbstAlphObs (MtcSystem &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 Lm-observer computation.
void calcAbstAlphObs (MtcSystem &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans)
 Lm-observer computation.
bool IsMtcObs (const MtcSystem &rLowGen, const EventSet &rHighAlph)
 Verification of the observer property.
void mtcParallel (const MtcSystem &rGen1, const MtcSystem &rGen2, MtcSystem &rResGen)
 Parallel composition of two colored marking generators, controllability status is observed.
void mtcParallel (const MtcSystem &rGen1, const MtcSystem &rGen2, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, MtcSystem &rResGen)
 Parallel composition of two MtcSystems.
void ComposedColorSet (const MtcSystem &rGen1, const Idx stdidx1, ColorSet &colors1, const MtcSystem &rGen2, const Idx stdidx2, ColorSet &colors2, ColorSet &composedSet)
 Compose the color set for a state combined from two states in two distinct automata.
void mtcUniqueInit (MtcSystem &rGen)
void mtcDeterministic (const MtcSystem &rGen, MtcSystem &rResGen)
 Make generator deterministic.
void mtcDeterministic (const MtcSystem &rGen, std::map< Idx, StateSet > &rEntryStatesMap, MtcSystem &rResGen)
 Make generator deterministic.
void mtcDeterministic (const MtcSystem &rGen, std::vector< StateSet > &rPowerStates, std::vector< Idx > &rDetStates, MtcSystem &rResGen)
 Make generator deterministic.
void mtcProjectNonDet (MtcSystem &rGen, const EventSet &rProjectAlphabet)
 Project generator to alphabet rProjectAlphabet.
void mtcProjectNonDet (const MtcSystem &rGen, const EventSet &rProjectAlphabet, MtcSystem &rResGen)
 Project generator to alphabet rProjectAlphabet.
void mtcProject (const MtcSystem &rGen, const EventSet &rProjectAlphabet, MtcSystem &rResGen)
 Minimized Deterministic projection.
void mtcProject (const MtcSystem &rGen, const EventSet &rProjectAlphabet, std::map< Idx, StateSet > &rEntryStatesMap, MtcSystem &rResGen)
 Minimized Deterministic projection.
void mtcInvProject (MtcSystem &rGen, const EventSet &rProjectAlphabet)
 Inverse projection.
void mtcInvProject (const MtcSystem &rGen, const EventSet &rProjectAlphabet, MtcSystem &rResGen)
 RTI wrapper.
void SearchScc (const Idx state, int &rCount, const Generator &rGen, StateSet &rNewStates, std::stack< Idx > &rSTACK, StateSet &rStackStates, std::map< const Idx, int > &rDFN, std::map< const Idx, int > &rLOWLINK, std::set< StateSet > &rSccSet, StateSet &rRoots)
 Search for strongly connected components (SCC)*** This function partitions the stateset of a generator into equivalence classes such that states x1 and x2 are equivalent iff there is a path from x1 to x2 AND a path from x2 to x1.
bool ComputeSCC (const Generator &rGen, std::set< StateSet > &rSccSet, StateSet &rRoots)
 Computes the strongly connected components (SCCs) of an automaton.
void ColoredSCC (MtcSystem &rGen, ColorSet &rColors, std::set< StateSet > &rColoredSCCs)
 Compute all strongly connected components (SCCs) in a colored marking generator (CMG) that are marked with a given set of colors.
bool CheckRedundantColor (MtcSystem rGen, Idx redundantColor)
 Check if a color in a colored marking generator is redundant for the supervisor synthesis.
void OptimalColorSet (const MtcSystem &rGen, ColorSet &rOptimalColors, EventSet &rHighAlph)
 Compute an optimal subset of the colors that should be removed.
void rec_OptimalColorSet (const MtcSystem &rGen, const std::vector< Idx > &rColorVector, Idx colorNumber, ColorSet &rOptimalColors, Idx &rOptimalNumberStates, Idx &rOptimalNumberColors, const EventSet &rHighAlph, EventSet &rOptimalHighAlph)
 Recursively find an optimal set of colors to be removed.
void mtcStateMin (MtcSystem &rGen, MtcSystem &rResGen)
 State Minimization This function implements the (n*log n) set partitioning algorithm by John E.
void mtcStateMin (MtcSystem &rGen, MtcSystem &rResGen, std::vector< StateSet > &rSubsets, std::vector< Idx > &rNewIndices)
 State Minimization This function implements the (n*log n) set partitioning algorithm by John E.
void mtcStateMin (const MtcSystem &rGen, MtcSystem &rResGen)
 RTI wrapper.
void mtcSupConNB (const MtcSystem &rPlantGen, const MtcSystem &rSpecGen, MtcSystem &rResGen)
 Nonblocking Supremal Controllable Sublanguage (wrapper function).
void mtcSupConNB (const MtcSystem &rPlantGen, const MtcSystem &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, MtcSystem &rResGen)
 Nonblocking Supremal Controllable Sublanguage.
void mtcSupConClosed (const MtcSystem &rPlantGen, const MtcSystem &rSpecGen, MtcSystem &rResGen)
 Supremal Controllable Sublanguage (wrapper function).
void mtcSupConClosed (const MtcSystem &rPlantGen, const MtcSystem &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, MtcSystem &rResGen)
 Supremal Controllable Sublanguage.
void mtcSupConParallel (const MtcSystem &rPlantGen, const MtcSystem &rSpecGen, const EventSet &rUAlph, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, MtcSystem &rResGen)
 Fast parallel composition for computation for the mtcSupConNB.
void mtcSupConUnchecked (const MtcSystem &rPlantGen, const EventSet &rCAlph, MtcSystem &rSupGen)
 Supremal Controllable Sublangauge (Real SupCon function; unchecked).
bool ccTrim (const Generator &gen, Generator &trimGen)
 A more efficient Trim() operation.
bool IsConditionalClosed (const GeneratorVector &specVect, const Generator &pk, const GeneratorVector &genVect, const Generator &gk)
 Conditionalclosedness Checking Algorithm.
bool IsConditionalControllable (const GeneratorVector &specVect, const Generator &pk, const GeneratorVector &genVect, const Generator &gk, const EventSet &ACntrl)
 Conditionalcontrollability Checking Algorithm.
bool IsConditionalDecomposable (const Generator &gen, const EventSetVector &rAlphabets, const EventSet &ek, Generator &proof)
 Conditionaldecomposability Checking Algorithm.
void ConDecExtension (const Generator &gen, const EventSetVector &rAlphabets, EventSet &ek)
 Conditionaldecomposability Extension Algorithm.
Generator ComputeTildeG (const EventSet &unionset, const EventSetVector &ee, const EventSet &ek, const Generator &gen)
bool isExtendedEk (const Generator &tildeGen, const Generator &rGen, EventSet &ek)
bool SupConditionalControllable (const Generator &gen, const GeneratorVector &genVector, const EventSet &ACntrl, const EventSet &InitEk, GeneratorVector &supVector, Generator &Coord)
 Conditionalcontrollability Checking Algorithm.
StateSet Transient (const PushdownGenerator &pd)
 Get all states that are the starting state of a lambda reading transition.
PushdownGenerator Rnce (const PushdownGenerator &pd, const System &s)
 Remove non-controllable ears from a generator.
PushdownGenerator Times (const System &reg, const PushdownGenerator &pd)
 synchronous product generator of a pushdown generator and a regular generator
void IntersectEvents (const System &s, const PushdownGenerator &pd, PushdownGenerator &rPd)
 Adds the intersection of events of the first two generators to the result generator.
PushdownGenerator Split (const PushdownGenerator &pd)
 Splits the states of a pushdown generator into heads and ears.
void PushdownNonblock (const PushdownGenerator &pd, PushdownGenerator &res, bool print=false)
 Make a pushdown generator nonblocking.
void CorrectEvents (const PushdownGenerator &correctPd, PushdownGenerator &pd)
 Sets controllability and observability flags for a pushdown generator's events to the event flags of another pushdown generator.
bool Ts (const PushdownGenerator &pd, Idx state)
 Test a state for reachability.
bool Te (const PushdownGenerator &pd, const Transition &trans, const std::vector< Idx > &pop, const std::vector< Idx > &push)
 Test a transition for reachability.
bool Ruls1 (Idx state, const PushdownGenerator &pd)
PushdownGenerator Ruls (const PushdownGenerator &pd)
 Remove useless states of a pushdown generator.
void PushdownAccessible (const PushdownGenerator &pd, PushdownGenerator &res)
 Construct the accessible part of a pushdown generator.
PushdownGenerator Ccs (const PushdownGenerator &contr, const System &plant)
 Single execution of the loop to construct a minimal restrictive sound controller.
PushdownGenerator Ccl (const PushdownGenerator &contr, const System &plant, Idx iteration=0)
 Looped exectuion of to construct a minimal restrictive sound controller.
void PushdownConstructController (const PushdownGenerator &spec, const System &plant, PushdownGenerator &res)
 Construct a minimal restrictive sound controller.
int timeval_subtract (timeval *result, timeval *x, timeval *y)
 from http://www.gnu.org/software/libc/manual/html_node/Elapsed-Time.html Calculates time difference x - y.
GrammarSymbolWordSet PostCl (const GrammarSymbolVector &word)
 Construct the postfix closure of a word.
GrammarSymbolWordSet Fds (const Grammar &gr)
 Determine certain words in a grammar.
GrammarSymbolWordMap First1 (const Grammar &gr, const GrammarSymbolWordMap &f, bool *madeChanges)
 Updates the function which maps words to their first possible terminal symbols.
GrammarSymbolWordMap FirstL (const Grammar &gr, const GrammarSymbolWordMap &f)
 Builds a function that maps words to their first possible terminal symbols by recursively calling First1.
std::set< TerminalFirstA (const Grammar &gr, const GrammarSymbolVector &word)
 Determines which terminals can come first for a given word.
std::set< TerminalFirst (const Grammar &gr, const GrammarSymbolVector &word)
 Determines which terminals can come first for a given word.
std::set< TerminalFirstRed (const Grammar &gr, const GrammarSymbolVector &word)
 Calls first, but only if all symbols in the word are in the grammar as well.
NonterminalPtr Filter1 (const std::set< Nonterminal > &symbolSet, const GrammarSymbolVector &w)
 Extract the first symbol from the word that is in the symbol set.
std::set< TerminalFirstAll (const Grammar &gr, const GrammarSymbolVector &word)
 Determines which terminals can come first for a given word and ensures that the word can be entirely reduced.
std::set< TerminalFirstLeq1 (const Grammar &gr, uint k, const GrammarSymbolVector &word)
 Determine which terminals can come first for a given word for any k <= 1.
void WriteMap (GrammarSymbolWordMap f, bool changed=false)
 Convenience print function for first map function.
std::set< Lr1ConfigurationDesc11 (const Grammar &gr, uint k, const Lr1Configuration &config)
 Obtain the immediate descendants of a configuration if the dot were pushed one nonterminal further.
std::set< Lr1ConfigurationDesc1 (const Grammar &gr, uint k, const std::set< Lr1Configuration > &configs)
 Obtain the immediate descendants of configurations if the dot were pushed one nonterminal further.
std::set< Lr1ConfigurationDesc (const Grammar &gr, uint k, const std::set< Lr1Configuration > &config)
 Obtain all descendants of a configuration set.
std::set< Lr1ConfigurationPassesX (const Lr1Configuration &config, const GrammarSymbolPtr &symbol)
 Try to shift the dot in a configuration over a specified symbol.
std::set< Lr1ConfigurationBasis (const std::set< Lr1Configuration > configs, const GrammarSymbolPtr &symbol)
 Try to shift the dots in a configuration set over a specified symbol.
std::set< Lr1ConfigurationGoTo (const Grammar &gr, uint k, const std::set< Lr1Configuration > configs, const GrammarSymbolPtr &symbol)
 Try to shift the dots in a configurations set and obtain the shifted configuration set's descendants.
LrmTransitionMap Lrm1 (const Grammar &gr, uint k, const Lr1ConfigurationSetSet &configSetSet)
 Generate outgoing transitions for an LR(k) machine for a given configuration set.
std::pair< LrmTransitionMap,
Lr1ConfigurationSetSet
LrmLoop (const Grammar &gr, uint k, const LrmTransitionMap &transitions, const Lr1ConfigurationSetSet &states, Lr1ConfigurationSetSet examineStates)
 Recursively generate all transitions and states for an LR(k) machine.
std::set< Lr1ConfigurationDescInitial (const Grammar &gr)
 Determine the initial parser configurations for a grammar.
std::set< Lr1ConfigurationValidEmpty (const Grammar &gr, uint k)
 Determine the descendants of the initial parser configurations.
GotoGenerator Lrm (const Grammar &gr, uint k)
 Generate an LR(k) machine for a grammar.
Grammar Aug (const Grammar &gr, const Nonterminal &startSymbol, const Terminal &augSymbol)
 Augments the grammar with a nonterminal S and a terminal $ such that a new grammar production will be inserted.
std::set< IdxGeneratorGoto (const GotoGenerator &gotoGen, Idx state, const GrammarSymbolPtr &symbol)
 Find the successor states of a state for a given input symbol.
std::vector< IdxGeneratorGotoSeq (const GotoGenerator &gotoGen, Idx startState, const GrammarSymbolVector &word)
 Find the successor state sequence of a state for a given input word.
std::set< Lr1ParserActionLrpShiftRules (const Grammar &gr, const Grammar &augGr, const GotoGenerator &gotoGen, uint k)
 construct the parsing rules for shifting from a grammar and its LR(k) machine
std::set< Lr1ParserActionLrpReduceRules (const Grammar &gr, const Grammar &augGr, const GotoGenerator &gotoGen, uint k)
 construct the parsing rules for reducing from a grammar and its LR(k) machine
std::set< Lr1ParserActionLrpRules (const Grammar &gr, const Grammar &augGr, const GotoGenerator &gotoGen, uint k)
 construct all parsing rules from a grammar and its LR(k) machine
Lr1Parser Lrp (const Grammar &gr, const Grammar &augGr, const GotoGenerator &gotoGen, uint k, const Terminal &augSymbol)
 construct an LR(k) parser from a grammar and its LR(k) machine
PushdownGenerator Gp2Pp (const GotoGenerator &gotoGen, const Lr1Parser &parser)
 Converts a parser into a pushdown generator.
PushdownGenerator Dim (const PushdownGenerator &pd, const Terminal &augSymbol)
 Remove the augmentation from the generator (diminish it).
std::set< NonterminalFilter (const std::set< Nonterminal > &symbolSet, const GrammarSymbolVector &w)
 Extract all symbols from the word that are in the symbol set.
std::set< NonterminalRnpp1 (const Grammar &gr, const std::set< Nonterminal > &ntSet)
 Find all nonterminals that are eliminable in one step and assuming that a certain set of nonterminals has already been eliminated.
std::set< NonterminalRnppl (const Grammar &gr, const std::set< Nonterminal > &ntSet)
 Find all nonterminals that are eliminable in as many steps as needed and assuming that a certain set of nonterminals has already been eliminated.
Grammar Rnpp (const Grammar &gr)
 Remove all productions from a grammar that are nonproductive, i.
Grammar Sp2Lr (const PushdownGenerator &pd)
 Transform a simple pushdown generator into an LR(1) grammar.
Grammar Sp2Lr2 (const PushdownGenerator &pd)
 Transform a simple pushdown generator into an LR(1) grammar.
Grammar Rup (const Grammar &gr)
 Remove all unreachable productions and nonterminals from the grammar.
PushdownGenerator RenQ (const std::string word, const PushdownGenerator &pd)
 Associates each state of the generator with an annotation.
PushdownGenerator RenG (const std::string word, const PushdownGenerator &pd)
 Adds an annotation to each stack symbol of the generator.
PushdownGenerator Rep0 (const PushdownGenerator &pd)
 Removes all edges popping lambda.
PushdownGenerator Rpp (const PushdownGenerator &pd)
 Restricts a pushdown generator to a pushdown generator with transitions that are either read (p,a,lambda,lambda,q), pop (p,lambda,x,lambda,q) or push (p,lambda,x,yx,q).
void PrintTransitions (const std::multimap< Transition, std::pair< std::vector< StackSymbol >, std::vector< StackSymbol > > > &transitions)
 For debugging, prints a transitions with their pop and push attributes.
PushdownGenerator Rep2 (const PushdownGenerator &pd)
 Removes transitions popping more than one stack symbol.
PushdownGenerator Nda (const PushdownGenerator &pd)
 Input must have passed Rpp! remodells the generator to prevent double (or multiple) acceptance of the same input string.
PushdownGenerator TrimStackSymbols (const PushdownGenerator &pd)
 Delete stack symbols from the generator that are not used in any of the transitions.
PushdownGenerator RemoveUselessTransitions (const PushdownGenerator &pd)
 Remove certain transitions that can never be used because their pop symbol can never be the stack top.
StackSymbolSet GetPossibleStackTops (const PushdownGenerator &pd, const StateSet &examinedStates, Idx q)
 Get all possible stack top symbols for a state.
bool CompareGsVector (const GrammarSymbolVector &lhs, const GrammarSymbolVector &rhs)
bool EqualsGsVector (const GrammarSymbolVector &lhs, const GrammarSymbolVector &rhs)
bool CompareGs (const GrammarSymbolPtr &lhs, const GrammarSymbolPtr &rhs)
bool ContainsWord (const GrammarSymbolWordSet &set, const GrammarSymbolVector &word)
 Test if a given set of words contains a specific word.
bool CompareConfigSet (const std::set< Lr1Configuration > &lhs, const std::set< Lr1Configuration > &rhs)
bool CompareConfigGsPair (const ConfigSetGsPair &lhs, const ConfigSetGsPair &rhs)
std::string ConfigSetToStr (const std::set< Lr1Configuration > &configs)
 To string function for configuration sets.
std::string ConfigSetSetToStr (const Lr1ConfigurationSetSet configSetSet)
 To string function for configuration set sets.
std::string TransitionMapToStr (const LrmTransitionMap &transitionMap)
 To string function for a transition map.
void TestAlternativeAccessible (Generator &rGen)
 Alternative accessibility algorithm.
void TestTransientStates ()
 Test if Transient chooses the right states.
void TestTransientStatesEmpty ()
 Test if Transient chooses the right states.
void TestRnceRemoveEars ()
 Test if uncontrollable ears are correctly removed.
void TestIntersectEventsAll ()
 test for intersect events
void TestTimesStates ()
 test for the the right number of states and for correctly set merge states
void TestTimesStackSymbols ()
 Test if all stack symbols and the stack bottom are set correctly.
void TestTimesTransitions ()
 Test if the number of lambda transitions and the total number of transitions is right.
void TestSplitStackSymbols ()
 Test if the stack bottom remains unchanged and all stack symbols from the old generator are in the split generator.
void TestSplitStates ()
 Test if the states have been split correctly into heads and ears.
void TestSplitTransitionsHeadToEar ()
 Test if all transitions originating at heads end at ears and if the pop/push of the transition is correctly set.
void TestSplitTransitionsEarToHead ()
 Test if all transitions originating at ears end at heads and if the pop of the transition is correctly set.
void TestTsUnreachable ()
 Test Te with transitions that are unreachable.
void TestTeReachable ()
 Test Ts with transitions that are reachable.
void TestTeUnreachable ()
 Test Ts with states that are unreachable.
void TestRulsRemoveStates ()
 Test if Ruls deletes the correct states.
void TestAcAccessible ()
 Test if Ac makes the test generator accessible.
void TestTransient ()
 All Transient tests.
void TestRnce ()
 All Rnce tests.
void TestTimes ()
 all Times tests
void TestIntersectEvents ()
 all IntersectEvents tests
void TestSplit ()
 all Split tests
void TestNonblock ()
 all Nonblock tests
void TestTs ()
 all Ts tests
void TestTe ()
 all Te tests
void TestRuls ()
 all Ruls tests
void TestAc ()
 all Ac tests
void TestPostClPostfixes ()
 Test all postfixes of a given word.
void TestFdsWords ()
 Test if Fds returns all expected words.
void TestFirstLMap ()
 Test if the mapping function produced by FirstL is correct.
void TestFirstASelectedWords ()
 Test for some selected word if the correct set of terminals is returned.
void TestFirstSelectedWords ()
 Test for some selected word if the correct set of terminals is returned.
void TestFirstRedConsistentWord ()
 Test FirstRed with a consistent word as input.
void TestFirstRedInconsistentWord ()
 Test FirstRed with an inconsistent word as input.
void TestFilter1MixedGrammarSymbols ()
 Filter a nonterminal from a vector of terminals and nonterminals.
void TestFilter1Nothing ()
 filter from an empty word
void TestFirstAllTerminalsOnly ()
 Test with only Terminals as input.
void TestFirstAllNonterminalsIrreducibleWord ()
void TestFirstAllNonterminalsReducibleWord ()
void TestFirstLeq1ZeroEmpty ()
 Test with k = 0 and a word that results in an empty first set.
void TestFirstLeq1ZeroNonempty ()
 Test with k = 0 and a word that results in a nonempty first set.
void TestFirstLeq1OneNonempty ()
 Test with k = 1 and a word that results in a nonempty first set.
void TestFirstLeq1TwoNonempty ()
 Test with k = 2 and a word that results in a nonempty first set.
void TestPostCl ()
 All PostCl tests.
void TestFds ()
 All Fds tests.
void TestFirstA ()
 All FirstA tests.
void TestFirstL ()
 All FirstL tests.
void TestFirst ()
 All First tests.
void TestFirstRed ()
 All FirstRed tests.
void TestFilter1 ()
 All Filter1 tests.
void TestFirstAll ()
 All FirstAll tests.
void TestFirstLeq1 ()
 All FirstLeq1 tests.
void TestFirstAllNonterminalsReducible ()
 Test with Nonterminals and a reducible word as input.
void TestFirstAllNonterminalsIrreducible ()
 Test with Nonterminals and an irreducible word as input.
void TestDesc11Terminal ()
 Test Desc11 with a terminal at the beginning of afterDot.
void TestDesc11Nonterminal ()
 Test Desc11 with a nonterminal at the beginning of afterDot.
void TestDescSelectedConfigs ()
 Test Desc with some configurations.
void TestPassesXNonterminal ()
 Test PassesX by shifting the dot over a nonterminal.
void TestPassesXTerminal ()
 Test PassesX by shifting the dot over a terminal.
void TestPassesXNoShift ()
 Test PassesX by trying to shift the dot over nothing or a nonexistent symbol.
void TestLrm1FindOne ()
 Test if Lrm1 finds the correct following configuration set when only one must be found.
void TestLrm1FindThree ()
 Test if Lrm1 finds three following configuration sets when three must be found.
void TestLrmLoopAnB ()
 Test if LrmLoop generates the correct number of transitions and states for the "$ a^n b $" grammar.
void TestDescInitialFindTwo ()
 Test Desc Initial if it finds the two correct starting configurations.
void TestLrmGr1 ()
 Test if Lrm generates a GotoMachine with the correct number of transitions and states for the "$ a^n b $" grammar.
void TestLrmGr2 ()
 Test if Lrm generates a GotoMachine with the correct number of transitions and states for a specific.
void TestAugSuccess ()
 Augment a grammar which should result in a successful augmentation.
void TestDesc11 ()
 All Desc11 Tests.
void TestDesc ()
 All Desc Tests.
void TestPassesX ()
 All PassesX Tests.
void TestLrm1 ()
 All Lrm1 Tests.
void TestLrmLoop ()
 All LrmLoop Tests.
void TestDescInitial ()
 All DescInitial Tests.
void TestLrm ()
 All Lrm Tests.
void TestAug ()
 All Aug Tests.
void TestGeneratorGotoOneSuccessor ()
 Test if GeneratorGoto finds the right successor.
void TestGeneratorGotoNoSuccessor ()
 Test if GeneratorGoto finds no successor when none is to be found.
void TestGeneratorGotoSeqFull ()
 Test if a word fully matches a sequence of states when a match is possible.
void TestGeneratorGotoSeqPartial ()
 Test if a partial state sequence is generated when no full match for the word is possible.
void TestLrpShiftRulesNumberAndTerminals ()
 Test if the number of shift rules is correct and test for the correct number of occurences of terminals and each action's left-hand side element's right-hand side.
void TestLrpReduceRulesNumberAndTerminals ()
 Test if the number of reduce rules is correct and test for the correct number of occurences of terminals and each action element's right-hand side.
void TestLrpActions ()
 Test if Lrp generates a parser with the correct rules.
void TestLrpNonterminalsTerminals ()
 Test if Lrp generates a parser with the correct number of nonterminals and terminals for a certain grammar.
void TestGp2PpStates ()
 Test if all states are set correctly and whether the correct ones are used in transitions.
void TestGp2PpTransitions ()
 Test if the number of transitions is correct and test if the number of transitions per event is as expected.
void TestDimNoAugment ()
 Test if the augment symbol transitions were successfully removed from the generator and the new number of transitions is correct.
void TestDimNewFinalStates ()
 Test if final states are set correctly after the removal auf the augment symbol.
void TestGeneratorGoto ()
 All GeneratorGoto Tests.
void TestGeneratorGotoSeq ()
 All GeneratorGotoSeq Tests.
void TestLrpShiftRules ()
 All LrpShiftRules Tests.
void TestLrpReduceRules ()
 All LrpReduceRules Tests.
void TestLrp ()
 All Lrp Tests.
void TestGp2Pp ()
 All Gp2Pp Tests.
void TestDim ()
 All Dim Tests.
void TestFilterMixedGrammarSymbols ()
 Filter a nonterminal from a vector of terminals and nonterminals.
void TestFilterNothing ()
 filter from an empty word
void TestRnpp1FindSymbolsEmptySet ()
 Find an eliminable symbol with Rnpp1 and an empty set of nonterminals.
void TestRnpp1FindSymbolsNonemptySet ()
 Find an eliminable symbol with Rnpp1 and a nonempty set of nonterminals.
void TestRnpplFindSymbolsEmptySet ()
 Find all eliminable symbols with Rnppl and an empty set of nonterminals.
void TestRnpplFindSymbolsNonemptySet ()
 Find all eliminable symbolswith Rnppl and a nonempty set of nonterminals.
void TestRnpplFindSymbolsCompleteSet ()
 Find all eliminable symbols with Rnppl and a set already containing all eliminable symbols.
void TestRnppGrammar1 ()
 Remove all noneliminable nonterminals and all productions containing noneliminable nonterminals.
void TestRnppGrammar2 ()
 Remove all noneliminable nonterminals and all productions containing noneliminable nonterminals.
void TestRnppEmptyGrammar ()
 Try to remove all noneliminable nonterminals and all productions containing noneliminable nonterminals from an empty grammar.
void TestSp2LrTerminals ()
 Test if all terminals have been set correctly and match the generator's events.
void TestSp2LrNonterminals ()
 Test if all possible nonterminals were generated.
void TestSp2LrProductions ()
 Test if all expected productions for read, pop and push transitions and for the final states were generated.
void TestSp2Lr2Productions ()
 Test if all expected productions for read, pop and push transitions and for the final states were generated.
void TestRupProductions ()
void TestRupNonterminals ()
void TestFilter ()
 All Filter tests.
void TestRnpp1 ()
 All Rnpp1 tests.
void TestRnppl ()
 All Rnppl tests.
void TestRnpp ()
 All Rnpp tests.
void TestSp2Lr ()
 All Sp2Lr tests.
void TestSp2Lr2 ()
 All Sp2Lr tests.
void TestRup ()
 All Rup tests.
void TestRenQRenaming ()
 Test if all states were renamed correctly (merge attribute is set correctly).
void TestRenQNumberOfStates ()
 Test if the number of states did not change.
void TestRenGRenamingStackSymbols ()
 Test if all stack symbols were renamed correctly.
void TestRenGNumberOfStackSymbols ()
 Test if the number of stack symbols did not change.
void TestRenGRenamingTransitions ()
 Test if the stack symbols in pop and push of transitions were changed correctly.
void TestRep0NoLambdaPop ()
 Tests if there are any lambda popping edges left.
void TestRep0AllExpectingTransition ()
 Test if resulting generator has a transition able to pop all stack symbols, but only if the orignal generator had at least one lambda transition.
void TestRep2NumberOfStatesTransitions ()
 Test for the right number of transitions and states in the generator after applying Rep2.
void TestRep2Renaming ()
 Tests if the MergeStateAnnotations have all been set to "old".
void TestRppNumberStatesTransitions ()
 Test if the number of transitions and states is correct after calling Rpp.
void TestRppReadPopPushOnly ()
 Test if all transitions are either read only, pop only or push only.
void TestNdaActivePassive ()
 Test if the states are split into active and passive states and if the number of states has been doubled.
void TestNdaTransitions ()
 Test if transition start and end states are set as expected.
void TestRenQ ()
 All RenQ Tests.
void TestRenG ()
 All RenG tests.
void TestRep0 ()
 All Rep0 tests.
void TestRpp ()
 All Rpp tests.
void TestRep2 ()
 All Rep2 tests.
void TestNda ()
 All Nda tests.
void TestRemoveUselessTransitionsNumberOfTransitions ()
 Test if RemoveUselessTransitions removes the correct amount of transitions from a test generator.
void TestGetPossibleStackTopsFindCorrectOnes ()
 Test if GetPossibleStackTops finds the correct stack symbols.
void TestRemoveUselessTransitions ()
 all RemoveUselessTransitions tests
void TestGetPossibleStackTops ()
 all GetPossibleStackTops tests
PushdownGenerator TestGenerator1 ()
 build a test generator
PushdownGenerator TestGenerator2 ()
 build a test generator
PushdownGenerator TestGenerator3 ()
 <Generator> Generator
PushdownGenerator TestGenerator4 ()
 <Generator> Generator
PushdownGenerator TestGenerator5 ()
 <Generator> Generator
PushdownGenerator TestGenerator6 ()
PushdownGenerator TestGenerator7 ()
PushdownGenerator TestGenerator8 ()
PushdownGenerator TestGenerator9 ()
PushdownGenerator TestGenerator10 ()
PushdownGenerator TestGenerator11 ()
PushdownGenerator TestGenerator12 ()
PushdownGenerator TestGenerator13 ()
PushdownGenerator TestGenerator14 ()
PushdownGenerator TestGenerator15 ()
PushdownGenerator TestGenerator16 ()
PushdownGenerator TestGenerator17 ()
PushdownGenerator TestGenerator18 ()
PushdownGenerator TestGenerator19 ()
PushdownGenerator TestGenerator20 ()
PushdownGenerator TestGenerator21 ()
PushdownGenerator TestGenerator22 ()
PushdownGenerator TestGenerator23 ()
PushdownGenerator TestGenerator24 ()
PushdownGenerator TestGenerator25 ()
System TestSystem1 ()
 <Generator> Generator
System TestSystem2 ()
System TestSystem3 ()
System TestSystem4 ()
System TestSystem5 ()
Grammar TestGrammar1 ()
 build a test grammer based on the generator from TestGenerator()
Grammar TestGrammar2 ()
 build a test grammer based on the generator from TestGenerator()
Grammar TestGrammar3 ()
Grammar TestGrammar4 ()
Grammar TestGrammar5 ()
Grammar TestGrammar6 ()
Grammar TestGrammar7 ()
Grammar TestGrammar8 ()
Grammar TestGrammar9 ()
Grammar TestGrammar10 ()
Grammar TestGrammar11 ()
void TestStart (std::string name)
 write to console to indicate start of test
void TestEnd (std::string name)
 write to console to indicate end of test
template<class GlobalAttr1 , class StateAttr1 , class EventAttr1 , class TransAttr1 , class GlobalAttr2 , class StateAttr2 , class EventAttr2 , class TransAttr2 , class GlobalAttrR , class StateAttrR , class EventAttrR , class TransAttrR >
void TParallel (const TGEN1 &rGen1, const TGEN2 &rGen2, TGENR &rResGen)
 Parallel composition of timed generators.
template<class GlobalAttr1 , class StateAttr1 , class EventAttr1 , class TransAttr1 , class GlobalAttr2 , class StateAttr2 , class EventAttr2 , class TransAttr2 , class GlobalAttrR , class StateAttrR , class EventAttrR , class TransAttrR >
void TParallel (const TGEN1 &rGen1, const TGEN2 &rGen2, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, TGENR &rResGen)
 Parallel composition of timed generators.
void ran_plant_seeds (long x)
 Use this function to set the state of all the random number generator streams by "planting" a sequence of states (seeds), one per stream, with all states dictated by the state of the default stream.
void ran_put_seed (long seed)
 Put a seed.
void ran_select_stream (int index)
 Use this function to set the current random number generator stream -- that stream from which the next random number will come.
void ran_init (long seed)
 Initialize random generator.
double ran (void)
 Run random generator Random Number Generator (for more details see "Random Number Generators: Good Ones Are Hard To Find" Steve Park and Keith Miller Communications of the ACM, October 1988).
double ran_uniform (double a, double b)
 Sample a random variable uniformly on interval [a;b) Distribution: f(t) dt= {1/(b-a)} dt for t, a <=t< b, else 0.
long ran_uniform_int (long a, long b)
 Sample a discrete random variable uniformly on interval [a;b) Distribution: p(n) = 1/(b-a-1).
double ran_exponential (double mu)
 Sample a random variable exponentially Distribution: f(t) dt = 1/mu exp(-t/mu) dt for t>=0.
double ran_exponential (double mu, tpTime::Type tossLB, tpTime::Type tossUB)
 Sample a random variable exponentially on a restricted interval Distribution: f(t) dt = 1/mu exp(-t/mu) dt for t>=0.
double ran_gauss (double mu, double sigma, tpTime::Type tossLB, tpTime::Type tossUB)
 Sample a random variable gaussian distributed on a restricted interval Distribution: f(t) = 1 / sqrt(2 pi sigma^2) * exp( -1/2 ((t-mu)/sigma)^2) for t>=0.
double ran_gaussian_cdf_P (double x)
 Help function: calculate gaussian CDF using an approximation from Abromowitz and Stegun: Handbook of Mathematical Functions.
void * SDeviceSynchro (void *arg)
int syncSend (int dest, const char *data, int len, int flag)
void * NDeviceListen (void *arg)
void * SwigCastPtr (void *ptr, swig_type_info *from, swig_type_info *ty)
swig_lua_userdataSwigUserData (lua_State *L, int index)
std::string MangleString (const std::string &str)
static bool luafaudes_rl_valididentifier (const std::string &str)
static void luafaudes_rl_dmadd (std::list< std::string > &mlist, const std::string &prefix, const std::string &str, const std::string &suffix)
static int luafaudes_rl_getmetaindex (lua_State *L)
static void luafaudes_rl_getmetafn (lua_State *L)
static void luafaudes_rl_getmetaget (lua_State *L)
static int luafaudes_rl_getmeta (lua_State *L, bool has_colon)
static int luafaudes_rl_getfield (lua_State *L, const char *s, size_t n)
static std::list< std::string > luafaudes_rl_complete (lua_State *L, const std::string &word)
Functions (modular diagnoser computation)

void DecentralizedModularDiagnoser (const std::vector< const System * > &rGens, const Generator &rSpec, std::vector< Diagnoser * > &rDiags, std::string &rReportString)
 Function that computes decentralized diagnosers for the respective subsystems of a composed (modular) system.
bool ModularDiagnoser (const SystemVector &rGsubs, const GeneratorVector &rKsubs, GeneratorVector &rDiagSubs, std::string &rReportString)
 Function that computes diagnosers for the respective subsystems of a composed system.
Functions (decentralized diagnosability)

bool IsCoDiagnosable (const System &rGen, const Generator &rSpec, const std::vector< const EventSet * > &rAlphabets, std::string &rReportString)
 Checks co-diagnosability for a system G with respect to the specification K and the local observation alphabets rAlphabets.
Functions (diagnoser computation)

void EventDiagnoser (const System &rOrigGen, const AttributeFailureTypeMap &rAttrFTMap, Diagnoser &rDiagGen)
 Compute a standard diagnoser from an input generator and a failure partition.
void LanguageDiagnoser (const System &rGen, const System &rSpec, Diagnoser &rDiagGen)
 Compute a standard diagnoser from an input generator and a specification.
Functions (diagnosability with respect to a failure partition)

bool IsEventDiagnosable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, std::string &rReportString)
 Test a system's diagnosability with respect to a given failure partition.
bool IsIndicatorEventDiagnosable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, std::string &rReportString)
 Test a system's I-diagnosability with respect to a given failure partition.
bool MeetsDiagnosabilityAssumptions (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, std::string &rReportString)
 Check if a generator meets the general assumptions of diagnosability as required by IsDiagnosable(const System&, const AttributeFailureTypeMap&, std::string&) and IsIndicatorDiagnosable(const System&, const AttributeFailureTypeMap&, std::string&).
Functions (verification and computation of loop-preserving observers)

bool IsLoopPreservingObserver (const System &rGen, const EventSet &rHighAlph)
 Verifies a loop-preserving observer.
void LoopPreservingObserver (const System &rGen, const EventSet &rInitialHighAlph, EventSet &rHighAlph)
 Computes a loop-preserving observer with minimal state size of the abstraction.
Functions (diagnosability with respect to a specification)

bool IsLanguageDiagnosableX (const System &rGen, const System &rSpec, std::string &rReportString)
 Tests a system's diagnosability with respect to a given specification.
Functions (modular diagnosability)

bool IsModularDiagnosable (const SystemVector &rGsubs, const GeneratorVector &rKsubs, std::string &rReportString)
 Checks modular diagnosability for a system G (which consists of the subsystems rGsubs) with respect to the specification K (consisting of local specifications rKsubs) and the local abstraction alphabets rHighAlphSubs.

Variables

TokenWritergTestProtocolTw = NULL
std::string gTestProtocolFr
static bool(* gBreakFnct )(void)=0
static long ran_seed [STREAMS] = {DEFAULT}
static int ran_stream = 0
static int ran_initialized = 0
AutoRegisterType< TaNameSet
< AttributeSignalEvent > > 
gRti1RegisterSignalDeviceEventSet ("SignalDeviceEventSet")
AutoRegisterXElementTag
< TaNameSet
< AttributeSignalEvent > > 
gRti1XElementTagSignalDeviceEventSet ("SignalDeviceEventSet","Event")
AutoRegisterType< nDevicegRtiRegisterSimplenetDevice ("SimplenetDevice")
static volatile
AutoRegisterType< xDevice
gRtiRegisterDeviceContainer ("DeviceContainer")
static const char *const luafaudes_rl_keywords []

Detailed Description

libFAUDES resides within the namespace faudes.

Plug-Ins may use the same namespace.


Typedef Documentation

Convenience typedef.

Definition at line 243 of file cfl_cgenerator.h.

Definition at line 136 of file pd_parser.h.

Definition at line 154 of file pd_parser.h.

typedef std::vector<std::set<Lr1Configuration> > faudes::ConfigSetVector

Definition at line 139 of file pd_parser.h.

typedef std::tr1::shared_ptr<const GrammarSymbol> faudes::ConstGrammarSymbolPtr

Definition at line 236 of file pd_grammar.h.

typedef std::tr1::shared_ptr<const Nonterminal> faudes::ConstNonterminalPtr

Definition at line 240 of file pd_grammar.h.

typedef std::tr1::shared_ptr<const Terminal> faudes::ConstTerminalPtr

Definition at line 244 of file pd_grammar.h.

typedef double faudes::Float

Type definition for real type (use C std double, must at least represent Int).

Definition at line 55 of file cfl_definitions.h.

typedef unsigned long int faudes::fType

Convenience typdef flag data.

Definition at line 164 of file cfl_attributes.h.

Convenience typedef for std GotoGenerator.

Definition at line 283 of file pd_gotogenerator.h.

typedef std::tr1::shared_ptr<GrammarSymbol> faudes::GrammarSymbolPtr

Definition at line 235 of file pd_grammar.h.

Definition at line 271 of file pd_grammar.h.

Definition at line 247 of file pd_grammar.h.

Definition at line 276 of file pd_grammar.h.

Definition at line 482 of file cfl_project.cpp.

typedef uint32_t faudes::Idx

Type definition for index type (allways 32bit).

Definition at line 46 of file cfl_definitions.h.

typedef long int faudes::Int

Type definition for integer type (let target system decide, minimum 32bit).

Definition at line 50 of file cfl_definitions.h.

Definition at line 218 of file cfl_elementary.h.

Definition at line 227 of file ios_attributes.h.

Definition at line 133 of file pd_parser.h.

Definition at line 151 of file pd_parser.h.

Definition at line 481 of file cfl_project.cpp.

typedef std::tr1::shared_ptr<Nonterminal> faudes::NonterminalPtr

Definition at line 239 of file pd_grammar.h.

typedef void*(* faudes::swig_converter_func)(void *, int *)

Definition at line 52 of file lbp_function.cpp.

typedef struct swig_type_info*(* faudes::swig_dycast_func)(void **)

Definition at line 53 of file lbp_function.cpp.

typedef std::tr1::shared_ptr<Terminal> faudes::TerminalPtr

Definition at line 243 of file pd_grammar.h.

Convenience typedef for std TimedGenerator.

Definition at line 801 of file tp_tgenerator.h.

typedef unsigned int faudes::uint

Definition at line 29 of file pd_basics.h.

typedef void faudes::vDevice

Dummy typedef in the absence of the IO Device plugin.

Definition at line 29 of file sp_dplpexecutor.h.


Enumeration Type Documentation

Enumerator:
NORMAL 
CONFUSED 
BLOCK 

Definition at line 88 of file diag_languagediagnosis.h.


Function Documentation

TransSet faudes::ActiveBackwardTransSet ( const System &  rGen,
Idx  state 
)

Obtain all transitions from other states into a given state of a generator.

Parameters:
rGen A generator.
state A state from the generators state set.
Returns:
A transition set.
void faudes::AdjustHioController ( const HioController &  rHioController,
const HioModule *  rHioModule1,
const HioModule *  rHioModule2,
HioController &  rResEnv 
)

Definition at line 603 of file hio_module.cpp.

void faudes::aParallel ( const GeneratorVector &  rGenVec,
Generator &  rResGen 
)

Parallel composition.

See also aParallel(const Generator&, const Generator&, Generator&). This version takes a vector of generators as argument to perform a synchronous composition of multiple generators. The implementation calls the std aParallel multiple times, future implementations may explore the overall reachable state set.

Parameters:
rGenVec Vector of input generators
rResGen Reference to resulting composition generator
Grammar faudes::Aug ( const Grammar &  gr,
const Nonterminal &  startSymbol,
const Terminal &  augSymbol 
)

Augments the grammar with a nonterminal S and a terminal $ such that a new grammar production will be inserted.

S is the new start symbol of the grammar and S' is the old start symbol of the grammar

Parameters:
gr the grammar to be augmented
startSymbol the new start symbol S. S must not exist in the grammar
augSymbol the $ symbol which augments the grammar. $ must not exist in the grammar
Returns:
augmented grammar with a new production S -> $ S' $
void faudes::backwardReachabilityObsOCC ( const TransSetX2EvX1 &  rTransSetX2EvX1,
const EventSet &  rControllableEvents,
const EventSet &  rHighAlph,
Idx  exitState,
Idx  currentState,
bool  controllablePath,
map< Idx, map< Idx, bool > > &  rExitLocalStatesMap,
StateSet &  rDoneStates 
)

Definition at line 1162 of file op_observercomputation.cpp.

void faudes::backwardVerificationLCC ( const TransSetX2EvX1 &  rTransSetX2EvX1,
const EventSet &  rControllableEvents,
const EventSet &  rHighAlph,
Idx  exitState,
Idx  currentState,
bool  controllablePath,
std::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
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
std::set< Lr1Configuration > faudes::Basis ( const std::set< Lr1Configuration >  configs,
const GrammarSymbolPtr &  symbol 
)

Try to shift the dots in a configuration set over a specified symbol.

Parameters:
configs the configurations
symbol the symbol over which to shift
Returns:
set that contains all shifted configurations
void faudes::calcAbstAlphClosed ( Generator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
std::map< Transition, Idx > &  rMapChangedTrans 
)

L(G)-observer computation.

This function is called by void calcAbstAlphClosed(Generator& 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 prefix-closed language of 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
void faudes::calcAbstAlphClosed ( Generator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
std::map< Idx, std::set< Idx > > &  rMapRelabeledEvents 
)

L(G)-observer computation.

This function is called by calcAbstAlphClosed(System& 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 L(G)-observer for the prefix-closed language of 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)
void faudes::calcAbstAlphClosed ( Generator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Transition, Idx > &  rMapChangedTrans 
)

Definition at line 721 of file op_observercomputation.cpp.

void faudes::calcAbstAlphClosed ( Generator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 698 of file op_observercomputation.cpp.

void faudes::calcAbstAlphClosed ( System &  rGenObs,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 687 of file op_observercomputation.cpp.

void faudes::calcAbstAlphMSA ( Generator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
std::map< Transition, Idx > &  rMapChangedTrans 
)

MSA-observer computation.

This function is called by void calcAbstAlphMSA(Generator& 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 MSA-observer for the language marked by the resulting generator. This function evaluates the observer algorithm as described in K. Schmidt and Th. Moor, "Marked String Accepting Observers for the Hierarchical and Decentralized Control of Discrete Event Systems," Workshop on Discrete Event Systems, 2006.

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
void faudes::calcAbstAlphMSA ( Generator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
std::map< Idx, std::set< Idx > > &  rMapRelabeledEvents 
)

MSA-observer computation.

This function is called by calcAbstAlphMSA(System& 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 MSA-observer for the language marked by the resulting generator. This function evaluates the observer algorithm as described in K. Schmidt and Th. Moor, "Marked String Accepting Observers for the Hierarchical and Decentralized Control of Discrete Event Systems," Workshop on Discrete Event Systems, 2006.

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)
void faudes::calcAbstAlphMSA ( Generator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Transition, Idx > &  rMapChangedTrans 
)

Definition at line 886 of file op_observercomputation.cpp.

void faudes::calcAbstAlphMSA ( Generator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 863 of file op_observercomputation.cpp.

void faudes::calcAbstAlphMSA ( System &  rGenObs,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 852 of file op_observercomputation.cpp.

void faudes::calcAbstAlphMSALCC ( Generator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
std::map< Transition, Idx > &  rMapChangedTrans 
)

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

This function is called by calcAbstAlphMSALCC(System& 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 MSA-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. Schmidt and C. Breindl, "On Maximal Permissiveness of Hierarchical and Modular Supervisory Control Approaches for Discrete Event Systems, Workshop on Discrete Event Systems, 2008. 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
void faudes::calcAbstAlphMSALCC ( Generator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Transition, Idx > &  rMapChangedTrans 
)

Definition at line 1305 of file op_observercomputation.cpp.

void faudes::calcAbstAlphMSALCC ( System &  rGenObs,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 1278 of file op_observercomputation.cpp.

void faudes::calcAbstAlphObs ( MtcSystem rGenObs,
EventSet rControllableEvents,
EventSet rHighAlph,
EventSet rNewHighAlph,
std::map< Transition, Idx > &  rMapChangedTrans 
)

Lm-observer computation.

This function is called by void calcAbstAlphObs(Generator& rGenObs, EventSet& rControllableEvents, EventSet& rHighAlph, EventSet& rNewHighAlph, std::map<Idx, std::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
void faudes::calcAbstAlphObs ( MtcSystem rGenObs,
EventSet rControllableEvents,
EventSet rHighAlph,
EventSet rNewHighAlph,
std::map< Idx, std::set< Idx > > &  rMapRelabeledEvents 
)

Lm-observer computation.

This function is called by calcAbstAlphObs(System& rGenObs, EventSet& rHighAlph, EventSet& rNewHighAlph, std::map<Idx, std::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)
void faudes::calcAbstAlphObs ( MtcSystem rGenObs,
EventSet rControllableEvents,
EventSet rHighAlph,
EventSet rNewHighAlph,
map< Transition, Idx > &  rMapChangedTrans 
)

Definition at line 97 of file mtc_observercomputation.cpp.

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

Definition at line 74 of file mtc_observercomputation.cpp.

void faudes::calcAbstAlphObs ( MtcSystem rGenObs,
EventSet rHighAlph,
EventSet rNewHighAlph,
map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 63 of file mtc_observercomputation.cpp.

void faudes::calcAbstAlphObs ( Generator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
std::map< Transition, Idx > &  rMapChangedTrans 
)

Lm-observer computation.

This function is called by void calcAbstAlphObs(Generator& 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
void faudes::calcAbstAlphObs ( Generator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
std::map< Idx, std::set< Idx > > &  rMapRelabeledEvents 
)

Lm-observer computation.

This function is called by calcAbstAlphObs(System& 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)
void faudes::calcAbstAlphObs ( System &  rGenObs,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
EventRelabelMap &  rMapRelabeledEvents 
)

Rti convenience wrapper.

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

Definition at line 803 of file op_observercomputation.cpp.

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

Definition at line 780 of file op_observercomputation.cpp.

void faudes::calcAbstAlphObs ( System &  rGenObs,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 769 of file op_observercomputation.cpp.

void faudes::calcAbstAlphObsLCC ( Generator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
std::map< Transition, Idx > &  rMapChangedTrans 
)

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

This function is called by calcAbstAlphObsLCC(System& 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
void faudes::calcAbstAlphObsLCC ( Generator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Transition, Idx > &  rMapChangedTrans 
)

Definition at line 1228 of file op_observercomputation.cpp.

void faudes::calcAbstAlphObsLCC ( System &  rGenObs,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 1201 of file op_observercomputation.cpp.

void faudes::calcBisimulation ( Generator &  rGenOrig,
map< Idx, Idx > &  rMapStateToPartition,
vector< Idx > &  rNewPartitions 
)

Definition at line 53 of file op_bisimulation.cpp.

void faudes::calcBisimulation ( Generator &  rGenOrig,
map< Idx, Idx > &  rMapStateToPartition,
Generator &  rGenPart,
vector< Idx > &  rNewPartitions 
)

Definition at line 37 of file op_bisimulation.cpp.

void faudes::calculateDynamicSystemClosedObs ( const Generator &  rGen,
EventSet &  rHighAlph,
Generator &  rGenDyn 
)

Computation of the dynamic system for Delta_sigma (reachable states after the occurrence of one high-level event).

This function computes the part of the dynamic system that is needed for evaluating the observer algorithm for closed languages.

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
void faudes::calculateDynamicSystemLCC ( const Generator &  rGen,
const EventSet &  rControllableEvents,
const EventSet &  rHighAlph,
Generator &  rGenDyn 
)

Computation of the dynamic system for Delta_lcc (fulfillment of the local control consistency property).

This function computes the part of the dynamic system that is needed for evaluating the observer algorithm for local control consistency

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
void faudes::calculateDynamicSystemMSA ( const Generator &  rGen,
EventSet &  rHighAlph,
Generator &  rGenDyn 
)

Computation of the dynamic system for Delta_msa (local fulfillment of the msa-observer property).

This function computes the part of the dynamic system that is needed for evaluating the observer algorithm for msa-observers.

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
void faudes::calculateDynamicSystemObs ( const MtcSystem rGen,
EventSet rHighAlph,
Generator 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
void faudes::calculateDynamicSystemObs ( const Generator &  rGen,
EventSet &  rHighAlph,
Generator &  rGenDyn 
)

Computation of the dynamic system for Delta_obs (local reachability of a marked state).

This function computes the part of the dynamic system that is needed for evaluating the observer algorithm for marked languages.

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
PushdownGenerator faudes::Ccl ( const PushdownGenerator &  contr,
const System &  plant,
Idx  iteration = 0 
)

Looped exectuion of to construct a minimal restrictive sound controller.

Alphabets of specification and plant are expected to be equal.

Parameters:
contr the controller candidate
plant the plant
iteration number of iterations of ccl
Returns:
minimal restrictive controller
PushdownGenerator faudes::Ccs ( const PushdownGenerator &  contr,
const System &  plant 
)

Single execution of the loop to construct a minimal restrictive sound controller.

Alphabets of specification and plant are expected to be equal.

Parameters:
contr the controller candidate
plant the plant
Returns:
product of controller candidate and plant
bool faudes::CheckMergibility ( Idx  stateI,
Idx  stateJ,
std::vector< std::set< Idx > > &  rWaitList,
Idx  cNode,
const System &  rSupGen,
const std::map< Idx, ReductionStateInfo > &  rSupStateInfo,
const std::map< Idx, Idx > &  rState2Class,
const std::vector< StateSet > &  rClass2States 
)

Supervisor Reduction mergibility algorithm.

This recursive algorithm determines if two supervisor states can be merged to the same coset. It is called by the main procedure SupReduce.

Parameters:
stateI First state to be checked
stateJ second state to be checked
rWaitList list of waiting state pairs
cNode remembers first state to be checked
rSupGen constant reference to supervisor
rSupStateInfo constant reference to state info data structure
rState2Class constant reference to data structure that maps states to their coset
rClass2State constant reference to data structure that maps cosets to their states
Returns:
True if the classes of statep and stateq can be merged
bool faudes::CheckSplit ( const Generator &  rGenObs,
const EventSet &  rSplitAlphabet,
const std::vector< std::pair< StateSet, Idx > > &  rNondeterministicStates,
Idx  entryState 
)

Check if the current alphabet splits all local automata with nondeterminims or unobservable transitions.

This algorithm verifies if nondetermisisms or unobservable transitions are resolved if the given events in are added to the high-level alphabet. The function is called by ExtendHighAlphabet,

The alphabet rHighAlph has to be a subset 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
rSplitAlphabet Reference to the current alphabet for splitting verification
rNondeterministicStates vector with states where nondeterminism has to be resolved and the related event
entryState current state that is investigated
bool faudes::CheckSplit ( const Generator &  rGen,
const EventSet &  rSplitAlphabet,
const vector< pair< StateSet, Idx > > &  rNondeterministicStates,
Idx  entryState 
)

Definition at line 654 of file op_observercomputation.cpp.

std::string faudes::CollapsString ( const std::string &  rString,
unsigned int  len = FD_MAXCONTAINERNAME 
)

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

Parameters:
rString string
len Maximum number of charakters in string (approx)
Returns:
Collapsed string
bool faudes::CompareConfigGsPair ( const ConfigSetGsPair &  lhs,
const ConfigSetGsPair &  rhs 
)
bool faudes::CompareConfigSet ( const std::set< Lr1Configuration > &  lhs,
const std::set< Lr1Configuration > &  rhs 
)
bool faudes::CompareGs ( const GrammarSymbolPtr &  lhs,
const GrammarSymbolPtr &  rhs 
)
bool faudes::CompareGsVector ( const GrammarSymbolVector &  lhs,
const GrammarSymbolVector &  rhs 
)
void faudes::ComposedColorSet ( const MtcSystem &  rGen1,
const Idx  stdidx1,
ColorSet &  colors1,
const MtcSystem &  rGen2,
const Idx  stdidx2,
ColorSet &  colors2,
ColorSet &  composedSet 
)

Compose the color set for a state combined from two states in two distinct automata.

Parameters:
rGen1 First MtcSystem for parallel composition
stdidx1 Index to first MtcSystem's current state
colors1 Color set of first MtcSystem
rGen2 Second MtcSystem for parallel composition
stdidx2 Index to second MtcSystem's current state
colors2 Color set of second MtcSystem
composedSet Color set where composition colors will be inserted
Exceptions:
Exception 
  • Index not member of set (id 200)
  • Index not found in set (id 201)
void faudes::CompositionMap1 ( const std::map< std::pair< Idx, Idx >, Idx > &  rCompositionMap,
std::map< Idx, Idx > &  rCompositionMap1 
)

Definition at line 671 of file cfl_parallel.cpp.

void faudes::CompositionMap2 ( const std::map< std::pair< Idx, Idx >, Idx > &  rCompositionMap,
std::map< Idx, Idx > &  rCompositionMap2 
)

Definition at line 683 of file cfl_parallel.cpp.

void faudes::ComputeGd ( const Diagnoser &  rGobs,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
System &  rGd 
)

Compute the diagnosability testing generator G_d as a parallel composition of G_o with itself (according to Jiang).

Parameters:
rGobs Input diagnoser G_o.
rReverseCompositionMap Output variable containing the mapping of G_o states and G_d states (generated by Parallel()).
rGd Output variable for G_d.
void faudes::ComputeGd ( const Diagnoser &  rGobs,
map< pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
System &  rGd 
)

Definition at line 588 of file diag_eventdiagnosis.cpp.

void faudes::ComputeGobs ( const System &  rGenMarkedNonSpecBehaviour,
Diagnoser &  rGobs 
)

Compute G_o for a generator that marks the faulty behaviour of a plant.

Every specification violation will be labelled with label "F".

Parameters:
rGenMarkedNonSpecBehaviour Input generator that specifies specification violations by marked states.
rGobs Output variable for G_o.
void faudes::ComputeGobs ( const System &  rOrigGen,
const std::string &  rFailureType,
const EventSet &  rFailureEvents,
Diagnoser &  rGobs 
)

Compute G_o for a single failure type of a generator.

Parameters:
rOrigGen Input generator, which is a model of the original plant containing the relevant failures events.
rFailureType Failure type name.
rFailureEvents Failure events belonging to the failure type.
rGobs Output variable for G_o.
void faudes::ComputeGobs ( const System &  rOrigGen,
const AttributeFailureTypeMap &  rAttrFTMap,
Diagnoser &  rGobs 
)

Compute G_o for a given generator with a given failure partition (according to Jiang).

Parameters:
rOrigGen Input generator, which is a model of the original plant containing the relevant failures events.
rAttrFTMap Failure partition.
rGobs Output variable for G_o.
Exceptions:
Exception 
  • Input generator has no unique initial state (id 301).
void faudes::ComputeGobs ( const System &  rOrigGen,
const string &  rFailureType,
const EventSet &  rFailureEvents,
Diagnoser &  rGobs 
)

Definition at line 423 of file diag_eventdiagnosis.cpp.

void faudes::ComputeReachability ( const System &  rGen,
const EventSet &  rUnobsEvents,
Idx  State,
std::map< Idx, std::multimap< Idx, DiagLabelSet > > &  rReachabilityMap 
)

Compute the reachability from a state of a generator that marks its faulty behaviour.

States are said to be reachable if they can be reached through a trace that consists of arbitrarily many unobservable events followed by one observable event.

Parameters:
rGen Input generator.
rUnobsEvents Unobservable events in the generators alphabet.
State A state of the generators state set.
rReachabilityMap Output variable for the reachability. Maps occurring observable events to the reachable generator states and a label that contains information about specification violations.
void faudes::ComputeReachability ( const System &  rGen,
const EventSet &  rUnobsEvents,
Idx  State,
map< Idx, multimap< Idx, DiagLabelSet > > &  rReachabilityMap 
)

Definition at line 180 of file diag_languagediagnosis.cpp.

void faudes::ComputeReachability ( const System &  rGen,
const EventSet &  rUnobsEvents,
const EventSet &  rFailures,
Idx  State,
const AttributeFailureTypeMap &  rAttrFTMap,
std::map< Idx, std::multimap< Idx, DiagLabelSet > > &  rReachabilityMap 
)

Compute the reachability from a given generator state through a trace that consists of arbitrarily many unobservable events followed by one observable event.

Parameters:
rGen Input generator.
rUnobsEvents Unobservable events in the generators alphabet.
rFailures Unobservable failure events in the generators alphabet.
State A state of the generators state set.
rAttrFTMap Failure partition.
rReachabilityMap Output variable for the reachability. Maps occurring observable events to the reachable generator states and the corresponding failure types that occurred within the unobservable part of the trace.
void faudes::ComputeReachability ( const System &  rGen,
const EventSet &  rUnobsEvents,
const EventSet &  rFailures,
Idx  State,
const AttributeFailureTypeMap &  rAttrFTMap,
map< Idx, multimap< Idx, DiagLabelSet > > &  rReachabilityMap 
)

Definition at line 703 of file diag_eventdiagnosis.cpp.

void faudes::ComputeReachabilityRecursive ( const System &  rGen,
const EventSet &  rUnobsEvents,
Idx  State,
StateSet  done,
std::map< Idx, std::multimap< Idx, DiagLabelSet > > &  rReachabilityMap 
)

Auxiliary function for ComputeReachability(const System&, const EventSet&, Idx State, std::map<Idx,std::multimap< Idx,DiagLabelSet> >&).

Is recursively called for every occurring state on the trace (that consists of arbitrarily many unobservable events followed by one observable event).

Parameters:
rGen Input generator.
rUnobsEvents Unobservable events in the generators alphabet.
State The current state within the trace.
done Progress.
rReachabilityMap Output variable for the reachability. Maps occurring observable events to the reachable generator states and a label that contains information about specification violations.
void faudes::ComputeReachabilityRecursive ( const System &  rGen,
const EventSet &  rUnobsEvents,
Idx  State,
StateSet  done,
map< Idx, multimap< Idx, DiagLabelSet > > &  rReachabilityMap 
)

Definition at line 207 of file diag_languagediagnosis.cpp.

void faudes::ComputeReachabilityRecursive ( const System &  rGen,
const EventSet &  rUnobsEvents,
const EventSet &  rFailures,
Idx  State,
const AttributeFailureTypeMap &  rAttrFTMap,
std::map< Idx, std::multimap< Idx, DiagLabelSet > > &  rReachabilityMap,
const DiagLabelSet  FToccurred 
)

Auxiliary function for ComputeReachability(const System&, const EventSet&, const EventSet&, Idx, const AttributeFailureTypeMap&, std::map<Idx,std::multimap<Idx,DiagLabelSet>>&).

Is recursively called for every occurring state on the trace (that consists of arbitrarily many unobservable events followed by one observable event).

Parameters:
rGen Input generator.
rUnobsEvents Unobservable events in the generators alphabet.
rFailures Unobservable failure events in the generators alphabet.
State The current state within the trace.
rAttrFTMap Failure partition.
rReachabilityMap Output variable for the reachability. Maps occurring observable events to the reachable generator states and the coresponing failure types that occurred within the unobservable part of the trace.
FToccurred Collects occurring failure types.
void faudes::ComputeReachabilityRecursive ( const System &  rGen,
const EventSet &  rUnobsEvents,
const EventSet &  rFailures,
Idx  State,
const AttributeFailureTypeMap &  rAttrFTMap,
map< Idx, multimap< Idx, DiagLabelSet > > &  rReachabilityMap,
const DiagLabelSet  FToccurred 
)

Definition at line 729 of file diag_eventdiagnosis.cpp.

Generator faudes::ComputeTildeG ( const EventSet &  unionset,
const EventSetVector &  ee,
const EventSet &  ek,
const Generator &  gen 
)
void faudes::ConcatenateFullLanguage ( Generator &  rGen  ) 

ConcatenateFullLanguage: concatenate Sigma* to language marked by rGen.

Less expensive than using LanguageConcatenate() to concatenate Sigma*, as no additional nondeterminism is caused. Used in SupNorm(). Method: Transitions starting from marked states are erased. Remaining accessible marked states are provided with Sigma-selfloops. Determinism: Result can only become nondeterministic when a parameter is nondeterministic.

Parameters:
rGen generator marking the language to be concatenated with Sigma*
std::string faudes::ConfigSetSetToStr ( const Lr1ConfigurationSetSet  configSetSet  ) 

To string function for configuration set sets.

Parameters:
configSetSet the configuration set sets to turn into a string
Returns:
the configuration set sets as a string
std::string faudes::ConfigSetToStr ( const std::set< Lr1Configuration > &  configs  ) 

To string function for configuration sets.

Parameters:
configs the configuration set to turn into a string
Returns:
the configuration set as a string
bool faudes::ContainsWord ( const GrammarSymbolWordSet &  set,
const GrammarSymbolVector &  word 
)

Test if a given set of words contains a specific word.

Parameters:
set the set to be searched
word the word to be searched for
Returns:
true, if the set contains the word, else false
std::string faudes::ContributorsString (  ) 

Return contributors as std::string.

Returns:
std::string
void faudes::ControlProblemConsistencyCheck ( const Generator &  rPlantGen,
const EventSet &  rCAlph,
const EventSet &  rOAlph,
const Generator &  rSpecGen 
)

Consistency check for controlproblem input data.

Tests whether alphabets match and generators are deterministic.

Parameters:
rPlantGen Plant generator
rCAlph Controllable events
rOAlph Observable 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)
void faudes::ControlProblemConsistencyCheck ( const Generator &  rPlantGen,
const EventSet &  rCAlph,
const Generator &  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)
void faudes::ConvertParallelCompositionMap ( const std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
std::map< Idx, std::pair< Idx, Idx > > &  rCompositionMap 
)

Convert the reverse composition map of Parallel() by switching first and second entry.

Parameters:
rReverseCompositionMap Input map as generated by Parallel().
rCompositionMap Converted map.
void faudes::ConvertParallelCompositionMap ( const map< pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
map< Idx, pair< Idx, Idx > > &  rCompositionMap 
)

Definition at line 210 of file diag_eventdiagnosis.cpp.

void faudes::CorrectEvents ( const PushdownGenerator &  correctPd,
PushdownGenerator &  pd 
)

Sets controllability and observability flags for a pushdown generator's events to the event flags of another pushdown generator.

Parameters:
correctPd pushdown generator with correct flags
pd this generator's event flags will be set to the correctPd's event flags
void faudes::cParallel ( const std::vector< System > &  rGens,
System &  rResGen 
)

Parallel composition of multiple generators.

Parameters:
rGens STL-vector of generators.
rResGen Output variable for the resulting product generator.
void faudes::cParallel ( const vector< System > &  rGens,
System &  rResGen 
)

Definition at line 270 of file diag_modulardiagnosis.cpp.

void faudes::cParallel ( const std::vector< const System * > &  rGens,
System &  rResGen 
)

Parallel composition of multiple generators.

Parameters:
rGens STL-vector of generators.
rResGen Output variable for the resulting product generator.
void faudes::CreateConstraint ( int  mType[5],
Generator &  constrP,
Generator &  constrE 
)

This function creates constraints which describe the condition of completeness and Yp-liveness of a Specification.

The implementation follows the same algorithm as the CreateSpec() function, and has the same limitation: it is only for use with a specific model

Parameters:
mType By the type we specify type of the specification to build constraint for
constrP Generator to the resulting operator constraint for the specification
constrE Generator to the resulting environment constraint for the specification
void faudes::CreateEntryStatesMap ( const std::map< StateSet, Idx > &  rRevEntryStatesMap,
std::map< Idx, StateSet > &  rEntryStatesMap 
)

Definition at line 1521 of file cfl_project.cpp.

void faudes::CreateSpec ( int  mType[5],
HioPlant &  rHioSpec,
Generator &  constrP,
Generator &  constrE 
)

This function creates new specification given by the type ("xxxxx") Note: The core of this function is a template specification model (SpecCB12.gen).

Based on this model are the specifications created, by simply adding corresponding states and transitions. Hence, for different models, this function can not be used directly, but can serve as an example.

Parameters:
mType By the type we specify the desired behaviour we want to model
rHioSpec HioPlant reference to the resulting specification (result)
constrP Generator to the resulting operator constraint for the specification
constrE Generator to the resulting environment constraint for the specification
std::string faudes::CreateTempFile ( void   ) 

Create a temp file, length 0.

Returns:
Name of temp file
bool faudes::CycleOfUnobsEvents ( const System &  rGen,
std::string &  rReport 
)

Test if there exist any cycles of unobservable events in a generator.

Parameters:
rGen Input generator.
rReport User-readable information of violating condition (in case of positive test result).
Returns:
True if there exists a cycle of unobservable events.
bool faudes::CycleOfUnobsEvents ( const System &  rGen,
string &  rReport 
)

Definition at line 241 of file diag_eventdiagnosis.cpp.

void faudes::CycleStartStates ( const System &  rGen,
StateSet &  rCycleOrigins 
)

Find all start/end states of cycles of unobservable events in a generator.

Parameters:
rGen Input generator.
rCycleOrigins Output variable for the states that have been found.
void faudes::CycleStartStatesSearch ( const System &  rGen,
StateSet &  rTodo,
Idx  currState,
StateSet  statesOnPath,
StateSet &  rCycleOriginStates 
)

Auxiliary function for CycleStartStates().

Parses through the active event set of the current state and checks whether any of the successor states already occurred on the path to current state (then a cycle is found).

Parameters:
rGen Input generator.
rTodo States that remain to be processed.
currState The current state.
statesOnPath States that occurred on the path.
rCycleOriginStates Output variable for the states that have been found.
bool faudes::DecentralizedDiagnoser ( const System &  rGen,
const Generator &  rSpec,
const EventSetVector &  rAlphabets,
GeneratorVector &  rDiags 
)

Function definition for run-time interface.

void faudes::DecentralizedModularDiagnoser ( const SystemVector &  rGens,
const Generator &  rSpec,
GeneratorVector &  rDiags 
)

Function definition for run-time interface.

std::set< Lr1Configuration > faudes::Desc ( const Grammar &  gr,
uint  k,
const std::set< Lr1Configuration > &  config 
)

Obtain all descendants of a configuration set.

Parameters:
gr the grammar on which to work
k a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1))
config a set of configurations whose descendants are to be obtained
Returns:
set of all descendant parser configurations
std::set< Lr1Configuration > faudes::Desc1 ( const Grammar &  gr,
uint  k,
const std::set< Lr1Configuration > &  configs 
)

Obtain the immediate descendants of configurations if the dot were pushed one nonterminal further.

Parameters:
gr the grammar on which to work
k a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1))
configs a set of configurations whose descendants are to be obtained
Returns:
set of all immediate descendant parser configurations
std::set< Lr1Configuration > faudes::Desc11 ( const Grammar &  gr,
uint  k,
const Lr1Configuration &  config 
)

Obtain the immediate descendants of a configuration if the dot were pushed one nonterminal further.

Parameters:
gr the grammar on which to work
k a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1))
config the configuration whose descendants are to be obtained
Returns:
set of all descendant parser configurations
std::set< Lr1Configuration > faudes::DescInitial ( const Grammar &  gr  ) 

Determine the initial parser configurations for a grammar.

Parameters:
gr the grammar
Returns:
a set with the initial configurations
void faudes::Deterministic ( const Generator &  rGen,
std::vector< StateSet > &  rPowerStates,
std::vector< Idx > &  rDetStates,
Generator &  rResGen 
)

Make generator deterministic.

Constructs a deterministic generator while preserving the generated and marked languages. See Deterministic(const Generator&,Generator& rResGen) for the intended api. This version provides as second and third parameters the correspondence between 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
void faudes::Deterministic ( const Generator &  rGen,
std::map< Idx, StateSet > &  rEntryStatesMap,
Generator &  rResGen 
)

Make generator deterministic.

Constructs a deterministic generator while preserving the generated and marked languages. See Deterministic(const Generator&,Generator& 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
PushdownGenerator faudes::Dim ( const PushdownGenerator &  pd,
const Terminal &  augSymbol 
)

Remove the augmentation from the generator (diminish it).

This will remove all transitions whose event is the augment symbol and make those transitions start states final. It will also remove the augment symbol as an event.

Parameters:
pd generator to diminish
augSymbol the symbol with wich the grammar that was used to create the generator was augmented
Returns:
diminished generator
bool faudes::DirectoryExists ( const std::string &  rDirectory  ) 

Test existence of directory.

Parameters:
rDitectory Name of file to test
Returns:
True <> can open directory for reading
bool faudes::EqualsGsVector ( const GrammarSymbolVector &  lhs,
const GrammarSymbolVector &  rhs 
)
void faudes::EventDiagnoser ( const System &  rOrigGen,
const std::map< std::string, EventSet > &  rFailureTypeMap,
Diagnoser &  rDiagGen 
)

Compute a standard diagnoser from an input generator and a failure partition.

Parameters:
rOrigGen Input plant including failure events.
rFailureTypeMap Failure partition: maps failure type names to failure events.
rDiagGen Diagnoser generator for output.
void faudes::EventDiagnoser ( const System &  rOrigGen,
const map< string, EventSet > &  rFailureTypeMap,
Diagnoser &  rDiagGen 
)

Definition at line 816 of file diag_eventdiagnosis.cpp.

bool faudes::ExistsCycle ( const System &  rGen,
std::string &  rReport 
)

Test if there exist any cycles in a generator.

Parameters:
rGen Input generator.
rReport User-readable information of violating condition (in case of positive test result).
Returns:
True if there exists a cycle.
bool faudes::ExistsCycle ( const System &  rGen,
string &  rReport 
)

Definition at line 283 of file diag_eventdiagnosis.cpp.

bool faudes::ExistsCycleSearch ( const System &  rGen,
StateSet &  rTodo,
Idx  currState,
StateSet  statesOnPath,
std::string &  rReport 
)

Auxiliary function for ExistsCycle(const System&, std::string&).

Starting from a state currState, this function makes a depth-first-search through the generator rGen.

Parameters:
rGen Input generator.
rTodo States to process.
currState Current state.
statesOnPath States that occurred on the way to current state.
rReport User-readable information of violating condition (in case of negative test result).
Returns:
True if a cycle is found.
bool faudes::ExistsCycleSearch ( const System &  rGen,
StateSet &  rTodo,
Idx  currState,
StateSet  statesOnPath,
string &  rReport 
)

Definition at line 306 of file diag_eventdiagnosis.cpp.

bool faudes::ExistsViolatingCyclesInGd ( System &  rGd,
const Diagnoser &  rGobs,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
const std::string &  rFailureType,
std::string &  rReportString 
)

Remove states with same failure labels from rGd and from rReverseCompositionMap and perform cycle detection.

Parameters:
rGd Input diagnoser generator.
rGobs Generator G_o to look up failure labels.
rReverseCompositionMap Mapping of G_d states with G_o states.
rFailureType The considered failure type.
rReportString User-readable information of violating condition (in case of negative test result).
Returns:
True if violating cycles exist.
bool faudes::ExistsViolatingCyclesInGd ( System &  rGd,
const Diagnoser &  rGobs,
map< pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
const string &  rFailureType,
string &  rReportString 
)

Definition at line 380 of file diag_eventdiagnosis.cpp.

void faudes::ExitFunction ( void   ) 

Definition at line 408 of file cfl_helper.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
void faudes::ExtendHighAlphabet ( const Generator &  rGen,
EventSet &  rHighAlph,
map< Idx, Idx > &  rMapStateToPartition 
)

Definition at line 540 of file op_observercomputation.cpp.

std::string faudes::ExtractBasename ( const std::string &  rFullName  ) 

Extract file name from full path.

This version also remove the last suffix.

Parameters:
rFullName Full path of file eg "/home/friend/data/generator.gen"
Returns:
Filename "generator"
std::string faudes::ExtractDirectory ( const std::string &  rFullPath  ) 

Extract directory from full path.

Parameters:
rFullPath Full name of file eg "/home/friend/data/generator.gen"
Returns:
Directory eg "/home/friend/data"
std::string faudes::ExtractExtension ( const std::string &  rFullName  ) 

Extract file name from full path.

This version also remove the last suffix.

Parameters:
rFullName Full path of file eg "/home/friend/data/generator.gen"
Returns:
Extension "gen"
std::string faudes::ExtractFilename ( const std::string &  rFullName  ) 

Extract file name from full path.

Parameters:
rFullName Full path of file eg "/home/friend/data/generator.gen"
Returns:
Filename "generator.gen"
bool faudes::FailuresUnobservable ( const System &  rGen,
const AttributeFailureTypeMap &  rFailureTypeMap,
std::string &  rReport 
)

Check if all failure events are unobservable events in a generator's alphabet.

Parameters:
rGen Input generator, is a model of the original plant containing the relevant failures events.
rFailureTypeMap Failure partition: maps failure type names to failure events and indicator events.
rReport User-readable information of violating condition (in case of negative result).
Returns:
True if all failures events are unobservable.
bool faudes::FailuresUnobservable ( const System &  rGen,
const AttributeFailureTypeMap &  rFailureTypeMap,
string &  rReport 
)

Definition at line 265 of file diag_eventdiagnosis.cpp.

const std::string& faudes::FaudesFunctionName ( const Function rObject  ) 

Definition at line 696 of file cfl_registry.cpp.

GrammarSymbolWordSet faudes::Fds ( const Grammar &  gr  ) 

Determine certain words in a grammar.

The words are all lefthand sides and all righthand sides as well as the righthand sides' postfixes

Parameters:
gr the grammar
Returns:
all lefthand sides and all righthand sides' postfixes as words
bool faudes::FileCopy ( const std::string &  rFromFile,
const std::string &  rToFile 
)

Copy file.

Parameters:
rFromFile Name of source file
rToFile Name of dest file
Returns:
True <> operation ok
bool faudes::FileDelete ( const std::string &  rFilename  ) 

Delete file.

Parameters:
rFilename Name of file to delete
Returns:
True <> could delete the file
bool faudes::FileExists ( const std::string &  rFilename  ) 

Test existence of file.

Parameters:
rFilename Name of file to test
Returns:
True <> can open file for reading
std::set< Nonterminal > faudes::Filter ( const std::set< Nonterminal > &  symbolSet,
const GrammarSymbolVector &  w 
)

Extract all symbols from the word that are in the symbol set.

Parameters:
symbolSet the symbol set
w the word
Returns:
set of found symbols
NonterminalPtr faudes::Filter1 ( const std::set< Nonterminal > &  symbolSet,
const GrammarSymbolVector &  w 
)

Extract the first symbol from the word that is in the symbol set.

Parameters:
symbolSet the symbol set
w the word
Returns:
pointer to the found symbol or NULL if none is found
std::set< Terminal > faudes::First ( const Grammar &  gr,
const GrammarSymbolVector &  word 
)

Determines which terminals can come first for a given word.

Parameters:
gr the grammar on which to work
word the word whose first terminals are to be determined
Returns:
set of first terminals
GrammarSymbolWordMap faudes::First1 ( const Grammar &  gr,
const GrammarSymbolWordMap &  f,
bool *  madeChanges 
)

Updates the function which maps words to their first possible terminal symbols.

Must be called until no changes are made in order to have a complete mapping.

Parameters:
gr the grammar on which to work
f the mapping function (word -> first symbols)
madeChanges this variable will be written to true if changes were made and written to false if no changes were made
Returns:
the updated first function
std::set< Terminal > faudes::FirstA ( const Grammar &  gr,
const GrammarSymbolVector &  word 
)

Determines which terminals can come first for a given word.

The word must be in Fds()!

Parameters:
gr the grammar on which to work
word the word whose first terminals are to be determined
Returns:
set of first terminals
std::set< Terminal > faudes::FirstAll ( const Grammar &  gr,
const GrammarSymbolVector &  word 
)

Determines which terminals can come first for a given word and ensures that the word can be entirely reduced.

Parameters:
gr the grammar on which to work
word the word whose first terminals are to be determined
Returns:
set of first terminals or empty set, if the word cannot be entirely reduced
GrammarSymbolWordMap faudes::FirstL ( const Grammar &  gr,
const GrammarSymbolWordMap &  f 
)

Builds a function that maps words to their first possible terminal symbols by recursively calling First1.

Parameters:
gr the grammar on which to work
f the mapping function (word -> first symbols)
Returns:
the first function
std::set< Terminal > faudes::FirstLeq1 ( const Grammar &  gr,
uint  k,
const GrammarSymbolVector &  word 
)

Determine which terminals can come first for a given word for any k <= 1.

Parameters:
gr the grammar on which to work
k a natural number k
word the word whose first terminals are to be determined
Returns:
for k = 1 and k = 0: set of first terminals for k = 0 and set of first terminals not empty: lambda for k > 1: empty set
std::set< Terminal > faudes::FirstRed ( const Grammar &  gr,
const GrammarSymbolVector &  word 
)

Calls first, but only if all symbols in the word are in the grammar as well.

Parameters:
gr the grammar
word the word
Returns:
set of first terminals or empty set if the word contained symbols not in the grammar
std::set< Idx > faudes::GeneratorGoto ( const GotoGenerator &  gotoGen,
Idx  state,
const GrammarSymbolPtr &  symbol 
)

Find the successor states of a state for a given input symbol.

Parameters:
gotoGen the generator on which to work
state the state of which to find the successor state
symbol the input symbol
Returns:
A set with the successor states. The set size is 1 if a successor state is found. Set size is 0 if no successor state is found.
std::vector< Idx > faudes::GeneratorGotoSeq ( const GotoGenerator &  gotoGen,
Idx  startState,
const GrammarSymbolVector &  word 
)

Find the successor state sequence of a state for a given input word.

If the word cannot be completely matched to a state sequence, the state sequence will be partially matched (i. e., it will be as long as the part of the word that can be matched).

Parameters:
gotoGen the generator on which to work
state the state of which to find the successor state
word the input word
Returns:
A set with the successor states. The set size will be anywhere between 0 and the length of the word.
StackSymbolSet faudes::GetPossibleStackTops ( const PushdownGenerator &  pd,
const StateSet &  examinedStates,
Idx  q 
)

Get all possible stack top symbols for a state.

Parameters:
pd the pushdown generator containing the state
examinedStates the already examined states
q the state
Returns:
set of all possible stack top symbols
std::set< Lr1Configuration > faudes::GoTo ( const Grammar &  gr,
uint  k,
const std::set< Lr1Configuration >  configs,
const GrammarSymbolPtr &  symbol 
)

Try to shift the dots in a configurations set and obtain the shifted configuration set's descendants.

Parameters:
gr the grammar on which to work
k a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1))
configs the configurations
symbol the symbol over which to shift
Returns:
set containing the shifted configuration's descendant configurations
PushdownGenerator faudes::Gp2Pp ( const GotoGenerator &  gotoGen,
const Lr1Parser &  parser 
)

Converts a parser into a pushdown generator.

The stack symbols will be the parser's nonterminals

Parameters:
gotoGen Lr(k) machine of the grammar that the parser parses
parser the parser to convert
Returns:
the parser as a pushdown generator
void faudes::GroupHioModules ( const std::vector< HioModule * > &  rChildren,
HioModule &  rParentModule 
)

GroupHioModules: This function groups two or more HioModules to a new HioModule.

The new HioModule represents the uncontrolled behaviour of the composed HioModules.

Parameters:
rChildren vector of HioModules to group
rParentModule resulting HioModule
void faudes::HioShuffle_Musunoi ( const HioPlant &  rPlantA,
const HioPlant &  rPlantB,
int  depth,
Generator &  rIOShuffAB 
)
void faudes::HioStatePartition ( HioPlant &  rPlant  ) 

Function definition for run-time interface.

Parameters:
rPlant HioPlant
void faudes::HioStatePartition ( HioEnvironment &  rEnvironment  ) 

Function definition for run-time interface.

Parameters:
rEnvironment HioEnvironment
void faudes::HioStatePartition ( HioController &  rController  ) 

Function definition for run-time interface.

Parameters:
rController HioController
void faudes::HioStatePartition ( HioConstraint &  rConstraint  ) 

Function definition for run-time interface.

Parameters:
rConstraint HioConstraint
void faudes::HioSynth_Musunoi ( const Generator &  rPlant,
const HioPlant &  rSpec,
const Generator &  rConstr,
const Generator &  rLocConstr,
const EventSet &  rYp,
const EventSet &  rUp,
Generator &  rController 
)
void faudes::insertRelabeledEvents ( Generator &  rGenPlant,
const std::map< Idx, std::set< Idx > > &  rMapRelabeledEvents 
)

Convenience function for relabeling events in a given generator.

See insertRelabeledEvents(Generator&, const std::map<Idx, std::set<Idx> >&, EventSet&)

There are no restrictions on parameters.

Parameters:
rGenPlant Plant component automaton
rMapRelabeledEvents maps the original events to sets of newly introduced events
void faudes::insertRelabeledEvents ( System &  rGenPlant,
const std::map< Idx, std::set< Idx > > &  rMapRelabeledEvents 
)

Convenience function for relabeling events in a given generator.

See insertRelabeledEvents(System&, const std::map<Idx, std::set<Idx> >&, Alphabet&)

There are no restrictions on parameters.

Parameters:
rGenPlant Plant component automaton
rMapRelabeledEvents maps the original events to sets of newly introduced events
void faudes::insertRelabeledEvents ( Generator &  rGenPlant,
const std::map< Idx, std::set< Idx > > &  rMapRelabeledEvents,
EventSet &  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.

Technical note: Recording of new events includes attributes, provided that the third parameter has a compatible attribute type.

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)
void faudes::insertRelabeledEvents ( System &  rGenPlant,
const std::map< Idx, std::set< Idx > > &  rMapRelabeledEvents,
Alphabet &  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 relableing from another plant component.

Technical note: This version records newly inserted events incl. their respective controllability attribute in the third parameter. T

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)
void faudes::insertRelabeledEvents ( Generator &  rGenPlant,
const EventRelabelMap &  rMapRelabeledEvents 
)

Rti convenience wrapper.

void faudes::insertRelabeledEvents ( Generator &  rGenPlant,
const EventRelabelMap &  rMapRelabeledEvents,
EventSet &  rNewEvents 
)

Rti convenience wrapper.

void faudes::insertRelabeledEvents ( Generator &  rGenPlant,
const map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 1939 of file op_observercomputation.cpp.

void faudes::insertRelabeledEvents ( System &  rGenPlant,
const map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 1933 of file op_observercomputation.cpp.

void faudes::insertRelabeledEvents ( Generator &  rGenPlant,
const map< Idx, set< Idx > > &  rMapRelabeledEvents,
EventSet &  rNewEvents 
)

Definition at line 1907 of file op_observercomputation.cpp.

void faudes::insertRelabeledEvents ( System &  rGenPlant,
const map< Idx, set< Idx > > &  rMapRelabeledEvents,
Alphabet &  rNewEvents 
)

Definition at line 1884 of file op_observercomputation.cpp.

long int faudes::IntegerSum ( const IntegerVector &  intvect  ) 
long int faudes::IntegerSum ( const Integer &  arg1,
const Integer &  arg2 
)
void faudes::IntersectEvents ( const System &  s,
const PushdownGenerator &  pd,
PushdownGenerator &  rPd 
)

Adds the intersection of events of the first two generators to the result generator.

The function considers observability and controllability, so observability and controllability attributes will be kept.

Parameters:
s first generator
pd second generator
rPd result generator
void faudes::IoStatePartition ( IoSystem &  rIoSystem  ) 

Construct io state partition.

This is an rti wrapper for bool IsIoSystem(IoSystem&).

Parameters:
rIoSystem Generator to test.
void faudes::IoSynthesis ( const IoSystem &  rPlant,
const Generator &  rSpec,
IoSystem &  rSup 
)

IO system synthesis.

This method esentially is a wrapper for SupConComplete(), which implements a synthesis procedure to compute the supremal controllable and complete sublanguage for a given plant and specification. Input events are regarded controllable. marking is ignored, i.e., synthesis refers to the generated langugaes rather than the the marked languages. For a version thet refers to Buchi acceptance condition, see IoSynthesisNB(const IoSystem&, const Generator&, IoSystem&).

The resulting supervisor is an IO System with the plant input events as outputs and vice versa.

Note that this routine does not test whether the plant has a locally free input U, nor does it ensure that the resulting supervisor has a free input Y.

Parameters:
rPlant IO-System - plant model
rSpec Generator - specification
rSup IO-System - supervisor
Exceptions:
Exception 
  • Any exceptions passed on from SupConComplete
void faudes::IoSynthesisNB ( const IoSystem &  rPlant,
const Generator &  rSpec,
IoSystem &  rSup 
)

IO system synthesis.

This method esentially is a wrapper for SupConOmegaNB(), which implements a synthesis procedure to compute the supremal omega-controllable. sublanguage for a given plant and specification. Input events are regarded controllable. In contrast to IoSynthesis(const IoSystem&, const Generator&, IoSystem&), this procedure refers to the Bucji acceptance condition and ensures a omega-nonblocking closed-loop behaviour.

The resulting supervisor is an IO System with the plant input events as outputs and vice versa.

Note that this routine does not test whether the plant has a locally free input U, nor does it ensure that the resulting supervisor has a free input Y.

Parameters:
rPlant IO-System - plant model
rSpec Generator - specification
rSup IO-System - supervisor
Exceptions:
Exception 
  • Any exceptions passed on from SupConOmegaNB
bool faudes::IsCoDiagnosable ( const System &  rGen,
const Generator &  rSpec,
const EventSetVector &  rAlphabets 
)

Function definition for run-time interface.

bool faudes::IsCoDiagnosable ( const System &  rGen,
const Generator &  rSpec,
const vector< const EventSet * > &  rAlphabets,
std::string &  rReportString 
)

Definition at line 24 of file diag_decentralizeddiagnosis.cpp.

bool faudes::IsComplete ( const vGenerator &  rGen,
const StateSet &  rStateSet 
)

Definition at line 3843 of file cfl_generator.cpp.

bool faudes::IsControllableUnchecked ( const Generator &  rPlantGen,
const EventSet &  rCAlph,
const Generator &  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.

This internal function performs no consistency test of the given 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
bool faudes::IsEventDiagnosable ( const System &  rGen,
const AttributeFailureTypeMap &  rFailureTypeMap 
)

Function definition for run-time interface.

bool faudes::IsEventDiagnosable ( const System &  rGen,
const AttributeFailureTypeMap &  rFailureTypeMap,
string &  rReportString 
)

Definition at line 13 of file diag_eventdiagnosis.cpp.

bool faudes::isExtendedEk ( const Generator &  tildeGen,
const Generator &  rGen,
EventSet &  ek 
)
bool faudes::IsHioConstraintForm ( HioConstraint &  rHioConstraint  ) 

IsHioConstraintForm: check if rHioConstraint is in I/O-constraint form and assign state attributes.

This function tests if rHioConstraint meets the I/O-constraint form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioConstraint formally describe an I/O constraint. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QY flag is assigned to a state if its active eventset is a subset of the Y-Alphabet. The assignment of HioStateFlags is complete only if IsHioConstraintForm() returns true. Method: all conditions of the formal I/O-constraint form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.

Parameters:
rHioConstraint HioConstraint to check, HioStateFlags are set
Returns:
true if rHioConstraint is in I/O-constraint form
bool faudes::IsHioConstraintForm ( HioConstraint &  rHioConstraint,
std::string &  rReportStr 
)

IsHioConstraintForm: check if rHioConstraint is in I/O-constraint form and assign state attributes.

This function tests if rHioConstraint meets the I/O-constraint form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioConstraint formally describe an I/O constraint. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QY flag is assigned to a state if its active eventset is a subset of the Y-Alphabet. The assignment of HioStateFlags is complete only if IsHioConstraintForm() returns true. Method: all conditions in the formal I/O-constraint form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.

Parameters:
rHioConstraint HioConstraint to check, HioStateFlags are set
rReportStr Information about test results
Returns:
true if rHioConstraint is in I/O-constraint form
bool faudes::IsHioConstraintForm ( HioConstraint &  rHioConstraint,
StateSet &  rQY,
StateSet &  rQU,
EventSet &  rErrEvSet,
TransSet &  rErrTrSet,
StateSet &  rErrStSet,
std::string &  rReportStr 
)

IsHioConstraintForm: check if rHioConstraint is in I/O-constraint form and assign state attributes.

This function tests if rHioConstraint meets the I/O-constraint form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioConstraint formally describe an I/O constraint. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QY flag is assigned to a state if its active eventset is a subset of the Y-Alphabet. The assignment of HioStateFlags is complete only if IsHioConstraintForm() returns true. Method: all conditions in the formal I/O-constraint form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.

Parameters:
rHioConstraint HioConstraint to check, HioStateFlags are set
rQY State set containing all QY states
rQU State set containing all QU states
rErrEvSet Event set for possible 'bad' events
rErrTrSet Event set for possible 'bad' transition relations
rErrStSet Event set for possible 'bad' states
rReportStr Information about test results
Returns:
true if rHioConstraint is in I/O-constraint form
bool faudes::IsHioControllerForm ( HioController &  rHioController  ) 

IsHioControllerForm: check if rHioController is in I/O-controller form and assign state attributes.

This function tests if rHioController meets the I/O-controller form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioController formally describe an I/O controller. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYcUp flag is assigned to a state if its active eventset is a subset of the union of the YC- and the UP-Alphabet. The assignment of HioStateFlags is complete only if IsHioControllerForm() returns true. Method: all conditions of the formal I/O-controller form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.

Parameters:
rHioController HioController to check, HioStateFlags are set
Returns:
true if rHioController is in I/O-controller form
bool faudes::IsHioControllerForm ( HioController &  rHioController,
std::string &  rReportStr 
)

IsHioControllerForm: check if rHioController is in I/O-controller form and assign state attributes.

This function tests if rHioController meets the I/O-controller form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioController formally describe an I/O controller. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYcUp flag is assigned to a state if its active eventset is a subset of the union of the YC- and the UP-Alphabet. The assignment of HioStateFlags is complete only if IsHioControllerForm() returns true. Method: all conditions in the formal I/O-controller form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.

Parameters:
rHioController HioController to check, HioStateFlags are set
rReportStr Information about test results
Returns:
true if rHioController is in I/O-controller form
bool faudes::IsHioControllerForm ( HioController &  rHioController,
StateSet &  rQUc,
StateSet &  rQYP,
StateSet &  rQUp,
StateSet &  rQYcUp,
EventSet &  rErrEvSet,
TransSet &  rErrTrSet,
StateSet &  rErrStSet,
std::string &  rReportStr 
)

IsHioControllerForm: check if rHioController is in I/O-controller form and assign state attributes.

This function tests if rHioController meets the I/O-controller form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioController formally describe an I/O controller. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYcUp flag is assigned to a state if its active eventset is a subset of the union of the YC- and the UP-Alphabet. The assignment of HioStateFlags is complete only if IsHioControllerForm() returns true. Method: all conditions in the formal I/O-controller form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.

Parameters:
rHioController HioController to check, HioStateFlags are set
rQUc State set containing all QUc states
rQYP State set containing all QYP states
rQUp State set containing all QUp states
rQYcUp State set containing all QYcUp states
rErrEvSet Event set for possible 'bad' events
rErrTrSet Event set for possible 'bad' transition relations
rErrStSet Event set for possible 'bad' states
rReportStr Information about test results
Returns:
true if rHioController is in I/O-controller form
bool faudes::IsHioEnvironmentForm ( HioEnvironment &  rHioEnvironment  ) 

IsHioEnvironmentForm: check if rHioEnvironment is in I/O-environment form and assign state attributes.

This function tests if rHioEnvironment meets the I/O-environment form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioEnvironment formally describe an I/O environment. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYlUe flag is assigned to a state if its active eventset is a subset of the union of the YL- and the UE-Alphabet. The assignment of HioStateFlags is complete only if IsHioEnvironmentForm() returns true. Method: all conditions of the formal I/O-environment form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.

Parameters:
rHioEnvironment HioEnvironment to check, HioStateFlags are set
Returns:
true if rHioEnvironment is in I/O-environment form
bool faudes::IsHioEnvironmentForm ( HioEnvironment &  rHioEnvironment,
std::string &  rReportStr 
)

IsHioEnvironmentForm: check if rHioEnvironment is in I/O-environment form and assign state attributes.

This function tests if rHioEnvironment meets the I/O-environment form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioEnvironment formally describe an I/O environment. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYlUe flag is assigned to a state if its active eventset is a subset of the union of the YL- and the UE-Alphabet. The assignment of HioStateFlags is complete only if IsHioEnvironmentForm() returns true. Method: all conditions in the formal I/O-environment form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.

Parameters:
rHioEnvironment HioEnvironment to check, HioStateFlags are set
rReportStr Information about test results
Returns:
true if rHioEnvironment is in I/O-environment form
bool faudes::IsHioEnvironmentForm ( HioEnvironment &  rHioEnvironment,
StateSet &  rQYe,
StateSet &  rQUe,
StateSet &  rQUl,
StateSet &  rQYlUe,
EventSet &  rErrEvSet,
TransSet &  rErrTrSet,
StateSet &  rErrStSet,
std::string &  rReportStr 
)

IsHioEnvironmentForm: check if rHioEnvironment is in I/O-environment form and assign state attributes.

This function tests if rHioEnvironment meets the I/O-environment form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioEnvironment formally describe an I/O environment. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYlUe flag is assigned to a state if its active eventset is a subset of the union of the YL- and the UE-Alphabet. The assignment of HioStateFlags is complete only if IsHioEnvironmentForm() returns true. Method: all conditions in the formal I/O-environment form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.

Parameters:
rHioEnvironment HioEnvironment to check, HioStateFlags are set
rQYe State set containing all QYe states
rQUe State set containing all QUe states
rQUl State set containing all QUl states
rQYlUe State set containing all QYlUe states
rErrEvSet Event set for possible 'bad' events
rErrTrSet Event set for possible 'bad' transition relations
rErrStSet Event set for possible 'bad' states
rReportStr Information about test results
Returns:
true if rHioEnvironment is in I/O-environment form
bool faudes::IsHioPlantForm ( HioPlant &  rHioPlant  ) 

IsHioPlantForm: check if rHioPlant is in I/O-plant form and assign state attributes.

Function definition for run-time interface.

This function tests if rHioPlant meets the I/O-plant form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioPlant formally describe an I/O plant. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYpYe flag is assigned to a state if its active eventset is a subset of the union of the YP- and the YE-Alphabet. The assignment of HioStateFlags is complete only if IsHioPlantForm() returns true. Method: all conditions of the formal I/O-plant form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.

Parameters:
rHioPlant HioPlant to check, HioStateFlags are set
Returns:
true if rHioPlant is in I/O-plant form
bool faudes::IsHioPlantForm ( HioPlant &  rHioPlant,
std::string &  rReportStr 
)

IsHioPlantForm: check if rHioPlant is in I/O-plant form and assign state attributes.

Function definition for run-time interface.

This function tests if rHioPlant meets the I/O-plant form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioPlant formally describe an I/O plant. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYpYe flag is assigned to a state if its active even set is a subset of the union of the YP- and the YE-Alphabet. The assignment of HioStateFlags is complete only if IsHioPlantForm() returns true. Method: all conditions in the formal I/O-plant form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.

Parameters:
rHioPlant HioPlant to check, HioStateFlags are set
rReportStr Information about test results
Returns:
true if rHioPlant is in I/O-plant form
bool faudes::IsHioPlantForm ( HioPlant &  rHioPlant,
StateSet &  rQYpYe,
StateSet &  rQUp,
StateSet &  rQUe,
EventSet &  rErrEvSet,
TransSet &  rErrTrSet,
StateSet &  rErrStSet,
std::string &  rReportStr 
)

IsHioPlantForm: check if rHioPlant is in I/O-plant form and assign state attributes.

Function definition for run-time interface.

This function tests if rHioPlant meets the I/O-plant form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioPlant formally describe an I/O plant. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYpYe flag is assigned to a state if its active even set is a subset of the union of the YP- and the YE-Alphabet. The assignment of HioStateFlags is complete only if IsHioPlantForm() returns true. Method: all conditions in the formal I/O-plant form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.

Parameters:
rHioPlant HioPlant to check, HioStateFlags are set
rQYpYe State set containing all QYpYe states
rQUp State set containing all QUp states
rQUe State set containing all QUe states
rErrEvSet Event set for possible 'bad' events
rErrTrSet Event set for possible 'bad' transition relations
rErrStSet Event set for possible 'bad' states
rReportStr Information about test results
Returns:
true if rHioPlant is in I/O-plant form
bool faudes::IsIndicatorEventDiagnosable ( const System &  rGen,
const AttributeFailureTypeMap &  rFailureTypeMap 
)

Function definition for run-time interface.

bool faudes::IsIndicatorEventDiagnosable ( const System &  rGen,
const AttributeFailureTypeMap &  rFailureTypeMap,
string &  rReportString 
)

Definition at line 85 of file diag_eventdiagnosis.cpp.

bool faudes::IsLanguageDiagnosable ( const System &  rGen,
const System  rSpec,
std::string &  rReportString 
)

Test function to verify language-diagnosability.

bool faudes::IsLanguageDiagnosable ( const System &  rGen,
const System &  rSpec 
)

Function definition for run-time interface.

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
bool faudes::IsLive ( const System &  rGen,
std::string &  rReport 
)

Test if a generator is live.

Parameters:
rGen Input generator.
rReport User-readable information of violating condition (in case of negative result).
Returns:
True if generator is live.
bool faudes::IsLive ( const System &  rGen,
string &  rReport 
)

Definition at line 225 of file diag_eventdiagnosis.cpp.

bool faudes::IsModularDiagnosable ( const SystemVector &  rGsubs,
const GeneratorVector &  rKsubs 
)

Function definition for run-time interface.

bool faudes::IsModularDiagnosable ( const vector< const System * > &  rGSubs,
const vector< const Generator * > &  rKSubs,
std::string &  rReportString 
)

Definition at line 50 of file diag_modulardiagnosis.cpp.

bool faudes::IsModularDiagnosable ( const SystemVector &  rGsubs,
const GeneratorVector &  rKsubs,
string &  rReportString 
)

Definition at line 23 of file diag_modulardiagnosis.cpp.

bool faudes::IsMtcObs ( const MtcSystem &  rLowGen,
const EventSet &  rHighAlph 
)

Verification of the observer property.

For verifying if a natural projection has the observer property, one step in the observer algorithm is evaluated. If the resulting generator equals the input generator, then the natural projection on the abstraction alphabet is an observer.

Parameters:
rLowGen Input generator
rHighAlph High level alphabet
Returns:
true if the observer property holds
void faudes::IsMutuallyControllable ( const System &  rGen1,
const System &  rGen2,
bool &  rRes 
)

RTI wrapper.

bool faudes::IsMutuallyControllable ( const System &  rGen1,
const System &  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
bool faudes::IsNormal ( const System &  rPlantGen,
const Generator &  rSupCandGen 
)

IsNormal wrapper.

Wrapper for convenient access via the run-time interface.

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
bool faudes::IsRelativelyOmegaClosedUnchecked ( const Generator &  rGenPlant,
const Generator &  rGenCand 
)

Test for relative closedness, omega languages.

This variant does not perform consitency tests on the parameters. Neither does it handle the special cases on empty arguments. See also IsRelativelyOmegaClosed(const Generator&, const Generator& )

Parameters:
rGenPlant Generator GPlant
rGenCand Generator GCand
void faudes::LabelCorrection ( const std::multimap< Idx, DiagLabelSet > &  mm,
AttributeDiagnoserState &  attr 
)

Perform label correction on propagated failure type labels.

Parameters:
mm Propagated absolute failure type labels for a diagnoser state.
attr Output variable for the diagnoser state attribute.
void faudes::LabelCorrection ( const multimap< Idx, DiagLabelSet > &  mm,
AttributeDiagnoserState &  attr 
)

Definition at line 1047 of file diag_eventdiagnosis.cpp.

void faudes::LabelPropagation ( const DiagLabelSet &  lastLabel,
const DiagLabelSet &  failureTypes,
DiagLabelSet &  newLabel 
)

Generate a new label.

From the last label and the failure types that occurred on the way, the new label is generated.

Parameters:
lastLabel Diagnoser label of state estimate.
failureTypes Failure types that occurred.
newLabel Output variable for the new label.
void faudes::LanguageIntersection ( const GeneratorVector &  rGenVec,
Generator &  rResGen 
)

Language intersection.

See also LanguageUnion(const Generator&, const Generator&, Generator&); This version takes a vector of generators as argument to perform the intersection for multiple languages. The implementation calls the std intersection multiple times, future implementations may do better.

Parameters:
rGenVec Vector of input generators
rResGen Reference to resulting generator
void faudes::LanguageUnion ( const GeneratorVector &  rGenVec,
Generator &  rResGen 
)

Language union.

See also LanguageUnion(const Generator&, const Generator&, Generator&); This version takes a vector of generators as argument to perform the union for multiple languages. The implementation calls the std union multiple times, future implementations may do better.

Parameters:
rGenVec Vector of input generators
rResGen Reference to resulting generator
void faudes::LocalAccessibleReach ( const Generator &  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
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
bool faudes::LocalObservationConsistency ( const System &  rPlantGen,
const System &  rSpecGen,
const EventSet &  rHighAlph,
const EventSet &  rObsAlph 
)

Supervisor Reduction algorithm.

Computes a reduced supervisor from a given potentially non-reduced supervisor and the plant. This algorithm implements the results obtained in

R. Su and W. M. Wonham. Supervisor Reduction for Discrete-Event Systems. Discrete Event Dynamic Systems vol. 14, no. 1, January 2004.

Both, plant and supervisor MUST be deterministic and share the same alphabet!!!

Parameters:
rPlantGen Plant generator
rSpecGen Specification generator
rHighAlph high-level alphabet
rObsAlph observable alphabet
Returns:
True if a reduction was achieved
Exceptions:
Exception 
  • alphabets of generators don't match (id 100)
  • plant nondeterministic (id 201)
  • supervisor nondeterministic (id 203)
  • plant and supervisor nondeterministic (id 204)
void faudes::LoopCallback ( bool(*)(void)  pBreakFnct  ) 

Algorithm loop callback.

Set a callback function for libFAUDES algorithms. Applications are meant to use this interface to terminate an algorithm on user request. libFAUDES algorithms are meant to throw an execption when the callback function returns true. See also void LoopCallback(void).

Parameters:
pBreakFnct 
void faudes::LoopCallback ( void   ) 

Algorithm loop callback.

Calls the loop callback function and throws an exception if it returns true.

Exceptions:
Break on appliation request (id 110)
void faudes::LoopCallback ( bool   pBreakvoid  ) 

Definition at line 565 of file cfl_helper.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)
StateSet faudes::LowExitStates ( const Generator &  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)
GotoGenerator faudes::Lrm ( const Grammar &  gr,
uint  k 
)

Generate an LR(k) machine for a grammar.

Parameters:
gr the grammar
k a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1))
Returns:
the LR(k) machine
LrmTransitionMap faudes::Lrm1 ( const Grammar &  gr,
uint  k,
const Lr1ConfigurationSetSet &  configSetSet 
)

Generate outgoing transitions for an LR(k) machine for a given configuration set.

Parameters:
gr the grammar on which to work
k a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1))
configs the configuration set from which to generate the transitions
Returns:
outgoing transitions from the given configuration set as a map mapping the original configuration set and a grammar symbol to another configuration set
std::pair< LrmTransitionMap, Lr1ConfigurationSetSet > faudes::LrmLoop ( const Grammar &  gr,
uint  k,
const LrmTransitionMap &  transitions,
const Lr1ConfigurationSetSet &  states,
Lr1ConfigurationSetSet  examineStates 
)

Recursively generate all transitions and states for an LR(k) machine.

Parameters:
gr the grammar on which to work
k a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1))
transitions the transitions that are already found
states the states that are already found
examineStates the states that need to be examined for outgoing transitions
Returns:
a pair with the transition map and all states
Lr1Parser faudes::Lrp ( const Grammar &  gr,
const Grammar &  augGr,
const GotoGenerator &  gotoGen,
uint  k,
const Terminal &  augSymbol 
)

construct an LR(k) parser from a grammar and its LR(k) machine

Parameters:
gr the grammar on which to work
augGr augmented version of the grammar on which to work
gotoGen LR(k) machine of the grammar
k a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1))
augSymbol the terminal with which the grammar was augmented to create the augmented grammar
Returns:
set of parsing rules
std::set< Lr1ParserAction > faudes::LrpReduceRules ( const Grammar &  gr,
const Grammar &  augGr,
const GotoGenerator &  gotoGen,
uint  k 
)

construct the parsing rules for reducing from a grammar and its LR(k) machine

Parameters:
gr the grammar on which to work
augGr augmented version of the grammar on which to work
gotoGen LR(k) machine of the grammar
k a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1))
Returns:
set of reduce actions
std::set< Lr1ParserAction > faudes::LrpRules ( const Grammar &  gr,
const Grammar &  augGr,
const GotoGenerator &  gotoGen,
uint  k 
)

construct all parsing rules from a grammar and its LR(k) machine

Parameters:
gr the grammar on which to work
augGr augmented version of the grammar on which to work
gotoGen LR(k) machine of the grammar
k a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1))
Returns:
set of parsing rules
std::set< Lr1ParserAction > faudes::LrpShiftRules ( const Grammar &  gr,
const Grammar &  augGr,
const GotoGenerator &  gotoGen,
uint  k 
)

construct the parsing rules for shifting from a grammar and its LR(k) machine

Parameters:
gr the grammar on which to work
augGr augmented version of the grammar on which to work
gotoGen LR(k) machine of the grammar
k a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1))
Returns:
set of shift actions
static std::list< std::string > faudes::luafaudes_rl_complete ( lua_State *  L,
const std::string &  word 
) [static]

Definition at line 185 of file lbp_function.cpp.

static void faudes::luafaudes_rl_dmadd ( std::list< std::string > &  mlist,
const std::string &  prefix,
const std::string &  str,
const std::string &  suffix 
) [static]

Definition at line 49 of file lbp_function.cpp.

static int faudes::luafaudes_rl_getfield ( lua_State *  L,
const char *  s,
size_t  n 
) [static]

Definition at line 167 of file lbp_function.cpp.

static int faudes::luafaudes_rl_getmeta ( lua_State *  L,
bool  has_colon 
) [static]

Definition at line 138 of file lbp_function.cpp.

static void faudes::luafaudes_rl_getmetafn ( lua_State *  L  )  [static]

Definition at line 106 of file lbp_function.cpp.

static void faudes::luafaudes_rl_getmetaget ( lua_State *  L  )  [static]

Definition at line 122 of file lbp_function.cpp.

static int faudes::luafaudes_rl_getmetaindex ( lua_State *  L  )  [static]

Definition at line 88 of file lbp_function.cpp.

static bool faudes::luafaudes_rl_valididentifier ( const std::string &  str  )  [static]

Definition at line 39 of file lbp_function.cpp.

std::string faudes::MangleString ( const std::string &  str  ) 

Definition at line 143 of file lbp_function.cpp.

bool faudes::MeetsDiagnosabilityAssumptions ( const System &  rGen,
const AttributeFailureTypeMap &  rFailureTypeMap,
string &  rReportString 
)

Definition at line 160 of file diag_eventdiagnosis.cpp.

bool faudes::ModularDiagnoser ( const SystemVector &  rGsubs,
const GeneratorVector &  rKsubs,
GeneratorVector &  rDiagsubs 
)

Function definition for run-time interface.

bool faudes::ModularDiagnoser ( const SystemVector &  rGsubs,
const GeneratorVector &  rKsubs,
GeneratorVector &  rDiagSubs,
string &  rReportString 
)

Definition at line 128 of file diag_modulardiagnosis.cpp.

void faudes::mtcDeterministic ( const MtcSystem &  rGen,
std::vector< StateSet > &  rPowerStates,
std::vector< Idx > &  rDetStates,
MtcSystem &  rResGen 
)

Make generator deterministic.

(real function)

Second and third parameter hold the subsets + deterministic states in vectors

The multiway merge algorithm is based on a propsal in "Ted Leslie, Efficient Approaches to Subset Construction, Computer Science, University of Waterloo, 1995"

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
void faudes::mtcDeterministic ( const MtcSystem &  rGen,
std::map< Idx, StateSet > &  rEntryStatesMap,
MtcSystem &  rResGen 
)

Make generator deterministic.

(function wrapper)

The second parameter is an empty std::map<Idx,StateSet> which holds all the pairs of new states and their respective power states set. This 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
void faudes::mtcInvProject ( const MtcSystem &  rGen,
const EventSet &  rProjectAlphabet,
MtcSystem &  rResGen 
)
void faudes::mtcParallel ( const MtcSystem &  rGen1,
const MtcSystem &  rGen2,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
MtcSystem &  rResGen 
)

Parallel composition of two MtcSystems.

Parameters:
rGen1 First MtcSystem for parallel composition
rGen2 Second MtcSystem for parallel composition
rReverseCompositionMap 
rResGen Generator in which the result of the parallel composition is saved
void faudes::mtcProject ( const MtcSystem &  rGen,
const EventSet &  rProjectAlphabet,
std::map< Idx, StateSet > &  rEntryStatesMap,
MtcSystem &  rResGen 
)

Minimized Deterministic projection.

Does not modify generator. Calls project, determine and statemin. See functions for details.

Parameters:
rGen Reference to generator
rProjectAlphabet Projection alphabet
rEntryStatesMap Reference to entry states map, see Deterministic(..) (result)
rResGen Reference to resulting deterministic generator (result)
void faudes::mtcStateMin ( const MtcSystem &  rGen,
MtcSystem &  rResGen 
)

RTI wrapper.

See also mtcStateMin(MtcSystem&, MtcSystem&).

void faudes::mtcStateMin ( MtcSystem &  rGen,
MtcSystem &  rResGen,
std::vector< StateSet > &  rSubsets,
std::vector< Idx > &  rNewIndices 
)

State Minimization This function implements the (n*log n) set partitioning algorithm by John E.

Hopcroft extended to colored marking. Given generator will be made accessible before computing minimized generator.

Parameters:
rGen MtcSystem
rResGen Minimized MtcSystem (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 505)
void faudes::mtcStateMin ( MtcSystem &  rGen,
MtcSystem &  rResGen 
)

State Minimization This function implements the (n*log n) set partitioning algorithm by John E.

Hopcroft extended to colored marking. Given generator will be made accessible before computing minimized generator.

Parameters:
rGen MtcSystem
rResGen Minimized MtcSystem (result)
Exceptions:
Exception 
  • Input automaton nondeterministic (id 505)
void faudes::mtcSupConClosed ( const MtcSystem &  rPlantGen,
const MtcSystem &  rSpecGen,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
MtcSystem &  rResGen 
)

Supremal Controllable Sublanguage.

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

Real mtcSupCon function

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 MtcSystem
rSpecGen Specification MtcSystem
rReverseCompositionMap std::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function
rResGen Reference to resulting MtcSystem, the minimal restrictive supervisor
Exceptions:
Exception 
  • Alphabets of generators don't match (id 500)
  • plant nondeterministic (id 501)
  • spec nondeterministic (id 503)
  • plant and spec nondeterministic (id 504)
void faudes::mtcSupConNB ( const MtcSystem &  rPlantGen,
const MtcSystem &  rSpecGen,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
MtcSystem &  rResGen 
)

Nonblocking Supremal Controllable Sublanguage.

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

Real mtcSupConNB function

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 MtcSystem
rSpecGen Specification MtcSystem
rReverseCompositionMap std::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function
rResGen Reference to resulting MtcSystem, the minimal restrictive nonblocking supervisor
Exceptions:
Exception 
  • Alphabets of generators don't match (id 500)
  • plant nondeterministic (id 501)
  • spec nondeterministic (id 503)
  • plant and spec nondeterministic (id 504)
void faudes::mtcSupConParallel ( const MtcSystem &  rPlantGen,
const MtcSystem &  rSpecGen,
const EventSet &  rUAlph,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
MtcSystem &  rResGen 
)

Fast parallel composition for computation for the mtcSupConNB.

Composition stops at transition paths that leave the specification by uncontrollable events in plant.

Parameters:
rPlantGen Plant MtcSystem
rSpecGen Specification MtcSystem
rUAlph Uncontrollable Events
rReverseCompositionMap std::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function
rResGen Reference to resulting MtcSystem, the less restrictive supervisor
void faudes::mtcSupConUnchecked ( const MtcSystem &  rPlantGen,
const EventSet &  rCAlph,
MtcSystem &  rSupGen 
)

Supremal Controllable Sublangauge (Real SupCon function; unchecked).

Both, plant and spec MUST be deterministic and share the same alphabet!!!

Most likely will result in blocking states.

Parameters:
rPlantGen Plant generator
rCAlph Controllable events
rSupGen Specification 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)
void faudes::mtcUniqueInit ( MtcSystem &  rGen  ) 

Definition at line 34 of file mtc_project.cpp.

PushdownGenerator faudes::Nda ( const PushdownGenerator &  pd  ) 

Input must have passed Rpp! remodells the generator to prevent double (or multiple) acceptance of the same input string.

Parameters:
pd the generator
Returns:
remodelled generator without double acceptance
void * faudes::NDeviceListen ( void *  arg  ) 
void faudes::NormalityConsistencyCheck ( const Generator &  rL,
const EventSet &  rOAlph,
const Generator &  rK 
)

NormalityConsistencyCheck: Consistency check for normality input data.

Used e.g. in IsNormal(), and SupNorm(). See exceptions.

Parameters:
rL generator of language L
rOAlph observable alphabet
rK generator of language K
Exceptions:
Exception 
  • nondeterministic parameter(s) (id: 101)
  • rOAlph not subset of rL.Alphabet() (id: 100)
  • Alphabets of generators don't match (id: 100)
  • K is not subset of L (id 0)
bool faudes::OmegaControlledLiveness ( Generator &  rSupCandGen,
const EventSet &  rCAlph,
const StateSet &  rPlantMarking,
std::map< Idx, Idx > &  rControllerStatesMap,
std::map< Idx, EventSet > &  rFeedbackMap 
)

Definition at line 873 of file syn_wsupcon.cpp.

bool faudes::OmegaControlledLiveness ( Generator &  rSupCandGen,
const EventSet &  rCAlph,
const StateSet &  rPlantMarking,
std::map< Idx, EventSet > &  rFeedbackMap 
)

Definition at line 682 of file syn_wsupcon.cpp.

bool faudes::OmegaControlledLiveness ( Generator &  rSupCandGen,
const EventSet &  rCAlph,
const StateSet &  rPlantMarking 
)

Definition at line 544 of file syn_wsupcon.cpp.

void faudes::OmegaSupConNBUnchecked ( const Generator &  rPlantGen,
const EventSet &  rCAlph,
const Generator &  rSpecGen,
StateSet &  rPlantMarking,
Generator &  rResGen 
)

Definition at line 1345 of file syn_wsupcon.cpp.

void faudes::OmegaSupConNormNBUnchecked ( const Generator &  rPlantGen,
const EventSet &  rCAlph,
const EventSet &  rOAlph,
const Generator &  rSpecGen,
StateSet &  rPlantMarking,
std::map< Idx, Idx > &  rObserverStateMap,
std::map< Idx, EventSet > &  rFeedbackMap,
Generator &  rResGen 
)

Definition at line 1463 of file syn_wsupcon.cpp.

void faudes::OmegaSupConProduct ( const Generator &  rPlantGen,
const EventSet &  rCAlph,
const Generator &  rSpecGen,
std::map< OPSState, Idx > &  rProductCompositionMap,
Generator &  rResGen 
)

Definition at line 1132 of file syn_wsupcon.cpp.

void faudes::Parallel ( const Generator &  rGen1,
const Generator &  rGen2,
std::map< std::pair< Idx, Idx >, Idx > &  rCompositionMap,
Generator &  rResGen 
)

Parallel composition.

See Parallel(const Generator&, const Generator&, Generator&). This version fills a composition map to map pairs of old states to new states.

Parameters:
rGen1 First generator
rGen2 Second generator
rCompositionMap Composition map (map< pair<Idx,Idx>, Idx>)
rResGen Reference to resulting parallel composition generator
void faudes::Parallel ( const Generator &  rGen1,
const Generator &  rGen2,
ProductCompositionMap &  rCompositionMap,
StateSet &  rMark1,
StateSet &  rMark2,
Generator &  rResGen 
)

Parallel composition.

See Parallel(const Generator&, const Generator&, Generator&). This version fills a composition map to map pairs of old states to new states. It also returns the sets of states marked w.r.t. the argument generators.

Parameters:
rGen1 First generator
rGen2 Second generator
rCompositionMap Composition map (map< pair<Idx,Idx>, Idx>)
rMark2 States maked in first generator
rMark1 States maked in second generator
rResGen Reference to resulting parallel composition generator
std::set< Lr1Configuration > faudes::PassesX ( const Lr1Configuration &  config,
const GrammarSymbolPtr &  symbol 
)

Try to shift the dot in a configuration over a specified symbol.

Parameters:
config the configuration
symbol the symbol over which to shift
Returns:
set of size one that contains the new configuration or an empty set if the specified symbol was not found directly after the dot
const std::string& faudes::PathSeparator ( void   ) 

Std dir-separator.

Returns:
Separator as one-char string
std::string faudes::PluginsString (  ) 

Return FAUDES_PLUGINS as std::string.

Returns:
std::string with FAUDES_VERSION
GrammarSymbolWordSet faudes::PostCl ( const GrammarSymbolVector &  word  ) 

Construct the postfix closure of a word.

Parameters:
word the word
Returns:
all postfixes of the word including lambda
std::string faudes::PrependDirectory ( const std::string &  rDirectory,
const std::string &  rFileName 
)

Construct full path from directory and filename.

Parameters:
rDirectory Directory eg "/home/friend/data"
rFileName File eg "generator.gen"
Returns:
Path eg "/home/friend/data/generator.gen"
void faudes::PrintTransitions ( const std::multimap< Transition, std::pair< std::vector< StackSymbol >, std::vector< StackSymbol > > > &  transitions  ) 

For debugging, prints a transitions with their pop and push attributes.

Parameters:
transitions multimap containing the transitions
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)
void faudes::Product ( const Generator &  rGen1,
const Generator &  rGen2,
std::map< std::pair< Idx, Idx >, Idx > &  rCompositionMap,
Generator &  rResGen 
)

Product composition.

See Product(const Generator&, const Generator&, Generator&). This version fills given composition map to map pairs of old states to new states.

Parameters:
rGen1 First generator
rGen2 Second generator
rCompositionMap Composition map (map< pair<Idx,Idx>, Idx>)
rResGen Reference to resulting product composition generator
void faudes::Product ( const Generator &  rGen1,
const Generator &  rGen2,
std::map< std::pair< Idx, Idx >, Idx > &  rCompositionMap,
StateSet &  rMark1,
StateSet &  rMark2,
Generator &  rResGen 
)

Product composition.

See Product(const Generator&, const Generator&, Generator&). This version fills given composition map to map pairs of old states to new states. It also returns the sets of states marked w.r.t. the argument generators.

Parameters:
rGen1 First generator
rGen2 Second generator
rCompositionMap Composition map (map< pair<Idx,Idx>, Idx>)
rMark2 States maked in first generator
rMark1 States maked in second generator
rResGen Reference to resulting product composition generator
void faudes::Project ( const Generator &  rGen,
const EventSet &  rProjectAlphabet,
std::map< Idx, StateSet > &  rEntryStatesMap,
Generator &  rResGen 
)

Deterministic projection.

Projects the generated and marked languages to a subalphabet of the original alphabet, and subsequently calls Deterministic 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)
void faudes::ProjectNonDet_barthel ( Generator &  rGen,
const EventSet &  rProjectAlphabet 
)

Definition at line 679 of file cfl_project.cpp.

void faudes::ProjectNonDet_fbr ( Generator &  rGen,
const EventSet &  rProjectAlphabet 
)

Definition at line 797 of file cfl_project.cpp.

void faudes::ProjectNonDet_graph ( Generator &  rGen,
const EventSet &  rProjectAlphabet 
)

Definition at line 489 of file cfl_project.cpp.

void faudes::ProjectNonDet_opitz ( Generator &  rGen,
const EventSet &  rProjectAlphabet 
)

Definition at line 40 of file cfl_project.cpp.

void faudes::ProjectNonDet_ref ( Generator &  rGen,
const EventSet &  rProjectAlphabet 
)

Definition at line 124 of file cfl_project.cpp.

void faudes::ProjectNonDet_scc ( Generator &  rGen,
const EventSet &  rProjectAlphabet 
)

Definition at line 1052 of file cfl_project.cpp.

void faudes::ProjectNonDet_simple ( Generator &  rGen,
const EventSet &  rProjectAlphabet 
)

Definition at line 599 of file cfl_project.cpp.

void faudes::PushdownAccessible ( const PushdownGenerator &  pd,
PushdownGenerator &  res 
)

Construct the accessible part of a pushdown generator.

Parameters:
pd pushdown generator to make accessible
res accessible pushdown generator
void faudes::PushdownConstructController ( const PushdownGenerator &  spec,
const System &  plant,
PushdownGenerator &  res 
)

Construct a minimal restrictive sound controller.

Alphabets of specification and plant are expected to be equal.

Parameters:
spec the specification
plant the plant
res the result
Returns:
void faudes::PushdownNonblock ( const PushdownGenerator &  pd,
PushdownGenerator &  res,
bool  print = false 
)

Make a pushdown generator nonblocking.

This will remodel the pushdown generator and replace stack symbols with new ones.

Parameters:
pd pushdown generator to make nonblocking
res nonblocking pushdown generator
print temporary debug parameter
void faudes::ReachableEvents ( const Generator &  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)
EventSet faudes::ReachableEvents ( const Generator &  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
std::set< std::string > faudes::ReadDirectory ( const std::string &  rDirectory  ) 

Read the contents of the specified directors.

Parameters:
rDirectory Directory eg "/home/friend/data"
Returns:
List of files, e.g. "gen1.gen gen2.gen data subdir"
bool faudes::rec_ComputeLoopPreservingObserver ( const System &  rGen,
const EventSet &  rInitialHighAlph,
EventSet &  rHighAlph,
const std::vector< Idx > &  rDiffVector,
Idx  numberEvents,
Idx  currentNumberEvents,
Idx  currentLocation,
EventSet  chosenEvents 
)

rec_ComputeLoopPreservingObserver(rGen, rInitialHighAlph, rHighAlph, rDdffVector, numberEvents, currentNumberEvents, currentLocation, hosenEvents)

void faudes::rec_OptimalColorSet ( const MtcSystem rGen,
const std::vector< Idx > &  rColorVector,
Idx  colorNumber,
ColorSet rOptimalColors,
Idx &  rOptimalNumberStates,
Idx &  rOptimalNumberColors,
const EventSet rHighAlph,
EventSet rOptimalHighAlph 
)

Recursively find an optimal set of colors to be removed.

This function recursively enumerates all possible subsets of colors that can be removed without affecting supervisor synthesis and remembers the color set that leads to the smallest hierarchical abstraction. It is called by the function OptimalColorSet.

Parameters:
rGen input colored marking generator
rColorVector set of colors of the generator (ordered!)
colorNumber number of colors currently removed
rOptimalColors current optimal set of colors
rOptimalNumberStates current optimal number of states
rOptimalNumberColors size of the optimal color set
rHighAlph initial high-level alphabet
rOptimalHighAlph optimal high-level alphabet
void faudes::recursiveCheckLCC ( const TransSetX2EvX1 &  rRevTransSet,
const EventSet &  rControllableEvents,
const EventSet &  rHighAlph,
Idx  currentState,
StateSet &  rDoneStates 
)

Find states that fulfill the lcc condition.

This function performs a backward reachability computation to determine states where the lcc condition is fulfilled

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:
rRevTransSet Reversely ordered transition relation
rControllableEvents Set of controllable events
rHighAlph Abstraction alphabet
currentState Index of the start state of the backward reachability computation
rDoneStates Set of already investigated states
Returns:
True if the condition is fulfilled, false otherwise
bool faudes::recursiveCheckMSABackward ( const Generator &  rGen,
const TransSetX2EvX1 &  rRevTransSet,
const EventSet &  rHighAlph,
Idx  currentState,
StateSet &  rDoneStates 
)

Check if the msa-observer conditions is fulfilled for a given state.

This function performs a backward reachability computation to determine if the msa-observer condition is fulfilled for a given state.

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
rRevTransSet Reversely ordered transition relation
rHighAlph Abstraction alphabet
currentState Index of the state to be checked
rDoneStates Set of already investigated states
Returns:
True if the condition is fulfilled, false otherwise
bool faudes::recursiveCheckMSAForward ( const Generator &  rGen,
const EventSet &  rHighAlph,
Idx  currentState,
StateSet &  rDoneStates 
)

Check if the msa-observer conditions is fulfilled for a given state.

This function performs a forward reachability computation to determine if the msa-observer condition is fulfilled for a given state.

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
currentState Index of the state to be checked
rDoneStates Set of already investigated states
Returns:
True if the condition is fulfilled, false otherwise
bool faudes::relabel ( Generator &  rGenRelabel,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
std::vector< Idx > &  rNewPartitions,
std::map< Idx, Idx > &  rMapStateToPartition,
std::map< Transition, Transition > &  rMapChangedTransReverse,
std::map< Transition, Idx > &  rMapChangedTrans,
std::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
bool faudes::relabel ( Generator &  rGenRelabel,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
vector< Idx > &  rNewPartitions,
map< Idx, Idx > &  rMapStateToPartition,
map< Transition, Transition > &  rMapChangedTransReverse,
map< Transition, Idx > &  rMapChangedTrans,
map< Idx, EventSet > &  rMapRelabeledEvents 
)

Definition at line 1499 of file op_observercomputation.cpp.

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

Delete a file.

Parameters:
rFileName Name of file to delete
PushdownGenerator faudes::RemoveUselessTransitions ( const PushdownGenerator &  pd  ) 

Remove certain transitions that can never be used because their pop symbol can never be the stack top.

Parameters:
pd the generator from which to remove transitions
Returns:
generator with removed transitions
PushdownGenerator faudes::RenG ( const std::string  word,
const PushdownGenerator &  pd 
)

Adds an annotation to each stack symbol of the generator.

Each stack symbol will be copied and added to to generator with the annotation preceding the original name.

Parameters:
word word with which the stack symbols will be annotated
pd pushdown automaton to be annotated
Returns:
copy of the parameter automaton with annotated states
PushdownGenerator faudes::RenQ ( const std::string  word,
const PushdownGenerator &  pd 
)

Associates each state of the generator with an annotation.

Each state's merge attribute will be set to a MergeStateAnnotation. The MergeStateAnnotation will contain the annotation.

Parameters:
word word with which the states will be annotated
pd pushdown automaton to be annotated
Returns:
copy of the parameter automaton with annotated states
PushdownGenerator faudes::Rep0 ( const PushdownGenerator &  pd  ) 

Removes all edges popping lambda.

Parameters:
pd pushdown automaton
Returns:
pushdown automaton without lambda popping edges
PushdownGenerator faudes::Rep2 ( const PushdownGenerator &  pd  ) 

Removes transitions popping more than one stack symbol.

Inserts new transitions instead that only pop one stack symbol.

Parameters:
pd the generator, which must NOT contain lambda pops
Returns:
generator with altered transitions
PushdownGenerator faudes::Rnce ( const PushdownGenerator &  pd,
const System &  s 
)

Remove non-controllable ears from a generator.

The initial state must not be an ear. Times and Split must have been executed on the generator.

Parameters:
pd the pushdown generator with ears
s the system that was used in the intersection operation to generate the pushdown generator
Returns:
pushdowngenerator without noncontrollable ears
Grammar faudes::Rnpp ( const Grammar &  gr  ) 

Remove all productions from a grammar that are nonproductive, i.

e. they contain nonterminals that are not eliminable.

std::set< Nonterminal > faudes::Rnpp1 ( const Grammar &  gr,
const std::set< Nonterminal > &  ntSet 
)

Find all nonterminals that are eliminable in one step and assuming that a certain set of nonterminals has already been eliminated.

Parameters:
gr the grammar
ntSet the set of already eliminated nonterminals
Returns:
eliminable symbols including the already eliminated ones
std::set< Nonterminal > faudes::Rnppl ( const Grammar &  gr,
const std::set< Nonterminal > &  ntSet 
)

Find all nonterminals that are eliminable in as many steps as needed and assuming that a certain set of nonterminals has already been eliminated.

Parameters:
gr the grammar
ntSet the set of already eliminated nonterminals
Returns:
eliminable symbols including the already eliminated ones
PushdownGenerator faudes::Rpp ( const PushdownGenerator &  pd  ) 

Restricts a pushdown generator to a pushdown generator with transitions that are either read (p,a,lambda,lambda,q), pop (p,lambda,x,lambda,q) or push (p,lambda,x,yx,q).

Parameters:
pd the generator, which must not have transitions that pop more than one stack symbol
Returns:
generator
PushdownGenerator faudes::Ruls ( const PushdownGenerator &  pd  ) 

Remove useless states of a pushdown generator.

Parameters:
pd the generator, which is required to have passed Split() before
Returns:
generator that only has useable states.
bool faudes::Ruls1 ( Idx  state,
const PushdownGenerator &  pd 
)
Grammar faudes::Rup ( const Grammar &  gr  ) 

Remove all unreachable productions and nonterminals from the grammar.

Parameters:
gr grammar with productions to be removed
Returns:
grammar with only reachable productions
void * faudes::SDeviceSynchro ( void *  arg  ) 
void faudes::SearchScc ( const Idx  state,
int &  rCount,
const Generator rGen,
StateSet rNewStates,
std::stack< Idx > &  rSTACK,
StateSet rStackStates,
std::map< const Idx, int > &  rDFN,
std::map< const Idx, int > &  rLOWLINK,
std::set< StateSet > &  rSccSet,
StateSet rRoots 
)

Search for strongly connected components (SCC)*** This function partitions the stateset of a generator into equivalence classes such that states x1 and x2 are equivalent iff there is a path from x1 to x2 AND a path from x2 to x1.

This function implements the algorithm based on a depth first search presented in: -Aho, Hopcroft, Ullman: The Design and Analysis of Computer Algorithms-

Most of the comments in this function have been literally taken from this book!

Parameters:
state State, from which the current recursion is started.
rCount denotes the current depth of the recursion.
rGen Generator under investigation
rNewStates Set of states that up to now were not found by the depth first search
rSTACK stack of state indices
rStackStates set of states whose indices are on STACK.
rDFN map assigning to each state its Depth-First Number
rLOWLINK map assigning to each state its LOWLINK Number
rSccSet result - the set of strongly connected components
rRoots,: result - the set of states that each are root of some SCC.
void faudes::SearchScc ( const Idx  vState,
int &  vRcount,
const Generator &  rGen,
const SccFilter &  rFilter,
StateSet &  rTodo,
std::stack< Idx > &  rStack,
StateSet &  rStackStates,
std::map< const Idx, int > &  rDfn,
std::map< const Idx, int > &  rLowLnk,
std::list< StateSet > &  rSccList,
StateSet &  rRoots 
)

Search for strongly connected components (SCC).

This function partitions the stateset of a generator into equivalent classes such that states x1 and x2 are equivalent iff there is a path from x1 to x2 AND a path from x2 to x1.

This function implements the algorithm based on a recursive depth first search presented in:

-- Aho, Hopcroft, Ullman: The Design and Analysis of Computer Algorithms --

While the original algorithm works on a directed graph, this implementation adds some features that refer to transition systems and allow to filter SCCs on the run. The filter condition is specified by the SccFilter parameter rFilter.

Note: this version is derived from earlier implementations used in various plug-ins; in due course, this version will replace earlier versions.

Note: Due to the recursive implementation, this function requires a stack size proportional to the largest SCC. We have experienced typical default configurations to be good for a depth of about 80000 (Mac OSX 10.6, Debian 7.4). For SCCs exceeding the default stack size, you may adjust the operating system parameters accordingly. On Unix/Linux/MacOsX this is done by the shell command "ulimit -s hard". A future revision of SearchSCC() may be re-designed to circumvent this inconvenient issue.

Note: for a convenience API see also ComputeScc()

Parameters:
vState State, from which the current recursion is started.
vRcount Denotes the current depth of the recursion.
rGen Transition system to investigate
rFilter Filter out specified transitions
rTodo Set of states that up to now were not found by the depth first search.
rStack Stack of states to represent current path.
rStackStates Set of states that are in rStack
rDfn Map assigning to each state idx its Depth-First Number.
rLowLnk Map assigning to each state its LOWLINK Number.
rSccList Set SCCs (accumulative result).
rRoots Set of states that each are root of some SCC (accumulative result).
void faudes::SetComposedStateNames ( const Generator &  rGen1,
const Generator &  rGen2,
const std::map< std::pair< Idx, Idx >, Idx > &  rCompositionMap,
Generator &  rGen12 
)

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

Purely cosmetic.

Parameters:
rGen1 First generator
rGen2 Second generator
rCompositionMap Composition map (map< pair<Idx,Idx>, Idx>)
rGen12 Reference to resulting parallel composition generator
void faudes::SetDifference ( const vGenerator &  rGenA,
const vGenerator &  rGenB,
EventSet &  rRes 
)

RTI convenience function.

void faudes::SetIntersection ( const vGenerator &  rGenA,
const vGenerator &  rGenB,
EventSet &  rRes 
)

RTI convenience function.

void faudes::SetUnion ( const vGenerator &  rGenA,
const vGenerator &  rGenB,
EventSet &  rRes 
)

RTI convenience function.

Grammar faudes::Sp2Lr ( const PushdownGenerator &  pd  ) 

Transform a simple pushdown generator into an LR(1) grammar.

Parameters:
pd the generator
Returns:
the grammar
Grammar faudes::Sp2Lr2 ( const PushdownGenerator &  pd  ) 

Transform a simple pushdown generator into an LR(1) grammar.

Memory-optimized version. May take significantly longer than the non-optimized version.

Parameters:
pd the generator
Returns:
the grammar
PushdownGenerator faudes::Split ( const PushdownGenerator &  pd  ) 

Splits the states of a pushdown generator into heads and ears.

Each ear is associated with a stack symbol.

Transitions will always be either from ear to head or from head to ear. Transitions from ear to head will always pop the stack symbol associated with the ear. Transitions from head to ear will always read lambda and pop and push the stack symbol associated with the ear.

Parameters:
pd pushdown generator to be split
Returns:
the split pushdown generator
void faudes::StateMin ( Generator &  rGen,
Generator &  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(Generator&,Generator&).

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)
void faudes::StateMin ( Generator &  rGen,
Generator &  rResGen 
)

State set minimization.

Constructs a generator with minimal stateset while preserving the generated und marked languages. This function implements the (n*log n) set partitioning algorithm by John E. Hopcroft. The given generator will be made accessible before computing minimized generator. See also StateMin(Generator&,Generator&,std::vector<StateSet>&,std::vector<Idx>&).

Parameters:
rGen Generator
rResGen Minimized generator (result)
Exceptions:
Exception Input automaton nondeterministic (id 101)
std::string faudes::StringSubstitute ( const std::string &  rString,
const std::string &  rFrom,
const std::string &  rTo 
)

Substitute in string.

Parameters:
rString Source string to substitute
rFrom String to match
rTo Replacement to fill in
Returns:
Result string
void faudes::SupConClosed ( const Generator &  rPlantGen,
const EventSet &  rCAlph,
const Generator &  rSpecGen,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
Generator &  rResGen 
)

Supremal Controllable and Closed Sublanguage.

Implementation of SupConClosed.

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

This version sets up a "composition map" provided as a reference parameter. The map is restricted such that its range matches the resulting 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 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)
void faudes::SupConClosedUnchecked ( const Generator &  rPlantGen,
const EventSet &  rCAlph,
Generator &  rSupCandGen 
)

Supremal Controllable Sublangauge (internal function).

Indentifies and deletes "critical" states in the supervisor candidate, in order to achieve controllability. This version of SupConClosed performs no consistency test of the given parameter. In order to obtain indeed the supremal sublanguage, the state space of the candidate must be rich enough to discriminate plant states. This can be done by e.g. setting up the candidate SupConParallel.

In general, the result is blocking.

Parameters:
rPlantGen Plant generator
rCAlph Controllable events
rSupCandGen Supervisor candidate generator
void faudes::SupConNBUnchecked ( const Generator &  rPlantGen,
const EventSet &  rCAlph,
const Generator &  rSpecGen,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
Generator &  rResGen 
)

Nonblocking Supremal Controllable Sublanguage (internal function).

This version of SupConNB performs no consistency test of the given parameter. It set's up a "composition map" as in the parallel composition, however, the map may still contain states that have been removed from the result to obtain controllability.

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 System, 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)
void faudes::SupConNormClosed ( const System &  rPlantGen,
const Generator &  rSpecGen,
Generator &  rResGen 
)

rti wrapper

void faudes::SupConNormClosedUnchecked ( const Generator &  rPlantGen,
const EventSet &  rCAlph,
const EventSet &  rOAlph,
Generator &  rObserverGen,
Generator &  rSupCandGen 
)

Supremal Normal Controllable Sublangauge (internal function).

Indentifies and deletes conflicting transitions to obtain a controllable and prefix-normal sublanguage. This function is a bit experimental it depends on various unverified preconditions and conjectures -- use only after careful code-review. The completely independent implementation SupNormConClosed should be fine

Conditions

  • controllabel events as specified explicitly must be a subset of the observable events
  • L(H) <= L(G)
  • stateset of H must be sufficiently rich to discriminate states in G (e.g. initialise by H:=H' x G)
  • H_obs must be "a" observer automaton for H w.r.t. observable events (e.g. initialize with p_inv p H)
Parameters:
rPlantGen Plant generator G
rCAlph Controllable events
rOAlph Observable events
rObserverGen Observer H_obs
rSupCandGen Closed-loop candidate H
void faudes::SupConNormNB ( const System &  rPlantGen,
const Generator &  rSpecGen,
Generator &  rResGen 
)

rti wrapper

void faudes::SupConProduct ( const Generator &  rPlantGen,
const EventSet &  rCAlph,
const Generator &  rSpecGen,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
Generator &  rResGen 
)

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

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

This internal function performs no consistency test of the given parameter. It set's up a "composition map" as in the product composition, however, the map may still contain states that have been removed from the result to obtain controllability.

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
void faudes::SupNorm ( const System &  rPlantGen,
const Generator &  rSpecGen,
Generator &  rResGen 
)

rti wrapper

void faudes::SupNormClosed ( const System &  rPlantGen,
const Generator &  rSpecGen,
Generator &  rResGen 
)

rti wrapper

bool faudes::SupNormSP ( Generator &  rL,
const EventSet &  rOAlph,
const Generator &  rK,
Generator &  rResult 
)

Definition at line 29 of file hio_functions.cpp.

bool faudes::SupPrefixClosed ( const Generator &  rK,
Generator &  rResult 
)

SupPrefixClosed: supremal closed sublanguage of K by cancelling all tranistions leading to a non-marked state.

Returns false on empty result. todo: implement test routines, verify correctness

Parameters:
rK marks the (not necessarily closed) language K=Lm(rK)
rResult generates and marks the supremal closed sublanguage, where L(rResult)=Lm(rResult)
Returns:
true for nonempty result
Exceptions:
Exception 
  • todo: check determinism of rK
void faudes::SupRelativelyPrefixClosedUnchecked ( const Generator &  rPlantGen,
const Generator &  rSpecGen,
std::map< std::pair< Idx, Idx >, Idx > &  rCompositionMap,
Generator &  rResGen 
)

Supremal Relatively Closed Sublanguage (internal function).

This version of SupRelativelyPrefixClosed performs no consistency test of the given parameter. It set's up a "composition map" as in the parallel composition, however, the map may still contain states that have been removed from the result to obtain controllability.

Parameter restrictions: both generators must be deterministic and have the same alphabet.

Parameters:
rPlantGen Plant G
rSpecGen Specification Generator E
rResGen Reference to resulting Generator,
void faudes::SupTconNBUnchecked ( const Generator &  rPlantGen,
const EventSet &  rCAlph,
const EventSet &  rFAlph,
const EventSet &  rPAlph,
const Generator &  rSpecGen,
std::map< std::pair< Idx, Idx >, Idx > &  rCompositionMap,
Generator &  rResGen 
)

Definition at line 211 of file syn_tsupcon.cpp.

void faudes::SupTconUnchecked ( const Generator &  rPlantGen,
const EventSet &  rCAlph,
const EventSet &  rFAlph,
const EventSet &  rPAlph,
const EventSet &  rCPAlph,
Generator &  rSupCandGen 
)

Definition at line 40 of file syn_tsupcon.cpp.

void* faudes::SwigCastPtr ( void *  ptr,
swig_type_info *  from,
swig_type_info *  ty 
)

Definition at line 83 of file lbp_function.cpp.

swig_lua_userdata* faudes::SwigUserData ( lua_State *  L,
int  index 
)

Definition at line 114 of file lbp_function.cpp.

int faudes::syncSend ( int  dest,
const char *  data,
int  len,
int  flag 
)

Definition at line 248 of file iop_simplenet.cpp.

bool faudes::Te ( const PushdownGenerator &  pd,
const Transition &  trans,
const std::vector< Idx > &  pop,
const std::vector< Idx > &  push 
)

Test a transition for reachability.

Parameters:
pd the pushdown generator
trans the transition to test for reachability
pop the pop of the transitions to test for reachability
push the push of the transitions to test for reachability
Returns:
true if the transition is reachable, else false
void faudes::TestAc (  ) 

all Ac tests

void faudes::TestAcAccessible (  ) 

Test if Ac makes the test generator accessible.

void faudes::TestAlternativeAccessible ( Generator &  rGen  ) 

Alternative accessibility algorithm.

We use the alternative accessibility algorithm from tutorial 6 for our example plugin. The implementation uses a todo stack to discover accessible states and finaly remove all other states from the input generator.

Example:

pex_g_notacc.png
Parameters:
rGen Input generator
void faudes::TestAug (  ) 

All Aug Tests.

void faudes::TestAugSuccess (  ) 

Augment a grammar which should result in a successful augmentation.

void faudes::TestDesc (  ) 

All Desc Tests.

Includes Testing Desc1 since Desc1 is just an iterator.

void faudes::TestDesc11 (  ) 

All Desc11 Tests.

void faudes::TestDesc11Nonterminal (  ) 

Test Desc11 with a nonterminal at the beginning of afterDot.

void faudes::TestDesc11Terminal (  ) 

Test Desc11 with a terminal at the beginning of afterDot.

void faudes::TestDescInitial (  ) 

All DescInitial Tests.

void faudes::TestDescInitialFindTwo (  ) 

Test Desc Initial if it finds the two correct starting configurations.

void faudes::TestDescSelectedConfigs (  ) 

Test Desc with some configurations.

void faudes::TestDim (  ) 

All Dim Tests.

void faudes::TestDimNewFinalStates (  ) 

Test if final states are set correctly after the removal auf the augment symbol.

void faudes::TestDimNoAugment (  ) 

Test if the augment symbol transitions were successfully removed from the generator and the new number of transitions is correct.

void faudes::TestEnd ( std::string  name  ) 

write to console to indicate end of test

Parameters:
name name of the test
void faudes::TestFds (  ) 

All Fds tests.

void faudes::TestFdsWords (  ) 

Test if Fds returns all expected words.

void faudes::TestFilter (  ) 

All Filter tests.

void faudes::TestFilter1 (  ) 

All Filter1 tests.

void faudes::TestFilter1MixedGrammarSymbols (  ) 

Filter a nonterminal from a vector of terminals and nonterminals.

void faudes::TestFilter1Nothing (  ) 

filter from an empty word

void faudes::TestFilterMixedGrammarSymbols (  ) 

Filter a nonterminal from a vector of terminals and nonterminals.

void faudes::TestFilterNothing (  ) 

filter from an empty word

void faudes::TestFirst (  ) 

All First tests.

void faudes::TestFirstA (  ) 

All FirstA tests.

void faudes::TestFirstAll (  ) 

All FirstAll tests.

void faudes::TestFirstAllNonterminalsIrreducible (  ) 

Test with Nonterminals and an irreducible word as input.

void faudes::TestFirstAllNonterminalsIrreducibleWord (  ) 

Definition at line 830 of file pd_alg_first_test.cpp.

void faudes::TestFirstAllNonterminalsReducible (  ) 

Test with Nonterminals and a reducible word as input.

void faudes::TestFirstAllNonterminalsReducibleWord (  ) 

Definition at line 867 of file pd_alg_first_test.cpp.

void faudes::TestFirstAllTerminalsOnly (  ) 

Test with only Terminals as input.

void faudes::TestFirstASelectedWords (  ) 

Test for some selected word if the correct set of terminals is returned.

void faudes::TestFirstL (  ) 

All FirstL tests.

Includes testing of First1, because First1 needs to be called recursively in order to be tested correctly. FirstL does nothing else than calling First1 recursively.

void faudes::TestFirstLeq1 (  ) 

All FirstLeq1 tests.

void faudes::TestFirstLeq1OneNonempty (  ) 

Test with k = 1 and a word that results in a nonempty first set.

void faudes::TestFirstLeq1TwoNonempty (  ) 

Test with k = 2 and a word that results in a nonempty first set.

void faudes::TestFirstLeq1ZeroEmpty (  ) 

Test with k = 0 and a word that results in an empty first set.

void faudes::TestFirstLeq1ZeroNonempty (  ) 

Test with k = 0 and a word that results in a nonempty first set.

void faudes::TestFirstLMap (  ) 

Test if the mapping function produced by FirstL is correct.

void faudes::TestFirstRed (  ) 

All FirstRed tests.

void faudes::TestFirstRedConsistentWord (  ) 

Test FirstRed with a consistent word as input.

void faudes::TestFirstRedInconsistentWord (  ) 

Test FirstRed with an inconsistent word as input.

void faudes::TestFirstSelectedWords (  ) 

Test for some selected word if the correct set of terminals is returned.

PushdownGenerator faudes::TestGenerator1 (  ) 

build a test generator

Returns:
the populated test generator
PushdownGenerator faudes::TestGenerator10 (  ) 
PushdownGenerator faudes::TestGenerator11 (  ) 
PushdownGenerator faudes::TestGenerator12 (  ) 
PushdownGenerator faudes::TestGenerator13 (  ) 
PushdownGenerator faudes::TestGenerator14 (  ) 
PushdownGenerator faudes::TestGenerator15 (  ) 
PushdownGenerator faudes::TestGenerator16 (  ) 
PushdownGenerator faudes::TestGenerator17 (  ) 
PushdownGenerator faudes::TestGenerator18 (  ) 
PushdownGenerator faudes::TestGenerator19 (  ) 
PushdownGenerator faudes::TestGenerator2 (  ) 

build a test generator

<Generator> Generator

% % Statistics for Generator % % States: 3 % Init/Marked: 1/1 % Events: 3 % Transitions: 4 % StateSymbols: 3 % Attrib. E/S/T: 1/0/4 %

<Alphabet> lambda a +C+ b d </Alphabet>

<States> s1 s2 s3 </States>

<TransRel> s1 a s2 ++ +lambda+ +dot, dot+ s1 b s2 ++ +square+ +dot, square+ s2 lambda s3 ++ +dot, dot+ +square+ s3 b s1 ++ +square+ +square+ </TransRel>

<InitStates> s1 </InitStates>

<MarkedStates> s2 </MarkedStates>

<StackSymbols> lambda dot square bottom </StackSymbols>

</Generator>

Returns:
the populated test generator
PushdownGenerator faudes::TestGenerator20 (  ) 
PushdownGenerator faudes::TestGenerator21 (  ) 
PushdownGenerator faudes::TestGenerator22 (  ) 
PushdownGenerator faudes::TestGenerator23 (  ) 
PushdownGenerator faudes::TestGenerator24 (  ) 
PushdownGenerator faudes::TestGenerator25 (  ) 
PushdownGenerator faudes::TestGenerator3 (  ) 

<Generator> Generator

% % Statistics for Generator % % States: 3 % Init/Marked: 1/1 % Events: 2 % Transitions: 4 % StateSymbols: 3 % Attrib. E/S/T: 1/0/4 %

<Alphabet> a +C+ b </Alphabet>

<States> s1 s2 s3 </States>

<TransRel> s1 a s2 ++ +dot+ +dot, dot+ s1 b s2 ++ +square+ +dot, square+ s2 a s3 ++ +dot+ +dot+ s3 b s1 ++ +dot+ +dot+ </TransRel>

<InitStates> s1 </InitStates>

<MarkedStates> s2 </MarkedStates>

<StackSymbols> lambda dot square </StackSymbols>

</Generator>

PushdownGenerator faudes::TestGenerator4 (  ) 

<Generator> Generator

% % Statistics for Generator % % States: 3 % Init/Marked: 1/1 % Events: 2 % Transitions: 4 % StateSymbols: 3 % Attrib. E/S/T: 1/0/4 %

<Alphabet> a +C+ b </Alphabet>

<States> s1 s2 s3 </States>

<TransRel> s1 a s2 ++ +dot, dot, dot+ +dot, dot+ s1 b s2 ++ +dot, square+ +dot, square+ s2 a s3 ++ +dot, dot+ +dot+ s3 b s1 ++ +dot+ +dot+ </TransRel>

<InitStates> s1 </InitStates>

<MarkedStates> s2 </MarkedStates>

<StackSymbols> lambda dot square </StackSymbols>

</Generator>

PushdownGenerator faudes::TestGenerator5 (  ) 

<Generator> Generator

% % Statistics for Generator % % States: 3 % Init/Marked: 1/1 % Events: 3 % Transitions: 4 % StateSymbols: 3 % Attrib. E/S/T: 1/0/4 %

<Alphabet> lambda a +C+ b </Alphabet>

<States> s1 s2 s3 </States>

<TransRel> s1 a s2 ++ +square+ +square+ s1 b s2 ++ +dot+ +square+ s2 lambda s3 ++ +dot+ +square, dot, dot+ +square+ +square+ s3 lambda s1 ++ +square+ +lambda+ +square+ +square, dot+ </TransRel>

<InitStates> s1 </InitStates>

<MarkedStates> s2 </MarkedStates>

<StackSymbols> lambda dot square </StackSymbols>

</Generator>

PushdownGenerator faudes::TestGenerator6 (  ) 
PushdownGenerator faudes::TestGenerator7 (  ) 
PushdownGenerator faudes::TestGenerator8 (  ) 
PushdownGenerator faudes::TestGenerator9 (  ) 
void faudes::TestGeneratorGoto (  ) 

All GeneratorGoto Tests.

void faudes::TestGeneratorGotoNoSuccessor (  ) 

Test if GeneratorGoto finds no successor when none is to be found.

void faudes::TestGeneratorGotoOneSuccessor (  ) 

Test if GeneratorGoto finds the right successor.

void faudes::TestGeneratorGotoSeq (  ) 

All GeneratorGotoSeq Tests.

void faudes::TestGeneratorGotoSeqFull (  ) 

Test if a word fully matches a sequence of states when a match is possible.

void faudes::TestGeneratorGotoSeqPartial (  ) 

Test if a partial state sequence is generated when no full match for the word is possible.

void faudes::TestGetPossibleStackTops (  ) 

all GetPossibleStackTops tests

void faudes::TestGetPossibleStackTopsFindCorrectOnes (  ) 

Test if GetPossibleStackTops finds the correct stack symbols.

void faudes::TestGp2Pp (  ) 

All Gp2Pp Tests.

void faudes::TestGp2PpStates (  ) 

Test if all states are set correctly and whether the correct ones are used in transitions.

void faudes::TestGp2PpTransitions (  ) 

Test if the number of transitions is correct and test if the number of transitions per event is as expected.

Grammar faudes::TestGrammar1 (  ) 

build a test grammer based on the generator from TestGenerator()

start symbol: (3, 2) nonterminals: (1, 2, 2), (2, 3, 3), (3, 2), (4, 3), (5, 3, 1) terminals: a, b grammar productions: (1, 2, 2) --> (2, 3, 3) (1, 2, 2) --> (5, 3, 1) (3, 2) --> (4, 3)b (4, 3) --> a(1, 2, 2)b (5, 3, 1) --> b

Returns:
the populated test grammar
Grammar faudes::TestGrammar10 (  ) 
Grammar faudes::TestGrammar11 (  ) 
Grammar faudes::TestGrammar2 (  ) 

build a test grammer based on the generator from TestGenerator()

start symbol: (4, 3) nonterminals: (1, 2, 2), (2, 3, 3), (3, 2), (4, 3), (5, 3, 1) terminals: a, b grammar productions: (1, 2, 2) --> (2, 3, 3) (1, 2, 2) --> (5, 3, 1) (4, 3) --> a(1, 2, 2)b (5, 3, 1) --> b

Returns:
the populated test grammar
Grammar faudes::TestGrammar3 (  ) 
Grammar faudes::TestGrammar4 (  ) 
Grammar faudes::TestGrammar5 (  ) 
Grammar faudes::TestGrammar6 (  ) 
Grammar faudes::TestGrammar7 (  ) 
Grammar faudes::TestGrammar8 (  ) 
Grammar faudes::TestGrammar9 (  ) 
void faudes::TestIntersectEvents (  ) 

all IntersectEvents tests

void faudes::TestIntersectEventsAll (  ) 

test for intersect events

void faudes::TestLrm (  ) 

All Lrm Tests.

void faudes::TestLrm1 (  ) 

All Lrm1 Tests.

void faudes::TestLrm1FindOne (  ) 

Test if Lrm1 finds the correct following configuration set when only one must be found.

void faudes::TestLrm1FindThree (  ) 

Test if Lrm1 finds three following configuration sets when three must be found.

void faudes::TestLrmGr1 (  ) 

Test if Lrm generates a GotoMachine with the correct number of transitions and states for the "$ a^n b $" grammar.

void faudes::TestLrmGr2 (  ) 

Test if Lrm generates a GotoMachine with the correct number of transitions and states for a specific.

//TODO dont know what to expecet as a result

void faudes::TestLrmLoop (  ) 

All LrmLoop Tests.

void faudes::TestLrmLoopAnB (  ) 

Test if LrmLoop generates the correct number of transitions and states for the "$ a^n b $" grammar.

void faudes::TestLrp (  ) 

All Lrp Tests.

void faudes::TestLrpActions (  ) 

Test if Lrp generates a parser with the correct rules.

void faudes::TestLrpNonterminalsTerminals (  ) 

Test if Lrp generates a parser with the correct number of nonterminals and terminals for a certain grammar.

void faudes::TestLrpReduceRules (  ) 

All LrpReduceRules Tests.

void faudes::TestLrpReduceRulesNumberAndTerminals (  ) 

Test if the number of reduce rules is correct and test for the correct number of occurences of terminals and each action element's right-hand side.

void faudes::TestLrpShiftRules (  ) 

All LrpShiftRules Tests.

void faudes::TestLrpShiftRulesNumberAndTerminals (  ) 

Test if the number of shift rules is correct and test for the correct number of occurences of terminals and each action's left-hand side element's right-hand side.

void faudes::TestNda (  ) 

All Nda tests.

void faudes::TestNdaActivePassive (  ) 

Test if the states are split into active and passive states and if the number of states has been doubled.

void faudes::TestNdaTransitions (  ) 

Test if transition start and end states are set as expected.

void faudes::TestNonblock (  ) 

all Nonblock tests

void faudes::TestPassesX (  ) 

All PassesX Tests.

void faudes::TestPassesXNonterminal (  ) 

Test PassesX by shifting the dot over a nonterminal.

void faudes::TestPassesXNoShift (  ) 

Test PassesX by trying to shift the dot over nothing or a nonexistent symbol.

void faudes::TestPassesXTerminal (  ) 

Test PassesX by shifting the dot over a terminal.

void faudes::TestPostCl (  ) 

All PostCl tests.

void faudes::TestPostClPostfixes (  ) 

Test all postfixes of a given word.

bool faudes::TestProtocol ( void   ) 

Test Protocol.

Perform a comparison of the recent protocol file and the corresponding reference. Returns true if the test passes.

Note: this function closes the current protocol.

Returns:
True <=> test past
void faudes::TestProtocol ( const std::string &  rMessage,
const std::string &  data 
)

Test Protocol.

Specialized version for string data. See also TestProtocol(const std::string&, const Type&, bool);

Parameters:
rMessage Informal identifyer of the test
data Test data
void faudes::TestProtocol ( const std::string &  rMessage,
long int  data 
)

Test Protocol.

Specialized version for integer test data. See also TestProtocol(const std::string&, const Type&, bool);

Parameters:
rMessage Informal identifyer of the test
data Test data
void faudes::TestProtocol ( const std::string &  rMessage,
bool  data 
)

Test Protocol.

Specialized version for boolean test data. See also TestProtocol(const std::string&, const Type&, bool);

Parameters:
rMessage Informal identifyer of the test
data Test data
void faudes::TestProtocol ( const std::string &  rMessage,
const Type &  rData,
bool  core = false 
)

Test Protocol.

This function dumps the specified data to the protocol file for the purpose of later comparison with a refernce value. If the protocol file has not been set up, this function does nothing; see also TestProtocol(const std::string&.

Parameters:
rMessage Informal identifyer of the test
rData Formal result of the test case
core Whether to record full token io or statistics only.
std::string faudes::TestProtocol ( const std::string &  rSource  ) 

Test Protocol.

Sets the filename for the test protocol by

  • removing any path specififucation,
  • replacing "." by "_",
  • appending ".prot", and finaly
  • prepending "tmp_". The function returns the filename except for the "tmp_" prefix. The latter is considered the nominal protocol output (aka reference protocol).

Note: only the first invocation of this functions actually sets the protocol file. Further invocations are ignored, but can be used to query the reference protocol.

Parameters:
rSource Source file to protocol
Returns:
Filename with nominal protocol.
void faudes::TestRemoveUselessTransitions (  ) 

all RemoveUselessTransitions tests

void faudes::TestRemoveUselessTransitionsNumberOfTransitions (  ) 

Test if RemoveUselessTransitions removes the correct amount of transitions from a test generator.

void faudes::TestRenG (  ) 

All RenG tests.

void faudes::TestRenGNumberOfStackSymbols (  ) 

Test if the number of stack symbols did not change.

void faudes::TestRenGRenamingStackSymbols (  ) 

Test if all stack symbols were renamed correctly.

void faudes::TestRenGRenamingTransitions (  ) 

Test if the stack symbols in pop and push of transitions were changed correctly.

void faudes::TestRenQ (  ) 

All RenQ Tests.

void faudes::TestRenQNumberOfStates (  ) 

Test if the number of states did not change.

void faudes::TestRenQRenaming (  ) 

Test if all states were renamed correctly (merge attribute is set correctly).

void faudes::TestRep0 (  ) 

All Rep0 tests.

void faudes::TestRep0AllExpectingTransition (  ) 

Test if resulting generator has a transition able to pop all stack symbols, but only if the orignal generator had at least one lambda transition.

void faudes::TestRep0NoLambdaPop (  ) 

Tests if there are any lambda popping edges left.

void faudes::TestRep2 (  ) 

All Rep2 tests.

void faudes::TestRep2NumberOfStatesTransitions (  ) 

Test for the right number of transitions and states in the generator after applying Rep2.

void faudes::TestRep2Renaming (  ) 

Tests if the MergeStateAnnotations have all been set to "old".

void faudes::TestRnce (  ) 

All Rnce tests.

void faudes::TestRnceRemoveEars (  ) 

Test if uncontrollable ears are correctly removed.

void faudes::TestRnpp (  ) 

All Rnpp tests.

void faudes::TestRnpp1 (  ) 

All Rnpp1 tests.

void faudes::TestRnpp1FindSymbolsEmptySet (  ) 

Find an eliminable symbol with Rnpp1 and an empty set of nonterminals.

void faudes::TestRnpp1FindSymbolsNonemptySet (  ) 

Find an eliminable symbol with Rnpp1 and a nonempty set of nonterminals.

void faudes::TestRnppEmptyGrammar (  ) 

Try to remove all noneliminable nonterminals and all productions containing noneliminable nonterminals from an empty grammar.

void faudes::TestRnppGrammar1 (  ) 

Remove all noneliminable nonterminals and all productions containing noneliminable nonterminals.

void faudes::TestRnppGrammar2 (  ) 

Remove all noneliminable nonterminals and all productions containing noneliminable nonterminals.

void faudes::TestRnppl (  ) 

All Rnppl tests.

void faudes::TestRnpplFindSymbolsCompleteSet (  ) 

Find all eliminable symbols with Rnppl and a set already containing all eliminable symbols.

void faudes::TestRnpplFindSymbolsEmptySet (  ) 

Find all eliminable symbols with Rnppl and an empty set of nonterminals.

void faudes::TestRnpplFindSymbolsNonemptySet (  ) 

Find all eliminable symbolswith Rnppl and a nonempty set of nonterminals.

void faudes::TestRpp (  ) 

All Rpp tests.

void faudes::TestRppNumberStatesTransitions (  ) 

Test if the number of transitions and states is correct after calling Rpp.

void faudes::TestRppReadPopPushOnly (  ) 

Test if all transitions are either read only, pop only or push only.

void faudes::TestRuls (  ) 

all Ruls tests

void faudes::TestRulsRemoveStates (  ) 

Test if Ruls deletes the correct states.

void faudes::TestRup (  ) 

All Rup tests.

void faudes::TestRupNonterminals (  ) 
void faudes::TestRupProductions (  ) 
void faudes::TestSp2Lr (  ) 

All Sp2Lr tests.

void faudes::TestSp2Lr2 (  ) 

All Sp2Lr tests.

void faudes::TestSp2Lr2Productions (  ) 

Test if all expected productions for read, pop and push transitions and for the final states were generated.

void faudes::TestSp2LrNonterminals (  ) 

Test if all possible nonterminals were generated.

void faudes::TestSp2LrProductions (  ) 

Test if all expected productions for read, pop and push transitions and for the final states were generated.

void faudes::TestSp2LrTerminals (  ) 

Test if all terminals have been set correctly and match the generator's events.

void faudes::TestSplit (  ) 

all Split tests

void faudes::TestSplitStackSymbols (  ) 

Test if the stack bottom remains unchanged and all stack symbols from the old generator are in the split generator.

void faudes::TestSplitStates (  ) 

Test if the states have been split correctly into heads and ears.

void faudes::TestSplitTransitionsEarToHead (  ) 

Test if all transitions originating at ears end at heads and if the pop of the transition is correctly set.

void faudes::TestSplitTransitionsHeadToEar (  ) 

Test if all transitions originating at heads end at ears and if the pop/push of the transition is correctly set.

void faudes::TestStart ( std::string  name  ) 

write to console to indicate start of test

Parameters:
name name of the test
System faudes::TestSystem1 (  ) 

<Generator> Generator

% % Statistics for Generator % % States: 3 % Init/Marked: 1/1 % Events: 3 % Transitions: 5 % StateSymbols: 3 % Attrib. E/S/T: 2/0/0 %

<Alphabet> a +C+ b c +C+ </Alphabet>

<States> s1 s2 s3 </States>

<TransRel> s1 a s2 s1 b s3 s1 c s3 s2 b s1 s3 a s2 </TransRel>

<InitStates> s1 </InitStates>

<MarkedStates> s3 </MarkedStates>

</Generator>

Returns:
the populated test system
System faudes::TestSystem2 (  ) 
System faudes::TestSystem3 (  ) 
System faudes::TestSystem4 (  ) 
System faudes::TestSystem5 (  ) 
void faudes::TestTe (  ) 

all Te tests

void faudes::TestTeReachable (  ) 

Test Ts with transitions that are reachable.

void faudes::TestTeUnreachable (  ) 

Test Ts with states that are unreachable.

void faudes::TestTimes (  ) 

all Times tests

void faudes::TestTimesStackSymbols (  ) 

Test if all stack symbols and the stack bottom are set correctly.

void faudes::TestTimesStates (  ) 

test for the the right number of states and for correctly set merge states

void faudes::TestTimesTransitions (  ) 

Test if the number of lambda transitions and the total number of transitions is right.

void faudes::TestTransient (  ) 

All Transient tests.

void faudes::TestTransientStates (  ) 

Test if Transient chooses the right states.

void faudes::TestTransientStatesEmpty (  ) 

Test if Transient chooses the right states.

void faudes::TestTs (  ) 

all Ts tests

void faudes::TestTsUnreachable (  ) 

Test Te with transitions that are unreachable.

PushdownGenerator faudes::Times ( const System &  reg,
const PushdownGenerator &  pd 
)

synchronous product generator of a pushdown generator and a regular generator

Parameters:
reg the regualar generator
pd the pushdown generator
Returns:
the synchronous product
int faudes::timeval_subtract ( timeval *  result,
timeval *  x,
timeval *  y 
)

from http://www.gnu.org/software/libc/manual/html_node/Elapsed-Time.html Calculates time difference x - y.

For debugging and time measurement.

Parameters:
result the time difference is stored here
x the time x
y the time y
Returns:
1 if x - y is negative, else 0
Idx faudes::ToIdx ( const std::string &  rString  ) 

Convert a string to Idx.

Parameters:
rString string to convert
Returns:
Idx
Exceptions:
Idx overflow (id 600)
std::string faudes::ToStringFloat ( double  number  ) 

float to string

Parameters:
number double
Returns:
string
std::string faudes::ToStringInteger ( long int  number  ) 

integer to string

Parameters:
number integer
Returns:
string
std::string faudes::ToStringInteger16 ( long int  number  ) 

integer to string base 16

Parameters:
number integer
Returns:
string
StateSet faudes::Transient ( const PushdownGenerator &  pd  ) 

Get all states that are the starting state of a lambda reading transition.

Parameters:
pd the generator
Returns:
the states
std::string faudes::TransitionMapToStr ( const LrmTransitionMap &  transitionMap  ) 

To string function for a transition map.

Parameters:
transitionMap the transition map to turn into a string
Returns:
the transition map as a string
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
void faudes::TrimNonIndicatorTracesOfGd ( System &  rGd,
const Diagnoser &  rGobs,
const Idx  rFailureType,
const EventSet &  rIndicatorEvents,
const std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap 
)

Extract all traces of a generator G_d that start with an indicator event that follows a failure event of a certain failure type.

Parameters:
rGd Input generator G_d which will be prunded.
rGobs Generator G_o (containing failure label information).
rFailureType Failure type index.
rIndicatorEvents Set of indicator events.
rReverseCompositionMap Mapping of G_d states with G_o states.
void faudes::TrimNonIndicatorTracesOfGd ( System &  rGd,
const Diagnoser &  rGobs,
const Idx  rFailureType,
const EventSet &  rIndicatorEvents,
const map< pair< Idx, Idx >, Idx > &  rReverseCompositionMap 
)

Definition at line 606 of file diag_eventdiagnosis.cpp.

void faudes::TrimNonIndicatorTracesOfGdRecursive ( System &  rGd,
const Diagnoser &  rGobs,
const Idx  rFailureType,
const EventSet &  rIndicatorEvents,
std::map< Idx, std::pair< Idx, Idx > > &  rCompositionMap,
Idx  state,
StateSet &  rStatesDone 
)

Auxiliary function for TrimNonIndicatorTracesOfGd().

Parse through active transition set of the current state and delete transitions if occurring event is not an indicator event or there did not occur a failure before the indicator.

Parameters:
rGd Input generator G_d which will be pruned.
rGobs Generator G_o (containing failure label information).
rFailureType Failure type index.
rIndicatorEvents Set of indicator events.
rCompositionMap Inverted mapping of G_d states with G_o states.
state Current state.
rStatesDone States that have been processed already.
void faudes::TrimNonIndicatorTracesOfGdRecursive ( System &  rGd,
const Diagnoser &  rGobs,
const Idx  rFailureType,
const EventSet &  rIndicatorEvents,
map< Idx, pair< Idx, Idx > > &  rCompositionMap,
Idx  state,
StateSet &  rStatesDone 
)

Definition at line 618 of file diag_eventdiagnosis.cpp.

PushdownGenerator faudes::TrimStackSymbols ( const PushdownGenerator &  pd  ) 

Delete stack symbols from the generator that are not used in any of the transitions.

Parameters:
pd pushdown generator to trim
Returns:
trimmed pushdown generator
bool faudes::Ts ( const PushdownGenerator &  pd,
Idx  state 
)

Test a state for reachability.

Parameters:
pd the pushdown generator
state the state to test for reachability
Returns:
true if the state is reachable, else false
std::set< Lr1Configuration > faudes::ValidEmpty ( const Grammar &  gr,
uint  k 
)

Determine the descendants of the initial parser configurations.

Parameters:
gr the grammar
k a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1))
Returns:
a set with the descendants of the initial configurations
std::string faudes::VersionString (  ) 

Return FAUDES_VERSION as std::string.

Returns:
std::string with FAUDES_VERSION
void faudes::WriteMap ( GrammarSymbolWordMap  f,
bool  changed = false 
)

Convenience print function for first map function.

Parameters:
f map function to print
changed indicator if changes were made, defaults to false
bool faudes::YclessScc ( const Generator &  rGen,
const EventSet &  rYc,
std::set< StateSet > &  rSccSet 
)

Definition at line 1800 of file hio_functions.cpp.


Variable Documentation

bool(* faudes::gBreakFnct)(void)=0 [static]

Definition at line 562 of file cfl_helper.cpp.

volatile AutoRegisterType<xDevice> faudes::gRtiRegisterDeviceContainer("DeviceContainer") [static]

Definition at line 447 of file cfl_helper.cpp.

Definition at line 446 of file cfl_helper.cpp.

const char* const faudes::luafaudes_rl_keywords[] [static]
Initial value:
 {
  "and", "break", "do", "else", "elseif", "end", "false",
  "for", "function", "if", "in", "local", "nil", "not", "or",
  "repeat", "return", "then", "true", "until", "while", NULL
}

Definition at line 32 of file lbp_function.cpp.

int faudes::ran_initialized = 0 [static]

Definition at line 30 of file sp_random.cpp.

long faudes::ran_seed[STREAMS] = {DEFAULT} [static]

Definition at line 28 of file sp_random.cpp.

int faudes::ran_stream = 0 [static]

Definition at line 29 of file sp_random.cpp.

libFAUDES 2.23h --- 2014.04.03 --- c++ api documentaion by doxygen