About
User Reference
C++ API
luafaudes
Developer
Links
libFAUDES online
libFAUDES

Sections

Index

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...
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  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  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...
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...

Typedefs

typedef unsigned long int fType
 Convenience typdef flag data.
typedef TaNameSet
< AttributeCFlags
Alphabet
 Convenience typedef for event sets with controllability attributes.
typedef TBaseVector< AlphabetAlphaberVector
 Convenience typedef.
typedef TcGenerator
< AttributeVoid, AttributeVoid,
AttributeCFlags, AttributeVoid
System
 Convenience typedef for std System.
typedef TBaseVector< SystemSystemVector
 Convenience typedef for vectors of systems.
typedef long unsigned int Idx
 Type definition for index type.
typedef long int SignedIdx
 Type definition for signed index type.
typedef TBaseVector< IntegerIntegerVector
typedef vGenerator Generator
 Plain generator, api typedef for generator with no attributes.
typedef TBaseVector< GeneratorGeneratorVector
 Convenience typedef for vectors og generators.
typedef IndexSet StateSet
typedef TBaseVector< IndexSetIndexSetVector
 Convenience typedef for vectors og generators.
typedef NameSet EventSet
 Convenience typedef for plain event sets.
typedef TBaseVector< EventSetEventSetVector
typedef 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 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.

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)
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 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 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.
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.
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 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 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.
void ProjectNonDet (Generator &rGen, const EventSet &rProjectAlphabet)
 Language projection.
void aProjectNonDet (Generator &rGen, const EventSet &rProjectAlphabet)
 Language projection.
void Project (const Generator &rGen, const EventSet &rProjectAlphabet, Generator &rResGen)
 Minimized deterministic projection.
void aProject (const Generator &rGen, const EventSet &rProjectAlphabet, Generator &rResGen)
 Minimized deterministic projection.
void Project (const Generator &rGen, const EventSet &rProjectAlphabet, std::map< Idx, StateSet > &rEntryStatesMap, Generator &rResGen)
 Minimized Deterministic projection.
void InvProject (Generator &rGen, const EventSet &rProjectAlphabet)
 Inverse projection.
void aInvProject (Generator &rGen, const EventSet &rProjectAlphabet)
 Inverse projection.
void aInvProject (const Generator &rGen, const EventSet &rProjectAlphabet, Generator &rResGen)
 Inverse projection.
void CreateEntryStatesMap (const std::map< StateSet, Idx > &rRevEntryStatesMap, std::map< Idx, StateSet > &rEntryStatesMap)
void LoadRegistry (const std::string &rPath="")
 Load all registered types and functions.
void SaveRegistry (const std::string &rPath="")
 Dump all registered types and functions.
void ClearRegistry (void)
 Clear all registry.
TypeNewFaudesObject (const std::string &rTypeName)
 Instantiate faudes typed objects by type name.
FunctionNewFaudesFunction (const std::string &rFunctName)
 Instantiate faudes function objects by function name.
const std::string & FaudesTypeName (const Type &rObject)
 Query type name.
bool FaudesTypeTest (const std::string &rTypeName, const Type &rObject)
 Test type compatibility.
const std::string & FaudesFunctionName (const Function &rObject)
const std::string & FaudesFunctionName (const Type &rObject)
 Query function name.
