Classes | |
class | spot::bfs_steps |
Make a BFS in a spot::tgba to compute a tgba_run::steps.This class should be used to compute the shortest path between a state of a spot::tgba and the first transition or state that matches some conditions. More... | |
struct | spot::tgba_statistics |
Functions | |
tgba_explicit * | spot::tgba_dupexp_bfs (const tgba *aut) |
Build an explicit automata from all states of aut, numbering states in bread first order as they are processed. | |
tgba_explicit * | spot::tgba_dupexp_dfs (const tgba *aut) |
Build an explicit automata from all states of aut, numbering states in depth first order as they are processed. | |
tgba_explicit * | spot::tgba_powerset (const tgba *aut) |
Build a deterministic automaton, ignoring acceptance conditions.This create a deterministic automaton that recognize the same language as aut would if its acceptance conditions were ignored. This is the classical powerset algorithm. | |
tgba * | spot::random_graph (int n, float d, const ltl::atomic_prop_set *ap, bdd_dict *dict, int n_acc=0, float a=0.1, float t=0.5, ltl::environment *env=<l::default_environment::instance()) |
Construct a tgba randomly. | |
tgba_statistics | spot::stats_reachable (const tgba *g) |
Compute statistics for an automaton. |
tgba* spot::random_graph | ( | int | n, | |
float | d, | |||
const ltl::atomic_prop_set * | ap, | |||
bdd_dict * | dict, | |||
int | n_acc = 0 , |
|||
float | a = 0.1 , |
|||
float | t = 0.5 , |
|||
ltl::environment * | env = <l::default_environment::instance() | |||
) |
Construct a tgba randomly.
n | The number of states wanted in the automata (>0). All states will be connected, and there will be no dead state. | |
d | The density of the automata. This is the probability (between 0.0 and 1.0), to add a transition between two states. All states have at least one outgoing transition, so d is considered only when adding the remaining transition. A density of 1 means all states will be connected to each other. | |
ap | The list of atomic property that should label the transition. | |
dict | The bdd_dict to used for this automata. | |
n_acc | The number of acceptance sets to use. | |
a | The probability (between 0.0 and 1.0) that a transition belongs to an acceptance set. | |
t | The probability (between 0.0 and 1.0) that an atomic proposition is true. | |
env | The environment in which to declare the acceptance conditions. |
This algorithms is adapted from the one in Fig 6.2 page 48 of
/// @TechReport{ tauriainen.00.a66, /// author = {Heikki Tauriainen}, /// title = {Automated Testing of {B\"u}chi Automata Translators for /// {L}inear {T}emporal {L}ogic}, /// address = {Espoo, Finland}, /// institution = {Helsinki University of Technology, Laboratory for /// Theoretical Computer Science}, /// number = {A66}, /// year = {2000}, /// url = {http://citeseer.nj.nec.com/tauriainen00automated.html}, /// type = {Research Report}, /// note = {Reprint of Master's thesis} /// } ///
Although the intent is similar, there are some differences with between the above published algorithm and this implementation . First labels are on transitions, and acceptance conditions are generated too. Second, the number of successors of a node is chosen in following a normal distribution with mean
and variance
. (This is less accurate, but faster than considering all possible n successors one by one.)
tgba_statistics spot::stats_reachable | ( | const tgba * | g | ) |
Compute statistics for an automaton.
tgba_explicit* spot::tgba_dupexp_bfs | ( | const tgba * | aut | ) |
Build an explicit automata from all states of aut, numbering states in bread first order as they are processed.
tgba_explicit* spot::tgba_dupexp_dfs | ( | const tgba * | aut | ) |
Build an explicit automata from all states of aut, numbering states in depth first order as they are processed.
tgba_explicit* spot::tgba_powerset | ( | const tgba * | aut | ) |
Build a deterministic automaton, ignoring acceptance conditions.This create a deterministic automaton that recognize the same language as aut would if its acceptance conditions were ignored. This is the classical powerset algorithm.