Vcsn  2.4
Be Rational
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
algos.cc File Reference
Include dependency graph for algos.cc:

Go to the source code of this file.

Namespaces

 vcsn
 
 vcsn::dyn
 
 vcsn::dyn::detail
 

Functions

static Registry< accessible_t > & vcsn::dyn::detail::accessible_registry ()
 
bool vcsn::dyn::detail::accessible_register (const signature &sig, accessible_t fn)
 
automaton vcsn::dyn::accessible (const automaton &aut)
 The accessible subautomaton of aut. More...
 
static Registry< add_t > & vcsn::dyn::detail::add_registry ()
 
bool vcsn::dyn::detail::add_register (const signature &sig, add_t fn)
 
automaton vcsn::dyn::add (const automaton &lhs, const automaton &rhs, const std::string &algo="auto")
 Sum of two automata. More...
 
static Registry
< add_expansion_t > & 
vcsn::dyn::detail::add_expansion_registry ()
 
bool vcsn::dyn::detail::add_expansion_register (const signature &sig, add_expansion_t fn)
 
expression vcsn::dyn::add (const expression &lhs, const expression &rhs)
 Sum of two expressions. More...
 
static Registry
< add_expression_t > & 
vcsn::dyn::detail::add_expression_registry ()
 
bool vcsn::dyn::detail::add_expression_register (const signature &sig, add_expression_t fn)
 
static Registry
< add_polynomial_t > & 
vcsn::dyn::detail::add_polynomial_registry ()
 
bool vcsn::dyn::detail::add_polynomial_register (const signature &sig, add_polynomial_t fn)
 
static Registry< add_weight_t > & vcsn::dyn::detail::add_weight_registry ()
 
bool vcsn::dyn::detail::add_weight_register (const signature &sig, add_weight_t fn)
 
static Registry
< ambiguous_word_t > & 
vcsn::dyn::detail::ambiguous_word_registry ()
 
bool vcsn::dyn::detail::ambiguous_word_register (const signature &sig, ambiguous_word_t fn)
 
word vcsn::dyn::ambiguous_word (const automaton &aut)
 An ambiguous word, or raise if there is none. More...
 
static Registry
< are_equivalent_t > & 
vcsn::dyn::detail::are_equivalent_registry ()
 
bool vcsn::dyn::detail::are_equivalent_register (const signature &sig, are_equivalent_t fn)
 
bool vcsn::dyn::are_equivalent (const automaton &lhs, const automaton &rhs)
 Whether compute the same series. More...
 
static Registry
< are_equivalent_expression_t > & 
vcsn::dyn::detail::are_equivalent_expression_registry ()
 
bool vcsn::dyn::detail::are_equivalent_expression_register (const signature &sig, are_equivalent_expression_t fn)
 
bool vcsn::dyn::are_equivalent (const expression &lhs, const expression &rhs)
 Whether denote the same series. More...
 
static Registry
< are_isomorphic_t > & 
vcsn::dyn::detail::are_isomorphic_registry ()
 
bool vcsn::dyn::detail::are_isomorphic_register (const signature &sig, are_isomorphic_t fn)
 
bool vcsn::dyn::are_isomorphic (const automaton &lhs, const automaton &rhs)
 Whether there exists an isomorphism between the states of lhs and those of rhs. More...
 
static Registry< cerny_t > & vcsn::dyn::detail::cerny_registry ()
 
bool vcsn::dyn::detail::cerny_register (const signature &sig, cerny_t fn)
 
automaton vcsn::dyn::cerny (const context &ctx, unsigned num_states)
 Produce a Černý automaton of num_states states. More...
 
static Registry< coaccessible_t > & vcsn::dyn::detail::coaccessible_registry ()
 
bool vcsn::dyn::detail::coaccessible_register (const signature &sig, coaccessible_t fn)
 
automaton vcsn::dyn::coaccessible (const automaton &aut)
 The coaccessible subautomaton of aut. More...
 
static Registry
< codeterminize_t > & 
vcsn::dyn::detail::codeterminize_registry ()
 
bool vcsn::dyn::detail::codeterminize_register (const signature &sig, codeterminize_t fn)
 
automaton vcsn::dyn::codeterminize (const automaton &aut, const std::string &algo="auto")
 The codeterminized automaton. More...
 
static Registry< cominimize_t > & vcsn::dyn::detail::cominimize_registry ()
 
bool vcsn::dyn::detail::cominimize_register (const signature &sig, cominimize_t fn)
 
automaton vcsn::dyn::cominimize (const automaton &aut, const std::string &algo="auto")
 The cominimized automaton. More...
 
static Registry< complement_t > & vcsn::dyn::detail::complement_registry ()
 
bool vcsn::dyn::detail::complement_register (const signature &sig, complement_t fn)
 
automaton vcsn::dyn::complement (const automaton &aut)
 The complement of aut. More...
 
static Registry
< complement_expansion_t > & 
vcsn::dyn::detail::complement_expansion_registry ()
 
bool vcsn::dyn::detail::complement_expansion_register (const signature &sig, complement_expansion_t fn)
 
expansion vcsn::dyn::complement (const expansion &x)
 Complement this expansion. More...
 
static Registry
< complement_expression_t > & 
vcsn::dyn::detail::complement_expression_registry ()
 
bool vcsn::dyn::detail::complement_expression_register (const signature &sig, complement_expression_t fn)
 
static Registry< complete_t > & vcsn::dyn::detail::complete_registry ()
 
bool vcsn::dyn::detail::complete_register (const signature &sig, complete_t fn)
 
automaton vcsn::dyn::complete (const automaton &aut)
 A completed copy of aut. More...
 
static Registry< component_t > & vcsn::dyn::detail::component_registry ()
 
bool vcsn::dyn::detail::component_register (const signature &sig, component_t fn)
 
automaton vcsn::dyn::component (const automaton &aut, unsigned num)
 The automaton of a strongly connected component. More...
 
static Registry< compose_t > & vcsn::dyn::detail::compose_registry ()
 
bool vcsn::dyn::detail::compose_register (const signature &sig, compose_t fn)
 
automaton vcsn::dyn::compose (const automaton &lhs, const automaton &rhs, bool lazy=false)
 The composition of transducers lhs and rhs. More...
 
static Registry
< compose_expansion_t > & 
vcsn::dyn::detail::compose_expansion_registry ()
 
bool vcsn::dyn::detail::compose_expansion_register (const signature &sig, compose_expansion_t fn)
 
expansion vcsn::dyn::compose (const expansion &lhs, const expansion &rhs)
 The composition of two expansions. More...
 
static Registry
< compose_expression_t > & 
vcsn::dyn::detail::compose_expression_registry ()
 
bool vcsn::dyn::detail::compose_expression_register (const signature &sig, compose_expression_t fn)
 
static Registry
< compose_polynomial_t > & 
vcsn::dyn::detail::compose_polynomial_registry ()
 
bool vcsn::dyn::detail::compose_polynomial_register (const signature &sig, compose_polynomial_t fn)
 
static Registry
< concatenate_expression_t > & 
vcsn::dyn::detail::concatenate_expression_registry ()
 
bool vcsn::dyn::detail::concatenate_expression_register (const signature &sig, concatenate_expression_t fn)
 
expression vcsn::dyn::concatenate (const expression &lhs, const expression &rhs)
 Concatenate two expressions. More...
 
static Registry< condense_t > & vcsn::dyn::detail::condense_registry ()
 
bool vcsn::dyn::detail::condense_register (const signature &sig, condense_t fn)
 
