faudes Namespace Reference

libFAUDES resides within the namespace faudes. More...

Classes

class  TaGenerator
 Generator with specified attribute types. More...
class  AttributeVoid
 Minimal Attribute. More...
class  AttributeFlags
 Boolean flags Attribute. More...
class  TAttrMap
 Attribute interface for TBaseSet. More...
class  TBaseSet
 STL style set template. More...
class  vBaseVector
 Vector bass class. More...
class  TBaseVector
 Vector template. More...
struct  Pnode
class  Bisimulation
class  AttributeCFlags
 Attribute class to model event controllability properties. More...
class  TcGenerator
 Generator with controllability attributes. 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  Hopcroft
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 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  ComSyn
class  SmallSize
class  SNOState
struct  ReductionStateInfo
 Data structure for identifying states in the same coset for supervisor reduction. More...
class  SOE
class  MCtrlPattern
class  OPSState
class  EventRelabelMap
 Rti convenience wrapper for relabeling maps. 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  ScopeLogger
 Class to create a log file which contains function calls with their runtime. 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  Time
 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...
class  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  mbDevice
 Processimage synchronisation via Modbus/TCP. 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 TaNameSet
< AttributeCFlags
cEventSet
 Compatibility: pre 2.20b used cEventSet as C++ class name.
typedef TBaseVector< cEventSetcEventSetVector
typedef TcGenerator
< AttributeVoid, AttributeVoid,
AttributeCFlags, AttributeVoid
System
 Convenience typedef for std System.
typedef TBaseVector< SystemSystemVector
 Convenience typedef for vectors of systems.
typedef TcGenerator
< AttributeVoid, AttributeVoid,
AttributeCFlags, AttributeVoid
cGenerator
 Compatibility: pre 2.20b used cGenerator as C++ class name.
typedef TBaseVector< cGeneratorcGeneratorVector
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.
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 TdiagGenerator
< AttributeFailureTypeMap,
AttributeDiagnoserState,
AttributeCFlags, AttributeVoid
diagGenerator
 Compatibility: pre 2.20b used diagGenerator as C++ class name.
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 TmtcGenerator
< AttributeVoid,
AttributeColoredState,
AttributeCFlags, AttributeVoid
mtcGenerator
 Compatibility: pre 2.20b used mtcGenerator as C++ class name.
typedef std::vector
< std::vector< std::pair< Idx,
MergeTransition > > > 
TransformationHistoryVec
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::shared_ptr
< GrammarSymbol
GrammarSymbolPtr
typedef std::shared_ptr< const
GrammarSymbol
ConstGrammarSymbolPtr
typedef std::shared_ptr
< Nonterminal
NonterminalPtr
typedef std::shared_ptr< const
Nonterminal
ConstNonterminalPtr
typedef std::shared_ptr< TerminalTerminalPtr
typedef std::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 PushdownGenerator.
typedef TaTransSet
< AttributePushdownTransition
PdTransSet
typedef TtGenerator
< AttributeTimedGlobal,
AttributeTimedState,
AttributeCFlags,
AttributeTimedTrans
TimedGenerator
 Convenience typedef for std TimedGenerator.
typedef TtGenerator
< AttributeTimedGlobal,
AttributeTimedState,
AttributeCFlags,
AttributeTimedTrans
tGenerator
 Compatibility: pre 2.20b used tGenerator as C++ class name.
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 calcBisimulation (const Generator &rGenOrig, map< Idx, Idx > &rMapStateToPartition)
void calcBisimulation (const Generator &rGenOrig, map< Idx, Idx > &rMapStateToPartition, Generator &rGenPart)
void calcBisimulation (const Generator &rGenOrig, std::list< StateSet > &rClasses)
 Computation of the coarsest bisimulation relation for a specified generator.
FAUDES_API void calcBisimulation (const Generator &rGenOrig, std::map< Idx, Idx > &rMapStateToPartition)
 Computation of the coarsest bisimulation relation for a specified generator.
FAUDES_API void calcBisimulation (const Generator &rGenOrig, std::map< Idx, Idx > &rMapStateToPartition, Generator &rGenPart)
 Computation of the coarsest bisimulation relation for a specified generator.
void MergeEquivalenceClasses (Generator &rGen, TransSetX2EvX1 &rRevTrans, const std::list< StateSet > &rClasses)
void ExtendedTransRel (const Generator &rGen, const EventSet &rSilentAlphabet, TransSet &rXTrans)
void ObservationEquivalentQuotient (Generator &g, const EventSet &silent)
bool IsIncomingEquivalent (const TransSetX2EvX1 &rRevXTrans, const EventSet &rSilent, const StateSet &rInitialStates, Idx q1, Idx q2)
void IncomingEquivalentCandidates (const TransSet &rXTrans, const TransSetX2EvX1 &rRevXTrans, const EventSet &rSilent, const StateSet &rInitialStates, Idx q1, StateSet &rRes)
void ActiveEventsRule (Generator &g, const EventSet &silent)
void SilentContinuationRule (Generator &g, const EventSet &silent)
void MergeSilentSccs (Generator &g, const EventSet &silent)
void RemoveNonCoaccessibleOut (Generator &g)
void BlockingSilentEvent (Generator &g, const EventSet &silent)
void MergeNonCoaccessible (Generator &g)
void BlockingEvent (Generator &g, const EventSet &silent)
void OnlySilentIncoming (Generator &g, const EventSet &silent)
void OnlySilentOutgoing (Generator &g, const EventSet &silent)
void ConflictEquivalentAbstraction (vGenerator &rGen, const EventSet &rSilentEvents)
 Conflict equivalent abstraction.
bool IsNonblocking (const GeneratorVector &rGenVec)
 Test for conflicts.
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 (Int number)
 integer to string
std::string ToStringInteger16 (Int number)
 integer to string base 16
std::string ToStringFloat (Float 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.
FAUDES_API const std::string & PathSeparator (void)
 Std dir-separator.
FAUDES_API 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)
FAUDES_API 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_org (const Generator &rGen, Generator &rResGen, std::vector< StateSet > &rSubsets, std::vector< Idx > &rNewIndices)
void StateMin (const Generator &rGen, Generator &rResGen)
 State set minimization.
void StateMin (const Generator &rGen, Generator &rResGen, std::vector< StateSet > &rSubsets, std::vector< Idx > &rNewIndices)
 State set minimization.
void aStateMin (const Generator &rGen, Generator &rResGen)
 State set minimization.
void aStateMin (Generator &rGen)
 State set minimization.
void TransSpec (const GeneratorVector &rSpecGenVec, const EventSet &rGUncAlph, GeneratorVector &rResGenVec)
 translate specification into plant
void calcWSOE (const Generator &rGenOrig, const EventSet &rConAlph, const EventSet &rLocAlph, std::map< Idx, Idx > &rMapStateToPartition, Generator &rResGen)
 weak synthesis obeservation equivalence [not implemented]
void GlobalSelfloop (GeneratorVector &rGenVec)
 remove the events from the entire buffer which have only selfloop transitions
void LocalSelfloop (Generator &rGen, EventSet &rLocAlph)
 remove the events from a generator which have only selfloop transitions
void MakeDistinguisher (Generator &AbstGen, std::map< Idx, Idx > &rMapStateToPartition, Generator &OrigGen, std::map< Idx, std::vector< Idx > > &rMapOldToNew)
 make a distinguisher and a map for solving nondeterminism and rewrite abstracted automaton
void Splitter (const std::map< Idx, std::vector< Idx > > &rMapOldToNew, EventSet &rConAlph, GeneratorVector &rGenVec, std::map< Idx, Idx > &rMapEventsToPlant, GeneratorVector &rDisGenVec, GeneratorVector &rSupGenVec)
 update the generators in synthesis-buffer and in supervisor with new events
void SelectSubsystem_V1 (GeneratorVector &rGenVec, Generator &rResGen)
 heuristic: vorious approaches to select subsystem from synthesis-buffer then compose them and remove them from buffer.
void SelectSubsystem_V2 (GeneratorVector &rGenVec, Generator &rResGen)
void calcHSupConNB (const Generator &rOrigGen, const EventSet &rConAlph, const EventSet &rLocAlph, Generator &rHSupGen)
 halbway-synthesis
void SingleTransSpec (const Generator &rSpecGen, const EventSet &rUncAlph, Generator &rResGen)
void SplittGen (Generator &rGen, Idx parent, const std::vector< Idx > &kids)
 subfunction for Splitter: splitt the events in a generator
bool BiggerMax (std::vector< GeneratorVector::Position > &rCandidate, GeneratorVector &rGenVec)
void H_tocollect (StateSet &rBlockingstates, const TransSetX2EvX1 &rRtrel, const EventSet &rLouc, const EventSet &rShuc, TransSetX2EvX1 &rToredirect)
void ControlProblemConsistencyCheck (const GeneratorVector &rPlantGenVec, const EventSet &rConAlph, const GeneratorVector &rSpecGenVec)
 Compositional synthesis.
void CompositionalSynthesisUnchecked (const GeneratorVector &rPlantGenVec, const EventSet &rConAlph, const GeneratorVector &rSpecGenVec, std::map< Idx, Idx > &rMapEventsToPlant, GeneratorVector &rDisGenVec, GeneratorVector &rSupGenVec)
 Compositional synthesis.
void CompositionalSynthesis (const GeneratorVector &rPlantGenVec, const EventSet &rConAlph, const GeneratorVector &rSpecGenVec, std::map< Idx, Idx > &rMapEventsToPlant, GeneratorVector &rDisGenVec, GeneratorVector &rSupGenVec)
 Compositional synthesis.
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.
bool IsStdSynthesisConsistentUnchecked (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rPlant0Gen)
bool IsStdSynthesisConsistent (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rPlant0Gen)
 Test consistency of an abstractions w.r.t.
bool IsStdSynthesisConsistent (const System &rPlantGen, const Generator &rPlant0Gen)
 Test consistency of an abstraction w.r.t standard synthesis.
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 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)
bool SupReduce (const System &rPlantGen, const System &rSupGen, System &rReducedSup)
 Supervisor Reduction algorithm.
void calcSynthObsEquiv (const Generator &rGenOrig, const EventSet &rConAlph, const EventSet &rLocAlph, std::map< Idx, Idx > &rMapStateToPartition, Generator &rResGen)
 Synthesis-observation equivalence.
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!)
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, 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.
FAUDES_API void ExtendHighAlphabet (const Generator &rGenObs, EventSet &rHighAlph, std::map< Idx, Idx > &rMapStateToPartition)
 Extension of the high-level alphabet to achieve the Lm-observer property.
FAUDES_API 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.
FAUDES_API void calcAbstAlphClosed (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 L(G)-observer computation.
FAUDES_API void calcAbstAlphClosed (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 L(G)-observer computation.
FAUDES_API void calcAbstAlphClosed (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans)
 L(G)-observer computation.
FAUDES_API void calcAbstAlphObs (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 Lm-observer computation.
FAUDES_API void calcAbstAlphObs (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 Lm-observer computation.
FAUDES_API void calcAbstAlphObs (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans)
 Lm-observer computation.
FAUDES_API 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.
FAUDES_API void calcAbstAlphMSA (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans)
 MSA-observer computation.
FAUDES_API void calcAbstAlphObsLCC (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 Lm-observer computation including output control consistency (OCC).
FAUDES_API void calcAbstAlphObsLCC (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans)
 Lm-observer computation including local control consistency (LCC).
FAUDES_API void calcAbstAlphMSALCC (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 MSA-observer computation including local control consistency (LCC).
FAUDES_API 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::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.
FAUDES_API void insertRelabeledEvents (System &rGenPlant, const std::map< Idx, std::set< Idx > > &rMapRelabeledEvents, Alphabet &rNewEvents)
 Convenience function for relabeling events in a given generator.
FAUDES_API void insertRelabeledEvents (Generator &rGenPlant, const std::map< Idx, std::set< Idx > > &rMapRelabeledEvents, EventSet &rNewEvents)
 Convenience function for relabeling events in a given generator.
FAUDES_API 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).
FAUDES_API 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)
FAUDES_API 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.
FAUDES_API bool IsLive (const System &rGen, std::string &rReport)
 Test if a generator is live.
FAUDES_API bool CycleOfUnobsEvents (const System &rGen, std::string &rReport)
 Test if there exist any cycles of unobservable events in a generator.
FAUDES_API bool FailuresUnobservable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, std::string &rReport)
 Check if all failure events are unobservable events in a generator's alphabet.
FAUDES_API bool ExistsCycle (const System &rGen, std::string &rReport)
 Test if there exist any cycles in a generator.
FAUDES_API bool ExistsCycleSearch (const System &rGen, StateSet &rTodo, Idx currState, StateSet statesOnPath, std::string &rReport)
 Auxiliary function for ExistsCycle(const System&, std::string&).
FAUDES_API 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.
FAUDES_API 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.
FAUDES_API 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).
FAUDES_API 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.
FAUDES_API 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().
FAUDES_API 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.
FAUDES_API 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>>&).
FAUDES_API 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.
FAUDES_API 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)
FAUDES_API 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)
FAUDES_API 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)
FAUDES_API 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.
FAUDES_API void calcAbstAlphObs (MtcSystem &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 Lm-observer computation.
FAUDES_API 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 &ee, const EventSet &ek, Generator &proof)
 Conditionaldecomposability Checking Algorithm.
bool IsCD (const Generator &gen, const EventSetVector &ee, const EventSet &ek, const EventSet &unionset, Generator &proof)
void ConDecExtension (const Generator &gen, const EventSetVector &rAlphabets, EventSet &ek)
 Conditionaldecomposability Extension Algorithm.
void CDExt (const Generator &gen, const EventSetVector &ee, const EventSet &unionset, EventSet &ek)
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.
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
void DetachAugSymbol (Lr1Parser &rParser)
 Detach augmented symbole from Lr(1)-parser.
std::vector< IdxCreateNonterms (const std::vector< Idx > &rVec, Terminal term, std::map< std::pair< Idx, Terminal >, Idx > &indexMap)
Lr1Parser TransformParserAction (const Lr1Parser &rParser)
 Transform action of Lr(1)-parser as follows actions of the form (q,a,p,a) to ((q,lambda),a,(p,a),lambda), ((q,a),lambda,(p,a),lambda) actions of the form (q,a,p,lambda) to ((q,lambda),a,(p,lambda),lambda) , ((q,a),lambda,(p,lambda),lambda)
PushdownGenerator LrParser2EPDA (const Lr1Parser &parser)
void PushdownConstructController (const PushdownGenerator &rSpec, const System &rPlant, PushdownGenerator &rRes, bool debug=false)
 Construct a minimal restrictive sound controller, based on the Algorithm presented by Sven Schneider and Anne-Kathrin Schmuck.
void ConstructControllerPreCombine (const PushdownGenerator &rSpec, const System &rPlant, PushdownGenerator &rRes, bool debug=false)
 Create a nonblocking product generator of a pushdown generator and a regular generator.
int ConstructControllerLoop (const PushdownGenerator &rContr, const System &rPlant, PushdownGenerator &rRes, int loopcounter=0, bool debug=false)
 Looped execution to construct a minimal restrictive controller.
void PushdownBlockfree (const PushdownGenerator &rPd, PushdownGenerator &rResPd, bool debug=false)
 Make a pushdown generator nonblocking.
void PushdownAccessible (const PushdownGenerator &pd, PushdownGenerator &resPd, bool coacc=true, bool debug=false)
 Construct the accessible part of a pushdown generator.
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 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.
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.
PushdownGenerator AnnotatePdStates (const std::string word, const PushdownGenerator &pd)
 Associates each state of the generator with an annotation.
PushdownGenerator RenameStackSymbold (const std::string word, const PushdownGenerator &pd)
 Adds an annotation to each stack symbol of the generator.
PushdownGenerator Nda (const PushdownGenerator &pd)
 Input must have passed SPDA() ! Remodels the generator to prevent double (or multiple) acceptance of the same input string.
void ReachableStateMap (const PushdownGenerator &rPd, std::map< Idx, StateSet > &rMap)
 Fill map.
bool PushdownTrim (PushdownGenerator &rPd, const uint n, bool debug=false)
 Make generator trim.
PushdownGenerator SPDA (const PushdownGenerator &pd, TransformationHistoryVec *pTransformHistory=NULL)
 (previously called Rpp) Restricts a pushdown generator to a simple pushdown generator SPDA with transitions that are either read (p,a,lambda,lambda,q), pop (p,lambda,x,lambda,q) or push (p,lambda,x,yx,q).
PushdownGenerator RebuildFromSPDA (const PushdownGenerator &rSPDA, const TransformationHistoryVec &rTransformHistory)
 Input must have passed SPDA() ! Rebuild a pushdown generator which passed SPDA as far as possible.
PushdownGenerator RemainingPd (const Grammar &rGr, const PushdownGenerator &pd)
 Input must have passed SPDA() ! Compares the given pushdown generator with the given grammar and removes all transition, which cannot be find in productions of the grammar.
PushdownGenerator RemoveLambdaPop (const PushdownGenerator &pd)
 (previously called Rep0) Removes all transitions popping lambda.