void LanguageUnionNonDet (const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
 Language union, nondeterministic version.
void LanguageUnion (const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
 Language union, deterministic version.
void LanguageUnion (const GeneratorVector &rGenVec, Generator &rResGen)
 Language union.
void LanguageIntersection (const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
 Language intersection.
void LanguageIntersection (const GeneratorVector &rGenVec, Generator &rResGen)
 Language intersection.
bool EmptyLanguageIntersection (const Generator &rGen1, const Generator &rGen2)
 Test for empty language intersection (same as Disjoind()).
bool LanguageDisjoint (const Generator &rGen1, const Generator &rGen2)
 Test whether two languages are disjoint.
void Automaton (Generator &rGen, const EventSet &rAlphabet)
 Convert generator to automaton wrt specified alphabet.
void Automaton (Generator &rGen)
 Convert generator to automaton.
void LanguageComplement (Generator &rGen, const EventSet &rAlphabet)
 Language complement wrt specified alphabet.
void LanguageComplement (Generator &rGen)
 Language complement.
void LanguageComplement (const Generator &rGen, Generator &rRes)
 Language Complement (uniform API wrapper).
void LanguageComplement (const Generator &rGen, const EventSet &rSigma, Generator &rRes)
 Language Complement (uniform API wrapper).
void LanguageDifference (const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
 Language difference (set-theoretic difference).
void LanguageConcatenateNonDet (const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
 Language concatenation, nondeterministic version.
void LanguageConcatenate (const Generator &rGen1, const Generator &rGen2, Generator &rResGen)
 Language concatenation, deterministic version.
void FullLanguage (const EventSet &rAlphabet, Generator &rResGen)
 Full Language, L(G)=Lm(G)=Sigma*.
void AlphabetLanguage (const EventSet &rAlphabet, Generator &rResGen)
 Alphabet Language, L(G)=Lm(G)=Sigma.
void EmptyStringLanguage (const EventSet &rAlphabet, Generator &rResGen)
 Empty string language, L(G)=Lm(G)={epsilon}.
void EmptyLanguage (const EventSet &rAlphabet, Generator &rResGen)
 Empty language Lm(G)={}.
bool IsEmptyLanguage (const Generator &rGen)
 Test for Empty language Lm(G)=={}.
bool LanguageInclusion (const Generator &rGen1, const Generator &rGen2)
 Test language inclusion, Lm1<=Lm2.
bool LanguageEquality (const Generator &rGen1, const Generator &rGen2)
 Language equality, Lm1==Lm2.
void KleeneClosure (Generator &rGen)
 Kleene Closure.
void KleeneClosure (const Generator &rGen, Generator &rResGen)
 Kleene Closure.
void KleeneClosureNonDet (Generator &rGen)
 Kleene Closure, nondeterministic version.
void PrefixClosure (Generator &rGen)
 Prefix Closure.
bool IsPrefixClosed (const Generator &rGen)
 Test for prefix closed marked language.
bool IsNonblocking (const Generator &rGen)
 Test for nonblocking generator.
bool IsNonblocking (const Generator &rGen1, const Generator &rGen2)
 Test for nonblocking marked languages.
void SelfLoop (Generator &rGen, const EventSet &rAlphabet)
 Self-loop all states.
void SelfLoopMarkedStates (Generator &rGen, const EventSet &rAlphabet)
 Self-loop all marked states.
void SelfLoop (Generator &rGen, const EventSet &rAlphabet, const StateSet &rStates)
 Self-loop specified states.
void StateMin (const Generator &rGen, Generator &rResGen)
 State set minimization.
void aStateMin (const Generator &rGen, Generator &rResGen)
 State set minimization.
void aStateMin (Generator &rGen)
 State set minimization.
void StateMin (Generator &rGen, Generator &rResGen)
 State set minimization.
void StateMin (Generator &rGen, Generator &rResGen, std::vector< StateSet > &rSubsets, std::vector< Idx > &rNewIndices)
 State set minimization.
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 * SDeviceSynchro (void *arg)
int syncSend (int dest, const char *data, int len, int flag)
void * NDeviceListen (void *arg)
void * NDeviceServer (void *)
void * NDeviceReply (void *)
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.

Variables

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

Detailed Description

libFAUDES resides within the namespace faudes.

Plug-Ins may use the same namespace.


Typedef Documentation

Convenience typedef.

Definition at line 243 of file cfl_cgenerator.h.

typedef unsigned long int faudes::fType

Convenience typdef flag data.

Definition at line 164 of file cfl_attributes.h.

typedef long unsigned int faudes::Idx

Type definition for index type.

Definition at line 44 of file cfl_definitions.h.

Definition at line 218 of file cfl_elementary.h.

typedef long int faudes::SignedIdx

Type definition for signed index type.

Definition at line 47 of file cfl_definitions.h.

Convenience typedef for std TimedGenerator.

Definition at line 801 of file tp_tgenerator.h.

typedef void faudes::vDevice

Dummy typedef in the absence of the IO Device plugin.

Definition at line 29 of file sp_dplpexecutor.h.


Function Documentation

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
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
void faudes::CompositionMap1 ( const std::map< std::pair< Idx, Idx >, Idx > &  rCompositionMap,
std::map< Idx, Idx > &  rCompositionMap1 
)

Definition at line 671 of file cfl_parallel.cpp.

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

Definition at line 683 of file cfl_parallel.cpp.

std::string faudes::ContributorsString (  ) 

Return contributors as std::string.

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

Definition at line 727 of file cfl_project.cpp.

std::string faudes::CreateTempFile ( void   ) 

Create a temp file, length 0.

Returns:
Name of temp file
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 betwwen new states and the original state sets. in vectors

Parameters:
rGen Reference to generator
rPowerStates Vector that holds the power states
rDetStates Vector that holds the corresponding deterministic states
rResGen Reference to resulting deterministic generator
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
void faudes::ExitFunction ( void   ) 

Definition at line 385 of file cfl_helper.cpp.

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

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

Parameters:
rString string
len Minimum number of charakters in string
Returns:
Expanded string
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"
const std::string& faudes::FaudesFunctionName ( const Function &  rObject  ) 

Definition at line 689 of file cfl_registry.cpp.

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
long int faudes::IntegerSum ( const IntegerVector &  intvect  ) 
long int faudes::IntegerSum ( const Integer &  arg1,
const Integer &  arg2 
)
bool faudes::IsComplete ( const vGenerator &  rGen,
const StateSet &  rStateSet 
)

Definition at line 3702 of file cfl_generator.cpp.

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
void faudes::LoopCallback ( bool(*)(void)  pBreakFnct  ) 

Algorithm loop callback.

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

Parameters:
pBreakFnct 
void faudes::LoopCallback ( void   ) 

Algorithm loop callback.

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

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

Definition at line 542 of file cfl_helper.cpp.

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

LowExitStates call-by-reference function:

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

Parameters:
rHighAlph High level events
rEntryStatesMap Entry states map (see CreateEntryStatesMap(resmap))
rLowRevTransRel Reverse sorted low level transition relation
highState Hi level state for which to compute low level exit states
rLowExitStates Reference to StateSet for low level exit states (result)
Exceptions:
Exception Hi level state not found in entry states map (with FAUDES_CHECKED)
StateSet faudes::LowExitStates ( const Generator &  rLowGen,
const EventSet &  rHighAlph,
const std::map< Idx, StateSet > &  rEntryStatesMap,
const TransSetX2EvX1 &  rLowRevTransRel,
Idx  highState 
)

LowExitStates return-copy function:

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

Parameters:
rLowGen Low level generator (just needed for determining statetable)
rHighAlph High level events
rEntryStatesMap Entry states map (see CreateEntryStatesMap(resmap))
rLowRevTransRel Reverse sorted low level transition relation
highState Hi level state for which to compute low level exit states
Exceptions:
Exception Hi level state not found in entry states map (with FAUDES_CHECKED) (id 502)
void * faudes::NDeviceListen ( void *  arg  ) 
void* faudes::NDeviceReply ( void *   ) 
void* faudes::NDeviceServer ( void *   ) 
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
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
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::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 
)

Minimized Deterministic projection.

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

Parameters:
rGen Reference to generator
rProjectAlphabet Projection alphabet
rEntryStatesMap Reference to entry states map, see Deterministic(..) (result)
rResGen Reference to resulting deterministic generator (result)
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::RemoveFile ( const std::string &  rFileName  ) 

Delete a file.

Parameters:
rFileName Name of file to delete
void * faudes::SDeviceSynchro ( void *  arg  ) 
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 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; filter conditions are not thouroughly tested.

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.

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
int faudes::syncSend ( int  dest,
const char *  data,
int  len,
int  flag 
)

Definition at line 248 of file iop_simplenet.cpp.

bool faudes::TestProtocol ( void   ) 

Test Protocol.

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

Note: this function closes the current protocol.

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

Test Protocol.

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

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

Test Protocol.

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

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

Test Protocol.

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

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

Test Protocol.

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

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

Test Protocol.

Sets the filename for the test protocol by

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

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

Parameters:
rSource Source file to protocol
Returns:
Filename with nominal protocol.
Idx faudes::ToIdx ( const std::string &  rString  ) 

Convert a string to Idx.

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

float to string

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

integer to string

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

integer to string base 16

Parameters:
number integer
Returns:
string
std::string faudes::VersionString (  ) 

Return FAUDES_VERSION as std::string.

Returns:
std::string with FAUDES_VERSION

Variable Documentation

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

Definition at line 539 of file cfl_helper.cpp.

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

Definition at line 424 of file cfl_helper.cpp.

Definition at line 423 of file cfl_helper.cpp.

int faudes::ran_initialized = 0 [static]

Definition at line 30 of file sp_random.cpp.

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

Definition at line 28 of file sp_random.cpp.

int faudes::ran_stream = 0 [static]

Definition at line 29 of file sp_random.cpp.

libFAUDES 2.22k --- 2013.04.02 --- c++ source docu by doxygen