automaton vcsn::dyn::condense (const automaton &aut)
 The condensation of aut such that each state is a strongly connected component. More...
 
static Registry< conjugate_t > & vcsn::dyn::detail::conjugate_registry ()
 
bool vcsn::dyn::detail::conjugate_register (const signature &sig, conjugate_t fn)
 
automaton vcsn::dyn::conjugate (const automaton &aut)
 The conjugate of aut. More...
 
static Registry< conjunction_t > & vcsn::dyn::detail::conjunction_registry ()
 
bool vcsn::dyn::detail::conjunction_register (const signature &sig, conjunction_t fn)
 
automaton vcsn::dyn::conjunction (const std::vector< automaton > &as, bool lazy=false)
 The conjunction (aka synchronized product) of automata. More...
 
static Registry
< conjunction_expansion_t > & 
vcsn::dyn::detail::conjunction_expansion_registry ()
 
bool vcsn::dyn::detail::conjunction_expansion_register (const signature &sig, conjunction_expansion_t fn)
 
expansion vcsn::dyn::conjunction (const expansion &lhs, const expansion &rhs)
 The Hadamard product of expansions lhs and rhs. More...
 
static Registry
< conjunction_expression_t > & 
vcsn::dyn::detail::conjunction_expression_registry ()
 
bool vcsn::dyn::detail::conjunction_expression_register (const signature &sig, conjunction_expression_t fn)
 
static Registry
< conjunction_polynomial_t > & 
vcsn::dyn::detail::conjunction_polynomial_registry ()
 
bool vcsn::dyn::detail::conjunction_polynomial_register (const signature &sig, conjunction_polynomial_t fn)
 
static Registry
< conjunction_repeated_t > & 
vcsn::dyn::detail::conjunction_repeated_registry ()
 
bool vcsn::dyn::detail::conjunction_repeated_register (const signature &sig, conjunction_repeated_t fn)
 
automaton vcsn::dyn::conjunction (const automaton &aut, unsigned n)
 Repeated conjunction of aut with itself. More...
 
static Registry
< constant_term_t > & 
vcsn::dyn::detail::constant_term_registry ()
 
bool vcsn::dyn::detail::constant_term_register (const signature &sig, constant_term_t fn)
 
weight vcsn::dyn::constant_term (const expression &e)
 The weight associated to the empty word in e. More...
 
static Registry< context_of_t > & vcsn::dyn::detail::context_of_registry ()
 
bool vcsn::dyn::detail::context_of_register (const signature &sig, context_of_t fn)
 
context vcsn::dyn::context_of (const automaton &a)
 The context of this automaton. More...
 
static Registry
< context_of_expansion_t > & 
vcsn::dyn::detail::context_of_expansion_registry ()
 
bool vcsn::dyn::detail::context_of_expansion_register (const signature &sig, context_of_expansion_t fn)
 
context vcsn::dyn::context_of (const expansion &r)
 The context of this expansion. More...
 
static Registry
< context_of_expression_t > & 
vcsn::dyn::detail::context_of_expression_registry ()
 
bool vcsn::dyn::detail::context_of_expression_register (const signature &sig, context_of_expression_t fn)
 
static Registry
< context_of_polynomial_t > & 
vcsn::dyn::detail::context_of_polynomial_registry ()
 
bool vcsn::dyn::detail::context_of_polynomial_register (const signature &sig, context_of_polynomial_t fn)
 
static Registry< copy_t > & vcsn::dyn::detail::copy_registry ()
 
bool vcsn::dyn::detail::copy_register (const signature &sig, copy_t fn)
 
automaton vcsn::dyn::copy (const automaton &aut)
 A copy of aut. More...
 
static Registry< copy_convert_t > & vcsn::dyn::detail::copy_convert_registry ()
 
bool vcsn::dyn::detail::copy_convert_register (const signature &sig, copy_convert_t fn)
 
automaton vcsn::dyn::copy (const automaton &aut, const context &ctx)
 A copy of aut converted to context ctx. More...
 
static Registry
< copy_expression_t > & 
vcsn::dyn::detail::copy_expression_registry ()
 
bool vcsn::dyn::detail::copy_expression_register (const signature &sig, copy_expression_t fn)
 
expression vcsn::dyn::copy (const expression &exp, const context &ctx, identities ids)
 Copy of exp, but built with ctx. More...
 
static Registry< costandard_t > & vcsn::dyn::detail::costandard_registry ()
 
bool vcsn::dyn::detail::costandard_register (const signature &sig, costandard_t fn)
 
automaton vcsn::dyn::costandard (const automaton &a)
 A co-standardized a. More...
 
static Registry< cotrie_t > & vcsn::dyn::detail::cotrie_registry ()
 
bool vcsn::dyn::detail::cotrie_register (const signature &sig, cotrie_t fn)
 
automaton vcsn::dyn::cotrie (const polynomial &p)
 A reversed trie-like automaton (multiple initial states, single final state) automaton to accept p. More...
 
static Registry
< cotrie_stream_t > & 
vcsn::dyn::detail::cotrie_stream_registry ()
 
bool vcsn::dyn::detail::cotrie_stream_register (const signature &sig, cotrie_stream_t fn)
 
automaton vcsn::dyn::cotrie (const context &ctx, std::istream &is, const std::string &format="default")
 A reversed trie-like automaton (multiple initial states, single final state) automaton to accept the series contained in is. More...
 
static Registry< de_bruijn_t > & vcsn::dyn::detail::de_bruijn_registry ()
 
bool vcsn::dyn::detail::de_bruijn_register (const signature &sig, de_bruijn_t fn)
 
automaton vcsn::dyn::de_bruijn (const context &ctx, unsigned n)
 A simple NFA for (a+b)*a(a+b)^n. More...
 
static Registry
< delay_automaton_t > & 
vcsn::dyn::detail::delay_automaton_registry ()
 
bool vcsn::dyn::detail::delay_automaton_register (const signature &sig, delay_automaton_t fn)
 
automaton vcsn::dyn::delay_automaton (const automaton &a)
 The automaton with the delay of each state. More...
 
static Registry< derivation_t > & vcsn::dyn::detail::derivation_registry ()
 
bool vcsn::dyn::detail::derivation_register (const signature &sig, derivation_t fn)
 
polynomial vcsn::dyn::derivation (const expression &exp, const label &lbl, bool breaking=false)
 Derive exp with respect to s. More...
 
static Registry< derived_term_t > & vcsn::dyn::detail::derived_term_registry ()
 
bool vcsn::dyn::detail::derived_term_register (const signature &sig, derived_term_t fn)
 
automaton vcsn::dyn::derived_term (const expression &exp, const std::string &algo="auto")
 The derived-term automaton of exp. More...
 
static Registry< determinize_t > & vcsn::dyn::detail::determinize_registry ()
 
bool vcsn::dyn::detail::determinize_register (const signature &sig, determinize_t fn)
 
automaton vcsn::dyn::determinize (const automaton &aut, const std::string &algo="auto")
 The determinized automaton. More...
 
static Registry< difference_t > & vcsn::dyn::detail::difference_registry ()
 
bool vcsn::dyn::detail::difference_register (const signature &sig, difference_t fn)
 
automaton vcsn::dyn::difference (const automaton &lhs, const automaton &rhs)
 An automaton whose behavior is that of lhs on words not accepted by rhs. More...
 
static Registry
< difference_expression_t > & 
vcsn::dyn::detail::difference_expression_registry ()
 
bool vcsn::dyn::detail::difference_expression_register (const signature &sig, difference_expression_t fn)
 
expression vcsn::dyn::difference (const expression &lhs, const expression &rhs)
 Words accepted by lhs, but not by rhs. More...
 