Grammar Sp2Lr (const PushdownGenerator &rPd, uint n=0, bool ignorReducible=false, bool debug=false)
 Input must have passed SPDA() and Nda() ! Transform a simple pushdown generator into a context free grammar.
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, 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, 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 Rup (const Grammar &gr)
 Remove all unreachable productions and nonterminals from the grammar.
PushdownGenerator RemoveMultPop (const PushdownGenerator &pd)
 (previously called Rep2) Removes transitions popping more than one stack symbol.
uint InTransitionSize (Idx trg, const PushdownGenerator &rPd)
 Getting the number of incoming transitions of a state.
std::set< std::pair
< Transition, Transition > > 
PossibleAdjacentMerges (Idx q, const PushdownGenerator &pd)
bool CombinedTransitions (Idx q, PushdownGenerator &rPd,StateSet &next, StateSet &done)
 Merge transitions from state q with adjacent transitions without changing the marked language.
void MergeAdjacentTransitions (PushdownGenerator &rPd)
 Merge adjacent transitions until no more mergers are possible.
void debug_printf (const std::string &msg, const PushdownGenerator &pd)
 Print generator depending on debug level (PD_DEBUG_LEVEL)
void debug_printf (const std::string &msg, const std::string &tex="")
 Print given text depending on debug level (PD_DEBUG_LEVEL)
void ToFile (const PushdownGenerator &pd, std::string name, bool printDOT=true, bool printPNG=true)
 Print pushdown generator to file, if the number of transitions does not exceed PD_DEBUG_MAX_TRANS.
void ToFile (const std::string &tex, std::string name)
 Print given text to file.
std::string RewriteDotFile (const std::string &fileName)
System SystemFromDot (const std::string &filename)
 Parse a System (TcGenerator) from given dot-file.
bool IsLambdaReplacement (const std::string &str)
 check if given string is a replacement for lambda Replacements are empty string (""), underline ("_") , html lambda code ("&lambda;") or "lambda"
std::vector< std::string > split (const std::string &rStr, const std::string &rSep, const std::string &rFilename, const int lineNr)
std::string::size_type getIde (std::string::size_type &rPos, const std::string &rInput, std::string &rRestString, const std::string &rFilename, const int lineNr)
 Get string literal between quotations ("ide") to &resText and return the position after the second quotation (").
template<class GlobalAttr , class StateAttr , class EventAttr , class TransAttr >
FAUDES_API void ParserInsStackSymbols (std::vector< std::string > &rVec, const std::string &rFileName, const int lineNr, TpdGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > &rPd)
template<class GlobalAttr , class StateAttr , class EventAttr , class TransAttr >
FAUDES_API bool ParseTransition (const std::string input, const std::string &rFilename, const int linenr, TpdGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > &rPd)
template<class GlobalAttr , class StateAttr , class EventAttr , class TransAttr >
FAUDES_API void ParseEvent (std::string input, const std::string &rFileName, const int lineNr, TpdGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > &rPd)
template<class GlobalAttr , class StateAttr , class EventAttr , class TransAttr >
FAUDES_API void ParseState (const std::string input, const std::string &rFileName, const int lineNr, TpdGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > &rPd)
template<class GlobalAttr , class StateAttr , class EventAttr , class TransAttr >
FAUDES_API void ParseStackBottom (const std::string input, const std::string &rFilename, const int linenr, TpdGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > &rPd)
template<class GlobalAttr , class StateAttr , class EventAttr , class TransAttr >
FAUDES_API void CreatPdFromDot (const std::string &fileName, TpdGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > &pd)
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.
const std::string currentDateTime ()
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 TestLrParser2EPDAStates ()
 Test if all states are set correctly and whether the correct ones are used in transitions.
void TestLrParser2EPDATransitions ()
 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 TestLrParser2EPDA ()
 All LrParser2EPDA Tests.
void TestDim ()
 All Dim Tests.
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 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 TestAc ()
 all Ac tests
void TestTsUnreachable ()
 Test Te with transitions that are unreachable.
void TestRenameStatesRenaming ()
 Test if all states were renamed correctly (merge attribute is set correctly).
void TestRenameStatesNumberOfStates ()
 Test if the number of states did not change.
void TestRenameStackSymbolsRenamingStackSymbols ()
 Test if all stack symbols were renamed correctly.
void TestRenameStackSymbolsNumberOfStackSymbols ()
 Test if the number of stack symbols did not change.
void TestRenameStackSymbolsRenamingTransitions ()
 Test if the stack symbols in pop and push of transitions were changed correctly.
void TestRemoveLambdaPopNoLambdaPop ()
void TestRemoveLambdaPopAllExpectingTransition ()
void TestRemoveMulPopNumberOfStatesTransitions ()
 Test for the right number of transitions and states in the generator after applying Rep2.
void TestSPDANumberStatesTransitions ()
 Test if the number of transitions and states is correct after calling Rpp.
void TestSPDAReadPopPushOnly ()
 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 TestAnnotatePdStates ()
 All AnnotatePdStates Tests.
void TestRenameStackSymbols ()
 All RenG tests.
void TestRemoveLambdaPop ()
 All RemoveLambdaPop tests.
void TestSPDA ()
 All SPDA tests.
void TestRemoveMultPop ()
 All RemoveMultPop tests.
void TestNda ()
 All Nda 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 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 TestRup ()
 All Rup tests.
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.
int main (std::string &arg1, std::string &arg2)
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, Time::Type tossLB, Time::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, Time::Type tossLB, Time::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.
FAUDES_API 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)
FAUDES_API 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)
FAUDES_API bool IsEventDiagnosable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, std::string &rReportString)
 Test a system's diagnosability with respect to a given failure partition.
FAUDES_API bool IsIndicatorEventDiagnosable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, std::string &rReportString)
 Test a system's I-diagnosability with respect to a given failure partition.
FAUDES_API 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)
FAUDES_API 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)
FAUDES_API 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
int fileCounter = 0
static long ran_seed [STREAMS] = {DEFAULT}
static int ran_stream = 0
static int ran_initialized = 0
AutoRegisterType< mbDevicegRtiRegisterSpiDevice ("ModbusDevice")
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.

sp_densityfnct.h Discrete density function approximation

Plug-Ins may use the same namespace.

Typedef Documentation

Convenience typedef.

Definition at line 243 of file cfl_cgenerator.h.

Compatibility: pre 2.20b used cEventSet as C++ class name.

Definition at line 247 of file cfl_cgenerator.h.

Definition at line 248 of file cfl_cgenerator.h.

Compatibility: pre 2.20b used cGenerator as C++ class name.

Definition at line 920 of file cfl_cgenerator.h.

Definition at line 921 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::shared_ptr<const GrammarSymbol> faudes::ConstGrammarSymbolPtr

Definition at line 246 of file pd_grammar.h.

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

Definition at line 250 of file pd_grammar.h.

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

Definition at line 254 of file pd_grammar.h.

Compatibility: pre 2.20b used diagGenerator as C++ class name.

Definition at line 201 of file diag_generator.h.

typedef double faudes::Float

Type definition for real type.

Definition at line 52 of file cfl_definitions.h.

typedef unsigned long int faudes::fType

Convenience typdef flag data.

Definition at line 182 of file cfl_attributes.h.

Convenience typedef for std GotoGenerator.

Definition at line 287 of file pd_gotogenerator.h.

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

Definition at line 245 of file pd_grammar.h.

Definition at line 281 of file pd_grammar.h.

Definition at line 257 of file pd_grammar.h.

Definition at line 286 of file pd_grammar.h.

Definition at line 486 of file cfl_project.cpp.

typedef uint32_t faudes::Idx

Type definition for index type (allways 32bit)

Definition at line 43 of file cfl_definitions.h.

typedef long int faudes::Int

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

Definition at line 47 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.

Compatibility: pre 2.20b used mtcGenerator as C++ class name.

Definition at line 751 of file mtc_generator.h.

Definition at line 485 of file cfl_project.cpp.

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

Definition at line 249 of file pd_grammar.h.

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

Definition at line 55 of file lbp_function.cpp.

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

Definition at line 56 of file lbp_function.cpp.

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

Definition at line 253 of file pd_grammar.h.

Compatibility: pre 2.20b used tGenerator as C++ class name.

Definition at line 781 of file tp_tgenerator.h.

Convenience typedef for std TimedGenerator.

Definition at line 776 of file tp_tgenerator.h.

typedef std::vector<std::vector<std::pair<Idx,MergeTransition> > > faudes::TransformationHistoryVec

Definition at line 19 of file pd_alg_sub.h.

typedef unsigned int faudes::uint

Definition at line 35 of file pd_basics.h.

Enumeration Type Documentation

Enumerator:
NORMAL 
CONFUSED 
BLOCK 

Definition at line 88 of file diag_languagediagnosis.h.

Function Documentation

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

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

Parameters
rGenA generator.
stateA state from the generators state set.
Returns
A transition set.

Definition at line 802 of file diag_eventdiagnosis.cpp.

void faudes::ActiveEventsRule ( Generator &  g,
const EventSet &  silent 
)

Definition at line 313 of file cfl_conflequiv.cpp.

void faudes::AdjustHioController ( const HioController &  rHioController,
const HioModule *  rHioModule1,
const HioModule *  rHioModule2,
HioController &  rResEnv 
)

Definition at line 604 of file hio_module.cpp.

