|
faudes Namespace Reference
libFAUDES resides within the namespace faudes.
More...
Classes |
class | TaBaseSet |
| Set with nontrivial attributes. More...
|
class | TaGenerator |
| Generator with specified attribute types. More...
|
class | AttributeVoid |
| Minimal Attribute. More...
|
class | AttributeFlags |
| Boolean flags Attribute. More...
|
class | TBaseSet |
| STL style set template. More...
|
class | vBaseVector |
| Vector bass class. More...
|
class | TBaseVector |
| Vector template. More...
|
class | AttributeCFlags |
| Attribute class to model event controllability properties. More...
|
class | TcGenerator |
| Compatibility: pre 2.20b used cEventSet as C++ class name. More...
|
class | Integer |
| Elementary type. More...
|
class | String |
| Elementary type. More...
|
class | Boolean |
| Elementary type. More...
|
class | Exception |
| Faudes exception class. More...
|
class | Parameter |
| Structure to model a parameter type within the Signature of a Function. More...
|
class | Signature |
| Signature of a Function. More...
|
class | FunctionDefinition |
| A FunctionDefinition defines the interface to a faudes-function. More...
|
class | Function |
| A faudes-function hosts parameter values of some faudes type and provides a method to perform an operation on the specified paramters, e.g. More...
|
class | vGenerator |
| Base class of all FAUDES generators. More...
|
class | SccFilter |
| Filter for strictly connected components (SCC) search/compute routines. More...
|
class | ConsoleOut |
| Console Out. More...
|
class | ObjectCount |
| Debugging counter. More...
|
class | IndexSet |
| Set of indices. More...
|
class | TaIndexSet |
| Set of indices with attributes. More...
|
class | NameSet |
| Set of indices with symbolic names. More...
|
class | TaNameSet |
| Set of indices with symbolic names and attributes. More...
|
class | OPState |
class | ProductCompositionMap |
| Rti-wrapper for composition maps. More...
|
struct | TGraph |
| A graph is modelled as a map from vertex-labels to nodes. More...
|
struct | TNode |
| A node represents the edges related to one individual vertex. More...
|
struct | node_entry_t |
| A node-entry represents one edge. More...
|
struct | graph_iterator_t |
| An iterators over the map of all nodes is interpreted as a state incl. More...
|
struct | node_iterator_t |
| An iterator over the set of edges related to one vertex is interpreted as a transition. More...
|
struct | TGraph< Idx, Idx > |
| Specialisation of the graph template to provide convenience methods addressing the intended ussage. More...
|
class | TypeRegistry |
| The TypeRegistry registers faudes-types. More...
|
class | AutoRegisterType |
| Auto register faudes-type with specified type name. More...
|
class | AutoRegisterXElementTag |
class | FunctionRegistry |
| The FunctionRegistry registers faudes-functions. More...
|
class | SymbolSet |
| Set of symbols. More...
|
class | SymbolTable |
| A SymbolTable associates sybolic names with indices. More...
|
class | Token |
| Tokens model atomic data for stream IO. More...
|
class | TokenReader |
| A TokenReader reads sequential tokens from a file or string. More...
|
class | TokenWriter |
| A TokenWriter writes sequential tokens to a file, a string or stdout. More...
|
class | Transition |
| Triple (X1,Ev,X2) to represent current state, event and next state. More...
|
class | TransSort |
| Alternative ordering of Transitions. More...
|
class | TTransSet |
| Set of Transitions. More...
|
class | TaTransSet |
| Set of Transitions with attributes. More...
|
class | Type |
| Base class of all libFAUDES objects that participate in the run-time interface. More...
|
class | Documentation |
| faudes type implementation macros, overall, debug version More...
|
class | TypeDefinition |
| A TypeDefinition defines a faudes-type in that it specifies a faudes-type name to identify the type and a method NewObject() to instantiate objects of the respective type. More...
|
class | SNOState |
struct | ReductionStateInfo |
| Data structure for identifying states in the same coset for supervisor reduction. More...
|
class | MCtrlPattern |
class | OPSState |
class | Bisimulation |
| This class implements the algorithms needed for the computation of the coarsest quasi-congruence (=Bisimulation) of a given generator. More...
|
class | EventRelabelMap |
| Rti convenience wrapper for relabeling maps. More...
|
struct | Partition |
| This struct implements a coset (=equivalence class) as needed for the computation of the coarsest quasi-congruence on an automaton. More...
|
class | AttributeDiagnoserState |
| Implements state estimates for the current status of the generator. More...
|
class | AttributeFailureEvents |
| Stores the failure and indicator events for a particular failure type. More...
|
class | AttributeFailureTypeMap |
| Partitions the failure and indicator events. More...
|
class | DiagLabelSet |
| Implements the label representation for state estimates. More...
|
struct | CoVerifierState |
class | TdiagGenerator |
| Provides the structure and methods to build and handle diagnosers. More...
|
struct | VerifierState |
class | HioEventFlags |
| Event attributes for hierarchical discrete event systems with inputs and outputs. More...
|
class | HioStateFlags |
| State attributes for hierarchical discrete event systems with inputs and outputs. More...
|
class | THioConstraint |
| Generator with I/O-constraint attributes. More...
|
class | THioController |
| Generator with I/O-controller attributes. More...
|
class | THioEnvironment |
| Generator with I/O-environment attributes. More...
|
class | HioModule |
| Recurring structure in hierarchies designed according to the I/O based DES framework. More...
|
class | THioPlant |
| Generator with I/O-plant attributes. More...
|
class | AttributeIosEvent |
| Attributes for events in DES with in- and outputs. More...
|
class | AttributeIosState |
| Attributes for states in DESs with in- and outputs. More...
|
class | TioGenerator |
| Generator with I/O-system attributes. More...
|
class | AttributeColoredState |
| State attributes for multitasking automata. More...
|
class | ColorSet |
| Container for colors: this is a NameSet with its own static symboltable. More...
|
class | TmtcGenerator |
| Allows to create colored marking generators (CMGs) as the common five tupel consisting of alphabet, stateset, transition relation, initial states, marked states, and attributes for state and event properties. More...
|
class | adjlist |
class | AttributePushdownState |
| State attribute with substates. More...
|
class | AttributePushdownTransition |
class | AttributePushdownGlobal |
| Global attribute with stack alphabet and stack bottom. More...
|
class | StackSymbolSet |
| Container class to model a set of stack symbols. More...
|
class | StackSymbol |
| Deprecated, do not use! More...
|
class | AttributeGotoTransition |
| Event attribute with grammar symbols. More...
|
class | AttributeGotoState |
| State attribute with configuration set. More...
|
class | GotoMachine |
| Simple generator for parsing with goto tables. More...
|
class | TgotoGenerator |
| Generator for parsing with goto tables. More...
|
class | GrammarSymbol |
| Grammar Symbol. More...
|
class | Terminal |
| Terminal. More...
|
class | Nonterminal |
| Nonterminals are constructed from two states and a stack symbol or one state and a stack symbol. More...
|
struct | GsVectorComparator |
struct | GsComparator |
class | GrammarProduction |
| Grammar Production. More...
|
class | Grammar |
| Grammar. More...
|
class | LangK |
| This class is used to find all words that can be found when traversing a maximum of k transitions of a given generator. More...
|
class | MergeAbstract |
| Abstract interface class for all kinds of items which can comprise a new state. More...
|
class | MergeStates |
| Merge class which contains only states. More...
|
class | MergeStateAnnotation |
| Merge class which contains one state and a string annotation. More...
|
class | MergeStateEvent |
| Merge class which contains one state and one event. More...
|
class | MergeStateSplit |
| Merge class which contains one state, one stack symbol and a string annotation. More...
|
class | MergeTransition |
| Merge class which contains one transition. More...
|
class | Lr1Configuration |
| Lr1 Configuration. More...
|
struct | ConfigSetComparator |
struct | ConfigGsPairComparator |
class | Lr1ParserActionElement |
| Lr1ParserActionElement. More...
|
class | Lr1ParserAction |
| Lr1ParserAction. More...
|
class | Lr1Parser |
| Lr1Parser. More...
|
class | TpdGenerator |
| Generator with push down extensions. More...
|
class | AttributeTimedTrans |
| Transition Attribute with guard and resets. More...
|
class | AttributeTimedState |
| State attribute with invariant. More...
|
class | AttributeTimedGlobal |
| Globat attribute with clockset. More...
|
class | TtGenerator |
| Generator with timing extensions. More...
|
class | ClockSet |
| Container class to model a set of clocks. More...
|
class | ElemConstraint |
| Model of an elementary clock constraint formula. More...
|
class | TimeConstraint |
| A TimeConstraint is a set of elementary clock constraints. More...
|
class | tpTime |
| Type to represent time. More...
|
class | TimeInterval |
| Model of a time interval. More...
|
class | DiscreteDensityFunction |
| Density Function. More...
|
class | SampledDensityFunction |
class | DeviceExecutor |
| Executer with IO device to handle external/physical events. More...
|
struct | TimedEvent |
| Global Tyoedefs. More...
|
class | Executor |
| An Executor is a timed generator that maintains a current state. More...
|
class | LoggingExecutor |
| Executor with logging facilities. More...
|
class | ParallelExecutor |
| Synchronized parallel execution of TimedGenerators. More...
|
class | ProposingExecutor |
| Executer that proposes which transition to execute. More...
|
class | SimEventCondition |
| Defining data of event based simulation condition. More...
|
class | SimStateCondition |
| Defining data of state based simulation condition. More...
|
class | AttributeSimCondition |
| Attribute for a simulation condition. More...
|
class | SimConditionSet |
| Set of simulation named conditions. More...
|
class | SimPriorityEventAttribute |
| Defining data to prioritise events. More...
|
class | SimStochasticEventAttribute |
| Defining data of stochastic behaviour. More...
|
class | SimEventAttribute |
| Attribute for an event in the context of simulation. More...
|
class | AttributeSignalOutput |
| Configuration of a signal based output mapping. More...
|
class | AttributeSignalInput |
| Configuration of a signal based input mapping. More...
|
class | AttributeSignalEvent |
| Configuration of a signal based input or output. More...
|
class | sDevice |
| An sDevice implements signal based semantics for faudes events. More...
|
class | SimplenetAddress |
| Simplenet node address. More...
|
class | AttributeSimplenetOutput |
| Configuration of a network output mapping. More...
|
class | AttributeSimplenetInput |
| Configuration of a network input mapping. More...
|
class | AttributeSimplenetEvent |
| Configuration of a networked input or output. More...
|
class | nDevice |
| An nDevice implements networked IO via a simple TCP/IP protocol. More...
|
class | AttributeDeviceEvent |
| Attribute for the configuration of a input or output mapping. More...
|
class | vDevice |
| Virtual base class to define the interface for event io. More...
|
class | xDevice |
| Container of devices. More...
|
struct | swig_cast_info |
struct | swig_type_info |
struct | swig_lua_userdata |
class | LuaFunctionDefinition |
| A LuaFunctionDefinition is derived from FunctionDefinition to define a faudes-function by a Lua script. More...
|
class | LuaState |
| Wrapper class to maintain a Lua state. More...
|
class | LuaFunction |
| A LuaFunction is a faudes-function that executes a luafaudes script. More...
|
Typedefs |
typedef unsigned long int | fType |
| Convenience typdef flag data.
|
typedef TaNameSet
< AttributeCFlags > | Alphabet |
| Convenience typedef for event sets with controllability attributes.
|
typedef TBaseVector< Alphabet > | AlphaberVector |
| Convenience typedef.
|
typedef TcGenerator
< AttributeVoid, AttributeVoid,
AttributeCFlags, AttributeVoid > | System |
| Convenience typedef for std System.
|
typedef TBaseVector< System > | SystemVector |
| Convenience typedef for vectors of systems.
|
typedef uint32_t | Idx |
| Type definition for index type (allways 32bit).
|
typedef long int | Int |
| Type definition for integer type (let target system decide, minimum 32bit).
|
typedef double | Float |
| Type definition for real type (use C std double, must at least represent Int).
|
typedef TBaseVector< Integer > | IntegerVector |
typedef vGenerator | Generator |
| Plain generator, api typedef for generator with no attributes.
|
typedef TBaseVector< Generator > | GeneratorVector |
| Convenience typedef for vectors og generators.
|
typedef IndexSet | StateSet |
typedef TBaseVector< IndexSet > | IndexSetVector |
| Convenience typedef for vectors og generators.
|
typedef NameSet | EventSet |
| Convenience typedef for plain event sets.
|
typedef TBaseVector< EventSet > | EventSetVector |
typedef TNode< Idx, Idx > | Node |
typedef TGraph< Idx, Idx > | Graph |
typedef TTransSet
< TransSort::X1EvX2 > | TransSet |
| Type definition for default sorted TTransSet.
|
typedef TTransSet
< TransSort::X1EvX2 > | TransSetX1EvX2 |
| Type definition for default sorted TTransSet.
|
typedef TTransSet
< TransSort::EvX1X2 > | TransSetEvX1X2 |
| Type definition for ev, x1, x2 sorted TTransSet.
|
typedef TTransSet
< TransSort::EvX2X1 > | TransSetEvX2X1 |
| Type definition for ev, x2, x1 sorted TTransSet.
|
typedef TTransSet
< TransSort::X2EvX1 > | TransSetX2EvX1 |
| Type definition for x2, ev, x1 sorted TTransSet.
|
typedef TTransSet
< TransSort::X2X1Ev > | TransSetX2X1Ev |
| Type definition for x2, x1, ev sorted TTransSet.
|
typedef TTransSet
< TransSort::X1X2Ev > | TransSetX1X2Ev |
| Type definition for x1, x2, ev sorted TTransSet.
|
typedef TdiagGenerator
< AttributeFailureTypeMap,
AttributeDiagnoserState,
AttributeCFlags, AttributeVoid > | Diagnoser |
typedef THioConstraint
< AttributeVoid, HioStateFlags,
HioEventFlags, AttributeVoid > | HioConstraint |
typedef THioController
< AttributeVoid, HioStateFlags,
HioEventFlags, AttributeVoid > | HioController |
typedef THioEnvironment
< AttributeVoid, HioStateFlags,
HioEventFlags, AttributeVoid > | HioEnvironment |
typedef THioPlant
< AttributeVoid, HioStateFlags,
HioEventFlags, AttributeVoid > | HioPlant |
typedef TaNameSet
< AttributeIosEvent > | IosEventSet |
typedef TaIndexSet
< AttributeIosState > | IosStateSet |
typedef TioGenerator
< AttributeVoid,
AttributeIosState,
AttributeIosEvent,
AttributeVoid > | IoSystem |
typedef TmtcGenerator
< AttributeVoid,
AttributeColoredState,
AttributeCFlags, AttributeVoid > | MtcSystem |
typedef std::set< std::pair
< std::vector< Idx >
, std::vector< Idx > > > | PopPushSet |
| Transition attribute with pop and push.
|
typedef unsigned int | uint |
typedef TgotoGenerator
< AttributeVoid,
AttributeGotoState,
AttributeVoid,
AttributeGotoTransition > | GotoGenerator |
| Convenience typedef for std GotoGenerator.
|
typedef std::tr1::shared_ptr
< GrammarSymbol > | GrammarSymbolPtr |
typedef std::tr1::shared_ptr
< const GrammarSymbol > | ConstGrammarSymbolPtr |
typedef std::tr1::shared_ptr
< Nonterminal > | NonterminalPtr |
typedef std::tr1::shared_ptr
< const Nonterminal > | ConstNonterminalPtr |
typedef std::tr1::shared_ptr
< Terminal > | TerminalPtr |
typedef std::tr1::shared_ptr
< const Terminal > | ConstTerminalPtr |
typedef std::vector
< GrammarSymbolPtr > | GrammarSymbolVector |
typedef std::set
< GrammarSymbolPtr,
GsComparator > | GrammarSymbolSet |
typedef std::set
< GrammarSymbolVector,
GsVectorComparator > | GrammarSymbolWordSet |
typedef std::map
< GrammarSymbolVector,
std::set< Terminal >
, GsVectorComparator > | GrammarSymbolWordMap |
typedef std::set< std::set
< Lr1Configuration >
, ConfigSetComparator > | Lr1ConfigurationSetSet |
typedef std::pair< std::set
< Lr1Configuration >
, GrammarSymbolPtr > | ConfigSetGsPair |
typedef std::vector< std::set
< Lr1Configuration > > | ConfigSetVector |
typedef std::map
< ConfigSetGsPair, std::set
< Lr1Configuration >
, ConfigGsPairComparator > | LrmTransitionMap |
typedef std::set
< ConfigSetGsPair,
ConfigGsPairComparator > | ConfigSetGsPairSet |
typedef TpdGenerator
< AttributePushdownGlobal,
AttributePushdownState,
AttributeCFlags,
AttributePushdownTransition > | PushdownGenerator |
| Convenience typedef for std PushdownGenerator.
|
typedef TaTransSet
< AttributePushdownTransition > | PdTransSet |
typedef TtGenerator
< AttributeTimedGlobal,
AttributeTimedState,
AttributeCFlags,
AttributeTimedTrans > | TimedGenerator |
| Convenience typedef for std TimedGenerator.
|
typedef void | vDevice |
| Dummy typedef in the absence of the IO Device plugin.
|
typedef TaNameSet
< SimEventAttribute > | sEventSet |
| Typedef for events with simulation attributes.
|
typedef void *(* | swig_converter_func )(void *, int *) |
typedef struct swig_type_info *(* | swig_dycast_func )(void **) |
typedef struct
faudes::swig_cast_info | swig_cast_info |
typedef struct
faudes::swig_type_info | swig_type_info |
Enumerations |
enum | VerifierStateLabel { NORMAL,
CONFUSED,
BLOCK
} |
Functions |
template<class T , class Cmp > |
void | SetUnion (const TBaseSet< T, Cmp > &rSetA, const TBaseSet< T, Cmp > &rSetB, TBaseSet< T, Cmp > &rRes) |
template<class T , class Cmp > |
void | SetIntersection (const TBaseSet< T, Cmp > &rSetA, const TBaseSet< T, Cmp > &rSetB, TBaseSet< T, Cmp > &rRes) |
template<class T , class Cmp > |
void | SetDifference (const TBaseSet< T, Cmp > &rSetA, const TBaseSet< T, Cmp > &rSetB, TBaseSet< T, Cmp > &rRes) |
template<class T , class Cmp > |
bool | SetEquality (const TBaseSet< T, Cmp > &rSetA, const TBaseSet< T, Cmp > &rSetB) |
template<class T , class Cmp > |
bool | SetInclusion (const TBaseSet< T, Cmp > &rSetA, const TBaseSet< T, Cmp > &rSetB) |
void | UniqueInit (Generator &rGen) |
| Make initial states unique.
|
void | UniqueInit (const Generator &rGen, Generator &rResGen) |
| Make initial states unique.
|
void | Deterministic (const Generator &rGen, Generator &rResGen) |
| Make generator deterministic.
|
void | aDeterministic (const Generator &rGen, Generator &rResGen) |
| Make generator deterministic.
|
void | Deterministic (const Generator &rGen, std::map< Idx, StateSet > &rEntryStatesMap, Generator &rResGen) |
| Make generator deterministic.
|
void | Deterministic (const Generator &rGen, std::vector< StateSet > &rPowerStates, std::vector< Idx > &rDetStates, Generator &rResGen) |
| Make generator deterministic.
|
long int | IntegerSum (const Integer &arg1, const Integer &arg2) |
long int | IntegerSum (const IntegerVector &intvect) |
bool | IsAccessible (const vGenerator &rGen) |
| RTI wrapper function.
|
bool | IsCoaccessible (const vGenerator &rGen) |
| RTI wrapper function.
|
bool | IsTrim (const vGenerator &rGen) |
| RTI wrapper function.
|
bool | IsOmegaTrim (const vGenerator &rGen) |
| RTI wrapper function.
|
bool | IsComplete (const vGenerator &rGen) |
| RTI wrapper function.
|
bool | IsComplete (const vGenerator &rGen, const StateSet &rStateSet) |
bool | IsComplete (const vGenerator &rGen, const EventSet &rSigmaO) |
| RTI wrapper function.
|
bool | IsDeterministic (const vGenerator &rGen) |
| RTI wrapper function.
|
void | Accessible (vGenerator &rGen) |
| RTI wrapper function.
|
void | Accessible (const vGenerator &rGen, vGenerator &rRes) |
| RTI wrapper function.
|
void | Coaccessible (vGenerator &rGen) |
| RTI wrapper function.
|
void | Coaccessible (const vGenerator &rGen, vGenerator &rRes) |
| RTI wrapper function.
|
void | Complete (vGenerator &rGen) |
| RTI wrapper function.
|
void | Complete (const vGenerator &rGen, vGenerator &rRes) |
| RTI wrapper function.
|
void | Complete (vGenerator &rGen, const EventSet &rSigmaO) |
| RTI wrapper function.
|
void | Complete (const vGenerator &rGen, const EventSet &rSigmaO, vGenerator &rRes) |
| RTI wrapper function.
|
void | Trim (vGenerator &rGen) |
| RTI wrapper function.
|
void | Trim (const vGenerator &rGen, vGenerator &rRes) |
| RTI wrapper function.
|
void | OmegaTrim (vGenerator &rGen) |
| RTI wrapper function.
|
void | OmegaTrim (const vGenerator &rGen, vGenerator &rRes) |
| RTI wrapper function.
|
void | MarkAllStates (vGenerator &rGen) |
| RTI wrapper function.
|
void | AlphabetExtract (const vGenerator &rGen, EventSet &rRes) |
| RTI wrapper function.
|
void | SetIntersection (const GeneratorVector &rGenVec, EventSet &rRes) |
| RTI convenience function.
|
void | SetUnion (const GeneratorVector &rGenVec, EventSet &rRes) |
| RTI convenience function.
|
void | SetIntersection (const vGenerator &rGenA, const vGenerator &rGenB, EventSet &rRes) |
| RTI convenience function.
|
void | SetUnion (const vGenerator &rGenA, const vGenerator &rGenB, EventSet &rRes) |
| RTI convenience function.
|
void | SetDifference (const vGenerator &rGenA, const vGenerator &rGenB, EventSet &rRes) |
| RTI convenience function.
|
void | SearchScc (const Idx vState, int &vRcount, const Generator &rGen, const SccFilter &rFilter, StateSet &rTodo, std::stack< Idx > &rStack, StateSet &rStackStates, std::map< const Idx, int > &rDfn, std::map< const Idx, int > &rLowLnk, std::list< StateSet > &rSccList, StateSet &rRoots) |
| Search for strongly connected components (SCC).
|
bool | ComputeScc (const Generator &rGen, const SccFilter &rFilter, std::list< StateSet > &rSccList, StateSet &rRoots) |
| Compute strongly connected components (SCC).
|
bool | ComputeScc (const Generator &rGen, std::list< StateSet > &rSccList, StateSet &rRoots) |
| Compute strongly connected components (SCC).
|
bool | ComputeScc (const Generator &rGen, const SccFilter &rFilter, Idx q0, StateSet &rScc) |
| Compute strongly connected component (SCC).
|
bool | ComputeScc (const Generator &rGen, const SccFilter &rFilter, StateSet &rScc) |
| Compute one strongly connected components (SCC).
|
bool | HasScc (const Generator &rGen, const SccFilter &rFilter) |
| Test for strongly connected components (SCC).
|
bool | ComputeNextScc (const Generator &rGen, SccFilter &rFilter, StateSet &rScc) |
| Compute next SCC.
|
std::string | ToStringInteger (long int number) |
| integer to string
|
std::string | ToStringInteger16 (long int number) |
| integer to string base 16
|
std::string | ToStringFloat (double number) |
| float to string
|
std::string | ExpandString (const std::string &rString, unsigned int len) |
| Fill string with spaces up to a given length if length of the string is smaller than given length parameter.
|
std::string | CollapsString (const std::string &rString, unsigned int len=FD_MAXCONTAINERNAME) |
| Limit length of string, return head and tail of string.
|
Idx | ToIdx (const std::string &rString) |
| Convert a string to Idx.
|
std::string | StringSubstitute (const std::string &rString, const std::string &rFrom, const std::string &rTo) |
| Substitute in string.
|
std::string | VersionString () |
| Return FAUDES_VERSION as std::string.
|
std::string | PluginsString () |
| Return FAUDES_PLUGINS as std::string.
|
std::string | ContributorsString () |
| Return contributors as std::string.
|
void | ProcessDot (const std::string &rDotFile, const std::string &rOutFile, const std::string &rOutFormat="", const std::string &rDotExec="dot") |
| Convenience function: process dot file to graphics output.
|
std::string | CreateTempFile (void) |
| Create a temp file, length 0.
|
bool | RemoveFile (const std::string &rFileName) |
| Delete a file.
|
std::string | ExtractDirectory (const std::string &rFullPath) |
| Extract directory from full path.
|
std::string | ExtractFilename (const std::string &rFullName) |
| Extract file name from full path.
|
std::string | ExtractBasename (const std::string &rFullName) |
| Extract file name from full path.
|
std::string | ExtractExtension (const std::string &rFullName) |
| Extract file name from full path.
|
std::string | PrependDirectory (const std::string &rDirectory, const std::string &rFileName) |
| Construct full path from directory and filename.
|
bool | DirectoryExists (const std::string &rDirectory) |
| Test existence of directory.
|
std::set< std::string > | ReadDirectory (const std::string &rDirectory) |
| Read the contents of the specified directors.
|
bool | FileExists (const std::string &rFilename) |
| Test existence of file.
|
bool | FileDelete (const std::string &rFilename) |
| Delete file.
|
bool | FileCopy (const std::string &rFromFile, const std::string &rToFile) |
| Copy file.
|
void | ExitFunction (void) |
std::string | TestProtocol (const std::string &rSource) |
| Test Protocol.
|
void | TestProtocol (const std::string &rMessage, const Type &rData, bool core=false) |
| Test Protocol.
|
void | TestProtocol (const std::string &rMessage, bool data) |
| Test Protocol.
|
void | TestProtocol (const std::string &rMessage, long int data) |
| Test Protocol.
|
void | TestProtocol (const std::string &rMessage, const std::string &data) |
| Test Protocol.
|
bool | TestProtocol (void) |
| Test Protocol.
|
void | LoopCallback (bool pBreak(void)) |
void | LoopCallback (void) |
| Algorithm loop callback.
|
const std::string & | PathSeparator (void) |
| Std dir-separator.
|
void | LoopCallback (bool(*pBreakFnct)(void)) |
| Algorithm loop callback.
|
StateSet | LowExitStates (const Generator &rLowGen, const EventSet &rHighAlph, const std::map< Idx, StateSet > &rEntryStatesMap, const TransSetX2EvX1 &rLowRevTransRel, Idx highState) |
| LowExitStates return-copy function:
|
void | LowExitStates (const EventSet &rHighAlph, const std::map< Idx, StateSet > &rEntryStatesMap, const TransSetX2EvX1 &rLowRevTransRel, Idx highState, StateSet &rLowExitStates) |
| LowExitStates call-by-reference function:
|
EventSet | ReachableEvents (const Generator &rLowGen, const EventSet &rHighAlph, Idx lowState) |
| ReachableEvents return-copy function:
|
void | ReachableEvents (const Generator &rLowGen, const EventSet &rHighAlph, Idx lowState, EventSet &rReachableEvents) |
| ReachableEvents call-by-reference function:
|
void | LocalCoaccessibleReach (const TransSetX2EvX1 &rRevTransRel, const EventSet &rHighAlph, Idx lowState, StateSet &rCoaccessibleReach) |
| Compute the coaccessible reach for a local automaton.
|
void | LocalAccessibleReach (const Generator &rLowGen, const EventSet &rHighAlph, Idx lowState, StateSet &rAccessibleReach) |
| Compute the accessible reach for a local automaton.
|
void | aOmegaProduct (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Product composition for Buechi automata.
|
void | OmegaProduct (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Product composition for Buechi automata.
|
void | aOmegaParallel (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Parallel composition with relaxed acceptance condition.
|
void | OmegaParallel (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Parallel composition with relaxed acceptance condition.
|
void | OmegaClosure (Generator &rGen) |
| Topological closure.
|
bool | IsOmegaClosed (const Generator &rGen) |
| Test for topologically closed omega language.
|
void | Parallel (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Parallel composition.
|
void | aParallel (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Parallel composition.
|
void | aParallel (const GeneratorVector &rGenVec, Generator &rResGen) |
| Parallel composition.
|
void | aParallel (const Generator &rGen1, const Generator &rGen2, ProductCompositionMap &rCompositionMap, Generator &rResGen) |
| Parallel composition.
|
void | Parallel (const Generator &rGen1, const Generator &rGen2, ProductCompositionMap &rCompositionMap, Generator &rResGen) |
| Parallel composition.
|
void | Parallel (const Generator &rGen1, const Generator &rGen2, ProductCompositionMap &rCompositionMap, StateSet &rMark1, StateSet &rMark2, Generator &rResGen) |
| Parallel composition.
|
void | Parallel (const Generator &rGen1, const Generator &rGen2, std::map< std::pair< Idx, Idx >, Idx > &rCompositionMap, Generator &rResGen) |
| Parallel composition.
|
void | Product (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Product composition.
|
void | aProduct (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Product composition.
|
void | aProduct (const Generator &rGen1, const Generator &rGen2, ProductCompositionMap &rCompositionMap, Generator &rResGen) |
| Product composition.
|
void | Product (const Generator &rGen1, const Generator &rGen2, std::map< std::pair< Idx, Idx >, Idx > &rCompositionMap, StateSet &rMark1, StateSet &rMark2, Generator &rResGen) |
| Product composition.
|
void | Product (const Generator &rGen1, const Generator &rGen2, std::map< std::pair< Idx, Idx >, Idx > &rCompositionMap, Generator &rResGen) |
| Product composition.
|
void | SetComposedStateNames (const Generator &rGen1, const Generator &rGen2, const std::map< std::pair< Idx, Idx >, Idx > &rCompositionMap, Generator &rGen12) |
| Helper: uses composition map to track state names in a paralell composition.
|
void | CompositionMap1 (const std::map< std::pair< Idx, Idx >, Idx > &rCompositionMap, std::map< Idx, Idx > &rCompositionMap1) |
void | CompositionMap2 (const std::map< std::pair< Idx, Idx >, Idx > &rCompositionMap, std::map< Idx, Idx > &rCompositionMap2) |
void | ProjectNonDet_opitz (Generator &rGen, const EventSet &rProjectAlphabet) |
void | ProjectNonDet_ref (Generator &rGen, const EventSet &rProjectAlphabet) |
void | ProjectNonDet_graph (Generator &rGen, const EventSet &rProjectAlphabet) |
void | ProjectNonDet_simple (Generator &rGen, const EventSet &rProjectAlphabet) |
void | ProjectNonDet_barthel (Generator &rGen, const EventSet &rProjectAlphabet) |
void | ProjectNonDet_fbr (Generator &rGen, const EventSet &rProjectAlphabet) |
void | ProjectNonDet_scc (Generator &rGen, const EventSet &rProjectAlphabet) |
void | ProjectNonDet (Generator &rGen, const EventSet &rProjectAlphabet) |
| Language projection.
|
void | ProjectNonDetScc (Generator &rGen, const EventSet &rProjectAlphabet) |
| Language projection.
|
void | Project (const Generator &rGen, const EventSet &rProjectAlphabet, Generator &rResGen) |
| Deterministic projection.
|
void | aProjectNonDet (Generator &rGen, const EventSet &rProjectAlphabet) |
| Language projection.
|
void | aProject (const Generator &rGen, const EventSet &rProjectAlphabet, Generator &rResGen) |
| Deterministic projection.
|
void | Project (const Generator &rGen, const EventSet &rProjectAlphabet, std::map< Idx, StateSet > &rEntryStatesMap, Generator &rResGen) |
| Deterministic projection.
|
void | InvProject (Generator &rGen, const EventSet &rProjectAlphabet) |
| Inverse projection.
|
void | aInvProject (Generator &rGen, const EventSet &rProjectAlphabet) |
| Inverse projection.
|
void | aInvProject (const Generator &rGen, const EventSet &rProjectAlphabet, Generator &rResGen) |
| Inverse projection.
|
void | CreateEntryStatesMap (const std::map< StateSet, Idx > &rRevEntryStatesMap, std::map< Idx, StateSet > &rEntryStatesMap) |
void | LoadRegistry (const std::string &rPath="") |
| Load all registered types and functions.
|
void | SaveRegistry (const std::string &rPath="") |
| Dump all registered types and functions.
|
void | ClearRegistry (void) |
| Clear all registry.
|
Type * | NewFaudesObject (const std::string &rTypeName) |
| Instantiate faudes typed objects by type name.
|
Function * | NewFaudesFunction (const std::string &rFunctName) |
| Instantiate faudes function objects by function name.
|
const std::string & | FaudesTypeName (const Type &rObject) |
| Query type name.
|
bool | FaudesTypeTest (const std::string &rTypeName, const Type &rObject) |
| Test type compatibility.
|
const std::string & | FaudesFunctionName (const Function &rObject) |
const std::string & | FaudesFunctionName (const Type &rObject) |
| Query function name.
|
void | LanguageUnionNonDet (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Language union, nondeterministic version.
|
void | LanguageUnion (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Language union, deterministic version.
|
void | LanguageUnion (const GeneratorVector &rGenVec, Generator &rResGen) |
| Language union.
|
void | LanguageIntersection (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Language intersection.
|
void | LanguageIntersection (const GeneratorVector &rGenVec, Generator &rResGen) |
| Language intersection.
|
bool | EmptyLanguageIntersection (const Generator &rGen1, const Generator &rGen2) |
| Test for empty language intersection (same as Disjoind()).
|
bool | LanguageDisjoint (const Generator &rGen1, const Generator &rGen2) |
| Test whether two languages are disjoint.
|
void | Automaton (Generator &rGen, const EventSet &rAlphabet) |
| Convert generator to automaton wrt specified alphabet.
|
void | Automaton (Generator &rGen) |
| Convert generator to automaton.
|
void | LanguageComplement (Generator &rGen, const EventSet &rAlphabet) |
| Language complement wrt specified alphabet.
|
void | LanguageComplement (Generator &rGen) |
| Language complement.
|
void | LanguageComplement (const Generator &rGen, Generator &rRes) |
| Language Complement (uniform API wrapper).
|
void | LanguageComplement (const Generator &rGen, const EventSet &rSigma, Generator &rRes) |
| Language Complement (uniform API wrapper).
|
void | LanguageDifference (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Language difference (set-theoretic difference).
|
void | LanguageConcatenateNonDet (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Language concatenation, nondeterministic version.
|
void | LanguageConcatenate (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Language concatenation, deterministic version.
|
void | FullLanguage (const EventSet &rAlphabet, Generator &rResGen) |
| Full Language, L(G)=Lm(G)=Sigma*.
|
void | AlphabetLanguage (const EventSet &rAlphabet, Generator &rResGen) |
| Alphabet Language, L(G)=Lm(G)=Sigma.
|
void | EmptyStringLanguage (const EventSet &rAlphabet, Generator &rResGen) |
| Empty string language, L(G)=Lm(G)={epsilon}.
|
void | EmptyLanguage (const EventSet &rAlphabet, Generator &rResGen) |
| Empty language Lm(G)={}.
|
bool | IsEmptyLanguage (const Generator &rGen) |
| Test for Empty language Lm(G)=={}.
|
bool | LanguageInclusion (const Generator &rGen1, const Generator &rGen2) |
| Test language inclusion, Lm1<=Lm2.
|
bool | LanguageEquality (const Generator &rGen1, const Generator &rGen2) |
| Language equality, Lm1==Lm2.
|
void | KleeneClosure (Generator &rGen) |
| Kleene Closure.
|
void | KleeneClosure (const Generator &rGen, Generator &rResGen) |
| Kleene Closure.
|
void | KleeneClosureNonDet (Generator &rGen) |
| Kleene Closure, nondeterministic version.
|
void | PrefixClosure (Generator &rGen) |
| Prefix Closure.
|
bool | IsPrefixClosed (const Generator &rGen) |
| Test for prefix closed marked language.
|
bool | IsNonblocking (const Generator &rGen) |
| Test for nonblocking generator.
|
bool | IsNonblocking (const Generator &rGen1, const Generator &rGen2) |
| Test for nonblocking marked languages.
|
void | SelfLoop (Generator &rGen, const EventSet &rAlphabet) |
| Self-loop all states.
|
void | SelfLoopMarkedStates (Generator &rGen, const EventSet &rAlphabet) |
| Self-loop all marked states.
|
void | SelfLoop (Generator &rGen, const EventSet &rAlphabet, const StateSet &rStates) |
| Self-loop specified states.
|
void | StateMin (const Generator &rGen, Generator &rResGen) |
| State set minimization.
|
void | aStateMin (const Generator &rGen, Generator &rResGen) |
| State set minimization.
|
void | aStateMin (Generator &rGen) |
| State set minimization.
|
void | StateMin (Generator &rGen, Generator &rResGen) |
| State set minimization.
|
void | StateMin (Generator &rGen, Generator &rResGen, std::vector< StateSet > &rSubsets, std::vector< Idx > &rNewIndices) |
| State set minimization.
|
bool | IsRelativelyMarked (const Generator &rGenPlant, const Generator &rGenCand) |
| Test for relative marking.
|
bool | IsRelativelyPrefixClosed (const Generator &rGenPlant, const Generator &rGenCand) |
| Test for relative prefix-closedness.
|
void | SupRelativelyPrefixClosed (const Generator &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| Supremal Relatively Closed Sublanguage.
|
void | SupRelativelyPrefixClosedUnchecked (const Generator &rPlantGen, const Generator &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rCompositionMap, Generator &rResGen) |
| Supremal Relatively Closed Sublanguage (internal function).
|
bool | IsRelativelyOmegaMarked (const Generator &rGenPlant, const Generator &rGenCand) |
| Test for relative marking, omega langauges.
|
bool | IsRelativelyOmegaClosed (const Generator &rGenPlant, const Generator &rGenCand) |
| Test for relative closedness, omega languages.
|
bool | IsRelativelyOmegaClosedUnchecked (const Generator &rGenPlant, const Generator &rGenCand) |
| Test for relative closedness, omega languages.
|
void | SupConClosedUnchecked (const Generator &rPlantGen, const EventSet &rCAlph, Generator &rSupCandGen) |
| Supremal Controllable Sublangauge (internal function).
|
bool | IsControllableUnchecked (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, StateSet &rCriticalStates) |
| Controllability (internal function).
|
void | SupConProduct (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, Generator &rResGen) |
| Parallel composition optimized for the purpose of SupCon (internal function).
|
void | SupConNBUnchecked (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, Generator &rResGen) |
| Nonblocking Supremal Controllable Sublanguage (internal function).
|
void | ControlProblemConsistencyCheck (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen) |
| Consistency check for controlproblem input data.
|
void | ControlProblemConsistencyCheck (const Generator &rPlantGen, const EventSet &rCAlph, const EventSet &rOAlph, const Generator &rSpecGen) |
| Consistency check for controlproblem input data.
|
bool | IsControllable (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSupCandGen) |
| Test controllability.
|
bool | IsControllable (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSupCandGen, StateSet &rCriticalStates) |
| Test controllability.
|
void | SupConNB (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, Generator &rResGen) |
| Nonblocking Supremal Controllable Sublanguage.
|
void | SupConClosed (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, Generator &rResGen) |
| Supremal Controllable and Closed Sublanguage.
|
void | SupConClosed (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, Generator &rResGen) |
| Supremal Controllable and Closed Sublanguage.
|
void | TraverseUncontrollableBackwards (const EventSet &rCAlph, TransSetX2EvX1 &rtransrel, StateSet &rCriticalStates, Idx current) |
| Helper function for IsControllable.
|
bool | IsControllable (const System &rPlantGen, const Generator &rSupCandGen) |
| Test controllability.
|
void | SupConNB (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| Nonblocking Supremal Controllable Sublanguage.
|
void | SupConClosed (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| Supremal Controllable and Closed Sublanguage.
|
void | NormalityConsistencyCheck (const Generator &rL, const EventSet &rOAlph, const Generator &rK) |
| NormalityConsistencyCheck: Consistency check for normality input data.
|
bool | IsNormal (const Generator &rL, const EventSet &rOAlph, const Generator &rK) |
| IsNormal: checks normality of a language K generated by rK wrt a language L generated by rL and the subset of observable events rOAlph.
|
bool | IsNormal (const System &rPlantGen, const Generator &rSupCandGen) |
| IsNormal wrapper.
|
void | ConcatenateFullLanguage (Generator &rGen) |
| ConcatenateFullLanguage: concatenate Sigma* to language marked by rGen.
|
bool | SupNorm (const Generator &rL, const EventSet &rOAlph, const Generator &rK, Generator &rResult) |
| SupNorm: compute supremal normal sublanguage.
|
bool | SupNormClosed (const Generator &rL, const EventSet &rOAlph, const Generator &rK, Generator &rResult) |
| SupNormClosed - compute supremal normal and closed sublanguage.
|
void | SupConNormClosed (const Generator &rL, const EventSet &rCAlph, const EventSet &rOAlph, const Generator &rK, Generator &rResult) |
| SupConNormClosed: compute supremal controllable, normal and closed sublanguage.
|
void | SupConNormNB (const Generator &rL, const EventSet &rCAlph, const EventSet &rOAlph, const Generator &rK, Generator &rResult) |
| SupConNormNB: compute supremal controllable and normal sublanguage.
|
bool | SupPrefixClosed (const Generator &rK, Generator &rResult) |
| SupPrefixClosed: supremal closed sublanguage of K by cancelling all tranistions leading to a non-marked state.
|
void | SupConNormClosedUnchecked (const Generator &rPlantGen, const EventSet &rCAlph, const EventSet &rOAlph, Generator &rObserverGen, Generator &rSupCandGen) |
| Supremal Normal Controllable Sublangauge (internal function).
|
void | SupNorm (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| rti wrapper
|
void | SupNormClosed (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| rti wrapper
|
void | SupConNormClosed (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| rti wrapper
|
void | SupConNormNB (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| rti wrapper
|
bool | SupReduce (const System &rPlantGen, const System &rSupGen, System &rReducedSup) |
| Supervisor Reduction algorithm.
|
bool | CheckMergibility (Idx stateI, Idx stateJ, std::vector< std::set< Idx > > &rWaitList, Idx cNode, const System &rSupGen, const std::map< Idx, ReductionStateInfo > &rSupStateInfo, const std::map< Idx, Idx > &rState2Class, const std::vector< StateSet > &rClass2States) |
| Supervisor Reduction mergibility algorithm.
|
void | SupTconUnchecked (const Generator &rPlantGen, const EventSet &rCAlph, const EventSet &rFAlph, const EventSet &rPAlph, const EventSet &rCPAlph, Generator &rSupCandGen) |
void | SupTconNBUnchecked (const Generator &rPlantGen, const EventSet &rCAlph, const EventSet &rFAlph, const EventSet &rPAlph, const Generator &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rCompositionMap, Generator &rResGen) |
void | SupTconNB (const Generator &rPlantGen, const EventSet &rCAlph, const EventSet &rFAlph, const EventSet &rPAlph, const Generator &rSpecGen, Generator &rResGen) |
| Nonblocking Supremal TDES-Controllable Sublanguage.
|
void | SupTconNB (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| Nonblocking Supremal TDES-Controllable Sublanguage.
|
bool | IsOmegaControllable (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSupCandGen) |
| Test omega controllability.
|
bool | IsOmegaControllable (const System &rPlantGen, const Generator &rSupCandGen) |
| Test omega-controllability.
|
void | SupConCmplClosed (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, Generator &rResGen) |
| Supremal controllable and complete sublanguage.
|
void | SupConCmplClosed (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| Supremal controllable and complete sublanguage.
|
void | SupConCmplNB (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, Generator &rResGen) |
| Supremal controllable and complete sublanguage.
|
void | SupConCmplNB (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| Supremal controllable and complete sublanguage.
|
void | SupConNormCmplNB (const Generator &rPlantGen, const EventSet &rCAlph, const EventSet &rOAlph, const Generator &rSpecGen, Generator &rResGen) |
| Supremal controllable, normal and complete sublanguage.
|
void | SupConNormCmplNB (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| rti wrapper
|
bool | OmegaControlledLiveness (Generator &rSupCandGen, const EventSet &rCAlph, const StateSet &rPlantMarking) |
bool | OmegaControlledLiveness (Generator &rSupCandGen, const EventSet &rCAlph, const StateSet &rPlantMarking, std::map< Idx, EventSet > &rFeedbackMap) |
bool | OmegaControlledLiveness (Generator &rSupCandGen, const EventSet &rCAlph, const StateSet &rPlantMarking, std::map< Idx, Idx > &rControllerStatesMap, std::map< Idx, EventSet > &rFeedbackMap) |
void | OmegaSupConProduct (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, std::map< OPSState, Idx > &rProductCompositionMap, Generator &rResGen) |
void | OmegaSupConNBUnchecked (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, StateSet &rPlantMarking, Generator &rResGen) |
void | OmegaSupConNormNBUnchecked (const Generator &rPlantGen, const EventSet &rCAlph, const EventSet &rOAlph, const Generator &rSpecGen, StateSet &rPlantMarking, std::map< Idx, Idx > &rObserverStateMap, std::map< Idx, EventSet > &rFeedbackMap, Generator &rResGen) |
void | OmegaSupConNB (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, Generator &rResGen) |
| Omega-synthesis.
|
void | OmegaSupConNB (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| Omega-synthesis.
|
void | OmegaConNB (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, Generator &rResGen) |
| Omega-synthesis.
|
void | OmegaConNB (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| Omega-synthesis.
|
void | OmegaSupConNormNB (const Generator &rPlantGen, const EventSet &rOAlph, const EventSet &rCAlph, const Generator &rSpecGen, Generator &rResGen) |
| Omega-synthesis for partial observation (experimental!).
|
void | OmegaSupConNormNB (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| Omega-synthesis for partial observation.
|
void | OmegaConNormNB (const Generator &rPlantGen, const EventSet &rOAlph, const EventSet &rCAlph, const Generator &rSpecGen, Generator &rResGen) |
| Omega-synthesis for partial observation (experimental!).
|
void | OmegaConNormNB (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| Omega-synthesis for partial observation (experimental!).
|
void | calcBisimulation (Generator &rGenOrig, map< Idx, Idx > &rMapStateToPartition, Generator &rGenPart, vector< Idx > &rNewPartitions) |
void | calcBisimulation (Generator &rGenOrig, map< Idx, Idx > &rMapStateToPartition, vector< Idx > &rNewPartitions) |
void | calcBisimulation (Generator &rGenOrig, std::map< Idx, Idx > &rMapStateToPartition, Generator &rGenPart, std::vector< Idx > &rNewPartitions) |
| Computation of a bisimulation over a given generator.
|
void | calcBisimulation (Generator &rGenOrig, std::map< Idx, Idx > &rMapStateToPartition, std::vector< Idx > &rNewPartitions) |
| Computation of a bisimulation over a given generator.
|
bool | IsMutuallyControllable (const System &rGen1, const System &rGen2) |
| Verification of mutual controllability.
|
bool | IsMutuallyControllable (const System &rGen1, const System &rGen2, StateSet &rForbidden1, StateSet &rForbidden2) |
| Verification of mutual controllability.
|
void | IsMutuallyControllable (const System &rGen1, const System &rGen2, bool &rRes) |
| RTI wrapper.
|
void | calculateDynamicSystemClosedObs (const Generator &rGen, EventSet &rHighAlph, Generator &rGenDyn) |
| Computation of the dynamic system for Delta_sigma (reachable states after the occurrence of one high-level event).
|
void | calculateDynamicSystemObs (const Generator &rGen, EventSet &rHighAlph, Generator &rGenDyn) |
| Computation of the dynamic system for Delta_obs (local reachability of a marked state).
|
void | calculateDynamicSystemMSA (const Generator &rGen, EventSet &rHighAlph, Generator &rGenDyn) |
| Computation of the dynamic system for Delta_msa (local fulfillment of the msa-observer property).
|
bool | recursiveCheckMSAForward (const Generator &rGen, const EventSet &rHighAlph, Idx currentState, StateSet &rDoneStates) |
| Check if the msa-observer conditions is fulfilled for a given state.
|
bool | recursiveCheckMSABackward (const Generator &rGen, const TransSetX2EvX1 &rRevTransSet, const EventSet &rHighAlph, Idx currentState, StateSet &rDoneStates) |
| Check if the msa-observer conditions is fulfilled for a given state.
|
void | calculateDynamicSystemLCC (const Generator &rGen, const EventSet &rControllableEvents, const EventSet &rHighAlph, Generator &rGenDyn) |
| Computation of the dynamic system for Delta_lcc (fulfillment of the local control consistency property).
|
void | recursiveCheckLCC (const TransSetX2EvX1 &rRevTransSet, const EventSet &rControllableEvents, const EventSet &rHighAlph, Idx currentState, StateSet &rDoneStates) |
| Find states that fulfill the lcc condition.
|
Idx | calcClosedObserver (const Generator &rGenObs, EventSet &rHighAlph) |
| L(G)-observer computation by adding events to the high-level alphabet.
|
Int | calcNaturalObserver (const Generator &rGenObs, EventSet &rHighAlph) |
| Lm(G)-observer computation by adding events to the high-level alphabet.
|
Int | calcNaturalObserverLCC (const Generator &rGen, const EventSet &rControllableEvents, EventSet &rHighAlph) |
| Lm(G)-observer computation including local control consistency (LCC) by adding events to the high-level alphabet.
|
Int | calcMSAObserver (const Generator &rGen, EventSet &rHighAlph) |
| MSA-observer computation by adding events to the high-level alphabet.
|
Int | calcMSAObserverLCC (const Generator &rGen, const EventSet &rControllableEvents, EventSet &rHighAlph) |
| MSA-observer computation including local control consistency (LCC) by adding events to the high-level alphabet.
|
void | ExtendHighAlphabet (const Generator &rGen, EventSet &rHighAlph, map< Idx, Idx > &rMapStateToPartition) |
bool | CheckSplit (const Generator &rGen, const EventSet &rSplitAlphabet, const vector< pair< StateSet, Idx > > &rNondeterministicStates, Idx entryState) |
void | calcAbstAlphClosed (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents) |
void | calcAbstAlphClosed (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents) |
void | calcAbstAlphClosed (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans) |
void | calcAbstAlphObs (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents) |
void | calcAbstAlphObs (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents) |
void | calcAbstAlphObs (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans) |
void | calcAbstAlphMSA (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents) |
void | calcAbstAlphMSA (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents) |
void | calcAbstAlphMSA (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans) |
void | backwardReachabilityObsOCC (const TransSetX2EvX1 &rTransSetX2EvX1, const EventSet &rControllableEvents, const EventSet &rHighAlph, Idx exitState, Idx currentState, bool controllablePath, map< Idx, map< Idx, bool > > &rExitLocalStatesMap, StateSet &rDoneStates) |
void | calcAbstAlphObsLCC (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents) |
void | calcAbstAlphObsLCC (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans) |
void | calcAbstAlphMSALCC (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents) |
void | calcAbstAlphMSALCC (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans) |
bool | relabel (Generator &rGenRelabel, EventSet &rControllableEvents, EventSet &rHighAlph, vector< Idx > &rNewPartitions, map< Idx, Idx > &rMapStateToPartition, map< Transition, Transition > &rMapChangedTransReverse, map< Transition, Idx > &rMapChangedTrans, map< Idx, EventSet > &rMapRelabeledEvents) |
void | insertRelabeledEvents (System &rGenPlant, const map< Idx, set< Idx > > &rMapRelabeledEvents, Alphabet &rNewEvents) |
void | insertRelabeledEvents (Generator &rGenPlant, const map< Idx, set< Idx > > &rMapRelabeledEvents, EventSet &rNewEvents) |
void | insertRelabeledEvents (System &rGenPlant, const map< Idx, set< Idx > > &rMapRelabeledEvents) |
void | insertRelabeledEvents (Generator &rGenPlant, const map< Idx, set< Idx > > &rMapRelabeledEvents) |
void | calcAbstAlphObs (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, EventRelabelMap &rMapRelabeledEvents) |
| Rti convenience wrapper.
|
void | insertRelabeledEvents (Generator &rGenPlant, const EventRelabelMap &rMapRelabeledEvents, EventSet &rNewEvents) |
| Rti convenience wrapper.
|
void | insertRelabeledEvents (Generator &rGenPlant, const EventRelabelMap &rMapRelabeledEvents) |
| Rti convenience wrapper.
|
void | ExtendHighAlphabet (const Generator &rGenObs, EventSet &rHighAlph, std::map< Idx, Idx > &rMapStateToPartition) |
| Extension of the high-level alphabet to achieve the Lm-observer property.
|
bool | CheckSplit (const Generator &rGenObs, const EventSet &rSplitAlphabet, const std::vector< std::pair< StateSet, Idx > > &rNondeterministicStates, Idx entryState) |
| Check if the current alphabet splits all local automata with nondeterminims or unobservable transitions.
|
void | calcAbstAlphClosed (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents) |
| L(G)-observer computation.
|
void | calcAbstAlphClosed (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents) |
| L(G)-observer computation.
|
void | calcAbstAlphClosed (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans) |
| L(G)-observer computation.
|
void | calcAbstAlphObs (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents) |
| Lm-observer computation.
|
void | calcAbstAlphObs (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents) |
| Lm-observer computation.
|
void | calcAbstAlphObs (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans) |
| Lm-observer computation.
|
void | calcAbstAlphMSA (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents) |
| MSA-observer computation.
|
void | calcAbstAlphMSA (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents) |
| MSA-observer computation.
|
void | calcAbstAlphMSA (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans) |
| MSA-observer computation.
|
void | calcAbstAlphObsLCC (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents) |
| Lm-observer computation including output control consistency (OCC).
|
void | calcAbstAlphObsLCC (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans) |
| Lm-observer computation including local control consistency (LCC).
|
void | calcAbstAlphMSALCC (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents) |
| MSA-observer computation including local control consistency (LCC).
|
void | calcAbstAlphMSALCC (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans) |
| MSA-observer computation including local control consistency (LCC).
|
bool | relabel (Generator &rGenRelabel, EventSet &rControllableEvents, EventSet &rHighAlph, std::vector< Idx > &rNewPartitions, std::map< Idx, Idx > &rMapStateToPartition, std::map< Transition, Transition > &rMapChangedTransReverse, std::map< Transition, Idx > &rMapChangedTrans, std::map< Idx, EventSet > &rMapRelabeledEvents) |
| Relabeling algorithm for the computation of an Lm-observer.
|
void | insertRelabeledEvents (System &rGenPlant, const std::map< Idx, std::set< Idx > > &rMapRelabeledEvents, Alphabet &rNewEvents) |
| Convenience function for relabeling events in a given generator.
|
void | insertRelabeledEvents (Generator &rGenPlant, const std::map< Idx, std::set< Idx > > &rMapRelabeledEvents, EventSet &rNewEvents) |
| Convenience function for relabeling events in a given generator.
|
void | insertRelabeledEvents (System &rGenPlant, const std::map< Idx, std::set< Idx > > &rMapRelabeledEvents) |
| Convenience function for relabeling events in a given generator.
|
void | insertRelabeledEvents (Generator &rGenPlant, const std::map< Idx, std::set< Idx > > &rMapRelabeledEvents) |
| Convenience function for relabeling events in a given generator.
|
bool | IsObs (const Generator &rLowGen, const EventSet &rHighAlph) |
| Verification of the natural observer property.
|
bool | IsMSA (const Generator &rLowGen, const EventSet &rHighAlph) |
| Verification of the MSA observer property.
|
bool | IsOCC (const System &rLowGen, const EventSet &rHighAlph) |
| Verification of output control consistency (OCC).
|
bool | IsOCC (const Generator &rLowGen, const EventSet &rControllableEvents, const EventSet &rHighAlph) |
| Verification of output control consistency (OCC).
|
bool | backwardVerificationOCC (const Generator &rLowGen, const EventSet &rControllableEvents, const EventSet &rHighAlph, Idx currentState) |
| Function that supports the verification of output control consistency (OCC).
|
bool | IsLCC (const System &rLowGen, const EventSet &rHighAlph) |
| Verification of local control consistency (LCC).
|
bool | IsLCC (const Generator &rLowGen, const EventSet &rControllableEvents, const EventSet &rHighAlph) |
| Verification of local control consistency (LCC).
|
void | backwardVerificationLCC (const TransSetX2EvX1 &rTransSetX2EvX1, const EventSet &rControllableEvents, const EventSet &rHighAlph, Idx exitState, Idx currentState, bool controllablePath, std::map< Idx, bool > &rLocalStatesMap, StateSet &rDoneStates) |
| Function that supports the verification of local control consistency (LCC).
|
bool | LocalObservationConsistency (const System &rPlantGen, const System &rSpecGen, const EventSet &rHighAlph, const EventSet &rObsAlph) |
| Supervisor Reduction algorithm.
|
bool | IsCoDiagnosable (const System &rGen, const Generator &rSpec, const vector< const EventSet * > &rAlphabets, std::string &rReportString) |
bool | DecentralizedDiagnoser (const System &rGen, const Generator &rSpec, const std::vector< const EventSet * > &rAlphabets, std::vector< Diagnoser * > &rDiags, std::string &rReportString) |
| Computes decentralized diagnosers for multiple local sites.
|
bool | IsCoDiagnosable (const System &rGen, const Generator &rSpec, const EventSetVector &rAlphabets) |
| Function definition for run-time interface.
|
bool | DecentralizedDiagnoser (const System &rGen, const Generator &rSpec, const EventSetVector &rAlphabets, GeneratorVector &rDiags) |
| Function definition for run-time interface.
|
void | DecentralizedModularDiagnoser (const SystemVector &rGens, const Generator &rSpec, GeneratorVector &rDiags) |
| Function definition for run-time interface.
|
void | cParallel (const std::vector< const System * > &rGens, System &rResGen) |
| Parallel composition of multiple generators.
|
bool | IsEventDiagnosable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, string &rReportString) |
bool | IsEventDiagnosable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap) |
| Function definition for run-time interface.
|
bool | IsIndicatorEventDiagnosable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, string &rReportString) |
bool | IsIndicatorEventDiagnosable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap) |
| Function definition for run-time interface.
|
bool | MeetsDiagnosabilityAssumptions (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, string &rReportString) |
void | ConvertParallelCompositionMap (const map< pair< Idx, Idx >, Idx > &rReverseCompositionMap, map< Idx, pair< Idx, Idx > > &rCompositionMap) |
bool | IsLive (const System &rGen, string &rReport) |
bool | CycleOfUnobsEvents (const System &rGen, string &rReport) |
bool | FailuresUnobservable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, string &rReport) |
bool | ExistsCycle (const System &rGen, string &rReport) |
bool | ExistsCycleSearch (const System &rGen, StateSet &rTodo, Idx currState, StateSet statesOnPath, string &rReport) |
void | CycleStartStates (const System &rGen, StateSet &rCycleOrigins) |
| Find all start/end states of cycles of unobservable events in a generator.
|
void | CycleStartStatesSearch (const System &rGen, StateSet &rTodo, Idx currState, StateSet statesOnPath, StateSet &rCycleOriginStates) |
| Auxiliary function for CycleStartStates().
|
bool | ExistsViolatingCyclesInGd (System &rGd, const Diagnoser &rGobs, map< pair< Idx, Idx >, Idx > &rReverseCompositionMap, const string &rFailureType, string &rReportString) |
void | ComputeGobs (const System &rOrigGen, const string &rFailureType, const EventSet &rFailureEvents, Diagnoser &rGobs) |
void | ComputeGobs (const System &rOrigGen, const AttributeFailureTypeMap &rAttrFTMap, Diagnoser &rGobs) |
| Compute G_o for a given generator with a given failure partition (according to Jiang).
|
void | ComputeGd (const Diagnoser &rGobs, map< pair< Idx, Idx >, Idx > &rReverseCompositionMap, System &rGd) |
void | TrimNonIndicatorTracesOfGd (System &rGd, const Diagnoser &rGobs, const Idx rFailureType, const EventSet &rIndicatorEvents, const map< pair< Idx, Idx >, Idx > &rReverseCompositionMap) |
void | TrimNonIndicatorTracesOfGdRecursive (System &rGd, const Diagnoser &rGobs, const Idx rFailureType, const EventSet &rIndicatorEvents, map< Idx, pair< Idx, Idx > > &rCompositionMap, Idx state, StateSet &rStatesDone) |
void | ComputeReachability (const System &rGen, const EventSet &rUnobsEvents, const EventSet &rFailures, Idx State, const AttributeFailureTypeMap &rAttrFTMap, map< Idx, multimap< Idx, DiagLabelSet > > &rReachabilityMap) |
void | ComputeReachabilityRecursive (const System &rGen, const EventSet &rUnobsEvents, const EventSet &rFailures, Idx State, const AttributeFailureTypeMap &rAttrFTMap, map< Idx, multimap< Idx, DiagLabelSet > > &rReachabilityMap, const DiagLabelSet FToccurred) |
TransSet | ActiveBackwardTransSet (const System &rGen, Idx state) |
| Obtain all transitions from other states into a given state of a generator.
|
void | EventDiagnoser (const System &rOrigGen, const map< string, EventSet > &rFailureTypeMap, Diagnoser &rDiagGen) |
void | LabelPropagation (const DiagLabelSet &lastLabel, const DiagLabelSet &failureTypes, DiagLabelSet &newLabel) |
| Generate a new label.
|
void | LabelCorrection (const multimap< Idx, DiagLabelSet > &mm, AttributeDiagnoserState &attr) |
void | ConvertParallelCompositionMap (const std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, std::map< Idx, std::pair< Idx, Idx > > &rCompositionMap) |
| Convert the reverse composition map of Parallel() by switching first and second entry.
|
bool | IsLive (const System &rGen, std::string &rReport) |
| Test if a generator is live.
|
bool | CycleOfUnobsEvents (const System &rGen, std::string &rReport) |
| Test if there exist any cycles of unobservable events in a generator.
|
bool | FailuresUnobservable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, std::string &rReport) |
| Check if all failure events are unobservable events in a generator's alphabet.
|
bool | ExistsCycle (const System &rGen, std::string &rReport) |
| Test if there exist any cycles in a generator.
|
bool | ExistsCycleSearch (const System &rGen, StateSet &rTodo, Idx currState, StateSet statesOnPath, std::string &rReport) |
| Auxiliary function for ExistsCycle(const System&, std::string&).
|
bool | ExistsViolatingCyclesInGd (System &rGd, const Diagnoser &rGobs, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, const std::string &rFailureType, std::string &rReportString) |
| Remove states with same failure labels from rGd and from rReverseCompositionMap and perform cycle detection.
|
void | ComputeGobs (const System &rOrigGen, const std::string &rFailureType, const EventSet &rFailureEvents, Diagnoser &rGobs) |
| Compute G_o for a single failure type of a generator.
|
void | ComputeGd (const Diagnoser &rGobs, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, System &rGd) |
| Compute the diagnosability testing generator G_d as a parallel composition of G_o with itself (according to Jiang).
|
void | TrimNonIndicatorTracesOfGd (System &rGd, const Diagnoser &rGobs, const Idx rFailureType, const EventSet &rIndicatorEvents, const std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap) |
| Extract all traces of a generator G_d that start with an indicator event that follows a failure event of a certain failure type.
|
void | TrimNonIndicatorTracesOfGdRecursive (System &rGd, const Diagnoser &rGobs, const Idx rFailureType, const EventSet &rIndicatorEvents, std::map< Idx, std::pair< Idx, Idx > > &rCompositionMap, Idx state, StateSet &rStatesDone) |
| Auxiliary function for TrimNonIndicatorTracesOfGd().
|
void | ComputeReachability (const System &rGen, const EventSet &rUnobsEvents, const EventSet &rFailures, Idx State, const AttributeFailureTypeMap &rAttrFTMap, std::map< Idx, std::multimap< Idx, DiagLabelSet > > &rReachabilityMap) |
| Compute the reachability from a given generator state through a trace that consists of arbitrarily many unobservable events followed by one observable event.
|
void | ComputeReachabilityRecursive (const System &rGen, const EventSet &rUnobsEvents, const EventSet &rFailures, Idx State, const AttributeFailureTypeMap &rAttrFTMap, std::map< Idx, std::multimap< Idx, DiagLabelSet > > &rReachabilityMap, const DiagLabelSet FToccurred) |
| Auxiliary function for ComputeReachability(const System&, const EventSet&, const EventSet&, Idx, const AttributeFailureTypeMap&, std::map<Idx,std::multimap<Idx,DiagLabelSet>>&).
|
void | EventDiagnoser (const System &rOrigGen, const std::map< std::string, EventSet > &rFailureTypeMap, Diagnoser &rDiagGen) |
| Compute a standard diagnoser from an input generator and a failure partition.
|
void | LabelCorrection (const std::multimap< Idx, DiagLabelSet > &mm, AttributeDiagnoserState &attr) |
| Perform label correction on propagated failure type labels.
|
bool | IsLanguageDiagnosable (const System &rGen, const System &rSpec) |
| Function definition for run-time interface.
|
void | ComputeGobs (const System &rGenMarkedNonSpecBehaviour, Diagnoser &rGobs) |
| Compute G_o for a generator that marks the faulty behaviour of a plant.
|
void | ComputeReachability (const System &rGen, const EventSet &rUnobsEvents, Idx State, map< Idx, multimap< Idx, DiagLabelSet > > &rReachabilityMap) |
void | ComputeReachabilityRecursive (const System &rGen, const EventSet &rUnobsEvents, Idx State, StateSet done, map< Idx, multimap< Idx, DiagLabelSet > > &rReachabilityMap) |
bool | IsLanguageDiagnosable (const System &rGen, const System rSpec, std::string &rReportString) |
| Test function to verify language-diagnosability.
|
bool | rec_ComputeLoopPreservingObserver (const System &rGen, const EventSet &rInitialHighAlph, EventSet &rHighAlph, const std::vector< Idx > &rDdffVector, Idx numberEvents, Idx currentNumberEvents, Idx currentLocation, EventSet chosenEvents) |
| rec_ComputeLoopPreservingObserver(rGen, rInitialHighAlph, rHighAlph, rDdffVector, numberEvents, currentNumberEvents, currentLocation, hosenEvents)
|
void | ComputeReachability (const System &rGen, const EventSet &rUnobsEvents, Idx State, std::map< Idx, std::multimap< Idx, DiagLabelSet > > &rReachabilityMap) |
| Compute the reachability from a state of a generator that marks its faulty behaviour.
|
void | ComputeReachabilityRecursive (const System &rGen, const EventSet &rUnobsEvents, Idx State, StateSet done, std::map< Idx, std::multimap< Idx, DiagLabelSet > > &rReachabilityMap) |
| Auxiliary function for ComputeReachability(const System&, const EventSet&, Idx State, std::map<Idx,std::multimap< Idx,DiagLabelSet> >&).
|
bool | IsModularDiagnosable (const SystemVector &rGsubs, const GeneratorVector &rKsubs, string &rReportString) |
bool | IsModularDiagnosable (const vector< const System * > &rGSubs, const vector< const Generator * > &rKSubs, std::string &rReportString) |
bool | ModularDiagnoser (const SystemVector &rGsubs, const GeneratorVector &rKsubs, GeneratorVector &rDiagSubs, string &rReportString) |
bool | ModularDiagnoser (const std::vector< const System * > &rGsubs, const std::vector< const Generator * > &rKsubs, std::vector< Diagnoser * > &rDiagsubs, std::string &rReportString) |
| Checks modular diagnosability for a system G (which consists of the subsystems rGsubs) with respect to the specification K (consisting of local specifications rKsubs) and the local abstraction alphabets rHighAlphSubs.
|
bool | IsModularDiagnosable (const SystemVector &rGsubs, const GeneratorVector &rKsubs) |
| Function definition for run-time interface.
|
bool | ModularDiagnoser (const SystemVector &rGsubs, const GeneratorVector &rKsubs, GeneratorVector &rDiagsubs) |
| Function definition for run-time interface.
|
void | cParallel (const vector< System > &rGens, System &rResGen) |
bool | IsModularDiagnosable (const std::vector< const System * > &rGsubs, const std::vector< const Generator * > &rKsubs, std::string &rReportString) |
| Checks modular diagnosability for a system G (which consists of the subsystems rGsubs) with respect to the specification K (consisting of local specifications rKsubs) and the local abstraction alphabets rHighAlphSubs.
|
void | cParallel (const std::vector< System > &rGens, System &rResGen) |
| Parallel composition of multiple generators.
|
bool | IsHioConstraintForm (HioConstraint &rHioConstraint, StateSet &rQY, StateSet &rQU, EventSet &rErrEvSet, TransSet &rErrTrSet, StateSet &rErrStSet, std::string &rReportStr) |
| IsHioConstraintForm: check if rHioConstraint is in I/O-constraint form and assign state attributes.
|
bool | IsHioConstraintForm (HioConstraint &rHioConstraint, std::string &rReportStr) |
| IsHioConstraintForm: check if rHioConstraint is in I/O-constraint form and assign state attributes.
|
bool | IsHioConstraintForm (HioConstraint &rHioConstraint) |
| IsHioConstraintForm: check if rHioConstraint is in I/O-constraint form and assign state attributes.
|
void | HioStatePartition (HioConstraint &rConstraint) |
| Function definition for run-time interface.
|
bool | IsHioControllerForm (HioController &rHioController, StateSet &rQUc, StateSet &rQYP, StateSet &rQUp, StateSet &rQYcUp, EventSet &rErrEvSet, TransSet &rErrTrSet, StateSet &rErrStSet, std::string &rReportStr) |
| IsHioControllerForm: check if rHioController is in I/O-controller form and assign state attributes.
|
bool | IsHioControllerForm (HioController &rHioController, std::string &rReportStr) |
| IsHioControllerForm: check if rHioController is in I/O-controller form and assign state attributes.
|
bool | IsHioControllerForm (HioController &rHioController) |
| IsHioControllerForm: check if rHioController is in I/O-controller form and assign state attributes.
|
void | HioStatePartition (HioController &rController) |
| Function definition for run-time interface.
|
bool | IsHioEnvironmentForm (HioEnvironment &rHioEnvironment, StateSet &rQYe, StateSet &rQUe, StateSet &rQUl, StateSet &rQYlUe, EventSet &rErrEvSet, TransSet &rErrTrSet, StateSet &rErrStSet, std::string &rReportStr) |
| IsHioEnvironmentForm: check if rHioEnvironment is in I/O-environment form and assign state attributes.
|
bool | IsHioEnvironmentForm (HioEnvironment &rHioEnvironment, std::string &rReportStr) |
| IsHioEnvironmentForm: check if rHioEnvironment is in I/O-environment form and assign state attributes.
|
bool | IsHioEnvironmentForm (HioEnvironment &rHioEnvironment) |
| IsHioEnvironmentForm: check if rHioEnvironment is in I/O-environment form and assign state attributes.
|
void | HioStatePartition (HioEnvironment &rEnvironment) |
| Function definition for run-time interface.
|
bool | SupNormSP (Generator &rL, const EventSet &rOAlph, const Generator &rK, Generator &rResult) |
bool | CompleteSynth (const Generator &rPlant, const EventSet rCAlph, const Generator &rSpec, Generator &rClosedLoop) |
| CompleteSynth: compute supremal complete and controllable (and closed) sublanguage.
|
bool | NormalCompleteSynth (Generator &rPlant, const EventSet &rCAlph, const EventSet &rOAlph, const Generator &rSpec, Generator &rClosedLoop) |
| NormalCompleteSynth: compute normal, complete and controllable (and closed) sublanguage.
|
bool | NormalCompleteSynthNB (Generator &rPlant, const EventSet &rCAlph, const EventSet &rOAlph, const Generator &rSpec, Generator &rClosedLoop) |
| NormalCompleteSynthNB: compute normal, complete, controllable and nonblocking sublanguage.
|
Generator | HioSortCL (const EventSet &rYc, const EventSet &rUc, const EventSet &rYp, const EventSet &rUp, const EventSet &rYe, const EventSet &rUe) |
| IoSortCL: returns IO-sorting structure required for closed loops.
|
void | HioFreeInput (const Generator &rGen, const EventSet &rInput, const EventSet &rOutput, Generator &rResGen, const std::string &rErrState1, const std::string &rErrState2, Idx &rErrState1Idx, Idx &rErrState2Idx) |
| HioFreeInput: extend generator by obviously missing input transitions.
|
void | HioFreeInput (const Generator &rGen, const EventSet &rInput, const EventSet &rOutput, Generator &rResGen, const std::string &rErrState1, const std::string &rErrState2) |
| HioFreeInput: extend generator by obviously missing input transitions.
|
void | HioFreeInput (const Generator &rGen, const EventSet &rInput, const EventSet &rOutput, Generator &rResGen) |
| HioFreeInput: extend generator by obviously missing input transitions.
|
void | HioFreeInput (const HioPlant &rPlant, HioPlant &rResPlant) |
| HioFreeInput: extend HioPlant by obviously missing input transitions.
|
void | HioFreeInput (const HioController &rController, HioController &rResController) |
| HioFreeInput: extend HioController by obviously missing input transitions.
|
void | HioFreeInput (const HioEnvironment &rEnvironment, HioEnvironment &rResEnvironment) |
| HioFreeInput: extend HioEnvironment by obviously missing input transitions.
|
void | HioFreeInput (const HioConstraint &rConstraint, HioConstraint &rResConstraint) |
| HioFreeInput: extend HioConstraint by obviously missing input transitions.
|
void | HioFreeInput (HioPlant &rPlant) |
| HioFreeInput: convenience interface to faudes::HioFreeInput(const HioPlant&, HioPlant).
|
void | HioFreeInput (HioController &rController) |
| HioFreeInput: convenience interface to faudes::HioFreeInput(const HioController&, HioController).
|
void | HioFreeInput (HioEnvironment &rEnvironment) |
| HioFreeInput: convenience interface to faudes::HioFreeInput(const HioEnvironment&, HioEnvironment).
|
void | HioFreeInput (HioConstraint &rConstraint) |
| HioFreeInput: convenience interface to faudes::HioFreeInput(const HioConstraint&, HioConstraint).
|
void | MarkHioShuffle (const Generator &rGen1, const Generator &rGen2, const std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, Generator &rShuffle) |
| MarkHioShuffle: marking rule for HioShuffle() in case of marked parameters rGen1 and rGen2 - UNDER CONSTRUCTION.
|
void | MarkAlternationAB (const EventSet rAset, const EventSet rBset, Generator &rAltAB) |
| MarkAlternationAB: returns Generator marking the alternation of Aset-transitions with Bset-transitions.
|
void | HioShuffleUnchecked (const Generator &rPlantA, const Generator &rPlantB, const EventSet &rYp, const EventSet &rUp, const EventSet &rYe, const EventSet &rUe, Generator &rIOShuffAB) |
| HioShuffleUnchecked: IO-shuffle of rPlantA and rPlantB according to definition, no parameter check.
|
void | HioShuffle (const Generator &rPlantA, const Generator &rPlantB, const EventSet &rYp, const EventSet &rUp, const EventSet &rYe, const EventSet &rUe, Generator &rIOShuffAB) |
| HioShuffle: IO-shuffle of rPlantA and rPlantB according to definition.
|
void | HioShuffle (const HioPlant &rPlantA, const HioPlant &rPlantB, HioPlant &rIOShuffAB) |
| HioShuffle: IO-shuffle of rPlantA and rPlantB according to definition.
|
void | CheapAltAnB (const EventSet rAset, const EventSet rBset, const int Depth, Generator &rAltAnB) |
| CheapAltAnB: returns Generator of the following specification: "After a maximum of n (=depth) pairs of
A-transitions, a B-transition has to occur!".
|
void | CheapAltAB (const EventSet rAset, const EventSet rBset, const int Depth, Generator &rAltAB) |
| CheapAltAB: returns Generator of the following specification: "After a maximum of n (=depth) pairs of
A-transitions, a B-transition has to occur and vice-versa!".
|
void | HioShuffleTU (const Generator &rPlantA, const Generator &rPlantB, const EventSet &rYp, const EventSet &rUp, const EventSet &rYe, const EventSet &rUe, const int Depth, Generator &rIOShuffAB) |
| HioShuffleTU: IO-shuffle of rPlantA and rPlantB according to definition with additional forced alternation of depth Depth (see CheapAltAB()) between A- and B-events.
|
void | SearchYclessScc (const Idx state, int &rcount,const Generator &rGen, const EventSet &rYc, const bool UnMarkedOnly, StateSet &rNewStates, std::stack< Idx > &rSTACK, StateSet &rStackStates, std::map< const Idx, int > &rDFN, std::map< const Idx, int > &rLOWLINK, std::set< StateSet > &rSccSet, StateSet &rRoots) |
| SearchYclessSCC: Search for strongly connected ycless components (YC-less SCC's).
|
bool | YclessScc (const Generator &rGen, const EventSet &rYc, std::set< StateSet > &rSccSet, StateSet &rRoots) |
| YclessSCC: Search for strongly connected ycless components (YC-less SCC's) - convenience api.
|
bool | YclessUnmarkedScc (const Generator &rGen, const EventSet &rYc, std::set< StateSet > &rSccSet, StateSet &rRoots) |
| YclessUnmarkedSCC: Search for strongly connected ycless components (YC-less SCC's) consisting of unmarked states only.
|
bool | YclessScc (const Generator &rGen, const EventSet &rYc, std::set< StateSet > &rSccSet) |
bool | IsYcLive (const Generator &rGen, const EventSet &rYc) |
| IsYcLive: This function checks if generator is Yc-live.
|
void | WriteStateSets (const std::set< StateSet > &rStateSets) |
| WriteStateSets: Write set of StateSet's to console (indeces).
|
void | WriteStateSets (const Generator &rGen, const std::set< StateSet > &rStateSets) |
| WriteStateSets: Write set of StateSet's to console (symbolic state names taken from rGen).
|
void | SccEntries (const Generator &rGen, const std::set< StateSet > &rSccSet, StateSet &rEntryStates, TransSetX2EvX1 &rEntryTransSet) |
| SCCEntries: figure entry states and entry transitions of strongly connected components rSccSet of rGen.
|
void | CloneScc (Generator &rGen, const StateSet &rScc, std::set< StateSet > &rSccSet, const Idx EntryState, StateSet &rEntryStates, TransSetX2EvX1 &rEntryTransSet) |
| cloneSCC: makes a copy (clone) of strongly connected component (rSCC) of the generator and moves all transitions leading to some entry state EntryState of this SCC to the copy of EntryState.
|
void | CloneUnMarkedScc (Generator &rGen, const StateSet &rScc, const Idx EntryState, const StateSet &rEntryStates, TransSetX2EvX1 &rEntryTransSet) |
| CloneUnMarkedSCC: makes a copy (clone) of strongly connected unmarked component (rSCC) of rGen.
|
void | YcAcyclic (const Generator &rGen, const EventSet &rYc, Generator &rResGen) |
| YcAcyclic: Computes the supremal(?) Yc-acyclic sublanguage of L(Gen).
|
void | ConstrSynth_Beta (Generator &rPlant, const EventSet &rYp, const EventSet &rUp, const Generator &rLocConstr, Generator &rOpConstraint) |
| ConstrSynth_Beta: compute operator constraint Sp for plant under environment constraint Sl such that plant is complete & Yp-live wrt both constraints - Beta Version.
|
void | HioSynthUnchecked (const Generator &rPlant, const Generator &rSpec, const Generator &rConstr, const Generator &rLocConstr, const EventSet &rYc, const EventSet &rUc, const EventSet &rYp, const EventSet &rUp, const EventSet &rYel, const EventSet &rUel, Generator &rController) |
| HioSynthUnchecked: I/O controller synthesis procedure, no parameter check.
|
void | HioSynth (const Generator &rPlant, const Generator &rSpec, const Generator &rConstr, const Generator &rLocConstr, const EventSet &rYc, const EventSet &rUc, const EventSet &rYp, const EventSet &rUp, const EventSet &rYel, const EventSet &rUel, Generator &rController) |
| HioSynthUnchecked: I/O controller synthesis procedure.
|
void | HioSynthMonolithic (const HioPlant &rPlant, const HioPlant &rSpec, const HioConstraint &rSc, const HioConstraint &rSp, const HioConstraint &rSe, HioController &rController) |
| HioSynthMonolithic: I/O controller synthesis procedure for monolithic plant.
|
void | HioSynthHierarchical (const HioPlant &rHioShuffle, const HioEnvironment &rEnvironment, const HioPlant &rSpec, const Generator &rIntConstr, const HioConstraint &rSc, const HioConstraint &rSl, HioController &rController) |
| HioSynthHierarchical: I/O controller synthesis procedure for I/O-shuffle of i plants and their interaction via an I/O environment.
|
void | HioShuffle_Musunoi (const HioPlant &rPlantA, const HioPlant &rPlantB, int depth, Generator &rIOShuffAB) |
void | HioSynth_Musunoi (const Generator &rPlant, const HioPlant &rSpec, const Generator &rConstr, const Generator &rLocConstr, const EventSet &rYp, const EventSet &rUp, Generator &rController) |
bool | YclessSCC (const Generator &rGen, const EventSet &rYc, std::set< StateSet > &rSccSet) |
| YclessSCC: Search for strongly connected ycless components (YC-less SCC's) - convenience api.
|
void | AdjustHioController (const HioController &rHioController, const HioModule *rHioModule1, const HioModule *rHioModule2, HioController &rResEnv) |
void | GroupHioModules (const std::vector< HioModule * > &rChildren, HioModule &rParentModule) |
| GroupHioModules: This function groups two or more HioModules to a new HioModule.
|
void | CreateSpec (int mType[5], HioPlant &rHioSpec, Generator &constrP, Generator &constrE) |
| This function creates new specification given by the type ("xxxxx") Note: The core of this function is a template specification model (SpecCB12.gen).
|
void | CreateConstraint (int mType[5], Generator &constrP, Generator &constrE) |
| This function creates constraints which describe the condition of completeness and Yp-liveness of a Specification.
|
bool | IsHioPlantForm (HioPlant &rHioPlant, StateSet &rQYpYe, StateSet &rQUp, StateSet &rQUe, EventSet &rErrEvSet, TransSet &rErrTrSet, StateSet &rErrStSet, std::string &rReportStr) |
| IsHioPlantForm: check if rHioPlant is in I/O-plant form and assign state attributes.
|
bool | IsHioPlantForm (HioPlant &rHioPlant, std::string &rReportStr) |
| IsHioPlantForm: check if rHioPlant is in I/O-plant form and assign state attributes.
|
bool | IsHioPlantForm (HioPlant &rHioPlant) |
| IsHioPlantForm: check if rHioPlant is in I/O-plant form and assign state attributes.
|
void | HioStatePartition (HioPlant &rPlant) |
| Function definition for run-time interface.
|
bool | IsIoSystem (const IoSystem &rIoSystem, StateSet &rQU, StateSet &rQY, StateSet &rQErr) |
| Test whether the system satisfies basic I/O conditions.
|
bool | IsIoSystem (IoSystem &rIoSystem) |
| Test whether the system satisfies the IO conditions.
|
void | IoStatePartition (IoSystem &rIoSystem) |
| Construct io state partition.
|
bool | IsInputLocallyFree (IoSystem &rIoSystem) |
| Test whether the system has a locally free input.
|
bool | IsInputLocallyFree (const IoSystem &rIoSystem, StateSet &rQErr) |
| Test whether the system has a locally free input.
|
bool | IsInputOmegaFree (IoSystem &rIoSystem) |
| Test whether the system behaviour has exhibits a free input.
|
bool | IsInputOmegaFree (const IoSystem &rIoSystem, StateSet &rQErr) |
| Test whether the system behaviour exhibits a free input.
|
void | IoFreeInput (IoSystem &rIoSystem) |
| Enable all input events for each input state.
|
void | IoFreeInput (Generator &rIoSystem, const EventSet &rUAlph) |
| Enable all input events for each input state.
|
void | RemoveIoDummyStates (IoSystem &rIoSystem) |
| Remove dummy states.
|
void | IoSynthesisNB (const IoSystem &rPlant, const Generator &rSpec, IoSystem &rSup) |
| IO system synthesis.
|
void | IoSynthesis (const IoSystem &rPlant, const Generator &rSpec, IoSystem &rSup) |
| IO system synthesis.
|
bool | IsStronglyCoaccessible (const MtcSystem &rGen) |
| RTI wrapper function.
|
bool | IsStronglyTrim (const MtcSystem &rGen) |
| RTI wrapper function.
|
void | StronglyCoaccessible (MtcSystem &rGen) |
| RTI wrapper function.
|
void | StronglyCoaccessible (const MtcSystem &rGen, MtcSystem &rRes) |
| RTI wrapper function.
|
void | StronglyTrim (MtcSystem &rGen) |
| RTI wrapper function.
|
void | StronglyTrim (const MtcSystem &rGen, MtcSystem &rRes) |
| RTI wrapper function.
|
Idx | calcNaturalObserver (const MtcSystem &rGen, EventSet &rHighAlph) |
| Calculate a colored natural observer by extending a given high-level alphabet.
|
void | calcAbstAlphObs (MtcSystem &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents) |
void | calcAbstAlphObs (MtcSystem &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents) |
void | calcAbstAlphObs (MtcSystem &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans) |
void | calculateDynamicSystemObs (const MtcSystem &rGen, EventSet &rHighAlph, Generator &rGenDyn) |
| Computation of the dynamic system for an Lm-observer.
|
void | calcAbstAlphObs (MtcSystem &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents) |
| Lm-observer computation.
|
void | calcAbstAlphObs (MtcSystem &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents) |
| Lm-observer computation.
|
void | calcAbstAlphObs (MtcSystem &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans) |
| Lm-observer computation.
|
bool | IsMtcObs (const MtcSystem &rLowGen, const EventSet &rHighAlph) |
| Verification of the observer property.
|
void | mtcParallel (const MtcSystem &rGen1, const MtcSystem &rGen2, MtcSystem &rResGen) |
| Parallel composition of two colored marking generators, controllability status is observed.
|
void | mtcParallel (const MtcSystem &rGen1, const MtcSystem &rGen2, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, MtcSystem &rResGen) |
| Parallel composition of two MtcSystems.
|
void | ComposedColorSet (const MtcSystem &rGen1, const Idx stdidx1, ColorSet &colors1, const MtcSystem &rGen2, const Idx stdidx2, ColorSet &colors2, ColorSet &composedSet) |
| Compose the color set for a state combined from two states in two distinct automata.
|
void | mtcUniqueInit (MtcSystem &rGen) |
void | mtcDeterministic (const MtcSystem &rGen, MtcSystem &rResGen) |
| Make generator deterministic.
|
void | mtcDeterministic (const MtcSystem &rGen, std::map< Idx, StateSet > &rEntryStatesMap, MtcSystem &rResGen) |
| Make generator deterministic.
|
void | mtcDeterministic (const MtcSystem &rGen, std::vector< StateSet > &rPowerStates, std::vector< Idx > &rDetStates, MtcSystem &rResGen) |
| Make generator deterministic.
|
void | mtcProjectNonDet (MtcSystem &rGen, const EventSet &rProjectAlphabet) |
| Project generator to alphabet rProjectAlphabet.
|
void | mtcProjectNonDet (const MtcSystem &rGen, const EventSet &rProjectAlphabet, MtcSystem &rResGen) |
| Project generator to alphabet rProjectAlphabet.
|
void | mtcProject (const MtcSystem &rGen, const EventSet &rProjectAlphabet, MtcSystem &rResGen) |
| Minimized Deterministic projection.
|
void | mtcProject (const MtcSystem &rGen, const EventSet &rProjectAlphabet, std::map< Idx, StateSet > &rEntryStatesMap, MtcSystem &rResGen) |
| Minimized Deterministic projection.
|
void | mtcInvProject (MtcSystem &rGen, const EventSet &rProjectAlphabet) |
| Inverse projection.
|
void | mtcInvProject (const MtcSystem &rGen, const EventSet &rProjectAlphabet, MtcSystem &rResGen) |
| RTI wrapper.
|
void | SearchScc (const Idx state, int &rCount, const Generator &rGen, StateSet &rNewStates, std::stack< Idx > &rSTACK, StateSet &rStackStates, std::map< const Idx, int > &rDFN, std::map< const Idx, int > &rLOWLINK, std::set< StateSet > &rSccSet, StateSet &rRoots) |
| Search for strongly connected components (SCC)*** This function partitions the stateset of a generator into equivalence classes such that states x1 and x2 are equivalent iff there is a path from x1 to x2 AND a path from x2 to x1.
|
bool | ComputeSCC (const Generator &rGen, std::set< StateSet > &rSccSet, StateSet &rRoots) |
| Computes the strongly connected components (SCCs) of an automaton.
|
void | ColoredSCC (MtcSystem &rGen, ColorSet &rColors, std::set< StateSet > &rColoredSCCs) |
| Compute all strongly connected components (SCCs) in a colored marking generator (CMG) that are marked with a given set of colors.
|
bool | CheckRedundantColor (MtcSystem rGen, Idx redundantColor) |
| Check if a color in a colored marking generator is redundant for the supervisor synthesis.
|
void | OptimalColorSet (const MtcSystem &rGen, ColorSet &rOptimalColors, EventSet &rHighAlph) |
| Compute an optimal subset of the colors that should be removed.
|
void | rec_OptimalColorSet (const MtcSystem &rGen, const std::vector< Idx > &rColorVector, Idx colorNumber, ColorSet &rOptimalColors, Idx &rOptimalNumberStates, Idx &rOptimalNumberColors, const EventSet &rHighAlph, EventSet &rOptimalHighAlph) |
| Recursively find an optimal set of colors to be removed.
|
void | mtcStateMin (MtcSystem &rGen, MtcSystem &rResGen) |
| State Minimization This function implements the (n*log n) set partitioning algorithm by John E.
|
void | mtcStateMin (MtcSystem &rGen, MtcSystem &rResGen, std::vector< StateSet > &rSubsets, std::vector< Idx > &rNewIndices) |
| State Minimization This function implements the (n*log n) set partitioning algorithm by John E.
|
void | mtcStateMin (const MtcSystem &rGen, MtcSystem &rResGen) |
| RTI wrapper.
|
void | mtcSupConNB (const MtcSystem &rPlantGen, const MtcSystem &rSpecGen, MtcSystem &rResGen) |
| Nonblocking Supremal Controllable Sublanguage (wrapper function).
|
void | mtcSupConNB (const MtcSystem &rPlantGen, const MtcSystem &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, MtcSystem &rResGen) |
| Nonblocking Supremal Controllable Sublanguage.
|
void | mtcSupConClosed (const MtcSystem &rPlantGen, const MtcSystem &rSpecGen, MtcSystem &rResGen) |
| Supremal Controllable Sublanguage (wrapper function).
|
void | mtcSupConClosed (const MtcSystem &rPlantGen, const MtcSystem &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, MtcSystem &rResGen) |
| Supremal Controllable Sublanguage.
|
void | mtcSupConParallel (const MtcSystem &rPlantGen, const MtcSystem &rSpecGen, const EventSet &rUAlph, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, MtcSystem &rResGen) |
| Fast parallel composition for computation for the mtcSupConNB.
|
void | mtcSupConUnchecked (const MtcSystem &rPlantGen, const EventSet &rCAlph, MtcSystem &rSupGen) |
| Supremal Controllable Sublangauge (Real SupCon function; unchecked).
|
bool | ccTrim (const Generator &gen, Generator &trimGen) |
| A more efficient Trim() operation.
|
bool | IsConditionalClosed (const GeneratorVector &specVect, const Generator &pk, const GeneratorVector &genVect, const Generator &gk) |
| Conditionalclosedness Checking Algorithm.
|
bool | IsConditionalControllable (const GeneratorVector &specVect, const Generator &pk, const GeneratorVector &genVect, const Generator &gk, const EventSet &ACntrl) |
| Conditionalcontrollability Checking Algorithm.
|
bool | IsConditionalDecomposable (const Generator &gen, const EventSetVector &rAlphabets, const EventSet &ek, Generator &proof) |
| Conditionaldecomposability Checking Algorithm.
|
void | ConDecExtension (const Generator &gen, const EventSetVector &rAlphabets, EventSet &ek) |
| Conditionaldecomposability Extension Algorithm.
|
Generator | ComputeTildeG (const EventSet &unionset, const EventSetVector &ee, const EventSet &ek, const Generator &gen) |
bool | isExtendedEk (const Generator &tildeGen, const Generator &rGen, EventSet &ek) |
bool | SupConditionalControllable (const Generator &gen, const GeneratorVector &genVector, const EventSet &ACntrl, const EventSet &InitEk, GeneratorVector &supVector, Generator &Coord) |
| Conditionalcontrollability Checking Algorithm.
|
StateSet | Transient (const PushdownGenerator &pd) |
| Get all states that are the starting state of a lambda reading transition.
|
PushdownGenerator | Rnce (const PushdownGenerator &pd, const System &s) |
| Remove non-controllable ears from a generator.
|
PushdownGenerator | Times (const System ®, const PushdownGenerator &pd) |
| synchronous product generator of a pushdown generator and a regular generator
|
void | IntersectEvents (const System &s, const PushdownGenerator &pd, PushdownGenerator &rPd) |
| Adds the intersection of events of the first two generators to the result generator.
|
PushdownGenerator | Split (const PushdownGenerator &pd) |
| Splits the states of a pushdown generator into heads and ears.
|
void | PushdownNonblock (const PushdownGenerator &pd, PushdownGenerator &res, bool print=false) |
| Make a pushdown generator nonblocking.
|
void | CorrectEvents (const PushdownGenerator &correctPd, PushdownGenerator &pd) |
| Sets controllability and observability flags for a pushdown generator's events to the event flags of another pushdown generator.
|
bool | Ts (const PushdownGenerator &pd, Idx state) |
| Test a state for reachability.
|
bool | Te (const PushdownGenerator &pd, const Transition &trans, const std::vector< Idx > &pop, const std::vector< Idx > &push) |
| Test a transition for reachability.
|
bool | Ruls1 (Idx state, const PushdownGenerator &pd) |
PushdownGenerator | Ruls (const PushdownGenerator &pd) |
| Remove useless states of a pushdown generator.
|
void | PushdownAccessible (const PushdownGenerator &pd, PushdownGenerator &res) |
| Construct the accessible part of a pushdown generator.
|
PushdownGenerator | Ccs (const PushdownGenerator &contr, const System &plant) |
| Single execution of the loop to construct a minimal restrictive sound controller.
|
PushdownGenerator | Ccl (const PushdownGenerator &contr, const System &plant, Idx iteration=0) |
| Looped exectuion of to construct a minimal restrictive sound controller.
|
void | PushdownConstructController (const PushdownGenerator &spec, const System &plant, PushdownGenerator &res) |
| Construct a minimal restrictive sound controller.
|
int | timeval_subtract (timeval *result, timeval *x, timeval *y) |
| from http://www.gnu.org/software/libc/manual/html_node/Elapsed-Time.html Calculates time difference x - y.
|
GrammarSymbolWordSet | PostCl (const GrammarSymbolVector &word) |
| Construct the postfix closure of a word.
|
GrammarSymbolWordSet | Fds (const Grammar &gr) |
| Determine certain words in a grammar.
|
GrammarSymbolWordMap | First1 (const Grammar &gr, const GrammarSymbolWordMap &f, bool *madeChanges) |
| Updates the function which maps words to their first possible terminal symbols.
|
GrammarSymbolWordMap | FirstL (const Grammar &gr, const GrammarSymbolWordMap &f) |
| Builds a function that maps words to their first possible terminal symbols by recursively calling First1.
|
std::set< Terminal > | FirstA (const Grammar &gr, const GrammarSymbolVector &word) |
| Determines which terminals can come first for a given word.
|
std::set< Terminal > | First (const Grammar &gr, const GrammarSymbolVector &word) |
| Determines which terminals can come first for a given word.
|
std::set< Terminal > | FirstRed (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< Terminal > | 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.
|
std::set< Terminal > | FirstLeq1 (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< Lr1Configuration > | Desc11 (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< Lr1Configuration > | 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.
|
std::set< Lr1Configuration > | Desc (const Grammar &gr, uint k, const std::set< Lr1Configuration > &config) |
| Obtain all descendants of a configuration set.
|
std::set< Lr1Configuration > | PassesX (const Lr1Configuration &config, const GrammarSymbolPtr &symbol) |
| Try to shift the dot in a configuration over a specified symbol.
|
std::set< Lr1Configuration > | Basis (const std::set< Lr1Configuration > configs, const GrammarSymbolPtr &symbol) |
| Try to shift the dots in a configuration set over a specified symbol.
|
std::set< Lr1Configuration > | 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.
|
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< Lr1Configuration > | DescInitial (const Grammar &gr) |
| Determine the initial parser configurations for a grammar.
|
std::set< Lr1Configuration > | ValidEmpty (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< Idx > | GeneratorGoto (const GotoGenerator &gotoGen, Idx state, const GrammarSymbolPtr &symbol) |
| Find the successor states of a state for a given input symbol.
|
std::vector< Idx > | GeneratorGotoSeq (const GotoGenerator &gotoGen, Idx startState, const GrammarSymbolVector &word) |
| Find the successor state sequence of a state for a given input word.
|
std::set< Lr1ParserAction > | 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
|
std::set< Lr1ParserAction > | 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
|
std::set< Lr1ParserAction > | LrpRules (const Grammar &gr, const Grammar &augGr, const GotoGenerator &gotoGen, uint k) |
| construct all parsing rules from a grammar and its LR(k) machine
|
Lr1Parser | Lrp (const Grammar &gr, const Grammar &augGr, const GotoGenerator &gotoGen, uint k, const Terminal &augSymbol) |
| construct an LR(k) parser from a grammar and its LR(k) machine
|
PushdownGenerator | Gp2Pp (const GotoGenerator &gotoGen, const Lr1Parser &parser) |
| Converts a parser into a pushdown generator.
|
PushdownGenerator | Dim (const PushdownGenerator &pd, const Terminal &augSymbol) |
| Remove the augmentation from the generator (diminish it).
|
std::set< Nonterminal > | Filter (const std::set< Nonterminal > &symbolSet, const GrammarSymbolVector &w) |
| Extract all symbols from the word that are in the symbol set.
|
std::set< Nonterminal > | Rnpp1 (const Grammar &gr, const std::set< Nonterminal > &ntSet) |
| Find all nonterminals that are eliminable in one step and assuming that a certain set of nonterminals has already been eliminated.
|
std::set< Nonterminal > | Rnppl (const Grammar &gr, const std::set< Nonterminal > &ntSet) |
| Find all nonterminals that are eliminable in as many steps as needed and assuming that a certain set of nonterminals has already been eliminated.
|
Grammar | Rnpp (const Grammar &gr) |
| Remove all productions from a grammar that are nonproductive, i.
|
Grammar | Sp2Lr (const PushdownGenerator &pd) |
| Transform a simple pushdown generator into an LR(1) grammar.
|
Grammar | Sp2Lr2 (const PushdownGenerator &pd) |
| Transform a simple pushdown generator into an LR(1) grammar.
|
Grammar | Rup (const Grammar &gr) |
| Remove all unreachable productions and nonterminals from the grammar.
|
PushdownGenerator | RenQ (const std::string word, const PushdownGenerator &pd) |
| Associates each state of the generator with an annotation.
|
PushdownGenerator | RenG (const std::string word, const PushdownGenerator &pd) |
| Adds an annotation to each stack symbol of the generator.
|
PushdownGenerator | Rep0 (const PushdownGenerator &pd) |
| Removes all edges popping lambda.
|
PushdownGenerator | Rpp (const PushdownGenerator &pd) |
| Restricts a pushdown generator to a pushdown generator with transitions that are either read (p,a,lambda,lambda,q), pop (p,lambda,x,lambda,q) or push (p,lambda,x,yx,q).
|
void | PrintTransitions (const std::multimap< Transition, std::pair< std::vector< StackSymbol >, std::vector< StackSymbol > > > &transitions) |
| For debugging, prints a transitions with their pop and push attributes.
|
PushdownGenerator | Rep2 (const PushdownGenerator &pd) |
| Removes transitions popping more than one stack symbol.
|
PushdownGenerator | Nda (const PushdownGenerator &pd) |
| Input must have passed Rpp! remodells the generator to prevent double (or multiple) acceptance of the same input string.
|
PushdownGenerator | TrimStackSymbols (const PushdownGenerator &pd) |
| Delete stack symbols from the generator that are not used in any of the transitions.
|
PushdownGenerator | RemoveUselessTransitions (const PushdownGenerator &pd) |
| Remove certain transitions that can never be used because their pop symbol can never be the stack top.
|
StackSymbolSet | GetPossibleStackTops (const PushdownGenerator &pd, const StateSet &examinedStates, Idx q) |
| Get all possible stack top symbols for a state.
|
bool | CompareGsVector (const GrammarSymbolVector &lhs, const GrammarSymbolVector &rhs) |
bool | EqualsGsVector (const GrammarSymbolVector &lhs, const GrammarSymbolVector &rhs) |
bool | CompareGs (const GrammarSymbolPtr &lhs, const GrammarSymbolPtr &rhs) |
bool | ContainsWord (const GrammarSymbolWordSet &set, const GrammarSymbolVector &word) |
| Test if a given set of words contains a specific word.
|
bool | CompareConfigSet (const std::set< Lr1Configuration > &lhs, const std::set< Lr1Configuration > &rhs) |
bool | CompareConfigGsPair (const ConfigSetGsPair &lhs, const ConfigSetGsPair &rhs) |
std::string | ConfigSetToStr (const std::set< Lr1Configuration > &configs) |
| To string function for configuration sets.
|
std::string | ConfigSetSetToStr (const Lr1ConfigurationSetSet configSetSet) |
| To string function for configuration set sets.
|
std::string | TransitionMapToStr (const LrmTransitionMap &transitionMap) |
| To string function for a transition map.
|
void | TestAlternativeAccessible (Generator &rGen) |
| Alternative accessibility algorithm.
|
void | TestTransientStates () |
| Test if Transient chooses the right states.
|
void | TestTransientStatesEmpty () |
| Test if Transient chooses the right states.
|
void | TestRnceRemoveEars () |
| Test if uncontrollable ears are correctly removed.
|
void | TestIntersectEventsAll () |
| test for intersect events
|
void | TestTimesStates () |
| test for the the right number of states and for correctly set merge states
|
void | TestTimesStackSymbols () |
| Test if all stack symbols and the stack bottom are set correctly.
|
void | TestTimesTransitions () |
| Test if the number of lambda transitions and the total number of transitions is right.
|
void | TestSplitStackSymbols () |
| Test if the stack bottom remains unchanged and all stack symbols from the old generator are in the split generator.
|
void | TestSplitStates () |
| Test if the states have been split correctly into heads and ears.
|
void | TestSplitTransitionsHeadToEar () |
| Test if all transitions originating at heads end at ears and if the pop/push of the transition is correctly set.
|
void | TestSplitTransitionsEarToHead () |
| Test if all transitions originating at ears end at heads and if the pop of the transition is correctly set.
|
void | TestTsUnreachable () |
| Test Te with transitions that are unreachable.
|
void | TestTeReachable () |
| Test Ts with transitions that are reachable.
|
void | TestTeUnreachable () |
| Test Ts with states that are unreachable.
|
void | TestRulsRemoveStates () |
| Test if Ruls deletes the correct states.
|
void | TestAcAccessible () |
| Test if Ac makes the test generator accessible.
|
void | TestTransient () |
| All Transient tests.
|
void | TestRnce () |
| All Rnce tests.
|
void | TestTimes () |
| all Times tests
|
void | TestIntersectEvents () |
| all IntersectEvents tests
|
void | TestSplit () |
| all Split tests
|
void | TestNonblock () |
| all Nonblock tests
|
void | TestTs () |
| all Ts tests
|
void | TestTe () |
| all Te tests
|
void | TestRuls () |
| all Ruls tests
|
void | TestAc () |
| all Ac tests
|
void | TestPostClPostfixes () |
| Test all postfixes of a given word.
|
void | TestFdsWords () |
| Test if Fds returns all expected words.
|
void | TestFirstLMap () |
| Test if the mapping function produced by FirstL is correct.
|
void | TestFirstASelectedWords () |
| Test for some selected word if the correct set of terminals is returned.
|
void | TestFirstSelectedWords () |
| Test for some selected word if the correct set of terminals is returned.
|
void | TestFirstRedConsistentWord () |
| Test FirstRed with a consistent word as input.
|
void | TestFirstRedInconsistentWord () |
| Test FirstRed with an inconsistent word as input.
|
void | TestFilter1MixedGrammarSymbols () |
| Filter a nonterminal from a vector of terminals and nonterminals.
|
void | TestFilter1Nothing () |
| filter from an empty word
|
void | TestFirstAllTerminalsOnly () |
| Test with only Terminals as input.
|
void | TestFirstAllNonterminalsIrreducibleWord () |
void | TestFirstAllNonterminalsReducibleWord () |
void | TestFirstLeq1ZeroEmpty () |
| Test with k = 0 and a word that results in an empty first set.
|
void | TestFirstLeq1ZeroNonempty () |
| Test with k = 0 and a word that results in a nonempty first set.
|
void | TestFirstLeq1OneNonempty () |
| Test with k = 1 and a word that results in a nonempty first set.
|
void | TestFirstLeq1TwoNonempty () |
| Test with k = 2 and a word that results in a nonempty first set.
|
void | TestPostCl () |
| All PostCl tests.
|
void | TestFds () |
| All Fds tests.
|
void | TestFirstA () |
| All FirstA tests.
|
void | TestFirstL () |
| All FirstL tests.
|
void | TestFirst () |
| All First tests.
|
void | TestFirstRed () |
| All FirstRed tests.
|
void | TestFilter1 () |
| All Filter1 tests.
|
void | TestFirstAll () |
| All FirstAll tests.
|
void | TestFirstLeq1 () |
| All FirstLeq1 tests.
|
void | TestFirstAllNonterminalsReducible () |
| Test with Nonterminals and a reducible word as input.
|
void | TestFirstAllNonterminalsIrreducible () |
| Test with Nonterminals and an irreducible word as input.
|
void | TestDesc11Terminal () |
| Test Desc11 with a terminal at the beginning of afterDot.
|
void | TestDesc11Nonterminal () |
| Test Desc11 with a nonterminal at the beginning of afterDot.
|
void | TestDescSelectedConfigs () |
| Test Desc with some configurations.
|
void | TestPassesXNonterminal () |
| Test PassesX by shifting the dot over a nonterminal.
|
void | TestPassesXTerminal () |
| Test PassesX by shifting the dot over a terminal.
|
void | TestPassesXNoShift () |
| Test PassesX by trying to shift the dot over nothing or a nonexistent symbol.
|
void | TestLrm1FindOne () |
| Test if Lrm1 finds the correct following configuration set when only one must be found.
|
void | TestLrm1FindThree () |
| Test if Lrm1 finds three following configuration sets when three must be found.
|
void | TestLrmLoopAnB () |
| Test if LrmLoop generates the correct number of transitions and states for the "$ a^n b $" grammar.
|
void | TestDescInitialFindTwo () |
| Test Desc Initial if it finds the two correct starting configurations.
|
void | TestLrmGr1 () |
| Test if Lrm generates a GotoMachine with the correct number of transitions and states for the "$ a^n b $" grammar.
|
void | TestLrmGr2 () |
| Test if Lrm generates a GotoMachine with the correct number of transitions and states for a specific.
|
void | TestAugSuccess () |
| Augment a grammar which should result in a successful augmentation.
|
void | TestDesc11 () |
| All Desc11 Tests.
|
void | TestDesc () |
| All Desc Tests.
|
void | TestPassesX () |
| All PassesX Tests.
|
void | TestLrm1 () |
| All Lrm1 Tests.
|
void | TestLrmLoop () |
| All LrmLoop Tests.
|
void | TestDescInitial () |
| All DescInitial Tests.
|
void | TestLrm () |
| All Lrm Tests.
|
void | TestAug () |
| All Aug Tests.
|
void | TestGeneratorGotoOneSuccessor () |
| Test if GeneratorGoto finds the right successor.
|
void | TestGeneratorGotoNoSuccessor () |
| Test if GeneratorGoto finds no successor when none is to be found.
|
void | TestGeneratorGotoSeqFull () |
| Test if a word fully matches a sequence of states when a match is possible.
|
void | TestGeneratorGotoSeqPartial () |
| Test if a partial state sequence is generated when no full match for the word is possible.
|
void | TestLrpShiftRulesNumberAndTerminals () |
| Test if the number of shift rules is correct and test for the correct number of occurences of terminals and each action's left-hand side element's right-hand side.
|
void | TestLrpReduceRulesNumberAndTerminals () |
| Test if the number of reduce rules is correct and test for the correct number of occurences of terminals and each action element's right-hand side.
|
void | TestLrpActions () |
| Test if Lrp generates a parser with the correct rules.
|
void | TestLrpNonterminalsTerminals () |
| Test if Lrp generates a parser with the correct number of nonterminals and terminals for a certain grammar.
|
void | TestGp2PpStates () |
| Test if all states are set correctly and whether the correct ones are used in transitions.
|
void | TestGp2PpTransitions () |
| Test if the number of transitions is correct and test if the number of transitions per event is as expected.
|
void | TestDimNoAugment () |
| Test if the augment symbol transitions were successfully removed from the generator and the new number of transitions is correct.
|
void | TestDimNewFinalStates () |
| Test if final states are set correctly after the removal auf the augment symbol.
|
void | TestGeneratorGoto () |
| All GeneratorGoto Tests.
|
void | TestGeneratorGotoSeq () |
| All GeneratorGotoSeq Tests.
|
void | TestLrpShiftRules () |
| All LrpShiftRules Tests.
|
void | TestLrpReduceRules () |
| All LrpReduceRules Tests.
|
void | TestLrp () |
| All Lrp Tests.
|
void | TestGp2Pp () |
| All Gp2Pp Tests.
|
void | TestDim () |
| All Dim Tests.
|
void | TestFilterMixedGrammarSymbols () |
| Filter a nonterminal from a vector of terminals and nonterminals.
|
void | TestFilterNothing () |
| filter from an empty word
|
void | TestRnpp1FindSymbolsEmptySet () |
| Find an eliminable symbol with Rnpp1 and an empty set of nonterminals.
|
void | TestRnpp1FindSymbolsNonemptySet () |
| Find an eliminable symbol with Rnpp1 and a nonempty set of nonterminals.
|
void | TestRnpplFindSymbolsEmptySet () |
| Find all eliminable symbols with Rnppl and an empty set of nonterminals.
|
void | TestRnpplFindSymbolsNonemptySet () |
| Find all eliminable symbolswith Rnppl and a nonempty set of nonterminals.
|
void | TestRnpplFindSymbolsCompleteSet () |
| Find all eliminable symbols with Rnppl and a set already containing all eliminable symbols.
|
void | TestRnppGrammar1 () |
| Remove all noneliminable nonterminals and all productions containing noneliminable nonterminals.
|
void | TestRnppGrammar2 () |
| Remove all noneliminable nonterminals and all productions containing noneliminable nonterminals.
|
void | TestRnppEmptyGrammar () |
| Try to remove all noneliminable nonterminals and all productions containing noneliminable nonterminals from an empty grammar.
|
void | TestSp2LrTerminals () |
| Test if all terminals have been set correctly and match the generator's events.
|
void | TestSp2LrNonterminals () |
| Test if all possible nonterminals were generated.
|
void | TestSp2LrProductions () |
| Test if all expected productions for read, pop and push transitions and for the final states were generated.
|
void | TestSp2Lr2Productions () |
| Test if all expected productions for read, pop and push transitions and for the final states were generated.
|
void | TestRupProductions () |
void | TestRupNonterminals () |
void | TestFilter () |
| All Filter tests.
|
void | TestRnpp1 () |
| All Rnpp1 tests.
|
void | TestRnppl () |
| All Rnppl tests.
|
void | TestRnpp () |
| All Rnpp tests.
|
void | TestSp2Lr () |
| All Sp2Lr tests.
|
void | TestSp2Lr2 () |
| All Sp2Lr tests.
|
void | TestRup () |
| All Rup tests.
|
void | TestRenQRenaming () |
| Test if all states were renamed correctly (merge attribute is set correctly).
|
void | TestRenQNumberOfStates () |
| Test if the number of states did not change.
|
void | TestRenGRenamingStackSymbols () |
| Test if all stack symbols were renamed correctly.
|
void | TestRenGNumberOfStackSymbols () |
| Test if the number of stack symbols did not change.
|
void | TestRenGRenamingTransitions () |
| Test if the stack symbols in pop and push of transitions were changed correctly.
|
void | TestRep0NoLambdaPop () |
| Tests if there are any lambda popping edges left.
|
void | TestRep0AllExpectingTransition () |
| Test if resulting generator has a transition able to pop all stack symbols, but only if the orignal generator had at least one lambda transition.
|
void | TestRep2NumberOfStatesTransitions () |
| Test for the right number of transitions and states in the generator after applying Rep2.
|
void | TestRep2Renaming () |
| Tests if the MergeStateAnnotations have all been set to "old".
|
void | TestRppNumberStatesTransitions () |
| Test if the number of transitions and states is correct after calling Rpp.
|
void | TestRppReadPopPushOnly () |
| Test if all transitions are either read only, pop only or push only.
|
void | TestNdaActivePassive () |
| Test if the states are split into active and passive states and if the number of states has been doubled.
|
void | TestNdaTransitions () |
| Test if transition start and end states are set as expected.
|
void | TestRenQ () |
| All RenQ Tests.
|
void | TestRenG () |
| All RenG tests.
|
void | TestRep0 () |
| All Rep0 tests.
|
void | TestRpp () |
| All Rpp tests.
|
void | TestRep2 () |
| All Rep2 tests.
|
void | TestNda () |
| All Nda tests.
|
void | TestRemoveUselessTransitionsNumberOfTransitions () |
| Test if RemoveUselessTransitions removes the correct amount of transitions from a test generator.
|
void | TestGetPossibleStackTopsFindCorrectOnes () |
| Test if GetPossibleStackTops finds the correct stack symbols.
|
void | TestRemoveUselessTransitions () |
| all RemoveUselessTransitions tests
|
void | TestGetPossibleStackTops () |
| all GetPossibleStackTops tests
|
PushdownGenerator | TestGenerator1 () |
| build a test generator
|
PushdownGenerator | TestGenerator2 () |
| build a test generator
|
PushdownGenerator | TestGenerator3 () |
| <Generator> Generator
|
PushdownGenerator | TestGenerator4 () |
| <Generator> Generator
|
PushdownGenerator | TestGenerator5 () |
| <Generator> Generator
|
PushdownGenerator | TestGenerator6 () |
PushdownGenerator | TestGenerator7 () |
PushdownGenerator | TestGenerator8 () |
PushdownGenerator | TestGenerator9 () |
PushdownGenerator | TestGenerator10 () |
PushdownGenerator | TestGenerator11 () |
PushdownGenerator | TestGenerator12 () |
PushdownGenerator | TestGenerator13 () |
PushdownGenerator | TestGenerator14 () |
PushdownGenerator | TestGenerator15 () |
PushdownGenerator | TestGenerator16 () |
PushdownGenerator | TestGenerator17 () |
PushdownGenerator | TestGenerator18 () |
PushdownGenerator | TestGenerator19 () |
PushdownGenerator | TestGenerator20 () |
PushdownGenerator | TestGenerator21 () |
PushdownGenerator | TestGenerator22 () |
PushdownGenerator | TestGenerator23 () |
PushdownGenerator | TestGenerator24 () |
PushdownGenerator | TestGenerator25 () |
System | TestSystem1 () |
| <Generator> Generator
|
System | TestSystem2 () |
System | TestSystem3 () |
System | TestSystem4 () |
System | TestSystem5 () |
Grammar | TestGrammar1 () |
| build a test grammer based on the generator from TestGenerator()
|
Grammar | TestGrammar2 () |
| build a test grammer based on the generator from TestGenerator()
|
Grammar | TestGrammar3 () |
Grammar | TestGrammar4 () |
Grammar | TestGrammar5 () |
Grammar | TestGrammar6 () |
Grammar | TestGrammar7 () |
Grammar | TestGrammar8 () |
Grammar | TestGrammar9 () |
Grammar | TestGrammar10 () |
Grammar | TestGrammar11 () |
void | TestStart (std::string name) |
| write to console to indicate start of test
|
void | TestEnd (std::string name) |
| write to console to indicate end of test
|
template<class GlobalAttr1 , class StateAttr1 , class EventAttr1 , class TransAttr1 , class GlobalAttr2 , class StateAttr2 , class EventAttr2 , class TransAttr2 , class GlobalAttrR , class StateAttrR , class EventAttrR , class TransAttrR > |
void | TParallel (const TGEN1 &rGen1, const TGEN2 &rGen2, TGENR &rResGen) |
| Parallel composition of timed generators.
|
template<class GlobalAttr1 , class StateAttr1 , class EventAttr1 , class TransAttr1 , class GlobalAttr2 , class StateAttr2 , class EventAttr2 , class TransAttr2 , class GlobalAttrR , class StateAttrR , class EventAttrR , class TransAttrR > |
void | TParallel (const TGEN1 &rGen1, const TGEN2 &rGen2, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, TGENR &rResGen) |
| Parallel composition of timed generators.
|
void | ran_plant_seeds (long x) |
| Use this function to set the state of all the random number generator streams by "planting" a sequence of states (seeds), one per stream, with all states dictated by the state of the default stream.
|
void | ran_put_seed (long seed) |
| Put a seed.
|
void | ran_select_stream (int index) |
| Use this function to set the current random number generator stream -- that stream from which the next random number will come.
|
void | ran_init (long seed) |
| Initialize random generator.
|
double | ran (void) |
| Run random generator Random Number Generator (for more details see "Random Number Generators: Good Ones Are Hard To Find" Steve Park and Keith Miller Communications of the ACM, October 1988).
|
double | ran_uniform (double a, double b) |
| Sample a random variable uniformly on interval [a;b) Distribution: f(t) dt= {1/(b-a)} dt for t, a <=t< b, else 0.
|
long | ran_uniform_int (long a, long b) |
| Sample a discrete random variable uniformly on interval [a;b) Distribution: p(n) = 1/(b-a-1).
|
double | ran_exponential (double mu) |
| Sample a random variable exponentially Distribution: f(t) dt = 1/mu exp(-t/mu) dt for t>=0.
|
double | ran_exponential (double mu, tpTime::Type tossLB, tpTime::Type tossUB) |
| Sample a random variable exponentially on a restricted interval Distribution: f(t) dt = 1/mu exp(-t/mu) dt for t>=0.
|
double | ran_gauss (double mu, double sigma, tpTime::Type tossLB, tpTime::Type tossUB) |
| Sample a random variable gaussian distributed on a restricted interval Distribution: f(t) = 1 / sqrt(2 pi sigma^2) * exp( -1/2 ((t-mu)/sigma)^2) for t>=0.
|
double | ran_gaussian_cdf_P (double x) |
| Help function: calculate gaussian CDF using an approximation from Abromowitz and Stegun: Handbook of Mathematical Functions.
|
void * | SDeviceSynchro (void *arg) |
int | syncSend (int dest, const char *data, int len, int flag) |
void * | NDeviceListen (void *arg) |
void * | SwigCastPtr (void *ptr, swig_type_info *from, swig_type_info *ty) |
swig_lua_userdata * | SwigUserData (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) |
|
|
void | DecentralizedModularDiagnoser (const std::vector< const System * > &rGens, const Generator &rSpec, std::vector< Diagnoser * > &rDiags, std::string &rReportString) |
| Function that computes decentralized diagnosers for the respective subsystems of a composed (modular) system.
|
bool | ModularDiagnoser (const SystemVector &rGsubs, const GeneratorVector &rKsubs, GeneratorVector &rDiagSubs, std::string &rReportString) |
| Function that computes diagnosers for the respective subsystems of a composed system.
|
|
|
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.
|
|
|
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.
|
|
|
bool | IsEventDiagnosable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, std::string &rReportString) |
| Test a system's diagnosability with respect to a given failure partition.
|
bool | IsIndicatorEventDiagnosable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, std::string &rReportString) |
| Test a system's I-diagnosability with respect to a given failure partition.
|
bool | MeetsDiagnosabilityAssumptions (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, std::string &rReportString) |
| Check if a generator meets the general assumptions of diagnosability as required by IsDiagnosable(const System&, const AttributeFailureTypeMap&, std::string&) and IsIndicatorDiagnosable(const System&, const AttributeFailureTypeMap&, std::string&).
|
|
|
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.
|
|
|
bool | IsLanguageDiagnosableX (const System &rGen, const System &rSpec, std::string &rReportString) |
| Tests a system's diagnosability with respect to a given specification.
|
|
|
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 |
TokenWriter * | gTestProtocolTw = NULL |
std::string | gTestProtocolFr |
static bool(* | gBreakFnct )(void)=0 |
static long | ran_seed [STREAMS] = {DEFAULT} |
static int | ran_stream = 0 |
static int | ran_initialized = 0 |
AutoRegisterType< TaNameSet
< AttributeSignalEvent > > | gRti1RegisterSignalDeviceEventSet ("SignalDeviceEventSet") |
AutoRegisterXElementTag
< TaNameSet
< AttributeSignalEvent > > | gRti1XElementTagSignalDeviceEventSet ("SignalDeviceEventSet","Event") |
AutoRegisterType< nDevice > | gRtiRegisterSimplenetDevice ("SimplenetDevice") |
static volatile
AutoRegisterType< xDevice > | gRtiRegisterDeviceContainer ("DeviceContainer") |
static const char *const | luafaudes_rl_keywords [] |
Detailed Description
libFAUDES resides within the namespace faudes.
Plug-Ins may use the same namespace.
Typedef Documentation
Type definition for real type (use C std double, must at least represent Int).
Definition at line 55 of file cfl_definitions.h.
Type definition for integer type (let target system decide, minimum 32bit).
Definition at line 50 of file cfl_definitions.h.
Convenience typedef for std PushdownGenerator.
Definition at line 826 of file pd_pdgenerator.h.
Convenience typedef for std TimedGenerator.
Definition at line 801 of file tp_tgenerator.h.
Dummy typedef in the absence of the IO Device plugin.
Definition at line 29 of file sp_dplpexecutor.h.
Enumeration Type Documentation
Function Documentation
TransSet faudes::ActiveBackwardTransSet |
( |
const System & |
rGen, |
|
|
Idx |
state | |
|
) |
| | |
Obtain all transitions from other states into a given state of a generator.
- Parameters:
-
| rGen | A generator. |
| state | A state from the generators state set. |
- Returns:
- A transition set.
void faudes::AdjustHioController |
( |
const HioController & |
rHioController, |
|
|
const HioModule * |
rHioModule1, |
|
|
const HioModule * |
rHioModule2, |
|
|
HioController & |
rResEnv | |
|
) |
| | |
void faudes::aParallel |
( |
const GeneratorVector & |
rGenVec, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Parallel composition.
See also aParallel(const Generator&, const Generator&, Generator&). This version takes a vector of generators as argument to perform a synchronous composition of multiple generators. The implementation calls the std aParallel multiple times, future implementations may explore the overall reachable state set.
- Parameters:
-
| rGenVec | Vector of input generators |
| rResGen | Reference to resulting composition generator |
Grammar faudes::Aug |
( |
const Grammar & |
gr, |
|
|
const Nonterminal & |
startSymbol, |
|
|
const Terminal & |
augSymbol | |
|
) |
| | |
Augments the grammar with a nonterminal S and a terminal $ such that a new grammar production will be inserted.
S is the new start symbol of the grammar and S' is the old start symbol of the grammar
- Parameters:
-
| gr | the grammar to be augmented |
| startSymbol | the new start symbol S. S must not exist in the grammar |
| augSymbol | the $ symbol which augments the grammar. $ must not exist in the grammar |
- Returns:
- augmented grammar with a new production S -> $ S' $
void faudes::backwardReachabilityObsOCC |
( |
const TransSetX2EvX1 & |
rTransSetX2EvX1, |
|
|
const EventSet & |
rControllableEvents, |
|
|
const EventSet & |
rHighAlph, |
|
|
Idx |
exitState, |
|
|
Idx |
currentState, |
|
|
bool |
controllablePath, |
|
|
map< Idx, map< Idx, bool > > & |
rExitLocalStatesMap, |
|
|
StateSet & |
rDoneStates | |
|
) |
| | |
void faudes::backwardVerificationLCC |
( |
const TransSetX2EvX1 & |
rTransSetX2EvX1, |
|
|
const EventSet & |
rControllableEvents, |
|
|
const EventSet & |
rHighAlph, |
|
|
Idx |
exitState, |
|
|
Idx |
currentState, |
|
|
bool |
controllablePath, |
|
|
std::map< Idx, bool > & |
rLocalStatesMap, |
|
|
StateSet & |
rDoneStates | |
|
) |
| | |
Function that supports the verification of local control consistency (LCC).
This function performs a recursive backward reachability to find if from a state where an uncontrollable high-level event is possible, another state is only reachable by local strings that contaion at least one controllable event. If this is the case, LCC is violated.
- Parameters:
-
| rTransSetX2EvX1 | reverse transition relation of the input generator |
| rControllableEvents | set of controllable events |
| rHighAlph | High level alphabet |
| exitState | start state for backward reachability |
| currentState | current state for backward reachability |
| controllablePath | false if at least one uncontrollable path to the currentState exists |
| rLocalStatesMap | map for states and their controllability property |
| rDoneStates | states that have already been visited |
bool faudes::backwardVerificationOCC |
( |
const Generator & |
rLowGen, |
|
|
const EventSet & |
rControllableEvents, |
|
|
const EventSet & |
rHighAlph, |
|
|
Idx |
currentState | |
|
) |
| | |
Function that supports the verification of output control consistency (OCC).
This function performs a backward reachability to find if an uncontrollable high-level event is preemted by an uncontrollable low-level event. If this is the case, OCC is violated.
- Parameters:
-
| rLowGen | Input generator |
| rControllableEvents | set of controllable events |
| rHighAlph | High level alphabet |
| currentState | start state for backward reachability |
- Returns:
- true if no controllable low-level event has been found
std::set< Lr1Configuration > faudes::Basis |
( |
const std::set< Lr1Configuration > |
configs, |
|
|
const GrammarSymbolPtr & |
symbol | |
|
) |
| | |
Try to shift the dots in a configuration set over a specified symbol.
- Parameters:
-
| configs | the configurations |
| symbol | the symbol over which to shift |
- Returns:
- set that contains all shifted configurations
void faudes::calcAbstAlphClosed |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
std::map< Transition, Idx > & |
rMapChangedTrans | |
|
) |
| | |
L(G)-observer computation.
This function is called by void calcAbstAlphClosed(Generator& rGenObs, EventSet& rControllableEvents, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx, set<Idx> >& rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an Lm-observer for the prefix-closed language of the resulting generator. This function evaluates the observer algorithm as described in K. C. Wong and W. M. Wonham, "On the Computation of Observers in Discrete Event Systems," Discrete Event Dynamic Systems, vol. 14, no. 1, pp. 55-107, 2004.
The alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs. rGenObs must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGenObs | Low-level generator. It is modified by the algorithm by relabeling transitions and events |
| rControllableEvents | Set of controllable events |
| rHighAlph | Initial abstraction alphabet |
| rNewHighAlph | Modified abstraction alphabet such that the abstraction is an Lm-observer |
| rMapChangedTrans | Maps the original relabeled transitions to the new events |
void faudes::calcAbstAlphClosed |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
std::map< Idx, std::set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
L(G)-observer computation.
This function is called by calcAbstAlphClosed(System& rGenObs, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx, set<Idx> >& rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an L(G)-observer for the prefix-closed language of the resulting generator. This function evaluates the observer algorithm as described in K. C. Wong and W. M. Wonham, "On the Computation of Observers in Discrete Event Systems," Discrete Event Dynamic Systems, vol. 14, no. 1, pp. 55-107, 2004.
the alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs rGenObs must be a deterministic generator no further restrictions on parameters.
- Parameters:
-
| rGenObs | Low-level generator. It is modified by the algorithm by relabeling transitions and events |
| rControllableEvents | Set of controllable events |
| rHighAlph | Initial abstraction alphabet |
| rNewHighAlph | Modified abstraction alphabet such that the abstraction is an Lm-observer |
| rMapRelabeledEvents | Maps the original events to sets of newly introduced events (accumulatoive, call clear before) |
void faudes::calcAbstAlphClosed |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Transition, Idx > & |
rMapChangedTrans | |
|
) |
| | |
void faudes::calcAbstAlphClosed |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Idx, set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::calcAbstAlphClosed |
( |
System & |
rGenObs, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Idx, set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::calcAbstAlphMSA |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
std::map< Transition, Idx > & |
rMapChangedTrans | |
|
) |
| | |
MSA-observer computation.
This function is called by void calcAbstAlphMSA(Generator& rGenObs, EventSet& rControllableEvents, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx, set<Idx> >& rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an MSA-observer for the language marked by the resulting generator. This function evaluates the observer algorithm as described in K. Schmidt and Th. Moor, "Marked String Accepting Observers for the Hierarchical and Decentralized Control of Discrete Event Systems," Workshop on Discrete Event Systems, 2006.
The alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs. rGenObs must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGenObs | Low-level generator. It is modified by the algorithm by relabeling transitions and events |
| rControllableEvents | Set of controllable events |
| rHighAlph | Initial abstraction alphabet |
| rNewHighAlph | Modified abstraction alphabet such that the abstraction is an Lm-observer |
| rMapChangedTrans | Maps the original relabeled transitions to the new events |
void faudes::calcAbstAlphMSA |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
std::map< Idx, std::set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
MSA-observer computation.
This function is called by calcAbstAlphMSA(System& rGenObs, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx, set<Idx> >& rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an MSA-observer for the language marked by the resulting generator. This function evaluates the observer algorithm as described in K. Schmidt and Th. Moor, "Marked String Accepting Observers for the Hierarchical and Decentralized Control of Discrete Event Systems," Workshop on Discrete Event Systems, 2006.
the alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs rGenObs must be a deterministic generator no further restrictions on parameters.
- Parameters:
-
| rGenObs | Low-level generator. It is modified by the algorithm by relabeling transitions and events |
| rControllableEvents | Set of controllable events |
| rHighAlph | Initial abstraction alphabet |
| rNewHighAlph | Modified abstraction alphabet such that the abstraction is an Lm-observer |
| rMapRelabeledEvents | Maps the original events to sets of newly introduced events (accumulatoive, call clear before) |
void faudes::calcAbstAlphMSA |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Transition, Idx > & |
rMapChangedTrans | |
|
) |
| | |
void faudes::calcAbstAlphMSA |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Idx, set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::calcAbstAlphMSA |
( |
System & |
rGenObs, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Idx, set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::calcAbstAlphMSALCC |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
std::map< Transition, Idx > & |
rMapChangedTrans | |
|
) |
| | |
MSA-observer computation including local control consistency (LCC).
This function is called by calcAbstAlphMSALCC(System& rGenObs, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx,set<Idx > > & rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an MSA-observer for the language marked by the resulting generator and at the same time fulfills the local control consistency condition (LCC). This function evaluates the observer algorithm as described in K. Schmidt and C. Breindl, "On Maximal Permissiveness of Hierarchical and Modular Supervisory Control Approaches for Discrete Event Systems, Workshop on Discrete Event Systems, 2008. with an extension to LCC as indicated in K. Schmidt and C. Breindl, "On Maximal Permissiveness of Hierarchical and Modular Supervisory
Control Approaches for Discrete Event Systems," Workshop on Discrete Event Systems, 2008.
The alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs. rGenObs must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGenObs | Low-level generator. It is modified by the algorithm by relabeling transitions and events |
| rControllableEvents | Set of controllable events |
| rHighAlph | Initial abstraction alphabet |
| rNewHighAlph | Modified abstraction alphabet such that the abstraction is an Lm-observer |
| rMapChangedTrans | Maps the original relabeled transitions to the new events |
void faudes::calcAbstAlphMSALCC |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Transition, Idx > & |
rMapChangedTrans | |
|
) |
| | |
void faudes::calcAbstAlphMSALCC |
( |
System & |
rGenObs, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Idx, set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
Lm-observer computation.
This function is called by void calcAbstAlphObs(Generator& rGenObs, EventSet& rControllableEvents, EventSet& rHighAlph, EventSet& rNewHighAlph, std::map<Idx, std::set<Idx> >& rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an Lm-observer for the language marked by the resulting generator. This function evaluates the observer algorithm as described in K. C. Wong and W. M. Wonham, "On the Computation of Observers in Discrete Event Systems," Discrete Event Dynamic Systems, vol. 14, no. 1, pp. 55-107, 2004.
The alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs. rGenObs must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGenObs | Low-level generator. It is modified by the algorithm by relabeling transitions and events |
| rControllableEvents | Set of controllable events |
| rHighAlph | Initial abstraction alphabet |
| rNewHighAlph | Modified abstraction alphabet such that the abstraction is an Lm-observer |
| rMapChangedTrans | Maps the original relabeled transitions to the new events |
void faudes::calcAbstAlphObs |
( |
MtcSystem & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
std::map< Idx, std::set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
Lm-observer computation.
This function is called by calcAbstAlphObs(System& rGenObs, EventSet& rHighAlph, EventSet& rNewHighAlph, std::map<Idx, std::set<Idx> >& rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an Lm-observer for the language marked by the resulting generator. This function evaluates the observer algorithm as described in K. C. Wong and W. M. Wonham, "On the Computation of Observers in Discrete Event Systems," Discrete Event Dynamic Systems, vol. 14, no. 1, pp. 55-107, 2004.
the alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs rGenObs must be a deterministic generator no further restrictions on parameters.
- Parameters:
-
| rGenObs | Low-level generator. It is modified by the algorithm by relabeling transitions and events |
| rControllableEvents | Set of controllable events |
| rHighAlph | Initial abstraction alphabet |
| rNewHighAlph | Modified abstraction alphabet such that the abstraction is an Lm-observer |
| rMapRelabeledEvents | Maps the original events to sets of newly introduced events (accumulatoive, call clear before) |
void faudes::calcAbstAlphObs |
( |
MtcSystem & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Idx, set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::calcAbstAlphObs |
( |
MtcSystem & |
rGenObs, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Idx, set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::calcAbstAlphObs |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
std::map< Transition, Idx > & |
rMapChangedTrans | |
|
) |
| | |
Lm-observer computation.
This function is called by void calcAbstAlphObs(Generator& rGenObs, EventSet& rControllableEvents, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx, set<Idx> >& rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an Lm-observer for the language marked by the resulting generator. This function evaluates the observer algorithm as described in K. C. Wong and W. M. Wonham, "On the Computation of Observers in Discrete Event Systems," Discrete Event Dynamic Systems, vol. 14, no. 1, pp. 55-107, 2004.
The alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs. rGenObs must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGenObs | Low-level generator. It is modified by the algorithm by relabeling transitions and events |
| rControllableEvents | Set of controllable events |
| rHighAlph | Initial abstraction alphabet |
| rNewHighAlph | Modified abstraction alphabet such that the abstraction is an Lm-observer |
| rMapChangedTrans | Maps the original relabeled transitions to the new events |
void faudes::calcAbstAlphObs |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
std::map< Idx, std::set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
Lm-observer computation.
This function is called by calcAbstAlphObs(System& rGenObs, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx, set<Idx> >& rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an Lm-observer for the language marked by the resulting generator. This function evaluates the observer algorithm as described in K. C. Wong and W. M. Wonham, "On the Computation of Observers in Discrete Event Systems," Discrete Event Dynamic Systems, vol. 14, no. 1, pp. 55-107, 2004.
the alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs rGenObs must be a deterministic generator no further restrictions on parameters.
- Parameters:
-
| rGenObs | Low-level generator. It is modified by the algorithm by relabeling transitions and events |
| rControllableEvents | Set of controllable events |
| rHighAlph | Initial abstraction alphabet |
| rNewHighAlph | Modified abstraction alphabet such that the abstraction is an Lm-observer |
| rMapRelabeledEvents | Maps the original events to sets of newly introduced events (accumulatoive, call clear before) |
void faudes::calcAbstAlphObs |
( |
System & |
rGenObs, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
EventRelabelMap & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::calcAbstAlphObs |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Transition, Idx > & |
rMapChangedTrans | |
|
) |
| | |
void faudes::calcAbstAlphObs |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Idx, set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::calcAbstAlphObs |
( |
System & |
rGenObs, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Idx, set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::calcAbstAlphObsLCC |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
std::map< Transition, Idx > & |
rMapChangedTrans | |
|
) |
| | |
Lm-observer computation including local control consistency (LCC).
This function is called by calcAbstAlphObsLCC(System& rGenObs, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx,set<Idx > > & rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an Lm-observer for the language marked by the resulting generator and at the same time fulfills the local control consistency condition (LCC). This function evaluates the observer algorithm as described in K. C. Wong and W. M. Wonham, "On the Computation of Observers in Discrete Event Systems," Discrete Event Dynamic Systems, vol. 14, no. 1, pp. 55-107, 2004. with an extension to LCC as indicated in K. Schmidt and C. Breindl, "On Maximal Permissiveness of Hierarchical and Modular Supervisory
Control Approaches for Discrete Event Systems," Workshop on Discrete Event Systems, 2008.
The alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs. rGenObs must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGenObs | Low-level generator. It is modified by the algorithm by relabeling transitions and events |
| rControllableEvents | Set of controllable events |
| rHighAlph | Initial abstraction alphabet |
| rNewHighAlph | Modified abstraction alphabet such that the abstraction is an Lm-observer |
| rMapChangedTrans | Maps the original relabeled transitions to the new events |
void faudes::calcAbstAlphObsLCC |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Transition, Idx > & |
rMapChangedTrans | |
|
) |
| | |
void faudes::calcAbstAlphObsLCC |
( |
System & |
rGenObs, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Idx, set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::calcBisimulation |
( |
Generator & |
rGenOrig, |
|
|
map< Idx, Idx > & |
rMapStateToPartition, |
|
|
vector< Idx > & |
rNewPartitions | |
|
) |
| | |
void faudes::calcBisimulation |
( |
Generator & |
rGenOrig, |
|
|
map< Idx, Idx > & |
rMapStateToPartition, |
|
|
Generator & |
rGenPart, |
|
|
vector< Idx > & |
rNewPartitions | |
|
) |
| | |
void faudes::calculateDynamicSystemClosedObs |
( |
const Generator & |
rGen, |
|
|
EventSet & |
rHighAlph, |
|
|
Generator & |
rGenDyn | |
|
) |
| | |
Computation of the dynamic system for Delta_sigma (reachable states after the occurrence of one high-level event).
This function computes the part of the dynamic system that is needed for evaluating the observer algorithm for closed languages.
The alphabet rHighAlph has to be a subset of the alphabet of rGen. rGen must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGen | Generator for which the dynamic system is computed |
| rHighAlph | Abstraction alphabet |
| rGenDyn | Generator representing the dynamic system |
void faudes::calculateDynamicSystemLCC |
( |
const Generator & |
rGen, |
|
|
const EventSet & |
rControllableEvents, |
|
|
const EventSet & |
rHighAlph, |
|
|
Generator & |
rGenDyn | |
|
) |
| | |
Computation of the dynamic system for Delta_lcc (fulfillment of the local control consistency property).
This function computes the part of the dynamic system that is needed for evaluating the observer algorithm for local control consistency
The alphabet rHighAlph has to be a subset of the alphabet of rGen. rGen must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGen | Generator for which the dynamic system is computed |
| rControllableEvents | Set of controllable events |
| rHighAlph | Abstraction alphabet |
| rGenDyn | Generator representing the dynamic system |
void faudes::calculateDynamicSystemMSA |
( |
const Generator & |
rGen, |
|
|
EventSet & |
rHighAlph, |
|
|
Generator & |
rGenDyn | |
|
) |
| | |
Computation of the dynamic system for Delta_msa (local fulfillment of the msa-observer property).
This function computes the part of the dynamic system that is needed for evaluating the observer algorithm for msa-observers.
The alphabet rHighAlph has to be a subset of the alphabet of rGen. rGen must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGen | Generator for which the dynamic system is computed |
| rHighAlph | Abstraction alphabet |
| rGenDyn | Generator representing the dynamic system |
Computation of the dynamic system for an Lm-observer.
This function computes the dynamic system that is needed for evaluating the observer algorithm.
The alphabet rHighAlph has to be a subset of the alphabet of rGen. rGen must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGen | Generator for which the dynamic system is computed |
| rHighAlph | Abstraction alphabet |
| rGenDyn | Generator representing the dynamic system |
void faudes::calculateDynamicSystemObs |
( |
const Generator & |
rGen, |
|
|
EventSet & |
rHighAlph, |
|
|
Generator & |
rGenDyn | |
|
) |
| | |
Computation of the dynamic system for Delta_obs (local reachability of a marked state).
This function computes the part of the dynamic system that is needed for evaluating the observer algorithm for marked languages.
The alphabet rHighAlph has to be a subset of the alphabet of rGen. rGen must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGen | Generator for which the dynamic system is computed |
| rHighAlph | Abstraction alphabet |
| rGenDyn | Generator representing the dynamic system |
PushdownGenerator faudes::Ccl |
( |
const PushdownGenerator & |
contr, |
|
|
const System & |
plant, |
|
|
Idx |
iteration = 0 | |
|
) |
| | |
Looped exectuion of to construct a minimal restrictive sound controller.
Alphabets of specification and plant are expected to be equal.
- Parameters:
-
| contr | the controller candidate |
| plant | the plant |
| iteration | number of iterations of ccl |
- Returns:
- minimal restrictive controller
PushdownGenerator faudes::Ccs |
( |
const PushdownGenerator & |
contr, |
|
|
const System & |
plant | |
|
) |
| | |
Single execution of the loop to construct a minimal restrictive sound controller.
Alphabets of specification and plant are expected to be equal.
- Parameters:
-
| contr | the controller candidate |
| plant | the plant |
- Returns:
- product of controller candidate and plant
bool faudes::CheckMergibility |
( |
Idx |
stateI, |
|
|
Idx |
stateJ, |
|
|
std::vector< std::set< Idx > > & |
rWaitList, |
|
|
Idx |
cNode, |
|
|
const System & |
rSupGen, |
|
|
const std::map< Idx, ReductionStateInfo > & |
rSupStateInfo, |
|
|
const std::map< Idx, Idx > & |
rState2Class, |
|
|
const std::vector< StateSet > & |
rClass2States | |
|
) |
| | |
Supervisor Reduction mergibility algorithm.
This recursive algorithm determines if two supervisor states can be merged to the same coset. It is called by the main procedure SupReduce.
- Parameters:
-
| stateI | First state to be checked |
| stateJ | second state to be checked |
| rWaitList | list of waiting state pairs |
| cNode | remembers first state to be checked |
| rSupGen | constant reference to supervisor |
| rSupStateInfo | constant reference to state info data structure |
| rState2Class | constant reference to data structure that maps states to their coset |
| rClass2State | constant reference to data structure that maps cosets to their states |
- Returns:
- True if the classes of statep and stateq can be merged
bool faudes::CheckSplit |
( |
const Generator & |
rGenObs, |
|
|
const EventSet & |
rSplitAlphabet, |
|
|
const std::vector< std::pair< StateSet, Idx > > & |
rNondeterministicStates, |
|
|
Idx |
entryState | |
|
) |
| | |
Check if the current alphabet splits all local automata with nondeterminims or unobservable transitions.
This algorithm verifies if nondetermisisms or unobservable transitions are resolved if the given events in are added to the high-level alphabet. The function is called by ExtendHighAlphabet,
The alphabet rHighAlph has to be a subset of the alphabet of rGenObs. rGenObs must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGenObs | Low-level generator. It is modified by the algorithm by relabeling transitions and events |
| rSplitAlphabet | Reference to the current alphabet for splitting verification |
| rNondeterministicStates | vector with states where nondeterminism has to be resolved and the related event |
| entryState | current state that is investigated |
bool faudes::CheckSplit |
( |
const Generator & |
rGen, |
|
|
const EventSet & |
rSplitAlphabet, |
|
|
const vector< pair< StateSet, Idx > > & |
rNondeterministicStates, |
|
|
Idx |
entryState | |
|
) |
| | |
std::string faudes::CollapsString |
( |
const std::string & |
rString, |
|
|
unsigned int |
len = FD_MAXCONTAINERNAME | |
|
) |
| | |
Limit length of string, return head and tail of string.
- Parameters:
-
| rString | string |
| len | Maximum number of charakters in string (approx) |
- Returns:
- Collapsed string
bool faudes::CompareConfigGsPair |
( |
const ConfigSetGsPair & |
lhs, |
|
|
const ConfigSetGsPair & |
rhs | |
|
) |
| | |
bool faudes::CompareConfigSet |
( |
const std::set< Lr1Configuration > & |
lhs, |
|
|
const std::set< Lr1Configuration > & |
rhs | |
|
) |
| | |
bool faudes::CompareGs |
( |
const GrammarSymbolPtr & |
lhs, |
|
|
const GrammarSymbolPtr & |
rhs | |
|
) |
| | |
bool faudes::CompareGsVector |
( |
const GrammarSymbolVector & |
lhs, |
|
|
const GrammarSymbolVector & |
rhs | |
|
) |
| | |
void faudes::ComposedColorSet |
( |
const MtcSystem & |
rGen1, |
|
|
const Idx |
stdidx1, |
|
|
ColorSet & |
colors1, |
|
|
const MtcSystem & |
rGen2, |
|
|
const Idx |
stdidx2, |
|
|
ColorSet & |
colors2, |
|
|
ColorSet & |
composedSet | |
|
) |
| | |
Compose the color set for a state combined from two states in two distinct automata.
- Parameters:
-
| rGen1 | First MtcSystem for parallel composition |
| stdidx1 | Index to first MtcSystem's current state |
| colors1 | Color set of first MtcSystem |
| rGen2 | Second MtcSystem for parallel composition |
| stdidx2 | Index to second MtcSystem's current state |
| colors2 | Color set of second MtcSystem |
| composedSet | Color set where composition colors will be inserted |
- Exceptions:
-
| Exception |
- Index not member of set (id 200)
- Index not found in set (id 201)
|
void faudes::CompositionMap1 |
( |
const std::map< std::pair< Idx, Idx >, Idx > & |
rCompositionMap, |
|
|
std::map< Idx, Idx > & |
rCompositionMap1 | |
|
) |
| | |
void faudes::CompositionMap2 |
( |
const std::map< std::pair< Idx, Idx >, Idx > & |
rCompositionMap, |
|
|
std::map< Idx, Idx > & |
rCompositionMap2 | |
|
) |
| | |
void faudes::ComputeGd |
( |
const Diagnoser & |
rGobs, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
System & |
rGd | |
|
) |
| | |
Compute the diagnosability testing generator G_d as a parallel composition of G_o with itself (according to Jiang).
- Parameters:
-
| rGobs | Input diagnoser G_o. |
| rReverseCompositionMap | Output variable containing the mapping of G_o states and G_d states (generated by Parallel()). |
| rGd | Output variable for G_d. |
void faudes::ComputeGd |
( |
const Diagnoser & |
rGobs, |
|
|
map< pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
System & |
rGd | |
|
) |
| | |
void faudes::ComputeGobs |
( |
const System & |
rGenMarkedNonSpecBehaviour, |
|
|
Diagnoser & |
rGobs | |
|
) |
| | |
Compute G_o for a generator that marks the faulty behaviour of a plant.
Every specification violation will be labelled with label "F".
- Parameters:
-
| rGenMarkedNonSpecBehaviour | Input generator that specifies specification violations by marked states. |
| rGobs | Output variable for G_o. |
void faudes::ComputeGobs |
( |
const System & |
rOrigGen, |
|
|
const std::string & |
rFailureType, |
|
|
const EventSet & |
rFailureEvents, |
|
|
Diagnoser & |
rGobs | |
|
) |
| | |
Compute G_o for a single failure type of a generator.
- Parameters:
-
| rOrigGen | Input generator, which is a model of the original plant containing the relevant failures events. |
| rFailureType | Failure type name. |
| rFailureEvents | Failure events belonging to the failure type. |
| rGobs | Output variable for G_o. |
void faudes::ComputeGobs |
( |
const System & |
rOrigGen, |
|
|
const AttributeFailureTypeMap & |
rAttrFTMap, |
|
|
Diagnoser & |
rGobs | |
|
) |
| | |
Compute G_o for a given generator with a given failure partition (according to Jiang).
- Parameters:
-
| rOrigGen | Input generator, which is a model of the original plant containing the relevant failures events. |
| rAttrFTMap | Failure partition. |
| rGobs | Output variable for G_o. |
- Exceptions:
-
| Exception |
- Input generator has no unique initial state (id 301).
|
void faudes::ComputeGobs |
( |
const System & |
rOrigGen, |
|
|
const string & |
rFailureType, |
|
|
const EventSet & |
rFailureEvents, |
|
|
Diagnoser & |
rGobs | |
|
) |
| | |
void faudes::ComputeReachability |
( |
const System & |
rGen, |
|
|
const EventSet & |
rUnobsEvents, |
|
|
Idx |
State, |
|
|
std::map< Idx, std::multimap< Idx, DiagLabelSet > > & |
rReachabilityMap | |
|
) |
| | |
Compute the reachability from a state of a generator that marks its faulty behaviour.
States are said to be reachable if they can be reached through a trace that consists of arbitrarily many unobservable events followed by one observable event.
- Parameters:
-
| rGen | Input generator. |
| rUnobsEvents | Unobservable events in the generators alphabet. |
| State | A state of the generators state set. |
| rReachabilityMap | Output variable for the reachability. Maps occurring observable events to the reachable generator states and a label that contains information about specification violations. |
void faudes::ComputeReachability |
( |
const System & |
rGen, |
|
|
const EventSet & |
rUnobsEvents, |
|
|
Idx |
State, |
|
|
map< Idx, multimap< Idx, DiagLabelSet > > & |
rReachabilityMap | |
|
) |
| | |
void faudes::ComputeReachability |
( |
const System & |
rGen, |
|
|
const EventSet & |
rUnobsEvents, |
|
|
const EventSet & |
rFailures, |
|
|
Idx |
State, |
|
|
const AttributeFailureTypeMap & |
rAttrFTMap, |
|
|
std::map< Idx, std::multimap< Idx, DiagLabelSet > > & |
rReachabilityMap | |
|
) |
| | |
Compute the reachability from a given generator state through a trace that consists of arbitrarily many unobservable events followed by one observable event.
- Parameters:
-
| rGen | Input generator. |
| rUnobsEvents | Unobservable events in the generators alphabet. |
| rFailures | Unobservable failure events in the generators alphabet. |
| State | A state of the generators state set. |
| rAttrFTMap | Failure partition. |
| rReachabilityMap | Output variable for the reachability. Maps occurring observable events to the reachable generator states and the corresponding failure types that occurred within the unobservable part of the trace. |
void faudes::ComputeReachability |
( |
const System & |
rGen, |
|
|
const EventSet & |
rUnobsEvents, |
|
|
const EventSet & |
rFailures, |
|
|
Idx |
State, |
|
|
const AttributeFailureTypeMap & |
rAttrFTMap, |
|
|
map< Idx, multimap< Idx, DiagLabelSet > > & |
rReachabilityMap | |
|
) |
| | |
void faudes::ComputeReachabilityRecursive |
( |
const System & |
rGen, |
|
|
const EventSet & |
rUnobsEvents, |
|
|
Idx |
State, |
|
|
StateSet |
done, |
|
|
std::map< Idx, std::multimap< Idx, DiagLabelSet > > & |
rReachabilityMap | |
|
) |
| | |
Auxiliary function for ComputeReachability(const System&, const EventSet&, Idx State, std::map<Idx,std::multimap< Idx,DiagLabelSet> >&).
Is recursively called for every occurring state on the trace (that consists of arbitrarily many unobservable events followed by one observable event).
- Parameters:
-
| rGen | Input generator. |
| rUnobsEvents | Unobservable events in the generators alphabet. |
| State | The current state within the trace. |
| done | Progress. |
| rReachabilityMap | Output variable for the reachability. Maps occurring observable events to the reachable generator states and a label that contains information about specification violations. |
void faudes::ComputeReachabilityRecursive |
( |
const System & |
rGen, |
|
|
const EventSet & |
rUnobsEvents, |
|
|
Idx |
State, |
|
|
StateSet |
done, |
|
|
map< Idx, multimap< Idx, DiagLabelSet > > & |
rReachabilityMap | |
|
) |
| | |
void faudes::ComputeReachabilityRecursive |
( |
const System & |
rGen, |
|
|
const EventSet & |
rUnobsEvents, |
|
|
const EventSet & |
rFailures, |
|
|
Idx |
State, |
|
|
const AttributeFailureTypeMap & |
rAttrFTMap, |
|
|
std::map< Idx, std::multimap< Idx, DiagLabelSet > > & |
rReachabilityMap, |
|
|
const DiagLabelSet |
FToccurred | |
|
) |
| | |
Auxiliary function for ComputeReachability(const System&, const EventSet&, const EventSet&, Idx, const AttributeFailureTypeMap&, std::map<Idx,std::multimap<Idx,DiagLabelSet>>&).
Is recursively called for every occurring state on the trace (that consists of arbitrarily many unobservable events followed by one observable event).
- Parameters:
-
| rGen | Input generator. |
| rUnobsEvents | Unobservable events in the generators alphabet. |
| rFailures | Unobservable failure events in the generators alphabet. |
| State | The current state within the trace. |
| rAttrFTMap | Failure partition. |
| rReachabilityMap | Output variable for the reachability. Maps occurring observable events to the reachable generator states and the coresponing failure types that occurred within the unobservable part of the trace. |
| FToccurred | Collects occurring failure types. |
void faudes::ComputeReachabilityRecursive |
( |
const System & |
rGen, |
|
|
const EventSet & |
rUnobsEvents, |
|
|
const EventSet & |
rFailures, |
|
|
Idx |
State, |
|
|
const AttributeFailureTypeMap & |
rAttrFTMap, |
|
|
map< Idx, multimap< Idx, DiagLabelSet > > & |
rReachabilityMap, |
|
|
const DiagLabelSet |
FToccurred | |
|
) |
| | |
Generator faudes::ComputeTildeG |
( |
const EventSet & |
unionset, |
|
|
const EventSetVector & |
ee, |
|
|
const EventSet & |
ek, |
|
|
const Generator & |
gen | |
|
) |
| | |
void faudes::ConcatenateFullLanguage |
( |
Generator & |
rGen |
) |
|
ConcatenateFullLanguage: concatenate Sigma* to language marked by rGen.
Less expensive than using LanguageConcatenate() to concatenate Sigma*, as no additional nondeterminism is caused. Used in SupNorm(). Method: Transitions starting from marked states are erased. Remaining accessible marked states are provided with Sigma-selfloops. Determinism: Result can only become nondeterministic when a parameter is nondeterministic.
- Parameters:
-
| rGen | generator marking the language to be concatenated with Sigma* |
std::string faudes::ConfigSetSetToStr |
( |
const Lr1ConfigurationSetSet |
configSetSet |
) |
|
To string function for configuration set sets.
- Parameters:
-
| configSetSet | the configuration set sets to turn into a string |
- Returns:
- the configuration set sets as a string
std::string faudes::ConfigSetToStr |
( |
const std::set< Lr1Configuration > & |
configs |
) |
|
To string function for configuration sets.
- Parameters:
-
| configs | the configuration set to turn into a string |
- Returns:
- the configuration set as a string
bool faudes::ContainsWord |
( |
const GrammarSymbolWordSet & |
set, |
|
|
const GrammarSymbolVector & |
word | |
|
) |
| | |
Test if a given set of words contains a specific word.
- Parameters:
-
| set | the set to be searched |
| word | the word to be searched for |
- Returns:
- true, if the set contains the word, else false
std::string faudes::ContributorsString |
( |
|
) |
|
Return contributors as std::string.
- Returns:
- std::string
void faudes::ControlProblemConsistencyCheck |
( |
const Generator & |
rPlantGen, |
|
|
const EventSet & |
rCAlph, |
|
|
const EventSet & |
rOAlph, |
|
|
const Generator & |
rSpecGen | |
|
) |
| | |
Consistency check for controlproblem input data.
Tests whether alphabets match and generators are deterministic.
- Parameters:
-
| rPlantGen | Plant generator |
| rCAlph | Controllable events |
| rOAlph | Observable events |
| rSpecGen | Specification generator |
- Exceptions:
-
| Exception |
- lphabets of generators don't match (id 100)
- plant generator nondeterministic (id 201)
- specification generator nondeterministic (id 203)
- plant and spec generator nondeterministic (id 204)
|
void faudes::ControlProblemConsistencyCheck |
( |
const Generator & |
rPlantGen, |
|
|
const EventSet & |
rCAlph, |
|
|
const Generator & |
rSpecGen | |
|
) |
| | |
Consistency check for controlproblem input data.
Tests whether alphabets match and generators are deterministic.
- Parameters:
-
| rPlantGen | Plant generator |
| rCAlph | Controllable events |
| rSpecGen | Specification generator |
- Exceptions:
-
| Exception |
- lphabets of generators don't match (id 100)
- plant generator nondeterministic (id 201)
- specification generator nondeterministic (id 203)
- plant and spec generator nondeterministic (id 204)
|
void faudes::ConvertParallelCompositionMap |
( |
const std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
std::map< Idx, std::pair< Idx, Idx > > & |
rCompositionMap | |
|
) |
| | |
Convert the reverse composition map of Parallel() by switching first and second entry.
- Parameters:
-
| rReverseCompositionMap | Input map as generated by Parallel(). |
| rCompositionMap | Converted map. |
void faudes::ConvertParallelCompositionMap |
( |
const map< pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
map< Idx, pair< Idx, Idx > > & |
rCompositionMap | |
|
) |
| | |
void faudes::CorrectEvents |
( |
const PushdownGenerator & |
correctPd, |
|
|
PushdownGenerator & |
pd | |
|
) |
| | |
Sets controllability and observability flags for a pushdown generator's events to the event flags of another pushdown generator.
- Parameters:
-
| correctPd | pushdown generator with correct flags |
| pd | this generator's event flags will be set to the correctPd's event flags |
void faudes::cParallel |
( |
const std::vector< System > & |
rGens, |
|
|
System & |
rResGen | |
|
) |
| | |
Parallel composition of multiple generators.
- Parameters:
-
| rGens | STL-vector of generators. |
| rResGen | Output variable for the resulting product generator. |
void faudes::cParallel |
( |
const vector< System > & |
rGens, |
|
|
System & |
rResGen | |
|
) |
| | |
void faudes::cParallel |
( |
const std::vector< const System * > & |
rGens, |
|
|
System & |
rResGen | |
|
) |
| | |
Parallel composition of multiple generators.
- Parameters:
-
| rGens | STL-vector of generators. |
| rResGen | Output variable for the resulting product generator. |
void faudes::CreateConstraint |
( |
int |
mType[5], |
|
|
Generator & |
constrP, |
|
|
Generator & |
constrE | |
|
) |
| | |
This function creates constraints which describe the condition of completeness and Yp-liveness of a Specification.
The implementation follows the same algorithm as the CreateSpec() function, and has the same limitation: it is only for use with a specific model
- Parameters:
-
| mType | By the type we specify type of the specification to build constraint for |
| constrP | Generator to the resulting operator constraint for the specification |
| constrE | Generator to the resulting environment constraint for the specification |
void faudes::CreateEntryStatesMap |
( |
const std::map< StateSet, Idx > & |
rRevEntryStatesMap, |
|
|
std::map< Idx, StateSet > & |
rEntryStatesMap | |
|
) |
| | |
void faudes::CreateSpec |
( |
int |
mType[5], |
|
|
HioPlant & |
rHioSpec, |
|
|
Generator & |
constrP, |
|
|
Generator & |
constrE | |
|
) |
| | |
This function creates new specification given by the type ("xxxxx") Note: The core of this function is a template specification model (SpecCB12.gen).
Based on this model are the specifications created, by simply adding corresponding states and transitions. Hence, for different models, this function can not be used directly, but can serve as an example.
- Parameters:
-
| mType | By the type we specify the desired behaviour we want to model |
| rHioSpec | HioPlant reference to the resulting specification (result) |
| constrP | Generator to the resulting operator constraint for the specification |
| constrE | Generator to the resulting environment constraint for the specification |
std::string faudes::CreateTempFile |
( |
void |
|
) |
|
Create a temp file, length 0.
- Returns:
- Name of temp file
bool faudes::CycleOfUnobsEvents |
( |
const System & |
rGen, |
|
|
std::string & |
rReport | |
|
) |
| | |
Test if there exist any cycles of unobservable events in a generator.
- Parameters:
-
| rGen | Input generator. |
| rReport | User-readable information of violating condition (in case of positive test result). |
- Returns:
- True if there exists a cycle of unobservable events.
bool faudes::CycleOfUnobsEvents |
( |
const System & |
rGen, |
|
|
string & |
rReport | |
|
) |
| | |
void faudes::CycleStartStates |
( |
const System & |
rGen, |
|
|
StateSet & |
rCycleOrigins | |
|
) |
| | |
Find all start/end states of cycles of unobservable events in a generator.
- Parameters:
-
| rGen | Input generator. |
| rCycleOrigins | Output variable for the states that have been found. |
void faudes::CycleStartStatesSearch |
( |
const System & |
rGen, |
|
|
StateSet & |
rTodo, |
|
|
Idx |
currState, |
|
|
StateSet |
statesOnPath, |
|
|
StateSet & |
rCycleOriginStates | |
|
) |
| | |
Auxiliary function for CycleStartStates().
Parses through the active event set of the current state and checks whether any of the successor states already occurred on the path to current state (then a cycle is found).
- Parameters:
-
| rGen | Input generator. |
| rTodo | States that remain to be processed. |
| currState | The current state. |
| statesOnPath | States that occurred on the path. |
| rCycleOriginStates | Output variable for the states that have been found. |
bool faudes::DecentralizedDiagnoser |
( |
const System & |
rGen, |
|
|
const Generator & |
rSpec, |
|
|
const EventSetVector & |
rAlphabets, |
|
|
GeneratorVector & |
rDiags | |
|
) |
| | |
Function definition for run-time interface.
void faudes::DecentralizedModularDiagnoser |
( |
const SystemVector & |
rGens, |
|
|
const Generator & |
rSpec, |
|
|
GeneratorVector & |
rDiags | |
|
) |
| | |
Function definition for run-time interface.
std::set< Lr1Configuration > faudes::Desc |
( |
const Grammar & |
gr, |
|
|
uint |
k, |
|
|
const std::set< Lr1Configuration > & |
config | |
|
) |
| | |
Obtain all descendants of a configuration set.
- Parameters:
-
| gr | the grammar on which to work |
| k | a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1)) |
| config | a set of configurations whose descendants are to be obtained |
- Returns:
- set of all descendant parser configurations
std::set< Lr1Configuration > faudes::Desc1 |
( |
const Grammar & |
gr, |
|
|
uint |
k, |
|
|
const std::set< Lr1Configuration > & |
configs | |
|
) |
| | |
Obtain the immediate descendants of configurations if the dot were pushed one nonterminal further.
- Parameters:
-
| gr | the grammar on which to work |
| k | a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1)) |
| configs | a set of configurations whose descendants are to be obtained |
- Returns:
- set of all immediate descendant parser configurations
std::set< Lr1Configuration > faudes::Desc11 |
( |
const Grammar & |
gr, |
|
|
uint |
k, |
|
|
const Lr1Configuration & |
config | |
|
) |
| | |
Obtain the immediate descendants of a configuration if the dot were pushed one nonterminal further.
- Parameters:
-
| gr | the grammar on which to work |
| k | a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1)) |
| config | the configuration whose descendants are to be obtained |
- Returns:
- set of all descendant parser configurations
Determine the initial parser configurations for a grammar.
- Parameters:
-
- Returns:
- a set with the initial configurations
void faudes::Deterministic |
( |
const Generator & |
rGen, |
|
|
std::vector< StateSet > & |
rPowerStates, |
|
|
std::vector< Idx > & |
rDetStates, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Make generator deterministic.
Constructs a deterministic generator while preserving the generated and marked languages. See Deterministic(const Generator&,Generator& rResGen) for the intended api. This version provides as second and third parameters the correspondence between new states and the original state sets. in vectors
- Parameters:
-
| rGen | Reference to generator |
| rPowerStates | Vector that holds the power states |
| rDetStates | Vector that holds the corresponding deterministic states |
| rResGen | Reference to resulting deterministic generator |
void faudes::Deterministic |
( |
const Generator & |
rGen, |
|
|
std::map< Idx, StateSet > & |
rEntryStatesMap, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Make generator deterministic.
Constructs a deterministic generator while preserving the generated and marked languages. See Deterministic(const Generator&,Generator& rResGen) for the intended api. This version provides as a second parameter the resulting map from new states to their respective original state set. It is used as a so called "entry state map" for deterministic projected generators.
- Parameters:
-
| rGen | Reference to generator |
| rEntryStatesMap | Entry state map |
| rResGen | Reference to resulting deterministic generator |
PushdownGenerator faudes::Dim |
( |
const PushdownGenerator & |
pd, |
|
|
const Terminal & |
augSymbol | |
|
) |
| | |
Remove the augmentation from the generator (diminish it).
This will remove all transitions whose event is the augment symbol and make those transitions start states final. It will also remove the augment symbol as an event.
- Parameters:
-
| pd | generator to diminish |
| augSymbol | the symbol with wich the grammar that was used to create the generator was augmented |
- Returns:
- diminished generator
bool faudes::DirectoryExists |
( |
const std::string & |
rDirectory |
) |
|
Test existence of directory.
- Parameters:
-
| rDitectory | Name of file to test |
- Returns:
- True <> can open directory for reading
bool faudes::EqualsGsVector |
( |
const GrammarSymbolVector & |
lhs, |
|
|
const GrammarSymbolVector & |
rhs | |
|
) |
| | |
void faudes::EventDiagnoser |
( |
const System & |
rOrigGen, |
|
|
const std::map< std::string, EventSet > & |
rFailureTypeMap, |
|
|
Diagnoser & |
rDiagGen | |
|
) |
| | |
Compute a standard diagnoser from an input generator and a failure partition.
- Parameters:
-
| rOrigGen | Input plant including failure events. |
| rFailureTypeMap | Failure partition: maps failure type names to failure events. |
| rDiagGen | Diagnoser generator for output. |
void faudes::EventDiagnoser |
( |
const System & |
rOrigGen, |
|
|
const map< string, EventSet > & |
rFailureTypeMap, |
|
|
Diagnoser & |
rDiagGen | |
|
) |
| | |
bool faudes::ExistsCycle |
( |
const System & |
rGen, |
|
|
std::string & |
rReport | |
|
) |
| | |
Test if there exist any cycles in a generator.
- Parameters:
-
| rGen | Input generator. |
| rReport | User-readable information of violating condition (in case of positive test result). |
- Returns:
- True if there exists a cycle.
bool faudes::ExistsCycle |
( |
const System & |
rGen, |
|
|
string & |
rReport | |
|
) |
| | |
bool faudes::ExistsCycleSearch |
( |
const System & |
rGen, |
|
|
StateSet & |
rTodo, |
|
|
Idx |
currState, |
|
|
StateSet |
statesOnPath, |
|
|
std::string & |
rReport | |
|
) |
| | |
Auxiliary function for ExistsCycle(const System&, std::string&).
Starting from a state currState, this function makes a depth-first-search through the generator rGen.
- Parameters:
-
| rGen | Input generator. |
| rTodo | States to process. |
| currState | Current state. |
| statesOnPath | States that occurred on the way to current state. |
| rReport | User-readable information of violating condition (in case of negative test result). |
- Returns:
- True if a cycle is found.
bool faudes::ExistsCycleSearch |
( |
const System & |
rGen, |
|
|
StateSet & |
rTodo, |
|
|
Idx |
currState, |
|
|
StateSet |
statesOnPath, |
|
|
string & |
rReport | |
|
) |
| | |
bool faudes::ExistsViolatingCyclesInGd |
( |
System & |
rGd, |
|
|
const Diagnoser & |
rGobs, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
const std::string & |
rFailureType, |
|
|
std::string & |
rReportString | |
|
) |
| | |
Remove states with same failure labels from rGd and from rReverseCompositionMap and perform cycle detection.
- Parameters:
-
| rGd | Input diagnoser generator. |
| rGobs | Generator G_o to look up failure labels. |
| rReverseCompositionMap | Mapping of G_d states with G_o states. |
| rFailureType | The considered failure type. |
| rReportString | User-readable information of violating condition (in case of negative test result). |
- Returns:
- True if violating cycles exist.
bool faudes::ExistsViolatingCyclesInGd |
( |
System & |
rGd, |
|
|
const Diagnoser & |
rGobs, |
|
|
map< pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
const string & |
rFailureType, |
|
|
string & |
rReportString | |
|
) |
| | |
void faudes::ExitFunction |
( |
void |
|
) |
|
std::string faudes::ExpandString |
( |
const std::string & |
rString, |
|
|
unsigned int |
len | |
|
) |
| | |
Fill string with spaces up to a given length if length of the string is smaller than given length parameter.
- Parameters:
-
| rString | string |
| len | Minimum number of charakters in string |
- Returns:
- Expanded string
void faudes::ExtendHighAlphabet |
( |
const Generator & |
rGen, |
|
|
EventSet & |
rHighAlph, |
|
|
map< Idx, Idx > & |
rMapStateToPartition | |
|
) |
| | |
std::string faudes::ExtractBasename |
( |
const std::string & |
rFullName |
) |
|
Extract file name from full path.
This version also remove the last suffix.
- Parameters:
-
| rFullName | Full path of file eg "/home/friend/data/generator.gen" |
- Returns:
- Filename "generator"
std::string faudes::ExtractDirectory |
( |
const std::string & |
rFullPath |
) |
|
Extract directory from full path.
- Parameters:
-
| rFullPath | Full name of file eg "/home/friend/data/generator.gen" |
- Returns:
- Directory eg "/home/friend/data"
std::string faudes::ExtractExtension |
( |
const std::string & |
rFullName |
) |
|
Extract file name from full path.
This version also remove the last suffix.
- Parameters:
-
| rFullName | Full path of file eg "/home/friend/data/generator.gen" |
- Returns:
- Extension "gen"
std::string faudes::ExtractFilename |
( |
const std::string & |
rFullName |
) |
|
Extract file name from full path.
- Parameters:
-
| rFullName | Full path of file eg "/home/friend/data/generator.gen" |
- Returns:
- Filename "generator.gen"
bool faudes::FailuresUnobservable |
( |
const System & |
rGen, |
|
|
const AttributeFailureTypeMap & |
rFailureTypeMap, |
|
|
std::string & |
rReport | |
|
) |
| | |
Check if all failure events are unobservable events in a generator's alphabet.
- Parameters:
-
| rGen | Input generator, is a model of the original plant containing the relevant failures events. |
| rFailureTypeMap | Failure partition: maps failure type names to failure events and indicator events. |
| rReport | User-readable information of violating condition (in case of negative result). |
- Returns:
- True if all failures events are unobservable.
bool faudes::FailuresUnobservable |
( |
const System & |
rGen, |
|
|
const AttributeFailureTypeMap & |
rFailureTypeMap, |
|
|
string & |
rReport | |
|
) |
| | |
const std::string& faudes::FaudesFunctionName |
( |
const Function & |
rObject |
) |
|
Determine certain words in a grammar.
The words are all lefthand sides and all righthand sides as well as the righthand sides' postfixes
- Parameters:
-
- Returns:
- all lefthand sides and all righthand sides' postfixes as words
bool faudes::FileCopy |
( |
const std::string & |
rFromFile, |
|
|
const std::string & |
rToFile | |
|
) |
| | |
Copy file.
- Parameters:
-
| rFromFile | Name of source file |
| rToFile | Name of dest file |
- Returns:
- True <> operation ok
bool faudes::FileDelete |
( |
const std::string & |
rFilename |
) |
|
Delete file.
- Parameters:
-
| rFilename | Name of file to delete |
- Returns:
- True <> could delete the file
bool faudes::FileExists |
( |
const std::string & |
rFilename |
) |
|
Test existence of file.
- Parameters:
-
| rFilename | Name of file to test |
- Returns:
- True <> can open file for reading
std::set< Nonterminal > faudes::Filter |
( |
const std::set< Nonterminal > & |
symbolSet, |
|
|
const GrammarSymbolVector & |
w | |
|
) |
| | |
Extract all symbols from the word that are in the symbol set.
- Parameters:
-
| symbolSet | the symbol set |
| w | the word |
- Returns:
- set of found symbols
NonterminalPtr faudes::Filter1 |
( |
const std::set< Nonterminal > & |
symbolSet, |
|
|
const GrammarSymbolVector & |
w | |
|
) |
| | |
Extract the first symbol from the word that is in the symbol set.
- Parameters:
-
| symbolSet | the symbol set |
| w | the word |
- Returns:
- pointer to the found symbol or NULL if none is found
std::set< Terminal > faudes::First |
( |
const Grammar & |
gr, |
|
|
const GrammarSymbolVector & |
word | |
|
) |
| | |
Determines which terminals can come first for a given word.
- Parameters:
-
| gr | the grammar on which to work |
| word | the word whose first terminals are to be determined |
- Returns:
- set of first terminals
GrammarSymbolWordMap faudes::First1 |
( |
const Grammar & |
gr, |
|
|
const GrammarSymbolWordMap & |
f, |
|
|
bool * |
madeChanges | |
|
) |
| | |
Updates the function which maps words to their first possible terminal symbols.
Must be called until no changes are made in order to have a complete mapping.
- Parameters:
-
| gr | the grammar on which to work |
| f | the mapping function (word -> first symbols) |
| madeChanges | this variable will be written to true if changes were made and written to false if no changes were made |
- Returns:
- the updated first function
std::set< Terminal > faudes::FirstA |
( |
const Grammar & |
gr, |
|
|
const GrammarSymbolVector & |
word | |
|
) |
| | |
Determines which terminals can come first for a given word.
The word must be in Fds()!
- Parameters:
-
| gr | the grammar on which to work |
| word | the word whose first terminals are to be determined |
- Returns:
- set of first terminals
std::set< Terminal > faudes::FirstAll |
( |
const Grammar & |
gr, |
|
|
const GrammarSymbolVector & |
word | |
|
) |
| | |
Determines which terminals can come first for a given word and ensures that the word can be entirely reduced.
- Parameters:
-
| gr | the grammar on which to work |
| word | the word whose first terminals are to be determined |
- Returns:
- set of first terminals or empty set, if the word cannot be entirely reduced
Builds a function that maps words to their first possible terminal symbols by recursively calling First1.
- Parameters:
-
| gr | the grammar on which to work |
| f | the mapping function (word -> first symbols) |
- Returns:
- the first function
std::set< Terminal > faudes::FirstLeq1 |
( |
const Grammar & |
gr, |
|
|
uint |
k, |
|
|
const GrammarSymbolVector & |
word | |
|
) |
| | |
Determine which terminals can come first for a given word for any k <= 1.
- Parameters:
-
| gr | the grammar on which to work |
| k | a natural number k |
| word | the word whose first terminals are to be determined |
- Returns:
- for k = 1 and k = 0: set of first terminals for k = 0 and set of first terminals not empty: lambda for k > 1: empty set
std::set< Terminal > faudes::FirstRed |
( |
const Grammar & |
gr, |
|
|
const GrammarSymbolVector & |
word | |
|
) |
| | |
Calls first, but only if all symbols in the word are in the grammar as well.
- Parameters:
-
| gr | the grammar |
| word | the word |
- Returns:
- set of first terminals or empty set if the word contained symbols not in the grammar
std::set< Idx > faudes::GeneratorGoto |
( |
const GotoGenerator & |
gotoGen, |
|
|
Idx |
state, |
|
|
const GrammarSymbolPtr & |
symbol | |
|
) |
| | |
Find the successor states of a state for a given input symbol.
- Parameters:
-
| gotoGen | the generator on which to work |
| state | the state of which to find the successor state |
| symbol | the input symbol |
- Returns:
- A set with the successor states. The set size is 1 if a successor state is found. Set size is 0 if no successor state is found.
std::vector< Idx > faudes::GeneratorGotoSeq |
( |
const GotoGenerator & |
gotoGen, |
|
|
Idx |
startState, |
|
|
const GrammarSymbolVector & |
word | |
|
) |
| | |
Find the successor state sequence of a state for a given input word.
If the word cannot be completely matched to a state sequence, the state sequence will be partially matched (i. e., it will be as long as the part of the word that can be matched).
- Parameters:
-
| gotoGen | the generator on which to work |
| state | the state of which to find the successor state |
| word | the input word |
- Returns:
- A set with the successor states. The set size will be anywhere between 0 and the length of the word.
StackSymbolSet faudes::GetPossibleStackTops |
( |
const PushdownGenerator & |
pd, |
|
|
const StateSet & |
examinedStates, |
|
|
Idx |
q | |
|
) |
| | |
Get all possible stack top symbols for a state.
- Parameters:
-
| pd | the pushdown generator containing the state |
| examinedStates | the already examined states |
| q | the state |
- Returns:
- set of all possible stack top symbols
std::set< Lr1Configuration > faudes::GoTo |
( |
const Grammar & |
gr, |
|
|
uint |
k, |
|
|
const std::set< Lr1Configuration > |
configs, |
|
|
const GrammarSymbolPtr & |
symbol | |
|
) |
| | |
Try to shift the dots in a configurations set and obtain the shifted configuration set's descendants.
- Parameters:
-
| gr | the grammar on which to work |
| k | a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1)) |
| configs | the configurations |
| symbol | the symbol over which to shift |
- Returns:
- set containing the shifted configuration's descendant configurations
PushdownGenerator faudes::Gp2Pp |
( |
const GotoGenerator & |
gotoGen, |
|
|
const Lr1Parser & |
parser | |
|
) |
| | |
Converts a parser into a pushdown generator.
The stack symbols will be the parser's nonterminals
- Parameters:
-
| gotoGen | Lr(k) machine of the grammar that the parser parses |
| parser | the parser to convert |
- Returns:
- the parser as a pushdown generator
void faudes::GroupHioModules |
( |
const std::vector< HioModule * > & |
rChildren, |
|
|
HioModule & |
rParentModule | |
|
) |
| | |
GroupHioModules: This function groups two or more HioModules to a new HioModule.
The new HioModule represents the uncontrolled behaviour of the composed HioModules.
- Parameters:
-
| rChildren | vector of HioModules to group |
| rParentModule | resulting HioModule |
void faudes::HioShuffle_Musunoi |
( |
const HioPlant & |
rPlantA, |
|
|
const HioPlant & |
rPlantB, |
|
|
int |
depth, |
|
|
Generator & |
rIOShuffAB | |
|
) |
| | |
void faudes::HioStatePartition |
( |
HioPlant & |
rPlant |
) |
|
Function definition for run-time interface.
- Parameters:
-
void faudes::HioStatePartition |
( |
HioEnvironment & |
rEnvironment |
) |
|
Function definition for run-time interface.
- Parameters:
-
| rEnvironment | HioEnvironment |
void faudes::HioStatePartition |
( |
HioController & |
rController |
) |
|
Function definition for run-time interface.
- Parameters:
-
| rController | HioController |
void faudes::HioStatePartition |
( |
HioConstraint & |
rConstraint |
) |
|
Function definition for run-time interface.
- Parameters:
-
| rConstraint | HioConstraint |
void faudes::HioSynth_Musunoi |
( |
const Generator & |
rPlant, |
|
|
const HioPlant & |
rSpec, |
|
|
const Generator & |
rConstr, |
|
|
const Generator & |
rLocConstr, |
|
|
const EventSet & |
rYp, |
|
|
const EventSet & |
rUp, |
|
|
Generator & |
rController | |
|
) |
| | |
void faudes::insertRelabeledEvents |
( |
Generator & |
rGenPlant, |
|
|
const std::map< Idx, std::set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::insertRelabeledEvents |
( |
System & |
rGenPlant, |
|
|
const std::map< Idx, std::set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::insertRelabeledEvents |
( |
Generator & |
rGenPlant, |
|
|
const std::map< Idx, std::set< Idx > > & |
rMapRelabeledEvents, |
|
|
EventSet & |
rNewEvents | |
|
) |
| | |
Convenience function for relabeling events in a given generator.
This function inserts new events and respective transitions given by a relableing map into a given generator.
Technical note: Recording of new events includes attributes, provided that the third parameter has a compatible attribute type.
There are no restrictions on parameters.
- Parameters:
-
| rGenPlant | Plant component automaton |
| rMapRelabeledEvents | Maps the original events to sets of newly introduced events |
| rNewEvents | Returns the newly inserted events (accumulative, call clear before) |
void faudes::insertRelabeledEvents |
( |
System & |
rGenPlant, |
|
|
const std::map< Idx, std::set< Idx > > & |
rMapRelabeledEvents, |
|
|
Alphabet & |
rNewEvents | |
|
) |
| | |
Convenience function for relabeling events in a given generator.
This function inserts new events and respective transitions given by a relableing map into a given generator. The function is used to adjust plant components to the relableing from another plant component.
Technical note: This version records newly inserted events incl. their respective controllability attribute in the third parameter. T
There are no restrictions on parameters.
- Parameters:
-
| rGenPlant | Plant component automaton |
| rMapRelabeledEvents | Maps the original events to sets of newly introduced events |
| rNewEvents | Returns the newly inserted events (accumulative, call clear before) |
void faudes::insertRelabeledEvents |
( |
Generator & |
rGenPlant, |
|
|
const EventRelabelMap & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::insertRelabeledEvents |
( |
Generator & |
rGenPlant, |
|
|
const EventRelabelMap & |
rMapRelabeledEvents, |
|
|
EventSet & |
rNewEvents | |
|
) |
| | |
void faudes::insertRelabeledEvents |
( |
Generator & |
rGenPlant, |
|
|
const map< Idx, set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::insertRelabeledEvents |
( |
System & |
rGenPlant, |
|
|
const map< Idx, set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::insertRelabeledEvents |
( |
Generator & |
rGenPlant, |
|
|
const map< Idx, set< Idx > > & |
rMapRelabeledEvents, |
|
|
EventSet & |
rNewEvents | |
|
) |
| | |
void faudes::insertRelabeledEvents |
( |
System & |
rGenPlant, |
|
|
const map< Idx, set< Idx > > & |
rMapRelabeledEvents, |
|
|
Alphabet & |
rNewEvents | |
|
) |
| | |
long int faudes::IntegerSum |
( |
const IntegerVector & |
intvect |
) |
|
long int faudes::IntegerSum |
( |
const Integer & |
arg1, |
|
|
const Integer & |
arg2 | |
|
) |
| | |
void faudes::IntersectEvents |
( |
const System & |
s, |
|
|
const PushdownGenerator & |
pd, |
|
|
PushdownGenerator & |
rPd | |
|
) |
| | |
Adds the intersection of events of the first two generators to the result generator.
The function considers observability and controllability, so observability and controllability attributes will be kept.
- Parameters:
-
| s | first generator |
| pd | second generator |
| rPd | result generator |
void faudes::IoStatePartition |
( |
IoSystem & |
rIoSystem |
) |
|
Construct io state partition.
This is an rti wrapper for bool IsIoSystem(IoSystem&).
- Parameters:
-
| rIoSystem | Generator to test. |
void faudes::IoSynthesis |
( |
const IoSystem & |
rPlant, |
|
|
const Generator & |
rSpec, |
|
|
IoSystem & |
rSup | |
|
) |
| | |
IO system synthesis.
This method esentially is a wrapper for SupConComplete(), which implements a synthesis procedure to compute the supremal controllable and complete sublanguage for a given plant and specification. Input events are regarded controllable. marking is ignored, i.e., synthesis refers to the generated langugaes rather than the the marked languages. For a version thet refers to Buchi acceptance condition, see IoSynthesisNB(const IoSystem&, const Generator&, IoSystem&).
The resulting supervisor is an IO System with the plant input events as outputs and vice versa.
Note that this routine does not test whether the plant has a locally free input U, nor does it ensure that the resulting supervisor has a free input Y.
- Parameters:
-
| rPlant | IO-System - plant model |
| rSpec | Generator - specification |
| rSup | IO-System - supervisor |
- Exceptions:
-
| Exception |
- Any exceptions passed on from SupConComplete
|
void faudes::IoSynthesisNB |
( |
const IoSystem & |
rPlant, |
|
|
const Generator & |
rSpec, |
|
|
IoSystem & |
rSup | |
|
) |
| | |
IO system synthesis.
This method esentially is a wrapper for SupConOmegaNB(), which implements a synthesis procedure to compute the supremal omega-controllable. sublanguage for a given plant and specification. Input events are regarded controllable. In contrast to IoSynthesis(const IoSystem&, const Generator&, IoSystem&), this procedure refers to the Bucji acceptance condition and ensures a omega-nonblocking closed-loop behaviour.
The resulting supervisor is an IO System with the plant input events as outputs and vice versa.
Note that this routine does not test whether the plant has a locally free input U, nor does it ensure that the resulting supervisor has a free input Y.
- Parameters:
-
| rPlant | IO-System - plant model |
| rSpec | Generator - specification |
| rSup | IO-System - supervisor |
- Exceptions:
-
| Exception |
- Any exceptions passed on from SupConOmegaNB
|
bool faudes::IsCoDiagnosable |
( |
const System & |
rGen, |
|
|
const Generator & |
rSpec, |
|
|
const EventSetVector & |
rAlphabets | |
|
) |
| | |
Function definition for run-time interface.
bool faudes::IsCoDiagnosable |
( |
const System & |
rGen, |
|
|
const Generator & |
rSpec, |
|
|
const vector< const EventSet * > & |
rAlphabets, |
|
|
std::string & |
rReportString | |
|
) |
| | |
bool faudes::IsComplete |
( |
const vGenerator & |
rGen, |
|
|
const StateSet & |
rStateSet | |
|
) |
| | |
bool faudes::IsControllableUnchecked |
( |
const Generator & |
rPlantGen, |
|
|
const EventSet & |
rCAlph, |
|
|
const Generator & |
rSpecGen, |
|
|
StateSet & |
rCriticalStates | |
|
) |
| | |
Controllability (internal function).
Checks if language of specification h is controllable with respect to language of generator g. Only for deterministic plant + spec. Controllable event set has to be given as parameter.
This internal function performs no consistency test of the given parameter.
- Parameters:
-
| rPlantGen | Plant generator |
| rCAlph | Controllable events |
| rSpecGen | Specification generator |
| rCriticalStates | Set of critical states |
- Exceptions:
-
| Exception |
- alphabets of generators don't match (id 100)
- plant generator nondeterministic (id 201)
- specification generator nondeterministic (id 203)
- plant & spec generator nondeterministic (id 204)
|
- Returns:
- true / false
bool faudes::IsEventDiagnosable |
( |
const System & |
rGen, |
|
|
const AttributeFailureTypeMap & |
rFailureTypeMap | |
|
) |
| | |
Function definition for run-time interface.
bool faudes::IsEventDiagnosable |
( |
const System & |
rGen, |
|
|
const AttributeFailureTypeMap & |
rFailureTypeMap, |
|
|
string & |
rReportString | |
|
) |
| | |
bool faudes::isExtendedEk |
( |
const Generator & |
tildeGen, |
|
|
const Generator & |
rGen, |
|
|
EventSet & |
ek | |
|
) |
| | |
bool faudes::IsHioConstraintForm |
( |
HioConstraint & |
rHioConstraint |
) |
|
IsHioConstraintForm: check if rHioConstraint is in I/O-constraint form and assign state attributes.
This function tests if rHioConstraint meets the I/O-constraint form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioConstraint formally describe an I/O constraint. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QY flag is assigned to a state if its active eventset is a subset of the Y-Alphabet. The assignment of HioStateFlags is complete only if IsHioConstraintForm() returns true. Method: all conditions of the formal I/O-constraint form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
- Returns:
- true if rHioConstraint is in I/O-constraint form
bool faudes::IsHioConstraintForm |
( |
HioConstraint & |
rHioConstraint, |
|
|
std::string & |
rReportStr | |
|
) |
| | |
IsHioConstraintForm: check if rHioConstraint is in I/O-constraint form and assign state attributes.
This function tests if rHioConstraint meets the I/O-constraint form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioConstraint formally describe an I/O constraint. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QY flag is assigned to a state if its active eventset is a subset of the Y-Alphabet. The assignment of HioStateFlags is complete only if IsHioConstraintForm() returns true. Method: all conditions in the formal I/O-constraint form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
| rHioConstraint | HioConstraint to check, HioStateFlags are set |
| rReportStr | Information about test results |
- Returns:
- true if rHioConstraint is in I/O-constraint form
bool faudes::IsHioConstraintForm |
( |
HioConstraint & |
rHioConstraint, |
|
|
StateSet & |
rQY, |
|
|
StateSet & |
rQU, |
|
|
EventSet & |
rErrEvSet, |
|
|
TransSet & |
rErrTrSet, |
|
|
StateSet & |
rErrStSet, |
|
|
std::string & |
rReportStr | |
|
) |
| | |
IsHioConstraintForm: check if rHioConstraint is in I/O-constraint form and assign state attributes.
This function tests if rHioConstraint meets the I/O-constraint form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioConstraint formally describe an I/O constraint. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QY flag is assigned to a state if its active eventset is a subset of the Y-Alphabet. The assignment of HioStateFlags is complete only if IsHioConstraintForm() returns true. Method: all conditions in the formal I/O-constraint form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
| rHioConstraint | HioConstraint to check, HioStateFlags are set |
| rQY | State set containing all QY states |
| rQU | State set containing all QU states |
| rErrEvSet | Event set for possible 'bad' events |
| rErrTrSet | Event set for possible 'bad' transition relations |
| rErrStSet | Event set for possible 'bad' states |
| rReportStr | Information about test results |
- Returns:
- true if rHioConstraint is in I/O-constraint form
bool faudes::IsHioControllerForm |
( |
HioController & |
rHioController |
) |
|
IsHioControllerForm: check if rHioController is in I/O-controller form and assign state attributes.
This function tests if rHioController meets the I/O-controller form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioController formally describe an I/O controller. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYcUp flag is assigned to a state if its active eventset is a subset of the union of the YC- and the UP-Alphabet. The assignment of HioStateFlags is complete only if IsHioControllerForm() returns true. Method: all conditions of the formal I/O-controller form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
- Returns:
- true if rHioController is in I/O-controller form
bool faudes::IsHioControllerForm |
( |
HioController & |
rHioController, |
|
|
std::string & |
rReportStr | |
|
) |
| | |
IsHioControllerForm: check if rHioController is in I/O-controller form and assign state attributes.
This function tests if rHioController meets the I/O-controller form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioController formally describe an I/O controller. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYcUp flag is assigned to a state if its active eventset is a subset of the union of the YC- and the UP-Alphabet. The assignment of HioStateFlags is complete only if IsHioControllerForm() returns true. Method: all conditions in the formal I/O-controller form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
| rHioController | HioController to check, HioStateFlags are set |
| rReportStr | Information about test results |
- Returns:
- true if rHioController is in I/O-controller form
bool faudes::IsHioControllerForm |
( |
HioController & |
rHioController, |
|
|
StateSet & |
rQUc, |
|
|
StateSet & |
rQYP, |
|
|
StateSet & |
rQUp, |
|
|
StateSet & |
rQYcUp, |
|
|
EventSet & |
rErrEvSet, |
|
|
TransSet & |
rErrTrSet, |
|
|
StateSet & |
rErrStSet, |
|
|
std::string & |
rReportStr | |
|
) |
| | |
IsHioControllerForm: check if rHioController is in I/O-controller form and assign state attributes.
This function tests if rHioController meets the I/O-controller form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioController formally describe an I/O controller. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYcUp flag is assigned to a state if its active eventset is a subset of the union of the YC- and the UP-Alphabet. The assignment of HioStateFlags is complete only if IsHioControllerForm() returns true. Method: all conditions in the formal I/O-controller form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
| rHioController | HioController to check, HioStateFlags are set |
| rQUc | State set containing all QUc states |
| rQYP | State set containing all QYP states |
| rQUp | State set containing all QUp states |
| rQYcUp | State set containing all QYcUp states |
| rErrEvSet | Event set for possible 'bad' events |
| rErrTrSet | Event set for possible 'bad' transition relations |
| rErrStSet | Event set for possible 'bad' states |
| rReportStr | Information about test results |
- Returns:
- true if rHioController is in I/O-controller form
bool faudes::IsHioEnvironmentForm |
( |
HioEnvironment & |
rHioEnvironment |
) |
|
IsHioEnvironmentForm: check if rHioEnvironment is in I/O-environment form and assign state attributes.
This function tests if rHioEnvironment meets the I/O-environment form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioEnvironment formally describe an I/O environment. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYlUe flag is assigned to a state if its active eventset is a subset of the union of the YL- and the UE-Alphabet. The assignment of HioStateFlags is complete only if IsHioEnvironmentForm() returns true. Method: all conditions of the formal I/O-environment form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
- Returns:
- true if rHioEnvironment is in I/O-environment form
bool faudes::IsHioEnvironmentForm |
( |
HioEnvironment & |
rHioEnvironment, |
|
|
std::string & |
rReportStr | |
|
) |
| | |
IsHioEnvironmentForm: check if rHioEnvironment is in I/O-environment form and assign state attributes.
This function tests if rHioEnvironment meets the I/O-environment form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioEnvironment formally describe an I/O environment. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYlUe flag is assigned to a state if its active eventset is a subset of the union of the YL- and the UE-Alphabet. The assignment of HioStateFlags is complete only if IsHioEnvironmentForm() returns true. Method: all conditions in the formal I/O-environment form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
| rHioEnvironment | HioEnvironment to check, HioStateFlags are set |
| rReportStr | Information about test results |
- Returns:
- true if rHioEnvironment is in I/O-environment form
bool faudes::IsHioEnvironmentForm |
( |
HioEnvironment & |
rHioEnvironment, |
|
|
StateSet & |
rQYe, |
|
|
StateSet & |
rQUe, |
|
|
StateSet & |
rQUl, |
|
|
StateSet & |
rQYlUe, |
|
|
EventSet & |
rErrEvSet, |
|
|
TransSet & |
rErrTrSet, |
|
|
StateSet & |
rErrStSet, |
|
|
std::string & |
rReportStr | |
|
) |
| | |
IsHioEnvironmentForm: check if rHioEnvironment is in I/O-environment form and assign state attributes.
This function tests if rHioEnvironment meets the I/O-environment form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioEnvironment formally describe an I/O environment. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYlUe flag is assigned to a state if its active eventset is a subset of the union of the YL- and the UE-Alphabet. The assignment of HioStateFlags is complete only if IsHioEnvironmentForm() returns true. Method: all conditions in the formal I/O-environment form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
| rHioEnvironment | HioEnvironment to check, HioStateFlags are set |
| rQYe | State set containing all QYe states |
| rQUe | State set containing all QUe states |
| rQUl | State set containing all QUl states |
| rQYlUe | State set containing all QYlUe states |
| rErrEvSet | Event set for possible 'bad' events |
| rErrTrSet | Event set for possible 'bad' transition relations |
| rErrStSet | Event set for possible 'bad' states |
| rReportStr | Information about test results |
- Returns:
- true if rHioEnvironment is in I/O-environment form
bool faudes::IsHioPlantForm |
( |
HioPlant & |
rHioPlant |
) |
|
IsHioPlantForm: check if rHioPlant is in I/O-plant form and assign state attributes.
Function definition for run-time interface.
This function tests if rHioPlant meets the I/O-plant form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioPlant formally describe an I/O plant. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYpYe flag is assigned to a state if its active eventset is a subset of the union of the YP- and the YE-Alphabet. The assignment of HioStateFlags is complete only if IsHioPlantForm() returns true. Method: all conditions of the formal I/O-plant form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
- Returns:
- true if rHioPlant is in I/O-plant form
bool faudes::IsHioPlantForm |
( |
HioPlant & |
rHioPlant, |
|
|
std::string & |
rReportStr | |
|
) |
| | |
IsHioPlantForm: check if rHioPlant is in I/O-plant form and assign state attributes.
Function definition for run-time interface.
This function tests if rHioPlant meets the I/O-plant form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioPlant formally describe an I/O plant. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYpYe flag is assigned to a state if its active even set is a subset of the union of the YP- and the YE-Alphabet. The assignment of HioStateFlags is complete only if IsHioPlantForm() returns true. Method: all conditions in the formal I/O-plant form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
| rHioPlant | HioPlant to check, HioStateFlags are set |
| rReportStr | Information about test results |
- Returns:
- true if rHioPlant is in I/O-plant form
bool faudes::IsHioPlantForm |
( |
HioPlant & |
rHioPlant, |
|
|
StateSet & |
rQYpYe, |
|
|
StateSet & |
rQUp, |
|
|
StateSet & |
rQUe, |
|
|
EventSet & |
rErrEvSet, |
|
|
TransSet & |
rErrTrSet, |
|
|
StateSet & |
rErrStSet, |
|
|
std::string & |
rReportStr | |
|
) |
| | |
IsHioPlantForm: check if rHioPlant is in I/O-plant form and assign state attributes.
Function definition for run-time interface.
This function tests if rHioPlant meets the I/O-plant form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioPlant formally describe an I/O plant. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYpYe flag is assigned to a state if its active even set is a subset of the union of the YP- and the YE-Alphabet. The assignment of HioStateFlags is complete only if IsHioPlantForm() returns true. Method: all conditions in the formal I/O-plant form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
| rHioPlant | HioPlant to check, HioStateFlags are set |
| rQYpYe | State set containing all QYpYe states |
| rQUp | State set containing all QUp states |
| rQUe | State set containing all QUe states |
| rErrEvSet | Event set for possible 'bad' events |
| rErrTrSet | Event set for possible 'bad' transition relations |
| rErrStSet | Event set for possible 'bad' states |
| rReportStr | Information about test results |
- Returns:
- true if rHioPlant is in I/O-plant form
bool faudes::IsIndicatorEventDiagnosable |
( |
const System & |
rGen, |
|
|
const AttributeFailureTypeMap & |
rFailureTypeMap | |
|
) |
| | |
Function definition for run-time interface.
bool faudes::IsIndicatorEventDiagnosable |
( |
const System & |
rGen, |
|
|
const AttributeFailureTypeMap & |
rFailureTypeMap, |
|
|
string & |
rReportString | |
|
) |
| | |
bool faudes::IsLanguageDiagnosable |
( |
const System & |
rGen, |
|
|
const System |
rSpec, |
|
|
std::string & |
rReportString | |
|
) |
| | |
Test function to verify language-diagnosability.
bool faudes::IsLanguageDiagnosable |
( |
const System & |
rGen, |
|
|
const System & |
rSpec | |
|
) |
| | |
Function definition for run-time interface.
bool faudes::IsLCC |
( |
const Generator & |
rLowGen, |
|
|
const EventSet & |
rControllableEvents, |
|
|
const EventSet & |
rHighAlph | |
|
) |
| | |
Verification of local control consistency (LCC).
For verifying if a natural projection fulfills the local control consistency condition, a backward reachability is conducted. If starting from a state, where an uncontrollable high-level event is feasible, at least one local state cannot be reached by an uncontrollable path, LCC is violated.
- Parameters:
-
| rLowGen | Input generator |
| rControllableEvents | set of controllable events |
| rHighAlph | High level alphabet |
- Returns:
- true if LCC holds
bool faudes::IsLive |
( |
const System & |
rGen, |
|
|
std::string & |
rReport | |
|
) |
| | |
Test if a generator is live.
- Parameters:
-
| rGen | Input generator. |
| rReport | User-readable information of violating condition (in case of negative result). |
- Returns:
- True if generator is live.
bool faudes::IsLive |
( |
const System & |
rGen, |
|
|
string & |
rReport | |
|
) |
| | |
bool faudes::IsModularDiagnosable |
( |
const SystemVector & |
rGsubs, |
|
|
const GeneratorVector & |
rKsubs | |
|
) |
| | |
Function definition for run-time interface.
bool faudes::IsModularDiagnosable |
( |
const vector< const System * > & |
rGSubs, |
|
|
const vector< const Generator * > & |
rKSubs, |
|
|
std::string & |
rReportString | |
|
) |
| | |
bool faudes::IsModularDiagnosable |
( |
const SystemVector & |
rGsubs, |
|
|
const GeneratorVector & |
rKsubs, |
|
|
string & |
rReportString | |
|
) |
| | |
bool faudes::IsMtcObs |
( |
const MtcSystem & |
rLowGen, |
|
|
const EventSet & |
rHighAlph | |
|
) |
| | |
Verification of the observer property.
For verifying if a natural projection has the observer property, one step in the observer algorithm is evaluated. If the resulting generator equals the input generator, then the natural projection on the abstraction alphabet is an observer.
- Parameters:
-
| rLowGen | Input generator |
| rHighAlph | High level alphabet |
- Returns:
- true if the observer property holds
void faudes::IsMutuallyControllable |
( |
const System & |
rGen1, |
|
|
const System & |
rGen2, |
|
|
bool & |
rRes | |
|
) |
| | |
bool faudes::IsMutuallyControllable |
( |
const System & |
rGen1, |
|
|
const System & |
rGen2, |
|
|
StateSet & |
rForbidden1, |
|
|
StateSet & |
rForbidden2 | |
|
) |
| | |
Verification of mutual controllability.
This function checks if two generators are mutually controllable w.r.t. each other. Additionally, this function provides the states where mutual controllability fails in case the condition is violated.
- Parameters:
-
| rGen1 | Generator 1 |
| rGen2 | Generator 2 |
| rForbidden1 | Forbidden states in Generator 1 |
| rForbidden2 | Forbidden states in Generator 2 |
- Returns:
- True if mutual controllability is fulfilled
bool faudes::IsNormal |
( |
const System & |
rPlantGen, |
|
|
const Generator & |
rSupCandGen | |
|
) |
| | |
IsNormal wrapper.
Wrapper for convenient access via the run-time interface.
bool faudes::IsOCC |
( |
const Generator & |
rLowGen, |
|
|
const EventSet & |
rControllableEvents, |
|
|
const EventSet & |
rHighAlph | |
|
) |
| | |
Verification of output control consistency (OCC).
For verifying if a natural projection fulfills the output control consistency condition, a backward reachability is conducted. If starting from a state, where an uncontrollable high-level event is feasible, a controllable event can be reached on a local backward path, OCC is violated.
- Parameters:
-
| rLowGen | Input generator |
| rControllableEvents | set of controllable events |
| rHighAlph | High level alphabet |
- Returns:
- true if OCC holds
bool faudes::IsRelativelyOmegaClosedUnchecked |
( |
const Generator & |
rGenPlant, |
|
|
const Generator & |
rGenCand | |
|
) |
| | |
Test for relative closedness, omega languages.
This variant does not perform consitency tests on the parameters. Neither does it handle the special cases on empty arguments. See also IsRelativelyOmegaClosed(const Generator&, const Generator& )
- Parameters:
-
| rGenPlant | Generator GPlant |
| rGenCand | Generator GCand |
void faudes::LabelCorrection |
( |
const std::multimap< Idx, DiagLabelSet > & |
mm, |
|
|
AttributeDiagnoserState & |
attr | |
|
) |
| | |
Perform label correction on propagated failure type labels.
- Parameters:
-
| mm | Propagated absolute failure type labels for a diagnoser state. |
| attr | Output variable for the diagnoser state attribute. |
void faudes::LabelCorrection |
( |
const multimap< Idx, DiagLabelSet > & |
mm, |
|
|
AttributeDiagnoserState & |
attr | |
|
) |
| | |
void faudes::LabelPropagation |
( |
const DiagLabelSet & |
lastLabel, |
|
|
const DiagLabelSet & |
failureTypes, |
|
|
DiagLabelSet & |
newLabel | |
|
) |
| | |
Generate a new label.
From the last label and the failure types that occurred on the way, the new label is generated.
- Parameters:
-
| lastLabel | Diagnoser label of state estimate. |
| failureTypes | Failure types that occurred. |
| newLabel | Output variable for the new label. |
void faudes::LanguageIntersection |
( |
const GeneratorVector & |
rGenVec, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Language intersection.
See also LanguageUnion(const Generator&, const Generator&, Generator&); This version takes a vector of generators as argument to perform the intersection for multiple languages. The implementation calls the std intersection multiple times, future implementations may do better.
- Parameters:
-
| rGenVec | Vector of input generators |
| rResGen | Reference to resulting generator |
void faudes::LanguageUnion |
( |
const GeneratorVector & |
rGenVec, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Language union.
See also LanguageUnion(const Generator&, const Generator&, Generator&); This version takes a vector of generators as argument to perform the union for multiple languages. The implementation calls the std union multiple times, future implementations may do better.
- Parameters:
-
| rGenVec | Vector of input generators |
| rResGen | Reference to resulting generator |
void faudes::LocalAccessibleReach |
( |
const Generator & |
rLowGen, |
|
|
const EventSet & |
rHighAlph, |
|
|
Idx |
lowState, |
|
|
StateSet & |
rAccessibleReach | |
|
) |
| | |
Compute the accessible reach for a local automaton.
- Parameters:
-
| rLowGen | Low level generator |
| rHighAlph | High level alphabet |
| lowState | Low level entry state |
| rAccessibleReach | Result |
void faudes::LocalCoaccessibleReach |
( |
const TransSetX2EvX1 & |
rRevTransRel, |
|
|
const EventSet & |
rHighAlph, |
|
|
Idx |
lowState, |
|
|
StateSet & |
rCoaccessibleReach | |
|
) |
| | |
Compute the coaccessible reach for a local automaton.
- Parameters:
-
| rRevTransRel | Reverse sorted transition relation |
| rHighAlph | High level alphabet |
| lowState | Low level exit state |
| rCoaccessibleReach | Result |
bool faudes::LocalObservationConsistency |
( |
const System & |
rPlantGen, |
|
|
const System & |
rSpecGen, |
|
|
const EventSet & |
rHighAlph, |
|
|
const EventSet & |
rObsAlph | |
|
) |
| | |
Supervisor Reduction algorithm.
Computes a reduced supervisor from a given potentially non-reduced supervisor and the plant. This algorithm implements the results obtained in
R. Su and W. M. Wonham. Supervisor Reduction for Discrete-Event Systems. Discrete Event Dynamic Systems vol. 14, no. 1, January 2004.
Both, plant and supervisor MUST be deterministic and share the same alphabet!!!
- Parameters:
-
| rPlantGen | Plant generator |
| rSpecGen | Specification generator |
| rHighAlph | high-level alphabet |
| rObsAlph | observable alphabet |
- Returns:
- True if a reduction was achieved
- Exceptions:
-
| Exception |
- alphabets of generators don't match (id 100)
- plant nondeterministic (id 201)
- supervisor nondeterministic (id 203)
- plant and supervisor nondeterministic (id 204)
|
void faudes::LoopCallback |
( |
bool(*)(void) |
pBreakFnct |
) |
|
Algorithm loop callback.
Set a callback function for libFAUDES algorithms. Applications are meant to use this interface to terminate an algorithm on user request. libFAUDES algorithms are meant to throw an execption when the callback function returns true. See also void LoopCallback(void).
- Parameters:
-
void faudes::LoopCallback |
( |
void |
|
) |
|
Algorithm loop callback.
Calls the loop callback function and throws an exception if it returns true.
- Exceptions:
-
| Break | on appliation request (id 110) |
void faudes::LoopCallback |
( |
bool |
pBreakvoid |
) |
|
void faudes::LowExitStates |
( |
const EventSet & |
rHighAlph, |
|
|
const std::map< Idx, StateSet > & |
rEntryStatesMap, |
|
|
const TransSetX2EvX1 & |
rLowRevTransRel, |
|
|
Idx |
highState, |
|
|
StateSet & |
rLowExitStates | |
|
) |
| | |
LowExitStates call-by-reference function:
Compute the low level exit states for a corresponding hi level state
- Parameters:
-
| rHighAlph | High level events |
| rEntryStatesMap | Entry states map (see CreateEntryStatesMap(resmap)) |
| rLowRevTransRel | Reverse sorted low level transition relation |
| highState | Hi level state for which to compute low level exit states |
| rLowExitStates | Reference to StateSet for low level exit states (result) |
- Exceptions:
-
| Exception | Hi level state not found in entry states map (with FAUDES_CHECKED) |
StateSet faudes::LowExitStates |
( |
const Generator & |
rLowGen, |
|
|
const EventSet & |
rHighAlph, |
|
|
const std::map< Idx, StateSet > & |
rEntryStatesMap, |
|
|
const TransSetX2EvX1 & |
rLowRevTransRel, |
|
|
Idx |
highState | |
|
) |
| | |
LowExitStates return-copy function:
Wrapper for the corresponding call-by-reference function. Creates new StateSet, calls function and returns StateSet containing low level exit states.
- Parameters:
-
| rLowGen | Low level generator (just needed for determining statetable) |
| rHighAlph | High level events |
| rEntryStatesMap | Entry states map (see CreateEntryStatesMap(resmap)) |
| rLowRevTransRel | Reverse sorted low level transition relation |
| highState | Hi level state for which to compute low level exit states |
- Exceptions:
-
| Exception | Hi level state not found in entry states map (with FAUDES_CHECKED) (id 502) |
Generate an LR(k) machine for a grammar.
- Parameters:
-
| gr | the grammar |
| k | a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1)) |
- Returns:
- the LR(k) machine
LrmTransitionMap faudes::Lrm1 |
( |
const Grammar & |
gr, |
|
|
uint |
k, |
|
|
const Lr1ConfigurationSetSet & |
configSetSet | |
|
) |
| | |
Generate outgoing transitions for an LR(k) machine for a given configuration set.
- Parameters:
-
| gr | the grammar on which to work |
| k | a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1)) |
| configs | the configuration set from which to generate the transitions |
- Returns:
- outgoing transitions from the given configuration set as a map mapping the original configuration set and a grammar symbol to another configuration set
std::pair< LrmTransitionMap, Lr1ConfigurationSetSet > faudes::LrmLoop |
( |
const Grammar & |
gr, |
|
|
uint |
k, |
|
|
const LrmTransitionMap & |
transitions, |
|
|
const Lr1ConfigurationSetSet & |
states, |
|
|
Lr1ConfigurationSetSet |
examineStates | |
|
) |
| | |
Recursively generate all transitions and states for an LR(k) machine.
- Parameters:
-
| gr | the grammar on which to work |
| k | a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1)) |
| transitions | the transitions that are already found |
| states | the states that are already found |
| examineStates | the states that need to be examined for outgoing transitions |
- Returns:
- a pair with the transition map and all states
Lr1Parser faudes::Lrp |
( |
const Grammar & |
gr, |
|
|
const Grammar & |
augGr, |
|
|
const GotoGenerator & |
gotoGen, |
|
|
uint |
k, |
|
|
const Terminal & |
augSymbol | |
|
) |
| | |
construct an LR(k) parser from a grammar and its LR(k) machine
- Parameters:
-
| gr | the grammar on which to work |
| augGr | augmented version of the grammar on which to work |
| gotoGen | LR(k) machine of the grammar |
| k | a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1)) |
| augSymbol | the terminal with which the grammar was augmented to create the augmented grammar |
- Returns:
- set of parsing rules
std::set< Lr1ParserAction > faudes::LrpReduceRules |
( |
const Grammar & |
gr, |
|
|
const Grammar & |
augGr, |
|
|
const GotoGenerator & |
gotoGen, |
|
|
uint |
k | |
|
) |
| | |
construct the parsing rules for reducing from a grammar and its LR(k) machine
- Parameters:
-
| gr | the grammar on which to work |
| augGr | augmented version of the grammar on which to work |
| gotoGen | LR(k) machine of the grammar |
| k | a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1)) |
- Returns:
- set of reduce actions
std::set< Lr1ParserAction > faudes::LrpRules |
( |
const Grammar & |
gr, |
|
|
const Grammar & |
augGr, |
|
|
const GotoGenerator & |
gotoGen, |
|
|
uint |
k | |
|
) |
| | |
construct all parsing rules from a grammar and its LR(k) machine
- Parameters:
-
| gr | the grammar on which to work |
| augGr | augmented version of the grammar on which to work |
| gotoGen | LR(k) machine of the grammar |
| k | a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1)) |
- Returns:
- set of parsing rules
std::set< Lr1ParserAction > faudes::LrpShiftRules |
( |
const Grammar & |
gr, |
|
|
const Grammar & |
augGr, |
|
|
const GotoGenerator & |
gotoGen, |
|
|
uint |
k | |
|
) |
| | |
construct the parsing rules for shifting from a grammar and its LR(k) machine
- Parameters:
-
| gr | the grammar on which to work |
| augGr | augmented version of the grammar on which to work |
| gotoGen | LR(k) machine of the grammar |
| k | a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1)) |
- Returns:
- set of shift actions
static std::list< std::string > faudes::luafaudes_rl_complete |
( |
lua_State * |
L, |
|
|
const std::string & |
word | |
|
) |
| | [static] |
static void faudes::luafaudes_rl_dmadd |
( |
std::list< std::string > & |
mlist, |
|
|
const std::string & |
prefix, |
|
|
const std::string & |
str, |
|
|
const std::string & |
suffix | |
|
) |
| | [static] |
static int faudes::luafaudes_rl_getfield |
( |
lua_State * |
L, |
|
|
const char * |
s, |
|
|
size_t |
n | |
|
) |
| | [static] |
static int faudes::luafaudes_rl_getmeta |
( |
lua_State * |
L, |
|
|
bool |
has_colon | |
|
) |
| | [static] |
static void faudes::luafaudes_rl_getmetafn |
( |
lua_State * |
L |
) |
[static] |
static void faudes::luafaudes_rl_getmetaget |
( |
lua_State * |
L |
) |
[static] |
static int faudes::luafaudes_rl_getmetaindex |
( |
lua_State * |
L |
) |
[static] |
static bool faudes::luafaudes_rl_valididentifier |
( |
const std::string & |
str |
) |
[static] |
std::string faudes::MangleString |
( |
const std::string & |
str |
) |
|
bool faudes::MeetsDiagnosabilityAssumptions |
( |
const System & |
rGen, |
|
|
const AttributeFailureTypeMap & |
rFailureTypeMap, |
|
|
string & |
rReportString | |
|
) |
| | |
bool faudes::ModularDiagnoser |
( |
const SystemVector & |
rGsubs, |
|
|
const GeneratorVector & |
rKsubs, |
|
|
GeneratorVector & |
rDiagsubs | |
|
) |
| | |
Function definition for run-time interface.
bool faudes::ModularDiagnoser |
( |
const SystemVector & |
rGsubs, |
|
|
const GeneratorVector & |
rKsubs, |
|
|
GeneratorVector & |
rDiagSubs, |
|
|
string & |
rReportString | |
|
) |
| | |
void faudes::mtcDeterministic |
( |
const MtcSystem & |
rGen, |
|
|
std::vector< StateSet > & |
rPowerStates, |
|
|
std::vector< Idx > & |
rDetStates, |
|
|
MtcSystem & |
rResGen | |
|
) |
| | |
Make generator deterministic.
(real function)
Second and third parameter hold the subsets + deterministic states in vectors
The multiway merge algorithm is based on a propsal in "Ted Leslie, Efficient Approaches to Subset Construction,
Computer Science, University of Waterloo, 1995"
- Parameters:
-
| rGen | Reference to generator |
| rPowerStates | Vector that holds the power states |
| rDetStates | Vector that holds the corresponding deterministic states |
| rResGen | Reference to resulting deterministic generator |
void faudes::mtcDeterministic |
( |
const MtcSystem & |
rGen, |
|
|
std::map< Idx, StateSet > & |
rEntryStatesMap, |
|
|
MtcSystem & |
rResGen | |
|
) |
| | |
Make generator deterministic.
(function wrapper)
The second parameter is an empty std::map<Idx,StateSet> which holds all the pairs of new states and their respective power states set. This is used as a so called "entry state map" for deterministic projected generators.
- Parameters:
-
| rGen | Reference to generator |
| rEntryStatesMap | Entry state map |
| rResGen | Reference to resulting deterministic generator |
void faudes::mtcInvProject |
( |
const MtcSystem & |
rGen, |
|
|
const EventSet & |
rProjectAlphabet, |
|
|
MtcSystem & |
rResGen | |
|
) |
| | |
void faudes::mtcParallel |
( |
const MtcSystem & |
rGen1, |
|
|
const MtcSystem & |
rGen2, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
MtcSystem & |
rResGen | |
|
) |
| | |
Parallel composition of two MtcSystems.
- Parameters:
-
| rGen1 | First MtcSystem for parallel composition |
| rGen2 | Second MtcSystem for parallel composition |
| rReverseCompositionMap | |
| rResGen | Generator in which the result of the parallel composition is saved |
void faudes::mtcProject |
( |
const MtcSystem & |
rGen, |
|
|
const EventSet & |
rProjectAlphabet, |
|
|
std::map< Idx, StateSet > & |
rEntryStatesMap, |
|
|
MtcSystem & |
rResGen | |
|
) |
| | |
Minimized Deterministic projection.
Does not modify generator. Calls project, determine and statemin. See functions for details.
- Parameters:
-
| rGen | Reference to generator |
| rProjectAlphabet | Projection alphabet |
| rEntryStatesMap | Reference to entry states map, see Deterministic(..) (result) |
| rResGen | Reference to resulting deterministic generator (result) |
void faudes::mtcStateMin |
( |
const MtcSystem & |
rGen, |
|
|
MtcSystem & |
rResGen | |
|
) |
| | |
void faudes::mtcStateMin |
( |
MtcSystem & |
rGen, |
|
|
MtcSystem & |
rResGen, |
|
|
std::vector< StateSet > & |
rSubsets, |
|
|
std::vector< Idx > & |
rNewIndices | |
|
) |
| | |
State Minimization This function implements the (n*log n) set partitioning algorithm by John E.
Hopcroft extended to colored marking. Given generator will be made accessible before computing minimized generator.
- Parameters:
-
| rGen | MtcSystem |
| rResGen | Minimized MtcSystem (result) |
| rSubsets | Vector of subsets that will be constructed during running the algorithm (optional parameter) |
| rNewIndices | Vector of new state indices corresponding to the subsets (optional parameter) |
- Exceptions:
-
| Exception |
- Input automaton nondeterministic (id 505)
|
void faudes::mtcStateMin |
( |
MtcSystem & |
rGen, |
|
|
MtcSystem & |
rResGen | |
|
) |
| | |
State Minimization This function implements the (n*log n) set partitioning algorithm by John E.
Hopcroft extended to colored marking. Given generator will be made accessible before computing minimized generator.
- Parameters:
-
| rGen | MtcSystem |
| rResGen | Minimized MtcSystem (result) |
- Exceptions:
-
| Exception |
- Input automaton nondeterministic (id 505)
|
void faudes::mtcSupConClosed |
( |
const MtcSystem & |
rPlantGen, |
|
|
const MtcSystem & |
rSpecGen, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
MtcSystem & |
rResGen | |
|
) |
| | |
Supremal Controllable Sublanguage.
Only for deterministic plant + spec. Throws exception if plant or spec is nondeterministic.
Real mtcSupCon function
Finds the "largest" sublanguage of h for that language of g is controllable with respect to h. Differing from theory the marked language of h may not be a sublanguage of g but both must share the same alphabet.
See "C.G CASSANDRAS AND S. LAFORTUNE. Introduction to Discrete Event
Systems. Kluwer, 1999." for base algorithm.
This version creates a "reverse composition map" given as reference parameter.
- Parameters:
-
| rPlantGen | Plant MtcSystem |
| rSpecGen | Specification MtcSystem |
| rReverseCompositionMap | std::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function |
| rResGen | Reference to resulting MtcSystem, the minimal restrictive supervisor |
- Exceptions:
-
| Exception |
- Alphabets of generators don't match (id 500)
- plant nondeterministic (id 501)
- spec nondeterministic (id 503)
- plant and spec nondeterministic (id 504)
|
void faudes::mtcSupConNB |
( |
const MtcSystem & |
rPlantGen, |
|
|
const MtcSystem & |
rSpecGen, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
MtcSystem & |
rResGen | |
|
) |
| | |
Nonblocking Supremal Controllable Sublanguage.
Only for deterministic plant + spec. Throws exception if plant or spec is nondeterministic.
Real mtcSupConNB function
Finds the "largest" sublanguage of h for that language of g is controllable with respect to h. Differing from theory the marked language of h may not be a sublanguage of g but both must share the same alphabet.
See "C.G CASSANDRAS AND S. LAFORTUNE. Introduction to Discrete Event
Systems. Kluwer, 1999." for base algorithm.
This version creates a "reverse composition map" given as reference parameter.
- Parameters:
-
| rPlantGen | Plant MtcSystem |
| rSpecGen | Specification MtcSystem |
| rReverseCompositionMap | std::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function |
| rResGen | Reference to resulting MtcSystem, the minimal restrictive nonblocking supervisor |
- Exceptions:
-
| Exception |
- Alphabets of generators don't match (id 500)
- plant nondeterministic (id 501)
- spec nondeterministic (id 503)
- plant and spec nondeterministic (id 504)
|
void faudes::mtcSupConParallel |
( |
const MtcSystem & |
rPlantGen, |
|
|
const MtcSystem & |
rSpecGen, |
|
|
const EventSet & |
rUAlph, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
MtcSystem & |
rResGen | |
|
) |
| | |
Fast parallel composition for computation for the mtcSupConNB.
Composition stops at transition paths that leave the specification by uncontrollable events in plant.
- Parameters:
-
| rPlantGen | Plant MtcSystem |
| rSpecGen | Specification MtcSystem |
| rUAlph | Uncontrollable Events |
| rReverseCompositionMap | std::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function |
| rResGen | Reference to resulting MtcSystem, the less restrictive supervisor |
void faudes::mtcSupConUnchecked |
( |
const MtcSystem & |
rPlantGen, |
|
|
const EventSet & |
rCAlph, |
|
|
MtcSystem & |
rSupGen | |
|
) |
| | |
Supremal Controllable Sublangauge (Real SupCon function; unchecked).
Both, plant and spec MUST be deterministic and share the same alphabet!!!
Most likely will result in blocking states.
- Parameters:
-
| rPlantGen | Plant generator |
| rCAlph | Controllable events |
| rSupGen | Specification generator |
- Exceptions:
-
| Exception |
- Alphabets of generators don't match (id 500)
- Plant generator nondeterministic (id 501)
- Specification generator nondeterministic (id 503)
- Plant & Spec generator nondeterministic (id 504)
|
void faudes::mtcUniqueInit |
( |
MtcSystem & |
rGen |
) |
|
Input must have passed Rpp! remodells the generator to prevent double (or multiple) acceptance of the same input string.
- Parameters:
-
- Returns:
- remodelled generator without double acceptance
void * faudes::NDeviceListen |
( |
void * |
arg |
) |
|
void faudes::NormalityConsistencyCheck |
( |
const Generator & |
rL, |
|
|
const EventSet & |
rOAlph, |
|
|
const Generator & |
rK | |
|
) |
| | |
NormalityConsistencyCheck: Consistency check for normality input data.
Used e.g. in IsNormal(), and SupNorm(). See exceptions.
- Parameters:
-
| rL | generator of language L |
| rOAlph | observable alphabet |
| rK | generator of language K |
- Exceptions:
-
| Exception |
- nondeterministic parameter(s) (id: 101)
- rOAlph not subset of rL.Alphabet() (id: 100)
- Alphabets of generators don't match (id: 100)
- K is not subset of L (id 0)
|
bool faudes::OmegaControlledLiveness |
( |
Generator & |
rSupCandGen, |
|
|
const EventSet & |
rCAlph, |
|
|
const StateSet & |
rPlantMarking, |
|
|
std::map< Idx, Idx > & |
rControllerStatesMap, |
|
|
std::map< Idx, EventSet > & |
rFeedbackMap | |
|
) |
| | |
bool faudes::OmegaControlledLiveness |
( |
Generator & |
rSupCandGen, |
|
|
const EventSet & |
rCAlph, |
|
|
const StateSet & |
rPlantMarking, |
|
|
std::map< Idx, EventSet > & |
rFeedbackMap | |
|
) |
| | |
bool faudes::OmegaControlledLiveness |
( |
Generator & |
rSupCandGen, |
|
|
const EventSet & |
rCAlph, |
|
|
const StateSet & |
rPlantMarking | |
|
) |
| | |
void faudes::OmegaSupConNBUnchecked |
( |
const Generator & |
rPlantGen, |
|
|
const EventSet & |
rCAlph, |
|
|
const Generator & |
rSpecGen, |
|
|
StateSet & |
rPlantMarking, |
|
|
Generator & |
rResGen | |
|
) |
| | |
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 | |
|
) |
| | |
void faudes::OmegaSupConProduct |
( |
const Generator & |
rPlantGen, |
|
|
const EventSet & |
rCAlph, |
|
|
const Generator & |
rSpecGen, |
|
|
std::map< OPSState, Idx > & |
rProductCompositionMap, |
|
|
Generator & |
rResGen | |
|
) |
| | |
void faudes::Parallel |
( |
const Generator & |
rGen1, |
|
|
const Generator & |
rGen2, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rCompositionMap, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Parallel composition.
See Parallel(const Generator&, const Generator&, Generator&). This version fills a composition map to map pairs of old states to new states.
- Parameters:
-
| rGen1 | First generator |
| rGen2 | Second generator |
| rCompositionMap | Composition map (map< pair<Idx,Idx>, Idx>) |
| rResGen | Reference to resulting parallel composition generator |
void faudes::Parallel |
( |
const Generator & |
rGen1, |
|
|
const Generator & |
rGen2, |
|
|
ProductCompositionMap & |
rCompositionMap, |
|
|
StateSet & |
rMark1, |
|
|
StateSet & |
rMark2, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Parallel composition.
See Parallel(const Generator&, const Generator&, Generator&). This version fills a composition map to map pairs of old states to new states. It also returns the sets of states marked w.r.t. the argument generators.
- Parameters:
-
| rGen1 | First generator |
| rGen2 | Second generator |
| rCompositionMap | Composition map (map< pair<Idx,Idx>, Idx>) |
| rMark2 | States maked in first generator |
| rMark1 | States maked in second generator |
| rResGen | Reference to resulting parallel composition generator |
std::set< Lr1Configuration > faudes::PassesX |
( |
const Lr1Configuration & |
config, |
|
|
const GrammarSymbolPtr & |
symbol | |
|
) |
| | |
Try to shift the dot in a configuration over a specified symbol.
- Parameters:
-
| config | the configuration |
| symbol | the symbol over which to shift |
- Returns:
- set of size one that contains the new configuration or an empty set if the specified symbol was not found directly after the dot
const std::string& faudes::PathSeparator |
( |
void |
|
) |
|
Std dir-separator.
- Returns:
- Separator as one-char string
std::string faudes::PluginsString |
( |
|
) |
|
Return FAUDES_PLUGINS as std::string.
- Returns:
- std::string with FAUDES_VERSION
Construct the postfix closure of a word.
- Parameters:
-
- Returns:
- all postfixes of the word including lambda
std::string faudes::PrependDirectory |
( |
const std::string & |
rDirectory, |
|
|
const std::string & |
rFileName | |
|
) |
| | |
Construct full path from directory and filename.
- Parameters:
-
| rDirectory | Directory eg "/home/friend/data" |
| rFileName | File eg "generator.gen" |
- Returns:
- Path eg "/home/friend/data/generator.gen"
void faudes::PrintTransitions |
( |
const std::multimap< Transition, std::pair< std::vector< StackSymbol >, std::vector< StackSymbol > > > & |
transitions |
) |
|
For debugging, prints a transitions with their pop and push attributes.
- Parameters:
-
| transitions | multimap containing the transitions |
void faudes::ProcessDot |
( |
const std::string & |
rDotFile, |
|
|
const std::string & |
rOutFile, |
|
|
const std::string & |
rOutFormat = "" , |
|
|
const std::string & |
rDotExec = "dot" | |
|
) |
| | |
Convenience function: process dot file to graphics output.
If no output format is given, try to guess from filename extension.
- Parameters:
-
| rDotFile | name of dot file |
| rOutFile | name of graphics file |
| rOutFormat | graphics format eg "png", "jpg" |
| rDotExec | path/name of executable |
- Exceptions:
-
| Exception |
- error in systemcall (id 3)
- unkown format (id 3)
|
void faudes::Product |
( |
const Generator & |
rGen1, |
|
|
const Generator & |
rGen2, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rCompositionMap, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Product composition.
See Product(const Generator&, const Generator&, Generator&). This version fills given composition map to map pairs of old states to new states.
- Parameters:
-
| rGen1 | First generator |
| rGen2 | Second generator |
| rCompositionMap | Composition map (map< pair<Idx,Idx>, Idx>) |
| rResGen | Reference to resulting product composition generator |
void faudes::Product |
( |
const Generator & |
rGen1, |
|
|
const Generator & |
rGen2, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rCompositionMap, |
|
|
StateSet & |
rMark1, |
|
|
StateSet & |
rMark2, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Product composition.
See Product(const Generator&, const Generator&, Generator&). This version fills given composition map to map pairs of old states to new states. It also returns the sets of states marked w.r.t. the argument generators.
- Parameters:
-
| rGen1 | First generator |
| rGen2 | Second generator |
| rCompositionMap | Composition map (map< pair<Idx,Idx>, Idx>) |
| rMark2 | States maked in first generator |
| rMark1 | States maked in second generator |
| rResGen | Reference to resulting product composition generator |
void faudes::Project |
( |
const Generator & |
rGen, |
|
|
const EventSet & |
rProjectAlphabet, |
|
|
std::map< Idx, StateSet > & |
rEntryStatesMap, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Deterministic projection.
Projects the generated and marked languages to a subalphabet of the original alphabet, and subsequently calls Deterministic to construct a deterministic minimal realisation of the result. The input generator does not need to be deterministic.
- Parameters:
-
| rGen | Reference to generator |
| rProjectAlphabet | Projection alphabet |
| rEntryStatesMap | Reference to entry states map, see Deterministic(..) (result) |
| rResGen | Reference to resulting deterministic generator (result) |
void faudes::ProjectNonDet_barthel |
( |
Generator & |
rGen, |
|
|
const EventSet & |
rProjectAlphabet | |
|
) |
| | |
void faudes::ProjectNonDet_fbr |
( |
Generator & |
rGen, |
|
|
const EventSet & |
rProjectAlphabet | |
|
) |
| | |
void faudes::ProjectNonDet_graph |
( |
Generator & |
rGen, |
|
|
const EventSet & |
rProjectAlphabet | |
|
) |
| | |
void faudes::ProjectNonDet_opitz |
( |
Generator & |
rGen, |
|
|
const EventSet & |
rProjectAlphabet | |
|
) |
| | |
void faudes::ProjectNonDet_ref |
( |
Generator & |
rGen, |
|
|
const EventSet & |
rProjectAlphabet | |
|
) |
| | |
void faudes::ProjectNonDet_scc |
( |
Generator & |
rGen, |
|
|
const EventSet & |
rProjectAlphabet | |
|
) |
| | |
void faudes::ProjectNonDet_simple |
( |
Generator & |
rGen, |
|
|
const EventSet & |
rProjectAlphabet | |
|
) |
| | |
void faudes::PushdownAccessible |
( |
const PushdownGenerator & |
pd, |
|
|
PushdownGenerator & |
res | |
|
) |
| | |
Construct the accessible part of a pushdown generator.
- Parameters:
-
| pd | pushdown generator to make accessible |
| res | accessible pushdown generator |
void faudes::PushdownConstructController |
( |
const PushdownGenerator & |
spec, |
|
|
const System & |
plant, |
|
|
PushdownGenerator & |
res | |
|
) |
| | |
Construct a minimal restrictive sound controller.
Alphabets of specification and plant are expected to be equal.
- Parameters:
-
| spec | the specification |
| plant | the plant |
| res | the result |
- Returns:
void faudes::PushdownNonblock |
( |
const PushdownGenerator & |
pd, |
|
|
PushdownGenerator & |
res, |
|
|
bool |
print = false | |
|
) |
| | |
Make a pushdown generator nonblocking.
This will remodel the pushdown generator and replace stack symbols with new ones.
- Parameters:
-
| pd | pushdown generator to make nonblocking |
| res | nonblocking pushdown generator |
| print | temporary debug parameter |
void faudes::ReachableEvents |
( |
const Generator & |
rLowGen, |
|
|
const EventSet & |
rHighAlph, |
|
|
Idx |
lowState, |
|
|
EventSet & |
rReachableEvents | |
|
) |
| | |
ReachableEvents call-by-reference function:
Compute the set of hi level events which can be reached from a low level state. Resulting set will be cleared first.
- Parameters:
-
| rLowGen | Low level generator |
| rHighAlph | High level alphabet |
| lowState | Low level state |
| rReachableEvents | Reference to EventSet which will contain the reachable high level events (result) |
EventSet faudes::ReachableEvents |
( |
const Generator & |
rLowGen, |
|
|
const EventSet & |
rHighAlph, |
|
|
Idx |
lowState | |
|
) |
| | |
ReachableEvents return-copy function:
Wrapper for the corresponding call-by-reference function. Creates new EventSet, calls function and returns EventSet containing the reachable hi level events.
- Parameters:
-
| rLowGen | Low level generator |
| rHighAlph | High level alphabet |
| lowState | Low level state |
std::set< std::string > faudes::ReadDirectory |
( |
const std::string & |
rDirectory |
) |
|
Read the contents of the specified directors.
- Parameters:
-
| rDirectory | Directory eg "/home/friend/data" |
- Returns:
- List of files, e.g. "gen1.gen gen2.gen data subdir"
bool faudes::rec_ComputeLoopPreservingObserver |
( |
const System & |
rGen, |
|
|
const EventSet & |
rInitialHighAlph, |
|
|
EventSet & |
rHighAlph, |
|
|
const std::vector< Idx > & |
rDiffVector, |
|
|
Idx |
numberEvents, |
|
|
Idx |
currentNumberEvents, |
|
|
Idx |
currentLocation, |
|
|
EventSet |
chosenEvents | |
|
) |
| | |
rec_ComputeLoopPreservingObserver(rGen, rInitialHighAlph, rHighAlph, rDdffVector, numberEvents, currentNumberEvents, currentLocation, hosenEvents)
void faudes::rec_OptimalColorSet |
( |
const MtcSystem & |
rGen, |
|
|
const std::vector< Idx > & |
rColorVector, |
|
|
Idx |
colorNumber, |
|
|
ColorSet & |
rOptimalColors, |
|
|
Idx & |
rOptimalNumberStates, |
|
|
Idx & |
rOptimalNumberColors, |
|
|
const EventSet & |
rHighAlph, |
|
|
EventSet & |
rOptimalHighAlph | |
|
) |
| | |
Recursively find an optimal set of colors to be removed.
This function recursively enumerates all possible subsets of colors that can be removed without affecting supervisor synthesis and remembers the color set that leads to the smallest hierarchical abstraction. It is called by the function OptimalColorSet.
- Parameters:
-
| rGen | input colored marking generator |
| rColorVector | set of colors of the generator (ordered!) |
| colorNumber | number of colors currently removed |
| rOptimalColors | current optimal set of colors |
| rOptimalNumberStates | current optimal number of states |
| rOptimalNumberColors | size of the optimal color set |
| rHighAlph | initial high-level alphabet |
| rOptimalHighAlph | optimal high-level alphabet |
void faudes::recursiveCheckLCC |
( |
const TransSetX2EvX1 & |
rRevTransSet, |
|
|
const EventSet & |
rControllableEvents, |
|
|
const EventSet & |
rHighAlph, |
|
|
Idx |
currentState, |
|
|
StateSet & |
rDoneStates | |
|
) |
| | |
Find states that fulfill the lcc condition.
This function performs a backward reachability computation to determine states where the lcc condition is fulfilled
The alphabet rHighAlph has to be a subset of the alphabet of rGen. rGen must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rRevTransSet | Reversely ordered transition relation |
| rControllableEvents | Set of controllable events |
| rHighAlph | Abstraction alphabet |
| currentState | Index of the start state of the backward reachability computation |
| rDoneStates | Set of already investigated states |
- Returns:
- True if the condition is fulfilled, false otherwise
bool faudes::recursiveCheckMSABackward |
( |
const Generator & |
rGen, |
|
|
const TransSetX2EvX1 & |
rRevTransSet, |
|
|
const EventSet & |
rHighAlph, |
|
|
Idx |
currentState, |
|
|
StateSet & |
rDoneStates | |
|
) |
| | |
Check if the msa-observer conditions is fulfilled for a given state.
This function performs a backward reachability computation to determine if the msa-observer condition is fulfilled for a given state.
The alphabet rHighAlph has to be a subset of the alphabet of rGen. rGen must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGen | Generator for which the dynamic system is computed |
| rRevTransSet | Reversely ordered transition relation |
| rHighAlph | Abstraction alphabet |
| currentState | Index of the state to be checked |
| rDoneStates | Set of already investigated states |
- Returns:
- True if the condition is fulfilled, false otherwise
bool faudes::recursiveCheckMSAForward |
( |
const Generator & |
rGen, |
|
|
const EventSet & |
rHighAlph, |
|
|
Idx |
currentState, |
|
|
StateSet & |
rDoneStates | |
|
) |
| | |
Check if the msa-observer conditions is fulfilled for a given state.
This function performs a forward reachability computation to determine if the msa-observer condition is fulfilled for a given state.
The alphabet rHighAlph has to be a subset of the alphabet of rGen. rGen must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGen | Generator for which the dynamic system is computed |
| rHighAlph | Abstraction alphabet |
| currentState | Index of the state to be checked |
| rDoneStates | Set of already investigated states |
- Returns:
- True if the condition is fulfilled, false otherwise
bool faudes::relabel |
( |
Generator & |
rGenRelabel, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
std::vector< Idx > & |
rNewPartitions, |
|
|
std::map< Idx, Idx > & |
rMapStateToPartition, |
|
|
std::map< Transition, Transition > & |
rMapChangedTransReverse, |
|
|
std::map< Transition, Idx > & |
rMapChangedTrans, |
|
|
std::map< Idx, EventSet > & |
rMapRelabeledEvents | |
|
) |
| | |
Relabeling algorithm for the computation of an Lm-observer.
This function checks the termination criterion of the observer algorithm. If required, transitions of the input generator are relabeled.
The alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenRelabel. There are no further restrictions on parameters.
- Parameters:
-
| rGenRelabel | Generator whose transitions are modified |
| rControllableEvents | Set of controllable events |
| rHighAlph | Abstraction alphabet |
| rNewPartitions | Vector containing the indices of the equivalence classes that partition the state space of rGenRelabel |
| rMapStateToPartition | Maps each state of rGenRelabel to an equivalence class that must also be contained in rNewPartitions |
| rMapChangedTransReverse | Maps the relabeled transitions to the original transitions |
| rMapChangedTrans | Maps the the modified original transitions to its new events |
| rMapRelabeledEvents | Maps the original events to the set of new events they were relabeled with |
bool faudes::relabel |
( |
Generator & |
rGenRelabel, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
vector< Idx > & |
rNewPartitions, |
|
|
map< Idx, Idx > & |
rMapStateToPartition, |
|
|
map< Transition, Transition > & |
rMapChangedTransReverse, |
|
|
map< Transition, Idx > & |
rMapChangedTrans, |
|
|
map< Idx, EventSet > & |
rMapRelabeledEvents | |
|
) |
| | |
bool faudes::RemoveFile |
( |
const std::string & |
rFileName |
) |
|
Delete a file.
- Parameters:
-
| rFileName | Name of file to delete |
Remove certain transitions that can never be used because their pop symbol can never be the stack top.
- Parameters:
-
| pd | the generator from which to remove transitions |
- Returns:
- generator with removed transitions
PushdownGenerator faudes::RenG |
( |
const std::string |
word, |
|
|
const PushdownGenerator & |
pd | |
|
) |
| | |
Adds an annotation to each stack symbol of the generator.
Each stack symbol will be copied and added to to generator with the annotation preceding the original name.
- Parameters:
-
| word | word with which the stack symbols will be annotated |
| pd | pushdown automaton to be annotated |
- Returns:
- copy of the parameter automaton with annotated states
PushdownGenerator faudes::RenQ |
( |
const std::string |
word, |
|
|
const PushdownGenerator & |
pd | |
|
) |
| | |
Associates each state of the generator with an annotation.
Each state's merge attribute will be set to a MergeStateAnnotation. The MergeStateAnnotation will contain the annotation.
- Parameters:
-
| word | word with which the states will be annotated |
| pd | pushdown automaton to be annotated |
- Returns:
- copy of the parameter automaton with annotated states
Removes all edges popping lambda.
- Parameters:
-
- Returns:
- pushdown automaton without lambda popping edges
Removes transitions popping more than one stack symbol.
Inserts new transitions instead that only pop one stack symbol.
- Parameters:
-
| pd | the generator, which must NOT contain lambda pops |
- Returns:
- generator with altered transitions
Remove non-controllable ears from a generator.
The initial state must not be an ear. Times and Split must have been executed on the generator.
- Parameters:
-
| pd | the pushdown generator with ears |
| s | the system that was used in the intersection operation to generate the pushdown generator |
- Returns:
- pushdowngenerator without noncontrollable ears
Grammar faudes::Rnpp |
( |
const Grammar & |
gr |
) |
|
Remove all productions from a grammar that are nonproductive, i.
e. they contain nonterminals that are not eliminable.
std::set< Nonterminal > faudes::Rnpp1 |
( |
const Grammar & |
gr, |
|
|
const std::set< Nonterminal > & |
ntSet | |
|
) |
| | |
Find all nonterminals that are eliminable in one step and assuming that a certain set of nonterminals has already been eliminated.
- Parameters:
-
| gr | the grammar |
| ntSet | the set of already eliminated nonterminals |
- Returns:
- eliminable symbols including the already eliminated ones
std::set< Nonterminal > faudes::Rnppl |
( |
const Grammar & |
gr, |
|
|
const std::set< Nonterminal > & |
ntSet | |
|
) |
| | |
Find all nonterminals that are eliminable in as many steps as needed and assuming that a certain set of nonterminals has already been eliminated.
- Parameters:
-
| gr | the grammar |
| ntSet | the set of already eliminated nonterminals |
- Returns:
- eliminable symbols including the already eliminated ones
Restricts a pushdown generator to a pushdown generator with transitions that are either read (p,a,lambda,lambda,q), pop (p,lambda,x,lambda,q) or push (p,lambda,x,yx,q).
- Parameters:
-
| pd | the generator, which must not have transitions that pop more than one stack symbol |
- Returns:
- generator
Remove useless states of a pushdown generator.
- Parameters:
-
| pd | the generator, which is required to have passed Split() before |
- Returns:
- generator that only has useable states.
bool faudes::Ruls1 |
( |
Idx |
state, |
|
|
const PushdownGenerator & |
pd | |
|
) |
| | |
Grammar faudes::Rup |
( |
const Grammar & |
gr |
) |
|
Remove all unreachable productions and nonterminals from the grammar.
- Parameters:
-
| gr | grammar with productions to be removed |
- Returns:
- grammar with only reachable productions
void * faudes::SDeviceSynchro |
( |
void * |
arg |
) |
|
void faudes::SearchScc |
( |
const Idx |
state, |
|
|
int & |
rCount, |
|
|
const Generator & |
rGen, |
|
|
StateSet & |
rNewStates, |
|
|
std::stack< Idx > & |
rSTACK, |
|
|
StateSet & |
rStackStates, |
|
|
std::map< const Idx, int > & |
rDFN, |
|
|
std::map< const Idx, int > & |
rLOWLINK, |
|
|
std::set< StateSet > & |
rSccSet, |
|
|
StateSet & |
rRoots | |
|
) |
| | |
Search for strongly connected components (SCC)*** This function partitions the stateset of a generator into equivalence classes such that states x1 and x2 are equivalent iff there is a path from x1 to x2 AND a path from x2 to x1.
This function implements the algorithm based on a depth first search presented in: -Aho, Hopcroft, Ullman: The Design and Analysis of Computer Algorithms-
Most of the comments in this function have been literally taken from this book!
- Parameters:
-
| state | State, from which the current recursion is started. |
| rCount | denotes the current depth of the recursion. |
| rGen | Generator under investigation |
| rNewStates | Set of states that up to now were not found by the depth first search |
| rSTACK | stack of state indices |
| rStackStates | set of states whose indices are on STACK. |
| rDFN | map assigning to each state its Depth-First Number |
| rLOWLINK | map assigning to each state its LOWLINK Number |
| rSccSet | result - the set of strongly connected components |
| rRoots,: | result - the set of states that each are root of some SCC. |
void faudes::SearchScc |
( |
const Idx |
vState, |
|
|
int & |
vRcount, |
|
|
const Generator & |
rGen, |
|
|
const SccFilter & |
rFilter, |
|
|
StateSet & |
rTodo, |
|
|
std::stack< Idx > & |
rStack, |
|
|
StateSet & |
rStackStates, |
|
|
std::map< const Idx, int > & |
rDfn, |
|
|
std::map< const Idx, int > & |
rLowLnk, |
|
|
std::list< StateSet > & |
rSccList, |
|
|
StateSet & |
rRoots | |
|
) |
| | |
Search for strongly connected components (SCC).
This function partitions the stateset of a generator into equivalent classes such that states x1 and x2 are equivalent iff there is a path from x1 to x2 AND a path from x2 to x1.
This function implements the algorithm based on a recursive depth first search presented in:
-- Aho, Hopcroft, Ullman: The Design and Analysis of Computer Algorithms --
While the original algorithm works on a directed graph, this implementation adds some features that refer to transition systems and allow to filter SCCs on the run. The filter condition is specified by the SccFilter parameter rFilter.
Note: this version is derived from earlier implementations used in various plug-ins; in due course, this version will replace earlier versions.
Note: Due to the recursive implementation, this function requires a stack size proportional to the largest SCC. We have experienced typical default configurations to be good for a depth of about 80000 (Mac OSX 10.6, Debian 7.4). For SCCs exceeding the default stack size, you may adjust the operating system parameters accordingly. On Unix/Linux/MacOsX this is done by the shell command "ulimit -s hard". A future revision of SearchSCC() may be re-designed to circumvent this inconvenient issue.
Note: for a convenience API see also ComputeScc()
- Parameters:
-
| vState | State, from which the current recursion is started. |
| vRcount | Denotes the current depth of the recursion. |
| rGen | Transition system to investigate |
| rFilter | Filter out specified transitions |
| rTodo | Set of states that up to now were not found by the depth first search. |
| rStack | Stack of states to represent current path. |
| rStackStates | Set of states that are in rStack |
| rDfn | Map assigning to each state idx its Depth-First Number. |
| rLowLnk | Map assigning to each state its LOWLINK Number. |
| rSccList | Set SCCs (accumulative result). |
| rRoots | Set of states that each are root of some SCC (accumulative result). |
void faudes::SetComposedStateNames |
( |
const Generator & |
rGen1, |
|
|
const Generator & |
rGen2, |
|
|
const std::map< std::pair< Idx, Idx >, Idx > & |
rCompositionMap, |
|
|
Generator & |
rGen12 | |
|
) |
| | |
Helper: uses composition map to track state names in a paralell composition.
Purely cosmetic.
- Parameters:
-
| rGen1 | First generator |
| rGen2 | Second generator |
| rCompositionMap | Composition map (map< pair<Idx,Idx>, Idx>) |
| rGen12 | Reference to resulting parallel composition generator |
void faudes::SetDifference |
( |
const vGenerator & |
rGenA, |
|
|
const vGenerator & |
rGenB, |
|
|
EventSet & |
rRes | |
|
) |
| | |
RTI convenience function.
void faudes::SetIntersection |
( |
const vGenerator & |
rGenA, |
|
|
const vGenerator & |
rGenB, |
|
|
EventSet & |
rRes | |
|
) |
| | |
RTI convenience function.
void faudes::SetUnion |
( |
const vGenerator & |
rGenA, |
|
|
const vGenerator & |
rGenB, |
|
|
EventSet & |
rRes | |
|
) |
| | |
RTI convenience function.
Grammar faudes::Sp2Lr |
( |
const PushdownGenerator & |
pd |
) |
|
Transform a simple pushdown generator into an LR(1) grammar.
- Parameters:
-
- Returns:
- the grammar
Grammar faudes::Sp2Lr2 |
( |
const PushdownGenerator & |
pd |
) |
|
Transform a simple pushdown generator into an LR(1) grammar.
Memory-optimized version. May take significantly longer than the non-optimized version.
- Parameters:
-
- Returns:
- the grammar
Splits the states of a pushdown generator into heads and ears.
Each ear is associated with a stack symbol.
Transitions will always be either from ear to head or from head to ear. Transitions from ear to head will always pop the stack symbol associated with the ear. Transitions from head to ear will always read lambda and pop and push the stack symbol associated with the ear.
- Parameters:
-
| pd | pushdown generator to be split |
- Returns:
- the split pushdown generator
void faudes::StateMin |
( |
Generator & |
rGen, |
|
|
Generator & |
rResGen, |
|
|
std::vector< StateSet > & |
rSubsets, |
|
|
std::vector< Idx > & |
rNewIndices | |
|
) |
| | |
State set minimization.
This function implements the (n*log n) set partitioning algorithm by John E. Hopcroft. Given generator will be made accessible before computing minimized generator. See also StateMin(Generator&,Generator&).
- Parameters:
-
| rGen | Generator |
| rResGen | Minimized generator (result) |
| rSubsets | Vector of subsets that will be constructed during running the algorithm (optional parameter) |
| rNewIndices | Vector of new state indices corresponding to the subsets (optional parameter) |
- Exceptions:
-
| Exception | Input automaton nondeterministic (id 101) |
void faudes::StateMin |
( |
Generator & |
rGen, |
|
|
Generator & |
rResGen | |
|
) |
| | |
State set minimization.
Constructs a generator with minimal stateset while preserving the generated und marked languages. This function implements the (n*log n) set partitioning algorithm by John E. Hopcroft. The given generator will be made accessible before computing minimized generator. See also StateMin(Generator&,Generator&,std::vector<StateSet>&,std::vector<Idx>&).
- Parameters:
-
| rGen | Generator |
| rResGen | Minimized generator (result) |
- Exceptions:
-
| Exception | Input automaton nondeterministic (id 101) |
std::string faudes::StringSubstitute |
( |
const std::string & |
rString, |
|
|
const std::string & |
rFrom, |
|
|
const std::string & |
rTo | |
|
) |
| | |
Substitute in string.
- Parameters:
-
| rString | Source string to substitute |
| rFrom | String to match |
| rTo | Replacement to fill in |
- Returns:
- Result string
void faudes::SupConClosed |
( |
const Generator & |
rPlantGen, |
|
|
const EventSet & |
rCAlph, |
|
|
const Generator & |
rSpecGen, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Supremal Controllable and Closed Sublanguage.
Implementation of SupConClosed.
See "C.G CASSANDRAS AND S. LAFORTUNE. Introduction to Discrete Event
Systems. Kluwer, 1999." for base algorithm.
This version sets up a "composition map" provided as a reference parameter. The map is restricted such that its range matches the resulting supervisor.
- Parameters:
-
| rPlantGen | Plant Generator |
| rCAlph | Controllable events |
| rSpecGen | Specification Generator |
| rReverseCompositionMap | std::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function |
| rResGen | Reference to resulting Generator, the minimal restrictive supervisor |
- Exceptions:
-
| Exception |
- alphabets of generators don't match (id 100)
- plant nondeterministic (id 201)
- spec nondeterministic (id 203)
- plant and spec nondeterministic (id 204)
|
void faudes::SupConClosedUnchecked |
( |
const Generator & |
rPlantGen, |
|
|
const EventSet & |
rCAlph, |
|
|
Generator & |
rSupCandGen | |
|
) |
| | |
Supremal Controllable Sublangauge (internal function).
Indentifies and deletes "critical" states in the supervisor candidate, in order to achieve controllability. This version of SupConClosed performs no consistency test of the given parameter. In order to obtain indeed the supremal sublanguage, the state space of the candidate must be rich enough to discriminate plant states. This can be done by e.g. setting up the candidate SupConParallel.
In general, the result is blocking.
- Parameters:
-
| rPlantGen | Plant generator |
| rCAlph | Controllable events |
| rSupCandGen | Supervisor candidate generator |
void faudes::SupConNBUnchecked |
( |
const Generator & |
rPlantGen, |
|
|
const EventSet & |
rCAlph, |
|
|
const Generator & |
rSpecGen, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Nonblocking Supremal Controllable Sublanguage (internal function).
This version of SupConNB performs no consistency test of the given parameter. It set's up a "composition map" as in the parallel composition, however, the map may still contain states that have been removed from the result to obtain controllability.
- Parameters:
-
| rPlantGen | Plant Generator |
| rCAlph | Controllable events |
| rSpecGen | Specification Generator |
| rReverseCompositionMap | std::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function |
| rResGen | Reference to resulting System, the minimal restrictive nonblocking supervisor |
- Exceptions:
-
| Exception |
- alphabets of generators don't match (id 100)
- plant nondeterministic (id 201)
- spec nondeterministic (id 203)
- plant and spec nondeterministic (id 204)
|
void faudes::SupConNormClosed |
( |
const System & |
rPlantGen, |
|
|
const Generator & |
rSpecGen, |
|
|
Generator & |
rResGen | |
|
) |
| | |
void faudes::SupConNormClosedUnchecked |
( |
const Generator & |
rPlantGen, |
|
|
const EventSet & |
rCAlph, |
|
|
const EventSet & |
rOAlph, |
|
|
Generator & |
rObserverGen, |
|
|
Generator & |
rSupCandGen | |
|
) |
| | |
Supremal Normal Controllable Sublangauge (internal function).
Indentifies and deletes conflicting transitions to obtain a controllable and prefix-normal sublanguage. This function is a bit experimental it depends on various unverified preconditions and conjectures -- use only after careful code-review. The completely independent implementation SupNormConClosed should be fine
Conditions
- controllabel events as specified explicitly must be a subset of the observable events
- L(H) <= L(G)
- stateset of H must be sufficiently rich to discriminate states in G (e.g. initialise by H:=H' x G)
- H_obs must be "a" observer automaton for H w.r.t. observable events (e.g. initialize with p_inv p H)
- Parameters:
-
| rPlantGen | Plant generator G |
| rCAlph | Controllable events |
| rOAlph | Observable events |
| rObserverGen | Observer H_obs |
| rSupCandGen | Closed-loop candidate H |
void faudes::SupConNormNB |
( |
const System & |
rPlantGen, |
|
|
const Generator & |
rSpecGen, |
|
|
Generator & |
rResGen | |
|
) |
| | |
void faudes::SupConProduct |
( |
const Generator & |
rPlantGen, |
|
|
const EventSet & |
rCAlph, |
|
|
const Generator & |
rSpecGen, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Parallel composition optimized for the purpose of SupCon (internal function).
Composition stops at transition paths that violate the specification by uncontrollable plant transitions.
This internal function performs no consistency test of the given parameter. It set's up a "composition map" as in the product composition, however, the map may still contain states that have been removed from the result to obtain controllability.
- Parameters:
-
| rPlantGen | Plant Generator |
| rCAlph | Uncontrollable Events |
| rSpecGen | Specification Generator |
| rReverseCompositionMap | std::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function |
| rResGen | Reference to resulting Generator, the less restrictive supervisor |
void faudes::SupNorm |
( |
const System & |
rPlantGen, |
|
|
const Generator & |
rSpecGen, |
|
|
Generator & |
rResGen | |
|
) |
| | |
void faudes::SupNormClosed |
( |
const System & |
rPlantGen, |
|
|
const Generator & |
rSpecGen, |
|
|
Generator & |
rResGen | |
|
) |
| | |
bool faudes::SupNormSP |
( |
Generator & |
rL, |
|
|
const EventSet & |
rOAlph, |
|
|
const Generator & |
rK, |
|
|
Generator & |
rResult | |
|
) |
| | |
bool faudes::SupPrefixClosed |
( |
const Generator & |
rK, |
|
|
Generator & |
rResult | |
|
) |
| | |
SupPrefixClosed: supremal closed sublanguage of K by cancelling all tranistions leading to a non-marked state.
Returns false on empty result. todo: implement test routines, verify correctness
- Parameters:
-
| rK | marks the (not necessarily closed) language K=Lm(rK) |
| rResult | generates and marks the supremal closed sublanguage, where L(rResult)=Lm(rResult) |
- Returns:
- true for nonempty result
- Exceptions:
-
void faudes::SupRelativelyPrefixClosedUnchecked |
( |
const Generator & |
rPlantGen, |
|
|
const Generator & |
rSpecGen, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rCompositionMap, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Supremal Relatively Closed Sublanguage (internal function).
This version of SupRelativelyPrefixClosed performs no consistency test of the given parameter. It set's up a "composition map" as in the parallel composition, however, the map may still contain states that have been removed from the result to obtain controllability.
Parameter restrictions: both generators must be deterministic and have the same alphabet.
- Parameters:
-
| rPlantGen | Plant G |
| rSpecGen | Specification Generator E |
| rResGen | Reference to resulting Generator, |
void faudes::SupTconNBUnchecked |
( |
const Generator & |
rPlantGen, |
|
|
const EventSet & |
rCAlph, |
|
|
const EventSet & |
rFAlph, |
|
|
const EventSet & |
rPAlph, |
|
|
const Generator & |
rSpecGen, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rCompositionMap, |
|
|
Generator & |
rResGen | |
|
) |
| | |
void faudes::SupTconUnchecked |
( |
const Generator & |
rPlantGen, |
|
|
const EventSet & |
rCAlph, |
|
|
const EventSet & |
rFAlph, |
|
|
const EventSet & |
rPAlph, |
|
|
const EventSet & |
rCPAlph, |
|
|
Generator & |
rSupCandGen | |
|
) |
| | |
void* faudes::SwigCastPtr |
( |
void * |
ptr, |
|
|
swig_type_info * |
from, |
|
|
swig_type_info * |
ty | |
|
) |
| | |
int faudes::syncSend |
( |
int |
dest, |
|
|
const char * |
data, |
|
|
int |
len, |
|
|
int |
flag | |
|
) |
| | |
bool faudes::Te |
( |
const PushdownGenerator & |
pd, |
|
|
const Transition & |
trans, |
|
|
const std::vector< Idx > & |
pop, |
|
|
const std::vector< Idx > & |
push | |
|
) |
| | |
Test a transition for reachability.
- Parameters:
-
| pd | the pushdown generator |
| trans | the transition to test for reachability |
| pop | the pop of the transitions to test for reachability |
| push | the push of the transitions to test for reachability |
- Returns:
- true if the transition is reachable, else false
void faudes::TestAcAccessible |
( |
|
) |
|
Test if Ac makes the test generator accessible.
void faudes::TestAlternativeAccessible |
( |
Generator & |
rGen |
) |
|
Alternative accessibility algorithm.
We use the alternative accessibility algorithm from tutorial 6 for our example plugin. The implementation uses a todo stack to discover accessible states and finaly remove all other states from the input generator.
Example:
- Parameters:
-
void faudes::TestAugSuccess |
( |
|
) |
|
Augment a grammar which should result in a successful augmentation.
void faudes::TestDesc |
( |
|
) |
|
All Desc Tests.
Includes Testing Desc1 since Desc1 is just an iterator.
void faudes::TestDesc11 |
( |
|
) |
|
void faudes::TestDesc11Nonterminal |
( |
|
) |
|
Test Desc11 with a nonterminal at the beginning of afterDot.
void faudes::TestDesc11Terminal |
( |
|
) |
|
Test Desc11 with a terminal at the beginning of afterDot.
void faudes::TestDescInitial |
( |
|
) |
|
void faudes::TestDescInitialFindTwo |
( |
|
) |
|
Test Desc Initial if it finds the two correct starting configurations.
void faudes::TestDescSelectedConfigs |
( |
|
) |
|
Test Desc with some configurations.
void faudes::TestDimNewFinalStates |
( |
|
) |
|
Test if final states are set correctly after the removal auf the augment symbol.
void faudes::TestDimNoAugment |
( |
|
) |
|
Test if the augment symbol transitions were successfully removed from the generator and the new number of transitions is correct.
void faudes::TestEnd |
( |
std::string |
name |
) |
|
write to console to indicate end of test
- Parameters:
-
void faudes::TestFdsWords |
( |
|
) |
|
Test if Fds returns all expected words.
void faudes::TestFilter |
( |
|
) |
|
void faudes::TestFilter1 |
( |
|
) |
|
void faudes::TestFilter1MixedGrammarSymbols |
( |
|
) |
|
Filter a nonterminal from a vector of terminals and nonterminals.
void faudes::TestFilter1Nothing |
( |
|
) |
|
filter from an empty word
void faudes::TestFilterMixedGrammarSymbols |
( |
|
) |
|
Filter a nonterminal from a vector of terminals and nonterminals.
void faudes::TestFilterNothing |
( |
|
) |
|
filter from an empty word
void faudes::TestFirst |
( |
|
) |
|
void faudes::TestFirstA |
( |
|
) |
|
void faudes::TestFirstAll |
( |
|
) |
|
void faudes::TestFirstAllNonterminalsIrreducible |
( |
|
) |
|
Test with Nonterminals and an irreducible word as input.
void faudes::TestFirstAllNonterminalsIrreducibleWord |
( |
|
) |
|
void faudes::TestFirstAllNonterminalsReducible |
( |
|
) |
|
Test with Nonterminals and a reducible word as input.
void faudes::TestFirstAllNonterminalsReducibleWord |
( |
|
) |
|
void faudes::TestFirstAllTerminalsOnly |
( |
|
) |
|
Test with only Terminals as input.
void faudes::TestFirstASelectedWords |
( |
|
) |
|
Test for some selected word if the correct set of terminals is returned.
void faudes::TestFirstL |
( |
|
) |
|
All FirstL tests.
Includes testing of First1, because First1 needs to be called recursively in order to be tested correctly. FirstL does nothing else than calling First1 recursively.
void faudes::TestFirstLeq1 |
( |
|
) |
|
void faudes::TestFirstLeq1OneNonempty |
( |
|
) |
|
Test with k = 1 and a word that results in a nonempty first set.
void faudes::TestFirstLeq1TwoNonempty |
( |
|
) |
|
Test with k = 2 and a word that results in a nonempty first set.
void faudes::TestFirstLeq1ZeroEmpty |
( |
|
) |
|
Test with k = 0 and a word that results in an empty first set.
void faudes::TestFirstLeq1ZeroNonempty |
( |
|
) |
|
Test with k = 0 and a word that results in a nonempty first set.
void faudes::TestFirstLMap |
( |
|
) |
|
Test if the mapping function produced by FirstL is correct.
void faudes::TestFirstRed |
( |
|
) |
|
void faudes::TestFirstRedConsistentWord |
( |
|
) |
|
Test FirstRed with a consistent word as input.
void faudes::TestFirstRedInconsistentWord |
( |
|
) |
|
Test FirstRed with an inconsistent word as input.
void faudes::TestFirstSelectedWords |
( |
|
) |
|
Test for some selected word if the correct set of terminals is returned.
build a test generator
- Returns:
- the populated test generator
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
<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>
<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>
<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>
void faudes::TestGeneratorGoto |
( |
|
) |
|
void faudes::TestGeneratorGotoNoSuccessor |
( |
|
) |
|
Test if GeneratorGoto finds no successor when none is to be found.
void faudes::TestGeneratorGotoOneSuccessor |
( |
|
) |
|
Test if GeneratorGoto finds the right successor.
void faudes::TestGeneratorGotoSeq |
( |
|
) |
|
All GeneratorGotoSeq Tests.
void faudes::TestGeneratorGotoSeqFull |
( |
|
) |
|
Test if a word fully matches a sequence of states when a match is possible.
void faudes::TestGeneratorGotoSeqPartial |
( |
|
) |
|
Test if a partial state sequence is generated when no full match for the word is possible.
void faudes::TestGetPossibleStackTops |
( |
|
) |
|
all GetPossibleStackTops tests
void faudes::TestGetPossibleStackTopsFindCorrectOnes |
( |
|
) |
|
Test if GetPossibleStackTops finds the correct stack symbols.
void faudes::TestGp2Pp |
( |
|
) |
|
void faudes::TestGp2PpStates |
( |
|
) |
|
Test if all states are set correctly and whether the correct ones are used in transitions.
void faudes::TestGp2PpTransitions |
( |
|
) |
|
Test if the number of transitions is correct and test if the number of transitions per event is as expected.
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
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
void faudes::TestIntersectEvents |
( |
|
) |
|
all IntersectEvents tests
void faudes::TestIntersectEventsAll |
( |
|
) |
|
test for intersect events
void faudes::TestLrm1 |
( |
|
) |
|
void faudes::TestLrm1FindOne |
( |
|
) |
|
Test if Lrm1 finds the correct following configuration set when only one must be found.
void faudes::TestLrm1FindThree |
( |
|
) |
|
Test if Lrm1 finds three following configuration sets when three must be found.
void faudes::TestLrmGr1 |
( |
|
) |
|
Test if Lrm generates a GotoMachine with the correct number of transitions and states for the "$ a^n b $" grammar.
void faudes::TestLrmGr2 |
( |
|
) |
|
Test if Lrm generates a GotoMachine with the correct number of transitions and states for a specific.
//TODO dont know what to expecet as a result
void faudes::TestLrmLoop |
( |
|
) |
|
void faudes::TestLrmLoopAnB |
( |
|
) |
|
Test if LrmLoop generates the correct number of transitions and states for the "$ a^n b $" grammar.
void faudes::TestLrpActions |
( |
|
) |
|
Test if Lrp generates a parser with the correct rules.
void faudes::TestLrpNonterminalsTerminals |
( |
|
) |
|
Test if Lrp generates a parser with the correct number of nonterminals and terminals for a certain grammar.
void faudes::TestLrpReduceRules |
( |
|
) |
|
All LrpReduceRules Tests.
void faudes::TestLrpReduceRulesNumberAndTerminals |
( |
|
) |
|
Test if the number of reduce rules is correct and test for the correct number of occurences of terminals and each action element's right-hand side.
void faudes::TestLrpShiftRules |
( |
|
) |
|
void faudes::TestLrpShiftRulesNumberAndTerminals |
( |
|
) |
|
Test if the number of shift rules is correct and test for the correct number of occurences of terminals and each action's left-hand side element's right-hand side.
void faudes::TestNdaActivePassive |
( |
|
) |
|
Test if the states are split into active and passive states and if the number of states has been doubled.
void faudes::TestNdaTransitions |
( |
|
) |
|
Test if transition start and end states are set as expected.
void faudes::TestNonblock |
( |
|
) |
|
void faudes::TestPassesX |
( |
|
) |
|
void faudes::TestPassesXNonterminal |
( |
|
) |
|
Test PassesX by shifting the dot over a nonterminal.
void faudes::TestPassesXNoShift |
( |
|
) |
|
Test PassesX by trying to shift the dot over nothing or a nonexistent symbol.
void faudes::TestPassesXTerminal |
( |
|
) |
|
Test PassesX by shifting the dot over a terminal.
void faudes::TestPostCl |
( |
|
) |
|
void faudes::TestPostClPostfixes |
( |
|
) |
|
Test all postfixes of a given word.
bool faudes::TestProtocol |
( |
void |
|
) |
|
Test Protocol.
Perform a comparison of the recent protocol file and the corresponding reference. Returns true if the test passes.
Note: this function closes the current protocol.
- Returns:
- True <=> test past
void faudes::TestProtocol |
( |
const std::string & |
rMessage, |
|
|
const std::string & |
data | |
|
) |
| | |
void faudes::TestProtocol |
( |
const std::string & |
rMessage, |
|
|
long int |
data | |
|
) |
| | |
void faudes::TestProtocol |
( |
const std::string & |
rMessage, |
|
|
bool |
data | |
|
) |
| | |
void faudes::TestProtocol |
( |
const std::string & |
rMessage, |
|
|
const Type & |
rData, |
|
|
bool |
core = false | |
|
) |
| | |
Test Protocol.
This function dumps the specified data to the protocol file for the purpose of later comparison with a refernce value. If the protocol file has not been set up, this function does nothing; see also TestProtocol(const std::string&.
- Parameters:
-
| rMessage | Informal identifyer of the test |
| rData | Formal result of the test case |
| core | Whether to record full token io or statistics only. |
std::string faudes::TestProtocol |
( |
const std::string & |
rSource |
) |
|
Test Protocol.
Sets the filename for the test protocol by
- removing any path specififucation,
- replacing "." by "_",
- appending ".prot", and finaly
- prepending "tmp_". The function returns the filename except for the "tmp_" prefix. The latter is considered the nominal protocol output (aka reference protocol).
Note: only the first invocation of this functions actually sets the protocol file. Further invocations are ignored, but can be used to query the reference protocol.
- Parameters:
-
| rSource | Source file to protocol |
- Returns:
- Filename with nominal protocol.
void faudes::TestRemoveUselessTransitions |
( |
|
) |
|
all RemoveUselessTransitions tests
void faudes::TestRemoveUselessTransitionsNumberOfTransitions |
( |
|
) |
|
Test if RemoveUselessTransitions removes the correct amount of transitions from a test generator.
void faudes::TestRenG |
( |
|
) |
|
void faudes::TestRenGNumberOfStackSymbols |
( |
|
) |
|
Test if the number of stack symbols did not change.
void faudes::TestRenGRenamingStackSymbols |
( |
|
) |
|
Test if all stack symbols were renamed correctly.
void faudes::TestRenGRenamingTransitions |
( |
|
) |
|
Test if the stack symbols in pop and push of transitions were changed correctly.
void faudes::TestRenQ |
( |
|
) |
|
void faudes::TestRenQNumberOfStates |
( |
|
) |
|
Test if the number of states did not change.
void faudes::TestRenQRenaming |
( |
|
) |
|
Test if all states were renamed correctly (merge attribute is set correctly).
void faudes::TestRep0 |
( |
|
) |
|
void faudes::TestRep0AllExpectingTransition |
( |
|
) |
|
Test if resulting generator has a transition able to pop all stack symbols, but only if the orignal generator had at least one lambda transition.
void faudes::TestRep0NoLambdaPop |
( |
|
) |
|
Tests if there are any lambda popping edges left.
void faudes::TestRep2 |
( |
|
) |
|
void faudes::TestRep2NumberOfStatesTransitions |
( |
|
) |
|
Test for the right number of transitions and states in the generator after applying Rep2.
void faudes::TestRep2Renaming |
( |
|
) |
|
Tests if the MergeStateAnnotations have all been set to "old".
void faudes::TestRnce |
( |
|
) |
|
void faudes::TestRnceRemoveEars |
( |
|
) |
|
Test if uncontrollable ears are correctly removed.
void faudes::TestRnpp |
( |
|
) |
|
void faudes::TestRnpp1 |
( |
|
) |
|
void faudes::TestRnpp1FindSymbolsEmptySet |
( |
|
) |
|
Find an eliminable symbol with Rnpp1 and an empty set of nonterminals.
void faudes::TestRnpp1FindSymbolsNonemptySet |
( |
|
) |
|
Find an eliminable symbol with Rnpp1 and a nonempty set of nonterminals.
void faudes::TestRnppEmptyGrammar |
( |
|
) |
|
Try to remove all noneliminable nonterminals and all productions containing noneliminable nonterminals from an empty grammar.
void faudes::TestRnppGrammar1 |
( |
|
) |
|
Remove all noneliminable nonterminals and all productions containing noneliminable nonterminals.
void faudes::TestRnppGrammar2 |
( |
|
) |
|
Remove all noneliminable nonterminals and all productions containing noneliminable nonterminals.
void faudes::TestRnppl |
( |
|
) |
|
void faudes::TestRnpplFindSymbolsCompleteSet |
( |
|
) |
|
Find all eliminable symbols with Rnppl and a set already containing all eliminable symbols.
void faudes::TestRnpplFindSymbolsEmptySet |
( |
|
) |
|
Find all eliminable symbols with Rnppl and an empty set of nonterminals.
void faudes::TestRnpplFindSymbolsNonemptySet |
( |
|
) |
|
Find all eliminable symbolswith Rnppl and a nonempty set of nonterminals.
void faudes::TestRppNumberStatesTransitions |
( |
|
) |
|
Test if the number of transitions and states is correct after calling Rpp.
void faudes::TestRppReadPopPushOnly |
( |
|
) |
|
Test if all transitions are either read only, pop only or push only.
void faudes::TestRuls |
( |
|
) |
|
void faudes::TestRulsRemoveStates |
( |
|
) |
|
Test if Ruls deletes the correct states.
void faudes::TestRupNonterminals |
( |
|
) |
|
void faudes::TestRupProductions |
( |
|
) |
|
void faudes::TestSp2Lr |
( |
|
) |
|
void faudes::TestSp2Lr2 |
( |
|
) |
|
void faudes::TestSp2Lr2Productions |
( |
|
) |
|
Test if all expected productions for read, pop and push transitions and for the final states were generated.
void faudes::TestSp2LrNonterminals |
( |
|
) |
|
Test if all possible nonterminals were generated.
void faudes::TestSp2LrProductions |
( |
|
) |
|
Test if all expected productions for read, pop and push transitions and for the final states were generated.
void faudes::TestSp2LrTerminals |
( |
|
) |
|
Test if all terminals have been set correctly and match the generator's events.
void faudes::TestSplit |
( |
|
) |
|
void faudes::TestSplitStackSymbols |
( |
|
) |
|
Test if the stack bottom remains unchanged and all stack symbols from the old generator are in the split generator.
void faudes::TestSplitStates |
( |
|
) |
|
Test if the states have been split correctly into heads and ears.
void faudes::TestSplitTransitionsEarToHead |
( |
|
) |
|
Test if all transitions originating at ears end at heads and if the pop of the transition is correctly set.
void faudes::TestSplitTransitionsHeadToEar |
( |
|
) |
|
Test if all transitions originating at heads end at ears and if the pop/push of the transition is correctly set.
void faudes::TestStart |
( |
std::string |
name |
) |
|
write to console to indicate start of test
- Parameters:
-
System faudes::TestSystem1 |
( |
|
) |
|
<Generator> Generator
% % Statistics for Generator % % States: 3 % Init/Marked: 1/1 % Events: 3 % Transitions: 5 % StateSymbols: 3 % Attrib. E/S/T: 2/0/0 %
<Alphabet> a +C+ b c +C+ </Alphabet>
<States> s1 s2 s3 </States>
<TransRel> s1 a s2 s1 b s3 s1 c s3 s2 b s1 s3 a s2 </TransRel>
<InitStates> s1 </InitStates>
<MarkedStates> s3 </MarkedStates>
</Generator>
- Returns:
- the populated test system
System faudes::TestSystem2 |
( |
|
) |
|
System faudes::TestSystem3 |
( |
|
) |
|
System faudes::TestSystem4 |
( |
|
) |
|
System faudes::TestSystem5 |
( |
|
) |
|
void faudes::TestTeReachable |
( |
|
) |
|
Test Ts with transitions that are reachable.
void faudes::TestTeUnreachable |
( |
|
) |
|
Test Ts with states that are unreachable.
void faudes::TestTimes |
( |
|
) |
|
void faudes::TestTimesStackSymbols |
( |
|
) |
|
Test if all stack symbols and the stack bottom are set correctly.
void faudes::TestTimesStates |
( |
|
) |
|
test for the the right number of states and for correctly set merge states
void faudes::TestTimesTransitions |
( |
|
) |
|
Test if the number of lambda transitions and the total number of transitions is right.
void faudes::TestTransient |
( |
|
) |
|
void faudes::TestTransientStates |
( |
|
) |
|
Test if Transient chooses the right states.
void faudes::TestTransientStatesEmpty |
( |
|
) |
|
Test if Transient chooses the right states.
void faudes::TestTsUnreachable |
( |
|
) |
|
Test Te with transitions that are unreachable.
synchronous product generator of a pushdown generator and a regular generator
- Parameters:
-
| reg | the regualar generator |
| pd | the pushdown generator |
- Returns:
- the synchronous product
int faudes::timeval_subtract |
( |
timeval * |
result, |
|
|
timeval * |
x, |
|
|
timeval * |
y | |
|
) |
| | |
Idx faudes::ToIdx |
( |
const std::string & |
rString |
) |
|
Convert a string to Idx.
- Parameters:
-
| rString | string to convert |
- Returns:
- Idx
- Exceptions:
-
std::string faudes::ToStringFloat |
( |
double |
number |
) |
|
float to string
- Parameters:
-
- Returns:
- string
std::string faudes::ToStringInteger |
( |
long int |
number |
) |
|
integer to string
- Parameters:
-
- Returns:
- string
std::string faudes::ToStringInteger16 |
( |
long int |
number |
) |
|
integer to string base 16
- Parameters:
-
- Returns:
- string
StateSet faudes::Transient |
( |
const PushdownGenerator & |
pd |
) |
|
Get all states that are the starting state of a lambda reading transition.
- Parameters:
-
- Returns:
- the states
std::string faudes::TransitionMapToStr |
( |
const LrmTransitionMap & |
transitionMap |
) |
|
To string function for a transition map.
- Parameters:
-
| transitionMap | the transition map to turn into a string |
- Returns:
- the transition map as a string
void faudes::TraverseUncontrollableBackwards |
( |
const EventSet & |
rCAlph, |
|
|
TransSetX2EvX1 & |
rtransrel, |
|
|
StateSet & |
rCriticalStates, |
|
|
Idx |
current | |
|
) |
| | |
Helper function for IsControllable.
The state given as "current" is considered critical. Itself and all uncontrollable predecessor states are added to the set "rCriticalStates".
- Parameters:
-
| rCAlph | Set of controllable events |
| rtransrel | Reverse sorted transition relation |
| rCriticalStates | Set of critical states in composition generator |
| current | Current state |
void faudes::TrimNonIndicatorTracesOfGd |
( |
System & |
rGd, |
|
|
const Diagnoser & |
rGobs, |
|
|
const Idx |
rFailureType, |
|
|
const EventSet & |
rIndicatorEvents, |
|
|
const std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap | |
|
) |
| | |
Extract all traces of a generator G_d that start with an indicator event that follows a failure event of a certain failure type.
- Parameters:
-
| rGd | Input generator G_d which will be prunded. |
| rGobs | Generator G_o (containing failure label information). |
| rFailureType | Failure type index. |
| rIndicatorEvents | Set of indicator events. |
| rReverseCompositionMap | Mapping of G_d states with G_o states. |
void faudes::TrimNonIndicatorTracesOfGd |
( |
System & |
rGd, |
|
|
const Diagnoser & |
rGobs, |
|
|
const Idx |
rFailureType, |
|
|
const EventSet & |
rIndicatorEvents, |
|
|
const map< pair< Idx, Idx >, Idx > & |
rReverseCompositionMap | |
|
) |
| | |
void faudes::TrimNonIndicatorTracesOfGdRecursive |
( |
System & |
rGd, |
|
|
const Diagnoser & |
rGobs, |
|
|
const Idx |
rFailureType, |
|
|
const EventSet & |
rIndicatorEvents, |
|
|
std::map< Idx, std::pair< Idx, Idx > > & |
rCompositionMap, |
|
|
Idx |
state, |
|
|
StateSet & |
rStatesDone | |
|
) |
| | |
Auxiliary function for TrimNonIndicatorTracesOfGd().
Parse through active transition set of the current state and delete transitions if occurring event is not an indicator event or there did not occur a failure before the indicator.
- Parameters:
-
| rGd | Input generator G_d which will be pruned. |
| rGobs | Generator G_o (containing failure label information). |
| rFailureType | Failure type index. |
| rIndicatorEvents | Set of indicator events. |
| rCompositionMap | Inverted mapping of G_d states with G_o states. |
| state | Current state. |
| rStatesDone | States that have been processed already. |
void faudes::TrimNonIndicatorTracesOfGdRecursive |
( |
System & |
rGd, |
|
|
const Diagnoser & |
rGobs, |
|
|
const Idx |
rFailureType, |
|
|
const EventSet & |
rIndicatorEvents, |
|
|
map< Idx, pair< Idx, Idx > > & |
rCompositionMap, |
|
|
Idx |
state, |
|
|
StateSet & |
rStatesDone | |
|
) |
| | |
Delete stack symbols from the generator that are not used in any of the transitions.
- Parameters:
-
| pd | pushdown generator to trim |
- Returns:
- trimmed pushdown generator
bool faudes::Ts |
( |
const PushdownGenerator & |
pd, |
|
|
Idx |
state | |
|
) |
| | |
Test a state for reachability.
- Parameters:
-
| pd | the pushdown generator |
| state | the state to test for reachability |
- Returns:
- true if the state is reachable, else false
Determine the descendants of the initial parser configurations.
- Parameters:
-
| gr | the grammar |
| k | a natural number that denotes the kind of parser the function is working on (LR(k) parser) (will currently only work for LR(1)) |
- Returns:
- a set with the descendants of the initial configurations
std::string faudes::VersionString |
( |
|
) |
|
Return FAUDES_VERSION as std::string.
- Returns:
- std::string with FAUDES_VERSION
void faudes::WriteMap |
( |
GrammarSymbolWordMap |
f, |
|
|
bool |
changed = false | |
|
) |
| | |
Convenience print function for first map function.
- Parameters:
-
| f | map function to print |
| changed | indicator if changes were made, defaults to false |
bool faudes::YclessScc |
( |
const Generator & |
rGen, |
|
|
const EventSet & |
rYc, |
|
|
std::set< StateSet > & |
rSccSet | |
|
) |
| | |
Variable Documentation
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.
libFAUDES 2.23h
--- 2014.04.03
--- c++ api documentaion by doxygen
|