static Registry< divkbaseb_t > & vcsn::dyn::detail::divkbaseb_registry ()
 
bool vcsn::dyn::detail::divkbaseb_register (const signature &sig, divkbaseb_t fn)
 
automaton vcsn::dyn::divkbaseb (const context &ctx, unsigned divisor, unsigned base)
 An automaton which accepts a word n representing a number in base b iff k|n. More...
 
static Registry< double_ring_t > & vcsn::dyn::detail::double_ring_registry ()
 
bool vcsn::dyn::detail::double_ring_register (const signature &sig, double_ring_t fn)
 
automaton vcsn::dyn::double_ring (const context &ctx, unsigned n, const std::vector< unsigned > &f)
 The double_ring automaton with n states and f the list of finals. More...
 
static Registry
< eliminate_state_t > & 
vcsn::dyn::detail::eliminate_state_registry ()
 
bool vcsn::dyn::detail::eliminate_state_register (const signature &sig, eliminate_state_t fn)
 
automaton vcsn::dyn::eliminate_state (const automaton &aut, int s=-1)
 The LAO automaton aut with state s removed. More...
 
static Registry
< eval_polynomial_t > & 
vcsn::dyn::detail::eval_polynomial_registry ()
 
bool vcsn::dyn::detail::eval_polynomial_register (const signature &sig, eval_polynomial_t fn)
 
weight vcsn::dyn::evaluate (const automaton &aut, const word &l)
 Evaluate l on aut. More...
 
static Registry< evaluate_t > & vcsn::dyn::detail::evaluate_registry ()
 
bool vcsn::dyn::detail::evaluate_register (const signature &sig, evaluate_t fn)
 
static Registry< expand_t > & vcsn::dyn::detail::expand_registry ()
 
bool vcsn::dyn::detail::expand_register (const signature &sig, expand_t fn)
 
expression vcsn::dyn::expand (const expression &e)
 Distribute product over addition recursively under the starred subexpressions and group the equal monomials. More...
 
static Registry
< expression_one_t > & 
vcsn::dyn::detail::expression_one_registry ()
 
bool vcsn::dyn::detail::expression_one_register (const signature &sig, expression_one_t fn)
 
expression vcsn::dyn::expression_one (const context &c, identities ids)
 The expression for \\e. More...
 
static Registry
< expression_zero_t > & 
vcsn::dyn::detail::expression_zero_registry ()
 
bool vcsn::dyn::detail::expression_zero_register (const signature &sig, expression_zero_t fn)
 
expression vcsn::dyn::expression_zero (const context &c, identities ids)
 The expression for \\z. More...
 
static Registry< factor_t > & vcsn::dyn::detail::factor_registry ()
 
bool vcsn::dyn::detail::factor_register (const signature &sig, factor_t fn)
 
automaton vcsn::dyn::factor (const automaton &aut)
 Create a factor automaton from aut. More...
 
static Registry< filter_t > & vcsn::dyn::detail::filter_registry ()
 
bool vcsn::dyn::detail::filter_register (const signature &sig, filter_t fn)
 
automaton vcsn::dyn::filter (const automaton &aut, const std::vector< unsigned > &ss)
 The subautomaton based on aut, with only states in ss visible. More...
 
static Registry
< has_bounded_lag_t > & 
vcsn::dyn::detail::has_bounded_lag_registry ()
 
bool vcsn::dyn::detail::has_bounded_lag_register (const signature &sig, has_bounded_lag_t fn)
 
bool vcsn::dyn::has_bounded_lag (const automaton &aut)
 Whether the transducer has bounded lag. More...
 
static Registry
< has_lightening_cycle_t > & 
vcsn::dyn::detail::has_lightening_cycle_registry ()
 
bool vcsn::dyn::detail::has_lightening_cycle_register (const signature &sig, has_lightening_cycle_t fn)
 
bool vcsn::dyn::has_lightening_cycle (const automaton &aut)
 Whether the automaton has a cycle with lightening weight. More...
 
static Registry
< has_twins_property_t > & 
vcsn::dyn::detail::has_twins_property_registry ()
 
bool vcsn::dyn::detail::has_twins_property_register (const signature &sig, has_twins_property_t fn)
 
bool vcsn::dyn::has_twins_property (const automaton &aut)
 Whether the automaton has the twins property. More...
 
static Registry
< identities_of_t > & 
vcsn::dyn::detail::identities_of_registry ()
 
bool vcsn::dyn::detail::identities_of_register (const signature &sig, identities_of_t fn)
 
identities vcsn::dyn::identities_of (const expression &exp)
 The identities of expression exp. More...
 
static Registry< inductive_t > & vcsn::dyn::detail::inductive_registry ()
 
bool vcsn::dyn::detail::inductive_register (const signature &sig, inductive_t fn)
 
automaton vcsn::dyn::inductive (const expression &e, const std::string &algo="auto")
 The inductive translation of e in an automaton. More...
 
static Registry< infiltrate_t > & vcsn::dyn::detail::infiltrate_registry ()
 
bool vcsn::dyn::detail::infiltrate_register (const signature &sig, infiltrate_t fn)
 
automaton vcsn::dyn::infiltrate (const std::vector< automaton > &as)
 The infiltration product of automata. More...
 
static Registry
< infiltrate_expression_t > & 
vcsn::dyn::detail::infiltrate_expression_registry ()
 
bool vcsn::dyn::detail::infiltrate_expression_register (const signature &sig, infiltrate_expression_t fn)
 
expression vcsn::dyn::infiltrate (const expression &lhs, const expression &rhs)
 The infiltration product of expressions lhs and rhs. More...
 
static Registry< info_t > & vcsn::dyn::detail::info_registry ()
 
bool vcsn::dyn::detail::info_register (const signature &sig, info_t fn)
 
std::ostream & vcsn::dyn::info (const automaton &aut, std::ostream &out=std::cout, unsigned details=2)
 Output various facts about an automaton. More...
 
static Registry
< info_expression_t > & 
vcsn::dyn::detail::info_expression_registry ()
 
bool vcsn::dyn::detail::info_expression_register (const signature &sig, info_expression_t fn)
 
std::ostream & vcsn::dyn::info (const expression &exp, std::ostream &out=std::cout)
 Output various facts about exp. More...
 
static Registry< insplit_t > & vcsn::dyn::detail::insplit_registry ()
 
bool vcsn::dyn::detail::insplit_register (const signature &sig, insplit_t fn)
 
automaton vcsn::dyn::insplit (const automaton &aut, bool lazy=false)
 Split automaton on the incoming transition. More...
 
static Registry
< is_accessible_t > & 
vcsn::dyn::detail::is_accessible_registry ()
 
bool vcsn::dyn::detail::is_accessible_register (const signature &sig, is_accessible_t fn)
 
bool vcsn::dyn::is_accessible (const automaton &aut)
 Whether aut is accessible. More...
 
static Registry< is_ambiguous_t > & vcsn::dyn::detail::is_ambiguous_registry ()
 
bool vcsn::dyn::detail::is_ambiguous_register (const signature &sig, is_ambiguous_t fn)
 
bool vcsn::dyn::is_ambiguous (const automaton &aut)
 Whether aut is ambiguous. More...
 
static Registry
< is_coaccessible_t > & 
vcsn::dyn::detail::is_coaccessible_registry ()
 
bool vcsn::dyn::detail::is_coaccessible_register (const signature &sig, is_coaccessible_t fn)
 
bool vcsn::dyn::is_coaccessible (const automaton &aut)
 Whether aut is coaccessible. More...
 