FAUDES_API PushdownGenerator faudes::AnnotatePdStates ( 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.

(previously called RenQ)

Parameters
wordword with which the states will be annotated
pdreference to pushdown automaton to be annotated
Returns
copy of the parameter automaton with annotated states

Definition at line 19 of file pd_alg_sub.cpp.

FAUDES_API 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
rGenVecVector of input generators
rResGenReference to resulting composition generator

Definition at line 87 of file cfl_parallel.cpp.

FAUDES_API 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
grthe grammar to be augmented
startSymbolthe new start symbol S. S must not exist in the grammar
augSymbolthe $ symbol which augments the grammar. $ must not exist in the grammar
Returns
augmented grammar with a new production S -> $ S' $

Definition at line 382 of file pd_alg_lrm.cpp.

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 1132 of file op_observercomputation.cpp.

FAUDES_API 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
rTransSetX2EvX1reverse transition relation of the input generator
rControllableEventsset of controllable events
rHighAlphHigh level alphabet
exitStatestart state for backward reachability
currentStatecurrent state for backward reachability
controllablePathfalse if at least one uncontrollable path to the currentState exists
rLocalStatesMapmap for states and their controllability property
rDoneStatesstates that have already been visited
FAUDES_API 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
rLowGenInput generator
rControllableEventsset of controllable events
rHighAlphHigh level alphabet
currentStatestart state for backward reachability
Returns
true if no controllable low-level event has been found

Definition at line 120 of file op_obserververification.cpp.

FAUDES_API 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
configsthe configurations
symbolthe symbol over which to shift
Returns
set that contains all shifted configurations

Definition at line 158 of file pd_alg_lrm.cpp.

bool faudes::BiggerMax ( std::vector< GeneratorVector::Position > &  rCandidate,
GeneratorVector &  rGenVec 
)

Definition at line 1013 of file syn_compsyn.cpp.

void faudes::BlockingEvent ( Generator &  g,
const EventSet &  silent 
)

Definition at line 647 of file cfl_conflequiv.cpp.

void faudes::BlockingSilentEvent ( Generator &  g,
const EventSet &  silent 
)

Definition at line 592 of file cfl_conflequiv.cpp.

FAUDES_API 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
rGenObsLow-level generator. It is modified by the algorithm by relabeling transitions and events
rControllableEventsSet of controllable events
rHighAlphInitial abstraction alphabet
rNewHighAlphModified abstraction alphabet such that the abstraction is an Lm-observer
rMapRelabeledEventsMaps the original events to sets of newly introduced events (accumulatoive, call clear before)
FAUDES_API 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
rGenObsLow-level generator. It is modified by the algorithm by relabeling transitions and events
rControllableEventsSet of controllable events
rHighAlphInitial abstraction alphabet
rNewHighAlphModified abstraction alphabet such that the abstraction is an Lm-observer
rMapChangedTransMaps the original relabeled transitions to the new events
void faudes::calcAbstAlphClosed ( System &  rGenObs,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 667 of file op_observercomputation.cpp.

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

Definition at line 678 of file op_observercomputation.cpp.

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

Definition at line 701 of file op_observercomputation.cpp.

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
rGenObsLow-level generator. It is modified by the algorithm by relabeling transitions and events
rControllableEventsSet of controllable events
rHighAlphInitial abstraction alphabet
rNewHighAlphModified abstraction alphabet such that the abstraction is an Lm-observer
rMapRelabeledEventsMaps the original events to sets of newly introduced events (accumulatoive, call clear before)
FAUDES_API 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
rGenObsLow-level generator. It is modified by the algorithm by relabeling transitions and events
rControllableEventsSet of controllable events
rHighAlphInitial abstraction alphabet
rNewHighAlphModified abstraction alphabet such that the abstraction is an Lm-observer
rMapChangedTransMaps the original relabeled transitions to the new events
void faudes::calcAbstAlphMSA ( System &  rGenObs,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 825 of file op_observercomputation.cpp.

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

Definition at line 836 of file op_observercomputation.cpp.

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

Definition at line 859 of file op_observercomputation.cpp.

FAUDES_API 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
rGenObsLow-level generator. It is modified by the algorithm by relabeling transitions and events
rControllableEventsSet of controllable events
rHighAlphInitial abstraction alphabet
rNewHighAlphModified abstraction alphabet such that the abstraction is an Lm-observer
rMapChangedTransMaps the original relabeled transitions to the new events
void faudes::calcAbstAlphMSALCC ( System &  rGenObs,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 1245 of file op_observercomputation.cpp.

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

Definition at line 1272 of file op_observercomputation.cpp.

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

Definition at line 60 of file mtc_observercomputation.cpp.

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

Definition at line 71 of file mtc_observercomputation.cpp.

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

Definition at line 94 of file mtc_observercomputation.cpp.

FAUDES_API 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
rGenObsLow-level generator. It is modified by the algorithm by relabeling transitions and events
rControllableEventsSet of controllable events
rHighAlphInitial abstraction alphabet
rNewHighAlphModified abstraction alphabet such that the abstraction is an Lm-observer
rMapRelabeledEventsMaps the original events to sets of newly introduced events (accumulatoive, call clear before)
FAUDES_API 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
rGenObsLow-level generator. It is modified by the algorithm by relabeling transitions and events
rControllableEventsSet of controllable events
rHighAlphInitial abstraction alphabet
rNewHighAlphModified abstraction alphabet such that the abstraction is an Lm-observer
rMapChangedTransMaps the original relabeled transitions to the new events
FAUDES_API 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
rGenObsLow-level generator. It is modified by the algorithm by relabeling transitions and events
rControllableEventsSet of controllable events
rHighAlphInitial abstraction alphabet
rNewHighAlphModified abstraction alphabet such that the abstraction is an Lm-observer
rMapRelabeledEventsMaps the original events to sets of newly introduced events (accumulatoive, call clear before)
FAUDES_API 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
rGenObsLow-level generator. It is modified by the algorithm by relabeling transitions and events
rControllableEventsSet of controllable events
rHighAlphInitial abstraction alphabet
rNewHighAlphModified abstraction alphabet such that the abstraction is an Lm-observer
rMapChangedTransMaps the original relabeled transitions to the new events
void faudes::calcAbstAlphObs ( System &  rGenObs,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 746 of file op_observercomputation.cpp.

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

Definition at line 757 of file op_observercomputation.cpp.

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

Definition at line 780 of file op_observercomputation.cpp.

FAUDES_API void faudes::calcAbstAlphObs ( System &  rGenObs,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
EventRelabelMap &  rMapRelabeledEvents 
)

Rti convenience wrapper.

Definition at line 1914 of file op_observercomputation.cpp.

FAUDES_API 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
rGenObsLow-level generator. It is modified by the algorithm by relabeling transitions and events
rControllableEventsSet of controllable events
rHighAlphInitial abstraction alphabet
rNewHighAlphModified abstraction alphabet such that the abstraction is an Lm-observer
rMapChangedTransMaps the original relabeled transitions to the new events
void faudes::calcAbstAlphObsLCC ( System &  rGenObs,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 1171 of file op_observercomputation.cpp.

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

Definition at line 1198 of file op_observercomputation.cpp.

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

Definition at line 1272 of file cfl_bisimulation.cpp.

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

Definition at line 1289 of file cfl_bisimulation.cpp.

void faudes::calcHSupConNB ( const Generator &  rOrigGen,
const EventSet &  rConAlph,
const EventSet &  rLocAlph,
Generator &  rHSupGen 
)

halbway-synthesis

Parameters
rOrigGenthe resulting composed new generator from synthesis-buffer
rConAlphcontrollable events
rLocAlphlocal events
rHSupGenthe resulting generator after halbway-synthesis

Definition at line 1225 of file syn_compsyn.cpp.

FAUDES_API 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
rGenGenerator for which the dynamic system is computed
rHighAlphAbstraction alphabet
rGenDynGenerator representing the dynamic system

Definition at line 46 of file op_observercomputation.cpp.

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
rGenGenerator for which the dynamic system is computed
rControllableEventsSet of controllable events
rHighAlphAbstraction alphabet
rGenDynGenerator representing the dynamic system

Definition at line 303 of file op_observercomputation.cpp.

FAUDES_API 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
rGenGenerator for which the dynamic system is computed
rHighAlphAbstraction alphabet
rGenDynGenerator representing the dynamic system

Definition at line 195 of file op_observercomputation.cpp.

FAUDES_API 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
rGenGenerator for which the dynamic system is computed
rHighAlphAbstraction alphabet
rGenDynGenerator representing the dynamic system

Definition at line 138 of file mtc_observercomputation.cpp.

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
rGenGenerator for which the dynamic system is computed
rHighAlphAbstraction alphabet
rGenDynGenerator representing the dynamic system

Definition at line 159 of file op_observercomputation.cpp.

void faudes::calcWSOE ( const Generator &  rGenOrig,
const EventSet &  rConAlph,
const EventSet &  rLocAlph,
std::map< Idx, Idx > &  rMapStateToPartition,
Generator &  rResGen 
)

weak synthesis obeservation equivalence [not implemented]

Parameters
rGenOrigoriginal generator
rConAlphcontrollable events
rLocAlphlocal events
rMapStateToPartitionmap state to equivalent class
rResGenthe quotient automaton
FAUDES_API void faudes::CDExt ( const Generator &  gen,
const EventSetVector &  ee,
const EventSet &  unionset,
EventSet &  ek 
)

Definition at line 99 of file con_decomposability_extension.cpp.

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 
)

Definition at line 68 of file syn_supreduce.cpp.

FAUDES_API 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
rGenObsLow-level generator. It is modified by the algorithm by relabeling transitions and events
rSplitAlphabetReference to the current alphabet for splitting verification
rNondeterministicStatesvector with states where nondeterminism has to be resolved and the related event
entryStatecurrent state that is investigated
bool faudes::CheckSplit ( const Generator &  rGen,
const EventSet &  rSplitAlphabet,
const vector< pair< StateSet, Idx > > &  rNondeterministicStates,
Idx  entryState 
)

Definition at line 634 of file op_observercomputation.cpp.

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

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

Parameters
rStringstring
lenMaximum number of charakters in string (approx)
Returns
Collapsed string

Definition at line 91 of file cfl_helper.cpp.

FAUDES_API bool faudes::CombinedTransitions ( Idx  q,
PushdownGenerator &  rPd,
StateSet &  next,
StateSet &  done 
)

Merge transitions from state q with adjacent transitions without changing the marked language.

( see PossibleAdjacentMerges() )

Parameters
qidx of state q
rPdreference to pushdown generator
nextreference to set of states to be checked next. If no transitions were merged, all successor states of q will be added to next. If transitions were merged, state q will be added to next.
donereference to set of states which already checked If no transitions was merged, state q will be added to done.
Returns
true, if a merger was made. False if not

Definition at line 1761 of file pd_alg_sub.cpp.

bool faudes::CompareConfigGsPair ( const ConfigSetGsPair &  lhs,
const ConfigSetGsPair &  rhs 
)

Definition at line 104 of file pd_parser.cpp.

FAUDES_API bool faudes::CompareConfigSet ( const std::set< Lr1Configuration > &  lhs,
const std::set< Lr1Configuration > &  rhs 
)

Definition at line 85 of file pd_parser.cpp.

FAUDES_API bool faudes::CompareGs ( const GrammarSymbolPtr &  lhs,
const GrammarSymbolPtr &  rhs 
)

Definition at line 155 of file pd_grammar.cpp.

FAUDES_API bool faudes::CompareGsVector ( const GrammarSymbolVector &  lhs,
const GrammarSymbolVector &  rhs 
)

Definition at line 126 of file pd_grammar.cpp.

FAUDES_API 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
rGen1First MtcSystem for parallel composition
stdidx1Index to first MtcSystem's current state
colors1Color set of first MtcSystem
rGen2Second MtcSystem for parallel composition
stdidx2Index to second MtcSystem's current state
colors2Color set of second MtcSystem
composedSetColor set where composition colors will be inserted
Exceptions
Exception
  • Index not member of set (id 200)
  • Index not found in set (id 201)

Definition at line 213 of file mtc_parallel.cpp.

FAUDES_API void faudes::CompositionalSynthesisUnchecked ( const GeneratorVector &  rPlantGenVec,
const EventSet &  rConAlph,
const GeneratorVector &  rSpecGenVec,
std::map< Idx, Idx > &  rMapEventsToPlant,
GeneratorVector &  rDisGenVec,
GeneratorVector &  rSupGenVec 
)

Compositional synthesis.

Variant of CompositionalSynthesis(const GeneratorVector&,const EventSet&,const GeneratorVector&,std::map<Idx,Idx>&,GeneratorVector&,GeneratorVector&); without parameter-consistency test.

Parameters
rPlantGenVecPlant components (must be deterministic)
rConAlphOverall set of controllable events
rPlantSpecVecSpecification components (must be deterministic)
rMapEventsToPlantResulting event map
rPlantDisVecResulting distinuisher automata
rPlantDisVecResulting supervisor automata

Definition at line 1361 of file syn_compsyn.cpp.

void faudes::CompositionMap1 ( const std::map< std::pair< Idx, Idx >, Idx > &  rCompositionMap,
std::map< Idx, Idx > &  rCompositionMap1 
)

Definition at line 681 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 693 of file cfl_parallel.cpp.

FAUDES_API 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
rGobsInput diagnoser G_o.
rReverseCompositionMapOutput variable containing the mapping of G_o states and G_d states (generated by Parallel()).
rGdOutput 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.

FAUDES_API 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
rGenMarkedNonSpecBehaviourInput generator that specifies specification violations by marked states.
rGobsOutput variable for G_o.

Definition at line 27 of file diag_languagediagnosis.cpp.

FAUDES_API 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
rOrigGenInput generator, which is a model of the original plant containing the relevant failures events.
rFailureTypeFailure type name.
rFailureEventsFailure events belonging to the failure type.
rGobsOutput variable for G_o.
void faudes::ComputeGobs ( const System &  rOrigGen,
const string &  rFailureType,
const EventSet &  rFailureEvents,
Diagnoser &  rGobs 
)

Definition at line 423 of file diag_eventdiagnosis.cpp.

FAUDES_API 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
rOrigGenInput generator, which is a model of the original plant containing the relevant failures events.
rAttrFTMapFailure partition.
rGobsOutput variable for G_o.
Exceptions
Exception
  • Input generator has no unique initial state (id 301).

Definition at line 431 of file diag_eventdiagnosis.cpp.

FAUDES_API 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
rGenInput generator.
rUnobsEventsUnobservable events in the generators alphabet.
StateA state of the generators state set.
rReachabilityMapOutput 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.

FAUDES_API 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
rGenInput generator.
rUnobsEventsUnobservable events in the generators alphabet.
rFailuresUnobservable failure events in the generators alphabet.
StateA state of the generators state set.
rAttrFTMapFailure partition.
rReachabilityMapOutput 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
rGenInput generator.
rUnobsEventsUnobservable events in the generators alphabet.
StateThe current state within the trace.
doneProgress.
rReachabilityMapOutput 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.

FAUDES_API 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
rGenInput generator.
rUnobsEventsUnobservable events in the generators alphabet.
rFailuresUnobservable failure events in the generators alphabet.
StateThe current state within the trace.
rAttrFTMapFailure partition.
rReachabilityMapOutput 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.
FToccurredCollects 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.

FAUDES_API Generator faudes::ComputeTildeG ( const EventSet &  unionset,
const EventSetVector &  ee,
const EventSet &  ek,
const Generator &  gen 
)

Definition at line 112 of file con_decomposability_extension.cpp.

FAUDES_API 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
rGengenerator marking the language to be concatenated with Sigma*

Definition at line 151 of file syn_supnorm.cpp.

FAUDES_API std::string faudes::ConfigSetSetToStr ( const Lr1ConfigurationSetSet  configSetSet)

To string function for configuration set sets.

Parameters
configSetSetthe configuration set sets to turn into a string
Returns
the configuration set sets as a string

Definition at line 133 of file pd_parser.cpp.

FAUDES_API std::string faudes::ConfigSetToStr ( const std::set< Lr1Configuration > &  configs)

To string function for configuration sets.

Parameters
configsthe configuration set to turn into a string
Returns
the configuration set as a string

Definition at line 116 of file pd_parser.cpp.

FAUDES_API int faudes::ConstructControllerLoop ( const PushdownGenerator &  rContr,
const System &  rPlant,
PushdownGenerator &  rRes,
int  loopcounter = 0,
bool  debug = false 
)

Looped execution to construct a minimal restrictive controller.

Alphabets of specification and plant are expected to be equal.

Parameters
rContrReference to controller candidate
rPlantReference to plant
rResReference to resulting minimal restrictive controller
loopcounterNumber to count number of iterations
debugSet true, to print out single steps of the function
Returns
number of iterations of ConstructControllerLoop

Definition at line 79 of file pd_alg_main.cpp.

FAUDES_API void faudes::ConstructControllerPreCombine ( const PushdownGenerator &  rSpec,
const System &  rPlant,
PushdownGenerator &  rRes,
bool  debug = false 
)

Create a nonblocking product generator of a pushdown generator and a regular generator.

For that, ConstructControllerPreCombine(...) will create the product generator and call the PushdownBlockfree(...) function.

Parameters
rSpecReference to pushdown generator
rPlantReference to regular generator
rResReference to resulting nonblocking product generator
debugSet true, to print out single steps of the function
Returns

Definition at line 59 of file pd_alg_main.cpp.

FAUDES_API bool faudes::ContainsWord ( const GrammarSymbolWordSet &  set,
const GrammarSymbolVector &  word 
)

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

Parameters
setthe set to be searched
wordthe word to be searched for
Returns
true, if the set contains the word, else false

Definition at line 162 of file pd_grammar.cpp.

FAUDES_API std::string faudes::ContributorsString ( )

Return contributors as std::string.

Returns
std::string

Definition at line 141 of file cfl_helper.cpp.

FAUDES_API 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
rPlantGenPlant generator
rCAlphControllable events
rSpecGenSpecification generator
Exceptions
Exception
  • lphabets of generators don't match (id 100)
  • plant generator nondeterministic (id 201)
  • specification generator nondeterministic (id 203)
  • plant and spec generator nondeterministic (id 204)

Definition at line 634 of file syn_supcon.cpp.

FAUDES_API 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
rPlantGenPlant generator
rCAlphControllable events
rOAlphObservable events
rSpecGenSpecification generator
Exceptions
Exception
  • lphabets of generators don't match (id 100)
  • plant generator nondeterministic (id 201)
  • specification generator nondeterministic (id 203)
  • plant and spec generator nondeterministic (id 204)

Definition at line 691 of file syn_supcon.cpp.

FAUDES_API void faudes::ControlProblemConsistencyCheck ( const GeneratorVector &  rPlantGenVec,
const EventSet &  rConAlph,
const GeneratorVector &  rSpecGenVec 
)

Compositional synthesis.

Text consistency of input-data fro compositional synthesis; through exception on error.

Parameters
rPlantGenVecPlant components (must be deterministic)
rConAlphOverall set of controllable events
rPlantSpecVecSpecification components (must be deterministic)

Definition at line 1301 of file syn_compsyn.cpp.

FAUDES_API 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
rReverseCompositionMapInput map as generated by Parallel().
rCompositionMapConverted 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.

FAUDES_API 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
correctPdpushdown generator with correct flags
pdthis generator's event flags will be set to the correctPd's event flags

Definition at line 797 of file pd_alg_main.cpp.

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

Parallel composition of multiple generators.

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

Parallel composition of multiple generators.

Parameters
rGensSTL-vector of generators.
rResGenOutput 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::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
mTypeBy the type we specify type of the specification to build constraint for
constrPGenerator to the resulting operator constraint for the specification
constrEGenerator to the resulting environment constraint for the specification

Definition at line 1810 of file hio_module.cpp.

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

Definition at line 1525 of file cfl_project.cpp.

std::vector<Idx> faudes::CreateNonterms ( const std::vector< Idx > &  rVec,
Terminal  term,
std::map< std::pair< Idx, Terminal >, Idx > &  indexMap 
)

Definition at line 431 of file pd_alg_lrp.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
mTypeBy the type we specify the desired behaviour we want to model
rHioSpecHioPlant reference to the resulting specification (result)
constrPGenerator to the resulting operator constraint for the specification
constrEGenerator to the resulting environment constraint for the specification

Definition at line 1120 of file hio_module.cpp.

FAUDES_API std::string faudes::CreateTempFile ( void  )

Create a temp file, length 0.

Returns
Name of temp file

Definition at line 205 of file cfl_helper.cpp.

template<class GlobalAttr , class StateAttr , class EventAttr , class TransAttr >
void faudes::CreatPdFromDot ( const std::string &  fileName,
TpdGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > &  pd 
)

Definition at line 362 of file pd_dotparser.h.

const std::string faudes::currentDateTime ( )

Definition at line 20 of file pd_scopelogger.cpp.

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

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

Parameters
rGenInput generator.
rReportUser-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.

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

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

Parameters
rGenInput generator.
rCycleOriginsOutput variable for the states that have been found.

Definition at line 334 of file diag_eventdiagnosis.cpp.

FAUDES_API 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
rGenInput generator.
rTodoStates that remain to be processed.
currStateThe current state.
statesOnPathStates that occurred on the path.
rCycleOriginStatesOutput variable for the states that have been found.

Definition at line 354 of file diag_eventdiagnosis.cpp.

void faudes::debug_printf ( const std::string &  msg,
const PushdownGenerator &  pd 
)

Print generator depending on debug level (PD_DEBUG_LEVEL)

Parameters
msgdebugging message and name of printed file
pdreference to generator to be printed
Returns

Definition at line 17 of file pd_debug.cpp.

void faudes::debug_printf ( const std::string &  msg,
const std::string &  tex = "" 
)

Print given text depending on debug level (PD_DEBUG_LEVEL)

Parameters
msgdebugging message and name of printed file
textext to be printed
Returns

Definition at line 24 of file pd_debug.cpp.

FAUDES_API bool faudes::DecentralizedDiagnoser ( const System &  rGen,
const Generator &  rSpec,
const EventSetVector &  rAlphabets,
GeneratorVector &  rDiags 
)

Function definition for run-time interface.

Definition at line 349 of file diag_decentralizeddiagnosis.cpp.

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

Function definition for run-time interface.

Definition at line 367 of file diag_decentralizeddiagnosis.cpp.

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

Obtain all descendants of a configuration set.

Parameters
grthe grammar on which to work
ka natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1))
configa set of configurations whose descendants are to be obtained
Returns
set of all descendant parser configurations

Definition at line 89 of file pd_alg_lrm.cpp.

FAUDES_API 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
grthe grammar on which to work
ka natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1))
configsa set of configurations whose descendants are to be obtained
Returns
set of all immediate descendant parser configurations

Definition at line 69 of file pd_alg_lrm.cpp.

FAUDES_API 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
grthe grammar on which to work
ka natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1))
configthe configuration whose descendants are to be obtained
Returns
set of all descendant parser configurations

Definition at line 17 of file pd_alg_lrm.cpp.

FAUDES_API std::set< Lr1Configuration > faudes::DescInitial ( const Grammar &  gr)

Determine the initial parser configurations for a grammar.

Parameters
grthe grammar
Returns
a set with the initial configurations

Definition at line 291 of file pd_alg_lrm.cpp.

FAUDES_API void faudes::DetachAugSymbol ( Lr1Parser &  rParser)

Detach augmented symbole from Lr(1)-parser.

Parameters
rParserreference to Lr(1)-parser
Returns

Definition at line 394 of file pd_alg_lrp.cpp.

FAUDES_API 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
rGenReference to generator
rEntryStatesMapEntry state map
rResGenReference to resulting deterministic generator

Definition at line 96 of file cfl_determin.cpp.

FAUDES_API 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
rGenReference to generator
rPowerStatesVector that holds the power states
rDetStatesVector that holds the corresponding deterministic states
rResGenReference to resulting deterministic generator

Definition at line 113 of file cfl_determin.cpp.

FAUDES_API bool faudes::DirectoryExists ( const std::string &  rDirectory)

Test existence of directory.

Parameters
rDitectoryName of file to test
Returns
True <> can open directory for reading

Definition at line 320 of file cfl_helper.cpp.

FAUDES_API bool faudes::EqualsGsVector ( const GrammarSymbolVector &  lhs,
const GrammarSymbolVector &  rhs 
)

Definition at line 145 of file pd_grammar.cpp.

FAUDES_API 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
rOrigGenInput plant including failure events.
rFailureTypeMapFailure partition: maps failure type names to failure events.
rDiagGenDiagnoser 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.

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

Test if there exist any cycles in a generator.

Parameters
rGenInput generator.
rReportUser-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.

FAUDES_API 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
rGenInput generator.
rTodoStates to process.
currStateCurrent state.
statesOnPathStates that occurred on the way to current state.
rReportUser-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.

FAUDES_API 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
rGdInput diagnoser generator.
rGobsGenerator G_o to look up failure labels.
rReverseCompositionMapMapping of G_d states with G_o states.
rFailureTypeThe considered failure type.
rReportStringUser-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 463 of file cfl_helper.cpp.

FAUDES_API 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
rStringstring
lenMinimum number of charakters in string
Returns
Expanded string

Definition at line 80 of file cfl_helper.cpp.

void faudes::ExtendedTransRel ( const Generator &  rGen,
const EventSet &  rSilentAlphabet,
TransSet &  rXTrans 
)

Definition at line 119 of file cfl_conflequiv.cpp.

void faudes::ExtendHighAlphabet ( const Generator &  rGen,
EventSet &  rHighAlph,
map< Idx, Idx > &  rMapStateToPartition 
)

Definition at line 520 of file op_observercomputation.cpp.

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

Extract file name from full path.

This version also removes the last suffix.

Parameters
rFullNameFull path of file eg "/home/friend/data/generator.gen"
Returns
Filename "generator"

Definition at line 280 of file cfl_helper.cpp.

FAUDES_API std::string faudes::ExtractDirectory ( const std::string &  rFullPath)

Extract directory from full path.

Parameters
rFullPathFull name of file eg "/home/friend/data/generator.gen"
Returns
Directory eg "/home/friend/data"

Definition at line 262 of file cfl_helper.cpp.

FAUDES_API std::string faudes::ExtractExtension ( const std::string &  rFullName)

Extract file name from full path.

This version also remove the last suffix.

Parameters
rFullNameFull path of file eg "/home/friend/data/generator.gen"
Returns
Extension "gen"

Definition at line 294 of file cfl_helper.cpp.

FAUDES_API std::string faudes::ExtractFilename ( const std::string &  rFullName)

Extract file name from full path.

Parameters
rFullNameFull path of file eg "/home/friend/data/generator.gen"
Returns
Filename "generator.gen"

Definition at line 271 of file cfl_helper.cpp.

FAUDES_API 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
rGenInput generator, is a model of the original plant containing the relevant failures events.
rFailureTypeMapFailure partition: maps failure type names to failure events and indicator events.
rReportUser-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 704 of file cfl_registry.cpp.

FAUDES_API 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
grthe grammar
Returns
all lefthand sides and all righthand sides' postfixes as words

Definition at line 43 of file pd_alg_first.cpp.

FAUDES_API bool faudes::FileCopy ( const std::string &  rFromFile,
const std::string &  rToFile 
)

Copy file.

Parameters
rFromFileName of source file
rToFileName of dest file
Returns
True <> operation ok

Definition at line 385 of file cfl_helper.cpp.

FAUDES_API bool faudes::FileDelete ( const std::string &  rFilename)

Delete file.

Parameters
rFilenameName of file to delete
Returns
True <> could delete the file

Definition at line 380 of file cfl_helper.cpp.

FAUDES_API bool faudes::FileExists ( const std::string &  rFilename)

Test existence of file.

Parameters
rFilenameName of file to test
Returns
True <> can open file for reading

Definition at line 373 of file cfl_helper.cpp.

FAUDES_API 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
symbolSetthe symbol set
wthe word
Returns
set of found symbols

Definition at line 1381 of file pd_alg_sub.cpp.

FAUDES_API 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
symbolSetthe symbol set
wthe word
Returns
pointer to the found symbol or NULL if none is found

Definition at line 333 of file pd_alg_first.cpp.

FAUDES_API std::set< Terminal > faudes::First ( const Grammar &  gr,
const GrammarSymbolVector &  word 
)

Determines which terminals can come first for a given word.

Parameters
grthe grammar on which to work
wordthe word whose first terminals are to be determined
Returns
set of first terminals

Definition at line 237 of file pd_alg_first.cpp.

FAUDES_API 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
grthe grammar on which to work
fthe mapping function (word -> first symbols)
madeChangesthis variable will be written to true if changes were made and written to false if no changes were made
Returns
the updated first function

Definition at line 71 of file pd_alg_first.cpp.

FAUDES_API 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
grthe grammar on which to work
wordthe word whose first terminals are to be determined
Returns
set of first terminals

Definition at line 214 of file pd_alg_first.cpp.

FAUDES_API 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
grthe grammar on which to work
wordthe word whose first terminals are to be determined
Returns
set of first terminals or empty set, if the word cannot be entirely reduced

Definition at line 360 of file pd_alg_first.cpp.

FAUDES_API 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
grthe grammar on which to work
fthe mapping function (word -> first symbols)
Returns
the first function

Definition at line 197 of file pd_alg_first.cpp.

FAUDES_API 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
grthe grammar on which to work
ka natural number k
wordthe 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

Definition at line 393 of file pd_alg_first.cpp.

FAUDES_API 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
grthe grammar
wordthe word
Returns
set of first terminals or empty set if the word contained symbols not in the grammar

Definition at line 287 of file pd_alg_first.cpp.

FAUDES_API 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
gotoGenthe generator on which to work
statethe state of which to find the successor state
symbolthe 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.

Definition at line 18 of file pd_alg_lrp.cpp.

FAUDES_API 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
gotoGenthe generator on which to work
statethe state of which to find the successor state
wordthe input word
Returns
A set with the successor states. The set size will be anywhere between 0 and the length of the word.

Definition at line 39 of file pd_alg_lrp.cpp.

FAUDES_API std::string::size_type faudes::getIde ( std::string::size_type &  rPos,
const std::string &  rInput,
std::string &  rRestString,
const std::string &  rFilename,
const int  lineNr 
)

Get string literal between quotations ("ide") to &resText and return the position after the second quotation (").

Parameters
rPosposition where to search from
rInputinput string
rRestStringreturn the string after the second quotation
rFilenamename of current file
lineNrcurrent line number
Returns
std::string::size_type position after the second quotation

Definition at line 216 of file pd_dotparser.cpp.

void faudes::GlobalSelfloop ( GeneratorVector &  rGenVec)

remove the events from the entire buffer which have only selfloop transitions

Parameters
rGenVecsynthesis-buffer

Definition at line 673 of file syn_compsyn.cpp.

FAUDES_API 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
grthe grammar on which to work
ka natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1))
configsthe configurations
symbolthe symbol over which to shift
Returns
set containing the shifted configuration's descendant configurations

Definition at line 182 of file pd_alg_lrm.cpp.

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
rChildrenvector of HioModules to group
rParentModuleresulting HioModule

Definition at line 1093 of file hio_module.cpp.

void faudes::H_tocollect ( StateSet &  rBlockingstates,
const TransSetX2EvX1 &  rRtrel,
const EventSet &  rLouc,
const EventSet &  rShuc,
TransSetX2EvX1 &  rToredirect 
)

Definition at line 1184 of file syn_compsyn.cpp.

void faudes::HioShuffle_Musunoi ( const HioPlant &  rPlantA,
const HioPlant &  rPlantB,
int  depth,
Generator &  rIOShuffAB 
)

Definition at line 2736 of file hio_functions.cpp.

FAUDES_API void faudes::HioStatePartition ( HioConstraint &  rConstraint)

Function definition for run-time interface.

Parameters
rConstraintHioConstraint

Definition at line 374 of file hio_constraint.cpp.

FAUDES_API void faudes::HioStatePartition ( HioPlant &  rPlant)

Function definition for run-time interface.

Parameters
rPlantHioPlant

Definition at line 445 of file hio_plant.cpp.

FAUDES_API void faudes::HioStatePartition ( HioController &  rController)

Function definition for run-time interface.

Parameters
rControllerHioController

Definition at line 502 of file hio_controller.cpp.

FAUDES_API void faudes::HioStatePartition ( HioEnvironment &  rEnvironment)

Function definition for run-time interface.

Parameters
rEnvironmentHioEnvironment

Definition at line 505 of file hio_environment.cpp.

void faudes::HioSynth_Musunoi ( const Generator &  rPlant,
const HioPlant &  rSpec,
const Generator &  rConstr,
const Generator &  rLocConstr,
const EventSet &  rYp,
const EventSet &  rUp,
Generator &  rController 
)

Definition at line 2875 of file hio_functions.cpp.

void faudes::IncomingEquivalentCandidates ( const TransSet &  rXTrans,
const TransSetX2EvX1 &  rRevXTrans,
const EventSet &  rSilent,
const StateSet &  rInitialStates,
Idx  q1,
StateSet &  rRes 
)

Definition at line 262 of file cfl_conflequiv.cpp.

FAUDES_API 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
rGenPlantPlant component automaton
rMapRelabeledEventsMaps the original events to sets of newly introduced events
rNewEventsReturns the newly inserted events (accumulative, call clear before)
FAUDES_API 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
rGenPlantPlant component automaton
rMapRelabeledEventsMaps the original events to sets of newly introduced events
rNewEventsReturns the newly inserted events (accumulative, call clear before)
FAUDES_API 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
rGenPlantPlant component automaton
rMapRelabeledEventsmaps the original events to sets of newly introduced events
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
rGenPlantPlant component automaton
rMapRelabeledEventsmaps the original events to sets of newly introduced events
void faudes::insertRelabeledEvents ( System &  rGenPlant,
const map< Idx, set< Idx > > &  rMapRelabeledEvents,
Alphabet &  rNewEvents 
)

Definition at line 1848 of file op_observercomputation.cpp.

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

Definition at line 1871 of file op_observercomputation.cpp.

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

Definition at line 1897 of file op_observercomputation.cpp.

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

Definition at line 1903 of file op_observercomputation.cpp.

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

Rti convenience wrapper.

Definition at line 1927 of file op_observercomputation.cpp.

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

Rti convenience wrapper.

Definition at line 1934 of file op_observercomputation.cpp.

FAUDES_API long int faudes::IntegerSum ( const Integer &  arg1,
const Integer &  arg2 
)

Definition at line 102 of file cfl_elementary.cpp.

FAUDES_API long int faudes::IntegerSum ( const IntegerVector &  intvect)

Definition at line 107 of file cfl_elementary.cpp.

FAUDES_API 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
sfirst generator
pdsecond generator
rPdresult generator

Definition at line 629 of file pd_alg_main.cpp.

FAUDES_API uint faudes::InTransitionSize ( Idx  trg,
const PushdownGenerator &  rPd 
)

Getting the number of incoming transitions of a state.

Parameters
trgidx of target state
rPdreference to pushdown generator
Returns
number of incoming transitions

Definition at line 1659 of file pd_alg_sub.cpp.

FAUDES_API void faudes::IoStatePartition ( IoSystem &  rIoSystem)

Construct io state partition.

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

Parameters
rIoSystemGenerator to test.

Definition at line 133 of file ios_algorithms.cpp.

FAUDES_API 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
rPlantIO-System - plant model
rSpecGenerator - specification
rSupIO-System - supervisor
Exceptions
Exception
  • Any exceptions passed on from SupConComplete

Definition at line 420 of file ios_algorithms.cpp.

FAUDES_API 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
rPlantIO-System - plant model
rSpecGenerator - specification
rSupIO-System - supervisor
Exceptions
Exception
  • Any exceptions passed on from SupConOmegaNB

Definition at line 406 of file ios_algorithms.cpp.

FAUDES_API bool faudes::IsCD ( const Generator &  gen,
const EventSetVector &  ee,
const EventSet &  ek,
const EventSet &  unionset,
Generator &  proof 
)

Definition at line 93 of file con_decomposability.cpp.

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.

FAUDES_API bool faudes::IsCoDiagnosable ( const System &  rGen,
const Generator &  rSpec,
const EventSetVector &  rAlphabets 
)

Function definition for run-time interface.

Definition at line 337 of file diag_decentralizeddiagnosis.cpp.

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

Definition at line 3904 of file cfl_generator.cpp.

FAUDES_API 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
rPlantGenPlant generator
rCAlphControllable events
rSpecGenSpecification generator
rCriticalStatesSet of critical states
Exceptions
Exception
  • alphabets of generators don't match (id 100)
  • plant generator nondeterministic (id 201)
  • specification generator nondeterministic (id 203)
  • plant & spec generator nondeterministic (id 204)
Returns
true / false

Definition at line 243 of file syn_supcon.cpp.

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

Definition at line 13 of file diag_eventdiagnosis.cpp.

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

Function definition for run-time interface.

Definition at line 78 of file diag_eventdiagnosis.cpp.

FAUDES_API bool faudes::isExtendedEk ( const Generator &  tildeGen,
const Generator &  rGen,
EventSet &  ek 
)

! Remembers the last symbol from E-Ek that has been read.

Definition at line 138 of file con_decomposability_extension.cpp.

FAUDES_API 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
rHioConstraintHioConstraint to check, HioStateFlags are set
rQYState set containing all QY states
rQUState set containing all QU states
rErrEvSetEvent set for possible 'bad' events
rErrTrSetEvent set for possible 'bad' transition relations
rErrStSetEvent set for possible 'bad' states
rReportStrInformation about test results
Returns
true if rHioConstraint is in I/O-constraint form

Definition at line 16 of file hio_constraint.cpp.

FAUDES_API 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
rHioConstraintHioConstraint to check, HioStateFlags are set
rReportStrInformation about test results
Returns
true if rHioConstraint is in I/O-constraint form

Definition at line 352 of file hio_constraint.cpp.

FAUDES_API 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
rHioConstraintHioConstraint to check, HioStateFlags are set
Returns
true if rHioConstraint is in I/O-constraint form

Definition at line 362 of file hio_constraint.cpp.

FAUDES_API 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
rHioControllerHioController to check, HioStateFlags are set
rQUcState set containing all QUc states
rQYPState set containing all QYP states
rQUpState set containing all QUp states
rQYcUpState set containing all QYcUp states
rErrEvSetEvent set for possible 'bad' events
rErrTrSetEvent set for possible 'bad' transition relations
rErrStSetEvent set for possible 'bad' states
rReportStrInformation about test results
Returns
true if rHioController is in I/O-controller form

Definition at line 16 of file hio_controller.cpp.

FAUDES_API 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
rHioControllerHioController to check, HioStateFlags are set
rReportStrInformation about test results
Returns
true if rHioController is in I/O-controller form

Definition at line 480 of file hio_controller.cpp.

FAUDES_API 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
rHioControllerHioController to check, HioStateFlags are set
Returns
true if rHioController is in I/O-controller form

Definition at line 490 of file hio_controller.cpp.

FAUDES_API 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
rHioEnvironmentHioEnvironment to check, HioStateFlags are set
rQYeState set containing all QYe states
rQUeState set containing all QUe states
rQUlState set containing all QUl states
rQYlUeState set containing all QYlUe states
rErrEvSetEvent set for possible 'bad' events
rErrTrSetEvent set for possible 'bad' transition relations
rErrStSetEvent set for possible 'bad' states
rReportStrInformation about test results
Returns
true if rHioEnvironment is in I/O-environment form

Definition at line 16 of file hio_environment.cpp.

FAUDES_API 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
rHioEnvironmentHioEnvironment to check, HioStateFlags are set
rReportStrInformation about test results
Returns
true if rHioEnvironment is in I/O-environment form

Definition at line 482 of file hio_environment.cpp.

FAUDES_API 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
rHioEnvironmentHioEnvironment to check, HioStateFlags are set
Returns
true if rHioEnvironment is in I/O-environment form

Definition at line 493 of file hio_environment.cpp.

FAUDES_API 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
rHioPlantHioPlant to check, HioStateFlags are set
rQYpYeState set containing all QYpYe states
rQUpState set containing all QUp states
rQUeState set containing all QUe states
rErrEvSetEvent set for possible 'bad' events
rErrTrSetEvent set for possible 'bad' transition relations
rErrStSetEvent set for possible 'bad' states
rReportStrInformation about test results
Returns
true if rHioPlant is in I/O-plant form

Definition at line 16 of file hio_plant.cpp.

FAUDES_API 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
rHioPlantHioPlant to check, HioStateFlags are set
rReportStrInformation about test results
Returns
true if rHioPlant is in I/O-plant form

Definition at line 422 of file hio_plant.cpp.

FAUDES_API 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
rHioPlantHioPlant to check, HioStateFlags are set
Returns
true if rHioPlant is in I/O-plant form

Definition at line 433 of file hio_plant.cpp.

bool faudes::IsIncomingEquivalent ( const TransSetX2EvX1 &  rRevXTrans,
const EventSet &  rSilent,
const StateSet &  rInitialStates,
Idx  q1,
Idx  q2 
)

Definition at line 195 of file cfl_conflequiv.cpp.

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

Definition at line 85 of file diag_eventdiagnosis.cpp.

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

Function definition for run-time interface.

Definition at line 153 of file diag_eventdiagnosis.cpp.

FAUDES_API bool faudes::IsLambdaReplacement ( const std::string &  str)

check if given string is a replacement for lambda Replacements are empty string (""), underline ("_") , html lambda code ("&lambda;") or "lambda"

Parameters
strstring to check
Returns
true, if given string is a replacement for lambda