static Registry
< is_codeterministic_t > & 
vcsn::dyn::detail::is_codeterministic_registry ()
 
bool vcsn::dyn::detail::is_codeterministic_register (const signature &sig, is_codeterministic_t fn)
 
bool vcsn::dyn::is_codeterministic (const automaton &aut)
 Whether aut is codeterministic. More...
 
static Registry< is_complete_t > & vcsn::dyn::detail::is_complete_registry ()
 
bool vcsn::dyn::detail::is_complete_register (const signature &sig, is_complete_t fn)
 
bool vcsn::dyn::is_complete (const automaton &aut)
 Whether aut is complete. More...
 
static Registry
< is_costandard_t > & 
vcsn::dyn::detail::is_costandard_registry ()
 
bool vcsn::dyn::detail::is_costandard_register (const signature &sig, is_costandard_t fn)
 
bool vcsn::dyn::is_costandard (const automaton &aut)
 Whether is costandard (unique final state, with weight one, no outcoming transition). More...
 
static Registry
< is_cycle_ambiguous_t > & 
vcsn::dyn::detail::is_cycle_ambiguous_registry ()
 
bool vcsn::dyn::detail::is_cycle_ambiguous_register (const signature &sig, is_cycle_ambiguous_t fn)
 
bool vcsn::dyn::is_cycle_ambiguous (const automaton &aut)
 Whether the automaton is cycle-ambiguous. More...
 
static Registry
< is_deterministic_t > & 
vcsn::dyn::detail::is_deterministic_registry ()
 
bool vcsn::dyn::detail::is_deterministic_register (const signature &sig, is_deterministic_t fn)
 
bool vcsn::dyn::is_deterministic (const automaton &aut)
 Whether aut is deterministic. More...
 
static Registry< is_empty_t > & vcsn::dyn::detail::is_empty_registry ()
 
bool vcsn::dyn::detail::is_empty_register (const signature &sig, is_empty_t fn)
 
bool vcsn::dyn::is_empty (const automaton &aut)
 Whether has no state. More...
 
static Registry
< is_eps_acyclic_t > & 
vcsn::dyn::detail::is_eps_acyclic_registry ()
 
bool vcsn::dyn::detail::is_eps_acyclic_register (const signature &sig, is_eps_acyclic_t fn)
 
bool vcsn::dyn::is_eps_acyclic (const automaton &aut)
 Whether has no cycle of spontaneous transitions. More...
 
static Registry
< is_functional_t > & 
vcsn::dyn::detail::is_functional_registry ()
 
bool vcsn::dyn::detail::is_functional_register (const signature &sig, is_functional_t fn)
 
bool vcsn::dyn::is_functional (const automaton &aut)
 Whether aut is functional. More...
 
static Registry
< is_letterized_t > & 
vcsn::dyn::detail::is_letterized_registry ()
 
bool vcsn::dyn::detail::is_letterized_register (const signature &sig, is_letterized_t fn)
 
bool vcsn::dyn::is_letterized (const automaton &aut)
 Whether aut is letterized. More...
 
static Registry
< is_normalized_t > & 
vcsn::dyn::detail::is_normalized_registry ()
 
bool vcsn::dyn::detail::is_normalized_register (const signature &sig, is_normalized_t fn)
 
bool vcsn::dyn::is_normalized (const automaton &aut)
 Whether is normalized (in the Thompson sense), i.e., standard and co-standard. More...
 
static Registry
< is_out_sorted_t > & 
vcsn::dyn::detail::is_out_sorted_registry ()
 
bool vcsn::dyn::detail::is_out_sorted_register (const signature &sig, is_out_sorted_t fn)
 
bool vcsn::dyn::is_out_sorted (const automaton &aut)
 Whether the outgoing transitions of each state have increasing labels. More...
 
static Registry
< is_partial_identity_t > & 
vcsn::dyn::detail::is_partial_identity_registry ()
 
bool vcsn::dyn::detail::is_partial_identity_register (const signature &sig, is_partial_identity_t fn)
 
bool vcsn::dyn::is_partial_identity (const automaton &aut)
 Whether aut realizes a partial identity. More...
 
static Registry< is_proper_t > & vcsn::dyn::detail::is_proper_registry ()
 
bool vcsn::dyn::detail::is_proper_register (const signature &sig, is_proper_t fn)
 
bool vcsn::dyn::is_proper (const automaton &aut)
 Whether has no spontaneous transition. More...
 
static Registry< is_realtime_t > & vcsn::dyn::detail::is_realtime_registry ()
 
bool vcsn::dyn::detail::is_realtime_register (const signature &sig, is_realtime_t fn)
 
bool vcsn::dyn::is_realtime (const automaton &aut)
 Whether has no spontaneous transition, and is letterized. More...
 
static Registry< is_standard_t > & vcsn::dyn::detail::is_standard_registry ()
 
bool vcsn::dyn::detail::is_standard_register (const signature &sig, is_standard_t fn)
 
bool vcsn::dyn::is_standard (const automaton &aut)
 Whether is standard (unique initial state, with weight one, no incoming transition). More...
 
static Registry
< is_synchronized_t > & 
vcsn::dyn::detail::is_synchronized_registry ()
 
bool vcsn::dyn::detail::is_synchronized_register (const signature &sig, is_synchronized_t fn)
 
bool vcsn::dyn::is_synchronized (const automaton &aut)
 Whether is synchronized. More...
 
static Registry
< is_synchronized_by_t > & 
vcsn::dyn::detail::is_synchronized_by_registry ()
 
bool vcsn::dyn::detail::is_synchronized_by_register (const signature &sig, is_synchronized_by_t fn)
 
bool vcsn::dyn::is_synchronized_by (const automaton &aut, const word &word)
 Whether the word synchronizes aut. More...
 
static Registry
< is_synchronizing_t > & 
vcsn::dyn::detail::is_synchronizing_registry ()
 
bool vcsn::dyn::detail::is_synchronizing_register (const signature &sig, is_synchronizing_t fn)
 
bool vcsn::dyn::is_synchronizing (const automaton &aut)
 Whether is synchronizing. More...
 
static Registry< is_trim_t > & vcsn::dyn::detail::is_trim_registry ()
 
bool vcsn::dyn::detail::is_trim_register (const signature &sig, is_trim_t fn)
 
bool vcsn::dyn::is_trim (const automaton &aut)
 Whether has no useless state. More...
 
static Registry< is_useless_t > & vcsn::dyn::detail::is_useless_registry ()
 
bool vcsn::dyn::detail::is_useless_register (const signature &sig, is_useless_t fn)
 
bool vcsn::dyn::is_useless (const automaton &aut)
 Whether has no useful state. More...
 
static Registry< is_valid_t > & vcsn::dyn::detail::is_valid_registry ()
 
bool vcsn::dyn::detail::is_valid_register (const signature &sig, is_valid_t fn)
 
bool vcsn::dyn::is_valid (const automaton &e)
 Whether automaton is valid (epsilon-cycles converge). More...
 
static Registry
< is_valid_expression_t > & 
vcsn::dyn::detail::is_valid_expression_registry ()
 
bool vcsn::dyn::detail::is_valid_expression_register (const signature &sig, is_valid_expression_t fn)
 
bool vcsn::dyn::is_valid (const expression &e)
 Whether rational expression is valid (all the starred sub-expressions are starrable). More...
 
static Registry< join_t > & vcsn::dyn::detail::join_registry ()
 
bool vcsn::dyn::detail::join_register (const signature &sig, join_t fn)
 
context vcsn::dyn::join (const context &lhs, const context &rhs)
 The join between two contexts, i.e., their lowest common supertype. More...
 
static Registry< ladybird_t > & vcsn::dyn::detail::ladybird_registry ()
 
bool vcsn::dyn::detail::ladybird_register (const signature &sig, ladybird_t fn)
 
automaton vcsn::dyn::ladybird (const context &ctx, unsigned n)
 The ladybird automaton with n states. More...
 
static Registry< ldivide_t > & vcsn::dyn::detail::ldivide_registry ()
 
bool vcsn::dyn::detail::ldivide_register (const signature &sig, ldivide_t fn)
 
automaton vcsn::dyn::ldivide (const automaton &lhs, const automaton &rhs)
 Left-division of two automata (lhs \ rhs). More...
 
static Registry
< ldivide_expansion_t > & 
vcsn::dyn::detail::ldivide_expansion_registry ()
 
bool vcsn::dyn::detail::ldivide_expansion_register (const signature &sig, ldivide_expansion_t fn)
 
expansion vcsn::dyn::ldivide (const expansion &lhs, const expansion &rhs)
 Left-division of two expansions (lhs \ rhs). More...
 
static Registry
< ldivide_expression_t > & 
vcsn::dyn::detail::ldivide_expression_registry ()
 
bool vcsn::dyn::detail::ldivide_expression_register (const signature &sig, ldivide_expression_t fn)
 
static Registry
< ldivide_label_t > & 
vcsn::dyn::detail::ldivide_label_registry ()
 
bool vcsn::dyn::detail::ldivide_label_register (const signature &sig, ldivide_label_t fn)
 
static Registry
< ldivide_polynomial_t > & 
vcsn::dyn::detail::ldivide_polynomial_registry ()
 
bool vcsn::dyn::detail::ldivide_polynomial_register (const signature &sig, ldivide_polynomial_t fn)
 
static Registry
< ldivide_weight_t > & 
vcsn::dyn::detail::ldivide_weight_registry ()
 
bool vcsn::dyn::detail::ldivide_weight_register (const signature &sig, ldivide_weight_t fn)
 
static Registry
< less_than_expression_t > & 
vcsn::dyn::detail::less_than_expression_registry ()
 
bool vcsn::dyn::detail::less_than_expression_register (const signature &sig, less_than_expression_t fn)
 
bool vcsn::dyn::less_than (const expression &lhs, const expression &rhs)
 Ordering between expressions. More...
 
static Registry< letterize_t > & vcsn::dyn::detail::letterize_registry ()
 
bool vcsn::dyn::detail::letterize_register (const signature &sig, letterize_t fn)
 
automaton vcsn::dyn::letterize (const automaton &aut)
 The automaton with letter transitions instead of words. More...
 
static Registry< levenshtein_t > & vcsn::dyn::detail::levenshtein_registry ()
 
bool vcsn::dyn::detail::levenshtein_register (const signature &sig, levenshtein_t fn)
 
automaton vcsn::dyn::levenshtein (const context &ls)
 The transducer representing the Levenshtein distance. More...
 
static Registry
< lgcd_polynomial_t > & 
vcsn::dyn::detail::lgcd_polynomial_registry ()
 
bool vcsn::dyn::detail::lgcd_polynomial_register (const signature &sig, lgcd_polynomial_t fn)
 
polynomial vcsn::dyn::lgcd (const polynomial &lhs, const polynomial &rhs)
 Left greatest common divisor of two polynomials (lhs \ rhs). More...
 
static Registry
< lift_expression_t > & 
vcsn::dyn::detail::lift_expression_registry ()
 
bool vcsn::dyn::detail::lift_expression_register (const signature &sig, lift_expression_t fn)
 
expression vcsn::dyn::lift (const expression &e)
 The lifted LAO rational expression from e. More...
 
static Registry< lightest_t > & vcsn::dyn::detail::lightest_registry ()
 
bool vcsn::dyn::detail::lightest_register (const signature &sig, lightest_t fn)
 
polynomial vcsn::dyn::lightest (const automaton &aut, unsigned num=1, const std::string &algo="auto")
 The approximated behavior of an automaton with smallest weights. More...
 
static Registry
< lightest_automaton_t > & 
vcsn::dyn::detail::lightest_automaton_registry ()
 
bool vcsn::dyn::detail::lightest_automaton_register (const signature &sig, lightest_automaton_t fn)
 
automaton vcsn::dyn::lightest_automaton (const automaton &aut, unsigned num=1, const std::string &algo="auto")
 The shortest path automaton using the given algorithm. More...
 
static Registry< lweight_t > & vcsn::dyn::detail::lweight_registry ()
 
bool vcsn::dyn::detail::lweight_register (const signature &sig, lweight_t fn)
 
automaton vcsn::dyn::lweight (const weight &w, const automaton &aut, const std::string &algo="auto")
 The left-multiplication of an automaton with w as weight. More...
 
static Registry
< lweight_expansion_t > & 
vcsn::dyn::detail::lweight_expansion_registry ()
 
bool vcsn::dyn::detail::lweight_expansion_register (const signature &sig, lweight_expansion_t fn)
 
expansion vcsn::dyn::lweight (const weight &w, const expansion &exp)
 The left-multiplication of an expansion with w as weight. More...
 
static Registry
< lweight_expression_t > & 
vcsn::dyn::detail::lweight_expression_registry ()
 
bool vcsn::dyn::detail::lweight_expression_register (const signature &sig, lweight_expression_t fn)
 
static Registry
< lweight_polynomial_t > & 
vcsn::dyn::detail::lweight_polynomial_registry ()
 
bool vcsn::dyn::detail::lweight_polynomial_register (const signature &sig, lweight_polynomial_t fn)
 
static Registry
< make_automaton_editor_t > & 
vcsn::dyn::detail::make_automaton_editor_registry ()
 
bool vcsn::dyn::detail::make_automaton_editor_register (const signature &sig, make_automaton_editor_t fn)
 
automaton_editor * vcsn::dyn::make_automaton_editor (const context &ctx)
 Build an automatonset from its context. More...
 
static Registry
< make_word_context_t > & 
vcsn::dyn::detail::make_word_context_registry ()
 
bool vcsn::dyn::detail::make_word_context_register (const signature &sig, make_word_context_t fn)
 
context vcsn::dyn::make_word_context (const context &ctx)
 The context for words. More...
 
static Registry< minimize_t > & vcsn::dyn::detail::minimize_registry ()
 
bool vcsn::dyn::detail::minimize_register (const signature &sig, minimize_t fn)
 
automaton vcsn::dyn::minimize (const automaton &aut, const std::string &algo="auto")
 The minimized automaton. More...
 
static Registry< multiply_t > & vcsn::dyn::detail::multiply_registry ()
 
bool vcsn::dyn::detail::multiply_register (const signature &sig, multiply_t fn)
 
automaton vcsn::dyn::multiply (const automaton &lhs, const automaton &rhs, const std::string &algo="auto")
 Multiply (concatenate) two automata. More...
 
static Registry
< multiply_expression_t > & 
vcsn::dyn::detail::multiply_expression_registry ()
 
bool vcsn::dyn::detail::multiply_expression_register (const signature &sig, multiply_expression_t fn)
 
expression vcsn::dyn::multiply (const expression &lhs, const expression &rhs)
 Multiply (concatenate) two expressions. More...
 
static Registry
< multiply_expression_repeated_t > & 
vcsn::dyn::detail::multiply_expression_repeated_registry ()
 
bool vcsn::dyn::detail::multiply_expression_repeated_register (const signature &sig, multiply_expression_repeated_t fn)
 