Definition at line 152 of file pd_dotparser.cpp.

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

Function definition for run-time interface.

Definition at line 20 of file diag_languagediagnosis.cpp.

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

Test function to verify language-diagnosability.

Definition at line 445 of file diag_languagediagnosis.cpp.

FAUDES_API 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
rLowGenInput generator
rControllableEventsset of controllable events
rHighAlphHigh level alphabet
Returns
true if LCC holds

Definition at line 316 of file op_obserververification.cpp.

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

Test if a generator is live.

Parameters
rGenInput generator.
rReportUser-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,
string &  rReportString 
)

Definition at line 23 of file diag_modulardiagnosis.cpp.

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 
)

Function definition for run-time interface.

Definition at line 252 of file diag_modulardiagnosis.cpp.

FAUDES_API 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
rLowGenInput generator
rHighAlphHigh level alphabet
Returns
true if the observer property holds

Definition at line 39 of file mtc_obserververification.cpp.

FAUDES_API 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
rGen1Generator 1
rGen2Generator 2
rForbidden1Forbidden states in Generator 1
rForbidden2Forbidden states in Generator 2
Returns
True if mutual controllability is fulfilled

Definition at line 43 of file op_mc.cpp.

FAUDES_API void faudes::IsMutuallyControllable ( const System &  rGen1,
const System &  rGen2,
bool &  rRes 
)

RTI wrapper.

Definition at line 109 of file op_mc.cpp.

FAUDES_API bool faudes::IsNormal ( const System &  rPlantGen,
const Generator &  rSupCandGen 
)

IsNormal wrapper.

Wrapper for convenient access via the run-time interface.

Definition at line 145 of file syn_supnorm.cpp.

FAUDES_API 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
rLowGenInput generator
rControllableEventsset of controllable events
rHighAlphHigh level alphabet
Returns
true if OCC holds

Definition at line 93 of file op_obserververification.cpp.

FAUDES_API 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
rGenPlantGenerator GPlant
rGenCandGenerator GCand

Definition at line 452 of file syn_functions.cpp.

bool faudes::IsStdSynthesisConsistentUnchecked ( const Generator &  rPlantGen,
const EventSet &  rCAlph,
const Generator &  rPlant0Gen 
)

Definition at line 58 of file syn_sscon.cpp.

FAUDES_API void faudes::LabelCorrection ( const std::multimap< Idx, DiagLabelSet > &  mm,
AttributeDiagnoserState &  attr 
)

Perform label correction on propagated failure type labels.

Parameters
mmPropagated absolute failure type labels for a diagnoser state.
attrOutput 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.

FAUDES_API 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
lastLabelDiagnoser label of state estimate.
failureTypesFailure types that occurred.
newLabelOutput variable for the new label.

Definition at line 1020 of file diag_eventdiagnosis.cpp.

FAUDES_API 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
rGenVecVector of input generators
rResGenReference to resulting generator

Definition at line 205 of file cfl_regular.cpp.

FAUDES_API 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
rGenVecVector of input generators
rResGenReference to resulting generator

Definition at line 155 of file cfl_regular.cpp.

FAUDES_API void faudes::LocalAccessibleReach ( const Generator &  rLowGen,
const EventSet &  rHighAlph,
Idx  lowState,
StateSet &  rAccessibleReach 
)

Compute the accessible reach for a local automaton.

Parameters
rLowGenLow level generator
rHighAlphHigh level alphabet
lowStateLow level entry state
rAccessibleReachResult

Definition at line 161 of file cfl_localgen.cpp.

FAUDES_API void faudes::LocalCoaccessibleReach ( const TransSetX2EvX1 &  rRevTransRel,
const EventSet &  rHighAlph,
Idx  lowState,
StateSet &  rCoaccessibleReach 
)

Compute the coaccessible reach for a local automaton.

Parameters
rRevTransRelReverse sorted transition relation
rHighAlphHigh level alphabet
lowStateLow level exit state
rCoaccessibleReachResult

Definition at line 129 of file cfl_localgen.cpp.

FAUDES_API 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
rPlantGenPlant generator
rSpecGenSpecification generator
rHighAlphhigh-level alphabet
rObsAlphobservable 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)

Definition at line 40 of file obs_local_observation_consistency.cpp.

void faudes::LocalSelfloop ( Generator &  rGen,
EventSet &  rLocAlph 
)

remove the events from a generator which have only selfloop transitions

Parameters
rGengenerator which is to be abstracted
rLocAlphlocal events

Definition at line 725 of file syn_compsyn.cpp.

FAUDES_API 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 ( bool   pBreakvoid)

Definition at line 620 of file cfl_helper.cpp.

FAUDES_API void faudes::LoopCallback ( void  )

Algorithm loop callback.

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

Exceptions
Breakon appliation request (id 110)

Definition at line 627 of file cfl_helper.cpp.

FAUDES_API 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
rLowGenLow level generator (just needed for determining statetable)
rHighAlphHigh level events
rEntryStatesMapEntry states map (see CreateEntryStatesMap(resmap))
rLowRevTransRelReverse sorted low level transition relation
highStateHi level state for which to compute low level exit states
Exceptions
ExceptionHi level state not found in entry states map (with FAUDES_CHECKED) (id 502)

Definition at line 27 of file cfl_localgen.cpp.

FAUDES_API 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
rHighAlphHigh level events
rEntryStatesMapEntry states map (see CreateEntryStatesMap(resmap))
rLowRevTransRelReverse sorted low level transition relation
highStateHi level state for which to compute low level exit states
rLowExitStatesReference to StateSet for low level exit states (result)
Exceptions
ExceptionHi level state not found in entry states map (with FAUDES_CHECKED)

Definition at line 40 of file cfl_localgen.cpp.

FAUDES_API GotoGenerator faudes::Lrm ( const Grammar &  gr,
uint  k 
)

Generate an LR(k) machine for a grammar.

Parameters
grthe grammar
ka 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

Definition at line 334 of file pd_alg_lrm.cpp.

FAUDES_API 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
grthe grammar on which to work
ka natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1))
configsthe 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

Definition at line 194 of file pd_alg_lrm.cpp.

FAUDES_API 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
grthe grammar on which to work
ka natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1))
transitionsthe transitions that are already found
statesthe states that are already found
examineStatesthe states that need to be examined for outgoing transitions
Returns
a pair with the transition map and all states

Definition at line 251 of file pd_alg_lrm.cpp.

FAUDES_API 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
grthe grammar on which to work
augGraugmented version of the grammar on which to work
gotoGenLR(k) machine of the grammar
ka natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1))
augSymbolthe terminal with which the grammar was augmented to create the augmented grammar
Returns
set of parsing rules

Definition at line 315 of file pd_alg_lrp.cpp.

FAUDES_API PushdownGenerator faudes::LrParser2EPDA ( const Lr1Parser &  parser)

Definition at line 572 of file pd_alg_lrp.cpp.

FAUDES_API 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
grthe grammar on which to work
augGraugmented version of the grammar on which to work
gotoGenLR(k) machine of the grammar
ka 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

Definition at line 206 of file pd_alg_lrp.cpp.

FAUDES_API 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
grthe grammar on which to work
augGraugmented version of the grammar on which to work
gotoGenLR(k) machine of the grammar
ka 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

Definition at line 297 of file pd_alg_lrp.cpp.

FAUDES_API 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
grthe grammar on which to work
augGraugmented version of the grammar on which to work
gotoGenLR(k) machine of the grammar
ka 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

Definition at line 85 of file pd_alg_lrp.cpp.

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.

int faudes::main ( std::string &  arg1,
std::string &  arg2 
)

Definition at line 25 of file pd_pushdown_V2.cpp.

void faudes::MakeDistinguisher ( Generator &  AbstGen,
std::map< Idx, Idx > &  rMapStateToPartition,
Generator &  OrigGen,
std::map< Idx, std::vector< Idx > > &  rMapOldToNew 
)

make a distinguisher and a map for solving nondeterminism and rewrite abstracted automaton

Parameters
AbstGenthe abstracted generator
rMapStateToPartitionmap state to equivalent class
OrigGenthe non-abstracted generator (after halbway-synthesis bevor abstraction)
rMapOldToNewmap the replaced events to new events

Definition at line 753 of file syn_compsyn.cpp.

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

Definition at line 146 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.

FAUDES_API void faudes::MergeAdjacentTransitions ( PushdownGenerator &  rPd)

Merge adjacent transitions until no more mergers are possible.

This will reduce the number of transitions and states. The marked language does not change.

Technical detail: Let qb be the state between transitions t1 and t2. t1 and t2 will be merged, if

  • qb is no marked state
  • t1 is the only transition, that leads to qb
  • for all transitions t' from qp:
    • t' is no self-loop transition
    • if t1->Ev != lambda then t'->Ev = lambda
  • the from t2 requiring stack-top is pushed by t1
Parameters
rPdreference to pushdown generator

Definition at line 1891 of file pd_alg_sub.cpp.

void faudes::MergeEquivalenceClasses ( Generator &  rGen,
TransSetX2EvX1 &  rRevTrans,
const std::list< StateSet > &  rClasses 
)

Definition at line 52 of file cfl_conflequiv.cpp.

void faudes::MergeNonCoaccessible ( Generator &  g)

Definition at line 625 of file cfl_conflequiv.cpp.

void faudes::MergeSilentSccs ( Generator &  g,
const EventSet &  silent 
)

Definition at line 506 of file cfl_conflequiv.cpp.

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

Definition at line 128 of file diag_modulardiagnosis.cpp.

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

Function definition for run-time interface.

Definition at line 260 of file diag_modulardiagnosis.cpp.

FAUDES_API 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
rGenReference to generator
rEntryStatesMapEntry state map
rResGenReference to resulting deterministic generator

Definition at line 82 of file mtc_project.cpp.

FAUDES_API 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
rGenReference to generator
rPowerStatesVector that holds the power states
rDetStatesVector that holds the corresponding deterministic states
rResGenReference to resulting deterministic generator

Definition at line 99 of file mtc_project.cpp.

FAUDES_API void faudes::mtcInvProject ( const MtcSystem &  rGen,
const EventSet &  rProjectAlphabet,
MtcSystem &  rResGen 
)

RTI wrapper.

See mtcInvProject(MtcSystem&, const EventSet&).

Definition at line 518 of file mtc_project.cpp.

FAUDES_API 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
rGen1First MtcSystem for parallel composition
rGen2Second MtcSystem for parallel composition
rReverseCompositionMap
rResGenGenerator in which the result of the parallel composition is saved

Definition at line 58 of file mtc_parallel.cpp.

FAUDES_API 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
rGenReference to generator
rProjectAlphabetProjection alphabet
rEntryStatesMapReference to entry states map, see Deterministic(..) (result)
rResGenReference to resulting deterministic generator (result)

Definition at line 453 of file mtc_project.cpp.

FAUDES_API 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
rGenMtcSystem
rResGenMinimized MtcSystem (result)
Exceptions
Exception
  • Input automaton nondeterministic (id 505)

Definition at line 32 of file mtc_statemin.cpp.

FAUDES_API 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
rGenMtcSystem
rResGenMinimized MtcSystem (result)
rSubsetsVector of subsets that will be constructed during running the algorithm (optional parameter)
rNewIndicesVector of new state indices corresponding to the subsets (optional parameter)
Exceptions
Exception
  • Input automaton nondeterministic (id 505)

Definition at line 39 of file mtc_statemin.cpp.

FAUDES_API void faudes::mtcStateMin ( const MtcSystem &  rGen,
MtcSystem &  rResGen 
)

RTI wrapper.

See also mtcStateMin(MtcSystem&, MtcSystem&).

Definition at line 301 of file mtc_statemin.cpp.

FAUDES_API 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
rPlantGenPlant MtcSystem
rSpecGenSpecification MtcSystem
rReverseCompositionMapstd::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function
rResGenReference 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)

Definition at line 140 of file mtc_supcon.cpp.

FAUDES_API 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
rPlantGenPlant MtcSystem
rSpecGenSpecification MtcSystem
rReverseCompositionMapstd::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function
rResGenReference 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)

Definition at line 50 of file mtc_supcon.cpp.

FAUDES_API 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
rPlantGenPlant MtcSystem
rSpecGenSpecification MtcSystem
rUAlphUncontrollable Events
rReverseCompositionMapstd::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function
rResGenReference to resulting MtcSystem, the less restrictive supervisor

Definition at line 220 of file mtc_supcon.cpp.

FAUDES_API 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
rPlantGenPlant generator
rCAlphControllable events
rSupGenSpecification 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)

Definition at line 462 of file mtc_supcon.cpp.

void faudes::mtcUniqueInit ( MtcSystem &  rGen)

Definition at line 34 of file mtc_project.cpp.

FAUDES_API PushdownGenerator faudes::Nda ( const PushdownGenerator &  pd)

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

Parameters
pdthe generator
Returns
remodeled generator without double acceptance
Exceptions
Exceptionif a transition is neither read nor pop nor push transition

Definition at line 113 of file pd_alg_sub.cpp.

void * faudes::NDeviceListen ( void *  arg)

Definition at line 677 of file iop_simplenet.cpp.

FAUDES_API 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
rLgenerator of language L
rOAlphobservable alphabet
rKgenerator 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)

Definition at line 45 of file syn_supnorm.cpp.

void faudes::ObservationEquivalentQuotient ( Generator &  g,
const EventSet &  silent 
)

Definition at line 166 of file cfl_conflequiv.cpp.

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

Definition at line 544 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,
std::map< Idx, Idx > &  rControllerStatesMap,
std::map< Idx, EventSet > &  rFeedbackMap 
)

Definition at line 873 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::OnlySilentIncoming ( Generator &  g,
const EventSet &  silent 
)

Definition at line 687 of file cfl_conflequiv.cpp.

void faudes::OnlySilentOutgoing ( Generator &  g,
const EventSet &  silent 
)

Definition at line 761 of file cfl_conflequiv.cpp.

FAUDES_API 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
rGen1First generator
rGen2Second generator
rCompositionMapComposition map (map< pair<Idx,Idx>, Idx>)
rMark2States maked in first generator
rMark1States maked in second generator
rResGenReference to resulting parallel composition generator

Definition at line 170 of file cfl_parallel.cpp.

FAUDES_API 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
rGen1First generator
rGen2Second generator
rCompositionMapComposition map (map< pair<Idx,Idx>, Idx>)
rResGenReference to resulting parallel composition generator

Definition at line 213 of file cfl_parallel.cpp.

template<class GlobalAttr , class StateAttr , class EventAttr , class TransAttr >
FAUDES_API void faudes::ParseEvent ( std::string  input,
const std::string &  rFileName,
const int  lineNr,
TpdGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > &  rPd 
)

Definition at line 285 of file pd_dotparser.h.

template<class GlobalAttr , class StateAttr , class EventAttr , class TransAttr >
FAUDES_API void faudes::ParserInsStackSymbols ( std::vector< std::string > &  rVec,
const std::string &  rFileName,
const int  lineNr,
TpdGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > &  rPd 
)

Definition at line 110 of file pd_dotparser.h.

template<class GlobalAttr , class StateAttr , class EventAttr , class TransAttr >
FAUDES_API void faudes::ParseStackBottom ( const std::string  input,
const std::string &  rFilename,
const int  linenr,
TpdGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > &  rPd 
)

Definition at line 349 of file pd_dotparser.h.

template<class GlobalAttr , class StateAttr , class EventAttr , class TransAttr >
FAUDES_API void faudes::ParseState ( const std::string  input,
const std::string &  rFileName,
const int  lineNr,
TpdGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > &  rPd 
)

Definition at line 326 of file pd_dotparser.h.

template<class GlobalAttr , class StateAttr , class EventAttr , class TransAttr >
FAUDES_API bool faudes::ParseTransition ( const std::string  input,
const std::string &  rFilename,
const int  linenr,
TpdGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > &  rPd 
)

Definition at line 151 of file pd_dotparser.h.

FAUDES_API std::set< Lr1Configuration > faudes::PassesX ( const Lr1Configuration &  config,
const GrammarSymbolPtr &  symbol 
)

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

Parameters
configthe configuration
symbolthe 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

Definition at line 111 of file pd_alg_lrm.cpp.

FAUDES_API const std::string& faudes::PathSeparator ( void  )

Std dir-separator.

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

Return FAUDES_PLUGINS as std::string.

Returns
std::string with FAUDES_VERSION

Definition at line 136 of file cfl_helper.cpp.

FAUDES_API std::set< std::pair< Transition, Transition > > faudes::PossibleAdjacentMerges ( Idx  q,
const PushdownGenerator &  pd 
)

Definition at line 1688 of file pd_alg_sub.cpp.

FAUDES_API GrammarSymbolWordSet faudes::PostCl ( const GrammarSymbolVector &  word)

Construct the postfix closure of a word.

Parameters
wordthe word
Returns
all postfixes of the word including lambda

Definition at line 18 of file pd_alg_first.cpp.

FAUDES_API std::string faudes::PrependDirectory ( const std::string &  rDirectory,
const std::string &  rFileName 
)