expression vcsn::dyn::multiply (const expression &e, int min, int max=-2)
 Repeated multiplication (concatenation) of an expression with itself. More...
 
static Registry
< multiply_label_t > & 
vcsn::dyn::detail::multiply_label_registry ()
 
bool vcsn::dyn::detail::multiply_label_register (const signature &sig, multiply_label_t fn)
 
static Registry
< multiply_label_repeated_t > & 
vcsn::dyn::detail::multiply_label_repeated_registry ()
 
bool vcsn::dyn::detail::multiply_label_repeated_register (const signature &sig, multiply_label_repeated_t fn)
 
label vcsn::dyn::multiply (const label &l, int num)
 Repeated multiplication of a label with itself. More...
 
static Registry
< multiply_polynomial_t > & 
vcsn::dyn::detail::multiply_polynomial_registry ()
 
bool vcsn::dyn::detail::multiply_polynomial_register (const signature &sig, multiply_polynomial_t fn)
 
static Registry
< multiply_repeated_t > & 
vcsn::dyn::detail::multiply_repeated_registry ()
 
bool vcsn::dyn::detail::multiply_repeated_register (const signature &sig, multiply_repeated_t fn)
 
automaton vcsn::dyn::multiply (const automaton &aut, int min, int max=-2, const std::string &algo="auto")
 Repeated multiplication (concatenation) of an automaton with itself. More...
 
static Registry
< multiply_weight_t > & 
vcsn::dyn::detail::multiply_weight_registry ()
 
bool vcsn::dyn::detail::multiply_weight_register (const signature &sig, multiply_weight_t fn)
 
static Registry
< multiply_weight_repeated_t > & 
vcsn::dyn::detail::multiply_weight_repeated_registry ()
 
bool vcsn::dyn::detail::multiply_weight_repeated_register (const signature &sig, multiply_weight_repeated_t fn)
 
static Registry< normalize_t > & vcsn::dyn::detail::normalize_registry ()
 
bool vcsn::dyn::detail::normalize_register (const signature &sig, normalize_t fn)
 
automaton vcsn::dyn::normalize (const automaton &aut)
 Normalize automaton aut. More...
 
static Registry
< num_components_t > & 
vcsn::dyn::detail::num_components_registry ()
 
bool vcsn::dyn::detail::num_components_register (const signature &sig, num_components_t fn)
 
std::size_t vcsn::dyn::num_components (const automaton &aut)
 The number of strongly connected components. More...
 
static Registry< num_tapes_t > & vcsn::dyn::detail::num_tapes_registry ()
 
bool vcsn::dyn::detail::num_tapes_register (const signature &sig, num_tapes_t fn)
 
std::size_t vcsn::dyn::num_tapes (const context &ctx)
 The number of input tapes. More...
 
static Registry< pair_t > & vcsn::dyn::detail::pair_registry ()
 
bool vcsn::dyn::detail::pair_register (const signature &sig, pair_t fn)
 
automaton vcsn::dyn::pair (const automaton &aut, bool keep_initials=false)
 Build the pair automaton of the given automaton. More...
 
static Registry
< partial_identity_t > & 
vcsn::dyn::detail::partial_identity_registry ()
 
bool vcsn::dyn::detail::partial_identity_register (const signature &sig, partial_identity_t fn)
 
automaton vcsn::dyn::partial_identity (const automaton &aut)
 Create a partial identity transducer from aut. More...
 
static Registry
< partial_identity_expression_t > & 
vcsn::dyn::detail::partial_identity_expression_registry ()
 
bool vcsn::dyn::detail::partial_identity_expression_register (const signature &sig, partial_identity_expression_t fn)
 
expression vcsn::dyn::partial_identity (const expression &e)
 Create a partial-identity two-tape expression from e. More...
 
static Registry< prefix_t > & vcsn::dyn::detail::prefix_registry ()
 
bool vcsn::dyn::detail::prefix_register (const signature &sig, prefix_t fn)
 
automaton vcsn::dyn::prefix (const automaton &aut)
 Create a prefix automaton from aut. More...
 
static Registry< print_t > & vcsn::dyn::detail::print_registry ()
 
bool vcsn::dyn::detail::print_register (const signature &sig, print_t fn)
 
std::ostream & vcsn::dyn::print (const automaton &aut, std::ostream &out=std::cout, const std::string &format="default")
 Print automaton a on out using format format. More...
 
static Registry
< print_context_t > & 
vcsn::dyn::detail::print_context_registry ()
 
bool vcsn::dyn::detail::print_context_register (const signature &sig, print_context_t fn)
 
std::ostream & vcsn::dyn::print (const context &c, std::ostream &out=std::cout, const std::string &format="default")
 Print context c on out using format format. More...
 
static Registry< proper_t > & vcsn::dyn::detail::proper_registry ()
 
bool vcsn::dyn::detail::proper_register (const signature &sig, proper_t fn)
 
automaton vcsn::dyn::proper (const automaton &aut, direction dir=direction::backward, bool prune=true, const std::string &algo="auto")
 An equivalent automaton without spontaneous transitions. More...
 
static Registry< push_weights_t > & vcsn::dyn::detail::push_weights_registry ()
 
bool vcsn::dyn::detail::push_weights_register (const signature &sig, push_weights_t fn)
 
automaton vcsn::dyn::push_weights (const automaton &aut)
 The weight pushing automaton of aut. More...
 
static Registry< quotkbaseb_t > & vcsn::dyn::detail::quotkbaseb_registry ()
 
bool vcsn::dyn::detail::quotkbaseb_register (const signature &sig, quotkbaseb_t fn)
 
automaton vcsn::dyn::quotkbaseb (const context &ctx, unsigned divisor, unsigned base)
 A transducer that computes the quotient of the division of a word n by k in base b iff k|n. More...
 
static Registry
< random_automaton_t > & 
vcsn::dyn::detail::random_automaton_registry ()
 
bool vcsn::dyn::detail::random_automaton_register (const signature &sig, random_automaton_t fn)
 
automaton vcsn::dyn::random_automaton (const context &ctx, unsigned num_states, float density=0.1, unsigned num_initial=1, unsigned num_final=1, boost::optional< unsigned > max_labels={}, float loop_chance=0.0, const std::string &weights="")
 A random automaton. More...
 
static Registry
< random_automaton_deterministic_t > & 
vcsn::dyn::detail::random_automaton_deterministic_registry ()
 
bool vcsn::dyn::detail::random_automaton_deterministic_register (const signature &sig, random_automaton_deterministic_t fn)
 
automaton vcsn::dyn::random_automaton_deterministic (const context &ctx, unsigned num_states)
 A random deterministic automaton. More...
 
static Registry
< random_expression_t > & 
vcsn::dyn::detail::random_expression_registry ()
 
bool vcsn::dyn::detail::random_expression_register (const signature &sig, random_expression_t fn)
 
expression vcsn::dyn::random_expression (const context &ctx, const std::string &param="+, ., *=.2, w., .w, length=10", identities ids={})
 A random expression. More...
 
static Registry
< random_weight_t > & 
vcsn::dyn::detail::random_weight_registry ()
 
bool vcsn::dyn::detail::random_weight_register (const signature &sig, random_weight_t fn)
 
weight vcsn::dyn::random_weight (const context &ctx, const std::string &param)
 A random weight. More...
 
static Registry< rdivide_t > & vcsn::dyn::detail::rdivide_registry ()
 
bool vcsn::dyn::detail::rdivide_register (const signature &sig, rdivide_t fn)
 
automaton vcsn::dyn::rdivide (const automaton &lhs, const automaton &rhs)
 Right-division of two automata (lhs / rhs). More...
 
static Registry
< rdivide_expression_t > & 
vcsn::dyn::detail::rdivide_expression_registry ()
 
bool vcsn::dyn::detail::rdivide_expression_register (const signature &sig, rdivide_expression_t fn)
 
expression vcsn::dyn::rdivide (const expression &lhs, const expression &rhs)
 Right-division of two expressions (lhs / rhs). More...
 
static Registry
< rdivide_label_t > & 
vcsn::dyn::detail::rdivide_label_registry ()
 
bool vcsn::dyn::detail::rdivide_label_register (const signature &sig, rdivide_label_t fn)
 
static Registry
< rdivide_weight_t > & 
vcsn::dyn::detail::rdivide_weight_registry ()
 
bool vcsn::dyn::detail::rdivide_weight_register (const signature &sig, rdivide_weight_t fn)
 
static Registry
< read_polynomial_t > & 
vcsn::dyn::detail::read_polynomial_registry ()
 
bool vcsn::dyn::detail::read_polynomial_register (const signature &sig, read_polynomial_t fn)
 
polynomial vcsn::dyn::read_polynomial (const context &ctx, std::istream &is)
 Read a polynomial from a stream. More...
 
static Registry< read_weight_t > & vcsn::dyn::detail::read_weight_registry ()
 
bool vcsn::dyn::detail::read_weight_register (const signature &sig, read_weight_t fn)
 
weight vcsn::dyn::read_weight (const context &ctx, std::istream &is)
 Read a weight from a stream. More...
 
static Registry< realtime_t > & vcsn::dyn::detail::realtime_registry ()
 
bool vcsn::dyn::detail::realtime_register (const signature &sig, realtime_t fn)
 
automaton vcsn::dyn::realtime (const automaton &aut)
 Create the realtime automaton (letterized and proper). More...
 
static Registry< reduce_t > & vcsn::dyn::detail::reduce_registry ()
 
bool vcsn::dyn::detail::reduce_register (const signature &sig, reduce_t fn)
 
automaton vcsn::dyn::reduce (const automaton &aut)
 Reduce aut. More...
 
static Registry< rweight_t > & vcsn::dyn::detail::rweight_registry ()
 
bool vcsn::dyn::detail::rweight_register (const signature &sig, rweight_t fn)
 
automaton vcsn::dyn::rweight (const automaton &aut, const weight &w, const std::string &algo="auto")
 The right-mult automaton with w as weight. More...
 
static Registry
< rweight_expansion_t > & 
vcsn::dyn::detail::rweight_expansion_registry ()
 
bool vcsn::dyn::detail::rweight_expansion_register (const signature &sig, rweight_expansion_t fn)
 
expansion vcsn::dyn::rweight (const expansion &aut, const weight &w)
 The right-multiplication of an expansion with w as weight. More...
 
static Registry
< rweight_expression_t > & 
vcsn::dyn::detail::rweight_expression_registry ()
 
bool vcsn::dyn::detail::rweight_expression_register (const signature &sig, rweight_expression_t fn)
 
static Registry
< rweight_polynomial_t > & 
vcsn::dyn::detail::rweight_polynomial_registry ()
 
bool vcsn::dyn::detail::rweight_polynomial_register (const signature &sig, rweight_polynomial_t fn)
 
static Registry< scc_t > & vcsn::dyn::detail::scc_registry ()
 
bool vcsn::dyn::detail::scc_register (const signature &sig, scc_t fn)
 
automaton vcsn::dyn::scc (const automaton &aut, const std::string &algo="auto")
 Build the SCC automaton whose states are labeled with number of the strongly-connected component they belong to. More...
 
static Registry< shortest_t > & vcsn::dyn::detail::shortest_registry ()
 
bool vcsn::dyn::detail::shortest_register (const signature &sig, shortest_t fn)
 
polynomial vcsn::dyn::shortest (const automaton &aut, boost::optional< unsigned > num={}, boost::optional< unsigned > len={})
 The approximated behavior of an automaton. More...
 
static Registry< shuffle_t > & vcsn::dyn::detail::shuffle_registry ()
 
bool vcsn::dyn::detail::shuffle_register (const signature &sig, shuffle_t fn)
 
automaton vcsn::dyn::shuffle (const std::vector< automaton > &as)
 The shuffle product of automata. More...
 
static Registry
< shuffle_expression_t > & 
vcsn::dyn::detail::shuffle_expression_registry ()
 
bool vcsn::dyn::detail::shuffle_expression_register (const signature &sig, shuffle_expression_t fn)
 
expression vcsn::dyn::shuffle (const expression &lhs, const expression &rhs)
 The shuffle product of expressions lhs and rhs. More...
 
static Registry< sort_t > & vcsn::dyn::detail::sort_registry ()
 
bool vcsn::dyn::detail::sort_register (const signature &sig, sort_t fn)
 
automaton vcsn::dyn::sort (const automaton &a)
 A copy of a with normalized state numbers. More...
 
static Registry< split_t > & vcsn::dyn::detail::split_registry ()
 
bool vcsn::dyn::detail::split_register (const signature &sig, split_t fn)
 
polynomial vcsn::dyn::split (const expression &exp)
 Break exp. More...
 
static Registry
< split_polynomial_t > & 
vcsn::dyn::detail::split_polynomial_registry ()
 
bool vcsn::dyn::detail::split_polynomial_register (const signature &sig, split_polynomial_t fn)
 
static Registry< standard_t > & vcsn::dyn::detail::standard_registry ()
 
bool vcsn::dyn::detail::standard_register (const signature &sig, standard_t fn)
 
automaton vcsn::dyn::standard (const automaton &a)
 A standardized a. More...
 
static Registry
< standard_expression_t > & 
vcsn::dyn::detail::standard_expression_registry ()
 
bool vcsn::dyn::detail::standard_expression_register (const signature &sig, standard_expression_t fn)
 
automaton vcsn::dyn::standard (const expression &e)
 The standard automaton of e. More...
 
static Registry< star_t > & vcsn::dyn::detail::star_registry ()
 
bool vcsn::dyn::detail::star_register (const signature &sig, star_t fn)
 
automaton vcsn::dyn::star (const automaton &aut, const std::string &algo="auto")
 Star of an automaton. More...
 
static Registry< star_height_t > & vcsn::dyn::detail::star_height_registry ()
 
bool vcsn::dyn::detail::star_height_register (const signature &sig, star_height_t fn)
 
unsigned vcsn::dyn::star_height (const expression &rs)
 Star height of an expression. More...
 
static Registry
< star_normal_form_t > & 
vcsn::dyn::detail::star_normal_form_registry ()
 
bool vcsn::dyn::detail::star_normal_form_register (const signature &sig, star_normal_form_t fn)
 
expression vcsn::dyn::star_normal_form (const expression &e)
 A normalized form where star is applied only to proper expressions. More...
 
static Registry< strip_t > & vcsn::dyn::detail::strip_registry ()
 
bool vcsn::dyn::detail::strip_register (const signature &sig, strip_t fn)
 
automaton vcsn::dyn::strip (const automaton &a)
 The automaton in a with its metadata layers removed. More...
 
static Registry< subword_t > & vcsn::dyn::detail::subword_registry ()
 
bool vcsn::dyn::detail::subword_register (const signature &sig, subword_t fn)
 
automaton vcsn::dyn::subword (const automaton &aut)
 Create a subword automaton from aut. More...
 
static Registry< suffix_t > & vcsn::dyn::detail::suffix_registry ()
 