Construct full path from directory and filename.

Parameters
rDirectoryDirectory eg "/home/friend/data"
rFileNameFile eg "generator.gen"
Returns
Path eg "/home/friend/data/generator.gen"

Definition at line 309 of file cfl_helper.cpp.

FAUDES_API 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
rDotFilename of dot file
rOutFilename of graphics file
rOutFormatgraphics format eg "png", "jpg"
rDotExecpath/name of executable
Exceptions
Exception
  • error in systemcall (id 3)
  • unkown format (id 3)

Definition at line 148 of file cfl_helper.cpp.

FAUDES_API 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
rGen1First generator
rGen2Second generator
rCompositionMapComposition map (map< pair<Idx,Idx>, Idx>)
rMark2States maked in first generator
rMark1States maked in second generator
rResGenReference to resulting product composition generator

Definition at line 497 of file cfl_parallel.cpp.

FAUDES_API 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
rGen1First generator
rGen2Second generator
rCompositionMapComposition map (map< pair<Idx,Idx>, Idx>)
rResGenReference to resulting product composition generator

Definition at line 522 of file cfl_parallel.cpp.

FAUDES_API 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
rGenReference to generator
rProjectAlphabetProjection alphabet
rEntryStatesMapReference to entry states map, see Deterministic(..) (result)
rResGenReference to resulting deterministic generator (result)

Definition at line 1426 of file cfl_project.cpp.

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

Definition at line 683 of file cfl_project.cpp.

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

Definition at line 801 of file cfl_project.cpp.

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

Definition at line 493 of file cfl_project.cpp.

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

Definition at line 46 of file cfl_project.cpp.

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

Definition at line 128 of file cfl_project.cpp.

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

Definition at line 1056 of file cfl_project.cpp.

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

Definition at line 603 of file cfl_project.cpp.

FAUDES_API void faudes::PushdownAccessible ( const PushdownGenerator &  pd,
PushdownGenerator &  resPd,
bool  coacc = true,
bool  debug = false 
)

Construct the accessible part of a pushdown generator.

Technical Details: The Algorithm converts the given pushdown generator to a context free grammar (CFG) and removes unreachable productions. From the reduced CFG accessible states and transitions can be identified.

By creating only reducible productions (see Sp2Lr() ) the function will also remove not coaccessible states. To avoid this, set 'coacc' to false.

Parameters
rPdReference to pushdown generator to make accessible
resPdReference to resulting accessible pushdown generator
coaccSet false, to avoid that not coaccessible states will be removed
debugSet true, to print out single steps of the function.
Returns

Definition at line 317 of file pd_alg_main.cpp.

FAUDES_API void faudes::PushdownBlockfree ( const PushdownGenerator &  rPd,
PushdownGenerator &  rResPd,
bool  debug = false 
)

Make a pushdown generator nonblocking.

This means, that the function will solve blocking issues.

Technical Details: The Algorithm converts the given pushdown generator to a (LR(1)-) grammar, removes unreachable productions and reconverts the grammar (via LR-parser) to an automaton. This will remodel the pushdown generator and may replace states and stack symbols with new ones.

The marked language does not change

Parameters
rPdReference to pushdown generator to make nonblocking
rResPdReference to resulting nonblocking pushdown generator
debugSet true, to print out single steps of the function
Returns

Definition at line 151 of file pd_alg_main.cpp.

FAUDES_API void faudes::PushdownConstructController ( const PushdownGenerator &  rSpec,
const System &  rPlant,
PushdownGenerator &  rRes,
bool  debug = false 
)

Construct a minimal restrictive sound controller, based on the Algorithm presented by Sven Schneider and Anne-Kathrin Schmuck.

Alphabets of specification and plant are expected to be equal.

Parameters
specReference to specification
plantReference to plant
rResReference to resulting minimal restrictive controller
debugSet true, to print out single steps of the function
Returns

Definition at line 16 of file pd_alg_main.cpp.

FAUDES_API bool faudes::PushdownTrim ( PushdownGenerator &  rPd,
const uint  n,
bool  debug = false 
)

Make generator trim.

This function removes all inaccessible states, useless transitions and unused stack symbols, with regard to the top n elements of the stacks. Useless transitions are those outgoing transitions, that requiring stack-top never fulfills. The function also removes states, that do not reach a marked state (with regard to the top n elements) by calling vGenerator::trim after removing foregoing transitions.

Note: For n = 0 the pushdown generator will call vGenerator::trim, therefore no useless transitions or unused stack symbols will be removed.

Parameters
pdreference to pushdown automaton to be trim n lookahead
debugSet true to debug
Returns
True if resulting generator contains at least one initial state and at least one marked state.

Definition at line 273 of file pd_alg_sub.cpp.

double faudes::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)

Returns
Random value in [0,1) ( excluding 1 (?))

Definition at line 75 of file sp_random.cpp.

double faudes::ran_exponential ( double  mu)

Sample a random variable exponentially Distribution: f(t) dt = 1/mu exp(-t/mu) dt for t>=0.

Parameters
mumu
Returns
Random variabe

Definition at line 107 of file sp_random.cpp.

double faudes::ran_exponential ( double  mu,
Time::Type  tossLB,
Time::Type  tossUB 
)

Sample a random variable exponentially on a restricted interval Distribution: f(t) dt = 1/mu exp(-t/mu) dt for t>=0.

Parameters
mumu
tossLBLower interval bound
tossUBUpper interval bound

Definition at line 116 of file sp_random.cpp.

double faudes::ran_gauss ( double  mu,
double  sigma,
Time::Type  tossLB,
Time::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.

Parameters
mumu
sigmasigma
tossLBLower interval bound
tossUBUpper interval bound

Definition at line 132 of file sp_random.cpp.

double faudes::ran_gaussian_cdf_P ( double  x)

Help function: calculate gaussian CDF using an approximation from Abromowitz and Stegun: Handbook of Mathematical Functions.

Parameters
x
Returns
CDF(x)

Definition at line 224 of file sp_random.cpp.

void faudes::ran_init ( long  seed)

Initialize random generator.

Parameters
seedRandom generator seed

Definition at line 67 of file sp_random.cpp.

void faudes::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.

The sequence of planted states is separated one from the next by 8,367,782 calls to ran().

Definition at line 35 of file sp_random.cpp.

void faudes::ran_put_seed ( long  seed)

Put a seed.

Parameters
seedRandom generator seed

Definition at line 55 of file sp_random.cpp.

void faudes::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.

Definition at line 60 of file sp_random.cpp.

double faudes::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.

Parameters
aLower bound
bUpper bound
Returns
Random value

Definition at line 91 of file sp_random.cpp.

long faudes::ran_uniform_int ( long  a,
long  b 
)

Sample a discrete random variable uniformly on interval [a;b) Distribution: p(n) = 1/(b-a-1)

Parameters
aLower bound
bUpper bound
Returns
Random value

Definition at line 98 of file sp_random.cpp.

FAUDES_API 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
rLowGenLow level generator
rHighAlphHigh level alphabet
lowStateLow level state

Definition at line 76 of file cfl_localgen.cpp.

FAUDES_API 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
rLowGenLow level generator
rHighAlphHigh level alphabet
lowStateLow level state
rReachableEventsReference to EventSet which will contain the reachable high level events (result)

Definition at line 88 of file cfl_localgen.cpp.

FAUDES_API void faudes::ReachableStateMap ( const PushdownGenerator &  rPd,
std::map< Idx, StateSet > &  rMap 
)

Fill map.

For each state entered, which states are reachable (directly or transitively) with regard to the top n elements of the stacks.

Parameters
rPdreference to pushdown generator
nlookahead
rMapreference to resulting map
Returns

Definition at line 223 of file pd_alg_sub.cpp.

FAUDES_API std::set< std::string > faudes::ReadDirectory ( const std::string &  rDirectory)

Read the contents of the specified directors.

Parameters
rDirectoryDirectory eg "/home/friend/data"
Returns
List of files, e.g. "gen1.gen gen2.gen data subdir"

Definition at line 336 of file cfl_helper.cpp.

FAUDES_API PushdownGenerator faudes::RebuildFromSPDA ( const PushdownGenerator &  rSPDA,
const TransformationHistoryVec &  rTransformHistory 
)

Input must have passed SPDA() ! Rebuild a pushdown generator which passed SPDA as far as possible.

This mean, if a transition t of the original generator was split into two or more transitions t1...tn of the SPDA, this transition t only will be rebuild, iff t1...tn still exists. After rebuilding, inaccessible states will be removed.

Note: Between the call of SPDA() and RebuildFromSPDA() the indices of states and events as well as stack symbol names must not have be changed.

Parameters
rSPDAreference to the generator which passed SPDA
rTransformHistoryreference to vector of each transformation per iteration
Returns
pushdown generator

Definition at line 718 of file pd_alg_sub.cpp.

FAUDES_API 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)

Definition at line 715 of file diag_languagediagnosis.cpp.

FAUDES_API 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
rGeninput colored marking generator
rColorVectorset of colors of the generator (ordered!)
colorNumbernumber of colors currently removed
rOptimalColorscurrent optimal set of colors
rOptimalNumberStatescurrent optimal number of states
rOptimalNumberColorssize of the optimal color set
rHighAlphinitial high-level alphabet
rOptimalHighAlphoptimal high-level alphabet

Definition at line 289 of file mtc_redundantcolors.cpp.

FAUDES_API 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
rRevTransSetReversely ordered transition relation
rControllableEventsSet of controllable events
rHighAlphAbstraction alphabet
currentStateIndex of the start state of the backward reachability computation
rDoneStatesSet of already investigated states
Returns
True if the condition is fulfilled, false otherwise

Definition at line 387 of file op_observercomputation.cpp.

FAUDES_API 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
rGenGenerator for which the dynamic system is computed
rRevTransSetReversely ordered transition relation
rHighAlphAbstraction alphabet
currentStateIndex of the state to be checked
rDoneStatesSet of already investigated states
Returns
True if the condition is fulfilled, false otherwise

Definition at line 278 of file op_observercomputation.cpp.

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
rGenGenerator for which the dynamic system is computed
rHighAlphAbstraction alphabet
currentStateIndex of the state to be checked
rDoneStatesSet of already investigated states
Returns
True if the condition is fulfilled, false otherwise

Definition at line 252 of file op_observercomputation.cpp.