bool vcsn::dyn::detail::suffix_register (const signature &sig, suffix_t fn)
 
automaton vcsn::dyn::suffix (const automaton &aut)
 Create a suffix automaton from aut. More...
 
static Registry< synchronize_t > & vcsn::dyn::detail::synchronize_registry ()
 
bool vcsn::dyn::detail::synchronize_register (const signature &sig, synchronize_t fn)
 
automaton vcsn::dyn::synchronize (const automaton &aut)
 Create a synchronized transducer from aut. More...
 
static Registry
< synchronizing_word_t > & 
vcsn::dyn::detail::synchronizing_word_registry ()
 
bool vcsn::dyn::detail::synchronizing_word_register (const signature &sig, synchronizing_word_t fn)
 
word vcsn::dyn::synchronizing_word (const automaton &aut, const std::string &algo="greedy")
 A synchronizing word, or raise if there is none. More...
 
static Registry< thompson_t > & vcsn::dyn::detail::thompson_registry ()
 
bool vcsn::dyn::detail::thompson_register (const signature &sig, thompson_t fn)
 
automaton vcsn::dyn::thompson (const expression &e)
 The Thompson automaton of e. More...
 
static Registry< to_expansion_t > & vcsn::dyn::detail::to_expansion_registry ()
 
bool vcsn::dyn::detail::to_expansion_register (const signature &sig, to_expansion_t fn)
 
expansion vcsn::dyn::to_expansion (const expression &exp)
 First order development of a exp. More...
 
static Registry
< to_expression_t > & 
vcsn::dyn::detail::to_expression_registry ()
 
bool vcsn::dyn::detail::to_expression_register (const signature &sig, to_expression_t fn)
 
expression vcsn::dyn::to_expression (const automaton &aut, identities ids={}, const std::string &algo="auto")
 An expression denoting the language of aut. More...
 
static Registry
< to_expression_class_t > & 
vcsn::dyn::detail::to_expression_class_registry ()
 
bool vcsn::dyn::detail::to_expression_class_register (const signature &sig, to_expression_class_t fn)
 
expression vcsn::dyn::to_expression (const context &ctx, identities ids, const letter_class_t &letters, bool accept=true)
 An expression matching one letter in a letter class. More...
 
static Registry
< to_expression_label_t > & 
vcsn::dyn::detail::to_expression_label_registry ()
 
bool vcsn::dyn::detail::to_expression_label_register (const signature &sig, to_expression_label_t fn)
 
expression vcsn::dyn::to_expression (const context &ctx, identities ids, const label &l)
 An expression denoting the label of l. More...
 
static Registry< transpose_t > & vcsn::dyn::detail::transpose_registry ()
 
bool vcsn::dyn::detail::transpose_register (const signature &sig, transpose_t fn)
 
automaton vcsn::dyn::transpose (automaton &aut)
 Transpose aut. More...
 
static Registry
< transpose_expression_t > & 
vcsn::dyn::detail::transpose_expression_registry ()
 
bool vcsn::dyn::detail::transpose_expression_register (const signature &sig, transpose_expression_t fn)
 
expression vcsn::dyn::transpose (const expression &e)
 Transpose e. More...
 
static Registry
< transposition_expression_t > & 
vcsn::dyn::detail::transposition_expression_registry ()
 
bool vcsn::dyn::detail::transposition_expression_register (const signature &sig, transposition_expression_t fn)
 
expression vcsn::dyn::transposition (const expression &r)
 Add the transposition operator to r. More...
 
static Registry< trie_t > & vcsn::dyn::detail::trie_registry ()
 
bool vcsn::dyn::detail::trie_register (const signature &sig, trie_t fn)
 
automaton vcsn::dyn::trie (const polynomial &p)
 A trie-like automaton (single initial state, multiple final states) to accept p. More...
 
static Registry< trie_stream_t > & vcsn::dyn::detail::trie_stream_registry ()
 
bool vcsn::dyn::detail::trie_stream_register (const signature &sig, trie_stream_t fn)
 
automaton vcsn::dyn::trie (const context &ctx, std::istream &is, const std::string &format="default")
 A trie-like automaton (single initial state, multiple final states) to accept the series contained in is. More...
 
static Registry< trim_t > & vcsn::dyn::detail::trim_registry ()
 
bool vcsn::dyn::detail::trim_register (const signature &sig, trim_t fn)
 
automaton vcsn::dyn::trim (const automaton &aut)
 The trim subautomaton of aut. More...
 
static Registry< tuple_t > & vcsn::dyn::detail::tuple_registry ()
 
bool vcsn::dyn::detail::tuple_register (const signature &sig, tuple_t fn)
 
automaton vcsn::dyn::tuple (const std::vector< automaton > &as)
 Build a k-tape automaton from k automata. More...
 
static Registry
< tuple_context_t > & 
vcsn::dyn::detail::tuple_context_registry ()
 
bool vcsn::dyn::detail::tuple_context_register (const signature &sig, tuple_context_t fn)
 
context vcsn::dyn::tuple (const std::vector< context > &ctxs)
 A k-tape context from k contexts. More...
 
static Registry
< tuple_expansion_t > & 
vcsn::dyn::detail::tuple_expansion_registry ()
 
bool vcsn::dyn::detail::tuple_expansion_register (const signature &sig, tuple_expansion_t fn)
 
expansion vcsn::dyn::tuple (const std::vector< expansion > &rs)
 Build a k-tape expansion from k expansions. More...
 
static Registry
< tuple_expression_t > & 
vcsn::dyn::detail::tuple_expression_registry ()
 
bool vcsn::dyn::detail::tuple_expression_register (const signature &sig, tuple_expression_t fn)
 
static Registry
< tuple_polynomial_t > & 
vcsn::dyn::detail::tuple_polynomial_registry ()
 
bool vcsn::dyn::detail::tuple_polynomial_register (const signature &sig, tuple_polynomial_t fn)
 
static Registry< u_t > & vcsn::dyn::detail::u_registry ()
 
bool vcsn::dyn::detail::u_register (const signature &sig, u_t fn)
 
automaton vcsn::dyn::u (const context &ctx, unsigned n)
 The Brzozowski universal witness. More...
 
static Registry< universal_t > & vcsn::dyn::detail::universal_registry ()
 
bool vcsn::dyn::detail::universal_register (const signature &sig, universal_t fn)
 
automaton vcsn::dyn::universal (const automaton &aut)
 The universal automaton of aut. More...
 
static Registry< weight_one_t > & vcsn::dyn::detail::weight_one_registry ()
 
bool vcsn::dyn::detail::weight_one_register (const signature &sig, weight_one_t fn)
 
weight vcsn::dyn::weight_one (const context &c)
 The weight one. More...
 
static Registry
< weight_series_t > & 
vcsn::dyn::detail::weight_series_registry ()
 
bool vcsn::dyn::detail::weight_series_register (const signature &sig, weight_series_t fn)
 
weight vcsn::dyn::weight_series (const automaton &aut)
 Compute weight of the series. More...
 
static Registry< weight_zero_t > & vcsn::dyn::detail::weight_zero_registry ()
 
bool vcsn::dyn::detail::weight_zero_register (const signature &sig, weight_zero_t fn)
 
weight vcsn::dyn::weight_zero (const context &c)
 The weight zero. More...
 
static Registry< zpc_t > & vcsn::dyn::detail::zpc_registry ()
 
bool vcsn::dyn::detail::zpc_register (const signature &sig, zpc_t fn)
 
automaton vcsn::dyn::zpc (const expression &exp, const std::string &algo="auto")
 The ZPC automaton of exp. More...