bool faudes::relabel ( Generator &  rGenRelabel,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
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
rGenRelabelGenerator whose transitions are modified
rControllableEventsSet of controllable events
rHighAlphAbstraction alphabet
rMapStateToPartitionMaps each state of rGenRelabel to an equivalence class
rMapChangedTransReverseMaps the relabeled transitions to the original transitions
rMapChangedTransMaps the the modified original transitions to its new events
rMapRelabeledEventsMaps the original events to the set of new events they were relabeled with
bool faudes::relabel ( Generator &  rGenRelabel,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
map< Idx, Idx > &  rMapStateToPartition,
map< Transition, Transition > &  rMapChangedTransReverse,
map< Transition, Idx > &  rMapChangedTrans,
map< Idx, EventSet > &  rMapRelabeledEvents 
)

Definition at line 1463 of file op_observercomputation.cpp.

FAUDES_API PushdownGenerator faudes::RemainingPd ( const Grammar &  rGr,
const PushdownGenerator &  pd 
)

Input must have passed SPDA() ! Compares the given pushdown generator with the given grammar and removes all transition, which cannot be find in productions of the grammar.

After that, inaccessible states will be removed.

Parameters
rGrreference to grammar
pdreference to generator
Returns
remaining generator

Definition at line 777 of file pd_alg_sub.cpp.

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

Delete a file.

Parameters
rFileNameName of file to delete

Definition at line 256 of file cfl_helper.cpp.

FAUDES_API PushdownGenerator faudes::RemoveLambdaPop ( const PushdownGenerator &  pd)

(previously called Rep0) Removes all transitions popping lambda.

Expect the generator to be deterministic

Note: By the new treatment of Transitions like (p,a,pop,push,q) with a != lambda and pop = push, there is no need to clear old init state and create a new init state which derived from pd.InitState()

Parameters
pdpushdown automaton
Returns
pushdown automaton without lambda popping edges

Definition at line 948 of file pd_alg_sub.cpp.

FAUDES_API PushdownGenerator faudes::RemoveMultPop ( const PushdownGenerator &  pd)

(previously called Rep2) Removes transitions popping more than one stack symbol.

Inserts new transitions instead that only pop one stack symbol.

Parameters
pdthe generator, which must NOT contain lambda pops
Returns
generator with altered transitions
Exceptions
Exceptionif a lambda pop transition exists

Definition at line 1563 of file pd_alg_sub.cpp.

void faudes::RemoveNonCoaccessibleOut ( Generator &  g)

Definition at line 576 of file cfl_conflequiv.cpp.

FAUDES_API PushdownGenerator faudes::RenameStackSymbold ( 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.

(previously called RenG)

Parameters
wordword with which the stack symbols will be annotated
pdreference to pushdown automaton to be annotated
Returns
copy of the parameter automaton with annotated states

Definition at line 36 of file pd_alg_sub.cpp.

std::string faudes::RewriteDotFile ( const std::string &  fileName)

Definition at line 16 of file pd_dotparser.cpp.

FAUDES_API 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
pdthe pushdown generator with ears
sthe system that was used in the intersection operation to generate the pushdown generator
Returns
pushdowngenerator without noncontrollable ears

Definition at line 433 of file pd_alg_main.cpp.

FAUDES_API Grammar faudes::Rnpp ( const Grammar &  gr)

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

e. those containing nonterminals that are not eliminable.

Parameters
grreference to grammar
Returns
grammar with only productive productions

Definition at line 1451 of file pd_alg_sub.cpp.

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

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

Parameters
grthe grammar
ntSetthe set of already eliminated nonterminals
Returns
eliminable symbols including the already eliminated ones

Definition at line 1409 of file pd_alg_sub.cpp.

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, assuming that a certain set of nonterminals has already been eliminated.

Parameters
grthe grammar
ntSetthe set of already eliminated nonterminals
Returns
eliminable symbols including the already eliminated ones

Definition at line 1436 of file pd_alg_sub.cpp.

FAUDES_API Grammar faudes::Rup ( const Grammar &  gr)

Remove all unreachable productions and nonterminals from the grammar.

Parameters
grgrammar with productions to be removed
Returns
grammar with only reachable productions

Definition at line 1500 of file pd_alg_sub.cpp.

void * faudes::SDeviceSynchro ( void *  arg)

Definition at line 772 of file iop_sdevice.cpp.

FAUDES_API 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
stateState, from which the current recursion is started.
rCountdenotes the current depth of the recursion.
rGenGenerator under investigation
rNewStatesSet of states that up to now were not found by the depth first search
rSTACKstack of state indices
rStackStatesset of states whose indices are on STACK.
rDFNmap assigning to each state its Depth-First Number
rLOWLINKmap assigning to each state its LOWLINK Number
rSccSetresult - the set of strongly connected components
rRoots,:result - the set of states that each are root of some SCC.

Definition at line 33 of file mtc_redundantcolors.cpp.

FAUDES_API 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
vStateState, from which the current recursion is started.
vRcountDenotes the current depth of the recursion.
rGenTransition system to investigate
rFilterFilter out specified transitions
rTodoSet of states that up to now were not found by the depth first search.
rStackStack of states to represent current path.
rStackStatesSet of states that are in rStack
rDfnMap assigning to each state idx its Depth-First Number.
rLowLnkMap assigning to each state its LOWLINK Number.
rSccListSet SCCs (accumulative result).
rRootsSet of states that each are root of some SCC (accumulative result).

Definition at line 228 of file cfl_graphfncts.cpp.

void faudes::SelectSubsystem_V1 ( GeneratorVector &  rGenVec,
Generator &  rResGen 
)

heuristic: vorious approaches to select subsystem from synthesis-buffer then compose them and remove them from buffer.

  1. determine subsystem
  2. parallel composition for subsystem
  3. delete subsystem from "GenVec"
Parameters
rGenVecsynthesis-buffer
rResGenthe composed new generator

Definition at line 1032 of file syn_compsyn.cpp.

void faudes::SelectSubsystem_V2 ( GeneratorVector &  rGenVec,
Generator &  rResGen 
)

Definition at line 1100 of file syn_compsyn.cpp.

FAUDES_API 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
rGen1First generator
rGen2Second generator
rCompositionMapComposition map (map< pair<Idx,Idx>, Idx>)
rGen12Reference to resulting parallel composition generator

Definition at line 658 of file cfl_parallel.cpp.

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

RTI convenience function.

Definition at line 4038 of file cfl_generator.cpp.

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

RTI convenience function.

Definition at line 4028 of file cfl_generator.cpp.

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

RTI convenience function.

Definition at line 4033 of file cfl_generator.cpp.

void faudes::SilentContinuationRule ( Generator &  g,
const EventSet &  silent 
)

Definition at line 425 of file cfl_conflequiv.cpp.

void faudes::SingleTransSpec ( const Generator &  rSpecGen,
const EventSet &  rUncAlph,
Generator &  rResGen 
)

Definition at line 604 of file syn_compsyn.cpp.

FAUDES_API Grammar faudes::Sp2Lr ( const PushdownGenerator &  rPd,
uint  n = 0,
bool  ignorReducible = false,
bool  debug = false 
)

Input must have passed SPDA() and Nda() ! Transform a simple pushdown generator into a context free grammar.

To reduce the number of to create productions, the generator will be trim (by calling PushdownGeneratorTrim )

Parameters
pdreference to pushdown generator
nthe lookahead for calling PushdownGeneratorTrim
ignorReducibleby set ignorReducible to false, only productions are generated which are coaccessible.
debugSet true, to print out single steps of the function
Returns
the grammar
Exceptions
Exceptionif a transition is neither read nor pop nor push transition

Definition at line 1046 of file pd_alg_sub.cpp.

FAUDES_API PushdownGenerator faudes::SPDA ( const PushdownGenerator &  pd,
TransformationHistoryVec *  pTransformHistory = NULL 
)

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

The parameter pTransformHistory is necessary to remember the transformations of each iteration. To rebuild the former generator see RebuildFromSPDA()

Note: To rebuild the former generator, the idx's of the states must not have been changed.

Parameters
pdthe generator, which to convert into SPDA
pTransformHistorypointer to vector to remember the transformations for each iteration By default no pointer is needed (NULL)
Returns
simple pushdown generator

Definition at line 426 of file pd_alg_sub.cpp.

FAUDES_API std::vector< std::string > faudes::split ( const std::string &  rStr,
const std::string &  rSep,
const std::string &  rFilename,
const int  lineNr 
)

Definition at line 157 of file pd_dotparser.cpp.

FAUDES_API 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
pdpushdown generator to be split
Returns
the split pushdown generator

Definition at line 674 of file pd_alg_main.cpp.

void faudes::Splitter ( const std::map< Idx, std::vector< Idx > > &  rMapOldToNew,
EventSet &  rConAlph,
GeneratorVector &  rGenVec,
std::map< Idx, Idx > &  rMapEventsToPlant,
GeneratorVector &  rDisGenVec,
GeneratorVector &  rSupGenVec 
)

update the generators in synthesis-buffer and in supervisor with new events

Parameters
rMapOldToNewmap the replaced events to new events
rConAlphcontrollable events
rGenVecsynthesis-buffer
rMapEventsToPlantmap the events in supervisor to plant
rDisGenVecdistinguisher generator-vector
rSupGenVecsupervisor generator-vector

Definition at line 898 of file syn_compsyn.cpp.

void faudes::SplittGen ( Generator &  rGen,
Idx  parent,
const std::vector< Idx > &  kids 
)

subfunction for Splitter: splitt the events in a generator

Parameters
rGena generator
parentprimal event
kidsnew events

Definition at line 856 of file syn_compsyn.cpp.

FAUDES_API void faudes::StateMin ( const 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
rGenGenerator
rResGenMinimized generator (result)
rSubsetsVector of subsets that will be constructed during running the algorithm (optional parameter)
rNewIndicesVector of new state indices corresponding to the subsets (optional parameter)
Exceptions
ExceptionInput automaton nondeterministic (id 101)

Definition at line 620 of file cfl_statemin.cpp.

void faudes::StateMin_org ( const Generator &  rGen,
Generator &  rResGen,
std::vector< StateSet > &  rSubsets,
std::vector< Idx > &  rNewIndices 
)

Definition at line 375 of file cfl_statemin.cpp.

FAUDES_API std::string faudes::StringSubstitute ( const std::string &  rString,
const std::string &  rFrom,
const std::string &  rTo 
)

Substitute in string.

Parameters
rStringSource string to substitute
rFromString to match
rToReplacement to fill in
Returns
Result string

Definition at line 111 of file cfl_helper.cpp.

FAUDES_API 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
rPlantGenPlant Generator
rCAlphControllable events
rSpecGenSpecification Generator
rReverseCompositionMapstd::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function
rResGenReference to resulting Generator, the minimal restrictive supervisor
Exceptions
Exception
  • alphabets of generators don't match (id 100)
  • plant nondeterministic (id 201)
  • spec nondeterministic (id 203)
  • plant and spec nondeterministic (id 204)

Definition at line 793 of file syn_supcon.cpp.

FAUDES_API 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
rPlantGenPlant generator
rCAlphControllable events
rSupCandGenSupervisor candidate generator

Definition at line 57 of file syn_supcon.cpp.

FAUDES_API 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
rPlantGenPlant Generator
rCAlphControllable events
rSpecGenSpecification Generator
rReverseCompositionMapstd::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function
rResGenReference 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)

Definition at line 586 of file syn_supcon.cpp.

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

rti wrapper

Definition at line 693 of file syn_supnorm.cpp.

FAUDES_API 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
rPlantGenPlant generator G
rCAlphControllable events
rOAlphObservable events
rObserverGenObserver H_obs
rSupCandGenClosed-loop candidate H

Definition at line 489 of file syn_supnorm.cpp.

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

rti wrapper

Definition at line 715 of file syn_supnorm.cpp.

FAUDES_API 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
rPlantGenPlant Generator
rCAlphUncontrollable Events
rSpecGenSpecification Generator
rReverseCompositionMapstd::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function
rResGenReference to resulting Generator, the less restrictive supervisor

Definition at line 386 of file syn_supcon.cpp.

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

rti wrapper

Definition at line 648 of file syn_supnorm.cpp.

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

rti wrapper

Definition at line 670 of file syn_supnorm.cpp.

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

Definition at line 32 of file hio_functions.cpp.

FAUDES_API 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
rKmarks the (not necessarily closed) language K=Lm(rK)
rResultgenerates and marks the supremal closed sublanguage, where L(rResult)=Lm(rResult)
Returns
true for nonempty result
Exceptions
Exception
  • todo: check determinism of rK

Definition at line 428 of file syn_supnorm.cpp.

FAUDES_API 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
rPlantGenPlant G
rSpecGenSpecification Generator E
rResGenReference to resulting Generator,

Definition at line 292 of file syn_functions.cpp.

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 86 of file lbp_function.cpp.

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

Definition at line 117 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.

FAUDES_API System faudes::SystemFromDot ( const std::string &  filename)

Parse a System (TcGenerator) from given dot-file.

For this, a temporary file will be created which annotates empty pop and push operations to each transition and a default stack bottom. The temporary file will be parsed by TpdGenerator::DotRead().

Parameters
filenamefile to parse
Returns
system from given file

Definition at line 116 of file pd_dotparser.cpp.

void faudes::TestAc ( )

all Ac tests

Definition at line 682 of file pd_alg_main_test.cpp.

void faudes::TestAcAccessible ( )

Test if Ac makes the test generator accessible.

Definition at line 586 of file pd_alg_main_test.cpp.

void faudes::TestAnnotatePdStates ( )

All AnnotatePdStates Tests.

Definition at line 567 of file pd_alg_sub_test.cpp.

void faudes::TestAug ( )

All Aug Tests.

Definition at line 1030 of file pd_alg_lrm_test.cpp.

void faudes::TestAugSuccess ( )

Augment a grammar which should result in a successful augmentation.

Definition at line 907 of file pd_alg_lrm_test.cpp.

void faudes::TestDesc ( )

All Desc Tests.

Includes Testing Desc1 since Desc1 is just an iterator.

Definition at line 984 of file pd_alg_lrm_test.cpp.

void faudes::TestDesc11 ( )

All Desc11 Tests.

Definition at line 976 of file pd_alg_lrm_test.cpp.

void faudes::TestDesc11Nonterminal ( )

Test Desc11 with a nonterminal at the beginning of afterDot.

Definition at line 68 of file pd_alg_lrm_test.cpp.

void faudes::TestDesc11Terminal ( )

Test Desc11 with a terminal at the beginning of afterDot.

Definition at line 16 of file pd_alg_lrm_test.cpp.

void faudes::TestDescInitial ( )

All DescInitial Tests.

Definition at line 1015 of file pd_alg_lrm_test.cpp.

void faudes::TestDescInitialFindTwo ( )

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

Definition at line 762 of file pd_alg_lrm_test.cpp.

void faudes::TestDescSelectedConfigs ( )

Test Desc with some configurations.

Definition at line 157 of file pd_alg_lrm_test.cpp.

void faudes::TestDim ( )

All Dim Tests.

Definition at line 1087 of file pd_alg_lrp_test.cpp.

void faudes::TestDimNewFinalStates ( )

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

Definition at line 975 of file pd_alg_lrp_test.cpp.

void faudes::TestDimNoAugment ( )

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

Definition at line 895 of file pd_alg_lrp_test.cpp.

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

write to console to indicate end of test

Parameters
namename of the test

Definition at line 2139 of file pd_test_util.cpp.

void faudes::TestFds ( )

All Fds tests.

Definition at line 1087 of file pd_alg_first_test.cpp.

void faudes::TestFdsWords ( )

Test if Fds returns all expected words.

Definition at line 106 of file pd_alg_first_test.cpp.

void faudes::TestFilter ( )

All Filter tests.

Definition at line 1388 of file pd_alg_sub_test.cpp.

void faudes::TestFilter1 ( )

All Filter1 tests.

Definition at line 1124 of file pd_alg_first_test.cpp.

void faudes::TestFilter1MixedGrammarSymbols ( )

Filter a nonterminal from a vector of terminals and nonterminals.

Definition at line 715 of file pd_alg_first_test.cpp.

void faudes::TestFilter1Nothing ( )

filter from an empty word

Definition at line 762 of file pd_alg_first_test.cpp.

void faudes::TestFilterMixedGrammarSymbols ( )

Filter a nonterminal from a vector of terminals and nonterminals.

Definition at line 616 of file pd_alg_sub_test.cpp.

void faudes::TestFilterNothing ( )

filter from an empty word

Definition at line 672 of file pd_alg_sub_test.cpp.

void faudes::TestFirst ( )

All First tests.

Definition at line 1108 of file pd_alg_first_test.cpp.

void faudes::TestFirstA ( )

All FirstA tests.

Definition at line 1094 of file pd_alg_first_test.cpp.

void faudes::TestFirstAll ( )

All FirstAll tests.

Definition at line 1132 of file pd_alg_first_test.cpp.

void faudes::TestFirstAllNonterminalsIrreducible ( )

Test with Nonterminals and an irreducible word as input.

void faudes::TestFirstAllNonterminalsIrreducibleWord ( )

Definition at line 831 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 868 of file pd_alg_first_test.cpp.

void faudes::TestFirstAllTerminalsOnly ( )

Test with only Terminals as input.

Definition at line 789 of file pd_alg_first_test.cpp.

void faudes::TestFirstASelectedWords ( )

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

Definition at line 410 of file pd_alg_first_test.cpp.

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.

Definition at line 1101 of file pd_alg_first_test.cpp.

void faudes::TestFirstLeq1 ( )

All FirstLeq1 tests.

Definition at line 1141 of file pd_alg_first_test.cpp.

void faudes::TestFirstLeq1OneNonempty ( )

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

Definition at line 999 of file pd_alg_first_test.cpp.

void faudes::TestFirstLeq1TwoNonempty ( )

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

Definition at line 1044 of file pd_alg_first_test.cpp.

void faudes::TestFirstLeq1ZeroEmpty ( )

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

Definition at line 918 of file pd_alg_first_test.cpp.

void faudes::TestFirstLeq1ZeroNonempty ( )

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

Definition at line 954 of file pd_alg_first_test.cpp.

void faudes::TestFirstLMap ( )

Test if the mapping function produced by FirstL is correct.

Definition at line 204 of file pd_alg_first_test.cpp.

void faudes::TestFirstRed ( )

All FirstRed tests.

Definition at line 1116 of file pd_alg_first_test.cpp.

void faudes::TestFirstRedConsistentWord ( )

Test FirstRed with a consistent word as input.

Definition at line 621 of file pd_alg_first_test.cpp.

void faudes::TestFirstRedInconsistentWord ( )

Test FirstRed with an inconsistent word as input.

Definition at line 673 of file pd_alg_first_test.cpp.

void faudes::TestFirstSelectedWords ( )

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

Definition at line 513 of file pd_alg_first_test.cpp.

PushdownGenerator faudes::TestGenerator1 ( )

build a test generator

Returns
the populated test generator

Definition at line 17 of file pd_test_util.cpp.

PushdownGenerator faudes::TestGenerator10 ( )

Definition at line 468 of file pd_test_util.cpp.

PushdownGenerator faudes::TestGenerator11 ( )

Definition at line 532 of file pd_test_util.cpp.

PushdownGenerator faudes::TestGenerator12 ( )

Definition at line 592 of file pd_test_util.cpp.

PushdownGenerator faudes::TestGenerator13 ( )

Definition at line 634 of file pd_test_util.cpp.

PushdownGenerator faudes::TestGenerator14 ( )

Definition at line 680 of file pd_test_util.cpp.

PushdownGenerator faudes::TestGenerator15 ( )

Definition at line 738 of file pd_test_util.cpp.

PushdownGenerator faudes::TestGenerator16 ( )

Definition at line 777 of file pd_test_util.cpp.

PushdownGenerator faudes::TestGenerator17 ( )

Definition at line 818 of file pd_test_util.cpp.

PushdownGenerator faudes::TestGenerator18 ( )

Definition at line 860 of file pd_test_util.cpp.

PushdownGenerator faudes::TestGenerator19 ( )

Definition at line 899 of file pd_test_util.cpp.

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

Definition at line 71 of file pd_test_util.cpp.

PushdownGenerator faudes::TestGenerator20 ( )

Definition at line 940 of file pd_test_util.cpp.

PushdownGenerator faudes::TestGenerator21 ( )

Definition at line 985 of file pd_test_util.cpp.

PushdownGenerator faudes::TestGenerator22 ( )

Definition at line 1033 of file pd_test_util.cpp.

PushdownGenerator faudes::TestGenerator23 ( )

Definition at line 1071 of file pd_test_util.cpp.

PushdownGenerator faudes::TestGenerator24 ( )

Definition at line 1119 of file pd_test_util.cpp.

PushdownGenerator faudes::TestGenerator25 ( )

Definition at line 1196 of file pd_test_util.cpp.

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>

Definition at line 113 of file pd_test_util.cpp.

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>

Definition at line 156 of file pd_test_util.cpp.

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>

Definition at line 202 of file pd_test_util.cpp.

PushdownGenerator faudes::TestGenerator6 ( )

Definition at line 282 of file pd_test_util.cpp.

PushdownGenerator faudes::TestGenerator7 ( )

Definition at line 328 of file pd_test_util.cpp.

PushdownGenerator faudes::TestGenerator8 ( )

Definition at line 371 of file pd_test_util.cpp.

PushdownGenerator faudes::TestGenerator9 ( )

Definition at line 407 of file pd_test_util.cpp.

void faudes::TestGeneratorGoto ( )

All GeneratorGoto Tests.

Definition at line 1040 of file pd_alg_lrp_test.cpp.

void faudes::TestGeneratorGotoNoSuccessor ( )

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

Definition at line 96 of file pd_alg_lrp_test.cpp.

void faudes::TestGeneratorGotoOneSuccessor ( )

Test if GeneratorGoto finds the right successor.

Definition at line 17 of file pd_alg_lrp_test.cpp.

void faudes::TestGeneratorGotoSeq ( )

All GeneratorGotoSeq Tests.

Definition at line 1048 of file pd_alg_lrp_test.cpp.

void faudes::TestGeneratorGotoSeqFull ( )

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

Definition at line 181 of file pd_alg_lrp_test.cpp.

void faudes::TestGeneratorGotoSeqPartial ( )

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

Definition at line 268 of file pd_alg_lrp_test.cpp.

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

Definition at line 1378 of file pd_test_util.cpp.

Grammar faudes::TestGrammar10 ( )

Definition at line 2031 of file pd_test_util.cpp.

Grammar faudes::TestGrammar11 ( )

Definition at line 2085 of file pd_test_util.cpp.

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

Definition at line 1453 of file pd_test_util.cpp.

Grammar faudes::TestGrammar3 ( )

Definition at line 1522 of file pd_test_util.cpp.

Grammar faudes::TestGrammar4 ( )

Definition at line 1608 of file pd_test_util.cpp.

Grammar faudes::TestGrammar5 ( )

Definition at line 1668 of file pd_test_util.cpp.

Grammar faudes::TestGrammar6 ( )

Definition at line 1747 of file pd_test_util.cpp.

Grammar faudes::TestGrammar7 ( )

Definition at line 1810 of file pd_test_util.cpp.

Grammar faudes::TestGrammar8 ( )

Definition at line 1873 of file pd_test_util.cpp.

Grammar faudes::TestGrammar9 ( )

Definition at line 1984 of file pd_test_util.cpp.

void faudes::TestIntersectEvents ( )

all IntersectEvents tests

Definition at line 665 of file pd_alg_main_test.cpp.

void faudes::TestIntersectEventsAll ( )

test for intersect events

Definition at line 98 of file pd_alg_main_test.cpp.

void faudes::TestLrm ( )

All Lrm Tests.

Definition at line 1022 of file pd_alg_lrm_test.cpp.

void faudes::TestLrm1 ( )

All Lrm1 Tests.

Definition at line 1000 of file pd_alg_lrm_test.cpp.

void faudes::TestLrm1FindOne ( )

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

Definition at line 493 of file pd_alg_lrm_test.cpp.

void faudes::TestLrm1FindThree ( )

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

Definition at line 602 of file pd_alg_lrm_test.cpp.

void faudes::TestLrmGr1 ( )

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

Definition at line 834 of file pd_alg_lrm_test.cpp.

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

Definition at line 866 of file pd_alg_lrm_test.cpp.

void faudes::TestLrmLoop ( )

All LrmLoop Tests.

Definition at line 1008 of file pd_alg_lrm_test.cpp.

void faudes::TestLrmLoopAnB ( )

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

Definition at line 693 of file pd_alg_lrm_test.cpp.

void faudes::TestLrp ( )

All Lrp Tests.

Definition at line 1070 of file pd_alg_lrp_test.cpp.

void faudes::TestLrpActions ( )

Test if Lrp generates a parser with the correct rules.

Definition at line 491 of file pd_alg_lrp_test.cpp.

void faudes::TestLrParser2EPDA ( )

All LrParser2EPDA Tests.

Definition at line 1078 of file pd_alg_lrp_test.cpp.

void faudes::TestLrParser2EPDAStates ( )

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

Definition at line 638 of file pd_alg_lrp_test.cpp.

void faudes::TestLrParser2EPDATransitions ( )

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

Definition at line 737 of file pd_alg_lrp_test.cpp.

void faudes::TestLrpNonterminalsTerminals ( )

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

Definition at line 573 of file pd_alg_lrp_test.cpp.

void faudes::TestLrpReduceRules ( )

All LrpReduceRules Tests.

Definition at line 1063 of file pd_alg_lrp_test.cpp.

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.

Definition at line 429 of file pd_alg_lrp_test.cpp.

void faudes::TestLrpShiftRules ( )

All LrpShiftRules Tests.

Definition at line 1056 of file pd_alg_lrp_test.cpp.

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.

Definition at line 354 of file pd_alg_lrp_test.cpp.

void faudes::TestNda ( )

All Nda tests.

Definition at line 607 of file pd_alg_sub_test.cpp.

void faudes::TestNdaActivePassive ( )

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

Definition at line 468 of file pd_alg_sub_test.cpp.

void faudes::TestNdaTransitions ( )

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

Definition at line 521 of file pd_alg_sub_test.cpp.

void faudes::TestPassesX ( )

All PassesX Tests.

Definition at line 991 of file pd_alg_lrm_test.cpp.

void faudes::TestPassesXNonterminal ( )

Test PassesX by shifting the dot over a nonterminal.

Definition at line 295 of file pd_alg_lrm_test.cpp.

void faudes::TestPassesXNoShift ( )

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

Definition at line 420 of file pd_alg_lrm_test.cpp.

void faudes::TestPassesXTerminal ( )

Test PassesX by shifting the dot over a terminal.

Definition at line 360 of file pd_alg_lrm_test.cpp.

void faudes::TestPostCl ( )

All PostCl tests.

Definition at line 1080 of file pd_alg_first_test.cpp.

void faudes::TestPostClPostfixes ( )

Test all postfixes of a given word.

Definition at line 17 of file pd_alg_first_test.cpp.

FAUDES_API 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
rSourceSource file to protocol
Returns
Filename with nominal protocol.

Definition at line 505 of file cfl_helper.cpp.

FAUDES_API 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
rMessageInformal identifyer of the test
rDataFormal result of the test case
coreWhether to record full token io or statistics only.

Definition at line 530 of file cfl_helper.cpp.

FAUDES_API 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
rMessageInformal identifyer of the test
dataTest data

Definition at line 540 of file cfl_helper.cpp.

FAUDES_API 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
rMessageInformal identifyer of the test
dataTest data

Definition at line 544 of file cfl_helper.cpp.

FAUDES_API 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
rMessageInformal identifyer of the test
dataTest data

Definition at line 548 of file cfl_helper.cpp.

FAUDES_API 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

Definition at line 554 of file cfl_helper.cpp.

void faudes::TestRemoveLambdaPop ( )

All RemoveLambdaPop tests.

Definition at line 584 of file pd_alg_sub_test.cpp.

void faudes::TestRemoveLambdaPopAllExpectingTransition ( )

Definition at line 245 of file pd_alg_sub_test.cpp.

void faudes::TestRemoveLambdaPopNoLambdaPop ( )

Definition at line 212 of file pd_alg_sub_test.cpp.

void faudes::TestRemoveMulPopNumberOfStatesTransitions ( )

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

Definition at line 329 of file pd_alg_sub_test.cpp.

void faudes::TestRemoveMultPop ( )

All RemoveMultPop tests.

Definition at line 600 of file pd_alg_sub_test.cpp.

void faudes::TestRenameStackSymbols ( )

All RenG tests.

Definition at line 575 of file pd_alg_sub_test.cpp.

void faudes::TestRenameStackSymbolsNumberOfStackSymbols ( )

Test if the number of stack symbols did not change.

Definition at line 122 of file pd_alg_sub_test.cpp.

void faudes::TestRenameStackSymbolsRenamingStackSymbols ( )

Test if all stack symbols were renamed correctly.

Definition at line 73 of file pd_alg_sub_test.cpp.

void faudes::TestRenameStackSymbolsRenamingTransitions ( )

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

Definition at line 146 of file pd_alg_sub_test.cpp.

void faudes::TestRenameStatesNumberOfStates ( )

Test if the number of states did not change.

Definition at line 49 of file pd_alg_sub_test.cpp.

void faudes::TestRenameStatesRenaming ( )

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

Definition at line 17 of file pd_alg_sub_test.cpp.

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::TestRnce ( )

All Rnce tests.

Definition at line 646 of file pd_alg_main_test.cpp.

void faudes::TestRnceRemoveEars ( )

Test if uncontrollable ears are correctly removed.

Definition at line 66 of file pd_alg_main_test.cpp.

void faudes::TestRnpp ( )

All Rnpp tests.

Definition at line 1413 of file pd_alg_sub_test.cpp.

void faudes::TestRnpp1 ( )

All Rnpp1 tests.

Definition at line 1396 of file pd_alg_sub_test.cpp.

void faudes::TestRnpp1FindSymbolsEmptySet ( )

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

Definition at line 698 of file pd_alg_sub_test.cpp.

void faudes::TestRnpp1FindSymbolsNonemptySet ( )

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

Definition at line 742 of file pd_alg_sub_test.cpp.

void faudes::TestRnppEmptyGrammar ( )

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

Definition at line 1074 of file pd_alg_sub_test.cpp.

void faudes::TestRnppGrammar1 ( )

Remove all noneliminable nonterminals and all productions containing noneliminable nonterminals.

Definition at line 929 of file pd_alg_sub_test.cpp.

void faudes::TestRnppGrammar2 ( )

Remove all noneliminable nonterminals and all productions containing noneliminable nonterminals.

Definition at line 1000 of file pd_alg_sub_test.cpp.

void faudes::TestRnppl ( )

All Rnppl tests.

Definition at line 1404 of file pd_alg_sub_test.cpp.

void faudes::TestRnpplFindSymbolsCompleteSet ( )

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

Definition at line 883 of file pd_alg_sub_test.cpp.

void faudes::TestRnpplFindSymbolsEmptySet ( )

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

Definition at line 787 of file pd_alg_sub_test.cpp.

void faudes::TestRnpplFindSymbolsNonemptySet ( )

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

Definition at line 833 of file pd_alg_sub_test.cpp.

void faudes::TestRup ( )

All Rup tests.

Definition at line 1433 of file pd_alg_sub_test.cpp.

void faudes::TestRupNonterminals ( )

Definition at line 1352 of file pd_alg_sub_test.cpp.

void faudes::TestRupProductions ( )

Definition at line 1307 of file pd_alg_sub_test.cpp.

void faudes::TestSp2Lr ( )

All Sp2Lr tests.

Definition at line 1422 of file pd_alg_sub_test.cpp.

void faudes::TestSp2LrNonterminals ( )

Test if all possible nonterminals were generated.

Definition at line 1140 of file pd_alg_sub_test.cpp.

void faudes::TestSp2LrProductions ( )

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

Definition at line 1175 of file pd_alg_sub_test.cpp.

void faudes::TestSp2LrTerminals ( )

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

Definition at line 1105 of file pd_alg_sub_test.cpp.

void faudes::TestSPDA ( )

All SPDA tests.

Definition at line 592 of file pd_alg_sub_test.cpp.

void faudes::TestSPDANumberStatesTransitions ( )

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

Definition at line 367 of file pd_alg_sub_test.cpp.

void faudes::TestSPDAReadPopPushOnly ( )

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

Definition at line 405 of file pd_alg_sub_test.cpp.

void faudes::TestSplit ( )

all Split tests

Definition at line 672 of file pd_alg_main_test.cpp.

void faudes::TestSplitStackSymbols ( )

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

Definition at line 353 of file pd_alg_main_test.cpp.

void faudes::TestSplitStates ( )

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

Definition at line 388 of file pd_alg_main_test.cpp.

void faudes::TestSplitTransitionsEarToHead ( )

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

Definition at line 526 of file pd_alg_main_test.cpp.

void faudes::TestSplitTransitionsHeadToEar ( )

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

Definition at line 466 of file pd_alg_main_test.cpp.

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

write to console to indicate start of test

Parameters
namename of the test

Definition at line 2135 of file pd_test_util.cpp.

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

Definition at line 1251 of file pd_test_util.cpp.

System faudes::TestSystem2 ( )

Definition at line 1278 of file pd_test_util.cpp.

System faudes::TestSystem3 ( )

Definition at line 1302 of file pd_test_util.cpp.

System faudes::TestSystem4 ( )

Definition at line 1323 of file pd_test_util.cpp.

System faudes::TestSystem5 ( )

Definition at line 1347 of file pd_test_util.cpp.

void faudes::TestTimes ( )

all Times tests

Definition at line 654 of file pd_alg_main_test.cpp.

void faudes::TestTimesStackSymbols ( )

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

Definition at line 247 of file pd_alg_main_test.cpp.

void faudes::TestTimesStates ( )

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

Definition at line 173 of file pd_alg_main_test.cpp.

void faudes::TestTimesTransitions ( )

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

Definition at line 291 of file pd_alg_main_test.cpp.

void faudes::TestTransient ( )

All Transient tests.

Definition at line 637 of file pd_alg_main_test.cpp.

void faudes::TestTransientStates ( )

Test if Transient chooses the right states.

Definition at line 16 of file pd_alg_main_test.cpp.

void faudes::TestTransientStatesEmpty ( )

Test if Transient chooses the right states.

Definition at line 41 of file pd_alg_main_test.cpp.

void faudes::TestTsUnreachable ( )

Test Te with transitions that are unreachable.

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

synchronous product generator of a pushdown generator and a regular generator

Parameters
regthe regualar generator
pdthe pushdown generator
Returns
the synchronous product

Definition at line 495 of file pd_alg_main.cpp.

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
resultthe time difference is stored here
xthe time x
ythe time y
Returns
1 if x - y is negative, else 0

Definition at line 835 of file pd_alg_main.cpp.

void faudes::ToFile ( const PushdownGenerator &  pd,
std::string  name,
bool  printDOT = true,
bool  printPNG = true 
)

Print pushdown generator to file, if the number of transitions does not exceed PD_DEBUG_MAX_TRANS.

The file will be annoutated with pd.XXXXX.name where XXXX stands for an unique number for each file.

Parameters
pdreference to pushdown generator to be printed
namename of file
printDOTtrue, if DOT-file should be print
printPNGtrue, if PNG Image should be print
Returns

Definition at line 36 of file pd_debug.cpp.

void faudes::ToFile ( const std::string &  tex,
std::string  name 
)

Print given text to file.

The file will be annoutated with pd.XXXXX.name where XXXX stands for an unique number for each file.

Parameters
pdreference to pushdown generator to be print
namename of file

Definition at line 63 of file pd_debug.cpp.

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

Convert a string to Idx.

Parameters
rStringstring to convert
Returns
Idx
Exceptions
Idxoverflow (id 600)

Definition at line 100 of file cfl_helper.cpp.

FAUDES_API std::string faudes::ToStringFloat ( Float  number)

float to string

Parameters
numberdouble
Returns
string

Definition at line 64 of file cfl_helper.cpp.

FAUDES_API std::string faudes::ToStringInteger ( Int  number)

integer to string

Parameters
numberinteger
Returns
string

Definition at line 43 of file cfl_helper.cpp.

FAUDES_API std::string faudes::ToStringInteger16 ( Int  number)

integer to string base 16

Parameters
numberinteger
Returns
string

Definition at line 54 of file cfl_helper.cpp.

FAUDES_API Lr1Parser faudes::TransformParserAction ( const Lr1Parser &  rParser)

Transform action of Lr(1)-parser as follows actions of the form (q,a,p,a) to ((q,lambda),a,(p,a),lambda), ((q,a),lambda,(p,a),lambda) actions of the form (q,a,p,lambda) to ((q,lambda),a,(p,lambda),lambda) , ((q,a),lambda,(p,lambda),lambda)

Parameters
rParserreference to Lr(1)-parser
Returns
Lr(1)-parser with transformed actions

Definition at line 471 of file pd_alg_lrp.cpp.

FAUDES_API StateSet faudes::Transient ( const PushdownGenerator &  pd)

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

Parameters
pdthe generator
Returns
the states

Definition at line 414 of file pd_alg_main.cpp.

FAUDES_API std::string faudes::TransitionMapToStr ( const LrmTransitionMap &  transitionMap)

To string function for a transition map.

Parameters
transitionMapthe transition map to turn into a string
Returns
the transition map as a string

Definition at line 149 of file pd_parser.cpp.

void faudes::TransSpec ( const GeneratorVector &  rSpecGenVec,
const EventSet &  rGUncAlph,
GeneratorVector &  rResGenVec 
)

translate specification into plant

Parameters
rSpecGenVecspecification generator-vector
rGUncAlphglobal uncontrollable events
rResGenVecsynthesis-buffer

Definition at line 649 of file syn_compsyn.cpp.

FAUDES_API 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
rCAlphSet of controllable events
rtransrelReverse sorted transition relation
rCriticalStatesSet of critical states in composition generator
currentCurrent state

Definition at line 847 of file syn_supcon.cpp.

FAUDES_API 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
rGdInput generator G_d which will be prunded.
rGobsGenerator G_o (containing failure label information).
rFailureTypeFailure type index.
rIndicatorEventsSet of indicator events.
rReverseCompositionMapMapping 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.

FAUDES_API 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
rGdInput generator G_d which will be pruned.
rGobsGenerator G_o (containing failure label information).
rFailureTypeFailure type index.
rIndicatorEventsSet of indicator events.
rCompositionMapInverted mapping of G_d states with G_o states.
stateCurrent state.
rStatesDoneStates 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.

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

Determine the descendants of the initial parser configurations.

Parameters
grthe grammar
ka 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

Definition at line 317 of file pd_alg_lrm.cpp.

FAUDES_API std::string faudes::VersionString ( )

Return FAUDES_VERSION as std::string.

Returns
std::string with FAUDES_VERSION

Definition at line 131 of file cfl_helper.cpp.

FAUDES_API void faudes::WriteMap ( GrammarSymbolWordMap  f,
bool  changed = false 
)

Convenience print function for first map function.

Parameters
fmap function to print
changedindicator if changes were made, defaults to false

Definition at line 420 of file pd_alg_first.cpp.

bool faudes::YclessScc ( const Generator &  rGen,
const EventSet &  rYc,
std::set< StateSet > &  rSccSet 
)

Definition at line 1803 of file hio_functions.cpp.

Variable Documentation

int faudes::fileCounter = 0

Definition at line 15 of file pd_debug.cpp.

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

Definition at line 617 of file cfl_helper.cpp.

AutoRegisterType< TaNameSet<AttributeSignalEvent> > faudes::gRti1RegisterSignalDeviceEventSet("SignalDeviceEventSet")
AutoRegisterXElementTag< TaNameSet<AttributeSignalEvent> > faudes::gRti1XElementTagSignalDeviceEventSet("SignalDeviceEventSet","Event")
volatile AutoRegisterType<xDevice> faudes::gRtiRegisterDeviceContainer("DeviceContainer")
static
AutoRegisterType<nDevice> faudes::gRtiRegisterSimplenetDevice("SimplenetDevice")
AutoRegisterType<mbDevice> faudes::gRtiRegisterSpiDevice("ModbusDevice")
std::string faudes::gTestProtocolFr

Definition at line 502 of file cfl_helper.cpp.

TokenWriter* faudes::gTestProtocolTw = NULL

Definition at line 501 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 31 of file sp_random.cpp.

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

Definition at line 29 of file sp_random.cpp.

int faudes::ran_stream = 0
static

Definition at line 30 of file sp_random.cpp.

libFAUDES 2.28c --- 2016.09.30 --- c++ api documentaion by doxygen